Commit 26a992db authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs 

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/ericvh/v9fs: (46 commits)
  fs/9p: Make the writeback_fid owned by root
  fs/9p: Writeback dirty data before setattr
  fs/9p: call vmtruncate before setattr 9p opeation
  fs/9p: Properly update inode attributes on link
  fs/9p: Prevent multiple inclusion of same header
  fs/9p: Workaround vfs rename rehash bug
  fs/9p: Mark directory inode invalid for many directory inode operations
  fs/9p: Add . and .. dentry revalidation flag
  fs/9p: mark inode attribute invalid on rename, unlink and setattr
  fs/9p: Add support for marking inode attribute invalid
  fs/9p: Initialize root inode number for dotl
  fs/9p: Update link count correctly on different file system operations
  fs/9p: Add drop_inode 9p callback
  fs/9p: Add direct IO support in cached mode
  fs/9p: Fix inode i_size update in file_write
  fs/9p: set default readahead pages in cached mode
  fs/9p: Move writeback fid to v9fs_inode
  fs/9p: Add v9fs_inode
  fs/9p: Don't set stat.st_blocks based on nrpages
  fs/9p: Add inode hashing
  ...
parents abab012a 7c9e592e

fs/9p/acl.c

+18 −10
Original line number Diff line number Diff line
@@ -21,8 +21,8 @@ 
#include <linux/posix_acl_xattr.h>

#include "xattr.h"

#include "acl.h"

#include "v9fs_vfs.h"

#include "v9fs.h"

#include "v9fs_vfs.h"



static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)

{
@@ -59,7 +59,8 @@ int v9fs_get_acl(struct inode *inode, struct p9_fid *fid) 
	struct v9fs_session_info *v9ses;



	v9ses = v9fs_inode2v9ses(inode);

	if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) {

	if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) ||

			((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) {

		set_cached_acl(inode, ACL_TYPE_DEFAULT, NULL);

		set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);

		return 0;
@@ -71,11 +72,15 @@ int v9fs_get_acl(struct inode *inode, struct p9_fid *fid) 
	if (!IS_ERR(dacl) && !IS_ERR(pacl)) {

		set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);

		set_cached_acl(inode, ACL_TYPE_ACCESS, pacl);

		posix_acl_release(dacl);

		posix_acl_release(pacl);

	} else

		retval = -EIO;



	if (!IS_ERR(dacl))

		posix_acl_release(dacl);



	if (!IS_ERR(pacl))

		posix_acl_release(pacl);



	return retval;

}
@@ -100,9 +105,10 @@ int v9fs_check_acl(struct inode *inode, int mask, unsigned int flags) 
		return -ECHILD;



	v9ses = v9fs_inode2v9ses(inode);

	if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) {

	if (((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) ||

			((v9ses->flags & V9FS_ACL_MASK) != V9FS_POSIX_ACL)) {

		/*

		 * On access = client mode get the acl

		 * On access = client  and acl = on mode get the acl

		 * values from the server

		 */

		return 0;
@@ -128,6 +134,10 @@ static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl) 
	struct inode *inode = dentry->d_inode;



	set_cached_acl(inode, type, acl);



	if (!acl)

		return 0;



	/* Set a setxattr request to server */

	size = posix_acl_xattr_size(acl->a_count);

	buffer = kmalloc(size, GFP_KERNEL);
@@ -177,9 +187,7 @@ int v9fs_acl_chmod(struct dentry *dentry) 
int v9fs_set_create_acl(struct dentry *dentry,

			struct posix_acl *dpacl, struct posix_acl *pacl)

{

	if (dpacl)

	v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, dpacl);

	if (pacl)

	v9fs_set_acl(dentry, ACL_TYPE_ACCESS, pacl);

	posix_acl_release(dpacl);

	posix_acl_release(pacl);

fs/9p/cache.c

+79 −125
Original line number Diff line number Diff line
@@ -33,67 +33,11 @@ 


#define CACHETAG_LEN  11



struct kmem_cache *vcookie_cache;



struct fscache_netfs v9fs_cache_netfs = {

	.name 		= "9p",

	.version 	= 0,

};



static void init_once(void *foo)

{

	struct v9fs_cookie *vcookie = (struct v9fs_cookie *) foo;

	vcookie->fscache = NULL;

	vcookie->qid = NULL;

	inode_init_once(&vcookie->inode);

}



/**

 * v9fs_init_vcookiecache - initialize a cache for vcookies to maintain

 *			    vcookie to inode mapping

 *

 * Returns 0 on success.

 */



static int v9fs_init_vcookiecache(void)

{

	vcookie_cache = kmem_cache_create("vcookie_cache",

					  sizeof(struct v9fs_cookie),

					  0, (SLAB_RECLAIM_ACCOUNT|

					      SLAB_MEM_SPREAD),

					  init_once);

	if (!vcookie_cache)

		return -ENOMEM;



	return 0;

}



/**

 * v9fs_destroy_vcookiecache - destroy the cache of vcookies

 *

 */



static void v9fs_destroy_vcookiecache(void)

{

	kmem_cache_destroy(vcookie_cache);

}



int __v9fs_cache_register(void)

{

	int ret;

	ret = v9fs_init_vcookiecache();

	if (ret < 0)

		return ret;



	return fscache_register_netfs(&v9fs_cache_netfs);

}



void __v9fs_cache_unregister(void)

{

	v9fs_destroy_vcookiecache();

	fscache_unregister_netfs(&v9fs_cache_netfs);

}



/**

 * v9fs_random_cachetag - Generate a random tag to be associated

 *			  with a new cache session.
@@ -163,33 +107,33 @@ void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses) 
static uint16_t v9fs_cache_inode_get_key(const void *cookie_netfs_data,

					 void *buffer, uint16_t bufmax)

{

	const struct v9fs_cookie *vcookie = cookie_netfs_data;

	memcpy(buffer, &vcookie->qid->path, sizeof(vcookie->qid->path));



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get key %llu", &vcookie->inode,

		   vcookie->qid->path);

	return sizeof(vcookie->qid->path);

	const struct v9fs_inode *v9inode = cookie_netfs_data;

	memcpy(buffer, &v9inode->fscache_key->path,

	       sizeof(v9inode->fscache_key->path));

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get key %llu", &v9inode->vfs_inode,

		   v9inode->fscache_key->path);

	return sizeof(v9inode->fscache_key->path);

}



static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,

				      uint64_t *size)

{

	const struct v9fs_cookie *vcookie = cookie_netfs_data;

	*size = i_size_read(&vcookie->inode);

	const struct v9fs_inode *v9inode = cookie_netfs_data;

	*size = i_size_read(&v9inode->vfs_inode);



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get attr %llu", &vcookie->inode,

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get attr %llu", &v9inode->vfs_inode,

		   *size);

}



static uint16_t v9fs_cache_inode_get_aux(const void *cookie_netfs_data,

					 void *buffer, uint16_t buflen)

{

	const struct v9fs_cookie *vcookie = cookie_netfs_data;

	memcpy(buffer, &vcookie->qid->version, sizeof(vcookie->qid->version));



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get aux %u", &vcookie->inode,

		   vcookie->qid->version);

	return sizeof(vcookie->qid->version);

	const struct v9fs_inode *v9inode = cookie_netfs_data;

	memcpy(buffer, &v9inode->fscache_key->version,

	       sizeof(v9inode->fscache_key->version));

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get aux %u", &v9inode->vfs_inode,

		   v9inode->fscache_key->version);

	return sizeof(v9inode->fscache_key->version);

}



static enum
@@ -197,13 +141,13 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data, 
					    const void *buffer,

					    uint16_t buflen)

{

	const struct v9fs_cookie *vcookie = cookie_netfs_data;

	const struct v9fs_inode *v9inode = cookie_netfs_data;



	if (buflen != sizeof(vcookie->qid->version))

	if (buflen != sizeof(v9inode->fscache_key->version))

		return FSCACHE_CHECKAUX_OBSOLETE;



	if (memcmp(buffer, &vcookie->qid->version,

		   sizeof(vcookie->qid->version)))

	if (memcmp(buffer, &v9inode->fscache_key->version,

		   sizeof(v9inode->fscache_key->version)))

		return FSCACHE_CHECKAUX_OBSOLETE;



	return FSCACHE_CHECKAUX_OKAY;
@@ -211,7 +155,7 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data, 


static void v9fs_cache_inode_now_uncached(void *cookie_netfs_data)

{

	struct v9fs_cookie *vcookie = cookie_netfs_data;

	struct v9fs_inode *v9inode = cookie_netfs_data;

	struct pagevec pvec;

	pgoff_t first;

	int loop, nr_pages;
@@ -220,7 +164,7 @@ static void v9fs_cache_inode_now_uncached(void *cookie_netfs_data) 
	first = 0;



	for (;;) {

		nr_pages = pagevec_lookup(&pvec, vcookie->inode.i_mapping,

		nr_pages = pagevec_lookup(&pvec, v9inode->vfs_inode.i_mapping,

					  first,

					  PAGEVEC_SIZE - pagevec_count(&pvec));

		if (!nr_pages)
@@ -249,115 +193,114 @@ const struct fscache_cookie_def v9fs_cache_inode_index_def = { 


void v9fs_cache_inode_get_cookie(struct inode *inode)

{

	struct v9fs_cookie *vcookie;

	struct v9fs_inode *v9inode;

	struct v9fs_session_info *v9ses;



	if (!S_ISREG(inode->i_mode))

		return;



	vcookie = v9fs_inode2cookie(inode);

	if (vcookie->fscache)

	v9inode = V9FS_I(inode);

	if (v9inode->fscache)

		return;



	v9ses = v9fs_inode2v9ses(inode);

	vcookie->fscache = fscache_acquire_cookie(v9ses->fscache,

	v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,

						  &v9fs_cache_inode_index_def,

						  vcookie);

						  v9inode);



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p get cookie %p", inode,

		   vcookie->fscache);

		   v9inode->fscache);

}



void v9fs_cache_inode_put_cookie(struct inode *inode)

{

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	struct v9fs_inode *v9inode = V9FS_I(inode);



	if (!vcookie->fscache)

	if (!v9inode->fscache)

		return;

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p put cookie %p", inode,

		   vcookie->fscache);

		   v9inode->fscache);



	fscache_relinquish_cookie(vcookie->fscache, 0);

	vcookie->fscache = NULL;

	fscache_relinquish_cookie(v9inode->fscache, 0);

	v9inode->fscache = NULL;

}



void v9fs_cache_inode_flush_cookie(struct inode *inode)

{

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	struct v9fs_inode *v9inode = V9FS_I(inode);



	if (!vcookie->fscache)

	if (!v9inode->fscache)

		return;

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p flush cookie %p", inode,

		   vcookie->fscache);

		   v9inode->fscache);



	fscache_relinquish_cookie(vcookie->fscache, 1);

	vcookie->fscache = NULL;

	fscache_relinquish_cookie(v9inode->fscache, 1);

	v9inode->fscache = NULL;

}



void v9fs_cache_inode_set_cookie(struct inode *inode, struct file *filp)

{

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	struct v9fs_inode *v9inode = V9FS_I(inode);

	struct p9_fid *fid;



	if (!vcookie->fscache)

	if (!v9inode->fscache)

		return;



	spin_lock(&vcookie->lock);

	spin_lock(&v9inode->fscache_lock);

	fid = filp->private_data;

	if ((filp->f_flags & O_ACCMODE) != O_RDONLY)

		v9fs_cache_inode_flush_cookie(inode);

	else

		v9fs_cache_inode_get_cookie(inode);



	spin_unlock(&vcookie->lock);

	spin_unlock(&v9inode->fscache_lock);

}



void v9fs_cache_inode_reset_cookie(struct inode *inode)

{

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	struct v9fs_inode *v9inode = V9FS_I(inode);

	struct v9fs_session_info *v9ses;

	struct fscache_cookie *old;



	if (!vcookie->fscache)

	if (!v9inode->fscache)

		return;



	old = vcookie->fscache;

	old = v9inode->fscache;



	spin_lock(&vcookie->lock);

	fscache_relinquish_cookie(vcookie->fscache, 1);

	spin_lock(&v9inode->fscache_lock);

	fscache_relinquish_cookie(v9inode->fscache, 1);



	v9ses = v9fs_inode2v9ses(inode);

	vcookie->fscache = fscache_acquire_cookie(v9ses->fscache,

	v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,

						  &v9fs_cache_inode_index_def,

						  vcookie);



						  v9inode);

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p",

		   inode, old, vcookie->fscache);

		   inode, old, v9inode->fscache);



	spin_unlock(&vcookie->lock);

	spin_unlock(&v9inode->fscache_lock);

}



int __v9fs_fscache_release_page(struct page *page, gfp_t gfp)

{

	struct inode *inode = page->mapping->host;

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	struct v9fs_inode *v9inode = V9FS_I(inode);



	BUG_ON(!vcookie->fscache);

	BUG_ON(!v9inode->fscache);



	return fscache_maybe_release_page(vcookie->fscache, page, gfp);

	return fscache_maybe_release_page(v9inode->fscache, page, gfp);

}



void __v9fs_fscache_invalidate_page(struct page *page)

{

	struct inode *inode = page->mapping->host;

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	struct v9fs_inode *v9inode = V9FS_I(inode);



	BUG_ON(!vcookie->fscache);

	BUG_ON(!v9inode->fscache);



	if (PageFsCache(page)) {

		fscache_wait_on_page_write(vcookie->fscache, page);

		fscache_wait_on_page_write(v9inode->fscache, page);

		BUG_ON(!PageLocked(page));

		fscache_uncache_page(vcookie->fscache, page);

		fscache_uncache_page(v9inode->fscache, page);

	}

}
@@ -380,13 +323,13 @@ static void v9fs_vfs_readpage_complete(struct page *page, void *data, 
int __v9fs_readpage_from_fscache(struct inode *inode, struct page *page)

{

	int ret;

	const struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	const struct v9fs_inode *v9inode = V9FS_I(inode);



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p page %p", inode, page);

	if (!vcookie->fscache)

	if (!v9inode->fscache)

		return -ENOBUFS;



	ret = fscache_read_or_alloc_page(vcookie->fscache,

	ret = fscache_read_or_alloc_page(v9inode->fscache,

					 page,

					 v9fs_vfs_readpage_complete,

					 NULL,
@@ -418,13 +361,13 @@ int __v9fs_readpages_from_fscache(struct inode *inode, 
				  unsigned *nr_pages)

{

	int ret;

	const struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	const struct v9fs_inode *v9inode = V9FS_I(inode);



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p pages %u", inode, *nr_pages);

	if (!vcookie->fscache)

	if (!v9inode->fscache)

		return -ENOBUFS;



	ret = fscache_read_or_alloc_pages(vcookie->fscache,

	ret = fscache_read_or_alloc_pages(v9inode->fscache,

					  mapping, pages, nr_pages,

					  v9fs_vfs_readpage_complete,

					  NULL,
@@ -453,11 +396,22 @@ int __v9fs_readpages_from_fscache(struct inode *inode, 
void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page)

{

	int ret;

	const struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	const struct v9fs_inode *v9inode = V9FS_I(inode);



	P9_DPRINTK(P9_DEBUG_FSC, "inode %p page %p", inode, page);

	ret = fscache_write_page(vcookie->fscache, page, GFP_KERNEL);

	ret = fscache_write_page(v9inode->fscache, page, GFP_KERNEL);

	P9_DPRINTK(P9_DEBUG_FSC, "ret =  %d", ret);

	if (ret != 0)

		v9fs_uncache_page(inode, page);

}



/*

 * wait for a page to complete writing to the cache

 */

void __v9fs_fscache_wait_on_page_write(struct inode *inode, struct page *page)

{

	const struct v9fs_inode *v9inode = V9FS_I(inode);

	P9_DPRINTK(P9_DEBUG_FSC, "inode %p page %p", inode, page);

	if (PageFsCache(page))

		fscache_wait_on_page_write(v9inode->fscache, page);

}

fs/9p/cache.h

+18 −46
Original line number Diff line number Diff line
@@ -25,20 +25,6 @@ 
#include <linux/fscache.h>

#include <linux/spinlock.h>



extern struct kmem_cache *vcookie_cache;



struct v9fs_cookie {

	spinlock_t lock;

	struct inode inode;

	struct fscache_cookie *fscache;

	struct p9_qid *qid;

};



static inline struct v9fs_cookie *v9fs_inode2cookie(const struct inode *inode)

{

	return container_of(inode, struct v9fs_cookie, inode);

}



extern struct fscache_netfs v9fs_cache_netfs;

extern const struct fscache_cookie_def v9fs_cache_session_index_def;

extern const struct fscache_cookie_def v9fs_cache_inode_index_def;
@@ -64,23 +50,8 @@ extern int __v9fs_readpages_from_fscache(struct inode *inode, 
					 struct list_head *pages,

					 unsigned *nr_pages);

extern void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page);





/**

 * v9fs_cache_register - Register v9fs file system with the cache

 */

static inline int v9fs_cache_register(void)

{

	return __v9fs_cache_register();

}



/**

 * v9fs_cache_unregister - Unregister v9fs from the cache

 */

static inline void v9fs_cache_unregister(void)

{

	__v9fs_cache_unregister();

}

extern void __v9fs_fscache_wait_on_page_write(struct inode *inode,

					      struct page *page);



static inline int v9fs_fscache_release_page(struct page *page,

					    gfp_t gfp)
@@ -117,28 +88,27 @@ static inline void v9fs_readpage_to_fscache(struct inode *inode, 


static inline void v9fs_uncache_page(struct inode *inode, struct page *page)

{

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	fscache_uncache_page(vcookie->fscache, page);

	struct v9fs_inode *v9inode = V9FS_I(inode);

	fscache_uncache_page(v9inode->fscache, page);

	BUG_ON(PageFsCache(page));

}



static inline void v9fs_vcookie_set_qid(struct inode *inode,

static inline void v9fs_fscache_set_key(struct inode *inode,

					struct p9_qid *qid)

{

	struct v9fs_cookie *vcookie = v9fs_inode2cookie(inode);

	spin_lock(&vcookie->lock);

	vcookie->qid = qid;

	spin_unlock(&vcookie->lock);

	struct v9fs_inode *v9inode = V9FS_I(inode);

	spin_lock(&v9inode->fscache_lock);

	v9inode->fscache_key = qid;

	spin_unlock(&v9inode->fscache_lock);

}



#else /* CONFIG_9P_FSCACHE */



static inline int v9fs_cache_register(void)

static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,

						   struct page *page)

{

	return 1;

	return __v9fs_fscache_wait_on_page_write(inode, page);

}



static inline void v9fs_cache_unregister(void) {}

#else /* CONFIG_9P_FSCACHE */



static inline int v9fs_fscache_release_page(struct page *page,

					    gfp_t gfp) {
@@ -168,9 +138,11 @@ static inline void v9fs_readpage_to_fscache(struct inode *inode, 
static inline void v9fs_uncache_page(struct inode *inode, struct page *page)

{}



static inline void v9fs_vcookie_set_qid(struct inode *inode,

					struct p9_qid *qid)

{}

static inline void v9fs_fscache_wait_on_page_write(struct inode *inode,

						   struct page *page)

{

	return;

}



#endif /* CONFIG_9P_FSCACHE */

#endif /* _9P_CACHE_H */

fs/9p/fid.c

+80 −34
Original line number Diff line number Diff line
@@ -125,46 +125,17 @@ err_out: 
	return -ENOMEM;

}



/**

 * v9fs_fid_lookup - lookup for a fid, try to walk if not found

 * @dentry: dentry to look for fid in

 *

 * Look for a fid in the specified dentry for the current user.

 * If no fid is found, try to create one walking from a fid from the parent

 * dentry (if it has one), or the root dentry. If the user haven't accessed

 * the fs yet, attach now and walk from the root.

 */



struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)

static struct p9_fid *v9fs_fid_lookup_with_uid(struct dentry *dentry,

					       uid_t uid, int any)

{

	int i, n, l, clone, any, access;

	u32 uid;

	struct p9_fid *fid, *old_fid = NULL;

	struct dentry *ds;

	struct v9fs_session_info *v9ses;

	char **wnames, *uname;

	int i, n, l, clone, access;

	struct v9fs_session_info *v9ses;

	struct p9_fid *fid, *old_fid = NULL;



	v9ses = v9fs_inode2v9ses(dentry->d_inode);

	access = v9ses->flags & V9FS_ACCESS_MASK;

	switch (access) {

	case V9FS_ACCESS_SINGLE:

	case V9FS_ACCESS_USER:

	case V9FS_ACCESS_CLIENT:

		uid = current_fsuid();

		any = 0;

		break;



	case V9FS_ACCESS_ANY:

		uid = v9ses->uid;

		any = 1;

		break;



	default:

		uid = ~0;

		any = 0;

		break;

	}



	fid = v9fs_fid_find(dentry, uid, any);

	if (fid)

		return fid;
@@ -250,6 +221,45 @@ err_out: 
	return fid;

}



/**

 * v9fs_fid_lookup - lookup for a fid, try to walk if not found

 * @dentry: dentry to look for fid in

 *

 * Look for a fid in the specified dentry for the current user.

 * If no fid is found, try to create one walking from a fid from the parent

 * dentry (if it has one), or the root dentry. If the user haven't accessed

 * the fs yet, attach now and walk from the root.

 */



struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)

{

	uid_t uid;

	int  any, access;

	struct v9fs_session_info *v9ses;



	v9ses = v9fs_inode2v9ses(dentry->d_inode);

	access = v9ses->flags & V9FS_ACCESS_MASK;

	switch (access) {

	case V9FS_ACCESS_SINGLE:

	case V9FS_ACCESS_USER:

	case V9FS_ACCESS_CLIENT:

		uid = current_fsuid();

		any = 0;

		break;



	case V9FS_ACCESS_ANY:

		uid = v9ses->uid;

		any = 1;

		break;



	default:

		uid = ~0;

		any = 0;

		break;

	}

	return v9fs_fid_lookup_with_uid(dentry, uid, any);

}



struct p9_fid *v9fs_fid_clone(struct dentry *dentry)

{

	struct p9_fid *fid, *ret;
@@ -261,3 +271,39 @@ struct p9_fid *v9fs_fid_clone(struct dentry *dentry) 
	ret = p9_client_walk(fid, 0, NULL, 1);

	return ret;

}



static struct p9_fid *v9fs_fid_clone_with_uid(struct dentry *dentry, uid_t uid)

{

	struct p9_fid *fid, *ret;



	fid = v9fs_fid_lookup_with_uid(dentry, uid, 0);

	if (IS_ERR(fid))

		return fid;



	ret = p9_client_walk(fid, 0, NULL, 1);

	return ret;

}



struct p9_fid *v9fs_writeback_fid(struct dentry *dentry)

{

	int err;

	struct p9_fid *fid;



	fid = v9fs_fid_clone_with_uid(dentry, 0);

	if (IS_ERR(fid))

		goto error_out;

	/*

	 * writeback fid will only be used to write back the

	 * dirty pages. We always request for the open fid in read-write

	 * mode so that a partial page write which result in page

	 * read can work.

	 */

	err = p9_client_open(fid, O_RDWR);

	if (err < 0) {

		p9_client_clunk(fid);

		fid = ERR_PTR(err);

		goto error_out;

	}

error_out:

	return fid;

}

fs/9p/fid.h

+4 −1
Original line number Diff line number Diff line
@@ -19,7 +19,8 @@ 
 *  Boston, MA  02111-1301  USA

 *

 */



#ifndef FS_9P_FID_H

#define FS_9P_FID_H

#include <linux/list.h>



/**
@@ -45,3 +46,5 @@ struct v9fs_dentry { 
struct p9_fid *v9fs_fid_lookup(struct dentry *dentry);

struct p9_fid *v9fs_fid_clone(struct dentry *dentry);

int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid);

struct p9_fid *v9fs_writeback_fid(struct dentry *dentry);

#endif

CRA Git | Maintained and supported by SUSTech CRA and CCSE