Merge branch 'for-2.6.39' of git://linux-nfs.org/~bfields/linux
[pandora-kernel.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/sunrpc/svcauth_gss.h>
41 #include <linux/sunrpc/clnt.h>
42 #include "xdr4.h"
43 #include "vfs.h"
44
45 #define NFSDDBG_FACILITY                NFSDDBG_PROC
46
47 /* Globals */
48 time_t nfsd4_lease = 90;     /* default lease time */
49 time_t nfsd4_grace = 90;
50 static time_t boot_time;
51 static u32 current_ownerid = 1;
52 static u32 current_fileid = 1;
53 static u32 current_delegid = 1;
54 static stateid_t zerostateid;             /* bits all 0 */
55 static stateid_t onestateid;              /* bits all 1 */
56 static u64 current_sessionid = 1;
57
58 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
59 #define ONE_STATEID(stateid)  (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
60
61 /* forward declarations */
62 static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
63 static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
64 static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
65 static void nfs4_set_recdir(char *recdir);
66
67 /* Locking: */
68
69 /* Currently used for almost all code touching nfsv4 state: */
70 static DEFINE_MUTEX(client_mutex);
71
72 /*
73  * Currently used for the del_recall_lru and file hash table.  In an
74  * effort to decrease the scope of the client_mutex, this spinlock may
75  * eventually cover more:
76  */
77 static DEFINE_SPINLOCK(recall_lock);
78
79 static struct kmem_cache *stateowner_slab = NULL;
80 static struct kmem_cache *file_slab = NULL;
81 static struct kmem_cache *stateid_slab = NULL;
82 static struct kmem_cache *deleg_slab = NULL;
83
84 void
85 nfs4_lock_state(void)
86 {
87         mutex_lock(&client_mutex);
88 }
89
90 void
91 nfs4_unlock_state(void)
92 {
93         mutex_unlock(&client_mutex);
94 }
95
96 static inline u32
97 opaque_hashval(const void *ptr, int nbytes)
98 {
99         unsigned char *cptr = (unsigned char *) ptr;
100
101         u32 x = 0;
102         while (nbytes--) {
103                 x *= 37;
104                 x += *cptr++;
105         }
106         return x;
107 }
108
109 static struct list_head del_recall_lru;
110
111 static inline void
112 put_nfs4_file(struct nfs4_file *fi)
113 {
114         if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
115                 list_del(&fi->fi_hash);
116                 spin_unlock(&recall_lock);
117                 iput(fi->fi_inode);
118                 kmem_cache_free(file_slab, fi);
119         }
120 }
121
122 static inline void
123 get_nfs4_file(struct nfs4_file *fi)
124 {
125         atomic_inc(&fi->fi_ref);
126 }
127
128 static int num_delegations;
129 unsigned int max_delegations;
130
131 /*
132  * Open owner state (share locks)
133  */
134
135 /* hash tables for nfs4_stateowner */
136 #define OWNER_HASH_BITS              8
137 #define OWNER_HASH_SIZE             (1 << OWNER_HASH_BITS)
138 #define OWNER_HASH_MASK             (OWNER_HASH_SIZE - 1)
139
140 #define ownerid_hashval(id) \
141         ((id) & OWNER_HASH_MASK)
142 #define ownerstr_hashval(clientid, ownername) \
143         (((clientid) + opaque_hashval((ownername.data), (ownername.len))) & OWNER_HASH_MASK)
144
145 static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
146 static struct list_head ownerstr_hashtbl[OWNER_HASH_SIZE];
147
148 /* hash table for nfs4_file */
149 #define FILE_HASH_BITS                   8
150 #define FILE_HASH_SIZE                  (1 << FILE_HASH_BITS)
151
152 /* hash table for (open)nfs4_stateid */
153 #define STATEID_HASH_BITS              10
154 #define STATEID_HASH_SIZE              (1 << STATEID_HASH_BITS)
155 #define STATEID_HASH_MASK              (STATEID_HASH_SIZE - 1)
156
157 #define file_hashval(x) \
158         hash_ptr(x, FILE_HASH_BITS)
159 #define stateid_hashval(owner_id, file_id)  \
160         (((owner_id) + (file_id)) & STATEID_HASH_MASK)
161
162 static struct list_head file_hashtbl[FILE_HASH_SIZE];
163 static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
164
165 static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
166 {
167         BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
168         atomic_inc(&fp->fi_access[oflag]);
169 }
170
171 static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
172 {
173         if (oflag == O_RDWR) {
174                 __nfs4_file_get_access(fp, O_RDONLY);
175                 __nfs4_file_get_access(fp, O_WRONLY);
176         } else
177                 __nfs4_file_get_access(fp, oflag);
178 }
179
180 static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
181 {
182         if (fp->fi_fds[oflag]) {
183                 fput(fp->fi_fds[oflag]);
184                 fp->fi_fds[oflag] = NULL;
185         }
186 }
187
188 static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
189 {
190         if (atomic_dec_and_test(&fp->fi_access[oflag])) {
191                 nfs4_file_put_fd(fp, O_RDWR);
192                 nfs4_file_put_fd(fp, oflag);
193         }
194 }
195
196 static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
197 {
198         if (oflag == O_RDWR) {
199                 __nfs4_file_put_access(fp, O_RDONLY);
200                 __nfs4_file_put_access(fp, O_WRONLY);
201         } else
202                 __nfs4_file_put_access(fp, oflag);
203 }
204
205 static struct nfs4_delegation *
206 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
207 {
208         struct nfs4_delegation *dp;
209         struct nfs4_file *fp = stp->st_file;
210
211         dprintk("NFSD alloc_init_deleg\n");
212         /*
213          * Major work on the lease subsystem (for example, to support
214          * calbacks on stat) will be required before we can support
215          * write delegations properly.
216          */
217         if (type != NFS4_OPEN_DELEGATE_READ)
218                 return NULL;
219         if (fp->fi_had_conflict)
220                 return NULL;
221         if (num_delegations > max_delegations)
222                 return NULL;
223         dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
224         if (dp == NULL)
225                 return dp;
226         num_delegations++;
227         INIT_LIST_HEAD(&dp->dl_perfile);
228         INIT_LIST_HEAD(&dp->dl_perclnt);
229         INIT_LIST_HEAD(&dp->dl_recall_lru);
230         dp->dl_client = clp;
231         get_nfs4_file(fp);
232         dp->dl_file = fp;
233         dp->dl_type = type;
234         dp->dl_stateid.si_boot = boot_time;
235         dp->dl_stateid.si_stateownerid = current_delegid++;
236         dp->dl_stateid.si_fileid = 0;
237         dp->dl_stateid.si_generation = 0;
238         fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
239         dp->dl_time = 0;
240         atomic_set(&dp->dl_count, 1);
241         INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
242         return dp;
243 }
244
245 void
246 nfs4_put_delegation(struct nfs4_delegation *dp)
247 {
248         if (atomic_dec_and_test(&dp->dl_count)) {
249                 dprintk("NFSD: freeing dp %p\n",dp);
250                 put_nfs4_file(dp->dl_file);
251                 kmem_cache_free(deleg_slab, dp);
252                 num_delegations--;
253         }
254 }
255
256 static void nfs4_put_deleg_lease(struct nfs4_file *fp)
257 {
258         if (atomic_dec_and_test(&fp->fi_delegees)) {
259                 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
260                 fp->fi_lease = NULL;
261                 fp->fi_deleg_file = NULL;
262         }
263 }
264
265 /* Called under the state lock. */
266 static void
267 unhash_delegation(struct nfs4_delegation *dp)
268 {
269         list_del_init(&dp->dl_perclnt);
270         spin_lock(&recall_lock);
271         list_del_init(&dp->dl_perfile);
272         list_del_init(&dp->dl_recall_lru);
273         spin_unlock(&recall_lock);
274         nfs4_put_deleg_lease(dp->dl_file);
275         nfs4_put_delegation(dp);
276 }
277
278 /* 
279  * SETCLIENTID state 
280  */
281
282 /* client_lock protects the client lru list and session hash table */
283 static DEFINE_SPINLOCK(client_lock);
284
285 /* Hash tables for nfs4_clientid state */
286 #define CLIENT_HASH_BITS                 4
287 #define CLIENT_HASH_SIZE                (1 << CLIENT_HASH_BITS)
288 #define CLIENT_HASH_MASK                (CLIENT_HASH_SIZE - 1)
289
290 #define clientid_hashval(id) \
291         ((id) & CLIENT_HASH_MASK)
292 #define clientstr_hashval(name) \
293         (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
294 /*
295  * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
296  * used in reboot/reset lease grace period processing
297  *
298  * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
299  * setclientid_confirmed info. 
300  *
301  * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed 
302  * setclientid info.
303  *
304  * client_lru holds client queue ordered by nfs4_client.cl_time
305  * for lease renewal.
306  *
307  * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
308  * for last close replay.
309  */
310 static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
311 static int reclaim_str_hashtbl_size = 0;
312 static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
313 static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
314 static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
315 static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
316 static struct list_head client_lru;
317 static struct list_head close_lru;
318
319 /*
320  * We store the NONE, READ, WRITE, and BOTH bits separately in the
321  * st_{access,deny}_bmap field of the stateid, in order to track not
322  * only what share bits are currently in force, but also what
323  * combinations of share bits previous opens have used.  This allows us
324  * to enforce the recommendation of rfc 3530 14.2.19 that the server
325  * return an error if the client attempt to downgrade to a combination
326  * of share bits not explicable by closing some of its previous opens.
327  *
328  * XXX: This enforcement is actually incomplete, since we don't keep
329  * track of access/deny bit combinations; so, e.g., we allow:
330  *
331  *      OPEN allow read, deny write
332  *      OPEN allow both, deny none
333  *      DOWNGRADE allow read, deny none
334  *
335  * which we should reject.
336  */
337 static void
338 set_access(unsigned int *access, unsigned long bmap) {
339         int i;
340
341         *access = 0;
342         for (i = 1; i < 4; i++) {
343                 if (test_bit(i, &bmap))
344                         *access |= i;
345         }
346 }
347
348 static void
349 set_deny(unsigned int *deny, unsigned long bmap) {
350         int i;
351
352         *deny = 0;
353         for (i = 0; i < 4; i++) {
354                 if (test_bit(i, &bmap))
355                         *deny |= i ;
356         }
357 }
358
359 static int
360 test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
361         unsigned int access, deny;
362
363         set_access(&access, stp->st_access_bmap);
364         set_deny(&deny, stp->st_deny_bmap);
365         if ((access & open->op_share_deny) || (deny & open->op_share_access))
366                 return 0;
367         return 1;
368 }
369
370 static int nfs4_access_to_omode(u32 access)
371 {
372         switch (access & NFS4_SHARE_ACCESS_BOTH) {
373         case NFS4_SHARE_ACCESS_READ:
374                 return O_RDONLY;
375         case NFS4_SHARE_ACCESS_WRITE:
376                 return O_WRONLY;
377         case NFS4_SHARE_ACCESS_BOTH:
378                 return O_RDWR;
379         }
380         BUG();
381 }
382
383 static int nfs4_access_bmap_to_omode(struct nfs4_stateid *stp)
384 {
385         unsigned int access;
386
387         set_access(&access, stp->st_access_bmap);
388         return nfs4_access_to_omode(access);
389 }
390
391 static void unhash_generic_stateid(struct nfs4_stateid *stp)
392 {
393         list_del(&stp->st_hash);
394         list_del(&stp->st_perfile);
395         list_del(&stp->st_perstateowner);
396 }
397
398 static void free_generic_stateid(struct nfs4_stateid *stp)
399 {
400         int oflag;
401
402         if (stp->st_access_bmap) {
403                 oflag = nfs4_access_bmap_to_omode(stp);
404                 nfs4_file_put_access(stp->st_file, oflag);
405                 put_nfs4_file(stp->st_file);
406         }
407         kmem_cache_free(stateid_slab, stp);
408 }
409
410 static void release_lock_stateid(struct nfs4_stateid *stp)
411 {
412         struct file *file;
413
414         unhash_generic_stateid(stp);
415         file = find_any_file(stp->st_file);
416         if (file)
417                 locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
418         free_generic_stateid(stp);
419 }
420
421 static void unhash_lockowner(struct nfs4_stateowner *sop)
422 {
423         struct nfs4_stateid *stp;
424
425         list_del(&sop->so_idhash);
426         list_del(&sop->so_strhash);
427         list_del(&sop->so_perstateid);
428         while (!list_empty(&sop->so_stateids)) {
429                 stp = list_first_entry(&sop->so_stateids,
430                                 struct nfs4_stateid, st_perstateowner);
431                 release_lock_stateid(stp);
432         }
433 }
434
435 static void release_lockowner(struct nfs4_stateowner *sop)
436 {
437         unhash_lockowner(sop);
438         nfs4_put_stateowner(sop);
439 }
440
441 static void
442 release_stateid_lockowners(struct nfs4_stateid *open_stp)
443 {
444         struct nfs4_stateowner *lock_sop;
445
446         while (!list_empty(&open_stp->st_lockowners)) {
447                 lock_sop = list_entry(open_stp->st_lockowners.next,
448                                 struct nfs4_stateowner, so_perstateid);
449                 /* list_del(&open_stp->st_lockowners);  */
450                 BUG_ON(lock_sop->so_is_open_owner);
451                 release_lockowner(lock_sop);
452         }
453 }
454
455 static void release_open_stateid(struct nfs4_stateid *stp)
456 {
457         unhash_generic_stateid(stp);
458         release_stateid_lockowners(stp);
459         free_generic_stateid(stp);
460 }
461
462 static void unhash_openowner(struct nfs4_stateowner *sop)
463 {
464         struct nfs4_stateid *stp;
465
466         list_del(&sop->so_idhash);
467         list_del(&sop->so_strhash);
468         list_del(&sop->so_perclient);
469         list_del(&sop->so_perstateid); /* XXX: necessary? */
470         while (!list_empty(&sop->so_stateids)) {
471                 stp = list_first_entry(&sop->so_stateids,
472                                 struct nfs4_stateid, st_perstateowner);
473                 release_open_stateid(stp);
474         }
475 }
476
477 static void release_openowner(struct nfs4_stateowner *sop)
478 {
479         unhash_openowner(sop);
480         list_del(&sop->so_close_lru);
481         nfs4_put_stateowner(sop);
482 }
483
484 #define SESSION_HASH_SIZE       512
485 static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
486
487 static inline int
488 hash_sessionid(struct nfs4_sessionid *sessionid)
489 {
490         struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
491
492         return sid->sequence % SESSION_HASH_SIZE;
493 }
494
495 static inline void
496 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
497 {
498         u32 *ptr = (u32 *)(&sessionid->data[0]);
499         dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
500 }
501
502 static void
503 gen_sessionid(struct nfsd4_session *ses)
504 {
505         struct nfs4_client *clp = ses->se_client;
506         struct nfsd4_sessionid *sid;
507
508         sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
509         sid->clientid = clp->cl_clientid;
510         sid->sequence = current_sessionid++;
511         sid->reserved = 0;
512 }
513
514 /*
515  * The protocol defines ca_maxresponssize_cached to include the size of
516  * the rpc header, but all we need to cache is the data starting after
517  * the end of the initial SEQUENCE operation--the rest we regenerate
518  * each time.  Therefore we can advertise a ca_maxresponssize_cached
519  * value that is the number of bytes in our cache plus a few additional
520  * bytes.  In order to stay on the safe side, and not promise more than
521  * we can cache, those additional bytes must be the minimum possible: 24
522  * bytes of rpc header (xid through accept state, with AUTH_NULL
523  * verifier), 12 for the compound header (with zero-length tag), and 44
524  * for the SEQUENCE op response:
525  */
526 #define NFSD_MIN_HDR_SEQ_SZ  (24 + 12 + 44)
527
528 static void
529 free_session_slots(struct nfsd4_session *ses)
530 {
531         int i;
532
533         for (i = 0; i < ses->se_fchannel.maxreqs; i++)
534                 kfree(ses->se_slots[i]);
535 }
536
537 /*
538  * We don't actually need to cache the rpc and session headers, so we
539  * can allocate a little less for each slot:
540  */
541 static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
542 {
543         return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
544 }
545
546 static int nfsd4_sanitize_slot_size(u32 size)
547 {
548         size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
549         size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
550
551         return size;
552 }
553
554 /*
555  * XXX: If we run out of reserved DRC memory we could (up to a point)
556  * re-negotiate active sessions and reduce their slot usage to make
557  * rooom for new connections. For now we just fail the create session.
558  */
559 static int nfsd4_get_drc_mem(int slotsize, u32 num)
560 {
561         int avail;
562
563         num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
564
565         spin_lock(&nfsd_drc_lock);
566         avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
567                         nfsd_drc_max_mem - nfsd_drc_mem_used);
568         num = min_t(int, num, avail / slotsize);
569         nfsd_drc_mem_used += num * slotsize;
570         spin_unlock(&nfsd_drc_lock);
571
572         return num;
573 }
574
575 static void nfsd4_put_drc_mem(int slotsize, int num)
576 {
577         spin_lock(&nfsd_drc_lock);
578         nfsd_drc_mem_used -= slotsize * num;
579         spin_unlock(&nfsd_drc_lock);
580 }
581
582 static struct nfsd4_session *alloc_session(int slotsize, int numslots)
583 {
584         struct nfsd4_session *new;
585         int mem, i;
586
587         BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
588                         + sizeof(struct nfsd4_session) > PAGE_SIZE);
589         mem = numslots * sizeof(struct nfsd4_slot *);
590
591         new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
592         if (!new)
593                 return NULL;
594         /* allocate each struct nfsd4_slot and data cache in one piece */
595         for (i = 0; i < numslots; i++) {
596                 mem = sizeof(struct nfsd4_slot) + slotsize;
597                 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
598                 if (!new->se_slots[i])
599                         goto out_free;
600         }
601         return new;
602 out_free:
603         while (i--)
604                 kfree(new->se_slots[i]);
605         kfree(new);
606         return NULL;
607 }
608
609 static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
610 {
611         u32 maxrpc = nfsd_serv->sv_max_mesg;
612
613         new->maxreqs = numslots;
614         new->maxresp_cached = min_t(u32, req->maxresp_cached,
615                                         slotsize + NFSD_MIN_HDR_SEQ_SZ);
616         new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
617         new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
618         new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
619 }
620
621 static void free_conn(struct nfsd4_conn *c)
622 {
623         svc_xprt_put(c->cn_xprt);
624         kfree(c);
625 }
626
627 static void nfsd4_conn_lost(struct svc_xpt_user *u)
628 {
629         struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
630         struct nfs4_client *clp = c->cn_session->se_client;
631
632         spin_lock(&clp->cl_lock);
633         if (!list_empty(&c->cn_persession)) {
634                 list_del(&c->cn_persession);
635                 free_conn(c);
636         }
637         spin_unlock(&clp->cl_lock);
638         nfsd4_probe_callback(clp);
639 }
640
641 static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
642 {
643         struct nfsd4_conn *conn;
644
645         conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
646         if (!conn)
647                 return NULL;
648         svc_xprt_get(rqstp->rq_xprt);
649         conn->cn_xprt = rqstp->rq_xprt;
650         conn->cn_flags = flags;
651         INIT_LIST_HEAD(&conn->cn_xpt_user.list);
652         return conn;
653 }
654
655 static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
656 {
657         conn->cn_session = ses;
658         list_add(&conn->cn_persession, &ses->se_conns);
659 }
660
661 static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
662 {
663         struct nfs4_client *clp = ses->se_client;
664
665         spin_lock(&clp->cl_lock);
666         __nfsd4_hash_conn(conn, ses);
667         spin_unlock(&clp->cl_lock);
668 }
669
670 static int nfsd4_register_conn(struct nfsd4_conn *conn)
671 {
672         conn->cn_xpt_user.callback = nfsd4_conn_lost;
673         return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
674 }
675
676 static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
677 {
678         struct nfsd4_conn *conn;
679         int ret;
680
681         conn = alloc_conn(rqstp, dir);
682         if (!conn)
683                 return nfserr_jukebox;
684         nfsd4_hash_conn(conn, ses);
685         ret = nfsd4_register_conn(conn);
686         if (ret)
687                 /* oops; xprt is already down: */
688                 nfsd4_conn_lost(&conn->cn_xpt_user);
689         return nfs_ok;
690 }
691
692 static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
693 {
694         u32 dir = NFS4_CDFC4_FORE;
695
696         if (ses->se_flags & SESSION4_BACK_CHAN)
697                 dir |= NFS4_CDFC4_BACK;
698
699         return nfsd4_new_conn(rqstp, ses, dir);
700 }
701
702 /* must be called under client_lock */
703 static void nfsd4_del_conns(struct nfsd4_session *s)
704 {
705         struct nfs4_client *clp = s->se_client;
706         struct nfsd4_conn *c;
707
708         spin_lock(&clp->cl_lock);
709         while (!list_empty(&s->se_conns)) {
710                 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
711                 list_del_init(&c->cn_persession);
712                 spin_unlock(&clp->cl_lock);
713
714                 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
715                 free_conn(c);
716
717                 spin_lock(&clp->cl_lock);
718         }
719         spin_unlock(&clp->cl_lock);
720 }
721
722 void free_session(struct kref *kref)
723 {
724         struct nfsd4_session *ses;
725         int mem;
726
727         ses = container_of(kref, struct nfsd4_session, se_ref);
728         nfsd4_del_conns(ses);
729         spin_lock(&nfsd_drc_lock);
730         mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
731         nfsd_drc_mem_used -= mem;
732         spin_unlock(&nfsd_drc_lock);
733         free_session_slots(ses);
734         kfree(ses);
735 }
736
737 static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
738 {
739         struct nfsd4_session *new;
740         struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
741         int numslots, slotsize;
742         int status;
743         int idx;
744
745         /*
746          * Note decreasing slot size below client's request may
747          * make it difficult for client to function correctly, whereas
748          * decreasing the number of slots will (just?) affect
749          * performance.  When short on memory we therefore prefer to
750          * decrease number of slots instead of their size.
751          */
752         slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
753         numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
754         if (numslots < 1)
755                 return NULL;
756
757         new = alloc_session(slotsize, numslots);
758         if (!new) {
759                 nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
760                 return NULL;
761         }
762         init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
763
764         new->se_client = clp;
765         gen_sessionid(new);
766
767         INIT_LIST_HEAD(&new->se_conns);
768
769         new->se_cb_seq_nr = 1;
770         new->se_flags = cses->flags;
771         new->se_cb_prog = cses->callback_prog;
772         kref_init(&new->se_ref);
773         idx = hash_sessionid(&new->se_sessionid);
774         spin_lock(&client_lock);
775         list_add(&new->se_hash, &sessionid_hashtbl[idx]);
776         spin_lock(&clp->cl_lock);
777         list_add(&new->se_perclnt, &clp->cl_sessions);
778         spin_unlock(&clp->cl_lock);
779         spin_unlock(&client_lock);
780
781         status = nfsd4_new_conn_from_crses(rqstp, new);
782         /* whoops: benny points out, status is ignored! (err, or bogus) */
783         if (status) {
784                 free_session(&new->se_ref);
785                 return NULL;
786         }
787         if (cses->flags & SESSION4_BACK_CHAN) {
788                 struct sockaddr *sa = svc_addr(rqstp);
789                 /*
790                  * This is a little silly; with sessions there's no real
791                  * use for the callback address.  Use the peer address
792                  * as a reasonable default for now, but consider fixing
793                  * the rpc client not to require an address in the
794                  * future:
795                  */
796                 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
797                 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
798         }
799         nfsd4_probe_callback(clp);
800         return new;
801 }
802
803 /* caller must hold client_lock */
804 static struct nfsd4_session *
805 find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
806 {
807         struct nfsd4_session *elem;
808         int idx;
809
810         dump_sessionid(__func__, sessionid);
811         idx = hash_sessionid(sessionid);
812         /* Search in the appropriate list */
813         list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
814                 if (!memcmp(elem->se_sessionid.data, sessionid->data,
815                             NFS4_MAX_SESSIONID_LEN)) {
816                         return elem;
817                 }
818         }
819
820         dprintk("%s: session not found\n", __func__);
821         return NULL;
822 }
823
824 /* caller must hold client_lock */
825 static void
826 unhash_session(struct nfsd4_session *ses)
827 {
828         list_del(&ses->se_hash);
829         spin_lock(&ses->se_client->cl_lock);
830         list_del(&ses->se_perclnt);
831         spin_unlock(&ses->se_client->cl_lock);
832 }
833
834 /* must be called under the client_lock */
835 static inline void
836 renew_client_locked(struct nfs4_client *clp)
837 {
838         if (is_client_expired(clp)) {
839                 dprintk("%s: client (clientid %08x/%08x) already expired\n",
840                         __func__,
841                         clp->cl_clientid.cl_boot,
842                         clp->cl_clientid.cl_id);
843                 return;
844         }
845
846         /*
847         * Move client to the end to the LRU list.
848         */
849         dprintk("renewing client (clientid %08x/%08x)\n", 
850                         clp->cl_clientid.cl_boot, 
851                         clp->cl_clientid.cl_id);
852         list_move_tail(&clp->cl_lru, &client_lru);
853         clp->cl_time = get_seconds();
854 }
855
856 static inline void
857 renew_client(struct nfs4_client *clp)
858 {
859         spin_lock(&client_lock);
860         renew_client_locked(clp);
861         spin_unlock(&client_lock);
862 }
863
864 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
865 static int
866 STALE_CLIENTID(clientid_t *clid)
867 {
868         if (clid->cl_boot == boot_time)
869                 return 0;
870         dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
871                 clid->cl_boot, clid->cl_id, boot_time);
872         return 1;
873 }
874
875 /* 
876  * XXX Should we use a slab cache ?
877  * This type of memory management is somewhat inefficient, but we use it
878  * anyway since SETCLIENTID is not a common operation.
879  */
880 static struct nfs4_client *alloc_client(struct xdr_netobj name)
881 {
882         struct nfs4_client *clp;
883
884         clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
885         if (clp == NULL)
886                 return NULL;
887         clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
888         if (clp->cl_name.data == NULL) {
889                 kfree(clp);
890                 return NULL;
891         }
892         memcpy(clp->cl_name.data, name.data, name.len);
893         clp->cl_name.len = name.len;
894         return clp;
895 }
896
897 static inline void
898 free_client(struct nfs4_client *clp)
899 {
900         while (!list_empty(&clp->cl_sessions)) {
901                 struct nfsd4_session *ses;
902                 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
903                                 se_perclnt);
904                 list_del(&ses->se_perclnt);
905                 nfsd4_put_session(ses);
906         }
907         if (clp->cl_cred.cr_group_info)
908                 put_group_info(clp->cl_cred.cr_group_info);
909         kfree(clp->cl_principal);
910         kfree(clp->cl_name.data);
911         kfree(clp);
912 }
913
914 void
915 release_session_client(struct nfsd4_session *session)
916 {
917         struct nfs4_client *clp = session->se_client;
918
919         if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
920                 return;
921         if (is_client_expired(clp)) {
922                 free_client(clp);
923                 session->se_client = NULL;
924         } else
925                 renew_client_locked(clp);
926         spin_unlock(&client_lock);
927 }
928
929 /* must be called under the client_lock */
930 static inline void
931 unhash_client_locked(struct nfs4_client *clp)
932 {
933         struct nfsd4_session *ses;
934
935         mark_client_expired(clp);
936         list_del(&clp->cl_lru);
937         spin_lock(&clp->cl_lock);
938         list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
939                 list_del_init(&ses->se_hash);
940         spin_unlock(&clp->cl_lock);
941 }
942
943 static void
944 expire_client(struct nfs4_client *clp)
945 {
946         struct nfs4_stateowner *sop;
947         struct nfs4_delegation *dp;
948         struct list_head reaplist;
949
950         INIT_LIST_HEAD(&reaplist);
951         spin_lock(&recall_lock);
952         while (!list_empty(&clp->cl_delegations)) {
953                 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
954                 list_del_init(&dp->dl_perclnt);
955                 list_move(&dp->dl_recall_lru, &reaplist);
956         }
957         spin_unlock(&recall_lock);
958         while (!list_empty(&reaplist)) {
959                 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
960                 list_del_init(&dp->dl_recall_lru);
961                 unhash_delegation(dp);
962         }
963         while (!list_empty(&clp->cl_openowners)) {
964                 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
965                 release_openowner(sop);
966         }
967         nfsd4_shutdown_callback(clp);
968         if (clp->cl_cb_conn.cb_xprt)
969                 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
970         list_del(&clp->cl_idhash);
971         list_del(&clp->cl_strhash);
972         spin_lock(&client_lock);
973         unhash_client_locked(clp);
974         if (atomic_read(&clp->cl_refcount) == 0)
975                 free_client(clp);
976         spin_unlock(&client_lock);
977 }
978
979 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
980 {
981         memcpy(target->cl_verifier.data, source->data,
982                         sizeof(target->cl_verifier.data));
983 }
984
985 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
986 {
987         target->cl_clientid.cl_boot = source->cl_clientid.cl_boot; 
988         target->cl_clientid.cl_id = source->cl_clientid.cl_id; 
989 }
990
991 static void copy_cred(struct svc_cred *target, struct svc_cred *source)
992 {
993         target->cr_uid = source->cr_uid;
994         target->cr_gid = source->cr_gid;
995         target->cr_group_info = source->cr_group_info;
996         get_group_info(target->cr_group_info);
997 }
998
999 static int same_name(const char *n1, const char *n2)
1000 {
1001         return 0 == memcmp(n1, n2, HEXDIR_LEN);
1002 }
1003
1004 static int
1005 same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1006 {
1007         return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1008 }
1009
1010 static int
1011 same_clid(clientid_t *cl1, clientid_t *cl2)
1012 {
1013         return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1014 }
1015
1016 /* XXX what about NGROUP */
1017 static int
1018 same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1019 {
1020         return cr1->cr_uid == cr2->cr_uid;
1021 }
1022
1023 static void gen_clid(struct nfs4_client *clp)
1024 {
1025         static u32 current_clientid = 1;
1026
1027         clp->cl_clientid.cl_boot = boot_time;
1028         clp->cl_clientid.cl_id = current_clientid++; 
1029 }
1030
1031 static void gen_confirm(struct nfs4_client *clp)
1032 {
1033         static u32 i;
1034         u32 *p;
1035
1036         p = (u32 *)clp->cl_confirm.data;
1037         *p++ = get_seconds();
1038         *p++ = i++;
1039 }
1040
1041 static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1042                 struct svc_rqst *rqstp, nfs4_verifier *verf)
1043 {
1044         struct nfs4_client *clp;
1045         struct sockaddr *sa = svc_addr(rqstp);
1046         char *princ;
1047
1048         clp = alloc_client(name);
1049         if (clp == NULL)
1050                 return NULL;
1051
1052         INIT_LIST_HEAD(&clp->cl_sessions);
1053
1054         princ = svc_gss_principal(rqstp);
1055         if (princ) {
1056                 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
1057                 if (clp->cl_principal == NULL) {
1058                         free_client(clp);
1059                         return NULL;
1060                 }
1061         }
1062
1063         memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
1064         atomic_set(&clp->cl_refcount, 0);
1065         clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1066         INIT_LIST_HEAD(&clp->cl_idhash);
1067         INIT_LIST_HEAD(&clp->cl_strhash);
1068         INIT_LIST_HEAD(&clp->cl_openowners);
1069         INIT_LIST_HEAD(&clp->cl_delegations);
1070         INIT_LIST_HEAD(&clp->cl_lru);
1071         INIT_LIST_HEAD(&clp->cl_callbacks);
1072         spin_lock_init(&clp->cl_lock);
1073         INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
1074         clp->cl_time = get_seconds();
1075         clear_bit(0, &clp->cl_cb_slot_busy);
1076         rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1077         copy_verf(clp, verf);
1078         rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1079         clp->cl_flavor = rqstp->rq_flavor;
1080         copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1081         gen_confirm(clp);
1082         clp->cl_cb_session = NULL;
1083         return clp;
1084 }
1085
1086 static int check_name(struct xdr_netobj name)
1087 {
1088         if (name.len == 0) 
1089                 return 0;
1090         if (name.len > NFS4_OPAQUE_LIMIT) {
1091                 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
1092                 return 0;
1093         }
1094         return 1;
1095 }
1096
1097 static void
1098 add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1099 {
1100         unsigned int idhashval;
1101
1102         list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1103         idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1104         list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
1105         renew_client(clp);
1106 }
1107
1108 static void
1109 move_to_confirmed(struct nfs4_client *clp)
1110 {
1111         unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1112         unsigned int strhashval;
1113
1114         dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1115         list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
1116         strhashval = clientstr_hashval(clp->cl_recdir);
1117         list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
1118         renew_client(clp);
1119 }
1120
1121 static struct nfs4_client *
1122 find_confirmed_client(clientid_t *clid)
1123 {
1124         struct nfs4_client *clp;
1125         unsigned int idhashval = clientid_hashval(clid->cl_id);
1126
1127         list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
1128                 if (same_clid(&clp->cl_clientid, clid))
1129                         return clp;
1130         }
1131         return NULL;
1132 }
1133
1134 static struct nfs4_client *
1135 find_unconfirmed_client(clientid_t *clid)
1136 {
1137         struct nfs4_client *clp;
1138         unsigned int idhashval = clientid_hashval(clid->cl_id);
1139
1140         list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
1141                 if (same_clid(&clp->cl_clientid, clid))
1142                         return clp;
1143         }
1144         return NULL;
1145 }
1146
1147 static bool clp_used_exchangeid(struct nfs4_client *clp)
1148 {
1149         return clp->cl_exchange_flags != 0;
1150
1151
1152 static struct nfs4_client *
1153 find_confirmed_client_by_str(const char *dname, unsigned int hashval)
1154 {
1155         struct nfs4_client *clp;
1156
1157         list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
1158                 if (same_name(clp->cl_recdir, dname))
1159                         return clp;
1160         }
1161         return NULL;
1162 }
1163
1164 static struct nfs4_client *
1165 find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
1166 {
1167         struct nfs4_client *clp;
1168
1169         list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
1170                 if (same_name(clp->cl_recdir, dname))
1171                         return clp;
1172         }
1173         return NULL;
1174 }
1175
1176 static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr)
1177 {
1178         switch (family) {
1179         case AF_INET:
1180                 ((struct sockaddr_in *)sa)->sin_family = AF_INET;
1181                 ((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr;
1182                 return;
1183         case AF_INET6:
1184                 ((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
1185                 ((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6;
1186                 return;
1187         }
1188 }
1189
1190 static void
1191 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
1192 {
1193         struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1194         struct sockaddr *sa = svc_addr(rqstp);
1195         u32 scopeid = rpc_get_scope_id(sa);
1196         unsigned short expected_family;
1197
1198         /* Currently, we only support tcp and tcp6 for the callback channel */
1199         if (se->se_callback_netid_len == 3 &&
1200             !memcmp(se->se_callback_netid_val, "tcp", 3))
1201                 expected_family = AF_INET;
1202         else if (se->se_callback_netid_len == 4 &&
1203                  !memcmp(se->se_callback_netid_val, "tcp6", 4))
1204                 expected_family = AF_INET6;
1205         else
1206                 goto out_err;
1207
1208         conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
1209                                             se->se_callback_addr_len,
1210                                             (struct sockaddr *)&conn->cb_addr,
1211                                             sizeof(conn->cb_addr));
1212
1213         if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1214                 goto out_err;
1215
1216         if (conn->cb_addr.ss_family == AF_INET6)
1217                 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1218
1219         conn->cb_prog = se->se_callback_prog;
1220         conn->cb_ident = se->se_callback_ident;
1221         rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr);
1222         return;
1223 out_err:
1224         conn->cb_addr.ss_family = AF_UNSPEC;
1225         conn->cb_addrlen = 0;
1226         dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1227                 "will not receive delegations\n",
1228                 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1229
1230         return;
1231 }
1232
1233 /*
1234  * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
1235  */
1236 void
1237 nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1238 {
1239         struct nfsd4_slot *slot = resp->cstate.slot;
1240         unsigned int base;
1241
1242         dprintk("--> %s slot %p\n", __func__, slot);
1243
1244         slot->sl_opcnt = resp->opcnt;
1245         slot->sl_status = resp->cstate.status;
1246
1247         if (nfsd4_not_cached(resp)) {
1248                 slot->sl_datalen = 0;
1249                 return;
1250         }
1251         slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1252         base = (char *)resp->cstate.datap -
1253                                         (char *)resp->xbuf->head[0].iov_base;
1254         if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1255                                     slot->sl_datalen))
1256                 WARN("%s: sessions DRC could not cache compound\n", __func__);
1257         return;
1258 }
1259
1260 /*
1261  * Encode the replay sequence operation from the slot values.
1262  * If cachethis is FALSE encode the uncached rep error on the next
1263  * operation which sets resp->p and increments resp->opcnt for
1264  * nfs4svc_encode_compoundres.
1265  *
1266  */
1267 static __be32
1268 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1269                           struct nfsd4_compoundres *resp)
1270 {
1271         struct nfsd4_op *op;
1272         struct nfsd4_slot *slot = resp->cstate.slot;
1273
1274         dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
1275                 resp->opcnt, resp->cstate.slot->sl_cachethis);
1276
1277         /* Encode the replayed sequence operation */
1278         op = &args->ops[resp->opcnt - 1];
1279         nfsd4_encode_operation(resp, op);
1280
1281         /* Return nfserr_retry_uncached_rep in next operation. */
1282         if (args->opcnt > 1 && slot->sl_cachethis == 0) {
1283                 op = &args->ops[resp->opcnt++];
1284                 op->status = nfserr_retry_uncached_rep;
1285                 nfsd4_encode_operation(resp, op);
1286         }
1287         return op->status;
1288 }
1289
1290 /*
1291  * The sequence operation is not cached because we can use the slot and
1292  * session values.
1293  */
1294 __be32
1295 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1296                          struct nfsd4_sequence *seq)
1297 {
1298         struct nfsd4_slot *slot = resp->cstate.slot;
1299         __be32 status;
1300
1301         dprintk("--> %s slot %p\n", __func__, slot);
1302
1303         /* Either returns 0 or nfserr_retry_uncached */
1304         status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1305         if (status == nfserr_retry_uncached_rep)
1306                 return status;
1307
1308         /* The sequence operation has been encoded, cstate->datap set. */
1309         memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
1310
1311         resp->opcnt = slot->sl_opcnt;
1312         resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1313         status = slot->sl_status;
1314
1315         return status;
1316 }
1317
1318 /*
1319  * Set the exchange_id flags returned by the server.
1320  */
1321 static void
1322 nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1323 {
1324         /* pNFS is not supported */
1325         new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1326
1327         /* Referrals are supported, Migration is not. */
1328         new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1329
1330         /* set the wire flags to return to client. */
1331         clid->flags = new->cl_exchange_flags;
1332 }
1333
1334 __be32
1335 nfsd4_exchange_id(struct svc_rqst *rqstp,
1336                   struct nfsd4_compound_state *cstate,
1337                   struct nfsd4_exchange_id *exid)
1338 {
1339         struct nfs4_client *unconf, *conf, *new;
1340         int status;
1341         unsigned int            strhashval;
1342         char                    dname[HEXDIR_LEN];
1343         char                    addr_str[INET6_ADDRSTRLEN];
1344         nfs4_verifier           verf = exid->verifier;
1345         struct sockaddr         *sa = svc_addr(rqstp);
1346
1347         rpc_ntop(sa, addr_str, sizeof(addr_str));
1348         dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1349                 "ip_addr=%s flags %x, spa_how %d\n",
1350                 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
1351                 addr_str, exid->flags, exid->spa_how);
1352
1353         if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1354                 return nfserr_inval;
1355
1356         /* Currently only support SP4_NONE */
1357         switch (exid->spa_how) {
1358         case SP4_NONE:
1359                 break;
1360         case SP4_SSV:
1361                 return nfserr_serverfault;
1362         default:
1363                 BUG();                          /* checked by xdr code */
1364         case SP4_MACH_CRED:
1365                 return nfserr_serverfault;      /* no excuse :-/ */
1366         }
1367
1368         status = nfs4_make_rec_clidname(dname, &exid->clname);
1369
1370         if (status)
1371                 goto error;
1372
1373         strhashval = clientstr_hashval(dname);
1374
1375         nfs4_lock_state();
1376         status = nfs_ok;
1377
1378         conf = find_confirmed_client_by_str(dname, strhashval);
1379         if (conf) {
1380                 if (!clp_used_exchangeid(conf)) {
1381                         status = nfserr_clid_inuse; /* XXX: ? */
1382                         goto out;
1383                 }
1384                 if (!same_verf(&verf, &conf->cl_verifier)) {
1385                         /* 18.35.4 case 8 */
1386                         if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1387                                 status = nfserr_not_same;
1388                                 goto out;
1389                         }
1390                         /* Client reboot: destroy old state */
1391                         expire_client(conf);
1392                         goto out_new;
1393                 }
1394                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1395                         /* 18.35.4 case 9 */
1396                         if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1397                                 status = nfserr_perm;
1398                                 goto out;
1399                         }
1400                         expire_client(conf);
1401                         goto out_new;
1402                 }
1403                 /*
1404                  * Set bit when the owner id and verifier map to an already
1405                  * confirmed client id (18.35.3).
1406                  */
1407                 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1408
1409                 /*
1410                  * Falling into 18.35.4 case 2, possible router replay.
1411                  * Leave confirmed record intact and return same result.
1412                  */
1413                 copy_verf(conf, &verf);
1414                 new = conf;
1415                 goto out_copy;
1416         }
1417
1418         /* 18.35.4 case 7 */
1419         if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1420                 status = nfserr_noent;
1421                 goto out;
1422         }
1423
1424         unconf  = find_unconfirmed_client_by_str(dname, strhashval);
1425         if (unconf) {
1426                 /*
1427                  * Possible retry or client restart.  Per 18.35.4 case 4,
1428                  * a new unconfirmed record should be generated regardless
1429                  * of whether any properties have changed.
1430                  */
1431                 expire_client(unconf);
1432         }
1433
1434 out_new:
1435         /* Normal case */
1436         new = create_client(exid->clname, dname, rqstp, &verf);
1437         if (new == NULL) {
1438                 status = nfserr_jukebox;
1439                 goto out;
1440         }
1441
1442         gen_clid(new);
1443         add_to_unconfirmed(new, strhashval);
1444 out_copy:
1445         exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1446         exid->clientid.cl_id = new->cl_clientid.cl_id;
1447
1448         exid->seqid = 1;
1449         nfsd4_set_ex_flags(new, exid);
1450
1451         dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1452                 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
1453         status = nfs_ok;
1454
1455 out:
1456         nfs4_unlock_state();
1457 error:
1458         dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1459         return status;
1460 }
1461
1462 static int
1463 check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
1464 {
1465         dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1466                 slot_seqid);
1467
1468         /* The slot is in use, and no response has been sent. */
1469         if (slot_inuse) {
1470                 if (seqid == slot_seqid)
1471                         return nfserr_jukebox;
1472                 else
1473                         return nfserr_seq_misordered;
1474         }
1475         /* Normal */
1476         if (likely(seqid == slot_seqid + 1))
1477                 return nfs_ok;
1478         /* Replay */
1479         if (seqid == slot_seqid)
1480                 return nfserr_replay_cache;
1481         /* Wraparound */
1482         if (seqid == 1 && (slot_seqid + 1) == 0)
1483                 return nfs_ok;
1484         /* Misordered replay or misordered new request */
1485         return nfserr_seq_misordered;
1486 }
1487
1488 /*
1489  * Cache the create session result into the create session single DRC
1490  * slot cache by saving the xdr structure. sl_seqid has been set.
1491  * Do this for solo or embedded create session operations.
1492  */
1493 static void
1494 nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1495                            struct nfsd4_clid_slot *slot, int nfserr)
1496 {
1497         slot->sl_status = nfserr;
1498         memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1499 }
1500
1501 static __be32
1502 nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1503                             struct nfsd4_clid_slot *slot)
1504 {
1505         memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1506         return slot->sl_status;
1507 }
1508
1509 __be32
1510 nfsd4_create_session(struct svc_rqst *rqstp,
1511                      struct nfsd4_compound_state *cstate,
1512                      struct nfsd4_create_session *cr_ses)
1513 {
1514         struct sockaddr *sa = svc_addr(rqstp);
1515         struct nfs4_client *conf, *unconf;
1516         struct nfsd4_session *new;
1517         struct nfsd4_clid_slot *cs_slot = NULL;
1518         bool confirm_me = false;
1519         int status = 0;
1520
1521         nfs4_lock_state();
1522         unconf = find_unconfirmed_client(&cr_ses->clientid);
1523         conf = find_confirmed_client(&cr_ses->clientid);
1524
1525         if (conf) {
1526                 cs_slot = &conf->cl_cs_slot;
1527                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1528                 if (status == nfserr_replay_cache) {
1529                         dprintk("Got a create_session replay! seqid= %d\n",
1530                                 cs_slot->sl_seqid);
1531                         /* Return the cached reply status */
1532                         status = nfsd4_replay_create_session(cr_ses, cs_slot);
1533                         goto out;
1534                 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
1535                         status = nfserr_seq_misordered;
1536                         dprintk("Sequence misordered!\n");
1537                         dprintk("Expected seqid= %d but got seqid= %d\n",
1538                                 cs_slot->sl_seqid, cr_ses->seqid);
1539                         goto out;
1540                 }
1541         } else if (unconf) {
1542                 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
1543                     !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
1544                         status = nfserr_clid_inuse;
1545                         goto out;
1546                 }
1547
1548                 cs_slot = &unconf->cl_cs_slot;
1549                 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1550                 if (status) {
1551                         /* an unconfirmed replay returns misordered */
1552                         status = nfserr_seq_misordered;
1553                         goto out;
1554                 }
1555
1556                 confirm_me = true;
1557                 conf = unconf;
1558         } else {
1559                 status = nfserr_stale_clientid;
1560                 goto out;
1561         }
1562
1563         /*
1564          * XXX: we should probably set this at creation time, and check
1565          * for consistent minorversion use throughout:
1566          */
1567         conf->cl_minorversion = 1;
1568         /*
1569          * We do not support RDMA or persistent sessions
1570          */
1571         cr_ses->flags &= ~SESSION4_PERSIST;
1572         cr_ses->flags &= ~SESSION4_RDMA;
1573
1574         status = nfserr_jukebox;
1575         new = alloc_init_session(rqstp, conf, cr_ses);
1576         if (!new)
1577                 goto out;
1578         status = nfs_ok;
1579         memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
1580                NFS4_MAX_SESSIONID_LEN);
1581         memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1582                 sizeof(struct nfsd4_channel_attrs));
1583         cs_slot->sl_seqid++;
1584         cr_ses->seqid = cs_slot->sl_seqid;
1585
1586         /* cache solo and embedded create sessions under the state lock */
1587         nfsd4_cache_create_session(cr_ses, cs_slot, status);
1588         if (confirm_me)
1589                 move_to_confirmed(conf);
1590 out:
1591         nfs4_unlock_state();
1592         dprintk("%s returns %d\n", __func__, ntohl(status));
1593         return status;
1594 }
1595
1596 static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1597 {
1598         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1599         struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1600
1601         return argp->opcnt == resp->opcnt;
1602 }
1603
1604 static __be32 nfsd4_map_bcts_dir(u32 *dir)
1605 {
1606         switch (*dir) {
1607         case NFS4_CDFC4_FORE:
1608         case NFS4_CDFC4_BACK:
1609                 return nfs_ok;
1610         case NFS4_CDFC4_FORE_OR_BOTH:
1611         case NFS4_CDFC4_BACK_OR_BOTH:
1612                 *dir = NFS4_CDFC4_BOTH;
1613                 return nfs_ok;
1614         };
1615         return nfserr_inval;
1616 }
1617
1618 __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1619                      struct nfsd4_compound_state *cstate,
1620                      struct nfsd4_bind_conn_to_session *bcts)
1621 {
1622         __be32 status;
1623
1624         if (!nfsd4_last_compound_op(rqstp))
1625                 return nfserr_not_only_op;
1626         spin_lock(&client_lock);
1627         cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1628         /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1629          * client_lock iself: */
1630         if (cstate->session) {
1631                 nfsd4_get_session(cstate->session);
1632                 atomic_inc(&cstate->session->se_client->cl_refcount);
1633         }
1634         spin_unlock(&client_lock);
1635         if (!cstate->session)
1636                 return nfserr_badsession;
1637
1638         status = nfsd4_map_bcts_dir(&bcts->dir);
1639         nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1640         return nfs_ok;
1641 }
1642
1643 static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1644 {
1645         if (!session)
1646                 return 0;
1647         return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1648 }
1649
1650 __be32
1651 nfsd4_destroy_session(struct svc_rqst *r,
1652                       struct nfsd4_compound_state *cstate,
1653                       struct nfsd4_destroy_session *sessionid)
1654 {
1655         struct nfsd4_session *ses;
1656         u32 status = nfserr_badsession;
1657
1658         /* Notes:
1659          * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1660          * - Should we return nfserr_back_chan_busy if waiting for
1661          *   callbacks on to-be-destroyed session?
1662          * - Do we need to clear any callback info from previous session?
1663          */
1664
1665         if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
1666                 if (!nfsd4_last_compound_op(r))
1667                         return nfserr_not_only_op;
1668         }
1669         dump_sessionid(__func__, &sessionid->sessionid);
1670         spin_lock(&client_lock);
1671         ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1672         if (!ses) {
1673                 spin_unlock(&client_lock);
1674                 goto out;
1675         }
1676
1677         unhash_session(ses);
1678         spin_unlock(&client_lock);
1679
1680         nfs4_lock_state();
1681         nfsd4_probe_callback_sync(ses->se_client);
1682         nfs4_unlock_state();
1683
1684         nfsd4_del_conns(ses);
1685
1686         nfsd4_put_session(ses);
1687         status = nfs_ok;
1688 out:
1689         dprintk("%s returns %d\n", __func__, ntohl(status));
1690         return status;
1691 }
1692
1693 static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
1694 {
1695         struct nfsd4_conn *c;
1696
1697         list_for_each_entry(c, &s->se_conns, cn_persession) {
1698                 if (c->cn_xprt == xpt) {
1699                         return c;
1700                 }
1701         }
1702         return NULL;
1703 }
1704
1705 static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
1706 {
1707         struct nfs4_client *clp = ses->se_client;
1708         struct nfsd4_conn *c;
1709         int ret;
1710
1711         spin_lock(&clp->cl_lock);
1712         c = __nfsd4_find_conn(new->cn_xprt, ses);
1713         if (c) {
1714                 spin_unlock(&clp->cl_lock);
1715                 free_conn(new);
1716                 return;
1717         }
1718         __nfsd4_hash_conn(new, ses);
1719         spin_unlock(&clp->cl_lock);
1720         ret = nfsd4_register_conn(new);
1721         if (ret)
1722                 /* oops; xprt is already down: */
1723                 nfsd4_conn_lost(&new->cn_xpt_user);
1724         return;
1725 }
1726
1727 __be32
1728 nfsd4_sequence(struct svc_rqst *rqstp,
1729                struct nfsd4_compound_state *cstate,
1730                struct nfsd4_sequence *seq)
1731 {
1732         struct nfsd4_compoundres *resp = rqstp->rq_resp;
1733         struct nfsd4_session *session;
1734         struct nfsd4_slot *slot;
1735         struct nfsd4_conn *conn;
1736         int status;
1737
1738         if (resp->opcnt != 1)
1739                 return nfserr_sequence_pos;
1740
1741         /*
1742          * Will be either used or freed by nfsd4_sequence_check_conn
1743          * below.
1744          */
1745         conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1746         if (!conn)
1747                 return nfserr_jukebox;
1748
1749         spin_lock(&client_lock);
1750         status = nfserr_badsession;
1751         session = find_in_sessionid_hashtbl(&seq->sessionid);
1752         if (!session)
1753                 goto out;
1754
1755         status = nfserr_badslot;
1756         if (seq->slotid >= session->se_fchannel.maxreqs)
1757                 goto out;
1758
1759         slot = session->se_slots[seq->slotid];
1760         dprintk("%s: slotid %d\n", __func__, seq->slotid);
1761
1762         /* We do not negotiate the number of slots yet, so set the
1763          * maxslots to the session maxreqs which is used to encode
1764          * sr_highest_slotid and the sr_target_slot id to maxslots */
1765         seq->maxslots = session->se_fchannel.maxreqs;
1766
1767         status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
1768         if (status == nfserr_replay_cache) {
1769                 cstate->slot = slot;
1770                 cstate->session = session;
1771                 /* Return the cached reply status and set cstate->status
1772                  * for nfsd4_proc_compound processing */
1773                 status = nfsd4_replay_cache_entry(resp, seq);
1774                 cstate->status = nfserr_replay_cache;
1775                 goto out;
1776         }
1777         if (status)
1778                 goto out;
1779
1780         nfsd4_sequence_check_conn(conn, session);
1781         conn = NULL;
1782
1783         /* Success! bump slot seqid */
1784         slot->sl_inuse = true;
1785         slot->sl_seqid = seq->seqid;
1786         slot->sl_cachethis = seq->cachethis;
1787
1788         cstate->slot = slot;
1789         cstate->session = session;
1790
1791 out:
1792         /* Hold a session reference until done processing the compound. */
1793         if (cstate->session) {
1794                 struct nfs4_client *clp = session->se_client;
1795
1796                 nfsd4_get_session(cstate->session);
1797                 atomic_inc(&clp->cl_refcount);
1798                 if (clp->cl_cb_state == NFSD4_CB_DOWN)
1799                         seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN;
1800         }
1801         kfree(conn);
1802         spin_unlock(&client_lock);
1803         dprintk("%s: return %d\n", __func__, ntohl(status));
1804         return status;
1805 }
1806
1807 __be32
1808 nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1809 {
1810         if (rc->rca_one_fs) {
1811                 if (!cstate->current_fh.fh_dentry)
1812                         return nfserr_nofilehandle;
1813                 /*
1814                  * We don't take advantage of the rca_one_fs case.
1815                  * That's OK, it's optional, we can safely ignore it.
1816                  */
1817                  return nfs_ok;
1818         }
1819         nfs4_lock_state();
1820         if (is_client_expired(cstate->session->se_client)) {
1821                 nfs4_unlock_state();
1822                 /*
1823                  * The following error isn't really legal.
1824                  * But we only get here if the client just explicitly
1825                  * destroyed the client.  Surely it no longer cares what
1826                  * error it gets back on an operation for the dead
1827                  * client.
1828                  */
1829                 return nfserr_stale_clientid;
1830         }
1831         nfsd4_create_clid_dir(cstate->session->se_client);
1832         nfs4_unlock_state();
1833         return nfs_ok;
1834 }
1835
1836 __be32
1837 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1838                   struct nfsd4_setclientid *setclid)
1839 {
1840         struct xdr_netobj       clname = { 
1841                 .len = setclid->se_namelen,
1842                 .data = setclid->se_name,
1843         };
1844         nfs4_verifier           clverifier = setclid->se_verf;
1845         unsigned int            strhashval;
1846         struct nfs4_client      *conf, *unconf, *new;
1847         __be32                  status;
1848         char                    dname[HEXDIR_LEN];
1849         
1850         if (!check_name(clname))
1851                 return nfserr_inval;
1852
1853         status = nfs4_make_rec_clidname(dname, &clname);
1854         if (status)
1855                 return status;
1856
1857         /* 
1858          * XXX The Duplicate Request Cache (DRC) has been checked (??)
1859          * We get here on a DRC miss.
1860          */
1861
1862         strhashval = clientstr_hashval(dname);
1863
1864         nfs4_lock_state();
1865         conf = find_confirmed_client_by_str(dname, strhashval);
1866         if (conf) {
1867                 /* RFC 3530 14.2.33 CASE 0: */
1868                 status = nfserr_clid_inuse;
1869                 if (clp_used_exchangeid(conf))
1870                         goto out;
1871                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1872                         char addr_str[INET6_ADDRSTRLEN];
1873                         rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1874                                  sizeof(addr_str));
1875                         dprintk("NFSD: setclientid: string in use by client "
1876                                 "at %s\n", addr_str);
1877                         goto out;
1878                 }
1879         }
1880         /*
1881          * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1882          * has a description of SETCLIENTID request processing consisting
1883          * of 5 bullet points, labeled as CASE0 - CASE4 below.
1884          */
1885         unconf = find_unconfirmed_client_by_str(dname, strhashval);
1886         status = nfserr_resource;
1887         if (!conf) {
1888                 /*
1889                  * RFC 3530 14.2.33 CASE 4:
1890                  * placed first, because it is the normal case
1891                  */
1892                 if (unconf)
1893                         expire_client(unconf);
1894                 new = create_client(clname, dname, rqstp, &clverifier);
1895                 if (new == NULL)
1896                         goto out;
1897                 gen_clid(new);
1898         } else if (same_verf(&conf->cl_verifier, &clverifier)) {
1899                 /*
1900                  * RFC 3530 14.2.33 CASE 1:
1901                  * probable callback update
1902                  */
1903                 if (unconf) {
1904                         /* Note this is removing unconfirmed {*x***},
1905                          * which is stronger than RFC recommended {vxc**}.
1906                          * This has the advantage that there is at most
1907                          * one {*x***} in either list at any time.
1908                          */
1909                         expire_client(unconf);
1910                 }
1911                 new = create_client(clname, dname, rqstp, &clverifier);
1912                 if (new == NULL)
1913                         goto out;
1914                 copy_clid(new, conf);
1915         } else if (!unconf) {
1916                 /*
1917                  * RFC 3530 14.2.33 CASE 2:
1918                  * probable client reboot; state will be removed if
1919                  * confirmed.
1920                  */
1921                 new = create_client(clname, dname, rqstp, &clverifier);
1922                 if (new == NULL)
1923                         goto out;
1924                 gen_clid(new);
1925         } else {
1926                 /*
1927                  * RFC 3530 14.2.33 CASE 3:
1928                  * probable client reboot; state will be removed if
1929                  * confirmed.
1930                  */
1931                 expire_client(unconf);
1932                 new = create_client(clname, dname, rqstp, &clverifier);
1933                 if (new == NULL)
1934                         goto out;
1935                 gen_clid(new);
1936         }
1937         /*
1938          * XXX: we should probably set this at creation time, and check
1939          * for consistent minorversion use throughout:
1940          */
1941         new->cl_minorversion = 0;
1942         gen_callback(new, setclid, rqstp);
1943         add_to_unconfirmed(new, strhashval);
1944         setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
1945         setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
1946         memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
1947         status = nfs_ok;
1948 out:
1949         nfs4_unlock_state();
1950         return status;
1951 }
1952
1953
1954 /*
1955  * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
1956  * a description of SETCLIENTID_CONFIRM request processing consisting of 4
1957  * bullets, labeled as CASE1 - CASE4 below.
1958  */
1959 __be32
1960 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
1961                          struct nfsd4_compound_state *cstate,
1962                          struct nfsd4_setclientid_confirm *setclientid_confirm)
1963 {
1964         struct sockaddr *sa = svc_addr(rqstp);
1965         struct nfs4_client *conf, *unconf;
1966         nfs4_verifier confirm = setclientid_confirm->sc_confirm; 
1967         clientid_t * clid = &setclientid_confirm->sc_clientid;
1968         __be32 status;
1969
1970         if (STALE_CLIENTID(clid))
1971                 return nfserr_stale_clientid;
1972         /* 
1973          * XXX The Duplicate Request Cache (DRC) has been checked (??)
1974          * We get here on a DRC miss.
1975          */
1976
1977         nfs4_lock_state();
1978
1979         conf = find_confirmed_client(clid);
1980         unconf = find_unconfirmed_client(clid);
1981
1982         status = nfserr_clid_inuse;
1983         if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
1984                 goto out;
1985         if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
1986                 goto out;
1987
1988         /*
1989          * section 14.2.34 of RFC 3530 has a description of
1990          * SETCLIENTID_CONFIRM request processing consisting
1991          * of 4 bullet points, labeled as CASE1 - CASE4 below.
1992          */
1993         if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
1994                 /*
1995                  * RFC 3530 14.2.34 CASE 1:
1996                  * callback update
1997                  */
1998                 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
1999                         status = nfserr_clid_inuse;
2000                 else {
2001                         nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2002                         nfsd4_probe_callback(conf);
2003                         expire_client(unconf);
2004                         status = nfs_ok;
2005
2006                 }
2007         } else if (conf && !unconf) {
2008                 /*
2009                  * RFC 3530 14.2.34 CASE 2:
2010                  * probable retransmitted request; play it safe and
2011                  * do nothing.
2012                  */
2013                 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
2014                         status = nfserr_clid_inuse;
2015                 else
2016                         status = nfs_ok;
2017         } else if (!conf && unconf
2018                         && same_verf(&unconf->cl_confirm, &confirm)) {
2019                 /*
2020                  * RFC 3530 14.2.34 CASE 3:
2021                  * Normal case; new or rebooted client:
2022                  */
2023                 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
2024                         status = nfserr_clid_inuse;
2025                 } else {
2026                         unsigned int hash =
2027                                 clientstr_hashval(unconf->cl_recdir);
2028                         conf = find_confirmed_client_by_str(unconf->cl_recdir,
2029                                                             hash);
2030                         if (conf) {
2031                                 nfsd4_remove_clid_dir(conf);
2032                                 expire_client(conf);
2033                         }
2034                         move_to_confirmed(unconf);
2035                         conf = unconf;
2036                         nfsd4_probe_callback(conf);
2037                         status = nfs_ok;
2038                 }
2039         } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
2040             && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
2041                                                                 &confirm)))) {
2042                 /*
2043                  * RFC 3530 14.2.34 CASE 4:
2044                  * Client probably hasn't noticed that we rebooted yet.
2045                  */
2046                 status = nfserr_stale_clientid;
2047         } else {
2048                 /* check that we have hit one of the cases...*/
2049                 status = nfserr_clid_inuse;
2050         }
2051 out:
2052         nfs4_unlock_state();
2053         return status;
2054 }
2055
2056 /* OPEN Share state helper functions */
2057 static inline struct nfs4_file *
2058 alloc_init_file(struct inode *ino)
2059 {
2060         struct nfs4_file *fp;
2061         unsigned int hashval = file_hashval(ino);
2062
2063         fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
2064         if (fp) {
2065                 atomic_set(&fp->fi_ref, 1);
2066                 INIT_LIST_HEAD(&fp->fi_hash);
2067                 INIT_LIST_HEAD(&fp->fi_stateids);
2068                 INIT_LIST_HEAD(&fp->fi_delegations);
2069                 fp->fi_inode = igrab(ino);
2070                 fp->fi_id = current_fileid++;
2071                 fp->fi_had_conflict = false;
2072                 fp->fi_lease = NULL;
2073                 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2074                 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2075                 spin_lock(&recall_lock);
2076                 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2077                 spin_unlock(&recall_lock);
2078                 return fp;
2079         }
2080         return NULL;
2081 }
2082
2083 static void
2084 nfsd4_free_slab(struct kmem_cache **slab)
2085 {
2086         if (*slab == NULL)
2087                 return;
2088         kmem_cache_destroy(*slab);
2089         *slab = NULL;
2090 }
2091
2092 void
2093 nfsd4_free_slabs(void)
2094 {
2095         nfsd4_free_slab(&stateowner_slab);
2096         nfsd4_free_slab(&file_slab);
2097         nfsd4_free_slab(&stateid_slab);
2098         nfsd4_free_slab(&deleg_slab);
2099 }
2100
2101 static int
2102 nfsd4_init_slabs(void)
2103 {
2104         stateowner_slab = kmem_cache_create("nfsd4_stateowners",
2105                         sizeof(struct nfs4_stateowner), 0, 0, NULL);
2106         if (stateowner_slab == NULL)
2107                 goto out_nomem;
2108         file_slab = kmem_cache_create("nfsd4_files",
2109                         sizeof(struct nfs4_file), 0, 0, NULL);
2110         if (file_slab == NULL)
2111                 goto out_nomem;
2112         stateid_slab = kmem_cache_create("nfsd4_stateids",
2113                         sizeof(struct nfs4_stateid), 0, 0, NULL);
2114         if (stateid_slab == NULL)
2115                 goto out_nomem;
2116         deleg_slab = kmem_cache_create("nfsd4_delegations",
2117                         sizeof(struct nfs4_delegation), 0, 0, NULL);
2118         if (deleg_slab == NULL)
2119                 goto out_nomem;
2120         return 0;
2121 out_nomem:
2122         nfsd4_free_slabs();
2123         dprintk("nfsd4: out of memory while initializing nfsv4\n");
2124         return -ENOMEM;
2125 }
2126
2127 void
2128 nfs4_free_stateowner(struct kref *kref)
2129 {
2130         struct nfs4_stateowner *sop =
2131                 container_of(kref, struct nfs4_stateowner, so_ref);
2132         kfree(sop->so_owner.data);
2133         kmem_cache_free(stateowner_slab, sop);
2134 }
2135
2136 static inline struct nfs4_stateowner *
2137 alloc_stateowner(struct xdr_netobj *owner)
2138 {
2139         struct nfs4_stateowner *sop;
2140
2141         if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
2142                 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
2143                         memcpy(sop->so_owner.data, owner->data, owner->len);
2144                         sop->so_owner.len = owner->len;
2145                         kref_init(&sop->so_ref);
2146                         return sop;
2147                 } 
2148                 kmem_cache_free(stateowner_slab, sop);
2149         }
2150         return NULL;
2151 }
2152
2153 static struct nfs4_stateowner *
2154 alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2155         struct nfs4_stateowner *sop;
2156         struct nfs4_replay *rp;
2157         unsigned int idhashval;
2158
2159         if (!(sop = alloc_stateowner(&open->op_owner)))
2160                 return NULL;
2161         idhashval = ownerid_hashval(current_ownerid);
2162         INIT_LIST_HEAD(&sop->so_idhash);
2163         INIT_LIST_HEAD(&sop->so_strhash);
2164         INIT_LIST_HEAD(&sop->so_perclient);
2165         INIT_LIST_HEAD(&sop->so_stateids);
2166         INIT_LIST_HEAD(&sop->so_perstateid);  /* not used */
2167         INIT_LIST_HEAD(&sop->so_close_lru);
2168         sop->so_time = 0;
2169         list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
2170         list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
2171         list_add(&sop->so_perclient, &clp->cl_openowners);
2172         sop->so_is_open_owner = 1;
2173         sop->so_id = current_ownerid++;
2174         sop->so_client = clp;
2175         sop->so_seqid = open->op_seqid;
2176         sop->so_confirmed = 0;
2177         rp = &sop->so_replay;
2178         rp->rp_status = nfserr_serverfault;
2179         rp->rp_buflen = 0;
2180         rp->rp_buf = rp->rp_ibuf;
2181         return sop;
2182 }
2183
2184 static inline void
2185 init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2186         struct nfs4_stateowner *sop = open->op_stateowner;
2187         unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
2188
2189         INIT_LIST_HEAD(&stp->st_hash);
2190         INIT_LIST_HEAD(&stp->st_perstateowner);
2191         INIT_LIST_HEAD(&stp->st_lockowners);
2192         INIT_LIST_HEAD(&stp->st_perfile);
2193         list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
2194         list_add(&stp->st_perstateowner, &sop->so_stateids);
2195         list_add(&stp->st_perfile, &fp->fi_stateids);
2196         stp->st_stateowner = sop;
2197         get_nfs4_file(fp);
2198         stp->st_file = fp;
2199         stp->st_stateid.si_boot = boot_time;
2200         stp->st_stateid.si_stateownerid = sop->so_id;
2201         stp->st_stateid.si_fileid = fp->fi_id;
2202         stp->st_stateid.si_generation = 0;
2203         stp->st_access_bmap = 0;
2204         stp->st_deny_bmap = 0;
2205         __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
2206                   &stp->st_access_bmap);
2207         __set_bit(open->op_share_deny, &stp->st_deny_bmap);
2208         stp->st_openstp = NULL;
2209 }
2210
2211 static void
2212 move_to_close_lru(struct nfs4_stateowner *sop)
2213 {
2214         dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
2215
2216         list_move_tail(&sop->so_close_lru, &close_lru);
2217         sop->so_time = get_seconds();
2218 }
2219
2220 static int
2221 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2222                                                         clientid_t *clid)
2223 {
2224         return (sop->so_owner.len == owner->len) &&
2225                 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2226                 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
2227 }
2228
2229 static struct nfs4_stateowner *
2230 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2231 {
2232         struct nfs4_stateowner *so = NULL;
2233
2234         list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
2235                 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
2236                         return so;
2237         }
2238         return NULL;
2239 }
2240
2241 /* search file_hashtbl[] for file */
2242 static struct nfs4_file *
2243 find_file(struct inode *ino)
2244 {
2245         unsigned int hashval = file_hashval(ino);
2246         struct nfs4_file *fp;
2247
2248         spin_lock(&recall_lock);
2249         list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2250                 if (fp->fi_inode == ino) {
2251                         get_nfs4_file(fp);
2252                         spin_unlock(&recall_lock);
2253                         return fp;
2254                 }
2255         }
2256         spin_unlock(&recall_lock);
2257         return NULL;
2258 }
2259
2260 static inline int access_valid(u32 x, u32 minorversion)
2261 {
2262         if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
2263                 return 0;
2264         if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
2265                 return 0;
2266         x &= ~NFS4_SHARE_ACCESS_MASK;
2267         if (minorversion && x) {
2268                 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
2269                         return 0;
2270                 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
2271                         return 0;
2272                 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
2273         }
2274         if (x)
2275                 return 0;
2276         return 1;
2277 }
2278
2279 static inline int deny_valid(u32 x)
2280 {
2281         /* Note: unlike access bits, deny bits may be zero. */
2282         return x <= NFS4_SHARE_DENY_BOTH;
2283 }
2284
2285 /*
2286  * Called to check deny when READ with all zero stateid or
2287  * WRITE with all zero or all one stateid
2288  */
2289 static __be32
2290 nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2291 {
2292         struct inode *ino = current_fh->fh_dentry->d_inode;
2293         struct nfs4_file *fp;
2294         struct nfs4_stateid *stp;
2295         __be32 ret;
2296
2297         dprintk("NFSD: nfs4_share_conflict\n");
2298
2299         fp = find_file(ino);
2300         if (!fp)
2301                 return nfs_ok;
2302         ret = nfserr_locked;
2303         /* Search for conflicting share reservations */
2304         list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2305                 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2306                     test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2307                         goto out;
2308         }
2309         ret = nfs_ok;
2310 out:
2311         put_nfs4_file(fp);
2312         return ret;
2313 }
2314
2315 static inline void
2316 nfs4_file_downgrade(struct nfs4_file *fp, unsigned int share_access)
2317 {
2318         if (share_access & NFS4_SHARE_ACCESS_WRITE)
2319                 nfs4_file_put_access(fp, O_WRONLY);
2320         if (share_access & NFS4_SHARE_ACCESS_READ)
2321                 nfs4_file_put_access(fp, O_RDONLY);
2322 }
2323
2324 static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
2325 {
2326         /* We're assuming the state code never drops its reference
2327          * without first removing the lease.  Since we're in this lease
2328          * callback (and since the lease code is serialized by the kernel
2329          * lock) we know the server hasn't removed the lease yet, we know
2330          * it's safe to take a reference: */
2331         atomic_inc(&dp->dl_count);
2332
2333         list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2334
2335         /* only place dl_time is set. protected by lock_flocks*/
2336         dp->dl_time = get_seconds();
2337
2338         nfsd4_cb_recall(dp);
2339 }
2340
2341 /* Called from break_lease() with lock_flocks() held. */
2342 static void nfsd_break_deleg_cb(struct file_lock *fl)
2343 {
2344         struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2345         struct nfs4_delegation *dp;
2346
2347         BUG_ON(!fp);
2348         /* We assume break_lease is only called once per lease: */
2349         BUG_ON(fp->fi_had_conflict);
2350         /*
2351          * We don't want the locks code to timeout the lease for us;
2352          * we'll remove it ourself if a delegation isn't returned
2353          * in time:
2354          */
2355         fl->fl_break_time = 0;
2356
2357         spin_lock(&recall_lock);
2358         fp->fi_had_conflict = true;
2359         list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2360                 nfsd_break_one_deleg(dp);
2361         spin_unlock(&recall_lock);
2362 }
2363
2364 static
2365 int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2366 {
2367         if (arg & F_UNLCK)
2368                 return lease_modify(onlist, arg);
2369         else
2370                 return -EAGAIN;
2371 }
2372
2373 static const struct lock_manager_operations nfsd_lease_mng_ops = {
2374         .fl_break = nfsd_break_deleg_cb,
2375         .fl_change = nfsd_change_deleg_cb,
2376 };
2377
2378
2379 __be32
2380 nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2381                     struct nfsd4_open *open)
2382 {
2383         clientid_t *clientid = &open->op_clientid;
2384         struct nfs4_client *clp = NULL;
2385         unsigned int strhashval;
2386         struct nfs4_stateowner *sop = NULL;
2387
2388         if (!check_name(open->op_owner))
2389                 return nfserr_inval;
2390
2391         if (STALE_CLIENTID(&open->op_clientid))
2392                 return nfserr_stale_clientid;
2393
2394         strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2395         sop = find_openstateowner_str(strhashval, open);
2396         open->op_stateowner = sop;
2397         if (!sop) {
2398                 /* Make sure the client's lease hasn't expired. */
2399                 clp = find_confirmed_client(clientid);
2400                 if (clp == NULL)
2401                         return nfserr_expired;
2402                 goto renew;
2403         }
2404         /* When sessions are used, skip open sequenceid processing */
2405         if (nfsd4_has_session(cstate))
2406                 goto renew;
2407         if (!sop->so_confirmed) {
2408                 /* Replace unconfirmed owners without checking for replay. */
2409                 clp = sop->so_client;
2410                 release_openowner(sop);
2411                 open->op_stateowner = NULL;
2412                 goto renew;
2413         }
2414         if (open->op_seqid == sop->so_seqid - 1) {
2415                 if (sop->so_replay.rp_buflen)
2416                         return nfserr_replay_me;
2417                 /* The original OPEN failed so spectacularly
2418                  * that we don't even have replay data saved!
2419                  * Therefore, we have no choice but to continue
2420                  * processing this OPEN; presumably, we'll
2421                  * fail again for the same reason.
2422                  */
2423                 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2424                 goto renew;
2425         }
2426         if (open->op_seqid != sop->so_seqid)
2427                 return nfserr_bad_seqid;
2428 renew:
2429         if (open->op_stateowner == NULL) {
2430                 sop = alloc_init_open_stateowner(strhashval, clp, open);
2431                 if (sop == NULL)
2432                         return nfserr_resource;
2433                 open->op_stateowner = sop;
2434         }
2435         list_del_init(&sop->so_close_lru);
2436         renew_client(sop->so_client);
2437         return nfs_ok;
2438 }
2439
2440 static inline __be32
2441 nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2442 {
2443         if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2444                 return nfserr_openmode;
2445         else
2446                 return nfs_ok;
2447 }
2448
2449 static struct nfs4_delegation *
2450 find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2451 {
2452         struct nfs4_delegation *dp;
2453
2454         spin_lock(&recall_lock);
2455         list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2456                 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) {
2457                         spin_unlock(&recall_lock);
2458                         return dp;
2459                 }
2460         spin_unlock(&recall_lock);
2461         return NULL;
2462 }
2463
2464 int share_access_to_flags(u32 share_access)
2465 {
2466         share_access &= ~NFS4_SHARE_WANT_MASK;
2467
2468         return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2469 }
2470
2471 static __be32
2472 nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2473                 struct nfs4_delegation **dp)
2474 {
2475         int flags;
2476         __be32 status = nfserr_bad_stateid;
2477
2478         *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2479         if (*dp == NULL)
2480                 goto out;
2481         flags = share_access_to_flags(open->op_share_access);
2482         status = nfs4_check_delegmode(*dp, flags);
2483         if (status)
2484                 *dp = NULL;
2485 out:
2486         if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2487                 return nfs_ok;
2488         if (status)
2489                 return status;
2490         open->op_stateowner->so_confirmed = 1;
2491         return nfs_ok;
2492 }
2493
2494 static __be32
2495 nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2496 {
2497         struct nfs4_stateid *local;
2498         __be32 status = nfserr_share_denied;
2499         struct nfs4_stateowner *sop = open->op_stateowner;
2500
2501         list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
2502                 /* ignore lock owners */
2503                 if (local->st_stateowner->so_is_open_owner == 0)
2504                         continue;
2505                 /* remember if we have seen this open owner */
2506                 if (local->st_stateowner == sop)
2507                         *stpp = local;
2508                 /* check for conflicting share reservations */
2509                 if (!test_share(local, open))
2510                         goto out;
2511         }
2512         status = 0;
2513 out:
2514         return status;
2515 }
2516
2517 static inline struct nfs4_stateid *
2518 nfs4_alloc_stateid(void)
2519 {
2520         return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2521 }
2522
2523 static inline int nfs4_access_to_access(u32 nfs4_access)
2524 {
2525         int flags = 0;
2526
2527         if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2528                 flags |= NFSD_MAY_READ;
2529         if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2530                 flags |= NFSD_MAY_WRITE;
2531         return flags;
2532 }
2533
2534 static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file
2535 *fp, struct svc_fh *cur_fh, u32 nfs4_access)
2536 {
2537         __be32 status;
2538         int oflag = nfs4_access_to_omode(nfs4_access);
2539         int access = nfs4_access_to_access(nfs4_access);
2540
2541         if (!fp->fi_fds[oflag]) {
2542                 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2543                         &fp->fi_fds[oflag]);
2544                 if (status)
2545                         return status;
2546         }
2547         nfs4_file_get_access(fp, oflag);
2548
2549         return nfs_ok;
2550 }
2551
2552 static __be32
2553 nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
2554                 struct nfs4_file *fp, struct svc_fh *cur_fh,
2555                 struct nfsd4_open *open)
2556 {
2557         struct nfs4_stateid *stp;
2558         __be32 status;
2559
2560         stp = nfs4_alloc_stateid();
2561         if (stp == NULL)
2562                 return nfserr_resource;
2563
2564         status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open->op_share_access);
2565         if (status) {
2566                 kmem_cache_free(stateid_slab, stp);
2567                 return status;
2568         }
2569         *stpp = stp;
2570         return 0;
2571 }
2572
2573 static inline __be32
2574 nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2575                 struct nfsd4_open *open)
2576 {
2577         struct iattr iattr = {
2578                 .ia_valid = ATTR_SIZE,
2579                 .ia_size = 0,
2580         };
2581         if (!open->op_truncate)
2582                 return 0;
2583         if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
2584                 return nfserr_inval;
2585         return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2586 }
2587
2588 static __be32
2589 nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
2590 {
2591         u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
2592         bool new_access;
2593         __be32 status;
2594
2595         new_access = !test_bit(op_share_access, &stp->st_access_bmap);
2596         if (new_access) {
2597                 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, op_share_access);
2598                 if (status)
2599                         return status;
2600         }
2601         status = nfsd4_truncate(rqstp, cur_fh, open);
2602         if (status) {
2603                 if (new_access) {
2604                         int oflag = nfs4_access_to_omode(new_access);
2605                         nfs4_file_put_access(fp, oflag);
2606                 }
2607                 return status;
2608         }
2609         /* remember the open */
2610         __set_bit(op_share_access, &stp->st_access_bmap);
2611         __set_bit(open->op_share_deny, &stp->st_deny_bmap);
2612
2613         return nfs_ok;
2614 }
2615
2616
2617 static void
2618 nfs4_set_claim_prev(struct nfsd4_open *open)
2619 {
2620         open->op_stateowner->so_confirmed = 1;
2621         open->op_stateowner->so_client->cl_firststate = 1;
2622 }
2623
2624 /* Should we give out recallable state?: */
2625 static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2626 {
2627         if (clp->cl_cb_state == NFSD4_CB_UP)
2628                 return true;
2629         /*
2630          * In the sessions case, since we don't have to establish a
2631          * separate connection for callbacks, we assume it's OK
2632          * until we hear otherwise:
2633          */
2634         return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2635 }
2636
2637 static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2638 {
2639         struct file_lock *fl;
2640
2641         fl = locks_alloc_lock();
2642         if (!fl)
2643                 return NULL;
2644         locks_init_lock(fl);
2645         fl->fl_lmops = &nfsd_lease_mng_ops;
2646         fl->fl_flags = FL_LEASE;
2647         fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2648         fl->fl_end = OFFSET_MAX;
2649         fl->fl_owner = (fl_owner_t)(dp->dl_file);
2650         fl->fl_pid = current->tgid;
2651         return fl;
2652 }
2653
2654 static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2655 {
2656         struct nfs4_file *fp = dp->dl_file;
2657         struct file_lock *fl;
2658         int status;
2659
2660         fl = nfs4_alloc_init_lease(dp, flag);
2661         if (!fl)
2662                 return -ENOMEM;
2663         fl->fl_file = find_readable_file(fp);
2664         list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2665         status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
2666         if (status) {
2667                 list_del_init(&dp->dl_perclnt);
2668                 locks_free_lock(fl);
2669                 return -ENOMEM;
2670         }
2671         fp->fi_lease = fl;
2672         fp->fi_deleg_file = fl->fl_file;
2673         get_file(fp->fi_deleg_file);
2674         atomic_set(&fp->fi_delegees, 1);
2675         list_add(&dp->dl_perfile, &fp->fi_delegations);
2676         return 0;
2677 }
2678
2679 static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2680 {
2681         struct nfs4_file *fp = dp->dl_file;
2682
2683         if (!fp->fi_lease)
2684                 return nfs4_setlease(dp, flag);
2685         spin_lock(&recall_lock);
2686         if (fp->fi_had_conflict) {
2687                 spin_unlock(&recall_lock);
2688                 return -EAGAIN;
2689         }
2690         atomic_inc(&fp->fi_delegees);
2691         list_add(&dp->dl_perfile, &fp->fi_delegations);
2692         spin_unlock(&recall_lock);
2693         list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2694         return 0;
2695 }
2696
2697 /*
2698  * Attempt to hand out a delegation.
2699  */
2700 static void
2701 nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2702 {
2703         struct nfs4_delegation *dp;
2704         struct nfs4_stateowner *sop = stp->st_stateowner;
2705         int cb_up;
2706         int status, flag = 0;
2707
2708         cb_up = nfsd4_cb_channel_good(sop->so_client);
2709         flag = NFS4_OPEN_DELEGATE_NONE;
2710         open->op_recall = 0;
2711         switch (open->op_claim_type) {
2712                 case NFS4_OPEN_CLAIM_PREVIOUS:
2713                         if (!cb_up)
2714                                 open->op_recall = 1;
2715                         flag = open->op_delegate_type;
2716                         if (flag == NFS4_OPEN_DELEGATE_NONE)
2717                                 goto out;
2718                         break;
2719                 case NFS4_OPEN_CLAIM_NULL:
2720                         /* Let's not give out any delegations till everyone's
2721                          * had the chance to reclaim theirs.... */
2722                         if (locks_in_grace())
2723                                 goto out;
2724                         if (!cb_up || !sop->so_confirmed)
2725                                 goto out;
2726                         if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2727                                 flag = NFS4_OPEN_DELEGATE_WRITE;
2728                         else
2729                                 flag = NFS4_OPEN_DELEGATE_READ;
2730                         break;
2731                 default:
2732                         goto out;
2733         }
2734
2735         dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
2736         if (dp == NULL)
2737                 goto out_no_deleg;
2738         status = nfs4_set_delegation(dp, flag);
2739         if (status)
2740                 goto out_free;
2741
2742         memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2743
2744         dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2745                 STATEID_VAL(&dp->dl_stateid));
2746 out:
2747         if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2748                         && flag == NFS4_OPEN_DELEGATE_NONE
2749                         && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2750                 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2751         open->op_delegate_type = flag;
2752         return;
2753 out_free:
2754         nfs4_put_delegation(dp);
2755 out_no_deleg:
2756         flag = NFS4_OPEN_DELEGATE_NONE;
2757         goto out;
2758 }
2759
2760 /*
2761  * called with nfs4_lock_state() held.
2762  */
2763 __be32
2764 nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2765 {
2766         struct nfsd4_compoundres *resp = rqstp->rq_resp;
2767         struct nfs4_file *fp = NULL;
2768         struct inode *ino = current_fh->fh_dentry->d_inode;
2769         struct nfs4_stateid *stp = NULL;
2770         struct nfs4_delegation *dp = NULL;
2771         __be32 status;
2772
2773         status = nfserr_inval;
2774         if (!access_valid(open->op_share_access, resp->cstate.minorversion)
2775                         || !deny_valid(open->op_share_deny))
2776                 goto out;
2777         /*
2778          * Lookup file; if found, lookup stateid and check open request,
2779          * and check for delegations in the process of being recalled.
2780          * If not found, create the nfs4_file struct
2781          */
2782         fp = find_file(ino);
2783         if (fp) {
2784                 if ((status = nfs4_check_open(fp, open, &stp)))
2785                         goto out;
2786                 status = nfs4_check_deleg(fp, open, &dp);
2787                 if (status)
2788                         goto out;
2789         } else {
2790                 status = nfserr_bad_stateid;
2791                 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2792                         goto out;
2793                 status = nfserr_resource;
2794                 fp = alloc_init_file(ino);
2795                 if (fp == NULL)
2796                         goto out;
2797         }
2798
2799         /*
2800          * OPEN the file, or upgrade an existing OPEN.
2801          * If truncate fails, the OPEN fails.
2802          */
2803         if (stp) {
2804                 /* Stateid was found, this is an OPEN upgrade */
2805                 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
2806                 if (status)
2807                         goto out;
2808                 update_stateid(&stp->st_stateid);
2809         } else {
2810                 status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
2811                 if (status)
2812                         goto out;
2813                 init_stateid(stp, fp, open);
2814                 status = nfsd4_truncate(rqstp, current_fh, open);
2815                 if (status) {
2816                         release_open_stateid(stp);
2817                         goto out;
2818                 }
2819                 if (nfsd4_has_session(&resp->cstate))
2820                         update_stateid(&stp->st_stateid);
2821         }
2822         memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2823
2824         if (nfsd4_has_session(&resp->cstate))
2825                 open->op_stateowner->so_confirmed = 1;
2826
2827         /*
2828         * Attempt to hand out a delegation. No error return, because the
2829         * OPEN succeeds even if we fail.
2830         */
2831         nfs4_open_delegation(current_fh, open, stp);
2832
2833         status = nfs_ok;
2834
2835         dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2836                 STATEID_VAL(&stp->st_stateid));
2837 out:
2838         if (fp)
2839                 put_nfs4_file(fp);
2840         if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2841                 nfs4_set_claim_prev(open);
2842         /*
2843         * To finish the open response, we just need to set the rflags.
2844         */
2845         open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
2846         if (!open->op_stateowner->so_confirmed &&
2847             !nfsd4_has_session(&resp->cstate))
2848                 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2849
2850         return status;
2851 }
2852
2853 __be32
2854 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2855             clientid_t *clid)
2856 {
2857         struct nfs4_client *clp;
2858         __be32 status;
2859
2860         nfs4_lock_state();
2861         dprintk("process_renew(%08x/%08x): starting\n", 
2862                         clid->cl_boot, clid->cl_id);
2863         status = nfserr_stale_clientid;
2864         if (STALE_CLIENTID(clid))
2865                 goto out;
2866         clp = find_confirmed_client(clid);
2867         status = nfserr_expired;
2868         if (clp == NULL) {
2869                 /* We assume the client took too long to RENEW. */
2870                 dprintk("nfsd4_renew: clientid not found!\n");
2871                 goto out;
2872         }
2873         renew_client(clp);
2874         status = nfserr_cb_path_down;
2875         if (!list_empty(&clp->cl_delegations)
2876                         && clp->cl_cb_state != NFSD4_CB_UP)
2877                 goto out;
2878         status = nfs_ok;
2879 out:
2880         nfs4_unlock_state();
2881         return status;
2882 }
2883
2884 struct lock_manager nfsd4_manager = {
2885 };
2886
2887 static void
2888 nfsd4_end_grace(void)
2889 {
2890         dprintk("NFSD: end of grace period\n");
2891         nfsd4_recdir_purge_old();
2892         locks_end_grace(&nfsd4_manager);
2893         /*
2894          * Now that every NFSv4 client has had the chance to recover and
2895          * to see the (possibly new, possibly shorter) lease time, we
2896          * can safely set the next grace time to the current lease time:
2897          */
2898         nfsd4_grace = nfsd4_lease;
2899 }
2900
2901 static time_t
2902 nfs4_laundromat(void)
2903 {
2904         struct nfs4_client *clp;
2905         struct nfs4_stateowner *sop;
2906         struct nfs4_delegation *dp;
2907         struct list_head *pos, *next, reaplist;
2908         time_t cutoff = get_seconds() - nfsd4_lease;
2909         time_t t, clientid_val = nfsd4_lease;
2910         time_t u, test_val = nfsd4_lease;
2911
2912         nfs4_lock_state();
2913
2914         dprintk("NFSD: laundromat service - starting\n");
2915         if (locks_in_grace())
2916                 nfsd4_end_grace();
2917         INIT_LIST_HEAD(&reaplist);
2918         spin_lock(&client_lock);
2919         list_for_each_safe(pos, next, &client_lru) {
2920                 clp = list_entry(pos, struct nfs4_client, cl_lru);
2921                 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2922                         t = clp->cl_time - cutoff;
2923                         if (clientid_val > t)
2924                                 clientid_val = t;
2925                         break;
2926                 }
2927                 if (atomic_read(&clp->cl_refcount)) {
2928                         dprintk("NFSD: client in use (clientid %08x)\n",
2929                                 clp->cl_clientid.cl_id);
2930                         continue;
2931                 }
2932                 unhash_client_locked(clp);
2933                 list_add(&clp->cl_lru, &reaplist);
2934         }
2935         spin_unlock(&client_lock);
2936         list_for_each_safe(pos, next, &reaplist) {
2937                 clp = list_entry(pos, struct nfs4_client, cl_lru);
2938                 dprintk("NFSD: purging unused client (clientid %08x)\n",
2939                         clp->cl_clientid.cl_id);
2940                 nfsd4_remove_clid_dir(clp);
2941                 expire_client(clp);
2942         }
2943         spin_lock(&recall_lock);
2944         list_for_each_safe(pos, next, &del_recall_lru) {
2945                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2946                 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
2947                         u = dp->dl_time - cutoff;
2948                         if (test_val > u)
2949                                 test_val = u;
2950                         break;
2951                 }
2952                 list_move(&dp->dl_recall_lru, &reaplist);
2953         }
2954         spin_unlock(&recall_lock);
2955         list_for_each_safe(pos, next, &reaplist) {
2956                 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2957                 list_del_init(&dp->dl_recall_lru);
2958                 unhash_delegation(dp);
2959         }
2960         test_val = nfsd4_lease;
2961         list_for_each_safe(pos, next, &close_lru) {
2962                 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
2963                 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
2964                         u = sop->so_time - cutoff;
2965                         if (test_val > u)
2966                                 test_val = u;
2967                         break;
2968                 }
2969                 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
2970                         sop->so_id);
2971                 release_openowner(sop);
2972         }
2973         if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
2974                 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
2975         nfs4_unlock_state();
2976         return clientid_val;
2977 }
2978
2979 static struct workqueue_struct *laundry_wq;
2980 static void laundromat_main(struct work_struct *);
2981 static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
2982
2983 static void
2984 laundromat_main(struct work_struct *not_used)
2985 {
2986         time_t t;
2987
2988         t = nfs4_laundromat();
2989         dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
2990         queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
2991 }
2992
2993 static struct nfs4_stateowner *
2994 search_close_lru(u32 st_id, int flags)
2995 {
2996         struct nfs4_stateowner *local = NULL;
2997
2998         if (flags & CLOSE_STATE) {
2999                 list_for_each_entry(local, &close_lru, so_close_lru) {
3000                         if (local->so_id == st_id)
3001                                 return local;
3002                 }
3003         }
3004         return NULL;
3005 }
3006
3007 static inline int
3008 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
3009 {
3010         return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
3011 }
3012
3013 static int
3014 STALE_STATEID(stateid_t *stateid)
3015 {
3016         if (stateid->si_boot == boot_time)
3017                 return 0;
3018         dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
3019                 STATEID_VAL(stateid));
3020         return 1;
3021 }
3022
3023 static inline int
3024 access_permit_read(unsigned long access_bmap)
3025 {
3026         return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
3027                 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
3028                 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
3029 }
3030
3031 static inline int
3032 access_permit_write(unsigned long access_bmap)
3033 {
3034         return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
3035                 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
3036 }
3037
3038 static
3039 __be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
3040 {
3041         __be32 status = nfserr_openmode;
3042
3043         /* For lock stateid's, we test the parent open, not the lock: */
3044         if (stp->st_openstp)
3045                 stp = stp->st_openstp;
3046         if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
3047                 goto out;
3048         if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
3049                 goto out;
3050         status = nfs_ok;
3051 out:
3052         return status;
3053 }
3054
3055 static inline __be32
3056 check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3057 {
3058         if (ONE_STATEID(stateid) && (flags & RD_STATE))
3059                 return nfs_ok;
3060         else if (locks_in_grace()) {
3061                 /* Answer in remaining cases depends on existence of
3062                  * conflicting state; so we must wait out the grace period. */
3063                 return nfserr_grace;
3064         } else if (flags & WR_STATE)
3065                 return nfs4_share_conflict(current_fh,
3066                                 NFS4_SHARE_DENY_WRITE);
3067         else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3068                 return nfs4_share_conflict(current_fh,
3069                                 NFS4_SHARE_DENY_READ);
3070 }
3071
3072 /*
3073  * Allow READ/WRITE during grace period on recovered state only for files
3074  * that are not able to provide mandatory locking.
3075  */
3076 static inline int
3077 grace_disallows_io(struct inode *inode)
3078 {
3079         return locks_in_grace() && mandatory_lock(inode);
3080 }
3081
3082 static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
3083 {
3084         /*
3085          * When sessions are used the stateid generation number is ignored
3086          * when it is zero.
3087          */
3088         if ((flags & HAS_SESSION) && in->si_generation == 0)
3089                 goto out;
3090
3091         /* If the client sends us a stateid from the future, it's buggy: */
3092         if (in->si_generation > ref->si_generation)
3093                 return nfserr_bad_stateid;
3094         /*
3095          * The following, however, can happen.  For example, if the
3096          * client sends an open and some IO at the same time, the open
3097          * may bump si_generation while the IO is still in flight.
3098          * Thanks to hard links and renames, the client never knows what
3099          * file an open will affect.  So it could avoid that situation
3100          * only by serializing all opens and IO from the same open
3101          * owner.  To recover from the old_stateid error, the client
3102          * will just have to retry the IO:
3103          */
3104         if (in->si_generation < ref->si_generation)
3105                 return nfserr_old_stateid;
3106 out:
3107         return nfs_ok;
3108 }
3109
3110 static int is_delegation_stateid(stateid_t *stateid)
3111 {
3112         return stateid->si_fileid == 0;
3113 }
3114
3115 /*
3116 * Checks for stateid operations
3117 */
3118 __be32
3119 nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3120                            stateid_t *stateid, int flags, struct file **filpp)
3121 {
3122         struct nfs4_stateid *stp = NULL;
3123         struct nfs4_delegation *dp = NULL;
3124         struct svc_fh *current_fh = &cstate->current_fh;
3125         struct inode *ino = current_fh->fh_dentry->d_inode;
3126         __be32 status;
3127
3128         if (filpp)
3129                 *filpp = NULL;
3130
3131         if (grace_disallows_io(ino))
3132                 return nfserr_grace;
3133
3134         if (nfsd4_has_session(cstate))
3135                 flags |= HAS_SESSION;
3136
3137         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3138                 return check_special_stateids(current_fh, stateid, flags);
3139
3140         status = nfserr_stale_stateid;
3141         if (STALE_STATEID(stateid)) 
3142                 goto out;
3143
3144         /*
3145          * We assume that any stateid that has the current boot time,
3146          * but that we can't find, is expired:
3147          */
3148         status = nfserr_expired;
3149         if (is_delegation_stateid(stateid)) {
3150                 dp = find_delegation_stateid(ino, stateid);
3151                 if (!dp)
3152                         goto out;
3153                 status = check_stateid_generation(stateid, &dp->dl_stateid,
3154                                                   flags);
3155                 if (status)
3156                         goto out;
3157                 status = nfs4_check_delegmode(dp, flags);
3158                 if (status)
3159                         goto out;
3160                 renew_client(dp->dl_client);
3161                 if (filpp) {
3162                         *filpp = dp->dl_file->fi_deleg_file;
3163                         BUG_ON(!*filpp);
3164                 }
3165         } else { /* open or lock stateid */
3166                 stp = find_stateid(stateid, flags);
3167                 if (!stp)
3168                         goto out;
3169                 status = nfserr_bad_stateid;
3170                 if (nfs4_check_fh(current_fh, stp))
3171                         goto out;
3172                 if (!stp->st_stateowner->so_confirmed)
3173                         goto out;
3174                 status = check_stateid_generation(stateid, &stp->st_stateid,
3175                                                   flags);
3176                 if (status)
3177                         goto out;
3178                 status = nfs4_check_openmode(stp, flags);
3179                 if (status)
3180                         goto out;
3181                 renew_client(stp->st_stateowner->so_client);
3182                 if (filpp) {
3183                         if (flags & RD_STATE)
3184                                 *filpp = find_readable_file(stp->st_file);
3185                         else
3186                                 *filpp = find_writeable_file(stp->st_file);
3187                 }
3188         }
3189         status = nfs_ok;
3190 out:
3191         return status;
3192 }
3193
3194 static inline int
3195 setlkflg (int type)
3196 {
3197         return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3198                 RD_STATE : WR_STATE;
3199 }
3200
3201 /* 
3202  * Checks for sequence id mutating operations. 
3203  */
3204 static __be32
3205 nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3206                          stateid_t *stateid, int flags,
3207                          struct nfs4_stateowner **sopp,
3208                          struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
3209 {
3210         struct nfs4_stateid *stp;
3211         struct nfs4_stateowner *sop;
3212         struct svc_fh *current_fh = &cstate->current_fh;
3213         __be32 status;
3214
3215         dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3216                 seqid, STATEID_VAL(stateid));
3217
3218         *stpp = NULL;
3219         *sopp = NULL;
3220
3221         if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
3222                 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
3223                 return nfserr_bad_stateid;
3224         }
3225
3226         if (STALE_STATEID(stateid))
3227                 return nfserr_stale_stateid;
3228
3229         if (nfsd4_has_session(cstate))
3230                 flags |= HAS_SESSION;
3231
3232         /*
3233         * We return BAD_STATEID if filehandle doesn't match stateid, 
3234         * the confirmed flag is incorrecly set, or the generation 
3235         * number is incorrect.  
3236         */
3237         stp = find_stateid(stateid, flags);
3238         if (stp == NULL) {
3239                 /*
3240                  * Also, we should make sure this isn't just the result of
3241                  * a replayed close:
3242                  */
3243                 sop = search_close_lru(stateid->si_stateownerid, flags);
3244                 /* It's not stale; let's assume it's expired: */
3245                 if (sop == NULL)
3246                         return nfserr_expired;
3247                 *sopp = sop;
3248                 goto check_replay;
3249         }
3250
3251         *stpp = stp;
3252         *sopp = sop = stp->st_stateowner;
3253
3254         if (lock) {
3255                 clientid_t *lockclid = &lock->v.new.clientid;
3256                 struct nfs4_client *clp = sop->so_client;
3257                 int lkflg = 0;
3258                 __be32 status;
3259
3260                 lkflg = setlkflg(lock->lk_type);
3261
3262                 if (lock->lk_is_new) {
3263                         if (!sop->so_is_open_owner)
3264                                 return nfserr_bad_stateid;
3265                         if (!(flags & HAS_SESSION) &&
3266                             !same_clid(&clp->cl_clientid, lockclid))
3267                                 return nfserr_bad_stateid;
3268                         /* stp is the open stateid */
3269                         status = nfs4_check_openmode(stp, lkflg);
3270                         if (status)
3271                                 return status;
3272                 } else {
3273                         /* stp is the lock stateid */
3274                         status = nfs4_check_openmode(stp->st_openstp, lkflg);
3275                         if (status)
3276                                 return status;
3277                }
3278         }
3279
3280         if (nfs4_check_fh(current_fh, stp)) {
3281                 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
3282                 return nfserr_bad_stateid;
3283         }
3284
3285         /*
3286         *  We now validate the seqid and stateid generation numbers.
3287         *  For the moment, we ignore the possibility of 
3288         *  generation number wraparound.
3289         */
3290         if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
3291                 goto check_replay;
3292
3293         if (sop->so_confirmed && flags & CONFIRM) {
3294                 dprintk("NFSD: preprocess_seqid_op: expected"
3295                                 " unconfirmed stateowner!\n");
3296                 return nfserr_bad_stateid;
3297         }
3298         if (!sop->so_confirmed && !(flags & CONFIRM)) {
3299                 dprintk("NFSD: preprocess_seqid_op: stateowner not"
3300                                 " confirmed yet!\n");
3301                 return nfserr_bad_stateid;
3302         }
3303         status = check_stateid_generation(stateid, &stp->st_stateid, flags);
3304         if (status)
3305                 return status;
3306         renew_client(sop->so_client);
3307         return nfs_ok;
3308
3309 check_replay:
3310         if (seqid == sop->so_seqid - 1) {