~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/delegation.c

Version: ~ [ linux-5.9-rc6 ] ~ [ linux-5.8.10 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.66 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.146 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.198 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.236 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.236 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp