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

static int stat_file(struct kstat *stbuf){	struct file *fd;	int rc;	fd = filp_open(fname, O_RDONLY, 0);	if (IS_ERR(fd)) {		pr_err(PREFIX " can't open file %s/n", run_id, fname);		return -EIO;	}#ifdef HAVE_INODEOPS_ENHANCED_GETATTR	rc = vfs_getattr(&fd->f_path, stbuf, STATX_INO, AT_STATX_SYNC_AS_STAT);#elif LINUX_VERSION_CODE >= KERNEL_VERSION(3, 9, 0)	rc = vfs_getattr(&fd->f_path, stbuf);#else	rc = vfs_getattr(fd->f_path.mnt, fd->f_path.dentry, stbuf);#endif	if (rc != 0) {		pr_err(PREFIX " vfs_getattr failed: %d/n", run_id, rc);		goto out;	}	pr_err(PREFIX " inode is %llu/n", run_id, stbuf->ino);	rc = 0;out:	filp_close(fd, NULL);	return rc;}

int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,		int flag){	struct path path;	int error = -EINVAL;	int lookup_flags = 0;	if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |		      AT_EMPTY_PATH)) != 0)		goto out;	if (!(flag & AT_SYMLINK_NOFOLLOW))		lookup_flags |= LOOKUP_FOLLOW;	if (flag & AT_EMPTY_PATH)		lookup_flags |= LOOKUP_EMPTY;	error = user_path_at(dfd, filename, lookup_flags, &path);	if (error)		goto out;	error = vfs_getattr(path.mnt, path.dentry, stat);	if (!error)		zpath_realsize(path.dentry, &stat->size);	path_put(&path);out:	return error;}

/** * ubi_open_volume_path - open UBI volume by its character device node path. * @pathname: volume character device node path * @mode: open mode * * This function is similar to 'ubi_open_volume()', but opens a volume the path * to its character device node. */struct ubi_volume_desc *ubi_open_volume_path(const char *pathname, int mode){	int error, ubi_num, vol_id;	struct path path;	struct kstat stat;	dbg_gen("open volume %s, mode %d", pathname, mode);	if (!pathname || !*pathname)		return ERR_PTR(-EINVAL);	error = kern_path(pathname, LOOKUP_FOLLOW, &path);	if (error)		return ERR_PTR(error);	error = vfs_getattr(&path, &stat, STATX_TYPE, AT_STATX_SYNC_AS_STAT);	path_put(&path);	if (error)		return ERR_PTR(error);	if (!S_ISCHR(stat.mode))		return ERR_PTR(-EINVAL);	ubi_num = ubi_major2num(MAJOR(stat.rdev));	vol_id = MINOR(stat.rdev) - 1;	if (vol_id >= 0 && ubi_num >= 0)		return ubi_open_volume(ubi_num, vol_id, mode);	return ERR_PTR(-ENODEV);}

int vfs_fstatat(int dfd, const char __user *filename, struct kstat *stat,		int flag){	struct path path;	int error = -EINVAL;	unsigned int lookup_flags = 0;	if ((flag & ~(AT_SYMLINK_NOFOLLOW | AT_NO_AUTOMOUNT |		      AT_EMPTY_PATH)) != 0)		goto out;	if (!(flag & AT_SYMLINK_NOFOLLOW))		lookup_flags |= LOOKUP_FOLLOW;	if (flag & AT_EMPTY_PATH)		lookup_flags |= LOOKUP_EMPTY;retry:	error = user_path_at(dfd, filename, lookup_flags, &path);	if (error)		goto out;	error = vfs_getattr(&path, stat);	path_put(&path);	if (retry_estale(error, lookup_flags)) {		lookup_flags |= LOOKUP_REVAL;		goto retry;	}out:	return error;}

static int ccfs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat){	int rc = 0;	struct dentry *lower_dentry;		struct ccfs_inode* inode = ccfs_inode_to_private(dentry->d_inode);	struct vfsmount *lower_mnt = ccfs_dentry_to_nested_mnt(dentry);	lower_dentry = ccfs_get_nested_dentry(dentry);	if ( inode->stat ) {		*stat = *inode->stat;		return 0;	}	mutex_lock(&lower_dentry->d_inode->i_mutex);	rc = vfs_getattr(lower_mnt, lower_dentry, stat);	mutex_unlock(&lower_dentry->d_inode->i_mutex);	if ( !rc && inode->cacheable) {		inode->stat = kmalloc(sizeof(struct kstat), GFP_KERNEL);		if ( inode->stat ) {			*(inode->stat) = *stat;		}	}	mdbg(INFO3, "Get stat returned res: %d uid %d gid %d", rc, stat->uid, stat->gid);	return rc;}

static int ovl_copy_up_last(struct dentry *dentry, struct iattr *attr,			    bool no_data){	int err;	struct dentry *parent;	struct kstat stat;	struct path lowerpath;	parent = dget_parent(dentry);	err = ovl_copy_up(parent);	if (err)		goto out_dput_parent;	ovl_path_lower(dentry, &lowerpath);	err = vfs_getattr(&lowerpath, &stat);	if (err)		goto out_dput_parent;	if (no_data)		stat.size = 0;	err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat, attr);out_dput_parent:	dput(parent);	return err;}

static int ovl_dir_getattr(struct vfsmount *mnt, struct dentry *dentry,			 struct kstat *stat){	int err;	enum ovl_path_type type;	struct path realpath;	type = ovl_path_real(dentry, &realpath);	err = vfs_getattr(&realpath, stat);	if (err)		return err;	stat->dev = dentry->d_sb->s_dev;	stat->ino = dentry->d_inode->i_ino;	/*	 * It's probably not worth it to count subdirs to get the	 * correct link count.  nlink=1 seems to pacify 'find' and	 * other utilities.	 */	if (OVL_TYPE_MERGE(type))		stat->nlink = 1;	return 0;}

static void fn_open(l4fdx_srv_obj srv_obj, struct internal_request *r){    struct file *f;    struct l4fdx_result_t ret;    struct l4fdx_client *c = srv_obj->client;    int err, fid = -1;    char const *path = r->open.path;    if (c->basepath) {        unsigned l = strlen(path);        char *s = kmalloc(c->basepath_len + l + 1, GFP_KERNEL);        if (!s) {            err = -ENOMEM;            goto out;        }        strncpy(s, c->basepath, c->basepath_len);        strncpy(s + c->basepath_len, path, l);        s[c->basepath_len + l] = 0;        if (!validate_path(s, c->basepath_len + l)) {            kfree(s);            err = -EINVAL;            goto out;        }        path = s;    }    call_fdx_event(c, "pre-open", path, UMH_WAIT_PROC);    f = filp_open(path, r->open.flags & c->openflags_mask, r->open.mode);    if (IS_ERR(f)) {        err = PTR_ERR(f);    } else {        fid = set_free_fdxslot(c, f);        if (fid == -1) {            filp_close(f, NULL);            err = -ENOMEM;        } else            err = 0;    }    if (c->flag_nogrow && err == 0) {        struct kstat stat;        int r = vfs_getattr(&f->f_path, &stat);        c->max_file_size = r ? 0 : stat.size;    }    call_fdx_event(c, "post-open", path, UMH_WAIT_EXEC);    if (c->basepath)        kfree(path);out:    ret.payload.fid = fid;    ret.payload.ret = err;    res_event(srv_obj, &ret, r->client_req_id);    kfree(r);}

extern intvnode_shadow_iop_getattr(    struct vfsmount *mnt,    DENT_T *dentry,    struct kstat *kstat){    DENT_T *rdentry;    VNODE_T *cvp;    int err;    rdentry = REALDENTRY_LOCKED(dentry, &cvp);    if (rdentry == NULL) {        err = -EOPNOTSUPP;             /* XXX */    } else {        VNODE_DGET(rdentry);                 /* protect inode */        if (rdentry != NULL && rdentry->d_inode != NULL) {            err = vfs_getattr(CVN_TO_VFSMNT(cvp), rdentry, kstat);            if (err == 0) {                SHADOW_CP_INODAT(dentry->d_inode, rdentry->d_inode);            }        } else            err = -EOPNOTSUPP;              /* XXX */        VNODE_DPUT(rdentry);        REALDENTRY_UNLOCK(dentry, cvp);    }    return(err);}

static int ovl_getattr(struct vfsmount *mnt, struct dentry *dentry,			 struct kstat *stat){	struct path realpath;	ovl_path_real(dentry, &realpath);	return vfs_getattr(&realpath, stat);}

static int fuse_getattr(const char *path, stat *stbuf){    int res;    res = vfs_getattr(path, stbuf);    if (res == -1)        return -errno;    return 0;}

/* Don't inline this: 'struct kstat' is biggish */static noinline_for_stack long fw_file_size(struct file *file){	struct kstat st;	if (vfs_getattr(&file->f_path, &st))		return -1;	if (!S_ISREG(st.mode))		return -1;	if (st.size != (long)st.size)		return -1;	return st.size;}

int vfs_fstat(unsigned int fd, struct kstat *stat){	struct file *f = fget(fd);	int error = -EBADF;	if (f) {		error = vfs_getattr(f->f_path.mnt, f->f_path.dentry, stat);		fput(f);	}	return error;}

int vfs_fstat(unsigned int fd, struct kstat *stat){	struct fd f = fdget_raw(fd);	int error = -EBADF;	if (f.file) {		error = vfs_getattr(&f.file->f_path, stat);		fdput(f);	}	return error;}

int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat){	struct nameidata nd;	int error;	error = __user_walk_fd(dfd, name, 0, &nd);	if (!error) {		error = vfs_getattr(nd.mnt, nd.dentry, stat);		path_release(&nd);	}	return error;}

int vfs_lstat_fd(int dfd, char __user *name, struct kstat *stat){	struct path path;	int error;	error = user_path_at(dfd, name, 0, &path);	if (!error) {		error = vfs_getattr(path.mnt, path.dentry, stat);		path_put(&path);	}	return error;}

int vfs_fstat(unsigned int fd, struct kstat *stat){	int fput_needed;	struct file *f = fget_light(fd, &fput_needed);	int error = -EBADF;	if (f) {		error = vfs_getattr(f->f_path.mnt, f->f_path.dentry, stat);		fput_light(f, fput_needed);	}	return error;}

int devtmpfs_delete_node(struct device *dev){	const char *tmp = NULL;	const char *nodename;	const struct cred *curr_cred;	struct nameidata nd;	struct dentry *dentry;	struct kstat stat;	int deleted = 1;	int err;	if (!dev_mnt)		return 0;	nodename = device_get_devnode(dev, NULL, &tmp);	if (!nodename)		return -ENOMEM;	curr_cred = override_creds(&init_cred);	err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,			      nodename, LOOKUP_PARENT, &nd);	if (err)		goto out;	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);	dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);	if (!IS_ERR(dentry)) {		if (dentry->d_inode) {			err = vfs_getattr(nd.path.mnt, dentry, &stat);			if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {				err = vfs_unlink(nd.path.dentry->d_inode,						 dentry);				if (!err || err == -ENOENT)					deleted = 1;			}		} else {			err = -ENOENT;		}		dput(dentry);	} else {		err = PTR_ERR(dentry);	}	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);	path_put(&nd.path);	if (deleted && strchr(nodename, '/'))		delete_path(nodename);out:	kfree(tmp);	revert_creds(curr_cred);	return err;}

unsigned long long file_size(struct file * file_ptr) {    struct kstat s;    int ret;    ret = vfs_getattr(file_ptr->f_path.mnt, file_ptr->f_path.dentry, &s);    if (ret != 0) {        printk(KERN_ERR "Failed to fstat file/n");        return -1;    }    return s.size;}

static int handle_remove(const char *nodename, struct device *dev){	struct nameidata nd;	struct dentry *dentry;	struct kstat stat;	int deleted = 1;	int err;	err = kern_path_parent(nodename, &nd);	if (err)		return err;	mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);	dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);	if (!IS_ERR(dentry)) {		if (dentry->d_inode) {			err = vfs_getattr(nd.path.mnt, dentry, &stat);			if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {				struct iattr newattrs;				/*				 * before unlinking this node, reset permissions				 * of possible references like hardlinks				 */				newattrs.ia_uid = 0;				newattrs.ia_gid = 0;				newattrs.ia_mode = stat.mode & ~0777;				newattrs.ia_valid =					ATTR_UID|ATTR_GID|ATTR_MODE;				mutex_lock(&dentry->d_inode->i_mutex);				notify_change(dentry, &newattrs);				mutex_unlock(&dentry->d_inode->i_mutex);				err = vfs_unlink(nd.path.dentry->d_inode,						 dentry);				if (!err || err == -ENOENT)					deleted = 1;			}		} else {			err = -ENOENT;		}		dput(dentry);	} else {		err = PTR_ERR(dentry);	}	mutex_unlock(&nd.path.dentry->d_inode->i_mutex);	path_put(&nd.path);	if (deleted && strchr(nodename, '/'))		delete_path(nodename);	return err;}

static int diaryfs_getattr(struct vfsmount *mnt, struct dentry * dentry, struct kstat *stat) {	int err;	struct kstat lower_stat;	struct path lower_path;	diaryfs_get_lower_path(dentry, &lower_path); 	err = vfs_getattr(&lower_path, &lower_stat);	if (err) 		goto out;	fsstack_copy_attr_all(dentry->d_inode, lower_path.dentry->d_inode);	generic_fillattr(dentry->d_inode, stat);	stat->blocks = lower_stat.blocks;out:	diaryfs_put_lower_path(dentry, &lower_path);	return err;}

static intnullfs_vfs_getlowerattr(mount_t mp, struct vfs_attr * vfap, vfs_context_t ctx){	memset(vfap, 0, sizeof(*vfap));	VFSATTR_INIT(vfap);	VFSATTR_WANTED(vfap, f_bsize);	VFSATTR_WANTED(vfap, f_iosize);	VFSATTR_WANTED(vfap, f_blocks);	VFSATTR_WANTED(vfap, f_bfree);	VFSATTR_WANTED(vfap, f_bavail);	VFSATTR_WANTED(vfap, f_bused);	VFSATTR_WANTED(vfap, f_files);	VFSATTR_WANTED(vfap, f_ffree);	VFSATTR_WANTED(vfap, f_capabilities);	return vfs_getattr(mp, vfap, ctx);}

/*! 2017. 8.12 study -ing */static int handle_remove(const char *nodename, struct device *dev){	struct path parent;	struct dentry *dentry;	int deleted = 0;	int err;	dentry = kern_path_locked(nodename, &parent);	if (IS_ERR(dentry))		return PTR_ERR(dentry);	if (dentry->d_inode) {		struct kstat stat;		struct path p = {.mnt = parent.mnt, .dentry = dentry};		err = vfs_getattr(&p, &stat);		if (!err && dev_mynode(dev, dentry->d_inode, &stat)) {			struct iattr newattrs;			/*			 * before unlinking this node, reset permissions			 * of possible references like hardlinks			 */			newattrs.ia_uid = GLOBAL_ROOT_UID;			newattrs.ia_gid = GLOBAL_ROOT_GID;			newattrs.ia_mode = stat.mode & ~0777;			newattrs.ia_valid =				ATTR_UID|ATTR_GID|ATTR_MODE;			mutex_lock(&dentry->d_inode->i_mutex);			notify_change(dentry, &newattrs, NULL);			mutex_unlock(&dentry->d_inode->i_mutex);			err = vfs_unlink(parent.dentry->d_inode, dentry, NULL);			if (!err || err == -ENOENT)				deleted = 1;		}	} else {		err = -ENOENT;	}	dput(dentry);	mutex_unlock(&parent.dentry->d_inode->i_mutex);	path_put(&parent);	if (deleted && strchr(nodename, '/'))		delete_path(nodename);	return err;}

int vfsub_update_h_iattr(struct path *h_path, int *did){	int err;	struct kstat st;	struct super_block *h_sb;	/* for remote fs, leave work for its getattr or d_revalidate */	/* for bad i_attr fs, handle them in aufs_getattr() */	/* still some fs may acquire i_mutex. we need to skip them */	err = 0;	if (!did)		did = &err;	h_sb = h_path->dentry->d_sb;	*did = (!au_test_fs_remote(h_sb) && au_test_fs_refresh_iattr(h_sb));	if (*did)		err = vfs_getattr(h_path->mnt, h_path->dentry, &st);	return err;}

/* Wrapper for vfs_getattr() to ensure we have the most * up-to-date inode info if working on a network filesystem. */int cr_fstat(cr_objectmap_t map, struct file *filp){    struct dentry *dentry = filp->f_dentry;    struct inode *inode = dentry->d_inode;    char *map_key = 1 + (char *)dentry;    int retval = 0;    if (!inode->i_op->getattr) {	/* Not a special fs, so trivially nothing to do */    } else if (map && cr_find_object(map, map_key, NULL)) {	/* Attrs up-to-date, so nothing to do */    } else {	struct kstat stat;	retval = vfs_getattr(filp->f_vfsmnt, dentry, &stat);	if (map && !retval) {	    cr_insert_object(map, map_key, (void *)1UL, GFP_KERNEL);	}    }    return retval;}

static struct dentry *ovl_clear_empty(struct dentry *dentry,				      struct list_head *list){	struct dentry *workdir = ovl_workdir(dentry);	struct inode *wdir = workdir->d_inode;	struct dentry *upperdir = ovl_dentry_upper(dentry->d_parent);	struct inode *udir = upperdir->d_inode;	struct path upperpath;	struct dentry *upper;	struct dentry *opaquedir;	struct kstat stat;	int err;	if (WARN_ON(!workdir))		return ERR_PTR(-EROFS);	err = ovl_lock_rename_workdir(workdir, upperdir);	if (err)		goto out;	ovl_path_upper(dentry, &upperpath);	err = vfs_getattr(&upperpath, &stat);	if (err)		goto out_unlock;	err = -ESTALE;	if (!S_ISDIR(stat.mode))		goto out_unlock;	upper = upperpath.dentry;	if (upper->d_parent->d_inode != udir)		goto out_unlock;	opaquedir = ovl_lookup_temp(workdir, dentry);	err = PTR_ERR(opaquedir);	if (IS_ERR(opaquedir))		goto out_unlock;	err = ovl_create_real(wdir, opaquedir,			      &(struct cattr){.mode = stat.mode}, NULL, true);