Update the statfs structure with 64-bit fields to allow
accurate reporting of multi-terabyte filesystem sizes. You should build and boot a new kernel BEFORE doing a `make world' as the new kernel will know about binaries using the old statfs structure, but an old kernel will not know about the new system calls that support the new statfs structure. Running an old kernel after a `make world' will cause programs such as `df' that do a statfs system call to fail with a bad system call. Reviewed by: Bruce Evans <bde@zeta.org.au> Reviewed by: Tim Robbins <tjr@freebsd.org> Reviewed by: Julian Elischer <julian@elischer.org> Reviewed by: the hoards of <arch@freebsd.org> Sponsored by: DARPA & NAI Labs.
This commit is contained in:
parent
a61575cf29
commit
fde81c7d8e
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=122537
48
bin/df/df.c
48
bin/df/df.c
@ -120,9 +120,9 @@ typedef enum { NONE, KILO, MEGA, GIGA, TERA, PETA, UNIT_MAX } unit_t;
|
||||
static unit_t unitp [] = { NONE, KILO, MEGA, GIGA, TERA, PETA };
|
||||
|
||||
static char *getmntpt(const char *);
|
||||
static size_t longwidth(long);
|
||||
static size_t int64width(int64_t);
|
||||
static char *makenetvfslist(void);
|
||||
static void prthuman(const struct statfs *, size_t);
|
||||
static void prthuman(const struct statfs *, int64_t);
|
||||
static void prthumanval(double);
|
||||
static void prtstat(struct statfs *, struct maxwidths *);
|
||||
static size_t regetmntinfo(struct statfs **, long, const char **);
|
||||
@ -371,7 +371,7 @@ unit_adjust(double *val)
|
||||
}
|
||||
|
||||
static void
|
||||
prthuman(const struct statfs *sfsp, size_t used)
|
||||
prthuman(const struct statfs *sfsp, int64_t used)
|
||||
{
|
||||
|
||||
prthumanval((double)sfsp->f_blocks * (double)sfsp->f_bsize);
|
||||
@ -408,10 +408,10 @@ prthumanval(double bytes)
|
||||
static void
|
||||
prtstat(struct statfs *sfsp, struct maxwidths *mwp)
|
||||
{
|
||||
static long blocksize;
|
||||
static u_long blocksize;
|
||||
static int headerlen, timesthrough = 0;
|
||||
static const char *header;
|
||||
size_t used, availblks, inodes;
|
||||
int64_t used, availblks, inodes;
|
||||
|
||||
if (++timesthrough == 1) {
|
||||
mwp->mntfrom = max(mwp->mntfrom, strlen("Filesystem"));
|
||||
@ -445,21 +445,23 @@ prtstat(struct statfs *sfsp, struct maxwidths *mwp)
|
||||
if (hflag) {
|
||||
prthuman(sfsp, used);
|
||||
} else {
|
||||
(void)printf(" %*ld %*ld %*ld",
|
||||
(u_int)mwp->total, fsbtoblk(sfsp->f_blocks, sfsp->f_bsize, blocksize),
|
||||
(u_int)mwp->used, fsbtoblk(used, sfsp->f_bsize, blocksize),
|
||||
(u_int)mwp->avail, fsbtoblk(sfsp->f_bavail, sfsp->f_bsize,
|
||||
blocksize));
|
||||
(void)printf(" %*qd %*qd %*qd",
|
||||
(u_int)mwp->total,
|
||||
(intmax_t)fsbtoblk(sfsp->f_blocks, sfsp->f_bsize, blocksize),
|
||||
(u_int)mwp->used,
|
||||
(intmax_t)fsbtoblk(used, sfsp->f_bsize, blocksize),
|
||||
(u_int)mwp->avail,
|
||||
(intmax_t)fsbtoblk(sfsp->f_bavail, sfsp->f_bsize, blocksize));
|
||||
}
|
||||
(void)printf(" %5.0f%%",
|
||||
availblks == 0 ? 100.0 : (double)used / (double)availblks * 100.0);
|
||||
if (iflag) {
|
||||
inodes = sfsp->f_files;
|
||||
used = inodes - sfsp->f_ffree;
|
||||
(void)printf(" %*lu %*lu %4.0f%% ",
|
||||
(u_int)mwp->iused, (u_long)used,
|
||||
(u_int)mwp->ifree, sfsp->f_ffree,
|
||||
inodes == 0 ? 100.0 : (double)used / (double)inodes * 100.0);
|
||||
(void)printf(" %*qd %*qd %4.0f%% ",
|
||||
(u_int)mwp->iused, (intmax_t)used,
|
||||
(u_int)mwp->ifree, (intmax_t)sfsp->f_ffree,
|
||||
inodes == 0 ? 100.0 : (double)used / (double)inodes * 100.0);
|
||||
} else
|
||||
(void)printf(" ");
|
||||
(void)printf(" %s\n", sfsp->f_mntonname);
|
||||
@ -472,27 +474,27 @@ prtstat(struct statfs *sfsp, struct maxwidths *mwp)
|
||||
static void
|
||||
update_maxwidths(struct maxwidths *mwp, const struct statfs *sfsp)
|
||||
{
|
||||
static long blocksize = 0;
|
||||
static u_long blocksize = 0;
|
||||
int dummy;
|
||||
|
||||
if (blocksize == 0)
|
||||
getbsize(&dummy, &blocksize);
|
||||
|
||||
mwp->mntfrom = max(mwp->mntfrom, strlen(sfsp->f_mntfromname));
|
||||
mwp->total = max(mwp->total, longwidth(fsbtoblk(sfsp->f_blocks,
|
||||
mwp->total = max(mwp->total, int64width(
|
||||
fsbtoblk((int64_t)sfsp->f_blocks, sfsp->f_bsize, blocksize)));
|
||||
mwp->used = max(mwp->used, int64width(fsbtoblk((int64_t)sfsp->f_blocks -
|
||||
(int64_t)sfsp->f_bfree, sfsp->f_bsize, blocksize)));
|
||||
mwp->avail = max(mwp->avail, int64width(fsbtoblk(sfsp->f_bavail,
|
||||
sfsp->f_bsize, blocksize)));
|
||||
mwp->used = max(mwp->used, longwidth(fsbtoblk(sfsp->f_blocks -
|
||||
sfsp->f_bfree, sfsp->f_bsize, blocksize)));
|
||||
mwp->avail = max(mwp->avail, longwidth(fsbtoblk(sfsp->f_bavail,
|
||||
sfsp->f_bsize, blocksize)));
|
||||
mwp->iused = max(mwp->iused, longwidth(sfsp->f_files -
|
||||
mwp->iused = max(mwp->iused, int64width((int64_t)sfsp->f_files -
|
||||
sfsp->f_ffree));
|
||||
mwp->ifree = max(mwp->ifree, longwidth(sfsp->f_ffree));
|
||||
mwp->ifree = max(mwp->ifree, int64width(sfsp->f_ffree));
|
||||
}
|
||||
|
||||
/* Return the width in characters of the specified long. */
|
||||
static size_t
|
||||
longwidth(long val)
|
||||
int64width(int64_t val)
|
||||
{
|
||||
size_t len;
|
||||
|
||||
|
@ -68,7 +68,7 @@
|
||||
15 STD POSIX { int chmod(char *path, int mode); }
|
||||
16 STD POSIX { int chown(char *path, int uid, int gid); }
|
||||
17 MSTD BSD { int obreak(char *nsize); } break obreak_args int
|
||||
18 STD BSD { int getfsstat(struct statfs *buf, long bufsize, \
|
||||
18 COMPAT4 BSD { int getfsstat(struct ostatfs *buf, long bufsize, \
|
||||
int flags); }
|
||||
19 COMPAT POSIX { long lseek(int fd, long offset, int whence); }
|
||||
20 MSTD POSIX { pid_t getpid(void); }
|
||||
@ -252,8 +252,8 @@
|
||||
155 MNOIMPL BSD { int nfssvc(int flag, caddr_t argp); }
|
||||
156 COMPAT BSD { int getdirentries(int fd, char *buf, u_int count, \
|
||||
long *basep); }
|
||||
157 STD BSD { int statfs(char *path, struct statfs *buf); }
|
||||
158 STD BSD { int fstatfs(int fd, struct statfs *buf); }
|
||||
157 COMPAT4 BSD { int statfs(char *path, struct ostatfs *buf); }
|
||||
158 COMPAT4 BSD { int fstatfs(int fd, struct ostatfs *buf); }
|
||||
159 UNIMPL NOHIDE nosys
|
||||
160 UNIMPL NOHIDE nosys
|
||||
161 STD BSD { int getfh(char *fname, struct fhandle *fhp); }
|
||||
@ -439,7 +439,7 @@
|
||||
295 UNIMPL NOHIDE nosys
|
||||
296 UNIMPL NOHIDE nosys
|
||||
; XXX 297 is 300 in NetBSD
|
||||
297 STD BSD { int fhstatfs(const struct fhandle *u_fhp, struct statfs *buf); }
|
||||
297 COMPAT4 BSD { int fhstatfs(const struct fhandle *u_fhp, struct ostatfs *buf); }
|
||||
298 STD BSD { int fhopen(const struct fhandle *u_fhp, int flags); }
|
||||
299 STD BSD { int fhstat(const struct fhandle *u_fhp, struct stat *sb); }
|
||||
; syscall numbers for FreeBSD
|
||||
@ -574,10 +574,12 @@
|
||||
struct sf_hdtr *hdtr, off_t *sbytes, int flags); }
|
||||
394 MSTD BSD { int mac_syscall(const char *policy, int call, \
|
||||
void *arg); }
|
||||
395 UNIMPL NOHIDE nosys
|
||||
396 UNIMPL NOHIDE nosys
|
||||
397 UNIMPL NOHIDE nosys
|
||||
398 UNIMPL NOHIDE nosys
|
||||
395 STD BSD { int getfsstat(struct statfs *buf, long bufsize, \
|
||||
int flags); }
|
||||
396 STD BSD { int statfs(char *path, struct statfs *buf); }
|
||||
397 STD BSD { int fstatfs(int fd, struct statfs *buf); }
|
||||
398 STD BSD { int fhstatfs(const struct fhandle *u_fhp, \
|
||||
struct statfs *buf); }
|
||||
399 UNIMPL NOHIDE nosys
|
||||
400 MNOSTD BSD { int ksem_close(semid_t id); }
|
||||
401 MNOSTD BSD { int ksem_post(semid_t id); }
|
||||
|
@ -3236,8 +3236,8 @@ bufdone(struct buf *bp)
|
||||
(int) m->pindex, (int)(foff >> 32),
|
||||
(int) foff & 0xffffffff, resid, i);
|
||||
if (!vn_isdisk(vp, NULL))
|
||||
printf(" iosize: %ld, lblkno: %jd, flags: 0x%x, npages: %d\n",
|
||||
bp->b_vp->v_mount->mnt_stat.f_iosize,
|
||||
printf(" iosize: %jd, lblkno: %jd, flags: 0x%x, npages: %d\n",
|
||||
(intmax_t)bp->b_vp->v_mount->mnt_stat.f_iosize,
|
||||
(intmax_t) bp->b_lblkno,
|
||||
bp->b_flags, bp->b_npages);
|
||||
else
|
||||
|
@ -327,8 +327,8 @@ cluster_rbuild(vp, filesize, lbn, blkno, size, run, fbp)
|
||||
GIANT_REQUIRED;
|
||||
|
||||
KASSERT(size == vp->v_mount->mnt_stat.f_iosize,
|
||||
("cluster_rbuild: size %ld != filesize %ld\n",
|
||||
size, vp->v_mount->mnt_stat.f_iosize));
|
||||
("cluster_rbuild: size %ld != filesize %jd\n",
|
||||
size, (intmax_t)vp->v_mount->mnt_stat.f_iosize));
|
||||
|
||||
/*
|
||||
* avoid a division
|
||||
|
@ -226,11 +226,10 @@ statfs(td, uap)
|
||||
struct statfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
register struct mount *mp;
|
||||
register struct statfs *sp;
|
||||
struct mount *mp;
|
||||
struct statfs *sp, sb;
|
||||
int error;
|
||||
struct nameidata nd;
|
||||
struct statfs sb;
|
||||
|
||||
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
|
||||
if ((error = namei(&nd)) != 0)
|
||||
@ -244,10 +243,15 @@ statfs(td, uap)
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
/*
|
||||
* Set these in case the underlying filesystem fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
@ -276,9 +280,8 @@ fstatfs(td, uap)
|
||||
{
|
||||
struct file *fp;
|
||||
struct mount *mp;
|
||||
register struct statfs *sp;
|
||||
struct statfs *sp, sb;
|
||||
int error;
|
||||
struct statfs sb;
|
||||
|
||||
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
||||
return (error);
|
||||
@ -292,10 +295,15 @@ fstatfs(td, uap)
|
||||
return (error);
|
||||
#endif
|
||||
sp = &mp->mnt_stat;
|
||||
/*
|
||||
* Set these in case the underlying filesystem fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
@ -323,8 +331,8 @@ getfsstat(td, uap)
|
||||
int flags;
|
||||
} */ *uap;
|
||||
{
|
||||
register struct mount *mp, *nmp;
|
||||
register struct statfs *sp;
|
||||
struct mount *mp, *nmp;
|
||||
struct statfs *sp, sb;
|
||||
caddr_t sfsp;
|
||||
long count, maxcount, error;
|
||||
|
||||
@ -338,6 +346,184 @@ getfsstat(td, uap)
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
continue;
|
||||
}
|
||||
if (sfsp && count < maxcount) {
|
||||
sp = &mp->mnt_stat;
|
||||
/*
|
||||
* Set these in case the underlying filesystem
|
||||
* fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
/*
|
||||
* If MNT_NOWAIT or MNT_LAZY is specified, do not
|
||||
* refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
|
||||
* overrides MNT_WAIT.
|
||||
*/
|
||||
if (((uap->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
|
||||
(uap->flags & MNT_WAIT)) &&
|
||||
(error = VFS_STATFS(mp, sp, td))) {
|
||||
mtx_lock(&mountlist_mtx);
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
vfs_unbusy(mp, td);
|
||||
continue;
|
||||
}
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
sp = &sb;
|
||||
}
|
||||
error = copyout(sp, sfsp, sizeof(*sp));
|
||||
if (error) {
|
||||
vfs_unbusy(mp, td);
|
||||
return (error);
|
||||
}
|
||||
sfsp += sizeof(*sp);
|
||||
}
|
||||
count++;
|
||||
mtx_lock(&mountlist_mtx);
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
vfs_unbusy(mp, td);
|
||||
}
|
||||
mtx_unlock(&mountlist_mtx);
|
||||
if (sfsp && count > maxcount)
|
||||
td->td_retval[0] = maxcount;
|
||||
else
|
||||
td->td_retval[0] = count;
|
||||
return (0);
|
||||
}
|
||||
|
||||
#ifdef COMPAT_FREEBSD4
|
||||
/*
|
||||
* Get old format filesystem statistics.
|
||||
*/
|
||||
static void cvtstatfs(struct thread *, struct statfs *, struct ostatfs *);
|
||||
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_statfs_args {
|
||||
char *path;
|
||||
struct ostatfs *buf;
|
||||
};
|
||||
#endif
|
||||
/* ARGSUSED */
|
||||
int
|
||||
freebsd4_statfs(td, uap)
|
||||
struct thread *td;
|
||||
struct freebsd4_statfs_args /* {
|
||||
char *path;
|
||||
struct ostatfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct mount *mp;
|
||||
struct statfs *sp;
|
||||
struct ostatfs osb;
|
||||
int error;
|
||||
struct nameidata nd;
|
||||
|
||||
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
|
||||
if ((error = namei(&nd)) != 0)
|
||||
return (error);
|
||||
mp = nd.ni_vp->v_mount;
|
||||
sp = &mp->mnt_stat;
|
||||
NDFREE(&nd, NDF_ONLY_PNBUF);
|
||||
vrele(nd.ni_vp);
|
||||
#ifdef MAC
|
||||
error = mac_check_mount_stat(td->td_ucred, mp);
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
cvtstatfs(td, sp, &osb);
|
||||
return (copyout(&osb, uap->buf, sizeof(osb)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Get filesystem statistics.
|
||||
*/
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_fstatfs_args {
|
||||
int fd;
|
||||
struct ostatfs *buf;
|
||||
};
|
||||
#endif
|
||||
/* ARGSUSED */
|
||||
int
|
||||
freebsd4_fstatfs(td, uap)
|
||||
struct thread *td;
|
||||
struct freebsd4_fstatfs_args /* {
|
||||
int fd;
|
||||
struct ostatfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct file *fp;
|
||||
struct mount *mp;
|
||||
struct statfs *sp;
|
||||
struct ostatfs osb;
|
||||
int error;
|
||||
|
||||
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
||||
return (error);
|
||||
mp = fp->f_vnode->v_mount;
|
||||
fdrop(fp, td);
|
||||
if (mp == NULL)
|
||||
return (EBADF);
|
||||
#ifdef MAC
|
||||
error = mac_check_mount_stat(td->td_ucred, mp);
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
sp = &mp->mnt_stat;
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
cvtstatfs(td, sp, &osb);
|
||||
return (copyout(&osb, uap->buf, sizeof(osb)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Get statistics on all filesystems.
|
||||
*/
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_getfsstat_args {
|
||||
struct ostatfs *buf;
|
||||
long bufsize;
|
||||
int flags;
|
||||
};
|
||||
#endif
|
||||
int
|
||||
freebsd4_getfsstat(td, uap)
|
||||
struct thread *td;
|
||||
register struct freebsd4_getfsstat_args /* {
|
||||
struct ostatfs *buf;
|
||||
long bufsize;
|
||||
int flags;
|
||||
} */ *uap;
|
||||
{
|
||||
struct mount *mp, *nmp;
|
||||
struct statfs *sp;
|
||||
struct ostatfs osb;
|
||||
caddr_t sfsp;
|
||||
long count, maxcount, error;
|
||||
|
||||
maxcount = uap->bufsize / sizeof(struct ostatfs);
|
||||
sfsp = (caddr_t)uap->buf;
|
||||
count = 0;
|
||||
mtx_lock(&mountlist_mtx);
|
||||
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
||||
#ifdef MAC
|
||||
if (mac_check_mount_stat(td->td_ucred, mp) != 0) {
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
@ -359,12 +545,13 @@ getfsstat(td, uap)
|
||||
continue;
|
||||
}
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
error = copyout(sp, sfsp, sizeof(*sp));
|
||||
cvtstatfs(td, sp, &osb);
|
||||
error = copyout(&osb, sfsp, sizeof(osb));
|
||||
if (error) {
|
||||
vfs_unbusy(mp, td);
|
||||
return (error);
|
||||
}
|
||||
sfsp += sizeof(*sp);
|
||||
sfsp += sizeof(osb);
|
||||
}
|
||||
count++;
|
||||
mtx_lock(&mountlist_mtx);
|
||||
@ -379,6 +566,98 @@ getfsstat(td, uap)
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Implement fstatfs() for (NFS) file handles.
|
||||
*/
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_fhstatfs_args {
|
||||
struct fhandle *u_fhp;
|
||||
struct ostatfs *buf;
|
||||
};
|
||||
#endif
|
||||
int
|
||||
freebsd4_fhstatfs(td, uap)
|
||||
struct thread *td;
|
||||
struct freebsd4_fhstatfs_args /* {
|
||||
struct fhandle *u_fhp;
|
||||
struct ostatfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct statfs *sp;
|
||||
struct mount *mp;
|
||||
struct vnode *vp;
|
||||
struct ostatfs osb;
|
||||
fhandle_t fh;
|
||||
int error;
|
||||
|
||||
/*
|
||||
* Must be super user
|
||||
*/
|
||||
error = suser(td);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
|
||||
return (error);
|
||||
|
||||
if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
|
||||
return (ESTALE);
|
||||
if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)))
|
||||
return (error);
|
||||
mp = vp->v_mount;
|
||||
sp = &mp->mnt_stat;
|
||||
vput(vp);
|
||||
#ifdef MAC
|
||||
error = mac_check_mount_stat(td->td_ucred, mp);
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
if ((error = VFS_STATFS(mp, sp, td)) != 0)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
cvtstatfs(td, sp, &osb);
|
||||
return (copyout(&osb, uap->buf, sizeof(osb)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a new format statfs structure to an old format statfs structure.
|
||||
*/
|
||||
static void
|
||||
cvtstatfs(td, nsp, osp)
|
||||
struct thread *td;
|
||||
struct statfs *nsp;
|
||||
struct ostatfs *osp;
|
||||
{
|
||||
|
||||
bzero(osp, sizeof(*osp));
|
||||
osp->f_bsize = MIN(nsp->f_bsize, LONG_MAX);
|
||||
osp->f_iosize = MIN(nsp->f_iosize, LONG_MAX);
|
||||
osp->f_blocks = MIN(nsp->f_blocks, LONG_MAX);
|
||||
osp->f_bfree = MIN(nsp->f_bfree, LONG_MAX);
|
||||
osp->f_bavail = MIN(nsp->f_bavail, LONG_MAX);
|
||||
osp->f_files = MIN(nsp->f_files, LONG_MAX);
|
||||
osp->f_ffree = MIN(nsp->f_ffree, LONG_MAX);
|
||||
osp->f_owner = nsp->f_owner;
|
||||
osp->f_type = nsp->f_type;
|
||||
osp->f_flags = nsp->f_flags;
|
||||
osp->f_syncwrites = MIN(nsp->f_syncwrites, LONG_MAX);
|
||||
osp->f_asyncwrites = MIN(nsp->f_asyncwrites, LONG_MAX);
|
||||
osp->f_syncreads = MIN(nsp->f_syncreads, LONG_MAX);
|
||||
osp->f_asyncreads = MIN(nsp->f_asyncreads, LONG_MAX);
|
||||
bcopy(nsp->f_fstypename, osp->f_fstypename,
|
||||
MIN(MFSNAMELEN, OMNAMELEN));
|
||||
bcopy(nsp->f_mntonname, osp->f_mntonname,
|
||||
MIN(MFSNAMELEN, OMNAMELEN));
|
||||
bcopy(nsp->f_mntfromname, osp->f_mntfromname,
|
||||
MIN(MFSNAMELEN, OMNAMELEN));
|
||||
if (suser(td)) {
|
||||
osp->f_fsid.val[0] = osp->f_fsid.val[1] = 0;
|
||||
} else {
|
||||
osp->f_fsid = nsp->f_fsid;
|
||||
}
|
||||
}
|
||||
#endif /* COMPAT_FREEBSD4 */
|
||||
|
||||
/*
|
||||
* Change current working directory to a given file descriptor.
|
||||
*/
|
||||
@ -3788,10 +4067,9 @@ fhstatfs(td, uap)
|
||||
struct statfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct statfs *sp;
|
||||
struct statfs *sp, sb;
|
||||
struct mount *mp;
|
||||
struct vnode *vp;
|
||||
struct statfs sb;
|
||||
fhandle_t fh;
|
||||
int error;
|
||||
|
||||
@ -3817,9 +4095,14 @@ fhstatfs(td, uap)
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
/*
|
||||
* Set these in case the underlying filesystem fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if ((error = VFS_STATFS(mp, sp, td)) != 0)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
|
@ -226,11 +226,10 @@ statfs(td, uap)
|
||||
struct statfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
register struct mount *mp;
|
||||
register struct statfs *sp;
|
||||
struct mount *mp;
|
||||
struct statfs *sp, sb;
|
||||
int error;
|
||||
struct nameidata nd;
|
||||
struct statfs sb;
|
||||
|
||||
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
|
||||
if ((error = namei(&nd)) != 0)
|
||||
@ -244,10 +243,15 @@ statfs(td, uap)
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
/*
|
||||
* Set these in case the underlying filesystem fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
@ -276,9 +280,8 @@ fstatfs(td, uap)
|
||||
{
|
||||
struct file *fp;
|
||||
struct mount *mp;
|
||||
register struct statfs *sp;
|
||||
struct statfs *sp, sb;
|
||||
int error;
|
||||
struct statfs sb;
|
||||
|
||||
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
||||
return (error);
|
||||
@ -292,10 +295,15 @@ fstatfs(td, uap)
|
||||
return (error);
|
||||
#endif
|
||||
sp = &mp->mnt_stat;
|
||||
/*
|
||||
* Set these in case the underlying filesystem fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
@ -323,8 +331,8 @@ getfsstat(td, uap)
|
||||
int flags;
|
||||
} */ *uap;
|
||||
{
|
||||
register struct mount *mp, *nmp;
|
||||
register struct statfs *sp;
|
||||
struct mount *mp, *nmp;
|
||||
struct statfs *sp, sb;
|
||||
caddr_t sfsp;
|
||||
long count, maxcount, error;
|
||||
|
||||
@ -338,6 +346,184 @@ getfsstat(td, uap)
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
continue;
|
||||
}
|
||||
if (sfsp && count < maxcount) {
|
||||
sp = &mp->mnt_stat;
|
||||
/*
|
||||
* Set these in case the underlying filesystem
|
||||
* fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
/*
|
||||
* If MNT_NOWAIT or MNT_LAZY is specified, do not
|
||||
* refresh the fsstat cache. MNT_NOWAIT or MNT_LAZY
|
||||
* overrides MNT_WAIT.
|
||||
*/
|
||||
if (((uap->flags & (MNT_LAZY|MNT_NOWAIT)) == 0 ||
|
||||
(uap->flags & MNT_WAIT)) &&
|
||||
(error = VFS_STATFS(mp, sp, td))) {
|
||||
mtx_lock(&mountlist_mtx);
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
vfs_unbusy(mp, td);
|
||||
continue;
|
||||
}
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
sp = &sb;
|
||||
}
|
||||
error = copyout(sp, sfsp, sizeof(*sp));
|
||||
if (error) {
|
||||
vfs_unbusy(mp, td);
|
||||
return (error);
|
||||
}
|
||||
sfsp += sizeof(*sp);
|
||||
}
|
||||
count++;
|
||||
mtx_lock(&mountlist_mtx);
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
vfs_unbusy(mp, td);
|
||||
}
|
||||
mtx_unlock(&mountlist_mtx);
|
||||
if (sfsp && count > maxcount)
|
||||
td->td_retval[0] = maxcount;
|
||||
else
|
||||
td->td_retval[0] = count;
|
||||
return (0);
|
||||
}
|
||||
|
||||
#ifdef COMPAT_FREEBSD4
|
||||
/*
|
||||
* Get old format filesystem statistics.
|
||||
*/
|
||||
static void cvtstatfs(struct thread *, struct statfs *, struct ostatfs *);
|
||||
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_statfs_args {
|
||||
char *path;
|
||||
struct ostatfs *buf;
|
||||
};
|
||||
#endif
|
||||
/* ARGSUSED */
|
||||
int
|
||||
freebsd4_statfs(td, uap)
|
||||
struct thread *td;
|
||||
struct freebsd4_statfs_args /* {
|
||||
char *path;
|
||||
struct ostatfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct mount *mp;
|
||||
struct statfs *sp;
|
||||
struct ostatfs osb;
|
||||
int error;
|
||||
struct nameidata nd;
|
||||
|
||||
NDINIT(&nd, LOOKUP, FOLLOW, UIO_USERSPACE, uap->path, td);
|
||||
if ((error = namei(&nd)) != 0)
|
||||
return (error);
|
||||
mp = nd.ni_vp->v_mount;
|
||||
sp = &mp->mnt_stat;
|
||||
NDFREE(&nd, NDF_ONLY_PNBUF);
|
||||
vrele(nd.ni_vp);
|
||||
#ifdef MAC
|
||||
error = mac_check_mount_stat(td->td_ucred, mp);
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
cvtstatfs(td, sp, &osb);
|
||||
return (copyout(&osb, uap->buf, sizeof(osb)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Get filesystem statistics.
|
||||
*/
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_fstatfs_args {
|
||||
int fd;
|
||||
struct ostatfs *buf;
|
||||
};
|
||||
#endif
|
||||
/* ARGSUSED */
|
||||
int
|
||||
freebsd4_fstatfs(td, uap)
|
||||
struct thread *td;
|
||||
struct freebsd4_fstatfs_args /* {
|
||||
int fd;
|
||||
struct ostatfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct file *fp;
|
||||
struct mount *mp;
|
||||
struct statfs *sp;
|
||||
struct ostatfs osb;
|
||||
int error;
|
||||
|
||||
if ((error = getvnode(td->td_proc->p_fd, uap->fd, &fp)) != 0)
|
||||
return (error);
|
||||
mp = fp->f_vnode->v_mount;
|
||||
fdrop(fp, td);
|
||||
if (mp == NULL)
|
||||
return (EBADF);
|
||||
#ifdef MAC
|
||||
error = mac_check_mount_stat(td->td_ucred, mp);
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
sp = &mp->mnt_stat;
|
||||
error = VFS_STATFS(mp, sp, td);
|
||||
if (error)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
cvtstatfs(td, sp, &osb);
|
||||
return (copyout(&osb, uap->buf, sizeof(osb)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Get statistics on all filesystems.
|
||||
*/
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_getfsstat_args {
|
||||
struct ostatfs *buf;
|
||||
long bufsize;
|
||||
int flags;
|
||||
};
|
||||
#endif
|
||||
int
|
||||
freebsd4_getfsstat(td, uap)
|
||||
struct thread *td;
|
||||
register struct freebsd4_getfsstat_args /* {
|
||||
struct ostatfs *buf;
|
||||
long bufsize;
|
||||
int flags;
|
||||
} */ *uap;
|
||||
{
|
||||
struct mount *mp, *nmp;
|
||||
struct statfs *sp;
|
||||
struct ostatfs osb;
|
||||
caddr_t sfsp;
|
||||
long count, maxcount, error;
|
||||
|
||||
maxcount = uap->bufsize / sizeof(struct ostatfs);
|
||||
sfsp = (caddr_t)uap->buf;
|
||||
count = 0;
|
||||
mtx_lock(&mountlist_mtx);
|
||||
for (mp = TAILQ_FIRST(&mountlist); mp != NULL; mp = nmp) {
|
||||
#ifdef MAC
|
||||
if (mac_check_mount_stat(td->td_ucred, mp) != 0) {
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
continue;
|
||||
}
|
||||
#endif
|
||||
if (vfs_busy(mp, LK_NOWAIT, &mountlist_mtx, td)) {
|
||||
nmp = TAILQ_NEXT(mp, mnt_list);
|
||||
@ -359,12 +545,13 @@ getfsstat(td, uap)
|
||||
continue;
|
||||
}
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
error = copyout(sp, sfsp, sizeof(*sp));
|
||||
cvtstatfs(td, sp, &osb);
|
||||
error = copyout(&osb, sfsp, sizeof(osb));
|
||||
if (error) {
|
||||
vfs_unbusy(mp, td);
|
||||
return (error);
|
||||
}
|
||||
sfsp += sizeof(*sp);
|
||||
sfsp += sizeof(osb);
|
||||
}
|
||||
count++;
|
||||
mtx_lock(&mountlist_mtx);
|
||||
@ -379,6 +566,98 @@ getfsstat(td, uap)
|
||||
return (0);
|
||||
}
|
||||
|
||||
/*
|
||||
* Implement fstatfs() for (NFS) file handles.
|
||||
*/
|
||||
#ifndef _SYS_SYSPROTO_H_
|
||||
struct freebsd4_fhstatfs_args {
|
||||
struct fhandle *u_fhp;
|
||||
struct ostatfs *buf;
|
||||
};
|
||||
#endif
|
||||
int
|
||||
freebsd4_fhstatfs(td, uap)
|
||||
struct thread *td;
|
||||
struct freebsd4_fhstatfs_args /* {
|
||||
struct fhandle *u_fhp;
|
||||
struct ostatfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct statfs *sp;
|
||||
struct mount *mp;
|
||||
struct vnode *vp;
|
||||
struct ostatfs osb;
|
||||
fhandle_t fh;
|
||||
int error;
|
||||
|
||||
/*
|
||||
* Must be super user
|
||||
*/
|
||||
error = suser(td);
|
||||
if (error)
|
||||
return (error);
|
||||
|
||||
if ((error = copyin(uap->u_fhp, &fh, sizeof(fhandle_t))) != 0)
|
||||
return (error);
|
||||
|
||||
if ((mp = vfs_getvfs(&fh.fh_fsid)) == NULL)
|
||||
return (ESTALE);
|
||||
if ((error = VFS_FHTOVP(mp, &fh.fh_fid, &vp)))
|
||||
return (error);
|
||||
mp = vp->v_mount;
|
||||
sp = &mp->mnt_stat;
|
||||
vput(vp);
|
||||
#ifdef MAC
|
||||
error = mac_check_mount_stat(td->td_ucred, mp);
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
if ((error = VFS_STATFS(mp, sp, td)) != 0)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
cvtstatfs(td, sp, &osb);
|
||||
return (copyout(&osb, uap->buf, sizeof(osb)));
|
||||
}
|
||||
|
||||
/*
|
||||
* Convert a new format statfs structure to an old format statfs structure.
|
||||
*/
|
||||
static void
|
||||
cvtstatfs(td, nsp, osp)
|
||||
struct thread *td;
|
||||
struct statfs *nsp;
|
||||
struct ostatfs *osp;
|
||||
{
|
||||
|
||||
bzero(osp, sizeof(*osp));
|
||||
osp->f_bsize = MIN(nsp->f_bsize, LONG_MAX);
|
||||
osp->f_iosize = MIN(nsp->f_iosize, LONG_MAX);
|
||||
osp->f_blocks = MIN(nsp->f_blocks, LONG_MAX);
|
||||
osp->f_bfree = MIN(nsp->f_bfree, LONG_MAX);
|
||||
osp->f_bavail = MIN(nsp->f_bavail, LONG_MAX);
|
||||
osp->f_files = MIN(nsp->f_files, LONG_MAX);
|
||||
osp->f_ffree = MIN(nsp->f_ffree, LONG_MAX);
|
||||
osp->f_owner = nsp->f_owner;
|
||||
osp->f_type = nsp->f_type;
|
||||
osp->f_flags = nsp->f_flags;
|
||||
osp->f_syncwrites = MIN(nsp->f_syncwrites, LONG_MAX);
|
||||
osp->f_asyncwrites = MIN(nsp->f_asyncwrites, LONG_MAX);
|
||||
osp->f_syncreads = MIN(nsp->f_syncreads, LONG_MAX);
|
||||
osp->f_asyncreads = MIN(nsp->f_asyncreads, LONG_MAX);
|
||||
bcopy(nsp->f_fstypename, osp->f_fstypename,
|
||||
MIN(MFSNAMELEN, OMNAMELEN));
|
||||
bcopy(nsp->f_mntonname, osp->f_mntonname,
|
||||
MIN(MFSNAMELEN, OMNAMELEN));
|
||||
bcopy(nsp->f_mntfromname, osp->f_mntfromname,
|
||||
MIN(MFSNAMELEN, OMNAMELEN));
|
||||
if (suser(td)) {
|
||||
osp->f_fsid.val[0] = osp->f_fsid.val[1] = 0;
|
||||
} else {
|
||||
osp->f_fsid = nsp->f_fsid;
|
||||
}
|
||||
}
|
||||
#endif /* COMPAT_FREEBSD4 */
|
||||
|
||||
/*
|
||||
* Change current working directory to a given file descriptor.
|
||||
*/
|
||||
@ -3788,10 +4067,9 @@ fhstatfs(td, uap)
|
||||
struct statfs *buf;
|
||||
} */ *uap;
|
||||
{
|
||||
struct statfs *sp;
|
||||
struct statfs *sp, sb;
|
||||
struct mount *mp;
|
||||
struct vnode *vp;
|
||||
struct statfs sb;
|
||||
fhandle_t fh;
|
||||
int error;
|
||||
|
||||
@ -3817,9 +4095,14 @@ fhstatfs(td, uap)
|
||||
if (error)
|
||||
return (error);
|
||||
#endif
|
||||
/*
|
||||
* Set these in case the underlying filesystem fails to do so.
|
||||
*/
|
||||
sp->f_version = STATFS_VERSION;
|
||||
sp->f_namemax = NAME_MAX;
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if ((error = VFS_STATFS(mp, sp, td)) != 0)
|
||||
return (error);
|
||||
sp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
if (suser(td)) {
|
||||
bcopy(sp, &sb, sizeof(sb));
|
||||
sb.f_fsid.val[0] = sb.f_fsid.val[1] = 0;
|
||||
|
@ -62,13 +62,41 @@ struct fid {
|
||||
/*
|
||||
* filesystem statistics
|
||||
*/
|
||||
#define MFSNAMELEN 16 /* length of type name including null */
|
||||
#define MNAMELEN 88 /* size of on/from name bufs */
|
||||
#define STATFS_VERSION 0x20030518 /* current version number */
|
||||
struct statfs {
|
||||
uint32_t f_version; /* structure version number */
|
||||
uint32_t f_type; /* type of filesystem */
|
||||
uint64_t f_flags; /* copy of mount exported flags */
|
||||
uint64_t f_bsize; /* filesystem fragment size */
|
||||
uint64_t f_iosize; /* optimal transfer block size */
|
||||
uint64_t f_blocks; /* total data blocks in filesystem */
|
||||
uint64_t f_bfree; /* free blocks in filesystem */
|
||||
int64_t f_bavail; /* free blocks avail to non-superuser */
|
||||
uint64_t f_files; /* total file nodes in filesystem */
|
||||
int64_t f_ffree; /* free nodes avail to non-superuser */
|
||||
uint64_t f_syncwrites; /* count of sync writes since mount */
|
||||
uint64_t f_asyncwrites; /* count of async writes since mount */
|
||||
uint64_t f_syncreads; /* count of sync reads since mount */
|
||||
uint64_t f_asyncreads; /* count of async reads since mount */
|
||||
uint64_t f_spare[10]; /* unused spare */
|
||||
uint32_t f_namemax; /* maximum filename length */
|
||||
uid_t f_owner; /* user that mounted the filesystem */
|
||||
fsid_t f_fsid; /* filesystem id */
|
||||
char f_charspare[80]; /* spare string space */
|
||||
char f_fstypename[MFSNAMELEN]; /* filesystem type name */
|
||||
char f_mntfromname[MNAMELEN]; /* mounted filesystem */
|
||||
char f_mntonname[MNAMELEN]; /* directory on which mounted */
|
||||
};
|
||||
|
||||
#define MFSNAMELEN 16 /* length of fs type name, including null */
|
||||
#define MNAMELEN (88 - 2 * sizeof(long)) /* size of on/from name bufs */
|
||||
#ifdef _KERNEL
|
||||
#define OMFSNAMELEN 16 /* length of fs type name, including null */
|
||||
#define OMNAMELEN (88 - 2 * sizeof(long)) /* size of on/from name bufs */
|
||||
|
||||
/* XXX getfsstat.2 is out of date with write and read counter changes here. */
|
||||
/* XXX statfs.2 is out of date with read counter changes here. */
|
||||
struct statfs {
|
||||
struct ostatfs {
|
||||
long f_spare2; /* placeholder */
|
||||
long f_bsize; /* fundamental filesystem block size */
|
||||
long f_iosize; /* optimal transfer block size */
|
||||
@ -83,12 +111,12 @@ struct statfs {
|
||||
int f_flags; /* copy of mount exported flags */
|
||||
long f_syncwrites; /* count of sync writes since mount */
|
||||
long f_asyncwrites; /* count of async writes since mount */
|
||||
char f_fstypename[MFSNAMELEN]; /* fs type name */
|
||||
char f_mntonname[MNAMELEN]; /* directory on which mounted */
|
||||
char f_fstypename[OMFSNAMELEN]; /* fs type name */
|
||||
char f_mntonname[OMNAMELEN]; /* directory on which mounted */
|
||||
long f_syncreads; /* count of sync reads since mount */
|
||||
long f_asyncreads; /* count of async reads since mount */
|
||||
short f_spares1; /* unused spare */
|
||||
char f_mntfromname[MNAMELEN];/* mounted filesystem */
|
||||
char f_mntfromname[OMNAMELEN];/* mounted filesystem */
|
||||
short f_spares2; /* unused spare */
|
||||
/*
|
||||
* XXX on machines where longs are aligned to 8-byte boundaries, there
|
||||
@ -98,7 +126,6 @@ struct statfs {
|
||||
long f_spare[2]; /* unused spare */
|
||||
};
|
||||
|
||||
#ifdef _KERNEL
|
||||
#define MMAXOPTIONLEN 65536 /* maximum length of a mount option */
|
||||
|
||||
TAILQ_HEAD(vnodelst, vnode);
|
||||
|
@ -1076,6 +1076,7 @@ ffs_statfs(mp, sbp, td)
|
||||
fs = ump->um_fs;
|
||||
if (fs->fs_magic != FS_UFS1_MAGIC && fs->fs_magic != FS_UFS2_MAGIC)
|
||||
panic("ffs_statfs");
|
||||
sbp->f_version = STATFS_VERSION;
|
||||
sbp->f_bsize = fs->fs_fsize;
|
||||
sbp->f_iosize = fs->fs_bsize;
|
||||
sbp->f_blocks = fs->fs_dsize;
|
||||
@ -1085,8 +1086,18 @@ ffs_statfs(mp, sbp, td)
|
||||
dbtofsb(fs, fs->fs_pendingblocks);
|
||||
sbp->f_files = fs->fs_ncg * fs->fs_ipg - ROOTINO;
|
||||
sbp->f_ffree = fs->fs_cstotal.cs_nifree + fs->fs_pendinginodes;
|
||||
sbp->f_namemax = NAME_MAX;
|
||||
if (sbp != &mp->mnt_stat) {
|
||||
sbp->f_flags = mp->mnt_flag & MNT_VISFLAGMASK;
|
||||
sbp->f_type = mp->mnt_vfc->vfc_typenum;
|
||||
sbp->f_syncwrites = mp->mnt_stat.f_syncwrites;
|
||||
sbp->f_asyncwrites = mp->mnt_stat.f_asyncwrites;
|
||||
sbp->f_syncreads = mp->mnt_stat.f_syncreads;
|
||||
sbp->f_asyncreads = mp->mnt_stat.f_asyncreads;
|
||||
sbp->f_owner = mp->mnt_stat.f_owner;
|
||||
sbp->f_fsid = mp->mnt_stat.f_fsid;
|
||||
bcopy((caddr_t)mp->mnt_stat.f_fstypename,
|
||||
(caddr_t)&sbp->f_fstypename[0], MFSNAMELEN);
|
||||
bcopy((caddr_t)mp->mnt_stat.f_mntonname,
|
||||
(caddr_t)&sbp->f_mntonname[0], MNAMELEN);
|
||||
bcopy((caddr_t)mp->mnt_stat.f_mntfromname,
|
||||
|
Loading…
Reference in New Issue
Block a user