blob: 5d8ccecf5f5caada2de94bf30689ecd9e725a15a [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
Chuck Leverd3978bb2010-12-24 01:33:04 +000044/**
45 * nfs_have_delegation - check if inode has a delegation
46 * @inode: inode to check
47 * @flags: delegation types to check for
48 *
49 * Returns one if inode has the indicated delegation, otherwise zero.
50 */
Bryan Schumaker011e2a72012-06-20 15:53:43 -040051int nfs4_have_delegation(struct inode *inode, fmode_t flags)
Trond Myklebustb7391f42008-12-23 15:21:52 -050052{
53 struct nfs_delegation *delegation;
54 int ret = 0;
55
56 flags &= FMODE_READ|FMODE_WRITE;
57 rcu_read_lock();
58 delegation = rcu_dereference(NFS_I(inode)->delegation);
Trond Myklebustd25be542013-02-05 11:43:28 -050059 if (delegation != NULL && (delegation->type & flags) == flags &&
60 !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags)) {
Trond Myklebustb7391f42008-12-23 15:21:52 -050061 nfs_mark_delegation_referenced(delegation);
62 ret = 1;
63 }
64 rcu_read_unlock();
65 return ret;
66}
67
Trond Myklebustdb4f2e632013-04-01 15:56:46 -040068static 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 -050069{
70 struct inode *inode = state->inode;
71 struct file_lock *fl;
Trond Myklebustd5122202009-06-17 13:22:58 -070072 int status = 0;
Trond Myklebust888e6942005-11-04 15:38:11 -050073
Trond Myklebust3f09df72009-06-17 13:23:00 -070074 if (inode->i_flock == NULL)
Trond Myklebust65b62a22013-02-07 10:54:07 -050075 goto out;
Jeff Layton314d7cc2013-04-10 15:36:48 -040076
Jeff Layton1c8c6012013-06-21 08:58:15 -040077 /* Protect inode->i_flock using the i_lock */
78 spin_lock(&inode->i_lock);
Harvey Harrison90dc7d22008-02-20 13:03:05 -080079 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
Trond Myklebust888e6942005-11-04 15:38:11 -050080 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
81 continue;
Trond Myklebustcd3758e2007-08-10 17:44:32 -040082 if (nfs_file_open_context(fl->fl_file) != ctx)
Trond Myklebust888e6942005-11-04 15:38:11 -050083 continue;
Jeff Layton1c8c6012013-06-21 08:58:15 -040084 spin_unlock(&inode->i_lock);
Trond Myklebustdb4f2e632013-04-01 15:56:46 -040085 status = nfs4_lock_delegation_recall(fl, state, stateid);
Trond Myklebustd5122202009-06-17 13:22:58 -070086 if (status < 0)
Trond Myklebust3f09df72009-06-17 13:23:00 -070087 goto out;
Jeff Layton1c8c6012013-06-21 08:58:15 -040088 spin_lock(&inode->i_lock);
Trond Myklebust888e6942005-11-04 15:38:11 -050089 }
Jeff Layton1c8c6012013-06-21 08:58:15 -040090 spin_unlock(&inode->i_lock);
Trond Myklebust3f09df72009-06-17 13:23:00 -070091out:
Trond Myklebust888e6942005-11-04 15:38:11 -050092 return status;
93}
94
Trond Myklebustd18cc1f2009-12-03 08:10:17 -050095static int nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *stateid)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096{
97 struct nfs_inode *nfsi = NFS_I(inode);
98 struct nfs_open_context *ctx;
Trond Myklebustd25be542013-02-05 11:43:28 -050099 struct nfs4_state_owner *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 struct nfs4_state *state;
Trond Myklebustd25be542013-02-05 11:43:28 -0500101 unsigned int seq;
Trond Myklebust888e6942005-11-04 15:38:11 -0500102 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103
104again:
105 spin_lock(&inode->i_lock);
106 list_for_each_entry(ctx, &nfsi->open_files, list) {
107 state = ctx->state;
108 if (state == NULL)
109 continue;
110 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
111 continue;
Trond Myklebustf597c532012-03-04 18:13:56 -0500112 if (!nfs4_stateid_match(&state->stateid, stateid))
Trond Myklebust90163022007-07-05 14:55:18 -0400113 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114 get_nfs_open_context(ctx);
115 spin_unlock(&inode->i_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500116 sp = state->owner;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500117 /* Block nfs4_proc_unlck */
118 mutex_lock(&sp->so_delegreturn_mutex);
Trond Myklebustd25be542013-02-05 11:43:28 -0500119 seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
Trond Myklebust13437e12007-07-06 15:10:43 -0400120 err = nfs4_open_delegation_recall(ctx, state, stateid);
Trond Myklebustd25be542013-02-05 11:43:28 -0500121 if (!err)
Trond Myklebustdb4f2e632013-04-01 15:56:46 -0400122 err = nfs_delegation_claim_locks(ctx, state, stateid);
Trond Myklebustd25be542013-02-05 11:43:28 -0500123 if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
124 err = -EAGAIN;
Trond Myklebust65b62a22013-02-07 10:54:07 -0500125 mutex_unlock(&sp->so_delegreturn_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 put_nfs_open_context(ctx);
Trond Myklebust888e6942005-11-04 15:38:11 -0500127 if (err != 0)
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500128 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 goto again;
130 }
131 spin_unlock(&inode->i_lock);
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500132 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
Chuck Leverd3978bb2010-12-24 01:33:04 +0000135/**
136 * nfs_inode_reclaim_delegation - process a delegation reclaim request
137 * @inode: inode to process
138 * @cred: credential to use for request
139 * @res: new delegation state from server
140 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000142void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
143 struct nfs_openres *res)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144{
Trond Myklebust8f649c32010-05-01 12:36:18 -0400145 struct nfs_delegation *delegation;
146 struct rpc_cred *oldcred = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Trond Myklebust8f649c32010-05-01 12:36:18 -0400148 rcu_read_lock();
149 delegation = rcu_dereference(NFS_I(inode)->delegation);
150 if (delegation != NULL) {
151 spin_lock(&delegation->lock);
152 if (delegation->inode != NULL) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500153 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400154 delegation->type = res->delegation_type;
155 delegation->maxsize = res->maxsize;
156 oldcred = delegation->cred;
157 delegation->cred = get_rpccred(cred);
158 clear_bit(NFS_DELEGATION_NEED_RECLAIM,
159 &delegation->flags);
160 NFS_I(inode)->delegation_state = delegation->type;
161 spin_unlock(&delegation->lock);
162 put_rpccred(oldcred);
163 rcu_read_unlock();
Trond Myklebustca8acf82013-08-13 10:36:56 -0400164 trace_nfs4_reclaim_delegation(inode, res->delegation_type);
Trond Myklebust8f649c32010-05-01 12:36:18 -0400165 } else {
166 /* We appear to have raced with a delegation return. */
167 spin_unlock(&delegation->lock);
168 rcu_read_unlock();
169 nfs_inode_set_delegation(inode, cred, res);
170 }
171 } else {
172 rcu_read_unlock();
173 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
175
Trond Myklebust57bfa892008-01-25 16:38:18 -0500176static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
177{
178 int res = 0;
179
180 res = nfs4_proc_delegreturn(inode, delegation->cred, &delegation->stateid, issync);
181 nfs_free_delegation(delegation);
182 return res;
183}
184
Trond Myklebust86e89482008-12-23 15:21:39 -0500185static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
186{
187 struct inode *inode = NULL;
188
189 spin_lock(&delegation->lock);
190 if (delegation->inode != NULL)
191 inode = igrab(delegation->inode);
192 spin_unlock(&delegation->lock);
193 return inode;
194}
195
Chuck Leverdda4b222010-12-24 01:32:54 +0000196static struct nfs_delegation *
Trond Myklebustd25be542013-02-05 11:43:28 -0500197nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
Trond Myklebust57bfa892008-01-25 16:38:18 -0500198{
Trond Myklebustd25be542013-02-05 11:43:28 -0500199 struct nfs_delegation *ret = NULL;
200 struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500201
202 if (delegation == NULL)
Trond Myklebustd25be542013-02-05 11:43:28 -0500203 goto out;
204 spin_lock(&delegation->lock);
205 if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
206 ret = delegation;
207 spin_unlock(&delegation->lock);
208out:
209 return ret;
210}
211
212static struct nfs_delegation *
213nfs_start_delegation_return(struct nfs_inode *nfsi)
214{
215 struct nfs_delegation *delegation;
216
217 rcu_read_lock();
218 delegation = nfs_start_delegation_return_locked(nfsi);
219 rcu_read_unlock();
220 return delegation;
221}
222
223static void
224nfs_abort_delegation_return(struct nfs_delegation *delegation,
225 struct nfs_client *clp)
226{
Chuck Leverdda4b222010-12-24 01:32:54 +0000227
Trond Myklebust34310432008-12-23 15:21:38 -0500228 spin_lock(&delegation->lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500229 clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
230 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
231 spin_unlock(&delegation->lock);
232 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
233}
234
235static struct nfs_delegation *
236nfs_detach_delegation_locked(struct nfs_inode *nfsi,
237 struct nfs_delegation *delegation,
238 struct nfs_client *clp)
239{
240 struct nfs_delegation *deleg_cur =
241 rcu_dereference_protected(nfsi->delegation,
242 lockdep_is_held(&clp->cl_lock));
243
244 if (deleg_cur == NULL || delegation != deleg_cur)
245 return NULL;
246
247 spin_lock(&delegation->lock);
248 set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500249 list_del_rcu(&delegation->super_list);
Trond Myklebust86e89482008-12-23 15:21:39 -0500250 delegation->inode = NULL;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500251 nfsi->delegation_state = 0;
252 rcu_assign_pointer(nfsi->delegation, NULL);
Trond Myklebust34310432008-12-23 15:21:38 -0500253 spin_unlock(&delegation->lock);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500254 return delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500255}
256
Chuck Leverdda4b222010-12-24 01:32:54 +0000257static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
Trond Myklebustd25be542013-02-05 11:43:28 -0500258 struct nfs_delegation *delegation,
259 struct nfs_server *server)
Chuck Leverdda4b222010-12-24 01:32:54 +0000260{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000261 struct nfs_client *clp = server->nfs_client;
Chuck Leverdda4b222010-12-24 01:32:54 +0000262
263 spin_lock(&clp->cl_lock);
Trond Myklebustd25be542013-02-05 11:43:28 -0500264 delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
Chuck Leverdda4b222010-12-24 01:32:54 +0000265 spin_unlock(&clp->cl_lock);
266 return delegation;
267}
268
Trond Myklebustd25be542013-02-05 11:43:28 -0500269static struct nfs_delegation *
270nfs_inode_detach_delegation(struct inode *inode)
271{
272 struct nfs_inode *nfsi = NFS_I(inode);
273 struct nfs_server *server = NFS_SERVER(inode);
274 struct nfs_delegation *delegation;
275
276 delegation = nfs_start_delegation_return(nfsi);
277 if (delegation == NULL)
278 return NULL;
279 return nfs_detach_delegation(nfsi, delegation, server);
280}
281
Chuck Leverd3978bb2010-12-24 01:33:04 +0000282/**
283 * nfs_inode_set_delegation - set up a delegation on an inode
284 * @inode: inode to which delegation applies
285 * @cred: cred to use for subsequent delegation processing
286 * @res: new delegation state from server
287 *
288 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 */
290int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
291{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000292 struct nfs_server *server = NFS_SERVER(inode);
293 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294 struct nfs_inode *nfsi = NFS_I(inode);
David Howells17d2c0a2010-05-01 12:37:18 -0400295 struct nfs_delegation *delegation, *old_delegation;
Trond Myklebust57bfa892008-01-25 16:38:18 -0500296 struct nfs_delegation *freeme = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 int status = 0;
298
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400299 delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 if (delegation == NULL)
301 return -ENOMEM;
Trond Myklebustf597c532012-03-04 18:13:56 -0500302 nfs4_stateid_copy(&delegation->stateid, &res->delegation);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303 delegation->type = res->delegation_type;
304 delegation->maxsize = res->maxsize;
Trond Myklebusta9a4a872011-10-17 16:08:46 -0700305 delegation->change_attr = inode->i_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 delegation->cred = get_rpccred(cred);
307 delegation->inode = inode;
Trond Myklebustb7391f42008-12-23 15:21:52 -0500308 delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
Trond Myklebust34310432008-12-23 15:21:38 -0500309 spin_lock_init(&delegation->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310
311 spin_lock(&clp->cl_lock);
David Howells17d2c0a2010-05-01 12:37:18 -0400312 old_delegation = rcu_dereference_protected(nfsi->delegation,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000313 lockdep_is_held(&clp->cl_lock));
David Howells17d2c0a2010-05-01 12:37:18 -0400314 if (old_delegation != NULL) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500315 if (nfs4_stateid_match(&delegation->stateid,
316 &old_delegation->stateid) &&
David Howells17d2c0a2010-05-01 12:37:18 -0400317 delegation->type == old_delegation->type) {
Trond Myklebust57bfa892008-01-25 16:38:18 -0500318 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 }
Trond Myklebust57bfa892008-01-25 16:38:18 -0500320 /*
321 * Deal with broken servers that hand out two
322 * delegations for the same file.
Trond Myklebust17280172012-03-11 13:11:00 -0400323 * Allow for upgrades to a WRITE delegation, but
324 * nothing else.
Trond Myklebust57bfa892008-01-25 16:38:18 -0500325 */
326 dfprintk(FILE, "%s: server %s handed out "
327 "a duplicate delegation!\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700328 __func__, clp->cl_hostname);
Trond Myklebust17280172012-03-11 13:11:00 -0400329 if (delegation->type == old_delegation->type ||
330 !(delegation->type & FMODE_WRITE)) {
Trond Myklebust57bfa892008-01-25 16:38:18 -0500331 freeme = delegation;
332 delegation = NULL;
333 goto out;
334 }
Trond Myklebustd25be542013-02-05 11:43:28 -0500335 freeme = nfs_detach_delegation_locked(nfsi,
336 old_delegation, clp);
337 if (freeme == NULL)
338 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000340 list_add_rcu(&delegation->super_list, &server->delegations);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500341 nfsi->delegation_state = delegation->type;
342 rcu_assign_pointer(nfsi->delegation, delegation);
343 delegation = NULL;
Trond Myklebust412c77c2007-07-03 16:10:55 -0400344
345 /* Ensure we revalidate the attributes and page cache! */
346 spin_lock(&inode->i_lock);
347 nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
348 spin_unlock(&inode->i_lock);
Trond Myklebustca8acf82013-08-13 10:36:56 -0400349 trace_nfs4_set_delegation(inode, res->delegation_type);
Trond Myklebust412c77c2007-07-03 16:10:55 -0400350
Trond Myklebust57bfa892008-01-25 16:38:18 -0500351out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 spin_unlock(&clp->cl_lock);
Trond Myklebust603c83d2007-10-18 19:59:20 -0400353 if (delegation != NULL)
354 nfs_free_delegation(delegation);
Trond Myklebust57bfa892008-01-25 16:38:18 -0500355 if (freeme != NULL)
356 nfs_do_return_delegation(inode, freeme, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 return status;
358}
359
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360/*
361 * Basic procedure for returning a delegation to the server
362 */
Trond Myklebustd25be542013-02-05 11:43:28 -0500363static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364{
Trond Myklebustd25be542013-02-05 11:43:28 -0500365 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500367 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368
Trond Myklebustd25be542013-02-05 11:43:28 -0500369 if (delegation == NULL)
370 return 0;
371 do {
372 err = nfs_delegation_claim_opens(inode, &delegation->stateid);
373 if (!issync || err != -EAGAIN)
374 break;
375 /*
376 * Guard against state recovery
377 */
378 err = nfs4_wait_clnt_recover(clp);
379 } while (err == 0);
380
381 if (err) {
382 nfs_abort_delegation_return(delegation, clp);
383 goto out;
384 }
385 if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500386 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500388 err = nfs_do_return_delegation(inode, delegation, issync);
389out:
390 return err;
Trond Myklebust90163022007-07-05 14:55:18 -0400391}
392
Trond Myklebustb7571442013-04-03 14:33:49 -0400393static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
394{
395 bool ret = false;
396
397 if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
398 ret = true;
399 if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
400 struct inode *inode;
401
402 spin_lock(&delegation->lock);
403 inode = delegation->inode;
404 if (inode && list_empty(&NFS_I(inode)->open_files))
405 ret = true;
406 spin_unlock(&delegation->lock);
407 }
408 return ret;
409}
410
Chuck Leverd3978bb2010-12-24 01:33:04 +0000411/**
412 * nfs_client_return_marked_delegations - return previously marked delegations
413 * @clp: nfs_client to process
414 *
Trond Myklebustdc327ed2012-05-06 19:46:30 -0400415 * Note that this function is designed to be called by the state
416 * manager thread. For this reason, it cannot flush the dirty data,
417 * since that could deadlock in case of a state recovery error.
418 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000419 * Returns zero on success, or a negative errno value.
Trond Myklebust515d8612008-12-23 15:21:46 -0500420 */
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500421int nfs_client_return_marked_delegations(struct nfs_client *clp)
Trond Myklebust515d8612008-12-23 15:21:46 -0500422{
423 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000424 struct nfs_server *server;
Trond Myklebust515d8612008-12-23 15:21:46 -0500425 struct inode *inode;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500426 int err = 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500427
428restart:
429 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000430 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
431 list_for_each_entry_rcu(delegation, &server->delegations,
432 super_list) {
Trond Myklebustb7571442013-04-03 14:33:49 -0400433 if (!nfs_delegation_need_return(delegation))
Chuck Leverd3978bb2010-12-24 01:33:04 +0000434 continue;
435 inode = nfs_delegation_grab_inode(delegation);
436 if (inode == NULL)
437 continue;
Trond Myklebustd25be542013-02-05 11:43:28 -0500438 delegation = nfs_start_delegation_return_locked(NFS_I(inode));
Chuck Leverd3978bb2010-12-24 01:33:04 +0000439 rcu_read_unlock();
440
Trond Myklebustd25be542013-02-05 11:43:28 -0500441 err = nfs_end_delegation_return(inode, delegation, 0);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000442 iput(inode);
443 if (!err)
444 goto restart;
445 set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
446 return err;
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500447 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500448 }
449 rcu_read_unlock();
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500450 return 0;
Trond Myklebust515d8612008-12-23 15:21:46 -0500451}
452
Chuck Leverd3978bb2010-12-24 01:33:04 +0000453/**
454 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
455 * @inode: inode to process
456 *
457 * Does not protect against delegation reclaims, therefore really only safe
458 * to be called from nfs4_clear_inode().
Trond Myklebuste6f81072008-01-24 18:14:34 -0500459 */
460void nfs_inode_return_delegation_noreclaim(struct inode *inode)
461{
Trond Myklebuste6f81072008-01-24 18:14:34 -0500462 struct nfs_delegation *delegation;
463
Trond Myklebustd25be542013-02-05 11:43:28 -0500464 delegation = nfs_inode_detach_delegation(inode);
465 if (delegation != NULL)
466 nfs_do_return_delegation(inode, delegation, 0);
Trond Myklebuste6f81072008-01-24 18:14:34 -0500467}
468
Chuck Leverd3978bb2010-12-24 01:33:04 +0000469/**
470 * nfs_inode_return_delegation - synchronously return a delegation
471 * @inode: inode to process
472 *
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400473 * This routine will always flush any dirty data to disk on the
474 * assumption that if we need to return the delegation, then
475 * we should stop caching.
476 *
Chuck Leverd3978bb2010-12-24 01:33:04 +0000477 * Returns zero on success, or a negative errno value.
478 */
Bryan Schumaker57ec14c2012-06-20 15:53:44 -0400479int nfs4_inode_return_delegation(struct inode *inode)
Trond Myklebust90163022007-07-05 14:55:18 -0400480{
Trond Myklebust90163022007-07-05 14:55:18 -0400481 struct nfs_inode *nfsi = NFS_I(inode);
482 struct nfs_delegation *delegation;
483 int err = 0;
484
Trond Myklebustc57d1bc2012-05-06 19:34:17 -0400485 nfs_wb_all(inode);
Trond Myklebustd25be542013-02-05 11:43:28 -0500486 delegation = nfs_start_delegation_return(nfsi);
487 if (delegation != NULL)
488 err = nfs_end_delegation_return(inode, delegation, 1);
Trond Myklebust90163022007-07-05 14:55:18 -0400489 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490}
491
Trond Myklebustb7571442013-04-03 14:33:49 -0400492static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
493 struct nfs_delegation *delegation)
494{
495 set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
496 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
497}
498
Trond Myklebusted1e6212011-07-25 15:37:29 -0400499static void nfs_mark_return_delegation(struct nfs_server *server,
500 struct nfs_delegation *delegation)
Trond Myklebust6411bd42008-12-23 15:21:51 -0500501{
502 set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
Trond Myklebusted1e6212011-07-25 15:37:29 -0400503 set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500504}
505
Trond Myklebust5c31e232013-04-03 19:04:58 -0400506static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
507{
508 struct nfs_delegation *delegation;
509 bool ret = false;
510
511 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
512 nfs_mark_return_delegation(server, delegation);
513 ret = true;
514 }
515 return ret;
516}
517
Trond Myklebustb02ba0b2013-04-03 19:23:58 -0400518static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
519{
520 struct nfs_server *server;
521
522 rcu_read_lock();
523 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
524 nfs_server_mark_return_all_delegations(server);
525 rcu_read_unlock();
526}
527
528static void nfs_delegation_run_state_manager(struct nfs_client *clp)
529{
530 if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
531 nfs4_schedule_state_manager(clp);
532}
533
534/**
535 * nfs_expire_all_delegations
536 * @clp: client to process
537 *
538 */
539void nfs_expire_all_delegations(struct nfs_client *clp)
540{
541 nfs_client_mark_return_all_delegations(clp);
542 nfs_delegation_run_state_manager(clp);
543}
544
Chuck Leverd3978bb2010-12-24 01:33:04 +0000545/**
546 * nfs_super_return_all_delegations - return delegations for one superblock
547 * @sb: sb to process
548 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 */
Bryan Schumakereeebf912012-06-20 15:53:41 -0400550void nfs_server_return_all_delegations(struct nfs_server *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000552 struct nfs_client *clp = server->nfs_client;
Trond Myklebust5c31e232013-04-03 19:04:58 -0400553 bool need_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 if (clp == NULL)
556 return;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000557
Trond Myklebust8383e462007-07-06 15:12:04 -0400558 rcu_read_lock();
Trond Myklebust5c31e232013-04-03 19:04:58 -0400559 need_wait = nfs_server_mark_return_all_delegations(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400560 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000561
Trond Myklebust5c31e232013-04-03 19:04:58 -0400562 if (need_wait) {
Trond Myklebustd18cc1f2009-12-03 08:10:17 -0500563 nfs4_schedule_state_manager(clp);
Trond Myklebust5c31e232013-04-03 19:04:58 -0400564 nfs4_wait_clnt_recover(clp);
565 }
Trond Myklebust515d8612008-12-23 15:21:46 -0500566}
567
Trond Myklebust826e0012013-04-03 19:27:52 -0400568static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000569 fmode_t flags)
Trond Myklebust515d8612008-12-23 15:21:46 -0500570{
571 struct nfs_delegation *delegation;
572
Chuck Leverd3978bb2010-12-24 01:33:04 +0000573 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500574 if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
575 continue;
576 if (delegation->type & flags)
Trond Myklebust826e0012013-04-03 19:27:52 -0400577 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebust707fb4b2008-12-23 15:21:47 -0500578 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000579}
580
Trond Myklebust826e0012013-04-03 19:27:52 -0400581static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
Chuck Leverd3978bb2010-12-24 01:33:04 +0000582 fmode_t flags)
583{
584 struct nfs_server *server;
585
586 rcu_read_lock();
587 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
Trond Myklebust826e0012013-04-03 19:27:52 -0400588 nfs_mark_return_unused_delegation_types(server, flags);
Trond Myklebust515d8612008-12-23 15:21:46 -0500589 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590}
591
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500592void nfs_remove_bad_delegation(struct inode *inode)
593{
594 struct nfs_delegation *delegation;
595
Trond Myklebustd25be542013-02-05 11:43:28 -0500596 delegation = nfs_inode_detach_delegation(inode);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500597 if (delegation) {
598 nfs_inode_find_state_and_recover(inode, &delegation->stateid);
599 nfs_free_delegation(delegation);
600 }
601}
Andy Adamson9cb81962012-03-07 10:49:41 -0500602EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -0500603
Chuck Leverd3978bb2010-12-24 01:33:04 +0000604/**
Trond Myklebust826e0012013-04-03 19:27:52 -0400605 * nfs_expire_unused_delegation_types
Chuck Leverd3978bb2010-12-24 01:33:04 +0000606 * @clp: client to process
607 * @flags: delegation types to expire
608 *
609 */
Trond Myklebust826e0012013-04-03 19:27:52 -0400610void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500611{
Trond Myklebust826e0012013-04-03 19:27:52 -0400612 nfs_client_mark_return_unused_delegation_types(clp, flags);
Alexandros Batsakisc79571a2009-12-05 13:20:52 -0500613 nfs_delegation_run_state_manager(clp);
614}
615
Chuck Leverd3978bb2010-12-24 01:33:04 +0000616static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
Trond Myklebustb7391f42008-12-23 15:21:52 -0500617{
618 struct nfs_delegation *delegation;
619
Chuck Leverd3978bb2010-12-24 01:33:04 +0000620 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebustb7391f42008-12-23 15:21:52 -0500621 if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
622 continue;
Trond Myklebustb7571442013-04-03 14:33:49 -0400623 nfs_mark_return_if_closed_delegation(server, delegation);
Trond Myklebustb7391f42008-12-23 15:21:52 -0500624 }
Trond Myklebustb7391f42008-12-23 15:21:52 -0500625}
626
Chuck Leverd3978bb2010-12-24 01:33:04 +0000627/**
628 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
629 * @clp: nfs_client to process
630 *
631 */
Trond Myklebustb7391f42008-12-23 15:21:52 -0500632void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
633{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000634 struct nfs_server *server;
635
636 rcu_read_lock();
637 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
638 nfs_mark_return_unreferenced_delegations(server);
639 rcu_read_unlock();
640
Trond Myklebustb7391f42008-12-23 15:21:52 -0500641 nfs_delegation_run_state_manager(clp);
642}
643
Chuck Leverd3978bb2010-12-24 01:33:04 +0000644/**
645 * nfs_async_inode_return_delegation - asynchronously return a delegation
646 * @inode: inode to process
Trond Myklebust8e663f02012-03-04 18:13:56 -0500647 * @stateid: state ID information
Chuck Leverd3978bb2010-12-24 01:33:04 +0000648 *
649 * Returns zero on success, or a negative errno value.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 */
Chuck Leverd3978bb2010-12-24 01:33:04 +0000651int nfs_async_inode_return_delegation(struct inode *inode,
652 const nfs4_stateid *stateid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653{
Trond Myklebusted1e6212011-07-25 15:37:29 -0400654 struct nfs_server *server = NFS_SERVER(inode);
655 struct nfs_client *clp = server->nfs_client;
Trond Myklebust6411bd42008-12-23 15:21:51 -0500656 struct nfs_delegation *delegation;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Trond Myklebustdc327ed2012-05-06 19:46:30 -0400658 filemap_flush(inode->i_mapping);
659
Trond Myklebust6411bd42008-12-23 15:21:51 -0500660 rcu_read_lock();
661 delegation = rcu_dereference(NFS_I(inode)->delegation);
Trond Myklebust755a48a2014-03-02 22:03:12 -0500662 if (delegation == NULL)
663 goto out_enoent;
Alexandros Batsakis25976412009-12-05 13:48:55 -0500664
Trond Myklebust755a48a2014-03-02 22:03:12 -0500665 if (!clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
666 goto out_enoent;
Trond Myklebusted1e6212011-07-25 15:37:29 -0400667 nfs_mark_return_delegation(server, delegation);
Trond Myklebust6411bd42008-12-23 15:21:51 -0500668 rcu_read_unlock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000669
Trond Myklebust6411bd42008-12-23 15:21:51 -0500670 nfs_delegation_run_state_manager(clp);
671 return 0;
Trond Myklebust755a48a2014-03-02 22:03:12 -0500672out_enoent:
673 rcu_read_unlock();
674 return -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675}
676
Chuck Leverd3978bb2010-12-24 01:33:04 +0000677static struct inode *
678nfs_delegation_find_inode_server(struct nfs_server *server,
679 const struct nfs_fh *fhandle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680{
681 struct nfs_delegation *delegation;
682 struct inode *res = NULL;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000683
684 list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
Trond Myklebust86e89482008-12-23 15:21:39 -0500685 spin_lock(&delegation->lock);
686 if (delegation->inode != NULL &&
687 nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 res = igrab(delegation->inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 }
Trond Myklebust86e89482008-12-23 15:21:39 -0500690 spin_unlock(&delegation->lock);
691 if (res != NULL)
692 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700693 }
Chuck Leverd3978bb2010-12-24 01:33:04 +0000694 return res;
695}
696
697/**
698 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
699 * @clp: client state handle
700 * @fhandle: filehandle from a delegation recall
701 *
702 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
703 * cannot be found.
704 */
705struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
706 const struct nfs_fh *fhandle)
707{
708 struct nfs_server *server;
709 struct inode *res = NULL;
710
711 rcu_read_lock();
712 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
713 res = nfs_delegation_find_inode_server(server, fhandle);
714 if (res != NULL)
715 break;
716 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400717 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 return res;
719}
720
Chuck Leverd3978bb2010-12-24 01:33:04 +0000721static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
722{
723 struct nfs_delegation *delegation;
724
725 list_for_each_entry_rcu(delegation, &server->delegations, super_list)
726 set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
727}
728
729/**
730 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
731 * @clp: nfs_client to process
732 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 */
David Howellsadfa6f92006-08-22 20:06:08 -0400734void nfs_delegation_mark_reclaim(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735{
Chuck Leverd3978bb2010-12-24 01:33:04 +0000736 struct nfs_server *server;
737
Trond Myklebust8383e462007-07-06 15:12:04 -0400738 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000739 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
740 nfs_delegation_mark_reclaim_server(server);
Trond Myklebust8383e462007-07-06 15:12:04 -0400741 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742}
743
Chuck Leverd3978bb2010-12-24 01:33:04 +0000744/**
745 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
746 * @clp: nfs_client to process
747 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 */
David Howellsadfa6f92006-08-22 20:06:08 -0400749void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
Trond Myklebust8383e462007-07-06 15:12:04 -0400751 struct nfs_delegation *delegation;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000752 struct nfs_server *server;
Trond Myklebust86e89482008-12-23 15:21:39 -0500753 struct inode *inode;
Chuck Leverd3978bb2010-12-24 01:33:04 +0000754
Trond Myklebust8383e462007-07-06 15:12:04 -0400755restart:
756 rcu_read_lock();
Chuck Leverd3978bb2010-12-24 01:33:04 +0000757 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
758 list_for_each_entry_rcu(delegation, &server->delegations,
759 super_list) {
760 if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
761 &delegation->flags) == 0)
762 continue;
763 inode = nfs_delegation_grab_inode(delegation);
764 if (inode == NULL)
765 continue;
766 delegation = nfs_detach_delegation(NFS_I(inode),
Trond Myklebustd25be542013-02-05 11:43:28 -0500767 delegation, server);
Chuck Leverd3978bb2010-12-24 01:33:04 +0000768 rcu_read_unlock();
769
770 if (delegation != NULL)
771 nfs_free_delegation(delegation);
772 iput(inode);
773 goto restart;
774 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400776 rcu_read_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777}
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500778
Chuck Leverd3978bb2010-12-24 01:33:04 +0000779/**
780 * nfs_delegations_present - check for existence of delegations
781 * @clp: client state handle
782 *
783 * Returns one if there are any nfs_delegation structures attached
784 * to this nfs_client.
785 */
786int nfs_delegations_present(struct nfs_client *clp)
787{
788 struct nfs_server *server;
789 int ret = 0;
790
791 rcu_read_lock();
792 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
793 if (!list_empty(&server->delegations)) {
794 ret = 1;
795 break;
796 }
797 rcu_read_unlock();
798 return ret;
799}
800
801/**
802 * nfs4_copy_delegation_stateid - Copy inode's state ID information
803 * @dst: stateid data structure to fill in
804 * @inode: inode to check
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500805 * @flags: delegation type requirement
Chuck Leverd3978bb2010-12-24 01:33:04 +0000806 *
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500807 * Returns "true" and fills in "dst->data" * if inode had a delegation,
808 * otherwise "false" is returned.
Chuck Leverd3978bb2010-12-24 01:33:04 +0000809 */
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500810bool nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode,
811 fmode_t flags)
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500812{
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500813 struct nfs_inode *nfsi = NFS_I(inode);
814 struct nfs_delegation *delegation;
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500815 bool ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500816
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500817 flags &= FMODE_READ|FMODE_WRITE;
Trond Myklebust8383e462007-07-06 15:12:04 -0400818 rcu_read_lock();
819 delegation = rcu_dereference(nfsi->delegation);
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500820 ret = (delegation != NULL && (delegation->type & flags) == flags);
821 if (ret) {
Trond Myklebustf597c532012-03-04 18:13:56 -0500822 nfs4_stateid_copy(dst, &delegation->stateid);
Trond Myklebust0032a7a2012-03-08 17:16:12 -0500823 nfs_mark_delegation_referenced(delegation);
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500824 }
Trond Myklebust8383e462007-07-06 15:12:04 -0400825 rcu_read_unlock();
826 return ret;
Trond Myklebust3e4f6292006-03-20 13:44:46 -0500827}