Commit 1913cdf5 authored by Chuck Lever's avatar Chuck Lever
Browse files

NFSD: Replace boolean fields in struct nfsd4_copy 



Clean up: saves 8 bytes, and we can replace check_and_set_stop_copy()
with an atomic bitop.

Signed-off-by: default avatarChuck Lever <chuck.lever@oracle.com>
parent 8ea6e2c9

fs/nfsd/nfs4proc.c

+19 −32
Original line number Diff line number Diff line
@@ -1293,23 +1293,9 @@ static void nfs4_put_copy(struct nfsd4_copy *copy) 
	kfree(copy);

}



static bool

check_and_set_stop_copy(struct nfsd4_copy *copy)

{

	bool value;



	spin_lock(&copy->cp_clp->async_lock);

	value = copy->stopped;

	if (!copy->stopped)

		copy->stopped = true;

	spin_unlock(&copy->cp_clp->async_lock);

	return value;

}



static void nfsd4_stop_copy(struct nfsd4_copy *copy)

{

	/* only 1 thread should stop the copy */

	if (!check_and_set_stop_copy(copy))

	if (!test_and_set_bit(NFSD4_COPY_F_STOPPED, &copy->cp_flags))

		kthread_stop(copy->copy_task);

	nfs4_put_copy(copy);

}
@@ -1678,8 +1664,9 @@ static const struct nfsd4_callback_ops nfsd4_cb_offload_ops = { 
static void nfsd4_init_copy_res(struct nfsd4_copy *copy, bool sync)

{

	copy->cp_res.wr_stable_how =

		copy->committed ? NFS_FILE_SYNC : NFS_UNSTABLE;

	copy->cp_synchronous = sync;

		test_bit(NFSD4_COPY_F_COMMITTED, &copy->cp_flags) ?

			NFS_FILE_SYNC : NFS_UNSTABLE;

	nfsd4_copy_set_sync(copy, sync);

	gen_boot_verifier(&copy->cp_res.wr_verifier, copy->cp_clp->net);

}
@@ -1708,16 +1695,16 @@ static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy) 
		copy->cp_res.wr_bytes_written += bytes_copied;

		src_pos += bytes_copied;

		dst_pos += bytes_copied;

	} while (bytes_total > 0 && !copy->cp_synchronous);

	} while (bytes_total > 0 && nfsd4_copy_is_async(copy));

	/* for a non-zero asynchronous copy do a commit of data */

	if (!copy->cp_synchronous && copy->cp_res.wr_bytes_written > 0) {

	if (nfsd4_copy_is_async(copy) && copy->cp_res.wr_bytes_written > 0) {

		since = READ_ONCE(dst->f_wb_err);

		status = vfs_fsync_range(dst, copy->cp_dst_pos,

					 copy->cp_res.wr_bytes_written, 0);

		if (!status)

			status = filemap_check_wb_err(dst->f_mapping, since);

		if (!status)

			copy->committed = true;

			set_bit(NFSD4_COPY_F_COMMITTED, &copy->cp_flags);

	}

	return bytes_copied;

}
@@ -1738,7 +1725,7 @@ static __be32 nfsd4_do_copy(struct nfsd4_copy *copy, bool sync) 
		status = nfs_ok;

	}



	if (!copy->cp_intra) /* Inter server SSC */

	if (nfsd4_ssc_is_inter(copy))

		nfsd4_cleanup_inter_ssc(copy->ss_mnt, copy->nf_src,

					copy->nf_dst);

	else
@@ -1752,13 +1739,13 @@ static void dup_copy_fields(struct nfsd4_copy *src, struct nfsd4_copy *dst) 
	dst->cp_src_pos = src->cp_src_pos;

	dst->cp_dst_pos = src->cp_dst_pos;

	dst->cp_count = src->cp_count;

	dst->cp_synchronous = src->cp_synchronous;

	dst->cp_flags = src->cp_flags;

	memcpy(&dst->cp_res, &src->cp_res, sizeof(src->cp_res));

	memcpy(&dst->fh, &src->fh, sizeof(src->fh));

	dst->cp_clp = src->cp_clp;

	dst->nf_dst = nfsd_file_get(src->nf_dst);

	dst->cp_intra = src->cp_intra;

	if (src->cp_intra) /* for inter, file_src doesn't exist yet */

	/* for inter, nf_src doesn't exist yet */

	if (!nfsd4_ssc_is_inter(src))

		dst->nf_src = nfsd_file_get(src->nf_src);



	memcpy(&dst->cp_stateid, &src->cp_stateid, sizeof(src->cp_stateid));
@@ -1772,7 +1759,7 @@ static void cleanup_async_copy(struct nfsd4_copy *copy) 
{

	nfs4_free_copy_state(copy);

	nfsd_file_put(copy->nf_dst);

	if (copy->cp_intra)

	if (!nfsd4_ssc_is_inter(copy))

		nfsd_file_put(copy->nf_src);

	spin_lock(&copy->cp_clp->async_lock);

	list_del(&copy->copies);
@@ -1785,7 +1772,7 @@ static int nfsd4_do_async_copy(void *data) 
	struct nfsd4_copy *copy = (struct nfsd4_copy *)data;

	struct nfsd4_copy *cb_copy;



	if (!copy->cp_intra) { /* Inter server SSC */

	if (nfsd4_ssc_is_inter(copy)) {

		copy->nf_src = kzalloc(sizeof(struct nfsd_file), GFP_KERNEL);

		if (!copy->nf_src) {

			copy->nfserr = nfserr_serverfault;
@@ -1817,7 +1804,7 @@ static int nfsd4_do_async_copy(void *data) 
			      &copy->fh, copy->cp_count, copy->nfserr);

	nfsd4_run_cb(&cb_copy->cp_cb);

out:

	if (!copy->cp_intra)

	if (nfsd4_ssc_is_inter(copy))

		kfree(copy->nf_src);

	cleanup_async_copy(copy);

	return 0;
@@ -1831,8 +1818,8 @@ nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
	__be32 status;

	struct nfsd4_copy *async_copy = NULL;



	if (!copy->cp_intra) { /* Inter server SSC */

		if (!inter_copy_offload_enable || copy->cp_synchronous) {

	if (nfsd4_ssc_is_inter(copy)) {

		if (!inter_copy_offload_enable || nfsd4_copy_is_sync(copy)) {

			status = nfserr_notsupp;

			goto out;

		}
@@ -1849,7 +1836,7 @@ nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
	copy->cp_clp = cstate->clp;

	memcpy(&copy->fh, &cstate->current_fh.fh_handle,

		sizeof(struct knfsd_fh));

	if (!copy->cp_synchronous) {

	if (nfsd4_copy_is_async(copy)) {

		struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);



		status = nfserrno(-ENOMEM);
@@ -1884,7 +1871,7 @@ nfsd4_copy(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, 
	if (async_copy)

		cleanup_async_copy(async_copy);

	status = nfserrno(-ENOMEM);

	if (!copy->cp_intra)

	if (nfsd4_ssc_is_inter(copy))

		nfsd4_interssc_disconnect(copy->ss_mnt);

	goto out;

}
@@ -2613,7 +2600,7 @@ check_if_stalefh_allowed(struct nfsd4_compoundargs *args) 
				return;

			}

			putfh = (struct nfsd4_putfh *)&saved_op->u;

			if (!copy->cp_intra)

			if (nfsd4_ssc_is_inter(copy))

				putfh->no_verify = true;

		}

	}

fs/nfsd/nfs4xdr.c

+6 −6
Original line number Diff line number Diff line
@@ -1896,8 +1896,8 @@ static __be32 nfsd4_decode_nl4_server(struct nfsd4_compoundargs *argp, 
static __be32

nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy)

{

	u32 consecutive, i, count, sync;

	struct nl4_server *ns_dummy;

	u32 consecutive, i, count;

	__be32 status;



	status = nfsd4_decode_stateid4(argp, &copy->cp_src_stateid);
@@ -1915,17 +1915,17 @@ nfsd4_decode_copy(struct nfsd4_compoundargs *argp, struct nfsd4_copy *copy) 
	/* ca_consecutive: we always do consecutive copies */

	if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0)

		return nfserr_bad_xdr;

	if (xdr_stream_decode_u32(argp->xdr, &copy->cp_synchronous) < 0)

	if (xdr_stream_decode_bool(argp->xdr, &sync) < 0)

		return nfserr_bad_xdr;

	nfsd4_copy_set_sync(copy, sync);



	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)

		return nfserr_bad_xdr;

	copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src));

	if (copy->cp_src == NULL)

		return nfserr_jukebox;

	copy->cp_intra = false;

	if (count == 0) { /* intra-server copy */

		copy->cp_intra = true;

		__set_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);

		return nfs_ok;

	}
@@ -4704,13 +4704,13 @@ nfsd4_encode_copy(struct nfsd4_compoundres *resp, __be32 nfserr, 
	__be32 *p;



	nfserr = nfsd42_encode_write_res(resp, &copy->cp_res,

					 !!copy->cp_synchronous);

					 nfsd4_copy_is_sync(copy));

	if (nfserr)

		return nfserr;



	p = xdr_reserve_space(resp->xdr, 4 + 4);

	*p++ = xdr_one; /* cr_consecutive */

	*p++ = cpu_to_be32(copy->cp_synchronous);

	*p = nfsd4_copy_is_sync(copy) ? xdr_one : xdr_zero;

	return 0;

}

fs/nfsd/xdr4.h

+28 −5
Original line number Diff line number Diff line
@@ -541,10 +541,12 @@ struct nfsd4_copy { 
	u64			cp_dst_pos;

	u64			cp_count;

	struct nl4_server	*cp_src;

	bool			cp_intra;



	/* both */

	u32			cp_synchronous;

	unsigned long		cp_flags;

#define NFSD4_COPY_F_STOPPED		(0)

#define NFSD4_COPY_F_INTRA		(1)

#define NFSD4_COPY_F_SYNCHRONOUS	(2)

#define NFSD4_COPY_F_COMMITTED		(3)



	/* response */

	struct nfsd42_write_res	cp_res;
@@ -564,14 +566,35 @@ struct nfsd4_copy { 
	struct list_head	copies;

	struct task_struct	*copy_task;

	refcount_t		refcount;

	bool			stopped;



	struct vfsmount		*ss_mnt;

	struct nfs_fh		c_fh;

	nfs4_stateid		stateid;

	bool			committed;

};



static inline void nfsd4_copy_set_sync(struct nfsd4_copy *copy, bool sync)

{

	if (sync)

		set_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);

	else

		clear_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);

}



static inline bool nfsd4_copy_is_sync(const struct nfsd4_copy *copy)

{

	return test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);

}



static inline bool nfsd4_copy_is_async(const struct nfsd4_copy *copy)

{

	return !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);

}



static inline bool nfsd4_ssc_is_inter(const struct nfsd4_copy *copy)

{

	return !test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);

}



struct nfsd4_seek {

	/* request */

	stateid_t	seek_stateid;