blob: 2714ef835bdd4261cbc301838c050f42896c24c0 [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
Peng Tao15bb3af2014-07-03 13:05:00 +080044static int
45nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
Trond Myklebustb7391f42008-12-23 15:21:52 -050046{
47 struct nfs_delegation *delegation;
48 int ret = 0;
49
50 flags &= FMODE_READ|FMODE_WRITE;
51 rcu_read_lock();
52 delegation = rcu_dereference(NFS_I(inode)->delegation);
Trond Myklebustd25be542013-02-05 11:43:28 -050053 if (delegation != NULL && (delegation->type & flags) == flags &&
54 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
Peng Tao15bb3af2014-07-03 13:05:00 +080055 if (mark)
56 nfs_mark_delegation_referenced(delegation);
Trond Myklebustb7391f42008-12-23 15:21:52 -050057 ret = 1;
58 }
59 rcu_read_unlock();
60 return ret;
61}
Peng Tao15bb3af2014-07-03 13:05:00 +080062/**
63 * nfs_have_delegation - check if inode has a delegation, mark it
64 * NFS_DELEGATION_REFERENCED if there is one.
65 * @inode: inode to check
66 * @flags: delegation types to check for
67 *
68 * Returns one if inode has the indicated delegation, otherwise zero.
69 */
70int nfs4_have_delegation(struct inode *inode, fmode_t flags)
71{
72 return nfs4_do_check_delegation(inode, flags, true);
73}
74
75/*
76 * nfs4_check_delegation - check if inode has a delegation, do not mark
77 * NFS_DELEGATION_REFERENCED if it has one.
78 */
79int nfs4_check_delegation(struct inode *inode, fmode_t flags)
80{
81 return nfs4_do_check_delegation(inode, flags, false);
82}
Trond Myklebustb7391f42008-12-23 15:21:52 -050083
Trond Myklebustdb4f2e632013-04-01 15:56:46 -040084static 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 -050085{
86 struct inode *inode = state->inode;
87 struct file_lock *fl;
Jeff Laytonbd61e0a2015-01-16 15:05:55 -050088 struct file_lock_context *flctx = inode->i_flctx;
89 struct list_head *list;
Trond Myklebustd5122202009-06-17 13:22:58 -070090 int status = 0;
Trond Myklebust888e6942005-11-04 15:38:11 -050091
Jeff Laytonbd61e0a2015-01-16 15:05:55 -050092 if (flctx == NULL)
Trond Myklebust65b62a22013-02-07 10:54:07 -050093 goto out;
Jeff Layton314d7cc2013-04-10 15:36:48 -040094
Jeff Laytonbd61e0a2015-01-16 15:05:55 -050095 list = &flctx->flc_posix;
Jeff Layton6109c852015-01-16 15:05:57 -050096 spin_lock(&flctx->flc_lock);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -050097restart:
98 list_for_each_entry(fl, list, fl_list) {
Trond Myklebustcd3758e2007-08-10 17:44:32 -040099 if (nfs_file_open_context(fl->fl_file) != ctx)
Trond Myklebust888e6942005-11-04 15:38:11 -0500100 continue;
Jeff Layton6109c852015-01-16 15:05:57 -0500101 spin_unlock(&flctx->flc_lock);
Trond Myklebustdb4f2e632013-04-01 15:56:46 -0400102 status = nfs4_lock_delegation_recall(fl, state, stateid);
Trond Myklebustd5122202009-06-17 13:22:58 -0700103 if (status < 0)
Trond Myklebust3f09df72009-06-17 13:23:00 -0700104 goto out;
Jeff Layton6109c852015-01-16 15:05:57 -0500105 spin_lock(&flctx->flc_lock);
Trond Myklebust888e6942005-11-04 15:38:11 -0500106 }
Jeff Laytonbd61e0a2015-01-16 15:05:55 -0500107 if (list == &flctx->flc_posix) {
108 list = &flctx->flc_flock;
109 goto restart;
Jeff Layton5263e312015-01-16 15:05:55 -0500110 }
Jeff Layton6109c852015-01-16 15:05:57 -0500111 spin_unlock(&flctx->flc_lock);
Trond Myklebust3f09df72009-06-17 13:23:00 -0700112out:
Trond Myklebust888e6942005-11-04 15:38:11 -0500113 return status;
114}
115
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500116static int nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *stateid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
118 struct nfs_inode *nfsi = NFS_I(inode);
119 struct nfs_open_context *ctx;
Trond Myklebustd25be542013-02-05 11:43:28 -0500120 struct nfs4_state_owner *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 struct nfs4_state *state;
Trond Myklebustd25be542013-02-05 11:43:28 -0500122 unsigned int seq;
Trond Myklebust888e6942005-11-04 15:38:11 -0500123 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124
125again:
126 spin_lock(&inode->i_lock);
127 list_for_each_entry(ctx, &nfsi->open_files, list) {
128 state = ctx->state;
129 if (state == NULL)
130 continue;
131 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
132 continue;
Trond Myklebustf8ebf7a2014-10-17 23:02:52 +0300133 if (!nfs4_valid_open_stateid(state))
134 continue;
Trond Myklebustf597c532012-03-04 18:13:56 -0500135 if (!nfs4_stateid_match(&state->stateid, stateid))
Trond Myklebust90163022007-07-05 14:55:18 -0400136 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 get_nfs_open_context(ctx);
138 spin_unlock(&inode->i_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500139 sp = state->owner;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500140 /* Block nfs4_proc_unlck */
141 mutex_lock(&sp->so_delegreturn_mutex);
Trond Myklebustd25be542013-02-05 11:43:28 -0500142 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
Trond Myklebust13437e12007-07-06 15:10:43 -0400143 err = nfs4_open_delegation_recall(ctx, state, stateid);
Trond Myklebustd25be542013-02-05 11:43:28 -0500144 if (!err)
Trond Myklebustdb4f2e632013-04-01 15:56:46 -0400145 err = nfs_delegation_claim_locks(ctx, state, stateid);
Trond Myklebustd25be542013-02-05 11:43:28 -0500146 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
147 err = -EAGAIN;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500148 mutex_unlock(&sp->so_delegreturn_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 put_nfs_open_context(ctx);
Trond Myklebust888e6942005-11-04 15:38:11 -0500150 if (err != 0)
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500151 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 goto again;
153 }
154 spin_unlock(&inode->i_lock);
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500155 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156}
157
Chuck Leverd3978bb2010-12-24 01:33:04 +0000158/**
159 * nfs_inode_reclaim_delegation - process a delegation reclaim request
160 * @inode: inode to process
161 * @cred: credential to use for request
162 * @res: new delegation state from server
163 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000165void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
166 struct nfs_openres *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Trond Myklebust8f649c32010-05-01 12:36:18 -0400168 struct nfs_delegation *delegation;
169 struct rpc_cred *oldcred = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Trond Myklebust8f649c32010-05-01 12:36:18 -0400171 rcu_read_lock();
172 delegation = rcu_dereference(NFS_I(inode)->delegation);
173 if (delegation != NULL) {
174 spin_lock(&delegation->lock);
175 if (delegation->inode != NULL) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500176 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400177 delegation->type = res->delegation_type;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400178 delegation->pagemod_limit = res->pagemod_limit;
Trond Myklebust8f649c32010-05-01 12:36:18 -0400179 oldcred = delegation->cred;
180 delegation->cred = get_rpccred(cred);
181 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
182 &delegation->flags);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400183 spin_unlock(&delegation->lock);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400184 rcu_read_unlock();
Trond Myklebust7c0af9f2015-02-26 12:54:46 -0500185 put_rpccred(oldcred);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400186 trace_nfs4_reclaim_delegation(inode, res->delegation_type);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400187 } else {
188 /* We appear to have raced with a delegation return. */
189 spin_unlock(&delegation->lock);
190 rcu_read_unlock();
191 nfs_inode_set_delegation(inode, cred, res);
192 }
193 } else {
194 rcu_read_unlock();
195 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196}
197
Trond Myklebust57bfa892008-01-25 16:38:18 -0500198static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
199{
200 int res = 0;
201
Trond Myklebust869f9df2014-11-10 18:43:56 -0500202 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
203 res = nfs4_proc_delegreturn(inode,
204 delegation->cred,
205 &delegation->stateid,
206 issync);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500207 nfs_free_delegation(delegation);
208 return res;
209}
210
Trond Myklebust86e89482008-12-23 15:21:39 -0500211static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
212{
213 struct inode *inode = NULL;
214
215 spin_lock(&delegation->lock);
216 if (delegation->inode != NULL)
217 inode = igrab(delegation->inode);
218 spin_unlock(&delegation->lock);
219 return inode;
220}
221
Chuck Leverdda4b222010-12-24 01:32:54 +0000222static struct nfs_delegation *
Trond Myklebustd25be542013-02-05 11:43:28 -0500223nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
Trond Myklebust57bfa892008-01-25 16:38:18 -0500224{
Trond Myklebustd25be542013-02-05 11:43:28 -0500225 struct nfs_delegation *ret = NULL;
226 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500227
228 if (delegation == NULL)
Trond Myklebustd25be542013-02-05 11:43:28 -0500229 goto out;
230 spin_lock(&delegation->lock);
231 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
232 ret = delegation;
233 spin_unlock(&delegation->lock);
234out:
235 return ret;
236}
237
238static struct nfs_delegation *
239nfs_start_delegation_return(struct nfs_inode *nfsi)
240{
241 struct nfs_delegation *delegation;
242
243 rcu_read_lock();
244 delegation = nfs_start_delegation_return_locked(nfsi);
245 rcu_read_unlock();
246 return delegation;
247}
248
249static void
250nfs_abort_delegation_return(struct nfs_delegation *delegation,
251 struct nfs_client *clp)
252{
Chuck Leverdda4b222010-12-24 01:32:54 +0000253
Trond Myklebust34310432008-12-23 15:21:38 -0500254 spin_lock(&delegation->lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500255 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
256 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
257 spin_unlock(&delegation->lock);
258 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
259}
260
261static struct nfs_delegation *
262nfs_detach_delegation_locked(struct nfs_inode *nfsi,
263 struct nfs_delegation *delegation,
264 struct nfs_client *clp)
265{
266 struct nfs_delegation *deleg_cur =
267 rcu_dereference_protected(nfsi->delegation,
268 lockdep_is_held(&clp->cl_lock));
269
270 if (deleg_cur == NULL || delegation != deleg_cur)
271 return NULL;
272
273 spin_lock(&delegation->lock);
274 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500275 list_del_rcu(&delegation->super_list);
Trond Myklebust86e89482008-12-23 15:21:39 -0500276 delegation->inode = NULL;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500277 rcu_assign_pointer(nfsi->delegation, NULL);
Trond Myklebust34310432008-12-23 15:21:38 -0500278 spin_unlock(&delegation->lock);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500279 return delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500280}
281
Chuck Leverdda4b222010-12-24 01:32:54 +0000282static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500283 struct nfs_delegation *delegation,
284 struct nfs_server *server)
Chuck Leverdda4b222010-12-24 01:32:54 +0000285{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000286 struct nfs_client *clp = server->nfs_client;
Chuck Leverdda4b222010-12-24 01:32:54 +0000287
288 spin_lock(&clp->cl_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500289 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
Chuck Leverdda4b222010-12-24 01:32:54 +0000290 spin_unlock(&clp->cl_lock);
291 return delegation;
292}
293
Trond Myklebustd25be542013-02-05 11:43:28 -0500294static struct nfs_delegation *
295nfs_inode_detach_delegation(struct inode *inode)
296{
297 struct nfs_inode *nfsi = NFS_I(inode);
298 struct nfs_server *server = NFS_SERVER(inode);
299 struct nfs_delegation *delegation;
300
301 delegation = nfs_start_delegation_return(nfsi);
302 if (delegation == NULL)
303 return NULL;
304 return nfs_detach_delegation(nfsi, delegation, server);
305}
306
Trond Myklebustcf6726e2014-12-19 11:22:28 -0500307static void
308nfs_update_inplace_delegation(struct nfs_delegation *delegation,
309 const struct nfs_delegation *update)
310{
311 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
312 delegation->stateid.seqid = update->stateid.seqid;
313 smp_wmb();
314 delegation->type = update->type;
315 }
316}
317
Chuck Leverd3978bb2010-12-24 01:33:04 +0000318/**
319 * nfs_inode_set_delegation - set up a delegation on an inode
320 * @inode: inode to which delegation applies
321 * @cred: cred to use for subsequent delegation processing
322 * @res: new delegation state from server
323 *
324 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 */
326int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
327{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000328 struct nfs_server *server = NFS_SERVER(inode);
329 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 struct nfs_inode *nfsi = NFS_I(inode);
David Howells17d2c0a2010-05-01 12:37:18 -0400331 struct nfs_delegation *delegation, *old_delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500332 struct nfs_delegation *freeme = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 int status = 0;
334
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400335 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 if (delegation == NULL)
337 return -ENOMEM;
Trond Myklebustf597c532012-03-04 18:13:56 -0500338 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 delegation->type = res->delegation_type;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400340 delegation->pagemod_limit = res->pagemod_limit;
Trond Myklebusta9a4a872011-10-17 16:08:46 -0700341 delegation->change_attr = inode->i_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342 delegation->cred = get_rpccred(cred);
343 delegation->inode = inode;
Trond Myklebustb7391f42008-12-23 15:21:52 -0500344 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
Trond Myklebust34310432008-12-23 15:21:38 -0500345 spin_lock_init(&delegation->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
347 spin_lock(&clp->cl_lock);
David Howells17d2c0a2010-05-01 12:37:18 -0400348 old_delegation = rcu_dereference_protected(nfsi->delegation,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000349 lockdep_is_held(&clp->cl_lock));
David Howells17d2c0a2010-05-01 12:37:18 -0400350 if (old_delegation != NULL) {
Trond Myklebustcf6726e2014-12-19 11:22:28 -0500351 /* Is this an update of the existing delegation? */
352 if (nfs4_stateid_match_other(&old_delegation->stateid,
353 &delegation->stateid)) {
354 nfs_update_inplace_delegation(old_delegation,
355 delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500356 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 }
Trond Myklebust57bfa892008-01-25 16:38:18 -0500358 /*
359 * Deal with broken servers that hand out two
360 * delegations for the same file.
Trond Myklebust17280172012-03-11 13:11:00 -0400361 * Allow for upgrades to a WRITE delegation, but
362 * nothing else.
Trond Myklebust57bfa892008-01-25 16:38:18 -0500363 */
364 dfprintk(FILE, "%s: server %s handed out "
365 "a duplicate delegation!\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700366 __func__, clp->cl_hostname);
Trond Myklebust17280172012-03-11 13:11:00 -0400367 if (delegation->type == old_delegation->type ||
368 !(delegation->type & FMODE_WRITE)) {
Trond Myklebust57bfa892008-01-25 16:38:18 -0500369 freeme = delegation;
370 delegation = NULL;
371 goto out;
372 }
Trond Myklebustade04642015-02-27 14:25:50 -0500373 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
374 &old_delegation->flags))
375 goto out;
376 freeme = nfs_detach_delegation_locked(nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500377 old_delegation, clp);
378 if (freeme == NULL)
379 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 }
Trond Myklebust38942ba2015-03-04 15:59:05 -0500381 list_add_tail_rcu(&delegation->super_list, &server->delegations);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500382 rcu_assign_pointer(nfsi->delegation, delegation);
383 delegation = NULL;
Trond Myklebust412c77c2007-07-03 16:10:55 -0400384
385 /* Ensure we revalidate the attributes and page cache! */
386 spin_lock(&inode->i_lock);
387 nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
388 spin_unlock(&inode->i_lock);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400389 trace_nfs4_set_delegation(inode, res->delegation_type);
Trond Myklebust412c77c2007-07-03 16:10:55 -0400390
Trond Myklebust57bfa892008-01-25 16:38:18 -0500391out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 spin_unlock(&clp->cl_lock);
Trond Myklebust603c83d2007-10-18 19:59:20 -0400393 if (delegation != NULL)
394 nfs_free_delegation(delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500395 if (freeme != NULL)
396 nfs_do_return_delegation(inode, freeme, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 return status;
398}
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400/*
401 * Basic procedure for returning a delegation to the server
402 */
Trond Myklebustd25be542013-02-05 11:43:28 -0500403static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404{
Trond Myklebustd25be542013-02-05 11:43:28 -0500405 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust869f9df2014-11-10 18:43:56 -0500407 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Trond Myklebustd25be542013-02-05 11:43:28 -0500409 if (delegation == NULL)
410 return 0;
411 do {
Trond Myklebust869f9df2014-11-10 18:43:56 -0500412 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
413 break;
Trond Myklebustd25be542013-02-05 11:43:28 -0500414 err = nfs_delegation_claim_opens(inode, &delegation->stateid);
415 if (!issync || err != -EAGAIN)
416 break;
417 /*
418 * Guard against state recovery
419 */
420 err = nfs4_wait_clnt_recover(clp);
421 } while (err == 0);
422
423 if (err) {
424 nfs_abort_delegation_return(delegation, clp);
425 goto out;
426 }
427 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500428 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500430 err = nfs_do_return_delegation(inode, delegation, issync);
431out:
432 return err;
Trond Myklebust90163022007-07-05 14:55:18 -0400433}
434
Trond Myklebustb7571442013-04-03 14:33:49 -0400435static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
436{
437 bool ret = false;
438
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500439 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
440 goto out;
Trond Myklebustb7571442013-04-03 14:33:49 -0400441 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
442 ret = true;
443 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
444 struct inode *inode;
445
446 spin_lock(&delegation->lock);
447 inode = delegation->inode;
448 if (inode && list_empty(&NFS_I(inode)->open_files))
449 ret = true;
450 spin_unlock(&delegation->lock);
451 }
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500452out:
Trond Myklebustb7571442013-04-03 14:33:49 -0400453 return ret;
454}
455
Chuck Leverd3978bb2010-12-24 01:33:04 +0000456/**
457 * nfs_client_return_marked_delegations - return previously marked delegations
458 * @clp: nfs_client to process
459 *
Trond Myklebustdc327ed2012-05-06 19:46:30 -0400460 * Note that this function is designed to be called by the state
461 * manager thread. For this reason, it cannot flush the dirty data,
462 * since that could deadlock in case of a state recovery error.
463 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000464 * Returns zero on success, or a negative errno value.
Trond Myklebust515d8612008-12-23 15:21:46 -0500465 */
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500466int nfs_client_return_marked_delegations(struct nfs_client *clp)
Trond Myklebust515d8612008-12-23 15:21:46 -0500467{
468 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000469 struct nfs_server *server;
Trond Myklebust515d8612008-12-23 15:21:46 -0500470 struct inode *inode;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500471 int err = 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500472
473restart:
474 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000475 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
476 list_for_each_entry_rcu(delegation, &server->delegations,
477 super_list) {
Trond Myklebustb7571442013-04-03 14:33:49 -0400478 if (!nfs_delegation_need_return(delegation))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000479 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500480 if (!nfs_sb_active(server->super))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000481 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500482 inode = nfs_delegation_grab_inode(delegation);
483 if (inode == NULL) {
484 rcu_read_unlock();
485 nfs_sb_deactive(server->super);
486 goto restart;
487 }
Trond Myklebustd25be542013-02-05 11:43:28 -0500488 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
Chuck Leverd3978bb2010-12-24 01:33:04 +0000489 rcu_read_unlock();
490
Trond Myklebustd25be542013-02-05 11:43:28 -0500491 err = nfs_end_delegation_return(inode, delegation, 0);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000492 iput(inode);
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500493 nfs_sb_deactive(server->super);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000494 if (!err)
495 goto restart;
496 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
497 return err;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500498 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500499 }
500 rcu_read_unlock();
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500501 return 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500502}
503
Chuck Leverd3978bb2010-12-24 01:33:04 +0000504/**
505 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
506 * @inode: inode to process
507 *
508 * Does not protect against delegation reclaims, therefore really only safe
509 * to be called from nfs4_clear_inode().
Trond Myklebuste6f81072008-01-24 18:14:34 -0500510 */
511void nfs_inode_return_delegation_noreclaim(struct inode *inode)
512{
Trond Myklebuste6f81072008-01-24 18:14:34 -0500513 struct nfs_delegation *delegation;
514
Trond Myklebustd25be542013-02-05 11:43:28 -0500515 delegation = nfs_inode_detach_delegation(inode);
516 if (delegation != NULL)
Trond Myklebust5fcdfac2015-03-25 13:19:42 -0400517 nfs_do_return_delegation(inode, delegation, 1);
Trond Myklebuste6f81072008-01-24 18:14:34 -0500518}
519
Chuck Leverd3978bb2010-12-24 01:33:04 +0000520/**
521 * nfs_inode_return_delegation - synchronously return a delegation
522 * @inode: inode to process
523 *
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400524 * This routine will always flush any dirty data to disk on the
525 * assumption that if we need to return the delegation, then
526 * we should stop caching.
527 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000528 * Returns zero on success, or a negative errno value.
529 */
Bryan Schumaker57ec14c2012-06-20 15:53:44 -0400530int nfs4_inode_return_delegation(struct inode *inode)
Trond Myklebust90163022007-07-05 14:55:18 -0400531{
Trond Myklebust90163022007-07-05 14:55:18 -0400532 struct nfs_inode *nfsi = NFS_I(inode);
533 struct nfs_delegation *delegation;
534 int err = 0;
535
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400536 nfs_wb_all(inode);
Trond Myklebustd25be542013-02-05 11:43:28 -0500537 delegation = nfs_start_delegation_return(nfsi);
538 if (delegation != NULL)
539 err = nfs_end_delegation_return(inode, delegation, 1);
Trond Myklebust90163022007-07-05 14:55:18 -0400540 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541}
542
Trond Myklebustb7571442013-04-03 14:33:49 -0400543static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
544 struct nfs_delegation *delegation)
545{
546 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
547 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
548}
549
Trond Myklebusted1e6212011-07-25 15:37:29 -0400550static void nfs_mark_return_delegation(struct nfs_server *server,
551 struct nfs_delegation *delegation)
Trond Myklebust6411bd42008-12-23 15:21:51 -0500552{
553 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
Trond Myklebusted1e6212011-07-25 15:37:29 -0400554 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500555}
556
Trond Myklebust5c31e232013-04-03 19:04:58 -0400557static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
558{
559 struct nfs_delegation *delegation;
560 bool ret = false;
561
562 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
563 nfs_mark_return_delegation(server, delegation);
564 ret = true;
565 }
566 return ret;
567}
568
Trond Myklebustb02ba0b2013-04-03 19:23:58 -0400569static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
570{
571 struct nfs_server *server;
572
573 rcu_read_lock();
574 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
575 nfs_server_mark_return_all_delegations(server);
576 rcu_read_unlock();
577}
578
579static void nfs_delegation_run_state_manager(struct nfs_client *clp)
580{
581 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
582 nfs4_schedule_state_manager(clp);
583}
584
585/**
586 * nfs_expire_all_delegations
587 * @clp: client to process
588 *
589 */
590void nfs_expire_all_delegations(struct nfs_client *clp)
591{
592 nfs_client_mark_return_all_delegations(clp);
593 nfs_delegation_run_state_manager(clp);
594}
595
Chuck Leverd3978bb2010-12-24 01:33:04 +0000596/**
597 * nfs_super_return_all_delegations - return delegations for one superblock
598 * @sb: sb to process
599 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 */
Bryan Schumakereeebf912012-06-20 15:53:41 -0400601void nfs_server_return_all_delegations(struct nfs_server *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000603 struct nfs_client *clp = server->nfs_client;
Trond Myklebust5c31e232013-04-03 19:04:58 -0400604 bool need_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605
606 if (clp == NULL)
607 return;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000608
Trond Myklebust8383e462007-07-06 15:12:04 -0400609 rcu_read_lock();
Trond Myklebust5c31e232013-04-03 19:04:58 -0400610 need_wait = nfs_server_mark_return_all_delegations(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400611 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000612
Trond Myklebust5c31e232013-04-03 19:04:58 -0400613 if (need_wait) {
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500614 nfs4_schedule_state_manager(clp);
Trond Myklebust5c31e232013-04-03 19:04:58 -0400615 nfs4_wait_clnt_recover(clp);
616 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500617}
618
Trond Myklebust826e0012013-04-03 19:27:52 -0400619static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000620 fmode_t flags)
Trond Myklebust515d8612008-12-23 15:21:46 -0500621{
622 struct nfs_delegation *delegation;
623
Chuck Leverd3978bb2010-12-24 01:33:04 +0000624 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500625 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
626 continue;
627 if (delegation->type & flags)
Trond Myklebust826e0012013-04-03 19:27:52 -0400628 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebust707fb4b2008-12-23 15:21:47 -0500629 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000630}
631
Trond Myklebust826e0012013-04-03 19:27:52 -0400632static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000633 fmode_t flags)
634{
635 struct nfs_server *server;
636
637 rcu_read_lock();
638 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
Trond Myklebust826e0012013-04-03 19:27:52 -0400639 nfs_mark_return_unused_delegation_types(server, flags);
Trond Myklebust515d8612008-12-23 15:21:46 -0500640 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641}
642
Trond Myklebust869f9df2014-11-10 18:43:56 -0500643static void nfs_revoke_delegation(struct inode *inode)
644{
645 struct nfs_delegation *delegation;
646 rcu_read_lock();
647 delegation = rcu_dereference(NFS_I(inode)->delegation);
648 if (delegation != NULL) {
649 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
650 nfs_mark_return_delegation(NFS_SERVER(inode), delegation);
651 }
652 rcu_read_unlock();
653}
654
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500655void nfs_remove_bad_delegation(struct inode *inode)
656{
657 struct nfs_delegation *delegation;
658
Trond Myklebust869f9df2014-11-10 18:43:56 -0500659 nfs_revoke_delegation(inode);
Trond Myklebustd25be542013-02-05 11:43:28 -0500660 delegation = nfs_inode_detach_delegation(inode);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500661 if (delegation) {
662 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
663 nfs_free_delegation(delegation);
664 }
665}
Andy Adamson9cb81962012-03-07 10:49:41 -0500666EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500667
Chuck Leverd3978bb2010-12-24 01:33:04 +0000668/**
Trond Myklebust826e0012013-04-03 19:27:52 -0400669 * nfs_expire_unused_delegation_types
Chuck Leverd3978bb2010-12-24 01:33:04 +0000670 * @clp: client to process
671 * @flags: delegation types to expire
672 *
673 */
Trond Myklebust826e0012013-04-03 19:27:52 -0400674void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500675{
Trond Myklebust826e0012013-04-03 19:27:52 -0400676 nfs_client_mark_return_unused_delegation_types(clp, flags);
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500677 nfs_delegation_run_state_manager(clp);
678}
679
Chuck Leverd3978bb2010-12-24 01:33:04 +0000680static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
Trond Myklebustb7391f42008-12-23 15:21:52 -0500681{
682 struct nfs_delegation *delegation;
683
Chuck Leverd3978bb2010-12-24 01:33:04 +0000684 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebustb7391f42008-12-23 15:21:52 -0500685 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
686 continue;
Trond Myklebustb7571442013-04-03 14:33:49 -0400687 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebustb7391f42008-12-23 15:21:52 -0500688 }
Trond Myklebustb7391f42008-12-23 15:21:52 -0500689}
690
Chuck Leverd3978bb2010-12-24 01:33:04 +0000691/**
692 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
693 * @clp: nfs_client to process
694 *
695 */
Trond Myklebustb7391f42008-12-23 15:21:52 -0500696void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
697{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000698 struct nfs_server *server;
699
700 rcu_read_lock();
701 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
702 nfs_mark_return_unreferenced_delegations(server);
703 rcu_read_unlock();
704
Trond Myklebustb7391f42008-12-23 15:21:52 -0500705 nfs_delegation_run_state_manager(clp);
706}
707
Chuck Leverd3978bb2010-12-24 01:33:04 +0000708/**
709 * nfs_async_inode_return_delegation - asynchronously return a delegation
710 * @inode: inode to process
Trond Myklebust8e663f02012-03-04 18:13:56 -0500711 * @stateid: state ID information
Chuck Leverd3978bb2010-12-24 01:33:04 +0000712 *
713 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000715int nfs_async_inode_return_delegation(struct inode *inode,
716 const nfs4_stateid *stateid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Trond Myklebusted1e6212011-07-25 15:37:29 -0400718 struct nfs_server *server = NFS_SERVER(inode);
719 struct nfs_client *clp = server->nfs_client;
Trond Myklebust6411bd42008-12-23 15:21:51 -0500720 struct nfs_delegation *delegation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Trond Myklebustdc327ed2012-05-06 19:46:30 -0400722 filemap_flush(inode->i_mapping);
723
Trond Myklebust6411bd42008-12-23 15:21:51 -0500724 rcu_read_lock();
725 delegation = rcu_dereference(NFS_I(inode)->delegation);
Trond Myklebust755a48a2014-03-02 22:03:12 -0500726 if (delegation == NULL)
727 goto out_enoent;
Alexandros Batsakis25976412009-12-05 13:48:55 -0500728
Trond Myklebust755a48a2014-03-02 22:03:12 -0500729 if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
730 goto out_enoent;
Trond Myklebusted1e6212011-07-25 15:37:29 -0400731 nfs_mark_return_delegation(server, delegation);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500732 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000733
Trond Myklebust6411bd42008-12-23 15:21:51 -0500734 nfs_delegation_run_state_manager(clp);
735 return 0;
Trond Myklebust755a48a2014-03-02 22:03:12 -0500736out_enoent:
737 rcu_read_unlock();
738 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739}
740
Chuck Leverd3978bb2010-12-24 01:33:04 +0000741static struct inode *
742nfs_delegation_find_inode_server(struct nfs_server *server,
743 const struct nfs_fh *fhandle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744{
745 struct nfs_delegation *delegation;
746 struct inode *res = NULL;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000747
748 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebust86e89482008-12-23 15:21:39 -0500749 spin_lock(&delegation->lock);
750 if (delegation->inode != NULL &&
751 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 res = igrab(delegation->inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753 }
Trond Myklebust86e89482008-12-23 15:21:39 -0500754 spin_unlock(&delegation->lock);
755 if (res != NULL)
756 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000758 return res;
759}
760
761/**
762 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
763 * @clp: client state handle
764 * @fhandle: filehandle from a delegation recall
765 *
766 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
767 * cannot be found.
768 */
769struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
770 const struct nfs_fh *fhandle)
771{
772 struct nfs_server *server;
773 struct inode *res = NULL;
774
775 rcu_read_lock();
776 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
777 res = nfs_delegation_find_inode_server(server, fhandle);
778 if (res != NULL)
779 break;
780 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400781 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 return res;
783}
784
Chuck Leverd3978bb2010-12-24 01:33:04 +0000785static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
786{
787 struct nfs_delegation *delegation;
788
789 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
790 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
791}
792
793/**
794 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
795 * @clp: nfs_client to process
796 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 */
David Howellsadfa6f92006-08-22 20:06:08 -0400798void nfs_delegation_mark_reclaim(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000800 struct nfs_server *server;
801
Trond Myklebust8383e462007-07-06 15:12:04 -0400802 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000803 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
804 nfs_delegation_mark_reclaim_server(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400805 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806}
807
Chuck Leverd3978bb2010-12-24 01:33:04 +0000808/**
809 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
810 * @clp: nfs_client to process
811 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 */
David Howellsadfa6f92006-08-22 20:06:08 -0400813void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
Trond Myklebust8383e462007-07-06 15:12:04 -0400815 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000816 struct nfs_server *server;
Trond Myklebust86e89482008-12-23 15:21:39 -0500817 struct inode *inode;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000818
Trond Myklebust8383e462007-07-06 15:12:04 -0400819restart:
820 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000821 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
822 list_for_each_entry_rcu(delegation, &server->delegations,
823 super_list) {
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500824 if (test_bit(NFS_DELEGATION_RETURNING,
825 &delegation->flags))
826 continue;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000827 if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
828 &delegation->flags) == 0)
829 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500830 if (!nfs_sb_active(server->super))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000831 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500832 inode = nfs_delegation_grab_inode(delegation);
833 if (inode == NULL) {
834 rcu_read_unlock();
835 nfs_sb_deactive(server->super);
836 goto restart;
837 }
Trond Myklebustb04b22f2015-02-26 13:59:38 -0500838 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
Chuck Leverd3978bb2010-12-24 01:33:04 +0000839 rcu_read_unlock();
Trond Myklebustb04b22f2015-02-26 13:59:38 -0500840 if (delegation != NULL) {
841 delegation = nfs_detach_delegation(NFS_I(inode),
842 delegation, server);
843 if (delegation != NULL)
844 nfs_free_delegation(delegation);
845 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000846 iput(inode);
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500847 nfs_sb_deactive(server->super);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000848 goto restart;
849 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400851 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852}
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500853
Chuck Leverd3978bb2010-12-24 01:33:04 +0000854/**
855 * nfs_delegations_present - check for existence of delegations
856 * @clp: client state handle
857 *
858 * Returns one if there are any nfs_delegation structures attached
859 * to this nfs_client.
860 */
861int nfs_delegations_present(struct nfs_client *clp)
862{
863 struct nfs_server *server;
864 int ret = 0;
865
866 rcu_read_lock();
867 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
868 if (!list_empty(&server->delegations)) {
869 ret = 1;
870 break;
871 }
872 rcu_read_unlock();
873 return ret;
874}
875
876/**
877 * nfs4_copy_delegation_stateid - Copy inode's state ID information
878 * @dst: stateid data structure to fill in
879 * @inode: inode to check
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500880 * @flags: delegation type requirement
Chuck Leverd3978bb2010-12-24 01:33:04 +0000881 *
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500882 * Returns "true" and fills in "dst->data" * if inode had a delegation,
883 * otherwise "false" is returned.
Chuck Leverd3978bb2010-12-24 01:33:04 +0000884 */
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500885bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode,
886 fmode_t flags)
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500887{
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500888 struct nfs_inode *nfsi = NFS_I(inode);
889 struct nfs_delegation *delegation;
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500890 bool ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500891
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500892 flags &= FMODE_READ|FMODE_WRITE;
Trond Myklebust8383e462007-07-06 15:12:04 -0400893 rcu_read_lock();
894 delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500895 ret = (delegation != NULL && (delegation->type & flags) == flags);
896 if (ret) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500897 nfs4_stateid_copy(dst, &delegation->stateid);
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500898 nfs_mark_delegation_referenced(delegation);
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500899 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400900 rcu_read_unlock();
901 return ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500902}
Trond Myklebust5445b1f2015-09-05 19:06:58 -0400903
904/**
905 * nfs4_delegation_flush_on_close - Check if we must flush file on close
906 * @inode: inode to check
907 *
908 * This function checks the number of outstanding writes to the file
909 * against the delegation 'space_limit' field to see if
910 * the spec requires us to flush the file on close.
911 */
912bool nfs4_delegation_flush_on_close(const struct inode *inode)
913{
914 struct nfs_inode *nfsi = NFS_I(inode);
915 struct nfs_delegation *delegation;
916 bool ret = true;
917
918 rcu_read_lock();
919 delegation = rcu_dereference(nfsi->delegation);
920 if (delegation == NULL || !(delegation->type & FMODE_WRITE))
921 goto out;
922 if (nfsi->nrequests < delegation->pagemod_limit)
923 ret = false;
924out:
925 rcu_read_unlock();
926 return ret;
927}