Merge tag 'nfsd-4.21' of git://linux-nfs.org/~bfields/linux
[sfrench/cifs-2.6.git] / fs / nfsd / nfs4state.c
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 "xdr4.h"
46 #include "xdr4cb.h"
47 #include "vfs.h"
48 #include "current_stateid.h"
49
50 #include "netns.h"
51 #include "pnfs.h"
52
53 #define NFSDDBG_FACILITY                NFSDDBG_PROC
54
55 #define all_ones {{~0,~0},~0}
56 static const stateid_t one_stateid = {
57         .si_generation = ~0,
58         .si_opaque = all_ones,
59 };
60 static const stateid_t zero_stateid = {
61         /* all fields zero */
62 };
63 static const stateid_t currentstateid = {
64         .si_generation = 1,
65 };
66 static const stateid_t close_stateid = {
67         .si_generation = 0xffffffffU,
68 };
69
70 static u64 current_sessionid = 1;
71
72 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
73 #define ONE_STATEID(stateid)  (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
74 #define CURRENT_STATEID(stateid) (!memcmp((stateid), &currentstateid, sizeof(stateid_t)))
75 #define CLOSE_STATEID(stateid)  (!memcmp((stateid), &close_stateid, sizeof(stateid_t)))
76
77 /* forward declarations */
78 static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
79 static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
80
81 /* Locking: */
82
83 /*
84  * Currently used for the del_recall_lru and file hash table.  In an
85  * effort to decrease the scope of the client_mutex, this spinlock may
86  * eventually cover more:
87  */
88 static DEFINE_SPINLOCK(state_lock);
89
90 enum nfsd4_st_mutex_lock_subclass {
91         OPEN_STATEID_MUTEX = 0,
92         LOCK_STATEID_MUTEX = 1,
93 };
94
95 /*
96  * A waitqueue for all in-progress 4.0 CLOSE operations that are waiting for
97  * the refcount on the open stateid to drop.
98  */
99 static DECLARE_WAIT_QUEUE_HEAD(close_wq);
100
101 static struct kmem_cache *client_slab;
102 static struct kmem_cache *openowner_slab;
103 static struct kmem_cache *lockowner_slab;
104 static struct kmem_cache *file_slab;
105 static struct kmem_cache *stateid_slab;
106 static struct kmem_cache *deleg_slab;
107 static struct kmem_cache *odstate_slab;
108
109 static void free_session(struct nfsd4_session *);
110
111 static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
112 static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
113
114 static bool is_session_dead(struct nfsd4_session *ses)
115 {
116         return ses->se_flags & NFS4_SESSION_DEAD;
117 }
118
119 static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
120 {
121         if (atomic_read(&ses->se_ref) > ref_held_by_me)
122                 return nfserr_jukebox;
123         ses->se_flags |= NFS4_SESSION_DEAD;
124         return nfs_ok;
125 }
126
127 static bool is_client_expired(struct nfs4_client *clp)
128 {
129         return clp->cl_time == 0;
130 }
131
132 static __be32 get_client_locked(struct nfs4_client *clp)
133 {
134         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
135
136         lockdep_assert_held(&nn->client_lock);
137
138         if (is_client_expired(clp))
139                 return nfserr_expired;
140         atomic_inc(&clp->cl_refcount);
141         return nfs_ok;
142 }
143
144 /* must be called under the client_lock */
145 static inline void
146 renew_client_locked(struct nfs4_client *clp)
147 {
148         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
149
150         if (is_client_expired(clp)) {
151                 WARN_ON(1);
152                 printk("%s: client (clientid %08x/%08x) already expired\n",
153                         __func__,
154                         clp->cl_clientid.cl_boot,
155                         clp->cl_clientid.cl_id);
156                 return;
157         }
158
159         dprintk("renewing client (clientid %08x/%08x)\n",
160                         clp->cl_clientid.cl_boot,
161                         clp->cl_clientid.cl_id);
162         list_move_tail(&clp->cl_lru, &nn->client_lru);
163         clp->cl_time = get_seconds();
164 }
165
166 static void put_client_renew_locked(struct nfs4_client *clp)
167 {
168         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
169
170         lockdep_assert_held(&nn->client_lock);
171
172         if (!atomic_dec_and_test(&clp->cl_refcount))
173                 return;
174         if (!is_client_expired(clp))
175                 renew_client_locked(clp);
176 }
177
178 static void put_client_renew(struct nfs4_client *clp)
179 {
180         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
181
182         if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
183                 return;
184         if (!is_client_expired(clp))
185                 renew_client_locked(clp);
186         spin_unlock(&nn->client_lock);
187 }
188
189 static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
190 {
191         __be32 status;
192
193         if (is_session_dead(ses))
194                 return nfserr_badsession;
195         status = get_client_locked(ses->se_client);
196         if (status)
197                 return status;
198         atomic_inc(&ses->se_ref);
199         return nfs_ok;
200 }
201
202 static void nfsd4_put_session_locked(struct nfsd4_session *ses)
203 {
204         struct nfs4_client *clp = ses->se_client;
205         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
206
207         lockdep_assert_held(&nn->client_lock);
208
209         if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
210                 free_session(ses);
211         put_client_renew_locked(clp);
212 }
213
214 static void nfsd4_put_session(struct nfsd4_session *ses)
215 {
216         struct nfs4_client *clp = ses->se_client;
217         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
218
219         spin_lock(&nn->client_lock);
220         nfsd4_put_session_locked(ses);
221         spin_unlock(&nn->client_lock);
222 }
223
224 static struct nfsd4_blocked_lock *
225 find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
226                         struct nfsd_net *nn)
227 {
228         struct nfsd4_blocked_lock *cur, *found = NULL;
229
230         spin_lock(&nn->blocked_locks_lock);
231         list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
232                 if (fh_match(fh, &cur->nbl_fh)) {
233                         list_del_init(&cur->nbl_list);
234                         list_del_init(&cur->nbl_lru);
235                         found = cur;
236                         break;
237                 }
238         }
239         spin_unlock(&nn->blocked_locks_lock);
240         if (found)
241                 locks_delete_block(&found->nbl_lock);
242         return found;
243 }
244
245 static struct nfsd4_blocked_lock *
246 find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
247                         struct nfsd_net *nn)
248 {
249         struct nfsd4_blocked_lock *nbl;
250
251         nbl = find_blocked_lock(lo, fh, nn);
252         if (!nbl) {
253                 nbl= kmalloc(sizeof(*nbl), GFP_KERNEL);
254                 if (nbl) {
255                         fh_copy_shallow(&nbl->nbl_fh, fh);
256                         locks_init_lock(&nbl->nbl_lock);
257                         nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client,
258                                         &nfsd4_cb_notify_lock_ops,
259                                         NFSPROC4_CLNT_CB_NOTIFY_LOCK);
260                 }
261         }
262         return nbl;
263 }
264
265 static void
266 free_blocked_lock(struct nfsd4_blocked_lock *nbl)
267 {
268         locks_release_private(&nbl->nbl_lock);
269         kfree(nbl);
270 }
271
272 static void
273 remove_blocked_locks(struct nfs4_lockowner *lo)
274 {
275         struct nfs4_client *clp = lo->lo_owner.so_client;
276         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
277         struct nfsd4_blocked_lock *nbl;
278         LIST_HEAD(reaplist);
279
280         /* Dequeue all blocked locks */
281         spin_lock(&nn->blocked_locks_lock);
282         while (!list_empty(&lo->lo_blocked)) {
283                 nbl = list_first_entry(&lo->lo_blocked,
284                                         struct nfsd4_blocked_lock,
285                                         nbl_list);
286                 list_del_init(&nbl->nbl_list);
287                 list_move(&nbl->nbl_lru, &reaplist);
288         }
289         spin_unlock(&nn->blocked_locks_lock);
290
291         /* Now free them */
292         while (!list_empty(&reaplist)) {
293                 nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
294                                         nbl_lru);
295                 list_del_init(&nbl->nbl_lru);
296                 locks_delete_block(&nbl->nbl_lock);
297                 free_blocked_lock(nbl);
298         }
299 }
300
301 static int
302 nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
303 {
304         /*
305          * Since this is just an optimization, we don't try very hard if it
306          * turns out not to succeed. We'll requeue it on NFS4ERR_DELAY, and
307          * just quit trying on anything else.
308          */
309         switch (task->tk_status) {
310         case -NFS4ERR_DELAY:
311                 rpc_delay(task, 1 * HZ);
312                 return 0;
313         default:
314                 return 1;
315         }
316 }
317
318 static void
319 nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb)
320 {
321         struct nfsd4_blocked_lock       *nbl = container_of(cb,
322                                                 struct nfsd4_blocked_lock, nbl_cb);
323
324         free_blocked_lock(nbl);
325 }
326
327 static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
328         .done           = nfsd4_cb_notify_lock_done,
329         .release        = nfsd4_cb_notify_lock_release,
330 };
331
332 static inline struct nfs4_stateowner *
333 nfs4_get_stateowner(struct nfs4_stateowner *sop)
334 {
335         atomic_inc(&sop->so_count);
336         return sop;
337 }
338
339 static int
340 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
341 {
342         return (sop->so_owner.len == owner->len) &&
343                 0 == memcmp(sop->so_owner.data, owner->data, owner->len);
344 }
345
346 static struct nfs4_openowner *
347 find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
348                         struct nfs4_client *clp)
349 {
350         struct nfs4_stateowner *so;
351
352         lockdep_assert_held(&clp->cl_lock);
353
354         list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
355                             so_strhash) {
356                 if (!so->so_is_open_owner)
357                         continue;
358                 if (same_owner_str(so, &open->op_owner))
359                         return openowner(nfs4_get_stateowner(so));
360         }
361         return NULL;
362 }
363
364 static struct nfs4_openowner *
365 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
366                         struct nfs4_client *clp)
367 {
368         struct nfs4_openowner *oo;
369
370         spin_lock(&clp->cl_lock);
371         oo = find_openstateowner_str_locked(hashval, open, clp);
372         spin_unlock(&clp->cl_lock);
373         return oo;
374 }
375
376 static inline u32
377 opaque_hashval(const void *ptr, int nbytes)
378 {
379         unsigned char *cptr = (unsigned char *) ptr;
380
381         u32 x = 0;
382         while (nbytes--) {
383                 x *= 37;
384                 x += *cptr++;
385         }
386         return x;
387 }
388
389 static void nfsd4_free_file_rcu(struct rcu_head *rcu)
390 {
391         struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);
392
393         kmem_cache_free(file_slab, fp);
394 }
395
396 void
397 put_nfs4_file(struct nfs4_file *fi)
398 {
399         might_lock(&state_lock);
400
401         if (refcount_dec_and_lock(&fi->fi_ref, &state_lock)) {
402                 hlist_del_rcu(&fi->fi_hash);
403                 spin_unlock(&state_lock);
404                 WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
405                 WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
406                 call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu);
407         }
408 }
409
410 static struct file *
411 __nfs4_get_fd(struct nfs4_file *f, int oflag)
412 {
413         if (f->fi_fds[oflag])
414                 return get_file(f->fi_fds[oflag]);
415         return NULL;
416 }
417
418 static struct file *
419 find_writeable_file_locked(struct nfs4_file *f)
420 {
421         struct file *ret;
422
423         lockdep_assert_held(&f->fi_lock);
424
425         ret = __nfs4_get_fd(f, O_WRONLY);
426         if (!ret)
427                 ret = __nfs4_get_fd(f, O_RDWR);
428         return ret;
429 }
430
431 static struct file *
432 find_writeable_file(struct nfs4_file *f)
433 {
434         struct file *ret;
435
436         spin_lock(&f->fi_lock);
437         ret = find_writeable_file_locked(f);
438         spin_unlock(&f->fi_lock);
439
440         return ret;
441 }
442
443 static struct file *find_readable_file_locked(struct nfs4_file *f)
444 {
445         struct file *ret;
446
447         lockdep_assert_held(&f->fi_lock);
448
449         ret = __nfs4_get_fd(f, O_RDONLY);
450         if (!ret)
451                 ret = __nfs4_get_fd(f, O_RDWR);
452         return ret;
453 }
454
455 static struct file *
456 find_readable_file(struct nfs4_file *f)
457 {
458         struct file *ret;
459
460         spin_lock(&f->fi_lock);
461         ret = find_readable_file_locked(f);
462         spin_unlock(&f->fi_lock);
463
464         return ret;
465 }
466
467 struct file *
468 find_any_file(struct nfs4_file *f)
469 {
470         struct file *ret;
471
472         spin_lock(&f->fi_lock);
473         ret = __nfs4_get_fd(f, O_RDWR);
474         if (!ret) {
475                 ret = __nfs4_get_fd(f, O_WRONLY);
476                 if (!ret)
477                         ret = __nfs4_get_fd(f, O_RDONLY);
478         }
479         spin_unlock(&f->fi_lock);
480         return ret;
481 }
482
483 static atomic_long_t num_delegations;
484 unsigned long max_delegations;
485
486 /*
487  * Open owner state (share locks)
488  */
489
490 /* hash tables for lock and open owners */
491 #define OWNER_HASH_BITS              8
492 #define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
493 #define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
494
495 static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
496 {
497         unsigned int ret;
498
499         ret = opaque_hashval(ownername->data, ownername->len);
500         return ret & OWNER_HASH_MASK;
501 }
502
503 /* hash table for nfs4_file */
504 #define FILE_HASH_BITS                   8
505 #define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
506
507 static unsigned int nfsd_fh_hashval(struct knfsd_fh *fh)
508 {
509         return jhash2(fh->fh_base.fh_pad, XDR_QUADLEN(fh->fh_size), 0);
510 }
511
512 static unsigned int file_hashval(struct knfsd_fh *fh)
513 {
514         return nfsd_fh_hashval(fh) & (FILE_HASH_SIZE - 1);
515 }
516
517 static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
518
519 static void
520 __nfs4_file_get_access(struct nfs4_file *fp, u32 access)
521 {
522         lockdep_assert_held(&fp->fi_lock);
523
524         if (access & NFS4_SHARE_ACCESS_WRITE)
525                 atomic_inc(&fp->fi_access[O_WRONLY]);
526         if (access & NFS4_SHARE_ACCESS_READ)
527                 atomic_inc(&fp->fi_access[O_RDONLY]);
528 }
529
530 static __be32
531 nfs4_file_get_access(struct nfs4_file *fp, u32 access)
532 {
533         lockdep_assert_held(&fp->fi_lock);
534
535         /* Does this access mode make sense? */
536         if (access & ~NFS4_SHARE_ACCESS_BOTH)
537                 return nfserr_inval;
538
539         /* Does it conflict with a deny mode already set? */
540         if ((access & fp->fi_share_deny) != 0)
541                 return nfserr_share_denied;
542
543         __nfs4_file_get_access(fp, access);
544         return nfs_ok;
545 }
546
547 static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
548 {
549         /* Common case is that there is no deny mode. */
550         if (deny) {
551                 /* Does this deny mode make sense? */
552                 if (deny & ~NFS4_SHARE_DENY_BOTH)
553                         return nfserr_inval;
554
555                 if ((deny & NFS4_SHARE_DENY_READ) &&
556                     atomic_read(&fp->fi_access[O_RDONLY]))
557                         return nfserr_share_denied;
558
559                 if ((deny & NFS4_SHARE_DENY_WRITE) &&
560                     atomic_read(&fp->fi_access[O_WRONLY]))
561                         return nfserr_share_denied;
562         }
563         return nfs_ok;
564 }
565
566 static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
567 {
568         might_lock(&fp->fi_lock);
569
570         if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
571                 struct file *f1 = NULL;
572                 struct file *f2 = NULL;
573
574                 swap(f1, fp->fi_fds[oflag]);
575                 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
576                         swap(f2, fp->fi_fds[O_RDWR]);
577                 spin_unlock(&fp->fi_lock);
578                 if (f1)
579                         fput(f1);
580                 if (f2)
581                         fput(f2);
582         }
583 }
584
585 static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
586 {
587         WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
588
589         if (access & NFS4_SHARE_ACCESS_WRITE)
590                 __nfs4_file_put_access(fp, O_WRONLY);
591         if (access & NFS4_SHARE_ACCESS_READ)
592                 __nfs4_file_put_access(fp, O_RDONLY);
593 }
594
595 /*
596  * Allocate a new open/delegation state counter. This is needed for
597  * pNFS for proper return on close semantics.
598  *
599  * Note that we only allocate it for pNFS-enabled exports, otherwise
600  * all pointers to struct nfs4_clnt_odstate are always NULL.
601  */
602 static struct nfs4_clnt_odstate *
603 alloc_clnt_odstate(struct nfs4_client *clp)
604 {
605         struct nfs4_clnt_odstate *co;
606
607         co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL);
608         if (co) {
609                 co->co_client = clp;
610                 refcount_set(&co->co_odcount, 1);
611         }
612         return co;
613 }
614
615 static void
616 hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
617 {
618         struct nfs4_file *fp = co->co_file;
619
620         lockdep_assert_held(&fp->fi_lock);
621         list_add(&co->co_perfile, &fp->fi_clnt_odstate);
622 }
623
624 static inline void
625 get_clnt_odstate(struct nfs4_clnt_odstate *co)
626 {
627         if (co)
628                 refcount_inc(&co->co_odcount);
629 }
630
631 static void
632 put_clnt_odstate(struct nfs4_clnt_odstate *co)
633 {
634         struct nfs4_file *fp;
635
636         if (!co)
637                 return;
638
639         fp = co->co_file;
640         if (refcount_dec_and_lock(&co->co_odcount, &fp->fi_lock)) {
641                 list_del(&co->co_perfile);
642                 spin_unlock(&fp->fi_lock);
643
644                 nfsd4_return_all_file_layouts(co->co_client, fp);
645                 kmem_cache_free(odstate_slab, co);
646         }
647 }
648
649 static struct nfs4_clnt_odstate *
650 find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
651 {
652         struct nfs4_clnt_odstate *co;
653         struct nfs4_client *cl;
654
655         if (!new)
656                 return NULL;
657
658         cl = new->co_client;
659
660         spin_lock(&fp->fi_lock);
661         list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
662                 if (co->co_client == cl) {
663                         get_clnt_odstate(co);
664                         goto out;
665                 }
666         }
667         co = new;
668         co->co_file = fp;
669         hash_clnt_odstate_locked(new);
670 out:
671         spin_unlock(&fp->fi_lock);
672         return co;
673 }
674
675 struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
676                                   void (*sc_free)(struct nfs4_stid *))
677 {
678         struct nfs4_stid *stid;
679         int new_id;
680
681         stid = kmem_cache_zalloc(slab, GFP_KERNEL);
682         if (!stid)
683                 return NULL;
684
685         idr_preload(GFP_KERNEL);
686         spin_lock(&cl->cl_lock);
687         new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 0, 0, GFP_NOWAIT);
688         spin_unlock(&cl->cl_lock);
689         idr_preload_end();
690         if (new_id < 0)
691                 goto out_free;
692
693         stid->sc_free = sc_free;
694         stid->sc_client = cl;
695         stid->sc_stateid.si_opaque.so_id = new_id;
696         stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
697         /* Will be incremented before return to client: */
698         refcount_set(&stid->sc_count, 1);
699         spin_lock_init(&stid->sc_lock);
700
701         /*
702          * It shouldn't be a problem to reuse an opaque stateid value.
703          * I don't think it is for 4.1.  But with 4.0 I worry that, for
704          * example, a stray write retransmission could be accepted by
705          * the server when it should have been rejected.  Therefore,
706          * adopt a trick from the sctp code to attempt to maximize the
707          * amount of time until an id is reused, by ensuring they always
708          * "increase" (mod INT_MAX):
709          */
710         return stid;
711 out_free:
712         kmem_cache_free(slab, stid);
713         return NULL;
714 }
715
716 /*
717  * Create a unique stateid_t to represent each COPY.
718  */
719 int nfs4_init_cp_state(struct nfsd_net *nn, struct nfsd4_copy *copy)
720 {
721         int new_id;
722
723         idr_preload(GFP_KERNEL);
724         spin_lock(&nn->s2s_cp_lock);
725         new_id = idr_alloc_cyclic(&nn->s2s_cp_stateids, copy, 0, 0, GFP_NOWAIT);
726         spin_unlock(&nn->s2s_cp_lock);
727         idr_preload_end();
728         if (new_id < 0)
729                 return 0;
730         copy->cp_stateid.si_opaque.so_id = new_id;
731         copy->cp_stateid.si_opaque.so_clid.cl_boot = nn->boot_time;
732         copy->cp_stateid.si_opaque.so_clid.cl_id = nn->s2s_cp_cl_id;
733         return 1;
734 }
735
736 void nfs4_free_cp_state(struct nfsd4_copy *copy)
737 {
738         struct nfsd_net *nn;
739
740         nn = net_generic(copy->cp_clp->net, nfsd_net_id);
741         spin_lock(&nn->s2s_cp_lock);
742         idr_remove(&nn->s2s_cp_stateids, copy->cp_stateid.si_opaque.so_id);
743         spin_unlock(&nn->s2s_cp_lock);
744 }
745
746 static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
747 {
748         struct nfs4_stid *stid;
749
750         stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
751         if (!stid)
752                 return NULL;
753
754         return openlockstateid(stid);
755 }
756
757 static void nfs4_free_deleg(struct nfs4_stid *stid)
758 {
759         kmem_cache_free(deleg_slab, stid);
760         atomic_long_dec(&num_delegations);
761 }
762
763 /*
764  * When we recall a delegation, we should be careful not to hand it
765  * out again straight away.
766  * To ensure this we keep a pair of bloom filters ('new' and 'old')
767  * in which the filehandles of recalled delegations are "stored".
768  * If a filehandle appear in either filter, a delegation is blocked.
769  * When a delegation is recalled, the filehandle is stored in the "new"
770  * filter.
771  * Every 30 seconds we swap the filters and clear the "new" one,
772  * unless both are empty of course.
773  *
774  * Each filter is 256 bits.  We hash the filehandle to 32bit and use the
775  * low 3 bytes as hash-table indices.
776  *
777  * 'blocked_delegations_lock', which is always taken in block_delegations(),
778  * is used to manage concurrent access.  Testing does not need the lock
779  * except when swapping the two filters.
780  */
781 static DEFINE_SPINLOCK(blocked_delegations_lock);
782 static struct bloom_pair {
783         int     entries, old_entries;
784         time_t  swap_time;
785         int     new; /* index into 'set' */
786         DECLARE_BITMAP(set[2], 256);
787 } blocked_delegations;
788
789 static int delegation_blocked(struct knfsd_fh *fh)
790 {
791         u32 hash;
792         struct bloom_pair *bd = &blocked_delegations;
793
794         if (bd->entries == 0)
795                 return 0;
796         if (seconds_since_boot() - bd->swap_time > 30) {
797                 spin_lock(&blocked_delegations_lock);
798                 if (seconds_since_boot() - bd->swap_time > 30) {
799                         bd->entries -= bd->old_entries;
800                         bd->old_entries = bd->entries;
801                         memset(bd->set[bd->new], 0,
802                                sizeof(bd->set[0]));
803                         bd->new = 1-bd->new;
804                         bd->swap_time = seconds_since_boot();
805                 }
806                 spin_unlock(&blocked_delegations_lock);
807         }
808         hash = jhash(&fh->fh_base, fh->fh_size, 0);
809         if (test_bit(hash&255, bd->set[0]) &&
810             test_bit((hash>>8)&255, bd->set[0]) &&
811             test_bit((hash>>16)&255, bd->set[0]))
812                 return 1;
813
814         if (test_bit(hash&255, bd->set[1]) &&
815             test_bit((hash>>8)&255, bd->set[1]) &&
816             test_bit((hash>>16)&255, bd->set[1]))
817                 return 1;
818
819         return 0;
820 }
821
822 static void block_delegations(struct knfsd_fh *fh)
823 {
824         u32 hash;
825         struct bloom_pair *bd = &blocked_delegations;
826
827         hash = jhash(&fh->fh_base, fh->fh_size, 0);
828
829         spin_lock(&blocked_delegations_lock);
830         __set_bit(hash&255, bd->set[bd->new]);
831         __set_bit((hash>>8)&255, bd->set[bd->new]);
832         __set_bit((hash>>16)&255, bd->set[bd->new]);
833         if (bd->entries == 0)
834                 bd->swap_time = seconds_since_boot();
835         bd->entries += 1;
836         spin_unlock(&blocked_delegations_lock);
837 }
838
839 static struct nfs4_delegation *
840 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp,
841                  struct svc_fh *current_fh,
842                  struct nfs4_clnt_odstate *odstate)
843 {
844         struct nfs4_delegation *dp;
845         long n;
846
847         dprintk("NFSD alloc_init_deleg\n");
848         n = atomic_long_inc_return(&num_delegations);
849         if (n < 0 || n > max_delegations)
850                 goto out_dec;
851         if (delegation_blocked(&current_fh->fh_handle))
852                 goto out_dec;
853         dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
854         if (dp == NULL)
855                 goto out_dec;
856
857         /*
858          * delegation seqid's are never incremented.  The 4.1 special
859          * meaning of seqid 0 isn't meaningful, really, but let's avoid
860          * 0 anyway just for consistency and use 1:
861          */
862         dp->dl_stid.sc_stateid.si_generation = 1;
863         INIT_LIST_HEAD(&dp->dl_perfile);
864         INIT_LIST_HEAD(&dp->dl_perclnt);
865         INIT_LIST_HEAD(&dp->dl_recall_lru);
866         dp->dl_clnt_odstate = odstate;
867         get_clnt_odstate(odstate);
868         dp->dl_type = NFS4_OPEN_DELEGATE_READ;
869         dp->dl_retries = 1;
870         nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
871                       &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
872         get_nfs4_file(fp);
873         dp->dl_stid.sc_file = fp;
874         return dp;
875 out_dec:
876         atomic_long_dec(&num_delegations);
877         return NULL;
878 }
879
880 void
881 nfs4_put_stid(struct nfs4_stid *s)
882 {
883         struct nfs4_file *fp = s->sc_file;
884         struct nfs4_client *clp = s->sc_client;
885
886         might_lock(&clp->cl_lock);
887
888         if (!refcount_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
889                 wake_up_all(&close_wq);
890                 return;
891         }
892         idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
893         spin_unlock(&clp->cl_lock);
894         s->sc_free(s);
895         if (fp)
896                 put_nfs4_file(fp);
897 }
898
899 void
900 nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
901 {
902         stateid_t *src = &stid->sc_stateid;
903
904         spin_lock(&stid->sc_lock);
905         if (unlikely(++src->si_generation == 0))
906                 src->si_generation = 1;
907         memcpy(dst, src, sizeof(*dst));
908         spin_unlock(&stid->sc_lock);
909 }
910
911 static void put_deleg_file(struct nfs4_file *fp)
912 {
913         struct file *filp = NULL;
914
915         spin_lock(&fp->fi_lock);
916         if (--fp->fi_delegees == 0)
917                 swap(filp, fp->fi_deleg_file);
918         spin_unlock(&fp->fi_lock);
919
920         if (filp)
921                 fput(filp);
922 }
923
924 static void nfs4_unlock_deleg_lease(struct nfs4_delegation *dp)
925 {
926         struct nfs4_file *fp = dp->dl_stid.sc_file;
927         struct file *filp = fp->fi_deleg_file;
928
929         WARN_ON_ONCE(!fp->fi_delegees);
930
931         vfs_setlease(filp, F_UNLCK, NULL, (void **)&dp);
932         put_deleg_file(fp);
933 }
934
935 static void destroy_unhashed_deleg(struct nfs4_delegation *dp)
936 {
937         put_clnt_odstate(dp->dl_clnt_odstate);
938         nfs4_unlock_deleg_lease(dp);
939         nfs4_put_stid(&dp->dl_stid);
940 }
941
942 void nfs4_unhash_stid(struct nfs4_stid *s)
943 {
944         s->sc_type = 0;
945 }
946
947 /**
948  * nfs4_delegation_exists - Discover if this delegation already exists
949  * @clp:     a pointer to the nfs4_client we're granting a delegation to
950  * @fp:      a pointer to the nfs4_file we're granting a delegation on
951  *
952  * Return:
953  *      On success: true iff an existing delegation is found
954  */
955
956 static bool
957 nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp)
958 {
959         struct nfs4_delegation *searchdp = NULL;
960         struct nfs4_client *searchclp = NULL;
961
962         lockdep_assert_held(&state_lock);
963         lockdep_assert_held(&fp->fi_lock);
964
965         list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
966                 searchclp = searchdp->dl_stid.sc_client;
967                 if (clp == searchclp) {
968                         return true;
969                 }
970         }
971         return false;
972 }
973
974 /**
975  * hash_delegation_locked - Add a delegation to the appropriate lists
976  * @dp:     a pointer to the nfs4_delegation we are adding.
977  * @fp:     a pointer to the nfs4_file we're granting a delegation on
978  *
979  * Return:
980  *      On success: NULL if the delegation was successfully hashed.
981  *
982  *      On error: -EAGAIN if one was previously granted to this
983  *                 nfs4_client for this nfs4_file. Delegation is not hashed.
984  *
985  */
986
987 static int
988 hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
989 {
990         struct nfs4_client *clp = dp->dl_stid.sc_client;
991
992         lockdep_assert_held(&state_lock);
993         lockdep_assert_held(&fp->fi_lock);
994
995         if (nfs4_delegation_exists(clp, fp))
996                 return -EAGAIN;
997         refcount_inc(&dp->dl_stid.sc_count);
998         dp->dl_stid.sc_type = NFS4_DELEG_STID;
999         list_add(&dp->dl_perfile, &fp->fi_delegations);
1000         list_add(&dp->dl_perclnt, &clp->cl_delegations);
1001         return 0;
1002 }
1003
1004 static bool
1005 unhash_delegation_locked(struct nfs4_delegation *dp)
1006 {
1007         struct nfs4_file *fp = dp->dl_stid.sc_file;
1008
1009         lockdep_assert_held(&state_lock);
1010
1011         if (list_empty(&dp->dl_perfile))
1012                 return false;
1013
1014         dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
1015         /* Ensure that deleg break won't try to requeue it */
1016         ++dp->dl_time;
1017         spin_lock(&fp->fi_lock);
1018         list_del_init(&dp->dl_perclnt);
1019         list_del_init(&dp->dl_recall_lru);
1020         list_del_init(&dp->dl_perfile);
1021         spin_unlock(&fp->fi_lock);
1022         return true;
1023 }
1024
1025 static void destroy_delegation(struct nfs4_delegation *dp)
1026 {
1027         bool unhashed;
1028
1029         spin_lock(&state_lock);
1030         unhashed = unhash_delegation_locked(dp);
1031         spin_unlock(&state_lock);
1032         if (unhashed)
1033                 destroy_unhashed_deleg(dp);
1034 }
1035
1036 static void revoke_delegation(struct nfs4_delegation *dp)
1037 {
1038         struct nfs4_client *clp = dp->dl_stid.sc_client;
1039
1040         WARN_ON(!list_empty(&dp->dl_recall_lru));
1041
1042         if (clp->cl_minorversion) {
1043                 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
1044                 refcount_inc(&dp->dl_stid.sc_count);
1045                 spin_lock(&clp->cl_lock);
1046                 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
1047                 spin_unlock(&clp->cl_lock);
1048         }
1049         destroy_unhashed_deleg(dp);
1050 }
1051
1052 /* 
1053  * SETCLIENTID state 
1054  */
1055
1056 static unsigned int clientid_hashval(u32 id)
1057 {
1058         return id & CLIENT_HASH_MASK;
1059 }
1060
1061 static unsigned int clientstr_hashval(const char *name)
1062 {
1063         return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
1064 }
1065
1066 /*
1067  * We store the NONE, READ, WRITE, and BOTH bits separately in the
1068  * st_{access,deny}_bmap field of the stateid, in order to track not
1069  * only what share bits are currently in force, but also what
1070  * combinations of share bits previous opens have used.  This allows us
1071  * to enforce the recommendation of rfc 3530 14.2.19 that the server
1072  * return an error if the client attempt to downgrade to a combination
1073  * of share bits not explicable by closing some of its previous opens.
1074  *
1075  * XXX: This enforcement is actually incomplete, since we don't keep
1076  * track of access/deny bit combinations; so, e.g., we allow:
1077  *
1078  *      OPEN allow read, deny write
1079  *      OPEN allow both, deny none
1080  *      DOWNGRADE allow read, deny none
1081  *
1082  * which we should reject.
1083  */
1084 static unsigned int
1085 bmap_to_share_mode(unsigned long bmap) {
1086         int i;
1087         unsigned int access = 0;
1088
1089         for (i = 1; i < 4; i++) {
1090                 if (test_bit(i, &bmap))
1091                         access |= i;
1092         }
1093         return access;
1094 }
1095
1096 /* set share access for a given stateid */
1097 static inline void
1098 set_access(u32 access, struct nfs4_ol_stateid *stp)
1099 {
1100         unsigned char mask = 1 << access;
1101
1102         WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
1103         stp->st_access_bmap |= mask;
1104 }
1105
1106 /* clear share access for a given stateid */
1107 static inline void
1108 clear_access(u32 access, struct nfs4_ol_stateid *stp)
1109 {
1110         unsigned char mask = 1 << access;
1111
1112         WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
1113         stp->st_access_bmap &= ~mask;
1114 }
1115
1116 /* test whether a given stateid has access */
1117 static inline bool
1118 test_access(u32 access, struct nfs4_ol_stateid *stp)
1119 {
1120         unsigned char mask = 1 << access;
1121
1122         return (bool)(stp->st_access_bmap & mask);
1123 }
1124
1125 /* set share deny for a given stateid */
1126 static inline void
1127 set_deny(u32 deny, struct nfs4_ol_stateid *stp)
1128 {
1129         unsigned char mask = 1 << deny;
1130
1131         WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
1132         stp->st_deny_bmap |= mask;
1133 }
1134
1135 /* clear share deny for a given stateid */
1136 static inline void
1137 clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
1138 {
1139         unsigned char mask = 1 << deny;
1140
1141         WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
1142         stp->st_deny_bmap &= ~mask;
1143 }
1144
1145 /* test whether a given stateid is denying specific access */
1146 static inline bool
1147 test_deny(u32 deny, struct nfs4_ol_stateid *stp)
1148 {
1149         unsigned char mask = 1 << deny;
1150
1151         return (bool)(stp->st_deny_bmap & mask);
1152 }
1153
1154 static int nfs4_access_to_omode(u32 access)
1155 {
1156         switch (access & NFS4_SHARE_ACCESS_BOTH) {
1157         case NFS4_SHARE_ACCESS_READ:
1158                 return O_RDONLY;
1159         case NFS4_SHARE_ACCESS_WRITE:
1160                 return O_WRONLY;
1161         case NFS4_SHARE_ACCESS_BOTH:
1162                 return O_RDWR;
1163         }
1164         WARN_ON_ONCE(1);
1165         return O_RDONLY;
1166 }
1167
1168 /*
1169  * A stateid that had a deny mode associated with it is being released
1170  * or downgraded. Recalculate the deny mode on the file.
1171  */
1172 static void
1173 recalculate_deny_mode(struct nfs4_file *fp)
1174 {
1175         struct nfs4_ol_stateid *stp;
1176
1177         spin_lock(&fp->fi_lock);
1178         fp->fi_share_deny = 0;
1179         list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
1180                 fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap);
1181         spin_unlock(&fp->fi_lock);
1182 }
1183
1184 static void
1185 reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
1186 {
1187         int i;
1188         bool change = false;
1189
1190         for (i = 1; i < 4; i++) {
1191                 if ((i & deny) != i) {
1192                         change = true;
1193                         clear_deny(i, stp);
1194                 }
1195         }
1196
1197         /* Recalculate per-file deny mode if there was a change */
1198         if (change)
1199                 recalculate_deny_mode(stp->st_stid.sc_file);
1200 }
1201
1202 /* release all access and file references for a given stateid */
1203 static void
1204 release_all_access(struct nfs4_ol_stateid *stp)
1205 {
1206         int i;
1207         struct nfs4_file *fp = stp->st_stid.sc_file;
1208
1209         if (fp && stp->st_deny_bmap != 0)
1210                 recalculate_deny_mode(fp);
1211
1212         for (i = 1; i < 4; i++) {
1213                 if (test_access(i, stp))
1214                         nfs4_file_put_access(stp->st_stid.sc_file, i);
1215                 clear_access(i, stp);
1216         }
1217 }
1218
1219 static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
1220 {
1221         kfree(sop->so_owner.data);
1222         sop->so_ops->so_free(sop);
1223 }
1224
1225 static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
1226 {
1227         struct nfs4_client *clp = sop->so_client;
1228
1229         might_lock(&clp->cl_lock);
1230
1231         if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
1232                 return;
1233         sop->so_ops->so_unhash(sop);
1234         spin_unlock(&clp->cl_lock);
1235         nfs4_free_stateowner(sop);
1236 }
1237
1238 static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
1239 {
1240         struct nfs4_file *fp = stp->st_stid.sc_file;
1241
1242         lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);
1243
1244         if (list_empty(&stp->st_perfile))
1245                 return false;
1246
1247         spin_lock(&fp->fi_lock);
1248         list_del_init(&stp->st_perfile);
1249         spin_unlock(&fp->fi_lock);
1250         list_del(&stp->st_perstateowner);
1251         return true;
1252 }
1253
1254 static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
1255 {
1256         struct nfs4_ol_stateid *stp = openlockstateid(stid);
1257
1258         put_clnt_odstate(stp->st_clnt_odstate);
1259         release_all_access(stp);
1260         if (stp->st_stateowner)
1261                 nfs4_put_stateowner(stp->st_stateowner);
1262         kmem_cache_free(stateid_slab, stid);
1263 }
1264
1265 static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
1266 {
1267         struct nfs4_ol_stateid *stp = openlockstateid(stid);
1268         struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
1269         struct file *file;
1270
1271         file = find_any_file(stp->st_stid.sc_file);
1272         if (file)
1273                 filp_close(file, (fl_owner_t)lo);
1274         nfs4_free_ol_stateid(stid);
1275 }
1276
1277 /*
1278  * Put the persistent reference to an already unhashed generic stateid, while
1279  * holding the cl_lock. If it's the last reference, then put it onto the
1280  * reaplist for later destruction.
1281  */
1282 static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
1283                                        struct list_head *reaplist)
1284 {
1285         struct nfs4_stid *s = &stp->st_stid;
1286         struct nfs4_client *clp = s->sc_client;
1287
1288         lockdep_assert_held(&clp->cl_lock);
1289
1290         WARN_ON_ONCE(!list_empty(&stp->st_locks));
1291
1292         if (!refcount_dec_and_test(&s->sc_count)) {
1293                 wake_up_all(&close_wq);
1294                 return;
1295         }
1296
1297         idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
1298         list_add(&stp->st_locks, reaplist);
1299 }
1300
1301 static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
1302 {
1303         lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1304
1305         list_del_init(&stp->st_locks);
1306         nfs4_unhash_stid(&stp->st_stid);
1307         return unhash_ol_stateid(stp);
1308 }
1309
1310 static void release_lock_stateid(struct nfs4_ol_stateid *stp)
1311 {
1312         struct nfs4_client *clp = stp->st_stid.sc_client;
1313         bool unhashed;
1314
1315         spin_lock(&clp->cl_lock);
1316         unhashed = unhash_lock_stateid(stp);
1317         spin_unlock(&clp->cl_lock);
1318         if (unhashed)
1319                 nfs4_put_stid(&stp->st_stid);
1320 }
1321
1322 static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
1323 {
1324         struct nfs4_client *clp = lo->lo_owner.so_client;
1325
1326         lockdep_assert_held(&clp->cl_lock);
1327
1328         list_del_init(&lo->lo_owner.so_strhash);
1329 }
1330
1331 /*
1332  * Free a list of generic stateids that were collected earlier after being
1333  * fully unhashed.
1334  */
1335 static void
1336 free_ol_stateid_reaplist(struct list_head *reaplist)
1337 {
1338         struct nfs4_ol_stateid *stp;
1339         struct nfs4_file *fp;
1340
1341         might_sleep();
1342
1343         while (!list_empty(reaplist)) {
1344                 stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
1345                                        st_locks);
1346                 list_del(&stp->st_locks);
1347                 fp = stp->st_stid.sc_file;
1348                 stp->st_stid.sc_free(&stp->st_stid);
1349                 if (fp)
1350                         put_nfs4_file(fp);
1351         }
1352 }
1353
1354 static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
1355                                        struct list_head *reaplist)
1356 {
1357         struct nfs4_ol_stateid *stp;
1358
1359         lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);
1360
1361         while (!list_empty(&open_stp->st_locks)) {
1362                 stp = list_entry(open_stp->st_locks.next,
1363                                 struct nfs4_ol_stateid, st_locks);
1364                 WARN_ON(!unhash_lock_stateid(stp));
1365                 put_ol_stateid_locked(stp, reaplist);
1366         }
1367 }
1368
1369 static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
1370                                 struct list_head *reaplist)
1371 {
1372         bool unhashed;
1373
1374         lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1375
1376         unhashed = unhash_ol_stateid(stp);
1377         release_open_stateid_locks(stp, reaplist);
1378         return unhashed;
1379 }
1380
1381 static void release_open_stateid(struct nfs4_ol_stateid *stp)
1382 {
1383         LIST_HEAD(reaplist);
1384
1385         spin_lock(&stp->st_stid.sc_client->cl_lock);
1386         if (unhash_open_stateid(stp, &reaplist))
1387                 put_ol_stateid_locked(stp, &reaplist);
1388         spin_unlock(&stp->st_stid.sc_client->cl_lock);
1389         free_ol_stateid_reaplist(&reaplist);
1390 }
1391
1392 static void unhash_openowner_locked(struct nfs4_openowner *oo)
1393 {
1394         struct nfs4_client *clp = oo->oo_owner.so_client;
1395
1396         lockdep_assert_held(&clp->cl_lock);
1397
1398         list_del_init(&oo->oo_owner.so_strhash);
1399         list_del_init(&oo->oo_perclient);
1400 }
1401
1402 static void release_last_closed_stateid(struct nfs4_openowner *oo)
1403 {
1404         struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,
1405                                           nfsd_net_id);
1406         struct nfs4_ol_stateid *s;
1407
1408         spin_lock(&nn->client_lock);
1409         s = oo->oo_last_closed_stid;
1410         if (s) {
1411                 list_del_init(&oo->oo_close_lru);
1412                 oo->oo_last_closed_stid = NULL;
1413         }
1414         spin_unlock(&nn->client_lock);
1415         if (s)
1416                 nfs4_put_stid(&s->st_stid);
1417 }
1418
1419 static void release_openowner(struct nfs4_openowner *oo)
1420 {
1421         struct nfs4_ol_stateid *stp;
1422         struct nfs4_client *clp = oo->oo_owner.so_client;
1423         struct list_head reaplist;
1424
1425         INIT_LIST_HEAD(&reaplist);
1426
1427         spin_lock(&clp->cl_lock);
1428         unhash_openowner_locked(oo);
1429         while (!list_empty(&oo->oo_owner.so_stateids)) {
1430                 stp = list_first_entry(&oo->oo_owner.so_stateids,
1431                                 struct nfs4_ol_stateid, st_perstateowner);
1432                 if (unhash_open_stateid(stp, &reaplist))
1433                         put_ol_stateid_locked(stp, &reaplist);
1434         }
1435         spin_unlock(&clp->cl_lock);
1436         free_ol_stateid_reaplist(&reaplist);
1437         release_last_closed_stateid(oo);
1438         nfs4_put_stateowner(&oo->oo_owner);
1439 }
1440
1441 static inline int
1442 hash_sessionid(struct nfs4_sessionid *sessionid)
1443 {
1444         struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
1445
1446         return sid->sequence % SESSION_HASH_SIZE;
1447 }
1448
1449 #ifdef CONFIG_SUNRPC_DEBUG
1450 static inline void
1451 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1452 {
1453         u32 *ptr = (u32 *)(&sessionid->data[0]);
1454         dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
1455 }
1456 #else
1457 static inline void
1458 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1459 {
1460 }
1461 #endif
1462
1463 /*
1464  * Bump the seqid on cstate->replay_owner, and clear replay_owner if it
1465  * won't be used for replay.
1466  */
1467 void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
1468 {
1469         struct nfs4_stateowner *so = cstate->replay_owner;
1470
1471         if (nfserr == nfserr_replay_me)
1472                 return;
1473
1474         if (!seqid_mutating_err(ntohl(nfserr))) {
1475                 nfsd4_cstate_clear_replay(cstate);
1476                 return;
1477         }
1478         if (!so)
1479                 return;
1480         if (so->so_is_open_owner)
1481                 release_last_closed_stateid(openowner(so));
1482         so->so_seqid++;
1483         return;
1484 }
1485
1486 static void
1487 gen_sessionid(struct nfsd4_session *ses)
1488 {
1489         struct nfs4_client *clp = ses->se_client;
1490         struct nfsd4_sessionid *sid;
1491
1492         sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
1493         sid->clientid = clp->cl_clientid;
1494         sid->sequence = current_sessionid++;
1495         sid->reserved = 0;
1496 }
1497
1498 /*
1499  * The protocol defines ca_maxresponssize_cached to include the size of
1500  * the rpc header, but all we need to cache is the data starting after
1501  * the end of the initial SEQUENCE operation--the rest we regenerate
1502  * each time.  Therefore we can advertise a ca_maxresponssize_cached
1503  * value that is the number of bytes in our cache plus a few additional
1504  * bytes.  In order to stay on the safe side, and not promise more than
1505  * we can cache, those additional bytes must be the minimum possible: 24
1506  * bytes of rpc header (xid through accept state, with AUTH_NULL
1507  * verifier), 12 for the compound header (with zero-length tag), and 44
1508  * for the SEQUENCE op response:
1509  */
1510 #define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)
1511
1512 static void
1513 free_session_slots(struct nfsd4_session *ses)
1514 {
1515         int i;
1516
1517         for (i = 0; i < ses->se_fchannel.maxreqs; i++) {
1518                 free_svc_cred(&ses->se_slots[i]->sl_cred);
1519                 kfree(ses->se_slots[i]);
1520         }
1521 }
1522
1523 /*
1524  * We don't actually need to cache the rpc and session headers, so we
1525  * can allocate a little less for each slot:
1526  */
1527 static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
1528 {
1529         u32 size;
1530
1531         if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
1532                 size = 0;
1533         else
1534                 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
1535         return size + sizeof(struct nfsd4_slot);
1536 }
1537
1538 /*
1539  * XXX: If we run out of reserved DRC memory we could (up to a point)
1540  * re-negotiate active sessions and reduce their slot usage to make
1541  * room for new connections. For now we just fail the create session.
1542  */
1543 static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
1544 {
1545         u32 slotsize = slot_bytes(ca);
1546         u32 num = ca->maxreqs;
1547         int avail;
1548
1549         spin_lock(&nfsd_drc_lock);
1550         avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
1551                     nfsd_drc_max_mem - nfsd_drc_mem_used);
1552         /*
1553          * Never use more than a third of the remaining memory,
1554          * unless it's the only way to give this client a slot:
1555          */
1556         avail = clamp_t(int, avail, slotsize, avail/3);
1557         num = min_t(int, num, avail / slotsize);
1558         nfsd_drc_mem_used += num * slotsize;
1559         spin_unlock(&nfsd_drc_lock);
1560
1561         return num;
1562 }
1563
1564 static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
1565 {
1566         int slotsize = slot_bytes(ca);
1567
1568         spin_lock(&nfsd_drc_lock);
1569         nfsd_drc_mem_used -= slotsize * ca->maxreqs;
1570         spin_unlock(&nfsd_drc_lock);
1571 }
1572
1573 static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
1574                                            struct nfsd4_channel_attrs *battrs)
1575 {
1576         int numslots = fattrs->maxreqs;
1577         int slotsize = slot_bytes(fattrs);
1578         struct nfsd4_session *new;
1579         int mem, i;
1580
1581         BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
1582                         + sizeof(struct nfsd4_session) > PAGE_SIZE);
1583         mem = numslots * sizeof(struct nfsd4_slot *);
1584
1585         new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
1586         if (!new)
1587                 return NULL;
1588         /* allocate each struct nfsd4_slot and data cache in one piece */
1589         for (i = 0; i < numslots; i++) {
1590                 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
1591                 if (!new->se_slots[i])
1592                         goto out_free;
1593         }
1594
1595         memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
1596         memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
1597
1598         return new;
1599 out_free:
1600         while (i--)
1601                 kfree(new->se_slots[i]);
1602         kfree(new);
1603         return NULL;
1604 }
1605
1606 static void free_conn(struct nfsd4_conn *c)
1607 {
1608         svc_xprt_put(c->cn_xprt);
1609         kfree(c);
1610 }
1611
1612 static void nfsd4_conn_lost(struct svc_xpt_user *u)
1613 {
1614         struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
1615         struct nfs4_client *clp = c->cn_session->se_client;
1616
1617         spin_lock(&clp->cl_lock);
1618         if (!list_empty(&c->cn_persession)) {
1619                 list_del(&c->cn_persession);
1620                 free_conn(c);
1621         }
1622         nfsd4_probe_callback(clp);
1623         spin_unlock(&clp->cl_lock);
1624 }
1625
1626 static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
1627 {
1628         struct nfsd4_conn *conn;
1629
1630         conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
1631         if (!conn)
1632                 return NULL;
1633         svc_xprt_get(rqstp->rq_xprt);
1634         conn->cn_xprt = rqstp->rq_xprt;
1635         conn->cn_flags = flags;
1636         INIT_LIST_HEAD(&conn->cn_xpt_user.list);
1637         return conn;
1638 }
1639
1640 static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1641 {
1642         conn->cn_session = ses;
1643         list_add(&conn->cn_persession, &ses->se_conns);
1644 }
1645
1646 static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1647 {
1648         struct nfs4_client *clp = ses->se_client;
1649
1650         spin_lock(&clp->cl_lock);
1651         __nfsd4_hash_conn(conn, ses);
1652         spin_unlock(&clp->cl_lock);
1653 }
1654
1655 static int nfsd4_register_conn(struct nfsd4_conn *conn)
1656 {
1657         conn->cn_xpt_user.callback = nfsd4_conn_lost;
1658         return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
1659 }
1660
1661 static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
1662 {
1663         int ret;
1664
1665         nfsd4_hash_conn(conn, ses);
1666         ret = nfsd4_register_conn(conn);
1667         if (ret)
1668                 /* oops; xprt is already down: */
1669                 nfsd4_conn_lost(&conn->cn_xpt_user);
1670         /* We may have gained or lost a callback channel: */
1671         nfsd4_probe_callback_sync(ses->se_client);
1672 }
1673
1674 static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
1675 {
1676         u32 dir = NFS4_CDFC4_FORE;
1677
1678         if (cses->flags & SESSION4_BACK_CHAN)
1679                 dir |= NFS4_CDFC4_BACK;
1680         return alloc_conn(rqstp, dir);
1681 }
1682
1683 /* must be called under client_lock */
1684 static void nfsd4_del_conns(struct nfsd4_session *s)
1685 {
1686         struct nfs4_client *clp = s->se_client;
1687         struct nfsd4_conn *c;
1688
1689         spin_lock(&clp->cl_lock);
1690         while (!list_empty(&s->se_conns)) {
1691                 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
1692                 list_del_init(&c->cn_persession);
1693                 spin_unlock(&clp->cl_lock);
1694
1695                 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
1696                 free_conn(c);
1697
1698                 spin_lock(&clp->cl_lock);
1699         }
1700         spin_unlock(&clp->cl_lock);
1701 }
1702
1703 static void __free_session(struct nfsd4_session *ses)
1704 {
1705         free_session_slots(ses);
1706         kfree(ses);
1707 }
1708
1709 static void free_session(struct nfsd4_session *ses)
1710 {
1711         nfsd4_del_conns(ses);
1712         nfsd4_put_drc_mem(&ses->se_fchannel);
1713         __free_session(ses);
1714 }
1715
1716 static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
1717 {
1718         int idx;
1719         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1720
1721         new->se_client = clp;
1722         gen_sessionid(new);
1723
1724         INIT_LIST_HEAD(&new->se_conns);
1725
1726         new->se_cb_seq_nr = 1;
1727         new->se_flags = cses->flags;
1728         new->se_cb_prog = cses->callback_prog;
1729         new->se_cb_sec = cses->cb_sec;
1730         atomic_set(&new->se_ref, 0);
1731         idx = hash_sessionid(&new->se_sessionid);
1732         list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
1733         spin_lock(&clp->cl_lock);
1734         list_add(&new->se_perclnt, &clp->cl_sessions);
1735         spin_unlock(&clp->cl_lock);
1736
1737         {
1738                 struct sockaddr *sa = svc_addr(rqstp);
1739                 /*
1740                  * This is a little silly; with sessions there's no real
1741                  * use for the callback address.  Use the peer address
1742                  * as a reasonable default for now, but consider fixing
1743                  * the rpc client not to require an address in the
1744                  * future:
1745                  */
1746                 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1747                 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1748         }
1749 }
1750
1751 /* caller must hold client_lock */
1752 static struct nfsd4_session *
1753 __find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
1754 {
1755         struct nfsd4_session *elem;
1756         int idx;
1757         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1758
1759         lockdep_assert_held(&nn->client_lock);
1760
1761         dump_sessionid(__func__, sessionid);
1762         idx = hash_sessionid(sessionid);
1763         /* Search in the appropriate list */
1764         list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
1765                 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1766                             NFS4_MAX_SESSIONID_LEN)) {
1767                         return elem;
1768                 }
1769         }
1770
1771         dprintk("%s: session not found\n", __func__);
1772         return NULL;
1773 }
1774
1775 static struct nfsd4_session *
1776 find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
1777                 __be32 *ret)
1778 {
1779         struct nfsd4_session *session;
1780         __be32 status = nfserr_badsession;
1781
1782         session = __find_in_sessionid_hashtbl(sessionid, net);
1783         if (!session)
1784                 goto out;
1785         status = nfsd4_get_session_locked(session);
1786         if (status)
1787                 session = NULL;
1788 out:
1789         *ret = status;
1790         return session;
1791 }
1792
1793 /* caller must hold client_lock */
1794 static void
1795 unhash_session(struct nfsd4_session *ses)
1796 {
1797         struct nfs4_client *clp = ses->se_client;
1798         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1799
1800         lockdep_assert_held(&nn->client_lock);
1801
1802         list_del(&ses->se_hash);
1803         spin_lock(&ses->se_client->cl_lock);
1804         list_del(&ses->se_perclnt);
1805         spin_unlock(&ses->se_client->cl_lock);
1806 }
1807
1808 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
1809 static int
1810 STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
1811 {
1812         /*
1813          * We're assuming the clid was not given out from a boot
1814          * precisely 2^32 (about 136 years) before this one.  That seems
1815          * a safe assumption:
1816          */
1817         if (clid->cl_boot == (u32)nn->boot_time)
1818                 return 0;
1819         dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1820                 clid->cl_boot, clid->cl_id, nn->boot_time);
1821         return 1;
1822 }
1823
1824 /* 
1825  * XXX Should we use a slab cache ?
1826  * This type of memory management is somewhat inefficient, but we use it
1827  * anyway since SETCLIENTID is not a common operation.
1828  */
1829 static struct nfs4_client *alloc_client(struct xdr_netobj name)
1830 {
1831         struct nfs4_client *clp;
1832         int i;
1833
1834         clp = kmem_cache_zalloc(client_slab, GFP_KERNEL);
1835         if (clp == NULL)
1836                 return NULL;
1837         clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
1838         if (clp->cl_name.data == NULL)
1839                 goto err_no_name;
1840         clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE,
1841                                                  sizeof(struct list_head),
1842                                                  GFP_KERNEL);
1843         if (!clp->cl_ownerstr_hashtbl)
1844                 goto err_no_hashtbl;
1845         for (i = 0; i < OWNER_HASH_SIZE; i++)
1846                 INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
1847         clp->cl_name.len = name.len;
1848         INIT_LIST_HEAD(&clp->cl_sessions);
1849         idr_init(&clp->cl_stateids);
1850         atomic_set(&clp->cl_refcount, 0);
1851         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1852         INIT_LIST_HEAD(&clp->cl_idhash);
1853         INIT_LIST_HEAD(&clp->cl_openowners);
1854         INIT_LIST_HEAD(&clp->cl_delegations);
1855         INIT_LIST_HEAD(&clp->cl_lru);
1856         INIT_LIST_HEAD(&clp->cl_revoked);
1857 #ifdef CONFIG_NFSD_PNFS
1858         INIT_LIST_HEAD(&clp->cl_lo_states);
1859 #endif
1860         INIT_LIST_HEAD(&clp->async_copies);
1861         spin_lock_init(&clp->async_lock);
1862         spin_lock_init(&clp->cl_lock);
1863         rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1864         return clp;
1865 err_no_hashtbl:
1866         kfree(clp->cl_name.data);
1867 err_no_name:
1868         kmem_cache_free(client_slab, clp);
1869         return NULL;
1870 }
1871
1872 static void
1873 free_client(struct nfs4_client *clp)
1874 {
1875         while (!list_empty(&clp->cl_sessions)) {
1876                 struct nfsd4_session *ses;
1877                 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1878                                 se_perclnt);
1879                 list_del(&ses->se_perclnt);
1880                 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1881                 free_session(ses);
1882         }
1883         rpc_destroy_wait_queue(&clp->cl_cb_waitq);
1884         free_svc_cred(&clp->cl_cred);
1885         kfree(clp->cl_ownerstr_hashtbl);
1886         kfree(clp->cl_name.data);
1887         idr_destroy(&clp->cl_stateids);
1888         kmem_cache_free(client_slab, clp);
1889 }
1890
1891 /* must be called under the client_lock */
1892 static void
1893 unhash_client_locked(struct nfs4_client *clp)
1894 {
1895         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1896         struct nfsd4_session *ses;
1897
1898         lockdep_assert_held(&nn->client_lock);
1899
1900         /* Mark the client as expired! */
1901         clp->cl_time = 0;
1902         /* Make it invisible */
1903         if (!list_empty(&clp->cl_idhash)) {
1904                 list_del_init(&clp->cl_idhash);
1905                 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
1906                         rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
1907                 else
1908                         rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1909         }
1910         list_del_init(&clp->cl_lru);
1911         spin_lock(&clp->cl_lock);
1912         list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1913                 list_del_init(&ses->se_hash);
1914         spin_unlock(&clp->cl_lock);
1915 }
1916
1917 static void
1918 unhash_client(struct nfs4_client *clp)
1919 {
1920         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1921
1922         spin_lock(&nn->client_lock);
1923         unhash_client_locked(clp);
1924         spin_unlock(&nn->client_lock);
1925 }
1926
1927 static __be32 mark_client_expired_locked(struct nfs4_client *clp)
1928 {
1929         if (atomic_read(&clp->cl_refcount))
1930                 return nfserr_jukebox;
1931         unhash_client_locked(clp);
1932         return nfs_ok;
1933 }
1934
1935 static void
1936 __destroy_client(struct nfs4_client *clp)
1937 {
1938         int i;
1939         struct nfs4_openowner *oo;
1940         struct nfs4_delegation *dp;
1941         struct list_head reaplist;
1942
1943         INIT_LIST_HEAD(&reaplist);
1944         spin_lock(&state_lock);
1945         while (!list_empty(&clp->cl_delegations)) {
1946                 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
1947                 WARN_ON(!unhash_delegation_locked(dp));
1948                 list_add(&dp->dl_recall_lru, &reaplist);
1949         }
1950         spin_unlock(&state_lock);
1951         while (!list_empty(&reaplist)) {
1952                 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1953                 list_del_init(&dp->dl_recall_lru);
1954                 destroy_unhashed_deleg(dp);
1955         }
1956         while (!list_empty(&clp->cl_revoked)) {
1957                 dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
1958                 list_del_init(&dp->dl_recall_lru);
1959                 nfs4_put_stid(&dp->dl_stid);
1960         }
1961         while (!list_empty(&clp->cl_openowners)) {
1962                 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1963                 nfs4_get_stateowner(&oo->oo_owner);
1964                 release_openowner(oo);
1965         }
1966         for (i = 0; i < OWNER_HASH_SIZE; i++) {
1967                 struct nfs4_stateowner *so, *tmp;
1968
1969                 list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i],
1970                                          so_strhash) {
1971                         /* Should be no openowners at this point */
1972                         WARN_ON_ONCE(so->so_is_open_owner);
1973                         remove_blocked_locks(lockowner(so));
1974                 }
1975         }
1976         nfsd4_return_all_client_layouts(clp);
1977         nfsd4_shutdown_copy(clp);
1978         nfsd4_shutdown_callback(clp);
1979         if (clp->cl_cb_conn.cb_xprt)
1980                 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1981         free_client(clp);
1982 }
1983
1984 static void
1985 destroy_client(struct nfs4_client *clp)
1986 {
1987         unhash_client(clp);
1988         __destroy_client(clp);
1989 }
1990
1991 static void expire_client(struct nfs4_client *clp)
1992 {
1993         unhash_client(clp);
1994         nfsd4_client_record_remove(clp);
1995         __destroy_client(clp);
1996 }
1997
1998 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1999 {
2000         memcpy(target->cl_verifier.data, source->data,
2001                         sizeof(target->cl_verifier.data));
2002 }
2003
2004 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
2005 {
2006         target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
2007         target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
2008 }
2009
2010 static int copy_cred(struct svc_cred *target, struct svc_cred *source)
2011 {
2012         target->cr_principal = kstrdup(source->cr_principal, GFP_KERNEL);
2013         target->cr_raw_principal = kstrdup(source->cr_raw_principal,
2014                                                                 GFP_KERNEL);
2015         target->cr_targ_princ = kstrdup(source->cr_targ_princ, GFP_KERNEL);
2016         if ((source->cr_principal && !target->cr_principal) ||
2017             (source->cr_raw_principal && !target->cr_raw_principal) ||
2018             (source->cr_targ_princ && !target->cr_targ_princ))
2019                 return -ENOMEM;
2020
2021         target->cr_flavor = source->cr_flavor;
2022         target->cr_uid = source->cr_uid;
2023         target->cr_gid = source->cr_gid;
2024         target->cr_group_info = source->cr_group_info;
2025         get_group_info(target->cr_group_info);
2026         target->cr_gss_mech = source->cr_gss_mech;
2027         if (source->cr_gss_mech)
2028                 gss_mech_get(source->cr_gss_mech);
2029         return 0;
2030 }
2031
2032 static int
2033 compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
2034 {
2035         if (o1->len < o2->len)
2036                 return -1;
2037         if (o1->len > o2->len)
2038                 return 1;
2039         return memcmp(o1->data, o2->data, o1->len);
2040 }
2041
2042 static int same_name(const char *n1, const char *n2)
2043 {
2044         return 0 == memcmp(n1, n2, HEXDIR_LEN);
2045 }
2046
2047 static int
2048 same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
2049 {
2050         return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
2051 }
2052
2053 static int
2054 same_clid(clientid_t *cl1, clientid_t *cl2)
2055 {
2056         return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
2057 }
2058
2059 static bool groups_equal(struct group_info *g1, struct group_info *g2)
2060 {
2061         int i;
2062
2063         if (g1->ngroups != g2->ngroups)
2064                 return false;
2065         for (i=0; i<g1->ngroups; i++)
2066                 if (!gid_eq(g1->gid[i], g2->gid[i]))
2067                         return false;
2068         return true;
2069 }
2070
2071 /*
2072  * RFC 3530 language requires clid_inuse be returned when the
2073  * "principal" associated with a requests differs from that previously
2074  * used.  We use uid, gid's, and gss principal string as our best
2075  * approximation.  We also don't want to allow non-gss use of a client
2076  * established using gss: in theory cr_principal should catch that
2077  * change, but in practice cr_principal can be null even in the gss case
2078  * since gssd doesn't always pass down a principal string.
2079  */
2080 static bool is_gss_cred(struct svc_cred *cr)
2081 {
2082         /* Is cr_flavor one of the gss "pseudoflavors"?: */
2083         return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
2084 }
2085
2086
2087 static bool
2088 same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
2089 {
2090         if ((is_gss_cred(cr1) != is_gss_cred(cr2))
2091                 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
2092                 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
2093                 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
2094                 return false;
2095         /* XXX: check that cr_targ_princ fields match ? */
2096         if (cr1->cr_principal == cr2->cr_principal)
2097                 return true;
2098         if (!cr1->cr_principal || !cr2->cr_principal)
2099                 return false;
2100         return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
2101 }
2102
2103 static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
2104 {
2105         struct svc_cred *cr = &rqstp->rq_cred;
2106         u32 service;
2107
2108         if (!cr->cr_gss_mech)
2109                 return false;
2110         service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
2111         return service == RPC_GSS_SVC_INTEGRITY ||
2112                service == RPC_GSS_SVC_PRIVACY;
2113 }
2114
2115 bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
2116 {
2117         struct svc_cred *cr = &rqstp->rq_cred;
2118
2119         if (!cl->cl_mach_cred)
2120                 return true;
2121         if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
2122                 return false;
2123         if (!svc_rqst_integrity_protected(rqstp))
2124                 return false;
2125         if (cl->cl_cred.cr_raw_principal)
2126                 return 0 == strcmp(cl->cl_cred.cr_raw_principal,
2127                                                 cr->cr_raw_principal);
2128         if (!cr->cr_principal)
2129                 return false;
2130         return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
2131 }
2132
2133 static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
2134 {
2135         __be32 verf[2];
2136
2137         /*
2138          * This is opaque to client, so no need to byte-swap. Use
2139          * __force to keep sparse happy
2140          */
2141         verf[0] = (__force __be32)get_seconds();
2142         verf[1] = (__force __be32)nn->clverifier_counter++;
2143         memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
2144 }
2145
2146 static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
2147 {
2148         clp->cl_clientid.cl_boot = nn->boot_time;
2149         clp->cl_clientid.cl_id = nn->clientid_counter++;
2150         gen_confirm(clp, nn);
2151 }
2152
2153 static struct nfs4_stid *
2154 find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
2155 {
2156         struct nfs4_stid *ret;
2157
2158         ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
2159         if (!ret || !ret->sc_type)
2160                 return NULL;
2161         return ret;
2162 }
2163
2164 static struct nfs4_stid *
2165 find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
2166 {
2167         struct nfs4_stid *s;
2168
2169         spin_lock(&cl->cl_lock);
2170         s = find_stateid_locked(cl, t);
2171         if (s != NULL) {
2172                 if (typemask & s->sc_type)
2173                         refcount_inc(&s->sc_count);
2174                 else
2175                         s = NULL;
2176         }
2177         spin_unlock(&cl->cl_lock);
2178         return s;
2179 }
2180
2181 static struct nfs4_client *create_client(struct xdr_netobj name,
2182                 struct svc_rqst *rqstp, nfs4_verifier *verf)
2183 {
2184         struct nfs4_client *clp;
2185         struct sockaddr *sa = svc_addr(rqstp);
2186         int ret;
2187         struct net *net = SVC_NET(rqstp);
2188
2189         clp = alloc_client(name);
2190         if (clp == NULL)
2191                 return NULL;
2192
2193         ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
2194         if (ret) {
2195                 free_client(clp);
2196                 return NULL;
2197         }
2198         nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
2199         clp->cl_time = get_seconds();
2200         clear_bit(0, &clp->cl_cb_slot_busy);
2201         copy_verf(clp, verf);
2202         rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
2203         clp->cl_cb_session = NULL;
2204         clp->net = net;
2205         return clp;
2206 }
2207
2208 static void
2209 add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
2210 {
2211         struct rb_node **new = &(root->rb_node), *parent = NULL;
2212         struct nfs4_client *clp;
2213
2214         while (*new) {
2215                 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
2216                 parent = *new;
2217
2218                 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
2219                         new = &((*new)->rb_left);
2220                 else
2221                         new = &((*new)->rb_right);
2222         }
2223
2224         rb_link_node(&new_clp->cl_namenode, parent, new);
2225         rb_insert_color(&new_clp->cl_namenode, root);
2226 }
2227
2228 static struct nfs4_client *
2229 find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
2230 {
2231         int cmp;
2232         struct rb_node *node = root->rb_node;
2233         struct nfs4_client *clp;
2234
2235         while (node) {
2236                 clp = rb_entry(node, struct nfs4_client, cl_namenode);
2237                 cmp = compare_blob(&clp->cl_name, name);
2238                 if (cmp > 0)
2239                         node = node->rb_left;
2240                 else if (cmp < 0)
2241                         node = node->rb_right;
2242                 else
2243                         return clp;
2244         }
2245         return NULL;
2246 }
2247
2248 static void
2249 add_to_unconfirmed(struct nfs4_client *clp)
2250 {
2251         unsigned int idhashval;
2252         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2253
2254         lockdep_assert_held(&nn->client_lock);
2255
2256         clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2257         add_clp_to_name_tree(clp, &nn->unconf_name_tree);
2258         idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2259         list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
2260         renew_client_locked(clp);
2261 }
2262
2263 static void
2264 move_to_confirmed(struct nfs4_client *clp)
2265 {
2266         unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2267         struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2268
2269         lockdep_assert_held(&nn->client_lock);
2270
2271         dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
2272         list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
2273         rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2274         add_clp_to_name_tree(clp, &nn->conf_name_tree);
2275         set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2276         renew_client_locked(clp);
2277 }
2278
2279 static struct nfs4_client *
2280 find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
2281 {
2282         struct nfs4_client *clp;
2283         unsigned int idhashval = clientid_hashval(clid->cl_id);
2284
2285         list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
2286                 if (same_clid(&clp->cl_clientid, clid)) {
2287                         if ((bool)clp->cl_minorversion != sessions)
2288                                 return NULL;
2289                         renew_client_locked(clp);
2290                         return clp;
2291                 }
2292         }
2293         return NULL;
2294 }
2295
2296 static struct nfs4_client *
2297 find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2298 {
2299         struct list_head *tbl = nn->conf_id_hashtbl;
2300
2301         lockdep_assert_held(&nn->client_lock);
2302         return find_client_in_id_table(tbl, clid, sessions);
2303 }
2304
2305 static struct nfs4_client *
2306 find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2307 {
2308         struct list_head *tbl = nn->unconf_id_hashtbl;
2309
2310         lockdep_assert_held(&nn->client_lock);
2311         return find_client_in_id_table(tbl, clid, sessions);
2312 }
2313
2314 static bool clp_used_exchangeid(struct nfs4_client *clp)
2315 {
2316         return clp->cl_exchange_flags != 0;
2317
2318
2319 static struct nfs4_client *
2320 find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
2321 {
2322         lockdep_assert_held(&nn->client_lock);
2323         return find_clp_in_name_tree(name, &nn->conf_name_tree);
2324 }
2325
2326 static struct nfs4_client *
2327 find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
2328 {
2329         lockdep_assert_held(&nn->client_lock);
2330         return find_clp_in_name_tree(name, &nn->unconf_name_tree);
2331 }
2332
2333 static void
2334 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
2335 {
2336         struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
2337         struct sockaddr *sa = svc_addr(rqstp);
2338         u32 scopeid = rpc_get_scope_id(sa);
2339         unsigned short expected_family;
2340
2341         /* Currently, we only support tcp and tcp6 for the callback channel */
2342         if (se->se_callback_netid_len == 3 &&
2343             !memcmp(se->se_callback_netid_val, "tcp", 3))
2344                 expected_family = AF_INET;
2345         else if (se->se_callback_netid_len == 4 &&
2346                  !memcmp(se->se_callback_netid_val, "tcp6", 4))
2347                 expected_family = AF_INET6;
2348         else
2349                 goto out_err;
2350
2351         conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
2352                                             se->se_callback_addr_len,
2353                                             (struct sockaddr *)&conn->cb_addr,
2354                                             sizeof(conn->cb_addr));
2355
2356         if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
2357                 goto out_err;
2358
2359         if (conn->cb_addr.ss_family == AF_INET6)
2360                 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
2361
2362         conn->cb_prog = se->se_callback_prog;
2363         conn->cb_ident = se->se_callback_ident;
2364         memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
2365         return;
2366 out_err:
2367         conn->cb_addr.ss_family = AF_UNSPEC;
2368         conn->cb_addrlen = 0;
2369         dprintk("NFSD: this client (clientid %08x/%08x) "
2370                 "will not receive delegations\n",
2371                 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
2372
2373         return;
2374 }
2375
2376 /*
2377  * Cache a reply. nfsd4_check_resp_size() has bounded the cache size.
2378  */
2379 static void
2380 nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
2381 {
2382         struct xdr_buf *buf = resp->xdr.buf;
2383         struct nfsd4_slot *slot = resp->cstate.slot;
2384         unsigned int base;
2385
2386         dprintk("--> %s slot %p\n", __func__, slot);
2387
2388         slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
2389         slot->sl_opcnt = resp->opcnt;
2390         slot->sl_status = resp->cstate.status;
2391         free_svc_cred(&slot->sl_cred);
2392         copy_cred(&slot->sl_cred, &resp->rqstp->rq_cred);
2393
2394         if (!nfsd4_cache_this(resp)) {
2395                 slot->sl_flags &= ~NFSD4_SLOT_CACHED;
2396                 return;
2397         }
2398         slot->sl_flags |= NFSD4_SLOT_CACHED;
2399
2400         base = resp->cstate.data_offset;
2401         slot->sl_datalen = buf->len - base;
2402         if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
2403                 WARN(1, "%s: sessions DRC could not cache compound\n",
2404                      __func__);
2405         return;
2406 }
2407
2408 /*
2409  * Encode the replay sequence operation from the slot values.
2410  * If cachethis is FALSE encode the uncached rep error on the next
2411  * operation which sets resp->p and increments resp->opcnt for
2412  * nfs4svc_encode_compoundres.
2413  *
2414  */
2415 static __be32
2416 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
2417                           struct nfsd4_compoundres *resp)
2418 {
2419         struct nfsd4_op *op;
2420         struct nfsd4_slot *slot = resp->cstate.slot;
2421
2422         /* Encode the replayed sequence operation */
2423         op = &args->ops[resp->opcnt - 1];
2424         nfsd4_encode_operation(resp, op);
2425
2426         if (slot->sl_flags & NFSD4_SLOT_CACHED)
2427                 return op->status;
2428         if (args->opcnt == 1) {
2429                 /*
2430                  * The original operation wasn't a solo sequence--we
2431                  * always cache those--so this retry must not match the
2432                  * original:
2433                  */
2434                 op->status = nfserr_seq_false_retry;
2435         } else {
2436                 op = &args->ops[resp->opcnt++];
2437                 op->status = nfserr_retry_uncached_rep;
2438                 nfsd4_encode_operation(resp, op);
2439         }
2440         return op->status;
2441 }
2442
2443 /*
2444  * The sequence operation is not cached because we can use the slot and
2445  * session values.
2446  */
2447 static __be32
2448 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
2449                          struct nfsd4_sequence *seq)
2450 {
2451         struct nfsd4_slot *slot = resp->cstate.slot;
2452         struct xdr_stream *xdr = &resp->xdr;
2453         __be32 *p;
2454         __be32 status;
2455
2456         dprintk("--> %s slot %p\n", __func__, slot);
2457
2458         status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
2459         if (status)
2460                 return status;
2461
2462         p = xdr_reserve_space(xdr, slot->sl_datalen);
2463         if (!p) {
2464                 WARN_ON_ONCE(1);
2465                 return nfserr_serverfault;
2466         }
2467         xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
2468         xdr_commit_encode(xdr);
2469
2470         resp->opcnt = slot->sl_opcnt;
2471         return slot->sl_status;
2472 }
2473
2474 /*
2475  * Set the exchange_id flags returned by the server.
2476  */
2477 static void
2478 nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
2479 {
2480 #ifdef CONFIG_NFSD_PNFS
2481         new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
2482 #else
2483         new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
2484 #endif
2485
2486         /* Referrals are supported, Migration is not. */
2487         new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
2488
2489         /* set the wire flags to return to client. */
2490         clid->flags = new->cl_exchange_flags;
2491 }
2492
2493 static bool client_has_openowners(struct nfs4_client *clp)
2494 {
2495         struct nfs4_openowner *oo;
2496
2497         list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
2498                 if (!list_empty(&oo->oo_owner.so_stateids))
2499                         return true;
2500         }
2501         return false;
2502 }
2503
2504 static bool client_has_state(struct nfs4_client *clp)
2505 {
2506         return client_has_openowners(clp)
2507 #ifdef CONFIG_NFSD_PNFS
2508                 || !list_empty(&clp->cl_lo_states)
2509 #endif
2510                 || !list_empty(&clp->cl_delegations)
2511                 || !list_empty(&clp->cl_sessions)
2512                 || !list_empty(&clp->async_copies);
2513 }
2514
2515 __be32
2516 nfsd4_exchange_id(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2517                 union nfsd4_op_u *u)
2518 {
2519         struct nfsd4_exchange_id *exid = &u->exchange_id;
2520         struct nfs4_client *conf, *new;
2521         struct nfs4_client *unconf = NULL;
2522         __be32 status;
2523         char                    addr_str[INET6_ADDRSTRLEN];
2524         nfs4_verifier           verf = exid->verifier;
2525         struct sockaddr         *sa = svc_addr(rqstp);
2526         bool    update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
2527         struct nfsd_net         *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2528
2529         rpc_ntop(sa, addr_str, sizeof(addr_str));
2530         dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
2531                 "ip_addr=%s flags %x, spa_how %d\n",
2532                 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
2533                 addr_str, exid->flags, exid->spa_how);
2534
2535         if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
2536                 return nfserr_inval;
2537
2538         new = create_client(exid->clname, rqstp, &verf);
2539         if (new == NULL)
2540                 return nfserr_jukebox;
2541
2542         switch (exid->spa_how) {
2543         case SP4_MACH_CRED:
2544                 exid->spo_must_enforce[0] = 0;
2545                 exid->spo_must_enforce[1] = (
2546                         1 << (OP_BIND_CONN_TO_SESSION - 32) |
2547                         1 << (OP_EXCHANGE_ID - 32) |
2548                         1 << (OP_CREATE_SESSION - 32) |
2549                         1 << (OP_DESTROY_SESSION - 32) |
2550                         1 << (OP_DESTROY_CLIENTID - 32));
2551
2552                 exid->spo_must_allow[0] &= (1 << (OP_CLOSE) |
2553                                         1 << (OP_OPEN_DOWNGRADE) |
2554                                         1 << (OP_LOCKU) |
2555                                         1 << (OP_DELEGRETURN));
2556
2557                 exid->spo_must_allow[1] &= (
2558                                         1 << (OP_TEST_STATEID - 32) |
2559                                         1 << (OP_FREE_STATEID - 32));
2560                 if (!svc_rqst_integrity_protected(rqstp)) {
2561                         status = nfserr_inval;
2562                         goto out_nolock;
2563                 }
2564                 /*
2565                  * Sometimes userspace doesn't give us a principal.
2566                  * Which is a bug, really.  Anyway, we can't enforce
2567                  * MACH_CRED in that case, better to give up now:
2568                  */
2569                 if (!new->cl_cred.cr_principal &&
2570                                         !new->cl_cred.cr_raw_principal) {
2571                         status = nfserr_serverfault;
2572                         goto out_nolock;
2573                 }
2574                 new->cl_mach_cred = true;
2575         case SP4_NONE:
2576                 break;
2577         default:                                /* checked by xdr code */
2578                 WARN_ON_ONCE(1);
2579         case SP4_SSV:
2580                 status = nfserr_encr_alg_unsupp;
2581                 goto out_nolock;
2582         }
2583
2584         /* Cases below refer to rfc 5661 section 18.35.4: */
2585         spin_lock(&nn->client_lock);
2586         conf = find_confirmed_client_by_name(&exid->clname, nn);
2587         if (conf) {
2588                 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
2589                 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
2590
2591                 if (update) {
2592                         if (!clp_used_exchangeid(conf)) { /* buggy client */
2593                                 status = nfserr_inval;
2594                                 goto out;
2595                         }
2596                         if (!nfsd4_mach_creds_match(conf, rqstp)) {
2597                                 status = nfserr_wrong_cred;
2598                                 goto out;
2599                         }
2600                         if (!creds_match) { /* case 9 */
2601                                 status = nfserr_perm;
2602                                 goto out;
2603                         }
2604                         if (!verfs_match) { /* case 8 */
2605                                 status = nfserr_not_same;
2606                                 goto out;
2607                         }
2608                         /* case 6 */
2609                         exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
2610                         goto out_copy;
2611                 }
2612                 if (!creds_match) { /* case 3 */
2613                         if (client_has_state(conf)) {
2614                                 status = nfserr_clid_inuse;
2615                                 goto out;
2616                         }
2617                         goto out_new;
2618                 }
2619                 if (verfs_match) { /* case 2 */
2620                         conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
2621                         goto out_copy;
2622                 }
2623                 /* case 5, client reboot */
2624                 conf = NULL;
2625                 goto out_new;
2626         }
2627
2628         if (update) { /* case 7 */
2629                 status = nfserr_noent;
2630                 goto out;
2631         }
2632
2633         unconf  = find_unconfirmed_client_by_name(&exid->clname, nn);
2634         if (unconf) /* case 4, possible retry or client restart */
2635                 unhash_client_locked(unconf);
2636
2637         /* case 1 (normal case) */
2638 out_new:
2639         if (conf) {
2640                 status = mark_client_expired_locked(conf);
2641                 if (status)
2642                         goto out;
2643         }
2644         new->cl_minorversion = cstate->minorversion;
2645         new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
2646         new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];
2647
2648         gen_clid(new, nn);
2649         add_to_unconfirmed(new);
2650         swap(new, conf);
2651 out_copy:
2652         exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
2653         exid->clientid.cl_id = conf->cl_clientid.cl_id;
2654
2655         exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
2656         nfsd4_set_ex_flags(conf, exid);
2657
2658         dprintk("nfsd4_exchange_id seqid %d flags %x\n",
2659                 conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
2660         status = nfs_ok;
2661
2662 out:
2663         spin_unlock(&nn->client_lock);
2664 out_nolock:
2665         if (new)
2666                 expire_client(new);
2667         if (unconf)
2668                 expire_client(unconf);
2669         return status;
2670 }
2671
2672 static __be32
2673 check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
2674 {
2675         dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
2676                 slot_seqid);
2677
2678         /* The slot is in use, and no response has been sent. */
2679         if (slot_inuse) {
2680                 if (seqid == slot_seqid)
2681                         return nfserr_jukebox;
2682                 else
2683                         return nfserr_seq_misordered;
2684         }
2685         /* Note unsigned 32-bit arithmetic handles wraparound: */
2686         if (likely(seqid == slot_seqid + 1))
2687                 return nfs_ok;
2688         if (seqid == slot_seqid)
2689                 return nfserr_replay_cache;
2690         return nfserr_seq_misordered;
2691 }
2692
2693 /*
2694  * Cache the create session result into the create session single DRC
2695  * slot cache by saving the xdr structure. sl_seqid has been set.
2696  * Do this for solo or embedded create session operations.
2697  */
2698 static void
2699 nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
2700                            struct nfsd4_clid_slot *slot, __be32 nfserr)
2701 {
2702         slot->sl_status = nfserr;
2703         memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
2704 }
2705
2706 static __be32
2707 nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
2708                             struct nfsd4_clid_slot *slot)
2709 {
2710         memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
2711         return slot->sl_status;
2712 }
2713
2714 #define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
2715                         2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
2716                         1 +     /* MIN tag is length with zero, only length */ \
2717                         3 +     /* version, opcount, opcode */ \
2718                         XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2719                                 /* seqid, slotID, slotID, cache */ \
2720                         4 ) * sizeof(__be32))
2721
2722 #define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
2723                         2 +     /* verifier: AUTH_NULL, length 0 */\
2724                         1 +     /* status */ \
2725                         1 +     /* MIN tag is length with zero, only length */ \
2726                         3 +     /* opcount, opcode, opstatus*/ \
2727                         XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
2728                                 /* seqid, slotID, slotID, slotID, status */ \
2729                         5 ) * sizeof(__be32))
2730
2731 static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
2732 {
2733         u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
2734
2735         if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
2736                 return nfserr_toosmall;
2737         if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
2738                 return nfserr_toosmall;
2739         ca->headerpadsz = 0;
2740         ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
2741         ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
2742         ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
2743         ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
2744                         NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
2745         ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
2746         /*
2747          * Note decreasing slot size below client's request may make it
2748          * difficult for client to function correctly, whereas
2749          * decreasing the number of slots will (just?) affect
2750          * performance.  When short on memory we therefore prefer to
2751          * decrease number of slots instead of their size.  Clients that
2752          * request larger slots than they need will get poor results:
2753          */
2754         ca->maxreqs = nfsd4_get_drc_mem(ca);
2755         if (!ca->maxreqs)
2756                 return nfserr_jukebox;
2757
2758         return nfs_ok;
2759 }
2760
2761 /*
2762  * Server's NFSv4.1 backchannel support is AUTH_SYS-only for now.
2763  * These are based on similar macros in linux/sunrpc/msg_prot.h .
2764  */
2765 #define RPC_MAX_HEADER_WITH_AUTH_SYS \
2766         (RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK))
2767
2768 #define RPC_MAX_REPHEADER_WITH_AUTH_SYS \
2769         (RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK))
2770
2771 #define NFSD_CB_MAX_REQ_SZ      ((NFS4_enc_cb_recall_sz + \
2772                                  RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32))
2773 #define NFSD_CB_MAX_RESP_SZ     ((NFS4_dec_cb_recall_sz + \
2774                                  RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \
2775                                  sizeof(__be32))
2776
2777 static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
2778 {
2779         ca->headerpadsz = 0;
2780
2781         if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
2782                 return nfserr_toosmall;
2783         if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
2784                 return nfserr_toosmall;
2785         ca->maxresp_cached = 0;
2786         if (ca->maxops < 2)
2787                 return nfserr_toosmall;
2788
2789         return nfs_ok;
2790 }
2791
2792 static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
2793 {
2794         switch (cbs->flavor) {
2795         case RPC_AUTH_NULL:
2796         case RPC_AUTH_UNIX:
2797                 return nfs_ok;
2798         default:
2799                 /*
2800                  * GSS case: the spec doesn't allow us to return this
2801                  * error.  But it also doesn't allow us not to support
2802                  * GSS.
2803                  * I'd rather this fail hard than return some error the
2804                  * client might think it can already handle:
2805                  */
2806                 return nfserr_encr_alg_unsupp;
2807         }
2808 }
2809
2810 __be32
2811 nfsd4_create_session(struct svc_rqst *rqstp,
2812                 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
2813 {
2814         struct nfsd4_create_session *cr_ses = &u->create_session;
2815         struct sockaddr *sa = svc_addr(rqstp);
2816         struct nfs4_client *conf, *unconf;
2817         struct nfs4_client *old = NULL;
2818         struct nfsd4_session *new;
2819         struct nfsd4_conn *conn;
2820         struct nfsd4_clid_slot *cs_slot = NULL;
2821         __be32 status = 0;
2822         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2823
2824         if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
2825                 return nfserr_inval;
2826         status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
2827         if (status)
2828                 return status;
2829         status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
2830         if (status)
2831                 return status;
2832         status = check_backchannel_attrs(&cr_ses->back_channel);
2833         if (status)
2834                 goto out_release_drc_mem;
2835         status = nfserr_jukebox;
2836         new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
2837         if (!new)
2838                 goto out_release_drc_mem;
2839         conn = alloc_conn_from_crses(rqstp, cr_ses);
2840         if (!conn)
2841                 goto out_free_session;
2842
2843         spin_lock(&nn->client_lock);
2844         unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
2845         conf = find_confirmed_client(&cr_ses->clientid, true, nn);
2846         WARN_ON_ONCE(conf && unconf);
2847
2848         if (conf) {
2849                 status = nfserr_wrong_cred;
2850                 if (!nfsd4_mach_creds_match(conf, rqstp))
2851                         goto out_free_conn;
2852                 cs_slot = &conf->cl_cs_slot;
2853                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
2854                 if (status) {
2855                         if (status == nfserr_replay_cache)
2856                                 status = nfsd4_replay_create_session(cr_ses, cs_slot);
2857                         goto out_free_conn;
2858                 }
2859         } else if (unconf) {
2860                 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
2861                     !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
2862                         status = nfserr_clid_inuse;
2863                         goto out_free_conn;
2864                 }
2865                 status = nfserr_wrong_cred;
2866                 if (!nfsd4_mach_creds_match(unconf, rqstp))
2867                         goto out_free_conn;
2868                 cs_slot = &unconf->cl_cs_slot;
2869                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
2870                 if (status) {
2871                         /* an unconfirmed replay returns misordered */
2872                         status = nfserr_seq_misordered;
2873                         goto out_free_conn;
2874                 }
2875                 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
2876                 if (old) {
2877                         status = mark_client_expired_locked(old);
2878                         if (status) {
2879                                 old = NULL;
2880                                 goto out_free_conn;
2881                         }
2882                 }
2883                 move_to_confirmed(unconf);
2884                 conf = unconf;
2885         } else {
2886                 status = nfserr_stale_clientid;
2887                 goto out_free_conn;
2888         }
2889         status = nfs_ok;
2890         /* Persistent sessions are not supported */
2891         cr_ses->flags &= ~SESSION4_PERSIST;
2892         /* Upshifting from TCP to RDMA is not supported */
2893         cr_ses->flags &= ~SESSION4_RDMA;
2894
2895         init_session(rqstp, new, conf, cr_ses);
2896         nfsd4_get_session_locked(new);
2897
2898         memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
2899                NFS4_MAX_SESSIONID_LEN);
2900         cs_slot->sl_seqid++;
2901         cr_ses->seqid = cs_slot->sl_seqid;
2902
2903         /* cache solo and embedded create sessions under the client_lock */
2904         nfsd4_cache_create_session(cr_ses, cs_slot, status);
2905         spin_unlock(&nn->client_lock);
2906         /* init connection and backchannel */
2907         nfsd4_init_conn(rqstp, conn, new);
2908         nfsd4_put_session(new);
2909         if (old)
2910                 expire_client(old);
2911         return status;
2912 out_free_conn:
2913         spin_unlock(&nn->client_lock);
2914         free_conn(conn);
2915         if (old)
2916                 expire_client(old);
2917 out_free_session:
2918         __free_session(new);
2919 out_release_drc_mem:
2920         nfsd4_put_drc_mem(&cr_ses->fore_channel);
2921         return status;
2922 }
2923
2924 static __be32 nfsd4_map_bcts_dir(u32 *dir)
2925 {
2926         switch (*dir) {
2927         case NFS4_CDFC4_FORE:
2928         case NFS4_CDFC4_BACK:
2929                 return nfs_ok;
2930         case NFS4_CDFC4_FORE_OR_BOTH:
2931         case NFS4_CDFC4_BACK_OR_BOTH:
2932                 *dir = NFS4_CDFC4_BOTH;
2933                 return nfs_ok;
2934         };
2935         return nfserr_inval;
2936 }
2937
2938 __be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp,
2939                 struct nfsd4_compound_state *cstate,
2940                 union nfsd4_op_u *u)
2941 {
2942         struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;
2943         struct nfsd4_session *session = cstate->session;
2944         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2945         __be32 status;
2946
2947         status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2948         if (status)
2949                 return status;
2950         spin_lock(&nn->client_lock);
2951         session->se_cb_prog = bc->bc_cb_program;
2952         session->se_cb_sec = bc->bc_cb_sec;
2953         spin_unlock(&nn->client_lock);
2954
2955         nfsd4_probe_callback(session->se_client);
2956
2957         return nfs_ok;
2958 }
2959
2960 __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2961                      struct nfsd4_compound_state *cstate,
2962                      union nfsd4_op_u *u)
2963 {
2964         struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;
2965         __be32 status;
2966         struct nfsd4_conn *conn;
2967         struct nfsd4_session *session;
2968         struct net *net = SVC_NET(rqstp);
2969         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2970
2971         if (!nfsd4_last_compound_op(rqstp))
2972                 return nfserr_not_only_op;
2973         spin_lock(&nn->client_lock);
2974         session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
2975         spin_unlock(&nn->client_lock);
2976         if (!session)
2977                 goto out_no_session;
2978         status = nfserr_wrong_cred;
2979         if (!nfsd4_mach_creds_match(session->se_client, rqstp))
2980                 goto out;
2981         status = nfsd4_map_bcts_dir(&bcts->dir);
2982         if (status)
2983                 goto out;
2984         conn = alloc_conn(rqstp, bcts->dir);
2985         status = nfserr_jukebox;
2986         if (!conn)
2987                 goto out;
2988         nfsd4_init_conn(rqstp, conn, session);
2989         status = nfs_ok;
2990 out:
2991         nfsd4_put_session(session);
2992 out_no_session:
2993         return status;
2994 }
2995
2996 static bool nfsd4_compound_in_session(struct nfsd4_compound_state *cstate, struct nfs4_sessionid *sid)
2997 {
2998         if (!cstate->session)
2999                 return false;
3000         return !memcmp(sid, &cstate->session->se_sessionid, sizeof(*sid));
3001 }
3002
3003 __be32
3004 nfsd4_destroy_session(struct svc_rqst *r, struct nfsd4_compound_state *cstate,
3005                 union nfsd4_op_u *u)
3006 {
3007         struct nfs4_sessionid *sessionid = &u->destroy_session.sessionid;
3008         struct nfsd4_session *ses;
3009         __be32 status;
3010         int ref_held_by_me = 0;
3011         struct net *net = SVC_NET(r);
3012         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3013
3014         status = nfserr_not_only_op;
3015         if (nfsd4_compound_in_session(cstate, sessionid)) {
3016                 if (!nfsd4_last_compound_op(r))
3017                         goto out;
3018                 ref_held_by_me++;
3019         }
3020         dump_sessionid(__func__, sessionid);
3021         spin_lock(&nn->client_lock);
3022         ses = find_in_sessionid_hashtbl(sessionid, net, &status);
3023         if (!ses)
3024                 goto out_client_lock;
3025         status = nfserr_wrong_cred;
3026         if (!nfsd4_mach_creds_match(ses->se_client, r))
3027                 goto out_put_session;
3028         status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
3029         if (status)
3030                 goto out_put_session;
3031         unhash_session(ses);
3032         spin_unlock(&nn->client_lock);
3033
3034         nfsd4_probe_callback_sync(ses->se_client);
3035
3036         spin_lock(&nn->client_lock);
3037         status = nfs_ok;
3038 out_put_session:
3039         nfsd4_put_session_locked(ses);
3040 out_client_lock:
3041         spin_unlock(&nn->client_lock);
3042 out:
3043         return status;
3044 }
3045
3046 static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
3047 {
3048         struct nfsd4_conn *c;
3049
3050         list_for_each_entry(c, &s->se_conns, cn_persession) {
3051                 if (c->cn_xprt == xpt) {
3052                         return c;
3053                 }
3054         }
3055         return NULL;
3056 }
3057
3058 static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
3059 {
3060         struct nfs4_client *clp = ses->se_client;
3061         struct nfsd4_conn *c;
3062         __be32 status = nfs_ok;
3063         int ret;
3064
3065         spin_lock(&clp->cl_lock);
3066         c = __nfsd4_find_conn(new->cn_xprt, ses);
3067         if (c)
3068                 goto out_free;
3069         status = nfserr_conn_not_bound_to_session;
3070         if (clp->cl_mach_cred)
3071                 goto out_free;
3072         __nfsd4_hash_conn(new, ses);
3073         spin_unlock(&clp->cl_lock);
3074         ret = nfsd4_register_conn(new);
3075         if (ret)
3076                 /* oops; xprt is already down: */
3077                 nfsd4_conn_lost(&new->cn_xpt_user);
3078         return nfs_ok;
3079 out_free:
3080         spin_unlock(&clp->cl_lock);
3081         free_conn(new);
3082         return status;
3083 }
3084
3085 static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
3086 {
3087         struct nfsd4_compoundargs *args = rqstp->rq_argp;
3088
3089         return args->opcnt > session->se_fchannel.maxops;
3090 }
3091
3092 static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
3093                                   struct nfsd4_session *session)
3094 {
3095         struct xdr_buf *xb = &rqstp->rq_arg;
3096
3097         return xb->len > session->se_fchannel.maxreq_sz;
3098 }
3099
3100 static bool replay_matches_cache(struct svc_rqst *rqstp,
3101                  struct nfsd4_sequence *seq, struct nfsd4_slot *slot)
3102 {
3103         struct nfsd4_compoundargs *argp = rqstp->rq_argp;
3104
3105         if ((bool)(slot->sl_flags & NFSD4_SLOT_CACHETHIS) !=
3106             (bool)seq->cachethis)
3107                 return false;
3108         /*
3109          * If there's an error than the reply can have fewer ops than
3110          * the call.  But if we cached a reply with *more* ops than the
3111          * call you're sending us now, then this new call is clearly not
3112          * really a replay of the old one:
3113          */
3114         if (slot->sl_opcnt < argp->opcnt)
3115                 return false;
3116         /* This is the only check explicitly called by spec: */
3117         if (!same_creds(&rqstp->rq_cred, &slot->sl_cred))
3118                 return false;
3119         /*
3120          * There may be more comparisons we could actually do, but the
3121          * spec doesn't require us to catch every case where the calls
3122          * don't match (that would require caching the call as well as
3123          * the reply), so we don't bother.
3124          */
3125         return true;
3126 }
3127
3128 __be32
3129 nfsd4_sequence(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3130                 union nfsd4_op_u *u)
3131 {
3132         struct nfsd4_sequence *seq = &u->sequence;
3133         struct nfsd4_compoundres *resp = rqstp->rq_resp;
3134         struct xdr_stream *xdr = &resp->xdr;
3135         struct nfsd4_session *session;
3136         struct nfs4_client *clp;
3137         struct nfsd4_slot *slot;
3138         struct nfsd4_conn *conn;
3139         __be32 status;
3140         int buflen;
3141         struct net *net = SVC_NET(rqstp);
3142         struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3143
3144         if (resp->opcnt != 1)
3145                 return nfserr_sequence_pos;
3146
3147         /*
3148          * Will be either used or freed by nfsd4_sequence_check_conn
3149          * below.
3150          */
3151         conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
3152         if (!conn)
3153                 return nfserr_jukebox;
3154
3155         spin_lock(&nn->client_lock);
3156         session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
3157         if (!session)
3158                 goto out_no_session;
3159         clp = session->se_client;
3160
3161         status = nfserr_too_many_ops;
3162         if (nfsd4_session_too_many_ops(rqstp, session))
3163                 goto out_put_session;
3164
3165         status = nfserr_req_too_big;
3166         if (nfsd4_request_too_big(rqstp, session))
3167                 goto out_put_session;
3168
3169         status = nfserr_badslot;
3170         if (seq->slotid >= session->se_fchannel.maxreqs)
3171                 goto out_put_session;
3172
3173         slot = session->se_slots[seq->slotid];
3174         dprintk("%s: slotid %d\n", __func__, seq->slotid);
3175
3176         /* We do not negotiate the number of slots yet, so set the
3177          * maxslots to the session maxreqs which is used to encode
3178          * sr_highest_slotid and the sr_target_slot id to maxslots */
3179         seq->maxslots = session->se_fchannel.maxreqs;
3180
3181         status = check_slot_seqid(seq->seqid, slot->sl_seqid,
3182                                         slot->sl_flags & NFSD4_SLOT_INUSE);
3183         if (status == nfserr_replay_cache) {
3184                 status = nfserr_seq_misordered;
3185                 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
3186                         goto out_put_session;
3187                 status = nfserr_seq_false_retry;
3188                 if (!replay_matches_cache(rqstp, seq, slot))
3189                         goto out_put_session;
3190                 cstate->slot = slot;
3191                 cstate->session = session;
3192                 cstate->clp = clp;
3193                 /* Return the cached reply status and set cstate->status
3194                  * for nfsd4_proc_compound processing */
3195                 status = nfsd4_replay_cache_entry(resp, seq);
3196                 cstate->status = nfserr_replay_cache;
3197                 goto out;
3198         }
3199         if (status)
3200                 goto out_put_session;
3201
3202         status = nfsd4_sequence_check_conn(conn, session);
3203         conn = NULL;
3204         if (status)
3205                 goto out_put_session;
3206
3207         buflen = (seq->cachethis) ?
3208                         session->se_fchannel.maxresp_cached :
3209                         session->se_fchannel.maxresp_sz;
3210         status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
3211                                     nfserr_rep_too_big;
3212         if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
3213                 goto out_put_session;
3214         svc_reserve(rqstp, buflen);
3215
3216         status = nfs_ok;
3217         /* Success! bump slot seqid */
3218         slot->sl_seqid = seq->seqid;
3219         slot->sl_flags |= NFSD4_SLOT_INUSE;
3220         if (seq->cachethis)
3221                 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
3222         else
3223                 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
3224
3225         cstate->slot = slot;
3226         cstate->session = session;
3227         cstate->clp = clp;
3228
3229 out:
3230         switch (clp->cl_cb_state) {
3231         case NFSD4_CB_DOWN:
3232                 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
3233                 break;
3234         case NFSD4_CB_FAULT:
3235                 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
3236                 break;
3237         default:
3238                 seq->status_flags = 0;
3239         }
3240         if (!list_empty(&clp->cl_revoked))
3241                 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
3242 out_no_session:
3243         if (conn)
3244                 free_conn(conn);
3245         spin_unlock(&nn->client_lock);
3246         return status;
3247 out_put_session:
3248         nfsd4_put_session_locked(session);
3249         goto out_no_session;
3250 }
3251
3252 void
3253 nfsd4_sequence_done(struct nfsd4_compoundres *resp)
3254 {
3255         struct nfsd4_compound_state *cs = &resp->cstate;
3256
3257         if (nfsd4_has_session(cs)) {
3258                 if (cs->status != nfserr_replay_cache) {
3259                         nfsd4_store_cache_entry(resp);
3260                         cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
3261                 }
3262                 /* Drop session reference that was taken in nfsd4_sequence() */
3263                 nfsd4_put_session(cs->session);
3264         } else if (cs->clp)
3265                 put_client_renew(cs->clp);
3266 }
3267
3268 __be32
3269 nfsd4_destroy_clientid(struct svc_rqst *rqstp,
3270                 struct nfsd4_compound_state *cstate,
3271                 union nfsd4_op_u *u)
3272 {
3273         struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;
3274         struct nfs4_client *conf, *unconf;
3275         struct nfs4_client *clp = NULL;
3276         __be32 status = 0;
3277         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3278
3279         spin_lock(&nn->client_lock);
3280         unconf = find_unconfirmed_client(&dc->clientid, true, nn);
3281         conf = find_confirmed_client(&dc->clientid, true, nn);
3282         WARN_ON_ONCE(conf && unconf);
3283
3284         if (conf) {
3285                 if (client_has_state(conf)) {
3286                         status = nfserr_clientid_busy;
3287                         goto out;
3288                 }
3289                 status = mark_client_expired_locked(conf);
3290                 if (status)
3291                         goto out;
3292                 clp = conf;
3293         } else if (unconf)
3294                 clp = unconf;
3295         else {
3296                 status = nfserr_stale_clientid;
3297                 goto out;
3298         }
3299         if (!nfsd4_mach_creds_match(clp, rqstp)) {
3300                 clp = NULL;
3301                 status = nfserr_wrong_cred;
3302                 goto out;
3303         }
3304         unhash_client_locked(clp);
3305 out:
3306         spin_unlock(&nn->client_lock);
3307         if (clp)
3308                 expire_client(clp);
3309         return status;
3310 }
3311
3312 __be32
3313 nfsd4_reclaim_complete(struct svc_rqst *rqstp,
3314                 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
3315 {
3316         struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;
3317         __be32 status = 0;
3318
3319         if (rc->rca_one_fs) {
3320                 if (!cstate->current_fh.fh_dentry)
3321                         return nfserr_nofilehandle;
3322                 /*
3323                  * We don't take advantage of the rca_one_fs case.
3324                  * That's OK, it's optional, we can safely ignore it.
3325                  */
3326                 return nfs_ok;
3327         }
3328
3329         status = nfserr_complete_already;
3330         if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
3331                              &cstate->session->se_client->cl_flags))
3332                 goto out;
3333
3334         status = nfserr_stale_clientid;
3335         if (is_client_expired(cstate->session->se_client))
3336                 /*
3337                  * The following error isn't really legal.
3338                  * But we only get here if the client just explicitly
3339                  * destroyed the client.  Surely it no longer cares what
3340                  * error it gets back on an operation for the dead
3341                  * client.
3342                  */
3343                 goto out;
3344
3345         status = nfs_ok;
3346         nfsd4_client_record_create(cstate->session->se_client);
3347 out:
3348         return status;
3349 }
3350
3351 __be32
3352 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3353                   union nfsd4_op_u *u)
3354 {
3355         struct nfsd4_setclientid *setclid = &u->setclientid;
3356         struct xdr_netobj       clname = setclid->se_name;
3357         nfs4_verifier           clverifier = setclid->se_verf;
3358         struct nfs4_client      *conf, *new;
3359         struct nfs4_client      *unconf = NULL;
3360         __be32                  status;
3361         struct nfsd_net         *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3362
3363         new = create_client(clname, rqstp, &clverifier);
3364         if (new == NULL)
3365                 return nfserr_jukebox;
3366         /* Cases below refer to rfc 3530 section 14.2.33: */
3367         spin_lock(&nn->client_lock);
3368         conf = find_confirmed_client_by_name(&clname, nn);
3369         if (conf && client_has_state(conf)) {
3370                 /* case 0: */
3371                 status = nfserr_clid_inuse;
3372                 if (clp_used_exchangeid(conf))
3373                         goto out;
3374                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
3375                         char addr_str[INET6_ADDRSTRLEN];
3376                         rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
3377                                  sizeof(addr_str));
3378                         dprintk("NFSD: setclientid: string in use by client "
3379                                 "at %s\n", addr_str);
3380                         goto out;
3381                 }
3382         }
3383         unconf = find_unconfirmed_client_by_name(&clname, nn);
3384         if (unconf)
3385                 unhash_client_locked(unconf);
3386         if (conf && same_verf(&conf->cl_verifier, &clverifier)) {
3387                 /* case 1: probable callback update */
3388                 copy_clid(new, conf);
3389                 gen_confirm(new, nn);
3390         } else /* case 4 (new client) or cases 2, 3 (client reboot): */
3391                 gen_clid(new, nn);
3392         new->cl_minorversion = 0;
3393         gen_callback(new, setclid, rqstp);
3394         add_to_unconfirmed(new);
3395         setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
3396         setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
3397         memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
3398         new = NULL;
3399         status = nfs_ok;
3400 out:
3401         spin_unlock(&nn->client_lock);
3402         if (new)
3403                 free_client(new);
3404         if (unconf)
3405                 expire_client(unconf);
3406         return status;
3407 }
3408
3409
3410 __be32
3411 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
3412                         struct nfsd4_compound_state *cstate,
3413                         union nfsd4_op_u *u)
3414 {
3415         struct nfsd4_setclientid_confirm *setclientid_confirm =
3416                         &u->setclientid_confirm;
3417         struct nfs4_client *conf, *unconf;
3418         struct nfs4_client *old = NULL;
3419         nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
3420         clientid_t * clid = &setclientid_confirm->sc_clientid;
3421         __be32 status;
3422         struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3423
3424         if (STALE_CLIENTID(clid, nn))
3425                 return nfserr_stale_clientid;
3426
3427         spin_lock(&nn->client_lock);
3428         conf = find_confirmed_client(clid, false, nn);
3429         unconf = find_unconfirmed_client(clid, false, nn);
3430         /*
3431          * We try hard to give out unique clientid's, so if we get an
3432          * attempt to confirm the same clientid with a different cred,
3433          * the client may be buggy; this should never happen.
3434          *
3435          * Nevertheless, RFC 7530 recommends INUSE for this case:
3436          */
3437         status = nfserr_clid_inuse;
3438         if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))