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