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

static int ecryptfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode){	int rc;	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	lower_dentry = ecryptfs_dentry_to_lower(dentry);	lower_dir_dentry = lock_parent(lower_dentry);	rc = vfs_mkdir(lower_dir_dentry->d_inode, lower_dentry, mode);	if (rc || !lower_dentry->d_inode)		goto out;	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);	if (rc)		goto out;	fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);	set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);out:	unlock_dir(lower_dir_dentry);	if (!dentry->d_inode)		d_drop(dentry);	return rc;}

static intecryptfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t dev){	int rc;	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	lower_dentry = ecryptfs_dentry_to_lower(dentry);	lower_dir_dentry = lock_parent(lower_dentry);	rc = vfs_mknod(d_inode(lower_dir_dentry), lower_dentry, mode, dev);	if (rc || d_really_is_negative(lower_dentry))		goto out;	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb);	if (rc)		goto out;	fsstack_copy_attr_times(dir, d_inode(lower_dir_dentry));	fsstack_copy_inode_size(dir, d_inode(lower_dir_dentry));out:	unlock_dir(lower_dir_dentry);	if (d_really_is_negative(dentry))		d_drop(dentry);	return rc;}

static int scfs_do_unlink(struct inode *dir, struct dentry *dentry, struct inode *inode){	struct dentry *lower_dentry = scfs_lower_dentry(dentry);	struct inode *lower_dir_inode = scfs_lower_inode(dir);	struct dentry *lower_dir_dentry;	int ret;	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	ret = vfs_unlink(lower_dir_inode, lower_dentry);	if (ret) {		SCFS_PRINT_ERROR("error in vfs_unlink, ret : %d/n", ret);		goto out;	}	fsstack_copy_attr_times(dir, lower_dir_inode);	set_nlink(inode, scfs_lower_inode(inode)->i_nlink);	inode->i_ctime = dir->i_ctime;	d_drop(dentry);out:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	return ret;}

/** * ecryptfs_do_create * @directory_inode: inode of the new file's dentry's parent in ecryptfs * @ecryptfs_dentry: New file's dentry in ecryptfs * @mode: The mode of the new file * @nd: nameidata of ecryptfs' parent's dentry & vfsmount * * Creates the underlying file and the eCryptfs inode which will link to * it. It will also update the eCryptfs directory inode to mimic the * stat of the lower directory inode. * * Returns the new eCryptfs inode on success; an ERR_PTR on error condition */static struct inode *ecryptfs_do_create(struct inode *directory_inode,		   struct dentry *ecryptfs_dentry, umode_t mode){	int rc;	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	struct inode *inode;	lower_dentry = ecryptfs_dentry_to_lower(ecryptfs_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	if (IS_ERR(lower_dir_dentry)) {		ecryptfs_printk(KERN_ERR, "Error locking directory of "				"dentry/n");		inode = ERR_CAST(lower_dir_dentry);		goto out;	}	rc = vfs_create(lower_dir_dentry->d_inode, lower_dentry, mode, NULL);	if (rc) {		printk(KERN_ERR "%s: Failure to create dentry in lower fs; "		       "rc = [%d]/n", __func__, rc);		inode = ERR_PTR(rc);		goto out_lock;	}	inode = __ecryptfs_get_inode(lower_dentry->d_inode,				     directory_inode->i_sb);	if (IS_ERR(inode)) {		vfs_unlink(lower_dir_dentry->d_inode, lower_dentry);		goto out_lock;	}	fsstack_copy_attr_times(directory_inode, lower_dir_dentry->d_inode);	fsstack_copy_inode_size(directory_inode, lower_dir_dentry->d_inode);out_lock:	unlock_dir(lower_dir_dentry);out:	return inode;}

static int ecryptfs_symlink(struct inode *dir, struct dentry *dentry,			    const char *symname){	int rc;	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	char *encoded_symname;	int encoded_symlen;	struct ecryptfs_crypt_stat *crypt_stat = NULL;	lower_dentry = ecryptfs_dentry_to_lower(dentry);	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	encoded_symlen = ecryptfs_encode_filename(crypt_stat, symname,						  strlen(symname),						  &encoded_symname);	if (encoded_symlen < 0) {		rc = encoded_symlen;		goto out_lock;	}	rc = vfs_symlink(lower_dir_dentry->d_inode, lower_dentry,			 encoded_symname);	kfree(encoded_symname);	if (rc || !lower_dentry->d_inode)		goto out_lock;	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb, 0);	if (rc)		goto out_lock;	fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_dir_dentry->d_inode);out_lock:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	if (!dentry->d_inode)		d_drop(dentry);	return rc;}

STATIC intbase0fs_mkdir(inode_t *dir, struct dentry *dentry, int mode){        int err;        struct dentry *lower_dentry;        struct dentry *lower_dir_dentry;        print_entry_location();        lower_dentry = base0fs_lower_dentry(dentry);	/* CPW: Moved below print_entry_location */        fist_checkinode(dir, "base0fs_mkdir-dir");        lower_dir_dentry = base0fs_lock_parent(lower_dentry);        err = VFS_MKDIR(lower_dir_dentry->d_inode,                        lower_dentry,                        mode);        if (err || !lower_dentry->d_inode)                goto out;        err = base0fs_interpose(lower_dentry, dentry, dir->i_sb, 0);        if (err)                goto out;        fist_copy_attr_timesizes(dir, lower_dir_dentry->d_inode);        /* update number of links on parent directory */        dir->i_nlink = lower_dir_dentry->d_inode->i_nlink;        fist_checkinode(dir, "post base0fs_mkdir-dir");out:        unlock_dir(lower_dir_dentry);        if (!dentry->d_inode)                d_drop(dentry);        print_exit_status(err);        return err;}

static int wrapfs_link(struct dentry *old_dentry, struct inode *dir,		       struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int err;	struct path lower_old_path, lower_new_path;	file_size_save = i_size_read(old_dentry->d_inode);	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_dir_dentry = lock_parent(lower_new_dentry);	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		       lower_new_dentry, NULL);	if (err || !lower_new_dentry->d_inode)		goto out;	err = wrapfs_interpose(new_dentry, dir->i_sb, &lower_new_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  wrapfs_lower_inode(old_dentry->d_inode)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	unlock_dir(lower_dir_dentry);	wrapfs_put_lower_path(old_dentry, &lower_old_path);	wrapfs_put_lower_path(new_dentry, &lower_new_path);	return err;}

static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry){	int rc = 0;	struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);	struct inode *lower_dir_inode = ecryptfs_inode_to_lower(dir);	struct dentry *lower_dir_dentry;	dget(lower_dentry);	lower_dir_dentry = lock_parent(lower_dentry);	rc = vfs_unlink(lower_dir_inode, lower_dentry);	if (rc) {		printk(KERN_ERR "Error in vfs_unlink; rc = [%d]/n", rc);		goto out_unlock;	}	fsstack_copy_attr_times(dir, lower_dir_inode);	set_nlink(dentry->d_inode,		  ecryptfs_inode_to_lower(dentry->d_inode)->i_nlink);	dentry->d_inode->i_ctime = dir->i_ctime;	d_drop(dentry);out_unlock:	unlock_dir(lower_dir_dentry);	dput(lower_dentry);	return rc;}

static int diaryfs_symlink(struct inode *dir, struct dentry *dentry, const char * symname) {	int err;	struct dentry *lower_dentry;	struct dentry *lower_parent_dentry = NULL;	struct path lower_path; 	diaryfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	lower_parent_dentry = lock_parent(lower_dentry);	err = vfs_symlink(lower_parent_dentry->d_inode, lower_dentry, symname);	if (err)		goto out;	err = diaryfs_interpose(dentry, dir->i_sb, &lower_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, diaryfs_lower_inode(dir));	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);out:	unlock_dir(lower_parent_dentry);	diaryfs_put_lower_path(dentry, &lower_path);	return err;}

static int ecryptfs_rmdir(struct inode *dir, struct dentry *dentry){	struct dentry *lower_dentry;	struct dentry *lower_dir_dentry;	int rc;	dentry_unhash(dentry);	lower_dentry = ecryptfs_dentry_to_lower(dentry);	dget(dentry);	lower_dir_dentry = lock_parent(lower_dentry);	dget(lower_dentry);	rc = vfs_rmdir(lower_dir_dentry->d_inode, lower_dentry);	dput(lower_dentry);	if (!rc && dentry->d_inode)		clear_nlink(dentry->d_inode);	fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);	set_nlink(dir, lower_dir_dentry->d_inode->i_nlink);	unlock_dir(lower_dir_dentry);	if (!rc)		d_drop(dentry);	dput(dentry);	return rc;}

static int wrapfs_create(struct inode *dir, struct dentry *dentry,			 int mode, struct nameidata *nd){	int err = 0;	struct dentry *lower_dentry;	struct dentry *lower_parent_dentry = NULL;	struct path lower_path, saved_path;	wrapfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	lower_parent_dentry = lock_parent(lower_dentry);	err = mnt_want_write(lower_path.mnt);	if (err)		goto out_unlock;	pathcpy(&saved_path, &nd->path);	pathcpy(&nd->path, &lower_path);	err = vfs_create(lower_parent_dentry->d_inode, lower_dentry, mode, nd);	pathcpy(&nd->path, &saved_path);	if (err)		goto out;	err = wrapfs_interpose(dentry, dir->i_sb, &lower_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, wrapfs_lower_inode(dir));	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);out:	mnt_drop_write(lower_path.mnt);out_unlock:	unlock_dir(lower_parent_dentry);	wrapfs_put_lower_path(dentry, &lower_path);	return err;}

//.........这里部分代码省略.........					   strlen(name));			if (IS_ERR(hidden_dentry))				goto out;			/* Replace the current dentry (if any) with the new one. */			DPUT(dtohd_index(dentry, bindex));			set_dtohd_index(dentry, bindex, hidden_dentry);			loop_start =			    (old_bstart < bindex) ? old_bstart : bindex;			loop_end = (old_bend > bindex) ? old_bend : bindex;			/* This loop sets the bstart and bend for the new			 * dentry by traversing from left to right.			 * It also dputs all negative dentries except			 * bindex (the newly looked dentry			 */			for (i = loop_start; i <= loop_end; i++) {				if (!dtohd_index(dentry, i))					continue;				if (i == bindex) {					new_bend = i;					if (new_bstart < 0)						new_bstart = i;					continue;				}				if (!dtohd_index(dentry, i)->d_inode) {					DPUT(dtohd_index(dentry, i));					set_dtohd_index(dentry, i, NULL);				} else {					if (new_bstart < 0)						new_bstart = i;					new_bend = i;				}			}			if (new_bstart < 0)				new_bstart = bindex;			if (new_bend < 0)				new_bend = bindex;			set_dbstart(dentry, new_bstart);			set_dbend(dentry, new_bend);			break;		}		if (hidden_dentry->d_inode) {			/* since this already exists we dput to avoid			 * multiple references on the same dentry */			DPUT(hidden_dentry);		} else {			uid_t saved_uid = current->fsuid;			gid_t saved_gid = current->fsgid;			/* its a negative dentry, create a new dir */			hidden_parent_dentry = lock_parent(hidden_dentry);			current->fsuid = hidden_parent_dentry->d_inode->i_uid;			current->fsgid = hidden_parent_dentry->d_inode->i_gid;			err = vfs_mkdir(hidden_parent_dentry->d_inode,					hidden_dentry, S_IRWXUGO);			current->fsuid = saved_uid;			current->fsgid = saved_gid;			unlock_dir(hidden_parent_dentry);			if (err || !hidden_dentry->d_inode) {				DPUT(hidden_dentry);				hidden_dentry = ERR_PTR(err);				goto out;			}			err =			    copyup_permissions(dir->i_sb, child_dentry,					       hidden_dentry);			if (err) {				DPUT(hidden_dentry);				hidden_dentry = ERR_PTR(err);				goto out;			}			set_itohi_index(child_dentry->d_inode, bindex,					igrab(hidden_dentry->d_inode));			if (ibstart(child_dentry->d_inode) > bindex)				ibstart(child_dentry->d_inode) = bindex;			if (ibend(child_dentry->d_inode) < bindex)				ibend(child_dentry->d_inode) = bindex;			set_dtohd_index(child_dentry, bindex, hidden_dentry);			if (dbstart(child_dentry) > bindex)				set_dbstart(child_dentry, bindex);			if (dbend(child_dentry) < bindex)				set_dbend(child_dentry, bindex);		}		parent_dentry = child_dentry;		child_dentry = path[--count];	}      out:	KFREE(path);	fist_print_dentry("OUT: create_parents_named", dentry);	print_exit_pointer(hidden_dentry);	return hidden_dentry;}

//.........这里部分代码省略.........#endif	} else if (S_ISBLK(old_hidden_dentry->d_inode->i_mode)		   || S_ISCHR(old_hidden_dentry->d_inode->i_mode)		   || S_ISFIFO(old_hidden_dentry->d_inode->i_mode)		   || S_ISSOCK(old_hidden_dentry->d_inode->i_mode)) {#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)		err = vfs_mknod(new_hidden_parent_dentry->d_inode,				new_hidden_dentry,				old_hidden_dentry->d_inode->i_mode,				kdev_t_to_nr(old_hidden_dentry->d_inode->					     i_rdev));#else		err = vfs_mknod(new_hidden_parent_dentry->d_inode,				new_hidden_dentry,				old_hidden_dentry->d_inode->i_mode,				old_hidden_dentry->d_inode->i_rdev);#endif	} else if (S_ISREG(old_hidden_dentry->d_inode->i_mode)) {#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,0)		err = vfs_create(new_hidden_parent_dentry->d_inode,				 new_hidden_dentry, S_IRWXU);#else		err = vfs_create(new_hidden_parent_dentry->d_inode,				 new_hidden_dentry, S_IRWXU, NULL);#endif	} else {		char diemsg[100];		snprintf(diemsg, sizeof(diemsg), "Unknown inode type %d/n",			 old_hidden_dentry->d_inode->i_mode);		FISTBUG(diemsg);	}	current->fsuid = saved_uid;	current->fsgid = saved_gid;	unlock_dir(new_hidden_parent_dentry);      copyup_readlink_err:	KFREE(symbuf);	if (err) {		/* get rid of the hidden dentry and all its traces */		DPUT(new_hidden_dentry);		set_dtohd_index(dentry, new_bindex, NULL);		set_dbstart(dentry, old_bstart);		set_dbend(dentry, old_bend);		goto out;	}	/* We actually copyup the file here. */	if (S_ISREG(old_hidden_dentry->d_inode->i_mode)) {		mntget(stohiddenmnt_index(sb, old_bindex));		branchget(sb, old_bindex);		got_branch_input = old_bindex;		input_file =		    DENTRY_OPEN(old_hidden_dentry,				stohiddenmnt_index(sb, old_bindex), O_RDONLY);		if (IS_ERR(input_file)) {			err = PTR_ERR(input_file);			goto out;		}		if (!input_file->f_op || !input_file->f_op->read) {			err = -EINVAL;			goto out;		}		/* copy the new file */		DGET(new_hidden_dentry);		mntget(stohiddenmnt_index(sb, new_bindex));		branchget(sb, new_bindex);

static int unionfs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode,			 dev_t dev){	int err = 0;	struct dentry *lower_dentry = NULL;	struct dentry *wh_dentry = NULL;	struct dentry *lower_parent_dentry = NULL;	struct dentry *parent;	char *name = NULL;	int valid = 0;	unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_CHILD);	parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);	unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);	valid = __unionfs_d_revalidate(dentry, parent, false, 0);	if (unlikely(!valid)) {		err = -ESTALE;		goto out;	}	/*	 * It's only a bug if this dentry was not negative and couldn't be	 * revalidated (shouldn't happen).	 */	BUG_ON(!valid && dentry->d_inode);	lower_dentry = find_writeable_branch(dir, dentry);	if (IS_ERR(lower_dentry)) {		err = PTR_ERR(lower_dentry);		goto out;	}	lower_parent_dentry = lock_parent(lower_dentry);	if (IS_ERR(lower_parent_dentry)) {		err = PTR_ERR(lower_parent_dentry);		goto out_unlock;	}	err = vfs_mknod(lower_parent_dentry->d_inode, lower_dentry, mode, dev);	if (!err) {		err = PTR_ERR(unionfs_interpose(dentry, dir->i_sb, 0));		if (!err) {			unionfs_copy_attr_times(dir);			fsstack_copy_inode_size(dir,						lower_parent_dentry->d_inode);			/* update no. of links on parent directory */			set_nlink(dir, unionfs_get_nlinks(dir));		}	}out_unlock:	unlock_dir(lower_parent_dentry);out:	dput(wh_dentry);	kfree(name);	if (!err) {		unionfs_postcopyup_setmnt(dentry);		unionfs_check_inode(dir);		unionfs_check_dentry(dentry);	}	unionfs_unlock_dentry(dentry);	unionfs_unlock_parent(dentry, parent);	unionfs_read_unlock(dentry->d_sb);	return err;}

static int unionfs_create(struct inode *dir, struct dentry *dentry,			  int mode, struct nameidata *nd_unused){	int err = 0;	struct dentry *lower_dentry = NULL;	struct dentry *lower_parent_dentry = NULL;	struct dentry *parent;	int valid = 0;	struct nameidata lower_nd;	unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_CHILD);	parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);	unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);	valid = __unionfs_d_revalidate(dentry, parent, false);	if (unlikely(!valid)) {		err = -ESTALE;	/* same as what real_lookup does */		goto out;	}	lower_dentry = find_writeable_branch(dir, dentry);	if (IS_ERR(lower_dentry)) {		err = PTR_ERR(lower_dentry);		goto out;	}	lower_parent_dentry = lock_parent(lower_dentry);	if (IS_ERR(lower_parent_dentry)) {		err = PTR_ERR(lower_parent_dentry);		goto out_unlock;	}	err = init_lower_nd(&lower_nd, LOOKUP_CREATE);	if (unlikely(err < 0))		goto out_unlock;	err = vfs_create(lower_parent_dentry->d_inode, lower_dentry, mode,			 &lower_nd);	release_lower_nd(&lower_nd, err);	if (!err) {		err = PTR_ERR(unionfs_interpose(dentry, dir->i_sb, 0));		if (!err) {			unionfs_copy_attr_times(dir);			fsstack_copy_inode_size(dir,						lower_parent_dentry->d_inode);			/* update no. of links on parent directory */			dir->i_nlink = unionfs_get_nlinks(dir);		}	}out_unlock:	unlock_dir(lower_parent_dentry);out:	if (!err) {		unionfs_postcopyup_setmnt(dentry);		unionfs_check_inode(dir);		unionfs_check_dentry(dentry);	}	unionfs_unlock_dentry(dentry);	unionfs_unlock_parent(dentry, parent);	unionfs_read_unlock(dentry->d_sb);	return err;}

//.........这里部分代码省略.........		err = -ENOSPC;		goto out_revert;	}	/* the lower_dentry is negative here */	sdcardfs_get_lower_path(dentry, &lower_path);	lower_dentry = lower_path.dentry;	lower_parent_dentry = lock_parent(lower_dentry);	err = mnt_want_write(lower_path.mnt);	if (err)		goto out_unlock;	/* set last 16bytes of mode field to 0775 */	mode = (mode & S_IFMT) | 00775; 	err = vfs_mkdir(lower_parent_dentry->d_inode, lower_dentry, mode);	if (err)		goto out;		/* if it is a local obb dentry, setup it with the base obbpath */	if(need_graft_path(dentry)) {		err = setup_obb_dentry(dentry, &lower_path);		if(err) {			/* if the sbi->obbpath is not available, the lower_path won't be 			 * changed by setup_obb_dentry() but the lower path is saved to              * its orig_path. this dentry will be revalidated later.			 * but now, the lower_path should be NULL */			sdcardfs_put_reset_lower_path(dentry);			/* the newly created lower path which saved to its orig_path or			 * the lower_path is the base obbpath.              * therefore, an additional path_get is required */			path_get(&lower_path);		} else			make_nomedia_in_obb = 1;	}	err = sdcardfs_interpose(dentry, dir->i_sb, &lower_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, sdcardfs_lower_inode(dir));	fsstack_copy_inode_size(dir, lower_parent_dentry->d_inode);	/* update number of links on parent directory */	set_nlink(dir, sdcardfs_lower_inode(dir)->i_nlink);	if ((sbi->options.derive == DERIVE_UNIFIED) && (!strcasecmp(dentry->d_name.name, "obb"))		&& (pi->perm == PERM_ANDROID) && (pi->userid == 0))		make_nomedia_in_obb = 1;	/* When creating /Android/data and /Android/obb, mark them as .nomedia */	if (make_nomedia_in_obb ||		((pi->perm == PERM_ANDROID) && (!strcasecmp(dentry->d_name.name, "data")))) {		page_buf = (char *)__get_free_page(GFP_KERNEL);		if (!page_buf) {			printk(KERN_ERR "sdcardfs: failed to allocate page buf/n");			goto out;		}		nomedia_dir_name = d_absolute_path_new(&lower_path, page_buf, PAGE_SIZE);		if (IS_ERR(nomedia_dir_name)) {			free_page((unsigned long)page_buf);			printk(KERN_ERR "sdcardfs: failed to get .nomedia dir name/n");			goto out;		}		fullpath_namelen = page_buf + PAGE_SIZE - nomedia_dir_name - 1;		fullpath_namelen += strlen("/.nomedia");		nomedia_fullpath = kzalloc(fullpath_namelen + 1, GFP_KERNEL);		if (!nomedia_fullpath) {			free_page((unsigned long)page_buf);			printk(KERN_ERR "sdcardfs: failed to allocate .nomedia fullpath buf/n");			goto out;		}		strcpy(nomedia_fullpath, nomedia_dir_name);		free_page((unsigned long)page_buf);		strcat(nomedia_fullpath, "/.nomedia");		touch_err = touch(nomedia_fullpath, 0664);		if (touch_err) {			printk(KERN_ERR "sdcardfs: failed to touch(%s): %d/n",							nomedia_fullpath, touch_err);			kfree(nomedia_fullpath);			goto out;		}		kfree(nomedia_fullpath);	}out:	mnt_drop_write(lower_path.mnt);out_unlock:	unlock_dir(lower_parent_dentry);	sdcardfs_put_lower_path(dentry, &lower_path);out_revert:	REVERT_CRED(saved_cred);out_eacces:	return err;}

//.........这里部分代码省略.........		}		/* store the child dentry */		path[count++] = child_dentry;	} while (!lower_parent_dentry);	count--;	sb = dentry->d_sb;	/*	 * This code goes between the begin/end labels and basically	 * emulates a while(child_dentry != dentry), only cleaner and	 * shorter than what would be a much longer while loop.	 */begin:	/* get lower parent dir in the current branch */	lower_parent_dentry = unionfs_lower_dentry_idx(parent_dentry, bindex);	dput(parent_dentry);	/* init the values to lookup */	childname = child_dentry->d_name.name;	childnamelen = child_dentry->d_name.len;	if (child_dentry != dentry) {		/* lookup child in the underlying file system */		lower_dentry = lookup_one_len(childname, lower_parent_dentry,					      childnamelen);		if (IS_ERR(lower_dentry))			goto out;	} else {		/*		 * Is the name a whiteout of the child name ?  lookup the		 * whiteout child in the underlying file system		 */		lower_dentry = lookup_one_len(name, lower_parent_dentry,					      strlen(name));		if (IS_ERR(lower_dentry))			goto out;		/* Replace the current dentry (if any) with the new one */		dput(unionfs_lower_dentry_idx(dentry, bindex));		unionfs_set_lower_dentry_idx(dentry, bindex,					     lower_dentry);		__cleanup_dentry(dentry, bindex, old_bstart, old_bend);		goto out;	}	if (lower_dentry->d_inode) {		/*		 * since this already exists we dput to avoid		 * multiple references on the same dentry		 */		dput(lower_dentry);	} else {		struct sioq_args args;		/* it's a negative dentry, create a new dir */		lower_parent_dentry = lock_parent(lower_dentry);		args.mkdir.parent = lower_parent_dentry->d_inode;		args.mkdir.dentry = lower_dentry;		args.mkdir.mode = child_dentry->d_inode->i_mode;		run_sioq(__unionfs_mkdir, &args);		err = args.err;		if (!err)			err = copyup_permissions(dir->i_sb, child_dentry,						 lower_dentry);		unlock_dir(lower_parent_dentry);		if (err) {			dput(lower_dentry);			lower_dentry = ERR_PTR(err);			goto out;		}	}	__set_inode(child_dentry, lower_dentry, bindex);	__set_dentry(child_dentry, lower_dentry, bindex);	/*	 * update times of this dentry, but also the parent, because if	 * we changed, the parent may have changed too.	 */	fsstack_copy_attr_times(parent_dentry->d_inode,				lower_parent_dentry->d_inode);	unionfs_copy_attr_times(child_dentry->d_inode);	parent_dentry = child_dentry;	child_dentry = path[--count];	goto begin;out:	/* cleanup any leftover locks from the do/while loop above */	if (IS_ERR(lower_dentry))		while (count)			dput(path[count--]);	kfree(path);	return lower_dentry;}

//.........这里部分代码省略.........			new_lower_dentry, new_bindex);		goto out_unlock;	}	/* We actually copyup the file here. */	if (S_ISREG(old_lower_dentry->d_inode->i_mode))		err = __copyup_reg_data(dentry, new_lower_dentry, new_bindex,					old_lower_dentry, old_bindex,					copyup_file, len);	if (err)		goto out_unlink;	/* Set permissions. */	err = copyup_permissions(sb, old_lower_dentry, new_lower_dentry);	if (err)		goto out_unlink;#ifdef CONFIG_UNION_FS_XATTR	/* Selinux uses extended attributes for permissions. */	err = copyup_xattrs(old_lower_dentry, new_lower_dentry);	if (err)		goto out_unlink;#endif /* CONFIG_UNION_FS_XATTR */	/* do not allow files getting deleted to be re-interposed */	if (!d_deleted(dentry))		unionfs_reinterpose(dentry);	goto out_unlock;out_unlink:	/*	 * copyup failed, because we possibly ran out of space or	 * quota, or something else happened so let's unlink; we don't	 * really care about the return value of vfs_unlink	 */	vfs_unlink(new_lower_parent_dentry->d_inode, new_lower_dentry);	if (copyup_file) {		/* need to close the file */		fput(*copyup_file);		branchput(sb, new_bindex);	}	/*	 * TODO: should we reset the error to something like -EIO?	 *	 * If we don't reset, the user may get some nonsensical errors, but	 * on the other hand, if we reset to EIO, we guarantee that the user	 * will get a "confusing" error message.	 */out_unlock:	unlock_dir(new_lower_parent_dentry);out_free:	/*	 * If old_lower_dentry was not a file, then we need to dput it.  If	 * it was a file, then it was already dput indirectly by other	 * functions we call above which operate on regular files.	 */	if (old_lower_dentry && old_lower_dentry->d_inode &&	    !S_ISREG(old_lower_dentry->d_inode->i_mode))		dput(old_lower_dentry);	kfree(symbuf);	if (err) {		/*		 * if directory creation succeeded, but inode copyup failed,		 * then purge new dentries.		 */		if (dbstart(dentry) < old_bstart &&		    ibstart(dentry->d_inode) > dbstart(dentry))			__clear(dentry, NULL, old_bstart, old_bend,				unionfs_lower_dentry(dentry), dbstart(dentry));		goto out;	}	if (!S_ISDIR(dentry->d_inode->i_mode)) {		unionfs_postcopyup_release(dentry);		if (!unionfs_lower_inode(dentry->d_inode)) {			/*			 * If we got here, then we copied up to an			 * unlinked-open file, whose name is .unionfsXXXXX.			 */			struct inode *inode = new_lower_dentry->d_inode;			atomic_inc(&inode->i_count);			unionfs_set_lower_inode_idx(dentry->d_inode,						    ibstart(dentry->d_inode),						    inode);		}	}	unionfs_postcopyup_setmnt(dentry);	/* sync inode times from copied-up inode to our inode */	unionfs_copy_attr_times(dentry->d_inode);	unionfs_check_inode(dir);	unionfs_check_dentry(dentry);out:	return err;}

static int unionfs_link(struct dentry *old_dentry, struct inode *dir,			struct dentry *new_dentry){	int err = 0;	struct dentry *lower_old_dentry = NULL;	struct dentry *lower_new_dentry = NULL;	struct dentry *lower_dir_dentry = NULL;	struct dentry *old_parent, *new_parent;	char *name = NULL;	bool valid;	unionfs_read_lock(old_dentry->d_sb, UNIONFS_SMUTEX_CHILD);	old_parent = dget_parent(old_dentry);	new_parent = dget_parent(new_dentry);	unionfs_double_lock_parents(old_parent, new_parent);	unionfs_double_lock_dentry(old_dentry, new_dentry);	valid = __unionfs_d_revalidate(old_dentry, old_parent, false, 0);	if (unlikely(!valid)) {		err = -ESTALE;		goto out;	}	if (new_dentry->d_inode) {		valid = __unionfs_d_revalidate(new_dentry, new_parent, false, 0);		if (unlikely(!valid)) {			err = -ESTALE;			goto out;		}	}	lower_new_dentry = unionfs_lower_dentry(new_dentry);	/* check for a whiteout in new dentry branch, and delete it */	err = check_unlink_whiteout(new_dentry, lower_new_dentry,				    dbstart(new_dentry));	if (err > 0) {	       /* whiteout found and removed successfully */		lower_dir_dentry = dget_parent(lower_new_dentry);		fsstack_copy_attr_times(dir, lower_dir_dentry->d_inode);		dput(lower_dir_dentry);		set_nlink(dir, unionfs_get_nlinks(dir));		err = 0;	}	if (err)		goto out;	/* check if parent hierachy is needed, then link in same branch */	if (dbstart(old_dentry) != dbstart(new_dentry)) {		lower_new_dentry = create_parents(dir, new_dentry,						  new_dentry->d_name.name,						  dbstart(old_dentry));		err = PTR_ERR(lower_new_dentry);		if (IS_COPYUP_ERR(err))			goto docopyup;		if (!lower_new_dentry || IS_ERR(lower_new_dentry))			goto out;	}	lower_new_dentry = unionfs_lower_dentry(new_dentry);	lower_old_dentry = unionfs_lower_dentry(old_dentry);	BUG_ON(dbstart(old_dentry) != dbstart(new_dentry));	lower_dir_dentry = lock_parent(lower_new_dentry);	err = is_robranch(old_dentry);	if (!err) {		/* see Documentation/filesystems/unionfs/issues.txt */		lockdep_off();		err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,			       lower_new_dentry);		lockdep_on();	}	unlock_dir(lower_dir_dentry);docopyup:	if (IS_COPYUP_ERR(err)) {		int old_bstart = dbstart(old_dentry);		int bindex;		for (bindex = old_bstart - 1; bindex >= 0; bindex--) {			err = copyup_dentry(old_parent->d_inode,					    old_dentry, old_bstart,					    bindex, old_dentry->d_name.name,					    old_dentry->d_name.len, NULL,					    i_size_read(old_dentry->d_inode));			if (err)				continue;			lower_new_dentry =				create_parents(dir, new_dentry,					       new_dentry->d_name.name,					       bindex);			lower_old_dentry = unionfs_lower_dentry(old_dentry);			lower_dir_dentry = lock_parent(lower_new_dentry);			/* see Documentation/filesystems/unionfs/issues.txt */			lockdep_off();			/* do vfs_link */			err = vfs_link(lower_old_dentry,				       lower_dir_dentry->d_inode,				       lower_new_dentry);			lockdep_on();			unlock_dir(lower_dir_dentry);			goto check_link;		}//.........这里部分代码省略.........

static int unionfs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode){	int err = 0;	struct dentry *lower_dentry = NULL;	struct dentry *lower_parent_dentry = NULL;	struct dentry *parent;	int bindex = 0, bstart;	char *name = NULL;	int valid;	unionfs_read_lock(dentry->d_sb, UNIONFS_SMUTEX_CHILD);	parent = unionfs_lock_parent(dentry, UNIONFS_DMUTEX_PARENT);	unionfs_lock_dentry(dentry, UNIONFS_DMUTEX_CHILD);	valid = __unionfs_d_revalidate(dentry, parent, false, 0);	if (unlikely(!valid)) {		err = -ESTALE;	/* same as what real_lookup does */		goto out;	}	bstart = dbstart(dentry);	lower_dentry = unionfs_lower_dentry(dentry);	/* check for a whiteout in new dentry branch, and delete it */	err = check_unlink_whiteout(dentry, lower_dentry, bstart);	if (err > 0)	       /* whiteout found and removed successfully */		err = 0;	if (err) {		/* exit if the error returned was NOT -EROFS */		if (!IS_COPYUP_ERR(err))			goto out;		bstart--;	}	/* check if copyup's needed, and mkdir */	for (bindex = bstart; bindex >= 0; bindex--) {		int i;		int bend = dbend(dentry);		if (is_robranch_super(dentry->d_sb, bindex))			continue;		lower_dentry = unionfs_lower_dentry_idx(dentry, bindex);		if (!lower_dentry) {			lower_dentry = create_parents(dir, dentry,						      dentry->d_name.name,						      bindex);			if (!lower_dentry || IS_ERR(lower_dentry)) {				printk(KERN_ERR "unionfs: lower dentry "				       " NULL for bindex = %d/n", bindex);				continue;			}		}		lower_parent_dentry = lock_parent(lower_dentry);		if (IS_ERR(lower_parent_dentry)) {			err = PTR_ERR(lower_parent_dentry);			goto out;		}		err = vfs_mkdir(lower_parent_dentry->d_inode, lower_dentry,				mode);		unlock_dir(lower_parent_dentry);		/* did the mkdir succeed? */		if (err)			break;		for (i = bindex + 1; i <= bend; i++) {			/* XXX: use path_put_lowers? */			if (unionfs_lower_dentry_idx(dentry, i)) {				dput(unionfs_lower_dentry_idx(dentry, i));				unionfs_set_lower_dentry_idx(dentry, i, NULL);			}		}		dbend(dentry) = bindex;		/*		 * Only INTERPOSE_LOOKUP can return a value other than 0 on		 * err.		 */		err = PTR_ERR(unionfs_interpose(dentry, dir->i_sb, 0));		if (!err) {			unionfs_copy_attr_times(dir);			fsstack_copy_inode_size(dir,						lower_parent_dentry->d_inode);			/* update number of links on parent directory */			set_nlink(dir, unionfs_get_nlinks(dir));		}		err = make_dir_opaque(dentry, dbstart(dentry));		if (err) {			printk(KERN_ERR "unionfs: mkdir: error creating "			       ".wh.__dir_opaque: %d/n", err);			goto out;		}//.........这里部分代码省略.........

static int amfs_link(struct dentry *old_dentry, struct inode *dir,		       struct dentry *new_dentry){	struct dentry *lower_old_dentry;	struct dentry *lower_new_dentry;	struct dentry *lower_dir_dentry;	u64 file_size_save;	int err;	struct path lower_old_path, lower_new_path;	char *value = NULL;	if (old_dentry->d_inode->i_ino ==			AMFS_SB(old_dentry->d_sb)->inode_no) {		err = -EPERM;		goto out_err;	}	/************XATTR************/	value = kzalloc(5, __GFP_WAIT);	if (value == NULL) {		err = -ENOMEM;		goto out_err;	}	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;	}	/************XATTR***********/	file_size_save = i_size_read(old_dentry->d_inode);	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_dir_dentry = lock_parent(lower_new_dentry);	err = vfs_link(lower_old_dentry, lower_dir_dentry->d_inode,		       lower_new_dentry, NULL);	if (err || !lower_new_dentry->d_inode)		goto out;	err = amfs_interpose(new_dentry, dir->i_sb, &lower_new_path);	if (err)		goto out;	fsstack_copy_attr_times(dir, lower_new_dentry->d_inode);	fsstack_copy_inode_size(dir, lower_new_dentry->d_inode);	set_nlink(old_dentry->d_inode,		  amfs_lower_inode(old_dentry->d_inode)->i_nlink);	i_size_write(new_dentry->d_inode, file_size_save);out:	unlock_dir(lower_dir_dentry);	amfs_put_lower_path(old_dentry, &lower_old_path);	amfs_put_lower_path(new_dentry, &lower_new_path);freevalue:	kfree(value);out_err:	return err;}