1 // SPDX-License-Identifier: GPL-2.0-only
3 * linux/fs/nfs/delegation.c
5 * Copyright (C) 2004 Trond Myklebust
7 * NFS file delegation management
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>
18 #include <linux/nfs4.h>
19 #include <linux/nfs_fs.h>
20 #include <linux/nfs_xdr.h>
23 #include "nfs4session.h"
24 #include "delegation.h"
26 #include "nfs4trace.h"
28 #define NFS_DEFAULT_DELEGATION_WATERMARK (5000U)
30 static atomic_long_t nfs_active_delegations
;
31 static unsigned nfs_delegation_watermark
= NFS_DEFAULT_DELEGATION_WATERMARK
;
33 static void __nfs_free_delegation(struct nfs_delegation
*delegation
)
35 put_cred(delegation
->cred
);
36 delegation
->cred
= NULL
;
37 kfree_rcu(delegation
, rcu
);
40 static void nfs_mark_delegation_revoked(struct nfs_delegation
*delegation
)
42 if (!test_and_set_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
43 delegation
->stateid
.type
= NFS4_INVALID_STATEID_TYPE
;
44 atomic_long_dec(&nfs_active_delegations
);
45 if (!test_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
))
46 nfs_clear_verifier_delegated(delegation
->inode
);
50 static struct nfs_delegation
*nfs_get_delegation(struct nfs_delegation
*delegation
)
52 refcount_inc(&delegation
->refcount
);
56 static void nfs_put_delegation(struct nfs_delegation
*delegation
)
58 if (refcount_dec_and_test(&delegation
->refcount
))
59 __nfs_free_delegation(delegation
);
62 static void nfs_free_delegation(struct nfs_delegation
*delegation
)
64 nfs_mark_delegation_revoked(delegation
);
65 nfs_put_delegation(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
)
75 set_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
);
78 static void nfs_mark_return_delegation(struct nfs_server
*server
,
79 struct nfs_delegation
*delegation
)
81 set_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
);
82 set_bit(NFS4CLNT_DELEGRETURN
, &server
->nfs_client
->cl_state
);
86 nfs4_is_valid_delegation(const struct nfs_delegation
*delegation
,
89 if (delegation
!= NULL
&& (delegation
->type
& flags
) == flags
&&
90 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
) &&
91 !test_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
))
96 struct nfs_delegation
*nfs4_get_valid_delegation(const struct inode
*inode
)
98 struct nfs_delegation
*delegation
;
100 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
101 if (nfs4_is_valid_delegation(delegation
, 0))
107 nfs4_do_check_delegation(struct inode
*inode
, fmode_t flags
, bool mark
)
109 struct nfs_delegation
*delegation
;
112 flags
&= FMODE_READ
|FMODE_WRITE
;
114 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
115 if (nfs4_is_valid_delegation(delegation
, flags
)) {
117 nfs_mark_delegation_referenced(delegation
);
124 * nfs4_have_delegation - check if inode has a delegation, mark it
125 * NFS_DELEGATION_REFERENCED if there is one.
126 * @inode: inode to check
127 * @flags: delegation types to check for
129 * Returns one if inode has the indicated delegation, otherwise zero.
131 int nfs4_have_delegation(struct inode
*inode
, fmode_t flags
)
133 return nfs4_do_check_delegation(inode
, flags
, true);
137 * nfs4_check_delegation - check if inode has a delegation, do not mark
138 * NFS_DELEGATION_REFERENCED if it has one.
140 int nfs4_check_delegation(struct inode
*inode
, fmode_t flags
)
142 return nfs4_do_check_delegation(inode
, flags
, false);
145 static int nfs_delegation_claim_locks(struct nfs4_state
*state
, const nfs4_stateid
*stateid
)
147 struct inode
*inode
= state
->inode
;
148 struct file_lock
*fl
;
149 struct file_lock_context
*flctx
= locks_inode_context(inode
);
150 struct list_head
*list
;
156 list
= &flctx
->flc_posix
;
157 spin_lock(&flctx
->flc_lock
);
159 for_each_file_lock(fl
, list
) {
160 if (nfs_file_open_context(fl
->fl_file
)->state
!= state
)
162 spin_unlock(&flctx
->flc_lock
);
163 status
= nfs4_lock_delegation_recall(fl
, state
, stateid
);
166 spin_lock(&flctx
->flc_lock
);
168 if (list
== &flctx
->flc_posix
) {
169 list
= &flctx
->flc_flock
;
172 spin_unlock(&flctx
->flc_lock
);
177 static int nfs_delegation_claim_opens(struct inode
*inode
,
178 const nfs4_stateid
*stateid
, fmode_t type
)
180 struct nfs_inode
*nfsi
= NFS_I(inode
);
181 struct nfs_open_context
*ctx
;
182 struct nfs4_state_owner
*sp
;
183 struct nfs4_state
*state
;
189 list_for_each_entry_rcu(ctx
, &nfsi
->open_files
, list
) {
193 if (!test_bit(NFS_DELEGATED_STATE
, &state
->flags
))
195 if (!nfs4_valid_open_stateid(state
))
197 if (!nfs4_stateid_match(&state
->stateid
, stateid
))
199 if (!get_nfs_open_context(ctx
))
203 /* Block nfs4_proc_unlck */
204 mutex_lock(&sp
->so_delegreturn_mutex
);
205 seq
= raw_seqcount_begin(&sp
->so_reclaim_seqcount
);
206 err
= nfs4_open_delegation_recall(ctx
, state
, stateid
);
208 err
= nfs_delegation_claim_locks(state
, stateid
);
209 if (!err
&& read_seqcount_retry(&sp
->so_reclaim_seqcount
, seq
))
211 mutex_unlock(&sp
->so_delegreturn_mutex
);
212 put_nfs_open_context(ctx
);
222 * nfs_inode_reclaim_delegation - process a delegation reclaim request
223 * @inode: inode to process
224 * @cred: credential to use for request
225 * @type: delegation type
226 * @stateid: delegation stateid
227 * @pagemod_limit: write delegation "space_limit"
230 void nfs_inode_reclaim_delegation(struct inode
*inode
, const struct cred
*cred
,
231 fmode_t type
, const nfs4_stateid
*stateid
,
232 unsigned long pagemod_limit
)
234 struct nfs_delegation
*delegation
;
235 const struct cred
*oldcred
= NULL
;
238 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
239 if (delegation
!= NULL
) {
240 spin_lock(&delegation
->lock
);
241 nfs4_stateid_copy(&delegation
->stateid
, stateid
);
242 delegation
->type
= type
;
243 delegation
->pagemod_limit
= pagemod_limit
;
244 oldcred
= delegation
->cred
;
245 delegation
->cred
= get_cred(cred
);
246 clear_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
247 if (test_and_clear_bit(NFS_DELEGATION_REVOKED
,
249 atomic_long_inc(&nfs_active_delegations
);
250 spin_unlock(&delegation
->lock
);
253 trace_nfs4_reclaim_delegation(inode
, type
);
256 nfs_inode_set_delegation(inode
, cred
, type
, stateid
,
261 static int nfs_do_return_delegation(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
263 const struct cred
*cred
;
266 if (!test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
267 spin_lock(&delegation
->lock
);
268 cred
= get_cred(delegation
->cred
);
269 spin_unlock(&delegation
->lock
);
270 res
= nfs4_proc_delegreturn(inode
, cred
,
271 &delegation
->stateid
,
278 static struct inode
*nfs_delegation_grab_inode(struct nfs_delegation
*delegation
)
280 struct inode
*inode
= NULL
;
282 spin_lock(&delegation
->lock
);
283 if (delegation
->inode
!= NULL
)
284 inode
= igrab(delegation
->inode
);
286 set_bit(NFS_DELEGATION_INODE_FREEING
, &delegation
->flags
);
287 spin_unlock(&delegation
->lock
);
291 static struct nfs_delegation
*
292 nfs_start_delegation_return_locked(struct nfs_inode
*nfsi
)
294 struct nfs_delegation
*ret
= NULL
;
295 struct nfs_delegation
*delegation
= rcu_dereference(nfsi
->delegation
);
297 if (delegation
== NULL
)
299 spin_lock(&delegation
->lock
);
300 if (!test_and_set_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
)) {
301 clear_bit(NFS_DELEGATION_RETURN_DELAYED
, &delegation
->flags
);
302 /* Refcount matched in nfs_end_delegation_return() */
303 ret
= nfs_get_delegation(delegation
);
305 spin_unlock(&delegation
->lock
);
307 nfs_clear_verifier_delegated(&nfsi
->vfs_inode
);
312 static struct nfs_delegation
*
313 nfs_start_delegation_return(struct nfs_inode
*nfsi
)
315 struct nfs_delegation
*delegation
;
318 delegation
= nfs_start_delegation_return_locked(nfsi
);
323 static void nfs_abort_delegation_return(struct nfs_delegation
*delegation
,
324 struct nfs_client
*clp
, int err
)
327 spin_lock(&delegation
->lock
);
328 clear_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
);
329 if (err
== -EAGAIN
) {
330 set_bit(NFS_DELEGATION_RETURN_DELAYED
, &delegation
->flags
);
331 set_bit(NFS4CLNT_DELEGRETURN_DELAYED
, &clp
->cl_state
);
333 spin_unlock(&delegation
->lock
);
336 static struct nfs_delegation
*
337 nfs_detach_delegation_locked(struct nfs_inode
*nfsi
,
338 struct nfs_delegation
*delegation
,
339 struct nfs_client
*clp
)
341 struct nfs_delegation
*deleg_cur
=
342 rcu_dereference_protected(nfsi
->delegation
,
343 lockdep_is_held(&clp
->cl_lock
));
345 if (deleg_cur
== NULL
|| delegation
!= deleg_cur
)
348 spin_lock(&delegation
->lock
);
349 if (!delegation
->inode
) {
350 spin_unlock(&delegation
->lock
);
353 list_del_rcu(&delegation
->super_list
);
354 delegation
->inode
= NULL
;
355 rcu_assign_pointer(nfsi
->delegation
, NULL
);
356 spin_unlock(&delegation
->lock
);
360 static struct nfs_delegation
*nfs_detach_delegation(struct nfs_inode
*nfsi
,
361 struct nfs_delegation
*delegation
,
362 struct nfs_server
*server
)
364 struct nfs_client
*clp
= server
->nfs_client
;
366 spin_lock(&clp
->cl_lock
);
367 delegation
= nfs_detach_delegation_locked(nfsi
, delegation
, clp
);
368 spin_unlock(&clp
->cl_lock
);
372 static struct nfs_delegation
*
373 nfs_inode_detach_delegation(struct inode
*inode
)
375 struct nfs_inode
*nfsi
= NFS_I(inode
);
376 struct nfs_server
*server
= NFS_SERVER(inode
);
377 struct nfs_delegation
*delegation
;
380 delegation
= rcu_dereference(nfsi
->delegation
);
381 if (delegation
!= NULL
)
382 delegation
= nfs_detach_delegation(nfsi
, delegation
, server
);
388 nfs_update_delegation_cred(struct nfs_delegation
*delegation
,
389 const struct cred
*cred
)
391 const struct cred
*old
;
393 if (cred_fscmp(delegation
->cred
, cred
) != 0) {
394 old
= xchg(&delegation
->cred
, get_cred(cred
));
400 nfs_update_inplace_delegation(struct nfs_delegation
*delegation
,
401 const struct nfs_delegation
*update
)
403 if (nfs4_stateid_is_newer(&update
->stateid
, &delegation
->stateid
)) {
404 delegation
->stateid
.seqid
= update
->stateid
.seqid
;
406 delegation
->type
= update
->type
;
407 delegation
->pagemod_limit
= update
->pagemod_limit
;
408 if (test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
409 delegation
->change_attr
= update
->change_attr
;
410 nfs_update_delegation_cred(delegation
, update
->cred
);
411 /* smp_mb__before_atomic() is implicit due to xchg() */
412 clear_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
);
413 atomic_long_inc(&nfs_active_delegations
);
419 * nfs_inode_set_delegation - set up a delegation on an inode
420 * @inode: inode to which delegation applies
421 * @cred: cred to use for subsequent delegation processing
422 * @type: delegation type
423 * @stateid: delegation stateid
424 * @pagemod_limit: write delegation "space_limit"
426 * Returns zero on success, or a negative errno value.
428 int nfs_inode_set_delegation(struct inode
*inode
, const struct cred
*cred
,
430 const nfs4_stateid
*stateid
,
431 unsigned long pagemod_limit
)
433 struct nfs_server
*server
= NFS_SERVER(inode
);
434 struct nfs_client
*clp
= server
->nfs_client
;
435 struct nfs_inode
*nfsi
= NFS_I(inode
);
436 struct nfs_delegation
*delegation
, *old_delegation
;
437 struct nfs_delegation
*freeme
= NULL
;
440 delegation
= kmalloc(sizeof(*delegation
), GFP_KERNEL_ACCOUNT
);
441 if (delegation
== NULL
)
443 nfs4_stateid_copy(&delegation
->stateid
, stateid
);
444 refcount_set(&delegation
->refcount
, 1);
445 delegation
->type
= type
;
446 delegation
->pagemod_limit
= pagemod_limit
;
447 delegation
->change_attr
= inode_peek_iversion_raw(inode
);
448 delegation
->cred
= get_cred(cred
);
449 delegation
->inode
= inode
;
450 delegation
->flags
= 1<<NFS_DELEGATION_REFERENCED
;
451 delegation
->test_gen
= 0;
452 spin_lock_init(&delegation
->lock
);
454 spin_lock(&clp
->cl_lock
);
455 old_delegation
= rcu_dereference_protected(nfsi
->delegation
,
456 lockdep_is_held(&clp
->cl_lock
));
457 if (old_delegation
== NULL
)
459 /* Is this an update of the existing delegation? */
460 if (nfs4_stateid_match_other(&old_delegation
->stateid
,
461 &delegation
->stateid
)) {
462 spin_lock(&old_delegation
->lock
);
463 nfs_update_inplace_delegation(old_delegation
,
465 spin_unlock(&old_delegation
->lock
);
468 if (!test_bit(NFS_DELEGATION_REVOKED
, &old_delegation
->flags
)) {
470 * Deal with broken servers that hand out two
471 * delegations for the same file.
472 * Allow for upgrades to a WRITE delegation, but
475 dfprintk(FILE, "%s: server %s handed out "
476 "a duplicate delegation!\n",
477 __func__
, clp
->cl_hostname
);
478 if (delegation
->type
== old_delegation
->type
||
479 !(delegation
->type
& FMODE_WRITE
)) {
484 if (test_and_set_bit(NFS_DELEGATION_RETURNING
,
485 &old_delegation
->flags
))
488 freeme
= nfs_detach_delegation_locked(nfsi
, old_delegation
, clp
);
493 * If we didn't revalidate the change attribute before setting
494 * the delegation, then pre-emptively ask for a full attribute
495 * cache revalidation.
497 spin_lock(&inode
->i_lock
);
498 if (NFS_I(inode
)->cache_validity
& NFS_INO_INVALID_CHANGE
)
499 nfs_set_cache_invalid(inode
,
500 NFS_INO_INVALID_ATIME
| NFS_INO_INVALID_CTIME
|
501 NFS_INO_INVALID_MTIME
| NFS_INO_INVALID_SIZE
|
502 NFS_INO_INVALID_BLOCKS
| NFS_INO_INVALID_NLINK
|
503 NFS_INO_INVALID_OTHER
| NFS_INO_INVALID_DATA
|
504 NFS_INO_INVALID_ACCESS
| NFS_INO_INVALID_ACL
|
505 NFS_INO_INVALID_XATTR
);
506 spin_unlock(&inode
->i_lock
);
508 list_add_tail_rcu(&delegation
->super_list
, &server
->delegations
);
509 rcu_assign_pointer(nfsi
->delegation
, delegation
);
512 atomic_long_inc(&nfs_active_delegations
);
514 trace_nfs4_set_delegation(inode
, type
);
516 spin_unlock(&clp
->cl_lock
);
517 if (delegation
!= NULL
)
518 __nfs_free_delegation(delegation
);
519 if (freeme
!= NULL
) {
520 nfs_do_return_delegation(inode
, freeme
, 0);
521 nfs_free_delegation(freeme
);
527 * Basic procedure for returning a delegation to the server
529 static int nfs_end_delegation_return(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
531 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
532 unsigned int mode
= O_WRONLY
| O_RDWR
;
535 if (delegation
== NULL
)
540 /* Recall of any remaining application leases */
541 err
= break_lease(inode
, mode
);
544 if (test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
))
546 err
= nfs_delegation_claim_opens(inode
, &delegation
->stateid
,
548 if (!issync
|| err
!= -EAGAIN
)
551 * Guard against state recovery
553 err
= nfs4_wait_clnt_recover(clp
);
557 nfs_abort_delegation_return(delegation
, clp
, err
);
561 err
= nfs_do_return_delegation(inode
, delegation
, issync
);
563 /* Refcount matched in nfs_start_delegation_return_locked() */
564 nfs_put_delegation(delegation
);
568 static bool nfs_delegation_need_return(struct nfs_delegation
*delegation
)
572 if (test_and_clear_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
))
574 else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
)) {
577 spin_lock(&delegation
->lock
);
578 inode
= delegation
->inode
;
579 if (inode
&& list_empty(&NFS_I(inode
)->open_files
))
581 spin_unlock(&delegation
->lock
);
584 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
);
585 if (test_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
) ||
586 test_bit(NFS_DELEGATION_RETURN_DELAYED
, &delegation
->flags
) ||
587 test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
))
593 static int nfs_server_return_marked_delegations(struct nfs_server
*server
,
594 void __always_unused
*data
)
596 struct nfs_delegation
*delegation
;
597 struct nfs_delegation
*prev
;
599 struct inode
*place_holder
= NULL
;
600 struct nfs_delegation
*place_holder_deleg
= NULL
;
605 * To avoid quadratic looping we hold a reference
606 * to an inode place_holder. Each time we restart, we
607 * list delegation in the server from the delegations
609 * prev is an RCU-protected pointer to a delegation which
610 * wasn't marked for return and might be a good choice for
611 * the next place_holder.
617 delegation
= rcu_dereference(NFS_I(place_holder
)->delegation
);
618 if (!delegation
|| delegation
!= place_holder_deleg
)
619 delegation
= list_entry_rcu(server
->delegations
.next
,
620 struct nfs_delegation
, super_list
);
621 list_for_each_entry_from_rcu(delegation
, &server
->delegations
, super_list
) {
622 struct inode
*to_put
= NULL
;
624 if (test_bit(NFS_DELEGATION_INODE_FREEING
, &delegation
->flags
))
626 if (!nfs_delegation_need_return(delegation
)) {
627 if (nfs4_is_valid_delegation(delegation
, 0))
633 struct inode
*tmp
= nfs_delegation_grab_inode(prev
);
635 to_put
= place_holder
;
637 place_holder_deleg
= prev
;
641 inode
= nfs_delegation_grab_inode(delegation
);
647 delegation
= nfs_start_delegation_return_locked(NFS_I(inode
));
652 err
= nfs_end_delegation_return(inode
, delegation
, 0);
657 set_bit(NFS4CLNT_DELEGRETURN
, &server
->nfs_client
->cl_state
);
666 static bool nfs_server_clear_delayed_delegations(struct nfs_server
*server
)
668 struct nfs_delegation
*d
;
671 list_for_each_entry_rcu (d
, &server
->delegations
, super_list
) {
672 if (!test_bit(NFS_DELEGATION_RETURN_DELAYED
, &d
->flags
))
674 nfs_mark_return_delegation(server
, d
);
675 clear_bit(NFS_DELEGATION_RETURN_DELAYED
, &d
->flags
);
681 static bool nfs_client_clear_delayed_delegations(struct nfs_client
*clp
)
683 struct nfs_server
*server
;
686 if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED
, &clp
->cl_state
))
689 list_for_each_entry_rcu (server
, &clp
->cl_superblocks
, client_link
) {
690 if (nfs_server_clear_delayed_delegations(server
))
699 * nfs_client_return_marked_delegations - return previously marked delegations
700 * @clp: nfs_client to process
702 * Note that this function is designed to be called by the state
703 * manager thread. For this reason, it cannot flush the dirty data,
704 * since that could deadlock in case of a state recovery error.
706 * Returns zero on success, or a negative errno value.
708 int nfs_client_return_marked_delegations(struct nfs_client
*clp
)
710 int err
= nfs_client_for_each_server(
711 clp
, nfs_server_return_marked_delegations
, NULL
);
714 /* If a return was delayed, sleep to prevent hard looping */
715 if (nfs_client_clear_delayed_delegations(clp
))
721 * nfs_inode_evict_delegation - return delegation, don't reclaim opens
722 * @inode: inode to process
724 * Does not protect against delegation reclaims, therefore really only safe
725 * to be called from nfs4_clear_inode(). Guaranteed to always free
726 * the delegation structure.
728 void nfs_inode_evict_delegation(struct inode
*inode
)
730 struct nfs_delegation
*delegation
;
732 delegation
= nfs_inode_detach_delegation(inode
);
733 if (delegation
!= NULL
) {
734 set_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
);
735 set_bit(NFS_DELEGATION_INODE_FREEING
, &delegation
->flags
);
736 nfs_do_return_delegation(inode
, delegation
, 1);
737 nfs_free_delegation(delegation
);
742 * nfs4_inode_return_delegation - synchronously return a delegation
743 * @inode: inode to process
745 * This routine will always flush any dirty data to disk on the
746 * assumption that if we need to return the delegation, then
747 * we should stop caching.
749 * Returns zero on success, or a negative errno value.
751 int nfs4_inode_return_delegation(struct inode
*inode
)
753 struct nfs_inode
*nfsi
= NFS_I(inode
);
754 struct nfs_delegation
*delegation
;
756 delegation
= nfs_start_delegation_return(nfsi
);
757 if (delegation
!= NULL
) {
758 /* Synchronous recall of any application leases */
759 break_lease(inode
, O_WRONLY
| O_RDWR
);
760 if (S_ISREG(inode
->i_mode
))
762 return nfs_end_delegation_return(inode
, delegation
, 1);
768 * nfs4_inode_return_delegation_on_close - asynchronously return a delegation
769 * @inode: inode to process
771 * This routine is called on file close in order to determine if the
772 * inode delegation needs to be returned immediately.
774 void nfs4_inode_return_delegation_on_close(struct inode
*inode
)
776 struct nfs_delegation
*delegation
;
777 struct nfs_delegation
*ret
= NULL
;
782 delegation
= nfs4_get_valid_delegation(inode
);
785 if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
) ||
786 atomic_long_read(&nfs_active_delegations
) >= nfs_delegation_watermark
) {
787 spin_lock(&delegation
->lock
);
788 if (delegation
->inode
&&
789 list_empty(&NFS_I(inode
)->open_files
) &&
790 !test_and_set_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
)) {
791 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
);
792 /* Refcount matched in nfs_end_delegation_return() */
793 ret
= nfs_get_delegation(delegation
);
795 spin_unlock(&delegation
->lock
);
797 nfs_clear_verifier_delegated(inode
);
801 nfs_end_delegation_return(inode
, ret
, 0);
805 * nfs4_inode_make_writeable
806 * @inode: pointer to inode
808 * Make the inode writeable by returning the delegation if necessary
810 * Returns zero on success, or a negative errno value.
812 int nfs4_inode_make_writeable(struct inode
*inode
)
814 struct nfs_delegation
*delegation
;
817 delegation
= nfs4_get_valid_delegation(inode
);
818 if (delegation
== NULL
||
819 (nfs4_has_session(NFS_SERVER(inode
)->nfs_client
) &&
820 (delegation
->type
& FMODE_WRITE
))) {
825 return nfs4_inode_return_delegation(inode
);
828 static void nfs_mark_return_if_closed_delegation(struct nfs_server
*server
,
829 struct nfs_delegation
*delegation
)
831 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
);
832 set_bit(NFS4CLNT_DELEGRETURN
, &server
->nfs_client
->cl_state
);
835 static bool nfs_server_mark_return_all_delegations(struct nfs_server
*server
)
837 struct nfs_delegation
*delegation
;
840 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
841 nfs_mark_return_delegation(server
, delegation
);
847 static void nfs_client_mark_return_all_delegations(struct nfs_client
*clp
)
849 struct nfs_server
*server
;
852 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
853 nfs_server_mark_return_all_delegations(server
);
857 static void nfs_delegation_run_state_manager(struct nfs_client
*clp
)
859 if (test_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
))
860 nfs4_schedule_state_manager(clp
);
864 * nfs_expire_all_delegations
865 * @clp: client to process
868 void nfs_expire_all_delegations(struct nfs_client
*clp
)
870 nfs_client_mark_return_all_delegations(clp
);
871 nfs_delegation_run_state_manager(clp
);
875 * nfs_server_return_all_delegations - return delegations for one superblock
876 * @server: pointer to nfs_server to process
879 void nfs_server_return_all_delegations(struct nfs_server
*server
)
881 struct nfs_client
*clp
= server
->nfs_client
;
888 need_wait
= nfs_server_mark_return_all_delegations(server
);
892 nfs4_schedule_state_manager(clp
);
893 nfs4_wait_clnt_recover(clp
);
897 static void nfs_mark_return_unused_delegation_types(struct nfs_server
*server
,
900 struct nfs_delegation
*delegation
;
902 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
903 if ((delegation
->type
== (FMODE_READ
|FMODE_WRITE
)) && !(flags
& FMODE_WRITE
))
905 if (delegation
->type
& flags
)
906 nfs_mark_return_if_closed_delegation(server
, delegation
);
910 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client
*clp
,
913 struct nfs_server
*server
;
916 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
917 nfs_mark_return_unused_delegation_types(server
, flags
);
921 static void nfs_revoke_delegation(struct inode
*inode
,
922 const nfs4_stateid
*stateid
)
924 struct nfs_delegation
*delegation
;
929 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
930 if (delegation
== NULL
)
932 if (stateid
== NULL
) {
933 nfs4_stateid_copy(&tmp
, &delegation
->stateid
);
936 if (!nfs4_stateid_match_other(stateid
, &delegation
->stateid
))
938 spin_lock(&delegation
->lock
);
939 if (stateid
->seqid
) {
940 if (nfs4_stateid_is_newer(&delegation
->stateid
, stateid
)) {
941 spin_unlock(&delegation
->lock
);
944 delegation
->stateid
.seqid
= stateid
->seqid
;
946 spin_unlock(&delegation
->lock
);
948 nfs_mark_delegation_revoked(delegation
);
953 nfs_inode_find_state_and_recover(inode
, stateid
);
956 void nfs_remove_bad_delegation(struct inode
*inode
,
957 const nfs4_stateid
*stateid
)
959 nfs_revoke_delegation(inode
, stateid
);
961 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation
);
963 void nfs_delegation_mark_returned(struct inode
*inode
,
964 const nfs4_stateid
*stateid
)
966 struct nfs_delegation
*delegation
;
972 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
976 spin_lock(&delegation
->lock
);
977 if (!nfs4_stateid_match_other(stateid
, &delegation
->stateid
))
978 goto out_spin_unlock
;
979 if (stateid
->seqid
) {
980 /* If delegation->stateid is newer, dont mark as returned */
981 if (nfs4_stateid_is_newer(&delegation
->stateid
, stateid
))
982 goto out_clear_returning
;
983 if (delegation
->stateid
.seqid
!= stateid
->seqid
)
984 delegation
->stateid
.seqid
= stateid
->seqid
;
987 nfs_mark_delegation_revoked(delegation
);
990 clear_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
);
992 spin_unlock(&delegation
->lock
);
996 nfs_inode_find_state_and_recover(inode
, stateid
);
1000 * nfs_expire_unused_delegation_types
1001 * @clp: client to process
1002 * @flags: delegation types to expire
1005 void nfs_expire_unused_delegation_types(struct nfs_client
*clp
, fmode_t flags
)
1007 nfs_client_mark_return_unused_delegation_types(clp
, flags
);
1008 nfs_delegation_run_state_manager(clp
);
1011 static void nfs_mark_return_unreferenced_delegations(struct nfs_server
*server
)
1013 struct nfs_delegation
*delegation
;
1015 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1016 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
))
1018 nfs_mark_return_if_closed_delegation(server
, delegation
);
1023 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
1024 * @clp: nfs_client to process
1027 void nfs_expire_unreferenced_delegations(struct nfs_client
*clp
)
1029 struct nfs_server
*server
;
1032 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1033 nfs_mark_return_unreferenced_delegations(server
);
1036 nfs_delegation_run_state_manager(clp
);
1040 * nfs_async_inode_return_delegation - asynchronously return a delegation
1041 * @inode: inode to process
1042 * @stateid: state ID information
1044 * Returns zero on success, or a negative errno value.
1046 int nfs_async_inode_return_delegation(struct inode
*inode
,
1047 const nfs4_stateid
*stateid
)
1049 struct nfs_server
*server
= NFS_SERVER(inode
);
1050 struct nfs_client
*clp
= server
->nfs_client
;
1051 struct nfs_delegation
*delegation
;
1054 delegation
= nfs4_get_valid_delegation(inode
);
1055 if (delegation
== NULL
)
1057 if (stateid
!= NULL
&&
1058 !clp
->cl_mvops
->match_stateid(&delegation
->stateid
, stateid
))
1060 nfs_mark_return_delegation(server
, delegation
);
1063 /* If there are any application leases or delegations, recall them */
1064 break_lease(inode
, O_WRONLY
| O_RDWR
| O_NONBLOCK
);
1066 nfs_delegation_run_state_manager(clp
);
1073 static struct inode
*
1074 nfs_delegation_find_inode_server(struct nfs_server
*server
,
1075 const struct nfs_fh
*fhandle
)
1077 struct nfs_delegation
*delegation
;
1078 struct super_block
*freeme
= NULL
;
1079 struct inode
*res
= NULL
;
1081 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1082 spin_lock(&delegation
->lock
);
1083 if (delegation
->inode
!= NULL
&&
1084 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
) &&
1085 nfs_compare_fh(fhandle
, &NFS_I(delegation
->inode
)->fh
) == 0) {
1086 if (nfs_sb_active(server
->super
)) {
1087 freeme
= server
->super
;
1088 res
= igrab(delegation
->inode
);
1090 spin_unlock(&delegation
->lock
);
1095 nfs_sb_deactive(freeme
);
1098 return ERR_PTR(-EAGAIN
);
1100 spin_unlock(&delegation
->lock
);
1102 return ERR_PTR(-ENOENT
);
1106 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
1107 * @clp: client state handle
1108 * @fhandle: filehandle from a delegation recall
1110 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
1113 struct inode
*nfs_delegation_find_inode(struct nfs_client
*clp
,
1114 const struct nfs_fh
*fhandle
)
1116 struct nfs_server
*server
;
1120 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
1121 res
= nfs_delegation_find_inode_server(server
, fhandle
);
1122 if (res
!= ERR_PTR(-ENOENT
)) {
1128 return ERR_PTR(-ENOENT
);
1131 static void nfs_delegation_mark_reclaim_server(struct nfs_server
*server
)
1133 struct nfs_delegation
*delegation
;
1135 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1137 * If the delegation may have been admin revoked, then we
1138 * cannot reclaim it.
1140 if (test_bit(NFS_DELEGATION_TEST_EXPIRED
, &delegation
->flags
))
1142 set_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
1147 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
1148 * @clp: nfs_client to process
1151 void nfs_delegation_mark_reclaim(struct nfs_client
*clp
)
1153 struct nfs_server
*server
;
1156 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1157 nfs_delegation_mark_reclaim_server(server
);
1161 static int nfs_server_reap_unclaimed_delegations(struct nfs_server
*server
,
1162 void __always_unused
*data
)
1164 struct nfs_delegation
*delegation
;
1165 struct inode
*inode
;
1169 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1170 if (test_bit(NFS_DELEGATION_INODE_FREEING
,
1171 &delegation
->flags
) ||
1172 test_bit(NFS_DELEGATION_RETURNING
,
1173 &delegation
->flags
) ||
1174 test_bit(NFS_DELEGATION_NEED_RECLAIM
,
1175 &delegation
->flags
) == 0)
1177 inode
= nfs_delegation_grab_inode(delegation
);
1179 goto restart_locked
;
1180 delegation
= nfs_start_delegation_return_locked(NFS_I(inode
));
1182 if (delegation
!= NULL
) {
1183 if (nfs_detach_delegation(NFS_I(inode
), delegation
,
1185 nfs_free_delegation(delegation
);
1186 /* Match nfs_start_delegation_return_locked */
1187 nfs_put_delegation(delegation
);
1198 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
1199 * @clp: nfs_client to process
1202 void nfs_delegation_reap_unclaimed(struct nfs_client
*clp
)
1204 nfs_client_for_each_server(clp
, nfs_server_reap_unclaimed_delegations
,
1208 static inline bool nfs4_server_rebooted(const struct nfs_client
*clp
)
1210 return (clp
->cl_state
& (BIT(NFS4CLNT_CHECK_LEASE
) |
1211 BIT(NFS4CLNT_LEASE_EXPIRED
) |
1212 BIT(NFS4CLNT_SESSION_RESET
))) != 0;
1215 static void nfs_mark_test_expired_delegation(struct nfs_server
*server
,
1216 struct nfs_delegation
*delegation
)
1218 if (delegation
->stateid
.type
== NFS4_INVALID_STATEID_TYPE
)
1220 clear_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
1221 set_bit(NFS_DELEGATION_TEST_EXPIRED
, &delegation
->flags
);
1222 set_bit(NFS4CLNT_DELEGATION_EXPIRED
, &server
->nfs_client
->cl_state
);
1225 static void nfs_inode_mark_test_expired_delegation(struct nfs_server
*server
,
1226 struct inode
*inode
)
1228 struct nfs_delegation
*delegation
;
1231 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1233 nfs_mark_test_expired_delegation(server
, delegation
);
1238 static void nfs_delegation_mark_test_expired_server(struct nfs_server
*server
)
1240 struct nfs_delegation
*delegation
;
1242 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
)
1243 nfs_mark_test_expired_delegation(server
, delegation
);
1247 * nfs_mark_test_expired_all_delegations - mark all delegations for testing
1248 * @clp: nfs_client to process
1250 * Iterates through all the delegations associated with this server and
1251 * marks them as needing to be checked for validity.
1253 void nfs_mark_test_expired_all_delegations(struct nfs_client
*clp
)
1255 struct nfs_server
*server
;
1258 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1259 nfs_delegation_mark_test_expired_server(server
);
1264 * nfs_test_expired_all_delegations - test all delegations for a client
1265 * @clp: nfs_client to process
1267 * Helper for handling "recallable state revoked" status from server.
1269 void nfs_test_expired_all_delegations(struct nfs_client
*clp
)
1271 nfs_mark_test_expired_all_delegations(clp
);
1272 nfs4_schedule_state_manager(clp
);
1276 nfs_delegation_test_free_expired(struct inode
*inode
,
1277 nfs4_stateid
*stateid
,
1278 const struct cred
*cred
)
1280 struct nfs_server
*server
= NFS_SERVER(inode
);
1281 const struct nfs4_minor_version_ops
*ops
= server
->nfs_client
->cl_mvops
;
1286 status
= ops
->test_and_free_expired(server
, stateid
, cred
);
1287 if (status
== -NFS4ERR_EXPIRED
|| status
== -NFS4ERR_BAD_STATEID
)
1288 nfs_remove_bad_delegation(inode
, stateid
);
1291 static int nfs_server_reap_expired_delegations(struct nfs_server
*server
,
1292 void __always_unused
*data
)
1294 struct nfs_delegation
*delegation
;
1295 struct inode
*inode
;
1296 const struct cred
*cred
;
1297 nfs4_stateid stateid
;
1298 unsigned long gen
= ++server
->delegation_gen
;
1303 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1304 if (test_bit(NFS_DELEGATION_INODE_FREEING
,
1305 &delegation
->flags
) ||
1306 test_bit(NFS_DELEGATION_RETURNING
,
1307 &delegation
->flags
) ||
1308 test_bit(NFS_DELEGATION_TEST_EXPIRED
,
1309 &delegation
->flags
) == 0 ||
1310 delegation
->test_gen
== gen
)
1312 inode
= nfs_delegation_grab_inode(delegation
);
1314 goto restart_locked
;
1315 spin_lock(&delegation
->lock
);
1316 cred
= get_cred_rcu(delegation
->cred
);
1317 nfs4_stateid_copy(&stateid
, &delegation
->stateid
);
1318 spin_unlock(&delegation
->lock
);
1319 delegation
->test_gen
= gen
;
1320 clear_bit(NFS_DELEGATION_TEST_EXPIRED
, &delegation
->flags
);
1322 nfs_delegation_test_free_expired(inode
, &stateid
, cred
);
1324 if (!nfs4_server_rebooted(server
->nfs_client
)) {
1329 nfs_inode_mark_test_expired_delegation(server
,inode
);
1338 * nfs_reap_expired_delegations - reap expired delegations
1339 * @clp: nfs_client to process
1341 * Iterates through all the delegations associated with this server and
1342 * checks if they have may have been revoked. This function is usually
1343 * expected to be called in cases where the server may have lost its
1346 void nfs_reap_expired_delegations(struct nfs_client
*clp
)
1348 nfs_client_for_each_server(clp
, nfs_server_reap_expired_delegations
,
1352 void nfs_inode_find_delegation_state_and_recover(struct inode
*inode
,
1353 const nfs4_stateid
*stateid
)
1355 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
1356 struct nfs_delegation
*delegation
;
1360 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1362 nfs4_stateid_match_or_older(&delegation
->stateid
, stateid
) &&
1363 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
1364 nfs_mark_test_expired_delegation(NFS_SERVER(inode
), delegation
);
1369 nfs4_schedule_state_manager(clp
);
1373 * nfs_delegations_present - check for existence of delegations
1374 * @clp: client state handle
1376 * Returns one if there are any nfs_delegation structures attached
1377 * to this nfs_client.
1379 int nfs_delegations_present(struct nfs_client
*clp
)
1381 struct nfs_server
*server
;
1385 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1386 if (!list_empty(&server
->delegations
)) {
1395 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid
1396 * @dst: stateid to refresh
1397 * @inode: inode to check
1399 * Returns "true" and updates "dst->seqid" * if inode had a delegation
1400 * that matches our delegation stateid. Otherwise "false" is returned.
1402 bool nfs4_refresh_delegation_stateid(nfs4_stateid
*dst
, struct inode
*inode
)
1404 struct nfs_delegation
*delegation
;
1410 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1411 if (delegation
!= NULL
&&
1412 nfs4_stateid_match_other(dst
, &delegation
->stateid
) &&
1413 nfs4_stateid_is_newer(&delegation
->stateid
, dst
) &&
1414 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
1415 dst
->seqid
= delegation
->stateid
.seqid
;
1424 * nfs4_copy_delegation_stateid - Copy inode's state ID information
1425 * @inode: inode to check
1426 * @flags: delegation type requirement
1427 * @dst: stateid data structure to fill in
1428 * @cred: optional argument to retrieve credential
1430 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1431 * otherwise "false" is returned.
1433 bool nfs4_copy_delegation_stateid(struct inode
*inode
, fmode_t flags
,
1434 nfs4_stateid
*dst
, const struct cred
**cred
)
1436 struct nfs_inode
*nfsi
= NFS_I(inode
);
1437 struct nfs_delegation
*delegation
;
1440 flags
&= FMODE_READ
|FMODE_WRITE
;
1442 delegation
= rcu_dereference(nfsi
->delegation
);
1445 spin_lock(&delegation
->lock
);
1446 ret
= nfs4_is_valid_delegation(delegation
, flags
);
1448 nfs4_stateid_copy(dst
, &delegation
->stateid
);
1449 nfs_mark_delegation_referenced(delegation
);
1451 *cred
= get_cred(delegation
->cred
);
1453 spin_unlock(&delegation
->lock
);
1460 * nfs4_delegation_flush_on_close - Check if we must flush file on close
1461 * @inode: inode to check
1463 * This function checks the number of outstanding writes to the file
1464 * against the delegation 'space_limit' field to see if
1465 * the spec requires us to flush the file on close.
1467 bool nfs4_delegation_flush_on_close(const struct inode
*inode
)
1469 struct nfs_inode
*nfsi
= NFS_I(inode
);
1470 struct nfs_delegation
*delegation
;
1474 delegation
= rcu_dereference(nfsi
->delegation
);
1475 if (delegation
== NULL
|| !(delegation
->type
& FMODE_WRITE
))
1477 if (atomic_long_read(&nfsi
->nrequests
) < delegation
->pagemod_limit
)
1484 module_param_named(delegation_watermark
, nfs_delegation_watermark
, uint
, 0644);