1
2
3
4
5
6
7
8
9
10#include <linux/completion.h>
11#include <linux/kthread.h>
12#include <linux/module.h>
13#include <linux/sched.h>
14#include <linux/slab.h>
15#include <linux/spinlock.h>
16#include <linux/iversion.h>
17
18#include <linux/nfs4.h>
19#include <linux/nfs_fs.h>
20#include <linux/nfs_xdr.h>
21
22#include "nfs4_fs.h"
23#include "nfs4session.h"
24#include "delegation.h"
25#include "internal.h"
26#include "nfs4trace.h"
27
28static void nfs_free_delegation(struct nfs_delegation *delegation)
29{
30 put_cred(delegation->cred);
31 delegation->cred = NULL;
32 kfree_rcu(delegation, rcu);
33}
34
35
36
37
38
39
40void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
41{
42 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
43}
44
45static bool
46nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
47 fmode_t flags)
48{
49 if (delegation != NULL && (delegation->type & flags) == flags &&
50 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
51 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
52 return true;
53 return false;
54}
55
56static int
57nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
58{
59 struct nfs_delegation *delegation;
60 int ret = 0;
61
62 flags &= FMODE_READ|FMODE_WRITE;
63 rcu_read_lock();
64 delegation = rcu_dereference(NFS_I(inode)->delegation);
65 if (nfs4_is_valid_delegation(delegation, flags)) {
66 if (mark)
67 nfs_mark_delegation_referenced(delegation);
68 ret = 1;
69 }
70 rcu_read_unlock();
71 return ret;
72}
73
74
75
76
77
78
79
80
81int nfs4_have_delegation(struct inode *inode, fmode_t flags)
82{
83 return nfs4_do_check_delegation(inode, flags, true);
84}
85
86
87
88
89
90int nfs4_check_delegation(struct inode *inode, fmode_t flags)
91{
92 return nfs4_do_check_delegation(inode, flags, false);
93}
94
95static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_stateid *stateid)
96{
97 struct inode *inode = state->inode;
98 struct file_lock *fl;
99 struct file_lock_context *flctx = inode->i_flctx;
100 struct list_head *list;
101 int status = 0;
102
103 if (flctx == NULL)
104 goto out;
105
106 list = &flctx->flc_posix;
107 spin_lock(&flctx->flc_lock);
108restart:
109 list_for_each_entry(fl, list, fl_list) {
110 if (nfs_file_open_context(fl->fl_file)->state != state)
111 continue;
112 spin_unlock(&flctx->flc_lock);
113 status = nfs4_lock_delegation_recall(fl, state, stateid);
114 if (status < 0)
115 goto out;
116 spin_lock(&flctx->flc_lock);
117 }
118 if (list == &flctx->flc_posix) {
119 list = &flctx->flc_flock;
120 goto restart;
121 }
122 spin_unlock(&flctx->flc_lock);
123out:
124 return status;
125}
126
127static int nfs_delegation_claim_opens(struct inode *inode,
128 const nfs4_stateid *stateid, fmode_t type)
129{
130 struct nfs_inode *nfsi = NFS_I(inode);
131 struct nfs_open_context *ctx;
132 struct nfs4_state_owner *sp;
133 struct nfs4_state *state;
134 unsigned int seq;
135 int err;
136
137again:
138 rcu_read_lock();
139 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
140 state = ctx->state;
141 if (state == NULL)
142 continue;
143 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
144 continue;
145 if (!nfs4_valid_open_stateid(state))
146 continue;
147 if (!nfs4_stateid_match(&state->stateid, stateid))
148 continue;
149 if (!get_nfs_open_context(ctx))
150 continue;
151 rcu_read_unlock();
152 sp = state->owner;
153
154 mutex_lock(&sp->so_delegreturn_mutex);
155 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
156 err = nfs4_open_delegation_recall(ctx, state, stateid);
157 if (!err)
158 err = nfs_delegation_claim_locks(state, stateid);
159 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
160 err = -EAGAIN;
161 mutex_unlock(&sp->so_delegreturn_mutex);
162 put_nfs_open_context(ctx);
163 if (err != 0)
164 return err;
165 goto again;
166 }
167 rcu_read_unlock();
168 return 0;
169}
170
171
172
173
174
175
176
177
178
179
180void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
181 fmode_t type,
182 const nfs4_stateid *stateid,
183 unsigned long pagemod_limit)
184{
185 struct nfs_delegation *delegation;
186 const struct cred *oldcred = NULL;
187
188 rcu_read_lock();
189 delegation = rcu_dereference(NFS_I(inode)->delegation);
190 if (delegation != NULL) {
191 spin_lock(&delegation->lock);
192 if (delegation->inode != NULL) {
193 nfs4_stateid_copy(&delegation->stateid, stateid);
194 delegation->type = type;
195 delegation->pagemod_limit = pagemod_limit;
196 oldcred = delegation->cred;
197 delegation->cred = get_cred(cred);
198 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
199 &delegation->flags);
200 spin_unlock(&delegation->lock);
201 rcu_read_unlock();
202 put_cred(oldcred);
203 trace_nfs4_reclaim_delegation(inode, type);
204 return;
205 }
206
207 spin_unlock(&delegation->lock);
208 }
209 rcu_read_unlock();
210 nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit);
211}
212
213static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
214{
215 int res = 0;
216
217 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
218 res = nfs4_proc_delegreturn(inode,
219 delegation->cred,
220 &delegation->stateid,
221 issync);
222 nfs_free_delegation(delegation);
223 return res;
224}
225
226static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
227{
228 struct inode *inode = NULL;
229
230 spin_lock(&delegation->lock);
231 if (delegation->inode != NULL)
232 inode = igrab(delegation->inode);
233 if (!inode)
234 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
235 spin_unlock(&delegation->lock);
236 return inode;
237}
238
239static struct nfs_delegation *
240nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
241{
242 struct nfs_delegation *ret = NULL;
243 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
244
245 if (delegation == NULL)
246 goto out;
247 spin_lock(&delegation->lock);
248 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
249 ret = delegation;
250 spin_unlock(&delegation->lock);
251out:
252 return ret;
253}
254
255static struct nfs_delegation *
256nfs_start_delegation_return(struct nfs_inode *nfsi)
257{
258 struct nfs_delegation *delegation;
259
260 rcu_read_lock();
261 delegation = nfs_start_delegation_return_locked(nfsi);
262 rcu_read_unlock();
263 return delegation;
264}
265
266static void
267nfs_abort_delegation_return(struct nfs_delegation *delegation,
268 struct nfs_client *clp)
269{
270
271 spin_lock(&delegation->lock);
272 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
273 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
274 spin_unlock(&delegation->lock);
275 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
276}
277
278static struct nfs_delegation *
279nfs_detach_delegation_locked(struct nfs_inode *nfsi,
280 struct nfs_delegation *delegation,
281 struct nfs_client *clp)
282{
283 struct nfs_delegation *deleg_cur =
284 rcu_dereference_protected(nfsi->delegation,
285 lockdep_is_held(&clp->cl_lock));
286
287 if (deleg_cur == NULL || delegation != deleg_cur)
288 return NULL;
289
290 spin_lock(&delegation->lock);
291 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
292 list_del_rcu(&delegation->super_list);
293 delegation->inode = NULL;
294 rcu_assign_pointer(nfsi->delegation, NULL);
295 spin_unlock(&delegation->lock);
296 return delegation;
297}
298
299static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
300 struct nfs_delegation *delegation,
301 struct nfs_server *server)
302{
303 struct nfs_client *clp = server->nfs_client;
304
305 spin_lock(&clp->cl_lock);
306 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
307 spin_unlock(&clp->cl_lock);
308 return delegation;
309}
310
311static struct nfs_delegation *
312nfs_inode_detach_delegation(struct inode *inode)
313{
314 struct nfs_inode *nfsi = NFS_I(inode);
315 struct nfs_server *server = NFS_SERVER(inode);
316 struct nfs_delegation *delegation;
317
318 delegation = nfs_start_delegation_return(nfsi);
319 if (delegation == NULL)
320 return NULL;
321 return nfs_detach_delegation(nfsi, delegation, server);
322}
323
324static void
325nfs_update_inplace_delegation(struct nfs_delegation *delegation,
326 const struct nfs_delegation *update)
327{
328 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
329 delegation->stateid.seqid = update->stateid.seqid;
330 smp_wmb();
331 delegation->type = update->type;
332 }
333}
334
335
336
337
338
339
340
341
342
343
344
345int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
346 fmode_t type,
347 const nfs4_stateid *stateid,
348 unsigned long pagemod_limit)
349{
350 struct nfs_server *server = NFS_SERVER(inode);
351 struct nfs_client *clp = server->nfs_client;
352 struct nfs_inode *nfsi = NFS_I(inode);
353 struct nfs_delegation *delegation, *old_delegation;
354 struct nfs_delegation *freeme = NULL;
355 int status = 0;
356
357 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
358 if (delegation == NULL)
359 return -ENOMEM;
360 nfs4_stateid_copy(&delegation->stateid, stateid);
361 delegation->type = type;
362 delegation->pagemod_limit = pagemod_limit;
363 delegation->change_attr = inode_peek_iversion_raw(inode);
364 delegation->cred = get_cred(cred);
365 delegation->inode = inode;
366 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
367 spin_lock_init(&delegation->lock);
368
369 spin_lock(&clp->cl_lock);
370 old_delegation = rcu_dereference_protected(nfsi->delegation,
371 lockdep_is_held(&clp->cl_lock));
372 if (old_delegation != NULL) {
373
374 if (nfs4_stateid_match_other(&old_delegation->stateid,
375 &delegation->stateid)) {
376 nfs_update_inplace_delegation(old_delegation,
377 delegation);
378 goto out;
379 }
380
381
382
383
384
385
386 dfprintk(FILE, "%s: server %s handed out "
387 "a duplicate delegation!\n",
388 __func__, clp->cl_hostname);
389 if (delegation->type == old_delegation->type ||
390 !(delegation->type & FMODE_WRITE)) {
391 freeme = delegation;
392 delegation = NULL;
393 goto out;
394 }
395 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
396 &old_delegation->flags))
397 goto out;
398 freeme = nfs_detach_delegation_locked(nfsi,
399 old_delegation, clp);
400 if (freeme == NULL)
401 goto out;
402 }
403 list_add_tail_rcu(&delegation->super_list, &server->delegations);
404 rcu_assign_pointer(nfsi->delegation, delegation);
405 delegation = NULL;
406
407 trace_nfs4_set_delegation(inode, type);
408
409 spin_lock(&inode->i_lock);
410 if (NFS_I(inode)->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME))
411 NFS_I(inode)->cache_validity |= NFS_INO_REVAL_FORCED;
412 spin_unlock(&inode->i_lock);
413out:
414 spin_unlock(&clp->cl_lock);
415 if (delegation != NULL)
416 nfs_free_delegation(delegation);
417 if (freeme != NULL)
418 nfs_do_return_delegation(inode, freeme, 0);
419 return status;
420}
421
422
423
424
425static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
426{
427 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
428 struct nfs_inode *nfsi = NFS_I(inode);
429 int err = 0;
430
431 if (delegation == NULL)
432 return 0;
433 do {
434 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
435 break;
436 err = nfs_delegation_claim_opens(inode, &delegation->stateid,
437 delegation->type);
438 if (!issync || err != -EAGAIN)
439 break;
440
441
442
443 err = nfs4_wait_clnt_recover(clp);
444 } while (err == 0);
445
446 if (err) {
447 nfs_abort_delegation_return(delegation, clp);
448 goto out;
449 }
450 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
451 goto out;
452
453 err = nfs_do_return_delegation(inode, delegation, issync);
454out:
455 return err;
456}
457
458static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
459{
460 bool ret = false;
461
462 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
463 goto out;
464 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
465 ret = true;
466 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
467 struct inode *inode;
468
469 spin_lock(&delegation->lock);
470 inode = delegation->inode;
471 if (inode && list_empty(&NFS_I(inode)->open_files))
472 ret = true;
473 spin_unlock(&delegation->lock);
474 }
475out:
476 return ret;
477}
478
479
480
481
482
483
484
485
486
487
488
489int nfs_client_return_marked_delegations(struct nfs_client *clp)
490{
491 struct nfs_delegation *delegation;
492 struct nfs_delegation *prev;
493 struct nfs_server *server;
494 struct inode *inode;
495 struct inode *place_holder = NULL;
496 struct nfs_delegation *place_holder_deleg = NULL;
497 int err = 0;
498
499restart:
500
501
502
503
504
505
506
507
508
509
510 rcu_read_lock();
511 prev = NULL;
512 if (place_holder)
513 server = NFS_SERVER(place_holder);
514 else
515 server = list_entry_rcu(clp->cl_superblocks.next,
516 struct nfs_server, client_link);
517 list_for_each_entry_from_rcu(server, &clp->cl_superblocks, client_link) {
518 delegation = NULL;
519 if (place_holder && server == NFS_SERVER(place_holder))
520 delegation = rcu_dereference(NFS_I(place_holder)->delegation);
521 if (!delegation || delegation != place_holder_deleg)
522 delegation = list_entry_rcu(server->delegations.next,
523 struct nfs_delegation, super_list);
524 list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
525 struct inode *to_put = NULL;
526
527 if (!nfs_delegation_need_return(delegation)) {
528 prev = delegation;
529 continue;
530 }
531 if (!nfs_sb_active(server->super))
532 break;
533
534 if (prev) {
535 struct inode *tmp;
536
537 tmp = nfs_delegation_grab_inode(prev);
538 if (tmp) {
539 to_put = place_holder;
540 place_holder = tmp;
541 place_holder_deleg = prev;
542 }
543 }
544
545 inode = nfs_delegation_grab_inode(delegation);
546 if (inode == NULL) {
547 rcu_read_unlock();
548 if (to_put)
549 iput(to_put);
550 nfs_sb_deactive(server->super);
551 goto restart;
552 }
553 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
554 rcu_read_unlock();
555
556 if (to_put)
557 iput(to_put);
558
559 err = nfs_end_delegation_return(inode, delegation, 0);
560 iput(inode);
561 nfs_sb_deactive(server->super);
562 cond_resched();
563 if (!err)
564 goto restart;
565 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
566 if (place_holder)
567 iput(place_holder);
568 return err;
569 }
570 }
571 rcu_read_unlock();
572 if (place_holder)
573 iput(place_holder);
574 return 0;
575}
576
577
578
579
580
581
582
583
584void nfs_inode_return_delegation_noreclaim(struct inode *inode)
585{
586 struct nfs_delegation *delegation;
587
588 delegation = nfs_inode_detach_delegation(inode);
589 if (delegation != NULL)
590 nfs_do_return_delegation(inode, delegation, 1);
591}
592
593
594
595
596
597
598
599
600
601
602
603int nfs4_inode_return_delegation(struct inode *inode)
604{
605 struct nfs_inode *nfsi = NFS_I(inode);
606 struct nfs_delegation *delegation;
607 int err = 0;
608
609 nfs_wb_all(inode);
610 delegation = nfs_start_delegation_return(nfsi);
611 if (delegation != NULL)
612 err = nfs_end_delegation_return(inode, delegation, 1);
613 return err;
614}
615
616
617
618
619
620
621
622
623
624int nfs4_inode_make_writeable(struct inode *inode)
625{
626 if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) ||
627 !nfs4_check_delegation(inode, FMODE_WRITE))
628 return nfs4_inode_return_delegation(inode);
629 return 0;
630}
631
632static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
633 struct nfs_delegation *delegation)
634{
635 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
636 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
637}
638
639static void nfs_mark_return_delegation(struct nfs_server *server,
640 struct nfs_delegation *delegation)
641{
642 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
643 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
644}
645
646static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
647{
648 struct nfs_delegation *delegation;
649 bool ret = false;
650
651 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
652 nfs_mark_return_delegation(server, delegation);
653 ret = true;
654 }
655 return ret;
656}
657
658static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
659{
660 struct nfs_server *server;
661
662 rcu_read_lock();
663 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
664 nfs_server_mark_return_all_delegations(server);
665 rcu_read_unlock();
666}
667
668static void nfs_delegation_run_state_manager(struct nfs_client *clp)
669{
670 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
671 nfs4_schedule_state_manager(clp);
672}
673
674
675
676
677
678
679void nfs_expire_all_delegations(struct nfs_client *clp)
680{
681 nfs_client_mark_return_all_delegations(clp);
682 nfs_delegation_run_state_manager(clp);
683}
684
685
686
687
688
689
690void nfs_server_return_all_delegations(struct nfs_server *server)
691{
692 struct nfs_client *clp = server->nfs_client;
693 bool need_wait;
694
695 if (clp == NULL)
696 return;
697
698 rcu_read_lock();
699 need_wait = nfs_server_mark_return_all_delegations(server);
700 rcu_read_unlock();
701
702 if (need_wait) {
703 nfs4_schedule_state_manager(clp);
704 nfs4_wait_clnt_recover(clp);
705 }
706}
707
708static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
709 fmode_t flags)
710{
711 struct nfs_delegation *delegation;
712
713 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
714 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
715 continue;
716 if (delegation->type & flags)
717 nfs_mark_return_if_closed_delegation(server, delegation);
718 }
719}
720
721static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
722 fmode_t flags)
723{
724 struct nfs_server *server;
725
726 rcu_read_lock();
727 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
728 nfs_mark_return_unused_delegation_types(server, flags);
729 rcu_read_unlock();
730}
731
732static void nfs_mark_delegation_revoked(struct nfs_server *server,
733 struct nfs_delegation *delegation)
734{
735 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
736 delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
737 nfs_mark_return_delegation(server, delegation);
738}
739
740static bool nfs_revoke_delegation(struct inode *inode,
741 const nfs4_stateid *stateid)
742{
743 struct nfs_delegation *delegation;
744 nfs4_stateid tmp;
745 bool ret = false;
746
747 rcu_read_lock();
748 delegation = rcu_dereference(NFS_I(inode)->delegation);
749 if (delegation == NULL)
750 goto out;
751 if (stateid == NULL) {
752 nfs4_stateid_copy(&tmp, &delegation->stateid);
753 stateid = &tmp;
754 } else if (!nfs4_stateid_match(stateid, &delegation->stateid))
755 goto out;
756 nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
757 ret = true;
758out:
759 rcu_read_unlock();
760 if (ret)
761 nfs_inode_find_state_and_recover(inode, stateid);
762 return ret;
763}
764
765void nfs_remove_bad_delegation(struct inode *inode,
766 const nfs4_stateid *stateid)
767{
768 struct nfs_delegation *delegation;
769
770 if (!nfs_revoke_delegation(inode, stateid))
771 return;
772 delegation = nfs_inode_detach_delegation(inode);
773 if (delegation)
774 nfs_free_delegation(delegation);
775}
776EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
777
778
779
780
781
782
783
784void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
785{
786 nfs_client_mark_return_unused_delegation_types(clp, flags);
787 nfs_delegation_run_state_manager(clp);
788}
789
790static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
791{
792 struct nfs_delegation *delegation;
793
794 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
795 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
796 continue;
797 nfs_mark_return_if_closed_delegation(server, delegation);
798 }
799}
800
801
802
803
804
805
806void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
807{
808 struct nfs_server *server;
809
810 rcu_read_lock();
811 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
812 nfs_mark_return_unreferenced_delegations(server);
813 rcu_read_unlock();
814
815 nfs_delegation_run_state_manager(clp);
816}
817
818
819
820
821
822
823
824
825int nfs_async_inode_return_delegation(struct inode *inode,
826 const nfs4_stateid *stateid)
827{
828 struct nfs_server *server = NFS_SERVER(inode);
829 struct nfs_client *clp = server->nfs_client;
830 struct nfs_delegation *delegation;
831
832 rcu_read_lock();
833 delegation = rcu_dereference(NFS_I(inode)->delegation);
834 if (delegation == NULL)
835 goto out_enoent;
836 if (stateid != NULL &&
837 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
838 goto out_enoent;
839 nfs_mark_return_delegation(server, delegation);
840 rcu_read_unlock();
841
842 nfs_delegation_run_state_manager(clp);
843 return 0;
844out_enoent:
845 rcu_read_unlock();
846 return -ENOENT;
847}
848
849static struct inode *
850nfs_delegation_find_inode_server(struct nfs_server *server,
851 const struct nfs_fh *fhandle)
852{
853 struct nfs_delegation *delegation;
854 struct inode *freeme, *res = NULL;
855
856 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
857 spin_lock(&delegation->lock);
858 if (delegation->inode != NULL &&
859 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
860 freeme = igrab(delegation->inode);
861 if (freeme && nfs_sb_active(freeme->i_sb))
862 res = freeme;
863 spin_unlock(&delegation->lock);
864 if (res != NULL)
865 return res;
866 if (freeme) {
867 rcu_read_unlock();
868 iput(freeme);
869 rcu_read_lock();
870 }
871 return ERR_PTR(-EAGAIN);
872 }
873 spin_unlock(&delegation->lock);
874 }
875 return ERR_PTR(-ENOENT);
876}
877
878
879
880
881
882
883
884
885
886struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
887 const struct nfs_fh *fhandle)
888{
889 struct nfs_server *server;
890 struct inode *res;
891
892 rcu_read_lock();
893 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
894 res = nfs_delegation_find_inode_server(server, fhandle);
895 if (res != ERR_PTR(-ENOENT)) {
896 rcu_read_unlock();
897 return res;
898 }
899 }
900 rcu_read_unlock();
901 return ERR_PTR(-ENOENT);
902}
903
904static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
905{
906 struct nfs_delegation *delegation;
907
908 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
909
910
911
912
913 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
914 continue;
915 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
916 }
917}
918
919
920
921
922
923
924void nfs_delegation_mark_reclaim(struct nfs_client *clp)
925{
926 struct nfs_server *server;
927
928 rcu_read_lock();
929 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
930 nfs_delegation_mark_reclaim_server(server);
931 rcu_read_unlock();
932}
933
934
935
936
937
938
939void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
940{
941 struct nfs_delegation *delegation;
942 struct nfs_server *server;
943 struct inode *inode;
944
945restart:
946 rcu_read_lock();
947 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
948 list_for_each_entry_rcu(delegation, &server->delegations,
949 super_list) {
950 if (test_bit(NFS_DELEGATION_INODE_FREEING,
951 &delegation->flags) ||
952 test_bit(NFS_DELEGATION_RETURNING,
953 &delegation->flags) ||
954 test_bit(NFS_DELEGATION_NEED_RECLAIM,
955 &delegation->flags) == 0)
956 continue;
957 if (!nfs_sb_active(server->super))
958 break;
959 inode = nfs_delegation_grab_inode(delegation);
960 if (inode == NULL) {
961 rcu_read_unlock();
962 nfs_sb_deactive(server->super);
963 goto restart;
964 }
965 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
966 rcu_read_unlock();
967 if (delegation != NULL) {
968 delegation = nfs_detach_delegation(NFS_I(inode),
969 delegation, server);
970 if (delegation != NULL)
971 nfs_free_delegation(delegation);
972 }
973 iput(inode);
974 nfs_sb_deactive(server->super);
975 cond_resched();
976 goto restart;
977 }
978 }
979 rcu_read_unlock();
980}
981
982static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
983{
984 return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
985 BIT(NFS4CLNT_LEASE_EXPIRED) |
986 BIT(NFS4CLNT_SESSION_RESET))) != 0;
987}
988
989static void nfs_mark_test_expired_delegation(struct nfs_server *server,
990 struct nfs_delegation *delegation)
991{
992 if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
993 return;
994 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
995 set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
996 set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
997}
998
999static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
1000 struct inode *inode)
1001{
1002 struct nfs_delegation *delegation;
1003
1004 rcu_read_lock();
1005 delegation = rcu_dereference(NFS_I(inode)->delegation);
1006 if (delegation)
1007 nfs_mark_test_expired_delegation(server, delegation);
1008 rcu_read_unlock();
1009
1010}
1011
1012static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
1013{
1014 struct nfs_delegation *delegation;
1015
1016 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
1017 nfs_mark_test_expired_delegation(server, delegation);
1018}
1019
1020
1021
1022
1023
1024
1025
1026
1027void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
1028{
1029 struct nfs_server *server;
1030
1031 rcu_read_lock();
1032 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1033 nfs_delegation_mark_test_expired_server(server);
1034 rcu_read_unlock();
1035}
1036
1037
1038
1039
1040
1041
1042
1043void nfs_test_expired_all_delegations(struct nfs_client *clp)
1044{
1045 nfs_mark_test_expired_all_delegations(clp);
1046 nfs4_schedule_state_manager(clp);
1047}
1048
1049static void
1050nfs_delegation_test_free_expired(struct inode *inode,
1051 nfs4_stateid *stateid,
1052 const struct cred *cred)
1053{
1054 struct nfs_server *server = NFS_SERVER(inode);
1055 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
1056 int status;
1057
1058 if (!cred)
1059 return;
1060 status = ops->test_and_free_expired(server, stateid, cred);
1061 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
1062 nfs_remove_bad_delegation(inode, stateid);
1063}
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074void nfs_reap_expired_delegations(struct nfs_client *clp)
1075{
1076 struct nfs_delegation *delegation;
1077 struct nfs_server *server;
1078 struct inode *inode;
1079 const struct cred *cred;
1080 nfs4_stateid stateid;
1081
1082restart:
1083 rcu_read_lock();
1084 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1085 list_for_each_entry_rcu(delegation, &server->delegations,
1086 super_list) {
1087 if (test_bit(NFS_DELEGATION_INODE_FREEING,
1088 &delegation->flags) ||
1089 test_bit(NFS_DELEGATION_RETURNING,
1090 &delegation->flags) ||
1091 test_bit(NFS_DELEGATION_TEST_EXPIRED,
1092 &delegation->flags) == 0)
1093 continue;
1094 if (!nfs_sb_active(server->super))
1095 break;
1096 inode = nfs_delegation_grab_inode(delegation);
1097 if (inode == NULL) {
1098 rcu_read_unlock();
1099 nfs_sb_deactive(server->super);
1100 goto restart;
1101 }
1102 cred = get_cred_rcu(delegation->cred);
1103 nfs4_stateid_copy(&stateid, &delegation->stateid);
1104 clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1105 rcu_read_unlock();
1106 nfs_delegation_test_free_expired(inode, &stateid, cred);
1107 put_cred(cred);
1108 if (nfs4_server_rebooted(clp)) {
1109 nfs_inode_mark_test_expired_delegation(server,inode);
1110 iput(inode);
1111 nfs_sb_deactive(server->super);
1112 return;
1113 }
1114 iput(inode);
1115 nfs_sb_deactive(server->super);
1116 cond_resched();
1117 goto restart;
1118 }
1119 }
1120 rcu_read_unlock();
1121}
1122
1123void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1124 const nfs4_stateid *stateid)
1125{
1126 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1127 struct nfs_delegation *delegation;
1128 bool found = false;
1129
1130 rcu_read_lock();
1131 delegation = rcu_dereference(NFS_I(inode)->delegation);
1132 if (delegation &&
1133 nfs4_stateid_match_other(&delegation->stateid, stateid)) {
1134 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1135 found = true;
1136 }
1137 rcu_read_unlock();
1138 if (found)
1139 nfs4_schedule_state_manager(clp);
1140}
1141
1142
1143
1144
1145
1146
1147
1148
1149int nfs_delegations_present(struct nfs_client *clp)
1150{
1151 struct nfs_server *server;
1152 int ret = 0;
1153
1154 rcu_read_lock();
1155 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1156 if (!list_empty(&server->delegations)) {
1157 ret = 1;
1158 break;
1159 }
1160 rcu_read_unlock();
1161 return ret;
1162}
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
1173{
1174 struct nfs_delegation *delegation;
1175 bool ret = false;
1176 if (!inode)
1177 goto out;
1178
1179 rcu_read_lock();
1180 delegation = rcu_dereference(NFS_I(inode)->delegation);
1181 if (delegation != NULL &&
1182 nfs4_stateid_match_other(dst, &delegation->stateid)) {
1183 dst->seqid = delegation->stateid.seqid;
1184 return ret;
1185 }
1186 rcu_read_unlock();
1187out:
1188 return ret;
1189}
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1202 nfs4_stateid *dst, const struct cred **cred)
1203{
1204 struct nfs_inode *nfsi = NFS_I(inode);
1205 struct nfs_delegation *delegation;
1206 bool ret;
1207
1208 flags &= FMODE_READ|FMODE_WRITE;
1209 rcu_read_lock();
1210 delegation = rcu_dereference(nfsi->delegation);
1211 ret = nfs4_is_valid_delegation(delegation, flags);
1212 if (ret) {
1213 nfs4_stateid_copy(dst, &delegation->stateid);
1214 nfs_mark_delegation_referenced(delegation);
1215 if (cred)
1216 *cred = get_cred(delegation->cred);
1217 }
1218 rcu_read_unlock();
1219 return ret;
1220}
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230bool nfs4_delegation_flush_on_close(const struct inode *inode)
1231{
1232 struct nfs_inode *nfsi = NFS_I(inode);
1233 struct nfs_delegation *delegation;
1234 bool ret = true;
1235
1236 rcu_read_lock();
1237 delegation = rcu_dereference(nfsi->delegation);
1238 if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1239 goto out;
1240 if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit)
1241 ret = false;
1242out:
1243 rcu_read_unlock();
1244 return ret;
1245}
1246