1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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/nfs_idmap.h>
46#include <linux/kthread.h>
47#include <linux/module.h>
48#include <linux/random.h>
49#include <linux/ratelimit.h>
50#include <linux/workqueue.h>
51#include <linux/bitops.h>
52#include <linux/jiffies.h>
53
54#include <linux/sunrpc/clnt.h>
55
56#include "nfs4_fs.h"
57#include "callback.h"
58#include "delegation.h"
59#include "internal.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
68const nfs4_stateid zero_stateid;
69static DEFINE_MUTEX(nfs_clid_init_mutex);
70
71int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
72{
73 struct nfs4_setclientid_res clid = {
74 .clientid = clp->cl_clientid,
75 .confirm = clp->cl_confirm,
76 };
77 unsigned short port;
78 int status;
79 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
80
81 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
82 goto do_confirm;
83 port = nn->nfs_callback_tcpport;
84 if (clp->cl_addr.ss_family == AF_INET6)
85 port = nn->nfs_callback_tcpport6;
86
87 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
88 if (status != 0)
89 goto out;
90 clp->cl_clientid = clid.clientid;
91 clp->cl_confirm = clid.confirm;
92 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
93do_confirm:
94 status = nfs4_proc_setclientid_confirm(clp, &clid, cred);
95 if (status != 0)
96 goto out;
97 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
98 nfs4_schedule_state_renewal(clp);
99out:
100 return status;
101}
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116int nfs40_discover_server_trunking(struct nfs_client *clp,
117 struct nfs_client **result,
118 struct rpc_cred *cred)
119{
120 struct nfs4_setclientid_res clid = {
121 .clientid = clp->cl_clientid,
122 .confirm = clp->cl_confirm,
123 };
124 struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
125 unsigned short port;
126 int status;
127
128 port = nn->nfs_callback_tcpport;
129 if (clp->cl_addr.ss_family == AF_INET6)
130 port = nn->nfs_callback_tcpport6;
131
132 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred, &clid);
133 if (status != 0)
134 goto out;
135 clp->cl_clientid = clid.clientid;
136 clp->cl_confirm = clid.confirm;
137
138 status = nfs40_walk_client_list(clp, result, cred);
139 if (status == 0) {
140
141
142 nfs4_schedule_state_renewal(*result);
143 }
144out:
145 return status;
146}
147
148struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
149{
150 struct rpc_cred *cred = NULL;
151
152 if (clp->cl_machine_cred != NULL)
153 cred = get_rpccred(clp->cl_machine_cred);
154 return cred;
155}
156
157static struct rpc_cred *
158nfs4_get_renew_cred_server_locked(struct nfs_server *server)
159{
160 struct rpc_cred *cred = NULL;
161 struct nfs4_state_owner *sp;
162 struct rb_node *pos;
163
164 for (pos = rb_first(&server->state_owners);
165 pos != NULL;
166 pos = rb_next(pos)) {
167 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
168 if (list_empty(&sp->so_states))
169 continue;
170 cred = get_rpccred(sp->so_cred);
171 break;
172 }
173 return cred;
174}
175
176
177
178
179
180
181
182
183struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
184{
185 struct rpc_cred *cred = NULL;
186 struct nfs_server *server;
187
188
189 cred = nfs4_get_machine_cred_locked(clp);
190 if (cred != NULL)
191 goto out;
192
193 rcu_read_lock();
194 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
195 cred = nfs4_get_renew_cred_server_locked(server);
196 if (cred != NULL)
197 break;
198 }
199 rcu_read_unlock();
200
201out:
202 return cred;
203}
204
205#if defined(CONFIG_NFS_V4_1)
206
207static int nfs41_setup_state_renewal(struct nfs_client *clp)
208{
209 int status;
210 struct nfs_fsinfo fsinfo;
211
212 if (!test_bit(NFS_CS_CHECK_LEASE_TIME, &clp->cl_res_state)) {
213 nfs4_schedule_state_renewal(clp);
214 return 0;
215 }
216
217 status = nfs4_proc_get_lease_time(clp, &fsinfo);
218 if (status == 0) {
219
220 spin_lock(&clp->cl_lock);
221 clp->cl_lease_time = fsinfo.lease_time * HZ;
222 clp->cl_last_renewal = jiffies;
223 spin_unlock(&clp->cl_lock);
224
225 nfs4_schedule_state_renewal(clp);
226 }
227
228 return status;
229}
230
231
232
233
234
235
236static void nfs4_end_drain_session(struct nfs_client *clp)
237{
238 struct nfs4_session *ses = clp->cl_session;
239 struct nfs4_slot_table *tbl;
240
241 if (ses == NULL)
242 return;
243 tbl = &ses->fc_slot_table;
244 if (test_and_clear_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state)) {
245 spin_lock(&tbl->slot_tbl_lock);
246 nfs41_wake_slot_table(tbl);
247 spin_unlock(&tbl->slot_tbl_lock);
248 }
249}
250
251
252
253
254void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl)
255{
256 if (nfs4_slot_tbl_draining(tbl))
257 complete(&tbl->complete);
258}
259
260static int nfs4_drain_slot_tbl(struct nfs4_slot_table *tbl)
261{
262 set_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state);
263 spin_lock(&tbl->slot_tbl_lock);
264 if (tbl->highest_used_slotid != NFS4_NO_SLOT) {
265 INIT_COMPLETION(tbl->complete);
266 spin_unlock(&tbl->slot_tbl_lock);
267 return wait_for_completion_interruptible(&tbl->complete);
268 }
269 spin_unlock(&tbl->slot_tbl_lock);
270 return 0;
271}
272
273static int nfs4_begin_drain_session(struct nfs_client *clp)
274{
275 struct nfs4_session *ses = clp->cl_session;
276 int ret = 0;
277
278
279 ret = nfs4_drain_slot_tbl(&ses->bc_slot_table);
280 if (ret)
281 return ret;
282
283 return nfs4_drain_slot_tbl(&ses->fc_slot_table);
284}
285
286static void nfs41_finish_session_reset(struct nfs_client *clp)
287{
288 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
289 clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
290
291 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
292 nfs41_setup_state_renewal(clp);
293}
294
295int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
296{
297 int status;
298
299 if (test_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state))
300 goto do_confirm;
301 nfs4_begin_drain_session(clp);
302 status = nfs4_proc_exchange_id(clp, cred);
303 if (status != 0)
304 goto out;
305 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
306do_confirm:
307 status = nfs4_proc_create_session(clp, cred);
308 if (status != 0)
309 goto out;
310 nfs41_finish_session_reset(clp);
311 nfs_mark_client_ready(clp, NFS_CS_READY);
312out:
313 return status;
314}
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329int nfs41_discover_server_trunking(struct nfs_client *clp,
330 struct nfs_client **result,
331 struct rpc_cred *cred)
332{
333 int status;
334
335 status = nfs4_proc_exchange_id(clp, cred);
336 if (status != NFS4_OK)
337 return status;
338 set_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
339
340 return nfs41_walk_client_list(clp, result, cred);
341}
342
343struct rpc_cred *nfs4_get_exchange_id_cred(struct nfs_client *clp)
344{
345 struct rpc_cred *cred;
346
347 spin_lock(&clp->cl_lock);
348 cred = nfs4_get_machine_cred_locked(clp);
349 spin_unlock(&clp->cl_lock);
350 return cred;
351}
352
353#endif
354
355static struct rpc_cred *
356nfs4_get_setclientid_cred_server(struct nfs_server *server)
357{
358 struct nfs_client *clp = server->nfs_client;
359 struct rpc_cred *cred = NULL;
360 struct nfs4_state_owner *sp;
361 struct rb_node *pos;
362
363 spin_lock(&clp->cl_lock);
364 pos = rb_first(&server->state_owners);
365 if (pos != NULL) {
366 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
367 cred = get_rpccred(sp->so_cred);
368 }
369 spin_unlock(&clp->cl_lock);
370 return cred;
371}
372
373
374
375
376
377
378
379struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
380{
381 struct nfs_server *server;
382 struct rpc_cred *cred;
383
384 spin_lock(&clp->cl_lock);
385 cred = nfs4_get_machine_cred_locked(clp);
386 spin_unlock(&clp->cl_lock);
387 if (cred != NULL)
388 goto out;
389
390 rcu_read_lock();
391 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
392 cred = nfs4_get_setclientid_cred_server(server);
393 if (cred != NULL)
394 break;
395 }
396 rcu_read_unlock();
397
398out:
399 return cred;
400}
401
402static struct nfs4_state_owner *
403nfs4_find_state_owner_locked(struct nfs_server *server, struct rpc_cred *cred)
404{
405 struct rb_node **p = &server->state_owners.rb_node,
406 *parent = NULL;
407 struct nfs4_state_owner *sp;
408
409 while (*p != NULL) {
410 parent = *p;
411 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
412
413 if (cred < sp->so_cred)
414 p = &parent->rb_left;
415 else if (cred > sp->so_cred)
416 p = &parent->rb_right;
417 else {
418 if (!list_empty(&sp->so_lru))
419 list_del_init(&sp->so_lru);
420 atomic_inc(&sp->so_count);
421 return sp;
422 }
423 }
424 return NULL;
425}
426
427static struct nfs4_state_owner *
428nfs4_insert_state_owner_locked(struct nfs4_state_owner *new)
429{
430 struct nfs_server *server = new->so_server;
431 struct rb_node **p = &server->state_owners.rb_node,
432 *parent = NULL;
433 struct nfs4_state_owner *sp;
434 int err;
435
436 while (*p != NULL) {
437 parent = *p;
438 sp = rb_entry(parent, struct nfs4_state_owner, so_server_node);
439
440 if (new->so_cred < sp->so_cred)
441 p = &parent->rb_left;
442 else if (new->so_cred > sp->so_cred)
443 p = &parent->rb_right;
444 else {
445 if (!list_empty(&sp->so_lru))
446 list_del_init(&sp->so_lru);
447 atomic_inc(&sp->so_count);
448 return sp;
449 }
450 }
451 err = ida_get_new(&server->openowner_id, &new->so_seqid.owner_id);
452 if (err)
453 return ERR_PTR(err);
454 rb_link_node(&new->so_server_node, parent, p);
455 rb_insert_color(&new->so_server_node, &server->state_owners);
456 return new;
457}
458
459static void
460nfs4_remove_state_owner_locked(struct nfs4_state_owner *sp)
461{
462 struct nfs_server *server = sp->so_server;
463
464 if (!RB_EMPTY_NODE(&sp->so_server_node))
465 rb_erase(&sp->so_server_node, &server->state_owners);
466 ida_remove(&server->openowner_id, sp->so_seqid.owner_id);
467}
468
469static void
470nfs4_init_seqid_counter(struct nfs_seqid_counter *sc)
471{
472 sc->create_time = ktime_get();
473 sc->flags = 0;
474 sc->counter = 0;
475 spin_lock_init(&sc->lock);
476 INIT_LIST_HEAD(&sc->list);
477 rpc_init_wait_queue(&sc->wait, "Seqid_waitqueue");
478}
479
480static void
481nfs4_destroy_seqid_counter(struct nfs_seqid_counter *sc)
482{
483 rpc_destroy_wait_queue(&sc->wait);
484}
485
486
487
488
489
490
491static struct nfs4_state_owner *
492nfs4_alloc_state_owner(struct nfs_server *server,
493 struct rpc_cred *cred,
494 gfp_t gfp_flags)
495{
496 struct nfs4_state_owner *sp;
497
498 sp = kzalloc(sizeof(*sp), gfp_flags);
499 if (!sp)
500 return NULL;
501 sp->so_server = server;
502 sp->so_cred = get_rpccred(cred);
503 spin_lock_init(&sp->so_lock);
504 INIT_LIST_HEAD(&sp->so_states);
505 nfs4_init_seqid_counter(&sp->so_seqid);
506 atomic_set(&sp->so_count, 1);
507 INIT_LIST_HEAD(&sp->so_lru);
508 seqcount_init(&sp->so_reclaim_seqcount);
509 mutex_init(&sp->so_delegreturn_mutex);
510 return sp;
511}
512
513static void
514nfs4_drop_state_owner(struct nfs4_state_owner *sp)
515{
516 struct rb_node *rb_node = &sp->so_server_node;
517
518 if (!RB_EMPTY_NODE(rb_node)) {
519 struct nfs_server *server = sp->so_server;
520 struct nfs_client *clp = server->nfs_client;
521
522 spin_lock(&clp->cl_lock);
523 if (!RB_EMPTY_NODE(rb_node)) {
524 rb_erase(rb_node, &server->state_owners);
525 RB_CLEAR_NODE(rb_node);
526 }
527 spin_unlock(&clp->cl_lock);
528 }
529}
530
531static void nfs4_free_state_owner(struct nfs4_state_owner *sp)
532{
533 nfs4_destroy_seqid_counter(&sp->so_seqid);
534 put_rpccred(sp->so_cred);
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
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
563
564
565
566
567
568
569
570struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server,
571 struct rpc_cred *cred,
572 gfp_t gfp_flags)
573{
574 struct nfs_client *clp = server->nfs_client;
575 struct nfs4_state_owner *sp, *new;
576
577 spin_lock(&clp->cl_lock);
578 sp = nfs4_find_state_owner_locked(server, cred);
579 spin_unlock(&clp->cl_lock);
580 if (sp != NULL)
581 goto out;
582 new = nfs4_alloc_state_owner(server, cred, gfp_flags);
583 if (new == NULL)
584 goto out;
585 do {
586 if (ida_pre_get(&server->openowner_id, gfp_flags) == 0)
587 break;
588 spin_lock(&clp->cl_lock);
589 sp = nfs4_insert_state_owner_locked(new);
590 spin_unlock(&clp->cl_lock);
591 } while (sp == ERR_PTR(-EAGAIN));
592 if (sp != new)
593 nfs4_free_state_owner(new);
594out:
595 nfs4_gc_state_owners(server);
596 return sp;
597}
598
599
600
601
602
603
604
605
606
607
608
609
610
611void nfs4_put_state_owner(struct nfs4_state_owner *sp)
612{
613 struct nfs_server *server = sp->so_server;
614 struct nfs_client *clp = server->nfs_client;
615
616 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
617 return;
618
619 sp->so_expires = jiffies;
620 list_add_tail(&sp->so_lru, &server->state_owners_lru);
621 spin_unlock(&clp->cl_lock);
622}
623
624
625
626
627
628
629
630
631void nfs4_purge_state_owners(struct nfs_server *server)
632{
633 struct nfs_client *clp = server->nfs_client;
634 struct nfs4_state_owner *sp, *tmp;
635 LIST_HEAD(doomed);
636
637 spin_lock(&clp->cl_lock);
638 list_for_each_entry_safe(sp, tmp, &server->state_owners_lru, so_lru) {
639 list_move(&sp->so_lru, &doomed);
640 nfs4_remove_state_owner_locked(sp);
641 }
642 spin_unlock(&clp->cl_lock);
643
644 list_for_each_entry_safe(sp, tmp, &doomed, so_lru) {
645 list_del(&sp->so_lru);
646 nfs4_free_state_owner(sp);
647 }
648}
649
650static struct nfs4_state *
651nfs4_alloc_open_state(void)
652{
653 struct nfs4_state *state;
654
655 state = kzalloc(sizeof(*state), GFP_NOFS);
656 if (!state)
657 return NULL;
658 atomic_set(&state->count, 1);
659 INIT_LIST_HEAD(&state->lock_states);
660 spin_lock_init(&state->state_lock);
661 seqlock_init(&state->seqlock);
662 return state;
663}
664
665void
666nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
667{
668 if (state->state == fmode)
669 return;
670
671 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
672 if (fmode & FMODE_WRITE)
673 list_move(&state->open_states, &state->owner->so_states);
674 else
675 list_move_tail(&state->open_states, &state->owner->so_states);
676 }
677 state->state = fmode;
678}
679
680static struct nfs4_state *
681__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
682{
683 struct nfs_inode *nfsi = NFS_I(inode);
684 struct nfs4_state *state;
685
686 list_for_each_entry(state, &nfsi->open_states, inode_states) {
687 if (state->owner != owner)
688 continue;
689 if (!nfs4_valid_open_stateid(state))
690 continue;
691 if (atomic_inc_not_zero(&state->count))
692 return state;
693 }
694 return NULL;
695}
696
697static void
698nfs4_free_open_state(struct nfs4_state *state)
699{
700 kfree(state);
701}
702
703struct nfs4_state *
704nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
705{
706 struct nfs4_state *state, *new;
707 struct nfs_inode *nfsi = NFS_I(inode);
708
709 spin_lock(&inode->i_lock);
710 state = __nfs4_find_state_byowner(inode, owner);
711 spin_unlock(&inode->i_lock);
712 if (state)
713 goto out;
714 new = nfs4_alloc_open_state();
715 spin_lock(&owner->so_lock);
716 spin_lock(&inode->i_lock);
717 state = __nfs4_find_state_byowner(inode, owner);
718 if (state == NULL && new != NULL) {
719 state = new;
720 state->owner = owner;
721 atomic_inc(&owner->so_count);
722 list_add(&state->inode_states, &nfsi->open_states);
723 ihold(inode);
724 state->inode = inode;
725 spin_unlock(&inode->i_lock);
726
727
728 list_add_tail(&state->open_states, &owner->so_states);
729 spin_unlock(&owner->so_lock);
730 } else {
731 spin_unlock(&inode->i_lock);
732 spin_unlock(&owner->so_lock);
733 if (new)
734 nfs4_free_open_state(new);
735 }
736out:
737 return state;
738}
739
740void nfs4_put_open_state(struct nfs4_state *state)
741{
742 struct inode *inode = state->inode;
743 struct nfs4_state_owner *owner = state->owner;
744
745 if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
746 return;
747 spin_lock(&inode->i_lock);
748 list_del(&state->inode_states);
749 list_del(&state->open_states);
750 spin_unlock(&inode->i_lock);
751 spin_unlock(&owner->so_lock);
752 iput(inode);
753 nfs4_free_open_state(state);
754 nfs4_put_state_owner(owner);
755}
756
757
758
759
760static void __nfs4_close(struct nfs4_state *state,
761 fmode_t fmode, gfp_t gfp_mask, int wait)
762{
763 struct nfs4_state_owner *owner = state->owner;
764 int call_close = 0;
765 fmode_t newstate;
766
767 atomic_inc(&owner->so_count);
768
769 spin_lock(&owner->so_lock);
770 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
771 case FMODE_READ:
772 state->n_rdonly--;
773 break;
774 case FMODE_WRITE:
775 state->n_wronly--;
776 break;
777 case FMODE_READ|FMODE_WRITE:
778 state->n_rdwr--;
779 }
780 newstate = FMODE_READ|FMODE_WRITE;
781 if (state->n_rdwr == 0) {
782 if (state->n_rdonly == 0) {
783 newstate &= ~FMODE_READ;
784 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
785 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
786 }
787 if (state->n_wronly == 0) {
788 newstate &= ~FMODE_WRITE;
789 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
790 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
791 }
792 if (newstate == 0)
793 clear_bit(NFS_DELEGATED_STATE, &state->flags);
794 }
795 nfs4_state_set_mode_locked(state, newstate);
796 spin_unlock(&owner->so_lock);
797
798 if (!call_close) {
799 nfs4_put_open_state(state);
800 nfs4_put_state_owner(owner);
801 } else
802 nfs4_do_close(state, gfp_mask, wait);
803}
804
805void nfs4_close_state(struct nfs4_state *state, fmode_t fmode)
806{
807 __nfs4_close(state, fmode, GFP_NOFS, 0);
808}
809
810void nfs4_close_sync(struct nfs4_state *state, fmode_t fmode)
811{
812 __nfs4_close(state, fmode, GFP_KERNEL, 1);
813}
814
815
816
817
818
819static struct nfs4_lock_state *
820__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
821{
822 struct nfs4_lock_state *pos;
823 list_for_each_entry(pos, &state->lock_states, ls_locks) {
824 if (type != NFS4_ANY_LOCK_TYPE && pos->ls_owner.lo_type != type)
825 continue;
826 switch (pos->ls_owner.lo_type) {
827 case NFS4_POSIX_LOCK_TYPE:
828 if (pos->ls_owner.lo_u.posix_owner != fl_owner)
829 continue;
830 break;
831 case NFS4_FLOCK_LOCK_TYPE:
832 if (pos->ls_owner.lo_u.flock_owner != fl_pid)
833 continue;
834 }
835 atomic_inc(&pos->ls_count);
836 return pos;
837 }
838 return NULL;
839}
840
841
842
843
844
845
846static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner, pid_t fl_pid, unsigned int type)
847{
848 struct nfs4_lock_state *lsp;
849 struct nfs_server *server = state->owner->so_server;
850
851 lsp = kzalloc(sizeof(*lsp), GFP_NOFS);
852 if (lsp == NULL)
853 return NULL;
854 nfs4_init_seqid_counter(&lsp->ls_seqid);
855 atomic_set(&lsp->ls_count, 1);
856 lsp->ls_state = state;
857 lsp->ls_owner.lo_type = type;
858 switch (lsp->ls_owner.lo_type) {
859 case NFS4_FLOCK_LOCK_TYPE:
860 lsp->ls_owner.lo_u.flock_owner = fl_pid;
861 break;
862 case NFS4_POSIX_LOCK_TYPE:
863 lsp->ls_owner.lo_u.posix_owner = fl_owner;
864 break;
865 default:
866 goto out_free;
867 }
868 lsp->ls_seqid.owner_id = ida_simple_get(&server->lockowner_id, 0, 0, GFP_NOFS);
869 if (lsp->ls_seqid.owner_id < 0)
870 goto out_free;
871 INIT_LIST_HEAD(&lsp->ls_locks);
872 return lsp;
873out_free:
874 kfree(lsp);
875 return NULL;
876}
877
878void nfs4_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
879{
880 ida_simple_remove(&server->lockowner_id, lsp->ls_seqid.owner_id);
881 nfs4_destroy_seqid_counter(&lsp->ls_seqid);
882 kfree(lsp);
883}
884
885
886
887
888
889
890static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner, pid_t pid, unsigned int type)
891{
892 struct nfs4_lock_state *lsp, *new = NULL;
893
894 for(;;) {
895 spin_lock(&state->state_lock);
896 lsp = __nfs4_find_lock_state(state, owner, pid, type);
897 if (lsp != NULL)
898 break;
899 if (new != NULL) {
900 list_add(&new->ls_locks, &state->lock_states);
901 set_bit(LK_STATE_IN_USE, &state->flags);
902 lsp = new;
903 new = NULL;
904 break;
905 }
906 spin_unlock(&state->state_lock);
907 new = nfs4_alloc_lock_state(state, owner, pid, type);
908 if (new == NULL)
909 return NULL;
910 }
911 spin_unlock(&state->state_lock);
912 if (new != NULL)
913 nfs4_free_lock_state(state->owner->so_server, new);
914 return lsp;
915}
916
917
918
919
920
921void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
922{
923 struct nfs_server *server;
924 struct nfs4_state *state;
925
926 if (lsp == NULL)
927 return;
928 state = lsp->ls_state;
929 if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
930 return;
931 list_del(&lsp->ls_locks);
932 if (list_empty(&state->lock_states))
933 clear_bit(LK_STATE_IN_USE, &state->flags);
934 spin_unlock(&state->state_lock);
935 server = state->owner->so_server;
936 if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
937 struct nfs_client *clp = server->nfs_client;
938
939 clp->cl_mvops->free_lock_state(server, lsp);
940 } else
941 nfs4_free_lock_state(server, lsp);
942}
943
944static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
945{
946 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
947
948 dst->fl_u.nfs4_fl.owner = lsp;
949 atomic_inc(&lsp->ls_count);
950}
951
952static void nfs4_fl_release_lock(struct file_lock *fl)
953{
954 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
955}
956
957static const struct file_lock_operations nfs4_fl_lock_ops = {
958 .fl_copy_lock = nfs4_fl_copy_lock,
959 .fl_release_private = nfs4_fl_release_lock,
960};
961
962int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
963{
964 struct nfs4_lock_state *lsp;
965
966 if (fl->fl_ops != NULL)
967 return 0;
968 if (fl->fl_flags & FL_POSIX)
969 lsp = nfs4_get_lock_state(state, fl->fl_owner, 0, NFS4_POSIX_LOCK_TYPE);
970 else if (fl->fl_flags & FL_FLOCK)
971 lsp = nfs4_get_lock_state(state, NULL, fl->fl_pid,
972 NFS4_FLOCK_LOCK_TYPE);
973 else
974 return -EINVAL;
975 if (lsp == NULL)
976 return -ENOMEM;
977 fl->fl_u.nfs4_fl.owner = lsp;
978 fl->fl_ops = &nfs4_fl_lock_ops;
979 return 0;
980}
981
982static int nfs4_copy_lock_stateid(nfs4_stateid *dst,
983 struct nfs4_state *state,
984 const struct nfs_lockowner *lockowner)
985{
986 struct nfs4_lock_state *lsp;
987 fl_owner_t fl_owner;
988 pid_t fl_pid;
989 int ret = -ENOENT;
990
991
992 if (lockowner == NULL)
993 goto out;
994
995 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
996 goto out;
997
998 fl_owner = lockowner->l_owner;
999 fl_pid = lockowner->l_pid;
1000 spin_lock(&state->state_lock);
1001 lsp = __nfs4_find_lock_state(state, fl_owner, fl_pid, NFS4_ANY_LOCK_TYPE);
1002 if (lsp != NULL && test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0) {
1003 nfs4_stateid_copy(dst, &lsp->ls_stateid);
1004 ret = 0;
1005 smp_rmb();
1006 if (!list_empty(&lsp->ls_seqid.list))
1007 ret = -EWOULDBLOCK;
1008 }
1009 spin_unlock(&state->state_lock);
1010 nfs4_put_lock_state(lsp);
1011out:
1012 return ret;
1013}
1014
1015static int nfs4_copy_open_stateid(nfs4_stateid *dst, struct nfs4_state *state)
1016{
1017 const nfs4_stateid *src;
1018 int ret;
1019 int seq;
1020
1021 do {
1022 src = &zero_stateid;
1023 seq = read_seqbegin(&state->seqlock);
1024 if (test_bit(NFS_OPEN_STATE, &state->flags))
1025 src = &state->open_stateid;
1026 nfs4_stateid_copy(dst, src);
1027 ret = 0;
1028 smp_rmb();
1029 if (!list_empty(&state->owner->so_seqid.list))
1030 ret = -EWOULDBLOCK;
1031 } while (read_seqretry(&state->seqlock, seq));
1032 return ret;
1033}
1034
1035
1036
1037
1038
1039int nfs4_select_rw_stateid(nfs4_stateid *dst, struct nfs4_state *state,
1040 fmode_t fmode, const struct nfs_lockowner *lockowner)
1041{
1042 int ret = 0;
1043 if (nfs4_copy_delegation_stateid(dst, state->inode, fmode))
1044 goto out;
1045 ret = nfs4_copy_lock_stateid(dst, state, lockowner);
1046 if (ret != -ENOENT)
1047 goto out;
1048 ret = nfs4_copy_open_stateid(dst, state);
1049out:
1050 if (nfs_server_capable(state->inode, NFS_CAP_STATEID_NFSV41))
1051 dst->seqid = 0;
1052 return ret;
1053}
1054
1055struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter, gfp_t gfp_mask)
1056{
1057 struct nfs_seqid *new;
1058
1059 new = kmalloc(sizeof(*new), gfp_mask);
1060 if (new != NULL) {
1061 new->sequence = counter;
1062 INIT_LIST_HEAD(&new->list);
1063 new->task = NULL;
1064 }
1065 return new;
1066}
1067
1068void nfs_release_seqid(struct nfs_seqid *seqid)
1069{
1070 struct nfs_seqid_counter *sequence;
1071
1072 if (list_empty(&seqid->list))
1073 return;
1074 sequence = seqid->sequence;
1075 spin_lock(&sequence->lock);
1076 list_del_init(&seqid->list);
1077 if (!list_empty(&sequence->list)) {
1078 struct nfs_seqid *next;
1079
1080 next = list_first_entry(&sequence->list,
1081 struct nfs_seqid, list);
1082 rpc_wake_up_queued_task(&sequence->wait, next->task);
1083 }
1084 spin_unlock(&sequence->lock);
1085}
1086
1087void nfs_free_seqid(struct nfs_seqid *seqid)
1088{
1089 nfs_release_seqid(seqid);
1090 kfree(seqid);
1091}
1092
1093
1094
1095
1096
1097
1098static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
1099{
1100 switch (status) {
1101 case 0:
1102 break;
1103 case -NFS4ERR_BAD_SEQID:
1104 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
1105 return;
1106 pr_warn_ratelimited("NFS: v4 server returned a bad"
1107 " sequence-id error on an"
1108 " unconfirmed sequence %p!\n",
1109 seqid->sequence);
1110 case -NFS4ERR_STALE_CLIENTID:
1111 case -NFS4ERR_STALE_STATEID:
1112 case -NFS4ERR_BAD_STATEID:
1113 case -NFS4ERR_BADXDR:
1114 case -NFS4ERR_RESOURCE:
1115 case -NFS4ERR_NOFILEHANDLE:
1116
1117 return;
1118 };
1119
1120
1121
1122
1123 seqid->sequence->counter++;
1124}
1125
1126void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
1127{
1128 struct nfs4_state_owner *sp = container_of(seqid->sequence,
1129 struct nfs4_state_owner, so_seqid);
1130 struct nfs_server *server = sp->so_server;
1131
1132 if (status == -NFS4ERR_BAD_SEQID)
1133 nfs4_drop_state_owner(sp);
1134 if (!nfs4_has_session(server->nfs_client))
1135 nfs_increment_seqid(status, seqid);
1136}
1137
1138
1139
1140
1141
1142
1143void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
1144{
1145 nfs_increment_seqid(status, seqid);
1146}
1147
1148int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
1149{
1150 struct nfs_seqid_counter *sequence = seqid->sequence;
1151 int status = 0;
1152
1153 spin_lock(&sequence->lock);
1154 seqid->task = task;
1155 if (list_empty(&seqid->list))
1156 list_add_tail(&seqid->list, &sequence->list);
1157 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
1158 goto unlock;
1159 rpc_sleep_on(&sequence->wait, task, NULL);
1160 status = -EAGAIN;
1161unlock:
1162 spin_unlock(&sequence->lock);
1163 return status;
1164}
1165
1166static int nfs4_run_state_manager(void *);
1167
1168static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
1169{
1170 smp_mb__before_clear_bit();
1171 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
1172 smp_mb__after_clear_bit();
1173 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
1174 rpc_wake_up(&clp->cl_rpcwaitq);
1175}
1176
1177
1178
1179
1180void nfs4_schedule_state_manager(struct nfs_client *clp)
1181{
1182 struct task_struct *task;
1183 char buf[INET6_ADDRSTRLEN + sizeof("-manager") + 1];
1184
1185 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1186 return;
1187 __module_get(THIS_MODULE);
1188 atomic_inc(&clp->cl_count);
1189
1190
1191
1192
1193 rcu_read_lock();
1194 snprintf(buf, sizeof(buf), "%s-manager",
1195 rpc_peeraddr2str(clp->cl_rpcclient, RPC_DISPLAY_ADDR));
1196 rcu_read_unlock();
1197 task = kthread_run(nfs4_run_state_manager, clp, buf);
1198 if (IS_ERR(task)) {
1199 printk(KERN_ERR "%s: kthread_run: %ld\n",
1200 __func__, PTR_ERR(task));
1201 nfs4_clear_state_manager_bit(clp);
1202 nfs_put_client(clp);
1203 module_put(THIS_MODULE);
1204 }
1205}
1206
1207
1208
1209
1210void nfs4_schedule_lease_recovery(struct nfs_client *clp)
1211{
1212 if (!clp)
1213 return;
1214 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1215 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1216 dprintk("%s: scheduling lease recovery for server %s\n", __func__,
1217 clp->cl_hostname);
1218 nfs4_schedule_state_manager(clp);
1219}
1220EXPORT_SYMBOL_GPL(nfs4_schedule_lease_recovery);
1221
1222int nfs4_wait_clnt_recover(struct nfs_client *clp)
1223{
1224 int res;
1225
1226 might_sleep();
1227
1228 res = wait_on_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING,
1229 nfs_wait_bit_killable, TASK_KILLABLE);
1230 if (res)
1231 return res;
1232
1233 if (clp->cl_cons_state < 0)
1234 return clp->cl_cons_state;
1235 return 0;
1236}
1237
1238int nfs4_client_recover_expired_lease(struct nfs_client *clp)
1239{
1240 unsigned int loop;
1241 int ret;
1242
1243 for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
1244 ret = nfs4_wait_clnt_recover(clp);
1245 if (ret != 0)
1246 break;
1247 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1248 !test_bit(NFS4CLNT_CHECK_LEASE,&clp->cl_state))
1249 break;
1250 nfs4_schedule_state_manager(clp);
1251 ret = -EIO;
1252 }
1253 return ret;
1254}
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264static void nfs40_handle_cb_pathdown(struct nfs_client *clp)
1265{
1266 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1267 nfs_expire_all_delegations(clp);
1268 dprintk("%s: handling CB_PATHDOWN recovery for server %s\n", __func__,
1269 clp->cl_hostname);
1270}
1271
1272void nfs4_schedule_path_down_recovery(struct nfs_client *clp)
1273{
1274 nfs40_handle_cb_pathdown(clp);
1275 nfs4_schedule_state_manager(clp);
1276}
1277
1278static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
1279{
1280
1281 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1282
1283 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
1284 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1285 return 0;
1286 }
1287 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
1288 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1289 return 1;
1290}
1291
1292static int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
1293{
1294 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
1295 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
1296 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
1297 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
1298 return 1;
1299}
1300
1301int nfs4_schedule_stateid_recovery(const struct nfs_server *server, struct nfs4_state *state)
1302{
1303 struct nfs_client *clp = server->nfs_client;
1304
1305 if (!nfs4_valid_open_stateid(state))
1306 return -EBADF;
1307 nfs4_state_mark_reclaim_nograce(clp, state);
1308 dprintk("%s: scheduling stateid recovery for server %s\n", __func__,
1309 clp->cl_hostname);
1310 nfs4_schedule_state_manager(clp);
1311 return 0;
1312}
1313EXPORT_SYMBOL_GPL(nfs4_schedule_stateid_recovery);
1314
1315void nfs_inode_find_state_and_recover(struct inode *inode,
1316 const nfs4_stateid *stateid)
1317{
1318 struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1319 struct nfs_inode *nfsi = NFS_I(inode);
1320 struct nfs_open_context *ctx;
1321 struct nfs4_state *state;
1322 bool found = false;
1323
1324 spin_lock(&inode->i_lock);
1325 list_for_each_entry(ctx, &nfsi->open_files, list) {
1326 state = ctx->state;
1327 if (state == NULL)
1328 continue;
1329 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
1330 continue;
1331 if (!nfs4_stateid_match(&state->stateid, stateid))
1332 continue;
1333 nfs4_state_mark_reclaim_nograce(clp, state);
1334 found = true;
1335 }
1336 spin_unlock(&inode->i_lock);
1337 if (found)
1338 nfs4_schedule_state_manager(clp);
1339}
1340
1341static void nfs4_state_mark_open_context_bad(struct nfs4_state *state)
1342{
1343 struct inode *inode = state->inode;
1344 struct nfs_inode *nfsi = NFS_I(inode);
1345 struct nfs_open_context *ctx;
1346
1347 spin_lock(&inode->i_lock);
1348 list_for_each_entry(ctx, &nfsi->open_files, list) {
1349 if (ctx->state != state)
1350 continue;
1351 set_bit(NFS_CONTEXT_BAD, &ctx->flags);
1352 }
1353 spin_unlock(&inode->i_lock);
1354}
1355
1356static void nfs4_state_mark_recovery_failed(struct nfs4_state *state, int error)
1357{
1358 set_bit(NFS_STATE_RECOVERY_FAILED, &state->flags);
1359 nfs4_state_mark_open_context_bad(state);
1360}
1361
1362
1363static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
1364{
1365 struct inode *inode = state->inode;
1366 struct nfs_inode *nfsi = NFS_I(inode);
1367 struct file_lock *fl;
1368 int status = 0;
1369
1370 if (inode->i_flock == NULL)
1371 return 0;
1372
1373
1374 down_write(&nfsi->rwsem);
1375
1376 lock_flocks();
1377 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
1378 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
1379 continue;
1380 if (nfs_file_open_context(fl->fl_file)->state != state)
1381 continue;
1382 unlock_flocks();
1383 status = ops->recover_lock(state, fl);
1384 switch (status) {
1385 case 0:
1386 break;
1387 case -ESTALE:
1388 case -NFS4ERR_ADMIN_REVOKED:
1389 case -NFS4ERR_STALE_STATEID:
1390 case -NFS4ERR_BAD_STATEID:
1391 case -NFS4ERR_EXPIRED:
1392 case -NFS4ERR_NO_GRACE:
1393 case -NFS4ERR_STALE_CLIENTID:
1394 case -NFS4ERR_BADSESSION:
1395 case -NFS4ERR_BADSLOT:
1396 case -NFS4ERR_BAD_HIGH_SLOT:
1397 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1398 goto out;
1399 default:
1400 printk(KERN_ERR "NFS: %s: unhandled error %d. "
1401 "Zeroing state\n", __func__, status);
1402 case -ENOMEM:
1403 case -NFS4ERR_DENIED:
1404 case -NFS4ERR_RECLAIM_BAD:
1405 case -NFS4ERR_RECLAIM_CONFLICT:
1406
1407 status = 0;
1408 }
1409 lock_flocks();
1410 }
1411 unlock_flocks();
1412out:
1413 up_write(&nfsi->rwsem);
1414 return status;
1415}
1416
1417static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
1418{
1419 struct nfs4_state *state;
1420 struct nfs4_lock_state *lock;
1421 int status = 0;
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431 spin_lock(&sp->so_lock);
1432 write_seqcount_begin(&sp->so_reclaim_seqcount);
1433restart:
1434 list_for_each_entry(state, &sp->so_states, open_states) {
1435 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
1436 continue;
1437 if (!nfs4_valid_open_stateid(state))
1438 continue;
1439 if (state->state == 0)
1440 continue;
1441 atomic_inc(&state->count);
1442 spin_unlock(&sp->so_lock);
1443 status = ops->recover_open(sp, state);
1444 if (status >= 0) {
1445 status = nfs4_reclaim_locks(state, ops);
1446 if (status >= 0) {
1447 spin_lock(&state->state_lock);
1448 list_for_each_entry(lock, &state->lock_states, ls_locks) {
1449 if (!test_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags))
1450 pr_warn_ratelimited("NFS: "
1451 "%s: Lock reclaim "
1452 "failed!\n", __func__);
1453 }
1454 spin_unlock(&state->state_lock);
1455 nfs4_put_open_state(state);
1456 spin_lock(&sp->so_lock);
1457 goto restart;
1458 }
1459 }
1460 switch (status) {
1461 default:
1462 printk(KERN_ERR "NFS: %s: unhandled error %d. "
1463 "Zeroing state\n", __func__, status);
1464 case -ENOENT:
1465 case -ENOMEM:
1466 case -ESTALE:
1467
1468
1469
1470
1471 nfs4_state_mark_recovery_failed(state, status);
1472 break;
1473 case -EAGAIN:
1474 ssleep(1);
1475 case -NFS4ERR_ADMIN_REVOKED:
1476 case -NFS4ERR_STALE_STATEID:
1477 case -NFS4ERR_BAD_STATEID:
1478 case -NFS4ERR_RECLAIM_BAD:
1479 case -NFS4ERR_RECLAIM_CONFLICT:
1480 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1481 break;
1482 case -NFS4ERR_EXPIRED:
1483 case -NFS4ERR_NO_GRACE:
1484 nfs4_state_mark_reclaim_nograce(sp->so_server->nfs_client, state);
1485 case -NFS4ERR_STALE_CLIENTID:
1486 case -NFS4ERR_BADSESSION:
1487 case -NFS4ERR_BADSLOT:
1488 case -NFS4ERR_BAD_HIGH_SLOT:
1489 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1490 goto out_err;
1491 }
1492 nfs4_put_open_state(state);
1493 spin_lock(&sp->so_lock);
1494 goto restart;
1495 }
1496 write_seqcount_end(&sp->so_reclaim_seqcount);
1497 spin_unlock(&sp->so_lock);
1498 return 0;
1499out_err:
1500 nfs4_put_open_state(state);
1501 spin_lock(&sp->so_lock);
1502 write_seqcount_end(&sp->so_reclaim_seqcount);
1503 spin_unlock(&sp->so_lock);
1504 return status;
1505}
1506
1507static void nfs4_clear_open_state(struct nfs4_state *state)
1508{
1509 struct nfs4_lock_state *lock;
1510
1511 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1512 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1513 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1514 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1515 spin_lock(&state->state_lock);
1516 list_for_each_entry(lock, &state->lock_states, ls_locks) {
1517 lock->ls_seqid.flags = 0;
1518 clear_bit(NFS_LOCK_INITIALIZED, &lock->ls_flags);
1519 }
1520 spin_unlock(&state->state_lock);
1521}
1522
1523static void nfs4_reset_seqids(struct nfs_server *server,
1524 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1525{
1526 struct nfs_client *clp = server->nfs_client;
1527 struct nfs4_state_owner *sp;
1528 struct rb_node *pos;
1529 struct nfs4_state *state;
1530
1531 spin_lock(&clp->cl_lock);
1532 for (pos = rb_first(&server->state_owners);
1533 pos != NULL;
1534 pos = rb_next(pos)) {
1535 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1536 sp->so_seqid.flags = 0;
1537 spin_lock(&sp->so_lock);
1538 list_for_each_entry(state, &sp->so_states, open_states) {
1539 if (mark_reclaim(clp, state))
1540 nfs4_clear_open_state(state);
1541 }
1542 spin_unlock(&sp->so_lock);
1543 }
1544 spin_unlock(&clp->cl_lock);
1545}
1546
1547static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp,
1548 int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
1549{
1550 struct nfs_server *server;
1551
1552 rcu_read_lock();
1553 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1554 nfs4_reset_seqids(server, mark_reclaim);
1555 rcu_read_unlock();
1556}
1557
1558static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1559{
1560
1561 nfs_delegation_mark_reclaim(clp);
1562 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1563}
1564
1565static void nfs4_reclaim_complete(struct nfs_client *clp,
1566 const struct nfs4_state_recovery_ops *ops)
1567{
1568
1569 if (ops->reclaim_complete)
1570 (void)ops->reclaim_complete(clp);
1571}
1572
1573static void nfs4_clear_reclaim_server(struct nfs_server *server)
1574{
1575 struct nfs_client *clp = server->nfs_client;
1576 struct nfs4_state_owner *sp;
1577 struct rb_node *pos;
1578 struct nfs4_state *state;
1579
1580 spin_lock(&clp->cl_lock);
1581 for (pos = rb_first(&server->state_owners);
1582 pos != NULL;
1583 pos = rb_next(pos)) {
1584 sp = rb_entry(pos, struct nfs4_state_owner, so_server_node);
1585 spin_lock(&sp->so_lock);
1586 list_for_each_entry(state, &sp->so_states, open_states) {
1587 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT,
1588 &state->flags))
1589 continue;
1590 nfs4_state_mark_reclaim_nograce(clp, state);
1591 }
1592 spin_unlock(&sp->so_lock);
1593 }
1594 spin_unlock(&clp->cl_lock);
1595}
1596
1597static int nfs4_state_clear_reclaim_reboot(struct nfs_client *clp)
1598{
1599 struct nfs_server *server;
1600
1601 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1602 return 0;
1603
1604 rcu_read_lock();
1605 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1606 nfs4_clear_reclaim_server(server);
1607 rcu_read_unlock();
1608
1609 nfs_delegation_reap_unclaimed(clp);
1610 return 1;
1611}
1612
1613static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1614{
1615 if (!nfs4_state_clear_reclaim_reboot(clp))
1616 return;
1617 nfs4_reclaim_complete(clp, clp->cl_mvops->reboot_recovery_ops);
1618}
1619
1620static void nfs_delegation_clear_all(struct nfs_client *clp)
1621{
1622 nfs_delegation_mark_reclaim(clp);
1623 nfs_delegation_reap_unclaimed(clp);
1624}
1625
1626static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1627{
1628 nfs_delegation_clear_all(clp);
1629 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1630}
1631
1632static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
1633{
1634 switch (error) {
1635 case 0:
1636 break;
1637 case -NFS4ERR_CB_PATH_DOWN:
1638 nfs40_handle_cb_pathdown(clp);
1639 break;
1640 case -NFS4ERR_NO_GRACE:
1641 nfs4_state_end_reclaim_reboot(clp);
1642 break;
1643 case -NFS4ERR_STALE_CLIENTID:
1644 case -NFS4ERR_LEASE_MOVED:
1645 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1646 nfs4_state_clear_reclaim_reboot(clp);
1647 nfs4_state_start_reclaim_reboot(clp);
1648 break;
1649 case -NFS4ERR_EXPIRED:
1650 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1651 nfs4_state_start_reclaim_nograce(clp);
1652 break;
1653 case -NFS4ERR_BADSESSION:
1654 case -NFS4ERR_BADSLOT:
1655 case -NFS4ERR_BAD_HIGH_SLOT:
1656 case -NFS4ERR_DEADSESSION:
1657 case -NFS4ERR_SEQ_FALSE_RETRY:
1658 case -NFS4ERR_SEQ_MISORDERED:
1659 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1660
1661 break;
1662 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1663 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1664 break;
1665 default:
1666 dprintk("%s: failed to handle error %d for server %s\n",
1667 __func__, error, clp->cl_hostname);
1668 return error;
1669 }
1670 dprintk("%s: handled error %d for server %s\n", __func__, error,
1671 clp->cl_hostname);
1672 return 0;
1673}
1674
1675static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
1676{
1677 struct nfs4_state_owner *sp;
1678 struct nfs_server *server;
1679 struct rb_node *pos;
1680 int status = 0;
1681
1682restart:
1683 rcu_read_lock();
1684 list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
1685 nfs4_purge_state_owners(server);
1686 spin_lock(&clp->cl_lock);
1687 for (pos = rb_first(&server->state_owners);
1688 pos != NULL;
1689 pos = rb_next(pos)) {
1690 sp = rb_entry(pos,
1691 struct nfs4_state_owner, so_server_node);
1692 if (!test_and_clear_bit(ops->owner_flag_bit,
1693 &sp->so_flags))
1694 continue;
1695 atomic_inc(&sp->so_count);
1696 spin_unlock(&clp->cl_lock);
1697 rcu_read_unlock();
1698
1699 status = nfs4_reclaim_open_state(sp, ops);
1700 if (status < 0) {
1701 set_bit(ops->owner_flag_bit, &sp->so_flags);
1702 nfs4_put_state_owner(sp);
1703 return nfs4_recovery_handle_error(clp, status);
1704 }
1705
1706 nfs4_put_state_owner(sp);
1707 goto restart;
1708 }
1709 spin_unlock(&clp->cl_lock);
1710 }
1711 rcu_read_unlock();
1712 return status;
1713}
1714
1715static int nfs4_check_lease(struct nfs_client *clp)
1716{
1717 struct rpc_cred *cred;
1718 const struct nfs4_state_maintenance_ops *ops =
1719 clp->cl_mvops->state_renewal_ops;
1720 int status;
1721
1722
1723 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1724 return 0;
1725 spin_lock(&clp->cl_lock);
1726 cred = ops->get_state_renewal_cred_locked(clp);
1727 spin_unlock(&clp->cl_lock);
1728 if (cred == NULL) {
1729 cred = nfs4_get_setclientid_cred(clp);
1730 status = -ENOKEY;
1731 if (cred == NULL)
1732 goto out;
1733 }
1734 status = ops->renew_lease(clp, cred);
1735 put_rpccred(cred);
1736 if (status == -ETIMEDOUT) {
1737 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1738 return 0;
1739 }
1740out:
1741 return nfs4_recovery_handle_error(clp, status);
1742}
1743
1744
1745
1746
1747static int nfs4_handle_reclaim_lease_error(struct nfs_client *clp, int status)
1748{
1749 switch (status) {
1750 case -NFS4ERR_SEQ_MISORDERED:
1751 if (test_and_set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state))
1752 return -ESERVERFAULT;
1753
1754 ssleep(1);
1755 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1756 break;
1757 case -NFS4ERR_STALE_CLIENTID:
1758 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1759 nfs4_state_clear_reclaim_reboot(clp);
1760 nfs4_state_start_reclaim_reboot(clp);
1761 break;
1762 case -NFS4ERR_CLID_INUSE:
1763 pr_err("NFS: Server %s reports our clientid is in use\n",
1764 clp->cl_hostname);
1765 nfs_mark_client_ready(clp, -EPERM);
1766 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1767 return -EPERM;
1768 case -EACCES:
1769 case -NFS4ERR_DELAY:
1770 case -ETIMEDOUT:
1771 case -EAGAIN:
1772 ssleep(1);
1773 break;
1774
1775 case -NFS4ERR_MINOR_VERS_MISMATCH:
1776 if (clp->cl_cons_state == NFS_CS_SESSION_INITING)
1777 nfs_mark_client_ready(clp, -EPROTONOSUPPORT);
1778 dprintk("%s: exit with error %d for server %s\n",
1779 __func__, -EPROTONOSUPPORT, clp->cl_hostname);
1780 return -EPROTONOSUPPORT;
1781 case -NFS4ERR_NOT_SAME:
1782
1783 default:
1784 dprintk("%s: exit with error %d for server %s\n", __func__,
1785 status, clp->cl_hostname);
1786 return status;
1787 }
1788 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1789 dprintk("%s: handled error %d for server %s\n", __func__, status,
1790 clp->cl_hostname);
1791 return 0;
1792}
1793
1794static int nfs4_establish_lease(struct nfs_client *clp)
1795{
1796 struct rpc_cred *cred;
1797 const struct nfs4_state_recovery_ops *ops =
1798 clp->cl_mvops->reboot_recovery_ops;
1799 int status;
1800
1801 cred = ops->get_clid_cred(clp);
1802 if (cred == NULL)
1803 return -ENOENT;
1804 status = ops->establish_clid(clp, cred);
1805 put_rpccred(cred);
1806 if (status != 0)
1807 return status;
1808 pnfs_destroy_all_layouts(clp);
1809 return 0;
1810}
1811
1812
1813
1814
1815
1816static int nfs4_reclaim_lease(struct nfs_client *clp)
1817{
1818 int status;
1819
1820 status = nfs4_establish_lease(clp);
1821 if (status < 0)
1822 return nfs4_handle_reclaim_lease_error(clp, status);
1823 if (test_and_clear_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state))
1824 nfs4_state_start_reclaim_nograce(clp);
1825 if (!test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1826 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
1827 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1828 clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1829 return 0;
1830}
1831
1832static int nfs4_purge_lease(struct nfs_client *clp)
1833{
1834 int status;
1835
1836 status = nfs4_establish_lease(clp);
1837 if (status < 0)
1838 return nfs4_handle_reclaim_lease_error(clp, status);
1839 clear_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1840 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1841 nfs4_state_start_reclaim_nograce(clp);
1842 return 0;
1843}
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858int nfs4_discover_server_trunking(struct nfs_client *clp,
1859 struct nfs_client **result)
1860{
1861 const struct nfs4_state_recovery_ops *ops =
1862 clp->cl_mvops->reboot_recovery_ops;
1863 struct rpc_clnt *clnt;
1864 struct rpc_cred *cred;
1865 int i, status;
1866
1867 dprintk("NFS: %s: testing '%s'\n", __func__, clp->cl_hostname);
1868
1869 clnt = clp->cl_rpcclient;
1870 i = 0;
1871
1872 mutex_lock(&nfs_clid_init_mutex);
1873again:
1874 status = -ENOENT;
1875 cred = ops->get_clid_cred(clp);
1876 if (cred == NULL)
1877 goto out_unlock;
1878
1879 status = ops->detect_trunking(clp, result, cred);
1880 put_rpccred(cred);
1881 switch (status) {
1882 case 0:
1883 break;
1884 case -NFS4ERR_DELAY:
1885 case -ETIMEDOUT:
1886 case -EAGAIN:
1887 ssleep(1);
1888 case -NFS4ERR_STALE_CLIENTID:
1889 dprintk("NFS: %s after status %d, retrying\n",
1890 __func__, status);
1891 goto again;
1892 case -EACCES:
1893 if (i++)
1894 break;
1895 case -NFS4ERR_CLID_INUSE:
1896 case -NFS4ERR_WRONGSEC:
1897 clnt = rpc_clone_client_set_auth(clnt, RPC_AUTH_UNIX);
1898 if (IS_ERR(clnt)) {
1899 status = PTR_ERR(clnt);
1900 break;
1901 }
1902
1903
1904
1905
1906 clnt = xchg(&clp->cl_rpcclient, clnt);
1907 rpc_shutdown_client(clnt);
1908 clnt = clp->cl_rpcclient;
1909 goto again;
1910
1911 case -NFS4ERR_MINOR_VERS_MISMATCH:
1912 status = -EPROTONOSUPPORT;
1913 break;
1914
1915 case -EKEYEXPIRED:
1916 case -NFS4ERR_NOT_SAME:
1917
1918 status = -EKEYEXPIRED;
1919 break;
1920 default:
1921 pr_warn("NFS: %s unhandled error %d. Exiting with error EIO\n",
1922 __func__, status);
1923 status = -EIO;
1924 }
1925
1926out_unlock:
1927 mutex_unlock(&nfs_clid_init_mutex);
1928 dprintk("NFS: %s: status = %d\n", __func__, status);
1929 return status;
1930}
1931
1932#ifdef CONFIG_NFS_V4_1
1933void nfs4_schedule_session_recovery(struct nfs4_session *session, int err)
1934{
1935 struct nfs_client *clp = session->clp;
1936
1937 switch (err) {
1938 default:
1939 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
1940 break;
1941 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1942 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
1943 }
1944 nfs4_schedule_lease_recovery(clp);
1945}
1946EXPORT_SYMBOL_GPL(nfs4_schedule_session_recovery);
1947
1948static void nfs41_ping_server(struct nfs_client *clp)
1949{
1950
1951 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
1952 nfs4_schedule_state_manager(clp);
1953}
1954
1955void nfs41_server_notify_target_slotid_update(struct nfs_client *clp)
1956{
1957 nfs41_ping_server(clp);
1958}
1959
1960void nfs41_server_notify_highest_slotid_update(struct nfs_client *clp)
1961{
1962 nfs41_ping_server(clp);
1963}
1964
1965static void nfs4_reset_all_state(struct nfs_client *clp)
1966{
1967 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
1968 set_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state);
1969 clear_bit(NFS4CLNT_LEASE_CONFIRM, &clp->cl_state);
1970 nfs4_state_start_reclaim_nograce(clp);
1971 dprintk("%s: scheduling reset of all state for server %s!\n",
1972 __func__, clp->cl_hostname);
1973 nfs4_schedule_state_manager(clp);
1974 }
1975}
1976
1977static void nfs41_handle_server_reboot(struct nfs_client *clp)
1978{
1979 if (test_and_set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0) {
1980 nfs4_state_start_reclaim_reboot(clp);
1981 dprintk("%s: server %s rebooted!\n", __func__,
1982 clp->cl_hostname);
1983 nfs4_schedule_state_manager(clp);
1984 }
1985}
1986
1987static void nfs41_handle_state_revoked(struct nfs_client *clp)
1988{
1989 nfs4_reset_all_state(clp);
1990 dprintk("%s: state revoked on server %s\n", __func__, clp->cl_hostname);
1991}
1992
1993static void nfs41_handle_recallable_state_revoked(struct nfs_client *clp)
1994{
1995
1996 nfs_expire_all_delegations(clp);
1997 dprintk("%s: Recallable state revoked on server %s!\n", __func__,
1998 clp->cl_hostname);
1999}
2000
2001static void nfs41_handle_backchannel_fault(struct nfs_client *clp)
2002{
2003 nfs_expire_all_delegations(clp);
2004 if (test_and_set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) == 0)
2005 nfs4_schedule_state_manager(clp);
2006 dprintk("%s: server %s declared a backchannel fault\n", __func__,
2007 clp->cl_hostname);
2008}
2009
2010static void nfs41_handle_cb_path_down(struct nfs_client *clp)
2011{
2012 if (test_and_set_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2013 &clp->cl_state) == 0)
2014 nfs4_schedule_state_manager(clp);
2015}
2016
2017void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
2018{
2019 if (!flags)
2020 return;
2021
2022 dprintk("%s: \"%s\" (client ID %llx) flags=0x%08x\n",
2023 __func__, clp->cl_hostname, clp->cl_clientid, flags);
2024
2025 if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
2026 nfs41_handle_server_reboot(clp);
2027 if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
2028 SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
2029 SEQ4_STATUS_ADMIN_STATE_REVOKED |
2030 SEQ4_STATUS_LEASE_MOVED))
2031 nfs41_handle_state_revoked(clp);
2032 if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
2033 nfs41_handle_recallable_state_revoked(clp);
2034 if (flags & SEQ4_STATUS_BACKCHANNEL_FAULT)
2035 nfs41_handle_backchannel_fault(clp);
2036 else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
2037 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
2038 nfs41_handle_cb_path_down(clp);
2039}
2040
2041static int nfs4_reset_session(struct nfs_client *clp)
2042{
2043 struct rpc_cred *cred;
2044 int status;
2045
2046 if (!nfs4_has_session(clp))
2047 return 0;
2048 nfs4_begin_drain_session(clp);
2049 cred = nfs4_get_exchange_id_cred(clp);
2050 status = nfs4_proc_destroy_session(clp->cl_session, cred);
2051 switch (status) {
2052 case 0:
2053 case -NFS4ERR_BADSESSION:
2054 case -NFS4ERR_DEADSESSION:
2055 break;
2056 case -NFS4ERR_BACK_CHAN_BUSY:
2057 case -NFS4ERR_DELAY:
2058 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
2059 status = 0;
2060 ssleep(1);
2061 goto out;
2062 default:
2063 status = nfs4_recovery_handle_error(clp, status);
2064 goto out;
2065 }
2066
2067 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
2068 status = nfs4_proc_create_session(clp, cred);
2069 if (status) {
2070 dprintk("%s: session reset failed with status %d for server %s!\n",
2071 __func__, status, clp->cl_hostname);
2072 status = nfs4_handle_reclaim_lease_error(clp, status);
2073 goto out;
2074 }
2075 nfs41_finish_session_reset(clp);
2076 dprintk("%s: session reset was successful for server %s!\n",
2077 __func__, clp->cl_hostname);
2078out:
2079 if (cred)
2080 put_rpccred(cred);
2081 return status;
2082}
2083
2084static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2085{
2086 struct rpc_cred *cred;
2087 int ret;
2088
2089 if (!nfs4_has_session(clp))
2090 return 0;
2091 nfs4_begin_drain_session(clp);
2092 cred = nfs4_get_exchange_id_cred(clp);
2093 ret = nfs4_proc_bind_conn_to_session(clp, cred);
2094 if (cred)
2095 put_rpccred(cred);
2096 clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2097 switch (ret) {
2098 case 0:
2099 dprintk("%s: bind_conn_to_session was successful for server %s!\n",
2100 __func__, clp->cl_hostname);
2101 break;
2102 case -NFS4ERR_DELAY:
2103 ssleep(1);
2104 set_bit(NFS4CLNT_BIND_CONN_TO_SESSION, &clp->cl_state);
2105 break;
2106 default:
2107 return nfs4_recovery_handle_error(clp, ret);
2108 }
2109 return 0;
2110}
2111#else
2112static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
2113static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
2114
2115static int nfs4_bind_conn_to_session(struct nfs_client *clp)
2116{
2117 return 0;
2118}
2119#endif
2120
2121static void nfs4_state_manager(struct nfs_client *clp)
2122{
2123 int status = 0;
2124 const char *section = "", *section_sep = "";
2125
2126
2127 do {
2128 if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
2129 section = "purge state";
2130 status = nfs4_purge_lease(clp);
2131 if (status < 0)
2132 goto out_error;
2133 continue;
2134 }
2135
2136 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
2137 section = "lease expired";
2138
2139 status = nfs4_reclaim_lease(clp);
2140 if (status < 0)
2141 goto out_error;
2142 continue;
2143 }
2144
2145
2146 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) {
2147 section = "reset session";
2148 status = nfs4_reset_session(clp);
2149 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
2150 continue;
2151 if (status < 0)
2152 goto out_error;
2153 }
2154
2155
2156 if (test_and_clear_bit(NFS4CLNT_BIND_CONN_TO_SESSION,
2157 &clp->cl_state)) {
2158 section = "bind conn to session";
2159 status = nfs4_bind_conn_to_session(clp);
2160 if (status < 0)
2161 goto out_error;
2162 continue;
2163 }
2164
2165 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
2166 section = "check lease";
2167 status = nfs4_check_lease(clp);
2168 if (status < 0)
2169 goto out_error;
2170 continue;
2171 }
2172
2173
2174 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
2175 section = "reclaim reboot";
2176 status = nfs4_do_reclaim(clp,
2177 clp->cl_mvops->reboot_recovery_ops);
2178 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
2179 test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
2180 continue;
2181 nfs4_state_end_reclaim_reboot(clp);
2182 if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
2183 continue;
2184 if (status < 0)
2185 goto out_error;
2186 }
2187
2188
2189 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
2190 section = "reclaim nograce";
2191 status = nfs4_do_reclaim(clp,
2192 clp->cl_mvops->nograce_recovery_ops);
2193 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
2194 test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) ||
2195 test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
2196 continue;
2197 if (status < 0)
2198 goto out_error;
2199 }
2200
2201 nfs4_end_drain_session(clp);
2202 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
2203 nfs_client_return_marked_delegations(clp);
2204 continue;
2205 }
2206
2207 nfs4_clear_state_manager_bit(clp);
2208
2209 if (clp->cl_state == 0)
2210 break;
2211 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
2212 break;
2213 } while (atomic_read(&clp->cl_count) > 1);
2214 return;
2215out_error:
2216 if (strlen(section))
2217 section_sep = ": ";
2218 pr_warn_ratelimited("NFS: state manager%s%s failed on NFSv4 server %s"
2219 " with error %d\n", section_sep, section,
2220 clp->cl_hostname, -status);
2221 ssleep(1);
2222 nfs4_end_drain_session(clp);
2223 nfs4_clear_state_manager_bit(clp);
2224}
2225
2226static int nfs4_run_state_manager(void *ptr)
2227{
2228 struct nfs_client *clp = ptr;
2229
2230 allow_signal(SIGKILL);
2231 nfs4_state_manager(clp);
2232 nfs_put_client(clp);
2233 module_put_and_exit(0);
2234 return 0;
2235}
2236
2237
2238
2239
2240
2241
2242