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