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"
24 static void nfs_do_free_delegation(struct nfs_delegation
*delegation
)
27 put_rpccred(delegation
->cred
);
31 static void nfs_free_delegation_callback(struct rcu_head
*head
)
33 struct nfs_delegation
*delegation
= container_of(head
, struct nfs_delegation
, rcu
);
35 nfs_do_free_delegation(delegation
);
38 static void nfs_free_delegation(struct nfs_delegation
*delegation
)
40 call_rcu(&delegation
->rcu
, nfs_free_delegation_callback
);
43 void nfs_mark_delegation_referenced(struct nfs_delegation
*delegation
)
45 set_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
);
48 int nfs_have_delegation(struct inode
*inode
, fmode_t flags
)
50 struct nfs_delegation
*delegation
;
53 flags
&= FMODE_READ
|FMODE_WRITE
;
55 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
56 if (delegation
!= NULL
&& (delegation
->type
& flags
) == flags
) {
57 nfs_mark_delegation_referenced(delegation
);
64 static int nfs_delegation_claim_locks(struct nfs_open_context
*ctx
, struct nfs4_state
*state
)
66 struct inode
*inode
= state
->inode
;
70 if (inode
->i_flock
== NULL
)
73 /* Protect inode->i_flock using the file locks lock */
75 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
76 if (!(fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)))
78 if (nfs_file_open_context(fl
->fl_file
) != ctx
)
81 status
= nfs4_lock_delegation_recall(state
, fl
);
91 static int nfs_delegation_claim_opens(struct inode
*inode
, const nfs4_stateid
*stateid
)
93 struct nfs_inode
*nfsi
= NFS_I(inode
);
94 struct nfs_open_context
*ctx
;
95 struct nfs4_state
*state
;
99 spin_lock(&inode
->i_lock
);
100 list_for_each_entry(ctx
, &nfsi
->open_files
, list
) {
104 if (!test_bit(NFS_DELEGATED_STATE
, &state
->flags
))
106 if (memcmp(state
->stateid
.data
, stateid
->data
, sizeof(state
->stateid
.data
)) != 0)
108 get_nfs_open_context(ctx
);
109 spin_unlock(&inode
->i_lock
);
110 err
= nfs4_open_delegation_recall(ctx
, state
, stateid
);
112 err
= nfs_delegation_claim_locks(ctx
, state
);
113 put_nfs_open_context(ctx
);
118 spin_unlock(&inode
->i_lock
);
123 * Set up a delegation on an inode
125 void nfs_inode_reclaim_delegation(struct inode
*inode
, struct rpc_cred
*cred
, struct nfs_openres
*res
)
127 struct nfs_delegation
*delegation
;
128 struct rpc_cred
*oldcred
= NULL
;
131 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
132 if (delegation
!= NULL
) {
133 spin_lock(&delegation
->lock
);
134 if (delegation
->inode
!= NULL
) {
135 memcpy(delegation
->stateid
.data
, res
->delegation
.data
,
136 sizeof(delegation
->stateid
.data
));
137 delegation
->type
= res
->delegation_type
;
138 delegation
->maxsize
= res
->maxsize
;
139 oldcred
= delegation
->cred
;
140 delegation
->cred
= get_rpccred(cred
);
141 clear_bit(NFS_DELEGATION_NEED_RECLAIM
,
143 NFS_I(inode
)->delegation_state
= delegation
->type
;
144 spin_unlock(&delegation
->lock
);
145 put_rpccred(oldcred
);
148 /* We appear to have raced with a delegation return. */
149 spin_unlock(&delegation
->lock
);
151 nfs_inode_set_delegation(inode
, cred
, res
);
158 static int nfs_do_return_delegation(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
162 res
= nfs4_proc_delegreturn(inode
, delegation
->cred
, &delegation
->stateid
, issync
);
163 nfs_free_delegation(delegation
);
167 static struct inode
*nfs_delegation_grab_inode(struct nfs_delegation
*delegation
)
169 struct inode
*inode
= NULL
;
171 spin_lock(&delegation
->lock
);
172 if (delegation
->inode
!= NULL
)
173 inode
= igrab(delegation
->inode
);
174 spin_unlock(&delegation
->lock
);
178 static struct nfs_delegation
*nfs_detach_delegation_locked(struct nfs_inode
*nfsi
,
179 const nfs4_stateid
*stateid
,
180 struct nfs_client
*clp
)
182 struct nfs_delegation
*delegation
=
183 rcu_dereference_protected(nfsi
->delegation
,
184 lockdep_is_held(&clp
->cl_lock
));
186 if (delegation
== NULL
)
188 spin_lock(&delegation
->lock
);
189 if (stateid
!= NULL
&& memcmp(delegation
->stateid
.data
, stateid
->data
,
190 sizeof(delegation
->stateid
.data
)) != 0)
192 list_del_rcu(&delegation
->super_list
);
193 delegation
->inode
= NULL
;
194 nfsi
->delegation_state
= 0;
195 rcu_assign_pointer(nfsi
->delegation
, NULL
);
196 spin_unlock(&delegation
->lock
);
199 spin_unlock(&delegation
->lock
);
205 * Set up a delegation on an inode
207 int nfs_inode_set_delegation(struct inode
*inode
, struct rpc_cred
*cred
, struct nfs_openres
*res
)
209 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
210 struct nfs_inode
*nfsi
= NFS_I(inode
);
211 struct nfs_delegation
*delegation
, *old_delegation
;
212 struct nfs_delegation
*freeme
= NULL
;
215 delegation
= kmalloc(sizeof(*delegation
), GFP_NOFS
);
216 if (delegation
== NULL
)
218 memcpy(delegation
->stateid
.data
, res
->delegation
.data
,
219 sizeof(delegation
->stateid
.data
));
220 delegation
->type
= res
->delegation_type
;
221 delegation
->maxsize
= res
->maxsize
;
222 delegation
->change_attr
= nfsi
->change_attr
;
223 delegation
->cred
= get_rpccred(cred
);
224 delegation
->inode
= inode
;
225 delegation
->flags
= 1<<NFS_DELEGATION_REFERENCED
;
226 spin_lock_init(&delegation
->lock
);
228 spin_lock(&clp
->cl_lock
);
229 old_delegation
= rcu_dereference_protected(nfsi
->delegation
,
230 lockdep_is_held(&clp
->cl_lock
));
231 if (old_delegation
!= NULL
) {
232 if (memcmp(&delegation
->stateid
, &old_delegation
->stateid
,
233 sizeof(old_delegation
->stateid
)) == 0 &&
234 delegation
->type
== old_delegation
->type
) {
238 * Deal with broken servers that hand out two
239 * delegations for the same file.
241 dfprintk(FILE, "%s: server %s handed out "
242 "a duplicate delegation!\n",
243 __func__
, clp
->cl_hostname
);
244 if (delegation
->type
<= old_delegation
->type
) {
249 freeme
= nfs_detach_delegation_locked(nfsi
, NULL
, clp
);
251 list_add_rcu(&delegation
->super_list
, &clp
->cl_delegations
);
252 nfsi
->delegation_state
= delegation
->type
;
253 rcu_assign_pointer(nfsi
->delegation
, delegation
);
256 /* Ensure we revalidate the attributes and page cache! */
257 spin_lock(&inode
->i_lock
);
258 nfsi
->cache_validity
|= NFS_INO_REVAL_FORCED
;
259 spin_unlock(&inode
->i_lock
);
262 spin_unlock(&clp
->cl_lock
);
263 if (delegation
!= NULL
)
264 nfs_free_delegation(delegation
);
266 nfs_do_return_delegation(inode
, freeme
, 0);
271 * Basic procedure for returning a delegation to the server
273 static int __nfs_inode_return_delegation(struct inode
*inode
, struct nfs_delegation
*delegation
, int issync
)
275 struct nfs_inode
*nfsi
= NFS_I(inode
);
279 * Guard against new delegated open/lock/unlock calls and against
282 down_write(&nfsi
->rwsem
);
283 err
= nfs_delegation_claim_opens(inode
, &delegation
->stateid
);
284 up_write(&nfsi
->rwsem
);
288 err
= nfs_do_return_delegation(inode
, delegation
, issync
);
294 * Return all delegations that have been marked for return
296 int nfs_client_return_marked_delegations(struct nfs_client
*clp
)
298 struct nfs_delegation
*delegation
;
304 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
305 if (!test_and_clear_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
))
307 inode
= nfs_delegation_grab_inode(delegation
);
310 spin_lock(&clp
->cl_lock
);
311 delegation
= nfs_detach_delegation_locked(NFS_I(inode
), NULL
, clp
);
312 spin_unlock(&clp
->cl_lock
);
314 if (delegation
!= NULL
) {
315 filemap_flush(inode
->i_mapping
);
316 err
= __nfs_inode_return_delegation(inode
, delegation
, 0);
321 set_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
);
329 * This function returns the delegation without reclaiming opens
330 * or protecting against delegation reclaims.
331 * It is therefore really only safe to be called from
334 void nfs_inode_return_delegation_noreclaim(struct inode
*inode
)
336 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
337 struct nfs_inode
*nfsi
= NFS_I(inode
);
338 struct nfs_delegation
*delegation
;
340 if (rcu_access_pointer(nfsi
->delegation
) != NULL
) {
341 spin_lock(&clp
->cl_lock
);
342 delegation
= nfs_detach_delegation_locked(nfsi
, NULL
, clp
);
343 spin_unlock(&clp
->cl_lock
);
344 if (delegation
!= NULL
)
345 nfs_do_return_delegation(inode
, delegation
, 0);
349 int nfs_inode_return_delegation(struct inode
*inode
)
351 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
352 struct nfs_inode
*nfsi
= NFS_I(inode
);
353 struct nfs_delegation
*delegation
;
356 if (rcu_access_pointer(nfsi
->delegation
) != NULL
) {
357 spin_lock(&clp
->cl_lock
);
358 delegation
= nfs_detach_delegation_locked(nfsi
, NULL
, clp
);
359 spin_unlock(&clp
->cl_lock
);
360 if (delegation
!= NULL
) {
362 err
= __nfs_inode_return_delegation(inode
, delegation
, 1);
368 static void nfs_mark_return_delegation(struct nfs_client
*clp
, struct nfs_delegation
*delegation
)
370 set_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
);
371 set_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
);
375 * Return all delegations associated to a super block
377 void nfs_super_return_all_delegations(struct super_block
*sb
)
379 struct nfs_client
*clp
= NFS_SB(sb
)->nfs_client
;
380 struct nfs_delegation
*delegation
;
385 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
386 spin_lock(&delegation
->lock
);
387 if (delegation
->inode
!= NULL
&& delegation
->inode
->i_sb
== sb
)
388 set_bit(NFS_DELEGATION_RETURN
, &delegation
->flags
);
389 spin_unlock(&delegation
->lock
);
392 if (nfs_client_return_marked_delegations(clp
) != 0)
393 nfs4_schedule_state_manager(clp
);
397 void nfs_client_mark_return_all_delegation_types(struct nfs_client
*clp
, fmode_t flags
)
399 struct nfs_delegation
*delegation
;
402 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
403 if ((delegation
->type
== (FMODE_READ
|FMODE_WRITE
)) && !(flags
& FMODE_WRITE
))
405 if (delegation
->type
& flags
)
406 nfs_mark_return_delegation(clp
, delegation
);
411 static void nfs_client_mark_return_all_delegations(struct nfs_client
*clp
)
413 nfs_client_mark_return_all_delegation_types(clp
, FMODE_READ
|FMODE_WRITE
);
416 static void nfs_delegation_run_state_manager(struct nfs_client
*clp
)
418 if (test_bit(NFS4CLNT_DELEGRETURN
, &clp
->cl_state
))
419 nfs4_schedule_state_manager(clp
);
422 void nfs_expire_all_delegation_types(struct nfs_client
*clp
, fmode_t flags
)
424 nfs_client_mark_return_all_delegation_types(clp
, flags
);
425 nfs_delegation_run_state_manager(clp
);
428 void nfs_expire_all_delegations(struct nfs_client
*clp
)
430 nfs_expire_all_delegation_types(clp
, FMODE_READ
|FMODE_WRITE
);
434 * Return all delegations following an NFS4ERR_CB_PATH_DOWN error.
436 void nfs_handle_cb_pathdown(struct nfs_client
*clp
)
440 nfs_client_mark_return_all_delegations(clp
);
443 static void nfs_client_mark_return_unreferenced_delegations(struct nfs_client
*clp
)
445 struct nfs_delegation
*delegation
;
448 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
449 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED
, &delegation
->flags
))
451 nfs_mark_return_delegation(clp
, delegation
);
456 void nfs_expire_unreferenced_delegations(struct nfs_client
*clp
)
458 nfs_client_mark_return_unreferenced_delegations(clp
);
459 nfs_delegation_run_state_manager(clp
);
463 * Asynchronous delegation recall!
465 int nfs_async_inode_return_delegation(struct inode
*inode
, const nfs4_stateid
*stateid
)
467 struct nfs_client
*clp
= NFS_SERVER(inode
)->nfs_client
;
468 struct nfs_delegation
*delegation
;
471 delegation
= rcu_dereference(NFS_I(inode
)->delegation
);
473 if (!clp
->cl_mvops
->validate_stateid(delegation
, stateid
)) {
478 nfs_mark_return_delegation(clp
, delegation
);
480 nfs_delegation_run_state_manager(clp
);
485 * Retrieve the inode associated with a delegation
487 struct inode
*nfs_delegation_find_inode(struct nfs_client
*clp
, const struct nfs_fh
*fhandle
)
489 struct nfs_delegation
*delegation
;
490 struct inode
*res
= NULL
;
492 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
493 spin_lock(&delegation
->lock
);
494 if (delegation
->inode
!= NULL
&&
495 nfs_compare_fh(fhandle
, &NFS_I(delegation
->inode
)->fh
) == 0) {
496 res
= igrab(delegation
->inode
);
498 spin_unlock(&delegation
->lock
);
507 * Mark all delegations as needing to be reclaimed
509 void nfs_delegation_mark_reclaim(struct nfs_client
*clp
)
511 struct nfs_delegation
*delegation
;
513 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
)
514 set_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
);
519 * Reap all unclaimed delegations after reboot recovery is done
521 void nfs_delegation_reap_unclaimed(struct nfs_client
*clp
)
523 struct nfs_delegation
*delegation
;
527 list_for_each_entry_rcu(delegation
, &clp
->cl_delegations
, super_list
) {
528 if (test_bit(NFS_DELEGATION_NEED_RECLAIM
, &delegation
->flags
) == 0)
530 inode
= nfs_delegation_grab_inode(delegation
);
533 spin_lock(&clp
->cl_lock
);
534 delegation
= nfs_detach_delegation_locked(NFS_I(inode
), NULL
, clp
);
535 spin_unlock(&clp
->cl_lock
);
537 if (delegation
!= NULL
)
538 nfs_free_delegation(delegation
);
545 int nfs4_copy_delegation_stateid(nfs4_stateid
*dst
, struct inode
*inode
)
547 struct nfs_inode
*nfsi
= NFS_I(inode
);
548 struct nfs_delegation
*delegation
;
552 delegation
= rcu_dereference(nfsi
->delegation
);
553 if (delegation
!= NULL
) {
554 memcpy(dst
->data
, delegation
->stateid
.data
, sizeof(dst
->data
));