~hc/RK356X_SDK_RELEASE.git

..	..	@@ -42,6 +42,7 @@
42	42	#include <linux/sunrpc/svcauth_gss.h>
43	43	#include <linux/sunrpc/addr.h>
44	44	#include <linux/jhash.h>
	45	+#include <linux/string_helpers.h>
45	46	#include "xdr4.h"
46	47	#include "xdr4cb.h"
47	48	#include "vfs.h"
..	..	@@ -49,6 +50,8 @@
49	50
50	51	#include "netns.h"
51	52	#include "pnfs.h"
	53	+#include "filecache.h"
	54	+#include "trace.h"
52	55
53	56	#define NFSDDBG_FACILITY NFSDDBG_PROC
54	57
..	..	@@ -77,6 +80,8 @@
77	80	/* forward declarations */
78	81	static bool check_for_locks(struct nfs4_file fp, struct nfs4_lockowner lowner);
79	82	static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
	83	+void nfsd4_end_grace(struct nfsd_net *nn);
	84	+static void _free_cpntf_state_locked(struct nfsd_net nn, struct nfs4_cpntf_state cps);
80	85
81	86	/* Locking: */
82	87
..	..	@@ -97,6 +102,13 @@
97	102	* the refcount on the open stateid to drop.
98	103	*/
99	104	static DECLARE_WAIT_QUEUE_HEAD(close_wq);
	105	+
	106	+/*
	107	+ * A waitqueue where a writer to clients/#/ctl destroying a client can
	108	+ * wait for cl_rpc_users to drop to 0 and then for the client to be
	109	+ * unhashed.
	110	+ */
	111	+static DECLARE_WAIT_QUEUE_HEAD(expiry_wq);
100	112
101	113	static struct kmem_cache *client_slab;
102	114	static struct kmem_cache *openowner_slab;
..	..	@@ -137,7 +149,7 @@
137	149
138	150	if (is_client_expired(clp))
139	151	return nfserr_expired;
140		- atomic_inc(&clp->cl_refcount);
	152	+ atomic_inc(&clp->cl_rpc_users);
141	153	return nfs_ok;
142	154	}
143	155
..	..	@@ -156,11 +168,8 @@
156	168	return;
157	169	}
158	170
159		- dprintk("renewing client (clientid %08x/%08x)\n",
160		- clp->cl_clientid.cl_boot,
161		- clp->cl_clientid.cl_id);
162	171	list_move_tail(&clp->cl_lru, &nn->client_lru);
163		- clp->cl_time = get_seconds();
	172	+ clp->cl_time = ktime_get_boottime_seconds();
164	173	}
165	174
166	175	static void put_client_renew_locked(struct nfs4_client *clp)
..	..	@@ -169,20 +178,24 @@
169	178
170	179	lockdep_assert_held(&nn->client_lock);
171	180
172		- if (!atomic_dec_and_test(&clp->cl_refcount))
	181	+ if (!atomic_dec_and_test(&clp->cl_rpc_users))
173	182	return;
174	183	if (!is_client_expired(clp))
175	184	renew_client_locked(clp);
	185	+ else
	186	+ wake_up_all(&expiry_wq);
176	187	}
177	188
178	189	static void put_client_renew(struct nfs4_client *clp)
179	190	{
180	191	struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
181	192
182		- if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
	193	+ if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock))
183	194	return;
184	195	if (!is_client_expired(clp))
185	196	renew_client_locked(clp);
	197	+ else
	198	+ wake_up_all(&expiry_wq);
186	199	spin_unlock(&nn->client_lock);
187	200	}
188	201
..	..	@@ -238,7 +251,7 @@
238	251	}
239	252	spin_unlock(&nn->blocked_locks_lock);
240	253	if (found)
241		- posix_unblock_lock(&found->nbl_lock);
	254	+ locks_delete_block(&found->nbl_lock);
242	255	return found;
243	256	}
244	257
..	..	@@ -267,6 +280,7 @@
267	280	static void
268	281	free_blocked_lock(struct nfsd4_blocked_lock *nbl)
269	282	{
	283	+ locks_delete_block(&nbl->nbl_lock);
270	284	locks_release_private(&nbl->nbl_lock);
271	285	kfree(nbl);
272	286	}
..	..	@@ -295,9 +309,16 @@
295	309	nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
296	310	nbl_lru);
297	311	list_del_init(&nbl->nbl_lru);
298		- posix_unblock_lock(&nbl->nbl_lock);
299	312	free_blocked_lock(nbl);
300	313	}
	314	+}
	315	+
	316	+static void
	317	+nfsd4_cb_notify_lock_prepare(struct nfsd4_callback *cb)
	318	+{
	319	+ struct nfsd4_blocked_lock *nbl = container_of(cb,
	320	+ struct nfsd4_blocked_lock, nbl_cb);
	321	+ locks_delete_block(&nbl->nbl_lock);
301	322	}
302	323
303	324	static int
..	..	@@ -327,6 +348,7 @@
327	348	}
328	349
329	350	static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
	351	+ .prepare = nfsd4_cb_notify_lock_prepare,
330	352	.done = nfsd4_cb_notify_lock_done,
331	353	.release = nfsd4_cb_notify_lock_release,
332	354	};
..	..	@@ -409,18 +431,18 @@
409	431	}
410	432	}
411	433
412		-static struct file *
	434	+static struct nfsd_file *
413	435	__nfs4_get_fd(struct nfs4_file *f, int oflag)
414	436	{
415	437	if (f->fi_fds[oflag])
416		- return get_file(f->fi_fds[oflag]);
	438	+ return nfsd_file_get(f->fi_fds[oflag]);
417	439	return NULL;
418	440	}
419	441
420		-static struct file *
	442	+static struct nfsd_file *
421	443	find_writeable_file_locked(struct nfs4_file *f)
422	444	{
423		- struct file *ret;
	445	+ struct nfsd_file *ret;
424	446
425	447	lockdep_assert_held(&f->fi_lock);
426	448
..	..	@@ -430,10 +452,10 @@
430	452	return ret;
431	453	}
432	454
433		-static struct file *
	455	+static struct nfsd_file *
434	456	find_writeable_file(struct nfs4_file *f)
435	457	{
436		- struct file *ret;
	458	+ struct nfsd_file *ret;
437	459
438	460	spin_lock(&f->fi_lock);
439	461	ret = find_writeable_file_locked(f);
..	..	@@ -442,9 +464,10 @@
442	464	return ret;
443	465	}
444	466
445		-static struct file find_readable_file_locked(struct nfs4_file f)
	467	+static struct nfsd_file *
	468	+find_readable_file_locked(struct nfs4_file *f)
446	469	{
447		- struct file *ret;
	470	+ struct nfsd_file *ret;
448	471
449	472	lockdep_assert_held(&f->fi_lock);
450	473
..	..	@@ -454,10 +477,10 @@
454	477	return ret;
455	478	}
456	479
457		-static struct file *
	480	+static struct nfsd_file *
458	481	find_readable_file(struct nfs4_file *f)
459	482	{
460		- struct file *ret;
	483	+ struct nfsd_file *ret;
461	484
462	485	spin_lock(&f->fi_lock);
463	486	ret = find_readable_file_locked(f);
..	..	@@ -466,10 +489,10 @@
466	489	return ret;
467	490	}
468	491
469		-struct file *
	492	+struct nfsd_file *
470	493	find_any_file(struct nfs4_file *f)
471	494	{
472		- struct file *ret;
	495	+ struct nfsd_file *ret;
473	496
474	497	if (!f)
475	498	return NULL;
..	..	@@ -480,6 +503,17 @@
480	503	if (!ret)
481	504	ret = __nfs4_get_fd(f, O_RDONLY);
482	505	}
	506	+ spin_unlock(&f->fi_lock);
	507	+ return ret;
	508	+}
	509	+
	510	+static struct nfsd_file find_deleg_file(struct nfs4_file f)
	511	+{
	512	+ struct nfsd_file *ret = NULL;
	513	+
	514	+ spin_lock(&f->fi_lock);
	515	+ if (f->fi_deleg_file)
	516	+ ret = nfsd_file_get(f->fi_deleg_file);
483	517	spin_unlock(&f->fi_lock);
484	518	return ret;
485	519	}
..	..	@@ -572,17 +606,17 @@
572	606	might_lock(&fp->fi_lock);
573	607
574	608	if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
575		- struct file *f1 = NULL;
576		- struct file *f2 = NULL;
	609	+ struct nfsd_file *f1 = NULL;
	610	+ struct nfsd_file *f2 = NULL;
577	611
578	612	swap(f1, fp->fi_fds[oflag]);
579	613	if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
580	614	swap(f2, fp->fi_fds[O_RDWR]);
581	615	spin_unlock(&fp->fi_lock);
582	616	if (f1)
583		- fput(f1);
	617	+ nfsd_file_put(f1);
584	618	if (f2)
585		- fput(f2);
	619	+ nfsd_file_put(f2);
586	620	}
587	621	}
588	622
..	..	@@ -688,7 +722,8 @@
688	722
689	723	idr_preload(GFP_KERNEL);
690	724	spin_lock(&cl->cl_lock);
691		- new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 0, 0, GFP_NOWAIT);
	725	+ /* Reserving 0 for start of file in nfsdfs "states" file: */
	726	+ new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 1, 0, GFP_NOWAIT);
692	727	spin_unlock(&cl->cl_lock);
693	728	idr_preload_end();
694	729	if (new_id < 0)
..	..	@@ -701,6 +736,7 @@
701	736	/* Will be incremented before return to client: */
702	737	refcount_set(&stid->sc_count, 1);
703	738	spin_lock_init(&stid->sc_lock);
	739	+ INIT_LIST_HEAD(&stid->sc_cp_list);
704	740
705	741	/*
706	742	* It shouldn't be a problem to reuse an opaque stateid value.
..	..	@@ -717,6 +753,83 @@
717	753	return NULL;
718	754	}
719	755
	756	+/*
	757	+ * Create a unique stateid_t to represent each COPY.
	758	+ */
	759	+static int nfs4_init_cp_state(struct nfsd_net nn, copy_stateid_t stid,
	760	+ unsigned char sc_type)
	761	+{
	762	+ int new_id;
	763	+
	764	+ stid->stid.si_opaque.so_clid.cl_boot = (u32)nn->boot_time;
	765	+ stid->stid.si_opaque.so_clid.cl_id = nn->s2s_cp_cl_id;
	766	+ stid->sc_type = sc_type;
	767	+
	768	+ idr_preload(GFP_KERNEL);
	769	+ spin_lock(&nn->s2s_cp_lock);
	770	+ new_id = idr_alloc_cyclic(&nn->s2s_cp_stateids, stid, 0, 0, GFP_NOWAIT);
	771	+ stid->stid.si_opaque.so_id = new_id;
	772	+ stid->stid.si_generation = 1;
	773	+ spin_unlock(&nn->s2s_cp_lock);
	774	+ idr_preload_end();
	775	+ if (new_id < 0)
	776	+ return 0;
	777	+ return 1;
	778	+}
	779	+
	780	+int nfs4_init_copy_state(struct nfsd_net nn, struct nfsd4_copy copy)
	781	+{
	782	+ return nfs4_init_cp_state(nn, &copy->cp_stateid, NFS4_COPY_STID);
	783	+}
	784	+
	785	+struct nfs4_cpntf_state nfs4_alloc_init_cpntf_state(struct nfsd_net nn,
	786	+ struct nfs4_stid *p_stid)
	787	+{
	788	+ struct nfs4_cpntf_state *cps;
	789	+
	790	+ cps = kzalloc(sizeof(struct nfs4_cpntf_state), GFP_KERNEL);
	791	+ if (!cps)
	792	+ return NULL;
	793	+ cps->cpntf_time = ktime_get_boottime_seconds();
	794	+ refcount_set(&cps->cp_stateid.sc_count, 1);
	795	+ if (!nfs4_init_cp_state(nn, &cps->cp_stateid, NFS4_COPYNOTIFY_STID))
	796	+ goto out_free;
	797	+ spin_lock(&nn->s2s_cp_lock);
	798	+ list_add(&cps->cp_list, &p_stid->sc_cp_list);
	799	+ spin_unlock(&nn->s2s_cp_lock);
	800	+ return cps;
	801	+out_free:
	802	+ kfree(cps);
	803	+ return NULL;
	804	+}
	805	+
	806	+void nfs4_free_copy_state(struct nfsd4_copy *copy)
	807	+{
	808	+ struct nfsd_net *nn;
	809	+
	810	+ WARN_ON_ONCE(copy->cp_stateid.sc_type != NFS4_COPY_STID);
	811	+ nn = net_generic(copy->cp_clp->net, nfsd_net_id);
	812	+ spin_lock(&nn->s2s_cp_lock);
	813	+ idr_remove(&nn->s2s_cp_stateids,
	814	+ copy->cp_stateid.stid.si_opaque.so_id);
	815	+ spin_unlock(&nn->s2s_cp_lock);
	816	+}
	817	+
	818	+static void nfs4_free_cpntf_statelist(struct net net, struct nfs4_stid stid)
	819	+{
	820	+ struct nfs4_cpntf_state *cps;
	821	+ struct nfsd_net *nn;
	822	+
	823	+ nn = net_generic(net, nfsd_net_id);
	824	+ spin_lock(&nn->s2s_cp_lock);
	825	+ while (!list_empty(&stid->sc_cp_list)) {
	826	+ cps = list_first_entry(&stid->sc_cp_list,
	827	+ struct nfs4_cpntf_state, cp_list);
	828	+ _free_cpntf_state_locked(nn, cps);
	829	+ }
	830	+ spin_unlock(&nn->s2s_cp_lock);
	831	+}
	832	+
720	833	static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
721	834	{
722	835	struct nfs4_stid *stid;
..	..	@@ -730,6 +843,7 @@
730	843
731	844	static void nfs4_free_deleg(struct nfs4_stid *stid)
732	845	{
	846	+ WARN_ON(!list_empty(&stid->sc_cp_list));
733	847	kmem_cache_free(deleg_slab, stid);
734	848	atomic_long_dec(&num_delegations);
735	849	}
..	..	@@ -755,7 +869,7 @@
755	869	static DEFINE_SPINLOCK(blocked_delegations_lock);
756	870	static struct bloom_pair {
757	871	int entries, old_entries;
758		- time_t swap_time;
	872	+ time64_t swap_time;
759	873	int new; /* index into 'set' */
760	874	DECLARE_BITMAP(set[2], 256);
761	875	} blocked_delegations;
..	..	@@ -767,15 +881,15 @@
767	881
768	882	if (bd->entries == 0)
769	883	return 0;
770		- if (seconds_since_boot() - bd->swap_time > 30) {
	884	+ if (ktime_get_seconds() - bd->swap_time > 30) {
771	885	spin_lock(&blocked_delegations_lock);
772		- if (seconds_since_boot() - bd->swap_time > 30) {
	886	+ if (ktime_get_seconds() - bd->swap_time > 30) {
773	887	bd->entries -= bd->old_entries;
774	888	bd->old_entries = bd->entries;
775	889	memset(bd->set[bd->new], 0,
776	890	sizeof(bd->set[0]));
777	891	bd->new = 1-bd->new;
778		- bd->swap_time = seconds_since_boot();
	892	+ bd->swap_time = ktime_get_seconds();
779	893	}
780	894	spin_unlock(&blocked_delegations_lock);
781	895	}
..	..	@@ -805,7 +919,7 @@
805	919	__set_bit((hash>>8)&255, bd->set[bd->new]);
806	920	__set_bit((hash>>16)&255, bd->set[bd->new]);
807	921	if (bd->entries == 0)
808		- bd->swap_time = seconds_since_boot();
	922	+ bd->swap_time = ktime_get_seconds();
809	923	bd->entries += 1;
810	924	spin_unlock(&blocked_delegations_lock);
811	925	}
..	..	@@ -864,6 +978,7 @@
864	978	return;
865	979	}
866	980	idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
	981	+ nfs4_free_cpntf_statelist(clp->net, s);
867	982	spin_unlock(&clp->cl_lock);
868	983	s->sc_free(s);
869	984	if (fp)
..	..	@@ -884,25 +999,25 @@
884	999
885	1000	static void put_deleg_file(struct nfs4_file *fp)
886	1001	{
887		- struct file *filp = NULL;
	1002	+ struct nfsd_file *nf = NULL;
888	1003
889	1004	spin_lock(&fp->fi_lock);
890	1005	if (--fp->fi_delegees == 0)
891		- swap(filp, fp->fi_deleg_file);
	1006	+ swap(nf, fp->fi_deleg_file);
892	1007	spin_unlock(&fp->fi_lock);
893	1008
894		- if (filp)
895		- fput(filp);
	1009	+ if (nf)
	1010	+ nfsd_file_put(nf);
896	1011	}
897	1012
898	1013	static void nfs4_unlock_deleg_lease(struct nfs4_delegation *dp)
899	1014	{
900	1015	struct nfs4_file *fp = dp->dl_stid.sc_file;
901		- struct file *filp = fp->fi_deleg_file;
	1016	+ struct nfsd_file *nf = fp->fi_deleg_file;
902	1017
903	1018	WARN_ON_ONCE(!fp->fi_delegees);
904	1019
905		- vfs_setlease(filp, F_UNLCK, NULL, (void **)&dp);
	1020	+ vfs_setlease(nf->nf_file, F_UNLCK, NULL, (void **)&dp);
906	1021	put_deleg_file(fp);
907	1022	}
908	1023
..	..	@@ -1037,9 +1152,9 @@
1037	1152	return id & CLIENT_HASH_MASK;
1038	1153	}
1039	1154
1040		-static unsigned int clientstr_hashval(const char *name)
	1155	+static unsigned int clientstr_hashval(struct xdr_netobj name)
1041	1156	{
1042		- return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
	1157	+ return opaque_hashval(name.data, 8) & CLIENT_HASH_MASK;
1043	1158	}
1044	1159
1045	1160	/*
..	..	@@ -1244,6 +1359,7 @@
1244	1359	release_all_access(stp);
1245	1360	if (stp->st_stateowner)
1246	1361	nfs4_put_stateowner(stp->st_stateowner);
	1362	+ WARN_ON(!list_empty(&stid->sc_cp_list));
1247	1363	kmem_cache_free(stateid_slab, stid);
1248	1364	}
1249	1365
..	..	@@ -1251,11 +1367,14 @@
1251	1367	{
1252	1368	struct nfs4_ol_stateid *stp = openlockstateid(stid);
1253	1369	struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
1254		- struct file *file;
	1370	+ struct nfsd_file *nf;
1255	1371
1256		- file = find_any_file(stp->st_stid.sc_file);
1257		- if (file)
1258		- filp_close(file, (fl_owner_t)lo);
	1372	+ nf = find_any_file(stp->st_stid.sc_file);
	1373	+ if (nf) {
	1374	+ get_file(nf->nf_file);
	1375	+ filp_close(nf->nf_file, (fl_owner_t)lo);
	1376	+ nfsd_file_put(nf);
	1377	+ }
1259	1378	nfs4_free_ol_stateid(stid);
1260	1379	}
1261	1380
..	..	@@ -1526,21 +1645,39 @@
1526	1645	* re-negotiate active sessions and reduce their slot usage to make
1527	1646	* room for new connections. For now we just fail the create session.
1528	1647	*/
1529		-static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
	1648	+static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs ca, struct nfsd_net nn)
1530	1649	{
1531	1650	u32 slotsize = slot_bytes(ca);
1532	1651	u32 num = ca->maxreqs;
1533	1652	unsigned long avail, total_avail;
	1653	+ unsigned int scale_factor;
1534	1654
1535	1655	spin_lock(&nfsd_drc_lock);
1536		- total_avail = nfsd_drc_max_mem - nfsd_drc_mem_used;
	1656	+ if (nfsd_drc_max_mem > nfsd_drc_mem_used)
	1657	+ total_avail = nfsd_drc_max_mem - nfsd_drc_mem_used;
	1658	+ else
	1659	+ /* We have handed out more space than we chose in
	1660	+ * set_max_drc() to allow. That isn't really a
	1661	+ * problem as long as that doesn't make us think we
	1662	+ * have lots more due to integer overflow.
	1663	+ */
	1664	+ total_avail = 0;
1537	1665	avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION, total_avail);
1538	1666	/*
1539		- * Never use more than a third of the remaining memory,
1540		- * unless it's the only way to give this client a slot:
	1667	+ * Never use more than a fraction of the remaining memory,
	1668	+ * unless it's the only way to give this client a slot.
	1669	+ * The chosen fraction is either 1/8 or 1/number of threads,
	1670	+ * whichever is smaller. This ensures there are adequate
	1671	+ * slots to support multiple clients per thread.
	1672	+ * Give the client one slot even if that would require
	1673	+ * over-allocation--it is better than failure.
1541	1674	*/
1542		- avail = clamp_t(unsigned long, avail, slotsize, total_avail/3);
	1675	+ scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads);
	1676	+
	1677	+ avail = clamp_t(unsigned long, avail, slotsize,
	1678	+ total_avail/scale_factor);
1543	1679	num = min_t(int, num, avail / slotsize);
	1680	+ num = max_t(int, num, 1);
1544	1681	nfsd_drc_mem_used += num * slotsize;
1545	1682	spin_unlock(&nfsd_drc_lock);
1546	1683
..	..	@@ -1802,8 +1939,7 @@
1802	1939	*/
1803	1940	if (clid->cl_boot == (u32)nn->boot_time)
1804	1941	return 0;
1805		- dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1806		- clid->cl_boot, clid->cl_id, nn->boot_time);
	1942	+ trace_nfsd_clid_stale(clid);
1807	1943	return 1;
1808	1944	}
1809	1945
..	..	@@ -1820,7 +1956,7 @@
1820	1956	clp = kmem_cache_zalloc(client_slab, GFP_KERNEL);
1821	1957	if (clp == NULL)
1822	1958	return NULL;
1823		- clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
	1959	+ xdr_netobj_dup(&clp->cl_name, &name, GFP_KERNEL);
1824	1960	if (clp->cl_name.data == NULL)
1825	1961	goto err_no_name;
1826	1962	clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE,
..	..	@@ -1830,10 +1966,9 @@
1830	1966	goto err_no_hashtbl;
1831	1967	for (i = 0; i < OWNER_HASH_SIZE; i++)
1832	1968	INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
1833		- clp->cl_name.len = name.len;
1834	1969	INIT_LIST_HEAD(&clp->cl_sessions);
1835	1970	idr_init(&clp->cl_stateids);
1836		- atomic_set(&clp->cl_refcount, 0);
	1971	+ atomic_set(&clp->cl_rpc_users, 0);
1837	1972	clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1838	1973	INIT_LIST_HEAD(&clp->cl_idhash);
1839	1974	INIT_LIST_HEAD(&clp->cl_openowners);
..	..	@@ -1843,6 +1978,8 @@
1843	1978	#ifdef CONFIG_NFSD_PNFS
1844	1979	INIT_LIST_HEAD(&clp->cl_lo_states);
1845	1980	#endif
	1981	+ INIT_LIST_HEAD(&clp->async_copies);
	1982	+ spin_lock_init(&clp->async_lock);
1846	1983	spin_lock_init(&clp->cl_lock);
1847	1984	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1848	1985	return clp;
..	..	@@ -1851,6 +1988,25 @@
1851	1988	err_no_name:
1852	1989	kmem_cache_free(client_slab, clp);
1853	1990	return NULL;
	1991	+}
	1992	+
	1993	+static void __free_client(struct kref *k)
	1994	+{
	1995	+ struct nfsdfs_client *c = container_of(k, struct nfsdfs_client, cl_ref);
	1996	+ struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs);
	1997	+
	1998	+ free_svc_cred(&clp->cl_cred);
	1999	+ kfree(clp->cl_ownerstr_hashtbl);
	2000	+ kfree(clp->cl_name.data);
	2001	+ kfree(clp->cl_nii_domain.data);
	2002	+ kfree(clp->cl_nii_name.data);
	2003	+ idr_destroy(&clp->cl_stateids);
	2004	+ kmem_cache_free(client_slab, clp);
	2005	+}
	2006	+
	2007	+static void drop_client(struct nfs4_client *clp)
	2008	+{
	2009	+ kref_put(&clp->cl_nfsdfs.cl_ref, __free_client);
1854	2010	}
1855	2011
1856	2012	static void
..	..	@@ -1865,11 +2021,12 @@
1865	2021	free_session(ses);
1866	2022	}
1867	2023	rpc_destroy_wait_queue(&clp->cl_cb_waitq);
1868		- free_svc_cred(&clp->cl_cred);
1869		- kfree(clp->cl_ownerstr_hashtbl);
1870		- kfree(clp->cl_name.data);
1871		- idr_destroy(&clp->cl_stateids);
1872		- kmem_cache_free(client_slab, clp);
	2024	+ if (clp->cl_nfsd_dentry) {
	2025	+ nfsd_client_rmdir(clp->cl_nfsd_dentry);
	2026	+ clp->cl_nfsd_dentry = NULL;
	2027	+ wake_up_all(&expiry_wq);
	2028	+ }
	2029	+ drop_client(clp);
1873	2030	}
1874	2031
1875	2032	/* must be called under the client_lock */
..	..	@@ -1910,7 +2067,7 @@
1910	2067
1911	2068	static __be32 mark_client_expired_locked(struct nfs4_client *clp)
1912	2069	{
1913		- if (atomic_read(&clp->cl_refcount))
	2070	+ if (atomic_read(&clp->cl_rpc_users))
1914	2071	return nfserr_jukebox;
1915	2072	unhash_client_locked(clp);
1916	2073	return nfs_ok;
..	..	@@ -1958,10 +2115,12 @@
1958	2115	}
1959	2116	}
1960	2117	nfsd4_return_all_client_layouts(clp);
	2118	+ nfsd4_shutdown_copy(clp);
1961	2119	nfsd4_shutdown_callback(clp);
1962	2120	if (clp->cl_cb_conn.cb_xprt)
1963	2121	svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1964	2122	free_client(clp);
	2123	+ wake_up_all(&expiry_wq);
1965	2124	}
1966	2125
1967	2126	static void
..	..	@@ -1969,6 +2128,22 @@
1969	2128	{
1970	2129	unhash_client(clp);
1971	2130	__destroy_client(clp);
	2131	+}
	2132	+
	2133	+static void inc_reclaim_complete(struct nfs4_client *clp)
	2134	+{
	2135	+ struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
	2136	+
	2137	+ if (!nn->track_reclaim_completes)
	2138	+ return;
	2139	+ if (!nfsd4_find_reclaim_client(clp->cl_name, nn))
	2140	+ return;
	2141	+ if (atomic_inc_return(&nn->nr_reclaim_complete) ==
	2142	+ nn->reclaim_str_hashtbl_size) {
	2143	+ printk(KERN_INFO "NFSD: all clients done reclaiming, ending NFSv4 grace period (net %x)\n",
	2144	+ clp->net->ns.inum);
	2145	+ nfsd4_end_grace(nn);
	2146	+ }
1972	2147	}
1973	2148
1974	2149	static void expire_client(struct nfs4_client *clp)
..	..	@@ -2020,11 +2195,6 @@
2020	2195	if (o1->len > o2->len)
2021	2196	return 1;
2022	2197	return memcmp(o1->data, o2->data, o1->len);
2023		-}
2024		-
2025		-static int same_name(const char n1, const char n2)
2026		-{
2027		- return 0 == memcmp(n1, n2, HEXDIR_LEN);
2028	2198	}
2029	2199
2030	2200	static int
..	..	@@ -2121,14 +2291,14 @@
2121	2291	* This is opaque to client, so no need to byte-swap. Use
2122	2292	* __force to keep sparse happy
2123	2293	*/
2124		- verf[0] = (__force __be32)get_seconds();
	2294	+ verf[0] = (__force __be32)(u32)ktime_get_real_seconds();
2125	2295	verf[1] = (__force __be32)nn->clverifier_counter++;
2126	2296	memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
2127	2297	}
2128	2298
2129	2299	static void gen_clid(struct nfs4_client clp, struct nfsd_net nn)
2130	2300	{
2131		- clp->cl_clientid.cl_boot = nn->boot_time;
	2301	+ clp->cl_clientid.cl_boot = (u32)nn->boot_time;
2132	2302	clp->cl_clientid.cl_id = nn->clientid_counter++;
2133	2303	gen_confirm(clp, nn);
2134	2304	}
..	..	@@ -2161,6 +2331,376 @@
2161	2331	return s;
2162	2332	}
2163	2333
	2334	+static struct nfs4_client get_nfsdfs_clp(struct inode inode)
	2335	+{
	2336	+ struct nfsdfs_client *nc;
	2337	+ nc = get_nfsdfs_client(inode);
	2338	+ if (!nc)
	2339	+ return NULL;
	2340	+ return container_of(nc, struct nfs4_client, cl_nfsdfs);
	2341	+}
	2342	+
	2343	+static void seq_quote_mem(struct seq_file m, char data, int len)
	2344	+{
	2345	+ seq_printf(m, "\"");
	2346	+ seq_escape_mem_ascii(m, data, len);
	2347	+ seq_printf(m, "\"");
	2348	+}
	2349	+
	2350	+static int client_info_show(struct seq_file m, void v)
	2351	+{
	2352	+ struct inode *inode = m->private;
	2353	+ struct nfs4_client *clp;
	2354	+ u64 clid;
	2355	+
	2356	+ clp = get_nfsdfs_clp(inode);
	2357	+ if (!clp)
	2358	+ return -ENXIO;
	2359	+ memcpy(&clid, &clp->cl_clientid, sizeof(clid));
	2360	+ seq_printf(m, "clientid: 0x%llx\n", clid);
	2361	+ seq_printf(m, "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr);
	2362	+ seq_printf(m, "name: ");
	2363	+ seq_quote_mem(m, clp->cl_name.data, clp->cl_name.len);
	2364	+ seq_printf(m, "\nminor version: %d\n", clp->cl_minorversion);
	2365	+ if (clp->cl_nii_domain.data) {
	2366	+ seq_printf(m, "Implementation domain: ");
	2367	+ seq_quote_mem(m, clp->cl_nii_domain.data,
	2368	+ clp->cl_nii_domain.len);
	2369	+ seq_printf(m, "\nImplementation name: ");
	2370	+ seq_quote_mem(m, clp->cl_nii_name.data, clp->cl_nii_name.len);
	2371	+ seq_printf(m, "\nImplementation time: [%lld, %ld]\n",
	2372	+ clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec);
	2373	+ }
	2374	+ drop_client(clp);
	2375	+
	2376	+ return 0;
	2377	+}
	2378	+
	2379	+static int client_info_open(struct inode inode, struct file file)
	2380	+{
	2381	+ return single_open(file, client_info_show, inode);
	2382	+}
	2383	+
	2384	+static const struct file_operations client_info_fops = {
	2385	+ .open = client_info_open,
	2386	+ .read = seq_read,
	2387	+ .llseek = seq_lseek,
	2388	+ .release = single_release,
	2389	+};
	2390	+
	2391	+static void states_start(struct seq_file s, loff_t *pos)
	2392	+ __acquires(&clp->cl_lock)
	2393	+{
	2394	+ struct nfs4_client *clp = s->private;
	2395	+ unsigned long id = *pos;
	2396	+ void *ret;
	2397	+
	2398	+ spin_lock(&clp->cl_lock);
	2399	+ ret = idr_get_next_ul(&clp->cl_stateids, &id);
	2400	+ *pos = id;
	2401	+ return ret;
	2402	+}
	2403	+
	2404	+static void states_next(struct seq_file s, void v, loff_t pos)
	2405	+{
	2406	+ struct nfs4_client *clp = s->private;
	2407	+ unsigned long id = *pos;
	2408	+ void *ret;
	2409	+
	2410	+ id = *pos;
	2411	+ id++;
	2412	+ ret = idr_get_next_ul(&clp->cl_stateids, &id);
	2413	+ *pos = id;
	2414	+ return ret;
	2415	+}
	2416	+
	2417	+static void states_stop(struct seq_file s, void v)
	2418	+ __releases(&clp->cl_lock)
	2419	+{
	2420	+ struct nfs4_client *clp = s->private;
	2421	+
	2422	+ spin_unlock(&clp->cl_lock);
	2423	+}
	2424	+
	2425	+static void nfs4_show_fname(struct seq_file s, struct nfsd_file f)
	2426	+{
	2427	+ seq_printf(s, "filename: \"%pD2\"", f->nf_file);
	2428	+}
	2429	+
	2430	+static void nfs4_show_superblock(struct seq_file s, struct nfsd_file f)
	2431	+{
	2432	+ struct inode *inode = f->nf_inode;
	2433	+
	2434	+ seq_printf(s, "superblock: \"%02x:%02x:%ld\"",
	2435	+ MAJOR(inode->i_sb->s_dev),
	2436	+ MINOR(inode->i_sb->s_dev),
	2437	+ inode->i_ino);
	2438	+}
	2439	+
	2440	+static void nfs4_show_owner(struct seq_file s, struct nfs4_stateowner oo)
	2441	+{
	2442	+ seq_printf(s, "owner: ");
	2443	+ seq_quote_mem(s, oo->so_owner.data, oo->so_owner.len);
	2444	+}
	2445	+
	2446	+static void nfs4_show_stateid(struct seq_file s, stateid_t stid)
	2447	+{
	2448	+ seq_printf(s, "0x%.8x", stid->si_generation);
	2449	+ seq_printf(s, "%12phN", &stid->si_opaque);
	2450	+}
	2451	+
	2452	+static int nfs4_show_open(struct seq_file s, struct nfs4_stid st)
	2453	+{
	2454	+ struct nfs4_ol_stateid *ols;
	2455	+ struct nfs4_file *nf;
	2456	+ struct nfsd_file *file;
	2457	+ struct nfs4_stateowner *oo;
	2458	+ unsigned int access, deny;
	2459	+
	2460	+ if (st->sc_type != NFS4_OPEN_STID && st->sc_type != NFS4_LOCK_STID)
	2461	+ return 0; /* XXX: or SEQ_SKIP? */
	2462	+ ols = openlockstateid(st);
	2463	+ oo = ols->st_stateowner;
	2464	+ nf = st->sc_file;
	2465	+ file = find_any_file(nf);
	2466	+ if (!file)
	2467	+ return 0;
	2468	+
	2469	+ seq_printf(s, "- ");
	2470	+ nfs4_show_stateid(s, &st->sc_stateid);
	2471	+ seq_printf(s, ": { type: open, ");
	2472	+
	2473	+ access = bmap_to_share_mode(ols->st_access_bmap);
	2474	+ deny = bmap_to_share_mode(ols->st_deny_bmap);
	2475	+
	2476	+ seq_printf(s, "access: %s%s, ",
	2477	+ access & NFS4_SHARE_ACCESS_READ ? "r" : "-",
	2478	+ access & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
	2479	+ seq_printf(s, "deny: %s%s, ",
	2480	+ deny & NFS4_SHARE_ACCESS_READ ? "r" : "-",
	2481	+ deny & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
	2482	+
	2483	+ nfs4_show_superblock(s, file);
	2484	+ seq_printf(s, ", ");
	2485	+ nfs4_show_fname(s, file);
	2486	+ seq_printf(s, ", ");
	2487	+ nfs4_show_owner(s, oo);
	2488	+ seq_printf(s, " }\n");
	2489	+ nfsd_file_put(file);
	2490	+
	2491	+ return 0;
	2492	+}
	2493	+
	2494	+static int nfs4_show_lock(struct seq_file s, struct nfs4_stid st)
	2495	+{
	2496	+ struct nfs4_ol_stateid *ols;
	2497	+ struct nfs4_file *nf;
	2498	+ struct nfsd_file *file;
	2499	+ struct nfs4_stateowner *oo;
	2500	+
	2501	+ ols = openlockstateid(st);
	2502	+ oo = ols->st_stateowner;
	2503	+ nf = st->sc_file;
	2504	+ file = find_any_file(nf);
	2505	+ if (!file)
	2506	+ return 0;
	2507	+
	2508	+ seq_printf(s, "- ");
	2509	+ nfs4_show_stateid(s, &st->sc_stateid);
	2510	+ seq_printf(s, ": { type: lock, ");
	2511	+
	2512	+ /*
	2513	+ * Note: a lock stateid isn't really the same thing as a lock,
	2514	+ * it's the locking state held by one owner on a file, and there
	2515	+ * may be multiple (or no) lock ranges associated with it.
	2516	+ * (Same for the matter is true of open stateids.)
	2517	+ */
	2518	+
	2519	+ nfs4_show_superblock(s, file);
	2520	+ /* XXX: open stateid? */
	2521	+ seq_printf(s, ", ");
	2522	+ nfs4_show_fname(s, file);
	2523	+ seq_printf(s, ", ");
	2524	+ nfs4_show_owner(s, oo);
	2525	+ seq_printf(s, " }\n");
	2526	+ nfsd_file_put(file);
	2527	+
	2528	+ return 0;
	2529	+}
	2530	+
	2531	+static int nfs4_show_deleg(struct seq_file s, struct nfs4_stid st)
	2532	+{
	2533	+ struct nfs4_delegation *ds;
	2534	+ struct nfs4_file *nf;
	2535	+ struct nfsd_file *file;
	2536	+
	2537	+ ds = delegstateid(st);
	2538	+ nf = st->sc_file;
	2539	+ file = find_deleg_file(nf);
	2540	+ if (!file)
	2541	+ return 0;
	2542	+
	2543	+ seq_printf(s, "- ");
	2544	+ nfs4_show_stateid(s, &st->sc_stateid);
	2545	+ seq_printf(s, ": { type: deleg, ");
	2546	+
	2547	+ /* Kinda dead code as long as we only support read delegs: */
	2548	+ seq_printf(s, "access: %s, ",
	2549	+ ds->dl_type == NFS4_OPEN_DELEGATE_READ ? "r" : "w");
	2550	+
	2551	+ /* XXX: lease time, whether it's being recalled. */
	2552	+
	2553	+ nfs4_show_superblock(s, file);
	2554	+ seq_printf(s, ", ");
	2555	+ nfs4_show_fname(s, file);
	2556	+ seq_printf(s, " }\n");
	2557	+ nfsd_file_put(file);
	2558	+
	2559	+ return 0;
	2560	+}
	2561	+
	2562	+static int nfs4_show_layout(struct seq_file s, struct nfs4_stid st)
	2563	+{
	2564	+ struct nfs4_layout_stateid *ls;
	2565	+ struct nfsd_file *file;
	2566	+
	2567	+ ls = container_of(st, struct nfs4_layout_stateid, ls_stid);
	2568	+ file = ls->ls_file;
	2569	+
	2570	+ seq_printf(s, "- ");
	2571	+ nfs4_show_stateid(s, &st->sc_stateid);
	2572	+ seq_printf(s, ": { type: layout, ");
	2573	+
	2574	+ /* XXX: What else would be useful? */
	2575	+
	2576	+ nfs4_show_superblock(s, file);
	2577	+ seq_printf(s, ", ");
	2578	+ nfs4_show_fname(s, file);
	2579	+ seq_printf(s, " }\n");
	2580	+
	2581	+ return 0;
	2582	+}
	2583	+
	2584	+static int states_show(struct seq_file s, void v)
	2585	+{
	2586	+ struct nfs4_stid *st = v;
	2587	+
	2588	+ switch (st->sc_type) {
	2589	+ case NFS4_OPEN_STID:
	2590	+ return nfs4_show_open(s, st);
	2591	+ case NFS4_LOCK_STID:
	2592	+ return nfs4_show_lock(s, st);
	2593	+ case NFS4_DELEG_STID:
	2594	+ return nfs4_show_deleg(s, st);
	2595	+ case NFS4_LAYOUT_STID:
	2596	+ return nfs4_show_layout(s, st);
	2597	+ default:
	2598	+ return 0; /* XXX: or SEQ_SKIP? */
	2599	+ }
	2600	+ /* XXX: copy stateids? */
	2601	+}
	2602	+
	2603	+static struct seq_operations states_seq_ops = {
	2604	+ .start = states_start,
	2605	+ .next = states_next,
	2606	+ .stop = states_stop,
	2607	+ .show = states_show
	2608	+};
	2609	+
	2610	+static int client_states_open(struct inode inode, struct file file)
	2611	+{
	2612	+ struct seq_file *s;
	2613	+ struct nfs4_client *clp;
	2614	+ int ret;
	2615	+
	2616	+ clp = get_nfsdfs_clp(inode);
	2617	+ if (!clp)
	2618	+ return -ENXIO;
	2619	+
	2620	+ ret = seq_open(file, &states_seq_ops);
	2621	+ if (ret)
	2622	+ return ret;
	2623	+ s = file->private_data;
	2624	+ s->private = clp;
	2625	+ return 0;
	2626	+}
	2627	+
	2628	+static int client_opens_release(struct inode inode, struct file file)
	2629	+{
	2630	+ struct seq_file *m = file->private_data;
	2631	+ struct nfs4_client *clp = m->private;
	2632	+
	2633	+ /* XXX: alternatively, we could get/drop in seq start/stop */
	2634	+ drop_client(clp);
	2635	+ return 0;
	2636	+}
	2637	+
	2638	+static const struct file_operations client_states_fops = {
	2639	+ .open = client_states_open,
	2640	+ .read = seq_read,
	2641	+ .llseek = seq_lseek,
	2642	+ .release = client_opens_release,
	2643	+};
	2644	+
	2645	+/*
	2646	+ * Normally we refuse to destroy clients that are in use, but here the
	2647	+ * administrator is telling us to just do it. We also want to wait
	2648	+ * so the caller has a guarantee that the client's locks are gone by
	2649	+ * the time the write returns:
	2650	+ */
	2651	+static void force_expire_client(struct nfs4_client *clp)
	2652	+{
	2653	+ struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
	2654	+ bool already_expired;
	2655	+
	2656	+ spin_lock(&nn->client_lock);
	2657	+ clp->cl_time = 0;
	2658	+ spin_unlock(&nn->client_lock);
	2659	+
	2660	+ wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0);
	2661	+ spin_lock(&nn->client_lock);
	2662	+ already_expired = list_empty(&clp->cl_lru);
	2663	+ if (!already_expired)
	2664	+ unhash_client_locked(clp);
	2665	+ spin_unlock(&nn->client_lock);
	2666	+
	2667	+ if (!already_expired)
	2668	+ expire_client(clp);
	2669	+ else
	2670	+ wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL);
	2671	+}
	2672	+
	2673	+static ssize_t client_ctl_write(struct file file, const char __user buf,
	2674	+ size_t size, loff_t *pos)
	2675	+{
	2676	+ char *data;
	2677	+ struct nfs4_client *clp;
	2678	+
	2679	+ data = simple_transaction_get(file, buf, size);
	2680	+ if (IS_ERR(data))
	2681	+ return PTR_ERR(data);
	2682	+ if (size != 7 \|\| 0 != memcmp(data, "expire\n", 7))
	2683	+ return -EINVAL;
	2684	+ clp = get_nfsdfs_clp(file_inode(file));
	2685	+ if (!clp)
	2686	+ return -ENXIO;
	2687	+ force_expire_client(clp);
	2688	+ drop_client(clp);
	2689	+ return 7;
	2690	+}
	2691	+
	2692	+static const struct file_operations client_ctl_fops = {
	2693	+ .write = client_ctl_write,
	2694	+ .release = simple_transaction_release,
	2695	+};
	2696	+
	2697	+static const struct tree_descr client_files[] = {
	2698	+ [0] = {"info", &client_info_fops, S_IRUSR},
	2699	+ [1] = {"states", &client_states_fops, S_IRUSR},
	2700	+ [2] = {"ctl", &client_ctl_fops, S_IWUSR},
	2701	+ [3] = {""},
	2702	+};
	2703	+
2164	2704	static struct nfs4_client *create_client(struct xdr_netobj name,
2165	2705	struct svc_rqst rqstp, nfs4_verifier verf)
2166	2706	{
..	..	@@ -2168,6 +2708,7 @@
2168	2708	struct sockaddr *sa = svc_addr(rqstp);
2169	2709	int ret;
2170	2710	struct net *net = SVC_NET(rqstp);
	2711	+ struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2171	2712
2172	2713	clp = alloc_client(name);
2173	2714	if (clp == NULL)
..	..	@@ -2178,13 +2719,22 @@
2178	2719	free_client(clp);
2179	2720	return NULL;
2180	2721	}
	2722	+ gen_clid(clp, nn);
	2723	+ kref_init(&clp->cl_nfsdfs.cl_ref);
2181	2724	nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
2182		- clp->cl_time = get_seconds();
	2725	+ clp->cl_time = ktime_get_boottime_seconds();
2183	2726	clear_bit(0, &clp->cl_cb_slot_busy);
2184	2727	copy_verf(clp, verf);
2185		- rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
	2728	+ memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage));
2186	2729	clp->cl_cb_session = NULL;
2187	2730	clp->net = net;
	2731	+ clp->cl_nfsd_dentry = nfsd_client_mkdir(nn, &clp->cl_nfsdfs,
	2732	+ clp->cl_clientid.cl_id - nn->clientid_base,
	2733	+ client_files);
	2734	+ if (!clp->cl_nfsd_dentry) {
	2735	+ free_client(clp);
	2736	+ return NULL;
	2737	+ }
2188	2738	return clp;
2189	2739	}
2190	2740
..	..	@@ -2345,14 +2895,12 @@
2345	2895	conn->cb_prog = se->se_callback_prog;
2346	2896	conn->cb_ident = se->se_callback_ident;
2347	2897	memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
	2898	+ trace_nfsd_cb_args(clp, conn);
2348	2899	return;
2349	2900	out_err:
2350	2901	conn->cb_addr.ss_family = AF_UNSPEC;
2351	2902	conn->cb_addrlen = 0;
2352		- dprintk("NFSD: this client (clientid %08x/%08x) "
2353		- "will not receive delegations\n",
2354		- clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
2355		-
	2903	+ trace_nfsd_cb_nodelegs(clp);
2356	2904	return;
2357	2905	}
2358	2906
..	..	@@ -2491,7 +3039,23 @@
2491	3039	\|\| !list_empty(&clp->cl_lo_states)
2492	3040	#endif
2493	3041	\|\| !list_empty(&clp->cl_delegations)
2494		- \|\| !list_empty(&clp->cl_sessions);
	3042	+ \|\| !list_empty(&clp->cl_sessions)
	3043	+ \|\| !list_empty(&clp->async_copies);
	3044	+}
	3045	+
	3046	+static __be32 copy_impl_id(struct nfs4_client *clp,
	3047	+ struct nfsd4_exchange_id *exid)
	3048	+{
	3049	+ if (!exid->nii_domain.data)
	3050	+ return 0;
	3051	+ xdr_netobj_dup(&clp->cl_nii_domain, &exid->nii_domain, GFP_KERNEL);
	3052	+ if (!clp->cl_nii_domain.data)
	3053	+ return nfserr_jukebox;
	3054	+ xdr_netobj_dup(&clp->cl_nii_name, &exid->nii_name, GFP_KERNEL);
	3055	+ if (!clp->cl_nii_name.data)
	3056	+ return nfserr_jukebox;
	3057	+ clp->cl_nii_time = exid->nii_time;
	3058	+ return 0;
2495	3059	}
2496	3060
2497	3061	__be32
..	..	@@ -2520,6 +3084,9 @@
2520	3084	new = create_client(exid->clname, rqstp, &verf);
2521	3085	if (new == NULL)
2522	3086	return nfserr_jukebox;
	3087	+ status = copy_impl_id(new, exid);
	3088	+ if (status)
	3089	+ goto out_nolock;
2523	3090
2524	3091	switch (exid->spa_how) {
2525	3092	case SP4_MACH_CRED:
..	..	@@ -2558,6 +3125,7 @@
2558	3125	break;
2559	3126	default: /* checked by xdr code */
2560	3127	WARN_ON_ONCE(1);
	3128	+ fallthrough;
2561	3129	case SP4_SSV:
2562	3130	status = nfserr_encr_alg_unsupp;
2563	3131	goto out_nolock;
..	..	@@ -2627,7 +3195,6 @@
2627	3195	new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
2628	3196	new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];
2629	3197
2630		- gen_clid(new, nn);
2631	3198	add_to_unconfirmed(new);
2632	3199	swap(new, conf);
2633	3200	out_copy:
..	..	@@ -2732,10 +3299,10 @@
2732	3299	* performance. When short on memory we therefore prefer to
2733	3300	* decrease number of slots instead of their size. Clients that
2734	3301	* request larger slots than they need will get poor results:
	3302	+ * Note that we always allow at least one slot, because our
	3303	+ * accounting is soft and provides no guarantees either way.
2735	3304	*/
2736		- ca->maxreqs = nfsd4_get_drc_mem(ca);
2737		- if (!ca->maxreqs)
2738		- return nfserr_jukebox;
	3305	+ ca->maxreqs = nfsd4_get_drc_mem(ca, nn);
2739	3306
2740	3307	return nfs_ok;
2741	3308	}
..	..	@@ -2913,7 +3480,7 @@
2913	3480	case NFS4_CDFC4_BACK_OR_BOTH:
2914	3481	*dir = NFS4_CDFC4_BOTH;
2915	3482	return nfs_ok;
2916		- };
	3483	+ }
2917	3484	return nfserr_inval;
2918	3485	}
2919	3486
..	..	@@ -2939,6 +3506,47 @@
2939	3506	return nfs_ok;
2940	3507	}
2941	3508
	3509	+static struct nfsd4_conn __nfsd4_find_conn(struct svc_xprt xpt, struct nfsd4_session *s)
	3510	+{
	3511	+ struct nfsd4_conn *c;
	3512	+
	3513	+ list_for_each_entry(c, &s->se_conns, cn_persession) {
	3514	+ if (c->cn_xprt == xpt) {
	3515	+ return c;
	3516	+ }
	3517	+ }
	3518	+ return NULL;
	3519	+}
	3520	+
	3521	+static __be32 nfsd4_match_existing_connection(struct svc_rqst *rqst,
	3522	+ struct nfsd4_session session, u32 req, struct nfsd4_conn *conn)
	3523	+{
	3524	+ struct nfs4_client *clp = session->se_client;
	3525	+ struct svc_xprt *xpt = rqst->rq_xprt;
	3526	+ struct nfsd4_conn *c;
	3527	+ __be32 status;
	3528	+
	3529	+ /* Following the last paragraph of RFC 5661 Section 18.34.3: */
	3530	+ spin_lock(&clp->cl_lock);
	3531	+ c = __nfsd4_find_conn(xpt, session);
	3532	+ if (!c)
	3533	+ status = nfserr_noent;
	3534	+ else if (req == c->cn_flags)
	3535	+ status = nfs_ok;
	3536	+ else if (req == NFS4_CDFC4_FORE_OR_BOTH &&
	3537	+ c->cn_flags != NFS4_CDFC4_BACK)
	3538	+ status = nfs_ok;
	3539	+ else if (req == NFS4_CDFC4_BACK_OR_BOTH &&
	3540	+ c->cn_flags != NFS4_CDFC4_FORE)
	3541	+ status = nfs_ok;
	3542	+ else
	3543	+ status = nfserr_inval;
	3544	+ spin_unlock(&clp->cl_lock);
	3545	+ if (status == nfs_ok && conn)
	3546	+ *conn = c;
	3547	+ return status;
	3548	+}
	3549	+
2942	3550	__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2943	3551	struct nfsd4_compound_state *cstate,
2944	3552	union nfsd4_op_u *u)
..	..	@@ -2959,6 +3567,17 @@
2959	3567	goto out_no_session;
2960	3568	status = nfserr_wrong_cred;
2961	3569	if (!nfsd4_mach_creds_match(session->se_client, rqstp))
	3570	+ goto out;
	3571	+ status = nfsd4_match_existing_connection(rqstp, session,
	3572	+ bcts->dir, &conn);
	3573	+ if (status == nfs_ok) {
	3574	+ if (bcts->dir == NFS4_CDFC4_FORE_OR_BOTH \|\|
	3575	+ bcts->dir == NFS4_CDFC4_BACK)
	3576	+ conn->cn_flags \|= NFS4_CDFC4_BACK;
	3577	+ nfsd4_probe_callback(session->se_client);
	3578	+ goto out;
	3579	+ }
	3580	+ if (status == nfserr_inval)
2962	3581	goto out;
2963	3582	status = nfsd4_map_bcts_dir(&bcts->dir);
2964	3583	if (status)
..	..	@@ -3023,18 +3642,6 @@
3023	3642	spin_unlock(&nn->client_lock);
3024	3643	out:
3025	3644	return status;
3026		-}
3027		-
3028		-static struct nfsd4_conn __nfsd4_find_conn(struct svc_xprt xpt, struct nfsd4_session *s)
3029		-{
3030		- struct nfsd4_conn *c;
3031		-
3032		- list_for_each_entry(c, &s->se_conns, cn_persession) {
3033		- if (c->cn_xprt == xpt) {
3034		- return c;
3035		- }
3036		- }
3037		- return NULL;
3038	3645	}
3039	3646
3040	3647	static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn new, struct nfsd4_session ses)
..	..	@@ -3331,6 +3938,7 @@
3331	3938
3332	3939	status = nfs_ok;
3333	3940	nfsd4_client_record_create(cstate->session->se_client);
	3941	+ inc_reclaim_complete(cstate->session->se_client);
3334	3942	out:
3335	3943	return status;
3336	3944	}
..	..	@@ -3359,23 +3967,18 @@
3359	3967	if (clp_used_exchangeid(conf))
3360	3968	goto out;
3361	3969	if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
3362		- char addr_str[INET6_ADDRSTRLEN];
3363		- rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
3364		- sizeof(addr_str));
3365		- dprintk("NFSD: setclientid: string in use by client "
3366		- "at %s\n", addr_str);
	3970	+ trace_nfsd_clid_inuse_err(conf);
3367	3971	goto out;
3368	3972	}
3369	3973	}
3370	3974	unconf = find_unconfirmed_client_by_name(&clname, nn);
3371	3975	if (unconf)
3372	3976	unhash_client_locked(unconf);
	3977	+ /* We need to handle only case 1: probable callback update */
3373	3978	if (conf && same_verf(&conf->cl_verifier, &clverifier)) {
3374		- /* case 1: probable callback update */
3375	3979	copy_clid(new, conf);
3376	3980	gen_confirm(new, nn);
3377		- } else /* case 4 (new client) or cases 2, 3 (client reboot): */
3378		- gen_clid(new, nn);
	3981	+ }
3379	3982	new->cl_minorversion = 0;
3380	3983	gen_callback(new, setclid, rqstp);
3381	3984	add_to_unconfirmed(new);
..	..	@@ -3558,7 +4161,6 @@
3558	4161	out_free_client_slab:
3559	4162	kmem_cache_destroy(client_slab);
3560	4163	out:
3561		- dprintk("nfsd4: out of memory while initializing nfsv4\n");
3562	4164	return -ENOMEM;
3563	4165	}
3564	4166
..	..	@@ -3598,12 +4200,11 @@
3598	4200	if (!sop)
3599	4201	return NULL;
3600	4202
3601		- sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
	4203	+ xdr_netobj_dup(&sop->so_owner, owner, GFP_KERNEL);
3602	4204	if (!sop->so_owner.data) {
3603	4205	kmem_cache_free(slab, sop);
3604	4206	return NULL;
3605	4207	}
3606		- sop->so_owner.len = owner->len;
3607	4208
3608	4209	INIT_LIST_HEAD(&sop->so_stateids);
3609	4210	sop->so_client = clp;
..	..	@@ -3825,7 +4426,7 @@
3825	4426	last = oo->oo_last_closed_stid;
3826	4427	oo->oo_last_closed_stid = s;
3827	4428	list_move_tail(&oo->oo_close_lru, &nn->close_lru);
3828		- oo->oo_time = get_seconds();
	4429	+ oo->oo_time = ktime_get_boottime_seconds();
3829	4430	spin_unlock(&nn->client_lock);
3830	4431	if (last)
3831	4432	nfs4_put_stid(&last->st_stid);
..	..	@@ -3837,7 +4438,8 @@
3837	4438	{
3838	4439	struct nfs4_file *fp;
3839	4440
3840		- hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash) {
	4441	+ hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash,
	4442	+ lockdep_is_held(&state_lock)) {
3841	4443	if (fh_match(&fp->fi_fhandle, fh)) {
3842	4444	if (refcount_inc_not_zero(&fp->fi_ref))
3843	4445	return fp;
..	..	@@ -3920,7 +4522,7 @@
3920	4522	*/
3921	4523	spin_lock(&state_lock);
3922	4524	if (delegation_hashed(dp) && dp->dl_time == 0) {
3923		- dp->dl_time = get_seconds();
	4525	+ dp->dl_time = ktime_get_boottime_seconds();
3924	4526	list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
3925	4527	}
3926	4528	spin_unlock(&state_lock);
..	..	@@ -3931,12 +4533,16 @@
3931	4533	{
3932	4534	struct nfs4_delegation *dp = cb_to_delegation(cb);
3933	4535
3934		- if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID)
	4536	+ if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID \|\|
	4537	+ dp->dl_stid.sc_type == NFS4_REVOKED_DELEG_STID)
3935	4538	return 1;
3936	4539
3937	4540	switch (task->tk_status) {
3938	4541	case 0:
3939	4542	return 1;
	4543	+ case -NFS4ERR_DELAY:
	4544	+ rpc_delay(task, 2 * HZ);
	4545	+ return 0;
3940	4546	case -EBADHANDLE:
3941	4547	case -NFS4ERR_BAD_STATEID:
3942	4548	/*
..	..	@@ -3947,9 +4553,9 @@
3947	4553	rpc_delay(task, 2 * HZ);
3948	4554	return 0;
3949	4555	}
3950		- /FALLTHRU/
	4556	+ fallthrough;
3951	4557	default:
3952		- return -1;
	4558	+ return 1;
3953	4559	}
3954	4560	}
3955	4561
..	..	@@ -3987,6 +4593,8 @@
3987	4593	struct nfs4_delegation dp = (struct nfs4_delegation )fl->fl_owner;
3988	4594	struct nfs4_file *fp = dp->dl_stid.sc_file;
3989	4595
	4596	+ trace_nfsd_deleg_break(&dp->dl_stid.sc_stateid);
	4597	+
3990	4598	/*
3991	4599	* We don't want the locks code to timeout the lease for us;
3992	4600	* we'll remove it ourself if a delegation isn't returned
..	..	@@ -4001,6 +4609,30 @@
4001	4609	return ret;
4002	4610	}
4003	4611
	4612	+/**
	4613	+ * nfsd_breaker_owns_lease - Check if lease conflict was resolved
	4614	+ * @fl: Lock state to check
	4615	+ *
	4616	+ * Return values:
	4617	+ * %true: Lease conflict was resolved
	4618	+ * %false: Lease conflict was not resolved.
	4619	+ */
	4620	+static bool nfsd_breaker_owns_lease(struct file_lock *fl)
	4621	+{
	4622	+ struct nfs4_delegation *dl = fl->fl_owner;
	4623	+ struct svc_rqst *rqst;
	4624	+ struct nfs4_client *clp;
	4625	+
	4626	+ if (!i_am_nfsd())
	4627	+ return false;
	4628	+ rqst = kthread_data(current);
	4629	+ /* Note rq_prog == NFS_ACL_PROGRAM is also possible: */
	4630	+ if (rqst->rq_prog != NFS_PROGRAM \|\| rqst->rq_vers < 4)
	4631	+ return false;
	4632	+ clp = *(rqst->rq_lease_breaker);
	4633	+ return dl->dl_stid.sc_client == clp;
	4634	+}
	4635	+
4004	4636	static int
4005	4637	nfsd_change_deleg_cb(struct file_lock *onlist, int arg,
4006	4638	struct list_head *dispose)
..	..	@@ -4012,6 +4644,7 @@
4012	4644	}
4013	4645
4014	4646	static const struct lock_manager_operations nfsd_lease_mng_ops = {
	4647	+ .lm_breaker_owns_lease = nfsd_breaker_owns_lease,
4015	4648	.lm_break = nfsd_break_deleg_cb,
4016	4649	.lm_change = nfsd_change_deleg_cb,
4017	4650	};
..	..	@@ -4029,7 +4662,8 @@
4029	4662
4030	4663	static __be32 lookup_clientid(clientid_t *clid,
4031	4664	struct nfsd4_compound_state *cstate,
4032		- struct nfsd_net *nn)
	4665	+ struct nfsd_net *nn,
	4666	+ bool sessions)
4033	4667	{
4034	4668	struct nfs4_client *found;
4035	4669
..	..	@@ -4050,12 +4684,12 @@
4050	4684	*/
4051	4685	WARN_ON_ONCE(cstate->session);
4052	4686	spin_lock(&nn->client_lock);
4053		- found = find_confirmed_client(clid, false, nn);
	4687	+ found = find_confirmed_client(clid, sessions, nn);
4054	4688	if (!found) {
4055	4689	spin_unlock(&nn->client_lock);
4056	4690	return nfserr_expired;
4057	4691	}
4058		- atomic_inc(&found->cl_refcount);
	4692	+ atomic_inc(&found->cl_rpc_users);
4059	4693	spin_unlock(&nn->client_lock);
4060	4694
4061	4695	/* Cache the nfs4_client in cstate! */
..	..	@@ -4083,7 +4717,7 @@
4083	4717	if (open->op_file == NULL)
4084	4718	return nfserr_jukebox;
4085	4719
4086		- status = lookup_clientid(clientid, cstate, nn);
	4720	+ status = lookup_clientid(clientid, cstate, nn, false);
4087	4721	if (status)
4088	4722	return status;
4089	4723	clp = cstate->clp;
..	..	@@ -4211,14 +4845,14 @@
4211	4845	return 0;
4212	4846	if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
4213	4847	return nfserr_inval;
4214		- return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
	4848	+ return nfsd_setattr(rqstp, fh, &iattr, 0, (time64_t)0);
4215	4849	}
4216	4850
4217	4851	static __be32 nfs4_get_vfs_file(struct svc_rqst rqstp, struct nfs4_file fp,
4218	4852	struct svc_fh cur_fh, struct nfs4_ol_stateid stp,
4219	4853	struct nfsd4_open *open)
4220	4854	{
4221		- struct file *filp = NULL;
	4855	+ struct nfsd_file *nf = NULL;
4222	4856	__be32 status;
4223	4857	int oflag = nfs4_access_to_omode(open->op_share_access);
4224	4858	int access = nfs4_access_to_access(open->op_share_access);
..	..	@@ -4254,18 +4888,23 @@
4254	4888
4255	4889	if (!fp->fi_fds[oflag]) {
4256	4890	spin_unlock(&fp->fi_lock);
4257		- status = nfsd_open(rqstp, cur_fh, S_IFREG, access, &filp);
	4891	+ status = nfsd_file_acquire(rqstp, cur_fh, access, &nf);
4258	4892	if (status)
4259	4893	goto out_put_access;
4260	4894	spin_lock(&fp->fi_lock);
4261	4895	if (!fp->fi_fds[oflag]) {
4262		- fp->fi_fds[oflag] = filp;
4263		- filp = NULL;
	4896	+ fp->fi_fds[oflag] = nf;
	4897	+ nf = NULL;
4264	4898	}
4265	4899	}
4266	4900	spin_unlock(&fp->fi_lock);
4267		- if (filp)
4268		- fput(filp);
	4901	+ if (nf)
	4902	+ nfsd_file_put(nf);
	4903	+
	4904	+ status = nfserrno(nfsd_open_break_lease(cur_fh->fh_dentry->d_inode,
	4905	+ access));
	4906	+ if (status)
	4907	+ goto out_put_access;
4269	4908
4270	4909	status = nfsd4_truncate(rqstp, cur_fh, open);
4271	4910	if (status)
..	..	@@ -4334,7 +4973,7 @@
4334	4973	fl->fl_end = OFFSET_MAX;
4335	4974	fl->fl_owner = (fl_owner_t)dp;
4336	4975	fl->fl_pid = current->tgid;
4337		- fl->fl_file = dp->dl_stid.sc_file->fi_deleg_file;
	4976	+ fl->fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file;
4338	4977	return fl;
4339	4978	}
4340	4979
..	..	@@ -4344,7 +4983,7 @@
4344	4983	{
4345	4984	int status = 0;
4346	4985	struct nfs4_delegation *dp;
4347		- struct file *filp;
	4986	+ struct nfsd_file *nf;
4348	4987	struct file_lock *fl;
4349	4988
4350	4989	/*
..	..	@@ -4355,8 +4994,8 @@
4355	4994	if (fp->fi_had_conflict)
4356	4995	return ERR_PTR(-EAGAIN);
4357	4996
4358		- filp = find_readable_file(fp);
4359		- if (!filp) {
	4997	+ nf = find_readable_file(fp);
	4998	+ if (!nf) {
4360	4999	/* We should always have a readable file here */
4361	5000	WARN_ON_ONCE(1);
4362	5001	return ERR_PTR(-EBADF);
..	..	@@ -4366,17 +5005,17 @@
4366	5005	if (nfs4_delegation_exists(clp, fp))
4367	5006	status = -EAGAIN;
4368	5007	else if (!fp->fi_deleg_file) {
4369		- fp->fi_deleg_file = filp;
	5008	+ fp->fi_deleg_file = nf;
4370	5009	/* increment early to prevent fi_deleg_file from being
4371	5010	* cleared */
4372	5011	fp->fi_delegees = 1;
4373		- filp = NULL;
	5012	+ nf = NULL;
4374	5013	} else
4375	5014	fp->fi_delegees++;
4376	5015	spin_unlock(&fp->fi_lock);
4377	5016	spin_unlock(&state_lock);
4378		- if (filp)
4379		- fput(filp);
	5017	+ if (nf)
	5018	+ nfsd_file_put(nf);
4380	5019	if (status)
4381	5020	return ERR_PTR(status);
4382	5021
..	..	@@ -4389,7 +5028,7 @@
4389	5028	if (!fl)
4390	5029	goto out_clnt_odstate;
4391	5030
4392		- status = vfs_setlease(fp->fi_deleg_file, fl->fl_type, &fl, NULL);
	5031	+ status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL);
4393	5032	if (fl)
4394	5033	locks_free_lock(fl);
4395	5034	if (status)
..	..	@@ -4409,7 +5048,7 @@
4409	5048
4410	5049	return dp;
4411	5050	out_unlock:
4412		- vfs_setlease(fp->fi_deleg_file, F_UNLCK, NULL, (void **)&dp);
	5051	+ vfs_setlease(fp->fi_deleg_file->nf_file, F_UNLCK, NULL, (void **)&dp);
4413	5052	out_clnt_odstate:
4414	5053	put_clnt_odstate(dp->dl_clnt_odstate);
4415	5054	nfs4_put_stid(&dp->dl_stid);
..	..	@@ -4496,8 +5135,7 @@
4496	5135
4497	5136	memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
4498	5137
4499		- dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
4500		- STATEID_VAL(&dp->dl_stid.sc_stateid));
	5138	+ trace_nfsd_deleg_read(&dp->dl_stid.sc_stateid);
4501	5139	open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
4502	5140	nfs4_put_stid(&dp->dl_stid);
4503	5141	return;
..	..	@@ -4614,9 +5252,7 @@
4614	5252	nfs4_open_delegation(current_fh, open, stp);
4615	5253	nodeleg:
4616	5254	status = nfs_ok;
4617		-
4618		- dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
4619		- STATEID_VAL(&stp->st_stid.sc_stateid));
	5255	+ trace_nfsd_open(&stp->st_stid.sc_stateid);
4620	5256	out:
4621	5257	/* 4.1 client trying to upgrade/downgrade delegation? */
4622	5258	if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
..	..	@@ -4670,9 +5306,8 @@
4670	5306	__be32 status;
4671	5307	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4672	5308
4673		- dprintk("process_renew(%08x/%08x): starting\n",
4674		- clid->cl_boot, clid->cl_id);
4675		- status = lookup_clientid(clid, cstate, nn);
	5309	+ trace_nfsd_clid_renew(clid);
	5310	+ status = lookup_clientid(clid, cstate, nn, false);
4676	5311	if (status)
4677	5312	goto out;
4678	5313	clp = cstate->clp;
..	..	@@ -4692,7 +5327,7 @@
4692	5327	if (nn->grace_ended)
4693	5328	return;
4694	5329
4695		- dprintk("NFSD: end of grace period\n");
	5330	+ trace_nfsd_grace_complete(nn);
4696	5331	nn->grace_ended = true;
4697	5332	/*
4698	5333	* If the server goes down again right now, an NFSv4
..	..	@@ -4724,10 +5359,13 @@
4724	5359	*/
4725	5360	static bool clients_still_reclaiming(struct nfsd_net *nn)
4726	5361	{
4727		- unsigned long now = get_seconds();
4728		- unsigned long double_grace_period_end = nn->boot_time +
4729		- 2 * nn->nfsd4_lease;
	5362	+ time64_t double_grace_period_end = nn->boot_time +
	5363	+ 2 * nn->nfsd4_lease;
4730	5364
	5365	+ if (nn->track_reclaim_completes &&
	5366	+ atomic_read(&nn->nr_reclaim_complete) ==
	5367	+ nn->reclaim_str_hashtbl_size)
	5368	+ return false;
4731	5369	if (!nn->somebody_reclaimed)
4732	5370	return false;
4733	5371	nn->somebody_reclaimed = false;
..	..	@@ -4735,12 +5373,12 @@
4735	5373	* If we've given them two lease times to reclaim, and they're
4736	5374	* still not done, give up:
4737	5375	*/
4738		- if (time_after(now, double_grace_period_end))
	5376	+ if (ktime_get_boottime_seconds() > double_grace_period_end)
4739	5377	return false;
4740	5378	return true;
4741	5379	}
4742	5380
4743		-static time_t
	5381	+static time64_t
4744	5382	nfs4_laundromat(struct nfsd_net *nn)
4745	5383	{
4746	5384	struct nfs4_client *clp;
..	..	@@ -4749,10 +5387,11 @@
4749	5387	struct nfs4_ol_stateid *stp;
4750	5388	struct nfsd4_blocked_lock *nbl;
4751	5389	struct list_head pos, next, reaplist;
4752		- time_t cutoff = get_seconds() - nn->nfsd4_lease;
4753		- time_t t, new_timeo = nn->nfsd4_lease;
4754		-
4755		- dprintk("NFSD: laundromat service - starting\n");
	5390	+ time64_t cutoff = ktime_get_boottime_seconds() - nn->nfsd4_lease;
	5391	+ time64_t t, new_timeo = nn->nfsd4_lease;
	5392	+ struct nfs4_cpntf_state *cps;
	5393	+ copy_stateid_t *cps_t;
	5394	+ int i;
4756	5395
4757	5396	if (clients_still_reclaiming(nn)) {
4758	5397	new_timeo = 0;
..	..	@@ -4760,17 +5399,26 @@
4760	5399	}
4761	5400	nfsd4_end_grace(nn);
4762	5401	INIT_LIST_HEAD(&reaplist);
	5402	+
	5403	+ spin_lock(&nn->s2s_cp_lock);
	5404	+ idr_for_each_entry(&nn->s2s_cp_stateids, cps_t, i) {
	5405	+ cps = container_of(cps_t, struct nfs4_cpntf_state, cp_stateid);
	5406	+ if (cps->cp_stateid.sc_type == NFS4_COPYNOTIFY_STID &&
	5407	+ cps->cpntf_time < cutoff)
	5408	+ _free_cpntf_state_locked(nn, cps);
	5409	+ }
	5410	+ spin_unlock(&nn->s2s_cp_lock);
	5411	+
4763	5412	spin_lock(&nn->client_lock);
4764	5413	list_for_each_safe(pos, next, &nn->client_lru) {
4765	5414	clp = list_entry(pos, struct nfs4_client, cl_lru);
4766		- if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
	5415	+ if (clp->cl_time > cutoff) {
4767	5416	t = clp->cl_time - cutoff;
4768	5417	new_timeo = min(new_timeo, t);
4769	5418	break;
4770	5419	}
4771	5420	if (mark_client_expired_locked(clp)) {
4772		- dprintk("NFSD: client in use (clientid %08x)\n",
4773		- clp->cl_clientid.cl_id);
	5421	+ trace_nfsd_clid_expired(&clp->cl_clientid);
4774	5422	continue;
4775	5423	}
4776	5424	list_add(&clp->cl_lru, &reaplist);
..	..	@@ -4778,15 +5426,14 @@
4778	5426	spin_unlock(&nn->client_lock);
4779	5427	list_for_each_safe(pos, next, &reaplist) {
4780	5428	clp = list_entry(pos, struct nfs4_client, cl_lru);
4781		- dprintk("NFSD: purging unused client (clientid %08x)\n",
4782		- clp->cl_clientid.cl_id);
	5429	+ trace_nfsd_clid_purged(&clp->cl_clientid);
4783	5430	list_del_init(&clp->cl_lru);
4784	5431	expire_client(clp);
4785	5432	}
4786	5433	spin_lock(&state_lock);
4787	5434	list_for_each_safe(pos, next, &nn->del_recall_lru) {
4788	5435	dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4789		- if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
	5436	+ if (dp->dl_time > cutoff) {
4790	5437	t = dp->dl_time - cutoff;
4791	5438	new_timeo = min(new_timeo, t);
4792	5439	break;
..	..	@@ -4806,8 +5453,7 @@
4806	5453	while (!list_empty(&nn->close_lru)) {
4807	5454	oo = list_first_entry(&nn->close_lru, struct nfs4_openowner,
4808	5455	oo_close_lru);
4809		- if (time_after((unsigned long)oo->oo_time,
4810		- (unsigned long)cutoff)) {
	5456	+ if (oo->oo_time > cutoff) {
4811	5457	t = oo->oo_time - cutoff;
4812	5458	new_timeo = min(new_timeo, t);
4813	5459	break;
..	..	@@ -4837,8 +5483,7 @@
4837	5483	while (!list_empty(&nn->blocked_locks_lru)) {
4838	5484	nbl = list_first_entry(&nn->blocked_locks_lru,
4839	5485	struct nfsd4_blocked_lock, nbl_lru);
4840		- if (time_after((unsigned long)nbl->nbl_time,
4841		- (unsigned long)cutoff)) {
	5486	+ if (nbl->nbl_time > cutoff) {
4842	5487	t = nbl->nbl_time - cutoff;
4843	5488	new_timeo = min(new_timeo, t);
4844	5489	break;
..	..	@@ -4852,11 +5497,10 @@
4852	5497	nbl = list_first_entry(&reaplist,
4853	5498	struct nfsd4_blocked_lock, nbl_lru);
4854	5499	list_del_init(&nbl->nbl_lru);
4855		- posix_unblock_lock(&nbl->nbl_lock);
4856	5500	free_blocked_lock(nbl);
4857	5501	}
4858	5502	out:
4859		- new_timeo = max_t(time_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
	5503	+ new_timeo = max_t(time64_t, new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
4860	5504	return new_timeo;
4861	5505	}
4862	5506
..	..	@@ -4866,13 +5510,12 @@
4866	5510	static void
4867	5511	laundromat_main(struct work_struct *laundry)
4868	5512	{
4869		- time_t t;
	5513	+ time64_t t;
4870	5514	struct delayed_work *dwork = to_delayed_work(laundry);
4871	5515	struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
4872	5516	laundromat_work);
4873	5517
4874	5518	t = nfs4_laundromat(nn);
4875		- dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
4876	5519	queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
4877	5520	}
4878	5521
..	..	@@ -4998,15 +5641,8 @@
4998	5641	if (ZERO_STATEID(stateid) \|\| ONE_STATEID(stateid) \|\|
4999	5642	CLOSE_STATEID(stateid))
5000	5643	return status;
5001		- /* Client debugging aid. */
5002		- if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
5003		- char addr_str[INET6_ADDRSTRLEN];
5004		- rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
5005		- sizeof(addr_str));
5006		- pr_warn_ratelimited("NFSD: client %s testing state ID "
5007		- "with incorrect client ID\n", addr_str);
	5644	+ if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid))
5008	5645	return status;
5009		- }
5010	5646	spin_lock(&cl->cl_lock);
5011	5647	s = find_stateid_locked(cl, stateid);
5012	5648	if (!s)
..	..	@@ -5027,7 +5663,7 @@
5027	5663	break;
5028	5664	default:
5029	5665	printk("unknown stateid type %x\n", s->sc_type);
5030		- /* Fallthrough */
	5666	+ fallthrough;
5031	5667	case NFS4_CLOSED_STID:
5032	5668	case NFS4_CLOSED_DELEG_STID:
5033	5669	status = nfserr_bad_stateid;
..	..	@@ -5057,7 +5693,8 @@
5057	5693	if (ZERO_STATEID(stateid) \|\| ONE_STATEID(stateid) \|\|
5058	5694	CLOSE_STATEID(stateid))
5059	5695	return nfserr_bad_stateid;
5060		- status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn);
	5696	+ status = lookup_clientid(&stateid->si_opaque.so_clid, cstate, nn,
	5697	+ false);
5061	5698	if (status == nfserr_stale_clientid) {
5062	5699	if (cstate->session)
5063	5700	return nfserr_bad_stateid;
..	..	@@ -5077,7 +5714,7 @@
5077	5714	return nfs_ok;
5078	5715	}
5079	5716
5080		-static struct file *
	5717	+static struct nfsd_file *
5081	5718	nfs4_find_file(struct nfs4_stid *s, int flags)
5082	5719	{
5083	5720	if (!s)
..	..	@@ -5087,21 +5724,20 @@
5087	5724	case NFS4_DELEG_STID:
5088	5725	if (WARN_ON_ONCE(!s->sc_file->fi_deleg_file))
5089	5726	return NULL;
5090		- return get_file(s->sc_file->fi_deleg_file);
	5727	+ return nfsd_file_get(s->sc_file->fi_deleg_file);
5091	5728	case NFS4_OPEN_STID:
5092	5729	case NFS4_LOCK_STID:
5093	5730	if (flags & RD_STATE)
5094	5731	return find_readable_file(s->sc_file);
5095	5732	else
5096	5733	return find_writeable_file(s->sc_file);
5097		- break;
5098	5734	}
5099	5735
5100	5736	return NULL;
5101	5737	}
5102	5738
5103	5739	static __be32
5104		-nfs4_check_olstateid(struct svc_fh fhp, struct nfs4_ol_stateid ols, int flags)
	5740	+nfs4_check_olstateid(struct nfs4_ol_stateid *ols, int flags)
5105	5741	{
5106	5742	__be32 status;
5107	5743
..	..	@@ -5113,32 +5749,107 @@
5113	5749
5114	5750	static __be32
5115	5751	nfs4_check_file(struct svc_rqst rqstp, struct svc_fh fhp, struct nfs4_stid *s,
5116		- struct file *filpp, bool tmp_file, int flags)
	5752	+ struct nfsd_file **nfp, int flags)
5117	5753	{
5118	5754	int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE;
5119		- struct file *file;
	5755	+ struct nfsd_file *nf;
5120	5756	__be32 status;
5121	5757
5122		- file = nfs4_find_file(s, flags);
5123		- if (file) {
	5758	+ nf = nfs4_find_file(s, flags);
	5759	+ if (nf) {
5124	5760	status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
5125	5761	acc \| NFSD_MAY_OWNER_OVERRIDE);
5126	5762	if (status) {
5127		- fput(file);
5128		- return status;
	5763	+ nfsd_file_put(nf);
	5764	+ goto out;
5129	5765	}
5130		-
5131		- *filpp = file;
5132	5766	} else {
5133		- status = nfsd_open(rqstp, fhp, S_IFREG, acc, filpp);
	5767	+ status = nfsd_file_acquire(rqstp, fhp, acc, &nf);
5134	5768	if (status)
5135	5769	return status;
5136		-
5137		- if (tmp_file)
5138		- *tmp_file = true;
5139	5770	}
	5771	+ *nfp = nf;
	5772	+out:
	5773	+ return status;
	5774	+}
	5775	+static void
	5776	+_free_cpntf_state_locked(struct nfsd_net nn, struct nfs4_cpntf_state cps)
	5777	+{
	5778	+ WARN_ON_ONCE(cps->cp_stateid.sc_type != NFS4_COPYNOTIFY_STID);
	5779	+ if (!refcount_dec_and_test(&cps->cp_stateid.sc_count))
	5780	+ return;
	5781	+ list_del(&cps->cp_list);
	5782	+ idr_remove(&nn->s2s_cp_stateids,
	5783	+ cps->cp_stateid.stid.si_opaque.so_id);
	5784	+ kfree(cps);
	5785	+}
	5786	+/*
	5787	+ * A READ from an inter server to server COPY will have a
	5788	+ * copy stateid. Look up the copy notify stateid from the
	5789	+ * idr structure and take a reference on it.
	5790	+ */
	5791	+__be32 manage_cpntf_state(struct nfsd_net nn, stateid_t st,
	5792	+ struct nfs4_client *clp,
	5793	+ struct nfs4_cpntf_state **cps)
	5794	+{
	5795	+ copy_stateid_t *cps_t;
	5796	+ struct nfs4_cpntf_state *state = NULL;
5140	5797
	5798	+ if (st->si_opaque.so_clid.cl_id != nn->s2s_cp_cl_id)
	5799	+ return nfserr_bad_stateid;
	5800	+ spin_lock(&nn->s2s_cp_lock);
	5801	+ cps_t = idr_find(&nn->s2s_cp_stateids, st->si_opaque.so_id);
	5802	+ if (cps_t) {
	5803	+ state = container_of(cps_t, struct nfs4_cpntf_state,
	5804	+ cp_stateid);
	5805	+ if (state->cp_stateid.sc_type != NFS4_COPYNOTIFY_STID) {
	5806	+ state = NULL;
	5807	+ goto unlock;
	5808	+ }
	5809	+ if (!clp)
	5810	+ refcount_inc(&state->cp_stateid.sc_count);
	5811	+ else
	5812	+ _free_cpntf_state_locked(nn, state);
	5813	+ }
	5814	+unlock:
	5815	+ spin_unlock(&nn->s2s_cp_lock);
	5816	+ if (!state)
	5817	+ return nfserr_bad_stateid;
	5818	+ if (!clp && state)
	5819	+ *cps = state;
5141	5820	return 0;
	5821	+}
	5822	+
	5823	+static __be32 find_cpntf_state(struct nfsd_net nn, stateid_t st,
	5824	+ struct nfs4_stid **stid)
	5825	+{
	5826	+ __be32 status;
	5827	+ struct nfs4_cpntf_state *cps = NULL;
	5828	+ struct nfsd4_compound_state cstate;
	5829	+
	5830	+ status = manage_cpntf_state(nn, st, NULL, &cps);
	5831	+ if (status)
	5832	+ return status;
	5833	+
	5834	+ cps->cpntf_time = ktime_get_boottime_seconds();
	5835	+ memset(&cstate, 0, sizeof(cstate));
	5836	+ status = lookup_clientid(&cps->cp_p_clid, &cstate, nn, true);
	5837	+ if (status)
	5838	+ goto out;
	5839	+ status = nfsd4_lookup_stateid(&cstate, &cps->cp_p_stateid,
	5840	+ NFS4_DELEG_STID\|NFS4_OPEN_STID\|NFS4_LOCK_STID,
	5841	+ stid, nn);
	5842	+ put_client_renew(cstate.clp);
	5843	+out:
	5844	+ nfs4_put_cpntf_state(nn, cps);
	5845	+ return status;
	5846	+}
	5847	+
	5848	+void nfs4_put_cpntf_state(struct nfsd_net nn, struct nfs4_cpntf_state cps)
	5849	+{
	5850	+ spin_lock(&nn->s2s_cp_lock);
	5851	+ _free_cpntf_state_locked(nn, cps);
	5852	+ spin_unlock(&nn->s2s_cp_lock);
5142	5853	}
5143	5854
5144	5855	/*
..	..	@@ -5147,7 +5858,8 @@
5147	5858	__be32
5148	5859	nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
5149	5860	struct nfsd4_compound_state cstate, struct svc_fh fhp,
5150		- stateid_t stateid, int flags, struct file filpp, bool tmp_file)
	5861	+ stateid_t stateid, int flags, struct nfsd_file *nfp,
	5862	+ struct nfs4_stid **cstid)
5151	5863	{
5152	5864	struct inode *ino = d_inode(fhp->fh_dentry);
5153	5865	struct net *net = SVC_NET(rqstp);
..	..	@@ -5155,10 +5867,8 @@
5155	5867	struct nfs4_stid *s = NULL;
5156	5868	__be32 status;
5157	5869
5158		- if (filpp)
5159		- *filpp = NULL;
5160		- if (tmp_file)
5161		- *tmp_file = false;
	5870	+ if (nfp)
	5871	+ *nfp = NULL;
5162	5872
5163	5873	if (grace_disallows_io(net, ino))
5164	5874	return nfserr_grace;
..	..	@@ -5171,6 +5881,8 @@
5171	5881	status = nfsd4_lookup_stateid(cstate, stateid,
5172	5882	NFS4_DELEG_STID\|NFS4_OPEN_STID\|NFS4_LOCK_STID,
5173	5883	&s, nn);
	5884	+ if (status == nfserr_bad_stateid)
	5885	+ status = find_cpntf_state(nn, stateid, &s);
5174	5886	if (status)
5175	5887	return status;
5176	5888	status = nfsd4_stid_check_stateid_generation(stateid, s,
..	..	@@ -5184,7 +5896,7 @@
5184	5896	break;
5185	5897	case NFS4_OPEN_STID:
5186	5898	case NFS4_LOCK_STID:
5187		- status = nfs4_check_olstateid(fhp, openlockstateid(s), flags);
	5899	+ status = nfs4_check_olstateid(openlockstateid(s), flags);
5188	5900	break;
5189	5901	default:
5190	5902	status = nfserr_bad_stateid;
..	..	@@ -5195,11 +5907,15 @@
5195	5907	status = nfs4_check_fh(fhp, s);
5196	5908
5197	5909	done:
5198		- if (!status && filpp)
5199		- status = nfs4_check_file(rqstp, fhp, s, filpp, tmp_file, flags);
	5910	+ if (status == nfs_ok && nfp)
	5911	+ status = nfs4_check_file(rqstp, fhp, s, nfp, flags);
5200	5912	out:
5201		- if (s)
5202		- nfs4_put_stid(s);
	5913	+ if (s) {
	5914	+ if (!status && cstid)
	5915	+ *cstid = s;
	5916	+ else
	5917	+ nfs4_put_stid(s);
	5918	+ }
5203	5919	return status;
5204	5920	}
5205	5921
..	..	@@ -5339,8 +6055,7 @@
5339	6055	struct nfs4_stid *s;
5340	6056	struct nfs4_ol_stateid *stp = NULL;
5341	6057
5342		- dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
5343		- seqid, STATEID_VAL(stateid));
	6058	+ trace_nfsd_preprocess(seqid, stateid);
5344	6059
5345	6060	*stpp = NULL;
5346	6061	status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn);
..	..	@@ -5409,9 +6124,7 @@
5409	6124	oo->oo_flags \|= NFS4_OO_CONFIRMED;
5410	6125	nfs4_inc_and_copy_stateid(&oc->oc_resp_stateid, &stp->st_stid);
5411	6126	mutex_unlock(&stp->st_mutex);
5412		- dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
5413		- __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
5414		-
	6127	+ trace_nfsd_open_confirm(oc->oc_seqid, &stp->st_stid.sc_stateid);
5415	6128	nfsd4_client_record_create(oo->oo_owner.so_client);
5416	6129	status = nfs_ok;
5417	6130	put_stateid:
..	..	@@ -5496,6 +6209,7 @@
5496	6209	struct nfs4_client *clp = s->st_stid.sc_client;
5497	6210	bool unhashed;
5498	6211	LIST_HEAD(reaplist);
	6212	+ struct nfs4_ol_stateid *stp;
5499	6213
5500	6214	spin_lock(&clp->cl_lock);
5501	6215	unhashed = unhash_open_stateid(s, &reaplist);
..	..	@@ -5504,6 +6218,8 @@
5504	6218	if (unhashed)
5505	6219	put_ol_stateid_locked(s, &reaplist);
5506	6220	spin_unlock(&clp->cl_lock);
	6221	+ list_for_each_entry(stp, &reaplist, st_locks)
	6222	+ nfs4_free_cpntf_statelist(clp->net, &stp->st_stid);
5507	6223	free_ol_stateid_reaplist(&reaplist);
5508	6224	} else {
5509	6225	spin_unlock(&clp->cl_lock);
..	..	@@ -5685,12 +6401,11 @@
5685	6401
5686	6402	if (fl->fl_lmops == &nfsd_posix_mng_ops) {
5687	6403	lo = (struct nfs4_lockowner *) fl->fl_owner;
5688		- deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
5689		- lo->lo_owner.so_owner.len, GFP_KERNEL);
	6404	+ xdr_netobj_dup(&deny->ld_owner, &lo->lo_owner.so_owner,
	6405	+ GFP_KERNEL);
5690	6406	if (!deny->ld_owner.data)
5691	6407	/* We just don't care that much */
5692	6408	goto nevermind;
5693		- deny->ld_owner.len = lo->lo_owner.so_owner.len;
5694	6409	deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
5695	6410	} else {
5696	6411	nevermind:
..	..	@@ -5961,7 +6676,7 @@
5961	6676	struct nfs4_ol_stateid *lock_stp = NULL;
5962	6677	struct nfs4_ol_stateid *open_stp = NULL;
5963	6678	struct nfs4_file *fp;
5964		- struct file *filp = NULL;
	6679	+ struct nfsd_file *nf = NULL;
5965	6680	struct nfsd4_blocked_lock *nbl = NULL;
5966	6681	struct file_lock *file_lock = NULL;
5967	6682	struct file_lock *conflock = NULL;
..	..	@@ -6040,11 +6755,11 @@
6040	6755	case NFS4_READW_LT:
6041	6756	if (nfsd4_has_session(cstate))
6042	6757	fl_flags \|= FL_SLEEP;
6043		- /* Fallthrough */
	6758	+ fallthrough;
6044	6759	case NFS4_READ_LT:
6045	6760	spin_lock(&fp->fi_lock);
6046		- filp = find_readable_file_locked(fp);
6047		- if (filp)
	6761	+ nf = find_readable_file_locked(fp);
	6762	+ if (nf)
6048	6763	get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
6049	6764	spin_unlock(&fp->fi_lock);
6050	6765	fl_type = F_RDLCK;
..	..	@@ -6052,11 +6767,11 @@
6052	6767	case NFS4_WRITEW_LT:
6053	6768	if (nfsd4_has_session(cstate))
6054	6769	fl_flags \|= FL_SLEEP;
6055		- /* Fallthrough */
	6770	+ fallthrough;
6056	6771	case NFS4_WRITE_LT:
6057	6772	spin_lock(&fp->fi_lock);
6058		- filp = find_writeable_file_locked(fp);
6059		- if (filp)
	6773	+ nf = find_writeable_file_locked(fp);
	6774	+ if (nf)
6060	6775	get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
6061	6776	spin_unlock(&fp->fi_lock);
6062	6777	fl_type = F_WRLCK;
..	..	@@ -6066,7 +6781,7 @@
6066	6781	goto out;
6067	6782	}
6068	6783
6069		- if (!filp) {
	6784	+ if (!nf) {
6070	6785	status = nfserr_openmode;
6071	6786	goto out;
6072	6787	}
..	..	@@ -6082,7 +6797,7 @@
6082	6797	file_lock->fl_type = fl_type;
6083	6798	file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner));
6084	6799	file_lock->fl_pid = current->tgid;
6085		- file_lock->fl_file = filp;
	6800	+ file_lock->fl_file = nf->nf_file;
6086	6801	file_lock->fl_flags = fl_flags;
6087	6802	file_lock->fl_lmops = &nfsd_posix_mng_ops;
6088	6803	file_lock->fl_start = lock->lk_offset;
..	..	@@ -6097,14 +6812,14 @@
6097	6812	}
6098	6813
6099	6814	if (fl_flags & FL_SLEEP) {
6100		- nbl->nbl_time = get_seconds();
	6815	+ nbl->nbl_time = ktime_get_boottime_seconds();
6101	6816	spin_lock(&nn->blocked_locks_lock);
6102	6817	list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked);
6103	6818	list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru);
6104	6819	spin_unlock(&nn->blocked_locks_lock);
6105	6820	}
6106	6821
6107		- err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
	6822	+ err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, conflock);
6108	6823	switch (err) {
6109	6824	case 0: /* success! */
6110	6825	nfs4_inc_and_copy_stateid(&lock->lk_resp_stateid, &lock_stp->st_stid);
..	..	@@ -6114,7 +6829,7 @@
6114	6829	break;
6115	6830	case FILE_LOCK_DEFERRED:
6116	6831	nbl = NULL;
6117		- /* Fallthrough */
	6832	+ fallthrough;
6118	6833	case -EAGAIN: /* conflock holds conflicting lock */
6119	6834	status = nfserr_denied;
6120	6835	dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
..	..	@@ -6139,8 +6854,8 @@
6139	6854	}
6140	6855	free_blocked_lock(nbl);
6141	6856	}
6142		- if (filp)
6143		- fput(filp);
	6857	+ if (nf)
	6858	+ nfsd_file_put(nf);
6144	6859	if (lock_stp) {
6145	6860	/* Bump seqid manually if the 4.0 replay owner is openowner */
6146	6861	if (cstate->replay_owner &&
..	..	@@ -6170,17 +6885,27 @@
6170	6885	/*
6171	6886	* The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
6172	6887	* so we do a temporary open here just to get an open file to pass to
6173		- * vfs_test_lock. (Arguably perhaps test_lock should be done with an
6174		- * inode operation.)
	6888	+ * vfs_test_lock.
6175	6889	*/
6176	6890	static __be32 nfsd_test_lock(struct svc_rqst rqstp, struct svc_fh fhp, struct file_lock *lock)
6177	6891	{
6178		- struct file *file;
6179		- __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
6180		- if (!err) {
6181		- err = nfserrno(vfs_test_lock(file, lock));
6182		- fput(file);
6183		- }
	6892	+ struct nfsd_file *nf;
	6893	+ __be32 err;
	6894	+
	6895	+ err = nfsd_file_acquire(rqstp, fhp, NFSD_MAY_READ, &nf);
	6896	+ if (err)
	6897	+ return err;
	6898	+ fh_lock(fhp); /* to block new leases till after test_lock: */
	6899	+ err = nfserrno(nfsd_open_break_lease(fhp->fh_dentry->d_inode,
	6900	+ NFSD_MAY_READ));
	6901	+ if (err)
	6902	+ goto out;
	6903	+ lock->fl_file = nf->nf_file;
	6904	+ err = nfserrno(vfs_test_lock(nf->nf_file, lock));
	6905	+ lock->fl_file = NULL;
	6906	+out:
	6907	+ fh_unlock(fhp);
	6908	+ nfsd_file_put(nf);
6184	6909	return err;
6185	6910	}
6186	6911
..	..	@@ -6204,7 +6929,8 @@
6204	6929	return nfserr_inval;
6205	6930
6206	6931	if (!nfsd4_has_session(cstate)) {
6207		- status = lookup_clientid(&lockt->lt_clientid, cstate, nn);
	6932	+ status = lookup_clientid(&lockt->lt_clientid, cstate, nn,
	6933	+ false);
6208	6934	if (status)
6209	6935	goto out;
6210	6936	}
..	..	@@ -6223,15 +6949,15 @@
6223	6949	case NFS4_READ_LT:
6224	6950	case NFS4_READW_LT:
6225	6951	file_lock->fl_type = F_RDLCK;
6226		- break;
	6952	+ break;
6227	6953	case NFS4_WRITE_LT:
6228	6954	case NFS4_WRITEW_LT:
6229	6955	file_lock->fl_type = F_WRLCK;
6230		- break;
	6956	+ break;
6231	6957	default:
6232	6958	dprintk("NFSD: nfs4_lockt: bad lock type!\n");
6233	6959	status = nfserr_inval;
6234		- goto out;
	6960	+ goto out;
6235	6961	}
6236	6962
6237	6963	lo = find_lockowner_str(cstate->clp, &lockt->lt_owner);
..	..	@@ -6267,7 +6993,7 @@
6267	6993	{
6268	6994	struct nfsd4_locku *locku = &u->locku;
6269	6995	struct nfs4_ol_stateid *stp;
6270		- struct file *filp = NULL;
	6996	+ struct nfsd_file *nf = NULL;
6271	6997	struct file_lock *file_lock = NULL;
6272	6998	__be32 status;
6273	6999	int err;
..	..	@@ -6285,8 +7011,8 @@
6285	7011	&stp, nn);
6286	7012	if (status)
6287	7013	goto out;
6288		- filp = find_any_file(stp->st_stid.sc_file);
6289		- if (!filp) {
	7014	+ nf = find_any_file(stp->st_stid.sc_file);
	7015	+ if (!nf) {
6290	7016	status = nfserr_lock_range;
6291	7017	goto put_stateid;
6292	7018	}
..	..	@@ -6294,13 +7020,13 @@
6294	7020	if (!file_lock) {
6295	7021	dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
6296	7022	status = nfserr_jukebox;
6297		- goto fput;
	7023	+ goto put_file;
6298	7024	}
6299	7025
6300	7026	file_lock->fl_type = F_UNLCK;
6301	7027	file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner));
6302	7028	file_lock->fl_pid = current->tgid;
6303		- file_lock->fl_file = filp;
	7029	+ file_lock->fl_file = nf->nf_file;
6304	7030	file_lock->fl_flags = FL_POSIX;
6305	7031	file_lock->fl_lmops = &nfsd_posix_mng_ops;
6306	7032	file_lock->fl_start = locku->lu_offset;
..	..	@@ -6309,14 +7035,14 @@
6309	7035	locku->lu_length);
6310	7036	nfs4_transform_lock_offset(file_lock);
6311	7037
6312		- err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
	7038	+ err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, NULL);
6313	7039	if (err) {
6314	7040	dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
6315	7041	goto out_nfserr;
6316	7042	}
6317	7043	nfs4_inc_and_copy_stateid(&locku->lu_stateid, &stp->st_stid);
6318		-fput:
6319		- fput(filp);
	7044	+put_file:
	7045	+ nfsd_file_put(nf);
6320	7046	put_stateid:
6321	7047	mutex_unlock(&stp->st_mutex);
6322	7048	nfs4_put_stid(&stp->st_stid);
..	..	@@ -6328,7 +7054,7 @@
6328	7054
6329	7055	out_nfserr:
6330	7056	status = nfserrno(err);
6331		- goto fput;
	7057	+ goto put_file;
6332	7058	}
6333	7059
6334	7060	/*
..	..	@@ -6341,17 +7067,17 @@
6341	7067	{
6342	7068	struct file_lock *fl;
6343	7069	int status = false;
6344		- struct file *filp = find_any_file(fp);
	7070	+ struct nfsd_file *nf = find_any_file(fp);
6345	7071	struct inode *inode;
6346	7072	struct file_lock_context *flctx;
6347	7073
6348		- if (!filp) {
	7074	+ if (!nf) {
6349	7075	/* Any valid lock stateid should have some sort of access */
6350	7076	WARN_ON_ONCE(1);
6351	7077	return status;
6352	7078	}
6353	7079
6354		- inode = locks_inode(filp);
	7080	+ inode = locks_inode(nf->nf_file);
6355	7081	flctx = inode->i_flctx;
6356	7082
6357	7083	if (flctx && !list_empty_careful(&flctx->flc_posix)) {
..	..	@@ -6364,7 +7090,7 @@
6364	7090	}
6365	7091	spin_unlock(&flctx->flc_lock);
6366	7092	}
6367		- fput(filp);
	7093	+ nfsd_file_put(nf);
6368	7094	return status;
6369	7095	}
6370	7096
..	..	@@ -6388,7 +7114,7 @@
6388	7114	dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
6389	7115	clid->cl_boot, clid->cl_id);
6390	7116
6391		- status = lookup_clientid(clid, cstate, nn);
	7117	+ status = lookup_clientid(clid, cstate, nn, false);
6392	7118	if (status)
6393	7119	return status;
6394	7120
..	..	@@ -6401,16 +7127,12 @@
6401	7127	if (sop->so_is_open_owner \|\| !same_owner_str(sop, owner))
6402	7128	continue;
6403	7129
6404		- /* see if there are still any locks associated with it */
6405		- lo = lockowner(sop);
6406		- list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
6407		- if (check_for_locks(stp->st_stid.sc_file, lo)) {
6408		- status = nfserr_locks_held;
6409		- spin_unlock(&clp->cl_lock);
6410		- return status;
6411		- }
	7130	+ if (atomic_read(&sop->so_count) != 1) {
	7131	+ spin_unlock(&clp->cl_lock);
	7132	+ return nfserr_locks_held;
6412	7133	}
6413	7134
	7135	+ lo = lockowner(sop);
6414	7136	nfs4_get_stateowner(sop);
6415	7137	break;
6416	7138	}
..	..	@@ -6442,7 +7164,7 @@
6442	7164	}
6443	7165
6444	7166	bool
6445		-nfs4_has_reclaimed_state(const char name, struct nfsd_net nn)
	7167	+nfs4_has_reclaimed_state(struct xdr_netobj name, struct nfsd_net *nn)
6446	7168	{
6447	7169	struct nfs4_client_reclaim *crp;
6448	7170
..	..	@@ -6452,20 +7174,26 @@
6452	7174
6453	7175	/*
6454	7176	* failure => all reset bets are off, nfserr_no_grace...
	7177	+ *
	7178	+ * The caller is responsible for freeing name.data if NULL is returned (it
	7179	+ * will be freed in nfs4_remove_reclaim_record in the normal case).
6455	7180	*/
6456	7181	struct nfs4_client_reclaim *
6457		-nfs4_client_to_reclaim(const char name, struct nfsd_net nn)
	7182	+nfs4_client_to_reclaim(struct xdr_netobj name, struct xdr_netobj princhash,
	7183	+ struct nfsd_net *nn)
6458	7184	{
6459	7185	unsigned int strhashval;
6460	7186	struct nfs4_client_reclaim *crp;
6461	7187
6462		- dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
6463	7188	crp = alloc_reclaim();
6464	7189	if (crp) {
6465	7190	strhashval = clientstr_hashval(name);
6466	7191	INIT_LIST_HEAD(&crp->cr_strhash);
6467	7192	list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
6468		- memcpy(crp->cr_recdir, name, HEXDIR_LEN);
	7193	+ crp->cr_name.data = name.data;
	7194	+ crp->cr_name.len = name.len;
	7195	+ crp->cr_princhash.data = princhash.data;
	7196	+ crp->cr_princhash.len = princhash.len;
6469	7197	crp->cr_clp = NULL;
6470	7198	nn->reclaim_str_hashtbl_size++;
6471	7199	}
..	..	@@ -6476,6 +7204,8 @@
6476	7204	nfs4_remove_reclaim_record(struct nfs4_client_reclaim crp, struct nfsd_net nn)
6477	7205	{
6478	7206	list_del(&crp->cr_strhash);
	7207	+ kfree(crp->cr_name.data);
	7208	+ kfree(crp->cr_princhash.data);
6479	7209	kfree(crp);
6480	7210	nn->reclaim_str_hashtbl_size--;
6481	7211	}
..	..	@@ -6499,16 +7229,14 @@
6499	7229	/*
6500	7230	* called from OPEN, CLAIM_PREVIOUS with a new clientid. */
6501	7231	struct nfs4_client_reclaim *
6502		-nfsd4_find_reclaim_client(const char recdir, struct nfsd_net nn)
	7232	+nfsd4_find_reclaim_client(struct xdr_netobj name, struct nfsd_net *nn)
6503	7233	{
6504	7234	unsigned int strhashval;
6505	7235	struct nfs4_client_reclaim *crp = NULL;
6506	7236
6507		- dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
6508		-
6509		- strhashval = clientstr_hashval(recdir);
	7237	+ strhashval = clientstr_hashval(name);
6510	7238	list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
6511		- if (same_name(crp->cr_recdir, recdir)) {
	7239	+ if (compare_blob(&crp->cr_name, &name) == 0) {
6512	7240	return crp;
6513	7241	}
6514	7242	}
..	..	@@ -6526,7 +7254,7 @@
6526	7254	__be32 status;
6527	7255
6528	7256	/* find clientid in conf_id_hashtbl */
6529		- status = lookup_clientid(clid, cstate, nn);
	7257	+ status = lookup_clientid(clid, cstate, nn, false);
6530	7258	if (status)
6531	7259	return nfserr_reclaim_bad;
6532	7260
..	..	@@ -6538,596 +7266,6 @@
6538	7266
6539	7267	return nfs_ok;
6540	7268	}
6541		-
6542		-#ifdef CONFIG_NFSD_FAULT_INJECTION
6543		-static inline void
6544		-put_client(struct nfs4_client *clp)
6545		-{
6546		- atomic_dec(&clp->cl_refcount);
6547		-}
6548		-
6549		-static struct nfs4_client *
6550		-nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
6551		-{
6552		- struct nfs4_client *clp;
6553		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6554		- nfsd_net_id);
6555		-
6556		- if (!nfsd_netns_ready(nn))
6557		- return NULL;
6558		-
6559		- list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6560		- if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
6561		- return clp;
6562		- }
6563		- return NULL;
6564		-}
6565		-
6566		-u64
6567		-nfsd_inject_print_clients(void)
6568		-{
6569		- struct nfs4_client *clp;
6570		- u64 count = 0;
6571		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6572		- nfsd_net_id);
6573		- char buf[INET6_ADDRSTRLEN];
6574		-
6575		- if (!nfsd_netns_ready(nn))
6576		- return 0;
6577		-
6578		- spin_lock(&nn->client_lock);
6579		- list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6580		- rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
6581		- pr_info("NFS Client: %s\n", buf);
6582		- ++count;
6583		- }
6584		- spin_unlock(&nn->client_lock);
6585		-
6586		- return count;
6587		-}
6588		-
6589		-u64
6590		-nfsd_inject_forget_client(struct sockaddr_storage *addr, size_t addr_size)
6591		-{
6592		- u64 count = 0;
6593		- struct nfs4_client *clp;
6594		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6595		- nfsd_net_id);
6596		-
6597		- if (!nfsd_netns_ready(nn))
6598		- return count;
6599		-
6600		- spin_lock(&nn->client_lock);
6601		- clp = nfsd_find_client(addr, addr_size);
6602		- if (clp) {
6603		- if (mark_client_expired_locked(clp) == nfs_ok)
6604		- ++count;
6605		- else
6606		- clp = NULL;
6607		- }
6608		- spin_unlock(&nn->client_lock);
6609		-
6610		- if (clp)
6611		- expire_client(clp);
6612		-
6613		- return count;
6614		-}
6615		-
6616		-u64
6617		-nfsd_inject_forget_clients(u64 max)
6618		-{
6619		- u64 count = 0;
6620		- struct nfs4_client clp, next;
6621		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6622		- nfsd_net_id);
6623		- LIST_HEAD(reaplist);
6624		-
6625		- if (!nfsd_netns_ready(nn))
6626		- return count;
6627		-
6628		- spin_lock(&nn->client_lock);
6629		- list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
6630		- if (mark_client_expired_locked(clp) == nfs_ok) {
6631		- list_add(&clp->cl_lru, &reaplist);
6632		- if (max != 0 && ++count >= max)
6633		- break;
6634		- }
6635		- }
6636		- spin_unlock(&nn->client_lock);
6637		-
6638		- list_for_each_entry_safe(clp, next, &reaplist, cl_lru)
6639		- expire_client(clp);
6640		-
6641		- return count;
6642		-}
6643		-
6644		-static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
6645		- const char *type)
6646		-{
6647		- char buf[INET6_ADDRSTRLEN];
6648		- rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
6649		- printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
6650		-}
6651		-
6652		-static void
6653		-nfsd_inject_add_lock_to_list(struct nfs4_ol_stateid *lst,
6654		- struct list_head *collect)
6655		-{
6656		- struct nfs4_client *clp = lst->st_stid.sc_client;
6657		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6658		- nfsd_net_id);
6659		-
6660		- if (!collect)
6661		- return;
6662		-
6663		- lockdep_assert_held(&nn->client_lock);
6664		- atomic_inc(&clp->cl_refcount);
6665		- list_add(&lst->st_locks, collect);
6666		-}
6667		-
6668		-static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max,
6669		- struct list_head *collect,
6670		- bool (func)(struct nfs4_ol_stateid ))
6671		-{
6672		- struct nfs4_openowner *oop;
6673		- struct nfs4_ol_stateid stp, st_next;
6674		- struct nfs4_ol_stateid lst, lst_next;
6675		- u64 count = 0;
6676		-
6677		- spin_lock(&clp->cl_lock);
6678		- list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
6679		- list_for_each_entry_safe(stp, st_next,
6680		- &oop->oo_owner.so_stateids, st_perstateowner) {
6681		- list_for_each_entry_safe(lst, lst_next,
6682		- &stp->st_locks, st_locks) {
6683		- if (func) {
6684		- if (func(lst))
6685		- nfsd_inject_add_lock_to_list(lst,
6686		- collect);
6687		- }
6688		- ++count;
6689		- /*
6690		- * Despite the fact that these functions deal
6691		- * with 64-bit integers for "count", we must
6692		- * ensure that it doesn't blow up the
6693		- * clp->cl_refcount. Throw a warning if we
6694		- * start to approach INT_MAX here.
6695		- */
6696		- WARN_ON_ONCE(count == (INT_MAX / 2));
6697		- if (count == max)
6698		- goto out;
6699		- }
6700		- }
6701		- }
6702		-out:
6703		- spin_unlock(&clp->cl_lock);
6704		-
6705		- return count;
6706		-}
6707		-
6708		-static u64
6709		-nfsd_collect_client_locks(struct nfs4_client clp, struct list_head collect,
6710		- u64 max)
6711		-{
6712		- return nfsd_foreach_client_lock(clp, max, collect, unhash_lock_stateid);
6713		-}
6714		-
6715		-static u64
6716		-nfsd_print_client_locks(struct nfs4_client *clp)
6717		-{
6718		- u64 count = nfsd_foreach_client_lock(clp, 0, NULL, NULL);
6719		- nfsd_print_count(clp, count, "locked files");
6720		- return count;
6721		-}
6722		-
6723		-u64
6724		-nfsd_inject_print_locks(void)
6725		-{
6726		- struct nfs4_client *clp;
6727		- u64 count = 0;
6728		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6729		- nfsd_net_id);
6730		-
6731		- if (!nfsd_netns_ready(nn))
6732		- return 0;
6733		-
6734		- spin_lock(&nn->client_lock);
6735		- list_for_each_entry(clp, &nn->client_lru, cl_lru)
6736		- count += nfsd_print_client_locks(clp);
6737		- spin_unlock(&nn->client_lock);
6738		-
6739		- return count;
6740		-}
6741		-
6742		-static void
6743		-nfsd_reap_locks(struct list_head *reaplist)
6744		-{
6745		- struct nfs4_client *clp;
6746		- struct nfs4_ol_stateid stp, next;
6747		-
6748		- list_for_each_entry_safe(stp, next, reaplist, st_locks) {
6749		- list_del_init(&stp->st_locks);
6750		- clp = stp->st_stid.sc_client;
6751		- nfs4_put_stid(&stp->st_stid);
6752		- put_client(clp);
6753		- }
6754		-}
6755		-
6756		-u64
6757		-nfsd_inject_forget_client_locks(struct sockaddr_storage *addr, size_t addr_size)
6758		-{
6759		- unsigned int count = 0;
6760		- struct nfs4_client *clp;
6761		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6762		- nfsd_net_id);
6763		- LIST_HEAD(reaplist);
6764		-
6765		- if (!nfsd_netns_ready(nn))
6766		- return count;
6767		-
6768		- spin_lock(&nn->client_lock);
6769		- clp = nfsd_find_client(addr, addr_size);
6770		- if (clp)
6771		- count = nfsd_collect_client_locks(clp, &reaplist, 0);
6772		- spin_unlock(&nn->client_lock);
6773		- nfsd_reap_locks(&reaplist);
6774		- return count;
6775		-}
6776		-
6777		-u64
6778		-nfsd_inject_forget_locks(u64 max)
6779		-{
6780		- u64 count = 0;
6781		- struct nfs4_client *clp;
6782		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6783		- nfsd_net_id);
6784		- LIST_HEAD(reaplist);
6785		-
6786		- if (!nfsd_netns_ready(nn))
6787		- return count;
6788		-
6789		- spin_lock(&nn->client_lock);
6790		- list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6791		- count += nfsd_collect_client_locks(clp, &reaplist, max - count);
6792		- if (max != 0 && count >= max)
6793		- break;
6794		- }
6795		- spin_unlock(&nn->client_lock);
6796		- nfsd_reap_locks(&reaplist);
6797		- return count;
6798		-}
6799		-
6800		-static u64
6801		-nfsd_foreach_client_openowner(struct nfs4_client *clp, u64 max,
6802		- struct list_head *collect,
6803		- void (func)(struct nfs4_openowner ))
6804		-{
6805		- struct nfs4_openowner oop, next;
6806		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6807		- nfsd_net_id);
6808		- u64 count = 0;
6809		-
6810		- lockdep_assert_held(&nn->client_lock);
6811		-
6812		- spin_lock(&clp->cl_lock);
6813		- list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
6814		- if (func) {
6815		- func(oop);
6816		- if (collect) {
6817		- atomic_inc(&clp->cl_refcount);
6818		- list_add(&oop->oo_perclient, collect);
6819		- }
6820		- }
6821		- ++count;
6822		- /*
6823		- * Despite the fact that these functions deal with
6824		- * 64-bit integers for "count", we must ensure that
6825		- * it doesn't blow up the clp->cl_refcount. Throw a
6826		- * warning if we start to approach INT_MAX here.
6827		- */
6828		- WARN_ON_ONCE(count == (INT_MAX / 2));
6829		- if (count == max)
6830		- break;
6831		- }
6832		- spin_unlock(&clp->cl_lock);
6833		-
6834		- return count;
6835		-}
6836		-
6837		-static u64
6838		-nfsd_print_client_openowners(struct nfs4_client *clp)
6839		-{
6840		- u64 count = nfsd_foreach_client_openowner(clp, 0, NULL, NULL);
6841		-
6842		- nfsd_print_count(clp, count, "openowners");
6843		- return count;
6844		-}
6845		-
6846		-static u64
6847		-nfsd_collect_client_openowners(struct nfs4_client *clp,
6848		- struct list_head *collect, u64 max)
6849		-{
6850		- return nfsd_foreach_client_openowner(clp, max, collect,
6851		- unhash_openowner_locked);
6852		-}
6853		-
6854		-u64
6855		-nfsd_inject_print_openowners(void)
6856		-{
6857		- struct nfs4_client *clp;
6858		- u64 count = 0;
6859		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6860		- nfsd_net_id);
6861		-
6862		- if (!nfsd_netns_ready(nn))
6863		- return 0;
6864		-
6865		- spin_lock(&nn->client_lock);
6866		- list_for_each_entry(clp, &nn->client_lru, cl_lru)
6867		- count += nfsd_print_client_openowners(clp);
6868		- spin_unlock(&nn->client_lock);
6869		-
6870		- return count;
6871		-}
6872		-
6873		-static void
6874		-nfsd_reap_openowners(struct list_head *reaplist)
6875		-{
6876		- struct nfs4_client *clp;
6877		- struct nfs4_openowner oop, next;
6878		-
6879		- list_for_each_entry_safe(oop, next, reaplist, oo_perclient) {
6880		- list_del_init(&oop->oo_perclient);
6881		- clp = oop->oo_owner.so_client;
6882		- release_openowner(oop);
6883		- put_client(clp);
6884		- }
6885		-}
6886		-
6887		-u64
6888		-nfsd_inject_forget_client_openowners(struct sockaddr_storage *addr,
6889		- size_t addr_size)
6890		-{
6891		- unsigned int count = 0;
6892		- struct nfs4_client *clp;
6893		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6894		- nfsd_net_id);
6895		- LIST_HEAD(reaplist);
6896		-
6897		- if (!nfsd_netns_ready(nn))
6898		- return count;
6899		-
6900		- spin_lock(&nn->client_lock);
6901		- clp = nfsd_find_client(addr, addr_size);
6902		- if (clp)
6903		- count = nfsd_collect_client_openowners(clp, &reaplist, 0);
6904		- spin_unlock(&nn->client_lock);
6905		- nfsd_reap_openowners(&reaplist);
6906		- return count;
6907		-}
6908		-
6909		-u64
6910		-nfsd_inject_forget_openowners(u64 max)
6911		-{
6912		- u64 count = 0;
6913		- struct nfs4_client *clp;
6914		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6915		- nfsd_net_id);
6916		- LIST_HEAD(reaplist);
6917		-
6918		- if (!nfsd_netns_ready(nn))
6919		- return count;
6920		-
6921		- spin_lock(&nn->client_lock);
6922		- list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6923		- count += nfsd_collect_client_openowners(clp, &reaplist,
6924		- max - count);
6925		- if (max != 0 && count >= max)
6926		- break;
6927		- }
6928		- spin_unlock(&nn->client_lock);
6929		- nfsd_reap_openowners(&reaplist);
6930		- return count;
6931		-}
6932		-
6933		-static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
6934		- struct list_head *victims)
6935		-{
6936		- struct nfs4_delegation dp, next;
6937		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6938		- nfsd_net_id);
6939		- u64 count = 0;
6940		-
6941		- lockdep_assert_held(&nn->client_lock);
6942		-
6943		- spin_lock(&state_lock);
6944		- list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
6945		- if (victims) {
6946		- /*
6947		- * It's not safe to mess with delegations that have a
6948		- * non-zero dl_time. They might have already been broken
6949		- * and could be processed by the laundromat outside of
6950		- * the state_lock. Just leave them be.
6951		- */
6952		- if (dp->dl_time != 0)
6953		- continue;
6954		-
6955		- atomic_inc(&clp->cl_refcount);
6956		- WARN_ON(!unhash_delegation_locked(dp));
6957		- list_add(&dp->dl_recall_lru, victims);
6958		- }
6959		- ++count;
6960		- /*
6961		- * Despite the fact that these functions deal with
6962		- * 64-bit integers for "count", we must ensure that
6963		- * it doesn't blow up the clp->cl_refcount. Throw a
6964		- * warning if we start to approach INT_MAX here.
6965		- */
6966		- WARN_ON_ONCE(count == (INT_MAX / 2));
6967		- if (count == max)
6968		- break;
6969		- }
6970		- spin_unlock(&state_lock);
6971		- return count;
6972		-}
6973		-
6974		-static u64
6975		-nfsd_print_client_delegations(struct nfs4_client *clp)
6976		-{
6977		- u64 count = nfsd_find_all_delegations(clp, 0, NULL);
6978		-
6979		- nfsd_print_count(clp, count, "delegations");
6980		- return count;
6981		-}
6982		-
6983		-u64
6984		-nfsd_inject_print_delegations(void)
6985		-{
6986		- struct nfs4_client *clp;
6987		- u64 count = 0;
6988		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
6989		- nfsd_net_id);
6990		-
6991		- if (!nfsd_netns_ready(nn))
6992		- return 0;
6993		-
6994		- spin_lock(&nn->client_lock);
6995		- list_for_each_entry(clp, &nn->client_lru, cl_lru)
6996		- count += nfsd_print_client_delegations(clp);
6997		- spin_unlock(&nn->client_lock);
6998		-
6999		- return count;
7000		-}
7001		-
7002		-static void
7003		-nfsd_forget_delegations(struct list_head *reaplist)
7004		-{
7005		- struct nfs4_client *clp;
7006		- struct nfs4_delegation dp, next;
7007		-
7008		- list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) {
7009		- list_del_init(&dp->dl_recall_lru);
7010		- clp = dp->dl_stid.sc_client;
7011		- revoke_delegation(dp);
7012		- put_client(clp);
7013		- }
7014		-}
7015		-
7016		-u64
7017		-nfsd_inject_forget_client_delegations(struct sockaddr_storage *addr,
7018		- size_t addr_size)
7019		-{
7020		- u64 count = 0;
7021		- struct nfs4_client *clp;
7022		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
7023		- nfsd_net_id);
7024		- LIST_HEAD(reaplist);
7025		-
7026		- if (!nfsd_netns_ready(nn))
7027		- return count;
7028		-
7029		- spin_lock(&nn->client_lock);
7030		- clp = nfsd_find_client(addr, addr_size);
7031		- if (clp)
7032		- count = nfsd_find_all_delegations(clp, 0, &reaplist);
7033		- spin_unlock(&nn->client_lock);
7034		-
7035		- nfsd_forget_delegations(&reaplist);
7036		- return count;
7037		-}
7038		-
7039		-u64
7040		-nfsd_inject_forget_delegations(u64 max)
7041		-{
7042		- u64 count = 0;
7043		- struct nfs4_client *clp;
7044		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
7045		- nfsd_net_id);
7046		- LIST_HEAD(reaplist);
7047		-
7048		- if (!nfsd_netns_ready(nn))
7049		- return count;
7050		-
7051		- spin_lock(&nn->client_lock);
7052		- list_for_each_entry(clp, &nn->client_lru, cl_lru) {
7053		- count += nfsd_find_all_delegations(clp, max - count, &reaplist);
7054		- if (max != 0 && count >= max)
7055		- break;
7056		- }
7057		- spin_unlock(&nn->client_lock);
7058		- nfsd_forget_delegations(&reaplist);
7059		- return count;
7060		-}
7061		-
7062		-static void
7063		-nfsd_recall_delegations(struct list_head *reaplist)
7064		-{
7065		- struct nfs4_client *clp;
7066		- struct nfs4_delegation dp, next;
7067		-
7068		- list_for_each_entry_safe(dp, next, reaplist, dl_recall_lru) {
7069		- list_del_init(&dp->dl_recall_lru);
7070		- clp = dp->dl_stid.sc_client;
7071		- /*
7072		- * We skipped all entries that had a zero dl_time before,
7073		- * so we can now reset the dl_time back to 0. If a delegation
7074		- * break comes in now, then it won't make any difference since
7075		- * we're recalling it either way.
7076		- */
7077		- spin_lock(&state_lock);
7078		- dp->dl_time = 0;
7079		- spin_unlock(&state_lock);
7080		- nfsd_break_one_deleg(dp);
7081		- put_client(clp);
7082		- }
7083		-}
7084		-
7085		-u64
7086		-nfsd_inject_recall_client_delegations(struct sockaddr_storage *addr,
7087		- size_t addr_size)
7088		-{
7089		- u64 count = 0;
7090		- struct nfs4_client *clp;
7091		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
7092		- nfsd_net_id);
7093		- LIST_HEAD(reaplist);
7094		-
7095		- if (!nfsd_netns_ready(nn))
7096		- return count;
7097		-
7098		- spin_lock(&nn->client_lock);
7099		- clp = nfsd_find_client(addr, addr_size);
7100		- if (clp)
7101		- count = nfsd_find_all_delegations(clp, 0, &reaplist);
7102		- spin_unlock(&nn->client_lock);
7103		-
7104		- nfsd_recall_delegations(&reaplist);
7105		- return count;
7106		-}
7107		-
7108		-u64
7109		-nfsd_inject_recall_delegations(u64 max)
7110		-{
7111		- u64 count = 0;
7112		- struct nfs4_client clp, next;
7113		- struct nfsd_net *nn = net_generic(current->nsproxy->net_ns,
7114		- nfsd_net_id);
7115		- LIST_HEAD(reaplist);
7116		-
7117		- if (!nfsd_netns_ready(nn))
7118		- return count;
7119		-
7120		- spin_lock(&nn->client_lock);
7121		- list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
7122		- count += nfsd_find_all_delegations(clp, max - count, &reaplist);
7123		- if (max != 0 && ++count >= max)
7124		- break;
7125		- }
7126		- spin_unlock(&nn->client_lock);
7127		- nfsd_recall_delegations(&reaplist);
7128		- return count;
7129		-}
7130		-#endif /* CONFIG_NFSD_FAULT_INJECTION */
7131	7269
7132	7270	/*
7133	7271	* Since the lifetime of a delegation isn't limited to that of an open, a
..	..	@@ -7179,7 +7317,7 @@
7179	7317	INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
7180	7318	nn->conf_name_tree = RB_ROOT;
7181	7319	nn->unconf_name_tree = RB_ROOT;
7182		- nn->boot_time = get_seconds();
	7320	+ nn->boot_time = ktime_get_real_seconds();
7183	7321	nn->grace_ended = false;
7184	7322	nn->nfsd4_manager.block_opens = true;
7185	7323	INIT_LIST_HEAD(&nn->nfsd4_manager.list);
..	..	@@ -7187,6 +7325,8 @@
7187	7325	INIT_LIST_HEAD(&nn->close_lru);
7188	7326	INIT_LIST_HEAD(&nn->del_recall_lru);
7189	7327	spin_lock_init(&nn->client_lock);
	7328	+ spin_lock_init(&nn->s2s_cp_lock);
	7329	+ idr_init(&nn->s2s_cp_stateids);
7190	7330
7191	7331	spin_lock_init(&nn->blocked_locks_lock);
7192	7332	INIT_LIST_HEAD(&nn->blocked_locks_lru);
..	..	@@ -7239,14 +7379,29 @@
7239	7379	struct nfsd_net *nn = net_generic(net, nfsd_net_id);
7240	7380	int ret;
7241	7381
7242		- ret = nfs4_state_create_net(net);
	7382	+ ret = get_nfsdfs(net);
7243	7383	if (ret)
7244	7384	return ret;
	7385	+ ret = nfs4_state_create_net(net);
	7386	+ if (ret) {
	7387	+ mntput(nn->nfsd_mnt);
	7388	+ return ret;
	7389	+ }
7245	7390	locks_start_grace(net, &nn->nfsd4_manager);
7246	7391	nfsd4_client_tracking_init(net);
7247		- printk(KERN_INFO "NFSD: starting %ld-second grace period (net %x)\n",
	7392	+ if (nn->track_reclaim_completes && nn->reclaim_str_hashtbl_size == 0)
	7393	+ goto skip_grace;
	7394	+ printk(KERN_INFO "NFSD: starting %lld-second grace period (net %x)\n",
7248	7395	nn->nfsd4_grace, net->ns.inum);
	7396	+ trace_nfsd_grace_start(nn);
7249	7397	queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
	7398	+ return 0;
	7399	+
	7400	+skip_grace:
	7401	+ printk(KERN_INFO "NFSD: no clients to reclaim, skipping NFSv4 grace period (net %x)\n",
	7402	+ net->ns.inum);
	7403	+ queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_lease * HZ);
	7404	+ nfsd4_end_grace(nn);
7250	7405	return 0;
7251	7406	}
7252	7407
..	..	@@ -7301,6 +7456,7 @@
7301	7456
7302	7457	nfsd4_client_tracking_exit(net);
7303	7458	nfs4_state_destroy_net(net);
	7459	+ mntput(nn->nfsd_mnt);
7304	7460	}
7305	7461
7306	7462	void
..	..	@@ -7313,7 +7469,8 @@
7313	7469	static void
7314	7470	get_stateid(struct nfsd4_compound_state cstate, stateid_t stateid)
7315	7471	{
7316		- if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
	7472	+ if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG) &&
	7473	+ CURRENT_STATEID(stateid))
7317	7474	memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
7318	7475	}
7319	7476
..	..	@@ -7322,14 +7479,14 @@
7322	7479	{
7323	7480	if (cstate->minorversion) {
7324	7481	memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
7325		- SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
	7482	+ SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
7326	7483	}
7327	7484	}
7328	7485
7329	7486	void
7330	7487	clear_current_stateid(struct nfsd4_compound_state *cstate)
7331	7488	{
7332		- CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
	7489	+ CLEAR_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
7333	7490	}
7334	7491
7335	7492	/*