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
= inode
->i_flctx
;
150 struct list_head
*list
;
156 list
= &flctx
->flc_posix
;
157 spin_lock(&flctx
->flc_lock
);
159 list_for_each_entry(fl
, list
, 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
,
232 const nfs4_stateid
*stateid
,
233 unsigned long pagemod_limit
)
235 struct nfs_delegation
*delegation
;
236 const struct cred
*oldcred
= NULL
;
239 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
240 if (delegation
!= NULL
) {
241 spin_lock(&delegation
->lock
);
242 if (nfs4_is_valid_delegation(delegation
, 0)) {
243 nfs4_stateid_copy(&delegation
->stateid
, stateid
);
244 delegation
->type
= type
;
245 delegation
->pagemod_limit
= pagemod_limit
;
246 oldcred
= delegation
->cred
;
247 delegation
->cred
= get_cred(cred
);
248 clear_bit(NFS_DELEGATION_NEED_RECLAIM
,
250 spin_unlock(&delegation
->lock
);
253 trace_nfs4_reclaim_delegation(inode
, type
);
256 /* We appear to have raced with a delegation return. */
257 spin_unlock(&delegation
->lock
);
260 nfs_inode_set_delegation(inode
, cred
, type
, stateid
, pagemod_limit
);
263 static int nfs_do_return_delegation(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
265 const struct cred
*cred
;
268 if (!test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
269 spin_lock(&delegation
->lock
);
270 cred
= get_cred(delegation
->cred
);
271 spin_unlock(&delegation
->lock
);
272 res
= nfs4_proc_delegreturn(inode
, cred
,
273 &delegation
->stateid
,
280 static struct inode
*nfs_delegation_grab_inode(struct nfs_delegation
*delegation
)
282 struct inode
*inode
= NULL
;
284 spin_lock(&delegation
->lock
);
285 if (delegation
->inode
!= NULL
)
286 inode
= igrab(delegation
->inode
);
288 set_bit(NFS_DELEGATION_INODE_FREEING
, &delegation
->flags
);
289 spin_unlock(&delegation
->lock
);
293 static struct nfs_delegation
*
294 nfs_start_delegation_return_locked(struct nfs_inode
*nfsi
)
296 struct nfs_delegation
*ret
= NULL
;
297 struct nfs_delegation
*delegation
= rcu_dereference(nfsi
->delegation
);
299 if (delegation
== NULL
)
301 spin_lock(&delegation
->lock
);
302 if (!test_and_set_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
)) {
303 clear_bit(NFS_DELEGATION_RETURN_DELAYED
, &delegation
->flags
);
304 /* Refcount matched in nfs_end_delegation_return() */
305 ret
= nfs_get_delegation(delegation
);
307 spin_unlock(&delegation
->lock
);
309 nfs_clear_verifier_delegated(&nfsi
->vfs_inode
);
314 static struct nfs_delegation
*
315 nfs_start_delegation_return(struct nfs_inode
*nfsi
)
317 struct nfs_delegation
*delegation
;
320 delegation
= nfs_start_delegation_return_locked(nfsi
);
325 static void nfs_abort_delegation_return(struct nfs_delegation
*delegation
,
326 struct nfs_client
*clp
, int err
)
329 spin_lock(&delegation
->lock
);
330 clear_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
);
331 if (err
== -EAGAIN
) {
332 set_bit(NFS_DELEGATION_RETURN_DELAYED
, &delegation
->flags
);
333 set_bit(NFS4CLNT_DELEGRETURN_DELAYED
, &clp
->cl_state
);
335 spin_unlock(&delegation
->lock
);
338 static struct nfs_delegation
*
339 nfs_detach_delegation_locked(struct nfs_inode
*nfsi
,
340 struct nfs_delegation
*delegation
,
341 struct nfs_client
*clp
)
343 struct nfs_delegation
*deleg_cur
=
344 rcu_dereference_protected(nfsi
->delegation
,
345 lockdep_is_held(&clp
->cl_lock
));
347 if (deleg_cur
== NULL
|| delegation
!= deleg_cur
)
350 spin_lock(&delegation
->lock
);
351 if (!delegation
->inode
) {
352 spin_unlock(&delegation
->lock
);
355 list_del_rcu(&delegation
->super_list
);
356 delegation
->inode
= NULL
;
357 rcu_assign_pointer(nfsi
->delegation
, NULL
);
358 spin_unlock(&delegation
->lock
);
362 static struct nfs_delegation
*nfs_detach_delegation(struct nfs_inode
*nfsi
,
363 struct nfs_delegation
*delegation
,
364 struct nfs_server
*server
)
366 struct nfs_client
*clp
= server
->nfs_client
;
368 spin_lock(&clp
->cl_lock
);
369 delegation
= nfs_detach_delegation_locked(nfsi
, delegation
, clp
);
370 spin_unlock(&clp
->cl_lock
);
374 static struct nfs_delegation
*
375 nfs_inode_detach_delegation(struct inode
*inode
)
377 struct nfs_inode
*nfsi
= NFS_I(inode
);
378 struct nfs_server
*server
= NFS_SERVER(inode
);
379 struct nfs_delegation
*delegation
;
382 delegation
= rcu_dereference(nfsi
->delegation
);
383 if (delegation
!= NULL
)
384 delegation
= nfs_detach_delegation(nfsi
, delegation
, server
);
390 nfs_update_delegation_cred(struct nfs_delegation
*delegation
,
391 const struct cred
*cred
)
393 const struct cred
*old
;
395 if (cred_fscmp(delegation
->cred
, cred
) != 0) {
396 old
= xchg(&delegation
->cred
, get_cred(cred
));
402 nfs_update_inplace_delegation(struct nfs_delegation
*delegation
,
403 const struct nfs_delegation
*update
)
405 if (nfs4_stateid_is_newer(&update
->stateid
, &delegation
->stateid
)) {
406 delegation
->stateid
.seqid
= update
->stateid
.seqid
;
408 delegation
->type
= update
->type
;
409 delegation
->pagemod_limit
= update
->pagemod_limit
;
410 if (test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
411 delegation
->change_attr
= update
->change_attr
;
412 nfs_update_delegation_cred(delegation
, update
->cred
);
413 /* smp_mb__before_atomic() is implicit due to xchg() */
414 clear_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
);
415 atomic_long_inc(&nfs_active_delegations
);
421 * nfs_inode_set_delegation - set up a delegation on an inode
422 * @inode: inode to which delegation applies
423 * @cred: cred to use for subsequent delegation processing
424 * @type: delegation type
425 * @stateid: delegation stateid
426 * @pagemod_limit: write delegation "space_limit"
428 * Returns zero on success, or a negative errno value.
430 int nfs_inode_set_delegation(struct inode
*inode
, const struct cred
*cred
,
432 const nfs4_stateid
*stateid
,
433 unsigned long pagemod_limit
)
435 struct nfs_server
*server
= NFS_SERVER(inode
);
436 struct nfs_client
*clp
= server
->nfs_client
;
437 struct nfs_inode
*nfsi
= NFS_I(inode
);
438 struct nfs_delegation
*delegation
, *old_delegation
;
439 struct nfs_delegation
*freeme
= NULL
;
442 delegation
= kmalloc(sizeof(*delegation
), GFP_NOFS
);
443 if (delegation
== NULL
)
445 nfs4_stateid_copy(&delegation
->stateid
, stateid
);
446 refcount_set(&delegation
->refcount
, 1);
447 delegation
->type
= type
;
448 delegation
->pagemod_limit
= pagemod_limit
;
449 delegation
->change_attr
= inode_peek_iversion_raw(inode
);
450 delegation
->cred
= get_cred(cred
);
451 delegation
->inode
= inode
;
452 delegation
->flags
= 1<<NFS_DELEGATION_REFERENCED
;
453 spin_lock_init(&delegation
->lock
);
455 spin_lock(&clp
->cl_lock
);
456 old_delegation
= rcu_dereference_protected(nfsi
->delegation
,
457 lockdep_is_held(&clp
->cl_lock
));
458 if (old_delegation
== NULL
)
460 /* Is this an update of the existing delegation? */
461 if (nfs4_stateid_match_other(&old_delegation
->stateid
,
462 &delegation
->stateid
)) {
463 spin_lock(&old_delegation
->lock
);
464 nfs_update_inplace_delegation(old_delegation
,
466 spin_unlock(&old_delegation
->lock
);
469 if (!test_bit(NFS_DELEGATION_REVOKED
, &old_delegation
->flags
)) {
471 * Deal with broken servers that hand out two
472 * delegations for the same file.
473 * Allow for upgrades to a WRITE delegation, but
476 dfprintk(FILE, "%s: server %s handed out "
477 "a duplicate delegation!\n",
478 __func__
, clp
->cl_hostname
);
479 if (delegation
->type
== old_delegation
->type
||
480 !(delegation
->type
& FMODE_WRITE
)) {
485 if (test_and_set_bit(NFS_DELEGATION_RETURNING
,
486 &old_delegation
->flags
))
489 freeme
= nfs_detach_delegation_locked(nfsi
, old_delegation
, clp
);
494 * If we didn't revalidate the change attribute before setting
495 * the delegation, then pre-emptively ask for a full attribute
496 * cache revalidation.
498 spin_lock(&inode
->i_lock
);
499 if (NFS_I(inode
)->cache_validity
& NFS_INO_INVALID_CHANGE
)
500 nfs_set_cache_invalid(inode
,
501 NFS_INO_INVALID_ATIME
| NFS_INO_INVALID_CTIME
|
502 NFS_INO_INVALID_MTIME
| NFS_INO_INVALID_SIZE
|
503 NFS_INO_INVALID_BLOCKS
| NFS_INO_INVALID_NLINK
|
504 NFS_INO_INVALID_OTHER
| NFS_INO_INVALID_DATA
|
505 NFS_INO_INVALID_ACCESS
| NFS_INO_INVALID_ACL
|
506 NFS_INO_INVALID_XATTR
);
507 spin_unlock(&inode
->i_lock
);
509 list_add_tail_rcu(&delegation
->super_list
, &server
->delegations
);
510 rcu_assign_pointer(nfsi
->delegation
, delegation
);
513 atomic_long_inc(&nfs_active_delegations
);
515 trace_nfs4_set_delegation(inode
, type
);
517 spin_unlock(&clp
->cl_lock
);
518 if (delegation
!= NULL
)
519 __nfs_free_delegation(delegation
);
520 if (freeme
!= NULL
) {
521 nfs_do_return_delegation(inode
, freeme
, 0);
522 nfs_free_delegation(freeme
);
528 * Basic procedure for returning a delegation to the server
530 static int nfs_end_delegation_return(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
532 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
535 if (delegation
== NULL
)
538 if (test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
))
540 err
= nfs_delegation_claim_opens(inode
, &delegation
->stateid
,
542 if (!issync
|| err
!= -EAGAIN
)
545 * Guard against state recovery
547 err
= nfs4_wait_clnt_recover(clp
);
551 nfs_abort_delegation_return(delegation
, clp
, err
);
555 err
= nfs_do_return_delegation(inode
, delegation
, issync
);
557 /* Refcount matched in nfs_start_delegation_return_locked() */
558 nfs_put_delegation(delegation
);
562 static bool nfs_delegation_need_return(struct nfs_delegation
*delegation
)
566 if (test_and_clear_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
))
568 else if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
)) {
571 spin_lock(&delegation
->lock
);
572 inode
= delegation
->inode
;
573 if (inode
&& list_empty(&NFS_I(inode
)->open_files
))
575 spin_unlock(&delegation
->lock
);
578 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
);
579 if (test_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
) ||
580 test_bit(NFS_DELEGATION_RETURN_DELAYED
, &delegation
->flags
) ||
581 test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
))
587 static int nfs_server_return_marked_delegations(struct nfs_server
*server
,
588 void __always_unused
*data
)
590 struct nfs_delegation
*delegation
;
591 struct nfs_delegation
*prev
;
593 struct inode
*place_holder
= NULL
;
594 struct nfs_delegation
*place_holder_deleg
= NULL
;
599 * To avoid quadratic looping we hold a reference
600 * to an inode place_holder. Each time we restart, we
601 * list delegation in the server from the delegations
603 * prev is an RCU-protected pointer to a delegation which
604 * wasn't marked for return and might be a good choice for
605 * the next place_holder.
611 delegation
= rcu_dereference(NFS_I(place_holder
)->delegation
);
612 if (!delegation
|| delegation
!= place_holder_deleg
)
613 delegation
= list_entry_rcu(server
->delegations
.next
,
614 struct nfs_delegation
, super_list
);
615 list_for_each_entry_from_rcu(delegation
, &server
->delegations
, super_list
) {
616 struct inode
*to_put
= NULL
;
618 if (test_bit(NFS_DELEGATION_INODE_FREEING
, &delegation
->flags
))
620 if (!nfs_delegation_need_return(delegation
)) {
621 if (nfs4_is_valid_delegation(delegation
, 0))
627 struct inode
*tmp
= nfs_delegation_grab_inode(prev
);
629 to_put
= place_holder
;
631 place_holder_deleg
= prev
;
635 inode
= nfs_delegation_grab_inode(delegation
);
641 delegation
= nfs_start_delegation_return_locked(NFS_I(inode
));
646 err
= nfs_end_delegation_return(inode
, delegation
, 0);
651 set_bit(NFS4CLNT_DELEGRETURN
, &server
->nfs_client
->cl_state
);
660 static bool nfs_server_clear_delayed_delegations(struct nfs_server
*server
)
662 struct nfs_delegation
*d
;
665 list_for_each_entry_rcu (d
, &server
->delegations
, super_list
) {
666 if (!test_bit(NFS_DELEGATION_RETURN_DELAYED
, &d
->flags
))
668 nfs_mark_return_delegation(server
, d
);
669 clear_bit(NFS_DELEGATION_RETURN_DELAYED
, &d
->flags
);
675 static bool nfs_client_clear_delayed_delegations(struct nfs_client
*clp
)
677 struct nfs_server
*server
;
680 if (!test_and_clear_bit(NFS4CLNT_DELEGRETURN_DELAYED
, &clp
->cl_state
))
683 list_for_each_entry_rcu (server
, &clp
->cl_superblocks
, client_link
) {
684 if (nfs_server_clear_delayed_delegations(server
))
693 * nfs_client_return_marked_delegations - return previously marked delegations
694 * @clp: nfs_client to process
696 * Note that this function is designed to be called by the state
697 * manager thread. For this reason, it cannot flush the dirty data,
698 * since that could deadlock in case of a state recovery error.
700 * Returns zero on success, or a negative errno value.
702 int nfs_client_return_marked_delegations(struct nfs_client
*clp
)
704 int err
= nfs_client_for_each_server(
705 clp
, nfs_server_return_marked_delegations
, NULL
);
708 /* If a return was delayed, sleep to prevent hard looping */
709 if (nfs_client_clear_delayed_delegations(clp
))
715 * nfs_inode_evict_delegation - return delegation, don't reclaim opens
716 * @inode: inode to process
718 * Does not protect against delegation reclaims, therefore really only safe
719 * to be called from nfs4_clear_inode(). Guaranteed to always free
720 * the delegation structure.
722 void nfs_inode_evict_delegation(struct inode
*inode
)
724 struct nfs_delegation
*delegation
;
726 delegation
= nfs_inode_detach_delegation(inode
);
727 if (delegation
!= NULL
) {
728 set_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
);
729 set_bit(NFS_DELEGATION_INODE_FREEING
, &delegation
->flags
);
730 nfs_do_return_delegation(inode
, delegation
, 1);
731 nfs_free_delegation(delegation
);
736 * nfs4_inode_return_delegation - synchronously return a delegation
737 * @inode: inode to process
739 * This routine will always flush any dirty data to disk on the
740 * assumption that if we need to return the delegation, then
741 * we should stop caching.
743 * Returns zero on success, or a negative errno value.
745 int nfs4_inode_return_delegation(struct inode
*inode
)
747 struct nfs_inode
*nfsi
= NFS_I(inode
);
748 struct nfs_delegation
*delegation
;
752 delegation
= nfs_start_delegation_return(nfsi
);
753 if (delegation
!= NULL
)
754 err
= nfs_end_delegation_return(inode
, delegation
, 1);
759 * nfs4_inode_return_delegation_on_close - asynchronously return a delegation
760 * @inode: inode to process
762 * This routine is called on file close in order to determine if the
763 * inode delegation needs to be returned immediately.
765 void nfs4_inode_return_delegation_on_close(struct inode
*inode
)
767 struct nfs_delegation
*delegation
;
768 struct nfs_delegation
*ret
= NULL
;
773 delegation
= nfs4_get_valid_delegation(inode
);
776 if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
) ||
777 atomic_long_read(&nfs_active_delegations
) >= nfs_delegation_watermark
) {
778 spin_lock(&delegation
->lock
);
779 if (delegation
->inode
&&
780 list_empty(&NFS_I(inode
)->open_files
) &&
781 !test_and_set_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
)) {
782 clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
);
783 /* Refcount matched in nfs_end_delegation_return() */
784 ret
= nfs_get_delegation(delegation
);
786 spin_unlock(&delegation
->lock
);
788 nfs_clear_verifier_delegated(inode
);
792 nfs_end_delegation_return(inode
, ret
, 0);
796 * nfs4_inode_make_writeable
797 * @inode: pointer to inode
799 * Make the inode writeable by returning the delegation if necessary
801 * Returns zero on success, or a negative errno value.
803 int nfs4_inode_make_writeable(struct inode
*inode
)
805 struct nfs_delegation
*delegation
;
808 delegation
= nfs4_get_valid_delegation(inode
);
809 if (delegation
== NULL
||
810 (nfs4_has_session(NFS_SERVER(inode
)->nfs_client
) &&
811 (delegation
->type
& FMODE_WRITE
))) {
816 return nfs4_inode_return_delegation(inode
);
819 static void nfs_mark_return_if_closed_delegation(struct nfs_server
*server
,
820 struct nfs_delegation
*delegation
)
822 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED
, &delegation
->flags
);
823 set_bit(NFS4CLNT_DELEGRETURN
, &server
->nfs_client
->cl_state
);
826 static bool nfs_server_mark_return_all_delegations(struct nfs_server
*server
)
828 struct nfs_delegation
*delegation
;
831 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
832 nfs_mark_return_delegation(server
, delegation
);
838 static void nfs_client_mark_return_all_delegations(struct nfs_client
*clp
)
840 struct nfs_server
*server
;
843 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
844 nfs_server_mark_return_all_delegations(server
);
848 static void nfs_delegation_run_state_manager(struct nfs_client
*clp
)
850 if (test_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
))
851 nfs4_schedule_state_manager(clp
);
855 * nfs_expire_all_delegations
856 * @clp: client to process
859 void nfs_expire_all_delegations(struct nfs_client
*clp
)
861 nfs_client_mark_return_all_delegations(clp
);
862 nfs_delegation_run_state_manager(clp
);
866 * nfs_server_return_all_delegations - return delegations for one superblock
867 * @server: pointer to nfs_server to process
870 void nfs_server_return_all_delegations(struct nfs_server
*server
)
872 struct nfs_client
*clp
= server
->nfs_client
;
879 need_wait
= nfs_server_mark_return_all_delegations(server
);
883 nfs4_schedule_state_manager(clp
);
884 nfs4_wait_clnt_recover(clp
);
888 static void nfs_mark_return_unused_delegation_types(struct nfs_server
*server
,
891 struct nfs_delegation
*delegation
;
893 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
894 if ((delegation
->type
== (FMODE_READ
|FMODE_WRITE
)) && !(flags
& FMODE_WRITE
))
896 if (delegation
->type
& flags
)
897 nfs_mark_return_if_closed_delegation(server
, delegation
);
901 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client
*clp
,
904 struct nfs_server
*server
;
907 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
908 nfs_mark_return_unused_delegation_types(server
, flags
);
912 static void nfs_revoke_delegation(struct inode
*inode
,
913 const nfs4_stateid
*stateid
)
915 struct nfs_delegation
*delegation
;
920 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
921 if (delegation
== NULL
)
923 if (stateid
== NULL
) {
924 nfs4_stateid_copy(&tmp
, &delegation
->stateid
);
927 if (!nfs4_stateid_match_other(stateid
, &delegation
->stateid
))
929 spin_lock(&delegation
->lock
);
930 if (stateid
->seqid
) {
931 if (nfs4_stateid_is_newer(&delegation
->stateid
, stateid
)) {
932 spin_unlock(&delegation
->lock
);
935 delegation
->stateid
.seqid
= stateid
->seqid
;
937 spin_unlock(&delegation
->lock
);
939 nfs_mark_delegation_revoked(delegation
);
944 nfs_inode_find_state_and_recover(inode
, stateid
);
947 void nfs_remove_bad_delegation(struct inode
*inode
,
948 const nfs4_stateid
*stateid
)
950 nfs_revoke_delegation(inode
, stateid
);
952 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation
);
954 void nfs_delegation_mark_returned(struct inode
*inode
,
955 const nfs4_stateid
*stateid
)
957 struct nfs_delegation
*delegation
;
963 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
967 spin_lock(&delegation
->lock
);
968 if (!nfs4_stateid_match_other(stateid
, &delegation
->stateid
))
969 goto out_spin_unlock
;
970 if (stateid
->seqid
) {
971 /* If delegation->stateid is newer, dont mark as returned */
972 if (nfs4_stateid_is_newer(&delegation
->stateid
, stateid
))
973 goto out_clear_returning
;
974 if (delegation
->stateid
.seqid
!= stateid
->seqid
)
975 delegation
->stateid
.seqid
= stateid
->seqid
;
978 nfs_mark_delegation_revoked(delegation
);
981 clear_bit(NFS_DELEGATION_RETURNING
, &delegation
->flags
);
983 spin_unlock(&delegation
->lock
);
987 nfs_inode_find_state_and_recover(inode
, stateid
);
991 * nfs_expire_unused_delegation_types
992 * @clp: client to process
993 * @flags: delegation types to expire
996 void nfs_expire_unused_delegation_types(struct nfs_client
*clp
, fmode_t flags
)
998 nfs_client_mark_return_unused_delegation_types(clp
, flags
);
999 nfs_delegation_run_state_manager(clp
);
1002 static void nfs_mark_return_unreferenced_delegations(struct nfs_server
*server
)
1004 struct nfs_delegation
*delegation
;
1006 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1007 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
))
1009 nfs_mark_return_if_closed_delegation(server
, delegation
);
1014 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
1015 * @clp: nfs_client to process
1018 void nfs_expire_unreferenced_delegations(struct nfs_client
*clp
)
1020 struct nfs_server
*server
;
1023 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1024 nfs_mark_return_unreferenced_delegations(server
);
1027 nfs_delegation_run_state_manager(clp
);
1031 * nfs_async_inode_return_delegation - asynchronously return a delegation
1032 * @inode: inode to process
1033 * @stateid: state ID information
1035 * Returns zero on success, or a negative errno value.
1037 int nfs_async_inode_return_delegation(struct inode
*inode
,
1038 const nfs4_stateid
*stateid
)
1040 struct nfs_server
*server
= NFS_SERVER(inode
);
1041 struct nfs_client
*clp
= server
->nfs_client
;
1042 struct nfs_delegation
*delegation
;
1045 delegation
= nfs4_get_valid_delegation(inode
);
1046 if (delegation
== NULL
)
1048 if (stateid
!= NULL
&&
1049 !clp
->cl_mvops
->match_stateid(&delegation
->stateid
, stateid
))
1051 nfs_mark_return_delegation(server
, delegation
);
1054 nfs_delegation_run_state_manager(clp
);
1061 static struct inode
*
1062 nfs_delegation_find_inode_server(struct nfs_server
*server
,
1063 const struct nfs_fh
*fhandle
)
1065 struct nfs_delegation
*delegation
;
1066 struct super_block
*freeme
= NULL
;
1067 struct inode
*res
= NULL
;
1069 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1070 spin_lock(&delegation
->lock
);
1071 if (delegation
->inode
!= NULL
&&
1072 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
) &&
1073 nfs_compare_fh(fhandle
, &NFS_I(delegation
->inode
)->fh
) == 0) {
1074 if (nfs_sb_active(server
->super
)) {
1075 freeme
= server
->super
;
1076 res
= igrab(delegation
->inode
);
1078 spin_unlock(&delegation
->lock
);
1083 nfs_sb_deactive(freeme
);
1086 return ERR_PTR(-EAGAIN
);
1088 spin_unlock(&delegation
->lock
);
1090 return ERR_PTR(-ENOENT
);
1094 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
1095 * @clp: client state handle
1096 * @fhandle: filehandle from a delegation recall
1098 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
1101 struct inode
*nfs_delegation_find_inode(struct nfs_client
*clp
,
1102 const struct nfs_fh
*fhandle
)
1104 struct nfs_server
*server
;
1108 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
) {
1109 res
= nfs_delegation_find_inode_server(server
, fhandle
);
1110 if (res
!= ERR_PTR(-ENOENT
)) {
1116 return ERR_PTR(-ENOENT
);
1119 static void nfs_delegation_mark_reclaim_server(struct nfs_server
*server
)
1121 struct nfs_delegation
*delegation
;
1123 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1125 * If the delegation may have been admin revoked, then we
1126 * cannot reclaim it.
1128 if (test_bit(NFS_DELEGATION_TEST_EXPIRED
, &delegation
->flags
))
1130 set_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
1135 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
1136 * @clp: nfs_client to process
1139 void nfs_delegation_mark_reclaim(struct nfs_client
*clp
)
1141 struct nfs_server
*server
;
1144 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1145 nfs_delegation_mark_reclaim_server(server
);
1149 static int nfs_server_reap_unclaimed_delegations(struct nfs_server
*server
,
1150 void __always_unused
*data
)
1152 struct nfs_delegation
*delegation
;
1153 struct inode
*inode
;
1157 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1158 if (test_bit(NFS_DELEGATION_INODE_FREEING
,
1159 &delegation
->flags
) ||
1160 test_bit(NFS_DELEGATION_RETURNING
,
1161 &delegation
->flags
) ||
1162 test_bit(NFS_DELEGATION_NEED_RECLAIM
,
1163 &delegation
->flags
) == 0)
1165 inode
= nfs_delegation_grab_inode(delegation
);
1167 goto restart_locked
;
1168 delegation
= nfs_start_delegation_return_locked(NFS_I(inode
));
1170 if (delegation
!= NULL
) {
1171 if (nfs_detach_delegation(NFS_I(inode
), delegation
,
1173 nfs_free_delegation(delegation
);
1174 /* Match nfs_start_delegation_return_locked */
1175 nfs_put_delegation(delegation
);
1186 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
1187 * @clp: nfs_client to process
1190 void nfs_delegation_reap_unclaimed(struct nfs_client
*clp
)
1192 nfs_client_for_each_server(clp
, nfs_server_reap_unclaimed_delegations
,
1196 static inline bool nfs4_server_rebooted(const struct nfs_client
*clp
)
1198 return (clp
->cl_state
& (BIT(NFS4CLNT_CHECK_LEASE
) |
1199 BIT(NFS4CLNT_LEASE_EXPIRED
) |
1200 BIT(NFS4CLNT_SESSION_RESET
))) != 0;
1203 static void nfs_mark_test_expired_delegation(struct nfs_server
*server
,
1204 struct nfs_delegation
*delegation
)
1206 if (delegation
->stateid
.type
== NFS4_INVALID_STATEID_TYPE
)
1208 clear_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
1209 set_bit(NFS_DELEGATION_TEST_EXPIRED
, &delegation
->flags
);
1210 set_bit(NFS4CLNT_DELEGATION_EXPIRED
, &server
->nfs_client
->cl_state
);
1213 static void nfs_inode_mark_test_expired_delegation(struct nfs_server
*server
,
1214 struct inode
*inode
)
1216 struct nfs_delegation
*delegation
;
1219 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1221 nfs_mark_test_expired_delegation(server
, delegation
);
1226 static void nfs_delegation_mark_test_expired_server(struct nfs_server
*server
)
1228 struct nfs_delegation
*delegation
;
1230 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
)
1231 nfs_mark_test_expired_delegation(server
, delegation
);
1235 * nfs_mark_test_expired_all_delegations - mark all delegations for testing
1236 * @clp: nfs_client to process
1238 * Iterates through all the delegations associated with this server and
1239 * marks them as needing to be checked for validity.
1241 void nfs_mark_test_expired_all_delegations(struct nfs_client
*clp
)
1243 struct nfs_server
*server
;
1246 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1247 nfs_delegation_mark_test_expired_server(server
);
1252 * nfs_test_expired_all_delegations - test all delegations for a client
1253 * @clp: nfs_client to process
1255 * Helper for handling "recallable state revoked" status from server.
1257 void nfs_test_expired_all_delegations(struct nfs_client
*clp
)
1259 nfs_mark_test_expired_all_delegations(clp
);
1260 nfs4_schedule_state_manager(clp
);
1264 nfs_delegation_test_free_expired(struct inode
*inode
,
1265 nfs4_stateid
*stateid
,
1266 const struct cred
*cred
)
1268 struct nfs_server
*server
= NFS_SERVER(inode
);
1269 const struct nfs4_minor_version_ops
*ops
= server
->nfs_client
->cl_mvops
;
1274 status
= ops
->test_and_free_expired(server
, stateid
, cred
);
1275 if (status
== -NFS4ERR_EXPIRED
|| status
== -NFS4ERR_BAD_STATEID
)
1276 nfs_remove_bad_delegation(inode
, stateid
);
1279 static int nfs_server_reap_expired_delegations(struct nfs_server
*server
,
1280 void __always_unused
*data
)
1282 struct nfs_delegation
*delegation
;
1283 struct inode
*inode
;
1284 const struct cred
*cred
;
1285 nfs4_stateid stateid
;
1289 list_for_each_entry_rcu(delegation
, &server
->delegations
, super_list
) {
1290 if (test_bit(NFS_DELEGATION_INODE_FREEING
,
1291 &delegation
->flags
) ||
1292 test_bit(NFS_DELEGATION_RETURNING
,
1293 &delegation
->flags
) ||
1294 test_bit(NFS_DELEGATION_TEST_EXPIRED
,
1295 &delegation
->flags
) == 0)
1297 inode
= nfs_delegation_grab_inode(delegation
);
1299 goto restart_locked
;
1300 spin_lock(&delegation
->lock
);
1301 cred
= get_cred_rcu(delegation
->cred
);
1302 nfs4_stateid_copy(&stateid
, &delegation
->stateid
);
1303 spin_unlock(&delegation
->lock
);
1304 clear_bit(NFS_DELEGATION_TEST_EXPIRED
, &delegation
->flags
);
1306 nfs_delegation_test_free_expired(inode
, &stateid
, cred
);
1308 if (!nfs4_server_rebooted(server
->nfs_client
)) {
1313 nfs_inode_mark_test_expired_delegation(server
,inode
);
1322 * nfs_reap_expired_delegations - reap expired delegations
1323 * @clp: nfs_client to process
1325 * Iterates through all the delegations associated with this server and
1326 * checks if they have may have been revoked. This function is usually
1327 * expected to be called in cases where the server may have lost its
1330 void nfs_reap_expired_delegations(struct nfs_client
*clp
)
1332 nfs_client_for_each_server(clp
, nfs_server_reap_expired_delegations
,
1336 void nfs_inode_find_delegation_state_and_recover(struct inode
*inode
,
1337 const nfs4_stateid
*stateid
)
1339 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
1340 struct nfs_delegation
*delegation
;
1344 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1346 nfs4_stateid_match_or_older(&delegation
->stateid
, stateid
) &&
1347 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
1348 nfs_mark_test_expired_delegation(NFS_SERVER(inode
), delegation
);
1353 nfs4_schedule_state_manager(clp
);
1357 * nfs_delegations_present - check for existence of delegations
1358 * @clp: client state handle
1360 * Returns one if there are any nfs_delegation structures attached
1361 * to this nfs_client.
1363 int nfs_delegations_present(struct nfs_client
*clp
)
1365 struct nfs_server
*server
;
1369 list_for_each_entry_rcu(server
, &clp
->cl_superblocks
, client_link
)
1370 if (!list_empty(&server
->delegations
)) {
1379 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid
1380 * @dst: stateid to refresh
1381 * @inode: inode to check
1383 * Returns "true" and updates "dst->seqid" * if inode had a delegation
1384 * that matches our delegation stateid. Otherwise "false" is returned.
1386 bool nfs4_refresh_delegation_stateid(nfs4_stateid
*dst
, struct inode
*inode
)
1388 struct nfs_delegation
*delegation
;
1394 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
1395 if (delegation
!= NULL
&&
1396 nfs4_stateid_match_other(dst
, &delegation
->stateid
) &&
1397 nfs4_stateid_is_newer(&delegation
->stateid
, dst
) &&
1398 !test_bit(NFS_DELEGATION_REVOKED
, &delegation
->flags
)) {
1399 dst
->seqid
= delegation
->stateid
.seqid
;
1408 * nfs4_copy_delegation_stateid - Copy inode's state ID information
1409 * @inode: inode to check
1410 * @flags: delegation type requirement
1411 * @dst: stateid data structure to fill in
1412 * @cred: optional argument to retrieve credential
1414 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1415 * otherwise "false" is returned.
1417 bool nfs4_copy_delegation_stateid(struct inode
*inode
, fmode_t flags
,
1418 nfs4_stateid
*dst
, const struct cred
**cred
)
1420 struct nfs_inode
*nfsi
= NFS_I(inode
);
1421 struct nfs_delegation
*delegation
;
1424 flags
&= FMODE_READ
|FMODE_WRITE
;
1426 delegation
= rcu_dereference(nfsi
->delegation
);
1429 spin_lock(&delegation
->lock
);
1430 ret
= nfs4_is_valid_delegation(delegation
, flags
);
1432 nfs4_stateid_copy(dst
, &delegation
->stateid
);
1433 nfs_mark_delegation_referenced(delegation
);
1435 *cred
= get_cred(delegation
->cred
);
1437 spin_unlock(&delegation
->lock
);
1444 * nfs4_delegation_flush_on_close - Check if we must flush file on close
1445 * @inode: inode to check
1447 * This function checks the number of outstanding writes to the file
1448 * against the delegation 'space_limit' field to see if
1449 * the spec requires us to flush the file on close.
1451 bool nfs4_delegation_flush_on_close(const struct inode
*inode
)
1453 struct nfs_inode
*nfsi
= NFS_I(inode
);
1454 struct nfs_delegation
*delegation
;
1458 delegation
= rcu_dereference(nfsi
->delegation
);
1459 if (delegation
== NULL
|| !(delegation
->type
& FMODE_WRITE
))
1461 if (atomic_long_read(&nfsi
->nrequests
) < delegation
->pagemod_limit
)
1468 module_param_named(delegation_watermark
, nfs_delegation_watermark
, uint
, 0644);