On Tue, Mar 08, 2016 at 04:55:57PM -0500, Anna Schumaker wrote:
> From: Anna Schumaker <Anna.Schumaker@xxxxxxxxxx>
>
> I only implemented the sync version of this call, since it's the
> easiest. I can simply call vfs_copy_range() and have the vfs do the
> right thing for the filesystem being exported.
>
> Signed-off-by: Anna Schumaker <bjschuma@xxxxxxxxxx>
> --
> v3:
> - Check for copying beyond the end of the file
> ---
> fs/nfsd/nfs4proc.c | 98 ++++++++++++++++++++++++++++++++++++++++++++++++------
> fs/nfsd/nfs4xdr.c | 63 +++++++++++++++++++++++++++++++++--
> fs/nfsd/vfs.c | 6 ++++
> fs/nfsd/vfs.h | 1 +
> fs/nfsd/xdr4.h | 23 +++++++++++++
> 5 files changed, 178 insertions(+), 13 deletions(-)
>
> diff --git a/fs/nfsd/nfs4proc.c b/fs/nfsd/nfs4proc.c
> index 4cba786..0a1aa2f 100644
> --- a/fs/nfsd/nfs4proc.c
> +++ b/fs/nfsd/nfs4proc.c
> @@ -1012,47 +1012,105 @@ nfsd4_write(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> }
>
> static __be32
> -nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> - struct nfsd4_clone *clone)
> +nfsd4_verify_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> + stateid_t *src_stateid, struct file **src,
> + stateid_t *dst_stateid, struct file **dst)
> {
> - struct file *src, *dst;
> __be32 status;
>
> status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->save_fh,
> - &clone->cl_src_stateid, RD_STATE,
> - &src, NULL);
> + src_stateid, RD_STATE, src, NULL);
> if (status) {
> dprintk("NFSD: %s: couldn't process src stateid!\n", __func__);
> goto out;
> }
>
> status = nfs4_preprocess_stateid_op(rqstp, cstate, &cstate->current_fh,
> - &clone->cl_dst_stateid, WR_STATE,
> - &dst, NULL);
> + dst_stateid, WR_STATE, dst, NULL);
> if (status) {
> dprintk("NFSD: %s: couldn't process dst stateid!\n", __func__);
> goto out_put_src;
> }
>
> /* fix up for NFS-specific error code */
> - if (!S_ISREG(file_inode(src)->i_mode) ||
> - !S_ISREG(file_inode(dst)->i_mode)) {
> + if (!S_ISREG(file_inode(*src)->i_mode) ||
> + !S_ISREG(file_inode(*dst)->i_mode)) {
> status = nfserr_wrong_type;
> goto out_put_dst;
> }
>
> +out:
> + return status;
> +out_put_dst:
> + fput(*dst);
> +out_put_src:
> + fput(*src);
> + goto out;
> +}
> +
> +static __be32
> +nfsd4_clone(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> + struct nfsd4_clone *clone)
> +{
> + struct file *src, *dst;
> + __be32 status;
> +
> + status = nfsd4_verify_copy(rqstp, cstate, &clone->cl_src_stateid, &src,
> + &clone->cl_dst_stateid, &dst);
> + if (status)
> + goto out;
> +
> status = nfsd4_clone_file_range(src, clone->cl_src_pos,
> dst, clone->cl_dst_pos, clone->cl_count);
>
> -out_put_dst:
> fput(dst);
> -out_put_src:
> fput(src);
> out:
> return status;
> }
>
> static __be32
> +nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> + struct nfsd4_copy *copy)
> +{
> + struct file *src, *dst;
> + __be32 status;
> + ssize_t bytes;
> + loff_t max;
> +
> + status = nfsd4_verify_copy(rqstp, cstate, ©->cp_src_stateid, &src,
> + ©->cp_dst_stateid, &dst);
> + if (status)
> + goto out;
> +
> + max = i_size_read(file_inode(src));
> + if ((copy->cp_src_pos + copy->cp_count) > max) {
> + status = nfserr_inval;
> + goto out_put;
> + }
If we care about the race between this check and the copy, then we need
some locking. If we don't, then a comment explaining why not would be
useful here.
(Looks like this check, and the INVAL error, are both mandated by the
spec. The behavior looks wrong to me--usually EINVAL's reserved for
things the client had to know was a problem, but here the client doesn't
necessarily know the file size. I would have expected just success and
a short read.)
--b.
> +
> + bytes = nfsd_copy_range(src, copy->cp_src_pos, dst, copy->cp_dst_pos,
> + copy->cp_count);
> +
> + if (bytes < 0)
> + status = nfserrno(bytes);
> + else {
> + copy->cp_res.wr_bytes_written = bytes;
> + copy->cp_res.wr_stable_how = NFS_UNSTABLE;
> + copy->cp_consecutive = 1;
> + copy->cp_synchronous = 1;
> + gen_boot_verifier(©->cp_res.wr_verifier, SVC_NET(rqstp));
> + status = nfs_ok;
> + }
> +
> +out_put:
> + fput(src);
> + fput(dst);
> +out:
> + return status;
> +}
> +
> +static __be32
> nfsd4_fallocate(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
> struct nfsd4_fallocate *fallocate, int flags)
> {
> @@ -1966,6 +2024,18 @@ static inline u32 nfsd4_create_session_rsize(struct svc_rqst *rqstp, struct nfsd
> op_encode_channel_attrs_maxsz) * sizeof(__be32);
> }
>
> +static inline u32 nfsd4_copy_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)
> +{
> + return (op_encode_hdr_size +
> + 1 /* wr_callback */ +
> + op_encode_stateid_maxsz /* wr_callback */ +
> + 2 /* wr_count */ +
> + 1 /* wr_committed */ +
> + op_encode_verifier_maxsz +
> + 1 /* cr_consecutive */ +
> + 1 /* cr_synchronous */) * sizeof(__be32);
> +}
> +
> #ifdef CONFIG_NFSD_PNFS
> /*
> * At this stage we don't really know what layout driver will handle the request,
> @@ -2328,6 +2398,12 @@ static struct nfsd4_operation nfsd4_ops[] = {
> .op_name = "OP_CLONE",
> .op_rsize_bop = (nfsd4op_rsize)nfsd4_only_status_rsize,
> },
> + [OP_COPY] = {
> + .op_func = (nfsd4op_func)nfsd4_copy,
> + .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME,
> + .op_name = "OP_COPY",
> + .op_rsize_bop = (nfsd4op_rsize)nfsd4_copy_rsize,
> + },
> [OP_SEEK] = {
> .op_func = (nfsd4op_func)nfsd4_seek,
> .op_name = "OP_SEEK",
> diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
> index d6ef095..2a73c7e 100644
> --- a/fs/nfsd/nfs4xdr.c
> +++ b/fs/nfsd/nfs4xdr.c
> @@ -1694,6 +1694,30 @@ nfsd4_decode_clone(struct nfsd4_compoundargs *argp, struct nfsd4_clone *clone)
> }
>
> static __be32
> +nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy)
> +{
> + DECODE_HEAD;
> + unsigned int tmp;
> +
> + status = nfsd4_decode_stateid(argp, ©->cp_src_stateid);
> + if (status)
> + return status;
> + status = nfsd4_decode_stateid(argp, ©->cp_dst_stateid);
> + if (status)
> + return status;
> +
> + READ_BUF(8 + 8 + 8 + 4 + 4 + 4);
> + p = xdr_decode_hyper(p, ©->cp_src_pos);
> + p = xdr_decode_hyper(p, ©->cp_dst_pos);
> + p = xdr_decode_hyper(p, ©->cp_count);
> + copy->cp_consecutive = be32_to_cpup(p++);
> + copy->cp_synchronous = be32_to_cpup(p++);
> + tmp = be32_to_cpup(p); /* Source server list not supported */
> +
> + DECODE_TAIL;
> +}
> +
> +static __be32
> nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek)
> {
> DECODE_HEAD;
> @@ -1793,7 +1817,7 @@ static nfsd4_dec nfsd4_dec_ops[] = {
>
> /* new operations for NFSv4.2 */
> [OP_ALLOCATE] = (nfsd4_dec)nfsd4_decode_fallocate,
> - [OP_COPY] = (nfsd4_dec)nfsd4_decode_notsupp,
> + [OP_COPY] = (nfsd4_dec)nfsd4_decode_copy,
> [OP_COPY_NOTIFY] = (nfsd4_dec)nfsd4_decode_notsupp,
> [OP_DEALLOCATE] = (nfsd4_dec)nfsd4_decode_fallocate,
> [OP_IO_ADVISE] = (nfsd4_dec)nfsd4_decode_notsupp,
> @@ -4203,6 +4227,41 @@ nfsd4_encode_layoutreturn(struct nfsd4_compoundres *resp, __be32 nfserr,
> #endif /* CONFIG_NFSD_PNFS */
>
> static __be32
> +nfsd42_encode_write_res(struct nfsd4_compoundres *resp, struct nfsd42_write_res *write)
> +{
> + __be32 *p;
> +
> + p = xdr_reserve_space(&resp->xdr, 4 + 8 + 4 + NFS4_VERIFIER_SIZE);
> + if (!p)
> + return nfserr_resource;
> +
> + *p++ = cpu_to_be32(0);
> + p = xdr_encode_hyper(p, write->wr_bytes_written);
> + *p++ = cpu_to_be32(write->wr_stable_how);
> + p = xdr_encode_opaque_fixed(p, write->wr_verifier.data,
> + NFS4_VERIFIER_SIZE);
> + return nfs_ok;
> +}
> +
> +static __be32
> +nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr,
> + struct nfsd4_copy *copy)
> +{
> + __be32 *p;
> +
> + if (!nfserr) {
> + nfserr = nfsd42_encode_write_res(resp, ©->cp_res);
> + if (nfserr)
> + return nfserr;
> +
> + p = xdr_reserve_space(&resp->xdr, 4 + 4);
> + *p++ = cpu_to_be32(copy->cp_consecutive);
> + *p++ = cpu_to_be32(copy->cp_synchronous);
> + }
> + return nfserr;
> +}
> +
> +static __be32
> nfsd4_encode_seek(struct nfsd4_compoundres *resp, __be32 nfserr,
> struct nfsd4_seek *seek)
> {
> @@ -4301,7 +4360,7 @@ static nfsd4_enc nfsd4_enc_ops[] = {
>
> /* NFSv4.2 operations */
> [OP_ALLOCATE] = (nfsd4_enc)nfsd4_encode_noop,
> - [OP_COPY] = (nfsd4_enc)nfsd4_encode_noop,
> + [OP_COPY] = (nfsd4_enc)nfsd4_encode_copy,
> [OP_COPY_NOTIFY] = (nfsd4_enc)nfsd4_encode_noop,
> [OP_DEALLOCATE] = (nfsd4_enc)nfsd4_encode_noop,
> [OP_IO_ADVISE] = (nfsd4_enc)nfsd4_encode_noop,
> diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
> index 5d2a57e..28802a7 100644
> --- a/fs/nfsd/vfs.c
> +++ b/fs/nfsd/vfs.c
> @@ -513,6 +513,12 @@ __be32 nfsd4_clone_file_range(struct file *src, u64 src_pos, struct file *dst,
> count));
> }
>
> +ssize_t nfsd_copy_range(struct file *src, u64 src_pos, struct file *dst,
> + u64 dst_pos, u64 count)
> +{
> + return vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
> +}
> +
> __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
> struct file *file, loff_t offset, loff_t len,
> int flags)
> diff --git a/fs/nfsd/vfs.h b/fs/nfsd/vfs.h
> index c11ba31..e36c497 100644
> --- a/fs/nfsd/vfs.h
> +++ b/fs/nfsd/vfs.h
> @@ -93,6 +93,7 @@ __be32 nfsd_symlink(struct svc_rqst *, struct svc_fh *,
> struct svc_fh *res);
> __be32 nfsd_link(struct svc_rqst *, struct svc_fh *,
> char *, int, struct svc_fh *);
> +ssize_t nfsd_copy_range(struct file *, u64, struct file *, u64, u64);
> __be32 nfsd_rename(struct svc_rqst *,
> struct svc_fh *, char *, int,
> struct svc_fh *, char *, int);
> diff --git a/fs/nfsd/xdr4.h b/fs/nfsd/xdr4.h
> index d955481..2cad349 100644
> --- a/fs/nfsd/xdr4.h
> +++ b/fs/nfsd/xdr4.h
> @@ -500,6 +500,28 @@ struct nfsd4_clone {
> u64 cl_count;
> };
>
> +struct nfsd42_write_res {
> + u64 wr_bytes_written;
> + u32 wr_stable_how;
> + nfs4_verifier wr_verifier;
> +};
> +
> +struct nfsd4_copy {
> + /* request */
> + stateid_t cp_src_stateid;
> + stateid_t cp_dst_stateid;
> + u64 cp_src_pos;
> + u64 cp_dst_pos;
> + u64 cp_count;
> +
> + /* both */
> + bool cp_consecutive;
> + bool cp_synchronous;
> +
> + /* response */
> + struct nfsd42_write_res cp_res;
> +};
> +
> struct nfsd4_seek {
> /* request */
> stateid_t seek_stateid;
> @@ -565,6 +587,7 @@ struct nfsd4_op {
> struct nfsd4_fallocate allocate;
> struct nfsd4_fallocate deallocate;
> struct nfsd4_clone clone;
> + struct nfsd4_copy copy;
> struct nfsd4_seek seek;
> } u;
> struct nfs4_replay * replay;
> --
> 2.7.2
--
To unsubscribe from this list: send the line "unsubscribe linux-nfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
