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