projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
nfsd4: fix alloc_init_session return type
[deliverable/linux.git] / fs / nfsd / nfs4state.c
CommitLineData
1da177e4 1/*
1da177e4
LT		 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
aceaf78d 35#include <linux/file.h>
1da177e4 36#include <linux/smp_lock.h>
5a0e3ad6 37#include <linux/slab.h>
0964a3d3 38#include <linux/namei.h>
c2f1a551 39#include <linux/swap.h>
68e76ad0 40#include <linux/sunrpc/svcauth_gss.h>
363168b4 41#include <linux/sunrpc/clnt.h>
9a74af21 42#include "xdr4.h"
0a3adade 43#include "vfs.h"
1da177e4
LT		 44
45#define NFSDDBG_FACILITY NFSDDBG_PROC
46
47/* Globals */
cf07d2ea 48time_t nfsd4_lease = 90; /* default lease time */
efc4bb4f 49time_t nfsd4_grace = 90;
fd39ca9a 50static time_t boot_time;
1da177e4
LT		 51static u32 current_ownerid = 1;
52static u32 current_fileid = 1;
53static u32 current_delegid = 1;
fd39ca9a
N		 54static stateid_t zerostateid; /* bits all 0 */
55static stateid_t onestateid; /* bits all 1 */
ec6b5d7b 56static u64 current_sessionid = 1;
fd39ca9a
N		 57
58#define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
59#define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
1da177e4 60
1da177e4 61/* forward declarations */
fd39ca9a 62static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
1da177e4 63static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
0964a3d3
N		 64static char user_recovery_dirname[PATH_MAX] = "/var/lib/nfs/v4recovery";
65static void nfs4_set_recdir(char *recdir);
1da177e4 66
8b671b80
BF		 67/* Locking: */
68
69/* Currently used for almost all code touching nfsv4 state: */
353ab6e9 70static DEFINE_MUTEX(client_mutex);
1da177e4 71
8b671b80
BF		 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 */
77static DEFINE_SPINLOCK(recall_lock);
78
e18b890b
CL		 79static struct kmem_cache *stateowner_slab = NULL;
80static struct kmem_cache *file_slab = NULL;
81static struct kmem_cache *stateid_slab = NULL;
82static struct kmem_cache *deleg_slab = NULL;
e60d4398 83
1da177e4
LT		 84void
85nfs4_lock_state(void)
86{
353ab6e9 87 mutex_lock(&client_mutex);
1da177e4
LT		 88}
89
90void
91nfs4_unlock_state(void)
92{
353ab6e9 93 mutex_unlock(&client_mutex);
1da177e4
LT		 94}
95
96static inline u32
97opaque_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
1da177e4
LT		 109static struct list_head del_recall_lru;
110
13cd2184
N		 111static inline void
112put_nfs4_file(struct nfs4_file *fi)
113{
8b671b80
BF		 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 }
13cd2184
N		 120}
121
122static inline void
123get_nfs4_file(struct nfs4_file *fi)
124{
8b671b80 125 atomic_inc(&fi->fi_ref);
13cd2184
N		 126}
127
ef0f3390 128static int num_delegations;
c2f1a551 129unsigned int max_delegations;
ef0f3390
N		 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
145static struct list_head ownerid_hashtbl[OWNER_HASH_SIZE];
146static 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#define FILE_HASH_MASK (FILE_HASH_SIZE - 1)
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
162static struct list_head file_hashtbl[FILE_HASH_SIZE];
163static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
164
998db52c 165static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
f9d7562f
BF		 166{
167 BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
168 atomic_inc(&fp->fi_access[oflag]);
169}
170
998db52c
BF		 171static 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
180static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
f9d7562f
BF		 181{
182 if (fp->fi_fds[oflag]) {
183 fput(fp->fi_fds[oflag]);
184 fp->fi_fds[oflag] = NULL;
185 }
186}
187
998db52c 188static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
f9d7562f
BF		 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
998db52c
BF		 196static 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
1da177e4
LT		 205static struct nfs4_delegation *
206alloc_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;
1da177e4
LT		 210
211 dprintk("NFSD alloc_init_deleg\n");
c3e48080
BF		 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;
47f9940c
MS		 219 if (fp->fi_had_conflict)
220 return NULL;
c2f1a551 221 if (num_delegations > max_delegations)
ef0f3390 222 return NULL;
5b2d21c1
N		 223 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
224 if (dp == NULL)
1da177e4 225 return dp;
ef0f3390 226 num_delegations++;
ea1da636
N		 227 INIT_LIST_HEAD(&dp->dl_perfile);
228 INIT_LIST_HEAD(&dp->dl_perclnt);
1da177e4
LT		 229 INIT_LIST_HEAD(&dp->dl_recall_lru);
230 dp->dl_client = clp;
13cd2184 231 get_nfs4_file(fp);
1da177e4 232 dp->dl_file = fp;
f9d7562f 233 nfs4_file_get_access(fp, O_RDONLY);
1da177e4 234 dp->dl_flock = NULL;
1da177e4 235 dp->dl_type = type;
e4e83ea4 236 dp->dl_stateid.si_boot = boot_time;
1da177e4
LT		 237 dp->dl_stateid.si_stateownerid = current_delegid++;
238 dp->dl_stateid.si_fileid = 0;
239 dp->dl_stateid.si_generation = 0;
6c02eaa1 240 fh_copy_shallow(&dp->dl_fh, &current_fh->fh_handle);
1da177e4
LT		 241 dp->dl_time = 0;
242 atomic_set(&dp->dl_count, 1);
ea1da636
N		 243 list_add(&dp->dl_perfile, &fp->fi_delegations);
244 list_add(&dp->dl_perclnt, &clp->cl_delegations);
b5a1a81e 245 INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
1da177e4
LT		 246 return dp;
247}
248
249void
250nfs4_put_delegation(struct nfs4_delegation *dp)
251{
252 if (atomic_dec_and_test(&dp->dl_count)) {
253 dprintk("NFSD: freeing dp %p\n",dp);
13cd2184 254 put_nfs4_file(dp->dl_file);
5b2d21c1 255 kmem_cache_free(deleg_slab, dp);
ef0f3390 256 num_delegations--;
1da177e4
LT		 257 }
258}
259
260/* Remove the associated file_lock first, then remove the delegation.
261 * lease_modify() is called to remove the FS_LEASE file_lock from
262 * the i_flock list, eventually calling nfsd's lock_manager
263 * fl_release_callback.
264 */
265static void
266nfs4_close_delegation(struct nfs4_delegation *dp)
267{
f9d7562f 268 struct file *filp = find_readable_file(dp->dl_file);
1da177e4
LT		 269
270 dprintk("NFSD: close_delegation dp %p\n",dp);
c907132d 271 if (dp->dl_flock)
a9933cea 272 vfs_setlease(filp, F_UNLCK, &dp->dl_flock);
f9d7562f 273 nfs4_file_put_access(dp->dl_file, O_RDONLY);
1da177e4
LT		 274}
275
276/* Called under the state lock. */
277static void
278unhash_delegation(struct nfs4_delegation *dp)
279{
ea1da636
N		 280 list_del_init(&dp->dl_perfile);
281 list_del_init(&dp->dl_perclnt);
1da177e4
LT		 282 spin_lock(&recall_lock);
283 list_del_init(&dp->dl_recall_lru);
284 spin_unlock(&recall_lock);
285 nfs4_close_delegation(dp);
286 nfs4_put_delegation(dp);
287}
288
289/*
290 * SETCLIENTID state
291 */
292
36acb66b 293/* client_lock protects the client lru list and session hash table */
9089f1b4
BH		 294static DEFINE_SPINLOCK(client_lock);
295
1da177e4
LT		 296/* Hash tables for nfs4_clientid state */
297#define CLIENT_HASH_BITS 4
298#define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
299#define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
300
301#define clientid_hashval(id) \
302 ((id) & CLIENT_HASH_MASK)
a55370a3
N		 303#define clientstr_hashval(name) \
304 (opaque_hashval((name), 8) & CLIENT_HASH_MASK)
1da177e4
LT		 305/*
306 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
307 * used in reboot/reset lease grace period processing
308 *
309 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
310 * setclientid_confirmed info.
311 *
312 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
313 * setclientid info.
314 *
315 * client_lru holds client queue ordered by nfs4_client.cl_time
316 * for lease renewal.
317 *
318 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
319 * for last close replay.
320 */
321static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
322static int reclaim_str_hashtbl_size = 0;
323static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
324static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
325static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
326static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
327static struct list_head client_lru;
328static struct list_head close_lru;
329
2283963f
BF		 330static void unhash_generic_stateid(struct nfs4_stateid *stp)
331{
332 list_del(&stp->st_hash);
333 list_del(&stp->st_perfile);
334 list_del(&stp->st_perstateowner);
335}
336
337static void free_generic_stateid(struct nfs4_stateid *stp)
338{
339 put_nfs4_file(stp->st_file);
340 kmem_cache_free(stateid_slab, stp);
341}
342
343static void release_lock_stateid(struct nfs4_stateid *stp)
344{
f9d7562f
BF		 345 struct file *file;
346
2283963f 347 unhash_generic_stateid(stp);
f9d7562f
BF		 348 file = find_any_file(stp->st_file);
349 if (file)
350 locks_remove_posix(file, (fl_owner_t)stp->st_stateowner);
2283963f
BF		 351 free_generic_stateid(stp);
352}
353
f044ff83
BF		 354static void unhash_lockowner(struct nfs4_stateowner *sop)
355{
356 struct nfs4_stateid *stp;
357
358 list_del(&sop->so_idhash);
359 list_del(&sop->so_strhash);
360 list_del(&sop->so_perstateid);
361 while (!list_empty(&sop->so_stateids)) {
362 stp = list_first_entry(&sop->so_stateids,
363 struct nfs4_stateid, st_perstateowner);
364 release_lock_stateid(stp);
365 }
366}
367
368static void release_lockowner(struct nfs4_stateowner *sop)
369{
370 unhash_lockowner(sop);
371 nfs4_put_stateowner(sop);
372}
373
f1d110ca
BF		 374static void
375release_stateid_lockowners(struct nfs4_stateid *open_stp)
376{
377 struct nfs4_stateowner *lock_sop;
378
379 while (!list_empty(&open_stp->st_lockowners)) {
380 lock_sop = list_entry(open_stp->st_lockowners.next,
381 struct nfs4_stateowner, so_perstateid);
382 /* list_del(&open_stp->st_lockowners); */
383 BUG_ON(lock_sop->so_is_open_owner);
f044ff83 384 release_lockowner(lock_sop);
f1d110ca
BF		 385 }
386}
387
f9d7562f
BF		 388/*
389 * We store the NONE, READ, WRITE, and BOTH bits separately in the
390 * st_{access,deny}_bmap field of the stateid, in order to track not
391 * only what share bits are currently in force, but also what
392 * combinations of share bits previous opens have used. This allows us
393 * to enforce the recommendation of rfc 3530 14.2.19 that the server
394 * return an error if the client attempt to downgrade to a combination
395 * of share bits not explicable by closing some of its previous opens.
396 *
397 * XXX: This enforcement is actually incomplete, since we don't keep
398 * track of access/deny bit combinations; so, e.g., we allow:
399 *
400 * OPEN allow read, deny write
401 * OPEN allow both, deny none
402 * DOWNGRADE allow read, deny none
403 *
404 * which we should reject.
405 */
406static void
407set_access(unsigned int *access, unsigned long bmap) {
408 int i;
409
410 *access = 0;
411 for (i = 1; i < 4; i++) {
412 if (test_bit(i, &bmap))
413 *access |= i;
414 }
415}
416
417static void
418set_deny(unsigned int *deny, unsigned long bmap) {
419 int i;
420
421 *deny = 0;
422 for (i = 0; i < 4; i++) {
423 if (test_bit(i, &bmap))
424 *deny |= i ;
425 }
426}
427
428static int
429test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
430 unsigned int access, deny;
431
432 set_access(&access, stp->st_access_bmap);
433 set_deny(&deny, stp->st_deny_bmap);
434 if ((access & open->op_share_deny) || (deny & open->op_share_access))
435 return 0;
436 return 1;
437}
438
439static int nfs4_access_to_omode(u32 access)
440{
8f34a430 441 switch (access & NFS4_SHARE_ACCESS_BOTH) {
f9d7562f
BF		 442 case NFS4_SHARE_ACCESS_READ:
443 return O_RDONLY;
444 case NFS4_SHARE_ACCESS_WRITE:
445 return O_WRONLY;
446 case NFS4_SHARE_ACCESS_BOTH:
447 return O_RDWR;
448 }
449 BUG();
450}
451
452static int nfs4_access_bmap_to_omode(struct nfs4_stateid *stp)
453{
454 unsigned int access;
455
456 set_access(&access, stp->st_access_bmap);
457 return nfs4_access_to_omode(access);
458}
459
2283963f
BF		 460static void release_open_stateid(struct nfs4_stateid *stp)
461{
f9d7562f
BF		 462 int oflag = nfs4_access_bmap_to_omode(stp);
463
2283963f
BF		 464 unhash_generic_stateid(stp);
465 release_stateid_lockowners(stp);
f9d7562f 466 nfs4_file_put_access(stp->st_file, oflag);
2283963f
BF		 467 free_generic_stateid(stp);
468}
469
f044ff83 470static void unhash_openowner(struct nfs4_stateowner *sop)
f1d110ca
BF		 471{
472 struct nfs4_stateid *stp;
473
474 list_del(&sop->so_idhash);
475 list_del(&sop->so_strhash);
f044ff83
BF		 476 list_del(&sop->so_perclient);
477 list_del(&sop->so_perstateid); /* XXX: necessary? */
f1d110ca 478 while (!list_empty(&sop->so_stateids)) {
f044ff83
BF		 479 stp = list_first_entry(&sop->so_stateids,
480 struct nfs4_stateid, st_perstateowner);
481 release_open_stateid(stp);
f1d110ca
BF		 482 }
483}
484
f044ff83 485static void release_openowner(struct nfs4_stateowner *sop)
f1d110ca 486{
f044ff83 487 unhash_openowner(sop);
f1d110ca
BF		 488 list_del(&sop->so_close_lru);
489 nfs4_put_stateowner(sop);
490}
491
5282fd72
ME		 492#define SESSION_HASH_SIZE 512
493static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
494
495static inline int
496hash_sessionid(struct nfs4_sessionid *sessionid)
497{
498 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
499
500 return sid->sequence % SESSION_HASH_SIZE;
501}
502
503static inline void
504dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
505{
506 u32 *ptr = (u32 *)(&sessionid->data[0]);
507 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
508}
509
ec6b5d7b
AA		 510static void
511gen_sessionid(struct nfsd4_session *ses)
512{
513 struct nfs4_client *clp = ses->se_client;
514 struct nfsd4_sessionid *sid;
515
516 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
517 sid->clientid = clp->cl_clientid;
518 sid->sequence = current_sessionid++;
519 sid->reserved = 0;
520}
521
522/*
a649637c
AA		 523 * The protocol defines ca_maxresponssize_cached to include the size of
524 * the rpc header, but all we need to cache is the data starting after
525 * the end of the initial SEQUENCE operation--the rest we regenerate
526 * each time. Therefore we can advertise a ca_maxresponssize_cached
527 * value that is the number of bytes in our cache plus a few additional
528 * bytes. In order to stay on the safe side, and not promise more than
529 * we can cache, those additional bytes must be the minimum possible: 24
530 * bytes of rpc header (xid through accept state, with AUTH_NULL
531 * verifier), 12 for the compound header (with zero-length tag), and 44
532 * for the SEQUENCE op response:
533 */
534#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
535
536/*
537 * Give the client the number of ca_maxresponsesize_cached slots it
538 * requests, of size bounded by NFSD_SLOT_CACHE_SIZE,
539 * NFSD_MAX_MEM_PER_SESSION, and nfsd_drc_max_mem. Do not allow more
540 * than NFSD_MAX_SLOTS_PER_SESSION.
ec6b5d7b 541 *
a649637c
AA		 542 * If we run out of reserved DRC memory we should (up to a point)
543 * re-negotiate active sessions and reduce their slot usage to make
544 * rooom for new connections. For now we just fail the create session.
ec6b5d7b 545 */
a649637c 546static int set_forechannel_drc_size(struct nfsd4_channel_attrs *fchan)
ec6b5d7b 547{
a649637c 548 int mem, size = fchan->maxresp_cached;
ec6b5d7b 549
5d77ddfb
AA		 550 if (fchan->maxreqs < 1)
551 return nfserr_inval;
5d77ddfb 552
a649637c
AA		 553 if (size < NFSD_MIN_HDR_SEQ_SZ)
554 size = NFSD_MIN_HDR_SEQ_SZ;
555 size -= NFSD_MIN_HDR_SEQ_SZ;
556 if (size > NFSD_SLOT_CACHE_SIZE)
557 size = NFSD_SLOT_CACHE_SIZE;
ec6b5d7b 558
a649637c
AA		 559 /* bound the maxreqs by NFSD_MAX_MEM_PER_SESSION */
560 mem = fchan->maxreqs * size;
561 if (mem > NFSD_MAX_MEM_PER_SESSION) {
562 fchan->maxreqs = NFSD_MAX_MEM_PER_SESSION / size;
563 if (fchan->maxreqs > NFSD_MAX_SLOTS_PER_SESSION)
564 fchan->maxreqs = NFSD_MAX_SLOTS_PER_SESSION;
565 mem = fchan->maxreqs * size;
566 }
ec6b5d7b 567
4bd9b0f4 568 spin_lock(&nfsd_drc_lock);
a649637c
AA		 569 /* bound the total session drc memory ussage */
570 if (mem + nfsd_drc_mem_used > nfsd_drc_max_mem) {
571 fchan->maxreqs = (nfsd_drc_max_mem - nfsd_drc_mem_used) / size;
572 mem = fchan->maxreqs * size;
573 }
0c193054 574 nfsd_drc_mem_used += mem;
4bd9b0f4 575 spin_unlock(&nfsd_drc_lock);
ec6b5d7b 576
b101ebbc 577 if (fchan->maxreqs == 0)
4731030d 578 return nfserr_jukebox;
a649637c
AA		 579
580 fchan->maxresp_cached = size + NFSD_MIN_HDR_SEQ_SZ;
b101ebbc 581 return 0;
ec6b5d7b
AA		 582}
583
584/*
585 * fchan holds the client values on input, and the server values on output
ddc04fd4 586 * sv_max_mesg is the maximum payload plus one page for overhead.
ec6b5d7b
AA		 587 */
588static int init_forechannel_attrs(struct svc_rqst *rqstp,
6c18ba9f
AB		 589 struct nfsd4_channel_attrs *session_fchan,
590 struct nfsd4_channel_attrs *fchan)
ec6b5d7b
AA		 591{
592 int status = 0;
ddc04fd4 593 __u32 maxcount = nfsd_serv->sv_max_mesg;
ec6b5d7b
AA		 594
595 /* headerpadsz set to zero in encode routine */
596
597 /* Use the client's max request and max response size if possible */
598 if (fchan->maxreq_sz > maxcount)
599 fchan->maxreq_sz = maxcount;
6c18ba9f 600 session_fchan->maxreq_sz = fchan->maxreq_sz;
ec6b5d7b
AA		 601
602 if (fchan->maxresp_sz > maxcount)
603 fchan->maxresp_sz = maxcount;
6c18ba9f 604 session_fchan->maxresp_sz = fchan->maxresp_sz;
ec6b5d7b 605
ec6b5d7b
AA		 606 /* Use the client's maxops if possible */
607 if (fchan->maxops > NFSD_MAX_OPS_PER_COMPOUND)
608 fchan->maxops = NFSD_MAX_OPS_PER_COMPOUND;
6c18ba9f 609 session_fchan->maxops = fchan->maxops;
ec6b5d7b 610
ec6b5d7b
AA		 611 /* FIXME: Error means no more DRC pages so the server should
612 * recover pages from existing sessions. For now fail session
613 * creation.
614 */
a649637c 615 status = set_forechannel_drc_size(fchan);
ec6b5d7b 616
a649637c 617 session_fchan->maxresp_cached = fchan->maxresp_cached;
6c18ba9f 618 session_fchan->maxreqs = fchan->maxreqs;
a649637c
AA		 619
620 dprintk("%s status %d\n", __func__, status);
ec6b5d7b
AA		 621 return status;
622}
623
557ce264
AA		 624static void
625free_session_slots(struct nfsd4_session *ses)
626{
627 int i;
628
629 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
630 kfree(ses->se_slots[i]);
631}
632
efe0cb6d
BF		 633/*
634 * We don't actually need to cache the rpc and session headers, so we
635 * can allocate a little less for each slot:
636 */
637static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
638{
639 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
640}
641
dd938424 642static __be32 alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
ec6b5d7b
AA		 643{
644 struct nfsd4_session *new, tmp;
557ce264
AA		 645 struct nfsd4_slot *sp;
646 int idx, slotsize, cachesize, i;
647 int status;
ec6b5d7b
AA		 648
649 memset(&tmp, 0, sizeof(tmp));
650
651 /* FIXME: For now, we just accept the client back channel attributes. */
6c18ba9f
AB		 652 tmp.se_bchannel = cses->back_channel;
653 status = init_forechannel_attrs(rqstp, &tmp.se_fchannel,
654 &cses->fore_channel);
ec6b5d7b
AA		 655 if (status)
656 goto out;
657
c23753da 658 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
557ce264
AA		 659 + sizeof(struct nfsd4_session) > PAGE_SIZE);
660
4731030d 661 status = nfserr_jukebox;
557ce264
AA		 662 /* allocate struct nfsd4_session and slot table pointers in one piece */
663 slotsize = tmp.se_fchannel.maxreqs * sizeof(struct nfsd4_slot *);
ec6b5d7b
AA		 664 new = kzalloc(sizeof(*new) + slotsize, GFP_KERNEL);
665 if (!new)
666 goto out;
667
668 memcpy(new, &tmp, sizeof(*new));
669
557ce264 670 /* allocate each struct nfsd4_slot and data cache in one piece */
efe0cb6d 671 cachesize = slot_bytes(&new->se_fchannel);
557ce264
AA		 672 for (i = 0; i < new->se_fchannel.maxreqs; i++) {
673 sp = kzalloc(sizeof(*sp) + cachesize, GFP_KERNEL);
674 if (!sp)
675 goto out_free;
676 new->se_slots[i] = sp;
677 }
678
ec6b5d7b
AA		 679 new->se_client = clp;
680 gen_sessionid(new);
681 idx = hash_sessionid(&new->se_sessionid);
682 memcpy(clp->cl_sessionid.data, new->se_sessionid.data,
683 NFS4_MAX_SESSIONID_LEN);
684
685 new->se_flags = cses->flags;
686 kref_init(&new->se_ref);
9089f1b4 687 spin_lock(&client_lock);
ec6b5d7b
AA		 688 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
689 list_add(&new->se_perclnt, &clp->cl_sessions);
9089f1b4 690 spin_unlock(&client_lock);
ec6b5d7b
AA		 691
692 status = nfs_ok;
693out:
694 return status;
557ce264
AA		 695out_free:
696 free_session_slots(new);
697 kfree(new);
698 goto out;
ec6b5d7b
AA		 699}
700
9089f1b4 701/* caller must hold client_lock */
5282fd72
ME		 702static struct nfsd4_session *
703find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
704{
705 struct nfsd4_session *elem;
706 int idx;
707
708 dump_sessionid(__func__, sessionid);
709 idx = hash_sessionid(sessionid);
5282fd72
ME		 710 /* Search in the appropriate list */
711 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
5282fd72
ME		 712 if (!memcmp(elem->se_sessionid.data, sessionid->data,
713 NFS4_MAX_SESSIONID_LEN)) {
714 return elem;
715 }
716 }
717
718 dprintk("%s: session not found\n", __func__);
719 return NULL;
720}
721
9089f1b4 722/* caller must hold client_lock */
7116ed6b 723static void
5282fd72 724unhash_session(struct nfsd4_session *ses)
7116ed6b
AA		 725{
726 list_del(&ses->se_hash);
727 list_del(&ses->se_perclnt);
5282fd72
ME		 728}
729
7116ed6b
AA		 730void
731free_session(struct kref *kref)
732{
733 struct nfsd4_session *ses;
dd829c45 734 int mem;
7116ed6b
AA		 735
736 ses = container_of(kref, struct nfsd4_session, se_ref);
be98d1bb 737 spin_lock(&nfsd_drc_lock);
efe0cb6d 738 mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
dd829c45 739 nfsd_drc_mem_used -= mem;
be98d1bb 740 spin_unlock(&nfsd_drc_lock);
557ce264 741 free_session_slots(ses);
7116ed6b
AA		 742 kfree(ses);
743}
744
36acb66b 745/* must be called under the client_lock */
1da177e4 746static inline void
36acb66b 747renew_client_locked(struct nfs4_client *clp)
1da177e4 748{
07cd4909
BH		 749 if (is_client_expired(clp)) {
750 dprintk("%s: client (clientid %08x/%08x) already expired\n",
751 __func__,
752 clp->cl_clientid.cl_boot,
753 clp->cl_clientid.cl_id);
754 return;
755 }
756
1da177e4
LT		 757 /*
758 * Move client to the end to the LRU list.
759 */
760 dprintk("renewing client (clientid %08x/%08x)\n",
761 clp->cl_clientid.cl_boot,
762 clp->cl_clientid.cl_id);
763 list_move_tail(&clp->cl_lru, &client_lru);
764 clp->cl_time = get_seconds();
765}
766
36acb66b
BH		 767static inline void
768renew_client(struct nfs4_client *clp)
769{
770 spin_lock(&client_lock);
771 renew_client_locked(clp);
772 spin_unlock(&client_lock);
773}
774
1da177e4
LT		 775/* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
776static int
777STALE_CLIENTID(clientid_t *clid)
778{
779 if (clid->cl_boot == boot_time)
780 return 0;
60adfc50
AA		 781 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
782 clid->cl_boot, clid->cl_id, boot_time);
1da177e4
LT		 783 return 1;
784}
785
786/*
787 * XXX Should we use a slab cache ?
788 * This type of memory management is somewhat inefficient, but we use it
789 * anyway since SETCLIENTID is not a common operation.
790 */
35bba9a3 791static struct nfs4_client *alloc_client(struct xdr_netobj name)
1da177e4
LT		 792{
793 struct nfs4_client *clp;
794
35bba9a3
BF		 795 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
796 if (clp == NULL)
797 return NULL;
798 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
799 if (clp->cl_name.data == NULL) {
800 kfree(clp);
801 return NULL;
1da177e4 802 }
35bba9a3
BF		 803 memcpy(clp->cl_name.data, name.data, name.len);
804 clp->cl_name.len = name.len;
1da177e4
LT		 805 return clp;
806}
807
808static inline void
809free_client(struct nfs4_client *clp)
810{
811 if (clp->cl_cred.cr_group_info)
812 put_group_info(clp->cl_cred.cr_group_info);
68e76ad0 813 kfree(clp->cl_principal);
1da177e4
LT		 814 kfree(clp->cl_name.data);
815 kfree(clp);
816}
817
d7682988
BH		 818void
819release_session_client(struct nfsd4_session *session)
820{
821 struct nfs4_client *clp = session->se_client;
822
823 if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
824 return;
825 if (is_client_expired(clp)) {
826 free_client(clp);
827 session->se_client = NULL;
828 } else
829 renew_client_locked(clp);
830 spin_unlock(&client_lock);
d7682988
BH		 831}
832
84d38ac9
BH		 833/* must be called under the client_lock */
834static inline void
835unhash_client_locked(struct nfs4_client *clp)
836{
07cd4909 837 mark_client_expired(clp);
84d38ac9
BH		 838 list_del(&clp->cl_lru);
839 while (!list_empty(&clp->cl_sessions)) {
840 struct nfsd4_session *ses;
841 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
842 se_perclnt);
843 unhash_session(ses);
844 nfsd4_put_session(ses);
845 }
846}
847
1da177e4
LT		 848static void
849expire_client(struct nfs4_client *clp)
850{
851 struct nfs4_stateowner *sop;
852 struct nfs4_delegation *dp;
1da177e4
LT		 853 struct list_head reaplist;
854
1da177e4
LT		 855 INIT_LIST_HEAD(&reaplist);
856 spin_lock(&recall_lock);
ea1da636
N		 857 while (!list_empty(&clp->cl_delegations)) {
858 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
1da177e4
LT		 859 dprintk("NFSD: expire client. dp %p, fp %p\n", dp,
860 dp->dl_flock);
ea1da636 861 list_del_init(&dp->dl_perclnt);
1da177e4
LT		 862 list_move(&dp->dl_recall_lru, &reaplist);
863 }
864 spin_unlock(&recall_lock);
865 while (!list_empty(&reaplist)) {
866 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
867 list_del_init(&dp->dl_recall_lru);
868 unhash_delegation(dp);
869 }
ea1da636
N		 870 while (!list_empty(&clp->cl_openowners)) {
871 sop = list_entry(clp->cl_openowners.next, struct nfs4_stateowner, so_perclient);
f044ff83 872 release_openowner(sop);
1da177e4 873 }
6ff8da08 874 nfsd4_shutdown_callback(clp);
84d38ac9
BH		 875 if (clp->cl_cb_conn.cb_xprt)
876 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
36acb66b
BH		 877 list_del(&clp->cl_idhash);
878 list_del(&clp->cl_strhash);
be1fdf6c 879 spin_lock(&client_lock);
84d38ac9 880 unhash_client_locked(clp);
46583e25
BH		 881 if (atomic_read(&clp->cl_refcount) == 0)
882 free_client(clp);
be1fdf6c 883 spin_unlock(&client_lock);
1da177e4
LT		 884}
885
35bba9a3
BF		 886static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
887{
888 memcpy(target->cl_verifier.data, source->data,
889 sizeof(target->cl_verifier.data));
1da177e4
LT		 890}
891
35bba9a3
BF		 892static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
893{
1da177e4
LT		 894 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
895 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
896}
897
35bba9a3
BF		 898static void copy_cred(struct svc_cred *target, struct svc_cred *source)
899{
1da177e4
LT		 900 target->cr_uid = source->cr_uid;
901 target->cr_gid = source->cr_gid;
902 target->cr_group_info = source->cr_group_info;
903 get_group_info(target->cr_group_info);
904}
905
35bba9a3 906static int same_name(const char *n1, const char *n2)
599e0a22 907{
a55370a3 908 return 0 == memcmp(n1, n2, HEXDIR_LEN);
1da177e4
LT		 909}
910
911static int
599e0a22
BF		 912same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
913{
914 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1da177e4
LT		 915}
916
917static int
599e0a22
BF		 918same_clid(clientid_t *cl1, clientid_t *cl2)
919{
920 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1da177e4
LT		 921}
922
923/* XXX what about NGROUP */
924static int
599e0a22
BF		 925same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
926{
927 return cr1->cr_uid == cr2->cr_uid;
1da177e4
LT		 928}
929
5ec7b46c
BF		 930static void gen_clid(struct nfs4_client *clp)
931{
932 static u32 current_clientid = 1;
933
1da177e4
LT		 934 clp->cl_clientid.cl_boot = boot_time;
935 clp->cl_clientid.cl_id = current_clientid++;
936}
937
deda2faa
BF		 938static void gen_confirm(struct nfs4_client *clp)
939{
940 static u32 i;
941 u32 *p;
1da177e4 942
1da177e4 943 p = (u32 *)clp->cl_confirm.data;
deda2faa
BF		 944 *p++ = get_seconds();
945 *p++ = i++;
1da177e4
LT		 946}
947
b09333c4
RL		 948static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
949 struct svc_rqst *rqstp, nfs4_verifier *verf)
950{
951 struct nfs4_client *clp;
952 struct sockaddr *sa = svc_addr(rqstp);
953 char *princ;
954
955 clp = alloc_client(name);
956 if (clp == NULL)
957 return NULL;
958
959 princ = svc_gss_principal(rqstp);
960 if (princ) {
961 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
962 if (clp->cl_principal == NULL) {
963 free_client(clp);
964 return NULL;
965 }
966 }
967
968 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
46583e25 969 atomic_set(&clp->cl_refcount, 0);
2bf23875 970 atomic_set(&clp->cl_cb_set, 0);
b09333c4
RL		 971 INIT_LIST_HEAD(&clp->cl_idhash);
972 INIT_LIST_HEAD(&clp->cl_strhash);
973 INIT_LIST_HEAD(&clp->cl_openowners);
974 INIT_LIST_HEAD(&clp->cl_delegations);
975 INIT_LIST_HEAD(&clp->cl_sessions);
976 INIT_LIST_HEAD(&clp->cl_lru);
6ff8da08 977 spin_lock_init(&clp->cl_lock);
cee277d9 978 INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
07cd4909 979 clp->cl_time = get_seconds();
b09333c4
RL		 980 clear_bit(0, &clp->cl_cb_slot_busy);
981 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
982 copy_verf(clp, verf);
983 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
984 clp->cl_flavor = rqstp->rq_flavor;
985 copy_cred(&clp->cl_cred, &rqstp->rq_cred);
986 gen_confirm(clp);
987
988 return clp;
989}
990
35bba9a3
BF		 991static int check_name(struct xdr_netobj name)
992{
1da177e4
LT		 993 if (name.len == 0)
994 return 0;
995 if (name.len > NFS4_OPAQUE_LIMIT) {
2fdada03 996 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
1da177e4
LT		 997 return 0;
998 }
999 return 1;
1000}
1001
fd39ca9a 1002static void
1da177e4
LT		 1003add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1004{
1005 unsigned int idhashval;
1006
1007 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1008 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1009 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
36acb66b 1010 renew_client(clp);
1da177e4
LT		 1011}
1012
fd39ca9a 1013static void
1da177e4
LT		 1014move_to_confirmed(struct nfs4_client *clp)
1015{
1016 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1017 unsigned int strhashval;
1018
1019 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
f116629d 1020 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
a55370a3 1021 strhashval = clientstr_hashval(clp->cl_recdir);
328efbab 1022 list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
1da177e4
LT		 1023 renew_client(clp);
1024}
1025
1026static struct nfs4_client *
1027find_confirmed_client(clientid_t *clid)
1028{
1029 struct nfs4_client *clp;
1030 unsigned int idhashval = clientid_hashval(clid->cl_id);
1031
1032 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
599e0a22 1033 if (same_clid(&clp->cl_clientid, clid))
1da177e4
LT		 1034 return clp;
1035 }
1036 return NULL;
1037}
1038
1039static struct nfs4_client *
1040find_unconfirmed_client(clientid_t *clid)
1041{
1042 struct nfs4_client *clp;
1043 unsigned int idhashval = clientid_hashval(clid->cl_id);
1044
1045 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
599e0a22 1046 if (same_clid(&clp->cl_clientid, clid))
1da177e4
LT		 1047 return clp;
1048 }
1049 return NULL;
1050}
1051
a1bcecd2
AA		 1052/*
1053 * Return 1 iff clp's clientid establishment method matches the use_exchange_id
1054 * parameter. Matching is based on the fact the at least one of the
1055 * EXCHGID4_FLAG_USE_{NON_PNFS,PNFS_MDS,PNFS_DS} flags must be set for v4.1
1056 *
1057 * FIXME: we need to unify the clientid namespaces for nfsv4.x
1058 * and correctly deal with client upgrade/downgrade in EXCHANGE_ID
1059 * and SET_CLIENTID{,_CONFIRM}
1060 */
1061static inline int
1062match_clientid_establishment(struct nfs4_client *clp, bool use_exchange_id)
1063{
1064 bool has_exchange_flags = (clp->cl_exchange_flags != 0);
1065 return use_exchange_id == has_exchange_flags;
1066}
1067
28ce6054 1068static struct nfs4_client *
a1bcecd2
AA		 1069find_confirmed_client_by_str(const char *dname, unsigned int hashval,
1070 bool use_exchange_id)
28ce6054
N		 1071{
1072 struct nfs4_client *clp;
1073
1074 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
a1bcecd2
AA		 1075 if (same_name(clp->cl_recdir, dname) &&
1076 match_clientid_establishment(clp, use_exchange_id))
28ce6054
N		 1077 return clp;
1078 }
1079 return NULL;
1080}
1081
1082static struct nfs4_client *
a1bcecd2
AA		 1083find_unconfirmed_client_by_str(const char *dname, unsigned int hashval,
1084 bool use_exchange_id)
28ce6054
N		 1085{
1086 struct nfs4_client *clp;
1087
1088 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
a1bcecd2
AA		 1089 if (same_name(clp->cl_recdir, dname) &&
1090 match_clientid_establishment(clp, use_exchange_id))
28ce6054
N		 1091 return clp;
1092 }
1093 return NULL;
1094}
1095
fd39ca9a 1096static void
fbf4665f 1097gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, u32 scopeid)
1da177e4 1098{
07263f1e 1099 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
7077ecba
JL		 1100 unsigned short expected_family;
1101
1102 /* Currently, we only support tcp and tcp6 for the callback channel */
1103 if (se->se_callback_netid_len == 3 &&
1104 !memcmp(se->se_callback_netid_val, "tcp", 3))
1105 expected_family = AF_INET;
1106 else if (se->se_callback_netid_len == 4 &&
1107 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1108 expected_family = AF_INET6;
1109 else
1da177e4
LT		 1110 goto out_err;
1111
07263f1e 1112 conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
aa9a4ec7 1113 se->se_callback_addr_len,
07263f1e
BF		 1114 (struct sockaddr *)&conn->cb_addr,
1115 sizeof(conn->cb_addr));
aa9a4ec7 1116
07263f1e 1117 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1da177e4 1118 goto out_err;
aa9a4ec7 1119
07263f1e
BF		 1120 if (conn->cb_addr.ss_family == AF_INET6)
1121 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
fbf4665f 1122
07263f1e
BF		 1123 conn->cb_minorversion = 0;
1124 conn->cb_prog = se->se_callback_prog;
1125 conn->cb_ident = se->se_callback_ident;
1da177e4
LT		 1126 return;
1127out_err:
07263f1e
BF		 1128 conn->cb_addr.ss_family = AF_UNSPEC;
1129 conn->cb_addrlen = 0;
849823c5 1130 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1da177e4
LT		 1131 "will not receive delegations\n",
1132 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1133
1da177e4
LT		 1134 return;
1135}
1136
074fe897 1137/*
557ce264 1138 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
074fe897 1139 */
074fe897
AA		 1140void
1141nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
074fe897 1142{
557ce264
AA		 1143 struct nfsd4_slot *slot = resp->cstate.slot;
1144 unsigned int base;
074fe897 1145
557ce264 1146 dprintk("--> %s slot %p\n", __func__, slot);
074fe897 1147
557ce264
AA		 1148 slot->sl_opcnt = resp->opcnt;
1149 slot->sl_status = resp->cstate.status;
074fe897 1150
bf864a31 1151 if (nfsd4_not_cached(resp)) {
557ce264 1152 slot->sl_datalen = 0;
bf864a31 1153 return;
074fe897 1154 }
557ce264
AA		 1155 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1156 base = (char *)resp->cstate.datap -
1157 (char *)resp->xbuf->head[0].iov_base;
1158 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1159 slot->sl_datalen))
1160 WARN("%s: sessions DRC could not cache compound\n", __func__);
1161 return;
074fe897
AA		 1162}
1163
1164/*
abfabf8c
AA		 1165 * Encode the replay sequence operation from the slot values.
1166 * If cachethis is FALSE encode the uncached rep error on the next
1167 * operation which sets resp->p and increments resp->opcnt for
1168 * nfs4svc_encode_compoundres.
074fe897 1169 *
074fe897 1170 */
abfabf8c
AA		 1171static __be32
1172nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1173 struct nfsd4_compoundres *resp)
074fe897 1174{
abfabf8c
AA		 1175 struct nfsd4_op *op;
1176 struct nfsd4_slot *slot = resp->cstate.slot;
bf864a31 1177
abfabf8c 1178 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
557ce264 1179 resp->opcnt, resp->cstate.slot->sl_cachethis);
bf864a31 1180
abfabf8c
AA		 1181 /* Encode the replayed sequence operation */
1182 op = &args->ops[resp->opcnt - 1];
1183 nfsd4_encode_operation(resp, op);
bf864a31 1184
abfabf8c 1185 /* Return nfserr_retry_uncached_rep in next operation. */
557ce264 1186 if (args->opcnt > 1 && slot->sl_cachethis == 0) {
abfabf8c
AA		 1187 op = &args->ops[resp->opcnt++];
1188 op->status = nfserr_retry_uncached_rep;
1189 nfsd4_encode_operation(resp, op);
074fe897 1190 }
abfabf8c 1191 return op->status;
074fe897
AA		 1192}
1193
1194/*
557ce264
AA		 1195 * The sequence operation is not cached because we can use the slot and
1196 * session values.
074fe897
AA		 1197 */
1198__be32
bf864a31
AA		 1199nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1200 struct nfsd4_sequence *seq)
074fe897 1201{
557ce264 1202 struct nfsd4_slot *slot = resp->cstate.slot;
074fe897
AA		 1203 __be32 status;
1204
557ce264 1205 dprintk("--> %s slot %p\n", __func__, slot);
074fe897 1206
abfabf8c
AA		 1207 /* Either returns 0 or nfserr_retry_uncached */
1208 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1209 if (status == nfserr_retry_uncached_rep)
1210 return status;
074fe897 1211
557ce264
AA		 1212 /* The sequence operation has been encoded, cstate->datap set. */
1213 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
074fe897 1214
557ce264
AA		 1215 resp->opcnt = slot->sl_opcnt;
1216 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1217 status = slot->sl_status;
074fe897
AA		 1218
1219 return status;
1220}
1221
0733d213
AA		 1222/*
1223 * Set the exchange_id flags returned by the server.
1224 */
1225static void
1226nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1227{
1228 /* pNFS is not supported */
1229 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1230
1231 /* Referrals are supported, Migration is not. */
1232 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1233
1234 /* set the wire flags to return to client. */
1235 clid->flags = new->cl_exchange_flags;
1236}
1237
069b6ad4
AA		 1238__be32
1239nfsd4_exchange_id(struct svc_rqst *rqstp,
1240 struct nfsd4_compound_state *cstate,
1241 struct nfsd4_exchange_id *exid)
1242{
0733d213
AA		 1243 struct nfs4_client *unconf, *conf, *new;
1244 int status;
1245 unsigned int strhashval;
1246 char dname[HEXDIR_LEN];
363168b4 1247 char addr_str[INET6_ADDRSTRLEN];
0733d213 1248 nfs4_verifier verf = exid->verifier;
363168b4 1249 struct sockaddr *sa = svc_addr(rqstp);
0733d213 1250
363168b4 1251 rpc_ntop(sa, addr_str, sizeof(addr_str));
0733d213 1252 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
363168b4 1253 "ip_addr=%s flags %x, spa_how %d\n",
0733d213 1254 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
363168b4 1255 addr_str, exid->flags, exid->spa_how);
0733d213
AA		 1256
1257 if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1258 return nfserr_inval;
1259
1260 /* Currently only support SP4_NONE */
1261 switch (exid->spa_how) {
1262 case SP4_NONE:
1263 break;
1264 case SP4_SSV:
1265 return nfserr_encr_alg_unsupp;
1266 default:
1267 BUG(); /* checked by xdr code */
1268 case SP4_MACH_CRED:
1269 return nfserr_serverfault; /* no excuse :-/ */
1270 }
1271
1272 status = nfs4_make_rec_clidname(dname, &exid->clname);
1273
1274 if (status)
1275 goto error;
1276
1277 strhashval = clientstr_hashval(dname);
1278
1279 nfs4_lock_state();
1280 status = nfs_ok;
1281
a1bcecd2 1282 conf = find_confirmed_client_by_str(dname, strhashval, true);
0733d213
AA		 1283 if (conf) {
1284 if (!same_verf(&verf, &conf->cl_verifier)) {
1285 /* 18.35.4 case 8 */
1286 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1287 status = nfserr_not_same;
1288 goto out;
1289 }
1290 /* Client reboot: destroy old state */
1291 expire_client(conf);
1292 goto out_new;
1293 }
1294 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1295 /* 18.35.4 case 9 */
1296 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1297 status = nfserr_perm;
1298 goto out;
1299 }
1300 expire_client(conf);
1301 goto out_new;
1302 }
0733d213
AA		 1303 /*
1304 * Set bit when the owner id and verifier map to an already
1305 * confirmed client id (18.35.3).
1306 */
1307 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1308
1309 /*
1310 * Falling into 18.35.4 case 2, possible router replay.
1311 * Leave confirmed record intact and return same result.
1312 */
1313 copy_verf(conf, &verf);
1314 new = conf;
1315 goto out_copy;
6ddbbbfe
MS		 1316 }
1317
1318 /* 18.35.4 case 7 */
1319 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1320 status = nfserr_noent;
1321 goto out;
0733d213
AA		 1322 }
1323
a1bcecd2 1324 unconf = find_unconfirmed_client_by_str(dname, strhashval, true);
0733d213
AA		 1325 if (unconf) {
1326 /*
1327 * Possible retry or client restart. Per 18.35.4 case 4,
1328 * a new unconfirmed record should be generated regardless
1329 * of whether any properties have changed.
1330 */
1331 expire_client(unconf);
1332 }
1333
1334out_new:
1335 /* Normal case */
b09333c4 1336 new = create_client(exid->clname, dname, rqstp, &verf);
0733d213 1337 if (new == NULL) {
4731030d 1338 status = nfserr_jukebox;
0733d213
AA		 1339 goto out;
1340 }
1341
0733d213 1342 gen_clid(new);
0733d213
AA		 1343 add_to_unconfirmed(new, strhashval);
1344out_copy:
1345 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1346 exid->clientid.cl_id = new->cl_clientid.cl_id;
1347
38eb76a5 1348 exid->seqid = 1;
0733d213
AA		 1349 nfsd4_set_ex_flags(new, exid);
1350
1351 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
49557cc7 1352 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
0733d213
AA		 1353 status = nfs_ok;
1354
1355out:
1356 nfs4_unlock_state();
1357error:
1358 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1359 return status;
069b6ad4
AA		 1360}
1361
b85d4c01 1362static int
88e588d5 1363check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
b85d4c01 1364{
88e588d5
AA		 1365 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1366 slot_seqid);
b85d4c01
BH		 1367
1368 /* The slot is in use, and no response has been sent. */
88e588d5
AA		 1369 if (slot_inuse) {
1370 if (seqid == slot_seqid)
b85d4c01
BH		 1371 return nfserr_jukebox;
1372 else
1373 return nfserr_seq_misordered;
1374 }
1375 /* Normal */
88e588d5 1376 if (likely(seqid == slot_seqid + 1))
b85d4c01
BH		 1377 return nfs_ok;
1378 /* Replay */
88e588d5 1379 if (seqid == slot_seqid)
b85d4c01
BH		 1380 return nfserr_replay_cache;
1381 /* Wraparound */
88e588d5 1382 if (seqid == 1 && (slot_seqid + 1) == 0)
b85d4c01
BH		 1383 return nfs_ok;
1384 /* Misordered replay or misordered new request */
1385 return nfserr_seq_misordered;
1386}
1387
49557cc7
AA		 1388/*
1389 * Cache the create session result into the create session single DRC
1390 * slot cache by saving the xdr structure. sl_seqid has been set.
1391 * Do this for solo or embedded create session operations.
1392 */
1393static void
1394nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1395 struct nfsd4_clid_slot *slot, int nfserr)
1396{
1397 slot->sl_status = nfserr;
1398 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1399}
1400
1401static __be32
1402nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1403 struct nfsd4_clid_slot *slot)
1404{
1405 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1406 return slot->sl_status;
1407}
1408
069b6ad4
AA		 1409__be32
1410nfsd4_create_session(struct svc_rqst *rqstp,
1411 struct nfsd4_compound_state *cstate,
1412 struct nfsd4_create_session *cr_ses)
1413{
363168b4 1414 struct sockaddr *sa = svc_addr(rqstp);
ec6b5d7b 1415 struct nfs4_client *conf, *unconf;
49557cc7 1416 struct nfsd4_clid_slot *cs_slot = NULL;
ec6b5d7b
AA		 1417 int status = 0;
1418
1419 nfs4_lock_state();
1420 unconf = find_unconfirmed_client(&cr_ses->clientid);
1421 conf = find_confirmed_client(&cr_ses->clientid);
1422
1423 if (conf) {
49557cc7
AA		 1424 cs_slot = &conf->cl_cs_slot;
1425 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
38eb76a5 1426 if (status == nfserr_replay_cache) {
ec6b5d7b 1427 dprintk("Got a create_session replay! seqid= %d\n",
49557cc7 1428 cs_slot->sl_seqid);
38eb76a5 1429 /* Return the cached reply status */
49557cc7 1430 status = nfsd4_replay_create_session(cr_ses, cs_slot);
38eb76a5 1431 goto out;
49557cc7 1432 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
ec6b5d7b
AA		 1433 status = nfserr_seq_misordered;
1434 dprintk("Sequence misordered!\n");
1435 dprintk("Expected seqid= %d but got seqid= %d\n",
49557cc7 1436 cs_slot->sl_seqid, cr_ses->seqid);
ec6b5d7b
AA		 1437 goto out;
1438 }
49557cc7 1439 cs_slot->sl_seqid++;
ec6b5d7b
AA		 1440 } else if (unconf) {
1441 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
363168b4 1442 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
ec6b5d7b
AA		 1443 status = nfserr_clid_inuse;
1444 goto out;
1445 }
1446
49557cc7
AA		 1447 cs_slot = &unconf->cl_cs_slot;
1448 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
38eb76a5
AA		 1449 if (status) {
1450 /* an unconfirmed replay returns misordered */
ec6b5d7b 1451 status = nfserr_seq_misordered;
49557cc7 1452 goto out_cache;
ec6b5d7b
AA		 1453 }
1454
49557cc7 1455 cs_slot->sl_seqid++; /* from 0 to 1 */
ec6b5d7b
AA		 1456 move_to_confirmed(unconf);
1457
38524ab3 1458 if (cr_ses->flags & SESSION4_BACK_CHAN) {
2bf23875
BF		 1459 unconf->cl_cb_conn.cb_xprt = rqstp->rq_xprt;
1460 svc_xprt_get(rqstp->rq_xprt);
38524ab3
AA		 1461 rpc_copy_addr(
1462 (struct sockaddr *)&unconf->cl_cb_conn.cb_addr,
1463 sa);
1464 unconf->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1465 unconf->cl_cb_conn.cb_minorversion =
1466 cstate->minorversion;
1467 unconf->cl_cb_conn.cb_prog = cr_ses->callback_prog;
2a1d1b59 1468 unconf->cl_cb_seq_nr = 1;
4b21d0de 1469 nfsd4_probe_callback(unconf, &unconf->cl_cb_conn);
38524ab3 1470 }
ec6b5d7b
AA		 1471 conf = unconf;
1472 } else {
1473 status = nfserr_stale_clientid;
1474 goto out;
1475 }
1476
408b79bc
BF		 1477 /*
1478 * We do not support RDMA or persistent sessions
1479 */
1480 cr_ses->flags &= ~SESSION4_PERSIST;
1481 cr_ses->flags &= ~SESSION4_RDMA;
1482
ec6b5d7b
AA		 1483 status = alloc_init_session(rqstp, conf, cr_ses);
1484 if (status)
1485 goto out;
1486
ec6b5d7b
AA		 1487 memcpy(cr_ses->sessionid.data, conf->cl_sessionid.data,
1488 NFS4_MAX_SESSIONID_LEN);
49557cc7 1489 cr_ses->seqid = cs_slot->sl_seqid;
ec6b5d7b 1490
49557cc7
AA		 1491out_cache:
1492 /* cache solo and embedded create sessions under the state lock */
1493 nfsd4_cache_create_session(cr_ses, cs_slot, status);
ec6b5d7b
AA		 1494out:
1495 nfs4_unlock_state();
1496 dprintk("%s returns %d\n", __func__, ntohl(status));
1497 return status;
069b6ad4
AA		 1498}
1499
57716355
BF		 1500static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1501{
1502 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1503 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1504
1505 return argp->opcnt == resp->opcnt;
1506}
1507
5d4cec2f
BF		 1508static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1509{
1510 if (!session)
1511 return 0;
1512 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1513}
1514
069b6ad4
AA		 1515__be32
1516nfsd4_destroy_session(struct svc_rqst *r,
1517 struct nfsd4_compound_state *cstate,
1518 struct nfsd4_destroy_session *sessionid)
1519{
e10e0cfc
BH		 1520 struct nfsd4_session *ses;
1521 u32 status = nfserr_badsession;
1522
1523 /* Notes:
1524 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1525 * - Should we return nfserr_back_chan_busy if waiting for
1526 * callbacks on to-be-destroyed session?
1527 * - Do we need to clear any callback info from previous session?
1528 */
1529
5d4cec2f 1530 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
57716355
BF		 1531 if (!nfsd4_last_compound_op(r))
1532 return nfserr_not_only_op;
1533 }
e10e0cfc 1534 dump_sessionid(__func__, &sessionid->sessionid);
9089f1b4 1535 spin_lock(&client_lock);
e10e0cfc
BH		 1536 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1537 if (!ses) {
9089f1b4 1538 spin_unlock(&client_lock);
e10e0cfc
BH		 1539 goto out;
1540 }
1541
1542 unhash_session(ses);
9089f1b4 1543 spin_unlock(&client_lock);
e10e0cfc 1544
ab707e15 1545 nfs4_lock_state();
e10e0cfc 1546 /* wait for callbacks */
6ff8da08 1547 nfsd4_shutdown_callback(ses->se_client);
ab707e15 1548 nfs4_unlock_state();
e10e0cfc
BH		 1549 nfsd4_put_session(ses);
1550 status = nfs_ok;
1551out:
1552 dprintk("%s returns %d\n", __func__, ntohl(status));
1553 return status;
069b6ad4
AA		 1554}
1555
1556__be32
b85d4c01 1557nfsd4_sequence(struct svc_rqst *rqstp,
069b6ad4
AA		 1558 struct nfsd4_compound_state *cstate,
1559 struct nfsd4_sequence *seq)
1560{
f9bb94c4 1561 struct nfsd4_compoundres *resp = rqstp->rq_resp;
b85d4c01
BH		 1562 struct nfsd4_session *session;
1563 struct nfsd4_slot *slot;
1564 int status;
1565
f9bb94c4
AA		 1566 if (resp->opcnt != 1)
1567 return nfserr_sequence_pos;
1568
9089f1b4 1569 spin_lock(&client_lock);
b85d4c01
BH		 1570 status = nfserr_badsession;
1571 session = find_in_sessionid_hashtbl(&seq->sessionid);
1572 if (!session)
1573 goto out;
1574
1575 status = nfserr_badslot;
6c18ba9f 1576 if (seq->slotid >= session->se_fchannel.maxreqs)
b85d4c01
BH		 1577 goto out;
1578
557ce264 1579 slot = session->se_slots[seq->slotid];
b85d4c01
BH		 1580 dprintk("%s: slotid %d\n", __func__, seq->slotid);
1581
a8dfdaeb
AA		 1582 /* We do not negotiate the number of slots yet, so set the
1583 * maxslots to the session maxreqs which is used to encode
1584 * sr_highest_slotid and the sr_target_slot id to maxslots */
1585 seq->maxslots = session->se_fchannel.maxreqs;
1586
88e588d5 1587 status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
b85d4c01
BH		 1588 if (status == nfserr_replay_cache) {
1589 cstate->slot = slot;
1590 cstate->session = session;
da3846a2 1591 /* Return the cached reply status and set cstate->status
557ce264 1592 * for nfsd4_proc_compound processing */
bf864a31 1593 status = nfsd4_replay_cache_entry(resp, seq);
da3846a2 1594 cstate->status = nfserr_replay_cache;
aaf84eb9 1595 goto out;
b85d4c01
BH		 1596 }
1597 if (status)
1598 goto out;
1599
1600 /* Success! bump slot seqid */
1601 slot->sl_inuse = true;
1602 slot->sl_seqid = seq->seqid;
557ce264 1603 slot->sl_cachethis = seq->cachethis;
b85d4c01
BH		 1604
1605 cstate->slot = slot;
1606 cstate->session = session;
1607
b85d4c01 1608out:
26c0c75e 1609 /* Hold a session reference until done processing the compound. */
aaf84eb9 1610 if (cstate->session) {
36acb66b 1611 nfsd4_get_session(cstate->session);
d7682988 1612 atomic_inc(&session->se_client->cl_refcount);
aaf84eb9 1613 }
36acb66b 1614 spin_unlock(&client_lock);
b85d4c01
BH		 1615 dprintk("%s: return %d\n", __func__, ntohl(status));
1616 return status;
069b6ad4
AA		 1617}
1618
4dc6ec00
BF		 1619__be32
1620nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1621{
1622 if (rc->rca_one_fs) {
1623 if (!cstate->current_fh.fh_dentry)
1624 return nfserr_nofilehandle;
1625 /*
1626 * We don't take advantage of the rca_one_fs case.
1627 * That's OK, it's optional, we can safely ignore it.
1628 */
1629 return nfs_ok;
1630 }
1631 nfs4_lock_state();
1632 if (is_client_expired(cstate->session->se_client)) {
1633 nfs4_unlock_state();
1634 /*
1635 * The following error isn't really legal.
1636 * But we only get here if the client just explicitly
1637 * destroyed the client. Surely it no longer cares what
1638 * error it gets back on an operation for the dead
1639 * client.
1640 */
1641 return nfserr_stale_clientid;
1642 }
1643 nfsd4_create_clid_dir(cstate->session->se_client);
1644 nfs4_unlock_state();
1645 return nfs_ok;
1646}
1647
b37ad28b 1648__be32
b591480b
BF		 1649nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1650 struct nfsd4_setclientid *setclid)
1da177e4 1651{
363168b4 1652 struct sockaddr *sa = svc_addr(rqstp);
1da177e4
LT		 1653 struct xdr_netobj clname = {
1654 .len = setclid->se_namelen,
1655 .data = setclid->se_name,
1656 };
1657 nfs4_verifier clverifier = setclid->se_verf;
1658 unsigned int strhashval;
28ce6054 1659 struct nfs4_client *conf, *unconf, *new;
b37ad28b 1660 __be32 status;
a55370a3 1661 char dname[HEXDIR_LEN];
1da177e4 1662
1da177e4 1663 if (!check_name(clname))
73aea4ec 1664 return nfserr_inval;
1da177e4 1665
a55370a3
N		 1666 status = nfs4_make_rec_clidname(dname, &clname);
1667 if (status)
73aea4ec 1668 return status;
a55370a3 1669
1da177e4
LT		 1670 /*
1671 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1672 * We get here on a DRC miss.
1673 */
1674
a55370a3 1675 strhashval = clientstr_hashval(dname);
1da177e4 1676
1da177e4 1677 nfs4_lock_state();
a1bcecd2 1678 conf = find_confirmed_client_by_str(dname, strhashval, false);
28ce6054 1679 if (conf) {
a186e767 1680 /* RFC 3530 14.2.33 CASE 0: */
1da177e4 1681 status = nfserr_clid_inuse;
026722c2 1682 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
363168b4
JL		 1683 char addr_str[INET6_ADDRSTRLEN];
1684 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1685 sizeof(addr_str));
1686 dprintk("NFSD: setclientid: string in use by client "
1687 "at %s\n", addr_str);
1da177e4
LT		 1688 goto out;
1689 }
1da177e4 1690 }
a186e767
BF		 1691 /*
1692 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1693 * has a description of SETCLIENTID request processing consisting
1694 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1695 */
a1bcecd2 1696 unconf = find_unconfirmed_client_by_str(dname, strhashval, false);
1da177e4
LT		 1697 status = nfserr_resource;
1698 if (!conf) {
a186e767
BF		 1699 /*
1700 * RFC 3530 14.2.33 CASE 4:
1701 * placed first, because it is the normal case
1da177e4
LT		 1702 */
1703 if (unconf)
1704 expire_client(unconf);
b09333c4 1705 new = create_client(clname, dname, rqstp, &clverifier);
a55370a3 1706 if (new == NULL)
1da177e4 1707 goto out;
1da177e4 1708 gen_clid(new);
599e0a22 1709 } else if (same_verf(&conf->cl_verifier, &clverifier)) {
1da177e4 1710 /*
a186e767
BF		 1711 * RFC 3530 14.2.33 CASE 1:
1712 * probable callback update
1da177e4 1713 */
31f4a6c1
N		 1714 if (unconf) {
1715 /* Note this is removing unconfirmed {*x***},
1716 * which is stronger than RFC recommended {vxc**}.
1717 * This has the advantage that there is at most
1718 * one {*x***} in either list at any time.
1719 */
1720 expire_client(unconf);
1da177e4 1721 }
b09333c4 1722 new = create_client(clname, dname, rqstp, &clverifier);
a55370a3 1723 if (new == NULL)
1da177e4 1724 goto out;
1da177e4 1725 copy_clid(new, conf);
1da177e4
LT		 1726 } else if (!unconf) {
1727 /*
a186e767
BF		 1728 * RFC 3530 14.2.33 CASE 2:
1729 * probable client reboot; state will be removed if
1730 * confirmed.
1da177e4 1731 */
b09333c4 1732 new = create_client(clname, dname, rqstp, &clverifier);
a55370a3 1733 if (new == NULL)
1da177e4 1734 goto out;
1da177e4 1735 gen_clid(new);
49ba8781 1736 } else {
a186e767
BF		 1737 /*
1738 * RFC 3530 14.2.33 CASE 3:
1739 * probable client reboot; state will be removed if
1740 * confirmed.
1da177e4
LT		 1741 */
1742 expire_client(unconf);
b09333c4 1743 new = create_client(clname, dname, rqstp, &clverifier);
a55370a3 1744 if (new == NULL)
1da177e4 1745 goto out;
1da177e4 1746 gen_clid(new);
1da177e4 1747 }
fbf4665f 1748 gen_callback(new, setclid, rpc_get_scope_id(sa));
c175b83c 1749 add_to_unconfirmed(new, strhashval);
1da177e4
LT		 1750 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
1751 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
1752 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
1753 status = nfs_ok;
1754out:
1755 nfs4_unlock_state();
1756 return status;
1757}
1758
1759
1760/*
a186e767
BF		 1761 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
1762 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
1763 * bullets, labeled as CASE1 - CASE4 below.
1da177e4 1764 */
b37ad28b 1765__be32
b591480b
BF		 1766nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
1767 struct nfsd4_compound_state *cstate,
1768 struct nfsd4_setclientid_confirm *setclientid_confirm)
1da177e4 1769{
363168b4 1770 struct sockaddr *sa = svc_addr(rqstp);
21ab45a4 1771 struct nfs4_client *conf, *unconf;
1da177e4
LT		 1772 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
1773 clientid_t * clid = &setclientid_confirm->sc_clientid;
b37ad28b 1774 __be32 status;
1da177e4
LT		 1775
1776 if (STALE_CLIENTID(clid))
1777 return nfserr_stale_clientid;
1778 /*
1779 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1780 * We get here on a DRC miss.
1781 */
1782
1783 nfs4_lock_state();
21ab45a4
N		 1784
1785 conf = find_confirmed_client(clid);
1786 unconf = find_unconfirmed_client(clid);
1787
1788 status = nfserr_clid_inuse;
363168b4 1789 if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
21ab45a4 1790 goto out;
363168b4 1791 if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
21ab45a4
N		 1792 goto out;
1793
a186e767
BF		 1794 /*
1795 * section 14.2.34 of RFC 3530 has a description of
1796 * SETCLIENTID_CONFIRM request processing consisting
1797 * of 4 bullet points, labeled as CASE1 - CASE4 below.
1798 */
366e0c1d 1799 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
a186e767
BF		 1800 /*
1801 * RFC 3530 14.2.34 CASE 1:
1802 * callback update
1803 */
599e0a22 1804 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
1da177e4
LT		 1805 status = nfserr_clid_inuse;
1806 else {
2bf23875 1807 atomic_set(&conf->cl_cb_set, 0);
4b21d0de 1808 nfsd4_probe_callback(conf, &unconf->cl_cb_conn);
1a69c179 1809 expire_client(unconf);
1da177e4 1810 status = nfs_ok;
1a69c179 1811
1da177e4 1812 }
f3aba4e5 1813 } else if (conf && !unconf) {
a186e767
BF		 1814 /*
1815 * RFC 3530 14.2.34 CASE 2:
1816 * probable retransmitted request; play it safe and
1817 * do nothing.
7c79f737 1818 */
599e0a22 1819 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
1da177e4 1820 status = nfserr_clid_inuse;
21ab45a4 1821 else
1da177e4 1822 status = nfs_ok;
7c79f737 1823 } else if (!conf && unconf
599e0a22 1824 && same_verf(&unconf->cl_confirm, &confirm)) {
a186e767
BF		 1825 /*
1826 * RFC 3530 14.2.34 CASE 3:
1827 * Normal case; new or rebooted client:
7c79f737 1828 */
599e0a22 1829 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
1da177e4
LT		 1830 status = nfserr_clid_inuse;
1831 } else {
1a69c179
N		 1832 unsigned int hash =
1833 clientstr_hashval(unconf->cl_recdir);
1834 conf = find_confirmed_client_by_str(unconf->cl_recdir,
a1bcecd2 1835 hash, false);
1a69c179 1836 if (conf) {
c7b9a459 1837 nfsd4_remove_clid_dir(conf);
1a69c179
N		 1838 expire_client(conf);
1839 }
1da177e4 1840 move_to_confirmed(unconf);
21ab45a4 1841 conf = unconf;
4b21d0de 1842 nfsd4_probe_callback(conf, &conf->cl_cb_conn);
1a69c179 1843 status = nfs_ok;
1da177e4 1844 }
599e0a22
BF		 1845 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
1846 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
7c79f737 1847 &confirm)))) {
a186e767
BF		 1848 /*
1849 * RFC 3530 14.2.34 CASE 4:
1850 * Client probably hasn't noticed that we rebooted yet.
7c79f737 1851 */
1da177e4 1852 status = nfserr_stale_clientid;
7c79f737 1853 } else {
08e8987c
N		 1854 /* check that we have hit one of the cases...*/
1855 status = nfserr_clid_inuse;
1856 }
1da177e4 1857out:
1da177e4
LT		 1858 nfs4_unlock_state();
1859 return status;
1860}
1861
1da177e4
LT		 1862/* OPEN Share state helper functions */
1863static inline struct nfs4_file *
1864alloc_init_file(struct inode *ino)
1865{
1866 struct nfs4_file *fp;
1867 unsigned int hashval = file_hashval(ino);
1868
e60d4398
N		 1869 fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
1870 if (fp) {
8b671b80 1871 atomic_set(&fp->fi_ref, 1);
1da177e4 1872 INIT_LIST_HEAD(&fp->fi_hash);
8beefa24
N		 1873 INIT_LIST_HEAD(&fp->fi_stateids);
1874 INIT_LIST_HEAD(&fp->fi_delegations);
1da177e4
LT		 1875 fp->fi_inode = igrab(ino);
1876 fp->fi_id = current_fileid++;
47f9940c 1877 fp->fi_had_conflict = false;
f9d7562f
BF		 1878 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
1879 memset(fp->fi_access, 0, sizeof(fp->fi_access));
47cee541
PE		 1880 spin_lock(&recall_lock);
1881 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
1882 spin_unlock(&recall_lock);
1da177e4
LT		 1883 return fp;
1884 }
1885 return NULL;
1886}
1887
e60d4398 1888static void
e18b890b 1889nfsd4_free_slab(struct kmem_cache **slab)
1da177e4 1890{
e60d4398
N		 1891 if (*slab == NULL)
1892 return;
1a1d92c1 1893 kmem_cache_destroy(*slab);
e60d4398 1894 *slab = NULL;
1da177e4
LT		 1895}
1896
e8ff2a84 1897void
1da177e4
LT		 1898nfsd4_free_slabs(void)
1899{
e60d4398
N		 1900 nfsd4_free_slab(&stateowner_slab);
1901 nfsd4_free_slab(&file_slab);
5ac049ac 1902 nfsd4_free_slab(&stateid_slab);
5b2d21c1 1903 nfsd4_free_slab(&deleg_slab);
e60d4398 1904}
1da177e4 1905
e60d4398
N		 1906static int
1907nfsd4_init_slabs(void)
1908{
1909 stateowner_slab = kmem_cache_create("nfsd4_stateowners",
20c2df83 1910 sizeof(struct nfs4_stateowner), 0, 0, NULL);
e60d4398
N		 1911 if (stateowner_slab == NULL)
1912 goto out_nomem;
1913 file_slab = kmem_cache_create("nfsd4_files",
20c2df83 1914 sizeof(struct nfs4_file), 0, 0, NULL);
e60d4398
N		 1915 if (file_slab == NULL)
1916 goto out_nomem;
5ac049ac 1917 stateid_slab = kmem_cache_create("nfsd4_stateids",
20c2df83 1918 sizeof(struct nfs4_stateid), 0, 0, NULL);
5ac049ac
N		 1919 if (stateid_slab == NULL)
1920 goto out_nomem;
5b2d21c1 1921 deleg_slab = kmem_cache_create("nfsd4_delegations",
20c2df83 1922 sizeof(struct nfs4_delegation), 0, 0, NULL);
5b2d21c1
N		 1923 if (deleg_slab == NULL)
1924 goto out_nomem;
e60d4398
N		 1925 return 0;
1926out_nomem:
1927 nfsd4_free_slabs();
1928 dprintk("nfsd4: out of memory while initializing nfsv4\n");
1929 return -ENOMEM;
1da177e4
LT		 1930}
1931
1932void
1933nfs4_free_stateowner(struct kref *kref)
1934{
1935 struct nfs4_stateowner *sop =
1936 container_of(kref, struct nfs4_stateowner, so_ref);
1937 kfree(sop->so_owner.data);
1938 kmem_cache_free(stateowner_slab, sop);
1939}
1940
1941static inline struct nfs4_stateowner *
1942alloc_stateowner(struct xdr_netobj *owner)
1943{
1944 struct nfs4_stateowner *sop;
1945
1946 if ((sop = kmem_cache_alloc(stateowner_slab, GFP_KERNEL))) {
1947 if ((sop->so_owner.data = kmalloc(owner->len, GFP_KERNEL))) {
1948 memcpy(sop->so_owner.data, owner->data, owner->len);
1949 sop->so_owner.len = owner->len;
1950 kref_init(&sop->so_ref);
1951 return sop;
1952 }
1953 kmem_cache_free(stateowner_slab, sop);
1954 }
1955 return NULL;
1956}
1957
1958static struct nfs4_stateowner *
1959alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
1960 struct nfs4_stateowner *sop;
1961 struct nfs4_replay *rp;
1962 unsigned int idhashval;
1963
1964 if (!(sop = alloc_stateowner(&open->op_owner)))
1965 return NULL;
1966 idhashval = ownerid_hashval(current_ownerid);
1967 INIT_LIST_HEAD(&sop->so_idhash);
1968 INIT_LIST_HEAD(&sop->so_strhash);
1969 INIT_LIST_HEAD(&sop->so_perclient);
ea1da636
N		 1970 INIT_LIST_HEAD(&sop->so_stateids);
1971 INIT_LIST_HEAD(&sop->so_perstateid); /* not used */
1da177e4
LT		 1972 INIT_LIST_HEAD(&sop->so_close_lru);
1973 sop->so_time = 0;
1974 list_add(&sop->so_idhash, &ownerid_hashtbl[idhashval]);
1975 list_add(&sop->so_strhash, &ownerstr_hashtbl[strhashval]);
ea1da636 1976 list_add(&sop->so_perclient, &clp->cl_openowners);
1da177e4
LT		 1977 sop->so_is_open_owner = 1;
1978 sop->so_id = current_ownerid++;
1979 sop->so_client = clp;
1980 sop->so_seqid = open->op_seqid;
1981 sop->so_confirmed = 0;
1982 rp = &sop->so_replay;
de1ae286 1983 rp->rp_status = nfserr_serverfault;
1da177e4
LT		 1984 rp->rp_buflen = 0;
1985 rp->rp_buf = rp->rp_ibuf;
1986 return sop;
1987}
1988
1da177e4
LT		 1989static inline void
1990init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
1991 struct nfs4_stateowner *sop = open->op_stateowner;
1992 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
1993
1994 INIT_LIST_HEAD(&stp->st_hash);
ea1da636
N		 1995 INIT_LIST_HEAD(&stp->st_perstateowner);
1996 INIT_LIST_HEAD(&stp->st_lockowners);
1da177e4
LT		 1997 INIT_LIST_HEAD(&stp->st_perfile);
1998 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
ea1da636 1999 list_add(&stp->st_perstateowner, &sop->so_stateids);
8beefa24 2000 list_add(&stp->st_perfile, &fp->fi_stateids);
1da177e4 2001 stp->st_stateowner = sop;
13cd2184 2002 get_nfs4_file(fp);
1da177e4 2003 stp->st_file = fp;
e4e83ea4 2004 stp->st_stateid.si_boot = boot_time;
1da177e4
LT		 2005 stp->st_stateid.si_stateownerid = sop->so_id;
2006 stp->st_stateid.si_fileid = fp->fi_id;
2007 stp->st_stateid.si_generation = 0;
2008 stp->st_access_bmap = 0;
2009 stp->st_deny_bmap = 0;
84459a11
AA		 2010 __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
2011 &stp->st_access_bmap);
1da177e4 2012 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
4c4cd222 2013 stp->st_openstp = NULL;
1da177e4
LT		 2014}
2015
fd39ca9a 2016static void
1da177e4
LT		 2017move_to_close_lru(struct nfs4_stateowner *sop)
2018{
2019 dprintk("NFSD: move_to_close_lru nfs4_stateowner %p\n", sop);
2020
358dd55a 2021 list_move_tail(&sop->so_close_lru, &close_lru);
1da177e4
LT		 2022 sop->so_time = get_seconds();
2023}
2024
1da177e4 2025static int
599e0a22
BF		 2026same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2027 clientid_t *clid)
2028{
2029 return (sop->so_owner.len == owner->len) &&
2030 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2031 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
1da177e4
LT		 2032}
2033
2034static struct nfs4_stateowner *
2035find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2036{
2037 struct nfs4_stateowner *so = NULL;
2038
2039 list_for_each_entry(so, &ownerstr_hashtbl[hashval], so_strhash) {
599e0a22 2040 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
1da177e4
LT		 2041 return so;
2042 }
2043 return NULL;
2044}
2045
2046/* search file_hashtbl[] for file */
2047static struct nfs4_file *
2048find_file(struct inode *ino)
2049{
2050 unsigned int hashval = file_hashval(ino);
2051 struct nfs4_file *fp;
2052
8b671b80 2053 spin_lock(&recall_lock);
1da177e4 2054 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
13cd2184
N		 2055 if (fp->fi_inode == ino) {
2056 get_nfs4_file(fp);
8b671b80 2057 spin_unlock(&recall_lock);
1da177e4 2058 return fp;
13cd2184 2059 }
1da177e4 2060 }
8b671b80 2061 spin_unlock(&recall_lock);
1da177e4
LT		 2062 return NULL;
2063}
2064
d87a8ade 2065static inline int access_valid(u32 x, u32 minorversion)
ba5a6a19 2066{
d87a8ade 2067 if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
8838dc43 2068 return 0;
d87a8ade
AA		 2069 if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
2070 return 0;
2071 x &= ~NFS4_SHARE_ACCESS_MASK;
2072 if (minorversion && x) {
2073 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
2074 return 0;
2075 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
2076 return 0;
2077 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
2078 }
2079 if (x)
8838dc43
BF		 2080 return 0;
2081 return 1;
ba5a6a19
BF		 2082}
2083
8838dc43 2084static inline int deny_valid(u32 x)
ba5a6a19 2085{
8838dc43
BF		 2086 /* Note: unlike access bits, deny bits may be zero. */
2087 return x <= NFS4_SHARE_DENY_BOTH;
ba5a6a19 2088}
1da177e4 2089
1da177e4
LT		 2090/*
2091 * Called to check deny when READ with all zero stateid or
2092 * WRITE with all zero or all one stateid
2093 */
b37ad28b 2094static __be32
1da177e4
LT		 2095nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2096{
2097 struct inode *ino = current_fh->fh_dentry->d_inode;
2098 struct nfs4_file *fp;
2099 struct nfs4_stateid *stp;
b37ad28b 2100 __be32 ret;
1da177e4
LT		 2101
2102 dprintk("NFSD: nfs4_share_conflict\n");
2103
2104 fp = find_file(ino);
13cd2184
N		 2105 if (!fp)
2106 return nfs_ok;
b700949b 2107 ret = nfserr_locked;
1da177e4 2108 /* Search for conflicting share reservations */
13cd2184
N		 2109 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2110 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2111 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2112 goto out;
1da177e4 2113 }
13cd2184
N		 2114 ret = nfs_ok;
2115out:
2116 put_nfs4_file(fp);
2117 return ret;
1da177e4
LT		 2118}
2119
2120static inline void
f9d7562f 2121nfs4_file_downgrade(struct nfs4_file *fp, unsigned int share_access)
1da177e4 2122{
f9d7562f
BF		 2123 if (share_access & NFS4_SHARE_ACCESS_WRITE)
2124 nfs4_file_put_access(fp, O_WRONLY);
2125 if (share_access & NFS4_SHARE_ACCESS_READ)
2126 nfs4_file_put_access(fp, O_RDONLY);
1da177e4
LT		 2127}
2128
1da177e4
LT		 2129/*
2130 * Spawn a thread to perform a recall on the delegation represented
2131 * by the lease (file_lock)
2132 *
2133 * Called from break_lease() with lock_kernel() held.
2134 * Note: we assume break_lease will only call this *once* for any given
2135 * lease.
2136 */
2137static
2138void nfsd_break_deleg_cb(struct file_lock *fl)
2139{
63e4863f 2140 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
1da177e4
LT		 2141
2142 dprintk("NFSD nfsd_break_deleg_cb: dp %p fl %p\n",dp,fl);
2143 if (!dp)
2144 return;
2145
2146 /* We're assuming the state code never drops its reference
2147 * without first removing the lease. Since we're in this lease
2148 * callback (and since the lease code is serialized by the kernel
2149 * lock) we know the server hasn't removed the lease yet, we know
2150 * it's safe to take a reference: */
2151 atomic_inc(&dp->dl_count);
2152
2153 spin_lock(&recall_lock);
2154 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2155 spin_unlock(&recall_lock);
2156
2157 /* only place dl_time is set. protected by lock_kernel*/
2158 dp->dl_time = get_seconds();
2159
0272e1fd
BF		 2160 /*
2161 * We don't want the locks code to timeout the lease for us;
2162 * we'll remove it ourself if the delegation isn't returned
2163 * in time.
2164 */
2165 fl->fl_break_time = 0;
1da177e4 2166
63e4863f
BF		 2167 dp->dl_file->fi_had_conflict = true;
2168 nfsd4_cb_recall(dp);
1da177e4
LT		 2169}
2170
2171/*
2172 * The file_lock is being reapd.
2173 *
2174 * Called by locks_free_lock() with lock_kernel() held.
2175 */
2176static
2177void nfsd_release_deleg_cb(struct file_lock *fl)
2178{
2179 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
2180
2181 dprintk("NFSD nfsd_release_deleg_cb: fl %p dp %p dl_count %d\n", fl,dp, atomic_read(&dp->dl_count));
2182
2183 if (!(fl->fl_flags & FL_LEASE) || !dp)
2184 return;
2185 dp->dl_flock = NULL;
2186}
2187
2188/*
2189 * Set the delegation file_lock back pointer.
2190 *
a9933cea 2191 * Called from setlease() with lock_kernel() held.
1da177e4
LT		 2192 */
2193static
2194void nfsd_copy_lock_deleg_cb(struct file_lock *new, struct file_lock *fl)
2195{
2196 struct nfs4_delegation *dp = (struct nfs4_delegation *)new->fl_owner;
2197
2198 dprintk("NFSD: nfsd_copy_lock_deleg_cb: new fl %p dp %p\n", new, dp);
2199 if (!dp)
2200 return;
2201 dp->dl_flock = new;
2202}
2203
2204/*
a9933cea 2205 * Called from setlease() with lock_kernel() held
1da177e4
LT		 2206 */
2207static
2208int nfsd_same_client_deleg_cb(struct file_lock *onlist, struct file_lock *try)
2209{
2210 struct nfs4_delegation *onlistd =
2211 (struct nfs4_delegation *)onlist->fl_owner;
2212 struct nfs4_delegation *tryd =
2213 (struct nfs4_delegation *)try->fl_owner;
2214
2215 if (onlist->fl_lmops != try->fl_lmops)
2216 return 0;
2217
2218 return onlistd->dl_client == tryd->dl_client;
2219}
2220
2221
2222static
2223int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2224{
2225 if (arg & F_UNLCK)
2226 return lease_modify(onlist, arg);
2227 else
2228 return -EAGAIN;
2229}
2230
7b021967 2231static const struct lock_manager_operations nfsd_lease_mng_ops = {
1da177e4
LT		 2232 .fl_break = nfsd_break_deleg_cb,
2233 .fl_release_private = nfsd_release_deleg_cb,
2234 .fl_copy_lock = nfsd_copy_lock_deleg_cb,
2235 .fl_mylease = nfsd_same_client_deleg_cb,
2236 .fl_change = nfsd_change_deleg_cb,
2237};
2238
2239
b37ad28b 2240__be32
6668958f
AA		 2241nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2242 struct nfsd4_open *open)
1da177e4 2243{
1da177e4
LT		 2244 clientid_t *clientid = &open->op_clientid;
2245 struct nfs4_client *clp = NULL;
2246 unsigned int strhashval;
2247 struct nfs4_stateowner *sop = NULL;
2248
1da177e4 2249 if (!check_name(open->op_owner))
0f442aa2 2250 return nfserr_inval;
1da177e4
LT		 2251
2252 if (STALE_CLIENTID(&open->op_clientid))
2253 return nfserr_stale_clientid;
2254
2255 strhashval = ownerstr_hashval(clientid->cl_id, open->op_owner);
2256 sop = find_openstateowner_str(strhashval, open);
0f442aa2
BF		 2257 open->op_stateowner = sop;
2258 if (!sop) {
2259 /* Make sure the client's lease hasn't expired. */
1da177e4
LT		 2260 clp = find_confirmed_client(clientid);
2261 if (clp == NULL)
0f442aa2
BF		 2262 return nfserr_expired;
2263 goto renew;
1da177e4 2264 }
6668958f
AA		 2265 /* When sessions are used, skip open sequenceid processing */
2266 if (nfsd4_has_session(cstate))
2267 goto renew;
0f442aa2
BF		 2268 if (!sop->so_confirmed) {
2269 /* Replace unconfirmed owners without checking for replay. */
2270 clp = sop->so_client;
f044ff83 2271 release_openowner(sop);
0f442aa2
BF		 2272 open->op_stateowner = NULL;
2273 goto renew;
2274 }
2275 if (open->op_seqid == sop->so_seqid - 1) {
2276 if (sop->so_replay.rp_buflen)
a90b061c 2277 return nfserr_replay_me;
0f442aa2
BF		 2278 /* The original OPEN failed so spectacularly
2279 * that we don't even have replay data saved!
2280 * Therefore, we have no choice but to continue
2281 * processing this OPEN; presumably, we'll
2282 * fail again for the same reason.
2283 */
2284 dprintk("nfsd4_process_open1: replay with no replay cache\n");
2285 goto renew;
2286 }
2287 if (open->op_seqid != sop->so_seqid)
2288 return nfserr_bad_seqid;
1da177e4 2289renew:
0f442aa2
BF		 2290 if (open->op_stateowner == NULL) {
2291 sop = alloc_init_open_stateowner(strhashval, clp, open);
2292 if (sop == NULL)
2293 return nfserr_resource;
2294 open->op_stateowner = sop;
2295 }
2296 list_del_init(&sop->so_close_lru);
1da177e4 2297 renew_client(sop->so_client);
0f442aa2 2298 return nfs_ok;
1da177e4
LT		 2299}
2300
b37ad28b 2301static inline __be32
4a6e43e6
N		 2302nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2303{
2304 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2305 return nfserr_openmode;
2306 else
2307 return nfs_ok;
2308}
2309
52f4fb43
N		 2310static struct nfs4_delegation *
2311find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2312{
2313 struct nfs4_delegation *dp;
2314
ea1da636 2315 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile) {
52f4fb43
N		 2316 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid)
2317 return dp;
2318 }
2319 return NULL;
2320}
2321
24a0111e
BF		 2322int share_access_to_flags(u32 share_access)
2323{
2324 share_access &= ~NFS4_SHARE_WANT_MASK;
2325
2326 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2327}
2328
b37ad28b 2329static __be32
567d9829
N		 2330nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2331 struct nfs4_delegation **dp)
2332{
2333 int flags;
b37ad28b 2334 __be32 status = nfserr_bad_stateid;
567d9829
N		 2335
2336 *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2337 if (*dp == NULL)
c44c5eeb 2338 goto out;
24a0111e 2339 flags = share_access_to_flags(open->op_share_access);
567d9829
N		 2340 status = nfs4_check_delegmode(*dp, flags);
2341 if (status)
2342 *dp = NULL;
c44c5eeb
N		 2343out:
2344 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2345 return nfs_ok;
2346 if (status)
2347 return status;
2348 open->op_stateowner->so_confirmed = 1;
2349 return nfs_ok;
567d9829
N		 2350}
2351
b37ad28b 2352static __be32
1da177e4
LT		 2353nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2354{
2355 struct nfs4_stateid *local;
b37ad28b 2356 __be32 status = nfserr_share_denied;
1da177e4
LT		 2357 struct nfs4_stateowner *sop = open->op_stateowner;
2358
8beefa24 2359 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
1da177e4
LT		 2360 /* ignore lock owners */
2361 if (local->st_stateowner->so_is_open_owner == 0)
2362 continue;
2363 /* remember if we have seen this open owner */
2364 if (local->st_stateowner == sop)
2365 *stpp = local;
2366 /* check for conflicting share reservations */
2367 if (!test_share(local, open))
2368 goto out;
2369 }
2370 status = 0;
2371out:
2372 return status;
2373}
2374
5ac049ac
N		 2375static inline struct nfs4_stateid *
2376nfs4_alloc_stateid(void)
2377{
2378 return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2379}
2380
21fb4016
BF		 2381static inline int nfs4_access_to_access(u32 nfs4_access)
2382{
2383 int flags = 0;
2384
2385 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2386 flags |= NFSD_MAY_READ;
2387 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2388 flags |= NFSD_MAY_WRITE;
2389 return flags;
2390}
2391
f9d7562f
BF		 2392static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file
2393*fp, struct svc_fh *cur_fh, u32 nfs4_access)
2394{
2395 __be32 status;
2396 int oflag = nfs4_access_to_omode(nfs4_access);
2397 int access = nfs4_access_to_access(nfs4_access);
2398
2399 if (!fp->fi_fds[oflag]) {
2400 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2401 &fp->fi_fds[oflag]);
2402 if (status == nfserr_dropit)
2403 status = nfserr_jukebox;
2404 if (status)
2405 return status;
2406 }
2407 nfs4_file_get_access(fp, oflag);
2408
2409 return nfs_ok;
2410}
2411
b37ad28b 2412static __be32
1da177e4 2413nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
f9d7562f
BF		 2414 struct nfs4_file *fp, struct svc_fh *cur_fh,
2415 struct nfsd4_open *open)
1da177e4
LT		 2416{
2417 struct nfs4_stateid *stp;
f9d7562f 2418 __be32 status;
1da177e4 2419
5ac049ac 2420 stp = nfs4_alloc_stateid();
1da177e4
LT		 2421 if (stp == NULL)
2422 return nfserr_resource;
2423
f9d7562f
BF		 2424 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open->op_share_access);
2425 if (status) {
2426 kmem_cache_free(stateid_slab, stp);
2427 return status;
1da177e4 2428 }
1da177e4
LT		 2429 *stpp = stp;
2430 return 0;
2431}
2432
b37ad28b 2433static inline __be32
1da177e4
LT		 2434nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2435 struct nfsd4_open *open)
2436{
2437 struct iattr iattr = {
2438 .ia_valid = ATTR_SIZE,
2439 .ia_size = 0,
2440 };
2441 if (!open->op_truncate)
2442 return 0;
2443 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
9246585a 2444 return nfserr_inval;
1da177e4
LT		 2445 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2446}
2447
b37ad28b 2448static __be32
f9d7562f 2449nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
1da177e4 2450{
7d947842
BF		 2451 u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
2452 bool new_access;
b37ad28b 2453 __be32 status;
1da177e4 2454
7d947842 2455 new_access = !test_bit(op_share_access, &stp->st_access_bmap);
f9d7562f 2456 if (new_access) {
7d947842 2457 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, op_share_access);
f9d7562f
BF		 2458 if (status)
2459 return status;
6c26d08f 2460 }
1da177e4
LT		 2461 status = nfsd4_truncate(rqstp, cur_fh, open);
2462 if (status) {
f9d7562f
BF		 2463 if (new_access) {
2464 int oflag = nfs4_access_to_omode(new_access);
2465 nfs4_file_put_access(fp, oflag);
2466 }
1da177e4
LT		 2467 return status;
2468 }
2469 /* remember the open */
24a0111e 2470 __set_bit(op_share_access, &stp->st_access_bmap);
b55e0ba1 2471 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
1da177e4
LT		 2472
2473 return nfs_ok;
2474}
2475
2476
1da177e4 2477static void
37515177 2478nfs4_set_claim_prev(struct nfsd4_open *open)
1da177e4 2479{
37515177
N		 2480 open->op_stateowner->so_confirmed = 1;
2481 open->op_stateowner->so_client->cl_firststate = 1;
1da177e4
LT		 2482}
2483
2484/*
2485 * Attempt to hand out a delegation.
2486 */
2487static void
2488nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2489{
2490 struct nfs4_delegation *dp;
2491 struct nfs4_stateowner *sop = stp->st_stateowner;
2bf23875 2492 int cb_up = atomic_read(&sop->so_client->cl_cb_set);
1da177e4
LT		 2493 struct file_lock fl, *flp = &fl;
2494 int status, flag = 0;
2495
2496 flag = NFS4_OPEN_DELEGATE_NONE;
7b190fec
N		 2497 open->op_recall = 0;
2498 switch (open->op_claim_type) {
2499 case NFS4_OPEN_CLAIM_PREVIOUS:
2bf23875 2500 if (!cb_up)
7b190fec
N		 2501 open->op_recall = 1;
2502 flag = open->op_delegate_type;
2503 if (flag == NFS4_OPEN_DELEGATE_NONE)
2504 goto out;
2505 break;
2506 case NFS4_OPEN_CLAIM_NULL:
2507 /* Let's not give out any delegations till everyone's
2508 * had the chance to reclaim theirs.... */
af558e33 2509 if (locks_in_grace())
7b190fec 2510 goto out;
2bf23875 2511 if (!cb_up || !sop->so_confirmed)
7b190fec
N		 2512 goto out;
2513 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2514 flag = NFS4_OPEN_DELEGATE_WRITE;
2515 else
2516 flag = NFS4_OPEN_DELEGATE_READ;
2517 break;
2518 default:
2519 goto out;
2520 }
1da177e4
LT		 2521
2522 dp = alloc_init_deleg(sop->so_client, stp, fh, flag);
2523 if (dp == NULL) {
2524 flag = NFS4_OPEN_DELEGATE_NONE;
2525 goto out;
2526 }
2527 locks_init_lock(&fl);
2528 fl.fl_lmops = &nfsd_lease_mng_ops;
2529 fl.fl_flags = FL_LEASE;
9167f501 2530 fl.fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
1da177e4
LT		 2531 fl.fl_end = OFFSET_MAX;
2532 fl.fl_owner = (fl_owner_t)dp;
f9d7562f
BF		 2533 fl.fl_file = find_readable_file(stp->st_file);
2534 BUG_ON(!fl.fl_file);
1da177e4
LT		 2535 fl.fl_pid = current->tgid;
2536
a9933cea 2537 /* vfs_setlease checks to see if delegation should be handed out.
1da177e4
LT		 2538 * the lock_manager callbacks fl_mylease and fl_change are used
2539 */
f9d7562f 2540 if ((status = vfs_setlease(fl.fl_file, fl.fl_type, &flp))) {
1da177e4 2541 dprintk("NFSD: setlease failed [%d], no delegation\n", status);
c907132d 2542 unhash_delegation(dp);
1da177e4
LT		 2543 flag = NFS4_OPEN_DELEGATE_NONE;
2544 goto out;
2545 }
2546
2547 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2548
8c10cbdb
BH		 2549 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2550 STATEID_VAL(&dp->dl_stateid));
1da177e4 2551out:
7b190fec
N		 2552 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2553 && flag == NFS4_OPEN_DELEGATE_NONE
2554 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2fdada03 2555 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
1da177e4
LT		 2556 open->op_delegate_type = flag;
2557}
2558
2559/*
2560 * called with nfs4_lock_state() held.
2561 */
b37ad28b 2562__be32
1da177e4
LT		 2563nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2564{
6668958f 2565 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1da177e4
LT		 2566 struct nfs4_file *fp = NULL;
2567 struct inode *ino = current_fh->fh_dentry->d_inode;
2568 struct nfs4_stateid *stp = NULL;
567d9829 2569 struct nfs4_delegation *dp = NULL;
b37ad28b 2570 __be32 status;
1da177e4
LT		 2571
2572 status = nfserr_inval;
d87a8ade 2573 if (!access_valid(open->op_share_access, resp->cstate.minorversion)
ba5a6a19 2574 || !deny_valid(open->op_share_deny))
1da177e4
LT		 2575 goto out;
2576 /*
2577 * Lookup file; if found, lookup stateid and check open request,
2578 * and check for delegations in the process of being recalled.
2579 * If not found, create the nfs4_file struct
2580 */
2581 fp = find_file(ino);
2582 if (fp) {
2583 if ((status = nfs4_check_open(fp, open, &stp)))
2584 goto out;
c44c5eeb
N		 2585 status = nfs4_check_deleg(fp, open, &dp);
2586 if (status)
2587 goto out;
1da177e4 2588 } else {
c44c5eeb
N		 2589 status = nfserr_bad_stateid;
2590 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2591 goto out;
1da177e4
LT		 2592 status = nfserr_resource;
2593 fp = alloc_init_file(ino);
2594 if (fp == NULL)
2595 goto out;
2596 }
2597
2598 /*
2599 * OPEN the file, or upgrade an existing OPEN.
2600 * If truncate fails, the OPEN fails.
2601 */
2602 if (stp) {
2603 /* Stateid was found, this is an OPEN upgrade */
f9d7562f 2604 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
1da177e4
LT		 2605 if (status)
2606 goto out;
444c2c07 2607 update_stateid(&stp->st_stateid);
1da177e4 2608 } else {
f9d7562f 2609 status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
567d9829 2610 if (status)
1da177e4
LT		 2611 goto out;
2612 init_stateid(stp, fp, open);
2613 status = nfsd4_truncate(rqstp, current_fh, open);
2614 if (status) {
2283963f 2615 release_open_stateid(stp);
1da177e4
LT		 2616 goto out;
2617 }
6668958f
AA		 2618 if (nfsd4_has_session(&resp->cstate))
2619 update_stateid(&stp->st_stateid);
1da177e4
LT		 2620 }
2621 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2622
4dc6ec00 2623 if (nfsd4_has_session(&resp->cstate))
6668958f
AA		 2624 open->op_stateowner->so_confirmed = 1;
2625
1da177e4
LT		 2626 /*
2627 * Attempt to hand out a delegation. No error return, because the
2628 * OPEN succeeds even if we fail.
2629 */
2630 nfs4_open_delegation(current_fh, open, stp);
2631
2632 status = nfs_ok;
2633
8c10cbdb
BH		 2634 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2635 STATEID_VAL(&stp->st_stateid));
1da177e4 2636out:
13cd2184
N		 2637 if (fp)
2638 put_nfs4_file(fp);
37515177
N		 2639 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2640 nfs4_set_claim_prev(open);
1da177e4
LT		 2641 /*
2642 * To finish the open response, we just need to set the rflags.
2643 */
2644 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
6668958f
AA		 2645 if (!open->op_stateowner->so_confirmed &&
2646 !nfsd4_has_session(&resp->cstate))
1da177e4
LT		 2647 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2648
2649 return status;
2650}
2651
b37ad28b 2652__be32
b591480b
BF		 2653nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2654 clientid_t *clid)
1da177e4
LT		 2655{
2656 struct nfs4_client *clp;
b37ad28b 2657 __be32 status;
1da177e4
LT		 2658
2659 nfs4_lock_state();
2660 dprintk("process_renew(%08x/%08x): starting\n",
2661 clid->cl_boot, clid->cl_id);
2662 status = nfserr_stale_clientid;
2663 if (STALE_CLIENTID(clid))
2664 goto out;
2665 clp = find_confirmed_client(clid);
2666 status = nfserr_expired;
2667 if (clp == NULL) {
2668 /* We assume the client took too long to RENEW. */
2669 dprintk("nfsd4_renew: clientid not found!\n");
2670 goto out;
2671 }
2672 renew_client(clp);
2673 status = nfserr_cb_path_down;
ea1da636 2674 if (!list_empty(&clp->cl_delegations)
2bf23875 2675 && !atomic_read(&clp->cl_cb_set))
1da177e4
LT		 2676 goto out;
2677 status = nfs_ok;
2678out:
2679 nfs4_unlock_state();
2680 return status;
2681}
2682
af558e33
BF		 2683struct lock_manager nfsd4_manager = {
2684};
2685
a76b4319 2686static void
af558e33 2687nfsd4_end_grace(void)
a76b4319
N		 2688{
2689 dprintk("NFSD: end of grace period\n");
c7b9a459 2690 nfsd4_recdir_purge_old();
af558e33 2691 locks_end_grace(&nfsd4_manager);
e46b498c
BF		 2692 /*
2693 * Now that every NFSv4 client has had the chance to recover and
2694 * to see the (possibly new, possibly shorter) lease time, we
2695 * can safely set the next grace time to the current lease time:
2696 */
2697 nfsd4_grace = nfsd4_lease;
a76b4319
N		 2698}
2699
fd39ca9a 2700static time_t
1da177e4
LT		 2701nfs4_laundromat(void)
2702{
2703 struct nfs4_client *clp;
2704 struct nfs4_stateowner *sop;
2705 struct nfs4_delegation *dp;
2706 struct list_head *pos, *next, reaplist;
cf07d2ea
BF		 2707 time_t cutoff = get_seconds() - nfsd4_lease;
2708 time_t t, clientid_val = nfsd4_lease;
2709 time_t u, test_val = nfsd4_lease;
1da177e4
LT		 2710
2711 nfs4_lock_state();
2712
2713 dprintk("NFSD: laundromat service - starting\n");
af558e33
BF		 2714 if (locks_in_grace())
2715 nfsd4_end_grace();
36acb66b
BH		 2716 INIT_LIST_HEAD(&reaplist);
2717 spin_lock(&client_lock);
1da177e4
LT		 2718 list_for_each_safe(pos, next, &client_lru) {
2719 clp = list_entry(pos, struct nfs4_client, cl_lru);
2720 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
2721 t = clp->cl_time - cutoff;
2722 if (clientid_val > t)
2723 clientid_val = t;
2724 break;
2725 }
d7682988
BH		 2726 if (atomic_read(&clp->cl_refcount)) {
2727 dprintk("NFSD: client in use (clientid %08x)\n",
2728 clp->cl_clientid.cl_id);
2729 continue;
2730 }
2731 unhash_client_locked(clp);
2732 list_add(&clp->cl_lru, &reaplist);
36acb66b
BH		 2733 }
2734 spin_unlock(&client_lock);
2735 list_for_each_safe(pos, next, &reaplist) {
2736 clp = list_entry(pos, struct nfs4_client, cl_lru);
1da177e4
LT		 2737 dprintk("NFSD: purging unused client (clientid %08x)\n",
2738 clp->cl_clientid.cl_id);
c7b9a459 2739 nfsd4_remove_clid_dir(clp);
1da177e4
LT		 2740 expire_client(clp);
2741 }
1da177e4
LT		 2742 spin_lock(&recall_lock);
2743 list_for_each_safe(pos, next, &del_recall_lru) {
2744 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2745 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
2746 u = dp->dl_time - cutoff;
2747 if (test_val > u)
2748 test_val = u;
2749 break;
2750 }
2751 dprintk("NFSD: purging unused delegation dp %p, fp %p\n",
2752 dp, dp->dl_flock);
2753 list_move(&dp->dl_recall_lru, &reaplist);
2754 }
2755 spin_unlock(&recall_lock);
2756 list_for_each_safe(pos, next, &reaplist) {
2757 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
2758 list_del_init(&dp->dl_recall_lru);
2759 unhash_delegation(dp);
2760 }
cf07d2ea 2761 test_val = nfsd4_lease;
1da177e4
LT		 2762 list_for_each_safe(pos, next, &close_lru) {
2763 sop = list_entry(pos, struct nfs4_stateowner, so_close_lru);
2764 if (time_after((unsigned long)sop->so_time, (unsigned long)cutoff)) {
2765 u = sop->so_time - cutoff;
2766 if (test_val > u)
2767 test_val = u;
2768 break;
2769 }
2770 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
2771 sop->so_id);
f044ff83 2772 release_openowner(sop);
1da177e4
LT		 2773 }
2774 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
2775 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
2776 nfs4_unlock_state();
2777 return clientid_val;
2778}
2779
a254b246
HH		 2780static struct workqueue_struct *laundry_wq;
2781static void laundromat_main(struct work_struct *);
2782static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
2783
2784static void
c4028958 2785laundromat_main(struct work_struct *not_used)
1da177e4
LT		 2786{
2787 time_t t;
2788
2789 t = nfs4_laundromat();
2790 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
58da282b 2791 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
1da177e4
LT		 2792}
2793
fd39ca9a 2794static struct nfs4_stateowner *
f8816512
N		 2795search_close_lru(u32 st_id, int flags)
2796{
1da177e4
LT		 2797 struct nfs4_stateowner *local = NULL;
2798
1da177e4
LT		 2799 if (flags & CLOSE_STATE) {
2800 list_for_each_entry(local, &close_lru, so_close_lru) {
2801 if (local->so_id == st_id)
2802 return local;
2803 }
2804 }
2805 return NULL;
2806}
2807
2808static inline int
2809nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
2810{
f9d7562f 2811 return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
1da177e4
LT		 2812}
2813
2814static int
2815STALE_STATEID(stateid_t *stateid)
2816{
e4e83ea4
BF		 2817 if (stateid->si_boot == boot_time)
2818 return 0;
2819 dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
8c10cbdb 2820 STATEID_VAL(stateid));
e4e83ea4 2821 return 1;
1da177e4
LT		 2822}
2823
2824static inline int
2825access_permit_read(unsigned long access_bmap)
2826{
2827 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
2828 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
2829 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
2830}
2831
2832static inline int
2833access_permit_write(unsigned long access_bmap)
2834{
2835 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
2836 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
2837}
2838
2839static
b37ad28b 2840__be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
1da177e4 2841{
b37ad28b 2842 __be32 status = nfserr_openmode;
1da177e4 2843
02921914
BF		 2844 /* For lock stateid's, we test the parent open, not the lock: */
2845 if (stp->st_openstp)
2846 stp = stp->st_openstp;
1da177e4
LT		 2847 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
2848 goto out;
2849 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
2850 goto out;
2851 status = nfs_ok;
2852out:
2853 return status;
2854}
2855
b37ad28b 2856static inline __be32
1da177e4
LT		 2857check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
2858{
203a8c8e 2859 if (ONE_STATEID(stateid) && (flags & RD_STATE))
1da177e4 2860 return nfs_ok;
af558e33 2861 else if (locks_in_grace()) {
1da177e4
LT		 2862 /* Answer in remaining cases depends on existance of
2863 * conflicting state; so we must wait out the grace period. */
2864 return nfserr_grace;
2865 } else if (flags & WR_STATE)
2866 return nfs4_share_conflict(current_fh,
2867 NFS4_SHARE_DENY_WRITE);
2868 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
2869 return nfs4_share_conflict(current_fh,
2870 NFS4_SHARE_DENY_READ);
2871}
2872
2873/*
2874 * Allow READ/WRITE during grace period on recovered state only for files
2875 * that are not able to provide mandatory locking.
2876 */
2877static inline int
18f82731 2878grace_disallows_io(struct inode *inode)
1da177e4 2879{
203a8c8e 2880 return locks_in_grace() && mandatory_lock(inode);
1da177e4
LT		 2881}
2882
6668958f 2883static int check_stateid_generation(stateid_t *in, stateid_t *ref, int flags)
0836f587 2884{
6668958f
AA		 2885 /*
2886 * When sessions are used the stateid generation number is ignored
2887 * when it is zero.
2888 */
2889 if ((flags & HAS_SESSION) && in->si_generation == 0)
2890 goto out;
2891
0836f587
BF		 2892 /* If the client sends us a stateid from the future, it's buggy: */
2893 if (in->si_generation > ref->si_generation)
2894 return nfserr_bad_stateid;
2895 /*
2896 * The following, however, can happen. For example, if the
2897 * client sends an open and some IO at the same time, the open
2898 * may bump si_generation while the IO is still in flight.
2899 * Thanks to hard links and renames, the client never knows what
2900 * file an open will affect. So it could avoid that situation
2901 * only by serializing all opens and IO from the same open
2902 * owner. To recover from the old_stateid error, the client
2903 * will just have to retry the IO:
2904 */
2905 if (in->si_generation < ref->si_generation)
2906 return nfserr_old_stateid;
6668958f 2907out:
0836f587
BF		 2908 return nfs_ok;
2909}
2910
3e633079
BF		 2911static int is_delegation_stateid(stateid_t *stateid)
2912{
2913 return stateid->si_fileid == 0;
2914}
2915
1da177e4
LT		 2916/*
2917* Checks for stateid operations
2918*/
b37ad28b 2919__be32
dd453dfd
BH		 2920nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
2921 stateid_t *stateid, int flags, struct file **filpp)
1da177e4
LT		 2922{
2923 struct nfs4_stateid *stp = NULL;
2924 struct nfs4_delegation *dp = NULL;
dd453dfd 2925 struct svc_fh *current_fh = &cstate->current_fh;
1da177e4 2926 struct inode *ino = current_fh->fh_dentry->d_inode;
b37ad28b 2927 __be32 status;
1da177e4 2928
1da177e4
LT		 2929 if (filpp)
2930 *filpp = NULL;
2931
18f82731 2932 if (grace_disallows_io(ino))
1da177e4
LT		 2933 return nfserr_grace;
2934
6668958f
AA		 2935 if (nfsd4_has_session(cstate))
2936 flags |= HAS_SESSION;
2937
1da177e4
LT		 2938 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
2939 return check_special_stateids(current_fh, stateid, flags);
2940
1da177e4
LT		 2941 status = nfserr_stale_stateid;
2942 if (STALE_STATEID(stateid))
2943 goto out;
2944
1da177e4 2945 status = nfserr_bad_stateid;
3e633079 2946 if (is_delegation_stateid(stateid)) {
a4455be0 2947 dp = find_delegation_stateid(ino, stateid);
e4e83ea4 2948 if (!dp)
1da177e4 2949 goto out;
6668958f
AA		 2950 status = check_stateid_generation(stateid, &dp->dl_stateid,
2951 flags);
0c2a498f
BF		 2952 if (status)
2953 goto out;
dc9bf700
BF		 2954 status = nfs4_check_delegmode(dp, flags);
2955 if (status)
2956 goto out;
2957 renew_client(dp->dl_client);
dc9bf700 2958 if (filpp)
f9d7562f
BF		 2959 *filpp = find_readable_file(dp->dl_file);
2960 BUG_ON(!*filpp);
1da177e4 2961 } else { /* open or lock stateid */
a4455be0 2962 stp = find_stateid(stateid, flags);
e4e83ea4 2963 if (!stp)
1da177e4 2964 goto out;
6150ef0d 2965 if (nfs4_check_fh(current_fh, stp))
1da177e4
LT		 2966 goto out;
2967 if (!stp->st_stateowner->so_confirmed)
2968 goto out;
6668958f
AA		 2969 status = check_stateid_generation(stateid, &stp->st_stateid,
2970 flags);
0c2a498f
BF		 2971 if (status)
2972 goto out;
a4455be0
BF		 2973 status = nfs4_check_openmode(stp, flags);
2974 if (status)
1da177e4
LT		 2975 goto out;
2976 renew_client(stp->st_stateowner->so_client);
f9d7562f
BF		 2977 if (filpp) {
2978 if (flags & RD_STATE)
2979 *filpp = find_readable_file(stp->st_file);
2980 else
2981 *filpp = find_writeable_file(stp->st_file);
f9d7562f 2982 }
1da177e4
LT		 2983 }
2984 status = nfs_ok;
2985out:
2986 return status;
2987}
2988
4c4cd222
N		 2989static inline int
2990setlkflg (int type)
2991{
2992 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
2993 RD_STATE : WR_STATE;
2994}
1da177e4
LT		 2995
2996/*
2997 * Checks for sequence id mutating operations.
2998 */
b37ad28b 2999static __be32
dd453dfd
BH		 3000nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3001 stateid_t *stateid, int flags,
3002 struct nfs4_stateowner **sopp,
3003 struct nfs4_stateid **stpp, struct nfsd4_lock *lock)
1da177e4 3004{
1da177e4
LT		 3005 struct nfs4_stateid *stp;
3006 struct nfs4_stateowner *sop;
dd453dfd 3007 struct svc_fh *current_fh = &cstate->current_fh;
0836f587 3008 __be32 status;
1da177e4 3009
8c10cbdb
BH		 3010 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3011 seqid, STATEID_VAL(stateid));
3a4f98bb 3012
1da177e4
LT		 3013 *stpp = NULL;
3014 *sopp = NULL;
3015
1da177e4 3016 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
2fdada03 3017 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
3a4f98bb 3018 return nfserr_bad_stateid;
1da177e4
LT		 3019 }
3020
1da177e4 3021 if (STALE_STATEID(stateid))
3a4f98bb 3022 return nfserr_stale_stateid;
6668958f
AA		 3023
3024 if (nfsd4_has_session(cstate))
3025 flags |= HAS_SESSION;
3026
1da177e4
LT		 3027 /*
3028 * We return BAD_STATEID if filehandle doesn't match stateid,
3029 * the confirmed flag is incorrecly set, or the generation
3030 * number is incorrect.
1da177e4 3031 */
f8816512
N		 3032 stp = find_stateid(stateid, flags);
3033 if (stp == NULL) {
3034 /*
3035 * Also, we should make sure this isn't just the result of
3036 * a replayed close:
3037 */
3038 sop = search_close_lru(stateid->si_stateownerid, flags);
3039 if (sop == NULL)
e4e83ea4 3040 return nfserr_bad_stateid;
f8816512
N		 3041 *sopp = sop;
3042 goto check_replay;
3043 }
1da177e4 3044
39325bd0
BF		 3045 *stpp = stp;
3046 *sopp = sop = stp->st_stateowner;
3047
4c4cd222 3048 if (lock) {
4c4cd222 3049 clientid_t *lockclid = &lock->v.new.clientid;
1da177e4 3050 struct nfs4_client *clp = sop->so_client;
4c4cd222 3051 int lkflg = 0;
b37ad28b 3052 __be32 status;
4c4cd222
N		 3053
3054 lkflg = setlkflg(lock->lk_type);
3055
3056 if (lock->lk_is_new) {
599e0a22
BF		 3057 if (!sop->so_is_open_owner)
3058 return nfserr_bad_stateid;
60adfc50
AA		 3059 if (!(flags & HAS_SESSION) &&
3060 !same_clid(&clp->cl_clientid, lockclid))
3061 return nfserr_bad_stateid;
599e0a22
BF		 3062 /* stp is the open stateid */
3063 status = nfs4_check_openmode(stp, lkflg);
3064 if (status)
3065 return status;
3066 } else {
3067 /* stp is the lock stateid */
3068 status = nfs4_check_openmode(stp->st_openstp, lkflg);
3069 if (status)
3070 return status;
4c4cd222 3071 }
1da177e4
LT		 3072 }
3073
f3362737 3074 if (nfs4_check_fh(current_fh, stp)) {
2fdada03 3075 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
3a4f98bb 3076 return nfserr_bad_stateid;
1da177e4
LT		 3077 }
3078
1da177e4
LT		 3079 /*
3080 * We now validate the seqid and stateid generation numbers.
3081 * For the moment, we ignore the possibility of
3082 * generation number wraparound.
3083 */
6668958f 3084 if (!(flags & HAS_SESSION) && seqid != sop->so_seqid)
1da177e4
LT		 3085 goto check_replay;
3086
3a4f98bb 3087 if (sop->so_confirmed && flags & CONFIRM) {
2fdada03 3088 dprintk("NFSD: preprocess_seqid_op: expected"
3a4f98bb
N		 3089 " unconfirmed stateowner!\n");
3090 return nfserr_bad_stateid;
1da177e4 3091 }
3a4f98bb 3092 if (!sop->so_confirmed && !(flags & CONFIRM)) {
2fdada03 3093 dprintk("NFSD: preprocess_seqid_op: stateowner not"
3a4f98bb
N		 3094 " confirmed yet!\n");
3095 return nfserr_bad_stateid;
1da177e4 3096 }
6668958f 3097 status = check_stateid_generation(stateid, &stp->st_stateid, flags);
0836f587
BF		 3098 if (status)
3099 return status;
52fd004e 3100 renew_client(sop->so_client);
3a4f98bb 3101 return nfs_ok;
1da177e4 3102
1da177e4 3103check_replay:
bd9aac52 3104 if (seqid == sop->so_seqid - 1) {
849823c5 3105 dprintk("NFSD: preprocess_seqid_op: retransmission?\n");
1da177e4 3106 /* indicate replay to calling function */
a90b061c 3107 return nfserr_replay_me;
1da177e4 3108 }
2fdada03 3109 dprintk("NFSD: preprocess_seqid_op: bad seqid (expected %d, got %d)\n",
3a4f98bb
N		 3110 sop->so_seqid, seqid);
3111 *sopp = NULL;
3112 return nfserr_bad_seqid;
1da177e4
LT		 3113}
3114
b37ad28b 3115__be32
ca364317 3116nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
a4f1706a 3117 struct nfsd4_open_confirm *oc)
1da177e4 3118{
b37ad28b 3119 __be32 status;
1da177e4
LT		 3120 struct nfs4_stateowner *sop;
3121 struct nfs4_stateid *stp;
3122
3123 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
ca364317
BF		 3124 (int)cstate->current_fh.fh_dentry->d_name.len,
3125 cstate->current_fh.fh_dentry->d_name.name);
1da177e4 3126
ca364317 3127 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
a8cddc5d
BF		 3128 if (status)
3129 return status;
1da177e4
LT		 3130
3131 nfs4_lock_state();
3132
dd453dfd 3133 if ((status = nfs4_preprocess_seqid_op(cstate,
ca364317 3134 oc->oc_seqid, &oc->oc_req_stateid,
f3362737 3135 CONFIRM | OPEN_STATE,
1da177e4
LT		 3136 &oc->oc_stateowner, &stp, NULL)))
3137 goto out;
3138
3139 sop = oc->oc_stateowner;
3140 sop->so_confirmed = 1;
3141 update_stateid(&stp->st_stateid);
3142 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
8c10cbdb
BH		 3143 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3144 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
c7b9a459
N		 3145
3146 nfsd4_create_clid_dir(sop->so_client);
1da177e4 3147out:
f2327d9a 3148 if (oc->oc_stateowner) {
1da177e4 3149 nfs4_get_stateowner(oc->oc_stateowner);
a4f1706a 3150 cstate->replay_owner = oc->oc_stateowner;
f2327d9a 3151 }
1da177e4
LT		 3152 nfs4_unlock_state();
3153 return status;
3154}
3155
3156
3157/*
3158 * unset all bits in union bitmap (bmap) that
3159 * do not exist in share (from successful OPEN_DOWNGRADE)
3160 */
3161static void
3162reset_union_bmap_access(unsigned long access, unsigned long *bmap)
3163{
3164 int i;
3165 for (i = 1; i < 4; i++) {
3166 if ((i & access) != i)
3167 __clear_bit(i, bmap);
3168 }
3169}
3170
3171static void
3172reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3173{
3174 int i;
3175 for (i = 0; i < 4; i++) {
3176 if ((i & deny) != i)
3177 __clear_bit(i, bmap);
3178 }
3179}
3180
b37ad28b 3181__be32
ca364317
BF		 3182nfsd4_open_downgrade(struct svc_rqst *rqstp,
3183 struct nfsd4_compound_state *cstate,
a4f1706a 3184 struct nfsd4_open_downgrade *od)
1da177e4 3185{
b37ad28b 3186 __be32 status;
1da177e4
LT		 3187 struct nfs4_stateid *stp;
3188 unsigned int share_access;
3189
3190 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
ca364317
BF		 3191 (int)cstate->current_fh.fh_dentry->d_name.len,
3192 cstate->current_fh.fh_dentry->d_name.name);
1da177e4 3193
d87a8ade 3194 if (!access_valid(od->od_share_access, cstate->minorversion)
ba5a6a19 3195 || !deny_valid(od->od_share_deny))
1da177e4
LT		 3196 return nfserr_inval;
3197
3198 nfs4_lock_state();
dd453dfd 3199 if ((status = nfs4_preprocess_seqid_op(cstate,
ca364317 3200 od->od_seqid,
1da177e4 3201 &od->od_stateid,
f3362737 3202 OPEN_STATE,
1da177e4
LT		 3203 &od->od_stateowner, &stp, NULL)))
3204 goto out;
3205
3206 status = nfserr_inval;
3207 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3208 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3209 stp->st_access_bmap, od->od_share_access);
3210 goto out;
3211 }
3212 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3213 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3214 stp->st_deny_bmap, od->od_share_deny);
3215 goto out;
3216 }
3217 set_access(&share_access, stp->st_access_bmap);
f9d7562f 3218 nfs4_file_downgrade(stp->st_file, share_access & ~od->od_share_access);
1da177e4
LT		 3219
3220 reset_union_bmap_access(od->od_share_access, &stp->st_access_bmap);
3221 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3222
3223 update_stateid(&stp->st_stateid);
3224 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3225 status = nfs_ok;
3226out:
f2327d9a 3227 if (od->od_stateowner) {
1da177e4 3228 nfs4_get_stateowner(od->od_stateowner);
a4f1706a 3229 cstate->replay_owner = od->od_stateowner;
f2327d9a 3230 }
1da177e4
LT		 3231 nfs4_unlock_state();
3232 return status;
3233}
3234
3235/*
3236 * nfs4_unlock_state() called after encode
3237 */
b37ad28b 3238__be32
ca364317 3239nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
a4f1706a 3240 struct nfsd4_close *close)
1da177e4 3241{
b37ad28b 3242 __be32 status;
1da177e4
LT		 3243 struct nfs4_stateid *stp;
3244
3245 dprintk("NFSD: nfsd4_close on file %.*s\n",
ca364317
BF		 3246 (int)cstate->current_fh.fh_dentry->d_name.len,
3247 cstate->current_fh.fh_dentry->d_name.name);
1da177e4
LT		 3248
3249 nfs4_lock_state();
3250 /* check close_lru for replay */
dd453dfd 3251 if ((status = nfs4_preprocess_seqid_op(cstate,
ca364317 3252 close->cl_seqid,
1da177e4 3253 &close->cl_stateid,
f3362737 3254 OPEN_STATE | CLOSE_STATE,
1da177e4
LT		 3255 &close->cl_stateowner, &stp, NULL)))
3256 goto out;
1da177e4
LT		 3257 status = nfs_ok;
3258 update_stateid(&stp->st_stateid);
3259 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3260
04ef5954 3261 /* release_stateid() calls nfsd_close() if needed */
2283963f 3262 release_open_stateid(stp);
04ef5954
BF		 3263
3264 /* place unused nfs4_stateowners on so_close_lru list to be
3265 * released by the laundromat service after the lease period
3266 * to enable us to handle CLOSE replay
3267 */
3268 if (list_empty(&close->cl_stateowner->so_stateids))
3269 move_to_close_lru(close->cl_stateowner);
1da177e4 3270out:
f2327d9a 3271 if (close->cl_stateowner) {
1da177e4 3272 nfs4_get_stateowner(close->cl_stateowner);
a4f1706a 3273 cstate->replay_owner = close->cl_stateowner;
f2327d9a 3274 }
1da177e4
LT		 3275 nfs4_unlock_state();
3276 return status;
3277}
3278
b37ad28b 3279__be32
ca364317
BF		 3280nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3281 struct nfsd4_delegreturn *dr)
1da177e4 3282{
203a8c8e
BF		 3283 struct nfs4_delegation *dp;
3284 stateid_t *stateid = &dr->dr_stateid;
3285 struct inode *inode;
b37ad28b 3286 __be32 status;
6668958f 3287 int flags = 0;
1da177e4 3288
ca364317 3289 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
203a8c8e
BF		 3290 return status;
3291 inode = cstate->current_fh.fh_dentry->d_inode;
1da177e4 3292
6668958f
AA		 3293 if (nfsd4_has_session(cstate))
3294 flags |= HAS_SESSION;
1da177e4 3295 nfs4_lock_state();
203a8c8e
BF		 3296 status = nfserr_bad_stateid;
3297 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3298 goto out;
3299 status = nfserr_stale_stateid;
3300 if (STALE_STATEID(stateid))
3301 goto out;
7e0f7cf5 3302 status = nfserr_bad_stateid;
203a8c8e
BF		 3303 if (!is_delegation_stateid(stateid))
3304 goto out;
203a8c8e 3305 dp = find_delegation_stateid(inode, stateid);
e4e83ea4 3306 if (!dp)
203a8c8e 3307 goto out;
6668958f 3308 status = check_stateid_generation(stateid, &dp->dl_stateid, flags);
203a8c8e
BF		 3309 if (status)
3310 goto out;
3311 renew_client(dp->dl_client);
3312
3313 unhash_delegation(dp);
1da177e4 3314out:
203a8c8e
BF		 3315 nfs4_unlock_state();
3316
1da177e4
LT		 3317 return status;
3318}
3319
3320
3321/*
3322 * Lock owner state (byte-range locks)
3323 */
3324#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3325#define LOCK_HASH_BITS 8
3326#define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3327#define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3328
87df4de8
BH		 3329static inline u64
3330end_offset(u64 start, u64 len)
3331{
3332 u64 end;
3333
3334 end = start + len;
3335 return end >= start ? end: NFS4_MAX_UINT64;
3336}
3337
3338/* last octet in a range */
3339static inline u64
3340last_byte_offset(u64 start, u64 len)
3341{
3342 u64 end;
3343
3344 BUG_ON(!len);
3345 end = start + len;
3346 return end > start ? end - 1: NFS4_MAX_UINT64;
3347}
3348
1da177e4
LT		 3349#define lockownerid_hashval(id) \
3350 ((id) & LOCK_HASH_MASK)
3351
3352static inline unsigned int
3353lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3354 struct xdr_netobj *ownername)
3355{
3356 return (file_hashval(inode) + cl_id
3357 + opaque_hashval(ownername->data, ownername->len))
3358 & LOCK_HASH_MASK;
3359}
3360
3361static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3362static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3363static struct list_head lockstateid_hashtbl[STATEID_HASH_SIZE];
3364
fd39ca9a 3365static struct nfs4_stateid *
1da177e4
LT		 3366find_stateid(stateid_t *stid, int flags)
3367{
9346eff0 3368 struct nfs4_stateid *local;
1da177e4
LT		 3369 u32 st_id = stid->si_stateownerid;
3370 u32 f_id = stid->si_fileid;
3371 unsigned int hashval;
3372
3373 dprintk("NFSD: find_stateid flags 0x%x\n",flags);
9346eff0 3374 if (flags & (LOCK_STATE | RD_STATE | WR_STATE)) {
1da177e4
LT		 3375 hashval = stateid_hashval(st_id, f_id);
3376 list_for_each_entry(local, &lockstateid_hashtbl[hashval], st_hash) {
3377 if ((local->st_stateid.si_stateownerid == st_id) &&
3378 (local->st_stateid.si_fileid == f_id))
3379 return local;
3380 }
3381 }
9346eff0
KK		 3382
3383 if (flags & (OPEN_STATE | RD_STATE | WR_STATE)) {
1da177e4
LT		 3384 hashval = stateid_hashval(st_id, f_id);
3385 list_for_each_entry(local, &stateid_hashtbl[hashval], st_hash) {
3386 if ((local->st_stateid.si_stateownerid == st_id) &&
3387 (local->st_stateid.si_fileid == f_id))
3388 return local;
3389 }
849823c5 3390 }
1da177e4
LT		 3391 return NULL;
3392}
3393
3394static struct nfs4_delegation *
3395find_delegation_stateid(struct inode *ino, stateid_t *stid)
3396{
13cd2184
N		 3397 struct nfs4_file *fp;
3398 struct nfs4_delegation *dl;
1da177e4 3399
8c10cbdb
BH		 3400 dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
3401 STATEID_VAL(stid));
1da177e4 3402
1da177e4 3403 fp = find_file(ino);
13cd2184
N		 3404 if (!fp)
3405 return NULL;
3406 dl = find_delegation_file(fp, stid);
3407 put_nfs4_file(fp);
3408 return dl;
1da177e4
LT		 3409}
3410
3411/*
3412 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3413 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3414 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3415 * locking, this prevents us from being completely protocol-compliant. The
3416 * real solution to this problem is to start using unsigned file offsets in
3417 * the VFS, but this is a very deep change!
3418 */
3419static inline void
3420nfs4_transform_lock_offset(struct file_lock *lock)
3421{
3422 if (lock->fl_start < 0)
3423 lock->fl_start = OFFSET_MAX;
3424 if (lock->fl_end < 0)
3425 lock->fl_end = OFFSET_MAX;
3426}
3427
d5b9026a
N		 3428/* Hack!: For now, we're defining this just so we can use a pointer to it
3429 * as a unique cookie to identify our (NFSv4's) posix locks. */
7b021967 3430static const struct lock_manager_operations nfsd_posix_mng_ops = {
d5b9026a 3431};
1da177e4
LT		 3432
3433static inline void
3434nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3435{
d5b9026a 3436 struct nfs4_stateowner *sop;
1da177e4 3437
d5b9026a
N		 3438 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3439 sop = (struct nfs4_stateowner *) fl->fl_owner;
1da177e4
LT		 3440 kref_get(&sop->so_ref);
3441 deny->ld_sop = sop;
3442 deny->ld_clientid = sop->so_client->cl_clientid;
d5b9026a
N		 3443 } else {
3444 deny->ld_sop = NULL;
3445 deny->ld_clientid.cl_boot = 0;
3446 deny->ld_clientid.cl_id = 0;
1da177e4
LT		 3447 }
3448 deny->ld_start = fl->fl_start;
87df4de8
BH		 3449 deny->ld_length = NFS4_MAX_UINT64;
3450 if (fl->fl_end != NFS4_MAX_UINT64)
1da177e4
LT		 3451 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3452 deny->ld_type = NFS4_READ_LT;
3453 if (fl->fl_type != F_RDLCK)
3454 deny->ld_type = NFS4_WRITE_LT;
3455}
3456
1da177e4
LT		 3457static struct nfs4_stateowner *
3458find_lockstateowner_str(struct inode *inode, clientid_t *clid,
3459 struct xdr_netobj *owner)
3460{
3461 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3462 struct nfs4_stateowner *op;
3463
3464 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
599e0a22 3465 if (same_owner_str(op, owner, clid))
1da177e4
LT		 3466 return op;
3467 }
3468 return NULL;
3469}
3470
3471/*
3472 * Alloc a lock owner structure.
3473 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
3474 * occured.
3475 *
3476 * strhashval = lock_ownerstr_hashval
1da177e4
LT		 3477 */
3478
3479static struct nfs4_stateowner *
3480alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3481 struct nfs4_stateowner *sop;
3482 struct nfs4_replay *rp;
3483 unsigned int idhashval;
3484
3485 if (!(sop = alloc_stateowner(&lock->lk_new_owner)))
3486 return NULL;
3487 idhashval = lockownerid_hashval(current_ownerid);
3488 INIT_LIST_HEAD(&sop->so_idhash);
3489 INIT_LIST_HEAD(&sop->so_strhash);
3490 INIT_LIST_HEAD(&sop->so_perclient);
ea1da636
N		 3491 INIT_LIST_HEAD(&sop->so_stateids);
3492 INIT_LIST_HEAD(&sop->so_perstateid);
1da177e4
LT		 3493 INIT_LIST_HEAD(&sop->so_close_lru); /* not used */
3494 sop->so_time = 0;
3495 list_add(&sop->so_idhash, &lock_ownerid_hashtbl[idhashval]);
3496 list_add(&sop->so_strhash, &lock_ownerstr_hashtbl[strhashval]);
ea1da636 3497 list_add(&sop->so_perstateid, &open_stp->st_lockowners);
1da177e4
LT		 3498 sop->so_is_open_owner = 0;
3499 sop->so_id = current_ownerid++;
3500 sop->so_client = clp;
b59e3c0e
NB		 3501 /* It is the openowner seqid that will be incremented in encode in the
3502 * case of new lockowners; so increment the lock seqid manually: */
3503 sop->so_seqid = lock->lk_new_lock_seqid + 1;
1da177e4
LT		 3504 sop->so_confirmed = 1;
3505 rp = &sop->so_replay;
de1ae286 3506 rp->rp_status = nfserr_serverfault;
1da177e4
LT		 3507 rp->rp_buflen = 0;
3508 rp->rp_buf = rp->rp_ibuf;
3509 return sop;
3510}
3511
fd39ca9a 3512static struct nfs4_stateid *
1da177e4
LT		 3513alloc_init_lock_stateid(struct nfs4_stateowner *sop, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3514{
3515 struct nfs4_stateid *stp;
3516 unsigned int hashval = stateid_hashval(sop->so_id, fp->fi_id);
3517
5ac049ac
N		 3518 stp = nfs4_alloc_stateid();
3519 if (stp == NULL)
1da177e4
LT		 3520 goto out;
3521 INIT_LIST_HEAD(&stp->st_hash);
3522 INIT_LIST_HEAD(&stp->st_perfile);
ea1da636
N		 3523 INIT_LIST_HEAD(&stp->st_perstateowner);
3524 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
1da177e4 3525 list_add(&stp->st_hash, &lockstateid_hashtbl[hashval]);
8beefa24 3526 list_add(&stp->st_perfile, &fp->fi_stateids);
ea1da636 3527 list_add(&stp->st_perstateowner, &sop->so_stateids);
1da177e4 3528 stp->st_stateowner = sop;
13cd2184 3529 get_nfs4_file(fp);
1da177e4 3530 stp->st_file = fp;
e4e83ea4 3531 stp->st_stateid.si_boot = boot_time;
1da177e4
LT		 3532 stp->st_stateid.si_stateownerid = sop->so_id;
3533 stp->st_stateid.si_fileid = fp->fi_id;
3534 stp->st_stateid.si_generation = 0;
1da177e4 3535 stp->st_deny_bmap = open_stp->st_deny_bmap;
4c4cd222 3536 stp->st_openstp = open_stp;
1da177e4
LT		 3537
3538out:
3539 return stp;
3540}
3541
fd39ca9a 3542static int
1da177e4
LT		 3543check_lock_length(u64 offset, u64 length)
3544{
87df4de8 3545 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
1da177e4
LT		 3546 LOFF_OVERFLOW(offset, length)));
3547}
3548
3549/*
3550 * LOCK operation
3551 */
b37ad28b 3552__be32
ca364317 3553nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
a4f1706a 3554 struct nfsd4_lock *lock)
1da177e4 3555{
3e9e3dbe 3556 struct nfs4_stateowner *open_sop = NULL;
b59e3c0e 3557 struct nfs4_stateowner *lock_sop = NULL;
1da177e4 3558 struct nfs4_stateid *lock_stp;
7d947842
BF		 3559 struct nfs4_file *fp;
3560 struct file *filp = NULL;
1da177e4 3561 struct file_lock file_lock;
8dc7c311 3562 struct file_lock conflock;
b37ad28b 3563 __be32 status = 0;
1da177e4 3564 unsigned int strhashval;
150b3934 3565 unsigned int cmd;
b8dd7b9a 3566 int err;
1da177e4
LT		 3567
3568 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3569 (long long) lock->lk_offset,
3570 (long long) lock->lk_length);
3571
1da177e4
LT		 3572 if (check_lock_length(lock->lk_offset, lock->lk_length))
3573 return nfserr_inval;
3574
ca364317 3575 if ((status = fh_verify(rqstp, &cstate->current_fh,
8837abca 3576 S_IFREG, NFSD_MAY_LOCK))) {
a6f6ef2f
AA		 3577 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3578 return status;
3579 }
3580
1da177e4
LT		 3581 nfs4_lock_state();
3582
3583 if (lock->lk_is_new) {
893f8770
N		 3584 /*
3585 * Client indicates that this is a new lockowner.
3586 * Use open owner and open stateid to create lock owner and
3587 * lock stateid.
3588 */
1da177e4 3589 struct nfs4_stateid *open_stp = NULL;
1da177e4
LT		 3590
3591 status = nfserr_stale_clientid;
60adfc50
AA		 3592 if (!nfsd4_has_session(cstate) &&
3593 STALE_CLIENTID(&lock->lk_new_clientid))
1da177e4 3594 goto out;
1da177e4 3595
1da177e4 3596 /* validate and update open stateid and open seqid */
dd453dfd 3597 status = nfs4_preprocess_seqid_op(cstate,
1da177e4
LT		 3598 lock->lk_new_open_seqid,
3599 &lock->lk_new_open_stateid,
f3362737 3600 OPEN_STATE,
3a65588a 3601 &lock->lk_replay_owner, &open_stp,
b59e3c0e 3602 lock);
37515177 3603 if (status)
1da177e4 3604 goto out;
3a65588a 3605 open_sop = lock->lk_replay_owner;
1da177e4
LT		 3606 /* create lockowner and lock stateid */
3607 fp = open_stp->st_file;
3608 strhashval = lock_ownerstr_hashval(fp->fi_inode,
3609 open_sop->so_client->cl_clientid.cl_id,
3610 &lock->v.new.owner);
3e9e3dbe
N		 3611 /* XXX: Do we need to check for duplicate stateowners on
3612 * the same file, or should they just be allowed (and
3613 * create new stateids)? */
1da177e4 3614 status = nfserr_resource;
b59e3c0e
NB		 3615 lock_sop = alloc_init_lock_stateowner(strhashval,
3616 open_sop->so_client, open_stp, lock);
3617 if (lock_sop == NULL)
1da177e4 3618 goto out;
b59e3c0e 3619 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
8a280510 3620 if (lock_stp == NULL)
1da177e4 3621 goto out;
1da177e4
LT		 3622 } else {
3623 /* lock (lock owner + lock stateid) already exists */
dd453dfd 3624 status = nfs4_preprocess_seqid_op(cstate,
1da177e4
LT		 3625 lock->lk_old_lock_seqid,
3626 &lock->lk_old_lock_stateid,
f3362737 3627 LOCK_STATE,
3a65588a 3628 &lock->lk_replay_owner, &lock_stp, lock);
1da177e4
LT		 3629 if (status)
3630 goto out;
3a65588a 3631 lock_sop = lock->lk_replay_owner;
7d947842 3632 fp = lock_stp->st_file;
1da177e4 3633 }
3a65588a 3634 /* lock->lk_replay_owner and lock_stp have been created or found */
1da177e4 3635
0dd395dc 3636 status = nfserr_grace;
af558e33 3637 if (locks_in_grace() && !lock->lk_reclaim)
0dd395dc
N		 3638 goto out;
3639 status = nfserr_no_grace;
af558e33 3640 if (!locks_in_grace() && lock->lk_reclaim)
0dd395dc
N		 3641 goto out;
3642
1da177e4
LT		 3643 locks_init_lock(&file_lock);
3644 switch (lock->lk_type) {
3645 case NFS4_READ_LT:
3646 case NFS4_READW_LT:
7d947842
BF		 3647 if (find_readable_file(lock_stp->st_file)) {
3648 nfs4_get_vfs_file(rqstp, fp, &cstate->current_fh, NFS4_SHARE_ACCESS_READ);
3649 filp = find_readable_file(lock_stp->st_file);
3650 }
1da177e4 3651 file_lock.fl_type = F_RDLCK;
150b3934 3652 cmd = F_SETLK;
1da177e4
LT		 3653 break;
3654 case NFS4_WRITE_LT:
3655 case NFS4_WRITEW_LT:
7d947842
BF		 3656 if (find_writeable_file(lock_stp->st_file)) {
3657 nfs4_get_vfs_file(rqstp, fp, &cstate->current_fh, NFS4_SHARE_ACCESS_WRITE);
3658 filp = find_writeable_file(lock_stp->st_file);
3659 }
1da177e4 3660 file_lock.fl_type = F_WRLCK;
150b3934 3661 cmd = F_SETLK;
1da177e4
LT		 3662 break;
3663 default:
3664 status = nfserr_inval;
3665 goto out;
3666 }
f9d7562f
BF		 3667 if (!filp) {
3668 status = nfserr_openmode;
3669 goto out;
3670 }
b59e3c0e 3671 file_lock.fl_owner = (fl_owner_t)lock_sop;
1da177e4
LT		 3672 file_lock.fl_pid = current->tgid;
3673 file_lock.fl_file = filp;
3674 file_lock.fl_flags = FL_POSIX;
d5b9026a 3675 file_lock.fl_lmops = &nfsd_posix_mng_ops;
1da177e4
LT		 3676
3677 file_lock.fl_start = lock->lk_offset;
87df4de8 3678 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
1da177e4
LT		 3679 nfs4_transform_lock_offset(&file_lock);
3680
3681 /*
3682 * Try to lock the file in the VFS.
3683 * Note: locks.c uses the BKL to protect the inode's lock list.
3684 */
3685
fd85b817 3686 err = vfs_lock_file(filp, cmd, &file_lock, &conflock);
b8dd7b9a 3687 switch (-err) {
1da177e4
LT		 3688 case 0: /* success! */
3689 update_stateid(&lock_stp->st_stateid);
3690 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
3691 sizeof(stateid_t));
b8dd7b9a 3692 status = 0;
eb76b3fd
AA		 3693 break;
3694 case (EAGAIN): /* conflock holds conflicting lock */
3695 status = nfserr_denied;
3696 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
3697 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
3698 break;
1da177e4
LT		 3699 case (EDEADLK):
3700 status = nfserr_deadlock;
eb76b3fd 3701 break;
1da177e4 3702 default:
fd85b817 3703 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
eb76b3fd
AA		 3704 status = nfserr_resource;
3705 break;
1da177e4 3706 }
1da177e4 3707out:
8a280510 3708 if (status && lock->lk_is_new && lock_sop)
f044ff83 3709 release_lockowner(lock_sop);
3a65588a
BF		 3710 if (lock->lk_replay_owner) {
3711 nfs4_get_stateowner(lock->lk_replay_owner);
a4f1706a 3712 cstate->replay_owner = lock->lk_replay_owner;
f2327d9a 3713 }
1da177e4
LT		 3714 nfs4_unlock_state();
3715 return status;
3716}
3717
55ef1274
BF		 3718/*
3719 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
3720 * so we do a temporary open here just to get an open file to pass to
3721 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
3722 * inode operation.)
3723 */
3724static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
3725{
3726 struct file *file;
3727 int err;
3728
3729 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
3730 if (err)
3731 return err;
3732 err = vfs_test_lock(file, lock);
3733 nfsd_close(file);
3734 return err;
3735}
3736
1da177e4
LT		 3737/*
3738 * LOCKT operation
3739 */
b37ad28b 3740__be32
ca364317
BF		 3741nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3742 struct nfsd4_lockt *lockt)
1da177e4
LT		 3743{
3744 struct inode *inode;
1da177e4 3745 struct file_lock file_lock;
fd85b817 3746 int error;
b37ad28b 3747 __be32 status;
1da177e4 3748
af558e33 3749 if (locks_in_grace())
1da177e4
LT		 3750 return nfserr_grace;
3751
3752 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
3753 return nfserr_inval;
3754
3755 lockt->lt_stateowner = NULL;
3756 nfs4_lock_state();
3757
3758 status = nfserr_stale_clientid;
60adfc50 3759 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
1da177e4 3760 goto out;
1da177e4 3761
ca364317 3762 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0))) {
849823c5 3763 dprintk("NFSD: nfsd4_lockt: fh_verify() failed!\n");
1da177e4
LT		 3764 if (status == nfserr_symlink)
3765 status = nfserr_inval;
3766 goto out;
3767 }
3768
ca364317 3769 inode = cstate->current_fh.fh_dentry->d_inode;
1da177e4
LT		 3770 locks_init_lock(&file_lock);
3771 switch (lockt->lt_type) {
3772 case NFS4_READ_LT:
3773 case NFS4_READW_LT:
3774 file_lock.fl_type = F_RDLCK;
3775 break;
3776 case NFS4_WRITE_LT:
3777 case NFS4_WRITEW_LT:
3778 file_lock.fl_type = F_WRLCK;
3779 break;
3780 default:
2fdada03 3781 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
1da177e4
LT		 3782 status = nfserr_inval;
3783 goto out;
3784 }
3785
3786 lockt->lt_stateowner = find_lockstateowner_str(inode,
3787 &lockt->lt_clientid, &lockt->lt_owner);
3788 if (lockt->lt_stateowner)
3789 file_lock.fl_owner = (fl_owner_t)lockt->lt_stateowner;
3790 file_lock.fl_pid = current->tgid;
3791 file_lock.fl_flags = FL_POSIX;
3792
3793 file_lock.fl_start = lockt->lt_offset;
87df4de8 3794 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
1da177e4
LT		 3795
3796 nfs4_transform_lock_offset(&file_lock);
3797
1da177e4 3798 status = nfs_ok;
55ef1274 3799 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
fd85b817
ME		 3800 if (error) {
3801 status = nfserrno(error);
3802 goto out;
3803 }
9d6a8c5c 3804 if (file_lock.fl_type != F_UNLCK) {
1da177e4 3805 status = nfserr_denied;
9d6a8c5c 3806 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
1da177e4
LT		 3807 }
3808out:
3809 nfs4_unlock_state();
3810 return status;
3811}
3812
b37ad28b 3813__be32
ca364317 3814nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
a4f1706a 3815 struct nfsd4_locku *locku)
1da177e4
LT		 3816{
3817 struct nfs4_stateid *stp;
3818 struct file *filp = NULL;
3819 struct file_lock file_lock;
b37ad28b 3820 __be32 status;
b8dd7b9a 3821 int err;
1da177e4
LT		 3822
3823 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
3824 (long long) locku->lu_offset,
3825 (long long) locku->lu_length);
3826
3827 if (check_lock_length(locku->lu_offset, locku->lu_length))
3828 return nfserr_inval;
3829
3830 nfs4_lock_state();
3831
dd453dfd 3832 if ((status = nfs4_preprocess_seqid_op(cstate,
1da177e4
LT		 3833 locku->lu_seqid,
3834 &locku->lu_stateid,
f3362737 3835 LOCK_STATE,
1da177e4
LT		 3836 &locku->lu_stateowner, &stp, NULL)))
3837 goto out;
3838
f9d7562f
BF		 3839 filp = find_any_file(stp->st_file);
3840 if (!filp) {
3841 status = nfserr_lock_range;
3842 goto out;
3843 }
1da177e4
LT		 3844 BUG_ON(!filp);
3845 locks_init_lock(&file_lock);
3846 file_lock.fl_type = F_UNLCK;
3847 file_lock.fl_owner = (fl_owner_t) locku->lu_stateowner;
3848 file_lock.fl_pid = current->tgid;
3849 file_lock.fl_file = filp;
3850 file_lock.fl_flags = FL_POSIX;
d5b9026a 3851 file_lock.fl_lmops = &nfsd_posix_mng_ops;
1da177e4
LT		 3852 file_lock.fl_start = locku->lu_offset;
3853
87df4de8 3854 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
1da177e4
LT		 3855 nfs4_transform_lock_offset(&file_lock);
3856
3857 /*
3858 * Try to unlock the file in the VFS.
3859 */
fd85b817 3860 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
b8dd7b9a 3861 if (err) {
fd85b817 3862 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
1da177e4
LT		 3863 goto out_nfserr;
3864 }
3865 /*
3866 * OK, unlock succeeded; the only thing left to do is update the stateid.
3867 */
3868 update_stateid(&stp->st_stateid);
3869 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
3870
3871out:
f2327d9a 3872 if (locku->lu_stateowner) {
1da177e4 3873 nfs4_get_stateowner(locku->lu_stateowner);
a4f1706a 3874 cstate->replay_owner = locku->lu_stateowner;
f2327d9a 3875 }
1da177e4
LT		 3876 nfs4_unlock_state();
3877 return status;
3878
3879out_nfserr:
b8dd7b9a 3880 status = nfserrno(err);
1da177e4
LT		 3881 goto out;
3882}
3883
3884/*
3885 * returns
3886 * 1: locks held by lockowner
3887 * 0: no locks held by lockowner
3888 */
3889static int
f9d7562f 3890check_for_locks(struct nfs4_file *filp, struct nfs4_stateowner *lowner)
1da177e4
LT		 3891{
3892 struct file_lock **flpp;
f9d7562f 3893 struct inode *inode = filp->fi_inode;
1da177e4
LT		 3894 int status = 0;
3895
3896 lock_kernel();
3897 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
796dadfd 3898 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
1da177e4
LT		 3899 status = 1;
3900 goto out;
796dadfd 3901 }
1da177e4
LT		 3902 }
3903out:
3904 unlock_kernel();
3905 return status;
3906}
3907
b37ad28b 3908__be32
b591480b
BF		 3909nfsd4_release_lockowner(struct svc_rqst *rqstp,
3910 struct nfsd4_compound_state *cstate,
3911 struct nfsd4_release_lockowner *rlockowner)
1da177e4
LT		 3912{
3913 clientid_t *clid = &rlockowner->rl_clientid;
3e9e3dbe
N		 3914 struct nfs4_stateowner *sop;
3915 struct nfs4_stateid *stp;
1da177e4 3916 struct xdr_netobj *owner = &rlockowner->rl_owner;
3e9e3dbe
N		 3917 struct list_head matches;
3918 int i;
b37ad28b 3919 __be32 status;
1da177e4
LT		 3920
3921 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
3922 clid->cl_boot, clid->cl_id);
3923
3924 /* XXX check for lease expiration */
3925
3926 status = nfserr_stale_clientid;
849823c5 3927 if (STALE_CLIENTID(clid))
1da177e4 3928 return status;
1da177e4
LT		 3929
3930 nfs4_lock_state();
3931
3e9e3dbe
N		 3932 status = nfserr_locks_held;
3933 /* XXX: we're doing a linear search through all the lockowners.
3934 * Yipes! For now we'll just hope clients aren't really using
3935 * release_lockowner much, but eventually we have to fix these
3936 * data structures. */
3937 INIT_LIST_HEAD(&matches);
3938 for (i = 0; i < LOCK_HASH_SIZE; i++) {
3939 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
599e0a22 3940 if (!same_owner_str(sop, owner, clid))
3e9e3dbe
N		 3941 continue;
3942 list_for_each_entry(stp, &sop->so_stateids,
3943 st_perstateowner) {
f9d7562f 3944 if (check_for_locks(stp->st_file, sop))
3e9e3dbe
N		 3945 goto out;
3946 /* Note: so_perclient unused for lockowners,
3947 * so it's OK to fool with here. */
3948 list_add(&sop->so_perclient, &matches);
3949 }
1da177e4 3950 }
3e9e3dbe
N		 3951 }
3952 /* Clients probably won't expect us to return with some (but not all)
3953 * of the lockowner state released; so don't release any until all
3954 * have been checked. */
3955 status = nfs_ok;
0fa822e4
N		 3956 while (!list_empty(&matches)) {
3957 sop = list_entry(matches.next, struct nfs4_stateowner,
3958 so_perclient);
3959 /* unhash_stateowner deletes so_perclient only
3960 * for openowners. */
3961 list_del(&sop->so_perclient);
f044ff83 3962 release_lockowner(sop);
1da177e4
LT		 3963 }
3964out:
3965 nfs4_unlock_state();
3966 return status;
3967}
3968
3969static inline struct nfs4_client_reclaim *
a55370a3 3970alloc_reclaim(void)
1da177e4 3971{
a55370a3 3972 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
1da177e4
LT		 3973}
3974
c7b9a459 3975int
a1bcecd2 3976nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
c7b9a459
N		 3977{
3978 unsigned int strhashval = clientstr_hashval(name);
3979 struct nfs4_client *clp;
3980
a1bcecd2 3981 clp = find_confirmed_client_by_str(name, strhashval, use_exchange_id);
c7b9a459
N		 3982 return clp ? 1 : 0;
3983}
3984
1da177e4
LT		 3985/*
3986 * failure => all reset bets are off, nfserr_no_grace...
3987 */
190e4fbf
N		 3988int
3989nfs4_client_to_reclaim(const char *name)
1da177e4
LT		 3990{
3991 unsigned int strhashval;
3992 struct nfs4_client_reclaim *crp = NULL;
3993
a55370a3
N		 3994 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
3995 crp = alloc_reclaim();
1da177e4
LT		 3996 if (!crp)
3997 return 0;
a55370a3 3998 strhashval = clientstr_hashval(name);
1da177e4
LT		 3999 INIT_LIST_HEAD(&crp->cr_strhash);
4000 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
a55370a3 4001 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
1da177e4
LT		 4002 reclaim_str_hashtbl_size++;
4003 return 1;
4004}
4005
4006static void
4007nfs4_release_reclaim(void)
4008{
4009 struct nfs4_client_reclaim *crp = NULL;
4010 int i;
4011
1da177e4
LT		 4012 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4013 while (!list_empty(&reclaim_str_hashtbl[i])) {
4014 crp = list_entry(reclaim_str_hashtbl[i].next,
4015 struct nfs4_client_reclaim, cr_strhash);
4016 list_del(&crp->cr_strhash);
1da177e4
LT		 4017 kfree(crp);
4018 reclaim_str_hashtbl_size--;
4019 }
4020 }
4021 BUG_ON(reclaim_str_hashtbl_size);
4022}
4023
4024/*
4025 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
fd39ca9a 4026static struct nfs4_client_reclaim *
1da177e4
LT		 4027nfs4_find_reclaim_client(clientid_t *clid)
4028{
4029 unsigned int strhashval;
4030 struct nfs4_client *clp;
4031 struct nfs4_client_reclaim *crp = NULL;
4032
4033
4034 /* find clientid in conf_id_hashtbl */
4035 clp = find_confirmed_client(clid);
4036 if (clp == NULL)
4037 return NULL;
4038
a55370a3
N		 4039 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4040 clp->cl_name.len, clp->cl_name.data,
4041 clp->cl_recdir);
1da177e4
LT		 4042
4043 /* find clp->cl_name in reclaim_str_hashtbl */
a55370a3 4044 strhashval = clientstr_hashval(clp->cl_recdir);
1da177e4 4045 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
a55370a3 4046 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
1da177e4
LT		 4047 return crp;
4048 }
4049 }
4050 return NULL;
4051}
4052
4053/*
4054* Called from OPEN. Look for clientid in reclaim list.
4055*/
b37ad28b 4056__be32
1da177e4
LT		 4057nfs4_check_open_reclaim(clientid_t *clid)
4058{
dfc83565 4059 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
1da177e4
LT		 4060}
4061
ac4d8ff2 4062/* initialization to perform at module load time: */
1da177e4 4063
e8ff2a84 4064int
ac4d8ff2 4065nfs4_state_init(void)
1da177e4 4066{
e8ff2a84 4067 int i, status;
1da177e4 4068
e8ff2a84
BF		 4069 status = nfsd4_init_slabs();
4070 if (status)
4071 return status;
1da177e4
LT		 4072 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4073 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4074 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4075 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4076 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
02cb2858 4077 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
1da177e4 4078 }
5282fd72
ME		 4079 for (i = 0; i < SESSION_HASH_SIZE; i++)
4080 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
1da177e4
LT		 4081 for (i = 0; i < FILE_HASH_SIZE; i++) {
4082 INIT_LIST_HEAD(&file_hashtbl[i]);
4083 }
4084 for (i = 0; i < OWNER_HASH_SIZE; i++) {
4085 INIT_LIST_HEAD(&ownerstr_hashtbl[i]);
4086 INIT_LIST_HEAD(&ownerid_hashtbl[i]);
4087 }
4088 for (i = 0; i < STATEID_HASH_SIZE; i++) {
4089 INIT_LIST_HEAD(&stateid_hashtbl[i]);
4090 INIT_LIST_HEAD(&lockstateid_hashtbl[i]);
4091 }
4092 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4093 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
4094 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
4095 }
1da177e4 4096 memset(&onestateid, ~0, sizeof(stateid_t));
1da177e4
LT		 4097 INIT_LIST_HEAD(&close_lru);
4098 INIT_LIST_HEAD(&client_lru);
4099 INIT_LIST_HEAD(&del_recall_lru);
ac4d8ff2 4100 reclaim_str_hashtbl_size = 0;
e8ff2a84 4101 return 0;
ac4d8ff2
N		 4102}
4103
190e4fbf
N		 4104static void
4105nfsd4_load_reboot_recovery_data(void)
4106{
4107 int status;
4108
0964a3d3
N		 4109 nfs4_lock_state();
4110 nfsd4_init_recdir(user_recovery_dirname);
190e4fbf 4111 status = nfsd4_recdir_load();
0964a3d3 4112 nfs4_unlock_state();
190e4fbf
N		 4113 if (status)
4114 printk("NFSD: Failure reading reboot recovery data\n");
4115}
4116
c2f1a551
MS		 4117/*
4118 * Since the lifetime of a delegation isn't limited to that of an open, a
4119 * client may quite reasonably hang on to a delegation as long as it has
4120 * the inode cached. This becomes an obvious problem the first time a
4121 * client's inode cache approaches the size of the server's total memory.
4122 *
4123 * For now we avoid this problem by imposing a hard limit on the number
4124 * of delegations, which varies according to the server's memory size.
4125 */
4126static void
4127set_max_delegations(void)
4128{
4129 /*
4130 * Allow at most 4 delegations per megabyte of RAM. Quick
4131 * estimates suggest that in the worst case (where every delegation
4132 * is for a different inode), a delegation could take about 1.5K,
4133 * giving a worst case usage of about 6% of memory.
4134 */
4135 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4136}
4137
ac4d8ff2
N		 4138/* initialization to perform when the nfsd service is started: */
4139
29ab23cc 4140static int
ac4d8ff2
N		 4141__nfs4_state_start(void)
4142{
b5a1a81e
BF		 4143 int ret;
4144
1da177e4 4145 boot_time = get_seconds();
af558e33 4146 locks_start_grace(&nfsd4_manager);
9a8db97e 4147 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
e46b498c 4148 nfsd4_grace);
b5a1a81e
BF		 4149 ret = set_callback_cred();
4150 if (ret)
4151 return -ENOMEM;
58da282b 4152 laundry_wq = create_singlethread_workqueue("nfsd4");
29ab23cc
BF		 4153 if (laundry_wq == NULL)
4154 return -ENOMEM;
b5a1a81e
BF		 4155 ret = nfsd4_create_callback_queue();
4156 if (ret)
4157 goto out_free_laundry;
e46b498c 4158 queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
c2f1a551 4159 set_max_delegations();
b5a1a81e
BF		 4160 return 0;
4161out_free_laundry:
4162 destroy_workqueue(laundry_wq);
4163 return ret;
1da177e4
LT		 4164}
4165
29ab23cc 4166int
76a3550e 4167nfs4_state_start(void)
1da177e4 4168{
190e4fbf 4169 nfsd4_load_reboot_recovery_data();
4ad9a344 4170 return __nfs4_state_start();
1da177e4
LT		 4171}
4172
1da177e4
LT		 4173static void
4174__nfs4_state_shutdown(void)
4175{
4176 int i;
4177 struct nfs4_client *clp = NULL;
4178 struct nfs4_delegation *dp = NULL;
1da177e4
LT		 4179 struct list_head *pos, *next, reaplist;
4180
1da177e4
LT		 4181 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4182 while (!list_empty(&conf_id_hashtbl[i])) {
4183 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4184 expire_client(clp);
4185 }
4186 while (!list_empty(&unconf_str_hashtbl[i])) {
4187 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4188 expire_client(clp);
4189 }
4190 }
4191 INIT_LIST_HEAD(&reaplist);
4192 spin_lock(&recall_lock);
4193 list_for_each_safe(pos, next, &del_recall_lru) {
4194 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4195 list_move(&dp->dl_recall_lru, &reaplist);
4196 }
4197 spin_unlock(&recall_lock);
4198 list_for_each_safe(pos, next, &reaplist) {
4199 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4200 list_del_init(&dp->dl_recall_lru);
4201 unhash_delegation(dp);
4202 }
4203
190e4fbf 4204 nfsd4_shutdown_recdir();
1da177e4
LT		 4205}
4206
4207void
4208nfs4_state_shutdown(void)
4209{
5e8d5c29
N		 4210 cancel_rearming_delayed_workqueue(laundry_wq, &laundromat_work);
4211 destroy_workqueue(laundry_wq);
2c5e7615 4212 locks_end_grace(&nfsd4_manager);
1da177e4
LT		 4213 nfs4_lock_state();
4214 nfs4_release_reclaim();
4215 __nfs4_state_shutdown();
1da177e4 4216 nfs4_unlock_state();
c3935e30 4217 nfsd4_destroy_callback_queue();
1da177e4
LT		 4218}
4219
3dd98a3b
JL		 4220/*
4221 * user_recovery_dirname is protected by the nfsd_mutex since it's only
4222 * accessed when nfsd is starting.
4223 */
0964a3d3
N		 4224static void
4225nfs4_set_recdir(char *recdir)
4226{
0964a3d3 4227 strcpy(user_recovery_dirname, recdir);
0964a3d3
N		 4228}
4229
4230/*
4231 * Change the NFSv4 recovery directory to recdir.
4232 */
4233int
4234nfs4_reset_recoverydir(char *recdir)
4235{
4236 int status;
a63bb996 4237 struct path path;
0964a3d3 4238
a63bb996 4239 status = kern_path(recdir, LOOKUP_FOLLOW, &path);
0964a3d3
N		 4240 if (status)
4241 return status;
4242 status = -ENOTDIR;
a63bb996 4243 if (S_ISDIR(path.dentry->d_inode->i_mode)) {
0964a3d3
N		 4244 nfs4_set_recdir(recdir);
4245 status = 0;
4246 }
a63bb996 4247 path_put(&path);
0964a3d3
N		 4248 return status;
4249}
4250
3dd98a3b
JL		 4251char *
4252nfs4_recoverydir(void)
4253{
4254 return user_recovery_dirname;
4255}
Linux kernel - Deliverables
This page took 0.768264 seconds and 5 git commands to generate.