fscache: Provide a function to resize a cookie

Provide a function to change the size of the storage attached to a cookie,
to match the size of the file being cached when it's changed by truncate or
fallocate:

	void fscache_resize_cookie(struct fscache_cookie *cookie,
				   loff_t new_size);

This acts synchronously and is expected to run under the inode lock of the
caller.

Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
cc: linux-cachefs@redhat.com
Link: https://lore.kernel.org/r/163819621839.215744.7895597119803515402.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/163906922387.143852.16394459879816147793.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/163967128998.1823006.10740669081985775576.stgit@warthog.procyon.org.uk/
Link: https://lore.kernel.org/r/164021527861.640689.3466382085497236267.stgit@warthog.procyon.org.uk/

diff --git a/fs/fscache/internal.h b/fs/fscache/internal.h
index 017bf3d346a439c6e681a2066b7c8c01285682ca..f121c21590dcf2950f404d2d76ef32f998fa0425 100644 (file)
--- a/fs/fscache/internal.h
+++ b/fs/fscache/internal.h
@@ -122,6 +122,9 @@ extern atomic_t fscache_n_relinquishes;
 extern atomic_t fscache_n_relinquishes_retire;
 extern atomic_t fscache_n_relinquishes_dropped;
 
+extern atomic_t fscache_n_resizes;
+extern atomic_t fscache_n_resizes_null;
+
 static inline void fscache_stat(atomic_t *stat)
 {
        atomic_inc(stat);

diff --git a/fs/fscache/io.c b/fs/fscache/io.c
index e9e5d6758ea8bbe7aa200b7370115b7a75dd0f25..bed7628a5a9dabc6f06262ea5e0f99e4dcbb4d2c 100644 (file)
--- a/fs/fscache/io.c
+++ b/fs/fscache/io.c
@@ -291,3 +291,28 @@ abandon:
                term_func(term_func_priv, ret, false);
 }
 EXPORT_SYMBOL(__fscache_write_to_cache);
+
+/*
+ * Change the size of a backing object.
+ */
+void __fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
+{
+       struct netfs_cache_resources cres;
+
+       trace_fscache_resize(cookie, new_size);
+       if (fscache_begin_operation(&cres, cookie, FSCACHE_WANT_WRITE,
+                                   fscache_access_io_resize) == 0) {
+               fscache_stat(&fscache_n_resizes);
+               set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &cookie->flags);
+
+               /* We cannot defer a resize as we need to do it inside the
+                * netfs's inode lock so that we're serialised with respect to
+                * writes.
+                */
+               cookie->volume->cache->ops->resize_cookie(&cres, new_size);
+               fscache_end_operation(&cres);
+       } else {
+               fscache_stat(&fscache_n_resizes_null);
+       }
+}
+EXPORT_SYMBOL(__fscache_resize_cookie);

diff --git a/fs/fscache/stats.c b/fs/fscache/stats.c
index db42beb1ba3fc41abd00751034f61a8e7d5adb35..798ee68b3e9dd47c0aff7c524fa47008a128fe68 100644 (file)
--- a/fs/fscache/stats.c
+++ b/fs/fscache/stats.c
@@ -35,6 +35,9 @@ atomic_t fscache_n_relinquishes;
 atomic_t fscache_n_relinquishes_retire;
 atomic_t fscache_n_relinquishes_dropped;
 
+atomic_t fscache_n_resizes;
+atomic_t fscache_n_resizes_null;
+
 atomic_t fscache_n_read;
 EXPORT_SYMBOL(fscache_n_read);
 atomic_t fscache_n_write;
@@ -69,8 +72,10 @@ int fscache_stats_show(struct seq_file *m, void *v)
        seq_printf(m, "Invals : n=%u\n",
                   atomic_read(&fscache_n_invalidates));
 
-       seq_printf(m, "Updates: n=%u\n",
-                  atomic_read(&fscache_n_updates));
+       seq_printf(m, "Updates: n=%u rsz=%u rsn=%u\n",
+                  atomic_read(&fscache_n_updates),
+                  atomic_read(&fscache_n_resizes),
+                  atomic_read(&fscache_n_resizes_null));
 
        seq_printf(m, "Relinqs: n=%u rtr=%u drop=%u\n",
                   atomic_read(&fscache_n_relinquishes),

diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 796c8b5c5305c00267e50437049f5fd2906dca9f..3fa4902dc87c713d4f313ed0c88363c6fd12c33e 100644 (file)
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -64,6 +64,10 @@ struct fscache_cache_ops {
        /* Withdraw an object without any cookie access counts held */
        void (*withdraw_cookie)(struct fscache_cookie *cookie);
 
+       /* Change the size of a data object */
+       void (*resize_cookie)(struct netfs_cache_resources *cres,
+                             loff_t new_size);
+
        /* Invalidate an object */
        bool (*invalidate_cookie)(struct fscache_cookie *cookie);
 

diff --git a/include/linux/fscache.h b/include/linux/fscache.h
index 28ce258c1f871f6b8849e9106ec7662a80e42703..86b1c0db1de5704b6e88cf512c64f95348640157 100644 (file)
--- a/include/linux/fscache.h
+++ b/include/linux/fscache.h
@@ -163,6 +163,7 @@ extern struct fscache_cookie *__fscache_acquire_cookie(
 extern void __fscache_use_cookie(struct fscache_cookie *, bool);
 extern void __fscache_unuse_cookie(struct fscache_cookie *, const void *, const loff_t *);
 extern void __fscache_relinquish_cookie(struct fscache_cookie *, bool);
+extern void __fscache_resize_cookie(struct fscache_cookie *, loff_t);
 extern void __fscache_invalidate(struct fscache_cookie *, const void *, loff_t, unsigned int);
 extern int __fscache_begin_read_operation(struct netfs_cache_resources *, struct fscache_cookie *);
 
@@ -366,6 +367,23 @@ void fscache_update_cookie(struct fscache_cookie *cookie, const void *aux_data,
                __fscache_update_cookie(cookie, aux_data, object_size);
 }
 
+/**
+ * fscache_resize_cookie - Request that a cache object be resized
+ * @cookie: The cookie representing the cache object
+ * @new_size: The new size of the object (may be NULL)
+ *
+ * Request that the size of an object be changed.
+ *
+ * See Documentation/filesystems/caching/netfs-api.txt for a complete
+ * description.
+ */
+static inline
+void fscache_resize_cookie(struct fscache_cookie *cookie, loff_t new_size)
+{
+       if (fscache_cookie_enabled(cookie))
+               __fscache_resize_cookie(cookie, new_size);
+}
+
 /**
  * fscache_invalidate - Notify cache that an object needs invalidation
  * @cookie: The cookie representing the cache object

diff --git a/include/trace/events/fscache.h b/include/trace/events/fscache.h
index 2459d75659cf346b4383fa0caeb125306c9037b9..5fa37a8b4ec7e0b1f9f7c43f806589388600e2c1 100644 (file)
--- a/include/trace/events/fscache.h
+++ b/include/trace/events/fscache.h
@@ -78,6 +78,7 @@ enum fscache_access_trace {
        fscache_access_invalidate_cookie_end,
        fscache_access_io_not_live,
        fscache_access_io_read,
+       fscache_access_io_resize,
        fscache_access_io_wait,
        fscache_access_io_write,
        fscache_access_lookup_cookie,
@@ -149,6 +150,7 @@ enum fscache_access_trace {
        EM(fscache_access_invalidate_cookie_end,"END   inval  ")        \
        EM(fscache_access_io_not_live,          "END   io_notl")        \
        EM(fscache_access_io_read,              "BEGIN io_read")        \
+       EM(fscache_access_io_resize,            "BEGIN io_resz")        \
        EM(fscache_access_io_wait,              "WAIT  io     ")        \
        EM(fscache_access_io_write,             "BEGIN io_writ")        \
        EM(fscache_access_lookup_cookie,        "BEGIN lookup ")        \
@@ -418,6 +420,29 @@ TRACE_EVENT(fscache_invalidate,
                      __entry->cookie, __entry->new_size)
            );
 
+TRACE_EVENT(fscache_resize,
+           TP_PROTO(struct fscache_cookie *cookie, loff_t new_size),
+
+           TP_ARGS(cookie, new_size),
+
+           TP_STRUCT__entry(
+                   __field(unsigned int,               cookie          )
+                   __field(loff_t,                     old_size        )
+                   __field(loff_t,                     new_size        )
+                            ),
+
+           TP_fast_assign(
+                   __entry->cookie     = cookie->debug_id;
+                   __entry->old_size   = cookie->object_size;
+                   __entry->new_size   = new_size;
+                          ),
+
+           TP_printk("c=%08x os=%08llx sz=%08llx",
+                     __entry->cookie,
+                     __entry->old_size,
+                     __entry->new_size)
+           );
+
 #endif /* _TRACE_FSCACHE_H */
 
 /* This part must be outside protection */