自学教程：C++ vfs_statfs函数代码示例

static int au_wbr_init(struct au_branch *br, struct super_block *sb,		       int perm, struct path *path){	int err;	struct kstatfs kst;	struct au_wbr *wbr;	struct dentry *h_dentry;	wbr = br->br_wbr;	au_rw_init(&wbr->wbr_wh_rwsem);	memset(wbr->wbr_wh, 0, sizeof(wbr->wbr_wh));	atomic_set(&wbr->wbr_wh_running, 0);	wbr->wbr_bytes = 0;	/*	 * a limit for rmdir/rename a dir	 * cf. AUFS_MAX_NAMELEN in include/linux/aufs_type.h	 */	h_dentry = path->dentry;	err = vfs_statfs(h_dentry, &kst);	if (unlikely(err))		goto out;	err = -EINVAL;	if (kst.f_namelen >= NAME_MAX)		err = au_br_init_wh(sb, br, perm, h_dentry);	else		pr_err("%.*s(%s), unsupported namelen %ld/n",		       AuDLNPair(h_dentry), au_sbtype(h_dentry->d_sb),		       kst.f_namelen);out:	return err;}

/*  This function is called from hpux_utssys(); HP-UX implements *  ustat() as an option to utssys(). * *  Now, struct ustat on HP-UX is exactly the same as on Linux, except *  that it contains one addition field on the end, int32_t f_blksize. *  So, we could have written this function to just call the Linux *  sys_ustat(), (defined in linux/fs/super.c), and then just *  added this additional field to the user's structure.  But I figure *  if we're gonna be digging through filesystem structures to get *  this, we might as well just do the whole enchilada all in one go. * *  So, most of this function is almost identical to sys_ustat(). *  I have placed comments at the few lines changed or added, to *  aid in porting forward if and when sys_ustat() is changed from *  its form in kernel 2.2.5. */static int hpux_ustat(dev_t dev, struct hpux_ustat __user *ubuf){	struct super_block *s;	struct hpux_ustat tmp;  /* Changed to hpux_ustat */	struct kstatfs sbuf;	int err = -EINVAL;	s = user_get_super(dev);	if (s == NULL)		goto out;	err = vfs_statfs(s, &sbuf);	drop_super(s);	if (err)		goto out;	memset(&tmp,0,sizeof(tmp));	tmp.f_tfree = (int32_t)sbuf.f_bfree;	tmp.f_tinode = (u_int32_t)sbuf.f_ffree;	tmp.f_blksize = (u_int32_t)sbuf.f_bsize;  /*  Added this line  */	err = copy_to_user(ubuf, &tmp, sizeof(tmp)) ? -EFAULT : 0;out:	return err;}

static intnullfs_getattr(struct vnop_getattr_args * args){	int error;	struct null_mount * null_mp = MOUNTTONULLMOUNT(vnode_mount(args->a_vp));	NULLFSDEBUG("%s %p/n", __FUNCTION__, args->a_vp);	lck_mtx_lock(&null_mp->nullm_lock);	if (nullfs_isspecialvp(args->a_vp)) {		error = nullfs_special_getattr(args);		lck_mtx_unlock(&null_mp->nullm_lock);		return error;	}	lck_mtx_unlock(&null_mp->nullm_lock);	/* this will return a different inode for third than read dir will */	struct vnode * lowervp = NULLVPTOLOWERVP(args->a_vp);	error = vnode_getwithref(lowervp);	if (error == 0) {		error = VNOP_GETATTR(lowervp, args->a_vap, args->a_context);		vnode_put(lowervp);		if (error == 0) {			/* fix up fsid so it doesn't say the underlying fs*/			VATTR_RETURN(args->a_vap, va_fsid, vfs_statfs(vnode_mount(args->a_vp))->f_fsid.val[0]);		}	}	return error;}

static int sdcardfs_statfs(struct dentry *dentry, struct kstatfs *buf){	int err;	struct path lower_path;	u32 min_blocks;	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(dentry->d_sb);	sdcardfs_get_lower_path(dentry, &lower_path);	err = vfs_statfs(&lower_path, buf);	sdcardfs_put_lower_path(dentry, &lower_path);	if (sbi->options.reserved_mb) {		/* Invalid statfs informations. */		if (buf->f_bsize == 0) {			printk(KERN_ERR "Returned block size is zero./n");			return -EINVAL;		}			min_blocks = ((sbi->options.reserved_mb * 1024 * 1024)/buf->f_bsize);		buf->f_blocks -= min_blocks;			if (buf->f_bavail > min_blocks)			buf->f_bavail -= min_blocks;		else			buf->f_bavail = 0;			/* Make reserved blocks invisiable to media storage */		buf->f_bfree = buf->f_bavail;	}	/* set return buf to our f/s to avoid confusing user-level utils */	buf->f_type = SDCARDFS_SUPER_MAGIC;	return err;}

static int vfs_statfs64(struct dentry *dentry, struct statfs64 *buf){	struct kstatfs st;	int retval;	retval = vfs_statfs(dentry, &st);	if (retval)		return retval;	if (sizeof(*buf) == sizeof(st))		memcpy(buf, &st, sizeof(st));	else {		buf->f_type = st.f_type;		buf->f_bsize = st.f_bsize;		buf->f_blocks = st.f_blocks;		buf->f_bfree = st.f_bfree;		buf->f_bavail = st.f_bavail;		buf->f_files = st.f_files;		buf->f_ffree = st.f_ffree;		buf->f_fsid = st.f_fsid;		buf->f_namelen = st.f_namelen;		buf->f_frsize = st.f_frsize;		memset(buf->f_spare, 0, sizeof(buf->f_spare));	}	return 0;}

/* * Check the amount of free space and suspend/resume accordingly. */static int check_free_space(struct bsd_acct_struct *acct){	struct kstatfs sbuf;	if (time_is_before_jiffies(acct->needcheck))		goto out;	/* May block */	if (vfs_statfs(&acct->file->f_path, &sbuf))		goto out;	if (acct->active) {		u64 suspend = sbuf.f_blocks * SUSPEND;		do_div(suspend, 100);		if (sbuf.f_bavail <= suspend) {			acct->active = 0;			pr_info("Process accounting paused/n");		}	} else {		u64 resume = sbuf.f_blocks * RESUME;		do_div(resume, 100);		if (sbuf.f_bavail >= resume) {			acct->active = 1;			pr_info("Process accounting resumed/n");		}	}	acct->needcheck = jiffies + ACCT_TIMEOUT*HZ;out:	return acct->active;}

static intvnop_getattr_9p(struct vnop_getattr_args *ap){	struct vnode_attr *vap;	struct timespec ts;	node_9p *np;	enum vtype type;	dev_t rdev;	int e, dotu;	TRACE();	e = 0;	np = NTO9P(ap->a_vp);	/* exclusive, because we modify np->dir */	nlock_9p(np, NODE_LCK_EXCLUSIVE);	if ((e=ngetdir_9p(np)))		goto error;	dotu = ISSET(np->nmp->flags, F_DOTU);	ts.tv_nsec	= 0;	vap = ap->a_vap;	VATTR_RETURN(vap, va_rdev, np->dir.dev);	VATTR_RETURN(vap, va_nlink, 1);	VATTR_RETURN(vap, va_data_size, np->dir.length);	VATTR_RETURN(vap, va_iosize, np->iounit);	if (dotu) {		VATTR_RETURN(vap, va_uid, np->dir.uidnum);		VATTR_RETURN(vap, va_gid, np->dir.gidnum);	} else {		VATTR_RETURN(vap, va_uid, np->nmp->uid);		VATTR_RETURN(vap, va_gid, np->nmp->gid);	}	VATTR_RETURN(vap, va_mode, np->dir.mode & 0777);	VATTR_RETURN(vap, va_flags, 0);	ts.tv_sec = np->dir.atime;	VATTR_RETURN(vap, va_access_time, ts);	ts.tv_sec = np->dir.mtime;	VATTR_RETURN(vap, va_modify_time, ts);	VATTR_RETURN(vap, va_fileid, QTOI(np->dir.qid));	VATTR_RETURN(vap, va_linkid, QTOI(np->dir.qid));	VATTR_RETURN(vap, va_fsid, vfs_statfs(np->nmp->mp)->f_fsid.val[0]);	VATTR_RETURN(vap, va_filerev, np->dir.qid.vers);	VATTR_RETURN(vap, va_gen, 0);	VATTR_RETURN(vap, va_encoding, 0x7E); /* utf-8 */	dirvtype_9p(&np->dir, dotu, &type, &rdev);	VATTR_RETURN(vap, va_type, type);	VATTR_RETURN(vap, va_rdev, rdev);	/*	if (VATTR_IS_ACTIVE(vap, va_name) && !vnode_isvroot(ap->a_vp)) {		strlcpy(vap->va_name, dp->name, MAXPATHLEN);		VATTR_SET_SUPPORTED(vap, va_name);	}	 */error:	nunlock_9p(np);	return e;}

/* * Check the amount of free space and suspend/resume accordingly. */static int check_free_space(struct bsd_acct_struct *acct, struct file *file){	struct kstatfs sbuf;	int res;	int act;	u64 resume;	u64 suspend;	spin_lock(&acct_lock);	res = acct->active;	if (!file || time_is_before_jiffies(acct->needcheck))		goto out;	spin_unlock(&acct_lock);	/* May block */	if (vfs_statfs(&file->f_path, &sbuf))		return res;	suspend = sbuf.f_blocks * SUSPEND;	resume = sbuf.f_blocks * RESUME;	do_div(suspend, 100);	do_div(resume, 100);	if (sbuf.f_bavail <= suspend)		act = -1;	else if (sbuf.f_bavail >= resume)		act = 1;	else		act = 0;	/*	 * If some joker switched acct->file under us we'ld better be	 * silent and _not_ touch anything.	 */	spin_lock(&acct_lock);	if (file != acct->file) {		if (act)			res = act > 0;		goto out;	}	if (acct->active) {		if (act < 0) {			acct->active = 0;			pr_info("Process accounting paused/n");		}	} else {		if (act > 0) {			acct->active = 1;			pr_info("Process accounting resumed/n");		}	}	acct->needcheck = jiffies + ACCT_TIMEOUT*HZ;	res = acct->active;out:	spin_unlock(&acct_lock);	return res;}

static int u2fs_statfs(struct dentry *dentry, struct kstatfs *buf){	int err;	struct path lower_path, lower_path1;		u2fs_get_lower_path(dentry, &lower_path, LEFT);	err = vfs_statfs(&lower_path, buf);	u2fs_put_lower_path(dentry, &lower_path);	u2fs_get_lower_path(dentry, &lower_path1, RIGHT);	err = vfs_statfs(&lower_path1, buf);	u2fs_put_lower_path(dentry, &lower_path1);	/* set return buf to our f/s to avoid confusing user-level utils */	buf->f_type = WRAPFS_SUPER_MAGIC;	return err;}

QTOCDataFormat10PtrCreateBufferFromIORegistry ( mount_t mountPtr ){	QTOCDataFormat10Ptr		TOCDataPtr			= NULL;	OSObject *				objectPtr			= NULL;	OSData *				dataPtr				= NULL;	IOCDMedia *				cdMediaPtr			= NULL;	char *					ioBSDNamePtr		= NULL;	DebugLog ( ( "CreateBufferFromIORegistry: Entering.../n" ) );		DebugAssert ( ( mountPtr != NULL ) );		ioBSDNamePtr = vfs_statfs ( mountPtr )->f_mntfromname;	DebugAssert ( ( ioBSDNamePtr != NULL ) );		cdMediaPtr = GetCDMediaObjectFromName ( ioBSDNamePtr );	DebugAssert ( ( cdMediaPtr != NULL ) );		if ( cdMediaPtr != NULL )	{				// Get the TOC property		objectPtr = cdMediaPtr->getProperty ( kIOCDMediaTOCKey );		if ( objectPtr == NULL )		{					DebugLog ( ( "CreateBufferFromIORegistry: objectPtr is NULL./n" ) );			return NULL;				}				// Cast it to an OSData *		dataPtr = OSDynamicCast ( OSData, objectPtr );		if ( dataPtr == NULL )		{					DebugLog ( ( "CreateBufferFromIORegistry: dataPtr is NULL./n" ) );			return NULL;				}		// Get the data from the registry entry		TOCDataPtr = CreateBufferFromData ( dataPtr );				DebugLog ( ( "Releasing refcsount on IOCDMedia./n" ) );		cdMediaPtr->release ( );			}		DebugLog ( ( "CreateBufferFromIORegistry: exiting.../n" ) );		return TOCDataPtr;	}

/** * Mount helper: Allocate and init VBoxVFS global data. * * @param mp            Mount data provided by VFS layer. * @param pUserData     Mounting parameters provided by user space mount tool. * * @return VBoxVFS global data or NULL. */static vboxvfs_mount_t *vboxvfs_alloc_internal_data(struct mount *mp, user_addr_t pUserData){    vboxvfs_mount_t             *pMount;    struct vboxvfs_mount_info    mountInfo;    struct vfsstatfs            *pVfsInfo;    size_t                       cbShareName;    int rc;    AssertReturn(mp,        NULL);    AssertReturn(pUserData, NULL);    pVfsInfo = vfs_statfs(mp);    AssertReturn(pVfsInfo, NULL);    /* Allocate memory for VBoxVFS internal data */    pMount = (vboxvfs_mount_t *)RTMemAllocZ(sizeof(vboxvfs_mount_t));    if (pMount)    {        rc = vboxvfs_get_mount_info(pUserData, &mountInfo);        if (rc == 0)        {            PDEBUG("Mounting shared folder '%s'", mountInfo.name);            /* Prepare for locking. We prepare locking group and attr data here,             * but allocate and initialize real lock in vboxvfs_create_vnode_internal().             * We use the same pLockGroup and pLockAttr for all vnodes related to this mount point. */            rc = vboxvfs_prepare_locking(pMount);            if (rc == 0)            {                rc = vboxvfs_set_share_name(mp, (char *)&mountInfo.name, &cbShareName);                if (rc == 0)                {                    pMount->pShareName = vboxvfs_construct_shflstring((char *)&mountInfo.name, cbShareName);                    if (pMount->pShareName)                    {                        /* Remember user who mounted this share */                        pMount->owner = pVfsInfo->f_owner;                        /* Mark root vnode as uninitialized */                        ASMAtomicWriteU8(&pMount->fRootVnodeState, VBOXVFS_OBJECT_UNINITIALIZED);                        return pMount;                    }                }            }            vboxvfs_destroy_locking(pMount);        }        RTMemFree(pMount);    }    return NULL;}

int user_statfs(const char __user *pathname, struct kstatfs *st){	struct path path;	int error = user_path_at(AT_FDCWD, pathname, LOOKUP_FOLLOW|LOOKUP_AUTOMOUNT, &path);	if (!error) {		error = vfs_statfs(&path, st);		path_put(&path);	}	return error;}

int fd_statfs(int fd, struct kstatfs *st){	struct file *file = fget_raw(fd);	int error = -EBADF;	if (file) {		error = vfs_statfs(&file->f_path, st);		fput(file);	}	return error;}

/* * Check the amount of free space and suspend/resume accordingly. */static int check_free_space(struct file *file){	struct statfs sbuf;	int res;	int act;	lock_kernel();	res = acct_active;	if (!file || !acct_needcheck)		goto out;	unlock_kernel();	/* May block */	if (vfs_statfs(file->f_dentry->d_inode->i_sb, &sbuf))		return res;	if (sbuf.f_bavail <= SUSPEND * sbuf.f_blocks / 100)		act = -1;	else if (sbuf.f_bavail >= RESUME * sbuf.f_blocks / 100)		act = 1;	else		act = 0;	/*	 * If some joker switched acct_file under us we'ld better be	 * silent and _not_ touch anything.	 */	lock_kernel();	if (file != acct_file) {		if (act)			res = act>0;		goto out;	}	if (acct_active) {		if (act < 0) {			acct_active = 0;			printk(KERN_INFO "Process accounting paused/n");		}	} else {		if (act > 0) {			acct_active = 1;			printk(KERN_INFO "Process accounting resumed/n");		}	}	del_timer(&acct_timer);	acct_needcheck = 0;	acct_timer.expires = jiffies + ACCT_TIMEOUT*HZ;	add_timer(&acct_timer);	res = acct_active;out:	unlock_kernel();	return res;}

/* most free space */static void au_mfs(struct dentry *dentry){	struct super_block *sb;	struct au_branch *br;	struct au_wbr_mfs *mfs;	aufs_bindex_t bindex, bend;	int err;	unsigned long long b, bavail;	struct path h_path;	/* reduce the stack usage */	struct kstatfs *st;	st = kmalloc(sizeof(*st), GFP_NOFS);	if (unlikely(!st)) {		AuWarn1("failed updating mfs(%d), ignored/n", -ENOMEM);		return;	}	bavail = 0;	sb = dentry->d_sb;	mfs = &au_sbi(sb)->si_wbr_mfs;	MtxMustLock(&mfs->mfs_lock);	mfs->mfs_bindex = -EROFS;	mfs->mfsrr_bytes = 0;	bend = au_sbend(sb);	for (bindex = 0; bindex <= bend; bindex++) {		br = au_sbr(sb, bindex);		if (au_br_rdonly(br))			continue;		/* sb->s_root for NFS is unreliable */		h_path.mnt = br->br_mnt;		h_path.dentry = h_path.mnt->mnt_root;		err = vfs_statfs(&h_path, st);		if (unlikely(err)) {			AuWarn1("failed statfs, b%d, %d/n", bindex, err);			continue;		}		/* when the available size is equal, select the lower one */		BUILD_BUG_ON(sizeof(b) < sizeof(st->f_bavail)			     || sizeof(b) < sizeof(st->f_bsize));		b = st->f_bavail * st->f_bsize;		br->br_wbr->wbr_bytes = b;		if (b >= bavail) {			bavail = b;			mfs->mfs_bindex = bindex;			mfs->mfs_jiffy = jiffies;		}	}	mfs->mfsrr_bytes = bavail;	AuDbg("b%d/n", mfs->mfs_bindex);	kfree(st);}

mini_fo_statfs(super_block_t *sb, struct statfs *buf)#endif{	int err = 0;	super_block_t *hidden_sb;	hidden_sb = stohs(sb);	err = vfs_statfs(hidden_sb, buf);	return err;}

static intvnop_strategy_9p(struct vnop_strategy_args *ap){	mount_t mp;	struct buf *bp;	node_9p *np;	caddr_t addr;	uio_t uio;	int e, flags;	TRACE();	bp = ap->a_bp;	np = NTO9P(buf_vnode(bp));	flags = buf_flags(bp);	uio = NULL;	addr = NULL;	mp = vnode_mount(buf_vnode(bp));	if (mp == NULL)		return ENXIO;	if ((e=buf_map(bp, &addr)))		goto error;	uio = uio_create(1, buf_blkno(bp) * vfs_statfs(mp)->f_bsize, UIO_SYSSPACE,					 ISSET(flags, B_READ)? UIO_READ: UIO_WRITE);	if (uio == NULL) {		e = ENOMEM;		goto error;	}		uio_addiov(uio, CAST_USER_ADDR_T(addr), buf_count(bp));	if (ISSET(flags, B_READ)) {		if((e=nread_9p(np, uio)))			goto error;		/* zero the rest of the page if we reached EOF */		if (uio_resid(uio) > 0) {			bzero(addr+buf_count(bp)-uio_resid(uio), uio_resid(uio));			uio_update(uio, uio_resid(uio));		}	} else {		if ((e=nwrite_9p(np, uio)))			goto error;	}	buf_setresid(bp, uio_resid(uio));error:	if (uio)		uio_free(uio);	if (addr)		buf_unmap(bp);	buf_seterror(bp, e);	buf_biodone(bp);	return e;}

static intvnop_offtoblk_9p(struct vnop_offtoblk_args *ap){	mount_t mp;		TRACE();	mp = vnode_mount(ap->a_vp);	if (mp == NULL)		return ENXIO;	*ap->a_lblkno = ap->a_offset / vfs_statfs(mp)->f_bsize;	return 0;}

static int ovl_check_namelen(struct path *path, struct ovl_fs *ofs,			     const char *name){	struct kstatfs statfs;	int err = vfs_statfs(path, &statfs);	if (err)		pr_err("overlayfs: statfs failed on '%s'/n", name);	else		ofs->namelen = max(ofs->namelen, statfs.f_namelen);	return err;}

static int esdfs_statfs(struct dentry *dentry, struct kstatfs *buf){	int err;	struct path lower_path;	esdfs_get_lower_path(dentry, &lower_path);	err = vfs_statfs(&lower_path, buf);	esdfs_put_lower_path(dentry, &lower_path);	/* set return buf to our f/s to avoid confusing user-level utils */	buf->f_type = ESDFS_SUPER_MAGIC;	return err;}

asmlinkage long sys_statfs(const char * path, struct statfs * buf){	struct nameidata nd;	int error;	error = user_path_walk(path, &nd);	if (!error) {		struct statfs tmp;		error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp);		if (!error && copy_to_user(buf, &tmp, sizeof(struct statfs)))			error = -EFAULT;		path_release(&nd);	}	return error;}

/** * ovl_statfs * @sb: The overlayfs super block * @buf: The struct kstatfs to fill in with stats * * Get the filesystem statistics.  As writes always target the upper layer * filesystem pass the statfs to the same filesystem. */static int ovl_statfs(struct dentry *dentry, struct kstatfs *buf){	struct ovl_fs *ofs = dentry->d_sb->s_fs_info;	struct dentry *root_dentry = dentry->d_sb->s_root;	struct path path;	int err;	ovl_path_upper(root_dentry, &path);	err = vfs_statfs(&path, buf);	if (!err) {		buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen);		buf->f_type = OVERLAYFS_SUPER_MAGIC;	}	return err;}

asmlinkage long sys_fstatfs(unsigned int fd, struct statfs * buf){	struct file * file;	struct statfs tmp;	int error;	error = -EBADF;	file = fget(fd);	if (!file)		goto out;	error = vfs_statfs(file->f_dentry->d_inode->i_sb, &tmp);	if (!error && copy_to_user(buf, &tmp, sizeof(struct statfs)))		error = -EFAULT;	fput(file);out:	return error;}

int user_statfs(const char __user *pathname, struct kstatfs *st){	struct path path;	int error;	unsigned int lookup_flags = LOOKUP_FOLLOW;retry:	error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);	if (!error) {		error = vfs_statfs(&path, st);		path_put(&path);		if (retry_estale(error, lookup_flags)) {			lookup_flags |= LOOKUP_REVAL;			goto retry;		}	}	return error;}

/** * Mount helper: Provide VFS layer with a VBox share name (stored as mounted device). * * @param mp            Mount data provided by VFS layer. * @param szShareName   VBox share name. * @param cbShareName   Returning parameter which contains VBox share name string length. * * @return 0 on success or BSD error code otherwise. */static intvboxvfs_set_share_name(struct mount *mp, char *szShareName, size_t *cbShareName){    struct vfsstatfs *pVfsInfo;    AssertReturn(mp,          EINVAL);    AssertReturn(szShareName, EINVAL);    AssertReturn(cbShareName, EINVAL);    pVfsInfo = vfs_statfs(mp);    if (!pVfsInfo)    {        PERROR("Unable to get VFS data for the mount structure");        return EINVAL;    }    return copystr(szShareName, pVfsInfo->f_mntfromname, MAXPATHLEN, cbShareName);}

static intvnop_blockmap_9p(struct vnop_blockmap_args *ap){	mount_t mp;		TRACE();	mp = vnode_mount(ap->a_vp);	if (mp == NULL)		return ENXIO;	if (ap->a_run)		*ap->a_run = ap->a_size;	if (ap->a_bpn)		*ap->a_bpn = ap->a_foffset / vfs_statfs(mp)->f_bsize;	if (ap->a_poff)		*(int32_t*)ap->a_poff = 0;	return 0;}

static int vfs_statfs_native(struct dentry *dentry, struct statfs *buf){	struct kstatfs st;	int retval;	retval = vfs_statfs(dentry, &st);	if (retval)		return retval;	if (sizeof(*buf) == sizeof(st))		memcpy(buf, &st, sizeof(st));	else {		if (sizeof buf->f_blocks == 4) {			if ((st.f_blocks | st.f_bfree | st.f_bavail |			     st.f_bsize | st.f_frsize) &			    0xffffffff00000000ULL)				return -EOVERFLOW;			/*			 * f_files and f_ffree may be -1; it's okay to stuff			 * that into 32 bits			 */			if (st.f_files != -1 &&			    (st.f_files & 0xffffffff00000000ULL))				return -EOVERFLOW;			if (st.f_ffree != -1 &&			    (st.f_ffree & 0xffffffff00000000ULL))				return -EOVERFLOW;		}		buf->f_type = st.f_type;		buf->f_bsize = st.f_bsize;		buf->f_blocks = st.f_blocks;		buf->f_bfree = st.f_bfree;		buf->f_bavail = st.f_bavail;		buf->f_files = st.f_files;		buf->f_ffree = st.f_ffree;		buf->f_fsid = st.f_fsid;		buf->f_namelen = st.f_namelen;		buf->f_frsize = st.f_frsize;		memset(buf->f_spare, 0, sizeof(buf->f_spare));	}	return 0;}