blob: dff600ae0d7477333a3e41749cffe58ad77c7e3a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * linux/fs/nfs/delegation.c
3 *
4 * Copyright (C) 2004 Trond Myklebust
5 *
6 * NFS file delegation management
7 *
8 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <linux/completion.h>
Trond Myklebust58d97142006-01-03 09:55:24 +010010#include <linux/kthread.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/module.h>
12#include <linux/sched.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090013#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/spinlock.h>
15
16#include <linux/nfs4.h>
17#include <linux/nfs_fs.h>
18#include <linux/nfs_xdr.h>
19
Trond Myklebust4ce79712005-06-22 17:16:21 +000020#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "delegation.h"
David Howells24c8dbb2006-08-22 20:06:10 -040022#include "internal.h"
Trond Myklebustca8acf82013-08-13 10:36:56 -040023#include "nfs4trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Trond Myklebust905f8d12007-08-06 12:18:34 -040025static void nfs_free_delegation(struct nfs_delegation *delegation)
26{
Trond Myklebuste00b8a22011-01-27 14:55:39 -050027 if (delegation->cred) {
28 put_rpccred(delegation->cred);
29 delegation->cred = NULL;
30 }
Lai Jiangshan26f04dd2011-05-01 06:21:54 -070031 kfree_rcu(delegation, rcu);
Trond Myklebust8383e462007-07-06 15:12:04 -040032}
33
Chuck Leverd3978bb2010-12-24 01:33:04 +000034/**
35 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
36 * @delegation: delegation to process
37 *
38 */
Trond Myklebustb7391f42008-12-23 15:21:52 -050039void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
40{
41 set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
42}
43
Trond Myklebustaa05c872016-09-22 13:38:54 -040044static bool
45nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
46 fmode_t flags)
47{
48 if (delegation != NULL && (delegation->type & flags) == flags &&
49 !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
50 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
51 return true;
52 return false;
53}
54
Peng Tao15bb3af2014-07-03 13:05:00 +080055static int
56nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
Trond Myklebustb7391f42008-12-23 15:21:52 -050057{
58 struct nfs_delegation *delegation;
59 int ret = 0;
60
61 flags &= FMODE_READ|FMODE_WRITE;
62 rcu_read_lock();
63 delegation = rcu_dereference(NFS_I(inode)->delegation);
Trond Myklebustaa05c872016-09-22 13:38:54 -040064 if (nfs4_is_valid_delegation(delegation, flags)) {
Peng Tao15bb3af2014-07-03 13:05:00 +080065 if (mark)
66 nfs_mark_delegation_referenced(delegation);
Trond Myklebustb7391f42008-12-23 15:21:52 -050067 ret = 1;
68 }
69 rcu_read_unlock();
70 return ret;
71}
Peng Tao15bb3af2014-07-03 13:05:00 +080072/**
73 * nfs_have_delegation - check if inode has a delegation, mark it
74 * NFS_DELEGATION_REFERENCED if there is one.
75 * @inode: inode to check
76 * @flags: delegation types to check for
77 *
78 * Returns one if inode has the indicated delegation, otherwise zero.
79 */
80int nfs4_have_delegation(struct inode *inode, fmode_t flags)
81{
82 return nfs4_do_check_delegation(inode, flags, true);
83}
84
85/*
86 * nfs4_check_delegation - check if inode has a delegation, do not mark
87 * NFS_DELEGATION_REFERENCED if it has one.
88 */
89int nfs4_check_delegation(struct inode *inode, fmode_t flags)
90{
91 return nfs4_do_check_delegation(inode, flags, false);
92}
Trond Myklebustb7391f42008-12-23 15:21:52 -050093
Trond Myklebustdb4f2e632013-04-01 15:56:46 -040094static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
Trond Myklebust888e6942005-11-04 15:38:11 -050095{
96 struct inode *inode = state->inode;
97 struct file_lock *fl;
Jeff Laytonbd61e0a2015-01-16 15:05:55 -050098 struct file_lock_context *flctx = inode->i_flctx;
99 struct list_head *list;
Trond Myklebustd5122202009-06-17 13:22:58 -0700100 int status = 0;
Trond Myklebust888e6942005-11-04 15:38:11 -0500101
Jeff Laytonbd61e0a2015-01-16 15:05:55 -0500102 if (flctx == NULL)
Trond Myklebust65b62a22013-02-07 10:54:07 -0500103 goto out;
Jeff Layton314d7cc2013-04-10 15:36:48 -0400104
Jeff Laytonbd61e0a2015-01-16 15:05:55 -0500105 list = &flctx->flc_posix;
Jeff Layton6109c852015-01-16 15:05:57 -0500106 spin_lock(&flctx->flc_lock);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -0500107restart:
108 list_for_each_entry(fl, list, fl_list) {
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400109 if (nfs_file_open_context(fl->fl_file) != ctx)
Trond Myklebust888e6942005-11-04 15:38:11 -0500110 continue;
Jeff Layton6109c852015-01-16 15:05:57 -0500111 spin_unlock(&flctx->flc_lock);
Trond Myklebustdb4f2e632013-04-01 15:56:46 -0400112 status = nfs4_lock_delegation_recall(fl, state, stateid);
Trond Myklebustd5122202009-06-17 13:22:58 -0700113 if (status < 0)
Trond Myklebust3f09df72009-06-17 13:23:00 -0700114 goto out;
Jeff Layton6109c852015-01-16 15:05:57 -0500115 spin_lock(&flctx->flc_lock);
Trond Myklebust888e6942005-11-04 15:38:11 -0500116 }
Jeff Laytonbd61e0a2015-01-16 15:05:55 -0500117 if (list == &flctx->flc_posix) {
118 list = &flctx->flc_flock;
119 goto restart;
Jeff Layton5263e312015-01-16 15:05:55 -0500120 }
Jeff Layton6109c852015-01-16 15:05:57 -0500121 spin_unlock(&flctx->flc_lock);
Trond Myklebust3f09df72009-06-17 13:23:00 -0700122out:
Trond Myklebust888e6942005-11-04 15:38:11 -0500123 return status;
124}
125
Trond Myklebust24311f82015-09-20 10:50:17 -0400126static int nfs_delegation_claim_opens(struct inode *inode,
127 const nfs4_stateid *stateid, fmode_t type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128{
129 struct nfs_inode *nfsi = NFS_I(inode);
130 struct nfs_open_context *ctx;
Trond Myklebustd25be542013-02-05 11:43:28 -0500131 struct nfs4_state_owner *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 struct nfs4_state *state;
Trond Myklebustd25be542013-02-05 11:43:28 -0500133 unsigned int seq;
Trond Myklebust888e6942005-11-04 15:38:11 -0500134 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135
136again:
137 spin_lock(&inode->i_lock);
138 list_for_each_entry(ctx, &nfsi->open_files, list) {
139 state = ctx->state;
140 if (state == NULL)
141 continue;
142 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
143 continue;
Trond Myklebustf8ebf7a2014-10-17 23:02:52 +0300144 if (!nfs4_valid_open_stateid(state))
145 continue;
Trond Myklebustf597c532012-03-04 18:13:56 -0500146 if (!nfs4_stateid_match(&state->stateid, stateid))
Trond Myklebust90163022007-07-05 14:55:18 -0400147 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 get_nfs_open_context(ctx);
149 spin_unlock(&inode->i_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500150 sp = state->owner;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500151 /* Block nfs4_proc_unlck */
152 mutex_lock(&sp->so_delegreturn_mutex);
Trond Myklebustd25be542013-02-05 11:43:28 -0500153 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
Trond Myklebust24311f82015-09-20 10:50:17 -0400154 err = nfs4_open_delegation_recall(ctx, state, stateid, type);
Trond Myklebustd25be542013-02-05 11:43:28 -0500155 if (!err)
Trond Myklebustdb4f2e632013-04-01 15:56:46 -0400156 err = nfs_delegation_claim_locks(ctx, state, stateid);
Trond Myklebustd25be542013-02-05 11:43:28 -0500157 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
158 err = -EAGAIN;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500159 mutex_unlock(&sp->so_delegreturn_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 put_nfs_open_context(ctx);
Trond Myklebust888e6942005-11-04 15:38:11 -0500161 if (err != 0)
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500162 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 goto again;
164 }
165 spin_unlock(&inode->i_lock);
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500166 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167}
168
Chuck Leverd3978bb2010-12-24 01:33:04 +0000169/**
170 * nfs_inode_reclaim_delegation - process a delegation reclaim request
171 * @inode: inode to process
172 * @cred: credential to use for request
173 * @res: new delegation state from server
174 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000176void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
177 struct nfs_openres *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
Trond Myklebust8f649c32010-05-01 12:36:18 -0400179 struct nfs_delegation *delegation;
180 struct rpc_cred *oldcred = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
Trond Myklebust8f649c32010-05-01 12:36:18 -0400182 rcu_read_lock();
183 delegation = rcu_dereference(NFS_I(inode)->delegation);
184 if (delegation != NULL) {
185 spin_lock(&delegation->lock);
186 if (delegation->inode != NULL) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500187 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400188 delegation->type = res->delegation_type;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400189 delegation->pagemod_limit = res->pagemod_limit;
Trond Myklebust8f649c32010-05-01 12:36:18 -0400190 oldcred = delegation->cred;
191 delegation->cred = get_rpccred(cred);
192 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
193 &delegation->flags);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400194 spin_unlock(&delegation->lock);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400195 rcu_read_unlock();
Trond Myklebust7c0af9f2015-02-26 12:54:46 -0500196 put_rpccred(oldcred);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400197 trace_nfs4_reclaim_delegation(inode, res->delegation_type);
Trond Myklebustb1a318d2016-09-22 13:39:12 -0400198 return;
Trond Myklebust8f649c32010-05-01 12:36:18 -0400199 }
Trond Myklebustb1a318d2016-09-22 13:39:12 -0400200 /* We appear to have raced with a delegation return. */
201 spin_unlock(&delegation->lock);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400202 }
Trond Myklebustb1a318d2016-09-22 13:39:12 -0400203 rcu_read_unlock();
204 nfs_inode_set_delegation(inode, cred, res);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205}
206
Trond Myklebust57bfa892008-01-25 16:38:18 -0500207static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
208{
209 int res = 0;
210
Trond Myklebust869f9df2014-11-10 18:43:56 -0500211 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
212 res = nfs4_proc_delegreturn(inode,
213 delegation->cred,
214 &delegation->stateid,
215 issync);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500216 nfs_free_delegation(delegation);
217 return res;
218}
219
Trond Myklebust86e89482008-12-23 15:21:39 -0500220static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
221{
222 struct inode *inode = NULL;
223
224 spin_lock(&delegation->lock);
225 if (delegation->inode != NULL)
226 inode = igrab(delegation->inode);
227 spin_unlock(&delegation->lock);
228 return inode;
229}
230
Chuck Leverdda4b222010-12-24 01:32:54 +0000231static struct nfs_delegation *
Trond Myklebustd25be542013-02-05 11:43:28 -0500232nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
Trond Myklebust57bfa892008-01-25 16:38:18 -0500233{
Trond Myklebustd25be542013-02-05 11:43:28 -0500234 struct nfs_delegation *ret = NULL;
235 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500236
237 if (delegation == NULL)
Trond Myklebustd25be542013-02-05 11:43:28 -0500238 goto out;
239 spin_lock(&delegation->lock);
240 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
241 ret = delegation;
242 spin_unlock(&delegation->lock);
243out:
244 return ret;
245}
246
247static struct nfs_delegation *
248nfs_start_delegation_return(struct nfs_inode *nfsi)
249{
250 struct nfs_delegation *delegation;
251
252 rcu_read_lock();
253 delegation = nfs_start_delegation_return_locked(nfsi);
254 rcu_read_unlock();
255 return delegation;
256}
257
258static void
259nfs_abort_delegation_return(struct nfs_delegation *delegation,
260 struct nfs_client *clp)
261{
Chuck Leverdda4b222010-12-24 01:32:54 +0000262
Trond Myklebust34310432008-12-23 15:21:38 -0500263 spin_lock(&delegation->lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500264 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
265 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
266 spin_unlock(&delegation->lock);
267 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
268}
269
270static struct nfs_delegation *
271nfs_detach_delegation_locked(struct nfs_inode *nfsi,
272 struct nfs_delegation *delegation,
273 struct nfs_client *clp)
274{
275 struct nfs_delegation *deleg_cur =
276 rcu_dereference_protected(nfsi->delegation,
277 lockdep_is_held(&clp->cl_lock));
278
279 if (deleg_cur == NULL || delegation != deleg_cur)
280 return NULL;
281
282 spin_lock(&delegation->lock);
283 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500284 list_del_rcu(&delegation->super_list);
Trond Myklebust86e89482008-12-23 15:21:39 -0500285 delegation->inode = NULL;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500286 rcu_assign_pointer(nfsi->delegation, NULL);
Trond Myklebust34310432008-12-23 15:21:38 -0500287 spin_unlock(&delegation->lock);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500288 return delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500289}
290
Chuck Leverdda4b222010-12-24 01:32:54 +0000291static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500292 struct nfs_delegation *delegation,
293 struct nfs_server *server)
Chuck Leverdda4b222010-12-24 01:32:54 +0000294{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000295 struct nfs_client *clp = server->nfs_client;
Chuck Leverdda4b222010-12-24 01:32:54 +0000296
297 spin_lock(&clp->cl_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500298 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
Chuck Leverdda4b222010-12-24 01:32:54 +0000299 spin_unlock(&clp->cl_lock);
300 return delegation;
301}
302
Trond Myklebustd25be542013-02-05 11:43:28 -0500303static struct nfs_delegation *
304nfs_inode_detach_delegation(struct inode *inode)
305{
306 struct nfs_inode *nfsi = NFS_I(inode);
307 struct nfs_server *server = NFS_SERVER(inode);
308 struct nfs_delegation *delegation;
309
310 delegation = nfs_start_delegation_return(nfsi);
311 if (delegation == NULL)
312 return NULL;
313 return nfs_detach_delegation(nfsi, delegation, server);
314}
315
Trond Myklebustcf6726e2014-12-19 11:22:28 -0500316static void
317nfs_update_inplace_delegation(struct nfs_delegation *delegation,
318 const struct nfs_delegation *update)
319{
320 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
321 delegation->stateid.seqid = update->stateid.seqid;
322 smp_wmb();
323 delegation->type = update->type;
324 }
325}
326
Chuck Leverd3978bb2010-12-24 01:33:04 +0000327/**
328 * nfs_inode_set_delegation - set up a delegation on an inode
329 * @inode: inode to which delegation applies
330 * @cred: cred to use for subsequent delegation processing
331 * @res: new delegation state from server
332 *
333 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 */
335int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
336{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000337 struct nfs_server *server = NFS_SERVER(inode);
338 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 struct nfs_inode *nfsi = NFS_I(inode);
David Howells17d2c0a2010-05-01 12:37:18 -0400340 struct nfs_delegation *delegation, *old_delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500341 struct nfs_delegation *freeme = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 int status = 0;
343
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400344 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 if (delegation == NULL)
346 return -ENOMEM;
Trond Myklebustf597c532012-03-04 18:13:56 -0500347 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 delegation->type = res->delegation_type;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400349 delegation->pagemod_limit = res->pagemod_limit;
Trond Myklebusta9a4a872011-10-17 16:08:46 -0700350 delegation->change_attr = inode->i_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 delegation->cred = get_rpccred(cred);
352 delegation->inode = inode;
Trond Myklebustb7391f42008-12-23 15:21:52 -0500353 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
Trond Myklebust34310432008-12-23 15:21:38 -0500354 spin_lock_init(&delegation->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
356 spin_lock(&clp->cl_lock);
David Howells17d2c0a2010-05-01 12:37:18 -0400357 old_delegation = rcu_dereference_protected(nfsi->delegation,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000358 lockdep_is_held(&clp->cl_lock));
David Howells17d2c0a2010-05-01 12:37:18 -0400359 if (old_delegation != NULL) {
Trond Myklebustcf6726e2014-12-19 11:22:28 -0500360 /* Is this an update of the existing delegation? */
361 if (nfs4_stateid_match_other(&old_delegation->stateid,
362 &delegation->stateid)) {
363 nfs_update_inplace_delegation(old_delegation,
364 delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500365 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 }
Trond Myklebust57bfa892008-01-25 16:38:18 -0500367 /*
368 * Deal with broken servers that hand out two
369 * delegations for the same file.
Trond Myklebust17280172012-03-11 13:11:00 -0400370 * Allow for upgrades to a WRITE delegation, but
371 * nothing else.
Trond Myklebust57bfa892008-01-25 16:38:18 -0500372 */
373 dfprintk(FILE, "%s: server %s handed out "
374 "a duplicate delegation!\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700375 __func__, clp->cl_hostname);
Trond Myklebust17280172012-03-11 13:11:00 -0400376 if (delegation->type == old_delegation->type ||
377 !(delegation->type & FMODE_WRITE)) {
Trond Myklebust57bfa892008-01-25 16:38:18 -0500378 freeme = delegation;
379 delegation = NULL;
380 goto out;
381 }
Trond Myklebustade04642015-02-27 14:25:50 -0500382 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
383 &old_delegation->flags))
384 goto out;
385 freeme = nfs_detach_delegation_locked(nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500386 old_delegation, clp);
387 if (freeme == NULL)
388 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 }
Trond Myklebust38942ba2015-03-04 15:59:05 -0500390 list_add_tail_rcu(&delegation->super_list, &server->delegations);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500391 rcu_assign_pointer(nfsi->delegation, delegation);
392 delegation = NULL;
Trond Myklebust412c77c2007-07-03 16:10:55 -0400393
394 /* Ensure we revalidate the attributes and page cache! */
395 spin_lock(&inode->i_lock);
396 nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
397 spin_unlock(&inode->i_lock);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400398 trace_nfs4_set_delegation(inode, res->delegation_type);
Trond Myklebust412c77c2007-07-03 16:10:55 -0400399
Trond Myklebust57bfa892008-01-25 16:38:18 -0500400out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401 spin_unlock(&clp->cl_lock);
Trond Myklebust603c83d2007-10-18 19:59:20 -0400402 if (delegation != NULL)
403 nfs_free_delegation(delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500404 if (freeme != NULL)
405 nfs_do_return_delegation(inode, freeme, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 return status;
407}
408
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409/*
410 * Basic procedure for returning a delegation to the server
411 */
Trond Myklebustd25be542013-02-05 11:43:28 -0500412static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413{
Trond Myklebustd25be542013-02-05 11:43:28 -0500414 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust869f9df2014-11-10 18:43:56 -0500416 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Trond Myklebustd25be542013-02-05 11:43:28 -0500418 if (delegation == NULL)
419 return 0;
420 do {
Trond Myklebust869f9df2014-11-10 18:43:56 -0500421 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
422 break;
Trond Myklebust24311f82015-09-20 10:50:17 -0400423 err = nfs_delegation_claim_opens(inode, &delegation->stateid,
424 delegation->type);
Trond Myklebustd25be542013-02-05 11:43:28 -0500425 if (!issync || err != -EAGAIN)
426 break;
427 /*
428 * Guard against state recovery
429 */
430 err = nfs4_wait_clnt_recover(clp);
431 } while (err == 0);
432
433 if (err) {
434 nfs_abort_delegation_return(delegation, clp);
435 goto out;
436 }
437 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500438 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500440 err = nfs_do_return_delegation(inode, delegation, issync);
441out:
442 return err;
Trond Myklebust90163022007-07-05 14:55:18 -0400443}
444
Trond Myklebustb7571442013-04-03 14:33:49 -0400445static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
446{
447 bool ret = false;
448
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500449 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
450 goto out;
Trond Myklebustb7571442013-04-03 14:33:49 -0400451 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
452 ret = true;
453 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
454 struct inode *inode;
455
456 spin_lock(&delegation->lock);
457 inode = delegation->inode;
458 if (inode && list_empty(&NFS_I(inode)->open_files))
459 ret = true;
460 spin_unlock(&delegation->lock);
461 }
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500462out:
Trond Myklebustb7571442013-04-03 14:33:49 -0400463 return ret;
464}
465
Chuck Leverd3978bb2010-12-24 01:33:04 +0000466/**
467 * nfs_client_return_marked_delegations - return previously marked delegations
468 * @clp: nfs_client to process
469 *
Trond Myklebustdc327ed2012-05-06 19:46:30 -0400470 * Note that this function is designed to be called by the state
471 * manager thread. For this reason, it cannot flush the dirty data,
472 * since that could deadlock in case of a state recovery error.
473 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000474 * Returns zero on success, or a negative errno value.
Trond Myklebust515d8612008-12-23 15:21:46 -0500475 */
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500476int nfs_client_return_marked_delegations(struct nfs_client *clp)
Trond Myklebust515d8612008-12-23 15:21:46 -0500477{
478 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000479 struct nfs_server *server;
Trond Myklebust515d8612008-12-23 15:21:46 -0500480 struct inode *inode;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500481 int err = 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500482
483restart:
484 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000485 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
486 list_for_each_entry_rcu(delegation, &server->delegations,
487 super_list) {
Trond Myklebustb7571442013-04-03 14:33:49 -0400488 if (!nfs_delegation_need_return(delegation))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000489 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500490 if (!nfs_sb_active(server->super))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000491 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500492 inode = nfs_delegation_grab_inode(delegation);
493 if (inode == NULL) {
494 rcu_read_unlock();
495 nfs_sb_deactive(server->super);
496 goto restart;
497 }
Trond Myklebustd25be542013-02-05 11:43:28 -0500498 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
Chuck Leverd3978bb2010-12-24 01:33:04 +0000499 rcu_read_unlock();
500
Trond Myklebustd25be542013-02-05 11:43:28 -0500501 err = nfs_end_delegation_return(inode, delegation, 0);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000502 iput(inode);
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500503 nfs_sb_deactive(server->super);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000504 if (!err)
505 goto restart;
506 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
507 return err;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500508 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500509 }
510 rcu_read_unlock();
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500511 return 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500512}
513
Chuck Leverd3978bb2010-12-24 01:33:04 +0000514/**
515 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
516 * @inode: inode to process
517 *
518 * Does not protect against delegation reclaims, therefore really only safe
519 * to be called from nfs4_clear_inode().
Trond Myklebuste6f81072008-01-24 18:14:34 -0500520 */
521void nfs_inode_return_delegation_noreclaim(struct inode *inode)
522{
Trond Myklebuste6f81072008-01-24 18:14:34 -0500523 struct nfs_delegation *delegation;
524
Trond Myklebustd25be542013-02-05 11:43:28 -0500525 delegation = nfs_inode_detach_delegation(inode);
526 if (delegation != NULL)
Trond Myklebust5fcdfac2015-03-25 13:19:42 -0400527 nfs_do_return_delegation(inode, delegation, 1);
Trond Myklebuste6f81072008-01-24 18:14:34 -0500528}
529
Chuck Leverd3978bb2010-12-24 01:33:04 +0000530/**
531 * nfs_inode_return_delegation - synchronously return a delegation
532 * @inode: inode to process
533 *
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400534 * This routine will always flush any dirty data to disk on the
535 * assumption that if we need to return the delegation, then
536 * we should stop caching.
537 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000538 * Returns zero on success, or a negative errno value.
539 */
Bryan Schumaker57ec14c2012-06-20 15:53:44 -0400540int nfs4_inode_return_delegation(struct inode *inode)
Trond Myklebust90163022007-07-05 14:55:18 -0400541{
Trond Myklebust90163022007-07-05 14:55:18 -0400542 struct nfs_inode *nfsi = NFS_I(inode);
543 struct nfs_delegation *delegation;
544 int err = 0;
545
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400546 nfs_wb_all(inode);
Trond Myklebustd25be542013-02-05 11:43:28 -0500547 delegation = nfs_start_delegation_return(nfsi);
548 if (delegation != NULL)
549 err = nfs_end_delegation_return(inode, delegation, 1);
Trond Myklebust90163022007-07-05 14:55:18 -0400550 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551}
552
Trond Myklebustb7571442013-04-03 14:33:49 -0400553static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
554 struct nfs_delegation *delegation)
555{
556 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
557 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
558}
559
Trond Myklebusted1e6212011-07-25 15:37:29 -0400560static void nfs_mark_return_delegation(struct nfs_server *server,
561 struct nfs_delegation *delegation)
Trond Myklebust6411bd42008-12-23 15:21:51 -0500562{
563 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
Trond Myklebusted1e6212011-07-25 15:37:29 -0400564 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500565}
566
Trond Myklebust5c31e232013-04-03 19:04:58 -0400567static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
568{
569 struct nfs_delegation *delegation;
570 bool ret = false;
571
572 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
573 nfs_mark_return_delegation(server, delegation);
574 ret = true;
575 }
576 return ret;
577}
578
Trond Myklebustb02ba0b2013-04-03 19:23:58 -0400579static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
580{
581 struct nfs_server *server;
582
583 rcu_read_lock();
584 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
585 nfs_server_mark_return_all_delegations(server);
586 rcu_read_unlock();
587}
588
589static void nfs_delegation_run_state_manager(struct nfs_client *clp)
590{
591 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
592 nfs4_schedule_state_manager(clp);
593}
594
595/**
596 * nfs_expire_all_delegations
597 * @clp: client to process
598 *
599 */
600void nfs_expire_all_delegations(struct nfs_client *clp)
601{
602 nfs_client_mark_return_all_delegations(clp);
603 nfs_delegation_run_state_manager(clp);
604}
605
Chuck Leverd3978bb2010-12-24 01:33:04 +0000606/**
607 * nfs_super_return_all_delegations - return delegations for one superblock
608 * @sb: sb to process
609 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 */
Bryan Schumakereeebf912012-06-20 15:53:41 -0400611void nfs_server_return_all_delegations(struct nfs_server *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000613 struct nfs_client *clp = server->nfs_client;
Trond Myklebust5c31e232013-04-03 19:04:58 -0400614 bool need_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
616 if (clp == NULL)
617 return;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000618
Trond Myklebust8383e462007-07-06 15:12:04 -0400619 rcu_read_lock();
Trond Myklebust5c31e232013-04-03 19:04:58 -0400620 need_wait = nfs_server_mark_return_all_delegations(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400621 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000622
Trond Myklebust5c31e232013-04-03 19:04:58 -0400623 if (need_wait) {
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500624 nfs4_schedule_state_manager(clp);
Trond Myklebust5c31e232013-04-03 19:04:58 -0400625 nfs4_wait_clnt_recover(clp);
626 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500627}
628
Trond Myklebust826e0012013-04-03 19:27:52 -0400629static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000630 fmode_t flags)
Trond Myklebust515d8612008-12-23 15:21:46 -0500631{
632 struct nfs_delegation *delegation;
633
Chuck Leverd3978bb2010-12-24 01:33:04 +0000634 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500635 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
636 continue;
637 if (delegation->type & flags)
Trond Myklebust826e0012013-04-03 19:27:52 -0400638 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebust707fb4b2008-12-23 15:21:47 -0500639 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000640}
641
Trond Myklebust826e0012013-04-03 19:27:52 -0400642static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000643 fmode_t flags)
644{
645 struct nfs_server *server;
646
647 rcu_read_lock();
648 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
Trond Myklebust826e0012013-04-03 19:27:52 -0400649 nfs_mark_return_unused_delegation_types(server, flags);
Trond Myklebust515d8612008-12-23 15:21:46 -0500650 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651}
652
Trond Myklebust41020b62016-09-22 13:38:58 -0400653static void nfs_mark_delegation_revoked(struct nfs_server *server,
654 struct nfs_delegation *delegation)
Trond Myklebust869f9df2014-11-10 18:43:56 -0500655{
Trond Myklebust41020b62016-09-22 13:38:58 -0400656 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
Trond Myklebust059b43e2016-09-22 13:39:06 -0400657 delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
Trond Myklebust41020b62016-09-22 13:38:58 -0400658 nfs_mark_return_delegation(server, delegation);
Trond Myklebust869f9df2014-11-10 18:43:56 -0500659}
660
Trond Myklebust41020b62016-09-22 13:38:58 -0400661static bool nfs_revoke_delegation(struct inode *inode,
662 const nfs4_stateid *stateid)
663{
664 struct nfs_delegation *delegation;
Trond Myklebust7f048832016-09-22 13:39:14 -0400665 nfs4_stateid tmp;
Trond Myklebust41020b62016-09-22 13:38:58 -0400666 bool ret = false;
667
668 rcu_read_lock();
669 delegation = rcu_dereference(NFS_I(inode)->delegation);
670 if (delegation == NULL)
671 goto out;
Trond Myklebust7f048832016-09-22 13:39:14 -0400672 if (stateid == NULL) {
673 nfs4_stateid_copy(&tmp, &delegation->stateid);
674 stateid = &tmp;
675 } else if (!nfs4_stateid_match(stateid, &delegation->stateid))
Trond Myklebust41020b62016-09-22 13:38:58 -0400676 goto out;
677 nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
678 ret = true;
679out:
680 rcu_read_unlock();
Trond Myklebust7f048832016-09-22 13:39:14 -0400681 if (ret)
682 nfs_inode_find_state_and_recover(inode, stateid);
Trond Myklebust41020b62016-09-22 13:38:58 -0400683 return ret;
684}
685
686void nfs_remove_bad_delegation(struct inode *inode,
687 const nfs4_stateid *stateid)
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500688{
689 struct nfs_delegation *delegation;
690
Trond Myklebust41020b62016-09-22 13:38:58 -0400691 if (!nfs_revoke_delegation(inode, stateid))
692 return;
Trond Myklebustd25be542013-02-05 11:43:28 -0500693 delegation = nfs_inode_detach_delegation(inode);
Trond Myklebust7f048832016-09-22 13:39:14 -0400694 if (delegation)
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500695 nfs_free_delegation(delegation);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500696}
Andy Adamson9cb81962012-03-07 10:49:41 -0500697EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500698
Chuck Leverd3978bb2010-12-24 01:33:04 +0000699/**
Trond Myklebust826e0012013-04-03 19:27:52 -0400700 * nfs_expire_unused_delegation_types
Chuck Leverd3978bb2010-12-24 01:33:04 +0000701 * @clp: client to process
702 * @flags: delegation types to expire
703 *
704 */
Trond Myklebust826e0012013-04-03 19:27:52 -0400705void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500706{
Trond Myklebust826e0012013-04-03 19:27:52 -0400707 nfs_client_mark_return_unused_delegation_types(clp, flags);
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500708 nfs_delegation_run_state_manager(clp);
709}
710
Chuck Leverd3978bb2010-12-24 01:33:04 +0000711static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
Trond Myklebustb7391f42008-12-23 15:21:52 -0500712{
713 struct nfs_delegation *delegation;
714
Chuck Leverd3978bb2010-12-24 01:33:04 +0000715 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebustb7391f42008-12-23 15:21:52 -0500716 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
717 continue;
Trond Myklebustb7571442013-04-03 14:33:49 -0400718 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebustb7391f42008-12-23 15:21:52 -0500719 }
Trond Myklebustb7391f42008-12-23 15:21:52 -0500720}
721
Chuck Leverd3978bb2010-12-24 01:33:04 +0000722/**
723 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
724 * @clp: nfs_client to process
725 *
726 */
Trond Myklebustb7391f42008-12-23 15:21:52 -0500727void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
728{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000729 struct nfs_server *server;
730
731 rcu_read_lock();
732 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
733 nfs_mark_return_unreferenced_delegations(server);
734 rcu_read_unlock();
735
Trond Myklebustb7391f42008-12-23 15:21:52 -0500736 nfs_delegation_run_state_manager(clp);
737}
738
Chuck Leverd3978bb2010-12-24 01:33:04 +0000739/**
740 * nfs_async_inode_return_delegation - asynchronously return a delegation
741 * @inode: inode to process
Trond Myklebust8e663f02012-03-04 18:13:56 -0500742 * @stateid: state ID information
Chuck Leverd3978bb2010-12-24 01:33:04 +0000743 *
744 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000746int nfs_async_inode_return_delegation(struct inode *inode,
747 const nfs4_stateid *stateid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
Trond Myklebusted1e6212011-07-25 15:37:29 -0400749 struct nfs_server *server = NFS_SERVER(inode);
750 struct nfs_client *clp = server->nfs_client;
Trond Myklebust6411bd42008-12-23 15:21:51 -0500751 struct nfs_delegation *delegation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752
Trond Myklebust6411bd42008-12-23 15:21:51 -0500753 rcu_read_lock();
754 delegation = rcu_dereference(NFS_I(inode)->delegation);
Trond Myklebust755a48a2014-03-02 22:03:12 -0500755 if (delegation == NULL)
756 goto out_enoent;
Trond Myklebust4816fda2015-09-20 14:58:42 -0400757 if (stateid != NULL &&
758 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
Trond Myklebust755a48a2014-03-02 22:03:12 -0500759 goto out_enoent;
Trond Myklebusted1e6212011-07-25 15:37:29 -0400760 nfs_mark_return_delegation(server, delegation);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500761 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000762
Trond Myklebust6411bd42008-12-23 15:21:51 -0500763 nfs_delegation_run_state_manager(clp);
764 return 0;
Trond Myklebust755a48a2014-03-02 22:03:12 -0500765out_enoent:
766 rcu_read_unlock();
767 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768}
769
Chuck Leverd3978bb2010-12-24 01:33:04 +0000770static struct inode *
771nfs_delegation_find_inode_server(struct nfs_server *server,
772 const struct nfs_fh *fhandle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773{
774 struct nfs_delegation *delegation;
775 struct inode *res = NULL;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000776
777 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebust86e89482008-12-23 15:21:39 -0500778 spin_lock(&delegation->lock);
779 if (delegation->inode != NULL &&
780 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 res = igrab(delegation->inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 }
Trond Myklebust86e89482008-12-23 15:21:39 -0500783 spin_unlock(&delegation->lock);
784 if (res != NULL)
785 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000787 return res;
788}
789
790/**
791 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
792 * @clp: client state handle
793 * @fhandle: filehandle from a delegation recall
794 *
795 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
796 * cannot be found.
797 */
798struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
799 const struct nfs_fh *fhandle)
800{
801 struct nfs_server *server;
802 struct inode *res = NULL;
803
804 rcu_read_lock();
805 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
806 res = nfs_delegation_find_inode_server(server, fhandle);
807 if (res != NULL)
808 break;
809 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400810 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 return res;
812}
813
Chuck Leverd3978bb2010-12-24 01:33:04 +0000814static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
815{
816 struct nfs_delegation *delegation;
817
Trond Myklebust45870d62016-09-22 13:38:59 -0400818 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
819 /*
820 * If the delegation may have been admin revoked, then we
821 * cannot reclaim it.
822 */
823 if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
824 continue;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000825 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
Trond Myklebust45870d62016-09-22 13:38:59 -0400826 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000827}
828
829/**
830 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
831 * @clp: nfs_client to process
832 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 */
David Howellsadfa6f92006-08-22 20:06:08 -0400834void nfs_delegation_mark_reclaim(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000836 struct nfs_server *server;
837
Trond Myklebust8383e462007-07-06 15:12:04 -0400838 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000839 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
840 nfs_delegation_mark_reclaim_server(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400841 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842}
843
Chuck Leverd3978bb2010-12-24 01:33:04 +0000844/**
845 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
846 * @clp: nfs_client to process
847 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 */
David Howellsadfa6f92006-08-22 20:06:08 -0400849void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850{
Trond Myklebust8383e462007-07-06 15:12:04 -0400851 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000852 struct nfs_server *server;
Trond Myklebust86e89482008-12-23 15:21:39 -0500853 struct inode *inode;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000854
Trond Myklebust8383e462007-07-06 15:12:04 -0400855restart:
856 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000857 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
858 list_for_each_entry_rcu(delegation, &server->delegations,
859 super_list) {
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500860 if (test_bit(NFS_DELEGATION_RETURNING,
861 &delegation->flags))
862 continue;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000863 if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
864 &delegation->flags) == 0)
865 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500866 if (!nfs_sb_active(server->super))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000867 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500868 inode = nfs_delegation_grab_inode(delegation);
869 if (inode == NULL) {
870 rcu_read_unlock();
871 nfs_sb_deactive(server->super);
872 goto restart;
873 }
Trond Myklebustb04b22f2015-02-26 13:59:38 -0500874 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
Chuck Leverd3978bb2010-12-24 01:33:04 +0000875 rcu_read_unlock();
Trond Myklebustb04b22f2015-02-26 13:59:38 -0500876 if (delegation != NULL) {
877 delegation = nfs_detach_delegation(NFS_I(inode),
878 delegation, server);
879 if (delegation != NULL)
880 nfs_free_delegation(delegation);
881 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000882 iput(inode);
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500883 nfs_sb_deactive(server->super);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000884 goto restart;
885 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700886 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400887 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888}
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500889
Trond Myklebustbb3d1a32016-09-22 13:39:00 -0400890static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
891{
892 return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
893 BIT(NFS4CLNT_LEASE_EXPIRED) |
894 BIT(NFS4CLNT_SESSION_RESET))) != 0;
895}
896
Trond Myklebust45870d62016-09-22 13:38:59 -0400897static void nfs_mark_test_expired_delegation(struct nfs_server *server,
898 struct nfs_delegation *delegation)
899{
Trond Myklebust059b43e2016-09-22 13:39:06 -0400900 if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
901 return;
Trond Myklebust45870d62016-09-22 13:38:59 -0400902 clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
903 set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
904 set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
905}
906
Trond Myklebustbb3d1a32016-09-22 13:39:00 -0400907static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
908 struct inode *inode)
909{
910 struct nfs_delegation *delegation;
911
912 rcu_read_lock();
913 delegation = rcu_dereference(NFS_I(inode)->delegation);
914 if (delegation)
915 nfs_mark_test_expired_delegation(server, delegation);
916 rcu_read_unlock();
917
918}
919
Trond Myklebust45870d62016-09-22 13:38:59 -0400920static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
921{
922 struct nfs_delegation *delegation;
923
924 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
925 nfs_mark_test_expired_delegation(server, delegation);
926}
927
928/**
929 * nfs_mark_test_expired_all_delegations - mark all delegations for testing
930 * @clp: nfs_client to process
931 *
932 * Iterates through all the delegations associated with this server and
933 * marks them as needing to be checked for validity.
934 */
935void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
936{
937 struct nfs_server *server;
938
939 rcu_read_lock();
940 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
941 nfs_delegation_mark_test_expired_server(server);
942 rcu_read_unlock();
943}
944
945/**
946 * nfs_reap_expired_delegations - reap expired delegations
947 * @clp: nfs_client to process
948 *
949 * Iterates through all the delegations associated with this server and
950 * checks if they have may have been revoked. This function is usually
951 * expected to be called in cases where the server may have lost its
952 * lease.
953 */
954void nfs_reap_expired_delegations(struct nfs_client *clp)
955{
956 const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
957 struct nfs_delegation *delegation;
958 struct nfs_server *server;
959 struct inode *inode;
960 struct rpc_cred *cred;
961 nfs4_stateid stateid;
962
963restart:
964 rcu_read_lock();
965 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
966 list_for_each_entry_rcu(delegation, &server->delegations,
967 super_list) {
968 if (test_bit(NFS_DELEGATION_RETURNING,
969 &delegation->flags))
970 continue;
971 if (test_bit(NFS_DELEGATION_TEST_EXPIRED,
972 &delegation->flags) == 0)
973 continue;
974 if (!nfs_sb_active(server->super))
975 continue;
976 inode = nfs_delegation_grab_inode(delegation);
977 if (inode == NULL) {
978 rcu_read_unlock();
979 nfs_sb_deactive(server->super);
980 goto restart;
981 }
982 cred = get_rpccred_rcu(delegation->cred);
983 nfs4_stateid_copy(&stateid, &delegation->stateid);
984 clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
985 rcu_read_unlock();
986 if (cred != NULL &&
987 ops->test_and_free_expired(server, &stateid, cred) < 0) {
988 nfs_revoke_delegation(inode, &stateid);
989 nfs_inode_find_state_and_recover(inode, &stateid);
990 }
991 put_rpccred(cred);
Trond Myklebustbb3d1a32016-09-22 13:39:00 -0400992 if (nfs4_server_rebooted(clp)) {
993 nfs_inode_mark_test_expired_delegation(server,inode);
994 iput(inode);
995 nfs_sb_deactive(server->super);
996 return;
997 }
Trond Myklebust45870d62016-09-22 13:38:59 -0400998 iput(inode);
999 nfs_sb_deactive(server->super);
1000 goto restart;
1001 }
1002 }
1003 rcu_read_unlock();
1004}
1005
Trond Myklebust6c2d8f82016-09-22 13:39:07 -04001006void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1007 const nfs4_stateid *stateid)
1008{
1009 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1010 struct nfs_delegation *delegation;
1011 bool found = false;
1012
1013 rcu_read_lock();
1014 delegation = rcu_dereference(NFS_I(inode)->delegation);
1015 if (delegation &&
1016 nfs4_stateid_match_other(&delegation->stateid, stateid)) {
1017 nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1018 found = true;
1019 }
1020 rcu_read_unlock();
1021 if (found)
1022 nfs4_schedule_state_manager(clp);
1023}
1024
Chuck Leverd3978bb2010-12-24 01:33:04 +00001025/**
1026 * nfs_delegations_present - check for existence of delegations
1027 * @clp: client state handle
1028 *
1029 * Returns one if there are any nfs_delegation structures attached
1030 * to this nfs_client.
1031 */
1032int nfs_delegations_present(struct nfs_client *clp)
1033{
1034 struct nfs_server *server;
1035 int ret = 0;
1036
1037 rcu_read_lock();
1038 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1039 if (!list_empty(&server->delegations)) {
1040 ret = 1;
1041 break;
1042 }
1043 rcu_read_unlock();
1044 return ret;
1045}
1046
1047/**
1048 * nfs4_copy_delegation_stateid - Copy inode's state ID information
Chuck Leverd3978bb2010-12-24 01:33:04 +00001049 * @inode: inode to check
Trond Myklebust0032a7a2012-03-08 17:16:12 -05001050 * @flags: delegation type requirement
Trond Myklebustabf4e132016-05-16 17:42:44 -04001051 * @dst: stateid data structure to fill in
1052 * @cred: optional argument to retrieve credential
Chuck Leverd3978bb2010-12-24 01:33:04 +00001053 *
Trond Myklebust0032a7a2012-03-08 17:16:12 -05001054 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1055 * otherwise "false" is returned.
Chuck Leverd3978bb2010-12-24 01:33:04 +00001056 */
Trond Myklebustabf4e132016-05-16 17:42:44 -04001057bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1058 nfs4_stateid *dst, struct rpc_cred **cred)
Trond Myklebust3e4f6292006-03-20 13:44:46 -05001059{
Trond Myklebust3e4f6292006-03-20 13:44:46 -05001060 struct nfs_inode *nfsi = NFS_I(inode);
1061 struct nfs_delegation *delegation;
Trond Myklebust0032a7a2012-03-08 17:16:12 -05001062 bool ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -05001063
Trond Myklebust0032a7a2012-03-08 17:16:12 -05001064 flags &= FMODE_READ|FMODE_WRITE;
Trond Myklebust8383e462007-07-06 15:12:04 -04001065 rcu_read_lock();
1066 delegation = rcu_dereference(nfsi->delegation);
Trond Myklebustaa05c872016-09-22 13:38:54 -04001067 ret = nfs4_is_valid_delegation(delegation, flags);
Trond Myklebust0032a7a2012-03-08 17:16:12 -05001068 if (ret) {
Trond Myklebustf597c532012-03-04 18:13:56 -05001069 nfs4_stateid_copy(dst, &delegation->stateid);
Trond Myklebust0032a7a2012-03-08 17:16:12 -05001070 nfs_mark_delegation_referenced(delegation);
Trond Myklebustabf4e132016-05-16 17:42:44 -04001071 if (cred)
1072 *cred = get_rpccred(delegation->cred);
Trond Myklebust3e4f6292006-03-20 13:44:46 -05001073 }
Trond Myklebust8383e462007-07-06 15:12:04 -04001074 rcu_read_unlock();
1075 return ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -05001076}
Trond Myklebust5445b1f2015-09-05 19:06:58 -04001077
1078/**
1079 * nfs4_delegation_flush_on_close - Check if we must flush file on close
1080 * @inode: inode to check
1081 *
1082 * This function checks the number of outstanding writes to the file
1083 * against the delegation 'space_limit' field to see if
1084 * the spec requires us to flush the file on close.
1085 */
1086bool nfs4_delegation_flush_on_close(const struct inode *inode)
1087{
1088 struct nfs_inode *nfsi = NFS_I(inode);
1089 struct nfs_delegation *delegation;
1090 bool ret = true;
1091
1092 rcu_read_lock();
1093 delegation = rcu_dereference(nfsi->delegation);
1094 if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1095 goto out;
1096 if (nfsi->nrequests < delegation->pagemod_limit)
1097 ret = false;
1098out:
1099 rcu_read_unlock();
1100 return ret;
1101}