forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
960 lines
25 KiB
960 lines
25 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* netfs cookie management |
|
* |
|
* Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved. |
|
* Written by David Howells ([email protected]) |
|
* |
|
* See Documentation/filesystems/caching/netfs-api.rst for more information on |
|
* the netfs API. |
|
*/ |
|
|
|
#define FSCACHE_DEBUG_LEVEL COOKIE |
|
#include <linux/module.h> |
|
#include <linux/slab.h> |
|
#include "internal.h" |
|
|
|
struct kmem_cache *fscache_cookie_jar; |
|
|
|
static atomic_t fscache_object_debug_id = ATOMIC_INIT(0); |
|
|
|
#define fscache_cookie_hash_shift 15 |
|
static struct hlist_bl_head fscache_cookie_hash[1 << fscache_cookie_hash_shift]; |
|
|
|
static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie, |
|
loff_t object_size); |
|
static int fscache_alloc_object(struct fscache_cache *cache, |
|
struct fscache_cookie *cookie); |
|
static int fscache_attach_object(struct fscache_cookie *cookie, |
|
struct fscache_object *object); |
|
|
|
static void fscache_print_cookie(struct fscache_cookie *cookie, char prefix) |
|
{ |
|
struct hlist_node *object; |
|
const u8 *k; |
|
unsigned loop; |
|
|
|
pr_err("%c-cookie c=%p [p=%p fl=%lx nc=%u na=%u]\n", |
|
prefix, cookie, cookie->parent, cookie->flags, |
|
atomic_read(&cookie->n_children), |
|
atomic_read(&cookie->n_active)); |
|
pr_err("%c-cookie d=%p n=%p\n", |
|
prefix, cookie->def, cookie->netfs_data); |
|
|
|
object = READ_ONCE(cookie->backing_objects.first); |
|
if (object) |
|
pr_err("%c-cookie o=%p\n", |
|
prefix, hlist_entry(object, struct fscache_object, cookie_link)); |
|
|
|
pr_err("%c-key=[%u] '", prefix, cookie->key_len); |
|
k = (cookie->key_len <= sizeof(cookie->inline_key)) ? |
|
cookie->inline_key : cookie->key; |
|
for (loop = 0; loop < cookie->key_len; loop++) |
|
pr_cont("%02x", k[loop]); |
|
pr_cont("'\n"); |
|
} |
|
|
|
void fscache_free_cookie(struct fscache_cookie *cookie) |
|
{ |
|
if (cookie) { |
|
BUG_ON(!hlist_empty(&cookie->backing_objects)); |
|
if (cookie->aux_len > sizeof(cookie->inline_aux)) |
|
kfree(cookie->aux); |
|
if (cookie->key_len > sizeof(cookie->inline_key)) |
|
kfree(cookie->key); |
|
kmem_cache_free(fscache_cookie_jar, cookie); |
|
} |
|
} |
|
|
|
/* |
|
* Set the index key in a cookie. The cookie struct has space for a 16-byte |
|
* key plus length and hash, but if that's not big enough, it's instead a |
|
* pointer to a buffer containing 3 bytes of hash, 1 byte of length and then |
|
* the key data. |
|
*/ |
|
static int fscache_set_key(struct fscache_cookie *cookie, |
|
const void *index_key, size_t index_key_len) |
|
{ |
|
unsigned long long h; |
|
u32 *buf; |
|
int bufs; |
|
int i; |
|
|
|
bufs = DIV_ROUND_UP(index_key_len, sizeof(*buf)); |
|
|
|
if (index_key_len > sizeof(cookie->inline_key)) { |
|
buf = kcalloc(bufs, sizeof(*buf), GFP_KERNEL); |
|
if (!buf) |
|
return -ENOMEM; |
|
cookie->key = buf; |
|
} else { |
|
buf = (u32 *)cookie->inline_key; |
|
} |
|
|
|
memcpy(buf, index_key, index_key_len); |
|
|
|
/* Calculate a hash and combine this with the length in the first word |
|
* or first half word |
|
*/ |
|
h = (unsigned long)cookie->parent; |
|
h += index_key_len + cookie->type; |
|
|
|
for (i = 0; i < bufs; i++) |
|
h += buf[i]; |
|
|
|
cookie->key_hash = h ^ (h >> 32); |
|
return 0; |
|
} |
|
|
|
static long fscache_compare_cookie(const struct fscache_cookie *a, |
|
const struct fscache_cookie *b) |
|
{ |
|
const void *ka, *kb; |
|
|
|
if (a->key_hash != b->key_hash) |
|
return (long)a->key_hash - (long)b->key_hash; |
|
if (a->parent != b->parent) |
|
return (long)a->parent - (long)b->parent; |
|
if (a->key_len != b->key_len) |
|
return (long)a->key_len - (long)b->key_len; |
|
if (a->type != b->type) |
|
return (long)a->type - (long)b->type; |
|
|
|
if (a->key_len <= sizeof(a->inline_key)) { |
|
ka = &a->inline_key; |
|
kb = &b->inline_key; |
|
} else { |
|
ka = a->key; |
|
kb = b->key; |
|
} |
|
return memcmp(ka, kb, a->key_len); |
|
} |
|
|
|
/* |
|
* Allocate a cookie. |
|
*/ |
|
struct fscache_cookie *fscache_alloc_cookie( |
|
struct fscache_cookie *parent, |
|
const struct fscache_cookie_def *def, |
|
const void *index_key, size_t index_key_len, |
|
const void *aux_data, size_t aux_data_len, |
|
void *netfs_data, |
|
loff_t object_size) |
|
{ |
|
struct fscache_cookie *cookie; |
|
|
|
/* allocate and initialise a cookie */ |
|
cookie = kmem_cache_zalloc(fscache_cookie_jar, GFP_KERNEL); |
|
if (!cookie) |
|
return NULL; |
|
|
|
cookie->key_len = index_key_len; |
|
cookie->aux_len = aux_data_len; |
|
|
|
if (fscache_set_key(cookie, index_key, index_key_len) < 0) |
|
goto nomem; |
|
|
|
if (cookie->aux_len <= sizeof(cookie->inline_aux)) { |
|
memcpy(cookie->inline_aux, aux_data, cookie->aux_len); |
|
} else { |
|
cookie->aux = kmemdup(aux_data, cookie->aux_len, GFP_KERNEL); |
|
if (!cookie->aux) |
|
goto nomem; |
|
} |
|
|
|
atomic_set(&cookie->usage, 1); |
|
atomic_set(&cookie->n_children, 0); |
|
|
|
/* We keep the active count elevated until relinquishment to prevent an |
|
* attempt to wake up every time the object operations queue quiesces. |
|
*/ |
|
atomic_set(&cookie->n_active, 1); |
|
|
|
cookie->def = def; |
|
cookie->parent = parent; |
|
cookie->netfs_data = netfs_data; |
|
cookie->flags = (1 << FSCACHE_COOKIE_NO_DATA_YET); |
|
cookie->type = def->type; |
|
spin_lock_init(&cookie->lock); |
|
spin_lock_init(&cookie->stores_lock); |
|
INIT_HLIST_HEAD(&cookie->backing_objects); |
|
|
|
/* radix tree insertion won't use the preallocation pool unless it's |
|
* told it may not wait */ |
|
INIT_RADIX_TREE(&cookie->stores, GFP_NOFS & ~__GFP_DIRECT_RECLAIM); |
|
return cookie; |
|
|
|
nomem: |
|
fscache_free_cookie(cookie); |
|
return NULL; |
|
} |
|
|
|
/* |
|
* Attempt to insert the new cookie into the hash. If there's a collision, we |
|
* return the old cookie if it's not in use and an error otherwise. |
|
*/ |
|
struct fscache_cookie *fscache_hash_cookie(struct fscache_cookie *candidate) |
|
{ |
|
struct fscache_cookie *cursor; |
|
struct hlist_bl_head *h; |
|
struct hlist_bl_node *p; |
|
unsigned int bucket; |
|
|
|
bucket = candidate->key_hash & (ARRAY_SIZE(fscache_cookie_hash) - 1); |
|
h = &fscache_cookie_hash[bucket]; |
|
|
|
hlist_bl_lock(h); |
|
hlist_bl_for_each_entry(cursor, p, h, hash_link) { |
|
if (fscache_compare_cookie(candidate, cursor) == 0) |
|
goto collision; |
|
} |
|
|
|
__set_bit(FSCACHE_COOKIE_ACQUIRED, &candidate->flags); |
|
fscache_cookie_get(candidate->parent, fscache_cookie_get_acquire_parent); |
|
atomic_inc(&candidate->parent->n_children); |
|
hlist_bl_add_head(&candidate->hash_link, h); |
|
hlist_bl_unlock(h); |
|
return candidate; |
|
|
|
collision: |
|
if (test_and_set_bit(FSCACHE_COOKIE_ACQUIRED, &cursor->flags)) { |
|
trace_fscache_cookie(cursor, fscache_cookie_collision, |
|
atomic_read(&cursor->usage)); |
|
pr_err("Duplicate cookie detected\n"); |
|
fscache_print_cookie(cursor, 'O'); |
|
fscache_print_cookie(candidate, 'N'); |
|
hlist_bl_unlock(h); |
|
return NULL; |
|
} |
|
|
|
fscache_cookie_get(cursor, fscache_cookie_get_reacquire); |
|
hlist_bl_unlock(h); |
|
return cursor; |
|
} |
|
|
|
/* |
|
* request a cookie to represent an object (index, datafile, xattr, etc) |
|
* - parent specifies the parent object |
|
* - the top level index cookie for each netfs is stored in the fscache_netfs |
|
* struct upon registration |
|
* - def points to the definition |
|
* - the netfs_data will be passed to the functions pointed to in *def |
|
* - all attached caches will be searched to see if they contain this object |
|
* - index objects aren't stored on disk until there's a dependent file that |
|
* needs storing |
|
* - other objects are stored in a selected cache immediately, and all the |
|
* indices forming the path to it are instantiated if necessary |
|
* - we never let on to the netfs about errors |
|
* - we may set a negative cookie pointer, but that's okay |
|
*/ |
|
struct fscache_cookie *__fscache_acquire_cookie( |
|
struct fscache_cookie *parent, |
|
const struct fscache_cookie_def *def, |
|
const void *index_key, size_t index_key_len, |
|
const void *aux_data, size_t aux_data_len, |
|
void *netfs_data, |
|
loff_t object_size, |
|
bool enable) |
|
{ |
|
struct fscache_cookie *candidate, *cookie; |
|
|
|
BUG_ON(!def); |
|
|
|
_enter("{%s},{%s},%p,%u", |
|
parent ? (char *) parent->def->name : "<no-parent>", |
|
def->name, netfs_data, enable); |
|
|
|
if (!index_key || !index_key_len || index_key_len > 255 || aux_data_len > 255) |
|
return NULL; |
|
if (!aux_data || !aux_data_len) { |
|
aux_data = NULL; |
|
aux_data_len = 0; |
|
} |
|
|
|
fscache_stat(&fscache_n_acquires); |
|
|
|
/* if there's no parent cookie, then we don't create one here either */ |
|
if (!parent) { |
|
fscache_stat(&fscache_n_acquires_null); |
|
_leave(" [no parent]"); |
|
return NULL; |
|
} |
|
|
|
/* validate the definition */ |
|
BUG_ON(!def->name[0]); |
|
|
|
BUG_ON(def->type == FSCACHE_COOKIE_TYPE_INDEX && |
|
parent->type != FSCACHE_COOKIE_TYPE_INDEX); |
|
|
|
candidate = fscache_alloc_cookie(parent, def, |
|
index_key, index_key_len, |
|
aux_data, aux_data_len, |
|
netfs_data, object_size); |
|
if (!candidate) { |
|
fscache_stat(&fscache_n_acquires_oom); |
|
_leave(" [ENOMEM]"); |
|
return NULL; |
|
} |
|
|
|
cookie = fscache_hash_cookie(candidate); |
|
if (!cookie) { |
|
trace_fscache_cookie(candidate, fscache_cookie_discard, 1); |
|
goto out; |
|
} |
|
|
|
if (cookie == candidate) |
|
candidate = NULL; |
|
|
|
switch (cookie->type) { |
|
case FSCACHE_COOKIE_TYPE_INDEX: |
|
fscache_stat(&fscache_n_cookie_index); |
|
break; |
|
case FSCACHE_COOKIE_TYPE_DATAFILE: |
|
fscache_stat(&fscache_n_cookie_data); |
|
break; |
|
default: |
|
fscache_stat(&fscache_n_cookie_special); |
|
break; |
|
} |
|
|
|
trace_fscache_acquire(cookie); |
|
|
|
if (enable) { |
|
/* if the object is an index then we need do nothing more here |
|
* - we create indices on disk when we need them as an index |
|
* may exist in multiple caches */ |
|
if (cookie->type != FSCACHE_COOKIE_TYPE_INDEX) { |
|
if (fscache_acquire_non_index_cookie(cookie, object_size) == 0) { |
|
set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags); |
|
} else { |
|
atomic_dec(&parent->n_children); |
|
fscache_cookie_put(cookie, |
|
fscache_cookie_put_acquire_nobufs); |
|
fscache_stat(&fscache_n_acquires_nobufs); |
|
_leave(" = NULL"); |
|
return NULL; |
|
} |
|
} else { |
|
set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags); |
|
} |
|
} |
|
|
|
fscache_stat(&fscache_n_acquires_ok); |
|
|
|
out: |
|
fscache_free_cookie(candidate); |
|
return cookie; |
|
} |
|
EXPORT_SYMBOL(__fscache_acquire_cookie); |
|
|
|
/* |
|
* Enable a cookie to permit it to accept new operations. |
|
*/ |
|
void __fscache_enable_cookie(struct fscache_cookie *cookie, |
|
const void *aux_data, |
|
loff_t object_size, |
|
bool (*can_enable)(void *data), |
|
void *data) |
|
{ |
|
_enter("%p", cookie); |
|
|
|
trace_fscache_enable(cookie); |
|
|
|
wait_on_bit_lock(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK, |
|
TASK_UNINTERRUPTIBLE); |
|
|
|
fscache_update_aux(cookie, aux_data); |
|
|
|
if (test_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags)) |
|
goto out_unlock; |
|
|
|
if (can_enable && !can_enable(data)) { |
|
/* The netfs decided it didn't want to enable after all */ |
|
} else if (cookie->type != FSCACHE_COOKIE_TYPE_INDEX) { |
|
/* Wait for outstanding disablement to complete */ |
|
__fscache_wait_on_invalidate(cookie); |
|
|
|
if (fscache_acquire_non_index_cookie(cookie, object_size) == 0) |
|
set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags); |
|
} else { |
|
set_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags); |
|
} |
|
|
|
out_unlock: |
|
clear_bit_unlock(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags); |
|
wake_up_bit(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK); |
|
} |
|
EXPORT_SYMBOL(__fscache_enable_cookie); |
|
|
|
/* |
|
* acquire a non-index cookie |
|
* - this must make sure the index chain is instantiated and instantiate the |
|
* object representation too |
|
*/ |
|
static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie, |
|
loff_t object_size) |
|
{ |
|
struct fscache_object *object; |
|
struct fscache_cache *cache; |
|
int ret; |
|
|
|
_enter(""); |
|
|
|
set_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags); |
|
|
|
/* now we need to see whether the backing objects for this cookie yet |
|
* exist, if not there'll be nothing to search */ |
|
down_read(&fscache_addremove_sem); |
|
|
|
if (list_empty(&fscache_cache_list)) { |
|
up_read(&fscache_addremove_sem); |
|
_leave(" = 0 [no caches]"); |
|
return 0; |
|
} |
|
|
|
/* select a cache in which to store the object */ |
|
cache = fscache_select_cache_for_object(cookie->parent); |
|
if (!cache) { |
|
up_read(&fscache_addremove_sem); |
|
fscache_stat(&fscache_n_acquires_no_cache); |
|
_leave(" = -ENOMEDIUM [no cache]"); |
|
return -ENOMEDIUM; |
|
} |
|
|
|
_debug("cache %s", cache->tag->name); |
|
|
|
set_bit(FSCACHE_COOKIE_LOOKING_UP, &cookie->flags); |
|
|
|
/* ask the cache to allocate objects for this cookie and its parent |
|
* chain */ |
|
ret = fscache_alloc_object(cache, cookie); |
|
if (ret < 0) { |
|
up_read(&fscache_addremove_sem); |
|
_leave(" = %d", ret); |
|
return ret; |
|
} |
|
|
|
spin_lock(&cookie->lock); |
|
if (hlist_empty(&cookie->backing_objects)) { |
|
spin_unlock(&cookie->lock); |
|
goto unavailable; |
|
} |
|
|
|
object = hlist_entry(cookie->backing_objects.first, |
|
struct fscache_object, cookie_link); |
|
|
|
fscache_set_store_limit(object, object_size); |
|
|
|
/* initiate the process of looking up all the objects in the chain |
|
* (done by fscache_initialise_object()) */ |
|
fscache_raise_event(object, FSCACHE_OBJECT_EV_NEW_CHILD); |
|
|
|
spin_unlock(&cookie->lock); |
|
|
|
/* we may be required to wait for lookup to complete at this point */ |
|
if (!fscache_defer_lookup) { |
|
_debug("non-deferred lookup %p", &cookie->flags); |
|
wait_on_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP, |
|
TASK_UNINTERRUPTIBLE); |
|
_debug("complete"); |
|
if (test_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags)) |
|
goto unavailable; |
|
} |
|
|
|
up_read(&fscache_addremove_sem); |
|
_leave(" = 0 [deferred]"); |
|
return 0; |
|
|
|
unavailable: |
|
up_read(&fscache_addremove_sem); |
|
_leave(" = -ENOBUFS"); |
|
return -ENOBUFS; |
|
} |
|
|
|
/* |
|
* recursively allocate cache object records for a cookie/cache combination |
|
* - caller must be holding the addremove sem |
|
*/ |
|
static int fscache_alloc_object(struct fscache_cache *cache, |
|
struct fscache_cookie *cookie) |
|
{ |
|
struct fscache_object *object; |
|
int ret; |
|
|
|
_enter("%p,%p{%s}", cache, cookie, cookie->def->name); |
|
|
|
spin_lock(&cookie->lock); |
|
hlist_for_each_entry(object, &cookie->backing_objects, |
|
cookie_link) { |
|
if (object->cache == cache) |
|
goto object_already_extant; |
|
} |
|
spin_unlock(&cookie->lock); |
|
|
|
/* ask the cache to allocate an object (we may end up with duplicate |
|
* objects at this stage, but we sort that out later) */ |
|
fscache_stat(&fscache_n_cop_alloc_object); |
|
object = cache->ops->alloc_object(cache, cookie); |
|
fscache_stat_d(&fscache_n_cop_alloc_object); |
|
if (IS_ERR(object)) { |
|
fscache_stat(&fscache_n_object_no_alloc); |
|
ret = PTR_ERR(object); |
|
goto error; |
|
} |
|
|
|
ASSERTCMP(object->cookie, ==, cookie); |
|
fscache_stat(&fscache_n_object_alloc); |
|
|
|
object->debug_id = atomic_inc_return(&fscache_object_debug_id); |
|
|
|
_debug("ALLOC OBJ%x: %s {%lx}", |
|
object->debug_id, cookie->def->name, object->events); |
|
|
|
ret = fscache_alloc_object(cache, cookie->parent); |
|
if (ret < 0) |
|
goto error_put; |
|
|
|
/* only attach if we managed to allocate all we needed, otherwise |
|
* discard the object we just allocated and instead use the one |
|
* attached to the cookie */ |
|
if (fscache_attach_object(cookie, object) < 0) { |
|
fscache_stat(&fscache_n_cop_put_object); |
|
cache->ops->put_object(object, fscache_obj_put_attach_fail); |
|
fscache_stat_d(&fscache_n_cop_put_object); |
|
} |
|
|
|
_leave(" = 0"); |
|
return 0; |
|
|
|
object_already_extant: |
|
ret = -ENOBUFS; |
|
if (fscache_object_is_dying(object) || |
|
fscache_cache_is_broken(object)) { |
|
spin_unlock(&cookie->lock); |
|
goto error; |
|
} |
|
spin_unlock(&cookie->lock); |
|
_leave(" = 0 [found]"); |
|
return 0; |
|
|
|
error_put: |
|
fscache_stat(&fscache_n_cop_put_object); |
|
cache->ops->put_object(object, fscache_obj_put_alloc_fail); |
|
fscache_stat_d(&fscache_n_cop_put_object); |
|
error: |
|
_leave(" = %d", ret); |
|
return ret; |
|
} |
|
|
|
/* |
|
* attach a cache object to a cookie |
|
*/ |
|
static int fscache_attach_object(struct fscache_cookie *cookie, |
|
struct fscache_object *object) |
|
{ |
|
struct fscache_object *p; |
|
struct fscache_cache *cache = object->cache; |
|
int ret; |
|
|
|
_enter("{%s},{OBJ%x}", cookie->def->name, object->debug_id); |
|
|
|
ASSERTCMP(object->cookie, ==, cookie); |
|
|
|
spin_lock(&cookie->lock); |
|
|
|
/* there may be multiple initial creations of this object, but we only |
|
* want one */ |
|
ret = -EEXIST; |
|
hlist_for_each_entry(p, &cookie->backing_objects, cookie_link) { |
|
if (p->cache == object->cache) { |
|
if (fscache_object_is_dying(p)) |
|
ret = -ENOBUFS; |
|
goto cant_attach_object; |
|
} |
|
} |
|
|
|
/* pin the parent object */ |
|
spin_lock_nested(&cookie->parent->lock, 1); |
|
hlist_for_each_entry(p, &cookie->parent->backing_objects, |
|
cookie_link) { |
|
if (p->cache == object->cache) { |
|
if (fscache_object_is_dying(p)) { |
|
ret = -ENOBUFS; |
|
spin_unlock(&cookie->parent->lock); |
|
goto cant_attach_object; |
|
} |
|
object->parent = p; |
|
spin_lock(&p->lock); |
|
p->n_children++; |
|
spin_unlock(&p->lock); |
|
break; |
|
} |
|
} |
|
spin_unlock(&cookie->parent->lock); |
|
|
|
/* attach to the cache's object list */ |
|
if (list_empty(&object->cache_link)) { |
|
spin_lock(&cache->object_list_lock); |
|
list_add(&object->cache_link, &cache->object_list); |
|
spin_unlock(&cache->object_list_lock); |
|
} |
|
|
|
/* Attach to the cookie. The object already has a ref on it. */ |
|
hlist_add_head(&object->cookie_link, &cookie->backing_objects); |
|
|
|
fscache_objlist_add(object); |
|
ret = 0; |
|
|
|
cant_attach_object: |
|
spin_unlock(&cookie->lock); |
|
_leave(" = %d", ret); |
|
return ret; |
|
} |
|
|
|
/* |
|
* Invalidate an object. Callable with spinlocks held. |
|
*/ |
|
void __fscache_invalidate(struct fscache_cookie *cookie) |
|
{ |
|
struct fscache_object *object; |
|
|
|
_enter("{%s}", cookie->def->name); |
|
|
|
fscache_stat(&fscache_n_invalidates); |
|
|
|
/* Only permit invalidation of data files. Invalidating an index will |
|
* require the caller to release all its attachments to the tree rooted |
|
* there, and if it's doing that, it may as well just retire the |
|
* cookie. |
|
*/ |
|
ASSERTCMP(cookie->type, ==, FSCACHE_COOKIE_TYPE_DATAFILE); |
|
|
|
/* If there's an object, we tell the object state machine to handle the |
|
* invalidation on our behalf, otherwise there's nothing to do. |
|
*/ |
|
if (!hlist_empty(&cookie->backing_objects)) { |
|
spin_lock(&cookie->lock); |
|
|
|
if (fscache_cookie_enabled(cookie) && |
|
!hlist_empty(&cookie->backing_objects) && |
|
!test_and_set_bit(FSCACHE_COOKIE_INVALIDATING, |
|
&cookie->flags)) { |
|
object = hlist_entry(cookie->backing_objects.first, |
|
struct fscache_object, |
|
cookie_link); |
|
if (fscache_object_is_live(object)) |
|
fscache_raise_event( |
|
object, FSCACHE_OBJECT_EV_INVALIDATE); |
|
} |
|
|
|
spin_unlock(&cookie->lock); |
|
} |
|
|
|
_leave(""); |
|
} |
|
EXPORT_SYMBOL(__fscache_invalidate); |
|
|
|
/* |
|
* Wait for object invalidation to complete. |
|
*/ |
|
void __fscache_wait_on_invalidate(struct fscache_cookie *cookie) |
|
{ |
|
_enter("%p", cookie); |
|
|
|
wait_on_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING, |
|
TASK_UNINTERRUPTIBLE); |
|
|
|
_leave(""); |
|
} |
|
EXPORT_SYMBOL(__fscache_wait_on_invalidate); |
|
|
|
/* |
|
* update the index entries backing a cookie |
|
*/ |
|
void __fscache_update_cookie(struct fscache_cookie *cookie, const void *aux_data) |
|
{ |
|
struct fscache_object *object; |
|
|
|
fscache_stat(&fscache_n_updates); |
|
|
|
if (!cookie) { |
|
fscache_stat(&fscache_n_updates_null); |
|
_leave(" [no cookie]"); |
|
return; |
|
} |
|
|
|
_enter("{%s}", cookie->def->name); |
|
|
|
spin_lock(&cookie->lock); |
|
|
|
fscache_update_aux(cookie, aux_data); |
|
|
|
if (fscache_cookie_enabled(cookie)) { |
|
/* update the index entry on disk in each cache backing this |
|
* cookie. |
|
*/ |
|
hlist_for_each_entry(object, |
|
&cookie->backing_objects, cookie_link) { |
|
fscache_raise_event(object, FSCACHE_OBJECT_EV_UPDATE); |
|
} |
|
} |
|
|
|
spin_unlock(&cookie->lock); |
|
_leave(""); |
|
} |
|
EXPORT_SYMBOL(__fscache_update_cookie); |
|
|
|
/* |
|
* Disable a cookie to stop it from accepting new requests from the netfs. |
|
*/ |
|
void __fscache_disable_cookie(struct fscache_cookie *cookie, |
|
const void *aux_data, |
|
bool invalidate) |
|
{ |
|
struct fscache_object *object; |
|
bool awaken = false; |
|
|
|
_enter("%p,%u", cookie, invalidate); |
|
|
|
trace_fscache_disable(cookie); |
|
|
|
ASSERTCMP(atomic_read(&cookie->n_active), >, 0); |
|
|
|
if (atomic_read(&cookie->n_children) != 0) { |
|
pr_err("Cookie '%s' still has children\n", |
|
cookie->def->name); |
|
BUG(); |
|
} |
|
|
|
wait_on_bit_lock(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK, |
|
TASK_UNINTERRUPTIBLE); |
|
|
|
fscache_update_aux(cookie, aux_data); |
|
|
|
if (!test_and_clear_bit(FSCACHE_COOKIE_ENABLED, &cookie->flags)) |
|
goto out_unlock_enable; |
|
|
|
/* If the cookie is being invalidated, wait for that to complete first |
|
* so that we can reuse the flag. |
|
*/ |
|
__fscache_wait_on_invalidate(cookie); |
|
|
|
/* Dispose of the backing objects */ |
|
set_bit(FSCACHE_COOKIE_INVALIDATING, &cookie->flags); |
|
|
|
spin_lock(&cookie->lock); |
|
if (!hlist_empty(&cookie->backing_objects)) { |
|
hlist_for_each_entry(object, &cookie->backing_objects, cookie_link) { |
|
if (invalidate) |
|
set_bit(FSCACHE_OBJECT_RETIRED, &object->flags); |
|
clear_bit(FSCACHE_OBJECT_PENDING_WRITE, &object->flags); |
|
fscache_raise_event(object, FSCACHE_OBJECT_EV_KILL); |
|
} |
|
} else { |
|
if (test_and_clear_bit(FSCACHE_COOKIE_INVALIDATING, &cookie->flags)) |
|
awaken = true; |
|
} |
|
spin_unlock(&cookie->lock); |
|
if (awaken) |
|
wake_up_bit(&cookie->flags, FSCACHE_COOKIE_INVALIDATING); |
|
|
|
/* Wait for cessation of activity requiring access to the netfs (when |
|
* n_active reaches 0). This makes sure outstanding reads and writes |
|
* have completed. |
|
*/ |
|
if (!atomic_dec_and_test(&cookie->n_active)) { |
|
wait_var_event(&cookie->n_active, |
|
!atomic_read(&cookie->n_active)); |
|
} |
|
|
|
/* Make sure any pending writes are cancelled. */ |
|
if (cookie->type != FSCACHE_COOKIE_TYPE_INDEX) |
|
fscache_invalidate_writes(cookie); |
|
|
|
/* Reset the cookie state if it wasn't relinquished */ |
|
if (!test_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags)) { |
|
atomic_inc(&cookie->n_active); |
|
set_bit(FSCACHE_COOKIE_NO_DATA_YET, &cookie->flags); |
|
} |
|
|
|
out_unlock_enable: |
|
clear_bit_unlock(FSCACHE_COOKIE_ENABLEMENT_LOCK, &cookie->flags); |
|
wake_up_bit(&cookie->flags, FSCACHE_COOKIE_ENABLEMENT_LOCK); |
|
_leave(""); |
|
} |
|
EXPORT_SYMBOL(__fscache_disable_cookie); |
|
|
|
/* |
|
* release a cookie back to the cache |
|
* - the object will be marked as recyclable on disk if retire is true |
|
* - all dependents of this cookie must have already been unregistered |
|
* (indices/files/pages) |
|
*/ |
|
void __fscache_relinquish_cookie(struct fscache_cookie *cookie, |
|
const void *aux_data, |
|
bool retire) |
|
{ |
|
fscache_stat(&fscache_n_relinquishes); |
|
if (retire) |
|
fscache_stat(&fscache_n_relinquishes_retire); |
|
|
|
if (!cookie) { |
|
fscache_stat(&fscache_n_relinquishes_null); |
|
_leave(" [no cookie]"); |
|
return; |
|
} |
|
|
|
_enter("%p{%s,%p,%d},%d", |
|
cookie, cookie->def->name, cookie->netfs_data, |
|
atomic_read(&cookie->n_active), retire); |
|
|
|
trace_fscache_relinquish(cookie, retire); |
|
|
|
/* No further netfs-accessing operations on this cookie permitted */ |
|
if (test_and_set_bit(FSCACHE_COOKIE_RELINQUISHED, &cookie->flags)) |
|
BUG(); |
|
|
|
__fscache_disable_cookie(cookie, aux_data, retire); |
|
|
|
/* Clear pointers back to the netfs */ |
|
cookie->netfs_data = NULL; |
|
cookie->def = NULL; |
|
BUG_ON(!radix_tree_empty(&cookie->stores)); |
|
|
|
if (cookie->parent) { |
|
ASSERTCMP(atomic_read(&cookie->parent->usage), >, 0); |
|
ASSERTCMP(atomic_read(&cookie->parent->n_children), >, 0); |
|
atomic_dec(&cookie->parent->n_children); |
|
} |
|
|
|
/* Dispose of the netfs's link to the cookie */ |
|
ASSERTCMP(atomic_read(&cookie->usage), >, 0); |
|
fscache_cookie_put(cookie, fscache_cookie_put_relinquish); |
|
|
|
_leave(""); |
|
} |
|
EXPORT_SYMBOL(__fscache_relinquish_cookie); |
|
|
|
/* |
|
* Remove a cookie from the hash table. |
|
*/ |
|
static void fscache_unhash_cookie(struct fscache_cookie *cookie) |
|
{ |
|
struct hlist_bl_head *h; |
|
unsigned int bucket; |
|
|
|
bucket = cookie->key_hash & (ARRAY_SIZE(fscache_cookie_hash) - 1); |
|
h = &fscache_cookie_hash[bucket]; |
|
|
|
hlist_bl_lock(h); |
|
hlist_bl_del(&cookie->hash_link); |
|
hlist_bl_unlock(h); |
|
} |
|
|
|
/* |
|
* Drop a reference to a cookie. |
|
*/ |
|
void fscache_cookie_put(struct fscache_cookie *cookie, |
|
enum fscache_cookie_trace where) |
|
{ |
|
struct fscache_cookie *parent; |
|
int usage; |
|
|
|
_enter("%p", cookie); |
|
|
|
do { |
|
usage = atomic_dec_return(&cookie->usage); |
|
trace_fscache_cookie(cookie, where, usage); |
|
|
|
if (usage > 0) |
|
return; |
|
BUG_ON(usage < 0); |
|
|
|
parent = cookie->parent; |
|
fscache_unhash_cookie(cookie); |
|
fscache_free_cookie(cookie); |
|
|
|
cookie = parent; |
|
where = fscache_cookie_put_parent; |
|
} while (cookie); |
|
|
|
_leave(""); |
|
} |
|
|
|
/* |
|
* check the consistency between the netfs inode and the backing cache |
|
* |
|
* NOTE: it only serves no-index type |
|
*/ |
|
int __fscache_check_consistency(struct fscache_cookie *cookie, |
|
const void *aux_data) |
|
{ |
|
struct fscache_operation *op; |
|
struct fscache_object *object; |
|
bool wake_cookie = false; |
|
int ret; |
|
|
|
_enter("%p,", cookie); |
|
|
|
ASSERTCMP(cookie->type, ==, FSCACHE_COOKIE_TYPE_DATAFILE); |
|
|
|
if (fscache_wait_for_deferred_lookup(cookie) < 0) |
|
return -ERESTARTSYS; |
|
|
|
if (hlist_empty(&cookie->backing_objects)) |
|
return 0; |
|
|
|
op = kzalloc(sizeof(*op), GFP_NOIO | __GFP_NOMEMALLOC | __GFP_NORETRY); |
|
if (!op) |
|
return -ENOMEM; |
|
|
|
fscache_operation_init(cookie, op, NULL, NULL, NULL); |
|
op->flags = FSCACHE_OP_MYTHREAD | |
|
(1 << FSCACHE_OP_WAITING) | |
|
(1 << FSCACHE_OP_UNUSE_COOKIE); |
|
trace_fscache_page_op(cookie, NULL, op, fscache_page_op_check_consistency); |
|
|
|
spin_lock(&cookie->lock); |
|
|
|
fscache_update_aux(cookie, aux_data); |
|
|
|
if (!fscache_cookie_enabled(cookie) || |
|
hlist_empty(&cookie->backing_objects)) |
|
goto inconsistent; |
|
object = hlist_entry(cookie->backing_objects.first, |
|
struct fscache_object, cookie_link); |
|
if (test_bit(FSCACHE_IOERROR, &object->cache->flags)) |
|
goto inconsistent; |
|
|
|
op->debug_id = atomic_inc_return(&fscache_op_debug_id); |
|
|
|
__fscache_use_cookie(cookie); |
|
if (fscache_submit_op(object, op) < 0) |
|
goto submit_failed; |
|
|
|
/* the work queue now carries its own ref on the object */ |
|
spin_unlock(&cookie->lock); |
|
|
|
ret = fscache_wait_for_operation_activation(object, op, NULL, NULL); |
|
if (ret == 0) { |
|
/* ask the cache to honour the operation */ |
|
ret = object->cache->ops->check_consistency(op); |
|
fscache_op_complete(op, false); |
|
} else if (ret == -ENOBUFS) { |
|
ret = 0; |
|
} |
|
|
|
fscache_put_operation(op); |
|
_leave(" = %d", ret); |
|
return ret; |
|
|
|
submit_failed: |
|
wake_cookie = __fscache_unuse_cookie(cookie); |
|
inconsistent: |
|
spin_unlock(&cookie->lock); |
|
if (wake_cookie) |
|
__fscache_wake_unused_cookie(cookie); |
|
kfree(op); |
|
_leave(" = -ESTALE"); |
|
return -ESTALE; |
|
} |
|
EXPORT_SYMBOL(__fscache_check_consistency);
|
|
|