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

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

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

~ [ 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