Merge tag 'nfsd-6.7-2' of git://git.kernel.org/pub/scm/linux/kernel/git/cel/linux (ac1c13e2) · Commits · git / linux-nf

fs/nfsd/nfs4callback.c

+1 −96

Original line number	Diff line number	Diff line
		@@ -84,21 +84,7 @@ static void encode_uint32(struct xdr_stream *xdr, u32 n)
		static void encode_bitmap4(struct xdr_stream xdr, const __u32 bitmap,
		size_t len)
		{
		xdr_stream_encode_uint32_array(xdr, bitmap, len);
		}

		static int decode_cb_fattr4(struct xdr_stream xdr, uint32_t bitmap,
		struct nfs4_cb_fattr *fattr)
		{
		fattr->ncf_cb_change = 0;
		fattr->ncf_cb_fsize = 0;
		if (bitmap[0] & FATTR4_WORD0_CHANGE)
		if (xdr_stream_decode_u64(xdr, &fattr->ncf_cb_change) < 0)
		return -NFSERR_BAD_XDR;
		if (bitmap[0] & FATTR4_WORD0_SIZE)
		if (xdr_stream_decode_u64(xdr, &fattr->ncf_cb_fsize) < 0)
		return -NFSERR_BAD_XDR;
		return 0;
		WARN_ON_ONCE(xdr_stream_encode_uint32_array(xdr, bitmap, len) < 0);
		}

		/*
		@@ -371,30 +357,6 @@ encode_cb_recallany4args(struct xdr_stream *xdr,
		hdr->nops++;
		}

		/*
		* CB_GETATTR4args
		* struct CB_GETATTR4args {
		* nfs_fh4 fh;
		* bitmap4 attr_request;
		* };
		*
		* The size and change attributes are the only one
		* guaranteed to be serviced by the client.
		*/
		static void
		encode_cb_getattr4args(struct xdr_stream xdr, struct nfs4_cb_compound_hdr hdr,
		struct nfs4_cb_fattr *fattr)
		{
		struct nfs4_delegation *dp =
		container_of(fattr, struct nfs4_delegation, dl_cb_fattr);
		struct knfsd_fh *fh = &dp->dl_stid.sc_file->fi_fhandle;

		encode_nfs_cb_opnum4(xdr, OP_CB_GETATTR);
		encode_nfs_fh4(xdr, fh);
		encode_bitmap4(xdr, fattr->ncf_cb_bmap, ARRAY_SIZE(fattr->ncf_cb_bmap));
		hdr->nops++;
		}

		/*
		* CB_SEQUENCE4args
		*
		@@ -530,26 +492,6 @@ static void nfs4_xdr_enc_cb_null(struct rpc_rqst req, struct xdr_stream xdr,
		xdr_reserve_space(xdr, 0);
		}

		/*
		* 20.1. Operation 3: CB_GETATTR - Get Attributes
		*/
		static void nfs4_xdr_enc_cb_getattr(struct rpc_rqst *req,
		struct xdr_stream xdr, const void data)
		{
		const struct nfsd4_callback *cb = data;
		struct nfs4_cb_fattr *ncf =
		container_of(cb, struct nfs4_cb_fattr, ncf_getattr);
		struct nfs4_cb_compound_hdr hdr = {
		.ident = cb->cb_clp->cl_cb_ident,
		.minorversion = cb->cb_clp->cl_minorversion,
		};

		encode_cb_compound4args(xdr, &hdr);
		encode_cb_sequence4args(xdr, cb, &hdr);
		encode_cb_getattr4args(xdr, &hdr, ncf);
		encode_cb_nops(&hdr);
		}

		/*
		* 20.2. Operation 4: CB_RECALL - Recall a Delegation
		*/
		@@ -605,42 +547,6 @@ static int nfs4_xdr_dec_cb_null(struct rpc_rqst req, struct xdr_stream xdr,
		return 0;
		}

		/*
		* 20.1. Operation 3: CB_GETATTR - Get Attributes
		*/
		static int nfs4_xdr_dec_cb_getattr(struct rpc_rqst *rqstp,
		struct xdr_stream *xdr,
		void *data)
		{
		struct nfsd4_callback *cb = data;
		struct nfs4_cb_compound_hdr hdr;
		int status;
		u32 bitmap[3] = {0};
		u32 attrlen;
		struct nfs4_cb_fattr *ncf =
		container_of(cb, struct nfs4_cb_fattr, ncf_getattr);

		status = decode_cb_compound4res(xdr, &hdr);
		if (unlikely(status))
		return status;

		status = decode_cb_sequence4res(xdr, cb);
		if (unlikely(status \|\| cb->cb_seq_status))
		return status;

		status = decode_cb_op_status(xdr, OP_CB_GETATTR, &cb->cb_status);
		if (status)
		return status;
		if (xdr_stream_decode_uint32_array(xdr, bitmap, 3) < 0)
		return -NFSERR_BAD_XDR;
		if (xdr_stream_decode_u32(xdr, &attrlen) < 0)
		return -NFSERR_BAD_XDR;
		if (attrlen > (sizeof(ncf->ncf_cb_change) + sizeof(ncf->ncf_cb_fsize)))
		return -NFSERR_BAD_XDR;
		status = decode_cb_fattr4(xdr, bitmap, ncf);
		return status;
		}

		/*
		* 20.2. Operation 4: CB_RECALL - Recall a Delegation
		*/
		@@ -949,7 +855,6 @@ static const struct rpc_procinfo nfs4_cb_procedures[] = {
		PROC(CB_NOTIFY_LOCK, COMPOUND, cb_notify_lock, cb_notify_lock),
		PROC(CB_OFFLOAD, COMPOUND, cb_offload, cb_offload),
		PROC(CB_RECALL_ANY, COMPOUND, cb_recall_any, cb_recall_any),
		PROC(CB_GETATTR, COMPOUND, cb_getattr, cb_getattr),
		};

		static unsigned int nfs4_cb_counts[ARRAY_SIZE(nfs4_cb_procedures)];

fs/nfsd/nfs4state.c

+11 −103

Original line number	Diff line number	Diff line
		@@ -127,7 +127,6 @@ static void free_session(struct nfsd4_session *);

		static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
		static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
		static const struct nfsd4_callback_ops nfsd4_cb_getattr_ops;

		static struct workqueue_struct *laundry_wq;

		@@ -1190,10 +1189,6 @@ alloc_init_deleg(struct nfs4_client clp, struct nfs4_file fp,
		dp->dl_recalled = false;
		nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
		&nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
		nfsd4_init_cb(&dp->dl_cb_fattr.ncf_getattr, dp->dl_stid.sc_client,
		&nfsd4_cb_getattr_ops, NFSPROC4_CLNT_CB_GETATTR);
		dp->dl_cb_fattr.ncf_file_modified = false;
		dp->dl_cb_fattr.ncf_cb_bmap[0] = FATTR4_WORD0_CHANGE \| FATTR4_WORD0_SIZE;
		get_nfs4_file(fp);
		dp->dl_stid.sc_file = fp;
		return dp;
		@@ -2901,56 +2896,11 @@ nfsd4_cb_recall_any_release(struct nfsd4_callback *cb)
		spin_unlock(&nn->client_lock);
		}

		static int
		nfsd4_cb_getattr_done(struct nfsd4_callback cb, struct rpc_task task)
		{
		struct nfs4_cb_fattr *ncf =
		container_of(cb, struct nfs4_cb_fattr, ncf_getattr);

		ncf->ncf_cb_status = task->tk_status;
		switch (task->tk_status) {
		case -NFS4ERR_DELAY:
		rpc_delay(task, 2 * HZ);
		return 0;
		default:
		return 1;
		}
		}

		static void
		nfsd4_cb_getattr_release(struct nfsd4_callback *cb)
		{
		struct nfs4_cb_fattr *ncf =
		container_of(cb, struct nfs4_cb_fattr, ncf_getattr);
		struct nfs4_delegation *dp =
		container_of(ncf, struct nfs4_delegation, dl_cb_fattr);

		nfs4_put_stid(&dp->dl_stid);
		clear_bit(CB_GETATTR_BUSY, &ncf->ncf_cb_flags);
		wake_up_bit(&ncf->ncf_cb_flags, CB_GETATTR_BUSY);
		}

		static const struct nfsd4_callback_ops nfsd4_cb_recall_any_ops = {
		.done = nfsd4_cb_recall_any_done,
		.release = nfsd4_cb_recall_any_release,
		};

		static const struct nfsd4_callback_ops nfsd4_cb_getattr_ops = {
		.done = nfsd4_cb_getattr_done,
		.release = nfsd4_cb_getattr_release,
		};

		void nfs4_cb_getattr(struct nfs4_cb_fattr *ncf)
		{
		struct nfs4_delegation *dp =
		container_of(ncf, struct nfs4_delegation, dl_cb_fattr);

		if (test_and_set_bit(CB_GETATTR_BUSY, &ncf->ncf_cb_flags))
		return;
		refcount_inc(&dp->dl_stid.sc_count);
		nfsd4_run_cb(&ncf->ncf_getattr);
		}

		static struct nfs4_client *create_client(struct xdr_netobj name,
		struct svc_rqst rqstp, nfs4_verifier verf)
		{
		@@ -5685,8 +5635,6 @@ nfs4_open_delegation(struct nfsd4_open open, struct nfs4_ol_stateid stp,
		struct svc_fh *parent = NULL;
		int cb_up;
		int status = 0;
		struct kstat stat;
		struct path path;

		cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
		open->op_recall = false;
		@@ -5724,18 +5672,6 @@ nfs4_open_delegation(struct nfsd4_open open, struct nfs4_ol_stateid stp,
		if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) {
		open->op_delegate_type = NFS4_OPEN_DELEGATE_WRITE;
		trace_nfsd_deleg_write(&dp->dl_stid.sc_stateid);
		path.mnt = currentfh->fh_export->ex_path.mnt;
		path.dentry = currentfh->fh_dentry;
		if (vfs_getattr(&path, &stat,
		(STATX_SIZE \| STATX_CTIME \| STATX_CHANGE_COOKIE),
		AT_STATX_SYNC_AS_STAT)) {
		nfs4_put_stid(&dp->dl_stid);
		destroy_delegation(dp);
		goto out_no_deleg;
		}
		dp->dl_cb_fattr.ncf_cur_fsize = stat.size;
		dp->dl_cb_fattr.ncf_initial_cinfo =
		nfsd4_change_attribute(&stat, d_inode(currentfh->fh_dentry));
		} else {
		open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
		trace_nfsd_deleg_read(&dp->dl_stid.sc_stateid);
		@@ -8492,8 +8428,6 @@ nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
		* nfsd4_deleg_getattr_conflict - Recall if GETATTR causes conflict
		* @rqstp: RPC transaction context
		* @inode: file to be checked for a conflict
		* @modified: return true if file was modified
		* @size: new size of file if modified is true
		*
		* This function is called when there is a conflict between a write
		* delegation and a change/size GETATTR from another client. The server
		@@ -8502,23 +8436,21 @@ nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
		* delegation before replying to the GETATTR. See RFC 8881 section
		* 18.7.4.
		*
		* The current implementation does not support CB_GETATTR yet. However
		* this can avoid recalling the delegation could be added in follow up
		* work.
		*
		* Returns 0 if there is no conflict; otherwise an nfs_stat
		* code is returned.
		*/
		__be32
		nfsd4_deleg_getattr_conflict(struct svc_rqst rqstp, struct inode inode,
		bool modified, u64 size)
		nfsd4_deleg_getattr_conflict(struct svc_rqst rqstp, struct inode inode)
		{
		__be32 status;
		struct file_lock_context *ctx;
		struct nfs4_delegation *dp;
		struct nfs4_cb_fattr *ncf;
		struct file_lock *fl;
		struct iattr attrs;
		__be32 status;

		might_sleep();
		struct nfs4_delegation *dp;

		*modified = false;
		ctx = locks_inode_context(inode);
		if (!ctx)
		return 0;
		@@ -8545,34 +8477,10 @@ nfsd4_deleg_getattr_conflict(struct svc_rqst rqstp, struct inode inode,
		break_lease:
		spin_unlock(&ctx->flc_lock);
		nfsd_stats_wdeleg_getattr_inc();

		dp = fl->fl_owner;
		ncf = &dp->dl_cb_fattr;
		nfs4_cb_getattr(&dp->dl_cb_fattr);
		wait_on_bit(&ncf->ncf_cb_flags, CB_GETATTR_BUSY, TASK_INTERRUPTIBLE);
		if (ncf->ncf_cb_status) {
		status = nfserrno(nfsd_open_break_lease(inode, NFSD_MAY_READ));
		if (status != nfserr_jukebox \|\|
		!nfsd_wait_for_delegreturn(rqstp, inode))
		return status;
		}
		if (!ncf->ncf_file_modified &&
		(ncf->ncf_initial_cinfo != ncf->ncf_cb_change \|\|
		ncf->ncf_cur_fsize != ncf->ncf_cb_fsize))
		ncf->ncf_file_modified = true;
		if (ncf->ncf_file_modified) {
		/*
		* The server would not update the file's metadata
		* with the client's modified size.
		*/
		attrs.ia_mtime = attrs.ia_ctime = current_time(inode);
		attrs.ia_valid = ATTR_MTIME \| ATTR_CTIME;
		setattr_copy(&nop_mnt_idmap, inode, &attrs);
		mark_inode_dirty(inode);
		ncf->ncf_cur_fsize = ncf->ncf_cb_fsize;
		*size = ncf->ncf_cur_fsize;
		*modified = true;
		}
		return 0;
		}
		break;

fs/nfsd/nfs4xdr.c

+2 −5

Original line number	Diff line number	Diff line
		@@ -3505,9 +3505,7 @@ nfsd4_encode_fattr4(struct svc_rqst rqstp, struct xdr_stream xdr,
		u32 attrmask[3];
		unsigned long mask[2];
		} u;
		bool file_modified;
		unsigned long bit;
		u64 size = 0;

		WARN_ON_ONCE(bmval[1] & NFSD_WRITEONLY_ATTRS_WORD1);
		WARN_ON_ONCE(!nfsd_attrs_supported(minorversion, bmval));
		@@ -3534,8 +3532,7 @@ nfsd4_encode_fattr4(struct svc_rqst rqstp, struct xdr_stream xdr,
		}
		args.size = 0;
		if (u.attrmask[0] & (FATTR4_WORD0_CHANGE \| FATTR4_WORD0_SIZE)) {
		status = nfsd4_deleg_getattr_conflict(rqstp, d_inode(dentry),
		&file_modified, &size);
		status = nfsd4_deleg_getattr_conflict(rqstp, d_inode(dentry));
		if (status)
		goto out;
		}
		@@ -3545,7 +3542,7 @@ nfsd4_encode_fattr4(struct svc_rqst rqstp, struct xdr_stream xdr,
		AT_STATX_SYNC_AS_STAT);
		if (err)
		goto out_nfserr;
		args.size = file_modified ? size : args.stat.size;
		args.size = args.stat.size;

		if (!(args.stat.result_mask & STATX_BTIME))
		/* underlying FS does not offer btime so we can't share it */

fs/nfsd/nfsctl.c

+10 −8

Original line number	Diff line number	Diff line
		@@ -705,7 +705,9 @@ static ssize_t __write_ports_addfd(char buf, struct net net, const struct cred

		err = svc_addsock(nn->nfsd_serv, net, fd, buf, SIMPLE_TRANSACTION_LIMIT, cred);

		if (err >= 0 &&
		if (err < 0 && !nn->nfsd_serv->sv_nrthreads && !nn->keep_active)
		nfsd_last_thread(net);
		else if (err >= 0 &&
		!nn->nfsd_serv->sv_nrthreads && !xchg(&nn->keep_active, 1))
		svc_get(nn->nfsd_serv);

		@@ -757,6 +759,9 @@ static ssize_t __write_ports_addxprt(char buf, struct net net, const struct cr
		svc_xprt_put(xprt);
		}
		out_err:
		if (!nn->nfsd_serv->sv_nrthreads && !nn->keep_active)
		nfsd_last_thread(net);

		nfsd_put(net);
		return err;
		}
		@@ -1510,10 +1515,9 @@ int nfsd_nl_rpc_status_get_start(struct netlink_callback *cb)
		int ret = -ENODEV;

		mutex_lock(&nfsd_mutex);
		if (nn->nfsd_serv) {
		svc_get(nn->nfsd_serv);
		if (nn->nfsd_serv)
		ret = 0;
		}
		else
		mutex_unlock(&nfsd_mutex);

		return ret;
		@@ -1686,8 +1690,6 @@ int nfsd_nl_rpc_status_get_dumpit(struct sk_buff *skb,
		*/
		int nfsd_nl_rpc_status_get_done(struct netlink_callback *cb)
		{
		mutex_lock(&nfsd_mutex);
		nfsd_put(sock_net(cb->skb->sk));
		mutex_unlock(&nfsd_mutex);

		return 0;

fs/nfsd/nfsd.h

+1 −0

Original line number	Diff line number	Diff line
		@@ -155,6 +155,7 @@ int nfsd_vers(struct nfsd_net *nn, int vers, enum vers_op change);
		int nfsd_minorversion(struct nfsd_net *nn, u32 minorversion, enum vers_op change);
		void nfsd_reset_versions(struct nfsd_net *nn);
		int nfsd_create_serv(struct net *net);
		void nfsd_last_thread(struct net *net);

		extern int nfsd_max_blksize;