lael-labs/linux

fs/lockd/Makefile+4−2

 # Makefile for the linux lock manager stuff
 #
+ccflags-y += -I$(src)			# needed for trace events
 obj-$(CONFIG_LOCKD) += lockd.o
-lockd-objs-y := clntlock.o clntproc.o clntxdr.o host.o svc.o svclock.o \
+lockd-objs-y += clntlock.o clntproc.o clntxdr.o host.o svc.o svclock.o \
-	        svcshare.o svcproc.o svcsubs.o mon.o xdr.o
+	        svcshare.o svcproc.o svcsubs.o mon.o trace.o xdr.o
 lockd-objs-$(CONFIG_LOCKD_V4) += clnt4xdr.o xdr4.o svc4proc.o
 lockd-objs-$(CONFIG_PROC_FS) += procfs.o
 lockd-objs		      := $(lockd-objs-y)

fs/lockd/clntlock.c+25−33

@@ -14,9 +14,12 @@ · 13 unmodified lines
14	#include <linux/nfs_fs.h>	14	#include <linux/nfs_fs.h>
15	#include <linux/sunrpc/addr.h>	15	#include <linux/sunrpc/addr.h>
16	#include <linux/sunrpc/svc.h>	16	#include <linux/sunrpc/svc.h>
		17	#include <linux/sunrpc/svc_xprt.h>
17	#include <linux/lockd/lockd.h>	18	#include <linux/lockd/lockd.h>
18	#include <linux/kthread.h>	19	#include <linux/kthread.h>
19		20
		21	#include "trace.h"
		22
20	#define NLMDBG_FACILITY NLMDBG_CLIENT	23	#define NLMDBG_FACILITY NLMDBG_CLIENT
21		24
22	/*	25	/*
@@ -29,18 +32,6 @@ static int reclaimer(void *ptr); · 6 unmodified lines
29	* client perspective.	32	* client perspective.
30	*/	33	*/
31		34
32	/*
33	* This is the representation of a blocked client lock.
34	*/
35	struct nlm_wait {
36	struct list_head b_list; /* linked list */
37	wait_queue_head_t b_wait; /* where to wait on */
38	struct nlm_host * b_host;
39	struct file_lock * b_lock; /* local file lock */
40	unsigned short b_reclaim; /* got to reclaim lock */
41	__be32 b_status; /* grant callback status */
42	};
43
44	static LIST_HEAD(nlm_blocked);	35	static LIST_HEAD(nlm_blocked);
45	static DEFINE_SPINLOCK(nlm_blocked_lock);	36	static DEFINE_SPINLOCK(nlm_blocked_lock);
46		37
@@ -94,41 +85,42 @@ void nlmclnt_done(struct nlm_host *host) · 47 unmodified lines
94	}	85	}
95	EXPORT_SYMBOL_GPL(nlmclnt_done);	86	EXPORT_SYMBOL_GPL(nlmclnt_done);
96		87
		88	void nlmclnt_prepare_block(struct nlm_wait block, struct nlm_host host, struct file_lock *fl)
		89	{
		90	block->b_host = host;
		91	block->b_lock = fl;
		92	init_waitqueue_head(&block->b_wait);
		93	block->b_status = nlm_lck_blocked;
		94	}
		95
97	/*	96	/*
98	* Queue up a lock for blocking so that the GRANTED request can see it	97	* Queue up a lock for blocking so that the GRANTED request can see it
99	*/	98	*/
100	struct nlm_wait nlmclnt_prepare_block(struct nlm_host host, struct file_lock *fl)	99	void nlmclnt_queue_block(struct nlm_wait *block)
101	{	100	{
102	struct nlm_wait *block;	101	spin_lock(&nlm_blocked_lock);
103		102	list_add(&block->b_list, &nlm_blocked);
104	block = kmalloc(sizeof(*block), GFP_KERNEL);	103	spin_unlock(&nlm_blocked_lock);
105	if (block != NULL) {
106	block->b_host = host;
107	block->b_lock = fl;
108	init_waitqueue_head(&block->b_wait);
109	block->b_status = nlm_lck_blocked;
110
111	spin_lock(&nlm_blocked_lock);
112	list_add(&block->b_list, &nlm_blocked);
113	spin_unlock(&nlm_blocked_lock);
114	}
115	return block;
116	}	104	}
117		105
118	void nlmclnt_finish_block(struct nlm_wait *block)	106	/*
		107	* Dequeue the block and return its final status
		108	*/
		109	__be32 nlmclnt_dequeue_block(struct nlm_wait *block)
119	{	110	{
120	if (block == NULL)	111	__be32 status;
121	return;	112
122	spin_lock(&nlm_blocked_lock);	113	spin_lock(&nlm_blocked_lock);
123	list_del(&block->b_list);	114	list_del(&block->b_list);
		115	status = block->b_status;
124	spin_unlock(&nlm_blocked_lock);	116	spin_unlock(&nlm_blocked_lock);
125	kfree(block);	117	return status;
126	}	118	}
127		119
128	/*	120	/*
129	* Block on a lock	121	* Block on a lock
130	*/	122	*/
131	int nlmclnt_block(struct nlm_wait block, struct nlm_rqst req, long timeout)	123	int nlmclnt_wait(struct nlm_wait block, struct nlm_rqst req, long timeout)
132	{	124	{
133	long ret;	125	long ret;
134		126
@@ -154,7 +146,6 @@ int nlmclnt_block(struct nlm_wait block, struct nlm_rqst req, long timeout) · 19 unmodified lines
154	/* Reset the lock status after a server reboot so we resend */	146	/* Reset the lock status after a server reboot so we resend */
155	if (block->b_status == nlm_lck_denied_grace_period)	147	if (block->b_status == nlm_lck_denied_grace_period)
156	block->b_status = nlm_lck_blocked;	148	block->b_status = nlm_lck_blocked;
157	req->a_res.status = block->b_status;
158	return 0;	149	return 0;
159	}	150	}
160		151
@@ -198,6 +189,7 @@ __be32 nlmclnt_grant(const struct sockaddr addr, const struct nlm_lock lock) · 37 unmodified lines
198	res = nlm_granted;	189	res = nlm_granted;
199	}	190	}
200	spin_unlock(&nlm_blocked_lock);	191	spin_unlock(&nlm_blocked_lock);
		192	trace_nlmclnt_grant(lock, addr, svc_addr_len(addr), res);
201	return res;	193	return res;
202	}	194	}
203		195

fs/lockd/clntproc.c+32−10

@@ -20,6 +20,8 @@ · 19 unmodified lines
20	#include <linux/sunrpc/svc.h>	20	#include <linux/sunrpc/svc.h>
21	#include <linux/lockd/lockd.h>	21	#include <linux/lockd/lockd.h>
22		22
		23	#include "trace.h"
		24
23	#define NLMDBG_FACILITY NLMDBG_CLIENT	25	#define NLMDBG_FACILITY NLMDBG_CLIENT
24	#define NLMCLNT_GRACE_WAIT (5*HZ)	26	#define NLMCLNT_GRACE_WAIT (5*HZ)
25	#define NLMCLNT_POLL_TIMEOUT (30*HZ)	27	#define NLMCLNT_POLL_TIMEOUT (30*HZ)
@@ -451,6 +453,9 @@ nlmclnt_test(struct nlm_rqst req, struct file_lock fl) · 425 unmodified lines
451	status = nlm_stat_to_errno(req->a_res.status);	453	status = nlm_stat_to_errno(req->a_res.status);
452	}	454	}
453	out:	455	out:
		456	trace_nlmclnt_test(&req->a_args.lock,
		457	(const struct sockaddr *)&req->a_host->h_addr,
		458	req->a_host->h_addrlen, req->a_res.status);
454	nlmclnt_release_call(req);	459	nlmclnt_release_call(req);
455	return status;	460	return status;
456	}	461	}
@@ -516,9 +521,10 @@ nlmclnt_lock(struct nlm_rqst req, struct file_lock fl) · 59 unmodified lines
516	const struct cred *cred = nfs_file_cred(fl->fl_file);	521	const struct cred *cred = nfs_file_cred(fl->fl_file);
517	struct nlm_host *host = req->a_host;	522	struct nlm_host *host = req->a_host;
518	struct nlm_res *resp = &req->a_res;	523	struct nlm_res *resp = &req->a_res;
519	struct nlm_wait *block = NULL;	524	struct nlm_wait block;
520	unsigned char fl_flags = fl->fl_flags;	525	unsigned char fl_flags = fl->fl_flags;
521	unsigned char fl_type;	526	unsigned char fl_type;
		527	__be32 b_status;
522	int status = -ENOLCK;	528	int status = -ENOLCK;
523		529
524	if (nsm_monitor(host) < 0)	530	if (nsm_monitor(host) < 0)
@@ -531,31 +537,41 @@ nlmclnt_lock(struct nlm_rqst req, struct file_lock fl) · 6 unmodified lines
531	if (status < 0)	537	if (status < 0)
532	goto out;	538	goto out;
533		539
534	block = nlmclnt_prepare_block(host, fl);	540	nlmclnt_prepare_block(&block, host, fl);
535	again:	541	again:
536	/*	542	/*
537	* Initialise resp->status to a valid non-zero value,	543	* Initialise resp->status to a valid non-zero value,
538	* since 0 == nlm_lck_granted	544	* since 0 == nlm_lck_granted
539	*/	545	*/
540	resp->status = nlm_lck_blocked;	546	resp->status = nlm_lck_blocked;
541	for(;;) {	547
		548	/*
		549	* A GRANTED callback can come at any time -- even before the reply
		550	* to the LOCK request arrives, so we queue the wait before
		551	* requesting the lock.
		552	*/
		553	nlmclnt_queue_block(&block);
		554	for (;;) {
542	/* Reboot protection */	555	/* Reboot protection */
543	fl->fl_u.nfs_fl.state = host->h_state;	556	fl->fl_u.nfs_fl.state = host->h_state;
544	status = nlmclnt_call(cred, req, NLMPROC_LOCK);	557	status = nlmclnt_call(cred, req, NLMPROC_LOCK);
545	if (status < 0)	558	if (status < 0)
546	break;	559	break;
547	/* Did a reclaimer thread notify us of a server reboot? */	560	/* Did a reclaimer thread notify us of a server reboot? */
548	if (resp->status == nlm_lck_denied_grace_period)	561	if (resp->status == nlm_lck_denied_grace_period)
549	continue;	562	continue;
550	if (resp->status != nlm_lck_blocked)	563	if (resp->status != nlm_lck_blocked)
551	break;	564	break;
552	/* Wait on an NLM blocking lock */	565	/* Wait on an NLM blocking lock */
553	status = nlmclnt_block(block, req, NLMCLNT_POLL_TIMEOUT);	566	status = nlmclnt_wait(&block, req, NLMCLNT_POLL_TIMEOUT);
554	if (status < 0)	567	if (status < 0)
555	break;	568	break;
556	if (resp->status != nlm_lck_blocked)	569	if (block.b_status != nlm_lck_blocked)
557	break;	570	break;
558	}	571	}
		572	b_status = nlmclnt_dequeue_block(&block);
		573	if (resp->status == nlm_lck_blocked)
		574	resp->status = b_status;
559		575
560	/* if we were interrupted while blocking, then cancel the lock request	576	/* if we were interrupted while blocking, then cancel the lock request
561	* and exit	577	* and exit
@@ -564,7 +580,7 @@ again: · 2 unmodified lines
564	if (!req->a_args.block)	580	if (!req->a_args.block)
565	goto out_unlock;	581	goto out_unlock;
566	if (nlmclnt_cancel(host, req->a_args.block, fl) == 0)	582	if (nlmclnt_cancel(host, req->a_args.block, fl) == 0)
567	goto out_unblock;	583	goto out;
568	}	584	}
569		585
570	if (resp->status == nlm_granted) {	586	if (resp->status == nlm_granted) {
@@ -593,16 +609,19 @@ again: · 22 unmodified lines
593	status = -ENOLCK;	609	status = -ENOLCK;
594	else	610	else
595	status = nlm_stat_to_errno(resp->status);	611	status = nlm_stat_to_errno(resp->status);
596	out_unblock:
597	nlmclnt_finish_block(block);
598	out:	612	out:
		613	trace_nlmclnt_lock(&req->a_args.lock,
		614	(const struct sockaddr *)&req->a_host->h_addr,
		615	req->a_host->h_addrlen, req->a_res.status);
599	nlmclnt_release_call(req);	616	nlmclnt_release_call(req);
600	return status;	617	return status;
601	out_unlock:	618	out_unlock:
602	/* Fatal error: ensure that we remove the lock altogether */	619	/* Fatal error: ensure that we remove the lock altogether */
		620	trace_nlmclnt_lock(&req->a_args.lock,
		621	(const struct sockaddr *)&req->a_host->h_addr,
		622	req->a_host->h_addrlen, req->a_res.status);
603	dprintk("lockd: lock attempt ended in fatal error.\n"	623	dprintk("lockd: lock attempt ended in fatal error.\n"
604	" Attempting to unlock.\n");	624	" Attempting to unlock.\n");
605	nlmclnt_finish_block(block);
606	fl_type = fl->fl_type;	625	fl_type = fl->fl_type;
607	fl->fl_type = F_UNLCK;	626	fl->fl_type = F_UNLCK;
608	down_read(&host->h_rwsem);	627	down_read(&host->h_rwsem);
@@ -696,6 +715,9 @@ nlmclnt_unlock(struct nlm_rqst req, struct file_lock fl) · 87 unmodified lines
696	/* What to do now? I'm out of my depth... */	715	/* What to do now? I'm out of my depth... */
697	status = -ENOLCK;	716	status = -ENOLCK;
698	out:	717	out:
		718	trace_nlmclnt_unlock(&req->a_args.lock,
		719	(const struct sockaddr *)&req->a_host->h_addr,
		720	req->a_host->h_addrlen, req->a_res.status);
699	nlmclnt_release_call(req);	721	nlmclnt_release_call(req);
700	return status;	722	return status;
701	}	723	}

fs/lockd/host.c+1−0

@@ -629,6 +629,7 @@ nlm_shutdown_hosts_net(struct net *net) · 628 unmodified lines
629	rpc_shutdown_client(host->h_rpcclnt);	629	rpc_shutdown_client(host->h_rpcclnt);
630	host->h_rpcclnt = NULL;	630	host->h_rpcclnt = NULL;
631	}	631	}
		632	nlmsvc_free_host_resources(host);
632	}	633	}
633		634
634	/* Then, perform a garbage collection pass */	635	/* Then, perform a garbage collection pass */

fs/lockd/svclock.c+17−4

 nlmsvc_grant_reply(struct nlm_cookie *cookie, __be32 status)
 {
 	struct nlm_block	*block;
+	struct file_lock	*fl;
+	int			error;
 	dprintk("grant_reply: looking for cookie %x, s=%d \n",
 		*(unsigned int *)(cookie->data), status);
 	if (!(block = nlmsvc_find_block(cookie)))
 		return;
-	if (status == nlm_lck_denied_grace_period) {
+	switch (status) {
+	case nlm_lck_denied_grace_period:
 		/* Try again in a couple of seconds */
 		nlmsvc_insert_block(block, 10 * HZ);
-	} else {
+		break;
+	case nlm_lck_denied:
+		/* Client doesn't want it, just unlock it */
+		nlmsvc_unlink_block(block);
+		fl = &block->b_call->a_args.lock.fl;
+		fl->fl_type = F_UNLCK;
+		error = vfs_lock_file(fl->fl_file, F_SETLK, fl, NULL);
+		if (error)
+			pr_warn("lockd: unable to unlock lock rejected by client!\n");
+		break;
+	default:
 		/*
-		 * Lock is now held by client, or has been rejected.
+		 * Either it was accepted or the status makes no sense
-		 * In both cases, the block should be removed.
+		 * just unlink it either way.
 		 */
 		nlmsvc_unlink_block(block);
 	}

fs/lockd/trace.c+3−0

@@ -0,0 +1,3 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	#define CREATE_TRACE_POINTS
	3	#include "trace.h"

fs/lockd/trace.h+106−0

@@ -0,0 +1,106 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#undef TRACE_SYSTEM
	3	#define TRACE_SYSTEM lockd
	4
	5	#if !defined(_TRACE_LOCKD_H) \|\| defined(TRACE_HEADER_MULTI_READ)
	6	#define _TRACE_LOCKD_H
	7
	8	#include <linux/tracepoint.h>
	9	#include <linux/crc32.h>
	10	#include <linux/nfs.h>
	11	#include <linux/lockd/lockd.h>
	12
	13	#ifdef CONFIG_LOCKD_V4
	14	#define NLM_STATUS_LIST \
	15	nlm_status_code(LCK_GRANTED) \
	16	nlm_status_code(LCK_DENIED) \
	17	nlm_status_code(LCK_DENIED_NOLOCKS) \
	18	nlm_status_code(LCK_BLOCKED) \
	19	nlm_status_code(LCK_DENIED_GRACE_PERIOD) \
	20	nlm_status_code(DEADLCK) \
	21	nlm_status_code(ROFS) \
	22	nlm_status_code(STALE_FH) \
	23	nlm_status_code(FBIG) \
	24	nlm_status_code_end(FAILED)
	25	#else
	26	#define NLM_STATUS_LIST \
	27	nlm_status_code(LCK_GRANTED) \
	28	nlm_status_code(LCK_DENIED) \
	29	nlm_status_code(LCK_DENIED_NOLOCKS) \
	30	nlm_status_code(LCK_BLOCKED) \
	31	nlm_status_code_end(LCK_DENIED_GRACE_PERIOD)
	32	#endif
	33
	34	#undef nlm_status_code
	35	#undef nlm_status_code_end
	36	#define nlm_status_code(x) TRACE_DEFINE_ENUM(NLM_##x);
	37	#define nlm_status_code_end(x) TRACE_DEFINE_ENUM(NLM_##x);
	38
	39	NLM_STATUS_LIST
	40
	41	#undef nlm_status_code
	42	#undef nlm_status_code_end
	43	#define nlm_status_code(x) { NLM_##x, #x },
	44	#define nlm_status_code_end(x) { NLM_##x, #x }
	45
	46	#define show_nlm_status(x) __print_symbolic(x, NLM_STATUS_LIST)
	47
	48	DECLARE_EVENT_CLASS(nlmclnt_lock_event,
	49	TP_PROTO(
	50	const struct nlm_lock *lock,
	51	const struct sockaddr *addr,
	52	unsigned int addrlen,
	53	__be32 status
	54	),
	55
	56	TP_ARGS(lock, addr, addrlen, status),
	57
	58	TP_STRUCT__entry(
	59	__field(u32, oh)
	60	__field(u32, svid)
	61	__field(u32, fh)
	62	__field(unsigned long, status)
	63	__field(u64, start)
	64	__field(u64, len)
	65	__sockaddr(addr, addrlen)
	66	),
	67
	68	TP_fast_assign(
	69	__entry->oh = ~crc32_le(0xffffffff, lock->oh.data, lock->oh.len);
	70	__entry->svid = lock->svid;
	71	__entry->fh = nfs_fhandle_hash(&lock->fh);
	72	__entry->start = lock->lock_start;
	73	__entry->len = lock->lock_len;
	74	__entry->status = be32_to_cpu(status);
	75	__assign_sockaddr(addr, addr, addrlen);
	76	),
	77
	78	TP_printk(
	79	"addr=%pISpc oh=0x%08x svid=0x%08x fh=0x%08x start=%llu len=%llu status=%s",
	80	__get_sockaddr(addr), __entry->oh, __entry->svid,
	81	__entry->fh, __entry->start, __entry->len,
	82	show_nlm_status(__entry->status)
	83	)
	84	);
	85
	86	#define DEFINE_NLMCLNT_EVENT(name) \
	87	DEFINE_EVENT(nlmclnt_lock_event, name, \
	88	TP_PROTO( \
	89	const struct nlm_lock *lock, \
	90	const struct sockaddr *addr, \
	91	unsigned int addrlen, \
	92	__be32 status \
	93	), \
	94	TP_ARGS(lock, addr, addrlen, status))
	95
	96	DEFINE_NLMCLNT_EVENT(nlmclnt_test);
	97	DEFINE_NLMCLNT_EVENT(nlmclnt_lock);
	98	DEFINE_NLMCLNT_EVENT(nlmclnt_unlock);
	99	DEFINE_NLMCLNT_EVENT(nlmclnt_grant);
	100
	101	#endif /* _TRACE_LOCKD_H */
	102
	103	#undef TRACE_INCLUDE_PATH
	104	#define TRACE_INCLUDE_PATH .
	105	#define TRACE_INCLUDE_FILE trace
	106	#include <trace/define_trace.h>

fs/nfs/export.c+6−3

 	.encode_fh = nfs_encode_fh,
 	.fh_to_dentry = nfs_fh_to_dentry,
 	.get_parent = nfs_get_parent,
-	.flags = EXPORT_OP_NOWCC|EXPORT_OP_NOSUBTREECHK|
+	.flags = EXPORT_OP_NOWCC		|
-		EXPORT_OP_CLOSE_BEFORE_UNLINK|EXPORT_OP_REMOTE_FS|
+		 EXPORT_OP_NOSUBTREECHK		|
-		EXPORT_OP_NOATOMIC_ATTR,
+		 EXPORT_OP_CLOSE_BEFORE_UNLINK	|
+		 EXPORT_OP_REMOTE_FS		|
+		 EXPORT_OP_NOATOMIC_ATTR	|
+		 EXPORT_OP_FLUSH_ON_CLOSE,
 };

fs/nfs/internal.h+0−15

@@ -855,27 +855,12 @@ u64 nfs_timespec_to_change_attr(const struct timespec64 *ts) · 854 unmodified lines
855	}	855	}
856		856
857	#ifdef CONFIG_CRC32	857	#ifdef CONFIG_CRC32
858	/**
859	* nfs_fhandle_hash - calculate the crc32 hash for the filehandle
860	* @fh - pointer to filehandle
861	*
862	* returns a crc32 hash for the filehandle that is compatible with
863	* the one displayed by "wireshark".
864	*/
865	static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
866	{
867	return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);
868	}
869	static inline u32 nfs_stateid_hash(const nfs4_stateid *stateid)	858	static inline u32 nfs_stateid_hash(const nfs4_stateid *stateid)
870	{	859	{
871	return ~crc32_le(0xFFFFFFFF, &stateid->other[0],	860	return ~crc32_le(0xFFFFFFFF, &stateid->other[0],
872	NFS4_STATEID_OTHER_SIZE);	861	NFS4_STATEID_OTHER_SIZE);
873	}	862	}
874	#else	863	#else
875	static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
876	{
877	return 0;
878	}
879	static inline u32 nfs_stateid_hash(nfs4_stateid *stateid)	864	static inline u32 nfs_stateid_hash(nfs4_stateid *stateid)
880	{	865	{
881	return 0;	866	return 0;

fs/nfsd/export.c+54−10

 	/* OK, we seem to have a valid key */
 	key.h.flags = 0;
-	key.h.expiry_time = get_expiry(&mesg);
+	err = get_expiry(&mesg, &key.h.expiry_time);
-	if (key.h.expiry_time == 0)
+	if (err)
 		goto out;
 	key.ek_client = dom;
 	key.ek_fsidtype = fsidtype;
 	memcpy(key.ek_fsid, buf, len);
 		return -EINVAL;
 	}
 	return 0;
 }
 #ifdef CONFIG_NFSD_V4
 secinfo_parse(char **mesg, char *buf, struct svc_export *exp) { return 0; }
 #endif
+static int xprtsec_parse(char **mesg, char *buf, struct svc_export *exp)
+{
+	unsigned int i, mode, listsize;
+	int err;
+	err = get_uint(mesg, &listsize);
+	if (err)
+		return err;
+	if (listsize > NFSEXP_XPRTSEC_NUM)
+		return -EINVAL;
+	exp->ex_xprtsec_modes = 0;
+	for (i = 0; i < listsize; i++) {
+		err = get_uint(mesg, &mode);
+		if (err)
+			return err;
+		if (mode > NFSEXP_XPRTSEC_MTLS)
+			return -EINVAL;
+		exp->ex_xprtsec_modes |= mode;
+	}
+	return 0;
+}
 static inline int
 nfsd_uuid_parse(char **mesg, char *buf, unsigned char **puuid)
 {
 	exp.ex_client = dom;
 	exp.cd = cd;
 	exp.ex_devid_map = NULL;
+	exp.ex_xprtsec_modes = NFSEXP_XPRTSEC_ALL;
 	/* expiry */
-	err = -EINVAL;
+	err = get_expiry(&mesg, &exp.h.expiry_time);
-	exp.h.expiry_time = get_expiry(&mesg);
+	if (err)
-	if (exp.h.expiry_time == 0)
 		goto out3;
 	/* flags */
 		if (err || an_int < 0)
 			goto out3;
 		exp.ex_flags= an_int;
 		/* anon uid */
 		err = get_int(&mesg, &an_int);
 		if (err)
 				err = nfsd_uuid_parse(&mesg, buf, &exp.ex_uuid);
 			else if (strcmp(buf, "secinfo") == 0)
 				err = secinfo_parse(&mesg, buf, &exp);
+			else if (strcmp(buf, "xprtsec") == 0)
+				err = xprtsec_parse(&mesg, buf, &exp);
 			else
 				/* quietly ignore unknown words and anything
 				 * following. Newer user-space can try to set
 		err = check_export(&exp.ex_path, &exp.ex_flags, exp.ex_uuid);
 		if (err)
 			goto out4;
 		/*
 		 * No point caching this if it would immediately expire.
 		 * Also, this protects exportfs's dummy export from the
 	for (i = 0; i < MAX_SECINFO_LIST; i++) {
 		new->ex_flavors[i] = item->ex_flavors[i];
 	}
+	new->ex_xprtsec_modes = item->ex_xprtsec_modes;
 }
 static struct cache_head *svc_export_alloc(void)
 __be32 check_nfsd_access(struct svc_export *exp, struct svc_rqst *rqstp)
 {
-	struct exp_flavor_info *f;
+	struct exp_flavor_info *f, *end = exp->ex_flavors + exp->ex_nflavors;
-	struct exp_flavor_info *end = exp->ex_flavors + exp->ex_nflavors;
+	struct svc_xprt *xprt = rqstp->rq_xprt;
+	if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_NONE) {
+		if (!test_bit(XPT_TLS_SESSION, &xprt->xpt_flags))
+			goto ok;
+	}
+	if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_TLS) {
+		if (test_bit(XPT_TLS_SESSION, &xprt->xpt_flags) &&
+		    !test_bit(XPT_PEER_AUTH, &xprt->xpt_flags))
+			goto ok;
+	}
+	if (exp->ex_xprtsec_modes & NFSEXP_XPRTSEC_MTLS) {
+		if (test_bit(XPT_TLS_SESSION, &xprt->xpt_flags) &&
+		    test_bit(XPT_PEER_AUTH, &xprt->xpt_flags))
+			goto ok;
+	}
+	goto denied;
+ok:
 	/* legacy gss-only clients are always OK: */
 	if (exp->ex_client == rqstp->rq_gssclient)
 		return 0;
 	if (nfsd4_spo_must_allow(rqstp))
 		return 0;
+denied:
 	return rqstp->rq_vers < 4 ? nfserr_acces : nfserr_wrongsec;
 }

fs/nfsd/export.h+1−0

@@ -77,6 +77,7 @@ struct svc_export { · 76 unmodified lines
77	struct cache_detail *cd;	77	struct cache_detail *cd;
78	struct rcu_head ex_rcu;	78	struct rcu_head ex_rcu;
79	struct export_stats ex_stats;	79	struct export_stats ex_stats;
		80	unsigned long ex_xprtsec_modes;
80	};	81	};
81		82
82	/* an "export key" (expkey) maps a filehandlefragement to an	83	/* an "export key" (expkey) maps a filehandlefragement to an

fs/nfsd/filecache.c+185−245

@@ -74,70 +74,9 @@ static struct list_lru nfsd_file_lru; · 73 unmodified lines
74	static unsigned long nfsd_file_flags;	74	static unsigned long nfsd_file_flags;
75	static struct fsnotify_group *nfsd_file_fsnotify_group;	75	static struct fsnotify_group *nfsd_file_fsnotify_group;
76	static struct delayed_work nfsd_filecache_laundrette;	76	static struct delayed_work nfsd_filecache_laundrette;
77	static struct rhashtable nfsd_file_rhash_tbl	77	static struct rhltable nfsd_file_rhltable
78	____cacheline_aligned_in_smp;	78	____cacheline_aligned_in_smp;
79		79
80	enum nfsd_file_lookup_type {
81	NFSD_FILE_KEY_INODE,
82	NFSD_FILE_KEY_FULL,
83	};
84
85	struct nfsd_file_lookup_key {
86	struct inode *inode;
87	struct net *net;
88	const struct cred *cred;
89	unsigned char need;
90	bool gc;
91	enum nfsd_file_lookup_type type;
92	};
93
94	/*
95	* The returned hash value is based solely on the address of an in-code
96	* inode, a pointer to a slab-allocated object. The entropy in such a
97	* pointer is concentrated in its middle bits.
98	*/
99	static u32 nfsd_file_inode_hash(const struct inode *inode, u32 seed)
100	{
101	unsigned long ptr = (unsigned long)inode;
102	u32 k;
103
104	k = ptr >> L1_CACHE_SHIFT;
105	k &= 0x00ffffff;
106	return jhash2(&k, 1, seed);
107	}
108
109	/**
110	* nfsd_file_key_hashfn - Compute the hash value of a lookup key
111	* @data: key on which to compute the hash value
112	* @len: rhash table's key_len parameter (unused)
113	* @seed: rhash table's random seed of the day
114	*
115	* Return value:
116	* Computed 32-bit hash value
117	*/
118	static u32 nfsd_file_key_hashfn(const void *data, u32 len, u32 seed)
119	{
120	const struct nfsd_file_lookup_key *key = data;
121
122	return nfsd_file_inode_hash(key->inode, seed);
123	}
124
125	/**
126	* nfsd_file_obj_hashfn - Compute the hash value of an nfsd_file
127	* @data: object on which to compute the hash value
128	* @len: rhash table's key_len parameter (unused)
129	* @seed: rhash table's random seed of the day
130	*
131	* Return value:
132	* Computed 32-bit hash value
133	*/
134	static u32 nfsd_file_obj_hashfn(const void *data, u32 len, u32 seed)
135	{
136	const struct nfsd_file *nf = data;
137
138	return nfsd_file_inode_hash(nf->nf_inode, seed);
139	}
140
141	static bool	80	static bool
142	nfsd_match_cred(const struct cred c1, const struct cred c2)	81	nfsd_match_cred(const struct cred c1, const struct cred c2)
143	{	82	{
@@ -158,53 +97,16 @@ nfsd_match_cred(const struct cred c1, const struct cred c2) · 14 unmodified lines
158	return true;	97	return true;
159	}	98	}
160		99
161	/**
162	* nfsd_file_obj_cmpfn - Match a cache item against search criteria
163	* @arg: search criteria
164	* @ptr: cache item to check
165	*
166	* Return values:
167	* %0 - Item matches search criteria
168	* %1 - Item does not match search criteria
169	*/
170	static int nfsd_file_obj_cmpfn(struct rhashtable_compare_arg *arg,
171	const void *ptr)
172	{
173	const struct nfsd_file_lookup_key *key = arg->key;
174	const struct nfsd_file *nf = ptr;
175
176	switch (key->type) {
177	case NFSD_FILE_KEY_INODE:
178	if (nf->nf_inode != key->inode)
179	return 1;
180	break;
181	case NFSD_FILE_KEY_FULL:
182	if (nf->nf_inode != key->inode)
183	return 1;
184	if (nf->nf_may != key->need)
185	return 1;
186	if (nf->nf_net != key->net)
187	return 1;
188	if (!nfsd_match_cred(nf->nf_cred, key->cred))
189	return 1;
190	if (!!test_bit(NFSD_FILE_GC, &nf->nf_flags) != key->gc)
191	return 1;
192	if (test_bit(NFSD_FILE_HASHED, &nf->nf_flags) == 0)
193	return 1;
194	break;
195	}
196	return 0;
197	}
198
199	static const struct rhashtable_params nfsd_file_rhash_params = {	100	static const struct rhashtable_params nfsd_file_rhash_params = {
200	.key_len = sizeof_field(struct nfsd_file, nf_inode),	101	.key_len = sizeof_field(struct nfsd_file, nf_inode),
201	.key_offset = offsetof(struct nfsd_file, nf_inode),	102	.key_offset = offsetof(struct nfsd_file, nf_inode),
202	.head_offset = offsetof(struct nfsd_file, nf_rhash),	103	.head_offset = offsetof(struct nfsd_file, nf_rlist),
203	.hashfn = nfsd_file_key_hashfn,	104
204	.obj_hashfn = nfsd_file_obj_hashfn,	105	/*
205	.obj_cmpfn = nfsd_file_obj_cmpfn,	106	* Start with a single page hash table to reduce resizing churn
206	/* Reduce resizing churn on light workloads */	107	* on light workloads.
207	.min_size = 512, /* buckets */	108	*/
		109	.min_size = 256,
208	.automatic_shrinking = true,	110	.automatic_shrinking = true,
209	};	111	};
210		112
@@ -307,27 +209,27 @@ nfsd_file_mark_find_or_create(struct nfsd_file nf, struct inode inode) · 96 unmodified lines
307	}	209	}
308		210
309	static struct nfsd_file *	211	static struct nfsd_file *
310	nfsd_file_alloc(struct nfsd_file_lookup_key *key, unsigned int may)	212	nfsd_file_alloc(struct net net, struct inode inode, unsigned char need,
		213	bool want_gc)
311	{	214	{
312	struct nfsd_file *nf;	215	struct nfsd_file *nf;
313		216
314	nf = kmem_cache_alloc(nfsd_file_slab, GFP_KERNEL);	217	nf = kmem_cache_alloc(nfsd_file_slab, GFP_KERNEL);
315	if (nf) {	218	if (unlikely(!nf))
316	INIT_LIST_HEAD(&nf->nf_lru);	219	return NULL;
317	nf->nf_birthtime = ktime_get();	220
318	nf->nf_file = NULL;	221	INIT_LIST_HEAD(&nf->nf_lru);
319	nf->nf_cred = get_current_cred();	222	nf->nf_birthtime = ktime_get();
320	nf->nf_net = key->net;	223	nf->nf_file = NULL;
321	nf->nf_flags = 0;	224	nf->nf_cred = get_current_cred();
322	__set_bit(NFSD_FILE_HASHED, &nf->nf_flags);	225	nf->nf_net = net;
323	__set_bit(NFSD_FILE_PENDING, &nf->nf_flags);	226	nf->nf_flags = want_gc ?
324	if (key->gc)	227	BIT(NFSD_FILE_HASHED) \| BIT(NFSD_FILE_PENDING) \| BIT(NFSD_FILE_GC) :
325	__set_bit(NFSD_FILE_GC, &nf->nf_flags);	228	BIT(NFSD_FILE_HASHED) \| BIT(NFSD_FILE_PENDING);
326	nf->nf_inode = key->inode;	229	nf->nf_inode = inode;
327	refcount_set(&nf->nf_ref, 1);	230	refcount_set(&nf->nf_ref, 1);
328	nf->nf_may = key->need;	231	nf->nf_may = need;
329	nf->nf_mark = NULL;	232	nf->nf_mark = NULL;
330	}
331	return nf;	233	return nf;
332	}	234	}
333		235
@@ -352,8 +254,8 @@ static void · 18 unmodified lines
352	nfsd_file_hash_remove(struct nfsd_file *nf)	254	nfsd_file_hash_remove(struct nfsd_file *nf)
353	{	255	{
354	trace_nfsd_file_unhash(nf);	256	trace_nfsd_file_unhash(nf);
355	rhashtable_remove_fast(&nfsd_file_rhash_tbl, &nf->nf_rhash,	257	rhltable_remove(&nfsd_file_rhltable, &nf->nf_rlist,
356	nfsd_file_rhash_params);	258	nfsd_file_rhash_params);
357	}	259	}
358		260
359	static bool	261	static bool
@@ -380,10 +282,8 @@ nfsd_file_free(struct nfsd_file *nf) · 20 unmodified lines
380	if (nf->nf_mark)	282	if (nf->nf_mark)
381	nfsd_file_mark_put(nf->nf_mark);	283	nfsd_file_mark_put(nf->nf_mark);
382	if (nf->nf_file) {	284	if (nf->nf_file) {
383	get_file(nf->nf_file);
384	filp_close(nf->nf_file, NULL);
385	nfsd_file_check_write_error(nf);	285	nfsd_file_check_write_error(nf);
386	fput(nf->nf_file);	286	filp_close(nf->nf_file, NULL);
387	}	287	}
388		288
389	/*	289	/*
@@ -402,13 +302,23 @@ nfsd_file_check_writeback(struct nfsd_file *nf) · 12 unmodified lines
402	struct file *file = nf->nf_file;	302	struct file *file = nf->nf_file;
403	struct address_space *mapping;	303	struct address_space *mapping;
404		304
405	if (!file \|\| !(file->f_mode & FMODE_WRITE))	305	/* File not open for write? */
		306	if (!(file->f_mode & FMODE_WRITE))
		307	return false;
		308
		309	/*
		310	* Some filesystems (e.g. NFS) flush all dirty data on close.
		311	* On others, there is no need to wait for writeback.
		312	*/
		313	if (!(file_inode(file)->i_sb->s_export_op->flags & EXPORT_OP_FLUSH_ON_CLOSE))
406	return false;	314	return false;
		315
407	mapping = file->f_mapping;	316	mapping = file->f_mapping;
408	return mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) \|\|	317	return mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) \|\|
409	mapping_tagged(mapping, PAGECACHE_TAG_WRITEBACK);	318	mapping_tagged(mapping, PAGECACHE_TAG_WRITEBACK);
410	}	319	}
411		320
		321
412	static bool nfsd_file_lru_add(struct nfsd_file *nf)	322	static bool nfsd_file_lru_add(struct nfsd_file *nf)
413	{	323	{
414	set_bit(NFSD_FILE_REFERENCED, &nf->nf_flags);	324	set_bit(NFSD_FILE_REFERENCED, &nf->nf_flags);
@@ -492,49 +402,26 @@ nfsd_file_dispose_list(struct list_head *dispose) · 77 unmodified lines
492	}	402	}
493	}	403	}
494		404
495	static void	405	/**
496	nfsd_file_list_remove_disposal(struct list_head *dst,	406	* nfsd_file_dispose_list_delayed - move list of dead files to net's freeme list
497	struct nfsd_fcache_disposal *l)	407	* @dispose: list of nfsd_files to be disposed
498	{	408	*
499	spin_lock(&l->lock);	409	* Transfers each file to the "freeme" list for its nfsd_net, to eventually
500	list_splice_init(&l->freeme, dst);	410	* be disposed of by the per-net garbage collector.
501	spin_unlock(&l->lock);	411	*/
502	}
503
504	static void
505	nfsd_file_list_add_disposal(struct list_head files, struct net net)
506	{
507	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
508	struct nfsd_fcache_disposal *l = nn->fcache_disposal;
509
510	spin_lock(&l->lock);
511	list_splice_tail_init(files, &l->freeme);
512	spin_unlock(&l->lock);
513	queue_work(nfsd_filecache_wq, &l->work);
514	}
515
516	static void
517	nfsd_file_list_add_pernet(struct list_head dst, struct list_head src,
518	struct net *net)
519	{
520	struct nfsd_file nf, tmp;
521
522	list_for_each_entry_safe(nf, tmp, src, nf_lru) {
523	if (nf->nf_net == net)
524	list_move_tail(&nf->nf_lru, dst);
525	}
526	}
527
528	static void	412	static void
529	nfsd_file_dispose_list_delayed(struct list_head *dispose)	413	nfsd_file_dispose_list_delayed(struct list_head *dispose)
530	{	414	{
531	LIST_HEAD(list);
532	struct nfsd_file *nf;
533
534	while(!list_empty(dispose)) {	415	while(!list_empty(dispose)) {
535	nf = list_first_entry(dispose, struct nfsd_file, nf_lru);	416	struct nfsd_file *nf = list_first_entry(dispose,
536	nfsd_file_list_add_pernet(&list, dispose, nf->nf_net);	417	struct nfsd_file, nf_lru);
537	nfsd_file_list_add_disposal(&list, nf->nf_net);	418	struct nfsd_net *nn = net_generic(nf->nf_net, nfsd_net_id);
		419	struct nfsd_fcache_disposal *l = nn->fcache_disposal;
		420
		421	spin_lock(&l->lock);
		422	list_move_tail(&nf->nf_lru, &l->freeme);
		423	spin_unlock(&l->lock);
		424	queue_work(nfsd_filecache_wq, &l->work);
538	}	425	}
539	}	426	}
540		427
@@ -678,8 +565,8 @@ nfsd_file_cond_queue(struct nfsd_file nf, struct list_head dispose) · 137 unmodified lines
678	* @inode: inode on which to close out nfsd_files	565	* @inode: inode on which to close out nfsd_files
679	* @dispose: list on which to gather nfsd_files to close out	566	* @dispose: list on which to gather nfsd_files to close out
680	*	567	*
681	* An nfsd_file represents a struct file being held open on behalf of nfsd. An	568	* An nfsd_file represents a struct file being held open on behalf of nfsd.
682	* open file however can block other activity (such as leases), or cause	569	* An open file however can block other activity (such as leases), or cause
683	* undesirable behavior (e.g. spurious silly-renames when reexporting NFS).	570	* undesirable behavior (e.g. spurious silly-renames when reexporting NFS).
684	*	571	*
685	* This function is intended to find open nfsd_files when this sort of	572	* This function is intended to find open nfsd_files when this sort of
@@ -692,20 +579,17 @@ nfsd_file_cond_queue(struct nfsd_file nf, struct list_head dispose) · 6 unmodified lines
692	static void	579	static void
693	nfsd_file_queue_for_close(struct inode inode, struct list_head dispose)	580	nfsd_file_queue_for_close(struct inode inode, struct list_head dispose)
694	{	581	{
695	struct nfsd_file_lookup_key key = {	582	struct rhlist_head tmp, list;
696	.type = NFSD_FILE_KEY_INODE,
697	.inode = inode,
698	};
699	struct nfsd_file *nf;	583	struct nfsd_file *nf;
700		584
701	rcu_read_lock();	585	rcu_read_lock();
702	do {	586	list = rhltable_lookup(&nfsd_file_rhltable, &inode,
703	nf = rhashtable_lookup(&nfsd_file_rhash_tbl, &key,	587	nfsd_file_rhash_params);
704	nfsd_file_rhash_params);	588	rhl_for_each_entry_rcu(nf, tmp, list, nf_rlist) {
705	if (!nf)	589	if (!test_bit(NFSD_FILE_GC, &nf->nf_flags))
706	break;	590	continue;
707	nfsd_file_cond_queue(nf, dispose);	591	nfsd_file_cond_queue(nf, dispose);
708	} while (1);	592	}
709	rcu_read_unlock();	593	rcu_read_unlock();
710	}	594	}
711		595
@@ -758,8 +642,8 @@ nfsd_file_close_inode_sync(struct inode *inode) · 46 unmodified lines
758	* nfsd_file_delayed_close - close unused nfsd_files	642	* nfsd_file_delayed_close - close unused nfsd_files
759	* @work: dummy	643	* @work: dummy
760	*	644	*
761	* Walk the LRU list and destroy any entries that have not been used since	645	* Scrape the freeme list for this nfsd_net, and then dispose of them
762	* the last scan.	646	* all.
763	*/	647	*/
764	static void	648	static void
765	nfsd_file_delayed_close(struct work_struct *work)	649	nfsd_file_delayed_close(struct work_struct *work)
@@ -768,7 +652,10 @@ nfsd_file_delayed_close(struct work_struct *work) · 2 unmodified lines
768	struct nfsd_fcache_disposal *l = container_of(work,	652	struct nfsd_fcache_disposal *l = container_of(work,
769	struct nfsd_fcache_disposal, work);	653	struct nfsd_fcache_disposal, work);
770		654
771	nfsd_file_list_remove_disposal(&head, l);	655	spin_lock(&l->lock);
		656	list_splice_init(&l->freeme, &head);
		657	spin_unlock(&l->lock);
		658
772	nfsd_file_dispose_list(&head);	659	nfsd_file_dispose_list(&head);
773	}	660	}
774		661
@@ -829,7 +716,7 @@ nfsd_file_cache_init(void) · 54 unmodified lines
829	if (test_and_set_bit(NFSD_FILE_CACHE_UP, &nfsd_file_flags) == 1)	716	if (test_and_set_bit(NFSD_FILE_CACHE_UP, &nfsd_file_flags) == 1)
830	return 0;	717	return 0;
831		718
832	ret = rhashtable_init(&nfsd_file_rhash_tbl, &nfsd_file_rhash_params);	719	ret = rhltable_init(&nfsd_file_rhltable, &nfsd_file_rhash_params);
833	if (ret)	720	if (ret)
834	return ret;	721	return ret;
835		722
@@ -897,7 +784,7 @@ out_err: · 61 unmodified lines
897	nfsd_file_mark_slab = NULL;	784	nfsd_file_mark_slab = NULL;
898	destroy_workqueue(nfsd_filecache_wq);	785	destroy_workqueue(nfsd_filecache_wq);
899	nfsd_filecache_wq = NULL;	786	nfsd_filecache_wq = NULL;
900	rhashtable_destroy(&nfsd_file_rhash_tbl);	787	rhltable_destroy(&nfsd_file_rhltable);
901	goto out;	788	goto out;
902	}	789	}
903		790
@@ -906,7 +793,8 @@ out_err: · 2 unmodified lines
906	* @net: net-namespace to shut down the cache (may be NULL)	793	* @net: net-namespace to shut down the cache (may be NULL)
907	*	794	*
908	* Walk the nfsd_file cache and close out any that match @net. If @net is NULL,	795	* Walk the nfsd_file cache and close out any that match @net. If @net is NULL,
909	* then close out everything. Called when an nfsd instance is being shut down.	796	* then close out everything. Called when an nfsd instance is being shut down,
		797	* and when the exports table is flushed.
910	*/	798	*/
911	static void	799	static void
912	__nfsd_file_cache_purge(struct net *net)	800	__nfsd_file_cache_purge(struct net *net)
@@ -915,7 +803,7 @@ __nfsd_file_cache_purge(struct net *net) · 2 unmodified lines
915	struct nfsd_file *nf;	803	struct nfsd_file *nf;
916	LIST_HEAD(dispose);	804	LIST_HEAD(dispose);
917		805
918	rhashtable_walk_enter(&nfsd_file_rhash_tbl, &iter);	806	rhltable_walk_enter(&nfsd_file_rhltable, &iter);
919	do {	807	do {
920	rhashtable_walk_start(&iter);	808	rhashtable_walk_start(&iter);
921		809
@@ -1021,7 +909,7 @@ nfsd_file_cache_shutdown(void) · 99 unmodified lines
1021	nfsd_file_mark_slab = NULL;	909	nfsd_file_mark_slab = NULL;
1022	destroy_workqueue(nfsd_filecache_wq);	910	destroy_workqueue(nfsd_filecache_wq);
1023	nfsd_filecache_wq = NULL;	911	nfsd_filecache_wq = NULL;
1024	rhashtable_destroy(&nfsd_file_rhash_tbl);	912	rhltable_destroy(&nfsd_file_rhltable);
1025		913
1026	for_each_possible_cpu(i) {	914	for_each_possible_cpu(i) {
1027	per_cpu(nfsd_file_cache_hits, i) = 0;	915	per_cpu(nfsd_file_cache_hits, i) = 0;
@@ -1032,6 +920,35 @@ nfsd_file_cache_shutdown(void) · 4 unmodified lines
1032	}	920	}
1033	}	921	}
1034		922
		923	static struct nfsd_file *
		924	nfsd_file_lookup_locked(const struct net net, const struct cred cred,
		925	struct inode *inode, unsigned char need,
		926	bool want_gc)
		927	{
		928	struct rhlist_head tmp, list;
		929	struct nfsd_file *nf;
		930
		931	list = rhltable_lookup(&nfsd_file_rhltable, &inode,
		932	nfsd_file_rhash_params);
		933	rhl_for_each_entry_rcu(nf, tmp, list, nf_rlist) {
		934	if (nf->nf_may != need)
		935	continue;
		936	if (nf->nf_net != net)
		937	continue;
		938	if (!nfsd_match_cred(nf->nf_cred, cred))
		939	continue;
		940	if (test_bit(NFSD_FILE_GC, &nf->nf_flags) != want_gc)
		941	continue;
		942	if (test_bit(NFSD_FILE_HASHED, &nf->nf_flags) == 0)
		943	continue;
		944
		945	if (!nfsd_file_get(nf))
		946	continue;
		947	return nf;
		948	}
		949	return NULL;
		950	}
		951
1035	/**	952	/**
1036	* nfsd_file_is_cached - are there any cached open files for this inode?	953	* nfsd_file_is_cached - are there any cached open files for this inode?
1037	* @inode: inode to check	954	* @inode: inode to check
@@ -1046,15 +963,20 @@ nfsd_file_cache_shutdown(void) · 8 unmodified lines
1046	bool	963	bool
1047	nfsd_file_is_cached(struct inode *inode)	964	nfsd_file_is_cached(struct inode *inode)
1048	{	965	{
1049	struct nfsd_file_lookup_key key = {	966	struct rhlist_head tmp, list;
1050	.type = NFSD_FILE_KEY_INODE,	967	struct nfsd_file *nf;
1051	.inode = inode,
1052	};
1053	bool ret = false;	968	bool ret = false;
1054		969
1055	if (rhashtable_lookup_fast(&nfsd_file_rhash_tbl, &key,	970	rcu_read_lock();
1056	nfsd_file_rhash_params) != NULL)	971	list = rhltable_lookup(&nfsd_file_rhltable, &inode,
1057	ret = true;	972	nfsd_file_rhash_params);
		973	rhl_for_each_entry_rcu(nf, tmp, list, nf_rlist)
		974	if (test_bit(NFSD_FILE_GC, &nf->nf_flags)) {
		975	ret = true;
		976	break;
		977	}
		978	rcu_read_unlock();
		979
1058	trace_nfsd_file_is_cached(inode, (int)ret);	980	trace_nfsd_file_is_cached(inode, (int)ret);
1059	return ret;	981	return ret;
1060	}	982	}
@@ -1064,14 +986,12 @@ nfsd_file_do_acquire(struct svc_rqst rqstp, struct svc_fh fhp, · 3 unmodified lines
1064	unsigned int may_flags, struct file *file,	986	unsigned int may_flags, struct file *file,
1065	struct nfsd_file **pnf, bool want_gc)	987	struct nfsd_file **pnf, bool want_gc)
1066	{	988	{
1067	struct nfsd_file_lookup_key key = {	989	unsigned char need = may_flags & NFSD_FILE_MAY_MASK;
1068	.type = NFSD_FILE_KEY_FULL,	990	struct net *net = SVC_NET(rqstp);
1069	.need = may_flags & NFSD_FILE_MAY_MASK,	991	struct nfsd_file new, nf;
1070	.net = SVC_NET(rqstp),	992	const struct cred *cred;
1071	.gc = want_gc,
1072	};
1073	bool open_retry = true;	993	bool open_retry = true;
1074	struct nfsd_file *nf;	994	struct inode *inode;
1075	__be32 status;	995	__be32 status;
1076	int ret;	996	int ret;
1077		997
@@ -1079,80 +999,88 @@ nfsd_file_do_acquire(struct svc_rqst rqstp, struct svc_fh fhp, · 1 unmodified line
1079	may_flags\|NFSD_MAY_OWNER_OVERRIDE);	999	may_flags\|NFSD_MAY_OWNER_OVERRIDE);
1080	if (status != nfs_ok)	1000	if (status != nfs_ok)
1081	return status;	1001	return status;
1082	key.inode = d_inode(fhp->fh_dentry);	1002	inode = d_inode(fhp->fh_dentry);
1083	key.cred = get_current_cred();	1003	cred = get_current_cred();
1084		1004
1085	retry:	1005	retry:
1086	rcu_read_lock();	1006	rcu_read_lock();
1087	nf = rhashtable_lookup(&nfsd_file_rhash_tbl, &key,	1007	nf = nfsd_file_lookup_locked(net, cred, inode, need, want_gc);
1088	nfsd_file_rhash_params);
1089	nf = nfsd_file_get(nf);
1090	rcu_read_unlock();	1008	rcu_read_unlock();
1091		1009
1092	if (nf) {	1010	if (nf) {
		1011	/*
		1012	* If the nf is on the LRU then it holds an extra reference
		1013	* that must be put if it's removed. It had better not be
		1014	* the last one however, since we should hold another.
		1015	*/
1093	if (nfsd_file_lru_remove(nf))	1016	if (nfsd_file_lru_remove(nf))
1094	WARN_ON_ONCE(refcount_dec_and_test(&nf->nf_ref));	1017	WARN_ON_ONCE(refcount_dec_and_test(&nf->nf_ref));
1095	goto wait_for_construction;	1018	goto wait_for_construction;
1096	}	1019	}
1097		1020
1098	nf = nfsd_file_alloc(&key, may_flags);	1021	new = nfsd_file_alloc(net, inode, need, want_gc);
1099	if (!nf) {	1022	if (!new) {
1100	status = nfserr_jukebox;	1023	status = nfserr_jukebox;
1101	goto out_status;	1024	goto out;
1102	}	1025	}
1103		1026
1104	ret = rhashtable_lookup_insert_key(&nfsd_file_rhash_tbl,	1027	rcu_read_lock();
1105	&key, &nf->nf_rhash,	1028	spin_lock(&inode->i_lock);
1106	nfsd_file_rhash_params);	1029	nf = nfsd_file_lookup_locked(net, cred, inode, need, want_gc);
		1030	if (unlikely(nf)) {
		1031	spin_unlock(&inode->i_lock);
		1032	rcu_read_unlock();
		1033	nfsd_file_slab_free(&new->nf_rcu);
		1034	goto wait_for_construction;
		1035	}
		1036	nf = new;
		1037	ret = rhltable_insert(&nfsd_file_rhltable, &nf->nf_rlist,
		1038	nfsd_file_rhash_params);
		1039	spin_unlock(&inode->i_lock);
		1040	rcu_read_unlock();
1107	if (likely(ret == 0))	1041	if (likely(ret == 0))
1108	goto open_file;	1042	goto open_file;
1109		1043
1110	nfsd_file_slab_free(&nf->nf_rcu);
1111	nf = NULL;
1112	if (ret == -EEXIST)	1044	if (ret == -EEXIST)
1113	goto retry;	1045	goto retry;
1114	trace_nfsd_file_insert_err(rqstp, key.inode, may_flags, ret);	1046	trace_nfsd_file_insert_err(rqstp, inode, may_flags, ret);
1115	status = nfserr_jukebox;	1047	status = nfserr_jukebox;
1116	goto out_status;	1048	goto construction_err;
1117		1049
1118	wait_for_construction:	1050	wait_for_construction:
1119	wait_on_bit(&nf->nf_flags, NFSD_FILE_PENDING, TASK_UNINTERRUPTIBLE);	1051	wait_on_bit(&nf->nf_flags, NFSD_FILE_PENDING, TASK_UNINTERRUPTIBLE);
1120		1052
1121	/* Did construction of this file fail? */	1053	/* Did construction of this file fail? */
1122	if (!test_bit(NFSD_FILE_HASHED, &nf->nf_flags)) {	1054	if (!test_bit(NFSD_FILE_HASHED, &nf->nf_flags)) {
1123	trace_nfsd_file_cons_err(rqstp, key.inode, may_flags, nf);	1055	trace_nfsd_file_cons_err(rqstp, inode, may_flags, nf);
1124	if (!open_retry) {	1056	if (!open_retry) {
1125	status = nfserr_jukebox;	1057	status = nfserr_jukebox;
1126	goto out;	1058	goto construction_err;
1127	}	1059	}
1128	open_retry = false;	1060	open_retry = false;
1129	if (refcount_dec_and_test(&nf->nf_ref))
1130	nfsd_file_free(nf);
1131	goto retry;	1061	goto retry;
1132	}	1062	}
1133
1134	this_cpu_inc(nfsd_file_cache_hits);	1063	this_cpu_inc(nfsd_file_cache_hits);
1135		1064
1136	status = nfserrno(nfsd_open_break_lease(file_inode(nf->nf_file), may_flags));	1065	status = nfserrno(nfsd_open_break_lease(file_inode(nf->nf_file), may_flags));
		1066	if (status != nfs_ok) {
		1067	nfsd_file_put(nf);
		1068	nf = NULL;
		1069	}
		1070
1137	out:	1071	out:
1138	if (status == nfs_ok) {	1072	if (status == nfs_ok) {
1139	this_cpu_inc(nfsd_file_acquisitions);	1073	this_cpu_inc(nfsd_file_acquisitions);
1140	nfsd_file_check_write_error(nf);	1074	nfsd_file_check_write_error(nf);
1141	*pnf = nf;	1075	*pnf = nf;
1142	} else {
1143	if (refcount_dec_and_test(&nf->nf_ref))
1144	nfsd_file_free(nf);
1145	nf = NULL;
1146	}	1076	}
1147		1077	put_cred(cred);
1148	out_status:	1078	trace_nfsd_file_acquire(rqstp, inode, may_flags, nf, status);
1149	put_cred(key.cred);
1150	trace_nfsd_file_acquire(rqstp, key.inode, may_flags, nf, status);
1151	return status;	1079	return status;
1152		1080
1153	open_file:	1081	open_file:
1154	trace_nfsd_file_alloc(nf);	1082	trace_nfsd_file_alloc(nf);
1155	nf->nf_mark = nfsd_file_mark_find_or_create(nf, key.inode);	1083	nf->nf_mark = nfsd_file_mark_find_or_create(nf, inode);
1156	if (nf->nf_mark) {	1084	if (nf->nf_mark) {
1157	if (file) {	1085	if (file) {
1158	get_file(file);	1086	get_file(file);
@@ -1170,13 +1098,16 @@ open_file: · 11 unmodified lines
1170	* If construction failed, or we raced with a call to unlink()	1098	* If construction failed, or we raced with a call to unlink()
1171	* then unhash.	1099	* then unhash.
1172	*/	1100	*/
1173	if (status == nfs_ok && key.inode->i_nlink == 0)	1101	if (status != nfs_ok \|\| inode->i_nlink == 0)
1174	status = nfserr_jukebox;
1175	if (status != nfs_ok)
1176	nfsd_file_unhash(nf);	1102	nfsd_file_unhash(nf);
1177	clear_bit_unlock(NFSD_FILE_PENDING, &nf->nf_flags);	1103	clear_and_wake_up_bit(NFSD_FILE_PENDING, &nf->nf_flags);
1178	smp_mb__after_atomic();	1104	if (status == nfs_ok)
1179	wake_up_bit(&nf->nf_flags, NFSD_FILE_PENDING);	1105	goto out;
		1106
		1107	construction_err:
		1108	if (refcount_dec_and_test(&nf->nf_ref))
		1109	nfsd_file_free(nf);
		1110	nf = NULL;
1180	goto out;	1111	goto out;
1181	}	1112	}
1182		1113
@@ -1192,8 +1123,11 @@ open_file: · 9 unmodified lines
1192	* seconds after the final nfsd_file_put() in case the caller	1123	* seconds after the final nfsd_file_put() in case the caller
1193	* wants to re-use it.	1124	* wants to re-use it.
1194	*	1125	*
1195	* Returns nfs_ok and sets @pnf on success; otherwise an nfsstat in	1126	* Return values:
1196	* network byte order is returned.	1127	* %nfs_ok - @pnf points to an nfsd_file with its reference
		1128	* count boosted.
		1129	*
		1130	* On error, an nfsstat value in network byte order is returned.
1197	*/	1131	*/
1198	__be32	1132	__be32
1199	nfsd_file_acquire_gc(struct svc_rqst rqstp, struct svc_fh fhp,	1133	nfsd_file_acquire_gc(struct svc_rqst rqstp, struct svc_fh fhp,
@@ -1213,8 +1147,11 @@ nfsd_file_acquire_gc(struct svc_rqst rqstp, struct svc_fh fhp, · 13 unmodified lines
1213	* but not garbage-collected. The object is unhashed after the	1147	* but not garbage-collected. The object is unhashed after the
1214	* final nfsd_file_put().	1148	* final nfsd_file_put().
1215	*	1149	*
1216	* Returns nfs_ok and sets @pnf on success; otherwise an nfsstat in	1150	* Return values:
1217	* network byte order is returned.	1151	* %nfs_ok - @pnf points to an nfsd_file with its reference
		1152	* count boosted.
		1153	*
		1154	* On error, an nfsstat value in network byte order is returned.
1218	*/	1155	*/
1219	__be32	1156	__be32
1220	nfsd_file_acquire(struct svc_rqst rqstp, struct svc_fh fhp,	1157	nfsd_file_acquire(struct svc_rqst rqstp, struct svc_fh fhp,
@@ -1235,8 +1172,11 @@ nfsd_file_acquire(struct svc_rqst rqstp, struct svc_fh fhp, · 14 unmodified lines
1235	* and @file is non-NULL, use it to instantiate a new nfsd_file instead of	1172	* and @file is non-NULL, use it to instantiate a new nfsd_file instead of
1236	* opening a new one.	1173	* opening a new one.
1237	*	1174	*
1238	* Returns nfs_ok and sets @pnf on success; otherwise an nfsstat in	1175	* Return values:
1239	* network byte order is returned.	1176	* %nfs_ok - @pnf points to an nfsd_file with its reference
		1177	* count boosted.
		1178	*
		1179	* On error, an nfsstat value in network byte order is returned.
1240	*/	1180	*/
1241	__be32	1181	__be32
1242	nfsd_file_acquire_opened(struct svc_rqst rqstp, struct svc_fh fhp,	1182	nfsd_file_acquire_opened(struct svc_rqst rqstp, struct svc_fh fhp,
@@ -1267,7 +1207,7 @@ int nfsd_file_cache_stats_show(struct seq_file m, void v) · 24 unmodified lines
1267	lru = list_lru_count(&nfsd_file_lru);	1207	lru = list_lru_count(&nfsd_file_lru);
1268		1208
1269	rcu_read_lock();	1209	rcu_read_lock();
1270	ht = &nfsd_file_rhash_tbl;	1210	ht = &nfsd_file_rhltable.ht;
1271	count = atomic_read(&ht->nelems);	1211	count = atomic_read(&ht->nelems);
1272	tbl = rht_dereference_rcu(ht->tbl, ht);	1212	tbl = rht_dereference_rcu(ht->tbl, ht);
1273	buckets = tbl->size;	1213	buckets = tbl->size;
@@ -1283,7 +1223,7 @@ int nfsd_file_cache_stats_show(struct seq_file m, void v) · 9 unmodified lines
1283	evictions += per_cpu(nfsd_file_evictions, i);	1223	evictions += per_cpu(nfsd_file_evictions, i);
1284	}	1224	}
1285		1225
1286	seq_printf(m, "total entries: %u\n", count);	1226	seq_printf(m, "total inodes: %u\n", count);
1287	seq_printf(m, "hash buckets: %u\n", buckets);	1227	seq_printf(m, "hash buckets: %u\n", buckets);
1288	seq_printf(m, "lru entries: %lu\n", lru);	1228	seq_printf(m, "lru entries: %lu\n", lru);
1289	seq_printf(m, "cache hits: %lu\n", hits);	1229	seq_printf(m, "cache hits: %lu\n", hits);

fs/nfsd/filecache.h+5−4

  * never be dereferenced, only used for comparison.
  */
 struct nfsd_file {
-	struct rhash_head	nf_rhash;
+	struct rhlist_head	nf_rlist;
-	struct list_head	nf_lru;
+	void			*nf_inode;
-	struct rcu_head		nf_rcu;
 	struct file		*nf_file;
 	const struct cred	*nf_cred;
 	struct net		*nf_net;
 #define NFSD_FILE_REFERENCED	(2)
 #define NFSD_FILE_GC		(3)
 	unsigned long		nf_flags;
-	struct inode		*nf_inode;	/* don't deref */
 	refcount_t		nf_ref;
 	unsigned char		nf_may;
 	struct nfsd_file_mark	*nf_mark;
+	struct list_head	nf_lru;
+	struct rcu_head		nf_rcu;
 	ktime_t			nf_birthtime;
 };

fs/nfsd/nfs4idmap.c+4−4

@@ -240,8 +240,8 @@ idtoname_parse(struct cache_detail cd, char buf, int buflen) · 239 unmodified lines
240	goto out;	240	goto out;
241		241
242	/* expiry */	242	/* expiry */
243	ent.h.expiry_time = get_expiry(&buf);	243	error = get_expiry(&buf, &ent.h.expiry_time);
244	if (ent.h.expiry_time == 0)	244	if (error)
245	goto out;	245	goto out;
246		246
247	error = -ENOMEM;	247	error = -ENOMEM;
@@ -408,8 +408,8 @@ nametoid_parse(struct cache_detail cd, char buf, int buflen) · 160 unmodified lines
408	memcpy(ent.name, buf1, sizeof(ent.name));	408	memcpy(ent.name, buf1, sizeof(ent.name));
409		409
410	/* expiry */	410	/* expiry */
411	ent.h.expiry_time = get_expiry(&buf);	411	error = get_expiry(&buf, &ent.h.expiry_time);
412	if (ent.h.expiry_time == 0)	412	if (error)
413	goto out;	413	goto out;
414		414
415	/* ID */	415	/* ID */

fs/nfsd/vfs.c+7−6

  * Grab and keep cached pages associated with a file in the svc_rqst
  * so that they can be passed to the network sendmsg/sendpage routines
  * directly. They will be released after the sending has completed.
+ *
+ * Return values: Number of bytes consumed, or -EIO if there are no
+ * remaining pages in rqstp->rq_pages.
  */
 static int
 nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
 		 */
 		if (page == *(rqstp->rq_next_page - 1))
 			continue;
-		svc_rqst_replace_page(rqstp, page);
+		if (unlikely(!svc_rqst_replace_page(rqstp, page)))
+			return -EIO;
 	}
 	if (rqstp->rq_res.page_len == 0)	// first call
 		rqstp->rq_res.page_base = offset % PAGE_SIZE;
 		goto out;
 	}
-	buf = kvmalloc(len, GFP_KERNEL | GFP_NOFS);
+	buf = kvmalloc(len, GFP_KERNEL);
 	if (buf == NULL) {
 		err = nfserr_jukebox;
 		goto out;
 		goto out;
 	}
-	/*
+	buf = kvmalloc(len, GFP_KERNEL);
-	 * We're holding i_rwsem - use GFP_NOFS.
-	 */
-	buf = kvmalloc(len, GFP_KERNEL | GFP_NOFS);
 	if (buf == NULL) {
 		err = nfserr_jukebox;
 		goto out;

include/linux/exportfs.h+1−0

@@ -220,6 +220,7 @@ struct export_operations { · 219 unmodified lines
220	#define EXPORT_OP_NOATOMIC_ATTR (0x10) /* Filesystem cannot supply	220	#define EXPORT_OP_NOATOMIC_ATTR (0x10) /* Filesystem cannot supply
221	atomic attribute updates	221	atomic attribute updates
222	*/	222	*/
		223	#define EXPORT_OP_FLUSH_ON_CLOSE (0x20) /* fs flushes file data on close */
223	unsigned long flags;	224	unsigned long flags;
224	};	225	};
225		226

include/linux/lockd/lockd.h+15−14

 /*
  * Rigorous type checking on sockaddr type conversions
  */
-static inline struct sockaddr_in *nlm_addr_in(const struct nlm_host *host)
-{
-	return (struct sockaddr_in *)&host->h_addr;
-}
 static inline struct sockaddr *nlm_addr(const struct nlm_host *host)
 {
 	return (struct sockaddr *)&host->h_addr;
 }
-static inline struct sockaddr_in *nlm_srcaddr_in(const struct nlm_host *host)
-{
-	return (struct sockaddr_in *)&host->h_srcaddr;
-}
 static inline struct sockaddr *nlm_srcaddr(const struct nlm_host *host)
 {
 	return (struct sockaddr *)&host->h_srcaddr;
 	uint32_t pid;
 };
-struct nlm_wait;
+/*
+ * This is the representation of a blocked client lock.
+ */
+struct nlm_wait {
+	struct list_head	b_list;		/* linked list */
+	wait_queue_head_t	b_wait;		/* where to wait on */
+	struct nlm_host		*b_host;
+	struct file_lock	*b_lock;	/* local file lock */
+	__be32			b_status;	/* grant callback status */
+};
 /*
  * Memory chunk for NLM client RPC request.
 int		  nlm_async_call(struct nlm_rqst *, u32, const struct rpc_call_ops *);
 int		  nlm_async_reply(struct nlm_rqst *, u32, const struct rpc_call_ops *);
 void		  nlmclnt_release_call(struct nlm_rqst *);
-struct nlm_wait * nlmclnt_prepare_block(struct nlm_host *host, struct file_lock *fl);
+void		  nlmclnt_prepare_block(struct nlm_wait *block, struct nlm_host *host,
-void		  nlmclnt_finish_block(struct nlm_wait *block);
+					struct file_lock *fl);
-int		  nlmclnt_block(struct nlm_wait *block, struct nlm_rqst *req, long timeout);
+void		  nlmclnt_queue_block(struct nlm_wait *block);
+__be32		  nlmclnt_dequeue_block(struct nlm_wait *block);
+int		  nlmclnt_wait(struct nlm_wait *block, struct nlm_rqst *req, long timeout);
 __be32		  nlmclnt_grant(const struct sockaddr *addr,
 				const struct nlm_lock *lock);
 void		  nlmclnt_recovery(struct nlm_host *);

include/linux/nfs.h+20−0

@@ -10,6 +10,7 @@ · 9 unmodified lines
10		10
11	#include <linux/sunrpc/msg_prot.h>	11	#include <linux/sunrpc/msg_prot.h>
12	#include <linux/string.h>	12	#include <linux/string.h>
		13	#include <linux/crc32.h>
13	#include <uapi/linux/nfs.h>	14	#include <uapi/linux/nfs.h>
14		15
15	/*	16	/*
@@ -44,4 +45,23 @@ enum nfs3_stable_how { · 28 unmodified lines
44	/* used by direct.c to mark verf as invalid */	45	/* used by direct.c to mark verf as invalid */
45	NFS_INVALID_STABLE_HOW = -1	46	NFS_INVALID_STABLE_HOW = -1
46	};	47	};
		48
		49	#ifdef CONFIG_CRC32
		50	/**
		51	* nfs_fhandle_hash - calculate the crc32 hash for the filehandle
		52	* @fh - pointer to filehandle
		53	*
		54	* returns a crc32 hash for the filehandle that is compatible with
		55	* the one displayed by "wireshark".
		56	*/
		57	static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
		58	{
		59	return ~crc32_le(0xFFFFFFFF, &fh->data[0], fh->size);
		60	}
		61	#else /* CONFIG_CRC32 */
		62	static inline u32 nfs_fhandle_hash(const struct nfs_fh *fh)
		63	{
		64	return 0;
		65	}
		66	#endif /* CONFIG_CRC32 */
47	#endif /* _LINUX_NFS_H */	67	#endif /* _LINUX_NFS_H */

include/linux/sunrpc/cache.h+8−7

@@ -300,17 +300,18 @@ static inline int get_time(char *bpp, time64_t time) · 299 unmodified lines
300	return 0;	300	return 0;
301	}	301	}
302		302
303	static inline time64_t get_expiry(char **bpp)	303	static inline int get_expiry(char *bpp, time64_t rvp)
304	{	304	{
305	time64_t rv;	305	int error;
306	struct timespec64 boot;	306	struct timespec64 boot;
307		307
308	if (get_time(bpp, &rv))	308	error = get_time(bpp, rvp);
309	return 0;	309	if (error)
310	if (rv < 0)	310	return error;
311	return 0;	311
312	getboottime64(&boot);	312	getboottime64(&boot);
313	return rv - boot.tv_sec;	313	(*rvp) -= boot.tv_sec;
		314	return 0;
314	}	315	}
315		316
316	#endif /* _LINUX_SUNRPC_CACHE_H_ */	317	#endif /* _LINUX_SUNRPC_CACHE_H_ */

include/linux/sunrpc/svc.h+3−13

 	return (struct sockaddr *) &rqst->rq_daddr;
 }
-static inline void svc_free_res_pages(struct svc_rqst *rqstp)
-{
-	while (rqstp->rq_next_page != rqstp->rq_respages) {
-		struct page **pp = --rqstp->rq_next_page;
-		if (*pp) {
-			put_page(*pp);
-			*pp = NULL;
-		}
-	}
-}
 struct svc_deferred_req {
 	u32			prot;	/* protocol (UDP or TCP) */
 	struct svc_xprt		*xprt;
 			    int (*threadfn)(void *data));
 struct svc_rqst *svc_rqst_alloc(struct svc_serv *serv,
 					struct svc_pool *pool, int node);
-void		   svc_rqst_replace_page(struct svc_rqst *rqstp,
+bool		   svc_rqst_replace_page(struct svc_rqst *rqstp,
 					 struct page *page);
+void		   svc_rqst_release_pages(struct svc_rqst *rqstp);
 void		   svc_rqst_free(struct svc_rqst *);
 void		   svc_exit_thread(struct svc_rqst *);
 struct svc_serv *  svc_create_pooled(struct svc_program *, unsigned int,
 				     int (*threadfn)(void *data));
 int		   svc_set_num_threads(struct svc_serv *, struct svc_pool *, int);
 int		   svc_pool_stats_open(struct svc_serv *serv, struct file *file);
-int		   svc_process(struct svc_rqst *);
+void		   svc_process(struct svc_rqst *rqstp);
 int		   bc_svc_process(struct svc_serv *, struct rpc_rqst *,
 			struct svc_rqst *);
 int		   svc_register(const struct svc_serv *, struct net *, const int,

include/linux/sunrpc/svc_xprt.h+4−1

 	void		(*xpo_detach)(struct svc_xprt *);
 	void		(*xpo_free)(struct svc_xprt *);
 	void		(*xpo_kill_temp_xprt)(struct svc_xprt *);
-	void		(*xpo_start_tls)(struct svc_xprt *);
+	void		(*xpo_handshake)(struct svc_xprt *xprt);
 };
 struct svc_xprt_class {
 #define XPT_LOCAL	12		/* connection from loopback interface */
 #define XPT_KILL_TEMP   13		/* call xpo_kill_temp_xprt before closing */
 #define XPT_CONG_CTRL	14		/* has congestion control */
+#define XPT_HANDSHAKE	15		/* xprt requests a handshake */
+#define XPT_TLS_SESSION	16		/* transport-layer security established */
+#define XPT_PEER_AUTH	17		/* peer has been authenticated */
 	struct svc_serv		*xpt_server;	/* service for transport */
 	atomic_t    	    	xpt_reserved;	/* space on outq that is rsvd */

include/linux/sunrpc/svcsock.h+3−1

 	/* Number of queued send requests */
 	atomic_t		sk_sendqlen;
+	struct completion	sk_handshake_done;
 	struct page *		sk_pages[RPCSVC_MAXPAGES];	/* received data */
 };
  */
 void		svc_close_net(struct svc_serv *, struct net *);
 int		svc_recv(struct svc_rqst *, long);
-int		svc_send(struct svc_rqst *);
+void		svc_send(struct svc_rqst *rqstp);
 void		svc_drop(struct svc_rqst *);
 void		svc_sock_update_bufs(struct svc_serv *serv);
 bool		svc_alien_sock(struct net *net, int fd);

include/net/tls.h+2−0

@@ -69,6 +69,8 @@ extern const struct tls_cipher_size_desc tls_cipher_size_desc[]; · 68 unmodified lines
69		69
70	#define TLS_CRYPTO_INFO_READY(info) ((info)->cipher_type)	70	#define TLS_CRYPTO_INFO_READY(info) ((info)->cipher_type)
71		71
		72	#define TLS_RECORD_TYPE_ALERT 0x15
		73	#define TLS_RECORD_TYPE_HANDSHAKE 0x16
72	#define TLS_RECORD_TYPE_DATA 0x17	74	#define TLS_RECORD_TYPE_DATA 0x17
73		75
74	#define TLS_AAD_SPACE_SIZE 13	76	#define TLS_AAD_SPACE_SIZE 13

include/trace/events/sunrpc.h+40−1

@@ -1790,6 +1790,31 @@ DEFINE_EVENT(svc_rqst_status, svc_send, · 1789 unmodified lines
1790	TP_PROTO(const struct svc_rqst *rqst, int status),	1790	TP_PROTO(const struct svc_rqst *rqst, int status),
1791	TP_ARGS(rqst, status));	1791	TP_ARGS(rqst, status));
1792		1792
		1793	TRACE_EVENT(svc_replace_page_err,
		1794	TP_PROTO(const struct svc_rqst *rqst),
		1795
		1796	TP_ARGS(rqst),
		1797	TP_STRUCT__entry(
		1798	SVC_RQST_ENDPOINT_FIELDS(rqst)
		1799
		1800	__field(const void *, begin)
		1801	__field(const void *, respages)
		1802	__field(const void *, nextpage)
		1803	),
		1804
		1805	TP_fast_assign(
		1806	SVC_RQST_ENDPOINT_ASSIGNMENTS(rqst);
		1807
		1808	__entry->begin = rqst->rq_pages;
		1809	__entry->respages = rqst->rq_respages;
		1810	__entry->nextpage = rqst->rq_next_page;
		1811	),
		1812
		1813	TP_printk(SVC_RQST_ENDPOINT_FORMAT " begin=%p respages=%p nextpage=%p",
		1814	SVC_RQST_ENDPOINT_VARARGS,
		1815	__entry->begin, __entry->respages, __entry->nextpage)
		1816	);
		1817
1793	TRACE_EVENT(svc_stats_latency,	1818	TRACE_EVENT(svc_stats_latency,
1794	TP_PROTO(	1819	TP_PROTO(
1795	const struct svc_rqst *rqst	1820	const struct svc_rqst *rqst
@@ -1832,7 +1857,10 @@ TRACE_EVENT(svc_stats_latency, · 36 unmodified lines
1832	{ BIT(XPT_CACHE_AUTH), "CACHE_AUTH" }, \	1857	{ BIT(XPT_CACHE_AUTH), "CACHE_AUTH" }, \
1833	{ BIT(XPT_LOCAL), "LOCAL" }, \	1858	{ BIT(XPT_LOCAL), "LOCAL" }, \
1834	{ BIT(XPT_KILL_TEMP), "KILL_TEMP" }, \	1859	{ BIT(XPT_KILL_TEMP), "KILL_TEMP" }, \
1835	{ BIT(XPT_CONG_CTRL), "CONG_CTRL" })	1860	{ BIT(XPT_CONG_CTRL), "CONG_CTRL" }, \
		1861	{ BIT(XPT_HANDSHAKE), "HANDSHAKE" }, \
		1862	{ BIT(XPT_TLS_SESSION), "TLS_SESSION" }, \
		1863	{ BIT(XPT_PEER_AUTH), "PEER_AUTH" })
1836		1864
1837	TRACE_EVENT(svc_xprt_create_err,	1865	TRACE_EVENT(svc_xprt_create_err,
1838	TP_PROTO(	1866	TP_PROTO(
@@ -1965,6 +1993,17 @@ DEFINE_SVC_XPRT_EVENT(close); · 126 unmodified lines
1965	DEFINE_SVC_XPRT_EVENT(detach);	1993	DEFINE_SVC_XPRT_EVENT(detach);
1966	DEFINE_SVC_XPRT_EVENT(free);	1994	DEFINE_SVC_XPRT_EVENT(free);
1967		1995
		1996	#define DEFINE_SVC_TLS_EVENT(name) \
		1997	DEFINE_EVENT(svc_xprt_event, svc_tls_##name, \
		1998	TP_PROTO(const struct svc_xprt *xprt), \
		1999	TP_ARGS(xprt))
		2000
		2001	DEFINE_SVC_TLS_EVENT(start);
		2002	DEFINE_SVC_TLS_EVENT(upcall);
		2003	DEFINE_SVC_TLS_EVENT(unavailable);
		2004	DEFINE_SVC_TLS_EVENT(not_started);
		2005	DEFINE_SVC_TLS_EVENT(timed_out);
		2006
1968	TRACE_EVENT(svc_xprt_accept,	2007	TRACE_EVENT(svc_xprt_accept,
1969	TP_PROTO(	2008	TP_PROTO(
1970	const struct svc_xprt *xprt,	2009	const struct svc_xprt *xprt,

include/uapi/linux/nfsd/export.h+13−0

@@ -62,5 +62,18 @@ · 61 unmodified lines
62	\| NFSEXP_ALLSQUASH \	62	\| NFSEXP_ALLSQUASH \
63	\| NFSEXP_INSECURE_PORT)	63	\| NFSEXP_INSECURE_PORT)
64		64
		65	/*
		66	* Transport layer security policies that are permitted to access
		67	* an export
		68	*/
		69	#define NFSEXP_XPRTSEC_NONE 0x0001
		70	#define NFSEXP_XPRTSEC_TLS 0x0002
		71	#define NFSEXP_XPRTSEC_MTLS 0x0004
		72
		73	#define NFSEXP_XPRTSEC_NUM (3)
		74
		75	#define NFSEXP_XPRTSEC_ALL (NFSEXP_XPRTSEC_NONE \| \
		76	NFSEXP_XPRTSEC_TLS \| \
		77	NFSEXP_XPRTSEC_MTLS)
65		78
66	#endif /* _UAPINFSD_EXPORT_H */	79	#endif /* _UAPINFSD_EXPORT_H */

net/sunrpc/auth_gss/svcauth_gss.c+6−6

 	rsii.h.flags = 0;
 	/* expiry */
-	expiry = get_expiry(&mesg);
+	status = get_expiry(&mesg, &expiry);
-	status = -EINVAL;
+	if (status)
-	if (expiry == 0)
 		goto out;
+	status = -EINVAL;
 	/* major/minor */
 	len = qword_get(&mesg, buf, mlen);
 	if (len <= 0)
 	rsci.h.flags = 0;
 	/* expiry */
-	expiry = get_expiry(&mesg);
+	status = get_expiry(&mesg, &expiry);
-	status = -EINVAL;
+	if (status)
-	if (expiry == 0)
 		goto out;
+	status = -EINVAL;
 	rscp = rsc_lookup(cd, &rsci);
 	if (!rscp)
 		goto out;

net/sunrpc/svc.c+42−7

 	if (!rqstp)
 		return rqstp;
+	pagevec_init(&rqstp->rq_pvec);
 	__set_bit(RQ_BUSY, &rqstp->rq_flags);
 	rqstp->rq_server = serv;
 	rqstp->rq_pool = pool;
  *
  * When replacing a page in rq_pages, batch the release of the
  * replaced pages to avoid hammering the page allocator.
+ *
+ * Return values:
+ *   %true: page replaced
+ *   %false: array bounds checking failed
  */
-void svc_rqst_replace_page(struct svc_rqst *rqstp, struct page *page)
+bool svc_rqst_replace_page(struct svc_rqst *rqstp, struct page *page)
 {
+	struct page **begin = rqstp->rq_pages;
+	struct page **end = &rqstp->rq_pages[RPCSVC_MAXPAGES];
+	if (unlikely(rqstp->rq_next_page < begin || rqstp->rq_next_page > end)) {
+		trace_svc_replace_page_err(rqstp);
+		return false;
+	}
 	if (*rqstp->rq_next_page) {
 		if (!pagevec_space(&rqstp->rq_pvec))
 			__pagevec_release(&rqstp->rq_pvec);
 	get_page(page);
 	*(rqstp->rq_next_page++) = page;
+	return true;
 }
 EXPORT_SYMBOL_GPL(svc_rqst_replace_page);
+/**
+ * svc_rqst_release_pages - Release Reply buffer pages
+ * @rqstp: RPC transaction context
+ *
+ * Release response pages that might still be in flight after
+ * svc_send, and any spliced filesystem-owned pages.
+ */
+void svc_rqst_release_pages(struct svc_rqst *rqstp)
+{
+	int i, count = rqstp->rq_next_page - rqstp->rq_respages;
+	if (count) {
+		release_pages(rqstp->rq_respages, count);
+		for (i = 0; i < count; i++)
+			rqstp->rq_respages[i] = NULL;
+	}
+}
 /*
  * Called from a server thread as it's exiting. Caller must hold the "service
  * mutex" for the service.
 void
 svc_rqst_free(struct svc_rqst *rqstp)
 {
+	pagevec_release(&rqstp->rq_pvec);
 	svc_release_buffer(rqstp);
 	if (rqstp->rq_scratch_page)
 		put_page(rqstp->rq_scratch_page);
 	goto sendit;
 }
-/*
+/**
- * Process the RPC request.
+ * svc_process - Execute one RPC transaction
+ * @rqstp: RPC transaction context
+ *
  */
-int
+void svc_process(struct svc_rqst *rqstp)
-svc_process(struct svc_rqst *rqstp)
 {
 	struct kvec		*resv = &rqstp->rq_res.head[0];
 	__be32 *p;
 	if (!svc_process_common(rqstp))
 		goto out_drop;
-	return svc_send(rqstp);
+	svc_send(rqstp);
+	return;
 out_baddir:
 	svc_printk(rqstp, "bad direction 0x%08x, dropping request\n",
 	rqstp->rq_server->sv_stats->rpcbadfmt++;
 out_drop:
 	svc_drop(rqstp);
-	return 0;
 }
 EXPORT_SYMBOL_GPL(svc_process);

net/sunrpc/svc_xprt.c+16−17

 	if (xpt_flags & BIT(XPT_BUSY))
 		return false;
-	if (xpt_flags & (BIT(XPT_CONN) | BIT(XPT_CLOSE)))
+	if (xpt_flags & (BIT(XPT_CONN) | BIT(XPT_CLOSE) | BIT(XPT_HANDSHAKE)))
 		return true;
 	if (xpt_flags & (BIT(XPT_DATA) | BIT(XPT_DEFERRED))) {
 		if (xprt->xpt_ops->xpo_has_wspace(xprt) &&
 	kfree(rqstp->rq_deferred);
 	rqstp->rq_deferred = NULL;
-	pagevec_release(&rqstp->rq_pvec);
+	svc_rqst_release_pages(rqstp);
-	svc_free_res_pages(rqstp);
 	rqstp->rq_res.page_len = 0;
 	rqstp->rq_res.page_base = 0;
 	struct xdr_buf *arg = &rqstp->rq_arg;
 	unsigned long pages, filled, ret;
-	pagevec_init(&rqstp->rq_pvec);
 	pages = (serv->sv_max_mesg + 2 * PAGE_SIZE) >> PAGE_SHIFT;
 	if (pages > RPCSVC_MAXPAGES) {
 		pr_warn_once("svc: warning: pages=%lu > RPCSVC_MAXPAGES=%lu\n",
 	arg->page_len = (pages-2)*PAGE_SIZE;
 	arg->len = (pages-1)*PAGE_SIZE;
 	arg->tail[0].iov_len = 0;
+	rqstp->rq_xid = xdr_zero;
 	return 0;
 }
 			module_put(xprt->xpt_class->xcl_owner);
 		}
 		svc_xprt_received(xprt);
+	} else if (test_bit(XPT_HANDSHAKE, &xprt->xpt_flags)) {
+		xprt->xpt_ops->xpo_handshake(xprt);
+		svc_xprt_received(xprt);
 	} else if (svc_xprt_reserve_slot(rqstp, xprt)) {
 		/* XPT_DATA|XPT_DEFERRED case: */
 		dprintk("svc: server %p, pool %u, transport %p, inuse=%d\n",
 }
 EXPORT_SYMBOL_GPL(svc_drop);
-/*
+/**
- * Return reply to client.
+ * svc_send - Return reply to client
+ * @rqstp: RPC transaction context
+ *
  */
-int svc_send(struct svc_rqst *rqstp)
+void svc_send(struct svc_rqst *rqstp)
 {
 	struct svc_xprt	*xprt;
-	int		len = -EFAULT;
 	struct xdr_buf	*xb;
+	int status;
 	xprt = rqstp->rq_xprt;
 	if (!xprt)
-		goto out;
+		return;
 	/* calculate over-all length */
 	xb = &rqstp->rq_res;
 	trace_svc_xdr_sendto(rqstp->rq_xid, xb);
 	trace_svc_stats_latency(rqstp);
-	len = xprt->xpt_ops->xpo_sendto(rqstp);
+	status = xprt->xpt_ops->xpo_sendto(rqstp);
-	trace_svc_send(rqstp, len);
+	trace_svc_send(rqstp, status);
 	svc_xprt_release(rqstp);
-	if (len == -ECONNREFUSED || len == -ENOTCONN || len == -EAGAIN)
-		len = 0;
-out:
-	return len;
 }
 /*

net/sunrpc/svcauth_unix.c+15−8

 #include <net/ipv6.h>
 #include <linux/kernel.h>
 #include <linux/user_namespace.h>
-#define RPCDBG_FACILITY	RPCDBG_AUTH
+#include <trace/events/sunrpc.h>
+#define RPCDBG_FACILITY	RPCDBG_AUTH
 #include "netns.h"
 		return -EINVAL;
 	}
-	expiry = get_expiry(&mesg);
+	err = get_expiry(&mesg, &expiry);
-	if (expiry ==0)
+	if (err)
-		return -EINVAL;
+		return err;
 	/* domainname, or empty for NEGATIVE */
 	len = qword_get(&mesg, buf, mlen);
 	uid = make_kuid(current_user_ns(), id);
 	ug.uid = uid;
-	expiry = get_expiry(&mesg);
+	err = get_expiry(&mesg, &expiry);
-	if (expiry == 0)
+	if (err)
-		return -EINVAL;
+		return err;
 	rv = get_int(&mesg, &gids);
 	if (rv || gids < 0 || gids > 8192)
 {
 	struct xdr_stream *xdr = &rqstp->rq_arg_stream;
 	struct svc_cred	*cred = &rqstp->rq_cred;
+	struct svc_xprt *xprt = rqstp->rq_xprt;
 	u32 flavor, len;
 	void *body;
 	__be32 *p;
 	if (cred->cr_group_info == NULL)
 		return SVC_CLOSE;
-	if (rqstp->rq_xprt->xpt_ops->xpo_start_tls) {
+	if (xprt->xpt_ops->xpo_handshake) {
 		p = xdr_reserve_space(&rqstp->rq_res_stream, XDR_UNIT * 2 + 8);
 		if (!p)
 			return SVC_CLOSE;
+		trace_svc_tls_start(xprt);
 		*p++ = rpc_auth_null;
 		*p++ = cpu_to_be32(8);
 		memcpy(p, "STARTTLS", 8);
+		set_bit(XPT_HANDSHAKE, &xprt->xpt_flags);
+		svc_xprt_enqueue(xprt);
 	} else {
+		trace_svc_tls_unavailable(xprt);
 		if (xdr_stream_encode_opaque_auth(&rqstp->rq_res_stream,
 						  RPC_AUTH_NULL, NULL, 0) < 0)
 			return SVC_CLOSE;

net/sunrpc/svcsock.c+162−12

@@ -43,9 +43,12 @@ · 42 unmodified lines
43	#include <net/udp.h>	43	#include <net/udp.h>
44	#include <net/tcp.h>	44	#include <net/tcp.h>
45	#include <net/tcp_states.h>	45	#include <net/tcp_states.h>
		46	#include <net/tls.h>
		47	#include <net/handshake.h>
46	#include <linux/uaccess.h>	48	#include <linux/uaccess.h>
47	#include <linux/highmem.h>	49	#include <linux/highmem.h>
48	#include <asm/ioctls.h>	50	#include <asm/ioctls.h>
		51	#include <linux/key.h>
49		52
50	#include <linux/sunrpc/types.h>	53	#include <linux/sunrpc/types.h>
51	#include <linux/sunrpc/clnt.h>	54	#include <linux/sunrpc/clnt.h>
@@ -63,6 +66,12 @@ · 11 unmodified lines
63		66
64	#define RPCDBG_FACILITY RPCDBG_SVCXPRT	67	#define RPCDBG_FACILITY RPCDBG_SVCXPRT
65		68
		69	/* To-do: to avoid tying up an nfsd thread while waiting for a
		70	* handshake request, the request could instead be deferred.
		71	*/
		72	enum {
		73	SVC_HANDSHAKE_TO = 5U * HZ
		74	};
66		75
67	static struct svc_sock svc_setup_socket(struct svc_serv , struct socket *,	76	static struct svc_sock svc_setup_socket(struct svc_serv , struct socket *,
68	int flags);	77	int flags);
@@ -216,6 +225,49 @@ static int svc_one_sock_name(struct svc_sock svsk, char buf, int remaining) · 147 unmodified lines
216	return len;	225	return len;
217	}	226	}
218		227
		228	static int
		229	svc_tcp_sock_process_cmsg(struct svc_sock svsk, struct msghdr msg,
		230	struct cmsghdr *cmsg, int ret)
		231	{
		232	if (cmsg->cmsg_level == SOL_TLS &&
		233	cmsg->cmsg_type == TLS_GET_RECORD_TYPE) {
		234	u8 content_type = ((u8 )CMSG_DATA(cmsg));
		235
		236	switch (content_type) {
		237	case TLS_RECORD_TYPE_DATA:
		238	/* TLS sets EOR at the end of each application data
		239	* record, even though there might be more frames
		240	* waiting to be decrypted.
		241	*/
		242	msg->msg_flags &= ~MSG_EOR;
		243	break;
		244	case TLS_RECORD_TYPE_ALERT:
		245	ret = -ENOTCONN;
		246	break;
		247	default:
		248	ret = -EAGAIN;
		249	}
		250	}
		251	return ret;
		252	}
		253
		254	static int
		255	svc_tcp_sock_recv_cmsg(struct svc_sock svsk, struct msghdr msg)
		256	{
		257	union {
		258	struct cmsghdr cmsg;
		259	u8 buf[CMSG_SPACE(sizeof(u8))];
		260	} u;
		261	int ret;
		262
		263	msg->msg_control = &u;
		264	msg->msg_controllen = sizeof(u);
		265	ret = sock_recvmsg(svsk->sk_sock, msg, MSG_DONTWAIT);
		266	if (unlikely(msg->msg_controllen != sizeof(u)))
		267	ret = svc_tcp_sock_process_cmsg(svsk, msg, &u.cmsg, ret);
		268	return ret;
		269	}
		270
219	#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE	271	#if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE
220	static void svc_flush_bvec(const struct bio_vec *bvec, size_t size, size_t seek)	272	static void svc_flush_bvec(const struct bio_vec *bvec, size_t size, size_t seek)
221	{	273	{
@@ -263,7 +315,7 @@ static ssize_t svc_tcp_read_msg(struct svc_rqst *rqstp, size_t buflen, · 41 unmodified lines
263	iov_iter_advance(&msg.msg_iter, seek);	315	iov_iter_advance(&msg.msg_iter, seek);
264	buflen -= seek;	316	buflen -= seek;
265	}	317	}
266	len = sock_recvmsg(svsk->sk_sock, &msg, MSG_DONTWAIT);	318	len = svc_tcp_sock_recv_cmsg(svsk, &msg);
267	if (len > 0)	319	if (len > 0)
268	svc_flush_bvec(bvec, len, seek);	320	svc_flush_bvec(bvec, len, seek);
269		321
@@ -315,6 +367,8 @@ static void svc_data_ready(struct sock *sk) · 45 unmodified lines
315	rmb();	367	rmb();
316	svsk->sk_odata(sk);	368	svsk->sk_odata(sk);
317	trace_svcsock_data_ready(&svsk->sk_xprt, 0);	369	trace_svcsock_data_ready(&svsk->sk_xprt, 0);
		370	if (test_bit(XPT_HANDSHAKE, &svsk->sk_xprt.xpt_flags))
		371	return;
318	if (!test_and_set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags))	372	if (!test_and_set_bit(XPT_DATA, &svsk->sk_xprt.xpt_flags))
319	svc_xprt_enqueue(&svsk->sk_xprt);	373	svc_xprt_enqueue(&svsk->sk_xprt);
320	}	374	}
@@ -352,6 +406,88 @@ static void svc_tcp_kill_temp_xprt(struct svc_xprt *xprt) · 31 unmodified lines
352	sock_no_linger(svsk->sk_sock->sk);	406	sock_no_linger(svsk->sk_sock->sk);
353	}	407	}
354		408
		409	/**
		410	* svc_tcp_handshake_done - Handshake completion handler
		411	* @data: address of xprt to wake
		412	* @status: status of handshake
		413	* @peerid: serial number of key containing the remote peer's identity
		414	*
		415	* If a security policy is specified as an export option, we don't
		416	* have a specific export here to check. So we set a "TLS session
		417	* is present" flag on the xprt and let an upper layer enforce local
		418	* security policy.
		419	*/
		420	static void svc_tcp_handshake_done(void *data, int status, key_serial_t peerid)
		421	{
		422	struct svc_xprt *xprt = data;
		423	struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
		424
		425	if (!status) {
		426	if (peerid != TLS_NO_PEERID)
		427	set_bit(XPT_PEER_AUTH, &xprt->xpt_flags);
		428	set_bit(XPT_TLS_SESSION, &xprt->xpt_flags);
		429	}
		430	clear_bit(XPT_HANDSHAKE, &xprt->xpt_flags);
		431	complete_all(&svsk->sk_handshake_done);
		432	}
		433
		434	/**
		435	* svc_tcp_handshake - Perform a transport-layer security handshake
		436	* @xprt: connected transport endpoint
		437	*
		438	*/
		439	static void svc_tcp_handshake(struct svc_xprt *xprt)
		440	{
		441	struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
		442	struct sock *sk = svsk->sk_sock->sk;
		443	struct tls_handshake_args args = {
		444	.ta_sock = svsk->sk_sock,
		445	.ta_done = svc_tcp_handshake_done,
		446	.ta_data = xprt,
		447	};
		448	int ret;
		449
		450	trace_svc_tls_upcall(xprt);
		451
		452	clear_bit(XPT_TLS_SESSION, &xprt->xpt_flags);
		453	init_completion(&svsk->sk_handshake_done);
		454
		455	ret = tls_server_hello_x509(&args, GFP_KERNEL);
		456	if (ret) {
		457	trace_svc_tls_not_started(xprt);
		458	goto out_failed;
		459	}
		460
		461	ret = wait_for_completion_interruptible_timeout(&svsk->sk_handshake_done,
		462	SVC_HANDSHAKE_TO);
		463	if (ret <= 0) {
		464	if (tls_handshake_cancel(sk)) {
		465	trace_svc_tls_timed_out(xprt);
		466	goto out_close;
		467	}
		468	}
		469
		470	if (!test_bit(XPT_TLS_SESSION, &xprt->xpt_flags)) {
		471	trace_svc_tls_unavailable(xprt);
		472	goto out_close;
		473	}
		474
		475	/* Mark the transport ready in case the remote sent RPC
		476	* traffic before the kernel received the handshake
		477	* completion downcall.
		478	*/
		479	set_bit(XPT_DATA, &xprt->xpt_flags);
		480	svc_xprt_enqueue(xprt);
		481	return;
		482
		483	out_close:
		484	set_bit(XPT_CLOSE, &xprt->xpt_flags);
		485	out_failed:
		486	clear_bit(XPT_HANDSHAKE, &xprt->xpt_flags);
		487	set_bit(XPT_DATA, &xprt->xpt_flags);
		488	svc_xprt_enqueue(xprt);
		489	}
		490
355	/*	491	/*
356	* See net/ipv6/ip_sockglue.c : ip_cmsg_recv_pktinfo	492	* See net/ipv6/ip_sockglue.c : ip_cmsg_recv_pktinfo
357	*/	493	*/
@@ -877,7 +1013,7 @@ static ssize_t svc_tcp_read_marker(struct svc_sock *svsk, · 519 unmodified lines
877	iov.iov_base = ((char *)&svsk->sk_marker) + svsk->sk_tcplen;	1013	iov.iov_base = ((char *)&svsk->sk_marker) + svsk->sk_tcplen;
878	iov.iov_len = want;	1014	iov.iov_len = want;
879	iov_iter_kvec(&msg.msg_iter, ITER_DEST, &iov, 1, want);	1015	iov_iter_kvec(&msg.msg_iter, ITER_DEST, &iov, 1, want);
880	len = sock_recvmsg(svsk->sk_sock, &msg, MSG_DONTWAIT);	1016	len = svc_tcp_sock_recv_cmsg(svsk, &msg);
881	if (len < 0)	1017	if (len < 0)
882	return len;	1018	return len;
883	svsk->sk_tcplen += len;	1019	svsk->sk_tcplen += len;
@@ -1213,6 +1349,7 @@ static const struct svc_xprt_ops svc_tcp_ops = { · 329 unmodified lines
1213	.xpo_has_wspace = svc_tcp_has_wspace,	1349	.xpo_has_wspace = svc_tcp_has_wspace,
1214	.xpo_accept = svc_tcp_accept,	1350	.xpo_accept = svc_tcp_accept,
1215	.xpo_kill_temp_xprt = svc_tcp_kill_temp_xprt,	1351	.xpo_kill_temp_xprt = svc_tcp_kill_temp_xprt,
		1352	.xpo_handshake = svc_tcp_handshake,
1216	};	1353	};
1217		1354
1218	static struct svc_xprt_class svc_tcp_class = {	1355	static struct svc_xprt_class svc_tcp_class = {
@@ -1293,26 +1430,37 @@ static struct svc_sock svc_setup_socket(struct svc_serv serv, · 74 unmodified lines
1293	struct socket *sock,	1430	struct socket *sock,
1294	int flags)	1431	int flags)
1295	{	1432	{
		1433	struct file *filp = NULL;
1296	struct svc_sock *svsk;	1434	struct svc_sock *svsk;
1297	struct sock *inet;	1435	struct sock *inet;
1298	int pmap_register = !(flags & SVC_SOCK_ANONYMOUS);	1436	int pmap_register = !(flags & SVC_SOCK_ANONYMOUS);
1299	int err = 0;
1300		1437
1301	svsk = kzalloc(sizeof(*svsk), GFP_KERNEL);	1438	svsk = kzalloc(sizeof(*svsk), GFP_KERNEL);
1302	if (!svsk)	1439	if (!svsk)
1303	return ERR_PTR(-ENOMEM);	1440	return ERR_PTR(-ENOMEM);
1304		1441
		1442	if (!sock->file) {
		1443	filp = sock_alloc_file(sock, O_NONBLOCK, NULL);
		1444	if (IS_ERR(filp)) {
		1445	kfree(svsk);
		1446	return ERR_CAST(filp);
		1447	}
		1448	}
		1449
1305	inet = sock->sk;	1450	inet = sock->sk;
1306		1451
1307	/* Register socket with portmapper */	1452	if (pmap_register) {
1308	if (pmap_register)	1453	int err;
		1454
1309	err = svc_register(serv, sock_net(sock->sk), inet->sk_family,	1455	err = svc_register(serv, sock_net(sock->sk), inet->sk_family,
1310	inet->sk_protocol,	1456	inet->sk_protocol,
1311	ntohs(inet_sk(inet)->inet_sport));	1457	ntohs(inet_sk(inet)->inet_sport));
1312		1458	if (err < 0) {
1313	if (err < 0) {	1459	if (filp)
1314	kfree(svsk);	1460	fput(filp);
1315	return ERR_PTR(err);	1461	kfree(svsk);
		1462	return ERR_PTR(err);
		1463	}
1316	}	1464	}
1317		1465
1318	svsk->sk_sock = sock;	1466	svsk->sk_sock = sock;
@@ -1525,10 +1673,12 @@ static void svc_tcp_sock_detach(struct svc_xprt *xprt) · 206 unmodified lines
1525	static void svc_sock_free(struct svc_xprt *xprt)	1673	static void svc_sock_free(struct svc_xprt *xprt)
1526	{	1674	{
1527	struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);	1675	struct svc_sock *svsk = container_of(xprt, struct svc_sock, sk_xprt);
		1676	struct socket *sock = svsk->sk_sock;
1528		1677
1529	if (svsk->sk_sock->file)	1678	tls_handshake_cancel(sock->sk);
1530	sockfd_put(svsk->sk_sock);	1679	if (sock->file)
		1680	sockfd_put(sock);
1531	else	1681	else
1532	sock_release(svsk->sk_sock);	1682	sock_release(sock);
1533	kfree(svsk);	1683	kfree(svsk);
1534	}	1684	}

net/sunrpc/xprtrdma/svc_rdma.c+2−19

@@ -212,24 +212,6 @@ static struct ctl_table svcrdma_parm_table[] = { · 211 unmodified lines
212	{ },	212	{ },
213	};	213	};
214		214
215	static struct ctl_table svcrdma_table[] = {
216	{
217	.procname = "svc_rdma",
218	.mode = 0555,
219	.child = svcrdma_parm_table
220	},
221	{ },
222	};
223
224	static struct ctl_table svcrdma_root_table[] = {
225	{
226	.procname = "sunrpc",
227	.mode = 0555,
228	.child = svcrdma_table
229	},
230	{ },
231	};
232
233	static void svc_rdma_proc_cleanup(void)	215	static void svc_rdma_proc_cleanup(void)
234	{	216	{
235	if (!svcrdma_table_header)	217	if (!svcrdma_table_header)
@@ -263,7 +245,8 @@ static int svc_rdma_proc_init(void) · 27 unmodified lines
263	if (rc)	245	if (rc)
264	goto out_err;	246	goto out_err;
265		247
266	svcrdma_table_header = register_sysctl_table(svcrdma_root_table);	248	svcrdma_table_header = register_sysctl("sunrpc/svc_rdma",
		249	svcrdma_parm_table);
267	return 0;	250	return 0;
268		251
269	out_err:	252	out_err: