402cb8dda9
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 <dhowells@redhat.com>
Acked-by: Anna Schumaker <anna.schumaker@netapp.com>
Tested-by: Steve Dickson <steved@redhat.com>
99 lines
3.1 KiB
C
99 lines
3.1 KiB
C
/* Filesystem index definition
|
|
*
|
|
* Copyright (C) 2004-2007 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 License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#define FSCACHE_DEBUG_LEVEL CACHE
|
|
#include <linux/module.h>
|
|
#include "internal.h"
|
|
|
|
static
|
|
enum fscache_checkaux fscache_fsdef_netfs_check_aux(void *cookie_netfs_data,
|
|
const void *data,
|
|
uint16_t datalen);
|
|
|
|
/*
|
|
* The root index is owned by FS-Cache itself.
|
|
*
|
|
* When a netfs requests caching facilities, FS-Cache will, if one doesn't
|
|
* already exist, create an entry in the root index with the key being the name
|
|
* of the netfs ("AFS" for example), and the auxiliary data holding the index
|
|
* structure version supplied by the netfs:
|
|
*
|
|
* FSDEF
|
|
* |
|
|
* +-----------+
|
|
* | |
|
|
* NFS AFS
|
|
* [v=1] [v=1]
|
|
*
|
|
* If an entry with the appropriate name does already exist, the version is
|
|
* compared. If the version is different, the entire subtree from that entry
|
|
* will be discarded and a new entry created.
|
|
*
|
|
* The new entry will be an index, and a cookie referring to it will be passed
|
|
* to the netfs. This is then the root handle by which the netfs accesses the
|
|
* cache. It can create whatever objects it likes in that index, including
|
|
* further indices.
|
|
*/
|
|
static struct fscache_cookie_def fscache_fsdef_index_def = {
|
|
.name = ".FS-Cache",
|
|
.type = FSCACHE_COOKIE_TYPE_INDEX,
|
|
};
|
|
|
|
struct fscache_cookie fscache_fsdef_index = {
|
|
.usage = ATOMIC_INIT(1),
|
|
.n_active = ATOMIC_INIT(1),
|
|
.lock = __SPIN_LOCK_UNLOCKED(fscache_fsdef_index.lock),
|
|
.backing_objects = HLIST_HEAD_INIT,
|
|
.def = &fscache_fsdef_index_def,
|
|
.flags = 1 << FSCACHE_COOKIE_ENABLED,
|
|
.type = FSCACHE_COOKIE_TYPE_INDEX,
|
|
};
|
|
EXPORT_SYMBOL(fscache_fsdef_index);
|
|
|
|
/*
|
|
* Definition of an entry in the root index. Each entry is an index, keyed to
|
|
* a specific netfs and only applicable to a particular version of the index
|
|
* structure used by that netfs.
|
|
*/
|
|
struct fscache_cookie_def fscache_fsdef_netfs_def = {
|
|
.name = "FSDEF.netfs",
|
|
.type = FSCACHE_COOKIE_TYPE_INDEX,
|
|
.check_aux = fscache_fsdef_netfs_check_aux,
|
|
};
|
|
|
|
/*
|
|
* check that the index structure version number stored in the auxiliary data
|
|
* matches the one the netfs gave us
|
|
*/
|
|
static enum fscache_checkaux fscache_fsdef_netfs_check_aux(
|
|
void *cookie_netfs_data,
|
|
const void *data,
|
|
uint16_t datalen)
|
|
{
|
|
struct fscache_netfs *netfs = cookie_netfs_data;
|
|
uint32_t version;
|
|
|
|
_enter("{%s},,%hu", netfs->name, datalen);
|
|
|
|
if (datalen != sizeof(version)) {
|
|
_leave(" = OBSOLETE [dl=%d v=%zu]", datalen, sizeof(version));
|
|
return FSCACHE_CHECKAUX_OBSOLETE;
|
|
}
|
|
|
|
memcpy(&version, data, sizeof(version));
|
|
if (version != netfs->version) {
|
|
_leave(" = OBSOLETE [ver=%x net=%x]", version, netfs->version);
|
|
return FSCACHE_CHECKAUX_OBSOLETE;
|
|
}
|
|
|
|
_leave(" = OKAY");
|
|
return FSCACHE_CHECKAUX_OKAY;
|
|
}
|