Commit c4a86165 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfs-for-4.9-1' of git://git.linux-nfs.org/projects/anna/linux-nfs 

Pull NFS client updates from Anna Schumaker:
 "Highlights include:

  Stable bugfixes:
   - sunrpc: fix writ espace race causing stalls
   - NFS: Fix inode corruption in nfs_prime_dcache()
   - NFSv4: Don't report revoked delegations as valid in nfs_have_delegation()
   - NFSv4: nfs4_copy_delegation_stateid() must fail if the delegation is invalid
   - NFSv4: Open state recovery must account for file permission changes
   - NFSv4.2: Fix a reference leak in nfs42_proc_layoutstats_generic

  Features:
   - Add support for tracking multiple layout types with an ordered list
   - Add support for using multiple backchannel threads on the client
   - Add support for pNFS file layout session trunking
   - Delay xprtrdma use of DMA API (for device driver removal)
   - Add support for xprtrdma remote invalidation
   - Add support for larger xprtrdma inline thresholds
   - Use a scatter/gather list for sending xprtrdma RPC calls
   - Add support for the CB_NOTIFY_LOCK callback
   - Improve hashing sunrpc auth_creds by using both uid and gid

  Bugfixes:
   - Fix xprtrdma use of DMA API
   - Validate filenames before adding to the dcache
   - Fix corruption of xdr->nwords in xdr_copy_to_scratch
   - Fix setting buffer length in xdr_set_next_buffer()
   - Don't deadlock the state manager on the SEQUENCE status flags
   - Various delegation and stateid related fixes
   - Retry operations if an interrupted slot receives EREMOTEIO
   - Make nfs boot time y2038 safe"

* tag 'nfs-for-4.9-1' of git://git.linux-nfs.org/projects/anna/linux-nfs: (100 commits)
  NFSv4.2: Fix a reference leak in nfs42_proc_layoutstats_generic
  fs: nfs: Make nfs boot time y2038 safe
  sunrpc: replace generic auth_cred hash with auth-specific function
  sunrpc: add RPCSEC_GSS hash_cred() function
  sunrpc: add auth_unix hash_cred() function
  sunrpc: add generic_auth hash_cred() function
  sunrpc: add hash_cred() function to rpc_authops struct
  Retry operation on EREMOTEIO on an interrupted slot
  pNFS: Fix atime updates on pNFS clients
  sunrpc: queue work on system_power_efficient_wq
  NFSv4.1: Even if the stateid is OK, we may need to recover the open modes
  NFSv4: If recovery failed for a specific open stateid, then don't retry
  NFSv4: Fix retry issues with nfs41_test/free_stateid
  NFSv4: Open state recovery must account for file permission changes
  NFSv4: Mark the lock and open stateids as invalid after freeing them
  NFSv4: Don't test open_stateid unless it is set
  NFSv4: nfs4_do_handle_exception() handle revoke/expiry of a single stateid
  NFS: Always call nfs_inode_find_state_and_recover() when revoking a delegation
  NFSv4: Fix a race when updating an open_stateid
  NFSv4: Fix a race in nfs_inode_reclaim_delegation()
  ...
parents 27785564 3f807e5a

Documentation/kernel-parameters.txt

+12 −0
Original line number Diff line number Diff line
@@ -2470,6 +2470,11 @@ bytes respectively. Such letter suffixes can also be entirely omitted. 
	nfsrootdebug	[NFS] enable nfsroot debugging messages.

			See Documentation/filesystems/nfs/nfsroot.txt.



	nfs.callback_nr_threads=

			[NFSv4] set the total number of threads that the

			NFS client will assign to service NFSv4 callback

			requests.



	nfs.callback_tcpport=

			[NFS] set the TCP port on which the NFSv4 callback

			channel should listen.
@@ -2493,6 +2498,13 @@ bytes respectively. Such letter suffixes can also be entirely omitted. 
			of returning the full 64-bit number.

			The default is to return 64-bit inode numbers.



	nfs.max_session_cb_slots=

			[NFSv4.1] Sets the maximum number of session

			slots the client will assign to the callback

			channel. This determines the maximum number of

			callbacks the client will process in parallel for

			a particular server.



	nfs.max_session_slots=

			[NFSv4.1] Sets the maximum number of session slots

			the client will attempt to negotiate with the server.

fs/nfs/cache_lib.c

+1 −1
Original line number Diff line number Diff line
@@ -76,7 +76,7 @@ static void nfs_dns_cache_revisit(struct cache_deferred_req *d, int toomany) 


	dreq = container_of(d, struct nfs_cache_defer_req, deferred_req);



	complete_all(&dreq->completion);

	complete(&dreq->completion);

	nfs_cache_defer_req_put(dreq);

}

fs/nfs/callback.c

+54 −82
Original line number Diff line number Diff line
@@ -31,8 +31,6 @@ 
struct nfs_callback_data {

	unsigned int users;

	struct svc_serv *serv;

	struct svc_rqst *rqst;

	struct task_struct *task;

};



static struct nfs_callback_data nfs_callback_info[NFS4_MAX_MINOR_VERSION + 1];
@@ -89,15 +87,6 @@ nfs4_callback_svc(void *vrqstp) 
	return 0;

}



/*

 * Prepare to bring up the NFSv4 callback service

 */

static struct svc_rqst *

nfs4_callback_up(struct svc_serv *serv)

{

	return svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);

}



#if defined(CONFIG_NFS_V4_1)

/*

 * The callback service for NFSv4.1 callbacks
@@ -139,29 +128,6 @@ nfs41_callback_svc(void *vrqstp) 
	return 0;

}



/*

 * Bring up the NFSv4.1 callback service

 */

static struct svc_rqst *

nfs41_callback_up(struct svc_serv *serv)

{

	struct svc_rqst *rqstp;



	INIT_LIST_HEAD(&serv->sv_cb_list);

	spin_lock_init(&serv->sv_cb_lock);

	init_waitqueue_head(&serv->sv_cb_waitq);

	rqstp = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);

	dprintk("--> %s return %d\n", __func__, PTR_ERR_OR_ZERO(rqstp));

	return rqstp;

}



static void nfs_minorversion_callback_svc_setup(struct svc_serv *serv,

		struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))

{

	*rqstpp = nfs41_callback_up(serv);

	*callback_svc = nfs41_callback_svc;

}



static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,

		struct svc_serv *serv)

{
@@ -173,13 +139,6 @@ static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt, 
		xprt->bc_serv = serv;

}

#else

static void nfs_minorversion_callback_svc_setup(struct svc_serv *serv,

		struct svc_rqst **rqstpp, int (**callback_svc)(void *vrqstp))

{

	*rqstpp = ERR_PTR(-ENOTSUPP);

	*callback_svc = ERR_PTR(-ENOTSUPP);

}



static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt,

		struct svc_serv *serv)

{
@@ -189,45 +148,22 @@ static inline void nfs_callback_bc_serv(u32 minorversion, struct rpc_xprt *xprt, 
static int nfs_callback_start_svc(int minorversion, struct rpc_xprt *xprt,

				  struct svc_serv *serv)

{

	struct svc_rqst *rqstp;

	int (*callback_svc)(void *vrqstp);

	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];

	int nrservs = nfs_callback_nr_threads;

	int ret;



	nfs_callback_bc_serv(minorversion, xprt, serv);



	if (cb_info->task)

		return 0;



	switch (minorversion) {

	case 0:

		/* v4.0 callback setup */

		rqstp = nfs4_callback_up(serv);

		callback_svc = nfs4_callback_svc;

		break;

	default:

		nfs_minorversion_callback_svc_setup(serv,

				&rqstp, &callback_svc);

	}



	if (IS_ERR(rqstp))

		return PTR_ERR(rqstp);

	if (nrservs < NFS4_MIN_NR_CALLBACK_THREADS)

		nrservs = NFS4_MIN_NR_CALLBACK_THREADS;



	svc_sock_update_bufs(serv);

	if (serv->sv_nrthreads-1 == nrservs)

		return 0;



	cb_info->serv = serv;

	cb_info->rqst = rqstp;

	cb_info->task = kthread_create(callback_svc, cb_info->rqst,

				    "nfsv4.%u-svc", minorversion);

	if (IS_ERR(cb_info->task)) {

		ret = PTR_ERR(cb_info->task);

		svc_exit_thread(cb_info->rqst);

		cb_info->rqst = NULL;

		cb_info->task = NULL;

	ret = serv->sv_ops->svo_setup(serv, NULL, nrservs);

	if (ret) {

		serv->sv_ops->svo_setup(serv, NULL, 0);

		return ret;

	}

	rqstp->rq_task = cb_info->task;

	wake_up_process(cb_info->task);

	dprintk("nfs_callback_up: service started\n");

	return 0;

}
@@ -281,19 +217,41 @@ err_bind: 
	return ret;

}



static struct svc_serv_ops nfs_cb_sv_ops = {

static struct svc_serv_ops nfs40_cb_sv_ops = {

	.svo_function		= nfs4_callback_svc,

	.svo_enqueue_xprt	= svc_xprt_do_enqueue,

	.svo_setup		= svc_set_num_threads,

	.svo_module		= THIS_MODULE,

};

#if defined(CONFIG_NFS_V4_1)

static struct svc_serv_ops nfs41_cb_sv_ops = {

	.svo_function		= nfs41_callback_svc,

	.svo_enqueue_xprt	= svc_xprt_do_enqueue,

	.svo_setup		= svc_set_num_threads,

	.svo_module		= THIS_MODULE,

};



struct svc_serv_ops *nfs4_cb_sv_ops[] = {

	[0] = &nfs40_cb_sv_ops,

	[1] = &nfs41_cb_sv_ops,

};

#else

struct svc_serv_ops *nfs4_cb_sv_ops[] = {

	[0] = &nfs40_cb_sv_ops,

	[1] = NULL,

};

#endif



static struct svc_serv *nfs_callback_create_svc(int minorversion)

{

	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];

	struct svc_serv *serv;

	struct svc_serv_ops *sv_ops;



	/*

	 * Check whether we're already up and running.

	 */

	if (cb_info->task) {

	if (cb_info->serv) {

		/*

		 * Note: increase service usage, because later in case of error

		 * svc_destroy() will be called.
@@ -302,6 +260,17 @@ static struct svc_serv *nfs_callback_create_svc(int minorversion) 
		return cb_info->serv;

	}



	switch (minorversion) {

	case 0:

		sv_ops = nfs4_cb_sv_ops[0];

		break;

	default:

		sv_ops = nfs4_cb_sv_ops[1];

	}



	if (sv_ops == NULL)

		return ERR_PTR(-ENOTSUPP);



	/*

	 * Sanity check: if there's no task,

	 * we should be the first user ...
@@ -310,11 +279,12 @@ static struct svc_serv *nfs_callback_create_svc(int minorversion) 
		printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",

			cb_info->users);



	serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, &nfs_cb_sv_ops);

	serv = svc_create(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, sv_ops);

	if (!serv) {

		printk(KERN_ERR "nfs_callback_create_svc: create service failed\n");

		return ERR_PTR(-ENOMEM);

	}

	cb_info->serv = serv;

	/* As there is only one thread we need to over-ride the

	 * default maximum of 80 connections

	 */
@@ -357,6 +327,8 @@ int nfs_callback_up(u32 minorversion, struct rpc_xprt *xprt) 
	 * thread exits.

	 */

err_net:

	if (!cb_info->users)

		cb_info->serv = NULL;

	svc_destroy(serv);

err_create:

	mutex_unlock(&nfs_callback_mutex);
@@ -374,18 +346,18 @@ err_start: 
void nfs_callback_down(int minorversion, struct net *net)

{

	struct nfs_callback_data *cb_info = &nfs_callback_info[minorversion];

	struct svc_serv *serv;



	mutex_lock(&nfs_callback_mutex);

	nfs_callback_down_net(minorversion, cb_info->serv, net);

	serv = cb_info->serv;

	nfs_callback_down_net(minorversion, serv, net);

	cb_info->users--;

	if (cb_info->users == 0 && cb_info->task != NULL) {

		kthread_stop(cb_info->task);

		dprintk("nfs_callback_down: service stopped\n");

		svc_exit_thread(cb_info->rqst);

	if (cb_info->users == 0) {

		svc_get(serv);

		serv->sv_ops->svo_setup(serv, NULL, 0);

		svc_destroy(serv);

		dprintk("nfs_callback_down: service destroyed\n");

		cb_info->serv = NULL;

		cb_info->rqst = NULL;

		cb_info->task = NULL;

	}

	mutex_unlock(&nfs_callback_mutex);

}

fs/nfs/callback.h

+12 −0
Original line number Diff line number Diff line
@@ -179,6 +179,15 @@ extern __be32 nfs4_callback_devicenotify( 
	struct cb_devicenotifyargs *args,

	void *dummy, struct cb_process_state *cps);



struct cb_notify_lock_args {

	struct nfs_fh			cbnl_fh;

	struct nfs_lowner		cbnl_owner;

	bool				cbnl_valid;

};



extern __be32 nfs4_callback_notify_lock(struct cb_notify_lock_args *args,

					 void *dummy,

					 struct cb_process_state *cps);

#endif /* CONFIG_NFS_V4_1 */

extern int check_gss_callback_principal(struct nfs_client *, struct svc_rqst *);

extern __be32 nfs4_callback_getattr(struct cb_getattrargs *args,
@@ -198,6 +207,9 @@ extern void nfs_callback_down(int minorversion, struct net *net); 
#define NFS41_BC_MIN_CALLBACKS 1

#define NFS41_BC_MAX_CALLBACKS 1



#define NFS4_MIN_NR_CALLBACK_THREADS 1



extern unsigned int nfs_callback_set_tcpport;

extern unsigned short nfs_callback_nr_threads;



#endif /* __LINUX_FS_NFS_CALLBACK_H */

fs/nfs/callback_proc.c

+16 −0
Original line number Diff line number Diff line
@@ -628,4 +628,20 @@ out: 
	dprintk("%s: exit with status = %d\n", __func__, ntohl(status));

	return status;

}



__be32 nfs4_callback_notify_lock(struct cb_notify_lock_args *args, void *dummy,

				 struct cb_process_state *cps)

{

	if (!cps->clp) /* set in cb_sequence */

		return htonl(NFS4ERR_OP_NOT_IN_SESSION);



	dprintk_rcu("NFS: CB_NOTIFY_LOCK request from %s\n",

		rpc_peeraddr2str(cps->clp->cl_rpcclient, RPC_DISPLAY_ADDR));



	/* Don't wake anybody if the string looked bogus */

	if (args->cbnl_valid)

		__wake_up(&cps->clp->cl_lock_waitq, TASK_NORMAL, 0, args);



	return htonl(NFS4_OK);

}

#endif /* CONFIG_NFS_V4_1 */

CRA Git | Maintained and supported by SUSTech CRA and CCSE