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

int vfsub_symlink(struct inode *dir, struct path *path, const char *symname){	int err;	struct dentry *d;	IMustLock(dir);	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_symlink(path, d, symname);	path->dentry = d;	if (unlikely(err))		goto out;	err = vfs_symlink(dir, path->dentry, symname);	if (!err) {		struct path tmp = *path;		int did;		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

int vfsub_mknod(struct inode *dir, struct path *path, int mode, dev_t dev){	int err;	struct dentry *d;	IMustLock(dir);	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_mknod(path, d, mode, new_encode_dev(dev));	path->dentry = d;	if (unlikely(err))		goto out;	err = vfs_mknod(dir, path->dentry, mode, dev);	if (!err) {		struct path tmp = *path;		int did;		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

int vfsub_create(struct inode *dir, struct path *path, int mode, bool want_excl){	int err;	struct dentry *d;	IMustLock(dir);	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_mknod(path, d, mode, 0);	path->dentry = d;	if (unlikely(err))		goto out;	lockdep_off();	err = vfs_create(dir, path->dentry, mode, want_excl);	lockdep_on();	if (!err) {		struct path tmp = *path;		int did;		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

int vfsub_create(struct inode *dir, struct path *path, int mode){	int err;	struct dentry *d;	IMustLock(dir);	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_mknod(path, d, mode, 0);	path->dentry = d;	if (unlikely(err))		goto out;	if (au_test_fs_null_nd(dir->i_sb))		err = vfs_create(dir, path->dentry, mode, NULL);	else {		struct nameidata h_nd;		memset(&h_nd, 0, sizeof(h_nd));		h_nd.flags = LOOKUP_CREATE;		h_nd.intent.open.flags = O_CREAT			| vfsub_fmode_to_uint(FMODE_READ);		h_nd.intent.open.create_mode = mode;		h_nd.path.dentry = path->dentry->d_parent;		h_nd.path.mnt = path->mnt;		path_get(&h_nd.path);		err = vfs_create(dir, path->dentry, mode, &h_nd);		path_put(&h_nd.path);	}	if (!err) {		struct path tmp = *path;		int did;		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

int vfsub_rmdir(struct inode *dir, struct path *path){	int err;	struct dentry *d;	IMustLock(dir);	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_rmdir(path, d);	path->dentry = d;	if (unlikely(err))		goto out;	lockdep_off();	err = vfs_rmdir(dir, path->dentry);	lockdep_on();	if (!err) {		struct path tmp = {			.dentry	= path->dentry->d_parent,			.mnt	= path->mnt		};		vfsub_update_h_iattr(&tmp, /*did*/NULL); /*ignore*/	}out:	return err;}/* ---------------------------------------------------------------------- *//* todo: support mmap_sem? */ssize_t vfsub_read_u(struct file *file, char __user *ubuf, size_t count,		     loff_t *ppos){	ssize_t err;	lockdep_off();	err = vfs_read(file, ubuf, count, ppos);	lockdep_on();	if (err >= 0)		vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/	return err;}

int vfsub_readdir(struct file *file, filldir_t filldir, void *arg){	int err;	err = vfs_readdir(file, filldir, arg);	if (err >= 0)		vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/	return err;}

int vfsub_kern_path(const char *name, unsigned int flags, struct path *path){	int err;	err = kern_path(name, flags, path);	if (!err && path->dentry->d_inode)		vfsub_update_h_iattr(path, /*did*/NULL); /*ignore*/	return err;}

long vfsub_splice_from(struct pipe_inode_info *pipe, struct file *out,		       loff_t *ppos, size_t len, unsigned int flags){	long err;	err = do_splice_from(pipe, out, ppos, len, flags);	if (err >= 0)		vfsub_update_h_iattr(&out->f_path, /*did*/NULL); /*ignore*/	return err;}

ssize_t vfsub_write_u(struct file *file, const char __user *ubuf, size_t count,		      loff_t *ppos){	ssize_t err;	err = vfs_write(file, ubuf, count, ppos);	if (err >= 0)		vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/	return err;}

int vfsub_link(struct dentry *src_dentry, struct inode *dir, struct path *path,	       struct inode **delegated_inode){	int err;	struct dentry *d;	IMustLock(dir);	err = au_test_nlink(d_inode(src_dentry));	if (unlikely(err))		return err;	/* we don't call may_linkat() */	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_link(src_dentry, path, d);	path->dentry = d;	if (unlikely(err))		goto out;	lockdep_off();	err = vfs_link(src_dentry, dir, path->dentry, delegated_inode);	lockdep_on();	if (!err) {		struct path tmp = *path;		int did;		/* fuse has different memory inode for the same inumber */		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);			tmp.dentry = src_dentry;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

struct file *vfsub_filp_open(const char *path, int oflags, int mode){	struct file *file;	file = filp_open(path, oflags, mode);	if (IS_ERR(file))		goto out;	vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/out:	return file;}

long vfsub_splice_to(struct file *in, loff_t *ppos,		     struct pipe_inode_info *pipe, size_t len,		     unsigned int flags){	long err;	err = do_splice_to(in, ppos, pipe, len, flags);	file_accessed(in);	if (err >= 0)		vfsub_update_h_iattr(&in->f_path, /*did*/NULL); /*ignore*/	return err;}

int vfsub_iterate_dir(struct file *file, struct dir_context *ctx){	int err;	AuDbg("%pD, ctx{%pf, %llu}/n", file, ctx->actor, ctx->pos);	lockdep_off();	err = iterate_dir(file, ctx);	lockdep_on();	if (err >= 0)		vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/	return err;}

int vfsub_flush(struct file *file, fl_owner_t id){	int err;	err = 0;	if (file->f_op && file->f_op->flush) {		err = file->f_op->flush(file, id);		if (!err)			vfsub_update_h_iattr(&file->f_path, /*did*/NULL);		/*ignore*/	}	return err;}

struct file *vfsub_filp_open(const char *path, int oflags, int mode){	struct file *file;	lockdep_off();	file = filp_open(path,			 oflags /* | __FMODE_NONOTIFY */,			 mode);	lockdep_on();	if (IS_ERR(file))		goto out;	vfsub_update_h_iattr(&file->f_path, /*did*/NULL); /*ignore*/out:	return file;}

static void call_notify_change(void *args){	struct notify_change_args *a = args;	struct inode *h_inode;	h_inode = a->path->dentry->d_inode;	IMustLock(h_inode);	*a->errp = -EPERM;	if (!IS_IMMUTABLE(h_inode) && !IS_APPEND(h_inode)) {		*a->errp = notify_change(a->path->dentry, a->ia);		if (!*a->errp)			vfsub_update_h_iattr(a->path, /*did*/NULL); /*ignore*/	}	AuTraceErr(*a->errp);}

struct dentry *vfsub_lookup_hash(struct nameidata *nd){	struct path path = {		.mnt = nd->path.mnt	};	IMustLock(nd->path.dentry->d_inode);	path.dentry = lookup_hash(nd);	if (IS_ERR(path.dentry))		goto out;	if (path.dentry->d_inode)		vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/ out:	AuTraceErrPtr(path.dentry);	return path.dentry;}/* ---------------------------------------------------------------------- */struct dentry *vfsub_lock_rename(struct dentry *d1, struct au_hinode *hdir1,				 struct dentry *d2, struct au_hinode *hdir2){	struct dentry *d;	lockdep_off();	d = lock_rename(d1, d2);	lockdep_on();	au_hn_suspend(hdir1);	if (hdir1 != hdir2)		au_hn_suspend(hdir2);	return d;}void vfsub_unlock_rename(struct dentry *d1, struct au_hinode *hdir1,			 struct dentry *d2, struct au_hinode *hdir2){	au_hn_resume(hdir1);	if (hdir1 != hdir2)		au_hn_resume(hdir2);	lockdep_off();	unlock_rename(d1, d2);	lockdep_on();}

int vfsub_fsync(struct file *file, struct path *path, int datasync){	int err;	/* file can be NULL */	lockdep_off();	err = vfs_fsync(file, datasync);	lockdep_on();	if (!err) {		if (!path) {			AuDebugOn(!file);			path = &file->f_path;		}		vfsub_update_h_iattr(path, /*did*/NULL); /*ignore*/	}	return err;}

struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent,				    int len){	struct path path = {		.mnt = NULL	};	IMustLock(parent->d_inode);	path.dentry = lookup_one_len(name, parent, len);	if (IS_ERR(path.dentry))		goto out;	if (path.dentry->d_inode)		vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/out:	AuTraceErrPtr(path.dentry);	return path.dentry;}

int vfsub_flush(struct file *file, fl_owner_t id){	int err;	err = 0;	if (file->f_op && file->f_op->flush) {		if (!au_test_nfs(file->f_dentry->d_sb))			err = file->f_op->flush(file, id);		else {			lockdep_off();			err = file->f_op->flush(file, id);			lockdep_on();		}		if (!err)			vfsub_update_h_iattr(&file->f_path, /*did*/NULL);		/*ignore*/	}	return err;}

struct dentry *vfsub_lookup_one_len(const char *name, struct dentry *parent,				    int len){	struct path path = {		.mnt = NULL	};	/* VFS checks it too, but by WARN_ON_ONCE() */	IMustLock(d_inode(parent));	path.dentry = lookup_one_len(name, parent, len);	if (IS_ERR(path.dentry))		goto out;	if (d_is_positive(path.dentry))		vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/out:	AuTraceErrPtr(path.dentry);	return path.dentry;}

/* * when an error happened, remove the created whiteout and revert everything. */static int do_revert(int err, struct inode *dir, aufs_bindex_t bindex,		     aufs_bindex_t bwh, struct dentry *wh_dentry,		     struct dentry *dentry, struct au_dtime *dt){	int rerr;	struct path h_path = {		.dentry	= wh_dentry,		.mnt	= au_sbr_mnt(dir->i_sb, bindex)	};	rerr = au_wh_unlink_dentry(au_h_iptr(dir, bindex), &h_path, dentry);	if (!rerr) {		au_set_dbwh(dentry, bwh);		au_dtime_revert(dt);		return 0;	}	AuIOErr("%pd reverting whiteout failed(%d, %d)/n", dentry, err, rerr);	return -EIO;}/* ---------------------------------------------------------------------- */int aufs_unlink(struct inode *dir, struct dentry *dentry){	int err;	aufs_bindex_t bwh, bindex, bstart;	struct inode *inode, *h_dir, *delegated;	struct dentry *parent, *wh_dentry;	/* to reuduce stack size */	struct {		struct au_dtime dt;		struct au_pin pin;		struct path h_path;	} *a;	IMustLock(dir);	err = -ENOMEM;	a = kmalloc(sizeof(*a), GFP_NOFS);	if (unlikely(!a))		goto out;	err = aufs_read_lock(dentry, AuLock_DW | AuLock_GEN);	if (unlikely(err))		goto out_free;	err = au_d_hashed_positive(dentry);	if (unlikely(err))		goto out_unlock;	inode = d_inode(dentry);	IMustLock(inode);	err = -EISDIR;	if (unlikely(d_is_dir(dentry)))		goto out_unlock; /* possible? */	bstart = au_dbstart(dentry);	bwh = au_dbwh(dentry);	bindex = -1;	parent = dentry->d_parent; /* dir inode is locked */	di_write_lock_parent(parent);	wh_dentry = lock_hdir_create_wh(dentry, /*isdir*/0, &bindex, &a->dt,					&a->pin);	err = PTR_ERR(wh_dentry);	if (IS_ERR(wh_dentry))		goto out_parent;	a->h_path.mnt = au_sbr_mnt(dentry->d_sb, bstart);	a->h_path.dentry = au_h_dptr(dentry, bstart);	dget(a->h_path.dentry);	if (bindex == bstart) {		h_dir = au_pinned_h_dir(&a->pin);		delegated = NULL;		err = vfsub_unlink(h_dir, &a->h_path, &delegated, /*force*/0);		if (unlikely(err == -EWOULDBLOCK)) {			pr_warn("cannot retry for NFSv4 delegation"				" for an internal unlink/n");			iput(delegated);		}	} else {		/* dir inode is locked */		h_dir = d_inode(wh_dentry->d_parent);		IMustLock(h_dir);		err = 0;	}	if (!err) {		vfsub_drop_nlink(inode);		epilog(dir, dentry, bindex);		/* update target timestamps */		if (bindex == bstart) {			vfsub_update_h_iattr(&a->h_path, /*did*/NULL);			/*ignore*/			inode->i_ctime = d_inode(a->h_path.dentry)->i_ctime;		} else			/* todo: this timestamp may be reverted later */			inode->i_ctime = h_dir->i_ctime;//.........这里部分代码省略.........

int vfsub_rename(struct inode *src_dir, struct dentry *src_dentry,		 struct inode *dir, struct path *path){	int err;	struct path tmp = {		.mnt	= path->mnt	};	struct dentry *d;	IMustLock(dir);	IMustLock(src_dir);	d = path->dentry;	path->dentry = d->d_parent;	tmp.dentry = src_dentry->d_parent;	err = security_path_rename(&tmp, src_dentry, path, d);	path->dentry = d;	if (unlikely(err))		goto out;	lockdep_off();	err = vfs_rename(src_dir, src_dentry, dir, path->dentry);	lockdep_on();	if (!err) {		int did;		tmp.dentry = d->d_parent;		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = src_dentry;			vfsub_update_h_iattr(&tmp, /*did*/NULL);			tmp.dentry = src_dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}int vfsub_mkdir(struct inode *dir, struct path *path, int mode){	int err;	struct dentry *d;	IMustLock(dir);	d = path->dentry;	path->dentry = d->d_parent;	err = security_path_mkdir(path, d, mode);	path->dentry = d;	if (unlikely(err))		goto out;	err = vfs_mkdir(dir, path->dentry, mode);	if (!err) {		struct path tmp = *path;		int did;		vfsub_update_h_iattr(&tmp, &did);		if (did) {			tmp.dentry = path->dentry->d_parent;			vfsub_update_h_iattr(&tmp, /*did*/NULL);		}		/*ignore*/	}out:	return err;}

static int do_rename(struct au_ren_args *a){	int err;	struct dentry *d, *h_d;	/* prepare workqueue args for asynchronous rmdir */	h_d = a->dst_h_dentry;	if (au_ftest_ren(a->flags, ISDIR) && h_d->d_inode) {		err = -ENOMEM;		a->thargs = au_whtmp_rmdir_alloc(a->src_dentry->d_sb, GFP_NOFS);		if (unlikely(!a->thargs))			goto out;		a->h_dst = dget(h_d);	}	/* create whiteout for src_dentry */	if (au_ftest_ren(a->flags, WHSRC)) {		a->src_bwh = au_dbwh(a->src_dentry);		AuDebugOn(a->src_bwh >= 0);		a->src_wh_dentry			= au_wh_create(a->src_dentry, a->btgt, a->src_h_parent);		err = PTR_ERR(a->src_wh_dentry);		if (IS_ERR(a->src_wh_dentry))			goto out_thargs;	}	/* lookup whiteout for dentry */	if (au_ftest_ren(a->flags, WHDST)) {		h_d = au_wh_lkup(a->dst_h_parent, &a->dst_dentry->d_name,				 a->br);		err = PTR_ERR(h_d);		if (IS_ERR(h_d))			goto out_whsrc;		if (!h_d->d_inode)			dput(h_d);		else			a->dst_wh_dentry = h_d;	}	/* rename dentry to tmpwh */	if (a->thargs) {		err = au_whtmp_ren(a->dst_h_dentry, a->br);		if (unlikely(err))			goto out_whdst;		d = a->dst_dentry;		au_set_h_dptr(d, a->btgt, NULL);		err = au_lkup_neg(d, a->btgt);		if (unlikely(err))			goto out_whtmp;		a->dst_h_dentry = au_h_dptr(d, a->btgt);	}	/* cpup src */	if (a->dst_h_dentry->d_inode && a->src_bstart != a->btgt) {		struct mutex *h_mtx = &a->src_h_dentry->d_inode->i_mutex;		struct file *h_file;		mutex_lock_nested(h_mtx, AuLsc_I_CHILD);		AuDebugOn(au_dbstart(a->src_dentry) != a->src_bstart);		h_file = au_h_open_pre(a->src_dentry, a->src_bstart);		if (IS_ERR(h_file)) {			err = PTR_ERR(h_file);			h_file = NULL;		} else			err = au_sio_cpup_simple(a->src_dentry, a->btgt, -1,						 !AuCpup_DTIME);		mutex_unlock(h_mtx);		au_h_open_post(a->src_dentry, a->src_bstart, h_file);		if (unlikely(err))			goto out_whtmp;	}	/* rename by vfs_rename or cpup */	d = a->dst_dentry;	if (au_ftest_ren(a->flags, ISDIR)	    && (a->dst_wh_dentry		|| au_dbdiropq(d) == a->btgt		/* hide the lower to keep xino */		|| a->btgt < au_dbend(d)		|| au_opt_test(au_mntflags(d->d_sb), ALWAYS_DIROPQ)))		au_fset_ren(a->flags, DIROPQ);	err = au_ren_or_cpup(a);	if (unlikely(err))		/* leave the copied-up one */		goto out_whtmp;	/* make dir opaque */	if (au_ftest_ren(a->flags, DIROPQ)) {		err = au_ren_diropq(a);		if (unlikely(err))			goto out_rename;	}	/* update target timestamps */	AuDebugOn(au_dbstart(a->src_dentry) != a->btgt);	a->h_path.dentry = au_h_dptr(a->src_dentry, a->btgt);	vfsub_update_h_iattr(&a->h_path, /*did*/NULL); /*ignore*/	a->src_inode->i_ctime = a->h_path.dentry->d_inode->i_ctime;//.........这里部分代码省略.........

struct dentry *vfsub_lookup_hash(struct nameidata *nd){	struct path path = {		.mnt = nd->path.mnt	};	IMustLock(nd->path.dentry->d_inode);	path.dentry = lookup_hash(nd);	if (IS_ERR(path.dentry))		goto out;	if (path.dentry->d_inode)		vfsub_update_h_iattr(&path, /*did*/NULL); /*ignore*/out:	AuTraceErrPtr(path.dentry);	return path.dentry;}/* * this is "VFS:__lookup_one_len()" which was removed and merged into * VFS:lookup_one_len() by the commit. *	6a96ba5 2011-03-14 kill __lookup_one_len() * this function should always be equivalent to the corresponding part in * VFS:lookup_one_len(). */int vfsub_name_hash(const char *name, struct qstr *this, int len){	unsigned int c;	this->name = name;	this->len = len;	this->hash = full_name_hash(name, len);	if (!len)		return -EACCES;	while (len--) {		c = *(const unsigned char *)name++;		if (c == '/' || c == '/0')			return -EACCES;	}	return 0;}/* ---------------------------------------------------------------------- */struct dentry *vfsub_lock_rename(struct dentry *d1, struct au_hinode *hdir1,				 struct dentry *d2, struct au_hinode *hdir2){	struct dentry *d;	lockdep_off();	d = lock_rename(d1, d2);	lockdep_on();	au_hn_suspend(hdir1);	if (hdir1 != hdir2)		au_hn_suspend(hdir2);	return d;}void vfsub_unlock_rename(struct dentry *d1, struct au_hinode *hdir1,			 struct dentry *d2, struct au_hinode *hdir2){	au_hn_resume(hdir1);	if (hdir1 != hdir2)		au_hn_resume(hdir2);	lockdep_off();	unlock_rename(d1, d2);	lockdep_on();}