1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35#include <linux/file.h>
36#include <linux/fs.h>
37#include <linux/slab.h>
38#include <linux/namei.h>
39#include <linux/swap.h>
40#include <linux/pagemap.h>
41#include <linux/ratelimit.h>
42#include <linux/sunrpc/svcauth_gss.h>
43#include <linux/sunrpc/addr.h>
44#include "xdr4.h"
45#include "xdr4cb.h"
46#include "vfs.h"
47#include "current_stateid.h"
48
49#include "netns.h"
50
51#define NFSDDBG_FACILITY NFSDDBG_PROC
52
53#define all_ones {{~0,~0},~0}
54static const stateid_t one_stateid = {
55 .si_generation = ~0,
56 .si_opaque = all_ones,
57};
58static const stateid_t zero_stateid = {
59
60};
61static const stateid_t currentstateid = {
62 .si_generation = 1,
63};
64
65static u64 current_sessionid = 1;
66
67#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
68#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
69#define CURRENT_STATEID(stateid) (!memcmp((stateid), ¤tstateid, sizeof(stateid_t)))
70
71
72static int check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner);
73
74
75
76
77static DEFINE_MUTEX(client_mutex);
78
79
80
81
82
83
84static DEFINE_SPINLOCK(recall_lock);
85
86static struct kmem_cache *openowner_slab = NULL;
87static struct kmem_cache *lockowner_slab = NULL;
88static struct kmem_cache *file_slab = NULL;
89static struct kmem_cache *stateid_slab = NULL;
90static struct kmem_cache *deleg_slab = NULL;
91
92void
93nfs4_lock_state(void)
94{
95 mutex_lock(&client_mutex);
96}
97
98static void free_session(struct nfsd4_session *);
99
100static bool is_session_dead(struct nfsd4_session *ses)
101{
102 return ses->se_flags & NFS4_SESSION_DEAD;
103}
104
105void nfsd4_put_session(struct nfsd4_session *ses)
106{
107 if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
108 free_session(ses);
109}
110
111static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
112{
113 if (atomic_read(&ses->se_ref) > ref_held_by_me)
114 return nfserr_jukebox;
115 ses->se_flags |= NFS4_SESSION_DEAD;
116 return nfs_ok;
117}
118
119static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
120{
121 if (is_session_dead(ses))
122 return nfserr_badsession;
123 atomic_inc(&ses->se_ref);
124 return nfs_ok;
125}
126
127void
128nfs4_unlock_state(void)
129{
130 mutex_unlock(&client_mutex);
131}
132
133static bool is_client_expired(struct nfs4_client *clp)
134{
135 return clp->cl_time == 0;
136}
137
138static __be32 mark_client_expired_locked(struct nfs4_client *clp)
139{
140 if (atomic_read(&clp->cl_refcount))
141 return nfserr_jukebox;
142 clp->cl_time = 0;
143 return nfs_ok;
144}
145
146static __be32 mark_client_expired(struct nfs4_client *clp)
147{
148 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
149 __be32 ret;
150
151 spin_lock(&nn->client_lock);
152 ret = mark_client_expired_locked(clp);
153 spin_unlock(&nn->client_lock);
154 return ret;
155}
156
157static __be32 get_client_locked(struct nfs4_client *clp)
158{
159 if (is_client_expired(clp))
160 return nfserr_expired;
161 atomic_inc(&clp->cl_refcount);
162 return nfs_ok;
163}
164
165
166static inline void
167renew_client_locked(struct nfs4_client *clp)
168{
169 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
170
171 if (is_client_expired(clp)) {
172 WARN_ON(1);
173 printk("%s: client (clientid %08x/%08x) already expired\n",
174 __func__,
175 clp->cl_clientid.cl_boot,
176 clp->cl_clientid.cl_id);
177 return;
178 }
179
180 dprintk("renewing client (clientid %08x/%08x)\n",
181 clp->cl_clientid.cl_boot,
182 clp->cl_clientid.cl_id);
183 list_move_tail(&clp->cl_lru, &nn->client_lru);
184 clp->cl_time = get_seconds();
185}
186
187static inline void
188renew_client(struct nfs4_client *clp)
189{
190 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
191
192 spin_lock(&nn->client_lock);
193 renew_client_locked(clp);
194 spin_unlock(&nn->client_lock);
195}
196
197static void put_client_renew_locked(struct nfs4_client *clp)
198{
199 if (!atomic_dec_and_test(&clp->cl_refcount))
200 return;
201 if (!is_client_expired(clp))
202 renew_client_locked(clp);
203}
204
205void put_client_renew(struct nfs4_client *clp)
206{
207 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
208
209 if (!atomic_dec_and_lock(&clp->cl_refcount, &nn->client_lock))
210 return;
211 if (!is_client_expired(clp))
212 renew_client_locked(clp);
213 spin_unlock(&nn->client_lock);
214}
215
216
217static inline u32
218opaque_hashval(const void *ptr, int nbytes)
219{
220 unsigned char *cptr = (unsigned char *) ptr;
221
222 u32 x = 0;
223 while (nbytes--) {
224 x *= 37;
225 x += *cptr++;
226 }
227 return x;
228}
229
230static void nfsd4_free_file(struct nfs4_file *f)
231{
232 kmem_cache_free(file_slab, f);
233}
234
235static inline void
236put_nfs4_file(struct nfs4_file *fi)
237{
238 if (atomic_dec_and_lock(&fi->fi_ref, &recall_lock)) {
239 hlist_del(&fi->fi_hash);
240 spin_unlock(&recall_lock);
241 iput(fi->fi_inode);
242 nfsd4_free_file(fi);
243 }
244}
245
246static inline void
247get_nfs4_file(struct nfs4_file *fi)
248{
249 atomic_inc(&fi->fi_ref);
250}
251
252static int num_delegations;
253unsigned long max_delegations;
254
255
256
257
258
259
260#define OWNER_HASH_BITS 8
261#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
262#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
263
264static unsigned int ownerstr_hashval(u32 clientid, struct xdr_netobj *ownername)
265{
266 unsigned int ret;
267
268 ret = opaque_hashval(ownername->data, ownername->len);
269 ret += clientid;
270 return ret & OWNER_HASH_MASK;
271}
272
273
274#define FILE_HASH_BITS 8
275#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
276
277static unsigned int file_hashval(struct inode *ino)
278{
279
280 return hash_ptr(ino, FILE_HASH_BITS);
281}
282
283static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
284
285static void __nfs4_file_get_access(struct nfs4_file *fp, int oflag)
286{
287 WARN_ON_ONCE(!(fp->fi_fds[oflag] || fp->fi_fds[O_RDWR]));
288 atomic_inc(&fp->fi_access[oflag]);
289}
290
291static void nfs4_file_get_access(struct nfs4_file *fp, int oflag)
292{
293 if (oflag == O_RDWR) {
294 __nfs4_file_get_access(fp, O_RDONLY);
295 __nfs4_file_get_access(fp, O_WRONLY);
296 } else
297 __nfs4_file_get_access(fp, oflag);
298}
299
300static void nfs4_file_put_fd(struct nfs4_file *fp, int oflag)
301{
302 if (fp->fi_fds[oflag]) {
303 fput(fp->fi_fds[oflag]);
304 fp->fi_fds[oflag] = NULL;
305 }
306}
307
308static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
309{
310 if (atomic_dec_and_test(&fp->fi_access[oflag])) {
311 nfs4_file_put_fd(fp, oflag);
312 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
313 nfs4_file_put_fd(fp, O_RDWR);
314 }
315}
316
317static void nfs4_file_put_access(struct nfs4_file *fp, int oflag)
318{
319 if (oflag == O_RDWR) {
320 __nfs4_file_put_access(fp, O_RDONLY);
321 __nfs4_file_put_access(fp, O_WRONLY);
322 } else
323 __nfs4_file_put_access(fp, oflag);
324}
325
326static struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct
327kmem_cache *slab)
328{
329 struct idr *stateids = &cl->cl_stateids;
330 struct nfs4_stid *stid;
331 int new_id;
332
333 stid = kmem_cache_alloc(slab, GFP_KERNEL);
334 if (!stid)
335 return NULL;
336
337 new_id = idr_alloc_cyclic(stateids, stid, 0, 0, GFP_KERNEL);
338 if (new_id < 0)
339 goto out_free;
340 stid->sc_client = cl;
341 stid->sc_type = 0;
342 stid->sc_stateid.si_opaque.so_id = new_id;
343 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
344
345 stid->sc_stateid.si_generation = 0;
346
347
348
349
350
351
352
353
354
355
356 return stid;
357out_free:
358 kmem_cache_free(slab, stid);
359 return NULL;
360}
361
362static struct nfs4_ol_stateid * nfs4_alloc_stateid(struct nfs4_client *clp)
363{
364 return openlockstateid(nfs4_alloc_stid(clp, stateid_slab));
365}
366
367static struct nfs4_delegation *
368alloc_init_deleg(struct nfs4_client *clp, struct nfs4_ol_stateid *stp, struct svc_fh *current_fh)
369{
370 struct nfs4_delegation *dp;
371 struct nfs4_file *fp = stp->st_file;
372
373 dprintk("NFSD alloc_init_deleg\n");
374 if (fp->fi_had_conflict)
375 return NULL;
376 if (num_delegations > max_delegations)
377 return NULL;
378 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab));
379 if (dp == NULL)
380 return dp;
381 dp->dl_stid.sc_type = NFS4_DELEG_STID;
382
383
384
385
386
387 dp->dl_stid.sc_stateid.si_generation = 1;
388 num_delegations++;
389 INIT_LIST_HEAD(&dp->dl_perfile);
390 INIT_LIST_HEAD(&dp->dl_perclnt);
391 INIT_LIST_HEAD(&dp->dl_recall_lru);
392 get_nfs4_file(fp);
393 dp->dl_file = fp;
394 dp->dl_type = NFS4_OPEN_DELEGATE_READ;
395 fh_copy_shallow(&dp->dl_fh, ¤t_fh->fh_handle);
396 dp->dl_time = 0;
397 atomic_set(&dp->dl_count, 1);
398 nfsd4_init_callback(&dp->dl_recall);
399 return dp;
400}
401
402static void remove_stid(struct nfs4_stid *s)
403{
404 struct idr *stateids = &s->sc_client->cl_stateids;
405
406 idr_remove(stateids, s->sc_stateid.si_opaque.so_id);
407}
408
409void
410nfs4_put_delegation(struct nfs4_delegation *dp)
411{
412 if (atomic_dec_and_test(&dp->dl_count)) {
413 kmem_cache_free(deleg_slab, dp);
414 num_delegations--;
415 }
416}
417
418static void nfs4_put_deleg_lease(struct nfs4_file *fp)
419{
420 if (atomic_dec_and_test(&fp->fi_delegees)) {
421 vfs_setlease(fp->fi_deleg_file, F_UNLCK, &fp->fi_lease);
422 fp->fi_lease = NULL;
423 fput(fp->fi_deleg_file);
424 fp->fi_deleg_file = NULL;
425 }
426}
427
428static void unhash_stid(struct nfs4_stid *s)
429{
430 s->sc_type = 0;
431}
432
433
434static void
435unhash_delegation(struct nfs4_delegation *dp)
436{
437 list_del_init(&dp->dl_perclnt);
438 spin_lock(&recall_lock);
439 list_del_init(&dp->dl_perfile);
440 list_del_init(&dp->dl_recall_lru);
441 spin_unlock(&recall_lock);
442 nfs4_put_deleg_lease(dp->dl_file);
443 put_nfs4_file(dp->dl_file);
444 dp->dl_file = NULL;
445}
446
447
448
449static void destroy_revoked_delegation(struct nfs4_delegation *dp)
450{
451 list_del_init(&dp->dl_recall_lru);
452 remove_stid(&dp->dl_stid);
453 nfs4_put_delegation(dp);
454}
455
456static void destroy_delegation(struct nfs4_delegation *dp)
457{
458 unhash_delegation(dp);
459 remove_stid(&dp->dl_stid);
460 nfs4_put_delegation(dp);
461}
462
463static void revoke_delegation(struct nfs4_delegation *dp)
464{
465 struct nfs4_client *clp = dp->dl_stid.sc_client;
466
467 if (clp->cl_minorversion == 0)
468 destroy_delegation(dp);
469 else {
470 unhash_delegation(dp);
471 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
472 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
473 }
474}
475
476
477
478
479
480static unsigned int clientid_hashval(u32 id)
481{
482 return id & CLIENT_HASH_MASK;
483}
484
485static unsigned int clientstr_hashval(const char *name)
486{
487 return opaque_hashval(name, 8) & CLIENT_HASH_MASK;
488}
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508static unsigned int
509bmap_to_share_mode(unsigned long bmap) {
510 int i;
511 unsigned int access = 0;
512
513 for (i = 1; i < 4; i++) {
514 if (test_bit(i, &bmap))
515 access |= i;
516 }
517 return access;
518}
519
520static bool
521test_share(struct nfs4_ol_stateid *stp, struct nfsd4_open *open) {
522 unsigned int access, deny;
523
524 access = bmap_to_share_mode(stp->st_access_bmap);
525 deny = bmap_to_share_mode(stp->st_deny_bmap);
526 if ((access & open->op_share_deny) || (deny & open->op_share_access))
527 return false;
528 return true;
529}
530
531
532static inline void
533set_access(u32 access, struct nfs4_ol_stateid *stp)
534{
535 __set_bit(access, &stp->st_access_bmap);
536}
537
538
539static inline void
540clear_access(u32 access, struct nfs4_ol_stateid *stp)
541{
542 __clear_bit(access, &stp->st_access_bmap);
543}
544
545
546static inline bool
547test_access(u32 access, struct nfs4_ol_stateid *stp)
548{
549 return test_bit(access, &stp->st_access_bmap);
550}
551
552
553static inline void
554set_deny(u32 access, struct nfs4_ol_stateid *stp)
555{
556 __set_bit(access, &stp->st_deny_bmap);
557}
558
559
560static inline void
561clear_deny(u32 access, struct nfs4_ol_stateid *stp)
562{
563 __clear_bit(access, &stp->st_deny_bmap);
564}
565
566
567static inline bool
568test_deny(u32 access, struct nfs4_ol_stateid *stp)
569{
570 return test_bit(access, &stp->st_deny_bmap);
571}
572
573static int nfs4_access_to_omode(u32 access)
574{
575 switch (access & NFS4_SHARE_ACCESS_BOTH) {
576 case NFS4_SHARE_ACCESS_READ:
577 return O_RDONLY;
578 case NFS4_SHARE_ACCESS_WRITE:
579 return O_WRONLY;
580 case NFS4_SHARE_ACCESS_BOTH:
581 return O_RDWR;
582 }
583 WARN_ON_ONCE(1);
584 return O_RDONLY;
585}
586
587
588static void
589release_all_access(struct nfs4_ol_stateid *stp)
590{
591 int i;
592
593 for (i = 1; i < 4; i++) {
594 if (test_access(i, stp))
595 nfs4_file_put_access(stp->st_file,
596 nfs4_access_to_omode(i));
597 clear_access(i, stp);
598 }
599}
600
601static void unhash_generic_stateid(struct nfs4_ol_stateid *stp)
602{
603 list_del(&stp->st_perfile);
604 list_del(&stp->st_perstateowner);
605}
606
607static void close_generic_stateid(struct nfs4_ol_stateid *stp)
608{
609 release_all_access(stp);
610 put_nfs4_file(stp->st_file);
611 stp->st_file = NULL;
612}
613
614static void free_generic_stateid(struct nfs4_ol_stateid *stp)
615{
616 remove_stid(&stp->st_stid);
617 kmem_cache_free(stateid_slab, stp);
618}
619
620static void release_lock_stateid(struct nfs4_ol_stateid *stp)
621{
622 struct file *file;
623
624 unhash_generic_stateid(stp);
625 unhash_stid(&stp->st_stid);
626 file = find_any_file(stp->st_file);
627 if (file)
628 locks_remove_posix(file, (fl_owner_t)lockowner(stp->st_stateowner));
629 close_generic_stateid(stp);
630 free_generic_stateid(stp);
631}
632
633static void unhash_lockowner(struct nfs4_lockowner *lo)
634{
635 struct nfs4_ol_stateid *stp;
636
637 list_del(&lo->lo_owner.so_strhash);
638 list_del(&lo->lo_perstateid);
639 list_del(&lo->lo_owner_ino_hash);
640 while (!list_empty(&lo->lo_owner.so_stateids)) {
641 stp = list_first_entry(&lo->lo_owner.so_stateids,
642 struct nfs4_ol_stateid, st_perstateowner);
643 release_lock_stateid(stp);
644 }
645}
646
647static void release_lockowner(struct nfs4_lockowner *lo)
648{
649 unhash_lockowner(lo);
650 nfs4_free_lockowner(lo);
651}
652
653static void
654release_stateid_lockowners(struct nfs4_ol_stateid *open_stp)
655{
656 struct nfs4_lockowner *lo;
657
658 while (!list_empty(&open_stp->st_lockowners)) {
659 lo = list_entry(open_stp->st_lockowners.next,
660 struct nfs4_lockowner, lo_perstateid);
661 release_lockowner(lo);
662 }
663}
664
665static void unhash_open_stateid(struct nfs4_ol_stateid *stp)
666{
667 unhash_generic_stateid(stp);
668 release_stateid_lockowners(stp);
669 close_generic_stateid(stp);
670}
671
672static void release_open_stateid(struct nfs4_ol_stateid *stp)
673{
674 unhash_open_stateid(stp);
675 unhash_stid(&stp->st_stid);
676 free_generic_stateid(stp);
677}
678
679static void unhash_openowner(struct nfs4_openowner *oo)
680{
681 struct nfs4_ol_stateid *stp;
682
683 list_del(&oo->oo_owner.so_strhash);
684 list_del(&oo->oo_perclient);
685 while (!list_empty(&oo->oo_owner.so_stateids)) {
686 stp = list_first_entry(&oo->oo_owner.so_stateids,
687 struct nfs4_ol_stateid, st_perstateowner);
688 release_open_stateid(stp);
689 }
690}
691
692static void release_last_closed_stateid(struct nfs4_openowner *oo)
693{
694 struct nfs4_ol_stateid *s = oo->oo_last_closed_stid;
695
696 if (s) {
697 unhash_stid(&s->st_stid);
698 free_generic_stateid(s);
699 oo->oo_last_closed_stid = NULL;
700 }
701}
702
703static void release_openowner(struct nfs4_openowner *oo)
704{
705 unhash_openowner(oo);
706 list_del(&oo->oo_close_lru);
707 release_last_closed_stateid(oo);
708 nfs4_free_openowner(oo);
709}
710
711static inline int
712hash_sessionid(struct nfs4_sessionid *sessionid)
713{
714 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
715
716 return sid->sequence % SESSION_HASH_SIZE;
717}
718
719#ifdef NFSD_DEBUG
720static inline void
721dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
722{
723 u32 *ptr = (u32 *)(&sessionid->data[0]);
724 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
725}
726#else
727static inline void
728dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
729{
730}
731#endif
732
733
734
735
736
737void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
738{
739 struct nfs4_stateowner *so = cstate->replay_owner;
740
741 if (nfserr == nfserr_replay_me)
742 return;
743
744 if (!seqid_mutating_err(ntohl(nfserr))) {
745 cstate->replay_owner = NULL;
746 return;
747 }
748 if (!so)
749 return;
750 if (so->so_is_open_owner)
751 release_last_closed_stateid(openowner(so));
752 so->so_seqid++;
753 return;
754}
755
756static void
757gen_sessionid(struct nfsd4_session *ses)
758{
759 struct nfs4_client *clp = ses->se_client;
760 struct nfsd4_sessionid *sid;
761
762 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
763 sid->clientid = clp->cl_clientid;
764 sid->sequence = current_sessionid++;
765 sid->reserved = 0;
766}
767
768
769
770
771
772
773
774
775
776
777
778
779
780#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
781
782static void
783free_session_slots(struct nfsd4_session *ses)
784{
785 int i;
786
787 for (i = 0; i < ses->se_fchannel.maxreqs; i++)
788 kfree(ses->se_slots[i]);
789}
790
791
792
793
794
795static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
796{
797 u32 size;
798
799 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
800 size = 0;
801 else
802 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
803 return size + sizeof(struct nfsd4_slot);
804}
805
806
807
808
809
810
811static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca)
812{
813 u32 slotsize = slot_bytes(ca);
814 u32 num = ca->maxreqs;
815 int avail;
816
817 spin_lock(&nfsd_drc_lock);
818 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION,
819 nfsd_drc_max_mem - nfsd_drc_mem_used);
820 num = min_t(int, num, avail / slotsize);
821 nfsd_drc_mem_used += num * slotsize;
822 spin_unlock(&nfsd_drc_lock);
823
824 return num;
825}
826
827static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
828{
829 int slotsize = slot_bytes(ca);
830
831 spin_lock(&nfsd_drc_lock);
832 nfsd_drc_mem_used -= slotsize * ca->maxreqs;
833 spin_unlock(&nfsd_drc_lock);
834}
835
836static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *attrs)
837{
838 int numslots = attrs->maxreqs;
839 int slotsize = slot_bytes(attrs);
840 struct nfsd4_session *new;
841 int mem, i;
842
843 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
844 + sizeof(struct nfsd4_session) > PAGE_SIZE);
845 mem = numslots * sizeof(struct nfsd4_slot *);
846
847 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
848 if (!new)
849 return NULL;
850
851 for (i = 0; i < numslots; i++) {
852 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
853 if (!new->se_slots[i])
854 goto out_free;
855 }
856 return new;
857out_free:
858 while (i--)
859 kfree(new->se_slots[i]);
860 kfree(new);
861 return NULL;
862}
863
864static void free_conn(struct nfsd4_conn *c)
865{
866 svc_xprt_put(c->cn_xprt);
867 kfree(c);
868}
869
870static void nfsd4_conn_lost(struct svc_xpt_user *u)
871{
872 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
873 struct nfs4_client *clp = c->cn_session->se_client;
874
875 spin_lock(&clp->cl_lock);
876 if (!list_empty(&c->cn_persession)) {
877 list_del(&c->cn_persession);
878 free_conn(c);
879 }
880 nfsd4_probe_callback(clp);
881 spin_unlock(&clp->cl_lock);
882}
883
884static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
885{
886 struct nfsd4_conn *conn;
887
888 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
889 if (!conn)
890 return NULL;
891 svc_xprt_get(rqstp->rq_xprt);
892 conn->cn_xprt = rqstp->rq_xprt;
893 conn->cn_flags = flags;
894 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
895 return conn;
896}
897
898static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
899{
900 conn->cn_session = ses;
901 list_add(&conn->cn_persession, &ses->se_conns);
902}
903
904static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
905{
906 struct nfs4_client *clp = ses->se_client;
907
908 spin_lock(&clp->cl_lock);
909 __nfsd4_hash_conn(conn, ses);
910 spin_unlock(&clp->cl_lock);
911}
912
913static int nfsd4_register_conn(struct nfsd4_conn *conn)
914{
915 conn->cn_xpt_user.callback = nfsd4_conn_lost;
916 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
917}
918
919static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
920{
921 int ret;
922
923 nfsd4_hash_conn(conn, ses);
924 ret = nfsd4_register_conn(conn);
925 if (ret)
926
927 nfsd4_conn_lost(&conn->cn_xpt_user);
928 if (conn->cn_flags & NFS4_CDFC4_BACK) {
929
930 nfsd4_probe_callback(ses->se_client);
931 }
932}
933
934static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
935{
936 u32 dir = NFS4_CDFC4_FORE;
937
938 if (cses->flags & SESSION4_BACK_CHAN)
939 dir |= NFS4_CDFC4_BACK;
940 return alloc_conn(rqstp, dir);
941}
942
943
944static void nfsd4_del_conns(struct nfsd4_session *s)
945{
946 struct nfs4_client *clp = s->se_client;
947 struct nfsd4_conn *c;
948
949 spin_lock(&clp->cl_lock);
950 while (!list_empty(&s->se_conns)) {
951 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
952 list_del_init(&c->cn_persession);
953 spin_unlock(&clp->cl_lock);
954
955 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
956 free_conn(c);
957
958 spin_lock(&clp->cl_lock);
959 }
960 spin_unlock(&clp->cl_lock);
961}
962
963static void __free_session(struct nfsd4_session *ses)
964{
965 free_session_slots(ses);
966 kfree(ses);
967}
968
969static void free_session(struct nfsd4_session *ses)
970{
971 struct nfsd_net *nn = net_generic(ses->se_client->net, nfsd_net_id);
972
973 lockdep_assert_held(&nn->client_lock);
974 nfsd4_del_conns(ses);
975 nfsd4_put_drc_mem(&ses->se_fchannel);
976 __free_session(ses);
977}
978
979static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
980{
981 int idx;
982 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
983
984 new->se_client = clp;
985 gen_sessionid(new);
986
987 INIT_LIST_HEAD(&new->se_conns);
988
989 new->se_cb_seq_nr = 1;
990 new->se_flags = cses->flags;
991 new->se_cb_prog = cses->callback_prog;
992 new->se_cb_sec = cses->cb_sec;
993 atomic_set(&new->se_ref, 0);
994 idx = hash_sessionid(&new->se_sessionid);
995 spin_lock(&nn->client_lock);
996 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
997 spin_lock(&clp->cl_lock);
998 list_add(&new->se_perclnt, &clp->cl_sessions);
999 spin_unlock(&clp->cl_lock);
1000 spin_unlock(&nn->client_lock);
1001 memcpy(&new->se_fchannel, &cses->fore_channel,
1002 sizeof(struct nfsd4_channel_attrs));
1003 if (cses->flags & SESSION4_BACK_CHAN) {
1004 struct sockaddr *sa = svc_addr(rqstp);
1005
1006
1007
1008
1009
1010
1011
1012 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1013 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1014 }
1015}
1016
1017
1018static struct nfsd4_session *
1019find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
1020{
1021 struct nfsd4_session *elem;
1022 int idx;
1023 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1024
1025 dump_sessionid(__func__, sessionid);
1026 idx = hash_sessionid(sessionid);
1027
1028 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
1029 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1030 NFS4_MAX_SESSIONID_LEN)) {
1031 return elem;
1032 }
1033 }
1034
1035 dprintk("%s: session not found\n", __func__);
1036 return NULL;
1037}
1038
1039
1040static void
1041unhash_session(struct nfsd4_session *ses)
1042{
1043 list_del(&ses->se_hash);
1044 spin_lock(&ses->se_client->cl_lock);
1045 list_del(&ses->se_perclnt);
1046 spin_unlock(&ses->se_client->cl_lock);
1047}
1048
1049
1050static int
1051STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
1052{
1053 if (clid->cl_boot == nn->boot_time)
1054 return 0;
1055 dprintk("NFSD stale clientid (%08x/%08x) boot_time %08lx\n",
1056 clid->cl_boot, clid->cl_id, nn->boot_time);
1057 return 1;
1058}
1059
1060
1061
1062
1063
1064
1065static struct nfs4_client *alloc_client(struct xdr_netobj name)
1066{
1067 struct nfs4_client *clp;
1068
1069 clp = kzalloc(sizeof(struct nfs4_client), GFP_KERNEL);
1070 if (clp == NULL)
1071 return NULL;
1072 clp->cl_name.data = kmemdup(name.data, name.len, GFP_KERNEL);
1073 if (clp->cl_name.data == NULL) {
1074 kfree(clp);
1075 return NULL;
1076 }
1077 clp->cl_name.len = name.len;
1078 return clp;
1079}
1080
1081static inline void
1082free_client(struct nfs4_client *clp)
1083{
1084 struct nfsd_net __maybe_unused *nn = net_generic(clp->net, nfsd_net_id);
1085
1086 lockdep_assert_held(&nn->client_lock);
1087 while (!list_empty(&clp->cl_sessions)) {
1088 struct nfsd4_session *ses;
1089 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
1090 se_perclnt);
1091 list_del(&ses->se_perclnt);
1092 WARN_ON_ONCE(atomic_read(&ses->se_ref));
1093 free_session(ses);
1094 }
1095 free_svc_cred(&clp->cl_cred);
1096 kfree(clp->cl_name.data);
1097 idr_destroy(&clp->cl_stateids);
1098 kfree(clp);
1099}
1100
1101
1102static inline void
1103unhash_client_locked(struct nfs4_client *clp)
1104{
1105 struct nfsd4_session *ses;
1106
1107 list_del(&clp->cl_lru);
1108 spin_lock(&clp->cl_lock);
1109 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
1110 list_del_init(&ses->se_hash);
1111 spin_unlock(&clp->cl_lock);
1112}
1113
1114static void
1115destroy_client(struct nfs4_client *clp)
1116{
1117 struct nfs4_openowner *oo;
1118 struct nfs4_delegation *dp;
1119 struct list_head reaplist;
1120 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1121
1122 INIT_LIST_HEAD(&reaplist);
1123 spin_lock(&recall_lock);
1124 while (!list_empty(&clp->cl_delegations)) {
1125 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
1126 list_del_init(&dp->dl_perclnt);
1127 list_move(&dp->dl_recall_lru, &reaplist);
1128 }
1129 spin_unlock(&recall_lock);
1130 while (!list_empty(&reaplist)) {
1131 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
1132 destroy_delegation(dp);
1133 }
1134 while (!list_empty(&clp->cl_openowners)) {
1135 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
1136 release_openowner(oo);
1137 }
1138 nfsd4_shutdown_callback(clp);
1139 if (clp->cl_cb_conn.cb_xprt)
1140 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
1141 list_del(&clp->cl_idhash);
1142 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
1143 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
1144 else
1145 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1146 spin_lock(&nn->client_lock);
1147 unhash_client_locked(clp);
1148 WARN_ON_ONCE(atomic_read(&clp->cl_refcount));
1149 free_client(clp);
1150 spin_unlock(&nn->client_lock);
1151}
1152
1153static void expire_client(struct nfs4_client *clp)
1154{
1155 nfsd4_client_record_remove(clp);
1156 destroy_client(clp);
1157}
1158
1159static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
1160{
1161 memcpy(target->cl_verifier.data, source->data,
1162 sizeof(target->cl_verifier.data));
1163}
1164
1165static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
1166{
1167 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
1168 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
1169}
1170
1171static int copy_cred(struct svc_cred *target, struct svc_cred *source)
1172{
1173 if (source->cr_principal) {
1174 target->cr_principal =
1175 kstrdup(source->cr_principal, GFP_KERNEL);
1176 if (target->cr_principal == NULL)
1177 return -ENOMEM;
1178 } else
1179 target->cr_principal = NULL;
1180 target->cr_flavor = source->cr_flavor;
1181 target->cr_uid = source->cr_uid;
1182 target->cr_gid = source->cr_gid;
1183 target->cr_group_info = source->cr_group_info;
1184 get_group_info(target->cr_group_info);
1185 target->cr_gss_mech = source->cr_gss_mech;
1186 if (source->cr_gss_mech)
1187 gss_mech_get(source->cr_gss_mech);
1188 return 0;
1189}
1190
1191static long long
1192compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
1193{
1194 long long res;
1195
1196 res = o1->len - o2->len;
1197 if (res)
1198 return res;
1199 return (long long)memcmp(o1->data, o2->data, o1->len);
1200}
1201
1202static int same_name(const char *n1, const char *n2)
1203{
1204 return 0 == memcmp(n1, n2, HEXDIR_LEN);
1205}
1206
1207static int
1208same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
1209{
1210 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
1211}
1212
1213static int
1214same_clid(clientid_t *cl1, clientid_t *cl2)
1215{
1216 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
1217}
1218
1219static bool groups_equal(struct group_info *g1, struct group_info *g2)
1220{
1221 int i;
1222
1223 if (g1->ngroups != g2->ngroups)
1224 return false;
1225 for (i=0; i<g1->ngroups; i++)
1226 if (!gid_eq(GROUP_AT(g1, i), GROUP_AT(g2, i)))
1227 return false;
1228 return true;
1229}
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240static bool is_gss_cred(struct svc_cred *cr)
1241{
1242
1243 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
1244}
1245
1246
1247static bool
1248same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
1249{
1250 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
1251 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
1252 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
1253 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
1254 return false;
1255 if (cr1->cr_principal == cr2->cr_principal)
1256 return true;
1257 if (!cr1->cr_principal || !cr2->cr_principal)
1258 return false;
1259 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
1260}
1261
1262static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
1263{
1264 struct svc_cred *cr = &rqstp->rq_cred;
1265 u32 service;
1266
1267 if (!cr->cr_gss_mech)
1268 return false;
1269 service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
1270 return service == RPC_GSS_SVC_INTEGRITY ||
1271 service == RPC_GSS_SVC_PRIVACY;
1272}
1273
1274static bool mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
1275{
1276 struct svc_cred *cr = &rqstp->rq_cred;
1277
1278 if (!cl->cl_mach_cred)
1279 return true;
1280 if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
1281 return false;
1282 if (!svc_rqst_integrity_protected(rqstp))
1283 return false;
1284 if (!cr->cr_principal)
1285 return false;
1286 return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
1287}
1288
1289static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
1290{
1291 static u32 current_clientid = 1;
1292
1293 clp->cl_clientid.cl_boot = nn->boot_time;
1294 clp->cl_clientid.cl_id = current_clientid++;
1295}
1296
1297static void gen_confirm(struct nfs4_client *clp)
1298{
1299 __be32 verf[2];
1300 static u32 i;
1301
1302 verf[0] = (__be32)get_seconds();
1303 verf[1] = (__be32)i++;
1304 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
1305}
1306
1307static struct nfs4_stid *find_stateid(struct nfs4_client *cl, stateid_t *t)
1308{
1309 struct nfs4_stid *ret;
1310
1311 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
1312 if (!ret || !ret->sc_type)
1313 return NULL;
1314 return ret;
1315}
1316
1317static struct nfs4_stid *find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
1318{
1319 struct nfs4_stid *s;
1320
1321 s = find_stateid(cl, t);
1322 if (!s)
1323 return NULL;
1324 if (typemask & s->sc_type)
1325 return s;
1326 return NULL;
1327}
1328
1329static struct nfs4_client *create_client(struct xdr_netobj name,
1330 struct svc_rqst *rqstp, nfs4_verifier *verf)
1331{
1332 struct nfs4_client *clp;
1333 struct sockaddr *sa = svc_addr(rqstp);
1334 int ret;
1335 struct net *net = SVC_NET(rqstp);
1336 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1337
1338 clp = alloc_client(name);
1339 if (clp == NULL)
1340 return NULL;
1341
1342 INIT_LIST_HEAD(&clp->cl_sessions);
1343 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
1344 if (ret) {
1345 spin_lock(&nn->client_lock);
1346 free_client(clp);
1347 spin_unlock(&nn->client_lock);
1348 return NULL;
1349 }
1350 idr_init(&clp->cl_stateids);
1351 atomic_set(&clp->cl_refcount, 0);
1352 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1353 INIT_LIST_HEAD(&clp->cl_idhash);
1354 INIT_LIST_HEAD(&clp->cl_openowners);
1355 INIT_LIST_HEAD(&clp->cl_delegations);
1356 INIT_LIST_HEAD(&clp->cl_lru);
1357 INIT_LIST_HEAD(&clp->cl_callbacks);
1358 INIT_LIST_HEAD(&clp->cl_revoked);
1359 spin_lock_init(&clp->cl_lock);
1360 nfsd4_init_callback(&clp->cl_cb_null);
1361 clp->cl_time = get_seconds();
1362 clear_bit(0, &clp->cl_cb_slot_busy);
1363 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1364 copy_verf(clp, verf);
1365 rpc_copy_addr((struct sockaddr *) &clp->cl_addr, sa);
1366 gen_confirm(clp);
1367 clp->cl_cb_session = NULL;
1368 clp->net = net;
1369 return clp;
1370}
1371
1372static void
1373add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
1374{
1375 struct rb_node **new = &(root->rb_node), *parent = NULL;
1376 struct nfs4_client *clp;
1377
1378 while (*new) {
1379 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
1380 parent = *new;
1381
1382 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
1383 new = &((*new)->rb_left);
1384 else
1385 new = &((*new)->rb_right);
1386 }
1387
1388 rb_link_node(&new_clp->cl_namenode, parent, new);
1389 rb_insert_color(&new_clp->cl_namenode, root);
1390}
1391
1392static struct nfs4_client *
1393find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
1394{
1395 long long cmp;
1396 struct rb_node *node = root->rb_node;
1397 struct nfs4_client *clp;
1398
1399 while (node) {
1400 clp = rb_entry(node, struct nfs4_client, cl_namenode);
1401 cmp = compare_blob(&clp->cl_name, name);
1402 if (cmp > 0)
1403 node = node->rb_left;
1404 else if (cmp < 0)
1405 node = node->rb_right;
1406 else
1407 return clp;
1408 }
1409 return NULL;
1410}
1411
1412static void
1413add_to_unconfirmed(struct nfs4_client *clp)
1414{
1415 unsigned int idhashval;
1416 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1417
1418 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
1419 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
1420 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1421 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
1422 renew_client(clp);
1423}
1424
1425static void
1426move_to_confirmed(struct nfs4_client *clp)
1427{
1428 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
1429 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1430
1431 dprintk("NFSD: move_to_confirm nfs4_client %p\n", clp);
1432 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
1433 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
1434 add_clp_to_name_tree(clp, &nn->conf_name_tree);
1435 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
1436 renew_client(clp);
1437}
1438
1439static struct nfs4_client *
1440find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
1441{
1442 struct nfs4_client *clp;
1443 unsigned int idhashval = clientid_hashval(clid->cl_id);
1444
1445 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
1446 if (same_clid(&clp->cl_clientid, clid)) {
1447 if ((bool)clp->cl_minorversion != sessions)
1448 return NULL;
1449 renew_client(clp);
1450 return clp;
1451 }
1452 }
1453 return NULL;
1454}
1455
1456static struct nfs4_client *
1457find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1458{
1459 struct list_head *tbl = nn->conf_id_hashtbl;
1460
1461 return find_client_in_id_table(tbl, clid, sessions);
1462}
1463
1464static struct nfs4_client *
1465find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
1466{
1467 struct list_head *tbl = nn->unconf_id_hashtbl;
1468
1469 return find_client_in_id_table(tbl, clid, sessions);
1470}
1471
1472static bool clp_used_exchangeid(struct nfs4_client *clp)
1473{
1474 return clp->cl_exchange_flags != 0;
1475}
1476
1477static struct nfs4_client *
1478find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
1479{
1480 return find_clp_in_name_tree(name, &nn->conf_name_tree);
1481}
1482
1483static struct nfs4_client *
1484find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
1485{
1486 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
1487}
1488
1489static void
1490gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
1491{
1492 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
1493 struct sockaddr *sa = svc_addr(rqstp);
1494 u32 scopeid = rpc_get_scope_id(sa);
1495 unsigned short expected_family;
1496
1497
1498 if (se->se_callback_netid_len == 3 &&
1499 !memcmp(se->se_callback_netid_val, "tcp", 3))
1500 expected_family = AF_INET;
1501 else if (se->se_callback_netid_len == 4 &&
1502 !memcmp(se->se_callback_netid_val, "tcp6", 4))
1503 expected_family = AF_INET6;
1504 else
1505 goto out_err;
1506
1507 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
1508 se->se_callback_addr_len,
1509 (struct sockaddr *)&conn->cb_addr,
1510 sizeof(conn->cb_addr));
1511
1512 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
1513 goto out_err;
1514
1515 if (conn->cb_addr.ss_family == AF_INET6)
1516 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
1517
1518 conn->cb_prog = se->se_callback_prog;
1519 conn->cb_ident = se->se_callback_ident;
1520 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
1521 return;
1522out_err:
1523 conn->cb_addr.ss_family = AF_UNSPEC;
1524 conn->cb_addrlen = 0;
1525 dprintk(KERN_INFO "NFSD: this client (clientid %08x/%08x) "
1526 "will not receive delegations\n",
1527 clp->cl_clientid.cl_boot, clp->cl_clientid.cl_id);
1528
1529 return;
1530}
1531
1532
1533
1534
1535void
1536nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
1537{
1538 struct nfsd4_slot *slot = resp->cstate.slot;
1539 unsigned int base;
1540
1541 dprintk("--> %s slot %p\n", __func__, slot);
1542
1543 slot->sl_opcnt = resp->opcnt;
1544 slot->sl_status = resp->cstate.status;
1545
1546 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
1547 if (nfsd4_not_cached(resp)) {
1548 slot->sl_datalen = 0;
1549 return;
1550 }
1551 slot->sl_datalen = (char *)resp->p - (char *)resp->cstate.datap;
1552 base = (char *)resp->cstate.datap -
1553 (char *)resp->xbuf->head[0].iov_base;
1554 if (read_bytes_from_xdr_buf(resp->xbuf, base, slot->sl_data,
1555 slot->sl_datalen))
1556 WARN("%s: sessions DRC could not cache compound\n", __func__);
1557 return;
1558}
1559
1560
1561
1562
1563
1564
1565
1566
1567static __be32
1568nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
1569 struct nfsd4_compoundres *resp)
1570{
1571 struct nfsd4_op *op;
1572 struct nfsd4_slot *slot = resp->cstate.slot;
1573
1574
1575 op = &args->ops[resp->opcnt - 1];
1576 nfsd4_encode_operation(resp, op);
1577
1578
1579 if (args->opcnt > 1 && !(slot->sl_flags & NFSD4_SLOT_CACHETHIS)) {
1580 op = &args->ops[resp->opcnt++];
1581 op->status = nfserr_retry_uncached_rep;
1582 nfsd4_encode_operation(resp, op);
1583 }
1584 return op->status;
1585}
1586
1587
1588
1589
1590
1591__be32
1592nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
1593 struct nfsd4_sequence *seq)
1594{
1595 struct nfsd4_slot *slot = resp->cstate.slot;
1596 __be32 status;
1597
1598 dprintk("--> %s slot %p\n", __func__, slot);
1599
1600
1601 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
1602 if (status == nfserr_retry_uncached_rep)
1603 return status;
1604
1605
1606 memcpy(resp->cstate.datap, slot->sl_data, slot->sl_datalen);
1607
1608 resp->opcnt = slot->sl_opcnt;
1609 resp->p = resp->cstate.datap + XDR_QUADLEN(slot->sl_datalen);
1610 status = slot->sl_status;
1611
1612 return status;
1613}
1614
1615
1616
1617
1618static void
1619nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
1620{
1621
1622 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
1623
1624
1625 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
1626
1627
1628 clid->flags = new->cl_exchange_flags;
1629}
1630
1631static bool client_has_state(struct nfs4_client *clp)
1632{
1633
1634
1635
1636
1637
1638
1639 return !list_empty(&clp->cl_openowners)
1640 || !list_empty(&clp->cl_delegations)
1641 || !list_empty(&clp->cl_sessions);
1642}
1643
1644__be32
1645nfsd4_exchange_id(struct svc_rqst *rqstp,
1646 struct nfsd4_compound_state *cstate,
1647 struct nfsd4_exchange_id *exid)
1648{
1649 struct nfs4_client *unconf, *conf, *new;
1650 __be32 status;
1651 char addr_str[INET6_ADDRSTRLEN];
1652 nfs4_verifier verf = exid->verifier;
1653 struct sockaddr *sa = svc_addr(rqstp);
1654 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
1655 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1656
1657 rpc_ntop(sa, addr_str, sizeof(addr_str));
1658 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
1659 "ip_addr=%s flags %x, spa_how %d\n",
1660 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
1661 addr_str, exid->flags, exid->spa_how);
1662
1663 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
1664 return nfserr_inval;
1665
1666 switch (exid->spa_how) {
1667 case SP4_MACH_CRED:
1668 if (!svc_rqst_integrity_protected(rqstp))
1669 return nfserr_inval;
1670 case SP4_NONE:
1671 break;
1672 default:
1673 WARN_ON_ONCE(1);
1674 case SP4_SSV:
1675 return nfserr_encr_alg_unsupp;
1676 }
1677
1678
1679 nfs4_lock_state();
1680 conf = find_confirmed_client_by_name(&exid->clname, nn);
1681 if (conf) {
1682 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
1683 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
1684
1685 if (update) {
1686 if (!clp_used_exchangeid(conf)) {
1687 status = nfserr_inval;
1688 goto out;
1689 }
1690 if (!mach_creds_match(conf, rqstp)) {
1691 status = nfserr_wrong_cred;
1692 goto out;
1693 }
1694 if (!creds_match) {
1695 status = nfserr_perm;
1696 goto out;
1697 }
1698 if (!verfs_match) {
1699 status = nfserr_not_same;
1700 goto out;
1701 }
1702
1703 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
1704 new = conf;
1705 goto out_copy;
1706 }
1707 if (!creds_match) {
1708 if (client_has_state(conf)) {
1709 status = nfserr_clid_inuse;
1710 goto out;
1711 }
1712 expire_client(conf);
1713 goto out_new;
1714 }
1715 if (verfs_match) {
1716 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
1717 new = conf;
1718 goto out_copy;
1719 }
1720
1721 goto out_new;
1722 }
1723
1724 if (update) {
1725 status = nfserr_noent;
1726 goto out;
1727 }
1728
1729 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
1730 if (unconf)
1731 expire_client(unconf);
1732
1733
1734out_new:
1735 new = create_client(exid->clname, rqstp, &verf);
1736 if (new == NULL) {
1737 status = nfserr_jukebox;
1738 goto out;
1739 }
1740 new->cl_minorversion = cstate->minorversion;
1741 new->cl_mach_cred = (exid->spa_how == SP4_MACH_CRED);
1742
1743 gen_clid(new, nn);
1744 add_to_unconfirmed(new);
1745out_copy:
1746 exid->clientid.cl_boot = new->cl_clientid.cl_boot;
1747 exid->clientid.cl_id = new->cl_clientid.cl_id;
1748
1749 exid->seqid = new->cl_cs_slot.sl_seqid + 1;
1750 nfsd4_set_ex_flags(new, exid);
1751
1752 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
1753 new->cl_cs_slot.sl_seqid, new->cl_exchange_flags);
1754 status = nfs_ok;
1755
1756out:
1757 nfs4_unlock_state();
1758 return status;
1759}
1760
1761static __be32
1762check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
1763{
1764 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
1765 slot_seqid);
1766
1767
1768 if (slot_inuse) {
1769 if (seqid == slot_seqid)
1770 return nfserr_jukebox;
1771 else
1772 return nfserr_seq_misordered;
1773 }
1774
1775 if (likely(seqid == slot_seqid + 1))
1776 return nfs_ok;
1777 if (seqid == slot_seqid)
1778 return nfserr_replay_cache;
1779 return nfserr_seq_misordered;
1780}
1781
1782
1783
1784
1785
1786
1787static void
1788nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
1789 struct nfsd4_clid_slot *slot, __be32 nfserr)
1790{
1791 slot->sl_status = nfserr;
1792 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
1793}
1794
1795static __be32
1796nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
1797 struct nfsd4_clid_slot *slot)
1798{
1799 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
1800 return slot->sl_status;
1801}
1802
1803#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
1804 2 * 2 + \
1805 1 + \
1806 3 + \
1807 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1808 \
1809 4 ) * sizeof(__be32))
1810
1811#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
1812 2 + \
1813 1 + \
1814 1 + \
1815 3 + \
1816 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
1817 \
1818 5 ) * sizeof(__be32))
1819
1820static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
1821{
1822 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
1823
1824 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
1825 return nfserr_toosmall;
1826 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
1827 return nfserr_toosmall;
1828 ca->headerpadsz = 0;
1829 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
1830 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
1831 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
1832 ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
1833 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
1834 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
1835
1836
1837
1838
1839
1840
1841
1842
1843 ca->maxreqs = nfsd4_get_drc_mem(ca);
1844 if (!ca->maxreqs)
1845 return nfserr_jukebox;
1846
1847 return nfs_ok;
1848}
1849
1850static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
1851{
1852 ca->headerpadsz = 0;
1853
1854
1855
1856
1857
1858
1859
1860 if (ca->maxreq_sz < NFS4_enc_cb_recall_sz + RPC_MAX_HEADER_WITH_AUTH)
1861 return nfserr_toosmall;
1862 if (ca->maxresp_sz < NFS4_dec_cb_recall_sz + RPC_MAX_REPHEADER_WITH_AUTH)
1863 return nfserr_toosmall;
1864 ca->maxresp_cached = 0;
1865 if (ca->maxops < 2)
1866 return nfserr_toosmall;
1867
1868 return nfs_ok;
1869}
1870
1871static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
1872{
1873 switch (cbs->flavor) {
1874 case RPC_AUTH_NULL:
1875 case RPC_AUTH_UNIX:
1876 return nfs_ok;
1877 default:
1878
1879
1880
1881
1882
1883
1884
1885 return nfserr_encr_alg_unsupp;
1886 }
1887}
1888
1889__be32
1890nfsd4_create_session(struct svc_rqst *rqstp,
1891 struct nfsd4_compound_state *cstate,
1892 struct nfsd4_create_session *cr_ses)
1893{
1894 struct sockaddr *sa = svc_addr(rqstp);
1895 struct nfs4_client *conf, *unconf;
1896 struct nfsd4_session *new;
1897 struct nfsd4_conn *conn;
1898 struct nfsd4_clid_slot *cs_slot = NULL;
1899 __be32 status = 0;
1900 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1901
1902 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
1903 return nfserr_inval;
1904 status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
1905 if (status)
1906 return status;
1907 status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
1908 if (status)
1909 return status;
1910 status = check_backchannel_attrs(&cr_ses->back_channel);
1911 if (status)
1912 return status;
1913 status = nfserr_jukebox;
1914 new = alloc_session(&cr_ses->fore_channel);
1915 if (!new)
1916 goto out_release_drc_mem;
1917 conn = alloc_conn_from_crses(rqstp, cr_ses);
1918 if (!conn)
1919 goto out_free_session;
1920
1921 nfs4_lock_state();
1922 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
1923 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
1924 WARN_ON_ONCE(conf && unconf);
1925
1926 if (conf) {
1927 status = nfserr_wrong_cred;
1928 if (!mach_creds_match(conf, rqstp))
1929 goto out_free_conn;
1930 cs_slot = &conf->cl_cs_slot;
1931 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1932 if (status == nfserr_replay_cache) {
1933 status = nfsd4_replay_create_session(cr_ses, cs_slot);
1934 goto out_free_conn;
1935 } else if (cr_ses->seqid != cs_slot->sl_seqid + 1) {
1936 status = nfserr_seq_misordered;
1937 goto out_free_conn;
1938 }
1939 } else if (unconf) {
1940 struct nfs4_client *old;
1941 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
1942 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
1943 status = nfserr_clid_inuse;
1944 goto out_free_conn;
1945 }
1946 status = nfserr_wrong_cred;
1947 if (!mach_creds_match(unconf, rqstp))
1948 goto out_free_conn;
1949 cs_slot = &unconf->cl_cs_slot;
1950 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
1951 if (status) {
1952
1953 status = nfserr_seq_misordered;
1954 goto out_free_conn;
1955 }
1956 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
1957 if (old) {
1958 status = mark_client_expired(old);
1959 if (status)
1960 goto out_free_conn;
1961 expire_client(old);
1962 }
1963 move_to_confirmed(unconf);
1964 conf = unconf;
1965 } else {
1966 status = nfserr_stale_clientid;
1967 goto out_free_conn;
1968 }
1969 status = nfs_ok;
1970
1971
1972
1973 cr_ses->flags &= ~SESSION4_PERSIST;
1974 cr_ses->flags &= ~SESSION4_RDMA;
1975
1976 init_session(rqstp, new, conf, cr_ses);
1977 nfsd4_init_conn(rqstp, conn, new);
1978
1979 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
1980 NFS4_MAX_SESSIONID_LEN);
1981 cs_slot->sl_seqid++;
1982 cr_ses->seqid = cs_slot->sl_seqid;
1983
1984
1985 nfsd4_cache_create_session(cr_ses, cs_slot, status);
1986 nfs4_unlock_state();
1987 return status;
1988out_free_conn:
1989 nfs4_unlock_state();
1990 free_conn(conn);
1991out_free_session:
1992 __free_session(new);
1993out_release_drc_mem:
1994 nfsd4_put_drc_mem(&cr_ses->fore_channel);
1995 return status;
1996}
1997
1998static __be32 nfsd4_map_bcts_dir(u32 *dir)
1999{
2000 switch (*dir) {
2001 case NFS4_CDFC4_FORE:
2002 case NFS4_CDFC4_BACK:
2003 return nfs_ok;
2004 case NFS4_CDFC4_FORE_OR_BOTH:
2005 case NFS4_CDFC4_BACK_OR_BOTH:
2006 *dir = NFS4_CDFC4_BOTH;
2007 return nfs_ok;
2008 };
2009 return nfserr_inval;
2010}
2011
2012__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_backchannel_ctl *bc)
2013{
2014 struct nfsd4_session *session = cstate->session;
2015 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2016 __be32 status;
2017
2018 status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
2019 if (status)
2020 return status;
2021 spin_lock(&nn->client_lock);
2022 session->se_cb_prog = bc->bc_cb_program;
2023 session->se_cb_sec = bc->bc_cb_sec;
2024 spin_unlock(&nn->client_lock);
2025
2026 nfsd4_probe_callback(session->se_client);
2027
2028 return nfs_ok;
2029}
2030
2031__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
2032 struct nfsd4_compound_state *cstate,
2033 struct nfsd4_bind_conn_to_session *bcts)
2034{
2035 __be32 status;
2036 struct nfsd4_conn *conn;
2037 struct nfsd4_session *session;
2038 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2039
2040 if (!nfsd4_last_compound_op(rqstp))
2041 return nfserr_not_only_op;
2042 nfs4_lock_state();
2043 spin_lock(&nn->client_lock);
2044 session = find_in_sessionid_hashtbl(&bcts->sessionid, SVC_NET(rqstp));
2045 spin_unlock(&nn->client_lock);
2046 status = nfserr_badsession;
2047 if (!session)
2048 goto out;
2049 status = nfserr_wrong_cred;
2050 if (!mach_creds_match(session->se_client, rqstp))
2051 goto out;
2052 status = nfsd4_map_bcts_dir(&bcts->dir);
2053 if (status)
2054 goto out;
2055 conn = alloc_conn(rqstp, bcts->dir);
2056 status = nfserr_jukebox;
2057 if (!conn)
2058 goto out;
2059 nfsd4_init_conn(rqstp, conn, session);
2060 status = nfs_ok;
2061out:
2062 nfs4_unlock_state();
2063 return status;
2064}
2065
2066static bool nfsd4_compound_in_session(struct nfsd4_session *session, struct nfs4_sessionid *sid)
2067{
2068 if (!session)
2069 return 0;
2070 return !memcmp(sid, &session->se_sessionid, sizeof(*sid));
2071}
2072
2073__be32
2074nfsd4_destroy_session(struct svc_rqst *r,
2075 struct nfsd4_compound_state *cstate,
2076 struct nfsd4_destroy_session *sessionid)
2077{
2078 struct nfsd4_session *ses;
2079 __be32 status;
2080 int ref_held_by_me = 0;
2081 struct nfsd_net *nn = net_generic(SVC_NET(r), nfsd_net_id);
2082
2083 nfs4_lock_state();
2084 status = nfserr_not_only_op;
2085 if (nfsd4_compound_in_session(cstate->session, &sessionid->sessionid)) {
2086 if (!nfsd4_last_compound_op(r))
2087 goto out;
2088 ref_held_by_me++;
2089 }
2090 dump_sessionid(__func__, &sessionid->sessionid);
2091 spin_lock(&nn->client_lock);
2092 ses = find_in_sessionid_hashtbl(&sessionid->sessionid, SVC_NET(r));
2093 status = nfserr_badsession;
2094 if (!ses)
2095 goto out_client_lock;
2096 status = nfserr_wrong_cred;
2097 if (!mach_creds_match(ses->se_client, r))
2098 goto out_client_lock;
2099 nfsd4_get_session_locked(ses);
2100 status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
2101 if (status)
2102 goto out_put_session;
2103 unhash_session(ses);
2104 spin_unlock(&nn->client_lock);
2105
2106 nfsd4_probe_callback_sync(ses->se_client);
2107
2108 spin_lock(&nn->client_lock);
2109 status = nfs_ok;
2110out_put_session:
2111 nfsd4_put_session(ses);
2112out_client_lock:
2113 spin_unlock(&nn->client_lock);
2114out:
2115 nfs4_unlock_state();
2116 return status;
2117}
2118
2119static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
2120{
2121 struct nfsd4_conn *c;
2122
2123 list_for_each_entry(c, &s->se_conns, cn_persession) {
2124 if (c->cn_xprt == xpt) {
2125 return c;
2126 }
2127 }
2128 return NULL;
2129}
2130
2131static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
2132{
2133 struct nfs4_client *clp = ses->se_client;
2134 struct nfsd4_conn *c;
2135 __be32 status = nfs_ok;
2136 int ret;
2137
2138 spin_lock(&clp->cl_lock);
2139 c = __nfsd4_find_conn(new->cn_xprt, ses);
2140 if (c)
2141 goto out_free;
2142 status = nfserr_conn_not_bound_to_session;
2143 if (clp->cl_mach_cred)
2144 goto out_free;
2145 __nfsd4_hash_conn(new, ses);
2146 spin_unlock(&clp->cl_lock);
2147 ret = nfsd4_register_conn(new);
2148 if (ret)
2149
2150 nfsd4_conn_lost(&new->cn_xpt_user);
2151 return nfs_ok;
2152out_free:
2153 spin_unlock(&clp->cl_lock);
2154 free_conn(new);
2155 return status;
2156}
2157
2158static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
2159{
2160 struct nfsd4_compoundargs *args = rqstp->rq_argp;
2161
2162 return args->opcnt > session->se_fchannel.maxops;
2163}
2164
2165static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
2166 struct nfsd4_session *session)
2167{
2168 struct xdr_buf *xb = &rqstp->rq_arg;
2169
2170 return xb->len > session->se_fchannel.maxreq_sz;
2171}
2172
2173__be32
2174nfsd4_sequence(struct svc_rqst *rqstp,
2175 struct nfsd4_compound_state *cstate,
2176 struct nfsd4_sequence *seq)
2177{
2178 struct nfsd4_compoundres *resp = rqstp->rq_resp;
2179 struct nfsd4_session *session;
2180 struct nfs4_client *clp;
2181 struct nfsd4_slot *slot;
2182 struct nfsd4_conn *conn;
2183 __be32 status;
2184 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2185
2186 if (resp->opcnt != 1)
2187 return nfserr_sequence_pos;
2188
2189
2190
2191
2192
2193 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
2194 if (!conn)
2195 return nfserr_jukebox;
2196
2197 spin_lock(&nn->client_lock);
2198 status = nfserr_badsession;
2199 session = find_in_sessionid_hashtbl(&seq->sessionid, SVC_NET(rqstp));
2200 if (!session)
2201 goto out_no_session;
2202 clp = session->se_client;
2203 status = get_client_locked(clp);
2204 if (status)
2205 goto out_no_session;
2206 status = nfsd4_get_session_locked(session);
2207 if (status)
2208 goto out_put_client;
2209
2210 status = nfserr_too_many_ops;
2211 if (nfsd4_session_too_many_ops(rqstp, session))
2212 goto out_put_session;
2213
2214 status = nfserr_req_too_big;
2215 if (nfsd4_request_too_big(rqstp, session))
2216 goto out_put_session;
2217
2218 status = nfserr_badslot;
2219 if (seq->slotid >= session->se_fchannel.maxreqs)
2220 goto out_put_session;
2221
2222 slot = session->se_slots[seq->slotid];
2223 dprintk("%s: slotid %d\n", __func__, seq->slotid);
2224
2225
2226
2227
2228 seq->maxslots = session->se_fchannel.maxreqs;
2229
2230 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
2231 slot->sl_flags & NFSD4_SLOT_INUSE);
2232 if (status == nfserr_replay_cache) {
2233 status = nfserr_seq_misordered;
2234 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
2235 goto out_put_session;
2236 cstate->slot = slot;
2237 cstate->session = session;
2238
2239
2240 status = nfsd4_replay_cache_entry(resp, seq);
2241 cstate->status = nfserr_replay_cache;
2242 goto out;
2243 }
2244 if (status)
2245 goto out_put_session;
2246
2247 status = nfsd4_sequence_check_conn(conn, session);
2248 conn = NULL;
2249 if (status)
2250 goto out_put_session;
2251
2252
2253 slot->sl_seqid = seq->seqid;
2254 slot->sl_flags |= NFSD4_SLOT_INUSE;
2255 if (seq->cachethis)
2256 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
2257 else
2258 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
2259
2260 cstate->slot = slot;
2261 cstate->session = session;
2262
2263out:
2264 switch (clp->cl_cb_state) {
2265 case NFSD4_CB_DOWN:
2266 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
2267 break;
2268 case NFSD4_CB_FAULT:
2269 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
2270 break;
2271 default:
2272 seq->status_flags = 0;
2273 }
2274 if (!list_empty(&clp->cl_revoked))
2275 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
2276out_no_session:
2277 kfree(conn);
2278 spin_unlock(&nn->client_lock);
2279 return status;
2280out_put_session:
2281 nfsd4_put_session(session);
2282out_put_client:
2283 put_client_renew_locked(clp);
2284 goto out_no_session;
2285}
2286
2287__be32
2288nfsd4_destroy_clientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_destroy_clientid *dc)
2289{
2290 struct nfs4_client *conf, *unconf, *clp;
2291 __be32 status = 0;
2292 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2293
2294 nfs4_lock_state();
2295 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
2296 conf = find_confirmed_client(&dc->clientid, true, nn);
2297 WARN_ON_ONCE(conf && unconf);
2298
2299 if (conf) {
2300 clp = conf;
2301
2302 if (client_has_state(conf)) {
2303 status = nfserr_clientid_busy;
2304 goto out;
2305 }
2306 } else if (unconf)
2307 clp = unconf;
2308 else {
2309 status = nfserr_stale_clientid;
2310 goto out;
2311 }
2312 if (!mach_creds_match(clp, rqstp)) {
2313 status = nfserr_wrong_cred;
2314 goto out;
2315 }
2316 expire_client(clp);
2317out:
2318 nfs4_unlock_state();
2319 return status;
2320}
2321
2322__be32
2323nfsd4_reclaim_complete(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, struct nfsd4_reclaim_complete *rc)
2324{
2325 __be32 status = 0;
2326
2327 if (rc->rca_one_fs) {
2328 if (!cstate->current_fh.fh_dentry)
2329 return nfserr_nofilehandle;
2330
2331
2332
2333
2334 return nfs_ok;
2335 }
2336
2337 nfs4_lock_state();
2338 status = nfserr_complete_already;
2339 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE,
2340 &cstate->session->se_client->cl_flags))
2341 goto out;
2342
2343 status = nfserr_stale_clientid;
2344 if (is_client_expired(cstate->session->se_client))
2345
2346
2347
2348
2349
2350
2351
2352 goto out;
2353
2354 status = nfs_ok;
2355 nfsd4_client_record_create(cstate->session->se_client);
2356out:
2357 nfs4_unlock_state();
2358 return status;
2359}
2360
2361__be32
2362nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
2363 struct nfsd4_setclientid *setclid)
2364{
2365 struct xdr_netobj clname = setclid->se_name;
2366 nfs4_verifier clverifier = setclid->se_verf;
2367 struct nfs4_client *conf, *unconf, *new;
2368 __be32 status;
2369 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2370
2371
2372 nfs4_lock_state();
2373 conf = find_confirmed_client_by_name(&clname, nn);
2374 if (conf) {
2375
2376 status = nfserr_clid_inuse;
2377 if (clp_used_exchangeid(conf))
2378 goto out;
2379 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
2380 char addr_str[INET6_ADDRSTRLEN];
2381 rpc_ntop((struct sockaddr *) &conf->cl_addr, addr_str,
2382 sizeof(addr_str));
2383 dprintk("NFSD: setclientid: string in use by client "
2384 "at %s\n", addr_str);
2385 goto out;
2386 }
2387 }
2388 unconf = find_unconfirmed_client_by_name(&clname, nn);
2389 if (unconf)
2390 expire_client(unconf);
2391 status = nfserr_jukebox;
2392 new = create_client(clname, rqstp, &clverifier);
2393 if (new == NULL)
2394 goto out;
2395 if (conf && same_verf(&conf->cl_verifier, &clverifier))
2396
2397 copy_clid(new, conf);
2398 else
2399 gen_clid(new, nn);
2400 new->cl_minorversion = 0;
2401 gen_callback(new, setclid, rqstp);
2402 add_to_unconfirmed(new);
2403 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
2404 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
2405 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
2406 status = nfs_ok;
2407out:
2408 nfs4_unlock_state();
2409 return status;
2410}
2411
2412
2413__be32
2414nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
2415 struct nfsd4_compound_state *cstate,
2416 struct nfsd4_setclientid_confirm *setclientid_confirm)
2417{
2418 struct nfs4_client *conf, *unconf;
2419 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
2420 clientid_t * clid = &setclientid_confirm->sc_clientid;
2421 __be32 status;
2422 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
2423
2424 if (STALE_CLIENTID(clid, nn))
2425 return nfserr_stale_clientid;
2426 nfs4_lock_state();
2427
2428 conf = find_confirmed_client(clid, false, nn);
2429 unconf = find_unconfirmed_client(clid, false, nn);
2430
2431
2432
2433
2434
2435
2436 status = nfserr_serverfault;
2437 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred))
2438 goto out;
2439 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred))
2440 goto out;
2441
2442 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
2443 if (conf && !unconf)
2444 status = nfs_ok;
2445 else
2446 status = nfserr_stale_clientid;
2447 goto out;
2448 }
2449 status = nfs_ok;
2450 if (conf) {
2451 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
2452 nfsd4_probe_callback(conf);
2453 expire_client(unconf);
2454 } else {
2455 conf = find_confirmed_client_by_name(&unconf->cl_name, nn);
2456 if (conf) {
2457 status = mark_client_expired(conf);
2458 if (status)
2459 goto out;
2460 expire_client(conf);
2461 }
2462 move_to_confirmed(unconf);
2463 nfsd4_probe_callback(unconf);
2464 }
2465out:
2466 nfs4_unlock_state();
2467 return status;
2468}
2469
2470static struct nfs4_file *nfsd4_alloc_file(void)
2471{
2472 return kmem_cache_alloc(file_slab, GFP_KERNEL);
2473}
2474
2475
2476static void nfsd4_init_file(struct nfs4_file *fp, struct inode *ino)
2477{
2478 unsigned int hashval = file_hashval(ino);
2479
2480 atomic_set(&fp->fi_ref, 1);
2481 INIT_LIST_HEAD(&fp->fi_stateids);
2482 INIT_LIST_HEAD(&fp->fi_delegations);
2483 fp->fi_inode = igrab(ino);
2484 fp->fi_had_conflict = false;
2485 fp->fi_lease = NULL;
2486 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
2487 memset(fp->fi_access, 0, sizeof(fp->fi_access));
2488 spin_lock(&recall_lock);
2489 hlist_add_head(&fp->fi_hash, &file_hashtbl[hashval]);
2490 spin_unlock(&recall_lock);
2491}
2492
2493static void
2494nfsd4_free_slab(struct kmem_cache **slab)
2495{
2496 if (*slab == NULL)
2497 return;
2498 kmem_cache_destroy(*slab);
2499 *slab = NULL;
2500}
2501
2502void
2503nfsd4_free_slabs(void)
2504{
2505 nfsd4_free_slab(&openowner_slab);
2506 nfsd4_free_slab(&lockowner_slab);
2507 nfsd4_free_slab(&file_slab);
2508 nfsd4_free_slab(&stateid_slab);
2509 nfsd4_free_slab(&deleg_slab);
2510}
2511
2512int
2513nfsd4_init_slabs(void)
2514{
2515 openowner_slab = kmem_cache_create("nfsd4_openowners",
2516 sizeof(struct nfs4_openowner), 0, 0, NULL);
2517 if (openowner_slab == NULL)
2518 goto out_nomem;
2519 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
2520 sizeof(struct nfs4_lockowner), 0, 0, NULL);
2521 if (lockowner_slab == NULL)
2522 goto out_nomem;
2523 file_slab = kmem_cache_create("nfsd4_files",
2524 sizeof(struct nfs4_file), 0, 0, NULL);
2525 if (file_slab == NULL)
2526 goto out_nomem;
2527 stateid_slab = kmem_cache_create("nfsd4_stateids",
2528 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
2529 if (stateid_slab == NULL)
2530 goto out_nomem;
2531 deleg_slab = kmem_cache_create("nfsd4_delegations",
2532 sizeof(struct nfs4_delegation), 0, 0, NULL);
2533 if (deleg_slab == NULL)
2534 goto out_nomem;
2535 return 0;
2536out_nomem:
2537 nfsd4_free_slabs();
2538 dprintk("nfsd4: out of memory while initializing nfsv4\n");
2539 return -ENOMEM;
2540}
2541
2542void nfs4_free_openowner(struct nfs4_openowner *oo)
2543{
2544 kfree(oo->oo_owner.so_owner.data);
2545 kmem_cache_free(openowner_slab, oo);
2546}
2547
2548void nfs4_free_lockowner(struct nfs4_lockowner *lo)
2549{
2550 kfree(lo->lo_owner.so_owner.data);
2551 kmem_cache_free(lockowner_slab, lo);
2552}
2553
2554static void init_nfs4_replay(struct nfs4_replay *rp)
2555{
2556 rp->rp_status = nfserr_serverfault;
2557 rp->rp_buflen = 0;
2558 rp->rp_buf = rp->rp_ibuf;
2559}
2560
2561static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
2562{
2563 struct nfs4_stateowner *sop;
2564
2565 sop = kmem_cache_alloc(slab, GFP_KERNEL);
2566 if (!sop)
2567 return NULL;
2568
2569 sop->so_owner.data = kmemdup(owner->data, owner->len, GFP_KERNEL);
2570 if (!sop->so_owner.data) {
2571 kmem_cache_free(slab, sop);
2572 return NULL;
2573 }
2574 sop->so_owner.len = owner->len;
2575
2576 INIT_LIST_HEAD(&sop->so_stateids);
2577 sop->so_client = clp;
2578 init_nfs4_replay(&sop->so_replay);
2579 return sop;
2580}
2581
2582static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
2583{
2584 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2585
2586 list_add(&oo->oo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
2587 list_add(&oo->oo_perclient, &clp->cl_openowners);
2588}
2589
2590static struct nfs4_openowner *
2591alloc_init_open_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfsd4_open *open) {
2592 struct nfs4_openowner *oo;
2593
2594 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
2595 if (!oo)
2596 return NULL;
2597 oo->oo_owner.so_is_open_owner = 1;
2598 oo->oo_owner.so_seqid = open->op_seqid;
2599 oo->oo_flags = NFS4_OO_NEW;
2600 oo->oo_time = 0;
2601 oo->oo_last_closed_stid = NULL;
2602 INIT_LIST_HEAD(&oo->oo_close_lru);
2603 hash_openowner(oo, clp, strhashval);
2604 return oo;
2605}
2606
2607static void init_open_stateid(struct nfs4_ol_stateid *stp, struct nfs4_file *fp, struct nfsd4_open *open) {
2608 struct nfs4_openowner *oo = open->op_openowner;
2609
2610 stp->st_stid.sc_type = NFS4_OPEN_STID;
2611 INIT_LIST_HEAD(&stp->st_lockowners);
2612 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
2613 list_add(&stp->st_perfile, &fp->fi_stateids);
2614 stp->st_stateowner = &oo->oo_owner;
2615 get_nfs4_file(fp);
2616 stp->st_file = fp;
2617 stp->st_access_bmap = 0;
2618 stp->st_deny_bmap = 0;
2619 set_access(open->op_share_access, stp);
2620 set_deny(open->op_share_deny, stp);
2621 stp->st_openstp = NULL;
2622}
2623
2624static void
2625move_to_close_lru(struct nfs4_openowner *oo, struct net *net)
2626{
2627 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2628
2629 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
2630
2631 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
2632 oo->oo_time = get_seconds();
2633}
2634
2635static int
2636same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner,
2637 clientid_t *clid)
2638{
2639 return (sop->so_owner.len == owner->len) &&
2640 0 == memcmp(sop->so_owner.data, owner->data, owner->len) &&
2641 (sop->so_client->cl_clientid.cl_id == clid->cl_id);
2642}
2643
2644static struct nfs4_openowner *
2645find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
2646 bool sessions, struct nfsd_net *nn)
2647{
2648 struct nfs4_stateowner *so;
2649 struct nfs4_openowner *oo;
2650 struct nfs4_client *clp;
2651
2652 list_for_each_entry(so, &nn->ownerstr_hashtbl[hashval], so_strhash) {
2653 if (!so->so_is_open_owner)
2654 continue;
2655 if (same_owner_str(so, &open->op_owner, &open->op_clientid)) {
2656 oo = openowner(so);
2657 clp = oo->oo_owner.so_client;
2658 if ((bool)clp->cl_minorversion != sessions)
2659 return NULL;
2660 renew_client(oo->oo_owner.so_client);
2661 return oo;
2662 }
2663 }
2664 return NULL;
2665}
2666
2667
2668static struct nfs4_file *
2669find_file(struct inode *ino)
2670{
2671 unsigned int hashval = file_hashval(ino);
2672 struct nfs4_file *fp;
2673
2674 spin_lock(&recall_lock);
2675 hlist_for_each_entry(fp, &file_hashtbl[hashval], fi_hash) {
2676 if (fp->fi_inode == ino) {
2677 get_nfs4_file(fp);
2678 spin_unlock(&recall_lock);
2679 return fp;
2680 }
2681 }
2682 spin_unlock(&recall_lock);
2683 return NULL;
2684}
2685
2686
2687
2688
2689
2690static __be32
2691nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
2692{
2693 struct inode *ino = current_fh->fh_dentry->d_inode;
2694 struct nfs4_file *fp;
2695 struct nfs4_ol_stateid *stp;
2696 __be32 ret;
2697
2698 fp = find_file(ino);
2699 if (!fp)
2700 return nfs_ok;
2701 ret = nfserr_locked;
2702
2703 list_for_each_entry(stp, &fp->fi_stateids, st_perfile) {
2704 if (test_deny(deny_type, stp) ||
2705 test_deny(NFS4_SHARE_DENY_BOTH, stp))
2706 goto out;
2707 }
2708 ret = nfs_ok;
2709out:
2710 put_nfs4_file(fp);
2711 return ret;
2712}
2713
2714static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
2715{
2716 struct nfs4_client *clp = dp->dl_stid.sc_client;
2717 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2718
2719
2720
2721
2722
2723
2724 atomic_inc(&dp->dl_count);
2725
2726 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
2727
2728
2729 dp->dl_time = get_seconds();
2730
2731 nfsd4_cb_recall(dp);
2732}
2733
2734
2735static void nfsd_break_deleg_cb(struct file_lock *fl)
2736{
2737 struct nfs4_file *fp = (struct nfs4_file *)fl->fl_owner;
2738 struct nfs4_delegation *dp;
2739
2740 if (!fp) {
2741 WARN(1, "(%p)->fl_owner NULL\n", fl);
2742 return;
2743 }
2744 if (fp->fi_had_conflict) {
2745 WARN(1, "duplicate break on %p\n", fp);
2746 return;
2747 }
2748
2749
2750
2751
2752
2753 fl->fl_break_time = 0;
2754
2755 spin_lock(&recall_lock);
2756 fp->fi_had_conflict = true;
2757 list_for_each_entry(dp, &fp->fi_delegations, dl_perfile)
2758 nfsd_break_one_deleg(dp);
2759 spin_unlock(&recall_lock);
2760}
2761
2762static
2763int nfsd_change_deleg_cb(struct file_lock **onlist, int arg)
2764{
2765 if (arg & F_UNLCK)
2766 return lease_modify(onlist, arg);
2767 else
2768 return -EAGAIN;
2769}
2770
2771static const struct lock_manager_operations nfsd_lease_mng_ops = {
2772 .lm_break = nfsd_break_deleg_cb,
2773 .lm_change = nfsd_change_deleg_cb,
2774};
2775
2776static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
2777{
2778 if (nfsd4_has_session(cstate))
2779 return nfs_ok;
2780 if (seqid == so->so_seqid - 1)
2781 return nfserr_replay_me;
2782 if (seqid == so->so_seqid)
2783 return nfs_ok;
2784 return nfserr_bad_seqid;
2785}
2786
2787__be32
2788nfsd4_process_open1(struct nfsd4_compound_state *cstate,
2789 struct nfsd4_open *open, struct nfsd_net *nn)
2790{
2791 clientid_t *clientid = &open->op_clientid;
2792 struct nfs4_client *clp = NULL;
2793 unsigned int strhashval;
2794 struct nfs4_openowner *oo = NULL;
2795 __be32 status;
2796
2797 if (STALE_CLIENTID(&open->op_clientid, nn))
2798 return nfserr_stale_clientid;
2799
2800
2801
2802
2803 open->op_file = nfsd4_alloc_file();
2804 if (open->op_file == NULL)
2805 return nfserr_jukebox;
2806
2807 strhashval = ownerstr_hashval(clientid->cl_id, &open->op_owner);
2808 oo = find_openstateowner_str(strhashval, open, cstate->minorversion, nn);
2809 open->op_openowner = oo;
2810 if (!oo) {
2811 clp = find_confirmed_client(clientid, cstate->minorversion,
2812 nn);
2813 if (clp == NULL)
2814 return nfserr_expired;
2815 goto new_owner;
2816 }
2817 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
2818
2819 clp = oo->oo_owner.so_client;
2820 release_openowner(oo);
2821 open->op_openowner = NULL;
2822 goto new_owner;
2823 }
2824 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
2825 if (status)
2826 return status;
2827 clp = oo->oo_owner.so_client;
2828 goto alloc_stateid;
2829new_owner:
2830 oo = alloc_init_open_stateowner(strhashval, clp, open);
2831 if (oo == NULL)
2832 return nfserr_jukebox;
2833 open->op_openowner = oo;
2834alloc_stateid:
2835 open->op_stp = nfs4_alloc_stateid(clp);
2836 if (!open->op_stp)
2837 return nfserr_jukebox;
2838 return nfs_ok;
2839}
2840
2841static inline __be32
2842nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
2843{
2844 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
2845 return nfserr_openmode;
2846 else
2847 return nfs_ok;
2848}
2849
2850static int share_access_to_flags(u32 share_access)
2851{
2852 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
2853}
2854
2855static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
2856{
2857 struct nfs4_stid *ret;
2858
2859 ret = find_stateid_by_type(cl, s, NFS4_DELEG_STID);
2860 if (!ret)
2861 return NULL;
2862 return delegstateid(ret);
2863}
2864
2865static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
2866{
2867 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
2868 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
2869}
2870
2871static __be32
2872nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
2873 struct nfs4_delegation **dp)
2874{
2875 int flags;
2876 __be32 status = nfserr_bad_stateid;
2877
2878 *dp = find_deleg_stateid(cl, &open->op_delegate_stateid);
2879 if (*dp == NULL)
2880 goto out;
2881 flags = share_access_to_flags(open->op_share_access);
2882 status = nfs4_check_delegmode(*dp, flags);
2883 if (status)
2884 *dp = NULL;
2885out:
2886 if (!nfsd4_is_deleg_cur(open))
2887 return nfs_ok;
2888 if (status)
2889 return status;
2890 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
2891 return nfs_ok;
2892}
2893
2894static __be32
2895nfs4_check_open(struct nfs4_file *fp, struct nfsd4_open *open, struct nfs4_ol_stateid **stpp)
2896{
2897 struct nfs4_ol_stateid *local;
2898 struct nfs4_openowner *oo = open->op_openowner;
2899
2900 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
2901
2902 if (local->st_stateowner->so_is_open_owner == 0)
2903 continue;
2904
2905 if (local->st_stateowner == &oo->oo_owner)
2906 *stpp = local;
2907
2908 if (!test_share(local, open))
2909 return nfserr_share_denied;
2910 }
2911 return nfs_ok;
2912}
2913
2914static inline int nfs4_access_to_access(u32 nfs4_access)
2915{
2916 int flags = 0;
2917
2918 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
2919 flags |= NFSD_MAY_READ;
2920 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
2921 flags |= NFSD_MAY_WRITE;
2922 return flags;
2923}
2924
2925static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
2926 struct svc_fh *cur_fh, struct nfsd4_open *open)
2927{
2928 __be32 status;
2929 int oflag = nfs4_access_to_omode(open->op_share_access);
2930 int access = nfs4_access_to_access(open->op_share_access);
2931
2932 if (!fp->fi_fds[oflag]) {
2933 status = nfsd_open(rqstp, cur_fh, S_IFREG, access,
2934 &fp->fi_fds[oflag]);
2935 if (status)
2936 return status;
2937 }
2938 nfs4_file_get_access(fp, oflag);
2939
2940 return nfs_ok;
2941}
2942
2943static inline __be32
2944nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
2945 struct nfsd4_open *open)
2946{
2947 struct iattr iattr = {
2948 .ia_valid = ATTR_SIZE,
2949 .ia_size = 0,
2950 };
2951 if (!open->op_truncate)
2952 return 0;
2953 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
2954 return nfserr_inval;
2955 return nfsd_setattr(rqstp, fh, &iattr, 0, (time_t)0);
2956}
2957
2958static __be32
2959nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
2960{
2961 u32 op_share_access = open->op_share_access;
2962 bool new_access;
2963 __be32 status;
2964
2965 new_access = !test_access(op_share_access, stp);
2966 if (new_access) {
2967 status = nfs4_get_vfs_file(rqstp, fp, cur_fh, open);
2968 if (status)
2969 return status;
2970 }
2971 status = nfsd4_truncate(rqstp, cur_fh, open);
2972 if (status) {
2973 if (new_access) {
2974 int oflag = nfs4_access_to_omode(op_share_access);
2975 nfs4_file_put_access(fp, oflag);
2976 }
2977 return status;
2978 }
2979
2980 set_access(op_share_access, stp);
2981 set_deny(open->op_share_deny, stp);
2982
2983 return nfs_ok;
2984}
2985
2986
2987static void
2988nfs4_set_claim_prev(struct nfsd4_open *open, bool has_session)
2989{
2990 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
2991}
2992
2993
2994static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
2995{
2996 if (clp->cl_cb_state == NFSD4_CB_UP)
2997 return true;
2998
2999
3000
3001
3002
3003 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
3004}
3005
3006static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp, int flag)
3007{
3008 struct file_lock *fl;
3009
3010 fl = locks_alloc_lock();
3011 if (!fl)
3012 return NULL;
3013 locks_init_lock(fl);
3014 fl->fl_lmops = &nfsd_lease_mng_ops;
3015 fl->fl_flags = FL_LEASE;
3016 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
3017 fl->fl_end = OFFSET_MAX;
3018 fl->fl_owner = (fl_owner_t)(dp->dl_file);
3019 fl->fl_pid = current->tgid;
3020 return fl;
3021}
3022
3023static int nfs4_setlease(struct nfs4_delegation *dp)
3024{
3025 struct nfs4_file *fp = dp->dl_file;
3026 struct file_lock *fl;
3027 int status;
3028
3029 fl = nfs4_alloc_init_lease(dp, NFS4_OPEN_DELEGATE_READ);
3030 if (!fl)
3031 return -ENOMEM;
3032 fl->fl_file = find_readable_file(fp);
3033 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
3034 status = vfs_setlease(fl->fl_file, fl->fl_type, &fl);
3035 if (status) {
3036 list_del_init(&dp->dl_perclnt);
3037 locks_free_lock(fl);
3038 return -ENOMEM;
3039 }
3040 fp->fi_lease = fl;
3041 fp->fi_deleg_file = get_file(fl->fl_file);
3042 atomic_set(&fp->fi_delegees, 1);
3043 list_add(&dp->dl_perfile, &fp->fi_delegations);
3044 return 0;
3045}
3046
3047static int nfs4_set_delegation(struct nfs4_delegation *dp)
3048{
3049 struct nfs4_file *fp = dp->dl_file;
3050
3051 if (!fp->fi_lease)
3052 return nfs4_setlease(dp);
3053 spin_lock(&recall_lock);
3054 if (fp->fi_had_conflict) {
3055 spin_unlock(&recall_lock);
3056 return -EAGAIN;
3057 }
3058 atomic_inc(&fp->fi_delegees);
3059 list_add(&dp->dl_perfile, &fp->fi_delegations);
3060 spin_unlock(&recall_lock);
3061 list_add(&dp->dl_perclnt, &dp->dl_stid.sc_client->cl_delegations);
3062 return 0;
3063}
3064
3065static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
3066{
3067 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3068 if (status == -EAGAIN)
3069 open->op_why_no_deleg = WND4_CONTENTION;
3070 else {
3071 open->op_why_no_deleg = WND4_RESOURCE;
3072 switch (open->op_deleg_want) {
3073 case NFS4_SHARE_WANT_READ_DELEG:
3074 case NFS4_SHARE_WANT_WRITE_DELEG:
3075 case NFS4_SHARE_WANT_ANY_DELEG:
3076 break;
3077 case NFS4_SHARE_WANT_CANCEL:
3078 open->op_why_no_deleg = WND4_CANCELLED;
3079 break;
3080 case NFS4_SHARE_WANT_NO_DELEG:
3081 WARN_ON_ONCE(1);
3082 }
3083 }
3084}
3085
3086
3087
3088
3089
3090
3091
3092static void
3093nfs4_open_delegation(struct net *net, struct svc_fh *fh,
3094 struct nfsd4_open *open, struct nfs4_ol_stateid *stp)
3095{
3096 struct nfs4_delegation *dp;
3097 struct nfs4_openowner *oo = container_of(stp->st_stateowner, struct nfs4_openowner, oo_owner);
3098 int cb_up;
3099 int status = 0;
3100
3101 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
3102 open->op_recall = 0;
3103 switch (open->op_claim_type) {
3104 case NFS4_OPEN_CLAIM_PREVIOUS:
3105 if (!cb_up)
3106 open->op_recall = 1;
3107 if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
3108 goto out_no_deleg;
3109 break;
3110 case NFS4_OPEN_CLAIM_NULL:
3111
3112
3113
3114
3115 if (locks_in_grace(net))
3116 goto out_no_deleg;
3117 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
3118 goto out_no_deleg;
3119
3120
3121
3122
3123
3124
3125
3126 if (open->op_share_access & NFS4_SHARE_ACCESS_WRITE)
3127 goto out_no_deleg;
3128 if (open->op_create == NFS4_OPEN_CREATE)
3129 goto out_no_deleg;
3130 break;
3131 default:
3132 goto out_no_deleg;
3133 }
3134 dp = alloc_init_deleg(oo->oo_owner.so_client, stp, fh);
3135 if (dp == NULL)
3136 goto out_no_deleg;
3137 status = nfs4_set_delegation(dp);
3138 if (status)
3139 goto out_free;
3140
3141 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
3142
3143 dprintk("NFSD: delegation stateid=" STATEID_FMT "\n",
3144 STATEID_VAL(&dp->dl_stid.sc_stateid));
3145 open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
3146 return;
3147out_free:
3148 unhash_stid(&dp->dl_stid);
3149 nfs4_put_delegation(dp);
3150out_no_deleg:
3151 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
3152 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
3153 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
3154 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
3155 open->op_recall = 1;
3156 }
3157
3158
3159 if (open->op_deleg_want)
3160 nfsd4_open_deleg_none_ext(open, status);
3161 return;
3162}
3163
3164static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
3165 struct nfs4_delegation *dp)
3166{
3167 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
3168 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3169 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3170 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
3171 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
3172 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
3173 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3174 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
3175 }
3176
3177
3178
3179
3180}
3181
3182
3183
3184
3185__be32
3186nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
3187{
3188 struct nfsd4_compoundres *resp = rqstp->rq_resp;
3189 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
3190 struct nfs4_file *fp = NULL;
3191 struct inode *ino = current_fh->fh_dentry->d_inode;
3192 struct nfs4_ol_stateid *stp = NULL;
3193 struct nfs4_delegation *dp = NULL;
3194 __be32 status;
3195
3196
3197
3198
3199
3200
3201 fp = find_file(ino);
3202 if (fp) {
3203 if ((status = nfs4_check_open(fp, open, &stp)))
3204 goto out;
3205 status = nfs4_check_deleg(cl, open, &dp);
3206 if (status)
3207 goto out;
3208 } else {
3209 status = nfserr_bad_stateid;
3210 if (nfsd4_is_deleg_cur(open))
3211 goto out;
3212 status = nfserr_jukebox;
3213 fp = open->op_file;
3214 open->op_file = NULL;
3215 nfsd4_init_file(fp, ino);
3216 }
3217
3218
3219
3220
3221
3222 if (stp) {
3223
3224 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
3225 if (status)
3226 goto out;
3227 } else {
3228 status = nfs4_get_vfs_file(rqstp, fp, current_fh, open);
3229 if (status)
3230 goto out;
3231 status = nfsd4_truncate(rqstp, current_fh, open);
3232 if (status)
3233 goto out;
3234 stp = open->op_stp;
3235 open->op_stp = NULL;
3236 init_open_stateid(stp, fp, open);
3237 }
3238 update_stateid(&stp->st_stid.sc_stateid);
3239 memcpy(&open->op_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3240
3241 if (nfsd4_has_session(&resp->cstate)) {
3242 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
3243
3244 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
3245 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
3246 open->op_why_no_deleg = WND4_NOT_WANTED;
3247 goto nodeleg;
3248 }
3249 }
3250
3251
3252
3253
3254
3255 nfs4_open_delegation(SVC_NET(rqstp), current_fh, open, stp);
3256nodeleg:
3257 status = nfs_ok;
3258
3259 dprintk("%s: stateid=" STATEID_FMT "\n", __func__,
3260 STATEID_VAL(&stp->st_stid.sc_stateid));
3261out:
3262
3263 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
3264 open->op_deleg_want)
3265 nfsd4_deleg_xgrade_none_ext(open, dp);
3266
3267 if (fp)
3268 put_nfs4_file(fp);
3269 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
3270 nfs4_set_claim_prev(open, nfsd4_has_session(&resp->cstate));
3271
3272
3273
3274 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
3275 if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED) &&
3276 !nfsd4_has_session(&resp->cstate))
3277 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
3278
3279 return status;
3280}
3281
3282void nfsd4_cleanup_open_state(struct nfsd4_open *open, __be32 status)
3283{
3284 if (open->op_openowner) {
3285 struct nfs4_openowner *oo = open->op_openowner;
3286
3287 if (!list_empty(&oo->oo_owner.so_stateids))
3288 list_del_init(&oo->oo_close_lru);
3289 if (oo->oo_flags & NFS4_OO_NEW) {
3290 if (status) {
3291 release_openowner(oo);
3292 open->op_openowner = NULL;
3293 } else
3294 oo->oo_flags &= ~NFS4_OO_NEW;
3295 }
3296 }
3297 if (open->op_file)
3298 nfsd4_free_file(open->op_file);
3299 if (open->op_stp)
3300 free_generic_stateid(open->op_stp);
3301}
3302
3303static __be32 lookup_clientid(clientid_t *clid, bool session, struct nfsd_net *nn, struct nfs4_client **clp)
3304{
3305 struct nfs4_client *found;
3306
3307 if (STALE_CLIENTID(clid, nn))
3308 return nfserr_stale_clientid;
3309 found = find_confirmed_client(clid, session, nn);
3310 if (clp)
3311 *clp = found;
3312 return found ? nfs_ok : nfserr_expired;
3313}
3314
3315__be32
3316nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3317 clientid_t *clid)
3318{
3319 struct nfs4_client *clp;
3320 __be32 status;
3321 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3322
3323 nfs4_lock_state();
3324 dprintk("process_renew(%08x/%08x): starting\n",
3325 clid->cl_boot, clid->cl_id);
3326 status = lookup_clientid(clid, cstate->minorversion, nn, &clp);
3327 if (status)
3328 goto out;
3329 status = nfserr_cb_path_down;
3330 if (!list_empty(&clp->cl_delegations)
3331 && clp->cl_cb_state != NFSD4_CB_UP)
3332 goto out;
3333 status = nfs_ok;
3334out:
3335 nfs4_unlock_state();
3336 return status;
3337}
3338
3339static void
3340nfsd4_end_grace(struct nfsd_net *nn)
3341{
3342
3343 if (nn->grace_ended)
3344 return;
3345
3346 dprintk("NFSD: end of grace period\n");
3347 nn->grace_ended = true;
3348 nfsd4_record_grace_done(nn, nn->boot_time);
3349 locks_end_grace(&nn->nfsd4_manager);
3350
3351
3352
3353
3354
3355 nn->nfsd4_grace = nn->nfsd4_lease;
3356}
3357
3358static time_t
3359nfs4_laundromat(struct nfsd_net *nn)
3360{
3361 struct nfs4_client *clp;
3362 struct nfs4_openowner *oo;
3363 struct nfs4_delegation *dp;
3364 struct list_head *pos, *next, reaplist;
3365 time_t cutoff = get_seconds() - nn->nfsd4_lease;
3366 time_t t, clientid_val = nn->nfsd4_lease;
3367 time_t u, test_val = nn->nfsd4_lease;
3368
3369 nfs4_lock_state();
3370
3371 dprintk("NFSD: laundromat service - starting\n");
3372 nfsd4_end_grace(nn);
3373 INIT_LIST_HEAD(&reaplist);
3374 spin_lock(&nn->client_lock);
3375 list_for_each_safe(pos, next, &nn->client_lru) {
3376 clp = list_entry(pos, struct nfs4_client, cl_lru);
3377 if (time_after((unsigned long)clp->cl_time, (unsigned long)cutoff)) {
3378 t = clp->cl_time - cutoff;
3379 if (clientid_val > t)
3380 clientid_val = t;
3381 break;
3382 }
3383 if (mark_client_expired_locked(clp)) {
3384 dprintk("NFSD: client in use (clientid %08x)\n",
3385 clp->cl_clientid.cl_id);
3386 continue;
3387 }
3388 list_move(&clp->cl_lru, &reaplist);
3389 }
3390 spin_unlock(&nn->client_lock);
3391 list_for_each_safe(pos, next, &reaplist) {
3392 clp = list_entry(pos, struct nfs4_client, cl_lru);
3393 dprintk("NFSD: purging unused client (clientid %08x)\n",
3394 clp->cl_clientid.cl_id);
3395 expire_client(clp);
3396 }
3397 spin_lock(&recall_lock);
3398 list_for_each_safe(pos, next, &nn->del_recall_lru) {
3399 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3400 if (net_generic(dp->dl_stid.sc_client->net, nfsd_net_id) != nn)
3401 continue;
3402 if (time_after((unsigned long)dp->dl_time, (unsigned long)cutoff)) {
3403 u = dp->dl_time - cutoff;
3404 if (test_val > u)
3405 test_val = u;
3406 break;
3407 }
3408 list_move(&dp->dl_recall_lru, &reaplist);
3409 }
3410 spin_unlock(&recall_lock);
3411 list_for_each_safe(pos, next, &reaplist) {
3412 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
3413 revoke_delegation(dp);
3414 }
3415 test_val = nn->nfsd4_lease;
3416 list_for_each_safe(pos, next, &nn->close_lru) {
3417 oo = container_of(pos, struct nfs4_openowner, oo_close_lru);
3418 if (time_after((unsigned long)oo->oo_time, (unsigned long)cutoff)) {
3419 u = oo->oo_time - cutoff;
3420 if (test_val > u)
3421 test_val = u;
3422 break;
3423 }
3424 release_openowner(oo);
3425 }
3426 if (clientid_val < NFSD_LAUNDROMAT_MINTIMEOUT)
3427 clientid_val = NFSD_LAUNDROMAT_MINTIMEOUT;
3428 nfs4_unlock_state();
3429 return clientid_val;
3430}
3431
3432static struct workqueue_struct *laundry_wq;
3433static void laundromat_main(struct work_struct *);
3434
3435static void
3436laundromat_main(struct work_struct *laundry)
3437{
3438 time_t t;
3439 struct delayed_work *dwork = container_of(laundry, struct delayed_work,
3440 work);
3441 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
3442 laundromat_work);
3443
3444 t = nfs4_laundromat(nn);
3445 dprintk("NFSD: laundromat_main - sleeping for %ld seconds\n", t);
3446 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
3447}
3448
3449static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_ol_stateid *stp)
3450{
3451 if (fhp->fh_dentry->d_inode != stp->st_file->fi_inode)
3452 return nfserr_bad_stateid;
3453 return nfs_ok;
3454}
3455
3456static inline int
3457access_permit_read(struct nfs4_ol_stateid *stp)
3458{
3459 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
3460 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
3461 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
3462}
3463
3464static inline int
3465access_permit_write(struct nfs4_ol_stateid *stp)
3466{
3467 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
3468 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
3469}
3470
3471static
3472__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
3473{
3474 __be32 status = nfserr_openmode;
3475
3476
3477 if (stp->st_openstp)
3478 stp = stp->st_openstp;
3479 if ((flags & WR_STATE) && !access_permit_write(stp))
3480 goto out;
3481 if ((flags & RD_STATE) && !access_permit_read(stp))
3482 goto out;
3483 status = nfs_ok;
3484out:
3485 return status;
3486}
3487
3488static inline __be32
3489check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
3490{
3491 if (ONE_STATEID(stateid) && (flags & RD_STATE))
3492 return nfs_ok;
3493 else if (locks_in_grace(net)) {
3494
3495
3496 return nfserr_grace;
3497 } else if (flags & WR_STATE)
3498 return nfs4_share_conflict(current_fh,
3499 NFS4_SHARE_DENY_WRITE);
3500 else
3501 return nfs4_share_conflict(current_fh,
3502 NFS4_SHARE_DENY_READ);
3503}
3504
3505
3506
3507
3508
3509static inline int
3510grace_disallows_io(struct net *net, struct inode *inode)
3511{
3512 return locks_in_grace(net) && mandatory_lock(inode);
3513}
3514
3515
3516static bool stateid_generation_after(stateid_t *a, stateid_t *b)
3517{
3518 return (s32)(a->si_generation - b->si_generation) > 0;
3519}
3520
3521static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
3522{
3523
3524
3525
3526
3527 if (has_session && in->si_generation == 0)
3528 return nfs_ok;
3529
3530 if (in->si_generation == ref->si_generation)
3531 return nfs_ok;
3532
3533
3534 if (stateid_generation_after(in, ref))
3535 return nfserr_bad_stateid;
3536
3537
3538
3539
3540
3541
3542
3543
3544
3545
3546 return nfserr_old_stateid;
3547}
3548
3549static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
3550{
3551 struct nfs4_stid *s;
3552 struct nfs4_ol_stateid *ols;
3553 __be32 status;
3554
3555 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3556 return nfserr_bad_stateid;
3557
3558 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid)) {
3559 char addr_str[INET6_ADDRSTRLEN];
3560 rpc_ntop((struct sockaddr *)&cl->cl_addr, addr_str,
3561 sizeof(addr_str));
3562 pr_warn_ratelimited("NFSD: client %s testing state ID "
3563 "with incorrect client ID\n", addr_str);
3564 return nfserr_bad_stateid;
3565 }
3566 s = find_stateid(cl, stateid);
3567 if (!s)
3568 return nfserr_bad_stateid;
3569 status = check_stateid_generation(stateid, &s->sc_stateid, 1);
3570 if (status)
3571 return status;
3572 switch (s->sc_type) {
3573 case NFS4_DELEG_STID:
3574 return nfs_ok;
3575 case NFS4_REVOKED_DELEG_STID:
3576 return nfserr_deleg_revoked;
3577 case NFS4_OPEN_STID:
3578 case NFS4_LOCK_STID:
3579 ols = openlockstateid(s);
3580 if (ols->st_stateowner->so_is_open_owner
3581 && !(openowner(ols->st_stateowner)->oo_flags
3582 & NFS4_OO_CONFIRMED))
3583 return nfserr_bad_stateid;
3584 return nfs_ok;
3585 default:
3586 printk("unknown stateid type %x\n", s->sc_type);
3587 case NFS4_CLOSED_STID:
3588 return nfserr_bad_stateid;
3589 }
3590}
3591
3592static __be32 nfsd4_lookup_stateid(stateid_t *stateid, unsigned char typemask,
3593 struct nfs4_stid **s, bool sessions,
3594 struct nfsd_net *nn)
3595{
3596 struct nfs4_client *cl;
3597 __be32 status;
3598
3599 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3600 return nfserr_bad_stateid;
3601 status = lookup_clientid(&stateid->si_opaque.so_clid, sessions,
3602 nn, &cl);
3603 if (status == nfserr_stale_clientid)
3604 return nfserr_stale_stateid;
3605 if (status)
3606 return status;
3607 *s = find_stateid_by_type(cl, stateid, typemask);
3608 if (!*s)
3609 return nfserr_bad_stateid;
3610 return nfs_ok;
3611}
3612
3613
3614
3615
3616__be32
3617nfs4_preprocess_stateid_op(struct net *net, struct nfsd4_compound_state *cstate,
3618 stateid_t *stateid, int flags, struct file **filpp)
3619{
3620 struct nfs4_stid *s;
3621 struct nfs4_ol_stateid *stp = NULL;
3622 struct nfs4_delegation *dp = NULL;
3623 struct svc_fh *current_fh = &cstate->current_fh;
3624 struct inode *ino = current_fh->fh_dentry->d_inode;
3625 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3626 __be32 status;
3627
3628 if (filpp)
3629 *filpp = NULL;
3630
3631 if (grace_disallows_io(net, ino))
3632 return nfserr_grace;
3633
3634 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid))
3635 return check_special_stateids(net, current_fh, stateid, flags);
3636
3637 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
3638 &s, cstate->minorversion, nn);
3639 if (status)
3640 return status;
3641 status = check_stateid_generation(stateid, &s->sc_stateid, nfsd4_has_session(cstate));
3642 if (status)
3643 goto out;
3644 switch (s->sc_type) {
3645 case NFS4_DELEG_STID:
3646 dp = delegstateid(s);
3647 status = nfs4_check_delegmode(dp, flags);
3648 if (status)
3649 goto out;
3650 if (filpp) {
3651 *filpp = dp->dl_file->fi_deleg_file;
3652 if (!*filpp) {
3653 WARN_ON_ONCE(1);
3654 status = nfserr_serverfault;
3655 goto out;
3656 }
3657 }
3658 break;
3659 case NFS4_OPEN_STID:
3660 case NFS4_LOCK_STID:
3661 stp = openlockstateid(s);
3662 status = nfs4_check_fh(current_fh, stp);
3663 if (status)
3664 goto out;
3665 if (stp->st_stateowner->so_is_open_owner
3666 && !(openowner(stp->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
3667 goto out;
3668 status = nfs4_check_openmode(stp, flags);
3669 if (status)
3670 goto out;
3671 if (filpp) {
3672 if (flags & RD_STATE)
3673 *filpp = find_readable_file(stp->st_file);
3674 else
3675 *filpp = find_writeable_file(stp->st_file);
3676 }
3677 break;
3678 default:
3679 return nfserr_bad_stateid;
3680 }
3681 status = nfs_ok;
3682out:
3683 return status;
3684}
3685
3686static __be32
3687nfsd4_free_lock_stateid(struct nfs4_ol_stateid *stp)
3688{
3689 if (check_for_locks(stp->st_file, lockowner(stp->st_stateowner)))
3690 return nfserr_locks_held;
3691 release_lock_stateid(stp);
3692 return nfs_ok;
3693}
3694
3695
3696
3697
3698__be32
3699nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3700 struct nfsd4_test_stateid *test_stateid)
3701{
3702 struct nfsd4_test_stateid_id *stateid;
3703 struct nfs4_client *cl = cstate->session->se_client;
3704
3705 nfs4_lock_state();
3706 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
3707 stateid->ts_id_status =
3708 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
3709 nfs4_unlock_state();
3710
3711 return nfs_ok;
3712}
3713
3714__be32
3715nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3716 struct nfsd4_free_stateid *free_stateid)
3717{
3718 stateid_t *stateid = &free_stateid->fr_stateid;
3719 struct nfs4_stid *s;
3720 struct nfs4_delegation *dp;
3721 struct nfs4_client *cl = cstate->session->se_client;
3722 __be32 ret = nfserr_bad_stateid;
3723
3724 nfs4_lock_state();
3725 s = find_stateid(cl, stateid);
3726 if (!s)
3727 goto out;
3728 switch (s->sc_type) {
3729 case NFS4_DELEG_STID:
3730 ret = nfserr_locks_held;
3731 goto out;
3732 case NFS4_OPEN_STID:
3733 case NFS4_LOCK_STID:
3734 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
3735 if (ret)
3736 goto out;
3737 if (s->sc_type == NFS4_LOCK_STID)
3738 ret = nfsd4_free_lock_stateid(openlockstateid(s));
3739 else
3740 ret = nfserr_locks_held;
3741 break;
3742 case NFS4_REVOKED_DELEG_STID:
3743 dp = delegstateid(s);
3744 destroy_revoked_delegation(dp);
3745 ret = nfs_ok;
3746 break;
3747 default:
3748 ret = nfserr_bad_stateid;
3749 }
3750out:
3751 nfs4_unlock_state();
3752 return ret;
3753}
3754
3755static inline int
3756setlkflg (int type)
3757{
3758 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
3759 RD_STATE : WR_STATE;
3760}
3761
3762static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
3763{
3764 struct svc_fh *current_fh = &cstate->current_fh;
3765 struct nfs4_stateowner *sop = stp->st_stateowner;
3766 __be32 status;
3767
3768 status = nfsd4_check_seqid(cstate, sop, seqid);
3769 if (status)
3770 return status;
3771 if (stp->st_stid.sc_type == NFS4_CLOSED_STID
3772 || stp->st_stid.sc_type == NFS4_REVOKED_DELEG_STID)
3773
3774
3775
3776
3777
3778 return nfserr_bad_stateid;
3779 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
3780 if (status)
3781 return status;
3782 return nfs4_check_fh(current_fh, stp);
3783}
3784
3785
3786
3787
3788static __be32
3789nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3790 stateid_t *stateid, char typemask,
3791 struct nfs4_ol_stateid **stpp,
3792 struct nfsd_net *nn)
3793{
3794 __be32 status;
3795 struct nfs4_stid *s;
3796
3797 dprintk("NFSD: %s: seqid=%d stateid = " STATEID_FMT "\n", __func__,
3798 seqid, STATEID_VAL(stateid));
3799
3800 *stpp = NULL;
3801 status = nfsd4_lookup_stateid(stateid, typemask, &s,
3802 cstate->minorversion, nn);
3803 if (status)
3804 return status;
3805 *stpp = openlockstateid(s);
3806 if (!nfsd4_has_session(cstate))
3807 cstate->replay_owner = (*stpp)->st_stateowner;
3808
3809 return nfs4_seqid_op_checks(cstate, stateid, seqid, *stpp);
3810}
3811
3812static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
3813 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
3814{
3815 __be32 status;
3816 struct nfs4_openowner *oo;
3817
3818 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
3819 NFS4_OPEN_STID, stpp, nn);
3820 if (status)
3821 return status;
3822 oo = openowner((*stpp)->st_stateowner);
3823 if (!(oo->oo_flags & NFS4_OO_CONFIRMED))
3824 return nfserr_bad_stateid;
3825 return nfs_ok;
3826}
3827
3828__be32
3829nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3830 struct nfsd4_open_confirm *oc)
3831{
3832 __be32 status;
3833 struct nfs4_openowner *oo;
3834 struct nfs4_ol_stateid *stp;
3835 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3836
3837 dprintk("NFSD: nfsd4_open_confirm on file %.*s\n",
3838 (int)cstate->current_fh.fh_dentry->d_name.len,
3839 cstate->current_fh.fh_dentry->d_name.name);
3840
3841 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
3842 if (status)
3843 return status;
3844
3845 nfs4_lock_state();
3846
3847 status = nfs4_preprocess_seqid_op(cstate,
3848 oc->oc_seqid, &oc->oc_req_stateid,
3849 NFS4_OPEN_STID, &stp, nn);
3850 if (status)
3851 goto out;
3852 oo = openowner(stp->st_stateowner);
3853 status = nfserr_bad_stateid;
3854 if (oo->oo_flags & NFS4_OO_CONFIRMED)
3855 goto out;
3856 oo->oo_flags |= NFS4_OO_CONFIRMED;
3857 update_stateid(&stp->st_stid.sc_stateid);
3858 memcpy(&oc->oc_resp_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3859 dprintk("NFSD: %s: success, seqid=%d stateid=" STATEID_FMT "\n",
3860 __func__, oc->oc_seqid, STATEID_VAL(&stp->st_stid.sc_stateid));
3861
3862 nfsd4_client_record_create(oo->oo_owner.so_client);
3863 status = nfs_ok;
3864out:
3865 nfsd4_bump_seqid(cstate, status);
3866 if (!cstate->replay_owner)
3867 nfs4_unlock_state();
3868 return status;
3869}
3870
3871static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
3872{
3873 if (!test_access(access, stp))
3874 return;
3875 nfs4_file_put_access(stp->st_file, nfs4_access_to_omode(access));
3876 clear_access(access, stp);
3877}
3878
3879static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
3880{
3881 switch (to_access) {
3882 case NFS4_SHARE_ACCESS_READ:
3883 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
3884 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3885 break;
3886 case NFS4_SHARE_ACCESS_WRITE:
3887 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
3888 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
3889 break;
3890 case NFS4_SHARE_ACCESS_BOTH:
3891 break;
3892 default:
3893 WARN_ON_ONCE(1);
3894 }
3895}
3896
3897static void
3898reset_union_bmap_deny(unsigned long deny, struct nfs4_ol_stateid *stp)
3899{
3900 int i;
3901 for (i = 0; i < 4; i++) {
3902 if ((i & deny) != i)
3903 clear_deny(i, stp);
3904 }
3905}
3906
3907__be32
3908nfsd4_open_downgrade(struct svc_rqst *rqstp,
3909 struct nfsd4_compound_state *cstate,
3910 struct nfsd4_open_downgrade *od)
3911{
3912 __be32 status;
3913 struct nfs4_ol_stateid *stp;
3914 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3915
3916 dprintk("NFSD: nfsd4_open_downgrade on file %.*s\n",
3917 (int)cstate->current_fh.fh_dentry->d_name.len,
3918 cstate->current_fh.fh_dentry->d_name.name);
3919
3920
3921 if (od->od_deleg_want)
3922 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
3923 od->od_deleg_want);
3924
3925 nfs4_lock_state();
3926 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
3927 &od->od_stateid, &stp, nn);
3928 if (status)
3929 goto out;
3930 status = nfserr_inval;
3931 if (!test_access(od->od_share_access, stp)) {
3932 dprintk("NFSD: access not a subset current bitmap: 0x%lx, input access=%08x\n",
3933 stp->st_access_bmap, od->od_share_access);
3934 goto out;
3935 }
3936 if (!test_deny(od->od_share_deny, stp)) {
3937 dprintk("NFSD:deny not a subset current bitmap: 0x%lx, input deny=%08x\n",
3938 stp->st_deny_bmap, od->od_share_deny);
3939 goto out;
3940 }
3941 nfs4_stateid_downgrade(stp, od->od_share_access);
3942
3943 reset_union_bmap_deny(od->od_share_deny, stp);
3944
3945 update_stateid(&stp->st_stid.sc_stateid);
3946 memcpy(&od->od_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3947 status = nfs_ok;
3948out:
3949 nfsd4_bump_seqid(cstate, status);
3950 if (!cstate->replay_owner)
3951 nfs4_unlock_state();
3952 return status;
3953}
3954
3955static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
3956{
3957 unhash_open_stateid(s);
3958 s->st_stid.sc_type = NFS4_CLOSED_STID;
3959}
3960
3961
3962
3963
3964__be32
3965nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3966 struct nfsd4_close *close)
3967{
3968 __be32 status;
3969 struct nfs4_openowner *oo;
3970 struct nfs4_ol_stateid *stp;
3971 struct net *net = SVC_NET(rqstp);
3972 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3973
3974 dprintk("NFSD: nfsd4_close on file %.*s\n",
3975 (int)cstate->current_fh.fh_dentry->d_name.len,
3976 cstate->current_fh.fh_dentry->d_name.name);
3977
3978 nfs4_lock_state();
3979 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
3980 &close->cl_stateid,
3981 NFS4_OPEN_STID|NFS4_CLOSED_STID,
3982 &stp, nn);
3983 nfsd4_bump_seqid(cstate, status);
3984 if (status)
3985 goto out;
3986 oo = openowner(stp->st_stateowner);
3987 update_stateid(&stp->st_stid.sc_stateid);
3988 memcpy(&close->cl_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
3989
3990 nfsd4_close_open_stateid(stp);
3991
3992 if (cstate->minorversion) {
3993 unhash_stid(&stp->st_stid);
3994 free_generic_stateid(stp);
3995 } else
3996 oo->oo_last_closed_stid = stp;
3997
3998 if (list_empty(&oo->oo_owner.so_stateids)) {
3999 if (cstate->minorversion)
4000 release_openowner(oo);
4001 else {
4002
4003
4004
4005
4006 move_to_close_lru(oo, SVC_NET(rqstp));
4007 }
4008 }
4009out:
4010 if (!cstate->replay_owner)
4011 nfs4_unlock_state();
4012 return status;
4013}
4014
4015__be32
4016nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4017 struct nfsd4_delegreturn *dr)
4018{
4019 struct nfs4_delegation *dp;
4020 stateid_t *stateid = &dr->dr_stateid;
4021 struct nfs4_stid *s;
4022 __be32 status;
4023 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4024
4025 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
4026 return status;
4027
4028 nfs4_lock_state();
4029 status = nfsd4_lookup_stateid(stateid, NFS4_DELEG_STID, &s,
4030 cstate->minorversion, nn);
4031 if (status)
4032 goto out;
4033 dp = delegstateid(s);
4034 status = check_stateid_generation(stateid, &dp->dl_stid.sc_stateid, nfsd4_has_session(cstate));
4035 if (status)
4036 goto out;
4037
4038 destroy_delegation(dp);
4039out:
4040 nfs4_unlock_state();
4041
4042 return status;
4043}
4044
4045
4046#define LOFF_OVERFLOW(start, len) ((u64)(len) > ~(u64)(start))
4047
4048#define LOCKOWNER_INO_HASH_MASK (LOCKOWNER_INO_HASH_SIZE - 1)
4049
4050static inline u64
4051end_offset(u64 start, u64 len)
4052{
4053 u64 end;
4054
4055 end = start + len;
4056 return end >= start ? end: NFS4_MAX_UINT64;
4057}
4058
4059
4060static inline u64
4061last_byte_offset(u64 start, u64 len)
4062{
4063 u64 end;
4064
4065 WARN_ON_ONCE(!len);
4066 end = start + len;
4067 return end > start ? end - 1: NFS4_MAX_UINT64;
4068}
4069
4070static unsigned int lockowner_ino_hashval(struct inode *inode, u32 cl_id, struct xdr_netobj *ownername)
4071{
4072 return (file_hashval(inode) + cl_id
4073 + opaque_hashval(ownername->data, ownername->len))
4074 & LOCKOWNER_INO_HASH_MASK;
4075}
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085static inline void
4086nfs4_transform_lock_offset(struct file_lock *lock)
4087{
4088 if (lock->fl_start < 0)
4089 lock->fl_start = OFFSET_MAX;
4090 if (lock->fl_end < 0)
4091 lock->fl_end = OFFSET_MAX;
4092}
4093
4094
4095
4096static const struct lock_manager_operations nfsd_posix_mng_ops = {
4097};
4098
4099static inline void
4100nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
4101{
4102 struct nfs4_lockowner *lo;
4103
4104 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
4105 lo = (struct nfs4_lockowner *) fl->fl_owner;
4106 deny->ld_owner.data = kmemdup(lo->lo_owner.so_owner.data,
4107 lo->lo_owner.so_owner.len, GFP_KERNEL);
4108 if (!deny->ld_owner.data)
4109
4110 goto nevermind;
4111 deny->ld_owner.len = lo->lo_owner.so_owner.len;
4112 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
4113 } else {
4114nevermind:
4115 deny->ld_owner.len = 0;
4116 deny->ld_owner.data = NULL;
4117 deny->ld_clientid.cl_boot = 0;
4118 deny->ld_clientid.cl_id = 0;
4119 }
4120 deny->ld_start = fl->fl_start;
4121 deny->ld_length = NFS4_MAX_UINT64;
4122 if (fl->fl_end != NFS4_MAX_UINT64)
4123 deny->ld_length = fl->fl_end - fl->fl_start + 1;
4124 deny->ld_type = NFS4_READ_LT;
4125 if (fl->fl_type != F_RDLCK)
4126 deny->ld_type = NFS4_WRITE_LT;
4127}
4128
4129static bool same_lockowner_ino(struct nfs4_lockowner *lo, struct inode *inode, clientid_t *clid, struct xdr_netobj *owner)
4130{
4131 struct nfs4_ol_stateid *lst;
4132
4133 if (!same_owner_str(&lo->lo_owner, owner, clid))
4134 return false;
4135 lst = list_first_entry(&lo->lo_owner.so_stateids,
4136 struct nfs4_ol_stateid, st_perstateowner);
4137 return lst->st_file->fi_inode == inode;
4138}
4139
4140static struct nfs4_lockowner *
4141find_lockowner_str(struct inode *inode, clientid_t *clid,
4142 struct xdr_netobj *owner, struct nfsd_net *nn)
4143{
4144 unsigned int hashval = lockowner_ino_hashval(inode, clid->cl_id, owner);
4145 struct nfs4_lockowner *lo;
4146
4147 list_for_each_entry(lo, &nn->lockowner_ino_hashtbl[hashval], lo_owner_ino_hash) {
4148 if (same_lockowner_ino(lo, inode, clid, owner))
4149 return lo;
4150 }
4151 return NULL;
4152}
4153
4154static void hash_lockowner(struct nfs4_lockowner *lo, unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp)
4155{
4156 struct inode *inode = open_stp->st_file->fi_inode;
4157 unsigned int inohash = lockowner_ino_hashval(inode,
4158 clp->cl_clientid.cl_id, &lo->lo_owner.so_owner);
4159 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
4160
4161 list_add(&lo->lo_owner.so_strhash, &nn->ownerstr_hashtbl[strhashval]);
4162 list_add(&lo->lo_owner_ino_hash, &nn->lockowner_ino_hashtbl[inohash]);
4163 list_add(&lo->lo_perstateid, &open_stp->st_lockowners);
4164}
4165
4166
4167
4168
4169
4170
4171
4172
4173
4174static struct nfs4_lockowner *
4175alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp, struct nfs4_ol_stateid *open_stp, struct nfsd4_lock *lock) {
4176 struct nfs4_lockowner *lo;
4177
4178 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
4179 if (!lo)
4180 return NULL;
4181 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
4182 lo->lo_owner.so_is_open_owner = 0;
4183
4184
4185 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid + 1;
4186 hash_lockowner(lo, strhashval, clp, open_stp);
4187 return lo;
4188}
4189
4190static struct nfs4_ol_stateid *
4191alloc_init_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fp, struct nfs4_ol_stateid *open_stp)
4192{
4193 struct nfs4_ol_stateid *stp;
4194 struct nfs4_client *clp = lo->lo_owner.so_client;
4195
4196 stp = nfs4_alloc_stateid(clp);
4197 if (stp == NULL)
4198 return NULL;
4199 stp->st_stid.sc_type = NFS4_LOCK_STID;
4200 list_add(&stp->st_perfile, &fp->fi_stateids);
4201 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
4202 stp->st_stateowner = &lo->lo_owner;
4203 get_nfs4_file(fp);
4204 stp->st_file = fp;
4205 stp->st_access_bmap = 0;
4206 stp->st_deny_bmap = open_stp->st_deny_bmap;
4207 stp->st_openstp = open_stp;
4208 return stp;
4209}
4210
4211static int
4212check_lock_length(u64 offset, u64 length)
4213{
4214 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
4215 LOFF_OVERFLOW(offset, length)));
4216}
4217
4218static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
4219{
4220 struct nfs4_file *fp = lock_stp->st_file;
4221 int oflag = nfs4_access_to_omode(access);
4222
4223 if (test_access(access, lock_stp))
4224 return;
4225 nfs4_file_get_access(fp, oflag);
4226 set_access(access, lock_stp);
4227}
4228
4229static __be32 lookup_or_create_lock_state(struct nfsd4_compound_state *cstate, struct nfs4_ol_stateid *ost, struct nfsd4_lock *lock, struct nfs4_ol_stateid **lst, bool *new)
4230{
4231 struct nfs4_file *fi = ost->st_file;
4232 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
4233 struct nfs4_client *cl = oo->oo_owner.so_client;
4234 struct nfs4_lockowner *lo;
4235 unsigned int strhashval;
4236 struct nfsd_net *nn = net_generic(cl->net, nfsd_net_id);
4237
4238 lo = find_lockowner_str(fi->fi_inode, &cl->cl_clientid,
4239 &lock->v.new.owner, nn);
4240 if (lo) {
4241 if (!cstate->minorversion)
4242 return nfserr_bad_seqid;
4243
4244 *lst = list_first_entry(&lo->lo_owner.so_stateids,
4245 struct nfs4_ol_stateid, st_perstateowner);
4246 return nfs_ok;
4247 }
4248 strhashval = ownerstr_hashval(cl->cl_clientid.cl_id,
4249 &lock->v.new.owner);
4250 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
4251 if (lo == NULL)
4252 return nfserr_jukebox;
4253 *lst = alloc_init_lock_stateid(lo, fi, ost);
4254 if (*lst == NULL) {
4255 release_lockowner(lo);
4256 return nfserr_jukebox;
4257 }
4258 *new = true;
4259 return nfs_ok;
4260}
4261
4262
4263
4264
4265__be32
4266nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4267 struct nfsd4_lock *lock)
4268{
4269 struct nfs4_openowner *open_sop = NULL;
4270 struct nfs4_lockowner *lock_sop = NULL;
4271 struct nfs4_ol_stateid *lock_stp;
4272 struct file *filp = NULL;
4273 struct file_lock *file_lock = NULL;
4274 struct file_lock *conflock = NULL;
4275 __be32 status = 0;
4276 bool new_state = false;
4277 int lkflg;
4278 int err;
4279 struct net *net = SVC_NET(rqstp);
4280 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4281
4282 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
4283 (long long) lock->lk_offset,
4284 (long long) lock->lk_length);
4285
4286 if (check_lock_length(lock->lk_offset, lock->lk_length))
4287 return nfserr_inval;
4288
4289 if ((status = fh_verify(rqstp, &cstate->current_fh,
4290 S_IFREG, NFSD_MAY_LOCK))) {
4291 dprintk("NFSD: nfsd4_lock: permission denied!\n");
4292 return status;
4293 }
4294
4295 nfs4_lock_state();
4296
4297 if (lock->lk_is_new) {
4298 struct nfs4_ol_stateid *open_stp = NULL;
4299
4300 if (nfsd4_has_session(cstate))
4301
4302 memcpy(&lock->v.new.clientid,
4303 &cstate->session->se_client->cl_clientid,
4304 sizeof(clientid_t));
4305
4306 status = nfserr_stale_clientid;
4307 if (STALE_CLIENTID(&lock->lk_new_clientid, nn))
4308 goto out;
4309
4310
4311 status = nfs4_preprocess_confirmed_seqid_op(cstate,
4312 lock->lk_new_open_seqid,
4313 &lock->lk_new_open_stateid,
4314 &open_stp, nn);
4315 if (status)
4316 goto out;
4317 open_sop = openowner(open_stp->st_stateowner);
4318 status = nfserr_bad_stateid;
4319 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
4320 &lock->v.new.clientid))
4321 goto out;
4322 status = lookup_or_create_lock_state(cstate, open_stp, lock,
4323 &lock_stp, &new_state);
4324 } else
4325 status = nfs4_preprocess_seqid_op(cstate,
4326 lock->lk_old_lock_seqid,
4327 &lock->lk_old_lock_stateid,
4328 NFS4_LOCK_STID, &lock_stp, nn);
4329 if (status)
4330 goto out;
4331 lock_sop = lockowner(lock_stp->st_stateowner);
4332
4333 lkflg = setlkflg(lock->lk_type);
4334 status = nfs4_check_openmode(lock_stp, lkflg);
4335 if (status)
4336 goto out;
4337
4338 status = nfserr_grace;
4339 if (locks_in_grace(net) && !lock->lk_reclaim)
4340 goto out;
4341 status = nfserr_no_grace;
4342 if (!locks_in_grace(net) && lock->lk_reclaim)
4343 goto out;
4344
4345 file_lock = locks_alloc_lock();
4346 if (!file_lock) {
4347 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4348 status = nfserr_jukebox;
4349 goto out;
4350 }
4351
4352 locks_init_lock(file_lock);
4353 switch (lock->lk_type) {
4354 case NFS4_READ_LT:
4355 case NFS4_READW_LT:
4356 filp = find_readable_file(lock_stp->st_file);
4357 if (filp)
4358 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
4359 file_lock->fl_type = F_RDLCK;
4360 break;
4361 case NFS4_WRITE_LT:
4362 case NFS4_WRITEW_LT:
4363 filp = find_writeable_file(lock_stp->st_file);
4364 if (filp)
4365 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
4366 file_lock->fl_type = F_WRLCK;
4367 break;
4368 default:
4369 status = nfserr_inval;
4370 goto out;
4371 }
4372 if (!filp) {
4373 status = nfserr_openmode;
4374 goto out;
4375 }
4376 file_lock->fl_owner = (fl_owner_t)lock_sop;
4377 file_lock->fl_pid = current->tgid;
4378 file_lock->fl_file = filp;
4379 file_lock->fl_flags = FL_POSIX;
4380 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4381 file_lock->fl_start = lock->lk_offset;
4382 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
4383 nfs4_transform_lock_offset(file_lock);
4384
4385 conflock = locks_alloc_lock();
4386 if (!conflock) {
4387 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4388 status = nfserr_jukebox;
4389 goto out;
4390 }
4391
4392 err = vfs_lock_file(filp, F_SETLK, file_lock, conflock);
4393 switch (-err) {
4394 case 0:
4395 update_stateid(&lock_stp->st_stid.sc_stateid);
4396 memcpy(&lock->lk_resp_stateid, &lock_stp->st_stid.sc_stateid,
4397 sizeof(stateid_t));
4398 status = 0;
4399 break;
4400 case (EAGAIN):
4401 status = nfserr_denied;
4402 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
4403 nfs4_set_lock_denied(conflock, &lock->lk_denied);
4404 break;
4405 case (EDEADLK):
4406 status = nfserr_deadlock;
4407 break;
4408 default:
4409 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
4410 status = nfserrno(err);
4411 break;
4412 }
4413out:
4414 if (status && new_state)
4415 release_lockowner(lock_sop);
4416 nfsd4_bump_seqid(cstate, status);
4417 if (!cstate->replay_owner)
4418 nfs4_unlock_state();
4419 if (file_lock)
4420 locks_free_lock(file_lock);
4421 if (conflock)
4422 locks_free_lock(conflock);
4423 return status;
4424}
4425
4426
4427
4428
4429
4430
4431
4432static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
4433{
4434 struct file *file;
4435 __be32 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
4436 if (!err) {
4437 err = nfserrno(vfs_test_lock(file, lock));
4438 nfsd_close(file);
4439 }
4440 return err;
4441}
4442
4443
4444
4445
4446__be32
4447nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4448 struct nfsd4_lockt *lockt)
4449{
4450 struct inode *inode;
4451 struct file_lock *file_lock = NULL;
4452 struct nfs4_lockowner *lo;
4453 __be32 status;
4454 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4455
4456 if (locks_in_grace(SVC_NET(rqstp)))
4457 return nfserr_grace;
4458
4459 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
4460 return nfserr_inval;
4461
4462 nfs4_lock_state();
4463
4464 if (!nfsd4_has_session(cstate)) {
4465 status = lookup_clientid(&lockt->lt_clientid, false, nn, NULL);
4466 if (status)
4467 goto out;
4468 }
4469
4470 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
4471 goto out;
4472
4473 inode = cstate->current_fh.fh_dentry->d_inode;
4474 file_lock = locks_alloc_lock();
4475 if (!file_lock) {
4476 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4477 status = nfserr_jukebox;
4478 goto out;
4479 }
4480 locks_init_lock(file_lock);
4481 switch (lockt->lt_type) {
4482 case NFS4_READ_LT:
4483 case NFS4_READW_LT:
4484 file_lock->fl_type = F_RDLCK;
4485 break;
4486 case NFS4_WRITE_LT:
4487 case NFS4_WRITEW_LT:
4488 file_lock->fl_type = F_WRLCK;
4489 break;
4490 default:
4491 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
4492 status = nfserr_inval;
4493 goto out;
4494 }
4495
4496 lo = find_lockowner_str(inode, &lockt->lt_clientid, &lockt->lt_owner, nn);
4497 if (lo)
4498 file_lock->fl_owner = (fl_owner_t)lo;
4499 file_lock->fl_pid = current->tgid;
4500 file_lock->fl_flags = FL_POSIX;
4501
4502 file_lock->fl_start = lockt->lt_offset;
4503 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
4504
4505 nfs4_transform_lock_offset(file_lock);
4506
4507 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
4508 if (status)
4509 goto out;
4510
4511 if (file_lock->fl_type != F_UNLCK) {
4512 status = nfserr_denied;
4513 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
4514 }
4515out:
4516 nfs4_unlock_state();
4517 if (file_lock)
4518 locks_free_lock(file_lock);
4519 return status;
4520}
4521
4522__be32
4523nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4524 struct nfsd4_locku *locku)
4525{
4526 struct nfs4_ol_stateid *stp;
4527 struct file *filp = NULL;
4528 struct file_lock *file_lock = NULL;
4529 __be32 status;
4530 int err;
4531 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4532
4533 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
4534 (long long) locku->lu_offset,
4535 (long long) locku->lu_length);
4536
4537 if (check_lock_length(locku->lu_offset, locku->lu_length))
4538 return nfserr_inval;
4539
4540 nfs4_lock_state();
4541
4542 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
4543 &locku->lu_stateid, NFS4_LOCK_STID,
4544 &stp, nn);
4545 if (status)
4546 goto out;
4547 filp = find_any_file(stp->st_file);
4548 if (!filp) {
4549 status = nfserr_lock_range;
4550 goto out;
4551 }
4552 file_lock = locks_alloc_lock();
4553 if (!file_lock) {
4554 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
4555 status = nfserr_jukebox;
4556 goto out;
4557 }
4558 locks_init_lock(file_lock);
4559 file_lock->fl_type = F_UNLCK;
4560 file_lock->fl_owner = (fl_owner_t)lockowner(stp->st_stateowner);
4561 file_lock->fl_pid = current->tgid;
4562 file_lock->fl_file = filp;
4563 file_lock->fl_flags = FL_POSIX;
4564 file_lock->fl_lmops = &nfsd_posix_mng_ops;
4565 file_lock->fl_start = locku->lu_offset;
4566
4567 file_lock->fl_end = last_byte_offset(locku->lu_offset,
4568 locku->lu_length);
4569 nfs4_transform_lock_offset(file_lock);
4570
4571 err = vfs_lock_file(filp, F_SETLK, file_lock, NULL);
4572 if (err) {
4573 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
4574 goto out_nfserr;
4575 }
4576 update_stateid(&stp->st_stid.sc_stateid);
4577 memcpy(&locku->lu_stateid, &stp->st_stid.sc_stateid, sizeof(stateid_t));
4578
4579out:
4580 nfsd4_bump_seqid(cstate, status);
4581 if (!cstate->replay_owner)
4582 nfs4_unlock_state();
4583 if (file_lock)
4584 locks_free_lock(file_lock);
4585 return status;
4586
4587out_nfserr:
4588 status = nfserrno(err);
4589 goto out;
4590}
4591
4592
4593
4594
4595
4596
4597static int
4598check_for_locks(struct nfs4_file *filp, struct nfs4_lockowner *lowner)
4599{
4600 struct file_lock **flpp;
4601 struct inode *inode = filp->fi_inode;
4602 int status = 0;
4603
4604 spin_lock(&inode->i_lock);
4605 for (flpp = &inode->i_flock; *flpp != NULL; flpp = &(*flpp)->fl_next) {
4606 if ((*flpp)->fl_owner == (fl_owner_t)lowner) {
4607 status = 1;
4608 goto out;
4609 }
4610 }
4611out:
4612 spin_unlock(&inode->i_lock);
4613 return status;
4614}
4615
4616__be32
4617nfsd4_release_lockowner(struct svc_rqst *rqstp,
4618 struct nfsd4_compound_state *cstate,
4619 struct nfsd4_release_lockowner *rlockowner)
4620{
4621 clientid_t *clid = &rlockowner->rl_clientid;
4622 struct nfs4_stateowner *sop;
4623 struct nfs4_lockowner *lo;
4624 struct nfs4_ol_stateid *stp;
4625 struct xdr_netobj *owner = &rlockowner->rl_owner;
4626 struct list_head matches;
4627 unsigned int hashval = ownerstr_hashval(clid->cl_id, owner);
4628 __be32 status;
4629 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4630
4631 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
4632 clid->cl_boot, clid->cl_id);
4633
4634 nfs4_lock_state();
4635
4636 status = lookup_clientid(clid, cstate->minorversion, nn, NULL);
4637 if (status)
4638 goto out;
4639
4640 status = nfserr_locks_held;
4641 INIT_LIST_HEAD(&matches);
4642
4643 list_for_each_entry(sop, &nn->ownerstr_hashtbl[hashval], so_strhash) {
4644 if (sop->so_is_open_owner)
4645 continue;
4646 if (!same_owner_str(sop, owner, clid))
4647 continue;
4648 list_for_each_entry(stp, &sop->so_stateids,
4649 st_perstateowner) {
4650 lo = lockowner(sop);
4651 if (check_for_locks(stp->st_file, lo))
4652 goto out;
4653 list_add(&lo->lo_list, &matches);
4654 }
4655 }
4656
4657
4658
4659 status = nfs_ok;
4660 while (!list_empty(&matches)) {
4661 lo = list_entry(matches.next, struct nfs4_lockowner,
4662 lo_list);
4663
4664
4665 list_del(&lo->lo_list);
4666 release_lockowner(lo);
4667 }
4668out:
4669 nfs4_unlock_state();
4670 return status;
4671}
4672
4673static inline struct nfs4_client_reclaim *
4674alloc_reclaim(void)
4675{
4676 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
4677}
4678
4679bool
4680nfs4_has_reclaimed_state(const char *name, struct nfsd_net *nn)
4681{
4682 struct nfs4_client_reclaim *crp;
4683
4684 crp = nfsd4_find_reclaim_client(name, nn);
4685 return (crp && crp->cr_clp);
4686}
4687
4688
4689
4690
4691struct nfs4_client_reclaim *
4692nfs4_client_to_reclaim(const char *name, struct nfsd_net *nn)
4693{
4694 unsigned int strhashval;
4695 struct nfs4_client_reclaim *crp;
4696
4697 dprintk("NFSD nfs4_client_to_reclaim NAME: %.*s\n", HEXDIR_LEN, name);
4698 crp = alloc_reclaim();
4699 if (crp) {
4700 strhashval = clientstr_hashval(name);
4701 INIT_LIST_HEAD(&crp->cr_strhash);
4702 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
4703 memcpy(crp->cr_recdir, name, HEXDIR_LEN);
4704 crp->cr_clp = NULL;
4705 nn->reclaim_str_hashtbl_size++;
4706 }
4707 return crp;
4708}
4709
4710void
4711nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
4712{
4713 list_del(&crp->cr_strhash);
4714 kfree(crp);
4715 nn->reclaim_str_hashtbl_size--;
4716}
4717
4718void
4719nfs4_release_reclaim(struct nfsd_net *nn)
4720{
4721 struct nfs4_client_reclaim *crp = NULL;
4722 int i;
4723
4724 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
4725 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
4726 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
4727 struct nfs4_client_reclaim, cr_strhash);
4728 nfs4_remove_reclaim_record(crp, nn);
4729 }
4730 }
4731 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
4732}
4733
4734
4735
4736struct nfs4_client_reclaim *
4737nfsd4_find_reclaim_client(const char *recdir, struct nfsd_net *nn)
4738{
4739 unsigned int strhashval;
4740 struct nfs4_client_reclaim *crp = NULL;
4741
4742 dprintk("NFSD: nfs4_find_reclaim_client for recdir %s\n", recdir);
4743
4744 strhashval = clientstr_hashval(recdir);
4745 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
4746 if (same_name(crp->cr_recdir, recdir)) {
4747 return crp;
4748 }
4749 }
4750 return NULL;
4751}
4752
4753
4754
4755
4756__be32
4757nfs4_check_open_reclaim(clientid_t *clid, bool sessions, struct nfsd_net *nn)
4758{
4759 struct nfs4_client *clp;
4760
4761
4762 clp = find_confirmed_client(clid, sessions, nn);
4763 if (clp == NULL)
4764 return nfserr_reclaim_bad;
4765
4766 return nfsd4_client_record_check(clp) ? nfserr_reclaim_bad : nfs_ok;
4767}
4768
4769#ifdef CONFIG_NFSD_FAULT_INJECTION
4770
4771u64 nfsd_forget_client(struct nfs4_client *clp, u64 max)
4772{
4773 if (mark_client_expired(clp))
4774 return 0;
4775 expire_client(clp);
4776 return 1;
4777}
4778
4779u64 nfsd_print_client(struct nfs4_client *clp, u64 num)
4780{
4781 char buf[INET6_ADDRSTRLEN];
4782 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
4783 printk(KERN_INFO "NFS Client: %s\n", buf);
4784 return 1;
4785}
4786
4787static void nfsd_print_count(struct nfs4_client *clp, unsigned int count,
4788 const char *type)
4789{
4790 char buf[INET6_ADDRSTRLEN];
4791 rpc_ntop((struct sockaddr *)&clp->cl_addr, buf, sizeof(buf));
4792 printk(KERN_INFO "NFS Client: %s has %u %s\n", buf, count, type);
4793}
4794
4795static u64 nfsd_foreach_client_lock(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_lockowner *))
4796{
4797 struct nfs4_openowner *oop;
4798 struct nfs4_lockowner *lop, *lo_next;
4799 struct nfs4_ol_stateid *stp, *st_next;
4800 u64 count = 0;
4801
4802 list_for_each_entry(oop, &clp->cl_openowners, oo_perclient) {
4803 list_for_each_entry_safe(stp, st_next, &oop->oo_owner.so_stateids, st_perstateowner) {
4804 list_for_each_entry_safe(lop, lo_next, &stp->st_lockowners, lo_perstateid) {
4805 if (func)
4806 func(lop);
4807 if (++count == max)
4808 return count;
4809 }
4810 }
4811 }
4812
4813 return count;
4814}
4815
4816u64 nfsd_forget_client_locks(struct nfs4_client *clp, u64 max)
4817{
4818 return nfsd_foreach_client_lock(clp, max, release_lockowner);
4819}
4820
4821u64 nfsd_print_client_locks(struct nfs4_client *clp, u64 max)
4822{
4823 u64 count = nfsd_foreach_client_lock(clp, max, NULL);
4824 nfsd_print_count(clp, count, "locked files");
4825 return count;
4826}
4827
4828static u64 nfsd_foreach_client_open(struct nfs4_client *clp, u64 max, void (*func)(struct nfs4_openowner *))
4829{
4830 struct nfs4_openowner *oop, *next;
4831 u64 count = 0;
4832
4833 list_for_each_entry_safe(oop, next, &clp->cl_openowners, oo_perclient) {
4834 if (func)
4835 func(oop);
4836 if (++count == max)
4837 break;
4838 }
4839
4840 return count;
4841}
4842
4843u64 nfsd_forget_client_openowners(struct nfs4_client *clp, u64 max)
4844{
4845 return nfsd_foreach_client_open(clp, max, release_openowner);
4846}
4847
4848u64 nfsd_print_client_openowners(struct nfs4_client *clp, u64 max)
4849{
4850 u64 count = nfsd_foreach_client_open(clp, max, NULL);
4851 nfsd_print_count(clp, count, "open files");
4852 return count;
4853}
4854
4855static u64 nfsd_find_all_delegations(struct nfs4_client *clp, u64 max,
4856 struct list_head *victims)
4857{
4858 struct nfs4_delegation *dp, *next;
4859 u64 count = 0;
4860
4861 list_for_each_entry_safe(dp, next, &clp->cl_delegations, dl_perclnt) {
4862 if (victims)
4863 list_move(&dp->dl_recall_lru, victims);
4864 if (++count == max)
4865 break;
4866 }
4867 return count;
4868}
4869
4870u64 nfsd_forget_client_delegations(struct nfs4_client *clp, u64 max)
4871{
4872 struct nfs4_delegation *dp, *next;
4873 LIST_HEAD(victims);
4874 u64 count;
4875
4876 spin_lock(&recall_lock);
4877 count = nfsd_find_all_delegations(clp, max, &victims);
4878 spin_unlock(&recall_lock);
4879
4880 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4881 revoke_delegation(dp);
4882
4883 return count;
4884}
4885
4886u64 nfsd_recall_client_delegations(struct nfs4_client *clp, u64 max)
4887{
4888 struct nfs4_delegation *dp, *next;
4889 LIST_HEAD(victims);
4890 u64 count;
4891
4892 spin_lock(&recall_lock);
4893 count = nfsd_find_all_delegations(clp, max, &victims);
4894 list_for_each_entry_safe(dp, next, &victims, dl_recall_lru)
4895 nfsd_break_one_deleg(dp);
4896 spin_unlock(&recall_lock);
4897
4898 return count;
4899}
4900
4901u64 nfsd_print_client_delegations(struct nfs4_client *clp, u64 max)
4902{
4903 u64 count = 0;
4904
4905 spin_lock(&recall_lock);
4906 count = nfsd_find_all_delegations(clp, max, NULL);
4907 spin_unlock(&recall_lock);
4908
4909 nfsd_print_count(clp, count, "delegations");
4910 return count;
4911}
4912
4913u64 nfsd_for_n_state(u64 max, u64 (*func)(struct nfs4_client *, u64))
4914{
4915 struct nfs4_client *clp, *next;
4916 u64 count = 0;
4917 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
4918
4919 if (!nfsd_netns_ready(nn))
4920 return 0;
4921
4922 list_for_each_entry_safe(clp, next, &nn->client_lru, cl_lru) {
4923 count += func(clp, max - count);
4924 if ((max != 0) && (count >= max))
4925 break;
4926 }
4927
4928 return count;
4929}
4930
4931struct nfs4_client *nfsd_find_client(struct sockaddr_storage *addr, size_t addr_size)
4932{
4933 struct nfs4_client *clp;
4934 struct nfsd_net *nn = net_generic(current->nsproxy->net_ns, nfsd_net_id);
4935
4936 if (!nfsd_netns_ready(nn))
4937 return NULL;
4938
4939 list_for_each_entry(clp, &nn->client_lru, cl_lru) {
4940 if (memcmp(&clp->cl_addr, addr, addr_size) == 0)
4941 return clp;
4942 }
4943 return NULL;
4944}
4945
4946#endif
4947
4948
4949
4950void
4951nfs4_state_init(void)
4952{
4953}
4954
4955
4956
4957
4958
4959
4960
4961
4962
4963
4964static void
4965set_max_delegations(void)
4966{
4967
4968
4969
4970
4971
4972
4973 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
4974}
4975
4976static int nfs4_state_create_net(struct net *net)
4977{
4978 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
4979 int i;
4980
4981 nn->conf_id_hashtbl = kmalloc(sizeof(struct list_head) *
4982 CLIENT_HASH_SIZE, GFP_KERNEL);
4983 if (!nn->conf_id_hashtbl)
4984 goto err;
4985 nn->unconf_id_hashtbl = kmalloc(sizeof(struct list_head) *
4986 CLIENT_HASH_SIZE, GFP_KERNEL);
4987 if (!nn->unconf_id_hashtbl)
4988 goto err_unconf_id;
4989 nn->ownerstr_hashtbl = kmalloc(sizeof(struct list_head) *
4990 OWNER_HASH_SIZE, GFP_KERNEL);
4991 if (!nn->ownerstr_hashtbl)
4992 goto err_ownerstr;
4993 nn->lockowner_ino_hashtbl = kmalloc(sizeof(struct list_head) *
4994 LOCKOWNER_INO_HASH_SIZE, GFP_KERNEL);
4995 if (!nn->lockowner_ino_hashtbl)
4996 goto err_lockowner_ino;
4997 nn->sessionid_hashtbl = kmalloc(sizeof(struct list_head) *
4998 SESSION_HASH_SIZE, GFP_KERNEL);
4999 if (!nn->sessionid_hashtbl)
5000 goto err_sessionid;
5001
5002 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5003 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
5004 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
5005 }
5006 for (i = 0; i < OWNER_HASH_SIZE; i++)
5007 INIT_LIST_HEAD(&nn->ownerstr_hashtbl[i]);
5008 for (i = 0; i < LOCKOWNER_INO_HASH_SIZE; i++)
5009 INIT_LIST_HEAD(&nn->lockowner_ino_hashtbl[i]);
5010 for (i = 0; i < SESSION_HASH_SIZE; i++)
5011 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
5012 nn->conf_name_tree = RB_ROOT;
5013 nn->unconf_name_tree = RB_ROOT;
5014 INIT_LIST_HEAD(&nn->client_lru);
5015 INIT_LIST_HEAD(&nn->close_lru);
5016 INIT_LIST_HEAD(&nn->del_recall_lru);
5017 spin_lock_init(&nn->client_lock);
5018
5019 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
5020 get_net(net);
5021
5022 return 0;
5023
5024err_sessionid:
5025 kfree(nn->lockowner_ino_hashtbl);
5026err_lockowner_ino:
5027 kfree(nn->ownerstr_hashtbl);
5028err_ownerstr:
5029 kfree(nn->unconf_id_hashtbl);
5030err_unconf_id:
5031 kfree(nn->conf_id_hashtbl);
5032err:
5033 return -ENOMEM;
5034}
5035
5036static void
5037nfs4_state_destroy_net(struct net *net)
5038{
5039 int i;
5040 struct nfs4_client *clp = NULL;
5041 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5042 struct rb_node *node, *tmp;
5043
5044 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
5045 while (!list_empty(&nn->conf_id_hashtbl[i])) {
5046 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
5047 destroy_client(clp);
5048 }
5049 }
5050
5051 node = rb_first(&nn->unconf_name_tree);
5052 while (node != NULL) {
5053 tmp = node;
5054 node = rb_next(tmp);
5055 clp = rb_entry(tmp, struct nfs4_client, cl_namenode);
5056 rb_erase(tmp, &nn->unconf_name_tree);
5057 destroy_client(clp);
5058 }
5059
5060 kfree(nn->sessionid_hashtbl);
5061 kfree(nn->lockowner_ino_hashtbl);
5062 kfree(nn->ownerstr_hashtbl);
5063 kfree(nn->unconf_id_hashtbl);
5064 kfree(nn->conf_id_hashtbl);
5065 put_net(net);
5066}
5067
5068int
5069nfs4_state_start_net(struct net *net)
5070{
5071 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5072 int ret;
5073
5074 ret = nfs4_state_create_net(net);
5075 if (ret)
5076 return ret;
5077 nfsd4_client_tracking_init(net);
5078 nn->boot_time = get_seconds();
5079 locks_start_grace(net, &nn->nfsd4_manager);
5080 nn->grace_ended = false;
5081 printk(KERN_INFO "NFSD: starting %ld-second grace period (net %p)\n",
5082 nn->nfsd4_grace, net);
5083 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
5084 return 0;
5085}
5086
5087
5088
5089int
5090nfs4_state_start(void)
5091{
5092 int ret;
5093
5094 ret = set_callback_cred();
5095 if (ret)
5096 return -ENOMEM;
5097 laundry_wq = create_singlethread_workqueue("nfsd4");
5098 if (laundry_wq == NULL) {
5099 ret = -ENOMEM;
5100 goto out_recovery;
5101 }
5102 ret = nfsd4_create_callback_queue();
5103 if (ret)
5104 goto out_free_laundry;
5105
5106 set_max_delegations();
5107
5108 return 0;
5109
5110out_free_laundry:
5111 destroy_workqueue(laundry_wq);
5112out_recovery:
5113 return ret;
5114}
5115
5116
5117void
5118nfs4_state_shutdown_net(struct net *net)
5119{
5120 struct nfs4_delegation *dp = NULL;
5121 struct list_head *pos, *next, reaplist;
5122 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
5123
5124 cancel_delayed_work_sync(&nn->laundromat_work);
5125 locks_end_grace(&nn->nfsd4_manager);
5126
5127 INIT_LIST_HEAD(&reaplist);
5128 spin_lock(&recall_lock);
5129 list_for_each_safe(pos, next, &nn->del_recall_lru) {
5130 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5131 list_move(&dp->dl_recall_lru, &reaplist);
5132 }
5133 spin_unlock(&recall_lock);
5134 list_for_each_safe(pos, next, &reaplist) {
5135 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5136 destroy_delegation(dp);
5137 }
5138
5139 nfsd4_client_tracking_exit(net);
5140 nfs4_state_destroy_net(net);
5141}
5142
5143void
5144nfs4_state_shutdown(void)
5145{
5146 destroy_workqueue(laundry_wq);
5147 nfsd4_destroy_callback_queue();
5148}
5149
5150static void
5151get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5152{
5153 if (HAS_STATE_ID(cstate, CURRENT_STATE_ID_FLAG) && CURRENT_STATEID(stateid))
5154 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
5155}
5156
5157static void
5158put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
5159{
5160 if (cstate->minorversion) {
5161 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
5162 SET_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5163 }
5164}
5165
5166void
5167clear_current_stateid(struct nfsd4_compound_state *cstate)
5168{
5169 CLEAR_STATE_ID(cstate, CURRENT_STATE_ID_FLAG);
5170}
5171
5172
5173
5174
5175void
5176nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5177{
5178 put_stateid(cstate, &odp->od_stateid);
5179}
5180
5181void
5182nfsd4_set_openstateid(struct nfsd4_compound_state *cstate, struct nfsd4_open *open)
5183{
5184 put_stateid(cstate, &open->op_stateid);
5185}
5186
5187void
5188nfsd4_set_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5189{
5190 put_stateid(cstate, &close->cl_stateid);
5191}
5192
5193void
5194nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate, struct nfsd4_lock *lock)
5195{
5196 put_stateid(cstate, &lock->lk_resp_stateid);
5197}
5198
5199
5200
5201
5202
5203void
5204nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate, struct nfsd4_open_downgrade *odp)
5205{
5206 get_stateid(cstate, &odp->od_stateid);
5207}
5208
5209void
5210nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate, struct nfsd4_delegreturn *drp)
5211{
5212 get_stateid(cstate, &drp->dr_stateid);
5213}
5214
5215void
5216nfsd4_get_freestateid(struct nfsd4_compound_state *cstate, struct nfsd4_free_stateid *fsp)
5217{
5218 get_stateid(cstate, &fsp->fr_stateid);
5219}
5220
5221void
5222nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate, struct nfsd4_setattr *setattr)
5223{
5224 get_stateid(cstate, &setattr->sa_stateid);
5225}
5226
5227void
5228nfsd4_get_closestateid(struct nfsd4_compound_state *cstate, struct nfsd4_close *close)
5229{
5230 get_stateid(cstate, &close->cl_stateid);
5231}
5232
5233void
5234nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate, struct nfsd4_locku *locku)
5235{
5236 get_stateid(cstate, &locku->lu_stateid);
5237}
5238
5239void
5240nfsd4_get_readstateid(struct nfsd4_compound_state *cstate, struct nfsd4_read *read)
5241{
5242 get_stateid(cstate, &read->rd_stateid);
5243}
5244
5245void
5246nfsd4_get_writestateid(struct nfsd4_compound_state *cstate, struct nfsd4_write *write)
5247{
5248 get_stateid(cstate, &write->wr_stateid);
5249}
5250