Lines Matching full:delegation
3 * linux/fs/nfs/delegation.c
7 * NFS file delegation management
24 #include "delegation.h"
33 static void __nfs_free_delegation(struct nfs_delegation *delegation) in __nfs_free_delegation() argument
35 put_cred(delegation->cred); in __nfs_free_delegation()
36 delegation->cred = NULL; in __nfs_free_delegation()
37 kfree_rcu(delegation, rcu); in __nfs_free_delegation()
40 static void nfs_mark_delegation_revoked(struct nfs_delegation *delegation) in nfs_mark_delegation_revoked() argument
42 if (!test_and_set_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { in nfs_mark_delegation_revoked()
43 delegation->stateid.type = NFS4_INVALID_STATEID_TYPE; in nfs_mark_delegation_revoked()
45 if (!test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) in nfs_mark_delegation_revoked()
46 nfs_clear_verifier_delegated(delegation->inode); in nfs_mark_delegation_revoked()
50 static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation) in nfs_get_delegation() argument
52 refcount_inc(&delegation->refcount); in nfs_get_delegation()
53 return delegation; in nfs_get_delegation()
56 static void nfs_put_delegation(struct nfs_delegation *delegation) in nfs_put_delegation() argument
58 if (refcount_dec_and_test(&delegation->refcount)) in nfs_put_delegation()
59 __nfs_free_delegation(delegation); in nfs_put_delegation()
62 static void nfs_free_delegation(struct nfs_delegation *delegation) in nfs_free_delegation() argument
64 nfs_mark_delegation_revoked(delegation); in nfs_free_delegation()
65 nfs_put_delegation(delegation); in nfs_free_delegation()
69 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
70 * @delegation: delegation to process
73 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation) in nfs_mark_delegation_referenced() argument
75 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags); in nfs_mark_delegation_referenced()
79 struct nfs_delegation *delegation) in nfs_mark_return_delegation() argument
81 set_bit(NFS_DELEGATION_RETURN, &delegation->flags); in nfs_mark_return_delegation()
86 static bool nfs4_is_valid_delegation(const struct nfs_delegation *delegation, in nfs4_is_valid_delegation() argument
89 if (delegation != NULL && (delegation->type & type) == type && in nfs4_is_valid_delegation()
90 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) && in nfs4_is_valid_delegation()
91 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) in nfs4_is_valid_delegation()
98 struct nfs_delegation *delegation; in nfs4_get_valid_delegation() local
100 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs4_get_valid_delegation()
101 if (nfs4_is_valid_delegation(delegation, 0)) in nfs4_get_valid_delegation()
102 return delegation; in nfs4_get_valid_delegation()
109 struct nfs_delegation *delegation; in nfs4_do_check_delegation() local
114 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs4_do_check_delegation()
115 if (nfs4_is_valid_delegation(delegation, type)) { in nfs4_do_check_delegation()
117 nfs_mark_delegation_referenced(delegation); in nfs4_do_check_delegation()
120 !test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags)) in nfs4_do_check_delegation()
127 * nfs4_have_delegation - check if inode has a delegation, mark it
130 * @type: delegation types to check for
133 * Returns one if inode has the indicated delegation, otherwise zero.
141 * nfs4_check_delegation - check if inode has a delegation, do not mark
222 * nfs_inode_reclaim_delegation - process a delegation reclaim request
225 * @type: delegation type
226 * @stateid: delegation stateid
227 * @pagemod_limit: write delegation "space_limit"
228 * @deleg_type: raw delegation type
235 struct nfs_delegation *delegation; in nfs_inode_reclaim_delegation() local
239 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs_inode_reclaim_delegation()
240 if (delegation != NULL) { in nfs_inode_reclaim_delegation()
241 spin_lock(&delegation->lock); in nfs_inode_reclaim_delegation()
242 nfs4_stateid_copy(&delegation->stateid, stateid); in nfs_inode_reclaim_delegation()
243 delegation->type = type; in nfs_inode_reclaim_delegation()
244 delegation->pagemod_limit = pagemod_limit; in nfs_inode_reclaim_delegation()
245 oldcred = delegation->cred; in nfs_inode_reclaim_delegation()
246 delegation->cred = get_cred(cred); in nfs_inode_reclaim_delegation()
250 set_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags); in nfs_inode_reclaim_delegation()
253 clear_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags); in nfs_inode_reclaim_delegation()
255 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); in nfs_inode_reclaim_delegation()
257 &delegation->flags)) in nfs_inode_reclaim_delegation()
259 spin_unlock(&delegation->lock); in nfs_inode_reclaim_delegation()
271 struct nfs_delegation *delegation, in nfs_do_return_delegation() argument
277 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { in nfs_do_return_delegation()
278 spin_lock(&delegation->lock); in nfs_do_return_delegation()
279 cred = get_cred(delegation->cred); in nfs_do_return_delegation()
280 spin_unlock(&delegation->lock); in nfs_do_return_delegation()
281 res = nfs4_proc_delegreturn(inode, cred, &delegation->stateid, in nfs_do_return_delegation()
282 delegation, issync); in nfs_do_return_delegation()
288 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation) in nfs_delegation_grab_inode() argument
292 spin_lock(&delegation->lock); in nfs_delegation_grab_inode()
293 if (delegation->inode != NULL) in nfs_delegation_grab_inode()
294 inode = igrab(delegation->inode); in nfs_delegation_grab_inode()
296 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags); in nfs_delegation_grab_inode()
297 spin_unlock(&delegation->lock); in nfs_delegation_grab_inode()
305 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation); in nfs_start_delegation_return_locked() local
307 if (delegation == NULL) in nfs_start_delegation_return_locked()
309 spin_lock(&delegation->lock); in nfs_start_delegation_return_locked()
310 if (delegation->inode && in nfs_start_delegation_return_locked()
311 !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) { in nfs_start_delegation_return_locked()
312 clear_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags); in nfs_start_delegation_return_locked()
314 ret = nfs_get_delegation(delegation); in nfs_start_delegation_return_locked()
316 spin_unlock(&delegation->lock); in nfs_start_delegation_return_locked()
326 struct nfs_delegation *delegation; in nfs_start_delegation_return() local
329 delegation = nfs_start_delegation_return_locked(nfsi); in nfs_start_delegation_return()
331 return delegation; in nfs_start_delegation_return()
334 static void nfs_abort_delegation_return(struct nfs_delegation *delegation, in nfs_abort_delegation_return() argument
337 spin_lock(&delegation->lock); in nfs_abort_delegation_return()
338 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); in nfs_abort_delegation_return()
340 set_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags); in nfs_abort_delegation_return()
346 spin_unlock(&delegation->lock); in nfs_abort_delegation_return()
351 struct nfs_delegation *delegation, in nfs_detach_delegation_locked() argument
355 rcu_dereference_protected(nfsi->delegation, in nfs_detach_delegation_locked()
358 if (deleg_cur == NULL || delegation != deleg_cur) in nfs_detach_delegation_locked()
361 spin_lock(&delegation->lock); in nfs_detach_delegation_locked()
362 if (!delegation->inode) { in nfs_detach_delegation_locked()
363 spin_unlock(&delegation->lock); in nfs_detach_delegation_locked()
366 list_del_rcu(&delegation->super_list); in nfs_detach_delegation_locked()
367 delegation->inode = NULL; in nfs_detach_delegation_locked()
368 rcu_assign_pointer(nfsi->delegation, NULL); in nfs_detach_delegation_locked()
369 spin_unlock(&delegation->lock); in nfs_detach_delegation_locked()
370 return delegation; in nfs_detach_delegation_locked()
374 struct nfs_delegation *delegation, in nfs_detach_delegation() argument
380 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp); in nfs_detach_delegation()
382 return delegation; in nfs_detach_delegation()
390 struct nfs_delegation *delegation; in nfs_inode_detach_delegation() local
393 delegation = rcu_dereference(nfsi->delegation); in nfs_inode_detach_delegation()
394 if (delegation != NULL) in nfs_inode_detach_delegation()
395 delegation = nfs_detach_delegation(nfsi, delegation, server); in nfs_inode_detach_delegation()
397 return delegation; in nfs_inode_detach_delegation()
401 nfs_update_delegation_cred(struct nfs_delegation *delegation, in nfs_update_delegation_cred() argument
406 if (cred_fscmp(delegation->cred, cred) != 0) { in nfs_update_delegation_cred()
407 old = xchg(&delegation->cred, get_cred(cred)); in nfs_update_delegation_cred()
413 nfs_update_inplace_delegation(struct nfs_delegation *delegation, in nfs_update_inplace_delegation() argument
416 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) { in nfs_update_inplace_delegation()
417 delegation->stateid.seqid = update->stateid.seqid; in nfs_update_inplace_delegation()
419 delegation->type = update->type; in nfs_update_inplace_delegation()
420 delegation->pagemod_limit = update->pagemod_limit; in nfs_update_inplace_delegation()
421 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { in nfs_update_inplace_delegation()
422 delegation->change_attr = update->change_attr; in nfs_update_inplace_delegation()
423 nfs_update_delegation_cred(delegation, update->cred); in nfs_update_inplace_delegation()
425 clear_bit(NFS_DELEGATION_REVOKED, &delegation->flags); in nfs_update_inplace_delegation()
432 * nfs_inode_set_delegation - set up a delegation on an inode
433 * @inode: inode to which delegation applies
434 * @cred: cred to use for subsequent delegation processing
435 * @type: delegation type
436 * @stateid: delegation stateid
437 * @pagemod_limit: write delegation "space_limit"
438 * @deleg_type: raw delegation type
449 struct nfs_delegation *delegation, *old_delegation; in nfs_inode_set_delegation() local
453 delegation = kmalloc(sizeof(*delegation), GFP_KERNEL_ACCOUNT); in nfs_inode_set_delegation()
454 if (delegation == NULL) in nfs_inode_set_delegation()
456 nfs4_stateid_copy(&delegation->stateid, stateid); in nfs_inode_set_delegation()
457 refcount_set(&delegation->refcount, 1); in nfs_inode_set_delegation()
458 delegation->type = type; in nfs_inode_set_delegation()
459 delegation->pagemod_limit = pagemod_limit; in nfs_inode_set_delegation()
460 delegation->change_attr = inode_peek_iversion_raw(inode); in nfs_inode_set_delegation()
461 delegation->cred = get_cred(cred); in nfs_inode_set_delegation()
462 delegation->inode = inode; in nfs_inode_set_delegation()
463 delegation->flags = 1<<NFS_DELEGATION_REFERENCED; in nfs_inode_set_delegation()
467 delegation->flags |= BIT(NFS_DELEGATION_DELEGTIME); in nfs_inode_set_delegation()
469 delegation->test_gen = 0; in nfs_inode_set_delegation()
470 spin_lock_init(&delegation->lock); in nfs_inode_set_delegation()
473 old_delegation = rcu_dereference_protected(nfsi->delegation, in nfs_inode_set_delegation()
477 /* Is this an update of the existing delegation? */ in nfs_inode_set_delegation()
479 &delegation->stateid)) { in nfs_inode_set_delegation()
482 delegation); in nfs_inode_set_delegation()
490 * Allow for upgrades to a WRITE delegation, but in nfs_inode_set_delegation()
494 "a duplicate delegation!\n", in nfs_inode_set_delegation()
496 if (delegation->type == old_delegation->type || in nfs_inode_set_delegation()
497 !(delegation->type & FMODE_WRITE)) { in nfs_inode_set_delegation()
498 freeme = delegation; in nfs_inode_set_delegation()
499 delegation = NULL; in nfs_inode_set_delegation()
512 * the delegation, then pre-emptively ask for a full attribute in nfs_inode_set_delegation()
526 list_add_tail_rcu(&delegation->super_list, &server->delegations); in nfs_inode_set_delegation()
527 rcu_assign_pointer(nfsi->delegation, delegation); in nfs_inode_set_delegation()
528 delegation = NULL; in nfs_inode_set_delegation()
540 if (delegation != NULL) in nfs_inode_set_delegation()
541 __nfs_free_delegation(delegation); in nfs_inode_set_delegation()
550 * Basic procedure for returning a delegation to the server
552 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int is… in nfs_end_delegation_return() argument
558 if (delegation == NULL) in nfs_end_delegation_return()
567 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) in nfs_end_delegation_return()
569 err = nfs_delegation_claim_opens(inode, &delegation->stateid, in nfs_end_delegation_return()
570 delegation->type); in nfs_end_delegation_return()
580 nfs_abort_delegation_return(delegation, server, err); in nfs_end_delegation_return()
584 err = nfs_do_return_delegation(inode, delegation, issync); in nfs_end_delegation_return()
587 nfs_put_delegation(delegation); in nfs_end_delegation_return()
591 static bool nfs_delegation_need_return(struct nfs_delegation *delegation) in nfs_delegation_need_return() argument
595 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags)) in nfs_delegation_need_return()
597 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) || in nfs_delegation_need_return()
598 test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) || in nfs_delegation_need_return()
599 test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) in nfs_delegation_need_return()
608 struct nfs_delegation *delegation; in nfs_server_return_marked_delegations() local
622 * list delegation in the server from the delegations in nfs_server_return_marked_delegations()
624 * prev is an RCU-protected pointer to a delegation which in nfs_server_return_marked_delegations()
629 delegation = NULL; in nfs_server_return_marked_delegations()
632 delegation = rcu_dereference(NFS_I(place_holder)->delegation); in nfs_server_return_marked_delegations()
633 if (!delegation || delegation != place_holder_deleg) in nfs_server_return_marked_delegations()
634 delegation = list_entry_rcu(server->delegations.next, in nfs_server_return_marked_delegations()
636 list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) { in nfs_server_return_marked_delegations()
639 if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags)) in nfs_server_return_marked_delegations()
641 if (!nfs_delegation_need_return(delegation)) { in nfs_server_return_marked_delegations()
642 if (nfs4_is_valid_delegation(delegation, 0)) in nfs_server_return_marked_delegations()
643 prev = delegation; in nfs_server_return_marked_delegations()
646 inode = nfs_delegation_grab_inode(delegation); in nfs_server_return_marked_delegations()
659 delegation = nfs_start_delegation_return_locked(NFS_I(inode)); in nfs_server_return_marked_delegations()
664 err = nfs_end_delegation_return(inode, delegation, 0); in nfs_server_return_marked_delegations()
738 * nfs_inode_evict_delegation - return delegation, don't reclaim opens
741 * Does not protect against delegation reclaims, therefore really only safe
743 * the delegation structure.
747 struct nfs_delegation *delegation; in nfs_inode_evict_delegation() local
749 delegation = nfs_inode_detach_delegation(inode); in nfs_inode_evict_delegation()
750 if (delegation != NULL) { in nfs_inode_evict_delegation()
751 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags); in nfs_inode_evict_delegation()
752 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags); in nfs_inode_evict_delegation()
753 nfs_do_return_delegation(inode, delegation, 1); in nfs_inode_evict_delegation()
754 nfs_free_delegation(delegation); in nfs_inode_evict_delegation()
759 * nfs4_inode_return_delegation - synchronously return a delegation
763 * assumption that if we need to return the delegation, then
771 struct nfs_delegation *delegation; in nfs4_inode_return_delegation() local
773 delegation = nfs_start_delegation_return(nfsi); in nfs4_inode_return_delegation()
774 if (delegation != NULL) { in nfs4_inode_return_delegation()
779 return nfs_end_delegation_return(inode, delegation, 1); in nfs4_inode_return_delegation()
785 * nfs4_inode_set_return_delegation_on_close - asynchronously return a delegation
788 * This routine is called to request that the delegation be returned as soon
789 * as the file is closed. If the file is already closed, the delegation is
794 struct nfs_delegation *delegation; in nfs4_inode_set_return_delegation_on_close() local
800 delegation = nfs4_get_valid_delegation(inode); in nfs4_inode_set_return_delegation_on_close()
801 if (!delegation) in nfs4_inode_set_return_delegation_on_close()
803 spin_lock(&delegation->lock); in nfs4_inode_set_return_delegation_on_close()
804 if (!delegation->inode) in nfs4_inode_set_return_delegation_on_close()
807 !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) { in nfs4_inode_set_return_delegation_on_close()
809 ret = nfs_get_delegation(delegation); in nfs4_inode_set_return_delegation_on_close()
811 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); in nfs4_inode_set_return_delegation_on_close()
813 spin_unlock(&delegation->lock); in nfs4_inode_set_return_delegation_on_close()
822 * nfs4_inode_return_delegation_on_close - asynchronously return a delegation
826 * inode delegation needs to be returned immediately.
830 struct nfs_delegation *delegation; in nfs4_inode_return_delegation_on_close() local
836 delegation = nfs4_get_valid_delegation(inode); in nfs4_inode_return_delegation_on_close()
837 if (!delegation) in nfs4_inode_return_delegation_on_close()
839 if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) || in nfs4_inode_return_delegation_on_close()
841 spin_lock(&delegation->lock); in nfs4_inode_return_delegation_on_close()
842 if (delegation->inode && in nfs4_inode_return_delegation_on_close()
844 !test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) { in nfs4_inode_return_delegation_on_close()
845 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); in nfs4_inode_return_delegation_on_close()
847 ret = nfs_get_delegation(delegation); in nfs4_inode_return_delegation_on_close()
849 spin_unlock(&delegation->lock); in nfs4_inode_return_delegation_on_close()
862 * Make the inode writeable by returning the delegation if necessary
868 struct nfs_delegation *delegation; in nfs4_inode_make_writeable() local
871 delegation = nfs4_get_valid_delegation(inode); in nfs4_inode_make_writeable()
872 if (delegation == NULL || in nfs4_inode_make_writeable()
874 (delegation->type & FMODE_WRITE))) { in nfs4_inode_make_writeable()
884 struct nfs_delegation *delegation) in nfs_mark_return_if_closed_delegation() argument
888 if (test_bit(NFS_DELEGATION_RETURN, &delegation->flags) || in nfs_mark_return_if_closed_delegation()
889 test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags)) in nfs_mark_return_if_closed_delegation()
891 spin_lock(&delegation->lock); in nfs_mark_return_if_closed_delegation()
892 inode = delegation->inode; in nfs_mark_return_if_closed_delegation()
896 nfs_mark_return_delegation(server, delegation); in nfs_mark_return_if_closed_delegation()
898 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags); in nfs_mark_return_if_closed_delegation()
900 spin_unlock(&delegation->lock); in nfs_mark_return_if_closed_delegation()
905 struct nfs_delegation *delegation; in nfs_server_mark_return_all_delegations() local
908 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_server_mark_return_all_delegations()
909 nfs_mark_return_delegation(server, delegation); in nfs_server_mark_return_all_delegations()
968 struct nfs_delegation *delegation; in nfs_mark_return_unused_delegation_types() local
970 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_mark_return_unused_delegation_types()
971 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE)) in nfs_mark_return_unused_delegation_types()
973 if (delegation->type & flags) in nfs_mark_return_unused_delegation_types()
974 nfs_mark_return_if_closed_delegation(server, delegation); in nfs_mark_return_unused_delegation_types()
992 struct nfs_delegation *delegation; in nfs_revoke_delegation() local
997 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs_revoke_delegation()
998 if (delegation == NULL) in nfs_revoke_delegation()
1001 nfs4_stateid_copy(&tmp, &delegation->stateid); in nfs_revoke_delegation()
1004 if (!nfs4_stateid_match_other(stateid, &delegation->stateid)) in nfs_revoke_delegation()
1006 spin_lock(&delegation->lock); in nfs_revoke_delegation()
1008 if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) { in nfs_revoke_delegation()
1009 spin_unlock(&delegation->lock); in nfs_revoke_delegation()
1012 delegation->stateid.seqid = stateid->seqid; in nfs_revoke_delegation()
1014 spin_unlock(&delegation->lock); in nfs_revoke_delegation()
1016 nfs_mark_delegation_revoked(delegation); in nfs_revoke_delegation()
1034 struct nfs_delegation *delegation; in nfs_delegation_mark_returned() local
1040 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs_delegation_mark_returned()
1041 if (!delegation) in nfs_delegation_mark_returned()
1044 spin_lock(&delegation->lock); in nfs_delegation_mark_returned()
1045 if (!nfs4_stateid_match_other(stateid, &delegation->stateid)) in nfs_delegation_mark_returned()
1048 /* If delegation->stateid is newer, dont mark as returned */ in nfs_delegation_mark_returned()
1049 if (nfs4_stateid_is_newer(&delegation->stateid, stateid)) in nfs_delegation_mark_returned()
1051 if (delegation->stateid.seqid != stateid->seqid) in nfs_delegation_mark_returned()
1052 delegation->stateid.seqid = stateid->seqid; in nfs_delegation_mark_returned()
1055 nfs_mark_delegation_revoked(delegation); in nfs_delegation_mark_returned()
1056 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); in nfs_delegation_mark_returned()
1057 spin_unlock(&delegation->lock); in nfs_delegation_mark_returned()
1058 if (nfs_detach_delegation(NFS_I(inode), delegation, NFS_SERVER(inode))) in nfs_delegation_mark_returned()
1059 nfs_put_delegation(delegation); in nfs_delegation_mark_returned()
1063 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags); in nfs_delegation_mark_returned()
1065 spin_unlock(&delegation->lock); in nfs_delegation_mark_returned()
1075 * @flags: delegation types to expire
1086 struct nfs_delegation *delegation; in nfs_mark_return_unreferenced_delegations() local
1088 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_mark_return_unreferenced_delegations()
1089 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags)) in nfs_mark_return_unreferenced_delegations()
1091 nfs_mark_return_if_closed_delegation(server, delegation); in nfs_mark_return_unreferenced_delegations()
1113 * nfs_async_inode_return_delegation - asynchronously return a delegation
1124 struct nfs_delegation *delegation; in nfs_async_inode_return_delegation() local
1127 delegation = nfs4_get_valid_delegation(inode); in nfs_async_inode_return_delegation()
1128 if (delegation == NULL) in nfs_async_inode_return_delegation()
1131 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid)) in nfs_async_inode_return_delegation()
1133 nfs_mark_return_delegation(server, delegation); in nfs_async_inode_return_delegation()
1150 struct nfs_delegation *delegation; in nfs_delegation_find_inode_server() local
1154 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_delegation_find_inode_server()
1155 spin_lock(&delegation->lock); in nfs_delegation_find_inode_server()
1156 if (delegation->inode != NULL && in nfs_delegation_find_inode_server()
1157 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) && in nfs_delegation_find_inode_server()
1158 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) { in nfs_delegation_find_inode_server()
1161 res = igrab(delegation->inode); in nfs_delegation_find_inode_server()
1163 spin_unlock(&delegation->lock); in nfs_delegation_find_inode_server()
1173 spin_unlock(&delegation->lock); in nfs_delegation_find_inode_server()
1179 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
1181 * @fhandle: filehandle from a delegation recall
1206 struct nfs_delegation *delegation; in nfs_delegation_mark_reclaim_server() local
1208 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_delegation_mark_reclaim_server()
1210 * If the delegation may have been admin revoked, then we in nfs_delegation_mark_reclaim_server()
1213 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags)) in nfs_delegation_mark_reclaim_server()
1215 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); in nfs_delegation_mark_reclaim_server()
1237 struct nfs_delegation *delegation; in nfs_server_reap_unclaimed_delegations() local
1241 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_server_reap_unclaimed_delegations()
1243 &delegation->flags) || in nfs_server_reap_unclaimed_delegations()
1245 &delegation->flags) || in nfs_server_reap_unclaimed_delegations()
1247 &delegation->flags) == 0) in nfs_server_reap_unclaimed_delegations()
1249 inode = nfs_delegation_grab_inode(delegation); in nfs_server_reap_unclaimed_delegations()
1252 delegation = nfs_start_delegation_return_locked(NFS_I(inode)); in nfs_server_reap_unclaimed_delegations()
1254 if (delegation != NULL) { in nfs_server_reap_unclaimed_delegations()
1255 if (nfs_detach_delegation(NFS_I(inode), delegation, in nfs_server_reap_unclaimed_delegations()
1257 nfs_free_delegation(delegation); in nfs_server_reap_unclaimed_delegations()
1259 nfs_put_delegation(delegation); in nfs_server_reap_unclaimed_delegations()
1288 struct nfs_delegation *delegation) in nfs_mark_test_expired_delegation() argument
1290 if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE) in nfs_mark_test_expired_delegation()
1292 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags); in nfs_mark_test_expired_delegation()
1293 set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); in nfs_mark_test_expired_delegation()
1301 struct nfs_delegation *delegation; in nfs_inode_mark_test_expired_delegation() local
1304 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs_inode_mark_test_expired_delegation()
1305 if (delegation) in nfs_inode_mark_test_expired_delegation()
1306 nfs_mark_test_expired_delegation(server, delegation); in nfs_inode_mark_test_expired_delegation()
1313 struct nfs_delegation *delegation; in nfs_delegation_mark_test_expired_server() local
1315 list_for_each_entry_rcu(delegation, &server->delegations, super_list) in nfs_delegation_mark_test_expired_server()
1316 nfs_mark_test_expired_delegation(server, delegation); in nfs_delegation_mark_test_expired_server()
1367 struct nfs_delegation *delegation; in nfs_server_reap_expired_delegations() local
1378 list_for_each_entry_rcu(delegation, &server->delegations, super_list) { in nfs_server_reap_expired_delegations()
1380 &delegation->flags) || in nfs_server_reap_expired_delegations()
1382 &delegation->flags) || in nfs_server_reap_expired_delegations()
1384 &delegation->flags) == 0 || in nfs_server_reap_expired_delegations()
1385 delegation->test_gen == gen) in nfs_server_reap_expired_delegations()
1387 inode = nfs_delegation_grab_inode(delegation); in nfs_server_reap_expired_delegations()
1390 spin_lock(&delegation->lock); in nfs_server_reap_expired_delegations()
1391 cred = get_cred_rcu(delegation->cred); in nfs_server_reap_expired_delegations()
1392 nfs4_stateid_copy(&stateid, &delegation->stateid); in nfs_server_reap_expired_delegations()
1393 spin_unlock(&delegation->lock); in nfs_server_reap_expired_delegations()
1394 delegation->test_gen = gen; in nfs_server_reap_expired_delegations()
1395 clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags); in nfs_server_reap_expired_delegations()
1434 struct nfs_delegation *delegation; in nfs_inode_find_delegation_state_and_recover() local
1438 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs_inode_find_delegation_state_and_recover()
1439 if (delegation && in nfs_inode_find_delegation_state_and_recover()
1440 nfs4_stateid_match_or_older(&delegation->stateid, stateid) && in nfs_inode_find_delegation_state_and_recover()
1441 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { in nfs_inode_find_delegation_state_and_recover()
1442 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation); in nfs_inode_find_delegation_state_and_recover()
1473 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid
1477 * Returns "true" and updates "dst->seqid" * if inode had a delegation
1478 * that matches our delegation stateid. Otherwise "false" is returned.
1482 struct nfs_delegation *delegation; in nfs4_refresh_delegation_stateid() local
1488 delegation = rcu_dereference(NFS_I(inode)->delegation); in nfs4_refresh_delegation_stateid()
1489 if (delegation != NULL && in nfs4_refresh_delegation_stateid()
1490 nfs4_stateid_match_other(dst, &delegation->stateid) && in nfs4_refresh_delegation_stateid()
1491 nfs4_stateid_is_newer(&delegation->stateid, dst) && in nfs4_refresh_delegation_stateid()
1492 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) { in nfs4_refresh_delegation_stateid()
1493 dst->seqid = delegation->stateid.seqid; in nfs4_refresh_delegation_stateid()
1504 * @flags: delegation type requirement
1508 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1515 struct nfs_delegation *delegation; in nfs4_copy_delegation_stateid() local
1520 delegation = rcu_dereference(nfsi->delegation); in nfs4_copy_delegation_stateid()
1521 if (!delegation) in nfs4_copy_delegation_stateid()
1523 spin_lock(&delegation->lock); in nfs4_copy_delegation_stateid()
1524 ret = nfs4_is_valid_delegation(delegation, flags); in nfs4_copy_delegation_stateid()
1526 nfs4_stateid_copy(dst, &delegation->stateid); in nfs4_copy_delegation_stateid()
1527 nfs_mark_delegation_referenced(delegation); in nfs4_copy_delegation_stateid()
1529 *cred = get_cred(delegation->cred); in nfs4_copy_delegation_stateid()
1531 spin_unlock(&delegation->lock); in nfs4_copy_delegation_stateid()
1542 * against the delegation 'space_limit' field to see if
1548 struct nfs_delegation *delegation; in nfs4_delegation_flush_on_close() local
1552 delegation = rcu_dereference(nfsi->delegation); in nfs4_delegation_flush_on_close()
1553 if (delegation == NULL || !(delegation->type & FMODE_WRITE)) in nfs4_delegation_flush_on_close()
1555 if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit) in nfs4_delegation_flush_on_close()