netfs, afs: Use writeback retry to deal with alternate keys

Use a hook in the new writeback code's retry algorithm to rotate the keys
once all the outstanding subreqs have failed rather than doing it
separately on each subreq.

Signed-off-by: David Howells <dhowells@redhat.com>
Reviewed-by: Jeff Layton <jlayton@kernel.org>
cc: Marc Dionne <marc.dionne@auristor.com>
cc: linux-afs@lists.infradead.org
cc: netfs@lists.linux.dev
cc: linux-fsdevel@vger.kernel.org

diff --git a/fs/afs/file.c b/fs/afs/file.c
index 8f983e3ecae7775341737bffcd7703a69daaf10e..c3f0c45ae9a9b6f6582accd6e9365862808fb7e1 100644 (file)
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -368,6 +368,7 @@ static int afs_check_write_begin(struct file *file, loff_t pos, unsigned len,
 static void afs_free_request(struct netfs_io_request *rreq)
 {
        key_put(rreq->netfs_priv);
+       afs_put_wb_key(rreq->netfs_priv2);
 }
 
 static void afs_update_i_size(struct inode *inode, loff_t new_i_size)

diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 887245f9336d70812e33aebf9964e851a9eb79cc..6e1d3c4daf72c6578b173b32364a1e136c7b6fec 100644 (file)
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -1601,6 +1601,7 @@ extern int afs_check_volume_status(struct afs_volume *, struct afs_operation *);
 void afs_prepare_write(struct netfs_io_subrequest *subreq);
 void afs_issue_write(struct netfs_io_subrequest *subreq);
 void afs_begin_writeback(struct netfs_io_request *wreq);
+void afs_retry_request(struct netfs_io_request *wreq, struct netfs_io_stream *stream);
 extern int afs_writepages(struct address_space *, struct writeback_control *);
 extern int afs_fsync(struct file *, loff_t, loff_t, int);
 extern vm_fault_t afs_page_mkwrite(struct vm_fault *vmf);

diff --git a/fs/afs/write.c b/fs/afs/write.c
index b8505a8b622af8899247147b5c19b29d8b851977..e959640694c25c67f97b2b79cb8065de3d68f714 100644 (file)
--- a/fs/afs/write.c
+++ b/fs/afs/write.c
@@ -29,43 +29,39 @@ static void afs_pages_written_back(struct afs_vnode *vnode, loff_t start, unsign
 
 /*
  * Find a key to use for the writeback.  We cached the keys used to author the
- * writes on the vnode.  *_wbk will contain the last writeback key used or NULL
- * and we need to start from there if it's set.
+ * writes on the vnode.  wreq->netfs_priv2 will contain the last writeback key
+ * record used or NULL and we need to start from there if it's set.
+ * wreq->netfs_priv will be set to the key itself or NULL.
  */
-static int afs_get_writeback_key(struct afs_vnode *vnode,
-                                struct afs_wb_key **_wbk)
+static void afs_get_writeback_key(struct netfs_io_request *wreq)
 {
-       struct afs_wb_key *wbk = NULL;
-       struct list_head *p;
-       int ret = -ENOKEY, ret2;
+       struct afs_wb_key *wbk, *old = wreq->netfs_priv2;
+       struct afs_vnode *vnode = AFS_FS_I(wreq->inode);
+
+       key_put(wreq->netfs_priv);
+       wreq->netfs_priv = NULL;
+       wreq->netfs_priv2 = NULL;
 
        spin_lock(&vnode->wb_lock);
-       if (*_wbk)
-               p = (*_wbk)->vnode_link.next;
+       if (old)
+               wbk = list_next_entry(old, vnode_link);
        else
-               p = vnode->wb_keys.next;
+               wbk = list_first_entry(&vnode->wb_keys, struct afs_wb_key, vnode_link);
 
-       while (p != &vnode->wb_keys) {
-               wbk = list_entry(p, struct afs_wb_key, vnode_link);
+       list_for_each_entry_from(wbk, &vnode->wb_keys, vnode_link) {
                _debug("wbk %u", key_serial(wbk->key));
-               ret2 = key_validate(wbk->key);
-               if (ret2 == 0) {
+               if (key_validate(wbk->key) == 0) {
                        refcount_inc(&wbk->usage);
+                       wreq->netfs_priv = key_get(wbk->key);
+                       wreq->netfs_priv2 = wbk;
                        _debug("USE WB KEY %u", key_serial(wbk->key));
                        break;
                }
-
-               wbk = NULL;
-               if (ret == -ENOKEY)
-                       ret = ret2;
-               p = p->next;
        }
 
        spin_unlock(&vnode->wb_lock);
-       if (*_wbk)
-               afs_put_wb_key(*_wbk);
-       *_wbk = wbk;
-       return 0;
+
+       afs_put_wb_key(old);
 }
 
 static void afs_store_data_success(struct afs_operation *op)
@@ -88,72 +84,91 @@ static const struct afs_operation_ops afs_store_data_operation = {
 };
 
 /*
- * write to a file
+ * Prepare a subrequest to write to the server.  This sets the max_len
+ * parameter.
  */
-static int afs_store_data(struct afs_vnode *vnode, struct iov_iter *iter, loff_t pos)
+void afs_prepare_write(struct netfs_io_subrequest *subreq)
 {
+       //if (test_bit(NETFS_SREQ_RETRYING, &subreq->flags))
+       //      subreq->max_len = 512 * 1024;
+       //else
+       subreq->max_len = 256 * 1024 * 1024;
+}
+
+/*
+ * Issue a subrequest to write to the server.
+ */
+static void afs_issue_write_worker(struct work_struct *work)
+{
+       struct netfs_io_subrequest *subreq = container_of(work, struct netfs_io_subrequest, work);
+       struct netfs_io_request *wreq = subreq->rreq;
        struct afs_operation *op;
-       struct afs_wb_key *wbk = NULL;
-       loff_t size = iov_iter_count(iter);
+       struct afs_vnode *vnode = AFS_FS_I(wreq->inode);
+       unsigned long long pos = subreq->start + subreq->transferred;
+       size_t len = subreq->len - subreq->transferred;
        int ret = -ENOKEY;
 
-       _enter("%s{%llx:%llu.%u},%llx,%llx",
+       _enter("R=%x[%x],%s{%llx:%llu.%u},%llx,%zx",
+              wreq->debug_id, subreq->debug_index,
               vnode->volume->name,
               vnode->fid.vid,
               vnode->fid.vnode,
               vnode->fid.unique,
-              size, pos);
+              pos, len);
 
-       ret = afs_get_writeback_key(vnode, &wbk);
-       if (ret) {
-               _leave(" = %d [no keys]", ret);
-               return ret;
-       }
+#if 0 // Error injection
+       if (subreq->debug_index == 3)
+               return netfs_write_subrequest_terminated(subreq, -ENOANO, false);
 
-       op = afs_alloc_operation(wbk->key, vnode->volume);
-       if (IS_ERR(op)) {
-               afs_put_wb_key(wbk);
-               return -ENOMEM;
+       if (!test_bit(NETFS_SREQ_RETRYING, &subreq->flags)) {
+               set_bit(NETFS_SREQ_NEED_RETRY, &subreq->flags);
+               return netfs_write_subrequest_terminated(subreq, -EAGAIN, false);
        }
+#endif
+
+       op = afs_alloc_operation(wreq->netfs_priv, vnode->volume);
+       if (IS_ERR(op))
+               return netfs_write_subrequest_terminated(subreq, -EAGAIN, false);
 
        afs_op_set_vnode(op, 0, vnode);
-       op->file[0].dv_delta = 1;
+       op->file[0].dv_delta    = 1;
        op->file[0].modification = true;
-       op->store.pos = pos;
-       op->store.size = size;
-       op->flags |= AFS_OPERATION_UNINTR;
-       op->ops = &afs_store_data_operation;
+       op->store.pos           = pos;
+       op->store.size          = len;
+       op->flags               |= AFS_OPERATION_UNINTR;
+       op->ops                 = &afs_store_data_operation;
 
-try_next_key:
        afs_begin_vnode_operation(op);
 
-       op->store.write_iter = iter;
-       op->store.i_size = max(pos + size, vnode->netfs.remote_i_size);
-       op->mtime = inode_get_mtime(&vnode->netfs.inode);
+       op->store.write_iter    = &subreq->io_iter;
+       op->store.i_size        = umax(pos + len, vnode->netfs.remote_i_size);
+       op->mtime               = inode_get_mtime(&vnode->netfs.inode);
 
        afs_wait_for_operation(op);
-
-       switch (afs_op_error(op)) {
+       ret = afs_put_operation(op);
+       switch (ret) {
        case -EACCES:
        case -EPERM:
        case -ENOKEY:
        case -EKEYEXPIRED:
        case -EKEYREJECTED:
        case -EKEYREVOKED:
-               _debug("next");
-
-               ret = afs_get_writeback_key(vnode, &wbk);
-               if (ret == 0) {
-                       key_put(op->key);
-                       op->key = key_get(wbk->key);
-                       goto try_next_key;
-               }
+               /* If there are more keys we can try, use the retry algorithm
+                * to rotate the keys.
+                */
+               if (wreq->netfs_priv2)
+                       set_bit(NETFS_SREQ_NEED_RETRY, &subreq->flags);
                break;
        }
 
-       afs_put_wb_key(wbk);
-       _leave(" = %d", afs_op_error(op));
-       return afs_put_operation(op);
+       netfs_write_subrequest_terminated(subreq, ret < 0 ? ret : subreq->len, false);
+}
+
+void afs_issue_write(struct netfs_io_subrequest *subreq)
+{
+       subreq->work.func = afs_issue_write_worker;
+       if (!queue_work(system_unbound_wq, &subreq->work))
+               WARN_ON_ONCE(1);
 }
 
 /*
@@ -162,52 +177,32 @@ try_next_key:
  */
 void afs_begin_writeback(struct netfs_io_request *wreq)
 {
+       afs_get_writeback_key(wreq);
        wreq->io_streams[0].avail = true;
 }
 
 /*
- * Prepare a subrequest to write to the server.  This sets the max_len
- * parameter.
- */
-void afs_prepare_write(struct netfs_io_subrequest *subreq)
-{
-       //if (test_bit(NETFS_SREQ_RETRYING, &subreq->flags))
-       //      subreq->max_len = 512 * 1024;
-       //else
-       subreq->max_len = 256 * 1024 * 1024;
-}
-
-/*
- * Issue a subrequest to write to the server.
+ * Prepare to retry the writes in request.  Use this to try rotating the
+ * available writeback keys.
  */
-static void afs_issue_write_worker(struct work_struct *work)
+void afs_retry_request(struct netfs_io_request *wreq, struct netfs_io_stream *stream)
 {
-       struct netfs_io_subrequest *subreq = container_of(work, struct netfs_io_subrequest, work);
-       struct afs_vnode *vnode = AFS_FS_I(subreq->rreq->inode);
-       ssize_t ret;
-
-       _enter("%x[%x],%zx",
-              subreq->rreq->debug_id, subreq->debug_index, subreq->io_iter.count);
-
-#if 0 // Error injection
-       if (subreq->debug_index == 3)
-               return netfs_write_subrequest_terminated(subreq, -ENOANO, false);
+       struct netfs_io_subrequest *subreq =
+               list_first_entry(&stream->subrequests,
+                                struct netfs_io_subrequest, rreq_link);
 
-       if (!test_bit(NETFS_SREQ_RETRYING, &subreq->flags)) {
-               set_bit(NETFS_SREQ_NEED_RETRY, &subreq->flags);
-               return netfs_write_subrequest_terminated(subreq, -EAGAIN, false);
+       switch (subreq->error) {
+       case -EACCES:
+       case -EPERM:
+       case -ENOKEY:
+       case -EKEYEXPIRED:
+       case -EKEYREJECTED:
+       case -EKEYREVOKED:
+               afs_get_writeback_key(wreq);
+               if (!wreq->netfs_priv)
+                       stream->failed = true;
+               break;
        }
-#endif
-
-       ret = afs_store_data(vnode, &subreq->io_iter, subreq->start);
-       netfs_write_subrequest_terminated(subreq, ret < 0 ? ret : subreq->len, false);
-}
-
-void afs_issue_write(struct netfs_io_subrequest *subreq)
-{
-       subreq->work.func = afs_issue_write_worker;
-       if (!queue_work(system_unbound_wq, &subreq->work))
-               WARN_ON_ONCE(1);
 }
 
 /*

diff --git a/fs/netfs/write_collect.c b/fs/netfs/write_collect.c
index f14c08bf605d3d0048a749a445979102c549b643..60112e4b2c5eb70e350a873feb2cc397517534a7 100644 (file)
--- a/fs/netfs/write_collect.c
+++ b/fs/netfs/write_collect.c
@@ -163,6 +163,13 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
 
        _enter("R=%x[%x:]", wreq->debug_id, stream->stream_nr);
 
+       if (list_empty(&stream->subrequests))
+               return;
+
+       if (stream->source == NETFS_UPLOAD_TO_SERVER &&
+           wreq->netfs_ops->retry_request)
+               wreq->netfs_ops->retry_request(wreq, stream);
+
        if (unlikely(stream->failed))
                return;
 
@@ -182,8 +189,6 @@ static void netfs_retry_write_stream(struct netfs_io_request *wreq,
                return;
        }
 
-       if (list_empty(&stream->subrequests))
-               return;
        next = stream->subrequests.next;
 
        do {

diff --git a/include/linux/netfs.h b/include/linux/netfs.h
index c2ba364041b0ef2844a93636c0513c71f94ed2b4..298552f5122ce74bba20962f311cf1b2301084ce 100644 (file)
--- a/include/linux/netfs.h
+++ b/include/linux/netfs.h
@@ -235,6 +235,7 @@ struct netfs_io_request {
        struct iov_iter         iter;           /* Unencrypted-side iterator */
        struct iov_iter         io_iter;        /* I/O (Encrypted-side) iterator */
        void                    *netfs_priv;    /* Private data for the netfs */
+       void                    *netfs_priv2;   /* Private data for the netfs */
        struct bio_vec          *direct_bv;     /* DIO buffer list (when handling iovec-iter) */
        unsigned int            direct_bv_count; /* Number of elements in direct_bv[] */
        unsigned int            debug_id;
@@ -306,6 +307,7 @@ struct netfs_request_ops {
        void (*begin_writeback)(struct netfs_io_request *wreq);
        void (*prepare_write)(struct netfs_io_subrequest *subreq);
        void (*issue_write)(struct netfs_io_subrequest *subreq);
+       void (*retry_request)(struct netfs_io_request *wreq, struct netfs_io_stream *stream);
        void (*invalidate_cache)(struct netfs_io_request *wreq);
 };