PageRenderTime 40ms CodeModel.GetById 19ms app.highlight 17ms RepoModel.GetById 0ms app.codeStats 0ms

/fs/fscache/cookie.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 514 lines | 333 code | 92 blank | 89 comment | 39 complexity | 45c8c51d2d996040880d1bcfa0be7c08 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
  1/* netfs cookie management
  2 *
  3 * Copyright (C) 2004-2007 Red Hat, Inc. All Rights Reserved.
  4 * Written by David Howells (dhowells@redhat.com)
  5 *
  6 * This program is free software; you can redistribute it and/or
  7 * modify it under the terms of the GNU General Public License
  8 * as published by the Free Software Foundation; either version
  9 * 2 of the License, or (at your option) any later version.
 10 *
 11 * See Documentation/filesystems/caching/netfs-api.txt for more information on
 12 * the netfs API.
 13 */
 14
 15#define FSCACHE_DEBUG_LEVEL COOKIE
 16#include <linux/module.h>
 17#include <linux/slab.h>
 18#include "internal.h"
 19
 20struct kmem_cache *fscache_cookie_jar;
 21
 22static atomic_t fscache_object_debug_id = ATOMIC_INIT(0);
 23
 24static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie);
 25static int fscache_alloc_object(struct fscache_cache *cache,
 26				struct fscache_cookie *cookie);
 27static int fscache_attach_object(struct fscache_cookie *cookie,
 28				 struct fscache_object *object);
 29
 30/*
 31 * initialise an cookie jar slab element prior to any use
 32 */
 33void fscache_cookie_init_once(void *_cookie)
 34{
 35	struct fscache_cookie *cookie = _cookie;
 36
 37	memset(cookie, 0, sizeof(*cookie));
 38	spin_lock_init(&cookie->lock);
 39	spin_lock_init(&cookie->stores_lock);
 40	INIT_HLIST_HEAD(&cookie->backing_objects);
 41}
 42
 43/*
 44 * request a cookie to represent an object (index, datafile, xattr, etc)
 45 * - parent specifies the parent object
 46 *   - the top level index cookie for each netfs is stored in the fscache_netfs
 47 *     struct upon registration
 48 * - def points to the definition
 49 * - the netfs_data will be passed to the functions pointed to in *def
 50 * - all attached caches will be searched to see if they contain this object
 51 * - index objects aren't stored on disk until there's a dependent file that
 52 *   needs storing
 53 * - other objects are stored in a selected cache immediately, and all the
 54 *   indices forming the path to it are instantiated if necessary
 55 * - we never let on to the netfs about errors
 56 *   - we may set a negative cookie pointer, but that's okay
 57 */
 58struct fscache_cookie *__fscache_acquire_cookie(
 59	struct fscache_cookie *parent,
 60	const struct fscache_cookie_def *def,
 61	void *netfs_data)
 62{
 63	struct fscache_cookie *cookie;
 64
 65	BUG_ON(!def);
 66
 67	_enter("{%s},{%s},%p",
 68	       parent ? (char *) parent->def->name : "<no-parent>",
 69	       def->name, netfs_data);
 70
 71	fscache_stat(&fscache_n_acquires);
 72
 73	/* if there's no parent cookie, then we don't create one here either */
 74	if (!parent) {
 75		fscache_stat(&fscache_n_acquires_null);
 76		_leave(" [no parent]");
 77		return NULL;
 78	}
 79
 80	/* validate the definition */
 81	BUG_ON(!def->get_key);
 82	BUG_ON(!def->name[0]);
 83
 84	BUG_ON(def->type == FSCACHE_COOKIE_TYPE_INDEX &&
 85	       parent->def->type != FSCACHE_COOKIE_TYPE_INDEX);
 86
 87	/* allocate and initialise a cookie */
 88	cookie = kmem_cache_alloc(fscache_cookie_jar, GFP_KERNEL);
 89	if (!cookie) {
 90		fscache_stat(&fscache_n_acquires_oom);
 91		_leave(" [ENOMEM]");
 92		return NULL;
 93	}
 94
 95	atomic_set(&cookie->usage, 1);
 96	atomic_set(&cookie->n_children, 0);
 97
 98	atomic_inc(&parent->usage);
 99	atomic_inc(&parent->n_children);
100
101	cookie->def		= def;
102	cookie->parent		= parent;
103	cookie->netfs_data	= netfs_data;
104	cookie->flags		= 0;
105
106	/* radix tree insertion won't use the preallocation pool unless it's
107	 * told it may not wait */
108	INIT_RADIX_TREE(&cookie->stores, GFP_NOFS & ~__GFP_WAIT);
109
110	switch (cookie->def->type) {
111	case FSCACHE_COOKIE_TYPE_INDEX:
112		fscache_stat(&fscache_n_cookie_index);
113		break;
114	case FSCACHE_COOKIE_TYPE_DATAFILE:
115		fscache_stat(&fscache_n_cookie_data);
116		break;
117	default:
118		fscache_stat(&fscache_n_cookie_special);
119		break;
120	}
121
122	/* if the object is an index then we need do nothing more here - we
123	 * create indices on disk when we need them as an index may exist in
124	 * multiple caches */
125	if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) {
126		if (fscache_acquire_non_index_cookie(cookie) < 0) {
127			atomic_dec(&parent->n_children);
128			__fscache_cookie_put(cookie);
129			fscache_stat(&fscache_n_acquires_nobufs);
130			_leave(" = NULL");
131			return NULL;
132		}
133	}
134
135	fscache_stat(&fscache_n_acquires_ok);
136	_leave(" = %p", cookie);
137	return cookie;
138}
139EXPORT_SYMBOL(__fscache_acquire_cookie);
140
141/*
142 * acquire a non-index cookie
143 * - this must make sure the index chain is instantiated and instantiate the
144 *   object representation too
145 */
146static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
147{
148	struct fscache_object *object;
149	struct fscache_cache *cache;
150	uint64_t i_size;
151	int ret;
152
153	_enter("");
154
155	cookie->flags = 1 << FSCACHE_COOKIE_UNAVAILABLE;
156
157	/* now we need to see whether the backing objects for this cookie yet
158	 * exist, if not there'll be nothing to search */
159	down_read(&fscache_addremove_sem);
160
161	if (list_empty(&fscache_cache_list)) {
162		up_read(&fscache_addremove_sem);
163		_leave(" = 0 [no caches]");
164		return 0;
165	}
166
167	/* select a cache in which to store the object */
168	cache = fscache_select_cache_for_object(cookie->parent);
169	if (!cache) {
170		up_read(&fscache_addremove_sem);
171		fscache_stat(&fscache_n_acquires_no_cache);
172		_leave(" = -ENOMEDIUM [no cache]");
173		return -ENOMEDIUM;
174	}
175
176	_debug("cache %s", cache->tag->name);
177
178	cookie->flags =
179		(1 << FSCACHE_COOKIE_LOOKING_UP) |
180		(1 << FSCACHE_COOKIE_CREATING) |
181		(1 << FSCACHE_COOKIE_NO_DATA_YET);
182
183	/* ask the cache to allocate objects for this cookie and its parent
184	 * chain */
185	ret = fscache_alloc_object(cache, cookie);
186	if (ret < 0) {
187		up_read(&fscache_addremove_sem);
188		_leave(" = %d", ret);
189		return ret;
190	}
191
192	/* pass on how big the object we're caching is supposed to be */
193	cookie->def->get_attr(cookie->netfs_data, &i_size);
194
195	spin_lock(&cookie->lock);
196	if (hlist_empty(&cookie->backing_objects)) {
197		spin_unlock(&cookie->lock);
198		goto unavailable;
199	}
200
201	object = hlist_entry(cookie->backing_objects.first,
202			     struct fscache_object, cookie_link);
203
204	fscache_set_store_limit(object, i_size);
205
206	/* initiate the process of looking up all the objects in the chain
207	 * (done by fscache_initialise_object()) */
208	fscache_enqueue_object(object);
209
210	spin_unlock(&cookie->lock);
211
212	/* we may be required to wait for lookup to complete at this point */
213	if (!fscache_defer_lookup) {
214		_debug("non-deferred lookup %p", &cookie->flags);
215		wait_on_bit(&cookie->flags, FSCACHE_COOKIE_LOOKING_UP,
216			    fscache_wait_bit, TASK_UNINTERRUPTIBLE);
217		_debug("complete");
218		if (test_bit(FSCACHE_COOKIE_UNAVAILABLE, &cookie->flags))
219			goto unavailable;
220	}
221
222	up_read(&fscache_addremove_sem);
223	_leave(" = 0 [deferred]");
224	return 0;
225
226unavailable:
227	up_read(&fscache_addremove_sem);
228	_leave(" = -ENOBUFS");
229	return -ENOBUFS;
230}
231
232/*
233 * recursively allocate cache object records for a cookie/cache combination
234 * - caller must be holding the addremove sem
235 */
236static int fscache_alloc_object(struct fscache_cache *cache,
237				struct fscache_cookie *cookie)
238{
239	struct fscache_object *object;
240	struct hlist_node *_n;
241	int ret;
242
243	_enter("%p,%p{%s}", cache, cookie, cookie->def->name);
244
245	spin_lock(&cookie->lock);
246	hlist_for_each_entry(object, _n, &cookie->backing_objects,
247			     cookie_link) {
248		if (object->cache == cache)
249			goto object_already_extant;
250	}
251	spin_unlock(&cookie->lock);
252
253	/* ask the cache to allocate an object (we may end up with duplicate
254	 * objects at this stage, but we sort that out later) */
255	fscache_stat(&fscache_n_cop_alloc_object);
256	object = cache->ops->alloc_object(cache, cookie);
257	fscache_stat_d(&fscache_n_cop_alloc_object);
258	if (IS_ERR(object)) {
259		fscache_stat(&fscache_n_object_no_alloc);
260		ret = PTR_ERR(object);
261		goto error;
262	}
263
264	fscache_stat(&fscache_n_object_alloc);
265
266	object->debug_id = atomic_inc_return(&fscache_object_debug_id);
267
268	_debug("ALLOC OBJ%x: %s {%lx}",
269	       object->debug_id, cookie->def->name, object->events);
270
271	ret = fscache_alloc_object(cache, cookie->parent);
272	if (ret < 0)
273		goto error_put;
274
275	/* only attach if we managed to allocate all we needed, otherwise
276	 * discard the object we just allocated and instead use the one
277	 * attached to the cookie */
278	if (fscache_attach_object(cookie, object) < 0) {
279		fscache_stat(&fscache_n_cop_put_object);
280		cache->ops->put_object(object);
281		fscache_stat_d(&fscache_n_cop_put_object);
282	}
283
284	_leave(" = 0");
285	return 0;
286
287object_already_extant:
288	ret = -ENOBUFS;
289	if (object->state >= FSCACHE_OBJECT_DYING) {
290		spin_unlock(&cookie->lock);
291		goto error;
292	}
293	spin_unlock(&cookie->lock);
294	_leave(" = 0 [found]");
295	return 0;
296
297error_put:
298	fscache_stat(&fscache_n_cop_put_object);
299	cache->ops->put_object(object);
300	fscache_stat_d(&fscache_n_cop_put_object);
301error:
302	_leave(" = %d", ret);
303	return ret;
304}
305
306/*
307 * attach a cache object to a cookie
308 */
309static int fscache_attach_object(struct fscache_cookie *cookie,
310				 struct fscache_object *object)
311{
312	struct fscache_object *p;
313	struct fscache_cache *cache = object->cache;
314	struct hlist_node *_n;
315	int ret;
316
317	_enter("{%s},{OBJ%x}", cookie->def->name, object->debug_id);
318
319	spin_lock(&cookie->lock);
320
321	/* there may be multiple initial creations of this object, but we only
322	 * want one */
323	ret = -EEXIST;
324	hlist_for_each_entry(p, _n, &cookie->backing_objects, cookie_link) {
325		if (p->cache == object->cache) {
326			if (p->state >= FSCACHE_OBJECT_DYING)
327				ret = -ENOBUFS;
328			goto cant_attach_object;
329		}
330	}
331
332	/* pin the parent object */
333	spin_lock_nested(&cookie->parent->lock, 1);
334	hlist_for_each_entry(p, _n, &cookie->parent->backing_objects,
335			     cookie_link) {
336		if (p->cache == object->cache) {
337			if (p->state >= FSCACHE_OBJECT_DYING) {
338				ret = -ENOBUFS;
339				spin_unlock(&cookie->parent->lock);
340				goto cant_attach_object;
341			}
342			object->parent = p;
343			spin_lock(&p->lock);
344			p->n_children++;
345			spin_unlock(&p->lock);
346			break;
347		}
348	}
349	spin_unlock(&cookie->parent->lock);
350
351	/* attach to the cache's object list */
352	if (list_empty(&object->cache_link)) {
353		spin_lock(&cache->object_list_lock);
354		list_add(&object->cache_link, &cache->object_list);
355		spin_unlock(&cache->object_list_lock);
356	}
357
358	/* attach to the cookie */
359	object->cookie = cookie;
360	atomic_inc(&cookie->usage);
361	hlist_add_head(&object->cookie_link, &cookie->backing_objects);
362
363	fscache_objlist_add(object);
364	ret = 0;
365
366cant_attach_object:
367	spin_unlock(&cookie->lock);
368	_leave(" = %d", ret);
369	return ret;
370}
371
372/*
373 * update the index entries backing a cookie
374 */
375void __fscache_update_cookie(struct fscache_cookie *cookie)
376{
377	struct fscache_object *object;
378	struct hlist_node *_p;
379
380	fscache_stat(&fscache_n_updates);
381
382	if (!cookie) {
383		fscache_stat(&fscache_n_updates_null);
384		_leave(" [no cookie]");
385		return;
386	}
387
388	_enter("{%s}", cookie->def->name);
389
390	BUG_ON(!cookie->def->get_aux);
391
392	spin_lock(&cookie->lock);
393
394	/* update the index entry on disk in each cache backing this cookie */
395	hlist_for_each_entry(object, _p,
396			     &cookie->backing_objects, cookie_link) {
397		fscache_raise_event(object, FSCACHE_OBJECT_EV_UPDATE);
398	}
399
400	spin_unlock(&cookie->lock);
401	_leave("");
402}
403EXPORT_SYMBOL(__fscache_update_cookie);
404
405/*
406 * release a cookie back to the cache
407 * - the object will be marked as recyclable on disk if retire is true
408 * - all dependents of this cookie must have already been unregistered
409 *   (indices/files/pages)
410 */
411void __fscache_relinquish_cookie(struct fscache_cookie *cookie, int retire)
412{
413	struct fscache_cache *cache;
414	struct fscache_object *object;
415	unsigned long event;
416
417	fscache_stat(&fscache_n_relinquishes);
418	if (retire)
419		fscache_stat(&fscache_n_relinquishes_retire);
420
421	if (!cookie) {
422		fscache_stat(&fscache_n_relinquishes_null);
423		_leave(" [no cookie]");
424		return;
425	}
426
427	_enter("%p{%s,%p},%d",
428	       cookie, cookie->def->name, cookie->netfs_data, retire);
429
430	if (atomic_read(&cookie->n_children) != 0) {
431		printk(KERN_ERR "FS-Cache: Cookie '%s' still has children\n",
432		       cookie->def->name);
433		BUG();
434	}
435
436	/* wait for the cookie to finish being instantiated (or to fail) */
437	if (test_bit(FSCACHE_COOKIE_CREATING, &cookie->flags)) {
438		fscache_stat(&fscache_n_relinquishes_waitcrt);
439		wait_on_bit(&cookie->flags, FSCACHE_COOKIE_CREATING,
440			    fscache_wait_bit, TASK_UNINTERRUPTIBLE);
441	}
442
443	event = retire ? FSCACHE_OBJECT_EV_RETIRE : FSCACHE_OBJECT_EV_RELEASE;
444
445	spin_lock(&cookie->lock);
446
447	/* break links with all the active objects */
448	while (!hlist_empty(&cookie->backing_objects)) {
449		object = hlist_entry(cookie->backing_objects.first,
450				     struct fscache_object,
451				     cookie_link);
452
453		_debug("RELEASE OBJ%x", object->debug_id);
454
455		/* detach each cache object from the object cookie */
456		spin_lock(&object->lock);
457		hlist_del_init(&object->cookie_link);
458
459		cache = object->cache;
460		object->cookie = NULL;
461		fscache_raise_event(object, event);
462		spin_unlock(&object->lock);
463
464		if (atomic_dec_and_test(&cookie->usage))
465			/* the cookie refcount shouldn't be reduced to 0 yet */
466			BUG();
467	}
468
469	/* detach pointers back to the netfs */
470	cookie->netfs_data	= NULL;
471	cookie->def		= NULL;
472
473	spin_unlock(&cookie->lock);
474
475	if (cookie->parent) {
476		ASSERTCMP(atomic_read(&cookie->parent->usage), >, 0);
477		ASSERTCMP(atomic_read(&cookie->parent->n_children), >, 0);
478		atomic_dec(&cookie->parent->n_children);
479	}
480
481	/* finally dispose of the cookie */
482	ASSERTCMP(atomic_read(&cookie->usage), >, 0);
483	fscache_cookie_put(cookie);
484
485	_leave("");
486}
487EXPORT_SYMBOL(__fscache_relinquish_cookie);
488
489/*
490 * destroy a cookie
491 */
492void __fscache_cookie_put(struct fscache_cookie *cookie)
493{
494	struct fscache_cookie *parent;
495
496	_enter("%p", cookie);
497
498	for (;;) {
499		_debug("FREE COOKIE %p", cookie);
500		parent = cookie->parent;
501		BUG_ON(!hlist_empty(&cookie->backing_objects));
502		kmem_cache_free(fscache_cookie_jar, cookie);
503
504		if (!parent)
505			break;
506
507		cookie = parent;
508		BUG_ON(atomic_read(&cookie->usage) <= 0);
509		if (!atomic_dec_and_test(&cookie->usage))
510			break;
511	}
512
513	_leave("");
514}