Skip to content

Commit

Permalink
fscache: Attach the index key and aux data to the cookie
Browse files Browse the repository at this point in the history
Attach copies of the index key and auxiliary data to the fscache cookie so
that:

 (1) The callbacks to the netfs for this stuff can be eliminated.  This
     can simplify things in the cache as the information is still
     available, even after the cache has relinquished the cookie.

 (2) Simplifies the locking requirements of accessing the information as we
     don't have to worry about the netfs object going away on us.

 (3) The cache can do lazy updating of the coherency information on disk.
     As long as the cache is flushed before reboot/poweroff, there's no
     need to update the coherency info on disk every time it changes.

 (4) Cookies can be hashed or put in a tree as the index key is easily
     available.  This allows:

     (a) Checks for duplicate cookies can be made at the top fscache layer
     	 rather than down in the bowels of the cache backend.

     (b) Caching can be added to a netfs object that has a cookie if the
     	 cache is brought online after the netfs object is allocated.

A certain amount of space is made in the cookie for inline copies of the
data, but if it won't fit there, extra memory will be allocated for it.

The downside of this is that live cache operation requires more memory.

Signed-off-by: David Howells <[email protected]>
Acked-by: Anna Schumaker <[email protected]>
Tested-by: Steve Dickson <[email protected]>
  • Loading branch information
dhowells committed Apr 4, 2018
1 parent 08c2e3d commit 402cb8d
Show file tree
Hide file tree
Showing 26 changed files with 606 additions and 786 deletions.
106 changes: 51 additions & 55 deletions Documentation/filesystems/caching/netfs-api.txt
Original file line number Diff line number Diff line change
Expand Up @@ -129,17 +129,9 @@ To define an object, a structure of the following type should be filled out:
const void *parent_netfs_data,
const void *cookie_netfs_data);

uint16_t (*get_key)(const void *cookie_netfs_data,
void *buffer,
uint16_t bufmax);

void (*get_attr)(const void *cookie_netfs_data,
uint64_t *size);

uint16_t (*get_aux)(const void *cookie_netfs_data,
void *buffer,
uint16_t bufmax);

enum fscache_checkaux (*check_aux)(void *cookie_netfs_data,
const void *data,
uint16_t datalen);
Expand Down Expand Up @@ -187,14 +179,7 @@ This has the following fields:
cache in the parent's list will be chosen, or failing that, the first
cache in the master list.

(4) A function to retrieve an object's key from the netfs [mandatory].

This function will be called with the netfs data that was passed to the
cookie acquisition function and the maximum length of key data that it may
provide. It should write the required key data into the given buffer and
return the quantity it wrote.

(5) A function to retrieve attribute data from the netfs [optional].
(4) A function to retrieve attribute data from the netfs [optional].

This function will be called with the netfs data that was passed to the
cookie acquisition function. It should return the size of the file if
Expand All @@ -203,20 +188,7 @@ This has the following fields:

If the function is absent, a file size of 0 is assumed.

(6) A function to retrieve auxiliary data from the netfs [optional].

This function will be called with the netfs data that was passed to the
cookie acquisition function and the maximum length of auxiliary data that
it may provide. It should write the auxiliary data into the given buffer
and return the quantity it wrote.

If this function is absent, the auxiliary data length will be set to 0.

The length of the auxiliary data buffer may be dependent on the key
length. A netfs mustn't rely on being able to provide more than 400 bytes
for both.

(7) A function to check the auxiliary data [optional].
(5) A function to check the auxiliary data [optional].

This function will be called to check that a match found in the cache for
this object is valid. For instance with AFS it could check the auxiliary
Expand All @@ -235,7 +207,7 @@ This has the following fields:
This function can also be used to extract data from the auxiliary data in
the cache and copy it into the netfs's structures.

(8) A pair of functions to manage contexts for the completion callback
(6) A pair of functions to manage contexts for the completion callback
[optional].

The cache read/write functions are passed a context which is then passed
Expand All @@ -249,7 +221,7 @@ This has the following fields:
required for indices as indices may not contain data. These functions may
be called in interrupt context and so may not sleep.

(9) A function to mark a page as retaining cache metadata [optional].
(7) A function to mark a page as retaining cache metadata [optional].

This is called by the cache to indicate that it is retaining in-memory
information for this page and that the netfs should uncache the page when
Expand All @@ -261,7 +233,7 @@ This has the following fields:

This function is not required for indices as they're not permitted data.

(10) A function to unmark all the pages retaining cache metadata [mandatory].
(8) A function to unmark all the pages retaining cache metadata [mandatory].

This is called by FS-Cache to indicate that a backing store is being
unbound from a cookie and that all the marks on the pages should be
Expand Down Expand Up @@ -333,12 +305,27 @@ the path to the file:
struct fscache_cookie *
fscache_acquire_cookie(struct fscache_cookie *parent,
const struct fscache_object_def *def,
const void *index_key,
size_t index_key_len,
const void *aux_data,
size_t aux_data_len,
void *netfs_data,
bool enable);

This function creates an index entry in the index represented by parent,
filling in the index entry by calling the operations pointed to by def.

A unique key that represents the object within the parent must be pointed to by
index_key and is of length index_key_len.

An optional blob of auxiliary data that is to be stored within the cache can be
pointed to with aux_data and should be of length aux_data_len. This would
typically be used for storing coherency data.

The netfs may pass an arbitrary value in netfs_data and this will be presented
to it in the event of any calling back. This may also be used in tracing or
logging of messages.

Note that this function never returns an error - all errors are handled
internally. It may, however, return NULL to indicate no cookie. It is quite
acceptable to pass this token back to this function as the parent to another
Expand All @@ -355,29 +342,23 @@ must be enabled to do anything with it. A disabled cookie can be enabled by
calling fscache_enable_cookie() (see below).

For example, with AFS, a cell would be added to the primary index. This index
entry would have a dependent inode containing a volume location index for the
volume mappings within this cell:
entry would have a dependent inode containing volume mappings within this cell:

cell->cache =
fscache_acquire_cookie(afs_cache_netfs.primary_index,
&afs_cell_cache_index_def,
cell->name, strlen(cell->name),
NULL, 0,
cell, true);

Then when a volume location was accessed, it would be entered into the cell's
index and an inode would be allocated that acts as a volume type and hash chain
combination:

vlocation->cache =
fscache_acquire_cookie(cell->cache,
&afs_vlocation_cache_index_def,
vlocation, true);

And then a particular flavour of volume (R/O for example) could be added to
that index, creating another index for vnodes (AFS inode equivalents):
And then a particular volume could be added to that index by ID, creating
another index for vnodes (AFS inode equivalents):

volume->cache =
fscache_acquire_cookie(vlocation->cache,
fscache_acquire_cookie(volume->cell->cache,
&afs_volume_cache_index_def,
&volume->vid, sizeof(volume->vid),
NULL, 0,
volume, true);


Expand All @@ -392,6 +373,8 @@ the object definition should be something other than index type.
vnode->cache =
fscache_acquire_cookie(volume->cache,
&afs_vnode_cache_object_def,
&key, sizeof(key),
&aux, sizeof(aux),
vnode, true);


Expand All @@ -408,6 +391,8 @@ it would be some other type of object such as a data file.
xattr->cache =
fscache_acquire_cookie(vnode->cache,
&afs_xattr_cache_object_def,
&xattr->name, strlen(xattr->name),
NULL, 0,
xattr, true);

Miscellaneous objects might be used to store extended attributes or directory
Expand Down Expand Up @@ -717,21 +702,23 @@ INDEX AND DATA FILE CONSISTENCY
To find out whether auxiliary data for an object is up to data within the
cache, the following function can be called:

int fscache_check_consistency(struct fscache_cookie *cookie)
int fscache_check_consistency(struct fscache_cookie *cookie,
const void *aux_data);

This will call back to the netfs to check whether the auxiliary data associated
with a cookie is correct. It returns 0 if it is and -ESTALE if it isn't; it
may also return -ENOMEM and -ERESTARTSYS.
with a cookie is correct; if aux_data is non-NULL, it will update the auxiliary
data buffer first. It returns 0 if it is and -ESTALE if it isn't; it may also
return -ENOMEM and -ERESTARTSYS.

To request an update of the index data for an index or other object, the
following function should be called:

void fscache_update_cookie(struct fscache_cookie *cookie);
void fscache_update_cookie(struct fscache_cookie *cookie,
const void *aux_data);

This function will refer back to the netfs_data pointer stored in the cookie by
the acquisition function to obtain the data to write into each revised index
entry. The update method in the parent index definition will be called to
transfer the data.
This function will update the cookie's auxiliary data buffer from aux_data if
that is non-NULL and then schedule this to be stored on disk. The update
method in the parent index definition will be called to transfer the data.

Note that partial updates may happen automatically at other times, such as when
data blocks are added to a data file object.
Expand All @@ -750,6 +737,7 @@ The initial enablement state is set by fscache_acquire_cookie(), but the cookie
can be enabled or disabled later. To disable a cookie, call:

void fscache_disable_cookie(struct fscache_cookie *cookie,
const void *aux_data,
bool invalidate);

If the cookie is not already disabled, this locks the cookie against other
Expand All @@ -764,6 +752,7 @@ markings are cleared up.
Cookies can be enabled or reenabled with:

void fscache_enable_cookie(struct fscache_cookie *cookie,
const void *aux_data,
bool (*can_enable)(void *data),
void *data)

Expand All @@ -777,6 +766,9 @@ ruling as to whether or not enablement should actually be permitted to begin.
All possible failures are handled internally. The cookie will only be marked
as enabled if provisional backing objects are allocated.

In both cases, the cookie's auxiliary data buffer is updated from aux_data if
that is non-NULL inside the enablement lock before proceeding.


===============================
MISCELLANEOUS COOKIE OPERATIONS
Expand Down Expand Up @@ -823,6 +815,7 @@ COOKIE UNREGISTRATION
To get rid of a cookie, this function should be called.

void fscache_relinquish_cookie(struct fscache_cookie *cookie,
const void *aux_data,
bool retire);

If retire is non-zero, then the object will be marked for recycling, and all
Expand All @@ -833,6 +826,9 @@ If retire is zero, then the object may be available again when next the
acquisition function is called. Retirement here will overrule the pinning on a
cookie.

The cookie's auxiliary data will be updated from aux_data if that is non-NULL
so that the cache can lazily update it on disk.

One very important note - relinquish must NOT be called for a cookie unless all
the cookies for "child" indices, objects and pages have been relinquished
first.
Expand Down
73 changes: 22 additions & 51 deletions fs/9p/cache.c
Original file line number Diff line number Diff line change
Expand Up @@ -55,41 +55,26 @@ int v9fs_random_cachetag(struct v9fs_session_info *v9ses)
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 = {
.name = "9P.session",
.type = FSCACHE_COOKIE_TYPE_INDEX,
.get_key = v9fs_cache_session_get_key,
};

void v9fs_cache_session_get_cookie(struct v9fs_session_info *v9ses)
{
/* If no cache session tag was specified, we generate a random one. */
if (!v9ses->cachetag)
v9fs_random_cachetag(v9ses);
if (!v9ses->cachetag) {
if (v9fs_random_cachetag(v9ses) < 0) {
v9ses->fscache = NULL;
return;
}
}

v9ses->fscache = fscache_acquire_cookie(v9fs_cache_netfs.primary_index,
&v9fs_cache_session_index_def,
v9ses->cachetag,
strlen(v9ses->cachetag),
NULL, 0,
v9ses, true);
p9_debug(P9_DEBUG_FSC, "session %p get cookie %p\n",
v9ses, v9ses->fscache);
Expand All @@ -99,21 +84,10 @@ void v9fs_cache_session_put_cookie(struct v9fs_session_info *v9ses)
{
p9_debug(P9_DEBUG_FSC, "session %p put cookie %p\n",
v9ses, v9ses->fscache);
fscache_relinquish_cookie(v9ses->fscache, 0);
fscache_relinquish_cookie(v9ses->fscache, NULL, false);
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)
{
Expand All @@ -124,16 +98,6 @@ static void v9fs_cache_inode_get_attr(const void *cookie_netfs_data,
&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
fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
const void *buffer,
Expand All @@ -154,9 +118,7 @@ fscache_checkaux v9fs_cache_inode_check_aux(void *cookie_netfs_data,
const struct fscache_cookie_def v9fs_cache_inode_index_def = {
.name = "9p.inode",
.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,
};

Expand All @@ -175,6 +137,10 @@ void v9fs_cache_inode_get_cookie(struct inode *inode)
v9ses = v9fs_inode2v9ses(inode);
v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,
&v9fs_cache_inode_index_def,
&v9inode->qid.path,
sizeof(v9inode->qid.path),
&v9inode->qid.version,
sizeof(v9inode->qid.version),
v9inode, true);

p9_debug(P9_DEBUG_FSC, "inode %p get cookie %p\n",
Expand All @@ -190,7 +156,8 @@ void v9fs_cache_inode_put_cookie(struct inode *inode)
p9_debug(P9_DEBUG_FSC, "inode %p put cookie %p\n",
inode, v9inode->fscache);

fscache_relinquish_cookie(v9inode->fscache, 0);
fscache_relinquish_cookie(v9inode->fscache, &v9inode->qid.version,
false);
v9inode->fscache = NULL;
}

Expand All @@ -203,7 +170,7 @@ void v9fs_cache_inode_flush_cookie(struct inode *inode)
p9_debug(P9_DEBUG_FSC, "inode %p flush cookie %p\n",
inode, v9inode->fscache);

fscache_relinquish_cookie(v9inode->fscache, 1);
fscache_relinquish_cookie(v9inode->fscache, NULL, true);
v9inode->fscache = NULL;
}

Expand Down Expand Up @@ -236,11 +203,15 @@ void v9fs_cache_inode_reset_cookie(struct inode *inode)
old = v9inode->fscache;

mutex_lock(&v9inode->fscache_lock);
fscache_relinquish_cookie(v9inode->fscache, 1);
fscache_relinquish_cookie(v9inode->fscache, NULL, true);

v9ses = v9fs_inode2v9ses(inode);
v9inode->fscache = fscache_acquire_cookie(v9ses->fscache,
&v9fs_cache_inode_index_def,
&v9inode->qid.path,
sizeof(v9inode->qid.path),
&v9inode->qid.version,
sizeof(v9inode->qid.version),
v9inode, true);
p9_debug(P9_DEBUG_FSC, "inode %p revalidating cookie old %p new %p\n",
inode, old, v9inode->fscache);
Expand Down
Loading

0 comments on commit 402cb8d

Please sign in to comment.