1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * linux/fs/nfs/delegation.c
4 *
5 * Copyright (C) 2004 Trond Myklebust
6 *
7 * NFS file delegation management
8 *
9 */
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>
17
18#include <linux/nfs4.h>
19#include <linux/nfs_fs.h>
20#include <linux/nfs_xdr.h>
21
22#include "nfs4_fs.h"
23#include "nfs4session.h"
24#include "delegation.h"
25#include "internal.h"
26#include "nfs4trace.h"
27
28#define NFS_DEFAULT_DELEGATION_WATERMARK (5000U)
29
30static unsigned nfs_delegation_watermark = NFS_DEFAULT_DELEGATION_WATERMARK;
31module_param_named(delegation_watermark, nfs_delegation_watermark, uint, 0644);
32
33static struct hlist_head *nfs_delegation_hash(struct nfs_server *server,
34 const struct nfs_fh *fhandle)
35{
36 return server->delegation_hash_table +
37 (nfs_fhandle_hash(fh: fhandle) & server->delegation_hash_mask);
38}
39
40static void __nfs_free_delegation(struct nfs_delegation *delegation)
41{
42 put_cred(cred: delegation->cred);
43 delegation->cred = NULL;
44 kfree_rcu(delegation, rcu);
45}
46
47static void nfs_mark_delegation_revoked(struct nfs_server *server,
48 struct nfs_delegation *delegation)
49{
50 if (!test_and_set_bit(nr: NFS_DELEGATION_REVOKED, addr: &delegation->flags)) {
51 delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
52 atomic_long_dec(v: &server->nr_active_delegations);
53 if (!test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
54 nfs_clear_verifier_delegated(inode: delegation->inode);
55 }
56}
57
58static struct nfs_delegation *nfs_get_delegation(struct nfs_delegation *delegation)
59{
60 refcount_inc(r: &delegation->refcount);
61 return delegation;
62}
63
64static void nfs_put_delegation(struct nfs_delegation *delegation)
65{
66 if (refcount_dec_and_test(r: &delegation->refcount))
67 __nfs_free_delegation(delegation);
68}
69
70static void nfs_free_delegation(struct nfs_server *server,
71 struct nfs_delegation *delegation)
72{
73 nfs_mark_delegation_revoked(server, delegation);
74 nfs_put_delegation(delegation);
75}
76
77/**
78 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
79 * @delegation: delegation to process
80 *
81 */
82void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
83{
84 set_bit(nr: NFS_DELEGATION_REFERENCED, addr: &delegation->flags);
85}
86
87static void nfs_mark_return_delegation(struct nfs_server *server,
88 struct nfs_delegation *delegation)
89{
90 set_bit(nr: NFS_DELEGATION_RETURN, addr: &delegation->flags);
91 set_bit(NFS4SERV_DELEGRETURN, addr: &server->delegation_flags);
92 set_bit(nr: NFS4CLNT_DELEGRETURN, addr: &server->nfs_client->cl_state);
93}
94
95static bool nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
96 fmode_t type)
97{
98 if (delegation != NULL && (delegation->type & type) == type &&
99 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
100 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
101 return true;
102 return false;
103}
104
105struct nfs_delegation *nfs4_get_valid_delegation(const struct inode *inode)
106{
107 struct nfs_delegation *delegation;
108
109 delegation = rcu_dereference(NFS_I(inode)->delegation);
110 if (nfs4_is_valid_delegation(delegation, type: 0))
111 return delegation;
112 return NULL;
113}
114
115static int nfs4_do_check_delegation(struct inode *inode, fmode_t type,
116 int flags, bool mark)
117{
118 struct nfs_delegation *delegation;
119 int ret = 0;
120
121 type &= FMODE_READ|FMODE_WRITE;
122 rcu_read_lock();
123 delegation = rcu_dereference(NFS_I(inode)->delegation);
124 if (nfs4_is_valid_delegation(delegation, type)) {
125 if (mark)
126 nfs_mark_delegation_referenced(delegation);
127 ret = 1;
128 if ((flags & NFS_DELEGATION_FLAG_TIME) &&
129 !test_bit(NFS_DELEGATION_DELEGTIME, &delegation->flags))
130 ret = 0;
131 }
132 rcu_read_unlock();
133 return ret;
134}
135/**
136 * nfs4_have_delegation - check if inode has a delegation, mark it
137 * NFS_DELEGATION_REFERENCED if there is one.
138 * @inode: inode to check
139 * @type: delegation types to check for
140 * @flags: various modifiers
141 *
142 * Returns one if inode has the indicated delegation, otherwise zero.
143 */
144int nfs4_have_delegation(struct inode *inode, fmode_t type, int flags)
145{
146 return nfs4_do_check_delegation(inode, type, flags, mark: true);
147}
148
149/*
150 * nfs4_check_delegation - check if inode has a delegation, do not mark
151 * NFS_DELEGATION_REFERENCED if it has one.
152 */
153int nfs4_check_delegation(struct inode *inode, fmode_t type)
154{
155 return nfs4_do_check_delegation(inode, type, flags: 0, mark: false);
156}
157
158static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_stateid *stateid)
159{
160 struct inode *inode = state->inode;
161 struct file_lock *fl;
162 struct file_lock_context *flctx = locks_inode_context(inode);
163 struct list_head *list;
164 int status = 0;
165
166 if (flctx == NULL)
167 goto out;
168
169 list = &flctx->flc_posix;
170 spin_lock(lock: &flctx->flc_lock);
171restart:
172 for_each_file_lock(fl, list) {
173 if (nfs_file_open_context(filp: fl->c.flc_file)->state != state)
174 continue;
175 spin_unlock(lock: &flctx->flc_lock);
176 status = nfs4_lock_delegation_recall(fl, state, stateid);
177 if (status < 0)
178 goto out;
179 spin_lock(lock: &flctx->flc_lock);
180 }
181 if (list == &flctx->flc_posix) {
182 list = &flctx->flc_flock;
183 goto restart;
184 }
185 spin_unlock(lock: &flctx->flc_lock);
186out:
187 return status;
188}
189
190static int nfs_delegation_claim_opens(struct inode *inode,
191 const nfs4_stateid *stateid, fmode_t type)
192{
193 struct nfs_inode *nfsi = NFS_I(inode);
194 struct nfs_open_context *ctx;
195 struct nfs4_state_owner *sp;
196 struct nfs4_state *state;
197 int err;
198
199again:
200 rcu_read_lock();
201 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
202 state = ctx->state;
203 if (state == NULL)
204 continue;
205 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
206 continue;
207 if (!nfs4_valid_open_stateid(state))
208 continue;
209 if (!nfs4_stateid_match(dst: &state->stateid, src: stateid))
210 continue;
211 if (!get_nfs_open_context(ctx))
212 continue;
213 rcu_read_unlock();
214 sp = state->owner;
215 /* Block nfs4_proc_unlck */
216 mutex_lock(lock: &sp->so_delegreturn_mutex);
217 err = nfs4_open_delegation_recall(ctx, state, stateid);
218 if (!err)
219 err = nfs_delegation_claim_locks(state, stateid);
220 mutex_unlock(lock: &sp->so_delegreturn_mutex);
221 put_nfs_open_context(ctx);
222 if (err != 0)
223 return err;
224 goto again;
225 }
226 rcu_read_unlock();
227 return 0;
228}
229
230/**
231 * nfs_inode_reclaim_delegation - process a delegation reclaim request
232 * @inode: inode to process
233 * @cred: credential to use for request
234 * @type: delegation type
235 * @stateid: delegation stateid
236 * @pagemod_limit: write delegation "space_limit"
237 * @deleg_type: raw delegation type
238 *
239 */
240void nfs_inode_reclaim_delegation(struct inode *inode, const struct cred *cred,
241 fmode_t type, const nfs4_stateid *stateid,
242 unsigned long pagemod_limit, u32 deleg_type)
243{
244 struct nfs_delegation *delegation;
245 const struct cred *oldcred = NULL;
246
247 rcu_read_lock();
248 delegation = rcu_dereference(NFS_I(inode)->delegation);
249 if (!delegation) {
250 rcu_read_unlock();
251 nfs_inode_set_delegation(inode, cred, type, stateid,
252 pagemod_limit, deleg_type);
253 return;
254 }
255
256 spin_lock(lock: &delegation->lock);
257 nfs4_stateid_copy(dst: &delegation->stateid, src: stateid);
258 delegation->type = type;
259 delegation->pagemod_limit = pagemod_limit;
260 oldcred = delegation->cred;
261 delegation->cred = get_cred(cred);
262 switch (deleg_type) {
263 case NFS4_OPEN_DELEGATE_READ_ATTRS_DELEG:
264 case NFS4_OPEN_DELEGATE_WRITE_ATTRS_DELEG:
265 set_bit(nr: NFS_DELEGATION_DELEGTIME, addr: &delegation->flags);
266 break;
267 default:
268 clear_bit(nr: NFS_DELEGATION_DELEGTIME, addr: &delegation->flags);
269 }
270 clear_bit(nr: NFS_DELEGATION_NEED_RECLAIM, addr: &delegation->flags);
271 if (test_and_clear_bit(nr: NFS_DELEGATION_REVOKED, addr: &delegation->flags))
272 atomic_long_inc(v: &NFS_SERVER(inode)->nr_active_delegations);
273 spin_unlock(lock: &delegation->lock);
274 rcu_read_unlock();
275 put_cred(cred: oldcred);
276 trace_nfs4_reclaim_delegation(inode, fmode: type);
277}
278
279static int nfs_do_return_delegation(struct inode *inode,
280 struct nfs_delegation *delegation,
281 int issync)
282{
283 const struct cred *cred;
284 int res = 0;
285
286 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
287 spin_lock(lock: &delegation->lock);
288 cred = get_cred(cred: delegation->cred);
289 spin_unlock(lock: &delegation->lock);
290 res = nfs4_proc_delegreturn(inode, cred, stateid: &delegation->stateid,
291 delegation, issync);
292 put_cred(cred);
293 }
294 return res;
295}
296
297static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
298{
299 struct inode *inode = NULL;
300
301 spin_lock(lock: &delegation->lock);
302 if (delegation->inode != NULL)
303 inode = igrab(delegation->inode);
304 if (!inode)
305 set_bit(nr: NFS_DELEGATION_INODE_FREEING, addr: &delegation->flags);
306 spin_unlock(lock: &delegation->lock);
307 return inode;
308}
309
310static struct nfs_delegation *
311nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
312{
313 struct nfs_delegation *ret = NULL;
314 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
315
316 if (delegation == NULL)
317 goto out;
318 spin_lock(lock: &delegation->lock);
319 if (delegation->inode &&
320 !test_and_set_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags)) {
321 clear_bit(nr: NFS_DELEGATION_RETURN_DELAYED, addr: &delegation->flags);
322 /* Refcount matched in nfs_end_delegation_return() */
323 ret = nfs_get_delegation(delegation);
324 }
325 spin_unlock(lock: &delegation->lock);
326 if (ret)
327 nfs_clear_verifier_delegated(inode: &nfsi->vfs_inode);
328out:
329 return ret;
330}
331
332static struct nfs_delegation *
333nfs_start_delegation_return(struct nfs_inode *nfsi)
334{
335 struct nfs_delegation *delegation;
336
337 rcu_read_lock();
338 delegation = nfs_start_delegation_return_locked(nfsi);
339 rcu_read_unlock();
340 return delegation;
341}
342
343static void nfs_abort_delegation_return(struct nfs_delegation *delegation,
344 struct nfs_server *server, int err)
345{
346 spin_lock(lock: &delegation->lock);
347 clear_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags);
348 if (err == -EAGAIN) {
349 set_bit(nr: NFS_DELEGATION_RETURN_DELAYED, addr: &delegation->flags);
350 set_bit(NFS4SERV_DELEGRETURN_DELAYED,
351 addr: &server->delegation_flags);
352 set_bit(nr: NFS4CLNT_DELEGRETURN_DELAYED,
353 addr: &server->nfs_client->cl_state);
354 }
355 spin_unlock(lock: &delegation->lock);
356}
357
358static struct nfs_delegation *
359nfs_detach_delegation_locked(struct nfs_inode *nfsi,
360 struct nfs_delegation *delegation,
361 struct nfs_client *clp)
362{
363 struct nfs_delegation *deleg_cur =
364 rcu_dereference_protected(nfsi->delegation,
365 lockdep_is_held(&clp->cl_lock));
366
367 trace_nfs4_detach_delegation(inode: &nfsi->vfs_inode, fmode: delegation->type);
368
369 if (deleg_cur == NULL || delegation != deleg_cur)
370 return NULL;
371
372 spin_lock(lock: &delegation->lock);
373 if (!delegation->inode) {
374 spin_unlock(lock: &delegation->lock);
375 return NULL;
376 }
377 hlist_del_init_rcu(n: &delegation->hash);
378 list_del_rcu(entry: &delegation->super_list);
379 delegation->inode = NULL;
380 rcu_assign_pointer(nfsi->delegation, NULL);
381 spin_unlock(lock: &delegation->lock);
382 return delegation;
383}
384
385static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
386 struct nfs_delegation *delegation,
387 struct nfs_server *server)
388{
389 struct nfs_client *clp = server->nfs_client;
390
391 spin_lock(lock: &clp->cl_lock);
392 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
393 spin_unlock(lock: &clp->cl_lock);
394 return delegation;
395}
396
397static struct nfs_delegation *
398nfs_inode_detach_delegation(struct inode *inode)
399{
400 struct nfs_inode *nfsi = NFS_I(inode);
401 struct nfs_server *server = NFS_SERVER(inode);
402 struct nfs_delegation *delegation;
403
404 rcu_read_lock();
405 delegation = rcu_dereference(nfsi->delegation);
406 if (delegation != NULL)
407 delegation = nfs_detach_delegation(nfsi, delegation, server);
408 rcu_read_unlock();
409 return delegation;
410}
411
412static void
413nfs_update_delegation_cred(struct nfs_delegation *delegation,
414 const struct cred *cred)
415{
416 const struct cred *old;
417
418 if (cred_fscmp(delegation->cred, cred) != 0) {
419 old = xchg(&delegation->cred, get_cred(cred));
420 put_cred(cred: old);
421 }
422}
423
424static void
425nfs_update_inplace_delegation(struct nfs_server *server,
426 struct nfs_delegation *delegation,
427 const struct nfs_delegation *update)
428{
429 if (nfs4_stateid_is_newer(s1: &update->stateid, s2: &delegation->stateid)) {
430 delegation->stateid.seqid = update->stateid.seqid;
431 smp_wmb();
432 delegation->type = update->type;
433 delegation->pagemod_limit = update->pagemod_limit;
434 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
435 delegation->change_attr = update->change_attr;
436 nfs_update_delegation_cred(delegation, cred: update->cred);
437 /* smp_mb__before_atomic() is implicit due to xchg() */
438 clear_bit(nr: NFS_DELEGATION_REVOKED, addr: &delegation->flags);
439 atomic_long_inc(v: &server->nr_active_delegations);
440 }
441 }
442}
443
444/**
445 * nfs_inode_set_delegation - set up a delegation on an inode
446 * @inode: inode to which delegation applies
447 * @cred: cred to use for subsequent delegation processing
448 * @type: delegation type
449 * @stateid: delegation stateid
450 * @pagemod_limit: write delegation "space_limit"
451 * @deleg_type: raw delegation type
452 *
453 * Returns zero on success, or a negative errno value.
454 */
455int nfs_inode_set_delegation(struct inode *inode, const struct cred *cred,
456 fmode_t type, const nfs4_stateid *stateid,
457 unsigned long pagemod_limit, u32 deleg_type)
458{
459 struct nfs_server *server = NFS_SERVER(inode);
460 struct nfs_client *clp = server->nfs_client;
461 struct nfs_inode *nfsi = NFS_I(inode);
462 struct nfs_delegation *delegation, *old_delegation;
463 struct nfs_delegation *freeme = NULL;
464 int status = 0;
465
466 delegation = kmalloc(sizeof(*delegation), GFP_KERNEL_ACCOUNT);
467 if (delegation == NULL)
468 return -ENOMEM;
469 nfs4_stateid_copy(dst: &delegation->stateid, src: stateid);
470 refcount_set(r: &delegation->refcount, n: 1);
471 delegation->type = type;
472 delegation->pagemod_limit = pagemod_limit;
473 delegation->change_attr = inode_peek_iversion_raw(inode);
474 delegation->cred = get_cred(cred);
475 delegation->inode = inode;
476 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
477 switch (deleg_type) {
478 case NFS4_OPEN_DELEGATE_READ_ATTRS_DELEG:
479 case NFS4_OPEN_DELEGATE_WRITE_ATTRS_DELEG:
480 delegation->flags |= BIT(NFS_DELEGATION_DELEGTIME);
481 }
482 delegation->test_gen = 0;
483 spin_lock_init(&delegation->lock);
484
485 spin_lock(lock: &clp->cl_lock);
486 old_delegation = rcu_dereference_protected(nfsi->delegation,
487 lockdep_is_held(&clp->cl_lock));
488 if (old_delegation == NULL)
489 goto add_new;
490 /* Is this an update of the existing delegation? */
491 if (nfs4_stateid_match_other(dst: &old_delegation->stateid,
492 src: &delegation->stateid)) {
493 spin_lock(lock: &old_delegation->lock);
494 nfs_update_inplace_delegation(server, delegation: old_delegation,
495 update: delegation);
496 spin_unlock(lock: &old_delegation->lock);
497 goto out;
498 }
499 if (!test_bit(NFS_DELEGATION_REVOKED, &old_delegation->flags)) {
500 /*
501 * Deal with broken servers that hand out two
502 * delegations for the same file.
503 * Allow for upgrades to a WRITE delegation, but
504 * nothing else.
505 */
506 dfprintk(FILE, "%s: server %s handed out "
507 "a duplicate delegation!\n",
508 __func__, clp->cl_hostname);
509 if (delegation->type == old_delegation->type ||
510 !(delegation->type & FMODE_WRITE)) {
511 freeme = delegation;
512 delegation = NULL;
513 goto out;
514 }
515 if (test_and_set_bit(nr: NFS_DELEGATION_RETURNING,
516 addr: &old_delegation->flags))
517 goto out;
518 }
519 freeme = nfs_detach_delegation_locked(nfsi, delegation: old_delegation, clp);
520 if (freeme == NULL)
521 goto out;
522add_new:
523 /*
524 * If we didn't revalidate the change attribute before setting
525 * the delegation, then pre-emptively ask for a full attribute
526 * cache revalidation.
527 */
528 spin_lock(lock: &inode->i_lock);
529 if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_CHANGE)
530 nfs_set_cache_invalid(inode,
531 NFS_INO_INVALID_ATIME | NFS_INO_INVALID_CTIME |
532 NFS_INO_INVALID_MTIME | NFS_INO_INVALID_SIZE |
533 NFS_INO_INVALID_BLOCKS | NFS_INO_INVALID_NLINK |
534 NFS_INO_INVALID_OTHER | NFS_INO_INVALID_DATA |
535 NFS_INO_INVALID_ACCESS | NFS_INO_INVALID_ACL |
536 NFS_INO_INVALID_XATTR);
537 spin_unlock(lock: &inode->i_lock);
538
539 list_add_tail_rcu(new: &delegation->super_list, head: &server->delegations);
540 hlist_add_head_rcu(n: &delegation->hash,
541 h: nfs_delegation_hash(server, fhandle: &NFS_I(inode)->fh));
542 rcu_assign_pointer(nfsi->delegation, delegation);
543 delegation = NULL;
544
545 atomic_long_inc(v: &server->nr_active_delegations);
546
547 trace_nfs4_set_delegation(inode, fmode: type);
548
549 /* If we hold writebacks and have delegated mtime then update */
550 if (deleg_type == NFS4_OPEN_DELEGATE_WRITE_ATTRS_DELEG &&
551 nfs_have_writebacks(inode))
552 nfs_update_delegated_mtime(inode);
553out:
554 spin_unlock(lock: &clp->cl_lock);
555 if (delegation != NULL)
556 __nfs_free_delegation(delegation);
557 if (freeme != NULL) {
558 nfs_do_return_delegation(inode, delegation: freeme, issync: 0);
559 nfs_free_delegation(server, delegation: freeme);
560 }
561 return status;
562}
563
564/*
565 * Basic procedure for returning a delegation to the server
566 */
567static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
568{
569 struct nfs_server *server = NFS_SERVER(inode);
570 unsigned int mode = O_WRONLY | O_RDWR;
571 int err = 0;
572
573 if (delegation == NULL)
574 return 0;
575
576 if (!issync)
577 mode |= O_NONBLOCK;
578 /* Recall of any remaining application leases */
579 err = break_lease(inode, mode);
580
581 while (err == 0) {
582 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
583 break;
584 err = nfs_delegation_claim_opens(inode, stateid: &delegation->stateid,
585 type: delegation->type);
586 if (!issync || err != -EAGAIN)
587 break;
588 /*
589 * Guard against state recovery
590 */
591 err = nfs4_wait_clnt_recover(clp: server->nfs_client);
592 }
593
594 if (err) {
595 nfs_abort_delegation_return(delegation, server, err);
596 goto out;
597 }
598
599 err = nfs_do_return_delegation(inode, delegation, issync);
600out:
601 /* Refcount matched in nfs_start_delegation_return_locked() */
602 nfs_put_delegation(delegation);
603 return err;
604}
605
606static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
607{
608 bool ret = false;
609
610 trace_nfs_delegation_need_return(delegation);
611
612 if (test_and_clear_bit(nr: NFS_DELEGATION_RETURN, addr: &delegation->flags))
613 ret = true;
614 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags) ||
615 test_bit(NFS_DELEGATION_RETURN_DELAYED, &delegation->flags) ||
616 test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
617 ret = false;
618
619 return ret;
620}
621
622static int nfs_server_return_marked_delegations(struct nfs_server *server,
623 void __always_unused *data)
624{
625 struct nfs_delegation *delegation;
626 struct nfs_delegation *prev;
627 struct inode *inode;
628 struct inode *place_holder = NULL;
629 struct nfs_delegation *place_holder_deleg = NULL;
630 int err = 0;
631
632 if (!test_and_clear_bit(NFS4SERV_DELEGRETURN,
633 addr: &server->delegation_flags))
634 return 0;
635restart:
636 /*
637 * To avoid quadratic looping we hold a reference
638 * to an inode place_holder. Each time we restart, we
639 * list delegation in the server from the delegations
640 * of that inode.
641 * prev is an RCU-protected pointer to a delegation which
642 * wasn't marked for return and might be a good choice for
643 * the next place_holder.
644 */
645 prev = NULL;
646 delegation = NULL;
647 rcu_read_lock();
648 if (place_holder)
649 delegation = rcu_dereference(NFS_I(place_holder)->delegation);
650 if (!delegation || delegation != place_holder_deleg)
651 delegation = list_entry_rcu(server->delegations.next,
652 struct nfs_delegation, super_list);
653 list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
654 struct inode *to_put = NULL;
655
656 if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags))
657 continue;
658 if (!nfs_delegation_need_return(delegation)) {
659 if (nfs4_is_valid_delegation(delegation, type: 0))
660 prev = delegation;
661 continue;
662 }
663 inode = nfs_delegation_grab_inode(delegation);
664 if (inode == NULL)
665 continue;
666
667 if (prev) {
668 struct inode *tmp = nfs_delegation_grab_inode(delegation: prev);
669 if (tmp) {
670 to_put = place_holder;
671 place_holder = tmp;
672 place_holder_deleg = prev;
673 }
674 }
675
676 delegation = nfs_start_delegation_return_locked(nfsi: NFS_I(inode));
677 rcu_read_unlock();
678
679 iput(to_put);
680
681 err = nfs_end_delegation_return(inode, delegation, issync: 0);
682 iput(inode);
683 cond_resched();
684 if (!err)
685 goto restart;
686 set_bit(NFS4SERV_DELEGRETURN, addr: &server->delegation_flags);
687 set_bit(nr: NFS4CLNT_DELEGRETURN, addr: &server->nfs_client->cl_state);
688 goto out;
689 }
690 rcu_read_unlock();
691out:
692 iput(place_holder);
693 return err;
694}
695
696static bool nfs_server_clear_delayed_delegations(struct nfs_server *server)
697{
698 struct nfs_delegation *d;
699 bool ret = false;
700
701 if (!test_and_clear_bit(NFS4SERV_DELEGRETURN_DELAYED,
702 addr: &server->delegation_flags))
703 goto out;
704 list_for_each_entry_rcu (d, &server->delegations, super_list) {
705 if (!test_bit(NFS_DELEGATION_RETURN_DELAYED, &d->flags))
706 continue;
707 nfs_mark_return_delegation(server, delegation: d);
708 clear_bit(nr: NFS_DELEGATION_RETURN_DELAYED, addr: &d->flags);
709 ret = true;
710 }
711out:
712 return ret;
713}
714
715static bool nfs_client_clear_delayed_delegations(struct nfs_client *clp)
716{
717 struct nfs_server *server;
718 bool ret = false;
719
720 if (!test_and_clear_bit(nr: NFS4CLNT_DELEGRETURN_DELAYED, addr: &clp->cl_state))
721 goto out;
722 rcu_read_lock();
723 list_for_each_entry_rcu (server, &clp->cl_superblocks, client_link) {
724 if (nfs_server_clear_delayed_delegations(server))
725 ret = true;
726 }
727 rcu_read_unlock();
728out:
729 return ret;
730}
731
732/**
733 * nfs_client_return_marked_delegations - return previously marked delegations
734 * @clp: nfs_client to process
735 *
736 * Note that this function is designed to be called by the state
737 * manager thread. For this reason, it cannot flush the dirty data,
738 * since that could deadlock in case of a state recovery error.
739 *
740 * Returns zero on success, or a negative errno value.
741 */
742int nfs_client_return_marked_delegations(struct nfs_client *clp)
743{
744 int err = nfs_client_for_each_server(
745 clp, fn: nfs_server_return_marked_delegations, NULL);
746 if (err)
747 return err;
748 /* If a return was delayed, sleep to prevent hard looping */
749 if (nfs_client_clear_delayed_delegations(clp))
750 ssleep(seconds: 1);
751 return 0;
752}
753
754/**
755 * nfs_inode_evict_delegation - return delegation, don't reclaim opens
756 * @inode: inode to process
757 *
758 * Does not protect against delegation reclaims, therefore really only safe
759 * to be called from nfs4_clear_inode(). Guaranteed to always free
760 * the delegation structure.
761 */
762void nfs_inode_evict_delegation(struct inode *inode)
763{
764 struct nfs_delegation *delegation;
765
766 delegation = nfs_inode_detach_delegation(inode);
767 if (delegation != NULL) {
768 set_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags);
769 set_bit(nr: NFS_DELEGATION_INODE_FREEING, addr: &delegation->flags);
770 nfs_do_return_delegation(inode, delegation, issync: 1);
771 nfs_free_delegation(server: NFS_SERVER(inode), delegation);
772 }
773}
774
775/**
776 * nfs4_inode_return_delegation - synchronously return a delegation
777 * @inode: inode to process
778 *
779 * This routine will always flush any dirty data to disk on the
780 * assumption that if we need to return the delegation, then
781 * we should stop caching.
782 *
783 * Returns zero on success, or a negative errno value.
784 */
785int nfs4_inode_return_delegation(struct inode *inode)
786{
787 struct nfs_inode *nfsi = NFS_I(inode);
788 struct nfs_delegation *delegation;
789
790 delegation = nfs_start_delegation_return(nfsi);
791 if (delegation != NULL) {
792 /* Synchronous recall of any application leases */
793 break_lease(inode, O_WRONLY | O_RDWR);
794 if (S_ISREG(inode->i_mode))
795 nfs_wb_all(inode);
796 return nfs_end_delegation_return(inode, delegation, issync: 1);
797 }
798 return 0;
799}
800
801/**
802 * nfs4_inode_set_return_delegation_on_close - asynchronously return a delegation
803 * @inode: inode to process
804 *
805 * This routine is called to request that the delegation be returned as soon
806 * as the file is closed. If the file is already closed, the delegation is
807 * immediately returned.
808 */
809void nfs4_inode_set_return_delegation_on_close(struct inode *inode)
810{
811 struct nfs_delegation *delegation;
812 struct nfs_delegation *ret = NULL;
813
814 if (!inode)
815 return;
816 rcu_read_lock();
817 delegation = nfs4_get_valid_delegation(inode);
818 if (!delegation)
819 goto out;
820 spin_lock(lock: &delegation->lock);
821 if (!delegation->inode)
822 goto out_unlock;
823 if (list_empty(head: &NFS_I(inode)->open_files) &&
824 !test_and_set_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags)) {
825 /* Refcount matched in nfs_end_delegation_return() */
826 ret = nfs_get_delegation(delegation);
827 } else
828 set_bit(nr: NFS_DELEGATION_RETURN_IF_CLOSED, addr: &delegation->flags);
829out_unlock:
830 spin_unlock(lock: &delegation->lock);
831 if (ret)
832 nfs_clear_verifier_delegated(inode);
833out:
834 rcu_read_unlock();
835 nfs_end_delegation_return(inode, delegation: ret, issync: 0);
836}
837
838/**
839 * nfs4_inode_return_delegation_on_close - asynchronously return a delegation
840 * @inode: inode to process
841 *
842 * This routine is called on file close in order to determine if the
843 * inode delegation needs to be returned immediately.
844 */
845void nfs4_inode_return_delegation_on_close(struct inode *inode)
846{
847 struct nfs_delegation *delegation;
848 struct nfs_delegation *ret = NULL;
849
850 if (!inode)
851 return;
852 rcu_read_lock();
853 delegation = nfs4_get_valid_delegation(inode);
854 if (!delegation)
855 goto out;
856 if (test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) ||
857 atomic_long_read(v: &NFS_SERVER(inode)->nr_active_delegations) >=
858 nfs_delegation_watermark) {
859 spin_lock(lock: &delegation->lock);
860 if (delegation->inode &&
861 list_empty(head: &NFS_I(inode)->open_files) &&
862 !test_and_set_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags)) {
863 clear_bit(nr: NFS_DELEGATION_RETURN_IF_CLOSED, addr: &delegation->flags);
864 /* Refcount matched in nfs_end_delegation_return() */
865 ret = nfs_get_delegation(delegation);
866 }
867 spin_unlock(lock: &delegation->lock);
868 if (ret)
869 nfs_clear_verifier_delegated(inode);
870 }
871out:
872 rcu_read_unlock();
873 nfs_end_delegation_return(inode, delegation: ret, issync: 0);
874}
875
876/**
877 * nfs4_inode_make_writeable
878 * @inode: pointer to inode
879 *
880 * Make the inode writeable by returning the delegation if necessary
881 *
882 * Returns zero on success, or a negative errno value.
883 */
884int nfs4_inode_make_writeable(struct inode *inode)
885{
886 struct nfs_delegation *delegation;
887
888 rcu_read_lock();
889 delegation = nfs4_get_valid_delegation(inode);
890 if (delegation == NULL ||
891 (nfs4_has_session(clp: NFS_SERVER(inode)->nfs_client) &&
892 (delegation->type & FMODE_WRITE))) {
893 rcu_read_unlock();
894 return 0;
895 }
896 rcu_read_unlock();
897 return nfs4_inode_return_delegation(inode);
898}
899
900static void
901nfs_mark_return_if_closed_delegation(struct nfs_server *server,
902 struct nfs_delegation *delegation)
903{
904 struct inode *inode;
905
906 if (test_bit(NFS_DELEGATION_RETURN, &delegation->flags) ||
907 test_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags))
908 return;
909 spin_lock(lock: &delegation->lock);
910 inode = delegation->inode;
911 if (!inode)
912 goto out;
913 if (list_empty(head: &NFS_I(inode)->open_files))
914 nfs_mark_return_delegation(server, delegation);
915 else
916 set_bit(nr: NFS_DELEGATION_RETURN_IF_CLOSED, addr: &delegation->flags);
917out:
918 spin_unlock(lock: &delegation->lock);
919}
920
921static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
922{
923 struct nfs_delegation *delegation;
924 bool ret = false;
925
926 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
927 nfs_mark_return_delegation(server, delegation);
928 ret = true;
929 }
930 return ret;
931}
932
933static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
934{
935 struct nfs_server *server;
936
937 rcu_read_lock();
938 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
939 nfs_server_mark_return_all_delegations(server);
940 rcu_read_unlock();
941}
942
943static void nfs_delegation_run_state_manager(struct nfs_client *clp)
944{
945 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
946 nfs4_schedule_state_manager(clp);
947}
948
949/**
950 * nfs_expire_all_delegations
951 * @clp: client to process
952 *
953 */
954void nfs_expire_all_delegations(struct nfs_client *clp)
955{
956 nfs_client_mark_return_all_delegations(clp);
957 nfs_delegation_run_state_manager(clp);
958}
959
960/**
961 * nfs_server_return_all_delegations - return delegations for one superblock
962 * @server: pointer to nfs_server to process
963 *
964 */
965void nfs_server_return_all_delegations(struct nfs_server *server)
966{
967 struct nfs_client *clp = server->nfs_client;
968 bool need_wait;
969
970 if (clp == NULL)
971 return;
972
973 rcu_read_lock();
974 need_wait = nfs_server_mark_return_all_delegations(server);
975 rcu_read_unlock();
976
977 if (need_wait) {
978 nfs4_schedule_state_manager(clp);
979 nfs4_wait_clnt_recover(clp);
980 }
981}
982
983static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
984 fmode_t flags)
985{
986 struct nfs_delegation *delegation;
987
988 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
989 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
990 continue;
991 if (delegation->type & flags)
992 nfs_mark_return_if_closed_delegation(server, delegation);
993 }
994}
995
996static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
997 fmode_t flags)
998{
999 struct nfs_server *server;
1000
1001 rcu_read_lock();
1002 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1003 nfs_mark_return_unused_delegation_types(server, flags);
1004 rcu_read_unlock();
1005}
1006
1007static void nfs_revoke_delegation(struct inode *inode,
1008 const nfs4_stateid *stateid)
1009{
1010 struct nfs_delegation *delegation;
1011 nfs4_stateid tmp;
1012 bool ret = false;
1013
1014 rcu_read_lock();
1015 delegation = rcu_dereference(NFS_I(inode)->delegation);
1016 if (delegation == NULL)
1017 goto out;
1018 if (stateid == NULL) {
1019 nfs4_stateid_copy(dst: &tmp, src: &delegation->stateid);
1020 stateid = &tmp;
1021 } else {
1022 if (!nfs4_stateid_match_other(dst: stateid, src: &delegation->stateid))
1023 goto out;
1024 spin_lock(lock: &delegation->lock);
1025 if (stateid->seqid) {
1026 if (nfs4_stateid_is_newer(s1: &delegation->stateid, s2: stateid)) {
1027 spin_unlock(lock: &delegation->lock);
1028 goto out;
1029 }
1030 delegation->stateid.seqid = stateid->seqid;
1031 }
1032 spin_unlock(lock: &delegation->lock);
1033 }
1034 nfs_mark_delegation_revoked(server: NFS_SERVER(inode), delegation);
1035 ret = true;
1036out:
1037 rcu_read_unlock();
1038 if (ret)
1039 nfs_inode_find_state_and_recover(inode, stateid);
1040}
1041
1042void nfs_delegation_mark_returned(struct inode *inode,
1043 const nfs4_stateid *stateid)
1044{
1045 struct nfs_delegation *delegation;
1046
1047 if (!inode)
1048 return;
1049
1050 rcu_read_lock();
1051 delegation = rcu_dereference(NFS_I(inode)->delegation);
1052 if (!delegation)
1053 goto out_rcu_unlock;
1054
1055 spin_lock(lock: &delegation->lock);
1056 if (!nfs4_stateid_match_other(dst: stateid, src: &delegation->stateid))
1057 goto out_spin_unlock;
1058 if (stateid->seqid) {
1059 /* If delegation->stateid is newer, dont mark as returned */
1060 if (nfs4_stateid_is_newer(s1: &delegation->stateid, s2: stateid))
1061 goto out_clear_returning;
1062 if (delegation->stateid.seqid != stateid->seqid)
1063 delegation->stateid.seqid = stateid->seqid;
1064 }
1065
1066 nfs_mark_delegation_revoked(server: NFS_SERVER(inode), delegation);
1067 clear_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags);
1068 spin_unlock(lock: &delegation->lock);
1069 if (nfs_detach_delegation(nfsi: NFS_I(inode), delegation, server: NFS_SERVER(inode)))
1070 nfs_put_delegation(delegation);
1071 goto out_rcu_unlock;
1072
1073out_clear_returning:
1074 clear_bit(nr: NFS_DELEGATION_RETURNING, addr: &delegation->flags);
1075out_spin_unlock:
1076 spin_unlock(lock: &delegation->lock);
1077out_rcu_unlock:
1078 rcu_read_unlock();
1079
1080 nfs_inode_find_state_and_recover(inode, stateid);
1081}
1082
1083/**
1084 * nfs_remove_bad_delegation - handle delegations that are unusable
1085 * @inode: inode to process
1086 * @stateid: the delegation's stateid
1087 *
1088 * If the server ACK-ed our FREE_STATEID then clean
1089 * up the delegation, else mark and keep the revoked state.
1090 */
1091void nfs_remove_bad_delegation(struct inode *inode,
1092 const nfs4_stateid *stateid)
1093{
1094 if (stateid && stateid->type == NFS4_FREED_STATEID_TYPE)
1095 nfs_delegation_mark_returned(inode, stateid);
1096 else
1097 nfs_revoke_delegation(inode, stateid);
1098}
1099EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
1100
1101/**
1102 * nfs_expire_unused_delegation_types
1103 * @clp: client to process
1104 * @flags: delegation types to expire
1105 *
1106 */
1107void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
1108{
1109 nfs_client_mark_return_unused_delegation_types(clp, flags);
1110 nfs_delegation_run_state_manager(clp);
1111}
1112
1113static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
1114{
1115 struct nfs_delegation *delegation;
1116
1117 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1118 if (test_and_clear_bit(nr: NFS_DELEGATION_REFERENCED, addr: &delegation->flags))
1119 continue;
1120 nfs_mark_return_if_closed_delegation(server, delegation);
1121 }
1122}
1123
1124/**
1125 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
1126 * @clp: nfs_client to process
1127 *
1128 */
1129void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
1130{
1131 struct nfs_server *server;
1132
1133 rcu_read_lock();
1134 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1135 nfs_mark_return_unreferenced_delegations(server);
1136 rcu_read_unlock();
1137
1138 nfs_delegation_run_state_manager(clp);
1139}
1140
1141/**
1142 * nfs_async_inode_return_delegation - asynchronously return a delegation
1143 * @inode: inode to process
1144 * @stateid: state ID information
1145 *
1146 * Returns zero on success, or a negative errno value.
1147 */
1148int nfs_async_inode_return_delegation(struct inode *inode,
1149 const nfs4_stateid *stateid)
1150{
1151 struct nfs_server *server = NFS_SERVER(inode);
1152 struct nfs_client *clp = server->nfs_client;
1153 struct nfs_delegation *delegation;
1154
1155 rcu_read_lock();
1156 delegation = nfs4_get_valid_delegation(inode);
1157 if (delegation == NULL)
1158 goto out_enoent;
1159 if (stateid != NULL &&
1160 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
1161 goto out_enoent;
1162 nfs_mark_return_delegation(server, delegation);
1163 rcu_read_unlock();
1164
1165 /* If there are any application leases or delegations, recall them */
1166 break_lease(inode, O_WRONLY | O_RDWR | O_NONBLOCK);
1167
1168 nfs_delegation_run_state_manager(clp);
1169 return 0;
1170out_enoent:
1171 rcu_read_unlock();
1172 return -ENOENT;
1173}
1174
1175static struct inode *
1176nfs_delegation_find_inode_server(struct nfs_server *server,
1177 const struct nfs_fh *fhandle)
1178{
1179 struct hlist_head *head = nfs_delegation_hash(server, fhandle);
1180 struct nfs_delegation *delegation;
1181 struct super_block *freeme = NULL;
1182 struct inode *res = NULL;
1183
1184 hlist_for_each_entry_rcu(delegation, head, hash) {
1185 spin_lock(lock: &delegation->lock);
1186 if (delegation->inode != NULL &&
1187 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
1188 nfs_compare_fh(a: fhandle, b: &NFS_I(inode: delegation->inode)->fh) == 0) {
1189 if (nfs_sb_active(sb: server->super)) {
1190 freeme = server->super;
1191 res = igrab(delegation->inode);
1192 }
1193 spin_unlock(lock: &delegation->lock);
1194 if (res != NULL)
1195 return res;
1196 if (freeme) {
1197 rcu_read_unlock();
1198 nfs_sb_deactive(sb: freeme);
1199 rcu_read_lock();
1200 }
1201 return ERR_PTR(error: -EAGAIN);
1202 }
1203 spin_unlock(lock: &delegation->lock);
1204 }
1205 return ERR_PTR(error: -ENOENT);
1206}
1207
1208/**
1209 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
1210 * @clp: client state handle
1211 * @fhandle: filehandle from a delegation recall
1212 *
1213 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
1214 * cannot be found.
1215 */
1216struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
1217 const struct nfs_fh *fhandle)
1218{
1219 struct nfs_server *server;
1220 struct inode *res;
1221
1222 rcu_read_lock();
1223 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1224 res = nfs_delegation_find_inode_server(server, fhandle);
1225 if (res != ERR_PTR(error: -ENOENT)) {
1226 rcu_read_unlock();
1227 return res;
1228 }
1229 }
1230 rcu_read_unlock();
1231 return ERR_PTR(error: -ENOENT);
1232}
1233
1234static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
1235{
1236 struct nfs_delegation *delegation;
1237
1238 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1239 /*
1240 * If the delegation may have been admin revoked, then we
1241 * cannot reclaim it.
1242 */
1243 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
1244 continue;
1245 set_bit(nr: NFS_DELEGATION_NEED_RECLAIM, addr: &delegation->flags);
1246 }
1247}
1248
1249/**
1250 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
1251 * @clp: nfs_client to process
1252 *
1253 */
1254void nfs_delegation_mark_reclaim(struct nfs_client *clp)
1255{
1256 struct nfs_server *server;
1257
1258 rcu_read_lock();
1259 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1260 nfs_delegation_mark_reclaim_server(server);
1261 rcu_read_unlock();
1262}
1263
1264static int nfs_server_reap_unclaimed_delegations(struct nfs_server *server,
1265 void __always_unused *data)
1266{
1267 struct nfs_delegation *delegation;
1268 struct inode *inode;
1269restart:
1270 rcu_read_lock();
1271 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1272 if (test_bit(NFS_DELEGATION_INODE_FREEING,
1273 &delegation->flags) ||
1274 test_bit(NFS_DELEGATION_RETURNING,
1275 &delegation->flags) ||
1276 test_bit(NFS_DELEGATION_NEED_RECLAIM,
1277 &delegation->flags) == 0)
1278 continue;
1279 inode = nfs_delegation_grab_inode(delegation);
1280 if (inode == NULL)
1281 continue;
1282 delegation = nfs_start_delegation_return_locked(nfsi: NFS_I(inode));
1283 rcu_read_unlock();
1284 if (delegation != NULL) {
1285 if (nfs_detach_delegation(nfsi: NFS_I(inode), delegation,
1286 server) != NULL)
1287 nfs_free_delegation(server, delegation);
1288 /* Match nfs_start_delegation_return_locked */
1289 nfs_put_delegation(delegation);
1290 }
1291 iput(inode);
1292 cond_resched();
1293 goto restart;
1294 }
1295 rcu_read_unlock();
1296 return 0;
1297}
1298
1299/**
1300 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
1301 * @clp: nfs_client to process
1302 *
1303 */
1304void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
1305{
1306 nfs_client_for_each_server(clp, fn: nfs_server_reap_unclaimed_delegations,
1307 NULL);
1308}
1309
1310static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
1311{
1312 return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
1313 BIT(NFS4CLNT_LEASE_EXPIRED) |
1314 BIT(NFS4CLNT_SESSION_RESET))) != 0;
1315}
1316
1317static void nfs_mark_test_expired_delegation(struct nfs_server *server,
1318 struct nfs_delegation *delegation)
1319{
1320 if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
1321 return;
1322 clear_bit(nr: NFS_DELEGATION_NEED_RECLAIM, addr: &delegation->flags);
1323 set_bit(nr: NFS_DELEGATION_TEST_EXPIRED, addr: &delegation->flags);
1324 set_bit(NFS4SERV_DELEGATION_EXPIRED, addr: &server->delegation_flags);
1325 set_bit(nr: NFS4CLNT_DELEGATION_EXPIRED, addr: &server->nfs_client->cl_state);
1326}
1327
1328static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
1329 struct inode *inode)
1330{
1331 struct nfs_delegation *delegation;
1332
1333 rcu_read_lock();
1334 delegation = rcu_dereference(NFS_I(inode)->delegation);
1335 if (delegation)
1336 nfs_mark_test_expired_delegation(server, delegation);
1337 rcu_read_unlock();
1338
1339}
1340
1341static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
1342{
1343 struct nfs_delegation *delegation;
1344
1345 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
1346 nfs_mark_test_expired_delegation(server, delegation);
1347}
1348
1349/**
1350 * nfs_mark_test_expired_all_delegations - mark all delegations for testing
1351 * @clp: nfs_client to process
1352 *
1353 * Iterates through all the delegations associated with this server and
1354 * marks them as needing to be checked for validity.
1355 */
1356void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
1357{
1358 struct nfs_server *server;
1359
1360 rcu_read_lock();
1361 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1362 nfs_delegation_mark_test_expired_server(server);
1363 rcu_read_unlock();
1364}
1365
1366/**
1367 * nfs_test_expired_all_delegations - test all delegations for a client
1368 * @clp: nfs_client to process
1369 *
1370 * Helper for handling "recallable state revoked" status from server.
1371 */
1372void nfs_test_expired_all_delegations(struct nfs_client *clp)
1373{
1374 nfs_mark_test_expired_all_delegations(clp);
1375 nfs4_schedule_state_manager(clp);
1376}
1377
1378static void
1379nfs_delegation_test_free_expired(struct inode *inode,
1380 nfs4_stateid *stateid,
1381 const struct cred *cred)
1382{
1383 struct nfs_server *server = NFS_SERVER(inode);
1384 const struct nfs4_minor_version_ops *ops = server->nfs_client->cl_mvops;
1385 int status;
1386
1387 if (!cred)
1388 return;
1389 status = ops->test_and_free_expired(server, stateid, cred);
1390 if (status == -NFS4ERR_EXPIRED || status == -NFS4ERR_BAD_STATEID)
1391 nfs_remove_bad_delegation(inode, stateid);
1392}
1393
1394static int nfs_server_reap_expired_delegations(struct nfs_server *server,
1395 void __always_unused *data)
1396{
1397 struct nfs_delegation *delegation;
1398 struct inode *inode;
1399 const struct cred *cred;
1400 nfs4_stateid stateid;
1401 unsigned long gen = ++server->delegation_gen;
1402
1403 if (!test_and_clear_bit(NFS4SERV_DELEGATION_EXPIRED,
1404 addr: &server->delegation_flags))
1405 return 0;
1406restart:
1407 rcu_read_lock();
1408 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
1409 if (test_bit(NFS_DELEGATION_INODE_FREEING,
1410 &delegation->flags) ||
1411 test_bit(NFS_DELEGATION_RETURNING,
1412 &delegation->flags) ||
1413 test_bit(NFS_DELEGATION_TEST_EXPIRED,
1414 &delegation->flags) == 0 ||
1415 delegation->test_gen == gen)
1416 continue;
1417 inode = nfs_delegation_grab_inode(delegation);
1418 if (inode == NULL)
1419 continue;
1420 spin_lock(lock: &delegation->lock);
1421 cred = get_cred_rcu(cred: delegation->cred);
1422 nfs4_stateid_copy(dst: &stateid, src: &delegation->stateid);
1423 spin_unlock(lock: &delegation->lock);
1424 delegation->test_gen = gen;
1425 clear_bit(nr: NFS_DELEGATION_TEST_EXPIRED, addr: &delegation->flags);
1426 rcu_read_unlock();
1427 nfs_delegation_test_free_expired(inode, stateid: &stateid, cred);
1428 put_cred(cred);
1429 if (!nfs4_server_rebooted(clp: server->nfs_client)) {
1430 iput(inode);
1431 cond_resched();
1432 goto restart;
1433 }
1434 nfs_inode_mark_test_expired_delegation(server,inode);
1435 set_bit(NFS4SERV_DELEGATION_EXPIRED, addr: &server->delegation_flags);
1436 set_bit(nr: NFS4CLNT_DELEGATION_EXPIRED,
1437 addr: &server->nfs_client->cl_state);
1438 iput(inode);
1439 return -EAGAIN;
1440 }
1441 rcu_read_unlock();
1442 return 0;
1443}
1444
1445/**
1446 * nfs_reap_expired_delegations - reap expired delegations
1447 * @clp: nfs_client to process
1448 *
1449 * Iterates through all the delegations associated with this server and
1450 * checks if they have may have been revoked. This function is usually
1451 * expected to be called in cases where the server may have lost its
1452 * lease.
1453 */
1454void nfs_reap_expired_delegations(struct nfs_client *clp)
1455{
1456 nfs_client_for_each_server(clp, fn: nfs_server_reap_expired_delegations,
1457 NULL);
1458}
1459
1460void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1461 const nfs4_stateid *stateid)
1462{
1463 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1464 struct nfs_delegation *delegation;
1465 bool found = false;
1466
1467 rcu_read_lock();
1468 delegation = rcu_dereference(NFS_I(inode)->delegation);
1469 if (delegation &&
1470 nfs4_stateid_match_or_older(dst: &delegation->stateid, src: stateid) &&
1471 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
1472 nfs_mark_test_expired_delegation(server: NFS_SERVER(inode), delegation);
1473 found = true;
1474 }
1475 rcu_read_unlock();
1476 if (found)
1477 nfs4_schedule_state_manager(clp);
1478}
1479
1480/**
1481 * nfs_delegations_present - check for existence of delegations
1482 * @clp: client state handle
1483 *
1484 * Returns one if there are any nfs_delegation structures attached
1485 * to this nfs_client.
1486 */
1487int nfs_delegations_present(struct nfs_client *clp)
1488{
1489 struct nfs_server *server;
1490 int ret = 0;
1491
1492 rcu_read_lock();
1493 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1494 if (!list_empty(head: &server->delegations)) {
1495 ret = 1;
1496 break;
1497 }
1498 rcu_read_unlock();
1499 return ret;
1500}
1501
1502/**
1503 * nfs4_refresh_delegation_stateid - Update delegation stateid seqid
1504 * @dst: stateid to refresh
1505 * @inode: inode to check
1506 *
1507 * Returns "true" and updates "dst->seqid" * if inode had a delegation
1508 * that matches our delegation stateid. Otherwise "false" is returned.
1509 */
1510bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
1511{
1512 struct nfs_delegation *delegation;
1513 bool ret = false;
1514 if (!inode)
1515 goto out;
1516
1517 rcu_read_lock();
1518 delegation = rcu_dereference(NFS_I(inode)->delegation);
1519 if (delegation != NULL &&
1520 nfs4_stateid_match_other(dst, src: &delegation->stateid) &&
1521 nfs4_stateid_is_newer(s1: &delegation->stateid, s2: dst) &&
1522 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags)) {
1523 dst->seqid = delegation->stateid.seqid;
1524 ret = true;
1525 }
1526 rcu_read_unlock();
1527out:
1528 return ret;
1529}
1530
1531/**
1532 * nfs4_copy_delegation_stateid - Copy inode's state ID information
1533 * @inode: inode to check
1534 * @flags: delegation type requirement
1535 * @dst: stateid data structure to fill in
1536 * @cred: optional argument to retrieve credential
1537 *
1538 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1539 * otherwise "false" is returned.
1540 */
1541bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1542 nfs4_stateid *dst, const struct cred **cred)
1543{
1544 struct nfs_inode *nfsi = NFS_I(inode);
1545 struct nfs_delegation *delegation;
1546 bool ret = false;
1547
1548 flags &= FMODE_READ|FMODE_WRITE;
1549 rcu_read_lock();
1550 delegation = rcu_dereference(nfsi->delegation);
1551 if (!delegation)
1552 goto out;
1553 spin_lock(lock: &delegation->lock);
1554 ret = nfs4_is_valid_delegation(delegation, type: flags);
1555 if (ret) {
1556 nfs4_stateid_copy(dst, src: &delegation->stateid);
1557 nfs_mark_delegation_referenced(delegation);
1558 if (cred)
1559 *cred = get_cred(cred: delegation->cred);
1560 }
1561 spin_unlock(lock: &delegation->lock);
1562out:
1563 rcu_read_unlock();
1564 return ret;
1565}
1566
1567/**
1568 * nfs4_delegation_flush_on_close - Check if we must flush file on close
1569 * @inode: inode to check
1570 *
1571 * This function checks the number of outstanding writes to the file
1572 * against the delegation 'space_limit' field to see if
1573 * the spec requires us to flush the file on close.
1574 */
1575bool nfs4_delegation_flush_on_close(const struct inode *inode)
1576{
1577 struct nfs_inode *nfsi = NFS_I(inode);
1578 struct nfs_delegation *delegation;
1579 bool ret = true;
1580
1581 rcu_read_lock();
1582 delegation = rcu_dereference(nfsi->delegation);
1583 if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1584 goto out;
1585 if (atomic_long_read(v: &nfsi->nrequests) < delegation->pagemod_limit)
1586 ret = false;
1587out:
1588 rcu_read_unlock();
1589 return ret;
1590}
1591
1592int nfs4_delegation_hash_alloc(struct nfs_server *server)
1593{
1594 int delegation_buckets, i;
1595
1596 delegation_buckets = roundup_pow_of_two(nfs_delegation_watermark / 16);
1597 server->delegation_hash_mask = delegation_buckets - 1;
1598 server->delegation_hash_table = kmalloc_array(delegation_buckets,
1599 sizeof(*server->delegation_hash_table), GFP_KERNEL);
1600 if (!server->delegation_hash_table)
1601 return -ENOMEM;
1602 for (i = 0; i < delegation_buckets; i++)
1603 INIT_HLIST_HEAD(&server->delegation_hash_table[i]);
1604 return 0;
1605}
1606