All of lore.kernel.org
 help / color / mirror / Atom feed
From: Jeff Layton <jlayton@kernel.org>
To: David Howells <dhowells@redhat.com>, linux-cachefs@redhat.com
Cc: Trond Myklebust <trondmy@hammerspace.com>,
	Anna Schumaker <anna.schumaker@netapp.com>,
	Steve French <sfrench@samba.org>,
	Dominique Martinet <asmadeus@codewreck.org>,
	Matthew Wilcox <willy@infradead.org>,
	Alexander Viro <viro@zeniv.linux.org.uk>,
	Omar Sandoval <osandov@osandov.com>,
	JeffleXu <jefflexu@linux.alibaba.com>,
	Linus Torvalds <torvalds@linux-foundation.org>,
	linux-afs@lists.infradead.org, linux-nfs@vger.kernel.org,
	linux-cifs@vger.kernel.org, ceph-devel@vger.kernel.org,
	v9fs-developer@lists.sourceforge.net,
	linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: Re: [PATCH v2 08/67] fscache: Implement cache registration
Date: Tue, 14 Dec 2021 13:36:58 -0500	[thread overview]
Message-ID: <a23a1638bd39fdc314d36482a3155ca7b800a045.camel@kernel.org> (raw)
In-Reply-To: <163906889665.143852.10378009165231294456.stgit@warthog.procyon.org.uk>

On Thu, 2021-12-09 at 16:54 +0000, David Howells wrote:
> Implement a register of caches and provide functions to manage it.
> 
> Two functions are provided for the cache backend to use:
> 
>  (1) Acquire a cache cookie:
> 
> 	struct fscache_cache *fscache_acquire_cache(const char *name)
> 
>      This gets the cache cookie for a cache of the specified name and moves
>      it to the preparation state.  If a nameless cache cookie exists, that
>      will be given this name and used.
> 
>  (2) Relinquish a cache cookie:
> 
> 	void fscache_relinquish_cache(struct fscache_cache *cache);
> 
>      This relinquishes a cache cookie, cleans it and makes it available if
>      it's still referenced by a network filesystem.
> 
> Note that network filesystems don't deal with cache cookies directly, but
> rather go straight to the volume registration.

This final sentence is a bit vague. Netfs's do need to _track_ fscache
cookies (generally on a per-inode basis). I get that you mean that they
don't have to deal with cookies that refer to caches. Maybe the term
cookie is just overloaded here. ;)

> 
> Signed-off-by: David Howells <dhowells@redhat.com>
> cc: linux-cachefs@redhat.com
> Link: https://lore.kernel.org/r/163819587157.215744.13523139317322503286.stgit@warthog.procyon.org.uk/ # v1
> ---
> 
>  fs/fscache/Makefile            |    1 
>  fs/fscache/cache.c             |  274 ++++++++++++++++++++++++++++++++++++++++
>  fs/fscache/internal.h          |   33 +++++
>  fs/fscache/proc.c              |    4 +
>  include/linux/fscache-cache.h  |   34 +++++
>  include/trace/events/fscache.h |   43 ++++++
>  6 files changed, 389 insertions(+)
>  create mode 100644 fs/fscache/cache.c
> 
> diff --git a/fs/fscache/Makefile b/fs/fscache/Makefile
> index f9722de32247..d9fc22c18090 100644
> --- a/fs/fscache/Makefile
> +++ b/fs/fscache/Makefile
> @@ -4,6 +4,7 @@
>  #
>  
>  fscache-y := \
> +	cache.o \
>  	main.o
>  
>  fscache-$(CONFIG_PROC_FS) += proc.o
> diff --git a/fs/fscache/cache.c b/fs/fscache/cache.c
> new file mode 100644
> index 000000000000..8db77bb9f8e2
> --- /dev/null
> +++ b/fs/fscache/cache.c
> @@ -0,0 +1,274 @@
> +// SPDX-License-Identifier: GPL-2.0-or-later
> +/* FS-Cache cache handling
> + *
> + * Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
> + * Written by David Howells (dhowells@redhat.com)
> + */
> +
> +#define FSCACHE_DEBUG_LEVEL CACHE
> +#include <linux/export.h>
> +#include <linux/slab.h>
> +#include "internal.h"
> +
> +static LIST_HEAD(fscache_caches);
> +DECLARE_RWSEM(fscache_addremove_sem);
> +EXPORT_SYMBOL(fscache_addremove_sem);
> +
> +static atomic_t fscache_cache_debug_id;
> +
> +/*
> + * Allocate a cache cookie.
> + */
> +static struct fscache_cache *fscache_alloc_cache(const char *name)
> +{
> +	struct fscache_cache *cache;
> +
> +	cache = kzalloc(sizeof(*cache), GFP_KERNEL);
> +	if (cache) {
> +		if (name) {
> +			cache->name = kstrdup(name, GFP_KERNEL);
> +			if (!cache->name) {
> +				kfree(cache);
> +				return NULL;
> +			}
> +		}
> +		refcount_set(&cache->ref, 1);
> +		INIT_LIST_HEAD(&cache->cache_link);
> +		cache->debug_id = atomic_inc_return(&fscache_cache_debug_id);
> +	}
> +	return cache;
> +}
> +
> +static bool fscache_get_cache_maybe(struct fscache_cache *cache,
> +				    enum fscache_cache_trace where)
> +{
> +	bool success;
> +	int ref;
> +
> +	success = __refcount_inc_not_zero(&cache->ref, &ref);
> +	if (success)
> +		trace_fscache_cache(cache->debug_id, ref + 1, where);
> +	return success;
> +}
> +
> +/*
> + * Look up a cache cookie.
> + */
> +struct fscache_cache *fscache_lookup_cache(const char *name, bool is_cache)
> +{
> +	struct fscache_cache *candidate, *cache, *unnamed = NULL;
> +
> +	/* firstly check for the existence of the cache under read lock */
> +	down_read(&fscache_addremove_sem);
> +
> +	list_for_each_entry(cache, &fscache_caches, cache_link) {
> +		if (cache->name && name && strcmp(cache->name, name) == 0 &&
> +		    fscache_get_cache_maybe(cache, fscache_cache_get_acquire))
> +			goto got_cache_r;
> +		if (!cache->name && !name &&
> +		    fscache_get_cache_maybe(cache, fscache_cache_get_acquire))
> +			goto got_cache_r;
> +	}
> +
> +	if (!name) {
> +		list_for_each_entry(cache, &fscache_caches, cache_link) {
> +			if (cache->name &&
> +			    fscache_get_cache_maybe(cache, fscache_cache_get_acquire))
> +				goto got_cache_r;
> +		}
> +	}
> +
> +	up_read(&fscache_addremove_sem);
> +
> +	/* the cache does not exist - create a candidate */
> +	candidate = fscache_alloc_cache(name);
> +	if (!candidate)
> +		return ERR_PTR(-ENOMEM);
> +
> +	/* write lock, search again and add if still not present */
> +	down_write(&fscache_addremove_sem);
> +
> +	list_for_each_entry(cache, &fscache_caches, cache_link) {
> +		if (cache->name && name && strcmp(cache->name, name) == 0 &&
> +		    fscache_get_cache_maybe(cache, fscache_cache_get_acquire))
> +			goto got_cache_w;
> +		if (!cache->name) {
> +			unnamed = cache;
> +			if (!name &&
> +			    fscache_get_cache_maybe(cache, fscache_cache_get_acquire))
> +				goto got_cache_w;
> +		}
> +	}
> +
> +	if (unnamed && is_cache &&
> +	    fscache_get_cache_maybe(unnamed, fscache_cache_get_acquire))
> +		goto use_unnamed_cache;
> +
> +	if (!name) {
> +		list_for_each_entry(cache, &fscache_caches, cache_link) {
> +			if (cache->name &&
> +			    fscache_get_cache_maybe(cache, fscache_cache_get_acquire))
> +				goto got_cache_w;
> +		}
> +	}
> +
> +	list_add_tail(&candidate->cache_link, &fscache_caches);
> +	trace_fscache_cache(candidate->debug_id,
> +			    refcount_read(&candidate->ref),
> +			    fscache_cache_new_acquire);
> +	up_write(&fscache_addremove_sem);
> +	return candidate;
> +
> +got_cache_r:
> +	up_read(&fscache_addremove_sem);
> +	return cache;
> +use_unnamed_cache:
> +	cache = unnamed;
> +	cache->name = candidate->name;
> +	candidate->name = NULL;
> +got_cache_w:
> +	up_write(&fscache_addremove_sem);
> +	kfree(candidate->name);
> +	kfree(candidate);
> +	return cache;
> +}
> +
> +/**
> + * fscache_acquire_cache - Acquire a cache-level cookie.
> + * @name: The name of the cache.
> + *
> + * Get a cookie to represent an actual cache.  If a name is given and there is
> + * a nameless cache record available, this will acquire that and set its name,
> + * directing all the volumes using it to this cache.
> + *
> + * The cache will be switched over to the preparing state if not currently in
> + * use, otherwise -EBUSY will be returned.
> + */
> +struct fscache_cache *fscache_acquire_cache(const char *name)
> +{
> +	struct fscache_cache *cache;
> +
> +	ASSERT(name);
> +	cache = fscache_lookup_cache(name, true);
> +	if (IS_ERR(cache))
> +		return cache;
> +
> +	if (!fscache_set_cache_state_maybe(cache,
> +					   FSCACHE_CACHE_IS_NOT_PRESENT,
> +					   FSCACHE_CACHE_IS_PREPARING)) {
> +		pr_warn("Cache tag %s in use\n", name);
> +		fscache_put_cache(cache, fscache_cache_put_cache);
> +		return ERR_PTR(-EBUSY);
> +	}
> +
> +	return cache;
> +}
> +EXPORT_SYMBOL(fscache_acquire_cache);
> +
> +/**
> + * fscache_put_cache - Release a cache-level cookie.
> + * @cache: The cache cookie to be released
> + * @where: An indication of where the release happened
> + *
> + * Release the caller's reference on a cache-level cookie.  The @where
> + * indication should give information about the circumstances in which the call
> + * occurs and will be logged through a tracepoint.
> + */
> +void fscache_put_cache(struct fscache_cache *cache,
> +		       enum fscache_cache_trace where)
> +{
> +	unsigned int debug_id = cache->debug_id;
> +	bool zero;
> +	int ref;
> +
> +	if (IS_ERR_OR_NULL(cache))
> +		return;
> +
> +	zero = __refcount_dec_and_test(&cache->ref, &ref);
> +	trace_fscache_cache(debug_id, ref - 1, where);
> +
> +	if (zero) {
> +		down_write(&fscache_addremove_sem);
> +		list_del_init(&cache->cache_link);
> +		up_write(&fscache_addremove_sem);
> +		kfree(cache->name);
> +		kfree(cache);
> +	}
> +}
> +
> +/**
> + * fscache_relinquish_cache - Reset cache state and release cookie
> + * @cache: The cache cookie to be released
> + *
> + * Reset the state of a cache and release the caller's reference on a cache
> + * cookie.
> + */
> +void fscache_relinquish_cache(struct fscache_cache *cache)
> +{
> +	enum fscache_cache_trace where =
> +		(cache->state == FSCACHE_CACHE_IS_PREPARING) ?
> +		fscache_cache_put_prep_failed :
> +		fscache_cache_put_relinquish;
> +
> +	cache->cache_priv = NULL;
> +	smp_store_release(&cache->state, FSCACHE_CACHE_IS_NOT_PRESENT);
> +	fscache_put_cache(cache, where);
> +}
> +EXPORT_SYMBOL(fscache_relinquish_cache);
> +
> +#ifdef CONFIG_PROC_FS
> +static const char fscache_cache_states[NR__FSCACHE_CACHE_STATE] = "-PAEW";
> +
> +/*
> + * Generate a list of caches in /proc/fs/fscache/caches
> + */
> +static int fscache_caches_seq_show(struct seq_file *m, void *v)
> +{
> +	struct fscache_cache *cache;
> +
> +	if (v == &fscache_caches) {
> +		seq_puts(m,
> +			 "CACHE    REF   VOLS  OBJS  ACCES S NAME\n"
> +			 "======== ===== ===== ===== ===== = ===============\n"
> +			 );
> +		return 0;
> +	}
> +
> +	cache = list_entry(v, struct fscache_cache, cache_link);
> +	seq_printf(m,
> +		   "%08x %5d %5d %5d %5d %c %s\n",
> +		   cache->debug_id,
> +		   refcount_read(&cache->ref),
> +		   atomic_read(&cache->n_volumes),
> +		   atomic_read(&cache->object_count),
> +		   atomic_read(&cache->n_accesses),
> +		   fscache_cache_states[cache->state],
> +		   cache->name ?: "-");
> +	return 0;
> +}
> +
> +static void *fscache_caches_seq_start(struct seq_file *m, loff_t *_pos)
> +	__acquires(fscache_addremove_sem)
> +{
> +	down_read(&fscache_addremove_sem);
> +	return seq_list_start_head(&fscache_caches, *_pos);
> +}
> +
> +static void *fscache_caches_seq_next(struct seq_file *m, void *v, loff_t *_pos)
> +{
> +	return seq_list_next(v, &fscache_caches, _pos);
> +}
> +
> +static void fscache_caches_seq_stop(struct seq_file *m, void *v)
> +	__releases(fscache_addremove_sem)
> +{
> +	up_read(&fscache_addremove_sem);
> +}
> +
> +const struct seq_operations fscache_caches_seq_ops = {
> +	.start  = fscache_caches_seq_start,
> +	.next   = fscache_caches_seq_next,
> +	.stop   = fscache_caches_seq_stop,
> +	.show   = fscache_caches_seq_show,
> +};
> +#endif /* CONFIG_PROC_FS */
> diff --git a/fs/fscache/internal.h b/fs/fscache/internal.h
> index 64767992bd15..2788435361f9 100644
> --- a/fs/fscache/internal.h
> +++ b/fs/fscache/internal.h
> @@ -17,6 +17,39 @@
>  #include <linux/sched.h>
>  #include <linux/seq_file.h>
>  
> +/*
> + * cache.c
> + */
> +#ifdef CONFIG_PROC_FS
> +extern const struct seq_operations fscache_caches_seq_ops;
> +#endif
> +struct fscache_cache *fscache_lookup_cache(const char *name, bool is_cache);
> +void fscache_put_cache(struct fscache_cache *cache, enum fscache_cache_trace where);
> +
> +static inline enum fscache_cache_state fscache_cache_state(const struct fscache_cache *cache)
> +{
> +	return smp_load_acquire(&cache->state);
> +}
> +
> +static inline bool fscache_cache_is_live(const struct fscache_cache *cache)
> +{
> +	return fscache_cache_state(cache) == FSCACHE_CACHE_IS_ACTIVE;
> +}
> +
> +static inline void fscache_set_cache_state(struct fscache_cache *cache,
> +					   enum fscache_cache_state new_state)
> +{
> +	smp_store_release(&cache->state, new_state);
> +
> +}
> +
> +static inline bool fscache_set_cache_state_maybe(struct fscache_cache *cache,
> +						 enum fscache_cache_state old_state,
> +						 enum fscache_cache_state new_state)
> +{
> +	return try_cmpxchg_release(&cache->state, &old_state, new_state);
> +}
> +
>  /*
>   * main.c
>   */
> diff --git a/fs/fscache/proc.c b/fs/fscache/proc.c
> index b28003d7d63f..7400568bf85e 100644
> --- a/fs/fscache/proc.c
> +++ b/fs/fscache/proc.c
> @@ -19,6 +19,10 @@ int __init fscache_proc_init(void)
>  	if (!proc_mkdir("fs/fscache", NULL))
>  		goto error_dir;
>  
> +	if (!proc_create_seq("fs/fscache/caches", S_IFREG | 0444, NULL,
> +			     &fscache_caches_seq_ops))
> +		goto error;
> +
>  #ifdef CONFIG_FSCACHE_STATS
>  	if (!proc_create_single("fs/fscache/stats", S_IFREG | 0444, NULL,
>  				fscache_stats_show))
> diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
> index d6910a913918..18cd5c9877bb 100644
> --- a/include/linux/fscache-cache.h
> +++ b/include/linux/fscache-cache.h
> @@ -16,6 +16,40 @@
>  
>  #include <linux/fscache.h>
>  
> +enum fscache_cache_trace;
> +enum fscache_access_trace;
> +
> +enum fscache_cache_state {
> +	FSCACHE_CACHE_IS_NOT_PRESENT,	/* No cache is present for this name */
> +	FSCACHE_CACHE_IS_PREPARING,	/* A cache is preparing to come live */
> +	FSCACHE_CACHE_IS_ACTIVE,	/* Attached cache is active and can be used */
> +	FSCACHE_CACHE_GOT_IOERROR,	/* Attached cache stopped on I/O error */
> +	FSCACHE_CACHE_IS_WITHDRAWN,	/* Attached cache is being withdrawn */
> +#define NR__FSCACHE_CACHE_STATE (FSCACHE_CACHE_IS_WITHDRAWN + 1)
> +};
> +
> +/*
> + * Cache cookie.
> + */
> +struct fscache_cache {
> +	struct list_head	cache_link;	/* Link in cache list */
> +	void			*cache_priv;	/* Private cache data (or NULL) */
> +	refcount_t		ref;
> +	atomic_t		n_volumes;	/* Number of active volumes; */
> +	atomic_t		n_accesses;	/* Number of in-progress accesses on the cache */
> +	atomic_t		object_count;	/* no. of live objects in this cache */
> +	unsigned int		debug_id;
> +	enum fscache_cache_state state;
> +	char			*name;
> +};
> +
>  extern struct workqueue_struct *fscache_wq;
>  
> +/*
> + * out-of-line cache backend functions
> + */
> +extern struct rw_semaphore fscache_addremove_sem;
> +extern struct fscache_cache *fscache_acquire_cache(const char *name);
> +extern void fscache_relinquish_cache(struct fscache_cache *cache);
> +
>  #endif /* _LINUX_FSCACHE_CACHE_H */
> diff --git a/include/trace/events/fscache.h b/include/trace/events/fscache.h
> index fe214c5cc87f..3b8e0597b2c1 100644
> --- a/include/trace/events/fscache.h
> +++ b/include/trace/events/fscache.h
> @@ -19,11 +19,27 @@
>  #ifndef __FSCACHE_DECLARE_TRACE_ENUMS_ONCE_ONLY
>  #define __FSCACHE_DECLARE_TRACE_ENUMS_ONCE_ONLY
>  
> +enum fscache_cache_trace {
> +	fscache_cache_collision,
> +	fscache_cache_get_acquire,
> +	fscache_cache_new_acquire,
> +	fscache_cache_put_cache,
> +	fscache_cache_put_prep_failed,
> +	fscache_cache_put_relinquish,
> +};
> +
>  #endif
>  
>  /*
>   * Declare tracing information enums and their string mappings for display.
>   */
> +#define fscache_cache_traces						\
> +	EM(fscache_cache_collision,		"*COLLIDE*")		\
> +	EM(fscache_cache_get_acquire,		"GET acq  ")		\
> +	EM(fscache_cache_new_acquire,		"NEW acq  ")		\
> +	EM(fscache_cache_put_cache,		"PUT cache")		\
> +	EM(fscache_cache_put_prep_failed,	"PUT pfail")		\
> +	E_(fscache_cache_put_relinquish,	"PUT relnq")
>  
>  /*
>   * Export enum symbols via userspace.
> @@ -33,6 +49,8 @@
>  #define EM(a, b) TRACE_DEFINE_ENUM(a);
>  #define E_(a, b) TRACE_DEFINE_ENUM(a);
>  
> +fscache_cache_traces;
> +
>  /*
>   * Now redefine the EM() and E_() macros to map the enums to the strings that
>   * will be printed in the output.
> @@ -43,6 +61,31 @@
>  #define E_(a, b)	{ a, b }
>  
>  
> +TRACE_EVENT(fscache_cache,
> +	    TP_PROTO(unsigned int cache_debug_id,
> +		     int usage,
> +		     enum fscache_cache_trace where),
> +
> +	    TP_ARGS(cache_debug_id, usage, where),
> +
> +	    TP_STRUCT__entry(
> +		    __field(unsigned int,		cache		)
> +		    __field(int,			usage		)
> +		    __field(enum fscache_cache_trace,	where		)
> +			     ),
> +
> +	    TP_fast_assign(
> +		    __entry->cache	= cache_debug_id;
> +		    __entry->usage	= usage;
> +		    __entry->where	= where;
> +			   ),
> +
> +	    TP_printk("C=%08x %s r=%d",
> +		      __entry->cache,
> +		      __print_symbolic(__entry->where, fscache_cache_traces),
> +		      __entry->usage)
> +	    );
> +
>  #endif /* _TRACE_FSCACHE_H */
>  
>  /* This part must be outside protection */
> 
> 

-- 
Jeff Layton <jlayton@kernel.org>

  reply	other threads:[~2021-12-14 18:37 UTC|newest]

Thread overview: 88+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2021-12-09 16:53 [PATCH v2 00/67] fscache, cachefiles: Rewrite David Howells
2021-12-09 16:53 ` [PATCH v2 01/67] fscache, cachefiles: Disable configuration David Howells
2021-12-09 16:53 ` [PATCH v2 02/67] cachefiles: Delete the cachefiles driver pending rewrite David Howells
2021-12-09 16:54 ` [PATCH v2 03/67] fscache: Remove the contents of the fscache driver, " David Howells
2021-12-09 16:54 ` [PATCH v2 04/67] netfs: Display the netfs inode number in the netfs_read tracepoint David Howells
2021-12-09 16:54 ` [PATCH v2 05/67] netfs: Pass a flag to ->prepare_write() to say if there's no alloc'd space David Howells
2021-12-09 16:54 ` [PATCH v2 06/67] fscache: Introduce new driver David Howells
2021-12-09 16:54 ` [PATCH v2 07/67] fscache: Implement a hash function David Howells
2021-12-09 17:12   ` Linus Torvalds
2021-12-09 21:57   ` David Howells
2021-12-09 22:07     ` Linus Torvalds
2021-12-10 14:35     ` David Howells
2021-12-10 14:41     ` David Howells
2021-12-10 17:33       ` Linus Torvalds
2021-12-09 16:54 ` [PATCH v2 08/67] fscache: Implement cache registration David Howells
2021-12-14 18:36   ` Jeff Layton [this message]
2021-12-09 16:55 ` [PATCH v2 09/67] fscache: Implement volume registration David Howells
2021-12-09 17:32   ` Linus Torvalds
2021-12-14 18:52   ` Jeff Layton
2021-12-14 19:57   ` David Howells
2021-12-09 16:55 ` [PATCH v2 10/67] fscache: Implement cookie registration David Howells
2021-12-09 17:21   ` Linus Torvalds
2021-12-09 16:55 ` [PATCH v2 11/67] fscache: Implement cache-level access helpers David Howells
2021-12-09 16:55 ` [PATCH v2 12/67] fscache: Implement volume-level " David Howells
2021-12-09 16:55 ` [PATCH v2 13/67] fscache: Implement cookie-level " David Howells
2021-12-09 16:56 ` [PATCH v2 14/67] fscache: Implement functions add/remove a cache David Howells
2021-12-09 16:56 ` [PATCH v2 15/67] fscache: Provide and use cache methods to lookup/create/free a volume David Howells
2021-12-09 16:56 ` [PATCH v2 16/67] fscache: Add a function for a cache backend to note an I/O error David Howells
2021-12-09 16:57 ` [PATCH v2 17/67] fscache: Implement simple cookie state machine David Howells
2021-12-09 16:57 ` [PATCH v2 18/67] fscache: Implement cookie user counting and resource pinning David Howells
2021-12-09 16:58 ` [PATCH v2 19/67] fscache: Implement cookie invalidation David Howells
2021-12-09 16:58 ` [PATCH v2 20/67] fscache: Provide a means to begin an operation David Howells
2021-12-09 16:58 ` [PATCH v2 21/67] fscache: Count data storage objects in a cache David Howells
2021-12-09 16:58 ` [PATCH v2 22/67] fscache: Provide read/write stat counters for the cache David Howells
2021-12-09 16:58 ` [PATCH v2 23/67] fscache: Provide a function to let the netfs update its coherency data David Howells
2021-12-09 16:59 ` [PATCH v2 24/67] netfs: Pass more information on how to deal with a hole in the cache David Howells
2021-12-09 16:59 ` [PATCH v2 25/67] fscache: Implement raw I/O interface David Howells
2021-12-09 16:59 ` [PATCH v2 26/67] fscache: Implement higher-level write " David Howells
2021-12-09 16:59 ` [PATCH v2 27/67] vfs, fscache: Implement pinning of cache usage for writeback David Howells
2021-12-09 17:00 ` [PATCH v2 28/67] fscache: Provide a function to note the release of a page David Howells
2021-12-09 17:00 ` [PATCH v2 29/67] fscache: Provide a function to resize a cookie David Howells
2021-12-09 17:00 ` [PATCH v2 30/67] cachefiles: Introduce rewritten driver David Howells
2021-12-09 17:00 ` [PATCH v2 31/67] cachefiles: Define structs David Howells
2021-12-09 17:00 ` [PATCH v2 32/67] cachefiles: Add some error injection support David Howells
2021-12-09 17:01 ` [PATCH v2 33/67] cachefiles: Add a couple of tracepoints for logging errors David Howells
2021-12-09 17:01 ` [PATCH v2 34/67] cachefiles: Add cache error reporting macro David Howells
2021-12-09 17:01 ` [PATCH v2 35/67] cachefiles: Add security derivation David Howells
2021-12-09 17:01 ` [PATCH v2 36/67] cachefiles: Register a miscdev and parse commands over it David Howells
2021-12-09 17:01 ` [PATCH v2 37/67] cachefiles: Provide a function to check how much space there is David Howells
2021-12-09 17:01 ` [PATCH v2 38/67] vfs, cachefiles: Mark a backing file in use with an inode flag David Howells
2021-12-09 17:02 ` [PATCH v2 39/67] cachefiles: Implement a function to get/create a directory in the cache David Howells
2021-12-09 17:02 ` [PATCH v2 40/67] cachefiles: Implement cache registration and withdrawal David Howells
2021-12-09 17:02 ` [PATCH v2 41/67] cachefiles: Implement volume support David Howells
2021-12-09 17:03 ` [PATCH v2 42/67] cachefiles: Add tracepoints for calls to the VFS David Howells
2021-12-09 17:03 ` [PATCH v2 43/67] cachefiles: Implement object lifecycle funcs David Howells
2021-12-09 17:03 ` [PATCH v2 44/67] cachefiles: Implement key to filename encoding David Howells
2021-12-09 17:03 ` [PATCH v2 45/67] cachefiles: Implement metadata/coherency data storage in xattrs David Howells
2021-12-09 17:03 ` [PATCH v2 46/67] cachefiles: Mark a backing file in use with an inode flag David Howells
2021-12-09 17:04 ` [PATCH v2 47/67] cachefiles: Implement culling daemon commands David Howells
2021-12-09 17:04 ` [PATCH v2 48/67] cachefiles: Implement backing file wrangling David Howells
2021-12-09 17:05 ` [PATCH v2 49/67] cachefiles: Implement begin and end I/O operation David Howells
2021-12-09 17:05 ` [PATCH v2 50/67] cachefiles: Implement cookie resize for truncate David Howells
2021-12-09 17:05 ` [PATCH v2 51/67] cachefiles: Implement the I/O routines David Howells
2021-12-09 17:06 ` [PATCH v2 52/67] cachefiles: Allow cachefiles to actually function David Howells
2021-12-09 17:06 ` [PATCH v2 53/67] fscache, cachefiles: Display stats of no-space events David Howells
2021-12-09 17:06 ` [PATCH v2 54/67] fscache, cachefiles: Display stat of culling events David Howells
2021-12-09 17:07 ` [PATCH v2 55/67] afs: Handle len being extending over page end in write_begin/write_end David Howells
2021-12-09 17:08 ` [PATCH v2 56/67] afs: Fix afs_write_end() to handle len > page size David Howells
2021-12-09 17:08 ` [PATCH v2 57/67] afs: Convert afs to use the new fscache API David Howells
2021-12-09 17:08 ` [PATCH v2 58/67] afs: Copy local writes to the cache when writing to the server David Howells
2021-12-09 17:08 ` [PATCH v2 59/67] afs: Skip truncation on the server of data we haven't written yet David Howells
2021-12-09 17:09 ` [PATCH v2 60/67] 9p: Use fscache indexing rewrite and reenable caching David Howells
2021-12-09 17:09 ` [PATCH v2 61/67] 9p: Copy local writes to the cache when writing to the server David Howells
2021-12-09 17:09 ` [PATCH v2 62/67] nfs: Convert to new fscache volume/cookie API David Howells
2021-12-11 13:22   ` David Wysochanski
2021-12-11 13:37   ` David Howells
2021-12-09 17:10 ` [PATCH v2 63/67] nfs: Implement cache I/O by accessing the cache directly David Howells
2021-12-09 17:10 ` [PATCH v2 64/67] cifs: Support fscache indexing rewrite (untested) David Howells
2021-12-09 17:10 ` [PATCH v2 65/67] ceph: conversion to new fscache API David Howells
2021-12-09 17:10 ` [PATCH v2 66/67] ceph: add fscache writeback support David Howells
2021-12-09 17:11 ` [PATCH v2 67/67] fscache: Rewrite documentation David Howells
2021-12-10 18:38 ` [PATCH v2 00/67] fscache, cachefiles: Rewrite David Wysochanski
2021-12-11 13:44   ` David Wysochanski
2021-12-13 15:41   ` [PATCH] fscache: Need to go round again after processing LRU_DISCARDING state David Howells
2021-12-13 21:05     ` David Wysochanski
2021-12-13 16:22   ` David Howells
2021-12-13 20:03   ` David Howells
2021-12-13 22:39   ` David Howells

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=a23a1638bd39fdc314d36482a3155ca7b800a045.camel@kernel.org \
    --to=jlayton@kernel.org \
    --cc=anna.schumaker@netapp.com \
    --cc=asmadeus@codewreck.org \
    --cc=ceph-devel@vger.kernel.org \
    --cc=dhowells@redhat.com \
    --cc=jefflexu@linux.alibaba.com \
    --cc=linux-afs@lists.infradead.org \
    --cc=linux-cachefs@redhat.com \
    --cc=linux-cifs@vger.kernel.org \
    --cc=linux-fsdevel@vger.kernel.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=linux-nfs@vger.kernel.org \
    --cc=osandov@osandov.com \
    --cc=sfrench@samba.org \
    --cc=torvalds@linux-foundation.org \
    --cc=trondmy@hammerspace.com \
    --cc=v9fs-developer@lists.sourceforge.net \
    --cc=viro@zeniv.linux.org.uk \
    --cc=willy@infradead.org \
    --subject='Re: [PATCH v2 08/67] fscache: Implement cache registration' \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.