2 * Copyright (c) 2001 The Regents of the University of Michigan.
5 * Kendrick Smith <kmsmith@umich.edu>
6 * Andy Adamson <kandros@umich.edu>
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
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.
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.
35 #include <linux/file.h>
37 #include <linux/slab.h>
38 #include <linux/namei.h>
39 #include <linux/swap.h>
40 #include <linux/pagemap.h>
41 #include <linux/sunrpc/svcauth_gss.h>
42 #include <linux/sunrpc/clnt.h>
46 #define NFSDDBG_FACILITY NFSDDBG_PROC
49 time_t nfsd4_lease = 90; /* default lease time */
50 time_t nfsd4_grace = 90;
51 static time_t boot_time;
52 static u32 current_ownerid = 1;
53 static u32 current_fileid = 1;
54 static u32 current_delegid = 1;
55 static stateid_t zerostateid; /* bits all 0 */
56 static stateid_t onestateid; /* bits all 1 */
57 static u64 current_sessionid = 1;
59 #define ZERO_STATEID(stateid) (!memcmp((stateid), &zerostateid, sizeof(stateid_t)))
60 #define ONE_STATEID(stateid) (!memcmp((stateid), &onestateid, sizeof(stateid_t)))
62 /* forward declarations */
63 static struct nfs4_stateid * find_stateid(stateid_t *stid, int flags);
64 static struct nfs4_delegation * search_for_delegation(stateid_t *stid);
65 static struct nfs4_delegation * find_delegation_stateid(struct inode *ino, stateid_t *stid);
66 static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
70 /* Currently used for almost all code touching nfsv4 state: */
71 static DEFINE_MUTEX(client_mutex);
74 * Currently used for the del_recall_lru and file hash table. In an
75 * effort to decrease the scope of the client_mutex, this spinlock may
76 * eventually cover more:
78 static DEFINE_SPINLOCK(recall_lock);
80 static struct kmem_cache *openowner_slab = NULL;
81 static struct kmem_cache *lockowner_slab = NULL;
82 static struct kmem_cache *file_slab = NULL;
83 static struct kmem_cache *stateid_slab = NULL;
84 static struct kmem_cache *deleg_slab = NULL;
89 mutex_lock(&client_mutex);
93 nfs4_unlock_state(void)
95 mutex_unlock(&client_mutex);
99 opaque_hashval(const void *ptr, int nbytes)
101 unsigned char *cptr = (unsigned char *) ptr;
111 static struct list_head del_recall_lru;
114 put_nfs4_file(struct nfs4_file *fi)
116 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
117 list_del(&fi->fi_hash);
118 spin_unlock(&recall_lock);
120 kmem_cache_free(file_slab, fi);
125 get_nfs4_file(struct nfs4_file *fi)
127 atomic_inc(&fi->fi_ref);
130 static int num_delegations;
131 unsigned int max_delegations;
134 * Open owner state (share locks)
137 /* hash tables for open owners */
138 #define OPEN_OWNER_HASH_BITS 8
139 #define OPEN_OWNER_HASH_SIZE (1 << OPEN_OWNER_HASH_BITS)
140 #define OPEN_OWNER_HASH_MASK (OPEN_OWNER_HASH_SIZE - 1)
142 static unsigned int open_ownerid_hashval(const u32 id)
144 return id & OPEN_OWNER_HASH_MASK;
147 static unsigned int open_ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
151 ret = opaque_hashval(ownername->data, ownername->len);
153 return ret & OPEN_OWNER_HASH_MASK;
156 static struct list_head open_ownerid_hashtbl[OPEN_OWNER_HASH_SIZE];
157 static struct list_head open_ownerstr_hashtbl[OPEN_OWNER_HASH_SIZE];
159 /* hash table for nfs4_file */
160 #define FILE_HASH_BITS 8
161 #define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
163 /* hash table for (open)nfs4_stateid */
164 #define STATEID_HASH_BITS 10
165 #define STATEID_HASH_SIZE (1 << STATEID_HASH_BITS)
166 #define STATEID_HASH_MASK (STATEID_HASH_SIZE - 1)
168 static unsigned int file_hashval(struct inode *ino)
170 /* XXX: why are we hashing on inode pointer, anyway? */
171 return hash_ptr(ino, FILE_HASH_BITS);
174 static unsigned int stateid_hashval(u32 owner_id, u32 file_id)
176 return (owner_id + file_id) & STATEID_HASH_MASK;
179 static struct list_head file_hashtbl[FILE_HASH_SIZE];
180 static struct list_head stateid_hashtbl[STATEID_HASH_SIZE];
182 static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
184 BUG_ON(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
185 atomic_inc(&fp->fi_access[oflag]);
188 static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
190 if (oflag == O_RDWR) {
191 __nfs4_file_get_access(fp, O_RDONLY);
192 __nfs4_file_get_access(fp, O_WRONLY);
194 __nfs4_file_get_access(fp, oflag);
197 static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
199 if (fp->fi_fds[oflag]) {
200 fput(fp->fi_fds[oflag]);
201 fp->fi_fds[oflag] = NULL;
205 static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
207 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
208 nfs4_file_put_fd(fp, O_RDWR);
209 nfs4_file_put_fd(fp, oflag);
213 static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
215 if (oflag == O_RDWR) {
216 __nfs4_file_put_access(fp, O_RDONLY);
217 __nfs4_file_put_access(fp, O_WRONLY);
219 __nfs4_file_put_access(fp, oflag);
222 static struct nfs4_delegation *
223 alloc_init_deleg(struct nfs4_client *clp, struct nfs4_stateid *stp, struct svc_fh *current_fh, u32 type)
225 struct nfs4_delegation *dp;
226 struct nfs4_file *fp = stp->st_file;
228 dprintk("NFSD alloc_init_deleg\n");
230 * Major work on the lease subsystem (for example, to support
231 * calbacks on stat) will be required before we can support
232 * write delegations properly.
234 if (type != NFS4_OPEN_DELEGATE_READ)
236 if (fp->fi_had_conflict)
238 if (num_delegations > max_delegations)
240 dp = kmem_cache_alloc(deleg_slab, GFP_KERNEL);
244 INIT_LIST_HEAD(&dp->dl_perfile);
245 INIT_LIST_HEAD(&dp->dl_perclnt);
246 INIT_LIST_HEAD(&dp->dl_recall_lru);
251 dp->dl_stateid.si_boot = boot_time;
252 dp->dl_stateid.si_stateownerid = current_delegid++;
253 dp->dl_stateid.si_fileid = 0;
254 dp->dl_stateid.si_generation = 1;
255 fh_copy_shallow(&dp->dl_fh, ¤t_fh->fh_handle);
257 atomic_set(&dp->dl_count, 1);
258 INIT_WORK(&dp->dl_recall.cb_work, nfsd4_do_callback_rpc);
263 nfs4_put_delegation(struct nfs4_delegation *dp)
265 if (atomic_dec_and_test(&dp->dl_count)) {
266 dprintk("NFSD: freeing dp %p\n",dp);
267 put_nfs4_file(dp->dl_file);
268 kmem_cache_free(deleg_slab, dp);
273 static void nfs4_put_deleg_lease(struct nfs4_file *fp)
275 if (atomic_dec_and_test(&fp->fi_delegees)) {
276 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
278 fput(fp->fi_deleg_file);
279 fp->fi_deleg_file = NULL;
283 /* Called under the state lock. */
285 unhash_delegation(struct nfs4_delegation *dp)
287 list_del_init(&dp->dl_perclnt);
288 spin_lock(&recall_lock);
289 list_del_init(&dp->dl_perfile);
290 list_del_init(&dp->dl_recall_lru);
291 spin_unlock(&recall_lock);
292 nfs4_put_deleg_lease(dp->dl_file);
293 nfs4_put_delegation(dp);
300 /* client_lock protects the client lru list and session hash table */
301 static DEFINE_SPINLOCK(client_lock);
303 /* Hash tables for nfs4_clientid state */
304 #define CLIENT_HASH_BITS 4
305 #define CLIENT_HASH_SIZE (1 << CLIENT_HASH_BITS)
306 #define CLIENT_HASH_MASK (CLIENT_HASH_SIZE - 1)
308 static unsigned int clientid_hashval(u32 id)
310 return id & CLIENT_HASH_MASK;
313 static unsigned int clientstr_hashval(const char *name)
315 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
319 * reclaim_str_hashtbl[] holds known client info from previous reset/reboot
320 * used in reboot/reset lease grace period processing
322 * conf_id_hashtbl[], and conf_str_hashtbl[] hold confirmed
323 * setclientid_confirmed info.
325 * unconf_str_hastbl[] and unconf_id_hashtbl[] hold unconfirmed
328 * client_lru holds client queue ordered by nfs4_client.cl_time
331 * close_lru holds (open) stateowner queue ordered by nfs4_stateowner.so_time
332 * for last close replay.
334 static struct list_head reclaim_str_hashtbl[CLIENT_HASH_SIZE];
335 static int reclaim_str_hashtbl_size = 0;
336 static struct list_head conf_id_hashtbl[CLIENT_HASH_SIZE];
337 static struct list_head conf_str_hashtbl[CLIENT_HASH_SIZE];
338 static struct list_head unconf_str_hashtbl[CLIENT_HASH_SIZE];
339 static struct list_head unconf_id_hashtbl[CLIENT_HASH_SIZE];
340 static struct list_head client_lru;
341 static struct list_head close_lru;
344 * We store the NONE, READ, WRITE, and BOTH bits separately in the
345 * st_{access,deny}_bmap field of the stateid, in order to track not
346 * only what share bits are currently in force, but also what
347 * combinations of share bits previous opens have used. This allows us
348 * to enforce the recommendation of rfc 3530 14.2.19 that the server
349 * return an error if the client attempt to downgrade to a combination
350 * of share bits not explicable by closing some of its previous opens.
352 * XXX: This enforcement is actually incomplete, since we don't keep
353 * track of access/deny bit combinations; so, e.g., we allow:
355 * OPEN allow read, deny write
356 * OPEN allow both, deny none
357 * DOWNGRADE allow read, deny none
359 * which we should reject.
362 set_access(unsigned int *access, unsigned long bmap) {
366 for (i = 1; i < 4; i++) {
367 if (test_bit(i, &bmap))
373 set_deny(unsigned int *deny, unsigned long bmap) {
377 for (i = 0; i < 4; i++) {
378 if (test_bit(i, &bmap))
384 test_share(struct nfs4_stateid *stp, struct nfsd4_open *open) {
385 unsigned int access, deny;
387 set_access(&access, stp->st_access_bmap);
388 set_deny(&deny, stp->st_deny_bmap);
389 if ((access & open->op_share_deny) || (deny & open->op_share_access))
394 static int nfs4_access_to_omode(u32 access)
396 switch (access & NFS4_SHARE_ACCESS_BOTH) {
397 case NFS4_SHARE_ACCESS_READ:
399 case NFS4_SHARE_ACCESS_WRITE:
401 case NFS4_SHARE_ACCESS_BOTH:
407 static void unhash_generic_stateid(struct nfs4_stateid *stp)
409 list_del(&stp->st_hash);
410 list_del(&stp->st_perfile);
411 list_del(&stp->st_perstateowner);
414 static void close_generic_stateid(struct nfs4_stateid *stp)
418 if (stp->st_access_bmap) {
419 for (i = 1; i < 4; i++) {
420 if (test_bit(i, &stp->st_access_bmap))
421 nfs4_file_put_access(stp->st_file,
422 nfs4_access_to_omode(i));
423 __clear_bit(i, &stp->st_access_bmap);
426 put_nfs4_file(stp->st_file);
430 static void free_generic_stateid(struct nfs4_stateid *stp)
432 close_generic_stateid(stp);
433 kmem_cache_free(stateid_slab, stp);
436 static void release_lock_stateid(struct nfs4_stateid *stp)
440 unhash_generic_stateid(stp);
441 file = find_any_file(stp->st_file);
443 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
444 free_generic_stateid(stp);
447 static void unhash_lockowner(struct nfs4_lockowner *lo)
449 struct nfs4_stateid *stp;
451 list_del(&lo->lo_owner.so_idhash);
452 list_del(&lo->lo_owner.so_strhash);
453 list_del(&lo->lo_perstateid);
454 while (!list_empty(&lo->lo_owner.so_stateids)) {
455 stp = list_first_entry(&lo->lo_owner.so_stateids,
456 struct nfs4_stateid, st_perstateowner);
457 release_lock_stateid(stp);
461 static void release_lockowner(struct nfs4_lockowner *lo)
463 unhash_lockowner(lo);
464 nfs4_free_lockowner(lo);
468 release_stateid_lockowners(struct nfs4_stateid *open_stp)
470 struct nfs4_lockowner *lo;
472 while (!list_empty(&open_stp->st_lockowners)) {
473 lo = list_entry(open_stp->st_lockowners.next,
474 struct nfs4_lockowner, lo_perstateid);
475 release_lockowner(lo);
479 static void release_open_stateid(struct nfs4_stateid *stp)
481 unhash_generic_stateid(stp);
482 release_stateid_lockowners(stp);
483 free_generic_stateid(stp);
486 static void unhash_openowner(struct nfs4_openowner *oo)
488 struct nfs4_stateid *stp;
490 list_del(&oo->oo_owner.so_idhash);
491 list_del(&oo->oo_owner.so_strhash);
492 list_del(&oo->oo_perclient);
493 while (!list_empty(&oo->oo_owner.so_stateids)) {
494 stp = list_first_entry(&oo->oo_owner.so_stateids,
495 struct nfs4_stateid, st_perstateowner);
496 release_open_stateid(stp);
500 static void release_openowner(struct nfs4_openowner *oo)
502 unhash_openowner(oo);
503 list_del(&oo->oo_close_lru);
504 nfs4_free_openowner(oo);
507 #define SESSION_HASH_SIZE 512
508 static struct list_head sessionid_hashtbl[SESSION_HASH_SIZE];
511 hash_sessionid(struct nfs4_sessionid *sessionid)
513 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
515 return sid->sequence % SESSION_HASH_SIZE;
519 dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
521 u32 *ptr = (u32 *)(&sessionid->data[0]);
522 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
526 gen_sessionid(struct nfsd4_session *ses)
528 struct nfs4_client *clp = ses->se_client;
529 struct nfsd4_sessionid *sid;
531 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
532 sid->clientid = clp->cl_clientid;
533 sid->sequence = current_sessionid++;
538 * The protocol defines ca_maxresponssize_cached to include the size of
539 * the rpc header, but all we need to cache is the data starting after
540 * the end of the initial SEQUENCE operation--the rest we regenerate
541 * each time. Therefore we can advertise a ca_maxresponssize_cached
542 * value that is the number of bytes in our cache plus a few additional
543 * bytes. In order to stay on the safe side, and not promise more than
544 * we can cache, those additional bytes must be the minimum possible: 24
545 * bytes of rpc header (xid through accept state, with AUTH_NULL
546 * verifier), 12 for the compound header (with zero-length tag), and 44
547 * for the SEQUENCE op response:
549 #define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
552 free_session_slots(struct nfsd4_session *ses)
556 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
557 kfree(ses->se_slots[i]);
561 * We don't actually need to cache the rpc and session headers, so we
562 * can allocate a little less for each slot:
564 static inline int slot_bytes(struct nfsd4_channel_attrs *ca)
566 return ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
569 static int nfsd4_sanitize_slot_size(u32 size)
571 size -= NFSD_MIN_HDR_SEQ_SZ; /* We don't cache the rpc header */
572 size = min_t(u32, size, NFSD_SLOT_CACHE_SIZE);
578 * XXX: If we run out of reserved DRC memory we could (up to a point)
579 * re-negotiate active sessions and reduce their slot usage to make
580 * rooom for new connections. For now we just fail the create session.
582 static int nfsd4_get_drc_mem(int slotsize, u32 num)
586 num = min_t(u32, num, NFSD_MAX_SLOTS_PER_SESSION);
588 spin_lock(&nfsd_drc_lock);
589 avail = min_t(int, NFSD_MAX_MEM_PER_SESSION,
590 nfsd_drc_max_mem - nfsd_drc_mem_used);
591 num = min_t(int, num, avail / slotsize);
592 nfsd_drc_mem_used += num * slotsize;
593 spin_unlock(&nfsd_drc_lock);
598 static void nfsd4_put_drc_mem(int slotsize, int num)
600 spin_lock(&nfsd_drc_lock);
601 nfsd_drc_mem_used -= slotsize * num;
602 spin_unlock(&nfsd_drc_lock);
605 static struct nfsd4_session *alloc_session(int slotsize, int numslots)
607 struct nfsd4_session *new;
610 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
611 + sizeof(struct nfsd4_session) > PAGE_SIZE);
612 mem = numslots * sizeof(struct nfsd4_slot *);
614 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
617 /* allocate each struct nfsd4_slot and data cache in one piece */
618 for (i = 0; i < numslots; i++) {
619 mem = sizeof(struct nfsd4_slot) + slotsize;
620 new->se_slots[i] = kzalloc(mem, GFP_KERNEL);
621 if (!new->se_slots[i])
627 kfree(new->se_slots[i]);
632 static void init_forechannel_attrs(struct nfsd4_channel_attrs *new, struct nfsd4_channel_attrs *req, int numslots, int slotsize)
634 u32 maxrpc = nfsd_serv->sv_max_mesg;
636 new->maxreqs = numslots;
637 new->maxresp_cached = min_t(u32, req->maxresp_cached,
638 slotsize + NFSD_MIN_HDR_SEQ_SZ);
639 new->maxreq_sz = min_t(u32, req->maxreq_sz, maxrpc);
640 new->maxresp_sz = min_t(u32, req->maxresp_sz, maxrpc);
641 new->maxops = min_t(u32, req->maxops, NFSD_MAX_OPS_PER_COMPOUND);
644 static void free_conn(struct nfsd4_conn *c)
646 svc_xprt_put(c->cn_xprt);
650 static void nfsd4_conn_lost(struct svc_xpt_user *u)
652 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
653 struct nfs4_client *clp = c->cn_session->se_client;
655 spin_lock(&clp->cl_lock);
656 if (!list_empty(&c->cn_persession)) {
657 list_del(&c->cn_persession);
660 spin_unlock(&clp->cl_lock);
661 nfsd4_probe_callback(clp);
664 static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
666 struct nfsd4_conn *conn;
668 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
671 svc_xprt_get(rqstp->rq_xprt);
672 conn->cn_xprt = rqstp->rq_xprt;
673 conn->cn_flags = flags;
674 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
678 static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
680 conn->cn_session = ses;
681 list_add(&conn->cn_persession, &ses->se_conns);
684 static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
686 struct nfs4_client *clp = ses->se_client;
688 spin_lock(&clp->cl_lock);
689 __nfsd4_hash_conn(conn, ses);
690 spin_unlock(&clp->cl_lock);
693 static int nfsd4_register_conn(struct nfsd4_conn *conn)
695 conn->cn_xpt_user.callback = nfsd4_conn_lost;
696 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
699 static __be32 nfsd4_new_conn(struct svc_rqst *rqstp, struct nfsd4_session *ses, u32 dir)
701 struct nfsd4_conn *conn;
704 conn = alloc_conn(rqstp, dir);
706 return nfserr_jukebox;
707 nfsd4_hash_conn(conn, ses);
708 ret = nfsd4_register_conn(conn);
710 /* oops; xprt is already down: */
711 nfsd4_conn_lost(&conn->cn_xpt_user);
715 static __be32 nfsd4_new_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_session *ses)
717 u32 dir = NFS4_CDFC4_FORE;
719 if (ses->se_flags & SESSION4_BACK_CHAN)
720 dir |= NFS4_CDFC4_BACK;
722 return nfsd4_new_conn(rqstp, ses, dir);
725 /* must be called under client_lock */
726 static void nfsd4_del_conns(struct nfsd4_session *s)
728 struct nfs4_client *clp = s->se_client;
729 struct nfsd4_conn *c;
731 spin_lock(&clp->cl_lock);
732 while (!list_empty(&s->se_conns)) {
733 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
734 list_del_init(&c->cn_persession);
735 spin_unlock(&clp->cl_lock);
737 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
740 spin_lock(&clp->cl_lock);
742 spin_unlock(&clp->cl_lock);
745 void free_session(struct kref *kref)
747 struct nfsd4_session *ses;
750 ses = container_of(kref, struct nfsd4_session, se_ref);
751 nfsd4_del_conns(ses);
752 spin_lock(&nfsd_drc_lock);
753 mem = ses->se_fchannel.maxreqs * slot_bytes(&ses->se_fchannel);
754 nfsd_drc_mem_used -= mem;
755 spin_unlock(&nfsd_drc_lock);
756 free_session_slots(ses);
760 static struct nfsd4_session *alloc_init_session(struct svc_rqst *rqstp, struct nfs4_client *clp, struct nfsd4_create_session *cses)
762 struct nfsd4_session *new;
763 struct nfsd4_channel_attrs *fchan = &cses->fore_channel;
764 int numslots, slotsize;
769 * Note decreasing slot size below client's request may
770 * make it difficult for client to function correctly, whereas
771 * decreasing the number of slots will (just?) affect
772 * performance. When short on memory we therefore prefer to
773 * decrease number of slots instead of their size.
775 slotsize = nfsd4_sanitize_slot_size(fchan->maxresp_cached);
776 numslots = nfsd4_get_drc_mem(slotsize, fchan->maxreqs);
780 new = alloc_session(slotsize, numslots);
782 nfsd4_put_drc_mem(slotsize, fchan->maxreqs);
785 init_forechannel_attrs(&new->se_fchannel, fchan, numslots, slotsize);
787 new->se_client = clp;
790 INIT_LIST_HEAD(&new->se_conns);
792 new->se_cb_seq_nr = 1;
793 new->se_flags = cses->flags;
794 new->se_cb_prog = cses->callback_prog;
795 kref_init(&new->se_ref);
796 idx = hash_sessionid(&new->se_sessionid);
797 spin_lock(&client_lock);
798 list_add(&new->se_hash, &sessionid_hashtbl[idx]);
799 spin_lock(&clp->cl_lock);
800 list_add(&new->se_perclnt, &clp->cl_sessions);
801 spin_unlock(&clp->cl_lock);
802 spin_unlock(&client_lock);
804 status = nfsd4_new_conn_from_crses(rqstp, new);
805 /* whoops: benny points out, status is ignored! (err, or bogus) */
807 free_session(&new->se_ref);
810 if (cses->flags & SESSION4_BACK_CHAN) {
811 struct sockaddr *sa = svc_addr(rqstp);
813 * This is a little silly; with sessions there's no real
814 * use for the callback address. Use the peer address
815 * as a reasonable default for now, but consider fixing
816 * the rpc client not to require an address in the
819 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
820 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
822 nfsd4_probe_callback(clp);
826 /* caller must hold client_lock */
827 static struct nfsd4_session *
828 find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid)
830 struct nfsd4_session *elem;
833 dump_sessionid(__func__, sessionid);
834 idx = hash_sessionid(sessionid);
835 /* Search in the appropriate list */
836 list_for_each_entry(elem, &sessionid_hashtbl[idx], se_hash) {
837 if (!memcmp(elem->se_sessionid.data, sessionid->data,
838 NFS4_MAX_SESSIONID_LEN)) {
843 dprintk("%s: session not found\n", __func__);
847 /* caller must hold client_lock */
849 unhash_session(struct nfsd4_session *ses)
851 list_del(&ses->se_hash);
852 spin_lock(&ses->se_client->cl_lock);
853 list_del(&ses->se_perclnt);
854 spin_unlock(&ses->se_client->cl_lock);
857 /* must be called under the client_lock */
859 renew_client_locked(struct nfs4_client *clp)
861 if (is_client_expired(clp)) {
862 dprintk("%s: client (clientid %08x/%08x) already expired\n",
864 clp->cl_clientid.cl_boot,
865 clp->cl_clientid.cl_id);
870 * Move client to the end to the LRU list.
872 dprintk("renewing client (clientid %08x/%08x)\n",
873 clp->cl_clientid.cl_boot,
874 clp->cl_clientid.cl_id);
875 list_move_tail(&clp->cl_lru, &client_lru);
876 clp->cl_time = get_seconds();
880 renew_client(struct nfs4_client *clp)
882 spin_lock(&client_lock);
883 renew_client_locked(clp);
884 spin_unlock(&client_lock);
887 /* SETCLIENTID and SETCLIENTID_CONFIRM Helper functions */
889 STALE_CLIENTID(clientid_t *clid)
891 if (clid->cl_boot == boot_time)
893 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
894 clid->cl_boot, clid->cl_id, boot_time);
899 * XXX Should we use a slab cache ?
900 * This type of memory management is somewhat inefficient, but we use it
901 * anyway since SETCLIENTID is not a common operation.
903 static struct nfs4_client *alloc_client(struct xdr_netobj name)
905 struct nfs4_client *clp;
907 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
910 clp->cl_name.data = kmalloc(name.len, GFP_KERNEL);
911 if (clp->cl_name.data == NULL) {
915 memcpy(clp->cl_name.data, name.data, name.len);
916 clp->cl_name.len = name.len;
921 free_client(struct nfs4_client *clp)
923 while (!list_empty(&clp->cl_sessions)) {
924 struct nfsd4_session *ses;
925 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
927 list_del(&ses->se_perclnt);
928 nfsd4_put_session(ses);
930 if (clp->cl_cred.cr_group_info)
931 put_group_info(clp->cl_cred.cr_group_info);
932 kfree(clp->cl_principal);
933 kfree(clp->cl_name.data);
938 release_session_client(struct nfsd4_session *session)
940 struct nfs4_client *clp = session->se_client;
942 if (!atomic_dec_and_lock(&clp->cl_refcount, &client_lock))
944 if (is_client_expired(clp)) {
946 session->se_client = NULL;
948 renew_client_locked(clp);
949 spin_unlock(&client_lock);
952 /* must be called under the client_lock */
954 unhash_client_locked(struct nfs4_client *clp)
956 struct nfsd4_session *ses;
958 mark_client_expired(clp);
959 list_del(&clp->cl_lru);
960 spin_lock(&clp->cl_lock);
961 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
962 list_del_init(&ses->se_hash);
963 spin_unlock(&clp->cl_lock);
967 expire_client(struct nfs4_client *clp)
969 struct nfs4_openowner *oo;
970 struct nfs4_delegation *dp;
971 struct list_head reaplist;
973 INIT_LIST_HEAD(&reaplist);
974 spin_lock(&recall_lock);
975 while (!list_empty(&clp->cl_delegations)) {
976 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
977 list_del_init(&dp->dl_perclnt);
978 list_move(&dp->dl_recall_lru, &reaplist);
980 spin_unlock(&recall_lock);
981 while (!list_empty(&reaplist)) {
982 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
983 list_del_init(&dp->dl_recall_lru);
984 unhash_delegation(dp);
986 while (!list_empty(&clp->cl_openowners)) {
987 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
988 release_openowner(oo);
990 nfsd4_shutdown_callback(clp);
991 if (clp->cl_cb_conn.cb_xprt)
992 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
993 list_del(&clp->cl_idhash);
994 list_del(&clp->cl_strhash);
995 spin_lock(&client_lock);
996 unhash_client_locked(clp);
997 if (atomic_read(&clp->cl_refcount) == 0)
999 spin_unlock(&client_lock);
1002 static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1004 memcpy(target->cl_verifier.data, source->data,
1005 sizeof(target->cl_verifier.data));
1008 static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1010 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1011 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1014 static void copy_cred(struct svc_cred *target, struct svc_cred *source)
1016 target->cr_uid = source->cr_uid;
1017 target->cr_gid = source->cr_gid;
1018 target->cr_group_info = source->cr_group_info;
1019 get_group_info(target->cr_group_info);
1022 static int same_name(const char *n1, const char *n2)
1024 return 0 == memcmp(n1, n2, HEXDIR_LEN);
1028 same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1030 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1034 same_clid(clientid_t *cl1, clientid_t *cl2)
1036 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1039 /* XXX what about NGROUP */
1041 same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1043 return cr1->cr_uid == cr2->cr_uid;
1046 static void gen_clid(struct nfs4_client *clp)
1048 static u32 current_clientid = 1;
1050 clp->cl_clientid.cl_boot = boot_time;
1051 clp->cl_clientid.cl_id = current_clientid++;
1054 static void gen_confirm(struct nfs4_client *clp)
1059 p = (u32 *)clp->cl_confirm.data;
1060 *p++ = get_seconds();
1064 static struct nfs4_client *create_client(struct xdr_netobj name, char *recdir,
1065 struct svc_rqst *rqstp, nfs4_verifier *verf)
1067 struct nfs4_client *clp;
1068 struct sockaddr *sa = svc_addr(rqstp);
1071 clp = alloc_client(name);
1075 INIT_LIST_HEAD(&clp->cl_sessions);
1077 princ = svc_gss_principal(rqstp);
1079 clp->cl_principal = kstrdup(princ, GFP_KERNEL);
1080 if (clp->cl_principal == NULL) {
1086 memcpy(clp->cl_recdir, recdir, HEXDIR_LEN);
1087 atomic_set(&clp->cl_refcount, 0);
1088 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1089 INIT_LIST_HEAD(&clp->cl_idhash);
1090 INIT_LIST_HEAD(&clp->cl_strhash);
1091 INIT_LIST_HEAD(&clp->cl_openowners);
1092 INIT_LIST_HEAD(&clp->cl_delegations);
1093 INIT_LIST_HEAD(&clp->cl_lru);
1094 INIT_LIST_HEAD(&clp->cl_callbacks);
1095 spin_lock_init(&clp->cl_lock);
1096 INIT_WORK(&clp->cl_cb_null.cb_work, nfsd4_do_callback_rpc);
1097 clp->cl_time = get_seconds();
1098 clear_bit(0, &clp->cl_cb_slot_busy);
1099 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1100 copy_verf(clp, verf);
1101 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1102 clp->cl_flavor = rqstp->rq_flavor;
1103 copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1105 clp->cl_cb_session = NULL;
1109 static int check_name(struct xdr_netobj name)
1113 if (name.len > NFS4_OPAQUE_LIMIT) {
1114 dprintk("NFSD: check_name: name too long(%d)!\n", name.len);
1121 add_to_unconfirmed(struct nfs4_client *clp, unsigned int strhashval)
1123 unsigned int idhashval;
1125 list_add(&clp->cl_strhash, &unconf_str_hashtbl[strhashval]);
1126 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1127 list_add(&clp->cl_idhash, &unconf_id_hashtbl[idhashval]);
1132 move_to_confirmed(struct nfs4_client *clp)
1134 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1135 unsigned int strhashval;
1137 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1138 list_move(&clp->cl_idhash, &conf_id_hashtbl[idhashval]);
1139 strhashval = clientstr_hashval(clp->cl_recdir);
1140 list_move(&clp->cl_strhash, &conf_str_hashtbl[strhashval]);
1144 static struct nfs4_client *
1145 find_confirmed_client(clientid_t *clid)
1147 struct nfs4_client *clp;
1148 unsigned int idhashval = clientid_hashval(clid->cl_id);
1150 list_for_each_entry(clp, &conf_id_hashtbl[idhashval], cl_idhash) {
1151 if (same_clid(&clp->cl_clientid, clid))
1157 static struct nfs4_client *
1158 find_unconfirmed_client(clientid_t *clid)
1160 struct nfs4_client *clp;
1161 unsigned int idhashval = clientid_hashval(clid->cl_id);
1163 list_for_each_entry(clp, &unconf_id_hashtbl[idhashval], cl_idhash) {
1164 if (same_clid(&clp->cl_clientid, clid))
1170 static bool clp_used_exchangeid(struct nfs4_client *clp)
1172 return clp->cl_exchange_flags != 0;
1175 static struct nfs4_client *
1176 find_confirmed_client_by_str(const char *dname, unsigned int hashval)
1178 struct nfs4_client *clp;
1180 list_for_each_entry(clp, &conf_str_hashtbl[hashval], cl_strhash) {
1181 if (same_name(clp->cl_recdir, dname))
1187 static struct nfs4_client *
1188 find_unconfirmed_client_by_str(const char *dname, unsigned int hashval)
1190 struct nfs4_client *clp;
1192 list_for_each_entry(clp, &unconf_str_hashtbl[hashval], cl_strhash) {
1193 if (same_name(clp->cl_recdir, dname))
1199 static void rpc_svcaddr2sockaddr(struct sockaddr *sa, unsigned short family, union svc_addr_u *svcaddr)
1203 ((struct sockaddr_in *)sa)->sin_family = AF_INET;
1204 ((struct sockaddr_in *)sa)->sin_addr = svcaddr->addr;
1207 ((struct sockaddr_in6 *)sa)->sin6_family = AF_INET6;
1208 ((struct sockaddr_in6 *)sa)->sin6_addr = svcaddr->addr6;
1214 gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
1216 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1217 struct sockaddr *sa = svc_addr(rqstp);
1218 u32 scopeid = rpc_get_scope_id(sa);
1219 unsigned short expected_family;
1221 /* Currently, we only support tcp and tcp6 for the callback channel */
1222 if (se->se_callback_netid_len == 3 &&
1223 !memcmp(se->se_callback_netid_val, "tcp", 3))
1224 expected_family = AF_INET;
1225 else if (se->se_callback_netid_len == 4 &&
1226 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1227 expected_family = AF_INET6;
1231 conn->cb_addrlen = rpc_uaddr2sockaddr(se->se_callback_addr_val,
1232 se->se_callback_addr_len,
1233 (struct sockaddr *)&conn->cb_addr,
1234 sizeof(conn->cb_addr));
1236 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1239 if (conn->cb_addr.ss_family == AF_INET6)
1240 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1242 conn->cb_prog = se->se_callback_prog;
1243 conn->cb_ident = se->se_callback_ident;
1244 rpc_svcaddr2sockaddr((struct sockaddr *)&conn->cb_saddr, expected_family, &rqstp->rq_daddr);
1247 conn->cb_addr.ss_family = AF_UNSPEC;
1248 conn->cb_addrlen = 0;
1249 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1250 "will not receive delegations\n",
1251 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1257 * Cache a reply. nfsd4_check_drc_limit() has bounded the cache size.
1260 nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1262 struct nfsd4_slot *slot = resp->cstate.slot;
1265 dprintk("--> %s slot %p\n", __func__, slot);
1267 slot->sl_opcnt = resp->opcnt;
1268 slot->sl_status = resp->cstate.status;
1270 if (nfsd4_not_cached(resp)) {
1271 slot->sl_datalen = 0;
1274 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1275 base = (char *)resp->cstate.datap -
1276 (char *)resp->xbuf->head[0].iov_base;
1277 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1279 WARN("%s: sessions DRC could not cache compound\n", __func__);
1284 * Encode the replay sequence operation from the slot values.
1285 * If cachethis is FALSE encode the uncached rep error on the next
1286 * operation which sets resp->p and increments resp->opcnt for
1287 * nfs4svc_encode_compoundres.
1291 nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1292 struct nfsd4_compoundres *resp)
1294 struct nfsd4_op *op;
1295 struct nfsd4_slot *slot = resp->cstate.slot;
1297 dprintk("--> %s resp->opcnt %d cachethis %u \n", __func__,
1298 resp->opcnt, resp->cstate.slot->sl_cachethis);
1300 /* Encode the replayed sequence operation */
1301 op = &args->ops[resp->opcnt - 1];
1302 nfsd4_encode_operation(resp, op);
1304 /* Return nfserr_retry_uncached_rep in next operation. */
1305 if (args->opcnt > 1 && slot->sl_cachethis == 0) {
1306 op = &args->ops[resp->opcnt++];
1307 op->status = nfserr_retry_uncached_rep;
1308 nfsd4_encode_operation(resp, op);
1314 * The sequence operation is not cached because we can use the slot and
1318 nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1319 struct nfsd4_sequence *seq)
1321 struct nfsd4_slot *slot = resp->cstate.slot;
1324 dprintk("--> %s slot %p\n", __func__, slot);
1326 /* Either returns 0 or nfserr_retry_uncached */
1327 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1328 if (status == nfserr_retry_uncached_rep)
1331 /* The sequence operation has been encoded, cstate->datap set. */
1332 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
1334 resp->opcnt = slot->sl_opcnt;
1335 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1336 status = slot->sl_status;
1342 * Set the exchange_id flags returned by the server.
1345 nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1347 /* pNFS is not supported */
1348 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1350 /* Referrals are supported, Migration is not. */
1351 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1353 /* set the wire flags to return to client. */
1354 clid->flags = new->cl_exchange_flags;
1358 nfsd4_exchange_id(struct svc_rqst *rqstp,
1359 struct nfsd4_compound_state *cstate,
1360 struct nfsd4_exchange_id *exid)
1362 struct nfs4_client *unconf, *conf, *new;
1364 unsigned int strhashval;
1365 char dname[HEXDIR_LEN];
1366 char addr_str[INET6_ADDRSTRLEN];
1367 nfs4_verifier verf = exid->verifier;
1368 struct sockaddr *sa = svc_addr(rqstp);
1370 rpc_ntop(sa, addr_str, sizeof(addr_str));
1371 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1372 "ip_addr=%s flags %x, spa_how %d\n",
1373 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
1374 addr_str, exid->flags, exid->spa_how);
1376 if (!check_name(exid->clname) || (exid->flags & ~EXCHGID4_FLAG_MASK_A))
1377 return nfserr_inval;
1379 /* Currently only support SP4_NONE */
1380 switch (exid->spa_how) {
1384 return nfserr_serverfault;
1386 BUG(); /* checked by xdr code */
1388 return nfserr_serverfault; /* no excuse :-/ */
1391 status = nfs4_make_rec_clidname(dname, &exid->clname);
1396 strhashval = clientstr_hashval(dname);
1401 conf = find_confirmed_client_by_str(dname, strhashval);
1403 if (!clp_used_exchangeid(conf)) {
1404 status = nfserr_clid_inuse; /* XXX: ? */
1407 if (!same_verf(&verf, &conf->cl_verifier)) {
1408 /* 18.35.4 case 8 */
1409 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1410 status = nfserr_not_same;
1413 /* Client reboot: destroy old state */
1414 expire_client(conf);
1417 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1418 /* 18.35.4 case 9 */
1419 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1420 status = nfserr_perm;
1423 expire_client(conf);
1427 * Set bit when the owner id and verifier map to an already
1428 * confirmed client id (18.35.3).
1430 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1433 * Falling into 18.35.4 case 2, possible router replay.
1434 * Leave confirmed record intact and return same result.
1436 copy_verf(conf, &verf);
1441 /* 18.35.4 case 7 */
1442 if (exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A) {
1443 status = nfserr_noent;
1447 unconf = find_unconfirmed_client_by_str(dname, strhashval);
1450 * Possible retry or client restart. Per 18.35.4 case 4,
1451 * a new unconfirmed record should be generated regardless
1452 * of whether any properties have changed.
1454 expire_client(unconf);
1459 new = create_client(exid->clname, dname, rqstp, &verf);
1461 status = nfserr_jukebox;
1466 add_to_unconfirmed(new, strhashval);
1468 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1469 exid->clientid.cl_id = new->cl_clientid.cl_id;
1472 nfsd4_set_ex_flags(new, exid);
1474 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1475 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
1479 nfs4_unlock_state();
1481 dprintk("nfsd4_exchange_id returns %d\n", ntohl(status));
1486 check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
1488 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1491 /* The slot is in use, and no response has been sent. */
1493 if (seqid == slot_seqid)
1494 return nfserr_jukebox;
1496 return nfserr_seq_misordered;
1499 if (likely(seqid == slot_seqid + 1))
1502 if (seqid == slot_seqid)
1503 return nfserr_replay_cache;
1505 if (seqid == 1 && (slot_seqid + 1) == 0)
1507 /* Misordered replay or misordered new request */
1508 return nfserr_seq_misordered;
1512 * Cache the create session result into the create session single DRC
1513 * slot cache by saving the xdr structure. sl_seqid has been set.
1514 * Do this for solo or embedded create session operations.
1517 nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1518 struct nfsd4_clid_slot *slot, int nfserr)
1520 slot->sl_status = nfserr;
1521 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1525 nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1526 struct nfsd4_clid_slot *slot)
1528 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1529 return slot->sl_status;
1532 #define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1533 2 * 2 + /* credential,verifier: AUTH_NULL, length 0 */ \
1534 1 + /* MIN tag is length with zero, only length */ \
1535 3 + /* version, opcount, opcode */ \
1536 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1537 /* seqid, slotID, slotID, cache */ \
1538 4 ) * sizeof(__be32))
1540 #define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1541 2 + /* verifier: AUTH_NULL, length 0 */\
1543 1 + /* MIN tag is length with zero, only length */ \
1544 3 + /* opcount, opcode, opstatus*/ \
1545 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1546 /* seqid, slotID, slotID, slotID, status */ \
1547 5 ) * sizeof(__be32))
1549 static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs fchannel)
1551 return fchannel.maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ
1552 || fchannel.maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ;
1556 nfsd4_create_session(struct svc_rqst *rqstp,
1557 struct nfsd4_compound_state *cstate,
1558 struct nfsd4_create_session *cr_ses)
1560 struct sockaddr *sa = svc_addr(rqstp);
1561 struct nfs4_client *conf, *unconf;
1562 struct nfsd4_session *new;
1563 struct nfsd4_clid_slot *cs_slot = NULL;
1564 bool confirm_me = false;
1567 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1568 return nfserr_inval;
1571 unconf = find_unconfirmed_client(&cr_ses->clientid);
1572 conf = find_confirmed_client(&cr_ses->clientid);
1575 cs_slot = &conf->cl_cs_slot;
1576 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1577 if (status == nfserr_replay_cache) {
1578 dprintk("Got a create_session replay! seqid= %d\n",
1580 /* Return the cached reply status */
1581 status = nfsd4_replay_create_session(cr_ses, cs_slot);
1583 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
1584 status = nfserr_seq_misordered;
1585 dprintk("Sequence misordered!\n");
1586 dprintk("Expected seqid= %d but got seqid= %d\n",
1587 cs_slot->sl_seqid, cr_ses->seqid);
1590 } else if (unconf) {
1591 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
1592 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
1593 status = nfserr_clid_inuse;
1597 cs_slot = &unconf->cl_cs_slot;
1598 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1600 /* an unconfirmed replay returns misordered */
1601 status = nfserr_seq_misordered;
1608 status = nfserr_stale_clientid;
1613 * XXX: we should probably set this at creation time, and check
1614 * for consistent minorversion use throughout:
1616 conf->cl_minorversion = 1;
1618 * We do not support RDMA or persistent sessions
1620 cr_ses->flags &= ~SESSION4_PERSIST;
1621 cr_ses->flags &= ~SESSION4_RDMA;
1623 status = nfserr_toosmall;
1624 if (check_forechannel_attrs(cr_ses->fore_channel))
1627 status = nfserr_jukebox;
1628 new = alloc_init_session(rqstp, conf, cr_ses);
1632 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
1633 NFS4_MAX_SESSIONID_LEN);
1634 memcpy(&cr_ses->fore_channel, &new->se_fchannel,
1635 sizeof(struct nfsd4_channel_attrs));
1636 cs_slot->sl_seqid++;
1637 cr_ses->seqid = cs_slot->sl_seqid;
1639 /* cache solo and embedded create sessions under the state lock */
1640 nfsd4_cache_create_session(cr_ses, cs_slot, status);
1642 move_to_confirmed(conf);
1644 nfs4_unlock_state();
1645 dprintk("%s returns %d\n", __func__, ntohl(status));
1649 static bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
1651 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1652 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
1654 return argp->opcnt == resp->opcnt;
1657 static __be32 nfsd4_map_bcts_dir(u32 *dir)
1660 case NFS4_CDFC4_FORE:
1661 case NFS4_CDFC4_BACK:
1663 case NFS4_CDFC4_FORE_OR_BOTH:
1664 case NFS4_CDFC4_BACK_OR_BOTH:
1665 *dir = NFS4_CDFC4_BOTH;
1668 return nfserr_inval;
1671 __be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
1672 struct nfsd4_compound_state *cstate,
1673 struct nfsd4_bind_conn_to_session *bcts)
1677 if (!nfsd4_last_compound_op(rqstp))
1678 return nfserr_not_only_op;
1679 spin_lock(&client_lock);
1680 cstate->session = find_in_sessionid_hashtbl(&bcts->sessionid);
1681 /* Sorta weird: we only need the refcnt'ing because new_conn acquires
1682 * client_lock iself: */
1683 if (cstate->session) {
1684 nfsd4_get_session(cstate->session);
1685 atomic_inc(&cstate->session->se_client->cl_refcount);
1687 spin_unlock(&client_lock);
1688 if (!cstate->session)
1689 return nfserr_badsession;
1691 status = nfsd4_map_bcts_dir(&bcts->dir);
1693 nfsd4_new_conn(rqstp, cstate->session, bcts->dir);
1697 static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
1701 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
1705 nfsd4_destroy_session(struct svc_rqst *r,
1706 struct nfsd4_compound_state *cstate,
1707 struct nfsd4_destroy_session *sessionid)
1709 struct nfsd4_session *ses;
1710 u32 status = nfserr_badsession;
1713 * - The confirmed nfs4_client->cl_sessionid holds destroyed sessinid
1714 * - Should we return nfserr_back_chan_busy if waiting for
1715 * callbacks on to-be-destroyed session?
1716 * - Do we need to clear any callback info from previous session?
1719 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
1720 if (!nfsd4_last_compound_op(r))
1721 return nfserr_not_only_op;
1723 dump_sessionid(__func__, &sessionid->sessionid);
1724 spin_lock(&client_lock);
1725 ses = find_in_sessionid_hashtbl(&sessionid->sessionid);
1727 spin_unlock(&client_lock);
1731 unhash_session(ses);
1732 spin_unlock(&client_lock);
1735 nfsd4_probe_callback_sync(ses->se_client);
1736 nfs4_unlock_state();
1738 nfsd4_del_conns(ses);
1740 nfsd4_put_session(ses);
1743 dprintk("%s returns %d\n", __func__, ntohl(status));
1747 static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
1749 struct nfsd4_conn *c;
1751 list_for_each_entry(c, &s->se_conns, cn_persession) {
1752 if (c->cn_xprt == xpt) {
1759 static void nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
1761 struct nfs4_client *clp = ses->se_client;
1762 struct nfsd4_conn *c;
1765 spin_lock(&clp->cl_lock);
1766 c = __nfsd4_find_conn(new->cn_xprt, ses);
1768 spin_unlock(&clp->cl_lock);
1772 __nfsd4_hash_conn(new, ses);
1773 spin_unlock(&clp->cl_lock);
1774 ret = nfsd4_register_conn(new);
1776 /* oops; xprt is already down: */
1777 nfsd4_conn_lost(&new->cn_xpt_user);
1781 static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
1783 struct nfsd4_compoundargs *args = rqstp->rq_argp;
1785 return args->opcnt > session->se_fchannel.maxops;
1788 static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
1789 struct nfsd4_session *session)
1791 struct xdr_buf *xb = &rqstp->rq_arg;
1793 return xb->len > session->se_fchannel.maxreq_sz;
1797 nfsd4_sequence(struct svc_rqst *rqstp,
1798 struct nfsd4_compound_state *cstate,
1799 struct nfsd4_sequence *seq)
1801 struct nfsd4_compoundres *resp = rqstp->rq_resp;
1802 struct nfsd4_session *session;
1803 struct nfsd4_slot *slot;
1804 struct nfsd4_conn *conn;
1807 if (resp->opcnt != 1)
1808 return nfserr_sequence_pos;
1811 * Will be either used or freed by nfsd4_sequence_check_conn
1814 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
1816 return nfserr_jukebox;
1818 spin_lock(&client_lock);
1819 status = nfserr_badsession;
1820 session = find_in_sessionid_hashtbl(&seq->sessionid);
1824 status = nfserr_too_many_ops;
1825 if (nfsd4_session_too_many_ops(rqstp, session))
1828 status = nfserr_req_too_big;
1829 if (nfsd4_request_too_big(rqstp, session))
1832 status = nfserr_badslot;
1833 if (seq->slotid >= session->se_fchannel.maxreqs)
1836 slot = session->se_slots[seq->slotid];
1837 dprintk("%s: slotid %d\n", __func__, seq->slotid);
1839 /* We do not negotiate the number of slots yet, so set the
1840 * maxslots to the session maxreqs which is used to encode
1841 * sr_highest_slotid and the sr_target_slot id to maxslots */
1842 seq->maxslots = session->se_fchannel.maxreqs;
1844 status = check_slot_seqid(seq->seqid, slot->sl_seqid, slot->sl_inuse);
1845 if (status == nfserr_replay_cache) {
1846 cstate->slot = slot;
1847 cstate->session = session;
1848 /* Return the cached reply status and set cstate->status
1849 * for nfsd4_proc_compound processing */
1850 status = nfsd4_replay_cache_entry(resp, seq);
1851 cstate->status = nfserr_replay_cache;
1857 nfsd4_sequence_check_conn(conn, session);
1860 /* Success! bump slot seqid */
1861 slot->sl_inuse = true;
1862 slot->sl_seqid = seq->seqid;
1863 slot->sl_cachethis = seq->cachethis;
1865 cstate->slot = slot;
1866 cstate->session = session;
1869 /* Hold a session reference until done processing the compound. */
1870 if (cstate->session) {
1871 struct nfs4_client *clp = session->se_client;
1873 nfsd4_get_session(cstate->session);
1874 atomic_inc(&clp->cl_refcount);
1875 if (clp->cl_cb_state == NFSD4_CB_DOWN)
1876 seq->status_flags |= SEQ4_STATUS_CB_PATH_DOWN;
1879 spin_unlock(&client_lock);
1880 dprintk("%s: return %d\n", __func__, ntohl(status));
1885 nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
1889 if (rc->rca_one_fs) {
1890 if (!cstate->current_fh.fh_dentry)
1891 return nfserr_nofilehandle;
1893 * We don't take advantage of the rca_one_fs case.
1894 * That's OK, it's optional, we can safely ignore it.
1900 status = nfserr_complete_already;
1901 if (cstate->session->se_client->cl_firststate)
1904 status = nfserr_stale_clientid;
1905 if (is_client_expired(cstate->session->se_client))
1907 * The following error isn't really legal.
1908 * But we only get here if the client just explicitly
1909 * destroyed the client. Surely it no longer cares what
1910 * error it gets back on an operation for the dead
1916 nfsd4_create_clid_dir(cstate->session->se_client);
1918 nfs4_unlock_state();
1923 nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
1924 struct nfsd4_setclientid *setclid)
1926 struct xdr_netobj clname = {
1927 .len = setclid->se_namelen,
1928 .data = setclid->se_name,
1930 nfs4_verifier clverifier = setclid->se_verf;
1931 unsigned int strhashval;
1932 struct nfs4_client *conf, *unconf, *new;
1934 char dname[HEXDIR_LEN];
1936 if (!check_name(clname))
1937 return nfserr_inval;
1939 status = nfs4_make_rec_clidname(dname, &clname);
1944 * XXX The Duplicate Request Cache (DRC) has been checked (??)
1945 * We get here on a DRC miss.
1948 strhashval = clientstr_hashval(dname);
1951 conf = find_confirmed_client_by_str(dname, strhashval);
1953 /* RFC 3530 14.2.33 CASE 0: */
1954 status = nfserr_clid_inuse;
1955 if (clp_used_exchangeid(conf))
1957 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
1958 char addr_str[INET6_ADDRSTRLEN];
1959 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
1961 dprintk("NFSD: setclientid: string in use by client "
1962 "at %s\n", addr_str);
1967 * section 14.2.33 of RFC 3530 (under the heading "IMPLEMENTATION")
1968 * has a description of SETCLIENTID request processing consisting
1969 * of 5 bullet points, labeled as CASE0 - CASE4 below.
1971 unconf = find_unconfirmed_client_by_str(dname, strhashval);
1972 status = nfserr_jukebox;
1975 * RFC 3530 14.2.33 CASE 4:
1976 * placed first, because it is the normal case
1979 expire_client(unconf);
1980 new = create_client(clname, dname, rqstp, &clverifier);
1984 } else if (same_verf(&conf->cl_verifier, &clverifier)) {
1986 * RFC 3530 14.2.33 CASE 1:
1987 * probable callback update
1990 /* Note this is removing unconfirmed {*x***},
1991 * which is stronger than RFC recommended {vxc**}.
1992 * This has the advantage that there is at most
1993 * one {*x***} in either list at any time.
1995 expire_client(unconf);
1997 new = create_client(clname, dname, rqstp, &clverifier);
2000 copy_clid(new, conf);
2001 } else if (!unconf) {
2003 * RFC 3530 14.2.33 CASE 2:
2004 * probable client reboot; state will be removed if
2007 new = create_client(clname, dname, rqstp, &clverifier);
2013 * RFC 3530 14.2.33 CASE 3:
2014 * probable client reboot; state will be removed if
2017 expire_client(unconf);
2018 new = create_client(clname, dname, rqstp, &clverifier);
2024 * XXX: we should probably set this at creation time, and check
2025 * for consistent minorversion use throughout:
2027 new->cl_minorversion = 0;
2028 gen_callback(new, setclid, rqstp);
2029 add_to_unconfirmed(new, strhashval);
2030 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2031 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2032 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2035 nfs4_unlock_state();
2041 * Section 14.2.34 of RFC 3530 (under the heading "IMPLEMENTATION") has
2042 * a description of SETCLIENTID_CONFIRM request processing consisting of 4
2043 * bullets, labeled as CASE1 - CASE4 below.
2046 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2047 struct nfsd4_compound_state *cstate,
2048 struct nfsd4_setclientid_confirm *setclientid_confirm)
2050 struct sockaddr *sa = svc_addr(rqstp);
2051 struct nfs4_client *conf, *unconf;
2052 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2053 clientid_t * clid = &setclientid_confirm->sc_clientid;
2056 if (STALE_CLIENTID(clid))
2057 return nfserr_stale_clientid;
2059 * XXX The Duplicate Request Cache (DRC) has been checked (??)
2060 * We get here on a DRC miss.
2065 conf = find_confirmed_client(clid);
2066 unconf = find_unconfirmed_client(clid);
2068 status = nfserr_clid_inuse;
2069 if (conf && !rpc_cmp_addr((struct sockaddr *) &conf->cl_addr, sa))
2071 if (unconf && !rpc_cmp_addr((struct sockaddr *) &unconf->cl_addr, sa))
2075 * section 14.2.34 of RFC 3530 has a description of
2076 * SETCLIENTID_CONFIRM request processing consisting
2077 * of 4 bullet points, labeled as CASE1 - CASE4 below.
2079 if (conf && unconf && same_verf(&confirm, &unconf->cl_confirm)) {
2081 * RFC 3530 14.2.34 CASE 1:
2084 if (!same_creds(&conf->cl_cred, &unconf->cl_cred))
2085 status = nfserr_clid_inuse;
2087 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2088 nfsd4_probe_callback(conf);
2089 expire_client(unconf);
2093 } else if (conf && !unconf) {
2095 * RFC 3530 14.2.34 CASE 2:
2096 * probable retransmitted request; play it safe and
2099 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred))
2100 status = nfserr_clid_inuse;
2103 } else if (!conf && unconf
2104 && same_verf(&unconf->cl_confirm, &confirm)) {
2106 * RFC 3530 14.2.34 CASE 3:
2107 * Normal case; new or rebooted client:
2109 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
2110 status = nfserr_clid_inuse;
2113 clientstr_hashval(unconf->cl_recdir);
2114 conf = find_confirmed_client_by_str(unconf->cl_recdir,
2117 nfsd4_remove_clid_dir(conf);
2118 expire_client(conf);
2120 move_to_confirmed(unconf);
2122 nfsd4_probe_callback(conf);
2125 } else if ((!conf || (conf && !same_verf(&conf->cl_confirm, &confirm)))
2126 && (!unconf || (unconf && !same_verf(&unconf->cl_confirm,
2129 * RFC 3530 14.2.34 CASE 4:
2130 * Client probably hasn't noticed that we rebooted yet.
2132 status = nfserr_stale_clientid;
2134 /* check that we have hit one of the cases...*/
2135 status = nfserr_clid_inuse;
2138 nfs4_unlock_state();
2142 /* OPEN Share state helper functions */
2143 static inline struct nfs4_file *
2144 alloc_init_file(struct inode *ino)
2146 struct nfs4_file *fp;
2147 unsigned int hashval = file_hashval(ino);
2149 fp = kmem_cache_alloc(file_slab, GFP_KERNEL);
2151 atomic_set(&fp->fi_ref, 1);
2152 INIT_LIST_HEAD(&fp->fi_hash);
2153 INIT_LIST_HEAD(&fp->fi_stateids);
2154 INIT_LIST_HEAD(&fp->fi_delegations);
2155 fp->fi_inode = igrab(ino);
2156 fp->fi_id = current_fileid++;
2157 fp->fi_had_conflict = false;
2158 fp->fi_lease = NULL;
2159 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2160 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2161 spin_lock(&recall_lock);
2162 list_add(&fp->fi_hash, &file_hashtbl[hashval]);
2163 spin_unlock(&recall_lock);
2170 nfsd4_free_slab(struct kmem_cache **slab)
2174 kmem_cache_destroy(*slab);
2179 nfsd4_free_slabs(void)
2181 nfsd4_free_slab(&openowner_slab);
2182 nfsd4_free_slab(&lockowner_slab);
2183 nfsd4_free_slab(&file_slab);
2184 nfsd4_free_slab(&stateid_slab);
2185 nfsd4_free_slab(&deleg_slab);
2189 nfsd4_init_slabs(void)
2191 openowner_slab = kmem_cache_create("nfsd4_openowners",
2192 sizeof(struct nfs4_openowner), 0, 0, NULL);
2193 if (openowner_slab == NULL)
2195 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
2196 sizeof(struct nfs4_openowner), 0, 0, NULL);
2197 if (lockowner_slab == NULL)
2199 file_slab = kmem_cache_create("nfsd4_files",
2200 sizeof(struct nfs4_file), 0, 0, NULL);
2201 if (file_slab == NULL)
2203 stateid_slab = kmem_cache_create("nfsd4_stateids",
2204 sizeof(struct nfs4_stateid), 0, 0, NULL);
2205 if (stateid_slab == NULL)
2207 deleg_slab = kmem_cache_create("nfsd4_delegations",
2208 sizeof(struct nfs4_delegation), 0, 0, NULL);
2209 if (deleg_slab == NULL)
2214 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2218 void nfs4_free_openowner(struct nfs4_openowner *oo)
2220 kfree(oo->oo_owner.so_owner.data);
2221 kmem_cache_free(openowner_slab, oo);
2224 void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2226 kfree(lo->lo_owner.so_owner.data);
2227 kmem_cache_free(lockowner_slab, lo);
2230 static void init_nfs4_replay(struct nfs4_replay *rp)
2232 rp->rp_status = nfserr_serverfault;
2234 rp->rp_buf = rp->rp_ibuf;
2237 static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
2239 struct nfs4_stateowner *sop;
2241 sop = kmem_cache_alloc(slab, GFP_KERNEL);
2245 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2246 if (!sop->so_owner.data) {
2247 kmem_cache_free(slab, sop);
2250 sop->so_owner.len = owner->len;
2252 INIT_LIST_HEAD(&sop->so_stateids);
2253 sop->so_id = current_ownerid++;
2254 sop->so_client = clp;
2255 init_nfs4_replay(&sop->so_replay);
2259 static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
2261 unsigned int idhashval;
2263 idhashval = open_ownerid_hashval(oo->oo_owner.so_id);
2264 list_add(&oo->oo_owner.so_idhash, &open_ownerid_hashtbl[idhashval]);
2265 list_add(&oo->oo_owner.so_strhash, &open_ownerstr_hashtbl[strhashval]);
2266 list_add(&oo->oo_perclient, &clp->cl_openowners);
2269 static struct nfs4_openowner *
2270 alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2271 struct nfs4_openowner *oo;
2273 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2276 oo->oo_owner.so_is_open_owner = 1;
2277 oo->oo_owner.so_seqid = open->op_seqid;
2278 oo->oo_confirmed = 0;
2280 INIT_LIST_HEAD(&oo->oo_close_lru);
2281 hash_openowner(oo, clp, strhashval);
2286 init_stateid(struct nfs4_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2287 struct nfs4_openowner *oo = open->op_openowner;
2288 unsigned int hashval = stateid_hashval(oo->oo_owner.so_id, fp->fi_id);
2290 INIT_LIST_HEAD(&stp->st_hash);
2291 INIT_LIST_HEAD(&stp->st_perstateowner);
2292 INIT_LIST_HEAD(&stp->st_lockowners);
2293 INIT_LIST_HEAD(&stp->st_perfile);
2294 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
2295 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
2296 list_add(&stp->st_perfile, &fp->fi_stateids);
2297 stp->st_type = NFS4_OPEN_STID;
2298 stp->st_stateowner = &oo->oo_owner;
2301 stp->st_stateid.si_boot = boot_time;
2302 stp->st_stateid.si_stateownerid = oo->oo_owner.so_id;
2303 stp->st_stateid.si_fileid = fp->fi_id;
2304 /* note will be incremented before first return to client: */
2305 stp->st_stateid.si_generation = 0;
2306 stp->st_access_bmap = 0;
2307 stp->st_deny_bmap = 0;
2308 __set_bit(open->op_share_access & ~NFS4_SHARE_WANT_MASK,
2309 &stp->st_access_bmap);
2310 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
2311 stp->st_openstp = NULL;
2315 move_to_close_lru(struct nfs4_openowner *oo)
2317 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
2319 list_move_tail(&oo->oo_close_lru, &close_lru);
2320 oo->oo_time = get_seconds();
2324 same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2327 return (sop->so_owner.len == owner->len) &&
2328 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2329 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
2332 static struct nfs4_openowner *
2333 find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open)
2335 struct nfs4_stateowner *so = NULL;
2337 list_for_each_entry(so, &open_ownerstr_hashtbl[hashval], so_strhash) {
2338 if (same_owner_str(so, &open->op_owner, &open->op_clientid))
2339 return container_of(so, struct nfs4_openowner, oo_owner);
2344 /* search file_hashtbl[] for file */
2345 static struct nfs4_file *
2346 find_file(struct inode *ino)
2348 unsigned int hashval = file_hashval(ino);
2349 struct nfs4_file *fp;
2351 spin_lock(&recall_lock);
2352 list_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2353 if (fp->fi_inode == ino) {
2355 spin_unlock(&recall_lock);
2359 spin_unlock(&recall_lock);
2363 static inline int access_valid(u32 x, u32 minorversion)
2365 if ((x & NFS4_SHARE_ACCESS_MASK) < NFS4_SHARE_ACCESS_READ)
2367 if ((x & NFS4_SHARE_ACCESS_MASK) > NFS4_SHARE_ACCESS_BOTH)
2369 x &= ~NFS4_SHARE_ACCESS_MASK;
2370 if (minorversion && x) {
2371 if ((x & NFS4_SHARE_WANT_MASK) > NFS4_SHARE_WANT_CANCEL)
2373 if ((x & NFS4_SHARE_WHEN_MASK) > NFS4_SHARE_PUSH_DELEG_WHEN_UNCONTENDED)
2375 x &= ~(NFS4_SHARE_WANT_MASK | NFS4_SHARE_WHEN_MASK);
2382 static inline int deny_valid(u32 x)
2384 /* Note: unlike access bits, deny bits may be zero. */
2385 return x <= NFS4_SHARE_DENY_BOTH;
2389 * Called to check deny when READ with all zero stateid or
2390 * WRITE with all zero or all one stateid
2393 nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2395 struct inode *ino = current_fh->fh_dentry->d_inode;
2396 struct nfs4_file *fp;
2397 struct nfs4_stateid *stp;
2400 dprintk("NFSD: nfs4_share_conflict\n");
2402 fp = find_file(ino);
2405 ret = nfserr_locked;
2406 /* Search for conflicting share reservations */
2407 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2408 if (test_bit(deny_type, &stp->st_deny_bmap) ||
2409 test_bit(NFS4_SHARE_DENY_BOTH, &stp->st_deny_bmap))
2418 static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
2420 /* We're assuming the state code never drops its reference
2421 * without first removing the lease. Since we're in this lease
2422 * callback (and since the lease code is serialized by the kernel
2423 * lock) we know the server hasn't removed the lease yet, we know
2424 * it's safe to take a reference: */
2425 atomic_inc(&dp->dl_count);
2427 list_add_tail(&dp->dl_recall_lru, &del_recall_lru);
2429 /* only place dl_time is set. protected by lock_flocks*/
2430 dp->dl_time = get_seconds();
2432 nfsd4_cb_recall(dp);
2435 /* Called from break_lease() with lock_flocks() held. */
2436 static void nfsd_break_deleg_cb(struct file_lock *fl)
2438 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2439 struct nfs4_delegation *dp;
2442 /* We assume break_lease is only called once per lease: */
2443 BUG_ON(fp->fi_had_conflict);
2445 * We don't want the locks code to timeout the lease for us;
2446 * we'll remove it ourself if a delegation isn't returned
2449 fl->fl_break_time = 0;
2451 spin_lock(&recall_lock);
2452 fp->fi_had_conflict = true;
2453 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2454 nfsd_break_one_deleg(dp);
2455 spin_unlock(&recall_lock);
2459 int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2462 return lease_modify(onlist, arg);
2467 static const struct lock_manager_operations nfsd_lease_mng_ops = {
2468 .lm_break = nfsd_break_deleg_cb,
2469 .lm_change = nfsd_change_deleg_cb,
2472 static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2474 if (nfsd4_has_session(cstate))
2476 if (seqid == so->so_seqid - 1)
2477 return nfserr_replay_me;
2478 if (seqid == so->so_seqid)
2480 return nfserr_bad_seqid;
2484 nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2485 struct nfsd4_open *open)
2487 clientid_t *clientid = &open->op_clientid;
2488 struct nfs4_client *clp = NULL;
2489 unsigned int strhashval;
2490 struct nfs4_openowner *oo = NULL;
2493 if (!check_name(open->op_owner))
2494 return nfserr_inval;
2496 if (STALE_CLIENTID(&open->op_clientid))
2497 return nfserr_stale_clientid;
2499 strhashval = open_ownerstr_hashval(clientid->cl_id, &open->op_owner);
2500 oo = find_openstateowner_str(strhashval, open);
2501 open->op_openowner = oo;
2503 /* Make sure the client's lease hasn't expired. */
2504 clp = find_confirmed_client(clientid);
2506 return nfserr_expired;
2509 if (!oo->oo_confirmed) {
2510 /* Replace unconfirmed owners without checking for replay. */
2511 clp = oo->oo_owner.so_client;
2512 release_openowner(oo);
2513 open->op_openowner = NULL;
2516 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2520 if (open->op_openowner == NULL) {
2521 oo = alloc_init_open_stateowner(strhashval, clp, open);
2523 return nfserr_jukebox;
2524 open->op_openowner = oo;
2526 list_del_init(&oo->oo_close_lru);
2527 renew_client(oo->oo_owner.so_client);
2531 static inline __be32
2532 nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2534 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2535 return nfserr_openmode;
2540 static struct nfs4_delegation *
2541 find_delegation_file(struct nfs4_file *fp, stateid_t *stid)
2543 struct nfs4_delegation *dp;
2545 spin_lock(&recall_lock);
2546 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2547 if (dp->dl_stateid.si_stateownerid == stid->si_stateownerid) {
2548 spin_unlock(&recall_lock);
2551 spin_unlock(&recall_lock);
2555 static int share_access_to_flags(u32 share_access)
2557 share_access &= ~NFS4_SHARE_WANT_MASK;
2559 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2563 nfs4_check_deleg(struct nfs4_file *fp, struct nfsd4_open *open,
2564 struct nfs4_delegation **dp)
2567 __be32 status = nfserr_bad_stateid;
2569 *dp = find_delegation_file(fp, &open->op_delegate_stateid);
2572 flags = share_access_to_flags(open->op_share_access);
2573 status = nfs4_check_delegmode(*dp, flags);
2577 if (open->op_claim_type != NFS4_OPEN_CLAIM_DELEGATE_CUR)
2581 open->op_openowner->oo_confirmed = 1;
2586 nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_stateid **stpp)
2588 struct nfs4_stateid *local;
2589 struct nfs4_openowner *oo = open->op_openowner;
2591 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
2592 /* ignore lock owners */
2593 if (local->st_stateowner->so_is_open_owner == 0)
2595 /* remember if we have seen this open owner */
2596 if (local->st_stateowner == &oo->oo_owner)
2598 /* check for conflicting share reservations */
2599 if (!test_share(local, open))
2600 return nfserr_share_denied;
2605 static inline struct nfs4_stateid *
2606 nfs4_alloc_stateid(void)
2608 return kmem_cache_alloc(stateid_slab, GFP_KERNEL);
2611 static inline int nfs4_access_to_access(u32 nfs4_access)
2615 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2616 flags |= NFSD_MAY_READ;
2617 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2618 flags |= NFSD_MAY_WRITE;
2622 static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2623 struct svc_fh *cur_fh, struct nfsd4_open *open)
2626 int oflag = nfs4_access_to_omode(open->op_share_access);
2627 int access = nfs4_access_to_access(open->op_share_access);
2629 /* CLAIM_DELEGATE_CUR is used in response to a broken lease;
2630 * allowing it to break the lease and return EAGAIN leaves the
2631 * client unable to make progress in returning the delegation */
2632 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2633 access |= NFSD_MAY_NOT_BREAK_LEASE;
2635 if (!fp->fi_fds[oflag]) {
2636 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2637 &fp->fi_fds[oflag]);
2641 nfs4_file_get_access(fp, oflag);
2647 nfs4_new_open(struct svc_rqst *rqstp, struct nfs4_stateid **stpp,
2648 struct nfs4_file *fp, struct svc_fh *cur_fh,
2649 struct nfsd4_open *open)
2651 struct nfs4_stateid *stp;
2654 stp = nfs4_alloc_stateid();
2656 return nfserr_jukebox;
2658 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2660 kmem_cache_free(stateid_slab, stp);
2667 static inline __be32
2668 nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2669 struct nfsd4_open *open)
2671 struct iattr iattr = {
2672 .ia_valid = ATTR_SIZE,
2675 if (!open->op_truncate)
2677 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
2678 return nfserr_inval;
2679 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2683 nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_stateid *stp, struct nfsd4_open *open)
2685 u32 op_share_access = open->op_share_access & ~NFS4_SHARE_WANT_MASK;
2689 new_access = !test_bit(op_share_access, &stp->st_access_bmap);
2691 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2695 status = nfsd4_truncate(rqstp, cur_fh, open);
2698 int oflag = nfs4_access_to_omode(op_share_access);
2699 nfs4_file_put_access(fp, oflag);
2703 /* remember the open */
2704 __set_bit(op_share_access, &stp->st_access_bmap);
2705 __set_bit(open->op_share_deny, &stp->st_deny_bmap);
2712 nfs4_set_claim_prev(struct nfsd4_open *open)
2714 open->op_openowner->oo_confirmed = 1;
2715 open->op_openowner->oo_owner.so_client->cl_firststate = 1;
2718 /* Should we give out recallable state?: */
2719 static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2721 if (clp->cl_cb_state == NFSD4_CB_UP)
2724 * In the sessions case, since we don't have to establish a
2725 * separate connection for callbacks, we assume it's OK
2726 * until we hear otherwise:
2728 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
2731 static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
2733 struct file_lock *fl;
2735 fl = locks_alloc_lock();
2738 locks_init_lock(fl);
2739 fl->fl_lmops = &nfsd_lease_mng_ops;
2740 fl->fl_flags = FL_LEASE;
2741 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
2742 fl->fl_end = OFFSET_MAX;
2743 fl->fl_owner = (fl_owner_t)(dp->dl_file);
2744 fl->fl_pid = current->tgid;
2748 static int nfs4_setlease(struct nfs4_delegation *dp, int flag)
2750 struct nfs4_file *fp = dp->dl_file;
2751 struct file_lock *fl;
2754 fl = nfs4_alloc_init_lease(dp, flag);
2757 fl->fl_file = find_readable_file(fp);
2758 list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2759 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
2761 list_del_init(&dp->dl_perclnt);
2762 locks_free_lock(fl);
2766 fp->fi_deleg_file = fl->fl_file;
2767 get_file(fp->fi_deleg_file);
2768 atomic_set(&fp->fi_delegees, 1);
2769 list_add(&dp->dl_perfile, &fp->fi_delegations);
2773 static int nfs4_set_delegation(struct nfs4_delegation *dp, int flag)
2775 struct nfs4_file *fp = dp->dl_file;
2778 return nfs4_setlease(dp, flag);
2779 spin_lock(&recall_lock);
2780 if (fp->fi_had_conflict) {
2781 spin_unlock(&recall_lock);
2784 atomic_inc(&fp->fi_delegees);
2785 list_add(&dp->dl_perfile, &fp->fi_delegations);
2786 spin_unlock(&recall_lock);
2787 list_add(&dp->dl_perclnt, &dp->dl_client->cl_delegations);
2792 * Attempt to hand out a delegation.
2795 nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open, struct nfs4_stateid *stp)
2797 struct nfs4_delegation *dp;
2798 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
2800 int status, flag = 0;
2802 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
2803 flag = NFS4_OPEN_DELEGATE_NONE;
2804 open->op_recall = 0;
2805 switch (open->op_claim_type) {
2806 case NFS4_OPEN_CLAIM_PREVIOUS:
2808 open->op_recall = 1;
2809 flag = open->op_delegate_type;
2810 if (flag == NFS4_OPEN_DELEGATE_NONE)
2813 case NFS4_OPEN_CLAIM_NULL:
2814 /* Let's not give out any delegations till everyone's
2815 * had the chance to reclaim theirs.... */
2816 if (locks_in_grace())
2818 if (!cb_up || !oo->oo_confirmed)
2820 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
2821 flag = NFS4_OPEN_DELEGATE_WRITE;
2823 flag = NFS4_OPEN_DELEGATE_READ;
2829 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh, flag);
2832 status = nfs4_set_delegation(dp, flag);
2836 memcpy(&open->op_delegate_stateid, &dp->dl_stateid, sizeof(dp->dl_stateid));
2838 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
2839 STATEID_VAL(&dp->dl_stateid));
2841 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS
2842 && flag == NFS4_OPEN_DELEGATE_NONE
2843 && open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE)
2844 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
2845 open->op_delegate_type = flag;
2848 nfs4_put_delegation(dp);
2850 flag = NFS4_OPEN_DELEGATE_NONE;
2855 * called with nfs4_lock_state() held.
2858 nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
2860 struct nfsd4_compoundres *resp = rqstp->rq_resp;
2861 struct nfs4_file *fp = NULL;
2862 struct inode *ino = current_fh->fh_dentry->d_inode;
2863 struct nfs4_stateid *stp = NULL;
2864 struct nfs4_delegation *dp = NULL;
2867 status = nfserr_inval;
2868 if (!access_valid(open->op_share_access, resp->cstate.minorversion)
2869 || !deny_valid(open->op_share_deny))
2872 * Lookup file; if found, lookup stateid and check open request,
2873 * and check for delegations in the process of being recalled.
2874 * If not found, create the nfs4_file struct
2876 fp = find_file(ino);
2878 if ((status = nfs4_check_open(fp, open, &stp)))
2880 status = nfs4_check_deleg(fp, open, &dp);
2884 status = nfserr_bad_stateid;
2885 if (open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR)
2887 status = nfserr_jukebox;
2888 fp = alloc_init_file(ino);
2894 * OPEN the file, or upgrade an existing OPEN.
2895 * If truncate fails, the OPEN fails.
2898 /* Stateid was found, this is an OPEN upgrade */
2899 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
2903 status = nfs4_new_open(rqstp, &stp, fp, current_fh, open);
2906 init_stateid(stp, fp, open);
2907 status = nfsd4_truncate(rqstp, current_fh, open);
2909 release_open_stateid(stp);
2913 update_stateid(&stp->st_stateid);
2914 memcpy(&open->op_stateid, &stp->st_stateid, sizeof(stateid_t));
2916 if (nfsd4_has_session(&resp->cstate))
2917 open->op_openowner->oo_confirmed = 1;
2920 * Attempt to hand out a delegation. No error return, because the
2921 * OPEN succeeds even if we fail.
2923 nfs4_open_delegation(current_fh, open, stp);
2927 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
2928 STATEID_VAL(&stp->st_stateid));
2932 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
2933 nfs4_set_claim_prev(open);
2935 * To finish the open response, we just need to set the rflags.
2937 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
2938 if (!open->op_openowner->oo_confirmed &&
2939 !nfsd4_has_session(&resp->cstate))
2940 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
2946 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2949 struct nfs4_client *clp;
2953 dprintk("process_renew(%08x/%08x): starting\n",
2954 clid->cl_boot, clid->cl_id);
2955 status = nfserr_stale_clientid;
2956 if (STALE_CLIENTID(clid))
2958 clp = find_confirmed_client(clid);
2959 status = nfserr_expired;
2961 /* We assume the client took too long to RENEW. */
2962 dprintk("nfsd4_renew: clientid not found!\n");
2966 status = nfserr_cb_path_down;
2967 if (!list_empty(&clp->cl_delegations)
2968 && clp->cl_cb_state != NFSD4_CB_UP)
2972 nfs4_unlock_state();
2976 static struct lock_manager nfsd4_manager = {
2980 nfsd4_end_grace(void)
2982 dprintk("NFSD: end of grace period\n");
2983 nfsd4_recdir_purge_old();
2984 locks_end_grace(&nfsd4_manager);
2986 * Now that every NFSv4 client has had the chance to recover and
2987 * to see the (possibly new, possibly shorter) lease time, we
2988 * can safely set the next grace time to the current lease time:
2990 nfsd4_grace = nfsd4_lease;
2994 nfs4_laundromat(void)
2996 struct nfs4_client *clp;
2997 struct nfs4_openowner *oo;
2998 struct nfs4_delegation *dp;
2999 struct list_head *pos, *next, reaplist;
3000 time_t cutoff = get_seconds() - nfsd4_lease;
3001 time_t t, clientid_val = nfsd4_lease;
3002 time_t u, test_val = nfsd4_lease;
3006 dprintk("NFSD: laundromat service - starting\n");
3007 if (locks_in_grace())
3009 INIT_LIST_HEAD(&reaplist);
3010 spin_lock(&client_lock);
3011 list_for_each_safe(pos, next, &client_lru) {
3012 clp = list_entry(pos, struct nfs4_client, cl_lru);
3013 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3014 t = clp->cl_time - cutoff;
3015 if (clientid_val > t)
3019 if (atomic_read(&clp->cl_refcount)) {
3020 dprintk("NFSD: client in use (clientid %08x)\n",
3021 clp->cl_clientid.cl_id);
3024 unhash_client_locked(clp);
3025 list_add(&clp->cl_lru, &reaplist);
3027 spin_unlock(&client_lock);
3028 list_for_each_safe(pos, next, &reaplist) {
3029 clp = list_entry(pos, struct nfs4_client, cl_lru);
3030 dprintk("NFSD: purging unused client (clientid %08x)\n",
3031 clp->cl_clientid.cl_id);
3032 nfsd4_remove_clid_dir(clp);
3035 spin_lock(&recall_lock);
3036 list_for_each_safe(pos, next, &del_recall_lru) {
3037 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3038 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3039 u = dp->dl_time - cutoff;
3044 list_move(&dp->dl_recall_lru, &reaplist);
3046 spin_unlock(&recall_lock);
3047 list_for_each_safe(pos, next, &reaplist) {
3048 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3049 list_del_init(&dp->dl_recall_lru);
3050 unhash_delegation(dp);
3052 test_val = nfsd4_lease;
3053 list_for_each_safe(pos, next, &close_lru) {
3054 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3055 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3056 u = oo->oo_time - cutoff;
3061 dprintk("NFSD: purging unused open stateowner (so_id %d)\n",
3062 oo->oo_owner.so_id);
3063 release_openowner(oo);
3065 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3066 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3067 nfs4_unlock_state();
3068 return clientid_val;
3071 static struct workqueue_struct *laundry_wq;
3072 static void laundromat_main(struct work_struct *);
3073 static DECLARE_DELAYED_WORK(laundromat_work, laundromat_main);
3076 laundromat_main(struct work_struct *not_used)
3080 t = nfs4_laundromat();
3081 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
3082 queue_delayed_work(laundry_wq, &laundromat_work, t*HZ);
3085 static struct nfs4_openowner * search_close_lru(u32 st_id)
3087 struct nfs4_openowner *local;
3089 list_for_each_entry(local, &close_lru, oo_close_lru) {
3090 if (local->oo_owner.so_id == st_id)
3097 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stateid *stp)
3099 return fhp->fh_dentry->d_inode != stp->st_file->fi_inode;
3103 STALE_STATEID(stateid_t *stateid)
3105 if (stateid->si_boot == boot_time)
3107 dprintk("NFSD: stale stateid " STATEID_FMT "!\n",
3108 STATEID_VAL(stateid));
3113 access_permit_read(unsigned long access_bmap)
3115 return test_bit(NFS4_SHARE_ACCESS_READ, &access_bmap) ||
3116 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap) ||
3117 test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap);
3121 access_permit_write(unsigned long access_bmap)
3123 return test_bit(NFS4_SHARE_ACCESS_WRITE, &access_bmap) ||
3124 test_bit(NFS4_SHARE_ACCESS_BOTH, &access_bmap);
3128 __be32 nfs4_check_openmode(struct nfs4_stateid *stp, int flags)
3130 __be32 status = nfserr_openmode;
3132 /* For lock stateid's, we test the parent open, not the lock: */
3133 if (stp->st_openstp)
3134 stp = stp->st_openstp;
3135 if ((flags & WR_STATE) && (!access_permit_write(stp->st_access_bmap)))
3137 if ((flags & RD_STATE) && (!access_permit_read(stp->st_access_bmap)))
3144 static inline __be32
3145 check_special_stateids(svc_fh *current_fh, stateid_t *stateid, int flags)
3147 if (ONE_STATEID(stateid) && (flags & RD_STATE))
3149 else if (locks_in_grace()) {
3150 /* Answer in remaining cases depends on existence of
3151 * conflicting state; so we must wait out the grace period. */
3152 return nfserr_grace;
3153 } else if (flags & WR_STATE)
3154 return nfs4_share_conflict(current_fh,
3155 NFS4_SHARE_DENY_WRITE);
3156 else /* (flags & RD_STATE) && ZERO_STATEID(stateid) */
3157 return nfs4_share_conflict(current_fh,
3158 NFS4_SHARE_DENY_READ);
3162 * Allow READ/WRITE during grace period on recovered state only for files
3163 * that are not able to provide mandatory locking.
3166 grace_disallows_io(struct inode *inode)
3168 return locks_in_grace() && mandatory_lock(inode);
3171 /* Returns true iff a is later than b: */
3172 static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3174 return (s32)a->si_generation - (s32)b->si_generation > 0;
3177 static int check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
3180 * When sessions are used the stateid generation number is ignored
3183 if (has_session && in->si_generation == 0)
3186 if (in->si_generation == ref->si_generation)
3189 /* If the client sends us a stateid from the future, it's buggy: */
3190 if (stateid_generation_after(in, ref))
3191 return nfserr_bad_stateid;
3193 * However, we could see a stateid from the past, even from a
3194 * non-buggy client. For example, if the client sends a lock
3195 * while some IO is outstanding, the lock may bump si_generation
3196 * while the IO is still in flight. The client could avoid that
3197 * situation by waiting for responses on all the IO requests,
3198 * but better performance may result in retrying IO that
3199 * receives an old_stateid error if requests are rarely
3200 * reordered in flight:
3202 return nfserr_old_stateid;
3205 static int is_delegation_stateid(stateid_t *stateid)
3207 return stateid->si_fileid == 0;
3210 __be32 nfs4_validate_stateid(stateid_t *stateid, bool has_session)
3212 struct nfs4_stateid *stp = NULL;
3213 __be32 status = nfserr_stale_stateid;
3215 if (STALE_STATEID(stateid))
3218 status = nfserr_expired;
3219 stp = find_stateid(stateid, 0);
3222 status = nfserr_bad_stateid;
3224 if (stp->st_stateowner->so_is_open_owner
3225 && !openowner(stp->st_stateowner)->oo_confirmed)
3228 status = check_stateid_generation(stateid, &stp->st_stateid, has_session);
3238 * Checks for stateid operations
3241 nfs4_preprocess_stateid_op(struct nfsd4_compound_state *cstate,
3242 stateid_t *stateid, int flags, struct file **filpp)
3244 struct nfs4_stateid *stp = NULL;
3245 struct nfs4_delegation *dp = NULL;
3246 struct svc_fh *current_fh = &cstate->current_fh;
3247 struct inode *ino = current_fh->fh_dentry->d_inode;
3253 if (grace_disallows_io(ino))
3254 return nfserr_grace;
3256 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3257 return check_special_stateids(current_fh, stateid, flags);
3259 status = nfserr_stale_stateid;
3260 if (STALE_STATEID(stateid))
3264 * We assume that any stateid that has the current boot time,
3265 * but that we can't find, is expired:
3267 status = nfserr_expired;
3268 if (is_delegation_stateid(stateid)) {
3269 dp = find_delegation_stateid(ino, stateid);
3272 status = check_stateid_generation(stateid, &dp->dl_stateid, nfsd4_has_session(cstate));
3275 status = nfs4_check_delegmode(dp, flags);
3278 renew_client(dp->dl_client);
3280 *filpp = dp->dl_file->fi_deleg_file;
3283 } else { /* open or lock stateid */
3284 stp = find_stateid(stateid, flags);
3287 status = nfserr_bad_stateid;
3288 if (nfs4_check_fh(current_fh, stp))
3290 if (stp->st_stateowner->so_is_open_owner
3291 && !openowner(stp->st_stateowner)->oo_confirmed)
3293 status = check_stateid_generation(stateid, &stp->st_stateid,
3294 nfsd4_has_session(cstate));
3297 status = nfs4_check_openmode(stp, flags);
3300 renew_client(stp->st_stateowner->so_client);
3302 if (flags & RD_STATE)
3303 *filpp = find_readable_file(stp->st_file);
3305 *filpp = find_writeable_file(stp->st_file);
3314 nfsd4_free_delegation_stateid(stateid_t *stateid)
3316 struct nfs4_delegation *dp = search_for_delegation(stateid);
3318 return nfserr_locks_held;
3319 return nfserr_bad_stateid;
3323 nfsd4_free_lock_stateid(struct nfs4_stateid *stp)
3325 if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
3326 return nfserr_locks_held;
3327 release_lock_stateid(stp);
3332 * Test if the stateid is valid
3335 nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3336 struct nfsd4_test_stateid *test_stateid)
3338 test_stateid->ts_has_session = nfsd4_has_session(cstate);
3346 nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3347 struct nfsd4_free_stateid *free_stateid)
3349 stateid_t *stateid = &free_stateid->fr_stateid;
3350 struct nfs4_stateid *stp;
3354 if (is_delegation_stateid(stateid)) {
3355 ret = nfsd4_free_delegation_stateid(stateid);
3359 stp = find_stateid(stateid, 0);
3361 ret = nfserr_bad_stateid;
3364 ret = check_stateid_generation(stateid, &stp->st_stateid, 1);
3368 if (stp->st_type == NFS4_OPEN_STID) {
3369 ret = nfserr_locks_held;
3372 ret = nfsd4_free_lock_stateid(stp);
3377 nfs4_unlock_state();
3384 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3385 RD_STATE : WR_STATE;
3389 * Checks for sequence id mutating operations.
3392 nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3393 stateid_t *stateid, int flags,
3394 struct nfs4_stateid **stpp)
3396 struct nfs4_stateowner *sop;
3397 struct svc_fh *current_fh = &cstate->current_fh;
3400 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3401 seqid, STATEID_VAL(stateid));
3405 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
3406 dprintk("NFSD: preprocess_seqid_op: magic stateid!\n");
3407 return nfserr_bad_stateid;
3410 if (STALE_STATEID(stateid))
3411 return nfserr_stale_stateid;
3414 * We return BAD_STATEID if filehandle doesn't match stateid,
3415 * the confirmed flag is incorrecly set, or the generation
3416 * number is incorrect.
3418 *stpp = find_stateid(stateid, flags);
3420 return nfserr_expired;
3422 sop = (*stpp)->st_stateowner;
3423 cstate->replay_owner = sop;
3425 if (nfs4_check_fh(current_fh, *stpp)) {
3426 dprintk("NFSD: preprocess_seqid_op: fh-stateid mismatch!\n");
3427 return nfserr_bad_stateid;
3430 status = nfsd4_check_seqid(cstate, sop, seqid);
3434 if (sop->so_is_open_owner && !openowner(sop)->oo_confirmed
3435 && !(flags & CONFIRM)) {
3436 dprintk("NFSD: preprocess_seqid_op: stateowner not"
3437 " confirmed yet!\n");
3438 return nfserr_bad_stateid;
3440 status = check_stateid_generation(stateid, &(*stpp)->st_stateid, nfsd4_has_session(cstate));
3443 renew_client(sop->so_client);
3448 nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3449 struct nfsd4_open_confirm *oc)
3452 struct nfs4_openowner *oo;
3453 struct nfs4_stateid *stp;
3455 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
3456 (int)cstate->current_fh.fh_dentry->d_name.len,
3457 cstate->current_fh.fh_dentry->d_name.name);
3459 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
3465 status = nfs4_preprocess_seqid_op(cstate,
3466 oc->oc_seqid, &oc->oc_req_stateid,
3467 CONFIRM | OPEN_STATE, &stp);
3470 oo = openowner(stp->st_stateowner);
3471 status = nfserr_bad_stateid;
3472 if (oo->oo_confirmed)
3474 oo->oo_confirmed = 1;
3475 update_stateid(&stp->st_stateid);
3476 memcpy(&oc->oc_resp_stateid, &stp->st_stateid, sizeof(stateid_t));
3477 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3478 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stateid));
3480 nfsd4_create_clid_dir(oo->oo_owner.so_client);
3483 if (!cstate->replay_owner)
3484 nfs4_unlock_state();
3488 static inline void nfs4_file_downgrade(struct nfs4_stateid *stp, unsigned int to_access)
3492 for (i = 1; i < 4; i++) {
3493 if (test_bit(i, &stp->st_access_bmap) && !(i & to_access)) {
3494 nfs4_file_put_access(stp->st_file, i);
3495 __clear_bit(i, &stp->st_access_bmap);
3501 reset_union_bmap_deny(unsigned long deny, unsigned long *bmap)
3504 for (i = 0; i < 4; i++) {
3505 if ((i & deny) != i)
3506 __clear_bit(i, bmap);
3511 nfsd4_open_downgrade(struct svc_rqst *rqstp,
3512 struct nfsd4_compound_state *cstate,
3513 struct nfsd4_open_downgrade *od)
3516 struct nfs4_stateid *stp;
3518 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
3519 (int)cstate->current_fh.fh_dentry->d_name.len,
3520 cstate->current_fh.fh_dentry->d_name.name);
3522 if (!access_valid(od->od_share_access, cstate->minorversion)
3523 || !deny_valid(od->od_share_deny))
3524 return nfserr_inval;
3527 status = nfs4_preprocess_seqid_op(cstate, od->od_seqid,
3528 &od->od_stateid, OPEN_STATE, &stp);
3531 status = nfserr_inval;
3532 if (!test_bit(od->od_share_access, &stp->st_access_bmap)) {
3533 dprintk("NFSD:access not a subset current bitmap: 0x%lx, input access=%08x\n",
3534 stp->st_access_bmap, od->od_share_access);
3537 if (!test_bit(od->od_share_deny, &stp->st_deny_bmap)) {
3538 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3539 stp->st_deny_bmap, od->od_share_deny);
3542 nfs4_file_downgrade(stp, od->od_share_access);
3544 reset_union_bmap_deny(od->od_share_deny, &stp->st_deny_bmap);
3546 update_stateid(&stp->st_stateid);
3547 memcpy(&od->od_stateid, &stp->st_stateid, sizeof(stateid_t));
3550 if (!cstate->replay_owner)
3551 nfs4_unlock_state();
3556 * nfs4_unlock_state() called after encode
3559 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3560 struct nfsd4_close *close)
3563 struct nfs4_openowner *oo;
3564 struct nfs4_stateid *stp;
3566 dprintk("NFSD: nfsd4_close on file %.*s\n",
3567 (int)cstate->current_fh.fh_dentry->d_name.len,
3568 cstate->current_fh.fh_dentry->d_name.name);
3571 /* check close_lru for replay */
3572 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
3575 if (stp == NULL && status == nfserr_expired) {
3577 * Also, we should make sure this isn't just the result of
3580 oo = search_close_lru(close->cl_stateid.si_stateownerid);
3581 /* It's not stale; let's assume it's expired: */
3584 cstate->replay_owner = &oo->oo_owner;
3585 status = nfsd4_check_seqid(cstate, &oo->oo_owner, close->cl_seqid);
3588 status = nfserr_bad_seqid;
3592 oo = openowner(stp->st_stateowner);
3594 update_stateid(&stp->st_stateid);
3595 memcpy(&close->cl_stateid, &stp->st_stateid, sizeof(stateid_t));
3597 /* release_stateid() calls nfsd_close() if needed */
3598 release_open_stateid(stp);
3600 /* place unused nfs4_stateowners on so_close_lru list to be
3601 * released by the laundromat service after the lease period
3602 * to enable us to handle CLOSE replay
3604 if (list_empty(&oo->oo_owner.so_stateids))
3605 move_to_close_lru(oo);
3607 if (!cstate->replay_owner)
3608 nfs4_unlock_state();
3613 nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3614 struct nfsd4_delegreturn *dr)
3616 struct nfs4_delegation *dp;
3617 stateid_t *stateid = &dr->dr_stateid;
3618 struct inode *inode;
3621 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
3623 inode = cstate->current_fh.fh_dentry->d_inode;
3626 status = nfserr_bad_stateid;
3627 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3629 status = nfserr_stale_stateid;
3630 if (STALE_STATEID(stateid))
3632 status = nfserr_bad_stateid;
3633 if (!is_delegation_stateid(stateid))
3635 status = nfserr_expired;
3636 dp = find_delegation_stateid(inode, stateid);
3639 status = check_stateid_generation(stateid, &dp->dl_stateid, nfsd4_has_session(cstate));
3642 renew_client(dp->dl_client);
3644 unhash_delegation(dp);
3646 nfs4_unlock_state();
3653 * Lock owner state (byte-range locks)
3655 #define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
3656 #define LOCK_HASH_BITS 8
3657 #define LOCK_HASH_SIZE (1 << LOCK_HASH_BITS)
3658 #define LOCK_HASH_MASK (LOCK_HASH_SIZE - 1)
3661 end_offset(u64 start, u64 len)
3666 return end >= start ? end: NFS4_MAX_UINT64;
3669 /* last octet in a range */
3671 last_byte_offset(u64 start, u64 len)
3677 return end > start ? end - 1: NFS4_MAX_UINT64;
3680 static unsigned int lockownerid_hashval(u32 id)
3682 return id & LOCK_HASH_MASK;
3685 static inline unsigned int
3686 lock_ownerstr_hashval(struct inode *inode, u32 cl_id,
3687 struct xdr_netobj *ownername)
3689 return (file_hashval(inode) + cl_id
3690 + opaque_hashval(ownername->data, ownername->len))
3694 static struct list_head lock_ownerid_hashtbl[LOCK_HASH_SIZE];
3695 static struct list_head lock_ownerstr_hashtbl[LOCK_HASH_SIZE];
3698 same_stateid(stateid_t *id_one, stateid_t *id_two)
3700 if (id_one->si_stateownerid != id_two->si_stateownerid)
3702 return id_one->si_fileid == id_two->si_fileid;
3705 static struct nfs4_stateid *find_stateid(stateid_t *t, int flags)
3707 struct nfs4_stateid *s;
3708 unsigned int hashval;
3710 hashval = stateid_hashval(t->si_stateownerid, t->si_fileid);
3711 list_for_each_entry(s, &stateid_hashtbl[hashval], st_hash) {
3712 if (!same_stateid(&s->st_stateid, t))
3714 if (flags & LOCK_STATE && s->st_type != NFS4_LOCK_STID)
3716 if (flags & OPEN_STATE && s->st_type != NFS4_OPEN_STID)
3723 static struct nfs4_delegation *
3724 search_for_delegation(stateid_t *stid)
3726 struct nfs4_file *fp;
3727 struct nfs4_delegation *dp;
3728 struct list_head *pos;
3731 for (i = 0; i < FILE_HASH_SIZE; i++) {
3732 list_for_each_entry(fp, &file_hashtbl[i], fi_hash) {
3733 list_for_each(pos, &fp->fi_delegations) {
3734 dp = list_entry(pos, struct nfs4_delegation, dl_perfile);
3735 if (same_stateid(&dp->dl_stateid, stid))
3743 static struct nfs4_delegation *
3744 find_delegation_stateid(struct inode *ino, stateid_t *stid)
3746 struct nfs4_file *fp;
3747 struct nfs4_delegation *dl;
3749 dprintk("NFSD: %s: stateid=" STATEID_FMT "\n", __func__,
3752 fp = find_file(ino);
3755 dl = find_delegation_file(fp, stid);
3761 * TODO: Linux file offsets are _signed_ 64-bit quantities, which means that
3762 * we can't properly handle lock requests that go beyond the (2^63 - 1)-th
3763 * byte, because of sign extension problems. Since NFSv4 calls for 64-bit
3764 * locking, this prevents us from being completely protocol-compliant. The
3765 * real solution to this problem is to start using unsigned file offsets in
3766 * the VFS, but this is a very deep change!
3769 nfs4_transform_lock_offset(struct file_lock *lock)
3771 if (lock->fl_start < 0)
3772 lock->fl_start = OFFSET_MAX;
3773 if (lock->fl_end < 0)
3774 lock->fl_end = OFFSET_MAX;
3777 /* Hack!: For now, we're defining this just so we can use a pointer to it
3778 * as a unique cookie to identify our (NFSv4's) posix locks. */
3779 static const struct lock_manager_operations nfsd_posix_mng_ops = {
3783 nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
3785 struct nfs4_lockowner *lo;
3787 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
3788 lo = (struct nfs4_lockowner *) fl->fl_owner;
3789 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
3790 lo->lo_owner.so_owner.len, GFP_KERNEL);
3791 if (!deny->ld_owner.data)
3792 /* We just don't care that much */
3794 deny->ld_owner.len = lo->lo_owner.so_owner.len;
3795 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
3798 deny->ld_owner.len = 0;
3799 deny->ld_owner.data = NULL;
3800 deny->ld_clientid.cl_boot = 0;
3801 deny->ld_clientid.cl_id = 0;
3803 deny->ld_start = fl->fl_start;
3804 deny->ld_length = NFS4_MAX_UINT64;
3805 if (fl->fl_end != NFS4_MAX_UINT64)
3806 deny->ld_length = fl->fl_end - fl->fl_start + 1;
3807 deny->ld_type = NFS4_READ_LT;
3808 if (fl->fl_type != F_RDLCK)
3809 deny->ld_type = NFS4_WRITE_LT;
3812 static struct nfs4_lockowner *
3813 find_lockowner_str(struct inode *inode, clientid_t *clid,
3814 struct xdr_netobj *owner)
3816 unsigned int hashval = lock_ownerstr_hashval(inode, clid->cl_id, owner);
3817 struct nfs4_stateowner *op;
3819 list_for_each_entry(op, &lock_ownerstr_hashtbl[hashval], so_strhash) {
3820 if (same_owner_str(op, owner, clid))
3821 return lockowner(op);
3826 static void hash_lockowner(struct nfs4_lockowner *lo, unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp)
3828 unsigned int idhashval;
3830 idhashval = lockownerid_hashval(lo->lo_owner.so_id);
3831 list_add(&lo->lo_owner.so_idhash, &lock_ownerid_hashtbl[idhashval]);
3832 list_add(&lo->lo_owner.so_strhash, &lock_ownerstr_hashtbl[strhashval]);
3833 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
3837 * Alloc a lock owner structure.
3838 * Called in nfsd4_lock - therefore, OPEN and OPEN_CONFIRM (if needed) has
3841 * strhashval = lock_ownerstr_hashval
3844 static struct nfs4_lockowner *
3845 alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_stateid *open_stp, struct nfsd4_lock *lock) {
3846 struct nfs4_lockowner *lo;
3848 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
3851 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
3852 lo->lo_owner.so_is_open_owner = 0;
3853 /* It is the openowner seqid that will be incremented in encode in the
3854 * case of new lockowners; so increment the lock seqid manually: */
3855 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
3856 hash_lockowner(lo, strhashval, clp, open_stp);
3860 static struct nfs4_stateid *
3861 alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_stateid *open_stp)
3863 struct nfs4_stateid *stp;
3864 unsigned int hashval = stateid_hashval(lo->lo_owner.so_id, fp->fi_id);
3866 stp = nfs4_alloc_stateid();
3869 INIT_LIST_HEAD(&stp->st_hash);
3870 INIT_LIST_HEAD(&stp->st_perfile);
3871 INIT_LIST_HEAD(&stp->st_perstateowner);
3872 INIT_LIST_HEAD(&stp->st_lockowners); /* not used */
3873 list_add(&stp->st_hash, &stateid_hashtbl[hashval]);
3874 list_add(&stp->st_perfile, &fp->fi_stateids);
3875 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
3876 stp->st_stateowner = &lo->lo_owner;
3877 stp->st_type = NFS4_LOCK_STID;
3880 stp->st_stateid.si_boot = boot_time;
3881 stp->st_stateid.si_stateownerid = lo->lo_owner.so_id;
3882 stp->st_stateid.si_fileid = fp->fi_id;
3883 /* note will be incremented before first return to client: */
3884 stp->st_stateid.si_generation = 0;
3885 stp->st_access_bmap = 0;
3886 stp->st_deny_bmap = open_stp->st_deny_bmap;
3887 stp->st_openstp = open_stp;
3894 check_lock_length(u64 offset, u64 length)
3896 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
3897 LOFF_OVERFLOW(offset, length)));
3900 static void get_lock_access(struct nfs4_stateid *lock_stp, u32 access)
3902 struct nfs4_file *fp = lock_stp->st_file;
3903 int oflag = nfs4_access_to_omode(access);
3905 if (test_bit(access, &lock_stp->st_access_bmap))
3907 nfs4_file_get_access(fp, oflag);
3908 __set_bit(access, &lock_stp->st_access_bmap);
3915 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3916 struct nfsd4_lock *lock)
3918 struct nfs4_openowner *open_sop = NULL;
3919 struct nfs4_lockowner *lock_sop = NULL;
3920 struct nfs4_stateid *lock_stp;
3921 struct nfs4_file *fp;
3922 struct file *filp = NULL;
3923 struct file_lock file_lock;
3924 struct file_lock conflock;
3926 unsigned int strhashval;
3930 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
3931 (long long) lock->lk_offset,
3932 (long long) lock->lk_length);
3934 if (check_lock_length(lock->lk_offset, lock->lk_length))
3935 return nfserr_inval;
3937 if ((status = fh_verify(rqstp, &cstate->current_fh,
3938 S_IFREG, NFSD_MAY_LOCK))) {
3939 dprintk("NFSD: nfsd4_lock: permission denied!\n");
3945 if (lock->lk_is_new) {
3947 * Client indicates that this is a new lockowner.
3948 * Use open owner and open stateid to create lock owner and
3951 struct nfs4_stateid *open_stp = NULL;
3953 status = nfserr_stale_clientid;
3954 if (!nfsd4_has_session(cstate) &&
3955 STALE_CLIENTID(&lock->lk_new_clientid))
3958 /* validate and update open stateid and open seqid */
3959 status = nfs4_preprocess_seqid_op(cstate,
3960 lock->lk_new_open_seqid,
3961 &lock->lk_new_open_stateid,
3962 OPEN_STATE, &open_stp);
3965 open_sop = openowner(open_stp->st_stateowner);
3966 status = nfserr_bad_stateid;
3967 if (!nfsd4_has_session(cstate) &&
3968 !same_clid(&open_sop->oo_owner.so_client->cl_clientid,
3969 &lock->v.new.clientid))
3971 /* create lockowner and lock stateid */
3972 fp = open_stp->st_file;
3973 strhashval = lock_ownerstr_hashval(fp->fi_inode,
3974 open_sop->oo_owner.so_client->cl_clientid.cl_id,
3975 &lock->v.new.owner);
3976 /* XXX: Do we need to check for duplicate stateowners on
3977 * the same file, or should they just be allowed (and
3978 * create new stateids)? */
3979 status = nfserr_jukebox;
3980 lock_sop = alloc_init_lock_stateowner(strhashval,
3981 open_sop->oo_owner.so_client, open_stp, lock);
3982 if (lock_sop == NULL)
3984 lock_stp = alloc_init_lock_stateid(lock_sop, fp, open_stp);
3985 if (lock_stp == NULL)
3988 /* lock (lock owner + lock stateid) already exists */
3989 status = nfs4_preprocess_seqid_op(cstate,
3990 lock->lk_old_lock_seqid,
3991 &lock->lk_old_lock_stateid,
3992 LOCK_STATE, &lock_stp);
3995 lock_sop = lockowner(lock_stp->st_stateowner);
3996 fp = lock_stp->st_file;
3998 /* lock_sop and lock_stp have been created or found */
4000 lkflg = setlkflg(lock->lk_type);
4001 status = nfs4_check_openmode(lock_stp, lkflg);
4005 status = nfserr_grace;
4006 if (locks_in_grace() && !lock->lk_reclaim)
4008 status = nfserr_no_grace;
4009 if (!locks_in_grace() && lock->lk_reclaim)
4012 locks_init_lock(&file_lock);
4013 switch (lock->lk_type) {
4016 filp = find_readable_file(lock_stp->st_file);
4018 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
4019 file_lock.fl_type = F_RDLCK;
4022 case NFS4_WRITEW_LT:
4023 filp = find_writeable_file(lock_stp->st_file);
4025 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
4026 file_lock.fl_type = F_WRLCK;
4029 status = nfserr_inval;
4033 status = nfserr_openmode;
4036 file_lock.fl_owner = (fl_owner_t)lock_sop;
4037 file_lock.fl_pid = current->tgid;
4038 file_lock.fl_file = filp;
4039 file_lock.fl_flags = FL_POSIX;
4040 file_lock.fl_lmops = &nfsd_posix_mng_ops;
4042 file_lock.fl_start = lock->lk_offset;
4043 file_lock.fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4044 nfs4_transform_lock_offset(&file_lock);
4047 * Try to lock the file in the VFS.
4048 * Note: locks.c uses the BKL to protect the inode's lock list.
4051 err = vfs_lock_file(filp, F_SETLK, &file_lock, &conflock);
4053 case 0: /* success! */
4054 update_stateid(&lock_stp->st_stateid);
4055 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stateid,
4059 case (EAGAIN): /* conflock holds conflicting lock */
4060 status = nfserr_denied;
4061 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4062 nfs4_set_lock_denied(&conflock, &lock->lk_denied);
4065 status = nfserr_deadlock;
4068 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
4069 status = nfserrno(err);
4073 if (status && lock->lk_is_new && lock_sop)
4074 release_lockowner(lock_sop);
4075 if (!cstate->replay_owner)
4076 nfs4_unlock_state();
4081 * The NFSv4 spec allows a client to do a LOCKT without holding an OPEN,
4082 * so we do a temporary open here just to get an open file to pass to
4083 * vfs_test_lock. (Arguably perhaps test_lock should be done with an
4086 static int nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4091 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4094 err = vfs_test_lock(file, lock);
4103 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4104 struct nfsd4_lockt *lockt)
4106 struct inode *inode;
4107 struct file_lock file_lock;
4108 struct nfs4_lockowner *lo;
4112 if (locks_in_grace())
4113 return nfserr_grace;
4115 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4116 return nfserr_inval;
4120 status = nfserr_stale_clientid;
4121 if (!nfsd4_has_session(cstate) && STALE_CLIENTID(&lockt->lt_clientid))
4124 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
4127 inode = cstate->current_fh.fh_dentry->d_inode;
4128 locks_init_lock(&file_lock);
4129 switch (lockt->lt_type) {
4132 file_lock.fl_type = F_RDLCK;
4135 case NFS4_WRITEW_LT:
4136 file_lock.fl_type = F_WRLCK;
4139 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
4140 status = nfserr_inval;
4144 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner);
4146 file_lock.fl_owner = (fl_owner_t)lo;
4147 file_lock.fl_pid = current->tgid;
4148 file_lock.fl_flags = FL_POSIX;
4150 file_lock.fl_start = lockt->lt_offset;
4151 file_lock.fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
4153 nfs4_transform_lock_offset(&file_lock);
4156 error = nfsd_test_lock(rqstp, &cstate->current_fh, &file_lock);
4158 status = nfserrno(error);
4161 if (file_lock.fl_type != F_UNLCK) {
4162 status = nfserr_denied;
4163 nfs4_set_lock_denied(&file_lock, &lockt->lt_denied);
4166 nfs4_unlock_state();
4171 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4172 struct nfsd4_locku *locku)
4174 struct nfs4_stateid *stp;
4175 struct file *filp = NULL;
4176 struct file_lock file_lock;
4180 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4181 (long long) locku->lu_offset,
4182 (long long) locku->lu_length);
4184 if (check_lock_length(locku->lu_offset, locku->lu_length))
4185 return nfserr_inval;
4189 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
4190 &locku->lu_stateid, LOCK_STATE, &stp);
4193 filp = find_any_file(stp->st_file);
4195 status = nfserr_lock_range;
4199 locks_init_lock(&file_lock);
4200 file_lock.fl_type = F_UNLCK;
4201 file_lock.fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
4202 file_lock.fl_pid = current->tgid;
4203 file_lock.fl_file = filp;
4204 file_lock.fl_flags = FL_POSIX;
4205 file_lock.fl_lmops = &nfsd_posix_mng_ops;
4206 file_lock.fl_start = locku->lu_offset;
4208 file_lock.fl_end = last_byte_offset(locku->lu_offset, locku->lu_length);
4209 nfs4_transform_lock_offset(&file_lock);
4212 * Try to unlock the file in the VFS.
4214 err = vfs_lock_file(filp, F_SETLK, &file_lock, NULL);
4216 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
4220 * OK, unlock succeeded; the only thing left to do is update the stateid.
4222 update_stateid(&stp->st_stateid);
4223 memcpy(&locku->lu_stateid, &stp->st_stateid, sizeof(stateid_t));
4226 nfs4_unlock_state();
4230 status = nfserrno(err);
4236 * 1: locks held by lockowner
4237 * 0: no locks held by lockowner
4240 check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
4242 struct file_lock **flpp;
4243 struct inode *inode = filp->fi_inode;
4247 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
4248 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
4259 nfsd4_release_lockowner(struct svc_rqst *rqstp,
4260 struct nfsd4_compound_state *cstate,
4261 struct nfsd4_release_lockowner *rlockowner)
4263 clientid_t *clid = &rlockowner->rl_clientid;
4264 struct nfs4_stateowner *sop;
4265 struct nfs4_lockowner *lo;
4266 struct nfs4_stateid *stp;
4267 struct xdr_netobj *owner = &rlockowner->rl_owner;
4268 struct list_head matches;
4272 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4273 clid->cl_boot, clid->cl_id);
4275 /* XXX check for lease expiration */
4277 status = nfserr_stale_clientid;
4278 if (STALE_CLIENTID(clid))
4283 status = nfserr_locks_held;
4284 /* XXX: we're doing a linear search through all the lockowners.
4285 * Yipes! For now we'll just hope clients aren't really using
4286 * release_lockowner much, but eventually we have to fix these
4287 * data structures. */
4288 INIT_LIST_HEAD(&matches);
4289 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4290 list_for_each_entry(sop, &lock_ownerid_hashtbl[i], so_idhash) {
4291 if (!same_owner_str(sop, owner, clid))
4293 list_for_each_entry(stp, &sop->so_stateids,
4295 lo = lockowner(sop);
4296 if (check_for_locks(stp->st_file, lo))
4298 list_add(&lo->lo_list, &matches);
4302 /* Clients probably won't expect us to return with some (but not all)
4303 * of the lockowner state released; so don't release any until all
4304 * have been checked. */
4306 while (!list_empty(&matches)) {
4307 lo = list_entry(matches.next, struct nfs4_lockowner,
4309 /* unhash_stateowner deletes so_perclient only
4310 * for openowners. */
4311 list_del(&lo->lo_list);
4312 release_lockowner(lo);
4315 nfs4_unlock_state();
4319 static inline struct nfs4_client_reclaim *
4322 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
4326 nfs4_has_reclaimed_state(const char *name, bool use_exchange_id)
4328 unsigned int strhashval = clientstr_hashval(name);
4329 struct nfs4_client *clp;
4331 clp = find_confirmed_client_by_str(name, strhashval);
4336 * failure => all reset bets are off, nfserr_no_grace...
4339 nfs4_client_to_reclaim(const char *name)
4341 unsigned int strhashval;
4342 struct nfs4_client_reclaim *crp = NULL;
4344 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4345 crp = alloc_reclaim();
4348 strhashval = clientstr_hashval(name);
4349 INIT_LIST_HEAD(&crp->cr_strhash);
4350 list_add(&crp->cr_strhash, &reclaim_str_hashtbl[strhashval]);
4351 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
4352 reclaim_str_hashtbl_size++;
4357 nfs4_release_reclaim(void)
4359 struct nfs4_client_reclaim *crp = NULL;
4362 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4363 while (!list_empty(&reclaim_str_hashtbl[i])) {
4364 crp = list_entry(reclaim_str_hashtbl[i].next,
4365 struct nfs4_client_reclaim, cr_strhash);
4366 list_del(&crp->cr_strhash);
4368 reclaim_str_hashtbl_size--;
4371 BUG_ON(reclaim_str_hashtbl_size);
4375 * called from OPEN, CLAIM_PREVIOUS with a new clientid. */
4376 static struct nfs4_client_reclaim *
4377 nfs4_find_reclaim_client(clientid_t *clid)
4379 unsigned int strhashval;
4380 struct nfs4_client *clp;
4381 struct nfs4_client_reclaim *crp = NULL;
4384 /* find clientid in conf_id_hashtbl */
4385 clp = find_confirmed_client(clid);
4389 dprintk("NFSD: nfs4_find_reclaim_client for %.*s with recdir %s\n",
4390 clp->cl_name.len, clp->cl_name.data,
4393 /* find clp->cl_name in reclaim_str_hashtbl */
4394 strhashval = clientstr_hashval(clp->cl_recdir);
4395 list_for_each_entry(crp, &reclaim_str_hashtbl[strhashval], cr_strhash) {
4396 if (same_name(crp->cr_recdir, clp->cl_recdir)) {
4404 * Called from OPEN. Look for clientid in reclaim list.
4407 nfs4_check_open_reclaim(clientid_t *clid)
4409 return nfs4_find_reclaim_client(clid) ? nfs_ok : nfserr_reclaim_bad;
4412 /* initialization to perform at module load time: */
4415 nfs4_state_init(void)
4419 status = nfsd4_init_slabs();
4422 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4423 INIT_LIST_HEAD(&conf_id_hashtbl[i]);
4424 INIT_LIST_HEAD(&conf_str_hashtbl[i]);
4425 INIT_LIST_HEAD(&unconf_str_hashtbl[i]);
4426 INIT_LIST_HEAD(&unconf_id_hashtbl[i]);
4427 INIT_LIST_HEAD(&reclaim_str_hashtbl[i]);
4429 for (i = 0; i < SESSION_HASH_SIZE; i++)
4430 INIT_LIST_HEAD(&sessionid_hashtbl[i]);
4431 for (i = 0; i < FILE_HASH_SIZE; i++) {
4432 INIT_LIST_HEAD(&file_hashtbl[i]);
4434 for (i = 0; i < OPEN_OWNER_HASH_SIZE; i++) {
4435 INIT_LIST_HEAD(&open_ownerstr_hashtbl[i]);
4436 INIT_LIST_HEAD(&open_ownerid_hashtbl[i]);
4438 for (i = 0; i < STATEID_HASH_SIZE; i++)
4439 INIT_LIST_HEAD(&stateid_hashtbl[i]);
4440 for (i = 0; i < LOCK_HASH_SIZE; i++) {
4441 INIT_LIST_HEAD(&lock_ownerid_hashtbl[i]);
4442 INIT_LIST_HEAD(&lock_ownerstr_hashtbl[i]);
4444 memset(&onestateid, ~0, sizeof(stateid_t));
4445 INIT_LIST_HEAD(&close_lru);
4446 INIT_LIST_HEAD(&client_lru);
4447 INIT_LIST_HEAD(&del_recall_lru);
4448 reclaim_str_hashtbl_size = 0;
4453 nfsd4_load_reboot_recovery_data(void)
4458 nfsd4_init_recdir();
4459 status = nfsd4_recdir_load();
4460 nfs4_unlock_state();
4462 printk("NFSD: Failure reading reboot recovery data\n");
4466 * Since the lifetime of a delegation isn't limited to that of an open, a
4467 * client may quite reasonably hang on to a delegation as long as it has
4468 * the inode cached. This becomes an obvious problem the first time a
4469 * client's inode cache approaches the size of the server's total memory.
4471 * For now we avoid this problem by imposing a hard limit on the number
4472 * of delegations, which varies according to the server's memory size.
4475 set_max_delegations(void)
4478 * Allow at most 4 delegations per megabyte of RAM. Quick
4479 * estimates suggest that in the worst case (where every delegation
4480 * is for a different inode), a delegation could take about 1.5K,
4481 * giving a worst case usage of about 6% of memory.
4483 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4486 /* initialization to perform when the nfsd service is started: */
4489 __nfs4_state_start(void)
4493 boot_time = get_seconds();
4494 locks_start_grace(&nfsd4_manager);
4495 printk(KERN_INFO "NFSD: starting %ld-second grace period\n",
4497 ret = set_callback_cred();
4500 laundry_wq = create_singlethread_workqueue("nfsd4");
4501 if (laundry_wq == NULL)
4503 ret = nfsd4_create_callback_queue();
4505 goto out_free_laundry;
4506 queue_delayed_work(laundry_wq, &laundromat_work, nfsd4_grace * HZ);
4507 set_max_delegations();
4510 destroy_workqueue(laundry_wq);
4515 nfs4_state_start(void)
4517 nfsd4_load_reboot_recovery_data();
4518 return __nfs4_state_start();
4522 __nfs4_state_shutdown(void)
4525 struct nfs4_client *clp = NULL;
4526 struct nfs4_delegation *dp = NULL;
4527 struct list_head *pos, *next, reaplist;
4529 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4530 while (!list_empty(&conf_id_hashtbl[i])) {
4531 clp = list_entry(conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
4534 while (!list_empty(&unconf_str_hashtbl[i])) {
4535 clp = list_entry(unconf_str_hashtbl[i].next, struct nfs4_client, cl_strhash);
4539 INIT_LIST_HEAD(&reaplist);
4540 spin_lock(&recall_lock);
4541 list_for_each_safe(pos, next, &del_recall_lru) {
4542 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4543 list_move(&dp->dl_recall_lru, &reaplist);
4545 spin_unlock(&recall_lock);
4546 list_for_each_safe(pos, next, &reaplist) {
4547 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
4548 list_del_init(&dp->dl_recall_lru);
4549 unhash_delegation(dp);
4552 nfsd4_shutdown_recdir();
4556 nfs4_state_shutdown(void)
4558 cancel_delayed_work_sync(&laundromat_work);
4559 destroy_workqueue(laundry_wq);
4560 locks_end_grace(&nfsd4_manager);
4562 nfs4_release_reclaim();
4563 __nfs4_state_shutdown();
4564 nfs4_unlock_state();
4565 nfsd4_destroy_callback_queue();