fs/fscache/cache.c - kernel/msm-4.9 - Gitiles

 /* FS-Cache cache handling
  *
  * Copyright (C) 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 <linux/slab.h>
 #include "internal.h"

 LIST_HEAD(fscache_cache_list);
 DECLARE_RWSEM(fscache_addremove_sem);
 DECLARE_WAIT_QUEUE_HEAD(fscache_cache_cleared_wq);
 EXPORT_SYMBOL(fscache_cache_cleared_wq);

 static LIST_HEAD(fscache_cache_tag_list);

 /*
  * look up a cache tag
  */
 struct fscache_cache_tag *__fscache_lookup_cache_tag(const char *name)
 {
 	struct fscache_cache_tag *tag, *xtag;

 	/* firstly check for the existence of the tag under read lock */
 	down_read(&fscache_addremove_sem);

 	list_for_each_entry(tag, &fscache_cache_tag_list, link) {
 		if (strcmp(tag->name, name) == 0) {
 			atomic_inc(&tag->usage);
 			up_read(&fscache_addremove_sem);
 			return tag;
 		}
 	}

 	up_read(&fscache_addremove_sem);

 	/* the tag does not exist - create a candidate */
 	xtag = kzalloc(sizeof(*xtag) + strlen(name) + 1, GFP_KERNEL);
 	if (!xtag)
 		/* return a dummy tag if out of memory */
 		return ERR_PTR(-ENOMEM);

 	atomic_set(&xtag->usage, 1);
 	strcpy(xtag->name, name);

 	/* write lock, search again and add if still not present */
 	down_write(&fscache_addremove_sem);

 	list_for_each_entry(tag, &fscache_cache_tag_list, link) {
 		if (strcmp(tag->name, name) == 0) {
 			atomic_inc(&tag->usage);
 			up_write(&fscache_addremove_sem);
 			kfree(xtag);
 			return tag;
 		}
 	}

 	list_add_tail(&xtag->link, &fscache_cache_tag_list);
 	up_write(&fscache_addremove_sem);
 	return xtag;
 }

 /*
  * release a reference to a cache tag
  */
 void __fscache_release_cache_tag(struct fscache_cache_tag *tag)
 {
 	if (tag != ERR_PTR(-ENOMEM)) {
 		down_write(&fscache_addremove_sem);

 		if (atomic_dec_and_test(&tag->usage))
 			list_del_init(&tag->link);
 		else
 			tag = NULL;

 		up_write(&fscache_addremove_sem);

 		kfree(tag);
 	}
 }

 /*
  * select a cache in which to store an object
  * - the cache addremove semaphore must be at least read-locked by the caller
  * - the object will never be an index
  */
 struct fscache_cache *fscache_select_cache_for_object(
 	struct fscache_cookie *cookie)
 {
 	struct fscache_cache_tag *tag;
 	struct fscache_object *object;
 	struct fscache_cache *cache;

 	_enter("");

 	if (list_empty(&fscache_cache_list)) {
 		_leave(" = NULL [no cache]");
 		return NULL;
 	}

 	/* we check the parent to determine the cache to use */
 	spin_lock(&cookie->lock);

 	/* the first in the parent's backing list should be the preferred
 	 * cache */
 	if (!hlist_empty(&cookie->backing_objects)) {
 		object = hlist_entry(cookie->backing_objects.first,
 				     struct fscache_object, cookie_link);

 		cache = object->cache;
 		if (object->state >= FSCACHE_OBJECT_DYING ||
 		    test_bit(FSCACHE_IOERROR, &cache->flags))
 			cache = NULL;

 		spin_unlock(&cookie->lock);
 		_leave(" = %p [parent]", cache);
 		return cache;
 	}

 	/* the parent is unbacked */
 	if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) {
 		/* cookie not an index and is unbacked */
 		spin_unlock(&cookie->lock);
 		_leave(" = NULL [cookie ub,ni]");
 		return NULL;
 	}

 	spin_unlock(&cookie->lock);

 	if (!cookie->def->select_cache)
 		goto no_preference;

 	/* ask the netfs for its preference */
 	tag = cookie->def->select_cache(cookie->parent->netfs_data,
 					cookie->netfs_data);
 	if (!tag)
 		goto no_preference;

 	if (tag == ERR_PTR(-ENOMEM)) {
 		_leave(" = NULL [nomem tag]");
 		return NULL;
 	}

 	if (!tag->cache) {
 		_leave(" = NULL [unbacked tag]");
 		return NULL;
 	}

 	if (test_bit(FSCACHE_IOERROR, &tag->cache->flags))
 		return NULL;

 	_leave(" = %p [specific]", tag->cache);
 	return tag->cache;

 no_preference:
 	/* netfs has no preference - just select first cache */
 	cache = list_entry(fscache_cache_list.next,
 			   struct fscache_cache, link);
 	_leave(" = %p [first]", cache);
 	return cache;
 }

 /**
  * fscache_init_cache - Initialise a cache record
  * @cache: The cache record to be initialised
  * @ops: The cache operations to be installed in that record
  * @idfmt: Format string to define identifier
  * @...: sprintf-style arguments
  *
  * Initialise a record of a cache and fill in the name.
  *
  * See Documentation/filesystems/caching/backend-api.txt for a complete
  * description.
  */
 void fscache_init_cache(struct fscache_cache *cache,
 			const struct fscache_cache_ops *ops,
 			const char *idfmt,
 			...)
 {
 	va_list va;

 	memset(cache, 0, sizeof(*cache));

 	cache->ops = ops;

 	va_start(va, idfmt);
 	vsnprintf(cache->identifier, sizeof(cache->identifier), idfmt, va);
 	va_end(va);

 	INIT_WORK(&cache->op_gc, fscache_operation_gc);
 	INIT_LIST_HEAD(&cache->link);
 	INIT_LIST_HEAD(&cache->object_list);
 	INIT_LIST_HEAD(&cache->op_gc_list);
 	spin_lock_init(&cache->object_list_lock);
 	spin_lock_init(&cache->op_gc_list_lock);
 }
 EXPORT_SYMBOL(fscache_init_cache);

 /**
  * fscache_add_cache - Declare a cache as being open for business
  * @cache: The record describing the cache
  * @ifsdef: The record of the cache object describing the top-level index
  * @tagname: The tag describing this cache
  *
  * Add a cache to the system, making it available for netfs's to use.
  *
  * See Documentation/filesystems/caching/backend-api.txt for a complete
  * description.
  */
 int fscache_add_cache(struct fscache_cache *cache,
 		      struct fscache_object *ifsdef,
 		      const char *tagname)
 {
 	struct fscache_cache_tag *tag;

 	BUG_ON(!cache->ops);
 	BUG_ON(!ifsdef);

 	cache->flags = 0;
 	ifsdef->event_mask = ULONG_MAX & ~(1 << FSCACHE_OBJECT_EV_CLEARED);
 	ifsdef->state = FSCACHE_OBJECT_ACTIVE;

 	if (!tagname)
 		tagname = cache->identifier;

 	BUG_ON(!tagname[0]);

 	_enter("{%s.%s},,%s", cache->ops->name, cache->identifier, tagname);

 	/* we use the cache tag to uniquely identify caches */
 	tag = __fscache_lookup_cache_tag(tagname);
 	if (IS_ERR(tag))
 		goto nomem;

 	if (test_and_set_bit(FSCACHE_TAG_RESERVED, &tag->flags))
 		goto tag_in_use;

 	cache->kobj = kobject_create_and_add(tagname, fscache_root);
 	if (!cache->kobj)
 		goto error;

 	ifsdef->cookie = &fscache_fsdef_index;
 	ifsdef->cache = cache;
 	cache->fsdef = ifsdef;

 	down_write(&fscache_addremove_sem);

 	tag->cache = cache;
 	cache->tag = tag;

 	/* add the cache to the list */
 	list_add(&cache->link, &fscache_cache_list);

 	/* add the cache's netfs definition index object to the cache's
 	 * list */
 	spin_lock(&cache->object_list_lock);
 	list_add_tail(&ifsdef->cache_link, &cache->object_list);
 	spin_unlock(&cache->object_list_lock);
 	fscache_objlist_add(ifsdef);

 	/* add the cache's netfs definition index object to the top level index
 	 * cookie as a known backing object */
 	spin_lock(&fscache_fsdef_index.lock);

 	hlist_add_head(&ifsdef->cookie_link,
 		       &fscache_fsdef_index.backing_objects);

 	atomic_inc(&fscache_fsdef_index.usage);

 	/* done */
 	spin_unlock(&fscache_fsdef_index.lock);
 	up_write(&fscache_addremove_sem);

 	printk(KERN_NOTICE "FS-Cache: Cache \"%s\" added (type %s)\n",
 	       cache->tag->name, cache->ops->name);
 	kobject_uevent(cache->kobj, KOBJ_ADD);

 	_leave(" = 0 [%s]", cache->identifier);
 	return 0;

 tag_in_use:
 	printk(KERN_ERR "FS-Cache: Cache tag '%s' already in use\n", tagname);
 	__fscache_release_cache_tag(tag);
 	_leave(" = -EXIST");
 	return -EEXIST;

 error:
 	__fscache_release_cache_tag(tag);
 	_leave(" = -EINVAL");
 	return -EINVAL;

 nomem:
 	_leave(" = -ENOMEM");
 	return -ENOMEM;
 }
 EXPORT_SYMBOL(fscache_add_cache);

 /**
  * fscache_io_error - Note a cache I/O error
  * @cache: The record describing the cache
  *
  * Note that an I/O error occurred in a cache and that it should no longer be
  * used for anything.  This also reports the error into the kernel log.
  *
  * See Documentation/filesystems/caching/backend-api.txt for a complete
  * description.
  */
 void fscache_io_error(struct fscache_cache *cache)
 {
 	set_bit(FSCACHE_IOERROR, &cache->flags);

 	printk(KERN_ERR "FS-Cache: Cache %s stopped due to I/O error\n",
 	       cache->ops->name);
 }
 EXPORT_SYMBOL(fscache_io_error);

 /*
  * request withdrawal of all the objects in a cache
  * - all the objects being withdrawn are moved onto the supplied list
  */
 static void fscache_withdraw_all_objects(struct fscache_cache *cache,
 					 struct list_head *dying_objects)
 {
 	struct fscache_object *object;

 	spin_lock(&cache->object_list_lock);

 	while (!list_empty(&cache->object_list)) {
 		object = list_entry(cache->object_list.next,
 				    struct fscache_object, cache_link);
 		list_move_tail(&object->cache_link, dying_objects);

 		_debug("withdraw %p", object->cookie);

 		spin_lock(&object->lock);
 		spin_unlock(&cache->object_list_lock);
 		fscache_raise_event(object, FSCACHE_OBJECT_EV_WITHDRAW);
 		spin_unlock(&object->lock);

 		cond_resched();
 		spin_lock(&cache->object_list_lock);
 	}

 	spin_unlock(&cache->object_list_lock);
 }

 /**
  * fscache_withdraw_cache - Withdraw a cache from the active service
  * @cache: The record describing the cache
  *
  * Withdraw a cache from service, unbinding all its cache objects from the
  * netfs cookies they're currently representing.
  *
  * See Documentation/filesystems/caching/backend-api.txt for a complete
  * description.
  */
 void fscache_withdraw_cache(struct fscache_cache *cache)
 {
 	LIST_HEAD(dying_objects);

 	_enter("");

 	printk(KERN_NOTICE "FS-Cache: Withdrawing cache \"%s\"\n",
 	       cache->tag->name);

 	/* make the cache unavailable for cookie acquisition */
 	if (test_and_set_bit(FSCACHE_CACHE_WITHDRAWN, &cache->flags))
 		BUG();

 	down_write(&fscache_addremove_sem);
 	list_del_init(&cache->link);
 	cache->tag->cache = NULL;
 	up_write(&fscache_addremove_sem);

 	/* make sure all pages pinned by operations on behalf of the netfs are
 	 * written to disk */
 	fscache_stat(&fscache_n_cop_sync_cache);
 	cache->ops->sync_cache(cache);
 	fscache_stat_d(&fscache_n_cop_sync_cache);

 	/* dissociate all the netfs pages backed by this cache from the block
 	 * mappings in the cache */
 	fscache_stat(&fscache_n_cop_dissociate_pages);
 	cache->ops->dissociate_pages(cache);
 	fscache_stat_d(&fscache_n_cop_dissociate_pages);

 	/* we now have to destroy all the active objects pertaining to this
 	 * cache - which we do by passing them off to thread pool to be
 	 * disposed of */
 	_debug("destroy");

 	fscache_withdraw_all_objects(cache, &dying_objects);

 	/* wait for all extant objects to finish their outstanding operations
 	 * and go away */
 	_debug("wait for finish");
 	wait_event(fscache_cache_cleared_wq,
 		   atomic_read(&cache->object_count) == 0);
 	_debug("wait for clearance");
 	wait_event(fscache_cache_cleared_wq,
 		   list_empty(&cache->object_list));
 	_debug("cleared");
 	ASSERT(list_empty(&dying_objects));

 	kobject_put(cache->kobj);

 	clear_bit(FSCACHE_TAG_RESERVED, &cache->tag->flags);
 	fscache_release_cache_tag(cache->tag);
 	cache->tag = NULL;

 	_leave("");
 }
 EXPORT_SYMBOL(fscache_withdraw_cache);
	/* FS-Cache cache handling
	*
	* Copyright (C) 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 <linux/slab.h>
	#include "internal.h"

	LIST_HEAD(fscache_cache_list);
	DECLARE_RWSEM(fscache_addremove_sem);
	DECLARE_WAIT_QUEUE_HEAD(fscache_cache_cleared_wq);
	EXPORT_SYMBOL(fscache_cache_cleared_wq);

	static LIST_HEAD(fscache_cache_tag_list);

	/*
	* look up a cache tag
	*/
	struct fscache_cache_tag __fscache_lookup_cache_tag(const char name)
	{
	struct fscache_cache_tag tag, xtag;

	/* firstly check for the existence of the tag under read lock */
	down_read(&fscache_addremove_sem);

	list_for_each_entry(tag, &fscache_cache_tag_list, link) {
	if (strcmp(tag->name, name) == 0) {
	atomic_inc(&tag->usage);
	up_read(&fscache_addremove_sem);
	return tag;
	}
	}

	up_read(&fscache_addremove_sem);

	/* the tag does not exist - create a candidate */
	xtag = kzalloc(sizeof(*xtag) + strlen(name) + 1, GFP_KERNEL);
	if (!xtag)
	/* return a dummy tag if out of memory */
	return ERR_PTR(-ENOMEM);

	atomic_set(&xtag->usage, 1);
	strcpy(xtag->name, name);

	/* write lock, search again and add if still not present */
	down_write(&fscache_addremove_sem);

	list_for_each_entry(tag, &fscache_cache_tag_list, link) {
	if (strcmp(tag->name, name) == 0) {
	atomic_inc(&tag->usage);
	up_write(&fscache_addremove_sem);
	kfree(xtag);
	return tag;
	}
	}

	list_add_tail(&xtag->link, &fscache_cache_tag_list);
	up_write(&fscache_addremove_sem);
	return xtag;
	}

	/*
	* release a reference to a cache tag
	*/
	void __fscache_release_cache_tag(struct fscache_cache_tag *tag)
	{
	if (tag != ERR_PTR(-ENOMEM)) {
	down_write(&fscache_addremove_sem);

	if (atomic_dec_and_test(&tag->usage))
	list_del_init(&tag->link);
	else
	tag = NULL;

	up_write(&fscache_addremove_sem);

	kfree(tag);
	}
	}

	/*
	* select a cache in which to store an object
	* - the cache addremove semaphore must be at least read-locked by the caller
	* - the object will never be an index
	*/
	struct fscache_cache *fscache_select_cache_for_object(
	struct fscache_cookie *cookie)
	{
	struct fscache_cache_tag *tag;
	struct fscache_object *object;
	struct fscache_cache *cache;

	_enter("");

	if (list_empty(&fscache_cache_list)) {
	_leave(" = NULL [no cache]");
	return NULL;
	}

	/* we check the parent to determine the cache to use */
	spin_lock(&cookie->lock);

	/* the first in the parent's backing list should be the preferred
	* cache */
	if (!hlist_empty(&cookie->backing_objects)) {
	object = hlist_entry(cookie->backing_objects.first,
	struct fscache_object, cookie_link);

	cache = object->cache;
	if (object->state >= FSCACHE_OBJECT_DYING \|\|
	test_bit(FSCACHE_IOERROR, &cache->flags))
	cache = NULL;

	spin_unlock(&cookie->lock);
	_leave(" = %p [parent]", cache);
	return cache;
	}

	/* the parent is unbacked */
	if (cookie->def->type != FSCACHE_COOKIE_TYPE_INDEX) {
	/* cookie not an index and is unbacked */
	spin_unlock(&cookie->lock);
	_leave(" = NULL [cookie ub,ni]");
	return NULL;
	}

	spin_unlock(&cookie->lock);

	if (!cookie->def->select_cache)
	goto no_preference;

	/* ask the netfs for its preference */
	tag = cookie->def->select_cache(cookie->parent->netfs_data,
	cookie->netfs_data);
	if (!tag)
	goto no_preference;

	if (tag == ERR_PTR(-ENOMEM)) {
	_leave(" = NULL [nomem tag]");
	return NULL;
	}

	if (!tag->cache) {
	_leave(" = NULL [unbacked tag]");
	return NULL;
	}

	if (test_bit(FSCACHE_IOERROR, &tag->cache->flags))
	return NULL;

	_leave(" = %p [specific]", tag->cache);
	return tag->cache;

	no_preference:
	/* netfs has no preference - just select first cache */
	cache = list_entry(fscache_cache_list.next,
	struct fscache_cache, link);
	_leave(" = %p [first]", cache);
	return cache;
	}

	/**
	* fscache_init_cache - Initialise a cache record
	* @cache: The cache record to be initialised
	* @ops: The cache operations to be installed in that record
	* @idfmt: Format string to define identifier
	* @...: sprintf-style arguments
	*
	* Initialise a record of a cache and fill in the name.
	*
	* See Documentation/filesystems/caching/backend-api.txt for a complete
	* description.
	*/
	void fscache_init_cache(struct fscache_cache *cache,
	const struct fscache_cache_ops *ops,
	const char *idfmt,
	...)
	{
	va_list va;

	memset(cache, 0, sizeof(*cache));

	cache->ops = ops;

	va_start(va, idfmt);
	vsnprintf(cache->identifier, sizeof(cache->identifier), idfmt, va);
	va_end(va);

	INIT_WORK(&cache->op_gc, fscache_operation_gc);
	INIT_LIST_HEAD(&cache->link);
	INIT_LIST_HEAD(&cache->object_list);
	INIT_LIST_HEAD(&cache->op_gc_list);
	spin_lock_init(&cache->object_list_lock);
	spin_lock_init(&cache->op_gc_list_lock);
	}
	EXPORT_SYMBOL(fscache_init_cache);

	/**
	* fscache_add_cache - Declare a cache as being open for business
	* @cache: The record describing the cache
	* @ifsdef: The record of the cache object describing the top-level index
	* @tagname: The tag describing this cache
	*
	* Add a cache to the system, making it available for netfs's to use.
	*
	* See Documentation/filesystems/caching/backend-api.txt for a complete
	* description.
	*/
	int fscache_add_cache(struct fscache_cache *cache,
	struct fscache_object *ifsdef,
	const char *tagname)
	{
	struct fscache_cache_tag *tag;

	BUG_ON(!cache->ops);
	BUG_ON(!ifsdef);

	cache->flags = 0;
	ifsdef->event_mask = ULONG_MAX & ~(1 << FSCACHE_OBJECT_EV_CLEARED);
	ifsdef->state = FSCACHE_OBJECT_ACTIVE;

	if (!tagname)
	tagname = cache->identifier;

	BUG_ON(!tagname[0]);

	_enter("{%s.%s},,%s", cache->ops->name, cache->identifier, tagname);

	/* we use the cache tag to uniquely identify caches */
	tag = __fscache_lookup_cache_tag(tagname);
	if (IS_ERR(tag))
	goto nomem;

	if (test_and_set_bit(FSCACHE_TAG_RESERVED, &tag->flags))
	goto tag_in_use;

	cache->kobj = kobject_create_and_add(tagname, fscache_root);
	if (!cache->kobj)
	goto error;

	ifsdef->cookie = &fscache_fsdef_index;
	ifsdef->cache = cache;
	cache->fsdef = ifsdef;

	down_write(&fscache_addremove_sem);

	tag->cache = cache;
	cache->tag = tag;

	/* add the cache to the list */
	list_add(&cache->link, &fscache_cache_list);

	/* add the cache's netfs definition index object to the cache's
	* list */
	spin_lock(&cache->object_list_lock);
	list_add_tail(&ifsdef->cache_link, &cache->object_list);
	spin_unlock(&cache->object_list_lock);
	fscache_objlist_add(ifsdef);

	/* add the cache's netfs definition index object to the top level index
	* cookie as a known backing object */
	spin_lock(&fscache_fsdef_index.lock);

	hlist_add_head(&ifsdef->cookie_link,
	&fscache_fsdef_index.backing_objects);

	atomic_inc(&fscache_fsdef_index.usage);

	/* done */
	spin_unlock(&fscache_fsdef_index.lock);
	up_write(&fscache_addremove_sem);

	printk(KERN_NOTICE "FS-Cache: Cache \"%s\" added (type %s)\n",
	cache->tag->name, cache->ops->name);
	kobject_uevent(cache->kobj, KOBJ_ADD);

	_leave(" = 0 [%s]", cache->identifier);
	return 0;

	tag_in_use:
	printk(KERN_ERR "FS-Cache: Cache tag '%s' already in use\n", tagname);
	__fscache_release_cache_tag(tag);
	_leave(" = -EXIST");
	return -EEXIST;

	error:
	__fscache_release_cache_tag(tag);
	_leave(" = -EINVAL");
	return -EINVAL;

	nomem:
	_leave(" = -ENOMEM");
	return -ENOMEM;
	}
	EXPORT_SYMBOL(fscache_add_cache);

	/**
	* fscache_io_error - Note a cache I/O error
	* @cache: The record describing the cache
	*
	* Note that an I/O error occurred in a cache and that it should no longer be
	* used for anything. This also reports the error into the kernel log.
	*
	* See Documentation/filesystems/caching/backend-api.txt for a complete
	* description.
	*/
	void fscache_io_error(struct fscache_cache *cache)
	{
	set_bit(FSCACHE_IOERROR, &cache->flags);

	printk(KERN_ERR "FS-Cache: Cache %s stopped due to I/O error\n",
	cache->ops->name);
	}
	EXPORT_SYMBOL(fscache_io_error);

	/*
	* request withdrawal of all the objects in a cache
	* - all the objects being withdrawn are moved onto the supplied list
	*/
	static void fscache_withdraw_all_objects(struct fscache_cache *cache,
	struct list_head *dying_objects)
	{
	struct fscache_object *object;

	spin_lock(&cache->object_list_lock);

	while (!list_empty(&cache->object_list)) {
	object = list_entry(cache->object_list.next,
	struct fscache_object, cache_link);
	list_move_tail(&object->cache_link, dying_objects);

	_debug("withdraw %p", object->cookie);

	spin_lock(&object->lock);
	spin_unlock(&cache->object_list_lock);
	fscache_raise_event(object, FSCACHE_OBJECT_EV_WITHDRAW);
	spin_unlock(&object->lock);

	cond_resched();
	spin_lock(&cache->object_list_lock);
	}

	spin_unlock(&cache->object_list_lock);
	}

	/**
	* fscache_withdraw_cache - Withdraw a cache from the active service
	* @cache: The record describing the cache
	*
	* Withdraw a cache from service, unbinding all its cache objects from the
	* netfs cookies they're currently representing.
	*
	* See Documentation/filesystems/caching/backend-api.txt for a complete
	* description.
	*/
	void fscache_withdraw_cache(struct fscache_cache *cache)
	{
	LIST_HEAD(dying_objects);

	_enter("");

	printk(KERN_NOTICE "FS-Cache: Withdrawing cache \"%s\"\n",
	cache->tag->name);

	/* make the cache unavailable for cookie acquisition */
	if (test_and_set_bit(FSCACHE_CACHE_WITHDRAWN, &cache->flags))
	BUG();

	down_write(&fscache_addremove_sem);
	list_del_init(&cache->link);
	cache->tag->cache = NULL;
	up_write(&fscache_addremove_sem);

	/* make sure all pages pinned by operations on behalf of the netfs are
	* written to disk */
	fscache_stat(&fscache_n_cop_sync_cache);
	cache->ops->sync_cache(cache);
	fscache_stat_d(&fscache_n_cop_sync_cache);

	/* dissociate all the netfs pages backed by this cache from the block
	* mappings in the cache */
	fscache_stat(&fscache_n_cop_dissociate_pages);
	cache->ops->dissociate_pages(cache);
	fscache_stat_d(&fscache_n_cop_dissociate_pages);

	/* we now have to destroy all the active objects pertaining to this
	* cache - which we do by passing them off to thread pool to be
	* disposed of */
	_debug("destroy");

	fscache_withdraw_all_objects(cache, &dying_objects);

	/* wait for all extant objects to finish their outstanding operations
	* and go away */
	_debug("wait for finish");
	wait_event(fscache_cache_cleared_wq,
	atomic_read(&cache->object_count) == 0);
	_debug("wait for clearance");
	wait_event(fscache_cache_cleared_wq,
	list_empty(&cache->object_list));
	_debug("cleared");
	ASSERT(list_empty(&dying_objects));

	kobject_put(cache->kobj);

	clear_bit(FSCACHE_TAG_RESERVED, &cache->tag->flags);
	fscache_release_cache_tag(cache->tag);
	cache->tag = NULL;

	_leave("");
	}
	EXPORT_SYMBOL(fscache_withdraw_cache);