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