GNU Linux-libre 4.19.211-gnu1
[releases.git] / fs / nfs / delegation.c
1 /*
2  * linux/fs/nfs/delegation.c
3  *
4  * Copyright (C) 2004 Trond Myklebust
5  *
6  * NFS file delegation management
7  *
8  */
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>
15 #include <linux/iversion.h>
16
17 #include <linux/nfs4.h>
18 #include <linux/nfs_fs.h>
19 #include <linux/nfs_xdr.h>
20
21 #include "nfs4_fs.h"
22 #include "nfs4session.h"
23 #include "delegation.h"
24 #include "internal.h"
25 #include "nfs4trace.h"
26
27 static void nfs_free_delegation(struct nfs_delegation *delegation)
28 {
29         if (delegation->cred) {
30                 put_rpccred(delegation->cred);
31                 delegation->cred = NULL;
32         }
33         kfree_rcu(delegation, rcu);
34 }
35
36 /**
37  * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
38  * @delegation: delegation to process
39  *
40  */
41 void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
42 {
43         set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
44 }
45
46 static bool
47 nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
48                 fmode_t flags)
49 {
50         if (delegation != NULL && (delegation->type & flags) == flags &&
51             !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
52             !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
53                 return true;
54         return false;
55 }
56
57 struct nfs_delegation *nfs4_get_valid_delegation(const struct inode *inode)
58 {
59         struct nfs_delegation *delegation;
60
61         delegation = rcu_dereference(NFS_I(inode)->delegation);
62         if (nfs4_is_valid_delegation(delegation, 0))
63                 return delegation;
64         return NULL;
65 }
66
67 static int
68 nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
69 {
70         struct nfs_delegation *delegation;
71         int ret = 0;
72
73         flags &= FMODE_READ|FMODE_WRITE;
74         rcu_read_lock();
75         delegation = rcu_dereference(NFS_I(inode)->delegation);
76         if (nfs4_is_valid_delegation(delegation, flags)) {
77                 if (mark)
78                         nfs_mark_delegation_referenced(delegation);
79                 ret = 1;
80         }
81         rcu_read_unlock();
82         return ret;
83 }
84 /**
85  * nfs_have_delegation - check if inode has a delegation, mark it
86  * NFS_DELEGATION_REFERENCED if there is one.
87  * @inode: inode to check
88  * @flags: delegation types to check for
89  *
90  * Returns one if inode has the indicated delegation, otherwise zero.
91  */
92 int nfs4_have_delegation(struct inode *inode, fmode_t flags)
93 {
94         return nfs4_do_check_delegation(inode, flags, true);
95 }
96
97 /*
98  * nfs4_check_delegation - check if inode has a delegation, do not mark
99  * NFS_DELEGATION_REFERENCED if it has one.
100  */
101 int nfs4_check_delegation(struct inode *inode, fmode_t flags)
102 {
103         return nfs4_do_check_delegation(inode, flags, false);
104 }
105
106 static int nfs_delegation_claim_locks(struct nfs4_state *state, const nfs4_stateid *stateid)
107 {
108         struct inode *inode = state->inode;
109         struct file_lock *fl;
110         struct file_lock_context *flctx = inode->i_flctx;
111         struct list_head *list;
112         int status = 0;
113
114         if (flctx == NULL)
115                 goto out;
116
117         list = &flctx->flc_posix;
118         spin_lock(&flctx->flc_lock);
119 restart:
120         list_for_each_entry(fl, list, fl_list) {
121                 if (nfs_file_open_context(fl->fl_file)->state != state)
122                         continue;
123                 spin_unlock(&flctx->flc_lock);
124                 status = nfs4_lock_delegation_recall(fl, state, stateid);
125                 if (status < 0)
126                         goto out;
127                 spin_lock(&flctx->flc_lock);
128         }
129         if (list == &flctx->flc_posix) {
130                 list = &flctx->flc_flock;
131                 goto restart;
132         }
133         spin_unlock(&flctx->flc_lock);
134 out:
135         return status;
136 }
137
138 static int nfs_delegation_claim_opens(struct inode *inode,
139                 const nfs4_stateid *stateid, fmode_t type)
140 {
141         struct nfs_inode *nfsi = NFS_I(inode);
142         struct nfs_open_context *ctx;
143         struct nfs4_state_owner *sp;
144         struct nfs4_state *state;
145         unsigned int seq;
146         int err;
147
148 again:
149         spin_lock(&inode->i_lock);
150         list_for_each_entry(ctx, &nfsi->open_files, list) {
151                 state = ctx->state;
152                 if (state == NULL)
153                         continue;
154                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
155                         continue;
156                 if (!nfs4_valid_open_stateid(state))
157                         continue;
158                 if (!nfs4_stateid_match(&state->stateid, stateid))
159                         continue;
160                 get_nfs_open_context(ctx);
161                 spin_unlock(&inode->i_lock);
162                 sp = state->owner;
163                 /* Block nfs4_proc_unlck */
164                 mutex_lock(&sp->so_delegreturn_mutex);
165                 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
166                 err = nfs4_open_delegation_recall(ctx, state, stateid);
167                 if (!err)
168                         err = nfs_delegation_claim_locks(state, stateid);
169                 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
170                         err = -EAGAIN;
171                 mutex_unlock(&sp->so_delegreturn_mutex);
172                 put_nfs_open_context(ctx);
173                 if (err != 0)
174                         return err;
175                 goto again;
176         }
177         spin_unlock(&inode->i_lock);
178         return 0;
179 }
180
181 /**
182  * nfs_inode_reclaim_delegation - process a delegation reclaim request
183  * @inode: inode to process
184  * @cred: credential to use for request
185  * @type: delegation type
186  * @stateid: delegation stateid
187  * @pagemod_limit: write delegation "space_limit"
188  *
189  */
190 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
191                                   fmode_t type,
192                                   const nfs4_stateid *stateid,
193                                   unsigned long pagemod_limit)
194 {
195         struct nfs_delegation *delegation;
196         struct rpc_cred *oldcred = NULL;
197
198         rcu_read_lock();
199         delegation = rcu_dereference(NFS_I(inode)->delegation);
200         if (delegation != NULL) {
201                 spin_lock(&delegation->lock);
202                 if (delegation->inode != NULL) {
203                         nfs4_stateid_copy(&delegation->stateid, stateid);
204                         delegation->type = type;
205                         delegation->pagemod_limit = pagemod_limit;
206                         oldcred = delegation->cred;
207                         delegation->cred = get_rpccred(cred);
208                         clear_bit(NFS_DELEGATION_NEED_RECLAIM,
209                                   &delegation->flags);
210                         spin_unlock(&delegation->lock);
211                         rcu_read_unlock();
212                         put_rpccred(oldcred);
213                         trace_nfs4_reclaim_delegation(inode, type);
214                         return;
215                 }
216                 /* We appear to have raced with a delegation return. */
217                 spin_unlock(&delegation->lock);
218         }
219         rcu_read_unlock();
220         nfs_inode_set_delegation(inode, cred, type, stateid, pagemod_limit);
221 }
222
223 static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
224 {
225         int res = 0;
226
227         if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
228                 res = nfs4_proc_delegreturn(inode,
229                                 delegation->cred,
230                                 &delegation->stateid,
231                                 issync);
232         nfs_free_delegation(delegation);
233         return res;
234 }
235
236 static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
237 {
238         struct inode *inode = NULL;
239
240         spin_lock(&delegation->lock);
241         if (delegation->inode != NULL)
242                 inode = igrab(delegation->inode);
243         if (!inode)
244                 set_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags);
245         spin_unlock(&delegation->lock);
246         return inode;
247 }
248
249 static struct nfs_delegation *
250 nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
251 {
252         struct nfs_delegation *ret = NULL;
253         struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
254
255         if (delegation == NULL)
256                 goto out;
257         spin_lock(&delegation->lock);
258         if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
259                 ret = delegation;
260         spin_unlock(&delegation->lock);
261 out:
262         return ret;
263 }
264
265 static struct nfs_delegation *
266 nfs_start_delegation_return(struct nfs_inode *nfsi)
267 {
268         struct nfs_delegation *delegation;
269
270         rcu_read_lock();
271         delegation = nfs_start_delegation_return_locked(nfsi);
272         rcu_read_unlock();
273         return delegation;
274 }
275
276 static void
277 nfs_abort_delegation_return(struct nfs_delegation *delegation,
278                 struct nfs_client *clp)
279 {
280
281         spin_lock(&delegation->lock);
282         clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
283         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
284         spin_unlock(&delegation->lock);
285         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
286 }
287
288 static struct nfs_delegation *
289 nfs_detach_delegation_locked(struct nfs_inode *nfsi,
290                 struct nfs_delegation *delegation,
291                 struct nfs_client *clp)
292 {
293         struct nfs_delegation *deleg_cur =
294                 rcu_dereference_protected(nfsi->delegation,
295                                 lockdep_is_held(&clp->cl_lock));
296
297         if (deleg_cur == NULL || delegation != deleg_cur)
298                 return NULL;
299
300         spin_lock(&delegation->lock);
301         set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
302         list_del_rcu(&delegation->super_list);
303         delegation->inode = NULL;
304         rcu_assign_pointer(nfsi->delegation, NULL);
305         spin_unlock(&delegation->lock);
306         return delegation;
307 }
308
309 static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
310                 struct nfs_delegation *delegation,
311                 struct nfs_server *server)
312 {
313         struct nfs_client *clp = server->nfs_client;
314
315         spin_lock(&clp->cl_lock);
316         delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
317         spin_unlock(&clp->cl_lock);
318         return delegation;
319 }
320
321 static struct nfs_delegation *
322 nfs_inode_detach_delegation(struct inode *inode)
323 {
324         struct nfs_inode *nfsi = NFS_I(inode);
325         struct nfs_server *server = NFS_SERVER(inode);
326         struct nfs_delegation *delegation;
327
328         delegation = nfs_start_delegation_return(nfsi);
329         if (delegation == NULL)
330                 return NULL;
331         return nfs_detach_delegation(nfsi, delegation, server);
332 }
333
334 static void
335 nfs_update_inplace_delegation(struct nfs_delegation *delegation,
336                 const struct nfs_delegation *update)
337 {
338         if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
339                 delegation->stateid.seqid = update->stateid.seqid;
340                 smp_wmb();
341                 delegation->type = update->type;
342         }
343 }
344
345 /**
346  * nfs_inode_set_delegation - set up a delegation on an inode
347  * @inode: inode to which delegation applies
348  * @cred: cred to use for subsequent delegation processing
349  * @type: delegation type
350  * @stateid: delegation stateid
351  * @pagemod_limit: write delegation "space_limit"
352  *
353  * Returns zero on success, or a negative errno value.
354  */
355 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred,
356                                   fmode_t type,
357                                   const nfs4_stateid *stateid,
358                                   unsigned long pagemod_limit)
359 {
360         struct nfs_server *server = NFS_SERVER(inode);
361         struct nfs_client *clp = server->nfs_client;
362         struct nfs_inode *nfsi = NFS_I(inode);
363         struct nfs_delegation *delegation, *old_delegation;
364         struct nfs_delegation *freeme = NULL;
365         int status = 0;
366
367         delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
368         if (delegation == NULL)
369                 return -ENOMEM;
370         nfs4_stateid_copy(&delegation->stateid, stateid);
371         delegation->type = type;
372         delegation->pagemod_limit = pagemod_limit;
373         delegation->change_attr = inode_peek_iversion_raw(inode);
374         delegation->cred = get_rpccred(cred);
375         delegation->inode = inode;
376         delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
377         spin_lock_init(&delegation->lock);
378
379         spin_lock(&clp->cl_lock);
380         old_delegation = rcu_dereference_protected(nfsi->delegation,
381                                         lockdep_is_held(&clp->cl_lock));
382         if (old_delegation != NULL) {
383                 /* Is this an update of the existing delegation? */
384                 if (nfs4_stateid_match_other(&old_delegation->stateid,
385                                         &delegation->stateid)) {
386                         nfs_update_inplace_delegation(old_delegation,
387                                         delegation);
388                         goto out;
389                 }
390                 /*
391                  * Deal with broken servers that hand out two
392                  * delegations for the same file.
393                  * Allow for upgrades to a WRITE delegation, but
394                  * nothing else.
395                  */
396                 dfprintk(FILE, "%s: server %s handed out "
397                                 "a duplicate delegation!\n",
398                                 __func__, clp->cl_hostname);
399                 if (delegation->type == old_delegation->type ||
400                     !(delegation->type & FMODE_WRITE)) {
401                         freeme = delegation;
402                         delegation = NULL;
403                         goto out;
404                 }
405                 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
406                                         &old_delegation->flags))
407                         goto out;
408                 freeme = nfs_detach_delegation_locked(nfsi,
409                                 old_delegation, clp);
410                 if (freeme == NULL)
411                         goto out;
412         }
413         list_add_tail_rcu(&delegation->super_list, &server->delegations);
414         rcu_assign_pointer(nfsi->delegation, delegation);
415         delegation = NULL;
416
417         trace_nfs4_set_delegation(inode, type);
418
419         spin_lock(&inode->i_lock);
420         if (NFS_I(inode)->cache_validity & (NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME))
421                 NFS_I(inode)->cache_validity |= NFS_INO_REVAL_FORCED;
422         spin_unlock(&inode->i_lock);
423 out:
424         spin_unlock(&clp->cl_lock);
425         if (delegation != NULL)
426                 nfs_free_delegation(delegation);
427         if (freeme != NULL)
428                 nfs_do_return_delegation(inode, freeme, 0);
429         return status;
430 }
431
432 /*
433  * Basic procedure for returning a delegation to the server
434  */
435 static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
436 {
437         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
438         struct nfs_inode *nfsi = NFS_I(inode);
439         int err = 0;
440
441         if (delegation == NULL)
442                 return 0;
443         do {
444                 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
445                         break;
446                 err = nfs_delegation_claim_opens(inode, &delegation->stateid,
447                                 delegation->type);
448                 if (!issync || err != -EAGAIN)
449                         break;
450                 /*
451                  * Guard against state recovery
452                  */
453                 err = nfs4_wait_clnt_recover(clp);
454         } while (err == 0);
455
456         if (err) {
457                 nfs_abort_delegation_return(delegation, clp);
458                 goto out;
459         }
460         if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
461                 goto out;
462
463         err = nfs_do_return_delegation(inode, delegation, issync);
464 out:
465         return err;
466 }
467
468 static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
469 {
470         bool ret = false;
471
472         if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
473                 goto out;
474         if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
475                 ret = true;
476         if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
477                 struct inode *inode;
478
479                 spin_lock(&delegation->lock);
480                 inode = delegation->inode;
481                 if (inode && list_empty(&NFS_I(inode)->open_files))
482                         ret = true;
483                 spin_unlock(&delegation->lock);
484         }
485 out:
486         return ret;
487 }
488
489 /**
490  * nfs_client_return_marked_delegations - return previously marked delegations
491  * @clp: nfs_client to process
492  *
493  * Note that this function is designed to be called by the state
494  * manager thread. For this reason, it cannot flush the dirty data,
495  * since that could deadlock in case of a state recovery error.
496  *
497  * Returns zero on success, or a negative errno value.
498  */
499 int nfs_client_return_marked_delegations(struct nfs_client *clp)
500 {
501         struct nfs_delegation *delegation;
502         struct nfs_delegation *prev;
503         struct nfs_server *server;
504         struct inode *inode;
505         struct inode *place_holder = NULL;
506         struct nfs_delegation *place_holder_deleg = NULL;
507         int err = 0;
508
509 restart:
510         /*
511          * To avoid quadratic looping we hold a reference
512          * to an inode place_holder.  Each time we restart, we
513          * list nfs_servers from the server of that inode, and
514          * delegation in the server from the delegations of that
515          * inode.
516          * prev is an RCU-protected pointer to a delegation which
517          * wasn't marked for return and might be a good choice for
518          * the next place_holder.
519          */
520         rcu_read_lock();
521         prev = NULL;
522         if (place_holder)
523                 server = NFS_SERVER(place_holder);
524         else
525                 server = list_entry_rcu(clp->cl_superblocks.next,
526                                         struct nfs_server, client_link);
527         list_for_each_entry_from_rcu(server, &clp->cl_superblocks, client_link) {
528                 delegation = NULL;
529                 if (place_holder && server == NFS_SERVER(place_holder))
530                         delegation = rcu_dereference(NFS_I(place_holder)->delegation);
531                 if (!delegation || delegation != place_holder_deleg)
532                         delegation = list_entry_rcu(server->delegations.next,
533                                                     struct nfs_delegation, super_list);
534                 list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
535                         struct inode *to_put = NULL;
536
537                         if (!nfs_delegation_need_return(delegation)) {
538                                 prev = delegation;
539                                 continue;
540                         }
541                         if (!nfs_sb_active(server->super))
542                                 break; /* continue in outer loop */
543
544                         if (prev) {
545                                 struct inode *tmp;
546
547                                 tmp = nfs_delegation_grab_inode(prev);
548                                 if (tmp) {
549                                         to_put = place_holder;
550                                         place_holder = tmp;
551                                         place_holder_deleg = prev;
552                                 }
553                         }
554
555                         inode = nfs_delegation_grab_inode(delegation);
556                         if (inode == NULL) {
557                                 rcu_read_unlock();
558                                 if (to_put)
559                                         iput(to_put);
560                                 nfs_sb_deactive(server->super);
561                                 goto restart;
562                         }
563                         delegation = nfs_start_delegation_return_locked(NFS_I(inode));
564                         rcu_read_unlock();
565
566                         if (to_put)
567                                 iput(to_put);
568
569                         err = nfs_end_delegation_return(inode, delegation, 0);
570                         iput(inode);
571                         nfs_sb_deactive(server->super);
572                         cond_resched();
573                         if (!err)
574                                 goto restart;
575                         set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
576                         if (place_holder)
577                                 iput(place_holder);
578                         return err;
579                 }
580         }
581         rcu_read_unlock();
582         if (place_holder)
583                 iput(place_holder);
584         return 0;
585 }
586
587 /**
588  * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
589  * @inode: inode to process
590  *
591  * Does not protect against delegation reclaims, therefore really only safe
592  * to be called from nfs4_clear_inode().
593  */
594 void nfs_inode_return_delegation_noreclaim(struct inode *inode)
595 {
596         struct nfs_delegation *delegation;
597
598         delegation = nfs_inode_detach_delegation(inode);
599         if (delegation != NULL)
600                 nfs_do_return_delegation(inode, delegation, 1);
601 }
602
603 /**
604  * nfs_inode_return_delegation - synchronously return a delegation
605  * @inode: inode to process
606  *
607  * This routine will always flush any dirty data to disk on the
608  * assumption that if we need to return the delegation, then
609  * we should stop caching.
610  *
611  * Returns zero on success, or a negative errno value.
612  */
613 int nfs4_inode_return_delegation(struct inode *inode)
614 {
615         struct nfs_inode *nfsi = NFS_I(inode);
616         struct nfs_delegation *delegation;
617         int err = 0;
618
619         nfs_wb_all(inode);
620         delegation = nfs_start_delegation_return(nfsi);
621         if (delegation != NULL)
622                 err = nfs_end_delegation_return(inode, delegation, 1);
623         return err;
624 }
625
626 /**
627  * nfs4_inode_make_writeable
628  * @inode: pointer to inode
629  *
630  * Make the inode writeable by returning the delegation if necessary
631  *
632  * Returns zero on success, or a negative errno value.
633  */
634 int nfs4_inode_make_writeable(struct inode *inode)
635 {
636         if (!nfs4_has_session(NFS_SERVER(inode)->nfs_client) ||
637             !nfs4_check_delegation(inode, FMODE_WRITE))
638                 return nfs4_inode_return_delegation(inode);
639         return 0;
640 }
641
642 static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
643                 struct nfs_delegation *delegation)
644 {
645         set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
646         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
647 }
648
649 static void nfs_mark_return_delegation(struct nfs_server *server,
650                 struct nfs_delegation *delegation)
651 {
652         set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
653         set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
654 }
655
656 static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
657 {
658         struct nfs_delegation *delegation;
659         bool ret = false;
660
661         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
662                 nfs_mark_return_delegation(server, delegation);
663                 ret = true;
664         }
665         return ret;
666 }
667
668 static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
669 {
670         struct nfs_server *server;
671
672         rcu_read_lock();
673         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
674                 nfs_server_mark_return_all_delegations(server);
675         rcu_read_unlock();
676 }
677
678 static void nfs_delegation_run_state_manager(struct nfs_client *clp)
679 {
680         if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
681                 nfs4_schedule_state_manager(clp);
682 }
683
684 /**
685  * nfs_expire_all_delegations
686  * @clp: client to process
687  *
688  */
689 void nfs_expire_all_delegations(struct nfs_client *clp)
690 {
691         nfs_client_mark_return_all_delegations(clp);
692         nfs_delegation_run_state_manager(clp);
693 }
694
695 /**
696  * nfs_super_return_all_delegations - return delegations for one superblock
697  * @sb: sb to process
698  *
699  */
700 void nfs_server_return_all_delegations(struct nfs_server *server)
701 {
702         struct nfs_client *clp = server->nfs_client;
703         bool need_wait;
704
705         if (clp == NULL)
706                 return;
707
708         rcu_read_lock();
709         need_wait = nfs_server_mark_return_all_delegations(server);
710         rcu_read_unlock();
711
712         if (need_wait) {
713                 nfs4_schedule_state_manager(clp);
714                 nfs4_wait_clnt_recover(clp);
715         }
716 }
717
718 static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
719                                                  fmode_t flags)
720 {
721         struct nfs_delegation *delegation;
722
723         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
724                 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
725                         continue;
726                 if (delegation->type & flags)
727                         nfs_mark_return_if_closed_delegation(server, delegation);
728         }
729 }
730
731 static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
732                                                         fmode_t flags)
733 {
734         struct nfs_server *server;
735
736         rcu_read_lock();
737         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
738                 nfs_mark_return_unused_delegation_types(server, flags);
739         rcu_read_unlock();
740 }
741
742 static void nfs_mark_delegation_revoked(struct nfs_server *server,
743                 struct nfs_delegation *delegation)
744 {
745         set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
746         delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
747         nfs_mark_return_delegation(server, delegation);
748 }
749
750 static bool nfs_revoke_delegation(struct inode *inode,
751                 const nfs4_stateid *stateid)
752 {
753         struct nfs_delegation *delegation;
754         nfs4_stateid tmp;
755         bool ret = false;
756
757         rcu_read_lock();
758         delegation = rcu_dereference(NFS_I(inode)->delegation);
759         if (delegation == NULL)
760                 goto out;
761         if (stateid == NULL) {
762                 nfs4_stateid_copy(&tmp, &delegation->stateid);
763                 stateid = &tmp;
764         } else if (!nfs4_stateid_match(stateid, &delegation->stateid))
765                 goto out;
766         nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
767         ret = true;
768 out:
769         rcu_read_unlock();
770         if (ret)
771                 nfs_inode_find_state_and_recover(inode, stateid);
772         return ret;
773 }
774
775 void nfs_remove_bad_delegation(struct inode *inode,
776                 const nfs4_stateid *stateid)
777 {
778         struct nfs_delegation *delegation;
779
780         if (!nfs_revoke_delegation(inode, stateid))
781                 return;
782         delegation = nfs_inode_detach_delegation(inode);
783         if (delegation)
784                 nfs_free_delegation(delegation);
785 }
786 EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
787
788 /**
789  * nfs_expire_unused_delegation_types
790  * @clp: client to process
791  * @flags: delegation types to expire
792  *
793  */
794 void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
795 {
796         nfs_client_mark_return_unused_delegation_types(clp, flags);
797         nfs_delegation_run_state_manager(clp);
798 }
799
800 static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
801 {
802         struct nfs_delegation *delegation;
803
804         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
805                 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
806                         continue;
807                 nfs_mark_return_if_closed_delegation(server, delegation);
808         }
809 }
810
811 /**
812  * nfs_expire_unreferenced_delegations - Eliminate unused delegations
813  * @clp: nfs_client to process
814  *
815  */
816 void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
817 {
818         struct nfs_server *server;
819
820         rcu_read_lock();
821         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
822                 nfs_mark_return_unreferenced_delegations(server);
823         rcu_read_unlock();
824
825         nfs_delegation_run_state_manager(clp);
826 }
827
828 /**
829  * nfs_async_inode_return_delegation - asynchronously return a delegation
830  * @inode: inode to process
831  * @stateid: state ID information
832  *
833  * Returns zero on success, or a negative errno value.
834  */
835 int nfs_async_inode_return_delegation(struct inode *inode,
836                                       const nfs4_stateid *stateid)
837 {
838         struct nfs_server *server = NFS_SERVER(inode);
839         struct nfs_client *clp = server->nfs_client;
840         struct nfs_delegation *delegation;
841
842         rcu_read_lock();
843         delegation = rcu_dereference(NFS_I(inode)->delegation);
844         if (delegation == NULL)
845                 goto out_enoent;
846         if (stateid != NULL &&
847             !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
848                 goto out_enoent;
849         nfs_mark_return_delegation(server, delegation);
850         rcu_read_unlock();
851
852         nfs_delegation_run_state_manager(clp);
853         return 0;
854 out_enoent:
855         rcu_read_unlock();
856         return -ENOENT;
857 }
858
859 static struct inode *
860 nfs_delegation_find_inode_server(struct nfs_server *server,
861                                  const struct nfs_fh *fhandle)
862 {
863         struct nfs_delegation *delegation;
864         struct inode *freeme, *res = NULL;
865
866         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
867                 spin_lock(&delegation->lock);
868                 if (delegation->inode != NULL &&
869                     nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
870                         freeme = igrab(delegation->inode);
871                         if (freeme && nfs_sb_active(freeme->i_sb))
872                                 res = freeme;
873                         spin_unlock(&delegation->lock);
874                         if (res != NULL)
875                                 return res;
876                         if (freeme) {
877                                 rcu_read_unlock();
878                                 iput(freeme);
879                                 rcu_read_lock();
880                         }
881                         return ERR_PTR(-EAGAIN);
882                 }
883                 spin_unlock(&delegation->lock);
884         }
885         return ERR_PTR(-ENOENT);
886 }
887
888 /**
889  * nfs_delegation_find_inode - retrieve the inode associated with a delegation
890  * @clp: client state handle
891  * @fhandle: filehandle from a delegation recall
892  *
893  * Returns pointer to inode matching "fhandle," or NULL if a matching inode
894  * cannot be found.
895  */
896 struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
897                                         const struct nfs_fh *fhandle)
898 {
899         struct nfs_server *server;
900         struct inode *res;
901
902         rcu_read_lock();
903         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
904                 res = nfs_delegation_find_inode_server(server, fhandle);
905                 if (res != ERR_PTR(-ENOENT)) {
906                         rcu_read_unlock();
907                         return res;
908                 }
909         }
910         rcu_read_unlock();
911         return ERR_PTR(-ENOENT);
912 }
913
914 static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
915 {
916         struct nfs_delegation *delegation;
917
918         list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
919                 /*
920                  * If the delegation may have been admin revoked, then we
921                  * cannot reclaim it.
922                  */
923                 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
924                         continue;
925                 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
926         }
927 }
928
929 /**
930  * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
931  * @clp: nfs_client to process
932  *
933  */
934 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
935 {
936         struct nfs_server *server;
937
938         rcu_read_lock();
939         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
940                 nfs_delegation_mark_reclaim_server(server);
941         rcu_read_unlock();
942 }
943
944 /**
945  * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
946  * @clp: nfs_client to process
947  *
948  */
949 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
950 {
951         struct nfs_delegation *delegation;
952         struct nfs_server *server;
953         struct inode *inode;
954
955 restart:
956         rcu_read_lock();
957         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
958                 list_for_each_entry_rcu(delegation, &server->delegations,
959                                                                 super_list) {
960                         if (test_bit(NFS_DELEGATION_INODE_FREEING,
961                                                 &delegation->flags) ||
962                             test_bit(NFS_DELEGATION_RETURNING,
963                                                 &delegation->flags) ||
964                             test_bit(NFS_DELEGATION_NEED_RECLAIM,
965                                                 &delegation->flags) == 0)
966                                 continue;
967                         if (!nfs_sb_active(server->super))
968                                 break; /* continue in outer loop */
969                         inode = nfs_delegation_grab_inode(delegation);
970                         if (inode == NULL) {
971                                 rcu_read_unlock();
972                                 nfs_sb_deactive(server->super);
973                                 goto restart;
974                         }
975                         delegation = nfs_start_delegation_return_locked(NFS_I(inode));
976                         rcu_read_unlock();
977                         if (delegation != NULL) {
978                                 delegation = nfs_detach_delegation(NFS_I(inode),
979                                         delegation, server);
980                                 if (delegation != NULL)
981                                         nfs_free_delegation(delegation);
982                         }
983                         iput(inode);
984                         nfs_sb_deactive(server->super);
985                         cond_resched();
986                         goto restart;
987                 }
988         }
989         rcu_read_unlock();
990 }
991
992 static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
993 {
994         return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
995                                 BIT(NFS4CLNT_LEASE_EXPIRED) |
996                                 BIT(NFS4CLNT_SESSION_RESET))) != 0;
997 }
998
999 static void nfs_mark_test_expired_delegation(struct nfs_server *server,
1000             struct nfs_delegation *delegation)
1001 {
1002         if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
1003                 return;
1004         clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
1005         set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1006         set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
1007 }
1008
1009 static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
1010                 struct inode *inode)
1011 {
1012         struct nfs_delegation *delegation;
1013
1014         rcu_read_lock();
1015         delegation = rcu_dereference(NFS_I(inode)->delegation);
1016         if (delegation)
1017                 nfs_mark_test_expired_delegation(server, delegation);
1018         rcu_read_unlock();
1019
1020 }
1021
1022 static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
1023 {
1024         struct nfs_delegation *delegation;
1025
1026         list_for_each_entry_rcu(delegation, &server->delegations, super_list)
1027                 nfs_mark_test_expired_delegation(server, delegation);
1028 }
1029
1030 /**
1031  * nfs_mark_test_expired_all_delegations - mark all delegations for testing
1032  * @clp: nfs_client to process
1033  *
1034  * Iterates through all the delegations associated with this server and
1035  * marks them as needing to be checked for validity.
1036  */
1037 void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
1038 {
1039         struct nfs_server *server;
1040
1041         rcu_read_lock();
1042         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1043                 nfs_delegation_mark_test_expired_server(server);
1044         rcu_read_unlock();
1045 }
1046
1047 /**
1048  * nfs_reap_expired_delegations - reap expired delegations
1049  * @clp: nfs_client to process
1050  *
1051  * Iterates through all the delegations associated with this server and
1052  * checks if they have may have been revoked. This function is usually
1053  * expected to be called in cases where the server may have lost its
1054  * lease.
1055  */
1056 void nfs_reap_expired_delegations(struct nfs_client *clp)
1057 {
1058         const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
1059         struct nfs_delegation *delegation;
1060         struct nfs_server *server;
1061         struct inode *inode;
1062         struct rpc_cred *cred;
1063         nfs4_stateid stateid;
1064
1065 restart:
1066         rcu_read_lock();
1067         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1068                 list_for_each_entry_rcu(delegation, &server->delegations,
1069                                                                 super_list) {
1070                         if (test_bit(NFS_DELEGATION_INODE_FREEING,
1071                                                 &delegation->flags) ||
1072                             test_bit(NFS_DELEGATION_RETURNING,
1073                                                 &delegation->flags) ||
1074                             test_bit(NFS_DELEGATION_TEST_EXPIRED,
1075                                                 &delegation->flags) == 0)
1076                                 continue;
1077                         if (!nfs_sb_active(server->super))
1078                                 break; /* continue in outer loop */
1079                         inode = nfs_delegation_grab_inode(delegation);
1080                         if (inode == NULL) {
1081                                 rcu_read_unlock();
1082                                 nfs_sb_deactive(server->super);
1083                                 goto restart;
1084                         }
1085                         cred = get_rpccred_rcu(delegation->cred);
1086                         nfs4_stateid_copy(&stateid, &delegation->stateid);
1087                         clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
1088                         rcu_read_unlock();
1089                         if (cred != NULL &&
1090                             ops->test_and_free_expired(server, &stateid, cred) < 0) {
1091                                 nfs_revoke_delegation(inode, &stateid);
1092                                 nfs_inode_find_state_and_recover(inode, &stateid);
1093                         }
1094                         put_rpccred(cred);
1095                         if (nfs4_server_rebooted(clp)) {
1096                                 nfs_inode_mark_test_expired_delegation(server,inode);
1097                                 iput(inode);
1098                                 nfs_sb_deactive(server->super);
1099                                 return;
1100                         }
1101                         iput(inode);
1102                         nfs_sb_deactive(server->super);
1103                         cond_resched();
1104                         goto restart;
1105                 }
1106         }
1107         rcu_read_unlock();
1108 }
1109
1110 void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1111                 const nfs4_stateid *stateid)
1112 {
1113         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1114         struct nfs_delegation *delegation;
1115         bool found = false;
1116
1117         rcu_read_lock();
1118         delegation = rcu_dereference(NFS_I(inode)->delegation);
1119         if (delegation &&
1120             nfs4_stateid_match_other(&delegation->stateid, stateid)) {
1121                 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1122                 found = true;
1123         }
1124         rcu_read_unlock();
1125         if (found)
1126                 nfs4_schedule_state_manager(clp);
1127 }
1128
1129 /**
1130  * nfs_delegations_present - check for existence of delegations
1131  * @clp: client state handle
1132  *
1133  * Returns one if there are any nfs_delegation structures attached
1134  * to this nfs_client.
1135  */
1136 int nfs_delegations_present(struct nfs_client *clp)
1137 {
1138         struct nfs_server *server;
1139         int ret = 0;
1140
1141         rcu_read_lock();
1142         list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1143                 if (!list_empty(&server->delegations)) {
1144                         ret = 1;
1145                         break;
1146                 }
1147         rcu_read_unlock();
1148         return ret;
1149 }
1150
1151 /**
1152  * nfs4_refresh_delegation_stateid - Update delegation stateid seqid
1153  * @dst: stateid to refresh
1154  * @inode: inode to check
1155  *
1156  * Returns "true" and updates "dst->seqid" * if inode had a delegation
1157  * that matches our delegation stateid. Otherwise "false" is returned.
1158  */
1159 bool nfs4_refresh_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
1160 {
1161         struct nfs_delegation *delegation;
1162         bool ret = false;
1163         if (!inode)
1164                 goto out;
1165
1166         rcu_read_lock();
1167         delegation = rcu_dereference(NFS_I(inode)->delegation);
1168         if (delegation != NULL &&
1169             nfs4_stateid_match_other(dst, &delegation->stateid)) {
1170                 dst->seqid = delegation->stateid.seqid;
1171                 ret = true;
1172         }
1173         rcu_read_unlock();
1174 out:
1175         return ret;
1176 }
1177
1178 /**
1179  * nfs4_copy_delegation_stateid - Copy inode's state ID information
1180  * @inode: inode to check
1181  * @flags: delegation type requirement
1182  * @dst: stateid data structure to fill in
1183  * @cred: optional argument to retrieve credential
1184  *
1185  * Returns "true" and fills in "dst->data" * if inode had a delegation,
1186  * otherwise "false" is returned.
1187  */
1188 bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1189                 nfs4_stateid *dst, struct rpc_cred **cred)
1190 {
1191         struct nfs_inode *nfsi = NFS_I(inode);
1192         struct nfs_delegation *delegation;
1193         bool ret;
1194
1195         flags &= FMODE_READ|FMODE_WRITE;
1196         rcu_read_lock();
1197         delegation = rcu_dereference(nfsi->delegation);
1198         ret = nfs4_is_valid_delegation(delegation, flags);
1199         if (ret) {
1200                 nfs4_stateid_copy(dst, &delegation->stateid);
1201                 nfs_mark_delegation_referenced(delegation);
1202                 if (cred)
1203                         *cred = get_rpccred(delegation->cred);
1204         }
1205         rcu_read_unlock();
1206         return ret;
1207 }
1208
1209 /**
1210  * nfs4_delegation_flush_on_close - Check if we must flush file on close
1211  * @inode: inode to check
1212  *
1213  * This function checks the number of outstanding writes to the file
1214  * against the delegation 'space_limit' field to see if
1215  * the spec requires us to flush the file on close.
1216  */
1217 bool nfs4_delegation_flush_on_close(const struct inode *inode)
1218 {
1219         struct nfs_inode *nfsi = NFS_I(inode);
1220         struct nfs_delegation *delegation;
1221         bool ret = true;
1222
1223         rcu_read_lock();
1224         delegation = rcu_dereference(nfsi->delegation);
1225         if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1226                 goto out;
1227         if (atomic_long_read(&nfsi->nrequests) < delegation->pagemod_limit)
1228                 ret = false;
1229 out:
1230         rcu_read_unlock();
1231         return ret;
1232 }