[PATCH 25/67] cachefiles: Fold fscache_object into cachefiles_object

[David Howells <dhowells@redhat.com>]

Merge struct fscache_object into cachefiles_object so that it can be got
rid of.

Signed-off-by: David Howells <dhowells@redhat.com>
---

 fs/cachefiles/bind.c              |    6 +-
 fs/cachefiles/interface.c         |  116 +++++++++++++++----------------------
 fs/cachefiles/internal.h          |   19 +-----
 fs/cachefiles/key.c               |    8 +--
 fs/cachefiles/namei.c             |   21 +++----
 fs/cachefiles/xattr.c             |   16 +++--
 fs/fscache/cache.c                |   10 ++-
 fs/fscache/cookie.c               |   20 +++---
 fs/fscache/internal.h             |    4 +
 fs/fscache/object.c               |  110 ++++++++++++++++++-----------------
 include/linux/fscache-cache.h     |   71 +++++++++++++----------
 include/trace/events/cachefiles.h |   14 ++--
 include/trace/events/fscache.h    |    2 -
 13 files changed, 194 insertions(+), 223 deletions(-)

diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c
index cb3296814056..8db1ef2d1196 100644
--- a/fs/cachefiles/bind.c
+++ b/fs/cachefiles/bind.c
@@ -193,7 +193,7 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache)
 	}
 
 	fsdef->dentry = cachedir;
-	fsdef->fscache.cookie = NULL;
+	fsdef->cookie = NULL;
 
 	/* get the graveyard directory */
 	graveyard = cachefiles_get_directory(cache, root, "graveyard", NULL);
@@ -210,10 +210,10 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache)
 			   "%s",
 			   fsdef->dentry->d_sb->s_id);
 
-	fscache_object_init(&fsdef->fscache, &fscache_fsdef_index,
+	fscache_object_init(fsdef, &fscache_fsdef_index,
 			    &cache->cache);
 
-	ret = fscache_add_cache(&cache->cache, &fsdef->fscache, cache->tag);
+	ret = fscache_add_cache(&cache->cache, fsdef, cache->tag);
 	if (ret < 0)
 		goto error_add_cache;
 
diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c
index 92bb3ba78c41..7ec2302a3214 100644
--- a/fs/cachefiles/interface.c
+++ b/fs/cachefiles/interface.c
@@ -15,7 +15,7 @@ static int cachefiles_attr_changed(struct cachefiles_object *object);
 /*
  * allocate an object record for a cookie lookup and prepare the lookup data
  */
-static struct fscache_object *cachefiles_alloc_object(
+static struct cachefiles_object *cachefiles_alloc_object(
 	struct fscache_cache *_cache,
 	struct fscache_cookie *cookie)
 {
@@ -33,7 +33,7 @@ static struct fscache_object *cachefiles_alloc_object(
 
 	atomic_set(&object->usage, 1);
 
-	fscache_object_init(&object->fscache, cookie, &cache->cache);
+	fscache_object_init(object, cookie, &cache->cache);
 
 	object->type = cookie->type;
 
@@ -41,8 +41,8 @@ static struct fscache_object *cachefiles_alloc_object(
 	if (!cachefiles_cook_key(object))
 		goto nomem_key;
 
-	_leave(" = %x [%s]", object->fscache.debug_id, object->d_name);
-	return &object->fscache;
+	_leave(" = %x [%s]", object->debug_id, object->d_name);
+	return object;
 
 nomem_key:
 	kmem_cache_free(cachefiles_object_jar, object);
@@ -56,19 +56,17 @@ static struct fscache_object *cachefiles_alloc_object(
  * attempt to look up the nominated node in this cache
  * - return -ETIMEDOUT to be scheduled again
  */
-static int cachefiles_lookup_object(struct fscache_object *_object)
+static int cachefiles_lookup_object(struct cachefiles_object *object)
 {
-	struct cachefiles_object *parent, *object;
+	struct cachefiles_object *parent;
 	struct cachefiles_cache *cache;
 	const struct cred *saved_cred;
 	int ret;
 
-	_enter("{OBJ%x}", _object->debug_id);
+	_enter("{OBJ%x}", object->debug_id);
 
-	cache = container_of(_object->cache, struct cachefiles_cache, cache);
-	parent = container_of(_object->parent,
-			      struct cachefiles_object, fscache);
-	object = container_of(_object, struct cachefiles_object, fscache);
+	cache = container_of(object->cache, struct cachefiles_cache, cache);
+	parent = object->parent;
 
 	ASSERT(object->d_name);
 
@@ -79,13 +77,13 @@ static int cachefiles_lookup_object(struct fscache_object *_object)
 
 	/* polish off by setting the attributes of non-index files */
 	if (ret == 0 &&
-	    object->fscache.cookie->type != FSCACHE_COOKIE_TYPE_INDEX)
+	    object->cookie->type != FSCACHE_COOKIE_TYPE_INDEX)
 		cachefiles_attr_changed(object);
 
 	if (ret < 0 && ret != -ETIMEDOUT) {
 		if (ret != -ENOBUFS)
 			pr_warn("Lookup failed error %d\n", ret);
-		fscache_object_lookup_error(&object->fscache);
+		fscache_object_lookup_error(object);
 	}
 
 	_leave(" [%d]", ret);
@@ -95,52 +93,43 @@ static int cachefiles_lookup_object(struct fscache_object *_object)
 /*
  * indication of lookup completion
  */
-static void cachefiles_lookup_complete(struct fscache_object *_object)
+static void cachefiles_lookup_complete(struct cachefiles_object *object)
 {
-	struct cachefiles_object *object;
-
-	object = container_of(_object, struct cachefiles_object, fscache);
-
-	_enter("{OBJ%x}", object->fscache.debug_id);
+	_enter("{OBJ%x}", object->debug_id);
 }
 
 /*
  * increment the usage count on an inode object (may fail if unmounting)
  */
 static
-struct fscache_object *cachefiles_grab_object(struct fscache_object *_object,
-					      enum fscache_obj_ref_trace why)
+struct cachefiles_object *cachefiles_grab_object(struct cachefiles_object *object,
+						 enum fscache_obj_ref_trace why)
 {
-	struct cachefiles_object *object =
-		container_of(_object, struct cachefiles_object, fscache);
 	int u;
 
-	_enter("{OBJ%x,%d}", _object->debug_id, atomic_read(&object->usage));
+	_enter("{OBJ%x,%d}", object->debug_id, atomic_read(&object->usage));
 
 #ifdef CACHEFILES_DEBUG_SLAB
 	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
 #endif
 
 	u = atomic_inc_return(&object->usage);
-	trace_cachefiles_ref(object, _object->cookie,
+	trace_cachefiles_ref(object, object->cookie,
 			     (enum cachefiles_obj_ref_trace)why, u);
-	return &object->fscache;
+	return object;
 }
 
 /*
  * update the auxiliary data for an object object on disk
  */
-static void cachefiles_update_object(struct fscache_object *_object)
+static void cachefiles_update_object(struct cachefiles_object *object)
 {
-	struct cachefiles_object *object;
 	struct cachefiles_cache *cache;
 	const struct cred *saved_cred;
 
-	_enter("{OBJ%x}", _object->debug_id);
+	_enter("{OBJ%x}", object->debug_id);
 
-	object = container_of(_object, struct cachefiles_object, fscache);
-	cache = container_of(object->fscache.cache, struct cachefiles_cache,
-			     cache);
+	cache = container_of(object->cache, struct cachefiles_cache, cache);
 
 	cachefiles_begin_secure(cache, &saved_cred);
 	cachefiles_set_object_xattr(object, XATTR_REPLACE);
@@ -152,21 +141,16 @@ static void cachefiles_update_object(struct fscache_object *_object)
  * discard the resources pinned by an object and effect retirement if
  * requested
  */
-static void cachefiles_drop_object(struct fscache_object *_object)
+static void cachefiles_drop_object(struct cachefiles_object *object)
 {
-	struct cachefiles_object *object;
 	struct cachefiles_cache *cache;
 	const struct cred *saved_cred;
 
-	ASSERT(_object);
-
-	object = container_of(_object, struct cachefiles_object, fscache);
+	ASSERT(object);
 
-	_enter("{OBJ%x,%d}",
-	       object->fscache.debug_id, atomic_read(&object->usage));
+	_enter("{OBJ%x,%d}", object->debug_id, atomic_read(&object->usage));
 
-	cache = container_of(object->fscache.cache,
-			     struct cachefiles_cache, cache);
+	cache = container_of(object->cache, struct cachefiles_cache, cache);
 
 #ifdef CACHEFILES_DEBUG_SLAB
 	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
@@ -179,10 +163,10 @@ static void cachefiles_drop_object(struct fscache_object *_object)
 	 */
 	if (object->dentry) {
 		/* delete retired objects */
-		if (test_bit(FSCACHE_OBJECT_RETIRED, &object->fscache.flags) &&
-		    _object != cache->cache.fsdef
+		if (test_bit(FSCACHE_OBJECT_RETIRED, &object->flags) &&
+		    object != cache->cache.fsdef
 		    ) {
-			_debug("- retire object OBJ%x", object->fscache.debug_id);
+			_debug("- retire object OBJ%x", object->debug_id);
 			cachefiles_begin_secure(cache, &saved_cred);
 			cachefiles_delete_object(cache, object);
 			cachefiles_end_secure(cache, saved_cred);
@@ -200,43 +184,40 @@ static void cachefiles_drop_object(struct fscache_object *_object)
 /*
  * dispose of a reference to an object
  */
-void cachefiles_put_object(struct fscache_object *_object,
+void cachefiles_put_object(struct cachefiles_object *object,
 			   enum fscache_obj_ref_trace why)
 {
-	struct cachefiles_object *object;
 	struct fscache_cache *cache;
 	int u;
 
-	ASSERT(_object);
-
-	object = container_of(_object, struct cachefiles_object, fscache);
+	ASSERT(object);
 
 	_enter("{OBJ%x,%d}",
-	       object->fscache.debug_id, atomic_read(&object->usage));
+	       object->debug_id, atomic_read(&object->usage));
 
 #ifdef CACHEFILES_DEBUG_SLAB
 	ASSERT((atomic_read(&object->usage) & 0xffff0000) != 0x6b6b0000);
 #endif
 
-	ASSERTIFCMP(object->fscache.parent,
-		    object->fscache.parent->n_children, >, 0);
+	ASSERTIFCMP(object->parent,
+		    object->parent->n_children, >, 0);
 
 	u = atomic_dec_return(&object->usage);
-	trace_cachefiles_ref(object, _object->cookie,
+	trace_cachefiles_ref(object, object->cookie,
 			     (enum cachefiles_obj_ref_trace)why, u);
 	ASSERTCMP(u, !=, -1);
 	if (u == 0) {
-		_debug("- kill object OBJ%x", object->fscache.debug_id);
+		_debug("- kill object OBJ%x", object->debug_id);
 
-		ASSERTCMP(object->fscache.parent, ==, NULL);
+		ASSERTCMP(object->parent, ==, NULL);
 		ASSERTCMP(object->dentry, ==, NULL);
-		ASSERTCMP(object->fscache.n_ops, ==, 0);
-		ASSERTCMP(object->fscache.n_children, ==, 0);
+		ASSERTCMP(object->n_ops, ==, 0);
+		ASSERTCMP(object->n_children, ==, 0);
 
 		kfree(object->d_name);
 
-		cache = object->fscache.cache;
-		fscache_object_destroy(&object->fscache);
+		cache = object->cache;
+		fscache_object_destroy(object);
 		kmem_cache_free(cachefiles_object_jar, object);
 		fscache_object_destroyed(cache);
 	}
@@ -285,12 +266,12 @@ static int cachefiles_attr_changed(struct cachefiles_object *object)
 	loff_t oi_size;
 	int ret;
 
-	ni_size = object->fscache.cookie->object_size;
+	ni_size = object->cookie->object_size;
 
 	_enter("{OBJ%x},[%llu]",
-	       object->fscache.debug_id, (unsigned long long) ni_size);
+	       object->debug_id, (unsigned long long) ni_size);
 
-	cache = container_of(object->fscache.cache,
+	cache = container_of(object->cache,
 			     struct cachefiles_cache, cache);
 
 	if (ni_size == object->i_size)
@@ -337,23 +318,20 @@ static int cachefiles_attr_changed(struct cachefiles_object *object)
 /*
  * Invalidate an object
  */
-static void cachefiles_invalidate_object(struct fscache_object *_object)
+static void cachefiles_invalidate_object(struct cachefiles_object *object)
 {
-	struct cachefiles_object *object;
 	struct cachefiles_cache *cache;
 	const struct cred *saved_cred;
 	struct path path;
 	uint64_t ni_size;
 	int ret;
 
-	object = container_of(_object, struct cachefiles_object, fscache);
-	cache = container_of(object->fscache.cache,
-			     struct cachefiles_cache, cache);
+	cache = container_of(object->cache, struct cachefiles_cache, cache);
 
-	ni_size = object->fscache.cookie->object_size;
+	ni_size = object->cookie->object_size;
 
 	_enter("{OBJ%x},[%llu]",
-	       object->fscache.debug_id, (unsigned long long)ni_size);
+	       object->debug_id, (unsigned long long)ni_size);
 
 	if (object->dentry) {
 		ASSERT(d_is_reg(object->dentry));
diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h
index 9f2f837027e0..f268495ecbc6 100644
--- a/fs/cachefiles/internal.h
+++ b/fs/cachefiles/internal.h
@@ -29,21 +29,6 @@ extern unsigned cachefiles_debug;
 
 #define cachefiles_gfp (__GFP_RECLAIM | __GFP_NORETRY | __GFP_NOMEMALLOC)
 
-/*
- * node records
- */
-struct cachefiles_object {
-	struct fscache_object		fscache;	/* fscache handle */
-	char				*d_name;	/* Filename */
-	struct dentry			*dentry;	/* the file/dir representing this object */
-	loff_t				i_size;		/* object size */
-	atomic_t			usage;		/* object usage count */
-	uint8_t				type;		/* object type */
-	bool				new;		/* T if object new */
-	u8				d_name_len;	/* Length of filename */
-	u8				key_hash;
-};
-
 extern struct kmem_cache *cachefiles_object_jar;
 
 /*
@@ -114,7 +99,7 @@ extern int cachefiles_has_space(struct cachefiles_cache *cache,
  */
 extern const struct fscache_cache_ops cachefiles_cache_ops;
 
-void cachefiles_put_object(struct fscache_object *_object,
+void cachefiles_put_object(struct cachefiles_object *_object,
 			   enum fscache_obj_ref_trace why);
 
 /*
@@ -191,7 +176,7 @@ do {							\
 do {									\
 	struct cachefiles_cache *___cache;				\
 									\
-	___cache = container_of((object)->fscache.cache,		\
+	___cache = container_of((object)->cache,			\
 				struct cachefiles_cache, cache);	\
 	cachefiles_io_error(___cache, FMT, ##__VA_ARGS__);		\
 } while (0)
diff --git a/fs/cachefiles/key.c b/fs/cachefiles/key.c
index 56a9b3201b41..ccadbc4776f1 100644
--- a/fs/cachefiles/key.c
+++ b/fs/cachefiles/key.c
@@ -31,8 +31,8 @@ static const char cachefiles_filecharmap[256] = {
  */
 bool cachefiles_cook_key(struct cachefiles_object *object)
 {
-	const u8 *key = fscache_get_key(object->fscache.cookie);
-	unsigned int acc, sum, keylen = object->fscache.cookie->key_len;
+	const u8 *key = fscache_get_key(object->cookie);
+	unsigned int acc, sum, keylen = object->cookie->key_len;
 	char *name;
 	u8 *buffer, *p;
 	int i, len, elem3, print;
@@ -57,7 +57,7 @@ bool cachefiles_cook_key(struct cachefiles_object *object)
 		if (!name)
 			return false;
 
-		switch (object->fscache.cookie->type) {
+		switch (object->cookie->type) {
 		case FSCACHE_COOKIE_TYPE_INDEX:		type = 'I';	break;
 		case FSCACHE_COOKIE_TYPE_DATAFILE:	type = 'D';	break;
 		default:				type = 'S';	break;
@@ -97,7 +97,7 @@ bool cachefiles_cook_key(struct cachefiles_object *object)
 		return false;
 	}
 
-	switch (object->fscache.cookie->type) {
+	switch (object->cookie->type) {
 	case FSCACHE_COOKIE_TYPE_INDEX:		type = 'J';	break;
 	case FSCACHE_COOKIE_TYPE_DATAFILE:	type = 'E';	break;
 	default:				type = 'T';	break;
diff --git a/fs/cachefiles/namei.c b/fs/cachefiles/namei.c
index 7f02fcb34b1e..d3903cbb7de3 100644
--- a/fs/cachefiles/namei.c
+++ b/fs/cachefiles/namei.c
@@ -29,7 +29,7 @@ static bool cachefiles_mark_inode_in_use(struct cachefiles_object *object)
 	struct inode *inode = d_backing_inode(dentry);
 	bool can_use = false;
 
-	_enter(",%x", object->fscache.debug_id);
+	_enter(",%x", object->debug_id);
 
 	inode_lock(inode);
 
@@ -235,7 +235,7 @@ int cachefiles_delete_object(struct cachefiles_cache *cache,
 	struct dentry *dir;
 	int ret;
 
-	_enter(",OBJ%x{%pd}", object->fscache.debug_id, object->dentry);
+	_enter(",OBJ%x{%pd}", object->debug_id, object->dentry);
 
 	ASSERT(object->dentry);
 	ASSERT(d_backing_inode(object->dentry));
@@ -350,11 +350,11 @@ static int cachefiles_walk_to_file(struct cachefiles_cache *cache,
 		/* This element of the path doesn't exist, so we can release
 		 * any readers in the certain knowledge that there's nothing
 		 * for them to actually read */
-		fscache_object_lookup_negative(&object->fscache);
+		fscache_object_lookup_negative(object);
 
 		ret = cachefiles_has_space(cache, 1, 0);
 		if (ret < 0) {
-			fscache_object_mark_killed(&object->fscache, FSCACHE_OBJECT_NO_SPACE);
+			fscache_object_mark_killed(object, FSCACHE_OBJECT_NO_SPACE);
 			goto error_dput;
 		}
 
@@ -423,11 +423,10 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
 	int ret;
 
 	_enter("OBJ%x{%pd},OBJ%x,%s,",
-	       parent->fscache.debug_id, parent->dentry,
-	       object->fscache.debug_id, object->d_name);
+	       parent->debug_id, parent->dentry,
+	       object->debug_id, object->d_name);
 
-	cache = container_of(parent->fscache.cache,
-			     struct cachefiles_cache, cache);
+	cache = container_of(parent->cache, struct cachefiles_cache, cache);
 	ASSERT(parent->dentry);
 	ASSERT(d_backing_inode(parent->dentry));
 
@@ -460,7 +459,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
 		goto check_error;
 
 	object->new = false;
-	fscache_obtained_object(&object->fscache);
+	fscache_obtained_object(object);
 	_leave(" = 0 [%lu]", d_backing_inode(object->dentry)->i_ino);
 	return 0;
 
@@ -468,7 +467,7 @@ int cachefiles_walk_to_object(struct cachefiles_object *parent,
 	if (ret == -ESTALE) {
 		dput(object->dentry);
 		object->dentry = NULL;
-		fscache_object_retrying_stale(&object->fscache);
+		fscache_object_retrying_stale(object);
 		goto lookup_again;
 	}
 	if (ret == -EIO)
@@ -514,7 +513,7 @@ struct dentry *cachefiles_get_directory(struct cachefiles_cache *cache,
 		 * any readers in the certain knowledge that there's nothing
 		 * for them to actually read */
 		if (object)
-			fscache_object_lookup_negative(&object->fscache);
+			fscache_object_lookup_negative(object);
 
 		ret = cachefiles_has_space(cache, 1, 0);
 		if (ret < 0)
diff --git a/fs/cachefiles/xattr.c b/fs/cachefiles/xattr.c
index 8b9f30f9ce21..464dea0b467c 100644
--- a/fs/cachefiles/xattr.c
+++ b/fs/cachefiles/xattr.c
@@ -31,23 +31,23 @@ int cachefiles_set_object_xattr(struct cachefiles_object *object,
 {
 	struct cachefiles_xattr *buf;
 	struct dentry *dentry = object->dentry;
-	unsigned int len = object->fscache.cookie->aux_len;
+	unsigned int len = object->cookie->aux_len;
 	int ret;
 
 	if (!dentry)
 		return -ESTALE;
 
-	_enter("%x,#%d", object->fscache.debug_id, len);
+	_enter("%x,#%d", object->debug_id, len);
 
 	buf = kmalloc(sizeof(struct cachefiles_xattr) + len, GFP_KERNEL);
 	if (!buf)
 		return -ENOMEM;
 
-	buf->type = object->fscache.cookie->type;
+	buf->type = object->cookie->type;
 	if (len > 0)
-		memcpy(buf->data, fscache_get_aux(object->fscache.cookie), len);
+		memcpy(buf->data, fscache_get_aux(object->cookie), len);
 
-	clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
+	clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->cookie->flags);
 	ret = vfs_setxattr(&init_user_ns, dentry, cachefiles_xattr_cache,
 			   buf, sizeof(struct cachefiles_xattr) + len,
 			   xattr_flags);
@@ -68,8 +68,8 @@ int cachefiles_check_auxdata(struct cachefiles_object *object)
 {
 	struct cachefiles_xattr *buf;
 	struct dentry *dentry = object->dentry;
-	unsigned int len = object->fscache.cookie->aux_len, tlen;
-	const void *p = fscache_get_aux(object->fscache.cookie);
+	unsigned int len = object->cookie->aux_len, tlen;
+	const void *p = fscache_get_aux(object->cookie);
 	ssize_t ret;
 
 	ASSERT(dentry);
@@ -82,7 +82,7 @@ int cachefiles_check_auxdata(struct cachefiles_object *object)
 
 	ret = vfs_getxattr(&init_user_ns, dentry, cachefiles_xattr_cache, buf, tlen);
 	if (ret == tlen &&
-	    buf->type == object->fscache.cookie->type &&
+	    buf->type == object->cookie->type &&
 	    memcmp(buf->data, p, len) == 0)
 		ret = 0;
 	else
diff --git a/fs/fscache/cache.c b/fs/fscache/cache.c
index efcd834d6279..8a3191a89c32 100644
--- a/fs/fscache/cache.c
+++ b/fs/fscache/cache.c
@@ -93,7 +93,7 @@ struct fscache_cache *fscache_select_cache_for_object(
 	struct fscache_cookie *cookie)
 {
 	struct fscache_cache_tag *tag;
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 	struct fscache_cache *cache;
 
 	_enter("");
@@ -110,7 +110,7 @@ struct fscache_cache *fscache_select_cache_for_object(
 	 * cache */
 	if (!hlist_empty(&cookie->backing_objects)) {
 		object = hlist_entry(cookie->backing_objects.first,
-				     struct fscache_object, cookie_link);
+				     struct cachefiles_object, cookie_link);
 
 		cache = object->cache;
 		if (fscache_object_is_dying(object) ||
@@ -200,7 +200,7 @@ EXPORT_SYMBOL(fscache_init_cache);
  * description.
  */
 int fscache_add_cache(struct fscache_cache *cache,
-		      struct fscache_object *ifsdef,
+		      struct cachefiles_object *ifsdef,
 		      const char *tagname)
 {
 	struct fscache_cache_tag *tag;
@@ -313,14 +313,14 @@ EXPORT_SYMBOL(fscache_io_error);
 static void fscache_withdraw_all_objects(struct fscache_cache *cache,
 					 struct list_head *dying_objects)
 {
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 
 	while (!list_empty(&cache->object_list)) {
 		spin_lock(&cache->object_list_lock);
 
 		if (!list_empty(&cache->object_list)) {
 			object = list_entry(cache->object_list.next,
-					    struct fscache_object, cache_link);
+					    struct cachefiles_object, cache_link);
 			list_move_tail(&object->cache_link, dying_objects);
 
 			_debug("withdraw %x", object->cookie->debug_id);
diff --git a/fs/fscache/cookie.c b/fs/fscache/cookie.c
index 0dc27f82e910..3f7bb2eecdc3 100644
--- a/fs/fscache/cookie.c
+++ b/fs/fscache/cookie.c
@@ -26,11 +26,11 @@ static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie);
 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);
+				 struct cachefiles_object *object);
 
 static void fscache_print_cookie(struct fscache_cookie *cookie, char prefix)
 {
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 	struct hlist_node *o;
 	const u8 *k;
 	unsigned loop;
@@ -48,7 +48,7 @@ static void fscache_print_cookie(struct fscache_cookie *cookie, char prefix)
 
 	o = READ_ONCE(cookie->backing_objects.first);
 	if (o) {
-		object = hlist_entry(o, struct fscache_object, cookie_link);
+		object = hlist_entry(o, struct cachefiles_object, cookie_link);
 		pr_err("%c-cookie o=%u\n", prefix, object->debug_id);
 	}
 
@@ -396,7 +396,7 @@ EXPORT_SYMBOL(__fscache_enable_cookie);
  */
 static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
 {
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 	struct fscache_cache *cache;
 	int ret;
 
@@ -443,7 +443,7 @@ static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
 	}
 
 	object = hlist_entry(cookie->backing_objects.first,
-			     struct fscache_object, cookie_link);
+			     struct cachefiles_object, cookie_link);
 
 	/* initiate the process of looking up all the objects in the chain
 	 * (done by fscache_initialise_object()) */
@@ -476,7 +476,7 @@ static int fscache_acquire_non_index_cookie(struct fscache_cookie *cookie)
 static int fscache_alloc_object(struct fscache_cache *cache,
 				struct fscache_cookie *cookie)
 {
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 	int ret;
 
 	_enter("%s,%x{%s}", cache->tag->name, cookie->debug_id, cookie->type_name);
@@ -548,9 +548,9 @@ static int fscache_alloc_object(struct fscache_cache *cache,
  * attach a cache object to a cookie
  */
 static int fscache_attach_object(struct fscache_cookie *cookie,
-				 struct fscache_object *object)
+				 struct cachefiles_object *object)
 {
-	struct fscache_object *p;
+	struct cachefiles_object *p;
 	struct fscache_cache *cache = object->cache;
 	int ret;
 
@@ -648,7 +648,7 @@ EXPORT_SYMBOL(__fscache_wait_on_invalidate);
  */
 void __fscache_update_cookie(struct fscache_cookie *cookie, const void *aux_data)
 {
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 
 	fscache_stat(&fscache_n_updates);
 
@@ -686,7 +686,7 @@ void __fscache_disable_cookie(struct fscache_cookie *cookie,
 			      const void *aux_data,
 			      bool invalidate)
 {
-	struct fscache_object *object;
+	struct cachefiles_object *object;
 	bool awaken = false;
 
 	_enter("%x,%u", cookie->debug_id, invalidate);
diff --git a/fs/fscache/internal.h b/fs/fscache/internal.h
index e78ca3151e41..eefcb6dfee3e 100644
--- a/fs/fscache/internal.h
+++ b/fs/fscache/internal.h
@@ -106,7 +106,7 @@ static inline bool fscache_object_congested(void)
 /*
  * object.c
  */
-extern void fscache_enqueue_object(struct fscache_object *);
+extern void fscache_enqueue_object(struct cachefiles_object *);
 
 /*
  * proc.c
@@ -227,7 +227,7 @@ int fscache_stats_show(struct seq_file *m, void *v);
  * - if the event is not masked for that object, then the object is
  *   queued for attention by the thread pool.
  */
-static inline void fscache_raise_event(struct fscache_object *object,
+static inline void fscache_raise_event(struct cachefiles_object *object,
 				       unsigned event)
 {
 	BUG_ON(event >= NR_FSCACHE_OBJECT_EVENTS);
diff --git a/fs/fscache/object.c b/fs/fscache/object.c
index 761d6dc4aa0f..e653d0194f71 100644
--- a/fs/fscache/object.c
+++ b/fs/fscache/object.c
@@ -14,19 +14,19 @@
 #include <linux/prefetch.h>
 #include "internal.h"
 
-static const struct fscache_state *fscache_abort_initialisation(struct fscache_object *, int);
-static const struct fscache_state *fscache_kill_dependents(struct fscache_object *, int);
-static const struct fscache_state *fscache_drop_object(struct fscache_object *, int);
-static const struct fscache_state *fscache_initialise_object(struct fscache_object *, int);
-static const struct fscache_state *fscache_invalidate_object(struct fscache_object *, int);
-static const struct fscache_state *fscache_jumpstart_dependents(struct fscache_object *, int);
-static const struct fscache_state *fscache_kill_object(struct fscache_object *, int);
-static const struct fscache_state *fscache_lookup_failure(struct fscache_object *, int);
-static const struct fscache_state *fscache_look_up_object(struct fscache_object *, int);
-static const struct fscache_state *fscache_object_available(struct fscache_object *, int);
-static const struct fscache_state *fscache_parent_ready(struct fscache_object *, int);
-static const struct fscache_state *fscache_update_object(struct fscache_object *, int);
-static const struct fscache_state *fscache_object_dead(struct fscache_object *, int);
+static const struct fscache_state *fscache_abort_initialisation(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_kill_dependents(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_drop_object(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_initialise_object(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_invalidate_object(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_jumpstart_dependents(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_kill_object(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_lookup_failure(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_look_up_object(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_object_available(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_parent_ready(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_update_object(struct cachefiles_object *, int);
+static const struct fscache_state *fscache_object_dead(struct cachefiles_object *, int);
 
 #define __STATE_NAME(n) fscache_osm_##n
 #define STATE(n) (&__STATE_NAME(n))
@@ -133,21 +133,21 @@ static const struct fscache_transition fscache_osm_run_oob[] = {
 	   { 0, NULL }
 };
 
-static int  fscache_get_object(struct fscache_object *,
+static int  fscache_get_object(struct cachefiles_object *,
 			       enum fscache_obj_ref_trace);
-static void fscache_put_object(struct fscache_object *,
+static void fscache_put_object(struct cachefiles_object *,
 			       enum fscache_obj_ref_trace);
-static bool fscache_enqueue_dependents(struct fscache_object *, int);
-static void fscache_dequeue_object(struct fscache_object *);
-static void fscache_update_aux_data(struct fscache_object *);
+static bool fscache_enqueue_dependents(struct cachefiles_object *, int);
+static void fscache_dequeue_object(struct cachefiles_object *);
+static void fscache_update_aux_data(struct cachefiles_object *);
 
 /*
  * we need to notify the parent when an op completes that we had outstanding
  * upon it
  */
-static inline void fscache_done_parent_op(struct fscache_object *object)
+static inline void fscache_done_parent_op(struct cachefiles_object *object)
 {
-	struct fscache_object *parent = object->parent;
+	struct cachefiles_object *parent = object->parent;
 
 	_enter("OBJ%x {OBJ%x,%x}",
 	       object->debug_id, parent->debug_id, parent->n_ops);
@@ -163,7 +163,7 @@ static inline void fscache_done_parent_op(struct fscache_object *object)
 /*
  * Object state machine dispatcher.
  */
-static void fscache_object_sm_dispatcher(struct fscache_object *object)
+static void fscache_object_sm_dispatcher(struct cachefiles_object *object)
 {
 	const struct fscache_transition *t;
 	const struct fscache_state *state, *new_state;
@@ -274,8 +274,8 @@ static void fscache_object_sm_dispatcher(struct fscache_object *object)
  */
 static void fscache_object_work_func(struct work_struct *work)
 {
-	struct fscache_object *object =
-		container_of(work, struct fscache_object, work);
+	struct cachefiles_object *object =
+		container_of(work, struct cachefiles_object, work);
 
 	_enter("{OBJ%x}", object->debug_id);
 
@@ -294,7 +294,7 @@ static void fscache_object_work_func(struct work_struct *work)
  * See Documentation/filesystems/caching/backend-api.rst for a complete
  * description.
  */
-void fscache_object_init(struct fscache_object *object,
+void fscache_object_init(struct cachefiles_object *object,
 			 struct fscache_cookie *cookie,
 			 struct fscache_cache *cache)
 {
@@ -335,7 +335,7 @@ EXPORT_SYMBOL(fscache_object_init);
  * Mark the object as no longer being live, making sure that we synchronise
  * against op submission.
  */
-static inline void fscache_mark_object_dead(struct fscache_object *object)
+static inline void fscache_mark_object_dead(struct cachefiles_object *object)
 {
 	spin_lock(&object->lock);
 	clear_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);
@@ -345,7 +345,7 @@ static inline void fscache_mark_object_dead(struct fscache_object *object)
 /*
  * Abort object initialisation before we start it.
  */
-static const struct fscache_state *fscache_abort_initialisation(struct fscache_object *object,
+static const struct fscache_state *fscache_abort_initialisation(struct cachefiles_object *object,
 								int event)
 {
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -362,10 +362,10 @@ static const struct fscache_state *fscache_abort_initialisation(struct fscache_o
  * - we may need to start the process of creating a parent and we need to wait
  *   for the parent's lookup and creation to complete if it's not there yet
  */
-static const struct fscache_state *fscache_initialise_object(struct fscache_object *object,
+static const struct fscache_state *fscache_initialise_object(struct cachefiles_object *object,
 							     int event)
 {
-	struct fscache_object *parent;
+	struct cachefiles_object *parent;
 	bool success;
 
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -417,10 +417,10 @@ static const struct fscache_state *fscache_initialise_object(struct fscache_obje
 /*
  * Once the parent object is ready, we should kick off our lookup op.
  */
-static const struct fscache_state *fscache_parent_ready(struct fscache_object *object,
+static const struct fscache_state *fscache_parent_ready(struct cachefiles_object *object,
 							int event)
 {
-	struct fscache_object *parent = object->parent;
+	struct cachefiles_object *parent = object->parent;
 
 	_enter("{OBJ%x},%d", object->debug_id, event);
 
@@ -440,11 +440,11 @@ static const struct fscache_state *fscache_parent_ready(struct fscache_object *o
  * - we hold an "access lock" on the parent object, so the parent object cannot
  *   be withdrawn by either party till we've finished
  */
-static const struct fscache_state *fscache_look_up_object(struct fscache_object *object,
+static const struct fscache_state *fscache_look_up_object(struct cachefiles_object *object,
 							  int event)
 {
 	struct fscache_cookie *cookie = object->cookie;
-	struct fscache_object *parent = object->parent;
+	struct cachefiles_object *parent = object->parent;
 	int ret;
 
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -499,7 +499,7 @@ static const struct fscache_state *fscache_look_up_object(struct fscache_object
  * Note negative lookup, permitting those waiting to read data from an already
  * existing backing object to continue as there's no data for them to read.
  */
-void fscache_object_lookup_negative(struct fscache_object *object)
+void fscache_object_lookup_negative(struct cachefiles_object *object)
 {
 	struct fscache_cookie *cookie = object->cookie;
 
@@ -531,7 +531,7 @@ EXPORT_SYMBOL(fscache_object_lookup_negative);
  * Note that after calling this, an object's cookie may be relinquished by the
  * netfs, and so must be accessed with object lock held.
  */
-void fscache_obtained_object(struct fscache_object *object)
+void fscache_obtained_object(struct cachefiles_object *object)
 {
 	struct fscache_cookie *cookie = object->cookie;
 
@@ -563,7 +563,7 @@ EXPORT_SYMBOL(fscache_obtained_object);
 /*
  * handle an object that has just become available
  */
-static const struct fscache_state *fscache_object_available(struct fscache_object *object,
+static const struct fscache_state *fscache_object_available(struct cachefiles_object *object,
 							    int event)
 {
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -588,7 +588,7 @@ static const struct fscache_state *fscache_object_available(struct fscache_objec
 /*
  * Wake up this object's dependent objects now that we've become available.
  */
-static const struct fscache_state *fscache_jumpstart_dependents(struct fscache_object *object,
+static const struct fscache_state *fscache_jumpstart_dependents(struct cachefiles_object *object,
 								int event)
 {
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -601,7 +601,7 @@ static const struct fscache_state *fscache_jumpstart_dependents(struct fscache_o
 /*
  * Handle lookup or creation failute.
  */
-static const struct fscache_state *fscache_lookup_failure(struct fscache_object *object,
+static const struct fscache_state *fscache_lookup_failure(struct cachefiles_object *object,
 							  int event)
 {
 	struct fscache_cookie *cookie;
@@ -629,7 +629,7 @@ static const struct fscache_state *fscache_lookup_failure(struct fscache_object
  * Wait for completion of all active operations on this object and the death of
  * all child objects of this object.
  */
-static const struct fscache_state *fscache_kill_object(struct fscache_object *object,
+static const struct fscache_state *fscache_kill_object(struct cachefiles_object *object,
 						       int event)
 {
 	_enter("{OBJ%x,%d,%d},%d",
@@ -652,7 +652,7 @@ static const struct fscache_state *fscache_kill_object(struct fscache_object *ob
 /*
  * Kill dependent objects.
  */
-static const struct fscache_state *fscache_kill_dependents(struct fscache_object *object,
+static const struct fscache_state *fscache_kill_dependents(struct cachefiles_object *object,
 							   int event)
 {
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -665,10 +665,10 @@ static const struct fscache_state *fscache_kill_dependents(struct fscache_object
 /*
  * Drop an object's attachments
  */
-static const struct fscache_state *fscache_drop_object(struct fscache_object *object,
+static const struct fscache_state *fscache_drop_object(struct cachefiles_object *object,
 						       int event)
 {
-	struct fscache_object *parent = object->parent;
+	struct cachefiles_object *parent = object->parent;
 	struct fscache_cookie *cookie = object->cookie;
 	struct fscache_cache *cache = object->cache;
 	bool awaken = false;
@@ -738,7 +738,7 @@ static const struct fscache_state *fscache_drop_object(struct fscache_object *ob
 /*
  * get a ref on an object
  */
-static int fscache_get_object(struct fscache_object *object,
+static int fscache_get_object(struct cachefiles_object *object,
 			      enum fscache_obj_ref_trace why)
 {
 	int ret;
@@ -752,7 +752,7 @@ static int fscache_get_object(struct fscache_object *object,
 /*
  * Discard a ref on an object
  */
-static void fscache_put_object(struct fscache_object *object,
+static void fscache_put_object(struct cachefiles_object *object,
 			       enum fscache_obj_ref_trace why)
 {
 	fscache_stat(&fscache_n_cop_put_object);
@@ -766,7 +766,7 @@ static void fscache_put_object(struct fscache_object *object,
  *
  * Note the imminent destruction and deallocation of a cache object record.
  */
-void fscache_object_destroy(struct fscache_object *object)
+void fscache_object_destroy(struct cachefiles_object *object)
 {
 	/* We can get rid of the cookie now */
 	fscache_put_cookie(object->cookie, fscache_cookie_put_object);
@@ -777,7 +777,7 @@ EXPORT_SYMBOL(fscache_object_destroy);
 /*
  * enqueue an object for metadata-type processing
  */
-void fscache_enqueue_object(struct fscache_object *object)
+void fscache_enqueue_object(struct cachefiles_object *object)
 {
 	_enter("{OBJ%x}", object->debug_id);
 
@@ -831,9 +831,9 @@ EXPORT_SYMBOL_GPL(fscache_object_sleep_till_congested);
  * again then return false immediately.  We return true if the list was
  * cleared.
  */
-static bool fscache_enqueue_dependents(struct fscache_object *object, int event)
+static bool fscache_enqueue_dependents(struct cachefiles_object *object, int event)
 {
-	struct fscache_object *dep;
+	struct cachefiles_object *dep;
 	bool ret = true;
 
 	_enter("{OBJ%x}", object->debug_id);
@@ -845,7 +845,7 @@ static bool fscache_enqueue_dependents(struct fscache_object *object, int event)
 
 	while (!list_empty(&object->dependents)) {
 		dep = list_entry(object->dependents.next,
-				 struct fscache_object, dep_link);
+				 struct cachefiles_object, dep_link);
 		list_del_init(&dep->dep_link);
 
 		fscache_raise_event(dep, event);
@@ -864,7 +864,7 @@ static bool fscache_enqueue_dependents(struct fscache_object *object, int event)
 /*
  * remove an object from whatever queue it's waiting on
  */
-static void fscache_dequeue_object(struct fscache_object *object)
+static void fscache_dequeue_object(struct cachefiles_object *object)
 {
 	_enter("{OBJ%x}", object->debug_id);
 
@@ -877,7 +877,7 @@ static void fscache_dequeue_object(struct fscache_object *object)
 	_leave("");
 }
 
-static const struct fscache_state *fscache_invalidate_object(struct fscache_object *object,
+static const struct fscache_state *fscache_invalidate_object(struct cachefiles_object *object,
 							     int event)
 {
 	return transit_to(UPDATE_OBJECT);
@@ -886,7 +886,7 @@ static const struct fscache_state *fscache_invalidate_object(struct fscache_obje
 /*
  * Update auxiliary data.
  */
-static void fscache_update_aux_data(struct fscache_object *object)
+static void fscache_update_aux_data(struct cachefiles_object *object)
 {
 	fscache_stat(&fscache_n_updates_run);
 	fscache_stat(&fscache_n_cop_update_object);
@@ -897,7 +897,7 @@ static void fscache_update_aux_data(struct fscache_object *object)
 /*
  * Asynchronously update an object.
  */
-static const struct fscache_state *fscache_update_object(struct fscache_object *object,
+static const struct fscache_state *fscache_update_object(struct cachefiles_object *object,
 							 int event)
 {
 	_enter("{OBJ%x},%d", object->debug_id, event);
@@ -915,7 +915,7 @@ static const struct fscache_state *fscache_update_object(struct fscache_object *
  * Note that an object lookup found an on-disk object that was adjudged to be
  * stale and has been deleted.  The lookup will be retried.
  */
-void fscache_object_retrying_stale(struct fscache_object *object)
+void fscache_object_retrying_stale(struct cachefiles_object *object)
 {
 	fscache_stat(&fscache_n_cache_no_space_reject);
 }
@@ -929,7 +929,7 @@ EXPORT_SYMBOL(fscache_object_retrying_stale);
  * Note that an object was killed.  Returns true if the object was
  * already marked killed, false if it wasn't.
  */
-void fscache_object_mark_killed(struct fscache_object *object,
+void fscache_object_mark_killed(struct cachefiles_object *object,
 				enum fscache_why_object_killed why)
 {
 	if (test_and_set_bit(FSCACHE_OBJECT_KILLED_BY_CACHE, &object->flags)) {
@@ -961,7 +961,7 @@ EXPORT_SYMBOL(fscache_object_mark_killed);
  * already running (and so can be requeued) but hasn't yet cleared the event
  * mask.
  */
-static const struct fscache_state *fscache_object_dead(struct fscache_object *object,
+static const struct fscache_state *fscache_object_dead(struct cachefiles_object *object,
 						       int event)
 {
 	if (!test_and_set_bit(FSCACHE_OBJECT_RUN_AFTER_DEAD,
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 0439dc3021c7..7021c1ec2b64 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -22,7 +22,7 @@
 
 struct fscache_cache;
 struct fscache_cache_ops;
-struct fscache_object;
+struct cachefiles_object;
 enum fscache_cookie_trace;
 
 enum fscache_obj_ref_trace {
@@ -65,7 +65,7 @@ struct fscache_cache {
 	struct list_head	object_list;	/* list of data/index objects */
 	spinlock_t		object_list_lock;
 	atomic_t		object_count;	/* no. of live objects in this cache */
-	struct fscache_object	*fsdef;		/* object for the fsdef index */
+	struct cachefiles_object	*fsdef;		/* object for the fsdef index */
 	unsigned long		flags;
 #define FSCACHE_IOERROR		0	/* cache stopped on I/O error */
 #define FSCACHE_CACHE_WITHDRAWN	1	/* cache has been withdrawn */
@@ -81,46 +81,46 @@ struct fscache_cache_ops {
 	const char *name;
 
 	/* allocate an object record for a cookie */
-	struct fscache_object *(*alloc_object)(struct fscache_cache *cache,
+	struct cachefiles_object *(*alloc_object)(struct fscache_cache *cache,
 					       struct fscache_cookie *cookie);
 
 	/* look up the object for a cookie
 	 * - return -ETIMEDOUT to be requeued
 	 */
-	int (*lookup_object)(struct fscache_object *object);
+	int (*lookup_object)(struct cachefiles_object *object);
 
 	/* finished looking up */
-	void (*lookup_complete)(struct fscache_object *object);
+	void (*lookup_complete)(struct cachefiles_object *object);
 
 	/* increment the usage count on this object (may fail if unmounting) */
-	struct fscache_object *(*grab_object)(struct fscache_object *object,
+	struct cachefiles_object *(*grab_object)(struct cachefiles_object *object,
 					      enum fscache_obj_ref_trace why);
 
 	/* pin an object in the cache */
-	int (*pin_object)(struct fscache_object *object);
+	int (*pin_object)(struct cachefiles_object *object);
 
 	/* unpin an object in the cache */
-	void (*unpin_object)(struct fscache_object *object);
+	void (*unpin_object)(struct cachefiles_object *object);
 
 	/* store the updated auxiliary data on an object */
-	void (*update_object)(struct fscache_object *object);
+	void (*update_object)(struct cachefiles_object *object);
 
 	/* Invalidate an object */
-	void (*invalidate_object)(struct fscache_object *object);
+	void (*invalidate_object)(struct cachefiles_object *object);
 
 	/* discard the resources pinned by an object and effect retirement if
 	 * necessary */
-	void (*drop_object)(struct fscache_object *object);
+	void (*drop_object)(struct cachefiles_object *object);
 
 	/* dispose of a reference to an object */
-	void (*put_object)(struct fscache_object *object,
+	void (*put_object)(struct cachefiles_object *object,
 			   enum fscache_obj_ref_trace why);
 
 	/* sync a cache */
 	void (*sync_cache)(struct fscache_cache *cache);
 
 	/* reserve space for an object's data and associated metadata */
-	int (*reserve_space)(struct fscache_object *object, loff_t i_size);
+	int (*reserve_space)(struct cachefiles_object *object, loff_t i_size);
 
 	/* Begin an operation for the netfs lib */
 	int (*begin_operation)(struct netfs_cache_resources *cres);
@@ -155,7 +155,7 @@ struct fscache_transition {
 struct fscache_state {
 	char name[24];
 	char short_name[8];
-	const struct fscache_state *(*work)(struct fscache_object *object,
+	const struct fscache_state *(*work)(struct cachefiles_object *object,
 					    int event);
 	const struct fscache_transition transitions[];
 };
@@ -163,7 +163,7 @@ struct fscache_state {
 /*
  * on-disk cache file or index handle
  */
-struct fscache_object {
+struct cachefiles_object {
 	const struct fscache_state *state;	/* Object state machine state */
 	const struct fscache_transition *oob_table; /* OOB state transition table */
 	int			debug_id;	/* debugging ID */
@@ -192,40 +192,49 @@ struct fscache_object {
 	struct hlist_node	cookie_link;	/* link in cookie->backing_objects */
 	struct fscache_cache	*cache;		/* cache that supplied this object */
 	struct fscache_cookie	*cookie;	/* netfs's file/index object */
-	struct fscache_object	*parent;	/* parent object */
+	struct cachefiles_object	*parent;	/* parent object */
 	struct work_struct	work;		/* attention scheduling record */
 	struct list_head	dependents;	/* FIFO of dependent objects */
 	struct list_head	dep_link;	/* link in parent's dependents list */
+
+	char				*d_name;	/* Filename */
+	struct dentry			*dentry;	/* the file/dir representing this object */
+	loff_t				i_size;		/* object size */
+	atomic_t			usage;		/* object usage count */
+	uint8_t				type;		/* object type */
+	bool				new;		/* T if object new */
+	u8				d_name_len;	/* Length of filename */
+	u8				key_hash;
 };
 
-extern void fscache_object_init(struct fscache_object *, struct fscache_cookie *,
+extern void fscache_object_init(struct cachefiles_object *, struct fscache_cookie *,
 				struct fscache_cache *);
-extern void fscache_object_destroy(struct fscache_object *);
+extern void fscache_object_destroy(struct cachefiles_object *);
 
-extern void fscache_object_lookup_negative(struct fscache_object *object);
-extern void fscache_obtained_object(struct fscache_object *object);
+extern void fscache_object_lookup_negative(struct cachefiles_object *object);
+extern void fscache_obtained_object(struct cachefiles_object *object);
 
-static inline bool fscache_object_is_live(struct fscache_object *object)
+static inline bool fscache_object_is_live(struct cachefiles_object *object)
 {
 	return test_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);
 }
 
-static inline bool fscache_object_is_dying(struct fscache_object *object)
+static inline bool fscache_object_is_dying(struct cachefiles_object *object)
 {
 	return !fscache_object_is_live(object);
 }
 
-static inline bool fscache_object_is_available(struct fscache_object *object)
+static inline bool fscache_object_is_available(struct cachefiles_object *object)
 {
 	return test_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags);
 }
 
-static inline bool fscache_cache_is_broken(struct fscache_object *object)
+static inline bool fscache_cache_is_broken(struct cachefiles_object *object)
 {
 	return test_bit(FSCACHE_IOERROR, &object->cache->flags);
 }
 
-static inline bool fscache_object_is_active(struct fscache_object *object)
+static inline bool fscache_object_is_active(struct cachefiles_object *object)
 {
 	return fscache_object_is_available(object) &&
 		fscache_object_is_live(object) &&
@@ -251,7 +260,7 @@ static inline void fscache_object_destroyed(struct fscache_cache *cache)
  * Note that an object encountered a fatal error (usually an I/O error) and
  * that it should be withdrawn as soon as possible.
  */
-static inline void fscache_object_lookup_error(struct fscache_object *object)
+static inline void fscache_object_lookup_error(struct cachefiles_object *object)
 {
 	set_bit(FSCACHE_OBJECT_EV_ERROR, &object->events);
 }
@@ -268,7 +277,7 @@ static inline void __fscache_use_cookie(struct fscache_cookie *cookie)
  * Request usage of the cookie attached to an object.  NULL is returned if the
  * relinquishment had reduced the cookie usage count to 0.
  */
-static inline bool fscache_use_cookie(struct fscache_object *object)
+static inline bool fscache_use_cookie(struct cachefiles_object *object)
 {
 	struct fscache_cookie *cookie = object->cookie;
 	return atomic_inc_not_zero(&cookie->n_active) != 0;
@@ -291,7 +300,7 @@ static inline void __fscache_wake_unused_cookie(struct fscache_cookie *cookie)
  * Cease usage of the cookie attached to an object.  When the users count
  * reaches zero then the cookie relinquishment will be permitted to proceed.
  */
-static inline void fscache_unuse_cookie(struct fscache_object *object)
+static inline void fscache_unuse_cookie(struct cachefiles_object *object)
 {
 	struct fscache_cookie *cookie = object->cookie;
 	if (__fscache_unuse_cookie(cookie))
@@ -307,7 +316,7 @@ void fscache_init_cache(struct fscache_cache *cache,
 			const char *idfmt, ...);
 
 extern int fscache_add_cache(struct fscache_cache *cache,
-			     struct fscache_object *fsdef,
+			     struct cachefiles_object *fsdef,
 			     const char *tagname);
 extern void fscache_withdraw_cache(struct fscache_cache *cache);
 
@@ -315,7 +324,7 @@ extern void fscache_io_error(struct fscache_cache *cache);
 
 extern bool fscache_object_sleep_till_congested(signed long *timeoutp);
 
-extern void fscache_object_retrying_stale(struct fscache_object *object);
+extern void fscache_object_retrying_stale(struct cachefiles_object *object);
 
 enum fscache_why_object_killed {
 	FSCACHE_OBJECT_IS_STALE,
@@ -323,7 +332,7 @@ enum fscache_why_object_killed {
 	FSCACHE_OBJECT_WAS_RETIRED,
 	FSCACHE_OBJECT_WAS_CULLED,
 };
-extern void fscache_object_mark_killed(struct fscache_object *object,
+extern void fscache_object_mark_killed(struct cachefiles_object *object,
 				       enum fscache_why_object_killed why);
 
 extern struct fscache_cookie *fscache_get_cookie(struct fscache_cookie *cookie,
diff --git a/include/trace/events/cachefiles.h b/include/trace/events/cachefiles.h
index 87681dd957ec..5aec097d51ae 100644
--- a/include/trace/events/cachefiles.h
+++ b/include/trace/events/cachefiles.h
@@ -85,7 +85,7 @@ TRACE_EVENT(cachefiles_ref,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj->fscache.debug_id;
+		    __entry->obj	= obj->debug_id;
 		    __entry->cookie	= cookie->debug_id;
 		    __entry->usage	= usage;
 		    __entry->why	= why;
@@ -109,7 +109,7 @@ TRACE_EVENT(cachefiles_lookup,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj->fscache.debug_id;
+		    __entry->obj	= obj->debug_id;
 		    __entry->ino	= (!IS_ERR(de) && d_backing_inode(de) ?
 					   d_backing_inode(de)->i_ino : 0);
 		    __entry->error	= IS_ERR(de) ? PTR_ERR(de) : 0;
@@ -132,7 +132,7 @@ TRACE_EVENT(cachefiles_create,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj->fscache.debug_id;
+		    __entry->obj	= obj->debug_id;
 		    __entry->de		= de;
 		    __entry->ret	= ret;
 			   ),
@@ -156,7 +156,7 @@ TRACE_EVENT(cachefiles_unlink,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj ? obj->fscache.debug_id : UINT_MAX;
+		    __entry->obj	= obj ? obj->debug_id : UINT_MAX;
 		    __entry->de		= de;
 		    __entry->why	= why;
 			   ),
@@ -183,7 +183,7 @@ TRACE_EVENT(cachefiles_rename,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj ? obj->fscache.debug_id : UINT_MAX;
+		    __entry->obj	= obj ? obj->debug_id : UINT_MAX;
 		    __entry->de		= de;
 		    __entry->to		= to;
 		    __entry->why	= why;
@@ -207,7 +207,7 @@ TRACE_EVENT(cachefiles_mark_active,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj->fscache.debug_id;
+		    __entry->obj	= obj->debug_id;
 		    __entry->de		= de;
 			   ),
 
@@ -230,7 +230,7 @@ TRACE_EVENT(cachefiles_mark_inactive,
 			     ),
 
 	    TP_fast_assign(
-		    __entry->obj	= obj->fscache.debug_id;
+		    __entry->obj	= obj->debug_id;
 		    __entry->de		= de;
 		    __entry->inode	= inode;
 			   ),
diff --git a/include/trace/events/fscache.h b/include/trace/events/fscache.h
index eac561d3ac51..412f016f6975 100644
--- a/include/trace/events/fscache.h
+++ b/include/trace/events/fscache.h
@@ -228,7 +228,7 @@ TRACE_EVENT(fscache_disable,
 	    );
 
 TRACE_EVENT(fscache_osm,
-	    TP_PROTO(struct fscache_object *object,
+	    TP_PROTO(struct cachefiles_object *object,
 		     const struct fscache_state *state,
 		     bool wait, bool oob, s8 event_num),