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

/* * The locking rules in wrapfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int wrapfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct path lower_old_path, lower_new_path;	wrapfs_get_lower_path(old_dentry, &lower_old_path);	wrapfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry,			 NULL, 0);	if (err)		goto out;	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir,				      lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir,					lower_old_dir_dentry->d_inode);	}out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	wrapfs_put_lower_path(old_dentry, &lower_old_path);	wrapfs_put_lower_path(new_dentry, &lower_new_path);#ifdef NEKTECH_LOGGER /*NEKTECH LOGGING*/            nektech_logger (new_dir, new_dentry, NEKTECH_RENAME);#endif          /*NEKTECH LOGGING*/	return err;}

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();}

/* Workdir should not be subdir of upperdir and vice versa */static bool ovl_workdir_ok(struct dentry *workdir, struct dentry *upperdir){	bool ok = false;	if (workdir != upperdir) {		ok = (lock_rename(workdir, upperdir) == NULL);		unlock_rename(workdir, upperdir);	}	return ok;}

static intecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,		struct inode *new_dir, struct dentry *new_dentry){	int rc;	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_old_dir_dentry;	struct dentry *lower_new_dir_dentry;	struct dentry *trap = NULL;	struct inode *target_inode;#ifdef CONFIG_SDP	if(IS_CHAMBER_DENTRY(old_dentry)) {		printk("You're renaming chamber directory. I/O error/n");		return -EIO;	}#endif	lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);	lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);	dget(lower_old_dentry);	dget(lower_new_dentry);	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	target_inode = new_dentry->d_inode;	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		rc = -EINVAL;		goto out_lock;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		rc = -ENOTEMPTY;		goto out_lock;	}	rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			lower_new_dir_dentry->d_inode, lower_new_dentry);	if (rc)		goto out_lock;	if (target_inode)		fsstack_copy_attr_all(target_inode,				      ecryptfs_inode_to_lower(target_inode));	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir)		fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);out_lock:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dentry);	dput(lower_old_dentry);	return rc;}

/** * debugfs_rename - rename a file/directory in the debugfs filesystem * @old_dir: a pointer to the parent dentry for the renamed object. This *          should be a directory dentry. * @old_dentry: dentry of an object to be renamed. * @new_dir: a pointer to the parent dentry where the object should be *          moved. This should be a directory dentry. * @new_name: a pointer to a string containing the target name. * * This function renames a file/directory in debugfs.  The target must not * exist for rename to succeed. * * This function will return a pointer to old_dentry (which is updated to * reflect renaming) if it succeeds. If an error occurs, %NULL will be * returned. * * If debugfs is not enabled in the kernel, the value -%ENODEV will be * returned. */struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,		struct dentry *new_dir, const char *new_name){	int error;	struct dentry *dentry = NULL, *trap;	const char *old_name;	trap = lock_rename(new_dir, old_dir);	/* Source or destination directories don't exist? */	if (!old_dir->d_inode || !new_dir->d_inode)		goto exit;	/* Source does not exist, cyclic rename, or mountpoint? */	if (!old_dentry->d_inode || old_dentry == trap ||	    d_mountpoint(old_dentry))		goto exit;	dentry = lookup_one_len(new_name, new_dir, strlen(new_name));	/* Lookup failed, cyclic rename or target exists? */	if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)		goto exit;	old_name = fsnotify_oldname_init(old_dentry->d_name.name);	error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,		dentry);	if (error) {		fsnotify_oldname_free(old_name);		goto exit;	}	d_move(old_dentry, dentry);	fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,		old_dentry->d_name.name, S_ISDIR(old_dentry->d_inode->i_mode),		NULL, old_dentry);	fsnotify_oldname_free(old_name);	unlock_rename(new_dir, old_dir);	dput(dentry);	return old_dentry;exit:	if (dentry && !IS_ERR(dentry))		dput(dentry);	unlock_rename(new_dir, old_dir);	return NULL;}

static intecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,		struct inode *new_dir, struct dentry *new_dentry,		unsigned int flags){	int rc;	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_old_dir_dentry;	struct dentry *lower_new_dir_dentry;	struct dentry *trap = NULL;	struct inode *target_inode;	if (flags)		return -EINVAL;	lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);	lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);	dget(lower_old_dentry);	dget(lower_new_dentry);	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	target_inode = d_inode(new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		rc = -EINVAL;		goto out_lock;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		rc = -ENOTEMPTY;		goto out_lock;	}	rc = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,			d_inode(lower_new_dir_dentry), lower_new_dentry,			NULL, 0);	if (rc)		goto out_lock;	if (target_inode)		fsstack_copy_attr_all(target_inode,				      ecryptfs_inode_to_lower(target_inode));	fsstack_copy_attr_all(new_dir, d_inode(lower_new_dir_dentry));	if (new_dir != old_dir)		fsstack_copy_attr_all(old_dir, d_inode(lower_old_dir_dentry));out_lock:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dentry);	dput(lower_old_dentry);	return rc;}

/* * The locking rules in diaryfs_rename are complex. We could use a simpler * superblock level namespace lock for renames and copy-ups  */static int diaryfs_rename(struct inode * old_dir, struct dentry * old_dentry,			struct inode * new_dir, struct dentry * new_dentry) {	int err = 0; 	struct dentry * lower_old_dentry = NULL;	struct dentry * lower_new_dentry = NULL;	struct dentry * lower_old_dir_dentry = NULL; 	struct dentry * lower_new_dir_dentry = NULL; 	struct dentry * trap = NULL;	struct path lower_old_path, lower_new_path; 	diaryfs_get_lower_path(old_dentry, &lower_old_path); 	diaryfs_get_lower_path(new_dentry, &lower_new_path); 	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry; 	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry); 	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of the target */ 	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -EINVAL;		goto out; 	} err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry, lower_new_dir_dentry->d_inode, lower_new_dentry, NULL, 0);	if (err)		goto out;	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir, 				lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir,				lower_old_dir_dentry->d_inode);	}out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	diaryfs_put_lower_path(old_dentry, &lower_old_path);	diaryfs_put_lower_path(new_dentry, &lower_new_path);	return err;}

static int rename_temp_file(struct file *fp_old, struct file *fp_new){	int rc;	struct inode *pi_old = fp_old->f_path.dentry->d_parent->d_inode;	struct inode *pi_new = fp_new->f_path.dentry->d_parent->d_inode;		struct dentry *d_old = fp_old->f_path.dentry;	struct dentry *d_new = fp_new->f_path.dentry;		struct dentry *pd_old = NULL;	struct dentry *pd_new = NULL;	struct dentry *trap = NULL;		dget(d_old);	dget(d_new);	pd_old=dget_parent(d_old);	pd_new=dget_parent(d_new);	trap = lock_rename(pd_old,pd_new);	if(trap == d_old){		rc = -EINVAL;		goto out;	}	if(trap == d_new){		rc = -ENOTEMPTY;		goto out;	}	rc = vfs_rename(pi_old,d_old,pi_new,d_new,NULL,0);	if(rc){		printk("Error in vfs_rename() /n");		rc= -ECANCELED;		goto out;	}out:	unlock_rename(pd_old,pd_new);	dput(pd_new);	dput(pd_old);	dput(d_new);	dput(d_old);		return rc;}

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();}

static intecryptfs_rename(struct inode *old_dir, struct dentry *old_dentry,		struct inode *new_dir, struct dentry *new_dentry){	int rc;	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_old_dir_dentry;	struct dentry *lower_new_dir_dentry;	struct dentry *trap = NULL;	if (new_dentry->d_inode && S_ISDIR(new_dentry->d_inode->i_mode))		dentry_unhash(new_dentry);	lower_old_dentry = ecryptfs_dentry_to_lower(old_dentry);	lower_new_dentry = ecryptfs_dentry_to_lower(new_dentry);	dget(lower_old_dentry);	dget(lower_new_dentry);	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		rc = -EINVAL;		goto out_lock;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		rc = -ENOTEMPTY;		goto out_lock;	}	rc = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			lower_new_dir_dentry->d_inode, lower_new_dentry);	if (rc)		goto out_lock;	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir)		fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);out_lock:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dentry);	dput(lower_old_dentry);	return rc;}

STATIC intbase0fs_rename(inode_t *old_dir, struct dentry *old_dentry,              inode_t *new_dir, struct dentry *new_dentry){        int err;        struct dentry *lower_old_dentry;        struct dentry *lower_new_dentry;        struct dentry *lower_old_dir_dentry;        struct dentry *lower_new_dir_dentry;        print_entry_location();        lower_old_dentry = base0fs_lower_dentry(old_dentry);/* CPW: Moved below print_entry_location */        lower_new_dentry = base0fs_lower_dentry(new_dentry);        fist_checkinode(old_dir, "base0fs_rename-old_dir");        fist_checkinode(new_dir, "base0fs_rename-new_dir");        dget(lower_old_dentry);        dget(lower_new_dentry);        lower_old_dir_dentry = dget_parent(lower_old_dentry);        lower_new_dir_dentry = dget_parent(lower_new_dentry);        lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);        err = VFS_RENAME(lower_old_dir_dentry->d_inode, lower_old_dentry,                         lower_new_dir_dentry->d_inode, lower_new_dentry);        if (err)                goto out_lock;        fist_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);        if (new_dir != old_dir)                fist_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);out_lock:        // unlock_rename will dput the new/old parent dentries whose refcnts        // were incremented via dget_parent above.        dput(lower_new_dentry);        dput(lower_old_dentry);        unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);        fist_checkinode(new_dir, "post base0fs_rename-new_dir");        print_exit_status(err);        return err;}

static int ovl_lock_rename_workdir(struct dentry *workdir,				   struct dentry *upperdir){	/* Workdir should not be the same as upperdir */	if (workdir == upperdir)		goto err;	/* Workdir should not be subdir of upperdir and vice versa */	if (lock_rename(workdir, upperdir) != NULL)		goto err_unlock;	return 0;err_unlock:	unlock_rename(workdir, upperdir);err:	pr_err("overlayfs: failed to lock workdir+upperdir/n");	return -EIO;}

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,			  STATX_BASIC_STATS, AT_STATX_SYNC_AS_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_create_temp(workdir, OVL_CATTR(stat.mode));	err = PTR_ERR(opaquedir);	if (IS_ERR(opaquedir))		goto out_unlock;	err = ovl_copy_xattr(upper, opaquedir);	if (err)		goto out_cleanup;	err = ovl_set_opaque(dentry, opaquedir);	if (err)		goto out_cleanup;	inode_lock(opaquedir->d_inode);	err = ovl_set_attr(opaquedir, &stat);	inode_unlock(opaquedir->d_inode);	if (err)		goto out_cleanup;	err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);	if (err)		goto out_cleanup;	ovl_cleanup_whiteouts(upper, list);	ovl_cleanup(wdir, upper);	unlock_rename(workdir, upperdir);	/* dentry's upper doesn't match now, get rid of it */	d_drop(dentry);	return opaquedir;out_cleanup:	ovl_cleanup(wdir, opaquedir);	dput(opaquedir);out_unlock:	unlock_rename(workdir, upperdir);out:	return ERR_PTR(err);}

/* * The locking rules in wrapfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int wrapfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct path lower_old_path, lower_new_path;	wrapfs_get_lower_path(old_dentry, &lower_old_path);	wrapfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = mnt_want_write(lower_old_path.mnt);	if (err)		goto out;	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_drop_old_write;	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry);	if (err)		goto out_err;	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir,				      lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir,					lower_old_dir_dentry->d_inode);	}out_err:	mnt_drop_write(lower_new_path.mnt);out_drop_old_write:	mnt_drop_write(lower_old_path.mnt);out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	wrapfs_put_lower_path(old_dentry, &lower_old_path);	wrapfs_put_lower_path(new_dentry, &lower_new_path);	return err;}

static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,				    struct kstat *stat, const char *link,				    struct dentry *hardlink){	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 dentry *upper;	struct dentry *newdentry;	int err;	if (WARN_ON(!workdir))		return -EROFS;	err = ovl_lock_rename_workdir(workdir, upperdir);	if (err)		goto out;	newdentry = ovl_lookup_temp(workdir, dentry);	err = PTR_ERR(newdentry);	if (IS_ERR(newdentry))		goto out_unlock;	upper = lookup_one_len(dentry->d_name.name, upperdir,			       dentry->d_name.len);	err = PTR_ERR(upper);	if (IS_ERR(upper))		goto out_dput;	err = ovl_create_real(wdir, newdentry, stat, link, hardlink, true);	if (err)		goto out_dput2;	if (S_ISDIR(stat->mode)) {		err = ovl_set_opaque(newdentry);		if (err)			goto out_cleanup;		err = ovl_do_rename(wdir, newdentry, udir, upper,				    RENAME_EXCHANGE);		if (err)			goto out_cleanup;		ovl_cleanup(wdir, upper);	} else {		err = ovl_do_rename(wdir, newdentry, udir, upper, 0);		if (err)			goto out_cleanup;	}	ovl_dentry_version_inc(dentry->d_parent);	ovl_dentry_update(dentry, newdentry);	ovl_copyattr(newdentry->d_inode, inode);	d_instantiate(dentry, inode);	newdentry = NULL;out_dput2:	dput(upper);out_dput:	dput(newdentry);out_unlock:	unlock_rename(workdir, upperdir);out:	return err;out_cleanup:	ovl_cleanup(wdir, newdentry);	goto out_dput2;}

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;	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, &stat, NULL, NULL, true);	if (err)		goto out_dput;	err = ovl_copy_xattr(upper, opaquedir);	if (err)		goto out_cleanup;	err = ovl_set_opaque(opaquedir);	if (err)		goto out_cleanup;	mutex_lock(&opaquedir->d_inode->i_mutex);	err = ovl_set_attr(opaquedir, &stat);	mutex_unlock(&opaquedir->d_inode->i_mutex);	if (err)		goto out_cleanup;	err = ovl_do_rename(wdir, opaquedir, udir, upper, RENAME_EXCHANGE);	if (err)		goto out_cleanup;	ovl_cleanup_whiteouts(upper, list);	ovl_cleanup(wdir, upper);	unlock_rename(workdir, upperdir);	/* dentry's upper doesn't match now, get rid of it */	d_drop(dentry);	return opaquedir;out_cleanup:	ovl_cleanup(wdir, opaquedir);out_dput:	dput(opaquedir);out_unlock:	unlock_rename(workdir, upperdir);out:	return ERR_PTR(err);}

//.........这里部分代码省略.........	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct dentry *ret = NULL;	struct path lower_old_path, lower_new_path;		/* creating parent directories if destination is read-only */	if((U2FS_D(old_dentry)->lower_path[LEFT].dentry) == NULL && 		(U2FS_D(old_dentry)->lower_path[LEFT].mnt) == NULL){		err = create_whiteout(old_dentry);			if(err){			err = -EIO;			goto out_copyup;		}		err = copyup_dentry(old_dir, old_dentry,			  old_dentry->d_name.name, old_dentry->d_name.len,			  NULL, i_size_read(old_dentry->d_inode));		if(err)			goto out_copyup;	}		if((U2FS_D(new_dentry)->lower_path[LEFT].dentry) == NULL && 		(U2FS_D(new_dentry)->lower_path[LEFT].mnt) == NULL){		ret = create_parents(new_dir, new_dentry, 					new_dentry->d_name.name);		if (!ret || IS_ERR(ret)) {					err = PTR_ERR(ret);					if (!IS_COPYUP_ERR(err))						printk(KERN_ERR					      	 "u2fs: create_parents for "				     		  "u2fs_rename failed"					      	 "err=%d/n", err);					goto out_copyup;		}		u2fs_postcopyup_setmnt(new_dentry);		u2fs_put_reset_lower_path(new_dentry, RIGHT);				if(err)			goto out_copyup;	}		u2fs_get_lower_path(old_dentry, &lower_old_path, LEFT);	u2fs_get_lower_path(new_dentry, &lower_new_path, LEFT);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = mnt_want_write(lower_old_path.mnt);	if (err)		goto out;	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_drop_old_write;	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry);	if (err)		goto out_err;	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir,				      lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir,					lower_old_dir_dentry->d_inode);	}out_err:	mnt_drop_write(lower_new_path.mnt);out_drop_old_write:	mnt_drop_write(lower_old_path.mnt);out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	u2fs_put_lower_path(old_dentry, &lower_old_path);	u2fs_put_lower_path(new_dentry, &lower_new_path);out_copyup:	return err;}

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();}

static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,				    struct kstat *stat, const char *link,				    struct dentry *hardlink){	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 dentry *upper;	struct dentry *newdentry;	int err;	struct posix_acl *acl, *default_acl;	if (WARN_ON(!workdir))		return -EROFS;	if (!hardlink) {		err = posix_acl_create(dentry->d_parent->d_inode,				       &stat->mode, &default_acl, &acl);		if (err)			return err;	}	err = ovl_lock_rename_workdir(workdir, upperdir);	if (err)		goto out;	newdentry = ovl_lookup_temp(workdir, dentry);	err = PTR_ERR(newdentry);	if (IS_ERR(newdentry))		goto out_unlock;	upper = lookup_one_len(dentry->d_name.name, upperdir,			       dentry->d_name.len);	err = PTR_ERR(upper);	if (IS_ERR(upper))		goto out_dput;	err = ovl_create_real(wdir, newdentry, stat, link, hardlink, true);	if (err)		goto out_dput2;	/*	 * mode could have been mutilated due to umask (e.g. sgid directory)	 */	if (!hardlink &&	    !S_ISLNK(stat->mode) && newdentry->d_inode->i_mode != stat->mode) {		struct iattr attr = {			.ia_valid = ATTR_MODE,			.ia_mode = stat->mode,		};		inode_lock(newdentry->d_inode);		err = notify_change(newdentry, &attr, NULL);		inode_unlock(newdentry->d_inode);		if (err)			goto out_cleanup;	}	if (!hardlink) {		err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,					acl);		if (err)			goto out_cleanup;		err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,					default_acl);		if (err)			goto out_cleanup;	}	if (!hardlink && S_ISDIR(stat->mode)) {		err = ovl_set_opaque(newdentry);		if (err)			goto out_cleanup;		err = ovl_do_rename(wdir, newdentry, udir, upper,				    RENAME_EXCHANGE);		if (err)			goto out_cleanup;		ovl_cleanup(wdir, upper);	} else {		err = ovl_do_rename(wdir, newdentry, udir, upper, 0);		if (err)			goto out_cleanup;	}	ovl_instantiate(dentry, inode, newdentry, !!hardlink);	newdentry = NULL;out_dput2:	dput(upper);out_dput:	dput(newdentry);out_unlock:	unlock_rename(workdir, upperdir);out:	if (!hardlink) {		posix_acl_release(acl);		posix_acl_release(default_acl);	}	return err;//.........这里部分代码省略.........

/* * The locking rules in sdcardfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct dentry *new_parent = NULL;	struct path lower_old_path, lower_new_path;	struct sdcardfs_sb_info *sbi = SDCARDFS_SB(old_dentry->d_sb);	const struct cred *saved_cred = NULL;	int has_rw = get_caller_has_rw_locked(sbi->pkgl_id, sbi->options.derive);	if(!check_caller_access_to_name(old_dir, old_dentry->d_name.name,			sbi->options.derive, 1, has_rw) ||		!check_caller_access_to_name(new_dir, new_dentry->d_name.name,			sbi->options.derive, 1, has_rw)) {		err = -EACCES;		goto out_eacces;	}	/* save current_cred and override it */	OVERRIDE_CRED(SDCARDFS_SB(old_dir->i_sb), saved_cred);	sdcardfs_get_real_lower(old_dentry, &lower_old_path);	sdcardfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = mnt_want_write(lower_old_path.mnt);	if (err)		goto out;	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_drop_old_write;	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry);	if (err)		goto out_err;	/* Copy attrs from lower dir, but i_uid/i_gid */	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	fix_derived_permission(new_dir); 	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir, lower_old_dir_dentry->d_inode);		fix_derived_permission(old_dir);		/* update the derived permission of the old_dentry		 * with its new parent		 */		new_parent = dget_parent(new_dentry);		if(new_parent) {			if(old_dentry->d_inode) {				get_derived_permission(new_parent, old_dentry);				fix_derived_permission(old_dentry->d_inode);			}			dput(new_parent);		}	}out_err:	mnt_drop_write(lower_new_path.mnt);out_drop_old_write:	mnt_drop_write(lower_old_path.mnt);out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	sdcardfs_put_real_lower(old_dentry, &lower_old_path);	sdcardfs_put_lower_path(new_dentry, &lower_new_path);	REVERT_CRED(saved_cred);out_eacces:	return err;}

/* * The locking rules in sdcardfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct dentry *new_parent = NULL;	struct path lower_old_path, lower_new_path;	const struct cred *saved_cred = NULL;	if(!check_caller_access_to_name(old_dir, old_dentry->d_name.name) ||		!check_caller_access_to_name(new_dir, new_dentry->d_name.name)) {		printk(KERN_INFO "%s: need to check the caller's gid in packages.list/n" 						 "  new_dentry: %s, task:%s/n",						 __func__, new_dentry->d_name.name, current->comm);		err = -EACCES;		goto out_eacces;	}	/* save current_cred and override it */	OVERRIDE_CRED(SDCARDFS_SB(old_dir->i_sb), saved_cred);	sdcardfs_get_real_lower(old_dentry, &lower_old_path);	sdcardfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = mnt_want_write(lower_old_path.mnt);	if (err)		goto out;	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_drop_old_write;	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry);	if (err)		goto out_err;	/* Copy attrs from lower dir, but i_uid/i_gid */	sdcardfs_copy_inode_attr(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	fix_derived_permission(new_dir);	if (new_dir != old_dir) {		sdcardfs_copy_inode_attr(old_dir, lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir, lower_old_dir_dentry->d_inode);		fix_derived_permission(old_dir);		/* update the derived permission of the old_dentry		 * with its new parent		 */		new_parent = dget_parent(new_dentry);		if(new_parent) {			if(old_dentry->d_inode) {				get_derived_permission(new_parent, old_dentry);				fix_derived_permission(old_dentry->d_inode);			}			dput(new_parent);		}	}out_err:	mnt_drop_write(lower_new_path.mnt);out_drop_old_write:	mnt_drop_write(lower_old_path.mnt);out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	sdcardfs_put_real_lower(old_dentry, &lower_old_path);	sdcardfs_put_lower_path(new_dentry, &lower_new_path);	REVERT_CRED(saved_cred);out_eacces:	return err;}

/* * The locking rules in esdfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int esdfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct path lower_old_path, lower_new_path;	int mask;	const struct cred *creds =			esdfs_override_creds(ESDFS_SB(old_dir->i_sb), &mask);	if (!creds)		return -ENOMEM;	/* Never rename to or from a pseudo hard link target. */	if (ESDFS_DENTRY_HAS_STUB(old_dentry))		esdfs_get_lower_stub_path(old_dentry, &lower_old_path);	else		esdfs_get_lower_path(old_dentry, &lower_old_path);	if (ESDFS_DENTRY_HAS_STUB(new_dentry))		esdfs_get_lower_stub_path(new_dentry, &lower_new_path);	else		esdfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	esdfs_get_lower_parent(old_dentry, lower_old_dentry,			       &lower_old_dir_dentry);	esdfs_get_lower_parent(new_dentry, lower_new_dentry,			       &lower_new_dir_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = mnt_want_write(lower_old_path.mnt);	if (err)		goto out;	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_drop_old_write;	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry);	if (err)		goto out_err;	esdfs_copy_attr(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir) {		esdfs_copy_attr(old_dir,				      lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir,					lower_old_dir_dentry->d_inode);	}	/* Drop any old links */	if (ESDFS_DENTRY_HAS_STUB(old_dentry))		d_drop(old_dentry);	if (ESDFS_DENTRY_HAS_STUB(new_dentry))		d_drop(new_dentry);out_err:	mnt_drop_write(lower_new_path.mnt);out_drop_old_write:	mnt_drop_write(lower_old_path.mnt);out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	esdfs_put_lower_parent(old_dentry, &lower_old_dir_dentry);	esdfs_put_lower_parent(new_dentry, &lower_new_dir_dentry);	esdfs_put_lower_path(old_dentry, &lower_old_path);	esdfs_put_lower_path(new_dentry, &lower_new_path);	esdfs_revert_creds(creds, &mask);	return err;}

static int ovl_create_over_whiteout(struct dentry *dentry, struct inode *inode,				    struct ovl_cattr *cattr){	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 dentry *upper;	struct dentry *newdentry;	int err;	struct posix_acl *acl, *default_acl;	bool hardlink = !!cattr->hardlink;	if (WARN_ON(!workdir))		return -EROFS;	if (!hardlink) {		err = posix_acl_create(dentry->d_parent->d_inode,				       &cattr->mode, &default_acl, &acl);		if (err)			return err;	}	err = ovl_lock_rename_workdir(workdir, upperdir);	if (err)		goto out;	upper = lookup_one_len(dentry->d_name.name, upperdir,			       dentry->d_name.len);	err = PTR_ERR(upper);	if (IS_ERR(upper))		goto out_unlock;	newdentry = ovl_create_temp(workdir, cattr);	err = PTR_ERR(newdentry);	if (IS_ERR(newdentry))		goto out_dput;	/*	 * mode could have been mutilated due to umask (e.g. sgid directory)	 */	if (!hardlink &&	    !S_ISLNK(cattr->mode) &&	    newdentry->d_inode->i_mode != cattr->mode) {		struct iattr attr = {			.ia_valid = ATTR_MODE,			.ia_mode = cattr->mode,		};		inode_lock(newdentry->d_inode);		err = notify_change(newdentry, &attr, NULL);		inode_unlock(newdentry->d_inode);		if (err)			goto out_cleanup;	}	if (!hardlink) {		err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_ACCESS,					acl);		if (err)			goto out_cleanup;		err = ovl_set_upper_acl(newdentry, XATTR_NAME_POSIX_ACL_DEFAULT,					default_acl);		if (err)			goto out_cleanup;	}	if (!hardlink && S_ISDIR(cattr->mode)) {		err = ovl_set_opaque(dentry, newdentry);		if (err)			goto out_cleanup;		err = ovl_do_rename(wdir, newdentry, udir, upper,				    RENAME_EXCHANGE);		if (err)			goto out_cleanup;		ovl_cleanup(wdir, upper);	} else {		err = ovl_do_rename(wdir, newdentry, udir, upper, 0);		if (err)			goto out_cleanup;	}	err = ovl_instantiate(dentry, inode, newdentry, hardlink);	if (err)		goto out_cleanup;out_dput:	dput(upper);out_unlock:	unlock_rename(workdir, upperdir);out:	if (!hardlink) {		posix_acl_release(acl);		posix_acl_release(default_acl);	}	return err;out_cleanup:	ovl_cleanup(wdir, newdentry);	dput(newdentry);	goto out_dput;//.........这里部分代码省略.........

/* * The locking rules in amfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int amfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct path lower_old_path, lower_new_path;	/*******Variable which will help in checking XATTR***************/	char *value = NULL;	if (old_dentry->d_inode->i_ino ==				AMFS_SB(old_dentry->d_sb)->inode_no) {		err = -EPERM;		goto exitcode;	}	value = kzalloc(5, __GFP_WAIT);	if (value == NULL) {		err = -ENOMEM;		goto exitcode;	}	if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5) > 0) {		if (!strncmp(value, AMFS_BADFILE, 3)) {			err = -EPERM;			goto freevalue;		}	} else if (amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5)			!= -ENODATA) {		err = amfs_getxattr(old_dentry, AMFS_XATTR_NAME, value, 5);		goto freevalue;	}	/****************************************************************/	amfs_get_lower_path(old_dentry, &lower_old_path);	amfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry,			 NULL, 0);	if (err)		goto out;	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir,				      lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir,					lower_old_dir_dentry->d_inode);	}out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	amfs_put_lower_path(old_dentry, &lower_old_path);	amfs_put_lower_path(new_dentry, &lower_new_path);freevalue:	kfree(value);exitcode:	return err;}

/* * The locking rules in sdcardfs_rename are complex.  We could use a simpler * superblock-level name-space lock for renames and copy-ups. */static int sdcardfs_rename(struct inode *old_dir, struct dentry *old_dentry,			 struct inode *new_dir, struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_old_dir_dentry = NULL;	struct dentry *lower_new_dir_dentry = NULL;	struct dentry *trap = NULL;	struct path lower_old_path, lower_new_path;	OVERRIDE_CRED(SDCARDFS_SB(old_dir->i_sb));	sdcardfs_get_lower_path(old_dentry, &lower_old_path);	sdcardfs_get_lower_path(new_dentry, &lower_new_path);	lower_old_dentry = lower_old_path.dentry;	lower_new_dentry = lower_new_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	/* source should not be ancestor of target */	if (trap == lower_old_dentry) {		err = -EINVAL;		goto out;	}	/* target should not be ancestor of source */	if (trap == lower_new_dentry) {		err = -ENOTEMPTY;		goto out;	}	err = mnt_want_write(lower_old_path.mnt);	if (err)		goto out;	err = mnt_want_write(lower_new_path.mnt);	if (err)		goto out_drop_old_write;	err = vfs_rename(lower_old_dir_dentry->d_inode, lower_old_dentry,			 lower_new_dir_dentry->d_inode, lower_new_dentry);	if (err)		goto out_err;	/* Copy attrs from lower dir, but i_uid/i_gid */	fsstack_copy_attr_all(new_dir, lower_new_dir_dentry->d_inode);	fsstack_copy_inode_size(new_dir, lower_new_dir_dentry->d_inode);	fix_fat_permission(new_dir); 	if (new_dir != old_dir) {		fsstack_copy_attr_all(old_dir, lower_old_dir_dentry->d_inode);		fsstack_copy_inode_size(old_dir, lower_old_dir_dentry->d_inode);		fix_fat_permission(old_dir); 	}out_err:	mnt_drop_write(lower_new_path.mnt);out_drop_old_write:	mnt_drop_write(lower_old_path.mnt);out:	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	dput(lower_old_dir_dentry);	dput(lower_new_dir_dentry);	sdcardfs_put_lower_path(old_dentry, &lower_old_path);	sdcardfs_put_lower_path(new_dentry, &lower_new_path);	REVERT_CRED();	return err;}

//.........这里部分代码省略.........	err = get_file_handle(&(f->filp_in), f->in_file->name, O_RDONLY, 0);	if (err)		goto ERR_KEY;	if (!(f->filp_in->f_op->read)) {		printk(KERN_ALERT"read operation not supported/n");		err = -EPERM;		goto ERR_IN;	}	printk(KERN_ALERT"read file permission/n");	if (f->create_out_file == 'y') {		printk(KERN_ALERT"file with default permission/n");		err = get_file_handle(&(f->filp_temp), "/tmp/my_temp_file", O_WRONLY|O_CREAT|O_TRUNC, 0666-current_umask());	} else {		printk(KERN_ALERT"creating file with outfile mode/n");		err = get_file_handle(&(f->filp_temp), "/tmp/my_temp_file", O_WRONLY|O_CREAT|O_TRUNC, f->out_file_mode);	}	if (err)		goto ERR_IN;	printk(KERN_ALERT"file permission for temp file=/n");	printk(KERN_ALERT"/n");	if (user_args->flags == 1)		err = encrypt(f, &key_hash[0], user_args);	else		err = decrypt(f, &key_hash[0], user_args);	if (err) {		tmp_err = err;		err = vfs_unlink(d_inode(f->filp_temp->f_path.dentry->d_parent), f->filp_temp->f_path.dentry, NULL);		if (err)			printk(KERN_ALERT"Error in unlink/n");		err = tmp_err;		goto ERR_IN;	}	printk(KERN_ALERT"enc/dec done so now doing a rename/n");	if (f->create_out_file == 'y')		err = get_file_handle(&(f->filp_out), f->out_file->name, O_WRONLY|O_CREAT|O_TRUNC, 0666-current_umask());	else		err = get_file_handle(&(f->filp_out), f->out_file->name, O_WRONLY, 0);	if (err)		goto ERR_OUT;	if (!(f->filp_out->f_op->write)) {		printk(KERN_ALERT"write operation not supported/n");		err = -EPERM;		goto ERR;	}	lower_old_dentry = f->filp_temp->f_path.dentry;	lower_old_dir_dentry = dget_parent(lower_old_dentry);	lower_new_dentry = f->filp_out->f_path.dentry;	lower_new_dir_dentry = dget_parent(lower_new_dentry);	trap = lock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	err = vfs_rename(d_inode(lower_old_dir_dentry), lower_old_dentry,			d_inode(lower_new_dir_dentry), lower_new_dentry,			NULL, 0);	if (err) {		printk(KERN_ALERT"error in rename/n");		tmp_err = err;		err = vfs_unlink(d_inode(f->filp_temp->f_path.dentry->d_parent), f->filp_temp->f_path.dentry, NULL);		if (err)			printk(KERN_ALERT"Error in unlink/n");		if (f->create_out_file == 'y') {			err = vfs_unlink(d_inode(f->filp_temp->f_path.dentry->d_parent), f->filp_temp->f_path.dentry, NULL);			if (err)				printk(KERN_ALERT"Error in unlink/n");		}		err = tmp_err;	}	printk(KERN_ALERT"rename done!/n");	unlock_rename(lower_old_dir_dentry, lower_new_dir_dentry);	if (f->filp_temp)		filp_close(f->filp_temp, NULL);ERR_OUT:	if (f->filp_out)		filp_close(f->filp_out, NULL);ERR_IN:	if (f->filp_in)		filp_close(f->filp_in, NULL);ERR_KEY:	kfree(key_hash);ERR:	return err;}