Skip to content

Commit

Permalink
fs/9p: Add v9fs_inode
Browse files Browse the repository at this point in the history 
Switch to the fscache code to v9fs_inode. We will later use
v9fs_inode in cache=loose mode to track the inode cache
validity timeout. Ie if we find an inode in cache older
that a specific jiffie range we will consider it stale

Signed-off-by: Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
Signed-off-by: Venkateswararao Jujjuri <jvrao@linux.vnet.ibm.com>
Signed-off-by: Eric Van Hensbergen <ericvh@gmail.com>
  • Loading branch information
Aneesh Kumar K.V authored and Eric Van Hensbergen committed Mar 15, 2011
1 parent a121190 commit a78ce05
Show file tree
Hide file tree
Showing 8 changed files with 184 additions and 220 deletions.
197 changes: 70 additions & 127 deletions fs/9p/cache.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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.
Expand Down Expand Up @@ -133,9 +77,9 @@ static uint16_t v9fs_cache_session_get_key(const void *cookie_netfs_data,
}

const struct fscache_cookie_def v9fs_cache_session_index_def = {
.name = "9P.session",
.type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = v9fs_cache_session_get_key,
.name = "9P.session",
.type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = v9fs_cache_session_get_key,
};

void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses)
Expand Down Expand Up @@ -163,55 +107,55 @@ 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
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;
}

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;
Expand All @@ -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)
Expand Down Expand Up @@ -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);
}
}

Expand All @@ -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,
Expand Down Expand Up @@ -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,
Expand Down Expand Up @@ -453,10 +396,10 @@ 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);
Expand All @@ -467,8 +410,8 @@ void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page)
*/
void __v9fs_fscache_wait_on_page_write(struct inode *inode, struct page *page)
{
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 (PageFsCache(page))
fscache_wait_on_page_write(vcookie->fscache, page);
fscache_wait_on_page_write(v9inode->fscache, page);
}
Loading

0 comments on commit a78ce05

Please sign in to comment.