blob: f95e3b58bbc304ae381df2a5f1721d8074789c51 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/nfs/nfs4state.c
3 *
4 * Client-side XDR for NFSv4.
5 *
6 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * All rights reserved.
8 *
9 * Kendrick Smith <kmsmith@umich.edu>
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 *
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * Implementation of the NFSv4 state model. For the time being,
37 * this is minimal, but will be made much more complex in a
38 * subsequent patch.
39 */
40
Trond Myklebust6f43ddc2007-07-08 16:49:11 -040041#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/slab.h>
Arnd Bergmannb89f4322010-09-18 15:09:31 +020043#include <linux/fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include <linux/nfs_fs.h>
45#include <linux/nfs_idmap.h>
Trond Myklebust5043e902006-01-03 09:55:23 +010046#include <linux/kthread.h>
47#include <linux/module.h>
Trond Myklebust9f958ab2007-07-02 13:58:33 -040048#include <linux/random.h>
Randy Dunlap8c7597f2010-10-22 16:18:52 -070049#include <linux/ratelimit.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070050#include <linux/workqueue.h>
51#include <linux/bitops.h>
Chuck Lever0aaaf5c2011-12-06 16:13:48 -050052#include <linux/jiffies.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053
Chuck Lever05f4c352012-09-14 17:24:32 -040054#include <linux/sunrpc/clnt.h>
55
Trond Myklebust4ce79712005-06-22 17:16:21 +000056#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070057#include "callback.h"
58#include "delegation.h"
David Howells24c8dbb2006-08-22 20:06:10 -040059#include "internal.h"
Trond Myklebust76e697b2012-11-26 14:20:49 -050060#include "nfs4session.h"
Andy Adamson974cec82010-10-20 00:18:02 -040061#include "pnfs.h"
Stanislav Kinsburskybbe0a3a2012-08-20 18:00:36 +040062#include "netns.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
Chuck Levere3c0fb72012-05-21 22:45:24 -040064#define NFSDBG_FACILITY NFSDBG_STATE
65
Linus Torvalds1da177e2005-04-16 15:20:36 -070066#define OPENOWNER_POOL_SIZE 8
67
Trond Myklebust4ce79712005-06-22 17:16:21 +000068const nfs4_stateid zero_stateid;
Chuck Lever05f4c352012-09-14 17:24:32 -040069static DEFINE_MUTEX(nfs_clid_init_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Andy Adamson591d71c2009-04-01 09:22:47 -040071int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -070072{
Trond Myklebustfd954ae2011-04-24 14:28:18 -040073 struct nfs4_setclientid_res clid = {
74 .clientid = clp->cl_clientid,
75 .confirm = clp->cl_confirm,
76 };
Chuck Leverf738f512009-03-18 20:48:06 -040077 unsigned short port;
78 int status;
Stanislav Kinsburskybbe0a3a2012-08-20 18:00:36 +040079 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
Chuck Leverf738f512009-03-18 20:48:06 -040080
Trond Myklebustfd954ae2011-04-24 14:28:18 -040081 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
82 goto do_confirm;
Stanislav Kinsburskybbe0a3a2012-08-20 18:00:36 +040083 port = nn->nfs_callback_tcpport;
Chuck Leverf738f512009-03-18 20:48:06 -040084 if (clp->cl_addr.ss_family == AF_INET6)
Stanislav Kinsbursky29dcc162012-08-20 18:00:41 +040085 port = nn->nfs_callback_tcpport6;
Chuck Leverf738f512009-03-18 20:48:06 -040086
Trond Myklebustbb8b27e2010-04-16 16:43:06 -040087 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
88 if (status != 0)
89 goto out;
Trond Myklebustfd954ae2011-04-24 14:28:18 -040090 clp->cl_clientid = clid.clientid;
91 clp->cl_confirm = clid.confirm;
92 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
93do_confirm:
Trond Myklebustbb8b27e2010-04-16 16:43:06 -040094 status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
95 if (status != 0)
96 goto out;
Trond Myklebustfd954ae2011-04-24 14:28:18 -040097 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
Trond Myklebustbb8b27e2010-04-16 16:43:06 -040098 nfs4_schedule_state_renewal(clp);
99out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 return status;
101}
102
Chuck Lever05f4c352012-09-14 17:24:32 -0400103/**
104 * nfs40_discover_server_trunking - Detect server IP address trunking (mv0)
105 *
106 * @clp: nfs_client under test
107 * @result: OUT: found nfs_client, or clp
108 * @cred: credential to use for trunking test
109 *
110 * Returns zero, a negative errno, or a negative NFS4ERR status.
111 * If zero is returned, an nfs_client pointer is planted in
112 * "result".
113 *
114 * Note: The returned client may not yet be marked ready.
115 */
116int nfs40_discover_server_trunking(struct nfs_client *clp,
117 struct nfs_client **result,
118 struct rpc_cred *cred)
119{
120 struct nfs4_setclientid_res clid = {
121 .clientid = clp->cl_clientid,
122 .confirm = clp->cl_confirm,
123 };
Trond Myklebust9f623872012-10-01 16:17:31 -0700124 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
Chuck Lever05f4c352012-09-14 17:24:32 -0400125 unsigned short port;
126 int status;
127
Trond Myklebust9f623872012-10-01 16:17:31 -0700128 port = nn->nfs_callback_tcpport;
Chuck Lever05f4c352012-09-14 17:24:32 -0400129 if (clp->cl_addr.ss_family == AF_INET6)
Trond Myklebust9f623872012-10-01 16:17:31 -0700130 port = nn->nfs_callback_tcpport6;
Chuck Lever05f4c352012-09-14 17:24:32 -0400131
132 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
133 if (status != 0)
134 goto out;
135 clp->cl_clientid = clid.clientid;
136 clp->cl_confirm = clid.confirm;
137
138 status = nfs40_walk_client_list(clp, result, cred);
Trond Myklebust202c3122013-01-18 22:56:23 -0500139 if (status == 0) {
Chuck Lever05f4c352012-09-14 17:24:32 -0400140 /* Sustain the lease, even if it's empty. If the clientid4
141 * goes stale it's of no use for trunking discovery. */
142 nfs4_schedule_state_renewal(*result);
Chuck Lever05f4c352012-09-14 17:24:32 -0400143 }
Chuck Lever05f4c352012-09-14 17:24:32 -0400144out:
145 return status;
146}
147
Andy Adamsona7b72102009-04-01 09:22:46 -0400148struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400149{
150 struct rpc_cred *cred = NULL;
151
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400152 if (clp->cl_machine_cred != NULL)
153 cred = get_rpccred(clp->cl_machine_cred);
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400154 return cred;
155}
156
Chuck Leverd688f7b2013-07-24 12:28:28 -0400157static void nfs4_root_machine_cred(struct nfs_client *clp)
158{
159 struct rpc_cred *cred, *new;
160
161 new = rpc_lookup_machine_cred(NULL);
162 spin_lock(&clp->cl_lock);
163 cred = clp->cl_machine_cred;
164 clp->cl_machine_cred = new;
165 spin_unlock(&clp->cl_lock);
166 if (cred != NULL)
167 put_rpccred(cred);
168}
169
Chuck Lever24d292b2010-12-24 01:32:43 +0000170static struct rpc_cred *
171nfs4_get_renew_cred_server_locked(struct nfs_server *server)
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100172{
Chuck Lever24d292b2010-12-24 01:32:43 +0000173 struct rpc_cred *cred = NULL;
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100174 struct nfs4_state_owner *sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400175 struct rb_node *pos;
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100176
Chuck Lever24d292b2010-12-24 01:32:43 +0000177 for (pos = rb_first(&server->state_owners);
178 pos != NULL;
179 pos = rb_next(pos)) {
180 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100181 if (list_empty(&sp->so_states))
182 continue;
183 cred = get_rpccred(sp->so_cred);
184 break;
185 }
186 return cred;
187}
188
Chuck Lever24d292b2010-12-24 01:32:43 +0000189/**
190 * nfs4_get_renew_cred_locked - Acquire credential for a renew operation
191 * @clp: client state handle
192 *
193 * Returns an rpc_cred with reference count bumped, or NULL.
194 * Caller must hold clp->cl_lock.
195 */
196struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
197{
198 struct rpc_cred *cred = NULL;
199 struct nfs_server *server;
200
Sachin Prabhue49a29b2012-03-16 19:25:52 +0000201 /* Use machine credentials if available */
202 cred = nfs4_get_machine_cred_locked(clp);
203 if (cred != NULL)
204 goto out;
205
Chuck Lever24d292b2010-12-24 01:32:43 +0000206 rcu_read_lock();
207 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
208 cred = nfs4_get_renew_cred_server_locked(server);
209 if (cred != NULL)
210 break;
211 }
212 rcu_read_unlock();
Sachin Prabhue49a29b2012-03-16 19:25:52 +0000213
214out:
Chuck Lever24d292b2010-12-24 01:32:43 +0000215 return cred;
216}
217
Andy Adamson62f288a2013-06-19 16:39:44 -0400218static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500219{
Andy Adamson774d5f12013-05-20 14:13:50 -0400220 if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
Trond Myklebust961a8282012-01-17 22:57:37 -0500221 spin_lock(&tbl->slot_tbl_lock);
Trond Myklebustb75ad4c2012-11-29 17:27:47 -0500222 nfs41_wake_slot_table(tbl);
Trond Myklebust961a8282012-01-17 22:57:37 -0500223 spin_unlock(&tbl->slot_tbl_lock);
Alexandros Batsakis689cf5c2009-12-14 21:27:56 -0800224 }
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500225}
226
Andy Adamson62f288a2013-06-19 16:39:44 -0400227static void nfs4_end_drain_session(struct nfs_client *clp)
228{
229 struct nfs4_session *ses = clp->cl_session;
230
Chuck Lever2cf8bca2013-08-09 12:49:56 -0400231 if (clp->cl_slot_tbl) {
232 nfs4_end_drain_slot_table(clp->cl_slot_tbl);
233 return;
234 }
235
Andy Adamson62f288a2013-06-19 16:39:44 -0400236 if (ses != NULL) {
237 nfs4_end_drain_slot_table(&ses->bc_slot_table);
238 nfs4_end_drain_slot_table(&ses->fc_slot_table);
239 }
240}
241
Andy Adamson774d5f12013-05-20 14:13:50 -0400242static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500243{
Andy Adamson774d5f12013-05-20 14:13:50 -0400244 set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500245 spin_lock(&tbl->slot_tbl_lock);
Andy Adamsonb6bf6e72012-02-17 13:05:23 -0500246 if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
Wolfram Sang16735d02013-11-14 14:32:02 -0800247 reinit_completion(&tbl->complete);
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500248 spin_unlock(&tbl->slot_tbl_lock);
Andy Adamson42acd022011-01-06 02:04:34 +0000249 return wait_for_completion_interruptible(&tbl->complete);
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500250 }
251 spin_unlock(&tbl->slot_tbl_lock);
252 return 0;
253}
254
Andy Adamson42acd022011-01-06 02:04:34 +0000255static int nfs4_begin_drain_session(struct nfs_client *clp)
256{
257 struct nfs4_session *ses = clp->cl_session;
258 int ret = 0;
259
Chuck Lever2cf8bca2013-08-09 12:49:56 -0400260 if (clp->cl_slot_tbl)
261 return nfs4_drain_slot_tbl(clp->cl_slot_tbl);
262
Andy Adamson42acd022011-01-06 02:04:34 +0000263 /* back channel */
Andy Adamson774d5f12013-05-20 14:13:50 -0400264 ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
Andy Adamson42acd022011-01-06 02:04:34 +0000265 if (ret)
266 return ret;
267 /* fore channel */
Andy Adamson774d5f12013-05-20 14:13:50 -0400268 return nfs4_drain_slot_tbl(&ses->fc_slot_table);
Andy Adamson42acd022011-01-06 02:04:34 +0000269}
270
Chuck Leverc9fdeb22013-10-17 14:13:02 -0400271#if defined(CONFIG_NFS_V4_1)
272
Chuck Lever2cf8bca2013-08-09 12:49:56 -0400273static int nfs41_setup_state_renewal(struct nfs_client *clp)
274{
275 int status;
276 struct nfs_fsinfo fsinfo;
277
278 if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
279 nfs4_schedule_state_renewal(clp);
280 return 0;
281 }
282
283 status = nfs4_proc_get_lease_time(clp, &fsinfo);
284 if (status == 0) {
285 /* Update lease time and schedule renewal */
286 spin_lock(&clp->cl_lock);
287 clp->cl_lease_time = fsinfo.lease_time * HZ;
288 clp->cl_last_renewal = jiffies;
289 spin_unlock(&clp->cl_lock);
290
291 nfs4_schedule_state_renewal(clp);
292 }
293
294 return status;
295}
296
Trond Myklebustbda197f2012-06-05 10:22:14 -0400297static void nfs41_finish_session_reset(struct nfs_client *clp)
298{
299 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
300 clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
301 /* create_session negotiated new slot table */
Trond Myklebustbda197f2012-06-05 10:22:14 -0400302 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
303 nfs41_setup_state_renewal(clp);
304}
305
Andy Adamson4d643d12009-12-04 15:52:24 -0500306int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
307{
308 int status;
309
Trond Myklebustfd954ae2011-04-24 14:28:18 -0400310 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
311 goto do_confirm;
Trond Myklebust38045412009-12-15 17:36:57 -0500312 nfs4_begin_drain_session(clp);
Andy Adamson4d643d12009-12-04 15:52:24 -0500313 status = nfs4_proc_exchange_id(clp, cred);
Ricardo Labiaga9430fb62009-12-06 12:23:46 -0500314 if (status != 0)
315 goto out;
Trond Myklebustfd954ae2011-04-24 14:28:18 -0400316 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
317do_confirm:
Trond Myklebust848f5bd2012-05-25 17:51:23 -0400318 status = nfs4_proc_create_session(clp, cred);
Ricardo Labiaga9430fb62009-12-06 12:23:46 -0500319 if (status != 0)
320 goto out;
Trond Myklebustbda197f2012-06-05 10:22:14 -0400321 nfs41_finish_session_reset(clp);
Ricardo Labiaga9430fb62009-12-06 12:23:46 -0500322 nfs_mark_client_ready(clp, NFS_CS_READY);
323out:
Andy Adamson4d643d12009-12-04 15:52:24 -0500324 return status;
325}
326
Chuck Lever05f4c352012-09-14 17:24:32 -0400327/**
328 * nfs41_discover_server_trunking - Detect server IP address trunking (mv1)
329 *
330 * @clp: nfs_client under test
331 * @result: OUT: found nfs_client, or clp
332 * @cred: credential to use for trunking test
333 *
334 * Returns NFS4_OK, a negative errno, or a negative NFS4ERR status.
335 * If NFS4_OK is returned, an nfs_client pointer is planted in
336 * "result".
337 *
338 * Note: The returned client may not yet be marked ready.
339 */
340int nfs41_discover_server_trunking(struct nfs_client *clp,
341 struct nfs_client **result,
342 struct rpc_cred *cred)
343{
344 int status;
345
346 status = nfs4_proc_exchange_id(clp, cred);
347 if (status != NFS4_OK)
348 return status;
349
Trond Myklebust48d66b92015-03-03 20:28:59 -0500350 status = nfs41_walk_client_list(clp, result, cred);
351 if (status < 0)
352 return status;
353 if (clp != *result)
354 return 0;
355
Trond Myklebuste11259f2015-03-03 20:35:31 -0500356 /* Purge state if the client id was established in a prior instance */
357 if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R)
358 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
359 else
360 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
Trond Myklebust48d66b92015-03-03 20:28:59 -0500361 nfs4_schedule_state_manager(clp);
362 status = nfs_wait_client_init_complete(clp);
363 if (status < 0)
364 nfs_put_client(clp);
365 return status;
Chuck Lever05f4c352012-09-14 17:24:32 -0400366}
367
Andy Adamsonb4b82602009-04-01 09:22:49 -0400368#endif /* CONFIG_NFS_V4_1 */
369
Chuck Lever24d292b2010-12-24 01:32:43 +0000370/**
Chuck Lever73d8bde2013-07-24 12:28:37 -0400371 * nfs4_get_clid_cred - Acquire credential for a setclientid operation
Chuck Lever24d292b2010-12-24 01:32:43 +0000372 * @clp: client state handle
373 *
374 * Returns an rpc_cred with reference count bumped, or NULL.
375 */
Chuck Lever73d8bde2013-07-24 12:28:37 -0400376struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp)
Chuck Lever24d292b2010-12-24 01:32:43 +0000377{
Chuck Lever24d292b2010-12-24 01:32:43 +0000378 struct rpc_cred *cred;
379
380 spin_lock(&clp->cl_lock);
381 cred = nfs4_get_machine_cred_locked(clp);
382 spin_unlock(&clp->cl_lock);
Chuck Lever24d292b2010-12-24 01:32:43 +0000383 return cred;
384}
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386static struct nfs4_state_owner *
Chuck Lever24d292b2010-12-24 01:32:43 +0000387nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
Chuck Lever24d292b2010-12-24 01:32:43 +0000389 struct rb_node **p = &server->state_owners.rb_node,
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400390 *parent = NULL;
Chuck Lever414adf12011-12-06 16:13:39 -0500391 struct nfs4_state_owner *sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400393 while (*p != NULL) {
394 parent = *p;
Chuck Lever24d292b2010-12-24 01:32:43 +0000395 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400396
397 if (cred < sp->so_cred)
398 p = &parent->rb_left;
399 else if (cred > sp->so_cred)
400 p = &parent->rb_right;
401 else {
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500402 if (!list_empty(&sp->so_lru))
403 list_del_init(&sp->so_lru);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400404 atomic_inc(&sp->so_count);
Chuck Lever414adf12011-12-06 16:13:39 -0500405 return sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 }
Chuck Lever414adf12011-12-06 16:13:39 -0500408 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409}
410
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400411static struct nfs4_state_owner *
Chuck Lever24d292b2010-12-24 01:32:43 +0000412nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400413{
Chuck Lever24d292b2010-12-24 01:32:43 +0000414 struct nfs_server *server = new->so_server;
415 struct rb_node **p = &server->state_owners.rb_node,
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400416 *parent = NULL;
417 struct nfs4_state_owner *sp;
Trond Myklebust9157c312012-01-17 22:04:24 -0500418 int err;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400419
420 while (*p != NULL) {
421 parent = *p;
Chuck Lever24d292b2010-12-24 01:32:43 +0000422 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400423
424 if (new->so_cred < sp->so_cred)
425 p = &parent->rb_left;
426 else if (new->so_cred > sp->so_cred)
427 p = &parent->rb_right;
428 else {
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500429 if (!list_empty(&sp->so_lru))
430 list_del_init(&sp->so_lru);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400431 atomic_inc(&sp->so_count);
432 return sp;
433 }
434 }
Trond Myklebust48c22eb2012-01-17 22:04:25 -0500435 err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
Trond Myklebust9157c312012-01-17 22:04:24 -0500436 if (err)
437 return ERR_PTR(err);
Chuck Lever24d292b2010-12-24 01:32:43 +0000438 rb_link_node(&new->so_server_node, parent, p);
439 rb_insert_color(&new->so_server_node, &server->state_owners);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400440 return new;
441}
442
443static void
Chuck Lever24d292b2010-12-24 01:32:43 +0000444nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400445{
Chuck Lever24d292b2010-12-24 01:32:43 +0000446 struct nfs_server *server = sp->so_server;
447
448 if (!RB_EMPTY_NODE(&sp->so_server_node))
449 rb_erase(&sp->so_server_node, &server->state_owners);
Trond Myklebust48c22eb2012-01-17 22:04:25 -0500450 ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400451}
452
Trond Myklebust7ba127a2012-01-17 22:04:25 -0500453static void
454nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
455{
Trond Myklebust95b72eb2012-04-20 19:24:51 -0400456 sc->create_time = ktime_get();
Trond Myklebust7ba127a2012-01-17 22:04:25 -0500457 sc->flags = 0;
458 sc->counter = 0;
459 spin_lock_init(&sc->lock);
460 INIT_LIST_HEAD(&sc->list);
461 rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
462}
463
464static void
465nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
466{
467 rpc_destroy_wait_queue(&sc->wait);
468}
469
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470/*
471 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
472 * create a new state_owner.
473 *
474 */
475static struct nfs4_state_owner *
Trond Myklebustd1e284d2012-01-17 22:04:24 -0500476nfs4_alloc_state_owner(struct nfs_server *server,
477 struct rpc_cred *cred,
478 gfp_t gfp_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
480 struct nfs4_state_owner *sp;
481
Trond Myklebustd1e284d2012-01-17 22:04:24 -0500482 sp = kzalloc(sizeof(*sp), gfp_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 if (!sp)
484 return NULL;
Trond Myklebustd1e284d2012-01-17 22:04:24 -0500485 sp->so_server = server;
486 sp->so_cred = get_rpccred(cred);
Trond Myklebustec073422005-10-20 14:22:47 -0700487 spin_lock_init(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 INIT_LIST_HEAD(&sp->so_states);
Trond Myklebust7ba127a2012-01-17 22:04:25 -0500489 nfs4_init_seqid_counter(&sp->so_seqid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 atomic_set(&sp->so_count, 1);
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500491 INIT_LIST_HEAD(&sp->so_lru);
Trond Myklebustc137afa2013-02-07 14:41:11 -0500492 seqcount_init(&sp->so_reclaim_seqcount);
Trond Myklebust65b62a22013-02-07 10:54:07 -0500493 mutex_init(&sp->so_delegreturn_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 return sp;
495}
496
Adrian Bunk1d2e88e2008-05-02 13:42:45 -0700497static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498nfs4_drop_state_owner(struct nfs4_state_owner *sp)
499{
Trond Myklebustc77365c2012-04-21 12:31:05 -0400500 struct rb_node *rb_node = &sp->so_server_node;
501
502 if (!RB_EMPTY_NODE(rb_node)) {
Chuck Lever24d292b2010-12-24 01:32:43 +0000503 struct nfs_server *server = sp->so_server;
504 struct nfs_client *clp = server->nfs_client;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400505
506 spin_lock(&clp->cl_lock);
Trond Myklebustc77365c2012-04-21 12:31:05 -0400507 if (!RB_EMPTY_NODE(rb_node)) {
508 rb_erase(rb_node, &server->state_owners);
509 RB_CLEAR_NODE(rb_node);
510 }
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400511 spin_unlock(&clp->cl_lock);
512 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513}
514
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500515static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
516{
Trond Myklebust7ba127a2012-01-17 22:04:25 -0500517 nfs4_destroy_seqid_counter(&sp->so_seqid);
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500518 put_rpccred(sp->so_cred);
519 kfree(sp);
520}
521
522static void nfs4_gc_state_owners(struct nfs_server *server)
523{
524 struct nfs_client *clp = server->nfs_client;
525 struct nfs4_state_owner *sp, *tmp;
526 unsigned long time_min, time_max;
527 LIST_HEAD(doomed);
528
529 spin_lock(&clp->cl_lock);
530 time_max = jiffies;
531 time_min = (long)time_max - (long)clp->cl_lease_time;
532 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
533 /* NB: LRU is sorted so that oldest is at the head */
534 if (time_in_range(sp->so_expires, time_min, time_max))
535 break;
536 list_move(&sp->so_lru, &doomed);
537 nfs4_remove_state_owner_locked(sp);
538 }
539 spin_unlock(&clp->cl_lock);
540
541 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
542 list_del(&sp->so_lru);
543 nfs4_free_state_owner(sp);
544 }
545}
546
Chuck Lever24d292b2010-12-24 01:32:43 +0000547/**
548 * nfs4_get_state_owner - Look up a state owner given a credential
549 * @server: nfs_server to search
550 * @cred: RPC credential to match
551 *
552 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
553 */
554struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
Trond Myklebustd1e284d2012-01-17 22:04:24 -0500555 struct rpc_cred *cred,
556 gfp_t gfp_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557{
David Howells7539bba2006-08-22 20:06:09 -0400558 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 struct nfs4_state_owner *sp, *new;
560
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 spin_lock(&clp->cl_lock);
Chuck Lever24d292b2010-12-24 01:32:43 +0000562 sp = nfs4_find_state_owner_locked(server, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 spin_unlock(&clp->cl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564 if (sp != NULL)
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500565 goto out;
Trond Myklebustd1e284d2012-01-17 22:04:24 -0500566 new = nfs4_alloc_state_owner(server, cred, gfp_flags);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400567 if (new == NULL)
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500568 goto out;
Trond Myklebust9157c312012-01-17 22:04:24 -0500569 do {
570 if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
571 break;
572 spin_lock(&clp->cl_lock);
573 sp = nfs4_insert_state_owner_locked(new);
574 spin_unlock(&clp->cl_lock);
575 } while (sp == ERR_PTR(-EAGAIN));
Trond Myklebustd1e284d2012-01-17 22:04:24 -0500576 if (sp != new)
577 nfs4_free_state_owner(new);
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500578out:
579 nfs4_gc_state_owners(server);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400580 return sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581}
582
Chuck Lever24d292b2010-12-24 01:32:43 +0000583/**
584 * nfs4_put_state_owner - Release a nfs4_state_owner
585 * @sp: state owner data to release
Trond Myklebust7bf97bc2012-04-21 12:36:19 -0400586 *
587 * Note that we keep released state owners on an LRU
588 * list.
589 * This caches valid state owners so that they can be
590 * reused, to avoid the OPEN_CONFIRM on minor version 0.
591 * It also pins the uniquifier of dropped state owners for
592 * a while, to ensure that those state owner names are
593 * never reused.
Chuck Lever24d292b2010-12-24 01:32:43 +0000594 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595void nfs4_put_state_owner(struct nfs4_state_owner *sp)
596{
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500597 struct nfs_server *server = sp->so_server;
598 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599
600 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
601 return;
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500602
Trond Myklebust7bf97bc2012-04-21 12:36:19 -0400603 sp->so_expires = jiffies;
604 list_add_tail(&sp->so_lru, &server->state_owners_lru);
605 spin_unlock(&clp->cl_lock);
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500606}
607
608/**
609 * nfs4_purge_state_owners - Release all cached state owners
610 * @server: nfs_server with cached state owners to release
611 *
612 * Called at umount time. Remaining state owners will be on
613 * the LRU with ref count of zero.
614 */
615void nfs4_purge_state_owners(struct nfs_server *server)
616{
617 struct nfs_client *clp = server->nfs_client;
618 struct nfs4_state_owner *sp, *tmp;
619 LIST_HEAD(doomed);
620
621 spin_lock(&clp->cl_lock);
622 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
623 list_move(&sp->so_lru, &doomed);
624 nfs4_remove_state_owner_locked(sp);
625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 spin_unlock(&clp->cl_lock);
Chuck Lever0aaaf5c2011-12-06 16:13:48 -0500627
628 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
629 list_del(&sp->so_lru);
630 nfs4_free_state_owner(sp);
631 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632}
633
634static struct nfs4_state *
635nfs4_alloc_open_state(void)
636{
637 struct nfs4_state *state;
638
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400639 state = kzalloc(sizeof(*state), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 if (!state)
641 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 atomic_set(&state->count, 1);
643 INIT_LIST_HEAD(&state->lock_states);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000644 spin_lock_init(&state->state_lock);
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400645 seqlock_init(&state->seqlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 return state;
647}
648
Trond Myklebust4cecb762005-11-04 15:32:58 -0500649void
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500650nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
Trond Myklebust4cecb762005-11-04 15:32:58 -0500651{
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500652 if (state->state == fmode)
Trond Myklebust4cecb762005-11-04 15:32:58 -0500653 return;
654 /* NB! List reordering - see the reclaim code for why. */
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500655 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
656 if (fmode & FMODE_WRITE)
Trond Myklebust4cecb762005-11-04 15:32:58 -0500657 list_move(&state->open_states, &state->owner->so_states);
658 else
659 list_move_tail(&state->open_states, &state->owner->so_states);
660 }
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500661 state->state = fmode;
Trond Myklebust4cecb762005-11-04 15:32:58 -0500662}
663
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664static struct nfs4_state *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
666{
667 struct nfs_inode *nfsi = NFS_I(inode);
668 struct nfs4_state *state;
669
670 list_for_each_entry(state, &nfsi->open_states, inode_states) {
Trond Myklebust1c816ef2007-07-03 14:41:19 -0400671 if (state->owner != owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 continue;
Trond Myklebust5d422302013-03-14 16:57:48 -0400673 if (!nfs4_valid_open_stateid(state))
674 continue;
Trond Myklebust1c816ef2007-07-03 14:41:19 -0400675 if (atomic_inc_not_zero(&state->count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 }
678 return NULL;
679}
680
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681static void
682nfs4_free_open_state(struct nfs4_state *state)
683{
684 kfree(state);
685}
686
687struct nfs4_state *
688nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
689{
690 struct nfs4_state *state, *new;
691 struct nfs_inode *nfsi = NFS_I(inode);
692
693 spin_lock(&inode->i_lock);
694 state = __nfs4_find_state_byowner(inode, owner);
695 spin_unlock(&inode->i_lock);
696 if (state)
697 goto out;
698 new = nfs4_alloc_open_state();
Trond Myklebustec073422005-10-20 14:22:47 -0700699 spin_lock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 spin_lock(&inode->i_lock);
701 state = __nfs4_find_state_byowner(inode, owner);
702 if (state == NULL && new != NULL) {
703 state = new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 state->owner = owner;
705 atomic_inc(&owner->so_count);
706 list_add(&state->inode_states, &nfsi->open_states);
Dave Chinner0444d762011-03-29 18:08:50 +1100707 ihold(inode);
708 state->inode = inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 spin_unlock(&inode->i_lock);
Trond Myklebustec073422005-10-20 14:22:47 -0700710 /* Note: The reclaim code dictates that we add stateless
711 * and read-only stateids to the end of the list */
712 list_add_tail(&state->open_states, &owner->so_states);
713 spin_unlock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 } else {
715 spin_unlock(&inode->i_lock);
Trond Myklebustec073422005-10-20 14:22:47 -0700716 spin_unlock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 if (new)
718 nfs4_free_open_state(new);
719 }
720out:
721 return state;
722}
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724void nfs4_put_open_state(struct nfs4_state *state)
725{
726 struct inode *inode = state->inode;
727 struct nfs4_state_owner *owner = state->owner;
728
Trond Myklebustec073422005-10-20 14:22:47 -0700729 if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 return;
Trond Myklebustec073422005-10-20 14:22:47 -0700731 spin_lock(&inode->i_lock);
Trond Myklebustba6830312007-07-27 10:23:05 -0400732 list_del(&state->inode_states);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 list_del(&state->open_states);
Trond Myklebustec073422005-10-20 14:22:47 -0700734 spin_unlock(&inode->i_lock);
735 spin_unlock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 nfs4_free_open_state(state);
738 nfs4_put_state_owner(owner);
739}
740
741/*
Trond Myklebust83c9d412005-10-18 14:20:13 -0700742 * Close the current file.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743 */
Al Viro643168c2011-06-22 18:20:23 -0400744static void __nfs4_close(struct nfs4_state *state,
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400745 fmode_t fmode, gfp_t gfp_mask, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747 struct nfs4_state_owner *owner = state->owner;
Trond Myklebust003707c2007-07-05 18:07:55 -0400748 int call_close = 0;
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500749 fmode_t newstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750
751 atomic_inc(&owner->so_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 /* Protect against nfs4_find_state() */
Trond Myklebustec073422005-10-20 14:22:47 -0700753 spin_lock(&owner->so_lock);
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500754 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
Trond Myklebuste7616922006-01-03 09:55:13 +0100755 case FMODE_READ:
756 state->n_rdonly--;
757 break;
758 case FMODE_WRITE:
759 state->n_wronly--;
760 break;
761 case FMODE_READ|FMODE_WRITE:
762 state->n_rdwr--;
763 }
Trond Myklebust003707c2007-07-05 18:07:55 -0400764 newstate = FMODE_READ|FMODE_WRITE;
Trond Myklebuste7616922006-01-03 09:55:13 +0100765 if (state->n_rdwr == 0) {
Trond Myklebust003707c2007-07-05 18:07:55 -0400766 if (state->n_rdonly == 0) {
Trond Myklebuste7616922006-01-03 09:55:13 +0100767 newstate &= ~FMODE_READ;
Trond Myklebust003707c2007-07-05 18:07:55 -0400768 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
769 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
770 }
771 if (state->n_wronly == 0) {
Trond Myklebuste7616922006-01-03 09:55:13 +0100772 newstate &= ~FMODE_WRITE;
Trond Myklebust003707c2007-07-05 18:07:55 -0400773 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
774 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
775 }
776 if (newstate == 0)
777 clear_bit(NFS_DELEGATED_STATE, &state->flags);
Trond Myklebuste7616922006-01-03 09:55:13 +0100778 }
Trond Myklebust003707c2007-07-05 18:07:55 -0400779 nfs4_state_set_mode_locked(state, newstate);
Trond Myklebustec073422005-10-20 14:22:47 -0700780 spin_unlock(&owner->so_lock);
Trond Myklebust4cecb762005-11-04 15:32:58 -0500781
Trond Myklebust003707c2007-07-05 18:07:55 -0400782 if (!call_close) {
Trond Myklebustb39e6252007-06-11 23:05:07 -0400783 nfs4_put_open_state(state);
784 nfs4_put_state_owner(owner);
Trond Myklebust1f7977c2012-09-20 20:31:51 -0400785 } else
786 nfs4_do_close(state, gfp_mask, wait);
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400787}
788
Al Viro643168c2011-06-22 18:20:23 -0400789void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400790{
Al Viro643168c2011-06-22 18:20:23 -0400791 __nfs4_close(state, fmode, GFP_NOFS, 0);
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400792}
793
Al Viro643168c2011-06-22 18:20:23 -0400794void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400795{
Al Viro643168c2011-06-22 18:20:23 -0400796 __nfs4_close(state, fmode, GFP_KERNEL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797}
798
799/*
800 * Search the state->lock_states for an existing lock_owner
801 * that is compatible with current->files
802 */
803static struct nfs4_lock_state *
Jeff Layton8003d3c2014-05-01 06:28:45 -0400804__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805{
806 struct nfs4_lock_state *pos;
807 list_for_each_entry(pos, &state->lock_states, ls_locks) {
Jeff Layton8003d3c2014-05-01 06:28:45 -0400808 if (pos->ls_owner != fl_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700809 continue;
810 atomic_inc(&pos->ls_count);
811 return pos;
812 }
813 return NULL;
814}
815
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816/*
817 * Return a compatible lock_state. If no initialized lock_state structure
818 * exists, return an uninitialized one.
819 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 */
Jeff Layton8003d3c2014-05-01 06:28:45 -0400821static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822{
823 struct nfs4_lock_state *lsp;
Chuck Lever24d292b2010-12-24 01:32:43 +0000824 struct nfs_server *server = state->owner->so_server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825
Trond Myklebust8535b2b2010-05-13 12:51:01 -0400826 lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 if (lsp == NULL)
828 return NULL;
Trond Myklebust7ba127a2012-01-17 22:04:25 -0500829 nfs4_init_seqid_counter(&lsp->ls_seqid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 atomic_set(&lsp->ls_count, 1);
Trond Myklebustb64aec82009-07-21 16:47:46 -0400831 lsp->ls_state = state;
Jeff Layton8003d3c2014-05-01 06:28:45 -0400832 lsp->ls_owner = fl_owner;
Trond Myklebust48c22eb2012-01-17 22:04:25 -0500833 lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
834 if (lsp->ls_seqid.owner_id < 0)
Trond Myklebustd2d7ce22012-01-17 22:04:25 -0500835 goto out_free;
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000836 INIT_LIST_HEAD(&lsp->ls_locks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 return lsp;
Trond Myklebustd2d7ce22012-01-17 22:04:25 -0500838out_free:
839 kfree(lsp);
840 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841}
842
Trond Myklebust5ae67c42012-03-19 16:17:18 -0400843void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400844{
Trond Myklebust48c22eb2012-01-17 22:04:25 -0500845 ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
Trond Myklebust7ba127a2012-01-17 22:04:25 -0500846 nfs4_destroy_seqid_counter(&lsp->ls_seqid);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400847 kfree(lsp);
848}
849
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850/*
851 * Return a compatible lock_state. If no initialized lock_state structure
852 * exists, return an uninitialized one.
853 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 */
Jeff Layton8003d3c2014-05-01 06:28:45 -0400855static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856{
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000857 struct nfs4_lock_state *lsp, *new = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000859 for(;;) {
860 spin_lock(&state->state_lock);
Jeff Layton8003d3c2014-05-01 06:28:45 -0400861 lsp = __nfs4_find_lock_state(state, owner);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000862 if (lsp != NULL)
863 break;
864 if (new != NULL) {
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000865 list_add(&new->ls_locks, &state->lock_states);
866 set_bit(LK_STATE_IN_USE, &state->flags);
867 lsp = new;
868 new = NULL;
869 break;
870 }
871 spin_unlock(&state->state_lock);
Jeff Layton8003d3c2014-05-01 06:28:45 -0400872 new = nfs4_alloc_lock_state(state, owner);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000873 if (new == NULL)
874 return NULL;
875 }
876 spin_unlock(&state->state_lock);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400877 if (new != NULL)
Trond Myklebust5ae67c42012-03-19 16:17:18 -0400878 nfs4_free_lock_state(state->owner->so_server, new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 return lsp;
880}
881
882/*
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000883 * Release reference to lock_state, and free it if we see that
884 * it is no longer in use
885 */
Trond Myklebustfaf5f492005-10-18 14:20:15 -0700886void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000887{
Trond Myklebustc8b2d0b2013-05-03 16:22:55 -0400888 struct nfs_server *server;
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000889 struct nfs4_state *state;
890
891 if (lsp == NULL)
892 return;
893 state = lsp->ls_state;
894 if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
895 return;
896 list_del(&lsp->ls_locks);
897 if (list_empty(&state->lock_states))
898 clear_bit(LK_STATE_IN_USE, &state->flags);
899 spin_unlock(&state->state_lock);
Jeff Layton0c0e0d32014-09-08 08:26:01 -0400900 server = state->owner->so_server;
901 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
902 struct nfs_client *clp = server->nfs_client;
903
904 clp->cl_mvops->free_lock_state(server, lsp);
905 } else
Trond Myklebustc8b2d0b2013-05-03 16:22:55 -0400906 nfs4_free_lock_state(server, lsp);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000907}
908
909static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
910{
911 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
912
913 dst->fl_u.nfs4_fl.owner = lsp;
914 atomic_inc(&lsp->ls_count);
915}
916
917static void nfs4_fl_release_lock(struct file_lock *fl)
918{
919 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
920}
921
Alexey Dobriyan6aed6282009-09-21 17:01:11 -0700922static const struct file_lock_operations nfs4_fl_lock_ops = {
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000923 .fl_copy_lock = nfs4_fl_copy_lock,
924 .fl_release_private = nfs4_fl_release_lock,
925};
926
927int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
928{
929 struct nfs4_lock_state *lsp;
930
931 if (fl->fl_ops != NULL)
932 return 0;
Jeff Layton8003d3c2014-05-01 06:28:45 -0400933 lsp = nfs4_get_lock_state(state, fl->fl_owner);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000934 if (lsp == NULL)
935 return -ENOMEM;
936 fl->fl_u.nfs4_fl.owner = lsp;
937 fl->fl_ops = &nfs4_fl_lock_ops;
938 return 0;
939}
940
Trond Myklebust5521abf2013-03-16 20:54:34 -0400941static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
942 struct nfs4_state *state,
Trond Myklebust2a369152012-08-13 18:54:45 -0400943 const struct nfs_lockowner *lockowner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944{
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000945 struct nfs4_lock_state *lsp;
Trond Myklebust2a369152012-08-13 18:54:45 -0400946 fl_owner_t fl_owner;
Trond Myklebust5521abf2013-03-16 20:54:34 -0400947 int ret = -ENOENT;
Trond Myklebust4fc87962012-03-08 17:42:01 -0500948
Trond Myklebust2a369152012-08-13 18:54:45 -0400949
950 if (lockowner == NULL)
951 goto out;
952
Trond Myklebust4fc87962012-03-08 17:42:01 -0500953 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
954 goto out;
955
Trond Myklebust2a369152012-08-13 18:54:45 -0400956 fl_owner = lockowner->l_owner;
Trond Myklebust4fc87962012-03-08 17:42:01 -0500957 spin_lock(&state->state_lock);
Jeff Layton8003d3c2014-05-01 06:28:45 -0400958 lsp = __nfs4_find_lock_state(state, fl_owner);
NeilBrownef1820f2013-09-04 17:04:49 +1000959 if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
960 ret = -EIO;
961 else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
Trond Myklebust4fc87962012-03-08 17:42:01 -0500962 nfs4_stateid_copy(dst, &lsp->ls_stateid);
Trond Myklebust5521abf2013-03-16 20:54:34 -0400963 ret = 0;
Trond Myklebust4fc87962012-03-08 17:42:01 -0500964 }
965 spin_unlock(&state->state_lock);
966 nfs4_put_lock_state(lsp);
967out:
968 return ret;
969}
970
Trond Myklebust927864c2014-03-04 13:12:03 -0500971static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
Trond Myklebust4fc87962012-03-08 17:42:01 -0500972{
Trond Myklebust92b40e92013-04-20 01:25:45 -0400973 const nfs4_stateid *src;
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400974 int seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700975
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400976 do {
Trond Myklebust92b40e92013-04-20 01:25:45 -0400977 src = &zero_stateid;
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400978 seq = read_seqbegin(&state->seqlock);
Trond Myklebust92b40e92013-04-20 01:25:45 -0400979 if (test_bit(NFS_OPEN_STATE, &state->flags))
980 src = &state->open_stateid;
981 nfs4_stateid_copy(dst, src);
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400982 } while (read_seqretry(&state->seqlock, seq));
Trond Myklebust4fc87962012-03-08 17:42:01 -0500983}
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000984
Trond Myklebust4fc87962012-03-08 17:42:01 -0500985/*
986 * Byte-range lock aware utility to initialize the stateid of read/write
987 * requests.
988 */
Trond Myklebust5521abf2013-03-16 20:54:34 -0400989int nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
Trond Myklebust2a369152012-08-13 18:54:45 -0400990 fmode_t fmode, const struct nfs_lockowner *lockowner)
Trond Myklebust4fc87962012-03-08 17:42:01 -0500991{
NeilBrownef1820f2013-09-04 17:04:49 +1000992 int ret = nfs4_copy_lock_stateid(dst, state, lockowner);
993 if (ret == -EIO)
994 /* A lost lock - don't even consider delegations */
995 goto out;
Andy Adamson146d70c2014-02-18 10:36:05 -0500996 /* returns true if delegation stateid found and copied */
997 if (nfs4_copy_delegation_stateid(dst, state->inode, fmode)) {
998 ret = 0;
Trond Myklebust5521abf2013-03-16 20:54:34 -0400999 goto out;
Andy Adamson146d70c2014-02-18 10:36:05 -05001000 }
Trond Myklebust5521abf2013-03-16 20:54:34 -04001001 if (ret != -ENOENT)
NeilBrownef1820f2013-09-04 17:04:49 +10001002 /* nfs4_copy_delegation_stateid() didn't over-write
1003 * dst, so it still has the lock stateid which we now
1004 * choose to use.
1005 */
Trond Myklebust5521abf2013-03-16 20:54:34 -04001006 goto out;
Trond Myklebust927864c2014-03-04 13:12:03 -05001007 nfs4_copy_open_stateid(dst, state);
1008 ret = 0;
Trond Myklebust5521abf2013-03-16 20:54:34 -04001009out:
Trond Myklebust3b664862013-03-17 15:31:15 -04001010 if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1011 dst->seqid = 0;
Trond Myklebust5521abf2013-03-16 20:54:34 -04001012 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013}
1014
Trond Myklebust8535b2b2010-05-13 12:51:01 -04001015struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016{
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001017 struct nfs_seqid *new;
1018
Trond Myklebust8535b2b2010-05-13 12:51:01 -04001019 new = kmalloc(sizeof(*new), gfp_mask);
Trond Myklebustbadc76d2015-01-23 18:48:00 -05001020 if (new == NULL)
1021 return ERR_PTR(-ENOMEM);
1022 new->sequence = counter;
1023 INIT_LIST_HEAD(&new->list);
1024 new->task = NULL;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001025 return new;
1026}
1027
Trond Myklebust72211db2009-12-15 14:47:36 -05001028void nfs_release_seqid(struct nfs_seqid *seqid)
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001029{
Trond Myklebust4601df22012-01-20 18:47:05 -05001030 struct nfs_seqid_counter *sequence;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001031
Trond Myklebusta6796412015-01-23 19:04:44 -05001032 if (seqid == NULL || list_empty(&seqid->list))
Trond Myklebust4601df22012-01-20 18:47:05 -05001033 return;
1034 sequence = seqid->sequence;
1035 spin_lock(&sequence->lock);
1036 list_del_init(&seqid->list);
1037 if (!list_empty(&sequence->list)) {
1038 struct nfs_seqid *next;
1039
1040 next = list_first_entry(&sequence->list,
1041 struct nfs_seqid, list);
1042 rpc_wake_up_queued_task(&sequence->wait, next->task);
Trond Myklebust2f74c0a2008-01-08 17:56:07 -05001043 }
Trond Myklebust4601df22012-01-20 18:47:05 -05001044 spin_unlock(&sequence->lock);
Trond Myklebust72211db2009-12-15 14:47:36 -05001045}
1046
1047void nfs_free_seqid(struct nfs_seqid *seqid)
1048{
1049 nfs_release_seqid(seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001050 kfree(seqid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051}
1052
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053/*
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001054 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
1055 * failed with a seqid incrementing error -
Toralf Förster16a6ddc2013-12-12 19:09:00 +01001056 * see comments nfs4.h:seqid_mutating_error()
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001057 */
Trond Myklebust88d90932007-07-02 14:03:03 -04001058static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059{
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001060 switch (status) {
1061 case 0:
1062 break;
1063 case -NFS4ERR_BAD_SEQID:
Trond Myklebust6f43ddc2007-07-08 16:49:11 -04001064 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1065 return;
Trond Myklebust9a3ba432012-03-12 18:01:48 -04001066 pr_warn_ratelimited("NFS: v4 server returned a bad"
Dan Muntz497799e2008-02-13 13:09:35 -08001067 " sequence-id error on an"
1068 " unconfirmed sequence %p!\n",
Trond Myklebust6f43ddc2007-07-08 16:49:11 -04001069 seqid->sequence);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001070 case -NFS4ERR_STALE_CLIENTID:
1071 case -NFS4ERR_STALE_STATEID:
1072 case -NFS4ERR_BAD_STATEID:
1073 case -NFS4ERR_BADXDR:
1074 case -NFS4ERR_RESOURCE:
1075 case -NFS4ERR_NOFILEHANDLE:
1076 /* Non-seqid mutating errors */
1077 return;
1078 };
1079 /*
1080 * Note: no locking needed as we are guaranteed to be first
1081 * on the sequence list
1082 */
1083 seqid->sequence->counter++;
1084}
1085
1086void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1087{
Trond Myklebusta6796412015-01-23 19:04:44 -05001088 struct nfs4_state_owner *sp;
Benny Halevy34dc1ad2009-04-01 09:22:52 -04001089
Trond Myklebusta6796412015-01-23 19:04:44 -05001090 if (seqid == NULL)
1091 return;
1092
1093 sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
Benny Halevy34dc1ad2009-04-01 09:22:52 -04001094 if (status == -NFS4ERR_BAD_SEQID)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 nfs4_drop_state_owner(sp);
Trond Myklebusta6796412015-01-23 19:04:44 -05001096 if (!nfs4_has_session(sp->so_server->nfs_client))
Benny Halevy34dc1ad2009-04-01 09:22:52 -04001097 nfs_increment_seqid(status, seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001098}
1099
1100/*
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001101 * Increment the seqid if the LOCK/LOCKU succeeded, or
1102 * failed with a seqid incrementing error -
Toralf Förster16a6ddc2013-12-12 19:09:00 +01001103 * see comments nfs4.h:seqid_mutating_error()
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001104 */
1105void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1106{
Trond Myklebusta6796412015-01-23 19:04:44 -05001107 if (seqid != NULL)
1108 nfs_increment_seqid(status, seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001109}
1110
1111int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1112{
Trond Myklebusta6796412015-01-23 19:04:44 -05001113 struct nfs_seqid_counter *sequence;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001114 int status = 0;
1115
Trond Myklebusta6796412015-01-23 19:04:44 -05001116 if (seqid == NULL)
1117 goto out;
1118 sequence = seqid->sequence;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001119 spin_lock(&sequence->lock);
Trond Myklebust4601df22012-01-20 18:47:05 -05001120 seqid->task = task;
Trond Myklebust2f74c0a2008-01-08 17:56:07 -05001121 if (list_empty(&seqid->list))
1122 list_add_tail(&seqid->list, &sequence->list);
1123 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1124 goto unlock;
Trond Myklebust5d008372008-02-22 16:34:17 -05001125 rpc_sleep_on(&sequence->wait, task, NULL);
Trond Myklebust2f74c0a2008-01-08 17:56:07 -05001126 status = -EAGAIN;
1127unlock:
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001128 spin_unlock(&sequence->lock);
Trond Myklebusta6796412015-01-23 19:04:44 -05001129out:
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001130 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131}
1132
Trond Myklebuste005e802008-12-23 15:21:48 -05001133static int nfs4_run_state_manager(void *);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134
Trond Myklebuste005e802008-12-23 15:21:48 -05001135static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
Trond Myklebust433fbe42006-01-03 09:55:22 +01001136{
Peter Zijlstra4e857c52014-03-17 18:06:10 +01001137 smp_mb__before_atomic();
Trond Myklebuste005e802008-12-23 15:21:48 -05001138 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
Peter Zijlstra4e857c52014-03-17 18:06:10 +01001139 smp_mb__after_atomic();
Trond Myklebuste005e802008-12-23 15:21:48 -05001140 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
Trond Myklebust433fbe42006-01-03 09:55:22 +01001141 rpc_wake_up(&clp->cl_rpcwaitq);
1142}
1143
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144/*
Trond Myklebuste005e802008-12-23 15:21:48 -05001145 * Schedule the nfs_client asynchronous state management routine
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146 */
Trond Myklebustb0d3ded2008-12-23 15:21:50 -05001147void nfs4_schedule_state_manager(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148{
Trond Myklebust5043e902006-01-03 09:55:23 +01001149 struct task_struct *task;
Trond Myklebust2446ab62012-03-01 17:00:56 -05001150 char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151
Trond Myklebuste005e802008-12-23 15:21:48 -05001152 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1153 return;
Trond Myklebust5043e902006-01-03 09:55:23 +01001154 __module_get(THIS_MODULE);
1155 atomic_inc(&clp->cl_count);
Trond Myklebust2446ab62012-03-01 17:00:56 -05001156
1157 /* The rcu_read_lock() is not strictly necessary, as the state
1158 * manager is the only thread that ever changes the rpc_xprt
1159 * after it's initialized. At this point, we're single threaded. */
1160 rcu_read_lock();
1161 snprintf(buf, sizeof(buf), "%s-manager",
1162 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1163 rcu_read_unlock();
Kees Cookf1701682013-07-03 15:04:58 -07001164 task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
Trond Myklebust2446ab62012-03-01 17:00:56 -05001165 if (IS_ERR(task)) {
1166 printk(KERN_ERR "%s: kthread_run: %ld\n",
1167 __func__, PTR_ERR(task));
1168 nfs4_clear_state_manager_bit(clp);
1169 nfs_put_client(clp);
1170 module_put(THIS_MODULE);
1171 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172}
1173
1174/*
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001175 * Schedule a lease recovery attempt
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 */
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001177void nfs4_schedule_lease_recovery(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178{
1179 if (!clp)
1180 return;
Trond Myklebuste598d842008-12-23 15:21:42 -05001181 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1182 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001183 dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1184 clp->cl_hostname);
Trond Myklebuste005e802008-12-23 15:21:48 -05001185 nfs4_schedule_state_manager(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186}
Andy Adamson9cb81962012-03-07 10:49:41 -05001187EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188
Chuck Leverc9fdeb22013-10-17 14:13:02 -04001189/**
1190 * nfs4_schedule_migration_recovery - trigger migration recovery
1191 *
1192 * @server: FSID that is migrating
1193 *
1194 * Returns zero if recovery has started, otherwise a negative NFS4ERR
1195 * value is returned.
1196 */
1197int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1198{
1199 struct nfs_client *clp = server->nfs_client;
1200
1201 if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1202 pr_err("NFS: volatile file handles not supported (server %s)\n",
1203 clp->cl_hostname);
1204 return -NFS4ERR_IO;
1205 }
1206
1207 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1208 return -NFS4ERR_IO;
1209
1210 dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1211 __func__,
1212 (unsigned long long)server->fsid.major,
1213 (unsigned long long)server->fsid.minor,
1214 clp->cl_hostname);
1215
1216 set_bit(NFS_MIG_IN_TRANSITION,
1217 &((struct nfs_server *)server)->mig_status);
1218 set_bit(NFS4CLNT_MOVED, &clp->cl_state);
1219
1220 nfs4_schedule_state_manager(clp);
1221 return 0;
1222}
1223EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1224
Chuck Leverb7f7a662013-10-17 14:13:35 -04001225/**
1226 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1227 *
1228 * @clp: server to check for moved leases
1229 *
1230 */
1231void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1232{
1233 dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1234 __func__, clp->cl_clientid, clp->cl_hostname);
1235
1236 set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
1237 nfs4_schedule_state_manager(clp);
1238}
1239EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1240
Trond Myklebust33021272012-11-26 13:13:29 -05001241int nfs4_wait_clnt_recover(struct nfs_client *clp)
1242{
1243 int res;
1244
1245 might_sleep();
1246
Chuck Lever0625c2d2013-10-17 14:14:10 -04001247 atomic_inc(&clp->cl_count);
NeilBrown74316202014-07-07 15:16:04 +10001248 res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
1249 nfs_wait_bit_killable, TASK_KILLABLE);
Trond Myklebust33021272012-11-26 13:13:29 -05001250 if (res)
Chuck Lever0625c2d2013-10-17 14:14:10 -04001251 goto out;
Trond Myklebust33021272012-11-26 13:13:29 -05001252 if (clp->cl_cons_state < 0)
Chuck Lever0625c2d2013-10-17 14:14:10 -04001253 res = clp->cl_cons_state;
1254out:
1255 nfs_put_client(clp);
1256 return res;
Trond Myklebust33021272012-11-26 13:13:29 -05001257}
1258
1259int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1260{
1261 unsigned int loop;
1262 int ret;
1263
1264 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1265 ret = nfs4_wait_clnt_recover(clp);
1266 if (ret != 0)
1267 break;
1268 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1269 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1270 break;
1271 nfs4_schedule_state_manager(clp);
1272 ret = -EIO;
1273 }
1274 return ret;
1275}
1276
Trond Myklebustad1e3962012-03-10 11:23:15 -05001277/*
1278 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1279 * @clp: client to process
1280 *
1281 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1282 * resend of the SETCLIENTID and hence re-establish the
1283 * callback channel. Then return all existing delegations.
1284 */
1285static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1286{
1287 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1288 nfs_expire_all_delegations(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001289 dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1290 clp->cl_hostname);
Trond Myklebustad1e3962012-03-10 11:23:15 -05001291}
1292
Trond Myklebust042b60b2011-08-24 15:07:37 -04001293void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1294{
Trond Myklebustad1e3962012-03-10 11:23:15 -05001295 nfs40_handle_cb_pathdown(clp);
Trond Myklebust042b60b2011-08-24 15:07:37 -04001296 nfs4_schedule_state_manager(clp);
1297}
1298
Trond Myklebustf9feab12011-03-09 16:12:46 -05001299static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001300{
1301
1302 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1303 /* Don't recover state that expired before the reboot */
1304 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1305 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1306 return 0;
1307 }
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001308 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001309 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1310 return 1;
1311}
1312
Trond Myklebust4f14c192014-02-12 19:15:06 -05001313int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001314{
1315 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1316 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001317 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001318 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1319 return 1;
1320}
1321
Trond Myklebust5d422302013-03-14 16:57:48 -04001322int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001323{
1324 struct nfs_client *clp = server->nfs_client;
1325
Trond Myklebust5d422302013-03-14 16:57:48 -04001326 if (!nfs4_valid_open_stateid(state))
1327 return -EBADF;
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001328 nfs4_state_mark_reclaim_nograce(clp, state);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001329 dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1330 clp->cl_hostname);
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001331 nfs4_schedule_state_manager(clp);
Trond Myklebust5d422302013-03-14 16:57:48 -04001332 return 0;
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001333}
Andy Adamson9cb81962012-03-07 10:49:41 -05001334EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
Trond Myklebust0400a6b2011-03-09 16:00:53 -05001335
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -05001336void nfs_inode_find_state_and_recover(struct inode *inode,
1337 const nfs4_stateid *stateid)
1338{
1339 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1340 struct nfs_inode *nfsi = NFS_I(inode);
1341 struct nfs_open_context *ctx;
1342 struct nfs4_state *state;
1343 bool found = false;
1344
1345 spin_lock(&inode->i_lock);
1346 list_for_each_entry(ctx, &nfsi->open_files, list) {
1347 state = ctx->state;
1348 if (state == NULL)
1349 continue;
1350 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
1351 continue;
Trond Myklebustf597c532012-03-04 18:13:56 -05001352 if (!nfs4_stateid_match(&state->stateid, stateid))
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -05001353 continue;
1354 nfs4_state_mark_reclaim_nograce(clp, state);
1355 found = true;
1356 }
1357 spin_unlock(&inode->i_lock);
1358 if (found)
1359 nfs4_schedule_state_manager(clp);
1360}
1361
Trond Myklebustc58c8442013-03-18 19:45:14 -04001362static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
1363{
1364 struct inode *inode = state->inode;
1365 struct nfs_inode *nfsi = NFS_I(inode);
1366 struct nfs_open_context *ctx;
1367
1368 spin_lock(&inode->i_lock);
1369 list_for_each_entry(ctx, &nfsi->open_files, list) {
1370 if (ctx->state != state)
1371 continue;
1372 set_bit(NFS_CONTEXT_BAD, &ctx->flags);
1373 }
1374 spin_unlock(&inode->i_lock);
1375}
1376
Trond Myklebust5d422302013-03-14 16:57:48 -04001377static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1378{
1379 set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
Trond Myklebustc58c8442013-03-18 19:45:14 -04001380 nfs4_state_mark_open_context_bad(state);
Trond Myklebust5d422302013-03-14 16:57:48 -04001381}
1382
Trond Myklebusta1d0b5e2012-03-05 19:56:44 -05001383
Trond Myklebust02860012008-12-23 15:21:40 -05001384static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385{
1386 struct inode *inode = state->inode;
Trond Myklebust19e03c52008-12-23 15:21:44 -05001387 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 struct file_lock *fl;
1389 int status = 0;
Jeff Layton5263e312015-01-16 15:05:55 -05001390 struct file_lock_context *flctx = inode->i_flctx;
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001391 struct list_head *list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001393 if (flctx == NULL)
Trond Myklebust3f09df72009-06-17 13:23:00 -07001394 return 0;
1395
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001396 list = &flctx->flc_posix;
1397
Trond Myklebust3f09df72009-06-17 13:23:00 -07001398 /* Guard against delegation returns and new lock/unlock calls */
Trond Myklebust19e03c52008-12-23 15:21:44 -05001399 down_write(&nfsi->rwsem);
Jeff Layton6109c852015-01-16 15:05:57 -05001400 spin_lock(&flctx->flc_lock);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001401restart:
1402 list_for_each_entry(fl, list, fl_list) {
Jeff Layton5263e312015-01-16 15:05:55 -05001403 if (nfs_file_open_context(fl->fl_file)->state != state)
1404 continue;
Jeff Layton6109c852015-01-16 15:05:57 -05001405 spin_unlock(&flctx->flc_lock);
Jeff Layton5263e312015-01-16 15:05:55 -05001406 status = ops->recover_lock(state, fl);
1407 switch (status) {
1408 case 0:
1409 break;
1410 case -ESTALE:
1411 case -NFS4ERR_ADMIN_REVOKED:
1412 case -NFS4ERR_STALE_STATEID:
1413 case -NFS4ERR_BAD_STATEID:
1414 case -NFS4ERR_EXPIRED:
1415 case -NFS4ERR_NO_GRACE:
1416 case -NFS4ERR_STALE_CLIENTID:
1417 case -NFS4ERR_BADSESSION:
1418 case -NFS4ERR_BADSLOT:
1419 case -NFS4ERR_BAD_HIGH_SLOT:
1420 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1421 goto out;
1422 default:
1423 pr_err("NFS: %s: unhandled error %d\n",
1424 __func__, status);
1425 case -ENOMEM:
1426 case -NFS4ERR_DENIED:
1427 case -NFS4ERR_RECLAIM_BAD:
1428 case -NFS4ERR_RECLAIM_CONFLICT:
1429 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1430 status = 0;
1431 }
Jeff Layton6109c852015-01-16 15:05:57 -05001432 spin_lock(&flctx->flc_lock);
Jeff Layton5263e312015-01-16 15:05:55 -05001433 }
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001434 if (list == &flctx->flc_posix) {
1435 list = &flctx->flc_flock;
1436 goto restart;
1437 }
Jeff Layton6109c852015-01-16 15:05:57 -05001438 spin_unlock(&flctx->flc_lock);
Trond Myklebust965b5d62009-06-17 13:22:59 -07001439out:
Trond Myklebust19e03c52008-12-23 15:21:44 -05001440 up_write(&nfsi->rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441 return status;
1442}
1443
Trond Myklebust02860012008-12-23 15:21:40 -05001444static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445{
1446 struct nfs4_state *state;
1447 struct nfs4_lock_state *lock;
1448 int status = 0;
1449
1450 /* Note: we rely on the sp->so_states list being ordered
1451 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1452 * states first.
1453 * This is needed to ensure that the server won't give us any
1454 * read delegations that we have to return if, say, we are
1455 * recovering after a network partition or a reboot from a
1456 * server that doesn't support a grace period.
1457 */
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001458 spin_lock(&sp->so_lock);
Trond Myklebustabbec2da2014-06-05 10:42:37 -04001459 raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
Trond Myklebustc137afa2013-02-07 14:41:11 -05001460restart:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 list_for_each_entry(state, &sp->so_states, open_states) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001462 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1463 continue;
Trond Myklebust5d422302013-03-14 16:57:48 -04001464 if (!nfs4_valid_open_stateid(state))
1465 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466 if (state->state == 0)
1467 continue;
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001468 atomic_inc(&state->count);
1469 spin_unlock(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 status = ops->recover_open(sp, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 if (status >= 0) {
Trond Myklebust02860012008-12-23 15:21:40 -05001472 status = nfs4_reclaim_locks(state, ops);
1473 if (status >= 0) {
Jeff Layton1acd1c32013-10-31 13:03:04 -04001474 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
NeilBrown66863902013-08-12 16:52:47 +10001475 spin_lock(&state->state_lock);
1476 list_for_each_entry(lock, &state->lock_states, ls_locks) {
1477 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1478 pr_warn_ratelimited("NFS: "
1479 "%s: Lock reclaim "
1480 "failed!\n", __func__);
1481 }
1482 spin_unlock(&state->state_lock);
Trond Myklebust02860012008-12-23 15:21:40 -05001483 }
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001484 nfs4_put_open_state(state);
Trond Myklebustc137afa2013-02-07 14:41:11 -05001485 spin_lock(&sp->so_lock);
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001486 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 }
1489 switch (status) {
1490 default:
Andy Adamson3660cd42013-10-03 12:23:24 -04001491 printk(KERN_ERR "NFS: %s: unhandled error %d\n",
1492 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 case -ENOENT:
Trond Myklebust965b5d62009-06-17 13:22:59 -07001494 case -ENOMEM:
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001495 case -ESTALE:
Andy Adamson3660cd42013-10-03 12:23:24 -04001496 /* Open state on this file cannot be recovered */
Trond Myklebust5d422302013-03-14 16:57:48 -04001497 nfs4_state_mark_recovery_failed(state, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 break;
Trond Myklebust91876b12013-03-28 14:01:33 -04001499 case -EAGAIN:
1500 ssleep(1);
Trond Myklebust965b5d62009-06-17 13:22:59 -07001501 case -NFS4ERR_ADMIN_REVOKED:
1502 case -NFS4ERR_STALE_STATEID:
1503 case -NFS4ERR_BAD_STATEID:
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001504 case -NFS4ERR_RECLAIM_BAD:
1505 case -NFS4ERR_RECLAIM_CONFLICT:
Trond Myklebust1f0e8902010-06-24 15:11:43 -04001506 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001507 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 case -NFS4ERR_EXPIRED:
1509 case -NFS4ERR_NO_GRACE:
Trond Myklebust1f0e8902010-06-24 15:11:43 -04001510 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 case -NFS4ERR_STALE_CLIENTID:
Trond Myklebust9c4c7612009-12-03 15:58:56 -05001512 case -NFS4ERR_BADSESSION:
1513 case -NFS4ERR_BADSLOT:
1514 case -NFS4ERR_BAD_HIGH_SLOT:
1515 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 goto out_err;
1517 }
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001518 nfs4_put_open_state(state);
Trond Myklebustc137afa2013-02-07 14:41:11 -05001519 spin_lock(&sp->so_lock);
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001520 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 }
Trond Myklebustabbec2da2014-06-05 10:42:37 -04001522 raw_write_seqcount_end(&sp->so_reclaim_seqcount);
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001523 spin_unlock(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 return 0;
1525out_err:
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001526 nfs4_put_open_state(state);
Trond Myklebustc137afa2013-02-07 14:41:11 -05001527 spin_lock(&sp->so_lock);
Trond Myklebustabbec2da2014-06-05 10:42:37 -04001528 raw_write_seqcount_end(&sp->so_reclaim_seqcount);
Trond Myklebustc137afa2013-02-07 14:41:11 -05001529 spin_unlock(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 return status;
1531}
1532
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001533static void nfs4_clear_open_state(struct nfs4_state *state)
1534{
1535 struct nfs4_lock_state *lock;
1536
1537 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1538 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1539 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1540 clear_bit(NFS_O_RDWR_STATE, &state->flags);
Trond Myklebust4b44b402011-12-09 16:31:52 -05001541 spin_lock(&state->state_lock);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001542 list_for_each_entry(lock, &state->lock_states, ls_locks) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001543 lock->ls_seqid.flags = 0;
Trond Myklebust795a88c2012-09-10 13:26:49 -04001544 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001545 }
Trond Myklebust4b44b402011-12-09 16:31:52 -05001546 spin_unlock(&state->state_lock);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001547}
1548
Chuck Lever24d292b2010-12-24 01:32:43 +00001549static void nfs4_reset_seqids(struct nfs_server *server,
1550 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001551{
Chuck Lever24d292b2010-12-24 01:32:43 +00001552 struct nfs_client *clp = server->nfs_client;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001553 struct nfs4_state_owner *sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -04001554 struct rb_node *pos;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001555 struct nfs4_state *state;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001556
Chuck Lever24d292b2010-12-24 01:32:43 +00001557 spin_lock(&clp->cl_lock);
1558 for (pos = rb_first(&server->state_owners);
1559 pos != NULL;
1560 pos = rb_next(pos)) {
1561 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001562 sp->so_seqid.flags = 0;
Trond Myklebustec073422005-10-20 14:22:47 -07001563 spin_lock(&sp->so_lock);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001564 list_for_each_entry(state, &sp->so_states, open_states) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001565 if (mark_reclaim(clp, state))
1566 nfs4_clear_open_state(state);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001567 }
Trond Myklebustec073422005-10-20 14:22:47 -07001568 spin_unlock(&sp->so_lock);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001569 }
Chuck Lever24d292b2010-12-24 01:32:43 +00001570 spin_unlock(&clp->cl_lock);
1571}
1572
1573static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1574 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1575{
1576 struct nfs_server *server;
1577
1578 rcu_read_lock();
1579 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1580 nfs4_reset_seqids(server, mark_reclaim);
1581 rcu_read_unlock();
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001582}
1583
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001584static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1585{
1586 /* Mark all delegations for reclaim */
1587 nfs_delegation_mark_reclaim(clp);
1588 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1589}
1590
Ricardo Labiagafce5c832009-12-05 16:08:41 -05001591static void nfs4_reclaim_complete(struct nfs_client *clp,
Trond Myklebust965e9c22013-05-20 11:05:17 -04001592 const struct nfs4_state_recovery_ops *ops,
1593 struct rpc_cred *cred)
Ricardo Labiagafce5c832009-12-05 16:08:41 -05001594{
1595 /* Notify the server we're done reclaiming our state */
1596 if (ops->reclaim_complete)
Trond Myklebust965e9c22013-05-20 11:05:17 -04001597 (void)ops->reclaim_complete(clp, cred);
Ricardo Labiagafce5c832009-12-05 16:08:41 -05001598}
1599
Chuck Lever24d292b2010-12-24 01:32:43 +00001600static void nfs4_clear_reclaim_server(struct nfs_server *server)
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001601{
Chuck Lever24d292b2010-12-24 01:32:43 +00001602 struct nfs_client *clp = server->nfs_client;
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001603 struct nfs4_state_owner *sp;
1604 struct rb_node *pos;
1605 struct nfs4_state *state;
1606
Chuck Lever24d292b2010-12-24 01:32:43 +00001607 spin_lock(&clp->cl_lock);
1608 for (pos = rb_first(&server->state_owners);
1609 pos != NULL;
1610 pos = rb_next(pos)) {
1611 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001612 spin_lock(&sp->so_lock);
1613 list_for_each_entry(state, &sp->so_states, open_states) {
Chuck Lever24d292b2010-12-24 01:32:43 +00001614 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1615 &state->flags))
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001616 continue;
1617 nfs4_state_mark_reclaim_nograce(clp, state);
1618 }
1619 spin_unlock(&sp->so_lock);
1620 }
Chuck Lever24d292b2010-12-24 01:32:43 +00001621 spin_unlock(&clp->cl_lock);
1622}
1623
1624static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1625{
1626 struct nfs_server *server;
1627
1628 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1629 return 0;
1630
1631 rcu_read_lock();
1632 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1633 nfs4_clear_reclaim_server(server);
1634 rcu_read_unlock();
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001635
1636 nfs_delegation_reap_unclaimed(clp);
Trond Myklebust6eaa6142010-10-04 17:59:08 -04001637 return 1;
1638}
1639
1640static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1641{
Trond Myklebust965e9c22013-05-20 11:05:17 -04001642 const struct nfs4_state_recovery_ops *ops;
1643 struct rpc_cred *cred;
1644
Trond Myklebust6eaa6142010-10-04 17:59:08 -04001645 if (!nfs4_state_clear_reclaim_reboot(clp))
1646 return;
Trond Myklebust965e9c22013-05-20 11:05:17 -04001647 ops = clp->cl_mvops->reboot_recovery_ops;
Chuck Lever73d8bde2013-07-24 12:28:37 -04001648 cred = nfs4_get_clid_cred(clp);
Trond Myklebust965e9c22013-05-20 11:05:17 -04001649 nfs4_reclaim_complete(clp, ops, cred);
1650 put_rpccred(cred);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001651}
1652
1653static void nfs_delegation_clear_all(struct nfs_client *clp)
1654{
1655 nfs_delegation_mark_reclaim(clp);
1656 nfs_delegation_reap_unclaimed(clp);
1657}
1658
1659static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1660{
1661 nfs_delegation_clear_all(clp);
1662 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1663}
1664
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001665static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
Trond Myklebuste598d842008-12-23 15:21:42 -05001666{
1667 switch (error) {
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001668 case 0:
1669 break;
Trond Myklebuste598d842008-12-23 15:21:42 -05001670 case -NFS4ERR_CB_PATH_DOWN:
Trond Myklebustad1e3962012-03-10 11:23:15 -05001671 nfs40_handle_cb_pathdown(clp);
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001672 break;
Trond Myklebustc8b7ae3d2009-12-03 15:53:21 -05001673 case -NFS4ERR_NO_GRACE:
1674 nfs4_state_end_reclaim_reboot(clp);
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001675 break;
Trond Myklebuste598d842008-12-23 15:21:42 -05001676 case -NFS4ERR_STALE_CLIENTID:
Trond Myklebuste598d842008-12-23 15:21:42 -05001677 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
Trond Myklebust6eaa6142010-10-04 17:59:08 -04001678 nfs4_state_clear_reclaim_reboot(clp);
Trond Myklebuste598d842008-12-23 15:21:42 -05001679 nfs4_state_start_reclaim_reboot(clp);
1680 break;
1681 case -NFS4ERR_EXPIRED:
1682 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1683 nfs4_state_start_reclaim_nograce(clp);
Andy Adamson8ba9bf82009-12-04 15:55:34 -05001684 break;
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001685 case -NFS4ERR_BADSESSION:
1686 case -NFS4ERR_BADSLOT:
1687 case -NFS4ERR_BAD_HIGH_SLOT:
1688 case -NFS4ERR_DEADSESSION:
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001689 case -NFS4ERR_SEQ_FALSE_RETRY:
1690 case -NFS4ERR_SEQ_MISORDERED:
Andy Adamson6df08182009-12-04 15:55:05 -05001691 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
Andy Adamson0b9e2d42009-12-04 16:02:14 -05001692 /* Zero session reset errors */
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001693 break;
Trond Myklebust7c5d7252012-05-27 12:58:48 -04001694 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1695 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1696 break;
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001697 default:
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001698 dprintk("%s: failed to handle error %d for server %s\n",
1699 __func__, error, clp->cl_hostname);
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001700 return error;
Trond Myklebuste598d842008-12-23 15:21:42 -05001701 }
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001702 dprintk("%s: handled error %d for server %s\n", __func__, error,
1703 clp->cl_hostname);
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001704 return 0;
Trond Myklebuste598d842008-12-23 15:21:42 -05001705}
1706
Trond Myklebust02860012008-12-23 15:21:40 -05001707static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708{
Chuck Lever24d292b2010-12-24 01:32:43 +00001709 struct nfs4_state_owner *sp;
1710 struct nfs_server *server;
Trond Myklebust9f958ab2007-07-02 13:58:33 -04001711 struct rb_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 int status = 0;
1713
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001714restart:
Chuck Lever24d292b2010-12-24 01:32:43 +00001715 rcu_read_lock();
1716 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
Chuck Lever0aaaf5c2011-12-06 16:13:48 -05001717 nfs4_purge_state_owners(server);
Chuck Lever24d292b2010-12-24 01:32:43 +00001718 spin_lock(&clp->cl_lock);
1719 for (pos = rb_first(&server->state_owners);
1720 pos != NULL;
1721 pos = rb_next(pos)) {
1722 sp = rb_entry(pos,
1723 struct nfs4_state_owner, so_server_node);
1724 if (!test_and_clear_bit(ops->owner_flag_bit,
1725 &sp->so_flags))
1726 continue;
1727 atomic_inc(&sp->so_count);
1728 spin_unlock(&clp->cl_lock);
1729 rcu_read_unlock();
1730
1731 status = nfs4_reclaim_open_state(sp, ops);
1732 if (status < 0) {
1733 set_bit(ops->owner_flag_bit, &sp->so_flags);
1734 nfs4_put_state_owner(sp);
Trond Myklebustdf817ba32014-09-27 17:41:51 -04001735 status = nfs4_recovery_handle_error(clp, status);
1736 return (status != 0) ? status : -EAGAIN;
Chuck Lever24d292b2010-12-24 01:32:43 +00001737 }
1738
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001739 nfs4_put_state_owner(sp);
Chuck Lever24d292b2010-12-24 01:32:43 +00001740 goto restart;
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001741 }
Chuck Lever24d292b2010-12-24 01:32:43 +00001742 spin_unlock(&clp->cl_lock);
Trond Myklebust02860012008-12-23 15:21:40 -05001743 }
Chuck Lever24d292b2010-12-24 01:32:43 +00001744 rcu_read_unlock();
Trond Myklebustdf817ba32014-09-27 17:41:51 -04001745 return 0;
Trond Myklebust02860012008-12-23 15:21:40 -05001746}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
Trond Myklebust02860012008-12-23 15:21:40 -05001748static int nfs4_check_lease(struct nfs_client *clp)
1749{
1750 struct rpc_cred *cred;
Trond Myklebustc48f4f32010-06-16 09:52:27 -04001751 const struct nfs4_state_maintenance_ops *ops =
1752 clp->cl_mvops->state_renewal_ops;
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001753 int status;
Trond Myklebust02860012008-12-23 15:21:40 -05001754
Trond Myklebust0f605b52008-12-23 15:21:42 -05001755 /* Is the client already known to have an expired lease? */
1756 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1757 return 0;
Andy Adamsona7b72102009-04-01 09:22:46 -04001758 spin_lock(&clp->cl_lock);
1759 cred = ops->get_state_renewal_cred_locked(clp);
1760 spin_unlock(&clp->cl_lock);
Trond Myklebust0f605b52008-12-23 15:21:42 -05001761 if (cred == NULL) {
Chuck Lever73d8bde2013-07-24 12:28:37 -04001762 cred = nfs4_get_clid_cred(clp);
Trond Myklebust4f38e4a2011-12-01 16:31:34 -05001763 status = -ENOKEY;
Trond Myklebust0f605b52008-12-23 15:21:42 -05001764 if (cred == NULL)
1765 goto out;
Trond Myklebust02860012008-12-23 15:21:40 -05001766 }
Benny Halevy8e69514f2009-04-01 09:22:45 -04001767 status = ops->renew_lease(clp, cred);
Trond Myklebust0f605b52008-12-23 15:21:42 -05001768 put_rpccred(cred);
Trond Myklebustbc7a05c2013-04-08 17:50:28 -04001769 if (status == -ETIMEDOUT) {
1770 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1771 return 0;
1772 }
Trond Myklebust0f605b52008-12-23 15:21:42 -05001773out:
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001774 return nfs4_recovery_handle_error(clp, status);
Trond Myklebust02860012008-12-23 15:21:40 -05001775}
1776
Andy Adamson47b803c2012-10-01 20:42:32 -04001777/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1778 * and for recoverable errors on EXCHANGE_ID for v4.1
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001779 */
1780static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1781{
1782 switch (status) {
Trond Myklebust89a21732012-05-25 15:00:06 -04001783 case -NFS4ERR_SEQ_MISORDERED:
1784 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
1785 return -ESERVERFAULT;
1786 /* Lease confirmation error: retry after purging the lease */
1787 ssleep(1);
Andy Adamson47b803c2012-10-01 20:42:32 -04001788 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1789 break;
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001790 case -NFS4ERR_STALE_CLIENTID:
1791 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
Andy Adamson47b803c2012-10-01 20:42:32 -04001792 nfs4_state_start_reclaim_reboot(clp);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001793 break;
Chuck Leverde734832012-07-11 16:30:50 -04001794 case -NFS4ERR_CLID_INUSE:
1795 pr_err("NFS: Server %s reports our clientid is in use\n",
1796 clp->cl_hostname);
1797 nfs_mark_client_ready(clp, -EPERM);
1798 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1799 return -EPERM;
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001800 case -EACCES:
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001801 case -NFS4ERR_DELAY:
1802 case -ETIMEDOUT:
1803 case -EAGAIN:
1804 ssleep(1);
1805 break;
1806
1807 case -NFS4ERR_MINOR_VERS_MISMATCH:
1808 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
1809 nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001810 dprintk("%s: exit with error %d for server %s\n",
1811 __func__, -EPROTONOSUPPORT, clp->cl_hostname);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001812 return -EPROTONOSUPPORT;
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001813 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
1814 * in nfs4_exchange_id */
1815 default:
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001816 dprintk("%s: exit with error %d for server %s\n", __func__,
1817 status, clp->cl_hostname);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001818 return status;
1819 }
1820 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04001821 dprintk("%s: handled error %d for server %s\n", __func__, status,
1822 clp->cl_hostname);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001823 return 0;
1824}
1825
Trond Myklebustb42353f2012-06-05 11:19:47 -04001826static int nfs4_establish_lease(struct nfs_client *clp)
Trond Myklebust02860012008-12-23 15:21:40 -05001827{
1828 struct rpc_cred *cred;
Trond Myklebustc48f4f32010-06-16 09:52:27 -04001829 const struct nfs4_state_recovery_ops *ops =
1830 clp->cl_mvops->reboot_recovery_ops;
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001831 int status;
Trond Myklebust02860012008-12-23 15:21:40 -05001832
Chuck Lever73d8bde2013-07-24 12:28:37 -04001833 cred = nfs4_get_clid_cred(clp);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001834 if (cred == NULL)
1835 return -ENOENT;
1836 status = ops->establish_clid(clp, cred);
1837 put_rpccred(cred);
1838 if (status != 0)
Trond Myklebustb42353f2012-06-05 11:19:47 -04001839 return status;
1840 pnfs_destroy_all_layouts(clp);
1841 return 0;
1842}
1843
Chuck Lever6bbb4ae2012-07-11 16:30:59 -04001844/*
1845 * Returns zero or a negative errno. NFS4ERR values are converted
1846 * to local errno values.
1847 */
Trond Myklebustb42353f2012-06-05 11:19:47 -04001848static int nfs4_reclaim_lease(struct nfs_client *clp)
1849{
1850 int status;
1851
1852 status = nfs4_establish_lease(clp);
1853 if (status < 0)
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001854 return nfs4_handle_reclaim_lease_error(clp, status);
Trond Myklebustb42353f2012-06-05 11:19:47 -04001855 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
1856 nfs4_state_start_reclaim_nograce(clp);
1857 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1858 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1859 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1860 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1861 return 0;
1862}
1863
1864static int nfs4_purge_lease(struct nfs_client *clp)
1865{
1866 int status;
1867
1868 status = nfs4_establish_lease(clp);
1869 if (status < 0)
1870 return nfs4_handle_reclaim_lease_error(clp, status);
1871 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1872 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1873 nfs4_state_start_reclaim_nograce(clp);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04001874 return 0;
Trond Myklebust02860012008-12-23 15:21:40 -05001875}
1876
Chuck Leverc9fdeb22013-10-17 14:13:02 -04001877/*
1878 * Try remote migration of one FSID from a source server to a
1879 * destination server. The source server provides a list of
1880 * potential destinations.
1881 *
1882 * Returns zero or a negative NFS4ERR status code.
1883 */
1884static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
1885{
1886 struct nfs_client *clp = server->nfs_client;
1887 struct nfs4_fs_locations *locations = NULL;
1888 struct inode *inode;
1889 struct page *page;
1890 int status, result;
1891
1892 dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
1893 (unsigned long long)server->fsid.major,
1894 (unsigned long long)server->fsid.minor,
1895 clp->cl_hostname);
1896
1897 result = 0;
1898 page = alloc_page(GFP_KERNEL);
1899 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
1900 if (page == NULL || locations == NULL) {
1901 dprintk("<-- %s: no memory\n", __func__);
1902 goto out;
1903 }
1904
1905 inode = server->super->s_root->d_inode;
1906 result = nfs4_proc_get_locations(inode, locations, page, cred);
1907 if (result) {
1908 dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
1909 __func__, result);
1910 goto out;
1911 }
1912
1913 result = -NFS4ERR_NXIO;
1914 if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
1915 dprintk("<-- %s: No fs_locations data, migration skipped\n",
1916 __func__);
1917 goto out;
1918 }
1919
1920 nfs4_begin_drain_session(clp);
1921
1922 status = nfs4_replace_transport(server, locations);
1923 if (status != 0) {
1924 dprintk("<-- %s: failed to replace transport: %d\n",
1925 __func__, status);
1926 goto out;
1927 }
1928
1929 result = 0;
1930 dprintk("<-- %s: migration succeeded\n", __func__);
1931
1932out:
1933 if (page != NULL)
1934 __free_page(page);
1935 kfree(locations);
1936 if (result) {
1937 pr_err("NFS: migration recovery failed (server %s)\n",
1938 clp->cl_hostname);
1939 set_bit(NFS_MIG_FAILED, &server->mig_status);
1940 }
1941 return result;
1942}
1943
1944/*
1945 * Returns zero or a negative NFS4ERR status code.
1946 */
1947static int nfs4_handle_migration(struct nfs_client *clp)
1948{
1949 const struct nfs4_state_maintenance_ops *ops =
1950 clp->cl_mvops->state_renewal_ops;
1951 struct nfs_server *server;
1952 struct rpc_cred *cred;
1953
1954 dprintk("%s: migration reported on \"%s\"\n", __func__,
1955 clp->cl_hostname);
1956
1957 spin_lock(&clp->cl_lock);
1958 cred = ops->get_state_renewal_cred_locked(clp);
1959 spin_unlock(&clp->cl_lock);
1960 if (cred == NULL)
1961 return -NFS4ERR_NOENT;
1962
1963 clp->cl_mig_gen++;
1964restart:
1965 rcu_read_lock();
1966 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1967 int status;
1968
1969 if (server->mig_gen == clp->cl_mig_gen)
1970 continue;
1971 server->mig_gen = clp->cl_mig_gen;
1972
1973 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
1974 &server->mig_status))
1975 continue;
1976
1977 rcu_read_unlock();
1978 status = nfs4_try_migration(server, cred);
1979 if (status < 0) {
1980 put_rpccred(cred);
1981 return status;
1982 }
1983 goto restart;
1984 }
1985 rcu_read_unlock();
1986 put_rpccred(cred);
1987 return 0;
1988}
1989
Chuck Leverb7f7a662013-10-17 14:13:35 -04001990/*
1991 * Test each nfs_server on the clp's cl_superblocks list to see
1992 * if it's moved to another server. Stop when the server no longer
1993 * returns NFS4ERR_LEASE_MOVED.
1994 */
1995static int nfs4_handle_lease_moved(struct nfs_client *clp)
1996{
1997 const struct nfs4_state_maintenance_ops *ops =
1998 clp->cl_mvops->state_renewal_ops;
1999 struct nfs_server *server;
2000 struct rpc_cred *cred;
2001
2002 dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2003 clp->cl_hostname);
2004
2005 spin_lock(&clp->cl_lock);
2006 cred = ops->get_state_renewal_cred_locked(clp);
2007 spin_unlock(&clp->cl_lock);
2008 if (cred == NULL)
2009 return -NFS4ERR_NOENT;
2010
2011 clp->cl_mig_gen++;
2012restart:
2013 rcu_read_lock();
2014 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2015 struct inode *inode;
2016 int status;
2017
2018 if (server->mig_gen == clp->cl_mig_gen)
2019 continue;
2020 server->mig_gen = clp->cl_mig_gen;
2021
2022 rcu_read_unlock();
2023
2024 inode = server->super->s_root->d_inode;
2025 status = nfs4_proc_fsid_present(inode, cred);
2026 if (status != -NFS4ERR_MOVED)
2027 goto restart; /* wasn't this one */
2028 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2029 goto restart; /* there are more */
2030 goto out;
2031 }
2032 rcu_read_unlock();
2033
2034out:
2035 put_rpccred(cred);
2036 return 0;
2037}
2038
Chuck Lever05f4c352012-09-14 17:24:32 -04002039/**
2040 * nfs4_discover_server_trunking - Detect server IP address trunking
2041 *
2042 * @clp: nfs_client under test
2043 * @result: OUT: found nfs_client, or clp
2044 *
2045 * Returns zero or a negative errno. If zero is returned,
2046 * an nfs_client pointer is planted in "result".
2047 *
2048 * Note: since we are invoked in process context, and
2049 * not from inside the state manager, we cannot use
2050 * nfs4_handle_reclaim_lease_error().
2051 */
2052int nfs4_discover_server_trunking(struct nfs_client *clp,
2053 struct nfs_client **result)
2054{
2055 const struct nfs4_state_recovery_ops *ops =
2056 clp->cl_mvops->reboot_recovery_ops;
Chuck Lever05f4c352012-09-14 17:24:32 -04002057 struct rpc_clnt *clnt;
2058 struct rpc_cred *cred;
Chuck Lever4edaa302013-03-16 15:56:20 -04002059 int i, status;
Chuck Lever05f4c352012-09-14 17:24:32 -04002060
2061 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2062
Chuck Lever05f4c352012-09-14 17:24:32 -04002063 clnt = clp->cl_rpcclient;
Chuck Lever05f4c352012-09-14 17:24:32 -04002064 i = 0;
2065
2066 mutex_lock(&nfs_clid_init_mutex);
Chuck Lever05f4c352012-09-14 17:24:32 -04002067again:
Trond Myklebustea33e6c2013-04-05 13:22:50 -04002068 status = -ENOENT;
Chuck Lever73d8bde2013-07-24 12:28:37 -04002069 cred = nfs4_get_clid_cred(clp);
Chuck Lever05f4c352012-09-14 17:24:32 -04002070 if (cred == NULL)
2071 goto out_unlock;
2072
2073 status = ops->detect_trunking(clp, result, cred);
2074 put_rpccred(cred);
2075 switch (status) {
2076 case 0:
2077 break;
Chuck Lever05f4c352012-09-14 17:24:32 -04002078 case -ETIMEDOUT:
Trond Myklebust150e7262014-03-18 14:23:11 -04002079 if (clnt->cl_softrtry)
2080 break;
2081 case -NFS4ERR_DELAY:
Chuck Lever05f4c352012-09-14 17:24:32 -04002082 case -EAGAIN:
2083 ssleep(1);
Trond Myklebust202c3122013-01-18 22:56:23 -05002084 case -NFS4ERR_STALE_CLIENTID:
Chuck Lever05f4c352012-09-14 17:24:32 -04002085 dprintk("NFS: %s after status %d, retrying\n",
2086 __func__, status);
2087 goto again;
Chuck Lever4edaa302013-03-16 15:56:20 -04002088 case -EACCES:
Chuck Leverd688f7b2013-07-24 12:28:28 -04002089 if (i++ == 0) {
2090 nfs4_root_machine_cred(clp);
2091 goto again;
2092 }
Jeff Layton6d769f12013-11-13 09:08:21 -05002093 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
Chuck Lever4edaa302013-03-16 15:56:20 -04002094 break;
Chuck Lever05f4c352012-09-14 17:24:32 -04002095 case -NFS4ERR_CLID_INUSE:
2096 case -NFS4ERR_WRONGSEC:
Jeff Layton6d769f12013-11-13 09:08:21 -05002097 /* No point in retrying if we already used RPC_AUTH_UNIX */
2098 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2099 status = -EPERM;
2100 break;
2101 }
Chuck Lever79d852b2013-04-22 15:42:48 -04002102 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
Chuck Lever05f4c352012-09-14 17:24:32 -04002103 if (IS_ERR(clnt)) {
2104 status = PTR_ERR(clnt);
2105 break;
2106 }
Trond Myklebustb193d592013-04-04 15:55:00 -04002107 /* Note: this is safe because we haven't yet marked the
2108 * client as ready, so we are the only user of
2109 * clp->cl_rpcclient
2110 */
2111 clnt = xchg(&clp->cl_rpcclient, clnt);
2112 rpc_shutdown_client(clnt);
2113 clnt = clp->cl_rpcclient;
Chuck Lever05f4c352012-09-14 17:24:32 -04002114 goto again;
2115
2116 case -NFS4ERR_MINOR_VERS_MISMATCH:
2117 status = -EPROTONOSUPPORT;
2118 break;
2119
2120 case -EKEYEXPIRED:
Chuck Lever05f4c352012-09-14 17:24:32 -04002121 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2122 * in nfs4_exchange_id */
2123 status = -EKEYEXPIRED;
Trond Myklebustea33e6c2013-04-05 13:22:50 -04002124 break;
2125 default:
2126 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2127 __func__, status);
2128 status = -EIO;
Chuck Lever05f4c352012-09-14 17:24:32 -04002129 }
2130
2131out_unlock:
2132 mutex_unlock(&nfs_clid_init_mutex);
Chuck Lever05f4c352012-09-14 17:24:32 -04002133 dprintk("NFS: %s: status = %d\n", __func__, status);
2134 return status;
2135}
2136
Andy Adamson76db6d92009-04-01 09:22:38 -04002137#ifdef CONFIG_NFS_V4_1
Trond Myklebust9f594792012-05-27 13:02:53 -04002138void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
Trond Myklebust0400a6b2011-03-09 16:00:53 -05002139{
Trond Myklebust444f72f2011-05-26 14:26:35 -04002140 struct nfs_client *clp = session->clp;
2141
Trond Myklebust9f594792012-05-27 13:02:53 -04002142 switch (err) {
2143 default:
2144 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2145 break;
2146 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2147 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2148 }
Trond Myklebust444f72f2011-05-26 14:26:35 -04002149 nfs4_schedule_lease_recovery(clp);
Trond Myklebust0400a6b2011-03-09 16:00:53 -05002150}
Andy Adamsoncbdabc7f2011-03-01 01:34:20 +00002151EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
Trond Myklebust0400a6b2011-03-09 16:00:53 -05002152
Trond Myklebustac074832012-11-21 09:06:11 -05002153static void nfs41_ping_server(struct nfs_client *clp)
2154{
2155 /* Use CHECK_LEASE to ping the server with a SEQUENCE */
2156 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2157 nfs4_schedule_state_manager(clp);
2158}
2159
2160void nfs41_server_notify_target_slotid_update(struct nfs_client *clp)
2161{
2162 nfs41_ping_server(clp);
2163}
2164
Trond Myklebustc10e4492012-11-26 16:16:54 -05002165void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp)
2166{
2167 nfs41_ping_server(clp);
2168}
2169
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002170static void nfs4_reset_all_state(struct nfs_client *clp)
2171{
2172 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
Chuck Lever2c820d92012-05-21 22:45:33 -04002173 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
Trond Myklebustbe0bfed2012-05-25 16:02:15 -04002174 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002175 nfs4_state_start_reclaim_nograce(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002176 dprintk("%s: scheduling reset of all state for server %s!\n",
2177 __func__, clp->cl_hostname);
Trond Myklebust0400a6b2011-03-09 16:00:53 -05002178 nfs4_schedule_state_manager(clp);
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002179 }
2180}
2181
2182static void nfs41_handle_server_reboot(struct nfs_client *clp)
2183{
2184 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2185 nfs4_state_start_reclaim_reboot(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002186 dprintk("%s: server %s rebooted!\n", __func__,
2187 clp->cl_hostname);
Trond Myklebust0400a6b2011-03-09 16:00:53 -05002188 nfs4_schedule_state_manager(clp);
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002189 }
2190}
2191
2192static void nfs41_handle_state_revoked(struct nfs_client *clp)
2193{
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002194 nfs4_reset_all_state(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002195 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002196}
2197
2198static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2199{
2200 /* This will need to handle layouts too */
2201 nfs_expire_all_delegations(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002202 dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2203 clp->cl_hostname);
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002204}
2205
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002206static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002207{
2208 nfs_expire_all_delegations(clp);
2209 if (test_and_set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) == 0)
Trond Myklebust0400a6b2011-03-09 16:00:53 -05002210 nfs4_schedule_state_manager(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002211 dprintk("%s: server %s declared a backchannel fault\n", __func__,
2212 clp->cl_hostname);
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002213}
2214
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002215static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2216{
2217 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2218 &clp->cl_state) == 0)
2219 nfs4_schedule_state_manager(clp);
2220}
2221
Alexandros Batsakis0629e372009-12-05 13:46:14 -05002222void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
2223{
2224 if (!flags)
2225 return;
Chuck Lever2c820d92012-05-21 22:45:33 -04002226
2227 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2228 __func__, clp->cl_hostname, clp->cl_clientid, flags);
2229
Trond Myklebust111d4892011-12-01 16:37:42 -05002230 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002231 nfs41_handle_server_reboot(clp);
Trond Myklebust111d4892011-12-01 16:37:42 -05002232 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
Alexandros Batsakis0629e372009-12-05 13:46:14 -05002233 SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
Chuck Leverd1c23312013-10-17 14:13:58 -04002234 SEQ4_STATUS_ADMIN_STATE_REVOKED))
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002235 nfs41_handle_state_revoked(clp);
Chuck Leverd1c23312013-10-17 14:13:58 -04002236 if (flags & SEQ4_STATUS_LEASE_MOVED)
2237 nfs4_schedule_lease_moved_recovery(clp);
Trond Myklebust111d4892011-12-01 16:37:42 -05002238 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002239 nfs41_handle_recallable_state_revoked(clp);
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002240 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2241 nfs41_handle_backchannel_fault(clp);
2242 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2243 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
Trond Myklebust0f79fd62010-03-02 13:06:21 -05002244 nfs41_handle_cb_path_down(clp);
Alexandros Batsakis0629e372009-12-05 13:46:14 -05002245}
2246
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04002247static int nfs4_reset_session(struct nfs_client *clp)
2248{
Trond Myklebust848f5bd2012-05-25 17:51:23 -04002249 struct rpc_cred *cred;
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04002250 int status;
2251
Trond Myklebust1a47e7a2012-06-05 10:53:38 -04002252 if (!nfs4_has_session(clp))
2253 return 0;
Trond Myklebust38045412009-12-15 17:36:57 -05002254 nfs4_begin_drain_session(clp);
Chuck Lever73d8bde2013-07-24 12:28:37 -04002255 cred = nfs4_get_clid_cred(clp);
Trond Myklebust848f5bd2012-05-25 17:51:23 -04002256 status = nfs4_proc_destroy_session(clp->cl_session, cred);
Trond Myklebustc489ee22013-01-30 13:04:10 -05002257 switch (status) {
2258 case 0:
2259 case -NFS4ERR_BADSESSION:
2260 case -NFS4ERR_DEADSESSION:
2261 break;
2262 case -NFS4ERR_BACK_CHAN_BUSY:
2263 case -NFS4ERR_DELAY:
2264 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2265 status = 0;
2266 ssleep(1);
2267 goto out;
2268 default:
Ricardo Labiagaf4558482009-12-07 09:16:09 -05002269 status = nfs4_recovery_handle_error(clp, status);
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04002270 goto out;
2271 }
2272
2273 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
Trond Myklebust848f5bd2012-05-25 17:51:23 -04002274 status = nfs4_proc_create_session(clp, cred);
Andy Adamson41f54a52010-01-21 14:54:13 -05002275 if (status) {
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002276 dprintk("%s: session reset failed with status %d for server %s!\n",
2277 __func__, status, clp->cl_hostname);
Trond Myklebustf2c1b512012-05-27 14:46:46 -04002278 status = nfs4_handle_reclaim_lease_error(clp, status);
Andy Adamson41f54a52010-01-21 14:54:13 -05002279 goto out;
2280 }
Trond Myklebustbda197f2012-06-05 10:22:14 -04002281 nfs41_finish_session_reset(clp);
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002282 dprintk("%s: session reset was successful for server %s!\n",
2283 __func__, clp->cl_hostname);
Andy Adamson41f54a52010-01-21 14:54:13 -05002284out:
Trond Myklebust848f5bd2012-05-25 17:51:23 -04002285 if (cred)
2286 put_rpccred(cred);
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04002287 return status;
2288}
Andy Adamson76db6d92009-04-01 09:22:38 -04002289
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002290static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2291{
Trond Myklebust2cf047c2012-05-25 17:57:41 -04002292 struct rpc_cred *cred;
2293 int ret;
2294
Trond Myklebust1a47e7a2012-06-05 10:53:38 -04002295 if (!nfs4_has_session(clp))
2296 return 0;
Trond Myklebust43ac5442012-05-27 13:47:21 -04002297 nfs4_begin_drain_session(clp);
Chuck Lever73d8bde2013-07-24 12:28:37 -04002298 cred = nfs4_get_clid_cred(clp);
Trond Myklebust2cf047c2012-05-25 17:57:41 -04002299 ret = nfs4_proc_bind_conn_to_session(clp, cred);
2300 if (cred)
2301 put_rpccred(cred);
Trond Myklebust43ac5442012-05-27 13:47:21 -04002302 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
Trond Myklebustbf674c82012-05-27 12:53:10 -04002303 switch (ret) {
2304 case 0:
Trond Myklebustcc0a9842012-05-28 15:12:27 -04002305 dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2306 __func__, clp->cl_hostname);
Trond Myklebustbf674c82012-05-27 12:53:10 -04002307 break;
2308 case -NFS4ERR_DELAY:
2309 ssleep(1);
2310 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2311 break;
2312 default:
2313 return nfs4_recovery_handle_error(clp, ret);
2314 }
2315 return 0;
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002316}
Andy Adamson76db6d92009-04-01 09:22:38 -04002317#else /* CONFIG_NFS_V4_1 */
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04002318static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002319
2320static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2321{
2322 return 0;
2323}
Andy Adamson76db6d92009-04-01 09:22:38 -04002324#endif /* CONFIG_NFS_V4_1 */
2325
Trond Myklebuste005e802008-12-23 15:21:48 -05002326static void nfs4_state_manager(struct nfs_client *clp)
Trond Myklebust02860012008-12-23 15:21:40 -05002327{
Trond Myklebust02860012008-12-23 15:21:40 -05002328 int status = 0;
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002329 const char *section = "", *section_sep = "";
Trond Myklebust02860012008-12-23 15:21:40 -05002330
Trond Myklebust02860012008-12-23 15:21:40 -05002331 /* Ensure exclusive access to NFSv4 state */
Trond Myklebust47c21992011-04-15 17:34:18 -04002332 do {
Chuck Lever2c820d92012-05-21 22:45:33 -04002333 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002334 section = "purge state";
Trond Myklebustb42353f2012-06-05 11:19:47 -04002335 status = nfs4_purge_lease(clp);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04002336 if (status < 0)
2337 goto out_error;
Trond Myklebustb42353f2012-06-05 11:19:47 -04002338 continue;
Chuck Lever2c820d92012-05-21 22:45:33 -04002339 }
2340
Trond Myklebustb42353f2012-06-05 11:19:47 -04002341 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002342 section = "lease expired";
Trond Myklebustb79a4a12008-12-23 15:21:41 -05002343 /* We're going to have to re-establish a clientid */
2344 status = nfs4_reclaim_lease(clp);
Trond Myklebust2a6ee6a2012-05-25 15:00:06 -04002345 if (status < 0)
Trond Myklebustb79a4a12008-12-23 15:21:41 -05002346 goto out_error;
Trond Myklebustb42353f2012-06-05 11:19:47 -04002347 continue;
Trond Myklebuste598d842008-12-23 15:21:42 -05002348 }
2349
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04002350 /* Initialize or reset the session */
Trond Myklebust1a47e7a2012-06-05 10:53:38 -04002351 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002352 section = "reset session";
Andy Adamson4d643d12009-12-04 15:52:24 -05002353 status = nfs4_reset_session(clp);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05002354 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2355 continue;
2356 if (status < 0)
Andy Adamson76db6d92009-04-01 09:22:38 -04002357 goto out_error;
Andy Adamson76db6d92009-04-01 09:22:38 -04002358 }
Trond Myklebustb6d408b2009-12-03 15:53:22 -05002359
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002360 /* Send BIND_CONN_TO_SESSION */
2361 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
Trond Myklebust1a47e7a2012-06-05 10:53:38 -04002362 &clp->cl_state)) {
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002363 section = "bind conn to session";
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002364 status = nfs4_bind_conn_to_session(clp);
2365 if (status < 0)
2366 goto out_error;
Trond Myklebustbf674c82012-05-27 12:53:10 -04002367 continue;
Weston Andros Adamsona9e64442012-05-24 12:26:37 -04002368 }
2369
Trond Myklebust5df904a2012-11-21 09:22:14 -05002370 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2371 section = "check lease";
2372 status = nfs4_check_lease(clp);
2373 if (status < 0)
2374 goto out_error;
Olga Kornievskaia8faaa6d2014-09-24 18:11:28 -04002375 continue;
Chuck Leverc9fdeb22013-10-17 14:13:02 -04002376 }
2377
2378 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
2379 section = "migration";
2380 status = nfs4_handle_migration(clp);
2381 if (status < 0)
2382 goto out_error;
Trond Myklebust5df904a2012-11-21 09:22:14 -05002383 }
2384
Chuck Leverb7f7a662013-10-17 14:13:35 -04002385 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
2386 section = "lease moved";
2387 status = nfs4_handle_lease_moved(clp);
2388 if (status < 0)
2389 goto out_error;
2390 }
2391
Trond Myklebustb79a4a12008-12-23 15:21:41 -05002392 /* First recover reboot state... */
Trond Myklebuste345e882009-12-03 15:52:41 -05002393 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002394 section = "reclaim reboot";
Andy Adamson591d71c2009-04-01 09:22:47 -04002395 status = nfs4_do_reclaim(clp,
Trond Myklebustc48f4f32010-06-16 09:52:27 -04002396 clp->cl_mvops->reboot_recovery_ops);
Trond Myklebustdf817ba32014-09-27 17:41:51 -04002397 if (status == -EAGAIN)
Trond Myklebustb6d408b2009-12-03 15:53:22 -05002398 continue;
2399 if (status < 0)
2400 goto out_error;
Trond Myklebustdf817ba32014-09-27 17:41:51 -04002401 nfs4_state_end_reclaim_reboot(clp);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05002402 }
2403
2404 /* Now recover expired state... */
2405 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002406 section = "reclaim nograce";
Andy Adamson591d71c2009-04-01 09:22:47 -04002407 status = nfs4_do_reclaim(clp,
Trond Myklebustc48f4f32010-06-16 09:52:27 -04002408 clp->cl_mvops->nograce_recovery_ops);
Trond Myklebustdf817ba32014-09-27 17:41:51 -04002409 if (status == -EAGAIN)
Trond Myklebustb6d408b2009-12-03 15:53:22 -05002410 continue;
2411 if (status < 0)
Trond Myklebustb79a4a12008-12-23 15:21:41 -05002412 goto out_error;
Trond Myklebustb79a4a12008-12-23 15:21:41 -05002413 }
Trond Myklebust707fb4b2008-12-23 15:21:47 -05002414
Alexandros Batsakis5601a002009-12-14 21:27:58 -08002415 nfs4_end_drain_session(clp);
Trond Myklebust707fb4b2008-12-23 15:21:47 -05002416 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2417 nfs_client_return_marked_delegations(clp);
2418 continue;
2419 }
Trond Myklebuste005e802008-12-23 15:21:48 -05002420
2421 nfs4_clear_state_manager_bit(clp);
Trond Myklebustf3c76492008-12-23 15:21:48 -05002422 /* Did we race with an attempt to give us more work? */
2423 if (clp->cl_state == 0)
2424 break;
2425 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2426 break;
Trond Myklebust47c21992011-04-15 17:34:18 -04002427 } while (atomic_read(&clp->cl_count) > 1);
Trond Myklebuste005e802008-12-23 15:21:48 -05002428 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429out_error:
Weston Andros Adamson8ed27d42012-05-29 15:57:59 -04002430 if (strlen(section))
2431 section_sep = ": ";
2432 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2433 " with error %d\n", section_sep, section,
2434 clp->cl_hostname, -status);
Chuck Leverffe5a832012-09-14 17:23:23 -04002435 ssleep(1);
Alexandros Batsakis5601a002009-12-14 21:27:58 -08002436 nfs4_end_drain_session(clp);
Trond Myklebuste005e802008-12-23 15:21:48 -05002437 nfs4_clear_state_manager_bit(clp);
2438}
2439
2440static int nfs4_run_state_manager(void *ptr)
2441{
2442 struct nfs_client *clp = ptr;
2443
2444 allow_signal(SIGKILL);
2445 nfs4_state_manager(clp);
2446 nfs_put_client(clp);
2447 module_put_and_exit(0);
2448 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002449}
2450
2451/*
2452 * Local variables:
2453 * c-basic-offset: 8
2454 * End:
2455 */