| Message ID | 20241008134719.116825-18-cel@kernel.org (mailing list archive) |
|---|---|
| State | New |
| Headers | show |
| Series | async COPY fixes | expand |
On Wed, 09 Oct 2024, cel@kernel.org wrote: > From: Chuck Lever <chuck.lever@oracle.com> > > 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@oracle.com> > --- > fs/nfs/nfs42proc.c | 122 ++++++++++++++++++++++++++++++++++++++ > fs/nfs/nfs4proc.c | 3 +- > include/linux/nfs_fs_sb.h | 1 + > 3 files changed, 125 insertions(+), 1 deletion(-) > > diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c > index 869605a0a9d5..175330843558 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,126 @@ 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; > + > + if (!nfs4_sequence_done(task, &data->res.osr_seq_res)) > + return; > + > + switch (task->tk_status) { > + case 0: > + return; > + case -NFS4ERR_DELAY: > + if (nfs4_async_handle_error(task, data->seq_server, > + NULL, NULL) == -EAGAIN) > + rpc_restart_call_prepare(task); > + else > + task->tk_status = -EIO; > + break; > + case -NFS4ERR_GRACE: > + 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: > + 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: a signal was received. I'm wondering why this request is RPC_TASK_ASYNC rather than rpc_call_sync(). NeilBrown > + * > + * 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, > + }; > + struct rpc_task *task; > + int status; > + > + if (!(server->caps & NFS_CAP_OFFLOAD_STATUS)) > + return -EOPNOTSUPP; > + > + 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[0] != 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 cd2fbde2e6d7..324e38b70b9f 100644 > --- a/fs/nfs/nfs4proc.c > +++ b/fs/nfs/nfs4proc.c > @@ -10763,7 +10763,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 853df3fcd4c2..05b8deadd3b1 100644 > --- a/include/linux/nfs_fs_sb.h > +++ b/include/linux/nfs_fs_sb.h > @@ -289,6 +289,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.46.2 > > >
On Tue, Oct 08, 2024 at 06:09:13PM -0400, NeilBrown wrote: > On Wed, 09 Oct 2024, cel@kernel.org wrote: > > From: Chuck Lever <chuck.lever@oracle.com> > > > > 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@oracle.com> > > --- > > fs/nfs/nfs42proc.c | 122 ++++++++++++++++++++++++++++++++++++++ > > fs/nfs/nfs4proc.c | 3 +- > > include/linux/nfs_fs_sb.h | 1 + > > 3 files changed, 125 insertions(+), 1 deletion(-) > > > > diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c > > index 869605a0a9d5..175330843558 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,126 @@ 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; > > + > > + if (!nfs4_sequence_done(task, &data->res.osr_seq_res)) > > + return; > > + > > + switch (task->tk_status) { > > + case 0: > > + return; > > + case -NFS4ERR_DELAY: > > + if (nfs4_async_handle_error(task, data->seq_server, > > + NULL, NULL) == -EAGAIN) > > + rpc_restart_call_prepare(task); > > + else > > + task->tk_status = -EIO; > > + break; > > + case -NFS4ERR_GRACE: > > + 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: > > + 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: a signal was received. > > I'm wondering why this request is RPC_TASK_ASYNC rather than > rpc_call_sync(). I had a prototype that used rpc_call_sync(). It was long enough ago that I don't recall exactly why I needed to switch to ASYNC instead. I suspect it was because it needs to accomplish certain things via callback_ops, and that's not possible with rpc_call_sync(). > NeilBrown > > > > + * > > + * 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, > > + }; > > + struct rpc_task *task; > > + int status; > > + > > + if (!(server->caps & NFS_CAP_OFFLOAD_STATUS)) > > + return -EOPNOTSUPP; > > + > > + 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[0] != 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 cd2fbde2e6d7..324e38b70b9f 100644 > > --- a/fs/nfs/nfs4proc.c > > +++ b/fs/nfs/nfs4proc.c > > @@ -10763,7 +10763,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 853df3fcd4c2..05b8deadd3b1 100644 > > --- a/include/linux/nfs_fs_sb.h > > +++ b/include/linux/nfs_fs_sb.h > > @@ -289,6 +289,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.46.2 > > > > > > >
diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c index 869605a0a9d5..175330843558 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,126 @@ 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; + + if (!nfs4_sequence_done(task, &data->res.osr_seq_res)) + return; + + switch (task->tk_status) { + case 0: + return; + case -NFS4ERR_DELAY: + if (nfs4_async_handle_error(task, data->seq_server, + NULL, NULL) == -EAGAIN) + rpc_restart_call_prepare(task); + else + task->tk_status = -EIO; + break; + case -NFS4ERR_GRACE: + 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: + 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 + * + * 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, + }; + struct rpc_task *task; + int status; + + if (!(server->caps & NFS_CAP_OFFLOAD_STATUS)) + return -EOPNOTSUPP; + + 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[0] != 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 cd2fbde2e6d7..324e38b70b9f 100644 --- a/fs/nfs/nfs4proc.c +++ b/fs/nfs/nfs4proc.c @@ -10763,7 +10763,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 853df3fcd4c2..05b8deadd3b1 100644 --- a/include/linux/nfs_fs_sb.h +++ b/include/linux/nfs_fs_sb.h @@ -289,6 +289,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)