blob: 322c2585bc341eb49d5045e0898101ae7a1abab9 [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 Myklebust24311f82015-09-20 10:50:17 -0400116static int nfs_delegation_claim_opens(struct inode *inode,
117 const nfs4_stateid *stateid, fmode_t type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118{
119 struct nfs_inode *nfsi = NFS_I(inode);
120 struct nfs_open_context *ctx;
Trond Myklebustd25be542013-02-05 11:43:28 -0500121 struct nfs4_state_owner *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 struct nfs4_state *state;
Trond Myklebustd25be542013-02-05 11:43:28 -0500123 unsigned int seq;
Trond Myklebust888e6942005-11-04 15:38:11 -0500124 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125
126again:
127 spin_lock(&inode->i_lock);
128 list_for_each_entry(ctx, &nfsi->open_files, list) {
129 state = ctx->state;
130 if (state == NULL)
131 continue;
132 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
133 continue;
Trond Myklebustf8ebf7a2014-10-17 23:02:52 +0300134 if (!nfs4_valid_open_stateid(state))
135 continue;
Trond Myklebustf597c532012-03-04 18:13:56 -0500136 if (!nfs4_stateid_match(&state->stateid, stateid))
Trond Myklebust90163022007-07-05 14:55:18 -0400137 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138 get_nfs_open_context(ctx);
139 spin_unlock(&inode->i_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500140 sp = state->owner;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500141 /* Block nfs4_proc_unlck */
142 mutex_lock(&sp->so_delegreturn_mutex);
Trond Myklebustd25be542013-02-05 11:43:28 -0500143 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
Trond Myklebust24311f82015-09-20 10:50:17 -0400144 err = nfs4_open_delegation_recall(ctx, state, stateid, type);
Trond Myklebustd25be542013-02-05 11:43:28 -0500145 if (!err)
Trond Myklebustdb4f2e632013-04-01 15:56:46 -0400146 err = nfs_delegation_claim_locks(ctx, state, stateid);
Trond Myklebustd25be542013-02-05 11:43:28 -0500147 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
148 err = -EAGAIN;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500149 mutex_unlock(&sp->so_delegreturn_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 put_nfs_open_context(ctx);
Trond Myklebust888e6942005-11-04 15:38:11 -0500151 if (err != 0)
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500152 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 goto again;
154 }
155 spin_unlock(&inode->i_lock);
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500156 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157}
158
Chuck Leverd3978bb2010-12-24 01:33:04 +0000159/**
160 * nfs_inode_reclaim_delegation - process a delegation reclaim request
161 * @inode: inode to process
162 * @cred: credential to use for request
163 * @res: new delegation state from server
164 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000166void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
167 struct nfs_openres *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168{
Trond Myklebust8f649c32010-05-01 12:36:18 -0400169 struct nfs_delegation *delegation;
170 struct rpc_cred *oldcred = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171
Trond Myklebust8f649c32010-05-01 12:36:18 -0400172 rcu_read_lock();
173 delegation = rcu_dereference(NFS_I(inode)->delegation);
174 if (delegation != NULL) {
175 spin_lock(&delegation->lock);
176 if (delegation->inode != NULL) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500177 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400178 delegation->type = res->delegation_type;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400179 delegation->pagemod_limit = res->pagemod_limit;
Trond Myklebust8f649c32010-05-01 12:36:18 -0400180 oldcred = delegation->cred;
181 delegation->cred = get_rpccred(cred);
182 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
183 &delegation->flags);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400184 spin_unlock(&delegation->lock);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400185 rcu_read_unlock();
Trond Myklebust7c0af9f2015-02-26 12:54:46 -0500186 put_rpccred(oldcred);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400187 trace_nfs4_reclaim_delegation(inode, res->delegation_type);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400188 } else {
189 /* We appear to have raced with a delegation return. */
190 spin_unlock(&delegation->lock);
191 rcu_read_unlock();
192 nfs_inode_set_delegation(inode, cred, res);
193 }
194 } else {
195 rcu_read_unlock();
196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
Trond Myklebust57bfa892008-01-25 16:38:18 -0500199static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
200{
201 int res = 0;
202
Trond Myklebust869f9df2014-11-10 18:43:56 -0500203 if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
204 res = nfs4_proc_delegreturn(inode,
205 delegation->cred,
206 &delegation->stateid,
207 issync);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500208 nfs_free_delegation(delegation);
209 return res;
210}
211
Trond Myklebust86e89482008-12-23 15:21:39 -0500212static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
213{
214 struct inode *inode = NULL;
215
216 spin_lock(&delegation->lock);
217 if (delegation->inode != NULL)
218 inode = igrab(delegation->inode);
219 spin_unlock(&delegation->lock);
220 return inode;
221}
222
Chuck Leverdda4b222010-12-24 01:32:54 +0000223static struct nfs_delegation *
Trond Myklebustd25be542013-02-05 11:43:28 -0500224nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
Trond Myklebust57bfa892008-01-25 16:38:18 -0500225{
Trond Myklebustd25be542013-02-05 11:43:28 -0500226 struct nfs_delegation *ret = NULL;
227 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500228
229 if (delegation == NULL)
Trond Myklebustd25be542013-02-05 11:43:28 -0500230 goto out;
231 spin_lock(&delegation->lock);
232 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
233 ret = delegation;
234 spin_unlock(&delegation->lock);
235out:
236 return ret;
237}
238
239static struct nfs_delegation *
240nfs_start_delegation_return(struct nfs_inode *nfsi)
241{
242 struct nfs_delegation *delegation;
243
244 rcu_read_lock();
245 delegation = nfs_start_delegation_return_locked(nfsi);
246 rcu_read_unlock();
247 return delegation;
248}
249
250static void
251nfs_abort_delegation_return(struct nfs_delegation *delegation,
252 struct nfs_client *clp)
253{
Chuck Leverdda4b222010-12-24 01:32:54 +0000254
Trond Myklebust34310432008-12-23 15:21:38 -0500255 spin_lock(&delegation->lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500256 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
257 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
258 spin_unlock(&delegation->lock);
259 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
260}
261
262static struct nfs_delegation *
263nfs_detach_delegation_locked(struct nfs_inode *nfsi,
264 struct nfs_delegation *delegation,
265 struct nfs_client *clp)
266{
267 struct nfs_delegation *deleg_cur =
268 rcu_dereference_protected(nfsi->delegation,
269 lockdep_is_held(&clp->cl_lock));
270
271 if (deleg_cur == NULL || delegation != deleg_cur)
272 return NULL;
273
274 spin_lock(&delegation->lock);
275 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500276 list_del_rcu(&delegation->super_list);
Trond Myklebust86e89482008-12-23 15:21:39 -0500277 delegation->inode = NULL;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500278 rcu_assign_pointer(nfsi->delegation, NULL);
Trond Myklebust34310432008-12-23 15:21:38 -0500279 spin_unlock(&delegation->lock);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500280 return delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500281}
282
Chuck Leverdda4b222010-12-24 01:32:54 +0000283static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500284 struct nfs_delegation *delegation,
285 struct nfs_server *server)
Chuck Leverdda4b222010-12-24 01:32:54 +0000286{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000287 struct nfs_client *clp = server->nfs_client;
Chuck Leverdda4b222010-12-24 01:32:54 +0000288
289 spin_lock(&clp->cl_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500290 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
Chuck Leverdda4b222010-12-24 01:32:54 +0000291 spin_unlock(&clp->cl_lock);
292 return delegation;
293}
294
Trond Myklebustd25be542013-02-05 11:43:28 -0500295static struct nfs_delegation *
296nfs_inode_detach_delegation(struct inode *inode)
297{
298 struct nfs_inode *nfsi = NFS_I(inode);
299 struct nfs_server *server = NFS_SERVER(inode);
300 struct nfs_delegation *delegation;
301
302 delegation = nfs_start_delegation_return(nfsi);
303 if (delegation == NULL)
304 return NULL;
305 return nfs_detach_delegation(nfsi, delegation, server);
306}
307
Trond Myklebustcf6726e2014-12-19 11:22:28 -0500308static void
309nfs_update_inplace_delegation(struct nfs_delegation *delegation,
310 const struct nfs_delegation *update)
311{
312 if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
313 delegation->stateid.seqid = update->stateid.seqid;
314 smp_wmb();
315 delegation->type = update->type;
316 }
317}
318
Chuck Leverd3978bb2010-12-24 01:33:04 +0000319/**
320 * nfs_inode_set_delegation - set up a delegation on an inode
321 * @inode: inode to which delegation applies
322 * @cred: cred to use for subsequent delegation processing
323 * @res: new delegation state from server
324 *
325 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 */
327int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
328{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000329 struct nfs_server *server = NFS_SERVER(inode);
330 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 struct nfs_inode *nfsi = NFS_I(inode);
David Howells17d2c0a2010-05-01 12:37:18 -0400332 struct nfs_delegation *delegation, *old_delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500333 struct nfs_delegation *freeme = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334 int status = 0;
335
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400336 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 if (delegation == NULL)
338 return -ENOMEM;
Trond Myklebustf597c532012-03-04 18:13:56 -0500339 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 delegation->type = res->delegation_type;
Trond Myklebust7d160a62015-09-05 19:06:57 -0400341 delegation->pagemod_limit = res->pagemod_limit;
Trond Myklebusta9a4a872011-10-17 16:08:46 -0700342 delegation->change_attr = inode->i_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343 delegation->cred = get_rpccred(cred);
344 delegation->inode = inode;
Trond Myklebustb7391f42008-12-23 15:21:52 -0500345 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
Trond Myklebust34310432008-12-23 15:21:38 -0500346 spin_lock_init(&delegation->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347
348 spin_lock(&clp->cl_lock);
David Howells17d2c0a2010-05-01 12:37:18 -0400349 old_delegation = rcu_dereference_protected(nfsi->delegation,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000350 lockdep_is_held(&clp->cl_lock));
David Howells17d2c0a2010-05-01 12:37:18 -0400351 if (old_delegation != NULL) {
Trond Myklebustcf6726e2014-12-19 11:22:28 -0500352 /* Is this an update of the existing delegation? */
353 if (nfs4_stateid_match_other(&old_delegation->stateid,
354 &delegation->stateid)) {
355 nfs_update_inplace_delegation(old_delegation,
356 delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500357 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 }
Trond Myklebust57bfa892008-01-25 16:38:18 -0500359 /*
360 * Deal with broken servers that hand out two
361 * delegations for the same file.
Trond Myklebust17280172012-03-11 13:11:00 -0400362 * Allow for upgrades to a WRITE delegation, but
363 * nothing else.
Trond Myklebust57bfa892008-01-25 16:38:18 -0500364 */
365 dfprintk(FILE, "%s: server %s handed out "
366 "a duplicate delegation!\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700367 __func__, clp->cl_hostname);
Trond Myklebust17280172012-03-11 13:11:00 -0400368 if (delegation->type == old_delegation->type ||
369 !(delegation->type & FMODE_WRITE)) {
Trond Myklebust57bfa892008-01-25 16:38:18 -0500370 freeme = delegation;
371 delegation = NULL;
372 goto out;
373 }
Trond Myklebustade04642015-02-27 14:25:50 -0500374 if (test_and_set_bit(NFS_DELEGATION_RETURNING,
375 &old_delegation->flags))
376 goto out;
377 freeme = nfs_detach_delegation_locked(nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500378 old_delegation, clp);
379 if (freeme == NULL)
380 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381 }
Trond Myklebust38942ba2015-03-04 15:59:05 -0500382 list_add_tail_rcu(&delegation->super_list, &server->delegations);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500383 rcu_assign_pointer(nfsi->delegation, delegation);
384 delegation = NULL;
Trond Myklebust412c77c2007-07-03 16:10:55 -0400385
386 /* Ensure we revalidate the attributes and page cache! */
387 spin_lock(&inode->i_lock);
388 nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
389 spin_unlock(&inode->i_lock);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400390 trace_nfs4_set_delegation(inode, res->delegation_type);
Trond Myklebust412c77c2007-07-03 16:10:55 -0400391
Trond Myklebust57bfa892008-01-25 16:38:18 -0500392out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 spin_unlock(&clp->cl_lock);
Trond Myklebust603c83d2007-10-18 19:59:20 -0400394 if (delegation != NULL)
395 nfs_free_delegation(delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500396 if (freeme != NULL)
397 nfs_do_return_delegation(inode, freeme, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 return status;
399}
400
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401/*
402 * Basic procedure for returning a delegation to the server
403 */
Trond Myklebustd25be542013-02-05 11:43:28 -0500404static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405{
Trond Myklebustd25be542013-02-05 11:43:28 -0500406 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust869f9df2014-11-10 18:43:56 -0500408 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409
Trond Myklebustd25be542013-02-05 11:43:28 -0500410 if (delegation == NULL)
411 return 0;
412 do {
Trond Myklebust869f9df2014-11-10 18:43:56 -0500413 if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
414 break;
Trond Myklebust24311f82015-09-20 10:50:17 -0400415 err = nfs_delegation_claim_opens(inode, &delegation->stateid,
416 delegation->type);
Trond Myklebustd25be542013-02-05 11:43:28 -0500417 if (!issync || err != -EAGAIN)
418 break;
419 /*
420 * Guard against state recovery
421 */
422 err = nfs4_wait_clnt_recover(clp);
423 } while (err == 0);
424
425 if (err) {
426 nfs_abort_delegation_return(delegation, clp);
427 goto out;
428 }
429 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500430 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500432 err = nfs_do_return_delegation(inode, delegation, issync);
433out:
434 return err;
Trond Myklebust90163022007-07-05 14:55:18 -0400435}
436
Trond Myklebustb7571442013-04-03 14:33:49 -0400437static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
438{
439 bool ret = false;
440
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500441 if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
442 goto out;
Trond Myklebustb7571442013-04-03 14:33:49 -0400443 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
444 ret = true;
445 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
446 struct inode *inode;
447
448 spin_lock(&delegation->lock);
449 inode = delegation->inode;
450 if (inode && list_empty(&NFS_I(inode)->open_files))
451 ret = true;
452 spin_unlock(&delegation->lock);
453 }
Trond Myklebustec3ca4e2015-02-26 14:05:05 -0500454out:
Trond Myklebustb7571442013-04-03 14:33:49 -0400455 return ret;
456}
457
Chuck Leverd3978bb2010-12-24 01:33:04 +0000458/**
459 * nfs_client_return_marked_delegations - return previously marked delegations
460 * @clp: nfs_client to process
461 *
Trond Myklebustdc327ed2012-05-06 19:46:30 -0400462 * Note that this function is designed to be called by the state
463 * manager thread. For this reason, it cannot flush the dirty data,
464 * since that could deadlock in case of a state recovery error.
465 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000466 * Returns zero on success, or a negative errno value.
Trond Myklebust515d8612008-12-23 15:21:46 -0500467 */
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500468int nfs_client_return_marked_delegations(struct nfs_client *clp)
Trond Myklebust515d8612008-12-23 15:21:46 -0500469{
470 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000471 struct nfs_server *server;
Trond Myklebust515d8612008-12-23 15:21:46 -0500472 struct inode *inode;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500473 int err = 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500474
475restart:
476 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000477 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
478 list_for_each_entry_rcu(delegation, &server->delegations,
479 super_list) {
Trond Myklebustb7571442013-04-03 14:33:49 -0400480 if (!nfs_delegation_need_return(delegation))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000481 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500482 if (!nfs_sb_active(server->super))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000483 continue;
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500484 inode = nfs_delegation_grab_inode(delegation);
485 if (inode == NULL) {
486 rcu_read_unlock();
487 nfs_sb_deactive(server->super);
488 goto restart;
489 }
Trond Myklebustd25be542013-02-05 11:43:28 -0500490 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
Chuck Leverd3978bb2010-12-24 01:33:04 +0000491 rcu_read_unlock();
492
Trond Myklebustd25be542013-02-05 11:43:28 -0500493 err = nfs_end_delegation_return(inode, delegation, 0);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000494 iput(inode);
Trond Myklebust9f0f8e12015-02-26 09:57:34 -0500495 nfs_sb_deactive(server->super);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000496 if (!err)
497 goto restart;
498 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
499 return err;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500500 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500501 }
502 rcu_read_unlock();
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500503 return 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500504}
505
Chuck Leverd3978bb2010-12-24 01:33:04 +0000506/**
507 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
508 * @inode: inode to process
509 *
510 * Does not protect against delegation reclaims, therefore really only safe
511 * to be called from nfs4_clear_inode().
Trond Myklebuste6f81072008-01-24 18:14:34 -0500512 */
513void nfs_inode_return_delegation_noreclaim(struct inode *inode)
514{
Trond Myklebuste6f81072008-01-24 18:14:34 -0500515 struct nfs_delegation *delegation;
516
Trond Myklebustd25be542013-02-05 11:43:28 -0500517 delegation = nfs_inode_detach_delegation(inode);
518 if (delegation != NULL)
Trond Myklebust5fcdfac2015-03-25 13:19:42 -0400519 nfs_do_return_delegation(inode, delegation, 1);
Trond Myklebuste6f81072008-01-24 18:14:34 -0500520}
521
Chuck Leverd3978bb2010-12-24 01:33:04 +0000522/**
523 * nfs_inode_return_delegation - synchronously return a delegation
524 * @inode: inode to process
525 *
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400526 * This routine will always flush any dirty data to disk on the
527 * assumption that if we need to return the delegation, then
528 * we should stop caching.
529 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000530 * Returns zero on success, or a negative errno value.
531 */
Bryan Schumaker57ec14c2012-06-20 15:53:44 -0400532int nfs4_inode_return_delegation(struct inode *inode)
Trond Myklebust90163022007-07-05 14:55:18 -0400533{
Trond Myklebust90163022007-07-05 14:55:18 -0400534 struct nfs_inode *nfsi = NFS_I(inode);
535 struct nfs_delegation *delegation;
536 int err = 0;
537
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400538 nfs_wb_all(inode);
Trond Myklebustd25be542013-02-05 11:43:28 -0500539 delegation = nfs_start_delegation_return(nfsi);
540 if (delegation != NULL)
541 err = nfs_end_delegation_return(inode, delegation, 1);
Trond Myklebust90163022007-07-05 14:55:18 -0400542 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543}
544
Trond Myklebustb7571442013-04-03 14:33:49 -0400545static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
546 struct nfs_delegation *delegation)
547{
548 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
549 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
550}
551
Trond Myklebusted1e6212011-07-25 15:37:29 -0400552static void nfs_mark_return_delegation(struct nfs_server *server,
553 struct nfs_delegation *delegation)
Trond Myklebust6411bd42008-12-23 15:21:51 -0500554{
555 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
Trond Myklebusted1e6212011-07-25 15:37:29 -0400556 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500557}
558
Trond Myklebust5c31e232013-04-03 19:04:58 -0400559static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
560{
561 struct nfs_delegation *delegation;
562 bool ret = false;
563
564 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
565 nfs_mark_return_delegation(server, delegation);
566 ret = true;
567 }
568 return ret;
569}
570
Trond Myklebustb02ba0b2013-04-03 19:23:58 -0400571static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
572{
573 struct nfs_server *server;
574
575 rcu_read_lock();
576 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
577 nfs_server_mark_return_all_delegations(server);
578 rcu_read_unlock();
579}
580
581static void nfs_delegation_run_state_manager(struct nfs_client *clp)
582{
583 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
584 nfs4_schedule_state_manager(clp);
585}
586
587/**
588 * nfs_expire_all_delegations
589 * @clp: client to process
590 *
591 */
592void nfs_expire_all_delegations(struct nfs_client *clp)
593{
594 nfs_client_mark_return_all_delegations(clp);
595 nfs_delegation_run_state_manager(clp);
596}
597
Chuck Leverd3978bb2010-12-24 01:33:04 +0000598/**
599 * nfs_super_return_all_delegations - return delegations for one superblock
600 * @sb: sb to process
601 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 */
Bryan Schumakereeebf912012-06-20 15:53:41 -0400603void nfs_server_return_all_delegations(struct nfs_server *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000605 struct nfs_client *clp = server->nfs_client;
Trond Myklebust5c31e232013-04-03 19:04:58 -0400606 bool need_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
608 if (clp == NULL)
609 return;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000610
Trond Myklebust8383e462007-07-06 15:12:04 -0400611 rcu_read_lock();
Trond Myklebust5c31e232013-04-03 19:04:58 -0400612 need_wait = nfs_server_mark_return_all_delegations(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400613 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000614
Trond Myklebust5c31e232013-04-03 19:04:58 -0400615 if (need_wait) {
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500616 nfs4_schedule_state_manager(clp);
Trond Myklebust5c31e232013-04-03 19:04:58 -0400617 nfs4_wait_clnt_recover(clp);
618 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500619}
620
Trond Myklebust826e0012013-04-03 19:27:52 -0400621static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000622 fmode_t flags)
Trond Myklebust515d8612008-12-23 15:21:46 -0500623{
624 struct nfs_delegation *delegation;
625
Chuck Leverd3978bb2010-12-24 01:33:04 +0000626 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500627 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
628 continue;
629 if (delegation->type & flags)
Trond Myklebust826e0012013-04-03 19:27:52 -0400630 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebust707fb4b2008-12-23 15:21:47 -0500631 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000632}
633
Trond Myklebust826e0012013-04-03 19:27:52 -0400634static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000635 fmode_t flags)
636{
637 struct nfs_server *server;
638
639 rcu_read_lock();
640 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
Trond Myklebust826e0012013-04-03 19:27:52 -0400641 nfs_mark_return_unused_delegation_types(server, flags);
Trond Myklebust515d8612008-12-23 15:21:46 -0500642 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643}
644
Trond Myklebust869f9df2014-11-10 18:43:56 -0500645static void nfs_revoke_delegation(struct inode *inode)
646{
647 struct nfs_delegation *delegation;
648 rcu_read_lock();
649 delegation = rcu_dereference(NFS_I(inode)->delegation);
650 if (delegation != NULL) {
651 set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
652 nfs_mark_return_delegation(NFS_SERVER(inode), delegation);
653 }
654 rcu_read_unlock();
655}
656
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500657void nfs_remove_bad_delegation(struct inode *inode)
658{
659 struct nfs_delegation *delegation;
660
Trond Myklebust869f9df2014-11-10 18:43:56 -0500661 nfs_revoke_delegation(inode);
Trond Myklebustd25be542013-02-05 11:43:28 -0500662 delegation = nfs_inode_detach_delegation(inode);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500663 if (delegation) {
664 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
665 nfs_free_delegation(delegation);
666 }
667}
Andy Adamson9cb81962012-03-07 10:49:41 -0500668EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500669
Chuck Leverd3978bb2010-12-24 01:33:04 +0000670/**
Trond Myklebust826e0012013-04-03 19:27:52 -0400671 * nfs_expire_unused_delegation_types
Chuck Leverd3978bb2010-12-24 01:33:04 +0000672 * @clp: client to process
673 * @flags: delegation types to expire
674 *
675 */
Trond Myklebust826e0012013-04-03 19:27:52 -0400676void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500677{
Trond Myklebust826e0012013-04-03 19:27:52 -0400678 nfs_client_mark_return_unused_delegation_types(clp, flags);
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500679 nfs_delegation_run_state_manager(clp);
680}
681
Chuck Leverd3978bb2010-12-24 01:33:04 +0000682static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
Trond Myklebustb7391f42008-12-23 15:21:52 -0500683{
684 struct nfs_delegation *delegation;
685
Chuck Leverd3978bb2010-12-24 01:33:04 +0000686 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebustb7391f42008-12-23 15:21:52 -0500687 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
688 continue;
Trond Myklebustb7571442013-04-03 14:33:49 -0400689 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebustb7391f42008-12-23 15:21:52 -0500690 }
Trond Myklebustb7391f42008-12-23 15:21:52 -0500691}
692
Chuck Leverd3978bb2010-12-24 01:33:04 +0000693/**
694 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
695 * @clp: nfs_client to process
696 *
697 */
Trond Myklebustb7391f42008-12-23 15:21:52 -0500698void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
699{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000700 struct nfs_server *server;
701
702 rcu_read_lock();
703 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
704 nfs_mark_return_unreferenced_delegations(server);
705 rcu_read_unlock();
706
Trond Myklebustb7391f42008-12-23 15:21:52 -0500707 nfs_delegation_run_state_manager(clp);
708}
709
Chuck Leverd3978bb2010-12-24 01:33:04 +0000710/**
711 * nfs_async_inode_return_delegation - asynchronously return a delegation
712 * @inode: inode to process
Trond Myklebust8e663f02012-03-04 18:13:56 -0500713 * @stateid: state ID information
Chuck Leverd3978bb2010-12-24 01:33:04 +0000714 *
715 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000717int nfs_async_inode_return_delegation(struct inode *inode,
718 const nfs4_stateid *stateid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719{
Trond Myklebusted1e6212011-07-25 15:37:29 -0400720 struct nfs_server *server = NFS_SERVER(inode);
721 struct nfs_client *clp = server->nfs_client;
Trond Myklebust6411bd42008-12-23 15:21:51 -0500722 struct nfs_delegation *delegation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723
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;
Trond Myklebust4816fda2015-09-20 14:58:42 -0400728 if (stateid != NULL &&
729 !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
Trond Myklebust755a48a2014-03-02 22:03:12 -0500730 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
Chuck Leverd3978bb2010-12-24 01:33:04 +0000878 * @inode: inode to check
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500879 * @flags: delegation type requirement
Trond Myklebustabf4e132016-05-16 17:42:44 -0400880 * @dst: stateid data structure to fill in
881 * @cred: optional argument to retrieve credential
Chuck Leverd3978bb2010-12-24 01:33:04 +0000882 *
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500883 * Returns "true" and fills in "dst->data" * if inode had a delegation,
884 * otherwise "false" is returned.
Chuck Leverd3978bb2010-12-24 01:33:04 +0000885 */
Trond Myklebustabf4e132016-05-16 17:42:44 -0400886bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
887 nfs4_stateid *dst, struct rpc_cred **cred)
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500888{
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500889 struct nfs_inode *nfsi = NFS_I(inode);
890 struct nfs_delegation *delegation;
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500891 bool ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500892
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500893 flags &= FMODE_READ|FMODE_WRITE;
Trond Myklebust8383e462007-07-06 15:12:04 -0400894 rcu_read_lock();
895 delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500896 ret = (delegation != NULL && (delegation->type & flags) == flags);
897 if (ret) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500898 nfs4_stateid_copy(dst, &delegation->stateid);
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500899 nfs_mark_delegation_referenced(delegation);
Trond Myklebustabf4e132016-05-16 17:42:44 -0400900 if (cred)
901 *cred = get_rpccred(delegation->cred);
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500902 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400903 rcu_read_unlock();
904 return ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500905}
Trond Myklebust5445b1f2015-09-05 19:06:58 -0400906
907/**
908 * nfs4_delegation_flush_on_close - Check if we must flush file on close
909 * @inode: inode to check
910 *
911 * This function checks the number of outstanding writes to the file
912 * against the delegation 'space_limit' field to see if
913 * the spec requires us to flush the file on close.
914 */
915bool nfs4_delegation_flush_on_close(const struct inode *inode)
916{
917 struct nfs_inode *nfsi = NFS_I(inode);
918 struct nfs_delegation *delegation;
919 bool ret = true;
920
921 rcu_read_lock();
922 delegation = rcu_dereference(nfsi->delegation);
923 if (delegation == NULL || !(delegation->type & FMODE_WRITE))
924 goto out;
925 if (nfsi->nrequests < delegation->pagemod_limit)
926 ret = false;
927out:
928 rcu_read_unlock();
929 return ret;
930}