]> Git Repo - linux.git/blame - fs/nfs/nfs4state.c
projects / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'v6.12-p5' of git://git.kernel.org/pub/scm/linux/kernel/git/herbert/crypto-2.6
[linux.git] / fs / nfs / nfs4state.c
CommitLineData
1da177e4
LT		 1/*
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 <[email protected]>
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
6f43ddcc 41#include <linux/kernel.h>
1da177e4 42#include <linux/slab.h>
b89f4321 43#include <linux/fs.h>
1da177e4 44#include <linux/nfs_fs.h>
5043e900
TM		 45#include <linux/kthread.h>
46#include <linux/module.h>
9f958ab8 47#include <linux/random.h>
8c7597f6 48#include <linux/ratelimit.h>
1da177e4
LT		 49#include <linux/workqueue.h>
50#include <linux/bitops.h>
0aaaf5c4 51#include <linux/jiffies.h>
3e17898a 52#include <linux/sched/mm.h>
1da177e4 53
05f4c350
CL		 54#include <linux/sunrpc/clnt.h>
55
4ce79717 56#include "nfs4_fs.h"
1da177e4
LT		 57#include "callback.h"
58#include "delegation.h"
24c8dbbb 59#include "internal.h"
40c64c26 60#include "nfs4idmap.h"
76e697ba 61#include "nfs4session.h"
974cec8c 62#include "pnfs.h"
bbe0a3aa 63#include "netns.h"
511ba52e 64#include "nfs4trace.h"
1da177e4 65
e3c0fb7e
CL		 66#define NFSDBG_FACILITY NFSDBG_STATE
67
1da177e4
LT		 68#define OPENOWNER_POOL_SIZE 8
69
40882deb
TM		 70static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp);
71
93b717fd 72const nfs4_stateid zero_stateid = {
e0714ec4 73 { .data = { 0 } },
93b717fd
TM		 74 .type = NFS4_SPECIAL_STATEID_TYPE,
75};
fcd8843c
TM		 76const nfs4_stateid invalid_stateid = {
77 {
445f288d
TM		 78 /* Funky initialiser keeps older gcc versions happy */
79 .data = { 0xff, 0xff, 0xff, 0xff, 0 },
fcd8843c
TM		 80 },
81 .type = NFS4_INVALID_STATEID_TYPE,
82};
83
2409a976
FI		 84const nfs4_stateid current_stateid = {
85 {
86 /* Funky initialiser keeps older gcc versions happy */
87 .data = { 0x0, 0x0, 0x0, 0x1, 0 },
88 },
89 .type = NFS4_SPECIAL_STATEID_TYPE,
90};
91
05f4c350 92static DEFINE_MUTEX(nfs_clid_init_mutex);
1da177e4 93
5b596830
DB		 94static int nfs4_setup_state_renewal(struct nfs_client *clp)
95{
96 int status;
97 struct nfs_fsinfo fsinfo;
5b596830
DB		 98
99 if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
100 nfs4_schedule_state_renewal(clp);
101 return 0;
102 }
103
5b596830
DB		 104 status = nfs4_proc_get_lease_time(clp, &fsinfo);
105 if (status == 0) {
7dc2993a 106 nfs4_set_lease_period(clp, fsinfo.lease_time * HZ);
5b596830
DB		 107 nfs4_schedule_state_renewal(clp);
108 }
109
110 return status;
111}
112
a52458b4 113int nfs4_init_clientid(struct nfs_client *clp, const struct cred *cred)
1da177e4 114{
fd954ae1
TM		 115 struct nfs4_setclientid_res clid = {
116 .clientid = clp->cl_clientid,
117 .confirm = clp->cl_confirm,
118 };
f738f517
CL		 119 unsigned short port;
120 int status;
bbe0a3aa 121 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
f738f517 122
fd954ae1
TM		 123 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
124 goto do_confirm;
bbe0a3aa 125 port = nn->nfs_callback_tcpport;
f738f517 126 if (clp->cl_addr.ss_family == AF_INET6)
29dcc16a 127 port = nn->nfs_callback_tcpport6;
f738f517 128
bb8b27e5
TM		 129 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
130 if (status != 0)
131 goto out;
fd954ae1
TM		 132 clp->cl_clientid = clid.clientid;
133 clp->cl_confirm = clid.confirm;
134 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
135do_confirm:
bb8b27e5
TM		 136 status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
137 if (status != 0)
138 goto out;
fd954ae1 139 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
5b596830 140 nfs4_setup_state_renewal(clp);
bb8b27e5 141out:
1da177e4
LT		 142 return status;
143}
144
05f4c350
CL		 145/**
146 * nfs40_discover_server_trunking - Detect server IP address trunking (mv0)
147 *
148 * @clp: nfs_client under test
149 * @result: OUT: found nfs_client, or clp
150 * @cred: credential to use for trunking test
151 *
152 * Returns zero, a negative errno, or a negative NFS4ERR status.
153 * If zero is returned, an nfs_client pointer is planted in
154 * "result".
155 *
156 * Note: The returned client may not yet be marked ready.
157 */
158int nfs40_discover_server_trunking(struct nfs_client *clp,
159 struct nfs_client **result,
a52458b4 160 const struct cred *cred)
05f4c350
CL		 161{
162 struct nfs4_setclientid_res clid = {
163 .clientid = clp->cl_clientid,
164 .confirm = clp->cl_confirm,
165 };
9f62387d 166 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
05f4c350
CL		 167 unsigned short port;
168 int status;
169
9f62387d 170 port = nn->nfs_callback_tcpport;
05f4c350 171 if (clp->cl_addr.ss_family == AF_INET6)
9f62387d 172 port = nn->nfs_callback_tcpport6;
05f4c350
CL		 173
174 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
175 if (status != 0)
176 goto out;
177 clp->cl_clientid = clid.clientid;
178 clp->cl_confirm = clid.confirm;
179
180 status = nfs40_walk_client_list(clp, result, cred);
202c312d 181 if (status == 0) {
05f4c350
CL		 182 /* Sustain the lease, even if it's empty. If the clientid4
183 * goes stale it's of no use for trunking discovery. */
184 nfs4_schedule_state_renewal(*result);
f02f3755
Z		 185
186 /* If the client state need to recover, do it. */
187 if (clp->cl_state)
188 nfs4_schedule_state_manager(clp);
05f4c350 189 }
05f4c350
CL		 190out:
191 return status;
192}
193
a52458b4 194const struct cred *nfs4_get_machine_cred(struct nfs_client *clp)
a2b2bb88 195{
a52458b4 196 return get_cred(rpc_machine_cred());
a2b2bb88
TM		 197}
198
d688f7b8
CL		 199static void nfs4_root_machine_cred(struct nfs_client *clp)
200{
d688f7b8 201
5e16923b
N		 202 /* Force root creds instead of machine */
203 clp->cl_principal = NULL;
204 clp->cl_rpcclient->cl_principal = NULL;
d688f7b8
CL		 205}
206
a52458b4 207static const struct cred *
24d292b8 208nfs4_get_renew_cred_server_locked(struct nfs_server *server)
b4454fe1 209{
a52458b4 210 const struct cred *cred = NULL;
b4454fe1 211 struct nfs4_state_owner *sp;
9f958ab8 212 struct rb_node *pos;
b4454fe1 213
24d292b8
CL		 214 for (pos = rb_first(&server->state_owners);
215 pos != NULL;
216 pos = rb_next(pos)) {
217 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
b4454fe1
TM		 218 if (list_empty(&sp->so_states))
219 continue;
a52458b4 220 cred = get_cred(sp->so_cred);
b4454fe1
TM		 221 break;
222 }
223 return cred;
224}
225
24d292b8 226/**
f15e1e8b 227 * nfs4_get_renew_cred - Acquire credential for a renew operation
24d292b8
CL		 228 * @clp: client state handle
229 *
230 * Returns an rpc_cred with reference count bumped, or NULL.
231 * Caller must hold clp->cl_lock.
232 */
a52458b4 233const struct cred *nfs4_get_renew_cred(struct nfs_client *clp)
24d292b8 234{
a52458b4 235 const struct cred *cred = NULL;
24d292b8
CL		 236 struct nfs_server *server;
237
e49a29bd 238 /* Use machine credentials if available */
f15e1e8b 239 cred = nfs4_get_machine_cred(clp);
e49a29bd
SP		 240 if (cred != NULL)
241 goto out;
242
f15e1e8b 243 spin_lock(&clp->cl_lock);
24d292b8
CL		 244 rcu_read_lock();
245 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
246 cred = nfs4_get_renew_cred_server_locked(server);
247 if (cred != NULL)
248 break;
249 }
250 rcu_read_unlock();
f15e1e8b 251 spin_unlock(&clp->cl_lock);
e49a29bd
SP		 252
253out:
24d292b8
CL		 254 return cred;
255}
256
62f288a0 257static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
9dfdf404 258{
774d5f14 259 if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
961a828d 260 spin_lock(&tbl->slot_tbl_lock);
b75ad4cd 261 nfs41_wake_slot_table(tbl);
961a828d 262 spin_unlock(&tbl->slot_tbl_lock);
689cf5c1 263 }
9dfdf404
RL		 264}
265
62f288a0
AA		 266static void nfs4_end_drain_session(struct nfs_client *clp)
267{
268 struct nfs4_session *ses = clp->cl_session;
269
2cf8bca8
CL		 270 if (clp->cl_slot_tbl) {
271 nfs4_end_drain_slot_table(clp->cl_slot_tbl);
272 return;
273 }
274
62f288a0
AA		 275 if (ses != NULL) {
276 nfs4_end_drain_slot_table(&ses->bc_slot_table);
277 nfs4_end_drain_slot_table(&ses->fc_slot_table);
278 }
279}
280
774d5f14 281static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
9dfdf404 282{
774d5f14 283 set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
9dfdf404 284 spin_lock(&tbl->slot_tbl_lock);
b6bf6e7d 285 if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
16735d02 286 reinit_completion(&tbl->complete);
9dfdf404 287 spin_unlock(&tbl->slot_tbl_lock);
42acd021 288 return wait_for_completion_interruptible(&tbl->complete);
9dfdf404
RL		 289 }
290 spin_unlock(&tbl->slot_tbl_lock);
291 return 0;
292}
293
42acd021
AA		 294static int nfs4_begin_drain_session(struct nfs_client *clp)
295{
296 struct nfs4_session *ses = clp->cl_session;
8aafd2fd 297 int ret;
42acd021 298
2cf8bca8
CL		 299 if (clp->cl_slot_tbl)
300 return nfs4_drain_slot_tbl(clp->cl_slot_tbl);
301
42acd021 302 /* back channel */
774d5f14 303 ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
42acd021
AA		 304 if (ret)
305 return ret;
306 /* fore channel */
774d5f14 307 return nfs4_drain_slot_tbl(&ses->fc_slot_table);
42acd021
AA		 308}
309
c9fdeb28
CL		 310#if defined(CONFIG_NFS_V4_1)
311
bda197f5
TM		 312static void nfs41_finish_session_reset(struct nfs_client *clp)
313{
314 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
315 clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
316 /* create_session negotiated new slot table */
bda197f5 317 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
ea51efaa 318 nfs4_setup_state_renewal(clp);
bda197f5
TM		 319}
320
a52458b4 321int nfs41_init_clientid(struct nfs_client *clp, const struct cred *cred)
4d643d1d
AA		 322{
323 int status;
324
fd954ae1
TM		 325 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
326 goto do_confirm;
4d643d1d 327 status = nfs4_proc_exchange_id(clp, cred);
9430fb6b
RL		 328 if (status != 0)
329 goto out;
fd954ae1
TM		 330 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
331do_confirm:
848f5bda 332 status = nfs4_proc_create_session(clp, cred);
9430fb6b
RL		 333 if (status != 0)
334 goto out;
40882deb
TM		 335 if (!(clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R))
336 nfs4_state_start_reclaim_reboot(clp);
bda197f5 337 nfs41_finish_session_reset(clp);
9430fb6b
RL		 338 nfs_mark_client_ready(clp, NFS_CS_READY);
339out:
4d643d1d
AA		 340 return status;
341}
342
05f4c350
CL		 343/**
344 * nfs41_discover_server_trunking - Detect server IP address trunking (mv1)
345 *
346 * @clp: nfs_client under test
347 * @result: OUT: found nfs_client, or clp
348 * @cred: credential to use for trunking test
349 *
350 * Returns NFS4_OK, a negative errno, or a negative NFS4ERR status.
351 * If NFS4_OK is returned, an nfs_client pointer is planted in
352 * "result".
353 *
354 * Note: The returned client may not yet be marked ready.
355 */
356int nfs41_discover_server_trunking(struct nfs_client *clp,
357 struct nfs_client **result,
a52458b4 358 const struct cred *cred)
05f4c350
CL		 359{
360 int status;
361
362 status = nfs4_proc_exchange_id(clp, cred);
363 if (status != NFS4_OK)
364 return status;
365
48d66b97
TM		 366 status = nfs41_walk_client_list(clp, result, cred);
367 if (status < 0)
368 return status;
369 if (clp != *result)
370 return 0;
371
8dcbec6d
CL		 372 /*
373 * Purge state if the client id was established in a prior
374 * instance and the client id could not have arrived on the
375 * server via Transparent State Migration.
376 */
377 if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R) {
378 if (!test_bit(NFS_CS_TSM_POSSIBLE, &clp->cl_flags))
379 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
380 else
381 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
382 }
48d66b97
TM		 383 nfs4_schedule_state_manager(clp);
384 status = nfs_wait_client_init_complete(clp);
385 if (status < 0)
386 nfs_put_client(clp);
387 return status;
05f4c350
CL		 388}
389
b4b82607
AA		 390#endif /* CONFIG_NFS_V4_1 */
391
24d292b8 392/**
73d8bde5 393 * nfs4_get_clid_cred - Acquire credential for a setclientid operation
24d292b8
CL		 394 * @clp: client state handle
395 *
a52458b4 396 * Returns a cred with reference count bumped, or NULL.
24d292b8 397 */
a52458b4 398const struct cred *nfs4_get_clid_cred(struct nfs_client *clp)
24d292b8 399{
a52458b4 400 const struct cred *cred;
286d7d6a 401
f15e1e8b 402 cred = nfs4_get_machine_cred(clp);
a2b2bb88 403 return cred;
286d7d6a
TM		 404}
405
1da177e4 406static struct nfs4_state_owner *
a52458b4 407nfs4_find_state_owner_locked(struct nfs_server *server, const struct cred *cred)
1da177e4 408{
24d292b8 409 struct rb_node **p = &server->state_owners.rb_node,
9f958ab8 410 *parent = NULL;
414adf14 411 struct nfs4_state_owner *sp;
a52458b4 412 int cmp;
1da177e4 413
9f958ab8
TM		 414 while (*p != NULL) {
415 parent = *p;
24d292b8 416 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
a52458b4 417 cmp = cred_fscmp(cred, sp->so_cred);
9f958ab8 418
a52458b4 419 if (cmp < 0)
9f958ab8 420 p = &parent->rb_left;
a52458b4 421 else if (cmp > 0)
9f958ab8
TM		 422 p = &parent->rb_right;
423 else {
0aaaf5c4
CL		 424 if (!list_empty(&sp->so_lru))
425 list_del_init(&sp->so_lru);
9f958ab8 426 atomic_inc(&sp->so_count);
414adf14 427 return sp;
9f958ab8 428 }
1da177e4 429 }
414adf14 430 return NULL;
1da177e4
LT		 431}
432
9f958ab8 433static struct nfs4_state_owner *
24d292b8 434nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
9f958ab8 435{
24d292b8
CL		 436 struct nfs_server *server = new->so_server;
437 struct rb_node **p = &server->state_owners.rb_node,
9f958ab8
TM		 438 *parent = NULL;
439 struct nfs4_state_owner *sp;
a52458b4 440 int cmp;
9f958ab8
TM		 441
442 while (*p != NULL) {
443 parent = *p;
24d292b8 444 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
a52458b4 445 cmp = cred_fscmp(new->so_cred, sp->so_cred);
9f958ab8 446
a52458b4 447 if (cmp < 0)
9f958ab8 448 p = &parent->rb_left;
a52458b4 449 else if (cmp > 0)
9f958ab8
TM		 450 p = &parent->rb_right;
451 else {
0aaaf5c4
CL		 452 if (!list_empty(&sp->so_lru))
453 list_del_init(&sp->so_lru);
9f958ab8
TM		 454 atomic_inc(&sp->so_count);
455 return sp;
456 }
457 }
24d292b8
CL		 458 rb_link_node(&new->so_server_node, parent, p);
459 rb_insert_color(&new->so_server_node, &server->state_owners);
9f958ab8
TM		 460 return new;
461}
462
463static void
24d292b8 464nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
9f958ab8 465{
24d292b8
CL		 466 struct nfs_server *server = sp->so_server;
467
468 if (!RB_EMPTY_NODE(&sp->so_server_node))
469 rb_erase(&sp->so_server_node, &server->state_owners);
9f958ab8
TM		 470}
471
7ba127ab
TM		 472static void
473nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
474{
95b72eb0 475 sc->create_time = ktime_get();
7ba127ab
TM		 476 sc->flags = 0;
477 sc->counter = 0;
478 spin_lock_init(&sc->lock);
479 INIT_LIST_HEAD(&sc->list);
480 rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
481}
482
483static void
484nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
485{
486 rpc_destroy_wait_queue(&sc->wait);
487}
488
1da177e4
LT		 489/*
490 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
491 * create a new state_owner.
492 *
493 */
494static struct nfs4_state_owner *
d1e284d5 495nfs4_alloc_state_owner(struct nfs_server *server,
a52458b4 496 const struct cred *cred,
d1e284d5 497 gfp_t gfp_flags)
1da177e4
LT		 498{
499 struct nfs4_state_owner *sp;
500
d1e284d5 501 sp = kzalloc(sizeof(*sp), gfp_flags);
1da177e4
LT		 502 if (!sp)
503 return NULL;
d98f7227 504 sp->so_seqid.owner_id = atomic64_inc_return(&server->owner_ctr);
d1e284d5 505 sp->so_server = server;
a52458b4 506 sp->so_cred = get_cred(cred);
ec073428 507 spin_lock_init(&sp->so_lock);
1da177e4 508 INIT_LIST_HEAD(&sp->so_states);
7ba127ab 509 nfs4_init_seqid_counter(&sp->so_seqid);
1da177e4 510 atomic_set(&sp->so_count, 1);
0aaaf5c4 511 INIT_LIST_HEAD(&sp->so_lru);
65b62a29 512 mutex_init(&sp->so_delegreturn_mutex);
1da177e4
LT		 513 return sp;
514}
515
1d2e88e7 516static void
86cfb041 517nfs4_reset_state_owner(struct nfs4_state_owner *sp)
1da177e4 518{
86cfb041
N		 519 /* This state_owner is no longer usable, but must
520 * remain in place so that state recovery can find it
521 * and the opens associated with it.
522 * It may also be used for new 'open' request to
523 * return a delegation to the server.
524 * So update the 'create_time' so that it looks like
525 * a new state_owner. This will cause the server to
526 * request an OPEN_CONFIRM to start a new sequence.
527 */
528 sp->so_seqid.create_time = ktime_get();
1da177e4
LT		 529}
530
0aaaf5c4
CL		 531static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
532{
7ba127ab 533 nfs4_destroy_seqid_counter(&sp->so_seqid);
a52458b4 534 put_cred(sp->so_cred);
0aaaf5c4
CL		 535 kfree(sp);
536}
537
538static void nfs4_gc_state_owners(struct nfs_server *server)
539{
540 struct nfs_client *clp = server->nfs_client;
541 struct nfs4_state_owner *sp, *tmp;
542 unsigned long time_min, time_max;
543 LIST_HEAD(doomed);
544
545 spin_lock(&clp->cl_lock);
546 time_max = jiffies;
547 time_min = (long)time_max - (long)clp->cl_lease_time;
548 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
549 /* NB: LRU is sorted so that oldest is at the head */
550 if (time_in_range(sp->so_expires, time_min, time_max))
551 break;
552 list_move(&sp->so_lru, &doomed);
553 nfs4_remove_state_owner_locked(sp);
554 }
555 spin_unlock(&clp->cl_lock);
556
557 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
558 list_del(&sp->so_lru);
559 nfs4_free_state_owner(sp);
560 }
561}
562
24d292b8
CL		 563/**
564 * nfs4_get_state_owner - Look up a state owner given a credential
565 * @server: nfs_server to search
566 * @cred: RPC credential to match
302fad7b 567 * @gfp_flags: allocation mode
24d292b8
CL		 568 *
569 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
570 */
571struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
a52458b4 572 const struct cred *cred,
d1e284d5 573 gfp_t gfp_flags)
1da177e4 574{
7539bbab 575 struct nfs_client *clp = server->nfs_client;
1da177e4
LT		 576 struct nfs4_state_owner *sp, *new;
577
1da177e4 578 spin_lock(&clp->cl_lock);
24d292b8 579 sp = nfs4_find_state_owner_locked(server, cred);
1da177e4 580 spin_unlock(&clp->cl_lock);
1da177e4 581 if (sp != NULL)
0aaaf5c4 582 goto out;
d1e284d5 583 new = nfs4_alloc_state_owner(server, cred, gfp_flags);
9f958ab8 584 if (new == NULL)
0aaaf5c4 585 goto out;
aae5730e
MW		 586 spin_lock(&clp->cl_lock);
587 sp = nfs4_insert_state_owner_locked(new);
588 spin_unlock(&clp->cl_lock);
d1e284d5
TM		 589 if (sp != new)
590 nfs4_free_state_owner(new);
0aaaf5c4
CL		 591out:
592 nfs4_gc_state_owners(server);
9f958ab8 593 return sp;
1da177e4
LT		 594}
595
24d292b8
CL		 596/**
597 * nfs4_put_state_owner - Release a nfs4_state_owner
598 * @sp: state owner data to release
7bf97bc2
TM		 599 *
600 * Note that we keep released state owners on an LRU
601 * list.
602 * This caches valid state owners so that they can be
603 * reused, to avoid the OPEN_CONFIRM on minor version 0.
604 * It also pins the uniquifier of dropped state owners for
605 * a while, to ensure that those state owner names are
606 * never reused.
24d292b8 607 */
1da177e4
LT		 608void nfs4_put_state_owner(struct nfs4_state_owner *sp)
609{
0aaaf5c4
CL		 610 struct nfs_server *server = sp->so_server;
611 struct nfs_client *clp = server->nfs_client;
1da177e4
LT		 612
613 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
614 return;
0aaaf5c4 615
7bf97bc2
TM		 616 sp->so_expires = jiffies;
617 list_add_tail(&sp->so_lru, &server->state_owners_lru);
618 spin_unlock(&clp->cl_lock);
0aaaf5c4
CL		 619}
620
621/**
622 * nfs4_purge_state_owners - Release all cached state owners
623 * @server: nfs_server with cached state owners to release
c77e2283 624 * @head: resulting list of state owners
0aaaf5c4
CL		 625 *
626 * Called at umount time. Remaining state owners will be on
627 * the LRU with ref count of zero.
c77e2283
TM		 628 * Note that the state owners are not freed, but are added
629 * to the list @head, which can later be used as an argument
630 * to nfs4_free_state_owners.
0aaaf5c4 631 */
c77e2283 632void nfs4_purge_state_owners(struct nfs_server *server, struct list_head *head)
0aaaf5c4
CL		 633{
634 struct nfs_client *clp = server->nfs_client;
635 struct nfs4_state_owner *sp, *tmp;
0aaaf5c4
CL		 636
637 spin_lock(&clp->cl_lock);
638 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
c77e2283 639 list_move(&sp->so_lru, head);
0aaaf5c4
CL		 640 nfs4_remove_state_owner_locked(sp);
641 }
1da177e4 642 spin_unlock(&clp->cl_lock);
c77e2283 643}
0aaaf5c4 644
c77e2283 645/**
6453bcd0 646 * nfs4_free_state_owners - Release all cached state owners
c77e2283
TM		 647 * @head: resulting list of state owners
648 *
649 * Frees a list of state owners that was generated by
650 * nfs4_purge_state_owners
651 */
652void nfs4_free_state_owners(struct list_head *head)
653{
654 struct nfs4_state_owner *sp, *tmp;
655
656 list_for_each_entry_safe(sp, tmp, head, so_lru) {
0aaaf5c4
CL		 657 list_del(&sp->so_lru);
658 nfs4_free_state_owner(sp);
659 }
1da177e4
LT		 660}
661
662static struct nfs4_state *
663nfs4_alloc_open_state(void)
664{
665 struct nfs4_state *state;
666
9c00fd9a 667 state = kzalloc(sizeof(*state), GFP_KERNEL_ACCOUNT);
1da177e4
LT		 668 if (!state)
669 return NULL;
ace9fad4 670 refcount_set(&state->count, 1);
1da177e4 671 INIT_LIST_HEAD(&state->lock_states);
8d0a8a9d 672 spin_lock_init(&state->state_lock);
8bda4e4c 673 seqlock_init(&state->seqlock);
c9399f21 674 init_waitqueue_head(&state->waitq);
1da177e4
LT		 675 return state;
676}
677
4cecb76f 678void
dc0b027d 679nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
4cecb76f 680{
dc0b027d 681 if (state->state == fmode)
4cecb76f
TM		 682 return;
683 /* NB! List reordering - see the reclaim code for why. */
dc0b027d
TM		 684 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
685 if (fmode & FMODE_WRITE)
4cecb76f
TM		 686 list_move(&state->open_states, &state->owner->so_states);
687 else
688 list_move_tail(&state->open_states, &state->owner->so_states);
689 }
dc0b027d 690 state->state = fmode;
4cecb76f
TM		 691}
692
1da177e4
LT		 693static struct nfs4_state *
694__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
695{
696 struct nfs_inode *nfsi = NFS_I(inode);
697 struct nfs4_state *state;
698
9ae075fd 699 list_for_each_entry_rcu(state, &nfsi->open_states, inode_states) {
1c816efa 700 if (state->owner != owner)
1da177e4 701 continue;
5d422301
TM		 702 if (!nfs4_valid_open_stateid(state))
703 continue;
ace9fad4 704 if (refcount_inc_not_zero(&state->count))
1da177e4 705 return state;
1da177e4
LT		 706 }
707 return NULL;
708}
709
1da177e4
LT		 710static void
711nfs4_free_open_state(struct nfs4_state *state)
712{
9ae075fd 713 kfree_rcu(state, rcu_head);
1da177e4
LT		 714}
715
716struct nfs4_state *
717nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
718{
719 struct nfs4_state *state, *new;
720 struct nfs_inode *nfsi = NFS_I(inode);
721
9ae075fd 722 rcu_read_lock();
1da177e4 723 state = __nfs4_find_state_byowner(inode, owner);
9ae075fd 724 rcu_read_unlock();
1da177e4
LT		 725 if (state)
726 goto out;
727 new = nfs4_alloc_open_state();
ec073428 728 spin_lock(&owner->so_lock);
1da177e4
LT		 729 spin_lock(&inode->i_lock);
730 state = __nfs4_find_state_byowner(inode, owner);
731 if (state == NULL && new != NULL) {
732 state = new;
1da177e4
LT		 733 state->owner = owner;
734 atomic_inc(&owner->so_count);
0444d76a
DC		 735 ihold(inode);
736 state->inode = inode;
29fe8399 737 list_add_rcu(&state->inode_states, &nfsi->open_states);
1da177e4 738 spin_unlock(&inode->i_lock);
ec073428
TM		 739 /* Note: The reclaim code dictates that we add stateless
740 * and read-only stateids to the end of the list */
741 list_add_tail(&state->open_states, &owner->so_states);
742 spin_unlock(&owner->so_lock);
1da177e4
LT		 743 } else {
744 spin_unlock(&inode->i_lock);
ec073428 745 spin_unlock(&owner->so_lock);
1da177e4
LT		 746 if (new)
747 nfs4_free_open_state(new);
748 }
749out:
750 return state;
751}
752
1da177e4
LT		 753void nfs4_put_open_state(struct nfs4_state *state)
754{
755 struct inode *inode = state->inode;
756 struct nfs4_state_owner *owner = state->owner;
757
ace9fad4 758 if (!refcount_dec_and_lock(&state->count, &owner->so_lock))
1da177e4 759 return;
ec073428 760 spin_lock(&inode->i_lock);
9ae075fd 761 list_del_rcu(&state->inode_states);
1da177e4 762 list_del(&state->open_states);
ec073428
TM		 763 spin_unlock(&inode->i_lock);
764 spin_unlock(&owner->so_lock);
b7b7dac6 765 nfs4_inode_return_delegation_on_close(inode);
1da177e4 766 iput(inode);
1da177e4
LT		 767 nfs4_free_open_state(state);
768 nfs4_put_state_owner(owner);
769}
770
771/*
83c9d41e 772 * Close the current file.
1da177e4 773 */
643168c2 774static void __nfs4_close(struct nfs4_state *state,
8535b2be 775 fmode_t fmode, gfp_t gfp_mask, int wait)
1da177e4 776{
1da177e4 777 struct nfs4_state_owner *owner = state->owner;
003707c7 778 int call_close = 0;
dc0b027d 779 fmode_t newstate;
1da177e4
LT		 780
781 atomic_inc(&owner->so_count);
1da177e4 782 /* Protect against nfs4_find_state() */
ec073428 783 spin_lock(&owner->so_lock);
dc0b027d 784 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
e7616923
TM		 785 case FMODE_READ:
786 state->n_rdonly--;
787 break;
788 case FMODE_WRITE:
789 state->n_wronly--;
790 break;
791 case FMODE_READ|FMODE_WRITE:
792 state->n_rdwr--;
793 }
003707c7 794 newstate = FMODE_READ|FMODE_WRITE;
e7616923 795 if (state->n_rdwr == 0) {
003707c7 796 if (state->n_rdonly == 0) {
e7616923 797 newstate &= ~FMODE_READ;
003707c7
TM		 798 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
799 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
800 }
801 if (state->n_wronly == 0) {
e7616923 802 newstate &= ~FMODE_WRITE;
003707c7
TM		 803 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
804 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
805 }
806 if (newstate == 0)
807 clear_bit(NFS_DELEGATED_STATE, &state->flags);
e7616923 808 }
003707c7 809 nfs4_state_set_mode_locked(state, newstate);
ec073428 810 spin_unlock(&owner->so_lock);
4cecb76f 811
003707c7 812 if (!call_close) {
b39e625b
TM		 813 nfs4_put_open_state(state);
814 nfs4_put_state_owner(owner);
1f7977c1
TM		 815 } else
816 nfs4_do_close(state, gfp_mask, wait);
a49c3c77
TM		 817}
818
643168c2 819void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
a49c3c77 820{
da48f267 821 __nfs4_close(state, fmode, GFP_KERNEL, 0);
a49c3c77
TM		 822}
823
643168c2 824void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
a49c3c77 825{
643168c2 826 __nfs4_close(state, fmode, GFP_KERNEL, 1);
1da177e4
LT		 827}
828
829/*
830 * Search the state->lock_states for an existing lock_owner
3f8f2548
N		 831 * that is compatible with either of the given owners.
832 * If the second is non-zero, then the first refers to a Posix-lock
833 * owner (current->files) and the second refers to a flock/OFD
834 * owner (struct file*). In that case, prefer a match for the first
835 * owner.
836 * If both sorts of locks are held on the one file we cannot know
837 * which stateid was intended to be used, so a "correct" choice cannot
838 * be made. Failing that, a "consistent" choice is preferable. The
839 * consistent choice we make is to prefer the first owner, that of a
840 * Posix lock.
1da177e4
LT		 841 */
842static struct nfs4_lock_state *
8d424431 843__nfs4_find_lock_state(struct nfs4_state *state,
d7c9616b 844 fl_owner_t owner, fl_owner_t owner2)
1da177e4 845{
3f8f2548 846 struct nfs4_lock_state *pos, *ret = NULL;
1da177e4 847 list_for_each_entry(pos, &state->lock_states, ls_locks) {
d7c9616b 848 if (pos->ls_owner == owner) {
3f8f2548
N		 849 ret = pos;
850 break;
851 }
d7c9616b 852 if (pos->ls_owner == owner2)
3f8f2548 853 ret = pos;
1da177e4 854 }
3f8f2548 855 if (ret)
194bc1f4 856 refcount_inc(&ret->ls_count);
3f8f2548 857 return ret;
1da177e4
LT		 858}
859
1da177e4
LT		 860/*
861 * Return a compatible lock_state. If no initialized lock_state structure
862 * exists, return an uninitialized one.
863 *
1da177e4 864 */
d7c9616b 865static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t owner)
1da177e4
LT		 866{
867 struct nfs4_lock_state *lsp;
24d292b8 868 struct nfs_server *server = state->owner->so_server;
1da177e4 869
9c00fd9a 870 lsp = kzalloc(sizeof(*lsp), GFP_KERNEL_ACCOUNT);
1da177e4
LT		 871 if (lsp == NULL)
872 return NULL;
7ba127ab 873 nfs4_init_seqid_counter(&lsp->ls_seqid);
194bc1f4 874 refcount_set(&lsp->ls_count, 1);
b64aec8d 875 lsp->ls_state = state;
d7c9616b 876 lsp->ls_owner = owner;
d98f7227 877 lsp->ls_seqid.owner_id = atomic64_inc_return(&server->owner_ctr);
8d0a8a9d 878 INIT_LIST_HEAD(&lsp->ls_locks);
1da177e4
LT		 879 return lsp;
880}
881
5ae67c4f 882void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
9f958ab8 883{
7ba127ab 884 nfs4_destroy_seqid_counter(&lsp->ls_seqid);
9f958ab8
TM		 885 kfree(lsp);
886}
887
1da177e4
LT		 888/*
889 * Return a compatible lock_state. If no initialized lock_state structure
890 * exists, return an uninitialized one.
891 *
1da177e4 892 */
8003d3c4 893static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
1da177e4 894{
8d0a8a9d 895 struct nfs4_lock_state *lsp, *new = NULL;
1da177e4 896
8d0a8a9d
TM		 897 for(;;) {
898 spin_lock(&state->state_lock);
68e33bd6 899 lsp = __nfs4_find_lock_state(state, owner, NULL);
8d0a8a9d
TM		 900 if (lsp != NULL)
901 break;
902 if (new != NULL) {
8d0a8a9d
TM		 903 list_add(&new->ls_locks, &state->lock_states);
904 set_bit(LK_STATE_IN_USE, &state->flags);
905 lsp = new;
906 new = NULL;
907 break;
908 }
909 spin_unlock(&state->state_lock);
8003d3c4 910 new = nfs4_alloc_lock_state(state, owner);
8d0a8a9d
TM		 911 if (new == NULL)
912 return NULL;
913 }
914 spin_unlock(&state->state_lock);
9f958ab8 915 if (new != NULL)
5ae67c4f 916 nfs4_free_lock_state(state->owner->so_server, new);
1da177e4
LT		 917 return lsp;
918}
919
920/*
8d0a8a9d
TM		 921 * Release reference to lock_state, and free it if we see that
922 * it is no longer in use
1da177e4 923 */
faf5f49c 924void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
1da177e4 925{
c8b2d0bf 926 struct nfs_server *server;
8d0a8a9d 927 struct nfs4_state *state;
1da177e4 928
8d0a8a9d
TM		 929 if (lsp == NULL)
930 return;
931 state = lsp->ls_state;
194bc1f4 932 if (!refcount_dec_and_lock(&lsp->ls_count, &state->state_lock))
8d0a8a9d
TM		 933 return;
934 list_del(&lsp->ls_locks);
935 if (list_empty(&state->lock_states))
936 clear_bit(LK_STATE_IN_USE, &state->flags);
937 spin_unlock(&state->state_lock);
0c0e0d3c
JL		 938 server = state->owner->so_server;
939 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
940 struct nfs_client *clp = server->nfs_client;
941
942 clp->cl_mvops->free_lock_state(server, lsp);
943 } else
c8b2d0bf 944 nfs4_free_lock_state(server, lsp);
1da177e4
LT		 945}
946
8d0a8a9d 947static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
1da177e4 948{
8d0a8a9d 949 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
1da177e4 950
8d0a8a9d 951 dst->fl_u.nfs4_fl.owner = lsp;
194bc1f4 952 refcount_inc(&lsp->ls_count);
8d0a8a9d 953}
1da177e4 954
8d0a8a9d 955static void nfs4_fl_release_lock(struct file_lock *fl)
1da177e4 956{
8d0a8a9d 957 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
1da177e4
LT		 958}
959
6aed6285 960static const struct file_lock_operations nfs4_fl_lock_ops = {
8d0a8a9d
TM		 961 .fl_copy_lock = nfs4_fl_copy_lock,
962 .fl_release_private = nfs4_fl_release_lock,
963};
964
965int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
1da177e4 966{
8d0a8a9d
TM		 967 struct nfs4_lock_state *lsp;
968
969 if (fl->fl_ops != NULL)
970 return 0;
dd1fac6a 971 lsp = nfs4_get_lock_state(state, fl->c.flc_owner);
8d0a8a9d
TM		 972 if (lsp == NULL)
973 return -ENOMEM;
974 fl->fl_u.nfs4_fl.owner = lsp;
975 fl->fl_ops = &nfs4_fl_lock_ops;
976 return 0;
1da177e4
LT		 977}
978
5521abfd
TM		 979static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
980 struct nfs4_state *state,
17393475 981 const struct nfs_lock_context *l_ctx)
1da177e4 982{
8d0a8a9d 983 struct nfs4_lock_state *lsp;
d7c9616b 984 fl_owner_t owner, fl_flock_owner;
5521abfd 985 int ret = -ENOENT;
1da177e4 986
17393475 987 if (l_ctx == NULL)
2a369153
TM		 988 goto out;
989
8d0a8a9d 990 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
4fc8796d 991 goto out;
1da177e4 992
d7c9616b 993 owner = l_ctx->lockowner;
8d424431
N		 994 fl_flock_owner = l_ctx->open_context->flock_owner;
995
8d0a8a9d 996 spin_lock(&state->state_lock);
d7c9616b 997 lsp = __nfs4_find_lock_state(state, owner, fl_flock_owner);
ef1820f9
N		 998 if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
999 ret = -EIO;
1000 else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
f597c537 1001 nfs4_stateid_copy(dst, &lsp->ls_stateid);
5521abfd 1002 ret = 0;
4fc8796d 1003 }
8d0a8a9d 1004 spin_unlock(&state->state_lock);
1da177e4 1005 nfs4_put_lock_state(lsp);
4fc8796d
TM		 1006out:
1007 return ret;
1008}
1009
c82bac6f 1010bool nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
4fc8796d 1011{
c82bac6f 1012 bool ret;
92b40e93 1013 const nfs4_stateid *src;
4fc8796d
TM		 1014 int seq;
1015
1016 do {
c82bac6f 1017 ret = false;
92b40e93 1018 src = &zero_stateid;
4fc8796d 1019 seq = read_seqbegin(&state->seqlock);
c82bac6f 1020 if (test_bit(NFS_OPEN_STATE, &state->flags)) {
92b40e93 1021 src = &state->open_stateid;
c82bac6f
TM		 1022 ret = true;
1023 }
92b40e93 1024 nfs4_stateid_copy(dst, src);
4fc8796d 1025 } while (read_seqretry(&state->seqlock, seq));
c82bac6f 1026 return ret;
4fc8796d
TM		 1027}
1028
1029/*
1030 * Byte-range lock aware utility to initialize the stateid of read/write
1031 * requests.
1032 */
abf4e13c 1033int nfs4_select_rw_stateid(struct nfs4_state *state,
17393475 1034 fmode_t fmode, const struct nfs_lock_context *l_ctx,
a52458b4 1035 nfs4_stateid *dst, const struct cred **cred)
4fc8796d 1036{
abf4e13c
TM		 1037 int ret;
1038
7ebeb7fe
TM		 1039 if (!nfs4_valid_open_stateid(state))
1040 return -EIO;
abf4e13c
TM		 1041 if (cred != NULL)
1042 *cred = NULL;
17393475 1043 ret = nfs4_copy_lock_stateid(dst, state, l_ctx);
ef1820f9
N		 1044 if (ret == -EIO)
1045 /* A lost lock - don't even consider delegations */
1046 goto out;
146d70ca 1047 /* returns true if delegation stateid found and copied */
abf4e13c 1048 if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) {
146d70ca 1049 ret = 0;
5521abfd 1050 goto out;
146d70ca 1051 }
5521abfd 1052 if (ret != -ENOENT)
ef1820f9
N		 1053 /* nfs4_copy_delegation_stateid() didn't over-write
1054 * dst, so it still has the lock stateid which we now
1055 * choose to use.
1056 */
5521abfd 1057 goto out;
d9aba2b4 1058 ret = nfs4_copy_open_stateid(dst, state) ? 0 : -EAGAIN;
5521abfd 1059out:
3b66486c
TM		 1060 if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1061 dst->seqid = 0;
5521abfd 1062 return ret;
1da177e4
LT		 1063}
1064
8535b2be 1065struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
cee54fc9 1066{
cee54fc9
TM		 1067 struct nfs_seqid *new;
1068
8535b2be 1069 new = kmalloc(sizeof(*new), gfp_mask);
badc76dd
TM		 1070 if (new == NULL)
1071 return ERR_PTR(-ENOMEM);
1072 new->sequence = counter;
1073 INIT_LIST_HEAD(&new->list);
1074 new->task = NULL;
cee54fc9
TM		 1075 return new;
1076}
1077
72211dbe 1078void nfs_release_seqid(struct nfs_seqid *seqid)
1da177e4 1079{
4601df20 1080 struct nfs_seqid_counter *sequence;
cee54fc9 1081
a6796419 1082 if (seqid == NULL || list_empty(&seqid->list))
4601df20
TM		 1083 return;
1084 sequence = seqid->sequence;
1085 spin_lock(&sequence->lock);
1086 list_del_init(&seqid->list);
1087 if (!list_empty(&sequence->list)) {
1088 struct nfs_seqid *next;
1089
1090 next = list_first_entry(&sequence->list,
1091 struct nfs_seqid, list);
1092 rpc_wake_up_queued_task(&sequence->wait, next->task);
2f74c0a0 1093 }
4601df20 1094 spin_unlock(&sequence->lock);
72211dbe
TM		 1095}
1096
1097void nfs_free_seqid(struct nfs_seqid *seqid)
1098{
1099 nfs_release_seqid(seqid);
cee54fc9 1100 kfree(seqid);
1da177e4
LT		 1101}
1102
1103/*
cee54fc9
TM		 1104 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
1105 * failed with a seqid incrementing error -
16a6ddc7 1106 * see comments nfs4.h:seqid_mutating_error()
cee54fc9 1107 */
88d90939 1108static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
cee54fc9
TM		 1109{
1110 switch (status) {
1111 case 0:
1112 break;
1113 case -NFS4ERR_BAD_SEQID:
6f43ddcc
TM		 1114 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1115 return;
9a3ba432 1116 pr_warn_ratelimited("NFS: v4 server returned a bad"
497799e7
DM		 1117 " sequence-id error on an"
1118 " unconfirmed sequence %p!\n",
6f43ddcc 1119 seqid->sequence);
ffb81717 1120 return;
cee54fc9
TM		 1121 case -NFS4ERR_STALE_CLIENTID:
1122 case -NFS4ERR_STALE_STATEID:
1123 case -NFS4ERR_BAD_STATEID:
1124 case -NFS4ERR_BADXDR:
1125 case -NFS4ERR_RESOURCE:
1126 case -NFS4ERR_NOFILEHANDLE:
406dab84 1127 case -NFS4ERR_MOVED:
cee54fc9
TM		 1128 /* Non-seqid mutating errors */
1129 return;
8b98a532 1130 }
cee54fc9
TM		 1131 /*
1132 * Note: no locking needed as we are guaranteed to be first
1133 * on the sequence list
1134 */
1135 seqid->sequence->counter++;
1136}
1137
1138void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1139{
a6796419
TM		 1140 struct nfs4_state_owner *sp;
1141
1142 if (seqid == NULL)
1143 return;
34dc1ad7 1144
a6796419 1145 sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
34dc1ad7 1146 if (status == -NFS4ERR_BAD_SEQID)
86cfb041 1147 nfs4_reset_state_owner(sp);
a6796419 1148 if (!nfs4_has_session(sp->so_server->nfs_client))
34dc1ad7 1149 nfs_increment_seqid(status, seqid);
cee54fc9
TM		 1150}
1151
1152/*
cee54fc9
TM		 1153 * Increment the seqid if the LOCK/LOCKU succeeded, or
1154 * failed with a seqid incrementing error -
16a6ddc7 1155 * see comments nfs4.h:seqid_mutating_error()
cee54fc9
TM		 1156 */
1157void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1158{
a6796419
TM		 1159 if (seqid != NULL)
1160 nfs_increment_seqid(status, seqid);
cee54fc9
TM		 1161}
1162
1163int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1164{
a6796419 1165 struct nfs_seqid_counter *sequence;
cee54fc9
TM		 1166 int status = 0;
1167
a6796419
TM		 1168 if (seqid == NULL)
1169 goto out;
1170 sequence = seqid->sequence;
cee54fc9 1171 spin_lock(&sequence->lock);
4601df20 1172 seqid->task = task;
2f74c0a0
TM		 1173 if (list_empty(&seqid->list))
1174 list_add_tail(&seqid->list, &sequence->list);
1175 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1176 goto unlock;
5d00837b 1177 rpc_sleep_on(&sequence->wait, task, NULL);
2f74c0a0
TM		 1178 status = -EAGAIN;
1179unlock:
cee54fc9 1180 spin_unlock(&sequence->lock);
a6796419 1181out:
cee54fc9 1182 return status;
1da177e4
LT		 1183}
1184
e005e804 1185static int nfs4_run_state_manager(void *);
1da177e4 1186
e005e804 1187static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
433fbe4c 1188{
43d20e80 1189 clear_and_wake_up_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
433fbe4c
TM		 1190 rpc_wake_up(&clp->cl_rpcwaitq);
1191}
1192
1da177e4 1193/*
e005e804 1194 * Schedule the nfs_client asynchronous state management routine
1da177e4 1195 */
b0d3ded1 1196void nfs4_schedule_state_manager(struct nfs_client *clp)
1da177e4 1197{
5043e900 1198 struct task_struct *task;
2446ab60 1199 char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
956fd46f
TM		 1200 struct rpc_clnt *clnt = clp->cl_rpcclient;
1201 bool swapon = false;
1da177e4 1202
956fd46f 1203 if (clnt->cl_shutdown)
6ad477a6
BC		 1204 return;
1205
aeabb3c9 1206 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
956fd46f
TM		 1207
1208 if (atomic_read(&clnt->cl_swapper)) {
1209 swapon = !test_and_set_bit(NFS4CLNT_MANAGER_AVAILABLE,
1210 &clp->cl_state);
1211 if (!swapon) {
1212 wake_up_var(&clp->cl_state);
1213 return;
1214 }
4dc73c67 1215 }
956fd46f
TM		 1216
1217 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1218 return;
1219
5043e900 1220 __module_get(THIS_MODULE);
212bf41d 1221 refcount_inc(&clp->cl_count);
2446ab60
TM		 1222
1223 /* The rcu_read_lock() is not strictly necessary, as the state
1224 * manager is the only thread that ever changes the rpc_xprt
1225 * after it's initialized. At this point, we're single threaded. */
1226 rcu_read_lock();
1227 snprintf(buf, sizeof(buf), "%s-manager",
1228 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1229 rcu_read_unlock();
f170168b 1230 task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
2446ab60
TM		 1231 if (IS_ERR(task)) {
1232 printk(KERN_ERR "%s: kthread_run: %ld\n",
1233 __func__, PTR_ERR(task));
b4e4f669
TM		 1234 if (!nfs_client_init_is_complete(clp))
1235 nfs_mark_client_ready(clp, PTR_ERR(task));
956fd46f
TM		 1236 if (swapon)
1237 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
2446ab60
TM		 1238 nfs4_clear_state_manager_bit(clp);
1239 nfs_put_client(clp);
1240 module_put(THIS_MODULE);
1241 }
1da177e4
LT		 1242}
1243
1244/*
0400a6b0 1245 * Schedule a lease recovery attempt
1da177e4 1246 */
0400a6b0 1247void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1da177e4
LT		 1248{
1249 if (!clp)
1250 return;
e598d843
TM		 1251 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1252 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
cc0a9843
TM		 1253 dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1254 clp->cl_hostname);
e005e804 1255 nfs4_schedule_state_manager(clp);
1da177e4 1256}
9cb81968 1257EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1da177e4 1258
c9fdeb28
CL		 1259/**
1260 * nfs4_schedule_migration_recovery - trigger migration recovery
1261 *
1262 * @server: FSID that is migrating
1263 *
1264 * Returns zero if recovery has started, otherwise a negative NFS4ERR
1265 * value is returned.
1266 */
1267int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1268{
1269 struct nfs_client *clp = server->nfs_client;
1270
1271 if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1272 pr_err("NFS: volatile file handles not supported (server %s)\n",
1273 clp->cl_hostname);
1274 return -NFS4ERR_IO;
1275 }
1276
1277 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1278 return -NFS4ERR_IO;
1279
1280 dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1281 __func__,
1282 (unsigned long long)server->fsid.major,
1283 (unsigned long long)server->fsid.minor,
1284 clp->cl_hostname);
1285
1286 set_bit(NFS_MIG_IN_TRANSITION,
1287 &((struct nfs_server *)server)->mig_status);
1288 set_bit(NFS4CLNT_MOVED, &clp->cl_state);
1289
1290 nfs4_schedule_state_manager(clp);
1291 return 0;
1292}
1293EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1294
b7f7a66e
CL		 1295/**
1296 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1297 *
1298 * @clp: server to check for moved leases
1299 *
1300 */
1301void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1302{
1303 dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1304 __func__, clp->cl_clientid, clp->cl_hostname);
1305
1306 set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
1307 nfs4_schedule_state_manager(clp);
1308}
1309EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1310
33021279
TM		 1311int nfs4_wait_clnt_recover(struct nfs_client *clp)
1312{
1313 int res;
1314
1315 might_sleep();
1316
212bf41d 1317 refcount_inc(&clp->cl_count);
74316201 1318 res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
f5d39b02
PZ		 1319 nfs_wait_bit_killable,
1320 TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
33021279 1321 if (res)
0625c2dd 1322 goto out;
33021279 1323 if (clp->cl_cons_state < 0)
0625c2dd
CL		 1324 res = clp->cl_cons_state;
1325out:
1326 nfs_put_client(clp);
1327 return res;
33021279
TM		 1328}
1329
1330int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1331{
1332 unsigned int loop;
1333 int ret;
1334
1335 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1336 ret = nfs4_wait_clnt_recover(clp);
1337 if (ret != 0)
1338 break;
1339 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1340 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1341 break;
1342 nfs4_schedule_state_manager(clp);
1343 ret = -EIO;
1344 }
1345 return ret;
1346}
1347
ad1e3968
TM		 1348/*
1349 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1350 * @clp: client to process
1351 *
1352 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1353 * resend of the SETCLIENTID and hence re-establish the
1354 * callback channel. Then return all existing delegations.
1355 */
1356static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1357{
1358 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1359 nfs_expire_all_delegations(clp);
cc0a9843
TM		 1360 dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1361 clp->cl_hostname);
ad1e3968
TM		 1362}
1363
042b60be
TM		 1364void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1365{
ad1e3968 1366 nfs40_handle_cb_pathdown(clp);
042b60be
TM		 1367 nfs4_schedule_state_manager(clp);
1368}
1369
f9feab1e 1370static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
b79a4a1b
TM		 1371{
1372
7ebeb7fe
TM		 1373 if (!nfs4_valid_open_stateid(state))
1374 return 0;
b79a4a1b
TM		 1375 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1376 /* Don't recover state that expired before the reboot */
1377 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1378 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1379 return 0;
1380 }
7eff03ae 1381 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
b79a4a1b
TM		 1382 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1383 return 1;
1384}
1385
4f14c194 1386int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
b79a4a1b 1387{
7ebeb7fe
TM		 1388 if (!nfs4_valid_open_stateid(state))
1389 return 0;
b79a4a1b
TM		 1390 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1391 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
7eff03ae 1392 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
b79a4a1b
TM		 1393 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1394 return 1;
1395}
1396
5d422301 1397int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
0400a6b0
TM		 1398{
1399 struct nfs_client *clp = server->nfs_client;
1400
7ebeb7fe 1401 if (!nfs4_state_mark_reclaim_nograce(clp, state))
5d422301 1402 return -EBADF;
994b15b9
TM		 1403 nfs_inode_find_delegation_state_and_recover(state->inode,
1404 &state->stateid);
cc0a9843
TM		 1405 dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1406 clp->cl_hostname);
0400a6b0 1407 nfs4_schedule_state_manager(clp);
5d422301 1408 return 0;
0400a6b0 1409}
9cb81968 1410EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
0400a6b0 1411
6c2d8f8d
TM		 1412static struct nfs4_lock_state *
1413nfs_state_find_lock_state_by_stateid(struct nfs4_state *state,
1414 const nfs4_stateid *stateid)
1415{
1416 struct nfs4_lock_state *pos;
1417
1418 list_for_each_entry(pos, &state->lock_states, ls_locks) {
1419 if (!test_bit(NFS_LOCK_INITIALIZED, &pos->ls_flags))
1420 continue;
42c304c3 1421 if (nfs4_stateid_match_or_older(&pos->ls_stateid, stateid))
6c2d8f8d
TM		 1422 return pos;
1423 }
1424 return NULL;
1425}
1426
1427static bool nfs_state_lock_state_matches_stateid(struct nfs4_state *state,
1428 const nfs4_stateid *stateid)
1429{
1430 bool found = false;
1431
1432 if (test_bit(LK_STATE_IN_USE, &state->flags)) {
1433 spin_lock(&state->state_lock);
1434 if (nfs_state_find_lock_state_by_stateid(state, stateid))
1435 found = true;
1436 spin_unlock(&state->state_lock);
1437 }
1438 return found;
1439}
1440
a1d0b5ee
TM		 1441void nfs_inode_find_state_and_recover(struct inode *inode,
1442 const nfs4_stateid *stateid)
1443{
1444 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1445 struct nfs_inode *nfsi = NFS_I(inode);
1446 struct nfs_open_context *ctx;
1447 struct nfs4_state *state;
1448 bool found = false;
1449
0de43976
TM		 1450 rcu_read_lock();
1451 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
a1d0b5ee
TM		 1452 state = ctx->state;
1453 if (state == NULL)
1454 continue;
42c304c3 1455 if (nfs4_stateid_match_or_older(&state->stateid, stateid) &&
7ebeb7fe 1456 nfs4_state_mark_reclaim_nograce(clp, state)) {
6c2d8f8d 1457 found = true;
a1d0b5ee 1458 continue;
6c2d8f8d 1459 }
42c304c3
TM		 1460 if (test_bit(NFS_OPEN_STATE, &state->flags) &&
1461 nfs4_stateid_match_or_older(&state->open_stateid, stateid) &&
46280d9d
TM		 1462 nfs4_state_mark_reclaim_nograce(clp, state)) {
1463 found = true;
1464 continue;
1465 }
7ebeb7fe
TM		 1466 if (nfs_state_lock_state_matches_stateid(state, stateid) &&
1467 nfs4_state_mark_reclaim_nograce(clp, state))
6c2d8f8d 1468 found = true;
a1d0b5ee 1469 }
0de43976 1470 rcu_read_unlock();
6c2d8f8d
TM		 1471
1472 nfs_inode_find_delegation_state_and_recover(inode, stateid);
a1d0b5ee
TM		 1473 if (found)
1474 nfs4_schedule_state_manager(clp);
1475}
1476
86dbd08b 1477static void nfs4_state_mark_open_context_bad(struct nfs4_state *state, int err)
c58c8441
TM		 1478{
1479 struct inode *inode = state->inode;
1480 struct nfs_inode *nfsi = NFS_I(inode);
1481 struct nfs_open_context *ctx;
1482
0de43976
TM		 1483 rcu_read_lock();
1484 list_for_each_entry_rcu(ctx, &nfsi->open_files, list) {
c58c8441
TM		 1485 if (ctx->state != state)
1486 continue;
1487 set_bit(NFS_CONTEXT_BAD, &ctx->flags);
86dbd08b
TM		 1488 pr_warn("NFSv4: state recovery failed for open file %pd2, "
1489 "error = %d\n", ctx->dentry, err);
c58c8441 1490 }
0de43976 1491 rcu_read_unlock();
c58c8441
TM		 1492}
1493
5d422301
TM		 1494static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1495{
1496 set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
86dbd08b 1497 nfs4_state_mark_open_context_bad(state, error);
5d422301
TM		 1498}
1499
a1d0b5ee 1500
02860014 1501static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1da177e4
LT		 1502{
1503 struct inode *inode = state->inode;
19e03c57 1504 struct nfs_inode *nfsi = NFS_I(inode);
1da177e4 1505 struct file_lock *fl;
dce2630c 1506 struct nfs4_lock_state *lsp;
1da177e4 1507 int status = 0;
17b985de 1508 struct file_lock_context *flctx = locks_inode_context(inode);
bd61e0a9 1509 struct list_head *list;
1da177e4 1510
bd61e0a9 1511 if (flctx == NULL)
3f09df70
TM		 1512 return 0;
1513
bd61e0a9
JL		 1514 list = &flctx->flc_posix;
1515
3f09df70 1516 /* Guard against delegation returns and new lock/unlock calls */
19e03c57 1517 down_write(&nfsi->rwsem);
6109c850 1518 spin_lock(&flctx->flc_lock);
bd61e0a9 1519restart:
d7c9616b 1520 for_each_file_lock(fl, list) {
dd1fac6a 1521 if (nfs_file_open_context(fl->c.flc_file)->state != state)
5263e31e 1522 continue;
6109c850 1523 spin_unlock(&flctx->flc_lock);
5263e31e
JL		 1524 status = ops->recover_lock(state, fl);
1525 switch (status) {
1526 case 0:
1527 break;
67e7b52d 1528 case -ETIMEDOUT:
5263e31e
JL		 1529 case -ESTALE:
1530 case -NFS4ERR_ADMIN_REVOKED:
1531 case -NFS4ERR_STALE_STATEID:
1532 case -NFS4ERR_BAD_STATEID:
1533 case -NFS4ERR_EXPIRED:
1534 case -NFS4ERR_NO_GRACE:
1535 case -NFS4ERR_STALE_CLIENTID:
1536 case -NFS4ERR_BADSESSION:
1537 case -NFS4ERR_BADSLOT:
1538 case -NFS4ERR_BAD_HIGH_SLOT:
1539 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1540 goto out;
1541 default:
1542 pr_err("NFS: %s: unhandled error %d\n",
1543 __func__, status);
df561f66 1544 fallthrough;
5263e31e
JL		 1545 case -ENOMEM:
1546 case -NFS4ERR_DENIED:
1547 case -NFS4ERR_RECLAIM_BAD:
1548 case -NFS4ERR_RECLAIM_CONFLICT:
dce2630c
N		 1549 lsp = fl->fl_u.nfs4_fl.owner;
1550 if (lsp)
1551 set_bit(NFS_LOCK_LOST, &lsp->ls_flags);
5263e31e
JL		 1552 status = 0;
1553 }
6109c850 1554 spin_lock(&flctx->flc_lock);
5263e31e 1555 }
bd61e0a9
JL		 1556 if (list == &flctx->flc_posix) {
1557 list = &flctx->flc_flock;
1558 goto restart;
1559 }
6109c850 1560 spin_unlock(&flctx->flc_lock);
965b5d67 1561out:
19e03c57 1562 up_write(&nfsi->rwsem);
1da177e4
LT		 1563 return status;
1564}
1565
80f42368
AS		 1566#ifdef CONFIG_NFS_V4_2
1567static void nfs42_complete_copies(struct nfs4_state_owner *sp, struct nfs4_state *state)
1568{
1569 struct nfs4_copy_state *copy;
1570
0e65a32c
OK		 1571 if (!test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1572 !test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags))
80f42368
AS		 1573 return;
1574
1575 spin_lock(&sp->so_server->nfs_client->cl_lock);
1576 list_for_each_entry(copy, &sp->so_server->ss_copies, copies) {
0e65a32c
OK		 1577 if ((test_bit(NFS_CLNT_DST_SSC_COPY_STATE, &state->flags) &&
1578 !nfs4_stateid_match_other(&state->stateid,
1579 &copy->parent_dst_state->stateid)))
1580 continue;
80f42368 1581 copy->flags = 1;
0e65a32c
OK		 1582 if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
1583 &state->flags)) {
1584 clear_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags);
1585 complete(&copy->completion);
1586 }
1587 }
a848c29e 1588 list_for_each_entry(copy, &sp->so_server->ss_src_copies, src_copies) {
0e65a32c
OK		 1589 if ((test_bit(NFS_CLNT_SRC_SSC_COPY_STATE, &state->flags) &&
1590 !nfs4_stateid_match_other(&state->stateid,
1591 &copy->parent_src_state->stateid)))
1592 continue;
1593 copy->flags = 1;
1594 if (test_and_clear_bit(NFS_CLNT_DST_SSC_COPY_STATE,
1595 &state->flags))
1596 complete(&copy->completion);
80f42368
AS		 1597 }
1598 spin_unlock(&sp->so_server->nfs_client->cl_lock);
1599}
1600#else /* !CONFIG_NFS_V4_2 */
1601static inline void nfs42_complete_copies(struct nfs4_state_owner *sp,
1602 struct nfs4_state *state)
1603{
1604}
1605#endif /* CONFIG_NFS_V4_2 */
1606
cb7a8384 1607static int __nfs4_reclaim_open_state(struct nfs4_state_owner *sp, struct nfs4_state *state,
3e2910c7
N		 1608 const struct nfs4_state_recovery_ops *ops,
1609 int *lost_locks)
cb7a8384
AS		 1610{
1611 struct nfs4_lock_state *lock;
1612 int status;
1613
1614 status = ops->recover_open(sp, state);
1615 if (status < 0)
1616 return status;
1617
1618 status = nfs4_reclaim_locks(state, ops);
1619 if (status < 0)
1620 return status;
1621
1622 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1623 spin_lock(&state->state_lock);
1624 list_for_each_entry(lock, &state->lock_states, ls_locks) {
21f86d2d 1625 trace_nfs4_state_lock_reclaim(state, lock);
ef8d98f2
N		 1626 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags) &&
1627 !test_bit(NFS_LOCK_UNLOCKING, &lock->ls_flags))
3e2910c7 1628 *lost_locks += 1;
cb7a8384
AS		 1629 }
1630 spin_unlock(&state->state_lock);
1631 }
1632
80f42368 1633 nfs42_complete_copies(sp, state);
cb7a8384
AS		 1634 clear_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1635 return status;
1636}
1637
3e2910c7
N		 1638static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp,
1639 const struct nfs4_state_recovery_ops *ops,
1640 int *lost_locks)
1da177e4
LT		 1641{
1642 struct nfs4_state *state;
c34fae00 1643 unsigned int loop = 0;
1da177e4 1644 int status = 0;
0b9018b9
OK		 1645#ifdef CONFIG_NFS_V4_2
1646 bool found_ssc_copy_state = false;
1647#endif /* CONFIG_NFS_V4_2 */
1da177e4
LT		 1648
1649 /* Note: we rely on the sp->so_states list being ordered
1650 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1651 * states first.
1652 * This is needed to ensure that the server won't give us any
1653 * read delegations that we have to return if, say, we are
1654 * recovering after a network partition or a reboot from a
1655 * server that doesn't support a grace period.
1656 */
fe1d8195 1657 spin_lock(&sp->so_lock);
c137afab 1658restart:
1da177e4 1659 list_for_each_entry(state, &sp->so_states, open_states) {
b79a4a1b
TM		 1660 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1661 continue;
5d422301
TM		 1662 if (!nfs4_valid_open_stateid(state))
1663 continue;
1da177e4
LT		 1664 if (state->state == 0)
1665 continue;
0b9018b9
OK		 1666#ifdef CONFIG_NFS_V4_2
1667 if (test_bit(NFS_SRV_SSC_COPY_STATE, &state->flags)) {
1668 nfs4_state_mark_recovery_failed(state, -EIO);
1669 found_ssc_copy_state = true;
1670 continue;
1671 }
1672#endif /* CONFIG_NFS_V4_2 */
ace9fad4 1673 refcount_inc(&state->count);
fe1d8195 1674 spin_unlock(&sp->so_lock);
3e2910c7 1675 status = __nfs4_reclaim_open_state(sp, state, ops, lost_locks);
cb7a8384 1676
1da177e4 1677 switch (status) {
35a61606 1678 default:
c34fae00
TM		 1679 if (status >= 0) {
1680 loop = 0;
b79a4a1b 1681 break;
c34fae00 1682 }
35a61606 1683 printk(KERN_ERR "NFS: %s: unhandled error %d\n", __func__, status);
df561f66 1684 fallthrough;
35a61606
AS		 1685 case -ENOENT:
1686 case -ENOMEM:
1687 case -EACCES:
1688 case -EROFS:
1689 case -EIO:
1690 case -ESTALE:
1691 /* Open state on this file cannot be recovered */
1692 nfs4_state_mark_recovery_failed(state, status);
1693 break;
1694 case -EAGAIN:
1695 ssleep(1);
c34fae00
TM		 1696 if (loop++ < 10) {
1697 set_bit(ops->state_flag_bit, &state->flags);
1698 break;
1699 }
df561f66 1700 fallthrough;
35a61606
AS		 1701 case -NFS4ERR_ADMIN_REVOKED:
1702 case -NFS4ERR_STALE_STATEID:
1703 case -NFS4ERR_OLD_STATEID:
1704 case -NFS4ERR_BAD_STATEID:
1705 case -NFS4ERR_RECLAIM_BAD:
1706 case -NFS4ERR_RECLAIM_CONFLICT:
1707 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1708 break;
1709 case -NFS4ERR_EXPIRED:
1710 case -NFS4ERR_NO_GRACE:
1711 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
df561f66 1712 fallthrough;
35a61606
AS		 1713 case -NFS4ERR_STALE_CLIENTID:
1714 case -NFS4ERR_BADSESSION:
1715 case -NFS4ERR_BADSLOT:
1716 case -NFS4ERR_BAD_HIGH_SLOT:
1717 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
67e7b52d 1718 case -ETIMEDOUT:
35a61606 1719 goto out_err;
1da177e4 1720 }
fe1d8195 1721 nfs4_put_open_state(state);
c137afab 1722 spin_lock(&sp->so_lock);
fe1d8195 1723 goto restart;
1da177e4 1724 }
fe1d8195 1725 spin_unlock(&sp->so_lock);
0b9018b9
OK		 1726#ifdef CONFIG_NFS_V4_2
1727 if (found_ssc_copy_state)
1728 return -EIO;
1729#endif /* CONFIG_NFS_V4_2 */
1da177e4
LT		 1730 return 0;
1731out_err:
fe1d8195 1732 nfs4_put_open_state(state);
c137afab 1733 spin_lock(&sp->so_lock);
c137afab 1734 spin_unlock(&sp->so_lock);
1da177e4
LT		 1735 return status;
1736}
1737
b79a4a1b
TM		 1738static void nfs4_clear_open_state(struct nfs4_state *state)
1739{
1740 struct nfs4_lock_state *lock;
1741
1742 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1743 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1744 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1745 clear_bit(NFS_O_RDWR_STATE, &state->flags);
4b44b40e 1746 spin_lock(&state->state_lock);
b79a4a1b 1747 list_for_each_entry(lock, &state->lock_states, ls_locks) {
b79a4a1b 1748 lock->ls_seqid.flags = 0;
795a88c9 1749 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
b79a4a1b 1750 }
4b44b40e 1751 spin_unlock(&state->state_lock);
b79a4a1b
TM		 1752}
1753
24d292b8
CL		 1754static void nfs4_reset_seqids(struct nfs_server *server,
1755 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
cee54fc9 1756{
24d292b8 1757 struct nfs_client *clp = server->nfs_client;
cee54fc9 1758 struct nfs4_state_owner *sp;
9f958ab8 1759 struct rb_node *pos;
cee54fc9 1760 struct nfs4_state *state;
cee54fc9 1761
24d292b8
CL		 1762 spin_lock(&clp->cl_lock);
1763 for (pos = rb_first(&server->state_owners);
1764 pos != NULL;
1765 pos = rb_next(pos)) {
1766 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
cee54fc9 1767 sp->so_seqid.flags = 0;
ec073428 1768 spin_lock(&sp->so_lock);
cee54fc9 1769 list_for_each_entry(state, &sp->so_states, open_states) {
b79a4a1b
TM		 1770 if (mark_reclaim(clp, state))
1771 nfs4_clear_open_state(state);
cee54fc9 1772 }
ec073428 1773 spin_unlock(&sp->so_lock);
cee54fc9 1774 }
24d292b8
CL		 1775 spin_unlock(&clp->cl_lock);
1776}
1777
1778static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1779 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1780{
1781 struct nfs_server *server;
1782
1783 rcu_read_lock();
1784 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1785 nfs4_reset_seqids(server, mark_reclaim);
1786 rcu_read_unlock();
cee54fc9
TM		 1787}
1788
b79a4a1b
TM		 1789static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1790{
e59679f2 1791 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
b79a4a1b
TM		 1792 /* Mark all delegations for reclaim */
1793 nfs_delegation_mark_reclaim(clp);
1794 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1795}
1796
0048fdd0 1797static int nfs4_reclaim_complete(struct nfs_client *clp,
965e9c23 1798 const struct nfs4_state_recovery_ops *ops,
a52458b4 1799 const struct cred *cred)
fce5c838
RL		 1800{
1801 /* Notify the server we're done reclaiming our state */
1802 if (ops->reclaim_complete)
0048fdd0
TM		 1803 return ops->reclaim_complete(clp, cred);
1804 return 0;
fce5c838
RL		 1805}
1806
24d292b8 1807static void nfs4_clear_reclaim_server(struct nfs_server *server)
b79a4a1b 1808{
24d292b8 1809 struct nfs_client *clp = server->nfs_client;
b79a4a1b
TM		 1810 struct nfs4_state_owner *sp;
1811 struct rb_node *pos;
1812 struct nfs4_state *state;
1813
24d292b8
CL		 1814 spin_lock(&clp->cl_lock);
1815 for (pos = rb_first(&server->state_owners);
1816 pos != NULL;
1817 pos = rb_next(pos)) {
1818 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
b79a4a1b
TM		 1819 spin_lock(&sp->so_lock);
1820 list_for_each_entry(state, &sp->so_states, open_states) {
24d292b8
CL		 1821 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1822 &state->flags))
b79a4a1b
TM		 1823 continue;
1824 nfs4_state_mark_reclaim_nograce(clp, state);
1825 }
1826 spin_unlock(&sp->so_lock);
1827 }
24d292b8
CL		 1828 spin_unlock(&clp->cl_lock);
1829}
1830
1831static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1832{
1833 struct nfs_server *server;
1834
1835 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1836 return 0;
1837
1838 rcu_read_lock();
1839 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1840 nfs4_clear_reclaim_server(server);
1841 rcu_read_unlock();
b79a4a1b
TM		 1842
1843 nfs_delegation_reap_unclaimed(clp);
6eaa6149
TM		 1844 return 1;
1845}
1846
1847static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1848{
965e9c23 1849 const struct nfs4_state_recovery_ops *ops;
a52458b4 1850 const struct cred *cred;
0048fdd0 1851 int err;
965e9c23 1852
6eaa6149
TM		 1853 if (!nfs4_state_clear_reclaim_reboot(clp))
1854 return;
5468fc82 1855 pnfs_destroy_all_layouts(clp);
965e9c23 1856 ops = clp->cl_mvops->reboot_recovery_ops;
73d8bde5 1857 cred = nfs4_get_clid_cred(clp);
0048fdd0 1858 err = nfs4_reclaim_complete(clp, ops, cred);
a52458b4 1859 put_cred(cred);
0048fdd0
TM		 1860 if (err == -NFS4ERR_CONN_NOT_BOUND_TO_SESSION)
1861 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
b79a4a1b
TM		 1862}
1863
b79a4a1b
TM		 1864static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1865{
45870d69 1866 nfs_mark_test_expired_all_delegations(clp);
b79a4a1b
TM		 1867 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1868}
1869
4f7cdf18 1870static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
e598d843
TM		 1871{
1872 switch (error) {
000d3f95
AS		 1873 case 0:
1874 break;
1875 case -NFS4ERR_CB_PATH_DOWN:
1876 nfs40_handle_cb_pathdown(clp);
1877 break;
1878 case -NFS4ERR_NO_GRACE:
1879 nfs4_state_end_reclaim_reboot(clp);
1880 break;
1881 case -NFS4ERR_STALE_CLIENTID:
1882 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1883 nfs4_state_start_reclaim_reboot(clp);
1884 break;
1885 case -NFS4ERR_EXPIRED:
1886 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1887 nfs4_state_start_reclaim_nograce(clp);
1888 break;
1889 case -NFS4ERR_BADSESSION:
1890 case -NFS4ERR_BADSLOT:
1891 case -NFS4ERR_BAD_HIGH_SLOT:
1892 case -NFS4ERR_DEADSESSION:
1893 case -NFS4ERR_SEQ_FALSE_RETRY:
1894 case -NFS4ERR_SEQ_MISORDERED:
1895 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1896 /* Zero session reset errors */
1897 break;
1898 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1899 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1900 break;
1901 default:
1902 dprintk("%s: failed to handle error %d for server %s\n",
1903 __func__, error, clp->cl_hostname);
1904 return error;
e598d843 1905 }
cc0a9843
TM		 1906 dprintk("%s: handled error %d for server %s\n", __func__, error,
1907 clp->cl_hostname);
4f38e4aa 1908 return 0;
e598d843
TM		 1909}
1910
02860014 1911static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1da177e4 1912{
24d292b8
CL		 1913 struct nfs4_state_owner *sp;
1914 struct nfs_server *server;
9f958ab8 1915 struct rb_node *pos;
c77e2283 1916 LIST_HEAD(freeme);
3e2910c7 1917 int lost_locks = 0;
04602539 1918 int status;
1da177e4 1919
04602539
TM		 1920 status = nfs4_begin_drain_session(clp);
1921 if (status < 0)
1922 return status;
7eff03ae 1923restart:
24d292b8
CL		 1924 rcu_read_lock();
1925 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
c77e2283 1926 nfs4_purge_state_owners(server, &freeme);
24d292b8
CL		 1927 spin_lock(&clp->cl_lock);
1928 for (pos = rb_first(&server->state_owners);
1929 pos != NULL;
1930 pos = rb_next(pos)) {
1931 sp = rb_entry(pos,
1932 struct nfs4_state_owner, so_server_node);
1933 if (!test_and_clear_bit(ops->owner_flag_bit,
1934 &sp->so_flags))
1935 continue;
4a0954ef
TM		 1936 if (!atomic_inc_not_zero(&sp->so_count))
1937 continue;
24d292b8
CL		 1938 spin_unlock(&clp->cl_lock);
1939 rcu_read_unlock();
1940
3e2910c7 1941 status = nfs4_reclaim_open_state(sp, ops, &lost_locks);
24d292b8 1942 if (status < 0) {
3e2910c7
N		 1943 if (lost_locks)
1944 pr_warn("NFS: %s: lost %d locks\n",
1945 clp->cl_hostname, lost_locks);
24d292b8
CL		 1946 set_bit(ops->owner_flag_bit, &sp->so_flags);
1947 nfs4_put_state_owner(sp);
df817ba3 1948 status = nfs4_recovery_handle_error(clp, status);
8f6a7c94 1949 nfs4_free_state_owners(&freeme);
df817ba3 1950 return (status != 0) ? status : -EAGAIN;
24d292b8
CL		 1951 }
1952
7eff03ae 1953 nfs4_put_state_owner(sp);
24d292b8 1954 goto restart;
7eff03ae 1955 }
24d292b8 1956 spin_unlock(&clp->cl_lock);
02860014 1957 }
24d292b8 1958 rcu_read_unlock();
c77e2283 1959 nfs4_free_state_owners(&freeme);
3e2910c7
N		 1960 if (lost_locks)
1961 pr_warn("NFS: %s: lost %d locks\n",
1962 clp->cl_hostname, lost_locks);
df817ba3 1963 return 0;
02860014
TM		 1964}
1965
1966static int nfs4_check_lease(struct nfs_client *clp)
1967{
a52458b4 1968 const struct cred *cred;
c48f4f35
TM		 1969 const struct nfs4_state_maintenance_ops *ops =
1970 clp->cl_mvops->state_renewal_ops;
4f38e4aa 1971 int status;
1da177e4 1972
0f605b56
TM		 1973 /* Is the client already known to have an expired lease? */
1974 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1975 return 0;
f15e1e8b 1976 cred = ops->get_state_renewal_cred(clp);
0f605b56 1977 if (cred == NULL) {
73d8bde5 1978 cred = nfs4_get_clid_cred(clp);
4f38e4aa 1979 status = -ENOKEY;
0f605b56
TM		 1980 if (cred == NULL)
1981 goto out;
286d7d6a 1982 }
8e69514f 1983 status = ops->renew_lease(clp, cred);
a52458b4 1984 put_cred(cred);
bc7a05ca
TM		 1985 if (status == -ETIMEDOUT) {
1986 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1987 return 0;
1988 }
0f605b56 1989out:
4f7cdf18 1990 return nfs4_recovery_handle_error(clp, status);
02860014
TM		 1991}
1992
47b803c8
AA		 1993/* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1994 * and for recoverable errors on EXCHANGE_ID for v4.1
2a6ee6aa
TM		 1995 */
1996static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1997{
1998 switch (status) {
89a21736
TM		 1999 case -NFS4ERR_SEQ_MISORDERED:
2000 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
2001 return -ESERVERFAULT;
2002 /* Lease confirmation error: retry after purging the lease */
2003 ssleep(1);
47b803c8
AA		 2004 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2005 break;
2a6ee6aa
TM		 2006 case -NFS4ERR_STALE_CLIENTID:
2007 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
47b803c8 2008 nfs4_state_start_reclaim_reboot(clp);
2a6ee6aa 2009 break;
de734831
CL		 2010 case -NFS4ERR_CLID_INUSE:
2011 pr_err("NFS: Server %s reports our clientid is in use\n",
2012 clp->cl_hostname);
2013 nfs_mark_client_ready(clp, -EPERM);
2014 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2015 return -EPERM;
af94dca7
TM		 2016 case -ETIMEDOUT:
2017 if (clp->cl_cons_state == NFS_CS_SESSION_INITING) {
2018 nfs_mark_client_ready(clp, -EIO);
2019 return -EIO;
2020 }
2021 fallthrough;
2a6ee6aa 2022 case -EACCES:
2a6ee6aa 2023 case -NFS4ERR_DELAY:
2a6ee6aa
TM		 2024 case -EAGAIN:
2025 ssleep(1);
2026 break;
2027
2028 case -NFS4ERR_MINOR_VERS_MISMATCH:
2029 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2030 nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
cc0a9843
TM		 2031 dprintk("%s: exit with error %d for server %s\n",
2032 __func__, -EPROTONOSUPPORT, clp->cl_hostname);
2a6ee6aa 2033 return -EPROTONOSUPPORT;
ea027cb2
OK		 2034 case -ENOSPC:
2035 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
2036 nfs_mark_client_ready(clp, -EIO);
2037 return -EIO;
2a6ee6aa
TM		 2038 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2039 * in nfs4_exchange_id */
2040 default:
cc0a9843
TM		 2041 dprintk("%s: exit with error %d for server %s\n", __func__,
2042 status, clp->cl_hostname);
2a6ee6aa
TM		 2043 return status;
2044 }
2045 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
cc0a9843
TM		 2046 dprintk("%s: handled error %d for server %s\n", __func__, status,
2047 clp->cl_hostname);
2a6ee6aa
TM		 2048 return 0;
2049}
2050
b42353ff 2051static int nfs4_establish_lease(struct nfs_client *clp)
02860014 2052{
a52458b4 2053 const struct cred *cred;
c48f4f35
TM		 2054 const struct nfs4_state_recovery_ops *ops =
2055 clp->cl_mvops->reboot_recovery_ops;
2a6ee6aa 2056 int status;
02860014 2057
8aafd2fd
TM		 2058 status = nfs4_begin_drain_session(clp);
2059 if (status != 0)
2060 return status;
73d8bde5 2061 cred = nfs4_get_clid_cred(clp);
2a6ee6aa
TM		 2062 if (cred == NULL)
2063 return -ENOENT;
2064 status = ops->establish_clid(clp, cred);
a52458b4 2065 put_cred(cred);
2a6ee6aa 2066 if (status != 0)
b42353ff 2067 return status;
b42353ff
TM		 2068 return 0;
2069}
2070
6bbb4ae8
CL		 2071/*
2072 * Returns zero or a negative errno. NFS4ERR values are converted
2073 * to local errno values.
2074 */
b42353ff
TM		 2075static int nfs4_reclaim_lease(struct nfs_client *clp)
2076{
2077 int status;
2078
2079 status = nfs4_establish_lease(clp);
2080 if (status < 0)
2081 return nfs4_handle_reclaim_lease_error(clp, status);
2082 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
2083 nfs4_state_start_reclaim_nograce(clp);
2084 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
2085 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
2086 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2087 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
2088 return 0;
2089}
2090
2091static int nfs4_purge_lease(struct nfs_client *clp)
2092{
2093 int status;
2094
2095 status = nfs4_establish_lease(clp);
2096 if (status < 0)
2a6ee6aa 2097 return nfs4_handle_reclaim_lease_error(clp, status);
b42353ff
TM		 2098 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2099 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
2100 nfs4_state_start_reclaim_nograce(clp);
2a6ee6aa 2101 return 0;
02860014
TM		 2102}
2103
c9fdeb28
CL		 2104/*
2105 * Try remote migration of one FSID from a source server to a
2106 * destination server. The source server provides a list of
2107 * potential destinations.
2108 *
2109 * Returns zero or a negative NFS4ERR status code.
2110 */
a52458b4 2111static int nfs4_try_migration(struct nfs_server *server, const struct cred *cred)
c9fdeb28
CL		 2112{
2113 struct nfs_client *clp = server->nfs_client;
2114 struct nfs4_fs_locations *locations = NULL;
37ffe065 2115 struct nfs_fattr *fattr;
c9fdeb28
CL		 2116 struct inode *inode;
2117 struct page *page;
2118 int status, result;
2119
2120 dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
2121 (unsigned long long)server->fsid.major,
2122 (unsigned long long)server->fsid.minor,
2123 clp->cl_hostname);
2124
c9fdeb28
CL		 2125 page = alloc_page(GFP_KERNEL);
2126 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
37ffe065
BC		 2127 fattr = nfs_alloc_fattr();
2128 if (page == NULL || locations == NULL || fattr == NULL) {
c3ed2227 2129 dprintk("<-- %s: no memory\n", __func__);
37ffe065 2130 result = 0;
c3ed2227
BC		 2131 goto out;
2132 }
c9fdeb28 2133
37ffe065 2134 locations->fattr = fattr;
2b0143b5 2135 inode = d_inode(server->super->s_root);
1976b2b3
OK		 2136 result = nfs4_proc_get_locations(server, NFS_FH(inode), locations,
2137 page, cred);
c9fdeb28
CL		 2138 if (result) {
2139 dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
2140 __func__, result);
2141 goto out;
2142 }
2143
2144 result = -NFS4ERR_NXIO;
90e12a31
OK		 2145 if (!locations->nlocations)
2146 goto out;
2147
c3ed2227 2148 if (!(locations->fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
c9fdeb28
CL		 2149 dprintk("<-- %s: No fs_locations data, migration skipped\n",
2150 __func__);
2151 goto out;
2152 }
2153
8aafd2fd 2154 status = nfs4_begin_drain_session(clp);
1e672e36
WW		 2155 if (status != 0) {
2156 result = status;
2157 goto out;
2158 }
c9fdeb28
CL		 2159
2160 status = nfs4_replace_transport(server, locations);
2161 if (status != 0) {
2162 dprintk("<-- %s: failed to replace transport: %d\n",
2163 __func__, status);
2164 goto out;
2165 }
2166
2167 result = 0;
2168 dprintk("<-- %s: migration succeeded\n", __func__);
2169
2170out:
2171 if (page != NULL)
2172 __free_page(page);
c3ed2227
BC		 2173 if (locations != NULL)
2174 kfree(locations->fattr);
c9fdeb28
CL		 2175 kfree(locations);
2176 if (result) {
2177 pr_err("NFS: migration recovery failed (server %s)\n",
2178 clp->cl_hostname);
2179 set_bit(NFS_MIG_FAILED, &server->mig_status);
2180 }
2181 return result;
2182}
2183
2184/*
2185 * Returns zero or a negative NFS4ERR status code.
2186 */
2187static int nfs4_handle_migration(struct nfs_client *clp)
2188{
2189 const struct nfs4_state_maintenance_ops *ops =
2190 clp->cl_mvops->state_renewal_ops;
2191 struct nfs_server *server;
a52458b4 2192 const struct cred *cred;
c9fdeb28
CL		 2193
2194 dprintk("%s: migration reported on \"%s\"\n", __func__,
2195 clp->cl_hostname);
2196
f15e1e8b 2197 cred = ops->get_state_renewal_cred(clp);
c9fdeb28
CL		 2198 if (cred == NULL)
2199 return -NFS4ERR_NOENT;
2200
2201 clp->cl_mig_gen++;
2202restart:
2203 rcu_read_lock();
2204 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2205 int status;
2206
2207 if (server->mig_gen == clp->cl_mig_gen)
2208 continue;
2209 server->mig_gen = clp->cl_mig_gen;
2210
2211 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
2212 &server->mig_status))
2213 continue;
2214
2215 rcu_read_unlock();
2216 status = nfs4_try_migration(server, cred);
2217 if (status < 0) {
a52458b4 2218 put_cred(cred);
c9fdeb28
CL		 2219 return status;
2220 }
2221 goto restart;
2222 }
2223 rcu_read_unlock();
a52458b4 2224 put_cred(cred);
c9fdeb28
CL		 2225 return 0;
2226}
2227
b7f7a66e
CL		 2228/*
2229 * Test each nfs_server on the clp's cl_superblocks list to see
2230 * if it's moved to another server. Stop when the server no longer
2231 * returns NFS4ERR_LEASE_MOVED.
2232 */
2233static int nfs4_handle_lease_moved(struct nfs_client *clp)
2234{
2235 const struct nfs4_state_maintenance_ops *ops =
2236 clp->cl_mvops->state_renewal_ops;
2237 struct nfs_server *server;
a52458b4 2238 const struct cred *cred;
b7f7a66e
CL		 2239
2240 dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2241 clp->cl_hostname);
2242
f15e1e8b 2243 cred = ops->get_state_renewal_cred(clp);
b7f7a66e
CL		 2244 if (cred == NULL)
2245 return -NFS4ERR_NOENT;
2246
2247 clp->cl_mig_gen++;
2248restart:
2249 rcu_read_lock();
2250 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2251 struct inode *inode;
2252 int status;
2253
2254 if (server->mig_gen == clp->cl_mig_gen)
2255 continue;
2256 server->mig_gen = clp->cl_mig_gen;
2257
2258 rcu_read_unlock();
2259
2b0143b5 2260 inode = d_inode(server->super->s_root);
b7f7a66e
CL		 2261 status = nfs4_proc_fsid_present(inode, cred);
2262 if (status != -NFS4ERR_MOVED)
2263 goto restart; /* wasn't this one */
2264 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2265 goto restart; /* there are more */
2266 goto out;
2267 }
2268 rcu_read_unlock();
2269
2270out:
a52458b4 2271 put_cred(cred);
b7f7a66e
CL		 2272 return 0;
2273}
2274
05f4c350
CL		 2275/**
2276 * nfs4_discover_server_trunking - Detect server IP address trunking
2277 *
2278 * @clp: nfs_client under test
2279 * @result: OUT: found nfs_client, or clp
2280 *
2281 * Returns zero or a negative errno. If zero is returned,
2282 * an nfs_client pointer is planted in "result".
2283 *
2284 * Note: since we are invoked in process context, and
2285 * not from inside the state manager, we cannot use
2286 * nfs4_handle_reclaim_lease_error().
2287 */
2288int nfs4_discover_server_trunking(struct nfs_client *clp,
2289 struct nfs_client **result)
2290{
2291 const struct nfs4_state_recovery_ops *ops =
2292 clp->cl_mvops->reboot_recovery_ops;
05f4c350 2293 struct rpc_clnt *clnt;
a52458b4 2294 const struct cred *cred;
4edaa308 2295 int i, status;
05f4c350
CL		 2296
2297 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2298
05f4c350 2299 clnt = clp->cl_rpcclient;
05f4c350
CL		 2300 i = 0;
2301
2302 mutex_lock(&nfs_clid_init_mutex);
05f4c350 2303again:
ea33e6c3 2304 status = -ENOENT;
73d8bde5 2305 cred = nfs4_get_clid_cred(clp);
05f4c350
CL		 2306 if (cred == NULL)
2307 goto out_unlock;
2308
2309 status = ops->detect_trunking(clp, result, cred);
a52458b4 2310 put_cred(cred);
05f4c350
CL		 2311 switch (status) {
2312 case 0:
898fc11b
TM		 2313 case -EINTR:
2314 case -ERESTARTSYS:
05f4c350 2315 break;
05f4c350 2316 case -ETIMEDOUT:
150e7260
TM		 2317 if (clnt->cl_softrtry)
2318 break;
df561f66 2319 fallthrough;
150e7260 2320 case -NFS4ERR_DELAY:
05f4c350
CL		 2321 case -EAGAIN:
2322 ssleep(1);
df561f66 2323 fallthrough;
202c312d 2324 case -NFS4ERR_STALE_CLIENTID:
05f4c350
CL		 2325 dprintk("NFS: %s after status %d, retrying\n",
2326 __func__, status);
2327 goto again;
4edaa308 2328 case -EACCES:
d688f7b8
CL		 2329 if (i++ == 0) {
2330 nfs4_root_machine_cred(clp);
2331 goto again;
2332 }
6d769f1e 2333 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
4edaa308 2334 break;
df561f66 2335 fallthrough;
05f4c350
CL		 2336 case -NFS4ERR_CLID_INUSE:
2337 case -NFS4ERR_WRONGSEC:
6d769f1e
JL		 2338 /* No point in retrying if we already used RPC_AUTH_UNIX */
2339 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2340 status = -EPERM;
2341 break;
2342 }
79d852bf 2343 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
05f4c350
CL		 2344 if (IS_ERR(clnt)) {
2345 status = PTR_ERR(clnt);
2346 break;
2347 }
b193d59a
TM		 2348 /* Note: this is safe because we haven't yet marked the
2349 * client as ready, so we are the only user of
2350 * clp->cl_rpcclient
2351 */
2352 clnt = xchg(&clp->cl_rpcclient, clnt);
2353 rpc_shutdown_client(clnt);
2354 clnt = clp->cl_rpcclient;
05f4c350
CL		 2355 goto again;
2356
2357 case -NFS4ERR_MINOR_VERS_MISMATCH:
2358 status = -EPROTONOSUPPORT;
2359 break;
2360
2361 case -EKEYEXPIRED:
05f4c350
CL		 2362 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2363 * in nfs4_exchange_id */
2364 status = -EKEYEXPIRED;
ea33e6c3
TM		 2365 break;
2366 default:
2367 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2368 __func__, status);
2369 status = -EIO;
05f4c350
CL		 2370 }
2371
2372out_unlock:
2373 mutex_unlock(&nfs_clid_init_mutex);
05f4c350
CL		 2374 dprintk("NFS: %s: status = %d\n", __func__, status);
2375 return status;
2376}
2377
76db6d95 2378#ifdef CONFIG_NFS_V4_1
9f594791 2379void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
0400a6b0 2380{
444f72fe
TM		 2381 struct nfs_client *clp = session->clp;
2382
9f594791
TM		 2383 switch (err) {
2384 default:
2385 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2386 break;
2387 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2388 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2389 }
d94cbf6c 2390 nfs4_schedule_state_manager(clp);
0400a6b0 2391}
cbdabc7f 2392EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
0400a6b0 2393
3f10a6af 2394void nfs41_notify_server(struct nfs_client *clp)
ac074835
TM		 2395{
2396 /* Use CHECK_LEASE to ping the server with a SEQUENCE */
2397 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2398 nfs4_schedule_state_manager(clp);
2399}
2400
0f79fd6f
TM		 2401static void nfs4_reset_all_state(struct nfs_client *clp)
2402{
2403 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2c820d9a 2404 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
be0bfed0 2405 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
0f79fd6f 2406 nfs4_state_start_reclaim_nograce(clp);
cc0a9843
TM		 2407 dprintk("%s: scheduling reset of all state for server %s!\n",
2408 __func__, clp->cl_hostname);
0400a6b0 2409 nfs4_schedule_state_manager(clp);
0f79fd6f
TM		 2410 }
2411}
2412
2413static void nfs41_handle_server_reboot(struct nfs_client *clp)
2414{
2415 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2416 nfs4_state_start_reclaim_reboot(clp);
cc0a9843
TM		 2417 dprintk("%s: server %s rebooted!\n", __func__,
2418 clp->cl_hostname);
0400a6b0 2419 nfs4_schedule_state_manager(clp);
0f79fd6f
TM		 2420 }
2421}
2422
8b895ce6 2423static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
0f79fd6f 2424{
0f79fd6f 2425 nfs4_reset_all_state(clp);
cc0a9843 2426 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
0f79fd6f
TM		 2427}
2428
8b895ce6
TM		 2429static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2430{
45870d69 2431 nfs4_state_start_reclaim_nograce(clp);
8b895ce6
TM		 2432 nfs4_schedule_state_manager(clp);
2433
2434 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2435}
2436
0f79fd6f
TM		 2437static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2438{
4099287f
TM		 2439 /* FIXME: For now, we destroy all layouts. */
2440 pnfs_destroy_all_layouts(clp);
8ca017c8 2441 nfs_test_expired_all_delegations(clp);
cc0a9843
TM		 2442 dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2443 clp->cl_hostname);
0f79fd6f
TM		 2444}
2445
a9e64442 2446static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
0f79fd6f 2447{
b1352905
TM		 2448 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2449 nfs4_schedule_state_manager(clp);
2450
cc0a9843
TM		 2451 dprintk("%s: server %s declared a backchannel fault\n", __func__,
2452 clp->cl_hostname);
0f79fd6f
TM		 2453}
2454
a9e64442
WAA		 2455static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2456{
2457 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2458 &clp->cl_state) == 0)
2459 nfs4_schedule_state_manager(clp);
2460}
2461
0a014a44
TM		 2462void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags,
2463 bool recovery)
0629e370
AB		 2464{
2465 if (!flags)
2466 return;
2c820d9a
CL		 2467
2468 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2469 __func__, clp->cl_hostname, clp->cl_clientid, flags);
0a014a44
TM		 2470 /*
2471 * If we're called from the state manager thread, then assume we're
2472 * already handling the RECLAIM_NEEDED and/or STATE_REVOKED.
2473 * Those flags are expected to remain set until we're done
2474 * recovering (see RFC5661, section 18.46.3).
2475 */
2476 if (recovery)
2477 goto out_recovery;
2c820d9a 2478
111d489f 2479 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
0f79fd6f 2480 nfs41_handle_server_reboot(clp);
8b895ce6
TM		 2481 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2482 nfs41_handle_all_state_revoked(clp);
2483 if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
d1c2331e 2484 SEQ4_STATUS_ADMIN_STATE_REVOKED))
8b895ce6 2485 nfs41_handle_some_state_revoked(clp);
d1c2331e
CL		 2486 if (flags & SEQ4_STATUS_LEASE_MOVED)
2487 nfs4_schedule_lease_moved_recovery(clp);
111d489f 2488 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
0f79fd6f 2489 nfs41_handle_recallable_state_revoked(clp);
0a014a44 2490out_recovery:
a9e64442
WAA		 2491 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2492 nfs41_handle_backchannel_fault(clp);
2493 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2494 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
0f79fd6f 2495 nfs41_handle_cb_path_down(clp);
0629e370
AB		 2496}
2497
c3fad1b1
AA		 2498static int nfs4_reset_session(struct nfs_client *clp)
2499{
a52458b4 2500 const struct cred *cred;
c3fad1b1
AA		 2501 int status;
2502
1a47e7a6
TM		 2503 if (!nfs4_has_session(clp))
2504 return 0;
8aafd2fd
TM		 2505 status = nfs4_begin_drain_session(clp);
2506 if (status != 0)
2507 return status;
73d8bde5 2508 cred = nfs4_get_clid_cred(clp);
848f5bda 2509 status = nfs4_proc_destroy_session(clp->cl_session, cred);
c489ee29
TM		 2510 switch (status) {
2511 case 0:
2512 case -NFS4ERR_BADSESSION:
2513 case -NFS4ERR_DEADSESSION:
2514 break;
2515 case -NFS4ERR_BACK_CHAN_BUSY:
2516 case -NFS4ERR_DELAY:
2517 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2518 status = 0;
2519 ssleep(1);
2520 goto out;
2521 default:
f455848a 2522 status = nfs4_recovery_handle_error(clp, status);
c3fad1b1
AA		 2523 goto out;
2524 }
2525
2526 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
848f5bda 2527 status = nfs4_proc_create_session(clp, cred);
41f54a55 2528 if (status) {
cc0a9843
TM		 2529 dprintk("%s: session reset failed with status %d for server %s!\n",
2530 __func__, status, clp->cl_hostname);
f2c1b510 2531 status = nfs4_handle_reclaim_lease_error(clp, status);
41f54a55
AA		 2532 goto out;
2533 }
bda197f5 2534 nfs41_finish_session_reset(clp);
cc0a9843
TM		 2535 dprintk("%s: session reset was successful for server %s!\n",
2536 __func__, clp->cl_hostname);
41f54a55 2537out:
a52458b4 2538 put_cred(cred);
c3fad1b1
AA		 2539 return status;
2540}
76db6d95 2541
a9e64442
WAA		 2542static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2543{
a52458b4 2544 const struct cred *cred;
2cf047c9
TM		 2545 int ret;
2546
1a47e7a6
TM		 2547 if (!nfs4_has_session(clp))
2548 return 0;
8aafd2fd
TM		 2549 ret = nfs4_begin_drain_session(clp);
2550 if (ret != 0)
2551 return ret;
73d8bde5 2552 cred = nfs4_get_clid_cred(clp);
2cf047c9 2553 ret = nfs4_proc_bind_conn_to_session(clp, cred);
a52458b4 2554 put_cred(cred);
43ac544c 2555 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
bf674c82
TM		 2556 switch (ret) {
2557 case 0:
cc0a9843
TM		 2558 dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2559 __func__, clp->cl_hostname);
bf674c82
TM		 2560 break;
2561 case -NFS4ERR_DELAY:
2562 ssleep(1);
2563 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2564 break;
2565 default:
2566 return nfs4_recovery_handle_error(clp, ret);
2567 }
2568 return 0;
a9e64442 2569}
b5fdf841
TM		 2570
2571static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2572{
2573 int iomode = 0;
2574
2575 if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_READ, &clp->cl_state))
2576 iomode += IOMODE_READ;
2577 if (test_and_clear_bit(NFS4CLNT_RECALL_ANY_LAYOUT_RW, &clp->cl_state))
2578 iomode += IOMODE_RW;
2579 /* Note: IOMODE_READ + IOMODE_RW == IOMODE_ANY */
2580 if (iomode) {
2581 pnfs_layout_return_unused_byclid(clp, iomode);
2582 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2583 }
2584}
76db6d95 2585#else /* CONFIG_NFS_V4_1 */
c3fad1b1 2586static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
a9e64442
WAA		 2587
2588static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2589{
2590 return 0;
2591}
b5fdf841
TM		 2592
2593static void nfs4_layoutreturn_any_run(struct nfs_client *clp)
2594{
2595}
76db6d95
AA		 2596#endif /* CONFIG_NFS_V4_1 */
2597
e005e804 2598static void nfs4_state_manager(struct nfs_client *clp)
02860014 2599{
3e17898a 2600 unsigned int memflags;
02860014 2601 int status = 0;
8ed27d4f 2602 const char *section = "", *section_sep = "";
02860014 2603
3e17898a
TM		 2604 /*
2605 * State recovery can deadlock if the direct reclaim code tries
2606 * start NFS writeback. So ensure memory allocations are all
2607 * GFP_NOFS.
2608 */
2609 memflags = memalloc_nofs_save();
2610
02860014 2611 /* Ensure exclusive access to NFSv4 state */
47c2199b 2612 do {
511ba52e 2613 trace_nfs4_state_mgr(clp);
aeabb3c9 2614 clear_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2c820d9a 2615 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
8ed27d4f 2616 section = "purge state";
b42353ff 2617 status = nfs4_purge_lease(clp);
2a6ee6aa
TM		 2618 if (status < 0)
2619 goto out_error;
b42353ff 2620 continue;
2c820d9a
CL		 2621 }
2622
b42353ff 2623 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
8ed27d4f 2624 section = "lease expired";
b79a4a1b
TM		 2625 /* We're going to have to re-establish a clientid */
2626 status = nfs4_reclaim_lease(clp);
2a6ee6aa 2627 if (status < 0)
b79a4a1b 2628 goto out_error;
b42353ff 2629 continue;
e598d843
TM		 2630 }
2631
c3fad1b1 2632 /* Initialize or reset the session */
1a47e7a6 2633 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
8ed27d4f 2634 section = "reset session";
4d643d1d 2635 status = nfs4_reset_session(clp);
b6d408ba
TM		 2636 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2637 continue;
2638 if (status < 0)
76db6d95 2639 goto out_error;
76db6d95 2640 }
b6d408ba 2641
a9e64442
WAA		 2642 /* Send BIND_CONN_TO_SESSION */
2643 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
1a47e7a6 2644 &clp->cl_state)) {
8ed27d4f 2645 section = "bind conn to session";
a9e64442
WAA		 2646 status = nfs4_bind_conn_to_session(clp);
2647 if (status < 0)
2648 goto out_error;
bf674c82 2649 continue;
a9e64442
WAA		 2650 }
2651
5df904ae
TM		 2652 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2653 section = "check lease";
2654 status = nfs4_check_lease(clp);
2655 if (status < 0)
2656 goto out_error;
8faaa6d5 2657 continue;
c9fdeb28
CL		 2658 }
2659
2660 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
2661 section = "migration";
2662 status = nfs4_handle_migration(clp);
2663 if (status < 0)
2664 goto out_error;
5df904ae
TM		 2665 }
2666
b7f7a66e
CL		 2667 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
2668 section = "lease moved";
2669 status = nfs4_handle_lease_moved(clp);
2670 if (status < 0)
2671 goto out_error;
2672 }
2673
b79a4a1b 2674 /* First recover reboot state... */
e345e88a 2675 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
8ed27d4f 2676 section = "reclaim reboot";
591d71cb 2677 status = nfs4_do_reclaim(clp,
c48f4f35 2678 clp->cl_mvops->reboot_recovery_ops);
5468fc82
TM		 2679 if (status == 0)
2680 status = pnfs_layout_handle_reboot(clp);
df817ba3 2681 if (status == -EAGAIN)
b6d408ba
TM		 2682 continue;
2683 if (status < 0)
2684 goto out_error;
df817ba3 2685 nfs4_state_end_reclaim_reboot(clp);
5d917cba 2686 continue;
02860014
TM		 2687 }
2688
45870d69
TM		 2689 /* Detect expired delegations... */
2690 if (test_and_clear_bit(NFS4CLNT_DELEGATION_EXPIRED, &clp->cl_state)) {
2691 section = "detect expired delegations";
04602539
TM		 2692 status = nfs4_begin_drain_session(clp);
2693 if (status < 0)
2694 goto out_error;
45870d69
TM		 2695 nfs_reap_expired_delegations(clp);
2696 continue;
2697 }
2698
b79a4a1b 2699 /* Now recover expired state... */
67e7b52d 2700 if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
8ed27d4f 2701 section = "reclaim nograce";
591d71cb 2702 status = nfs4_do_reclaim(clp,
c48f4f35 2703 clp->cl_mvops->nograce_recovery_ops);
df817ba3 2704 if (status == -EAGAIN)
b6d408ba
TM		 2705 continue;
2706 if (status < 0)
b79a4a1b 2707 goto out_error;
67e7b52d 2708 clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1da177e4 2709 }
707fb4b3 2710
3e17898a 2711 memalloc_nofs_restore(memflags);
5601a00d 2712 nfs4_end_drain_session(clp);
aeabb3c9
TM		 2713 nfs4_clear_state_manager_bit(clp);
2714
ed1cc05a
TM		 2715 if (test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
2716 !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING,
2717 &clp->cl_state)) {
2718 memflags = memalloc_nofs_save();
2719 continue;
2720 }
2721
b5fdf841 2722 if (!test_and_set_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state)) {
aeabb3c9
TM		 2723 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2724 nfs_client_return_marked_delegations(clp);
2725 set_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state);
2726 }
b5fdf841
TM		 2727 nfs4_layoutreturn_any_run(clp);
2728 clear_bit(NFS4CLNT_RECALL_RUNNING, &clp->cl_state);
707fb4b3 2729 }
e005e804 2730
4dc73c67
N		 2731 return;
2732
a1aa09be 2733 } while (refcount_read(&clp->cl_count) > 1 && !signalled());
21a446cf
TM		 2734 goto out_drain;
2735
1da177e4 2736out_error:
8ed27d4f
WAA		 2737 if (strlen(section))
2738 section_sep = ": ";
511ba52e 2739 trace_nfs4_state_mgr_failed(clp, section, status);
8ed27d4f
WAA		 2740 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2741 " with error %d\n", section_sep, section,
2742 clp->cl_hostname, -status);
ffe5a830 2743 ssleep(1);
21a446cf 2744out_drain:
3e17898a 2745 memalloc_nofs_restore(memflags);
5601a00d 2746 nfs4_end_drain_session(clp);
e005e804
TM		 2747 nfs4_clear_state_manager_bit(clp);
2748}
2749
2750static int nfs4_run_state_manager(void *ptr)
2751{
2752 struct nfs_client *clp = ptr;
4dc73c67
N		 2753 struct rpc_clnt *cl = clp->cl_rpcclient;
2754
2755 while (cl != cl->cl_parent)
2756 cl = cl->cl_parent;
e005e804
TM		 2757
2758 allow_signal(SIGKILL);
4dc73c67 2759again:
e005e804 2760 nfs4_state_manager(clp);
956fd46f
TM		 2761
2762 if (test_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state) &&
2763 !test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state)) {
4dc73c67
N		 2764 wait_var_event_interruptible(&clp->cl_state,
2765 test_bit(NFS4CLNT_RUN_MANAGER,
2766 &clp->cl_state));
956fd46f
TM		 2767 if (!atomic_read(&cl->cl_swapper))
2768 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
2769 if (refcount_read(&clp->cl_count) > 1 && !signalled() &&
2770 !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state))
4dc73c67
N		 2771 goto again;
2772 /* Either no longer a swapper, or were signalled */
956fd46f 2773 clear_bit(NFS4CLNT_MANAGER_AVAILABLE, &clp->cl_state);
4dc73c67 2774 }
4dc73c67
N		 2775
2776 if (refcount_read(&clp->cl_count) > 1 && !signalled() &&
2777 test_bit(NFS4CLNT_RUN_MANAGER, &clp->cl_state) &&
956fd46f 2778 !test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state))
4dc73c67
N		 2779 goto again;
2780
e005e804 2781 nfs_put_client(clp);
080abad7 2782 module_put_and_kthread_exit(0);
e005e804 2783 return 0;
1da177e4 2784}
Empty description
This page took 1.696621 seconds and 4 git commands to generate.