Merge branch 'for-3.3' of git://linux-nfs.org/~bfields/linux
[linux-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/sunrpc/svcauth_gss.h>
42 #include <linux/sunrpc/clnt.h>
43 #include "xdr4.h"
44 #include "vfs.h"
45
46 #define NFSDDBG_FACILITY                NFSDDBG_PROC
47
48 /* Globals */
49 time_t nfsd4_lease = 90;     /* default lease time */
50 time_t nfsd4_grace = 90;
51 static time_t boot_time;
52
53 #define all_ones {{~0,~0},~0}
54 static const stateid_t one_stateid = {
55         .si_generation = ~0,
56         .si_opaque = all_ones,
57 };
58 static const stateid_t zero_stateid = {
59         /* all fields zero */
60 };
61
62 static u64 current_sessionid = 1;
63
64 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
65 #define ONE_STATEID(stateid)  (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
66
67 /* forward declarations */
68 static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
69
70 /* Locking: */
71
72 /* Currently used for almost all code touching nfsv4 state: */
73 static DEFINE_MUTEX(client_mutex);
74
75 /*
76  * Currently used for the del_recall_lru and file hash table.  In an
77  * effort to decrease the scope of the client_mutex, this spinlock may
78  * eventually cover more:
79  */
80 static DEFINE_SPINLOCK(recall_lock);
81
82 static struct kmem_cache *openowner_slab = NULL;
83 static struct kmem_cache *lockowner_slab = NULL;
84 static struct kmem_cache *file_slab = NULL;
85 static struct kmem_cache *stateid_slab = NULL;
86 static struct kmem_cache *deleg_slab = NULL;
87
88 void
89 nfs4_lock_state(void)
90 {
91         mutex_lock(&client_mutex);
92 }
93
94 void
95 nfs4_unlock_state(void)
96 {
97         mutex_unlock(&client_mutex);
98 }
99
100 static inline u32
101 opaque_hashval(const void *ptr, int nbytes)
102 {
103         unsigned char *cptr = (unsigned char *) ptr;
104
105         u32 x = 0;
106         while (nbytes--) {
107                 x *= 37;
108                 x += *cptr++;
109         }
110         return x;
111 }
112
113 static struct list_head del_recall_lru;
114
115 static void nfsd4_free_file(struct nfs4_file *f)
116 {
117         kmem_cache_free(file_slab, f);
118 }
119
120 static inline void
121 put_nfs4_file(struct nfs4_file *fi)
122 {
123         if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
124                 list_del(&fi->fi_hash);
125                 spin_unlock(&recall_lock);
126                 iput(fi->fi_inode);
127                 nfsd4_free_file(fi);
128         }
129 }
130
131 static inline void
132 get_nfs4_file(struct nfs4_file *fi)
133 {
134         atomic_inc(&fi->fi_ref);
135 }
136
137 static int num_delegations;
138 unsigned int max_delegations;
139
140 /*
141  * Open owner state (share locks)
142  */
143
144 /* hash tables for lock and open owners */
145 #define OWNER_HASH_BITS              8
146 #define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
147 #define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
148
149 static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
150 {
151         unsigned int ret;
152
153         ret = opaque_hashval(ownername->data, ownername->len);
154         ret += clientid;
155         return ret & OWNER_HASH_MASK;
156 }
157
158 static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
159
160 /* hash table for nfs4_file */
161 #define FILE_HASH_BITS                   8
162 #define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
163
164 static unsigned int file_hashval(struct inode *ino)
165 {
166         /* XXX: why are we hashing on inode pointer, anyway? */
167         return hash_ptr(ino, FILE_HASH_BITS);
168 }
169
170 static struct list_head file_hashtbl[FILE_HASH_SIZE];
171
172 static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
173 {
174         BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
175         atomic_inc(&fp->fi_access[oflag]);
176 }
177
178 static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
179 {
180         if (oflag == O_RDWR) {
181                 __nfs4_file_get_access(fp, O_RDONLY);
182                 __nfs4_file_get_access(fp, O_WRONLY);
183         } else
184                 __nfs4_file_get_access(fp, oflag);
185 }
186
187 static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
188 {
189         if (fp->fi_fds[oflag]) {
190                 fput(fp->fi_fds[oflag]);
191                 fp->fi_fds[oflag] = NULL;
192         }
193 }
194
195 static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
196 {
197         if (atomic_dec_and_test(&fp->fi_access[oflag])) {
198                 nfs4_file_put_fd(fp, oflag);
199                 /*
200                  * It's also safe to get rid of the RDWR open *if*
201                  * we no longer have need of the other kind of access
202                  * or if we already have the other kind of open:
203                  */
204                 if (fp->fi_fds[1-oflag]
205                         || atomic_read(&fp->fi_access[1 - oflag]) == 0)
206                         nfs4_file_put_fd(fp, O_RDWR);
207         }
208 }
209
210 static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
211 {
212         if (oflag == O_RDWR) {
213                 __nfs4_file_put_access(fp, O_RDONLY);
214                 __nfs4_file_put_access(fp, O_WRONLY);
215         } else
216                 __nfs4_file_put_access(fp, oflag);
217 }
218
219 static inline int get_new_stid(struct nfs4_stid *stid)
220 {
221         static int min_stateid = 0;
222         struct idr *stateids = &stid->sc_client->cl_stateids;
223         int new_stid;
224         int error;
225
226         error = idr_get_new_above(stateids, stid, min_stateid, &new_stid);
227         /*
228          * Note: the necessary preallocation was done in
229          * nfs4_alloc_stateid().  The idr code caps the number of
230          * preallocations that can exist at a time, but the state lock
231          * prevents anyone from using ours before we get here:
232          */
233         BUG_ON(error);
234         /*
235          * It shouldn't be a problem to reuse an opaque stateid value.
236          * I don't think it is for 4.1.  But with 4.0 I worry that, for
237          * example, a stray write retransmission could be accepted by
238          * the server when it should have been rejected.  Therefore,
239          * adopt a trick from the sctp code to attempt to maximize the
240          * amount of time until an id is reused, by ensuring they always
241          * "increase" (mod INT_MAX):
242          */
243
244         min_stateid = new_stid+1;
245         if (min_stateid == INT_MAX)
246                 min_stateid = 0;
247         return new_stid;
248 }
249
250 static void init_stid(struct nfs4_stid *stid, struct nfs4_client *cl, unsigned char type)
251 {
252         stateid_t *s = &stid->sc_stateid;
253         int new_id;
254
255         stid->sc_type = type;
256         stid->sc_client = cl;
257         s->si_opaque.so_clid = cl->cl_clientid;
258         new_id = get_new_stid(stid);
259         s->si_opaque.so_id = (u32)new_id;
260         /* Will be incremented before return to client: */
261         s->si_generation = 0;
262 }
263
264 static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab)
265 {
266         struct idr *stateids = &cl->cl_stateids;
267
268         if (!idr_pre_get(stateids, GFP_KERNEL))
269                 return NULL;
270         /*
271          * Note: if we fail here (or any time between now and the time
272          * we actually get the new idr), we won't need to undo the idr
273          * preallocation, since the idr code caps the number of
274          * preallocated entries.
275          */
276         return kmem_cache_alloc(slab, GFP_KERNEL);
277 }
278
279 static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
280 {
281         return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
282 }
283
284 static struct nfs4_delegation *
285 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh, u32 type)
286 {
287         struct nfs4_delegation *dp;
288         struct nfs4_file *fp = stp->st_file;
289
290         dprintk("NFSD alloc_init_deleg\n");
291         /*
292          * Major work on the lease subsystem (for example, to support
293          * calbacks on stat) will be required before we can support
294          * write delegations properly.
295          */
296         if (type != NFS4_OPEN_DELEGATE_READ)
297                 return NULL;
298         if (fp->fi_had_conflict)
299                 return NULL;
300         if (num_delegations > max_delegations)
301                 return NULL;
302         dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
303         if (dp == NULL)
304                 return dp;
305         init_stid(&dp->dl_stid, clp, NFS4_DELEG_STID);
306         /*
307          * delegation seqid's are never incremented.  The 4.1 special
308          * meaning of seqid 0 isn't meaningful, really, but let's avoid
309          * 0 anyway just for consistency and use 1:
310          */
311         dp->dl_stid.sc_stateid.si_generation = 1;
312         num_delegations++;
313         INIT_LIST_HEAD(&dp->dl_perfile);
314         INIT_LIST_HEAD(&dp->dl_perclnt);
315         INIT_LIST_HEAD(&dp->dl_recall_lru);
316         get_nfs4_file(fp);
317         dp->dl_file = fp;
318         dp->dl_type = type;
319         fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
320         dp->dl_time = 0;
321         atomic_set(&dp->dl_count, 1);
322         INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
323         return dp;
324 }
325
326 void
327 nfs4_put_delegation(struct nfs4_delegation *dp)
328 {
329         if (atomic_dec_and_test(&dp->dl_count)) {
330                 dprintk("NFSD: freeing dp %p\n",dp);
331                 put_nfs4_file(dp->dl_file);
332                 kmem_cache_free(deleg_slab, dp);
333                 num_delegations--;
334         }
335 }
336
337 static void nfs4_put_deleg_lease(struct nfs4_file *fp)
338 {
339         if (atomic_dec_and_test(&fp->fi_delegees)) {
340                 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
341                 fp->fi_lease = NULL;
342                 fput(fp->fi_deleg_file);
343                 fp->fi_deleg_file = NULL;
344         }
345 }
346
347 static void unhash_stid(struct nfs4_stid *s)
348 {
349         struct idr *stateids = &s->sc_client->cl_stateids;
350
351         idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
352 }
353
354 /* Called under the state lock. */
355 static void
356 unhash_delegation(struct nfs4_delegation *dp)
357 {
358         unhash_stid(&dp->dl_stid);
359         list_del_init(&dp->dl_perclnt);
360         spin_lock(&recall_lock);
361         list_del_init(&dp->dl_perfile);
362         list_del_init(&dp->dl_recall_lru);
363         spin_unlock(&recall_lock);
364         nfs4_put_deleg_lease(dp->dl_file);
365         nfs4_put_delegation(dp);
366 }
367
368 /* 
369  * SETCLIENTID state 
370  */
371
372 /* client_lock protects the client lru list and session hash table */
373 static DEFINE_SPINLOCK(client_lock);
374
375 /* Hash tables for nfs4_clientid state */
376 #define CLIENT_HASH_BITS                 4
377 #define CLIENT_HASH_SIZE                (1 << CLIENT_HASH_BITS)
378 #define CLIENT_HASH_MASK                (CLIENT_HASH_SIZE - 1)
379
380 static unsigned int clientid_hashval(u32 id)
381 {
382         return id & CLIENT_HASH_MASK;
383 }
384
385 static unsigned int clientstr_hashval(const char *name)
386 {
387         return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
388 }
389
390 /*
391  * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
392  * used in reboot/reset lease grace period processing
393  *
394  * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
395  * setclientid_confirmed info. 
396  *
397  * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed 
398  * setclientid info.
399  *
400  * client_lru holds client queue ordered by nfs4_client.cl_time
401  * for lease renewal.
402  *
403  * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
404  * for last close replay.
405  */
406 static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
407 static int reclaim_str_hashtbl_size = 0;
408 static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
409 static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
410 static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
411 static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
412 static struct list_head client_lru;
413 static struct list_head close_lru;
414
415 /*
416  * We store the NONE, READ, WRITE, and BOTH bits separately in the
417  * st_{access,deny}_bmap field of the stateid, in order to track not
418  * only what share bits are currently in force, but also what
419  * combinations of share bits previous opens have used.  This allows us
420  * to enforce the recommendation of rfc 3530 14.2.19 that the server
421  * return an error if the client attempt to downgrade to a combination
422  * of share bits not explicable by closing some of its previous opens.
423  *
424  * XXX: This enforcement is actually incomplete, since we don't keep
425  * track of access/deny bit combinations; so, e.g., we allow:
426  *
427  *      OPEN allow read, deny write
428  *      OPEN allow both, deny none
429  *      DOWNGRADE allow read, deny none
430  *
431  * which we should reject.
432  */
433 static void
434 set_access(unsigned int *access, unsigned long bmap) {
435         int i;
436
437         *access = 0;
438         for (i = 1; i < 4; i++) {
439                 if (test_bit(i, &bmap))
440                         *access |= i;
441         }
442 }
443
444 static void
445 set_deny(unsigned int *deny, unsigned long bmap) {
446         int i;
447
448         *deny = 0;
449         for (i = 0; i < 4; i++) {
450                 if (test_bit(i, &bmap))
451                         *deny |= i ;
452         }
453 }
454
455 static int
456 test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
457         unsigned int access, deny;
458
459         set_access(&access, stp->st_access_bmap);
460         set_deny(&deny, stp->st_deny_bmap);
461         if ((access & open->op_share_deny) || (deny & open->op_share_access))
462                 return 0;
463         return 1;
464 }
465
466 static int nfs4_access_to_omode(u32 access)
467 {
468         switch (access & NFS4_SHARE_ACCESS_BOTH) {
469         case NFS4_SHARE_ACCESS_READ:
470                 return O_RDONLY;
471         case NFS4_SHARE_ACCESS_WRITE:
472                 return O_WRONLY;
473         case NFS4_SHARE_ACCESS_BOTH:
474                 return O_RDWR;
475         }
476         BUG();
477 }
478
479 static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
480 {
481         list_del(&stp->st_perfile);
482         list_del(&stp->st_perstateowner);
483 }
484
485 static void close_generic_stateid(struct nfs4_ol_stateid *stp)
486 {
487         int i;
488
489         if (stp->st_access_bmap) {
490                 for (i = 1; i < 4; i++) {
491                         if (test_bit(i, &stp->st_access_bmap))
492                                 nfs4_file_put_access(stp->st_file,
493                                                 nfs4_access_to_omode(i));
494                         __clear_bit(i, &stp->st_access_bmap);
495                 }
496         }
497         put_nfs4_file(stp->st_file);
498         stp->st_file = NULL;
499 }
500
501 static void free_generic_stateid(struct nfs4_ol_stateid *stp)
502 {
503         kmem_cache_free(stateid_slab, stp);
504 }
505
506 static void release_lock_stateid(struct nfs4_ol_stateid *stp)
507 {
508         struct file *file;
509
510         unhash_generic_stateid(stp);
511         unhash_stid(&stp->st_stid);
512         file = find_any_file(stp->st_file);
513         if (file)
514                 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
515         close_generic_stateid(stp);
516         free_generic_stateid(stp);
517 }
518
519 static void unhash_lockowner(struct nfs4_lockowner *lo)
520 {
521         struct nfs4_ol_stateid *stp;
522
523         list_del(&lo->lo_owner.so_strhash);
524         list_del(&lo->lo_perstateid);
525         list_del(&lo->lo_owner_ino_hash);
526         while (!list_empty(&lo->lo_owner.so_stateids)) {
527                 stp = list_first_entry(&lo->lo_owner.so_stateids,
528                                 struct nfs4_ol_stateid, st_perstateowner);
529                 release_lock_stateid(stp);
530         }
531 }
532
533 static void release_lockowner(struct nfs4_lockowner *lo)
534 {
535         unhash_lockowner(lo);
536         nfs4_free_lockowner(lo);
537 }
538
539 static void
540 release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
541 {
542         struct nfs4_lockowner *lo;
543
544         while (!list_empty(&open_stp->st_lockowners)) {
545                 lo = list_entry(open_stp->st_lockowners.next,
546                                 struct nfs4_lockowner, lo_perstateid);
547                 release_lockowner(lo);
548         }
549 }
550
551 static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
552 {
553         unhash_generic_stateid(stp);
554         release_stateid_lockowners(stp);
555         close_generic_stateid(stp);
556 }
557
558 static void release_open_stateid(struct nfs4_ol_stateid *stp)
559 {
560         unhash_open_stateid(stp);
561         unhash_stid(&stp->st_stid);
562         free_generic_stateid(stp);
563 }
564
565 static void unhash_openowner(struct nfs4_openowner *oo)
566 {
567         struct nfs4_ol_stateid *stp;
568
569         list_del(&oo->oo_owner.so_strhash);
570         list_del(&oo->oo_perclient);
571         while (!list_empty(&oo->oo_owner.so_stateids)) {
572                 stp = list_first_entry(&oo->oo_owner.so_stateids,
573                                 struct nfs4_ol_stateid, st_perstateowner);
574                 release_open_stateid(stp);
575         }
576 }
577
578 static void release_last_closed_stateid(struct nfs4_openowner *oo)
579 {
580         struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
581
582         if (s) {
583                 unhash_stid(&s->st_stid);
584                 free_generic_stateid(s);
585                 oo->oo_last_closed_stid = NULL;
586         }
587 }
588
589 static void release_openowner(struct nfs4_openowner *oo)
590 {
591         unhash_openowner(oo);
592         list_del(&oo->oo_close_lru);
593         release_last_closed_stateid(oo);
594         nfs4_free_openowner(oo);
595 }
596
597 #define SESSION_HASH_SIZE       512
598 static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
599
600 static inline int
601 hash_sessionid(struct nfs4_sessionid *sessionid)
602 {
603         struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
604
605         return sid->sequence % SESSION_HASH_SIZE;
606 }
607
608 static inline void
609 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
610 {
611         u32 *ptr = (u32 *)(&sessionid->data[0]);
612         dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
613 }
614
615 static void
616 gen_sessionid(struct nfsd4_session *ses)
617 {
618         struct nfs4_client *clp = ses->se_client;
619         struct nfsd4_sessionid *sid;
620
621         sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
622         sid->clientid = clp->cl_clientid;
623         sid->sequence = current_sessionid++;
624         sid->reserved = 0;
625 }
626
627 /*
628  * The protocol defines ca_maxresponssize_cached to include the size of
629  * the rpc header, but all we need to cache is the data starting after
630  * the end of the initial SEQUENCE operation--the rest we regenerate
631  * each time.  Therefore we can advertise a ca_maxresponssize_cached
632  * value that is the number of bytes in our cache plus a few additional
633  * bytes.  In order to stay on the safe side, and not promise more than
634  * we can cache, those additional bytes must be the minimum possible: 24
635  * bytes of rpc header (xid through accept state, with AUTH_NULL
636  * verifier), 12 for the compound header (with zero-length tag), and 44
637  * for the SEQUENCE op response:
638  */
639 #define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)
640
641 static void
642 free_session_slots(struct nfsd4_session *ses)
643 {
644         int i;
645
646         for (i = 0; i < ses->se_fchannel.maxreqs; i++)
647                 kfree(ses->se_slots[i]);
648 }
649
650 /*
651  * We don't actually need to cache the rpc and session headers, so we
652  * can allocate a little less for each slot:
653  */
654 static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
655 {
656         return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
657 }
658
659 static int nfsd4_sanitize_slot_size(u32 size)
660 {
661         size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
662         size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
663
664         return size;
665 }
666
667 /*
668  * XXX: If we run out of reserved DRC memory we could (up to a point)
669  * re-negotiate active sessions and reduce their slot usage to make
670  * room for new connections. For now we just fail the create session.
671  */
672 static int nfsd4_get_drc_mem(int slotsize, u32 num)
673 {
674         int avail;
675
676         num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
677
678         spin_lock(&nfsd_drc_lock);
679         avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
680                         nfsd_drc_max_mem - nfsd_drc_mem_used);
681         num = min_t(int, num, avail / slotsize);
682         nfsd_drc_mem_used += num * slotsize;
683         spin_unlock(&nfsd_drc_lock);
684
685         return num;
686 }
687
688 static void nfsd4_put_drc_mem(int slotsize, int num)
689 {
690         spin_lock(&nfsd_drc_lock);
691         nfsd_drc_mem_used -= slotsize * num;
692         spin_unlock(&nfsd_drc_lock);
693 }
694
695 static struct nfsd4_session *alloc_session(int slotsize, int numslots)
696 {
697         struct nfsd4_session *new;
698         int mem, i;
699
700         BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
701                         + sizeof(struct nfsd4_session) > PAGE_SIZE);
702         mem = numslots * sizeof(struct nfsd4_slot *);
703
704         new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
705         if (!new)
706                 return NULL;
707         /* allocate each struct nfsd4_slot and data cache in one piece */
708         for (i = 0; i < numslots; i++) {
709                 mem = sizeof(struct nfsd4_slot) + slotsize;
710                 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
711                 if (!new->se_slots[i])
712                         goto out_free;
713         }
714         return new;
715 out_free:
716         while (i--)
717                 kfree(new->se_slots[i]);
718         kfree(new);
719         return NULL;
720 }
721
722 static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
723 {
724         u32 maxrpc = nfsd_serv->sv_max_mesg;
725
726         new->maxreqs = numslots;
727         new->maxresp_cached = min_t(u32, req->maxresp_cached,
728                                         slotsize + NFSD_MIN_HDR_SEQ_SZ);
729         new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
730         new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
731         new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
732 }
733
734 static void free_conn(struct nfsd4_conn *c)
735 {
736         svc_xprt_put(c->cn_xprt);
737         kfree(c);
738 }
739
740 static void nfsd4_conn_lost(struct svc_xpt_user *u)
741 {
742         struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
743         struct nfs4_client *clp = c->cn_session->se_client;
744
745         spin_lock(&clp->cl_lock);
746         if (!list_empty(&c->cn_persession)) {
747                 list_del(&c->cn_persession);
748                 free_conn(c);
749         }
750         spin_unlock(&clp->cl_lock);
751         nfsd4_probe_callback(clp);
752 }
753
754 static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
755 {
756         struct nfsd4_conn *conn;
757
758         conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
759         if (!conn)
760                 return NULL;
761         svc_xprt_get(rqstp->rq_xprt);
762         conn->cn_xprt = rqstp->rq_xprt;
763         conn->cn_flags = flags;
764         INIT_LIST_HEAD(&conn->cn_xpt_user.list);
765         return conn;
766 }
767
768 static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
769 {
770         conn->cn_session = ses;
771         list_add(&conn->cn_persession, &ses->se_conns);
772 }
773
774 static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
775 {
776         struct nfs4_client *clp = ses->se_client;
777
778         spin_lock(&clp->cl_lock);
779         __nfsd4_hash_conn(conn, ses);
780         spin_unlock(&clp->cl_lock);
781 }
782
783 static int nfsd4_register_conn(struct nfsd4_conn *conn)
784 {
785         conn->cn_xpt_user.callback = nfsd4_conn_lost;
786         return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
787 }
788
789 static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
790 {
791         struct nfsd4_conn *conn;
792         int ret;
793
794         conn = alloc_conn(rqstp, dir);
795         if (!conn)
796                 return nfserr_jukebox;
797         nfsd4_hash_conn(conn, ses);
798         ret = nfsd4_register_conn(conn);
799         if (ret)
800                 /* oops; xprt is already down: */
801                 nfsd4_conn_lost(&conn->cn_xpt_user);
802         return nfs_ok;
803 }
804
805 static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
806 {
807         u32 dir = NFS4_CDFC4_FORE;
808
809         if (ses->se_flags & SESSION4_BACK_CHAN)
810                 dir |= NFS4_CDFC4_BACK;
811
812         return nfsd4_new_conn(rqstp, ses, dir);
813 }
814
815 /* must be called under client_lock */
816 static void nfsd4_del_conns(struct nfsd4_session *s)
817 {
818         struct nfs4_client *clp = s->se_client;
819         struct nfsd4_conn *c;
820
821         spin_lock(&clp->cl_lock);
822         while (!list_empty(&s->se_conns)) {
823                 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
824                 list_del_init(&c->cn_persession);
825                 spin_unlock(&clp->cl_lock);
826
827                 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
828                 free_conn(c);
829
830                 spin_lock(&clp->cl_lock);
831         }
832         spin_unlock(&clp->cl_lock);
833 }
834
835 void free_session(struct kref *kref)
836 {
837         struct nfsd4_session *ses;
838         int mem;
839
840         ses = container_of(kref, struct nfsd4_session, se_ref);
841         nfsd4_del_conns(ses);
842         spin_lock(&nfsd_drc_lock);
843         mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
844         nfsd_drc_mem_used -= mem;
845         spin_unlock(&nfsd_drc_lock);
846         free_session_slots(ses);
847         kfree(ses);
848 }
849
850 static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
851 {
852         struct nfsd4_session *new;
853         struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
854         int numslots, slotsize;
855         int status;
856         int idx;
857
858         /*
859          * Note decreasing slot size below client's request may
860          * make it difficult for client to function correctly, whereas
861          * decreasing the number of slots will (just?) affect
862          * performance.  When short on memory we therefore prefer to
863          * decrease number of slots instead of their size.
864          */
865         slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
866         numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
867         if (numslots < 1)
868                 return NULL;
869
870         new = alloc_session(slotsize, numslots);
871         if (!new) {
872                 nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
873                 return NULL;
874         }
875         init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
876
877         new->se_client = clp;
878         gen_sessionid(new);
879
880         INIT_LIST_HEAD(&new->se_conns);
881
882         new->se_cb_seq_nr = 1;
883         new->se_flags = cses->flags;
884         new->se_cb_prog = cses->callback_prog;
885         kref_init(&new->se_ref);
886         idx = hash_sessionid(&new->se_sessionid);
887         spin_lock(&client_lock);
888         list_add(&new->se_hash, &sessionid_hashtbl[idx]);
889         spin_lock(&clp->cl_lock);
890         list_add(&new->se_perclnt, &clp->cl_sessions);
891         spin_unlock(&clp->cl_lock);
892         spin_unlock(&client_lock);
893
894         status = nfsd4_new_conn_from_crses(rqstp, new);
895         /* whoops: benny points out, status is ignored! (err, or bogus) */
896         if (status) {
897                 free_session(&new->se_ref);
898                 return NULL;
899         }
900         if (cses->flags & SESSION4_BACK_CHAN) {
901                 struct sockaddr *sa = svc_addr(rqstp);
902                 /*
903                  * This is a little silly; with sessions there's no real
904                  * use for the callback address.  Use the peer address
905                  * as a reasonable default for now, but consider fixing
906                  * the rpc client not to require an address in the
907                  * future:
908                  */
909                 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
910                 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
911         }
912         nfsd4_probe_callback(clp);
913         return new;
914 }
915
916 /* caller must hold client_lock */
917 static struct nfsd4_session *
918 find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
919 {
920         struct nfsd4_session *elem;
921         int idx;
922
923         dump_sessionid(__func__, sessionid);
924         idx = hash_sessionid(sessionid);
925         /* Search in the appropriate list */
926         list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
927                 if (!memcmp(elem->se_sessionid.data, sessionid->data,
928                             NFS4_MAX_SESSIONID_LEN)) {
929                         return elem;
930                 }
931         }
932
933         dprintk("%s: session not found\n", __func__);
934         return NULL;
935 }
936
937 /* caller must hold client_lock */
938 static void
939 unhash_session(struct nfsd4_session *ses)
940 {
941         list_del(&ses->se_hash);
942         spin_lock(&ses->se_client->cl_lock);
943         list_del(&ses->se_perclnt);
944         spin_unlock(&ses->se_client->cl_lock);
945 }
946
947 /* must be called under the client_lock */
948 static inline void
949 renew_client_locked(struct nfs4_client *clp)
950 {
951         if (is_client_expired(clp)) {
952                 dprintk("%s: client (clientid %08x/%08x) already expired\n",
953                         __func__,
954                         clp->cl_clientid.cl_boot,
955                         clp->cl_clientid.cl_id);
956                 return;
957         }
958
959         dprintk("renewing client (clientid %08x/%08x)\n", 
960                         clp->cl_clientid.cl_boot, 
961                         clp->cl_clientid.cl_id);
962         list_move_tail(&clp->cl_lru, &client_lru);
963         clp->cl_time = get_seconds();
964 }
965
966 static inline void
967 renew_client(struct nfs4_client *clp)
968 {
969         spin_lock(&client_lock);
970         renew_client_locked(clp);
971         spin_unlock(&client_lock);
972 }
973
974 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
975 static int
976 STALE_CLIENTID(clientid_t *clid)
977 {
978         if (clid->cl_boot == boot_time)
979                 return 0;
980         dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
981                 clid->cl_boot, clid->cl_id, boot_time);
982         return 1;
983 }
984
985 /* 
986  * XXX Should we use a slab cache ?
987  * This type of memory management is somewhat inefficient, but we use it
988  * anyway since SETCLIENTID is not a common operation.
989  */
990 static struct nfs4_client *alloc_client(struct xdr_netobj name)
991 {
992         struct nfs4_client *clp;
993
994         clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
995         if (clp == NULL)
996                 return NULL;
997         clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
998         if (clp->cl_name.data == NULL) {
999                 kfree(clp);
1000                 return NULL;
1001         }
1002         clp->cl_name.len = name.len;
1003         return clp;
1004 }
1005
1006 static inline void
1007 free_client(struct nfs4_client *clp)
1008 {
1009         while (!list_empty(&clp->cl_sessions)) {
1010                 struct nfsd4_session *ses;
1011                 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1012                                 se_perclnt);
1013                 list_del(&ses->se_perclnt);
1014                 nfsd4_put_session(ses);
1015         }
1016         if (clp->cl_cred.cr_group_info)
1017                 put_group_info(clp->cl_cred.cr_group_info);
1018         kfree(clp->cl_principal);
1019         kfree(clp->cl_name.data);
1020         kfree(clp);
1021 }
1022
1023 void
1024 release_session_client(struct nfsd4_session *session)
1025 {
1026         struct nfs4_client *clp = session->se_client;
1027
1028         if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
1029                 return;
1030         if (is_client_expired(clp)) {
1031                 free_client(clp);
1032                 session->se_client = NULL;
1033         } else
1034                 renew_client_locked(clp);
1035         spin_unlock(&client_lock);
1036 }
1037
1038 /* must be called under the client_lock */
1039 static inline void
1040 unhash_client_locked(struct nfs4_client *clp)
1041 {
1042         struct nfsd4_session *ses;
1043
1044         mark_client_expired(clp);
1045         list_del(&clp->cl_lru);
1046         spin_lock(&clp->cl_lock);
1047         list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1048                 list_del_init(&ses->se_hash);
1049         spin_unlock(&clp->cl_lock);
1050 }
1051
1052 static void
1053 expire_client(struct nfs4_client *clp)
1054 {
1055         struct nfs4_openowner *oo;
1056         struct nfs4_delegation *dp;
1057         struct list_head reaplist;
1058
1059         INIT_LIST_HEAD(&reaplist);
1060         spin_lock(&recall_lock);
1061         while (!list_empty(&clp->cl_delegations)) {
1062                 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
1063                 list_del_init(&dp->dl_perclnt);
1064                 list_move(&dp->dl_recall_lru, &reaplist);
1065         }
1066         spin_unlock(&recall_lock);
1067         while (!list_empty(&reaplist)) {
1068                 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1069                 unhash_delegation(dp);
1070         }
1071         while (!list_empty(&clp->cl_openowners)) {
1072                 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1073                 release_openowner(oo);
1074         }
1075         nfsd4_shutdown_callback(clp);
1076         if (clp->cl_cb_conn.cb_xprt)
1077                 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1078         list_del(&clp->cl_idhash);
1079         list_del(&clp->cl_strhash);
1080         spin_lock(&client_lock);
1081         unhash_client_locked(clp);
1082         if (atomic_read(&clp->cl_refcount) == 0)
1083                 free_client(clp);
1084         spin_unlock(&client_lock);
1085 }
1086
1087 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1088 {
1089         memcpy(target->cl_verifier.data, source->data,
1090                         sizeof(target->cl_verifier.data));
1091 }
1092
1093 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1094 {
1095         target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
1096         target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
1097 }
1098
1099 static void copy_cred(struct svc_cred *target, struct svc_cred *source)
1100 {
1101         target->cr_uid = source->cr_uid;
1102         target->cr_gid = source->cr_gid;
1103         target->cr_group_info = source->cr_group_info;
1104         get_group_info(target->cr_group_info);
1105 }
1106
1107 static int same_name(const char *n1, const char *n2)
1108 {
1109         return 0 == memcmp(n1, n2, HEXDIR_LEN);
1110 }
1111
1112 static int
1113 same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1114 {
1115         return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1116 }
1117
1118 static int
1119 same_clid(clientid_t *cl1, clientid_t *cl2)
1120 {
1121         return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1122 }
1123
1124 /* XXX what about NGROUP */
1125 static int
1126 same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1127 {
1128         return cr1->cr_uid == cr2->cr_uid;
1129 }
1130
1131 static void gen_clid(struct nfs4_client *clp)
1132 {
1133         static u32 current_clientid = 1;
1134
1135         clp->cl_clientid.cl_boot = boot_time;
1136         clp->cl_clientid.cl_id = current_clientid++; 
1137 }
1138
1139 static void gen_confirm(struct nfs4_client *clp)
1140 {
1141         static u32 i;
1142         u32 *p;
1143
1144         p = (u32 *)clp->cl_confirm.data;
1145         *p++ = get_seconds();
1146         *p++ = i++;
1147 }
1148
1149 static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
1150 {
1151         return idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1152 }
1153
1154 static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
1155 {
1156         struct nfs4_stid *s;
1157
1158         s = find_stateid(cl, t);
1159         if (!s)
1160                 return NULL;
1161         if (typemask & s->sc_type)
1162                 return s;
1163         return NULL;
1164 }
1165
1166 static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1167                 struct svc_rqst *rqstp, nfs4_verifier *verf)
1168 {
1169         struct nfs4_client *clp;
1170         struct sockaddr *sa = svc_addr(rqstp);
1171         char *princ;
1172
1173         clp = alloc_client(name);
1174         if (clp == NULL)
1175                 return NULL;
1176
1177         INIT_LIST_HEAD(&clp->cl_sessions);
1178
1179         princ = svc_gss_principal(rqstp);
1180         if (princ) {
1181                 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
1182                 if (clp->cl_principal == NULL) {
1183                         free_client(clp);
1184                         return NULL;
1185                 }
1186         }
1187
1188         idr_init(&clp->cl_stateids);
1189         memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
1190         atomic_set(&clp->cl_refcount, 0);
1191         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1192         INIT_LIST_HEAD(&clp->cl_idhash);
1193         INIT_LIST_HEAD(&clp->cl_strhash);
1194         INIT_LIST_HEAD(&clp->cl_openowners);
1195         INIT_LIST_HEAD(&clp->cl_delegations);
1196         INIT_LIST_HEAD(&clp->cl_lru);
1197         INIT_LIST_HEAD(&clp->cl_callbacks);
1198         spin_lock_init(&clp->cl_lock);
1199         INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
1200         clp->cl_time = get_seconds();
1201         clear_bit(0, &clp->cl_cb_slot_busy);
1202         rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1203         copy_verf(clp, verf);
1204         rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1205         clp->cl_flavor = rqstp->rq_flavor;
1206         copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1207         gen_confirm(clp);
1208         clp->cl_cb_session = NULL;
1209         return clp;
1210 }
1211
1212 static void
1213 add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1214 {
1215         unsigned int idhashval;
1216
1217         list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1218         idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1219         list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
1220         renew_client(clp);
1221 }
1222
1223 static void
1224 move_to_confirmed(struct nfs4_client *clp)
1225 {
1226         unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1227         unsigned int strhashval;
1228
1229         dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1230         list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
1231         strhashval = clientstr_hashval(clp->cl_recdir);
1232         list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
1233         renew_client(clp);
1234 }
1235
1236 static struct nfs4_client *
1237 find_confirmed_client(clientid_t *clid)
1238 {
1239         struct nfs4_client *clp;
1240         unsigned int idhashval = clientid_hashval(clid->cl_id);
1241
1242         list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
1243                 if (same_clid(&clp->cl_clientid, clid)) {
1244                         renew_client(clp);
1245                         return clp;
1246                 }
1247         }
1248         return NULL;
1249 }
1250
1251 static struct nfs4_client *
1252 find_unconfirmed_client(clientid_t *clid)
1253 {
1254         struct nfs4_client *clp;
1255         unsigned int idhashval = clientid_hashval(clid->cl_id);
1256
1257         list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
1258                 if (same_clid(&clp->cl_clientid, clid))
1259                         return clp;
1260         }
1261         return NULL;
1262 }
1263
1264 static bool clp_used_exchangeid(struct nfs4_client *clp)
1265 {
1266         return clp->cl_exchange_flags != 0;
1267
1268
1269 static struct nfs4_client *
1270 find_confirmed_client_by_str(const char *dname, unsigned int hashval)
1271 {
1272         struct nfs4_client *clp;
1273
1274         list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
1275                 if (same_name(clp->cl_recdir, dname))
1276                         return clp;
1277         }
1278         return NULL;
1279 }
1280
1281 static struct nfs4_client *
1282 find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
1283 {
1284         struct nfs4_client *clp;
1285
1286         list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
1287                 if (same_name(clp->cl_recdir, dname))
1288                         return clp;
1289         }
1290         return NULL;
1291 }
1292
1293 static void
1294 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
1295 {
1296         struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1297         struct sockaddr *sa = svc_addr(rqstp);
1298         u32 scopeid = rpc_get_scope_id(sa);
1299         unsigned short expected_family;
1300
1301         /* Currently, we only support tcp and tcp6 for the callback channel */
1302         if (se->se_callback_netid_len == 3 &&
1303             !memcmp(se->se_callback_netid_val, "tcp", 3))
1304                 expected_family = AF_INET;
1305         else if (se->se_callback_netid_len == 4 &&
1306                  !memcmp(se->se_callback_netid_val, "tcp6", 4))
1307                 expected_family = AF_INET6;
1308         else
1309                 goto out_err;
1310
1311         conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
1312                                             se->se_callback_addr_len,
1313                                             (struct sockaddr *)&conn->cb_addr,
1314                                             sizeof(conn->cb_addr));
1315
1316         if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1317                 goto out_err;
1318
1319         if (conn->cb_addr.ss_family == AF_INET6)
1320                 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1321
1322         conn->cb_prog = se->se_callback_prog;
1323         conn->cb_ident = se->se_callback_ident;
1324         memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
1325         return;
1326 out_err:
1327         conn->cb_addr.ss_family = AF_UNSPEC;
1328         conn->cb_addrlen = 0;
1329         dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1330                 "will not receive delegations\n",
1331                 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1332
1333         return;
1334 }
1335
1336 /*
1337  * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
1338  */
1339 void
1340 nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1341 {
1342         struct nfsd4_slot *slot = resp->cstate.slot;
1343         unsigned int base;
1344
1345         dprintk("--> %s slot %p\n", __func__, slot);
1346
1347         slot->sl_opcnt = resp->opcnt;
1348         slot->sl_status = resp->cstate.status;
1349
1350         if (nfsd4_not_cached(resp)) {
1351                 slot->sl_datalen = 0;
1352                 return;
1353         }
1354         slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1355         base = (char *)resp->cstate.datap -
1356                                         (char *)resp->xbuf->head[0].iov_base;
1357         if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1358                                     slot->sl_datalen))
1359                 WARN("%s: sessions DRC could not cache compound\n", __func__);
1360         return;
1361 }
1362
1363 /*
1364  * Encode the replay sequence operation from the slot values.
1365  * If cachethis is FALSE encode the uncached rep error on the next
1366  * operation which sets resp->p and increments resp->opcnt for
1367  * nfs4svc_encode_compoundres.
1368  *
1369  */
1370 static __be32
1371 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1372                           struct nfsd4_compoundres *resp)
1373 {
1374         struct nfsd4_op *op;
1375         struct nfsd4_slot *slot = resp->cstate.slot;
1376
1377         dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
1378                 resp->opcnt, resp->cstate.slot->sl_cachethis);
1379
1380         /* Encode the replayed sequence operation */
1381         op = &args->ops[resp->opcnt - 1];
1382         nfsd4_encode_operation(resp, op);
1383
1384         /* Return nfserr_retry_uncached_rep in next operation. */
1385         if (args->opcnt > 1 && slot->sl_cachethis == 0) {
1386                 op = &args->ops[resp->opcnt++];
1387                 op->status = nfserr_retry_uncached_rep;
1388                 nfsd4_encode_operation(resp, op);
1389         }
1390         return op->status;
1391 }
1392
1393 /*
1394  * The sequence operation is not cached because we can use the slot and
1395  * session values.
1396  */
1397 __be32
1398 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1399                          struct nfsd4_sequence *seq)
1400 {
1401         struct nfsd4_slot *slot = resp->cstate.slot;
1402         __be32 status;
1403
1404         dprintk("--> %s slot %p\n", __func__, slot);
1405
1406         /* Either returns 0 or nfserr_retry_uncached */
1407         status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1408         if (status == nfserr_retry_uncached_rep)
1409                 return status;
1410
1411         /* The sequence operation has been encoded, cstate->datap set. */
1412         memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
1413
1414         resp->opcnt = slot->sl_opcnt;
1415         resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1416         status = slot->sl_status;
1417
1418         return status;
1419 }
1420
1421 /*
1422  * Set the exchange_id flags returned by the server.
1423  */
1424 static void
1425 nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1426 {
1427         /* pNFS is not supported */
1428         new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1429
1430         /* Referrals are supported, Migration is not. */
1431         new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1432
1433         /* set the wire flags to return to client. */
1434         clid->flags = new->cl_exchange_flags;
1435 }
1436
1437 __be32
1438 nfsd4_exchange_id(struct svc_rqst *rqstp,
1439                   struct nfsd4_compound_state *cstate,
1440                   struct nfsd4_exchange_id *exid)
1441 {
1442         struct nfs4_client *unconf, *conf, *new;
1443         int status;
1444         unsigned int            strhashval;
1445         char                    dname[HEXDIR_LEN];
1446         char                    addr_str[INET6_ADDRSTRLEN];
1447         nfs4_verifier           verf = exid->verifier;
1448         struct sockaddr         *sa = svc_addr(rqstp);
1449
1450         rpc_ntop(sa, addr_str, sizeof(addr_str));
1451         dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1452                 "ip_addr=%s flags %x, spa_how %d\n",
1453                 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
1454                 addr_str, exid->flags, exid->spa_how);
1455
1456         if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
1457                 return nfserr_inval;
1458
1459         /* Currently only support SP4_NONE */
1460         switch (exid->spa_how) {
1461         case SP4_NONE:
1462                 break;
1463         case SP4_SSV:
1464                 return nfserr_serverfault;
1465         default:
1466                 BUG();                          /* checked by xdr code */
1467         case SP4_MACH_CRED:
1468                 return nfserr_serverfault;      /* no excuse :-/ */
1469         }
1470
1471         status = nfs4_make_rec_clidname(dname, &exid->clname);
1472
1473         if (status)
1474                 goto error;
1475
1476         strhashval = clientstr_hashval(dname);
1477
1478         nfs4_lock_state();
1479         status = nfs_ok;
1480
1481         conf = find_confirmed_client_by_str(dname, strhashval);
1482         if (conf) {
1483                 if (!clp_used_exchangeid(conf)) {
1484                         status = nfserr_clid_inuse; /* XXX: ? */
1485                         goto out;
1486                 }
1487                 if (!same_verf(&verf, &conf->cl_verifier)) {
1488                         /* 18.35.4 case 8 */
1489                         if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1490                                 status = nfserr_not_same;
1491                                 goto out;
1492                         }
1493                         /* Client reboot: destroy old state */
1494                         expire_client(conf);
1495                         goto out_new;
1496                 }
1497                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1498                         /* 18.35.4 case 9 */
1499                         if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1500                                 status = nfserr_perm;
1501                                 goto out;
1502                         }
1503                         expire_client(conf);
1504                         goto out_new;
1505                 }
1506                 /*
1507                  * Set bit when the owner id and verifier map to an already
1508                  * confirmed client id (18.35.3).
1509                  */
1510                 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1511
1512                 /*
1513                  * Falling into 18.35.4 case 2, possible router replay.
1514                  * Leave confirmed record intact and return same result.
1515                  */
1516                 copy_verf(conf, &verf);
1517                 new = conf;
1518                 goto out_copy;
1519         }
1520
1521         /* 18.35.4 case 7 */
1522         if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1523                 status = nfserr_noent;
1524                 goto out;
1525         }
1526
1527         unconf  = find_unconfirmed_client_by_str(dname, strhashval);
1528         if (unconf) {
1529                 /*
1530                  * Possible retry or client restart.  Per 18.35.4 case 4,
1531                  * a new unconfirmed record should be generated regardless
1532                  * of whether any properties have changed.
1533                  */
1534                 expire_client(unconf);
1535         }
1536
1537 out_new:
1538         /* Normal case */
1539         new = create_client(exid->clname, dname, rqstp, &verf);
1540         if (new == NULL) {
1541                 status = nfserr_jukebox;
1542                 goto out;
1543         }
1544
1545         gen_clid(new);
1546         add_to_unconfirmed(new, strhashval);
1547 out_copy:
1548         exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1549         exid->clientid.cl_id = new->cl_clientid.cl_id;
1550
1551         exid->seqid = 1;
1552         nfsd4_set_ex_flags(new, exid);
1553
1554         dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1555                 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
1556         status = nfs_ok;
1557
1558 out:
1559         nfs4_unlock_state();
1560 error:
1561         dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1562         return status;
1563 }
1564
1565 static int
1566 check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
1567 {
1568         dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1569                 slot_seqid);
1570
1571         /* The slot is in use, and no response has been sent. */
1572         if (slot_inuse) {
1573                 if (seqid == slot_seqid)
1574                         return nfserr_jukebox;
1575                 else
1576                         return nfserr_seq_misordered;
1577         }
1578         /* Normal */
1579         if (likely(seqid == slot_seqid + 1))
1580                 return nfs_ok;
1581         /* Replay */
1582         if (seqid == slot_seqid)
1583                 return nfserr_replay_cache;
1584         /* Wraparound */
1585         if (seqid == 1 && (slot_seqid + 1) == 0)
1586                 return nfs_ok;
1587         /* Misordered replay or misordered new request */
1588         return nfserr_seq_misordered;
1589 }
1590
1591 /*
1592  * Cache the create session result into the create session single DRC
1593  * slot cache by saving the xdr structure. sl_seqid has been set.
1594  * Do this for solo or embedded create session operations.
1595  */
1596 static void
1597 nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1598                            struct nfsd4_clid_slot *slot, int nfserr)
1599 {
1600         slot->sl_status = nfserr;
1601         memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1602 }
1603
1604 static __be32
1605 nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1606                             struct nfsd4_clid_slot *slot)
1607 {
1608         memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1609         return slot->sl_status;
1610 }
1611
1612 #define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1613                         2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1614                         1 +     /* MIN tag is length with zero, only length */ \
1615                         3 +     /* version, opcount, opcode */ \
1616                         XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1617                                 /* seqid, slotID, slotID, cache */ \
1618                         4 ) * sizeof(__be32))
1619
1620 #define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1621                         2 +     /* verifier: AUTH_NULL, length 0 */\
1622                         1 +     /* status */ \
1623                         1 +     /* MIN tag is length with zero, only length */ \
1624                         3 +     /* opcount, opcode, opstatus*/ \
1625                         XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1626                                 /* seqid, slotID, slotID, slotID, status */ \
1627                         5 ) * sizeof(__be32))
1628
1629 static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
1630 {
1631         return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
1632                 || fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
1633 }
1634
1635 __be32
1636 nfsd4_create_session(struct svc_rqst *rqstp,
1637                      struct nfsd4_compound_state *cstate,
1638                      struct nfsd4_create_session *cr_ses)
1639 {
1640         struct sockaddr *sa = svc_addr(rqstp);
1641         struct nfs4_client *conf, *unconf;
1642         struct nfsd4_session *new;
1643         struct nfsd4_clid_slot *cs_slot = NULL;
1644         bool confirm_me = false;
1645         int status = 0;
1646
1647         if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1648                 return nfserr_inval;
1649
1650         nfs4_lock_state();
1651         unconf = find_unconfirmed_client(&cr_ses->clientid);
1652         conf = find_confirmed_client(&cr_ses->clientid);
1653
1654         if (conf) {
1655                 cs_slot = &conf->cl_cs_slot;
1656                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1657                 if (status == nfserr_replay_cache) {
1658                         dprintk("Got a create_session replay! seqid= %d\n",
1659                                 cs_slot->sl_seqid);
1660                         /* Return the cached reply status */
1661                         status = nfsd4_replay_create_session(cr_ses, cs_slot);
1662                         goto out;
1663                 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
1664                         status = nfserr_seq_misordered;
1665                         dprintk("Sequence misordered!\n");
1666                         dprintk("Expected seqid= %d but got seqid= %d\n",
1667                                 cs_slot->sl_seqid, cr_ses->seqid);
1668                         goto out;
1669                 }
1670         } else if (unconf) {
1671                 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
1672                     !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
1673                         status = nfserr_clid_inuse;
1674                         goto out;
1675                 }
1676
1677                 cs_slot = &unconf->cl_cs_slot;
1678                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1679                 if (status) {
1680                         /* an unconfirmed replay returns misordered */
1681                         status = nfserr_seq_misordered;
1682                         goto out;
1683                 }
1684
1685                 confirm_me = true;
1686                 conf = unconf;
1687         } else {
1688                 status = nfserr_stale_clientid;
1689                 goto out;
1690         }
1691
1692         /*
1693          * XXX: we should probably set this at creation time, and check
1694          * for consistent minorversion use throughout:
1695          */
1696         conf->cl_minorversion = 1;
1697         /*
1698          * We do not support RDMA or persistent sessions
1699          */
1700         cr_ses->flags &= ~SESSION4_PERSIST;
1701         cr_ses->flags &= ~SESSION4_RDMA;
1702
1703         status = nfserr_toosmall;
1704         if (check_forechannel_attrs(cr_ses->fore_channel))
1705                 goto out;
1706
1707         status = nfserr_jukebox;
1708         new = alloc_init_session(rqstp, conf, cr_ses);
1709         if (!new)
1710                 goto out;
1711         status = nfs_ok;
1712         memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
1713                NFS4_MAX_SESSIONID_LEN);
1714         memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1715                 sizeof(struct nfsd4_channel_attrs));
1716         cs_slot->sl_seqid++;
1717         cr_ses->seqid = cs_slot->sl_seqid;
1718
1719         /* cache solo and embedded create sessions under the state lock */
1720         nfsd4_cache_create_session(cr_ses, cs_slot, status);
1721         if (confirm_me)
1722                 move_to_confirmed(conf);
1723 out:
1724         nfs4_unlock_state();
1725         dprintk("%s returns %d\n", __func__, ntohl(status));
1726         return status;
1727 }
1728
1729 static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1730 {
1731         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1732         struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1733
1734         return argp->opcnt == resp->opcnt;
1735 }
1736
1737 static __be32 nfsd4_map_bcts_dir(u32 *dir)
1738 {
1739         switch (*dir) {
1740         case NFS4_CDFC4_FORE:
1741         case NFS4_CDFC4_BACK:
1742                 return nfs_ok;
1743         case NFS4_CDFC4_FORE_OR_BOTH:
1744         case NFS4_CDFC4_BACK_OR_BOTH:
1745                 *dir = NFS4_CDFC4_BOTH;
1746                 return nfs_ok;
1747         };
1748         return nfserr_inval;
1749 }
1750
1751 __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1752                      struct nfsd4_compound_state *cstate,
1753                      struct nfsd4_bind_conn_to_session *bcts)
1754 {
1755         __be32 status;
1756
1757         if (!nfsd4_last_compound_op(rqstp))
1758                 return nfserr_not_only_op;
1759         spin_lock(&client_lock);
1760         cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1761         /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1762          * client_lock iself: */
1763         if (cstate->session) {
1764                 nfsd4_get_session(cstate->session);
1765                 atomic_inc(&cstate->session->se_client->cl_refcount);
1766         }
1767         spin_unlock(&client_lock);
1768         if (!cstate->session)
1769                 return nfserr_badsession;
1770
1771         status = nfsd4_map_bcts_dir(&bcts->dir);
1772         if (!status)
1773                 nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1774         return status;
1775 }
1776
1777 static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1778 {
1779         if (!session)
1780                 return 0;
1781         return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1782 }
1783
1784 __be32
1785 nfsd4_destroy_session(struct svc_rqst *r,
1786                       struct nfsd4_compound_state *cstate,
1787                       struct nfsd4_destroy_session *sessionid)
1788 {
1789         struct nfsd4_session *ses;
1790         u32 status = nfserr_badsession;
1791
1792         /* Notes:
1793          * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1794          * - Should we return nfserr_back_chan_busy if waiting for
1795          *   callbacks on to-be-destroyed session?
1796          * - Do we need to clear any callback info from previous session?
1797          */
1798
1799         if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
1800                 if (!nfsd4_last_compound_op(r))
1801                         return nfserr_not_only_op;
1802         }
1803         dump_sessionid(__func__, &sessionid->sessionid);
1804         spin_lock(&client_lock);
1805         ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1806         if (!ses) {
1807                 spin_unlock(&client_lock);
1808                 goto out;
1809         }
1810
1811         unhash_session(ses);
1812         spin_unlock(&client_lock);
1813
1814         nfs4_lock_state();
1815         nfsd4_probe_callback_sync(ses->se_client);
1816         nfs4_unlock_state();
1817
1818         nfsd4_del_conns(ses);
1819
1820         nfsd4_put_session(ses);
1821         status = nfs_ok;
1822 out:
1823         dprintk("%s returns %d\n", __func__, ntohl(status));
1824         return status;
1825 }
1826
1827 static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
1828 {
1829         struct nfsd4_conn *c;
1830
1831         list_for_each_entry(c, &s->se_conns, cn_persession) {
1832                 if (c->cn_xprt == xpt) {
1833                         return c;
1834                 }
1835         }
1836         return NULL;
1837 }
1838
1839 static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
1840 {
1841         struct nfs4_client *clp = ses->se_client;
1842         struct nfsd4_conn *c;
1843         int ret;
1844
1845         spin_lock(&clp->cl_lock);
1846         c = __nfsd4_find_conn(new->cn_xprt, ses);
1847         if (c) {
1848                 spin_unlock(&clp->cl_lock);
1849                 free_conn(new);
1850                 return;
1851         }
1852         __nfsd4_hash_conn(new, ses);
1853         spin_unlock(&clp->cl_lock);
1854         ret = nfsd4_register_conn(new);
1855         if (ret)
1856                 /* oops; xprt is already down: */
1857                 nfsd4_conn_lost(&new->cn_xpt_user);
1858         return;
1859 }
1860
1861 static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
1862 {
1863         struct nfsd4_compoundargs *args = rqstp->rq_argp;
1864
1865         return args->opcnt > session->se_fchannel.maxops;
1866 }
1867
1868 static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
1869                                   struct nfsd4_session *session)
1870 {
1871         struct xdr_buf *xb = &rqstp->rq_arg;
1872
1873         return xb->len > session->se_fchannel.maxreq_sz;
1874 }
1875
1876 __be32
1877 nfsd4_sequence(struct svc_rqst *rqstp,
1878                struct nfsd4_compound_state *cstate,
1879                struct nfsd4_sequence *seq)
1880 {
1881         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1882         struct nfsd4_session *session;
1883         struct nfsd4_slot *slot;
1884         struct nfsd4_conn *conn;
1885         int status;
1886
1887         if (resp->opcnt != 1)
1888                 return nfserr_sequence_pos;
1889
1890         /*
1891          * Will be either used or freed by nfsd4_sequence_check_conn
1892          * below.
1893          */
1894         conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1895         if (!conn)
1896                 return nfserr_jukebox;
1897
1898         spin_lock(&client_lock);
1899         status = nfserr_badsession;
1900         session = find_in_sessionid_hashtbl(&seq->sessionid);
1901         if (!session)
1902                 goto out;
1903
1904         status = nfserr_too_many_ops;
1905         if (nfsd4_session_too_many_ops(rqstp, session))
1906                 goto out;
1907
1908         status = nfserr_req_too_big;
1909         if (nfsd4_request_too_big(rqstp, session))
1910                 goto out;
1911
1912         status = nfserr_badslot;
1913         if (seq->slotid >= session->se_fchannel.maxreqs)
1914                 goto out;
1915
1916         slot = session->se_slots[seq->slotid];
1917         dprintk("%s: slotid %d\n", __func__, seq->slotid);
1918
1919         /* We do not negotiate the number of slots yet, so set the
1920          * maxslots to the session maxreqs which is used to encode
1921          * sr_highest_slotid and the sr_target_slot id to maxslots */
1922         seq->maxslots = session->se_fchannel.maxreqs;
1923
1924         status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
1925         if (status == nfserr_replay_cache) {
1926                 cstate->slot = slot;
1927                 cstate->session = session;
1928                 /* Return the cached reply status and set cstate->status
1929                  * for nfsd4_proc_compound processing */
1930                 status = nfsd4_replay_cache_entry(resp, seq);
1931                 cstate->status = nfserr_replay_cache;
1932                 goto out;
1933         }
1934         if (status)
1935                 goto out;
1936
1937         nfsd4_sequence_check_conn(conn, session);
1938         conn = NULL;
1939
1940         /* Success! bump slot seqid */
1941         slot->sl_inuse = true;
1942         slot->sl_seqid = seq->seqid;
1943         slot->sl_cachethis = seq->cachethis;
1944
1945         cstate->slot = slot;
1946         cstate->session = session;
1947
1948 out:
1949         /* Hold a session reference until done processing the compound. */
1950         if (cstate->session) {
1951                 struct nfs4_client *clp = session->se_client;
1952
1953                 nfsd4_get_session(cstate->session);
1954                 atomic_inc(&clp->cl_refcount);
1955                 switch (clp->cl_cb_state) {
1956                 case NFSD4_CB_DOWN:
1957                         seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
1958                         break;
1959                 case NFSD4_CB_FAULT:
1960                         seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
1961                         break;
1962                 default:
1963                         seq->status_flags = 0;
1964                 }
1965         }
1966         kfree(conn);
1967         spin_unlock(&client_lock);
1968         dprintk("%s: return %d\n", __func__, ntohl(status));
1969         return status;
1970 }
1971
1972 static inline bool has_resources(struct nfs4_client *clp)
1973 {
1974         return !list_empty(&clp->cl_openowners)
1975                 || !list_empty(&clp->cl_delegations)
1976                 || !list_empty(&clp->cl_sessions);
1977 }
1978
1979 __be32
1980 nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
1981 {
1982         struct nfs4_client *conf, *unconf, *clp;
1983         int status = 0;
1984
1985         nfs4_lock_state();
1986         unconf = find_unconfirmed_client(&dc->clientid);
1987         conf = find_confirmed_client(&dc->clientid);
1988
1989         if (conf) {
1990                 clp = conf;
1991
1992                 if (!is_client_expired(conf) && has_resources(conf)) {
1993                         status = nfserr_clientid_busy;
1994                         goto out;
1995                 }
1996
1997                 /* rfc5661 18.50.3 */
1998                 if (cstate->session && conf == cstate->session->se_client) {
1999                         status = nfserr_clientid_busy;
2000                         goto out;
2001                 }
2002         } else if (unconf)
2003                 clp = unconf;
2004         else {
2005                 status = nfserr_stale_clientid;
2006                 goto out;
2007         }
2008
2009         expire_client(clp);
2010 out:
2011         nfs4_unlock_state();
2012         dprintk("%s return %d\n", __func__, ntohl(status));
2013         return status;
2014 }
2015
2016 __be32
2017 nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2018 {
2019         int status = 0;
2020
2021         if (rc->rca_one_fs) {
2022                 if (!cstate->current_fh.fh_dentry)
2023                         return nfserr_nofilehandle;
2024                 /*
2025                  * We don't take advantage of the rca_one_fs case.
2026                  * That's OK, it's optional, we can safely ignore it.
2027                  */
2028                  return nfs_ok;
2029         }
2030
2031         nfs4_lock_state();
2032         status = nfserr_complete_already;
2033         if (cstate->session->se_client->cl_firststate)
2034                 goto out;
2035
2036         status = nfserr_stale_clientid;
2037         if (is_client_expired(cstate->session->se_client))
2038                 /*
2039                  * The following error isn't really legal.
2040                  * But we only get here if the client just explicitly
2041                  * destroyed the client.  Surely it no longer cares what
2042                  * error it gets back on an operation for the dead
2043                  * client.
2044                  */
2045                 goto out;
2046
2047         status = nfs_ok;
2048         nfsd4_create_clid_dir(cstate->session->se_client);
2049 out:
2050         nfs4_unlock_state();
2051         return status;
2052 }
2053
2054 __be32
2055 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2056                   struct nfsd4_setclientid *setclid)
2057 {
2058         struct xdr_netobj       clname = setclid->se_name;
2059         nfs4_verifier           clverifier = setclid->se_verf;
2060         unsigned int            strhashval;
2061         struct nfs4_client      *conf, *unconf, *new;
2062         __be32                  status;
2063         char                    dname[HEXDIR_LEN];
2064         
2065         status = nfs4_make_rec_clidname(dname, &clname);
2066         if (status)
2067                 return status;
2068
2069         /* 
2070          * XXX The Duplicate Request Cache (DRC) has been checked (??)
2071          * We get here on a DRC miss.
2072          */
2073
2074         strhashval = clientstr_hashval(dname);
2075
2076         nfs4_lock_state();
2077         conf = find_confirmed_client_by_str(dname, strhashval);
2078         if (conf) {
2079                 /* RFC 3530 14.2.33 CASE 0: */
2080                 status = nfserr_clid_inuse;
2081                 if (clp_used_exchangeid(conf))
2082                         goto out;
2083                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
2084                         char addr_str[INET6_ADDRSTRLEN];
2085                         rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2086                                  sizeof(addr_str));
2087                         dprintk("NFSD: setclientid: string in use by client "
2088                                 "at %s\n", addr_str);
2089                         goto out;
2090                 }
2091         }
2092         /*
2093          * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
2094          * has a description of SETCLIENTID request processing consisting
2095          * of 5 bullet points, labeled as CASE0 - CASE4 below.
2096          */
2097         unconf = find_unconfirmed_client_by_str(dname, strhashval);
2098         status = nfserr_jukebox;
2099         if (!conf) {
2100                 /*
2101                  * RFC 3530 14.2.33 CASE 4:
2102                  * placed first, because it is the normal case
2103                  */
2104                 if (unconf)
2105                         expire_client(unconf);
2106                 new = create_client(clname, dname, rqstp, &clverifier);
2107                 if (new == NULL)
2108                         goto out;
2109                 gen_clid(new);
2110         } else if (same_verf(&conf->cl_verifier, &clverifier)) {
2111                 /*
2112                  * RFC 3530 14.2.33 CASE 1:
2113                  * probable callback update
2114                  */
2115                 if (unconf) {
2116                         /* Note this is removing unconfirmed {*x***},
2117                          * which is stronger than RFC recommended {vxc**}.
2118                          * This has the advantage that there is at most
2119                          * one {*x***} in either list at any time.
2120                          */
2121                         expire_client(unconf);
2122                 }
2123                 new = create_client(clname, dname, rqstp, &clverifier);
2124                 if (new == NULL)
2125                         goto out;
2126                 copy_clid(new, conf);
2127         } else if (!unconf) {
2128                 /*
2129                  * RFC 3530 14.2.33 CASE 2:
2130                  * probable client reboot; state will be removed if
2131                  * confirmed.
2132                  */
2133                 new = create_client(clname, dname, rqstp, &clverifier);
2134                 if (new == NULL)
2135                         goto out;
2136                 gen_clid(new);
2137         } else {
2138                 /*
2139                  * RFC 3530 14.2.33 CASE 3:
2140                  * probable client reboot; state will be removed if
2141                  * confirmed.
2142                  */
2143                 expire_client(unconf);
2144                 new = create_client(clname, dname, rqstp, &clverifier);
2145                 if (new == NULL)
2146                         goto out;
2147                 gen_clid(new);
2148         }
2149         /*
2150          * XXX: we should probably set this at creation time, and check
2151          * for consistent minorversion use throughout:
2152          */
2153         new->cl_minorversion = 0;
2154         gen_callback(new, setclid, rqstp);
2155         add_to_unconfirmed(new, strhashval);
2156         setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2157         setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2158         memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2159         status = nfs_ok;
2160 out:
2161         nfs4_unlock_state();
2162         return status;
2163 }
2164
2165
2166 /*
2167  * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
2168  * a description of SETCLIENTID_CONFIRM request processing consisting of 4
2169  * bullets, labeled as CASE1 - CASE4 below.
2170  */
2171 __be32
2172 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2173                          struct nfsd4_compound_state *cstate,
2174                          struct nfsd4_setclientid_confirm *setclientid_confirm)
2175 {
2176         struct sockaddr *sa = svc_addr(rqstp);
2177         struct nfs4_client *conf, *unconf;
2178         nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
2179         clientid_t * clid = &setclientid_confirm->sc_clientid;
2180         __be32 status;
2181
2182         if (STALE_CLIENTID(clid))
2183                 return nfserr_stale_clientid;
2184         /* 
2185          * XXX The Duplicate Request Cache (DRC) has been checked (??)
2186          * We get here on a DRC miss.
2187          */
2188
2189         nfs4_lock_state();
2190
2191         conf = find_confirmed_client(clid);
2192         unconf = find_unconfirmed_client(clid);
2193
2194         status = nfserr_clid_inuse;
2195         if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
2196                 goto out;
2197         if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
2198                 goto out;
2199
2200         /*
2201          * section 14.2.34 of RFC 3530 has a description of
2202          * SETCLIENTID_CONFIRM request processing consisting
2203          * of 4 bullet points, labeled as CASE1 - CASE4 below.
2204          */
2205         if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
2206                 /*
2207                  * RFC 3530 14.2.34 CASE 1:
2208                  * callback update
2209                  */
2210                 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
2211                         status = nfserr_clid_inuse;
2212                 else {
2213                         nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2214                         nfsd4_probe_callback(conf);
2215                         expire_client(unconf);
2216                         status = nfs_ok;
2217
2218                 }
2219         } else if (conf && !unconf) {
2220                 /*
2221                  * RFC 3530 14.2.34 CASE 2:
2222                  * probable retransmitted request; play it safe and
2223                  * do nothing.
2224                  */
2225                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
2226                         status = nfserr_clid_inuse;
2227                 else
2228                         status = nfs_ok;
2229         } else if (!conf && unconf
2230                         && same_verf(&unconf->cl_confirm, &confirm)) {
2231                 /*
2232                  * RFC 3530 14.2.34 CASE 3:
2233                  * Normal case; new or rebooted client:
2234                  */
2235                 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
2236                         status = nfserr_clid_inuse;
2237                 } else {
2238                         unsigned int hash =
2239                                 clientstr_hashval(unconf->cl_recdir);
2240                         conf = find_confirmed_client_by_str(unconf->cl_recdir,
2241                                                             hash);
2242                         if (conf) {
2243                                 nfsd4_remove_clid_dir(conf);
2244                                 expire_client(conf);
2245                         }
2246                         move_to_confirmed(unconf);
2247                         conf = unconf;
2248                         nfsd4_probe_callback(conf);
2249                         status = nfs_ok;
2250                 }
2251         } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
2252             && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
2253                                                                 &confirm)))) {
2254                 /*
2255                  * RFC 3530 14.2.34 CASE 4:
2256                  * Client probably hasn't noticed that we rebooted yet.
2257                  */
2258                 status = nfserr_stale_clientid;
2259         } else {
2260                 /* check that we have hit one of the cases...*/
2261                 status = nfserr_clid_inuse;
2262         }
2263 out:
2264         nfs4_unlock_state();
2265         return status;
2266 }
2267
2268 static struct nfs4_file *nfsd4_alloc_file(void)
2269 {
2270         return kmem_cache_alloc(file_slab, GFP_KERNEL);
2271 }
2272
2273 /* OPEN Share state helper functions */
2274 static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2275 {
2276         unsigned int hashval = file_hashval(ino);
2277
2278         atomic_set(&fp->fi_ref, 1);
2279         INIT_LIST_HEAD(&fp->fi_hash);
2280         INIT_LIST_HEAD(&fp->fi_stateids);
2281         INIT_LIST_HEAD(&fp->fi_delegations);
2282         fp->fi_inode = igrab(ino);
2283         fp->fi_had_conflict = false;
2284         fp->fi_lease = NULL;
2285         memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2286         memset(fp->fi_access, 0, sizeof(fp->fi_access));
2287         spin_lock(&recall_lock);
2288         list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2289         spin_unlock(&recall_lock);
2290 }
2291
2292 static void
2293 nfsd4_free_slab(struct kmem_cache **slab)
2294 {
2295         if (*slab == NULL)
2296                 return;
2297         kmem_cache_destroy(*slab);
2298         *slab = NULL;
2299 }
2300
2301 void
2302 nfsd4_free_slabs(void)
2303 {
2304         nfsd4_free_slab(&openowner_slab);
2305         nfsd4_free_slab(&lockowner_slab);
2306         nfsd4_free_slab(&file_slab);
2307         nfsd4_free_slab(&stateid_slab);
2308         nfsd4_free_slab(&deleg_slab);
2309 }
2310
2311 int
2312 nfsd4_init_slabs(void)
2313 {
2314         openowner_slab = kmem_cache_create("nfsd4_openowners",
2315                         sizeof(struct nfs4_openowner), 0, 0, NULL);
2316         if (openowner_slab == NULL)
2317                 goto out_nomem;
2318         lockowner_slab = kmem_cache_create("nfsd4_lockowners",
2319                         sizeof(struct nfs4_openowner), 0, 0, NULL);
2320         if (lockowner_slab == NULL)
2321                 goto out_nomem;
2322         file_slab = kmem_cache_create("nfsd4_files",
2323                         sizeof(struct nfs4_file), 0, 0, NULL);
2324         if (file_slab == NULL)
2325                 goto out_nomem;
2326         stateid_slab = kmem_cache_create("nfsd4_stateids",
2327                         sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
2328         if (stateid_slab == NULL)
2329                 goto out_nomem;
2330         deleg_slab = kmem_cache_create("nfsd4_delegations",
2331                         sizeof(struct nfs4_delegation), 0, 0, NULL);
2332         if (deleg_slab == NULL)
2333                 goto out_nomem;
2334         return 0;
2335 out_nomem:
2336         nfsd4_free_slabs();
2337         dprintk("nfsd4: out of memory while initializing nfsv4\n");
2338         return -ENOMEM;
2339 }
2340
2341 void nfs4_free_openowner(struct nfs4_openowner *oo)
2342 {
2343         kfree(oo->oo_owner.so_owner.data);
2344         kmem_cache_free(openowner_slab, oo);
2345 }
2346
2347 void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2348 {
2349         kfree(lo->lo_owner.so_owner.data);
2350         kmem_cache_free(lockowner_slab, lo);
2351 }
2352
2353 static void init_nfs4_replay(struct nfs4_replay *rp)
2354 {
2355         rp->rp_status = nfserr_serverfault;
2356         rp->rp_buflen = 0;
2357         rp->rp_buf = rp->rp_ibuf;
2358 }
2359
2360 static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
2361 {
2362         struct nfs4_stateowner *sop;
2363
2364         sop = kmem_cache_alloc(slab, GFP_KERNEL);
2365         if (!sop)
2366                 return NULL;
2367
2368         sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2369         if (!sop->so_owner.data) {
2370                 kmem_cache_free(slab, sop);
2371                 return NULL;
2372         }
2373         sop->so_owner.len = owner->len;
2374
2375         INIT_LIST_HEAD(&sop->so_stateids);
2376         sop->so_client = clp;
2377         init_nfs4_replay(&sop->so_replay);
2378         return sop;
2379 }
2380
2381 static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
2382 {
2383         list_add(&oo->oo_owner.so_strhash, &ownerstr_hashtbl[strhashval]);
2384         list_add(&oo->oo_perclient, &clp->cl_openowners);
2385 }
2386
2387 static struct nfs4_openowner *
2388 alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2389         struct nfs4_openowner *oo;
2390
2391         oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2392         if (!oo)
2393                 return NULL;
2394         oo->oo_owner.so_is_open_owner = 1;
2395         oo->oo_owner.so_seqid = open->op_seqid;
2396         oo->oo_flags = NFS4_OO_NEW;
2397         oo->oo_time = 0;
2398         oo->oo_last_closed_stid = NULL;
2399         INIT_LIST_HEAD(&oo->oo_close_lru);
2400         hash_openowner(oo, clp, strhashval);
2401         return oo;
2402 }
2403
2404 static void init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2405         struct nfs4_openowner *oo = open->op_openowner;
2406         struct nfs4_client *clp = oo->oo_owner.so_client;
2407
2408         init_stid(&stp->st_stid, clp, NFS4_OPEN_STID);
2409         INIT_LIST_HEAD(&stp->st_lockowners);
2410         list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
2411         list_add(&stp->st_perfile, &fp->fi_stateids);
2412         stp->st_stateowner = &oo->oo_owner;
2413         get_nfs4_file(fp);
2414         stp->st_file = fp;
2415         stp->st_access_bmap = 0;
2416         stp->st_deny_bmap = 0;
2417         __set_bit(open->op_share_access, &stp->st_access_bmap);
2418         __set_bit(open->op_share_deny, &stp->st_deny_bmap);
2419         stp->st_openstp = NULL;
2420 }
2421
2422 static void
2423 move_to_close_lru(struct nfs4_openowner *oo)
2424 {
2425         dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
2426
2427         list_move_tail(&oo->oo_close_lru, &close_lru);
2428         oo->oo_time = get_seconds();
2429 }
2430
2431 static int
2432 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2433                                                         clientid_t *clid)
2434 {
2435         return (sop->so_owner.len == owner->len) &&
2436                 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2437                 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
2438 }
2439
2440 static struct nfs4_openowner *
2441 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2442 {
2443         struct nfs4_stateowner *so;
2444         struct nfs4_openowner *oo;
2445
2446         list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
2447                 if (!so->so_is_open_owner)
2448                         continue;
2449                 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2450                         oo = openowner(so);
2451                         renew_client(oo->oo_owner.so_client);
2452                         return oo;
2453                 }
2454         }
2455         return NULL;
2456 }
2457
2458 /* search file_hashtbl[] for file */
2459 static struct nfs4_file *
2460 find_file(struct inode *ino)
2461 {
2462         unsigned int hashval = file_hashval(ino);
2463         struct nfs4_file *fp;
2464
2465         spin_lock(&recall_lock);
2466         list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2467                 if (fp->fi_inode == ino) {
2468                         get_nfs4_file(fp);
2469                         spin_unlock(&recall_lock);
2470                         return fp;
2471                 }
2472         }
2473         spin_unlock(&recall_lock);
2474         return NULL;
2475 }
2476
2477 /*
2478  * Called to check deny when READ with all zero stateid or
2479  * WRITE with all zero or all one stateid
2480  */
2481 static __be32
2482 nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2483 {
2484         struct inode *ino = current_fh->fh_dentry->d_inode;
2485         struct nfs4_file *fp;
2486         struct nfs4_ol_stateid *stp;
2487         __be32 ret;
2488
2489         dprintk("NFSD: nfs4_share_conflict\n");
2490
2491         fp = find_file(ino);
2492         if (!fp)
2493                 return nfs_ok;
2494         ret = nfserr_locked;
2495         /* Search for conflicting share reservations */
2496         list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2497                 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2498                     test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2499                         goto out;
2500         }
2501         ret = nfs_ok;
2502 out:
2503         put_nfs4_file(fp);
2504         return ret;
2505 }
2506
2507 static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
2508 {
2509         /* We're assuming the state code never drops its reference
2510          * without first removing the lease.  Since we're in this lease
2511          * callback (and since the lease code is serialized by the kernel
2512          * lock) we know the server hasn't removed the lease yet, we know
2513          * it's safe to take a reference: */
2514         atomic_inc(&dp->dl_count);
2515
2516         list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2517
2518         /* only place dl_time is set. protected by lock_flocks*/
2519         dp->dl_time = get_seconds();
2520
2521         nfsd4_cb_recall(dp);
2522 }
2523
2524 /* Called from break_lease() with lock_flocks() held. */
2525 static void nfsd_break_deleg_cb(struct file_lock *fl)
2526 {
2527         struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2528         struct nfs4_delegation *dp;
2529
2530         BUG_ON(!fp);
2531         /* We assume break_lease is only called once per lease: */
2532         BUG_ON(fp->fi_had_conflict);
2533         /*
2534          * We don't want the locks code to timeout the lease for us;
2535          * we'll remove it ourself if a delegation isn't returned
2536          * in time:
2537          */
2538         fl->fl_break_time = 0;
2539
2540         spin_lock(&recall_lock);
2541         fp->fi_had_conflict = true;
2542         list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2543                 nfsd_break_one_deleg(dp);
2544         spin_unlock(&recall_lock);
2545 }
2546
2547 static
2548 int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2549 {
2550         if (arg & F_UNLCK)
2551                 return lease_modify(onlist, arg);
2552         else
2553                 return -EAGAIN;
2554 }
2555
2556 static const struct lock_manager_operations nfsd_lease_mng_ops = {
2557         .lm_break = nfsd_break_deleg_cb,
2558         .lm_change = nfsd_change_deleg_cb,
2559 };
2560
2561 static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2562 {
2563         if (nfsd4_has_session(cstate))
2564                 return nfs_ok;
2565         if (seqid == so->so_seqid - 1)
2566                 return nfserr_replay_me;
2567         if (seqid == so->so_seqid)
2568                 return nfs_ok;
2569         return nfserr_bad_seqid;
2570 }
2571
2572 __be32
2573 nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2574                     struct nfsd4_open *open)
2575 {
2576         clientid_t *clientid = &open->op_clientid;
2577         struct nfs4_client *clp = NULL;
2578         unsigned int strhashval;
2579         struct nfs4_openowner *oo = NULL;
2580         __be32 status;
2581
2582         if (STALE_CLIENTID(&open->op_clientid))
2583                 return nfserr_stale_clientid;
2584         /*
2585          * In case we need it later, after we've already created the
2586          * file and don't want to risk a further failure:
2587          */
2588         open->op_file = nfsd4_alloc_file();
2589         if (open->op_file == NULL)
2590                 return nfserr_jukebox;
2591
2592         strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
2593         oo = find_openstateowner_str(strhashval, open);
2594         open->op_openowner = oo;
2595         if (!oo) {
2596                 clp = find_confirmed_client(clientid);
2597                 if (clp == NULL)
2598                         return nfserr_expired;
2599                 goto new_owner;
2600         }
2601         if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
2602                 /* Replace unconfirmed owners without checking for replay. */
2603                 clp = oo->oo_owner.so_client;
2604                 release_openowner(oo);
2605                 open->op_openowner = NULL;
2606                 goto new_owner;
2607         }
2608         status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2609         if (status)
2610                 return status;
2611         clp = oo->oo_owner.so_client;
2612         goto alloc_stateid;
2613 new_owner:
2614         oo = alloc_init_open_stateowner(strhashval, clp, open);
2615         if (oo == NULL)
2616                 return nfserr_jukebox;
2617         open->op_openowner = oo;
2618 alloc_stateid:
2619         open->op_stp = nfs4_alloc_stateid(clp);
2620         if (!open->op_stp)
2621                 return nfserr_jukebox;
2622         return nfs_ok;
2623 }
2624
2625 static inline __be32
2626 nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2627 {
2628         if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2629                 return nfserr_openmode;
2630         else
2631                 return nfs_ok;
2632 }
2633
2634 static int share_access_to_flags(u32 share_access)
2635 {
2636         share_access &= ~NFS4_SHARE_WANT_MASK;
2637
2638         return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2639 }
2640
2641 static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
2642 {
2643         struct nfs4_stid *ret;
2644
2645         ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
2646         if (!ret)
2647                 return NULL;
2648         return delegstateid(ret);
2649 }
2650
2651 static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2652 {
2653         return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2654                open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2655 }
2656
2657 static __be32
2658 nfs4_check_deleg(struct nfs4_client *cl, struct nfs4_file *fp, struct nfsd4_open *open,
2659                 struct nfs4_delegation **dp)
2660 {
2661         int flags;
2662         __be32 status = nfserr_bad_stateid;
2663
2664         *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
2665         if (*dp == NULL)
2666                 goto out;
2667         flags = share_access_to_flags(open->op_share_access);
2668         status = nfs4_check_delegmode(*dp, flags);
2669         if (status)
2670                 *dp = NULL;
2671 out:
2672         if (!nfsd4_is_deleg_cur(open))
2673                 return nfs_ok;
2674         if (status)
2675                 return status;
2676         open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
2677         return nfs_ok;
2678 }
2679
2680 static __be32
2681 nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
2682 {
2683         struct nfs4_ol_stateid *local;
2684         struct nfs4_openowner *oo = open->op_openowner;
2685
2686         list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
2687                 /* ignore lock owners */
2688                 if (local->st_stateowner->so_is_open_owner == 0)
2689                         continue;
2690                 /* remember if we have seen this open owner */
2691                 if (local->st_stateowner == &oo->oo_owner)
2692                         *stpp = local;
2693                 /* check for conflicting share reservations */
2694                 if (!test_share(local, open))
2695                         return nfserr_share_denied;
2696         }
2697         return nfs_ok;
2698 }
2699
2700 static void nfs4_free_stateid(struct nfs4_ol_stateid *s)
2701 {
2702         kmem_cache_free(stateid_slab, s);
2703 }
2704
2705 static inline int nfs4_access_to_access(u32 nfs4_access)
2706 {
2707         int flags = 0;
2708
2709         if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2710                 flags |= NFSD_MAY_READ;
2711         if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2712                 flags |= NFSD_MAY_WRITE;
2713         return flags;
2714 }
2715
2716 static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2717                 struct svc_fh *cur_fh, struct nfsd4_open *open)
2718 {
2719         __be32 status;
2720         int oflag = nfs4_access_to_omode(open->op_share_access);
2721         int access = nfs4_access_to_access(open->op_share_access);
2722
2723         if (!fp->fi_fds[oflag]) {
2724                 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2725                         &fp->fi_fds[oflag]);
2726                 if (status)
2727                         return status;
2728         }
2729         nfs4_file_get_access(fp, oflag);
2730
2731         return nfs_ok;
2732 }
2733
2734 static inline __be32
2735 nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2736                 struct nfsd4_open *open)
2737 {
2738         struct iattr iattr = {
2739                 .ia_valid = ATTR_SIZE,
2740                 .ia_size = 0,
2741         };
2742         if (!open->op_truncate)
2743                 return 0;
2744         if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
2745                 return nfserr_inval;
2746         return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2747 }
2748
2749 static __be32
2750 nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
2751 {
2752         u32 op_share_access = open->op_share_access;
2753         bool new_access;
2754         __be32 status;
2755
2756         new_access = !test_bit(op_share_access, &stp->st_access_bmap);
2757         if (new_access) {
2758                 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2759                 if (status)
2760                         return status;
2761         }
2762         status = nfsd4_truncate(rqstp, cur_fh, open);
2763         if (status) {
2764                 if (new_access) {
2765                         int oflag = nfs4_access_to_omode(op_share_access);
2766                         nfs4_file_put_access(fp, oflag);
2767                 }
2768                 return status;
2769         }
2770         /* remember the open */
2771         __set_bit(op_share_access, &stp->st_access_bmap);
2772         __set_bit(open->op_share_deny, &stp->st_deny_bmap);
2773
2774         return nfs_ok;
2775 }
2776
2777
2778 static void
2779 nfs4_set_claim_prev(struct nfsd4_open *open)
2780 {
2781         open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
2782         open->op_openowner->oo_owner.so_client->cl_firststate = 1;
2783 }
2784
2785 /* Should we give out recallable state?: */
2786 static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2787 {
2788         if (clp->cl_cb_state == NFSD4_CB_UP)
2789                 return true;
2790         /*
2791          * In the sessions case, since we don't have to establish a
2792          * separate connection for callbacks, we assume it's OK
2793          * until we hear otherwise:
2794          */
2795         return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2796 }
2797
2798 static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2799 {
2800         struct file_lock *fl;
2801
2802         fl = locks_alloc_lock();
2803         if (!fl)
2804                 return NULL;
2805         locks_init_lock(fl);
2806         fl->fl_lmops = &nfsd_lease_mng_ops;
2807         fl->fl_flags = FL_LEASE;
2808         fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2809         fl->fl_end = OFFSET_MAX;
2810         fl->fl_owner = (fl_owner_t)(dp->dl_file);
2811         fl->fl_pid = current->tgid;
2812         return fl;
2813 }
2814
2815 static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2816 {
2817         struct nfs4_file *fp = dp->dl_file;
2818         struct file_lock *fl;
2819         int status;
2820
2821         fl = nfs4_alloc_init_lease(dp, flag);
2822         if (!fl)
2823                 return -ENOMEM;
2824         fl->fl_file = find_readable_file(fp);
2825         list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
2826         status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
2827         if (status) {
2828                 list_del_init(&dp->dl_perclnt);
2829                 locks_free_lock(fl);
2830                 return -ENOMEM;
2831         }
2832         fp->fi_lease = fl;
2833         fp->fi_deleg_file = fl->fl_file;
2834         get_file(fp->fi_deleg_file);
2835         atomic_set(&fp->fi_delegees, 1);
2836         list_add(&dp->dl_perfile, &fp->fi_delegations);
2837         return 0;
2838 }
2839
2840 static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2841 {
2842         struct nfs4_file *fp = dp->dl_file;
2843
2844         if (!fp->fi_lease)
2845                 return nfs4_setlease(dp, flag);
2846         spin_lock(&recall_lock);
2847         if (fp->fi_had_conflict) {
2848                 spin_unlock(&recall_lock);
2849                 return -EAGAIN;
2850         }
2851         atomic_inc(&fp->fi_delegees);
2852         list_add(&dp->dl_perfile, &fp->fi_delegations);
2853         spin_unlock(&recall_lock);
2854         list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
2855         return 0;
2856 }
2857
2858 /*
2859  * Attempt to hand out a delegation.
2860  */
2861 static void
2862 nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
2863 {
2864         struct nfs4_delegation *dp;
2865         struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
2866         int cb_up;
2867         int status, flag = 0;
2868
2869         cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
2870         flag = NFS4_OPEN_DELEGATE_NONE;
2871         open->op_recall = 0;
2872         switch (open->op_claim_type) {
2873                 case NFS4_OPEN_CLAIM_PREVIOUS:
2874                         if (!cb_up)
2875                                 open->op_recall = 1;
2876                         flag = open->op_delegate_type;
2877                         if (flag == NFS4_OPEN_DELEGATE_NONE)
2878                                 goto out;
2879                         break;
2880                 case NFS4_OPEN_CLAIM_NULL:
2881                         /* Let's not give out any delegations till everyone's
2882                          * had the chance to reclaim theirs.... */
2883                         if (locks_in_grace())
2884                                 goto out;
2885                         if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
2886                                 goto out;
2887                         if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2888                                 flag = NFS4_OPEN_DELEGATE_WRITE;
2889                         else
2890                                 flag = NFS4_OPEN_DELEGATE_READ;
2891                         break;
2892                 default:
2893                         goto out;
2894         }
2895
2896         dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag);
2897         if (dp == NULL)
2898                 goto out_no_deleg;
2899         status = nfs4_set_delegation(dp, flag);
2900         if (status)
2901                 goto out_free;
2902
2903         memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
2904
2905         dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2906                 STATEID_VAL(&dp->dl_stid.sc_stateid));
2907 out:
2908         if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2909                         && flag == NFS4_OPEN_DELEGATE_NONE
2910                         && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2911                 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2912         open->op_delegate_type = flag;
2913         return;
2914 out_free:
2915         nfs4_put_delegation(dp);
2916 out_no_deleg:
2917         flag = NFS4_OPEN_DELEGATE_NONE;
2918         goto out;
2919 }
2920
2921 /*
2922  * called with nfs4_lock_state() held.
2923  */
2924 __be32
2925 nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2926 {
2927         struct nfsd4_compoundres *resp = rqstp->rq_resp;
2928         struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
2929         struct nfs4_file *fp = NULL;
2930         struct inode *ino = current_fh->fh_dentry->d_inode;
2931         struct nfs4_ol_stateid *stp = NULL;
2932         struct nfs4_delegation *dp = NULL;
2933         __be32 status;
2934
2935         /*
2936          * Lookup file; if found, lookup stateid and check open request,
2937          * and check for delegations in the process of being recalled.
2938          * If not found, create the nfs4_file struct
2939          */
2940         fp = find_file(ino);
2941         if (fp) {
2942                 if ((status = nfs4_check_open(fp, open, &stp)))
2943                         goto out;
2944                 status = nfs4_check_deleg(cl, fp, open, &dp);
2945                 if (status)
2946                         goto out;
2947         } else {
2948                 status = nfserr_bad_stateid;
2949                 if (nfsd4_is_deleg_cur(open))
2950                         goto out;
2951                 status = nfserr_jukebox;
2952                 fp = open->op_file;
2953                 open->op_file = NULL;
2954                 nfsd4_init_file(fp, ino);
2955         }
2956
2957         /*
2958          * OPEN the file, or upgrade an existing OPEN.
2959          * If truncate fails, the OPEN fails.
2960          */
2961         if (stp) {
2962                 /* Stateid was found, this is an OPEN upgrade */
2963                 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
2964                 if (status)
2965                         goto out;
2966         } else {
2967                 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
2968                 if (status)
2969                         goto out;
2970                 stp = open->op_stp;
2971                 open->op_stp = NULL;
2972                 init_open_stateid(stp, fp, open);
2973                 status = nfsd4_truncate(rqstp, current_fh, open);
2974                 if (status) {
2975                         release_open_stateid(stp);
2976                         goto out;
2977                 }
2978         }
2979         update_stateid(&stp->st_stid.sc_stateid);
2980         memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
2981
2982         if (nfsd4_has_session(&resp->cstate))
2983                 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
2984
2985         /*
2986         * Attempt to hand out a delegation. No error return, because the
2987         * OPEN succeeds even if we fail.
2988         */
2989         nfs4_open_delegation(current_fh, open, stp);
2990
2991         status = nfs_ok;
2992
2993         dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2994                 STATEID_VAL(&stp->st_stid.sc_stateid));
2995 out:
2996         if (fp)
2997                 put_nfs4_file(fp);
2998         if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2999                 nfs4_set_claim_prev(open);
3000         /*
3001         * To finish the open response, we just need to set the rflags.
3002         */
3003         open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
3004         if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
3005             !nfsd4_has_session(&resp->cstate))
3006                 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3007
3008         return status;
3009 }
3010
3011 void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3012 {
3013         if (open->op_openowner) {
3014                 struct nfs4_openowner *oo = open->op_openowner;
3015
3016                 if (!list_empty(&oo->oo_owner.so_stateids))
3017                         list_del_init(&oo->oo_close_lru);
3018                 if (oo->oo_flags & NFS4_OO_NEW) {
3019                         if (status) {
3020                                 release_openowner(oo);
3021                                 open->op_openowner = NULL;
3022                         } else
3023                                 oo->oo_flags &= ~NFS4_OO_NEW;
3024                 }
3025         }
3026         if (open->op_file)
3027                 nfsd4_free_file(open->op_file);
3028         if (open->op_stp)
3029                 nfs4_free_stateid(open->op_stp);
3030 }
3031
3032 __be32
3033 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3034             clientid_t *clid)
3035 {
3036         struct nfs4_client *clp;
3037         __be32 status;
3038
3039         nfs4_lock_state();
3040         dprintk("process_renew(%08x/%08x): starting\n", 
3041                         clid->cl_boot, clid->cl_id);
3042         status = nfserr_stale_clientid;
3043         if (STALE_CLIENTID(clid))
3044                 goto out;
3045         clp = find_confirmed_client(clid);
3046         status = nfserr_expired;
3047         if (clp == NULL) {
3048                 /* We assume the client took too long to RENEW. */
3049                 dprintk("nfsd4_renew: clientid not found!\n");
3050                 goto out;
3051         }
3052         status = nfserr_cb_path_down;
3053         if (!list_empty(&clp->cl_delegations)
3054                         && clp->cl_cb_state != NFSD4_CB_UP)
3055                 goto out;
3056         status = nfs_ok;
3057 out:
3058         nfs4_unlock_state();
3059         return status;
3060 }
3061
3062 static struct lock_manager nfsd4_manager = {
3063 };
3064
3065 static void
3066 nfsd4_end_grace(void)
3067 {
3068         dprintk("NFSD: end of grace period\n");
3069         nfsd4_recdir_purge_old();
3070         locks_end_grace(&nfsd4_manager);
3071         /*
3072          * Now that every NFSv4 client has had the chance to recover and
3073          * to see the (possibly new, possibly shorter) lease time, we
3074          * can safely set the next grace time to the current lease time:
3075          */
3076         nfsd4_grace = nfsd4_lease;
3077 }
3078
3079 static time_t
3080 nfs4_laundromat(void)
3081 {
3082         struct nfs4_client *clp;
3083         struct nfs4_openowner *oo;
3084         struct nfs4_delegation *dp;
3085         struct list_head *pos, *next, reaplist;
3086         time_t cutoff = get_seconds() - nfsd4_lease;
3087         time_t t, clientid_val = nfsd4_lease;
3088         time_t u, test_val = nfsd4_lease;
3089
3090         nfs4_lock_state();
3091
3092         dprintk("NFSD: laundromat service - starting\n");
3093         if (locks_in_grace())
3094                 nfsd4_end_grace();
3095         INIT_LIST_HEAD(&reaplist);
3096         spin_lock(&client_lock);
3097         list_for_each_safe(pos, next, &client_lru) {
3098                 clp = list_entry(pos, struct nfs4_client, cl_lru);
3099                 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3100                         t = clp->cl_time - cutoff;
3101                         if (clientid_val > t)
3102                                 clientid_val = t;
3103                         break;
3104                 }
3105                 if (atomic_read(&clp->cl_refcount)) {
3106                         dprintk("NFSD: client in use (clientid %08x)\n",
3107                                 clp->cl_clientid.cl_id);
3108                         continue;
3109                 }
3110                 unhash_client_locked(clp);
3111                 list_add(&clp->cl_lru, &reaplist);
3112         }
3113         spin_unlock(&client_lock);
3114         list_for_each_safe(pos, next, &reaplist) {
3115                 clp = list_entry(pos, struct nfs4_client, cl_lru);
3116                 dprintk("NFSD: purging unused client (clientid %08x)\n",
3117                         clp->cl_clientid.cl_id);
3118                 nfsd4_remove_clid_dir(clp);
3119                 expire_client(clp);
3120         }
3121         spin_lock(&recall_lock);
3122         list_for_each_safe(pos, next, &del_recall_lru) {
3123                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3124                 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3125                         u = dp->dl_time - cutoff;
3126                         if (test_val > u)
3127                                 test_val = u;
3128                         break;
3129                 }
3130                 list_move(&dp->dl_recall_lru, &reaplist);
3131         }
3132         spin_unlock(&recall_lock);
3133         list_for_each_safe(pos, next, &reaplist) {
3134                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3135                 unhash_delegation(dp);
3136         }
3137         test_val = nfsd4_lease;
3138         list_for_each_safe(pos, next, &close_lru) {
3139                 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3140                 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3141                         u = oo->oo_time - cutoff;
3142                         if (test_val > u)
3143                                 test_val = u;
3144                         break;
3145                 }
3146                 release_openowner(oo);
3147         }
3148         if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3149                 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3150         nfs4_unlock_state();
3151         return clientid_val;
3152 }
3153
3154 static struct workqueue_struct *laundry_wq;
3155 static void laundromat_main(struct work_struct *);
3156 static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
3157
3158 static void
3159 laundromat_main(struct work_struct *not_used)
3160 {
3161         time_t t;
3162
3163         t = nfs4_laundromat();
3164         dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
3165         queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
3166 }
3167
3168 static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
3169 {
3170         if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3171                 return nfserr_bad_stateid;
3172         return nfs_ok;
3173 }
3174
3175 static int
3176 STALE_STATEID(stateid_t *stateid)
3177 {
3178         if (stateid->si_opaque.so_clid.cl_boot == boot_time)
3179                 return 0;
3180         dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
3181                 STATEID_VAL(stateid));
3182         return 1;
3183 }
3184
3185 static inline int
3186 access_permit_read(unsigned long access_bmap)
3187 {
3188         return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
3189                 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
3190                 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
3191 }
3192
3193 static inline int
3194 access_permit_write(unsigned long access_bmap)
3195 {
3196         return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
3197                 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
3198 }
3199
3200 static
3201 __be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
3202 {
3203         __be32 status = nfserr_openmode;
3204
3205         /* For lock stateid's, we test the parent open, not the lock: */
3206         if (stp->st_openstp)
3207                 stp = stp->st_openstp;
3208         if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
3209                 goto out;
3210         if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
3211                 goto out;
3212         status = nfs_ok;
3213 out:
3214         return status;
3215 }
3216
3217 static inline __be32
3218 check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3219 {
3220         if (ONE_STATEID(stateid) && (flags & RD_STATE))
3221                 return nfs_ok;
3222         else if (locks_in_grace()) {
3223                 /* Answer in remaining cases depends on existence of
3224                  * conflicting state; so we must wait out the grace period. */
3225                 return nfserr_grace;
3226         } else if (flags & WR_STATE)
3227                 return nfs4_share_conflict(current_fh,
3228                                 NFS4_SHARE_DENY_WRITE);
3229         else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3230                 return nfs4_share_conflict(current_fh,
3231                                 NFS4_SHARE_DENY_READ);
3232 }
3233
3234 /*
3235  * Allow READ/WRITE during grace period on recovered state only for files
3236  * that are not able to provide mandatory locking.
3237  */
3238 static inline int
3239 grace_disallows_io(struct inode *inode)
3240 {
3241         return locks_in_grace() && mandatory_lock(inode);
3242 }
3243
3244 /* Returns true iff a is later than b: */
3245 static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3246 {
3247         return (s32)a->si_generation - (s32)b->si_generation > 0;
3248 }
3249
3250 static int check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
3251 {
3252         /*
3253          * When sessions are used the stateid generation number is ignored
3254          * when it is zero.
3255          */
3256         if (has_session && in->si_generation == 0)
3257                 return nfs_ok;
3258
3259         if (in->si_generation == ref->si_generation)
3260                 return nfs_ok;
3261
3262         /* If the client sends us a stateid from the future, it's buggy: */
3263         if (stateid_generation_after(in, ref))
3264                 return nfserr_bad_stateid;
3265         /*
3266          * However, we could see a stateid from the past, even from a
3267          * non-buggy client.  For example, if the client sends a lock
3268          * while some IO is outstanding, the lock may bump si_generation
3269          * while the IO is still in flight.  The client could avoid that
3270          * situation by waiting for responses on all the IO requests,
3271          * but better performance may result in retrying IO that
3272          * receives an old_stateid error if requests are rarely
3273          * reordered in flight:
3274          */
3275         return nfserr_old_stateid;
3276 }
3277
3278 __be32 nfs4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
3279 {
3280         struct nfs4_stid *s;
3281         struct nfs4_ol_stateid *ols;
3282         __be32 status;
3283
3284         if (STALE_STATEID(stateid))
3285                 return nfserr_stale_stateid;
3286
3287         s = find_stateid(cl, stateid);
3288         if (!s)
3289                  return nfserr_stale_stateid;
3290         status = check_stateid_generation(stateid, &s->sc_stateid, 1);
3291         if (status)
3292                 return status;
3293         if (!(s->sc_type & (NFS4_OPEN_STID | NFS4_LOCK_STID)))
3294                 return nfs_ok;
3295         ols = openlockstateid(s);
3296         if (ols->st_stateowner->so_is_open_owner
3297             && !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
3298                 return nfserr_bad_stateid;
3299         return nfs_ok;
3300 }
3301
3302 static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask, struct nfs4_stid **s)
3303 {
3304         struct nfs4_client *cl;
3305
3306         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3307                 return nfserr_bad_stateid;
3308         if (STALE_STATEID(stateid))
3309                 return nfserr_stale_stateid;
3310         cl = find_confirmed_client(&stateid->si_opaque.so_clid);
3311         if (!cl)
3312                 return nfserr_expired;
3313         *s = find_stateid_by_type(cl, stateid, typemask);
3314         if (!*s)
3315                 return nfserr_bad_stateid;
3316         return nfs_ok;
3317
3318 }
3319
3320 /*
3321 * Checks for stateid operations
3322 */
3323 __be32
3324 nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3325                            stateid_t *stateid, int flags, struct file **filpp)
3326 {
3327         struct nfs4_stid *s;
3328         struct nfs4_ol_stateid *stp = NULL;
3329         struct nfs4_delegation *dp = NULL;
3330         struct svc_fh *current_fh = &cstate->current_fh;
3331         struct inode *ino = current_fh->fh_dentry->d_inode;
3332         __be32 status;
3333
3334         if (filpp)
3335                 *filpp = NULL;
3336
3337         if (grace_disallows_io(ino))
3338                 return nfserr_grace;
3339
3340         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3341                 return check_special_stateids(current_fh, stateid, flags);
3342
3343         status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID, &s);
3344         if (status)
3345                 return status;
3346         status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3347         if (status)
3348                 goto out;
3349         switch (s->sc_type) {
3350         case NFS4_DELEG_STID:
3351                 dp = delegstateid(s);
3352                 status = nfs4_check_delegmode(dp, flags);
3353                 if (status)
3354                         goto out;
3355                 if (filpp) {
3356                         *filpp = dp->dl_file->fi_deleg_file;
3357                         BUG_ON(!*filpp);
3358                 }
3359                 break;
3360         case NFS4_OPEN_STID:
3361         case NFS4_LOCK_STID:
3362                 stp = openlockstateid(s);
3363                 status = nfs4_check_fh(current_fh, stp);
3364                 if (status)
3365                         goto out;
3366                 if (stp->st_stateowner->so_is_open_owner
3367                     && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
3368                         goto out;
3369                 status = nfs4_check_openmode(stp, flags);
3370                 if (status)
3371                         goto out;
3372                 if (filpp) {
3373                         if (flags & RD_STATE)
3374                                 *filpp = find_readable_file(stp->st_file);
3375                         else
3376                                 *filpp = find_writeable_file(stp->st_file);
3377                 }
3378                 break;
3379         default:
3380                 return nfserr_bad_stateid;
3381         }
3382         status = nfs_ok;
3383 out:
3384         return status;
3385 }
3386
3387 static __be32
3388 nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
3389 {
3390         if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
3391                 return nfserr_locks_held;
3392         release_lock_stateid(stp);
3393         return nfs_ok;
3394 }
3395
3396 /*
3397  * Test if the stateid is valid
3398  */
3399 __be32
3400 nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3401                    struct nfsd4_test_stateid *test_stateid)
3402 {
3403         /* real work is done during encoding */
3404         return nfs_ok;
3405 }
3406
3407 __be32
3408 nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3409                    struct nfsd4_free_stateid *free_stateid)
3410 {
3411         stateid_t *stateid = &free_stateid->fr_stateid;
3412         struct nfs4_stid *s;
3413         struct nfs4_client *cl = cstate->session->se_client;
3414         __be32 ret = nfserr_bad_stateid;
3415
3416         nfs4_lock_state();
3417         s = find_stateid(cl, stateid);
3418         if (!s)
3419                 goto out;
3420         switch (s->sc_type) {
3421         case NFS4_DELEG_STID:
3422                 ret = nfserr_locks_held;
3423                 goto out;
3424         case NFS4_OPEN_STID:
3425         case NFS4_LOCK_STID:
3426                 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3427                 if (ret)
3428                         goto out;
3429                 if (s->sc_type == NFS4_LOCK_STID)
3430                         ret = nfsd4_free_lock_stateid(openlockstateid(s));
3431                 else
3432                         ret = nfserr_locks_held;
3433                 break;
3434         default:
3435                 ret = nfserr_bad_stateid;
3436         }
3437 out:
3438         nfs4_unlock_state();
3439         return ret;
3440 }
3441
3442 static inline int
3443 setlkflg (int type)
3444 {
3445         return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3446                 RD_STATE : WR_STATE;
3447 }
3448
3449 static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
3450 {
3451         struct svc_fh *current_fh = &cstate->current_fh;
3452         struct nfs4_stateowner *sop = stp->st_stateowner;
3453         __be32 status;
3454
3455         status = nfsd4_check_seqid(cstate, sop, seqid);
3456         if (status)
3457                 return status;
3458         if (stp->st_stid.sc_type == NFS4_CLOSED_STID)
3459                 /*
3460                  * "Closed" stateid's exist *only* to return
3461                  * nfserr_replay_me from the previous step.
3462                  */
3463                 return nfserr_bad_stateid;
3464         status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3465         if (status)
3466                 return status;
3467         return nfs4_check_fh(current_fh, stp);
3468 }
3469
3470 /* 
3471  * Checks for sequence id mutating operations. 
3472  */
3473 static __be32
3474 nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3475                          stateid_t *stateid, char typemask,
3476                          struct nfs4_ol_stateid **stpp)
3477 {
3478         __be32 status;
3479         struct nfs4_stid *s;
3480
3481         dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3482                 seqid, STATEID_VAL(stateid));
3483
3484         *stpp = NULL;
3485         status = nfsd4_lookup_stateid(stateid, typemask, &s);
3486         if (status)
3487                 return status;
3488         *stpp = openlockstateid(s);
3489         cstate->replay_owner = (*stpp)->st_stateowner;
3490
3491         return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3492 }
3493
3494 static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid, stateid_t *stateid, struct nfs4_ol_stateid **stpp)
3495 {
3496         __be32 status;
3497         struct nfs4_openowner *oo;
3498
3499         status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
3500                                                 NFS4_OPEN_STID, stpp);
3501         if (status)
3502                 return status;
3503         oo = openowner((*stpp)->st_stateowner);
3504         if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
3505                 return nfserr_bad_stateid;
3506         return nfs_ok;
3507 }
3508
3509 __be32
3510 nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3511                    struct nfsd4_open_confirm *oc)
3512 {
3513         __be32 status;
3514         struct nfs4_openowner *oo;
3515         struct nfs4_ol_stateid *stp;
3516
3517         dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
3518                         (int)cstate->current_fh.fh_dentry->d_name.len,
3519                         cstate->current_fh.fh_dentry->d_name.name);
3520
3521         status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
3522         if (status)
3523                 return status;
3524
3525         nfs4_lock_state();
3526
3527         status = nfs4_preprocess_seqid_op(cstate,
3528                                         oc->oc_seqid, &oc->oc_req_stateid,
3529                                         NFS4_OPEN_STID, &stp);
3530         if (status)
3531                 goto out;
3532         oo = openowner(stp->st_stateowner);
3533         status = nfserr_bad_stateid;
3534         if (oo->oo_flags & NFS4_OO_CONFIRMED)
3535                 goto out;
3536         oo->oo_flags |= NFS4_OO_CONFIRMED;
3537         update_stateid(&stp->st_stid.sc_stateid);
3538         memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3539         dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3540                 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
3541
3542         nfsd4_create_clid_dir(oo->oo_owner.so_client);
3543         status = nfs_ok;
3544 out:
3545         if (!cstate->replay_owner)
3546                 nfs4_unlock_state();
3547         return status;
3548 }
3549
3550 static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
3551 {
3552         if (!test_bit(access, &stp->st_access_bmap))
3553                 return;
3554         nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
3555         __clear_bit(access, &stp->st_access_bmap);
3556 }
3557
3558 static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
3559 {
3560         switch (to_access) {
3561         case NFS4_SHARE_ACCESS_READ:
3562                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
3563                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3564                 break;
3565         case NFS4_SHARE_ACCESS_WRITE:
3566                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
3567                 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3568                 break;
3569         case NFS4_SHARE_ACCESS_BOTH:
3570                 break;
3571         default:
3572                 BUG();
3573         }
3574 }
3575
3576 static void
3577 reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3578 {
3579         int i;
3580         for (i = 0; i < 4; i++) {
3581                 if ((i & deny) != i)
3582                         __clear_bit(i, bmap);
3583         }
3584 }
3585
3586 __be32
3587 nfsd4_open_downgrade(struct svc_rqst *rqstp,
3588                      struct nfsd4_compound_state *cstate,
3589                      struct nfsd4_open_downgrade *od)
3590 {
3591         __be32 status;
3592         struct nfs4_ol_stateid *stp;
3593
3594         dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n", 
3595                         (int)cstate->current_fh.fh_dentry->d_name.len,
3596                         cstate->current_fh.fh_dentry->d_name.name);
3597
3598         /* We don't yet support WANT bits: */
3599         od->od_share_access &= NFS4_SHARE_ACCESS_MASK;
3600
3601         nfs4_lock_state();
3602         status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
3603                                         &od->od_stateid, &stp);
3604         if (status)
3605                 goto out; 
3606         status = nfserr_inval;
3607         if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3608                 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3609                         stp->st_access_bmap, od->od_share_access);
3610                 goto out;
3611         }
3612         if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3613                 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3614                         stp->st_deny_bmap, od->od_share_deny);
3615                 goto out;
3616         }
3617         nfs4_stateid_downgrade(stp, od->od_share_access);
3618
3619         reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3620
3621         update_stateid(&stp->st_stid.sc_stateid);
3622         memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3623         status = nfs_ok;
3624 out:
3625         if (!cstate->replay_owner)
3626                 nfs4_unlock_state();
3627         return status;
3628 }
3629
3630 void nfsd4_purge_closed_stateid(struct nfs4_stateowner *so)
3631 {
3632         struct nfs4_openowner *oo;
3633         struct nfs4_ol_stateid *s;
3634
3635         if (!so->so_is_open_owner)
3636                 return;
3637         oo = openowner(so);
3638         s = oo->oo_last_closed_stid;
3639         if (!s)
3640                 return;
3641         if (!(oo->oo_flags & NFS4_OO_PURGE_CLOSE)) {
3642                 /* Release the last_closed_stid on the next seqid bump: */
3643                 oo->oo_flags |= NFS4_OO_PURGE_CLOSE;
3644                 return;
3645         }
3646         oo->oo_flags &= ~NFS4_OO_PURGE_CLOSE;
3647         release_last_closed_stateid(oo);
3648 }
3649
3650 static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
3651 {
3652         unhash_open_stateid(s);
3653         s->st_stid.sc_type = NFS4_CLOSED_STID;
3654 }
3655
3656 /*
3657  * nfs4_unlock_state() called after encode
3658  */
3659 __be32
3660 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3661             struct nfsd4_close *close)
3662 {
3663         __be32 status;
3664         struct nfs4_openowner *oo;
3665         struct nfs4_ol_stateid *stp;
3666
3667         dprintk("NFSD: nfsd4_close on file %.*s\n", 
3668                         (int)cstate->current_fh.fh_dentry->d_name.len,
3669                         cstate->current_fh.fh_dentry->d_name.name);
3670
3671         nfs4_lock_state();
3672         status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
3673                                         &close->cl_stateid,
3674                                         NFS4_OPEN_STID|NFS4_CLOSED_STID,
3675                                         &stp);
3676         if (status)
3677                 goto out; 
3678         oo = openowner(stp->st_stateowner);
3679         status = nfs_ok;
3680         update_stateid(&stp->st_stid.sc_stateid);
3681         memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3682
3683         nfsd4_close_open_stateid(stp);
3684         oo->oo_last_closed_stid = stp;
3685
3686         /* place unused nfs4_stateowners on so_close_lru list to be
3687          * released by the laundromat service after the lease period
3688          * to enable us to handle CLOSE replay
3689          */
3690         if (list_empty(&oo->oo_owner.so_stateids))
3691                 move_to_close_lru(oo);
3692 out:
3693         if (!cstate->replay_owner)
3694                 nfs4_unlock_state();
3695         return status;
3696 }
3697
3698 __be32
3699 nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3700                   struct nfsd4_delegreturn *dr)
3701 {
3702         struct nfs4_delegation *dp;
3703         stateid_t *stateid = &dr->dr_stateid;
3704         struct nfs4_stid *s;
3705         struct inode *inode;
3706         __be32 status;
3707
3708         if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
3709                 return status;
3710         inode = cstate->current_fh.fh_dentry->d_inode;
3711
3712         nfs4_lock_state();
3713         status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s);
3714         if (status)
3715                 goto out;
3716         dp = delegstateid(s);
3717         status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
3718         if (status)
3719                 goto out;
3720
3721         unhash_delegation(dp);
3722 out:
3723         nfs4_unlock_state();
3724
3725         return status;
3726 }
3727
3728
3729 #define LOFF_OVERFLOW(start, len)      ((u64)(len) > ~(u64)(start))
3730
3731 #define LOCKOWNER_INO_HASH_BITS 8
3732 #define LOCKOWNER_INO_HASH_SIZE (1 << LOCKOWNER_INO_HASH_BITS)
3733 #define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
3734
3735 static inline u64
3736 end_offset(u64 start, u64 len)
3737 {
3738         u64 end;
3739
3740         end = start + len;
3741         return end >= start ? end: NFS4_MAX_UINT64;
3742 }
3743
3744 /* last octet in a range */
3745 static inline u64
3746 last_byte_offset(u64 start, u64 len)
3747 {
3748         u64 end;
3749
3750         BUG_ON(!len);
3751         end = start + len;
3752         return end > start ? end - 1: NFS4_MAX_UINT64;
3753 }
3754
3755 static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
3756 {
3757         return (file_hashval(inode) + cl_id
3758                         + opaque_hashval(ownername->data, ownername->len))
3759                 & LOCKOWNER_INO_HASH_MASK;
3760 }
3761
3762 static struct list_head lockowner_ino_hashtbl[LOCKOWNER_INO_HASH_SIZE];
3763
3764 /*
3765  * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3766  * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3767  * byte, because of sign extension problems.  Since NFSv4 calls for 64-bit
3768  * locking, this prevents us from being completely protocol-compliant.  The
3769  * real solution to this problem is to start using unsigned file offsets in
3770  * the VFS, but this is a very deep change!
3771  */
3772 static inline void
3773 nfs4_transform_lock_offset(struct file_lock *lock)
3774 {
3775         if (lock->fl_start < 0)
3776                 lock->fl_start = OFFSET_MAX;
3777         if (lock->fl_end < 0)
3778                 lock->fl_end = OFFSET_MAX;
3779 }
3780
3781 /* Hack!: For now, we're defining this just so we can use a pointer to it
3782  * as a unique cookie to identify our (NFSv4's) posix locks. */
3783 static const struct lock_manager_operations nfsd_posix_mng_ops  = {
3784 };
3785
3786 static inline void
3787 nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3788 {
3789         struct nfs4_lockowner *lo;
3790
3791         if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3792                 lo = (struct nfs4_lockowner *) fl->fl_owner;
3793                 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
3794                                         lo->lo_owner.so_owner.len, GFP_KERNEL);
3795                 if (!deny->ld_owner.data)
3796                         /* We just don't care that much */
3797                         goto nevermind;
3798                 deny->ld_owner.len = lo->lo_owner.so_owner.len;
3799                 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
3800         } else {
3801 nevermind:
3802                 deny->ld_owner.len = 0;
3803                 deny->ld_owner.data = NULL;
3804                 deny->ld_clientid.cl_boot = 0;
3805                 deny->ld_clientid.cl_id = 0;
3806         }
3807         deny->ld_start = fl->fl_start;
3808         deny->ld_length = NFS4_MAX_UINT64;
3809         if (fl->fl_end != NFS4_MAX_UINT64)
3810                 deny->ld_length = fl->fl_end - fl->fl_start + 1;        
3811         deny->ld_type = NFS4_READ_LT;
3812         if (fl->fl_type != F_RDLCK)
3813                 deny->ld_type = NFS4_WRITE_LT;
3814 }
3815
3816 static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
3817 {
3818         struct nfs4_ol_stateid *lst;
3819
3820         if (!same_owner_str(&lo->lo_owner, owner, clid))
3821                 return false;
3822         lst = list_first_entry(&lo->lo_owner.so_stateids,
3823                                struct nfs4_ol_stateid, st_perstateowner);
3824         return lst->st_file->fi_inode == inode;
3825 }
3826
3827 static struct nfs4_lockowner *
3828 find_lockowner_str(struct inode *inode, clientid_t *clid,
3829                 struct xdr_netobj *owner)
3830 {
3831         unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
3832         struct nfs4_lockowner *lo;
3833
3834         list_for_each_entry(lo, &lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
3835                 if (same_lockowner_ino(lo, inode, clid, owner))
3836                         return lo;
3837         }
3838         return NULL;
3839 }
3840
3841 static void hash_lockowner(struct nfs4_lockowner *lo, unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp)
3842 {
3843         struct inode *inode = open_stp->st_file->fi_inode;
3844         unsigned int inohash = lockowner_ino_hashval(inode,
3845                         clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
3846
3847         list_add(&lo->lo_owner.so_strhash, &ownerstr_hashtbl[strhashval]);
3848         list_add(&lo->lo_owner_ino_hash, &lockowner_ino_hashtbl[inohash]);
3849         list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
3850 }
3851
3852 /*
3853  * Alloc a lock owner structure.
3854  * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has 
3855  * occurred. 
3856  *
3857  * strhashval = ownerstr_hashval
3858  */
3859
3860 static struct nfs4_lockowner *
3861 alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp, struct nfsd4_lock *lock) {
3862         struct nfs4_lockowner *lo;
3863
3864         lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
3865         if (!lo)
3866                 return NULL;
3867         INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
3868         lo->lo_owner.so_is_open_owner = 0;
3869         /* It is the openowner seqid that will be incremented in encode in the
3870          * case of new lockowners; so increment the lock seqid manually: */
3871         lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
3872         hash_lockowner(lo, strhashval, clp, open_stp);
3873         return lo;
3874 }
3875
3876 static struct nfs4_ol_stateid *
3877 alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
3878 {
3879         struct nfs4_ol_stateid *stp;
3880         struct nfs4_client *clp = lo->lo_owner.so_client;
3881
3882         stp = nfs4_alloc_stateid(clp);
3883         if (stp == NULL)
3884                 return NULL;
3885         init_stid(&stp->st_stid, clp, NFS4_LOCK_STID);
3886         list_add(&stp->st_perfile, &fp->fi_stateids);
3887         list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
3888         stp->st_stateowner = &lo->lo_owner;
3889         get_nfs4_file(fp);
3890         stp->st_file = fp;
3891         stp->st_access_bmap = 0;
3892         stp->st_deny_bmap = open_stp->st_deny_bmap;
3893         stp->st_openstp = open_stp;
3894         return stp;
3895 }
3896
3897 static int
3898 check_lock_length(u64 offset, u64 length)
3899 {
3900         return ((length == 0)  || ((length != NFS4_MAX_UINT64) &&
3901              LOFF_OVERFLOW(offset, length)));
3902 }
3903
3904 static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
3905 {
3906         struct nfs4_file *fp = lock_stp->st_file;
3907         int oflag = nfs4_access_to_omode(access);
3908
3909         if (test_bit(access, &lock_stp->st_access_bmap))
3910                 return;
3911         nfs4_file_get_access(fp, oflag);
3912         __set_bit(access, &lock_stp->st_access_bmap);
3913 }
3914
3915 __be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
3916 {
3917         struct nfs4_file *fi = ost->st_file;
3918         struct nfs4_openowner *oo = openowner(ost->st_stateowner);
3919         struct nfs4_client *cl = oo->oo_owner.so_client;
3920         struct nfs4_lockowner *lo;
3921         unsigned int strhashval;
3922
3923         lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid, &lock->v.new.owner);
3924         if (lo) {
3925                 if (!cstate->minorversion)
3926                         return nfserr_bad_seqid;
3927                 /* XXX: a lockowner always has exactly one stateid: */
3928                 *lst = list_first_entry(&lo->lo_owner.so_stateids,
3929                                 struct nfs4_ol_stateid, st_perstateowner);
3930                 return nfs_ok;
3931         }
3932         strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
3933                         &lock->v.new.owner);
3934         lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
3935         if (lo == NULL)
3936                 return nfserr_jukebox;
3937         *lst = alloc_init_lock_stateid(lo, fi, ost);
3938         if (*lst == NULL) {
3939                 release_lockowner(lo);
3940                 return nfserr_jukebox;
3941         }
3942         *new = true;
3943         return nfs_ok;
3944 }
3945
3946 /*
3947  *  LOCK operation 
3948  */
3949 __be32
3950 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3951            struct nfsd4_lock *lock)
3952 {
3953         struct nfs4_openowner *open_sop = NULL;
3954         struct nfs4_lockowner *lock_sop = NULL;
3955         struct nfs4_ol_stateid *lock_stp;
3956         struct nfs4_file *fp;
3957         struct file *filp = NULL;
3958         struct file_lock file_lock;
3959         struct file_lock conflock;
3960         __be32 status = 0;
3961         bool new_state = false;
3962         int lkflg;
3963         int err;
3964
3965         dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3966                 (long long) lock->lk_offset,
3967                 (long long) lock->lk_length);
3968
3969         if (check_lock_length(lock->lk_offset, lock->lk_length))
3970                  return nfserr_inval;
3971
3972         if ((status = fh_verify(rqstp, &cstate->current_fh,
3973                                 S_IFREG, NFSD_MAY_LOCK))) {
3974                 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3975                 return status;
3976         }
3977
3978         nfs4_lock_state();
3979
3980         if (lock->lk_is_new) {
3981                 /*
3982                  * Client indicates that this is a new lockowner.
3983                  * Use open owner and open stateid to create lock owner and
3984                  * lock stateid.
3985                  */
3986                 struct nfs4_ol_stateid *open_stp = NULL;
3987
3988                 if (nfsd4_has_session(cstate))
3989                         /* See rfc 5661 18.10.3: given clientid is ignored: */
3990                         memcpy(&lock->v.new.clientid,
3991                                 &cstate->session->se_client->cl_clientid,
3992                                 sizeof(clientid_t));
3993
3994                 status = nfserr_stale_clientid;
3995                 if (STALE_CLIENTID(&lock->lk_new_clientid))
3996                         goto out;
3997
3998                 /* validate and update open stateid and open seqid */
3999                 status = nfs4_preprocess_confirmed_seqid_op(cstate,
4000                                         lock->lk_new_open_seqid,
4001                                         &lock->lk_new_open_stateid,
4002                                         &open_stp);
4003                 if (status)
4004                         goto out;
4005                 open_sop = openowner(open_stp->st_stateowner);
4006                 status = nfserr_bad_stateid;
4007                 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
4008                                                 &lock->v.new.clientid))
4009                         goto out;
4010                 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4011                                                         &lock_stp, &new_state);
4012                 if (status)
4013                         goto out;
4014         } else {
4015                 /* lock (lock owner + lock stateid) already exists */
4016                 status = nfs4_preprocess_seqid_op(cstate,
4017                                        lock->lk_old_lock_seqid,
4018                                        &lock->lk_old_lock_stateid,
4019                                        NFS4_LOCK_STID, &lock_stp);
4020                 if (status)
4021                         goto out;
4022         }
4023         lock_sop = lockowner(lock_stp->st_stateowner);
4024         fp = lock_stp->st_file;
4025
4026         lkflg = setlkflg(lock->lk_type);
4027         status = nfs4_check_openmode(lock_stp, lkflg);
4028         if (status)
4029                 goto out;
4030
4031         status = nfserr_grace;
4032         if (locks_in_grace() && !lock->lk_reclaim)
4033                 goto out;
4034         status = nfserr_no_grace;
4035         if (!locks_in_grace() && lock->lk_reclaim)
4036                 goto out;
4037
4038         locks_init_lock(&file_lock);
4039         switch (lock->lk_type) {
4040                 case NFS4_READ_LT:
4041                 case NFS4_READW_LT:
4042                         filp = find_readable_file(lock_stp->st_file);
4043                         if (filp)
4044                                 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
4045                         file_lock.fl_type = F_RDLCK;
4046                         break;
4047                 case NFS4_WRITE_LT:
4048                 case NFS4_WRITEW_LT:
4049                         filp = find_writeable_file(lock_stp->st_file);
4050                         if (filp)
4051                                 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
4052                         file_lock.fl_type = F_WRLCK;
4053                         break;
4054                 default:
4055                         status = nfserr_inval;
4056                 goto out;
4057         }
4058         if (!filp) {
4059                 status = nfserr_openmode;
4060                 goto out;
4061         }
4062         file_lock.fl_owner = (fl_owner_t)lock_sop;
4063         file_lock.fl_pid = current->tgid;
4064         file_lock.fl_file = filp;
4065         file_lock.fl_flags = FL_POSIX;
4066         file_lock.fl_lmops = &nfsd_posix_mng_ops;
4067
4068         file_lock.fl_start = lock->lk_offset;
4069         file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4070         nfs4_transform_lock_offset(&file_lock);
4071
4072         /*
4073         * Try to lock the file in the VFS.
4074         * Note: locks.c uses the BKL to protect the inode's lock list.
4075         */
4076
4077         err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
4078         switch (-err) {
4079         case 0: /* success! */
4080                 update_stateid(&lock_stp->st_stid.sc_stateid);
4081                 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid, 
4082                                 sizeof(stateid_t));
4083                 status = 0;
4084                 break;
4085         case (EAGAIN):          /* conflock holds conflicting lock */
4086                 status = nfserr_denied;
4087                 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4088                 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
4089                 break;
4090         case (EDEADLK):
4091                 status = nfserr_deadlock;
4092                 break;
4093         default:
4094                 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
4095                 status = nfserrno(err);
4096                 break;
4097         }
4098 out:
4099         if (status && new_state)
4100                 release_lockowner(lock_sop);
4101         if (!cstate->replay_owner)
4102                 nfs4_unlock_state();
4103         return status;
4104 }
4105
4106 /*
4107  * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4108  * so we do a temporary open here just to get an open file to pass to
4109  * vfs_test_lock.  (Arguably perhaps test_lock should be done with an
4110  * inode operation.)
4111  */
4112 static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4113 {
4114         struct file *file;
4115         int err;
4116
4117         err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4118         if (err)
4119                 return err;
4120         err = vfs_test_lock(file, lock);
4121         nfsd_close(file);
4122         return err;
4123 }
4124
4125 /*
4126  * LOCKT operation
4127  */
4128 __be32
4129 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4130             struct nfsd4_lockt *lockt)
4131 {
4132         struct inode *inode;
4133         struct file_lock file_lock;
4134         struct nfs4_lockowner *lo;
4135         int error;
4136         __be32 status;
4137
4138         if (locks_in_grace())
4139                 return nfserr_grace;
4140
4141         if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4142                  return nfserr_inval;
4143
4144         nfs4_lock_state();
4145
4146         status = nfserr_stale_clientid;
4147         if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
4148                 goto out;
4149
4150         if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
4151                 goto out;
4152
4153         inode = cstate->current_fh.fh_dentry->d_inode;
4154         locks_init_lock(&file_lock);
4155         switch (lockt->lt_type) {
4156                 case NFS4_READ_LT:
4157                 case NFS4_READW_LT:
4158                         file_lock.fl_type = F_RDLCK;
4159                 break;
4160                 case NFS4_WRITE_LT:
4161                 case NFS4_WRITEW_LT:
4162                         file_lock.fl_type = F_WRLCK;
4163                 break;
4164                 default:
4165                         dprintk("NFSD: nfs4_lockt: bad lock type!\n");
4166                         status = nfserr_inval;
4167                 goto out;
4168         }
4169
4170         lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner);
4171         if (lo)
4172                 file_lock.fl_owner = (fl_owner_t)lo;
4173         file_lock.fl_pid = current->tgid;
4174         file_lock.fl_flags = FL_POSIX;
4175
4176         file_lock.fl_start = lockt->lt_offset;
4177         file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
4178
4179         nfs4_transform_lock_offset(&file_lock);
4180
4181         status = nfs_ok;
4182         error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
4183         if (error) {
4184                 status = nfserrno(error);
4185                 goto out;
4186         }
4187         if (file_lock.fl_type != F_UNLCK) {
4188                 status = nfserr_denied;
4189                 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
4190         }
4191 out:
4192         nfs4_unlock_state();
4193         return status;
4194 }
4195
4196 __be32
4197 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4198             struct nfsd4_locku *locku)
4199 {
4200         struct nfs4_ol_stateid *stp;
4201         struct file *filp = NULL;
4202         struct file_lock file_lock;
4203         __be32 status;
4204         int err;
4205                                                         
4206         dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4207                 (long long) locku->lu_offset,
4208                 (long long) locku->lu_length);
4209
4210         if (check_lock_length(locku->lu_offset, locku->lu_length))
4211                  return nfserr_inval;
4212
4213         nfs4_lock_state();
4214                                                                                 
4215         status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
4216                                         &locku->lu_stateid, NFS4_LOCK_STID, &stp);
4217         if (status)
4218                 goto out;
4219         filp = find_any_file(stp->st_file);
4220         if (!filp) {
4221                 status = nfserr_lock_range;
4222                 goto out;
4223         }
4224         BUG_ON(!filp);
4225         locks_init_lock(&file_lock);
4226         file_lock.fl_type = F_UNLCK;
4227         file_lock.fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
4228         file_lock.fl_pid = current->tgid;
4229         file_lock.fl_file = filp;
4230         file_lock.fl_flags = FL_POSIX; 
4231         file_lock.fl_lmops = &nfsd_posix_mng_ops;
4232         file_lock.fl_start = locku->lu_offset;
4233
4234         file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
4235         nfs4_transform_lock_offset(&file_lock);
4236
4237         /*
4238         *  Try to unlock the file in the VFS.
4239         */
4240         err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
4241         if (err) {
4242                 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
4243                 goto out_nfserr;
4244         }
4245         /*
4246         * OK, unlock succeeded; the only thing left to do is update the stateid.
4247         */
4248         update_stateid(&stp->st_stid.sc_stateid);
4249         memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
4250
4251 out:
4252         if (!cstate->replay_owner)
4253                 nfs4_unlock_state();
4254         return status;
4255
4256 out_nfserr:
4257         status = nfserrno(err);
4258         goto out;
4259 }
4260
4261 /*
4262  * returns
4263  *      1: locks held by lockowner
4264  *      0: no locks held by lockowner
4265  */
4266 static int
4267 check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
4268 {
4269         struct file_lock **flpp;
4270         struct inode *inode = filp->fi_inode;
4271         int status = 0;
4272
4273         lock_flocks();
4274         for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
4275                 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
4276                         status = 1;
4277                         goto out;
4278                 }
4279         }
4280 out:
4281         unlock_flocks();
4282         return status;
4283 }
4284
4285 __be32
4286 nfsd4_release_lockowner(struct svc_rqst *rqstp,
4287                         struct nfsd4_compound_state *cstate,
4288                         struct nfsd4_release_lockowner *rlockowner)
4289 {
4290         clientid_t *clid = &rlockowner->rl_clientid;
4291         struct nfs4_stateowner *sop;
4292         struct nfs4_lockowner *lo;
4293         struct nfs4_ol_stateid *stp;
4294         struct xdr_netobj *owner = &rlockowner->rl_owner;
4295         struct list_head matches;
4296         unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
4297         __be32 status;
4298
4299         dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4300                 clid->cl_boot, clid->cl_id);
4301
4302         /* XXX check for lease expiration */
4303
4304         status = nfserr_stale_clientid;
4305         if (STALE_CLIENTID(clid))
4306                 return status;
4307
4308         nfs4_lock_state();
4309
4310         status = nfserr_locks_held;
4311         INIT_LIST_HEAD(&matches);
4312
4313         list_for_each_entry(sop, &ownerstr_hashtbl[hashval], so_strhash) {
4314                 if (sop->so_is_open_owner)
4315                         continue;
4316                 if (!same_owner_str(sop, owner, clid))
4317                         continue;
4318                 list_for_each_entry(stp, &sop->so_stateids,
4319                                 st_perstateowner) {
4320                         lo = lockowner(sop);
4321                         if (check_for_locks(stp->st_file, lo))
4322                                 goto out;
4323                         list_add(&lo->lo_list, &matches);
4324                 }
4325         }
4326         /* Clients probably won't expect us to return with some (but not all)
4327          * of the lockowner state released; so don't release any until all
4328          * have been checked. */
4329         status = nfs_ok;
4330         while (!list_empty(&matches)) {
4331                 lo = list_entry(matches.next, struct nfs4_lockowner,
4332                                                                 lo_list);
4333                 /* unhash_stateowner deletes so_perclient only
4334                  * for openowners. */
4335                 list_del(&lo->lo_list);
4336                 release_lockowner(lo);
4337         }
4338 out:
4339         nfs4_unlock_state();
4340         return status;
4341 }
4342
4343 static inline struct nfs4_client_reclaim *
4344 alloc_reclaim(void)
4345 {
4346         return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
4347 }
4348
4349 int
4350 nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
4351 {
4352         unsigned int strhashval = clientstr_hashval(name);
4353         struct nfs4_client *clp;
4354
4355         clp = find_confirmed_client_by_str(name, strhashval);
4356         return clp ? 1 : 0;
4357 }
4358
4359 /*
4360  * failure => all reset bets are off, nfserr_no_grace...
4361  */
4362 int
4363 nfs4_client_to_reclaim(const char *name)
4364 {
4365         unsigned int strhashval;
4366         struct nfs4_client_reclaim *crp = NULL;
4367
4368         dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4369         crp = alloc_reclaim();
4370         if (!crp)
4371                 return 0;
4372         strhashval = clientstr_hashval(name);
4373         INIT_LIST_HEAD(&crp->cr_strhash);
4374         list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
4375         memcpy(crp->cr_recdir, name, HEXDIR_LEN);
4376         reclaim_str_hashtbl_size++;
4377         return 1;
4378 }
4379
4380 static void
4381 nfs4_release_reclaim(void)
4382 {
4383         struct nfs4_client_reclaim *crp = NULL;
4384         int i;
4385
4386         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4387                 while (!list_empty(&reclaim_str_hashtbl[i])) {
4388                         crp = list_entry(reclaim_str_hashtbl[i].next,
4389                                         struct nfs4_client_reclaim, cr_strhash);
4390                         list_del(&crp->cr_strhash);
4391                         kfree(crp);
4392                         reclaim_str_hashtbl_size--;
4393                 }
4394         }
4395         BUG_ON(reclaim_str_hashtbl_size);
4396 }
4397
4398 /*
4399  * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
4400 static struct nfs4_client_reclaim *
4401 nfs4_find_reclaim_client(clientid_t *clid)
4402 {
4403         unsigned int strhashval;
4404         struct nfs4_client *clp;
4405         struct nfs4_client_reclaim *crp = NULL;
4406
4407
4408         /* find clientid in conf_id_hashtbl */
4409         clp = find_confirmed_client(clid);
4410         if (clp == NULL)
4411                 return NULL;
4412
4413         dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4414                             clp->cl_name.len, clp->cl_name.data,
4415                             clp->cl_recdir);
4416
4417         /* find clp->cl_name in reclaim_str_hashtbl */
4418         strhashval = clientstr_hashval(clp->cl_recdir);
4419         list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
4420                 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
4421                         return crp;
4422                 }
4423         }
4424         return NULL;
4425 }
4426
4427 /*
4428 * Called from OPEN. Look for clientid in reclaim list.
4429 */
4430 __be32
4431 nfs4_check_open_reclaim(clientid_t *clid)
4432 {
4433         return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
4434 }
4435
4436 #ifdef CONFIG_NFSD_FAULT_INJECTION
4437
4438 void nfsd_forget_clients(u64 num)
4439 {
4440         struct nfs4_client *clp, *next;
4441         int count = 0;
4442
4443         nfs4_lock_state();
4444         list_for_each_entry_safe(clp, next, &client_lru, cl_lru) {
4445                 nfsd4_remove_clid_dir(clp);
4446                 expire_client(clp);
4447                 if (++count == num)
4448                         break;
4449         }
4450         nfs4_unlock_state();
4451
4452         printk(KERN_INFO "NFSD: Forgot %d clients", count);
4453 }
4454
4455 static void release_lockowner_sop(struct nfs4_stateowner *sop)
4456 {
4457         release_lockowner(lockowner(sop));
4458 }
4459
4460 static void release_openowner_sop(struct nfs4_stateowner *sop)
4461 {
4462         release_openowner(openowner(sop));
4463 }
4464
4465 static int nfsd_release_n_owners(u64 num, bool is_open_owner,
4466                                 void (*release_sop)(struct nfs4_stateowner *))
4467 {
4468         int i, count = 0;
4469         struct nfs4_stateowner *sop, *next;
4470
4471         for (i = 0; i < OWNER_HASH_SIZE; i++) {
4472                 list_for_each_entry_safe(sop, next, &ownerstr_hashtbl[i], so_strhash) {
4473                         if (sop->so_is_open_owner != is_open_owner)
4474                                 continue;
4475                         release_sop(sop);
4476                         if (++count == num)
4477                                 return count;
4478                 }
4479         }
4480         return count;
4481 }
4482
4483 void nfsd_forget_locks(u64 num)
4484 {
4485         int count;
4486
4487         nfs4_lock_state();
4488         count = nfsd_release_n_owners(num, false, release_lockowner_sop);
4489         nfs4_unlock_state();
4490
4491         printk(KERN_INFO "NFSD: Forgot %d locks", count);
4492 }
4493
4494 void nfsd_forget_openowners(u64 num)
4495 {
4496         int count;
4497
4498         nfs4_lock_state();
4499         count = nfsd_release_n_owners(num, true, release_openowner_sop);
4500         nfs4_unlock_state();
4501
4502         printk(KERN_INFO "NFSD: Forgot %d open owners", count);
4503 }
4504
4505 int nfsd_process_n_delegations(u64 num, void (*deleg_func)(struct nfs4_delegation *))
4506 {
4507         int i, count = 0;
4508         struct nfs4_file *fp, *fnext;
4509         struct nfs4_delegation *dp, *dnext;
4510
4511         for (i = 0; i < FILE_HASH_SIZE; i++) {
4512                 list_for_each_entry_safe(fp, fnext, &file_hashtbl[i], fi_hash) {
4513                         list_for_each_entry_safe(dp, dnext, &fp->fi_delegations, dl_perfile) {
4514                                 deleg_func(dp);
4515                                 if (++count == num)
4516                                         return count;
4517                         }
4518                 }
4519         }
4520
4521         return count;
4522 }
4523
4524 void nfsd_forget_delegations(u64 num)
4525 {
4526         unsigned int count;
4527
4528         nfs4_lock_state();
4529         count = nfsd_process_n_delegations(num, unhash_delegation);
4530         nfs4_unlock_state();
4531
4532         printk(KERN_INFO "NFSD: Forgot %d delegations", count);
4533 }
4534
4535 void nfsd_recall_delegations(u64 num)
4536 {
4537         unsigned int count;
4538
4539         nfs4_lock_state();
4540         spin_lock(&recall_lock);
4541         count = nfsd_process_n_delegations(num, nfsd_break_one_deleg);
4542         spin_unlock(&recall_lock);
4543         nfs4_unlock_state();
4544
4545         printk(KERN_INFO "NFSD: Recalled %d delegations", count);
4546 }
4547
4548 #endif /* CONFIG_NFSD_FAULT_INJECTION */
4549
4550 /* initialization to perform at module load time: */
4551
4552 void
4553 nfs4_state_init(void)
4554 {
4555         int i;
4556
4557         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4558                 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4559                 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4560                 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4561                 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
4562                 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
4563         }
4564         for (i = 0; i < SESSION_HASH_SIZE; i++)
4565                 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
4566         for (i = 0; i < FILE_HASH_SIZE; i++) {
4567                 INIT_LIST_HEAD(&file_hashtbl[i]);
4568         }
4569         for (i = 0; i < OWNER_HASH_SIZE; i++) {
4570                 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
4571         }
4572         for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
4573                 INIT_LIST_HEAD(&lockowner_ino_hashtbl[i]);
4574         INIT_LIST_HEAD(&close_lru);
4575         INIT_LIST_HEAD(&client_lru);
4576         INIT_LIST_HEAD(&del_recall_lru);
4577         reclaim_str_hashtbl_size = 0;
4578 }
4579
4580 static void
4581 nfsd4_load_reboot_recovery_data(void)
4582 {
4583         int status;
4584
4585         nfs4_lock_state();
4586         nfsd4_init_recdir();
4587         status = nfsd4_recdir_load();
4588         nfs4_unlock_state();
4589         if (status)
4590                 printk("NFSD: Failure reading reboot recovery data\n");
4591 }
4592
4593 /*
4594  * Since the lifetime of a delegation isn't limited to that of an open, a
4595  * client may quite reasonably hang on to a delegation as long as it has
4596  * the inode cached.  This becomes an obvious problem the first time a
4597  * client's inode cache approaches the size of the server's total memory.
4598  *
4599  * For now we avoid this problem by imposing a hard limit on the number
4600  * of delegations, which varies according to the server's memory size.
4601  */
4602 static void
4603 set_max_delegations(void)
4604 {
4605         /*
4606          * Allow at most 4 delegations per megabyte of RAM.  Quick
4607          * estimates suggest that in the worst case (where every delegation
4608          * is for a different inode), a delegation could take about 1.5K,
4609          * giving a worst case usage of about 6% of memory.
4610          */
4611         max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4612 }
4613
4614 /* initialization to perform when the nfsd service is started: */
4615
4616 static int
4617 __nfs4_state_start(void)
4618 {
4619         int ret;
4620
4621         boot_time = get_seconds();
4622         locks_start_grace(&nfsd4_manager);
4623         printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
4624                nfsd4_grace);
4625         ret = set_callback_cred();
4626         if (ret)
4627                 return -ENOMEM;
4628         laundry_wq = create_singlethread_workqueue("nfsd4");
4629         if (laundry_wq == NULL)
4630                 return -ENOMEM;
4631         ret = nfsd4_create_callback_queue();
4632         if (ret)
4633                 goto out_free_laundry;
4634         queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
4635         set_max_delegations();
4636         return 0;
4637 out_free_laundry:
4638         destroy_workqueue(laundry_wq);
4639         return ret;
4640 }
4641
4642 int
4643 nfs4_state_start(void)
4644 {
4645         nfsd4_load_reboot_recovery_data();
4646         return __nfs4_state_start();
4647 }
4648
4649 static void
4650 __nfs4_state_shutdown(void)
4651 {
4652         int i;
4653         struct nfs4_client *clp = NULL;
4654         struct nfs4_delegation *dp = NULL;
4655         struct list_head *pos, *next, reaplist;
4656
4657         for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4658                 while (!list_empty(&conf_id_hashtbl[i])) {
4659                         clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4660                         expire_client(clp);
4661                 }
4662                 while (!list_empty(&unconf_str_hashtbl[i])) {
4663                         clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4664                         expire_client(clp);
4665                 }
4666         }
4667         INIT_LIST_HEAD(&reaplist);
4668         spin_lock(&recall_lock);
4669         list_for_each_safe(pos, next, &del_recall_lru) {
4670                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4671                 list_move(&dp->dl_recall_lru, &reaplist);
4672         }
4673         spin_unlock(&recall_lock);
4674         list_for_each_safe(pos, next, &reaplist) {
4675                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4676                 unhash_delegation(dp);
4677         }
4678
4679         nfsd4_shutdown_recdir();
4680 }
4681
4682 void
4683 nfs4_state_shutdown(void)
4684 {
4685         cancel_delayed_work_sync(&laundromat_work);
4686         destroy_workqueue(laundry_wq);
4687         locks_end_grace(&nfsd4_manager);
4688         nfs4_lock_state();
4689         nfs4_release_reclaim();
4690         __nfs4_state_shutdown();
4691         nfs4_unlock_state();
4692         nfsd4_destroy_callback_queue();
4693 }