Commit 62f8e6c5 authored by Linus Torvalds's avatar Linus Torvalds

Merge tag 'fscache-next-20180406' of...

Merge tag 'fscache-next-20180406' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs

Pull fscache updates from David Howells:
 "Three patches that fix some of AFS's usage of fscache:

   (1) Need to invalidate the cache if a foreign data change is detected
       on the server.

   (2) Move the vnode ID uniquifier (equivalent to i_generation) from
       the auxiliary data to the index key to prevent a race between
       file delete and a subsequent file create seeing the same index
       key.

   (3) Need to retire cookies that correspond to files that we think got
       deleted on the server.

  Four patches to fix some things in fscache and cachefiles:

   (4) Fix a couple of checker warnings.

   (5) Correctly indicate to the end-of-operation callback whether an
       operation completed or was cancelled.

   (6) Add a check for multiple cookie relinquishment.

   (7) Fix a path through the asynchronous write that doesn't wake up a
       waiter for a page if the cache decides not to write that page,
       but discards it instead.

  A couple of patches to add tracepoints to fscache and cachefiles:

   (8) Add tracepoints for cookie operators, object state machine
       execution, cachefiles object management and cachefiles VFS
       operations.

   (9) Add tracepoints for fscache operation management and page
       wrangling.

  And then three development patches:

  (10) Attach the index key and auxiliary data to the cookie, pass this
       information through various fscache-netfs API functions and get
       rid of the callbacks to the netfs to get it.

       This means that the cache can get at this information, even if
       the netfs goes away. It also means that the cache can be lazy in
       updating the coherency data.

  (11) Pass the object data size through various fscache-netfs API
       rather than calling back to the netfs for it, and store the value
       in the object.

       This makes it easier to correctly resize the object, as the size
       is updated on writes to the cache, rather than calling back out
       to the netfs.

  (12) Maintain a catalogue of allocated cookies. This makes it possible
       to catch cookie collision up front rather than down in the bowels
       of the cache being run from a service thread from the object
       state machine.

       This will also make it possible in the future to reconnect to a
       cookie that's not gone dead yet because it's waiting for
       finalisation of the storage and also make it possible to bring
       cookies online if the cache is added after the cookie has been
       obtained"

* tag 'fscache-next-20180406' of git://git.kernel.org/pub/scm/linux/kernel/git/dhowells/linux-fs:
  fscache: Maintain a catalogue of allocated cookies
  fscache: Pass object size in rather than calling back for it
  fscache: Attach the index key and aux data to the cookie
  fscache: Add more tracepoints
  fscache: Add tracepoints
  fscache: Fix hanging wait on page discarded by writeback
  fscache: Detect multiple relinquishment of a cookie
  fscache: Pass the correct cancelled indications to fscache_op_complete()
  fscache, cachefiles: Fix checker warnings
  afs: Be more aggressive in retiring cached vnodes
  afs: Use the vnode ID uniquifier in the cache key not the aux data
  afs: Invalidate cache on server data change
parents f605ba97 ec0328e4
...@@ -55,42 +55,27 @@ int v9fs_random_cachetag(struct v9fs_session_info *v9ses) ...@@ -55,42 +55,27 @@ int v9fs_random_cachetag(struct v9fs_session_info *v9ses)
return scnprintf(v9ses->cachetag, CACHETAG_LEN, "%lu", jiffies); return scnprintf(v9ses->cachetag, CACHETAG_LEN, "%lu", jiffies);
} }
static uint16_t v9fs_cache_session_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
struct v9fs_session_info *v9ses;
uint16_t klen = 0;
v9ses = (struct v9fs_session_info *)cookie_netfs_data;
p9_debug(P9_DEBUG_FSC, "session %p buf %p size %u\n",
v9ses, buffer, bufmax);
if (v9ses->cachetag)
klen = strlen(v9ses->cachetag);
if (klen > bufmax)
return 0;
memcpy(buffer, v9ses->cachetag, klen);
p9_debug(P9_DEBUG_FSC, "cache session tag %s\n", v9ses->cachetag);
return klen;
}
const struct fscache_cookie_def v9fs_cache_session_index_def = { const struct fscache_cookie_def v9fs_cache_session_index_def = {
.name = "9P.session", .name = "9P.session",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = v9fs_cache_session_get_key,
}; };
void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses) void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses)
{ {
/* If no cache session tag was specified, we generate a random one. */ /* If no cache session tag was specified, we generate a random one. */
if (!v9ses->cachetag) if (!v9ses->cachetag) {
v9fs_random_cachetag(v9ses); if (v9fs_random_cachetag(v9ses) < 0) {
v9ses->fscache = NULL;
return;
}
}
v9ses->fscache = fscache_acquire_cookie(v9fs_cache_netfs.primary_index, v9ses->fscache = fscache_acquire_cookie(v9fs_cache_netfs.primary_index,
&v9fs_cache_session_index_def, &v9fs_cache_session_index_def,
v9ses, true); v9ses->cachetag,
strlen(v9ses->cachetag),
NULL, 0,
v9ses, 0, true);
p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n", p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n",
v9ses, v9ses->fscache); v9ses, v9ses->fscache);
} }
...@@ -99,45 +84,15 @@ void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses) ...@@ -99,45 +84,15 @@ void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses)
{ {
p9_debug(P9_DEBUG_FSC, "session %p put cookie %p\n", p9_debug(P9_DEBUG_FSC, "session %p put cookie %p\n",
v9ses, v9ses->fscache); v9ses, v9ses->fscache);
fscache_relinquish_cookie(v9ses->fscache, 0); fscache_relinquish_cookie(v9ses->fscache, NULL, false);
v9ses->fscache = NULL; v9ses->fscache = NULL;
} }
static uint16_t v9fs_cache_inode_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct v9fs_inode *v9inode = cookie_netfs_data;
memcpy(buffer, &v9inode->qid.path, sizeof(v9inode->qid.path));
p9_debug(P9_DEBUG_FSC, "inode %p get key %llu\n",
&v9inode->vfs_inode, v9inode->qid.path);
return sizeof(v9inode->qid.path);
}
static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,
uint64_t *size)
{
const struct v9fs_inode *v9inode = cookie_netfs_data;
*size = i_size_read(&v9inode->vfs_inode);
p9_debug(P9_DEBUG_FSC, "inode %p get attr %llu\n",
&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_inode *v9inode = cookie_netfs_data;
memcpy(buffer, &v9inode->qid.version, sizeof(v9inode->qid.version));
p9_debug(P9_DEBUG_FSC, "inode %p get aux %u\n",
&v9inode->vfs_inode, v9inode->qid.version);
return sizeof(v9inode->qid.version);
}
static enum static enum
fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data, fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
const void *buffer, const void *buffer,
uint16_t buflen) uint16_t buflen,
loff_t object_size)
{ {
const struct v9fs_inode *v9inode = cookie_netfs_data; const struct v9fs_inode *v9inode = cookie_netfs_data;
...@@ -154,9 +109,6 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data, ...@@ -154,9 +109,6 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
const struct fscache_cookie_def v9fs_cache_inode_index_def = { const struct fscache_cookie_def v9fs_cache_inode_index_def = {
.name = "9p.inode", .name = "9p.inode",
.type = FSCACHE_COOKIE_TYPE_DATAFILE, .type = FSCACHE_COOKIE_TYPE_DATAFILE,
.get_key = v9fs_cache_inode_get_key,
.get_attr = v9fs_cache_inode_get_attr,
.get_aux = v9fs_cache_inode_get_aux,
.check_aux = v9fs_cache_inode_check_aux, .check_aux = v9fs_cache_inode_check_aux,
}; };
...@@ -175,7 +127,13 @@ void v9fs_cache_inode_get_cookie(struct inode *inode) ...@@ -175,7 +127,13 @@ void v9fs_cache_inode_get_cookie(struct inode *inode)
v9ses = v9fs_inode2v9ses(inode); v9ses = v9fs_inode2v9ses(inode);
v9inode->fscache = fscache_acquire_cookie(v9ses->fscache, v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,
&v9fs_cache_inode_index_def, &v9fs_cache_inode_index_def,
v9inode, true); &v9inode->qid.path,
sizeof(v9inode->qid.path),
&v9inode->qid.version,
sizeof(v9inode->qid.version),
v9inode,
i_size_read(&v9inode->vfs_inode),
true);
p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n", p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",
inode, v9inode->fscache); inode, v9inode->fscache);
...@@ -190,7 +148,8 @@ void v9fs_cache_inode_put_cookie(struct inode *inode) ...@@ -190,7 +148,8 @@ void v9fs_cache_inode_put_cookie(struct inode *inode)
p9_debug(P9_DEBUG_FSC, "inode %p put cookie %p\n", p9_debug(P9_DEBUG_FSC, "inode %p put cookie %p\n",
inode, v9inode->fscache); inode, v9inode->fscache);
fscache_relinquish_cookie(v9inode->fscache, 0); fscache_relinquish_cookie(v9inode->fscache, &v9inode->qid.version,
false);
v9inode->fscache = NULL; v9inode->fscache = NULL;
} }
...@@ -203,7 +162,7 @@ void v9fs_cache_inode_flush_cookie(struct inode *inode) ...@@ -203,7 +162,7 @@ void v9fs_cache_inode_flush_cookie(struct inode *inode)
p9_debug(P9_DEBUG_FSC, "inode %p flush cookie %p\n", p9_debug(P9_DEBUG_FSC, "inode %p flush cookie %p\n",
inode, v9inode->fscache); inode, v9inode->fscache);
fscache_relinquish_cookie(v9inode->fscache, 1); fscache_relinquish_cookie(v9inode->fscache, NULL, true);
v9inode->fscache = NULL; v9inode->fscache = NULL;
} }
...@@ -236,12 +195,18 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode) ...@@ -236,12 +195,18 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode)
old = v9inode->fscache; old = v9inode->fscache;
mutex_lock(&v9inode->fscache_lock); mutex_lock(&v9inode->fscache_lock);
fscache_relinquish_cookie(v9inode->fscache, 1); fscache_relinquish_cookie(v9inode->fscache, NULL, true);
v9ses = v9fs_inode2v9ses(inode); v9ses = v9fs_inode2v9ses(inode);
v9inode->fscache = fscache_acquire_cookie(v9ses->fscache, v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,
&v9fs_cache_inode_index_def, &v9fs_cache_inode_index_def,
v9inode, true); &v9inode->qid.path,
sizeof(v9inode->qid.path),
&v9inode->qid.version,
sizeof(v9inode->qid.version),
v9inode,
i_size_read(&v9inode->vfs_inode),
true);
p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n", p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n",
inode, old, v9inode->fscache); inode, old, v9inode->fscache);
...@@ -367,7 +332,8 @@ void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page) ...@@ -367,7 +332,8 @@ void __v9fs_readpage_to_fscache(struct inode *inode, struct page *page)
const struct v9fs_inode *v9inode = V9FS_I(inode); const struct v9fs_inode *v9inode = V9FS_I(inode);
p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page); p9_debug(P9_DEBUG_FSC, "inode %p page %p\n", inode, page);
ret = fscache_write_page(v9inode->fscache, page, GFP_KERNEL); ret = fscache_write_page(v9inode->fscache, page,
i_size_read(&v9inode->vfs_inode), GFP_KERNEL);
p9_debug(P9_DEBUG_FSC, "ret = %d\n", ret); p9_debug(P9_DEBUG_FSC, "ret = %d\n", ret);
if (ret != 0) if (ret != 0)
v9fs_uncache_page(inode, page); v9fs_uncache_page(inode, page);
......
...@@ -12,167 +12,39 @@ ...@@ -12,167 +12,39 @@
#include <linux/sched.h> #include <linux/sched.h>
#include "internal.h" #include "internal.h"
static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t buflen);
static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t buflen);
static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t buflen);
static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
uint64_t *size);
static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
void *buffer, uint16_t buflen);
static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
const void *buffer, const void *buffer,
uint16_t buflen); uint16_t buflen,
loff_t object_size);
struct fscache_netfs afs_cache_netfs = { struct fscache_netfs afs_cache_netfs = {
.name = "afs", .name = "afs",
.version = 1, .version = 2,
}; };
struct fscache_cookie_def afs_cell_cache_index_def = { struct fscache_cookie_def afs_cell_cache_index_def = {
.name = "AFS.cell", .name = "AFS.cell",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = afs_cell_cache_get_key,
}; };
struct fscache_cookie_def afs_volume_cache_index_def = { struct fscache_cookie_def afs_volume_cache_index_def = {
.name = "AFS.volume", .name = "AFS.volume",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = afs_volume_cache_get_key,
}; };
struct fscache_cookie_def afs_vnode_cache_index_def = { struct fscache_cookie_def afs_vnode_cache_index_def = {
.name = "AFS.vnode", .name = "AFS.vnode",
.type = FSCACHE_COOKIE_TYPE_DATAFILE, .type = FSCACHE_COOKIE_TYPE_DATAFILE,
.get_key = afs_vnode_cache_get_key,
.get_attr = afs_vnode_cache_get_attr,
.get_aux = afs_vnode_cache_get_aux,
.check_aux = afs_vnode_cache_check_aux, .check_aux = afs_vnode_cache_check_aux,
}; };
/*
* set the key for the index entry
*/
static uint16_t afs_cell_cache_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct afs_cell *cell = cookie_netfs_data;
uint16_t klen;
_enter("%p,%p,%u", cell, buffer, bufmax);
klen = strlen(cell->name);
if (klen > bufmax)
return 0;
memcpy(buffer, cell->name, klen);
return klen;
}
/*****************************************************************************/
/*
* set the key for the volume index entry
*/
static uint16_t afs_volume_cache_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct afs_volume *volume = cookie_netfs_data;
struct {
u64 volid;
} __packed key;
_enter("{%u},%p,%u", volume->type, buffer, bufmax);
if (bufmax < sizeof(key))
return 0;
key.volid = volume->vid;
memcpy(buffer, &key, sizeof(key));
return sizeof(key);
}
/*****************************************************************************/
/*
* set the key for the index entry
*/
static uint16_t afs_vnode_cache_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct afs_vnode *vnode = cookie_netfs_data;
struct {
u32 vnode_id[3];
} __packed key;
_enter("{%x,%x,%llx},%p,%u",
vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
buffer, bufmax);
/* Allow for a 96-bit key */
memset(&key, 0, sizeof(key));
key.vnode_id[0] = vnode->fid.vnode;
key.vnode_id[1] = 0;
key.vnode_id[2] = 0;
if (sizeof(key) > bufmax)
return 0;
memcpy(buffer, &key, sizeof(key));
return sizeof(key);
}
/*
* provide updated file attributes
*/
static void afs_vnode_cache_get_attr(const void *cookie_netfs_data,
uint64_t *size)
{
const struct afs_vnode *vnode = cookie_netfs_data;
_enter("{%x,%x,%llx},",
vnode->fid.vnode, vnode->fid.unique,
vnode->status.data_version);
*size = vnode->status.size;
}
struct afs_vnode_cache_aux {
u64 data_version;
u32 fid_unique;
} __packed;
/*
* provide new auxiliary cache data
*/
static uint16_t afs_vnode_cache_get_aux(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct afs_vnode *vnode = cookie_netfs_data;
struct afs_vnode_cache_aux aux;
_enter("{%x,%x,%Lx},%p,%u",
vnode->fid.vnode, vnode->fid.unique, vnode->status.data_version,
buffer, bufmax);
memset(&aux, 0, sizeof(aux));
aux.data_version = vnode->status.data_version;
aux.fid_unique = vnode->fid.unique;
if (bufmax < sizeof(aux))
return 0;
memcpy(buffer, &aux, sizeof(aux));
return sizeof(aux);
}
/* /*
* check that the auxiliary data indicates that the entry is still valid * check that the auxiliary data indicates that the entry is still valid
*/ */
static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
const void *buffer, const void *buffer,
uint16_t buflen) uint16_t buflen,
loff_t object_size)
{ {
struct afs_vnode *vnode = cookie_netfs_data; struct afs_vnode *vnode = cookie_netfs_data;
struct afs_vnode_cache_aux aux; struct afs_vnode_cache_aux aux;
...@@ -189,12 +61,6 @@ static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data, ...@@ -189,12 +61,6 @@ static enum fscache_checkaux afs_vnode_cache_check_aux(void *cookie_netfs_data,
return FSCACHE_CHECKAUX_OBSOLETE; return FSCACHE_CHECKAUX_OBSOLETE;
} }
if (vnode->fid.unique != aux.fid_unique) {
_leave(" = OBSOLETE [uniq %x != %x]",
aux.fid_unique, vnode->fid.unique);
return FSCACHE_CHECKAUX_OBSOLETE;
}
if (vnode->status.data_version != aux.data_version) { if (vnode->status.data_version != aux.data_version) {
_leave(" = OBSOLETE [vers %llx != %llx]", _leave(" = OBSOLETE [vers %llx != %llx]",
aux.data_version, vnode->status.data_version); aux.data_version, vnode->status.data_version);
......
...@@ -522,7 +522,9 @@ static int afs_activate_cell(struct afs_net *net, struct afs_cell *cell) ...@@ -522,7 +522,9 @@ static int afs_activate_cell(struct afs_net *net, struct afs_cell *cell)
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index, cell->cache = fscache_acquire_cookie(afs_cache_netfs.primary_index,
&afs_cell_cache_index_def, &afs_cell_cache_index_def,
cell, true); cell->name, strlen(cell->name),
NULL, 0,
cell, 0, true);
#endif #endif
ret = afs_proc_cell_setup(net, cell); ret = afs_proc_cell_setup(net, cell);
if (ret < 0) if (ret < 0)
...@@ -547,7 +549,7 @@ static void afs_deactivate_cell(struct afs_net *net, struct afs_cell *cell) ...@@ -547,7 +549,7 @@ static void afs_deactivate_cell(struct afs_net *net, struct afs_cell *cell)
spin_unlock(&net->proc_cells_lock); spin_unlock(&net->proc_cells_lock);
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
fscache_relinquish_cookie(cell->cache, 0); fscache_relinquish_cookie(cell->cache, NULL, false);
cell->cache = NULL; cell->cache = NULL;
#endif #endif
......
...@@ -339,7 +339,8 @@ int afs_page_filler(void *data, struct page *page) ...@@ -339,7 +339,8 @@ int afs_page_filler(void *data, struct page *page)
/* send the page to the cache */ /* send the page to the cache */
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
if (PageFsCache(page) && if (PageFsCache(page) &&
fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) { fscache_write_page(vnode->cache, page, vnode->status.size,
GFP_KERNEL) != 0) {
fscache_uncache_page(vnode->cache, page); fscache_uncache_page(vnode->cache, page);
BUG_ON(PageFsCache(page)); BUG_ON(PageFsCache(page));
} }
...@@ -403,7 +404,8 @@ static void afs_readpages_page_done(struct afs_call *call, struct afs_read *req) ...@@ -403,7 +404,8 @@ static void afs_readpages_page_done(struct afs_call *call, struct afs_read *req)
/* send the page to the cache */ /* send the page to the cache */
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
if (PageFsCache(page) && if (PageFsCache(page) &&
fscache_write_page(vnode->cache, page, GFP_KERNEL) != 0) { fscache_write_page(vnode->cache, page, vnode->status.size,
GFP_KERNEL) != 0) {
fscache_uncache_page(vnode->cache, page); fscache_uncache_page(vnode->cache, page);
BUG_ON(PageFsCache(page)); BUG_ON(PageFsCache(page));
} }
......
...@@ -242,6 +242,33 @@ struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root) ...@@ -242,6 +242,33 @@ struct inode *afs_iget_pseudo_dir(struct super_block *sb, bool root)
return inode; return inode;
} }
/*
* Get a cache cookie for an inode.
*/
static void afs_get_inode_cache(struct afs_vnode *vnode)
{
#ifdef CONFIG_AFS_FSCACHE
struct {
u32 vnode_id;
u32 unique;
u32 vnode_id_ext[2]; /* Allow for a 96-bit key */
} __packed key;
struct afs_vnode_cache_aux aux;
key.vnode_id = vnode->fid.vnode;
key.unique = vnode->fid.unique;
key.vnode_id_ext[0] = 0;
key.vnode_id_ext[1] = 0;
aux.data_version = vnode->status.data_version;
vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
&afs_vnode_cache_index_def,
&key, sizeof(key),
&aux, sizeof(aux),
vnode, vnode->status.size, true);
#endif
}
/* /*
* inode retrieval * inode retrieval
*/ */
...@@ -307,11 +334,7 @@ struct inode *afs_iget(struct super_block *sb, struct key *key, ...@@ -307,11 +334,7 @@ struct inode *afs_iget(struct super_block *sb, struct key *key,
/* set up caching before mapping the status, as map-status reads the /* set up caching before mapping the status, as map-status reads the
* first page of symlinks to see if they're really mountpoints */ * first page of symlinks to see if they're really mountpoints */
inode->i_size = vnode->status.size; inode->i_size = vnode->status.size;
#ifdef CONFIG_AFS_FSCACHE afs_get_inode_cache(vnode);
vnode->cache = fscache_acquire_cookie(vnode->volume->cache,
&afs_vnode_cache_index_def,
vnode, true);
#endif
ret = afs_inode_map_status(vnode, key); ret = afs_inode_map_status(vnode, key);
if (ret < 0) if (ret < 0)
...@@ -327,7 +350,7 @@ struct inode *afs_iget(struct super_block *sb, struct key *key, ...@@ -327,7 +350,7 @@ struct inode *afs_iget(struct super_block *sb, struct key *key,
/* failure */ /* failure */
bad_inode: bad_inode:
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
fscache_relinquish_cookie(vnode->cache, 0); fscache_relinquish_cookie(vnode->cache, NULL, ret == -ENOENT);
vnode->cache = NULL; vnode->cache = NULL;
#endif #endif
iget_failed(inode); iget_failed(inode);
...@@ -343,6 +366,10 @@ void afs_zap_data(struct afs_vnode *vnode) ...@@ -343,6 +366,10 @@ void afs_zap_data(struct afs_vnode *vnode)
{ {
_enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode); _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
#ifdef CONFIG_AFS_FSCACHE
fscache_invalidate(vnode->cache);
#endif
/* nuke all the non-dirty pages that aren't locked, mapped or being /* nuke all the non-dirty pages that aren't locked, mapped or being
* written back in a regular file and completely discard the pages in a * written back in a regular file and completely discard the pages in a
* directory or symlink */ * directory or symlink */
...@@ -507,8 +534,14 @@ void afs_evict_inode(struct inode *inode) ...@@ -507,8 +534,14 @@ void afs_evict_inode(struct inode *inode)
} }
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
fscache_relinquish_cookie(vnode->cache, 0); {
struct afs_vnode_cache_aux aux;
aux.data_version = vnode->status.data_version;
fscache_relinquish_cookie(vnode->cache, &aux,
test_bit(AFS_VNODE_DELETED, &vnode->flags));
vnode->cache = NULL; vnode->cache = NULL;
}
#endif #endif
afs_put_permits(vnode->permit_cache); afs_put_permits(vnode->permit_cache);
......
...@@ -559,6 +559,13 @@ struct afs_fs_cursor { ...@@ -559,6 +559,13 @@ struct afs_fs_cursor {
#define AFS_FS_CURSOR_NO_VSLEEP 0x0020 /* Set to prevent sleep on VBUSY, VOFFLINE, ... */ #define AFS_FS_CURSOR_NO_VSLEEP 0x0020 /* Set to prevent sleep on VBUSY, VOFFLINE, ... */
}; };
/*
* Cache auxiliary data.
*/
struct afs_vnode_cache_aux {
u64 data_version;
} __packed;
#include <trace/events/afs.h> #include <trace/events/afs.h>
/*****************************************************************************/ /*****************************************************************************/
......
...@@ -225,7 +225,9 @@ void afs_activate_volume(struct afs_volume *volume) ...@@ -225,7 +225,9 @@ void afs_activate_volume(struct afs_volume *volume)
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
volume->cache = fscache_acquire_cookie(volume->cell->cache, volume->cache = fscache_acquire_cookie(volume->cell->cache,
&afs_volume_cache_index_def, &afs_volume_cache_index_def,
volume, true); &volume->vid, sizeof(volume->vid),
NULL, 0,
volume, 0, true);
#endif #endif
write_lock(&volume->cell->proc_lock); write_lock(&volume->cell->proc_lock);
...@@ -245,7 +247,7 @@ void afs_deactivate_volume(struct afs_volume *volume) ...@@ -245,7 +247,7 @@ void afs_deactivate_volume(struct afs_volume *volume)
write_unlock(&volume->cell->proc_lock); write_unlock(&volume->cell->proc_lock);
#ifdef CONFIG_AFS_FSCACHE #ifdef CONFIG_AFS_FSCACHE
fscache_relinquish_cookie(volume->cache, fscache_relinquish_cookie(volume->cache, NULL,
test_bit(AFS_VOLUME_DELETED, &volume->flags)); test_bit(AFS_VOLUME_DELETED, &volume->flags));
volume->cache = NULL; volume->cache = NULL;
#endif #endif
......
...@@ -32,7 +32,7 @@ static struct fscache_object *cachefiles_alloc_object( ...@@ -32,7 +32,7 @@ static struct fscache_object *cachefiles_alloc_object(
struct cachefiles_cache *cache; struct cachefiles_cache *cache;
struct cachefiles_xattr *auxdata; struct cachefiles_xattr *auxdata;
unsigned keylen, auxlen; unsigned keylen, auxlen;
void *buffer; void *buffer, *p;
char *key; char *key;
cache = container_of(_cache, struct cachefiles_cache, cache); cache = container_of(_cache, struct cachefiles_cache, cache);
...@@ -65,8 +65,12 @@ static struct fscache_object *cachefiles_alloc_object( ...@@ -65,8 +65,12 @@ static struct fscache_object *cachefiles_alloc_object(
if (!buffer) if (!buffer)
goto nomem_buffer; goto nomem_buffer;
keylen = cookie->def->get_key(cookie->netfs_data, buffer + 2, 512); keylen = cookie->key_len;
ASSERTCMP(keylen, <, 512); if (keylen <= sizeof(cookie->inline_key))
p = cookie->inline_key;
else
p = cookie->key;
memcpy(buffer + 2, p, keylen);
*(uint16_t *)buffer = keylen; *(uint16_t *)buffer = keylen;
((char *)buffer)[keylen + 2] = 0; ((char *)buffer)[keylen + 2] = 0;
...@@ -80,15 +84,17 @@ static struct fscache_object *cachefiles_alloc_object( ...@@ -80,15 +84,17 @@ static struct fscache_object *cachefiles_alloc_object(
/* get hold of the auxiliary data and prepend the object type */ /* get hold of the auxiliary data and prepend the object type */
auxdata = buffer; auxdata = buffer;
auxlen = 0; auxlen = cookie->aux_len;
if (cookie->def->get_aux) { if (auxlen) {
auxlen = cookie->def->get_aux(cookie->netfs_data, if (auxlen <= sizeof(cookie->inline_aux))
auxdata->data, 511); p = cookie->inline_aux;
ASSERTCMP(auxlen, <, 511); else
p = cookie->aux;
memcpy(auxdata->data, p, auxlen);
} }
auxdata->len = auxlen + 1; auxdata->len = auxlen + 1;
auxdata->type = cookie->def->type; auxdata->type = cookie->type;
lookup_data->auxdata = auxdata; lookup_data->auxdata = auxdata;
lookup_data->key = key; lookup_data->key = key;
...@@ -177,10 +183,12 @@ static void cachefiles_lookup_complete(struct fscache_object *_object) ...@@ -177,10 +183,12 @@ static void cachefiles_lookup_complete(struct fscache_object *_object)
* increment the usage count on an inode object (may fail if unmounting) * increment the usage count on an inode object (may fail if unmounting)
*/ */
static static
struct fscache_object *cachefiles_grab_object(struct fscache_object *_object) struct fscache_object *cachefiles_grab_object(struct fscache_object *_object,
enum fscache_obj_ref_trace why)
{ {
struct cachefiles_object *object = struct cachefiles_object *object =
container_of(_object, struct cachefiles_object, fscache); container_of(_object, struct cachefiles_object, fscache);
int u;
_enter("{OBJ%x,%d}", _object->debug_id, atomic_read(&object->usage)); _enter("{OBJ%x,%d}", _object->debug_id, atomic_read(&object->usage));
...@@ -188,7 +196,9 @@ struct fscache_object *cachefiles_grab_object(struct fscache_object *_object) ...@@ -188,7 +196,9 @@ struct fscache_object *cachefiles_grab_object(struct fscache_object *_object)
ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000); ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
#endif #endif
atomic_inc(&object->usage); u = atomic_inc_return(&object->usage);
trace_cachefiles_ref(object, _object->cookie,
(enum cachefiles_obj_ref_trace)why, u);
return &object->fscache; return &object->fscache;
} }
...@@ -202,6 +212,7 @@ static void cachefiles_update_object(struct fscache_object *_object) ...@@ -202,6 +212,7 @@ static void cachefiles_update_object(struct fscache_object *_object)
struct cachefiles_cache *cache; struct cachefiles_cache *cache;
struct fscache_cookie *cookie; struct fscache_cookie *cookie;
const struct cred *saved_cred; const struct cred *saved_cred;
const void *aux;
unsigned auxlen; unsigned auxlen;
_enter("{OBJ%x}", _object->debug_id); _enter("{OBJ%x}", _object->debug_id);
...@@ -216,26 +227,29 @@ static void cachefiles_update_object(struct fscache_object *_object) ...@@ -216,26 +227,29 @@ static void cachefiles_update_object(struct fscache_object *_object)
} }
cookie = object->fscache.cookie; cookie = object->fscache.cookie;
auxlen = cookie->aux_len;
if (!cookie->def->get_aux) { if (!auxlen) {
fscache_unuse_cookie(_object); fscache_unuse_cookie(_object);
_leave(" [no aux]"); _leave(" [no aux]");
return; return;
} }
auxdata = kmalloc(2 + 512 + 3, cachefiles_gfp); auxdata = kmalloc(2 + auxlen + 3, cachefiles_gfp);
if (!auxdata) { if (!auxdata) {
fscache_unuse_cookie(_object); fscache_unuse_cookie(_object);
_leave(" [nomem]"); _leave(" [nomem]");
return; return;
} }
auxlen = cookie->def->get_aux(cookie->netfs_data, auxdata->data, 511); aux = (auxlen <= sizeof(cookie->inline_aux)) ?
cookie->inline_aux : cookie->aux;
memcpy(auxdata->data, aux, auxlen);
fscache_unuse_cookie(_object); fscache_unuse_cookie(_object);
ASSERTCMP(auxlen, <, 511);
auxdata->len = auxlen + 1; auxdata->len = auxlen + 1;
auxdata->type = cookie->def->type; auxdata->type = cookie->type;
cachefiles_begin_secure(cache, &saved_cred); cachefiles_begin_secure(cache, &saved_cred);
cachefiles_update_object_xattr(object, auxdata); cachefiles_update_object_xattr(object, auxdata);
...@@ -309,10 +323,12 @@ static void cachefiles_drop_object(struct fscache_object *_object) ...@@ -309,10 +323,12 @@ static void cachefiles_drop_object(struct fscache_object *_object)
/* /*
* dispose of a reference to an object * dispose of a reference to an object
*/ */
static void cachefiles_put_object(struct fscache_object *_object) static void cachefiles_put_object(struct fscache_object *_object,
enum fscache_obj_ref_trace why)
{ {
struct cachefiles_object *object; struct cachefiles_object *object;
struct fscache_cache *cache; struct fscache_cache *cache;
int u;
ASSERT(_object); ASSERT(_object);
...@@ -328,7 +344,11 @@ static void cachefiles_put_object(struct fscache_object *_object) ...@@ -328,7 +344,11 @@ static void cachefiles_put_object(struct fscache_object *_object)
ASSERTIFCMP(object->fscache.parent, ASSERTIFCMP(object->fscache.parent,
object->fscache.parent->n_children, >, 0); object->fscache.parent->n_children, >, 0);
if (atomic_dec_and_test(&object->usage)) { u = atomic_dec_return(&object->usage);
trace_cachefiles_ref(object, _object->cookie,
(enum cachefiles_obj_ref_trace)why, u);
ASSERTCMP(u, !=, -1);
if (u == 0) {
_debug("- kill object OBJ%x", object->fscache.debug_id); _debug("- kill object OBJ%x", object->fscache.debug_id);
ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)); ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags));
...@@ -421,7 +441,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object) ...@@ -421,7 +441,7 @@ static int cachefiles_attr_changed(struct fscache_object *_object)
loff_t oi_size; loff_t oi_size;
int ret; int ret;
_object->cookie->def->get_attr(_object->cookie->netfs_data, &ni_size); ni_size = _object->store_limit_l;
_enter("{OBJ%x},[%llu]", _enter("{OBJ%x},[%llu]",
_object->debug_id, (unsigned long long) ni_size); _object->debug_id, (unsigned long long) ni_size);
...@@ -493,8 +513,7 @@ static void cachefiles_invalidate_object(struct fscache_operation *op) ...@@ -493,8 +513,7 @@ static void cachefiles_invalidate_object(struct fscache_operation *op)
cache = container_of(object->fscache.cache, cache = container_of(object->fscache.cache,
struct cachefiles_cache, cache); struct cachefiles_cache, cache);
op->object->cookie->def->get_attr(op->object->cookie->netfs_data, ni_size = op->object->store_limit_l;
&ni_size);
_enter("{OBJ%x},[%llu]", _enter("{OBJ%x},[%llu]",
op->object->debug_id, (unsigned long long)ni_size); op->object->debug_id, (unsigned long long)ni_size);
......
...@@ -124,6 +124,8 @@ struct cachefiles_xattr { ...@@ -124,6 +124,8 @@ struct cachefiles_xattr {
uint8_t data[]; uint8_t data[];
}; };
#include <trace/events/cachefiles.h>
/* /*
* note change of state for daemon * note change of state for daemon
*/ */
......
...@@ -22,6 +22,7 @@ ...@@ -22,6 +22,7 @@
#include <linux/statfs.h> #include <linux/statfs.h>
#include <linux/sysctl.h> #include <linux/sysctl.h>
#include <linux/miscdevice.h> #include <linux/miscdevice.h>
#define CREATE_TRACE_POINTS
#include "internal.h" #include "internal.h"
unsigned cachefiles_debug; unsigned cachefiles_debug;
......
...@@ -30,11 +30,11 @@ ...@@ -30,11 +30,11 @@
*/ */
static noinline static noinline
void __cachefiles_printk_object(struct cachefiles_object *object, void __cachefiles_printk_object(struct cachefiles_object *object,
const char *prefix, const char *prefix)
u8 *keybuf)
{ {
struct fscache_cookie *cookie; struct fscache_cookie *cookie;
unsigned keylen, loop; const u8 *k;
unsigned loop;
pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id); pr_err("%sobject: OBJ%x\n", prefix, object->fscache.debug_id);
pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n", pr_err("%sobjstate=%s fl=%lx wbusy=%x ev=%lx[%lx]\n",
...@@ -56,23 +56,16 @@ void __cachefiles_printk_object(struct cachefiles_object *object, ...@@ -56,23 +56,16 @@ void __cachefiles_printk_object(struct cachefiles_object *object,
object->fscache.cookie->parent, object->fscache.cookie->parent,
object->fscache.cookie->netfs_data, object->fscache.cookie->netfs_data,
object->fscache.cookie->flags); object->fscache.cookie->flags);
if (keybuf && cookie->def) pr_err("%skey=[%u] '", prefix, cookie->key_len);
keylen = cookie->def->get_key(cookie->netfs_data, keybuf, k = (cookie->key_len <= sizeof(cookie->inline_key)) ?
CACHEFILES_KEYBUF_SIZE); cookie->inline_key : cookie->key;
else for (loop = 0; loop < cookie->key_len; loop++)
keylen = 0; pr_cont("%02x", k[loop]);
pr_cont("'\n");
} else { } else {
pr_err("%scookie=NULL\n", prefix); pr_err("%scookie=NULL\n", prefix);
keylen = 0;
} }
spin_unlock(&object->fscache.lock); spin_unlock(&object->fscache.lock);
if (keylen) {
pr_err("%skey=[%u] '", prefix, keylen);
for (loop = 0; loop < keylen; loop++)
pr_cont("%02x", keybuf[loop]);
pr_cont("'\n");
}
} }
/* /*
...@@ -81,14 +74,10 @@ void __cachefiles_printk_object(struct cachefiles_object *object, ...@@ -81,14 +74,10 @@ void __cachefiles_printk_object(struct cachefiles_object *object,
static noinline void cachefiles_printk_object(struct cachefiles_object *object, static noinline void cachefiles_printk_object(struct cachefiles_object *object,
struct cachefiles_object *xobject) struct cachefiles_object *xobject)
{ {
u8 *keybuf;
keybuf = kmalloc(CACHEFILES_KEYBUF_SIZE, GFP_NOIO);
if (object) if (object)
__cachefiles_printk_object(object, "", keybuf); __cachefiles_printk_object(object, "");
if (xobject) if (xobject)
__cachefiles_printk_object(xobject, "x", keybuf); __cachefiles_printk_object(xobject, "x");
kfree(keybuf);
} }
/* /*
...@@ -120,6 +109,7 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache, ...@@ -120,6 +109,7 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
} }
write_unlock(&cache->active_lock); write_unlock(&cache->active_lock);
trace_cachefiles_mark_buried(NULL, dentry, why);
_leave(" [no owner]"); _leave(" [no owner]");
return; return;
...@@ -130,6 +120,8 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache, ...@@ -130,6 +120,8 @@ static void cachefiles_mark_object_buried(struct cachefiles_cache *cache,
object->fscache.state->name, object->fscache.state->name,
dentry); dentry);
trace_cachefiles_mark_buried(object, dentry, why);
if (fscache_object_is_live(&object->fscache)) { if (fscache_object_is_live(&object->fscache)) {
pr_err("\n"); pr_err("\n");
pr_err("Error: Can't preemptively bury live object\n"); pr_err("Error: Can't preemptively bury live object\n");
...@@ -158,13 +150,15 @@ static int cachefiles_mark_object_active(struct cachefiles_cache *cache, ...@@ -158,13 +150,15 @@ static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
try_again: try_again:
write_lock(&cache->active_lock); write_lock(&cache->active_lock);
dentry = object->dentry;
trace_cachefiles_mark_active(object, dentry);
if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) { if (test_and_set_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags)) {
pr_err("Error: Object already active\n"); pr_err("Error: Object already active\n");
cachefiles_printk_object(object, NULL); cachefiles_printk_object(object, NULL);
BUG(); BUG();
} }
dentry = object->dentry;
_p = &cache->active_nodes.rb_node; _p = &cache->active_nodes.rb_node;
while (*_p) { while (*_p) {
_parent = *_p; _parent = *_p;
...@@ -191,6 +185,8 @@ static int cachefiles_mark_object_active(struct cachefiles_cache *cache, ...@@ -191,6 +185,8 @@ static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
/* an old object from a previous incarnation is hogging the slot - we /* an old object from a previous incarnation is hogging the slot - we
* need to wait for it to be destroyed */ * need to wait for it to be destroyed */
wait_for_old_object: wait_for_old_object:
trace_cachefiles_wait_active(object, dentry, xobject);
if (fscache_object_is_live(&xobject->fscache)) { if (fscache_object_is_live(&xobject->fscache)) {
pr_err("\n"); pr_err("\n");
pr_err("Error: Unexpected object collision\n"); pr_err("Error: Unexpected object collision\n");
...@@ -248,12 +244,12 @@ static int cachefiles_mark_object_active(struct cachefiles_cache *cache, ...@@ -248,12 +244,12 @@ static int cachefiles_mark_object_active(struct cachefiles_cache *cache,
ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags)); ASSERT(!test_bit(CACHEFILES_OBJECT_ACTIVE, &xobject->flags));
cache->cache.ops->put_object(&xobject->fscache); cache->cache.ops->put_object(&xobject->fscache, cachefiles_obj_put_wait_retry);
goto try_again; goto try_again;
requeue: requeue:
clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
cache->cache.ops->put_object(&xobject->fscache); cache->cache.ops->put_object(&xobject->fscache, cachefiles_obj_put_wait_timeo);
_leave(" = -ETIMEDOUT"); _leave(" = -ETIMEDOUT");
return -ETIMEDOUT; return -ETIMEDOUT;
} }
...@@ -265,6 +261,11 @@ void cachefiles_mark_object_inactive(struct cachefiles_cache *cache, ...@@ -265,6 +261,11 @@ void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
struct cachefiles_object *object, struct cachefiles_object *object,
blkcnt_t i_blocks) blkcnt_t i_blocks)
{ {
struct dentry *dentry = object->dentry;
struct inode *inode = d_backing_inode(dentry);
trace_cachefiles_mark_inactive(object, dentry, inode);
write_lock(&cache->active_lock); write_lock(&cache->active_lock);
rb_erase(&object->active_node, &cache->active_nodes); rb_erase(&object->active_node, &cache->active_nodes);
clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags); clear_bit(CACHEFILES_OBJECT_ACTIVE, &object->flags);
...@@ -288,6 +289,7 @@ void cachefiles_mark_object_inactive(struct cachefiles_cache *cache, ...@@ -288,6 +289,7 @@ void cachefiles_mark_object_inactive(struct cachefiles_cache *cache,
* - unlocks the directory mutex * - unlocks the directory mutex
*/ */
static int cachefiles_bury_object(struct cachefiles_cache *cache, static int cachefiles_bury_object(struct cachefiles_cache *cache,
struct cachefiles_object *object,
struct dentry *dir, struct dentry *dir,
struct dentry *rep, struct dentry *rep,
bool preemptive, bool preemptive,
...@@ -312,6 +314,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache, ...@@ -312,6 +314,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
if (ret < 0) { if (ret < 0) {
cachefiles_io_error(cache, "Unlink security error"); cachefiles_io_error(cache, "Unlink security error");
} else { } else {
trace_cachefiles_unlink(object, rep, why);
ret = vfs_unlink(d_inode(dir), rep, NULL); ret = vfs_unlink(d_inode(dir), rep, NULL);
if (preemptive) if (preemptive)
...@@ -413,6 +416,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache, ...@@ -413,6 +416,7 @@ static int cachefiles_bury_object(struct cachefiles_cache *cache,
if (ret < 0) { if (ret < 0) {
cachefiles_io_error(cache, "Rename security error %d", ret); cachefiles_io_error(cache, "Rename security error %d", ret);
} else { } else {
trace_cachefiles_rename(object, rep, grave, why);
ret = vfs_rename(d_inode(dir), rep, ret = vfs_rename(d_inode(dir), rep,
d_inode(cache->graveyard), grave, NULL, 0); d_inode(cache->graveyard), grave, NULL, 0);
if (ret != 0 && ret != -ENOMEM) if (ret != 0 && ret != -ENOMEM)
...@@ -458,7 +462,7 @@ int cachefiles_delete_object(struct cachefiles_cache *cache, ...@@ -458,7 +462,7 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
/* we need to check that our parent is _still_ our parent - it /* we need to check that our parent is _still_ our parent - it
* may have been renamed */ * may have been renamed */
if (dir == object->dentry->d_parent) { if (dir == object->dentry->d_parent) {
ret = cachefiles_bury_object(cache, dir, ret = cachefiles_bury_object(cache, object, dir,
object->dentry, false, object->dentry, false,
FSCACHE_OBJECT_WAS_RETIRED); FSCACHE_OBJECT_WAS_RETIRED);
} else { } else {
...@@ -486,6 +490,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, ...@@ -486,6 +490,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
{ {
struct cachefiles_cache *cache; struct cachefiles_cache *cache;
struct dentry *dir, *next = NULL; struct dentry *dir, *next = NULL;
struct inode *inode;
struct path path; struct path path;
unsigned long start; unsigned long start;
const char *name; const char *name;
...@@ -529,13 +534,17 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, ...@@ -529,13 +534,17 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
start = jiffies; start = jiffies;
next = lookup_one_len(name, dir, nlen); next = lookup_one_len(name, dir, nlen);
cachefiles_hist(cachefiles_lookup_histogram, start); cachefiles_hist(cachefiles_lookup_histogram, start);
if (IS_ERR(next)) if (IS_ERR(next)) {
trace_cachefiles_lookup(object, next, NULL);
goto lookup_error; goto lookup_error;
}
_debug("next -> %p %s", next, d_backing_inode(next) ? "positive" : "negative"); inode = d_backing_inode(next);
trace_cachefiles_lookup(object, next, inode);
_debug("next -> %p %s", next, inode ? "positive" : "negative");
if (!key) if (!key)
object->new = !d_backing_inode(next); object->new = !inode;
/* if this element of the path doesn't exist, then the lookup phase /* if this element of the path doesn't exist, then the lookup phase
* failed, and we can release any readers in the certain knowledge that * failed, and we can release any readers in the certain knowledge that
...@@ -558,6 +567,8 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, ...@@ -558,6 +567,8 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
start = jiffies; start = jiffies;
ret = vfs_mkdir(d_inode(dir), next, 0); ret = vfs_mkdir(d_inode(dir), next, 0);
cachefiles_hist(cachefiles_mkdir_histogram, start); cachefiles_hist(cachefiles_mkdir_histogram, start);
if (!key)
trace_cachefiles_mkdir(object, next, ret);
if (ret < 0) if (ret < 0)
goto create_error; goto create_error;
...@@ -587,6 +598,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, ...@@ -587,6 +598,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
start = jiffies; start = jiffies;
ret = vfs_create(d_inode(dir), next, S_IFREG, true); ret = vfs_create(d_inode(dir), next, S_IFREG, true);
cachefiles_hist(cachefiles_create_histogram, start); cachefiles_hist(cachefiles_create_histogram, start);
trace_cachefiles_create(object, next, ret);
if (ret < 0) if (ret < 0)
goto create_error; goto create_error;
...@@ -629,7 +641,8 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent, ...@@ -629,7 +641,8 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
* mutex) */ * mutex) */
object->dentry = NULL; object->dentry = NULL;
ret = cachefiles_bury_object(cache, dir, next, true, ret = cachefiles_bury_object(cache, object, dir, next,
true,
FSCACHE_OBJECT_IS_STALE); FSCACHE_OBJECT_IS_STALE);
dput(next); dput(next);
next = NULL; next = NULL;
...@@ -955,7 +968,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir, ...@@ -955,7 +968,7 @@ int cachefiles_cull(struct cachefiles_cache *cache, struct dentry *dir,
/* actually remove the victim (drops the dir mutex) */ /* actually remove the victim (drops the dir mutex) */
_debug("bury"); _debug("bury");
ret = cachefiles_bury_object(cache, dir, victim, false, ret = cachefiles_bury_object(cache, NULL, dir, victim, false,
FSCACHE_OBJECT_WAS_CULLED); FSCACHE_OBJECT_WAS_CULLED);
if (ret < 0) if (ret < 0)
goto error; goto error;
......
...@@ -952,6 +952,7 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page) ...@@ -952,6 +952,7 @@ int cachefiles_write_page(struct fscache_storage *op, struct page *page)
* - cache withdrawal is prevented by the caller * - cache withdrawal is prevented by the caller
*/ */
void cachefiles_uncache_page(struct fscache_object *_object, struct page *page) void cachefiles_uncache_page(struct fscache_object *_object, struct page *page)
__releases(&object->fscache.cookie->lock)
{ {
struct cachefiles_object *object; struct cachefiles_object *object;
struct cachefiles_cache *cache; struct cachefiles_cache *cache;
......
...@@ -113,6 +113,7 @@ int cachefiles_set_object_xattr(struct cachefiles_object *object, ...@@ -113,6 +113,7 @@ int cachefiles_set_object_xattr(struct cachefiles_object *object,
/* attempt to install the cache metadata directly */ /* attempt to install the cache metadata directly */
_debug("SET #%u", auxdata->len); _debug("SET #%u", auxdata->len);
clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
ret = vfs_setxattr(dentry, cachefiles_xattr_cache, ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
&auxdata->type, auxdata->len, &auxdata->type, auxdata->len,
XATTR_CREATE); XATTR_CREATE);
...@@ -141,6 +142,7 @@ int cachefiles_update_object_xattr(struct cachefiles_object *object, ...@@ -141,6 +142,7 @@ int cachefiles_update_object_xattr(struct cachefiles_object *object,
/* attempt to install the cache metadata directly */ /* attempt to install the cache metadata directly */
_debug("SET #%u", auxdata->len); _debug("SET #%u", auxdata->len);
clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
ret = vfs_setxattr(dentry, cachefiles_xattr_cache, ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
&auxdata->type, auxdata->len, &auxdata->type, auxdata->len,
XATTR_REPLACE); XATTR_REPLACE);
...@@ -180,7 +182,8 @@ int cachefiles_check_auxdata(struct cachefiles_object *object) ...@@ -180,7 +182,8 @@ int cachefiles_check_auxdata(struct cachefiles_object *object)
goto error; goto error;
xlen--; xlen--;
validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen); validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
i_size_read(d_backing_inode(dentry)));
if (validity != FSCACHE_CHECKAUX_OKAY) if (validity != FSCACHE_CHECKAUX_OKAY)
goto error; goto error;
...@@ -249,7 +252,8 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object, ...@@ -249,7 +252,8 @@ int cachefiles_check_object_xattr(struct cachefiles_object *object,
object->fscache.cookie->def->name, dlen); object->fscache.cookie->def->name, dlen);
result = fscache_check_aux(&object->fscache, result = fscache_check_aux(&object->fscache,
&auxbuf->data, dlen); &auxbuf->data, dlen,
i_size_read(d_backing_inode(dentry)));
switch (result) { switch (result) {
/* entry okay as is */ /* entry okay as is */
......
...@@ -27,7 +27,6 @@ ...@@ -27,7 +27,6 @@
struct ceph_aux_inode { struct ceph_aux_inode {
u64 version; u64 version;
struct timespec mtime; struct timespec mtime;
loff_t size;
}; };
struct fscache_netfs ceph_cache_netfs = { struct fscache_netfs ceph_cache_netfs = {
...@@ -41,34 +40,15 @@ static LIST_HEAD(ceph_fscache_list); ...@@ -41,34 +40,15 @@ static LIST_HEAD(ceph_fscache_list);
struct ceph_fscache_entry { struct ceph_fscache_entry {
struct list_head list; struct list_head list;
struct fscache_cookie *fscache; struct fscache_cookie *fscache;
struct ceph_fsid fsid;
size_t uniq_len; size_t uniq_len;
/* The following members must be last */
struct ceph_fsid fsid;
char uniquifier[0]; char uniquifier[0];
}; };
static uint16_t ceph_fscache_session_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t maxbuf)
{
const struct ceph_fs_client* fsc = cookie_netfs_data;
const char *fscache_uniq = fsc->mount_options->fscache_uniq;
uint16_t fsid_len, uniq_len;
fsid_len = sizeof(fsc->client->fsid);
uniq_len = fscache_uniq ? strlen(fscache_uniq) : 0;
if (fsid_len + uniq_len > maxbuf)
return 0;
memcpy(buffer, &fsc->client->fsid, fsid_len);
if (uniq_len)
memcpy(buffer + fsid_len, fscache_uniq, uniq_len);
return fsid_len + uniq_len;
}
static const struct fscache_cookie_def ceph_fscache_fsid_object_def = { static const struct fscache_cookie_def ceph_fscache_fsid_object_def = {
.name = "CEPH.fsid", .name = "CEPH.fsid",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = ceph_fscache_session_get_key,
}; };
int ceph_fscache_register(void) int ceph_fscache_register(void)
...@@ -110,16 +90,19 @@ int ceph_fscache_register_fs(struct ceph_fs_client* fsc) ...@@ -110,16 +90,19 @@ int ceph_fscache_register_fs(struct ceph_fs_client* fsc)
goto out_unlock; goto out_unlock;
} }
fsc->fscache = fscache_acquire_cookie(ceph_cache_netfs.primary_index,
&ceph_fscache_fsid_object_def,
fsc, true);
if (fsc->fscache) {
memcpy(&ent->fsid, fsid, sizeof(*fsid)); memcpy(&ent->fsid, fsid, sizeof(*fsid));
if (uniq_len > 0) { if (uniq_len > 0) {
memcpy(&ent->uniquifier, fscache_uniq, uniq_len); memcpy(&ent->uniquifier, fscache_uniq, uniq_len);
ent->uniq_len = uniq_len; ent->uniq_len = uniq_len;
} }
fsc->fscache = fscache_acquire_cookie(ceph_cache_netfs.primary_index,
&ceph_fscache_fsid_object_def,
&ent->fsid, sizeof(ent->fsid) + uniq_len,
NULL, 0,
fsc, 0, true);
if (fsc->fscache) {
ent->fscache = fsc->fscache; ent->fscache = fsc->fscache;
list_add_tail(&ent->list, &ceph_fscache_list); list_add_tail(&ent->list, &ceph_fscache_list);
} else { } else {
...@@ -133,59 +116,21 @@ int ceph_fscache_register_fs(struct ceph_fs_client* fsc) ...@@ -133,59 +116,21 @@ int ceph_fscache_register_fs(struct ceph_fs_client* fsc)
return err; return err;
} }
static uint16_t ceph_fscache_inode_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t maxbuf)
{
const struct ceph_inode_info* ci = cookie_netfs_data;
uint16_t klen;
/* use ceph virtual inode (id + snapshot) */
klen = sizeof(ci->i_vino);
if (klen > maxbuf)
return 0;
memcpy(buffer, &ci->i_vino, klen);
return klen;
}
static uint16_t ceph_fscache_inode_get_aux(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
struct ceph_aux_inode aux;
const struct ceph_inode_info* ci = cookie_netfs_data;
const struct inode* inode = &ci->vfs_inode;
memset(&aux, 0, sizeof(aux));
aux.version = ci->i_version;
aux.mtime = inode->i_mtime;
aux.size = i_size_read(inode);
memcpy(buffer, &aux, sizeof(aux));
return sizeof(aux);
}
static void ceph_fscache_inode_get_attr(const void *cookie_netfs_data,
uint64_t *size)
{
const struct ceph_inode_info* ci = cookie_netfs_data;
*size = i_size_read(&ci->vfs_inode);
}
static enum fscache_checkaux ceph_fscache_inode_check_aux( static enum fscache_checkaux ceph_fscache_inode_check_aux(
void *cookie_netfs_data, const void *data, uint16_t dlen) void *cookie_netfs_data, const void *data, uint16_t dlen,
loff_t object_size)
{ {
struct ceph_aux_inode aux; struct ceph_aux_inode aux;
struct ceph_inode_info* ci = cookie_netfs_data; struct ceph_inode_info* ci = cookie_netfs_data;
struct inode* inode = &ci->vfs_inode; struct inode* inode = &ci->vfs_inode;
if (dlen != sizeof(aux)) if (dlen != sizeof(aux) ||
i_size_read(inode) != object_size)
return FSCACHE_CHECKAUX_OBSOLETE; return FSCACHE_CHECKAUX_OBSOLETE;
memset(&aux, 0, sizeof(aux)); memset(&aux, 0, sizeof(aux));
aux.version = ci->i_version; aux.version = ci->i_version;
aux.mtime = inode->i_mtime; aux.mtime = inode->i_mtime;
aux.size = i_size_read(inode);
if (memcmp(data, &aux, sizeof(aux)) != 0) if (memcmp(data, &aux, sizeof(aux)) != 0)
return FSCACHE_CHECKAUX_OBSOLETE; return FSCACHE_CHECKAUX_OBSOLETE;
...@@ -197,9 +142,6 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux( ...@@ -197,9 +142,6 @@ static enum fscache_checkaux ceph_fscache_inode_check_aux(
static const struct fscache_cookie_def ceph_fscache_inode_object_def = { static const struct fscache_cookie_def ceph_fscache_inode_object_def = {
.name = "CEPH.inode", .name = "CEPH.inode",
.type = FSCACHE_COOKIE_TYPE_DATAFILE, .type = FSCACHE_COOKIE_TYPE_DATAFILE,
.get_key = ceph_fscache_inode_get_key,
.get_attr = ceph_fscache_inode_get_attr,
.get_aux = ceph_fscache_inode_get_aux,
.check_aux = ceph_fscache_inode_check_aux, .check_aux = ceph_fscache_inode_check_aux,
}; };
...@@ -207,6 +149,7 @@ void ceph_fscache_register_inode_cookie(struct inode *inode) ...@@ -207,6 +149,7 @@ void ceph_fscache_register_inode_cookie(struct inode *inode)
{ {
struct ceph_inode_info *ci = ceph_inode(inode); struct ceph_inode_info *ci = ceph_inode(inode);
struct ceph_fs_client *fsc = ceph_inode_to_client(inode); struct ceph_fs_client *fsc = ceph_inode_to_client(inode);
struct ceph_aux_inode aux;
/* No caching for filesystem */ /* No caching for filesystem */
if (!fsc->fscache) if (!fsc->fscache)
...@@ -218,9 +161,14 @@ void ceph_fscache_register_inode_cookie(struct inode *inode) ...@@ -218,9 +161,14 @@ void ceph_fscache_register_inode_cookie(struct inode *inode)
inode_lock_nested(inode, I_MUTEX_CHILD); inode_lock_nested(inode, I_MUTEX_CHILD);
if (!ci->fscache) { if (!ci->fscache) {
memset(&aux, 0, sizeof(aux));
aux.version = ci->i_version;
aux.mtime = inode->i_mtime;
ci->fscache = fscache_acquire_cookie(fsc->fscache, ci->fscache = fscache_acquire_cookie(fsc->fscache,
&ceph_fscache_inode_object_def, &ceph_fscache_inode_object_def,
ci, false); &ci->i_vino, sizeof(ci->i_vino),
&aux, sizeof(aux),
ci, i_size_read(inode), false);
} }
inode_unlock(inode); inode_unlock(inode);
} }
...@@ -235,7 +183,7 @@ void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci) ...@@ -235,7 +183,7 @@ void ceph_fscache_unregister_inode_cookie(struct ceph_inode_info* ci)
ci->fscache = NULL; ci->fscache = NULL;
fscache_uncache_all_inode_pages(cookie, &ci->vfs_inode); fscache_uncache_all_inode_pages(cookie, &ci->vfs_inode);
fscache_relinquish_cookie(cookie, 0); fscache_relinquish_cookie(cookie, &ci->i_vino, false);
} }
static bool ceph_fscache_can_enable(void *data) static bool ceph_fscache_can_enable(void *data)
...@@ -254,11 +202,11 @@ void ceph_fscache_file_set_cookie(struct inode *inode, struct file *filp) ...@@ -254,11 +202,11 @@ void ceph_fscache_file_set_cookie(struct inode *inode, struct file *filp)
if (inode_is_open_for_write(inode)) { if (inode_is_open_for_write(inode)) {
dout("fscache_file_set_cookie %p %p disabling cache\n", dout("fscache_file_set_cookie %p %p disabling cache\n",
inode, filp); inode, filp);
fscache_disable_cookie(ci->fscache, false); fscache_disable_cookie(ci->fscache, &ci->i_vino, false);
fscache_uncache_all_inode_pages(ci->fscache, inode); fscache_uncache_all_inode_pages(ci->fscache, inode);
} else { } else {
fscache_enable_cookie(ci->fscache, ceph_fscache_can_enable, fscache_enable_cookie(ci->fscache, &ci->i_vino, i_size_read(inode),
inode); ceph_fscache_can_enable, inode);
if (fscache_cookie_enabled(ci->fscache)) { if (fscache_cookie_enabled(ci->fscache)) {
dout("fscache_file_set_cookie %p %p enabling cache\n", dout("fscache_file_set_cookie %p %p enabling cache\n",
inode, filp); inode, filp);
...@@ -351,7 +299,8 @@ void ceph_readpage_to_fscache(struct inode *inode, struct page *page) ...@@ -351,7 +299,8 @@ void ceph_readpage_to_fscache(struct inode *inode, struct page *page)
if (!cache_valid(ci)) if (!cache_valid(ci))
return; return;
ret = fscache_write_page(ci->fscache, page, GFP_KERNEL); ret = fscache_write_page(ci->fscache, page, i_size_read(inode),
GFP_KERNEL);
if (ret) if (ret)
fscache_uncache_page(ci->fscache, page); fscache_uncache_page(ci->fscache, page);
} }
...@@ -385,7 +334,7 @@ void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc) ...@@ -385,7 +334,7 @@ void ceph_fscache_unregister_fs(struct ceph_fs_client* fsc)
WARN_ON_ONCE(!found); WARN_ON_ONCE(!found);
mutex_unlock(&ceph_fscache_lock); mutex_unlock(&ceph_fscache_lock);
__fscache_relinquish_cookie(fsc->fscache, 0); __fscache_relinquish_cookie(fsc->fscache, NULL, false);
} }
fsc->fscache = NULL; fsc->fscache = NULL;
} }
...@@ -402,7 +351,7 @@ void ceph_fscache_revalidate_cookie(struct ceph_inode_info *ci) ...@@ -402,7 +351,7 @@ void ceph_fscache_revalidate_cookie(struct ceph_inode_info *ci)
* truncate while the caller holds CEPH_CAP_FILE_RD */ * truncate while the caller holds CEPH_CAP_FILE_RD */
mutex_lock(&ci->i_truncate_mutex); mutex_lock(&ci->i_truncate_mutex);
if (!cache_valid(ci)) { if (!cache_valid(ci)) {
if (fscache_check_consistency(ci->fscache)) if (fscache_check_consistency(ci->fscache, &ci->i_vino))
fscache_invalidate(ci->fscache); fscache_invalidate(ci->fscache);
spin_lock(&ci->i_ceph_lock); spin_lock(&ci->i_ceph_lock);
ci->i_fscache_gen = ci->i_rdcache_gen; ci->i_fscache_gen = ci->i_rdcache_gen;
......
...@@ -45,68 +45,12 @@ void cifs_fscache_unregister(void) ...@@ -45,68 +45,12 @@ void cifs_fscache_unregister(void)
fscache_unregister_netfs(&cifs_fscache_netfs); fscache_unregister_netfs(&cifs_fscache_netfs);
} }
/*
* Key layout of CIFS server cache index object
*/
struct cifs_server_key {
uint16_t family; /* address family */
__be16 port; /* IP port */
union {
struct in_addr ipv4_addr;
struct in6_addr ipv6_addr;
} addr[0];
};
/*
* Server object keyed by {IPaddress,port,family} tuple
*/
static uint16_t cifs_server_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t maxbuf)
{
const struct TCP_Server_Info *server = cookie_netfs_data;
const struct sockaddr *sa = (struct sockaddr *) &server->dstaddr;
const struct sockaddr_in *addr = (struct sockaddr_in *) sa;
const struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) sa;
struct cifs_server_key *key = buffer;
uint16_t key_len = sizeof(struct cifs_server_key);
memset(key, 0, key_len);
/*
* Should not be a problem as sin_family/sin6_family overlays
* sa_family field
*/
switch (sa->sa_family) {
case AF_INET:
key->family = sa->sa_family;
key->port = addr->sin_port;
key->addr[0].ipv4_addr = addr->sin_addr;
key_len += sizeof(key->addr[0].ipv4_addr);
break;
case AF_INET6:
key->family = sa->sa_family;
key->port = addr6->sin6_port;
key->addr[0].ipv6_addr = addr6->sin6_addr;
key_len += sizeof(key->addr[0].ipv6_addr);
break;
default:
cifs_dbg(VFS, "Unknown network family '%d'\n", sa->sa_family);
key_len = 0;
break;
}
return key_len;
}
/* /*
* Server object for FS-Cache * Server object for FS-Cache
*/ */
const struct fscache_cookie_def cifs_fscache_server_index_def = { const struct fscache_cookie_def cifs_fscache_server_index_def = {
.name = "CIFS.server", .name = "CIFS.server",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = cifs_server_get_key,
}; };
/* /*
...@@ -116,7 +60,7 @@ struct cifs_fscache_super_auxdata { ...@@ -116,7 +60,7 @@ struct cifs_fscache_super_auxdata {
u64 resource_id; /* unique server resource id */ u64 resource_id; /* unique server resource id */
}; };
static char *extract_sharename(const char *treename) char *extract_sharename(const char *treename)
{ {
const char *src; const char *src;
char *delim, *dst; char *delim, *dst;
...@@ -140,56 +84,11 @@ static char *extract_sharename(const char *treename) ...@@ -140,56 +84,11 @@ static char *extract_sharename(const char *treename)
return dst; return dst;
} }
/*
* Superblock object currently keyed by share name
*/
static uint16_t cifs_super_get_key(const void *cookie_netfs_data, void *buffer,
uint16_t maxbuf)
{
const struct cifs_tcon *tcon = cookie_netfs_data;
char *sharename;
uint16_t len;
sharename = extract_sharename(tcon->treeName);
if (IS_ERR(sharename)) {
cifs_dbg(FYI, "%s: couldn't extract sharename\n", __func__);
sharename = NULL;
return 0;
}
len = strlen(sharename);
if (len > maxbuf)
return 0;
memcpy(buffer, sharename, len);
kfree(sharename);
return len;
}
static uint16_t
cifs_fscache_super_get_aux(const void *cookie_netfs_data, void *buffer,
uint16_t maxbuf)
{
struct cifs_fscache_super_auxdata auxdata;
const struct cifs_tcon *tcon = cookie_netfs_data;
memset(&auxdata, 0, sizeof(auxdata));
auxdata.resource_id = tcon->resource_id;
if (maxbuf > sizeof(auxdata))
maxbuf = sizeof(auxdata);
memcpy(buffer, &auxdata, maxbuf);
return maxbuf;
}
static enum static enum
fscache_checkaux cifs_fscache_super_check_aux(void *cookie_netfs_data, fscache_checkaux cifs_fscache_super_check_aux(void *cookie_netfs_data,
const void *data, const void *data,
uint16_t datalen) uint16_t datalen,
loff_t object_size)
{ {
struct cifs_fscache_super_auxdata auxdata; struct cifs_fscache_super_auxdata auxdata;
const struct cifs_tcon *tcon = cookie_netfs_data; const struct cifs_tcon *tcon = cookie_netfs_data;
...@@ -212,68 +111,14 @@ fscache_checkaux cifs_fscache_super_check_aux(void *cookie_netfs_data, ...@@ -212,68 +111,14 @@ fscache_checkaux cifs_fscache_super_check_aux(void *cookie_netfs_data,
const struct fscache_cookie_def cifs_fscache_super_index_def = { const struct fscache_cookie_def cifs_fscache_super_index_def = {
.name = "CIFS.super", .name = "CIFS.super",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = cifs_super_get_key,
.get_aux = cifs_fscache_super_get_aux,
.check_aux = cifs_fscache_super_check_aux, .check_aux = cifs_fscache_super_check_aux,
}; };
/*
* Auxiliary data attached to CIFS inode within the cache
*/
struct cifs_fscache_inode_auxdata {
struct timespec last_write_time;
struct timespec last_change_time;
u64 eof;
};
static uint16_t cifs_fscache_inode_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t maxbuf)
{
const struct cifsInodeInfo *cifsi = cookie_netfs_data;
uint16_t keylen;
/* use the UniqueId as the key */
keylen = sizeof(cifsi->uniqueid);
if (keylen > maxbuf)
keylen = 0;
else
memcpy(buffer, &cifsi->uniqueid, keylen);
return keylen;
}
static void
cifs_fscache_inode_get_attr(const void *cookie_netfs_data, uint64_t *size)
{
const struct cifsInodeInfo *cifsi = cookie_netfs_data;
*size = cifsi->vfs_inode.i_size;
}
static uint16_t
cifs_fscache_inode_get_aux(const void *cookie_netfs_data, void *buffer,
uint16_t maxbuf)
{
struct cifs_fscache_inode_auxdata auxdata;
const struct cifsInodeInfo *cifsi = cookie_netfs_data;
memset(&auxdata, 0, sizeof(auxdata));
auxdata.eof = cifsi->server_eof;
auxdata.last_write_time = cifsi->vfs_inode.i_mtime;
auxdata.last_change_time = cifsi->vfs_inode.i_ctime;
if (maxbuf > sizeof(auxdata))
maxbuf = sizeof(auxdata);
memcpy(buffer, &auxdata, maxbuf);
return maxbuf;
}
static enum static enum
fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data, fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data,
const void *data, const void *data,
uint16_t datalen) uint16_t datalen,
loff_t object_size)
{ {
struct cifs_fscache_inode_auxdata auxdata; struct cifs_fscache_inode_auxdata auxdata;
struct cifsInodeInfo *cifsi = cookie_netfs_data; struct cifsInodeInfo *cifsi = cookie_netfs_data;
...@@ -295,8 +140,5 @@ fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data, ...@@ -295,8 +140,5 @@ fscache_checkaux cifs_fscache_inode_check_aux(void *cookie_netfs_data,
const struct fscache_cookie_def cifs_fscache_inode_object_def = { const struct fscache_cookie_def cifs_fscache_inode_object_def = {
.name = "CIFS.uniqueid", .name = "CIFS.uniqueid",
.type = FSCACHE_COOKIE_TYPE_DATAFILE, .type = FSCACHE_COOKIE_TYPE_DATAFILE,
.get_key = cifs_fscache_inode_get_key,
.get_attr = cifs_fscache_inode_get_attr,
.get_aux = cifs_fscache_inode_get_aux,
.check_aux = cifs_fscache_inode_check_aux, .check_aux = cifs_fscache_inode_check_aux,
}; };
...@@ -23,11 +23,63 @@ ...@@ -23,11 +23,63 @@
#include "cifs_debug.h" #include "cifs_debug.h"
#include "cifs_fs_sb.h" #include "cifs_fs_sb.h"
/*
* Key layout of CIFS server cache index object
*/
struct cifs_server_key {
struct {
uint16_t family; /* address family */
__be16 port; /* IP port */
} hdr;
union {
struct in_addr ipv4_addr;
struct in6_addr ipv6_addr;
};
} __packed;
/*
* Get a cookie for a server object keyed by {IPaddress,port,family} tuple
*/
void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server) void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)
{ {
const struct sockaddr *sa = (struct sockaddr *) &server->dstaddr;
const struct sockaddr_in *addr = (struct sockaddr_in *) sa;
const struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) sa;
struct cifs_server_key key;
uint16_t key_len = sizeof(key.hdr);
memset(&key, 0, sizeof(key));
/*
* Should not be a problem as sin_family/sin6_family overlays
* sa_family field
*/
key.hdr.family = sa->sa_family;
switch (sa->sa_family) {
case AF_INET:
key.hdr.port = addr->sin_port;
key.ipv4_addr = addr->sin_addr;
key_len += sizeof(key.ipv4_addr);
break;
case AF_INET6:
key.hdr.port = addr6->sin6_port;
key.ipv6_addr = addr6->sin6_addr;
key_len += sizeof(key.ipv6_addr);
break;
default:
cifs_dbg(VFS, "Unknown network family '%d'\n", sa->sa_family);
server->fscache = NULL;
return;
}
server->fscache = server->fscache =
fscache_acquire_cookie(cifs_fscache_netfs.primary_index, fscache_acquire_cookie(cifs_fscache_netfs.primary_index,
&cifs_fscache_server_index_def, server, true); &cifs_fscache_server_index_def,
&key, key_len,
NULL, 0,
server, 0, true);
cifs_dbg(FYI, "%s: (0x%p/0x%p)\n", cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
__func__, server, server->fscache); __func__, server, server->fscache);
} }
...@@ -36,17 +88,29 @@ void cifs_fscache_release_client_cookie(struct TCP_Server_Info *server) ...@@ -36,17 +88,29 @@ void cifs_fscache_release_client_cookie(struct TCP_Server_Info *server)
{ {
cifs_dbg(FYI, "%s: (0x%p/0x%p)\n", cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
__func__, server, server->fscache); __func__, server, server->fscache);
fscache_relinquish_cookie(server->fscache, 0); fscache_relinquish_cookie(server->fscache, NULL, false);
server->fscache = NULL; server->fscache = NULL;
} }
void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon) void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon)
{ {
struct TCP_Server_Info *server = tcon->ses->server; struct TCP_Server_Info *server = tcon->ses->server;
char *sharename;
sharename = extract_sharename(tcon->treeName);
if (IS_ERR(sharename)) {
cifs_dbg(FYI, "%s: couldn't extract sharename\n", __func__);
tcon->fscache = NULL;
return;
}
tcon->fscache = tcon->fscache =
fscache_acquire_cookie(server->fscache, fscache_acquire_cookie(server->fscache,
&cifs_fscache_super_index_def, tcon, true); &cifs_fscache_super_index_def,
sharename, strlen(sharename),
&tcon->resource_id, sizeof(tcon->resource_id),
tcon, 0, true);
kfree(sharename);
cifs_dbg(FYI, "%s: (0x%p/0x%p)\n", cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
__func__, server->fscache, tcon->fscache); __func__, server->fscache, tcon->fscache);
} }
...@@ -54,10 +118,28 @@ void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon) ...@@ -54,10 +118,28 @@ void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon)
void cifs_fscache_release_super_cookie(struct cifs_tcon *tcon) void cifs_fscache_release_super_cookie(struct cifs_tcon *tcon)
{ {
cifs_dbg(FYI, "%s: (0x%p)\n", __func__, tcon->fscache); cifs_dbg(FYI, "%s: (0x%p)\n", __func__, tcon->fscache);
fscache_relinquish_cookie(tcon->fscache, 0); fscache_relinquish_cookie(tcon->fscache, &tcon->resource_id, false);
tcon->fscache = NULL; tcon->fscache = NULL;
} }
static void cifs_fscache_acquire_inode_cookie(struct cifsInodeInfo *cifsi,
struct cifs_tcon *tcon)
{
struct cifs_fscache_inode_auxdata auxdata;
memset(&auxdata, 0, sizeof(auxdata));
auxdata.eof = cifsi->server_eof;
auxdata.last_write_time = cifsi->vfs_inode.i_mtime;
auxdata.last_change_time = cifsi->vfs_inode.i_ctime;
cifsi->fscache =
fscache_acquire_cookie(tcon->fscache,
&cifs_fscache_inode_object_def,
&cifsi->uniqueid, sizeof(cifsi->uniqueid),
&auxdata, sizeof(auxdata),
cifsi, cifsi->vfs_inode.i_size, true);
}
static void cifs_fscache_enable_inode_cookie(struct inode *inode) static void cifs_fscache_enable_inode_cookie(struct inode *inode)
{ {
struct cifsInodeInfo *cifsi = CIFS_I(inode); struct cifsInodeInfo *cifsi = CIFS_I(inode);
...@@ -67,21 +149,28 @@ static void cifs_fscache_enable_inode_cookie(struct inode *inode) ...@@ -67,21 +149,28 @@ static void cifs_fscache_enable_inode_cookie(struct inode *inode)
if (cifsi->fscache) if (cifsi->fscache)
return; return;
if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE) { if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_FSCACHE))
cifsi->fscache = fscache_acquire_cookie(tcon->fscache, return;
&cifs_fscache_inode_object_def, cifsi, true);
cifs_fscache_acquire_inode_cookie(cifsi, tcon);
cifs_dbg(FYI, "%s: got FH cookie (0x%p/0x%p)\n", cifs_dbg(FYI, "%s: got FH cookie (0x%p/0x%p)\n",
__func__, tcon->fscache, cifsi->fscache); __func__, tcon->fscache, cifsi->fscache);
}
} }
void cifs_fscache_release_inode_cookie(struct inode *inode) void cifs_fscache_release_inode_cookie(struct inode *inode)
{ {
struct cifs_fscache_inode_auxdata auxdata;
struct cifsInodeInfo *cifsi = CIFS_I(inode); struct cifsInodeInfo *cifsi = CIFS_I(inode);
if (cifsi->fscache) { if (cifsi->fscache) {
memset(&auxdata, 0, sizeof(auxdata));
auxdata.eof = cifsi->server_eof;
auxdata.last_write_time = cifsi->vfs_inode.i_mtime;
auxdata.last_change_time = cifsi->vfs_inode.i_ctime;
cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache); cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache);
fscache_relinquish_cookie(cifsi->fscache, 0); fscache_relinquish_cookie(cifsi->fscache, &auxdata, false);
cifsi->fscache = NULL; cifsi->fscache = NULL;
} }
} }
...@@ -93,7 +182,7 @@ static void cifs_fscache_disable_inode_cookie(struct inode *inode) ...@@ -93,7 +182,7 @@ static void cifs_fscache_disable_inode_cookie(struct inode *inode)
if (cifsi->fscache) { if (cifsi->fscache) {
cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache); cifs_dbg(FYI, "%s: (0x%p)\n", __func__, cifsi->fscache);
fscache_uncache_all_inode_pages(cifsi->fscache, inode); fscache_uncache_all_inode_pages(cifsi->fscache, inode);
fscache_relinquish_cookie(cifsi->fscache, 1); fscache_relinquish_cookie(cifsi->fscache, NULL, true);
cifsi->fscache = NULL; cifsi->fscache = NULL;
} }
} }
...@@ -110,16 +199,14 @@ void cifs_fscache_reset_inode_cookie(struct inode *inode) ...@@ -110,16 +199,14 @@ void cifs_fscache_reset_inode_cookie(struct inode *inode)
{ {
struct cifsInodeInfo *cifsi = CIFS_I(inode); struct cifsInodeInfo *cifsi = CIFS_I(inode);
struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
struct fscache_cookie *old = cifsi->fscache; struct fscache_cookie *old = cifsi->fscache;
if (cifsi->fscache) { if (cifsi->fscache) {
/* retire the current fscache cache and get a new one */ /* retire the current fscache cache and get a new one */
fscache_relinquish_cookie(cifsi->fscache, 1); fscache_relinquish_cookie(cifsi->fscache, NULL, true);
cifsi->fscache = fscache_acquire_cookie( cifs_fscache_acquire_inode_cookie(cifsi, tcon);
cifs_sb_master_tcon(cifs_sb)->fscache,
&cifs_fscache_inode_object_def,
cifsi, true);
cifs_dbg(FYI, "%s: new cookie 0x%p oldcookie 0x%p\n", cifs_dbg(FYI, "%s: new cookie 0x%p oldcookie 0x%p\n",
__func__, cifsi->fscache, old); __func__, cifsi->fscache, old);
} }
...@@ -214,13 +301,15 @@ int __cifs_readpages_from_fscache(struct inode *inode, ...@@ -214,13 +301,15 @@ int __cifs_readpages_from_fscache(struct inode *inode,
void __cifs_readpage_to_fscache(struct inode *inode, struct page *page) void __cifs_readpage_to_fscache(struct inode *inode, struct page *page)
{ {
struct cifsInodeInfo *cifsi = CIFS_I(inode);
int ret; int ret;
cifs_dbg(FYI, "%s: (fsc: %p, p: %p, i: %p)\n", cifs_dbg(FYI, "%s: (fsc: %p, p: %p, i: %p)\n",
__func__, CIFS_I(inode)->fscache, page, inode); __func__, cifsi->fscache, page, inode);
ret = fscache_write_page(CIFS_I(inode)->fscache, page, GFP_KERNEL); ret = fscache_write_page(cifsi->fscache, page,
cifsi->vfs_inode.i_size, GFP_KERNEL);
if (ret != 0) if (ret != 0)
fscache_uncache_page(CIFS_I(inode)->fscache, page); fscache_uncache_page(cifsi->fscache, page);
} }
void __cifs_fscache_readpages_cancel(struct inode *inode, struct list_head *pages) void __cifs_fscache_readpages_cancel(struct inode *inode, struct list_head *pages)
...@@ -239,4 +328,3 @@ void __cifs_fscache_invalidate_page(struct page *page, struct inode *inode) ...@@ -239,4 +328,3 @@ void __cifs_fscache_invalidate_page(struct page *page, struct inode *inode)
fscache_wait_on_page_write(cookie, page); fscache_wait_on_page_write(cookie, page);
fscache_uncache_page(cookie, page); fscache_uncache_page(cookie, page);
} }
...@@ -27,6 +27,18 @@ ...@@ -27,6 +27,18 @@
#ifdef CONFIG_CIFS_FSCACHE #ifdef CONFIG_CIFS_FSCACHE
/*
* Auxiliary data attached to CIFS inode within the cache
*/
struct cifs_fscache_inode_auxdata {
struct timespec last_write_time;
struct timespec last_change_time;
u64 eof;
};
/*
* cache.c
*/
extern struct fscache_netfs cifs_fscache_netfs; extern struct fscache_netfs cifs_fscache_netfs;
extern const struct fscache_cookie_def cifs_fscache_server_index_def; extern const struct fscache_cookie_def cifs_fscache_server_index_def;
extern const struct fscache_cookie_def cifs_fscache_super_index_def; extern const struct fscache_cookie_def cifs_fscache_super_index_def;
...@@ -34,6 +46,7 @@ extern const struct fscache_cookie_def cifs_fscache_inode_object_def; ...@@ -34,6 +46,7 @@ extern const struct fscache_cookie_def cifs_fscache_inode_object_def;
extern int cifs_fscache_register(void); extern int cifs_fscache_register(void);
extern void cifs_fscache_unregister(void); extern void cifs_fscache_unregister(void);
extern char *extract_sharename(const char *);
/* /*
* fscache.c * fscache.c
......
...@@ -125,7 +125,7 @@ struct fscache_cache *fscache_select_cache_for_object( ...@@ -125,7 +125,7 @@ struct fscache_cache *fscache_select_cache_for_object(
} }
/* the parent is unbacked */ /* the parent is unbacked */
if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) { if (cookie->type != FSCACHE_COOKIE_TYPE_INDEX) {
/* cookie not an index and is unbacked */ /* cookie not an index and is unbacked */
spin_unlock(&cookie->lock); spin_unlock(&cookie->lock);
_leave(" = NULL [cookie ub,ni]"); _leave(" = NULL [cookie ub,ni]");
......
This diff is collapsed.
...@@ -13,16 +13,11 @@ ...@@ -13,16 +13,11 @@
#include <linux/module.h> #include <linux/module.h>
#include "internal.h" #include "internal.h"
static uint16_t fscache_fsdef_netfs_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax);
static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax);
static static
enum fscache_checkaux fscache_fsdef_netfs_check_aux(void *cookie_netfs_data, enum fscache_checkaux fscache_fsdef_netfs_check_aux(void *cookie_netfs_data,
const void *data, const void *data,
uint16_t datalen); uint16_t datalen,
loff_t object_size);
/* /*
* The root index is owned by FS-Cache itself. * The root index is owned by FS-Cache itself.
...@@ -60,6 +55,7 @@ struct fscache_cookie fscache_fsdef_index = { ...@@ -60,6 +55,7 @@ struct fscache_cookie fscache_fsdef_index = {
.backing_objects = HLIST_HEAD_INIT, .backing_objects = HLIST_HEAD_INIT,
.def = &fscache_fsdef_index_def, .def = &fscache_fsdef_index_def,
.flags = 1 << FSCACHE_COOKIE_ENABLED, .flags = 1 << FSCACHE_COOKIE_ENABLED,
.type = FSCACHE_COOKIE_TYPE_INDEX,
}; };
EXPORT_SYMBOL(fscache_fsdef_index); EXPORT_SYMBOL(fscache_fsdef_index);
...@@ -71,51 +67,9 @@ EXPORT_SYMBOL(fscache_fsdef_index); ...@@ -71,51 +67,9 @@ EXPORT_SYMBOL(fscache_fsdef_index);
struct fscache_cookie_def fscache_fsdef_netfs_def = { struct fscache_cookie_def fscache_fsdef_netfs_def = {
.name = "FSDEF.netfs", .name = "FSDEF.netfs",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = fscache_fsdef_netfs_get_key,
.get_aux = fscache_fsdef_netfs_get_aux,
.check_aux = fscache_fsdef_netfs_check_aux, .check_aux = fscache_fsdef_netfs_check_aux,
}; };
/*
* get the key data for an FSDEF index record - this is the name of the netfs
* for which this entry is created
*/
static uint16_t fscache_fsdef_netfs_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct fscache_netfs *netfs = cookie_netfs_data;
unsigned klen;
_enter("{%s.%u},", netfs->name, netfs->version);
klen = strlen(netfs->name);
if (klen > bufmax)
return 0;
memcpy(buffer, netfs->name, klen);
return klen;
}
/*
* get the auxiliary data for an FSDEF index record - this is the index
* structure version number of the netfs for which this version is created
*/
static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct fscache_netfs *netfs = cookie_netfs_data;
unsigned dlen;
_enter("{%s.%u},", netfs->name, netfs->version);
dlen = sizeof(uint32_t);
if (dlen > bufmax)
return 0;
memcpy(buffer, &netfs->version, dlen);
return dlen;
}
/* /*
* check that the index structure version number stored in the auxiliary data * check that the index structure version number stored in the auxiliary data
* matches the one the netfs gave us * matches the one the netfs gave us
...@@ -123,7 +77,8 @@ static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data, ...@@ -123,7 +77,8 @@ static uint16_t fscache_fsdef_netfs_get_aux(const void *cookie_netfs_data,
static enum fscache_checkaux fscache_fsdef_netfs_check_aux( static enum fscache_checkaux fscache_fsdef_netfs_check_aux(
void *cookie_netfs_data, void *cookie_netfs_data,
const void *data, const void *data,
uint16_t datalen) uint16_t datalen,
loff_t object_size)
{ {
struct fscache_netfs *netfs = cookie_netfs_data; struct fscache_netfs *netfs = cookie_netfs_data;
uint32_t version; uint32_t version;
......
...@@ -29,6 +29,7 @@ ...@@ -29,6 +29,7 @@
#define pr_fmt(fmt) "FS-Cache: " fmt #define pr_fmt(fmt) "FS-Cache: " fmt
#include <linux/fscache-cache.h> #include <linux/fscache-cache.h>
#include <trace/events/fscache.h>
#include <linux/sched.h> #include <linux/sched.h>
#define FSCACHE_MIN_THREADS 4 #define FSCACHE_MIN_THREADS 4
...@@ -48,8 +49,16 @@ extern struct fscache_cache *fscache_select_cache_for_object( ...@@ -48,8 +49,16 @@ extern struct fscache_cache *fscache_select_cache_for_object(
*/ */
extern struct kmem_cache *fscache_cookie_jar; extern struct kmem_cache *fscache_cookie_jar;
extern void fscache_free_cookie(struct fscache_cookie *);
extern void fscache_cookie_init_once(void *); extern void fscache_cookie_init_once(void *);
extern void __fscache_cookie_put(struct fscache_cookie *); extern struct fscache_cookie *fscache_alloc_cookie(struct fscache_cookie *,
const struct fscache_cookie_def *,
const void *, size_t,
const void *, size_t,
void *, loff_t);
extern struct fscache_cookie *fscache_hash_cookie(struct fscache_cookie *);
extern void fscache_cookie_put(struct fscache_cookie *,
enum fscache_cookie_trace);
/* /*
* fsdef.c * fsdef.c
...@@ -311,14 +320,12 @@ static inline void fscache_raise_event(struct fscache_object *object, ...@@ -311,14 +320,12 @@ static inline void fscache_raise_event(struct fscache_object *object,
fscache_enqueue_object(object); fscache_enqueue_object(object);
} }
/* static inline void fscache_cookie_get(struct fscache_cookie *cookie,
* drop a reference to a cookie enum fscache_cookie_trace where)
*/
static inline void fscache_cookie_put(struct fscache_cookie *cookie)
{ {
BUG_ON(atomic_read(&cookie->usage) <= 0); int usage = atomic_inc_return(&cookie->usage);
if (atomic_dec_and_test(&cookie->usage))
__fscache_cookie_put(cookie); trace_fscache_cookie(cookie, where, usage);
} }
/* /*
...@@ -342,6 +349,27 @@ void fscache_put_context(struct fscache_cookie *cookie, void *context) ...@@ -342,6 +349,27 @@ void fscache_put_context(struct fscache_cookie *cookie, void *context)
cookie->def->put_context(cookie->netfs_data, context); cookie->def->put_context(cookie->netfs_data, context);
} }
/*
* Update the auxiliary data on a cookie.
*/
static inline
void fscache_update_aux(struct fscache_cookie *cookie, const void *aux_data)
{
void *p;
if (!aux_data)
return;
if (cookie->aux_len <= sizeof(cookie->inline_aux))
p = cookie->inline_aux;
else
p = cookie->aux;
if (memcmp(p, aux_data, cookie->aux_len) != 0) {
memcpy(p, aux_data, cookie->aux_len);
set_bit(FSCACHE_COOKIE_AUX_UPDATED, &cookie->flags);
}
}
/*****************************************************************************/ /*****************************************************************************/
/* /*
* debug tracing * debug tracing
......
...@@ -16,6 +16,7 @@ ...@@ -16,6 +16,7 @@
#include <linux/completion.h> #include <linux/completion.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#define CREATE_TRACE_POINTS
#include "internal.h" #include "internal.h"
MODULE_DESCRIPTION("FS Cache Manager"); MODULE_DESCRIPTION("FS Cache Manager");
......
...@@ -14,69 +14,51 @@ ...@@ -14,69 +14,51 @@
#include <linux/slab.h> #include <linux/slab.h>
#include "internal.h" #include "internal.h"
static LIST_HEAD(fscache_netfs_list);
/* /*
* register a network filesystem for caching * register a network filesystem for caching
*/ */
int __fscache_register_netfs(struct fscache_netfs *netfs) int __fscache_register_netfs(struct fscache_netfs *netfs)
{ {
struct fscache_netfs *ptr; struct fscache_cookie *candidate, *cookie;
struct fscache_cookie *cookie;
int ret;
_enter("{%s}", netfs->name); _enter("{%s}", netfs->name);
INIT_LIST_HEAD(&netfs->link);
/* allocate a cookie for the primary index */ /* allocate a cookie for the primary index */
cookie = kmem_cache_zalloc(fscache_cookie_jar, GFP_KERNEL); candidate = fscache_alloc_cookie(&fscache_fsdef_index,
&fscache_fsdef_netfs_def,
if (!cookie) { netfs->name, strlen(netfs->name),
&netfs->version, sizeof(netfs->version),
netfs, 0);
if (!candidate) {
_leave(" = -ENOMEM"); _leave(" = -ENOMEM");
return -ENOMEM; return -ENOMEM;
} }
/* initialise the primary index cookie */ candidate->flags = 1 << FSCACHE_COOKIE_ENABLED;
atomic_set(&cookie->usage, 1);
atomic_set(&cookie->n_children, 0);
atomic_set(&cookie->n_active, 1);
cookie->def = &fscache_fsdef_netfs_def;
cookie->parent = &fscache_fsdef_index;
cookie->netfs_data = netfs;
cookie->flags = 1 << FSCACHE_COOKIE_ENABLED;
spin_lock_init(&cookie->lock);
spin_lock_init(&cookie->stores_lock);
INIT_HLIST_HEAD(&cookie->backing_objects);
/* check the netfs type is not already present */ /* check the netfs type is not already present */
down_write(&fscache_addremove_sem); cookie = fscache_hash_cookie(candidate);
if (!cookie)
ret = -EEXIST;
list_for_each_entry(ptr, &fscache_netfs_list, link) {
if (strcmp(ptr->name, netfs->name) == 0)
goto already_registered; goto already_registered;
if (cookie != candidate) {
trace_fscache_cookie(candidate, fscache_cookie_discard, 1);
fscache_free_cookie(candidate);
} }
atomic_inc(&cookie->parent->usage); fscache_cookie_get(cookie->parent, fscache_cookie_get_register_netfs);
atomic_inc(&cookie->parent->n_children); atomic_inc(&cookie->parent->n_children);
netfs->primary_index = cookie; netfs->primary_index = cookie;
list_add(&netfs->link, &fscache_netfs_list);
ret = 0;
pr_notice("Netfs '%s' registered for caching\n", netfs->name); pr_notice("Netfs '%s' registered for caching\n", netfs->name);
trace_fscache_netfs(netfs);
_leave(" = 0");
return 0;
already_registered: already_registered:
up_write(&fscache_addremove_sem); fscache_cookie_put(candidate, fscache_cookie_put_dup_netfs);
_leave(" = -EEXIST");
if (ret < 0) return -EEXIST;
kmem_cache_free(fscache_cookie_jar, cookie);
_leave(" = %d", ret);
return ret;
} }
EXPORT_SYMBOL(__fscache_register_netfs); EXPORT_SYMBOL(__fscache_register_netfs);
...@@ -88,15 +70,8 @@ void __fscache_unregister_netfs(struct fscache_netfs *netfs) ...@@ -88,15 +70,8 @@ void __fscache_unregister_netfs(struct fscache_netfs *netfs)
{ {
_enter("{%s.%u}", netfs->name, netfs->version); _enter("{%s.%u}", netfs->name, netfs->version);
down_write(&fscache_addremove_sem); fscache_relinquish_cookie(netfs->primary_index, NULL, false);
pr_notice("Netfs '%s' unregistered from caching\n", netfs->name);
list_del(&netfs->link);
fscache_relinquish_cookie(netfs->primary_index, 0);
up_write(&fscache_addremove_sem);
pr_notice("Netfs '%s' unregistered from caching\n",
netfs->name);
_leave(""); _leave("");
} }
......
...@@ -36,8 +36,6 @@ struct fscache_objlist_data { ...@@ -36,8 +36,6 @@ struct fscache_objlist_data {
#define FSCACHE_OBJLIST_CONFIG_NOEVENTS 0x00000800 /* show objects without no events */ #define FSCACHE_OBJLIST_CONFIG_NOEVENTS 0x00000800 /* show objects without no events */
#define FSCACHE_OBJLIST_CONFIG_WORK 0x00001000 /* show objects with work */ #define FSCACHE_OBJLIST_CONFIG_WORK 0x00001000 /* show objects with work */
#define FSCACHE_OBJLIST_CONFIG_NOWORK 0x00002000 /* show objects without work */ #define FSCACHE_OBJLIST_CONFIG_NOWORK 0x00002000 /* show objects without work */
u8 buf[512]; /* key and aux data buffer */
}; };
/* /*
...@@ -170,7 +168,7 @@ static int fscache_objlist_show(struct seq_file *m, void *v) ...@@ -170,7 +168,7 @@ static int fscache_objlist_show(struct seq_file *m, void *v)
struct fscache_cookie *cookie; struct fscache_cookie *cookie;
unsigned long config = data->config; unsigned long config = data->config;
char _type[3], *type; char _type[3], *type;
u8 *buf = data->buf, *p; u8 *p;
if ((unsigned long) v == 1) { if ((unsigned long) v == 1) {
seq_puts(m, "OBJECT PARENT STAT CHLDN OPS OOP IPR EX READS" seq_puts(m, "OBJECT PARENT STAT CHLDN OPS OOP IPR EX READS"
...@@ -254,7 +252,7 @@ static int fscache_objlist_show(struct seq_file *m, void *v) ...@@ -254,7 +252,7 @@ static int fscache_objlist_show(struct seq_file *m, void *v)
if (fscache_use_cookie(obj)) { if (fscache_use_cookie(obj)) {
uint16_t keylen = 0, auxlen = 0; uint16_t keylen = 0, auxlen = 0;
switch (cookie->def->type) { switch (cookie->type) {
case 0: case 0:
type = "IX"; type = "IX";
break; break;
...@@ -263,7 +261,7 @@ static int fscache_objlist_show(struct seq_file *m, void *v) ...@@ -263,7 +261,7 @@ static int fscache_objlist_show(struct seq_file *m, void *v)
break; break;
default: default:
snprintf(_type, sizeof(_type), "%02u", snprintf(_type, sizeof(_type), "%02u",
cookie->def->type); cookie->type);
type = _type; type = _type;
break; break;
} }
...@@ -274,30 +272,30 @@ static int fscache_objlist_show(struct seq_file *m, void *v) ...@@ -274,30 +272,30 @@ static int fscache_objlist_show(struct seq_file *m, void *v)
cookie->flags, cookie->flags,
cookie->netfs_data); cookie->netfs_data);
if (cookie->def->get_key && if (config & FSCACHE_OBJLIST_CONFIG_KEY)
config & FSCACHE_OBJLIST_CONFIG_KEY) keylen = cookie->key_len;
keylen = cookie->def->get_key(cookie->netfs_data,
buf, 400);
if (cookie->def->get_aux && if (config & FSCACHE_OBJLIST_CONFIG_AUX)
config & FSCACHE_OBJLIST_CONFIG_AUX) auxlen = cookie->aux_len;
auxlen = cookie->def->get_aux(cookie->netfs_data,
buf + keylen, 512 - keylen);
fscache_unuse_cookie(obj);
if (keylen > 0 || auxlen > 0) { if (keylen > 0 || auxlen > 0) {
seq_puts(m, " "); seq_puts(m, " ");
for (p = buf; keylen > 0; keylen--) p = keylen <= sizeof(cookie->inline_key) ?
cookie->inline_key : cookie->key;
for (; keylen > 0; keylen--)
seq_printf(m, "%02x", *p++); seq_printf(m, "%02x", *p++);
if (auxlen > 0) { if (auxlen > 0) {
if (config & FSCACHE_OBJLIST_CONFIG_KEY) if (config & FSCACHE_OBJLIST_CONFIG_KEY)
seq_puts(m, ", "); seq_puts(m, ", ");
p = auxlen <= sizeof(cookie->inline_aux) ?
cookie->inline_aux : cookie->aux;
for (; auxlen > 0; auxlen--) for (; auxlen > 0; auxlen--)
seq_printf(m, "%02x", *p++); seq_printf(m, "%02x", *p++);
} }
} }
seq_puts(m, "\n"); seq_puts(m, "\n");
fscache_unuse_cookie(obj);
} else { } else {
seq_puts(m, "<no_netfs>\n"); seq_puts(m, "<no_netfs>\n");
} }
......
...@@ -138,10 +138,13 @@ static const struct fscache_transition fscache_osm_run_oob[] = { ...@@ -138,10 +138,13 @@ static const struct fscache_transition fscache_osm_run_oob[] = {
{ 0, NULL } { 0, NULL }
}; };
static int fscache_get_object(struct fscache_object *); static int fscache_get_object(struct fscache_object *,
static void fscache_put_object(struct fscache_object *); enum fscache_obj_ref_trace);
static void fscache_put_object(struct fscache_object *,
enum fscache_obj_ref_trace);
static bool fscache_enqueue_dependents(struct fscache_object *, int); static bool fscache_enqueue_dependents(struct fscache_object *, int);
static void fscache_dequeue_object(struct fscache_object *); static void fscache_dequeue_object(struct fscache_object *);
static void fscache_update_aux_data(struct fscache_object *);
/* /*
* we need to notify the parent when an op completes that we had outstanding * we need to notify the parent when an op completes that we had outstanding
...@@ -170,6 +173,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object) ...@@ -170,6 +173,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
const struct fscache_transition *t; const struct fscache_transition *t;
const struct fscache_state *state, *new_state; const struct fscache_state *state, *new_state;
unsigned long events, event_mask; unsigned long events, event_mask;
bool oob;
int event = -1; int event = -1;
ASSERT(object != NULL); ASSERT(object != NULL);
...@@ -188,6 +192,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object) ...@@ -188,6 +192,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
if (events & object->oob_event_mask) { if (events & object->oob_event_mask) {
_debug("{OBJ%x} oob %lx", _debug("{OBJ%x} oob %lx",
object->debug_id, events & object->oob_event_mask); object->debug_id, events & object->oob_event_mask);
oob = true;
for (t = object->oob_table; t->events; t++) { for (t = object->oob_table; t->events; t++) {
if (events & t->events) { if (events & t->events) {
state = t->transit_to; state = t->transit_to;
...@@ -199,6 +204,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object) ...@@ -199,6 +204,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
} }
} }
} }
oob = false;
/* Wait states are just transition tables */ /* Wait states are just transition tables */
if (!state->work) { if (!state->work) {
...@@ -207,6 +213,8 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object) ...@@ -207,6 +213,8 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
if (events & t->events) { if (events & t->events) {
new_state = t->transit_to; new_state = t->transit_to;
event = fls(events & t->events) - 1; event = fls(events & t->events) - 1;
trace_fscache_osm(object, state,
true, false, event);
clear_bit(event, &object->events); clear_bit(event, &object->events);
_debug("{OBJ%x} ev %d: %s -> %s", _debug("{OBJ%x} ev %d: %s -> %s",
object->debug_id, event, object->debug_id, event,
...@@ -226,6 +234,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object) ...@@ -226,6 +234,7 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
execute_work_state: execute_work_state:
_debug("{OBJ%x} exec %s", object->debug_id, state->name); _debug("{OBJ%x} exec %s", object->debug_id, state->name);
trace_fscache_osm(object, state, false, oob, event);
new_state = state->work(object, event); new_state = state->work(object, event);
event = -1; event = -1;
if (new_state == NO_TRANSIT) { if (new_state == NO_TRANSIT) {
...@@ -279,7 +288,7 @@ static void fscache_object_work_func(struct work_struct *work) ...@@ -279,7 +288,7 @@ static void fscache_object_work_func(struct work_struct *work)
start = jiffies; start = jiffies;
fscache_object_sm_dispatcher(object); fscache_object_sm_dispatcher(object);
fscache_hist(fscache_objs_histogram, start); fscache_hist(fscache_objs_histogram, start);
fscache_put_object(object); fscache_put_object(object, fscache_obj_put_work);
} }
/** /**
...@@ -397,7 +406,7 @@ static const struct fscache_state *fscache_initialise_object(struct fscache_obje ...@@ -397,7 +406,7 @@ static const struct fscache_state *fscache_initialise_object(struct fscache_obje
fscache_stat(&fscache_n_cop_grab_object); fscache_stat(&fscache_n_cop_grab_object);
success = false; success = false;
if (fscache_object_is_live(parent) && if (fscache_object_is_live(parent) &&
object->cache->ops->grab_object(object)) { object->cache->ops->grab_object(object, fscache_obj_get_add_to_deps)) {
list_add(&object->dep_link, &parent->dependents); list_add(&object->dep_link, &parent->dependents);
success = true; success = true;
} }
...@@ -703,6 +712,11 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob ...@@ -703,6 +712,11 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob
ASSERT(cookie != NULL); ASSERT(cookie != NULL);
ASSERT(!hlist_unhashed(&object->cookie_link)); ASSERT(!hlist_unhashed(&object->cookie_link));
if (test_bit(FSCACHE_COOKIE_AUX_UPDATED, &cookie->flags)) {
_debug("final update");
fscache_update_aux_data(object);
}
/* Make sure the cookie no longer points here and that the netfs isn't /* Make sure the cookie no longer points here and that the netfs isn't
* waiting for us. * waiting for us.
*/ */
...@@ -745,7 +759,7 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob ...@@ -745,7 +759,7 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob
} }
/* this just shifts the object release to the work processor */ /* this just shifts the object release to the work processor */
fscache_put_object(object); fscache_put_object(object, fscache_obj_put_drop_obj);
fscache_stat(&fscache_n_object_dead); fscache_stat(&fscache_n_object_dead);
_leave(""); _leave("");
...@@ -755,12 +769,13 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob ...@@ -755,12 +769,13 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob
/* /*
* get a ref on an object * get a ref on an object
*/ */
static int fscache_get_object(struct fscache_object *object) static int fscache_get_object(struct fscache_object *object,
enum fscache_obj_ref_trace why)
{ {
int ret; int ret;
fscache_stat(&fscache_n_cop_grab_object); fscache_stat(&fscache_n_cop_grab_object);
ret = object->cache->ops->grab_object(object) ? 0 : -EAGAIN; ret = object->cache->ops->grab_object(object, why) ? 0 : -EAGAIN;
fscache_stat_d(&fscache_n_cop_grab_object); fscache_stat_d(&fscache_n_cop_grab_object);
return ret; return ret;
} }
...@@ -768,10 +783,11 @@ static int fscache_get_object(struct fscache_object *object) ...@@ -768,10 +783,11 @@ static int fscache_get_object(struct fscache_object *object)
/* /*
* Discard a ref on an object * Discard a ref on an object
*/ */
static void fscache_put_object(struct fscache_object *object) static void fscache_put_object(struct fscache_object *object,
enum fscache_obj_ref_trace why)
{ {
fscache_stat(&fscache_n_cop_put_object); fscache_stat(&fscache_n_cop_put_object);
object->cache->ops->put_object(object); object->cache->ops->put_object(object, why);
fscache_stat_d(&fscache_n_cop_put_object); fscache_stat_d(&fscache_n_cop_put_object);
} }
...@@ -786,7 +802,7 @@ void fscache_object_destroy(struct fscache_object *object) ...@@ -786,7 +802,7 @@ void fscache_object_destroy(struct fscache_object *object)
fscache_objlist_remove(object); fscache_objlist_remove(object);
/* We can get rid of the cookie now */ /* We can get rid of the cookie now */
fscache_cookie_put(object->cookie); fscache_cookie_put(object->cookie, fscache_cookie_put_object);
object->cookie = NULL; object->cookie = NULL;
} }
EXPORT_SYMBOL(fscache_object_destroy); EXPORT_SYMBOL(fscache_object_destroy);
...@@ -798,7 +814,7 @@ void fscache_enqueue_object(struct fscache_object *object) ...@@ -798,7 +814,7 @@ void fscache_enqueue_object(struct fscache_object *object)
{ {
_enter("{OBJ%x}", object->debug_id); _enter("{OBJ%x}", object->debug_id);
if (fscache_get_object(object) >= 0) { if (fscache_get_object(object, fscache_obj_get_queue) >= 0) {
wait_queue_head_t *cong_wq = wait_queue_head_t *cong_wq =
&get_cpu_var(fscache_object_cong_wait); &get_cpu_var(fscache_object_cong_wait);
...@@ -806,7 +822,7 @@ void fscache_enqueue_object(struct fscache_object *object) ...@@ -806,7 +822,7 @@ void fscache_enqueue_object(struct fscache_object *object)
if (fscache_object_congested()) if (fscache_object_congested())
wake_up(cong_wq); wake_up(cong_wq);
} else } else
fscache_put_object(object); fscache_put_object(object, fscache_obj_put_queue);
put_cpu_var(fscache_object_cong_wait); put_cpu_var(fscache_object_cong_wait);
} }
...@@ -866,7 +882,7 @@ static bool fscache_enqueue_dependents(struct fscache_object *object, int event) ...@@ -866,7 +882,7 @@ static bool fscache_enqueue_dependents(struct fscache_object *object, int event)
list_del_init(&dep->dep_link); list_del_init(&dep->dep_link);
fscache_raise_event(dep, event); fscache_raise_event(dep, event);
fscache_put_object(dep); fscache_put_object(dep, fscache_obj_put_enq_dep);
if (!list_empty(&object->dependents) && need_resched()) { if (!list_empty(&object->dependents) && need_resched()) {
ret = false; ret = false;
...@@ -906,7 +922,8 @@ static void fscache_dequeue_object(struct fscache_object *object) ...@@ -906,7 +922,8 @@ static void fscache_dequeue_object(struct fscache_object *object)
* and creation). * and creation).
*/ */
enum fscache_checkaux fscache_check_aux(struct fscache_object *object, enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
const void *data, uint16_t datalen) const void *data, uint16_t datalen,
loff_t object_size)
{ {
enum fscache_checkaux result; enum fscache_checkaux result;
...@@ -916,7 +933,7 @@ enum fscache_checkaux fscache_check_aux(struct fscache_object *object, ...@@ -916,7 +933,7 @@ enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
} }
result = object->cookie->def->check_aux(object->cookie->netfs_data, result = object->cookie->def->check_aux(object->cookie->netfs_data,
data, datalen); data, datalen, object_size);
switch (result) { switch (result) {
/* entry okay as is */ /* entry okay as is */
case FSCACHE_CHECKAUX_OKAY: case FSCACHE_CHECKAUX_OKAY:
...@@ -972,11 +989,12 @@ static const struct fscache_state *_fscache_invalidate_object(struct fscache_obj ...@@ -972,11 +989,12 @@ static const struct fscache_state *_fscache_invalidate_object(struct fscache_obj
if (!op) if (!op)
goto nomem; goto nomem;
fscache_operation_init(op, object->cache->ops->invalidate_object, fscache_operation_init(cookie, op, object->cache->ops->invalidate_object,
NULL, NULL); NULL, NULL);
op->flags = FSCACHE_OP_ASYNC | op->flags = FSCACHE_OP_ASYNC |
(1 << FSCACHE_OP_EXCLUSIVE) | (1 << FSCACHE_OP_EXCLUSIVE) |
(1 << FSCACHE_OP_UNUSE_COOKIE); (1 << FSCACHE_OP_UNUSE_COOKIE);
trace_fscache_page_op(cookie, NULL, op, fscache_page_op_invalidate);
spin_lock(&cookie->lock); spin_lock(&cookie->lock);
if (fscache_submit_exclusive_op(object, op) < 0) if (fscache_submit_exclusive_op(object, op) < 0)
...@@ -1025,6 +1043,17 @@ static const struct fscache_state *fscache_invalidate_object(struct fscache_obje ...@@ -1025,6 +1043,17 @@ static const struct fscache_state *fscache_invalidate_object(struct fscache_obje
return s; return s;
} }
/*
* Update auxiliary data.
*/
static void fscache_update_aux_data(struct fscache_object *object)
{
fscache_stat(&fscache_n_updates_run);
fscache_stat(&fscache_n_cop_update_object);
object->cache->ops->update_object(object);
fscache_stat_d(&fscache_n_cop_update_object);
}
/* /*
* Asynchronously update an object. * Asynchronously update an object.
*/ */
...@@ -1033,10 +1062,7 @@ static const struct fscache_state *fscache_update_object(struct fscache_object * ...@@ -1033,10 +1062,7 @@ static const struct fscache_state *fscache_update_object(struct fscache_object *
{ {
_enter("{OBJ%x},%d", object->debug_id, event); _enter("{OBJ%x},%d", object->debug_id, event);
fscache_stat(&fscache_n_updates_run); fscache_update_aux_data(object);
fscache_stat(&fscache_n_cop_update_object);
object->cache->ops->update_object(object);
fscache_stat_d(&fscache_n_cop_update_object);
_leave(""); _leave("");
return transit_to(WAIT_FOR_CMD); return transit_to(WAIT_FOR_CMD);
......
...@@ -32,7 +32,8 @@ static void fscache_operation_dummy_cancel(struct fscache_operation *op) ...@@ -32,7 +32,8 @@ static void fscache_operation_dummy_cancel(struct fscache_operation *op)
* Do basic initialisation of an operation. The caller must still set flags, * Do basic initialisation of an operation. The caller must still set flags,
* object and processor if needed. * object and processor if needed.
*/ */
void fscache_operation_init(struct fscache_operation *op, void fscache_operation_init(struct fscache_cookie *cookie,
struct fscache_operation *op,
fscache_operation_processor_t processor, fscache_operation_processor_t processor,
fscache_operation_cancel_t cancel, fscache_operation_cancel_t cancel,
fscache_operation_release_t release) fscache_operation_release_t release)
...@@ -46,6 +47,7 @@ void fscache_operation_init(struct fscache_operation *op, ...@@ -46,6 +47,7 @@ void fscache_operation_init(struct fscache_operation *op,
op->release = release; op->release = release;
INIT_LIST_HEAD(&op->pend_link); INIT_LIST_HEAD(&op->pend_link);
fscache_stat(&fscache_n_op_initialised); fscache_stat(&fscache_n_op_initialised);
trace_fscache_op(cookie, op, fscache_op_init);
} }
EXPORT_SYMBOL(fscache_operation_init); EXPORT_SYMBOL(fscache_operation_init);
...@@ -59,6 +61,8 @@ EXPORT_SYMBOL(fscache_operation_init); ...@@ -59,6 +61,8 @@ EXPORT_SYMBOL(fscache_operation_init);
*/ */
void fscache_enqueue_operation(struct fscache_operation *op) void fscache_enqueue_operation(struct fscache_operation *op)
{ {
struct fscache_cookie *cookie = op->object->cookie;
_enter("{OBJ%x OP%x,%u}", _enter("{OBJ%x OP%x,%u}",
op->object->debug_id, op->debug_id, atomic_read(&op->usage)); op->object->debug_id, op->debug_id, atomic_read(&op->usage));
...@@ -71,12 +75,14 @@ void fscache_enqueue_operation(struct fscache_operation *op) ...@@ -71,12 +75,14 @@ void fscache_enqueue_operation(struct fscache_operation *op)
fscache_stat(&fscache_n_op_enqueue); fscache_stat(&fscache_n_op_enqueue);
switch (op->flags & FSCACHE_OP_TYPE) { switch (op->flags & FSCACHE_OP_TYPE) {
case FSCACHE_OP_ASYNC: case FSCACHE_OP_ASYNC:
trace_fscache_op(cookie, op, fscache_op_enqueue_async);
_debug("queue async"); _debug("queue async");
atomic_inc(&op->usage); atomic_inc(&op->usage);
if (!queue_work(fscache_op_wq, &op->work)) if (!queue_work(fscache_op_wq, &op->work))
fscache_put_operation(op); fscache_put_operation(op);
break; break;
case FSCACHE_OP_MYTHREAD: case FSCACHE_OP_MYTHREAD:
trace_fscache_op(cookie, op, fscache_op_enqueue_mythread);
_debug("queue for caller's attention"); _debug("queue for caller's attention");
break; break;
default: default:
...@@ -101,6 +107,8 @@ static void fscache_run_op(struct fscache_object *object, ...@@ -101,6 +107,8 @@ static void fscache_run_op(struct fscache_object *object,
wake_up_bit(&op->flags, FSCACHE_OP_WAITING); wake_up_bit(&op->flags, FSCACHE_OP_WAITING);
if (op->processor) if (op->processor)
fscache_enqueue_operation(op); fscache_enqueue_operation(op);
else
trace_fscache_op(object->cookie, op, fscache_op_run);
fscache_stat(&fscache_n_op_run); fscache_stat(&fscache_n_op_run);
} }
...@@ -155,6 +163,8 @@ int fscache_submit_exclusive_op(struct fscache_object *object, ...@@ -155,6 +163,8 @@ int fscache_submit_exclusive_op(struct fscache_object *object,
_enter("{OBJ%x OP%x},", object->debug_id, op->debug_id); _enter("{OBJ%x OP%x},", object->debug_id, op->debug_id);
trace_fscache_op(object->cookie, op, fscache_op_submit_ex);
ASSERTCMP(op->state, ==, FSCACHE_OP_ST_INITIALISED); ASSERTCMP(op->state, ==, FSCACHE_OP_ST_INITIALISED);
ASSERTCMP(atomic_read(&op->usage), >, 0); ASSERTCMP(atomic_read(&op->usage), >, 0);
...@@ -240,6 +250,8 @@ int fscache_submit_op(struct fscache_object *object, ...@@ -240,6 +250,8 @@ int fscache_submit_op(struct fscache_object *object,
_enter("{OBJ%x OP%x},{%u}", _enter("{OBJ%x OP%x},{%u}",
object->debug_id, op->debug_id, atomic_read(&op->usage)); object->debug_id, op->debug_id, atomic_read(&op->usage));
trace_fscache_op(object->cookie, op, fscache_op_submit);
ASSERTCMP(op->state, ==, FSCACHE_OP_ST_INITIALISED); ASSERTCMP(op->state, ==, FSCACHE_OP_ST_INITIALISED);
ASSERTCMP(atomic_read(&op->usage), >, 0); ASSERTCMP(atomic_read(&op->usage), >, 0);
...@@ -357,6 +369,8 @@ int fscache_cancel_op(struct fscache_operation *op, ...@@ -357,6 +369,8 @@ int fscache_cancel_op(struct fscache_operation *op,
_enter("OBJ%x OP%x}", op->object->debug_id, op->debug_id); _enter("OBJ%x OP%x}", op->object->debug_id, op->debug_id);
trace_fscache_op(object->cookie, op, fscache_op_cancel);
ASSERTCMP(op->state, >=, FSCACHE_OP_ST_PENDING); ASSERTCMP(op->state, >=, FSCACHE_OP_ST_PENDING);
ASSERTCMP(op->state, !=, FSCACHE_OP_ST_CANCELLED); ASSERTCMP(op->state, !=, FSCACHE_OP_ST_CANCELLED);
ASSERTCMP(atomic_read(&op->usage), >, 0); ASSERTCMP(atomic_read(&op->usage), >, 0);
...@@ -419,6 +433,8 @@ void fscache_cancel_all_ops(struct fscache_object *object) ...@@ -419,6 +433,8 @@ void fscache_cancel_all_ops(struct fscache_object *object)
fscache_stat(&fscache_n_op_cancelled); fscache_stat(&fscache_n_op_cancelled);
list_del_init(&op->pend_link); list_del_init(&op->pend_link);
trace_fscache_op(object->cookie, op, fscache_op_cancel_all);
ASSERTCMP(op->state, ==, FSCACHE_OP_ST_PENDING); ASSERTCMP(op->state, ==, FSCACHE_OP_ST_PENDING);
op->cancel(op); op->cancel(op);
op->state = FSCACHE_OP_ST_CANCELLED; op->state = FSCACHE_OP_ST_CANCELLED;
...@@ -454,9 +470,11 @@ void fscache_op_complete(struct fscache_operation *op, bool cancelled) ...@@ -454,9 +470,11 @@ void fscache_op_complete(struct fscache_operation *op, bool cancelled)
spin_lock(&object->lock); spin_lock(&object->lock);
if (!cancelled) { if (!cancelled) {
trace_fscache_op(object->cookie, op, fscache_op_completed);
op->state = FSCACHE_OP_ST_COMPLETE; op->state = FSCACHE_OP_ST_COMPLETE;
} else { } else {
op->cancel(op); op->cancel(op);
trace_fscache_op(object->cookie, op, fscache_op_cancelled);
op->state = FSCACHE_OP_ST_CANCELLED; op->state = FSCACHE_OP_ST_CANCELLED;
} }
...@@ -488,6 +506,8 @@ void fscache_put_operation(struct fscache_operation *op) ...@@ -488,6 +506,8 @@ void fscache_put_operation(struct fscache_operation *op)
if (!atomic_dec_and_test(&op->usage)) if (!atomic_dec_and_test(&op->usage))
return; return;
trace_fscache_op(op->object ? op->object->cookie : NULL, op, fscache_op_put);
_debug("PUT OP"); _debug("PUT OP");
ASSERTIFCMP(op->state != FSCACHE_OP_ST_INITIALISED && ASSERTIFCMP(op->state != FSCACHE_OP_ST_INITIALISED &&
op->state != FSCACHE_OP_ST_COMPLETE, op->state != FSCACHE_OP_ST_COMPLETE,
...@@ -563,6 +583,8 @@ void fscache_operation_gc(struct work_struct *work) ...@@ -563,6 +583,8 @@ void fscache_operation_gc(struct work_struct *work)
spin_unlock(&cache->op_gc_list_lock); spin_unlock(&cache->op_gc_list_lock);
object = op->object; object = op->object;
trace_fscache_op(object->cookie, op, fscache_op_gc);
spin_lock(&object->lock); spin_lock(&object->lock);
_debug("GC DEFERRED REL OBJ%x OP%x", _debug("GC DEFERRED REL OBJ%x OP%x",
...@@ -601,6 +623,8 @@ void fscache_op_work_func(struct work_struct *work) ...@@ -601,6 +623,8 @@ void fscache_op_work_func(struct work_struct *work)
_enter("{OBJ%x OP%x,%d}", _enter("{OBJ%x OP%x,%d}",
op->object->debug_id, op->debug_id, atomic_read(&op->usage)); op->object->debug_id, op->debug_id, atomic_read(&op->usage));
trace_fscache_op(op->object->cookie, op, fscache_op_work);
ASSERT(op->processor != NULL); ASSERT(op->processor != NULL);
start = jiffies; start = jiffies;
op->processor(op); op->processor(op);
......
This diff is collapsed.
...@@ -21,7 +21,6 @@ ...@@ -21,7 +21,6 @@
atomic_t fscache_n_op_pend; atomic_t fscache_n_op_pend;
atomic_t fscache_n_op_run; atomic_t fscache_n_op_run;
atomic_t fscache_n_op_enqueue; atomic_t fscache_n_op_enqueue;
atomic_t fscache_n_op_requeue;
atomic_t fscache_n_op_deferred_release; atomic_t fscache_n_op_deferred_release;
atomic_t fscache_n_op_initialised; atomic_t fscache_n_op_initialised;
atomic_t fscache_n_op_release; atomic_t fscache_n_op_release;
......
...@@ -49,59 +49,6 @@ void nfs_fscache_unregister(void) ...@@ -49,59 +49,6 @@ void nfs_fscache_unregister(void)
fscache_unregister_netfs(&nfs_fscache_netfs); fscache_unregister_netfs(&nfs_fscache_netfs);
} }
/*
* Layout of the key for an NFS server cache object.
*/
struct nfs_server_key {
uint16_t nfsversion; /* NFS protocol version */
uint16_t family; /* address family */
uint16_t port; /* IP port */
union {
struct in_addr ipv4_addr; /* IPv4 address */
struct in6_addr ipv6_addr; /* IPv6 address */
} addr[0];
};
/*
* Generate a key to describe a server in the main NFS index
* - We return the length of the key, or 0 if we can't generate one
*/
static uint16_t nfs_server_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct nfs_client *clp = cookie_netfs_data;
const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr;
const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr;
struct nfs_server_key *key = buffer;
uint16_t len = sizeof(struct nfs_server_key);
memset(key, 0, len);
key->nfsversion = clp->rpc_ops->version;
key->family = clp->cl_addr.ss_family;
switch (clp->cl_addr.ss_family) {
case AF_INET:
key->port = sin->sin_port;
key->addr[0].ipv4_addr = sin->sin_addr;
len += sizeof(key->addr[0].ipv4_addr);
break;
case AF_INET6:
key->port = sin6->sin6_port;
key->addr[0].ipv6_addr = sin6->sin6_addr;
len += sizeof(key->addr[0].ipv6_addr);
break;
default:
printk(KERN_WARNING "NFS: Unknown network family '%d'\n",
clp->cl_addr.ss_family);
len = 0;
break;
}
return len;
}
/* /*
* Define the server object for FS-Cache. This is used to describe a server * Define the server object for FS-Cache. This is used to describe a server
* object to fscache_acquire_cookie(). It is keyed by the NFS protocol and * object to fscache_acquire_cookie(). It is keyed by the NFS protocol and
...@@ -110,32 +57,8 @@ static uint16_t nfs_server_get_key(const void *cookie_netfs_data, ...@@ -110,32 +57,8 @@ static uint16_t nfs_server_get_key(const void *cookie_netfs_data,
const struct fscache_cookie_def nfs_fscache_server_index_def = { const struct fscache_cookie_def nfs_fscache_server_index_def = {
.name = "NFS.server", .name = "NFS.server",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = nfs_server_get_key,
}; };
/*
* Generate a key to describe a superblock key in the main NFS index
*/
static uint16_t nfs_super_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct nfs_fscache_key *key;
const struct nfs_server *nfss = cookie_netfs_data;
uint16_t len;
key = nfss->fscache_key;
len = sizeof(key->key) + key->key.uniq_len;
if (len > bufmax) {
len = 0;
} else {
memcpy(buffer, &key->key, sizeof(key->key));
memcpy(buffer + sizeof(key->key),
key->key.uniquifier, key->key.uniq_len);
}
return len;
}
/* /*
* Define the superblock object for FS-Cache. This is used to describe a * Define the superblock object for FS-Cache. This is used to describe a
* superblock object to fscache_acquire_cookie(). It is keyed by all the NFS * superblock object to fscache_acquire_cookie(). It is keyed by all the NFS
...@@ -144,83 +67,8 @@ static uint16_t nfs_super_get_key(const void *cookie_netfs_data, ...@@ -144,83 +67,8 @@ static uint16_t nfs_super_get_key(const void *cookie_netfs_data,
const struct fscache_cookie_def nfs_fscache_super_index_def = { const struct fscache_cookie_def nfs_fscache_super_index_def = {
.name = "NFS.super", .name = "NFS.super",
.type = FSCACHE_COOKIE_TYPE_INDEX, .type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = nfs_super_get_key,
}; };
/*
* Definition of the auxiliary data attached to NFS inode storage objects
* within the cache.
*
* The contents of this struct are recorded in the on-disk local cache in the
* auxiliary data attached to the data storage object backing an inode. This
* permits coherency to be managed when a new inode binds to an already extant
* cache object.
*/
struct nfs_fscache_inode_auxdata {
struct timespec mtime;
struct timespec ctime;
loff_t size;
u64 change_attr;
};
/*
* Generate a key to describe an NFS inode in an NFS server's index
*/
static uint16_t nfs_fscache_inode_get_key(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
const struct nfs_inode *nfsi = cookie_netfs_data;
uint16_t nsize;
/* use the inode's NFS filehandle as the key */
nsize = nfsi->fh.size;
memcpy(buffer, nfsi->fh.data, nsize);
return nsize;
}
/*
* Get certain file attributes from the netfs data
* - This function can be absent for an index
* - Not permitted to return an error
* - The netfs data from the cookie being used as the source is presented
*/
static void nfs_fscache_inode_get_attr(const void *cookie_netfs_data,
uint64_t *size)
{
const struct nfs_inode *nfsi = cookie_netfs_data;
*size = nfsi->vfs_inode.i_size;
}
/*
* Get the auxiliary data from netfs data
* - This function can be absent if the index carries no state data
* - Should store the auxiliary data in the buffer
* - Should return the amount of amount stored
* - Not permitted to return an error
* - The netfs data from the cookie being used as the source is presented
*/
static uint16_t nfs_fscache_inode_get_aux(const void *cookie_netfs_data,
void *buffer, uint16_t bufmax)
{
struct nfs_fscache_inode_auxdata auxdata;
const struct nfs_inode *nfsi = cookie_netfs_data;
memset(&auxdata, 0, sizeof(auxdata));
auxdata.size = nfsi->vfs_inode.i_size;
auxdata.mtime = nfsi->vfs_inode.i_mtime;
auxdata.ctime = nfsi->vfs_inode.i_ctime;
if (NFS_SERVER(&nfsi->vfs_inode)->nfs_client->rpc_ops->version == 4)
auxdata.change_attr = inode_peek_iversion_raw(&nfsi->vfs_inode);
if (bufmax > sizeof(auxdata))
bufmax = sizeof(auxdata);
memcpy(buffer, &auxdata, bufmax);
return bufmax;
}
/* /*
* Consult the netfs about the state of an object * Consult the netfs about the state of an object
* - This function can be absent if the index carries no state data * - This function can be absent if the index carries no state data
...@@ -230,7 +78,8 @@ static uint16_t nfs_fscache_inode_get_aux(const void *cookie_netfs_data, ...@@ -230,7 +78,8 @@ static uint16_t nfs_fscache_inode_get_aux(const void *cookie_netfs_data,
static static
enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data, enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data,
const void *data, const void *data,
uint16_t datalen) uint16_t datalen,
loff_t object_size)
{ {
struct nfs_fscache_inode_auxdata auxdata; struct nfs_fscache_inode_auxdata auxdata;
struct nfs_inode *nfsi = cookie_netfs_data; struct nfs_inode *nfsi = cookie_netfs_data;
...@@ -239,7 +88,6 @@ enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data, ...@@ -239,7 +88,6 @@ enum fscache_checkaux nfs_fscache_inode_check_aux(void *cookie_netfs_data,
return FSCACHE_CHECKAUX_OBSOLETE; return FSCACHE_CHECKAUX_OBSOLETE;
memset(&auxdata, 0, sizeof(auxdata)); memset(&auxdata, 0, sizeof(auxdata));
auxdata.size = nfsi->vfs_inode.i_size;
auxdata.mtime = nfsi->vfs_inode.i_mtime; auxdata.mtime = nfsi->vfs_inode.i_mtime;
auxdata.ctime = nfsi->vfs_inode.i_ctime; auxdata.ctime = nfsi->vfs_inode.i_ctime;
...@@ -288,9 +136,6 @@ static void nfs_fh_put_context(void *cookie_netfs_data, void *context) ...@@ -288,9 +136,6 @@ static void nfs_fh_put_context(void *cookie_netfs_data, void *context)
const struct fscache_cookie_def nfs_fscache_inode_object_def = { const struct fscache_cookie_def nfs_fscache_inode_object_def = {
.name = "NFS.fh", .name = "NFS.fh",
.type = FSCACHE_COOKIE_TYPE_DATAFILE, .type = FSCACHE_COOKIE_TYPE_DATAFILE,
.get_key = nfs_fscache_inode_get_key,
.get_attr = nfs_fscache_inode_get_attr,
.get_aux = nfs_fscache_inode_get_aux,
.check_aux = nfs_fscache_inode_check_aux, .check_aux = nfs_fscache_inode_check_aux,
.get_context = nfs_fh_get_context, .get_context = nfs_fh_get_context,
.put_context = nfs_fh_put_context, .put_context = nfs_fh_put_context,
......
...@@ -18,6 +18,7 @@ ...@@ -18,6 +18,7 @@
#include <linux/in6.h> #include <linux/in6.h>
#include <linux/seq_file.h> #include <linux/seq_file.h>
#include <linux/slab.h> #include <linux/slab.h>
#include <linux/iversion.h>
#include "internal.h" #include "internal.h"
#include "iostat.h" #include "iostat.h"
...@@ -28,6 +29,21 @@ ...@@ -28,6 +29,21 @@
static struct rb_root nfs_fscache_keys = RB_ROOT; static struct rb_root nfs_fscache_keys = RB_ROOT;
static DEFINE_SPINLOCK(nfs_fscache_keys_lock); static DEFINE_SPINLOCK(nfs_fscache_keys_lock);
/*
* Layout of the key for an NFS server cache object.
*/
struct nfs_server_key {
struct {
uint16_t nfsversion; /* NFS protocol version */
uint16_t family; /* address family */
__be16 port; /* IP port */
} hdr;
union {
struct in_addr ipv4_addr; /* IPv4 address */
struct in6_addr ipv6_addr; /* IPv6 address */
};
} __packed;
/* /*
* Get the per-client index cookie for an NFS client if the appropriate mount * Get the per-client index cookie for an NFS client if the appropriate mount
* flag was set * flag was set
...@@ -36,10 +52,41 @@ static DEFINE_SPINLOCK(nfs_fscache_keys_lock); ...@@ -36,10 +52,41 @@ static DEFINE_SPINLOCK(nfs_fscache_keys_lock);
*/ */
void nfs_fscache_get_client_cookie(struct nfs_client *clp) void nfs_fscache_get_client_cookie(struct nfs_client *clp)
{ {
const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &clp->cl_addr;
const struct sockaddr_in *sin = (struct sockaddr_in *) &clp->cl_addr;
struct nfs_server_key key;
uint16_t len = sizeof(key.hdr);
memset(&key, 0, sizeof(key));
key.hdr.nfsversion = clp->rpc_ops->version;
key.hdr.family = clp->cl_addr.ss_family;
switch (clp->cl_addr.ss_family) {
case AF_INET:
key.hdr.port = sin->sin_port;
key.ipv4_addr = sin->sin_addr;
len += sizeof(key.ipv4_addr);
break;
case AF_INET6:
key.hdr.port = sin6->sin6_port;
key.ipv6_addr = sin6->sin6_addr;
len += sizeof(key.ipv6_addr);
break;
default:
printk(KERN_WARNING "NFS: Unknown network family '%d'\n",
clp->cl_addr.ss_family);
clp->fscache = NULL;
return;
}
/* create a cache index for looking up filehandles */ /* create a cache index for looking up filehandles */
clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index, clp->fscache = fscache_acquire_cookie(nfs_fscache_netfs.primary_index,
&nfs_fscache_server_index_def, &nfs_fscache_server_index_def,
clp, true); &key, len,
NULL, 0,
clp, 0, true);
dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n", dfprintk(FSCACHE, "NFS: get client cookie (0x%p/0x%p)\n",
clp, clp->fscache); clp, clp->fscache);
} }
...@@ -52,7 +99,7 @@ void nfs_fscache_release_client_cookie(struct nfs_client *clp) ...@@ -52,7 +99,7 @@ void nfs_fscache_release_client_cookie(struct nfs_client *clp)
dfprintk(FSCACHE, "NFS: releasing client cookie (0x%p/0x%p)\n", dfprintk(FSCACHE, "NFS: releasing client cookie (0x%p/0x%p)\n",
clp, clp->fscache); clp, clp->fscache);
fscache_relinquish_cookie(clp->fscache, 0); fscache_relinquish_cookie(clp->fscache, NULL, false);
clp->fscache = NULL; clp->fscache = NULL;
} }
...@@ -139,7 +186,9 @@ void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int ...@@ -139,7 +186,9 @@ void nfs_fscache_get_super_cookie(struct super_block *sb, const char *uniq, int
/* create a cache index for looking up filehandles */ /* create a cache index for looking up filehandles */
nfss->fscache = fscache_acquire_cookie(nfss->nfs_client->fscache, nfss->fscache = fscache_acquire_cookie(nfss->nfs_client->fscache,
&nfs_fscache_super_index_def, &nfs_fscache_super_index_def,
nfss, true); key, sizeof(*key) + ulen,
NULL, 0,
nfss, 0, true);
dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n", dfprintk(FSCACHE, "NFS: get superblock cookie (0x%p/0x%p)\n",
nfss, nfss->fscache); nfss, nfss->fscache);
return; return;
...@@ -163,7 +212,7 @@ void nfs_fscache_release_super_cookie(struct super_block *sb) ...@@ -163,7 +212,7 @@ void nfs_fscache_release_super_cookie(struct super_block *sb)
dfprintk(FSCACHE, "NFS: releasing superblock cookie (0x%p/0x%p)\n", dfprintk(FSCACHE, "NFS: releasing superblock cookie (0x%p/0x%p)\n",
nfss, nfss->fscache); nfss, nfss->fscache);
fscache_relinquish_cookie(nfss->fscache, 0); fscache_relinquish_cookie(nfss->fscache, NULL, false);
nfss->fscache = NULL; nfss->fscache = NULL;
if (nfss->fscache_key) { if (nfss->fscache_key) {
...@@ -180,14 +229,25 @@ void nfs_fscache_release_super_cookie(struct super_block *sb) ...@@ -180,14 +229,25 @@ void nfs_fscache_release_super_cookie(struct super_block *sb)
*/ */
void nfs_fscache_init_inode(struct inode *inode) void nfs_fscache_init_inode(struct inode *inode)
{ {
struct nfs_fscache_inode_auxdata auxdata;
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
nfsi->fscache = NULL; nfsi->fscache = NULL;
if (!S_ISREG(inode->i_mode)) if (!S_ISREG(inode->i_mode))
return; return;
memset(&auxdata, 0, sizeof(auxdata));
auxdata.mtime = nfsi->vfs_inode.i_mtime;
auxdata.ctime = nfsi->vfs_inode.i_ctime;
if (NFS_SERVER(&nfsi->vfs_inode)->nfs_client->rpc_ops->version == 4)
auxdata.change_attr = inode_peek_iversion_raw(&nfsi->vfs_inode);
nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache, nfsi->fscache = fscache_acquire_cookie(NFS_SB(inode->i_sb)->fscache,
&nfs_fscache_inode_object_def, &nfs_fscache_inode_object_def,
nfsi, false); nfsi->fh.data, nfsi->fh.size,
&auxdata, sizeof(auxdata),
nfsi, nfsi->vfs_inode.i_size, false);
} }
/* /*
...@@ -195,12 +255,16 @@ void nfs_fscache_init_inode(struct inode *inode) ...@@ -195,12 +255,16 @@ void nfs_fscache_init_inode(struct inode *inode)
*/ */
void nfs_fscache_clear_inode(struct inode *inode) void nfs_fscache_clear_inode(struct inode *inode)
{ {
struct nfs_fscache_inode_auxdata auxdata;
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
struct fscache_cookie *cookie = nfs_i_fscache(inode); struct fscache_cookie *cookie = nfs_i_fscache(inode);
dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", nfsi, cookie); dfprintk(FSCACHE, "NFS: clear cookie (0x%p/0x%p)\n", nfsi, cookie);
fscache_relinquish_cookie(cookie, false); memset(&auxdata, 0, sizeof(auxdata));
auxdata.mtime = nfsi->vfs_inode.i_mtime;
auxdata.ctime = nfsi->vfs_inode.i_ctime;
fscache_relinquish_cookie(cookie, &auxdata, false);
nfsi->fscache = NULL; nfsi->fscache = NULL;
} }
...@@ -232,20 +296,26 @@ static bool nfs_fscache_can_enable(void *data) ...@@ -232,20 +296,26 @@ static bool nfs_fscache_can_enable(void *data)
*/ */
void nfs_fscache_open_file(struct inode *inode, struct file *filp) void nfs_fscache_open_file(struct inode *inode, struct file *filp)
{ {
struct nfs_fscache_inode_auxdata auxdata;
struct nfs_inode *nfsi = NFS_I(inode); struct nfs_inode *nfsi = NFS_I(inode);
struct fscache_cookie *cookie = nfs_i_fscache(inode); struct fscache_cookie *cookie = nfs_i_fscache(inode);
if (!fscache_cookie_valid(cookie)) if (!fscache_cookie_valid(cookie))
return; return;
memset(&auxdata, 0, sizeof(auxdata));
auxdata.mtime = nfsi->vfs_inode.i_mtime;
auxdata.ctime = nfsi->vfs_inode.i_ctime;
if (inode_is_open_for_write(inode)) { if (inode_is_open_for_write(inode)) {
dfprintk(FSCACHE, "NFS: nfsi 0x%p disabling cache\n", nfsi); dfprintk(FSCACHE, "NFS: nfsi 0x%p disabling cache\n", nfsi);
clear_bit(NFS_INO_FSCACHE, &nfsi->flags); clear_bit(NFS_INO_FSCACHE, &nfsi->flags);
fscache_disable_cookie(cookie, true); fscache_disable_cookie(cookie, &auxdata, true);
fscache_uncache_all_inode_pages(cookie, inode); fscache_uncache_all_inode_pages(cookie, inode);
} else { } else {
dfprintk(FSCACHE, "NFS: nfsi 0x%p enabling cache\n", nfsi); dfprintk(FSCACHE, "NFS: nfsi 0x%p enabling cache\n", nfsi);
fscache_enable_cookie(cookie, nfs_fscache_can_enable, inode); fscache_enable_cookie(cookie, &auxdata, nfsi->vfs_inode.i_size,
nfs_fscache_can_enable, inode);
if (fscache_cookie_enabled(cookie)) if (fscache_cookie_enabled(cookie))
set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags); set_bit(NFS_INO_FSCACHE, &NFS_I(inode)->flags);
} }
...@@ -422,7 +492,8 @@ void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync) ...@@ -422,7 +492,8 @@ void __nfs_readpage_to_fscache(struct inode *inode, struct page *page, int sync)
"NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n", "NFS: readpage_to_fscache(fsc:%p/p:%p(i:%lx f:%lx)/%d)\n",
nfs_i_fscache(inode), page, page->index, page->flags, sync); nfs_i_fscache(inode), page, page->index, page->flags, sync);
ret = fscache_write_page(nfs_i_fscache(inode), page, GFP_KERNEL); ret = fscache_write_page(nfs_i_fscache(inode), page,
inode->i_size, GFP_KERNEL);
dfprintk(FSCACHE, dfprintk(FSCACHE,
"NFS: readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n", "NFS: readpage_to_fscache: p:%p(i:%lu f:%lx) ret %d\n",
page, page->index, page->flags, ret); page, page->index, page->flags, ret);
......
...@@ -56,6 +56,21 @@ struct nfs_fscache_key { ...@@ -56,6 +56,21 @@ struct nfs_fscache_key {
} key; } key;
}; };
/*
* Definition of the auxiliary data attached to NFS inode storage objects
* within the cache.
*
* The contents of this struct are recorded in the on-disk local cache in the
* auxiliary data attached to the data storage object backing an inode. This
* permits coherency to be managed when a new inode binds to an already extant
* cache object.
*/
struct nfs_fscache_inode_auxdata {
struct timespec mtime;
struct timespec ctime;
u64 change_attr;
};
/* /*
* fscache-index.c * fscache-index.c
*/ */
......
...@@ -29,6 +29,18 @@ struct fscache_cache_ops; ...@@ -29,6 +29,18 @@ struct fscache_cache_ops;
struct fscache_object; struct fscache_object;
struct fscache_operation; struct fscache_operation;
enum fscache_obj_ref_trace {
fscache_obj_get_add_to_deps,
fscache_obj_get_queue,
fscache_obj_put_alloc_fail,
fscache_obj_put_attach_fail,
fscache_obj_put_drop_obj,
fscache_obj_put_enq_dep,
fscache_obj_put_queue,
fscache_obj_put_work,
fscache_obj_ref__nr_traces
};
/* /*
* cache tag definition * cache tag definition
*/ */
...@@ -123,7 +135,8 @@ extern void fscache_op_work_func(struct work_struct *work); ...@@ -123,7 +135,8 @@ extern void fscache_op_work_func(struct work_struct *work);
extern void fscache_enqueue_operation(struct fscache_operation *); extern void fscache_enqueue_operation(struct fscache_operation *);
extern void fscache_op_complete(struct fscache_operation *, bool); extern void fscache_op_complete(struct fscache_operation *, bool);
extern void fscache_put_operation(struct fscache_operation *); extern void fscache_put_operation(struct fscache_operation *);
extern void fscache_operation_init(struct fscache_operation *, extern void fscache_operation_init(struct fscache_cookie *,
struct fscache_operation *,
fscache_operation_processor_t, fscache_operation_processor_t,
fscache_operation_cancel_t, fscache_operation_cancel_t,
fscache_operation_release_t); fscache_operation_release_t);
...@@ -185,7 +198,7 @@ static inline void fscache_retrieval_complete(struct fscache_retrieval *op, ...@@ -185,7 +198,7 @@ static inline void fscache_retrieval_complete(struct fscache_retrieval *op,
{ {
atomic_sub(n_pages, &op->n_pages); atomic_sub(n_pages, &op->n_pages);
if (atomic_read(&op->n_pages) <= 0) if (atomic_read(&op->n_pages) <= 0)
fscache_op_complete(&op->op, true); fscache_op_complete(&op->op, false);
} }
/** /**
...@@ -231,7 +244,8 @@ struct fscache_cache_ops { ...@@ -231,7 +244,8 @@ struct fscache_cache_ops {
void (*lookup_complete)(struct fscache_object *object); void (*lookup_complete)(struct fscache_object *object);
/* increment the usage count on this object (may fail if unmounting) */ /* increment the usage count on this object (may fail if unmounting) */
struct fscache_object *(*grab_object)(struct fscache_object *object); struct fscache_object *(*grab_object)(struct fscache_object *object,
enum fscache_obj_ref_trace why);
/* pin an object in the cache */ /* pin an object in the cache */
int (*pin_object)(struct fscache_object *object); int (*pin_object)(struct fscache_object *object);
...@@ -254,7 +268,8 @@ struct fscache_cache_ops { ...@@ -254,7 +268,8 @@ struct fscache_cache_ops {
void (*drop_object)(struct fscache_object *object); void (*drop_object)(struct fscache_object *object);
/* dispose of a reference to an object */ /* dispose of a reference to an object */
void (*put_object)(struct fscache_object *object); void (*put_object)(struct fscache_object *object,
enum fscache_obj_ref_trace why);
/* sync a cache */ /* sync a cache */
void (*sync_cache)(struct fscache_cache *cache); void (*sync_cache)(struct fscache_cache *cache);
...@@ -538,7 +553,8 @@ extern bool fscache_object_sleep_till_congested(signed long *timeoutp); ...@@ -538,7 +553,8 @@ extern bool fscache_object_sleep_till_congested(signed long *timeoutp);
extern enum fscache_checkaux fscache_check_aux(struct fscache_object *object, extern enum fscache_checkaux fscache_check_aux(struct fscache_object *object,
const void *data, const void *data,
uint16_t datalen); uint16_t datalen,
loff_t object_size);
extern void fscache_object_retrying_stale(struct fscache_object *object); extern void fscache_object_retrying_stale(struct fscache_object *object);
......
This diff is collapsed.
/* CacheFiles tracepoints
*
* Copyright (C) 2016 Red Hat, Inc. All Rights Reserved.
* Written by David Howells (dhowells@redhat.com)
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public Licence
* as published by the Free Software Foundation; either version
* 2 of the Licence, or (at your option) any later version.
*/
#undef TRACE_SYSTEM
#define TRACE_SYSTEM cachefiles
#if !defined(_TRACE_CACHEFILES_H) || defined(TRACE_HEADER_MULTI_READ)
#define _TRACE_CACHEFILES_H
#include <linux/tracepoint.h>
/*
* Define enums for tracing information.
*/
#ifndef __CACHEFILES_DECLARE_TRACE_ENUMS_ONCE_ONLY
#define __CACHEFILES_DECLARE_TRACE_ENUMS_ONCE_ONLY
enum cachefiles_obj_ref_trace {
cachefiles_obj_put_wait_retry = fscache_obj_ref__nr_traces,
cachefiles_obj_put_wait_timeo,
cachefiles_obj_ref__nr_traces
};
#endif
/*
* Define enum -> string mappings for display.
*/
#define cachefiles_obj_kill_traces \
EM(FSCACHE_OBJECT_IS_STALE, "stale") \
EM(FSCACHE_OBJECT_NO_SPACE, "no_space") \
EM(FSCACHE_OBJECT_WAS_RETIRED, "was_retired") \
E_(FSCACHE_OBJECT_WAS_CULLED, "was_culled")
#define cachefiles_obj_ref_traces \
EM(fscache_obj_get_add_to_deps, "GET add_to_deps") \
EM(fscache_obj_get_queue, "GET queue") \
EM(fscache_obj_put_alloc_fail, "PUT alloc_fail") \
EM(fscache_obj_put_attach_fail, "PUT attach_fail") \
EM(fscache_obj_put_drop_obj, "PUT drop_obj") \
EM(fscache_obj_put_enq_dep, "PUT enq_dep") \
EM(fscache_obj_put_queue, "PUT queue") \
EM(fscache_obj_put_work, "PUT work") \
EM(cachefiles_obj_put_wait_retry, "PUT wait_retry") \
E_(cachefiles_obj_put_wait_timeo, "PUT wait_timeo")
/*
* Export enum symbols via userspace.
*/
#undef EM
#undef E_
#define EM(a, b) TRACE_DEFINE_ENUM(a);
#define E_(a, b) TRACE_DEFINE_ENUM(a);
cachefiles_obj_kill_traces;
cachefiles_obj_ref_traces;
/*
* Now redefine the EM() and E_() macros to map the enums to the strings that
* will be printed in the output.
*/
#undef EM
#undef E_
#define EM(a, b) { a, b },
#define E_(a, b) { a, b }
TRACE_EVENT(cachefiles_ref,
TP_PROTO(struct cachefiles_object *obj,
struct fscache_cookie *cookie,
enum cachefiles_obj_ref_trace why,
int usage),
TP_ARGS(obj, cookie, why, usage),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct fscache_cookie *, cookie )
__field(enum cachefiles_obj_ref_trace, why )
__field(int, usage )
),
TP_fast_assign(
__entry->obj = obj;
__entry->cookie = cookie;
__entry->usage = usage;
__entry->why = why;
),
TP_printk("c=%p o=%p u=%d %s",
__entry->cookie, __entry->obj, __entry->usage,
__print_symbolic(__entry->why, cachefiles_obj_ref_traces))
);
TRACE_EVENT(cachefiles_lookup,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de,
struct inode *inode),
TP_ARGS(obj, de, inode),
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(struct inode *, inode )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->inode = inode;
),
TP_printk("o=%p d=%p i=%p",
__entry->obj, __entry->de, __entry->inode)
);
TRACE_EVENT(cachefiles_mkdir,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de, int ret),
TP_ARGS(obj, de, ret),
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(int, ret )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->ret = ret;
),
TP_printk("o=%p d=%p r=%u",
__entry->obj, __entry->de, __entry->ret)
);
TRACE_EVENT(cachefiles_create,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de, int ret),
TP_ARGS(obj, de, ret),
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(int, ret )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->ret = ret;
),
TP_printk("o=%p d=%p r=%u",
__entry->obj, __entry->de, __entry->ret)
);
TRACE_EVENT(cachefiles_unlink,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de,
enum fscache_why_object_killed why),
TP_ARGS(obj, de, why),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(enum fscache_why_object_killed, why )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->why = why;
),
TP_printk("o=%p d=%p w=%s",
__entry->obj, __entry->de,
__print_symbolic(__entry->why, cachefiles_obj_kill_traces))
);
TRACE_EVENT(cachefiles_rename,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de,
struct dentry *to,
enum fscache_why_object_killed why),
TP_ARGS(obj, de, to, why),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(struct dentry *, to )
__field(enum fscache_why_object_killed, why )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->to = to;
__entry->why = why;
),
TP_printk("o=%p d=%p t=%p w=%s",
__entry->obj, __entry->de, __entry->to,
__print_symbolic(__entry->why, cachefiles_obj_kill_traces))
);
TRACE_EVENT(cachefiles_mark_active,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de),
TP_ARGS(obj, de),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
),
TP_printk("o=%p d=%p",
__entry->obj, __entry->de)
);
TRACE_EVENT(cachefiles_wait_active,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de,
struct cachefiles_object *xobj),
TP_ARGS(obj, de, xobj),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(struct cachefiles_object *, xobj )
__field(u16, flags )
__field(u16, fsc_flags )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->xobj = xobj;
__entry->flags = xobj->flags;
__entry->fsc_flags = xobj->fscache.flags;
),
TP_printk("o=%p d=%p wo=%p wf=%x wff=%x",
__entry->obj, __entry->de, __entry->xobj,
__entry->flags, __entry->fsc_flags)
);
TRACE_EVENT(cachefiles_mark_inactive,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de,
struct inode *inode),
TP_ARGS(obj, de, inode),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(struct inode *, inode )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->inode = inode;
),
TP_printk("o=%p d=%p i=%p",
__entry->obj, __entry->de, __entry->inode)
);
TRACE_EVENT(cachefiles_mark_buried,
TP_PROTO(struct cachefiles_object *obj,
struct dentry *de,
enum fscache_why_object_killed why),
TP_ARGS(obj, de, why),
/* Note that obj may be NULL */
TP_STRUCT__entry(
__field(struct cachefiles_object *, obj )
__field(struct dentry *, de )
__field(enum fscache_why_object_killed, why )
),
TP_fast_assign(
__entry->obj = obj;
__entry->de = de;
__entry->why = why;
),
TP_printk("o=%p d=%p w=%s",
__entry->obj, __entry->de,
__print_symbolic(__entry->why, cachefiles_obj_kill_traces))
);
#endif /* _TRACE_CACHEFILES_H */
/* This part must be outside protection */
#include <trace/define_trace.h>
This diff is collapsed.
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment