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

static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,					struct file *f,					int (*open)(struct inode *, struct file *),					const struct cred *cred){	static const struct file_operations empty_fops = {};	struct inode *inode;	int error;	f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |				FMODE_PREAD | FMODE_PWRITE;	if (unlikely(f->f_flags & O_PATH))		f->f_mode = FMODE_PATH;	inode = dentry->d_inode;	if (f->f_mode & FMODE_WRITE) {		error = __get_file_write_access(inode, mnt);		if (error)			goto cleanup_file;		if (!special_file(inode->i_mode))			file_take_write(f);	}	f->f_mapping = inode->i_mapping;	f->f_path.dentry = dentry;	f->f_path.mnt = mnt;	f->f_pos = 0;	if (unlikely(f->f_mode & FMODE_PATH)) {		f->f_op = &empty_fops;		return f;	}	f->f_op = fops_get(inode->i_fop);	error = security_dentry_open(f, cred);	if (error)		goto cleanup_all;	error = break_lease(inode, f->f_flags);	if (error)		goto cleanup_all;	if (!open && f->f_op)		open = f->f_op->open;	if (open) {		error = open(inode, f);		if (error)			goto cleanup_all;	}	if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)		i_readcount_inc(inode);	f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);	file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);	/* NB: we're sure to have correct a_ops only after f_op->open */	if (f->f_flags & O_DIRECT) {		if (!f->f_mapping->a_ops ||		    ((!f->f_mapping->a_ops->direct_IO) &&		    (!f->f_mapping->a_ops->get_xip_mem))) {			fput(f);			f = ERR_PTR(-EINVAL);		}	}	return f;cleanup_all:	fops_put(f->f_op);	if (f->f_mode & FMODE_WRITE) {		put_write_access(inode);		if (!special_file(inode->i_mode)) {			/*			 * We don't consider this a real			 * mnt_want/drop_write() pair			 * because it all happenend right			 * here, so just reset the state.			 */			file_reset_write(f);			mnt_drop_write(mnt);		}	}	f->f_path.dentry = NULL;	f->f_path.mnt = NULL;cleanup_file:	put_filp(f);	dput(dentry);	mntput(mnt);	return ERR_PTR(error);}

/** * ecryptfs_lookup_and_interpose_lower - Perform a lookup */int ecryptfs_lookup_and_interpose_lower(struct dentry *ecryptfs_dentry,					struct dentry *lower_dentry,					struct inode *ecryptfs_dir_inode){	struct dentry *lower_dir_dentry;	struct vfsmount *lower_mnt;	struct inode *lower_inode;	struct ecryptfs_crypt_stat *crypt_stat;	char *page_virt = NULL;	int put_lower = 0, rc = 0;	lower_dir_dentry = lower_dentry->d_parent;	lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(				   ecryptfs_dentry->d_parent));	lower_inode = lower_dentry->d_inode;	fsstack_copy_attr_atime(ecryptfs_dir_inode, lower_dir_dentry->d_inode);	BUG_ON(!lower_dentry->d_count);	ecryptfs_set_dentry_private(ecryptfs_dentry,				    kmem_cache_alloc(ecryptfs_dentry_info_cache,						     GFP_KERNEL));	if (!ecryptfs_dentry_to_private(ecryptfs_dentry)) {		rc = -ENOMEM;		printk(KERN_ERR "%s: Out of memory whilst attempting "		       "to allocate ecryptfs_dentry_info struct/n",			__func__);		goto out_put;	}	ecryptfs_set_dentry_lower(ecryptfs_dentry, lower_dentry);	ecryptfs_set_dentry_lower_mnt(ecryptfs_dentry, lower_mnt);	if (!lower_dentry->d_inode) {		/* We want to add because we couldn't find in lower */		d_add(ecryptfs_dentry, NULL);		goto out;	}	rc = ecryptfs_interpose(lower_dentry, ecryptfs_dentry,				ecryptfs_dir_inode->i_sb,				ECRYPTFS_INTERPOSE_FLAG_D_ADD);	if (rc) {		printk(KERN_ERR "%s: Error interposing; rc = [%d]/n",		       __func__, rc);		goto out;	}	if (S_ISDIR(lower_inode->i_mode))		goto out;	if (S_ISLNK(lower_inode->i_mode))		goto out;	if (special_file(lower_inode->i_mode))		goto out;	/* Released in this function */	page_virt = kmem_cache_zalloc(ecryptfs_header_cache_2, GFP_USER);	if (!page_virt) {		printk(KERN_ERR "%s: Cannot kmem_cache_zalloc() a page/n",		       __func__);		rc = -ENOMEM;		goto out;	}	rc = ecryptfs_get_lower_file(ecryptfs_dentry);	if (rc) {		printk(KERN_ERR "%s: Error attempting to initialize "			"the lower file for the dentry with name "			"[%s]; rc = [%d]/n", __func__,			ecryptfs_dentry->d_name.name, rc);		goto out_free_kmem;	}	put_lower = 1;	crypt_stat = &ecryptfs_inode_to_private(					ecryptfs_dentry->d_inode)->crypt_stat;	/* TODO: lock for crypt_stat comparison */	if (!(crypt_stat->flags & ECRYPTFS_POLICY_APPLIED))			ecryptfs_set_default_sizes(crypt_stat);	rc = ecryptfs_read_and_validate_header_region(page_virt,						      ecryptfs_dentry->d_inode);	if (rc) {		memset(page_virt, 0, PAGE_CACHE_SIZE);		rc = ecryptfs_read_and_validate_xattr_region(page_virt,							     ecryptfs_dentry);		if (rc) {			rc = 0;			goto out_free_kmem;		}		crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;	}	ecryptfs_i_size_init(page_virt, ecryptfs_dentry->d_inode);out_free_kmem:	kmem_cache_free(ecryptfs_header_cache_2, page_virt);	goto out;out_put:	dput(lower_dentry);	mntput(lower_mnt);	d_drop(ecryptfs_dentry);out:	if (put_lower)		ecryptfs_put_lower_file(ecryptfs_dentry->d_inode);	return rc;}

/* * access() needs to use the real uid/gid, not the effective uid/gid. * We do this by temporarily clearing all FS-related capabilities and * switching the fsuid/fsgid around to the real ones. */SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode){	const struct cred *old_cred;	struct cred *override_cred;	struct path path;	struct inode *inode;	int res;	if (mode & ~S_IRWXO)	/* where's F_OK, X_OK, W_OK, R_OK? */		return -EINVAL;	override_cred = prepare_creds();	if (!override_cred)		return -ENOMEM;	override_cred->fsuid = override_cred->uid;	override_cred->fsgid = override_cred->gid;	if (!issecure(SECURE_NO_SETUID_FIXUP)) {		/* Clear the capabilities if we switch to a non-root user */		if (override_cred->uid)			cap_clear(override_cred->cap_effective);		else			override_cred->cap_effective =				override_cred->cap_permitted;	}	old_cred = override_creds(override_cred);	res = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);	if (res)		goto out;	inode = path.dentry->d_inode;	if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {		/*		 * MAY_EXEC on regular files is denied if the fs is mounted		 * with the "noexec" flag.		 */		res = -EACCES;		if (path.mnt->mnt_flags & MNT_NOEXEC)			goto out_path_release;	}	res = inode_permission(inode, mode | MAY_ACCESS);	/* SuS v2 requires we report a read only fs too */	if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))		goto out_path_release;	/*	 * This is a rare case where using __mnt_is_readonly()	 * is OK without a mnt_want/drop_write() pair.  Since	 * no actual write to the fs is performed here, we do	 * not need to telegraph to that to anyone.	 *	 * By doing this, we accept that this access is	 * inherently racy and know that the fs may change	 * state before we even see this result.	 */	if (__mnt_is_readonly(path.mnt))		res = -EROFS;out_path_release:	path_put(&path);out:	revert_creds(old_cred);	put_cred(override_cred);	return res;}

static int do_dentry_open(struct file *f,			  int (*open)(struct inode *, struct file *),			  const struct cred *cred){	static const struct file_operations empty_fops = {};	struct inode *inode;	int error;	f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |				FMODE_PREAD | FMODE_PWRITE;	if (unlikely(f->f_flags & O_PATH))		f->f_mode = FMODE_PATH;	path_get(&f->f_path);	inode = f->f_inode = f->f_path.dentry->d_inode;	if (f->f_mode & FMODE_WRITE) {		error = __get_file_write_access(inode, f->f_path.mnt);		if (error)			goto cleanup_file;		if (!special_file(inode->i_mode))			file_take_write(f);	}	f->f_mapping = inode->i_mapping;	file_sb_list_add(f, inode->i_sb);	if (unlikely(f->f_mode & FMODE_PATH)) {		f->f_op = &empty_fops;		return 0;	}	f->f_op = fops_get(inode->i_fop);	error = security_file_open(f, cred);	if (error)		goto cleanup_all;	error = break_lease(inode, f->f_flags);	if (error)		goto cleanup_all;	if (!open && f->f_op)		open = f->f_op->open;	if (open) {		error = open(inode, f);		if (error)			goto cleanup_all;	}	if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)		i_readcount_inc(inode);	f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);	file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);	return 0;cleanup_all:	fops_put(f->f_op);	file_sb_list_del(f);	if (f->f_mode & FMODE_WRITE) {		put_write_access(inode);		if (!special_file(inode->i_mode)) {			/*			 * We don't consider this a real			 * mnt_want/drop_write() pair			 * because it all happenend right			 * here, so just reset the state.			 */			file_reset_write(f);			__mnt_drop_write(f->f_path.mnt);		}	}cleanup_file:	path_put(&f->f_path);	f->f_path.mnt = NULL;	f->f_path.dentry = NULL;	f->f_inode = NULL;	return error;}

static int do_dentry_open(struct file *f,			  int (*open)(struct inode *, struct file *),			  const struct cred *cred){	static const struct file_operations empty_fops = {};	struct inode *inode;	int error;	f->f_mode = OPEN_FMODE(f->f_flags) | FMODE_LSEEK |				FMODE_PREAD | FMODE_PWRITE;	path_get(&f->f_path);	inode = f->f_inode = f->f_path.dentry->d_inode;	f->f_mapping = inode->i_mapping;	if (unlikely(f->f_flags & O_PATH)) {		f->f_mode = FMODE_PATH;		f->f_op = &empty_fops;		return 0;	}	if (f->f_mode & FMODE_WRITE && !special_file(inode->i_mode)) {		error = get_write_access(inode);		if (unlikely(error))			goto cleanup_file;		error = __mnt_want_write(f->f_path.mnt);		if (unlikely(error)) {			put_write_access(inode);			goto cleanup_file;		}		f->f_mode |= FMODE_WRITER;	}	/* POSIX.1-2008/SUSv4 Section XSI 2.9.7 */	if (S_ISREG(inode->i_mode))		f->f_mode |= FMODE_ATOMIC_POS;	f->f_op = fops_get(inode->i_fop);	if (unlikely(WARN_ON(!f->f_op))) {		error = -ENODEV;		goto cleanup_all;	}	error = security_file_open(f, cred);	if (error)		goto cleanup_all;	error = break_lease(inode, f->f_flags);	if (error)		goto cleanup_all;	if (!open)		open = f->f_op->open;	if (open) {		error = open(inode, f);		if (error)			goto cleanup_all;	}	if ((f->f_mode & (FMODE_READ | FMODE_WRITE)) == FMODE_READ)		i_readcount_inc(inode);	if ((f->f_mode & FMODE_READ) &&	     likely(f->f_op->read || f->f_op->aio_read || f->f_op->read_iter))		f->f_mode |= FMODE_CAN_READ;	if ((f->f_mode & FMODE_WRITE) &&	     likely(f->f_op->write || f->f_op->aio_write || f->f_op->write_iter))		f->f_mode |= FMODE_CAN_WRITE;	f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);	file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);	return 0;cleanup_all:	fops_put(f->f_op);	if (f->f_mode & FMODE_WRITER) {		put_write_access(inode);		__mnt_drop_write(f->f_path.mnt);	}cleanup_file:	path_put(&f->f_path);	f->f_path.mnt = NULL;	f->f_path.dentry = NULL;	f->f_inode = NULL;	return error;}

/** * ecryptfs_lookup * @dir: inode * @dentry: The dentry * @nd: nameidata, may be NULL * * Find a file on disk. If the file does not exist, then we'll add it to the * dentry cache and continue on to read it from the disk. */static struct dentry *ecryptfs_lookup(struct inode *dir, struct dentry *dentry,				      struct nameidata *nd){	int rc = 0;	struct dentry *lower_dir_dentry;	struct dentry *lower_dentry;	struct vfsmount *lower_mnt;	char *encoded_name;	int encoded_namelen;	struct ecryptfs_crypt_stat *crypt_stat = NULL;	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;	char *page_virt = NULL;	struct inode *lower_inode;	u64 file_size;	lower_dir_dentry = ecryptfs_dentry_to_lower(dentry->d_parent);	dentry->d_op = &ecryptfs_dops;	if ((dentry->d_name.len == 1 && !strcmp(dentry->d_name.name, "."))	    || (dentry->d_name.len == 2		&& !strcmp(dentry->d_name.name, ".."))) {		d_drop(dentry);		goto out;	}	encoded_namelen = ecryptfs_encode_filename(crypt_stat,						   dentry->d_name.name,						   dentry->d_name.len,						   &encoded_name);	if (encoded_namelen < 0) {		rc = encoded_namelen;		d_drop(dentry);		goto out;	}	ecryptfs_printk(KERN_DEBUG, "encoded_name = [%s]; encoded_namelen "			"= [%d]/n", encoded_name, encoded_namelen);	lower_dentry = lookup_one_len(encoded_name, lower_dir_dentry,				      encoded_namelen - 1);	kfree(encoded_name);	if (IS_ERR(lower_dentry)) {		ecryptfs_printk(KERN_ERR, "ERR from lower_dentry/n");		rc = PTR_ERR(lower_dentry);		d_drop(dentry);		goto out;	}	lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(dentry->d_parent));	ecryptfs_printk(KERN_DEBUG, "lower_dentry = [%p]; lower_dentry->"       		"d_name.name = [%s]/n", lower_dentry,		lower_dentry->d_name.name);	lower_inode = lower_dentry->d_inode;	fsstack_copy_attr_atime(dir, lower_dir_dentry->d_inode);	BUG_ON(!atomic_read(&lower_dentry->d_count));	ecryptfs_set_dentry_private(dentry,				    kmem_cache_alloc(ecryptfs_dentry_info_cache,						     GFP_KERNEL));	if (!ecryptfs_dentry_to_private(dentry)) {		rc = -ENOMEM;		ecryptfs_printk(KERN_ERR, "Out of memory whilst attempting "				"to allocate ecryptfs_dentry_info struct/n");		goto out_dput;	}	ecryptfs_set_dentry_lower(dentry, lower_dentry);	ecryptfs_set_dentry_lower_mnt(dentry, lower_mnt);	if (!lower_dentry->d_inode) {		/* We want to add because we couldn't find in lower */		d_add(dentry, NULL);		goto out;	}	rc = ecryptfs_interpose(lower_dentry, dentry, dir->i_sb,				ECRYPTFS_INTERPOSE_FLAG_D_ADD);	if (rc) {		ecryptfs_printk(KERN_ERR, "Error interposing/n");		goto out;	}	if (S_ISDIR(lower_inode->i_mode)) {		ecryptfs_printk(KERN_DEBUG, "Is a directory; returning/n");		goto out;	}	if (S_ISLNK(lower_inode->i_mode)) {		ecryptfs_printk(KERN_DEBUG, "Is a symlink; returning/n");		goto out;	}	if (special_file(lower_inode->i_mode)) {		ecryptfs_printk(KERN_DEBUG, "Is a special file; returning/n");		goto out;	}	if (!nd) {		ecryptfs_printk(KERN_DEBUG, "We have a NULL nd, just leave"				"as we *think* we are about to unlink/n");		goto out;	}	/* Released in this function */	page_virt = kmem_cache_zalloc(ecryptfs_header_cache_2,//.........这里部分代码省略.........

SYSCALL_DEFINE3(faccessat, int, dfd, const char __user *, filename, int, mode){	const struct cred *old_cred;	struct cred *override_cred;	struct path path;	struct inode *inode;	int res;	unsigned int lookup_flags = LOOKUP_FOLLOW;	if (mode & ~S_IRWXO)			return -EINVAL;	override_cred = prepare_creds();	if (!override_cred)		return -ENOMEM;	override_cred->fsuid = override_cred->uid;	override_cred->fsgid = override_cred->gid;	if (!issecure(SECURE_NO_SETUID_FIXUP)) {				kuid_t root_uid = make_kuid(override_cred->user_ns, 0);		if (!uid_eq(override_cred->uid, root_uid))			cap_clear(override_cred->cap_effective);		else			override_cred->cap_effective =				override_cred->cap_permitted;	}	old_cred = override_creds(override_cred);retry:	res = user_path_at(dfd, filename, lookup_flags, &path);	if (res)		goto out;	inode = path.dentry->d_inode;	if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {		res = -EACCES;		if (path.mnt->mnt_flags & MNT_NOEXEC)			goto out_path_release;	}	res = inode_permission(inode, mode | MAY_ACCESS);		if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))		goto out_path_release;	if (__mnt_is_readonly(path.mnt))		res = -EROFS;out_path_release:	path_put(&path);	if (retry_estale(res, lookup_flags)) {		lookup_flags |= LOOKUP_REVAL;		goto retry;	}out:	revert_creds(old_cred);	put_cred(override_cred);	return res;}

//Replaced last parameter struct nameidata to unsigned int flags | kernel 3.7.1 | by Jiri Rakosnikstatic struct dentry *ccfs_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags){	int rc = 0;	struct dentry *lower_dir_dentry;	struct dentry *lower_dentry;	struct vfsmount *lower_mnt;	struct inode *lower_inode;			lower_dir_dentry = ccfs_get_nested_dentry(dentry->d_parent);	dentry->d_op = &ccfs_dops;	if ((dentry->d_name.len == 1 && !strcmp(dentry->d_name.name, "."))	    || (dentry->d_name.len == 2		&& !strcmp(dentry->d_name.name, ".."))) {		d_drop(dentry);		goto out;	}	mutex_lock(&lower_dir_dentry->d_inode->i_mutex);	lower_dentry = lookup_one_len(dentry->d_name.name, lower_dir_dentry,				      dentry->d_name.len);	mutex_unlock(&lower_dir_dentry->d_inode->i_mutex);	if (IS_ERR(lower_dentry)) {		mdbg(INFO3,"Error in lower dentry lookup");		rc = PTR_ERR(lower_dentry);		d_drop(dentry);		goto out;	}	lower_mnt = mntget(ccfs_dentry_to_nested_mnt(dentry->d_parent));	lower_inode = lower_dentry->d_inode;	mdbg(INFO3,"lower_dentry (lower_inode, dir_inode) = [%p] (%p, %p); lower_dentry->"       		"d_name.name = [%s]", lower_dentry, lower_inode, dir, 		lower_dentry->d_name.name);	fsstack_copy_attr_atime(dir, lower_dir_dentry->d_inode);	//BUG_ON(!atomic_read(&lower_dentry->d_count));	ccfs_set_dentry_private(dentry,				    kmem_cache_alloc(ccfs_dentry_cache,						     GFP_KERNEL));	if (!ccfs_dentry_to_private(dentry)) {		rc = -ENOMEM;		minfo(ERR1, "Out of memory whilst attempting to allocate ccfs_dentry_info struct");		goto out_dput;	}	ccfs_set_nested_dentry(dentry, lower_dentry);	ccfs_set_dentry_nested_mnt(dentry, lower_mnt);	if (!lower_dentry->d_inode) {		/* We want to add because we couldn't find in lower */		d_add(dentry, NULL);		goto out;	}	rc = ccfs_interpose(lower_dentry, dentry, dir->i_sb, 1);	if (rc) {	  	minfo(ERR1, "Error interposing inode: %d", rc);		goto out_dput;	}	if (S_ISDIR(lower_inode->i_mode)) {		mdbg(INFO3, "Is a directory; returning");		goto out;	}	if (S_ISLNK(lower_inode->i_mode)) {		mdbg(INFO3, "Is a symlink; returning");		goto out;	}	if (special_file(lower_inode->i_mode)) {		mdbg(INFO3, "Is a special file; returning");		goto out;	}	/*	Commented because nd does not exists by Jiri Rakosnik	if (!nd) {		mdbg(INFO3,"We have a NULL nd, just leave"				"as we *think* we are about to unlink");		goto out;	}	*/	goto out;out_dput:	mdbg(INFO3,"lookup PUT done with res: %d (dentry inode: %p name: %s)", rc, dentry->d_inode, dentry->d_name.name);	dput(lower_dentry);	d_drop(dentry);	return ERR_PTR(rc);	out:	mdbg(INFO3,"lookup done with res: %d (dentry inode: %p name: %s dir cacheable: %d)", rc, dentry->d_inode, dentry->d_name.name, ccfs_inode_to_private(dir)->cacheable);	return ERR_PTR(rc);}

static struct file *__dentry_open(struct dentry *dentry, struct vfsmount *mnt,					int flags, struct file *f,					int (*open)(struct inode *, struct file *)){	struct inode *inode;	int error;	f->f_flags = flags;	f->f_mode = ((flags+1) & O_ACCMODE) | FMODE_LSEEK |				FMODE_PREAD | FMODE_PWRITE;	inode = dentry->d_inode;	if (f->f_mode & FMODE_WRITE) {		error = __get_file_write_access(inode, mnt);		if (error)			goto cleanup_file;		if (!special_file(inode->i_mode))			file_take_write(f);	}	f->f_mapping = inode->i_mapping;	f->f_path.dentry = dentry;	f->f_path.mnt = mnt;	f->f_pos = 0;	f->f_op = fops_get(inode->i_fop);	file_move(f, &inode->i_sb->s_files);	error = security_dentry_open(f);	if (error)		goto cleanup_all;	if (!open && f->f_op)		open = f->f_op->open;	if (open) {		error = open(inode, f);		if (error)			goto cleanup_all;	}	f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);	file_ra_state_init(&f->f_ra, f->f_mapping->host->i_mapping);	/* NB: we're sure to have correct a_ops only after f_op->open */	if (f->f_flags & O_DIRECT) {		if (!f->f_mapping->a_ops ||		    ((!f->f_mapping->a_ops->direct_IO) &&		    (!f->f_mapping->a_ops->get_xip_mem))) {			fput(f);			f = ERR_PTR(-EINVAL);		}	}	return f;cleanup_all:	fops_put(f->f_op);	if (f->f_mode & FMODE_WRITE) {		put_write_access(inode);		if (!special_file(inode->i_mode)) {			/*			 * We don't consider this a real			 * mnt_want/drop_write() pair			 * because it all happenend right			 * here, so just reset the state.			 */			file_reset_write(f);			mnt_drop_write(mnt);		}	}	file_kill(f);	f->f_path.dentry = NULL;	f->f_path.mnt = NULL;cleanup_file:	put_filp(f);	dput(dentry);	mntput(mnt);	return ERR_PTR(error);}

/* * access() needs to use the real uid/gid, not the effective uid/gid. * We do this by temporarily clearing all FS-related capabilities and * switching the fsuid/fsgid around to the real ones. */asmlinkage long sys_faccessat(int dfd, const char __user *filename, int mode){	struct path path;	struct inode *inode;	int old_fsuid, old_fsgid;	kernel_cap_t uninitialized_var(old_cap);  /* !SECURE_NO_SETUID_FIXUP */	int res;	if (mode & ~S_IRWXO)	/* where's F_OK, X_OK, W_OK, R_OK? */		return -EINVAL;	old_fsuid = current->fsuid;	old_fsgid = current->fsgid;	current->fsuid = current->uid;	current->fsgid = current->gid;	if (!issecure(SECURE_NO_SETUID_FIXUP)) {		/*		 * Clear the capabilities if we switch to a non-root user		 */#ifndef CONFIG_SECURITY_FILE_CAPABILITIES		/*		 * FIXME: There is a race here against sys_capset.  The		 * capabilities can change yet we will restore the old		 * value below.  We should hold task_capabilities_lock,		 * but we cannot because user_path_at can sleep.		 */#endif /* ndef CONFIG_SECURITY_FILE_CAPABILITIES */		if (current->uid)			old_cap = cap_set_effective(__cap_empty_set);		else			old_cap = cap_set_effective(current->cap_permitted);	}	res = user_path_at(dfd, filename, LOOKUP_FOLLOW, &path);	if (res)		goto out;	inode = path.dentry->d_inode;	if ((mode & MAY_EXEC) && S_ISREG(inode->i_mode)) {		/*		 * MAY_EXEC on regular files is denied if the fs is mounted		 * with the "noexec" flag.		 */		res = -EACCES;		if (path.mnt->mnt_flags & MNT_NOEXEC)			goto out_path_release;	}	res = inode_permission(inode, mode | MAY_ACCESS);	/* SuS v2 requires we report a read only fs too */	if (res || !(mode & S_IWOTH) || special_file(inode->i_mode))		goto out_path_release;	/*	 * This is a rare case where using __mnt_is_readonly()	 * is OK without a mnt_want/drop_write() pair.  Since	 * no actual write to the fs is performed here, we do	 * not need to telegraph to that to anyone.	 *	 * By doing this, we accept that this access is	 * inherently racy and know that the fs may change	 * state before we even see this result.	 */	if (__mnt_is_readonly(path.mnt))		res = -EROFS;out_path_release:	path_put(&path);out:	current->fsuid = old_fsuid;	current->fsgid = old_fsgid;	if (!issecure(SECURE_NO_SETUID_FIXUP))		cap_set_effective(old_cap);	return res;}

/** * ecryptfs_lookup_and_interpose_lower - Perform a lookup */int ecryptfs_lookup_and_interpose_lower(struct dentry *ecryptfs_dentry,					struct dentry *lower_dentry,					struct ecryptfs_crypt_stat *crypt_stat,					struct inode *ecryptfs_dir_inode,					struct nameidata *ecryptfs_nd){	struct dentry *lower_dir_dentry;	struct vfsmount *lower_mnt;	struct inode *lower_inode;	struct ecryptfs_mount_crypt_stat *mount_crypt_stat;	char *page_virt = NULL;	u64 file_size;	int rc = 0;	lower_dir_dentry = lower_dentry->d_parent;	lower_mnt = mntget(ecryptfs_dentry_to_lower_mnt(				   ecryptfs_dentry->d_parent));	lower_inode = lower_dentry->d_inode;	fsstack_copy_attr_atime(ecryptfs_dir_inode, lower_dir_dentry->d_inode);	BUG_ON(!atomic_read(&lower_dentry->d_count));	ecryptfs_set_dentry_private(ecryptfs_dentry,				    kmem_cache_alloc(ecryptfs_dentry_info_cache,						     GFP_KERNEL));	if (!ecryptfs_dentry_to_private(ecryptfs_dentry)) {		rc = -ENOMEM;		printk(KERN_ERR "%s: Out of memory whilst attempting "		       "to allocate ecryptfs_dentry_info struct/n",			__func__);		goto out_dput;	}	ecryptfs_set_dentry_lower(ecryptfs_dentry, lower_dentry);	ecryptfs_set_dentry_lower_mnt(ecryptfs_dentry, lower_mnt);	if (!lower_dentry->d_inode) {		/* We want to add because we couldn't find in lower */		d_add(ecryptfs_dentry, NULL);		goto out;	}	rc = ecryptfs_interpose(lower_dentry, ecryptfs_dentry,				ecryptfs_dir_inode->i_sb, 1);	if (rc) {		printk(KERN_ERR "%s: Error interposing; rc = [%d]/n",		       __func__, rc);		goto out;	}	if (S_ISDIR(lower_inode->i_mode))		goto out;	if (S_ISLNK(lower_inode->i_mode))		goto out;	if (special_file(lower_inode->i_mode))		goto out;	if (!ecryptfs_nd)		goto out;	/* Released in this function */	page_virt = kmem_cache_zalloc(ecryptfs_header_cache_2, GFP_USER);	if (!page_virt) {		printk(KERN_ERR "%s: Cannot kmem_cache_zalloc() a page/n",		       __func__);		rc = -ENOMEM;		goto out;	}	if (!ecryptfs_inode_to_private(ecryptfs_dentry->d_inode)->lower_file) {		rc = ecryptfs_init_persistent_file(ecryptfs_dentry);		if (rc) {			printk(KERN_ERR "%s: Error attempting to initialize "			       "the persistent file for the dentry with name "			       "[%s]; rc = [%d]/n", __func__,			       ecryptfs_dentry->d_name.name, rc);			goto out_free_kmem;		}	}	rc = ecryptfs_read_and_validate_header_region(page_virt,						      ecryptfs_dentry->d_inode);	if (rc) {		rc = ecryptfs_read_and_validate_xattr_region(page_virt,							     ecryptfs_dentry);		if (rc) {			rc = 0;			goto out_free_kmem;		}		crypt_stat->flags |= ECRYPTFS_METADATA_IN_XATTR;	}	mount_crypt_stat = &ecryptfs_superblock_to_private(		ecryptfs_dentry->d_sb)->mount_crypt_stat;	if (mount_crypt_stat->flags & ECRYPTFS_ENCRYPTED_VIEW_ENABLED) {		if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR)			file_size = (crypt_stat->num_header_bytes_at_front				     + i_size_read(lower_dentry->d_inode));		else			file_size = i_size_read(lower_dentry->d_inode);	} else {		file_size = get_unaligned_be64(page_virt);	}	i_size_write(ecryptfs_dentry->d_inode, (loff_t)file_size);out_free_kmem:	kmem_cache_free(ecryptfs_header_cache_2, page_virt);	goto out;out_dput://.........这里部分代码省略.........