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/smp_lock.h>
15 #include <linux/spinlock.h>
17 #include <linux/nfs4.h>
18 #include <linux/nfs_fs.h>
19 #include <linux/nfs_xdr.h>
22 #include "delegation.h"
25 static void nfs_do_free_delegation(struct nfs_delegation
*delegation
)
28 put_rpccred(delegation
->cred
);
32 static void nfs_free_delegation_callback(struct rcu_head
*head
)
34 struct nfs_delegation
*delegation
= container_of(head
, struct nfs_delegation
, rcu
);
36 nfs_do_free_delegation(delegation
);
39 static void nfs_free_delegation(struct nfs_delegation
*delegation
)
41 call_rcu(&delegation
->rcu
, nfs_free_delegation_callback
);
44 void nfs_mark_delegation_referenced(struct nfs_delegation
*delegation
)
46 set_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
);
49 int nfs_have_delegation(struct inode
*inode
, fmode_t flags
)
51 struct nfs_delegation
*delegation
;
54 flags
&= FMODE_READ
|FMODE_WRITE
;
56 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
57 if (delegation
!= NULL
&& (delegation
->type
& flags
) == flags
) {
58 nfs_mark_delegation_referenced(delegation
);
65 static int nfs_delegation_claim_locks(struct nfs_open_context
*ctx
, struct nfs4_state
*state
)
67 struct inode
*inode
= state
->inode
;
71 if (inode
->i_flock
== NULL
)
74 /* Protect inode->i_flock using the file locks lock */
76 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
77 if (!(fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)))
79 if (nfs_file_open_context(fl
->fl_file
) != ctx
)
82 status
= nfs4_lock_delegation_recall(state
, fl
);
92 static int nfs_delegation_claim_opens(struct inode
*inode
, const nfs4_stateid
*stateid
)
94 struct nfs_inode
*nfsi
= NFS_I(inode
);
95 struct nfs_open_context
*ctx
;
96 struct nfs4_state
*state
;
100 spin_lock(&inode
->i_lock
);
101 list_for_each_entry(ctx
, &nfsi
->open_files
, list
) {
105 if (!test_bit(NFS_DELEGATED_STATE
, &state
->flags
))
107 if (memcmp(state
->stateid
.data
, stateid
->data
, sizeof(state
->stateid
.data
)) != 0)
109 get_nfs_open_context(ctx
);
110 spin_unlock(&inode
->i_lock
);
111 err
= nfs4_open_delegation_recall(ctx
, state
, stateid
);
113 err
= nfs_delegation_claim_locks(ctx
, state
);
114 put_nfs_open_context(ctx
);
119 spin_unlock(&inode
->i_lock
);
124 * Set up a delegation on an inode
126 void nfs_inode_reclaim_delegation(struct inode
*inode
, struct rpc_cred
*cred
, struct nfs_openres
*res
)
128 struct nfs_delegation
*delegation
;
129 struct rpc_cred
*oldcred
= NULL
;
132 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
133 if (delegation
!= NULL
) {
134 spin_lock(&delegation
->lock
);
135 if (delegation
->inode
!= NULL
) {
136 memcpy(delegation
->stateid
.data
, res
->delegation
.data
,
137 sizeof(delegation
->stateid
.data
));
138 delegation
->type
= res
->delegation_type
;
139 delegation
->maxsize
= res
->maxsize
;
140 oldcred
= delegation
->cred
;
141 delegation
->cred
= get_rpccred(cred
);
142 clear_bit(NFS_DELEGATION_NEED_RECLAIM
,
144 NFS_I(inode
)->delegation_state
= delegation
->type
;
145 spin_unlock(&delegation
->lock
);
146 put_rpccred(oldcred
);
149 /* We appear to have raced with a delegation return. */
150 spin_unlock(&delegation
->lock
);
152 nfs_inode_set_delegation(inode
, cred
, res
);
159 static int nfs_do_return_delegation(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
163 res
= nfs4_proc_delegreturn(inode
, delegation
->cred
, &delegation
->stateid
, issync
);
164 nfs_free_delegation(delegation
);
168 static struct inode
*nfs_delegation_grab_inode(struct nfs_delegation
*delegation
)
170 struct inode
*inode
= NULL
;
172 spin_lock(&delegation
->lock
);
173 if (delegation
->inode
!= NULL
)
174 inode
= igrab(delegation
->inode
);
175 spin_unlock(&delegation
->lock
);
179 static struct nfs_delegation
*nfs_detach_delegation_locked(struct nfs_inode
*nfsi
,
180 const nfs4_stateid
*stateid
,
181 struct nfs_client
*clp
)
183 struct nfs_delegation
*delegation
=
184 rcu_dereference_protected(nfsi
->delegation
,
185 lockdep_is_held(&clp
->cl_lock
));
187 if (delegation
== NULL
)
189 spin_lock(&delegation
->lock
);
190 if (stateid
!= NULL
&& memcmp(delegation
->stateid
.data
, stateid
->data
,
191 sizeof(delegation
->stateid
.data
)) != 0)
193 list_del_rcu(&delegation
->super_list
);
194 delegation
->inode
= NULL
;
195 nfsi
->delegation_state
= 0;
196 rcu_assign_pointer(nfsi
->delegation
, NULL
);
197 spin_unlock(&delegation
->lock
);
200 spin_unlock(&delegation
->lock
);
206 * Set up a delegation on an inode
208 int nfs_inode_set_delegation(struct inode
*inode
, struct rpc_cred
*cred
, struct nfs_openres
*res
)
210 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
211 struct nfs_inode
*nfsi
= NFS_I(inode
);
212 struct nfs_delegation
*delegation
, *old_delegation
;
213 struct nfs_delegation
*freeme
= NULL
;
216 delegation
= kmalloc(sizeof(*delegation
), GFP_NOFS
);
217 if (delegation
== NULL
)
219 memcpy(delegation
->stateid
.data
, res
->delegation
.data
,
220 sizeof(delegation
->stateid
.data
));
221 delegation
->type
= res
->delegation_type
;
222 delegation
->maxsize
= res
->maxsize
;
223 delegation
->change_attr
= nfsi
->change_attr
;
224 delegation
->cred
= get_rpccred(cred
);
225 delegation
->inode
= inode
;
226 delegation
->flags
= 1<<NFS_DELEGATION_REFERENCED
;
227 spin_lock_init(&delegation
->lock
);
229 spin_lock(&clp
->cl_lock
);
230 old_delegation
= rcu_dereference_protected(nfsi
->delegation
,
231 lockdep_is_held(&clp
->cl_lock
));
232 if (old_delegation
!= NULL
) {
233 if (memcmp(&delegation
->stateid
, &old_delegation
->stateid
,
234 sizeof(old_delegation
->stateid
)) == 0 &&
235 delegation
->type
== old_delegation
->type
) {
239 * Deal with broken servers that hand out two
240 * delegations for the same file.
242 dfprintk(FILE, "%s: server %s handed out "
243 "a duplicate delegation!\n",
244 __func__
, clp
->cl_hostname
);
245 if (delegation
->type
<= old_delegation
->type
) {
250 freeme
= nfs_detach_delegation_locked(nfsi
, NULL
, clp
);
252 list_add_rcu(&delegation
->super_list
, &clp
->cl_delegations
);
253 nfsi
->delegation_state
= delegation
->type
;
254 rcu_assign_pointer(nfsi
->delegation
, delegation
);
257 /* Ensure we revalidate the attributes and page cache! */
258 spin_lock(&inode
->i_lock
);
259 nfsi
->cache_validity
|= NFS_INO_REVAL_FORCED
;
260 spin_unlock(&inode
->i_lock
);
263 spin_unlock(&clp
->cl_lock
);
264 if (delegation
!= NULL
)
265 nfs_free_delegation(delegation
);
267 nfs_do_return_delegation(inode
, freeme
, 0);
272 * Basic procedure for returning a delegation to the server
274 static int __nfs_inode_return_delegation(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
276 struct nfs_inode
*nfsi
= NFS_I(inode
);
280 * Guard against new delegated open/lock/unlock calls and against
283 down_write(&nfsi
->rwsem
);
284 err
= nfs_delegation_claim_opens(inode
, &delegation
->stateid
);
285 up_write(&nfsi
->rwsem
);
289 err
= nfs_do_return_delegation(inode
, delegation
, issync
);
295 * Return all delegations that have been marked for return
297 int nfs_client_return_marked_delegations(struct nfs_client
*clp
)
299 struct nfs_delegation
*delegation
;
305 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
306 if (!test_and_clear_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
))
308 inode
= nfs_delegation_grab_inode(delegation
);
311 spin_lock(&clp
->cl_lock
);
312 delegation
= nfs_detach_delegation_locked(NFS_I(inode
), NULL
, clp
);
313 spin_unlock(&clp
->cl_lock
);
315 if (delegation
!= NULL
) {
316 filemap_flush(inode
->i_mapping
);
317 err
= __nfs_inode_return_delegation(inode
, delegation
, 0);
322 set_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
);
330 * This function returns the delegation without reclaiming opens
331 * or protecting against delegation reclaims.
332 * It is therefore really only safe to be called from
335 void nfs_inode_return_delegation_noreclaim(struct inode
*inode
)
337 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
338 struct nfs_inode
*nfsi
= NFS_I(inode
);
339 struct nfs_delegation
*delegation
;
341 if (rcu_access_pointer(nfsi
->delegation
) != NULL
) {
342 spin_lock(&clp
->cl_lock
);
343 delegation
= nfs_detach_delegation_locked(nfsi
, NULL
, clp
);
344 spin_unlock(&clp
->cl_lock
);
345 if (delegation
!= NULL
)
346 nfs_do_return_delegation(inode
, delegation
, 0);
350 int nfs_inode_return_delegation(struct inode
*inode
)
352 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
353 struct nfs_inode
*nfsi
= NFS_I(inode
);
354 struct nfs_delegation
*delegation
;
357 if (rcu_access_pointer(nfsi
->delegation
) != NULL
) {
358 spin_lock(&clp
->cl_lock
);
359 delegation
= nfs_detach_delegation_locked(nfsi
, NULL
, clp
);
360 spin_unlock(&clp
->cl_lock
);
361 if (delegation
!= NULL
) {
363 err
= __nfs_inode_return_delegation(inode
, delegation
, 1);
369 static void nfs_mark_return_delegation(struct nfs_client
*clp
, struct nfs_delegation
*delegation
)
371 set_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
);
372 set_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
);
376 * Return all delegations associated to a super block
378 void nfs_super_return_all_delegations(struct super_block
*sb
)
380 struct nfs_client
*clp
= NFS_SB(sb
)->nfs_client
;
381 struct nfs_delegation
*delegation
;
386 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
387 spin_lock(&delegation
->lock
);
388 if (delegation
->inode
!= NULL
&& delegation
->inode
->i_sb
== sb
)
389 set_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
);
390 spin_unlock(&delegation
->lock
);
393 if (nfs_client_return_marked_delegations(clp
) != 0)
394 nfs4_schedule_state_manager(clp
);
398 void nfs_client_mark_return_all_delegation_types(struct nfs_client
*clp
, fmode_t flags
)
400 struct nfs_delegation
*delegation
;
403 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
404 if ((delegation
->type
== (FMODE_READ
|FMODE_WRITE
)) && !(flags
& FMODE_WRITE
))
406 if (delegation
->type
& flags
)
407 nfs_mark_return_delegation(clp
, delegation
);
412 static void nfs_client_mark_return_all_delegations(struct nfs_client
*clp
)
414 nfs_client_mark_return_all_delegation_types(clp
, FMODE_READ
|FMODE_WRITE
);
417 static void nfs_delegation_run_state_manager(struct nfs_client
*clp
)
419 if (test_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
))
420 nfs4_schedule_state_manager(clp
);
423 void nfs_expire_all_delegation_types(struct nfs_client
*clp
, fmode_t flags
)
425 nfs_client_mark_return_all_delegation_types(clp
, flags
);
426 nfs_delegation_run_state_manager(clp
);
429 void nfs_expire_all_delegations(struct nfs_client
*clp
)
431 nfs_expire_all_delegation_types(clp
, FMODE_READ
|FMODE_WRITE
);
435 * Return all delegations following an NFS4ERR_CB_PATH_DOWN error.
437 void nfs_handle_cb_pathdown(struct nfs_client
*clp
)
441 nfs_client_mark_return_all_delegations(clp
);
444 static void nfs_client_mark_return_unreferenced_delegations(struct nfs_client
*clp
)
446 struct nfs_delegation
*delegation
;
449 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
450 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
))
452 nfs_mark_return_delegation(clp
, delegation
);
457 void nfs_expire_unreferenced_delegations(struct nfs_client
*clp
)
459 nfs_client_mark_return_unreferenced_delegations(clp
);
460 nfs_delegation_run_state_manager(clp
);
464 * Asynchronous delegation recall!
466 int nfs_async_inode_return_delegation(struct inode
*inode
, const nfs4_stateid
*stateid
)
468 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
469 struct nfs_delegation
*delegation
;
472 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
474 if (!clp
->cl_mvops
->validate_stateid(delegation
, stateid
)) {
479 nfs_mark_return_delegation(clp
, delegation
);
481 nfs_delegation_run_state_manager(clp
);
486 * Retrieve the inode associated with a delegation
488 struct inode
*nfs_delegation_find_inode(struct nfs_client
*clp
, const struct nfs_fh
*fhandle
)
490 struct nfs_delegation
*delegation
;
491 struct inode
*res
= NULL
;
493 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
494 spin_lock(&delegation
->lock
);
495 if (delegation
->inode
!= NULL
&&
496 nfs_compare_fh(fhandle
, &NFS_I(delegation
->inode
)->fh
) == 0) {
497 res
= igrab(delegation
->inode
);
499 spin_unlock(&delegation
->lock
);
508 * Mark all delegations as needing to be reclaimed
510 void nfs_delegation_mark_reclaim(struct nfs_client
*clp
)
512 struct nfs_delegation
*delegation
;
514 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
)
515 set_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
520 * Reap all unclaimed delegations after reboot recovery is done
522 void nfs_delegation_reap_unclaimed(struct nfs_client
*clp
)
524 struct nfs_delegation
*delegation
;
528 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
529 if (test_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
) == 0)
531 inode
= nfs_delegation_grab_inode(delegation
);
534 spin_lock(&clp
->cl_lock
);
535 delegation
= nfs_detach_delegation_locked(NFS_I(inode
), NULL
, clp
);
536 spin_unlock(&clp
->cl_lock
);
538 if (delegation
!= NULL
)
539 nfs_free_delegation(delegation
);
546 int nfs4_copy_delegation_stateid(nfs4_stateid
*dst
, struct inode
*inode
)
548 struct nfs_inode
*nfsi
= NFS_I(inode
);
549 struct nfs_delegation
*delegation
;
553 delegation
= rcu_dereference(nfsi
->delegation
);
554 if (delegation
!= NULL
) {
555 memcpy(dst
->data
, delegation
->stateid
.data
, sizeof(dst
->data
));