Re: [PATCH v1 5/7] NFS: Implement NFSv4.2's OFFLOAD_STATUS operation

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On 12/12/24 7:39 PM, Olga Kornievskaia wrote:
On Tue, Dec 3, 2024 at 11:29 AM <cel@xxxxxxxxxx> wrote:

From: Chuck Lever <chuck.lever@xxxxxxxxxx>

Enable the Linux NFS client to observe the progress of an offloaded
asynchronous COPY operation. This new operation will be put to use
in a subsequent patch.

Signed-off-by: Chuck Lever <chuck.lever@xxxxxxxxxx>
---
  fs/nfs/nfs42proc.c        | 117 ++++++++++++++++++++++++++++++++++++++
  fs/nfs/nfs4proc.c         |   3 +-
  include/linux/nfs_fs_sb.h |   1 +
  3 files changed, 120 insertions(+), 1 deletion(-)

diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c
index 9d716907cf30..fa180ce7c803 100644
--- a/fs/nfs/nfs42proc.c
+++ b/fs/nfs/nfs42proc.c
@@ -21,6 +21,8 @@

  #define NFSDBG_FACILITY NFSDBG_PROC
  static int nfs42_do_offload_cancel_async(struct file *dst, nfs4_stateid *std);
+static int nfs42_proc_offload_status(struct file *file, nfs4_stateid *stateid,
+                                    u64 *copied);

  static void nfs42_set_netaddr(struct file *filep, struct nfs42_netaddr *naddr)
  {
@@ -582,6 +584,121 @@ static int nfs42_do_offload_cancel_async(struct file *dst,
         return status;
  }

+static void nfs42_offload_status_done(struct rpc_task *task, void *calldata)
+{
+       struct nfs42_offload_data *data = calldata;
+
+       nfs41_sequence_done(task, &data->res.osr_seq_res);
+       switch (task->tk_status) {
+       case 0:
+               return;
+       case -NFS4ERR_ADMIN_REVOKED:
+       case -NFS4ERR_BAD_STATEID:
+       case -NFS4ERR_OLD_STATEID:
+               /*
+                * Server does not recognize the COPY stateid. CB_OFFLOAD
+                * could have purged it, or server might have rebooted.
+                * Since COPY stateids don't have an associated inode,
+                * avoid triggering state recovery.
+                */
+               task->tk_status = -EBADF;
+               break;
+       case -NFS4ERR_NOTSUPP:
+       case -ENOTSUPP:
+       case -EOPNOTSUPP:
+               data->seq_server->caps &= ~NFS_CAP_OFFLOAD_STATUS;
+               task->tk_status = -EOPNOTSUPP;
+               break;
+       default:
+               if (nfs4_async_handle_error(task, data->seq_server,
+                                           NULL, NULL) == -EAGAIN)
+                       rpc_restart_call_prepare(task);
+               else
+                       task->tk_status = -EIO;
+       }
+}
+
+static const struct rpc_call_ops nfs42_offload_status_ops = {
+       .rpc_call_prepare = nfs42_offload_prepare,
+       .rpc_call_done = nfs42_offload_status_done,
+       .rpc_release = nfs42_offload_release
+};
+
+/**
+ * nfs42_proc_offload_status - Poll completion status of an async copy operation
+ * @file: handle of file being copied
+ * @stateid: copy stateid (from async COPY result)
+ * @copied: OUT: number of bytes copied so far
+ *
+ * Return values:
+ *   %0: Server returned an NFS4_OK completion status
+ *   %-EINPROGRESS: Server returned no completion status
+ *   %-EREMOTEIO: Server returned an error completion status
+ *   %-EBADF: Server did not recognize the copy stateid
+ *   %-EOPNOTSUPP: Server does not support OFFLOAD_STATUS
+ *   %-ERESTARTSYS: Wait interrupted by signal
+ *
+ * Other negative errnos indicate the client could not complete the
+ * request.
+ */
+static int nfs42_proc_offload_status(struct file *file, nfs4_stateid *stateid,
+                                    u64 *copied)
+{
+       struct nfs_open_context *ctx = nfs_file_open_context(file);
+       struct nfs_server *server = NFS_SERVER(file_inode(file));
+       struct nfs42_offload_data *data = NULL;
+       struct rpc_message msg = {
+               .rpc_proc       = &nfs4_procedures[NFSPROC4_CLNT_OFFLOAD_STATUS],
+               .rpc_cred       = ctx->cred,
+       };
+       struct rpc_task_setup task_setup_data = {
+               .rpc_client     = server->client,
+               .rpc_message    = &msg,
+               .callback_ops   = &nfs42_offload_status_ops,
+               .workqueue      = nfsiod_workqueue,
+               .flags          = RPC_TASK_ASYNC | RPC_TASK_SOFTCONN,

I wonder why we are making status_offload an async task? Copy within
which we are doing copy_offload is/was a sync task.

I tried it as a sync task, there were some issues with that that I
no longer recall.


Why is it a SOFTCONN task?

If there is no existing connection to the server, fail immediately
instead of waiting for minutes to reconnect.

Otherwise, just like RENEW, the client will stack up a bunch of
OFFLOAD_STATUS operations as long as the RPC transport is down.

Also, when retrying, wait interruptibly -- that way a ^C will work
as expected.


+       };
+       struct rpc_task *task;
+       int status;
+
+       if (!(server->caps & NFS_CAP_OFFLOAD_STATUS))
+               return -EOPNOTSUPP;

Let's not forget to mark tasks RPC_TASK_MOVEABLE. I know other
nfs42proc need review and add that but since I remembered it here,
let's add it. It allows for if ever this transport were to be moved,
then the tasks can migrate to another transport.

OK.


+
+       data = kzalloc(sizeof(struct nfs42_offload_data), GFP_KERNEL);
+       if (data == NULL)
+               return -ENOMEM;
+
+       data->seq_server = server;
+       data->args.osa_src_fh = NFS_FH(file_inode(file));
+       memcpy(&data->args.osa_stateid, stateid,
+               sizeof(data->args.osa_stateid));
+       msg.rpc_argp = &data->args;
+       msg.rpc_resp = &data->res;
+       task_setup_data.callback_data = data;
+       nfs4_init_sequence(&data->args.osa_seq_args, &data->res.osr_seq_res,
+                          1, 0);
+       task = rpc_run_task(&task_setup_data);
+       if (IS_ERR(task)) {
+               nfs42_offload_release(data);
+               return PTR_ERR(task);
+       }
+       status = rpc_wait_for_completion_task(task);
+       if (status)
+               goto out;
+
+       *copied = data->res.osr_count;
+       if (task->tk_status)
+               status = task->tk_status;
+       else if (!data->res.complete_count)
+               status = -EINPROGRESS;
+       else if (data->res.osr_complete != NFS_OK)
+               status = -EREMOTEIO;
+
+out:
+       rpc_put_task(task);
+       return status;
+}
+
  static int _nfs42_proc_copy_notify(struct file *src, struct file *dst,
                                    struct nfs42_copy_notify_args *args,
                                    struct nfs42_copy_notify_res *res)
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 405f17e6e0b4..973b8d8fa98b 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -10769,7 +10769,8 @@ static const struct nfs4_minor_version_ops nfs_v4_2_minor_ops = {
                 | NFS_CAP_CLONE
                 | NFS_CAP_LAYOUTERROR
                 | NFS_CAP_READ_PLUS
-               | NFS_CAP_MOVEABLE,
+               | NFS_CAP_MOVEABLE
+               | NFS_CAP_OFFLOAD_STATUS,
         .init_client = nfs41_init_client,
         .shutdown_client = nfs41_shutdown_client,
         .match_stateid = nfs41_match_stateid,
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index b804346a9741..946ca1c28773 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -290,6 +290,7 @@ struct nfs_server {
  #define NFS_CAP_CASE_INSENSITIVE       (1U << 6)
  #define NFS_CAP_CASE_PRESERVING        (1U << 7)
  #define NFS_CAP_REBOOT_LAYOUTRETURN    (1U << 8)
+#define NFS_CAP_OFFLOAD_STATUS (1U << 9)
  #define NFS_CAP_OPEN_XOR       (1U << 12)
  #define NFS_CAP_DELEGTIME      (1U << 13)
  #define NFS_CAP_POSIX_LOCK     (1U << 14)
--
2.47.0




--
Chuck Lever




[Index of Archives]     [Linux Filesystem Development]     [Linux USB Development]     [Linux Media Development]     [Video for Linux]     [Linux NILFS]     [Linux Audio Users]     [Yosemite Info]     [Linux SCSI]

  Powered by Linux