FS-Cache: Permit cache retrieval ops to be interrupted in the initial wait phase

Permit the operations to retrieve data from the cache or to allocate space in
the cache for future writes to be interrupted whilst they're waiting for
permission for the operation to proceed.  Typically this wait occurs whilst the
cache object is being looked up on disk in the background.

If an interruption occurs, and the operation has not yet been given the
go-ahead to run, the operation is dequeued and cancelled, and control returns
to the read operation of the netfs routine with none of the requested pages
having been read or in any way marked as known by the cache.

This means that the initial wait is done interruptibly rather than
uninterruptibly.

In addition, extra stats values are made available to show the number of ops
cancelled and the number of cache space allocations interrupted.

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

1 files changed, 48 insertions, 7 deletions

diff --git a/fs/fscache/page.c b/fs/fscache/page.c
index 250dfd34c07b..e6f2e61133a1 100644
--- a/fs/fscache/page.c
+++ b/fs/fscache/page.c
@@ -295,8 +295,20 @@ int __fscache_read_or_alloc_page(struct fscache_cookie *cookie,
         if (test_bit(FSCACHE_OP_WAITING, &op->op.flags)) {
                 _debug(">>> WT");
                 fscache_stat(&fscache_n_retrieval_op_waits);
-                wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
-                            fscache_wait_bit, TASK_UNINTERRUPTIBLE);
+                if (wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
+                                fscache_wait_bit_interruptible,
+                                TASK_INTERRUPTIBLE) < 0) {
+                        ret = fscache_cancel_op(&op->op);
+                        if (ret == 0) {
+                                ret = -ERESTARTSYS;
+                                goto error;
+                        }
+
+                        /* it's been removed from the pending queue by another
+                         * party, so we should get to run shortly */
+                        wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
+                                    fscache_wait_bit, TASK_UNINTERRUPTIBLE);
+                }
                 _debug("<<< GO");
         }
 
@@ -313,6 +325,7 @@ int __fscache_read_or_alloc_page(struct fscache_cookie *cookie,
                 fscache_stat_d(&fscache_n_cop_read_or_alloc_page);
         }
 
+error:
         if (ret == -ENOMEM)
                 fscache_stat(&fscache_n_retrievals_nomem);
         else if (ret == -ERESTARTSYS)
@@ -412,8 +425,20 @@ int __fscache_read_or_alloc_pages(struct fscache_cookie *cookie,
         if (test_bit(FSCACHE_OP_WAITING, &op->op.flags)) {
                 _debug(">>> WT");
                 fscache_stat(&fscache_n_retrieval_op_waits);
-                wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
-                            fscache_wait_bit, TASK_UNINTERRUPTIBLE);
+                if (wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
+                                fscache_wait_bit_interruptible,
+                                TASK_INTERRUPTIBLE) < 0) {
+                        ret = fscache_cancel_op(&op->op);
+                        if (ret == 0) {
+                                ret = -ERESTARTSYS;
+                                goto error;
+                        }
+
+                        /* it's been removed from the pending queue by another
+                         * party, so we should get to run shortly */
+                        wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
+                                    fscache_wait_bit, TASK_UNINTERRUPTIBLE);
+                }
                 _debug("<<< GO");
         }
 
@@ -430,6 +455,7 @@ int __fscache_read_or_alloc_pages(struct fscache_cookie *cookie,
                 fscache_stat_d(&fscache_n_cop_read_or_alloc_pages);
         }
 
+error:
         if (ret == -ENOMEM)
                 fscache_stat(&fscache_n_retrievals_nomem);
         else if (ret == -ERESTARTSYS)
@@ -505,8 +531,20 @@ int __fscache_alloc_page(struct fscache_cookie *cookie,
         if (test_bit(FSCACHE_OP_WAITING, &op->op.flags)) {
                 _debug(">>> WT");
                 fscache_stat(&fscache_n_alloc_op_waits);
-                wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
-                            fscache_wait_bit, TASK_UNINTERRUPTIBLE);
+                if (wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
+                                fscache_wait_bit_interruptible,
+                                TASK_INTERRUPTIBLE) < 0) {
+                        ret = fscache_cancel_op(&op->op);
+                        if (ret == 0) {
+                                ret = -ERESTARTSYS;
+                                goto error;
+                        }
+
+                        /* it's been removed from the pending queue by another
+                         * party, so we should get to run shortly */
+                        wait_on_bit(&op->op.flags, FSCACHE_OP_WAITING,
+                                    fscache_wait_bit, TASK_UNINTERRUPTIBLE);
+                }
                 _debug("<<< GO");
         }
 
@@ -515,7 +553,10 @@ int __fscache_alloc_page(struct fscache_cookie *cookie,
         ret = object->cache->ops->allocate_page(op, page, gfp);
         fscache_stat_d(&fscache_n_cop_allocate_page);
 
-        if (ret < 0)
+error:
+        if (ret == -ERESTARTSYS)
+                fscache_stat(&fscache_n_allocs_intr);
+        else if (ret < 0)
                 fscache_stat(&fscache_n_allocs_nobufs);
         else
                 fscache_stat(&fscache_n_allocs_ok);