?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
powerpc/kprobes: Remove kretprobe_trampoline_holder.
[linux/fpc-iii.git] / fs / nfs / nfs4state.c
blob9679f47493640d4ce4a8a5e571727ece40e13625
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 <kmsmith@umich.edu>
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 *
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * Implementation of the NFSv4 state model. For the time being,
37 * this is minimal, but will be made much more complex in a
38 * subsequent patch.
39 */
40
41 #include <linux/kernel.h>
42 #include <linux/slab.h>
43 #include <linux/fs.h>
44 #include <linux/nfs_fs.h>
45 #include <linux/kthread.h>
46 #include <linux/module.h>
47 #include <linux/random.h>
48 #include <linux/ratelimit.h>
49 #include <linux/workqueue.h>
50 #include <linux/bitops.h>
51 #include <linux/jiffies.h>
52
53 #include <linux/sunrpc/clnt.h>
54
55 #include "nfs4_fs.h"
56 #include "callback.h"
57 #include "delegation.h"
58 #include "internal.h"
59 #include "nfs4idmap.h"
60 #include "nfs4session.h"
61 #include "pnfs.h"
62 #include "netns.h"
63
64 #define NFSDBG_FACILITY NFSDBG_STATE
65
66 #define OPENOWNER_POOL_SIZE 8
67
68 const nfs4_stateid zero_stateid = {
69 { .data = { 0 } },
70 .type = NFS4_SPECIAL_STATEID_TYPE,
71 };
72 static DEFINE_MUTEX(nfs_clid_init_mutex);
73
74 int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
75 {
76 struct nfs4_setclientid_res clid = {
77 .clientid = clp->cl_clientid,
78 .confirm = clp->cl_confirm,
79 };
80 unsigned short port;
81 int status;
82 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
83
84 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
85 goto do_confirm;
86 port = nn->nfs_callback_tcpport;
87 if (clp->cl_addr.ss_family == AF_INET6)
88 port = nn->nfs_callback_tcpport6;
89
90 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
91 if (status != 0)
92 goto out;
93 clp->cl_clientid = clid.clientid;
94 clp->cl_confirm = clid.confirm;
95 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
96 do_confirm:
97 status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
98 if (status != 0)
99 goto out;
100 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
101 nfs4_schedule_state_renewal(clp);
102 out:
103 return status;
104 }
105
106 /**
107 * nfs40_discover_server_trunking - Detect server IP address trunking (mv0)
108 *
109 * @clp: nfs_client under test
110 * @result: OUT: found nfs_client, or clp
111 * @cred: credential to use for trunking test
112 *
113 * Returns zero, a negative errno, or a negative NFS4ERR status.
114 * If zero is returned, an nfs_client pointer is planted in
115 * "result".
116 *
117 * Note: The returned client may not yet be marked ready.
118 */
119 int nfs40_discover_server_trunking(struct nfs_client *clp,
120 struct nfs_client **result,
121 struct rpc_cred *cred)
122 {
123 struct nfs4_setclientid_res clid = {
124 .clientid = clp->cl_clientid,
125 .confirm = clp->cl_confirm,
126 };
127 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
128 unsigned short port;
129 int status;
130
131 port = nn->nfs_callback_tcpport;
132 if (clp->cl_addr.ss_family == AF_INET6)
133 port = nn->nfs_callback_tcpport6;
134
135 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
136 if (status != 0)
137 goto out;
138 clp->cl_clientid = clid.clientid;
139 clp->cl_confirm = clid.confirm;
140
141 status = nfs40_walk_client_list(clp, result, cred);
142 if (status == 0) {
143 /* Sustain the lease, even if it's empty. If the clientid4
144 * goes stale it's of no use for trunking discovery. */
145 nfs4_schedule_state_renewal(*result);
146 }
147 out:
148 return status;
149 }
150
151 struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
152 {
153 struct rpc_cred *cred = NULL;
154
155 if (clp->cl_machine_cred != NULL)
156 cred = get_rpccred(clp->cl_machine_cred);
157 return cred;
158 }
159
160 static void nfs4_root_machine_cred(struct nfs_client *clp)
161 {
162 struct rpc_cred *cred, *new;
163
164 new = rpc_lookup_machine_cred(NULL);
165 spin_lock(&clp->cl_lock);
166 cred = clp->cl_machine_cred;
167 clp->cl_machine_cred = new;
168 spin_unlock(&clp->cl_lock);
169 if (cred != NULL)
170 put_rpccred(cred);
171 }
172
173 static struct rpc_cred *
174 nfs4_get_renew_cred_server_locked(struct nfs_server *server)
175 {
176 struct rpc_cred *cred = NULL;
177 struct nfs4_state_owner *sp;
178 struct rb_node *pos;
179
180 for (pos = rb_first(&server->state_owners);
181 pos != NULL;
182 pos = rb_next(pos)) {
183 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
184 if (list_empty(&sp->so_states))
185 continue;
186 cred = get_rpccred(sp->so_cred);
187 break;
188 }
189 return cred;
190 }
191
192 /**
193 * nfs4_get_renew_cred_locked - Acquire credential for a renew operation
194 * @clp: client state handle
195 *
196 * Returns an rpc_cred with reference count bumped, or NULL.
197 * Caller must hold clp->cl_lock.
198 */
199 struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
200 {
201 struct rpc_cred *cred = NULL;
202 struct nfs_server *server;
203
204 /* Use machine credentials if available */
205 cred = nfs4_get_machine_cred_locked(clp);
206 if (cred != NULL)
207 goto out;
208
209 rcu_read_lock();
210 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
211 cred = nfs4_get_renew_cred_server_locked(server);
212 if (cred != NULL)
213 break;
214 }
215 rcu_read_unlock();
216
217 out:
218 return cred;
219 }
220
221 static void nfs4_end_drain_slot_table(struct nfs4_slot_table *tbl)
222 {
223 if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
224 spin_lock(&tbl->slot_tbl_lock);
225 nfs41_wake_slot_table(tbl);
226 spin_unlock(&tbl->slot_tbl_lock);
227 }
228 }
229
230 static void nfs4_end_drain_session(struct nfs_client *clp)
231 {
232 struct nfs4_session *ses = clp->cl_session;
233
234 if (clp->cl_slot_tbl) {
235 nfs4_end_drain_slot_table(clp->cl_slot_tbl);
236 return;
237 }
238
239 if (ses != NULL) {
240 nfs4_end_drain_slot_table(&ses->bc_slot_table);
241 nfs4_end_drain_slot_table(&ses->fc_slot_table);
242 }
243 }
244
245 static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
246 {
247 set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
248 spin_lock(&tbl->slot_tbl_lock);
249 if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
250 reinit_completion(&tbl->complete);
251 spin_unlock(&tbl->slot_tbl_lock);
252 return wait_for_completion_interruptible(&tbl->complete);
253 }
254 spin_unlock(&tbl->slot_tbl_lock);
255 return 0;
256 }
257
258 static int nfs4_begin_drain_session(struct nfs_client *clp)
259 {
260 struct nfs4_session *ses = clp->cl_session;
261 int ret = 0;
262
263 if (clp->cl_slot_tbl)
264 return nfs4_drain_slot_tbl(clp->cl_slot_tbl);
265
266 /* back channel */
267 ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
268 if (ret)
269 return ret;
270 /* fore channel */
271 return nfs4_drain_slot_tbl(&ses->fc_slot_table);
272 }
273
274 #if defined(CONFIG_NFS_V4_1)
275
276 static int nfs41_setup_state_renewal(struct nfs_client *clp)
277 {
278 int status;
279 struct nfs_fsinfo fsinfo;
280
281 if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
282 nfs4_schedule_state_renewal(clp);
283 return 0;
284 }
285
286 status = nfs4_proc_get_lease_time(clp, &fsinfo);
287 if (status == 0) {
288 /* Update lease time and schedule renewal */
289 spin_lock(&clp->cl_lock);
290 clp->cl_lease_time = fsinfo.lease_time * HZ;
291 clp->cl_last_renewal = jiffies;
292 spin_unlock(&clp->cl_lock);
293
294 nfs4_schedule_state_renewal(clp);
295 }
296
297 return status;
298 }
299
300 static void nfs41_finish_session_reset(struct nfs_client *clp)
301 {
302 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
303 clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
304 /* create_session negotiated new slot table */
305 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
306 nfs41_setup_state_renewal(clp);
307 }
308
309 int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
310 {
311 int status;
312
313 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
314 goto do_confirm;
315 status = nfs4_proc_exchange_id(clp, cred);
316 if (status != 0)
317 goto out;
318 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
319 do_confirm:
320 status = nfs4_proc_create_session(clp, cred);
321 if (status != 0)
322 goto out;
323 nfs41_finish_session_reset(clp);
324 nfs_mark_client_ready(clp, NFS_CS_READY);
325 out:
326 return status;
327 }
328
329 /**
330 * nfs41_discover_server_trunking - Detect server IP address trunking (mv1)
331 *
332 * @clp: nfs_client under test
333 * @result: OUT: found nfs_client, or clp
334 * @cred: credential to use for trunking test
335 *
336 * Returns NFS4_OK, a negative errno, or a negative NFS4ERR status.
337 * If NFS4_OK is returned, an nfs_client pointer is planted in
338 * "result".
339 *
340 * Note: The returned client may not yet be marked ready.
341 */
342 int nfs41_discover_server_trunking(struct nfs_client *clp,
343 struct nfs_client **result,
344 struct rpc_cred *cred)
345 {
346 int status;
347
348 status = nfs4_proc_exchange_id(clp, cred);
349 if (status != NFS4_OK)
350 return status;
351
352 status = nfs41_walk_client_list(clp, result, cred);
353 if (status < 0)
354 return status;
355 if (clp != *result)
356 return 0;
357
358 /* Purge state if the client id was established in a prior instance */
359 if (clp->cl_exchange_flags & EXCHGID4_FLAG_CONFIRMED_R)
360 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
361 else
362 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
363 nfs4_schedule_state_manager(clp);
364 status = nfs_wait_client_init_complete(clp);
365 if (status < 0)
366 nfs_put_client(clp);
367 return status;
368 }
369
370 #endif /* CONFIG_NFS_V4_1 */
371
372 /**
373 * nfs4_get_clid_cred - Acquire credential for a setclientid operation
374 * @clp: client state handle
375 *
376 * Returns an rpc_cred with reference count bumped, or NULL.
377 */
378 struct rpc_cred *nfs4_get_clid_cred(struct nfs_client *clp)
379 {
380 struct rpc_cred *cred;
381
382 spin_lock(&clp->cl_lock);
383 cred = nfs4_get_machine_cred_locked(clp);
384 spin_unlock(&clp->cl_lock);
385 return cred;
386 }
387
388 static struct nfs4_state_owner *
389 nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
390 {
391 struct rb_node **p = &server->state_owners.rb_node,
392 *parent = NULL;
393 struct nfs4_state_owner *sp;
394
395 while (*p != NULL) {
396 parent = *p;
397 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
398
399 if (cred < sp->so_cred)
400 p = &parent->rb_left;
401 else if (cred > sp->so_cred)
402 p = &parent->rb_right;
403 else {
404 if (!list_empty(&sp->so_lru))
405 list_del_init(&sp->so_lru);
406 atomic_inc(&sp->so_count);
407 return sp;
408 }
409 }
410 return NULL;
411 }
412
413 static struct nfs4_state_owner *
414 nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
415 {
416 struct nfs_server *server = new->so_server;
417 struct rb_node **p = &server->state_owners.rb_node,
418 *parent = NULL;
419 struct nfs4_state_owner *sp;
420 int err;
421
422 while (*p != NULL) {
423 parent = *p;
424 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
425
426 if (new->so_cred < sp->so_cred)
427 p = &parent->rb_left;
428 else if (new->so_cred > sp->so_cred)
429 p = &parent->rb_right;
430 else {
431 if (!list_empty(&sp->so_lru))
432 list_del_init(&sp->so_lru);
433 atomic_inc(&sp->so_count);
434 return sp;
435 }
436 }
437 err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
438 if (err)
439 return ERR_PTR(err);
440 rb_link_node(&new->so_server_node, parent, p);
441 rb_insert_color(&new->so_server_node, &server->state_owners);
442 return new;
443 }
444
445 static void
446 nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
447 {
448 struct nfs_server *server = sp->so_server;
449
450 if (!RB_EMPTY_NODE(&sp->so_server_node))
451 rb_erase(&sp->so_server_node, &server->state_owners);
452 ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
453 }
454
455 static void
456 nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
457 {
458 sc->create_time = ktime_get();
459 sc->flags = 0;
460 sc->counter = 0;
461 spin_lock_init(&sc->lock);
462 INIT_LIST_HEAD(&sc->list);
463 rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
464 }
465
466 static void
467 nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
468 {
469 rpc_destroy_wait_queue(&sc->wait);
470 }
471
472 /*
473 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
474 * create a new state_owner.
475 *
476 */
477 static struct nfs4_state_owner *
478 nfs4_alloc_state_owner(struct nfs_server *server,
479 struct rpc_cred *cred,
480 gfp_t gfp_flags)
481 {
482 struct nfs4_state_owner *sp;
483
484 sp = kzalloc(sizeof(*sp), gfp_flags);
485 if (!sp)
486 return NULL;
487 sp->so_server = server;
488 sp->so_cred = get_rpccred(cred);
489 spin_lock_init(&sp->so_lock);
490 INIT_LIST_HEAD(&sp->so_states);
491 nfs4_init_seqid_counter(&sp->so_seqid);
492 atomic_set(&sp->so_count, 1);
493 INIT_LIST_HEAD(&sp->so_lru);
494 seqcount_init(&sp->so_reclaim_seqcount);
495 mutex_init(&sp->so_delegreturn_mutex);
496 return sp;
497 }
498
499 static void
500 nfs4_drop_state_owner(struct nfs4_state_owner *sp)
501 {
502 struct rb_node *rb_node = &sp->so_server_node;
503
504 if (!RB_EMPTY_NODE(rb_node)) {
505 struct nfs_server *server = sp->so_server;
506 struct nfs_client *clp = server->nfs_client;
507
508 spin_lock(&clp->cl_lock);
509 if (!RB_EMPTY_NODE(rb_node)) {
510 rb_erase(rb_node, &server->state_owners);
511 RB_CLEAR_NODE(rb_node);
512 }
513 spin_unlock(&clp->cl_lock);
514 }
515 }
516
517 static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
518 {
519 nfs4_destroy_seqid_counter(&sp->so_seqid);
520 put_rpccred(sp->so_cred);
521 kfree(sp);
522 }
523
524 static void nfs4_gc_state_owners(struct nfs_server *server)
525 {
526 struct nfs_client *clp = server->nfs_client;
527 struct nfs4_state_owner *sp, *tmp;
528 unsigned long time_min, time_max;
529 LIST_HEAD(doomed);
530
531 spin_lock(&clp->cl_lock);
532 time_max = jiffies;
533 time_min = (long)time_max - (long)clp->cl_lease_time;
534 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
535 /* NB: LRU is sorted so that oldest is at the head */
536 if (time_in_range(sp->so_expires, time_min, time_max))
537 break;
538 list_move(&sp->so_lru, &doomed);
539 nfs4_remove_state_owner_locked(sp);
540 }
541 spin_unlock(&clp->cl_lock);
542
543 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
544 list_del(&sp->so_lru);
545 nfs4_free_state_owner(sp);
546 }
547 }
548
549 /**
550 * nfs4_get_state_owner - Look up a state owner given a credential
551 * @server: nfs_server to search
552 * @cred: RPC credential to match
553 *
554 * Returns a pointer to an instantiated nfs4_state_owner struct, or NULL.
555 */
556 struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
557 struct rpc_cred *cred,
558 gfp_t gfp_flags)
559 {
560 struct nfs_client *clp = server->nfs_client;
561 struct nfs4_state_owner *sp, *new;
562
563 spin_lock(&clp->cl_lock);
564 sp = nfs4_find_state_owner_locked(server, cred);
565 spin_unlock(&clp->cl_lock);
566 if (sp != NULL)
567 goto out;
568 new = nfs4_alloc_state_owner(server, cred, gfp_flags);
569 if (new == NULL)
570 goto out;
571 do {
572 if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
573 break;
574 spin_lock(&clp->cl_lock);
575 sp = nfs4_insert_state_owner_locked(new);
576 spin_unlock(&clp->cl_lock);
577 } while (sp == ERR_PTR(-EAGAIN));
578 if (sp != new)
579 nfs4_free_state_owner(new);
580 out:
581 nfs4_gc_state_owners(server);
582 return sp;
583 }
584
585 /**
586 * nfs4_put_state_owner - Release a nfs4_state_owner
587 * @sp: state owner data to release
588 *
589 * Note that we keep released state owners on an LRU
590 * list.
591 * This caches valid state owners so that they can be
592 * reused, to avoid the OPEN_CONFIRM on minor version 0.
593 * It also pins the uniquifier of dropped state owners for
594 * a while, to ensure that those state owner names are
595 * never reused.
596 */
597 void nfs4_put_state_owner(struct nfs4_state_owner *sp)
598 {
599 struct nfs_server *server = sp->so_server;
600 struct nfs_client *clp = server->nfs_client;
601
602 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
603 return;
604
605 sp->so_expires = jiffies;
606 list_add_tail(&sp->so_lru, &server->state_owners_lru);
607 spin_unlock(&clp->cl_lock);
608 }
609
610 /**
611 * nfs4_purge_state_owners - Release all cached state owners
612 * @server: nfs_server with cached state owners to release
613 *
614 * Called at umount time. Remaining state owners will be on
615 * the LRU with ref count of zero.
616 */
617 void nfs4_purge_state_owners(struct nfs_server *server)
618 {
619 struct nfs_client *clp = server->nfs_client;
620 struct nfs4_state_owner *sp, *tmp;
621 LIST_HEAD(doomed);
622
623 spin_lock(&clp->cl_lock);
624 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
625 list_move(&sp->so_lru, &doomed);
626 nfs4_remove_state_owner_locked(sp);
627 }
628 spin_unlock(&clp->cl_lock);
629
630 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
631 list_del(&sp->so_lru);
632 nfs4_free_state_owner(sp);
633 }
634 }
635
636 static struct nfs4_state *
637 nfs4_alloc_open_state(void)
638 {
639 struct nfs4_state *state;
640
641 state = kzalloc(sizeof(*state), GFP_NOFS);
642 if (!state)
643 return NULL;
644 atomic_set(&state->count, 1);
645 INIT_LIST_HEAD(&state->lock_states);
646 spin_lock_init(&state->state_lock);
647 seqlock_init(&state->seqlock);
648 return state;
649 }
650
651 void
652 nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
653 {
654 if (state->state == fmode)
655 return;
656 /* NB! List reordering - see the reclaim code for why. */
657 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
658 if (fmode & FMODE_WRITE)
659 list_move(&state->open_states, &state->owner->so_states);
660 else
661 list_move_tail(&state->open_states, &state->owner->so_states);
662 }
663 state->state = fmode;
664 }
665
666 static struct nfs4_state *
667 __nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
668 {
669 struct nfs_inode *nfsi = NFS_I(inode);
670 struct nfs4_state *state;
671
672 list_for_each_entry(state, &nfsi->open_states, inode_states) {
673 if (state->owner != owner)
674 continue;
675 if (!nfs4_valid_open_stateid(state))
676 continue;
677 if (atomic_inc_not_zero(&state->count))
678 return state;
679 }
680 return NULL;
681 }
682
683 static void
684 nfs4_free_open_state(struct nfs4_state *state)
685 {
686 kfree(state);
687 }
688
689 struct nfs4_state *
690 nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
691 {
692 struct nfs4_state *state, *new;
693 struct nfs_inode *nfsi = NFS_I(inode);
694
695 spin_lock(&inode->i_lock);
696 state = __nfs4_find_state_byowner(inode, owner);
697 spin_unlock(&inode->i_lock);
698 if (state)
699 goto out;
700 new = nfs4_alloc_open_state();
701 spin_lock(&owner->so_lock);
702 spin_lock(&inode->i_lock);
703 state = __nfs4_find_state_byowner(inode, owner);
704 if (state == NULL && new != NULL) {
705 state = new;
706 state->owner = owner;
707 atomic_inc(&owner->so_count);
708 list_add(&state->inode_states, &nfsi->open_states);
709 ihold(inode);
710 state->inode = inode;
711 spin_unlock(&inode->i_lock);
712 /* Note: The reclaim code dictates that we add stateless
713 * and read-only stateids to the end of the list */
714 list_add_tail(&state->open_states, &owner->so_states);
715 spin_unlock(&owner->so_lock);
716 } else {
717 spin_unlock(&inode->i_lock);
718 spin_unlock(&owner->so_lock);
719 if (new)
720 nfs4_free_open_state(new);
721 }
722 out:
723 return state;
724 }
725
726 void nfs4_put_open_state(struct nfs4_state *state)
727 {
728 struct inode *inode = state->inode;
729 struct nfs4_state_owner *owner = state->owner;
730
731 if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
732 return;
733 spin_lock(&inode->i_lock);
734 list_del(&state->inode_states);
735 list_del(&state->open_states);
736 spin_unlock(&inode->i_lock);
737 spin_unlock(&owner->so_lock);
738 iput(inode);
739 nfs4_free_open_state(state);
740 nfs4_put_state_owner(owner);
741 }
742
743 /*
744 * Close the current file.
745 */
746 static void __nfs4_close(struct nfs4_state *state,
747 fmode_t fmode, gfp_t gfp_mask, int wait)
748 {
749 struct nfs4_state_owner *owner = state->owner;
750 int call_close = 0;
751 fmode_t newstate;
752
753 atomic_inc(&owner->so_count);
754 /* Protect against nfs4_find_state() */
755 spin_lock(&owner->so_lock);
756 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
757 case FMODE_READ:
758 state->n_rdonly--;
759 break;
760 case FMODE_WRITE:
761 state->n_wronly--;
762 break;
763 case FMODE_READ|FMODE_WRITE:
764 state->n_rdwr--;
765 }
766 newstate = FMODE_READ|FMODE_WRITE;
767 if (state->n_rdwr == 0) {
768 if (state->n_rdonly == 0) {
769 newstate &= ~FMODE_READ;
770 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
771 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
772 }
773 if (state->n_wronly == 0) {
774 newstate &= ~FMODE_WRITE;
775 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
776 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
777 }
778 if (newstate == 0)
779 clear_bit(NFS_DELEGATED_STATE, &state->flags);
780 }
781 nfs4_state_set_mode_locked(state, newstate);
782 spin_unlock(&owner->so_lock);
783
784 if (!call_close) {
785 nfs4_put_open_state(state);
786 nfs4_put_state_owner(owner);
787 } else
788 nfs4_do_close(state, gfp_mask, wait);
789 }
790
791 void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
792 {
793 __nfs4_close(state, fmode, GFP_NOFS, 0);
794 }
795
796 void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
797 {
798 __nfs4_close(state, fmode, GFP_KERNEL, 1);
799 }
800
801 /*
802 * Search the state->lock_states for an existing lock_owner
803 * that is compatible with current->files
804 */
805 static struct nfs4_lock_state *
806 __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
807 {
808 struct nfs4_lock_state *pos;
809 list_for_each_entry(pos, &state->lock_states, ls_locks) {
810 if (pos->ls_owner != fl_owner)
811 continue;
812 atomic_inc(&pos->ls_count);
813 return pos;
814 }
815 return NULL;
816 }
817
818 /*
819 * Return a compatible lock_state. If no initialized lock_state structure
820 * exists, return an uninitialized one.
821 *
822 */
823 static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
824 {
825 struct nfs4_lock_state *lsp;
826 struct nfs_server *server = state->owner->so_server;
827
828 lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
829 if (lsp == NULL)
830 return NULL;
831 nfs4_init_seqid_counter(&lsp->ls_seqid);
832 atomic_set(&lsp->ls_count, 1);
833 lsp->ls_state = state;
834 lsp->ls_owner = fl_owner;
835 lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
836 if (lsp->ls_seqid.owner_id < 0)
837 goto out_free;
838 INIT_LIST_HEAD(&lsp->ls_locks);
839 return lsp;
840 out_free:
841 kfree(lsp);
842 return NULL;
843 }
844
845 void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
846 {
847 ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
848 nfs4_destroy_seqid_counter(&lsp->ls_seqid);
849 kfree(lsp);
850 }
851
852 /*
853 * Return a compatible lock_state. If no initialized lock_state structure
854 * exists, return an uninitialized one.
855 *
856 */
857 static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
858 {
859 struct nfs4_lock_state *lsp, *new = NULL;
860
861 for(;;) {
862 spin_lock(&state->state_lock);
863 lsp = __nfs4_find_lock_state(state, owner);
864 if (lsp != NULL)
865 break;
866 if (new != NULL) {
867 list_add(&new->ls_locks, &state->lock_states);
868 set_bit(LK_STATE_IN_USE, &state->flags);
869 lsp = new;
870 new = NULL;
871 break;
872 }
873 spin_unlock(&state->state_lock);
874 new = nfs4_alloc_lock_state(state, owner);
875 if (new == NULL)
876 return NULL;
877 }
878 spin_unlock(&state->state_lock);
879 if (new != NULL)
880 nfs4_free_lock_state(state->owner->so_server, new);
881 return lsp;
882 }
883
884 /*
885 * Release reference to lock_state, and free it if we see that
886 * it is no longer in use
887 */
888 void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
889 {
890 struct nfs_server *server;
891 struct nfs4_state *state;
892
893 if (lsp == NULL)
894 return;
895 state = lsp->ls_state;
896 if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
897 return;
898 list_del(&lsp->ls_locks);
899 if (list_empty(&state->lock_states))
900 clear_bit(LK_STATE_IN_USE, &state->flags);
901 spin_unlock(&state->state_lock);
902 server = state->owner->so_server;
903 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
904 struct nfs_client *clp = server->nfs_client;
905
906 clp->cl_mvops->free_lock_state(server, lsp);
907 } else
908 nfs4_free_lock_state(server, lsp);
909 }
910
911 static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
912 {
913 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
914
915 dst->fl_u.nfs4_fl.owner = lsp;
916 atomic_inc(&lsp->ls_count);
917 }
918
919 static void nfs4_fl_release_lock(struct file_lock *fl)
920 {
921 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
922 }
923
924 static const struct file_lock_operations nfs4_fl_lock_ops = {
925 .fl_copy_lock = nfs4_fl_copy_lock,
926 .fl_release_private = nfs4_fl_release_lock,
927 };
928
929 int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
930 {
931 struct nfs4_lock_state *lsp;
932
933 if (fl->fl_ops != NULL)
934 return 0;
935 lsp = nfs4_get_lock_state(state, fl->fl_owner);
936 if (lsp == NULL)
937 return -ENOMEM;
938 fl->fl_u.nfs4_fl.owner = lsp;
939 fl->fl_ops = &nfs4_fl_lock_ops;
940 return 0;
941 }
942
943 static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
944 struct nfs4_state *state,
945 const struct nfs_lockowner *lockowner)
946 {
947 struct nfs4_lock_state *lsp;
948 fl_owner_t fl_owner;
949 int ret = -ENOENT;
950
951
952 if (lockowner == NULL)
953 goto out;
954
955 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
956 goto out;
957
958 fl_owner = lockowner->l_owner;
959 spin_lock(&state->state_lock);
960 lsp = __nfs4_find_lock_state(state, fl_owner);
961 if (lsp && test_bit(NFS_LOCK_LOST, &lsp->ls_flags))
962 ret = -EIO;
963 else if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
964 nfs4_stateid_copy(dst, &lsp->ls_stateid);
965 ret = 0;
966 }
967 spin_unlock(&state->state_lock);
968 nfs4_put_lock_state(lsp);
969 out:
970 return ret;
971 }
972
973 static void nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
974 {
975 const nfs4_stateid *src;
976 int seq;
977
978 do {
979 src = &zero_stateid;
980 seq = read_seqbegin(&state->seqlock);
981 if (test_bit(NFS_OPEN_STATE, &state->flags))
982 src = &state->open_stateid;
983 nfs4_stateid_copy(dst, src);
984 } while (read_seqretry(&state->seqlock, seq));
985 }
986
987 /*
988 * Byte-range lock aware utility to initialize the stateid of read/write
989 * requests.
990 */
991 int nfs4_select_rw_stateid(struct nfs4_state *state,
992 fmode_t fmode, const struct nfs_lockowner *lockowner,
993 nfs4_stateid *dst, struct rpc_cred **cred)
994 {
995 int ret;
996
997 if (cred != NULL)
998 *cred = NULL;
999 ret = nfs4_copy_lock_stateid(dst, state, lockowner);
1000 if (ret == -EIO)
1001 /* A lost lock - don't even consider delegations */
1002 goto out;
1003 /* returns true if delegation stateid found and copied */
1004 if (nfs4_copy_delegation_stateid(state->inode, fmode, dst, cred)) {
1005 ret = 0;
1006 goto out;
1007 }
1008 if (ret != -ENOENT)
1009 /* nfs4_copy_delegation_stateid() didn't over-write
1010 * dst, so it still has the lock stateid which we now
1011 * choose to use.
1012 */
1013 goto out;
1014 nfs4_copy_open_stateid(dst, state);
1015 ret = 0;
1016 out:
1017 if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1018 dst->seqid = 0;
1019 return ret;
1020 }
1021
1022 struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1023 {
1024 struct nfs_seqid *new;
1025
1026 new = kmalloc(sizeof(*new), gfp_mask);
1027 if (new == NULL)
1028 return ERR_PTR(-ENOMEM);
1029 new->sequence = counter;
1030 INIT_LIST_HEAD(&new->list);
1031 new->task = NULL;
1032 return new;
1033 }
1034
1035 void nfs_release_seqid(struct nfs_seqid *seqid)
1036 {
1037 struct nfs_seqid_counter *sequence;
1038
1039 if (seqid == NULL || list_empty(&seqid->list))
1040 return;
1041 sequence = seqid->sequence;
1042 spin_lock(&sequence->lock);
1043 list_del_init(&seqid->list);
1044 if (!list_empty(&sequence->list)) {
1045 struct nfs_seqid *next;
1046
1047 next = list_first_entry(&sequence->list,
1048 struct nfs_seqid, list);
1049 rpc_wake_up_queued_task(&sequence->wait, next->task);
1050 }
1051 spin_unlock(&sequence->lock);
1052 }
1053
1054 void nfs_free_seqid(struct nfs_seqid *seqid)
1055 {
1056 nfs_release_seqid(seqid);
1057 kfree(seqid);
1058 }
1059
1060 /*
1061 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
1062 * failed with a seqid incrementing error -
1063 * see comments nfs4.h:seqid_mutating_error()
1064 */
1065 static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1066 {
1067 switch (status) {
1068 case 0:
1069 break;
1070 case -NFS4ERR_BAD_SEQID:
1071 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1072 return;
1073 pr_warn_ratelimited("NFS: v4 server returned a bad"
1074 " sequence-id error on an"
1075 " unconfirmed sequence %p!\n",
1076 seqid->sequence);
1077 case -NFS4ERR_STALE_CLIENTID:
1078 case -NFS4ERR_STALE_STATEID:
1079 case -NFS4ERR_BAD_STATEID:
1080 case -NFS4ERR_BADXDR:
1081 case -NFS4ERR_RESOURCE:
1082 case -NFS4ERR_NOFILEHANDLE:
1083 /* Non-seqid mutating errors */
1084 return;
1085 };
1086 /*
1087 * Note: no locking needed as we are guaranteed to be first
1088 * on the sequence list
1089 */
1090 seqid->sequence->counter++;
1091 }
1092
1093 void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1094 {
1095 struct nfs4_state_owner *sp;
1096
1097 if (seqid == NULL)
1098 return;
1099
1100 sp = container_of(seqid->sequence, struct nfs4_state_owner, so_seqid);
1101 if (status == -NFS4ERR_BAD_SEQID)
1102 nfs4_drop_state_owner(sp);
1103 if (!nfs4_has_session(sp->so_server->nfs_client))
1104 nfs_increment_seqid(status, seqid);
1105 }
1106
1107 /*
1108 * Increment the seqid if the LOCK/LOCKU succeeded, or
1109 * failed with a seqid incrementing error -
1110 * see comments nfs4.h:seqid_mutating_error()
1111 */
1112 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1113 {
1114 if (seqid != NULL)
1115 nfs_increment_seqid(status, seqid);
1116 }
1117
1118 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1119 {
1120 struct nfs_seqid_counter *sequence;
1121 int status = 0;
1122
1123 if (seqid == NULL)
1124 goto out;
1125 sequence = seqid->sequence;
1126 spin_lock(&sequence->lock);
1127 seqid->task = task;
1128 if (list_empty(&seqid->list))
1129 list_add_tail(&seqid->list, &sequence->list);
1130 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1131 goto unlock;
1132 rpc_sleep_on(&sequence->wait, task, NULL);
1133 status = -EAGAIN;
1134 unlock:
1135 spin_unlock(&sequence->lock);
1136 out:
1137 return status;
1138 }
1139
1140 static int nfs4_run_state_manager(void *);
1141
1142 static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1143 {
1144 smp_mb__before_atomic();
1145 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1146 smp_mb__after_atomic();
1147 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
1148 rpc_wake_up(&clp->cl_rpcwaitq);
1149 }
1150
1151 /*
1152 * Schedule the nfs_client asynchronous state management routine
1153 */
1154 void nfs4_schedule_state_manager(struct nfs_client *clp)
1155 {
1156 struct task_struct *task;
1157 char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1158
1159 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1160 return;
1161 __module_get(THIS_MODULE);
1162 atomic_inc(&clp->cl_count);
1163
1164 /* The rcu_read_lock() is not strictly necessary, as the state
1165 * manager is the only thread that ever changes the rpc_xprt
1166 * after it's initialized. At this point, we're single threaded. */
1167 rcu_read_lock();
1168 snprintf(buf, sizeof(buf), "%s-manager",
1169 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1170 rcu_read_unlock();
1171 task = kthread_run(nfs4_run_state_manager, clp, "%s", buf);
1172 if (IS_ERR(task)) {
1173 printk(KERN_ERR "%s: kthread_run: %ld\n",
1174 __func__, PTR_ERR(task));
1175 nfs4_clear_state_manager_bit(clp);
1176 nfs_put_client(clp);
1177 module_put(THIS_MODULE);
1178 }
1179 }
1180
1181 /*
1182 * Schedule a lease recovery attempt
1183 */
1184 void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1185 {
1186 if (!clp)
1187 return;
1188 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1189 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1190 dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1191 clp->cl_hostname);
1192 nfs4_schedule_state_manager(clp);
1193 }
1194 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1195
1196 /**
1197 * nfs4_schedule_migration_recovery - trigger migration recovery
1198 *
1199 * @server: FSID that is migrating
1200 *
1201 * Returns zero if recovery has started, otherwise a negative NFS4ERR
1202 * value is returned.
1203 */
1204 int nfs4_schedule_migration_recovery(const struct nfs_server *server)
1205 {
1206 struct nfs_client *clp = server->nfs_client;
1207
1208 if (server->fh_expire_type != NFS4_FH_PERSISTENT) {
1209 pr_err("NFS: volatile file handles not supported (server %s)\n",
1210 clp->cl_hostname);
1211 return -NFS4ERR_IO;
1212 }
1213
1214 if (test_bit(NFS_MIG_FAILED, &server->mig_status))
1215 return -NFS4ERR_IO;
1216
1217 dprintk("%s: scheduling migration recovery for (%llx:%llx) on %s\n",
1218 __func__,
1219 (unsigned long long)server->fsid.major,
1220 (unsigned long long)server->fsid.minor,
1221 clp->cl_hostname);
1222
1223 set_bit(NFS_MIG_IN_TRANSITION,
1224 &((struct nfs_server *)server)->mig_status);
1225 set_bit(NFS4CLNT_MOVED, &clp->cl_state);
1226
1227 nfs4_schedule_state_manager(clp);
1228 return 0;
1229 }
1230 EXPORT_SYMBOL_GPL(nfs4_schedule_migration_recovery);
1231
1232 /**
1233 * nfs4_schedule_lease_moved_recovery - start lease-moved recovery
1234 *
1235 * @clp: server to check for moved leases
1236 *
1237 */
1238 void nfs4_schedule_lease_moved_recovery(struct nfs_client *clp)
1239 {
1240 dprintk("%s: scheduling lease-moved recovery for client ID %llx on %s\n",
1241 __func__, clp->cl_clientid, clp->cl_hostname);
1242
1243 set_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state);
1244 nfs4_schedule_state_manager(clp);
1245 }
1246 EXPORT_SYMBOL_GPL(nfs4_schedule_lease_moved_recovery);
1247
1248 int nfs4_wait_clnt_recover(struct nfs_client *clp)
1249 {
1250 int res;
1251
1252 might_sleep();
1253
1254 atomic_inc(&clp->cl_count);
1255 res = wait_on_bit_action(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
1256 nfs_wait_bit_killable, TASK_KILLABLE);
1257 if (res)
1258 goto out;
1259 if (clp->cl_cons_state < 0)
1260 res = clp->cl_cons_state;
1261 out:
1262 nfs_put_client(clp);
1263 return res;
1264 }
1265
1266 int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1267 {
1268 unsigned int loop;
1269 int ret;
1270
1271 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1272 ret = nfs4_wait_clnt_recover(clp);
1273 if (ret != 0)
1274 break;
1275 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1276 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1277 break;
1278 nfs4_schedule_state_manager(clp);
1279 ret = -EIO;
1280 }
1281 return ret;
1282 }
1283
1284 /*
1285 * nfs40_handle_cb_pathdown - return all delegations after NFS4ERR_CB_PATH_DOWN
1286 * @clp: client to process
1287 *
1288 * Set the NFS4CLNT_LEASE_EXPIRED state in order to force a
1289 * resend of the SETCLIENTID and hence re-establish the
1290 * callback channel. Then return all existing delegations.
1291 */
1292 static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1293 {
1294 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1295 nfs_expire_all_delegations(clp);
1296 dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1297 clp->cl_hostname);
1298 }
1299
1300 void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1301 {
1302 nfs40_handle_cb_pathdown(clp);
1303 nfs4_schedule_state_manager(clp);
1304 }
1305
1306 static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1307 {
1308
1309 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1310 /* Don't recover state that expired before the reboot */
1311 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1312 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1313 return 0;
1314 }
1315 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1316 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1317 return 1;
1318 }
1319
1320 int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1321 {
1322 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1323 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1324 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1325 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1326 return 1;
1327 }
1328
1329 int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1330 {
1331 struct nfs_client *clp = server->nfs_client;
1332
1333 if (!nfs4_valid_open_stateid(state))
1334 return -EBADF;
1335 nfs4_state_mark_reclaim_nograce(clp, state);
1336 dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1337 clp->cl_hostname);
1338 nfs4_schedule_state_manager(clp);
1339 return 0;
1340 }
1341 EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1342
1343 void nfs_inode_find_state_and_recover(struct inode *inode,
1344 const nfs4_stateid *stateid)
1345 {
1346 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1347 struct nfs_inode *nfsi = NFS_I(inode);
1348 struct nfs_open_context *ctx;
1349 struct nfs4_state *state;
1350 bool found = false;
1351
1352 spin_lock(&inode->i_lock);
1353 list_for_each_entry(ctx, &nfsi->open_files, list) {
1354 state = ctx->state;
1355 if (state == NULL)
1356 continue;
1357 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
1358 continue;
1359 if (!nfs4_stateid_match(&state->stateid, stateid))
1360 continue;
1361 nfs4_state_mark_reclaim_nograce(clp, state);
1362 found = true;
1363 }
1364 spin_unlock(&inode->i_lock);
1365 if (found)
1366 nfs4_schedule_state_manager(clp);
1367 }
1368
1369 static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
1370 {
1371 struct inode *inode = state->inode;
1372 struct nfs_inode *nfsi = NFS_I(inode);
1373 struct nfs_open_context *ctx;
1374
1375 spin_lock(&inode->i_lock);
1376 list_for_each_entry(ctx, &nfsi->open_files, list) {
1377 if (ctx->state != state)
1378 continue;
1379 set_bit(NFS_CONTEXT_BAD, &ctx->flags);
1380 }
1381 spin_unlock(&inode->i_lock);
1382 }
1383
1384 static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1385 {
1386 set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1387 nfs4_state_mark_open_context_bad(state);
1388 }
1389
1390
1391 static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1392 {
1393 struct inode *inode = state->inode;
1394 struct nfs_inode *nfsi = NFS_I(inode);
1395 struct file_lock *fl;
1396 int status = 0;
1397 struct file_lock_context *flctx = inode->i_flctx;
1398 struct list_head *list;
1399
1400 if (flctx == NULL)
1401 return 0;
1402
1403 list = &flctx->flc_posix;
1404
1405 /* Guard against delegation returns and new lock/unlock calls */
1406 down_write(&nfsi->rwsem);
1407 spin_lock(&flctx->flc_lock);
1408 restart:
1409 list_for_each_entry(fl, list, fl_list) {
1410 if (nfs_file_open_context(fl->fl_file)->state != state)
1411 continue;
1412 spin_unlock(&flctx->flc_lock);
1413 status = ops->recover_lock(state, fl);
1414 switch (status) {
1415 case 0:
1416 break;
1417 case -ESTALE:
1418 case -NFS4ERR_ADMIN_REVOKED:
1419 case -NFS4ERR_STALE_STATEID:
1420 case -NFS4ERR_BAD_STATEID:
1421 case -NFS4ERR_EXPIRED:
1422 case -NFS4ERR_NO_GRACE:
1423 case -NFS4ERR_STALE_CLIENTID:
1424 case -NFS4ERR_BADSESSION:
1425 case -NFS4ERR_BADSLOT:
1426 case -NFS4ERR_BAD_HIGH_SLOT:
1427 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1428 goto out;
1429 default:
1430 pr_err("NFS: %s: unhandled error %d\n",
1431 __func__, status);
1432 case -ENOMEM:
1433 case -NFS4ERR_DENIED:
1434 case -NFS4ERR_RECLAIM_BAD:
1435 case -NFS4ERR_RECLAIM_CONFLICT:
1436 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
1437 status = 0;
1438 }
1439 spin_lock(&flctx->flc_lock);
1440 }
1441 if (list == &flctx->flc_posix) {
1442 list = &flctx->flc_flock;
1443 goto restart;
1444 }
1445 spin_unlock(&flctx->flc_lock);
1446 out:
1447 up_write(&nfsi->rwsem);
1448 return status;
1449 }
1450
1451 static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
1452 {
1453 struct nfs4_state *state;
1454 struct nfs4_lock_state *lock;
1455 int status = 0;
1456
1457 /* Note: we rely on the sp->so_states list being ordered
1458 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
1459 * states first.
1460 * This is needed to ensure that the server won't give us any
1461 * read delegations that we have to return if, say, we are
1462 * recovering after a network partition or a reboot from a
1463 * server that doesn't support a grace period.
1464 */
1465 spin_lock(&sp->so_lock);
1466 raw_write_seqcount_begin(&sp->so_reclaim_seqcount);
1467 restart:
1468 list_for_each_entry(state, &sp->so_states, open_states) {
1469 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1470 continue;
1471 if (!nfs4_valid_open_stateid(state))
1472 continue;
1473 if (state->state == 0)
1474 continue;
1475 atomic_inc(&state->count);
1476 spin_unlock(&sp->so_lock);
1477 status = ops->recover_open(sp, state);
1478 if (status >= 0) {
1479 status = nfs4_reclaim_locks(state, ops);
1480 if (status >= 0) {
1481 if (!test_bit(NFS_DELEGATED_STATE, &state->flags)) {
1482 spin_lock(&state->state_lock);
1483 list_for_each_entry(lock, &state->lock_states, ls_locks) {
1484 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1485 pr_warn_ratelimited("NFS: "
1486 "%s: Lock reclaim "
1487 "failed!\n", __func__);
1488 }
1489 spin_unlock(&state->state_lock);
1490 }
1491 nfs4_put_open_state(state);
1492 clear_bit(NFS_STATE_RECLAIM_NOGRACE,
1493 &state->flags);
1494 spin_lock(&sp->so_lock);
1495 goto restart;
1496 }
1497 }
1498 switch (status) {
1499 default:
1500 printk(KERN_ERR "NFS: %s: unhandled error %d\n",
1501 __func__, status);
1502 case -ENOENT:
1503 case -ENOMEM:
1504 case -ESTALE:
1505 /* Open state on this file cannot be recovered */
1506 nfs4_state_mark_recovery_failed(state, status);
1507 break;
1508 case -EAGAIN:
1509 ssleep(1);
1510 case -NFS4ERR_ADMIN_REVOKED:
1511 case -NFS4ERR_STALE_STATEID:
1512 case -NFS4ERR_BAD_STATEID:
1513 case -NFS4ERR_RECLAIM_BAD:
1514 case -NFS4ERR_RECLAIM_CONFLICT:
1515 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1516 break;
1517 case -NFS4ERR_EXPIRED:
1518 case -NFS4ERR_NO_GRACE:
1519 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1520 case -NFS4ERR_STALE_CLIENTID:
1521 case -NFS4ERR_BADSESSION:
1522 case -NFS4ERR_BADSLOT:
1523 case -NFS4ERR_BAD_HIGH_SLOT:
1524 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1525 goto out_err;
1526 }
1527 nfs4_put_open_state(state);
1528 spin_lock(&sp->so_lock);
1529 goto restart;
1530 }
1531 raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1532 spin_unlock(&sp->so_lock);
1533 return 0;
1534 out_err:
1535 nfs4_put_open_state(state);
1536 spin_lock(&sp->so_lock);
1537 raw_write_seqcount_end(&sp->so_reclaim_seqcount);
1538 spin_unlock(&sp->so_lock);
1539 return status;
1540 }
1541
1542 static void nfs4_clear_open_state(struct nfs4_state *state)
1543 {
1544 struct nfs4_lock_state *lock;
1545
1546 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1547 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1548 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1549 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1550 spin_lock(&state->state_lock);
1551 list_for_each_entry(lock, &state->lock_states, ls_locks) {
1552 lock->ls_seqid.flags = 0;
1553 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1554 }
1555 spin_unlock(&state->state_lock);
1556 }
1557
1558 static void nfs4_reset_seqids(struct nfs_server *server,
1559 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1560 {
1561 struct nfs_client *clp = server->nfs_client;
1562 struct nfs4_state_owner *sp;
1563 struct rb_node *pos;
1564 struct nfs4_state *state;
1565
1566 spin_lock(&clp->cl_lock);
1567 for (pos = rb_first(&server->state_owners);
1568 pos != NULL;
1569 pos = rb_next(pos)) {
1570 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1571 sp->so_seqid.flags = 0;
1572 spin_lock(&sp->so_lock);
1573 list_for_each_entry(state, &sp->so_states, open_states) {
1574 if (mark_reclaim(clp, state))
1575 nfs4_clear_open_state(state);
1576 }
1577 spin_unlock(&sp->so_lock);
1578 }
1579 spin_unlock(&clp->cl_lock);
1580 }
1581
1582 static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1583 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1584 {
1585 struct nfs_server *server;
1586
1587 rcu_read_lock();
1588 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1589 nfs4_reset_seqids(server, mark_reclaim);
1590 rcu_read_unlock();
1591 }
1592
1593 static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1594 {
1595 /* Mark all delegations for reclaim */
1596 nfs_delegation_mark_reclaim(clp);
1597 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1598 }
1599
1600 static void nfs4_reclaim_complete(struct nfs_client *clp,
1601 const struct nfs4_state_recovery_ops *ops,
1602 struct rpc_cred *cred)
1603 {
1604 /* Notify the server we're done reclaiming our state */
1605 if (ops->reclaim_complete)
1606 (void)ops->reclaim_complete(clp, cred);
1607 }
1608
1609 static void nfs4_clear_reclaim_server(struct nfs_server *server)
1610 {
1611 struct nfs_client *clp = server->nfs_client;
1612 struct nfs4_state_owner *sp;
1613 struct rb_node *pos;
1614 struct nfs4_state *state;
1615
1616 spin_lock(&clp->cl_lock);
1617 for (pos = rb_first(&server->state_owners);
1618 pos != NULL;
1619 pos = rb_next(pos)) {
1620 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1621 spin_lock(&sp->so_lock);
1622 list_for_each_entry(state, &sp->so_states, open_states) {
1623 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1624 &state->flags))
1625 continue;
1626 nfs4_state_mark_reclaim_nograce(clp, state);
1627 }
1628 spin_unlock(&sp->so_lock);
1629 }
1630 spin_unlock(&clp->cl_lock);
1631 }
1632
1633 static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1634 {
1635 struct nfs_server *server;
1636
1637 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1638 return 0;
1639
1640 rcu_read_lock();
1641 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1642 nfs4_clear_reclaim_server(server);
1643 rcu_read_unlock();
1644
1645 nfs_delegation_reap_unclaimed(clp);
1646 return 1;
1647 }
1648
1649 static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1650 {
1651 const struct nfs4_state_recovery_ops *ops;
1652 struct rpc_cred *cred;
1653
1654 if (!nfs4_state_clear_reclaim_reboot(clp))
1655 return;
1656 ops = clp->cl_mvops->reboot_recovery_ops;
1657 cred = nfs4_get_clid_cred(clp);
1658 nfs4_reclaim_complete(clp, ops, cred);
1659 put_rpccred(cred);
1660 }
1661
1662 static void nfs_delegation_clear_all(struct nfs_client *clp)
1663 {
1664 nfs_delegation_mark_reclaim(clp);
1665 nfs_delegation_reap_unclaimed(clp);
1666 }
1667
1668 static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1669 {
1670 nfs_delegation_clear_all(clp);
1671 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1672 }
1673
1674 static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1675 {
1676 switch (error) {
1677 case 0:
1678 break;
1679 case -NFS4ERR_CB_PATH_DOWN:
1680 nfs40_handle_cb_pathdown(clp);
1681 break;
1682 case -NFS4ERR_NO_GRACE:
1683 nfs4_state_end_reclaim_reboot(clp);
1684 break;
1685 case -NFS4ERR_STALE_CLIENTID:
1686 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1687 nfs4_state_clear_reclaim_reboot(clp);
1688 nfs4_state_start_reclaim_reboot(clp);
1689 break;
1690 case -NFS4ERR_EXPIRED:
1691 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1692 nfs4_state_start_reclaim_nograce(clp);
1693 break;
1694 case -NFS4ERR_BADSESSION:
1695 case -NFS4ERR_BADSLOT:
1696 case -NFS4ERR_BAD_HIGH_SLOT:
1697 case -NFS4ERR_DEADSESSION:
1698 case -NFS4ERR_SEQ_FALSE_RETRY:
1699 case -NFS4ERR_SEQ_MISORDERED:
1700 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1701 /* Zero session reset errors */
1702 break;
1703 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1704 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1705 break;
1706 default:
1707 dprintk("%s: failed to handle error %d for server %s\n",
1708 __func__, error, clp->cl_hostname);
1709 return error;
1710 }
1711 dprintk("%s: handled error %d for server %s\n", __func__, error,
1712 clp->cl_hostname);
1713 return 0;
1714 }
1715
1716 static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1717 {
1718 struct nfs4_state_owner *sp;
1719 struct nfs_server *server;
1720 struct rb_node *pos;
1721 int status = 0;
1722
1723 restart:
1724 rcu_read_lock();
1725 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1726 nfs4_purge_state_owners(server);
1727 spin_lock(&clp->cl_lock);
1728 for (pos = rb_first(&server->state_owners);
1729 pos != NULL;
1730 pos = rb_next(pos)) {
1731 sp = rb_entry(pos,
1732 struct nfs4_state_owner, so_server_node);
1733 if (!test_and_clear_bit(ops->owner_flag_bit,
1734 &sp->so_flags))
1735 continue;
1736 if (!atomic_inc_not_zero(&sp->so_count))
1737 continue;
1738 spin_unlock(&clp->cl_lock);
1739 rcu_read_unlock();
1740
1741 status = nfs4_reclaim_open_state(sp, ops);
1742 if (status < 0) {
1743 set_bit(ops->owner_flag_bit, &sp->so_flags);
1744 nfs4_put_state_owner(sp);
1745 status = nfs4_recovery_handle_error(clp, status);
1746 return (status != 0) ? status : -EAGAIN;
1747 }
1748
1749 nfs4_put_state_owner(sp);
1750 goto restart;
1751 }
1752 spin_unlock(&clp->cl_lock);
1753 }
1754 rcu_read_unlock();
1755 return 0;
1756 }
1757
1758 static int nfs4_check_lease(struct nfs_client *clp)
1759 {
1760 struct rpc_cred *cred;
1761 const struct nfs4_state_maintenance_ops *ops =
1762 clp->cl_mvops->state_renewal_ops;
1763 int status;
1764
1765 /* Is the client already known to have an expired lease? */
1766 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1767 return 0;
1768 spin_lock(&clp->cl_lock);
1769 cred = ops->get_state_renewal_cred_locked(clp);
1770 spin_unlock(&clp->cl_lock);
1771 if (cred == NULL) {
1772 cred = nfs4_get_clid_cred(clp);
1773 status = -ENOKEY;
1774 if (cred == NULL)
1775 goto out;
1776 }
1777 status = ops->renew_lease(clp, cred);
1778 put_rpccred(cred);
1779 if (status == -ETIMEDOUT) {
1780 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1781 return 0;
1782 }
1783 out:
1784 return nfs4_recovery_handle_error(clp, status);
1785 }
1786
1787 /* Set NFS4CLNT_LEASE_EXPIRED and reclaim reboot state for all v4.0 errors
1788 * and for recoverable errors on EXCHANGE_ID for v4.1
1789 */
1790 static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1791 {
1792 switch (status) {
1793 case -NFS4ERR_SEQ_MISORDERED:
1794 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
1795 return -ESERVERFAULT;
1796 /* Lease confirmation error: retry after purging the lease */
1797 ssleep(1);
1798 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1799 break;
1800 case -NFS4ERR_STALE_CLIENTID:
1801 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1802 nfs4_state_start_reclaim_reboot(clp);
1803 break;
1804 case -NFS4ERR_CLID_INUSE:
1805 pr_err("NFS: Server %s reports our clientid is in use\n",
1806 clp->cl_hostname);
1807 nfs_mark_client_ready(clp, -EPERM);
1808 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1809 return -EPERM;
1810 case -EACCES:
1811 case -NFS4ERR_DELAY:
1812 case -ETIMEDOUT:
1813 case -EAGAIN:
1814 ssleep(1);
1815 break;
1816
1817 case -NFS4ERR_MINOR_VERS_MISMATCH:
1818 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
1819 nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
1820 dprintk("%s: exit with error %d for server %s\n",
1821 __func__, -EPROTONOSUPPORT, clp->cl_hostname);
1822 return -EPROTONOSUPPORT;
1823 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
1824 * in nfs4_exchange_id */
1825 default:
1826 dprintk("%s: exit with error %d for server %s\n", __func__,
1827 status, clp->cl_hostname);
1828 return status;
1829 }
1830 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1831 dprintk("%s: handled error %d for server %s\n", __func__, status,
1832 clp->cl_hostname);
1833 return 0;
1834 }
1835
1836 static int nfs4_establish_lease(struct nfs_client *clp)
1837 {
1838 struct rpc_cred *cred;
1839 const struct nfs4_state_recovery_ops *ops =
1840 clp->cl_mvops->reboot_recovery_ops;
1841 int status;
1842
1843 nfs4_begin_drain_session(clp);
1844 cred = nfs4_get_clid_cred(clp);
1845 if (cred == NULL)
1846 return -ENOENT;
1847 status = ops->establish_clid(clp, cred);
1848 put_rpccred(cred);
1849 if (status != 0)
1850 return status;
1851 pnfs_destroy_all_layouts(clp);
1852 return 0;
1853 }
1854
1855 /*
1856 * Returns zero or a negative errno. NFS4ERR values are converted
1857 * to local errno values.
1858 */
1859 static int nfs4_reclaim_lease(struct nfs_client *clp)
1860 {
1861 int status;
1862
1863 status = nfs4_establish_lease(clp);
1864 if (status < 0)
1865 return nfs4_handle_reclaim_lease_error(clp, status);
1866 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
1867 nfs4_state_start_reclaim_nograce(clp);
1868 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1869 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1870 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1871 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1872 return 0;
1873 }
1874
1875 static int nfs4_purge_lease(struct nfs_client *clp)
1876 {
1877 int status;
1878
1879 status = nfs4_establish_lease(clp);
1880 if (status < 0)
1881 return nfs4_handle_reclaim_lease_error(clp, status);
1882 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1883 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1884 nfs4_state_start_reclaim_nograce(clp);
1885 return 0;
1886 }
1887
1888 /*
1889 * Try remote migration of one FSID from a source server to a
1890 * destination server. The source server provides a list of
1891 * potential destinations.
1892 *
1893 * Returns zero or a negative NFS4ERR status code.
1894 */
1895 static int nfs4_try_migration(struct nfs_server *server, struct rpc_cred *cred)
1896 {
1897 struct nfs_client *clp = server->nfs_client;
1898 struct nfs4_fs_locations *locations = NULL;
1899 struct inode *inode;
1900 struct page *page;
1901 int status, result;
1902
1903 dprintk("--> %s: FSID %llx:%llx on \"%s\"\n", __func__,
1904 (unsigned long long)server->fsid.major,
1905 (unsigned long long)server->fsid.minor,
1906 clp->cl_hostname);
1907
1908 result = 0;
1909 page = alloc_page(GFP_KERNEL);
1910 locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
1911 if (page == NULL || locations == NULL) {
1912 dprintk("<-- %s: no memory\n", __func__);
1913 goto out;
1914 }
1915
1916 inode = d_inode(server->super->s_root);
1917 result = nfs4_proc_get_locations(inode, locations, page, cred);
1918 if (result) {
1919 dprintk("<-- %s: failed to retrieve fs_locations: %d\n",
1920 __func__, result);
1921 goto out;
1922 }
1923
1924 result = -NFS4ERR_NXIO;
1925 if (!(locations->fattr.valid & NFS_ATTR_FATTR_V4_LOCATIONS)) {
1926 dprintk("<-- %s: No fs_locations data, migration skipped\n",
1927 __func__);
1928 goto out;
1929 }
1930
1931 nfs4_begin_drain_session(clp);
1932
1933 status = nfs4_replace_transport(server, locations);
1934 if (status != 0) {
1935 dprintk("<-- %s: failed to replace transport: %d\n",
1936 __func__, status);
1937 goto out;
1938 }
1939
1940 result = 0;
1941 dprintk("<-- %s: migration succeeded\n", __func__);
1942
1943 out:
1944 if (page != NULL)
1945 __free_page(page);
1946 kfree(locations);
1947 if (result) {
1948 pr_err("NFS: migration recovery failed (server %s)\n",
1949 clp->cl_hostname);
1950 set_bit(NFS_MIG_FAILED, &server->mig_status);
1951 }
1952 return result;
1953 }
1954
1955 /*
1956 * Returns zero or a negative NFS4ERR status code.
1957 */
1958 static int nfs4_handle_migration(struct nfs_client *clp)
1959 {
1960 const struct nfs4_state_maintenance_ops *ops =
1961 clp->cl_mvops->state_renewal_ops;
1962 struct nfs_server *server;
1963 struct rpc_cred *cred;
1964
1965 dprintk("%s: migration reported on \"%s\"\n", __func__,
1966 clp->cl_hostname);
1967
1968 spin_lock(&clp->cl_lock);
1969 cred = ops->get_state_renewal_cred_locked(clp);
1970 spin_unlock(&clp->cl_lock);
1971 if (cred == NULL)
1972 return -NFS4ERR_NOENT;
1973
1974 clp->cl_mig_gen++;
1975 restart:
1976 rcu_read_lock();
1977 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1978 int status;
1979
1980 if (server->mig_gen == clp->cl_mig_gen)
1981 continue;
1982 server->mig_gen = clp->cl_mig_gen;
1983
1984 if (!test_and_clear_bit(NFS_MIG_IN_TRANSITION,
1985 &server->mig_status))
1986 continue;
1987
1988 rcu_read_unlock();
1989 status = nfs4_try_migration(server, cred);
1990 if (status < 0) {
1991 put_rpccred(cred);
1992 return status;
1993 }
1994 goto restart;
1995 }
1996 rcu_read_unlock();
1997 put_rpccred(cred);
1998 return 0;
1999 }
2000
2001 /*
2002 * Test each nfs_server on the clp's cl_superblocks list to see
2003 * if it's moved to another server. Stop when the server no longer
2004 * returns NFS4ERR_LEASE_MOVED.
2005 */
2006 static int nfs4_handle_lease_moved(struct nfs_client *clp)
2007 {
2008 const struct nfs4_state_maintenance_ops *ops =
2009 clp->cl_mvops->state_renewal_ops;
2010 struct nfs_server *server;
2011 struct rpc_cred *cred;
2012
2013 dprintk("%s: lease moved reported on \"%s\"\n", __func__,
2014 clp->cl_hostname);
2015
2016 spin_lock(&clp->cl_lock);
2017 cred = ops->get_state_renewal_cred_locked(clp);
2018 spin_unlock(&clp->cl_lock);
2019 if (cred == NULL)
2020 return -NFS4ERR_NOENT;
2021
2022 clp->cl_mig_gen++;
2023 restart:
2024 rcu_read_lock();
2025 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
2026 struct inode *inode;
2027 int status;
2028
2029 if (server->mig_gen == clp->cl_mig_gen)
2030 continue;
2031 server->mig_gen = clp->cl_mig_gen;
2032
2033 rcu_read_unlock();
2034
2035 inode = d_inode(server->super->s_root);
2036 status = nfs4_proc_fsid_present(inode, cred);
2037 if (status != -NFS4ERR_MOVED)
2038 goto restart; /* wasn't this one */
2039 if (nfs4_try_migration(server, cred) == -NFS4ERR_LEASE_MOVED)
2040 goto restart; /* there are more */
2041 goto out;
2042 }
2043 rcu_read_unlock();
2044
2045 out:
2046 put_rpccred(cred);
2047 return 0;
2048 }
2049
2050 /**
2051 * nfs4_discover_server_trunking - Detect server IP address trunking
2052 *
2053 * @clp: nfs_client under test
2054 * @result: OUT: found nfs_client, or clp
2055 *
2056 * Returns zero or a negative errno. If zero is returned,
2057 * an nfs_client pointer is planted in "result".
2058 *
2059 * Note: since we are invoked in process context, and
2060 * not from inside the state manager, we cannot use
2061 * nfs4_handle_reclaim_lease_error().
2062 */
2063 int nfs4_discover_server_trunking(struct nfs_client *clp,
2064 struct nfs_client **result)
2065 {
2066 const struct nfs4_state_recovery_ops *ops =
2067 clp->cl_mvops->reboot_recovery_ops;
2068 struct rpc_clnt *clnt;
2069 struct rpc_cred *cred;
2070 int i, status;
2071
2072 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
2073
2074 clnt = clp->cl_rpcclient;
2075 i = 0;
2076
2077 mutex_lock(&nfs_clid_init_mutex);
2078 again:
2079 status = -ENOENT;
2080 cred = nfs4_get_clid_cred(clp);
2081 if (cred == NULL)
2082 goto out_unlock;
2083
2084 status = ops->detect_trunking(clp, result, cred);
2085 put_rpccred(cred);
2086 switch (status) {
2087 case 0:
2088 break;
2089 case -ETIMEDOUT:
2090 if (clnt->cl_softrtry)
2091 break;
2092 case -NFS4ERR_DELAY:
2093 case -EAGAIN:
2094 ssleep(1);
2095 case -NFS4ERR_STALE_CLIENTID:
2096 dprintk("NFS: %s after status %d, retrying\n",
2097 __func__, status);
2098 goto again;
2099 case -EACCES:
2100 if (i++ == 0) {
2101 nfs4_root_machine_cred(clp);
2102 goto again;
2103 }
2104 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX)
2105 break;
2106 case -NFS4ERR_CLID_INUSE:
2107 case -NFS4ERR_WRONGSEC:
2108 /* No point in retrying if we already used RPC_AUTH_UNIX */
2109 if (clnt->cl_auth->au_flavor == RPC_AUTH_UNIX) {
2110 status = -EPERM;
2111 break;
2112 }
2113 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
2114 if (IS_ERR(clnt)) {
2115 status = PTR_ERR(clnt);
2116 break;
2117 }
2118 /* Note: this is safe because we haven't yet marked the
2119 * client as ready, so we are the only user of
2120 * clp->cl_rpcclient
2121 */
2122 clnt = xchg(&clp->cl_rpcclient, clnt);
2123 rpc_shutdown_client(clnt);
2124 clnt = clp->cl_rpcclient;
2125 goto again;
2126
2127 case -NFS4ERR_MINOR_VERS_MISMATCH:
2128 status = -EPROTONOSUPPORT;
2129 break;
2130
2131 case -EKEYEXPIRED:
2132 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
2133 * in nfs4_exchange_id */
2134 status = -EKEYEXPIRED;
2135 break;
2136 default:
2137 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
2138 __func__, status);
2139 status = -EIO;
2140 }
2141
2142 out_unlock:
2143 mutex_unlock(&nfs_clid_init_mutex);
2144 dprintk("NFS: %s: status = %d\n", __func__, status);
2145 return status;
2146 }
2147
2148 #ifdef CONFIG_NFS_V4_1
2149 void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
2150 {
2151 struct nfs_client *clp = session->clp;
2152
2153 switch (err) {
2154 default:
2155 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2156 break;
2157 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
2158 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2159 }
2160 nfs4_schedule_lease_recovery(clp);
2161 }
2162 EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
2163
2164 void nfs41_notify_server(struct nfs_client *clp)
2165 {
2166 /* Use CHECK_LEASE to ping the server with a SEQUENCE */
2167 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
2168 nfs4_schedule_state_manager(clp);
2169 }
2170
2171 static void nfs4_reset_all_state(struct nfs_client *clp)
2172 {
2173 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2174 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
2175 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
2176 nfs4_state_start_reclaim_nograce(clp);
2177 dprintk("%s: scheduling reset of all state for server %s!\n",
2178 __func__, clp->cl_hostname);
2179 nfs4_schedule_state_manager(clp);
2180 }
2181 }
2182
2183 static void nfs41_handle_server_reboot(struct nfs_client *clp)
2184 {
2185 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
2186 nfs4_state_start_reclaim_reboot(clp);
2187 dprintk("%s: server %s rebooted!\n", __func__,
2188 clp->cl_hostname);
2189 nfs4_schedule_state_manager(clp);
2190 }
2191 }
2192
2193 static void nfs41_handle_all_state_revoked(struct nfs_client *clp)
2194 {
2195 nfs4_reset_all_state(clp);
2196 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2197 }
2198
2199 static void nfs41_handle_some_state_revoked(struct nfs_client *clp)
2200 {
2201 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
2202 nfs4_schedule_state_manager(clp);
2203
2204 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
2205 }
2206
2207 static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
2208 {
2209 /* FIXME: For now, we destroy all layouts. */
2210 pnfs_destroy_all_layouts(clp);
2211 /* FIXME: For now, we test all delegations+open state+locks. */
2212 nfs41_handle_some_state_revoked(clp);
2213 dprintk("%s: Recallable state revoked on server %s!\n", __func__,
2214 clp->cl_hostname);
2215 }
2216
2217 static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2218 {
2219 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2220 nfs4_schedule_state_manager(clp);
2221
2222 dprintk("%s: server %s declared a backchannel fault\n", __func__,
2223 clp->cl_hostname);
2224 }
2225
2226 static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2227 {
2228 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2229 &clp->cl_state) == 0)
2230 nfs4_schedule_state_manager(clp);
2231 }
2232
2233 void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
2234 {
2235 if (!flags)
2236 return;
2237
2238 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2239 __func__, clp->cl_hostname, clp->cl_clientid, flags);
2240
2241 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2242 nfs41_handle_server_reboot(clp);
2243 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED))
2244 nfs41_handle_all_state_revoked(clp);
2245 if (flags & (SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2246 SEQ4_STATUS_ADMIN_STATE_REVOKED))
2247 nfs41_handle_some_state_revoked(clp);
2248 if (flags & SEQ4_STATUS_LEASE_MOVED)
2249 nfs4_schedule_lease_moved_recovery(clp);
2250 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2251 nfs41_handle_recallable_state_revoked(clp);
2252 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2253 nfs41_handle_backchannel_fault(clp);
2254 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2255 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2256 nfs41_handle_cb_path_down(clp);
2257 }
2258
2259 static int nfs4_reset_session(struct nfs_client *clp)
2260 {
2261 struct rpc_cred *cred;
2262 int status;
2263
2264 if (!nfs4_has_session(clp))
2265 return 0;
2266 nfs4_begin_drain_session(clp);
2267 cred = nfs4_get_clid_cred(clp);
2268 status = nfs4_proc_destroy_session(clp->cl_session, cred);
2269 switch (status) {
2270 case 0:
2271 case -NFS4ERR_BADSESSION:
2272 case -NFS4ERR_DEADSESSION:
2273 break;
2274 case -NFS4ERR_BACK_CHAN_BUSY:
2275 case -NFS4ERR_DELAY:
2276 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2277 status = 0;
2278 ssleep(1);
2279 goto out;
2280 default:
2281 status = nfs4_recovery_handle_error(clp, status);
2282 goto out;
2283 }
2284
2285 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2286 status = nfs4_proc_create_session(clp, cred);
2287 if (status) {
2288 dprintk("%s: session reset failed with status %d for server %s!\n",
2289 __func__, status, clp->cl_hostname);
2290 status = nfs4_handle_reclaim_lease_error(clp, status);
2291 goto out;
2292 }
2293 nfs41_finish_session_reset(clp);
2294 dprintk("%s: session reset was successful for server %s!\n",
2295 __func__, clp->cl_hostname);
2296 out:
2297 if (cred)
2298 put_rpccred(cred);
2299 return status;
2300 }
2301
2302 static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2303 {
2304 struct rpc_cred *cred;
2305 int ret;
2306
2307 if (!nfs4_has_session(clp))
2308 return 0;
2309 nfs4_begin_drain_session(clp);
2310 cred = nfs4_get_clid_cred(clp);
2311 ret = nfs4_proc_bind_conn_to_session(clp, cred);
2312 if (cred)
2313 put_rpccred(cred);
2314 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2315 switch (ret) {
2316 case 0:
2317 dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2318 __func__, clp->cl_hostname);
2319 break;
2320 case -NFS4ERR_DELAY:
2321 ssleep(1);
2322 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2323 break;
2324 default:
2325 return nfs4_recovery_handle_error(clp, ret);
2326 }
2327 return 0;
2328 }
2329 #else /* CONFIG_NFS_V4_1 */
2330 static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2331
2332 static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2333 {
2334 return 0;
2335 }
2336 #endif /* CONFIG_NFS_V4_1 */
2337
2338 static void nfs4_state_manager(struct nfs_client *clp)
2339 {
2340 int status = 0;
2341 const char *section = "", *section_sep = "";
2342
2343 /* Ensure exclusive access to NFSv4 state */
2344 do {
2345 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2346 section = "purge state";
2347 status = nfs4_purge_lease(clp);
2348 if (status < 0)
2349 goto out_error;
2350 continue;
2351 }
2352
2353 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2354 section = "lease expired";
2355 /* We're going to have to re-establish a clientid */
2356 status = nfs4_reclaim_lease(clp);
2357 if (status < 0)
2358 goto out_error;
2359 continue;
2360 }
2361
2362 /* Initialize or reset the session */
2363 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2364 section = "reset session";
2365 status = nfs4_reset_session(clp);
2366 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2367 continue;
2368 if (status < 0)
2369 goto out_error;
2370 }
2371
2372 /* Send BIND_CONN_TO_SESSION */
2373 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2374 &clp->cl_state)) {
2375 section = "bind conn to session";
2376 status = nfs4_bind_conn_to_session(clp);
2377 if (status < 0)
2378 goto out_error;
2379 continue;
2380 }
2381
2382 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2383 section = "check lease";
2384 status = nfs4_check_lease(clp);
2385 if (status < 0)
2386 goto out_error;
2387 continue;
2388 }
2389
2390 if (test_and_clear_bit(NFS4CLNT_MOVED, &clp->cl_state)) {
2391 section = "migration";
2392 status = nfs4_handle_migration(clp);
2393 if (status < 0)
2394 goto out_error;
2395 }
2396
2397 if (test_and_clear_bit(NFS4CLNT_LEASE_MOVED, &clp->cl_state)) {
2398 section = "lease moved";
2399 status = nfs4_handle_lease_moved(clp);
2400 if (status < 0)
2401 goto out_error;
2402 }
2403
2404 /* First recover reboot state... */
2405 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2406 section = "reclaim reboot";
2407 status = nfs4_do_reclaim(clp,
2408 clp->cl_mvops->reboot_recovery_ops);
2409 if (status == -EAGAIN)
2410 continue;
2411 if (status < 0)
2412 goto out_error;
2413 nfs4_state_end_reclaim_reboot(clp);
2414 }
2415
2416 /* Now recover expired state... */
2417 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2418 section = "reclaim nograce";
2419 status = nfs4_do_reclaim(clp,
2420 clp->cl_mvops->nograce_recovery_ops);
2421 if (status == -EAGAIN)
2422 continue;
2423 if (status < 0)
2424 goto out_error;
2425 }
2426
2427 nfs4_end_drain_session(clp);
2428 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2429 nfs_client_return_marked_delegations(clp);
2430 continue;
2431 }
2432
2433 nfs4_clear_state_manager_bit(clp);
2434 /* Did we race with an attempt to give us more work? */
2435 if (clp->cl_state == 0)
2436 break;
2437 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2438 break;
2439 } while (atomic_read(&clp->cl_count) > 1);
2440 return;
2441 out_error:
2442 if (strlen(section))
2443 section_sep = ": ";
2444 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2445 " with error %d\n", section_sep, section,
2446 clp->cl_hostname, -status);
2447 ssleep(1);
2448 nfs4_end_drain_session(clp);
2449 nfs4_clear_state_manager_bit(clp);
2450 }
2451
2452 static int nfs4_run_state_manager(void *ptr)
2453 {
2454 struct nfs_client *clp = ptr;
2455
2456 allow_signal(SIGKILL);
2457 nfs4_state_manager(clp);
2458 nfs_put_client(clp);
2459 module_put_and_exit(0);
2460 return 0;
2461 }
2462
2463 /*
2464 * Local variables:
2465 * c-basic-offset: 8
2466 * End:
2467 */
Linux with added FPC-III support