]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - fs/nfs/delegation.c
Merge branch 'core-urgent-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[mirror_ubuntu-bionic-kernel.git] / fs / nfs / delegation.c
CommitLineData
1da177e4
LT
1/*
2 * linux/fs/nfs/delegation.c
3 *
4 * Copyright (C) 2004 Trond Myklebust
5 *
6 * NFS file delegation management
7 *
8 */
1da177e4 9#include <linux/completion.h>
58d9714a 10#include <linux/kthread.h>
1da177e4
LT
11#include <linux/module.h>
12#include <linux/sched.h>
5a0e3ad6 13#include <linux/slab.h>
1da177e4
LT
14#include <linux/spinlock.h>
15
16#include <linux/nfs4.h>
17#include <linux/nfs_fs.h>
18#include <linux/nfs_xdr.h>
19
4ce79717 20#include "nfs4_fs.h"
1da177e4 21#include "delegation.h"
24c8dbbb 22#include "internal.h"
ca8acf8d 23#include "nfs4trace.h"
1da177e4 24
905f8d16
TM
25static void nfs_free_delegation(struct nfs_delegation *delegation)
26{
e00b8a24
TM
27 if (delegation->cred) {
28 put_rpccred(delegation->cred);
29 delegation->cred = NULL;
30 }
26f04dde 31 kfree_rcu(delegation, rcu);
8383e460
TM
32}
33
d3978bb3
CL
34/**
35 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
36 * @delegation: delegation to process
37 *
38 */
b7391f44
TM
39void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
40{
41 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
42}
43
15bb3afe
PT
44static int
45nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
b7391f44
TM
46{
47 struct nfs_delegation *delegation;
48 int ret = 0;
49
50 flags &= FMODE_READ|FMODE_WRITE;
51 rcu_read_lock();
52 delegation = rcu_dereference(NFS_I(inode)->delegation);
d25be546
TM
53 if (delegation != NULL && (delegation->type & flags) == flags &&
54 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
15bb3afe
PT
55 if (mark)
56 nfs_mark_delegation_referenced(delegation);
b7391f44
TM
57 ret = 1;
58 }
59 rcu_read_unlock();
60 return ret;
61}
15bb3afe
PT
62/**
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
67 *
68 * Returns one if inode has the indicated delegation, otherwise zero.
69 */
70int nfs4_have_delegation(struct inode *inode, fmode_t flags)
71{
72 return nfs4_do_check_delegation(inode, flags, true);
73}
74
75/*
76 * nfs4_check_delegation - check if inode has a delegation, do not mark
77 * NFS_DELEGATION_REFERENCED if it has one.
78 */
79int nfs4_check_delegation(struct inode *inode, fmode_t flags)
80{
81 return nfs4_do_check_delegation(inode, flags, false);
82}
b7391f44 83
db4f2e63 84static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
888e694c
TM
85{
86 struct inode *inode = state->inode;
87 struct file_lock *fl;
bd61e0a9
JL
88 struct file_lock_context *flctx = inode->i_flctx;
89 struct list_head *list;
d5122201 90 int status = 0;
888e694c 91
bd61e0a9 92 if (flctx == NULL)
65b62a29 93 goto out;
314d7cc0 94
bd61e0a9 95 list = &flctx->flc_posix;
6109c850 96 spin_lock(&flctx->flc_lock);
bd61e0a9
JL
97restart:
98 list_for_each_entry(fl, list, fl_list) {
cd3758e3 99 if (nfs_file_open_context(fl->fl_file) != ctx)
888e694c 100 continue;
6109c850 101 spin_unlock(&flctx->flc_lock);
db4f2e63 102 status = nfs4_lock_delegation_recall(fl, state, stateid);
d5122201 103 if (status < 0)
3f09df70 104 goto out;
6109c850 105 spin_lock(&flctx->flc_lock);
888e694c 106 }
bd61e0a9
JL
107 if (list == &flctx->flc_posix) {
108 list = &flctx->flc_flock;
109 goto restart;
888e694c 110 }
6109c850 111 spin_unlock(&flctx->flc_lock);
3f09df70 112out:
888e694c
TM
113 return status;
114}
115
24311f88
TM
116static int nfs_delegation_claim_opens(struct inode *inode,
117 const nfs4_stateid *stateid, fmode_t type)
1da177e4
LT
118{
119 struct nfs_inode *nfsi = NFS_I(inode);
120 struct nfs_open_context *ctx;
d25be546 121 struct nfs4_state_owner *sp;
1da177e4 122 struct nfs4_state *state;
d25be546 123 unsigned int seq;
888e694c 124 int err;
1da177e4
LT
125
126again:
127 spin_lock(&inode->i_lock);
128 list_for_each_entry(ctx, &nfsi->open_files, list) {
129 state = ctx->state;
130 if (state == NULL)
131 continue;
132 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
133 continue;
f8ebf7a8
TM
134 if (!nfs4_valid_open_stateid(state))
135 continue;
f597c537 136 if (!nfs4_stateid_match(&state->stateid, stateid))
90163027 137 continue;
1da177e4
LT
138 get_nfs_open_context(ctx);
139 spin_unlock(&inode->i_lock);
d25be546 140 sp = state->owner;
65b62a29
TM
141 /* Block nfs4_proc_unlck */
142 mutex_lock(&sp->so_delegreturn_mutex);
d25be546 143 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
24311f88 144 err = nfs4_open_delegation_recall(ctx, state, stateid, type);
d25be546 145 if (!err)
db4f2e63 146 err = nfs_delegation_claim_locks(ctx, state, stateid);
d25be546
TM
147 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
148 err = -EAGAIN;
65b62a29 149 mutex_unlock(&sp->so_delegreturn_mutex);
1da177e4 150 put_nfs_open_context(ctx);
888e694c 151 if (err != 0)
d18cc1fd 152 return err;
1da177e4
LT
153 goto again;
154 }
155 spin_unlock(&inode->i_lock);
d18cc1fd 156 return 0;
1da177e4
LT
157}
158
d3978bb3
CL
159/**
160 * nfs_inode_reclaim_delegation - process a delegation reclaim request
161 * @inode: inode to process
162 * @cred: credential to use for request
163 * @res: new delegation state from server
164 *
1da177e4 165 */
d3978bb3
CL
166void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
167 struct nfs_openres *res)
1da177e4 168{
8f649c37
TM
169 struct nfs_delegation *delegation;
170 struct rpc_cred *oldcred = NULL;
1da177e4 171
8f649c37
TM
172 rcu_read_lock();
173 delegation = rcu_dereference(NFS_I(inode)->delegation);
174 if (delegation != NULL) {
175 spin_lock(&delegation->lock);
176 if (delegation->inode != NULL) {
f597c537 177 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
8f649c37 178 delegation->type = res->delegation_type;
7d160a6c 179 delegation->pagemod_limit = res->pagemod_limit;
8f649c37
TM
180 oldcred = delegation->cred;
181 delegation->cred = get_rpccred(cred);
182 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
183 &delegation->flags);
8f649c37 184 spin_unlock(&delegation->lock);
8f649c37 185 rcu_read_unlock();
7c0af9ff 186 put_rpccred(oldcred);
ca8acf8d 187 trace_nfs4_reclaim_delegation(inode, res->delegation_type);
8f649c37
TM
188 } else {
189 /* We appear to have raced with a delegation return. */
190 spin_unlock(&delegation->lock);
191 rcu_read_unlock();
192 nfs_inode_set_delegation(inode, cred, res);
193 }
194 } else {
195 rcu_read_unlock();
196 }
1da177e4
LT
197}
198
57bfa891
TM
199static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
200{
201 int res = 0;
202
869f9dfa
TM
203 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
204 res = nfs4_proc_delegreturn(inode,
205 delegation->cred,
206 &delegation->stateid,
207 issync);
57bfa891
TM
208 nfs_free_delegation(delegation);
209 return res;
210}
211
86e89489
TM
212static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
213{
214 struct inode *inode = NULL;
215
216 spin_lock(&delegation->lock);
217 if (delegation->inode != NULL)
218 inode = igrab(delegation->inode);
219 spin_unlock(&delegation->lock);
220 return inode;
221}
222
d25be546
TM
223static struct nfs_delegation *
224nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
225{
226 struct nfs_delegation *ret = NULL;
227 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
228
229 if (delegation == NULL)
230 goto out;
231 spin_lock(&delegation->lock);
232 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
233 ret = delegation;
234 spin_unlock(&delegation->lock);
235out:
236 return ret;
237}
238
239static struct nfs_delegation *
240nfs_start_delegation_return(struct nfs_inode *nfsi)
241{
242 struct nfs_delegation *delegation;
243
244 rcu_read_lock();
245 delegation = nfs_start_delegation_return_locked(nfsi);
246 rcu_read_unlock();
247 return delegation;
248}
249
250static void
251nfs_abort_delegation_return(struct nfs_delegation *delegation,
252 struct nfs_client *clp)
253{
254
255 spin_lock(&delegation->lock);
256 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
257 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
258 spin_unlock(&delegation->lock);
259 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
260}
261
dda4b225
CL
262static struct nfs_delegation *
263nfs_detach_delegation_locked(struct nfs_inode *nfsi,
d25be546
TM
264 struct nfs_delegation *delegation,
265 struct nfs_client *clp)
57bfa891 266{
d25be546 267 struct nfs_delegation *deleg_cur =
17d2c0a0 268 rcu_dereference_protected(nfsi->delegation,
d25be546 269 lockdep_is_held(&clp->cl_lock));
57bfa891 270
d25be546
TM
271 if (deleg_cur == NULL || delegation != deleg_cur)
272 return NULL;
dda4b225 273
34310430 274 spin_lock(&delegation->lock);
d25be546 275 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
57bfa891 276 list_del_rcu(&delegation->super_list);
86e89489 277 delegation->inode = NULL;
57bfa891 278 rcu_assign_pointer(nfsi->delegation, NULL);
34310430 279 spin_unlock(&delegation->lock);
57bfa891 280 return delegation;
57bfa891
TM
281}
282
dda4b225 283static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
d25be546
TM
284 struct nfs_delegation *delegation,
285 struct nfs_server *server)
dda4b225 286{
d3978bb3 287 struct nfs_client *clp = server->nfs_client;
dda4b225
CL
288
289 spin_lock(&clp->cl_lock);
d25be546 290 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
dda4b225
CL
291 spin_unlock(&clp->cl_lock);
292 return delegation;
293}
294
d25be546
TM
295static struct nfs_delegation *
296nfs_inode_detach_delegation(struct inode *inode)
297{
298 struct nfs_inode *nfsi = NFS_I(inode);
299 struct nfs_server *server = NFS_SERVER(inode);
300 struct nfs_delegation *delegation;
301
302 delegation = nfs_start_delegation_return(nfsi);
303 if (delegation == NULL)
304 return NULL;
305 return nfs_detach_delegation(nfsi, delegation, server);
306}
307
cf6726e2
TM
308static void
309nfs_update_inplace_delegation(struct nfs_delegation *delegation,
310 const struct nfs_delegation *update)
311{
312 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
313 delegation->stateid.seqid = update->stateid.seqid;
314 smp_wmb();
315 delegation->type = update->type;
316 }
317}
318
d3978bb3
CL
319/**
320 * nfs_inode_set_delegation - set up a delegation on an inode
321 * @inode: inode to which delegation applies
322 * @cred: cred to use for subsequent delegation processing
323 * @res: new delegation state from server
324 *
325 * Returns zero on success, or a negative errno value.
1da177e4
LT
326 */
327int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
328{
d3978bb3
CL
329 struct nfs_server *server = NFS_SERVER(inode);
330 struct nfs_client *clp = server->nfs_client;
1da177e4 331 struct nfs_inode *nfsi = NFS_I(inode);
17d2c0a0 332 struct nfs_delegation *delegation, *old_delegation;
57bfa891 333 struct nfs_delegation *freeme = NULL;
1da177e4
LT
334 int status = 0;
335
8535b2be 336 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
1da177e4
LT
337 if (delegation == NULL)
338 return -ENOMEM;
f597c537 339 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
1da177e4 340 delegation->type = res->delegation_type;
7d160a6c 341 delegation->pagemod_limit = res->pagemod_limit;
a9a4a87a 342 delegation->change_attr = inode->i_version;
1da177e4
LT
343 delegation->cred = get_rpccred(cred);
344 delegation->inode = inode;
b7391f44 345 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
34310430 346 spin_lock_init(&delegation->lock);
1da177e4
LT
347
348 spin_lock(&clp->cl_lock);
17d2c0a0 349 old_delegation = rcu_dereference_protected(nfsi->delegation,
d3978bb3 350 lockdep_is_held(&clp->cl_lock));
17d2c0a0 351 if (old_delegation != NULL) {
cf6726e2
TM
352 /* Is this an update of the existing delegation? */
353 if (nfs4_stateid_match_other(&old_delegation->stateid,
354 &delegation->stateid)) {
355 nfs_update_inplace_delegation(old_delegation,
356 delegation);
57bfa891 357 goto out;
1da177e4 358 }
57bfa891
TM
359 /*
360 * Deal with broken servers that hand out two
361 * delegations for the same file.
17280175
TM
362 * Allow for upgrades to a WRITE delegation, but
363 * nothing else.
57bfa891
TM
364 */
365 dfprintk(FILE, "%s: server %s handed out "
366 "a duplicate delegation!\n",
3110ff80 367 __func__, clp->cl_hostname);
17280175
TM
368 if (delegation->type == old_delegation->type ||
369 !(delegation->type & FMODE_WRITE)) {
57bfa891
TM
370 freeme = delegation;
371 delegation = NULL;
372 goto out;
373 }
ade04647
TM
374 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
375 &old_delegation->flags))
376 goto out;
377 freeme = nfs_detach_delegation_locked(nfsi,
d25be546
TM
378 old_delegation, clp);
379 if (freeme == NULL)
380 goto out;
1da177e4 381 }
38942ba2 382 list_add_tail_rcu(&delegation->super_list, &server->delegations);
57bfa891
TM
383 rcu_assign_pointer(nfsi->delegation, delegation);
384 delegation = NULL;
412c77ce
TM
385
386 /* Ensure we revalidate the attributes and page cache! */
387 spin_lock(&inode->i_lock);
388 nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
389 spin_unlock(&inode->i_lock);
ca8acf8d 390 trace_nfs4_set_delegation(inode, res->delegation_type);
412c77ce 391
57bfa891 392out:
1da177e4 393 spin_unlock(&clp->cl_lock);
603c83da
TM
394 if (delegation != NULL)
395 nfs_free_delegation(delegation);
57bfa891
TM
396 if (freeme != NULL)
397 nfs_do_return_delegation(inode, freeme, 0);
1da177e4
LT
398 return status;
399}
400
1da177e4
LT
401/*
402 * Basic procedure for returning a delegation to the server
403 */
d25be546 404static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
1da177e4 405{
d25be546 406 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1da177e4 407 struct nfs_inode *nfsi = NFS_I(inode);
869f9dfa 408 int err = 0;
1da177e4 409
d25be546
TM
410 if (delegation == NULL)
411 return 0;
412 do {
869f9dfa
TM
413 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
414 break;
24311f88
TM
415 err = nfs_delegation_claim_opens(inode, &delegation->stateid,
416 delegation->type);
d25be546
TM
417 if (!issync || err != -EAGAIN)
418 break;
419 /*
420 * Guard against state recovery
421 */
422 err = nfs4_wait_clnt_recover(clp);
423 } while (err == 0);
424
425 if (err) {
426 nfs_abort_delegation_return(delegation, clp);
427 goto out;
428 }
429 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
d18cc1fd 430 goto out;
1da177e4 431
d18cc1fd
TM
432 err = nfs_do_return_delegation(inode, delegation, issync);
433out:
434 return err;
90163027
TM
435}
436
b757144f
TM
437static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
438{
439 bool ret = false;
440
ec3ca4e5
TM
441 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
442 goto out;
b757144f
TM
443 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
444 ret = true;
445 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
446 struct inode *inode;
447
448 spin_lock(&delegation->lock);
449 inode = delegation->inode;
450 if (inode && list_empty(&NFS_I(inode)->open_files))
451 ret = true;
452 spin_unlock(&delegation->lock);
453 }
ec3ca4e5 454out:
b757144f
TM
455 return ret;
456}
457
d3978bb3
CL
458/**
459 * nfs_client_return_marked_delegations - return previously marked delegations
460 * @clp: nfs_client to process
461 *
dc327ed4
TM
462 * Note that this function is designed to be called by the state
463 * manager thread. For this reason, it cannot flush the dirty data,
464 * since that could deadlock in case of a state recovery error.
465 *
d3978bb3 466 * Returns zero on success, or a negative errno value.
515d8611 467 */
d18cc1fd 468int nfs_client_return_marked_delegations(struct nfs_client *clp)
515d8611
TM
469{
470 struct nfs_delegation *delegation;
d3978bb3 471 struct nfs_server *server;
515d8611 472 struct inode *inode;
d18cc1fd 473 int err = 0;
515d8611
TM
474
475restart:
476 rcu_read_lock();
d3978bb3
CL
477 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
478 list_for_each_entry_rcu(delegation, &server->delegations,
479 super_list) {
b757144f 480 if (!nfs_delegation_need_return(delegation))
d3978bb3 481 continue;
9f0f8e12 482 if (!nfs_sb_active(server->super))
d3978bb3 483 continue;
9f0f8e12
TM
484 inode = nfs_delegation_grab_inode(delegation);
485 if (inode == NULL) {
486 rcu_read_unlock();
487 nfs_sb_deactive(server->super);
488 goto restart;
489 }
d25be546 490 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
d3978bb3
CL
491 rcu_read_unlock();
492
d25be546 493 err = nfs_end_delegation_return(inode, delegation, 0);
d3978bb3 494 iput(inode);
9f0f8e12 495 nfs_sb_deactive(server->super);
d3978bb3
CL
496 if (!err)
497 goto restart;
498 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
499 return err;
d18cc1fd 500 }
515d8611
TM
501 }
502 rcu_read_unlock();
d18cc1fd 503 return 0;
515d8611
TM
504}
505
d3978bb3
CL
506/**
507 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
508 * @inode: inode to process
509 *
510 * Does not protect against delegation reclaims, therefore really only safe
511 * to be called from nfs4_clear_inode().
e6f81075
TM
512 */
513void nfs_inode_return_delegation_noreclaim(struct inode *inode)
514{
e6f81075
TM
515 struct nfs_delegation *delegation;
516
d25be546
TM
517 delegation = nfs_inode_detach_delegation(inode);
518 if (delegation != NULL)
5fcdfacc 519 nfs_do_return_delegation(inode, delegation, 1);
e6f81075
TM
520}
521
d3978bb3
CL
522/**
523 * nfs_inode_return_delegation - synchronously return a delegation
524 * @inode: inode to process
525 *
c57d1bc5
TM
526 * This routine will always flush any dirty data to disk on the
527 * assumption that if we need to return the delegation, then
528 * we should stop caching.
529 *
d3978bb3
CL
530 * Returns zero on success, or a negative errno value.
531 */
57ec14c5 532int nfs4_inode_return_delegation(struct inode *inode)
90163027 533{
90163027
TM
534 struct nfs_inode *nfsi = NFS_I(inode);
535 struct nfs_delegation *delegation;
536 int err = 0;
537
c57d1bc5 538 nfs_wb_all(inode);
d25be546
TM
539 delegation = nfs_start_delegation_return(nfsi);
540 if (delegation != NULL)
541 err = nfs_end_delegation_return(inode, delegation, 1);
90163027 542 return err;
1da177e4
LT
543}
544
b757144f
TM
545static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
546 struct nfs_delegation *delegation)
547{
548 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
549 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
550}
551
ed1e6211
TM
552static void nfs_mark_return_delegation(struct nfs_server *server,
553 struct nfs_delegation *delegation)
6411bd4a
TM
554{
555 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
ed1e6211 556 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
6411bd4a
TM
557}
558
5c31e236
TM
559static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
560{
561 struct nfs_delegation *delegation;
562 bool ret = false;
563
564 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
565 nfs_mark_return_delegation(server, delegation);
566 ret = true;
567 }
568 return ret;
569}
570
b02ba0b6
TM
571static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
572{
573 struct nfs_server *server;
574
575 rcu_read_lock();
576 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
577 nfs_server_mark_return_all_delegations(server);
578 rcu_read_unlock();
579}
580
581static void nfs_delegation_run_state_manager(struct nfs_client *clp)
582{
583 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
584 nfs4_schedule_state_manager(clp);
585}
586
587/**
588 * nfs_expire_all_delegations
589 * @clp: client to process
590 *
591 */
592void nfs_expire_all_delegations(struct nfs_client *clp)
593{
594 nfs_client_mark_return_all_delegations(clp);
595 nfs_delegation_run_state_manager(clp);
596}
597
d3978bb3
CL
598/**
599 * nfs_super_return_all_delegations - return delegations for one superblock
600 * @sb: sb to process
601 *
1da177e4 602 */
eeebf916 603void nfs_server_return_all_delegations(struct nfs_server *server)
1da177e4 604{
d3978bb3 605 struct nfs_client *clp = server->nfs_client;
5c31e236 606 bool need_wait;
1da177e4
LT
607
608 if (clp == NULL)
609 return;
d3978bb3 610
8383e460 611 rcu_read_lock();
5c31e236 612 need_wait = nfs_server_mark_return_all_delegations(server);
8383e460 613 rcu_read_unlock();
d3978bb3 614
5c31e236 615 if (need_wait) {
d18cc1fd 616 nfs4_schedule_state_manager(clp);
5c31e236
TM
617 nfs4_wait_clnt_recover(clp);
618 }
515d8611
TM
619}
620
826e0013 621static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
d3978bb3 622 fmode_t flags)
515d8611
TM
623{
624 struct nfs_delegation *delegation;
625
d3978bb3 626 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
c79571a5
AB
627 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
628 continue;
629 if (delegation->type & flags)
826e0013 630 nfs_mark_return_if_closed_delegation(server, delegation);
707fb4b3 631 }
d3978bb3
CL
632}
633
826e0013 634static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
d3978bb3
CL
635 fmode_t flags)
636{
637 struct nfs_server *server;
638
639 rcu_read_lock();
640 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
826e0013 641 nfs_mark_return_unused_delegation_types(server, flags);
515d8611 642 rcu_read_unlock();
1da177e4
LT
643}
644
869f9dfa
TM
645static void nfs_revoke_delegation(struct inode *inode)
646{
647 struct nfs_delegation *delegation;
648 rcu_read_lock();
649 delegation = rcu_dereference(NFS_I(inode)->delegation);
650 if (delegation != NULL) {
651 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
652 nfs_mark_return_delegation(NFS_SERVER(inode), delegation);
653 }
654 rcu_read_unlock();
655}
656
a1d0b5ee
TM
657void nfs_remove_bad_delegation(struct inode *inode)
658{
659 struct nfs_delegation *delegation;
660
869f9dfa 661 nfs_revoke_delegation(inode);
d25be546 662 delegation = nfs_inode_detach_delegation(inode);
a1d0b5ee
TM
663 if (delegation) {
664 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
665 nfs_free_delegation(delegation);
666 }
667}
9cb81968 668EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
a1d0b5ee 669
d3978bb3 670/**
826e0013 671 * nfs_expire_unused_delegation_types
d3978bb3
CL
672 * @clp: client to process
673 * @flags: delegation types to expire
674 *
675 */
826e0013 676void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
58d9714a 677{
826e0013 678 nfs_client_mark_return_unused_delegation_types(clp, flags);
b0d3ded1 679 nfs_delegation_run_state_manager(clp);
58d9714a
TM
680}
681
d3978bb3 682static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
b7391f44
TM
683{
684 struct nfs_delegation *delegation;
685
d3978bb3 686 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
b7391f44
TM
687 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
688 continue;
b757144f 689 nfs_mark_return_if_closed_delegation(server, delegation);
b7391f44 690 }
b7391f44
TM
691}
692
d3978bb3
CL
693/**
694 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
695 * @clp: nfs_client to process
696 *
697 */
b7391f44
TM
698void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
699{
d3978bb3
CL
700 struct nfs_server *server;
701
702 rcu_read_lock();
703 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
704 nfs_mark_return_unreferenced_delegations(server);
705 rcu_read_unlock();
706
b7391f44
TM
707 nfs_delegation_run_state_manager(clp);
708}
709
d3978bb3
CL
710/**
711 * nfs_async_inode_return_delegation - asynchronously return a delegation
712 * @inode: inode to process
8e663f0e 713 * @stateid: state ID information
d3978bb3
CL
714 *
715 * Returns zero on success, or a negative errno value.
1da177e4 716 */
d3978bb3
CL
717int nfs_async_inode_return_delegation(struct inode *inode,
718 const nfs4_stateid *stateid)
1da177e4 719{
ed1e6211
TM
720 struct nfs_server *server = NFS_SERVER(inode);
721 struct nfs_client *clp = server->nfs_client;
6411bd4a 722 struct nfs_delegation *delegation;
1da177e4 723
6411bd4a
TM
724 rcu_read_lock();
725 delegation = rcu_dereference(NFS_I(inode)->delegation);
755a48a7
TM
726 if (delegation == NULL)
727 goto out_enoent;
4816fdad
TM
728 if (stateid != NULL &&
729 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
755a48a7 730 goto out_enoent;
ed1e6211 731 nfs_mark_return_delegation(server, delegation);
6411bd4a 732 rcu_read_unlock();
d3978bb3 733
6411bd4a
TM
734 nfs_delegation_run_state_manager(clp);
735 return 0;
755a48a7
TM
736out_enoent:
737 rcu_read_unlock();
738 return -ENOENT;
1da177e4
LT
739}
740
d3978bb3
CL
741static struct inode *
742nfs_delegation_find_inode_server(struct nfs_server *server,
743 const struct nfs_fh *fhandle)
1da177e4
LT
744{
745 struct nfs_delegation *delegation;
746 struct inode *res = NULL;
d3978bb3
CL
747
748 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
86e89489
TM
749 spin_lock(&delegation->lock);
750 if (delegation->inode != NULL &&
751 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
1da177e4 752 res = igrab(delegation->inode);
1da177e4 753 }
86e89489
TM
754 spin_unlock(&delegation->lock);
755 if (res != NULL)
756 break;
1da177e4 757 }
d3978bb3
CL
758 return res;
759}
760
761/**
762 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
763 * @clp: client state handle
764 * @fhandle: filehandle from a delegation recall
765 *
766 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
767 * cannot be found.
768 */
769struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
770 const struct nfs_fh *fhandle)
771{
772 struct nfs_server *server;
773 struct inode *res = NULL;
774
775 rcu_read_lock();
776 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
777 res = nfs_delegation_find_inode_server(server, fhandle);
778 if (res != NULL)
779 break;
780 }
8383e460 781 rcu_read_unlock();
1da177e4
LT
782 return res;
783}
784
d3978bb3
CL
785static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
786{
787 struct nfs_delegation *delegation;
788
789 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
790 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
791}
792
793/**
794 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
795 * @clp: nfs_client to process
796 *
1da177e4 797 */
adfa6f98 798void nfs_delegation_mark_reclaim(struct nfs_client *clp)
1da177e4 799{
d3978bb3
CL
800 struct nfs_server *server;
801
8383e460 802 rcu_read_lock();
d3978bb3
CL
803 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
804 nfs_delegation_mark_reclaim_server(server);
8383e460 805 rcu_read_unlock();
1da177e4
LT
806}
807
d3978bb3
CL
808/**
809 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
810 * @clp: nfs_client to process
811 *
1da177e4 812 */
adfa6f98 813void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
1da177e4 814{
8383e460 815 struct nfs_delegation *delegation;
d3978bb3 816 struct nfs_server *server;
86e89489 817 struct inode *inode;
d3978bb3 818
8383e460
TM
819restart:
820 rcu_read_lock();
d3978bb3
CL
821 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
822 list_for_each_entry_rcu(delegation, &server->delegations,
823 super_list) {
ec3ca4e5
TM
824 if (test_bit(NFS_DELEGATION_RETURNING,
825 &delegation->flags))
826 continue;
d3978bb3
CL
827 if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
828 &delegation->flags) == 0)
829 continue;
9f0f8e12 830 if (!nfs_sb_active(server->super))
d3978bb3 831 continue;
9f0f8e12
TM
832 inode = nfs_delegation_grab_inode(delegation);
833 if (inode == NULL) {
834 rcu_read_unlock();
835 nfs_sb_deactive(server->super);
836 goto restart;
837 }
b04b22f4 838 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
d3978bb3 839 rcu_read_unlock();
b04b22f4
TM
840 if (delegation != NULL) {
841 delegation = nfs_detach_delegation(NFS_I(inode),
842 delegation, server);
843 if (delegation != NULL)
844 nfs_free_delegation(delegation);
845 }
d3978bb3 846 iput(inode);
9f0f8e12 847 nfs_sb_deactive(server->super);
d3978bb3
CL
848 goto restart;
849 }
1da177e4 850 }
8383e460 851 rcu_read_unlock();
1da177e4 852}
3e4f6290 853
d3978bb3
CL
854/**
855 * nfs_delegations_present - check for existence of delegations
856 * @clp: client state handle
857 *
858 * Returns one if there are any nfs_delegation structures attached
859 * to this nfs_client.
860 */
861int nfs_delegations_present(struct nfs_client *clp)
862{
863 struct nfs_server *server;
864 int ret = 0;
865
866 rcu_read_lock();
867 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
868 if (!list_empty(&server->delegations)) {
869 ret = 1;
870 break;
871 }
872 rcu_read_unlock();
873 return ret;
874}
875
876/**
877 * nfs4_copy_delegation_stateid - Copy inode's state ID information
878 * @dst: stateid data structure to fill in
879 * @inode: inode to check
0032a7a7 880 * @flags: delegation type requirement
d3978bb3 881 *
0032a7a7
TM
882 * Returns "true" and fills in "dst->data" * if inode had a delegation,
883 * otherwise "false" is returned.
d3978bb3 884 */
0032a7a7
TM
885bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode,
886 fmode_t flags)
3e4f6290 887{
3e4f6290
TM
888 struct nfs_inode *nfsi = NFS_I(inode);
889 struct nfs_delegation *delegation;
0032a7a7 890 bool ret;
3e4f6290 891
0032a7a7 892 flags &= FMODE_READ|FMODE_WRITE;
8383e460
TM
893 rcu_read_lock();
894 delegation = rcu_dereference(nfsi->delegation);
0032a7a7
TM
895 ret = (delegation != NULL && (delegation->type & flags) == flags);
896 if (ret) {
f597c537 897 nfs4_stateid_copy(dst, &delegation->stateid);
0032a7a7 898 nfs_mark_delegation_referenced(delegation);
3e4f6290 899 }
8383e460
TM
900 rcu_read_unlock();
901 return ret;
3e4f6290 902}
5445b1fb
TM
903
904/**
905 * nfs4_delegation_flush_on_close - Check if we must flush file on close
906 * @inode: inode to check
907 *
908 * This function checks the number of outstanding writes to the file
909 * against the delegation 'space_limit' field to see if
910 * the spec requires us to flush the file on close.
911 */
912bool nfs4_delegation_flush_on_close(const struct inode *inode)
913{
914 struct nfs_inode *nfsi = NFS_I(inode);
915 struct nfs_delegation *delegation;
916 bool ret = true;
917
918 rcu_read_lock();
919 delegation = rcu_dereference(nfsi->delegation);
920 if (delegation == NULL || !(delegation->type & FMODE_WRITE))
921 goto out;
922 if (nfsi->nrequests < delegation->pagemod_limit)
923 ret = false;
924out:
925 rcu_read_unlock();
926 return ret;
927}