1	/*
2	* Copyright (c) 2001 The Regents of the University of Michigan.
3	* All rights reserved.
4	*
5	* Kendrick Smith <kmsmith@umich.edu>
6	* Andy Adamson <kandros@umich.edu>
7	*
8	* Redistribution and use in source and binary forms, with or without
9	* modification, are permitted provided that the following conditions
10	* are met:
11	*
12	* 1. Redistributions of source code must retain the above copyright
13	* notice, this list of conditions and the following disclaimer.
14	* 2. Redistributions in binary form must reproduce the above copyright
15	* notice, this list of conditions and the following disclaimer in the
16	* documentation and/or other materials provided with the distribution.
17	* 3. Neither the name of the University nor the names of its
18	* contributors may be used to endorse or promote products derived
19	* from this software without specific prior written permission.
20	*
21	* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
22	* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
23	* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24	* DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26	* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27	* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
28	* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
29	* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
30	* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
31	* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32	*
33	*/
34
35	#include <linux/file.h>
36	#include <linux/fs.h>
37	#include <linux/slab.h>
38	#include <linux/namei.h>
39	#include <linux/swap.h>
40	#include <linux/pagemap.h>
41	#include <linux/ratelimit.h>
42	#include <linux/sunrpc/svcauth_gss.h>
43	#include <linux/sunrpc/addr.h>
44	#include <linux/jhash.h>
45	#include <linux/string_helpers.h>
46	#include <linux/fsnotify.h>
47	#include <linux/rhashtable.h>
48	#include <linux/nfs_ssc.h>
49
50	#include "xdr4.h"
51	#include "xdr4cb.h"
52	#include "vfs.h"
53	#include "current_stateid.h"
54
55	#include "netns.h"
56	#include "pnfs.h"
57	#include "filecache.h"
58	#include "trace.h"
59
60	#define NFSDDBG_FACILITY NFSDDBG_PROC
61
62	#define all_ones {{ ~0, ~0}, ~0}
63	static const stateid_t one_stateid = {
64	.si_generation = ~0,
65	.si_opaque = all_ones,
66	};
67	static const stateid_t zero_stateid = {
68	/* all fields zero */
69	};
70	static const stateid_t currentstateid = {
71	.si_generation = 1,
72	};
73	static const stateid_t close_stateid = {
74	.si_generation = 0xffffffffU,
75	};
76
77	static u64 current_sessionid = 1;
78
79	#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
80	#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
81	#define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
82	#define CLOSE_STATEID(stateid) (!memcmp((stateid), &close_stateid, sizeof(stateid_t)))
83
84	/* forward declarations */
85	static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
86	static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
87	void nfsd4_end_grace(struct nfsd_net *nn);
88	static void _free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps);
89	static void nfsd4_file_hash_remove(struct nfs4_file *fi);
90	static void deleg_reaper(struct nfsd_net *nn);
91
92	/* Locking: */
93
94	/*
95	* Currently used for the del_recall_lru and file hash table. In an
96	* effort to decrease the scope of the client_mutex, this spinlock may
97	* eventually cover more:
98	*/
99	static DEFINE_SPINLOCK(state_lock);
100
101	enum nfsd4_st_mutex_lock_subclass {
102	OPEN_STATEID_MUTEX = 0,
103	LOCK_STATEID_MUTEX = 1,
104	};
105
106	/*
107	* A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for
108	* the refcount on the open stateid to drop.
109	*/
110	static DECLARE_WAIT_QUEUE_HEAD(close_wq);
111
112	/*
113	* A waitqueue where a writer to clients/#/ctl destroying a client can
114	* wait for cl_rpc_users to drop to 0 and then for the client to be
115	* unhashed.
116	*/
117	static DECLARE_WAIT_QUEUE_HEAD(expiry_wq);
118
119	static struct kmem_cache *client_slab;
120	static struct kmem_cache *openowner_slab;
121	static struct kmem_cache *lockowner_slab;
122	static struct kmem_cache *file_slab;
123	static struct kmem_cache *stateid_slab;
124	static struct kmem_cache *deleg_slab;
125	static struct kmem_cache *odstate_slab;
126
127	static void free_session(struct nfsd4_session *);
128
129	static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
130	static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
131	static const struct nfsd4_callback_ops nfsd4_cb_getattr_ops;
132
133	static struct workqueue_struct *laundry_wq;
134
135	int nfsd4_create_laundry_wq(void)
136	{
137	int rc = 0;
138
139	laundry_wq = alloc_workqueue(fmt: "%s", flags: WQ_UNBOUND, max_active: 0, "nfsd4");
140	if (laundry_wq == NULL)
141	rc = -ENOMEM;
142	return rc;
143	}
144
145	void nfsd4_destroy_laundry_wq(void)
146	{
147	destroy_workqueue(wq: laundry_wq);
148	}
149
150	static bool is_session_dead(struct nfsd4_session *ses)
151	{
152	return ses->se_flags & NFS4_SESSION_DEAD;
153	}
154
155	static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
156	{
157	if (atomic_read(v: &ses->se_ref) > ref_held_by_me)
158	return nfserr_jukebox;
159	ses->se_flags |= NFS4_SESSION_DEAD;
160	return nfs_ok;
161	}
162
163	static bool is_client_expired(struct nfs4_client *clp)
164	{
165	return clp->cl_time == 0;
166	}
167
168	static void nfsd4_dec_courtesy_client_count(struct nfsd_net *nn,
169	struct nfs4_client *clp)
170	{
171	if (clp->cl_state != NFSD4_ACTIVE)
172	atomic_add_unless(v: &nn->nfsd_courtesy_clients, a: -1, u: 0);
173	}
174
175	static __be32 get_client_locked(struct nfs4_client *clp)
176	{
177	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
178
179	lockdep_assert_held(&nn->client_lock);
180
181	if (is_client_expired(clp))
182	return nfserr_expired;
183	atomic_inc(v: &clp->cl_rpc_users);
184	nfsd4_dec_courtesy_client_count(nn, clp);
185	clp->cl_state = NFSD4_ACTIVE;
186	return nfs_ok;
187	}
188
189	/* must be called under the client_lock */
190	static inline void
191	renew_client_locked(struct nfs4_client *clp)
192	{
193	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
194
195	if (is_client_expired(clp)) {
196	WARN_ON(1);
197	printk("%s: client (clientid %08x/%08x) already expired\n",
198	__func__,
199	clp->cl_clientid.cl_boot,
200	clp->cl_clientid.cl_id);
201	return;
202	}
203
204	list_move_tail(list: &clp->cl_lru, head: &nn->client_lru);
205	clp->cl_time = ktime_get_boottime_seconds();
206	nfsd4_dec_courtesy_client_count(nn, clp);
207	clp->cl_state = NFSD4_ACTIVE;
208	}
209
210	static void put_client_renew_locked(struct nfs4_client *clp)
211	{
212	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
213
214	lockdep_assert_held(&nn->client_lock);
215
216	if (!atomic_dec_and_test(v: &clp->cl_rpc_users))
217	return;
218	if (!is_client_expired(clp))
219	renew_client_locked(clp);
220	else
221	wake_up_all(&expiry_wq);
222	}
223
224	static void put_client_renew(struct nfs4_client *clp)
225	{
226	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
227
228	if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock))
229	return;
230	if (!is_client_expired(clp))
231	renew_client_locked(clp);
232	else
233	wake_up_all(&expiry_wq);
234	spin_unlock(lock: &nn->client_lock);
235	}
236
237	static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
238	{
239	__be32 status;
240
241	if (is_session_dead(ses))
242	return nfserr_badsession;
243	status = get_client_locked(clp: ses->se_client);
244	if (status)
245	return status;
246	atomic_inc(v: &ses->se_ref);
247	return nfs_ok;
248	}
249
250	static void nfsd4_put_session_locked(struct nfsd4_session *ses)
251	{
252	struct nfs4_client *clp = ses->se_client;
253	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
254
255	lockdep_assert_held(&nn->client_lock);
256
257	if (atomic_dec_and_test(v: &ses->se_ref) && is_session_dead(ses))
258	free_session(ses);
259	put_client_renew_locked(clp);
260	}
261
262	static void nfsd4_put_session(struct nfsd4_session *ses)
263	{
264	struct nfs4_client *clp = ses->se_client;
265	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
266
267	spin_lock(lock: &nn->client_lock);
268	nfsd4_put_session_locked(ses);
269	spin_unlock(lock: &nn->client_lock);
270	}
271
272	static struct nfsd4_blocked_lock *
273	find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
274	struct nfsd_net *nn)
275	{
276	struct nfsd4_blocked_lock *cur, *found = NULL;
277
278	spin_lock(lock: &nn->blocked_locks_lock);
279	list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
280	if (fh_match(fh1: fh, fh2: &cur->nbl_fh)) {
281	list_del_init(entry: &cur->nbl_list);
282	WARN_ON(list_empty(&cur->nbl_lru));
283	list_del_init(entry: &cur->nbl_lru);
284	found = cur;
285	break;
286	}
287	}
288	spin_unlock(lock: &nn->blocked_locks_lock);
289	if (found)
290	locks_delete_block(&found->nbl_lock);
291	return found;
292	}
293
294	static struct nfsd4_blocked_lock *
295	find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
296	struct nfsd_net *nn)
297	{
298	struct nfsd4_blocked_lock *nbl;
299
300	nbl = find_blocked_lock(lo, fh, nn);
301	if (!nbl) {
302	nbl = kmalloc(size: sizeof(*nbl), GFP_KERNEL);
303	if (nbl) {
304	INIT_LIST_HEAD(list: &nbl->nbl_list);
305	INIT_LIST_HEAD(list: &nbl->nbl_lru);
306	fh_copy_shallow(dst: &nbl->nbl_fh, src: fh);
307	locks_init_lock(&nbl->nbl_lock);
308	kref_init(kref: &nbl->nbl_kref);
309	nfsd4_init_cb(cb: &nbl->nbl_cb, clp: lo->lo_owner.so_client,
310	ops: &nfsd4_cb_notify_lock_ops,
311	op: NFSPROC4_CLNT_CB_NOTIFY_LOCK);
312	}
313	}
314	return nbl;
315	}
316
317	static void
318	free_nbl(struct kref *kref)
319	{
320	struct nfsd4_blocked_lock *nbl;
321
322	nbl = container_of(kref, struct nfsd4_blocked_lock, nbl_kref);
323	locks_release_private(&nbl->nbl_lock);
324	kfree(objp: nbl);
325	}
326
327	static void
328	free_blocked_lock(struct nfsd4_blocked_lock *nbl)
329	{
330	locks_delete_block(&nbl->nbl_lock);
331	kref_put(kref: &nbl->nbl_kref, release: free_nbl);
332	}
333
334	static void
335	remove_blocked_locks(struct nfs4_lockowner *lo)
336	{
337	struct nfs4_client *clp = lo->lo_owner.so_client;
338	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
339	struct nfsd4_blocked_lock *nbl;
340	LIST_HEAD(reaplist);
341
342	/* Dequeue all blocked locks */
343	spin_lock(lock: &nn->blocked_locks_lock);
344	while (!list_empty(head: &lo->lo_blocked)) {
345	nbl = list_first_entry(&lo->lo_blocked,
346	struct nfsd4_blocked_lock,
347	nbl_list);
348	list_del_init(entry: &nbl->nbl_list);
349	WARN_ON(list_empty(&nbl->nbl_lru));
350	list_move(list: &nbl->nbl_lru, head: &reaplist);
351	}
352	spin_unlock(lock: &nn->blocked_locks_lock);
353
354	/* Now free them */
355	while (!list_empty(head: &reaplist)) {
356	nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
357	nbl_lru);
358	list_del_init(entry: &nbl->nbl_lru);
359	free_blocked_lock(nbl);
360	}
361	}
362
363	static void
364	nfsd4_cb_notify_lock_prepare(struct nfsd4_callback *cb)
365	{
366	struct nfsd4_blocked_lock *nbl = container_of(cb,
367	struct nfsd4_blocked_lock, nbl_cb);
368	locks_delete_block(&nbl->nbl_lock);
369	}
370
371	static int
372	nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
373	{
374	trace_nfsd_cb_notify_lock_done(stp: &zero_stateid, task);
375
376	/*
377	* Since this is just an optimization, we don't try very hard if it
378	* turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and
379	* just quit trying on anything else.
380	*/
381	switch (task->tk_status) {
382	case -NFS4ERR_DELAY:
383	rpc_delay(task, 1 * HZ);
384	return 0;
385	default:
386	return 1;
387	}
388	}
389
390	static void
391	nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb)
392	{
393	struct nfsd4_blocked_lock *nbl = container_of(cb,
394	struct nfsd4_blocked_lock, nbl_cb);
395
396	free_blocked_lock(nbl);
397	}
398
399	static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
400	.prepare = nfsd4_cb_notify_lock_prepare,
401	.done = nfsd4_cb_notify_lock_done,
402	.release = nfsd4_cb_notify_lock_release,
403	};
404
405	/*
406	* We store the NONE, READ, WRITE, and BOTH bits separately in the
407	* st_{access,deny}_bmap field of the stateid, in order to track not
408	* only what share bits are currently in force, but also what
409	* combinations of share bits previous opens have used. This allows us
410	* to enforce the recommendation in
411	* https://datatracker.ietf.org/doc/html/rfc7530#section-16.19.4 that
412	* the server return an error if the client attempt to downgrade to a
413	* combination of share bits not explicable by closing some of its
414	* previous opens.
415	*
416	* This enforcement is arguably incomplete, since we don't keep
417	* track of access/deny bit combinations; so, e.g., we allow:
418	*
419	* OPEN allow read, deny write
420	* OPEN allow both, deny none
421	* DOWNGRADE allow read, deny none
422	*
423	* which we should reject.
424	*
425	* But you could also argue that our current code is already overkill,
426	* since it only exists to return NFS4ERR_INVAL on incorrect client
427	* behavior.
428	*/
429	static unsigned int
430	bmap_to_share_mode(unsigned long bmap)
431	{
432	int i;
433	unsigned int access = 0;
434
435	for (i = 1; i < 4; i++) {
436	if (test_bit(i, &bmap))
437	access |= i;
438	}
439	return access;
440	}
441
442	/* set share access for a given stateid */
443	static inline void
444	set_access(u32 access, struct nfs4_ol_stateid *stp)
445	{
446	unsigned char mask = 1 << access;
447
448	WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
449	stp->st_access_bmap |= mask;
450	}
451
452	/* clear share access for a given stateid */
453	static inline void
454	clear_access(u32 access, struct nfs4_ol_stateid *stp)
455	{
456	unsigned char mask = 1 << access;
457
458	WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
459	stp->st_access_bmap &= ~mask;
460	}
461
462	/* test whether a given stateid has access */
463	static inline bool
464	test_access(u32 access, struct nfs4_ol_stateid *stp)
465	{
466	unsigned char mask = 1 << access;
467
468	return (bool)(stp->st_access_bmap & mask);
469	}
470
471	/* set share deny for a given stateid */
472	static inline void
473	set_deny(u32 deny, struct nfs4_ol_stateid *stp)
474	{
475	unsigned char mask = 1 << deny;
476
477	WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
478	stp->st_deny_bmap |= mask;
479	}
480
481	/* clear share deny for a given stateid */
482	static inline void
483	clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
484	{
485	unsigned char mask = 1 << deny;
486
487	WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
488	stp->st_deny_bmap &= ~mask;
489	}
490
491	/* test whether a given stateid is denying specific access */
492	static inline bool
493	test_deny(u32 deny, struct nfs4_ol_stateid *stp)
494	{
495	unsigned char mask = 1 << deny;
496
497	return (bool)(stp->st_deny_bmap & mask);
498	}
499
500	static int nfs4_access_to_omode(u32 access)
501	{
502	switch (access & NFS4_SHARE_ACCESS_BOTH) {
503	case NFS4_SHARE_ACCESS_READ:
504	return O_RDONLY;
505	case NFS4_SHARE_ACCESS_WRITE:
506	return O_WRONLY;
507	case NFS4_SHARE_ACCESS_BOTH:
508	return O_RDWR;
509	}
510	WARN_ON_ONCE(1);
511	return O_RDONLY;
512	}
513
514	static inline int
515	access_permit_read(struct nfs4_ol_stateid *stp)
516	{
517	return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
518	test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
519	test_access(NFS4_SHARE_ACCESS_WRITE, stp);
520	}
521
522	static inline int
523	access_permit_write(struct nfs4_ol_stateid *stp)
524	{
525	return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
526	test_access(NFS4_SHARE_ACCESS_BOTH, stp);
527	}
528
529	static inline struct nfs4_stateowner *
530	nfs4_get_stateowner(struct nfs4_stateowner *sop)
531	{
532	atomic_inc(v: &sop->so_count);
533	return sop;
534	}
535
536	static int
537	same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
538	{
539	return (sop->so_owner.len == owner->len) &&
540	0 == memcmp(p: sop->so_owner.data, q: owner->data, size: owner->len);
541	}
542
543	static struct nfs4_openowner *
544	find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
545	struct nfs4_client *clp)
546	{
547	struct nfs4_stateowner *so;
548
549	lockdep_assert_held(&clp->cl_lock);
550
551	list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
552	so_strhash) {
553	if (!so->so_is_open_owner)
554	continue;
555	if (same_owner_str(sop: so, owner: &open->op_owner))
556	return openowner(so: nfs4_get_stateowner(sop: so));
557	}
558	return NULL;
559	}
560
561	static struct nfs4_openowner *
562	find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
563	struct nfs4_client *clp)
564	{
565	struct nfs4_openowner *oo;
566
567	spin_lock(lock: &clp->cl_lock);
568	oo = find_openstateowner_str_locked(hashval, open, clp);
569	spin_unlock(lock: &clp->cl_lock);
570	return oo;
571	}
572
573	static inline u32
574	opaque_hashval(const void *ptr, int nbytes)
575	{
576	unsigned char *cptr = (unsigned char *) ptr;
577
578	u32 x = 0;
579	while (nbytes--) {
580	x *= 37;
581	x += *cptr++;
582	}
583	return x;
584	}
585
586	static void nfsd4_free_file_rcu(struct rcu_head *rcu)
587	{
588	struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);
589
590	kmem_cache_free(s: file_slab, objp: fp);
591	}
592
593	void
594	put_nfs4_file(struct nfs4_file *fi)
595	{
596	if (refcount_dec_and_test(r: &fi->fi_ref)) {
597	nfsd4_file_hash_remove(fi);
598	WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
599	WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
600	call_rcu(head: &fi->fi_rcu, func: nfsd4_free_file_rcu);
601	}
602	}
603
604	static struct nfsd_file *
605	find_writeable_file_locked(struct nfs4_file *f)
606	{
607	struct nfsd_file *ret;
608
609	lockdep_assert_held(&f->fi_lock);
610
611	ret = nfsd_file_get(nf: f->fi_fds[O_WRONLY]);
612	if (!ret)
613	ret = nfsd_file_get(nf: f->fi_fds[O_RDWR]);
614	return ret;
615	}
616
617	static struct nfsd_file *
618	find_writeable_file(struct nfs4_file *f)
619	{
620	struct nfsd_file *ret;
621
622	spin_lock(lock: &f->fi_lock);
623	ret = find_writeable_file_locked(f);
624	spin_unlock(lock: &f->fi_lock);
625
626	return ret;
627	}
628
629	static struct nfsd_file *
630	find_readable_file_locked(struct nfs4_file *f)
631	{
632	struct nfsd_file *ret;
633
634	lockdep_assert_held(&f->fi_lock);
635
636	ret = nfsd_file_get(nf: f->fi_fds[O_RDONLY]);
637	if (!ret)
638	ret = nfsd_file_get(nf: f->fi_fds[O_RDWR]);
639	return ret;
640	}
641
642	static struct nfsd_file *
643	find_readable_file(struct nfs4_file *f)
644	{
645	struct nfsd_file *ret;
646
647	spin_lock(lock: &f->fi_lock);
648	ret = find_readable_file_locked(f);
649	spin_unlock(lock: &f->fi_lock);
650
651	return ret;
652	}
653
654	static struct nfsd_file *
655	find_rw_file(struct nfs4_file *f)
656	{
657	struct nfsd_file *ret;
658
659	spin_lock(lock: &f->fi_lock);
660	ret = nfsd_file_get(nf: f->fi_fds[O_RDWR]);
661	spin_unlock(lock: &f->fi_lock);
662
663	return ret;
664	}
665
666	struct nfsd_file *
667	find_any_file(struct nfs4_file *f)
668	{
669	struct nfsd_file *ret;
670
671	if (!f)
672	return NULL;
673	spin_lock(lock: &f->fi_lock);
674	ret = nfsd_file_get(nf: f->fi_fds[O_RDWR]);
675	if (!ret) {
676	ret = nfsd_file_get(nf: f->fi_fds[O_WRONLY]);
677	if (!ret)
678	ret = nfsd_file_get(nf: f->fi_fds[O_RDONLY]);
679	}
680	spin_unlock(lock: &f->fi_lock);
681	return ret;
682	}
683
684	static struct nfsd_file *find_any_file_locked(struct nfs4_file *f)
685	{
686	lockdep_assert_held(&f->fi_lock);
687
688	if (f->fi_fds[O_RDWR])
689	return f->fi_fds[O_RDWR];
690	if (f->fi_fds[O_WRONLY])
691	return f->fi_fds[O_WRONLY];
692	if (f->fi_fds[O_RDONLY])
693	return f->fi_fds[O_RDONLY];
694	return NULL;
695	}
696
697	static atomic_long_t num_delegations;
698	unsigned long max_delegations;
699
700	/*
701	* Open owner state (share locks)
702	*/
703
704	/* hash tables for lock and open owners */
705	#define OWNER_HASH_BITS 8
706	#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
707	#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
708
709	static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
710	{
711	unsigned int ret;
712
713	ret = opaque_hashval(ptr: ownername->data, nbytes: ownername->len);
714	return ret & OWNER_HASH_MASK;
715	}
716
717	static struct rhltable nfs4_file_rhltable ____cacheline_aligned_in_smp;
718
719	static const struct rhashtable_params nfs4_file_rhash_params = {
720	.key_len = sizeof_field(struct nfs4_file, fi_inode),
721	.key_offset = offsetof(struct nfs4_file, fi_inode),
722	.head_offset = offsetof(struct nfs4_file, fi_rlist),
723
724	/*
725	* Start with a single page hash table to reduce resizing churn
726	* on light workloads.
727	*/
728	.min_size = 256,
729	.automatic_shrinking = true,
730	};
731
732	/*
733	* Check if courtesy clients have conflicting access and resolve it if possible
734	*
735	* access: is op_share_access if share_access is true.
736	* Check if access mode, op_share_access, would conflict with
737	* the current deny mode of the file 'fp'.
738	* access: is op_share_deny if share_access is false.
739	* Check if the deny mode, op_share_deny, would conflict with
740	* current access of the file 'fp'.
741	* stp: skip checking this entry.
742	* new_stp: normal open, not open upgrade.
743	*
744	* Function returns:
745	* false - access/deny mode conflict with normal client.
746	* true - no conflict or conflict with courtesy client(s) is resolved.
747	*/
748	static bool
749	nfs4_resolve_deny_conflicts_locked(struct nfs4_file *fp, bool new_stp,
750	struct nfs4_ol_stateid *stp, u32 access, bool share_access)
751	{
752	struct nfs4_ol_stateid *st;
753	bool resolvable = true;
754	unsigned char bmap;
755	struct nfsd_net *nn;
756	struct nfs4_client *clp;
757
758	lockdep_assert_held(&fp->fi_lock);
759	list_for_each_entry(st, &fp->fi_stateids, st_perfile) {
760	/* ignore lock stateid */
761	if (st->st_openstp)
762	continue;
763	if (st == stp && new_stp)
764	continue;
765	/* check file access against deny mode or vice versa */
766	bmap = share_access ? st->st_deny_bmap : st->st_access_bmap;
767	if (!(access & bmap_to_share_mode(bmap)))
768	continue;
769	clp = st->st_stid.sc_client;
770	if (try_to_expire_client(clp))
771	continue;
772	resolvable = false;
773	break;
774	}
775	if (resolvable) {
776	clp = stp->st_stid.sc_client;
777	nn = net_generic(net: clp->net, id: nfsd_net_id);
778	mod_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: 0);
779	}
780	return resolvable;
781	}
782
783	static void
784	__nfs4_file_get_access(struct nfs4_file *fp, u32 access)
785	{
786	lockdep_assert_held(&fp->fi_lock);
787
788	if (access & NFS4_SHARE_ACCESS_WRITE)
789	atomic_inc(v: &fp->fi_access[O_WRONLY]);
790	if (access & NFS4_SHARE_ACCESS_READ)
791	atomic_inc(v: &fp->fi_access[O_RDONLY]);
792	}
793
794	static __be32
795	nfs4_file_get_access(struct nfs4_file *fp, u32 access)
796	{
797	lockdep_assert_held(&fp->fi_lock);
798
799	/* Does this access mode make sense? */
800	if (access & ~NFS4_SHARE_ACCESS_BOTH)
801	return nfserr_inval;
802
803	/* Does it conflict with a deny mode already set? */
804	if ((access & fp->fi_share_deny) != 0)
805	return nfserr_share_denied;
806
807	__nfs4_file_get_access(fp, access);
808	return nfs_ok;
809	}
810
811	static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
812	{
813	/* Common case is that there is no deny mode. */
814	if (deny) {
815	/* Does this deny mode make sense? */
816	if (deny & ~NFS4_SHARE_DENY_BOTH)
817	return nfserr_inval;
818
819	if ((deny & NFS4_SHARE_DENY_READ) &&
820	atomic_read(v: &fp->fi_access[O_RDONLY]))
821	return nfserr_share_denied;
822
823	if ((deny & NFS4_SHARE_DENY_WRITE) &&
824	atomic_read(v: &fp->fi_access[O_WRONLY]))
825	return nfserr_share_denied;
826	}
827	return nfs_ok;
828	}
829
830	static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
831	{
832	might_lock(&fp->fi_lock);
833
834	if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
835	struct nfsd_file *f1 = NULL;
836	struct nfsd_file *f2 = NULL;
837
838	swap(f1, fp->fi_fds[oflag]);
839	if (atomic_read(v: &fp->fi_access[1 - oflag]) == 0)
840	swap(f2, fp->fi_fds[O_RDWR]);
841	spin_unlock(lock: &fp->fi_lock);
842	if (f1)
843	nfsd_file_put(nf: f1);
844	if (f2)
845	nfsd_file_put(nf: f2);
846	}
847	}
848
849	static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
850	{
851	WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
852
853	if (access & NFS4_SHARE_ACCESS_WRITE)
854	__nfs4_file_put_access(fp, O_WRONLY);
855	if (access & NFS4_SHARE_ACCESS_READ)
856	__nfs4_file_put_access(fp, O_RDONLY);
857	}
858
859	/*
860	* Allocate a new open/delegation state counter. This is needed for
861	* pNFS for proper return on close semantics.
862	*
863	* Note that we only allocate it for pNFS-enabled exports, otherwise
864	* all pointers to struct nfs4_clnt_odstate are always NULL.
865	*/
866	static struct nfs4_clnt_odstate *
867	alloc_clnt_odstate(struct nfs4_client *clp)
868	{
869	struct nfs4_clnt_odstate *co;
870
871	co = kmem_cache_zalloc(k: odstate_slab, GFP_KERNEL);
872	if (co) {
873	co->co_client = clp;
874	refcount_set(r: &co->co_odcount, n: 1);
875	}
876	return co;
877	}
878
879	static void
880	hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
881	{
882	struct nfs4_file *fp = co->co_file;
883
884	lockdep_assert_held(&fp->fi_lock);
885	list_add(new: &co->co_perfile, head: &fp->fi_clnt_odstate);
886	}
887
888	static inline void
889	get_clnt_odstate(struct nfs4_clnt_odstate *co)
890	{
891	if (co)
892	refcount_inc(r: &co->co_odcount);
893	}
894
895	static void
896	put_clnt_odstate(struct nfs4_clnt_odstate *co)
897	{
898	struct nfs4_file *fp;
899
900	if (!co)
901	return;
902
903	fp = co->co_file;
904	if (refcount_dec_and_lock(r: &co->co_odcount, lock: &fp->fi_lock)) {
905	list_del(entry: &co->co_perfile);
906	spin_unlock(lock: &fp->fi_lock);
907
908	nfsd4_return_all_file_layouts(clp: co->co_client, fp);
909	kmem_cache_free(s: odstate_slab, objp: co);
910	}
911	}
912
913	static struct nfs4_clnt_odstate *
914	find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
915	{
916	struct nfs4_clnt_odstate *co;
917	struct nfs4_client *cl;
918
919	if (!new)
920	return NULL;
921
922	cl = new->co_client;
923
924	spin_lock(lock: &fp->fi_lock);
925	list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
926	if (co->co_client == cl) {
927	get_clnt_odstate(co);
928	goto out;
929	}
930	}
931	co = new;
932	co->co_file = fp;
933	hash_clnt_odstate_locked(co: new);
934	out:
935	spin_unlock(lock: &fp->fi_lock);
936	return co;
937	}
938
939	struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
940	void (*sc_free)(struct nfs4_stid *))
941	{
942	struct nfs4_stid *stid;
943	int new_id;
944
945	stid = kmem_cache_zalloc(k: slab, GFP_KERNEL);
946	if (!stid)
947	return NULL;
948
949	idr_preload(GFP_KERNEL);
950	spin_lock(lock: &cl->cl_lock);
951	/* Reserving 0 for start of file in nfsdfs "states" file: */
952	new_id = idr_alloc_cyclic(&cl->cl_stateids, ptr: stid, start: 1, end: 0, GFP_NOWAIT);
953	spin_unlock(lock: &cl->cl_lock);
954	idr_preload_end();
955	if (new_id < 0)
956	goto out_free;
957
958	stid->sc_free = sc_free;
959	stid->sc_client = cl;
960	stid->sc_stateid.si_opaque.so_id = new_id;
961	stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
962	/* Will be incremented before return to client: */
963	refcount_set(r: &stid->sc_count, n: 1);
964	spin_lock_init(&stid->sc_lock);
965	INIT_LIST_HEAD(list: &stid->sc_cp_list);
966
967	/*
968	* It shouldn't be a problem to reuse an opaque stateid value.
969	* I don't think it is for 4.1. But with 4.0 I worry that, for
970	* example, a stray write retransmission could be accepted by
971	* the server when it should have been rejected. Therefore,
972	* adopt a trick from the sctp code to attempt to maximize the
973	* amount of time until an id is reused, by ensuring they always
974	* "increase" (mod INT_MAX):
975	*/
976	return stid;
977	out_free:
978	kmem_cache_free(s: slab, objp: stid);
979	return NULL;
980	}
981
982	/*
983	* Create a unique stateid_t to represent each COPY.
984	*/
985	static int nfs4_init_cp_state(struct nfsd_net *nn, copy_stateid_t *stid,
986	unsigned char cs_type)
987	{
988	int new_id;
989
990	stid->cs_stid.si_opaque.so_clid.cl_boot = (u32)nn->boot_time;
991	stid->cs_stid.si_opaque.so_clid.cl_id = nn->s2s_cp_cl_id;
992
993	idr_preload(GFP_KERNEL);
994	spin_lock(lock: &nn->s2s_cp_lock);
995	new_id = idr_alloc_cyclic(&nn->s2s_cp_stateids, ptr: stid, start: 0, end: 0, GFP_NOWAIT);
996	stid->cs_stid.si_opaque.so_id = new_id;
997	stid->cs_stid.si_generation = 1;
998	spin_unlock(lock: &nn->s2s_cp_lock);
999	idr_preload_end();
1000	if (new_id < 0)
1001	return 0;
1002	stid->cs_type = cs_type;
1003	return 1;
1004	}
1005
1006	int nfs4_init_copy_state(struct nfsd_net *nn, struct nfsd4_copy *copy)
1007	{
1008	return nfs4_init_cp_state(nn, stid: &copy->cp_stateid, NFS4_COPY_STID);
1009	}
1010
1011	struct nfs4_cpntf_state *nfs4_alloc_init_cpntf_state(struct nfsd_net *nn,
1012	struct nfs4_stid *p_stid)
1013	{
1014	struct nfs4_cpntf_state *cps;
1015
1016	cps = kzalloc(size: sizeof(struct nfs4_cpntf_state), GFP_KERNEL);
1017	if (!cps)
1018	return NULL;
1019	cps->cpntf_time = ktime_get_boottime_seconds();
1020	refcount_set(r: &cps->cp_stateid.cs_count, n: 1);
1021	if (!nfs4_init_cp_state(nn, stid: &cps->cp_stateid, NFS4_COPYNOTIFY_STID))
1022	goto out_free;
1023	spin_lock(lock: &nn->s2s_cp_lock);
1024	list_add(new: &cps->cp_list, head: &p_stid->sc_cp_list);
1025	spin_unlock(lock: &nn->s2s_cp_lock);
1026	return cps;
1027	out_free:
1028	kfree(objp: cps);
1029	return NULL;
1030	}
1031
1032	void nfs4_free_copy_state(struct nfsd4_copy *copy)
1033	{
1034	struct nfsd_net *nn;
1035
1036	if (copy->cp_stateid.cs_type != NFS4_COPY_STID)
1037	return;
1038	nn = net_generic(net: copy->cp_clp->net, id: nfsd_net_id);
1039	spin_lock(lock: &nn->s2s_cp_lock);
1040	idr_remove(&nn->s2s_cp_stateids,
1041	id: copy->cp_stateid.cs_stid.si_opaque.so_id);
1042	spin_unlock(lock: &nn->s2s_cp_lock);
1043	}
1044
1045	static void nfs4_free_cpntf_statelist(struct net *net, struct nfs4_stid *stid)
1046	{
1047	struct nfs4_cpntf_state *cps;
1048	struct nfsd_net *nn;
1049
1050	nn = net_generic(net, id: nfsd_net_id);
1051	spin_lock(lock: &nn->s2s_cp_lock);
1052	while (!list_empty(head: &stid->sc_cp_list)) {
1053	cps = list_first_entry(&stid->sc_cp_list,
1054	struct nfs4_cpntf_state, cp_list);
1055	_free_cpntf_state_locked(nn, cps);
1056	}
1057	spin_unlock(lock: &nn->s2s_cp_lock);
1058	}
1059
1060	static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
1061	{
1062	struct nfs4_stid *stid;
1063
1064	stid = nfs4_alloc_stid(cl: clp, slab: stateid_slab, sc_free: nfs4_free_ol_stateid);
1065	if (!stid)
1066	return NULL;
1067
1068	return openlockstateid(s: stid);
1069	}
1070
1071	static void nfs4_free_deleg(struct nfs4_stid *stid)
1072	{
1073	struct nfs4_delegation *dp = delegstateid(s: stid);
1074
1075	WARN_ON_ONCE(!list_empty(&stid->sc_cp_list));
1076	WARN_ON_ONCE(!list_empty(&dp->dl_perfile));
1077	WARN_ON_ONCE(!list_empty(&dp->dl_perclnt));
1078	WARN_ON_ONCE(!list_empty(&dp->dl_recall_lru));
1079	kmem_cache_free(s: deleg_slab, objp: stid);
1080	atomic_long_dec(v: &num_delegations);
1081	}
1082
1083	/*
1084	* When we recall a delegation, we should be careful not to hand it
1085	* out again straight away.
1086	* To ensure this we keep a pair of bloom filters ('new' and 'old')
1087	* in which the filehandles of recalled delegations are "stored".
1088	* If a filehandle appear in either filter, a delegation is blocked.
1089	* When a delegation is recalled, the filehandle is stored in the "new"
1090	* filter.
1091	* Every 30 seconds we swap the filters and clear the "new" one,
1092	* unless both are empty of course.
1093	*
1094	* Each filter is 256 bits. We hash the filehandle to 32bit and use the
1095	* low 3 bytes as hash-table indices.
1096	*
1097	* 'blocked_delegations_lock', which is always taken in block_delegations(),
1098	* is used to manage concurrent access. Testing does not need the lock
1099	* except when swapping the two filters.
1100	*/
1101	static DEFINE_SPINLOCK(blocked_delegations_lock);
1102	static struct bloom_pair {
1103	int entries, old_entries;
1104	time64_t swap_time;
1105	int new; /* index into 'set' */
1106	DECLARE_BITMAP(set[2], 256);
1107	} blocked_delegations;
1108
1109	static int delegation_blocked(struct knfsd_fh *fh)
1110	{
1111	u32 hash;
1112	struct bloom_pair *bd = &blocked_delegations;
1113
1114	if (bd->entries == 0)
1115	return 0;
1116	if (ktime_get_seconds() - bd->swap_time > 30) {
1117	spin_lock(lock: &blocked_delegations_lock);
1118	if (ktime_get_seconds() - bd->swap_time > 30) {
1119	bd->entries -= bd->old_entries;
1120	bd->old_entries = bd->entries;
1121	memset(bd->set[bd->new], 0,
1122	sizeof(bd->set[0]));
1123	bd->new = 1-bd->new;
1124	bd->swap_time = ktime_get_seconds();
1125	}
1126	spin_unlock(lock: &blocked_delegations_lock);
1127	}
1128	hash = jhash(key: &fh->fh_raw, length: fh->fh_size, initval: 0);
1129	if (test_bit(hash&255, bd->set[0]) &&
1130	test_bit((hash>>8)&255, bd->set[0]) &&
1131	test_bit((hash>>16)&255, bd->set[0]))
1132	return 1;
1133
1134	if (test_bit(hash&255, bd->set[1]) &&
1135	test_bit((hash>>8)&255, bd->set[1]) &&
1136	test_bit((hash>>16)&255, bd->set[1]))
1137	return 1;
1138
1139	return 0;
1140	}
1141
1142	static void block_delegations(struct knfsd_fh *fh)
1143	{
1144	u32 hash;
1145	struct bloom_pair *bd = &blocked_delegations;
1146
1147	hash = jhash(key: &fh->fh_raw, length: fh->fh_size, initval: 0);
1148
1149	spin_lock(lock: &blocked_delegations_lock);
1150	__set_bit(hash&255, bd->set[bd->new]);
1151	__set_bit((hash>>8)&255, bd->set[bd->new]);
1152	__set_bit((hash>>16)&255, bd->set[bd->new]);
1153	if (bd->entries == 0)
1154	bd->swap_time = ktime_get_seconds();
1155	bd->entries += 1;
1156	spin_unlock(lock: &blocked_delegations_lock);
1157	}
1158
1159	static struct nfs4_delegation *
1160	alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp,
1161	struct nfs4_clnt_odstate *odstate, u32 dl_type)
1162	{
1163	struct nfs4_delegation *dp;
1164	struct nfs4_stid *stid;
1165	long n;
1166
1167	dprintk("NFSD alloc_init_deleg\n");
1168	n = atomic_long_inc_return(v: &num_delegations);
1169	if (n < 0 || n > max_delegations)
1170	goto out_dec;
1171	if (delegation_blocked(fh: &fp->fi_fhandle))
1172	goto out_dec;
1173	stid = nfs4_alloc_stid(cl: clp, slab: deleg_slab, sc_free: nfs4_free_deleg);
1174	if (stid == NULL)
1175	goto out_dec;
1176	dp = delegstateid(s: stid);
1177
1178	/*
1179	* delegation seqid's are never incremented. The 4.1 special
1180	* meaning of seqid 0 isn't meaningful, really, but let's avoid
1181	* 0 anyway just for consistency and use 1:
1182	*/
1183	dp->dl_stid.sc_stateid.si_generation = 1;
1184	INIT_LIST_HEAD(list: &dp->dl_perfile);
1185	INIT_LIST_HEAD(list: &dp->dl_perclnt);
1186	INIT_LIST_HEAD(list: &dp->dl_recall_lru);
1187	dp->dl_clnt_odstate = odstate;
1188	get_clnt_odstate(co: odstate);
1189	dp->dl_type = dl_type;
1190	dp->dl_retries = 1;
1191	dp->dl_recalled = false;
1192	nfsd4_init_cb(cb: &dp->dl_recall, clp: dp->dl_stid.sc_client,
1193	ops: &nfsd4_cb_recall_ops, op: NFSPROC4_CLNT_CB_RECALL);
1194	nfsd4_init_cb(cb: &dp->dl_cb_fattr.ncf_getattr, clp: dp->dl_stid.sc_client,
1195	ops: &nfsd4_cb_getattr_ops, op: NFSPROC4_CLNT_CB_GETATTR);
1196	dp->dl_cb_fattr.ncf_file_modified = false;
1197	dp->dl_cb_fattr.ncf_cb_bmap[0] = FATTR4_WORD0_CHANGE | FATTR4_WORD0_SIZE;
1198	get_nfs4_file(fi: fp);
1199	dp->dl_stid.sc_file = fp;
1200	return dp;
1201	out_dec:
1202	atomic_long_dec(v: &num_delegations);
1203	return NULL;
1204	}
1205
1206	void
1207	nfs4_put_stid(struct nfs4_stid *s)
1208	{
1209	struct nfs4_file *fp = s->sc_file;
1210	struct nfs4_client *clp = s->sc_client;
1211
1212	might_lock(&clp->cl_lock);
1213
1214	if (!refcount_dec_and_lock(r: &s->sc_count, lock: &clp->cl_lock)) {
1215	wake_up_all(&close_wq);
1216	return;
1217	}
1218	idr_remove(&clp->cl_stateids, id: s->sc_stateid.si_opaque.so_id);
1219	if (s->sc_status & SC_STATUS_ADMIN_REVOKED)
1220	atomic_dec(v: &s->sc_client->cl_admin_revoked);
1221	nfs4_free_cpntf_statelist(net: clp->net, stid: s);
1222	spin_unlock(lock: &clp->cl_lock);
1223	s->sc_free(s);
1224	if (fp)
1225	put_nfs4_file(fi: fp);
1226	}
1227
1228	void
1229	nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
1230	{
1231	stateid_t *src = &stid->sc_stateid;
1232
1233	spin_lock(lock: &stid->sc_lock);
1234	if (unlikely(++src->si_generation == 0))
1235	src->si_generation = 1;
1236	memcpy(dst, src, sizeof(*dst));
1237	spin_unlock(lock: &stid->sc_lock);
1238	}
1239
1240	static void put_deleg_file(struct nfs4_file *fp)
1241	{
1242	struct nfsd_file *nf = NULL;
1243
1244	spin_lock(lock: &fp->fi_lock);
1245	if (--fp->fi_delegees == 0)
1246	swap(nf, fp->fi_deleg_file);
1247	spin_unlock(lock: &fp->fi_lock);
1248
1249	if (nf)
1250	nfsd_file_put(nf);
1251	}
1252
1253	static void nfs4_unlock_deleg_lease(struct nfs4_delegation *dp)
1254	{
1255	struct nfs4_file *fp = dp->dl_stid.sc_file;
1256	struct nfsd_file *nf = fp->fi_deleg_file;
1257
1258	WARN_ON_ONCE(!fp->fi_delegees);
1259
1260	kernel_setlease(nf->nf_file, F_UNLCK, NULL, (void **)&dp);
1261	put_deleg_file(fp);
1262	}
1263
1264	static void destroy_unhashed_deleg(struct nfs4_delegation *dp)
1265	{
1266	put_clnt_odstate(co: dp->dl_clnt_odstate);
1267	nfs4_unlock_deleg_lease(dp);
1268	nfs4_put_stid(s: &dp->dl_stid);
1269	}
1270
1271	/**
1272	* nfs4_delegation_exists - Discover if this delegation already exists
1273	* @clp: a pointer to the nfs4_client we're granting a delegation to
1274	* @fp: a pointer to the nfs4_file we're granting a delegation on
1275	*
1276	* Return:
1277	* On success: true iff an existing delegation is found
1278	*/
1279
1280	static bool
1281	nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp)
1282	{
1283	struct nfs4_delegation *searchdp = NULL;
1284	struct nfs4_client *searchclp = NULL;
1285
1286	lockdep_assert_held(&state_lock);
1287	lockdep_assert_held(&fp->fi_lock);
1288
1289	list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
1290	searchclp = searchdp->dl_stid.sc_client;
1291	if (clp == searchclp) {
1292	return true;
1293	}
1294	}
1295	return false;
1296	}
1297
1298	/**
1299	* hash_delegation_locked - Add a delegation to the appropriate lists
1300	* @dp: a pointer to the nfs4_delegation we are adding.
1301	* @fp: a pointer to the nfs4_file we're granting a delegation on
1302	*
1303	* Return:
1304	* On success: NULL if the delegation was successfully hashed.
1305	*
1306	* On error: -EAGAIN if one was previously granted to this
1307	* nfs4_client for this nfs4_file. Delegation is not hashed.
1308	*
1309	*/
1310
1311	static int
1312	hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
1313	{
1314	struct nfs4_client *clp = dp->dl_stid.sc_client;
1315
1316	lockdep_assert_held(&state_lock);
1317	lockdep_assert_held(&fp->fi_lock);
1318	lockdep_assert_held(&clp->cl_lock);
1319
1320	if (nfs4_delegation_exists(clp, fp))
1321	return -EAGAIN;
1322	refcount_inc(r: &dp->dl_stid.sc_count);
1323	dp->dl_stid.sc_type = SC_TYPE_DELEG;
1324	list_add(new: &dp->dl_perfile, head: &fp->fi_delegations);
1325	list_add(new: &dp->dl_perclnt, head: &clp->cl_delegations);
1326	return 0;
1327	}
1328
1329	static bool delegation_hashed(struct nfs4_delegation *dp)
1330	{
1331	return !(list_empty(head: &dp->dl_perfile));
1332	}
1333
1334	static bool
1335	unhash_delegation_locked(struct nfs4_delegation *dp, unsigned short statusmask)
1336	{
1337	struct nfs4_file *fp = dp->dl_stid.sc_file;
1338
1339	lockdep_assert_held(&state_lock);
1340
1341	if (!delegation_hashed(dp))
1342	return false;
1343
1344	if (statusmask == SC_STATUS_REVOKED &&
1345	dp->dl_stid.sc_client->cl_minorversion == 0)
1346	statusmask = SC_STATUS_CLOSED;
1347	dp->dl_stid.sc_status |= statusmask;
1348	if (statusmask & SC_STATUS_ADMIN_REVOKED)
1349	atomic_inc(v: &dp->dl_stid.sc_client->cl_admin_revoked);
1350
1351	/* Ensure that deleg break won't try to requeue it */
1352	++dp->dl_time;
1353	spin_lock(lock: &fp->fi_lock);
1354	list_del_init(entry: &dp->dl_perclnt);
1355	list_del_init(entry: &dp->dl_recall_lru);
1356	list_del_init(entry: &dp->dl_perfile);
1357	spin_unlock(lock: &fp->fi_lock);
1358	return true;
1359	}
1360
1361	static void destroy_delegation(struct nfs4_delegation *dp)
1362	{
1363	bool unhashed;
1364
1365	spin_lock(lock: &state_lock);
1366	unhashed = unhash_delegation_locked(dp, SC_STATUS_CLOSED);
1367	spin_unlock(lock: &state_lock);
1368	if (unhashed)
1369	destroy_unhashed_deleg(dp);
1370	}
1371
1372	static void revoke_delegation(struct nfs4_delegation *dp)
1373	{
1374	struct nfs4_client *clp = dp->dl_stid.sc_client;
1375
1376	WARN_ON(!list_empty(&dp->dl_recall_lru));
1377
1378	trace_nfsd_stid_revoke(stid: &dp->dl_stid);
1379
1380	if (dp->dl_stid.sc_status &
1381	(SC_STATUS_REVOKED | SC_STATUS_ADMIN_REVOKED)) {
1382	spin_lock(lock: &clp->cl_lock);
1383	refcount_inc(r: &dp->dl_stid.sc_count);
1384	list_add(new: &dp->dl_recall_lru, head: &clp->cl_revoked);
1385	spin_unlock(lock: &clp->cl_lock);
1386	}
1387	destroy_unhashed_deleg(dp);
1388	}
1389
1390	/*
1391	* SETCLIENTID state
1392	*/
1393
1394	static unsigned int clientid_hashval(u32 id)
1395	{
1396	return id & CLIENT_HASH_MASK;
1397	}
1398
1399	static unsigned int clientstr_hashval(struct xdr_netobj name)
1400	{
1401	return opaque_hashval(ptr: name.data, nbytes: 8) & CLIENT_HASH_MASK;
1402	}
1403
1404	/*
1405	* A stateid that had a deny mode associated with it is being released
1406	* or downgraded. Recalculate the deny mode on the file.
1407	*/
1408	static void
1409	recalculate_deny_mode(struct nfs4_file *fp)
1410	{
1411	struct nfs4_ol_stateid *stp;
1412
1413	spin_lock(lock: &fp->fi_lock);
1414	fp->fi_share_deny = 0;
1415	list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
1416	fp->fi_share_deny |= bmap_to_share_mode(bmap: stp->st_deny_bmap);
1417	spin_unlock(lock: &fp->fi_lock);
1418	}
1419
1420	static void
1421	reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
1422	{
1423	int i;
1424	bool change = false;
1425
1426	for (i = 1; i < 4; i++) {
1427	if ((i & deny) != i) {
1428	change = true;
1429	clear_deny(deny: i, stp);
1430	}
1431	}
1432
1433	/* Recalculate per-file deny mode if there was a change */
1434	if (change)
1435	recalculate_deny_mode(fp: stp->st_stid.sc_file);
1436	}
1437
1438	/* release all access and file references for a given stateid */
1439	static void
1440	release_all_access(struct nfs4_ol_stateid *stp)
1441	{
1442	int i;
1443	struct nfs4_file *fp = stp->st_stid.sc_file;
1444
1445	if (fp && stp->st_deny_bmap != 0)
1446	recalculate_deny_mode(fp);
1447
1448	for (i = 1; i < 4; i++) {
1449	if (test_access(access: i, stp))
1450	nfs4_file_put_access(fp: stp->st_stid.sc_file, access: i);
1451	clear_access(access: i, stp);
1452	}
1453	}
1454
1455	static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
1456	{
1457	kfree(objp: sop->so_owner.data);
1458	sop->so_ops->so_free(sop);
1459	}
1460
1461	static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
1462	{
1463	struct nfs4_client *clp = sop->so_client;
1464
1465	might_lock(&clp->cl_lock);
1466
1467	if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
1468	return;
1469	sop->so_ops->so_unhash(sop);
1470	spin_unlock(lock: &clp->cl_lock);
1471	nfs4_free_stateowner(sop);
1472	}
1473
1474	static bool
1475	nfs4_ol_stateid_unhashed(const struct nfs4_ol_stateid *stp)
1476	{
1477	return list_empty(head: &stp->st_perfile);
1478	}
1479
1480	static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
1481	{
1482	struct nfs4_file *fp = stp->st_stid.sc_file;
1483
1484	lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);
1485
1486	if (list_empty(head: &stp->st_perfile))
1487	return false;
1488
1489	spin_lock(lock: &fp->fi_lock);
1490	list_del_init(entry: &stp->st_perfile);
1491	spin_unlock(lock: &fp->fi_lock);
1492	list_del(entry: &stp->st_perstateowner);
1493	return true;
1494	}
1495
1496	static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
1497	{
1498	struct nfs4_ol_stateid *stp = openlockstateid(s: stid);
1499
1500	put_clnt_odstate(co: stp->st_clnt_odstate);
1501	release_all_access(stp);
1502	if (stp->st_stateowner)
1503	nfs4_put_stateowner(sop: stp->st_stateowner);
1504	WARN_ON(!list_empty(&stid->sc_cp_list));
1505	kmem_cache_free(s: stateid_slab, objp: stid);
1506	}
1507
1508	static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
1509	{
1510	struct nfs4_ol_stateid *stp = openlockstateid(s: stid);
1511	struct nfs4_lockowner *lo = lockowner(so: stp->st_stateowner);
1512	struct nfsd_file *nf;
1513
1514	nf = find_any_file(f: stp->st_stid.sc_file);
1515	if (nf) {
1516	get_file(f: nf->nf_file);
1517	filp_close(nf->nf_file, id: (fl_owner_t)lo);
1518	nfsd_file_put(nf);
1519	}
1520	nfs4_free_ol_stateid(stid);
1521	}
1522
1523	/*
1524	* Put the persistent reference to an already unhashed generic stateid, while
1525	* holding the cl_lock. If it's the last reference, then put it onto the
1526	* reaplist for later destruction.
1527	*/
1528	static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
1529	struct list_head *reaplist)
1530	{
1531	struct nfs4_stid *s = &stp->st_stid;
1532	struct nfs4_client *clp = s->sc_client;
1533
1534	lockdep_assert_held(&clp->cl_lock);
1535
1536	WARN_ON_ONCE(!list_empty(&stp->st_locks));
1537
1538	if (!refcount_dec_and_test(r: &s->sc_count)) {
1539	wake_up_all(&close_wq);
1540	return;
1541	}
1542
1543	idr_remove(&clp->cl_stateids, id: s->sc_stateid.si_opaque.so_id);
1544	if (s->sc_status & SC_STATUS_ADMIN_REVOKED)
1545	atomic_dec(v: &s->sc_client->cl_admin_revoked);
1546	list_add(new: &stp->st_locks, head: reaplist);
1547	}
1548
1549	static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
1550	{
1551	lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1552
1553	if (!unhash_ol_stateid(stp))
1554	return false;
1555	list_del_init(entry: &stp->st_locks);
1556	stp->st_stid.sc_status |= SC_STATUS_CLOSED;
1557	return true;
1558	}
1559
1560	static void release_lock_stateid(struct nfs4_ol_stateid *stp)
1561	{
1562	struct nfs4_client *clp = stp->st_stid.sc_client;
1563	bool unhashed;
1564
1565	spin_lock(lock: &clp->cl_lock);
1566	unhashed = unhash_lock_stateid(stp);
1567	spin_unlock(lock: &clp->cl_lock);
1568	if (unhashed)
1569	nfs4_put_stid(s: &stp->st_stid);
1570	}
1571
1572	static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
1573	{
1574	struct nfs4_client *clp = lo->lo_owner.so_client;
1575
1576	lockdep_assert_held(&clp->cl_lock);
1577
1578	list_del_init(entry: &lo->lo_owner.so_strhash);
1579	}
1580
1581	/*
1582	* Free a list of generic stateids that were collected earlier after being
1583	* fully unhashed.
1584	*/
1585	static void
1586	free_ol_stateid_reaplist(struct list_head *reaplist)
1587	{
1588	struct nfs4_ol_stateid *stp;
1589	struct nfs4_file *fp;
1590
1591	might_sleep();
1592
1593	while (!list_empty(head: reaplist)) {
1594	stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
1595	st_locks);
1596	list_del(entry: &stp->st_locks);
1597	fp = stp->st_stid.sc_file;
1598	stp->st_stid.sc_free(&stp->st_stid);
1599	if (fp)
1600	put_nfs4_file(fi: fp);
1601	}
1602	}
1603
1604	static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
1605	struct list_head *reaplist)
1606	{
1607	struct nfs4_ol_stateid *stp;
1608
1609	lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);
1610
1611	while (!list_empty(head: &open_stp->st_locks)) {
1612	stp = list_entry(open_stp->st_locks.next,
1613	struct nfs4_ol_stateid, st_locks);
1614	unhash_lock_stateid(stp);
1615	put_ol_stateid_locked(stp, reaplist);
1616	}
1617	}
1618
1619	static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
1620	struct list_head *reaplist)
1621	{
1622	lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1623
1624	if (!unhash_ol_stateid(stp))
1625	return false;
1626	release_open_stateid_locks(open_stp: stp, reaplist);
1627	return true;
1628	}
1629
1630	static void release_open_stateid(struct nfs4_ol_stateid *stp)
1631	{
1632	LIST_HEAD(reaplist);
1633
1634	spin_lock(lock: &stp->st_stid.sc_client->cl_lock);
1635	stp->st_stid.sc_status |= SC_STATUS_CLOSED;
1636	if (unhash_open_stateid(stp, reaplist: &reaplist))
1637	put_ol_stateid_locked(stp, reaplist: &reaplist);
1638	spin_unlock(lock: &stp->st_stid.sc_client->cl_lock);
1639	free_ol_stateid_reaplist(reaplist: &reaplist);
1640	}
1641
1642	static void unhash_openowner_locked(struct nfs4_openowner *oo)
1643	{
1644	struct nfs4_client *clp = oo->oo_owner.so_client;
1645
1646	lockdep_assert_held(&clp->cl_lock);
1647
1648	list_del_init(entry: &oo->oo_owner.so_strhash);
1649	list_del_init(entry: &oo->oo_perclient);
1650	}
1651
1652	static void release_last_closed_stateid(struct nfs4_openowner *oo)
1653	{
1654	struct nfsd_net *nn = net_generic(net: oo->oo_owner.so_client->net,
1655	id: nfsd_net_id);
1656	struct nfs4_ol_stateid *s;
1657
1658	spin_lock(lock: &nn->client_lock);
1659	s = oo->oo_last_closed_stid;
1660	if (s) {
1661	list_del_init(entry: &oo->oo_close_lru);
1662	oo->oo_last_closed_stid = NULL;
1663	}
1664	spin_unlock(lock: &nn->client_lock);
1665	if (s)
1666	nfs4_put_stid(s: &s->st_stid);
1667	}
1668
1669	static void release_openowner(struct nfs4_openowner *oo)
1670	{
1671	struct nfs4_ol_stateid *stp;
1672	struct nfs4_client *clp = oo->oo_owner.so_client;
1673	struct list_head reaplist;
1674
1675	INIT_LIST_HEAD(list: &reaplist);
1676
1677	spin_lock(lock: &clp->cl_lock);
1678	unhash_openowner_locked(oo);
1679	while (!list_empty(head: &oo->oo_owner.so_stateids)) {
1680	stp = list_first_entry(&oo->oo_owner.so_stateids,
1681	struct nfs4_ol_stateid, st_perstateowner);
1682	if (unhash_open_stateid(stp, reaplist: &reaplist))
1683	put_ol_stateid_locked(stp, reaplist: &reaplist);
1684	}
1685	spin_unlock(lock: &clp->cl_lock);
1686	free_ol_stateid_reaplist(reaplist: &reaplist);
1687	release_last_closed_stateid(oo);
1688	nfs4_put_stateowner(sop: &oo->oo_owner);
1689	}
1690
1691	static struct nfs4_stid *find_one_sb_stid(struct nfs4_client *clp,
1692	struct super_block *sb,
1693	unsigned int sc_types)
1694	{
1695	unsigned long id, tmp;
1696	struct nfs4_stid *stid;
1697
1698	spin_lock(lock: &clp->cl_lock);
1699	idr_for_each_entry_ul(&clp->cl_stateids, stid, tmp, id)
1700	if ((stid->sc_type & sc_types) &&
1701	stid->sc_status == 0 &&
1702	stid->sc_file->fi_inode->i_sb == sb) {
1703	refcount_inc(r: &stid->sc_count);
1704	break;
1705	}
1706	spin_unlock(lock: &clp->cl_lock);
1707	return stid;
1708	}
1709
1710	/**
1711	* nfsd4_revoke_states - revoke all nfsv4 states associated with given filesystem
1712	* @net: used to identify instance of nfsd (there is one per net namespace)
1713	* @sb: super_block used to identify target filesystem
1714	*
1715	* All nfs4 states (open, lock, delegation, layout) held by the server instance
1716	* and associated with a file on the given filesystem will be revoked resulting
1717	* in any files being closed and so all references from nfsd to the filesystem
1718	* being released. Thus nfsd will no longer prevent the filesystem from being
1719	* unmounted.
1720	*
1721	* The clients which own the states will subsequently being notified that the
1722	* states have been "admin-revoked".
1723	*/
1724	void nfsd4_revoke_states(struct net *net, struct super_block *sb)
1725	{
1726	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
1727	unsigned int idhashval;
1728	unsigned int sc_types;
1729
1730	sc_types = SC_TYPE_OPEN | SC_TYPE_LOCK | SC_TYPE_DELEG | SC_TYPE_LAYOUT;
1731
1732	spin_lock(lock: &nn->client_lock);
1733	for (idhashval = 0; idhashval < CLIENT_HASH_MASK; idhashval++) {
1734	struct list_head *head = &nn->conf_id_hashtbl[idhashval];
1735	struct nfs4_client *clp;
1736	retry:
1737	list_for_each_entry(clp, head, cl_idhash) {
1738	struct nfs4_stid *stid = find_one_sb_stid(clp, sb,
1739	sc_types);
1740	if (stid) {
1741	struct nfs4_ol_stateid *stp;
1742	struct nfs4_delegation *dp;
1743	struct nfs4_layout_stateid *ls;
1744
1745	spin_unlock(lock: &nn->client_lock);
1746	switch (stid->sc_type) {
1747	case SC_TYPE_OPEN:
1748	stp = openlockstateid(s: stid);
1749	mutex_lock_nested(lock: &stp->st_mutex,
1750	subclass: OPEN_STATEID_MUTEX);
1751
1752	spin_lock(lock: &clp->cl_lock);
1753	if (stid->sc_status == 0) {
1754	stid->sc_status |=
1755	SC_STATUS_ADMIN_REVOKED;
1756	atomic_inc(v: &clp->cl_admin_revoked);
1757	spin_unlock(lock: &clp->cl_lock);
1758	release_all_access(stp);
1759	} else
1760	spin_unlock(lock: &clp->cl_lock);
1761	mutex_unlock(lock: &stp->st_mutex);
1762	break;
1763	case SC_TYPE_LOCK:
1764	stp = openlockstateid(s: stid);
1765	mutex_lock_nested(lock: &stp->st_mutex,
1766	subclass: LOCK_STATEID_MUTEX);
1767	spin_lock(lock: &clp->cl_lock);
1768	if (stid->sc_status == 0) {
1769	struct nfs4_lockowner *lo =
1770	lockowner(so: stp->st_stateowner);
1771	struct nfsd_file *nf;
1772
1773	stid->sc_status |=
1774	SC_STATUS_ADMIN_REVOKED;
1775	atomic_inc(v: &clp->cl_admin_revoked);
1776	spin_unlock(lock: &clp->cl_lock);
1777	nf = find_any_file(f: stp->st_stid.sc_file);
1778	if (nf) {
1779	get_file(f: nf->nf_file);
1780	filp_close(nf->nf_file,
1781	id: (fl_owner_t)lo);
1782	nfsd_file_put(nf);
1783	}
1784	release_all_access(stp);
1785	} else
1786	spin_unlock(lock: &clp->cl_lock);
1787	mutex_unlock(lock: &stp->st_mutex);
1788	break;
1789	case SC_TYPE_DELEG:
1790	dp = delegstateid(s: stid);
1791	spin_lock(lock: &state_lock);
1792	if (!unhash_delegation_locked(
1793	dp, SC_STATUS_ADMIN_REVOKED))
1794	dp = NULL;
1795	spin_unlock(lock: &state_lock);
1796	if (dp)
1797	revoke_delegation(dp);
1798	break;
1799	case SC_TYPE_LAYOUT:
1800	ls = layoutstateid(s: stid);
1801	nfsd4_close_layout(ls);
1802	break;
1803	}
1804	nfs4_put_stid(s: stid);
1805	spin_lock(lock: &nn->client_lock);
1806	if (clp->cl_minorversion == 0)
1807	/* Allow cleanup after a lease period.
1808	* store_release ensures cleanup will
1809	* see any newly revoked states if it
1810	* sees the time updated.
1811	*/
1812	nn->nfs40_last_revoke =
1813	ktime_get_boottime_seconds();
1814	goto retry;
1815	}
1816	}
1817	}
1818	spin_unlock(lock: &nn->client_lock);
1819	}
1820
1821	static inline int
1822	hash_sessionid(struct nfs4_sessionid *sessionid)
1823	{
1824	struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
1825
1826	return sid->sequence % SESSION_HASH_SIZE;
1827	}
1828
1829	#ifdef CONFIG_SUNRPC_DEBUG
1830	static inline void
1831	dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1832	{
1833	u32 *ptr = (u32 *)(&sessionid->data[0]);
1834	dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
1835	}
1836	#else
1837	static inline void
1838	dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1839	{
1840	}
1841	#endif
1842
1843	/*
1844	* Bump the seqid on cstate->replay_owner, and clear replay_owner if it
1845	* won't be used for replay.
1846	*/
1847	void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
1848	{
1849	struct nfs4_stateowner *so = cstate->replay_owner;
1850
1851	if (nfserr == nfserr_replay_me)
1852	return;
1853
1854	if (!seqid_mutating_err(ntohl(nfserr))) {
1855	nfsd4_cstate_clear_replay(cstate);
1856	return;
1857	}
1858	if (!so)
1859	return;
1860	if (so->so_is_open_owner)
1861	release_last_closed_stateid(oo: openowner(so));
1862	so->so_seqid++;
1863	return;
1864	}
1865
1866	static void
1867	gen_sessionid(struct nfsd4_session *ses)
1868	{
1869	struct nfs4_client *clp = ses->se_client;
1870	struct nfsd4_sessionid *sid;
1871
1872	sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
1873	sid->clientid = clp->cl_clientid;
1874	sid->sequence = current_sessionid++;
1875	sid->reserved = 0;
1876	}
1877
1878	/*
1879	* The protocol defines ca_maxresponssize_cached to include the size of
1880	* the rpc header, but all we need to cache is the data starting after
1881	* the end of the initial SEQUENCE operation--the rest we regenerate
1882	* each time. Therefore we can advertise a ca_maxresponssize_cached
1883	* value that is the number of bytes in our cache plus a few additional
1884	* bytes. In order to stay on the safe side, and not promise more than
1885	* we can cache, those additional bytes must be the minimum possible: 24
1886	* bytes of rpc header (xid through accept state, with AUTH_NULL
1887	* verifier), 12 for the compound header (with zero-length tag), and 44
1888	* for the SEQUENCE op response:
1889	*/
1890	#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
1891
1892	static void
1893	free_session_slots(struct nfsd4_session *ses)
1894	{
1895	int i;
1896
1897	for (i = 0; i < ses->se_fchannel.maxreqs; i++) {
1898	free_svc_cred(cred: &ses->se_slots[i]->sl_cred);
1899	kfree(objp: ses->se_slots[i]);
1900	}
1901	}
1902
1903	/*
1904	* We don't actually need to cache the rpc and session headers, so we
1905	* can allocate a little less for each slot:
1906	*/
1907	static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
1908	{
1909	u32 size;
1910
1911	if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
1912	size = 0;
1913	else
1914	size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
1915	return size + sizeof(struct nfsd4_slot);
1916	}
1917
1918	/*
1919	* XXX: If we run out of reserved DRC memory we could (up to a point)
1920	* re-negotiate active sessions and reduce their slot usage to make
1921	* room for new connections. For now we just fail the create session.
1922	*/
1923	static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
1924	{
1925	u32 slotsize = slot_bytes(ca);
1926	u32 num = ca->maxreqs;
1927	unsigned long avail, total_avail;
1928	unsigned int scale_factor;
1929
1930	spin_lock(lock: &nfsd_drc_lock);
1931	if (nfsd_drc_max_mem > nfsd_drc_mem_used)
1932	total_avail = nfsd_drc_max_mem - nfsd_drc_mem_used;
1933	else
1934	/* We have handed out more space than we chose in
1935	* set_max_drc() to allow. That isn't really a
1936	* problem as long as that doesn't make us think we
1937	* have lots more due to integer overflow.
1938	*/
1939	total_avail = 0;
1940	avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION, total_avail);
1941	/*
1942	* Never use more than a fraction of the remaining memory,
1943	* unless it's the only way to give this client a slot.
1944	* The chosen fraction is either 1/8 or 1/number of threads,
1945	* whichever is smaller. This ensures there are adequate
1946	* slots to support multiple clients per thread.
1947	* Give the client one slot even if that would require
1948	* over-allocation--it is better than failure.
1949	*/
1950	scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads);
1951
1952	avail = clamp_t(unsigned long, avail, slotsize,
1953	total_avail/scale_factor);
1954	num = min_t(int, num, avail / slotsize);
1955	num = max_t(int, num, 1);
1956	nfsd_drc_mem_used += num * slotsize;
1957	spin_unlock(lock: &nfsd_drc_lock);
1958
1959	return num;
1960	}
1961
1962	static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
1963	{
1964	int slotsize = slot_bytes(ca);
1965
1966	spin_lock(lock: &nfsd_drc_lock);
1967	nfsd_drc_mem_used -= slotsize * ca->maxreqs;
1968	spin_unlock(lock: &nfsd_drc_lock);
1969	}
1970
1971	static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
1972	struct nfsd4_channel_attrs *battrs)
1973	{
1974	int numslots = fattrs->maxreqs;
1975	int slotsize = slot_bytes(ca: fattrs);
1976	struct nfsd4_session *new;
1977	int i;
1978
1979	BUILD_BUG_ON(struct_size(new, se_slots, NFSD_MAX_SLOTS_PER_SESSION)
1980	> PAGE_SIZE);
1981
1982	new = kzalloc(struct_size(new, se_slots, numslots), GFP_KERNEL);
1983	if (!new)
1984	return NULL;
1985	/* allocate each struct nfsd4_slot and data cache in one piece */
1986	for (i = 0; i < numslots; i++) {
1987	new->se_slots[i] = kzalloc(size: slotsize, GFP_KERNEL);
1988	if (!new->se_slots[i])
1989	goto out_free;
1990	}
1991
1992	memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
1993	memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
1994
1995	return new;
1996	out_free:
1997	while (i--)
1998	kfree(objp: new->se_slots[i]);
1999	kfree(objp: new);
2000	return NULL;
2001	}
2002
2003	static void free_conn(struct nfsd4_conn *c)
2004	{
2005	svc_xprt_put(xprt: c->cn_xprt);
2006	kfree(objp: c);
2007	}
2008
2009	static void nfsd4_conn_lost(struct svc_xpt_user *u)
2010	{
2011	struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
2012	struct nfs4_client *clp = c->cn_session->se_client;
2013
2014	trace_nfsd_cb_lost(clp);
2015
2016	spin_lock(lock: &clp->cl_lock);
2017	if (!list_empty(head: &c->cn_persession)) {
2018	list_del(entry: &c->cn_persession);
2019	free_conn(c);
2020	}
2021	nfsd4_probe_callback(clp);
2022	spin_unlock(lock: &clp->cl_lock);
2023	}
2024
2025	static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
2026	{
2027	struct nfsd4_conn *conn;
2028
2029	conn = kmalloc(size: sizeof(struct nfsd4_conn), GFP_KERNEL);
2030	if (!conn)
2031	return NULL;
2032	svc_xprt_get(xprt: rqstp->rq_xprt);
2033	conn->cn_xprt = rqstp->rq_xprt;
2034	conn->cn_flags = flags;
2035	INIT_LIST_HEAD(list: &conn->cn_xpt_user.list);
2036	return conn;
2037	}
2038
2039	static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
2040	{
2041	conn->cn_session = ses;
2042	list_add(new: &conn->cn_persession, head: &ses->se_conns);
2043	}
2044
2045	static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
2046	{
2047	struct nfs4_client *clp = ses->se_client;
2048
2049	spin_lock(lock: &clp->cl_lock);
2050	__nfsd4_hash_conn(conn, ses);
2051	spin_unlock(lock: &clp->cl_lock);
2052	}
2053
2054	static int nfsd4_register_conn(struct nfsd4_conn *conn)
2055	{
2056	conn->cn_xpt_user.callback = nfsd4_conn_lost;
2057	return register_xpt_user(xpt: conn->cn_xprt, u: &conn->cn_xpt_user);
2058	}
2059
2060	static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
2061	{
2062	int ret;
2063
2064	nfsd4_hash_conn(conn, ses);
2065	ret = nfsd4_register_conn(conn);
2066	if (ret)
2067	/* oops; xprt is already down: */
2068	nfsd4_conn_lost(u: &conn->cn_xpt_user);
2069	/* We may have gained or lost a callback channel: */
2070	nfsd4_probe_callback_sync(clp: ses->se_client);
2071	}
2072
2073	static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
2074	{
2075	u32 dir = NFS4_CDFC4_FORE;
2076
2077	if (cses->flags & SESSION4_BACK_CHAN)
2078	dir |= NFS4_CDFC4_BACK;
2079	return alloc_conn(rqstp, flags: dir);
2080	}
2081
2082	/* must be called under client_lock */
2083	static void nfsd4_del_conns(struct nfsd4_session *s)
2084	{
2085	struct nfs4_client *clp = s->se_client;
2086	struct nfsd4_conn *c;
2087
2088	spin_lock(lock: &clp->cl_lock);
2089	while (!list_empty(head: &s->se_conns)) {
2090	c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
2091	list_del_init(entry: &c->cn_persession);
2092	spin_unlock(lock: &clp->cl_lock);
2093
2094	unregister_xpt_user(xpt: c->cn_xprt, u: &c->cn_xpt_user);
2095	free_conn(c);
2096
2097	spin_lock(lock: &clp->cl_lock);
2098	}
2099	spin_unlock(lock: &clp->cl_lock);
2100	}
2101
2102	static void __free_session(struct nfsd4_session *ses)
2103	{
2104	free_session_slots(ses);
2105	kfree(objp: ses);
2106	}
2107
2108	static void free_session(struct nfsd4_session *ses)
2109	{
2110	nfsd4_del_conns(s: ses);
2111	nfsd4_put_drc_mem(ca: &ses->se_fchannel);
2112	__free_session(ses);
2113	}
2114
2115	static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
2116	{
2117	int idx;
2118	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
2119
2120	new->se_client = clp;
2121	gen_sessionid(ses: new);
2122
2123	INIT_LIST_HEAD(list: &new->se_conns);
2124
2125	new->se_cb_seq_nr = 1;
2126	new->se_flags = cses->flags;
2127	new->se_cb_prog = cses->callback_prog;
2128	new->se_cb_sec = cses->cb_sec;
2129	atomic_set(v: &new->se_ref, i: 0);
2130	idx = hash_sessionid(sessionid: &new->se_sessionid);
2131	list_add(new: &new->se_hash, head: &nn->sessionid_hashtbl[idx]);
2132	spin_lock(lock: &clp->cl_lock);
2133	list_add(new: &new->se_perclnt, head: &clp->cl_sessions);
2134	spin_unlock(lock: &clp->cl_lock);
2135
2136	{
2137	struct sockaddr *sa = svc_addr(rqst: rqstp);
2138	/*
2139	* This is a little silly; with sessions there's no real
2140	* use for the callback address. Use the peer address
2141	* as a reasonable default for now, but consider fixing
2142	* the rpc client not to require an address in the
2143	* future:
2144	*/
2145	rpc_copy_addr(dst: (struct sockaddr *)&clp->cl_cb_conn.cb_addr, src: sa);
2146	clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
2147	}
2148	}
2149
2150	/* caller must hold client_lock */
2151	static struct nfsd4_session *
2152	__find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
2153	{
2154	struct nfsd4_session *elem;
2155	int idx;
2156	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
2157
2158	lockdep_assert_held(&nn->client_lock);
2159
2160	dump_sessionid(fn: __func__, sessionid);
2161	idx = hash_sessionid(sessionid);
2162	/* Search in the appropriate list */
2163	list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
2164	if (!memcmp(p: elem->se_sessionid.data, q: sessionid->data,
2165	NFS4_MAX_SESSIONID_LEN)) {
2166	return elem;
2167	}
2168	}
2169
2170	dprintk("%s: session not found\n", __func__);
2171	return NULL;
2172	}
2173
2174	static struct nfsd4_session *
2175	find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
2176	__be32 *ret)
2177	{
2178	struct nfsd4_session *session;
2179	__be32 status = nfserr_badsession;
2180
2181	session = __find_in_sessionid_hashtbl(sessionid, net);
2182	if (!session)
2183	goto out;
2184	status = nfsd4_get_session_locked(ses: session);
2185	if (status)
2186	session = NULL;
2187	out:
2188	*ret = status;
2189	return session;
2190	}
2191
2192	/* caller must hold client_lock */
2193	static void
2194	unhash_session(struct nfsd4_session *ses)
2195	{
2196	struct nfs4_client *clp = ses->se_client;
2197	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
2198
2199	lockdep_assert_held(&nn->client_lock);
2200
2201	list_del(entry: &ses->se_hash);
2202	spin_lock(lock: &ses->se_client->cl_lock);
2203	list_del(entry: &ses->se_perclnt);
2204	spin_unlock(lock: &ses->se_client->cl_lock);
2205	}
2206
2207	/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
2208	static int
2209	STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
2210	{
2211	/*
2212	* We're assuming the clid was not given out from a boot
2213	* precisely 2^32 (about 136 years) before this one. That seems
2214	* a safe assumption:
2215	*/
2216	if (clid->cl_boot == (u32)nn->boot_time)
2217	return 0;
2218	trace_nfsd_clid_stale(clid);
2219	return 1;
2220	}
2221
2222	/*
2223	* XXX Should we use a slab cache ?
2224	* This type of memory management is somewhat inefficient, but we use it
2225	* anyway since SETCLIENTID is not a common operation.
2226	*/
2227	static struct nfs4_client *alloc_client(struct xdr_netobj name,
2228	struct nfsd_net *nn)
2229	{
2230	struct nfs4_client *clp;
2231	int i;
2232
2233	if (atomic_read(v: &nn->nfs4_client_count) >= nn->nfs4_max_clients) {
2234	mod_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: 0);
2235	return NULL;
2236	}
2237	clp = kmem_cache_zalloc(k: client_slab, GFP_KERNEL);
2238	if (clp == NULL)
2239	return NULL;
2240	xdr_netobj_dup(dst: &clp->cl_name, src: &name, GFP_KERNEL);
2241	if (clp->cl_name.data == NULL)
2242	goto err_no_name;
2243	clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE,
2244	size: sizeof(struct list_head),
2245	GFP_KERNEL);
2246	if (!clp->cl_ownerstr_hashtbl)
2247	goto err_no_hashtbl;
2248	for (i = 0; i < OWNER_HASH_SIZE; i++)
2249	INIT_LIST_HEAD(list: &clp->cl_ownerstr_hashtbl[i]);
2250	INIT_LIST_HEAD(list: &clp->cl_sessions);
2251	idr_init(idr: &clp->cl_stateids);
2252	atomic_set(v: &clp->cl_rpc_users, i: 0);
2253	clp->cl_cb_state = NFSD4_CB_UNKNOWN;
2254	clp->cl_state = NFSD4_ACTIVE;
2255	atomic_inc(v: &nn->nfs4_client_count);
2256	atomic_set(v: &clp->cl_delegs_in_recall, i: 0);
2257	INIT_LIST_HEAD(list: &clp->cl_idhash);
2258	INIT_LIST_HEAD(list: &clp->cl_openowners);
2259	INIT_LIST_HEAD(list: &clp->cl_delegations);
2260	INIT_LIST_HEAD(list: &clp->cl_lru);
2261	INIT_LIST_HEAD(list: &clp->cl_revoked);
2262	#ifdef CONFIG_NFSD_PNFS
2263	INIT_LIST_HEAD(list: &clp->cl_lo_states);
2264	#endif
2265	INIT_LIST_HEAD(list: &clp->async_copies);
2266	spin_lock_init(&clp->async_lock);
2267	spin_lock_init(&clp->cl_lock);
2268	rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
2269	return clp;
2270	err_no_hashtbl:
2271	kfree(objp: clp->cl_name.data);
2272	err_no_name:
2273	kmem_cache_free(s: client_slab, objp: clp);
2274	return NULL;
2275	}
2276
2277	static void __free_client(struct kref *k)
2278	{
2279	struct nfsdfs_client *c = container_of(k, struct nfsdfs_client, cl_ref);
2280	struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs);
2281
2282	free_svc_cred(cred: &clp->cl_cred);
2283	kfree(objp: clp->cl_ownerstr_hashtbl);
2284	kfree(objp: clp->cl_name.data);
2285	kfree(objp: clp->cl_nii_domain.data);
2286	kfree(objp: clp->cl_nii_name.data);
2287	idr_destroy(&clp->cl_stateids);
2288	kfree(objp: clp->cl_ra);
2289	kmem_cache_free(s: client_slab, objp: clp);
2290	}
2291
2292	static void drop_client(struct nfs4_client *clp)
2293	{
2294	kref_put(kref: &clp->cl_nfsdfs.cl_ref, release: __free_client);
2295	}
2296
2297	static void
2298	free_client(struct nfs4_client *clp)
2299	{
2300	while (!list_empty(head: &clp->cl_sessions)) {
2301	struct nfsd4_session *ses;
2302	ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
2303	se_perclnt);
2304	list_del(entry: &ses->se_perclnt);
2305	WARN_ON_ONCE(atomic_read(&ses->se_ref));
2306	free_session(ses);
2307	}
2308	rpc_destroy_wait_queue(&clp->cl_cb_waitq);
2309	if (clp->cl_nfsd_dentry) {
2310	nfsd_client_rmdir(dentry: clp->cl_nfsd_dentry);
2311	clp->cl_nfsd_dentry = NULL;
2312	wake_up_all(&expiry_wq);
2313	}
2314	drop_client(clp);
2315	}
2316
2317	/* must be called under the client_lock */
2318	static void
2319	unhash_client_locked(struct nfs4_client *clp)
2320	{
2321	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
2322	struct nfsd4_session *ses;
2323
2324	lockdep_assert_held(&nn->client_lock);
2325
2326	/* Mark the client as expired! */
2327	clp->cl_time = 0;
2328	/* Make it invisible */
2329	if (!list_empty(head: &clp->cl_idhash)) {
2330	list_del_init(entry: &clp->cl_idhash);
2331	if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
2332	rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
2333	else
2334	rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2335	}
2336	list_del_init(entry: &clp->cl_lru);
2337	spin_lock(lock: &clp->cl_lock);
2338	list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
2339	list_del_init(entry: &ses->se_hash);
2340	spin_unlock(lock: &clp->cl_lock);
2341	}
2342
2343	static void
2344	unhash_client(struct nfs4_client *clp)
2345	{
2346	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
2347
2348	spin_lock(lock: &nn->client_lock);
2349	unhash_client_locked(clp);
2350	spin_unlock(lock: &nn->client_lock);
2351	}
2352
2353	static __be32 mark_client_expired_locked(struct nfs4_client *clp)
2354	{
2355	if (atomic_read(v: &clp->cl_rpc_users))
2356	return nfserr_jukebox;
2357	unhash_client_locked(clp);
2358	return nfs_ok;
2359	}
2360
2361	static void
2362	__destroy_client(struct nfs4_client *clp)
2363	{
2364	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
2365	int i;
2366	struct nfs4_openowner *oo;
2367	struct nfs4_delegation *dp;
2368	struct list_head reaplist;
2369
2370	INIT_LIST_HEAD(list: &reaplist);
2371	spin_lock(lock: &state_lock);
2372	while (!list_empty(head: &clp->cl_delegations)) {
2373	dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
2374	unhash_delegation_locked(dp, SC_STATUS_CLOSED);
2375	list_add(new: &dp->dl_recall_lru, head: &reaplist);
2376	}
2377	spin_unlock(lock: &state_lock);
2378	while (!list_empty(head: &reaplist)) {
2379	dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
2380	list_del_init(entry: &dp->dl_recall_lru);
2381	destroy_unhashed_deleg(dp);
2382	}
2383	while (!list_empty(head: &clp->cl_revoked)) {
2384	dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
2385	list_del_init(entry: &dp->dl_recall_lru);
2386	nfs4_put_stid(s: &dp->dl_stid);
2387	}
2388	while (!list_empty(head: &clp->cl_openowners)) {
2389	oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
2390	nfs4_get_stateowner(sop: &oo->oo_owner);
2391	release_openowner(oo);
2392	}
2393	for (i = 0; i < OWNER_HASH_SIZE; i++) {
2394	struct nfs4_stateowner *so, *tmp;
2395
2396	list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i],
2397	so_strhash) {
2398	/* Should be no openowners at this point */
2399	WARN_ON_ONCE(so->so_is_open_owner);
2400	remove_blocked_locks(lo: lockowner(so));
2401	}
2402	}
2403	nfsd4_return_all_client_layouts(clp);
2404	nfsd4_shutdown_copy(clp);
2405	nfsd4_shutdown_callback(clp);
2406	if (clp->cl_cb_conn.cb_xprt)
2407	svc_xprt_put(xprt: clp->cl_cb_conn.cb_xprt);
2408	atomic_add_unless(v: &nn->nfs4_client_count, a: -1, u: 0);
2409	nfsd4_dec_courtesy_client_count(nn, clp);
2410	free_client(clp);
2411	wake_up_all(&expiry_wq);
2412	}
2413
2414	static void
2415	destroy_client(struct nfs4_client *clp)
2416	{
2417	unhash_client(clp);
2418	__destroy_client(clp);
2419	}
2420
2421	static void inc_reclaim_complete(struct nfs4_client *clp)
2422	{
2423	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
2424
2425	if (!nn->track_reclaim_completes)
2426	return;
2427	if (!nfsd4_find_reclaim_client(name: clp->cl_name, nn))
2428	return;
2429	if (atomic_inc_return(v: &nn->nr_reclaim_complete) ==
2430	nn->reclaim_str_hashtbl_size) {
2431	printk(KERN_INFO "NFSD: all clients done reclaiming, ending NFSv4 grace period (net %x)\n",
2432	clp->net->ns.inum);
2433	nfsd4_end_grace(nn);
2434	}
2435	}
2436
2437	static void expire_client(struct nfs4_client *clp)
2438	{
2439	unhash_client(clp);
2440	nfsd4_client_record_remove(clp);
2441	__destroy_client(clp);
2442	}
2443
2444	static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
2445	{
2446	memcpy(target->cl_verifier.data, source->data,
2447	sizeof(target->cl_verifier.data));
2448	}
2449
2450	static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
2451	{
2452	target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
2453	target->cl_clientid.cl_id = source->cl_clientid.cl_id;
2454	}
2455
2456	static int copy_cred(struct svc_cred *target, struct svc_cred *source)
2457	{
2458	target->cr_principal = kstrdup(s: source->cr_principal, GFP_KERNEL);
2459	target->cr_raw_principal = kstrdup(s: source->cr_raw_principal,
2460	GFP_KERNEL);
2461	target->cr_targ_princ = kstrdup(s: source->cr_targ_princ, GFP_KERNEL);
2462	if ((source->cr_principal && !target->cr_principal) ||
2463	(source->cr_raw_principal && !target->cr_raw_principal) ||
2464	(source->cr_targ_princ && !target->cr_targ_princ))
2465	return -ENOMEM;
2466
2467	target->cr_flavor = source->cr_flavor;
2468	target->cr_uid = source->cr_uid;
2469	target->cr_gid = source->cr_gid;
2470	target->cr_group_info = source->cr_group_info;
2471	get_group_info(gi: target->cr_group_info);
2472	target->cr_gss_mech = source->cr_gss_mech;
2473	if (source->cr_gss_mech)
2474	gss_mech_get(source->cr_gss_mech);
2475	return 0;
2476	}
2477
2478	static int
2479	compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
2480	{
2481	if (o1->len < o2->len)
2482	return -1;
2483	if (o1->len > o2->len)
2484	return 1;
2485	return memcmp(p: o1->data, q: o2->data, size: o1->len);
2486	}
2487
2488	static int
2489	same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
2490	{
2491	return 0 == memcmp(p: v1->data, q: v2->data, size: sizeof(v1->data));
2492	}
2493
2494	static int
2495	same_clid(clientid_t *cl1, clientid_t *cl2)
2496	{
2497	return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
2498	}
2499
2500	static bool groups_equal(struct group_info *g1, struct group_info *g2)
2501	{
2502	int i;
2503
2504	if (g1->ngroups != g2->ngroups)
2505	return false;
2506	for (i=0; i<g1->ngroups; i++)
2507	if (!gid_eq(left: g1->gid[i], right: g2->gid[i]))
2508	return false;
2509	return true;
2510	}
2511
2512	/*
2513	* RFC 3530 language requires clid_inuse be returned when the
2514	* "principal" associated with a requests differs from that previously
2515	* used. We use uid, gid's, and gss principal string as our best
2516	* approximation. We also don't want to allow non-gss use of a client
2517	* established using gss: in theory cr_principal should catch that
2518	* change, but in practice cr_principal can be null even in the gss case
2519	* since gssd doesn't always pass down a principal string.
2520	*/
2521	static bool is_gss_cred(struct svc_cred *cr)
2522	{
2523	/* Is cr_flavor one of the gss "pseudoflavors"?: */
2524	return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
2525	}
2526
2527
2528	static bool
2529	same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
2530	{
2531	if ((is_gss_cred(cr: cr1) != is_gss_cred(cr: cr2))
2532	|| (!uid_eq(left: cr1->cr_uid, right: cr2->cr_uid))
2533	|| (!gid_eq(left: cr1->cr_gid, right: cr2->cr_gid))
2534	|| !groups_equal(g1: cr1->cr_group_info, g2: cr2->cr_group_info))
2535	return false;
2536	/* XXX: check that cr_targ_princ fields match ? */
2537	if (cr1->cr_principal == cr2->cr_principal)
2538	return true;
2539	if (!cr1->cr_principal || !cr2->cr_principal)
2540	return false;
2541	return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
2542	}
2543
2544	static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
2545	{
2546	struct svc_cred *cr = &rqstp->rq_cred;
2547	u32 service;
2548
2549	if (!cr->cr_gss_mech)
2550	return false;
2551	service = gss_pseudoflavor_to_service(cr->cr_gss_mech, pseudoflavor: cr->cr_flavor);
2552	return service == RPC_GSS_SVC_INTEGRITY ||
2553	service == RPC_GSS_SVC_PRIVACY;
2554	}
2555
2556	bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
2557	{
2558	struct svc_cred *cr = &rqstp->rq_cred;
2559
2560	if (!cl->cl_mach_cred)
2561	return true;
2562	if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
2563	return false;
2564	if (!svc_rqst_integrity_protected(rqstp))
2565	return false;
2566	if (cl->cl_cred.cr_raw_principal)
2567	return 0 == strcmp(cl->cl_cred.cr_raw_principal,
2568	cr->cr_raw_principal);
2569	if (!cr->cr_principal)
2570	return false;
2571	return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
2572	}
2573
2574	static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
2575	{
2576	__be32 verf[2];
2577
2578	/*
2579	* This is opaque to client, so no need to byte-swap. Use
2580	* __force to keep sparse happy
2581	*/
2582	verf[0] = (__force __be32)(u32)ktime_get_real_seconds();
2583	verf[1] = (__force __be32)nn->clverifier_counter++;
2584	memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
2585	}
2586
2587	static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
2588	{
2589	clp->cl_clientid.cl_boot = (u32)nn->boot_time;
2590	clp->cl_clientid.cl_id = nn->clientid_counter++;
2591	gen_confirm(clp, nn);
2592	}
2593
2594	static struct nfs4_stid *
2595	find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
2596	{
2597	struct nfs4_stid *ret;
2598
2599	ret = idr_find(&cl->cl_stateids, id: t->si_opaque.so_id);
2600	if (!ret || !ret->sc_type)
2601	return NULL;
2602	return ret;
2603	}
2604
2605	static struct nfs4_stid *
2606	find_stateid_by_type(struct nfs4_client *cl, stateid_t *t,
2607	unsigned short typemask, unsigned short ok_states)
2608	{
2609	struct nfs4_stid *s;
2610
2611	spin_lock(lock: &cl->cl_lock);
2612	s = find_stateid_locked(cl, t);
2613	if (s != NULL) {
2614	if ((s->sc_status & ~ok_states) == 0 &&
2615	(typemask & s->sc_type))
2616	refcount_inc(r: &s->sc_count);
2617	else
2618	s = NULL;
2619	}
2620	spin_unlock(lock: &cl->cl_lock);
2621	return s;
2622	}
2623
2624	static struct nfs4_client *get_nfsdfs_clp(struct inode *inode)
2625	{
2626	struct nfsdfs_client *nc;
2627	nc = get_nfsdfs_client(inode);
2628	if (!nc)
2629	return NULL;
2630	return container_of(nc, struct nfs4_client, cl_nfsdfs);
2631	}
2632
2633	static void seq_quote_mem(struct seq_file *m, char *data, int len)
2634	{
2635	seq_puts(m, s: "\"");
2636	seq_escape_mem(m, src: data, len, ESCAPE_HEX | ESCAPE_NAP | ESCAPE_APPEND, esc: "\"\\");
2637	seq_puts(m, s: "\"");
2638	}
2639
2640	static const char *cb_state2str(int state)
2641	{
2642	switch (state) {
2643	case NFSD4_CB_UP:
2644	return "UP";
2645	case NFSD4_CB_UNKNOWN:
2646	return "UNKNOWN";
2647	case NFSD4_CB_DOWN:
2648	return "DOWN";
2649	case NFSD4_CB_FAULT:
2650	return "FAULT";
2651	}
2652	return "UNDEFINED";
2653	}
2654
2655	static int client_info_show(struct seq_file *m, void *v)
2656	{
2657	struct inode *inode = file_inode(f: m->file);
2658	struct nfs4_client *clp;
2659	u64 clid;
2660
2661	clp = get_nfsdfs_clp(inode);
2662	if (!clp)
2663	return -ENXIO;
2664	memcpy(&clid, &clp->cl_clientid, sizeof(clid));
2665	seq_printf(m, fmt: "clientid: 0x%llx\n", clid);
2666	seq_printf(m, fmt: "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr);
2667
2668	if (clp->cl_state == NFSD4_COURTESY)
2669	seq_puts(m, s: "status: courtesy\n");
2670	else if (clp->cl_state == NFSD4_EXPIRABLE)
2671	seq_puts(m, s: "status: expirable\n");
2672	else if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
2673	seq_puts(m, s: "status: confirmed\n");
2674	else
2675	seq_puts(m, s: "status: unconfirmed\n");
2676	seq_printf(m, fmt: "seconds from last renew: %lld\n",
2677	ktime_get_boottime_seconds() - clp->cl_time);
2678	seq_puts(m, s: "name: ");
2679	seq_quote_mem(m, data: clp->cl_name.data, len: clp->cl_name.len);
2680	seq_printf(m, fmt: "\nminor version: %d\n", clp->cl_minorversion);
2681	if (clp->cl_nii_domain.data) {
2682	seq_puts(m, s: "Implementation domain: ");
2683	seq_quote_mem(m, data: clp->cl_nii_domain.data,
2684	len: clp->cl_nii_domain.len);
2685	seq_puts(m, s: "\nImplementation name: ");
2686	seq_quote_mem(m, data: clp->cl_nii_name.data, len: clp->cl_nii_name.len);
2687	seq_printf(m, fmt: "\nImplementation time: [%lld, %ld]\n",
2688	clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec);
2689	}
2690	seq_printf(m, fmt: "callback state: %s\n", cb_state2str(state: clp->cl_cb_state));
2691	seq_printf(m, fmt: "callback address: %pISpc\n", &clp->cl_cb_conn.cb_addr);
2692	seq_printf(m, fmt: "admin-revoked states: %d\n",
2693	atomic_read(v: &clp->cl_admin_revoked));
2694	drop_client(clp);
2695
2696	return 0;
2697	}
2698
2699	DEFINE_SHOW_ATTRIBUTE(client_info);
2700
2701	static void *states_start(struct seq_file *s, loff_t *pos)
2702	__acquires(&clp->cl_lock)
2703	{
2704	struct nfs4_client *clp = s->private;
2705	unsigned long id = *pos;
2706	void *ret;
2707
2708	spin_lock(lock: &clp->cl_lock);
2709	ret = idr_get_next_ul(&clp->cl_stateids, nextid: &id);
2710	*pos = id;
2711	return ret;
2712	}
2713
2714	static void *states_next(struct seq_file *s, void *v, loff_t *pos)
2715	{
2716	struct nfs4_client *clp = s->private;
2717	unsigned long id = *pos;
2718	void *ret;
2719
2720	id = *pos;
2721	id++;
2722	ret = idr_get_next_ul(&clp->cl_stateids, nextid: &id);
2723	*pos = id;
2724	return ret;
2725	}
2726
2727	static void states_stop(struct seq_file *s, void *v)
2728	__releases(&clp->cl_lock)
2729	{
2730	struct nfs4_client *clp = s->private;
2731
2732	spin_unlock(lock: &clp->cl_lock);
2733	}
2734
2735	static void nfs4_show_fname(struct seq_file *s, struct nfsd_file *f)
2736	{
2737	seq_printf(m: s, fmt: "filename: \"%pD2\"", f->nf_file);
2738	}
2739
2740	static void nfs4_show_superblock(struct seq_file *s, struct nfsd_file *f)
2741	{
2742	struct inode *inode = file_inode(f: f->nf_file);
2743
2744	seq_printf(m: s, fmt: "superblock: \"%02x:%02x:%ld\"",
2745	MAJOR(inode->i_sb->s_dev),
2746	MINOR(inode->i_sb->s_dev),
2747	inode->i_ino);
2748	}
2749
2750	static void nfs4_show_owner(struct seq_file *s, struct nfs4_stateowner *oo)
2751	{
2752	seq_puts(m: s, s: "owner: ");
2753	seq_quote_mem(m: s, data: oo->so_owner.data, len: oo->so_owner.len);
2754	}
2755
2756	static void nfs4_show_stateid(struct seq_file *s, stateid_t *stid)
2757	{
2758	seq_printf(m: s, fmt: "0x%.8x", stid->si_generation);
2759	seq_printf(m: s, fmt: "%12phN", &stid->si_opaque);
2760	}
2761
2762	static int nfs4_show_open(struct seq_file *s, struct nfs4_stid *st)
2763	{
2764	struct nfs4_ol_stateid *ols;
2765	struct nfs4_file *nf;
2766	struct nfsd_file *file;
2767	struct nfs4_stateowner *oo;
2768	unsigned int access, deny;
2769
2770	ols = openlockstateid(s: st);
2771	oo = ols->st_stateowner;
2772	nf = st->sc_file;
2773
2774	seq_puts(m: s, s: "- ");
2775	nfs4_show_stateid(s, stid: &st->sc_stateid);
2776	seq_puts(m: s, s: ": { type: open, ");
2777
2778	access = bmap_to_share_mode(bmap: ols->st_access_bmap);
2779	deny = bmap_to_share_mode(bmap: ols->st_deny_bmap);
2780
2781	seq_printf(m: s, fmt: "access: %s%s, ",
2782	access & NFS4_SHARE_ACCESS_READ ? "r" : "-",
2783	access & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
2784	seq_printf(m: s, fmt: "deny: %s%s, ",
2785	deny & NFS4_SHARE_ACCESS_READ ? "r" : "-",
2786	deny & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
2787
2788	spin_lock(lock: &nf->fi_lock);
2789	file = find_any_file_locked(f: nf);
2790	if (file) {
2791	nfs4_show_superblock(s, f: file);
2792	seq_puts(m: s, s: ", ");
2793	nfs4_show_fname(s, f: file);
2794	seq_puts(m: s, s: ", ");
2795	}
2796	spin_unlock(lock: &nf->fi_lock);
2797	nfs4_show_owner(s, oo);
2798	if (st->sc_status & SC_STATUS_ADMIN_REVOKED)
2799	seq_puts(m: s, s: ", admin-revoked");
2800	seq_puts(m: s, s: " }\n");
2801	return 0;
2802	}
2803
2804	static int nfs4_show_lock(struct seq_file *s, struct nfs4_stid *st)
2805	{
2806	struct nfs4_ol_stateid *ols;
2807	struct nfs4_file *nf;
2808	struct nfsd_file *file;
2809	struct nfs4_stateowner *oo;
2810
2811	ols = openlockstateid(s: st);
2812	oo = ols->st_stateowner;
2813	nf = st->sc_file;
2814
2815	seq_puts(m: s, s: "- ");
2816	nfs4_show_stateid(s, stid: &st->sc_stateid);
2817	seq_puts(m: s, s: ": { type: lock, ");
2818
2819	spin_lock(lock: &nf->fi_lock);
2820	file = find_any_file_locked(f: nf);
2821	if (file) {
2822	/*
2823	* Note: a lock stateid isn't really the same thing as a lock,
2824	* it's the locking state held by one owner on a file, and there
2825	* may be multiple (or no) lock ranges associated with it.
2826	* (Same for the matter is true of open stateids.)
2827	*/
2828
2829	nfs4_show_superblock(s, f: file);
2830	/* XXX: open stateid? */
2831	seq_puts(m: s, s: ", ");
2832	nfs4_show_fname(s, f: file);
2833	seq_puts(m: s, s: ", ");
2834	}
2835	nfs4_show_owner(s, oo);
2836	if (st->sc_status & SC_STATUS_ADMIN_REVOKED)
2837	seq_puts(m: s, s: ", admin-revoked");
2838	seq_puts(m: s, s: " }\n");
2839	spin_unlock(lock: &nf->fi_lock);
2840	return 0;
2841	}
2842
2843	static int nfs4_show_deleg(struct seq_file *s, struct nfs4_stid *st)
2844	{
2845	struct nfs4_delegation *ds;
2846	struct nfs4_file *nf;
2847	struct nfsd_file *file;
2848
2849	ds = delegstateid(s: st);
2850	nf = st->sc_file;
2851
2852	seq_puts(m: s, s: "- ");
2853	nfs4_show_stateid(s, stid: &st->sc_stateid);
2854	seq_puts(m: s, s: ": { type: deleg, ");
2855
2856	seq_printf(m: s, fmt: "access: %s",
2857	ds->dl_type == NFS4_OPEN_DELEGATE_READ ? "r" : "w");
2858
2859	/* XXX: lease time, whether it's being recalled. */
2860
2861	spin_lock(lock: &nf->fi_lock);
2862	file = nf->fi_deleg_file;
2863	if (file) {
2864	seq_puts(m: s, s: ", ");
2865	nfs4_show_superblock(s, f: file);
2866	seq_puts(m: s, s: ", ");
2867	nfs4_show_fname(s, f: file);
2868	}
2869	spin_unlock(lock: &nf->fi_lock);
2870	if (st->sc_status & SC_STATUS_ADMIN_REVOKED)
2871	seq_puts(m: s, s: ", admin-revoked");
2872	seq_puts(m: s, s: " }\n");
2873	return 0;
2874	}
2875
2876	static int nfs4_show_layout(struct seq_file *s, struct nfs4_stid *st)
2877	{
2878	struct nfs4_layout_stateid *ls;
2879	struct nfsd_file *file;
2880
2881	ls = container_of(st, struct nfs4_layout_stateid, ls_stid);
2882
2883	seq_puts(m: s, s: "- ");
2884	nfs4_show_stateid(s, stid: &st->sc_stateid);
2885	seq_puts(m: s, s: ": { type: layout");
2886
2887	/* XXX: What else would be useful? */
2888
2889	spin_lock(lock: &ls->ls_stid.sc_file->fi_lock);
2890	file = ls->ls_file;
2891	if (file) {
2892	seq_puts(m: s, s: ", ");
2893	nfs4_show_superblock(s, f: file);
2894	seq_puts(m: s, s: ", ");
2895	nfs4_show_fname(s, f: file);
2896	}
2897	spin_unlock(lock: &ls->ls_stid.sc_file->fi_lock);
2898	if (st->sc_status & SC_STATUS_ADMIN_REVOKED)
2899	seq_puts(m: s, s: ", admin-revoked");
2900	seq_puts(m: s, s: " }\n");
2901
2902	return 0;
2903	}
2904
2905	static int states_show(struct seq_file *s, void *v)
2906	{
2907	struct nfs4_stid *st = v;
2908
2909	switch (st->sc_type) {
2910	case SC_TYPE_OPEN:
2911	return nfs4_show_open(s, st);
2912	case SC_TYPE_LOCK:
2913	return nfs4_show_lock(s, st);
2914	case SC_TYPE_DELEG:
2915	return nfs4_show_deleg(s, st);
2916	case SC_TYPE_LAYOUT:
2917	return nfs4_show_layout(s, st);
2918	default:
2919	return 0; /* XXX: or SEQ_SKIP? */
2920	}
2921	/* XXX: copy stateids? */
2922	}
2923
2924	static struct seq_operations states_seq_ops = {
2925	.start = states_start,
2926	.next = states_next,
2927	.stop = states_stop,
2928	.show = states_show
2929	};
2930
2931	static int client_states_open(struct inode *inode, struct file *file)
2932	{
2933	struct seq_file *s;
2934	struct nfs4_client *clp;
2935	int ret;
2936
2937	clp = get_nfsdfs_clp(inode);
2938	if (!clp)
2939	return -ENXIO;
2940
2941	ret = seq_open(file, &states_seq_ops);
2942	if (ret)
2943	return ret;
2944	s = file->private_data;
2945	s->private = clp;
2946	return 0;
2947	}
2948
2949	static int client_opens_release(struct inode *inode, struct file *file)
2950	{
2951	struct seq_file *m = file->private_data;
2952	struct nfs4_client *clp = m->private;
2953
2954	/* XXX: alternatively, we could get/drop in seq start/stop */
2955	drop_client(clp);
2956	return seq_release(inode, file);
2957	}
2958
2959	static const struct file_operations client_states_fops = {
2960	.open = client_states_open,
2961	.read = seq_read,
2962	.llseek = seq_lseek,
2963	.release = client_opens_release,
2964	};
2965
2966	/*
2967	* Normally we refuse to destroy clients that are in use, but here the
2968	* administrator is telling us to just do it. We also want to wait
2969	* so the caller has a guarantee that the client's locks are gone by
2970	* the time the write returns:
2971	*/
2972	static void force_expire_client(struct nfs4_client *clp)
2973	{
2974	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
2975	bool already_expired;
2976
2977	trace_nfsd_clid_admin_expired(clid: &clp->cl_clientid);
2978
2979	spin_lock(lock: &nn->client_lock);
2980	clp->cl_time = 0;
2981	spin_unlock(lock: &nn->client_lock);
2982
2983	wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0);
2984	spin_lock(lock: &nn->client_lock);
2985	already_expired = list_empty(head: &clp->cl_lru);
2986	if (!already_expired)
2987	unhash_client_locked(clp);
2988	spin_unlock(lock: &nn->client_lock);
2989
2990	if (!already_expired)
2991	expire_client(clp);
2992	else
2993	wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL);
2994	}
2995
2996	static ssize_t client_ctl_write(struct file *file, const char __user *buf,
2997	size_t size, loff_t *pos)
2998	{
2999	char *data;
3000	struct nfs4_client *clp;
3001
3002	data = simple_transaction_get(file, buf, size);
3003	if (IS_ERR(ptr: data))
3004	return PTR_ERR(ptr: data);
3005	if (size != 7 || 0 != memcmp(p: data, q: "expire\n", size: 7))
3006	return -EINVAL;
3007	clp = get_nfsdfs_clp(inode: file_inode(f: file));
3008	if (!clp)
3009	return -ENXIO;
3010	force_expire_client(clp);
3011	drop_client(clp);
3012	return 7;
3013	}
3014
3015	static const struct file_operations client_ctl_fops = {
3016	.write = client_ctl_write,
3017	.release = simple_transaction_release,
3018	};
3019
3020	static const struct tree_descr client_files[] = {
3021	[0] = {.name: "info", .ops: &client_info_fops, S_IRUSR},
3022	[1] = {"states", &client_states_fops, S_IRUSR},
3023	[2] = {"ctl", &client_ctl_fops, S_IWUSR},
3024	[3] = {""},
3025	};
3026
3027	static int
3028	nfsd4_cb_recall_any_done(struct nfsd4_callback *cb,
3029	struct rpc_task *task)
3030	{
3031	trace_nfsd_cb_recall_any_done(cb, task);
3032	switch (task->tk_status) {
3033	case -NFS4ERR_DELAY:
3034	rpc_delay(task, 2 * HZ);
3035	return 0;
3036	default:
3037	return 1;
3038	}
3039	}
3040
3041	static void
3042	nfsd4_cb_recall_any_release(struct nfsd4_callback *cb)
3043	{
3044	struct nfs4_client *clp = cb->cb_clp;
3045
3046	clear_bit(NFSD4_CLIENT_CB_RECALL_ANY, addr: &clp->cl_flags);
3047	drop_client(clp);
3048	}
3049
3050	static int
3051	nfsd4_cb_getattr_done(struct nfsd4_callback *cb, struct rpc_task *task)
3052	{
3053	struct nfs4_cb_fattr *ncf =
3054	container_of(cb, struct nfs4_cb_fattr, ncf_getattr);
3055
3056	ncf->ncf_cb_status = task->tk_status;
3057	switch (task->tk_status) {
3058	case -NFS4ERR_DELAY:
3059	rpc_delay(task, 2 * HZ);
3060	return 0;
3061	default:
3062	return 1;
3063	}
3064	}
3065
3066	static void
3067	nfsd4_cb_getattr_release(struct nfsd4_callback *cb)
3068	{
3069	struct nfs4_cb_fattr *ncf =
3070	container_of(cb, struct nfs4_cb_fattr, ncf_getattr);
3071	struct nfs4_delegation *dp =
3072	container_of(ncf, struct nfs4_delegation, dl_cb_fattr);
3073
3074	nfs4_put_stid(s: &dp->dl_stid);
3075	clear_bit(CB_GETATTR_BUSY, addr: &ncf->ncf_cb_flags);
3076	wake_up_bit(word: &ncf->ncf_cb_flags, CB_GETATTR_BUSY);
3077	}
3078
3079	static const struct nfsd4_callback_ops nfsd4_cb_recall_any_ops = {
3080	.done = nfsd4_cb_recall_any_done,
3081	.release = nfsd4_cb_recall_any_release,
3082	};
3083
3084	static const struct nfsd4_callback_ops nfsd4_cb_getattr_ops = {
3085	.done = nfsd4_cb_getattr_done,
3086	.release = nfsd4_cb_getattr_release,
3087	};
3088
3089	static void nfs4_cb_getattr(struct nfs4_cb_fattr *ncf)
3090	{
3091	struct nfs4_delegation *dp =
3092	container_of(ncf, struct nfs4_delegation, dl_cb_fattr);
3093
3094	if (test_and_set_bit(CB_GETATTR_BUSY, addr: &ncf->ncf_cb_flags))
3095	return;
3096	/* set to proper status when nfsd4_cb_getattr_done runs */
3097	ncf->ncf_cb_status = NFS4ERR_IO;
3098
3099	refcount_inc(r: &dp->dl_stid.sc_count);
3100	nfsd4_run_cb(cb: &ncf->ncf_getattr);
3101	}
3102
3103	static struct nfs4_client *create_client(struct xdr_netobj name,
3104	struct svc_rqst *rqstp, nfs4_verifier *verf)
3105	{
3106	struct nfs4_client *clp;
3107	struct sockaddr *sa = svc_addr(rqst: rqstp);
3108	int ret;
3109	struct net *net = SVC_NET(rqstp);
3110	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
3111	struct dentry *dentries[ARRAY_SIZE(client_files)];
3112
3113	clp = alloc_client(name, nn);
3114	if (clp == NULL)
3115	return NULL;
3116
3117	ret = copy_cred(target: &clp->cl_cred, source: &rqstp->rq_cred);
3118	if (ret) {
3119	free_client(clp);
3120	return NULL;
3121	}
3122	gen_clid(clp, nn);
3123	kref_init(kref: &clp->cl_nfsdfs.cl_ref);
3124	nfsd4_init_cb(cb: &clp->cl_cb_null, clp, NULL, op: NFSPROC4_CLNT_CB_NULL);
3125	clp->cl_time = ktime_get_boottime_seconds();
3126	clear_bit(nr: 0, addr: &clp->cl_cb_slot_busy);
3127	copy_verf(target: clp, source: verf);
3128	memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage));
3129	clp->cl_cb_session = NULL;
3130	clp->net = net;
3131	clp->cl_nfsd_dentry = nfsd_client_mkdir(
3132	nn, ncl: &clp->cl_nfsdfs,
3133	id: clp->cl_clientid.cl_id - nn->clientid_base,
3134	client_files, fdentries: dentries);
3135	clp->cl_nfsd_info_dentry = dentries[0];
3136	if (!clp->cl_nfsd_dentry) {
3137	free_client(clp);
3138	return NULL;
3139	}
3140	clp->cl_ra = kzalloc(size: sizeof(*clp->cl_ra), GFP_KERNEL);
3141	if (!clp->cl_ra) {
3142	free_client(clp);
3143	return NULL;
3144	}
3145	clp->cl_ra_time = 0;
3146	nfsd4_init_cb(cb: &clp->cl_ra->ra_cb, clp, ops: &nfsd4_cb_recall_any_ops,
3147	op: NFSPROC4_CLNT_CB_RECALL_ANY);
3148	return clp;
3149	}
3150
3151	static void
3152	add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
3153	{
3154	struct rb_node **new = &(root->rb_node), *parent = NULL;
3155	struct nfs4_client *clp;
3156
3157	while (*new) {
3158	clp = rb_entry(*new, struct nfs4_client, cl_namenode);
3159	parent = *new;
3160
3161	if (compare_blob(o1: &clp->cl_name, o2: &new_clp->cl_name) > 0)
3162	new = &((*new)->rb_left);
3163	else
3164	new = &((*new)->rb_right);
3165	}
3166
3167	rb_link_node(node: &new_clp->cl_namenode, parent, rb_link: new);
3168	rb_insert_color(&new_clp->cl_namenode, root);
3169	}
3170
3171	static struct nfs4_client *
3172	find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
3173	{
3174	int cmp;
3175	struct rb_node *node = root->rb_node;
3176	struct nfs4_client *clp;
3177
3178	while (node) {
3179	clp = rb_entry(node, struct nfs4_client, cl_namenode);
3180	cmp = compare_blob(o1: &clp->cl_name, o2: name);
3181	if (cmp > 0)
3182	node = node->rb_left;
3183	else if (cmp < 0)
3184	node = node->rb_right;
3185	else
3186	return clp;
3187	}
3188	return NULL;
3189	}
3190
3191	static void
3192	add_to_unconfirmed(struct nfs4_client *clp)
3193	{
3194	unsigned int idhashval;
3195	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
3196
3197	lockdep_assert_held(&nn->client_lock);
3198
3199	clear_bit(NFSD4_CLIENT_CONFIRMED, addr: &clp->cl_flags);
3200	add_clp_to_name_tree(new_clp: clp, root: &nn->unconf_name_tree);
3201	idhashval = clientid_hashval(id: clp->cl_clientid.cl_id);
3202	list_add(new: &clp->cl_idhash, head: &nn->unconf_id_hashtbl[idhashval]);
3203	renew_client_locked(clp);
3204	}
3205
3206	static void
3207	move_to_confirmed(struct nfs4_client *clp)
3208	{
3209	unsigned int idhashval = clientid_hashval(id: clp->cl_clientid.cl_id);
3210	struct nfsd_net *nn = net_generic(net: clp->net, id: nfsd_net_id);
3211
3212	lockdep_assert_held(&nn->client_lock);
3213
3214	list_move(list: &clp->cl_idhash, head: &nn->conf_id_hashtbl[idhashval]);
3215	rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
3216	add_clp_to_name_tree(new_clp: clp, root: &nn->conf_name_tree);
3217	set_bit(NFSD4_CLIENT_CONFIRMED, addr: &clp->cl_flags);
3218	trace_nfsd_clid_confirmed(clid: &clp->cl_clientid);
3219	renew_client_locked(clp);
3220	}
3221
3222	static struct nfs4_client *
3223	find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
3224	{
3225	struct nfs4_client *clp;
3226	unsigned int idhashval = clientid_hashval(id: clid->cl_id);
3227
3228	list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
3229	if (same_clid(cl1: &clp->cl_clientid, cl2: clid)) {
3230	if ((bool)clp->cl_minorversion != sessions)
3231	return NULL;
3232	renew_client_locked(clp);
3233	return clp;
3234	}
3235	}
3236	return NULL;
3237	}
3238
3239	static struct nfs4_client *
3240	find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
3241	{
3242	struct list_head *tbl = nn->conf_id_hashtbl;
3243
3244	lockdep_assert_held(&nn->client_lock);
3245	return find_client_in_id_table(tbl, clid, sessions);
3246	}
3247
3248	static struct nfs4_client *
3249	find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
3250	{
3251	struct list_head *tbl = nn->unconf_id_hashtbl;
3252
3253	lockdep_assert_held(&nn->client_lock);
3254	return find_client_in_id_table(tbl, clid, sessions);
3255	}
3256
3257	static bool clp_used_exchangeid(struct nfs4_client *clp)
3258	{
3259	return clp->cl_exchange_flags != 0;
3260	}
3261
3262	static struct nfs4_client *
3263	find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
3264	{
3265	lockdep_assert_held(&nn->client_lock);
3266	return find_clp_in_name_tree(name, root: &nn->conf_name_tree);
3267	}
3268
3269	static struct nfs4_client *
3270	find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
3271	{
3272	lockdep_assert_held(&nn->client_lock);
3273	return find_clp_in_name_tree(name, root: &nn->unconf_name_tree);
3274	}
3275
3276	static void
3277	gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
3278	{
3279	struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
3280	struct sockaddr *sa = svc_addr(rqst: rqstp);
3281	u32 scopeid = rpc_get_scope_id(sa);
3282	unsigned short expected_family;
3283
3284	/* Currently, we only support tcp and tcp6 for the callback channel */
3285	if (se->se_callback_netid_len == 3 &&
3286	!memcmp(p: se->se_callback_netid_val, q: "tcp", size: 3))
3287	expected_family = AF_INET;
3288	else if (se->se_callback_netid_len == 4 &&
3289	!memcmp(p: se->se_callback_netid_val, q: "tcp6", size: 4))
3290	expected_family = AF_INET6;
3291	else
3292	goto out_err;
3293
3294	conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
3295	se->se_callback_addr_len,
3296	(struct sockaddr *)&conn->cb_addr,
3297	sizeof(conn->cb_addr));
3298
3299	if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
3300	goto out_err;
3301
3302	if (conn->cb_addr.ss_family == AF_INET6)
3303	((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
3304
3305	conn->cb_prog = se->se_callback_prog;
3306	conn->cb_ident = se->se_callback_ident;
3307	memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
3308	trace_nfsd_cb_args(clp, conn);
3309	return;
3310	out_err:
3311	conn->cb_addr.ss_family = AF_UNSPEC;
3312	conn->cb_addrlen = 0;
3313	trace_nfsd_cb_nodelegs(clp);
3314	return;
3315	}
3316
3317	/*
3318	* Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
3319	*/
3320	static void
3321	nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
3322	{
3323	struct xdr_buf *buf = resp->xdr->buf;
3324	struct nfsd4_slot *slot = resp->cstate.slot;
3325	unsigned int base;
3326
3327	dprintk("--> %s slot %p\n", __func__, slot);
3328
3329	slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
3330	slot->sl_opcnt = resp->opcnt;
3331	slot->sl_status = resp->cstate.status;
3332	free_svc_cred(cred: &slot->sl_cred);
3333	copy_cred(target: &slot->sl_cred, source: &resp->rqstp->rq_cred);
3334
3335	if (!nfsd4_cache_this(resp)) {
3336	slot->sl_flags &= ~NFSD4_SLOT_CACHED;
3337	return;
3338	}
3339	slot->sl_flags |= NFSD4_SLOT_CACHED;
3340
3341	base = resp->cstate.data_offset;
3342	slot->sl_datalen = buf->len - base;
3343	if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
3344	WARN(1, "%s: sessions DRC could not cache compound\n",
3345	__func__);
3346	return;
3347	}
3348
3349	/*
3350	* Encode the replay sequence operation from the slot values.
3351	* If cachethis is FALSE encode the uncached rep error on the next
3352	* operation which sets resp->p and increments resp->opcnt for
3353	* nfs4svc_encode_compoundres.
3354	*
3355	*/
3356	static __be32
3357	nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
3358	struct nfsd4_compoundres *resp)
3359	{
3360	struct nfsd4_op *op;
3361	struct nfsd4_slot *slot = resp->cstate.slot;
3362
3363	/* Encode the replayed sequence operation */
3364	op = &args->ops[resp->opcnt - 1];
3365	nfsd4_encode_operation(resp, op);
3366
3367	if (slot->sl_flags & NFSD4_SLOT_CACHED)
3368	return op->status;
3369	if (args->opcnt == 1) {
3370	/*
3371	* The original operation wasn't a solo sequence--we
3372	* always cache those--so this retry must not match the
3373	* original:
3374	*/
3375	op->status = nfserr_seq_false_retry;
3376	} else {
3377	op = &args->ops[resp->opcnt++];
3378	op->status = nfserr_retry_uncached_rep;
3379	nfsd4_encode_operation(resp, op);
3380	}
3381	return op->status;
3382	}
3383
3384	/*
3385	* The sequence operation is not cached because we can use the slot and
3386	* session values.
3387	*/
3388	static __be32
3389	nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
3390	struct nfsd4_sequence *seq)
3391	{
3392	struct nfsd4_slot *slot = resp->cstate.slot;
3393	struct xdr_stream *xdr = resp->xdr;
3394	__be32 *p;
3395	__be32 status;
3396
3397	dprintk("--> %s slot %p\n", __func__, slot);
3398
3399	status = nfsd4_enc_sequence_replay(args: resp->rqstp->rq_argp, resp);
3400	if (status)
3401	return status;
3402
3403	p = xdr_reserve_space(xdr, nbytes: slot->sl_datalen);
3404	if (!p) {
3405	WARN_ON_ONCE(1);
3406	return nfserr_serverfault;
3407	}
3408	xdr_encode_opaque_fixed(p, ptr: slot->sl_data, len: slot->sl_datalen);
3409	xdr_commit_encode(xdr);
3410
3411	resp->opcnt = slot->sl_opcnt;
3412	return slot->sl_status;
3413	}
3414
3415	/*
3416	* Set the exchange_id flags returned by the server.
3417	*/
3418	static void
3419	nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
3420	{
3421	#ifdef CONFIG_NFSD_PNFS
3422	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
3423	#else
3424	new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
3425	#endif
3426
3427	/* Referrals are supported, Migration is not. */
3428	new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
3429
3430	/* set the wire flags to return to client. */
3431	clid->flags = new->cl_exchange_flags;
3432	}
3433
3434	static bool client_has_openowners(struct nfs4_client *clp)
3435	{
3436	struct nfs4_openowner *oo;
3437
3438	list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
3439	if (!list_empty(head: &oo->oo_owner.so_stateids))
3440	return true;
3441	}
3442	return false;
3443	}
3444
3445	static bool client_has_state(struct nfs4_client *clp)
3446	{
3447	return client_has_openowners(clp)
3448	#ifdef CONFIG_NFSD_PNFS
3449	|| !list_empty(head: &clp->cl_lo_states)
3450	#endif
3451	|| !list_empty(head: &clp->cl_delegations)
3452	|| !list_empty(head: &clp->cl_sessions)
3453	|| !list_empty(head: &clp->async_copies);
3454	}
3455
3456	static __be32 copy_impl_id(struct nfs4_client *clp,
3457	struct nfsd4_exchange_id *exid)
3458	{
3459	if (!exid->nii_domain.data)
3460	return 0;
3461	xdr_netobj_dup(dst: &clp->cl_nii_domain, src: &exid->nii_domain, GFP_KERNEL);
3462	if (!clp->cl_nii_domain.data)
3463	return nfserr_jukebox;
3464	xdr_netobj_dup(dst: &clp->cl_nii_name, src: &exid->nii_name, GFP_KERNEL);
3465	if (!clp->cl_nii_name.data)
3466	return nfserr_jukebox;
3467	clp->cl_nii_time = exid->nii_time;
3468	return 0;
3469	}
3470
3471	__be32
3472	nfsd4_exchange_id(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3473	union nfsd4_op_u *u)
3474	{
3475	struct nfsd4_exchange_id *exid = &u->exchange_id;
3476	struct nfs4_client *conf, *new;
3477	struct nfs4_client *unconf = NULL;
3478	__be32 status;
3479	char addr_str[INET6_ADDRSTRLEN];
3480	nfs4_verifier verf = exid->verifier;
3481	struct sockaddr *sa = svc_addr(rqst: rqstp);
3482	bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
3483	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
3484
3485	rpc_ntop(sa, addr_str, sizeof(addr_str));
3486	dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
3487	"ip_addr=%s flags %x, spa_how %u\n",
3488	__func__, rqstp, exid, exid->clname.len, exid->clname.data,
3489	addr_str, exid->flags, exid->spa_how);
3490
3491	if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
3492	return nfserr_inval;
3493
3494	new = create_client(name: exid->clname, rqstp, verf: &verf);
3495	if (new == NULL)
3496	return nfserr_jukebox;
3497	status = copy_impl_id(clp: new, exid);
3498	if (status)
3499	goto out_nolock;
3500
3501	switch (exid->spa_how) {
3502	case SP4_MACH_CRED:
3503	exid->spo_must_enforce[0] = 0;
3504	exid->spo_must_enforce[1] = (
3505	1 << (OP_BIND_CONN_TO_SESSION - 32) |
3506	1 << (OP_EXCHANGE_ID - 32) |
3507	1 << (OP_CREATE_SESSION - 32) |
3508	1 << (OP_DESTROY_SESSION - 32) |
3509	1 << (OP_DESTROY_CLIENTID - 32));
3510
3511	exid->spo_must_allow[0] &= (1 << (OP_CLOSE) |
3512	1 << (OP_OPEN_DOWNGRADE) |
3513	1 << (OP_LOCKU) |
3514	1 << (OP_DELEGRETURN));
3515
3516	exid->spo_must_allow[1] &= (
3517	1 << (OP_TEST_STATEID - 32) |
3518	1 << (OP_FREE_STATEID - 32));
3519	if (!svc_rqst_integrity_protected(rqstp)) {
3520	status = nfserr_inval;
3521	goto out_nolock;
3522	}
3523	/*
3524	* Sometimes userspace doesn't give us a principal.
3525	* Which is a bug, really. Anyway, we can't enforce
3526	* MACH_CRED in that case, better to give up now:
3527	*/
3528	if (!new->cl_cred.cr_principal &&
3529	!new->cl_cred.cr_raw_principal) {
3530	status = nfserr_serverfault;
3531	goto out_nolock;
3532	}
3533	new->cl_mach_cred = true;
3534	break;
3535	case SP4_NONE:
3536	break;
3537	default: /* checked by xdr code */
3538	WARN_ON_ONCE(1);
3539	fallthrough;
3540	case SP4_SSV:
3541	status = nfserr_encr_alg_unsupp;
3542	goto out_nolock;
3543	}
3544
3545	/* Cases below refer to rfc 5661 section 18.35.4: */
3546	spin_lock(lock: &nn->client_lock);
3547	conf = find_confirmed_client_by_name(name: &exid->clname, nn);
3548	if (conf) {
3549	bool creds_match = same_creds(cr1: &conf->cl_cred, cr2: &rqstp->rq_cred);
3550	bool verfs_match = same_verf(v1: &verf, v2: &conf->cl_verifier);
3551
3552	if (update) {
3553	if (!clp_used_exchangeid(clp: conf)) { /* buggy client */
3554	status = nfserr_inval;
3555	goto out;
3556	}
3557	if (!nfsd4_mach_creds_match(cl: conf, rqstp)) {
3558	status = nfserr_wrong_cred;
3559	goto out;
3560	}
3561	if (!creds_match) { /* case 9 */
3562	status = nfserr_perm;
3563	goto out;
3564	}
3565	if (!verfs_match) { /* case 8 */
3566	status = nfserr_not_same;
3567	goto out;
3568	}
3569	/* case 6 */
3570	exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
3571	trace_nfsd_clid_confirmed_r(clp: conf);
3572	goto out_copy;
3573	}
3574	if (!creds_match) { /* case 3 */
3575	if (client_has_state(clp: conf)) {
3576	status = nfserr_clid_inuse;
3577	trace_nfsd_clid_cred_mismatch(clp: conf, rqstp);
3578	goto out;
3579	}
3580	goto out_new;
3581	}
3582	if (verfs_match) { /* case 2 */
3583	conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
3584	trace_nfsd_clid_confirmed_r(clp: conf);
3585	goto out_copy;
3586	}
3587	/* case 5, client reboot */
3588	trace_nfsd_clid_verf_mismatch(clp: conf, rqstp, verf: &verf);
3589	conf = NULL;
3590	goto out_new;
3591	}
3592
3593	if (update) { /* case 7 */
3594	status = nfserr_noent;
3595	goto out;
3596	}
3597
3598	unconf = find_unconfirmed_client_by_name(name: &exid->clname, nn);
3599	if (unconf) /* case 4, possible retry or client restart */
3600	unhash_client_locked(clp: unconf);
3601
3602	/* case 1, new owner ID */
3603	trace_nfsd_clid_fresh(clp: new);
3604
3605	out_new:
3606	if (conf) {
3607	status = mark_client_expired_locked(clp: conf);
3608	if (status)
3609	goto out;
3610	trace_nfsd_clid_replaced(clid: &conf->cl_clientid);
3611	}
3612	new->cl_minorversion = cstate->minorversion;
3613	new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
3614	new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];
3615
3616	/* Contrived initial CREATE_SESSION response */
3617	new->cl_cs_slot.sl_status = nfserr_seq_misordered;
3618
3619	add_to_unconfirmed(clp: new);
3620	swap(new, conf);
3621	out_copy:
3622	exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
3623	exid->clientid.cl_id = conf->cl_clientid.cl_id;
3624
3625	exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
3626	nfsd4_set_ex_flags(new: conf, clid: exid);
3627
3628	dprintk("nfsd4_exchange_id seqid %d flags %x\n",
3629	conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
3630	status = nfs_ok;
3631
3632	out:
3633	spin_unlock(lock: &nn->client_lock);
3634	out_nolock:
3635	if (new)
3636	expire_client(clp: new);
3637	if (unconf) {
3638	trace_nfsd_clid_expire_unconf(clid: &unconf->cl_clientid);
3639	expire_client(clp: unconf);
3640	}
3641	return status;
3642	}
3643
3644	static __be32
3645	check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
3646	{
3647	dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
3648	slot_seqid);
3649
3650	/* The slot is in use, and no response has been sent. */
3651	if (slot_inuse) {
3652	if (seqid == slot_seqid)
3653	return nfserr_jukebox;
3654	else
3655	return nfserr_seq_misordered;
3656	}
3657	/* Note unsigned 32-bit arithmetic handles wraparound: */
3658	if (likely(seqid == slot_seqid + 1))
3659	return nfs_ok;
3660	if (seqid == slot_seqid)
3661	return nfserr_replay_cache;
3662	return nfserr_seq_misordered;
3663	}
3664
3665	/*
3666	* Cache the create session result into the create session single DRC
3667	* slot cache by saving the xdr structure. sl_seqid has been set.
3668	* Do this for solo or embedded create session operations.
3669	*/
3670	static void
3671	nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
3672	struct nfsd4_clid_slot *slot, __be32 nfserr)
3673	{
3674	slot->sl_status = nfserr;
3675	memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
3676	}
3677
3678	static __be32
3679	nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
3680	struct nfsd4_clid_slot *slot)
3681	{
3682	memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
3683	return slot->sl_status;
3684	}
3685
3686	#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
3687	2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
3688	1 + /* MIN tag is length with zero, only length */ \
3689	3 + /* version, opcount, opcode */ \
3690	XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
3691	/* seqid, slotID, slotID, cache */ \
3692	4 ) * sizeof(__be32))
3693
3694	#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
3695	2 + /* verifier: AUTH_NULL, length 0 */\
3696	1 + /* status */ \
3697	1 + /* MIN tag is length with zero, only length */ \
3698	3 + /* opcount, opcode, opstatus*/ \
3699	XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
3700	/* seqid, slotID, slotID, slotID, status */ \
3701	5 ) * sizeof(__be32))
3702
3703	static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
3704	{
3705	u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
3706
3707	if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
3708	return nfserr_toosmall;
3709	if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
3710	return nfserr_toosmall;
3711	ca->headerpadsz = 0;
3712	ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
3713	ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
3714	ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
3715	ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
3716	NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
3717	ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
3718	/*
3719	* Note decreasing slot size below client's request may make it
3720	* difficult for client to function correctly, whereas
3721	* decreasing the number of slots will (just?) affect
3722	* performance. When short on memory we therefore prefer to
3723	* decrease number of slots instead of their size. Clients that
3724	* request larger slots than they need will get poor results:
3725	* Note that we always allow at least one slot, because our
3726	* accounting is soft and provides no guarantees either way.
3727	*/
3728	ca->maxreqs = nfsd4_get_drc_mem(ca, nn);
3729
3730	return nfs_ok;
3731	}
3732
3733	/*
3734	* Server's NFSv4.1 backchannel support is AUTH_SYS-only for now.
3735	* These are based on similar macros in linux/sunrpc/msg_prot.h .
3736	*/
3737	#define RPC_MAX_HEADER_WITH_AUTH_SYS \
3738	(RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK))
3739
3740	#define RPC_MAX_REPHEADER_WITH_AUTH_SYS \
3741	(RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK))
3742
3743	#define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \
3744	RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32))
3745	#define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \
3746	RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \
3747	sizeof(__be32))
3748
3749	static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
3750	{
3751	ca->headerpadsz = 0;
3752
3753	if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
3754	return nfserr_toosmall;
3755	if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
3756	return nfserr_toosmall;
3757	ca->maxresp_cached = 0;
3758	if (ca->maxops < 2)
3759	return nfserr_toosmall;
3760
3761	return nfs_ok;
3762	}
3763
3764	static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
3765	{
3766	switch (cbs->flavor) {
3767	case RPC_AUTH_NULL:
3768	case RPC_AUTH_UNIX:
3769	return nfs_ok;
3770	default:
3771	/*
3772	* GSS case: the spec doesn't allow us to return this
3773	* error. But it also doesn't allow us not to support
3774	* GSS.
3775	* I'd rather this fail hard than return some error the
3776	* client might think it can already handle:
3777	*/
3778	return nfserr_encr_alg_unsupp;
3779	}
3780	}
3781
3782	__be32
3783	nfsd4_create_session(struct svc_rqst *rqstp,
3784	struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
3785	{
3786	struct nfsd4_create_session *cr_ses = &u->create_session;
3787	struct sockaddr *sa = svc_addr(rqst: rqstp);
3788	struct nfs4_client *conf, *unconf;
3789	struct nfsd4_clid_slot *cs_slot;
3790	struct nfs4_client *old = NULL;
3791	struct nfsd4_session *new;
3792	struct nfsd4_conn *conn;
3793	__be32 status = 0;
3794	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
3795
3796	if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
3797	return nfserr_inval;
3798	status = nfsd4_check_cb_sec(cbs: &cr_ses->cb_sec);
3799	if (status)
3800	return status;
3801	status = check_forechannel_attrs(ca: &cr_ses->fore_channel, nn);
3802	if (status)
3803	return status;
3804	status = check_backchannel_attrs(ca: &cr_ses->back_channel);
3805	if (status)
3806	goto out_release_drc_mem;
3807	status = nfserr_jukebox;
3808	new = alloc_session(fattrs: &cr_ses->fore_channel, battrs: &cr_ses->back_channel);
3809	if (!new)
3810	goto out_release_drc_mem;
3811	conn = alloc_conn_from_crses(rqstp, cses: cr_ses);
3812	if (!conn)
3813	goto out_free_session;
3814
3815	spin_lock(lock: &nn->client_lock);
3816
3817	/* RFC 8881 Section 18.36.4 Phase 1: Client record look-up. */
3818	unconf = find_unconfirmed_client(clid: &cr_ses->clientid, sessions: true, nn);
3819	conf = find_confirmed_client(clid: &cr_ses->clientid, sessions: true, nn);
3820	if (!conf && !unconf) {
3821	status = nfserr_stale_clientid;
3822	goto out_free_conn;
3823	}
3824
3825	/* RFC 8881 Section 18.36.4 Phase 2: Sequence ID processing. */
3826	if (conf)
3827	cs_slot = &conf->cl_cs_slot;
3828	else
3829	cs_slot = &unconf->cl_cs_slot;
3830	status = check_slot_seqid(seqid: cr_ses->seqid, slot_seqid: cs_slot->sl_seqid, slot_inuse: 0);
3831	switch (status) {
3832	case nfs_ok:
3833	cs_slot->sl_seqid++;
3834	cr_ses->seqid = cs_slot->sl_seqid;
3835	break;
3836	case nfserr_replay_cache:
3837	status = nfsd4_replay_create_session(cr_ses, slot: cs_slot);
3838	fallthrough;
3839	case nfserr_jukebox:
3840	/* The server MUST NOT cache NFS4ERR_DELAY */
3841	goto out_free_conn;
3842	default:
3843	goto out_cache_error;
3844	}
3845
3846	/* RFC 8881 Section 18.36.4 Phase 3: Client ID confirmation. */
3847	if (conf) {
3848	status = nfserr_wrong_cred;
3849	if (!nfsd4_mach_creds_match(cl: conf, rqstp))
3850	goto out_cache_error;
3851	} else {
3852	status = nfserr_clid_inuse;
3853	if (!same_creds(cr1: &unconf->cl_cred, cr2: &rqstp->rq_cred) ||
3854	!rpc_cmp_addr(sap1: sa, sap2: (struct sockaddr *) &unconf->cl_addr)) {
3855	trace_nfsd_clid_cred_mismatch(clp: unconf, rqstp);
3856	goto out_cache_error;
3857	}
3858	status = nfserr_wrong_cred;
3859	if (!nfsd4_mach_creds_match(cl: unconf, rqstp))
3860	goto out_cache_error;
3861	old = find_confirmed_client_by_name(name: &unconf->cl_name, nn);
3862	if (old) {
3863	status = mark_client_expired_locked(clp: old);
3864	if (status)
3865	goto out_expired_error;
3866	trace_nfsd_clid_replaced(clid: &old->cl_clientid);
3867	}
3868	move_to_confirmed(clp: unconf);
3869	conf = unconf;
3870	}
3871
3872	/* RFC 8881 Section 18.36.4 Phase 4: Session creation. */
3873	status = nfs_ok;
3874	/* Persistent sessions are not supported */
3875	cr_ses->flags &= ~SESSION4_PERSIST;
3876	/* Upshifting from TCP to RDMA is not supported */
3877	cr_ses->flags &= ~SESSION4_RDMA;
3878
3879	init_session(rqstp, new, clp: conf, cses: cr_ses);
3880	nfsd4_get_session_locked(ses: new);
3881
3882	memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
3883	NFS4_MAX_SESSIONID_LEN);
3884
3885	/* cache solo and embedded create sessions under the client_lock */
3886	nfsd4_cache_create_session(cr_ses, slot: cs_slot, nfserr: status);
3887	spin_unlock(lock: &nn->client_lock);
3888	if (conf == unconf)
3889	fsnotify_dentry(dentry: conf->cl_nfsd_info_dentry, FS_MODIFY);
3890	/* init connection and backchannel */
3891	nfsd4_init_conn(rqstp, conn, ses: new);
3892	nfsd4_put_session(ses: new);
3893	if (old)
3894	expire_client(clp: old);
3895	return status;
3896
3897	out_expired_error:
3898	old = NULL;
3899	/*
3900	* Revert the slot seq_nr change so the server will process
3901	* the client's resend instead of returning a cached response.
3902	*/
3903	if (status == nfserr_jukebox) {
3904	cs_slot->sl_seqid--;
3905	cr_ses->seqid = cs_slot->sl_seqid;
3906	goto out_free_conn;
3907	}
3908	out_cache_error:
3909	nfsd4_cache_create_session(cr_ses, slot: cs_slot, nfserr: status);
3910	out_free_conn:
3911	spin_unlock(lock: &nn->client_lock);
3912	free_conn(c: conn);
3913	if (old)
3914	expire_client(clp: old);
3915	out_free_session:
3916	__free_session(ses: new);
3917	out_release_drc_mem:
3918	nfsd4_put_drc_mem(ca: &cr_ses->fore_channel);
3919	return status;
3920	}
3921
3922	static __be32 nfsd4_map_bcts_dir(u32 *dir)
3923	{
3924	switch (*dir) {
3925	case NFS4_CDFC4_FORE:
3926	case NFS4_CDFC4_BACK:
3927	return nfs_ok;
3928	case NFS4_CDFC4_FORE_OR_BOTH:
3929	case NFS4_CDFC4_BACK_OR_BOTH:
3930	*dir = NFS4_CDFC4_BOTH;
3931	return nfs_ok;
3932	}
3933	return nfserr_inval;
3934	}
3935
3936	__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp,
3937	struct nfsd4_compound_state *cstate,
3938	union nfsd4_op_u *u)
3939	{
3940	struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;
3941	struct nfsd4_session *session = cstate->session;
3942	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
3943	__be32 status;
3944
3945	status = nfsd4_check_cb_sec(cbs: &bc->bc_cb_sec);
3946	if (status)
3947	return status;
3948	spin_lock(lock: &nn->client_lock);
3949	session->se_cb_prog = bc->bc_cb_program;
3950	session->se_cb_sec = bc->bc_cb_sec;
3951	spin_unlock(lock: &nn->client_lock);
3952
3953	nfsd4_probe_callback(clp: session->se_client);
3954
3955	return nfs_ok;
3956	}
3957
3958	static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
3959	{
3960	struct nfsd4_conn *c;
3961
3962	list_for_each_entry(c, &s->se_conns, cn_persession) {
3963	if (c->cn_xprt == xpt) {
3964	return c;
3965	}
3966	}
3967	return NULL;
3968	}
3969
3970	static __be32 nfsd4_match_existing_connection(struct svc_rqst *rqst,
3971	struct nfsd4_session *session, u32 req, struct nfsd4_conn **conn)
3972	{
3973	struct nfs4_client *clp = session->se_client;
3974	struct svc_xprt *xpt = rqst->rq_xprt;
3975	struct nfsd4_conn *c;
3976	__be32 status;
3977
3978	/* Following the last paragraph of RFC 5661 Section 18.34.3: */
3979	spin_lock(lock: &clp->cl_lock);
3980	c = __nfsd4_find_conn(xpt, s: session);
3981	if (!c)
3982	status = nfserr_noent;
3983	else if (req == c->cn_flags)
3984	status = nfs_ok;
3985	else if (req == NFS4_CDFC4_FORE_OR_BOTH &&
3986	c->cn_flags != NFS4_CDFC4_BACK)
3987	status = nfs_ok;
3988	else if (req == NFS4_CDFC4_BACK_OR_BOTH &&
3989	c->cn_flags != NFS4_CDFC4_FORE)
3990	status = nfs_ok;
3991	else
3992	status = nfserr_inval;
3993	spin_unlock(lock: &clp->cl_lock);
3994	if (status == nfs_ok && conn)
3995	*conn = c;
3996	return status;
3997	}
3998
3999	__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
4000	struct nfsd4_compound_state *cstate,
4001	union nfsd4_op_u *u)
4002	{
4003	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;
4004	__be32 status;
4005	struct nfsd4_conn *conn;
4006	struct nfsd4_session *session;
4007	struct net *net = SVC_NET(rqstp);
4008	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
4009
4010	if (!nfsd4_last_compound_op(rqstp))
4011	return nfserr_not_only_op;
4012	spin_lock(lock: &nn->client_lock);
4013	session = find_in_sessionid_hashtbl(sessionid: &bcts->sessionid, net, ret: &status);
4014	spin_unlock(lock: &nn->client_lock);
4015	if (!session)
4016	goto out_no_session;
4017	status = nfserr_wrong_cred;
4018	if (!nfsd4_mach_creds_match(cl: session->se_client, rqstp))
4019	goto out;
4020	status = nfsd4_match_existing_connection(rqst: rqstp, session,
4021	req: bcts->dir, conn: &conn);
4022	if (status == nfs_ok) {
4023	if (bcts->dir == NFS4_CDFC4_FORE_OR_BOTH ||
4024	bcts->dir == NFS4_CDFC4_BACK)
4025	conn->cn_flags |= NFS4_CDFC4_BACK;
4026	nfsd4_probe_callback(clp: session->se_client);
4027	goto out;
4028	}
4029	if (status == nfserr_inval)
4030	goto out;
4031	status = nfsd4_map_bcts_dir(dir: &bcts->dir);
4032	if (status)
4033	goto out;
4034	conn = alloc_conn(rqstp, flags: bcts->dir);
4035	status = nfserr_jukebox;
4036	if (!conn)
4037	goto out;
4038	nfsd4_init_conn(rqstp, conn, ses: session);
4039	status = nfs_ok;
4040	out:
4041	nfsd4_put_session(ses: session);
4042	out_no_session:
4043	return status;
4044	}
4045
4046	static bool nfsd4_compound_in_session(struct nfsd4_compound_state *cstate, struct nfs4_sessionid *sid)
4047	{
4048	if (!cstate->session)
4049	return false;
4050	return !memcmp(p: sid, q: &cstate->session->se_sessionid, size: sizeof(*sid));
4051	}
4052
4053	__be32
4054	nfsd4_destroy_session(struct svc_rqst *r, struct nfsd4_compound_state *cstate,
4055	union nfsd4_op_u *u)
4056	{
4057	struct nfs4_sessionid *sessionid = &u->destroy_session.sessionid;
4058	struct nfsd4_session *ses;
4059	__be32 status;
4060	int ref_held_by_me = 0;
4061	struct net *net = SVC_NET(r);
4062	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
4063
4064	status = nfserr_not_only_op;
4065	if (nfsd4_compound_in_session(cstate, sid: sessionid)) {
4066	if (!nfsd4_last_compound_op(rqstp: r))
4067	goto out;
4068	ref_held_by_me++;
4069	}
4070	dump_sessionid(fn: __func__, sessionid);
4071	spin_lock(lock: &nn->client_lock);
4072	ses = find_in_sessionid_hashtbl(sessionid, net, ret: &status);
4073	if (!ses)
4074	goto out_client_lock;
4075	status = nfserr_wrong_cred;
4076	if (!nfsd4_mach_creds_match(cl: ses->se_client, rqstp: r))
4077	goto out_put_session;
4078	status = mark_session_dead_locked(ses, ref_held_by_me: 1 + ref_held_by_me);
4079	if (status)
4080	goto out_put_session;
4081	unhash_session(ses);
4082	spin_unlock(lock: &nn->client_lock);
4083
4084	nfsd4_probe_callback_sync(clp: ses->se_client);
4085
4086	spin_lock(lock: &nn->client_lock);
4087	status = nfs_ok;
4088	out_put_session:
4089	nfsd4_put_session_locked(ses);
4090	out_client_lock:
4091	spin_unlock(lock: &nn->client_lock);
4092	out:
4093	return status;
4094	}
4095
4096	static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
4097	{
4098	struct nfs4_client *clp = ses->se_client;
4099	struct nfsd4_conn *c;
4100	__be32 status = nfs_ok;
4101	int ret;
4102
4103	spin_lock(lock: &clp->cl_lock);
4104	c = __nfsd4_find_conn(xpt: new->cn_xprt, s: ses);
4105	if (c)
4106	goto out_free;
4107	status = nfserr_conn_not_bound_to_session;
4108	if (clp->cl_mach_cred)
4109	goto out_free;
4110	__nfsd4_hash_conn(conn: new, ses);
4111	spin_unlock(lock: &clp->cl_lock);
4112	ret = nfsd4_register_conn(conn: new);
4113	if (ret)
4114	/* oops; xprt is already down: */
4115	nfsd4_conn_lost(u: &new->cn_xpt_user);
4116	return nfs_ok;
4117	out_free:
4118	spin_unlock(lock: &clp->cl_lock);
4119	free_conn(c: new);
4120	return status;
4121	}
4122
4123	static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
4124	{
4125	struct nfsd4_compoundargs *args = rqstp->rq_argp;
4126
4127	return args->opcnt > session->se_fchannel.maxops;
4128	}
4129
4130	static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
4131	struct nfsd4_session *session)
4132	{
4133	struct xdr_buf *xb = &rqstp->rq_arg;
4134
4135	return xb->len > session->se_fchannel.maxreq_sz;
4136	}
4137
4138	static bool replay_matches_cache(struct svc_rqst *rqstp,
4139	struct nfsd4_sequence *seq, struct nfsd4_slot *slot)
4140	{
4141	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
4142
4143	if ((bool)(slot->sl_flags & NFSD4_SLOT_CACHETHIS) !=
4144	(bool)seq->cachethis)
4145	return false;
4146	/*
4147	* If there's an error then the reply can have fewer ops than
4148	* the call.
4149	*/
4150	if (slot->sl_opcnt < argp->opcnt && !slot->sl_status)
4151	return false;
4152	/*
4153	* But if we cached a reply with *more* ops than the call you're
4154	* sending us now, then this new call is clearly not really a
4155	* replay of the old one:
4156	*/
4157	if (slot->sl_opcnt > argp->opcnt)
4158	return false;
4159	/* This is the only check explicitly called by spec: */
4160	if (!same_creds(cr1: &rqstp->rq_cred, cr2: &slot->sl_cred))
4161	return false;
4162	/*
4163	* There may be more comparisons we could actually do, but the
4164	* spec doesn't require us to catch every case where the calls
4165	* don't match (that would require caching the call as well as
4166	* the reply), so we don't bother.
4167	*/
4168	return true;
4169	}
4170
4171	__be32
4172	nfsd4_sequence(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4173	union nfsd4_op_u *u)
4174	{
4175	struct nfsd4_sequence *seq = &u->sequence;
4176	struct nfsd4_compoundres *resp = rqstp->rq_resp;
4177	struct xdr_stream *xdr = resp->xdr;
4178	struct nfsd4_session *session;
4179	struct nfs4_client *clp;
4180	struct nfsd4_slot *slot;
4181	struct nfsd4_conn *conn;
4182	__be32 status;
4183	int buflen;
4184	struct net *net = SVC_NET(rqstp);
4185	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
4186
4187	if (resp->opcnt != 1)
4188	return nfserr_sequence_pos;
4189
4190	/*
4191	* Will be either used or freed by nfsd4_sequence_check_conn
4192	* below.
4193	*/
4194	conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
4195	if (!conn)
4196	return nfserr_jukebox;
4197
4198	spin_lock(lock: &nn->client_lock);
4199	session = find_in_sessionid_hashtbl(sessionid: &seq->sessionid, net, ret: &status);
4200	if (!session)
4201	goto out_no_session;
4202	clp = session->se_client;
4203
4204	status = nfserr_too_many_ops;
4205	if (nfsd4_session_too_many_ops(rqstp, session))
4206	goto out_put_session;
4207
4208	status = nfserr_req_too_big;
4209	if (nfsd4_request_too_big(rqstp, session))
4210	goto out_put_session;
4211
4212	status = nfserr_badslot;
4213	if (seq->slotid >= session->se_fchannel.maxreqs)
4214	goto out_put_session;
4215
4216	slot = session->se_slots[seq->slotid];
4217	dprintk("%s: slotid %d\n", __func__, seq->slotid);
4218
4219	/* We do not negotiate the number of slots yet, so set the
4220	* maxslots to the session maxreqs which is used to encode
4221	* sr_highest_slotid and the sr_target_slot id to maxslots */
4222	seq->maxslots = session->se_fchannel.maxreqs;
4223
4224	status = check_slot_seqid(seqid: seq->seqid, slot_seqid: slot->sl_seqid,
4225	slot_inuse: slot->sl_flags & NFSD4_SLOT_INUSE);
4226	if (status == nfserr_replay_cache) {
4227	status = nfserr_seq_misordered;
4228	if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
4229	goto out_put_session;
4230	status = nfserr_seq_false_retry;
4231	if (!replay_matches_cache(rqstp, seq, slot))
4232	goto out_put_session;
4233	cstate->slot = slot;
4234	cstate->session = session;
4235	cstate->clp = clp;
4236	/* Return the cached reply status and set cstate->status
4237	* for nfsd4_proc_compound processing */
4238	status = nfsd4_replay_cache_entry(resp, seq);
4239	cstate->status = nfserr_replay_cache;
4240	goto out;
4241	}
4242	if (status)
4243	goto out_put_session;
4244
4245	status = nfsd4_sequence_check_conn(new: conn, ses: session);
4246	conn = NULL;
4247	if (status)
4248	goto out_put_session;
4249
4250	buflen = (seq->cachethis) ?
4251	session->se_fchannel.maxresp_cached :
4252	session->se_fchannel.maxresp_sz;
4253	status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
4254	nfserr_rep_too_big;
4255	if (xdr_restrict_buflen(xdr, newbuflen: buflen - rqstp->rq_auth_slack))
4256	goto out_put_session;
4257	svc_reserve(rqstp, space: buflen);
4258
4259	status = nfs_ok;
4260	/* Success! bump slot seqid */
4261	slot->sl_seqid = seq->seqid;
4262	slot->sl_flags |= NFSD4_SLOT_INUSE;
4263	if (seq->cachethis)
4264	slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
4265	else
4266	slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
4267
4268	cstate->slot = slot;
4269	cstate->session = session;
4270	cstate->clp = clp;
4271
4272	out:
4273	switch (clp->cl_cb_state) {
4274	case NFSD4_CB_DOWN:
4275	seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
4276	break;
4277	case NFSD4_CB_FAULT:
4278	seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
4279	break;
4280	default:
4281	seq->status_flags = 0;
4282	}
4283	if (!list_empty(head: &clp->cl_revoked))
4284	seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
4285	if (atomic_read(v: &clp->cl_admin_revoked))
4286	seq->status_flags |= SEQ4_STATUS_ADMIN_STATE_REVOKED;
4287	trace_nfsd_seq4_status(rqstp, sequence: seq);
4288	out_no_session:
4289	if (conn)
4290	free_conn(c: conn);
4291	spin_unlock(lock: &nn->client_lock);
4292	return status;
4293	out_put_session:
4294	nfsd4_put_session_locked(ses: session);
4295	goto out_no_session;
4296	}
4297
4298	void
4299	nfsd4_sequence_done(struct nfsd4_compoundres *resp)
4300	{
4301	struct nfsd4_compound_state *cs = &resp->cstate;
4302
4303	if (nfsd4_has_session(cs)) {
4304	if (cs->status != nfserr_replay_cache) {
4305	nfsd4_store_cache_entry(resp);
4306	cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
4307	}
4308	/* Drop session reference that was taken in nfsd4_sequence() */
4309	nfsd4_put_session(ses: cs->session);
4310	} else if (cs->clp)
4311	put_client_renew(clp: cs->clp);
4312	}
4313
4314	__be32
4315	nfsd4_destroy_clientid(struct svc_rqst *rqstp,
4316	struct nfsd4_compound_state *cstate,
4317	union nfsd4_op_u *u)
4318	{
4319	struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;
4320	struct nfs4_client *conf, *unconf;
4321	struct nfs4_client *clp = NULL;
4322	__be32 status = 0;
4323	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
4324
4325	spin_lock(lock: &nn->client_lock);
4326	unconf = find_unconfirmed_client(clid: &dc->clientid, sessions: true, nn);
4327	conf = find_confirmed_client(clid: &dc->clientid, sessions: true, nn);
4328	WARN_ON_ONCE(conf && unconf);
4329
4330	if (conf) {
4331	if (client_has_state(clp: conf)) {
4332	status = nfserr_clientid_busy;
4333	goto out;
4334	}
4335	status = mark_client_expired_locked(clp: conf);
4336	if (status)
4337	goto out;
4338	clp = conf;
4339	} else if (unconf)
4340	clp = unconf;
4341	else {
4342	status = nfserr_stale_clientid;
4343	goto out;
4344	}
4345	if (!nfsd4_mach_creds_match(cl: clp, rqstp)) {
4346	clp = NULL;
4347	status = nfserr_wrong_cred;
4348	goto out;
4349	}
4350	trace_nfsd_clid_destroyed(clid: &clp->cl_clientid);
4351	unhash_client_locked(clp);
4352	out:
4353	spin_unlock(lock: &nn->client_lock);
4354	if (clp)
4355	expire_client(clp);
4356	return status;
4357	}
4358
4359	__be32
4360	nfsd4_reclaim_complete(struct svc_rqst *rqstp,
4361	struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
4362	{
4363	struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;
4364	struct nfs4_client *clp = cstate->clp;
4365	__be32 status = 0;
4366
4367	if (rc->rca_one_fs) {
4368	if (!cstate->current_fh.fh_dentry)
4369	return nfserr_nofilehandle;
4370	/*
4371	* We don't take advantage of the rca_one_fs case.
4372	* That's OK, it's optional, we can safely ignore it.
4373	*/
4374	return nfs_ok;
4375	}
4376
4377	status = nfserr_complete_already;
4378	if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, addr: &clp->cl_flags))
4379	goto out;
4380
4381	status = nfserr_stale_clientid;
4382	if (is_client_expired(clp))
4383	/*
4384	* The following error isn't really legal.
4385	* But we only get here if the client just explicitly
4386	* destroyed the client. Surely it no longer cares what
4387	* error it gets back on an operation for the dead
4388	* client.
4389	*/
4390	goto out;
4391
4392	status = nfs_ok;
4393	trace_nfsd_clid_reclaim_complete(clid: &clp->cl_clientid);
4394	nfsd4_client_record_create(clp);
4395	inc_reclaim_complete(clp);
4396	out:
4397	return status;
4398	}
4399
4400	__be32
4401	nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4402	union nfsd4_op_u *u)
4403	{
4404	struct nfsd4_setclientid *setclid = &u->setclientid;
4405	struct xdr_netobj clname = setclid->se_name;
4406	nfs4_verifier clverifier = setclid->se_verf;
4407	struct nfs4_client *conf, *new;
4408	struct nfs4_client *unconf = NULL;
4409	__be32 status;
4410	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
4411
4412	new = create_client(name: clname, rqstp, verf: &clverifier);
4413	if (new == NULL)
4414	return nfserr_jukebox;
4415	spin_lock(lock: &nn->client_lock);
4416	conf = find_confirmed_client_by_name(name: &clname, nn);
4417	if (conf && client_has_state(clp: conf)) {
4418	status = nfserr_clid_inuse;
4419	if (clp_used_exchangeid(clp: conf))
4420	goto out;
4421	if (!same_creds(cr1: &conf->cl_cred, cr2: &rqstp->rq_cred)) {
4422	trace_nfsd_clid_cred_mismatch(clp: conf, rqstp);
4423	goto out;
4424	}
4425	}
4426	unconf = find_unconfirmed_client_by_name(name: &clname, nn);
4427	if (unconf)
4428	unhash_client_locked(clp: unconf);
4429	if (conf) {
4430	if (same_verf(v1: &conf->cl_verifier, v2: &clverifier)) {
4431	copy_clid(target: new, source: conf);
4432	gen_confirm(clp: new, nn);
4433	} else
4434	trace_nfsd_clid_verf_mismatch(clp: conf, rqstp,
4435	verf: &clverifier);
4436	} else
4437	trace_nfsd_clid_fresh(clp: new);
4438	new->cl_minorversion = 0;
4439	gen_callback(clp: new, se: setclid, rqstp);
4440	add_to_unconfirmed(clp: new);
4441	setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
4442	setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
4443	memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
4444	new = NULL;
4445	status = nfs_ok;
4446	out:
4447	spin_unlock(lock: &nn->client_lock);
4448	if (new)
4449	free_client(clp: new);
4450	if (unconf) {
4451	trace_nfsd_clid_expire_unconf(clid: &unconf->cl_clientid);
4452	expire_client(clp: unconf);
4453	}
4454	return status;
4455	}
4456
4457	__be32
4458	nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
4459	struct nfsd4_compound_state *cstate,
4460	union nfsd4_op_u *u)
4461	{
4462	struct nfsd4_setclientid_confirm *setclientid_confirm =
4463	&u->setclientid_confirm;
4464	struct nfs4_client *conf, *unconf;
4465	struct nfs4_client *old = NULL;
4466	nfs4_verifier confirm = setclientid_confirm->sc_confirm;
4467	clientid_t * clid = &setclientid_confirm->sc_clientid;
4468	__be32 status;
4469	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
4470
4471	if (STALE_CLIENTID(clid, nn))
4472	return nfserr_stale_clientid;
4473
4474	spin_lock(lock: &nn->client_lock);
4475	conf = find_confirmed_client(clid, sessions: false, nn);
4476	unconf = find_unconfirmed_client(clid, sessions: false, nn);
4477	/*
4478	* We try hard to give out unique clientid's, so if we get an
4479	* attempt to confirm the same clientid with a different cred,
4480	* the client may be buggy; this should never happen.
4481	*
4482	* Nevertheless, RFC 7530 recommends INUSE for this case:
4483	*/
4484	status = nfserr_clid_inuse;
4485	if (unconf && !same_creds(cr1: &unconf->cl_cred, cr2: &rqstp->rq_cred)) {
4486	trace_nfsd_clid_cred_mismatch(clp: unconf, rqstp);
4487	goto out;
4488	}
4489	if (conf && !same_creds(cr1: &conf->cl_cred, cr2: &rqstp->rq_cred)) {
4490	trace_nfsd_clid_cred_mismatch(clp: conf, rqstp);
4491	goto out;
4492	}
4493	if (!unconf || !same_verf(v1: &confirm, v2: &unconf->cl_confirm)) {
4494	if (conf && same_verf(v1: &confirm, v2: &conf->cl_confirm)) {
4495	status = nfs_ok;
4496	} else
4497	status = nfserr_stale_clientid;
4498	goto out;
4499	}
4500	status = nfs_ok;
4501	if (conf) {
4502	old = unconf;
4503	unhash_client_locked(clp: old);
4504	nfsd4_change_callback(clp: conf, &unconf->cl_cb_conn);
4505	} else {
4506	old = find_confirmed_client_by_name(name: &unconf->cl_name, nn);
4507	if (old) {
4508	status = nfserr_clid_inuse;
4509	if (client_has_state(clp: old)
4510	&& !same_creds(cr1: &unconf->cl_cred,
4511	cr2: &old->cl_cred)) {
4512	old = NULL;
4513	goto out;
4514	}
4515	status = mark_client_expired_locked(clp: old);
4516	if (status) {
4517	old = NULL;
4518	goto out;
4519	}
4520	trace_nfsd_clid_replaced(clid: &old->cl_clientid);
4521	}
4522	move_to_confirmed(clp: unconf);
4523	conf = unconf;
4524	}
4525	get_client_locked(clp: conf);
4526	spin_unlock(lock: &nn->client_lock);
4527	if (conf == unconf)
4528	fsnotify_dentry(dentry: conf->cl_nfsd_info_dentry, FS_MODIFY);
4529	nfsd4_probe_callback(clp: conf);
4530	spin_lock(lock: &nn->client_lock);
4531	put_client_renew_locked(clp: conf);
4532	out:
4533	spin_unlock(lock: &nn->client_lock);
4534	if (old)
4535	expire_client(clp: old);
4536	return status;
4537	}
4538
4539	static struct nfs4_file *nfsd4_alloc_file(void)
4540	{
4541	return kmem_cache_alloc(cachep: file_slab, GFP_KERNEL);
4542	}
4543
4544	/* OPEN Share state helper functions */
4545
4546	static void nfsd4_file_init(const struct svc_fh *fh, struct nfs4_file *fp)
4547	{
4548	refcount_set(r: &fp->fi_ref, n: 1);
4549	spin_lock_init(&fp->fi_lock);
4550	INIT_LIST_HEAD(list: &fp->fi_stateids);
4551	INIT_LIST_HEAD(list: &fp->fi_delegations);
4552	INIT_LIST_HEAD(list: &fp->fi_clnt_odstate);
4553	fh_copy_shallow(dst: &fp->fi_fhandle, src: &fh->fh_handle);
4554	fp->fi_deleg_file = NULL;
4555	fp->fi_had_conflict = false;
4556	fp->fi_share_deny = 0;
4557	memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
4558	memset(fp->fi_access, 0, sizeof(fp->fi_access));
4559	fp->fi_aliased = false;
4560	fp->fi_inode = d_inode(dentry: fh->fh_dentry);
4561	#ifdef CONFIG_NFSD_PNFS
4562	INIT_LIST_HEAD(list: &fp->fi_lo_states);
4563	atomic_set(v: &fp->fi_lo_recalls, i: 0);
4564	#endif
4565	}
4566
4567	void
4568	nfsd4_free_slabs(void)
4569	{
4570	kmem_cache_destroy(s: client_slab);
4571	kmem_cache_destroy(s: openowner_slab);
4572	kmem_cache_destroy(s: lockowner_slab);
4573	kmem_cache_destroy(s: file_slab);
4574	kmem_cache_destroy(s: stateid_slab);
4575	kmem_cache_destroy(s: deleg_slab);
4576	kmem_cache_destroy(s: odstate_slab);
4577	}
4578
4579	int
4580	nfsd4_init_slabs(void)
4581	{
4582	client_slab = KMEM_CACHE(nfs4_client, 0);
4583	if (client_slab == NULL)
4584	goto out;
4585	openowner_slab = KMEM_CACHE(nfs4_openowner, 0);
4586	if (openowner_slab == NULL)
4587	goto out_free_client_slab;
4588	lockowner_slab = KMEM_CACHE(nfs4_lockowner, 0);
4589	if (lockowner_slab == NULL)
4590	goto out_free_openowner_slab;
4591	file_slab = KMEM_CACHE(nfs4_file, 0);
4592	if (file_slab == NULL)
4593	goto out_free_lockowner_slab;
4594	stateid_slab = KMEM_CACHE(nfs4_ol_stateid, 0);
4595	if (stateid_slab == NULL)
4596	goto out_free_file_slab;
4597	deleg_slab = KMEM_CACHE(nfs4_delegation, 0);
4598	if (deleg_slab == NULL)
4599	goto out_free_stateid_slab;
4600	odstate_slab = KMEM_CACHE(nfs4_clnt_odstate, 0);
4601	if (odstate_slab == NULL)
4602	goto out_free_deleg_slab;
4603	return 0;
4604
4605	out_free_deleg_slab:
4606	kmem_cache_destroy(s: deleg_slab);
4607	out_free_stateid_slab:
4608	kmem_cache_destroy(s: stateid_slab);
4609	out_free_file_slab:
4610	kmem_cache_destroy(s: file_slab);
4611	out_free_lockowner_slab:
4612	kmem_cache_destroy(s: lockowner_slab);
4613	out_free_openowner_slab:
4614	kmem_cache_destroy(s: openowner_slab);
4615	out_free_client_slab:
4616	kmem_cache_destroy(s: client_slab);
4617	out:
4618	return -ENOMEM;
4619	}
4620
4621	static unsigned long
4622	nfsd4_state_shrinker_count(struct shrinker *shrink, struct shrink_control *sc)
4623	{
4624	int count;
4625	struct nfsd_net *nn = shrink->private_data;
4626
4627	count = atomic_read(v: &nn->nfsd_courtesy_clients);
4628	if (!count)
4629	count = atomic_long_read(v: &num_delegations);
4630	if (count)
4631	queue_work(wq: laundry_wq, work: &nn->nfsd_shrinker_work);
4632	return (unsigned long)count;
4633	}
4634
4635	static unsigned long
4636	nfsd4_state_shrinker_scan(struct shrinker *shrink, struct shrink_control *sc)
4637	{
4638	return SHRINK_STOP;
4639	}
4640
4641	void
4642	nfsd4_init_leases_net(struct nfsd_net *nn)
4643	{
4644	struct sysinfo si;
4645	u64 max_clients;
4646
4647	nn->nfsd4_lease = 90; /* default lease time */
4648	nn->nfsd4_grace = 90;
4649	nn->somebody_reclaimed = false;
4650	nn->track_reclaim_completes = false;
4651	nn->clverifier_counter = get_random_u32();
4652	nn->clientid_base = get_random_u32();
4653	nn->clientid_counter = nn->clientid_base + 1;
4654	nn->s2s_cp_cl_id = nn->clientid_counter++;
4655
4656	atomic_set(v: &nn->nfs4_client_count, i: 0);
4657	si_meminfo(val: &si);
4658	max_clients = (u64)si.totalram * si.mem_unit / (1024 * 1024 * 1024);
4659	max_clients *= NFS4_CLIENTS_PER_GB;
4660	nn->nfs4_max_clients = max_t(int, max_clients, NFS4_CLIENTS_PER_GB);
4661
4662	atomic_set(v: &nn->nfsd_courtesy_clients, i: 0);
4663	}
4664
4665	static void init_nfs4_replay(struct nfs4_replay *rp)
4666	{
4667	rp->rp_status = nfserr_serverfault;
4668	rp->rp_buflen = 0;
4669	rp->rp_buf = rp->rp_ibuf;
4670	mutex_init(&rp->rp_mutex);
4671	}
4672
4673	static void nfsd4_cstate_assign_replay(struct nfsd4_compound_state *cstate,
4674	struct nfs4_stateowner *so)
4675	{
4676	if (!nfsd4_has_session(cs: cstate)) {
4677	mutex_lock(&so->so_replay.rp_mutex);
4678	cstate->replay_owner = nfs4_get_stateowner(sop: so);
4679	}
4680	}
4681
4682	void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate)
4683	{
4684	struct nfs4_stateowner *so = cstate->replay_owner;
4685
4686	if (so != NULL) {
4687	cstate->replay_owner = NULL;
4688	mutex_unlock(lock: &so->so_replay.rp_mutex);
4689	nfs4_put_stateowner(sop: so);
4690	}
4691	}
4692
4693	static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
4694	{
4695	struct nfs4_stateowner *sop;
4696
4697	sop = kmem_cache_alloc(cachep: slab, GFP_KERNEL);
4698	if (!sop)
4699	return NULL;
4700
4701	xdr_netobj_dup(dst: &sop->so_owner, src: owner, GFP_KERNEL);
4702	if (!sop->so_owner.data) {
4703	kmem_cache_free(s: slab, objp: sop);
4704	return NULL;
4705	}
4706
4707	INIT_LIST_HEAD(list: &sop->so_stateids);
4708	sop->so_client = clp;
4709	init_nfs4_replay(rp: &sop->so_replay);
4710	atomic_set(v: &sop->so_count, i: 1);
4711	return sop;
4712	}
4713
4714	static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
4715	{
4716	lockdep_assert_held(&clp->cl_lock);
4717
4718	list_add(new: &oo->oo_owner.so_strhash,
4719	head: &clp->cl_ownerstr_hashtbl[strhashval]);
4720	list_add(new: &oo->oo_perclient, head: &clp->cl_openowners);
4721	}
4722
4723	static void nfs4_unhash_openowner(struct nfs4_stateowner *so)
4724	{
4725	unhash_openowner_locked(oo: openowner(so));
4726	}
4727
4728	static void nfs4_free_openowner(struct nfs4_stateowner *so)
4729	{
4730	struct nfs4_openowner *oo = openowner(so);
4731
4732	kmem_cache_free(s: openowner_slab, objp: oo);
4733	}
4734
4735	static const struct nfs4_stateowner_operations openowner_ops = {
4736	.so_unhash = nfs4_unhash_openowner,
4737	.so_free = nfs4_free_openowner,
4738	};
4739
4740	static struct nfs4_ol_stateid *
4741	nfsd4_find_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
4742	{
4743	struct nfs4_ol_stateid *local, *ret = NULL;
4744	struct nfs4_openowner *oo = open->op_openowner;
4745
4746	lockdep_assert_held(&fp->fi_lock);
4747
4748	list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
4749	/* ignore lock owners */
4750	if (local->st_stateowner->so_is_open_owner == 0)
4751	continue;
4752	if (local->st_stateowner != &oo->oo_owner)
4753	continue;
4754	if (local->st_stid.sc_type == SC_TYPE_OPEN &&
4755	!local->st_stid.sc_status) {
4756	ret = local;
4757	refcount_inc(r: &ret->st_stid.sc_count);
4758	break;
4759	}
4760	}
4761	return ret;
4762	}
4763
4764	static void nfsd4_drop_revoked_stid(struct nfs4_stid *s)
4765	__releases(&s->sc_client->cl_lock)
4766	{
4767	struct nfs4_client *cl = s->sc_client;
4768	LIST_HEAD(reaplist);
4769	struct nfs4_ol_stateid *stp;
4770	struct nfs4_delegation *dp;
4771	bool unhashed;
4772
4773	switch (s->sc_type) {
4774	case SC_TYPE_OPEN:
4775	stp = openlockstateid(s);
4776	if (unhash_open_stateid(stp, reaplist: &reaplist))
4777	put_ol_stateid_locked(stp, reaplist: &reaplist);
4778	spin_unlock(lock: &cl->cl_lock);
4779	free_ol_stateid_reaplist(reaplist: &reaplist);
4780	break;
4781	case SC_TYPE_LOCK:
4782	stp = openlockstateid(s);
4783	unhashed = unhash_lock_stateid(stp);
4784	spin_unlock(lock: &cl->cl_lock);
4785	if (unhashed)
4786	nfs4_put_stid(s);
4787	break;
4788	case SC_TYPE_DELEG:
4789	dp = delegstateid(s);
4790	list_del_init(entry: &dp->dl_recall_lru);
4791	spin_unlock(lock: &cl->cl_lock);
4792	nfs4_put_stid(s);
4793	break;
4794	default:
4795	spin_unlock(lock: &cl->cl_lock);
4796	}
4797	}
4798
4799	static void nfsd40_drop_revoked_stid(struct nfs4_client *cl,
4800	stateid_t *stid)
4801	{
4802	/* NFSv4.0 has no way for the client to tell the server
4803	* that it can forget an admin-revoked stateid.
4804	* So we keep it around until the first time that the
4805	* client uses it, and drop it the first time
4806	* nfserr_admin_revoked is returned.
4807	* For v4.1 and later we wait until explicitly told
4808	* to free the stateid.
4809	*/
4810	if (cl->cl_minorversion == 0) {
4811	struct nfs4_stid *st;
4812
4813	spin_lock(lock: &cl->cl_lock);
4814	st = find_stateid_locked(cl, t: stid);
4815	if (st)
4816	nfsd4_drop_revoked_stid(s: st);
4817	else
4818	spin_unlock(lock: &cl->cl_lock);
4819	}
4820	}
4821
4822	static __be32
4823	nfsd4_verify_open_stid(struct nfs4_stid *s)
4824	{
4825	__be32 ret = nfs_ok;
4826
4827	if (s->sc_status & SC_STATUS_ADMIN_REVOKED)
4828	ret = nfserr_admin_revoked;
4829	else if (s->sc_status & SC_STATUS_REVOKED)
4830	ret = nfserr_deleg_revoked;
4831	else if (s->sc_status & SC_STATUS_CLOSED)
4832	ret = nfserr_bad_stateid;
4833	return ret;
4834	}
4835
4836	/* Lock the stateid st_mutex, and deal with races with CLOSE */
4837	static __be32
4838	nfsd4_lock_ol_stateid(struct nfs4_ol_stateid *stp)
4839	{
4840	__be32 ret;
4841
4842	mutex_lock_nested(lock: &stp->st_mutex, subclass: LOCK_STATEID_MUTEX);
4843	ret = nfsd4_verify_open_stid(s: &stp->st_stid);
4844	if (ret == nfserr_admin_revoked)
4845	nfsd40_drop_revoked_stid(cl: stp->st_stid.sc_client,
4846	stid: &stp->st_stid.sc_stateid);
4847
4848	if (ret != nfs_ok)
4849	mutex_unlock(lock: &stp->st_mutex);
4850	return ret;
4851	}
4852
4853	static struct nfs4_ol_stateid *
4854	nfsd4_find_and_lock_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
4855	{
4856	struct nfs4_ol_stateid *stp;
4857	for (;;) {
4858	spin_lock(lock: &fp->fi_lock);
4859	stp = nfsd4_find_existing_open(fp, open);
4860	spin_unlock(lock: &fp->fi_lock);
4861	if (!stp || nfsd4_lock_ol_stateid(stp) == nfs_ok)
4862	break;
4863	nfs4_put_stid(s: &stp->st_stid);
4864	}
4865	return stp;
4866	}
4867
4868	static struct nfs4_openowner *
4869	alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
4870	struct nfsd4_compound_state *cstate)
4871	{
4872	struct nfs4_client *clp = cstate->clp;
4873	struct nfs4_openowner *oo, *ret;
4874
4875	oo = alloc_stateowner(slab: openowner_slab, owner: &open->op_owner, clp);
4876	if (!oo)
4877	return NULL;
4878	oo->oo_owner.so_ops = &openowner_ops;
4879	oo->oo_owner.so_is_open_owner = 1;
4880	oo->oo_owner.so_seqid = open->op_seqid;
4881	oo->oo_flags = 0;
4882	if (nfsd4_has_session(cs: cstate))
4883	oo->oo_flags |= NFS4_OO_CONFIRMED;
4884	oo->oo_time = 0;
4885	oo->oo_last_closed_stid = NULL;
4886	INIT_LIST_HEAD(list: &oo->oo_close_lru);
4887	spin_lock(lock: &clp->cl_lock);
4888	ret = find_openstateowner_str_locked(hashval: strhashval, open, clp);
4889	if (ret == NULL) {
4890	hash_openowner(oo, clp, strhashval);
4891	ret = oo;
4892	} else
4893	nfs4_free_stateowner(sop: &oo->oo_owner);
4894
4895	spin_unlock(lock: &clp->cl_lock);
4896	return ret;
4897	}
4898
4899	static struct nfs4_ol_stateid *
4900	init_open_stateid(struct nfs4_file *fp, struct nfsd4_open *open)
4901	{
4902
4903	struct nfs4_openowner *oo = open->op_openowner;
4904	struct nfs4_ol_stateid *retstp = NULL;
4905	struct nfs4_ol_stateid *stp;
4906
4907	stp = open->op_stp;
4908	/* We are moving these outside of the spinlocks to avoid the warnings */
4909	mutex_init(&stp->st_mutex);
4910	mutex_lock_nested(lock: &stp->st_mutex, subclass: OPEN_STATEID_MUTEX);
4911
4912	retry:
4913	spin_lock(lock: &oo->oo_owner.so_client->cl_lock);
4914	spin_lock(lock: &fp->fi_lock);
4915
4916	retstp = nfsd4_find_existing_open(fp, open);
4917	if (retstp)
4918	goto out_unlock;
4919
4920	open->op_stp = NULL;
4921	refcount_inc(r: &stp->st_stid.sc_count);
4922	stp->st_stid.sc_type = SC_TYPE_OPEN;
4923	INIT_LIST_HEAD(list: &stp->st_locks);
4924	stp->st_stateowner = nfs4_get_stateowner(sop: &oo->oo_owner);
4925	get_nfs4_file(fi: fp);
4926	stp->st_stid.sc_file = fp;
4927	stp->st_access_bmap = 0;
4928	stp->st_deny_bmap = 0;
4929	stp->st_openstp = NULL;
4930	list_add(new: &stp->st_perstateowner, head: &oo->oo_owner.so_stateids);
4931	list_add(new: &stp->st_perfile, head: &fp->fi_stateids);
4932
4933	out_unlock:
4934	spin_unlock(lock: &fp->fi_lock);
4935	spin_unlock(lock: &oo->oo_owner.so_client->cl_lock);
4936	if (retstp) {
4937	/* Handle races with CLOSE */
4938	if (nfsd4_lock_ol_stateid(stp: retstp) != nfs_ok) {
4939	nfs4_put_stid(s: &retstp->st_stid);
4940	goto retry;
4941	}
4942	/* To keep mutex tracking happy */
4943	mutex_unlock(lock: &stp->st_mutex);
4944	stp = retstp;
4945	}
4946	return stp;
4947	}
4948
4949	/*
4950	* In the 4.0 case we need to keep the owners around a little while to handle
4951	* CLOSE replay. We still do need to release any file access that is held by
4952	* them before returning however.
4953	*/
4954	static void
4955	move_to_close_lru(struct nfs4_ol_stateid *s, struct net *net)
4956	{
4957	struct nfs4_ol_stateid *last;
4958	struct nfs4_openowner *oo = openowner(so: s->st_stateowner);
4959	struct nfsd_net *nn = net_generic(net: s->st_stid.sc_client->net,
4960	id: nfsd_net_id);
4961
4962	dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
4963
4964	/*
4965	* We know that we hold one reference via nfsd4_close, and another
4966	* "persistent" reference for the client. If the refcount is higher
4967	* than 2, then there are still calls in progress that are using this
4968	* stateid. We can't put the sc_file reference until they are finished.
4969	* Wait for the refcount to drop to 2. Since it has been unhashed,
4970	* there should be no danger of the refcount going back up again at
4971	* this point.
4972	*/
4973	wait_event(close_wq, refcount_read(&s->st_stid.sc_count) == 2);
4974
4975	release_all_access(stp: s);
4976	if (s->st_stid.sc_file) {
4977	put_nfs4_file(fi: s->st_stid.sc_file);
4978	s->st_stid.sc_file = NULL;
4979	}
4980
4981	spin_lock(lock: &nn->client_lock);
4982	last = oo->oo_last_closed_stid;
4983	oo->oo_last_closed_stid = s;
4984	list_move_tail(list: &oo->oo_close_lru, head: &nn->close_lru);
4985	oo->oo_time = ktime_get_boottime_seconds();
4986	spin_unlock(lock: &nn->client_lock);
4987	if (last)
4988	nfs4_put_stid(s: &last->st_stid);
4989	}
4990
4991	static noinline_for_stack struct nfs4_file *
4992	nfsd4_file_hash_lookup(const struct svc_fh *fhp)
4993	{
4994	struct inode *inode = d_inode(dentry: fhp->fh_dentry);
4995	struct rhlist_head *tmp, *list;
4996	struct nfs4_file *fi;
4997
4998	rcu_read_lock();
4999	list = rhltable_lookup(hlt: &nfs4_file_rhltable, key: &inode,
5000	params: nfs4_file_rhash_params);
5001	rhl_for_each_entry_rcu(fi, tmp, list, fi_rlist) {
5002	if (fh_match(fh1: &fi->fi_fhandle, fh2: &fhp->fh_handle)) {
5003	if (refcount_inc_not_zero(r: &fi->fi_ref)) {
5004	rcu_read_unlock();
5005	return fi;
5006	}
5007	}
5008	}
5009	rcu_read_unlock();
5010	return NULL;
5011	}
5012
5013	/*
5014	* On hash insertion, identify entries with the same inode but
5015	* distinct filehandles. They will all be on the list returned
5016	* by rhltable_lookup().
5017	*
5018	* inode->i_lock prevents racing insertions from adding an entry
5019	* for the same inode/fhp pair twice.
5020	*/
5021	static noinline_for_stack struct nfs4_file *
5022	nfsd4_file_hash_insert(struct nfs4_file *new, const struct svc_fh *fhp)
5023	{
5024	struct inode *inode = d_inode(dentry: fhp->fh_dentry);
5025	struct rhlist_head *tmp, *list;
5026	struct nfs4_file *ret = NULL;
5027	bool alias_found = false;
5028	struct nfs4_file *fi;
5029	int err;
5030
5031	rcu_read_lock();
5032	spin_lock(lock: &inode->i_lock);
5033
5034	list = rhltable_lookup(hlt: &nfs4_file_rhltable, key: &inode,
5035	params: nfs4_file_rhash_params);
5036	rhl_for_each_entry_rcu(fi, tmp, list, fi_rlist) {
5037	if (fh_match(fh1: &fi->fi_fhandle, fh2: &fhp->fh_handle)) {
5038	if (refcount_inc_not_zero(r: &fi->fi_ref))
5039	ret = fi;
5040	} else
5041	fi->fi_aliased = alias_found = true;
5042	}
5043	if (ret)
5044	goto out_unlock;
5045
5046	nfsd4_file_init(fh: fhp, fp: new);
5047	err = rhltable_insert(hlt: &nfs4_file_rhltable, list: &new->fi_rlist,
5048	params: nfs4_file_rhash_params);
5049	if (err)
5050	goto out_unlock;
5051
5052	new->fi_aliased = alias_found;
5053	ret = new;
5054
5055	out_unlock:
5056	spin_unlock(lock: &inode->i_lock);
5057	rcu_read_unlock();
5058	return ret;
5059	}
5060
5061	static noinline_for_stack void nfsd4_file_hash_remove(struct nfs4_file *fi)
5062	{
5063	rhltable_remove(hlt: &nfs4_file_rhltable, list: &fi->fi_rlist,
5064	params: nfs4_file_rhash_params);
5065	}
5066
5067	/*
5068	* Called to check deny when READ with all zero stateid or
5069	* WRITE with all zero or all one stateid
5070	*/
5071	static __be32
5072	nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
5073	{
5074	struct nfs4_file *fp;
5075	__be32 ret = nfs_ok;
5076
5077	fp = nfsd4_file_hash_lookup(fhp: current_fh);
5078	if (!fp)
5079	return ret;
5080
5081	/* Check for conflicting share reservations */
5082	spin_lock(lock: &fp->fi_lock);
5083	if (fp->fi_share_deny & deny_type)
5084	ret = nfserr_locked;
5085	spin_unlock(lock: &fp->fi_lock);
5086	put_nfs4_file(fi: fp);
5087	return ret;
5088	}
5089
5090	static bool nfsd4_deleg_present(const struct inode *inode)
5091	{
5092	struct file_lock_context *ctx = locks_inode_context(inode);
5093
5094	return ctx && !list_empty_careful(head: &ctx->flc_lease);
5095	}
5096
5097	/**
5098	* nfsd_wait_for_delegreturn - wait for delegations to be returned
5099	* @rqstp: the RPC transaction being executed
5100	* @inode: in-core inode of the file being waited for
5101	*
5102	* The timeout prevents deadlock if all nfsd threads happen to be
5103	* tied up waiting for returning delegations.
5104	*
5105	* Return values:
5106	* %true: delegation was returned
5107	* %false: timed out waiting for delegreturn
5108	*/
5109	bool nfsd_wait_for_delegreturn(struct svc_rqst *rqstp, struct inode *inode)
5110	{
5111	long __maybe_unused timeo;
5112
5113	timeo = wait_var_event_timeout(inode, !nfsd4_deleg_present(inode),
5114	NFSD_DELEGRETURN_TIMEOUT);
5115	trace_nfsd_delegret_wakeup(rqstp, inode, timeo);
5116	return timeo > 0;
5117	}
5118
5119	static void nfsd4_cb_recall_prepare(struct nfsd4_callback *cb)
5120	{
5121	struct nfs4_delegation *dp = cb_to_delegation(cb);
5122	struct nfsd_net *nn = net_generic(net: dp->dl_stid.sc_client->net,
5123	id: nfsd_net_id);
5124
5125	block_delegations(fh: &dp->dl_stid.sc_file->fi_fhandle);
5126
5127	/*
5128	* We can't do this in nfsd_break_deleg_cb because it is
5129	* already holding inode->i_lock.
5130	*
5131	* If the dl_time != 0, then we know that it has already been
5132	* queued for a lease break. Don't queue it again.
5133	*/
5134	spin_lock(lock: &state_lock);
5135	if (delegation_hashed(dp) && dp->dl_time == 0) {
5136	dp->dl_time = ktime_get_boottime_seconds();
5137	list_add_tail(new: &dp->dl_recall_lru, head: &nn->del_recall_lru);
5138	}
5139	spin_unlock(lock: &state_lock);
5140	}
5141
5142	static int nfsd4_cb_recall_done(struct nfsd4_callback *cb,
5143	struct rpc_task *task)
5144	{
5145	struct nfs4_delegation *dp = cb_to_delegation(cb);
5146
5147	trace_nfsd_cb_recall_done(stp: &dp->dl_stid.sc_stateid, task);
5148
5149	if (dp->dl_stid.sc_status)
5150	/* CLOSED or REVOKED */
5151	return 1;
5152
5153	switch (task->tk_status) {
5154	case 0:
5155	return 1;
5156	case -NFS4ERR_DELAY:
5157	rpc_delay(task, 2 * HZ);
5158	return 0;
5159	case -EBADHANDLE:
5160	case -NFS4ERR_BAD_STATEID:
5161	/*
5162	* Race: client probably got cb_recall before open reply
5163	* granting delegation.
5164	*/
5165	if (dp->dl_retries--) {
5166	rpc_delay(task, 2 * HZ);
5167	return 0;
5168	}
5169	fallthrough;
5170	default:
5171	return 1;
5172	}
5173	}
5174
5175	static void nfsd4_cb_recall_release(struct nfsd4_callback *cb)
5176	{
5177	struct nfs4_delegation *dp = cb_to_delegation(cb);
5178
5179	nfs4_put_stid(s: &dp->dl_stid);
5180	}
5181
5182	static const struct nfsd4_callback_ops nfsd4_cb_recall_ops = {
5183	.prepare = nfsd4_cb_recall_prepare,
5184	.done = nfsd4_cb_recall_done,
5185	.release = nfsd4_cb_recall_release,
5186	};
5187
5188	static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
5189	{
5190	/*
5191	* We're assuming the state code never drops its reference
5192	* without first removing the lease. Since we're in this lease
5193	* callback (and since the lease code is serialized by the
5194	* flc_lock) we know the server hasn't removed the lease yet, and
5195	* we know it's safe to take a reference.
5196	*/
5197	refcount_inc(r: &dp->dl_stid.sc_count);
5198	WARN_ON_ONCE(!nfsd4_run_cb(&dp->dl_recall));
5199	}
5200
5201	/* Called from break_lease() with flc_lock held. */
5202	static bool
5203	nfsd_break_deleg_cb(struct file_lease *fl)
5204	{
5205	struct nfs4_delegation *dp = (struct nfs4_delegation *) fl->c.flc_owner;
5206	struct nfs4_file *fp = dp->dl_stid.sc_file;
5207	struct nfs4_client *clp = dp->dl_stid.sc_client;
5208	struct nfsd_net *nn;
5209
5210	trace_nfsd_cb_recall(stid: &dp->dl_stid);
5211
5212	dp->dl_recalled = true;
5213	atomic_inc(v: &clp->cl_delegs_in_recall);
5214	if (try_to_expire_client(clp)) {
5215	nn = net_generic(net: clp->net, id: nfsd_net_id);
5216	mod_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: 0);
5217	}
5218
5219	/*
5220	* We don't want the locks code to timeout the lease for us;
5221	* we'll remove it ourself if a delegation isn't returned
5222	* in time:
5223	*/
5224	fl->fl_break_time = 0;
5225
5226	fp->fi_had_conflict = true;
5227	nfsd_break_one_deleg(dp);
5228	return false;
5229	}
5230
5231	/**
5232	* nfsd_breaker_owns_lease - Check if lease conflict was resolved
5233	* @fl: Lock state to check
5234	*
5235	* Return values:
5236	* %true: Lease conflict was resolved
5237	* %false: Lease conflict was not resolved.
5238	*/
5239	static bool nfsd_breaker_owns_lease(struct file_lease *fl)
5240	{
5241	struct nfs4_delegation *dl = fl->c.flc_owner;
5242	struct svc_rqst *rqst;
5243	struct nfs4_client *clp;
5244
5245	if (!i_am_nfsd())
5246	return false;
5247	rqst = kthread_data(current);
5248	/* Note rq_prog == NFS_ACL_PROGRAM is also possible: */
5249	if (rqst->rq_prog != NFS_PROGRAM || rqst->rq_vers < 4)
5250	return false;
5251	clp = *(rqst->rq_lease_breaker);
5252	return dl->dl_stid.sc_client == clp;
5253	}
5254
5255	static int
5256	nfsd_change_deleg_cb(struct file_lease *onlist, int arg,
5257	struct list_head *dispose)
5258	{
5259	struct nfs4_delegation *dp = (struct nfs4_delegation *) onlist->c.flc_owner;
5260	struct nfs4_client *clp = dp->dl_stid.sc_client;
5261
5262	if (arg & F_UNLCK) {
5263	if (dp->dl_recalled)
5264	atomic_dec(v: &clp->cl_delegs_in_recall);
5265	return lease_modify(onlist, arg, dispose);
5266	} else
5267	return -EAGAIN;
5268	}
5269
5270	static const struct lease_manager_operations nfsd_lease_mng_ops = {
5271	.lm_breaker_owns_lease = nfsd_breaker_owns_lease,
5272	.lm_break = nfsd_break_deleg_cb,
5273	.lm_change = nfsd_change_deleg_cb,
5274	};
5275
5276	static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
5277	{
5278	if (nfsd4_has_session(cs: cstate))
5279	return nfs_ok;
5280	if (seqid == so->so_seqid - 1)
5281	return nfserr_replay_me;
5282	if (seqid == so->so_seqid)
5283	return nfs_ok;
5284	return nfserr_bad_seqid;
5285	}
5286
5287	static struct nfs4_client *lookup_clientid(clientid_t *clid, bool sessions,
5288	struct nfsd_net *nn)
5289	{
5290	struct nfs4_client *found;
5291
5292	spin_lock(lock: &nn->client_lock);
5293	found = find_confirmed_client(clid, sessions, nn);
5294	if (found)
5295	atomic_inc(v: &found->cl_rpc_users);
5296	spin_unlock(lock: &nn->client_lock);
5297	return found;
5298	}
5299
5300	static __be32 set_client(clientid_t *clid,
5301	struct nfsd4_compound_state *cstate,
5302	struct nfsd_net *nn)
5303	{
5304	if (cstate->clp) {
5305	if (!same_clid(cl1: &cstate->clp->cl_clientid, cl2: clid))
5306	return nfserr_stale_clientid;
5307	return nfs_ok;
5308	}
5309	if (STALE_CLIENTID(clid, nn))
5310	return nfserr_stale_clientid;
5311	/*
5312	* We're in the 4.0 case (otherwise the SEQUENCE op would have
5313	* set cstate->clp), so session = false:
5314	*/
5315	cstate->clp = lookup_clientid(clid, sessions: false, nn);
5316	if (!cstate->clp)
5317	return nfserr_expired;
5318	return nfs_ok;
5319	}
5320
5321	__be32
5322	nfsd4_process_open1(struct nfsd4_compound_state *cstate,
5323	struct nfsd4_open *open, struct nfsd_net *nn)
5324	{
5325	clientid_t *clientid = &open->op_clientid;
5326	struct nfs4_client *clp = NULL;
5327	unsigned int strhashval;
5328	struct nfs4_openowner *oo = NULL;
5329	__be32 status;
5330
5331	/*
5332	* In case we need it later, after we've already created the
5333	* file and don't want to risk a further failure:
5334	*/
5335	open->op_file = nfsd4_alloc_file();
5336	if (open->op_file == NULL)
5337	return nfserr_jukebox;
5338
5339	status = set_client(clid: clientid, cstate, nn);
5340	if (status)
5341	return status;
5342	clp = cstate->clp;
5343
5344	strhashval = ownerstr_hashval(ownername: &open->op_owner);
5345	oo = find_openstateowner_str(hashval: strhashval, open, clp);
5346	open->op_openowner = oo;
5347	if (!oo) {
5348	goto new_owner;
5349	}
5350	if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
5351	/* Replace unconfirmed owners without checking for replay. */
5352	release_openowner(oo);
5353	open->op_openowner = NULL;
5354	goto new_owner;
5355	}
5356	status = nfsd4_check_seqid(cstate, so: &oo->oo_owner, seqid: open->op_seqid);
5357	if (status)
5358	return status;
5359	goto alloc_stateid;
5360	new_owner:
5361	oo = alloc_init_open_stateowner(strhashval, open, cstate);
5362	if (oo == NULL)
5363	return nfserr_jukebox;
5364	open->op_openowner = oo;
5365	alloc_stateid:
5366	open->op_stp = nfs4_alloc_open_stateid(clp);
5367	if (!open->op_stp)
5368	return nfserr_jukebox;
5369
5370	if (nfsd4_has_session(cs: cstate) &&
5371	(cstate->current_fh.fh_export->ex_flags & NFSEXP_PNFS)) {
5372	open->op_odstate = alloc_clnt_odstate(clp);
5373	if (!open->op_odstate)
5374	return nfserr_jukebox;
5375	}
5376
5377	return nfs_ok;
5378	}
5379
5380	static inline __be32
5381	nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
5382	{
5383	if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
5384	return nfserr_openmode;
5385	else
5386	return nfs_ok;
5387	}
5388
5389	static int share_access_to_flags(u32 share_access)
5390	{
5391	return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
5392	}
5393
5394	static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl,
5395	stateid_t *s)
5396	{
5397	struct nfs4_stid *ret;
5398
5399	ret = find_stateid_by_type(cl, t: s, SC_TYPE_DELEG, SC_STATUS_REVOKED);
5400	if (!ret)
5401	return NULL;
5402	return delegstateid(s: ret);
5403	}
5404
5405	static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
5406	{
5407	return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
5408	open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
5409	}
5410
5411	static __be32
5412	nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
5413	struct nfs4_delegation **dp)
5414	{
5415	int flags;
5416	__be32 status = nfserr_bad_stateid;
5417	struct nfs4_delegation *deleg;
5418
5419	deleg = find_deleg_stateid(cl, s: &open->op_delegate_stateid);
5420	if (deleg == NULL)
5421	goto out;
5422	if (deleg->dl_stid.sc_status & SC_STATUS_ADMIN_REVOKED) {
5423	nfs4_put_stid(s: &deleg->dl_stid);
5424	status = nfserr_admin_revoked;
5425	goto out;
5426	}
5427	if (deleg->dl_stid.sc_status & SC_STATUS_REVOKED) {
5428	nfs4_put_stid(s: &deleg->dl_stid);
5429	nfsd40_drop_revoked_stid(cl, stid: &open->op_delegate_stateid);
5430	status = nfserr_deleg_revoked;
5431	goto out;
5432	}
5433	flags = share_access_to_flags(share_access: open->op_share_access);
5434	status = nfs4_check_delegmode(dp: deleg, flags);
5435	if (status) {
5436	nfs4_put_stid(s: &deleg->dl_stid);
5437	goto out;
5438	}
5439	*dp = deleg;
5440	out:
5441	if (!nfsd4_is_deleg_cur(open))
5442	return nfs_ok;
5443	if (status)
5444	return status;
5445	open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
5446	return nfs_ok;
5447	}
5448
5449	static inline int nfs4_access_to_access(u32 nfs4_access)
5450	{
5451	int flags = 0;
5452
5453	if (nfs4_access & NFS4_SHARE_ACCESS_READ)
5454	flags |= NFSD_MAY_READ;
5455	if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
5456	flags |= NFSD_MAY_WRITE;
5457	return flags;
5458	}
5459
5460	static inline __be32
5461	nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
5462	struct nfsd4_open *open)
5463	{
5464	struct iattr iattr = {
5465	.ia_valid = ATTR_SIZE,
5466	.ia_size = 0,
5467	};
5468	struct nfsd_attrs attrs = {
5469	.na_iattr = &iattr,
5470	};
5471	if (!open->op_truncate)
5472	return 0;
5473	if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
5474	return nfserr_inval;
5475	return nfsd_setattr(rqstp, fh, &attrs, NULL);
5476	}
5477
5478	static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
5479	struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp,
5480	struct nfsd4_open *open, bool new_stp)
5481	{
5482	struct nfsd_file *nf = NULL;
5483	__be32 status;
5484	int oflag = nfs4_access_to_omode(access: open->op_share_access);
5485	int access = nfs4_access_to_access(nfs4_access: open->op_share_access);
5486	unsigned char old_access_bmap, old_deny_bmap;
5487
5488	spin_lock(lock: &fp->fi_lock);
5489
5490	/*
5491	* Are we trying to set a deny mode that would conflict with
5492	* current access?
5493	*/
5494	status = nfs4_file_check_deny(fp, deny: open->op_share_deny);
5495	if (status != nfs_ok) {
5496	if (status != nfserr_share_denied) {
5497	spin_unlock(lock: &fp->fi_lock);
5498	goto out;
5499	}
5500	if (nfs4_resolve_deny_conflicts_locked(fp, new_stp,
5501	stp, access: open->op_share_deny, share_access: false))
5502	status = nfserr_jukebox;
5503	spin_unlock(lock: &fp->fi_lock);
5504	goto out;
5505	}
5506
5507	/* set access to the file */
5508	status = nfs4_file_get_access(fp, access: open->op_share_access);
5509	if (status != nfs_ok) {
5510	if (status != nfserr_share_denied) {
5511	spin_unlock(lock: &fp->fi_lock);
5512	goto out;
5513	}
5514	if (nfs4_resolve_deny_conflicts_locked(fp, new_stp,
5515	stp, access: open->op_share_access, share_access: true))
5516	status = nfserr_jukebox;
5517	spin_unlock(lock: &fp->fi_lock);
5518	goto out;
5519	}
5520
5521	/* Set access bits in stateid */
5522	old_access_bmap = stp->st_access_bmap;
5523	set_access(access: open->op_share_access, stp);
5524
5525	/* Set new deny mask */
5526	old_deny_bmap = stp->st_deny_bmap;
5527	set_deny(deny: open->op_share_deny, stp);
5528	fp->fi_share_deny |= (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
5529
5530	if (!fp->fi_fds[oflag]) {
5531	spin_unlock(lock: &fp->fi_lock);
5532
5533	status = nfsd_file_acquire_opened(rqstp, fhp: cur_fh, may_flags: access,
5534	file: open->op_filp, nfp: &nf);
5535	if (status != nfs_ok)
5536	goto out_put_access;
5537
5538	spin_lock(lock: &fp->fi_lock);
5539	if (!fp->fi_fds[oflag]) {
5540	fp->fi_fds[oflag] = nf;
5541	nf = NULL;
5542	}
5543	}
5544	spin_unlock(lock: &fp->fi_lock);
5545	if (nf)
5546	nfsd_file_put(nf);
5547
5548	status = nfserrno(errno: nfsd_open_break_lease(cur_fh->fh_dentry->d_inode,
5549	access));
5550	if (status)
5551	goto out_put_access;
5552
5553	status = nfsd4_truncate(rqstp, fh: cur_fh, open);
5554	if (status)
5555	goto out_put_access;
5556	out:
5557	return status;
5558	out_put_access:
5559	stp->st_access_bmap = old_access_bmap;
5560	nfs4_file_put_access(fp, access: open->op_share_access);
5561	reset_union_bmap_deny(deny: bmap_to_share_mode(bmap: old_deny_bmap), stp);
5562	goto out;
5563	}
5564
5565	static __be32
5566	nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp,
5567	struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp,
5568	struct nfsd4_open *open)
5569	{
5570	__be32 status;
5571	unsigned char old_deny_bmap = stp->st_deny_bmap;
5572
5573	if (!test_access(access: open->op_share_access, stp))
5574	return nfs4_get_vfs_file(rqstp, fp, cur_fh, stp, open, new_stp: false);
5575
5576	/* test and set deny mode */
5577	spin_lock(lock: &fp->fi_lock);
5578	status = nfs4_file_check_deny(fp, deny: open->op_share_deny);
5579	switch (status) {
5580	case nfs_ok:
5581	set_deny(deny: open->op_share_deny, stp);
5582	fp->fi_share_deny |=
5583	(open->op_share_deny & NFS4_SHARE_DENY_BOTH);
5584	break;
5585	case nfserr_share_denied:
5586	if (nfs4_resolve_deny_conflicts_locked(fp, new_stp: false,
5587	stp, access: open->op_share_deny, share_access: false))
5588	status = nfserr_jukebox;
5589	break;
5590	}
5591	spin_unlock(lock: &fp->fi_lock);
5592
5593	if (status != nfs_ok)
5594	return status;
5595
5596	status = nfsd4_truncate(rqstp, fh: cur_fh, open);
5597	if (status != nfs_ok)
5598	reset_union_bmap_deny(deny: old_deny_bmap, stp);
5599	return status;
5600	}
5601
5602	/* Should we give out recallable state?: */
5603	static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
5604	{
5605	if (clp->cl_cb_state == NFSD4_CB_UP)
5606	return true;
5607	/*
5608	* In the sessions case, since we don't have to establish a
5609	* separate connection for callbacks, we assume it's OK
5610	* until we hear otherwise:
5611	*/
5612	return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
5613	}
5614
5615	static struct file_lease *nfs4_alloc_init_lease(struct nfs4_delegation *dp,
5616	int flag)
5617	{
5618	struct file_lease *fl;
5619
5620	fl = locks_alloc_lease();
5621	if (!fl)
5622	return NULL;
5623	fl->fl_lmops = &nfsd_lease_mng_ops;
5624	fl->c.flc_flags = FL_DELEG;
5625	fl->c.flc_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
5626	fl->c.flc_owner = (fl_owner_t)dp;
5627	fl->c.flc_pid = current->tgid;
5628	fl->c.flc_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file;
5629	return fl;
5630	}
5631
5632	static int nfsd4_check_conflicting_opens(struct nfs4_client *clp,
5633	struct nfs4_file *fp)
5634	{
5635	struct nfs4_ol_stateid *st;
5636	struct file *f = fp->fi_deleg_file->nf_file;
5637	struct inode *ino = file_inode(f);
5638	int writes;
5639
5640	writes = atomic_read(v: &ino->i_writecount);
5641	if (!writes)
5642	return 0;
5643	/*
5644	* There could be multiple filehandles (hence multiple
5645	* nfs4_files) referencing this file, but that's not too
5646	* common; let's just give up in that case rather than
5647	* trying to go look up all the clients using that other
5648	* nfs4_file as well:
5649	*/
5650	if (fp->fi_aliased)
5651	return -EAGAIN;
5652	/*
5653	* If there's a close in progress, make sure that we see it
5654	* clear any fi_fds[] entries before we see it decrement
5655	* i_writecount:
5656	*/
5657	smp_mb__after_atomic();
5658
5659	if (fp->fi_fds[O_WRONLY])
5660	writes--;
5661	if (fp->fi_fds[O_RDWR])
5662	writes--;
5663	if (writes > 0)
5664	return -EAGAIN; /* There may be non-NFSv4 writers */
5665	/*
5666	* It's possible there are non-NFSv4 write opens in progress,
5667	* but if they haven't incremented i_writecount yet then they
5668	* also haven't called break lease yet; so, they'll break this
5669	* lease soon enough. So, all that's left to check for is NFSv4
5670	* opens:
5671	*/
5672	spin_lock(lock: &fp->fi_lock);
5673	list_for_each_entry(st, &fp->fi_stateids, st_perfile) {
5674	if (st->st_openstp == NULL /* it's an open */ &&
5675	access_permit_write(stp: st) &&
5676	st->st_stid.sc_client != clp) {
5677	spin_unlock(lock: &fp->fi_lock);
5678	return -EAGAIN;
5679	}
5680	}
5681	spin_unlock(lock: &fp->fi_lock);
5682	/*
5683	* There's a small chance that we could be racing with another
5684	* NFSv4 open. However, any open that hasn't added itself to
5685	* the fi_stateids list also hasn't called break_lease yet; so,
5686	* they'll break this lease soon enough.
5687	*/
5688	return 0;
5689	}
5690
5691	/*
5692	* It's possible that between opening the dentry and setting the delegation,
5693	* that it has been renamed or unlinked. Redo the lookup to verify that this
5694	* hasn't happened.
5695	*/
5696	static int
5697	nfsd4_verify_deleg_dentry(struct nfsd4_open *open, struct nfs4_file *fp,
5698	struct svc_fh *parent)
5699	{
5700	struct svc_export *exp;
5701	struct dentry *child;
5702	__be32 err;
5703
5704	err = nfsd_lookup_dentry(open->op_rqstp, parent,
5705	open->op_fname, open->op_fnamelen,
5706	&exp, &child);
5707
5708	if (err)
5709	return -EAGAIN;
5710
5711	exp_put(exp);
5712	dput(child);
5713	if (child != file_dentry(file: fp->fi_deleg_file->nf_file))
5714	return -EAGAIN;
5715
5716	return 0;
5717	}
5718
5719	/*
5720	* We avoid breaking delegations held by a client due to its own activity, but
5721	* clearing setuid/setgid bits on a write is an implicit activity and the client
5722	* may not notice and continue using the old mode. Avoid giving out a delegation
5723	* on setuid/setgid files when the client is requesting an open for write.
5724	*/
5725	static int
5726	nfsd4_verify_setuid_write(struct nfsd4_open *open, struct nfsd_file *nf)
5727	{
5728	struct inode *inode = file_inode(f: nf->nf_file);
5729
5730	if ((open->op_share_access & NFS4_SHARE_ACCESS_WRITE) &&
5731	(inode->i_mode & (S_ISUID|S_ISGID)))
5732	return -EAGAIN;
5733	return 0;
5734	}
5735
5736	static struct nfs4_delegation *
5737	nfs4_set_delegation(struct nfsd4_open *open, struct nfs4_ol_stateid *stp,
5738	struct svc_fh *parent)
5739	{
5740	int status = 0;
5741	struct nfs4_client *clp = stp->st_stid.sc_client;
5742	struct nfs4_file *fp = stp->st_stid.sc_file;
5743	struct nfs4_clnt_odstate *odstate = stp->st_clnt_odstate;
5744	struct nfs4_delegation *dp;
5745	struct nfsd_file *nf = NULL;
5746	struct file_lease *fl;
5747	u32 dl_type;
5748
5749	/*
5750	* The fi_had_conflict and nfs_get_existing_delegation checks
5751	* here are just optimizations; we'll need to recheck them at
5752	* the end:
5753	*/
5754	if (fp->fi_had_conflict)
5755	return ERR_PTR(error: -EAGAIN);
5756
5757	/*
5758	* Try for a write delegation first. RFC8881 section 10.4 says:
5759	*
5760	* "An OPEN_DELEGATE_WRITE delegation allows the client to handle,
5761	* on its own, all opens."
5762	*
5763	* Furthermore the client can use a write delegation for most READ
5764	* operations as well, so we require a O_RDWR file here.
5765	*
5766	* Offer a write delegation in the case of a BOTH open, and ensure
5767	* we get the O_RDWR descriptor.
5768	*/
5769	if ((open->op_share_access & NFS4_SHARE_ACCESS_BOTH) == NFS4_SHARE_ACCESS_BOTH) {
5770	nf = find_rw_file(f: fp);
5771	dl_type = NFS4_OPEN_DELEGATE_WRITE;
5772	}
5773
5774	/*
5775	* If the file is being opened O_RDONLY or we couldn't get a O_RDWR
5776	* file for some reason, then try for a read delegation instead.
5777	*/
5778	if (!nf && (open->op_share_access & NFS4_SHARE_ACCESS_READ)) {
5779	nf = find_readable_file(f: fp);
5780	dl_type = NFS4_OPEN_DELEGATE_READ;
5781	}
5782
5783	if (!nf)
5784	return ERR_PTR(error: -EAGAIN);
5785
5786	spin_lock(lock: &state_lock);
5787	spin_lock(lock: &fp->fi_lock);
5788	if (nfs4_delegation_exists(clp, fp))
5789	status = -EAGAIN;
5790	else if (nfsd4_verify_setuid_write(open, nf))
5791	status = -EAGAIN;
5792	else if (!fp->fi_deleg_file) {
5793	fp->fi_deleg_file = nf;
5794	/* increment early to prevent fi_deleg_file from being
5795	* cleared */
5796	fp->fi_delegees = 1;
5797	nf = NULL;
5798	} else
5799	fp->fi_delegees++;
5800	spin_unlock(lock: &fp->fi_lock);
5801	spin_unlock(lock: &state_lock);
5802	if (nf)
5803	nfsd_file_put(nf);
5804	if (status)
5805	return ERR_PTR(error: status);
5806
5807	status = -ENOMEM;
5808	dp = alloc_init_deleg(clp, fp, odstate, dl_type);
5809	if (!dp)
5810	goto out_delegees;
5811
5812	fl = nfs4_alloc_init_lease(dp, flag: dl_type);
5813	if (!fl)
5814	goto out_clnt_odstate;
5815
5816	status = kernel_setlease(fp->fi_deleg_file->nf_file,
5817	fl->c.flc_type, &fl, NULL);
5818	if (fl)
5819	locks_free_lease(fl);
5820	if (status)
5821	goto out_clnt_odstate;
5822
5823	if (parent) {
5824	status = nfsd4_verify_deleg_dentry(open, fp, parent);
5825	if (status)
5826	goto out_unlock;
5827	}
5828
5829	status = nfsd4_check_conflicting_opens(clp, fp);
5830	if (status)
5831	goto out_unlock;
5832
5833	/*
5834	* Now that the deleg is set, check again to ensure that nothing
5835	* raced in and changed the mode while we weren't lookng.
5836	*/
5837	status = nfsd4_verify_setuid_write(open, nf: fp->fi_deleg_file);
5838	if (status)
5839	goto out_unlock;
5840
5841	status = -EAGAIN;
5842	if (fp->fi_had_conflict)
5843	goto out_unlock;
5844
5845	spin_lock(lock: &state_lock);
5846	spin_lock(lock: &clp->cl_lock);
5847	spin_lock(lock: &fp->fi_lock);
5848	status = hash_delegation_locked(dp, fp);
5849	spin_unlock(lock: &fp->fi_lock);
5850	spin_unlock(lock: &clp->cl_lock);
5851	spin_unlock(lock: &state_lock);
5852
5853	if (status)
5854	goto out_unlock;
5855
5856	return dp;
5857	out_unlock:
5858	kernel_setlease(fp->fi_deleg_file->nf_file, F_UNLCK, NULL, (void **)&dp);
5859	out_clnt_odstate:
5860	put_clnt_odstate(co: dp->dl_clnt_odstate);
5861	nfs4_put_stid(s: &dp->dl_stid);
5862	out_delegees:
5863	put_deleg_file(fp);
5864	return ERR_PTR(error: status);
5865	}
5866
5867	static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
5868	{
5869	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
5870	if (status == -EAGAIN)
5871	open->op_why_no_deleg = WND4_CONTENTION;
5872	else {
5873	open->op_why_no_deleg = WND4_RESOURCE;
5874	switch (open->op_deleg_want) {
5875	case NFS4_SHARE_WANT_READ_DELEG:
5876	case NFS4_SHARE_WANT_WRITE_DELEG:
5877	case NFS4_SHARE_WANT_ANY_DELEG:
5878	break;
5879	case NFS4_SHARE_WANT_CANCEL:
5880	open->op_why_no_deleg = WND4_CANCELLED;
5881	break;
5882	case NFS4_SHARE_WANT_NO_DELEG:
5883	WARN_ON_ONCE(1);
5884	}
5885	}
5886	}
5887
5888	/*
5889	* The Linux NFS server does not offer write delegations to NFSv4.0
5890	* clients in order to avoid conflicts between write delegations and
5891	* GETATTRs requesting CHANGE or SIZE attributes.
5892	*
5893	* With NFSv4.1 and later minorversions, the SEQUENCE operation that
5894	* begins each COMPOUND contains a client ID. Delegation recall can
5895	* be avoided when the server recognizes the client sending a
5896	* GETATTR also holds write delegation it conflicts with.
5897	*
5898	* However, the NFSv4.0 protocol does not enable a server to
5899	* determine that a GETATTR originated from the client holding the
5900	* conflicting delegation versus coming from some other client. Per
5901	* RFC 7530 Section 16.7.5, the server must recall or send a
5902	* CB_GETATTR even when the GETATTR originates from the client that
5903	* holds the conflicting delegation.
5904	*
5905	* An NFSv4.0 client can trigger a pathological situation if it
5906	* always sends a DELEGRETURN preceded by a conflicting GETATTR in
5907	* the same COMPOUND. COMPOUND execution will always stop at the
5908	* GETATTR and the DELEGRETURN will never get executed. The server
5909	* eventually revokes the delegation, which can result in loss of
5910	* open or lock state.
5911	*/
5912	static void
5913	nfs4_open_delegation(struct nfsd4_open *open, struct nfs4_ol_stateid *stp,
5914	struct svc_fh *currentfh)
5915	{
5916	struct nfs4_delegation *dp;
5917	struct nfs4_openowner *oo = openowner(so: stp->st_stateowner);
5918	struct nfs4_client *clp = stp->st_stid.sc_client;
5919	struct svc_fh *parent = NULL;
5920	int cb_up;
5921	int status = 0;
5922	struct kstat stat;
5923	struct path path;
5924
5925	cb_up = nfsd4_cb_channel_good(clp: oo->oo_owner.so_client);
5926	open->op_recall = false;
5927	switch (open->op_claim_type) {
5928	case NFS4_OPEN_CLAIM_PREVIOUS:
5929	if (!cb_up)
5930	open->op_recall = true;
5931	break;
5932	case NFS4_OPEN_CLAIM_NULL:
5933	parent = currentfh;
5934	fallthrough;
5935	case NFS4_OPEN_CLAIM_FH:
5936	/*
5937	* Let's not give out any delegations till everyone's
5938	* had the chance to reclaim theirs, *and* until
5939	* NLM locks have all been reclaimed:
5940	*/
5941	if (locks_in_grace(clp->net))
5942	goto out_no_deleg;
5943	if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
5944	goto out_no_deleg;
5945	if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE &&
5946	!clp->cl_minorversion)
5947	goto out_no_deleg;
5948	break;
5949	default:
5950	goto out_no_deleg;
5951	}
5952	dp = nfs4_set_delegation(open, stp, parent);
5953	if (IS_ERR(ptr: dp))
5954	goto out_no_deleg;
5955
5956	memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
5957
5958	if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE) {
5959	open->op_delegate_type = NFS4_OPEN_DELEGATE_WRITE;
5960	trace_nfsd_deleg_write(stp: &dp->dl_stid.sc_stateid);
5961	path.mnt = currentfh->fh_export->ex_path.mnt;
5962	path.dentry = currentfh->fh_dentry;
5963	if (vfs_getattr(&path, &stat,
5964	(STATX_SIZE | STATX_CTIME | STATX_CHANGE_COOKIE),
5965	AT_STATX_SYNC_AS_STAT)) {
5966	nfs4_put_stid(s: &dp->dl_stid);
5967	destroy_delegation(dp);
5968	goto out_no_deleg;
5969	}
5970	dp->dl_cb_fattr.ncf_cur_fsize = stat.size;
5971	dp->dl_cb_fattr.ncf_initial_cinfo =
5972	nfsd4_change_attribute(stat: &stat, inode: d_inode(dentry: currentfh->fh_dentry));
5973	} else {
5974	open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
5975	trace_nfsd_deleg_read(stp: &dp->dl_stid.sc_stateid);
5976	}
5977	nfs4_put_stid(s: &dp->dl_stid);
5978	return;
5979	out_no_deleg:
5980	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
5981	if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
5982	open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
5983	dprintk("NFSD: WARNING: refusing delegation reclaim\n");
5984	open->op_recall = true;
5985	}
5986
5987	/* 4.1 client asking for a delegation? */
5988	if (open->op_deleg_want)
5989	nfsd4_open_deleg_none_ext(open, status);
5990	return;
5991	}
5992
5993	static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
5994	struct nfs4_delegation *dp)
5995	{
5996	if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
5997	dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
5998	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
5999	open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
6000	} else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
6001	dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
6002	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
6003	open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
6004	}
6005	/* Otherwise the client must be confused wanting a delegation
6006	* it already has, therefore we don't return
6007	* NFS4_OPEN_DELEGATE_NONE_EXT and reason.
6008	*/
6009	}
6010
6011	/**
6012	* nfsd4_process_open2 - finish open processing
6013	* @rqstp: the RPC transaction being executed
6014	* @current_fh: NFSv4 COMPOUND's current filehandle
6015	* @open: OPEN arguments
6016	*
6017	* If successful, (1) truncate the file if open->op_truncate was
6018	* set, (2) set open->op_stateid, (3) set open->op_delegation.
6019	*
6020	* Returns %nfs_ok on success; otherwise an nfs4stat value in
6021	* network byte order is returned.
6022	*/
6023	__be32
6024	nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
6025	{
6026	struct nfsd4_compoundres *resp = rqstp->rq_resp;
6027	struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
6028	struct nfs4_file *fp = NULL;
6029	struct nfs4_ol_stateid *stp = NULL;
6030	struct nfs4_delegation *dp = NULL;
6031	__be32 status;
6032	bool new_stp = false;
6033
6034	/*
6035	* Lookup file; if found, lookup stateid and check open request,
6036	* and check for delegations in the process of being recalled.
6037	* If not found, create the nfs4_file struct
6038	*/
6039	fp = nfsd4_file_hash_insert(new: open->op_file, fhp: current_fh);
6040	if (unlikely(!fp))
6041	return nfserr_jukebox;
6042	if (fp != open->op_file) {
6043	status = nfs4_check_deleg(cl, open, dp: &dp);
6044	if (status)
6045	goto out;
6046	stp = nfsd4_find_and_lock_existing_open(fp, open);
6047	} else {
6048	open->op_file = NULL;
6049	status = nfserr_bad_stateid;
6050	if (nfsd4_is_deleg_cur(open))
6051	goto out;
6052	}
6053
6054	if (!stp) {
6055	stp = init_open_stateid(fp, open);
6056	if (!open->op_stp)
6057	new_stp = true;
6058	}
6059
6060	/*
6061	* OPEN the file, or upgrade an existing OPEN.
6062	* If truncate fails, the OPEN fails.
6063	*
6064	* stp is already locked.
6065	*/
6066	if (!new_stp) {
6067	/* Stateid was found, this is an OPEN upgrade */
6068	status = nfs4_upgrade_open(rqstp, fp, cur_fh: current_fh, stp, open);
6069	if (status) {
6070	mutex_unlock(lock: &stp->st_mutex);
6071	goto out;
6072	}
6073	} else {
6074	status = nfs4_get_vfs_file(rqstp, fp, cur_fh: current_fh, stp, open, new_stp: true);
6075	if (status) {
6076	release_open_stateid(stp);
6077	mutex_unlock(lock: &stp->st_mutex);
6078	goto out;
6079	}
6080
6081	stp->st_clnt_odstate = find_or_hash_clnt_odstate(fp,
6082	new: open->op_odstate);
6083	if (stp->st_clnt_odstate == open->op_odstate)
6084	open->op_odstate = NULL;
6085	}
6086
6087	nfs4_inc_and_copy_stateid(dst: &open->op_stateid, stid: &stp->st_stid);
6088	mutex_unlock(lock: &stp->st_mutex);
6089
6090	if (nfsd4_has_session(cs: &resp->cstate)) {
6091	if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
6092	open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
6093	open->op_why_no_deleg = WND4_NOT_WANTED;
6094	goto nodeleg;
6095	}
6096	}
6097
6098	/*
6099	* Attempt to hand out a delegation. No error return, because the
6100	* OPEN succeeds even if we fail.
6101	*/
6102	nfs4_open_delegation(open, stp, currentfh: &resp->cstate.current_fh);
6103	nodeleg:
6104	status = nfs_ok;
6105	trace_nfsd_open(stp: &stp->st_stid.sc_stateid);
6106	out:
6107	/* 4.1 client trying to upgrade/downgrade delegation? */
6108	if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
6109	open->op_deleg_want)
6110	nfsd4_deleg_xgrade_none_ext(open, dp);
6111
6112	if (fp)
6113	put_nfs4_file(fi: fp);
6114	if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
6115	open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
6116	/*
6117	* To finish the open response, we just need to set the rflags.
6118	*/
6119	open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
6120	if (nfsd4_has_session(cs: &resp->cstate))
6121	open->op_rflags |= NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK;
6122	else if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED))
6123	open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
6124
6125	if (dp)
6126	nfs4_put_stid(s: &dp->dl_stid);
6127	if (stp)
6128	nfs4_put_stid(s: &stp->st_stid);
6129
6130	return status;
6131	}
6132
6133	void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
6134	struct nfsd4_open *open)
6135	{
6136	if (open->op_openowner) {
6137	struct nfs4_stateowner *so = &open->op_openowner->oo_owner;
6138
6139	nfsd4_cstate_assign_replay(cstate, so);
6140	nfs4_put_stateowner(sop: so);
6141	}
6142	if (open->op_file)
6143	kmem_cache_free(s: file_slab, objp: open->op_file);
6144	if (open->op_stp)
6145	nfs4_put_stid(s: &open->op_stp->st_stid);
6146	if (open->op_odstate)
6147	kmem_cache_free(s: odstate_slab, objp: open->op_odstate);
6148	}
6149
6150	__be32
6151	nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6152	union nfsd4_op_u *u)
6153	{
6154	clientid_t *clid = &u->renew;
6155	struct nfs4_client *clp;
6156	__be32 status;
6157	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
6158
6159	trace_nfsd_clid_renew(clid);
6160	status = set_client(clid, cstate, nn);
6161	if (status)
6162	return status;
6163	clp = cstate->clp;
6164	if (!list_empty(head: &clp->cl_delegations)
6165	&& clp->cl_cb_state != NFSD4_CB_UP)
6166	return nfserr_cb_path_down;
6167	return nfs_ok;
6168	}
6169
6170	void
6171	nfsd4_end_grace(struct nfsd_net *nn)
6172	{
6173	/* do nothing if grace period already ended */
6174	if (nn->grace_ended)
6175	return;
6176
6177	trace_nfsd_grace_complete(nn);
6178	nn->grace_ended = true;
6179	/*
6180	* If the server goes down again right now, an NFSv4
6181	* client will still be allowed to reclaim after it comes back up,
6182	* even if it hasn't yet had a chance to reclaim state this time.
6183	*
6184	*/
6185	nfsd4_record_grace_done(nn);
6186	/*
6187	* At this point, NFSv4 clients can still reclaim. But if the
6188	* server crashes, any that have not yet reclaimed will be out
6189	* of luck on the next boot.
6190	*
6191	* (NFSv4.1+ clients are considered to have reclaimed once they
6192	* call RECLAIM_COMPLETE. NFSv4.0 clients are considered to
6193	* have reclaimed after their first OPEN.)
6194	*/
6195	locks_end_grace(&nn->nfsd4_manager);
6196	/*
6197	* At this point, and once lockd and/or any other containers
6198	* exit their grace period, further reclaims will fail and
6199	* regular locking can resume.
6200	*/
6201	}
6202
6203	/*
6204	* If we've waited a lease period but there are still clients trying to
6205	* reclaim, wait a little longer to give them a chance to finish.
6206	*/
6207	static bool clients_still_reclaiming(struct nfsd_net *nn)
6208	{
6209	time64_t double_grace_period_end = nn->boot_time +
6210	2 * nn->nfsd4_lease;
6211
6212	if (nn->track_reclaim_completes &&
6213	atomic_read(v: &nn->nr_reclaim_complete) ==
6214	nn->reclaim_str_hashtbl_size)
6215	return false;
6216	if (!nn->somebody_reclaimed)
6217	return false;
6218	nn->somebody_reclaimed = false;
6219	/*
6220	* If we've given them *two* lease times to reclaim, and they're
6221	* still not done, give up:
6222	*/
6223	if (ktime_get_boottime_seconds() > double_grace_period_end)
6224	return false;
6225	return true;
6226	}
6227
6228	struct laundry_time {
6229	time64_t cutoff;
6230	time64_t new_timeo;
6231	};
6232
6233	static bool state_expired(struct laundry_time *lt, time64_t last_refresh)
6234	{
6235	time64_t time_remaining;
6236
6237	if (last_refresh < lt->cutoff)
6238	return true;
6239	time_remaining = last_refresh - lt->cutoff;
6240	lt->new_timeo = min(lt->new_timeo, time_remaining);
6241	return false;
6242	}
6243
6244	#ifdef CONFIG_NFSD_V4_2_INTER_SSC
6245	void nfsd4_ssc_init_umount_work(struct nfsd_net *nn)
6246	{
6247	spin_lock_init(&nn->nfsd_ssc_lock);
6248	INIT_LIST_HEAD(list: &nn->nfsd_ssc_mount_list);
6249	init_waitqueue_head(&nn->nfsd_ssc_waitq);
6250	}
6251	EXPORT_SYMBOL_GPL(nfsd4_ssc_init_umount_work);
6252
6253	/*
6254	* This is called when nfsd is being shutdown, after all inter_ssc
6255	* cleanup were done, to destroy the ssc delayed unmount list.
6256	*/
6257	static void nfsd4_ssc_shutdown_umount(struct nfsd_net *nn)
6258	{
6259	struct nfsd4_ssc_umount_item *ni = NULL;
6260	struct nfsd4_ssc_umount_item *tmp;
6261
6262	spin_lock(lock: &nn->nfsd_ssc_lock);
6263	list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
6264	list_del(entry: &ni->nsui_list);
6265	spin_unlock(lock: &nn->nfsd_ssc_lock);
6266	mntput(mnt: ni->nsui_vfsmount);
6267	kfree(objp: ni);
6268	spin_lock(lock: &nn->nfsd_ssc_lock);
6269	}
6270	spin_unlock(lock: &nn->nfsd_ssc_lock);
6271	}
6272
6273	static void nfsd4_ssc_expire_umount(struct nfsd_net *nn)
6274	{
6275	bool do_wakeup = false;
6276	struct nfsd4_ssc_umount_item *ni = NULL;
6277	struct nfsd4_ssc_umount_item *tmp;
6278
6279	spin_lock(lock: &nn->nfsd_ssc_lock);
6280	list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
6281	if (time_after(jiffies, ni->nsui_expire)) {
6282	if (refcount_read(r: &ni->nsui_refcnt) > 1)
6283	continue;
6284
6285	/* mark being unmount */
6286	ni->nsui_busy = true;
6287	spin_unlock(lock: &nn->nfsd_ssc_lock);
6288	mntput(mnt: ni->nsui_vfsmount);
6289	spin_lock(lock: &nn->nfsd_ssc_lock);
6290
6291	/* waiters need to start from begin of list */
6292	list_del(entry: &ni->nsui_list);
6293	kfree(objp: ni);
6294
6295	/* wakeup ssc_connect waiters */
6296	do_wakeup = true;
6297	continue;
6298	}
6299	break;
6300	}
6301	if (do_wakeup)
6302	wake_up_all(&nn->nfsd_ssc_waitq);
6303	spin_unlock(lock: &nn->nfsd_ssc_lock);
6304	}
6305	#endif
6306
6307	/* Check if any lock belonging to this lockowner has any blockers */
6308	static bool
6309	nfs4_lockowner_has_blockers(struct nfs4_lockowner *lo)
6310	{
6311	struct file_lock_context *ctx;
6312	struct nfs4_ol_stateid *stp;
6313	struct nfs4_file *nf;
6314
6315	list_for_each_entry(stp, &lo->lo_owner.so_stateids, st_perstateowner) {
6316	nf = stp->st_stid.sc_file;
6317	ctx = locks_inode_context(inode: nf->fi_inode);
6318	if (!ctx)
6319	continue;
6320	if (locks_owner_has_blockers(flctx: ctx, owner: lo))
6321	return true;
6322	}
6323	return false;
6324	}
6325
6326	static bool
6327	nfs4_anylock_blockers(struct nfs4_client *clp)
6328	{
6329	int i;
6330	struct nfs4_stateowner *so;
6331	struct nfs4_lockowner *lo;
6332
6333	if (atomic_read(v: &clp->cl_delegs_in_recall))
6334	return true;
6335	spin_lock(lock: &clp->cl_lock);
6336	for (i = 0; i < OWNER_HASH_SIZE; i++) {
6337	list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[i],
6338	so_strhash) {
6339	if (so->so_is_open_owner)
6340	continue;
6341	lo = lockowner(so);
6342	if (nfs4_lockowner_has_blockers(lo)) {
6343	spin_unlock(lock: &clp->cl_lock);
6344	return true;
6345	}
6346	}
6347	}
6348	spin_unlock(lock: &clp->cl_lock);
6349	return false;
6350	}
6351
6352	static void
6353	nfs4_get_client_reaplist(struct nfsd_net *nn, struct list_head *reaplist,
6354	struct laundry_time *lt)
6355	{
6356	unsigned int maxreap, reapcnt = 0;
6357	struct list_head *pos, *next;
6358	struct nfs4_client *clp;
6359
6360	maxreap = (atomic_read(v: &nn->nfs4_client_count) >= nn->nfs4_max_clients) ?
6361	NFSD_CLIENT_MAX_TRIM_PER_RUN : 0;
6362	INIT_LIST_HEAD(list: reaplist);
6363	spin_lock(lock: &nn->client_lock);
6364	list_for_each_safe(pos, next, &nn->client_lru) {
6365	clp = list_entry(pos, struct nfs4_client, cl_lru);
6366	if (clp->cl_state == NFSD4_EXPIRABLE)
6367	goto exp_client;
6368	if (!state_expired(lt, last_refresh: clp->cl_time))
6369	break;
6370	if (!atomic_read(v: &clp->cl_rpc_users)) {
6371	if (clp->cl_state == NFSD4_ACTIVE)
6372	atomic_inc(v: &nn->nfsd_courtesy_clients);
6373	clp->cl_state = NFSD4_COURTESY;
6374	}
6375	if (!client_has_state(clp))
6376	goto exp_client;
6377	if (!nfs4_anylock_blockers(clp))
6378	if (reapcnt >= maxreap)
6379	continue;
6380	exp_client:
6381	if (!mark_client_expired_locked(clp)) {
6382	list_add(new: &clp->cl_lru, head: reaplist);
6383	reapcnt++;
6384	}
6385	}
6386	spin_unlock(lock: &nn->client_lock);
6387	}
6388
6389	static void
6390	nfs4_get_courtesy_client_reaplist(struct nfsd_net *nn,
6391	struct list_head *reaplist)
6392	{
6393	unsigned int maxreap = 0, reapcnt = 0;
6394	struct list_head *pos, *next;
6395	struct nfs4_client *clp;
6396
6397	maxreap = NFSD_CLIENT_MAX_TRIM_PER_RUN;
6398	INIT_LIST_HEAD(list: reaplist);
6399
6400	spin_lock(lock: &nn->client_lock);
6401	list_for_each_safe(pos, next, &nn->client_lru) {
6402	clp = list_entry(pos, struct nfs4_client, cl_lru);
6403	if (clp->cl_state == NFSD4_ACTIVE)
6404	break;
6405	if (reapcnt >= maxreap)
6406	break;
6407	if (!mark_client_expired_locked(clp)) {
6408	list_add(new: &clp->cl_lru, head: reaplist);
6409	reapcnt++;
6410	}
6411	}
6412	spin_unlock(lock: &nn->client_lock);
6413	}
6414
6415	static void
6416	nfs4_process_client_reaplist(struct list_head *reaplist)
6417	{
6418	struct list_head *pos, *next;
6419	struct nfs4_client *clp;
6420
6421	list_for_each_safe(pos, next, reaplist) {
6422	clp = list_entry(pos, struct nfs4_client, cl_lru);
6423	trace_nfsd_clid_purged(clid: &clp->cl_clientid);
6424	list_del_init(entry: &clp->cl_lru);
6425	expire_client(clp);
6426	}
6427	}
6428
6429	static void nfs40_clean_admin_revoked(struct nfsd_net *nn,
6430	struct laundry_time *lt)
6431	{
6432	struct nfs4_client *clp;
6433
6434	spin_lock(lock: &nn->client_lock);
6435	if (nn->nfs40_last_revoke == 0 ||
6436	nn->nfs40_last_revoke > lt->cutoff) {
6437	spin_unlock(lock: &nn->client_lock);
6438	return;
6439	}
6440	nn->nfs40_last_revoke = 0;
6441
6442	retry:
6443	list_for_each_entry(clp, &nn->client_lru, cl_lru) {
6444	unsigned long id, tmp;
6445	struct nfs4_stid *stid;
6446
6447	if (atomic_read(v: &clp->cl_admin_revoked) == 0)
6448	continue;
6449
6450	spin_lock(lock: &clp->cl_lock);
6451	idr_for_each_entry_ul(&clp->cl_stateids, stid, tmp, id)
6452	if (stid->sc_status & SC_STATUS_ADMIN_REVOKED) {
6453	refcount_inc(r: &stid->sc_count);
6454	spin_unlock(lock: &nn->client_lock);
6455	/* this function drops ->cl_lock */
6456	nfsd4_drop_revoked_stid(s: stid);
6457	nfs4_put_stid(s: stid);
6458	spin_lock(lock: &nn->client_lock);
6459	goto retry;
6460	}
6461	spin_unlock(lock: &clp->cl_lock);
6462	}
6463	spin_unlock(lock: &nn->client_lock);
6464	}
6465
6466	static time64_t
6467	nfs4_laundromat(struct nfsd_net *nn)
6468	{
6469	struct nfs4_openowner *oo;
6470	struct nfs4_delegation *dp;
6471	struct nfs4_ol_stateid *stp;
6472	struct nfsd4_blocked_lock *nbl;
6473	struct list_head *pos, *next, reaplist;
6474	struct laundry_time lt = {
6475	.cutoff = ktime_get_boottime_seconds() - nn->nfsd4_lease,
6476	.new_timeo = nn->nfsd4_lease
6477	};
6478	struct nfs4_cpntf_state *cps;
6479	copy_stateid_t *cps_t;
6480	int i;
6481
6482	if (clients_still_reclaiming(nn)) {
6483	lt.new_timeo = 0;
6484	goto out;
6485	}
6486	nfsd4_end_grace(nn);
6487
6488	spin_lock(lock: &nn->s2s_cp_lock);
6489	idr_for_each_entry(&nn->s2s_cp_stateids, cps_t, i) {
6490	cps = container_of(cps_t, struct nfs4_cpntf_state, cp_stateid);
6491	if (cps->cp_stateid.cs_type == NFS4_COPYNOTIFY_STID &&
6492	state_expired(lt: &lt, last_refresh: cps->cpntf_time))
6493	_free_cpntf_state_locked(nn, cps);
6494	}
6495	spin_unlock(lock: &nn->s2s_cp_lock);
6496	nfs4_get_client_reaplist(nn, reaplist: &reaplist, lt: &lt);
6497	nfs4_process_client_reaplist(reaplist: &reaplist);
6498
6499	nfs40_clean_admin_revoked(nn, lt: &lt);
6500
6501	spin_lock(lock: &state_lock);
6502	list_for_each_safe(pos, next, &nn->del_recall_lru) {
6503	dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
6504	if (!state_expired(lt: &lt, last_refresh: dp->dl_time))
6505	break;
6506	unhash_delegation_locked(dp, SC_STATUS_REVOKED);
6507	list_add(new: &dp->dl_recall_lru, head: &reaplist);
6508	}
6509	spin_unlock(lock: &state_lock);
6510	while (!list_empty(head: &reaplist)) {
6511	dp = list_first_entry(&reaplist, struct nfs4_delegation,
6512	dl_recall_lru);
6513	list_del_init(entry: &dp->dl_recall_lru);
6514	revoke_delegation(dp);
6515	}
6516
6517	spin_lock(lock: &nn->client_lock);
6518	while (!list_empty(head: &nn->close_lru)) {
6519	oo = list_first_entry(&nn->close_lru, struct nfs4_openowner,
6520	oo_close_lru);
6521	if (!state_expired(lt: &lt, last_refresh: oo->oo_time))
6522	break;
6523	list_del_init(entry: &oo->oo_close_lru);
6524	stp = oo->oo_last_closed_stid;
6525	oo->oo_last_closed_stid = NULL;
6526	spin_unlock(lock: &nn->client_lock);
6527	nfs4_put_stid(s: &stp->st_stid);
6528	spin_lock(lock: &nn->client_lock);
6529	}
6530	spin_unlock(lock: &nn->client_lock);
6531
6532	/*
6533	* It's possible for a client to try and acquire an already held lock
6534	* that is being held for a long time, and then lose interest in it.
6535	* So, we clean out any un-revisited request after a lease period
6536	* under the assumption that the client is no longer interested.
6537	*
6538	* RFC5661, sec. 9.6 states that the client must not rely on getting
6539	* notifications and must continue to poll for locks, even when the
6540	* server supports them. Thus this shouldn't lead to clients blocking
6541	* indefinitely once the lock does become free.
6542	*/
6543	BUG_ON(!list_empty(&reaplist));
6544	spin_lock(lock: &nn->blocked_locks_lock);
6545	while (!list_empty(head: &nn->blocked_locks_lru)) {
6546	nbl = list_first_entry(&nn->blocked_locks_lru,
6547	struct nfsd4_blocked_lock, nbl_lru);
6548	if (!state_expired(lt: &lt, last_refresh: nbl->nbl_time))
6549	break;
6550	list_move(list: &nbl->nbl_lru, head: &reaplist);
6551	list_del_init(entry: &nbl->nbl_list);
6552	}
6553	spin_unlock(lock: &nn->blocked_locks_lock);
6554
6555	while (!list_empty(head: &reaplist)) {
6556	nbl = list_first_entry(&reaplist,
6557	struct nfsd4_blocked_lock, nbl_lru);
6558	list_del_init(entry: &nbl->nbl_lru);
6559	free_blocked_lock(nbl);
6560	}
6561	#ifdef CONFIG_NFSD_V4_2_INTER_SSC
6562	/* service the server-to-server copy delayed unmount list */
6563	nfsd4_ssc_expire_umount(nn);
6564	#endif
6565	if (atomic_long_read(v: &num_delegations) >= max_delegations)
6566	deleg_reaper(nn);
6567	out:
6568	return max_t(time64_t, lt.new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
6569	}
6570
6571	static void laundromat_main(struct work_struct *);
6572
6573	static void
6574	laundromat_main(struct work_struct *laundry)
6575	{
6576	time64_t t;
6577	struct delayed_work *dwork = to_delayed_work(work: laundry);
6578	struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
6579	laundromat_work);
6580
6581	t = nfs4_laundromat(nn);
6582	queue_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: t*HZ);
6583	}
6584
6585	static void
6586	courtesy_client_reaper(struct nfsd_net *nn)
6587	{
6588	struct list_head reaplist;
6589
6590	nfs4_get_courtesy_client_reaplist(nn, reaplist: &reaplist);
6591	nfs4_process_client_reaplist(reaplist: &reaplist);
6592	}
6593
6594	static void
6595	deleg_reaper(struct nfsd_net *nn)
6596	{
6597	struct list_head *pos, *next;
6598	struct nfs4_client *clp;
6599	struct list_head cblist;
6600
6601	INIT_LIST_HEAD(list: &cblist);
6602	spin_lock(lock: &nn->client_lock);
6603	list_for_each_safe(pos, next, &nn->client_lru) {
6604	clp = list_entry(pos, struct nfs4_client, cl_lru);
6605	if (clp->cl_state != NFSD4_ACTIVE ||
6606	list_empty(head: &clp->cl_delegations) ||
6607	atomic_read(v: &clp->cl_delegs_in_recall) ||
6608	test_bit(NFSD4_CLIENT_CB_RECALL_ANY, &clp->cl_flags) ||
6609	(ktime_get_boottime_seconds() -
6610	clp->cl_ra_time < 5)) {
6611	continue;
6612	}
6613	list_add(new: &clp->cl_ra_cblist, head: &cblist);
6614
6615	/* release in nfsd4_cb_recall_any_release */
6616	kref_get(kref: &clp->cl_nfsdfs.cl_ref);
6617	set_bit(NFSD4_CLIENT_CB_RECALL_ANY, addr: &clp->cl_flags);
6618	clp->cl_ra_time = ktime_get_boottime_seconds();
6619	}
6620	spin_unlock(lock: &nn->client_lock);
6621
6622	while (!list_empty(head: &cblist)) {
6623	clp = list_first_entry(&cblist, struct nfs4_client,
6624	cl_ra_cblist);
6625	list_del_init(entry: &clp->cl_ra_cblist);
6626	clp->cl_ra->ra_keep = 0;
6627	clp->cl_ra->ra_bmval[0] = BIT(RCA4_TYPE_MASK_RDATA_DLG);
6628	clp->cl_ra->ra_bmval[0] = BIT(RCA4_TYPE_MASK_RDATA_DLG) |
6629	BIT(RCA4_TYPE_MASK_WDATA_DLG);
6630	trace_nfsd_cb_recall_any(ra: clp->cl_ra);
6631	nfsd4_run_cb(cb: &clp->cl_ra->ra_cb);
6632	}
6633	}
6634
6635	static void
6636	nfsd4_state_shrinker_worker(struct work_struct *work)
6637	{
6638	struct nfsd_net *nn = container_of(work, struct nfsd_net,
6639	nfsd_shrinker_work);
6640
6641	courtesy_client_reaper(nn);
6642	deleg_reaper(nn);
6643	}
6644
6645	static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stid *stp)
6646	{
6647	if (!fh_match(fh1: &fhp->fh_handle, fh2: &stp->sc_file->fi_fhandle))
6648	return nfserr_bad_stateid;
6649	return nfs_ok;
6650	}
6651
6652	static
6653	__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
6654	{
6655	__be32 status = nfserr_openmode;
6656
6657	/* For lock stateid's, we test the parent open, not the lock: */
6658	if (stp->st_openstp)
6659	stp = stp->st_openstp;
6660	if ((flags & WR_STATE) && !access_permit_write(stp))
6661	goto out;
6662	if ((flags & RD_STATE) && !access_permit_read(stp))
6663	goto out;
6664	status = nfs_ok;
6665	out:
6666	return status;
6667	}
6668
6669	static inline __be32
6670	check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
6671	{
6672	if (ONE_STATEID(stateid) && (flags & RD_STATE))
6673	return nfs_ok;
6674	else if (opens_in_grace(net)) {
6675	/* Answer in remaining cases depends on existence of
6676	* conflicting state; so we must wait out the grace period. */
6677	return nfserr_grace;
6678	} else if (flags & WR_STATE)
6679	return nfs4_share_conflict(current_fh,
6680	NFS4_SHARE_DENY_WRITE);
6681	else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
6682	return nfs4_share_conflict(current_fh,
6683	NFS4_SHARE_DENY_READ);
6684	}
6685
6686	static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
6687	{
6688	/*
6689	* When sessions are used the stateid generation number is ignored
6690	* when it is zero.
6691	*/
6692	if (has_session && in->si_generation == 0)
6693	return nfs_ok;
6694
6695	if (in->si_generation == ref->si_generation)
6696	return nfs_ok;
6697
6698	/* If the client sends us a stateid from the future, it's buggy: */
6699	if (nfsd4_stateid_generation_after(a: in, b: ref))
6700	return nfserr_bad_stateid;
6701	/*
6702	* However, we could see a stateid from the past, even from a
6703	* non-buggy client. For example, if the client sends a lock
6704	* while some IO is outstanding, the lock may bump si_generation
6705	* while the IO is still in flight. The client could avoid that
6706	* situation by waiting for responses on all the IO requests,
6707	* but better performance may result in retrying IO that
6708	* receives an old_stateid error if requests are rarely
6709	* reordered in flight:
6710	*/
6711	return nfserr_old_stateid;
6712	}
6713
6714	static __be32 nfsd4_stid_check_stateid_generation(stateid_t *in, struct nfs4_stid *s, bool has_session)
6715	{
6716	__be32 ret;
6717
6718	spin_lock(lock: &s->sc_lock);
6719	ret = nfsd4_verify_open_stid(s);
6720	if (ret == nfs_ok)
6721	ret = check_stateid_generation(in, ref: &s->sc_stateid, has_session);
6722	spin_unlock(lock: &s->sc_lock);
6723	if (ret == nfserr_admin_revoked)
6724	nfsd40_drop_revoked_stid(cl: s->sc_client,
6725	stid: &s->sc_stateid);
6726	return ret;
6727	}
6728
6729	static __be32 nfsd4_check_openowner_confirmed(struct nfs4_ol_stateid *ols)
6730	{
6731	if (ols->st_stateowner->so_is_open_owner &&
6732	!(openowner(so: ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
6733	return nfserr_bad_stateid;
6734	return nfs_ok;
6735	}
6736
6737	static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
6738	{
6739	struct nfs4_stid *s;
6740	__be32 status = nfserr_bad_stateid;
6741
6742	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
6743	CLOSE_STATEID(stateid))
6744	return status;
6745	spin_lock(lock: &cl->cl_lock);
6746	s = find_stateid_locked(cl, t: stateid);
6747	if (!s)
6748	goto out_unlock;
6749	status = nfsd4_stid_check_stateid_generation(in: stateid, s, has_session: 1);
6750	if (status)
6751	goto out_unlock;
6752	status = nfsd4_verify_open_stid(s);
6753	if (status)
6754	goto out_unlock;
6755
6756	switch (s->sc_type) {
6757	case SC_TYPE_DELEG:
6758	status = nfs_ok;
6759	break;
6760	case SC_TYPE_OPEN:
6761	case SC_TYPE_LOCK:
6762	status = nfsd4_check_openowner_confirmed(ols: openlockstateid(s));
6763	break;
6764	default:
6765	printk("unknown stateid type %x\n", s->sc_type);
6766	status = nfserr_bad_stateid;
6767	}
6768	out_unlock:
6769	spin_unlock(lock: &cl->cl_lock);
6770	if (status == nfserr_admin_revoked)
6771	nfsd40_drop_revoked_stid(cl, stid: stateid);
6772	return status;
6773	}
6774
6775	__be32
6776	nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
6777	stateid_t *stateid,
6778	unsigned short typemask, unsigned short statusmask,
6779	struct nfs4_stid **s, struct nfsd_net *nn)
6780	{
6781	__be32 status;
6782	struct nfs4_stid *stid;
6783	bool return_revoked = false;
6784
6785	/*
6786	* only return revoked delegations if explicitly asked.
6787	* otherwise we report revoked or bad_stateid status.
6788	*/
6789	if (statusmask & SC_STATUS_REVOKED)
6790	return_revoked = true;
6791	if (typemask & SC_TYPE_DELEG)
6792	/* Always allow REVOKED for DELEG so we can
6793	* retturn the appropriate error.
6794	*/
6795	statusmask |= SC_STATUS_REVOKED;
6796
6797	statusmask |= SC_STATUS_ADMIN_REVOKED;
6798
6799	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
6800	CLOSE_STATEID(stateid))
6801	return nfserr_bad_stateid;
6802	status = set_client(clid: &stateid->si_opaque.so_clid, cstate, nn);
6803	if (status == nfserr_stale_clientid) {
6804	if (cstate->session)
6805	return nfserr_bad_stateid;
6806	return nfserr_stale_stateid;
6807	}
6808	if (status)
6809	return status;
6810	stid = find_stateid_by_type(cl: cstate->clp, t: stateid, typemask, ok_states: statusmask);
6811	if (!stid)
6812	return nfserr_bad_stateid;
6813	if ((stid->sc_status & SC_STATUS_REVOKED) && !return_revoked) {
6814	nfs4_put_stid(s: stid);
6815	return nfserr_deleg_revoked;
6816	}
6817	if (stid->sc_status & SC_STATUS_ADMIN_REVOKED) {
6818	nfsd40_drop_revoked_stid(cl: cstate->clp, stid: stateid);
6819	nfs4_put_stid(s: stid);
6820	return nfserr_admin_revoked;
6821	}
6822	*s = stid;
6823	return nfs_ok;
6824	}
6825
6826	static struct nfsd_file *
6827	nfs4_find_file(struct nfs4_stid *s, int flags)
6828	{
6829	struct nfsd_file *ret = NULL;
6830
6831	if (!s || s->sc_status)
6832	return NULL;
6833
6834	switch (s->sc_type) {
6835	case SC_TYPE_DELEG:
6836	spin_lock(lock: &s->sc_file->fi_lock);
6837	ret = nfsd_file_get(nf: s->sc_file->fi_deleg_file);
6838	spin_unlock(lock: &s->sc_file->fi_lock);
6839	break;
6840	case SC_TYPE_OPEN:
6841	case SC_TYPE_LOCK:
6842	if (flags & RD_STATE)
6843	ret = find_readable_file(f: s->sc_file);
6844	else
6845	ret = find_writeable_file(f: s->sc_file);
6846	}
6847
6848	return ret;
6849	}
6850
6851	static __be32
6852	nfs4_check_olstateid(struct nfs4_ol_stateid *ols, int flags)
6853	{
6854	__be32 status;
6855
6856	status = nfsd4_check_openowner_confirmed(ols);
6857	if (status)
6858	return status;
6859	return nfs4_check_openmode(stp: ols, flags);
6860	}
6861
6862	static __be32
6863	nfs4_check_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_stid *s,
6864	struct nfsd_file **nfp, int flags)
6865	{
6866	int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE;
6867	struct nfsd_file *nf;
6868	__be32 status;
6869
6870	nf = nfs4_find_file(s, flags);
6871	if (nf) {
6872	status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
6873	acc | NFSD_MAY_OWNER_OVERRIDE);
6874	if (status) {
6875	nfsd_file_put(nf);
6876	goto out;
6877	}
6878	} else {
6879	status = nfsd_file_acquire(rqstp, fhp, may_flags: acc, nfp: &nf);
6880	if (status)
6881	return status;
6882	}
6883	*nfp = nf;
6884	out:
6885	return status;
6886	}
6887	static void
6888	_free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps)
6889	{
6890	WARN_ON_ONCE(cps->cp_stateid.cs_type != NFS4_COPYNOTIFY_STID);
6891	if (!refcount_dec_and_test(r: &cps->cp_stateid.cs_count))
6892	return;
6893	list_del(entry: &cps->cp_list);
6894	idr_remove(&nn->s2s_cp_stateids,
6895	id: cps->cp_stateid.cs_stid.si_opaque.so_id);
6896	kfree(objp: cps);
6897	}
6898	/*
6899	* A READ from an inter server to server COPY will have a
6900	* copy stateid. Look up the copy notify stateid from the
6901	* idr structure and take a reference on it.
6902	*/
6903	__be32 manage_cpntf_state(struct nfsd_net *nn, stateid_t *st,
6904	struct nfs4_client *clp,
6905	struct nfs4_cpntf_state **cps)
6906	{
6907	copy_stateid_t *cps_t;
6908	struct nfs4_cpntf_state *state = NULL;
6909
6910	if (st->si_opaque.so_clid.cl_id != nn->s2s_cp_cl_id)
6911	return nfserr_bad_stateid;
6912	spin_lock(lock: &nn->s2s_cp_lock);
6913	cps_t = idr_find(&nn->s2s_cp_stateids, id: st->si_opaque.so_id);
6914	if (cps_t) {
6915	state = container_of(cps_t, struct nfs4_cpntf_state,
6916	cp_stateid);
6917	if (state->cp_stateid.cs_type != NFS4_COPYNOTIFY_STID) {
6918	state = NULL;
6919	goto unlock;
6920	}
6921	if (!clp)
6922	refcount_inc(r: &state->cp_stateid.cs_count);
6923	else
6924	_free_cpntf_state_locked(nn, cps: state);
6925	}
6926	unlock:
6927	spin_unlock(lock: &nn->s2s_cp_lock);
6928	if (!state)
6929	return nfserr_bad_stateid;
6930	if (!clp)
6931	*cps = state;
6932	return 0;
6933	}
6934
6935	static __be32 find_cpntf_state(struct nfsd_net *nn, stateid_t *st,
6936	struct nfs4_stid **stid)
6937	{
6938	__be32 status;
6939	struct nfs4_cpntf_state *cps = NULL;
6940	struct nfs4_client *found;
6941
6942	status = manage_cpntf_state(nn, st, NULL, cps: &cps);
6943	if (status)
6944	return status;
6945
6946	cps->cpntf_time = ktime_get_boottime_seconds();
6947
6948	status = nfserr_expired;
6949	found = lookup_clientid(clid: &cps->cp_p_clid, sessions: true, nn);
6950	if (!found)
6951	goto out;
6952
6953	*stid = find_stateid_by_type(cl: found, t: &cps->cp_p_stateid,
6954	SC_TYPE_DELEG|SC_TYPE_OPEN|SC_TYPE_LOCK,
6955	ok_states: 0);
6956	if (*stid)
6957	status = nfs_ok;
6958	else
6959	status = nfserr_bad_stateid;
6960
6961	put_client_renew(clp: found);
6962	out:
6963	nfs4_put_cpntf_state(nn, cps);
6964	return status;
6965	}
6966
6967	void nfs4_put_cpntf_state(struct nfsd_net *nn, struct nfs4_cpntf_state *cps)
6968	{
6969	spin_lock(lock: &nn->s2s_cp_lock);
6970	_free_cpntf_state_locked(nn, cps);
6971	spin_unlock(lock: &nn->s2s_cp_lock);
6972	}
6973
6974	/**
6975	* nfs4_preprocess_stateid_op - find and prep stateid for an operation
6976	* @rqstp: incoming request from client
6977	* @cstate: current compound state
6978	* @fhp: filehandle associated with requested stateid
6979	* @stateid: stateid (provided by client)
6980	* @flags: flags describing type of operation to be done
6981	* @nfp: optional nfsd_file return pointer (may be NULL)
6982	* @cstid: optional returned nfs4_stid pointer (may be NULL)
6983	*
6984	* Given info from the client, look up a nfs4_stid for the operation. On
6985	* success, it returns a reference to the nfs4_stid and/or the nfsd_file
6986	* associated with it.
6987	*/
6988	__be32
6989	nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
6990	struct nfsd4_compound_state *cstate, struct svc_fh *fhp,
6991	stateid_t *stateid, int flags, struct nfsd_file **nfp,
6992	struct nfs4_stid **cstid)
6993	{
6994	struct net *net = SVC_NET(rqstp);
6995	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
6996	struct nfs4_stid *s = NULL;
6997	__be32 status;
6998
6999	if (nfp)
7000	*nfp = NULL;
7001
7002	if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
7003	if (cstid)
7004	status = nfserr_bad_stateid;
7005	else
7006	status = check_special_stateids(net, current_fh: fhp, stateid,
7007	flags);
7008	goto done;
7009	}
7010
7011	status = nfsd4_lookup_stateid(cstate, stateid,
7012	SC_TYPE_DELEG|SC_TYPE_OPEN|SC_TYPE_LOCK,
7013	statusmask: 0, s: &s, nn);
7014	if (status == nfserr_bad_stateid)
7015	status = find_cpntf_state(nn, st: stateid, stid: &s);
7016	if (status)
7017	return status;
7018	status = nfsd4_stid_check_stateid_generation(in: stateid, s,
7019	has_session: nfsd4_has_session(cs: cstate));
7020	if (status)
7021	goto out;
7022
7023	switch (s->sc_type) {
7024	case SC_TYPE_DELEG:
7025	status = nfs4_check_delegmode(dp: delegstateid(s), flags);
7026	break;
7027	case SC_TYPE_OPEN:
7028	case SC_TYPE_LOCK:
7029	status = nfs4_check_olstateid(ols: openlockstateid(s), flags);
7030	break;
7031	}
7032	if (status)
7033	goto out;
7034	status = nfs4_check_fh(fhp, stp: s);
7035
7036	done:
7037	if (status == nfs_ok && nfp)
7038	status = nfs4_check_file(rqstp, fhp, s, nfp, flags);
7039	out:
7040	if (s) {
7041	if (!status && cstid)
7042	*cstid = s;
7043	else
7044	nfs4_put_stid(s);
7045	}
7046	return status;
7047	}
7048
7049	/*
7050	* Test if the stateid is valid
7051	*/
7052	__be32
7053	nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7054	union nfsd4_op_u *u)
7055	{
7056	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;
7057	struct nfsd4_test_stateid_id *stateid;
7058	struct nfs4_client *cl = cstate->clp;
7059
7060	list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
7061	stateid->ts_id_status =
7062	nfsd4_validate_stateid(cl, stateid: &stateid->ts_id_stateid);
7063
7064	return nfs_ok;
7065	}
7066
7067	static __be32
7068	nfsd4_free_lock_stateid(stateid_t *stateid, struct nfs4_stid *s)
7069	{
7070	struct nfs4_ol_stateid *stp = openlockstateid(s);
7071	__be32 ret;
7072
7073	ret = nfsd4_lock_ol_stateid(stp);
7074	if (ret)
7075	goto out_put_stid;
7076
7077	ret = check_stateid_generation(in: stateid, ref: &s->sc_stateid, has_session: 1);
7078	if (ret)
7079	goto out;
7080
7081	ret = nfserr_locks_held;
7082	if (check_for_locks(fp: stp->st_stid.sc_file,
7083	lowner: lockowner(so: stp->st_stateowner)))
7084	goto out;
7085
7086	release_lock_stateid(stp);
7087	ret = nfs_ok;
7088
7089	out:
7090	mutex_unlock(lock: &stp->st_mutex);
7091	out_put_stid:
7092	nfs4_put_stid(s);
7093	return ret;
7094	}
7095
7096	__be32
7097	nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7098	union nfsd4_op_u *u)
7099	{
7100	struct nfsd4_free_stateid *free_stateid = &u->free_stateid;
7101	stateid_t *stateid = &free_stateid->fr_stateid;
7102	struct nfs4_stid *s;
7103	struct nfs4_delegation *dp;
7104	struct nfs4_client *cl = cstate->clp;
7105	__be32 ret = nfserr_bad_stateid;
7106
7107	spin_lock(lock: &cl->cl_lock);
7108	s = find_stateid_locked(cl, t: stateid);
7109	if (!s || s->sc_status & SC_STATUS_CLOSED)
7110	goto out_unlock;
7111	if (s->sc_status & SC_STATUS_ADMIN_REVOKED) {
7112	nfsd4_drop_revoked_stid(s);
7113	ret = nfs_ok;
7114	goto out;
7115	}
7116	spin_lock(lock: &s->sc_lock);
7117	switch (s->sc_type) {
7118	case SC_TYPE_DELEG:
7119	if (s->sc_status & SC_STATUS_REVOKED) {
7120	spin_unlock(lock: &s->sc_lock);
7121	dp = delegstateid(s);
7122	list_del_init(entry: &dp->dl_recall_lru);
7123	spin_unlock(lock: &cl->cl_lock);
7124	nfs4_put_stid(s);
7125	ret = nfs_ok;
7126	goto out;
7127	}
7128	ret = nfserr_locks_held;
7129	break;
7130	case SC_TYPE_OPEN:
7131	ret = check_stateid_generation(in: stateid, ref: &s->sc_stateid, has_session: 1);
7132	if (ret)
7133	break;
7134	ret = nfserr_locks_held;
7135	break;
7136	case SC_TYPE_LOCK:
7137	spin_unlock(lock: &s->sc_lock);
7138	refcount_inc(r: &s->sc_count);
7139	spin_unlock(lock: &cl->cl_lock);
7140	ret = nfsd4_free_lock_stateid(stateid, s);
7141	goto out;
7142	}
7143	spin_unlock(lock: &s->sc_lock);
7144	out_unlock:
7145	spin_unlock(lock: &cl->cl_lock);
7146	out:
7147	return ret;
7148	}
7149
7150	static inline int
7151	setlkflg (int type)
7152	{
7153	return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
7154	RD_STATE : WR_STATE;
7155	}
7156
7157	static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
7158	{
7159	struct svc_fh *current_fh = &cstate->current_fh;
7160	struct nfs4_stateowner *sop = stp->st_stateowner;
7161	__be32 status;
7162
7163	status = nfsd4_check_seqid(cstate, so: sop, seqid);
7164	if (status)
7165	return status;
7166	status = nfsd4_lock_ol_stateid(stp);
7167	if (status != nfs_ok)
7168	return status;
7169	status = check_stateid_generation(in: stateid, ref: &stp->st_stid.sc_stateid, has_session: nfsd4_has_session(cs: cstate));
7170	if (status == nfs_ok)
7171	status = nfs4_check_fh(fhp: current_fh, stp: &stp->st_stid);
7172	if (status != nfs_ok)
7173	mutex_unlock(lock: &stp->st_mutex);
7174	return status;
7175	}
7176
7177	/**
7178	* nfs4_preprocess_seqid_op - find and prep an ol_stateid for a seqid-morphing op
7179	* @cstate: compund state
7180	* @seqid: seqid (provided by client)
7181	* @stateid: stateid (provided by client)
7182	* @typemask: mask of allowable types for this operation
7183	* @statusmask: mask of allowed states: 0 or STID_CLOSED
7184	* @stpp: return pointer for the stateid found
7185	* @nn: net namespace for request
7186	*
7187	* Given a stateid+seqid from a client, look up an nfs4_ol_stateid and
7188	* return it in @stpp. On a nfs_ok return, the returned stateid will
7189	* have its st_mutex locked.
7190	*/
7191	static __be32
7192	nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
7193	stateid_t *stateid,
7194	unsigned short typemask, unsigned short statusmask,
7195	struct nfs4_ol_stateid **stpp,
7196	struct nfsd_net *nn)
7197	{
7198	__be32 status;
7199	struct nfs4_stid *s;
7200	struct nfs4_ol_stateid *stp = NULL;
7201
7202	trace_nfsd_preprocess(seqid, stp: stateid);
7203
7204	*stpp = NULL;
7205	status = nfsd4_lookup_stateid(cstate, stateid,
7206	typemask, statusmask, s: &s, nn);
7207	if (status)
7208	return status;
7209	stp = openlockstateid(s);
7210	nfsd4_cstate_assign_replay(cstate, so: stp->st_stateowner);
7211
7212	status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp);
7213	if (!status)
7214	*stpp = stp;
7215	else
7216	nfs4_put_stid(s: &stp->st_stid);
7217	return status;
7218	}
7219
7220	static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
7221	stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
7222	{
7223	__be32 status;
7224	struct nfs4_openowner *oo;
7225	struct nfs4_ol_stateid *stp;
7226
7227	status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
7228	SC_TYPE_OPEN, statusmask: 0, stpp: &stp, nn);
7229	if (status)
7230	return status;
7231	oo = openowner(so: stp->st_stateowner);
7232	if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
7233	mutex_unlock(lock: &stp->st_mutex);
7234	nfs4_put_stid(s: &stp->st_stid);
7235	return nfserr_bad_stateid;
7236	}
7237	*stpp = stp;
7238	return nfs_ok;
7239	}
7240
7241	__be32
7242	nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7243	union nfsd4_op_u *u)
7244	{
7245	struct nfsd4_open_confirm *oc = &u->open_confirm;
7246	__be32 status;
7247	struct nfs4_openowner *oo;
7248	struct nfs4_ol_stateid *stp;
7249	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
7250
7251	dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
7252	cstate->current_fh.fh_dentry);
7253
7254	status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
7255	if (status)
7256	return status;
7257
7258	status = nfs4_preprocess_seqid_op(cstate,
7259	seqid: oc->oc_seqid, stateid: &oc->oc_req_stateid,
7260	SC_TYPE_OPEN, statusmask: 0, stpp: &stp, nn);
7261	if (status)
7262	goto out;
7263	oo = openowner(so: stp->st_stateowner);
7264	status = nfserr_bad_stateid;
7265	if (oo->oo_flags & NFS4_OO_CONFIRMED) {
7266	mutex_unlock(lock: &stp->st_mutex);
7267	goto put_stateid;
7268	}
7269	oo->oo_flags |= NFS4_OO_CONFIRMED;
7270	nfs4_inc_and_copy_stateid(dst: &oc->oc_resp_stateid, stid: &stp->st_stid);
7271	mutex_unlock(lock: &stp->st_mutex);
7272	trace_nfsd_open_confirm(seqid: oc->oc_seqid, stp: &stp->st_stid.sc_stateid);
7273	nfsd4_client_record_create(clp: oo->oo_owner.so_client);
7274	status = nfs_ok;
7275	put_stateid:
7276	nfs4_put_stid(s: &stp->st_stid);
7277	out:
7278	nfsd4_bump_seqid(cstate, nfserr: status);
7279	return status;
7280	}
7281
7282	static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
7283	{
7284	if (!test_access(access, stp))
7285	return;
7286	nfs4_file_put_access(fp: stp->st_stid.sc_file, access);
7287	clear_access(access, stp);
7288	}
7289
7290	static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
7291	{
7292	switch (to_access) {
7293	case NFS4_SHARE_ACCESS_READ:
7294	nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
7295	nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
7296	break;
7297	case NFS4_SHARE_ACCESS_WRITE:
7298	nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
7299	nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
7300	break;
7301	case NFS4_SHARE_ACCESS_BOTH:
7302	break;
7303	default:
7304	WARN_ON_ONCE(1);
7305	}
7306	}
7307
7308	__be32
7309	nfsd4_open_downgrade(struct svc_rqst *rqstp,
7310	struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
7311	{
7312	struct nfsd4_open_downgrade *od = &u->open_downgrade;
7313	__be32 status;
7314	struct nfs4_ol_stateid *stp;
7315	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
7316
7317	dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
7318	cstate->current_fh.fh_dentry);
7319
7320	/* We don't yet support WANT bits: */
7321	if (od->od_deleg_want)
7322	dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
7323	od->od_deleg_want);
7324
7325	status = nfs4_preprocess_confirmed_seqid_op(cstate, seqid: od->od_seqid,
7326	stateid: &od->od_stateid, stpp: &stp, nn);
7327	if (status)
7328	goto out;
7329	status = nfserr_inval;
7330	if (!test_access(access: od->od_share_access, stp)) {
7331	dprintk("NFSD: access not a subset of current bitmap: 0x%hhx, input access=%08x\n",
7332	stp->st_access_bmap, od->od_share_access);
7333	goto put_stateid;
7334	}
7335	if (!test_deny(deny: od->od_share_deny, stp)) {
7336	dprintk("NFSD: deny not a subset of current bitmap: 0x%hhx, input deny=%08x\n",
7337	stp->st_deny_bmap, od->od_share_deny);
7338	goto put_stateid;
7339	}
7340	nfs4_stateid_downgrade(stp, to_access: od->od_share_access);
7341	reset_union_bmap_deny(deny: od->od_share_deny, stp);
7342	nfs4_inc_and_copy_stateid(dst: &od->od_stateid, stid: &stp->st_stid);
7343	status = nfs_ok;
7344	put_stateid:
7345	mutex_unlock(lock: &stp->st_mutex);
7346	nfs4_put_stid(s: &stp->st_stid);
7347	out:
7348	nfsd4_bump_seqid(cstate, nfserr: status);
7349	return status;
7350	}
7351
7352	static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
7353	{
7354	struct nfs4_client *clp = s->st_stid.sc_client;
7355	bool unhashed;
7356	LIST_HEAD(reaplist);
7357	struct nfs4_ol_stateid *stp;
7358
7359	spin_lock(lock: &clp->cl_lock);
7360	unhashed = unhash_open_stateid(stp: s, reaplist: &reaplist);
7361
7362	if (clp->cl_minorversion) {
7363	if (unhashed)
7364	put_ol_stateid_locked(stp: s, reaplist: &reaplist);
7365	spin_unlock(lock: &clp->cl_lock);
7366	list_for_each_entry(stp, &reaplist, st_locks)
7367	nfs4_free_cpntf_statelist(net: clp->net, stid: &stp->st_stid);
7368	free_ol_stateid_reaplist(reaplist: &reaplist);
7369	} else {
7370	spin_unlock(lock: &clp->cl_lock);
7371	free_ol_stateid_reaplist(reaplist: &reaplist);
7372	if (unhashed)
7373	move_to_close_lru(s, net: clp->net);
7374	}
7375	}
7376
7377	/*
7378	* nfs4_unlock_state() called after encode
7379	*/
7380	__be32
7381	nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7382	union nfsd4_op_u *u)
7383	{
7384	struct nfsd4_close *close = &u->close;
7385	__be32 status;
7386	struct nfs4_ol_stateid *stp;
7387	struct net *net = SVC_NET(rqstp);
7388	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
7389
7390	dprintk("NFSD: nfsd4_close on file %pd\n",
7391	cstate->current_fh.fh_dentry);
7392
7393	status = nfs4_preprocess_seqid_op(cstate, seqid: close->cl_seqid,
7394	stateid: &close->cl_stateid,
7395	SC_TYPE_OPEN, SC_STATUS_CLOSED,
7396	stpp: &stp, nn);
7397	nfsd4_bump_seqid(cstate, nfserr: status);
7398	if (status)
7399	goto out;
7400
7401	spin_lock(lock: &stp->st_stid.sc_client->cl_lock);
7402	stp->st_stid.sc_status |= SC_STATUS_CLOSED;
7403	spin_unlock(lock: &stp->st_stid.sc_client->cl_lock);
7404
7405	/*
7406	* Technically we don't _really_ have to increment or copy it, since
7407	* it should just be gone after this operation and we clobber the
7408	* copied value below, but we continue to do so here just to ensure
7409	* that racing ops see that there was a state change.
7410	*/
7411	nfs4_inc_and_copy_stateid(dst: &close->cl_stateid, stid: &stp->st_stid);
7412
7413	nfsd4_close_open_stateid(s: stp);
7414	mutex_unlock(lock: &stp->st_mutex);
7415
7416	/* v4.1+ suggests that we send a special stateid in here, since the
7417	* clients should just ignore this anyway. Since this is not useful
7418	* for v4.0 clients either, we set it to the special close_stateid
7419	* universally.
7420	*
7421	* See RFC5661 section 18.2.4, and RFC7530 section 16.2.5
7422	*/
7423	memcpy(&close->cl_stateid, &close_stateid, sizeof(close->cl_stateid));
7424
7425	/* put reference from nfs4_preprocess_seqid_op */
7426	nfs4_put_stid(s: &stp->st_stid);
7427	out:
7428	return status;
7429	}
7430
7431	__be32
7432	nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7433	union nfsd4_op_u *u)
7434	{
7435	struct nfsd4_delegreturn *dr = &u->delegreturn;
7436	struct nfs4_delegation *dp;
7437	stateid_t *stateid = &dr->dr_stateid;
7438	struct nfs4_stid *s;
7439	__be32 status;
7440	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
7441
7442	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
7443	return status;
7444
7445	status = nfsd4_lookup_stateid(cstate, stateid, SC_TYPE_DELEG, statusmask: 0, s: &s, nn);
7446	if (status)
7447	goto out;
7448	dp = delegstateid(s);
7449	status = nfsd4_stid_check_stateid_generation(in: stateid, s: &dp->dl_stid, has_session: nfsd4_has_session(cs: cstate));
7450	if (status)
7451	goto put_stateid;
7452
7453	trace_nfsd_deleg_return(stp: stateid);
7454	wake_up_var(var: d_inode(dentry: cstate->current_fh.fh_dentry));
7455	destroy_delegation(dp);
7456	put_stateid:
7457	nfs4_put_stid(s: &dp->dl_stid);
7458	out:
7459	return status;
7460	}
7461
7462	/* last octet in a range */
7463	static inline u64
7464	last_byte_offset(u64 start, u64 len)
7465	{
7466	u64 end;
7467
7468	WARN_ON_ONCE(!len);
7469	end = start + len;
7470	return end > start ? end - 1: NFS4_MAX_UINT64;
7471	}
7472
7473	/*
7474	* TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
7475	* we can't properly handle lock requests that go beyond the (2^63 - 1)-th
7476	* byte, because of sign extension problems. Since NFSv4 calls for 64-bit
7477	* locking, this prevents us from being completely protocol-compliant. The
7478	* real solution to this problem is to start using unsigned file offsets in
7479	* the VFS, but this is a very deep change!
7480	*/
7481	static inline void
7482	nfs4_transform_lock_offset(struct file_lock *lock)
7483	{
7484	if (lock->fl_start < 0)
7485	lock->fl_start = OFFSET_MAX;
7486	if (lock->fl_end < 0)
7487	lock->fl_end = OFFSET_MAX;
7488	}
7489
7490	static fl_owner_t
7491	nfsd4_lm_get_owner(fl_owner_t owner)
7492	{
7493	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
7494
7495	nfs4_get_stateowner(sop: &lo->lo_owner);
7496	return owner;
7497	}
7498
7499	static void
7500	nfsd4_lm_put_owner(fl_owner_t owner)
7501	{
7502	struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
7503
7504	if (lo)
7505	nfs4_put_stateowner(sop: &lo->lo_owner);
7506	}
7507
7508	/* return pointer to struct nfs4_client if client is expirable */
7509	static bool
7510	nfsd4_lm_lock_expirable(struct file_lock *cfl)
7511	{
7512	struct nfs4_lockowner *lo = (struct nfs4_lockowner *) cfl->c.flc_owner;
7513	struct nfs4_client *clp = lo->lo_owner.so_client;
7514	struct nfsd_net *nn;
7515
7516	if (try_to_expire_client(clp)) {
7517	nn = net_generic(net: clp->net, id: nfsd_net_id);
7518	mod_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: 0);
7519	return true;
7520	}
7521	return false;
7522	}
7523
7524	/* schedule laundromat to run immediately and wait for it to complete */
7525	static void
7526	nfsd4_lm_expire_lock(void)
7527	{
7528	flush_workqueue(laundry_wq);
7529	}
7530
7531	static void
7532	nfsd4_lm_notify(struct file_lock *fl)
7533	{
7534	struct nfs4_lockowner *lo = (struct nfs4_lockowner *) fl->c.flc_owner;
7535	struct net *net = lo->lo_owner.so_client->net;
7536	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
7537	struct nfsd4_blocked_lock *nbl = container_of(fl,
7538	struct nfsd4_blocked_lock, nbl_lock);
7539	bool queue = false;
7540
7541	/* An empty list means that something else is going to be using it */
7542	spin_lock(lock: &nn->blocked_locks_lock);
7543	if (!list_empty(head: &nbl->nbl_list)) {
7544	list_del_init(entry: &nbl->nbl_list);
7545	list_del_init(entry: &nbl->nbl_lru);
7546	queue = true;
7547	}
7548	spin_unlock(lock: &nn->blocked_locks_lock);
7549
7550	if (queue) {
7551	trace_nfsd_cb_notify_lock(lo, nbl);
7552	nfsd4_run_cb(cb: &nbl->nbl_cb);
7553	}
7554	}
7555
7556	static const struct lock_manager_operations nfsd_posix_mng_ops = {
7557	.lm_mod_owner = THIS_MODULE,
7558	.lm_notify = nfsd4_lm_notify,
7559	.lm_get_owner = nfsd4_lm_get_owner,
7560	.lm_put_owner = nfsd4_lm_put_owner,
7561	.lm_lock_expirable = nfsd4_lm_lock_expirable,
7562	.lm_expire_lock = nfsd4_lm_expire_lock,
7563	};
7564
7565	static inline void
7566	nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
7567	{
7568	struct nfs4_lockowner *lo;
7569
7570	if (fl->fl_lmops == &nfsd_posix_mng_ops) {
7571	lo = (struct nfs4_lockowner *) fl->c.flc_owner;
7572	xdr_netobj_dup(dst: &deny->ld_owner, src: &lo->lo_owner.so_owner,
7573	GFP_KERNEL);
7574	if (!deny->ld_owner.data)
7575	/* We just don't care that much */
7576	goto nevermind;
7577	deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
7578	} else {
7579	nevermind:
7580	deny->ld_owner.len = 0;
7581	deny->ld_owner.data = NULL;
7582	deny->ld_clientid.cl_boot = 0;
7583	deny->ld_clientid.cl_id = 0;
7584	}
7585	deny->ld_start = fl->fl_start;
7586	deny->ld_length = NFS4_MAX_UINT64;
7587	if (fl->fl_end != NFS4_MAX_UINT64)
7588	deny->ld_length = fl->fl_end - fl->fl_start + 1;
7589	deny->ld_type = NFS4_READ_LT;
7590	if (fl->c.flc_type != F_RDLCK)
7591	deny->ld_type = NFS4_WRITE_LT;
7592	}
7593
7594	static struct nfs4_lockowner *
7595	find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner)
7596	{
7597	unsigned int strhashval = ownerstr_hashval(ownername: owner);
7598	struct nfs4_stateowner *so;
7599
7600	lockdep_assert_held(&clp->cl_lock);
7601
7602	list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
7603	so_strhash) {
7604	if (so->so_is_open_owner)
7605	continue;
7606	if (same_owner_str(sop: so, owner))
7607	return lockowner(so: nfs4_get_stateowner(sop: so));
7608	}
7609	return NULL;
7610	}
7611
7612	static struct nfs4_lockowner *
7613	find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner)
7614	{
7615	struct nfs4_lockowner *lo;
7616
7617	spin_lock(lock: &clp->cl_lock);
7618	lo = find_lockowner_str_locked(clp, owner);
7619	spin_unlock(lock: &clp->cl_lock);
7620	return lo;
7621	}
7622
7623	static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)
7624	{
7625	unhash_lockowner_locked(lo: lockowner(so: sop));
7626	}
7627
7628	static void nfs4_free_lockowner(struct nfs4_stateowner *sop)
7629	{
7630	struct nfs4_lockowner *lo = lockowner(so: sop);
7631
7632	kmem_cache_free(s: lockowner_slab, objp: lo);
7633	}
7634
7635	static const struct nfs4_stateowner_operations lockowner_ops = {
7636	.so_unhash = nfs4_unhash_lockowner,
7637	.so_free = nfs4_free_lockowner,
7638	};
7639
7640	/*
7641	* Alloc a lock owner structure.
7642	* Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
7643	* occurred.
7644	*
7645	* strhashval = ownerstr_hashval
7646	*/
7647	static struct nfs4_lockowner *
7648	alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
7649	struct nfs4_ol_stateid *open_stp,
7650	struct nfsd4_lock *lock)
7651	{
7652	struct nfs4_lockowner *lo, *ret;
7653
7654	lo = alloc_stateowner(slab: lockowner_slab, owner: &lock->lk_new_owner, clp);
7655	if (!lo)
7656	return NULL;
7657	INIT_LIST_HEAD(list: &lo->lo_blocked);
7658	INIT_LIST_HEAD(list: &lo->lo_owner.so_stateids);
7659	lo->lo_owner.so_is_open_owner = 0;
7660	lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;
7661	lo->lo_owner.so_ops = &lockowner_ops;
7662	spin_lock(lock: &clp->cl_lock);
7663	ret = find_lockowner_str_locked(clp, owner: &lock->lk_new_owner);
7664	if (ret == NULL) {
7665	list_add(new: &lo->lo_owner.so_strhash,
7666	head: &clp->cl_ownerstr_hashtbl[strhashval]);
7667	ret = lo;
7668	} else
7669	nfs4_free_stateowner(sop: &lo->lo_owner);
7670
7671	spin_unlock(lock: &clp->cl_lock);
7672	return ret;
7673	}
7674
7675	static struct nfs4_ol_stateid *
7676	find_lock_stateid(const struct nfs4_lockowner *lo,
7677	const struct nfs4_ol_stateid *ost)
7678	{
7679	struct nfs4_ol_stateid *lst;
7680
7681	lockdep_assert_held(&ost->st_stid.sc_client->cl_lock);
7682
7683	/* If ost is not hashed, ost->st_locks will not be valid */
7684	if (!nfs4_ol_stateid_unhashed(stp: ost))
7685	list_for_each_entry(lst, &ost->st_locks, st_locks) {
7686	if (lst->st_stateowner == &lo->lo_owner) {
7687	refcount_inc(r: &lst->st_stid.sc_count);
7688	return lst;
7689	}
7690	}
7691	return NULL;
7692	}
7693
7694	static struct nfs4_ol_stateid *
7695	init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo,
7696	struct nfs4_file *fp, struct inode *inode,
7697	struct nfs4_ol_stateid *open_stp)
7698	{
7699	struct nfs4_client *clp = lo->lo_owner.so_client;
7700	struct nfs4_ol_stateid *retstp;
7701
7702	mutex_init(&stp->st_mutex);
7703	mutex_lock_nested(lock: &stp->st_mutex, subclass: OPEN_STATEID_MUTEX);
7704	retry:
7705	spin_lock(lock: &clp->cl_lock);
7706	if (nfs4_ol_stateid_unhashed(stp: open_stp))
7707	goto out_close;
7708	retstp = find_lock_stateid(lo, ost: open_stp);
7709	if (retstp)
7710	goto out_found;
7711	refcount_inc(r: &stp->st_stid.sc_count);
7712	stp->st_stid.sc_type = SC_TYPE_LOCK;
7713	stp->st_stateowner = nfs4_get_stateowner(sop: &lo->lo_owner);
7714	get_nfs4_file(fi: fp);
7715	stp->st_stid.sc_file = fp;
7716	stp->st_access_bmap = 0;
7717	stp->st_deny_bmap = open_stp->st_deny_bmap;
7718	stp->st_openstp = open_stp;
7719	spin_lock(lock: &fp->fi_lock);
7720	list_add(new: &stp->st_locks, head: &open_stp->st_locks);
7721	list_add(new: &stp->st_perstateowner, head: &lo->lo_owner.so_stateids);
7722	list_add(new: &stp->st_perfile, head: &fp->fi_stateids);
7723	spin_unlock(lock: &fp->fi_lock);
7724	spin_unlock(lock: &clp->cl_lock);
7725	return stp;
7726	out_found:
7727	spin_unlock(lock: &clp->cl_lock);
7728	if (nfsd4_lock_ol_stateid(stp: retstp) != nfs_ok) {
7729	nfs4_put_stid(s: &retstp->st_stid);
7730	goto retry;
7731	}
7732	/* To keep mutex tracking happy */
7733	mutex_unlock(lock: &stp->st_mutex);
7734	return retstp;
7735	out_close:
7736	spin_unlock(lock: &clp->cl_lock);
7737	mutex_unlock(lock: &stp->st_mutex);
7738	return NULL;
7739	}
7740
7741	static struct nfs4_ol_stateid *
7742	find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi,
7743	struct inode *inode, struct nfs4_ol_stateid *ost,
7744	bool *new)
7745	{
7746	struct nfs4_stid *ns = NULL;
7747	struct nfs4_ol_stateid *lst;
7748	struct nfs4_openowner *oo = openowner(so: ost->st_stateowner);
7749	struct nfs4_client *clp = oo->oo_owner.so_client;
7750
7751	*new = false;
7752	spin_lock(lock: &clp->cl_lock);
7753	lst = find_lock_stateid(lo, ost);
7754	spin_unlock(lock: &clp->cl_lock);
7755	if (lst != NULL) {
7756	if (nfsd4_lock_ol_stateid(stp: lst) == nfs_ok)
7757	goto out;
7758	nfs4_put_stid(s: &lst->st_stid);
7759	}
7760	ns = nfs4_alloc_stid(cl: clp, slab: stateid_slab, sc_free: nfs4_free_lock_stateid);
7761	if (ns == NULL)
7762	return NULL;
7763
7764	lst = init_lock_stateid(stp: openlockstateid(s: ns), lo, fp: fi, inode, open_stp: ost);
7765	if (lst == openlockstateid(s: ns))
7766	*new = true;
7767	else
7768	nfs4_put_stid(s: ns);
7769	out:
7770	return lst;
7771	}
7772
7773	static int
7774	check_lock_length(u64 offset, u64 length)
7775	{
7776	return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
7777	(length > ~offset)));
7778	}
7779
7780	static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
7781	{
7782	struct nfs4_file *fp = lock_stp->st_stid.sc_file;
7783
7784	lockdep_assert_held(&fp->fi_lock);
7785
7786	if (test_access(access, stp: lock_stp))
7787	return;
7788	__nfs4_file_get_access(fp, access);
7789	set_access(access, stp: lock_stp);
7790	}
7791
7792	static __be32
7793	lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
7794	struct nfs4_ol_stateid *ost,
7795	struct nfsd4_lock *lock,
7796	struct nfs4_ol_stateid **plst, bool *new)
7797	{
7798	__be32 status;
7799	struct nfs4_file *fi = ost->st_stid.sc_file;
7800	struct nfs4_openowner *oo = openowner(so: ost->st_stateowner);
7801	struct nfs4_client *cl = oo->oo_owner.so_client;
7802	struct inode *inode = d_inode(dentry: cstate->current_fh.fh_dentry);
7803	struct nfs4_lockowner *lo;
7804	struct nfs4_ol_stateid *lst;
7805	unsigned int strhashval;
7806
7807	lo = find_lockowner_str(clp: cl, owner: &lock->lk_new_owner);
7808	if (!lo) {
7809	strhashval = ownerstr_hashval(ownername: &lock->lk_new_owner);
7810	lo = alloc_init_lock_stateowner(strhashval, clp: cl, open_stp: ost, lock);
7811	if (lo == NULL)
7812	return nfserr_jukebox;
7813	} else {
7814	/* with an existing lockowner, seqids must be the same */
7815	status = nfserr_bad_seqid;
7816	if (!cstate->minorversion &&
7817	lock->lk_new_lock_seqid != lo->lo_owner.so_seqid)
7818	goto out;
7819	}
7820
7821	lst = find_or_create_lock_stateid(lo, fi, inode, ost, new);
7822	if (lst == NULL) {
7823	status = nfserr_jukebox;
7824	goto out;
7825	}
7826
7827	status = nfs_ok;
7828	*plst = lst;
7829	out:
7830	nfs4_put_stateowner(sop: &lo->lo_owner);
7831	return status;
7832	}
7833
7834	/*
7835	* LOCK operation
7836	*/
7837	__be32
7838	nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7839	union nfsd4_op_u *u)
7840	{
7841	struct nfsd4_lock *lock = &u->lock;
7842	struct nfs4_openowner *open_sop = NULL;
7843	struct nfs4_lockowner *lock_sop = NULL;
7844	struct nfs4_ol_stateid *lock_stp = NULL;
7845	struct nfs4_ol_stateid *open_stp = NULL;
7846	struct nfs4_file *fp;
7847	struct nfsd_file *nf = NULL;
7848	struct nfsd4_blocked_lock *nbl = NULL;
7849	struct file_lock *file_lock = NULL;
7850	struct file_lock *conflock = NULL;
7851	struct super_block *sb;
7852	__be32 status = 0;
7853	int lkflg;
7854	int err;
7855	bool new = false;
7856	unsigned char type;
7857	unsigned int flags = FL_POSIX;
7858	struct net *net = SVC_NET(rqstp);
7859	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
7860
7861	dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
7862	(long long) lock->lk_offset,
7863	(long long) lock->lk_length);
7864
7865	if (check_lock_length(offset: lock->lk_offset, length: lock->lk_length))
7866	return nfserr_inval;
7867
7868	if ((status = fh_verify(rqstp, &cstate->current_fh,
7869	S_IFREG, NFSD_MAY_LOCK))) {
7870	dprintk("NFSD: nfsd4_lock: permission denied!\n");
7871	return status;
7872	}
7873	sb = cstate->current_fh.fh_dentry->d_sb;
7874
7875	if (lock->lk_is_new) {
7876	if (nfsd4_has_session(cs: cstate))
7877	/* See rfc 5661 18.10.3: given clientid is ignored: */
7878	memcpy(&lock->lk_new_clientid,
7879	&cstate->clp->cl_clientid,
7880	sizeof(clientid_t));
7881
7882	/* validate and update open stateid and open seqid */
7883	status = nfs4_preprocess_confirmed_seqid_op(cstate,
7884	seqid: lock->lk_new_open_seqid,
7885	stateid: &lock->lk_new_open_stateid,
7886	stpp: &open_stp, nn);
7887	if (status)
7888	goto out;
7889	mutex_unlock(lock: &open_stp->st_mutex);
7890	open_sop = openowner(so: open_stp->st_stateowner);
7891	status = nfserr_bad_stateid;
7892	if (!same_clid(cl1: &open_sop->oo_owner.so_client->cl_clientid,
7893	cl2: &lock->lk_new_clientid))
7894	goto out;
7895	status = lookup_or_create_lock_state(cstate, ost: open_stp, lock,
7896	plst: &lock_stp, new: &new);
7897	} else {
7898	status = nfs4_preprocess_seqid_op(cstate,
7899	seqid: lock->lk_old_lock_seqid,
7900	stateid: &lock->lk_old_lock_stateid,
7901	SC_TYPE_LOCK, statusmask: 0, stpp: &lock_stp,
7902	nn);
7903	}
7904	if (status)
7905	goto out;
7906	lock_sop = lockowner(so: lock_stp->st_stateowner);
7907
7908	lkflg = setlkflg(lock->lk_type);
7909	status = nfs4_check_openmode(stp: lock_stp, flags: lkflg);
7910	if (status)
7911	goto out;
7912
7913	status = nfserr_grace;
7914	if (locks_in_grace(net) && !lock->lk_reclaim)
7915	goto out;
7916	status = nfserr_no_grace;
7917	if (!locks_in_grace(net) && lock->lk_reclaim)
7918	goto out;
7919
7920	if (lock->lk_reclaim)
7921	flags |= FL_RECLAIM;
7922
7923	fp = lock_stp->st_stid.sc_file;
7924	switch (lock->lk_type) {
7925	case NFS4_READW_LT:
7926	if (nfsd4_has_session(cs: cstate) ||
7927	exportfs_lock_op_is_async(export_ops: sb->s_export_op))
7928	flags |= FL_SLEEP;
7929	fallthrough;
7930	case NFS4_READ_LT:
7931	spin_lock(lock: &fp->fi_lock);
7932	nf = find_readable_file_locked(f: fp);
7933	if (nf)
7934	get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
7935	spin_unlock(lock: &fp->fi_lock);
7936	type = F_RDLCK;
7937	break;
7938	case NFS4_WRITEW_LT:
7939	if (nfsd4_has_session(cs: cstate) ||
7940	exportfs_lock_op_is_async(export_ops: sb->s_export_op))
7941	flags |= FL_SLEEP;
7942	fallthrough;
7943	case NFS4_WRITE_LT:
7944	spin_lock(lock: &fp->fi_lock);
7945	nf = find_writeable_file_locked(f: fp);
7946	if (nf)
7947	get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
7948	spin_unlock(lock: &fp->fi_lock);
7949	type = F_WRLCK;
7950	break;
7951	default:
7952	status = nfserr_inval;
7953	goto out;
7954	}
7955
7956	if (!nf) {
7957	status = nfserr_openmode;
7958	goto out;
7959	}
7960
7961	/*
7962	* Most filesystems with their own ->lock operations will block
7963	* the nfsd thread waiting to acquire the lock. That leads to
7964	* deadlocks (we don't want every nfsd thread tied up waiting
7965	* for file locks), so don't attempt blocking lock notifications
7966	* on those filesystems:
7967	*/
7968	if (!exportfs_lock_op_is_async(export_ops: sb->s_export_op))
7969	flags &= ~FL_SLEEP;
7970
7971	nbl = find_or_allocate_block(lo: lock_sop, fh: &fp->fi_fhandle, nn);
7972	if (!nbl) {
7973	dprintk("NFSD: %s: unable to allocate block!\n", __func__);
7974	status = nfserr_jukebox;
7975	goto out;
7976	}
7977
7978	file_lock = &nbl->nbl_lock;
7979	file_lock->c.flc_type = type;
7980	file_lock->c.flc_owner = (fl_owner_t)lockowner(so: nfs4_get_stateowner(sop: &lock_sop->lo_owner));
7981	file_lock->c.flc_pid = current->tgid;
7982	file_lock->c.flc_file = nf->nf_file;
7983	file_lock->c.flc_flags = flags;
7984	file_lock->fl_lmops = &nfsd_posix_mng_ops;
7985	file_lock->fl_start = lock->lk_offset;
7986	file_lock->fl_end = last_byte_offset(start: lock->lk_offset, len: lock->lk_length);
7987	nfs4_transform_lock_offset(lock: file_lock);
7988
7989	conflock = locks_alloc_lock();
7990	if (!conflock) {
7991	dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
7992	status = nfserr_jukebox;
7993	goto out;
7994	}
7995
7996	if (flags & FL_SLEEP) {
7997	nbl->nbl_time = ktime_get_boottime_seconds();
7998	spin_lock(lock: &nn->blocked_locks_lock);
7999	list_add_tail(new: &nbl->nbl_list, head: &lock_sop->lo_blocked);
8000	list_add_tail(new: &nbl->nbl_lru, head: &nn->blocked_locks_lru);
8001	kref_get(kref: &nbl->nbl_kref);
8002	spin_unlock(lock: &nn->blocked_locks_lock);
8003	}
8004
8005	err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, conflock);
8006	switch (err) {
8007	case 0: /* success! */
8008	nfs4_inc_and_copy_stateid(dst: &lock->lk_resp_stateid, stid: &lock_stp->st_stid);
8009	status = 0;
8010	if (lock->lk_reclaim)
8011	nn->somebody_reclaimed = true;
8012	break;
8013	case FILE_LOCK_DEFERRED:
8014	kref_put(kref: &nbl->nbl_kref, release: free_nbl);
8015	nbl = NULL;
8016	fallthrough;
8017	case -EAGAIN: /* conflock holds conflicting lock */
8018	status = nfserr_denied;
8019	dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
8020	nfs4_set_lock_denied(fl: conflock, deny: &lock->lk_denied);
8021	break;
8022	case -EDEADLK:
8023	status = nfserr_deadlock;
8024	break;
8025	default:
8026	dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
8027	status = nfserrno(errno: err);
8028	break;
8029	}
8030	out:
8031	if (nbl) {
8032	/* dequeue it if we queued it before */
8033	if (flags & FL_SLEEP) {
8034	spin_lock(lock: &nn->blocked_locks_lock);
8035	if (!list_empty(head: &nbl->nbl_list) &&
8036	!list_empty(head: &nbl->nbl_lru)) {
8037	list_del_init(entry: &nbl->nbl_list);
8038	list_del_init(entry: &nbl->nbl_lru);
8039	kref_put(kref: &nbl->nbl_kref, release: free_nbl);
8040	}
8041	/* nbl can use one of lists to be linked to reaplist */
8042	spin_unlock(lock: &nn->blocked_locks_lock);
8043	}
8044	free_blocked_lock(nbl);
8045	}
8046	if (nf)
8047	nfsd_file_put(nf);
8048	if (lock_stp) {
8049	/* Bump seqid manually if the 4.0 replay owner is openowner */
8050	if (cstate->replay_owner &&
8051	cstate->replay_owner != &lock_sop->lo_owner &&
8052	seqid_mutating_err(ntohl(status)))
8053	lock_sop->lo_owner.so_seqid++;
8054
8055	/*
8056	* If this is a new, never-before-used stateid, and we are
8057	* returning an error, then just go ahead and release it.
8058	*/
8059	if (status && new)
8060	release_lock_stateid(stp: lock_stp);
8061
8062	mutex_unlock(lock: &lock_stp->st_mutex);
8063
8064	nfs4_put_stid(s: &lock_stp->st_stid);
8065	}
8066	if (open_stp)
8067	nfs4_put_stid(s: &open_stp->st_stid);
8068	nfsd4_bump_seqid(cstate, nfserr: status);
8069	if (conflock)
8070	locks_free_lock(fl: conflock);
8071	return status;
8072	}
8073
8074	void nfsd4_lock_release(union nfsd4_op_u *u)
8075	{
8076	struct nfsd4_lock *lock = &u->lock;
8077	struct nfsd4_lock_denied *deny = &lock->lk_denied;
8078
8079	kfree(objp: deny->ld_owner.data);
8080	}
8081
8082	/*
8083	* The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
8084	* so we do a temporary open here just to get an open file to pass to
8085	* vfs_test_lock.
8086	*/
8087	static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
8088	{
8089	struct nfsd_file *nf;
8090	struct inode *inode;
8091	__be32 err;
8092
8093	err = nfsd_file_acquire(rqstp, fhp, NFSD_MAY_READ, nfp: &nf);
8094	if (err)
8095	return err;
8096	inode = fhp->fh_dentry->d_inode;
8097	inode_lock(inode); /* to block new leases till after test_lock: */
8098	err = nfserrno(errno: nfsd_open_break_lease(inode, NFSD_MAY_READ));
8099	if (err)
8100	goto out;
8101	lock->c.flc_file = nf->nf_file;
8102	err = nfserrno(errno: vfs_test_lock(nf->nf_file, lock));
8103	lock->c.flc_file = NULL;
8104	out:
8105	inode_unlock(inode);
8106	nfsd_file_put(nf);
8107	return err;
8108	}
8109
8110	/*
8111	* LOCKT operation
8112	*/
8113	__be32
8114	nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
8115	union nfsd4_op_u *u)
8116	{
8117	struct nfsd4_lockt *lockt = &u->lockt;
8118	struct file_lock *file_lock = NULL;
8119	struct nfs4_lockowner *lo = NULL;
8120	__be32 status;
8121	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
8122
8123	if (locks_in_grace(SVC_NET(rqstp)))
8124	return nfserr_grace;
8125
8126	if (check_lock_length(offset: lockt->lt_offset, length: lockt->lt_length))
8127	return nfserr_inval;
8128
8129	if (!nfsd4_has_session(cs: cstate)) {
8130	status = set_client(clid: &lockt->lt_clientid, cstate, nn);
8131	if (status)
8132	goto out;
8133	}
8134
8135	if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
8136	goto out;
8137
8138	file_lock = locks_alloc_lock();
8139	if (!file_lock) {
8140	dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
8141	status = nfserr_jukebox;
8142	goto out;
8143	}
8144
8145	switch (lockt->lt_type) {
8146	case NFS4_READ_LT:
8147	case NFS4_READW_LT:
8148	file_lock->c.flc_type = F_RDLCK;
8149	break;
8150	case NFS4_WRITE_LT:
8151	case NFS4_WRITEW_LT:
8152	file_lock->c.flc_type = F_WRLCK;
8153	break;
8154	default:
8155	dprintk("NFSD: nfs4_lockt: bad lock type!\n");
8156	status = nfserr_inval;
8157	goto out;
8158	}
8159
8160	lo = find_lockowner_str(clp: cstate->clp, owner: &lockt->lt_owner);
8161	if (lo)
8162	file_lock->c.flc_owner = (fl_owner_t)lo;
8163	file_lock->c.flc_pid = current->tgid;
8164	file_lock->c.flc_flags = FL_POSIX;
8165
8166	file_lock->fl_start = lockt->lt_offset;
8167	file_lock->fl_end = last_byte_offset(start: lockt->lt_offset, len: lockt->lt_length);
8168
8169	nfs4_transform_lock_offset(lock: file_lock);
8170
8171	status = nfsd_test_lock(rqstp, fhp: &cstate->current_fh, lock: file_lock);
8172	if (status)
8173	goto out;
8174
8175	if (file_lock->c.flc_type != F_UNLCK) {
8176	status = nfserr_denied;
8177	nfs4_set_lock_denied(fl: file_lock, deny: &lockt->lt_denied);
8178	}
8179	out:
8180	if (lo)
8181	nfs4_put_stateowner(sop: &lo->lo_owner);
8182	if (file_lock)
8183	locks_free_lock(fl: file_lock);
8184	return status;
8185	}
8186
8187	void nfsd4_lockt_release(union nfsd4_op_u *u)
8188	{
8189	struct nfsd4_lockt *lockt = &u->lockt;
8190	struct nfsd4_lock_denied *deny = &lockt->lt_denied;
8191
8192	kfree(objp: deny->ld_owner.data);
8193	}
8194
8195	__be32
8196	nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
8197	union nfsd4_op_u *u)
8198	{
8199	struct nfsd4_locku *locku = &u->locku;
8200	struct nfs4_ol_stateid *stp;
8201	struct nfsd_file *nf = NULL;
8202	struct file_lock *file_lock = NULL;
8203	__be32 status;
8204	int err;
8205	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
8206
8207	dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
8208	(long long) locku->lu_offset,
8209	(long long) locku->lu_length);
8210
8211	if (check_lock_length(offset: locku->lu_offset, length: locku->lu_length))
8212	return nfserr_inval;
8213
8214	status = nfs4_preprocess_seqid_op(cstate, seqid: locku->lu_seqid,
8215	stateid: &locku->lu_stateid, SC_TYPE_LOCK, statusmask: 0,
8216	stpp: &stp, nn);
8217	if (status)
8218	goto out;
8219	nf = find_any_file(f: stp->st_stid.sc_file);
8220	if (!nf) {
8221	status = nfserr_lock_range;
8222	goto put_stateid;
8223	}
8224	file_lock = locks_alloc_lock();
8225	if (!file_lock) {
8226	dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
8227	status = nfserr_jukebox;
8228	goto put_file;
8229	}
8230
8231	file_lock->c.flc_type = F_UNLCK;
8232	file_lock->c.flc_owner = (fl_owner_t)lockowner(so: nfs4_get_stateowner(sop: stp->st_stateowner));
8233	file_lock->c.flc_pid = current->tgid;
8234	file_lock->c.flc_file = nf->nf_file;
8235	file_lock->c.flc_flags = FL_POSIX;
8236	file_lock->fl_lmops = &nfsd_posix_mng_ops;
8237	file_lock->fl_start = locku->lu_offset;
8238
8239	file_lock->fl_end = last_byte_offset(start: locku->lu_offset,
8240	len: locku->lu_length);
8241	nfs4_transform_lock_offset(lock: file_lock);
8242
8243	err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, NULL);
8244	if (err) {
8245	dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
8246	goto out_nfserr;
8247	}
8248	nfs4_inc_and_copy_stateid(dst: &locku->lu_stateid, stid: &stp->st_stid);
8249	put_file:
8250	nfsd_file_put(nf);
8251	put_stateid:
8252	mutex_unlock(lock: &stp->st_mutex);
8253	nfs4_put_stid(s: &stp->st_stid);
8254	out:
8255	nfsd4_bump_seqid(cstate, nfserr: status);
8256	if (file_lock)
8257	locks_free_lock(fl: file_lock);
8258	return status;
8259
8260	out_nfserr:
8261	status = nfserrno(errno: err);
8262	goto put_file;
8263	}
8264
8265	/*
8266	* returns
8267	* true: locks held by lockowner
8268	* false: no locks held by lockowner
8269	*/
8270	static bool
8271	check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner)
8272	{
8273	struct file_lock *fl;
8274	int status = false;
8275	struct nfsd_file *nf;
8276	struct inode *inode;
8277	struct file_lock_context *flctx;
8278
8279	spin_lock(lock: &fp->fi_lock);
8280	nf = find_any_file_locked(f: fp);
8281	if (!nf) {
8282	/* Any valid lock stateid should have some sort of access */
8283	WARN_ON_ONCE(1);
8284	goto out;
8285	}
8286
8287	inode = file_inode(f: nf->nf_file);
8288	flctx = locks_inode_context(inode);
8289
8290	if (flctx && !list_empty_careful(head: &flctx->flc_posix)) {
8291	spin_lock(lock: &flctx->flc_lock);
8292	for_each_file_lock(fl, &flctx->flc_posix) {
8293	if (fl->c.flc_owner == (fl_owner_t)lowner) {
8294	status = true;
8295	break;
8296	}
8297	}
8298	spin_unlock(lock: &flctx->flc_lock);
8299	}
8300	out:
8301	spin_unlock(lock: &fp->fi_lock);
8302	return status;
8303	}
8304
8305	/**
8306	* nfsd4_release_lockowner - process NFSv4.0 RELEASE_LOCKOWNER operations
8307	* @rqstp: RPC transaction
8308	* @cstate: NFSv4 COMPOUND state
8309	* @u: RELEASE_LOCKOWNER arguments
8310	*
8311	* Check if theree are any locks still held and if not - free the lockowner
8312	* and any lock state that is owned.
8313	*
8314	* Return values:
8315	* %nfs_ok: lockowner released or not found
8316	* %nfserr_locks_held: lockowner still in use
8317	* %nfserr_stale_clientid: clientid no longer active
8318	* %nfserr_expired: clientid not recognized
8319	*/
8320	__be32
8321	nfsd4_release_lockowner(struct svc_rqst *rqstp,
8322	struct nfsd4_compound_state *cstate,
8323	union nfsd4_op_u *u)
8324	{
8325	struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;
8326	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
8327	clientid_t *clid = &rlockowner->rl_clientid;
8328	struct nfs4_ol_stateid *stp;
8329	struct nfs4_lockowner *lo;
8330	struct nfs4_client *clp;
8331	LIST_HEAD(reaplist);
8332	__be32 status;
8333
8334	dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
8335	clid->cl_boot, clid->cl_id);
8336
8337	status = set_client(clid, cstate, nn);
8338	if (status)
8339	return status;
8340	clp = cstate->clp;
8341
8342	spin_lock(lock: &clp->cl_lock);
8343	lo = find_lockowner_str_locked(clp, owner: &rlockowner->rl_owner);
8344	if (!lo) {
8345	spin_unlock(lock: &clp->cl_lock);
8346	return nfs_ok;
8347	}
8348
8349	list_for_each_entry(stp, &lo->lo_owner.so_stateids, st_perstateowner) {
8350	if (check_for_locks(fp: stp->st_stid.sc_file, lowner: lo)) {
8351	spin_unlock(lock: &clp->cl_lock);
8352	nfs4_put_stateowner(sop: &lo->lo_owner);
8353	return nfserr_locks_held;
8354	}
8355	}
8356	unhash_lockowner_locked(lo);
8357	while (!list_empty(head: &lo->lo_owner.so_stateids)) {
8358	stp = list_first_entry(&lo->lo_owner.so_stateids,
8359	struct nfs4_ol_stateid,
8360	st_perstateowner);
8361	unhash_lock_stateid(stp);
8362	put_ol_stateid_locked(stp, reaplist: &reaplist);
8363	}
8364	spin_unlock(lock: &clp->cl_lock);
8365
8366	free_ol_stateid_reaplist(reaplist: &reaplist);
8367	remove_blocked_locks(lo);
8368	nfs4_put_stateowner(sop: &lo->lo_owner);
8369	return nfs_ok;
8370	}
8371
8372	static inline struct nfs4_client_reclaim *
8373	alloc_reclaim(void)
8374	{
8375	return kmalloc(size: sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
8376	}
8377
8378	bool
8379	nfs4_has_reclaimed_state(struct xdr_netobj name, struct nfsd_net *nn)
8380	{
8381	struct nfs4_client_reclaim *crp;
8382
8383	crp = nfsd4_find_reclaim_client(name, nn);
8384	return (crp && crp->cr_clp);
8385	}
8386
8387	/*
8388	* failure => all reset bets are off, nfserr_no_grace...
8389	*
8390	* The caller is responsible for freeing name.data if NULL is returned (it
8391	* will be freed in nfs4_remove_reclaim_record in the normal case).
8392	*/
8393	struct nfs4_client_reclaim *
8394	nfs4_client_to_reclaim(struct xdr_netobj name, struct xdr_netobj princhash,
8395	struct nfsd_net *nn)
8396	{
8397	unsigned int strhashval;
8398	struct nfs4_client_reclaim *crp;
8399
8400	crp = alloc_reclaim();
8401	if (crp) {
8402	strhashval = clientstr_hashval(name);
8403	INIT_LIST_HEAD(list: &crp->cr_strhash);
8404	list_add(new: &crp->cr_strhash, head: &nn->reclaim_str_hashtbl[strhashval]);
8405	crp->cr_name.data = name.data;
8406	crp->cr_name.len = name.len;
8407	crp->cr_princhash.data = princhash.data;
8408	crp->cr_princhash.len = princhash.len;
8409	crp->cr_clp = NULL;
8410	nn->reclaim_str_hashtbl_size++;
8411	}
8412	return crp;
8413	}
8414
8415	void
8416	nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
8417	{
8418	list_del(entry: &crp->cr_strhash);
8419	kfree(objp: crp->cr_name.data);
8420	kfree(objp: crp->cr_princhash.data);
8421	kfree(objp: crp);
8422	nn->reclaim_str_hashtbl_size--;
8423	}
8424
8425	void
8426	nfs4_release_reclaim(struct nfsd_net *nn)
8427	{
8428	struct nfs4_client_reclaim *crp = NULL;
8429	int i;
8430
8431	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
8432	while (!list_empty(head: &nn->reclaim_str_hashtbl[i])) {
8433	crp = list_entry(nn->reclaim_str_hashtbl[i].next,
8434	struct nfs4_client_reclaim, cr_strhash);
8435	nfs4_remove_reclaim_record(crp, nn);
8436	}
8437	}
8438	WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
8439	}
8440
8441	/*
8442	* called from OPEN, CLAIM_PREVIOUS with a new clientid. */
8443	struct nfs4_client_reclaim *
8444	nfsd4_find_reclaim_client(struct xdr_netobj name, struct nfsd_net *nn)
8445	{
8446	unsigned int strhashval;
8447	struct nfs4_client_reclaim *crp = NULL;
8448
8449	strhashval = clientstr_hashval(name);
8450	list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
8451	if (compare_blob(o1: &crp->cr_name, o2: &name) == 0) {
8452	return crp;
8453	}
8454	}
8455	return NULL;
8456	}
8457
8458	__be32
8459	nfs4_check_open_reclaim(struct nfs4_client *clp)
8460	{
8461	if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &clp->cl_flags))
8462	return nfserr_no_grace;
8463
8464	if (nfsd4_client_record_check(clp))
8465	return nfserr_reclaim_bad;
8466
8467	return nfs_ok;
8468	}
8469
8470	/*
8471	* Since the lifetime of a delegation isn't limited to that of an open, a
8472	* client may quite reasonably hang on to a delegation as long as it has
8473	* the inode cached. This becomes an obvious problem the first time a
8474	* client's inode cache approaches the size of the server's total memory.
8475	*
8476	* For now we avoid this problem by imposing a hard limit on the number
8477	* of delegations, which varies according to the server's memory size.
8478	*/
8479	static void
8480	set_max_delegations(void)
8481	{
8482	/*
8483	* Allow at most 4 delegations per megabyte of RAM. Quick
8484	* estimates suggest that in the worst case (where every delegation
8485	* is for a different inode), a delegation could take about 1.5K,
8486	* giving a worst case usage of about 6% of memory.
8487	*/
8488	max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
8489	}
8490
8491	static int nfs4_state_create_net(struct net *net)
8492	{
8493	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
8494	int i;
8495
8496	nn->conf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
8497	size: sizeof(struct list_head),
8498	GFP_KERNEL);
8499	if (!nn->conf_id_hashtbl)
8500	goto err;
8501	nn->unconf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
8502	size: sizeof(struct list_head),
8503	GFP_KERNEL);
8504	if (!nn->unconf_id_hashtbl)
8505	goto err_unconf_id;
8506	nn->sessionid_hashtbl = kmalloc_array(SESSION_HASH_SIZE,
8507	size: sizeof(struct list_head),
8508	GFP_KERNEL);
8509	if (!nn->sessionid_hashtbl)
8510	goto err_sessionid;
8511
8512	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
8513	INIT_LIST_HEAD(list: &nn->conf_id_hashtbl[i]);
8514	INIT_LIST_HEAD(list: &nn->unconf_id_hashtbl[i]);
8515	}
8516	for (i = 0; i < SESSION_HASH_SIZE; i++)
8517	INIT_LIST_HEAD(list: &nn->sessionid_hashtbl[i]);
8518	nn->conf_name_tree = RB_ROOT;
8519	nn->unconf_name_tree = RB_ROOT;
8520	nn->boot_time = ktime_get_real_seconds();
8521	nn->grace_ended = false;
8522	nn->nfsd4_manager.block_opens = true;
8523	INIT_LIST_HEAD(list: &nn->nfsd4_manager.list);
8524	INIT_LIST_HEAD(list: &nn->client_lru);
8525	INIT_LIST_HEAD(list: &nn->close_lru);
8526	INIT_LIST_HEAD(list: &nn->del_recall_lru);
8527	spin_lock_init(&nn->client_lock);
8528	spin_lock_init(&nn->s2s_cp_lock);
8529	idr_init(idr: &nn->s2s_cp_stateids);
8530
8531	spin_lock_init(&nn->blocked_locks_lock);
8532	INIT_LIST_HEAD(list: &nn->blocked_locks_lru);
8533
8534	INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
8535	INIT_WORK(&nn->nfsd_shrinker_work, nfsd4_state_shrinker_worker);
8536	get_net(net);
8537
8538	nn->nfsd_client_shrinker = shrinker_alloc(flags: 0, fmt: "nfsd-client");
8539	if (!nn->nfsd_client_shrinker)
8540	goto err_shrinker;
8541
8542	nn->nfsd_client_shrinker->scan_objects = nfsd4_state_shrinker_scan;
8543	nn->nfsd_client_shrinker->count_objects = nfsd4_state_shrinker_count;
8544	nn->nfsd_client_shrinker->private_data = nn;
8545
8546	shrinker_register(shrinker: nn->nfsd_client_shrinker);
8547
8548	return 0;
8549
8550	err_shrinker:
8551	put_net(net);
8552	kfree(objp: nn->sessionid_hashtbl);
8553	err_sessionid:
8554	kfree(objp: nn->unconf_id_hashtbl);
8555	err_unconf_id:
8556	kfree(objp: nn->conf_id_hashtbl);
8557	err:
8558	return -ENOMEM;
8559	}
8560
8561	static void
8562	nfs4_state_destroy_net(struct net *net)
8563	{
8564	int i;
8565	struct nfs4_client *clp = NULL;
8566	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
8567
8568	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
8569	while (!list_empty(head: &nn->conf_id_hashtbl[i])) {
8570	clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
8571	destroy_client(clp);
8572	}
8573	}
8574
8575	WARN_ON(!list_empty(&nn->blocked_locks_lru));
8576
8577	for (i = 0; i < CLIENT_HASH_SIZE; i++) {
8578	while (!list_empty(head: &nn->unconf_id_hashtbl[i])) {
8579	clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
8580	destroy_client(clp);
8581	}
8582	}
8583
8584	kfree(objp: nn->sessionid_hashtbl);
8585	kfree(objp: nn->unconf_id_hashtbl);
8586	kfree(objp: nn->conf_id_hashtbl);
8587	put_net(net);
8588	}
8589
8590	int
8591	nfs4_state_start_net(struct net *net)
8592	{
8593	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
8594	int ret;
8595
8596	ret = nfs4_state_create_net(net);
8597	if (ret)
8598	return ret;
8599	locks_start_grace(net, &nn->nfsd4_manager);
8600	nfsd4_client_tracking_init(net);
8601	if (nn->track_reclaim_completes && nn->reclaim_str_hashtbl_size == 0)
8602	goto skip_grace;
8603	printk(KERN_INFO "NFSD: starting %lld-second grace period (net %x)\n",
8604	nn->nfsd4_grace, net->ns.inum);
8605	trace_nfsd_grace_start(nn);
8606	queue_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: nn->nfsd4_grace * HZ);
8607	return 0;
8608
8609	skip_grace:
8610	printk(KERN_INFO "NFSD: no clients to reclaim, skipping NFSv4 grace period (net %x)\n",
8611	net->ns.inum);
8612	queue_delayed_work(wq: laundry_wq, dwork: &nn->laundromat_work, delay: nn->nfsd4_lease * HZ);
8613	nfsd4_end_grace(nn);
8614	return 0;
8615	}
8616
8617	/* initialization to perform when the nfsd service is started: */
8618
8619	int
8620	nfs4_state_start(void)
8621	{
8622	int ret;
8623
8624	ret = rhltable_init(hlt: &nfs4_file_rhltable, params: &nfs4_file_rhash_params);
8625	if (ret)
8626	return ret;
8627
8628	ret = nfsd4_create_callback_queue();
8629	if (ret) {
8630	rhltable_destroy(hlt: &nfs4_file_rhltable);
8631	return ret;
8632	}
8633
8634	set_max_delegations();
8635	return 0;
8636	}
8637
8638	void
8639	nfs4_state_shutdown_net(struct net *net)
8640	{
8641	struct nfs4_delegation *dp = NULL;
8642	struct list_head *pos, *next, reaplist;
8643	struct nfsd_net *nn = net_generic(net, id: nfsd_net_id);
8644
8645	shrinker_free(shrinker: nn->nfsd_client_shrinker);
8646	cancel_work(work: &nn->nfsd_shrinker_work);
8647	cancel_delayed_work_sync(dwork: &nn->laundromat_work);
8648	locks_end_grace(&nn->nfsd4_manager);
8649
8650	INIT_LIST_HEAD(list: &reaplist);
8651	spin_lock(lock: &state_lock);
8652	list_for_each_safe(pos, next, &nn->del_recall_lru) {
8653	dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
8654	unhash_delegation_locked(dp, SC_STATUS_CLOSED);
8655	list_add(new: &dp->dl_recall_lru, head: &reaplist);
8656	}
8657	spin_unlock(lock: &state_lock);
8658	list_for_each_safe(pos, next, &reaplist) {
8659	dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
8660	list_del_init(entry: &dp->dl_recall_lru);
8661	destroy_unhashed_deleg(dp);
8662	}
8663
8664	nfsd4_client_tracking_exit(net);
8665	nfs4_state_destroy_net(net);
8666	#ifdef CONFIG_NFSD_V4_2_INTER_SSC
8667	nfsd4_ssc_shutdown_umount(nn);
8668	#endif
8669	}
8670
8671	void
8672	nfs4_state_shutdown(void)
8673	{
8674	nfsd4_destroy_callback_queue();
8675	rhltable_destroy(hlt: &nfs4_file_rhltable);
8676	}
8677
8678	static void
8679	get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
8680	{
8681	if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG) &&
8682	CURRENT_STATEID(stateid))
8683	memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
8684	}
8685
8686	static void
8687	put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
8688	{
8689	if (cstate->minorversion) {
8690	memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
8691	SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
8692	}
8693	}
8694
8695	void
8696	clear_current_stateid(struct nfsd4_compound_state *cstate)
8697	{
8698	CLEAR_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
8699	}
8700
8701	/*
8702	* functions to set current state id
8703	*/
8704	void
8705	nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate,
8706	union nfsd4_op_u *u)
8707	{
8708	put_stateid(cstate, stateid: &u->open_downgrade.od_stateid);
8709	}
8710
8711	void
8712	nfsd4_set_openstateid(struct nfsd4_compound_state *cstate,
8713	union nfsd4_op_u *u)
8714	{
8715	put_stateid(cstate, stateid: &u->open.op_stateid);
8716	}
8717
8718	void
8719	nfsd4_set_closestateid(struct nfsd4_compound_state *cstate,
8720	union nfsd4_op_u *u)
8721	{
8722	put_stateid(cstate, stateid: &u->close.cl_stateid);
8723	}
8724
8725	void
8726	nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate,
8727	union nfsd4_op_u *u)
8728	{
8729	put_stateid(cstate, stateid: &u->lock.lk_resp_stateid);
8730	}
8731
8732	/*
8733	* functions to consume current state id
8734	*/
8735
8736	void
8737	nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate,
8738	union nfsd4_op_u *u)
8739	{
8740	get_stateid(cstate, stateid: &u->open_downgrade.od_stateid);
8741	}
8742
8743	void
8744	nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate,
8745	union nfsd4_op_u *u)
8746	{
8747	get_stateid(cstate, stateid: &u->delegreturn.dr_stateid);
8748	}
8749
8750	void
8751	nfsd4_get_freestateid(struct nfsd4_compound_state *cstate,
8752	union nfsd4_op_u *u)
8753	{
8754	get_stateid(cstate, stateid: &u->free_stateid.fr_stateid);
8755	}
8756
8757	void
8758	nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate,
8759	union nfsd4_op_u *u)
8760	{
8761	get_stateid(cstate, stateid: &u->setattr.sa_stateid);
8762	}
8763
8764	void
8765	nfsd4_get_closestateid(struct nfsd4_compound_state *cstate,
8766	union nfsd4_op_u *u)
8767	{
8768	get_stateid(cstate, stateid: &u->close.cl_stateid);
8769	}
8770
8771	void
8772	nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate,
8773	union nfsd4_op_u *u)
8774	{
8775	get_stateid(cstate, stateid: &u->locku.lu_stateid);
8776	}
8777
8778	void
8779	nfsd4_get_readstateid(struct nfsd4_compound_state *cstate,
8780	union nfsd4_op_u *u)
8781	{
8782	get_stateid(cstate, stateid: &u->read.rd_stateid);
8783	}
8784
8785	void
8786	nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
8787	union nfsd4_op_u *u)
8788	{
8789	get_stateid(cstate, stateid: &u->write.wr_stateid);
8790	}
8791
8792	/**
8793	* nfsd4_deleg_getattr_conflict - Recall if GETATTR causes conflict
8794	* @rqstp: RPC transaction context
8795	* @inode: file to be checked for a conflict
8796	* @modified: return true if file was modified
8797	* @size: new size of file if modified is true
8798	*
8799	* This function is called when there is a conflict between a write
8800	* delegation and a change/size GETATTR from another client. The server
8801	* must either use the CB_GETATTR to get the current values of the
8802	* attributes from the client that holds the delegation or recall the
8803	* delegation before replying to the GETATTR. See RFC 8881 section
8804	* 18.7.4.
8805	*
8806	* Returns 0 if there is no conflict; otherwise an nfs_stat
8807	* code is returned.
8808	*/
8809	__be32
8810	nfsd4_deleg_getattr_conflict(struct svc_rqst *rqstp, struct inode *inode,
8811	bool *modified, u64 *size)
8812	{
8813	__be32 status;
8814	struct nfsd_net *nn = net_generic(SVC_NET(rqstp), id: nfsd_net_id);
8815	struct file_lock_context *ctx;
8816	struct file_lease *fl;
8817	struct nfs4_delegation *dp;
8818	struct iattr attrs;
8819	struct nfs4_cb_fattr *ncf;
8820
8821	*modified = false;
8822	ctx = locks_inode_context(inode);
8823	if (!ctx)
8824	return 0;
8825	spin_lock(lock: &ctx->flc_lock);
8826	for_each_file_lock(fl, &ctx->flc_lease) {
8827	unsigned char type = fl->c.flc_type;
8828
8829	if (fl->c.flc_flags == FL_LAYOUT)
8830	continue;
8831	if (fl->fl_lmops != &nfsd_lease_mng_ops) {
8832	/*
8833	* non-nfs lease, if it's a lease with F_RDLCK then
8834	* we are done; there isn't any write delegation
8835	* on this inode
8836	*/
8837	if (type == F_RDLCK)
8838	break;
8839	goto break_lease;
8840	}
8841	if (type == F_WRLCK) {
8842	dp = fl->c.flc_owner;
8843	if (dp->dl_recall.cb_clp == *(rqstp->rq_lease_breaker)) {
8844	spin_unlock(lock: &ctx->flc_lock);
8845	return 0;
8846	}
8847	break_lease:
8848	nfsd_stats_wdeleg_getattr_inc(nn);
8849	dp = fl->c.flc_owner;
8850	ncf = &dp->dl_cb_fattr;
8851	nfs4_cb_getattr(ncf: &dp->dl_cb_fattr);
8852	spin_unlock(lock: &ctx->flc_lock);
8853	wait_on_bit_timeout(word: &ncf->ncf_cb_flags, CB_GETATTR_BUSY,
8854	TASK_INTERRUPTIBLE, NFSD_CB_GETATTR_TIMEOUT);
8855	if (ncf->ncf_cb_status) {
8856	/* Recall delegation only if client didn't respond */
8857	status = nfserrno(errno: nfsd_open_break_lease(inode, NFSD_MAY_READ));
8858	if (status != nfserr_jukebox ||
8859	!nfsd_wait_for_delegreturn(rqstp, inode))
8860	return status;
8861	}
8862	if (!ncf->ncf_file_modified &&
8863	(ncf->ncf_initial_cinfo != ncf->ncf_cb_change ||
8864	ncf->ncf_cur_fsize != ncf->ncf_cb_fsize))
8865	ncf->ncf_file_modified = true;
8866	if (ncf->ncf_file_modified) {
8867	/*
8868	* Per section 10.4.3 of RFC 8881, the server would
8869	* not update the file's metadata with the client's
8870	* modified size
8871	*/
8872	attrs.ia_mtime = attrs.ia_ctime = current_time(inode);
8873	attrs.ia_valid = ATTR_MTIME | ATTR_CTIME;
8874	setattr_copy(&nop_mnt_idmap, inode, attr: &attrs);
8875	mark_inode_dirty(inode);
8876	ncf->ncf_cur_fsize = ncf->ncf_cb_fsize;
8877	*size = ncf->ncf_cur_fsize;
8878	*modified = true;
8879	}
8880	return 0;
8881	}
8882	break;
8883	}
8884	spin_unlock(lock: &ctx->flc_lock);
8885	return 0;
8886	}
8887