2 * linux/fs/nfs/delegation.c
4 * Copyright (C) 2004 Trond Myklebust
6 * NFS file delegation management
9 #include <linux/completion.h>
10 #include <linux/kthread.h>
11 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/slab.h>
14 #include <linux/spinlock.h>
16 #include <linux/nfs4.h>
17 #include <linux/nfs_fs.h>
18 #include <linux/nfs_xdr.h>
21 #include "delegation.h"
23 #include "nfs4trace.h"
25 static void nfs_free_delegation(struct nfs_delegation *delegation)
27 if (delegation->cred) {
28 put_rpccred(delegation->cred);
29 delegation->cred = NULL;
31 kfree_rcu(delegation, rcu);
35 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
36 * @delegation: delegation to process
39 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
41 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
45 nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
47 struct nfs_delegation *delegation;
50 flags &= FMODE_READ|FMODE_WRITE;
52 delegation = rcu_dereference(NFS_I(inode)->delegation);
53 if (delegation != NULL && (delegation->type & flags) == flags &&
54 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
56 nfs_mark_delegation_referenced(delegation);
63 * nfs_have_delegation - check if inode has a delegation, mark it
64 * NFS_DELEGATION_REFERENCED if there is one.
65 * @inode: inode to check
66 * @flags: delegation types to check for
68 * Returns one if inode has the indicated delegation, otherwise zero.
70 int nfs4_have_delegation(struct inode *inode, fmode_t flags)
72 return nfs4_do_check_delegation(inode, flags, true);
76 * nfs4_check_delegation - check if inode has a delegation, do not mark
77 * NFS_DELEGATION_REFERENCED if it has one.
79 int nfs4_check_delegation(struct inode *inode, fmode_t flags)
81 return nfs4_do_check_delegation(inode, flags, false);
84 static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
86 struct inode *inode = state->inode;
90 if (inode->i_flock == NULL)
93 /* Protect inode->i_flock using the i_lock */
94 spin_lock(&inode->i_lock);
95 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
96 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
98 if (nfs_file_open_context(fl->fl_file) != ctx)
100 spin_unlock(&inode->i_lock);
101 status = nfs4_lock_delegation_recall(fl, state, stateid);
104 spin_lock(&inode->i_lock);
106 spin_unlock(&inode->i_lock);
111 static int nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *stateid)
113 struct nfs_inode *nfsi = NFS_I(inode);
114 struct nfs_open_context *ctx;
115 struct nfs4_state_owner *sp;
116 struct nfs4_state *state;
121 spin_lock(&inode->i_lock);
122 list_for_each_entry(ctx, &nfsi->open_files, list) {
126 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
128 if (!nfs4_stateid_match(&state->stateid, stateid))
130 get_nfs_open_context(ctx);
131 spin_unlock(&inode->i_lock);
133 /* Block nfs4_proc_unlck */
134 mutex_lock(&sp->so_delegreturn_mutex);
135 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
136 err = nfs4_open_delegation_recall(ctx, state, stateid);
138 err = nfs_delegation_claim_locks(ctx, state, stateid);
139 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
141 mutex_unlock(&sp->so_delegreturn_mutex);
142 put_nfs_open_context(ctx);
147 spin_unlock(&inode->i_lock);
152 * nfs_inode_reclaim_delegation - process a delegation reclaim request
153 * @inode: inode to process
154 * @cred: credential to use for request
155 * @res: new delegation state from server
158 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
159 struct nfs_openres *res)
161 struct nfs_delegation *delegation;
162 struct rpc_cred *oldcred = NULL;
165 delegation = rcu_dereference(NFS_I(inode)->delegation);
166 if (delegation != NULL) {
167 spin_lock(&delegation->lock);
168 if (delegation->inode != NULL) {
169 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
170 delegation->type = res->delegation_type;
171 delegation->maxsize = res->maxsize;
172 oldcred = delegation->cred;
173 delegation->cred = get_rpccred(cred);
174 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
176 NFS_I(inode)->delegation_state = delegation->type;
177 spin_unlock(&delegation->lock);
178 put_rpccred(oldcred);
180 trace_nfs4_reclaim_delegation(inode, res->delegation_type);
182 /* We appear to have raced with a delegation return. */
183 spin_unlock(&delegation->lock);
185 nfs_inode_set_delegation(inode, cred, res);
192 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
196 res = nfs4_proc_delegreturn(inode, delegation->cred, &delegation->stateid, issync);
197 nfs_free_delegation(delegation);
201 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
203 struct inode *inode = NULL;
205 spin_lock(&delegation->lock);
206 if (delegation->inode != NULL)
207 inode = igrab(delegation->inode);
208 spin_unlock(&delegation->lock);
212 static struct nfs_delegation *
213 nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
215 struct nfs_delegation *ret = NULL;
216 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
218 if (delegation == NULL)
220 spin_lock(&delegation->lock);
221 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
223 spin_unlock(&delegation->lock);
228 static struct nfs_delegation *
229 nfs_start_delegation_return(struct nfs_inode *nfsi)
231 struct nfs_delegation *delegation;
234 delegation = nfs_start_delegation_return_locked(nfsi);
240 nfs_abort_delegation_return(struct nfs_delegation *delegation,
241 struct nfs_client *clp)
244 spin_lock(&delegation->lock);
245 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
246 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
247 spin_unlock(&delegation->lock);
248 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
251 static struct nfs_delegation *
252 nfs_detach_delegation_locked(struct nfs_inode *nfsi,
253 struct nfs_delegation *delegation,
254 struct nfs_client *clp)
256 struct nfs_delegation *deleg_cur =
257 rcu_dereference_protected(nfsi->delegation,
258 lockdep_is_held(&clp->cl_lock));
260 if (deleg_cur == NULL || delegation != deleg_cur)
263 spin_lock(&delegation->lock);
264 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
265 list_del_rcu(&delegation->super_list);
266 delegation->inode = NULL;
267 nfsi->delegation_state = 0;
268 rcu_assign_pointer(nfsi->delegation, NULL);
269 spin_unlock(&delegation->lock);
273 static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
274 struct nfs_delegation *delegation,
275 struct nfs_server *server)
277 struct nfs_client *clp = server->nfs_client;
279 spin_lock(&clp->cl_lock);
280 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
281 spin_unlock(&clp->cl_lock);
285 static struct nfs_delegation *
286 nfs_inode_detach_delegation(struct inode *inode)
288 struct nfs_inode *nfsi = NFS_I(inode);
289 struct nfs_server *server = NFS_SERVER(inode);
290 struct nfs_delegation *delegation;
292 delegation = nfs_start_delegation_return(nfsi);
293 if (delegation == NULL)
295 return nfs_detach_delegation(nfsi, delegation, server);
299 * nfs_inode_set_delegation - set up a delegation on an inode
300 * @inode: inode to which delegation applies
301 * @cred: cred to use for subsequent delegation processing
302 * @res: new delegation state from server
304 * Returns zero on success, or a negative errno value.
306 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
308 struct nfs_server *server = NFS_SERVER(inode);
309 struct nfs_client *clp = server->nfs_client;
310 struct nfs_inode *nfsi = NFS_I(inode);
311 struct nfs_delegation *delegation, *old_delegation;
312 struct nfs_delegation *freeme = NULL;
315 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
316 if (delegation == NULL)
318 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
319 delegation->type = res->delegation_type;
320 delegation->maxsize = res->maxsize;
321 delegation->change_attr = inode->i_version;
322 delegation->cred = get_rpccred(cred);
323 delegation->inode = inode;
324 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
325 spin_lock_init(&delegation->lock);
327 spin_lock(&clp->cl_lock);
328 old_delegation = rcu_dereference_protected(nfsi->delegation,
329 lockdep_is_held(&clp->cl_lock));
330 if (old_delegation != NULL) {
331 if (nfs4_stateid_match(&delegation->stateid,
332 &old_delegation->stateid) &&
333 delegation->type == old_delegation->type) {
337 * Deal with broken servers that hand out two
338 * delegations for the same file.
339 * Allow for upgrades to a WRITE delegation, but
342 dfprintk(FILE, "%s: server %s handed out "
343 "a duplicate delegation!\n",
344 __func__, clp->cl_hostname);
345 if (delegation->type == old_delegation->type ||
346 !(delegation->type & FMODE_WRITE)) {
351 freeme = nfs_detach_delegation_locked(nfsi,
352 old_delegation, clp);
356 list_add_rcu(&delegation->super_list, &server->delegations);
357 nfsi->delegation_state = delegation->type;
358 rcu_assign_pointer(nfsi->delegation, delegation);
361 /* Ensure we revalidate the attributes and page cache! */
362 spin_lock(&inode->i_lock);
363 nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
364 spin_unlock(&inode->i_lock);
365 trace_nfs4_set_delegation(inode, res->delegation_type);
368 spin_unlock(&clp->cl_lock);
369 if (delegation != NULL)
370 nfs_free_delegation(delegation);
372 nfs_do_return_delegation(inode, freeme, 0);
377 * Basic procedure for returning a delegation to the server
379 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
381 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
382 struct nfs_inode *nfsi = NFS_I(inode);
385 if (delegation == NULL)
388 err = nfs_delegation_claim_opens(inode, &delegation->stateid);
389 if (!issync || err != -EAGAIN)
392 * Guard against state recovery
394 err = nfs4_wait_clnt_recover(clp);
398 nfs_abort_delegation_return(delegation, clp);
401 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
404 err = nfs_do_return_delegation(inode, delegation, issync);
409 static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
413 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
415 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
418 spin_lock(&delegation->lock);
419 inode = delegation->inode;
420 if (inode && list_empty(&NFS_I(inode)->open_files))
422 spin_unlock(&delegation->lock);
428 * nfs_client_return_marked_delegations - return previously marked delegations
429 * @clp: nfs_client to process
431 * Note that this function is designed to be called by the state
432 * manager thread. For this reason, it cannot flush the dirty data,
433 * since that could deadlock in case of a state recovery error.
435 * Returns zero on success, or a negative errno value.
437 int nfs_client_return_marked_delegations(struct nfs_client *clp)
439 struct nfs_delegation *delegation;
440 struct nfs_server *server;
446 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
447 list_for_each_entry_rcu(delegation, &server->delegations,
449 if (!nfs_delegation_need_return(delegation))
451 inode = nfs_delegation_grab_inode(delegation);
454 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
457 err = nfs_end_delegation_return(inode, delegation, 0);
461 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
470 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
471 * @inode: inode to process
473 * Does not protect against delegation reclaims, therefore really only safe
474 * to be called from nfs4_clear_inode().
476 void nfs_inode_return_delegation_noreclaim(struct inode *inode)
478 struct nfs_delegation *delegation;
480 delegation = nfs_inode_detach_delegation(inode);
481 if (delegation != NULL)
482 nfs_do_return_delegation(inode, delegation, 0);
486 * nfs_inode_return_delegation - synchronously return a delegation
487 * @inode: inode to process
489 * This routine will always flush any dirty data to disk on the
490 * assumption that if we need to return the delegation, then
491 * we should stop caching.
493 * Returns zero on success, or a negative errno value.
495 int nfs4_inode_return_delegation(struct inode *inode)
497 struct nfs_inode *nfsi = NFS_I(inode);
498 struct nfs_delegation *delegation;
502 delegation = nfs_start_delegation_return(nfsi);
503 if (delegation != NULL)
504 err = nfs_end_delegation_return(inode, delegation, 1);
508 static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
509 struct nfs_delegation *delegation)
511 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
512 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
515 static void nfs_mark_return_delegation(struct nfs_server *server,
516 struct nfs_delegation *delegation)
518 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
519 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
522 static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
524 struct nfs_delegation *delegation;
527 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
528 nfs_mark_return_delegation(server, delegation);
534 static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
536 struct nfs_server *server;
539 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
540 nfs_server_mark_return_all_delegations(server);
544 static void nfs_delegation_run_state_manager(struct nfs_client *clp)
546 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
547 nfs4_schedule_state_manager(clp);
551 * nfs_expire_all_delegations
552 * @clp: client to process
555 void nfs_expire_all_delegations(struct nfs_client *clp)
557 nfs_client_mark_return_all_delegations(clp);
558 nfs_delegation_run_state_manager(clp);
562 * nfs_super_return_all_delegations - return delegations for one superblock
566 void nfs_server_return_all_delegations(struct nfs_server *server)
568 struct nfs_client *clp = server->nfs_client;
575 need_wait = nfs_server_mark_return_all_delegations(server);
579 nfs4_schedule_state_manager(clp);
580 nfs4_wait_clnt_recover(clp);
584 static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
587 struct nfs_delegation *delegation;
589 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
590 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
592 if (delegation->type & flags)
593 nfs_mark_return_if_closed_delegation(server, delegation);
597 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
600 struct nfs_server *server;
603 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
604 nfs_mark_return_unused_delegation_types(server, flags);
608 void nfs_remove_bad_delegation(struct inode *inode)
610 struct nfs_delegation *delegation;
612 delegation = nfs_inode_detach_delegation(inode);
614 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
615 nfs_free_delegation(delegation);
618 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
621 * nfs_expire_unused_delegation_types
622 * @clp: client to process
623 * @flags: delegation types to expire
626 void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
628 nfs_client_mark_return_unused_delegation_types(clp, flags);
629 nfs_delegation_run_state_manager(clp);
632 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
634 struct nfs_delegation *delegation;
636 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
637 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
639 nfs_mark_return_if_closed_delegation(server, delegation);
644 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
645 * @clp: nfs_client to process
648 void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
650 struct nfs_server *server;
653 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
654 nfs_mark_return_unreferenced_delegations(server);
657 nfs_delegation_run_state_manager(clp);
661 * nfs_async_inode_return_delegation - asynchronously return a delegation
662 * @inode: inode to process
663 * @stateid: state ID information
665 * Returns zero on success, or a negative errno value.
667 int nfs_async_inode_return_delegation(struct inode *inode,
668 const nfs4_stateid *stateid)
670 struct nfs_server *server = NFS_SERVER(inode);
671 struct nfs_client *clp = server->nfs_client;
672 struct nfs_delegation *delegation;
674 filemap_flush(inode->i_mapping);
677 delegation = rcu_dereference(NFS_I(inode)->delegation);
678 if (delegation == NULL)
681 if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
683 nfs_mark_return_delegation(server, delegation);
686 nfs_delegation_run_state_manager(clp);
693 static struct inode *
694 nfs_delegation_find_inode_server(struct nfs_server *server,
695 const struct nfs_fh *fhandle)
697 struct nfs_delegation *delegation;
698 struct inode *res = NULL;
700 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
701 spin_lock(&delegation->lock);
702 if (delegation->inode != NULL &&
703 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
704 res = igrab(delegation->inode);
706 spin_unlock(&delegation->lock);
714 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
715 * @clp: client state handle
716 * @fhandle: filehandle from a delegation recall
718 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
721 struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
722 const struct nfs_fh *fhandle)
724 struct nfs_server *server;
725 struct inode *res = NULL;
728 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
729 res = nfs_delegation_find_inode_server(server, fhandle);
737 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
739 struct nfs_delegation *delegation;
741 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
742 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
746 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
747 * @clp: nfs_client to process
750 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
752 struct nfs_server *server;
755 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
756 nfs_delegation_mark_reclaim_server(server);
761 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
762 * @clp: nfs_client to process
765 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
767 struct nfs_delegation *delegation;
768 struct nfs_server *server;
773 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
774 list_for_each_entry_rcu(delegation, &server->delegations,
776 if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
777 &delegation->flags) == 0)
779 inode = nfs_delegation_grab_inode(delegation);
782 delegation = nfs_detach_delegation(NFS_I(inode),
786 if (delegation != NULL)
787 nfs_free_delegation(delegation);
796 * nfs_delegations_present - check for existence of delegations
797 * @clp: client state handle
799 * Returns one if there are any nfs_delegation structures attached
800 * to this nfs_client.
802 int nfs_delegations_present(struct nfs_client *clp)
804 struct nfs_server *server;
808 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
809 if (!list_empty(&server->delegations)) {
818 * nfs4_copy_delegation_stateid - Copy inode's state ID information
819 * @dst: stateid data structure to fill in
820 * @inode: inode to check
821 * @flags: delegation type requirement
823 * Returns "true" and fills in "dst->data" * if inode had a delegation,
824 * otherwise "false" is returned.
826 bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode,
829 struct nfs_inode *nfsi = NFS_I(inode);
830 struct nfs_delegation *delegation;
833 flags &= FMODE_READ|FMODE_WRITE;
835 delegation = rcu_dereference(nfsi->delegation);
836 ret = (delegation != NULL && (delegation->type & flags) == flags);
838 nfs4_stateid_copy(dst, &delegation->stateid);
839 nfs_mark_delegation_referenced(delegation);