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 <linux/jhash.h>
45#include <linux/string_helpers.h>
46#include <linux/fsnotify.h>
47#include <linux/nfs_ssc.h>
48#include "xdr4.h"
49#include "xdr4cb.h"
50#include "vfs.h"
51#include "current_stateid.h"
52
53#include "netns.h"
54#include "pnfs.h"
55#include "filecache.h"
56#include "trace.h"
57
58#define NFSDDBG_FACILITY NFSDDBG_PROC
59
60#define all_ones {{~0,~0},~0}
61static const stateid_t one_stateid = {
62 .si_generation = ~0,
63 .si_opaque = all_ones,
64};
65static const stateid_t zero_stateid = {
66
67};
68static const stateid_t currentstateid = {
69 .si_generation = 1,
70};
71static const stateid_t close_stateid = {
72 .si_generation = 0xffffffffU,
73};
74
75static u64 current_sessionid = 1;
76
77#define ZERO_STATEID(stateid) (!memcmp((stateid), &zero_stateid, sizeof(stateid_t)))
78#define ONE_STATEID(stateid) (!memcmp((stateid), &one_stateid, sizeof(stateid_t)))
79#define CURRENT_STATEID(stateid) (!memcmp((stateid), ¤tstateid, sizeof(stateid_t)))
80#define CLOSE_STATEID(stateid) (!memcmp((stateid), &close_stateid, sizeof(stateid_t)))
81
82
83static bool check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner);
84static void nfs4_free_ol_stateid(struct nfs4_stid *stid);
85void nfsd4_end_grace(struct nfsd_net *nn);
86static void _free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps);
87
88
89
90
91
92
93
94
95static DEFINE_SPINLOCK(state_lock);
96
97enum nfsd4_st_mutex_lock_subclass {
98 OPEN_STATEID_MUTEX = 0,
99 LOCK_STATEID_MUTEX = 1,
100};
101
102
103
104
105
106static DECLARE_WAIT_QUEUE_HEAD(close_wq);
107
108
109
110
111
112
113static DECLARE_WAIT_QUEUE_HEAD(expiry_wq);
114
115static struct kmem_cache *client_slab;
116static struct kmem_cache *openowner_slab;
117static struct kmem_cache *lockowner_slab;
118static struct kmem_cache *file_slab;
119static struct kmem_cache *stateid_slab;
120static struct kmem_cache *deleg_slab;
121static struct kmem_cache *odstate_slab;
122
123static void free_session(struct nfsd4_session *);
124
125static const struct nfsd4_callback_ops nfsd4_cb_recall_ops;
126static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops;
127
128static bool is_session_dead(struct nfsd4_session *ses)
129{
130 return ses->se_flags & NFS4_SESSION_DEAD;
131}
132
133static __be32 mark_session_dead_locked(struct nfsd4_session *ses, int ref_held_by_me)
134{
135 if (atomic_read(&ses->se_ref) > ref_held_by_me)
136 return nfserr_jukebox;
137 ses->se_flags |= NFS4_SESSION_DEAD;
138 return nfs_ok;
139}
140
141static bool is_client_expired(struct nfs4_client *clp)
142{
143 return clp->cl_time == 0;
144}
145
146static __be32 get_client_locked(struct nfs4_client *clp)
147{
148 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
149
150 lockdep_assert_held(&nn->client_lock);
151
152 if (is_client_expired(clp))
153 return nfserr_expired;
154 atomic_inc(&clp->cl_rpc_users);
155 return nfs_ok;
156}
157
158
159static inline void
160renew_client_locked(struct nfs4_client *clp)
161{
162 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
163
164 if (is_client_expired(clp)) {
165 WARN_ON(1);
166 printk("%s: client (clientid %08x/%08x) already expired\n",
167 __func__,
168 clp->cl_clientid.cl_boot,
169 clp->cl_clientid.cl_id);
170 return;
171 }
172
173 list_move_tail(&clp->cl_lru, &nn->client_lru);
174 clp->cl_time = ktime_get_boottime_seconds();
175}
176
177static void put_client_renew_locked(struct nfs4_client *clp)
178{
179 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
180
181 lockdep_assert_held(&nn->client_lock);
182
183 if (!atomic_dec_and_test(&clp->cl_rpc_users))
184 return;
185 if (!is_client_expired(clp))
186 renew_client_locked(clp);
187 else
188 wake_up_all(&expiry_wq);
189}
190
191static void put_client_renew(struct nfs4_client *clp)
192{
193 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
194
195 if (!atomic_dec_and_lock(&clp->cl_rpc_users, &nn->client_lock))
196 return;
197 if (!is_client_expired(clp))
198 renew_client_locked(clp);
199 else
200 wake_up_all(&expiry_wq);
201 spin_unlock(&nn->client_lock);
202}
203
204static __be32 nfsd4_get_session_locked(struct nfsd4_session *ses)
205{
206 __be32 status;
207
208 if (is_session_dead(ses))
209 return nfserr_badsession;
210 status = get_client_locked(ses->se_client);
211 if (status)
212 return status;
213 atomic_inc(&ses->se_ref);
214 return nfs_ok;
215}
216
217static void nfsd4_put_session_locked(struct nfsd4_session *ses)
218{
219 struct nfs4_client *clp = ses->se_client;
220 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
221
222 lockdep_assert_held(&nn->client_lock);
223
224 if (atomic_dec_and_test(&ses->se_ref) && is_session_dead(ses))
225 free_session(ses);
226 put_client_renew_locked(clp);
227}
228
229static void nfsd4_put_session(struct nfsd4_session *ses)
230{
231 struct nfs4_client *clp = ses->se_client;
232 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
233
234 spin_lock(&nn->client_lock);
235 nfsd4_put_session_locked(ses);
236 spin_unlock(&nn->client_lock);
237}
238
239static struct nfsd4_blocked_lock *
240find_blocked_lock(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
241 struct nfsd_net *nn)
242{
243 struct nfsd4_blocked_lock *cur, *found = NULL;
244
245 spin_lock(&nn->blocked_locks_lock);
246 list_for_each_entry(cur, &lo->lo_blocked, nbl_list) {
247 if (fh_match(fh, &cur->nbl_fh)) {
248 list_del_init(&cur->nbl_list);
249 list_del_init(&cur->nbl_lru);
250 found = cur;
251 break;
252 }
253 }
254 spin_unlock(&nn->blocked_locks_lock);
255 if (found)
256 locks_delete_block(&found->nbl_lock);
257 return found;
258}
259
260static struct nfsd4_blocked_lock *
261find_or_allocate_block(struct nfs4_lockowner *lo, struct knfsd_fh *fh,
262 struct nfsd_net *nn)
263{
264 struct nfsd4_blocked_lock *nbl;
265
266 nbl = find_blocked_lock(lo, fh, nn);
267 if (!nbl) {
268 nbl= kmalloc(sizeof(*nbl), GFP_KERNEL);
269 if (nbl) {
270 INIT_LIST_HEAD(&nbl->nbl_list);
271 INIT_LIST_HEAD(&nbl->nbl_lru);
272 fh_copy_shallow(&nbl->nbl_fh, fh);
273 locks_init_lock(&nbl->nbl_lock);
274 nfsd4_init_cb(&nbl->nbl_cb, lo->lo_owner.so_client,
275 &nfsd4_cb_notify_lock_ops,
276 NFSPROC4_CLNT_CB_NOTIFY_LOCK);
277 }
278 }
279 return nbl;
280}
281
282static void
283free_blocked_lock(struct nfsd4_blocked_lock *nbl)
284{
285 locks_delete_block(&nbl->nbl_lock);
286 locks_release_private(&nbl->nbl_lock);
287 kfree(nbl);
288}
289
290static void
291remove_blocked_locks(struct nfs4_lockowner *lo)
292{
293 struct nfs4_client *clp = lo->lo_owner.so_client;
294 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
295 struct nfsd4_blocked_lock *nbl;
296 LIST_HEAD(reaplist);
297
298
299 spin_lock(&nn->blocked_locks_lock);
300 while (!list_empty(&lo->lo_blocked)) {
301 nbl = list_first_entry(&lo->lo_blocked,
302 struct nfsd4_blocked_lock,
303 nbl_list);
304 list_del_init(&nbl->nbl_list);
305 list_move(&nbl->nbl_lru, &reaplist);
306 }
307 spin_unlock(&nn->blocked_locks_lock);
308
309
310 while (!list_empty(&reaplist)) {
311 nbl = list_first_entry(&reaplist, struct nfsd4_blocked_lock,
312 nbl_lru);
313 list_del_init(&nbl->nbl_lru);
314 free_blocked_lock(nbl);
315 }
316}
317
318static void
319nfsd4_cb_notify_lock_prepare(struct nfsd4_callback *cb)
320{
321 struct nfsd4_blocked_lock *nbl = container_of(cb,
322 struct nfsd4_blocked_lock, nbl_cb);
323 locks_delete_block(&nbl->nbl_lock);
324}
325
326static int
327nfsd4_cb_notify_lock_done(struct nfsd4_callback *cb, struct rpc_task *task)
328{
329
330
331
332
333
334 switch (task->tk_status) {
335 case -NFS4ERR_DELAY:
336 rpc_delay(task, 1 * HZ);
337 return 0;
338 default:
339 return 1;
340 }
341}
342
343static void
344nfsd4_cb_notify_lock_release(struct nfsd4_callback *cb)
345{
346 struct nfsd4_blocked_lock *nbl = container_of(cb,
347 struct nfsd4_blocked_lock, nbl_cb);
348
349 free_blocked_lock(nbl);
350}
351
352static const struct nfsd4_callback_ops nfsd4_cb_notify_lock_ops = {
353 .prepare = nfsd4_cb_notify_lock_prepare,
354 .done = nfsd4_cb_notify_lock_done,
355 .release = nfsd4_cb_notify_lock_release,
356};
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376static unsigned int
377bmap_to_share_mode(unsigned long bmap)
378{
379 int i;
380 unsigned int access = 0;
381
382 for (i = 1; i < 4; i++) {
383 if (test_bit(i, &bmap))
384 access |= i;
385 }
386 return access;
387}
388
389
390static inline void
391set_access(u32 access, struct nfs4_ol_stateid *stp)
392{
393 unsigned char mask = 1 << access;
394
395 WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
396 stp->st_access_bmap |= mask;
397}
398
399
400static inline void
401clear_access(u32 access, struct nfs4_ol_stateid *stp)
402{
403 unsigned char mask = 1 << access;
404
405 WARN_ON_ONCE(access > NFS4_SHARE_ACCESS_BOTH);
406 stp->st_access_bmap &= ~mask;
407}
408
409
410static inline bool
411test_access(u32 access, struct nfs4_ol_stateid *stp)
412{
413 unsigned char mask = 1 << access;
414
415 return (bool)(stp->st_access_bmap & mask);
416}
417
418
419static inline void
420set_deny(u32 deny, struct nfs4_ol_stateid *stp)
421{
422 unsigned char mask = 1 << deny;
423
424 WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
425 stp->st_deny_bmap |= mask;
426}
427
428
429static inline void
430clear_deny(u32 deny, struct nfs4_ol_stateid *stp)
431{
432 unsigned char mask = 1 << deny;
433
434 WARN_ON_ONCE(deny > NFS4_SHARE_DENY_BOTH);
435 stp->st_deny_bmap &= ~mask;
436}
437
438
439static inline bool
440test_deny(u32 deny, struct nfs4_ol_stateid *stp)
441{
442 unsigned char mask = 1 << deny;
443
444 return (bool)(stp->st_deny_bmap & mask);
445}
446
447static int nfs4_access_to_omode(u32 access)
448{
449 switch (access & NFS4_SHARE_ACCESS_BOTH) {
450 case NFS4_SHARE_ACCESS_READ:
451 return O_RDONLY;
452 case NFS4_SHARE_ACCESS_WRITE:
453 return O_WRONLY;
454 case NFS4_SHARE_ACCESS_BOTH:
455 return O_RDWR;
456 }
457 WARN_ON_ONCE(1);
458 return O_RDONLY;
459}
460
461static inline int
462access_permit_read(struct nfs4_ol_stateid *stp)
463{
464 return test_access(NFS4_SHARE_ACCESS_READ, stp) ||
465 test_access(NFS4_SHARE_ACCESS_BOTH, stp) ||
466 test_access(NFS4_SHARE_ACCESS_WRITE, stp);
467}
468
469static inline int
470access_permit_write(struct nfs4_ol_stateid *stp)
471{
472 return test_access(NFS4_SHARE_ACCESS_WRITE, stp) ||
473 test_access(NFS4_SHARE_ACCESS_BOTH, stp);
474}
475
476static inline struct nfs4_stateowner *
477nfs4_get_stateowner(struct nfs4_stateowner *sop)
478{
479 atomic_inc(&sop->so_count);
480 return sop;
481}
482
483static int
484same_owner_str(struct nfs4_stateowner *sop, struct xdr_netobj *owner)
485{
486 return (sop->so_owner.len == owner->len) &&
487 0 == memcmp(sop->so_owner.data, owner->data, owner->len);
488}
489
490static struct nfs4_openowner *
491find_openstateowner_str_locked(unsigned int hashval, struct nfsd4_open *open,
492 struct nfs4_client *clp)
493{
494 struct nfs4_stateowner *so;
495
496 lockdep_assert_held(&clp->cl_lock);
497
498 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[hashval],
499 so_strhash) {
500 if (!so->so_is_open_owner)
501 continue;
502 if (same_owner_str(so, &open->op_owner))
503 return openowner(nfs4_get_stateowner(so));
504 }
505 return NULL;
506}
507
508static struct nfs4_openowner *
509find_openstateowner_str(unsigned int hashval, struct nfsd4_open *open,
510 struct nfs4_client *clp)
511{
512 struct nfs4_openowner *oo;
513
514 spin_lock(&clp->cl_lock);
515 oo = find_openstateowner_str_locked(hashval, open, clp);
516 spin_unlock(&clp->cl_lock);
517 return oo;
518}
519
520static inline u32
521opaque_hashval(const void *ptr, int nbytes)
522{
523 unsigned char *cptr = (unsigned char *) ptr;
524
525 u32 x = 0;
526 while (nbytes--) {
527 x *= 37;
528 x += *cptr++;
529 }
530 return x;
531}
532
533static void nfsd4_free_file_rcu(struct rcu_head *rcu)
534{
535 struct nfs4_file *fp = container_of(rcu, struct nfs4_file, fi_rcu);
536
537 kmem_cache_free(file_slab, fp);
538}
539
540void
541put_nfs4_file(struct nfs4_file *fi)
542{
543 might_lock(&state_lock);
544
545 if (refcount_dec_and_lock(&fi->fi_ref, &state_lock)) {
546 hlist_del_rcu(&fi->fi_hash);
547 spin_unlock(&state_lock);
548 WARN_ON_ONCE(!list_empty(&fi->fi_clnt_odstate));
549 WARN_ON_ONCE(!list_empty(&fi->fi_delegations));
550 call_rcu(&fi->fi_rcu, nfsd4_free_file_rcu);
551 }
552}
553
554static struct nfsd_file *
555__nfs4_get_fd(struct nfs4_file *f, int oflag)
556{
557 if (f->fi_fds[oflag])
558 return nfsd_file_get(f->fi_fds[oflag]);
559 return NULL;
560}
561
562static struct nfsd_file *
563find_writeable_file_locked(struct nfs4_file *f)
564{
565 struct nfsd_file *ret;
566
567 lockdep_assert_held(&f->fi_lock);
568
569 ret = __nfs4_get_fd(f, O_WRONLY);
570 if (!ret)
571 ret = __nfs4_get_fd(f, O_RDWR);
572 return ret;
573}
574
575static struct nfsd_file *
576find_writeable_file(struct nfs4_file *f)
577{
578 struct nfsd_file *ret;
579
580 spin_lock(&f->fi_lock);
581 ret = find_writeable_file_locked(f);
582 spin_unlock(&f->fi_lock);
583
584 return ret;
585}
586
587static struct nfsd_file *
588find_readable_file_locked(struct nfs4_file *f)
589{
590 struct nfsd_file *ret;
591
592 lockdep_assert_held(&f->fi_lock);
593
594 ret = __nfs4_get_fd(f, O_RDONLY);
595 if (!ret)
596 ret = __nfs4_get_fd(f, O_RDWR);
597 return ret;
598}
599
600static struct nfsd_file *
601find_readable_file(struct nfs4_file *f)
602{
603 struct nfsd_file *ret;
604
605 spin_lock(&f->fi_lock);
606 ret = find_readable_file_locked(f);
607 spin_unlock(&f->fi_lock);
608
609 return ret;
610}
611
612struct nfsd_file *
613find_any_file(struct nfs4_file *f)
614{
615 struct nfsd_file *ret;
616
617 if (!f)
618 return NULL;
619 spin_lock(&f->fi_lock);
620 ret = __nfs4_get_fd(f, O_RDWR);
621 if (!ret) {
622 ret = __nfs4_get_fd(f, O_WRONLY);
623 if (!ret)
624 ret = __nfs4_get_fd(f, O_RDONLY);
625 }
626 spin_unlock(&f->fi_lock);
627 return ret;
628}
629
630static struct nfsd_file *find_deleg_file(struct nfs4_file *f)
631{
632 struct nfsd_file *ret = NULL;
633
634 spin_lock(&f->fi_lock);
635 if (f->fi_deleg_file)
636 ret = nfsd_file_get(f->fi_deleg_file);
637 spin_unlock(&f->fi_lock);
638 return ret;
639}
640
641static atomic_long_t num_delegations;
642unsigned long max_delegations;
643
644
645
646
647
648
649#define OWNER_HASH_BITS 8
650#define OWNER_HASH_SIZE (1 << OWNER_HASH_BITS)
651#define OWNER_HASH_MASK (OWNER_HASH_SIZE - 1)
652
653static unsigned int ownerstr_hashval(struct xdr_netobj *ownername)
654{
655 unsigned int ret;
656
657 ret = opaque_hashval(ownername->data, ownername->len);
658 return ret & OWNER_HASH_MASK;
659}
660
661
662#define FILE_HASH_BITS 8
663#define FILE_HASH_SIZE (1 << FILE_HASH_BITS)
664
665static unsigned int file_hashval(struct svc_fh *fh)
666{
667 struct inode *inode = d_inode(fh->fh_dentry);
668
669
670 return (unsigned int)hash_long(inode->i_ino, FILE_HASH_BITS);
671}
672
673static struct hlist_head file_hashtbl[FILE_HASH_SIZE];
674
675static void
676__nfs4_file_get_access(struct nfs4_file *fp, u32 access)
677{
678 lockdep_assert_held(&fp->fi_lock);
679
680 if (access & NFS4_SHARE_ACCESS_WRITE)
681 atomic_inc(&fp->fi_access[O_WRONLY]);
682 if (access & NFS4_SHARE_ACCESS_READ)
683 atomic_inc(&fp->fi_access[O_RDONLY]);
684}
685
686static __be32
687nfs4_file_get_access(struct nfs4_file *fp, u32 access)
688{
689 lockdep_assert_held(&fp->fi_lock);
690
691
692 if (access & ~NFS4_SHARE_ACCESS_BOTH)
693 return nfserr_inval;
694
695
696 if ((access & fp->fi_share_deny) != 0)
697 return nfserr_share_denied;
698
699 __nfs4_file_get_access(fp, access);
700 return nfs_ok;
701}
702
703static __be32 nfs4_file_check_deny(struct nfs4_file *fp, u32 deny)
704{
705
706 if (deny) {
707
708 if (deny & ~NFS4_SHARE_DENY_BOTH)
709 return nfserr_inval;
710
711 if ((deny & NFS4_SHARE_DENY_READ) &&
712 atomic_read(&fp->fi_access[O_RDONLY]))
713 return nfserr_share_denied;
714
715 if ((deny & NFS4_SHARE_DENY_WRITE) &&
716 atomic_read(&fp->fi_access[O_WRONLY]))
717 return nfserr_share_denied;
718 }
719 return nfs_ok;
720}
721
722static void __nfs4_file_put_access(struct nfs4_file *fp, int oflag)
723{
724 might_lock(&fp->fi_lock);
725
726 if (atomic_dec_and_lock(&fp->fi_access[oflag], &fp->fi_lock)) {
727 struct nfsd_file *f1 = NULL;
728 struct nfsd_file *f2 = NULL;
729
730 swap(f1, fp->fi_fds[oflag]);
731 if (atomic_read(&fp->fi_access[1 - oflag]) == 0)
732 swap(f2, fp->fi_fds[O_RDWR]);
733 spin_unlock(&fp->fi_lock);
734 if (f1)
735 nfsd_file_put(f1);
736 if (f2)
737 nfsd_file_put(f2);
738 }
739}
740
741static void nfs4_file_put_access(struct nfs4_file *fp, u32 access)
742{
743 WARN_ON_ONCE(access & ~NFS4_SHARE_ACCESS_BOTH);
744
745 if (access & NFS4_SHARE_ACCESS_WRITE)
746 __nfs4_file_put_access(fp, O_WRONLY);
747 if (access & NFS4_SHARE_ACCESS_READ)
748 __nfs4_file_put_access(fp, O_RDONLY);
749}
750
751
752
753
754
755
756
757
758static struct nfs4_clnt_odstate *
759alloc_clnt_odstate(struct nfs4_client *clp)
760{
761 struct nfs4_clnt_odstate *co;
762
763 co = kmem_cache_zalloc(odstate_slab, GFP_KERNEL);
764 if (co) {
765 co->co_client = clp;
766 refcount_set(&co->co_odcount, 1);
767 }
768 return co;
769}
770
771static void
772hash_clnt_odstate_locked(struct nfs4_clnt_odstate *co)
773{
774 struct nfs4_file *fp = co->co_file;
775
776 lockdep_assert_held(&fp->fi_lock);
777 list_add(&co->co_perfile, &fp->fi_clnt_odstate);
778}
779
780static inline void
781get_clnt_odstate(struct nfs4_clnt_odstate *co)
782{
783 if (co)
784 refcount_inc(&co->co_odcount);
785}
786
787static void
788put_clnt_odstate(struct nfs4_clnt_odstate *co)
789{
790 struct nfs4_file *fp;
791
792 if (!co)
793 return;
794
795 fp = co->co_file;
796 if (refcount_dec_and_lock(&co->co_odcount, &fp->fi_lock)) {
797 list_del(&co->co_perfile);
798 spin_unlock(&fp->fi_lock);
799
800 nfsd4_return_all_file_layouts(co->co_client, fp);
801 kmem_cache_free(odstate_slab, co);
802 }
803}
804
805static struct nfs4_clnt_odstate *
806find_or_hash_clnt_odstate(struct nfs4_file *fp, struct nfs4_clnt_odstate *new)
807{
808 struct nfs4_clnt_odstate *co;
809 struct nfs4_client *cl;
810
811 if (!new)
812 return NULL;
813
814 cl = new->co_client;
815
816 spin_lock(&fp->fi_lock);
817 list_for_each_entry(co, &fp->fi_clnt_odstate, co_perfile) {
818 if (co->co_client == cl) {
819 get_clnt_odstate(co);
820 goto out;
821 }
822 }
823 co = new;
824 co->co_file = fp;
825 hash_clnt_odstate_locked(new);
826out:
827 spin_unlock(&fp->fi_lock);
828 return co;
829}
830
831struct nfs4_stid *nfs4_alloc_stid(struct nfs4_client *cl, struct kmem_cache *slab,
832 void (*sc_free)(struct nfs4_stid *))
833{
834 struct nfs4_stid *stid;
835 int new_id;
836
837 stid = kmem_cache_zalloc(slab, GFP_KERNEL);
838 if (!stid)
839 return NULL;
840
841 idr_preload(GFP_KERNEL);
842 spin_lock(&cl->cl_lock);
843
844 new_id = idr_alloc_cyclic(&cl->cl_stateids, stid, 1, 0, GFP_NOWAIT);
845 spin_unlock(&cl->cl_lock);
846 idr_preload_end();
847 if (new_id < 0)
848 goto out_free;
849
850 stid->sc_free = sc_free;
851 stid->sc_client = cl;
852 stid->sc_stateid.si_opaque.so_id = new_id;
853 stid->sc_stateid.si_opaque.so_clid = cl->cl_clientid;
854
855 refcount_set(&stid->sc_count, 1);
856 spin_lock_init(&stid->sc_lock);
857 INIT_LIST_HEAD(&stid->sc_cp_list);
858
859
860
861
862
863
864
865
866
867
868 return stid;
869out_free:
870 kmem_cache_free(slab, stid);
871 return NULL;
872}
873
874
875
876
877static int nfs4_init_cp_state(struct nfsd_net *nn, copy_stateid_t *stid,
878 unsigned char sc_type)
879{
880 int new_id;
881
882 stid->stid.si_opaque.so_clid.cl_boot = (u32)nn->boot_time;
883 stid->stid.si_opaque.so_clid.cl_id = nn->s2s_cp_cl_id;
884 stid->sc_type = sc_type;
885
886 idr_preload(GFP_KERNEL);
887 spin_lock(&nn->s2s_cp_lock);
888 new_id = idr_alloc_cyclic(&nn->s2s_cp_stateids, stid, 0, 0, GFP_NOWAIT);
889 stid->stid.si_opaque.so_id = new_id;
890 stid->stid.si_generation = 1;
891 spin_unlock(&nn->s2s_cp_lock);
892 idr_preload_end();
893 if (new_id < 0)
894 return 0;
895 return 1;
896}
897
898int nfs4_init_copy_state(struct nfsd_net *nn, struct nfsd4_copy *copy)
899{
900 return nfs4_init_cp_state(nn, ©->cp_stateid, NFS4_COPY_STID);
901}
902
903struct nfs4_cpntf_state *nfs4_alloc_init_cpntf_state(struct nfsd_net *nn,
904 struct nfs4_stid *p_stid)
905{
906 struct nfs4_cpntf_state *cps;
907
908 cps = kzalloc(sizeof(struct nfs4_cpntf_state), GFP_KERNEL);
909 if (!cps)
910 return NULL;
911 cps->cpntf_time = ktime_get_boottime_seconds();
912 refcount_set(&cps->cp_stateid.sc_count, 1);
913 if (!nfs4_init_cp_state(nn, &cps->cp_stateid, NFS4_COPYNOTIFY_STID))
914 goto out_free;
915 spin_lock(&nn->s2s_cp_lock);
916 list_add(&cps->cp_list, &p_stid->sc_cp_list);
917 spin_unlock(&nn->s2s_cp_lock);
918 return cps;
919out_free:
920 kfree(cps);
921 return NULL;
922}
923
924void nfs4_free_copy_state(struct nfsd4_copy *copy)
925{
926 struct nfsd_net *nn;
927
928 WARN_ON_ONCE(copy->cp_stateid.sc_type != NFS4_COPY_STID);
929 nn = net_generic(copy->cp_clp->net, nfsd_net_id);
930 spin_lock(&nn->s2s_cp_lock);
931 idr_remove(&nn->s2s_cp_stateids,
932 copy->cp_stateid.stid.si_opaque.so_id);
933 spin_unlock(&nn->s2s_cp_lock);
934}
935
936static void nfs4_free_cpntf_statelist(struct net *net, struct nfs4_stid *stid)
937{
938 struct nfs4_cpntf_state *cps;
939 struct nfsd_net *nn;
940
941 nn = net_generic(net, nfsd_net_id);
942 spin_lock(&nn->s2s_cp_lock);
943 while (!list_empty(&stid->sc_cp_list)) {
944 cps = list_first_entry(&stid->sc_cp_list,
945 struct nfs4_cpntf_state, cp_list);
946 _free_cpntf_state_locked(nn, cps);
947 }
948 spin_unlock(&nn->s2s_cp_lock);
949}
950
951static struct nfs4_ol_stateid * nfs4_alloc_open_stateid(struct nfs4_client *clp)
952{
953 struct nfs4_stid *stid;
954
955 stid = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_ol_stateid);
956 if (!stid)
957 return NULL;
958
959 return openlockstateid(stid);
960}
961
962static void nfs4_free_deleg(struct nfs4_stid *stid)
963{
964 kmem_cache_free(deleg_slab, stid);
965 atomic_long_dec(&num_delegations);
966}
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986static DEFINE_SPINLOCK(blocked_delegations_lock);
987static struct bloom_pair {
988 int entries, old_entries;
989 time64_t swap_time;
990 int new;
991 DECLARE_BITMAP(set[2], 256);
992} blocked_delegations;
993
994static int delegation_blocked(struct knfsd_fh *fh)
995{
996 u32 hash;
997 struct bloom_pair *bd = &blocked_delegations;
998
999 if (bd->entries == 0)
1000 return 0;
1001 if (ktime_get_seconds() - bd->swap_time > 30) {
1002 spin_lock(&blocked_delegations_lock);
1003 if (ktime_get_seconds() - bd->swap_time > 30) {
1004 bd->entries -= bd->old_entries;
1005 bd->old_entries = bd->entries;
1006 memset(bd->set[bd->new], 0,
1007 sizeof(bd->set[0]));
1008 bd->new = 1-bd->new;
1009 bd->swap_time = ktime_get_seconds();
1010 }
1011 spin_unlock(&blocked_delegations_lock);
1012 }
1013 hash = jhash(&fh->fh_base, fh->fh_size, 0);
1014 if (test_bit(hash&255, bd->set[0]) &&
1015 test_bit((hash>>8)&255, bd->set[0]) &&
1016 test_bit((hash>>16)&255, bd->set[0]))
1017 return 1;
1018
1019 if (test_bit(hash&255, bd->set[1]) &&
1020 test_bit((hash>>8)&255, bd->set[1]) &&
1021 test_bit((hash>>16)&255, bd->set[1]))
1022 return 1;
1023
1024 return 0;
1025}
1026
1027static void block_delegations(struct knfsd_fh *fh)
1028{
1029 u32 hash;
1030 struct bloom_pair *bd = &blocked_delegations;
1031
1032 hash = jhash(&fh->fh_base, fh->fh_size, 0);
1033
1034 spin_lock(&blocked_delegations_lock);
1035 __set_bit(hash&255, bd->set[bd->new]);
1036 __set_bit((hash>>8)&255, bd->set[bd->new]);
1037 __set_bit((hash>>16)&255, bd->set[bd->new]);
1038 if (bd->entries == 0)
1039 bd->swap_time = ktime_get_seconds();
1040 bd->entries += 1;
1041 spin_unlock(&blocked_delegations_lock);
1042}
1043
1044static struct nfs4_delegation *
1045alloc_init_deleg(struct nfs4_client *clp, struct nfs4_file *fp,
1046 struct svc_fh *current_fh,
1047 struct nfs4_clnt_odstate *odstate)
1048{
1049 struct nfs4_delegation *dp;
1050 long n;
1051
1052 dprintk("NFSD alloc_init_deleg\n");
1053 n = atomic_long_inc_return(&num_delegations);
1054 if (n < 0 || n > max_delegations)
1055 goto out_dec;
1056 if (delegation_blocked(¤t_fh->fh_handle))
1057 goto out_dec;
1058 dp = delegstateid(nfs4_alloc_stid(clp, deleg_slab, nfs4_free_deleg));
1059 if (dp == NULL)
1060 goto out_dec;
1061
1062
1063
1064
1065
1066
1067 dp->dl_stid.sc_stateid.si_generation = 1;
1068 INIT_LIST_HEAD(&dp->dl_perfile);
1069 INIT_LIST_HEAD(&dp->dl_perclnt);
1070 INIT_LIST_HEAD(&dp->dl_recall_lru);
1071 dp->dl_clnt_odstate = odstate;
1072 get_clnt_odstate(odstate);
1073 dp->dl_type = NFS4_OPEN_DELEGATE_READ;
1074 dp->dl_retries = 1;
1075 nfsd4_init_cb(&dp->dl_recall, dp->dl_stid.sc_client,
1076 &nfsd4_cb_recall_ops, NFSPROC4_CLNT_CB_RECALL);
1077 get_nfs4_file(fp);
1078 dp->dl_stid.sc_file = fp;
1079 return dp;
1080out_dec:
1081 atomic_long_dec(&num_delegations);
1082 return NULL;
1083}
1084
1085void
1086nfs4_put_stid(struct nfs4_stid *s)
1087{
1088 struct nfs4_file *fp = s->sc_file;
1089 struct nfs4_client *clp = s->sc_client;
1090
1091 might_lock(&clp->cl_lock);
1092
1093 if (!refcount_dec_and_lock(&s->sc_count, &clp->cl_lock)) {
1094 wake_up_all(&close_wq);
1095 return;
1096 }
1097 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
1098 nfs4_free_cpntf_statelist(clp->net, s);
1099 spin_unlock(&clp->cl_lock);
1100 s->sc_free(s);
1101 if (fp)
1102 put_nfs4_file(fp);
1103}
1104
1105void
1106nfs4_inc_and_copy_stateid(stateid_t *dst, struct nfs4_stid *stid)
1107{
1108 stateid_t *src = &stid->sc_stateid;
1109
1110 spin_lock(&stid->sc_lock);
1111 if (unlikely(++src->si_generation == 0))
1112 src->si_generation = 1;
1113 memcpy(dst, src, sizeof(*dst));
1114 spin_unlock(&stid->sc_lock);
1115}
1116
1117static void put_deleg_file(struct nfs4_file *fp)
1118{
1119 struct nfsd_file *nf = NULL;
1120
1121 spin_lock(&fp->fi_lock);
1122 if (--fp->fi_delegees == 0)
1123 swap(nf, fp->fi_deleg_file);
1124 spin_unlock(&fp->fi_lock);
1125
1126 if (nf)
1127 nfsd_file_put(nf);
1128}
1129
1130static void nfs4_unlock_deleg_lease(struct nfs4_delegation *dp)
1131{
1132 struct nfs4_file *fp = dp->dl_stid.sc_file;
1133 struct nfsd_file *nf = fp->fi_deleg_file;
1134
1135 WARN_ON_ONCE(!fp->fi_delegees);
1136
1137 vfs_setlease(nf->nf_file, F_UNLCK, NULL, (void **)&dp);
1138 put_deleg_file(fp);
1139}
1140
1141static void destroy_unhashed_deleg(struct nfs4_delegation *dp)
1142{
1143 put_clnt_odstate(dp->dl_clnt_odstate);
1144 nfs4_unlock_deleg_lease(dp);
1145 nfs4_put_stid(&dp->dl_stid);
1146}
1147
1148void nfs4_unhash_stid(struct nfs4_stid *s)
1149{
1150 s->sc_type = 0;
1151}
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162static bool
1163nfs4_delegation_exists(struct nfs4_client *clp, struct nfs4_file *fp)
1164{
1165 struct nfs4_delegation *searchdp = NULL;
1166 struct nfs4_client *searchclp = NULL;
1167
1168 lockdep_assert_held(&state_lock);
1169 lockdep_assert_held(&fp->fi_lock);
1170
1171 list_for_each_entry(searchdp, &fp->fi_delegations, dl_perfile) {
1172 searchclp = searchdp->dl_stid.sc_client;
1173 if (clp == searchclp) {
1174 return true;
1175 }
1176 }
1177 return false;
1178}
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193static int
1194hash_delegation_locked(struct nfs4_delegation *dp, struct nfs4_file *fp)
1195{
1196 struct nfs4_client *clp = dp->dl_stid.sc_client;
1197
1198 lockdep_assert_held(&state_lock);
1199 lockdep_assert_held(&fp->fi_lock);
1200
1201 if (nfs4_delegation_exists(clp, fp))
1202 return -EAGAIN;
1203 refcount_inc(&dp->dl_stid.sc_count);
1204 dp->dl_stid.sc_type = NFS4_DELEG_STID;
1205 list_add(&dp->dl_perfile, &fp->fi_delegations);
1206 list_add(&dp->dl_perclnt, &clp->cl_delegations);
1207 return 0;
1208}
1209
1210static bool
1211unhash_delegation_locked(struct nfs4_delegation *dp)
1212{
1213 struct nfs4_file *fp = dp->dl_stid.sc_file;
1214
1215 lockdep_assert_held(&state_lock);
1216
1217 if (list_empty(&dp->dl_perfile))
1218 return false;
1219
1220 dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
1221
1222 ++dp->dl_time;
1223 spin_lock(&fp->fi_lock);
1224 list_del_init(&dp->dl_perclnt);
1225 list_del_init(&dp->dl_recall_lru);
1226 list_del_init(&dp->dl_perfile);
1227 spin_unlock(&fp->fi_lock);
1228 return true;
1229}
1230
1231static void destroy_delegation(struct nfs4_delegation *dp)
1232{
1233 bool unhashed;
1234
1235 spin_lock(&state_lock);
1236 unhashed = unhash_delegation_locked(dp);
1237 spin_unlock(&state_lock);
1238 if (unhashed)
1239 destroy_unhashed_deleg(dp);
1240}
1241
1242static void revoke_delegation(struct nfs4_delegation *dp)
1243{
1244 struct nfs4_client *clp = dp->dl_stid.sc_client;
1245
1246 WARN_ON(!list_empty(&dp->dl_recall_lru));
1247
1248 if (clp->cl_minorversion) {
1249 dp->dl_stid.sc_type = NFS4_REVOKED_DELEG_STID;
1250 refcount_inc(&dp->dl_stid.sc_count);
1251 spin_lock(&clp->cl_lock);
1252 list_add(&dp->dl_recall_lru, &clp->cl_revoked);
1253 spin_unlock(&clp->cl_lock);
1254 }
1255 destroy_unhashed_deleg(dp);
1256}
1257
1258
1259
1260
1261
1262static unsigned int clientid_hashval(u32 id)
1263{
1264 return id & CLIENT_HASH_MASK;
1265}
1266
1267static unsigned int clientstr_hashval(struct xdr_netobj name)
1268{
1269 return opaque_hashval(name.data, 8) & CLIENT_HASH_MASK;
1270}
1271
1272
1273
1274
1275
1276static void
1277recalculate_deny_mode(struct nfs4_file *fp)
1278{
1279 struct nfs4_ol_stateid *stp;
1280
1281 spin_lock(&fp->fi_lock);
1282 fp->fi_share_deny = 0;
1283 list_for_each_entry(stp, &fp->fi_stateids, st_perfile)
1284 fp->fi_share_deny |= bmap_to_share_mode(stp->st_deny_bmap);
1285 spin_unlock(&fp->fi_lock);
1286}
1287
1288static void
1289reset_union_bmap_deny(u32 deny, struct nfs4_ol_stateid *stp)
1290{
1291 int i;
1292 bool change = false;
1293
1294 for (i = 1; i < 4; i++) {
1295 if ((i & deny) != i) {
1296 change = true;
1297 clear_deny(i, stp);
1298 }
1299 }
1300
1301
1302 if (change)
1303 recalculate_deny_mode(stp->st_stid.sc_file);
1304}
1305
1306
1307static void
1308release_all_access(struct nfs4_ol_stateid *stp)
1309{
1310 int i;
1311 struct nfs4_file *fp = stp->st_stid.sc_file;
1312
1313 if (fp && stp->st_deny_bmap != 0)
1314 recalculate_deny_mode(fp);
1315
1316 for (i = 1; i < 4; i++) {
1317 if (test_access(i, stp))
1318 nfs4_file_put_access(stp->st_stid.sc_file, i);
1319 clear_access(i, stp);
1320 }
1321}
1322
1323static inline void nfs4_free_stateowner(struct nfs4_stateowner *sop)
1324{
1325 kfree(sop->so_owner.data);
1326 sop->so_ops->so_free(sop);
1327}
1328
1329static void nfs4_put_stateowner(struct nfs4_stateowner *sop)
1330{
1331 struct nfs4_client *clp = sop->so_client;
1332
1333 might_lock(&clp->cl_lock);
1334
1335 if (!atomic_dec_and_lock(&sop->so_count, &clp->cl_lock))
1336 return;
1337 sop->so_ops->so_unhash(sop);
1338 spin_unlock(&clp->cl_lock);
1339 nfs4_free_stateowner(sop);
1340}
1341
1342static bool
1343nfs4_ol_stateid_unhashed(const struct nfs4_ol_stateid *stp)
1344{
1345 return list_empty(&stp->st_perfile);
1346}
1347
1348static bool unhash_ol_stateid(struct nfs4_ol_stateid *stp)
1349{
1350 struct nfs4_file *fp = stp->st_stid.sc_file;
1351
1352 lockdep_assert_held(&stp->st_stateowner->so_client->cl_lock);
1353
1354 if (list_empty(&stp->st_perfile))
1355 return false;
1356
1357 spin_lock(&fp->fi_lock);
1358 list_del_init(&stp->st_perfile);
1359 spin_unlock(&fp->fi_lock);
1360 list_del(&stp->st_perstateowner);
1361 return true;
1362}
1363
1364static void nfs4_free_ol_stateid(struct nfs4_stid *stid)
1365{
1366 struct nfs4_ol_stateid *stp = openlockstateid(stid);
1367
1368 put_clnt_odstate(stp->st_clnt_odstate);
1369 release_all_access(stp);
1370 if (stp->st_stateowner)
1371 nfs4_put_stateowner(stp->st_stateowner);
1372 kmem_cache_free(stateid_slab, stid);
1373}
1374
1375static void nfs4_free_lock_stateid(struct nfs4_stid *stid)
1376{
1377 struct nfs4_ol_stateid *stp = openlockstateid(stid);
1378 struct nfs4_lockowner *lo = lockowner(stp->st_stateowner);
1379 struct nfsd_file *nf;
1380
1381 nf = find_any_file(stp->st_stid.sc_file);
1382 if (nf) {
1383 get_file(nf->nf_file);
1384 filp_close(nf->nf_file, (fl_owner_t)lo);
1385 nfsd_file_put(nf);
1386 }
1387 nfs4_free_ol_stateid(stid);
1388}
1389
1390
1391
1392
1393
1394
1395static void put_ol_stateid_locked(struct nfs4_ol_stateid *stp,
1396 struct list_head *reaplist)
1397{
1398 struct nfs4_stid *s = &stp->st_stid;
1399 struct nfs4_client *clp = s->sc_client;
1400
1401 lockdep_assert_held(&clp->cl_lock);
1402
1403 WARN_ON_ONCE(!list_empty(&stp->st_locks));
1404
1405 if (!refcount_dec_and_test(&s->sc_count)) {
1406 wake_up_all(&close_wq);
1407 return;
1408 }
1409
1410 idr_remove(&clp->cl_stateids, s->sc_stateid.si_opaque.so_id);
1411 list_add(&stp->st_locks, reaplist);
1412}
1413
1414static bool unhash_lock_stateid(struct nfs4_ol_stateid *stp)
1415{
1416 lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1417
1418 if (!unhash_ol_stateid(stp))
1419 return false;
1420 list_del_init(&stp->st_locks);
1421 nfs4_unhash_stid(&stp->st_stid);
1422 return true;
1423}
1424
1425static void release_lock_stateid(struct nfs4_ol_stateid *stp)
1426{
1427 struct nfs4_client *clp = stp->st_stid.sc_client;
1428 bool unhashed;
1429
1430 spin_lock(&clp->cl_lock);
1431 unhashed = unhash_lock_stateid(stp);
1432 spin_unlock(&clp->cl_lock);
1433 if (unhashed)
1434 nfs4_put_stid(&stp->st_stid);
1435}
1436
1437static void unhash_lockowner_locked(struct nfs4_lockowner *lo)
1438{
1439 struct nfs4_client *clp = lo->lo_owner.so_client;
1440
1441 lockdep_assert_held(&clp->cl_lock);
1442
1443 list_del_init(&lo->lo_owner.so_strhash);
1444}
1445
1446
1447
1448
1449
1450static void
1451free_ol_stateid_reaplist(struct list_head *reaplist)
1452{
1453 struct nfs4_ol_stateid *stp;
1454 struct nfs4_file *fp;
1455
1456 might_sleep();
1457
1458 while (!list_empty(reaplist)) {
1459 stp = list_first_entry(reaplist, struct nfs4_ol_stateid,
1460 st_locks);
1461 list_del(&stp->st_locks);
1462 fp = stp->st_stid.sc_file;
1463 stp->st_stid.sc_free(&stp->st_stid);
1464 if (fp)
1465 put_nfs4_file(fp);
1466 }
1467}
1468
1469static void release_open_stateid_locks(struct nfs4_ol_stateid *open_stp,
1470 struct list_head *reaplist)
1471{
1472 struct nfs4_ol_stateid *stp;
1473
1474 lockdep_assert_held(&open_stp->st_stid.sc_client->cl_lock);
1475
1476 while (!list_empty(&open_stp->st_locks)) {
1477 stp = list_entry(open_stp->st_locks.next,
1478 struct nfs4_ol_stateid, st_locks);
1479 WARN_ON(!unhash_lock_stateid(stp));
1480 put_ol_stateid_locked(stp, reaplist);
1481 }
1482}
1483
1484static bool unhash_open_stateid(struct nfs4_ol_stateid *stp,
1485 struct list_head *reaplist)
1486{
1487 lockdep_assert_held(&stp->st_stid.sc_client->cl_lock);
1488
1489 if (!unhash_ol_stateid(stp))
1490 return false;
1491 release_open_stateid_locks(stp, reaplist);
1492 return true;
1493}
1494
1495static void release_open_stateid(struct nfs4_ol_stateid *stp)
1496{
1497 LIST_HEAD(reaplist);
1498
1499 spin_lock(&stp->st_stid.sc_client->cl_lock);
1500 if (unhash_open_stateid(stp, &reaplist))
1501 put_ol_stateid_locked(stp, &reaplist);
1502 spin_unlock(&stp->st_stid.sc_client->cl_lock);
1503 free_ol_stateid_reaplist(&reaplist);
1504}
1505
1506static void unhash_openowner_locked(struct nfs4_openowner *oo)
1507{
1508 struct nfs4_client *clp = oo->oo_owner.so_client;
1509
1510 lockdep_assert_held(&clp->cl_lock);
1511
1512 list_del_init(&oo->oo_owner.so_strhash);
1513 list_del_init(&oo->oo_perclient);
1514}
1515
1516static void release_last_closed_stateid(struct nfs4_openowner *oo)
1517{
1518 struct nfsd_net *nn = net_generic(oo->oo_owner.so_client->net,
1519 nfsd_net_id);
1520 struct nfs4_ol_stateid *s;
1521
1522 spin_lock(&nn->client_lock);
1523 s = oo->oo_last_closed_stid;
1524 if (s) {
1525 list_del_init(&oo->oo_close_lru);
1526 oo->oo_last_closed_stid = NULL;
1527 }
1528 spin_unlock(&nn->client_lock);
1529 if (s)
1530 nfs4_put_stid(&s->st_stid);
1531}
1532
1533static void release_openowner(struct nfs4_openowner *oo)
1534{
1535 struct nfs4_ol_stateid *stp;
1536 struct nfs4_client *clp = oo->oo_owner.so_client;
1537 struct list_head reaplist;
1538
1539 INIT_LIST_HEAD(&reaplist);
1540
1541 spin_lock(&clp->cl_lock);
1542 unhash_openowner_locked(oo);
1543 while (!list_empty(&oo->oo_owner.so_stateids)) {
1544 stp = list_first_entry(&oo->oo_owner.so_stateids,
1545 struct nfs4_ol_stateid, st_perstateowner);
1546 if (unhash_open_stateid(stp, &reaplist))
1547 put_ol_stateid_locked(stp, &reaplist);
1548 }
1549 spin_unlock(&clp->cl_lock);
1550 free_ol_stateid_reaplist(&reaplist);
1551 release_last_closed_stateid(oo);
1552 nfs4_put_stateowner(&oo->oo_owner);
1553}
1554
1555static inline int
1556hash_sessionid(struct nfs4_sessionid *sessionid)
1557{
1558 struct nfsd4_sessionid *sid = (struct nfsd4_sessionid *)sessionid;
1559
1560 return sid->sequence % SESSION_HASH_SIZE;
1561}
1562
1563#ifdef CONFIG_SUNRPC_DEBUG
1564static inline void
1565dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1566{
1567 u32 *ptr = (u32 *)(&sessionid->data[0]);
1568 dprintk("%s: %u:%u:%u:%u\n", fn, ptr[0], ptr[1], ptr[2], ptr[3]);
1569}
1570#else
1571static inline void
1572dump_sessionid(const char *fn, struct nfs4_sessionid *sessionid)
1573{
1574}
1575#endif
1576
1577
1578
1579
1580
1581void nfsd4_bump_seqid(struct nfsd4_compound_state *cstate, __be32 nfserr)
1582{
1583 struct nfs4_stateowner *so = cstate->replay_owner;
1584
1585 if (nfserr == nfserr_replay_me)
1586 return;
1587
1588 if (!seqid_mutating_err(ntohl(nfserr))) {
1589 nfsd4_cstate_clear_replay(cstate);
1590 return;
1591 }
1592 if (!so)
1593 return;
1594 if (so->so_is_open_owner)
1595 release_last_closed_stateid(openowner(so));
1596 so->so_seqid++;
1597 return;
1598}
1599
1600static void
1601gen_sessionid(struct nfsd4_session *ses)
1602{
1603 struct nfs4_client *clp = ses->se_client;
1604 struct nfsd4_sessionid *sid;
1605
1606 sid = (struct nfsd4_sessionid *)ses->se_sessionid.data;
1607 sid->clientid = clp->cl_clientid;
1608 sid->sequence = current_sessionid++;
1609 sid->reserved = 0;
1610}
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624#define NFSD_MIN_HDR_SEQ_SZ (24 + 12 + 44)
1625
1626static void
1627free_session_slots(struct nfsd4_session *ses)
1628{
1629 int i;
1630
1631 for (i = 0; i < ses->se_fchannel.maxreqs; i++) {
1632 free_svc_cred(&ses->se_slots[i]->sl_cred);
1633 kfree(ses->se_slots[i]);
1634 }
1635}
1636
1637
1638
1639
1640
1641static inline u32 slot_bytes(struct nfsd4_channel_attrs *ca)
1642{
1643 u32 size;
1644
1645 if (ca->maxresp_cached < NFSD_MIN_HDR_SEQ_SZ)
1646 size = 0;
1647 else
1648 size = ca->maxresp_cached - NFSD_MIN_HDR_SEQ_SZ;
1649 return size + sizeof(struct nfsd4_slot);
1650}
1651
1652
1653
1654
1655
1656
1657static u32 nfsd4_get_drc_mem(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
1658{
1659 u32 slotsize = slot_bytes(ca);
1660 u32 num = ca->maxreqs;
1661 unsigned long avail, total_avail;
1662 unsigned int scale_factor;
1663
1664 spin_lock(&nfsd_drc_lock);
1665 if (nfsd_drc_max_mem > nfsd_drc_mem_used)
1666 total_avail = nfsd_drc_max_mem - nfsd_drc_mem_used;
1667 else
1668
1669
1670
1671
1672
1673 total_avail = 0;
1674 avail = min((unsigned long)NFSD_MAX_MEM_PER_SESSION, total_avail);
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684 scale_factor = max_t(unsigned int, 8, nn->nfsd_serv->sv_nrthreads);
1685
1686 avail = clamp_t(unsigned long, avail, slotsize,
1687 total_avail/scale_factor);
1688 num = min_t(int, num, avail / slotsize);
1689 num = max_t(int, num, 1);
1690 nfsd_drc_mem_used += num * slotsize;
1691 spin_unlock(&nfsd_drc_lock);
1692
1693 return num;
1694}
1695
1696static void nfsd4_put_drc_mem(struct nfsd4_channel_attrs *ca)
1697{
1698 int slotsize = slot_bytes(ca);
1699
1700 spin_lock(&nfsd_drc_lock);
1701 nfsd_drc_mem_used -= slotsize * ca->maxreqs;
1702 spin_unlock(&nfsd_drc_lock);
1703}
1704
1705static struct nfsd4_session *alloc_session(struct nfsd4_channel_attrs *fattrs,
1706 struct nfsd4_channel_attrs *battrs)
1707{
1708 int numslots = fattrs->maxreqs;
1709 int slotsize = slot_bytes(fattrs);
1710 struct nfsd4_session *new;
1711 int mem, i;
1712
1713 BUILD_BUG_ON(NFSD_MAX_SLOTS_PER_SESSION * sizeof(struct nfsd4_slot *)
1714 + sizeof(struct nfsd4_session) > PAGE_SIZE);
1715 mem = numslots * sizeof(struct nfsd4_slot *);
1716
1717 new = kzalloc(sizeof(*new) + mem, GFP_KERNEL);
1718 if (!new)
1719 return NULL;
1720
1721 for (i = 0; i < numslots; i++) {
1722 new->se_slots[i] = kzalloc(slotsize, GFP_KERNEL);
1723 if (!new->se_slots[i])
1724 goto out_free;
1725 }
1726
1727 memcpy(&new->se_fchannel, fattrs, sizeof(struct nfsd4_channel_attrs));
1728 memcpy(&new->se_bchannel, battrs, sizeof(struct nfsd4_channel_attrs));
1729
1730 return new;
1731out_free:
1732 while (i--)
1733 kfree(new->se_slots[i]);
1734 kfree(new);
1735 return NULL;
1736}
1737
1738static void free_conn(struct nfsd4_conn *c)
1739{
1740 svc_xprt_put(c->cn_xprt);
1741 kfree(c);
1742}
1743
1744static void nfsd4_conn_lost(struct svc_xpt_user *u)
1745{
1746 struct nfsd4_conn *c = container_of(u, struct nfsd4_conn, cn_xpt_user);
1747 struct nfs4_client *clp = c->cn_session->se_client;
1748
1749 trace_nfsd_cb_lost(clp);
1750
1751 spin_lock(&clp->cl_lock);
1752 if (!list_empty(&c->cn_persession)) {
1753 list_del(&c->cn_persession);
1754 free_conn(c);
1755 }
1756 nfsd4_probe_callback(clp);
1757 spin_unlock(&clp->cl_lock);
1758}
1759
1760static struct nfsd4_conn *alloc_conn(struct svc_rqst *rqstp, u32 flags)
1761{
1762 struct nfsd4_conn *conn;
1763
1764 conn = kmalloc(sizeof(struct nfsd4_conn), GFP_KERNEL);
1765 if (!conn)
1766 return NULL;
1767 svc_xprt_get(rqstp->rq_xprt);
1768 conn->cn_xprt = rqstp->rq_xprt;
1769 conn->cn_flags = flags;
1770 INIT_LIST_HEAD(&conn->cn_xpt_user.list);
1771 return conn;
1772}
1773
1774static void __nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1775{
1776 conn->cn_session = ses;
1777 list_add(&conn->cn_persession, &ses->se_conns);
1778}
1779
1780static void nfsd4_hash_conn(struct nfsd4_conn *conn, struct nfsd4_session *ses)
1781{
1782 struct nfs4_client *clp = ses->se_client;
1783
1784 spin_lock(&clp->cl_lock);
1785 __nfsd4_hash_conn(conn, ses);
1786 spin_unlock(&clp->cl_lock);
1787}
1788
1789static int nfsd4_register_conn(struct nfsd4_conn *conn)
1790{
1791 conn->cn_xpt_user.callback = nfsd4_conn_lost;
1792 return register_xpt_user(conn->cn_xprt, &conn->cn_xpt_user);
1793}
1794
1795static void nfsd4_init_conn(struct svc_rqst *rqstp, struct nfsd4_conn *conn, struct nfsd4_session *ses)
1796{
1797 int ret;
1798
1799 nfsd4_hash_conn(conn, ses);
1800 ret = nfsd4_register_conn(conn);
1801 if (ret)
1802
1803 nfsd4_conn_lost(&conn->cn_xpt_user);
1804
1805 nfsd4_probe_callback_sync(ses->se_client);
1806}
1807
1808static struct nfsd4_conn *alloc_conn_from_crses(struct svc_rqst *rqstp, struct nfsd4_create_session *cses)
1809{
1810 u32 dir = NFS4_CDFC4_FORE;
1811
1812 if (cses->flags & SESSION4_BACK_CHAN)
1813 dir |= NFS4_CDFC4_BACK;
1814 return alloc_conn(rqstp, dir);
1815}
1816
1817
1818static void nfsd4_del_conns(struct nfsd4_session *s)
1819{
1820 struct nfs4_client *clp = s->se_client;
1821 struct nfsd4_conn *c;
1822
1823 spin_lock(&clp->cl_lock);
1824 while (!list_empty(&s->se_conns)) {
1825 c = list_first_entry(&s->se_conns, struct nfsd4_conn, cn_persession);
1826 list_del_init(&c->cn_persession);
1827 spin_unlock(&clp->cl_lock);
1828
1829 unregister_xpt_user(c->cn_xprt, &c->cn_xpt_user);
1830 free_conn(c);
1831
1832 spin_lock(&clp->cl_lock);
1833 }
1834 spin_unlock(&clp->cl_lock);
1835}
1836
1837static void __free_session(struct nfsd4_session *ses)
1838{
1839 free_session_slots(ses);
1840 kfree(ses);
1841}
1842
1843static void free_session(struct nfsd4_session *ses)
1844{
1845 nfsd4_del_conns(ses);
1846 nfsd4_put_drc_mem(&ses->se_fchannel);
1847 __free_session(ses);
1848}
1849
1850static void init_session(struct svc_rqst *rqstp, struct nfsd4_session *new, struct nfs4_client *clp, struct nfsd4_create_session *cses)
1851{
1852 int idx;
1853 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
1854
1855 new->se_client = clp;
1856 gen_sessionid(new);
1857
1858 INIT_LIST_HEAD(&new->se_conns);
1859
1860 new->se_cb_seq_nr = 1;
1861 new->se_flags = cses->flags;
1862 new->se_cb_prog = cses->callback_prog;
1863 new->se_cb_sec = cses->cb_sec;
1864 atomic_set(&new->se_ref, 0);
1865 idx = hash_sessionid(&new->se_sessionid);
1866 list_add(&new->se_hash, &nn->sessionid_hashtbl[idx]);
1867 spin_lock(&clp->cl_lock);
1868 list_add(&new->se_perclnt, &clp->cl_sessions);
1869 spin_unlock(&clp->cl_lock);
1870
1871 {
1872 struct sockaddr *sa = svc_addr(rqstp);
1873
1874
1875
1876
1877
1878
1879
1880 rpc_copy_addr((struct sockaddr *)&clp->cl_cb_conn.cb_addr, sa);
1881 clp->cl_cb_conn.cb_addrlen = svc_addr_len(sa);
1882 }
1883}
1884
1885
1886static struct nfsd4_session *
1887__find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net)
1888{
1889 struct nfsd4_session *elem;
1890 int idx;
1891 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
1892
1893 lockdep_assert_held(&nn->client_lock);
1894
1895 dump_sessionid(__func__, sessionid);
1896 idx = hash_sessionid(sessionid);
1897
1898 list_for_each_entry(elem, &nn->sessionid_hashtbl[idx], se_hash) {
1899 if (!memcmp(elem->se_sessionid.data, sessionid->data,
1900 NFS4_MAX_SESSIONID_LEN)) {
1901 return elem;
1902 }
1903 }
1904
1905 dprintk("%s: session not found\n", __func__);
1906 return NULL;
1907}
1908
1909static struct nfsd4_session *
1910find_in_sessionid_hashtbl(struct nfs4_sessionid *sessionid, struct net *net,
1911 __be32 *ret)
1912{
1913 struct nfsd4_session *session;
1914 __be32 status = nfserr_badsession;
1915
1916 session = __find_in_sessionid_hashtbl(sessionid, net);
1917 if (!session)
1918 goto out;
1919 status = nfsd4_get_session_locked(session);
1920 if (status)
1921 session = NULL;
1922out:
1923 *ret = status;
1924 return session;
1925}
1926
1927
1928static void
1929unhash_session(struct nfsd4_session *ses)
1930{
1931 struct nfs4_client *clp = ses->se_client;
1932 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
1933
1934 lockdep_assert_held(&nn->client_lock);
1935
1936 list_del(&ses->se_hash);
1937 spin_lock(&ses->se_client->cl_lock);
1938 list_del(&ses->se_perclnt);
1939 spin_unlock(&ses->se_client->cl_lock);
1940}
1941
1942
1943static int
1944STALE_CLIENTID(clientid_t *clid, struct nfsd_net *nn)
1945{
1946
1947
1948
1949
1950
1951 if (clid->cl_boot == (u32)nn->boot_time)
1952 return 0;
1953 trace_nfsd_clid_stale(clid);
1954 return 1;
1955}
1956
1957
1958
1959
1960
1961
1962static struct nfs4_client *alloc_client(struct xdr_netobj name)
1963{
1964 struct nfs4_client *clp;
1965 int i;
1966
1967 clp = kmem_cache_zalloc(client_slab, GFP_KERNEL);
1968 if (clp == NULL)
1969 return NULL;
1970 xdr_netobj_dup(&clp->cl_name, &name, GFP_KERNEL);
1971 if (clp->cl_name.data == NULL)
1972 goto err_no_name;
1973 clp->cl_ownerstr_hashtbl = kmalloc_array(OWNER_HASH_SIZE,
1974 sizeof(struct list_head),
1975 GFP_KERNEL);
1976 if (!clp->cl_ownerstr_hashtbl)
1977 goto err_no_hashtbl;
1978 for (i = 0; i < OWNER_HASH_SIZE; i++)
1979 INIT_LIST_HEAD(&clp->cl_ownerstr_hashtbl[i]);
1980 INIT_LIST_HEAD(&clp->cl_sessions);
1981 idr_init(&clp->cl_stateids);
1982 atomic_set(&clp->cl_rpc_users, 0);
1983 clp->cl_cb_state = NFSD4_CB_UNKNOWN;
1984 INIT_LIST_HEAD(&clp->cl_idhash);
1985 INIT_LIST_HEAD(&clp->cl_openowners);
1986 INIT_LIST_HEAD(&clp->cl_delegations);
1987 INIT_LIST_HEAD(&clp->cl_lru);
1988 INIT_LIST_HEAD(&clp->cl_revoked);
1989#ifdef CONFIG_NFSD_PNFS
1990 INIT_LIST_HEAD(&clp->cl_lo_states);
1991#endif
1992 INIT_LIST_HEAD(&clp->async_copies);
1993 spin_lock_init(&clp->async_lock);
1994 spin_lock_init(&clp->cl_lock);
1995 rpc_init_wait_queue(&clp->cl_cb_waitq, "Backchannel slot table");
1996 return clp;
1997err_no_hashtbl:
1998 kfree(clp->cl_name.data);
1999err_no_name:
2000 kmem_cache_free(client_slab, clp);
2001 return NULL;
2002}
2003
2004static void __free_client(struct kref *k)
2005{
2006 struct nfsdfs_client *c = container_of(k, struct nfsdfs_client, cl_ref);
2007 struct nfs4_client *clp = container_of(c, struct nfs4_client, cl_nfsdfs);
2008
2009 free_svc_cred(&clp->cl_cred);
2010 kfree(clp->cl_ownerstr_hashtbl);
2011 kfree(clp->cl_name.data);
2012 kfree(clp->cl_nii_domain.data);
2013 kfree(clp->cl_nii_name.data);
2014 idr_destroy(&clp->cl_stateids);
2015 kmem_cache_free(client_slab, clp);
2016}
2017
2018static void drop_client(struct nfs4_client *clp)
2019{
2020 kref_put(&clp->cl_nfsdfs.cl_ref, __free_client);
2021}
2022
2023static void
2024free_client(struct nfs4_client *clp)
2025{
2026 while (!list_empty(&clp->cl_sessions)) {
2027 struct nfsd4_session *ses;
2028 ses = list_entry(clp->cl_sessions.next, struct nfsd4_session,
2029 se_perclnt);
2030 list_del(&ses->se_perclnt);
2031 WARN_ON_ONCE(atomic_read(&ses->se_ref));
2032 free_session(ses);
2033 }
2034 rpc_destroy_wait_queue(&clp->cl_cb_waitq);
2035 if (clp->cl_nfsd_dentry) {
2036 nfsd_client_rmdir(clp->cl_nfsd_dentry);
2037 clp->cl_nfsd_dentry = NULL;
2038 wake_up_all(&expiry_wq);
2039 }
2040 drop_client(clp);
2041}
2042
2043
2044static void
2045unhash_client_locked(struct nfs4_client *clp)
2046{
2047 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2048 struct nfsd4_session *ses;
2049
2050 lockdep_assert_held(&nn->client_lock);
2051
2052
2053 clp->cl_time = 0;
2054
2055 if (!list_empty(&clp->cl_idhash)) {
2056 list_del_init(&clp->cl_idhash);
2057 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
2058 rb_erase(&clp->cl_namenode, &nn->conf_name_tree);
2059 else
2060 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2061 }
2062 list_del_init(&clp->cl_lru);
2063 spin_lock(&clp->cl_lock);
2064 list_for_each_entry(ses, &clp->cl_sessions, se_perclnt)
2065 list_del_init(&ses->se_hash);
2066 spin_unlock(&clp->cl_lock);
2067}
2068
2069static void
2070unhash_client(struct nfs4_client *clp)
2071{
2072 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2073
2074 spin_lock(&nn->client_lock);
2075 unhash_client_locked(clp);
2076 spin_unlock(&nn->client_lock);
2077}
2078
2079static __be32 mark_client_expired_locked(struct nfs4_client *clp)
2080{
2081 if (atomic_read(&clp->cl_rpc_users))
2082 return nfserr_jukebox;
2083 unhash_client_locked(clp);
2084 return nfs_ok;
2085}
2086
2087static void
2088__destroy_client(struct nfs4_client *clp)
2089{
2090 int i;
2091 struct nfs4_openowner *oo;
2092 struct nfs4_delegation *dp;
2093 struct list_head reaplist;
2094
2095 INIT_LIST_HEAD(&reaplist);
2096 spin_lock(&state_lock);
2097 while (!list_empty(&clp->cl_delegations)) {
2098 dp = list_entry(clp->cl_delegations.next, struct nfs4_delegation, dl_perclnt);
2099 WARN_ON(!unhash_delegation_locked(dp));
2100 list_add(&dp->dl_recall_lru, &reaplist);
2101 }
2102 spin_unlock(&state_lock);
2103 while (!list_empty(&reaplist)) {
2104 dp = list_entry(reaplist.next, struct nfs4_delegation, dl_recall_lru);
2105 list_del_init(&dp->dl_recall_lru);
2106 destroy_unhashed_deleg(dp);
2107 }
2108 while (!list_empty(&clp->cl_revoked)) {
2109 dp = list_entry(clp->cl_revoked.next, struct nfs4_delegation, dl_recall_lru);
2110 list_del_init(&dp->dl_recall_lru);
2111 nfs4_put_stid(&dp->dl_stid);
2112 }
2113 while (!list_empty(&clp->cl_openowners)) {
2114 oo = list_entry(clp->cl_openowners.next, struct nfs4_openowner, oo_perclient);
2115 nfs4_get_stateowner(&oo->oo_owner);
2116 release_openowner(oo);
2117 }
2118 for (i = 0; i < OWNER_HASH_SIZE; i++) {
2119 struct nfs4_stateowner *so, *tmp;
2120
2121 list_for_each_entry_safe(so, tmp, &clp->cl_ownerstr_hashtbl[i],
2122 so_strhash) {
2123
2124 WARN_ON_ONCE(so->so_is_open_owner);
2125 remove_blocked_locks(lockowner(so));
2126 }
2127 }
2128 nfsd4_return_all_client_layouts(clp);
2129 nfsd4_shutdown_copy(clp);
2130 nfsd4_shutdown_callback(clp);
2131 if (clp->cl_cb_conn.cb_xprt)
2132 svc_xprt_put(clp->cl_cb_conn.cb_xprt);
2133 free_client(clp);
2134 wake_up_all(&expiry_wq);
2135}
2136
2137static void
2138destroy_client(struct nfs4_client *clp)
2139{
2140 unhash_client(clp);
2141 __destroy_client(clp);
2142}
2143
2144static void inc_reclaim_complete(struct nfs4_client *clp)
2145{
2146 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2147
2148 if (!nn->track_reclaim_completes)
2149 return;
2150 if (!nfsd4_find_reclaim_client(clp->cl_name, nn))
2151 return;
2152 if (atomic_inc_return(&nn->nr_reclaim_complete) ==
2153 nn->reclaim_str_hashtbl_size) {
2154 printk(KERN_INFO "NFSD: all clients done reclaiming, ending NFSv4 grace period (net %x)\n",
2155 clp->net->ns.inum);
2156 nfsd4_end_grace(nn);
2157 }
2158}
2159
2160static void expire_client(struct nfs4_client *clp)
2161{
2162 unhash_client(clp);
2163 nfsd4_client_record_remove(clp);
2164 __destroy_client(clp);
2165}
2166
2167static void copy_verf(struct nfs4_client *target, nfs4_verifier *source)
2168{
2169 memcpy(target->cl_verifier.data, source->data,
2170 sizeof(target->cl_verifier.data));
2171}
2172
2173static void copy_clid(struct nfs4_client *target, struct nfs4_client *source)
2174{
2175 target->cl_clientid.cl_boot = source->cl_clientid.cl_boot;
2176 target->cl_clientid.cl_id = source->cl_clientid.cl_id;
2177}
2178
2179static int copy_cred(struct svc_cred *target, struct svc_cred *source)
2180{
2181 target->cr_principal = kstrdup(source->cr_principal, GFP_KERNEL);
2182 target->cr_raw_principal = kstrdup(source->cr_raw_principal,
2183 GFP_KERNEL);
2184 target->cr_targ_princ = kstrdup(source->cr_targ_princ, GFP_KERNEL);
2185 if ((source->cr_principal && !target->cr_principal) ||
2186 (source->cr_raw_principal && !target->cr_raw_principal) ||
2187 (source->cr_targ_princ && !target->cr_targ_princ))
2188 return -ENOMEM;
2189
2190 target->cr_flavor = source->cr_flavor;
2191 target->cr_uid = source->cr_uid;
2192 target->cr_gid = source->cr_gid;
2193 target->cr_group_info = source->cr_group_info;
2194 get_group_info(target->cr_group_info);
2195 target->cr_gss_mech = source->cr_gss_mech;
2196 if (source->cr_gss_mech)
2197 gss_mech_get(source->cr_gss_mech);
2198 return 0;
2199}
2200
2201static int
2202compare_blob(const struct xdr_netobj *o1, const struct xdr_netobj *o2)
2203{
2204 if (o1->len < o2->len)
2205 return -1;
2206 if (o1->len > o2->len)
2207 return 1;
2208 return memcmp(o1->data, o2->data, o1->len);
2209}
2210
2211static int
2212same_verf(nfs4_verifier *v1, nfs4_verifier *v2)
2213{
2214 return 0 == memcmp(v1->data, v2->data, sizeof(v1->data));
2215}
2216
2217static int
2218same_clid(clientid_t *cl1, clientid_t *cl2)
2219{
2220 return (cl1->cl_boot == cl2->cl_boot) && (cl1->cl_id == cl2->cl_id);
2221}
2222
2223static bool groups_equal(struct group_info *g1, struct group_info *g2)
2224{
2225 int i;
2226
2227 if (g1->ngroups != g2->ngroups)
2228 return false;
2229 for (i=0; i<g1->ngroups; i++)
2230 if (!gid_eq(g1->gid[i], g2->gid[i]))
2231 return false;
2232 return true;
2233}
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244static bool is_gss_cred(struct svc_cred *cr)
2245{
2246
2247 return (cr->cr_flavor > RPC_AUTH_MAXFLAVOR);
2248}
2249
2250
2251static bool
2252same_creds(struct svc_cred *cr1, struct svc_cred *cr2)
2253{
2254 if ((is_gss_cred(cr1) != is_gss_cred(cr2))
2255 || (!uid_eq(cr1->cr_uid, cr2->cr_uid))
2256 || (!gid_eq(cr1->cr_gid, cr2->cr_gid))
2257 || !groups_equal(cr1->cr_group_info, cr2->cr_group_info))
2258 return false;
2259
2260 if (cr1->cr_principal == cr2->cr_principal)
2261 return true;
2262 if (!cr1->cr_principal || !cr2->cr_principal)
2263 return false;
2264 return 0 == strcmp(cr1->cr_principal, cr2->cr_principal);
2265}
2266
2267static bool svc_rqst_integrity_protected(struct svc_rqst *rqstp)
2268{
2269 struct svc_cred *cr = &rqstp->rq_cred;
2270 u32 service;
2271
2272 if (!cr->cr_gss_mech)
2273 return false;
2274 service = gss_pseudoflavor_to_service(cr->cr_gss_mech, cr->cr_flavor);
2275 return service == RPC_GSS_SVC_INTEGRITY ||
2276 service == RPC_GSS_SVC_PRIVACY;
2277}
2278
2279bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp)
2280{
2281 struct svc_cred *cr = &rqstp->rq_cred;
2282
2283 if (!cl->cl_mach_cred)
2284 return true;
2285 if (cl->cl_cred.cr_gss_mech != cr->cr_gss_mech)
2286 return false;
2287 if (!svc_rqst_integrity_protected(rqstp))
2288 return false;
2289 if (cl->cl_cred.cr_raw_principal)
2290 return 0 == strcmp(cl->cl_cred.cr_raw_principal,
2291 cr->cr_raw_principal);
2292 if (!cr->cr_principal)
2293 return false;
2294 return 0 == strcmp(cl->cl_cred.cr_principal, cr->cr_principal);
2295}
2296
2297static void gen_confirm(struct nfs4_client *clp, struct nfsd_net *nn)
2298{
2299 __be32 verf[2];
2300
2301
2302
2303
2304
2305 verf[0] = (__force __be32)(u32)ktime_get_real_seconds();
2306 verf[1] = (__force __be32)nn->clverifier_counter++;
2307 memcpy(clp->cl_confirm.data, verf, sizeof(clp->cl_confirm.data));
2308}
2309
2310static void gen_clid(struct nfs4_client *clp, struct nfsd_net *nn)
2311{
2312 clp->cl_clientid.cl_boot = (u32)nn->boot_time;
2313 clp->cl_clientid.cl_id = nn->clientid_counter++;
2314 gen_confirm(clp, nn);
2315}
2316
2317static struct nfs4_stid *
2318find_stateid_locked(struct nfs4_client *cl, stateid_t *t)
2319{
2320 struct nfs4_stid *ret;
2321
2322 ret = idr_find(&cl->cl_stateids, t->si_opaque.so_id);
2323 if (!ret || !ret->sc_type)
2324 return NULL;
2325 return ret;
2326}
2327
2328static struct nfs4_stid *
2329find_stateid_by_type(struct nfs4_client *cl, stateid_t *t, char typemask)
2330{
2331 struct nfs4_stid *s;
2332
2333 spin_lock(&cl->cl_lock);
2334 s = find_stateid_locked(cl, t);
2335 if (s != NULL) {
2336 if (typemask & s->sc_type)
2337 refcount_inc(&s->sc_count);
2338 else
2339 s = NULL;
2340 }
2341 spin_unlock(&cl->cl_lock);
2342 return s;
2343}
2344
2345static struct nfs4_client *get_nfsdfs_clp(struct inode *inode)
2346{
2347 struct nfsdfs_client *nc;
2348 nc = get_nfsdfs_client(inode);
2349 if (!nc)
2350 return NULL;
2351 return container_of(nc, struct nfs4_client, cl_nfsdfs);
2352}
2353
2354static void seq_quote_mem(struct seq_file *m, char *data, int len)
2355{
2356 seq_printf(m, "\"");
2357 seq_escape_mem(m, data, len, ESCAPE_HEX | ESCAPE_NAP | ESCAPE_APPEND, "\"\\");
2358 seq_printf(m, "\"");
2359}
2360
2361static const char *cb_state2str(int state)
2362{
2363 switch (state) {
2364 case NFSD4_CB_UP:
2365 return "UP";
2366 case NFSD4_CB_UNKNOWN:
2367 return "UNKNOWN";
2368 case NFSD4_CB_DOWN:
2369 return "DOWN";
2370 case NFSD4_CB_FAULT:
2371 return "FAULT";
2372 }
2373 return "UNDEFINED";
2374}
2375
2376static int client_info_show(struct seq_file *m, void *v)
2377{
2378 struct inode *inode = m->private;
2379 struct nfs4_client *clp;
2380 u64 clid;
2381
2382 clp = get_nfsdfs_clp(inode);
2383 if (!clp)
2384 return -ENXIO;
2385 memcpy(&clid, &clp->cl_clientid, sizeof(clid));
2386 seq_printf(m, "clientid: 0x%llx\n", clid);
2387 seq_printf(m, "address: \"%pISpc\"\n", (struct sockaddr *)&clp->cl_addr);
2388 if (test_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags))
2389 seq_puts(m, "status: confirmed\n");
2390 else
2391 seq_puts(m, "status: unconfirmed\n");
2392 seq_printf(m, "name: ");
2393 seq_quote_mem(m, clp->cl_name.data, clp->cl_name.len);
2394 seq_printf(m, "\nminor version: %d\n", clp->cl_minorversion);
2395 if (clp->cl_nii_domain.data) {
2396 seq_printf(m, "Implementation domain: ");
2397 seq_quote_mem(m, clp->cl_nii_domain.data,
2398 clp->cl_nii_domain.len);
2399 seq_printf(m, "\nImplementation name: ");
2400 seq_quote_mem(m, clp->cl_nii_name.data, clp->cl_nii_name.len);
2401 seq_printf(m, "\nImplementation time: [%lld, %ld]\n",
2402 clp->cl_nii_time.tv_sec, clp->cl_nii_time.tv_nsec);
2403 }
2404 seq_printf(m, "callback state: %s\n", cb_state2str(clp->cl_cb_state));
2405 seq_printf(m, "callback address: %pISpc\n", &clp->cl_cb_conn.cb_addr);
2406 drop_client(clp);
2407
2408 return 0;
2409}
2410
2411static int client_info_open(struct inode *inode, struct file *file)
2412{
2413 return single_open(file, client_info_show, inode);
2414}
2415
2416static const struct file_operations client_info_fops = {
2417 .open = client_info_open,
2418 .read = seq_read,
2419 .llseek = seq_lseek,
2420 .release = single_release,
2421};
2422
2423static void *states_start(struct seq_file *s, loff_t *pos)
2424 __acquires(&clp->cl_lock)
2425{
2426 struct nfs4_client *clp = s->private;
2427 unsigned long id = *pos;
2428 void *ret;
2429
2430 spin_lock(&clp->cl_lock);
2431 ret = idr_get_next_ul(&clp->cl_stateids, &id);
2432 *pos = id;
2433 return ret;
2434}
2435
2436static void *states_next(struct seq_file *s, void *v, loff_t *pos)
2437{
2438 struct nfs4_client *clp = s->private;
2439 unsigned long id = *pos;
2440 void *ret;
2441
2442 id = *pos;
2443 id++;
2444 ret = idr_get_next_ul(&clp->cl_stateids, &id);
2445 *pos = id;
2446 return ret;
2447}
2448
2449static void states_stop(struct seq_file *s, void *v)
2450 __releases(&clp->cl_lock)
2451{
2452 struct nfs4_client *clp = s->private;
2453
2454 spin_unlock(&clp->cl_lock);
2455}
2456
2457static void nfs4_show_fname(struct seq_file *s, struct nfsd_file *f)
2458{
2459 seq_printf(s, "filename: \"%pD2\"", f->nf_file);
2460}
2461
2462static void nfs4_show_superblock(struct seq_file *s, struct nfsd_file *f)
2463{
2464 struct inode *inode = f->nf_inode;
2465
2466 seq_printf(s, "superblock: \"%02x:%02x:%ld\"",
2467 MAJOR(inode->i_sb->s_dev),
2468 MINOR(inode->i_sb->s_dev),
2469 inode->i_ino);
2470}
2471
2472static void nfs4_show_owner(struct seq_file *s, struct nfs4_stateowner *oo)
2473{
2474 seq_printf(s, "owner: ");
2475 seq_quote_mem(s, oo->so_owner.data, oo->so_owner.len);
2476}
2477
2478static void nfs4_show_stateid(struct seq_file *s, stateid_t *stid)
2479{
2480 seq_printf(s, "0x%.8x", stid->si_generation);
2481 seq_printf(s, "%12phN", &stid->si_opaque);
2482}
2483
2484static int nfs4_show_open(struct seq_file *s, struct nfs4_stid *st)
2485{
2486 struct nfs4_ol_stateid *ols;
2487 struct nfs4_file *nf;
2488 struct nfsd_file *file;
2489 struct nfs4_stateowner *oo;
2490 unsigned int access, deny;
2491
2492 if (st->sc_type != NFS4_OPEN_STID && st->sc_type != NFS4_LOCK_STID)
2493 return 0;
2494 ols = openlockstateid(st);
2495 oo = ols->st_stateowner;
2496 nf = st->sc_file;
2497 file = find_any_file(nf);
2498 if (!file)
2499 return 0;
2500
2501 seq_printf(s, "- ");
2502 nfs4_show_stateid(s, &st->sc_stateid);
2503 seq_printf(s, ": { type: open, ");
2504
2505 access = bmap_to_share_mode(ols->st_access_bmap);
2506 deny = bmap_to_share_mode(ols->st_deny_bmap);
2507
2508 seq_printf(s, "access: %s%s, ",
2509 access & NFS4_SHARE_ACCESS_READ ? "r" : "-",
2510 access & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
2511 seq_printf(s, "deny: %s%s, ",
2512 deny & NFS4_SHARE_ACCESS_READ ? "r" : "-",
2513 deny & NFS4_SHARE_ACCESS_WRITE ? "w" : "-");
2514
2515 nfs4_show_superblock(s, file);
2516 seq_printf(s, ", ");
2517 nfs4_show_fname(s, file);
2518 seq_printf(s, ", ");
2519 nfs4_show_owner(s, oo);
2520 seq_printf(s, " }\n");
2521 nfsd_file_put(file);
2522
2523 return 0;
2524}
2525
2526static int nfs4_show_lock(struct seq_file *s, struct nfs4_stid *st)
2527{
2528 struct nfs4_ol_stateid *ols;
2529 struct nfs4_file *nf;
2530 struct nfsd_file *file;
2531 struct nfs4_stateowner *oo;
2532
2533 ols = openlockstateid(st);
2534 oo = ols->st_stateowner;
2535 nf = st->sc_file;
2536 file = find_any_file(nf);
2537 if (!file)
2538 return 0;
2539
2540 seq_printf(s, "- ");
2541 nfs4_show_stateid(s, &st->sc_stateid);
2542 seq_printf(s, ": { type: lock, ");
2543
2544
2545
2546
2547
2548
2549
2550
2551 nfs4_show_superblock(s, file);
2552
2553 seq_printf(s, ", ");
2554 nfs4_show_fname(s, file);
2555 seq_printf(s, ", ");
2556 nfs4_show_owner(s, oo);
2557 seq_printf(s, " }\n");
2558 nfsd_file_put(file);
2559
2560 return 0;
2561}
2562
2563static int nfs4_show_deleg(struct seq_file *s, struct nfs4_stid *st)
2564{
2565 struct nfs4_delegation *ds;
2566 struct nfs4_file *nf;
2567 struct nfsd_file *file;
2568
2569 ds = delegstateid(st);
2570 nf = st->sc_file;
2571 file = find_deleg_file(nf);
2572 if (!file)
2573 return 0;
2574
2575 seq_printf(s, "- ");
2576 nfs4_show_stateid(s, &st->sc_stateid);
2577 seq_printf(s, ": { type: deleg, ");
2578
2579
2580 seq_printf(s, "access: %s, ",
2581 ds->dl_type == NFS4_OPEN_DELEGATE_READ ? "r" : "w");
2582
2583
2584
2585 nfs4_show_superblock(s, file);
2586 seq_printf(s, ", ");
2587 nfs4_show_fname(s, file);
2588 seq_printf(s, " }\n");
2589 nfsd_file_put(file);
2590
2591 return 0;
2592}
2593
2594static int nfs4_show_layout(struct seq_file *s, struct nfs4_stid *st)
2595{
2596 struct nfs4_layout_stateid *ls;
2597 struct nfsd_file *file;
2598
2599 ls = container_of(st, struct nfs4_layout_stateid, ls_stid);
2600 file = ls->ls_file;
2601
2602 seq_printf(s, "- ");
2603 nfs4_show_stateid(s, &st->sc_stateid);
2604 seq_printf(s, ": { type: layout, ");
2605
2606
2607
2608 nfs4_show_superblock(s, file);
2609 seq_printf(s, ", ");
2610 nfs4_show_fname(s, file);
2611 seq_printf(s, " }\n");
2612
2613 return 0;
2614}
2615
2616static int states_show(struct seq_file *s, void *v)
2617{
2618 struct nfs4_stid *st = v;
2619
2620 switch (st->sc_type) {
2621 case NFS4_OPEN_STID:
2622 return nfs4_show_open(s, st);
2623 case NFS4_LOCK_STID:
2624 return nfs4_show_lock(s, st);
2625 case NFS4_DELEG_STID:
2626 return nfs4_show_deleg(s, st);
2627 case NFS4_LAYOUT_STID:
2628 return nfs4_show_layout(s, st);
2629 default:
2630 return 0;
2631 }
2632
2633}
2634
2635static struct seq_operations states_seq_ops = {
2636 .start = states_start,
2637 .next = states_next,
2638 .stop = states_stop,
2639 .show = states_show
2640};
2641
2642static int client_states_open(struct inode *inode, struct file *file)
2643{
2644 struct seq_file *s;
2645 struct nfs4_client *clp;
2646 int ret;
2647
2648 clp = get_nfsdfs_clp(inode);
2649 if (!clp)
2650 return -ENXIO;
2651
2652 ret = seq_open(file, &states_seq_ops);
2653 if (ret)
2654 return ret;
2655 s = file->private_data;
2656 s->private = clp;
2657 return 0;
2658}
2659
2660static int client_opens_release(struct inode *inode, struct file *file)
2661{
2662 struct seq_file *m = file->private_data;
2663 struct nfs4_client *clp = m->private;
2664
2665
2666 drop_client(clp);
2667 return 0;
2668}
2669
2670static const struct file_operations client_states_fops = {
2671 .open = client_states_open,
2672 .read = seq_read,
2673 .llseek = seq_lseek,
2674 .release = client_opens_release,
2675};
2676
2677
2678
2679
2680
2681
2682
2683static void force_expire_client(struct nfs4_client *clp)
2684{
2685 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2686 bool already_expired;
2687
2688 trace_nfsd_clid_admin_expired(&clp->cl_clientid);
2689
2690 spin_lock(&nn->client_lock);
2691 clp->cl_time = 0;
2692 spin_unlock(&nn->client_lock);
2693
2694 wait_event(expiry_wq, atomic_read(&clp->cl_rpc_users) == 0);
2695 spin_lock(&nn->client_lock);
2696 already_expired = list_empty(&clp->cl_lru);
2697 if (!already_expired)
2698 unhash_client_locked(clp);
2699 spin_unlock(&nn->client_lock);
2700
2701 if (!already_expired)
2702 expire_client(clp);
2703 else
2704 wait_event(expiry_wq, clp->cl_nfsd_dentry == NULL);
2705}
2706
2707static ssize_t client_ctl_write(struct file *file, const char __user *buf,
2708 size_t size, loff_t *pos)
2709{
2710 char *data;
2711 struct nfs4_client *clp;
2712
2713 data = simple_transaction_get(file, buf, size);
2714 if (IS_ERR(data))
2715 return PTR_ERR(data);
2716 if (size != 7 || 0 != memcmp(data, "expire\n", 7))
2717 return -EINVAL;
2718 clp = get_nfsdfs_clp(file_inode(file));
2719 if (!clp)
2720 return -ENXIO;
2721 force_expire_client(clp);
2722 drop_client(clp);
2723 return 7;
2724}
2725
2726static const struct file_operations client_ctl_fops = {
2727 .write = client_ctl_write,
2728 .release = simple_transaction_release,
2729};
2730
2731static const struct tree_descr client_files[] = {
2732 [0] = {"info", &client_info_fops, S_IRUSR},
2733 [1] = {"states", &client_states_fops, S_IRUSR},
2734 [2] = {"ctl", &client_ctl_fops, S_IWUSR},
2735 [3] = {""},
2736};
2737
2738static struct nfs4_client *create_client(struct xdr_netobj name,
2739 struct svc_rqst *rqstp, nfs4_verifier *verf)
2740{
2741 struct nfs4_client *clp;
2742 struct sockaddr *sa = svc_addr(rqstp);
2743 int ret;
2744 struct net *net = SVC_NET(rqstp);
2745 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
2746 struct dentry *dentries[ARRAY_SIZE(client_files)];
2747
2748 clp = alloc_client(name);
2749 if (clp == NULL)
2750 return NULL;
2751
2752 ret = copy_cred(&clp->cl_cred, &rqstp->rq_cred);
2753 if (ret) {
2754 free_client(clp);
2755 return NULL;
2756 }
2757 gen_clid(clp, nn);
2758 kref_init(&clp->cl_nfsdfs.cl_ref);
2759 nfsd4_init_cb(&clp->cl_cb_null, clp, NULL, NFSPROC4_CLNT_CB_NULL);
2760 clp->cl_time = ktime_get_boottime_seconds();
2761 clear_bit(0, &clp->cl_cb_slot_busy);
2762 copy_verf(clp, verf);
2763 memcpy(&clp->cl_addr, sa, sizeof(struct sockaddr_storage));
2764 clp->cl_cb_session = NULL;
2765 clp->net = net;
2766 clp->cl_nfsd_dentry = nfsd_client_mkdir(
2767 nn, &clp->cl_nfsdfs,
2768 clp->cl_clientid.cl_id - nn->clientid_base,
2769 client_files, dentries);
2770 clp->cl_nfsd_info_dentry = dentries[0];
2771 if (!clp->cl_nfsd_dentry) {
2772 free_client(clp);
2773 return NULL;
2774 }
2775 return clp;
2776}
2777
2778static void
2779add_clp_to_name_tree(struct nfs4_client *new_clp, struct rb_root *root)
2780{
2781 struct rb_node **new = &(root->rb_node), *parent = NULL;
2782 struct nfs4_client *clp;
2783
2784 while (*new) {
2785 clp = rb_entry(*new, struct nfs4_client, cl_namenode);
2786 parent = *new;
2787
2788 if (compare_blob(&clp->cl_name, &new_clp->cl_name) > 0)
2789 new = &((*new)->rb_left);
2790 else
2791 new = &((*new)->rb_right);
2792 }
2793
2794 rb_link_node(&new_clp->cl_namenode, parent, new);
2795 rb_insert_color(&new_clp->cl_namenode, root);
2796}
2797
2798static struct nfs4_client *
2799find_clp_in_name_tree(struct xdr_netobj *name, struct rb_root *root)
2800{
2801 int cmp;
2802 struct rb_node *node = root->rb_node;
2803 struct nfs4_client *clp;
2804
2805 while (node) {
2806 clp = rb_entry(node, struct nfs4_client, cl_namenode);
2807 cmp = compare_blob(&clp->cl_name, name);
2808 if (cmp > 0)
2809 node = node->rb_left;
2810 else if (cmp < 0)
2811 node = node->rb_right;
2812 else
2813 return clp;
2814 }
2815 return NULL;
2816}
2817
2818static void
2819add_to_unconfirmed(struct nfs4_client *clp)
2820{
2821 unsigned int idhashval;
2822 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2823
2824 lockdep_assert_held(&nn->client_lock);
2825
2826 clear_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2827 add_clp_to_name_tree(clp, &nn->unconf_name_tree);
2828 idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2829 list_add(&clp->cl_idhash, &nn->unconf_id_hashtbl[idhashval]);
2830 renew_client_locked(clp);
2831}
2832
2833static void
2834move_to_confirmed(struct nfs4_client *clp)
2835{
2836 unsigned int idhashval = clientid_hashval(clp->cl_clientid.cl_id);
2837 struct nfsd_net *nn = net_generic(clp->net, nfsd_net_id);
2838
2839 lockdep_assert_held(&nn->client_lock);
2840
2841 list_move(&clp->cl_idhash, &nn->conf_id_hashtbl[idhashval]);
2842 rb_erase(&clp->cl_namenode, &nn->unconf_name_tree);
2843 add_clp_to_name_tree(clp, &nn->conf_name_tree);
2844 set_bit(NFSD4_CLIENT_CONFIRMED, &clp->cl_flags);
2845 trace_nfsd_clid_confirmed(&clp->cl_clientid);
2846 renew_client_locked(clp);
2847}
2848
2849static struct nfs4_client *
2850find_client_in_id_table(struct list_head *tbl, clientid_t *clid, bool sessions)
2851{
2852 struct nfs4_client *clp;
2853 unsigned int idhashval = clientid_hashval(clid->cl_id);
2854
2855 list_for_each_entry(clp, &tbl[idhashval], cl_idhash) {
2856 if (same_clid(&clp->cl_clientid, clid)) {
2857 if ((bool)clp->cl_minorversion != sessions)
2858 return NULL;
2859 renew_client_locked(clp);
2860 return clp;
2861 }
2862 }
2863 return NULL;
2864}
2865
2866static struct nfs4_client *
2867find_confirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2868{
2869 struct list_head *tbl = nn->conf_id_hashtbl;
2870
2871 lockdep_assert_held(&nn->client_lock);
2872 return find_client_in_id_table(tbl, clid, sessions);
2873}
2874
2875static struct nfs4_client *
2876find_unconfirmed_client(clientid_t *clid, bool sessions, struct nfsd_net *nn)
2877{
2878 struct list_head *tbl = nn->unconf_id_hashtbl;
2879
2880 lockdep_assert_held(&nn->client_lock);
2881 return find_client_in_id_table(tbl, clid, sessions);
2882}
2883
2884static bool clp_used_exchangeid(struct nfs4_client *clp)
2885{
2886 return clp->cl_exchange_flags != 0;
2887}
2888
2889static struct nfs4_client *
2890find_confirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
2891{
2892 lockdep_assert_held(&nn->client_lock);
2893 return find_clp_in_name_tree(name, &nn->conf_name_tree);
2894}
2895
2896static struct nfs4_client *
2897find_unconfirmed_client_by_name(struct xdr_netobj *name, struct nfsd_net *nn)
2898{
2899 lockdep_assert_held(&nn->client_lock);
2900 return find_clp_in_name_tree(name, &nn->unconf_name_tree);
2901}
2902
2903static void
2904gen_callback(struct nfs4_client *clp, struct nfsd4_setclientid *se, struct svc_rqst *rqstp)
2905{
2906 struct nfs4_cb_conn *conn = &clp->cl_cb_conn;
2907 struct sockaddr *sa = svc_addr(rqstp);
2908 u32 scopeid = rpc_get_scope_id(sa);
2909 unsigned short expected_family;
2910
2911
2912 if (se->se_callback_netid_len == 3 &&
2913 !memcmp(se->se_callback_netid_val, "tcp", 3))
2914 expected_family = AF_INET;
2915 else if (se->se_callback_netid_len == 4 &&
2916 !memcmp(se->se_callback_netid_val, "tcp6", 4))
2917 expected_family = AF_INET6;
2918 else
2919 goto out_err;
2920
2921 conn->cb_addrlen = rpc_uaddr2sockaddr(clp->net, se->se_callback_addr_val,
2922 se->se_callback_addr_len,
2923 (struct sockaddr *)&conn->cb_addr,
2924 sizeof(conn->cb_addr));
2925
2926 if (!conn->cb_addrlen || conn->cb_addr.ss_family != expected_family)
2927 goto out_err;
2928
2929 if (conn->cb_addr.ss_family == AF_INET6)
2930 ((struct sockaddr_in6 *)&conn->cb_addr)->sin6_scope_id = scopeid;
2931
2932 conn->cb_prog = se->se_callback_prog;
2933 conn->cb_ident = se->se_callback_ident;
2934 memcpy(&conn->cb_saddr, &rqstp->rq_daddr, rqstp->rq_daddrlen);
2935 trace_nfsd_cb_args(clp, conn);
2936 return;
2937out_err:
2938 conn->cb_addr.ss_family = AF_UNSPEC;
2939 conn->cb_addrlen = 0;
2940 trace_nfsd_cb_nodelegs(clp);
2941 return;
2942}
2943
2944
2945
2946
2947static void
2948nfsd4_store_cache_entry(struct nfsd4_compoundres *resp)
2949{
2950 struct xdr_buf *buf = resp->xdr->buf;
2951 struct nfsd4_slot *slot = resp->cstate.slot;
2952 unsigned int base;
2953
2954 dprintk("--> %s slot %p\n", __func__, slot);
2955
2956 slot->sl_flags |= NFSD4_SLOT_INITIALIZED;
2957 slot->sl_opcnt = resp->opcnt;
2958 slot->sl_status = resp->cstate.status;
2959 free_svc_cred(&slot->sl_cred);
2960 copy_cred(&slot->sl_cred, &resp->rqstp->rq_cred);
2961
2962 if (!nfsd4_cache_this(resp)) {
2963 slot->sl_flags &= ~NFSD4_SLOT_CACHED;
2964 return;
2965 }
2966 slot->sl_flags |= NFSD4_SLOT_CACHED;
2967
2968 base = resp->cstate.data_offset;
2969 slot->sl_datalen = buf->len - base;
2970 if (read_bytes_from_xdr_buf(buf, base, slot->sl_data, slot->sl_datalen))
2971 WARN(1, "%s: sessions DRC could not cache compound\n",
2972 __func__);
2973 return;
2974}
2975
2976
2977
2978
2979
2980
2981
2982
2983static __be32
2984nfsd4_enc_sequence_replay(struct nfsd4_compoundargs *args,
2985 struct nfsd4_compoundres *resp)
2986{
2987 struct nfsd4_op *op;
2988 struct nfsd4_slot *slot = resp->cstate.slot;
2989
2990
2991 op = &args->ops[resp->opcnt - 1];
2992 nfsd4_encode_operation(resp, op);
2993
2994 if (slot->sl_flags & NFSD4_SLOT_CACHED)
2995 return op->status;
2996 if (args->opcnt == 1) {
2997
2998
2999
3000
3001
3002 op->status = nfserr_seq_false_retry;
3003 } else {
3004 op = &args->ops[resp->opcnt++];
3005 op->status = nfserr_retry_uncached_rep;
3006 nfsd4_encode_operation(resp, op);
3007 }
3008 return op->status;
3009}
3010
3011
3012
3013
3014
3015static __be32
3016nfsd4_replay_cache_entry(struct nfsd4_compoundres *resp,
3017 struct nfsd4_sequence *seq)
3018{
3019 struct nfsd4_slot *slot = resp->cstate.slot;
3020 struct xdr_stream *xdr = resp->xdr;
3021 __be32 *p;
3022 __be32 status;
3023
3024 dprintk("--> %s slot %p\n", __func__, slot);
3025
3026 status = nfsd4_enc_sequence_replay(resp->rqstp->rq_argp, resp);
3027 if (status)
3028 return status;
3029
3030 p = xdr_reserve_space(xdr, slot->sl_datalen);
3031 if (!p) {
3032 WARN_ON_ONCE(1);
3033 return nfserr_serverfault;
3034 }
3035 xdr_encode_opaque_fixed(p, slot->sl_data, slot->sl_datalen);
3036 xdr_commit_encode(xdr);
3037
3038 resp->opcnt = slot->sl_opcnt;
3039 return slot->sl_status;
3040}
3041
3042
3043
3044
3045static void
3046nfsd4_set_ex_flags(struct nfs4_client *new, struct nfsd4_exchange_id *clid)
3047{
3048#ifdef CONFIG_NFSD_PNFS
3049 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_PNFS_MDS;
3050#else
3051 new->cl_exchange_flags |= EXCHGID4_FLAG_USE_NON_PNFS;
3052#endif
3053
3054
3055 new->cl_exchange_flags |= EXCHGID4_FLAG_SUPP_MOVED_REFER;
3056
3057
3058 clid->flags = new->cl_exchange_flags;
3059}
3060
3061static bool client_has_openowners(struct nfs4_client *clp)
3062{
3063 struct nfs4_openowner *oo;
3064
3065 list_for_each_entry(oo, &clp->cl_openowners, oo_perclient) {
3066 if (!list_empty(&oo->oo_owner.so_stateids))
3067 return true;
3068 }
3069 return false;
3070}
3071
3072static bool client_has_state(struct nfs4_client *clp)
3073{
3074 return client_has_openowners(clp)
3075#ifdef CONFIG_NFSD_PNFS
3076 || !list_empty(&clp->cl_lo_states)
3077#endif
3078 || !list_empty(&clp->cl_delegations)
3079 || !list_empty(&clp->cl_sessions)
3080 || !list_empty(&clp->async_copies);
3081}
3082
3083static __be32 copy_impl_id(struct nfs4_client *clp,
3084 struct nfsd4_exchange_id *exid)
3085{
3086 if (!exid->nii_domain.data)
3087 return 0;
3088 xdr_netobj_dup(&clp->cl_nii_domain, &exid->nii_domain, GFP_KERNEL);
3089 if (!clp->cl_nii_domain.data)
3090 return nfserr_jukebox;
3091 xdr_netobj_dup(&clp->cl_nii_name, &exid->nii_name, GFP_KERNEL);
3092 if (!clp->cl_nii_name.data)
3093 return nfserr_jukebox;
3094 clp->cl_nii_time = exid->nii_time;
3095 return 0;
3096}
3097
3098__be32
3099nfsd4_exchange_id(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3100 union nfsd4_op_u *u)
3101{
3102 struct nfsd4_exchange_id *exid = &u->exchange_id;
3103 struct nfs4_client *conf, *new;
3104 struct nfs4_client *unconf = NULL;
3105 __be32 status;
3106 char addr_str[INET6_ADDRSTRLEN];
3107 nfs4_verifier verf = exid->verifier;
3108 struct sockaddr *sa = svc_addr(rqstp);
3109 bool update = exid->flags & EXCHGID4_FLAG_UPD_CONFIRMED_REC_A;
3110 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3111
3112 rpc_ntop(sa, addr_str, sizeof(addr_str));
3113 dprintk("%s rqstp=%p exid=%p clname.len=%u clname.data=%p "
3114 "ip_addr=%s flags %x, spa_how %u\n",
3115 __func__, rqstp, exid, exid->clname.len, exid->clname.data,
3116 addr_str, exid->flags, exid->spa_how);
3117
3118 if (exid->flags & ~EXCHGID4_FLAG_MASK_A)
3119 return nfserr_inval;
3120
3121 new = create_client(exid->clname, rqstp, &verf);
3122 if (new == NULL)
3123 return nfserr_jukebox;
3124 status = copy_impl_id(new, exid);
3125 if (status)
3126 goto out_nolock;
3127
3128 switch (exid->spa_how) {
3129 case SP4_MACH_CRED:
3130 exid->spo_must_enforce[0] = 0;
3131 exid->spo_must_enforce[1] = (
3132 1 << (OP_BIND_CONN_TO_SESSION - 32) |
3133 1 << (OP_EXCHANGE_ID - 32) |
3134 1 << (OP_CREATE_SESSION - 32) |
3135 1 << (OP_DESTROY_SESSION - 32) |
3136 1 << (OP_DESTROY_CLIENTID - 32));
3137
3138 exid->spo_must_allow[0] &= (1 << (OP_CLOSE) |
3139 1 << (OP_OPEN_DOWNGRADE) |
3140 1 << (OP_LOCKU) |
3141 1 << (OP_DELEGRETURN));
3142
3143 exid->spo_must_allow[1] &= (
3144 1 << (OP_TEST_STATEID - 32) |
3145 1 << (OP_FREE_STATEID - 32));
3146 if (!svc_rqst_integrity_protected(rqstp)) {
3147 status = nfserr_inval;
3148 goto out_nolock;
3149 }
3150
3151
3152
3153
3154
3155 if (!new->cl_cred.cr_principal &&
3156 !new->cl_cred.cr_raw_principal) {
3157 status = nfserr_serverfault;
3158 goto out_nolock;
3159 }
3160 new->cl_mach_cred = true;
3161 break;
3162 case SP4_NONE:
3163 break;
3164 default:
3165 WARN_ON_ONCE(1);
3166 fallthrough;
3167 case SP4_SSV:
3168 status = nfserr_encr_alg_unsupp;
3169 goto out_nolock;
3170 }
3171
3172
3173 spin_lock(&nn->client_lock);
3174 conf = find_confirmed_client_by_name(&exid->clname, nn);
3175 if (conf) {
3176 bool creds_match = same_creds(&conf->cl_cred, &rqstp->rq_cred);
3177 bool verfs_match = same_verf(&verf, &conf->cl_verifier);
3178
3179 if (update) {
3180 if (!clp_used_exchangeid(conf)) {
3181 status = nfserr_inval;
3182 goto out;
3183 }
3184 if (!nfsd4_mach_creds_match(conf, rqstp)) {
3185 status = nfserr_wrong_cred;
3186 goto out;
3187 }
3188 if (!creds_match) {
3189 status = nfserr_perm;
3190 goto out;
3191 }
3192 if (!verfs_match) {
3193 status = nfserr_not_same;
3194 goto out;
3195 }
3196
3197 exid->flags |= EXCHGID4_FLAG_CONFIRMED_R;
3198 trace_nfsd_clid_confirmed_r(conf);
3199 goto out_copy;
3200 }
3201 if (!creds_match) {
3202 if (client_has_state(conf)) {
3203 status = nfserr_clid_inuse;
3204 trace_nfsd_clid_cred_mismatch(conf, rqstp);
3205 goto out;
3206 }
3207 goto out_new;
3208 }
3209 if (verfs_match) {
3210 conf->cl_exchange_flags |= EXCHGID4_FLAG_CONFIRMED_R;
3211 trace_nfsd_clid_confirmed_r(conf);
3212 goto out_copy;
3213 }
3214
3215 trace_nfsd_clid_verf_mismatch(conf, rqstp, &verf);
3216 conf = NULL;
3217 goto out_new;
3218 }
3219
3220 if (update) {
3221 status = nfserr_noent;
3222 goto out;
3223 }
3224
3225 unconf = find_unconfirmed_client_by_name(&exid->clname, nn);
3226 if (unconf)
3227 unhash_client_locked(unconf);
3228
3229
3230 trace_nfsd_clid_fresh(new);
3231
3232out_new:
3233 if (conf) {
3234 status = mark_client_expired_locked(conf);
3235 if (status)
3236 goto out;
3237 trace_nfsd_clid_replaced(&conf->cl_clientid);
3238 }
3239 new->cl_minorversion = cstate->minorversion;
3240 new->cl_spo_must_allow.u.words[0] = exid->spo_must_allow[0];
3241 new->cl_spo_must_allow.u.words[1] = exid->spo_must_allow[1];
3242
3243 add_to_unconfirmed(new);
3244 swap(new, conf);
3245out_copy:
3246 exid->clientid.cl_boot = conf->cl_clientid.cl_boot;
3247 exid->clientid.cl_id = conf->cl_clientid.cl_id;
3248
3249 exid->seqid = conf->cl_cs_slot.sl_seqid + 1;
3250 nfsd4_set_ex_flags(conf, exid);
3251
3252 dprintk("nfsd4_exchange_id seqid %d flags %x\n",
3253 conf->cl_cs_slot.sl_seqid, conf->cl_exchange_flags);
3254 status = nfs_ok;
3255
3256out:
3257 spin_unlock(&nn->client_lock);
3258out_nolock:
3259 if (new)
3260 expire_client(new);
3261 if (unconf) {
3262 trace_nfsd_clid_expire_unconf(&unconf->cl_clientid);
3263 expire_client(unconf);
3264 }
3265 return status;
3266}
3267
3268static __be32
3269check_slot_seqid(u32 seqid, u32 slot_seqid, int slot_inuse)
3270{
3271 dprintk("%s enter. seqid %d slot_seqid %d\n", __func__, seqid,
3272 slot_seqid);
3273
3274
3275 if (slot_inuse) {
3276 if (seqid == slot_seqid)
3277 return nfserr_jukebox;
3278 else
3279 return nfserr_seq_misordered;
3280 }
3281
3282 if (likely(seqid == slot_seqid + 1))
3283 return nfs_ok;
3284 if (seqid == slot_seqid)
3285 return nfserr_replay_cache;
3286 return nfserr_seq_misordered;
3287}
3288
3289
3290
3291
3292
3293
3294static void
3295nfsd4_cache_create_session(struct nfsd4_create_session *cr_ses,
3296 struct nfsd4_clid_slot *slot, __be32 nfserr)
3297{
3298 slot->sl_status = nfserr;
3299 memcpy(&slot->sl_cr_ses, cr_ses, sizeof(*cr_ses));
3300}
3301
3302static __be32
3303nfsd4_replay_create_session(struct nfsd4_create_session *cr_ses,
3304 struct nfsd4_clid_slot *slot)
3305{
3306 memcpy(cr_ses, &slot->sl_cr_ses, sizeof(*cr_ses));
3307 return slot->sl_status;
3308}
3309
3310#define NFSD_MIN_REQ_HDR_SEQ_SZ ((\
3311 2 * 2 + \
3312 1 + \
3313 3 + \
3314 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
3315 \
3316 4 ) * sizeof(__be32))
3317
3318#define NFSD_MIN_RESP_HDR_SEQ_SZ ((\
3319 2 + \
3320 1 + \
3321 1 + \
3322 3 + \
3323 XDR_QUADLEN(NFS4_MAX_SESSIONID_LEN) + \
3324 \
3325 5 ) * sizeof(__be32))
3326
3327static __be32 check_forechannel_attrs(struct nfsd4_channel_attrs *ca, struct nfsd_net *nn)
3328{
3329 u32 maxrpc = nn->nfsd_serv->sv_max_mesg;
3330
3331 if (ca->maxreq_sz < NFSD_MIN_REQ_HDR_SEQ_SZ)
3332 return nfserr_toosmall;
3333 if (ca->maxresp_sz < NFSD_MIN_RESP_HDR_SEQ_SZ)
3334 return nfserr_toosmall;
3335 ca->headerpadsz = 0;
3336 ca->maxreq_sz = min_t(u32, ca->maxreq_sz, maxrpc);
3337 ca->maxresp_sz = min_t(u32, ca->maxresp_sz, maxrpc);
3338 ca->maxops = min_t(u32, ca->maxops, NFSD_MAX_OPS_PER_COMPOUND);
3339 ca->maxresp_cached = min_t(u32, ca->maxresp_cached,
3340 NFSD_SLOT_CACHE_SIZE + NFSD_MIN_HDR_SEQ_SZ);
3341 ca->maxreqs = min_t(u32, ca->maxreqs, NFSD_MAX_SLOTS_PER_SESSION);
3342
3343
3344
3345
3346
3347
3348
3349
3350
3351
3352 ca->maxreqs = nfsd4_get_drc_mem(ca, nn);
3353
3354 return nfs_ok;
3355}
3356
3357
3358
3359
3360
3361#define RPC_MAX_HEADER_WITH_AUTH_SYS \
3362 (RPC_CALLHDRSIZE + 2 * (2 + UNX_CALLSLACK))
3363
3364#define RPC_MAX_REPHEADER_WITH_AUTH_SYS \
3365 (RPC_REPHDRSIZE + (2 + NUL_REPLYSLACK))
3366
3367#define NFSD_CB_MAX_REQ_SZ ((NFS4_enc_cb_recall_sz + \
3368 RPC_MAX_HEADER_WITH_AUTH_SYS) * sizeof(__be32))
3369#define NFSD_CB_MAX_RESP_SZ ((NFS4_dec_cb_recall_sz + \
3370 RPC_MAX_REPHEADER_WITH_AUTH_SYS) * \
3371 sizeof(__be32))
3372
3373static __be32 check_backchannel_attrs(struct nfsd4_channel_attrs *ca)
3374{
3375 ca->headerpadsz = 0;
3376
3377 if (ca->maxreq_sz < NFSD_CB_MAX_REQ_SZ)
3378 return nfserr_toosmall;
3379 if (ca->maxresp_sz < NFSD_CB_MAX_RESP_SZ)
3380 return nfserr_toosmall;
3381 ca->maxresp_cached = 0;
3382 if (ca->maxops < 2)
3383 return nfserr_toosmall;
3384
3385 return nfs_ok;
3386}
3387
3388static __be32 nfsd4_check_cb_sec(struct nfsd4_cb_sec *cbs)
3389{
3390 switch (cbs->flavor) {
3391 case RPC_AUTH_NULL:
3392 case RPC_AUTH_UNIX:
3393 return nfs_ok;
3394 default:
3395
3396
3397
3398
3399
3400
3401
3402 return nfserr_encr_alg_unsupp;
3403 }
3404}
3405
3406__be32
3407nfsd4_create_session(struct svc_rqst *rqstp,
3408 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
3409{
3410 struct nfsd4_create_session *cr_ses = &u->create_session;
3411 struct sockaddr *sa = svc_addr(rqstp);
3412 struct nfs4_client *conf, *unconf;
3413 struct nfs4_client *old = NULL;
3414 struct nfsd4_session *new;
3415 struct nfsd4_conn *conn;
3416 struct nfsd4_clid_slot *cs_slot = NULL;
3417 __be32 status = 0;
3418 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3419
3420 if (cr_ses->flags & ~SESSION4_FLAG_MASK_A)
3421 return nfserr_inval;
3422 status = nfsd4_check_cb_sec(&cr_ses->cb_sec);
3423 if (status)
3424 return status;
3425 status = check_forechannel_attrs(&cr_ses->fore_channel, nn);
3426 if (status)
3427 return status;
3428 status = check_backchannel_attrs(&cr_ses->back_channel);
3429 if (status)
3430 goto out_release_drc_mem;
3431 status = nfserr_jukebox;
3432 new = alloc_session(&cr_ses->fore_channel, &cr_ses->back_channel);
3433 if (!new)
3434 goto out_release_drc_mem;
3435 conn = alloc_conn_from_crses(rqstp, cr_ses);
3436 if (!conn)
3437 goto out_free_session;
3438
3439 spin_lock(&nn->client_lock);
3440 unconf = find_unconfirmed_client(&cr_ses->clientid, true, nn);
3441 conf = find_confirmed_client(&cr_ses->clientid, true, nn);
3442 WARN_ON_ONCE(conf && unconf);
3443
3444 if (conf) {
3445 status = nfserr_wrong_cred;
3446 if (!nfsd4_mach_creds_match(conf, rqstp))
3447 goto out_free_conn;
3448 cs_slot = &conf->cl_cs_slot;
3449 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
3450 if (status) {
3451 if (status == nfserr_replay_cache)
3452 status = nfsd4_replay_create_session(cr_ses, cs_slot);
3453 goto out_free_conn;
3454 }
3455 } else if (unconf) {
3456 status = nfserr_clid_inuse;
3457 if (!same_creds(&unconf->cl_cred, &rqstp->rq_cred) ||
3458 !rpc_cmp_addr(sa, (struct sockaddr *) &unconf->cl_addr)) {
3459 trace_nfsd_clid_cred_mismatch(unconf, rqstp);
3460 goto out_free_conn;
3461 }
3462 status = nfserr_wrong_cred;
3463 if (!nfsd4_mach_creds_match(unconf, rqstp))
3464 goto out_free_conn;
3465 cs_slot = &unconf->cl_cs_slot;
3466 status = check_slot_seqid(cr_ses->seqid, cs_slot->sl_seqid, 0);
3467 if (status) {
3468
3469 status = nfserr_seq_misordered;
3470 goto out_free_conn;
3471 }
3472 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
3473 if (old) {
3474 status = mark_client_expired_locked(old);
3475 if (status) {
3476 old = NULL;
3477 goto out_free_conn;
3478 }
3479 trace_nfsd_clid_replaced(&old->cl_clientid);
3480 }
3481 move_to_confirmed(unconf);
3482 conf = unconf;
3483 } else {
3484 status = nfserr_stale_clientid;
3485 goto out_free_conn;
3486 }
3487 status = nfs_ok;
3488
3489 cr_ses->flags &= ~SESSION4_PERSIST;
3490
3491 cr_ses->flags &= ~SESSION4_RDMA;
3492
3493 init_session(rqstp, new, conf, cr_ses);
3494 nfsd4_get_session_locked(new);
3495
3496 memcpy(cr_ses->sessionid.data, new->se_sessionid.data,
3497 NFS4_MAX_SESSIONID_LEN);
3498 cs_slot->sl_seqid++;
3499 cr_ses->seqid = cs_slot->sl_seqid;
3500
3501
3502 nfsd4_cache_create_session(cr_ses, cs_slot, status);
3503 spin_unlock(&nn->client_lock);
3504 if (conf == unconf)
3505 fsnotify_dentry(conf->cl_nfsd_info_dentry, FS_MODIFY);
3506
3507 nfsd4_init_conn(rqstp, conn, new);
3508 nfsd4_put_session(new);
3509 if (old)
3510 expire_client(old);
3511 return status;
3512out_free_conn:
3513 spin_unlock(&nn->client_lock);
3514 free_conn(conn);
3515 if (old)
3516 expire_client(old);
3517out_free_session:
3518 __free_session(new);
3519out_release_drc_mem:
3520 nfsd4_put_drc_mem(&cr_ses->fore_channel);
3521 return status;
3522}
3523
3524static __be32 nfsd4_map_bcts_dir(u32 *dir)
3525{
3526 switch (*dir) {
3527 case NFS4_CDFC4_FORE:
3528 case NFS4_CDFC4_BACK:
3529 return nfs_ok;
3530 case NFS4_CDFC4_FORE_OR_BOTH:
3531 case NFS4_CDFC4_BACK_OR_BOTH:
3532 *dir = NFS4_CDFC4_BOTH;
3533 return nfs_ok;
3534 }
3535 return nfserr_inval;
3536}
3537
3538__be32 nfsd4_backchannel_ctl(struct svc_rqst *rqstp,
3539 struct nfsd4_compound_state *cstate,
3540 union nfsd4_op_u *u)
3541{
3542 struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;
3543 struct nfsd4_session *session = cstate->session;
3544 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3545 __be32 status;
3546
3547 status = nfsd4_check_cb_sec(&bc->bc_cb_sec);
3548 if (status)
3549 return status;
3550 spin_lock(&nn->client_lock);
3551 session->se_cb_prog = bc->bc_cb_program;
3552 session->se_cb_sec = bc->bc_cb_sec;
3553 spin_unlock(&nn->client_lock);
3554
3555 nfsd4_probe_callback(session->se_client);
3556
3557 return nfs_ok;
3558}
3559
3560static struct nfsd4_conn *__nfsd4_find_conn(struct svc_xprt *xpt, struct nfsd4_session *s)
3561{
3562 struct nfsd4_conn *c;
3563
3564 list_for_each_entry(c, &s->se_conns, cn_persession) {
3565 if (c->cn_xprt == xpt) {
3566 return c;
3567 }
3568 }
3569 return NULL;
3570}
3571
3572static __be32 nfsd4_match_existing_connection(struct svc_rqst *rqst,
3573 struct nfsd4_session *session, u32 req, struct nfsd4_conn **conn)
3574{
3575 struct nfs4_client *clp = session->se_client;
3576 struct svc_xprt *xpt = rqst->rq_xprt;
3577 struct nfsd4_conn *c;
3578 __be32 status;
3579
3580
3581 spin_lock(&clp->cl_lock);
3582 c = __nfsd4_find_conn(xpt, session);
3583 if (!c)
3584 status = nfserr_noent;
3585 else if (req == c->cn_flags)
3586 status = nfs_ok;
3587 else if (req == NFS4_CDFC4_FORE_OR_BOTH &&
3588 c->cn_flags != NFS4_CDFC4_BACK)
3589 status = nfs_ok;
3590 else if (req == NFS4_CDFC4_BACK_OR_BOTH &&
3591 c->cn_flags != NFS4_CDFC4_FORE)
3592 status = nfs_ok;
3593 else
3594 status = nfserr_inval;
3595 spin_unlock(&clp->cl_lock);
3596 if (status == nfs_ok && conn)
3597 *conn = c;
3598 return status;
3599}
3600
3601__be32 nfsd4_bind_conn_to_session(struct svc_rqst *rqstp,
3602 struct nfsd4_compound_state *cstate,
3603 union nfsd4_op_u *u)
3604{
3605 struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;
3606 __be32 status;
3607 struct nfsd4_conn *conn;
3608 struct nfsd4_session *session;
3609 struct net *net = SVC_NET(rqstp);
3610 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3611
3612 if (!nfsd4_last_compound_op(rqstp))
3613 return nfserr_not_only_op;
3614 spin_lock(&nn->client_lock);
3615 session = find_in_sessionid_hashtbl(&bcts->sessionid, net, &status);
3616 spin_unlock(&nn->client_lock);
3617 if (!session)
3618 goto out_no_session;
3619 status = nfserr_wrong_cred;
3620 if (!nfsd4_mach_creds_match(session->se_client, rqstp))
3621 goto out;
3622 status = nfsd4_match_existing_connection(rqstp, session,
3623 bcts->dir, &conn);
3624 if (status == nfs_ok) {
3625 if (bcts->dir == NFS4_CDFC4_FORE_OR_BOTH ||
3626 bcts->dir == NFS4_CDFC4_BACK)
3627 conn->cn_flags |= NFS4_CDFC4_BACK;
3628 nfsd4_probe_callback(session->se_client);
3629 goto out;
3630 }
3631 if (status == nfserr_inval)
3632 goto out;
3633 status = nfsd4_map_bcts_dir(&bcts->dir);
3634 if (status)
3635 goto out;
3636 conn = alloc_conn(rqstp, bcts->dir);
3637 status = nfserr_jukebox;
3638 if (!conn)
3639 goto out;
3640 nfsd4_init_conn(rqstp, conn, session);
3641 status = nfs_ok;
3642out:
3643 nfsd4_put_session(session);
3644out_no_session:
3645 return status;
3646}
3647
3648static bool nfsd4_compound_in_session(struct nfsd4_compound_state *cstate, struct nfs4_sessionid *sid)
3649{
3650 if (!cstate->session)
3651 return false;
3652 return !memcmp(sid, &cstate->session->se_sessionid, sizeof(*sid));
3653}
3654
3655__be32
3656nfsd4_destroy_session(struct svc_rqst *r, struct nfsd4_compound_state *cstate,
3657 union nfsd4_op_u *u)
3658{
3659 struct nfs4_sessionid *sessionid = &u->destroy_session.sessionid;
3660 struct nfsd4_session *ses;
3661 __be32 status;
3662 int ref_held_by_me = 0;
3663 struct net *net = SVC_NET(r);
3664 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3665
3666 status = nfserr_not_only_op;
3667 if (nfsd4_compound_in_session(cstate, sessionid)) {
3668 if (!nfsd4_last_compound_op(r))
3669 goto out;
3670 ref_held_by_me++;
3671 }
3672 dump_sessionid(__func__, sessionid);
3673 spin_lock(&nn->client_lock);
3674 ses = find_in_sessionid_hashtbl(sessionid, net, &status);
3675 if (!ses)
3676 goto out_client_lock;
3677 status = nfserr_wrong_cred;
3678 if (!nfsd4_mach_creds_match(ses->se_client, r))
3679 goto out_put_session;
3680 status = mark_session_dead_locked(ses, 1 + ref_held_by_me);
3681 if (status)
3682 goto out_put_session;
3683 unhash_session(ses);
3684 spin_unlock(&nn->client_lock);
3685
3686 nfsd4_probe_callback_sync(ses->se_client);
3687
3688 spin_lock(&nn->client_lock);
3689 status = nfs_ok;
3690out_put_session:
3691 nfsd4_put_session_locked(ses);
3692out_client_lock:
3693 spin_unlock(&nn->client_lock);
3694out:
3695 return status;
3696}
3697
3698static __be32 nfsd4_sequence_check_conn(struct nfsd4_conn *new, struct nfsd4_session *ses)
3699{
3700 struct nfs4_client *clp = ses->se_client;
3701 struct nfsd4_conn *c;
3702 __be32 status = nfs_ok;
3703 int ret;
3704
3705 spin_lock(&clp->cl_lock);
3706 c = __nfsd4_find_conn(new->cn_xprt, ses);
3707 if (c)
3708 goto out_free;
3709 status = nfserr_conn_not_bound_to_session;
3710 if (clp->cl_mach_cred)
3711 goto out_free;
3712 __nfsd4_hash_conn(new, ses);
3713 spin_unlock(&clp->cl_lock);
3714 ret = nfsd4_register_conn(new);
3715 if (ret)
3716
3717 nfsd4_conn_lost(&new->cn_xpt_user);
3718 return nfs_ok;
3719out_free:
3720 spin_unlock(&clp->cl_lock);
3721 free_conn(new);
3722 return status;
3723}
3724
3725static bool nfsd4_session_too_many_ops(struct svc_rqst *rqstp, struct nfsd4_session *session)
3726{
3727 struct nfsd4_compoundargs *args = rqstp->rq_argp;
3728
3729 return args->opcnt > session->se_fchannel.maxops;
3730}
3731
3732static bool nfsd4_request_too_big(struct svc_rqst *rqstp,
3733 struct nfsd4_session *session)
3734{
3735 struct xdr_buf *xb = &rqstp->rq_arg;
3736
3737 return xb->len > session->se_fchannel.maxreq_sz;
3738}
3739
3740static bool replay_matches_cache(struct svc_rqst *rqstp,
3741 struct nfsd4_sequence *seq, struct nfsd4_slot *slot)
3742{
3743 struct nfsd4_compoundargs *argp = rqstp->rq_argp;
3744
3745 if ((bool)(slot->sl_flags & NFSD4_SLOT_CACHETHIS) !=
3746 (bool)seq->cachethis)
3747 return false;
3748
3749
3750
3751
3752 if (slot->sl_opcnt < argp->opcnt && !slot->sl_status)
3753 return false;
3754
3755
3756
3757
3758
3759 if (slot->sl_opcnt > argp->opcnt)
3760 return false;
3761
3762 if (!same_creds(&rqstp->rq_cred, &slot->sl_cred))
3763 return false;
3764
3765
3766
3767
3768
3769
3770 return true;
3771}
3772
3773__be32
3774nfsd4_sequence(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
3775 union nfsd4_op_u *u)
3776{
3777 struct nfsd4_sequence *seq = &u->sequence;
3778 struct nfsd4_compoundres *resp = rqstp->rq_resp;
3779 struct xdr_stream *xdr = resp->xdr;
3780 struct nfsd4_session *session;
3781 struct nfs4_client *clp;
3782 struct nfsd4_slot *slot;
3783 struct nfsd4_conn *conn;
3784 __be32 status;
3785 int buflen;
3786 struct net *net = SVC_NET(rqstp);
3787 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
3788
3789 if (resp->opcnt != 1)
3790 return nfserr_sequence_pos;
3791
3792
3793
3794
3795
3796 conn = alloc_conn(rqstp, NFS4_CDFC4_FORE);
3797 if (!conn)
3798 return nfserr_jukebox;
3799
3800 spin_lock(&nn->client_lock);
3801 session = find_in_sessionid_hashtbl(&seq->sessionid, net, &status);
3802 if (!session)
3803 goto out_no_session;
3804 clp = session->se_client;
3805
3806 status = nfserr_too_many_ops;
3807 if (nfsd4_session_too_many_ops(rqstp, session))
3808 goto out_put_session;
3809
3810 status = nfserr_req_too_big;
3811 if (nfsd4_request_too_big(rqstp, session))
3812 goto out_put_session;
3813
3814 status = nfserr_badslot;
3815 if (seq->slotid >= session->se_fchannel.maxreqs)
3816 goto out_put_session;
3817
3818 slot = session->se_slots[seq->slotid];
3819 dprintk("%s: slotid %d\n", __func__, seq->slotid);
3820
3821
3822
3823
3824 seq->maxslots = session->se_fchannel.maxreqs;
3825
3826 status = check_slot_seqid(seq->seqid, slot->sl_seqid,
3827 slot->sl_flags & NFSD4_SLOT_INUSE);
3828 if (status == nfserr_replay_cache) {
3829 status = nfserr_seq_misordered;
3830 if (!(slot->sl_flags & NFSD4_SLOT_INITIALIZED))
3831 goto out_put_session;
3832 status = nfserr_seq_false_retry;
3833 if (!replay_matches_cache(rqstp, seq, slot))
3834 goto out_put_session;
3835 cstate->slot = slot;
3836 cstate->session = session;
3837 cstate->clp = clp;
3838
3839
3840 status = nfsd4_replay_cache_entry(resp, seq);
3841 cstate->status = nfserr_replay_cache;
3842 goto out;
3843 }
3844 if (status)
3845 goto out_put_session;
3846
3847 status = nfsd4_sequence_check_conn(conn, session);
3848 conn = NULL;
3849 if (status)
3850 goto out_put_session;
3851
3852 buflen = (seq->cachethis) ?
3853 session->se_fchannel.maxresp_cached :
3854 session->se_fchannel.maxresp_sz;
3855 status = (seq->cachethis) ? nfserr_rep_too_big_to_cache :
3856 nfserr_rep_too_big;
3857 if (xdr_restrict_buflen(xdr, buflen - rqstp->rq_auth_slack))
3858 goto out_put_session;
3859 svc_reserve(rqstp, buflen);
3860
3861 status = nfs_ok;
3862
3863 slot->sl_seqid = seq->seqid;
3864 slot->sl_flags |= NFSD4_SLOT_INUSE;
3865 if (seq->cachethis)
3866 slot->sl_flags |= NFSD4_SLOT_CACHETHIS;
3867 else
3868 slot->sl_flags &= ~NFSD4_SLOT_CACHETHIS;
3869
3870 cstate->slot = slot;
3871 cstate->session = session;
3872 cstate->clp = clp;
3873
3874out:
3875 switch (clp->cl_cb_state) {
3876 case NFSD4_CB_DOWN:
3877 seq->status_flags = SEQ4_STATUS_CB_PATH_DOWN;
3878 break;
3879 case NFSD4_CB_FAULT:
3880 seq->status_flags = SEQ4_STATUS_BACKCHANNEL_FAULT;
3881 break;
3882 default:
3883 seq->status_flags = 0;
3884 }
3885 if (!list_empty(&clp->cl_revoked))
3886 seq->status_flags |= SEQ4_STATUS_RECALLABLE_STATE_REVOKED;
3887out_no_session:
3888 if (conn)
3889 free_conn(conn);
3890 spin_unlock(&nn->client_lock);
3891 return status;
3892out_put_session:
3893 nfsd4_put_session_locked(session);
3894 goto out_no_session;
3895}
3896
3897void
3898nfsd4_sequence_done(struct nfsd4_compoundres *resp)
3899{
3900 struct nfsd4_compound_state *cs = &resp->cstate;
3901
3902 if (nfsd4_has_session(cs)) {
3903 if (cs->status != nfserr_replay_cache) {
3904 nfsd4_store_cache_entry(resp);
3905 cs->slot->sl_flags &= ~NFSD4_SLOT_INUSE;
3906 }
3907
3908 nfsd4_put_session(cs->session);
3909 } else if (cs->clp)
3910 put_client_renew(cs->clp);
3911}
3912
3913__be32
3914nfsd4_destroy_clientid(struct svc_rqst *rqstp,
3915 struct nfsd4_compound_state *cstate,
3916 union nfsd4_op_u *u)
3917{
3918 struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;
3919 struct nfs4_client *conf, *unconf;
3920 struct nfs4_client *clp = NULL;
3921 __be32 status = 0;
3922 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
3923
3924 spin_lock(&nn->client_lock);
3925 unconf = find_unconfirmed_client(&dc->clientid, true, nn);
3926 conf = find_confirmed_client(&dc->clientid, true, nn);
3927 WARN_ON_ONCE(conf && unconf);
3928
3929 if (conf) {
3930 if (client_has_state(conf)) {
3931 status = nfserr_clientid_busy;
3932 goto out;
3933 }
3934 status = mark_client_expired_locked(conf);
3935 if (status)
3936 goto out;
3937 clp = conf;
3938 } else if (unconf)
3939 clp = unconf;
3940 else {
3941 status = nfserr_stale_clientid;
3942 goto out;
3943 }
3944 if (!nfsd4_mach_creds_match(clp, rqstp)) {
3945 clp = NULL;
3946 status = nfserr_wrong_cred;
3947 goto out;
3948 }
3949 trace_nfsd_clid_destroyed(&clp->cl_clientid);
3950 unhash_client_locked(clp);
3951out:
3952 spin_unlock(&nn->client_lock);
3953 if (clp)
3954 expire_client(clp);
3955 return status;
3956}
3957
3958__be32
3959nfsd4_reclaim_complete(struct svc_rqst *rqstp,
3960 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
3961{
3962 struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;
3963 struct nfs4_client *clp = cstate->clp;
3964 __be32 status = 0;
3965
3966 if (rc->rca_one_fs) {
3967 if (!cstate->current_fh.fh_dentry)
3968 return nfserr_nofilehandle;
3969
3970
3971
3972
3973 return nfs_ok;
3974 }
3975
3976 status = nfserr_complete_already;
3977 if (test_and_set_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &clp->cl_flags))
3978 goto out;
3979
3980 status = nfserr_stale_clientid;
3981 if (is_client_expired(clp))
3982
3983
3984
3985
3986
3987
3988
3989 goto out;
3990
3991 status = nfs_ok;
3992 trace_nfsd_clid_reclaim_complete(&clp->cl_clientid);
3993 nfsd4_client_record_create(clp);
3994 inc_reclaim_complete(clp);
3995out:
3996 return status;
3997}
3998
3999__be32
4000nfsd4_setclientid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
4001 union nfsd4_op_u *u)
4002{
4003 struct nfsd4_setclientid *setclid = &u->setclientid;
4004 struct xdr_netobj clname = setclid->se_name;
4005 nfs4_verifier clverifier = setclid->se_verf;
4006 struct nfs4_client *conf, *new;
4007 struct nfs4_client *unconf = NULL;
4008 __be32 status;
4009 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4010
4011 new = create_client(clname, rqstp, &clverifier);
4012 if (new == NULL)
4013 return nfserr_jukebox;
4014 spin_lock(&nn->client_lock);
4015 conf = find_confirmed_client_by_name(&clname, nn);
4016 if (conf && client_has_state(conf)) {
4017 status = nfserr_clid_inuse;
4018 if (clp_used_exchangeid(conf))
4019 goto out;
4020 if (!same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
4021 trace_nfsd_clid_cred_mismatch(conf, rqstp);
4022 goto out;
4023 }
4024 }
4025 unconf = find_unconfirmed_client_by_name(&clname, nn);
4026 if (unconf)
4027 unhash_client_locked(unconf);
4028 if (conf) {
4029 if (same_verf(&conf->cl_verifier, &clverifier)) {
4030 copy_clid(new, conf);
4031 gen_confirm(new, nn);
4032 } else
4033 trace_nfsd_clid_verf_mismatch(conf, rqstp,
4034 &clverifier);
4035 } else
4036 trace_nfsd_clid_fresh(new);
4037 new->cl_minorversion = 0;
4038 gen_callback(new, setclid, rqstp);
4039 add_to_unconfirmed(new);
4040 setclid->se_clientid.cl_boot = new->cl_clientid.cl_boot;
4041 setclid->se_clientid.cl_id = new->cl_clientid.cl_id;
4042 memcpy(setclid->se_confirm.data, new->cl_confirm.data, sizeof(setclid->se_confirm.data));
4043 new = NULL;
4044 status = nfs_ok;
4045out:
4046 spin_unlock(&nn->client_lock);
4047 if (new)
4048 free_client(new);
4049 if (unconf) {
4050 trace_nfsd_clid_expire_unconf(&unconf->cl_clientid);
4051 expire_client(unconf);
4052 }
4053 return status;
4054}
4055
4056__be32
4057nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
4058 struct nfsd4_compound_state *cstate,
4059 union nfsd4_op_u *u)
4060{
4061 struct nfsd4_setclientid_confirm *setclientid_confirm =
4062 &u->setclientid_confirm;
4063 struct nfs4_client *conf, *unconf;
4064 struct nfs4_client *old = NULL;
4065 nfs4_verifier confirm = setclientid_confirm->sc_confirm;
4066 clientid_t * clid = &setclientid_confirm->sc_clientid;
4067 __be32 status;
4068 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
4069
4070 if (STALE_CLIENTID(clid, nn))
4071 return nfserr_stale_clientid;
4072
4073 spin_lock(&nn->client_lock);
4074 conf = find_confirmed_client(clid, false, nn);
4075 unconf = find_unconfirmed_client(clid, false, nn);
4076
4077
4078
4079
4080
4081
4082
4083 status = nfserr_clid_inuse;
4084 if (unconf && !same_creds(&unconf->cl_cred, &rqstp->rq_cred)) {
4085 trace_nfsd_clid_cred_mismatch(unconf, rqstp);
4086 goto out;
4087 }
4088 if (conf && !same_creds(&conf->cl_cred, &rqstp->rq_cred)) {
4089 trace_nfsd_clid_cred_mismatch(conf, rqstp);
4090 goto out;
4091 }
4092 if (!unconf || !same_verf(&confirm, &unconf->cl_confirm)) {
4093 if (conf && same_verf(&confirm, &conf->cl_confirm)) {
4094 status = nfs_ok;
4095 } else
4096 status = nfserr_stale_clientid;
4097 goto out;
4098 }
4099 status = nfs_ok;
4100 if (conf) {
4101 old = unconf;
4102 unhash_client_locked(old);
4103 nfsd4_change_callback(conf, &unconf->cl_cb_conn);
4104 } else {
4105 old = find_confirmed_client_by_name(&unconf->cl_name, nn);
4106 if (old) {
4107 status = nfserr_clid_inuse;
4108 if (client_has_state(old)
4109 && !same_creds(&unconf->cl_cred,
4110 &old->cl_cred))
4111 goto out;
4112 status = mark_client_expired_locked(old);
4113 if (status) {
4114 old = NULL;
4115 goto out;
4116 }
4117 trace_nfsd_clid_replaced(&old->cl_clientid);
4118 }
4119 move_to_confirmed(unconf);
4120 conf = unconf;
4121 }
4122 get_client_locked(conf);
4123 spin_unlock(&nn->client_lock);
4124 if (conf == unconf)
4125 fsnotify_dentry(conf->cl_nfsd_info_dentry, FS_MODIFY);
4126 nfsd4_probe_callback(conf);
4127 spin_lock(&nn->client_lock);
4128 put_client_renew_locked(conf);
4129out:
4130 spin_unlock(&nn->client_lock);
4131 if (old)
4132 expire_client(old);
4133 return status;
4134}
4135
4136static struct nfs4_file *nfsd4_alloc_file(void)
4137{
4138 return kmem_cache_alloc(file_slab, GFP_KERNEL);
4139}
4140
4141
4142static void nfsd4_init_file(struct svc_fh *fh, unsigned int hashval,
4143 struct nfs4_file *fp)
4144{
4145 lockdep_assert_held(&state_lock);
4146
4147 refcount_set(&fp->fi_ref, 1);
4148 spin_lock_init(&fp->fi_lock);
4149 INIT_LIST_HEAD(&fp->fi_stateids);
4150 INIT_LIST_HEAD(&fp->fi_delegations);
4151 INIT_LIST_HEAD(&fp->fi_clnt_odstate);
4152 fh_copy_shallow(&fp->fi_fhandle, &fh->fh_handle);
4153 fp->fi_deleg_file = NULL;
4154 fp->fi_had_conflict = false;
4155 fp->fi_share_deny = 0;
4156 memset(fp->fi_fds, 0, sizeof(fp->fi_fds));
4157 memset(fp->fi_access, 0, sizeof(fp->fi_access));
4158 fp->fi_aliased = false;
4159 fp->fi_inode = d_inode(fh->fh_dentry);
4160#ifdef CONFIG_NFSD_PNFS
4161 INIT_LIST_HEAD(&fp->fi_lo_states);
4162 atomic_set(&fp->fi_lo_recalls, 0);
4163#endif
4164 hlist_add_head_rcu(&fp->fi_hash, &file_hashtbl[hashval]);
4165}
4166
4167void
4168nfsd4_free_slabs(void)
4169{
4170 kmem_cache_destroy(client_slab);
4171 kmem_cache_destroy(openowner_slab);
4172 kmem_cache_destroy(lockowner_slab);
4173 kmem_cache_destroy(file_slab);
4174 kmem_cache_destroy(stateid_slab);
4175 kmem_cache_destroy(deleg_slab);
4176 kmem_cache_destroy(odstate_slab);
4177}
4178
4179int
4180nfsd4_init_slabs(void)
4181{
4182 client_slab = kmem_cache_create("nfsd4_clients",
4183 sizeof(struct nfs4_client), 0, 0, NULL);
4184 if (client_slab == NULL)
4185 goto out;
4186 openowner_slab = kmem_cache_create("nfsd4_openowners",
4187 sizeof(struct nfs4_openowner), 0, 0, NULL);
4188 if (openowner_slab == NULL)
4189 goto out_free_client_slab;
4190 lockowner_slab = kmem_cache_create("nfsd4_lockowners",
4191 sizeof(struct nfs4_lockowner), 0, 0, NULL);
4192 if (lockowner_slab == NULL)
4193 goto out_free_openowner_slab;
4194 file_slab = kmem_cache_create("nfsd4_files",
4195 sizeof(struct nfs4_file), 0, 0, NULL);
4196 if (file_slab == NULL)
4197 goto out_free_lockowner_slab;
4198 stateid_slab = kmem_cache_create("nfsd4_stateids",
4199 sizeof(struct nfs4_ol_stateid), 0, 0, NULL);
4200 if (stateid_slab == NULL)
4201 goto out_free_file_slab;
4202 deleg_slab = kmem_cache_create("nfsd4_delegations",
4203 sizeof(struct nfs4_delegation), 0, 0, NULL);
4204 if (deleg_slab == NULL)
4205 goto out_free_stateid_slab;
4206 odstate_slab = kmem_cache_create("nfsd4_odstate",
4207 sizeof(struct nfs4_clnt_odstate), 0, 0, NULL);
4208 if (odstate_slab == NULL)
4209 goto out_free_deleg_slab;
4210 return 0;
4211
4212out_free_deleg_slab:
4213 kmem_cache_destroy(deleg_slab);
4214out_free_stateid_slab:
4215 kmem_cache_destroy(stateid_slab);
4216out_free_file_slab:
4217 kmem_cache_destroy(file_slab);
4218out_free_lockowner_slab:
4219 kmem_cache_destroy(lockowner_slab);
4220out_free_openowner_slab:
4221 kmem_cache_destroy(openowner_slab);
4222out_free_client_slab:
4223 kmem_cache_destroy(client_slab);
4224out:
4225 return -ENOMEM;
4226}
4227
4228static void init_nfs4_replay(struct nfs4_replay *rp)
4229{
4230 rp->rp_status = nfserr_serverfault;
4231 rp->rp_buflen = 0;
4232 rp->rp_buf = rp->rp_ibuf;
4233 mutex_init(&rp->rp_mutex);
4234}
4235
4236static void nfsd4_cstate_assign_replay(struct nfsd4_compound_state *cstate,
4237 struct nfs4_stateowner *so)
4238{
4239 if (!nfsd4_has_session(cstate)) {
4240 mutex_lock(&so->so_replay.rp_mutex);
4241 cstate->replay_owner = nfs4_get_stateowner(so);
4242 }
4243}
4244
4245void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate)
4246{
4247 struct nfs4_stateowner *so = cstate->replay_owner;
4248
4249 if (so != NULL) {
4250 cstate->replay_owner = NULL;
4251 mutex_unlock(&so->so_replay.rp_mutex);
4252 nfs4_put_stateowner(so);
4253 }
4254}
4255
4256static inline void *alloc_stateowner(struct kmem_cache *slab, struct xdr_netobj *owner, struct nfs4_client *clp)
4257{
4258 struct nfs4_stateowner *sop;
4259
4260 sop = kmem_cache_alloc(slab, GFP_KERNEL);
4261 if (!sop)
4262 return NULL;
4263
4264 xdr_netobj_dup(&sop->so_owner, owner, GFP_KERNEL);
4265 if (!sop->so_owner.data) {
4266 kmem_cache_free(slab, sop);
4267 return NULL;
4268 }
4269
4270 INIT_LIST_HEAD(&sop->so_stateids);
4271 sop->so_client = clp;
4272 init_nfs4_replay(&sop->so_replay);
4273 atomic_set(&sop->so_count, 1);
4274 return sop;
4275}
4276
4277static void hash_openowner(struct nfs4_openowner *oo, struct nfs4_client *clp, unsigned int strhashval)
4278{
4279 lockdep_assert_held(&clp->cl_lock);
4280
4281 list_add(&oo->oo_owner.so_strhash,
4282 &clp->cl_ownerstr_hashtbl[strhashval]);
4283 list_add(&oo->oo_perclient, &clp->cl_openowners);
4284}
4285
4286static void nfs4_unhash_openowner(struct nfs4_stateowner *so)
4287{
4288 unhash_openowner_locked(openowner(so));
4289}
4290
4291static void nfs4_free_openowner(struct nfs4_stateowner *so)
4292{
4293 struct nfs4_openowner *oo = openowner(so);
4294
4295 kmem_cache_free(openowner_slab, oo);
4296}
4297
4298static const struct nfs4_stateowner_operations openowner_ops = {
4299 .so_unhash = nfs4_unhash_openowner,
4300 .so_free = nfs4_free_openowner,
4301};
4302
4303static struct nfs4_ol_stateid *
4304nfsd4_find_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
4305{
4306 struct nfs4_ol_stateid *local, *ret = NULL;
4307 struct nfs4_openowner *oo = open->op_openowner;
4308
4309 lockdep_assert_held(&fp->fi_lock);
4310
4311 list_for_each_entry(local, &fp->fi_stateids, st_perfile) {
4312
4313 if (local->st_stateowner->so_is_open_owner == 0)
4314 continue;
4315 if (local->st_stateowner != &oo->oo_owner)
4316 continue;
4317 if (local->st_stid.sc_type == NFS4_OPEN_STID) {
4318 ret = local;
4319 refcount_inc(&ret->st_stid.sc_count);
4320 break;
4321 }
4322 }
4323 return ret;
4324}
4325
4326static __be32
4327nfsd4_verify_open_stid(struct nfs4_stid *s)
4328{
4329 __be32 ret = nfs_ok;
4330
4331 switch (s->sc_type) {
4332 default:
4333 break;
4334 case 0:
4335 case NFS4_CLOSED_STID:
4336 case NFS4_CLOSED_DELEG_STID:
4337 ret = nfserr_bad_stateid;
4338 break;
4339 case NFS4_REVOKED_DELEG_STID:
4340 ret = nfserr_deleg_revoked;
4341 }
4342 return ret;
4343}
4344
4345
4346static __be32
4347nfsd4_lock_ol_stateid(struct nfs4_ol_stateid *stp)
4348{
4349 __be32 ret;
4350
4351 mutex_lock_nested(&stp->st_mutex, LOCK_STATEID_MUTEX);
4352 ret = nfsd4_verify_open_stid(&stp->st_stid);
4353 if (ret != nfs_ok)
4354 mutex_unlock(&stp->st_mutex);
4355 return ret;
4356}
4357
4358static struct nfs4_ol_stateid *
4359nfsd4_find_and_lock_existing_open(struct nfs4_file *fp, struct nfsd4_open *open)
4360{
4361 struct nfs4_ol_stateid *stp;
4362 for (;;) {
4363 spin_lock(&fp->fi_lock);
4364 stp = nfsd4_find_existing_open(fp, open);
4365 spin_unlock(&fp->fi_lock);
4366 if (!stp || nfsd4_lock_ol_stateid(stp) == nfs_ok)
4367 break;
4368 nfs4_put_stid(&stp->st_stid);
4369 }
4370 return stp;
4371}
4372
4373static struct nfs4_openowner *
4374alloc_init_open_stateowner(unsigned int strhashval, struct nfsd4_open *open,
4375 struct nfsd4_compound_state *cstate)
4376{
4377 struct nfs4_client *clp = cstate->clp;
4378 struct nfs4_openowner *oo, *ret;
4379
4380 oo = alloc_stateowner(openowner_slab, &open->op_owner, clp);
4381 if (!oo)
4382 return NULL;
4383 oo->oo_owner.so_ops = &openowner_ops;
4384 oo->oo_owner.so_is_open_owner = 1;
4385 oo->oo_owner.so_seqid = open->op_seqid;
4386 oo->oo_flags = 0;
4387 if (nfsd4_has_session(cstate))
4388 oo->oo_flags |= NFS4_OO_CONFIRMED;
4389 oo->oo_time = 0;
4390 oo->oo_last_closed_stid = NULL;
4391 INIT_LIST_HEAD(&oo->oo_close_lru);
4392 spin_lock(&clp->cl_lock);
4393 ret = find_openstateowner_str_locked(strhashval, open, clp);
4394 if (ret == NULL) {
4395 hash_openowner(oo, clp, strhashval);
4396 ret = oo;
4397 } else
4398 nfs4_free_stateowner(&oo->oo_owner);
4399
4400 spin_unlock(&clp->cl_lock);
4401 return ret;
4402}
4403
4404static struct nfs4_ol_stateid *
4405init_open_stateid(struct nfs4_file *fp, struct nfsd4_open *open)
4406{
4407
4408 struct nfs4_openowner *oo = open->op_openowner;
4409 struct nfs4_ol_stateid *retstp = NULL;
4410 struct nfs4_ol_stateid *stp;
4411
4412 stp = open->op_stp;
4413
4414 mutex_init(&stp->st_mutex);
4415 mutex_lock_nested(&stp->st_mutex, OPEN_STATEID_MUTEX);
4416
4417retry:
4418 spin_lock(&oo->oo_owner.so_client->cl_lock);
4419 spin_lock(&fp->fi_lock);
4420
4421 retstp = nfsd4_find_existing_open(fp, open);
4422 if (retstp)
4423 goto out_unlock;
4424
4425 open->op_stp = NULL;
4426 refcount_inc(&stp->st_stid.sc_count);
4427 stp->st_stid.sc_type = NFS4_OPEN_STID;
4428 INIT_LIST_HEAD(&stp->st_locks);
4429 stp->st_stateowner = nfs4_get_stateowner(&oo->oo_owner);
4430 get_nfs4_file(fp);
4431 stp->st_stid.sc_file = fp;
4432 stp->st_access_bmap = 0;
4433 stp->st_deny_bmap = 0;
4434 stp->st_openstp = NULL;
4435 list_add(&stp->st_perstateowner, &oo->oo_owner.so_stateids);
4436 list_add(&stp->st_perfile, &fp->fi_stateids);
4437
4438out_unlock:
4439 spin_unlock(&fp->fi_lock);
4440 spin_unlock(&oo->oo_owner.so_client->cl_lock);
4441 if (retstp) {
4442
4443 if (nfsd4_lock_ol_stateid(retstp) != nfs_ok) {
4444 nfs4_put_stid(&retstp->st_stid);
4445 goto retry;
4446 }
4447
4448 mutex_unlock(&stp->st_mutex);
4449 stp = retstp;
4450 }
4451 return stp;
4452}
4453
4454
4455
4456
4457
4458
4459static void
4460move_to_close_lru(struct nfs4_ol_stateid *s, struct net *net)
4461{
4462 struct nfs4_ol_stateid *last;
4463 struct nfs4_openowner *oo = openowner(s->st_stateowner);
4464 struct nfsd_net *nn = net_generic(s->st_stid.sc_client->net,
4465 nfsd_net_id);
4466
4467 dprintk("NFSD: move_to_close_lru nfs4_openowner %p\n", oo);
4468
4469
4470
4471
4472
4473
4474
4475
4476
4477
4478 wait_event(close_wq, refcount_read(&s->st_stid.sc_count) == 2);
4479
4480 release_all_access(s);
4481 if (s->st_stid.sc_file) {
4482 put_nfs4_file(s->st_stid.sc_file);
4483 s->st_stid.sc_file = NULL;
4484 }
4485
4486 spin_lock(&nn->client_lock);
4487 last = oo->oo_last_closed_stid;
4488 oo->oo_last_closed_stid = s;
4489 list_move_tail(&oo->oo_close_lru, &nn->close_lru);
4490 oo->oo_time = ktime_get_boottime_seconds();
4491 spin_unlock(&nn->client_lock);
4492 if (last)
4493 nfs4_put_stid(&last->st_stid);
4494}
4495
4496
4497static struct nfs4_file *
4498find_file_locked(struct svc_fh *fh, unsigned int hashval)
4499{
4500 struct nfs4_file *fp;
4501
4502 hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash,
4503 lockdep_is_held(&state_lock)) {
4504 if (fh_match(&fp->fi_fhandle, &fh->fh_handle)) {
4505 if (refcount_inc_not_zero(&fp->fi_ref))
4506 return fp;
4507 }
4508 }
4509 return NULL;
4510}
4511
4512static struct nfs4_file *insert_file(struct nfs4_file *new, struct svc_fh *fh,
4513 unsigned int hashval)
4514{
4515 struct nfs4_file *fp;
4516 struct nfs4_file *ret = NULL;
4517 bool alias_found = false;
4518
4519 spin_lock(&state_lock);
4520 hlist_for_each_entry_rcu(fp, &file_hashtbl[hashval], fi_hash,
4521 lockdep_is_held(&state_lock)) {
4522 if (fh_match(&fp->fi_fhandle, &fh->fh_handle)) {
4523 if (refcount_inc_not_zero(&fp->fi_ref))
4524 ret = fp;
4525 } else if (d_inode(fh->fh_dentry) == fp->fi_inode)
4526 fp->fi_aliased = alias_found = true;
4527 }
4528 if (likely(ret == NULL)) {
4529 nfsd4_init_file(fh, hashval, new);
4530 new->fi_aliased = alias_found;
4531 ret = new;
4532 }
4533 spin_unlock(&state_lock);
4534 return ret;
4535}
4536
4537static struct nfs4_file * find_file(struct svc_fh *fh)
4538{
4539 struct nfs4_file *fp;
4540 unsigned int hashval = file_hashval(fh);
4541
4542 rcu_read_lock();
4543 fp = find_file_locked(fh, hashval);
4544 rcu_read_unlock();
4545 return fp;
4546}
4547
4548static struct nfs4_file *
4549find_or_add_file(struct nfs4_file *new, struct svc_fh *fh)
4550{
4551 struct nfs4_file *fp;
4552 unsigned int hashval = file_hashval(fh);
4553
4554 rcu_read_lock();
4555 fp = find_file_locked(fh, hashval);
4556 rcu_read_unlock();
4557 if (fp)
4558 return fp;
4559
4560 return insert_file(new, fh, hashval);
4561}
4562
4563
4564
4565
4566
4567static __be32
4568nfs4_share_conflict(struct svc_fh *current_fh, unsigned int deny_type)
4569{
4570 struct nfs4_file *fp;
4571 __be32 ret = nfs_ok;
4572
4573 fp = find_file(current_fh);
4574 if (!fp)
4575 return ret;
4576
4577 spin_lock(&fp->fi_lock);
4578 if (fp->fi_share_deny & deny_type)
4579 ret = nfserr_locked;
4580 spin_unlock(&fp->fi_lock);
4581 put_nfs4_file(fp);
4582 return ret;
4583}
4584
4585static void nfsd4_cb_recall_prepare(struct nfsd4_callback *cb)
4586{
4587 struct nfs4_delegation *dp = cb_to_delegation(cb);
4588 struct nfsd_net *nn = net_generic(dp->dl_stid.sc_client->net,
4589 nfsd_net_id);
4590
4591 block_delegations(&dp->dl_stid.sc_file->fi_fhandle);
4592
4593
4594
4595
4596
4597
4598
4599
4600 spin_lock(&state_lock);
4601 if (dp->dl_time == 0) {
4602 dp->dl_time = ktime_get_boottime_seconds();
4603 list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
4604 }
4605 spin_unlock(&state_lock);
4606}
4607
4608static int nfsd4_cb_recall_done(struct nfsd4_callback *cb,
4609 struct rpc_task *task)
4610{
4611 struct nfs4_delegation *dp = cb_to_delegation(cb);
4612
4613 if (dp->dl_stid.sc_type == NFS4_CLOSED_DELEG_STID ||
4614 dp->dl_stid.sc_type == NFS4_REVOKED_DELEG_STID)
4615 return 1;
4616
4617 switch (task->tk_status) {
4618 case 0:
4619 return 1;
4620 case -NFS4ERR_DELAY:
4621 rpc_delay(task, 2 * HZ);
4622 return 0;
4623 case -EBADHANDLE:
4624 case -NFS4ERR_BAD_STATEID:
4625
4626
4627
4628
4629 if (dp->dl_retries--) {
4630 rpc_delay(task, 2 * HZ);
4631 return 0;
4632 }
4633 fallthrough;
4634 default:
4635 return 1;
4636 }
4637}
4638
4639static void nfsd4_cb_recall_release(struct nfsd4_callback *cb)
4640{
4641 struct nfs4_delegation *dp = cb_to_delegation(cb);
4642
4643 nfs4_put_stid(&dp->dl_stid);
4644}
4645
4646static const struct nfsd4_callback_ops nfsd4_cb_recall_ops = {
4647 .prepare = nfsd4_cb_recall_prepare,
4648 .done = nfsd4_cb_recall_done,
4649 .release = nfsd4_cb_recall_release,
4650};
4651
4652static void nfsd_break_one_deleg(struct nfs4_delegation *dp)
4653{
4654
4655
4656
4657
4658
4659
4660
4661 refcount_inc(&dp->dl_stid.sc_count);
4662 nfsd4_run_cb(&dp->dl_recall);
4663}
4664
4665
4666static bool
4667nfsd_break_deleg_cb(struct file_lock *fl)
4668{
4669 bool ret = false;
4670 struct nfs4_delegation *dp = (struct nfs4_delegation *)fl->fl_owner;
4671 struct nfs4_file *fp = dp->dl_stid.sc_file;
4672
4673 trace_nfsd_cb_recall(&dp->dl_stid);
4674
4675
4676
4677
4678
4679
4680 fl->fl_break_time = 0;
4681
4682 spin_lock(&fp->fi_lock);
4683 fp->fi_had_conflict = true;
4684 nfsd_break_one_deleg(dp);
4685 spin_unlock(&fp->fi_lock);
4686 return ret;
4687}
4688
4689static bool nfsd_breaker_owns_lease(struct file_lock *fl)
4690{
4691 struct nfs4_delegation *dl = fl->fl_owner;
4692 struct svc_rqst *rqst;
4693 struct nfs4_client *clp;
4694
4695 if (!i_am_nfsd())
4696 return NULL;
4697 rqst = kthread_data(current);
4698
4699 if (rqst->rq_prog != NFS_PROGRAM || rqst->rq_vers < 4)
4700 return NULL;
4701 clp = *(rqst->rq_lease_breaker);
4702 return dl->dl_stid.sc_client == clp;
4703}
4704
4705static int
4706nfsd_change_deleg_cb(struct file_lock *onlist, int arg,
4707 struct list_head *dispose)
4708{
4709 if (arg & F_UNLCK)
4710 return lease_modify(onlist, arg, dispose);
4711 else
4712 return -EAGAIN;
4713}
4714
4715static const struct lock_manager_operations nfsd_lease_mng_ops = {
4716 .lm_breaker_owns_lease = nfsd_breaker_owns_lease,
4717 .lm_break = nfsd_break_deleg_cb,
4718 .lm_change = nfsd_change_deleg_cb,
4719};
4720
4721static __be32 nfsd4_check_seqid(struct nfsd4_compound_state *cstate, struct nfs4_stateowner *so, u32 seqid)
4722{
4723 if (nfsd4_has_session(cstate))
4724 return nfs_ok;
4725 if (seqid == so->so_seqid - 1)
4726 return nfserr_replay_me;
4727 if (seqid == so->so_seqid)
4728 return nfs_ok;
4729 return nfserr_bad_seqid;
4730}
4731
4732static struct nfs4_client *lookup_clientid(clientid_t *clid, bool sessions,
4733 struct nfsd_net *nn)
4734{
4735 struct nfs4_client *found;
4736
4737 spin_lock(&nn->client_lock);
4738 found = find_confirmed_client(clid, sessions, nn);
4739 if (found)
4740 atomic_inc(&found->cl_rpc_users);
4741 spin_unlock(&nn->client_lock);
4742 return found;
4743}
4744
4745static __be32 set_client(clientid_t *clid,
4746 struct nfsd4_compound_state *cstate,
4747 struct nfsd_net *nn)
4748{
4749 if (cstate->clp) {
4750 if (!same_clid(&cstate->clp->cl_clientid, clid))
4751 return nfserr_stale_clientid;
4752 return nfs_ok;
4753 }
4754 if (STALE_CLIENTID(clid, nn))
4755 return nfserr_stale_clientid;
4756
4757
4758
4759
4760 cstate->clp = lookup_clientid(clid, false, nn);
4761 if (!cstate->clp)
4762 return nfserr_expired;
4763 return nfs_ok;
4764}
4765
4766__be32
4767nfsd4_process_open1(struct nfsd4_compound_state *cstate,
4768 struct nfsd4_open *open, struct nfsd_net *nn)
4769{
4770 clientid_t *clientid = &open->op_clientid;
4771 struct nfs4_client *clp = NULL;
4772 unsigned int strhashval;
4773 struct nfs4_openowner *oo = NULL;
4774 __be32 status;
4775
4776
4777
4778
4779
4780 open->op_file = nfsd4_alloc_file();
4781 if (open->op_file == NULL)
4782 return nfserr_jukebox;
4783
4784 status = set_client(clientid, cstate, nn);
4785 if (status)
4786 return status;
4787 clp = cstate->clp;
4788
4789 strhashval = ownerstr_hashval(&open->op_owner);
4790 oo = find_openstateowner_str(strhashval, open, clp);
4791 open->op_openowner = oo;
4792 if (!oo) {
4793 goto new_owner;
4794 }
4795 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
4796
4797 release_openowner(oo);
4798 open->op_openowner = NULL;
4799 goto new_owner;
4800 }
4801 status = nfsd4_check_seqid(cstate, &oo->oo_owner, open->op_seqid);
4802 if (status)
4803 return status;
4804 goto alloc_stateid;
4805new_owner:
4806 oo = alloc_init_open_stateowner(strhashval, open, cstate);
4807 if (oo == NULL)
4808 return nfserr_jukebox;
4809 open->op_openowner = oo;
4810alloc_stateid:
4811 open->op_stp = nfs4_alloc_open_stateid(clp);
4812 if (!open->op_stp)
4813 return nfserr_jukebox;
4814
4815 if (nfsd4_has_session(cstate) &&
4816 (cstate->current_fh.fh_export->ex_flags & NFSEXP_PNFS)) {
4817 open->op_odstate = alloc_clnt_odstate(clp);
4818 if (!open->op_odstate)
4819 return nfserr_jukebox;
4820 }
4821
4822 return nfs_ok;
4823}
4824
4825static inline __be32
4826nfs4_check_delegmode(struct nfs4_delegation *dp, int flags)
4827{
4828 if ((flags & WR_STATE) && (dp->dl_type == NFS4_OPEN_DELEGATE_READ))
4829 return nfserr_openmode;
4830 else
4831 return nfs_ok;
4832}
4833
4834static int share_access_to_flags(u32 share_access)
4835{
4836 return share_access == NFS4_SHARE_ACCESS_READ ? RD_STATE : WR_STATE;
4837}
4838
4839static struct nfs4_delegation *find_deleg_stateid(struct nfs4_client *cl, stateid_t *s)
4840{
4841 struct nfs4_stid *ret;
4842
4843 ret = find_stateid_by_type(cl, s,
4844 NFS4_DELEG_STID|NFS4_REVOKED_DELEG_STID);
4845 if (!ret)
4846 return NULL;
4847 return delegstateid(ret);
4848}
4849
4850static bool nfsd4_is_deleg_cur(struct nfsd4_open *open)
4851{
4852 return open->op_claim_type == NFS4_OPEN_CLAIM_DELEGATE_CUR ||
4853 open->op_claim_type == NFS4_OPEN_CLAIM_DELEG_CUR_FH;
4854}
4855
4856static __be32
4857nfs4_check_deleg(struct nfs4_client *cl, struct nfsd4_open *open,
4858 struct nfs4_delegation **dp)
4859{
4860 int flags;
4861 __be32 status = nfserr_bad_stateid;
4862 struct nfs4_delegation *deleg;
4863
4864 deleg = find_deleg_stateid(cl, &open->op_delegate_stateid);
4865 if (deleg == NULL)
4866 goto out;
4867 if (deleg->dl_stid.sc_type == NFS4_REVOKED_DELEG_STID) {
4868 nfs4_put_stid(&deleg->dl_stid);
4869 if (cl->cl_minorversion)
4870 status = nfserr_deleg_revoked;
4871 goto out;
4872 }
4873 flags = share_access_to_flags(open->op_share_access);
4874 status = nfs4_check_delegmode(deleg, flags);
4875 if (status) {
4876 nfs4_put_stid(&deleg->dl_stid);
4877 goto out;
4878 }
4879 *dp = deleg;
4880out:
4881 if (!nfsd4_is_deleg_cur(open))
4882 return nfs_ok;
4883 if (status)
4884 return status;
4885 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
4886 return nfs_ok;
4887}
4888
4889static inline int nfs4_access_to_access(u32 nfs4_access)
4890{
4891 int flags = 0;
4892
4893 if (nfs4_access & NFS4_SHARE_ACCESS_READ)
4894 flags |= NFSD_MAY_READ;
4895 if (nfs4_access & NFS4_SHARE_ACCESS_WRITE)
4896 flags |= NFSD_MAY_WRITE;
4897 return flags;
4898}
4899
4900static inline __be32
4901nfsd4_truncate(struct svc_rqst *rqstp, struct svc_fh *fh,
4902 struct nfsd4_open *open)
4903{
4904 struct iattr iattr = {
4905 .ia_valid = ATTR_SIZE,
4906 .ia_size = 0,
4907 };
4908 if (!open->op_truncate)
4909 return 0;
4910 if (!(open->op_share_access & NFS4_SHARE_ACCESS_WRITE))
4911 return nfserr_inval;
4912 return nfsd_setattr(rqstp, fh, &iattr, 0, (time64_t)0);
4913}
4914
4915static __be32 nfs4_get_vfs_file(struct svc_rqst *rqstp, struct nfs4_file *fp,
4916 struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp,
4917 struct nfsd4_open *open)
4918{
4919 struct nfsd_file *nf = NULL;
4920 __be32 status;
4921 int oflag = nfs4_access_to_omode(open->op_share_access);
4922 int access = nfs4_access_to_access(open->op_share_access);
4923 unsigned char old_access_bmap, old_deny_bmap;
4924
4925 spin_lock(&fp->fi_lock);
4926
4927
4928
4929
4930
4931 status = nfs4_file_check_deny(fp, open->op_share_deny);
4932 if (status != nfs_ok) {
4933 spin_unlock(&fp->fi_lock);
4934 goto out;
4935 }
4936
4937
4938 status = nfs4_file_get_access(fp, open->op_share_access);
4939 if (status != nfs_ok) {
4940 spin_unlock(&fp->fi_lock);
4941 goto out;
4942 }
4943
4944
4945 old_access_bmap = stp->st_access_bmap;
4946 set_access(open->op_share_access, stp);
4947
4948
4949 old_deny_bmap = stp->st_deny_bmap;
4950 set_deny(open->op_share_deny, stp);
4951 fp->fi_share_deny |= (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
4952
4953 if (!fp->fi_fds[oflag]) {
4954 spin_unlock(&fp->fi_lock);
4955 status = nfsd_file_acquire(rqstp, cur_fh, access, &nf);
4956 if (status)
4957 goto out_put_access;
4958 spin_lock(&fp->fi_lock);
4959 if (!fp->fi_fds[oflag]) {
4960 fp->fi_fds[oflag] = nf;
4961 nf = NULL;
4962 }
4963 }
4964 spin_unlock(&fp->fi_lock);
4965 if (nf)
4966 nfsd_file_put(nf);
4967
4968 status = nfserrno(nfsd_open_break_lease(cur_fh->fh_dentry->d_inode,
4969 access));
4970 if (status)
4971 goto out_put_access;
4972
4973 status = nfsd4_truncate(rqstp, cur_fh, open);
4974 if (status)
4975 goto out_put_access;
4976out:
4977 return status;
4978out_put_access:
4979 stp->st_access_bmap = old_access_bmap;
4980 nfs4_file_put_access(fp, open->op_share_access);
4981 reset_union_bmap_deny(bmap_to_share_mode(old_deny_bmap), stp);
4982 goto out;
4983}
4984
4985static __be32
4986nfs4_upgrade_open(struct svc_rqst *rqstp, struct nfs4_file *fp, struct svc_fh *cur_fh, struct nfs4_ol_stateid *stp, struct nfsd4_open *open)
4987{
4988 __be32 status;
4989 unsigned char old_deny_bmap = stp->st_deny_bmap;
4990
4991 if (!test_access(open->op_share_access, stp))
4992 return nfs4_get_vfs_file(rqstp, fp, cur_fh, stp, open);
4993
4994
4995 spin_lock(&fp->fi_lock);
4996 status = nfs4_file_check_deny(fp, open->op_share_deny);
4997 if (status == nfs_ok) {
4998 set_deny(open->op_share_deny, stp);
4999 fp->fi_share_deny |=
5000 (open->op_share_deny & NFS4_SHARE_DENY_BOTH);
5001 }
5002 spin_unlock(&fp->fi_lock);
5003
5004 if (status != nfs_ok)
5005 return status;
5006
5007 status = nfsd4_truncate(rqstp, cur_fh, open);
5008 if (status != nfs_ok)
5009 reset_union_bmap_deny(old_deny_bmap, stp);
5010 return status;
5011}
5012
5013
5014static bool nfsd4_cb_channel_good(struct nfs4_client *clp)
5015{
5016 if (clp->cl_cb_state == NFSD4_CB_UP)
5017 return true;
5018
5019
5020
5021
5022
5023 return clp->cl_minorversion && clp->cl_cb_state == NFSD4_CB_UNKNOWN;
5024}
5025
5026static struct file_lock *nfs4_alloc_init_lease(struct nfs4_delegation *dp,
5027 int flag)
5028{
5029 struct file_lock *fl;
5030
5031 fl = locks_alloc_lock();
5032 if (!fl)
5033 return NULL;
5034 fl->fl_lmops = &nfsd_lease_mng_ops;
5035 fl->fl_flags = FL_DELEG;
5036 fl->fl_type = flag == NFS4_OPEN_DELEGATE_READ? F_RDLCK: F_WRLCK;
5037 fl->fl_end = OFFSET_MAX;
5038 fl->fl_owner = (fl_owner_t)dp;
5039 fl->fl_pid = current->tgid;
5040 fl->fl_file = dp->dl_stid.sc_file->fi_deleg_file->nf_file;
5041 return fl;
5042}
5043
5044static int nfsd4_check_conflicting_opens(struct nfs4_client *clp,
5045 struct nfs4_file *fp)
5046{
5047 struct nfs4_ol_stateid *st;
5048 struct file *f = fp->fi_deleg_file->nf_file;
5049 struct inode *ino = locks_inode(f);
5050 int writes;
5051
5052 writes = atomic_read(&ino->i_writecount);
5053 if (!writes)
5054 return 0;
5055
5056
5057
5058
5059
5060
5061
5062 if (fp->fi_aliased)
5063 return -EAGAIN;
5064
5065
5066
5067
5068
5069 smp_mb__after_atomic();
5070
5071 if (fp->fi_fds[O_WRONLY])
5072 writes--;
5073 if (fp->fi_fds[O_RDWR])
5074 writes--;
5075 if (writes > 0)
5076 return -EAGAIN;
5077
5078
5079
5080
5081
5082
5083
5084 spin_lock(&fp->fi_lock);
5085 list_for_each_entry(st, &fp->fi_stateids, st_perfile) {
5086 if (st->st_openstp == NULL &&
5087 access_permit_write(st) &&
5088 st->st_stid.sc_client != clp) {
5089 spin_unlock(&fp->fi_lock);
5090 return -EAGAIN;
5091 }
5092 }
5093 spin_unlock(&fp->fi_lock);
5094
5095
5096
5097
5098
5099
5100 return 0;
5101}
5102
5103static struct nfs4_delegation *
5104nfs4_set_delegation(struct nfs4_client *clp, struct svc_fh *fh,
5105 struct nfs4_file *fp, struct nfs4_clnt_odstate *odstate)
5106{
5107 int status = 0;
5108 struct nfs4_delegation *dp;
5109 struct nfsd_file *nf;
5110 struct file_lock *fl;
5111
5112
5113
5114
5115
5116
5117 if (fp->fi_had_conflict)
5118 return ERR_PTR(-EAGAIN);
5119
5120 nf = find_readable_file(fp);
5121 if (!nf) {
5122
5123
5124
5125
5126
5127 return ERR_PTR(-EAGAIN);
5128 }
5129 spin_lock(&state_lock);
5130 spin_lock(&fp->fi_lock);
5131 if (nfs4_delegation_exists(clp, fp))
5132 status = -EAGAIN;
5133 else if (!fp->fi_deleg_file) {
5134 fp->fi_deleg_file = nf;
5135
5136
5137 fp->fi_delegees = 1;
5138 nf = NULL;
5139 } else
5140 fp->fi_delegees++;
5141 spin_unlock(&fp->fi_lock);
5142 spin_unlock(&state_lock);
5143 if (nf)
5144 nfsd_file_put(nf);
5145 if (status)
5146 return ERR_PTR(status);
5147
5148 status = -ENOMEM;
5149 dp = alloc_init_deleg(clp, fp, fh, odstate);
5150 if (!dp)
5151 goto out_delegees;
5152
5153 fl = nfs4_alloc_init_lease(dp, NFS4_OPEN_DELEGATE_READ);
5154 if (!fl)
5155 goto out_clnt_odstate;
5156
5157 status = vfs_setlease(fp->fi_deleg_file->nf_file, fl->fl_type, &fl, NULL);
5158 if (fl)
5159 locks_free_lock(fl);
5160 if (status)
5161 goto out_clnt_odstate;
5162 status = nfsd4_check_conflicting_opens(clp, fp);
5163 if (status)
5164 goto out_unlock;
5165
5166 spin_lock(&state_lock);
5167 spin_lock(&fp->fi_lock);
5168 if (fp->fi_had_conflict)
5169 status = -EAGAIN;
5170 else
5171 status = hash_delegation_locked(dp, fp);
5172 spin_unlock(&fp->fi_lock);
5173 spin_unlock(&state_lock);
5174
5175 if (status)
5176 goto out_unlock;
5177
5178 return dp;
5179out_unlock:
5180 vfs_setlease(fp->fi_deleg_file->nf_file, F_UNLCK, NULL, (void **)&dp);
5181out_clnt_odstate:
5182 put_clnt_odstate(dp->dl_clnt_odstate);
5183 nfs4_put_stid(&dp->dl_stid);
5184out_delegees:
5185 put_deleg_file(fp);
5186 return ERR_PTR(status);
5187}
5188
5189static void nfsd4_open_deleg_none_ext(struct nfsd4_open *open, int status)
5190{
5191 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
5192 if (status == -EAGAIN)
5193 open->op_why_no_deleg = WND4_CONTENTION;
5194 else {
5195 open->op_why_no_deleg = WND4_RESOURCE;
5196 switch (open->op_deleg_want) {
5197 case NFS4_SHARE_WANT_READ_DELEG:
5198 case NFS4_SHARE_WANT_WRITE_DELEG:
5199 case NFS4_SHARE_WANT_ANY_DELEG:
5200 break;
5201 case NFS4_SHARE_WANT_CANCEL:
5202 open->op_why_no_deleg = WND4_CANCELLED;
5203 break;
5204 case NFS4_SHARE_WANT_NO_DELEG:
5205 WARN_ON_ONCE(1);
5206 }
5207 }
5208}
5209
5210
5211
5212
5213
5214
5215
5216static void
5217nfs4_open_delegation(struct svc_fh *fh, struct nfsd4_open *open,
5218 struct nfs4_ol_stateid *stp)
5219{
5220 struct nfs4_delegation *dp;
5221 struct nfs4_openowner *oo = openowner(stp->st_stateowner);
5222 struct nfs4_client *clp = stp->st_stid.sc_client;
5223 int cb_up;
5224 int status = 0;
5225
5226 cb_up = nfsd4_cb_channel_good(oo->oo_owner.so_client);
5227 open->op_recall = 0;
5228 switch (open->op_claim_type) {
5229 case NFS4_OPEN_CLAIM_PREVIOUS:
5230 if (!cb_up)
5231 open->op_recall = 1;
5232 if (open->op_delegate_type != NFS4_OPEN_DELEGATE_READ)
5233 goto out_no_deleg;
5234 break;
5235 case NFS4_OPEN_CLAIM_NULL:
5236 case NFS4_OPEN_CLAIM_FH:
5237
5238
5239
5240
5241
5242 if (locks_in_grace(clp->net))
5243 goto out_no_deleg;
5244 if (!cb_up || !(oo->oo_flags & NFS4_OO_CONFIRMED))
5245 goto out_no_deleg;
5246 break;
5247 default:
5248 goto out_no_deleg;
5249 }
5250 dp = nfs4_set_delegation(clp, fh, stp->st_stid.sc_file, stp->st_clnt_odstate);
5251 if (IS_ERR(dp))
5252 goto out_no_deleg;
5253
5254 memcpy(&open->op_delegate_stateid, &dp->dl_stid.sc_stateid, sizeof(dp->dl_stid.sc_stateid));
5255
5256 trace_nfsd_deleg_read(&dp->dl_stid.sc_stateid);
5257 open->op_delegate_type = NFS4_OPEN_DELEGATE_READ;
5258 nfs4_put_stid(&dp->dl_stid);
5259 return;
5260out_no_deleg:
5261 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE;
5262 if (open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS &&
5263 open->op_delegate_type != NFS4_OPEN_DELEGATE_NONE) {
5264 dprintk("NFSD: WARNING: refusing delegation reclaim\n");
5265 open->op_recall = 1;
5266 }
5267
5268
5269 if (open->op_deleg_want)
5270 nfsd4_open_deleg_none_ext(open, status);
5271 return;
5272}
5273
5274static void nfsd4_deleg_xgrade_none_ext(struct nfsd4_open *open,
5275 struct nfs4_delegation *dp)
5276{
5277 if (open->op_deleg_want == NFS4_SHARE_WANT_READ_DELEG &&
5278 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
5279 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
5280 open->op_why_no_deleg = WND4_NOT_SUPP_DOWNGRADE;
5281 } else if (open->op_deleg_want == NFS4_SHARE_WANT_WRITE_DELEG &&
5282 dp->dl_type == NFS4_OPEN_DELEGATE_WRITE) {
5283 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
5284 open->op_why_no_deleg = WND4_NOT_SUPP_UPGRADE;
5285 }
5286
5287
5288
5289
5290}
5291
5292__be32
5293nfsd4_process_open2(struct svc_rqst *rqstp, struct svc_fh *current_fh, struct nfsd4_open *open)
5294{
5295 struct nfsd4_compoundres *resp = rqstp->rq_resp;
5296 struct nfs4_client *cl = open->op_openowner->oo_owner.so_client;
5297 struct nfs4_file *fp = NULL;
5298 struct nfs4_ol_stateid *stp = NULL;
5299 struct nfs4_delegation *dp = NULL;
5300 __be32 status;
5301 bool new_stp = false;
5302
5303
5304
5305
5306
5307
5308 fp = find_or_add_file(open->op_file, current_fh);
5309 if (fp != open->op_file) {
5310 status = nfs4_check_deleg(cl, open, &dp);
5311 if (status)
5312 goto out;
5313 stp = nfsd4_find_and_lock_existing_open(fp, open);
5314 } else {
5315 open->op_file = NULL;
5316 status = nfserr_bad_stateid;
5317 if (nfsd4_is_deleg_cur(open))
5318 goto out;
5319 }
5320
5321 if (!stp) {
5322 stp = init_open_stateid(fp, open);
5323 if (!open->op_stp)
5324 new_stp = true;
5325 }
5326
5327
5328
5329
5330
5331
5332
5333 if (!new_stp) {
5334
5335 status = nfs4_upgrade_open(rqstp, fp, current_fh, stp, open);
5336 if (status) {
5337 mutex_unlock(&stp->st_mutex);
5338 goto out;
5339 }
5340 } else {
5341 status = nfs4_get_vfs_file(rqstp, fp, current_fh, stp, open);
5342 if (status) {
5343 stp->st_stid.sc_type = NFS4_CLOSED_STID;
5344 release_open_stateid(stp);
5345 mutex_unlock(&stp->st_mutex);
5346 goto out;
5347 }
5348
5349 stp->st_clnt_odstate = find_or_hash_clnt_odstate(fp,
5350 open->op_odstate);
5351 if (stp->st_clnt_odstate == open->op_odstate)
5352 open->op_odstate = NULL;
5353 }
5354
5355 nfs4_inc_and_copy_stateid(&open->op_stateid, &stp->st_stid);
5356 mutex_unlock(&stp->st_mutex);
5357
5358 if (nfsd4_has_session(&resp->cstate)) {
5359 if (open->op_deleg_want & NFS4_SHARE_WANT_NO_DELEG) {
5360 open->op_delegate_type = NFS4_OPEN_DELEGATE_NONE_EXT;
5361 open->op_why_no_deleg = WND4_NOT_WANTED;
5362 goto nodeleg;
5363 }
5364 }
5365
5366
5367
5368
5369
5370 nfs4_open_delegation(current_fh, open, stp);
5371nodeleg:
5372 status = nfs_ok;
5373 trace_nfsd_open(&stp->st_stid.sc_stateid);
5374out:
5375
5376 if (open->op_delegate_type == NFS4_OPEN_DELEGATE_NONE && dp &&
5377 open->op_deleg_want)
5378 nfsd4_deleg_xgrade_none_ext(open, dp);
5379
5380 if (fp)
5381 put_nfs4_file(fp);
5382 if (status == 0 && open->op_claim_type == NFS4_OPEN_CLAIM_PREVIOUS)
5383 open->op_openowner->oo_flags |= NFS4_OO_CONFIRMED;
5384
5385
5386
5387 open->op_rflags = NFS4_OPEN_RESULT_LOCKTYPE_POSIX;
5388 if (nfsd4_has_session(&resp->cstate))
5389 open->op_rflags |= NFS4_OPEN_RESULT_MAY_NOTIFY_LOCK;
5390 else if (!(open->op_openowner->oo_flags & NFS4_OO_CONFIRMED))
5391 open->op_rflags |= NFS4_OPEN_RESULT_CONFIRM;
5392
5393 if (dp)
5394 nfs4_put_stid(&dp->dl_stid);
5395 if (stp)
5396 nfs4_put_stid(&stp->st_stid);
5397
5398 return status;
5399}
5400
5401void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
5402 struct nfsd4_open *open)
5403{
5404 if (open->op_openowner) {
5405 struct nfs4_stateowner *so = &open->op_openowner->oo_owner;
5406
5407 nfsd4_cstate_assign_replay(cstate, so);
5408 nfs4_put_stateowner(so);
5409 }
5410 if (open->op_file)
5411 kmem_cache_free(file_slab, open->op_file);
5412 if (open->op_stp)
5413 nfs4_put_stid(&open->op_stp->st_stid);
5414 if (open->op_odstate)
5415 kmem_cache_free(odstate_slab, open->op_odstate);
5416}
5417
5418__be32
5419nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
5420 union nfsd4_op_u *u)
5421{
5422 clientid_t *clid = &u->renew;
5423 struct nfs4_client *clp;
5424 __be32 status;
5425 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
5426
5427 trace_nfsd_clid_renew(clid);
5428 status = set_client(clid, cstate, nn);
5429 if (status)
5430 return status;
5431 clp = cstate->clp;
5432 if (!list_empty(&clp->cl_delegations)
5433 && clp->cl_cb_state != NFSD4_CB_UP)
5434 return nfserr_cb_path_down;
5435 return nfs_ok;
5436}
5437
5438void
5439nfsd4_end_grace(struct nfsd_net *nn)
5440{
5441
5442 if (nn->grace_ended)
5443 return;
5444
5445 trace_nfsd_grace_complete(nn);
5446 nn->grace_ended = true;
5447
5448
5449
5450
5451
5452
5453 nfsd4_record_grace_done(nn);
5454
5455
5456
5457
5458
5459
5460
5461
5462
5463 locks_end_grace(&nn->nfsd4_manager);
5464
5465
5466
5467
5468
5469}
5470
5471
5472
5473
5474
5475static bool clients_still_reclaiming(struct nfsd_net *nn)
5476{
5477 time64_t double_grace_period_end = nn->boot_time +
5478 2 * nn->nfsd4_lease;
5479
5480 if (nn->track_reclaim_completes &&
5481 atomic_read(&nn->nr_reclaim_complete) ==
5482 nn->reclaim_str_hashtbl_size)
5483 return false;
5484 if (!nn->somebody_reclaimed)
5485 return false;
5486 nn->somebody_reclaimed = false;
5487
5488
5489
5490
5491 if (ktime_get_boottime_seconds() > double_grace_period_end)
5492 return false;
5493 return true;
5494}
5495
5496struct laundry_time {
5497 time64_t cutoff;
5498 time64_t new_timeo;
5499};
5500
5501static bool state_expired(struct laundry_time *lt, time64_t last_refresh)
5502{
5503 time64_t time_remaining;
5504
5505 if (last_refresh < lt->cutoff)
5506 return true;
5507 time_remaining = last_refresh - lt->cutoff;
5508 lt->new_timeo = min(lt->new_timeo, time_remaining);
5509 return false;
5510}
5511
5512#ifdef CONFIG_NFSD_V4_2_INTER_SSC
5513void nfsd4_ssc_init_umount_work(struct nfsd_net *nn)
5514{
5515 spin_lock_init(&nn->nfsd_ssc_lock);
5516 INIT_LIST_HEAD(&nn->nfsd_ssc_mount_list);
5517 init_waitqueue_head(&nn->nfsd_ssc_waitq);
5518}
5519EXPORT_SYMBOL_GPL(nfsd4_ssc_init_umount_work);
5520
5521
5522
5523
5524
5525static void nfsd4_ssc_shutdown_umount(struct nfsd_net *nn)
5526{
5527 struct nfsd4_ssc_umount_item *ni = NULL;
5528 struct nfsd4_ssc_umount_item *tmp;
5529
5530 spin_lock(&nn->nfsd_ssc_lock);
5531 list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
5532 list_del(&ni->nsui_list);
5533 spin_unlock(&nn->nfsd_ssc_lock);
5534 mntput(ni->nsui_vfsmount);
5535 kfree(ni);
5536 spin_lock(&nn->nfsd_ssc_lock);
5537 }
5538 spin_unlock(&nn->nfsd_ssc_lock);
5539}
5540
5541static void nfsd4_ssc_expire_umount(struct nfsd_net *nn)
5542{
5543 bool do_wakeup = false;
5544 struct nfsd4_ssc_umount_item *ni = 0;
5545 struct nfsd4_ssc_umount_item *tmp;
5546
5547 spin_lock(&nn->nfsd_ssc_lock);
5548 list_for_each_entry_safe(ni, tmp, &nn->nfsd_ssc_mount_list, nsui_list) {
5549 if (time_after(jiffies, ni->nsui_expire)) {
5550 if (refcount_read(&ni->nsui_refcnt) > 1)
5551 continue;
5552
5553
5554 ni->nsui_busy = true;
5555 spin_unlock(&nn->nfsd_ssc_lock);
5556 mntput(ni->nsui_vfsmount);
5557 spin_lock(&nn->nfsd_ssc_lock);
5558
5559
5560 list_del(&ni->nsui_list);
5561 kfree(ni);
5562
5563
5564 do_wakeup = true;
5565 continue;
5566 }
5567 break;
5568 }
5569 if (do_wakeup)
5570 wake_up_all(&nn->nfsd_ssc_waitq);
5571 spin_unlock(&nn->nfsd_ssc_lock);
5572}
5573#endif
5574
5575static time64_t
5576nfs4_laundromat(struct nfsd_net *nn)
5577{
5578 struct nfs4_client *clp;
5579 struct nfs4_openowner *oo;
5580 struct nfs4_delegation *dp;
5581 struct nfs4_ol_stateid *stp;
5582 struct nfsd4_blocked_lock *nbl;
5583 struct list_head *pos, *next, reaplist;
5584 struct laundry_time lt = {
5585 .cutoff = ktime_get_boottime_seconds() - nn->nfsd4_lease,
5586 .new_timeo = nn->nfsd4_lease
5587 };
5588 struct nfs4_cpntf_state *cps;
5589 copy_stateid_t *cps_t;
5590 int i;
5591
5592 if (clients_still_reclaiming(nn)) {
5593 lt.new_timeo = 0;
5594 goto out;
5595 }
5596 nfsd4_end_grace(nn);
5597 INIT_LIST_HEAD(&reaplist);
5598
5599 spin_lock(&nn->s2s_cp_lock);
5600 idr_for_each_entry(&nn->s2s_cp_stateids, cps_t, i) {
5601 cps = container_of(cps_t, struct nfs4_cpntf_state, cp_stateid);
5602 if (cps->cp_stateid.sc_type == NFS4_COPYNOTIFY_STID &&
5603 state_expired(<, cps->cpntf_time))
5604 _free_cpntf_state_locked(nn, cps);
5605 }
5606 spin_unlock(&nn->s2s_cp_lock);
5607
5608 spin_lock(&nn->client_lock);
5609 list_for_each_safe(pos, next, &nn->client_lru) {
5610 clp = list_entry(pos, struct nfs4_client, cl_lru);
5611 if (!state_expired(<, clp->cl_time))
5612 break;
5613 if (mark_client_expired_locked(clp))
5614 continue;
5615 list_add(&clp->cl_lru, &reaplist);
5616 }
5617 spin_unlock(&nn->client_lock);
5618 list_for_each_safe(pos, next, &reaplist) {
5619 clp = list_entry(pos, struct nfs4_client, cl_lru);
5620 trace_nfsd_clid_purged(&clp->cl_clientid);
5621 list_del_init(&clp->cl_lru);
5622 expire_client(clp);
5623 }
5624 spin_lock(&state_lock);
5625 list_for_each_safe(pos, next, &nn->del_recall_lru) {
5626 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
5627 if (!state_expired(<, dp->dl_time))
5628 break;
5629 WARN_ON(!unhash_delegation_locked(dp));
5630 list_add(&dp->dl_recall_lru, &reaplist);
5631 }
5632 spin_unlock(&state_lock);
5633 while (!list_empty(&reaplist)) {
5634 dp = list_first_entry(&reaplist, struct nfs4_delegation,
5635 dl_recall_lru);
5636 list_del_init(&dp->dl_recall_lru);
5637 revoke_delegation(dp);
5638 }
5639
5640 spin_lock(&nn->client_lock);
5641 while (!list_empty(&nn->close_lru)) {
5642 oo = list_first_entry(&nn->close_lru, struct nfs4_openowner,
5643 oo_close_lru);
5644 if (!state_expired(<, oo->oo_time))
5645 break;
5646 list_del_init(&oo->oo_close_lru);
5647 stp = oo->oo_last_closed_stid;
5648 oo->oo_last_closed_stid = NULL;
5649 spin_unlock(&nn->client_lock);
5650 nfs4_put_stid(&stp->st_stid);
5651 spin_lock(&nn->client_lock);
5652 }
5653 spin_unlock(&nn->client_lock);
5654
5655
5656
5657
5658
5659
5660
5661
5662
5663
5664
5665
5666 BUG_ON(!list_empty(&reaplist));
5667 spin_lock(&nn->blocked_locks_lock);
5668 while (!list_empty(&nn->blocked_locks_lru)) {
5669 nbl = list_first_entry(&nn->blocked_locks_lru,
5670 struct nfsd4_blocked_lock, nbl_lru);
5671 if (!state_expired(<, nbl->nbl_time))
5672 break;
5673 list_move(&nbl->nbl_lru, &reaplist);
5674 list_del_init(&nbl->nbl_list);
5675 }
5676 spin_unlock(&nn->blocked_locks_lock);
5677
5678 while (!list_empty(&reaplist)) {
5679 nbl = list_first_entry(&reaplist,
5680 struct nfsd4_blocked_lock, nbl_lru);
5681 list_del_init(&nbl->nbl_lru);
5682 free_blocked_lock(nbl);
5683 }
5684#ifdef CONFIG_NFSD_V4_2_INTER_SSC
5685
5686 nfsd4_ssc_expire_umount(nn);
5687#endif
5688out:
5689 return max_t(time64_t, lt.new_timeo, NFSD_LAUNDROMAT_MINTIMEOUT);
5690}
5691
5692static struct workqueue_struct *laundry_wq;
5693static void laundromat_main(struct work_struct *);
5694
5695static void
5696laundromat_main(struct work_struct *laundry)
5697{
5698 time64_t t;
5699 struct delayed_work *dwork = to_delayed_work(laundry);
5700 struct nfsd_net *nn = container_of(dwork, struct nfsd_net,
5701 laundromat_work);
5702
5703 t = nfs4_laundromat(nn);
5704 queue_delayed_work(laundry_wq, &nn->laundromat_work, t*HZ);
5705}
5706
5707static inline __be32 nfs4_check_fh(struct svc_fh *fhp, struct nfs4_stid *stp)
5708{
5709 if (!fh_match(&fhp->fh_handle, &stp->sc_file->fi_fhandle))
5710 return nfserr_bad_stateid;
5711 return nfs_ok;
5712}
5713
5714static
5715__be32 nfs4_check_openmode(struct nfs4_ol_stateid *stp, int flags)
5716{
5717 __be32 status = nfserr_openmode;
5718
5719
5720 if (stp->st_openstp)
5721 stp = stp->st_openstp;
5722 if ((flags & WR_STATE) && !access_permit_write(stp))
5723 goto out;
5724 if ((flags & RD_STATE) && !access_permit_read(stp))
5725 goto out;
5726 status = nfs_ok;
5727out:
5728 return status;
5729}
5730
5731static inline __be32
5732check_special_stateids(struct net *net, svc_fh *current_fh, stateid_t *stateid, int flags)
5733{
5734 if (ONE_STATEID(stateid) && (flags & RD_STATE))
5735 return nfs_ok;
5736 else if (opens_in_grace(net)) {
5737
5738
5739 return nfserr_grace;
5740 } else if (flags & WR_STATE)
5741 return nfs4_share_conflict(current_fh,
5742 NFS4_SHARE_DENY_WRITE);
5743 else
5744 return nfs4_share_conflict(current_fh,
5745 NFS4_SHARE_DENY_READ);
5746}
5747
5748static __be32 check_stateid_generation(stateid_t *in, stateid_t *ref, bool has_session)
5749{
5750
5751
5752
5753
5754 if (has_session && in->si_generation == 0)
5755 return nfs_ok;
5756
5757 if (in->si_generation == ref->si_generation)
5758 return nfs_ok;
5759
5760
5761 if (nfsd4_stateid_generation_after(in, ref))
5762 return nfserr_bad_stateid;
5763
5764
5765
5766
5767
5768
5769
5770
5771
5772
5773 return nfserr_old_stateid;
5774}
5775
5776static __be32 nfsd4_stid_check_stateid_generation(stateid_t *in, struct nfs4_stid *s, bool has_session)
5777{
5778 __be32 ret;
5779
5780 spin_lock(&s->sc_lock);
5781 ret = nfsd4_verify_open_stid(s);
5782 if (ret == nfs_ok)
5783 ret = check_stateid_generation(in, &s->sc_stateid, has_session);
5784 spin_unlock(&s->sc_lock);
5785 return ret;
5786}
5787
5788static __be32 nfsd4_check_openowner_confirmed(struct nfs4_ol_stateid *ols)
5789{
5790 if (ols->st_stateowner->so_is_open_owner &&
5791 !(openowner(ols->st_stateowner)->oo_flags & NFS4_OO_CONFIRMED))
5792 return nfserr_bad_stateid;
5793 return nfs_ok;
5794}
5795
5796static __be32 nfsd4_validate_stateid(struct nfs4_client *cl, stateid_t *stateid)
5797{
5798 struct nfs4_stid *s;
5799 __be32 status = nfserr_bad_stateid;
5800
5801 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
5802 CLOSE_STATEID(stateid))
5803 return status;
5804 if (!same_clid(&stateid->si_opaque.so_clid, &cl->cl_clientid))
5805 return status;
5806 spin_lock(&cl->cl_lock);
5807 s = find_stateid_locked(cl, stateid);
5808 if (!s)
5809 goto out_unlock;
5810 status = nfsd4_stid_check_stateid_generation(stateid, s, 1);
5811 if (status)
5812 goto out_unlock;
5813 switch (s->sc_type) {
5814 case NFS4_DELEG_STID:
5815 status = nfs_ok;
5816 break;
5817 case NFS4_REVOKED_DELEG_STID:
5818 status = nfserr_deleg_revoked;
5819 break;
5820 case NFS4_OPEN_STID:
5821 case NFS4_LOCK_STID:
5822 status = nfsd4_check_openowner_confirmed(openlockstateid(s));
5823 break;
5824 default:
5825 printk("unknown stateid type %x\n", s->sc_type);
5826 fallthrough;
5827 case NFS4_CLOSED_STID:
5828 case NFS4_CLOSED_DELEG_STID:
5829 status = nfserr_bad_stateid;
5830 }
5831out_unlock:
5832 spin_unlock(&cl->cl_lock);
5833 return status;
5834}
5835
5836__be32
5837nfsd4_lookup_stateid(struct nfsd4_compound_state *cstate,
5838 stateid_t *stateid, unsigned char typemask,
5839 struct nfs4_stid **s, struct nfsd_net *nn)
5840{
5841 __be32 status;
5842 bool return_revoked = false;
5843
5844
5845
5846
5847
5848 if (typemask & NFS4_REVOKED_DELEG_STID)
5849 return_revoked = true;
5850 else if (typemask & NFS4_DELEG_STID)
5851 typemask |= NFS4_REVOKED_DELEG_STID;
5852
5853 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid) ||
5854 CLOSE_STATEID(stateid))
5855 return nfserr_bad_stateid;
5856 status = set_client(&stateid->si_opaque.so_clid, cstate, nn);
5857 if (status == nfserr_stale_clientid) {
5858 if (cstate->session)
5859 return nfserr_bad_stateid;
5860 return nfserr_stale_stateid;
5861 }
5862 if (status)
5863 return status;
5864 *s = find_stateid_by_type(cstate->clp, stateid, typemask);
5865 if (!*s)
5866 return nfserr_bad_stateid;
5867 if (((*s)->sc_type == NFS4_REVOKED_DELEG_STID) && !return_revoked) {
5868 nfs4_put_stid(*s);
5869 if (cstate->minorversion)
5870 return nfserr_deleg_revoked;
5871 return nfserr_bad_stateid;
5872 }
5873 return nfs_ok;
5874}
5875
5876static struct nfsd_file *
5877nfs4_find_file(struct nfs4_stid *s, int flags)
5878{
5879 if (!s)
5880 return NULL;
5881
5882 switch (s->sc_type) {
5883 case NFS4_DELEG_STID:
5884 if (WARN_ON_ONCE(!s->sc_file->fi_deleg_file))
5885 return NULL;
5886 return nfsd_file_get(s->sc_file->fi_deleg_file);
5887 case NFS4_OPEN_STID:
5888 case NFS4_LOCK_STID:
5889 if (flags & RD_STATE)
5890 return find_readable_file(s->sc_file);
5891 else
5892 return find_writeable_file(s->sc_file);
5893 }
5894
5895 return NULL;
5896}
5897
5898static __be32
5899nfs4_check_olstateid(struct nfs4_ol_stateid *ols, int flags)
5900{
5901 __be32 status;
5902
5903 status = nfsd4_check_openowner_confirmed(ols);
5904 if (status)
5905 return status;
5906 return nfs4_check_openmode(ols, flags);
5907}
5908
5909static __be32
5910nfs4_check_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct nfs4_stid *s,
5911 struct nfsd_file **nfp, int flags)
5912{
5913 int acc = (flags & RD_STATE) ? NFSD_MAY_READ : NFSD_MAY_WRITE;
5914 struct nfsd_file *nf;
5915 __be32 status;
5916
5917 nf = nfs4_find_file(s, flags);
5918 if (nf) {
5919 status = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
5920 acc | NFSD_MAY_OWNER_OVERRIDE);
5921 if (status) {
5922 nfsd_file_put(nf);
5923 goto out;
5924 }
5925 } else {
5926 status = nfsd_file_acquire(rqstp, fhp, acc, &nf);
5927 if (status)
5928 return status;
5929 }
5930 *nfp = nf;
5931out:
5932 return status;
5933}
5934static void
5935_free_cpntf_state_locked(struct nfsd_net *nn, struct nfs4_cpntf_state *cps)
5936{
5937 WARN_ON_ONCE(cps->cp_stateid.sc_type != NFS4_COPYNOTIFY_STID);
5938 if (!refcount_dec_and_test(&cps->cp_stateid.sc_count))
5939 return;
5940 list_del(&cps->cp_list);
5941 idr_remove(&nn->s2s_cp_stateids,
5942 cps->cp_stateid.stid.si_opaque.so_id);
5943 kfree(cps);
5944}
5945
5946
5947
5948
5949
5950__be32 manage_cpntf_state(struct nfsd_net *nn, stateid_t *st,
5951 struct nfs4_client *clp,
5952 struct nfs4_cpntf_state **cps)
5953{
5954 copy_stateid_t *cps_t;
5955 struct nfs4_cpntf_state *state = NULL;
5956
5957 if (st->si_opaque.so_clid.cl_id != nn->s2s_cp_cl_id)
5958 return nfserr_bad_stateid;
5959 spin_lock(&nn->s2s_cp_lock);
5960 cps_t = idr_find(&nn->s2s_cp_stateids, st->si_opaque.so_id);
5961 if (cps_t) {
5962 state = container_of(cps_t, struct nfs4_cpntf_state,
5963 cp_stateid);
5964 if (state->cp_stateid.sc_type != NFS4_COPYNOTIFY_STID) {
5965 state = NULL;
5966 goto unlock;
5967 }
5968 if (!clp)
5969 refcount_inc(&state->cp_stateid.sc_count);
5970 else
5971 _free_cpntf_state_locked(nn, state);
5972 }
5973unlock:
5974 spin_unlock(&nn->s2s_cp_lock);
5975 if (!state)
5976 return nfserr_bad_stateid;
5977 if (!clp && state)
5978 *cps = state;
5979 return 0;
5980}
5981
5982static __be32 find_cpntf_state(struct nfsd_net *nn, stateid_t *st,
5983 struct nfs4_stid **stid)
5984{
5985 __be32 status;
5986 struct nfs4_cpntf_state *cps = NULL;
5987 struct nfs4_client *found;
5988
5989 status = manage_cpntf_state(nn, st, NULL, &cps);
5990 if (status)
5991 return status;
5992
5993 cps->cpntf_time = ktime_get_boottime_seconds();
5994
5995 status = nfserr_expired;
5996 found = lookup_clientid(&cps->cp_p_clid, true, nn);
5997 if (!found)
5998 goto out;
5999
6000 *stid = find_stateid_by_type(found, &cps->cp_p_stateid,
6001 NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID);
6002 if (*stid)
6003 status = nfs_ok;
6004 else
6005 status = nfserr_bad_stateid;
6006
6007 put_client_renew(found);
6008out:
6009 nfs4_put_cpntf_state(nn, cps);
6010 return status;
6011}
6012
6013void nfs4_put_cpntf_state(struct nfsd_net *nn, struct nfs4_cpntf_state *cps)
6014{
6015 spin_lock(&nn->s2s_cp_lock);
6016 _free_cpntf_state_locked(nn, cps);
6017 spin_unlock(&nn->s2s_cp_lock);
6018}
6019
6020
6021
6022
6023__be32
6024nfs4_preprocess_stateid_op(struct svc_rqst *rqstp,
6025 struct nfsd4_compound_state *cstate, struct svc_fh *fhp,
6026 stateid_t *stateid, int flags, struct nfsd_file **nfp,
6027 struct nfs4_stid **cstid)
6028{
6029 struct net *net = SVC_NET(rqstp);
6030 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6031 struct nfs4_stid *s = NULL;
6032 __be32 status;
6033
6034 if (nfp)
6035 *nfp = NULL;
6036
6037 if (ZERO_STATEID(stateid) || ONE_STATEID(stateid)) {
6038 status = check_special_stateids(net, fhp, stateid, flags);
6039 goto done;
6040 }
6041
6042 status = nfsd4_lookup_stateid(cstate, stateid,
6043 NFS4_DELEG_STID|NFS4_OPEN_STID|NFS4_LOCK_STID,
6044 &s, nn);
6045 if (status == nfserr_bad_stateid)
6046 status = find_cpntf_state(nn, stateid, &s);
6047 if (status)
6048 return status;
6049 status = nfsd4_stid_check_stateid_generation(stateid, s,
6050 nfsd4_has_session(cstate));
6051 if (status)
6052 goto out;
6053
6054 switch (s->sc_type) {
6055 case NFS4_DELEG_STID:
6056 status = nfs4_check_delegmode(delegstateid(s), flags);
6057 break;
6058 case NFS4_OPEN_STID:
6059 case NFS4_LOCK_STID:
6060 status = nfs4_check_olstateid(openlockstateid(s), flags);
6061 break;
6062 default:
6063 status = nfserr_bad_stateid;
6064 break;
6065 }
6066 if (status)
6067 goto out;
6068 status = nfs4_check_fh(fhp, s);
6069
6070done:
6071 if (status == nfs_ok && nfp)
6072 status = nfs4_check_file(rqstp, fhp, s, nfp, flags);
6073out:
6074 if (s) {
6075 if (!status && cstid)
6076 *cstid = s;
6077 else
6078 nfs4_put_stid(s);
6079 }
6080 return status;
6081}
6082
6083
6084
6085
6086__be32
6087nfsd4_test_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6088 union nfsd4_op_u *u)
6089{
6090 struct nfsd4_test_stateid *test_stateid = &u->test_stateid;
6091 struct nfsd4_test_stateid_id *stateid;
6092 struct nfs4_client *cl = cstate->clp;
6093
6094 list_for_each_entry(stateid, &test_stateid->ts_stateid_list, ts_id_list)
6095 stateid->ts_id_status =
6096 nfsd4_validate_stateid(cl, &stateid->ts_id_stateid);
6097
6098 return nfs_ok;
6099}
6100
6101static __be32
6102nfsd4_free_lock_stateid(stateid_t *stateid, struct nfs4_stid *s)
6103{
6104 struct nfs4_ol_stateid *stp = openlockstateid(s);
6105 __be32 ret;
6106
6107 ret = nfsd4_lock_ol_stateid(stp);
6108 if (ret)
6109 goto out_put_stid;
6110
6111 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
6112 if (ret)
6113 goto out;
6114
6115 ret = nfserr_locks_held;
6116 if (check_for_locks(stp->st_stid.sc_file,
6117 lockowner(stp->st_stateowner)))
6118 goto out;
6119
6120 release_lock_stateid(stp);
6121 ret = nfs_ok;
6122
6123out:
6124 mutex_unlock(&stp->st_mutex);
6125out_put_stid:
6126 nfs4_put_stid(s);
6127 return ret;
6128}
6129
6130__be32
6131nfsd4_free_stateid(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6132 union nfsd4_op_u *u)
6133{
6134 struct nfsd4_free_stateid *free_stateid = &u->free_stateid;
6135 stateid_t *stateid = &free_stateid->fr_stateid;
6136 struct nfs4_stid *s;
6137 struct nfs4_delegation *dp;
6138 struct nfs4_client *cl = cstate->clp;
6139 __be32 ret = nfserr_bad_stateid;
6140
6141 spin_lock(&cl->cl_lock);
6142 s = find_stateid_locked(cl, stateid);
6143 if (!s)
6144 goto out_unlock;
6145 spin_lock(&s->sc_lock);
6146 switch (s->sc_type) {
6147 case NFS4_DELEG_STID:
6148 ret = nfserr_locks_held;
6149 break;
6150 case NFS4_OPEN_STID:
6151 ret = check_stateid_generation(stateid, &s->sc_stateid, 1);
6152 if (ret)
6153 break;
6154 ret = nfserr_locks_held;
6155 break;
6156 case NFS4_LOCK_STID:
6157 spin_unlock(&s->sc_lock);
6158 refcount_inc(&s->sc_count);
6159 spin_unlock(&cl->cl_lock);
6160 ret = nfsd4_free_lock_stateid(stateid, s);
6161 goto out;
6162 case NFS4_REVOKED_DELEG_STID:
6163 spin_unlock(&s->sc_lock);
6164 dp = delegstateid(s);
6165 list_del_init(&dp->dl_recall_lru);
6166 spin_unlock(&cl->cl_lock);
6167 nfs4_put_stid(s);
6168 ret = nfs_ok;
6169 goto out;
6170
6171 }
6172 spin_unlock(&s->sc_lock);
6173out_unlock:
6174 spin_unlock(&cl->cl_lock);
6175out:
6176 return ret;
6177}
6178
6179static inline int
6180setlkflg (int type)
6181{
6182 return (type == NFS4_READW_LT || type == NFS4_READ_LT) ?
6183 RD_STATE : WR_STATE;
6184}
6185
6186static __be32 nfs4_seqid_op_checks(struct nfsd4_compound_state *cstate, stateid_t *stateid, u32 seqid, struct nfs4_ol_stateid *stp)
6187{
6188 struct svc_fh *current_fh = &cstate->current_fh;
6189 struct nfs4_stateowner *sop = stp->st_stateowner;
6190 __be32 status;
6191
6192 status = nfsd4_check_seqid(cstate, sop, seqid);
6193 if (status)
6194 return status;
6195 status = nfsd4_lock_ol_stateid(stp);
6196 if (status != nfs_ok)
6197 return status;
6198 status = check_stateid_generation(stateid, &stp->st_stid.sc_stateid, nfsd4_has_session(cstate));
6199 if (status == nfs_ok)
6200 status = nfs4_check_fh(current_fh, &stp->st_stid);
6201 if (status != nfs_ok)
6202 mutex_unlock(&stp->st_mutex);
6203 return status;
6204}
6205
6206
6207
6208
6209static __be32
6210nfs4_preprocess_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
6211 stateid_t *stateid, char typemask,
6212 struct nfs4_ol_stateid **stpp,
6213 struct nfsd_net *nn)
6214{
6215 __be32 status;
6216 struct nfs4_stid *s;
6217 struct nfs4_ol_stateid *stp = NULL;
6218
6219 trace_nfsd_preprocess(seqid, stateid);
6220
6221 *stpp = NULL;
6222 status = nfsd4_lookup_stateid(cstate, stateid, typemask, &s, nn);
6223 if (status)
6224 return status;
6225 stp = openlockstateid(s);
6226 nfsd4_cstate_assign_replay(cstate, stp->st_stateowner);
6227
6228 status = nfs4_seqid_op_checks(cstate, stateid, seqid, stp);
6229 if (!status)
6230 *stpp = stp;
6231 else
6232 nfs4_put_stid(&stp->st_stid);
6233 return status;
6234}
6235
6236static __be32 nfs4_preprocess_confirmed_seqid_op(struct nfsd4_compound_state *cstate, u32 seqid,
6237 stateid_t *stateid, struct nfs4_ol_stateid **stpp, struct nfsd_net *nn)
6238{
6239 __be32 status;
6240 struct nfs4_openowner *oo;
6241 struct nfs4_ol_stateid *stp;
6242
6243 status = nfs4_preprocess_seqid_op(cstate, seqid, stateid,
6244 NFS4_OPEN_STID, &stp, nn);
6245 if (status)
6246 return status;
6247 oo = openowner(stp->st_stateowner);
6248 if (!(oo->oo_flags & NFS4_OO_CONFIRMED)) {
6249 mutex_unlock(&stp->st_mutex);
6250 nfs4_put_stid(&stp->st_stid);
6251 return nfserr_bad_stateid;
6252 }
6253 *stpp = stp;
6254 return nfs_ok;
6255}
6256
6257__be32
6258nfsd4_open_confirm(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6259 union nfsd4_op_u *u)
6260{
6261 struct nfsd4_open_confirm *oc = &u->open_confirm;
6262 __be32 status;
6263 struct nfs4_openowner *oo;
6264 struct nfs4_ol_stateid *stp;
6265 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
6266
6267 dprintk("NFSD: nfsd4_open_confirm on file %pd\n",
6268 cstate->current_fh.fh_dentry);
6269
6270 status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0);
6271 if (status)
6272 return status;
6273
6274 status = nfs4_preprocess_seqid_op(cstate,
6275 oc->oc_seqid, &oc->oc_req_stateid,
6276 NFS4_OPEN_STID, &stp, nn);
6277 if (status)
6278 goto out;
6279 oo = openowner(stp->st_stateowner);
6280 status = nfserr_bad_stateid;
6281 if (oo->oo_flags & NFS4_OO_CONFIRMED) {
6282 mutex_unlock(&stp->st_mutex);
6283 goto put_stateid;
6284 }
6285 oo->oo_flags |= NFS4_OO_CONFIRMED;
6286 nfs4_inc_and_copy_stateid(&oc->oc_resp_stateid, &stp->st_stid);
6287 mutex_unlock(&stp->st_mutex);
6288 trace_nfsd_open_confirm(oc->oc_seqid, &stp->st_stid.sc_stateid);
6289 nfsd4_client_record_create(oo->oo_owner.so_client);
6290 status = nfs_ok;
6291put_stateid:
6292 nfs4_put_stid(&stp->st_stid);
6293out:
6294 nfsd4_bump_seqid(cstate, status);
6295 return status;
6296}
6297
6298static inline void nfs4_stateid_downgrade_bit(struct nfs4_ol_stateid *stp, u32 access)
6299{
6300 if (!test_access(access, stp))
6301 return;
6302 nfs4_file_put_access(stp->st_stid.sc_file, access);
6303 clear_access(access, stp);
6304}
6305
6306static inline void nfs4_stateid_downgrade(struct nfs4_ol_stateid *stp, u32 to_access)
6307{
6308 switch (to_access) {
6309 case NFS4_SHARE_ACCESS_READ:
6310 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_WRITE);
6311 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
6312 break;
6313 case NFS4_SHARE_ACCESS_WRITE:
6314 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_READ);
6315 nfs4_stateid_downgrade_bit(stp, NFS4_SHARE_ACCESS_BOTH);
6316 break;
6317 case NFS4_SHARE_ACCESS_BOTH:
6318 break;
6319 default:
6320 WARN_ON_ONCE(1);
6321 }
6322}
6323
6324__be32
6325nfsd4_open_downgrade(struct svc_rqst *rqstp,
6326 struct nfsd4_compound_state *cstate, union nfsd4_op_u *u)
6327{
6328 struct nfsd4_open_downgrade *od = &u->open_downgrade;
6329 __be32 status;
6330 struct nfs4_ol_stateid *stp;
6331 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
6332
6333 dprintk("NFSD: nfsd4_open_downgrade on file %pd\n",
6334 cstate->current_fh.fh_dentry);
6335
6336
6337 if (od->od_deleg_want)
6338 dprintk("NFSD: %s: od_deleg_want=0x%x ignored\n", __func__,
6339 od->od_deleg_want);
6340
6341 status = nfs4_preprocess_confirmed_seqid_op(cstate, od->od_seqid,
6342 &od->od_stateid, &stp, nn);
6343 if (status)
6344 goto out;
6345 status = nfserr_inval;
6346 if (!test_access(od->od_share_access, stp)) {
6347 dprintk("NFSD: access not a subset of current bitmap: 0x%hhx, input access=%08x\n",
6348 stp->st_access_bmap, od->od_share_access);
6349 goto put_stateid;
6350 }
6351 if (!test_deny(od->od_share_deny, stp)) {
6352 dprintk("NFSD: deny not a subset of current bitmap: 0x%hhx, input deny=%08x\n",
6353 stp->st_deny_bmap, od->od_share_deny);
6354 goto put_stateid;
6355 }
6356 nfs4_stateid_downgrade(stp, od->od_share_access);
6357 reset_union_bmap_deny(od->od_share_deny, stp);
6358 nfs4_inc_and_copy_stateid(&od->od_stateid, &stp->st_stid);
6359 status = nfs_ok;
6360put_stateid:
6361 mutex_unlock(&stp->st_mutex);
6362 nfs4_put_stid(&stp->st_stid);
6363out:
6364 nfsd4_bump_seqid(cstate, status);
6365 return status;
6366}
6367
6368static void nfsd4_close_open_stateid(struct nfs4_ol_stateid *s)
6369{
6370 struct nfs4_client *clp = s->st_stid.sc_client;
6371 bool unhashed;
6372 LIST_HEAD(reaplist);
6373
6374 spin_lock(&clp->cl_lock);
6375 unhashed = unhash_open_stateid(s, &reaplist);
6376
6377 if (clp->cl_minorversion) {
6378 if (unhashed)
6379 put_ol_stateid_locked(s, &reaplist);
6380 spin_unlock(&clp->cl_lock);
6381 free_ol_stateid_reaplist(&reaplist);
6382 } else {
6383 spin_unlock(&clp->cl_lock);
6384 free_ol_stateid_reaplist(&reaplist);
6385 if (unhashed)
6386 move_to_close_lru(s, clp->net);
6387 }
6388}
6389
6390
6391
6392
6393__be32
6394nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6395 union nfsd4_op_u *u)
6396{
6397 struct nfsd4_close *close = &u->close;
6398 __be32 status;
6399 struct nfs4_ol_stateid *stp;
6400 struct net *net = SVC_NET(rqstp);
6401 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6402
6403 dprintk("NFSD: nfsd4_close on file %pd\n",
6404 cstate->current_fh.fh_dentry);
6405
6406 status = nfs4_preprocess_seqid_op(cstate, close->cl_seqid,
6407 &close->cl_stateid,
6408 NFS4_OPEN_STID|NFS4_CLOSED_STID,
6409 &stp, nn);
6410 nfsd4_bump_seqid(cstate, status);
6411 if (status)
6412 goto out;
6413
6414 stp->st_stid.sc_type = NFS4_CLOSED_STID;
6415
6416
6417
6418
6419
6420
6421
6422 nfs4_inc_and_copy_stateid(&close->cl_stateid, &stp->st_stid);
6423
6424 nfsd4_close_open_stateid(stp);
6425 mutex_unlock(&stp->st_mutex);
6426
6427
6428
6429
6430
6431
6432
6433
6434 memcpy(&close->cl_stateid, &close_stateid, sizeof(close->cl_stateid));
6435
6436
6437 nfs4_put_stid(&stp->st_stid);
6438out:
6439 return status;
6440}
6441
6442__be32
6443nfsd4_delegreturn(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6444 union nfsd4_op_u *u)
6445{
6446 struct nfsd4_delegreturn *dr = &u->delegreturn;
6447 struct nfs4_delegation *dp;
6448 stateid_t *stateid = &dr->dr_stateid;
6449 struct nfs4_stid *s;
6450 __be32 status;
6451 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
6452
6453 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
6454 return status;
6455
6456 status = nfsd4_lookup_stateid(cstate, stateid, NFS4_DELEG_STID, &s, nn);
6457 if (status)
6458 goto out;
6459 dp = delegstateid(s);
6460 status = nfsd4_stid_check_stateid_generation(stateid, &dp->dl_stid, nfsd4_has_session(cstate));
6461 if (status)
6462 goto put_stateid;
6463
6464 destroy_delegation(dp);
6465put_stateid:
6466 nfs4_put_stid(&dp->dl_stid);
6467out:
6468 return status;
6469}
6470
6471
6472static inline u64
6473last_byte_offset(u64 start, u64 len)
6474{
6475 u64 end;
6476
6477 WARN_ON_ONCE(!len);
6478 end = start + len;
6479 return end > start ? end - 1: NFS4_MAX_UINT64;
6480}
6481
6482
6483
6484
6485
6486
6487
6488
6489
6490static inline void
6491nfs4_transform_lock_offset(struct file_lock *lock)
6492{
6493 if (lock->fl_start < 0)
6494 lock->fl_start = OFFSET_MAX;
6495 if (lock->fl_end < 0)
6496 lock->fl_end = OFFSET_MAX;
6497}
6498
6499static fl_owner_t
6500nfsd4_fl_get_owner(fl_owner_t owner)
6501{
6502 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
6503
6504 nfs4_get_stateowner(&lo->lo_owner);
6505 return owner;
6506}
6507
6508static void
6509nfsd4_fl_put_owner(fl_owner_t owner)
6510{
6511 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)owner;
6512
6513 if (lo)
6514 nfs4_put_stateowner(&lo->lo_owner);
6515}
6516
6517static void
6518nfsd4_lm_notify(struct file_lock *fl)
6519{
6520 struct nfs4_lockowner *lo = (struct nfs4_lockowner *)fl->fl_owner;
6521 struct net *net = lo->lo_owner.so_client->net;
6522 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6523 struct nfsd4_blocked_lock *nbl = container_of(fl,
6524 struct nfsd4_blocked_lock, nbl_lock);
6525 bool queue = false;
6526
6527
6528 spin_lock(&nn->blocked_locks_lock);
6529 if (!list_empty(&nbl->nbl_list)) {
6530 list_del_init(&nbl->nbl_list);
6531 list_del_init(&nbl->nbl_lru);
6532 queue = true;
6533 }
6534 spin_unlock(&nn->blocked_locks_lock);
6535
6536 if (queue) {
6537 trace_nfsd_cb_notify_lock(lo, nbl);
6538 nfsd4_run_cb(&nbl->nbl_cb);
6539 }
6540}
6541
6542static const struct lock_manager_operations nfsd_posix_mng_ops = {
6543 .lm_notify = nfsd4_lm_notify,
6544 .lm_get_owner = nfsd4_fl_get_owner,
6545 .lm_put_owner = nfsd4_fl_put_owner,
6546};
6547
6548static inline void
6549nfs4_set_lock_denied(struct file_lock *fl, struct nfsd4_lock_denied *deny)
6550{
6551 struct nfs4_lockowner *lo;
6552
6553 if (fl->fl_lmops == &nfsd_posix_mng_ops) {
6554 lo = (struct nfs4_lockowner *) fl->fl_owner;
6555 xdr_netobj_dup(&deny->ld_owner, &lo->lo_owner.so_owner,
6556 GFP_KERNEL);
6557 if (!deny->ld_owner.data)
6558
6559 goto nevermind;
6560 deny->ld_clientid = lo->lo_owner.so_client->cl_clientid;
6561 } else {
6562nevermind:
6563 deny->ld_owner.len = 0;
6564 deny->ld_owner.data = NULL;
6565 deny->ld_clientid.cl_boot = 0;
6566 deny->ld_clientid.cl_id = 0;
6567 }
6568 deny->ld_start = fl->fl_start;
6569 deny->ld_length = NFS4_MAX_UINT64;
6570 if (fl->fl_end != NFS4_MAX_UINT64)
6571 deny->ld_length = fl->fl_end - fl->fl_start + 1;
6572 deny->ld_type = NFS4_READ_LT;
6573 if (fl->fl_type != F_RDLCK)
6574 deny->ld_type = NFS4_WRITE_LT;
6575}
6576
6577static struct nfs4_lockowner *
6578find_lockowner_str_locked(struct nfs4_client *clp, struct xdr_netobj *owner)
6579{
6580 unsigned int strhashval = ownerstr_hashval(owner);
6581 struct nfs4_stateowner *so;
6582
6583 lockdep_assert_held(&clp->cl_lock);
6584
6585 list_for_each_entry(so, &clp->cl_ownerstr_hashtbl[strhashval],
6586 so_strhash) {
6587 if (so->so_is_open_owner)
6588 continue;
6589 if (same_owner_str(so, owner))
6590 return lockowner(nfs4_get_stateowner(so));
6591 }
6592 return NULL;
6593}
6594
6595static struct nfs4_lockowner *
6596find_lockowner_str(struct nfs4_client *clp, struct xdr_netobj *owner)
6597{
6598 struct nfs4_lockowner *lo;
6599
6600 spin_lock(&clp->cl_lock);
6601 lo = find_lockowner_str_locked(clp, owner);
6602 spin_unlock(&clp->cl_lock);
6603 return lo;
6604}
6605
6606static void nfs4_unhash_lockowner(struct nfs4_stateowner *sop)
6607{
6608 unhash_lockowner_locked(lockowner(sop));
6609}
6610
6611static void nfs4_free_lockowner(struct nfs4_stateowner *sop)
6612{
6613 struct nfs4_lockowner *lo = lockowner(sop);
6614
6615 kmem_cache_free(lockowner_slab, lo);
6616}
6617
6618static const struct nfs4_stateowner_operations lockowner_ops = {
6619 .so_unhash = nfs4_unhash_lockowner,
6620 .so_free = nfs4_free_lockowner,
6621};
6622
6623
6624
6625
6626
6627
6628
6629
6630static struct nfs4_lockowner *
6631alloc_init_lock_stateowner(unsigned int strhashval, struct nfs4_client *clp,
6632 struct nfs4_ol_stateid *open_stp,
6633 struct nfsd4_lock *lock)
6634{
6635 struct nfs4_lockowner *lo, *ret;
6636
6637 lo = alloc_stateowner(lockowner_slab, &lock->lk_new_owner, clp);
6638 if (!lo)
6639 return NULL;
6640 INIT_LIST_HEAD(&lo->lo_blocked);
6641 INIT_LIST_HEAD(&lo->lo_owner.so_stateids);
6642 lo->lo_owner.so_is_open_owner = 0;
6643 lo->lo_owner.so_seqid = lock->lk_new_lock_seqid;
6644 lo->lo_owner.so_ops = &lockowner_ops;
6645 spin_lock(&clp->cl_lock);
6646 ret = find_lockowner_str_locked(clp, &lock->lk_new_owner);
6647 if (ret == NULL) {
6648 list_add(&lo->lo_owner.so_strhash,
6649 &clp->cl_ownerstr_hashtbl[strhashval]);
6650 ret = lo;
6651 } else
6652 nfs4_free_stateowner(&lo->lo_owner);
6653
6654 spin_unlock(&clp->cl_lock);
6655 return ret;
6656}
6657
6658static struct nfs4_ol_stateid *
6659find_lock_stateid(const struct nfs4_lockowner *lo,
6660 const struct nfs4_ol_stateid *ost)
6661{
6662 struct nfs4_ol_stateid *lst;
6663
6664 lockdep_assert_held(&ost->st_stid.sc_client->cl_lock);
6665
6666
6667 if (!nfs4_ol_stateid_unhashed(ost))
6668 list_for_each_entry(lst, &ost->st_locks, st_locks) {
6669 if (lst->st_stateowner == &lo->lo_owner) {
6670 refcount_inc(&lst->st_stid.sc_count);
6671 return lst;
6672 }
6673 }
6674 return NULL;
6675}
6676
6677static struct nfs4_ol_stateid *
6678init_lock_stateid(struct nfs4_ol_stateid *stp, struct nfs4_lockowner *lo,
6679 struct nfs4_file *fp, struct inode *inode,
6680 struct nfs4_ol_stateid *open_stp)
6681{
6682 struct nfs4_client *clp = lo->lo_owner.so_client;
6683 struct nfs4_ol_stateid *retstp;
6684
6685 mutex_init(&stp->st_mutex);
6686 mutex_lock_nested(&stp->st_mutex, OPEN_STATEID_MUTEX);
6687retry:
6688 spin_lock(&clp->cl_lock);
6689 if (nfs4_ol_stateid_unhashed(open_stp))
6690 goto out_close;
6691 retstp = find_lock_stateid(lo, open_stp);
6692 if (retstp)
6693 goto out_found;
6694 refcount_inc(&stp->st_stid.sc_count);
6695 stp->st_stid.sc_type = NFS4_LOCK_STID;
6696 stp->st_stateowner = nfs4_get_stateowner(&lo->lo_owner);
6697 get_nfs4_file(fp);
6698 stp->st_stid.sc_file = fp;
6699 stp->st_access_bmap = 0;
6700 stp->st_deny_bmap = open_stp->st_deny_bmap;
6701 stp->st_openstp = open_stp;
6702 spin_lock(&fp->fi_lock);
6703 list_add(&stp->st_locks, &open_stp->st_locks);
6704 list_add(&stp->st_perstateowner, &lo->lo_owner.so_stateids);
6705 list_add(&stp->st_perfile, &fp->fi_stateids);
6706 spin_unlock(&fp->fi_lock);
6707 spin_unlock(&clp->cl_lock);
6708 return stp;
6709out_found:
6710 spin_unlock(&clp->cl_lock);
6711 if (nfsd4_lock_ol_stateid(retstp) != nfs_ok) {
6712 nfs4_put_stid(&retstp->st_stid);
6713 goto retry;
6714 }
6715
6716 mutex_unlock(&stp->st_mutex);
6717 return retstp;
6718out_close:
6719 spin_unlock(&clp->cl_lock);
6720 mutex_unlock(&stp->st_mutex);
6721 return NULL;
6722}
6723
6724static struct nfs4_ol_stateid *
6725find_or_create_lock_stateid(struct nfs4_lockowner *lo, struct nfs4_file *fi,
6726 struct inode *inode, struct nfs4_ol_stateid *ost,
6727 bool *new)
6728{
6729 struct nfs4_stid *ns = NULL;
6730 struct nfs4_ol_stateid *lst;
6731 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
6732 struct nfs4_client *clp = oo->oo_owner.so_client;
6733
6734 *new = false;
6735 spin_lock(&clp->cl_lock);
6736 lst = find_lock_stateid(lo, ost);
6737 spin_unlock(&clp->cl_lock);
6738 if (lst != NULL) {
6739 if (nfsd4_lock_ol_stateid(lst) == nfs_ok)
6740 goto out;
6741 nfs4_put_stid(&lst->st_stid);
6742 }
6743 ns = nfs4_alloc_stid(clp, stateid_slab, nfs4_free_lock_stateid);
6744 if (ns == NULL)
6745 return NULL;
6746
6747 lst = init_lock_stateid(openlockstateid(ns), lo, fi, inode, ost);
6748 if (lst == openlockstateid(ns))
6749 *new = true;
6750 else
6751 nfs4_put_stid(ns);
6752out:
6753 return lst;
6754}
6755
6756static int
6757check_lock_length(u64 offset, u64 length)
6758{
6759 return ((length == 0) || ((length != NFS4_MAX_UINT64) &&
6760 (length > ~offset)));
6761}
6762
6763static void get_lock_access(struct nfs4_ol_stateid *lock_stp, u32 access)
6764{
6765 struct nfs4_file *fp = lock_stp->st_stid.sc_file;
6766
6767 lockdep_assert_held(&fp->fi_lock);
6768
6769 if (test_access(access, lock_stp))
6770 return;
6771 __nfs4_file_get_access(fp, access);
6772 set_access(access, lock_stp);
6773}
6774
6775static __be32
6776lookup_or_create_lock_state(struct nfsd4_compound_state *cstate,
6777 struct nfs4_ol_stateid *ost,
6778 struct nfsd4_lock *lock,
6779 struct nfs4_ol_stateid **plst, bool *new)
6780{
6781 __be32 status;
6782 struct nfs4_file *fi = ost->st_stid.sc_file;
6783 struct nfs4_openowner *oo = openowner(ost->st_stateowner);
6784 struct nfs4_client *cl = oo->oo_owner.so_client;
6785 struct inode *inode = d_inode(cstate->current_fh.fh_dentry);
6786 struct nfs4_lockowner *lo;
6787 struct nfs4_ol_stateid *lst;
6788 unsigned int strhashval;
6789
6790 lo = find_lockowner_str(cl, &lock->lk_new_owner);
6791 if (!lo) {
6792 strhashval = ownerstr_hashval(&lock->lk_new_owner);
6793 lo = alloc_init_lock_stateowner(strhashval, cl, ost, lock);
6794 if (lo == NULL)
6795 return nfserr_jukebox;
6796 } else {
6797
6798 status = nfserr_bad_seqid;
6799 if (!cstate->minorversion &&
6800 lock->lk_new_lock_seqid != lo->lo_owner.so_seqid)
6801 goto out;
6802 }
6803
6804 lst = find_or_create_lock_stateid(lo, fi, inode, ost, new);
6805 if (lst == NULL) {
6806 status = nfserr_jukebox;
6807 goto out;
6808 }
6809
6810 status = nfs_ok;
6811 *plst = lst;
6812out:
6813 nfs4_put_stateowner(&lo->lo_owner);
6814 return status;
6815}
6816
6817
6818
6819
6820__be32
6821nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
6822 union nfsd4_op_u *u)
6823{
6824 struct nfsd4_lock *lock = &u->lock;
6825 struct nfs4_openowner *open_sop = NULL;
6826 struct nfs4_lockowner *lock_sop = NULL;
6827 struct nfs4_ol_stateid *lock_stp = NULL;
6828 struct nfs4_ol_stateid *open_stp = NULL;
6829 struct nfs4_file *fp;
6830 struct nfsd_file *nf = NULL;
6831 struct nfsd4_blocked_lock *nbl = NULL;
6832 struct file_lock *file_lock = NULL;
6833 struct file_lock *conflock = NULL;
6834 struct super_block *sb;
6835 __be32 status = 0;
6836 int lkflg;
6837 int err;
6838 bool new = false;
6839 unsigned char fl_type;
6840 unsigned int fl_flags = FL_POSIX;
6841 struct net *net = SVC_NET(rqstp);
6842 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
6843
6844 dprintk("NFSD: nfsd4_lock: start=%Ld length=%Ld\n",
6845 (long long) lock->lk_offset,
6846 (long long) lock->lk_length);
6847
6848 if (check_lock_length(lock->lk_offset, lock->lk_length))
6849 return nfserr_inval;
6850
6851 if ((status = fh_verify(rqstp, &cstate->current_fh,
6852 S_IFREG, NFSD_MAY_LOCK))) {
6853 dprintk("NFSD: nfsd4_lock: permission denied!\n");
6854 return status;
6855 }
6856 sb = cstate->current_fh.fh_dentry->d_sb;
6857
6858 if (lock->lk_is_new) {
6859 if (nfsd4_has_session(cstate))
6860
6861 memcpy(&lock->lk_new_clientid,
6862 &cstate->clp->cl_clientid,
6863 sizeof(clientid_t));
6864
6865
6866 status = nfs4_preprocess_confirmed_seqid_op(cstate,
6867 lock->lk_new_open_seqid,
6868 &lock->lk_new_open_stateid,
6869 &open_stp, nn);
6870 if (status)
6871 goto out;
6872 mutex_unlock(&open_stp->st_mutex);
6873 open_sop = openowner(open_stp->st_stateowner);
6874 status = nfserr_bad_stateid;
6875 if (!same_clid(&open_sop->oo_owner.so_client->cl_clientid,
6876 &lock->lk_new_clientid))
6877 goto out;
6878 status = lookup_or_create_lock_state(cstate, open_stp, lock,
6879 &lock_stp, &new);
6880 } else {
6881 status = nfs4_preprocess_seqid_op(cstate,
6882 lock->lk_old_lock_seqid,
6883 &lock->lk_old_lock_stateid,
6884 NFS4_LOCK_STID, &lock_stp, nn);
6885 }
6886 if (status)
6887 goto out;
6888 lock_sop = lockowner(lock_stp->st_stateowner);
6889
6890 lkflg = setlkflg(lock->lk_type);
6891 status = nfs4_check_openmode(lock_stp, lkflg);
6892 if (status)
6893 goto out;
6894
6895 status = nfserr_grace;
6896 if (locks_in_grace(net) && !lock->lk_reclaim)
6897 goto out;
6898 status = nfserr_no_grace;
6899 if (!locks_in_grace(net) && lock->lk_reclaim)
6900 goto out;
6901
6902 if (lock->lk_reclaim)
6903 fl_flags |= FL_RECLAIM;
6904
6905 fp = lock_stp->st_stid.sc_file;
6906 switch (lock->lk_type) {
6907 case NFS4_READW_LT:
6908 if (nfsd4_has_session(cstate) &&
6909 !(sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS))
6910 fl_flags |= FL_SLEEP;
6911 fallthrough;
6912 case NFS4_READ_LT:
6913 spin_lock(&fp->fi_lock);
6914 nf = find_readable_file_locked(fp);
6915 if (nf)
6916 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_READ);
6917 spin_unlock(&fp->fi_lock);
6918 fl_type = F_RDLCK;
6919 break;
6920 case NFS4_WRITEW_LT:
6921 if (nfsd4_has_session(cstate) &&
6922 !(sb->s_export_op->flags & EXPORT_OP_SYNC_LOCKS))
6923 fl_flags |= FL_SLEEP;
6924 fallthrough;
6925 case NFS4_WRITE_LT:
6926 spin_lock(&fp->fi_lock);
6927 nf = find_writeable_file_locked(fp);
6928 if (nf)
6929 get_lock_access(lock_stp, NFS4_SHARE_ACCESS_WRITE);
6930 spin_unlock(&fp->fi_lock);
6931 fl_type = F_WRLCK;
6932 break;
6933 default:
6934 status = nfserr_inval;
6935 goto out;
6936 }
6937
6938 if (!nf) {
6939 status = nfserr_openmode;
6940 goto out;
6941 }
6942
6943 nbl = find_or_allocate_block(lock_sop, &fp->fi_fhandle, nn);
6944 if (!nbl) {
6945 dprintk("NFSD: %s: unable to allocate block!\n", __func__);
6946 status = nfserr_jukebox;
6947 goto out;
6948 }
6949
6950 file_lock = &nbl->nbl_lock;
6951 file_lock->fl_type = fl_type;
6952 file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(&lock_sop->lo_owner));
6953 file_lock->fl_pid = current->tgid;
6954 file_lock->fl_file = nf->nf_file;
6955 file_lock->fl_flags = fl_flags;
6956 file_lock->fl_lmops = &nfsd_posix_mng_ops;
6957 file_lock->fl_start = lock->lk_offset;
6958 file_lock->fl_end = last_byte_offset(lock->lk_offset, lock->lk_length);
6959 nfs4_transform_lock_offset(file_lock);
6960
6961 conflock = locks_alloc_lock();
6962 if (!conflock) {
6963 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
6964 status = nfserr_jukebox;
6965 goto out;
6966 }
6967
6968 if (fl_flags & FL_SLEEP) {
6969 nbl->nbl_time = ktime_get_boottime_seconds();
6970 spin_lock(&nn->blocked_locks_lock);
6971 list_add_tail(&nbl->nbl_list, &lock_sop->lo_blocked);
6972 list_add_tail(&nbl->nbl_lru, &nn->blocked_locks_lru);
6973 spin_unlock(&nn->blocked_locks_lock);
6974 }
6975
6976 err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, conflock);
6977 switch (err) {
6978 case 0:
6979 nfs4_inc_and_copy_stateid(&lock->lk_resp_stateid, &lock_stp->st_stid);
6980 status = 0;
6981 if (lock->lk_reclaim)
6982 nn->somebody_reclaimed = true;
6983 break;
6984 case FILE_LOCK_DEFERRED:
6985 nbl = NULL;
6986 fallthrough;
6987 case -EAGAIN:
6988 status = nfserr_denied;
6989 dprintk("NFSD: nfsd4_lock: conflicting lock found!\n");
6990 nfs4_set_lock_denied(conflock, &lock->lk_denied);
6991 break;
6992 case -EDEADLK:
6993 status = nfserr_deadlock;
6994 break;
6995 default:
6996 dprintk("NFSD: nfsd4_lock: vfs_lock_file() failed! status %d\n",err);
6997 status = nfserrno(err);
6998 break;
6999 }
7000out:
7001 if (nbl) {
7002
7003 if (fl_flags & FL_SLEEP) {
7004 spin_lock(&nn->blocked_locks_lock);
7005 list_del_init(&nbl->nbl_list);
7006 list_del_init(&nbl->nbl_lru);
7007 spin_unlock(&nn->blocked_locks_lock);
7008 }
7009 free_blocked_lock(nbl);
7010 }
7011 if (nf)
7012 nfsd_file_put(nf);
7013 if (lock_stp) {
7014
7015 if (cstate->replay_owner &&
7016 cstate->replay_owner != &lock_sop->lo_owner &&
7017 seqid_mutating_err(ntohl(status)))
7018 lock_sop->lo_owner.so_seqid++;
7019
7020
7021
7022
7023
7024 if (status && new)
7025 release_lock_stateid(lock_stp);
7026
7027 mutex_unlock(&lock_stp->st_mutex);
7028
7029 nfs4_put_stid(&lock_stp->st_stid);
7030 }
7031 if (open_stp)
7032 nfs4_put_stid(&open_stp->st_stid);
7033 nfsd4_bump_seqid(cstate, status);
7034 if (conflock)
7035 locks_free_lock(conflock);
7036 return status;
7037}
7038
7039
7040
7041
7042
7043
7044static __be32 nfsd_test_lock(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file_lock *lock)
7045{
7046 struct nfsd_file *nf;
7047 __be32 err;
7048
7049 err = nfsd_file_acquire(rqstp, fhp, NFSD_MAY_READ, &nf);
7050 if (err)
7051 return err;
7052 fh_lock(fhp);
7053 err = nfserrno(nfsd_open_break_lease(fhp->fh_dentry->d_inode,
7054 NFSD_MAY_READ));
7055 if (err)
7056 goto out;
7057 lock->fl_file = nf->nf_file;
7058 err = nfserrno(vfs_test_lock(nf->nf_file, lock));
7059 lock->fl_file = NULL;
7060out:
7061 fh_unlock(fhp);
7062 nfsd_file_put(nf);
7063 return err;
7064}
7065
7066
7067
7068
7069__be32
7070nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7071 union nfsd4_op_u *u)
7072{
7073 struct nfsd4_lockt *lockt = &u->lockt;
7074 struct file_lock *file_lock = NULL;
7075 struct nfs4_lockowner *lo = NULL;
7076 __be32 status;
7077 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
7078
7079 if (locks_in_grace(SVC_NET(rqstp)))
7080 return nfserr_grace;
7081
7082 if (check_lock_length(lockt->lt_offset, lockt->lt_length))
7083 return nfserr_inval;
7084
7085 if (!nfsd4_has_session(cstate)) {
7086 status = set_client(&lockt->lt_clientid, cstate, nn);
7087 if (status)
7088 goto out;
7089 }
7090
7091 if ((status = fh_verify(rqstp, &cstate->current_fh, S_IFREG, 0)))
7092 goto out;
7093
7094 file_lock = locks_alloc_lock();
7095 if (!file_lock) {
7096 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
7097 status = nfserr_jukebox;
7098 goto out;
7099 }
7100
7101 switch (lockt->lt_type) {
7102 case NFS4_READ_LT:
7103 case NFS4_READW_LT:
7104 file_lock->fl_type = F_RDLCK;
7105 break;
7106 case NFS4_WRITE_LT:
7107 case NFS4_WRITEW_LT:
7108 file_lock->fl_type = F_WRLCK;
7109 break;
7110 default:
7111 dprintk("NFSD: nfs4_lockt: bad lock type!\n");
7112 status = nfserr_inval;
7113 goto out;
7114 }
7115
7116 lo = find_lockowner_str(cstate->clp, &lockt->lt_owner);
7117 if (lo)
7118 file_lock->fl_owner = (fl_owner_t)lo;
7119 file_lock->fl_pid = current->tgid;
7120 file_lock->fl_flags = FL_POSIX;
7121
7122 file_lock->fl_start = lockt->lt_offset;
7123 file_lock->fl_end = last_byte_offset(lockt->lt_offset, lockt->lt_length);
7124
7125 nfs4_transform_lock_offset(file_lock);
7126
7127 status = nfsd_test_lock(rqstp, &cstate->current_fh, file_lock);
7128 if (status)
7129 goto out;
7130
7131 if (file_lock->fl_type != F_UNLCK) {
7132 status = nfserr_denied;
7133 nfs4_set_lock_denied(file_lock, &lockt->lt_denied);
7134 }
7135out:
7136 if (lo)
7137 nfs4_put_stateowner(&lo->lo_owner);
7138 if (file_lock)
7139 locks_free_lock(file_lock);
7140 return status;
7141}
7142
7143__be32
7144nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate,
7145 union nfsd4_op_u *u)
7146{
7147 struct nfsd4_locku *locku = &u->locku;
7148 struct nfs4_ol_stateid *stp;
7149 struct nfsd_file *nf = NULL;
7150 struct file_lock *file_lock = NULL;
7151 __be32 status;
7152 int err;
7153 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
7154
7155 dprintk("NFSD: nfsd4_locku: start=%Ld length=%Ld\n",
7156 (long long) locku->lu_offset,
7157 (long long) locku->lu_length);
7158
7159 if (check_lock_length(locku->lu_offset, locku->lu_length))
7160 return nfserr_inval;
7161
7162 status = nfs4_preprocess_seqid_op(cstate, locku->lu_seqid,
7163 &locku->lu_stateid, NFS4_LOCK_STID,
7164 &stp, nn);
7165 if (status)
7166 goto out;
7167 nf = find_any_file(stp->st_stid.sc_file);
7168 if (!nf) {
7169 status = nfserr_lock_range;
7170 goto put_stateid;
7171 }
7172 file_lock = locks_alloc_lock();
7173 if (!file_lock) {
7174 dprintk("NFSD: %s: unable to allocate lock!\n", __func__);
7175 status = nfserr_jukebox;
7176 goto put_file;
7177 }
7178
7179 file_lock->fl_type = F_UNLCK;
7180 file_lock->fl_owner = (fl_owner_t)lockowner(nfs4_get_stateowner(stp->st_stateowner));
7181 file_lock->fl_pid = current->tgid;
7182 file_lock->fl_file = nf->nf_file;
7183 file_lock->fl_flags = FL_POSIX;
7184 file_lock->fl_lmops = &nfsd_posix_mng_ops;
7185 file_lock->fl_start = locku->lu_offset;
7186
7187 file_lock->fl_end = last_byte_offset(locku->lu_offset,
7188 locku->lu_length);
7189 nfs4_transform_lock_offset(file_lock);
7190
7191 err = vfs_lock_file(nf->nf_file, F_SETLK, file_lock, NULL);
7192 if (err) {
7193 dprintk("NFSD: nfs4_locku: vfs_lock_file failed!\n");
7194 goto out_nfserr;
7195 }
7196 nfs4_inc_and_copy_stateid(&locku->lu_stateid, &stp->st_stid);
7197put_file:
7198 nfsd_file_put(nf);
7199put_stateid:
7200 mutex_unlock(&stp->st_mutex);
7201 nfs4_put_stid(&stp->st_stid);
7202out:
7203 nfsd4_bump_seqid(cstate, status);
7204 if (file_lock)
7205 locks_free_lock(file_lock);
7206 return status;
7207
7208out_nfserr:
7209 status = nfserrno(err);
7210 goto put_file;
7211}
7212
7213
7214
7215
7216
7217
7218static bool
7219check_for_locks(struct nfs4_file *fp, struct nfs4_lockowner *lowner)
7220{
7221 struct file_lock *fl;
7222 int status = false;
7223 struct nfsd_file *nf = find_any_file(fp);
7224 struct inode *inode;
7225 struct file_lock_context *flctx;
7226
7227 if (!nf) {
7228
7229 WARN_ON_ONCE(1);
7230 return status;
7231 }
7232
7233 inode = locks_inode(nf->nf_file);
7234 flctx = inode->i_flctx;
7235
7236 if (flctx && !list_empty_careful(&flctx->flc_posix)) {
7237 spin_lock(&flctx->flc_lock);
7238 list_for_each_entry(fl, &flctx->flc_posix, fl_list) {
7239 if (fl->fl_owner == (fl_owner_t)lowner) {
7240 status = true;
7241 break;
7242 }
7243 }
7244 spin_unlock(&flctx->flc_lock);
7245 }
7246 nfsd_file_put(nf);
7247 return status;
7248}
7249
7250__be32
7251nfsd4_release_lockowner(struct svc_rqst *rqstp,
7252 struct nfsd4_compound_state *cstate,
7253 union nfsd4_op_u *u)
7254{
7255 struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;
7256 clientid_t *clid = &rlockowner->rl_clientid;
7257 struct nfs4_stateowner *sop;
7258 struct nfs4_lockowner *lo = NULL;
7259 struct nfs4_ol_stateid *stp;
7260 struct xdr_netobj *owner = &rlockowner->rl_owner;
7261 unsigned int hashval = ownerstr_hashval(owner);
7262 __be32 status;
7263 struct nfsd_net *nn = net_generic(SVC_NET(rqstp), nfsd_net_id);
7264 struct nfs4_client *clp;
7265 LIST_HEAD (reaplist);
7266
7267 dprintk("nfsd4_release_lockowner clientid: (%08x/%08x):\n",
7268 clid->cl_boot, clid->cl_id);
7269
7270 status = set_client(clid, cstate, nn);
7271 if (status)
7272 return status;
7273
7274 clp = cstate->clp;
7275
7276 spin_lock(&clp->cl_lock);
7277 list_for_each_entry(sop, &clp->cl_ownerstr_hashtbl[hashval],
7278 so_strhash) {
7279
7280 if (sop->so_is_open_owner || !same_owner_str(sop, owner))
7281 continue;
7282
7283
7284 lo = lockowner(sop);
7285 list_for_each_entry(stp, &sop->so_stateids, st_perstateowner) {
7286 if (check_for_locks(stp->st_stid.sc_file, lo)) {
7287 status = nfserr_locks_held;
7288 spin_unlock(&clp->cl_lock);
7289 return status;
7290 }
7291 }
7292
7293 nfs4_get_stateowner(sop);
7294 break;
7295 }
7296 if (!lo) {
7297 spin_unlock(&clp->cl_lock);
7298 return status;
7299 }
7300
7301 unhash_lockowner_locked(lo);
7302 while (!list_empty(&lo->lo_owner.so_stateids)) {
7303 stp = list_first_entry(&lo->lo_owner.so_stateids,
7304 struct nfs4_ol_stateid,
7305 st_perstateowner);
7306 WARN_ON(!unhash_lock_stateid(stp));
7307 put_ol_stateid_locked(stp, &reaplist);
7308 }
7309 spin_unlock(&clp->cl_lock);
7310 free_ol_stateid_reaplist(&reaplist);
7311 remove_blocked_locks(lo);
7312 nfs4_put_stateowner(&lo->lo_owner);
7313
7314 return status;
7315}
7316
7317static inline struct nfs4_client_reclaim *
7318alloc_reclaim(void)
7319{
7320 return kmalloc(sizeof(struct nfs4_client_reclaim), GFP_KERNEL);
7321}
7322
7323bool
7324nfs4_has_reclaimed_state(struct xdr_netobj name, struct nfsd_net *nn)
7325{
7326 struct nfs4_client_reclaim *crp;
7327
7328 crp = nfsd4_find_reclaim_client(name, nn);
7329 return (crp && crp->cr_clp);
7330}
7331
7332
7333
7334
7335
7336
7337
7338struct nfs4_client_reclaim *
7339nfs4_client_to_reclaim(struct xdr_netobj name, struct xdr_netobj princhash,
7340 struct nfsd_net *nn)
7341{
7342 unsigned int strhashval;
7343 struct nfs4_client_reclaim *crp;
7344
7345 crp = alloc_reclaim();
7346 if (crp) {
7347 strhashval = clientstr_hashval(name);
7348 INIT_LIST_HEAD(&crp->cr_strhash);
7349 list_add(&crp->cr_strhash, &nn->reclaim_str_hashtbl[strhashval]);
7350 crp->cr_name.data = name.data;
7351 crp->cr_name.len = name.len;
7352 crp->cr_princhash.data = princhash.data;
7353 crp->cr_princhash.len = princhash.len;
7354 crp->cr_clp = NULL;
7355 nn->reclaim_str_hashtbl_size++;
7356 }
7357 return crp;
7358}
7359
7360void
7361nfs4_remove_reclaim_record(struct nfs4_client_reclaim *crp, struct nfsd_net *nn)
7362{
7363 list_del(&crp->cr_strhash);
7364 kfree(crp->cr_name.data);
7365 kfree(crp->cr_princhash.data);
7366 kfree(crp);
7367 nn->reclaim_str_hashtbl_size--;
7368}
7369
7370void
7371nfs4_release_reclaim(struct nfsd_net *nn)
7372{
7373 struct nfs4_client_reclaim *crp = NULL;
7374 int i;
7375
7376 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
7377 while (!list_empty(&nn->reclaim_str_hashtbl[i])) {
7378 crp = list_entry(nn->reclaim_str_hashtbl[i].next,
7379 struct nfs4_client_reclaim, cr_strhash);
7380 nfs4_remove_reclaim_record(crp, nn);
7381 }
7382 }
7383 WARN_ON_ONCE(nn->reclaim_str_hashtbl_size);
7384}
7385
7386
7387
7388struct nfs4_client_reclaim *
7389nfsd4_find_reclaim_client(struct xdr_netobj name, struct nfsd_net *nn)
7390{
7391 unsigned int strhashval;
7392 struct nfs4_client_reclaim *crp = NULL;
7393
7394 strhashval = clientstr_hashval(name);
7395 list_for_each_entry(crp, &nn->reclaim_str_hashtbl[strhashval], cr_strhash) {
7396 if (compare_blob(&crp->cr_name, &name) == 0) {
7397 return crp;
7398 }
7399 }
7400 return NULL;
7401}
7402
7403__be32
7404nfs4_check_open_reclaim(struct nfs4_client *clp)
7405{
7406 if (test_bit(NFSD4_CLIENT_RECLAIM_COMPLETE, &clp->cl_flags))
7407 return nfserr_no_grace;
7408
7409 if (nfsd4_client_record_check(clp))
7410 return nfserr_reclaim_bad;
7411
7412 return nfs_ok;
7413}
7414
7415
7416
7417
7418
7419
7420
7421
7422
7423
7424static void
7425set_max_delegations(void)
7426{
7427
7428
7429
7430
7431
7432
7433 max_delegations = nr_free_buffer_pages() >> (20 - 2 - PAGE_SHIFT);
7434}
7435
7436static int nfs4_state_create_net(struct net *net)
7437{
7438 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
7439 int i;
7440
7441 nn->conf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
7442 sizeof(struct list_head),
7443 GFP_KERNEL);
7444 if (!nn->conf_id_hashtbl)
7445 goto err;
7446 nn->unconf_id_hashtbl = kmalloc_array(CLIENT_HASH_SIZE,
7447 sizeof(struct list_head),
7448 GFP_KERNEL);
7449 if (!nn->unconf_id_hashtbl)
7450 goto err_unconf_id;
7451 nn->sessionid_hashtbl = kmalloc_array(SESSION_HASH_SIZE,
7452 sizeof(struct list_head),
7453 GFP_KERNEL);
7454 if (!nn->sessionid_hashtbl)
7455 goto err_sessionid;
7456
7457 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
7458 INIT_LIST_HEAD(&nn->conf_id_hashtbl[i]);
7459 INIT_LIST_HEAD(&nn->unconf_id_hashtbl[i]);
7460 }
7461 for (i = 0; i < SESSION_HASH_SIZE; i++)
7462 INIT_LIST_HEAD(&nn->sessionid_hashtbl[i]);
7463 nn->conf_name_tree = RB_ROOT;
7464 nn->unconf_name_tree = RB_ROOT;
7465 nn->boot_time = ktime_get_real_seconds();
7466 nn->grace_ended = false;
7467 nn->nfsd4_manager.block_opens = true;
7468 INIT_LIST_HEAD(&nn->nfsd4_manager.list);
7469 INIT_LIST_HEAD(&nn->client_lru);
7470 INIT_LIST_HEAD(&nn->close_lru);
7471 INIT_LIST_HEAD(&nn->del_recall_lru);
7472 spin_lock_init(&nn->client_lock);
7473 spin_lock_init(&nn->s2s_cp_lock);
7474 idr_init(&nn->s2s_cp_stateids);
7475
7476 spin_lock_init(&nn->blocked_locks_lock);
7477 INIT_LIST_HEAD(&nn->blocked_locks_lru);
7478
7479 INIT_DELAYED_WORK(&nn->laundromat_work, laundromat_main);
7480 get_net(net);
7481
7482 return 0;
7483
7484err_sessionid:
7485 kfree(nn->unconf_id_hashtbl);
7486err_unconf_id:
7487 kfree(nn->conf_id_hashtbl);
7488err:
7489 return -ENOMEM;
7490}
7491
7492static void
7493nfs4_state_destroy_net(struct net *net)
7494{
7495 int i;
7496 struct nfs4_client *clp = NULL;
7497 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
7498
7499 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
7500 while (!list_empty(&nn->conf_id_hashtbl[i])) {
7501 clp = list_entry(nn->conf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
7502 destroy_client(clp);
7503 }
7504 }
7505
7506 WARN_ON(!list_empty(&nn->blocked_locks_lru));
7507
7508 for (i = 0; i < CLIENT_HASH_SIZE; i++) {
7509 while (!list_empty(&nn->unconf_id_hashtbl[i])) {
7510 clp = list_entry(nn->unconf_id_hashtbl[i].next, struct nfs4_client, cl_idhash);
7511 destroy_client(clp);
7512 }
7513 }
7514
7515 kfree(nn->sessionid_hashtbl);
7516 kfree(nn->unconf_id_hashtbl);
7517 kfree(nn->conf_id_hashtbl);
7518 put_net(net);
7519}
7520
7521int
7522nfs4_state_start_net(struct net *net)
7523{
7524 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
7525 int ret;
7526
7527 ret = nfs4_state_create_net(net);
7528 if (ret)
7529 return ret;
7530 locks_start_grace(net, &nn->nfsd4_manager);
7531 nfsd4_client_tracking_init(net);
7532 if (nn->track_reclaim_completes && nn->reclaim_str_hashtbl_size == 0)
7533 goto skip_grace;
7534 printk(KERN_INFO "NFSD: starting %lld-second grace period (net %x)\n",
7535 nn->nfsd4_grace, net->ns.inum);
7536 trace_nfsd_grace_start(nn);
7537 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_grace * HZ);
7538 return 0;
7539
7540skip_grace:
7541 printk(KERN_INFO "NFSD: no clients to reclaim, skipping NFSv4 grace period (net %x)\n",
7542 net->ns.inum);
7543 queue_delayed_work(laundry_wq, &nn->laundromat_work, nn->nfsd4_lease * HZ);
7544 nfsd4_end_grace(nn);
7545 return 0;
7546}
7547
7548
7549
7550int
7551nfs4_state_start(void)
7552{
7553 int ret;
7554
7555 laundry_wq = alloc_workqueue("%s", WQ_UNBOUND, 0, "nfsd4");
7556 if (laundry_wq == NULL) {
7557 ret = -ENOMEM;
7558 goto out;
7559 }
7560 ret = nfsd4_create_callback_queue();
7561 if (ret)
7562 goto out_free_laundry;
7563
7564 set_max_delegations();
7565 return 0;
7566
7567out_free_laundry:
7568 destroy_workqueue(laundry_wq);
7569out:
7570 return ret;
7571}
7572
7573void
7574nfs4_state_shutdown_net(struct net *net)
7575{
7576 struct nfs4_delegation *dp = NULL;
7577 struct list_head *pos, *next, reaplist;
7578 struct nfsd_net *nn = net_generic(net, nfsd_net_id);
7579
7580 cancel_delayed_work_sync(&nn->laundromat_work);
7581 locks_end_grace(&nn->nfsd4_manager);
7582
7583 INIT_LIST_HEAD(&reaplist);
7584 spin_lock(&state_lock);
7585 list_for_each_safe(pos, next, &nn->del_recall_lru) {
7586 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
7587 WARN_ON(!unhash_delegation_locked(dp));
7588 list_add(&dp->dl_recall_lru, &reaplist);
7589 }
7590 spin_unlock(&state_lock);
7591 list_for_each_safe(pos, next, &reaplist) {
7592 dp = list_entry (pos, struct nfs4_delegation, dl_recall_lru);
7593 list_del_init(&dp->dl_recall_lru);
7594 destroy_unhashed_deleg(dp);
7595 }
7596
7597 nfsd4_client_tracking_exit(net);
7598 nfs4_state_destroy_net(net);
7599#ifdef CONFIG_NFSD_V4_2_INTER_SSC
7600 nfsd4_ssc_shutdown_umount(nn);
7601#endif
7602}
7603
7604void
7605nfs4_state_shutdown(void)
7606{
7607 destroy_workqueue(laundry_wq);
7608 nfsd4_destroy_callback_queue();
7609}
7610
7611static void
7612get_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
7613{
7614 if (HAS_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG) &&
7615 CURRENT_STATEID(stateid))
7616 memcpy(stateid, &cstate->current_stateid, sizeof(stateid_t));
7617}
7618
7619static void
7620put_stateid(struct nfsd4_compound_state *cstate, stateid_t *stateid)
7621{
7622 if (cstate->minorversion) {
7623 memcpy(&cstate->current_stateid, stateid, sizeof(stateid_t));
7624 SET_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
7625 }
7626}
7627
7628void
7629clear_current_stateid(struct nfsd4_compound_state *cstate)
7630{
7631 CLEAR_CSTATE_FLAG(cstate, CURRENT_STATE_ID_FLAG);
7632}
7633
7634
7635
7636
7637void
7638nfsd4_set_opendowngradestateid(struct nfsd4_compound_state *cstate,
7639 union nfsd4_op_u *u)
7640{
7641 put_stateid(cstate, &u->open_downgrade.od_stateid);
7642}
7643
7644void
7645nfsd4_set_openstateid(struct nfsd4_compound_state *cstate,
7646 union nfsd4_op_u *u)
7647{
7648 put_stateid(cstate, &u->open.op_stateid);
7649}
7650
7651void
7652nfsd4_set_closestateid(struct nfsd4_compound_state *cstate,
7653 union nfsd4_op_u *u)
7654{
7655 put_stateid(cstate, &u->close.cl_stateid);
7656}
7657
7658void
7659nfsd4_set_lockstateid(struct nfsd4_compound_state *cstate,
7660 union nfsd4_op_u *u)
7661{
7662 put_stateid(cstate, &u->lock.lk_resp_stateid);
7663}
7664
7665
7666
7667
7668
7669void
7670nfsd4_get_opendowngradestateid(struct nfsd4_compound_state *cstate,
7671 union nfsd4_op_u *u)
7672{
7673 get_stateid(cstate, &u->open_downgrade.od_stateid);
7674}
7675
7676void
7677nfsd4_get_delegreturnstateid(struct nfsd4_compound_state *cstate,
7678 union nfsd4_op_u *u)
7679{
7680 get_stateid(cstate, &u->delegreturn.dr_stateid);
7681}
7682
7683void
7684nfsd4_get_freestateid(struct nfsd4_compound_state *cstate,
7685 union nfsd4_op_u *u)
7686{
7687 get_stateid(cstate, &u->free_stateid.fr_stateid);
7688}
7689
7690void
7691nfsd4_get_setattrstateid(struct nfsd4_compound_state *cstate,
7692 union nfsd4_op_u *u)
7693{
7694 get_stateid(cstate, &u->setattr.sa_stateid);
7695}
7696
7697void
7698nfsd4_get_closestateid(struct nfsd4_compound_state *cstate,
7699 union nfsd4_op_u *u)
7700{
7701 get_stateid(cstate, &u->close.cl_stateid);
7702}
7703
7704void
7705nfsd4_get_lockustateid(struct nfsd4_compound_state *cstate,
7706 union nfsd4_op_u *u)
7707{
7708 get_stateid(cstate, &u->locku.lu_stateid);
7709}
7710
7711void
7712nfsd4_get_readstateid(struct nfsd4_compound_state *cstate,
7713 union nfsd4_op_u *u)
7714{
7715 get_stateid(cstate, &u->read.rd_stateid);
7716}
7717
7718void
7719nfsd4_get_writestateid(struct nfsd4_compound_state *cstate,
7720 union nfsd4_op_u *u)
7721{
7722 get_stateid(cstate, &u->write.wr_stateid);
7723}
7724