lael-labs/linux

MAINTAINERS+1−3

 FILE LOCKING (flock() and fcntl()/lockf())
 M:	Jeff Layton <jlayton@kernel.org>
-M:	"J. Bruce Fields" <bfields@fieldses.org>
 L:	linux-fsdevel@vger.kernel.org
 S:	Maintained
 F:	fs/fcntl.c
 W:	http://kernelnewbies.org/KernelJanitors
 KERNEL NFSD, SUNRPC, AND LOCKD SERVERS
-M:	"J. Bruce Fields" <bfields@fieldses.org>
 M:	Chuck Lever <chuck.lever@oracle.com>
 L:	linux-nfs@vger.kernel.org
 S:	Supported
 W:	http://nfs.sourceforge.net/
-T:	git git://linux-nfs.org/~bfields/linux.git
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/cel/linux.git
 F:	fs/lockd/
 F:	fs/nfs_common/
 F:	fs/nfsd/

fs/lockd/svc.c+61−139

@@ -54,13 +54,9 @@ EXPORT_SYMBOL_GPL(nlmsvc_ops); · 53 unmodified lines
54		54
55	static DEFINE_MUTEX(nlmsvc_mutex);	55	static DEFINE_MUTEX(nlmsvc_mutex);
56	static unsigned int nlmsvc_users;	56	static unsigned int nlmsvc_users;
57	static struct task_struct *nlmsvc_task;	57	static struct svc_serv *nlmsvc_serv;
58	static struct svc_rqst *nlmsvc_rqst;
59	unsigned long nlmsvc_timeout;	58	unsigned long nlmsvc_timeout;
60		59
61	static atomic_t nlm_ntf_refcnt = ATOMIC_INIT(0);
62	static DECLARE_WAIT_QUEUE_HEAD(nlm_ntf_wq);
63
64	unsigned int lockd_net_id;	60	unsigned int lockd_net_id;
65		61
66	/*	62	/*
@@ -184,7 +180,12 @@ lockd(void *vrqstp) · 117 unmodified lines
184	nlm_shutdown_hosts();	180	nlm_shutdown_hosts();
185	cancel_delayed_work_sync(&ln->grace_period_end);	181	cancel_delayed_work_sync(&ln->grace_period_end);
186	locks_end_grace(&ln->lockd_manager);	182	locks_end_grace(&ln->lockd_manager);
187	return 0;	183
		184	dprintk("lockd_down: service stopped\n");
		185
		186	svc_exit_thread(rqstp);
		187
		188	module_put_and_exit(0);
188	}	189	}
189		190
190	static int create_lockd_listener(struct svc_serv serv, const char name,	191	static int create_lockd_listener(struct svc_serv serv, const char name,
@@ -290,8 +291,8 @@ static void lockd_down_net(struct svc_serv serv, struct net net) · 99 unmodified lines
290	__func__, net->ns.inum);	291	__func__, net->ns.inum);
291	}	292	}
292	} else {	293	} else {
293	pr_err("%s: no users! task=%p, net=%x\n",	294	pr_err("%s: no users! net=%x\n",
294	__func__, nlmsvc_task, net->ns.inum);	295	__func__, net->ns.inum);
295	BUG();	296	BUG();
296	}	297	}
297	}	298	}
@@ -302,20 +303,16 @@ static int lockd_inetaddr_event(struct notifier_block *this, · 4 unmodified lines
302	struct in_ifaddr ifa = (struct in_ifaddr )ptr;	303	struct in_ifaddr ifa = (struct in_ifaddr )ptr;
303	struct sockaddr_in sin;	304	struct sockaddr_in sin;
304		305
305	if ((event != NETDEV_DOWN) \|\|	306	if (event != NETDEV_DOWN)
306	!atomic_inc_not_zero(&nlm_ntf_refcnt))
307	goto out;	307	goto out;
308		308
309	if (nlmsvc_rqst) {	309	if (nlmsvc_serv) {
310	dprintk("lockd_inetaddr_event: removed %pI4\n",	310	dprintk("lockd_inetaddr_event: removed %pI4\n",
311	&ifa->ifa_local);	311	&ifa->ifa_local);
312	sin.sin_family = AF_INET;	312	sin.sin_family = AF_INET;
313	sin.sin_addr.s_addr = ifa->ifa_local;	313	sin.sin_addr.s_addr = ifa->ifa_local;
314	svc_age_temp_xprts_now(nlmsvc_rqst->rq_server,	314	svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin);
315	(struct sockaddr *)&sin);
316	}	315	}
317	atomic_dec(&nlm_ntf_refcnt);
318	wake_up(&nlm_ntf_wq);
319		316
320	out:	317	out:
321	return NOTIFY_DONE;	318	return NOTIFY_DONE;
@@ -332,21 +329,17 @@ static int lockd_inet6addr_event(struct notifier_block *this, · 10 unmodified lines
332	struct inet6_ifaddr ifa = (struct inet6_ifaddr )ptr;	329	struct inet6_ifaddr ifa = (struct inet6_ifaddr )ptr;
333	struct sockaddr_in6 sin6;	330	struct sockaddr_in6 sin6;
334		331
335	if ((event != NETDEV_DOWN) \|\|	332	if (event != NETDEV_DOWN)
336	!atomic_inc_not_zero(&nlm_ntf_refcnt))
337	goto out;	333	goto out;
338		334
339	if (nlmsvc_rqst) {	335	if (nlmsvc_serv) {
340	dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr);	336	dprintk("lockd_inet6addr_event: removed %pI6\n", &ifa->addr);
341	sin6.sin6_family = AF_INET6;	337	sin6.sin6_family = AF_INET6;
342	sin6.sin6_addr = ifa->addr;	338	sin6.sin6_addr = ifa->addr;
343	if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)	339	if (ipv6_addr_type(&sin6.sin6_addr) & IPV6_ADDR_LINKLOCAL)
344	sin6.sin6_scope_id = ifa->idev->dev->ifindex;	340	sin6.sin6_scope_id = ifa->idev->dev->ifindex;
345	svc_age_temp_xprts_now(nlmsvc_rqst->rq_server,	341	svc_age_temp_xprts_now(nlmsvc_serv, (struct sockaddr *)&sin6);
346	(struct sockaddr *)&sin6);
347	}	342	}
348	atomic_dec(&nlm_ntf_refcnt);
349	wake_up(&nlm_ntf_wq);
350		343
351	out:	344	out:
352	return NOTIFY_DONE;	345	return NOTIFY_DONE;
@@ -357,86 +350,22 @@ static struct notifier_block lockd_inet6addr_notifier = { · 4 unmodified lines
357	};	350	};
358	#endif	351	#endif
359		352
360	static void lockd_unregister_notifiers(void)
361	{
362	unregister_inetaddr_notifier(&lockd_inetaddr_notifier);
363	#if IS_ENABLED(CONFIG_IPV6)
364	unregister_inet6addr_notifier(&lockd_inet6addr_notifier);
365	#endif
366	wait_event(nlm_ntf_wq, atomic_read(&nlm_ntf_refcnt) == 0);
367	}
368
369	static void lockd_svc_exit_thread(void)
370	{
371	atomic_dec(&nlm_ntf_refcnt);
372	lockd_unregister_notifiers();
373	svc_exit_thread(nlmsvc_rqst);
374	}
375
376	static int lockd_start_svc(struct svc_serv *serv)
377	{
378	int error;
379
380	if (nlmsvc_rqst)
381	return 0;
382
383	/*
384	* Create the kernel thread and wait for it to start.
385	*/
386	nlmsvc_rqst = svc_prepare_thread(serv, &serv->sv_pools[0], NUMA_NO_NODE);
387	if (IS_ERR(nlmsvc_rqst)) {
388	error = PTR_ERR(nlmsvc_rqst);
389	printk(KERN_WARNING
390	"lockd_up: svc_rqst allocation failed, error=%d\n",
391	error);
392	lockd_unregister_notifiers();
393	goto out_rqst;
394	}
395
396	atomic_inc(&nlm_ntf_refcnt);
397	svc_sock_update_bufs(serv);
398	serv->sv_maxconn = nlm_max_connections;
399
400	nlmsvc_task = kthread_create(lockd, nlmsvc_rqst, "%s", serv->sv_name);
401	if (IS_ERR(nlmsvc_task)) {
402	error = PTR_ERR(nlmsvc_task);
403	printk(KERN_WARNING
404	"lockd_up: kthread_run failed, error=%d\n", error);
405	goto out_task;
406	}
407	nlmsvc_rqst->rq_task = nlmsvc_task;
408	wake_up_process(nlmsvc_task);
409
410	dprintk("lockd_up: service started\n");
411	return 0;
412
413	out_task:
414	lockd_svc_exit_thread();
415	nlmsvc_task = NULL;
416	out_rqst:
417	nlmsvc_rqst = NULL;
418	return error;
419	}
420
421	static const struct svc_serv_ops lockd_sv_ops = {	353	static const struct svc_serv_ops lockd_sv_ops = {
422	.svo_shutdown = svc_rpcb_cleanup,	354	.svo_shutdown = svc_rpcb_cleanup,
		355	.svo_function = lockd,
423	.svo_enqueue_xprt = svc_xprt_do_enqueue,	356	.svo_enqueue_xprt = svc_xprt_do_enqueue,
		357	.svo_module = THIS_MODULE,
424	};	358	};
425		359
426	static struct svc_serv *lockd_create_svc(void)	360	static int lockd_get(void)
427	{	361	{
428	struct svc_serv *serv;	362	struct svc_serv *serv;
		363	int error;
429		364
430	/*	365	if (nlmsvc_serv) {
431	* Check whether we're already up and running.	366	svc_get(nlmsvc_serv);
432	*/	367	nlmsvc_users++;
433	if (nlmsvc_rqst) {	368	return 0;
434	/*
435	* Note: increase service usage, because later in case of error
436	* svc_destroy() will be called.
437	*/
438	svc_get(nlmsvc_rqst->rq_server);
439	return nlmsvc_rqst->rq_server;
440	}	369	}
441		370
442	/*	371	/*
@@ -454,14 +383,41 @@ static struct svc_serv *lockd_create_svc(void) · 11 unmodified lines
454	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, &lockd_sv_ops);	383	serv = svc_create(&nlmsvc_program, LOCKD_BUFSIZE, &lockd_sv_ops);
455	if (!serv) {	384	if (!serv) {
456	printk(KERN_WARNING "lockd_up: create service failed\n");	385	printk(KERN_WARNING "lockd_up: create service failed\n");
457	return ERR_PTR(-ENOMEM);	386	return -ENOMEM;
458	}	387	}
		388
		389	serv->sv_maxconn = nlm_max_connections;
		390	error = svc_set_num_threads(serv, NULL, 1);
		391	/* The thread now holds the only reference */
		392	svc_put(serv);
		393	if (error < 0)
		394	return error;
		395
		396	nlmsvc_serv = serv;
459	register_inetaddr_notifier(&lockd_inetaddr_notifier);	397	register_inetaddr_notifier(&lockd_inetaddr_notifier);
460	#if IS_ENABLED(CONFIG_IPV6)	398	#if IS_ENABLED(CONFIG_IPV6)
461	register_inet6addr_notifier(&lockd_inet6addr_notifier);	399	register_inet6addr_notifier(&lockd_inet6addr_notifier);
462	#endif	400	#endif
463	dprintk("lockd_up: service created\n");	401	dprintk("lockd_up: service created\n");
464	return serv;	402	nlmsvc_users++;
		403	return 0;
		404	}
		405
		406	static void lockd_put(void)
		407	{
		408	if (WARN(nlmsvc_users <= 0, "lockd_down: no users!\n"))
		409	return;
		410	if (--nlmsvc_users)
		411	return;
		412
		413	unregister_inetaddr_notifier(&lockd_inetaddr_notifier);
		414	#if IS_ENABLED(CONFIG_IPV6)
		415	unregister_inet6addr_notifier(&lockd_inet6addr_notifier);
		416	#endif
		417
		418	svc_set_num_threads(nlmsvc_serv, NULL, 0);
		419	nlmsvc_serv = NULL;
		420	dprintk("lockd_down: service destroyed\n");
465	}	421	}
466		422
467	/*	423	/*
@@ -469,36 +425,21 @@ static struct svc_serv *lockd_create_svc(void) · 1 unmodified line
469	*/	425	*/
470	int lockd_up(struct net net, const struct cred cred)	426	int lockd_up(struct net net, const struct cred cred)
471	{	427	{
472	struct svc_serv *serv;
473	int error;	428	int error;
474		429
475	mutex_lock(&nlmsvc_mutex);	430	mutex_lock(&nlmsvc_mutex);
476		431
477	serv = lockd_create_svc();	432	error = lockd_get();
478	if (IS_ERR(serv)) {	433	if (error)
479	error = PTR_ERR(serv);	434	goto err;
480	goto err_create;
481	}
482		435
483	error = lockd_up_net(serv, net, cred);	436	error = lockd_up_net(nlmsvc_serv, net, cred);
484	if (error < 0) {	437	if (error < 0) {
485	lockd_unregister_notifiers();	438	lockd_put();
486	goto err_put;	439	goto err;
487	}	440	}
488		441
489	error = lockd_start_svc(serv);	442	err:
490	if (error < 0) {
491	lockd_down_net(serv, net);
492	goto err_put;
493	}
494	nlmsvc_users++;
495	/*
496	* Note: svc_serv structures have an initial use count of 1,
497	* so we exit through here on both success and failure.
498	*/
499	err_put:
500	svc_destroy(serv);
501	err_create:
502	mutex_unlock(&nlmsvc_mutex);	443	mutex_unlock(&nlmsvc_mutex);
503	return error;	444	return error;
504	}	445	}
@@ -511,27 +452,8 @@ void · 6 unmodified lines
511	lockd_down(struct net *net)	452	lockd_down(struct net *net)
512	{	453	{
513	mutex_lock(&nlmsvc_mutex);	454	mutex_lock(&nlmsvc_mutex);
514	lockd_down_net(nlmsvc_rqst->rq_server, net);	455	lockd_down_net(nlmsvc_serv, net);
515	if (nlmsvc_users) {	456	lockd_put();
516	if (--nlmsvc_users)
517	goto out;
518	} else {
519	printk(KERN_ERR "lockd_down: no users! task=%p\n",
520	nlmsvc_task);
521	BUG();
522	}
523
524	if (!nlmsvc_task) {
525	printk(KERN_ERR "lockd_down: no lockd running.\n");
526	BUG();
527	}
528	kthread_stop(nlmsvc_task);
529	dprintk("lockd_down: service stopped\n");
530	lockd_svc_exit_thread();
531	dprintk("lockd_down: service destroyed\n");
532	nlmsvc_task = NULL;
533	nlmsvc_rqst = NULL;
534	out:
535	mutex_unlock(&nlmsvc_mutex);	457	mutex_unlock(&nlmsvc_mutex);
536	}	458	}
537	EXPORT_SYMBOL_GPL(lockd_down);	459	EXPORT_SYMBOL_GPL(lockd_down);

fs/lockd/svclock.c+4−2

 	    struct nlm_host *host, struct nlm_lock *lock, int wait,
 	    struct nlm_cookie *cookie, int reclaim)
 {
-	struct nlm_block	*block = NULL;
+#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
 	struct inode		*inode = nlmsvc_file_inode(file);
+#endif
+	struct nlm_block	*block = NULL;
 	int			error;
 	int			mode;
 	int			async_block = 0;
 				(long long)lock->fl.fl_end,
 				wait);
-	if (inode->i_sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS) {
+	if (nlmsvc_file_file(file)->f_op->lock) {
 		async_block = wait;
 		wait = 0;
 	}

fs/nfs/callback.c+9−23

 	if (nrservs < NFS4_MIN_NR_CALLBACK_THREADS)
 		nrservs = NFS4_MIN_NR_CALLBACK_THREADS;
-	if (serv->sv_nrthreads-1 == nrservs)
+	if (serv->sv_nrthreads == nrservs)
 		return 0;
-	ret = serv->sv_ops->svo_setup(serv, NULL, nrservs);
+	ret = svc_set_num_threads(serv, NULL, nrservs);
 	if (ret) {
-		serv->sv_ops->svo_setup(serv, NULL, 0);
+		svc_set_num_threads(serv, NULL, 0);
 		return ret;
 	}
 	dprintk("nfs_callback_up: service started\n");
 static const 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_sync,
 	.svo_module		= THIS_MODULE,
 };
 #if defined(CONFIG_NFS_V4_1)
 static const 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_sync,
 	.svo_module		= THIS_MODULE,
 };
 	/*
 	 * Check whether we're already up and running.
 	 */
-	if (cb_info->serv) {
+	if (cb_info->serv)
-		/*
+		return svc_get(cb_info->serv);
-		 * Note: increase service usage, because later in case of error
-		 * svc_destroy() will be called.
-		 */
-		svc_get(cb_info->serv);
-		return cb_info->serv;
-	}
 	switch (minorversion) {
 	case 0:
 		printk(KERN_WARNING "nfs_callback_create_svc: no kthread, %d users??\n",
 			cb_info->users);
-	serv = svc_create_pooled(&nfs4_callback_program, NFS4_CALLBACK_BUFSIZE, 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);
 		goto err_start;
 	cb_info->users++;
-	/*
-	 * svc_create creates the svc_serv with sv_nrthreads == 1, and then
-	 * svc_prepare_thread increments that. So we need to call svc_destroy
-	 * on both success and failure so that the refcount is 1 when the
-	 * thread exits.
-	 */
 err_net:
 	if (!cb_info->users)
 		cb_info->serv = NULL;
-	svc_destroy(serv);
+	svc_put(serv);
 err_create:
 	mutex_unlock(&nfs_callback_mutex);
 	return ret;
 	cb_info->users--;
 	if (cb_info->users == 0) {
 		svc_get(serv);
-		serv->sv_ops->svo_setup(serv, NULL, 0);
+		svc_set_num_threads(serv, NULL, 0);
-		svc_destroy(serv);
+		svc_put(serv);
 		dprintk("nfs_callback_down: service destroyed\n");
 		cb_info->serv = NULL;
 	}

fs/nfs/export.c+1−1

@@ -158,5 +158,5 @@ const struct export_operations nfs_export_ops = { · 157 unmodified lines
158	.fetch_iversion = nfs_fetch_iversion,	158	.fetch_iversion = nfs_fetch_iversion,
159	.flags = EXPORT_OP_NOWCC\|EXPORT_OP_NOSUBTREECHK\|	159	.flags = EXPORT_OP_NOWCC\|EXPORT_OP_NOSUBTREECHK\|
160	EXPORT_OP_CLOSE_BEFORE_UNLINK\|EXPORT_OP_REMOTE_FS\|	160	EXPORT_OP_CLOSE_BEFORE_UNLINK\|EXPORT_OP_REMOTE_FS\|
161	EXPORT_OP_NOATOMIC_ATTR\|EXPORT_OP_SYNC_LOCKS,	161	EXPORT_OP_NOATOMIC_ATTR,
162	};	162	};

fs/nfsd/filecache.c+16−63

 static DEFINE_PER_CPU(unsigned long, nfsd_file_cache_hits);
 struct nfsd_fcache_disposal {
-	struct list_head list;
 	struct work_struct work;
-	struct net *net;
 	spinlock_t lock;
 	struct list_head freeme;
-	struct rcu_head rcu;
 };
 static struct workqueue_struct *nfsd_filecache_wq __read_mostly;
 static struct fsnotify_group		*nfsd_file_fsnotify_group;
 static atomic_long_t			nfsd_filecache_count;
 static struct delayed_work		nfsd_filecache_laundrette;
-static DEFINE_SPINLOCK(laundrette_lock);
-static LIST_HEAD(laundrettes);
 static void nfsd_file_gc(void);
 				__set_bit(NFSD_FILE_BREAK_READ, &nf->nf_flags);
 		}
 		nf->nf_mark = NULL;
-		init_rwsem(&nf->nf_rwsem);
 		trace_nfsd_file_alloc(nf);
 	}
 	return nf;
 	trace_nfsd_file_unhash(nf);
 	if (nfsd_file_check_write_error(nf))
-		nfsd_reset_boot_verifier(net_generic(nf->nf_net, nfsd_net_id));
+		nfsd_reset_write_verifier(net_generic(nf->nf_net, nfsd_net_id));
 	--nfsd_file_hashtbl[nf->nf_hashval].nfb_count;
 	hlist_del_rcu(&nf->nf_node);
 	atomic_long_dec(&nfsd_filecache_count);
 static void
 nfsd_file_list_add_disposal(struct list_head *files, struct net *net)
 {
-	struct nfsd_fcache_disposal *l;
+	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+	struct nfsd_fcache_disposal *l = nn->fcache_disposal;
-	rcu_read_lock();
+	spin_lock(&l->lock);
-	list_for_each_entry_rcu(l, &laundrettes, list) {
+	list_splice_tail_init(files, &l->freeme);
-		if (l->net == net) {
+	spin_unlock(&l->lock);
-			spin_lock(&l->lock);
+	queue_work(nfsd_filecache_wq, &l->work);
-			list_splice_tail_init(files, &l->freeme);
-			spin_unlock(&l->lock);
-			queue_work(nfsd_filecache_wq, &l->work);
-			break;
-		}
-	}
-	rcu_read_unlock();
 }
 static void
 }
 static struct nfsd_fcache_disposal *
-nfsd_alloc_fcache_disposal(struct net *net)
+nfsd_alloc_fcache_disposal(void)
 {
 	struct nfsd_fcache_disposal *l;
 	if (!l)
 		return NULL;
 	INIT_WORK(&l->work, nfsd_file_delayed_close);
-	l->net = net;
 	spin_lock_init(&l->lock);
 	INIT_LIST_HEAD(&l->freeme);
 	return l;
 static void
 nfsd_free_fcache_disposal(struct nfsd_fcache_disposal *l)
 {
-	rcu_assign_pointer(l->net, NULL);
 	cancel_work_sync(&l->work);
 	nfsd_file_dispose_list(&l->freeme);
-	kfree_rcu(l, rcu);
+	kfree(l);
-}
-static void
-nfsd_add_fcache_disposal(struct nfsd_fcache_disposal *l)
-{
-	spin_lock(&laundrette_lock);
-	list_add_tail_rcu(&l->list, &laundrettes);
-	spin_unlock(&laundrette_lock);
-}
-static void
-nfsd_del_fcache_disposal(struct nfsd_fcache_disposal *l)
-{
-	spin_lock(&laundrette_lock);
-	list_del_rcu(&l->list);
-	spin_unlock(&laundrette_lock);
-}
-static int
-nfsd_alloc_fcache_disposal_net(struct net *net)
-{
-	struct nfsd_fcache_disposal *l;
-	l = nfsd_alloc_fcache_disposal(net);
-	if (!l)
-		return -ENOMEM;
-	nfsd_add_fcache_disposal(l);
-	return 0;
 }
 static void
 nfsd_free_fcache_disposal_net(struct net *net)
 {
-	struct nfsd_fcache_disposal *l;
+	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+	struct nfsd_fcache_disposal *l = nn->fcache_disposal;
-	rcu_read_lock();
+	nfsd_free_fcache_disposal(l);
-	list_for_each_entry_rcu(l, &laundrettes, list) {
-		if (l->net != net)
-			continue;
-		nfsd_del_fcache_disposal(l);
-		rcu_read_unlock();
-		nfsd_free_fcache_disposal(l);
-		return;
-	}
-	rcu_read_unlock();
 }
 int
 nfsd_file_cache_start_net(struct net *net)
 {
-	return nfsd_alloc_fcache_disposal_net(net);
+	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
+	nn->fcache_disposal = nfsd_alloc_fcache_disposal();
+	return nn->fcache_disposal ? 0 : -ENOMEM;
 }
 void

fs/nfsd/filecache.h+0−1

@@ -46,7 +46,6 @@ struct nfsd_file { · 45 unmodified lines
46	refcount_t nf_ref;	46	refcount_t nf_ref;
47	unsigned char nf_may;	47	unsigned char nf_may;
48	struct nfsd_file_mark *nf_mark;	48	struct nfsd_file_mark *nf_mark;
49	struct rw_semaphore nf_rwsem;
50	};	49	};
51		50
52	int nfsd_file_cache_init(void);	51	int nfsd_file_cache_init(void);

fs/nfsd/netns.h+16−11

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	#include <net/net_namespace.h>	11	#include <net/net_namespace.h>
12	#include <net/netns/generic.h>	12	#include <net/netns/generic.h>
13	#include <linux/percpu_counter.h>	13	#include <linux/percpu_counter.h>
		14	#include <linux/siphash.h>
14		15
15	/* Hash tables for nfs4_clientid state */	16	/* Hash tables for nfs4_clientid state */
16	#define CLIENT_HASH_BITS 4	17	#define CLIENT_HASH_BITS 4
@@ -108,9 +109,8 @@ struct nfsd_net { · 91 unmodified lines
108	bool nfsd_net_up;	109	bool nfsd_net_up;
109	bool lockd_up;	110	bool lockd_up;
110		111
111	/* Time of server startup */	112	seqlock_t writeverf_lock;
112	struct timespec64 nfssvc_boot;	113	unsigned char writeverf[8];
113	seqlock_t boot_lock;
114		114
115	/*	115	/*
116	* Max number of connections this nfsd container will allow. Defaults	116	* Max number of connections this nfsd container will allow. Defaults
@@ -123,12 +123,13 @@ struct nfsd_net { · 6 unmodified lines
123	u32 clverifier_counter;	123	u32 clverifier_counter;
124		124
125	struct svc_serv *nfsd_serv;	125	struct svc_serv *nfsd_serv;
126		126	/* When a listening socket is added to nfsd, keep_active is set
127	wait_queue_head_t ntf_wq;	127	* and this justifies a reference on nfsd_serv. This stops
128	atomic_t ntf_refcnt;	128	* nfsd_serv from being freed. When the number of threads is
129		129	* set, keep_active is cleared and the reference is dropped. So
130	/* Allow umount to wait for nfsd state cleanup */	130	* when the last thread exits, the service will be destroyed.
131	struct completion nfsd_shutdown_complete;	131	*/
		132	int keep_active;
132		133
133	/*	134	/*
134	* clientid and stateid data for construction of net unique COPY	135	* clientid and stateid data for construction of net unique COPY
@@ -184,6 +185,10 @@ struct nfsd_net { · 49 unmodified lines
184		185
185	/* utsname taken from the process that starts the server */	186	/* utsname taken from the process that starts the server */
186	char nfsd_name[UNX_MAXNODENAME+1];	187	char nfsd_name[UNX_MAXNODENAME+1];
		188
		189	struct nfsd_fcache_disposal *fcache_disposal;
		190
		191	siphash_key_t siphash_key;
187	};	192	};
188		193
189	/* Simple check to find out if a given net was properly initialized */	194	/* Simple check to find out if a given net was properly initialized */
@@ -193,6 +198,6 @@ extern void nfsd_netns_free_versions(struct nfsd_net *nn); · 3 unmodified lines
193		198
194	extern unsigned int nfsd_net_id;	199	extern unsigned int nfsd_net_id;
195		200
196	void nfsd_copy_boot_verifier(__be32 verf[2], struct nfsd_net *nn);	201	void nfsd_copy_write_verifier(__be32 verf[2], struct nfsd_net *nn);
197	void nfsd_reset_boot_verifier(struct nfsd_net *nn);	202	void nfsd_reset_write_verifier(struct nfsd_net *nn);
198	#endif /* __NFSD_NETNS_H__ */	203	#endif /* __NFSD_NETNS_H__ */

fs/nfsd/nfs3proc.c+1−5

@@ -202,15 +202,11 @@ nfsd3_proc_write(struct svc_rqst *rqstp) · 201 unmodified lines
202	fh_copy(&resp->fh, &argp->fh);	202	fh_copy(&resp->fh, &argp->fh);
203	resp->committed = argp->stable;	203	resp->committed = argp->stable;
204	nvecs = svc_fill_write_vector(rqstp, &argp->payload);	204	nvecs = svc_fill_write_vector(rqstp, &argp->payload);
205	if (!nvecs) {	205
206	resp->status = nfserr_io;
207	goto out;
208	}
209	resp->status = nfsd_write(rqstp, &resp->fh, argp->offset,	206	resp->status = nfsd_write(rqstp, &resp->fh, argp->offset,
210	rqstp->rq_vec, nvecs, &cnt,	207	rqstp->rq_vec, nvecs, &cnt,
211	resp->committed, resp->verf);	208	resp->committed, resp->verf);
212	resp->count = cnt;	209	resp->count = cnt;
213	out:
214	return rpc_success;	210	return rpc_success;
215	}	211	}
216		212

fs/nfsd/nfs3xdr.c+0−65

@@ -487,71 +487,6 @@ neither: · 486 unmodified lines
487	return true;	487	return true;
488	}	488	}
489		489
490	static bool fs_supports_change_attribute(struct super_block *sb)
491	{
492	return sb->s_flags & SB_I_VERSION \|\| sb->s_export_op->fetch_iversion;
493	}
494
495	/*
496	* Fill in the pre_op attr for the wcc data
497	*/
498	void fill_pre_wcc(struct svc_fh *fhp)
499	{
500	struct inode *inode;
501	struct kstat stat;
502	bool v4 = (fhp->fh_maxsize == NFS4_FHSIZE);
503
504	if (fhp->fh_no_wcc \|\| fhp->fh_pre_saved)
505	return;
506	inode = d_inode(fhp->fh_dentry);
507	if (fs_supports_change_attribute(inode->i_sb) \|\| !v4) {
508	__be32 err = fh_getattr(fhp, &stat);
509
510	if (err) {
511	/* Grab the times from inode anyway */
512	stat.mtime = inode->i_mtime;
513	stat.ctime = inode->i_ctime;
514	stat.size = inode->i_size;
515	}
516	fhp->fh_pre_mtime = stat.mtime;
517	fhp->fh_pre_ctime = stat.ctime;
518	fhp->fh_pre_size = stat.size;
519	}
520	if (v4)
521	fhp->fh_pre_change = nfsd4_change_attribute(&stat, inode);
522
523	fhp->fh_pre_saved = true;
524	}
525
526	/*
527	* Fill in the post_op attr for the wcc data
528	*/
529	void fill_post_wcc(struct svc_fh *fhp)
530	{
531	bool v4 = (fhp->fh_maxsize == NFS4_FHSIZE);
532	struct inode *inode = d_inode(fhp->fh_dentry);
533
534	if (fhp->fh_no_wcc)
535	return;
536
537	if (fhp->fh_post_saved)
538	printk("nfsd: inode locked twice during operation.\n");
539
540	fhp->fh_post_saved = true;
541
542	if (fs_supports_change_attribute(inode->i_sb) \|\| !v4) {
543	__be32 err = fh_getattr(fhp, &fhp->fh_post_attr);
544
545	if (err) {
546	fhp->fh_post_saved = false;
547	fhp->fh_post_attr.ctime = inode->i_ctime;
548	}
549	}
550	if (v4)
551	fhp->fh_post_change =
552	nfsd4_change_attribute(&fhp->fh_post_attr, inode);
553	}
554
555	/*	490	/*
556	* XDR decode functions	491	* XDR decode functions
557	*/	492	*/

fs/nfsd/nfs4proc.c+13−11

 	BUILD_BUG_ON(2*sizeof(*verf) != sizeof(verifier->data));
-	nfsd_copy_boot_verifier(verf, net_generic(net, nfsd_net_id));
+	nfsd_copy_write_verifier(verf, net_generic(net, nfsd_net_id));
 }
 static __be32
 	if (status)
 		goto out;
-	status = nfsd4_clone_file_range(src, clone->cl_src_pos,
+	status = nfsd4_clone_file_range(rqstp, src, clone->cl_src_pos,
 			dst, clone->cl_dst_pos, clone->cl_count,
 			EX_ISSYNC(cstate->current_fh.fh_export));
 static ssize_t _nfsd_copy_file_range(struct nfsd4_copy *copy)
 {
+	struct file *dst = copy->nf_dst->nf_file;
+	struct file *src = copy->nf_src->nf_file;
+	errseq_t since;
 	ssize_t bytes_copied = 0;
 	u64 bytes_total = copy->cp_count;
 	u64 src_pos = copy->cp_src_pos;
 	u64 dst_pos = copy->cp_dst_pos;
-	__be32 status;
+	int status;
 	/* See RFC 7862 p.67: */
 	if (bytes_total == 0)
 	do {
 		if (kthread_should_stop())
 			break;
-		bytes_copied = nfsd_copy_file_range(copy->nf_src->nf_file,
+		bytes_copied = nfsd_copy_file_range(src, src_pos, dst, dst_pos,
-				src_pos, copy->nf_dst->nf_file, dst_pos,
+						    bytes_total);
-				bytes_total);
 		if (bytes_copied <= 0)
 			break;
 		bytes_total -= bytes_copied;
 	} while (bytes_total > 0 && !copy->cp_synchronous);
 	/* for a non-zero asynchronous copy do a commit of data */
 	if (!copy->cp_synchronous && copy->cp_res.wr_bytes_written > 0) {
-		down_write(&copy->nf_dst->nf_rwsem);
+		since = READ_ONCE(dst->f_wb_err);
-		status = vfs_fsync_range(copy->nf_dst->nf_file,
+		status = vfs_fsync_range(dst, copy->cp_dst_pos,
-					 copy->cp_dst_pos,
 					 copy->cp_res.wr_bytes_written, 0);
-		up_write(&copy->nf_dst->nf_rwsem);
+		if (!status)
+			status = filemap_check_wb_err(dst->f_mapping, since);
 		if (!status)
 			copy->committed = true;
 	}
 			goto encode_op;
 		}
-		fh_clear_wcc(current_fh);
+		fh_clear_pre_post_attrs(current_fh);
 		/* If op is non-idempotent */
 		if (op->opdesc->op_flags & OP_MODIFIES_SOMETHING) {

fs/nfsd/nfs4state.c+49−14

 	list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
 		if (fh_match(fh, &cur->nbl_fh)) {
 			list_del_init(&cur->nbl_list);
+			WARN_ON(list_empty(&cur->nbl_lru));
 			list_del_init(&cur->nbl_lru);
 			found = cur;
 			break;
 			INIT_LIST_HEAD(&nbl->nbl_lru);
 			fh_copy_shallow(&nbl->nbl_fh, fh);
 			locks_init_lock(&nbl->nbl_lock);
+			kref_init(&nbl->nbl_kref);
 			nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client,
 					&nfsd4_cb_notify_lock_ops,
 					NFSPROC4_CLNT_CB_NOTIFY_LOCK);
 	return nbl;
 }
+static void
+free_nbl(struct kref *kref)
+{
+	struct nfsd4_blocked_lock *nbl;
+	nbl = container_of(kref, struct nfsd4_blocked_lock, nbl_kref);
+	kfree(nbl);
+}
 static void
 free_blocked_lock(struct nfsd4_blocked_lock *nbl)
 {
 	locks_delete_block(&nbl->nbl_lock);
 	locks_release_private(&nbl->nbl_lock);
-	kfree(nbl);
+	kref_put(&nbl->nbl_kref, free_nbl);
 }
 static void
 					struct nfsd4_blocked_lock,
 					nbl_list);
 		list_del_init(&nbl->nbl_list);
+		WARN_ON(list_empty(&nbl->nbl_lru));
 		list_move(&nbl->nbl_lru, &reaplist);
 	}
 	spin_unlock(&nn->blocked_locks_lock);
  * st_{access,deny}_bmap field of the stateid, in order to track not
  * only what share bits are currently in force, but also what
  * combinations of share bits previous opens have used.  This allows us
- * to enforce the recommendation of rfc 3530 14.2.19 that the server
+ * to enforce the recommendation in
- * return an error if the client attempt to downgrade to a combination
+ * https://datatracker.ietf.org/doc/html/rfc7530#section-16.19.4 that
- * of share bits not explicable by closing some of its previous opens.
+ * the server return an error if the client attempt to downgrade to a
+ * combination of share bits not explicable by closing some of its
+ * previous opens.
  *
- * XXX: This enforcement is actually incomplete, since we don't keep
+ * This enforcement is arguably incomplete, since we don't keep
  * track of access/deny bit combinations; so, e.g., we allow:
  *
  *	OPEN allow read, deny write
  *	DOWNGRADE allow read, deny none
  *
  * which we should reject.
+ *
+ * But you could also argue that our current code is already overkill,
+ * since it only exists to return NFS4ERR_INVAL on incorrect client
+ * behavior.
  */
 static unsigned int
 bmap_to_share_mode(unsigned long bmap)
 		*nfp = NULL;
 	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
-		status = check_special_stateids(net, fhp, stateid, flags);
+		if (cstid)
+			status = nfserr_bad_stateid;
+		else
+			status = check_special_stateids(net, fhp, stateid,
+									flags);
 		goto done;
 	}
 	struct nfsd4_blocked_lock *nbl = NULL;
 	struct file_lock *file_lock = NULL;
 	struct file_lock *conflock = NULL;
-	struct super_block *sb;
 	__be32 status = 0;
 	int lkflg;
 	int err;
 		dprintk("NFSD: nfsd4_lock: permission denied!\n");
 		return status;
 	}
-	sb = cstate->current_fh.fh_dentry->d_sb;
 	if (lock->lk_is_new) {
 		if (nfsd4_has_session(cstate))
 	fp = lock_stp->st_stid.sc_file;
 	switch (lock->lk_type) {
 		case NFS4_READW_LT:
-			if (nfsd4_has_session(cstate) &&
+			if (nfsd4_has_session(cstate))
-			    !(sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS))
 				fl_flags |= FL_SLEEP;
 			fallthrough;
 		case NFS4_READ_LT:
 			fl_type = F_RDLCK;
 			break;
 		case NFS4_WRITEW_LT:
-			if (nfsd4_has_session(cstate) &&
+			if (nfsd4_has_session(cstate))
-			    !(sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS))
 				fl_flags |= FL_SLEEP;
 			fallthrough;
 		case NFS4_WRITE_LT:
 		goto out;
 	}
+	/*
+	 * Most filesystems with their own ->lock operations will block
+	 * the nfsd thread waiting to acquire the lock.  That leads to
+	 * deadlocks (we don't want every nfsd thread tied up waiting
+	 * for file locks), so don't attempt blocking lock notifications
+	 * on those filesystems:
+	 */
+	if (nf->nf_file->f_op->lock)
+		fl_flags &= ~FL_SLEEP;
 	nbl = find_or_allocate_block(lock_sop, &fp->fi_fhandle, nn);
 	if (!nbl) {
 		dprintk("NFSD: %s: unable to allocate block!\n", __func__);
 		spin_lock(&nn->blocked_locks_lock);
 		list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked);
 		list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru);
+		kref_get(&nbl->nbl_kref);
 		spin_unlock(&nn->blocked_locks_lock);
 	}
 			nn->somebody_reclaimed = true;
 		break;
 	case FILE_LOCK_DEFERRED:
+		kref_put(&nbl->nbl_kref, free_nbl);
 		nbl = NULL;
 		fallthrough;
 	case -EAGAIN:		/* conflock holds conflicting lock */
 		/* dequeue it if we queued it before */
 		if (fl_flags & FL_SLEEP) {
 			spin_lock(&nn->blocked_locks_lock);
-			list_del_init(&nbl->nbl_list);
+			if (!list_empty(&nbl->nbl_list) &&
-			list_del_init(&nbl->nbl_lru);
+			    !list_empty(&nbl->nbl_lru)) {
+				list_del_init(&nbl->nbl_list);
+				list_del_init(&nbl->nbl_lru);
+				kref_put(&nbl->nbl_kref, free_nbl);
+			}
+			/* nbl can use one of lists to be linked to reaplist */
 			spin_unlock(&nn->blocked_locks_lock);
 		}
 		free_blocked_lock(nbl);

fs/nfsd/nfs4xdr.c+5−16

 static __be32
 nfsd4_decode_bitmap4(struct nfsd4_compoundargs *argp, u32 *bmval, u32 bmlen)
 {
-	u32 i, count;
+	ssize_t status;
-	__be32 *p;
-	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)
-		return nfserr_bad_xdr;
-	/* request sanity */
-	if (count > 1000)
-		return nfserr_bad_xdr;
-	p = xdr_inline_decode(argp->xdr, count << 2);
-	if (!p)
-		return nfserr_bad_xdr;
-	for (i = 0; i < bmlen; i++)
-		bmval[i] = (i < count) ? be32_to_cpup(p++) : 0;
-	return nfs_ok;
+	status = xdr_stream_decode_uint32_array(argp->xdr, bmval, bmlen);
+	return status == -EBADMSG ? nfserr_bad_xdr : nfs_ok;
 }
 static __be32
 		return nfserr_resource;
 	*p++ = htonl(NFS4_CONTENT_HOLE);
-	 p   = xdr_encode_hyper(p, read->rd_offset);
+	p = xdr_encode_hyper(p, read->rd_offset);
-	 p   = xdr_encode_hyper(p, count);
+	p = xdr_encode_hyper(p, count);
 	*eof = (read->rd_offset + count) >= f_size;
 	*maxcount = min_t(unsigned long, count, *maxcount);

fs/nfsd/nfscache.c+1−1

@@ -87,7 +87,7 @@ nfsd_hashsize(unsigned int limit) · 86 unmodified lines
87	static u32	87	static u32
88	nfsd_cache_hash(__be32 xid, struct nfsd_net *nn)	88	nfsd_cache_hash(__be32 xid, struct nfsd_net *nn)
89	{	89	{
90	return hash_32(be32_to_cpu(xid), nn->maskbits);	90	return hash_32((__force u32)xid, nn->maskbits);
91	}	91	}
92		92
93	static struct svc_cacherep *	93	static struct svc_cacherep *

fs/nfsd/nfsctl.c+12−15

 		return err;
 	err = svc_addsock(nn->nfsd_serv, fd, buf, SIMPLE_TRANSACTION_LIMIT, cred);
-	if (err < 0) {
-		nfsd_destroy(net);
-		return err;
-	}
-	/* Decrease the count, but don't shut down the service */
+	if (err >= 0 &&
-	nn->nfsd_serv->sv_nrthreads--;
+	    !nn->nfsd_serv->sv_nrthreads && !xchg(&nn->keep_active, 1))
+		svc_get(nn->nfsd_serv);
+	nfsd_put(net);
 	return err;
 }
 	if (err < 0 && err != -EAFNOSUPPORT)
 		goto out_close;
-	/* Decrease the count, but don't shut down the service */
+	if (!nn->nfsd_serv->sv_nrthreads && !xchg(&nn->keep_active, 1))
-	nn->nfsd_serv->sv_nrthreads--;
+		svc_get(nn->nfsd_serv);
+	nfsd_put(net);
 	return 0;
 out_close:
 	xprt = svc_find_xprt(nn->nfsd_serv, transport, net, PF_INET, port);
 		svc_xprt_put(xprt);
 	}
 out_err:
-	if (!list_empty(&nn->nfsd_serv->sv_permsocks))
+	nfsd_put(net);
-		nn->nfsd_serv->sv_nrthreads--;
-	 else
-		nfsd_destroy(net);
 	return err;
 }
 	nn->clientid_counter = nn->clientid_base + 1;
 	nn->s2s_cp_cl_id = nn->clientid_counter++;
-	atomic_set(&nn->ntf_refcnt, 0);
+	get_random_bytes(&nn->siphash_key, sizeof(nn->siphash_key));
-	init_waitqueue_head(&nn->ntf_wq);
+	seqlock_init(&nn->writeverf_lock);
-	seqlock_init(&nn->boot_lock);
 	return 0;

fs/nfsd/nfsd.h+1−1

@@ -97,7 +97,7 @@ int nfsd_pool_stats_open(struct inode , struct file ); · 96 unmodified lines
97	int nfsd_pool_stats_release(struct inode , struct file );	97	int nfsd_pool_stats_release(struct inode , struct file );
98	void nfsd_shutdown_threads(struct net *net);	98	void nfsd_shutdown_threads(struct net *net);
99		99
100	void nfsd_destroy(struct net *net);	100	void nfsd_put(struct net *net);
101		101
102	bool i_am_nfsd(void);	102	bool i_am_nfsd(void);
103		103

fs/nfsd/nfsfh.c+65−1

@@ -611,6 +611,70 @@ out_negative: · 610 unmodified lines
611	return nfserr_serverfault;	611	return nfserr_serverfault;
612	}	612	}
613		613
		614	#ifdef CONFIG_NFSD_V3
		615
		616	/**
		617	* fh_fill_pre_attrs - Fill in pre-op attributes
		618	* @fhp: file handle to be updated
		619	*
		620	*/
		621	void fh_fill_pre_attrs(struct svc_fh *fhp)
		622	{
		623	bool v4 = (fhp->fh_maxsize == NFS4_FHSIZE);
		624	struct inode *inode;
		625	struct kstat stat;
		626	__be32 err;
		627
		628	if (fhp->fh_no_wcc \|\| fhp->fh_pre_saved)
		629	return;
		630
		631	inode = d_inode(fhp->fh_dentry);
		632	err = fh_getattr(fhp, &stat);
		633	if (err) {
		634	/* Grab the times from inode anyway */
		635	stat.mtime = inode->i_mtime;
		636	stat.ctime = inode->i_ctime;
		637	stat.size = inode->i_size;
		638	}
		639	if (v4)
		640	fhp->fh_pre_change = nfsd4_change_attribute(&stat, inode);
		641
		642	fhp->fh_pre_mtime = stat.mtime;
		643	fhp->fh_pre_ctime = stat.ctime;
		644	fhp->fh_pre_size = stat.size;
		645	fhp->fh_pre_saved = true;
		646	}
		647
		648	/**
		649	* fh_fill_post_attrs - Fill in post-op attributes
		650	* @fhp: file handle to be updated
		651	*
		652	*/
		653	void fh_fill_post_attrs(struct svc_fh *fhp)
		654	{
		655	bool v4 = (fhp->fh_maxsize == NFS4_FHSIZE);
		656	struct inode *inode = d_inode(fhp->fh_dentry);
		657	__be32 err;
		658
		659	if (fhp->fh_no_wcc)
		660	return;
		661
		662	if (fhp->fh_post_saved)
		663	printk("nfsd: inode locked twice during operation.\n");
		664
		665	err = fh_getattr(fhp, &fhp->fh_post_attr);
		666	if (err) {
		667	fhp->fh_post_saved = false;
		668	fhp->fh_post_attr.ctime = inode->i_ctime;
		669	} else
		670	fhp->fh_post_saved = true;
		671	if (v4)
		672	fhp->fh_post_change =
		673	nfsd4_change_attribute(&fhp->fh_post_attr, inode);
		674	}
		675
		676	#endif /* CONFIG_NFSD_V3 */
		677
614	/*	678	/*
615	* Release a file handle.	679	* Release a file handle.
616	*/	680	*/
@@ -623,7 +687,7 @@ fh_put(struct svc_fh *fhp) · 6 unmodified lines
623	fh_unlock(fhp);	687	fh_unlock(fhp);
624	fhp->fh_dentry = NULL;	688	fhp->fh_dentry = NULL;
625	dput(dentry);	689	dput(dentry);
626	fh_clear_wcc(fhp);	690	fh_clear_pre_post_attrs(fhp);
627	}	691	}
628	fh_drop_write(fhp);	692	fh_drop_write(fhp);
629	if (exp) {	693	if (exp) {

fs/nfsd/nfsfh.h+26−14

@@ -284,12 +284,13 @@ static inline u32 knfsd_fh_hash(const struct knfsd_fh *fh) · 283 unmodified lines
284	#endif	284	#endif
285		285
286	#ifdef CONFIG_NFSD_V3	286	#ifdef CONFIG_NFSD_V3
287	/*	287
288	* The wcc data stored in current_fh should be cleared	288	/**
289	* between compound ops.	289	* fh_clear_pre_post_attrs - Reset pre/post attributes
		290	* @fhp: file handle to be updated
		291	*
290	*/	292	*/
291	static inline void	293	static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
292	fh_clear_wcc(struct svc_fh *fhp)
293	{	294	{
294	fhp->fh_post_saved = false;	295	fhp->fh_post_saved = false;
295	fhp->fh_pre_saved = false;	296	fhp->fh_pre_saved = false;
@@ -323,13 +324,24 @@ static inline u64 nfsd4_change_attribute(struct kstat *stat, · 27 unmodified lines
323	return time_to_chattr(&stat->ctime);	324	return time_to_chattr(&stat->ctime);
324	}	325	}
325		326
326	extern void fill_pre_wcc(struct svc_fh *fhp);	327	extern void fh_fill_pre_attrs(struct svc_fh *fhp);
327	extern void fill_post_wcc(struct svc_fh *fhp);	328	extern void fh_fill_post_attrs(struct svc_fh *fhp);
328	#else	329
329	#define fh_clear_wcc(ignored)	330	#else /* !CONFIG_NFSD_V3 */
330	#define fill_pre_wcc(ignored)	331
331	#define fill_post_wcc(notused)	332	static inline void fh_clear_pre_post_attrs(struct svc_fh *fhp)
332	#endif /* CONFIG_NFSD_V3 */	333	{
		334	}
		335
		336	static inline void fh_fill_pre_attrs(struct svc_fh *fhp)
		337	{
		338	}
		339
		340	static inline void fh_fill_post_attrs(struct svc_fh *fhp)
		341	{
		342	}
		343
		344	#endif /* !CONFIG_NFSD_V3 */
333		345
334		346
335	/*	347	/*
@@ -355,7 +367,7 @@ fh_lock_nested(struct svc_fh *fhp, unsigned int subclass) · 19 unmodified lines
355		367
356	inode = d_inode(dentry);	368	inode = d_inode(dentry);
357	inode_lock_nested(inode, subclass);	369	inode_lock_nested(inode, subclass);
358	fill_pre_wcc(fhp);	370	fh_fill_pre_attrs(fhp);
359	fhp->fh_locked = true;	371	fhp->fh_locked = true;
360	}	372	}
361		373
@@ -372,7 +384,7 @@ static inline void · 10 unmodified lines
372	fh_unlock(struct svc_fh *fhp)	384	fh_unlock(struct svc_fh *fhp)
373	{	385	{
374	if (fhp->fh_locked) {	386	if (fhp->fh_locked) {
375	fill_post_wcc(fhp);	387	fh_fill_post_attrs(fhp);
376	inode_unlock(d_inode(fhp->fh_dentry));	388	inode_unlock(d_inode(fhp->fh_dentry));
377	fhp->fh_locked = false;	389	fhp->fh_locked = false;
378	}	390	}

fs/nfsd/nfsproc.c+3−5

 		argp->len, argp->offset);
 	nvecs = svc_fill_write_vector(rqstp, &argp->payload);
-	if (!nvecs) {
-		resp->status = nfserr_io;
-		goto out;
-	}
 	resp->status = nfsd_write(rqstp, fh_copy(&resp->fh, &argp->fh),
 				  argp->offset, rqstp->rq_vec, nvecs,
 		resp->status = fh_getattr(&resp->fh, &resp->stat);
 	else if (resp->status == nfserr_jukebox)
 		return rpc_drop_reply;
-out:
 	return rpc_success;
 }
 		{ nfserr_io, -EIO },
 		{ nfserr_nxio, -ENXIO },
 		{ nfserr_fbig, -E2BIG },
+		{ nfserr_stale, -EBADF },
 		{ nfserr_acces, -EACCES },
 		{ nfserr_exist, -EEXIST },
 		{ nfserr_xdev, -EXDEV },
 		{ nfserr_toosmall, -ETOOSMALL },
 		{ nfserr_serverfault, -ESERVERFAULT },
 		{ nfserr_serverfault, -ENFILE },
+		{ nfserr_io, -EREMOTEIO },
+		{ nfserr_stale, -EOPENSTALE },
 		{ nfserr_io, -EUCLEAN },
 		{ nfserr_perm, -ENOKEY },
 		{ nfserr_no_grace, -ENOGRACE},

fs/nfsd/nfssvc.c+126−94

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	#include <linux/module.h>	12	#include <linux/module.h>
13	#include <linux/fs_struct.h>	13	#include <linux/fs_struct.h>
14	#include <linux/swap.h>	14	#include <linux/swap.h>
		15	#include <linux/siphash.h>
15		16
16	#include <linux/sunrpc/stats.h>	17	#include <linux/sunrpc/stats.h>
17	#include <linux/sunrpc/svcsock.h>	18	#include <linux/sunrpc/svcsock.h>
@@ -55,18 +56,17 @@ static __be32 nfsd_init_request(struct svc_rqst *, · 37 unmodified lines
55	struct svc_process_info *);	56	struct svc_process_info *);
56		57
57	/*	58	/*
58	* nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and the members	59	* nfsd_mutex protects nn->nfsd_serv -- both the pointer itself and some members
59	* of the svc_serv struct. In particular, ->sv_nrthreads but also to some	60	* of the svc_serv struct such as ->sv_temp_socks and ->sv_permsocks.
60	* extent ->sv_temp_socks and ->sv_permsocks. It also protects nfsdstats.th_cnt
61	*	61	*
62	* If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a	62	* If (out side the lock) nn->nfsd_serv is non-NULL, then it must point to a
63	* properly initialised 'struct svc_serv' with ->sv_nrthreads > 0. That number	63	* properly initialised 'struct svc_serv' with ->sv_nrthreads > 0 (unless
64	* of nfsd threads must exist and each must listed in ->sp_all_threads in each	64	* nn->keep_active is set). That number of nfsd threads must
65	* entry of ->sv_pools[].	65	* exist and each must be listed in ->sp_all_threads in some entry of
		66	* ->sv_pools[].
66	*	67	*
67	* Transitions of the thread count between zero and non-zero are of particular	68	* Each active thread holds a counted reference on nn->nfsd_serv, as does
68	* interest since the svc_serv needs to be created and initialized at that	69	* the nn->keep_active flag and various transient calls to svc_get().
69	* point, or freed.
70	*	70	*
71	* Finally, the nfsd_mutex also protects some of the global variables that are	71	* Finally, the nfsd_mutex also protects some of the global variables that are
72	* accessed when nfsd starts and that are settable via the write_* routines in	72	* accessed when nfsd starts and that are settable via the write_* routines in
@@ -345,33 +345,57 @@ static bool nfsd_needs_lockd(struct nfsd_net *nn) · 272 unmodified lines
345	return nfsd_vers(nn, 2, NFSD_TEST) \|\| nfsd_vers(nn, 3, NFSD_TEST);	345	return nfsd_vers(nn, 2, NFSD_TEST) \|\| nfsd_vers(nn, 3, NFSD_TEST);
346	}	346	}
347		347
348	void nfsd_copy_boot_verifier(__be32 verf[2], struct nfsd_net *nn)	348	/**
		349	* nfsd_copy_write_verifier - Atomically copy a write verifier
		350	* @verf: buffer in which to receive the verifier cookie
		351	* @nn: NFS net namespace
		352	*
		353	* This function provides a wait-free mechanism for copying the
		354	* namespace's write verifier without tearing it.
		355	*/
		356	void nfsd_copy_write_verifier(__be32 verf[2], struct nfsd_net *nn)
349	{	357	{
350	int seq = 0;	358	int seq = 0;
351		359
352	do {	360	do {
353	read_seqbegin_or_lock(&nn->boot_lock, &seq);	361	read_seqbegin_or_lock(&nn->writeverf_lock, &seq);
354	/*	362	memcpy(verf, nn->writeverf, sizeof(*verf));
355	* This is opaque to client, so no need to byte-swap. Use	363	} while (need_seqretry(&nn->writeverf_lock, seq));
356	* __force to keep sparse happy. y2038 time_t overflow is	364	done_seqretry(&nn->writeverf_lock, seq);
357	* irrelevant in this usage
358	*/
359	verf[0] = (__force __be32)nn->nfssvc_boot.tv_sec;
360	verf[1] = (__force __be32)nn->nfssvc_boot.tv_nsec;
361	} while (need_seqretry(&nn->boot_lock, seq));
362	done_seqretry(&nn->boot_lock, seq);
363	}	365	}
364		366
365	static void nfsd_reset_boot_verifier_locked(struct nfsd_net *nn)	367	static void nfsd_reset_write_verifier_locked(struct nfsd_net *nn)
366	{	368	{
367	ktime_get_real_ts64(&nn->nfssvc_boot);	369	struct timespec64 now;
		370	u64 verf;
		371
		372	/*
		373	* Because the time value is hashed, y2038 time_t overflow
		374	* is irrelevant in this usage.
		375	*/
		376	ktime_get_raw_ts64(&now);
		377	verf = siphash_2u64(now.tv_sec, now.tv_nsec, &nn->siphash_key);
		378	memcpy(nn->writeverf, &verf, sizeof(nn->writeverf));
368	}	379	}
369		380
370	void nfsd_reset_boot_verifier(struct nfsd_net *nn)	381	/**
		382	* nfsd_reset_write_verifier - Generate a new write verifier
		383	* @nn: NFS net namespace
		384	*
		385	* This function updates the ->writeverf field of @nn. This field
		386	* contains an opaque cookie that, according to Section 18.32.3 of
		387	* RFC 8881, "the client can use to determine whether a server has
		388	* changed instance state (e.g., server restart) between a call to
		389	* WRITE and a subsequent call to either WRITE or COMMIT. This
		390	* cookie MUST be unchanged during a single instance of the NFSv4.1
		391	* server and MUST be unique between instances of the NFSv4.1
		392	* server."
		393	*/
		394	void nfsd_reset_write_verifier(struct nfsd_net *nn)
371	{	395	{
372	write_seqlock(&nn->boot_lock);	396	write_seqlock(&nn->writeverf_lock);
373	nfsd_reset_boot_verifier_locked(nn);	397	nfsd_reset_write_verifier_locked(nn);
374	write_sequnlock(&nn->boot_lock);	398	write_sequnlock(&nn->writeverf_lock);
375	}	399	}
376		400
377	static int nfsd_startup_net(struct net net, const struct cred cred)	401	static int nfsd_startup_net(struct net net, const struct cred cred)
@@ -435,6 +459,7 @@ static void nfsd_shutdown_net(struct net *net) · 57 unmodified lines
435	nfsd_shutdown_generic();	459	nfsd_shutdown_generic();
436	}	460	}
437		461
		462	static DEFINE_SPINLOCK(nfsd_notifier_lock);
438	static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event,	463	static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event,
439	void *ptr)	464	void *ptr)
440	{	465	{
@@ -444,18 +469,17 @@ static int nfsd_inetaddr_event(struct notifier_block *this, unsigned long event, · 3 unmodified lines
444	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	469	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
445	struct sockaddr_in sin;	470	struct sockaddr_in sin;
446		471
447	if ((event != NETDEV_DOWN) \|\|	472	if (event != NETDEV_DOWN \|\| !nn->nfsd_serv)
448	!atomic_inc_not_zero(&nn->ntf_refcnt))
449	goto out;	473	goto out;
450		474
		475	spin_lock(&nfsd_notifier_lock);
451	if (nn->nfsd_serv) {	476	if (nn->nfsd_serv) {
452	dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local);	477	dprintk("nfsd_inetaddr_event: removed %pI4\n", &ifa->ifa_local);
453	sin.sin_family = AF_INET;	478	sin.sin_family = AF_INET;
454	sin.sin_addr.s_addr = ifa->ifa_local;	479	sin.sin_addr.s_addr = ifa->ifa_local;
455	svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin);	480	svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin);
456	}	481	}
457	atomic_dec(&nn->ntf_refcnt);	482	spin_unlock(&nfsd_notifier_lock);
458	wake_up(&nn->ntf_wq);
459		483
460	out:	484	out:
461	return NOTIFY_DONE;	485	return NOTIFY_DONE;
@@ -475,10 +499,10 @@ static int nfsd_inet6addr_event(struct notifier_block *this, · 13 unmodified lines
475	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	499	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
476	struct sockaddr_in6 sin6;	500	struct sockaddr_in6 sin6;
477		501
478	if ((event != NETDEV_DOWN) \|\|	502	if (event != NETDEV_DOWN \|\| !nn->nfsd_serv)
479	!atomic_inc_not_zero(&nn->ntf_refcnt))
480	goto out;	503	goto out;
481		504
		505	spin_lock(&nfsd_notifier_lock);
482	if (nn->nfsd_serv) {	506	if (nn->nfsd_serv) {
483	dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr);	507	dprintk("nfsd_inet6addr_event: removed %pI6\n", &ifa->addr);
484	sin6.sin6_family = AF_INET6;	508	sin6.sin6_family = AF_INET6;
@@ -487,8 +511,8 @@ static int nfsd_inet6addr_event(struct notifier_block *this, · 2 unmodified lines
487	sin6.sin6_scope_id = ifa->idev->dev->ifindex;	511	sin6.sin6_scope_id = ifa->idev->dev->ifindex;
488	svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6);	512	svc_age_temp_xprts_now(nn->nfsd_serv, (struct sockaddr *)&sin6);
489	}	513	}
490	atomic_dec(&nn->ntf_refcnt);	514	spin_unlock(&nfsd_notifier_lock);
491	wake_up(&nn->ntf_wq);	515
492	out:	516	out:
493	return NOTIFY_DONE;	517	return NOTIFY_DONE;
494	}	518	}
@@ -505,7 +529,6 @@ static void nfsd_last_thread(struct svc_serv serv, struct net net) · 10 unmodified lines
505	{	529	{
506	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	530	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
507		531
508	atomic_dec(&nn->ntf_refcnt);
509	/* check if the notifier still has clients */	532	/* check if the notifier still has clients */
510	if (atomic_dec_return(&nfsd_notifier_refcount) == 0) {	533	if (atomic_dec_return(&nfsd_notifier_refcount) == 0) {
511	unregister_inetaddr_notifier(&nfsd_inetaddr_notifier);	534	unregister_inetaddr_notifier(&nfsd_inetaddr_notifier);
@@ -513,7 +536,6 @@ static void nfsd_last_thread(struct svc_serv serv, struct net net) · 1 unmodified line
513	unregister_inet6addr_notifier(&nfsd_inet6addr_notifier);	536	unregister_inet6addr_notifier(&nfsd_inet6addr_notifier);
514	#endif	537	#endif
515	}	538	}
516	wait_event(nn->ntf_wq, atomic_read(&nn->ntf_refcnt) == 0);
517		539
518	/*	540	/*
519	* write_ports can create the server without actually starting	541	* write_ports can create the server without actually starting
@@ -594,20 +616,9 @@ static const struct svc_serv_ops nfsd_thread_sv_ops = { · 74 unmodified lines
594	.svo_shutdown = nfsd_last_thread,	616	.svo_shutdown = nfsd_last_thread,
595	.svo_function = nfsd,	617	.svo_function = nfsd,
596	.svo_enqueue_xprt = svc_xprt_do_enqueue,	618	.svo_enqueue_xprt = svc_xprt_do_enqueue,
597	.svo_setup = svc_set_num_threads,
598	.svo_module = THIS_MODULE,	619	.svo_module = THIS_MODULE,
599	};	620	};
600		621
601	static void nfsd_complete_shutdown(struct net *net)
602	{
603	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
604
605	WARN_ON(!mutex_is_locked(&nfsd_mutex));
606
607	nn->nfsd_serv = NULL;
608	complete(&nn->nfsd_shutdown_complete);
609	}
610
611	void nfsd_shutdown_threads(struct net *net)	622	void nfsd_shutdown_threads(struct net *net)
612	{	623	{
613	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	624	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
@@ -622,11 +633,9 @@ void nfsd_shutdown_threads(struct net *net) · 8 unmodified lines
622		633
623	svc_get(serv);	634	svc_get(serv);
624	/* Kill outstanding nfsd threads */	635	/* Kill outstanding nfsd threads */
625	serv->sv_ops->svo_setup(serv, NULL, 0);	636	svc_set_num_threads(serv, NULL, 0);
626	nfsd_destroy(net);	637	nfsd_put(net);
627	mutex_unlock(&nfsd_mutex);	638	mutex_unlock(&nfsd_mutex);
628	/* Wait for shutdown of nfsd_serv to complete */
629	wait_for_completion(&nn->nfsd_shutdown_complete);
630	}	639	}
631		640
632	bool i_am_nfsd(void)	641	bool i_am_nfsd(void)
@@ -638,6 +647,7 @@ int nfsd_create_serv(struct net *net) · 5 unmodified lines
638	{	647	{
639	int error;	648	int error;
640	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	649	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
		650	struct svc_serv *serv;
641		651
642	WARN_ON(!mutex_is_locked(&nfsd_mutex));	652	WARN_ON(!mutex_is_locked(&nfsd_mutex));
643	if (nn->nfsd_serv) {	653	if (nn->nfsd_serv) {
@@ -647,19 +657,23 @@ int nfsd_create_serv(struct net *net) · 3 unmodified lines
647	if (nfsd_max_blksize == 0)	657	if (nfsd_max_blksize == 0)
648	nfsd_max_blksize = nfsd_get_default_max_blksize();	658	nfsd_max_blksize = nfsd_get_default_max_blksize();
649	nfsd_reset_versions(nn);	659	nfsd_reset_versions(nn);
650	nn->nfsd_serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,	660	serv = svc_create_pooled(&nfsd_program, nfsd_max_blksize,
651	&nfsd_thread_sv_ops);	661	&nfsd_thread_sv_ops);
652	if (nn->nfsd_serv == NULL)	662	if (serv == NULL)
653	return -ENOMEM;	663	return -ENOMEM;
654	init_completion(&nn->nfsd_shutdown_complete);
655		664
656	nn->nfsd_serv->sv_maxconn = nn->max_connections;	665	serv->sv_maxconn = nn->max_connections;
657	error = svc_bind(nn->nfsd_serv, net);	666	error = svc_bind(serv, net);
658	if (error < 0) {	667	if (error < 0) {
659	svc_destroy(nn->nfsd_serv);	668	/* NOT nfsd_put() as notifiers (see below) haven't
660	nfsd_complete_shutdown(net);	669	* been set up yet.
		670	*/
		671	svc_put(serv);
661	return error;	672	return error;
662	}	673	}
		674	spin_lock(&nfsd_notifier_lock);
		675	nn->nfsd_serv = serv;
		676	spin_unlock(&nfsd_notifier_lock);
663		677
664	set_max_drc();	678	set_max_drc();
665	/* check if the notifier is already set */	679	/* check if the notifier is already set */
@@ -669,8 +683,7 @@ int nfsd_create_serv(struct net *net) · 3 unmodified lines
669	register_inet6addr_notifier(&nfsd_inet6addr_notifier);	683	register_inet6addr_notifier(&nfsd_inet6addr_notifier);
670	#endif	684	#endif
671	}	685	}
672	atomic_inc(&nn->ntf_refcnt);	686	nfsd_reset_write_verifier(nn);
673	nfsd_reset_boot_verifier(nn);
674	return 0;	687	return 0;
675	}	688	}
676		689
@@ -697,16 +710,26 @@ int nfsd_get_nrthreads(int n, int nthreads, struct net net) · 20 unmodified lines
697	return 0;	710	return 0;
698	}	711	}
699		712
700	void nfsd_destroy(struct net *net)	713	/* This is the callback for kref_put() below.
		714	* There is no code here as the first thing to be done is
		715	* call svc_shutdown_net(), but we cannot get the 'net' from
		716	* the kref. So do all the work when kref_put returns true.
		717	*/
		718	static void nfsd_noop(struct kref *ref)
		719	{
		720	}
		721
		722	void nfsd_put(struct net *net)
701	{	723	{
702	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	724	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
703	int destroy = (nn->nfsd_serv->sv_nrthreads == 1);
704		725
705	if (destroy)	726	if (kref_put(&nn->nfsd_serv->sv_refcnt, nfsd_noop)) {
706	svc_shutdown_net(nn->nfsd_serv, net);	727	svc_shutdown_net(nn->nfsd_serv, net);
707	svc_destroy(nn->nfsd_serv);	728	svc_destroy(&nn->nfsd_serv->sv_refcnt);
708	if (destroy)	729	spin_lock(&nfsd_notifier_lock);
709	nfsd_complete_shutdown(net);	730	nn->nfsd_serv = NULL;
		731	spin_unlock(&nfsd_notifier_lock);
		732	}
710	}	733	}
711		734
712	int nfsd_set_nrthreads(int n, int nthreads, struct net net)	735	int nfsd_set_nrthreads(int n, int nthreads, struct net net)
@@ -733,7 +756,7 @@ int nfsd_set_nrthreads(int n, int nthreads, struct net net) · 20 unmodified lines
733	if (tot > NFSD_MAXSERVS) {	756	if (tot > NFSD_MAXSERVS) {
734	/* total too large: scale down requested numbers */	757	/* total too large: scale down requested numbers */
735	for (i = 0; i < n && tot > 0; i++) {	758	for (i = 0; i < n && tot > 0; i++) {
736	int new = nthreads[i] * NFSD_MAXSERVS / tot;	759	int new = nthreads[i] * NFSD_MAXSERVS / tot;
737	tot -= (nthreads[i] - new);	760	tot -= (nthreads[i] - new);
738	nthreads[i] = new;	761	nthreads[i] = new;
739	}	762	}
@@ -753,12 +776,13 @@ int nfsd_set_nrthreads(int n, int nthreads, struct net net) · 13 unmodified lines
753	/* apply the new numbers */	776	/* apply the new numbers */
754	svc_get(nn->nfsd_serv);	777	svc_get(nn->nfsd_serv);
755	for (i = 0; i < n; i++) {	778	for (i = 0; i < n; i++) {
756	err = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,	779	err = svc_set_num_threads(nn->nfsd_serv,
757	&nn->nfsd_serv->sv_pools[i], nthreads[i]);	780	&nn->nfsd_serv->sv_pools[i],
		781	nthreads[i]);
758	if (err)	782	if (err)
759	break;	783	break;
760	}	784	}
761	nfsd_destroy(net);	785	nfsd_put(net);
762	return err;	786	return err;
763	}	787	}
764		788
@@ -795,21 +819,19 @@ nfsd_svc(int nrservs, struct net net, const struct cred cred) · 30 unmodified lines
795		819
796	error = nfsd_startup_net(net, cred);	820	error = nfsd_startup_net(net, cred);
797	if (error)	821	if (error)
798	goto out_destroy;	822	goto out_put;
799	error = nn->nfsd_serv->sv_ops->svo_setup(nn->nfsd_serv,	823	error = svc_set_num_threads(nn->nfsd_serv, NULL, nrservs);
800	NULL, nrservs);
801	if (error)	824	if (error)
802	goto out_shutdown;	825	goto out_shutdown;
803	/* We are holding a reference to nn->nfsd_serv which	826	error = nn->nfsd_serv->sv_nrthreads;
804	* we don't want to count in the return value,
805	* so subtract 1
806	*/
807	error = nn->nfsd_serv->sv_nrthreads - 1;
808	out_shutdown:	827	out_shutdown:
809	if (error < 0 && !nfsd_up_before)	828	if (error < 0 && !nfsd_up_before)
810	nfsd_shutdown_net(net);	829	nfsd_shutdown_net(net);
811	out_destroy:	830	out_put:
812	nfsd_destroy(net); /* Release server */	831	/* Threads now hold service active */
		832	if (xchg(&nn->keep_active, 0))
		833	nfsd_put(net);
		834	nfsd_put(net);
813	out:	835	out:
814	mutex_unlock(&nfsd_mutex);	836	mutex_unlock(&nfsd_mutex);
815	return error;	837	return error;
@@ -923,9 +945,6 @@ nfsd(void *vrqstp) · 107 unmodified lines
923	struct nfsd_net *nn = net_generic(net, nfsd_net_id);	945	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
924	int err;	946	int err;
925		947
926	/* Lock module and set up kernel thread */
927	mutex_lock(&nfsd_mutex);
928
929	/* At this point, the thread shares current->fs	948	/* At this point, the thread shares current->fs
930	* with the init process. We need to create files with the	949	* with the init process. We need to create files with the
931	* umask as defined by the client instead of init's umask. */	950	* umask as defined by the client instead of init's umask. */
@@ -945,8 +964,7 @@ nfsd(void *vrqstp) · 13 unmodified lines
945	allow_signal(SIGINT);	964	allow_signal(SIGINT);
946	allow_signal(SIGQUIT);	965	allow_signal(SIGQUIT);
947		966
948	nfsdstats.th_cnt++;	967	atomic_inc(&nfsdstats.th_cnt);
949	mutex_unlock(&nfsd_mutex);
950		968
951	set_freezable();	969	set_freezable();
952		970
@@ -973,19 +991,35 @@ nfsd(void *vrqstp) · 20 unmodified lines
973	/* Clear signals before calling svc_exit_thread() */	991	/* Clear signals before calling svc_exit_thread() */
974	flush_signals(current);	992	flush_signals(current);
975		993
976	mutex_lock(&nfsd_mutex);	994	atomic_dec(&nfsdstats.th_cnt);
977	nfsdstats.th_cnt --;
978		995
979	out:	996	out:
980	rqstp->rq_server = NULL;	997	/* Take an extra ref so that the svc_put in svc_exit_thread()
		998	* doesn't call svc_destroy()
		999	*/
		1000	svc_get(nn->nfsd_serv);
981		1001
982	/* Release the thread */	1002	/* Release the thread */
983	svc_exit_thread(rqstp);	1003	svc_exit_thread(rqstp);
984		1004
985	nfsd_destroy(net);	1005	/* We need to drop a ref, but may not drop the last reference
		1006	* without holding nfsd_mutex, and we cannot wait for nfsd_mutex as that
		1007	* could deadlock with nfsd_shutdown_threads() waiting for us.
		1008	* So three options are:
		1009	* - drop a non-final reference,
		1010	* - get the mutex without waiting
		1011	* - sleep briefly andd try the above again
		1012	*/
		1013	while (!svc_put_not_last(nn->nfsd_serv)) {
		1014	if (mutex_trylock(&nfsd_mutex)) {
		1015	nfsd_put(net);
		1016	mutex_unlock(&nfsd_mutex);
		1017	break;
		1018	}
		1019	msleep(20);
		1020	}
986		1021
987	/* Release module */	1022	/* Release module */
988	mutex_unlock(&nfsd_mutex);
989	module_put_and_exit(0);	1023	module_put_and_exit(0);
990	return 0;	1024	return 0;
991	}	1025	}
@@ -1096,7 +1130,6 @@ int nfsd_pool_stats_open(struct inode inode, struct file file) · 104 unmodified lines
1096	mutex_unlock(&nfsd_mutex);	1130	mutex_unlock(&nfsd_mutex);
1097	return -ENODEV;	1131	return -ENODEV;
1098	}	1132	}
1099	/* bump up the psudo refcount while traversing */
1100	svc_get(nn->nfsd_serv);	1133	svc_get(nn->nfsd_serv);
1101	ret = svc_pool_stats_open(nn->nfsd_serv, file);	1134	ret = svc_pool_stats_open(nn->nfsd_serv, file);
1102	mutex_unlock(&nfsd_mutex);	1135	mutex_unlock(&nfsd_mutex);
@@ -1109,8 +1142,7 @@ int nfsd_pool_stats_release(struct inode inode, struct file file) · 6 unmodified lines
1109	struct net *net = inode->i_sb->s_fs_info;	1142	struct net *net = inode->i_sb->s_fs_info;
1110		1143
1111	mutex_lock(&nfsd_mutex);	1144	mutex_lock(&nfsd_mutex);
1112	/* this function really, really should have been called svc_put() */	1145	nfsd_put(net);
1113	nfsd_destroy(net);
1114	mutex_unlock(&nfsd_mutex);	1146	mutex_unlock(&nfsd_mutex);
1115	return ret;	1147	return ret;
1116	}	1148	}

fs/nfsd/state.h+5−0

 	struct list_head		st_locks;
 	struct nfs4_stateowner		*st_stateowner;
 	struct nfs4_clnt_odstate	*st_clnt_odstate;
+/*
+ * These bitmasks use 3 separate bits for READ, ALLOW, and BOTH; see the
+ * comment above bmap_to_share_mode() for explanation:
+ */
 	unsigned char			st_access_bmap;
 	unsigned char			st_deny_bmap;
 	struct nfs4_ol_stateid		*st_openstp;
 	struct file_lock	nbl_lock;
 	struct knfsd_fh		nbl_fh;
 	struct nfsd4_callback	nbl_cb;
+	struct kref		nbl_kref;
 };
 struct nfsd4_compound_state;

fs/nfsd/stats.c+1−1

@@ -45,7 +45,7 @@ static int nfsd_proc_show(struct seq_file seq, void v) · 44 unmodified lines
45	percpu_counter_sum_positive(&nfsdstats.counter[NFSD_STATS_IO_WRITE]));	45	percpu_counter_sum_positive(&nfsdstats.counter[NFSD_STATS_IO_WRITE]));
46		46
47	/* thread usage: */	47	/* thread usage: */
48	seq_printf(seq, "th %u 0", nfsdstats.th_cnt);	48	seq_printf(seq, "th %u 0", atomic_read(&nfsdstats.th_cnt));
49		49
50	/* deprecated thread usage histogram stats */	50	/* deprecated thread usage histogram stats */
51	for (i = 0; i < 10; i++)	51	for (i = 0; i < 10; i++)

fs/nfsd/stats.h+1−3

@@ -29,11 +29,9 @@ enum { · 28 unmodified lines
29	struct nfsd_stats {	29	struct nfsd_stats {
30	struct percpu_counter counter[NFSD_STATS_COUNTERS_NUM];	30	struct percpu_counter counter[NFSD_STATS_COUNTERS_NUM];
31		31
32	/* Protected by nfsd_mutex */	32	atomic_t th_cnt; /* number of available threads */
33	unsigned int th_cnt; /* number of available threads */
34	};	33	};
35		34
36
37	extern struct nfsd_stats nfsdstats;	35	extern struct nfsd_stats nfsdstats;
38		36
39	extern struct svc_stat nfsd_svcstats;	37	extern struct svc_stat nfsd_svcstats;

fs/nfsd/trace.h+85−21

@@ -47,7 +47,7 @@ · 46 unmodified lines
47	rqstp->rq_xprt->xpt_remotelen); \	47	rqstp->rq_xprt->xpt_remotelen); \
48	} while (0);	48	} while (0);
49		49
50	TRACE_EVENT(nfsd_garbage_args_err,	50	DECLARE_EVENT_CLASS(nfsd_xdr_err_class,
51	TP_PROTO(	51	TP_PROTO(
52	const struct svc_rqst *rqstp	52	const struct svc_rqst *rqstp
53	),	53	),
@@ -69,27 +69,13 @@ TRACE_EVENT(nfsd_garbage_args_err, · 15 unmodified lines
69	)	69	)
70	);	70	);
71		71
72	TRACE_EVENT(nfsd_cant_encode_err,	72	#define DEFINE_NFSD_XDR_ERR_EVENT(name) \
73	TP_PROTO(	73	DEFINE_EVENT(nfsd_xdr_err_class, nfsd_##name##_err, \
74	const struct svc_rqst *rqstp	74	TP_PROTO(const struct svc_rqst *rqstp), \
75	),	75	TP_ARGS(rqstp))
76	TP_ARGS(rqstp),
77	TP_STRUCT__entry(
78	NFSD_TRACE_PROC_ARG_FIELDS
79
80	__field(u32, vers)
81	__field(u32, proc)
82	),
83	TP_fast_assign(
84	NFSD_TRACE_PROC_ARG_ASSIGNMENTS
85		76
86	__entry->vers = rqstp->rq_vers;	77	DEFINE_NFSD_XDR_ERR_EVENT(garbage_args);
87	__entry->proc = rqstp->rq_proc;	78	DEFINE_NFSD_XDR_ERR_EVENT(cant_encode);
88	),
89	TP_printk("xid=0x%08x vers=%u proc=%u",
90	__entry->xid, __entry->vers, __entry->proc
91	)
92	);
93		79
94	#define show_nfsd_may_flags(x) \	80	#define show_nfsd_may_flags(x) \
95	__print_flags(x, "\|", \	81	__print_flags(x, "\|", \
@@ -413,6 +399,56 @@ TRACE_EVENT(nfsd_dirent, · 317 unmodified lines
413	)	399	)
414	)	400	)
415		401
		402	DECLARE_EVENT_CLASS(nfsd_copy_err_class,
		403	TP_PROTO(struct svc_rqst *rqstp,
		404	struct svc_fh *src_fhp,
		405	loff_t src_offset,
		406	struct svc_fh *dst_fhp,
		407	loff_t dst_offset,
		408	u64 count,
		409	int status),
		410	TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, count, status),
		411	TP_STRUCT__entry(
		412	__field(u32, xid)
		413	__field(u32, src_fh_hash)
		414	__field(loff_t, src_offset)
		415	__field(u32, dst_fh_hash)
		416	__field(loff_t, dst_offset)
		417	__field(u64, count)
		418	__field(int, status)
		419	),
		420	TP_fast_assign(
		421	__entry->xid = be32_to_cpu(rqstp->rq_xid);
		422	__entry->src_fh_hash = knfsd_fh_hash(&src_fhp->fh_handle);
		423	__entry->src_offset = src_offset;
		424	__entry->dst_fh_hash = knfsd_fh_hash(&dst_fhp->fh_handle);
		425	__entry->dst_offset = dst_offset;
		426	__entry->count = count;
		427	__entry->status = status;
		428	),
		429	TP_printk("xid=0x%08x src_fh_hash=0x%08x src_offset=%lld "
		430	"dst_fh_hash=0x%08x dst_offset=%lld "
		431	"count=%llu status=%d",
		432	__entry->xid, __entry->src_fh_hash, __entry->src_offset,
		433	__entry->dst_fh_hash, __entry->dst_offset,
		434	(unsigned long long)__entry->count,
		435	__entry->status)
		436	)
		437
		438	#define DEFINE_NFSD_COPY_ERR_EVENT(name) \
		439	DEFINE_EVENT(nfsd_copy_err_class, nfsd_##name, \
		440	TP_PROTO(struct svc_rqst *rqstp, \
		441	struct svc_fh *src_fhp, \
		442	loff_t src_offset, \
		443	struct svc_fh *dst_fhp, \
		444	loff_t dst_offset, \
		445	u64 count, \
		446	int status), \
		447	TP_ARGS(rqstp, src_fhp, src_offset, dst_fhp, dst_offset, \
		448	count, status))
		449
		450	DEFINE_NFSD_COPY_ERR_EVENT(clone_file_range_err);
		451
416	#include "state.h"	452	#include "state.h"
417	#include "filecache.h"	453	#include "filecache.h"
418	#include "vfs.h"	454	#include "vfs.h"
@@ -538,6 +574,34 @@ DEFINE_EVENT(nfsd_net_class, nfsd_##name, \ · 119 unmodified lines
538	DEFINE_NET_EVENT(grace_start);	574	DEFINE_NET_EVENT(grace_start);
539	DEFINE_NET_EVENT(grace_complete);	575	DEFINE_NET_EVENT(grace_complete);
540		576
		577	TRACE_EVENT(nfsd_writeverf_reset,
		578	TP_PROTO(
		579	const struct nfsd_net *nn,
		580	const struct svc_rqst *rqstp,
		581	int error
		582	),
		583	TP_ARGS(nn, rqstp, error),
		584	TP_STRUCT__entry(
		585	__field(unsigned long long, boot_time)
		586	__field(u32, xid)
		587	__field(int, error)
		588	__array(unsigned char, verifier, NFS4_VERIFIER_SIZE)
		589	),
		590	TP_fast_assign(
		591	__entry->boot_time = nn->boot_time;
		592	__entry->xid = be32_to_cpu(rqstp->rq_xid);
		593	__entry->error = error;
		594
		595	/* avoid seqlock inside TP_fast_assign */
		596	memcpy(__entry->verifier, nn->writeverf,
		597	NFS4_VERIFIER_SIZE);
		598	),
		599	TP_printk("boot_time=%16llx xid=0x%08x error=%d new verifier=0x%s",
		600	__entry->boot_time, __entry->xid, __entry->error,
		601	__print_hex_str(__entry->verifier, NFS4_VERIFIER_SIZE)
		602	)
		603	);
		604
541	TRACE_EVENT(nfsd_clid_cred_mismatch,	605	TRACE_EVENT(nfsd_clid_cred_mismatch,
542	TP_PROTO(	606	TP_PROTO(
543	const struct nfs4_client *clp,	607	const struct nfs4_client *clp,

fs/nfsd/vfs.c+65−57

 #include "../internal.h"
 #include "acl.h"
 #include "idmap.h"
+#include "xdr4.h"
 #endif /* CONFIG_NFSD_V4 */
 #include "nfsd.h"
 }
 #endif
-__be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,
+static struct nfsd4_compound_state *nfsd4_get_cstate(struct svc_rqst *rqstp)
-		struct nfsd_file *nf_dst, u64 dst_pos, u64 count, bool sync)
+{
+	return &((struct nfsd4_compoundres *)rqstp->rq_resp)->cstate;
+}
+__be32 nfsd4_clone_file_range(struct svc_rqst *rqstp,
+		struct nfsd_file *nf_src, u64 src_pos,
+		struct nfsd_file *nf_dst, u64 dst_pos,
+		u64 count, bool sync)
 {
 	struct file *src = nf_src->nf_file;
 	struct file *dst = nf_dst->nf_file;
+	errseq_t since;
 	loff_t cloned;
 	__be32 ret = 0;
-	down_write(&nf_dst->nf_rwsem);
+	since = READ_ONCE(dst->f_wb_err);
 	cloned = vfs_clone_file_range(src, src_pos, dst, dst_pos, count, 0);
 	if (cloned < 0) {
 		ret = nfserrno(cloned);
 		loff_t dst_end = count ? dst_pos + count - 1 : LLONG_MAX;
 		int status = vfs_fsync_range(dst, dst_pos, dst_end, 0);
+		if (!status)
+			status = filemap_check_wb_err(dst->f_mapping, since);
 		if (!status)
 			status = commit_inode_metadata(file_inode(src));
 		if (status < 0) {
-			nfsd_reset_boot_verifier(net_generic(nf_dst->nf_net,
+			struct nfsd_net *nn = net_generic(nf_dst->nf_net,
-						 nfsd_net_id));
+							  nfsd_net_id);
+			trace_nfsd_clone_file_range_err(rqstp,
+					&nfsd4_get_cstate(rqstp)->save_fh,
+					src_pos,
+					&nfsd4_get_cstate(rqstp)->current_fh,
+					dst_pos,
+					count, status);
+			nfsd_reset_write_verifier(nn);
+			trace_nfsd_writeverf_reset(nn, rqstp, status);
 			ret = nfserrno(status);
 		}
 	}
 out_err:
-	up_write(&nf_dst->nf_rwsem);
 	return ret;
 }
 		int may_flags, struct file **filp)
 {
 	__be32 err;
+	bool retried = false;
 	validate_process_creds();
 	/*
 	 */
 	if (type == S_IFREG)
 		may_flags |= NFSD_MAY_OWNER_OVERRIDE;
+retry:
 	err = fh_verify(rqstp, fhp, type, may_flags);
-	if (!err)
+	if (!err) {
 		err = __nfsd_open(rqstp, fhp, type, may_flags, filp);
+		if (err == nfserr_stale && !retried) {
+			retried = true;
+			fh_put(fhp);
+			goto retry;
+		}
+	}
 	validate_process_creds();
 	return err;
 }
 				unsigned long *cnt, int stable,
 				__be32 *verf)
 {
+	struct nfsd_net		*nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
 	struct file		*file = nf->nf_file;
 	struct super_block	*sb = file_inode(file)->i_sb;
 	struct svc_export	*exp;
 	struct iov_iter		iter;
+	errseq_t		since;
 	__be32			nfserr;
 	int			host_err;
 	int			use_wgather;
 		flags |= RWF_SYNC;
 	iov_iter_kvec(&iter, WRITE, vec, vlen, *cnt);
-	if (flags & RWF_SYNC) {
+	since = READ_ONCE(file->f_wb_err);
-		down_write(&nf->nf_rwsem);
+	if (verf)
-		host_err = vfs_iter_write(file, &iter, &pos, flags);
+		nfsd_copy_write_verifier(verf, nn);
-		if (host_err < 0)
+	host_err = vfs_iter_write(file, &iter, &pos, flags);
-			nfsd_reset_boot_verifier(net_generic(SVC_NET(rqstp),
-						 nfsd_net_id));
-		up_write(&nf->nf_rwsem);
-	} else {
-		down_read(&nf->nf_rwsem);
-		if (verf)
-			nfsd_copy_boot_verifier(verf,
-					net_generic(SVC_NET(rqstp),
-					nfsd_net_id));
-		host_err = vfs_iter_write(file, &iter, &pos, flags);
-		up_read(&nf->nf_rwsem);
-	}
 	if (host_err < 0) {
-		nfsd_reset_boot_verifier(net_generic(SVC_NET(rqstp),
+		nfsd_reset_write_verifier(nn);
-					 nfsd_net_id));
+		trace_nfsd_writeverf_reset(nn, rqstp, host_err);
 		goto out_nfserr;
 	}
 	*cnt = host_err;
 	nfsd_stats_io_write_add(exp, *cnt);
 	fsnotify_modify(file);
+	host_err = filemap_check_wb_err(file->f_mapping, since);
+	if (host_err < 0)
+		goto out_nfserr;
 	if (stable && use_wgather) {
 		host_err = wait_for_concurrent_writes(file);
-		if (host_err < 0)
+		if (host_err < 0) {
-			nfsd_reset_boot_verifier(net_generic(SVC_NET(rqstp),
+			nfsd_reset_write_verifier(nn);
-						 nfsd_net_id));
+			trace_nfsd_writeverf_reset(nn, rqstp, host_err);
+		}
 	}
 out_nfserr:
 }
 #ifdef CONFIG_NFSD_V3
-static int
-nfsd_filemap_write_and_wait_range(struct nfsd_file *nf, loff_t offset,
-				  loff_t end)
-{
-	struct address_space *mapping = nf->nf_file->f_mapping;
-	int ret = filemap_fdatawrite_range(mapping, offset, end);
-	if (ret)
-		return ret;
-	filemap_fdatawait_range_keep_errors(mapping, offset, end);
-	return 0;
-}
 /*
  * Commit all pending writes to stable storage.
  *
 nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
                loff_t offset, unsigned long count, __be32 *verf)
 {
+	struct nfsd_net		*nn;
 	struct nfsd_file	*nf;
 	loff_t			end = LLONG_MAX;
 	__be32			err = nfserr_inval;
 			NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &nf);
 	if (err)
 		goto out;
+	nn = net_generic(nf->nf_net, nfsd_net_id);
 	if (EX_ISSYNC(fhp->fh_export)) {
-		int err2 = nfsd_filemap_write_and_wait_range(nf, offset, end);
+		errseq_t since = READ_ONCE(nf->nf_file->f_wb_err);
+		int err2;
-		down_write(&nf->nf_rwsem);
+		err2 = vfs_fsync_range(nf->nf_file, offset, end, 0);
-		if (!err2)
-			err2 = vfs_fsync_range(nf->nf_file, offset, end, 0);
 		switch (err2) {
 		case 0:
-			nfsd_copy_boot_verifier(verf, net_generic(nf->nf_net,
+			nfsd_copy_write_verifier(verf, nn);
-						nfsd_net_id));
+			err2 = filemap_check_wb_err(nf->nf_file->f_mapping,
+						    since);
 			break;
 		case -EINVAL:
 			err = nfserr_notsupp;
 			break;
 		default:
-			err = nfserrno(err2);
+			nfsd_reset_write_verifier(nn);
-			nfsd_reset_boot_verifier(net_generic(nf->nf_net,
+			trace_nfsd_writeverf_reset(nn, rqstp, err2);
-						 nfsd_net_id));
 		}
-		up_write(&nf->nf_rwsem);
+		err = nfserrno(err2);
 	} else
-		nfsd_copy_boot_verifier(verf, net_generic(nf->nf_net,
+		nfsd_copy_write_verifier(verf, nn);
-					nfsd_net_id));
 	nfsd_file_put(nf);
 out:
 	 * so do it by hand */
 	trap = lock_rename(tdentry, fdentry);
 	ffhp->fh_locked = tfhp->fh_locked = true;
-	fill_pre_wcc(ffhp);
+	fh_fill_pre_attrs(ffhp);
-	fill_pre_wcc(tfhp);
+	fh_fill_pre_attrs(tfhp);
 	odentry = lookup_one_len(fname, fdentry, flen);
 	host_err = PTR_ERR(odentry);
 	 * were the same, so again we do it by hand.
 	 */
 	if (!close_cached) {
-		fill_post_wcc(ffhp);
+		fh_fill_post_attrs(ffhp);
-		fill_post_wcc(tfhp);
+		fh_fill_post_attrs(tfhp);
 	}
 	unlock_rename(tdentry, fdentry);
 	ffhp->fh_locked = tfhp->fh_locked = false;

fs/nfsd/vfs.h+2−1

 		    struct xdr_netobj *);
 __be32		nfsd4_vfs_fallocate(struct svc_rqst *, struct svc_fh *,
 				    struct file *, loff_t, loff_t, int);
-__be32		nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,
+__be32		nfsd4_clone_file_range(struct svc_rqst *rqstp,
+				       struct nfsd_file *nf_src, u64 src_pos,
 				       struct nfsd_file *nf_dst, u64 dst_pos,
 				       u64 count, bool sync);
 #endif /* CONFIG_NFSD_V4 */

include/linux/exportfs.h+0−2

@@ -221,8 +221,6 @@ struct export_operations { · 220 unmodified lines
221	#define EXPORT_OP_NOATOMIC_ATTR (0x10) /* Filesystem cannot supply	221	#define EXPORT_OP_NOATOMIC_ATTR (0x10) /* Filesystem cannot supply
222	atomic attribute updates	222	atomic attribute updates
223	*/	223	*/
224	#define EXPORT_OP_SYNC_LOCKS (0x20) /* Filesystem can't do
225	asychronous blocking locks */
226	unsigned long flags;	224	unsigned long flags;
227	};	225	};
228		226

include/linux/fs.h+2−2

@@ -1221,13 +1221,13 @@ static inline int fcntl_setlk(unsigned int fd, struct file *file, · 1220 unmodified lines
1221		1221
1222	#if BITS_PER_LONG == 32	1222	#if BITS_PER_LONG == 32
1223	static inline int fcntl_getlk64(struct file *file, unsigned int cmd,	1223	static inline int fcntl_getlk64(struct file *file, unsigned int cmd,
1224	struct flock64 __user *user)	1224	struct flock64 *user)
1225	{	1225	{
1226	return -EINVAL;	1226	return -EINVAL;
1227	}	1227	}
1228		1228
1229	static inline int fcntl_setlk64(unsigned int fd, struct file *file,	1229	static inline int fcntl_setlk64(unsigned int fd, struct file *file,
1230	unsigned int cmd, struct flock64 __user *user)	1230	unsigned int cmd, struct flock64 *user)
1231	{	1231	{
1232	return -EACCES;	1232	return -EACCES;
1233	}	1233	}

include/linux/lockd/lockd.h+7−2

 int           nlmsvc_unlock_all_by_sb(struct super_block *sb);
 int           nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr);
+static inline struct file *nlmsvc_file_file(struct nlm_file *file)
+{
+	return file->f_file[O_RDONLY] ?
+	       file->f_file[O_RDONLY] : file->f_file[O_WRONLY];
+}
 static inline struct inode *nlmsvc_file_inode(struct nlm_file *file)
 {
-	return locks_inode(file->f_file[O_RDONLY] ?
+	return locks_inode(nlmsvc_file_file(file));
-			   file->f_file[O_RDONLY] : file->f_file[O_WRONLY]);
 }
 static inline int __nlm_privileged_request4(const struct sockaddr *sap)

include/linux/sunrpc/svc.h+39−40

@@ -64,10 +64,9 @@ struct svc_serv_ops { · 63 unmodified lines
64	/* queue up a transport for servicing */	64	/* queue up a transport for servicing */
65	void (svo_enqueue_xprt)(struct svc_xprt );	65	void (svo_enqueue_xprt)(struct svc_xprt );
66		66
67	/* set up thread (or whatever) execution context */	67	/* optional module to count when adding threads.
68	int (svo_setup)(struct svc_serv , struct svc_pool *, int);	68	* Thread function must call module_put_and_exit() to exit.
69		69	*/
70	/* optional module to count when adding threads (pooled svcs only) */
71	struct module *svo_module;	70	struct module *svo_module;
72	};	71	};
73		72
@@ -85,6 +84,7 @@ struct svc_serv { · 11 unmodified lines
85	struct svc_program * sv_program; /* RPC program */	84	struct svc_program * sv_program; /* RPC program */
86	struct svc_stat * sv_stats; /* RPC statistics */	85	struct svc_stat * sv_stats; /* RPC statistics */
87	spinlock_t sv_lock;	86	spinlock_t sv_lock;
		87	struct kref sv_refcnt;
88	unsigned int sv_nrthreads; /* # of server threads */	88	unsigned int sv_nrthreads; /* # of server threads */
89	unsigned int sv_maxconn; /* max connections allowed or	89	unsigned int sv_maxconn; /* max connections allowed or
90	* '0' causing max to be based	90	* '0' causing max to be based
@@ -114,15 +114,43 @@ struct svc_serv { · 23 unmodified lines
114	#endif /* CONFIG_SUNRPC_BACKCHANNEL */	114	#endif /* CONFIG_SUNRPC_BACKCHANNEL */
115	};	115	};
116		116
117	/*	117	/**
118	* We use sv_nrthreads as a reference count. svc_destroy() drops	118	* svc_get() - increment reference count on a SUNRPC serv
119	* this refcount, so we need to bump it up around operations that	119	* @serv: the svc_serv to have count incremented
120	* change the number of threads. Horrible, but there it is.	120	*
121	* Should be called with the "service mutex" held.	121	* Returns: the svc_serv that was passed in.
		122	*/
		123	static inline struct svc_serv svc_get(struct svc_serv serv)
		124	{
		125	kref_get(&serv->sv_refcnt);
		126	return serv;
		127	}
		128
		129	void svc_destroy(struct kref *);
		130
		131	/**
		132	* svc_put - decrement reference count on a SUNRPC serv
		133	* @serv: the svc_serv to have count decremented
		134	*
		135	* When the reference count reaches zero, svc_destroy()
		136	* is called to clean up and free the serv.
		137	*/
		138	static inline void svc_put(struct svc_serv *serv)
		139	{
		140	kref_put(&serv->sv_refcnt, svc_destroy);
		141	}
		142
		143	/**
		144	* svc_put_not_last - decrement non-final reference count on SUNRPC serv
		145	* @serv: the svc_serv to have count decremented
		146	*
		147	* Returns: %true is refcount was decremented.
		148	*
		149	* If the refcount is 1, it is not decremented and instead failure is reported.
122	*/	150	*/
123	static inline void svc_get(struct svc_serv *serv)	151	static inline bool svc_put_not_last(struct svc_serv *serv)
124	{	152	{
125	serv->sv_nrthreads++;	153	return refcount_dec_not_one(&serv->sv_refcnt.refcount);
126	}	154	}
127		155
128	/*	156	/*
@@ -468,29 +496,6 @@ struct svc_procedure { · 339 unmodified lines
468	const char * pc_name; /* for display */	496	const char * pc_name; /* for display */
469	};	497	};
470		498
471	/*
472	* Mode for mapping cpus to pools.
473	*/
474	enum {
475	SVC_POOL_AUTO = -1, /* choose one of the others */
476	SVC_POOL_GLOBAL, /* no mapping, just a single global pool
477	* (legacy & UP mode) */
478	SVC_POOL_PERCPU, /* one pool per cpu */
479	SVC_POOL_PERNODE /* one pool per numa node */
480	};
481
482	struct svc_pool_map {
483	int count; /* How many svc_servs use us */
484	int mode; /* Note: int not enum to avoid
485	* warnings about "enumeration value
486	* not handled in switch" */
487	unsigned int npools;
488	unsigned int pool_to; / maps pool id to cpu or node */
489	unsigned int to_pool; / maps cpu or node to pool id */
490	};
491
492	extern struct svc_pool_map svc_pool_map;
493
494	/*	499	/*
495	* Function prototypes.	500	* Function prototypes.
496	*/	501	*/
@@ -501,20 +506,14 @@ struct svc_serv svc_create(struct svc_program , unsigned int, · 4 unmodified lines
501	const struct svc_serv_ops *);	506	const struct svc_serv_ops *);
502	struct svc_rqst svc_rqst_alloc(struct svc_serv serv,	507	struct svc_rqst svc_rqst_alloc(struct svc_serv serv,
503	struct svc_pool *pool, int node);	508	struct svc_pool *pool, int node);
504	struct svc_rqst svc_prepare_thread(struct svc_serv serv,
505	struct svc_pool *pool, int node);
506	void svc_rqst_replace_page(struct svc_rqst *rqstp,	509	void svc_rqst_replace_page(struct svc_rqst *rqstp,
507	struct page *page);	510	struct page *page);
508	void svc_rqst_free(struct svc_rqst *);	511	void svc_rqst_free(struct svc_rqst *);
509	void svc_exit_thread(struct svc_rqst *);	512	void svc_exit_thread(struct svc_rqst *);
510	unsigned int svc_pool_map_get(void);
511	void svc_pool_map_put(void);
512	struct svc_serv * svc_create_pooled(struct svc_program *, unsigned int,	513	struct svc_serv * svc_create_pooled(struct svc_program *, unsigned int,
513	const struct svc_serv_ops *);	514	const struct svc_serv_ops *);
514	int svc_set_num_threads(struct svc_serv , struct svc_pool , int);	515	int svc_set_num_threads(struct svc_serv , struct svc_pool , int);
515	int svc_set_num_threads_sync(struct svc_serv , struct svc_pool , int);
516	int svc_pool_stats_open(struct svc_serv serv, struct file file);	516	int svc_pool_stats_open(struct svc_serv serv, struct file file);
517	void svc_destroy(struct svc_serv *);
518	void svc_shutdown_net(struct svc_serv , struct net );	517	void svc_shutdown_net(struct svc_serv , struct net );
519	int svc_process(struct svc_rqst *);	518	int svc_process(struct svc_rqst *);
520	int bc_svc_process(struct svc_serv , struct rpc_rqst ,	519	int bc_svc_process(struct svc_serv , struct rpc_rqst ,

include/trace/events/sunrpc.h+8−29

 		const char *program,
 		const char *protocol,
 		struct sockaddr *sap,
+		size_t salen,
 		const struct svc_xprt *xprt
 	),
-	TP_ARGS(program, protocol, sap, xprt),
+	TP_ARGS(program, protocol, sap, salen, xprt),
 	TP_STRUCT__entry(
 		__field(long, error)
 		__entry->error = PTR_ERR(xprt);
 		__assign_str(program, program);
 		__assign_str(protocol, protocol);
-		memcpy(__entry->addr, sap, sizeof(__entry->addr));
+		memcpy(__entry->addr, sap, min(salen, sizeof(__entry->addr)));
 	),
 	TP_printk("addr=%pISpc program=%s protocol=%s error=%ld",
 		__entry->error)
 );
-TRACE_EVENT(svc_xprt_do_enqueue,
+TRACE_EVENT(svc_xprt_enqueue,
 	TP_PROTO(struct svc_xprt *xprt, struct svc_rqst *rqst),
 	TP_ARGS(xprt, rqst),
 			), \
 			TP_ARGS(xprt))
-DEFINE_SVC_XPRT_EVENT(received);
 DEFINE_SVC_XPRT_EVENT(no_write_space);
 DEFINE_SVC_XPRT_EVENT(close);
 DEFINE_SVC_XPRT_EVENT(detach);
 	TP_printk("pages=%u", __entry->pages)
 );
-TRACE_EVENT(svc_handle_xprt,
-	TP_PROTO(struct svc_xprt *xprt, int len),
-	TP_ARGS(xprt, len),
-	TP_STRUCT__entry(
-		__field(int, len)
-		__field(unsigned long, flags)
-		__string(addr, xprt->xpt_remotebuf)
-	),
-	TP_fast_assign(
-		__entry->len = len;
-		__entry->flags = xprt->xpt_flags;
-		__assign_str(addr, xprt->xpt_remotebuf);
-	),
-	TP_printk("addr=%s len=%d flags=%s", __get_str(addr),
-		__entry->len, show_svc_xprt_flags(__entry->flags))
-);
 TRACE_EVENT(svc_stats_latency,
 	TP_PROTO(const struct svc_rqst *rqst),
 	TP_STRUCT__entry(
 		__field(long, status)
 		__string(service, service)
-		__array(unsigned char, addr, sizeof(struct sockaddr_in6))
+		__field(unsigned int, netns_ino)
 	),
 	TP_fast_assign(
 		__entry->status = status;
 		__assign_str(service, service);
-		memcpy(__entry->addr, &xprt->xpt_local, sizeof(__entry->addr));
+		__entry->netns_ino = xprt->xpt_net->ns.inum;
 	),
-	TP_printk("listener=%pISpc service=%s status=%ld",
+	TP_printk("addr=listener service=%s status=%ld",
-		__entry->addr, __get_str(service), __entry->status
+		__get_str(service), __entry->status
 	)
 );

net/sunrpc/svc.c+74−101

@@ -37,18 +37,37 @@ · 36 unmodified lines
37		37
38	static void svc_unregister(const struct svc_serv serv, struct net net);	38	static void svc_unregister(const struct svc_serv serv, struct net net);
39		39
40	#define svc_serv_is_pooled(serv) ((serv)->sv_ops->svo_function)
41
42	#define SVC_POOL_DEFAULT SVC_POOL_GLOBAL	40	#define SVC_POOL_DEFAULT SVC_POOL_GLOBAL
43		41
		42	/*
		43	* Mode for mapping cpus to pools.
		44	*/
		45	enum {
		46	SVC_POOL_AUTO = -1, /* choose one of the others */
		47	SVC_POOL_GLOBAL, /* no mapping, just a single global pool
		48	* (legacy & UP mode) */
		49	SVC_POOL_PERCPU, /* one pool per cpu */
		50	SVC_POOL_PERNODE /* one pool per numa node */
		51	};
		52
44	/*	53	/*
45	* Structure for mapping cpus to pools and vice versa.	54	* Structure for mapping cpus to pools and vice versa.
46	* Setup once during sunrpc initialisation.	55	* Setup once during sunrpc initialisation.
47	*/	56	*/
48	struct svc_pool_map svc_pool_map = {	57
		58	struct svc_pool_map {
		59	int count; /* How many svc_servs use us */
		60	int mode; /* Note: int not enum to avoid
		61	* warnings about "enumeration value
		62	* not handled in switch" */
		63	unsigned int npools;
		64	unsigned int pool_to; / maps pool id to cpu or node */
		65	unsigned int to_pool; / maps cpu or node to pool id */
		66	};
		67
		68	static struct svc_pool_map svc_pool_map = {
49	.mode = SVC_POOL_DEFAULT	69	.mode = SVC_POOL_DEFAULT
50	};	70	};
51	EXPORT_SYMBOL_GPL(svc_pool_map);
52		71
53	static DEFINE_MUTEX(svc_pool_map_mutex);/* protects svc_pool_map.count only */	72	static DEFINE_MUTEX(svc_pool_map_mutex);/* protects svc_pool_map.count only */
54		73
@@ -219,10 +238,12 @@ svc_pool_map_init_pernode(struct svc_pool_map *m) · 164 unmodified lines
219		238
220	/*	239	/*
221	* Add a reference to the global map of cpus to pools (and	240	* Add a reference to the global map of cpus to pools (and
222	* vice versa). Initialise the map if we're the first user.	241	* vice versa) if pools are in use.
223	* Returns the number of pools.	242	* Initialise the map if we're the first user.
		243	* Returns the number of pools. If this is '1', no reference
		244	* was taken.
224	*/	245	*/
225	unsigned int	246	static unsigned int
226	svc_pool_map_get(void)	247	svc_pool_map_get(void)
227	{	248	{
228	struct svc_pool_map *m = &svc_pool_map;	249	struct svc_pool_map *m = &svc_pool_map;
@@ -232,6 +253,7 @@ svc_pool_map_get(void) · 3 unmodified lines
232		253
233	if (m->count++) {	254	if (m->count++) {
234	mutex_unlock(&svc_pool_map_mutex);	255	mutex_unlock(&svc_pool_map_mutex);
		256	WARN_ON_ONCE(m->npools <= 1);
235	return m->npools;	257	return m->npools;
236	}	258	}
237		259
@@ -247,30 +269,36 @@ svc_pool_map_get(void) · 9 unmodified lines
247	break;	269	break;
248	}	270	}
249		271
250	if (npools < 0) {	272	if (npools <= 0) {
251	/* default, or memory allocation failure */	273	/* default, or memory allocation failure */
252	npools = 1;	274	npools = 1;
253	m->mode = SVC_POOL_GLOBAL;	275	m->mode = SVC_POOL_GLOBAL;
254	}	276	}
255	m->npools = npools;	277	m->npools = npools;
256		278
		279	if (npools == 1)
		280	/* service is unpooled, so doesn't hold a reference */
		281	m->count--;
		282
257	mutex_unlock(&svc_pool_map_mutex);	283	mutex_unlock(&svc_pool_map_mutex);
258	return m->npools;	284	return npools;
259	}	285	}
260	EXPORT_SYMBOL_GPL(svc_pool_map_get);
261		286
262	/*	287	/*
263	* Drop a reference to the global map of cpus to pools.	288	* Drop a reference to the global map of cpus to pools, if
		289	* pools were in use, i.e. if npools > 1.
264	* When the last reference is dropped, the map data is	290	* When the last reference is dropped, the map data is
265	* freed; this allows the sysadmin to change the pool	291	* freed; this allows the sysadmin to change the pool
266	* mode using the pool_mode module option without	292	* mode using the pool_mode module option without
267	* rebooting or re-loading sunrpc.ko.	293	* rebooting or re-loading sunrpc.ko.
268	*/	294	*/
269	void	295	static void
270	svc_pool_map_put(void)	296	svc_pool_map_put(int npools)
271	{	297	{
272	struct svc_pool_map *m = &svc_pool_map;	298	struct svc_pool_map *m = &svc_pool_map;
273		299
		300	if (npools <= 1)
		301	return;
274	mutex_lock(&svc_pool_map_mutex);	302	mutex_lock(&svc_pool_map_mutex);
275		303
276	if (!--m->count) {	304	if (!--m->count) {
@@ -283,7 +311,6 @@ svc_pool_map_put(void) · 6 unmodified lines
283		311
284	mutex_unlock(&svc_pool_map_mutex);	312	mutex_unlock(&svc_pool_map_mutex);
285	}	313	}
286	EXPORT_SYMBOL_GPL(svc_pool_map_put);
287		314
288	static int svc_pool_map_get_node(unsigned int pidx)	315	static int svc_pool_map_get_node(unsigned int pidx)
289	{	316	{
@@ -340,21 +367,18 @@ svc_pool_for_cpu(struct svc_serv *serv, int cpu) · 50 unmodified lines
340	struct svc_pool_map *m = &svc_pool_map;	367	struct svc_pool_map *m = &svc_pool_map;
341	unsigned int pidx = 0;	368	unsigned int pidx = 0;
342		369
343	/*	370	if (serv->sv_nrpools <= 1)
344	* An uninitialised map happens in a pure client when	371	return serv->sv_pools;
345	* lockd is brought up, so silently treat it the	372
346	* same as SVC_POOL_GLOBAL.	373	switch (m->mode) {
347	*/	374	case SVC_POOL_PERCPU:
348	if (svc_serv_is_pooled(serv)) {	375	pidx = m->to_pool[cpu];
349	switch (m->mode) {	376	break;
350	case SVC_POOL_PERCPU:	377	case SVC_POOL_PERNODE:
351	pidx = m->to_pool[cpu];	378	pidx = m->to_pool[cpu_to_node(cpu)];
352	break;	379	break;
353	case SVC_POOL_PERNODE:
354	pidx = m->to_pool[cpu_to_node(cpu)];
355	break;
356	}
357	}	380	}
		381
358	return &serv->sv_pools[pidx % serv->sv_nrpools];	382	return &serv->sv_pools[pidx % serv->sv_nrpools];
359	}	383	}
360		384
@@ -435,7 +459,7 @@ __svc_create(struct svc_program *prog, unsigned int bufsize, int npools, · 74 unmodified lines
435	return NULL;	459	return NULL;
436	serv->sv_name = prog->pg_name;	460	serv->sv_name = prog->pg_name;
437	serv->sv_program = prog;	461	serv->sv_program = prog;
438	serv->sv_nrthreads = 1;	462	kref_init(&serv->sv_refcnt);
439	serv->sv_stats = prog->pg_stats;	463	serv->sv_stats = prog->pg_stats;
440	if (bufsize > RPCSVC_MAXPAYLOAD)	464	if (bufsize > RPCSVC_MAXPAYLOAD)
441	bufsize = RPCSVC_MAXPAYLOAD;	465	bufsize = RPCSVC_MAXPAYLOAD;
@@ -507,7 +531,7 @@ svc_create_pooled(struct svc_program *prog, unsigned int bufsize, · 65 unmodified lines
507	goto out_err;	531	goto out_err;
508	return serv;	532	return serv;
509	out_err:	533	out_err:
510	svc_pool_map_put();	534	svc_pool_map_put(npools);
511	return NULL;	535	return NULL;
512	}	536	}
513	EXPORT_SYMBOL_GPL(svc_create_pooled);	537	EXPORT_SYMBOL_GPL(svc_create_pooled);
@@ -523,23 +547,14 @@ EXPORT_SYMBOL_GPL(svc_shutdown_net); · 9 unmodified lines
523		547
524	/*	548	/*
525	* Destroy an RPC service. Should be called with appropriate locking to	549	* Destroy an RPC service. Should be called with appropriate locking to
526	* protect the sv_nrthreads, sv_permsocks and sv_tempsocks.	550	* protect sv_permsocks and sv_tempsocks.
527	*/	551	*/
528	void	552	void
529	svc_destroy(struct svc_serv *serv)	553	svc_destroy(struct kref *ref)
530	{	554	{
531	dprintk("svc: svc_destroy(%s, %d)\n",	555	struct svc_serv *serv = container_of(ref, struct svc_serv, sv_refcnt);
532	serv->sv_program->pg_name,
533	serv->sv_nrthreads);
534
535	if (serv->sv_nrthreads) {
536	if (--(serv->sv_nrthreads) != 0) {
537	svc_sock_update_bufs(serv);
538	return;
539	}
540	} else
541	printk("svc_destroy: no threads for serv=%p!\n", serv);
542		556
		557	dprintk("svc: svc_destroy(%s)\n", serv->sv_program->pg_name);
543	del_timer_sync(&serv->sv_temptimer);	558	del_timer_sync(&serv->sv_temptimer);
544		559
545	/*	560	/*
@@ -551,8 +566,7 @@ svc_destroy(struct svc_serv *serv) · 5 unmodified lines
551		566
552	cache_clean_deferred(serv);	567	cache_clean_deferred(serv);
553		568
554	if (svc_serv_is_pooled(serv))	569	svc_pool_map_put(serv->sv_nrpools);
555	svc_pool_map_put();
556		570
557	kfree(serv->sv_pools);	571	kfree(serv->sv_pools);
558	kfree(serv);	572	kfree(serv);
@@ -638,7 +652,7 @@ out_enomem: · 79 unmodified lines
638	}	652	}
639	EXPORT_SYMBOL_GPL(svc_rqst_alloc);	653	EXPORT_SYMBOL_GPL(svc_rqst_alloc);
640		654
641	struct svc_rqst *	655	static struct svc_rqst *
642	svc_prepare_thread(struct svc_serv serv, struct svc_pool pool, int node)	656	svc_prepare_thread(struct svc_serv serv, struct svc_pool pool, int node)
643	{	657	{
644	struct svc_rqst *rqstp;	658	struct svc_rqst *rqstp;
@@ -647,14 +661,17 @@ svc_prepare_thread(struct svc_serv serv, struct svc_pool pool, int node) · 2 unmodified lines
647	if (!rqstp)	661	if (!rqstp)
648	return ERR_PTR(-ENOMEM);	662	return ERR_PTR(-ENOMEM);
649		663
650	serv->sv_nrthreads++;	664	svc_get(serv);
		665	spin_lock_bh(&serv->sv_lock);
		666	serv->sv_nrthreads += 1;
		667	spin_unlock_bh(&serv->sv_lock);
		668
651	spin_lock_bh(&pool->sp_lock);	669	spin_lock_bh(&pool->sp_lock);
652	pool->sp_nrthreads++;	670	pool->sp_nrthreads++;
653	list_add_rcu(&rqstp->rq_all, &pool->sp_all_threads);	671	list_add_rcu(&rqstp->rq_all, &pool->sp_all_threads);
654	spin_unlock_bh(&pool->sp_lock);	672	spin_unlock_bh(&pool->sp_lock);
655	return rqstp;	673	return rqstp;
656	}	674	}
657	EXPORT_SYMBOL_GPL(svc_prepare_thread);
658		675
659	/*	676	/*
660	* Choose a pool in which to create a new thread, for svc_set_num_threads	677	* Choose a pool in which to create a new thread, for svc_set_num_threads
@@ -748,59 +765,13 @@ svc_start_kthreads(struct svc_serv serv, struct svc_pool pool, int nrservs) · 87 unmodified lines
748	return 0;	765	return 0;
749	}	766	}
750		767
751
752	/* destroy old threads */
753	static int
754	svc_signal_kthreads(struct svc_serv serv, struct svc_pool pool, int nrservs)
755	{
756	struct task_struct *task;
757	unsigned int state = serv->sv_nrthreads-1;
758
759	/* destroy old threads */
760	do {
761	task = choose_victim(serv, pool, &state);
762	if (task == NULL)
763	break;
764	send_sig(SIGINT, task, 1);
765	nrservs++;
766	} while (nrservs < 0);
767
768	return 0;
769	}
770
771	/*	768	/*
772	* Create or destroy enough new threads to make the number	769	* Create or destroy enough new threads to make the number
773	* of threads the given number. If `pool' is non-NULL, applies	770	* of threads the given number. If `pool' is non-NULL, applies
774	* only to threads in that pool, otherwise round-robins between	771	* only to threads in that pool, otherwise round-robins between
775	* all pools. Caller must ensure that mutual exclusion between this and	772	* all pools. Caller must ensure that mutual exclusion between this and
776	* server startup or shutdown.	773	* server startup or shutdown.
777	*
778	* Destroying threads relies on the service threads filling in
779	* rqstp->rq_task, which only the nfs ones do. Assumes the serv
780	* has been created using svc_create_pooled().
781	*
782	* Based on code that used to be in nfsd_svc() but tweaked
783	* to be pool-aware.
784	*/	774	*/
785	int
786	svc_set_num_threads(struct svc_serv serv, struct svc_pool pool, int nrservs)
787	{
788	if (pool == NULL) {
789	/* The -1 assumes caller has done a svc_get() */
790	nrservs -= (serv->sv_nrthreads-1);
791	} else {
792	spin_lock_bh(&pool->sp_lock);
793	nrservs -= pool->sp_nrthreads;
794	spin_unlock_bh(&pool->sp_lock);
795	}
796
797	if (nrservs > 0)
798	return svc_start_kthreads(serv, pool, nrservs);
799	if (nrservs < 0)
800	return svc_signal_kthreads(serv, pool, nrservs);
801	return 0;
802	}
803	EXPORT_SYMBOL_GPL(svc_set_num_threads);
804		775
805	/* destroy old threads */	776	/* destroy old threads */
806	static int	777	static int
@@ -821,11 +792,10 @@ svc_stop_kthreads(struct svc_serv serv, struct svc_pool pool, int nrservs) · 14 unmodified lines
821	}	792	}
822		793
823	int	794	int
824	svc_set_num_threads_sync(struct svc_serv serv, struct svc_pool pool, int nrservs)	795	svc_set_num_threads(struct svc_serv serv, struct svc_pool pool, int nrservs)
825	{	796	{
826	if (pool == NULL) {	797	if (pool == NULL) {
827	/* The -1 assumes caller has done a svc_get() */	798	nrservs -= serv->sv_nrthreads;
828	nrservs -= (serv->sv_nrthreads-1);
829	} else {	799	} else {
830	spin_lock_bh(&pool->sp_lock);	800	spin_lock_bh(&pool->sp_lock);
831	nrservs -= pool->sp_nrthreads;	801	nrservs -= pool->sp_nrthreads;
@@ -838,7 +808,7 @@ svc_set_num_threads_sync(struct svc_serv serv, struct svc_pool pool, int nrser · 6 unmodified lines
838	return svc_stop_kthreads(serv, pool, nrservs);	808	return svc_stop_kthreads(serv, pool, nrservs);
839	return 0;	809	return 0;
840	}	810	}
841	EXPORT_SYMBOL_GPL(svc_set_num_threads_sync);	811	EXPORT_SYMBOL_GPL(svc_set_num_threads);
842		812
843	/**	813	/**
844	* svc_rqst_replace_page - Replace one page in rq_pages[]	814	* svc_rqst_replace_page - Replace one page in rq_pages[]
@@ -890,11 +860,14 @@ svc_exit_thread(struct svc_rqst *rqstp) · 45 unmodified lines
890	list_del_rcu(&rqstp->rq_all);	860	list_del_rcu(&rqstp->rq_all);
891	spin_unlock_bh(&pool->sp_lock);	861	spin_unlock_bh(&pool->sp_lock);
892		862
		863	spin_lock_bh(&serv->sv_lock);
		864	serv->sv_nrthreads -= 1;
		865	spin_unlock_bh(&serv->sv_lock);
		866	svc_sock_update_bufs(serv);
		867
893	svc_rqst_free(rqstp);	868	svc_rqst_free(rqstp);
894		869
895	/* Release the server */	870	svc_put(serv);
896	if (serv)
897	svc_destroy(serv);
898	}	871	}
899	EXPORT_SYMBOL_GPL(svc_exit_thread);	872	EXPORT_SYMBOL_GPL(svc_exit_thread);
900		873

net/sunrpc/svc_xprt.c+3−5

 	xprt = xcl->xcl_ops->xpo_create(serv, net, sap, len, flags);
 	if (IS_ERR(xprt))
 		trace_svc_xprt_create_err(serv->sv_program->pg_name,
-					  xcl->xcl_name, sap, xprt);
+					  xcl->xcl_name, sap, len, xprt);
 	return xprt;
 }
 		return;
 	}
-	trace_svc_xprt_received(xprt);
 	/* As soon as we clear busy, the xprt could be closed and
 	 * 'put', so we need a reference to call svc_enqueue_xprt with:
 	 */
 out_unlock:
 	rcu_read_unlock();
 	put_cpu();
-	trace_svc_xprt_do_enqueue(xprt, rqstp);
+	trace_svc_xprt_enqueue(xprt, rqstp);
 }
 EXPORT_SYMBOL_GPL(svc_xprt_do_enqueue);
 		atomic_add(rqstp->rq_reserved, &xprt->xpt_reserved);
 	} else
 		svc_xprt_received(xprt);
 out:
-	trace_svc_handle_xprt(xprt, len);
 	return len;
 }