4 * Client-side XDR for NFSv4.
6 * Copyright (c) 2002 The Regents of the University of Michigan.
9 * Kendrick Smith <kmsmith@umich.edu>
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
36 * Implementation of the NFSv4 state model. For the time being,
37 * this is minimal, but will be made much more complex in a
41 #include <linux/kernel.h>
42 #include <linux/slab.h>
43 #include <linux/smp_lock.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/workqueue.h>
50 #include <linux/bitops.h>
54 #include "delegation.h"
57 #define OPENOWNER_POOL_SIZE 8
59 const nfs4_stateid zero_stateid
;
61 static LIST_HEAD(nfs4_clientid_list
);
63 static int nfs4_init_client(struct nfs_client
*clp
, struct rpc_cred
*cred
)
65 int status
= nfs4_proc_setclientid(clp
, NFS4_CALLBACK
,
66 nfs_callback_tcpport
, cred
);
68 status
= nfs4_proc_setclientid_confirm(clp
, cred
);
70 nfs4_schedule_state_renewal(clp
);
74 static struct rpc_cred
*nfs4_get_machine_cred_locked(struct nfs_client
*clp
)
76 struct rpc_cred
*cred
= NULL
;
78 if (clp
->cl_machine_cred
!= NULL
)
79 cred
= get_rpccred(clp
->cl_machine_cred
);
83 static void nfs4_clear_machine_cred(struct nfs_client
*clp
)
85 struct rpc_cred
*cred
;
87 spin_lock(&clp
->cl_lock
);
88 cred
= clp
->cl_machine_cred
;
89 clp
->cl_machine_cred
= NULL
;
90 spin_unlock(&clp
->cl_lock
);
95 struct rpc_cred
*nfs4_get_renew_cred_locked(struct nfs_client
*clp
)
97 struct nfs4_state_owner
*sp
;
99 struct rpc_cred
*cred
= NULL
;
101 for (pos
= rb_first(&clp
->cl_state_owners
); pos
!= NULL
; pos
= rb_next(pos
)) {
102 sp
= rb_entry(pos
, struct nfs4_state_owner
, so_client_node
);
103 if (list_empty(&sp
->so_states
))
105 cred
= get_rpccred(sp
->so_cred
);
111 static struct rpc_cred
*nfs4_get_renew_cred(struct nfs_client
*clp
)
113 struct rpc_cred
*cred
;
115 spin_lock(&clp
->cl_lock
);
116 cred
= nfs4_get_renew_cred_locked(clp
);
117 spin_unlock(&clp
->cl_lock
);
121 static struct rpc_cred
*nfs4_get_setclientid_cred(struct nfs_client
*clp
)
123 struct nfs4_state_owner
*sp
;
125 struct rpc_cred
*cred
;
127 spin_lock(&clp
->cl_lock
);
128 cred
= nfs4_get_machine_cred_locked(clp
);
131 pos
= rb_first(&clp
->cl_state_owners
);
133 sp
= rb_entry(pos
, struct nfs4_state_owner
, so_client_node
);
134 cred
= get_rpccred(sp
->so_cred
);
137 spin_unlock(&clp
->cl_lock
);
141 static void nfs_alloc_unique_id(struct rb_root
*root
, struct nfs_unique_id
*new,
142 __u64 minval
, int maxbits
)
144 struct rb_node
**p
, *parent
;
145 struct nfs_unique_id
*pos
;
149 mask
= (1ULL << maxbits
) - 1ULL;
151 /* Ensure distribution is more or less flat */
152 get_random_bytes(&new->id
, sizeof(new->id
));
154 if (new->id
< minval
)
162 pos
= rb_entry(parent
, struct nfs_unique_id
, rb_node
);
164 if (new->id
< pos
->id
)
166 else if (new->id
> pos
->id
)
171 rb_link_node(&new->rb_node
, parent
, p
);
172 rb_insert_color(&new->rb_node
, root
);
177 if (new->id
< minval
|| (new->id
& mask
) != new->id
) {
181 parent
= rb_next(parent
);
184 pos
= rb_entry(parent
, struct nfs_unique_id
, rb_node
);
185 if (new->id
< pos
->id
)
191 static void nfs_free_unique_id(struct rb_root
*root
, struct nfs_unique_id
*id
)
193 rb_erase(&id
->rb_node
, root
);
196 static struct nfs4_state_owner
*
197 nfs4_find_state_owner(struct nfs_server
*server
, struct rpc_cred
*cred
)
199 struct nfs_client
*clp
= server
->nfs_client
;
200 struct rb_node
**p
= &clp
->cl_state_owners
.rb_node
,
202 struct nfs4_state_owner
*sp
, *res
= NULL
;
206 sp
= rb_entry(parent
, struct nfs4_state_owner
, so_client_node
);
208 if (server
< sp
->so_server
) {
209 p
= &parent
->rb_left
;
212 if (server
> sp
->so_server
) {
213 p
= &parent
->rb_right
;
216 if (cred
< sp
->so_cred
)
217 p
= &parent
->rb_left
;
218 else if (cred
> sp
->so_cred
)
219 p
= &parent
->rb_right
;
221 atomic_inc(&sp
->so_count
);
229 static struct nfs4_state_owner
*
230 nfs4_insert_state_owner(struct nfs_client
*clp
, struct nfs4_state_owner
*new)
232 struct rb_node
**p
= &clp
->cl_state_owners
.rb_node
,
234 struct nfs4_state_owner
*sp
;
238 sp
= rb_entry(parent
, struct nfs4_state_owner
, so_client_node
);
240 if (new->so_server
< sp
->so_server
) {
241 p
= &parent
->rb_left
;
244 if (new->so_server
> sp
->so_server
) {
245 p
= &parent
->rb_right
;
248 if (new->so_cred
< sp
->so_cred
)
249 p
= &parent
->rb_left
;
250 else if (new->so_cred
> sp
->so_cred
)
251 p
= &parent
->rb_right
;
253 atomic_inc(&sp
->so_count
);
257 nfs_alloc_unique_id(&clp
->cl_openowner_id
, &new->so_owner_id
, 1, 64);
258 rb_link_node(&new->so_client_node
, parent
, p
);
259 rb_insert_color(&new->so_client_node
, &clp
->cl_state_owners
);
264 nfs4_remove_state_owner(struct nfs_client
*clp
, struct nfs4_state_owner
*sp
)
266 if (!RB_EMPTY_NODE(&sp
->so_client_node
))
267 rb_erase(&sp
->so_client_node
, &clp
->cl_state_owners
);
268 nfs_free_unique_id(&clp
->cl_openowner_id
, &sp
->so_owner_id
);
272 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
273 * create a new state_owner.
276 static struct nfs4_state_owner
*
277 nfs4_alloc_state_owner(void)
279 struct nfs4_state_owner
*sp
;
281 sp
= kzalloc(sizeof(*sp
),GFP_KERNEL
);
284 spin_lock_init(&sp
->so_lock
);
285 INIT_LIST_HEAD(&sp
->so_states
);
286 INIT_LIST_HEAD(&sp
->so_delegations
);
287 rpc_init_wait_queue(&sp
->so_sequence
.wait
, "Seqid_waitqueue");
288 sp
->so_seqid
.sequence
= &sp
->so_sequence
;
289 spin_lock_init(&sp
->so_sequence
.lock
);
290 INIT_LIST_HEAD(&sp
->so_sequence
.list
);
291 atomic_set(&sp
->so_count
, 1);
296 nfs4_drop_state_owner(struct nfs4_state_owner
*sp
)
298 if (!RB_EMPTY_NODE(&sp
->so_client_node
)) {
299 struct nfs_client
*clp
= sp
->so_client
;
301 spin_lock(&clp
->cl_lock
);
302 rb_erase(&sp
->so_client_node
, &clp
->cl_state_owners
);
303 RB_CLEAR_NODE(&sp
->so_client_node
);
304 spin_unlock(&clp
->cl_lock
);
309 * Note: must be called with clp->cl_sem held in order to prevent races
310 * with reboot recovery!
312 struct nfs4_state_owner
*nfs4_get_state_owner(struct nfs_server
*server
, struct rpc_cred
*cred
)
314 struct nfs_client
*clp
= server
->nfs_client
;
315 struct nfs4_state_owner
*sp
, *new;
317 spin_lock(&clp
->cl_lock
);
318 sp
= nfs4_find_state_owner(server
, cred
);
319 spin_unlock(&clp
->cl_lock
);
322 new = nfs4_alloc_state_owner();
325 new->so_client
= clp
;
326 new->so_server
= server
;
328 spin_lock(&clp
->cl_lock
);
329 sp
= nfs4_insert_state_owner(clp
, new);
330 spin_unlock(&clp
->cl_lock
);
334 rpc_destroy_wait_queue(&new->so_sequence
.wait
);
341 * Must be called with clp->cl_sem held in order to avoid races
342 * with state recovery...
344 void nfs4_put_state_owner(struct nfs4_state_owner
*sp
)
346 struct nfs_client
*clp
= sp
->so_client
;
347 struct rpc_cred
*cred
= sp
->so_cred
;
349 if (!atomic_dec_and_lock(&sp
->so_count
, &clp
->cl_lock
))
351 nfs4_remove_state_owner(clp
, sp
);
352 spin_unlock(&clp
->cl_lock
);
353 rpc_destroy_wait_queue(&sp
->so_sequence
.wait
);
358 static struct nfs4_state
*
359 nfs4_alloc_open_state(void)
361 struct nfs4_state
*state
;
363 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
366 atomic_set(&state
->count
, 1);
367 INIT_LIST_HEAD(&state
->lock_states
);
368 spin_lock_init(&state
->state_lock
);
369 seqlock_init(&state
->seqlock
);
374 nfs4_state_set_mode_locked(struct nfs4_state
*state
, mode_t mode
)
376 if (state
->state
== mode
)
378 /* NB! List reordering - see the reclaim code for why. */
379 if ((mode
& FMODE_WRITE
) != (state
->state
& FMODE_WRITE
)) {
380 if (mode
& FMODE_WRITE
)
381 list_move(&state
->open_states
, &state
->owner
->so_states
);
383 list_move_tail(&state
->open_states
, &state
->owner
->so_states
);
388 static struct nfs4_state
*
389 __nfs4_find_state_byowner(struct inode
*inode
, struct nfs4_state_owner
*owner
)
391 struct nfs_inode
*nfsi
= NFS_I(inode
);
392 struct nfs4_state
*state
;
394 list_for_each_entry(state
, &nfsi
->open_states
, inode_states
) {
395 if (state
->owner
!= owner
)
397 if (atomic_inc_not_zero(&state
->count
))
404 nfs4_free_open_state(struct nfs4_state
*state
)
410 nfs4_get_open_state(struct inode
*inode
, struct nfs4_state_owner
*owner
)
412 struct nfs4_state
*state
, *new;
413 struct nfs_inode
*nfsi
= NFS_I(inode
);
415 spin_lock(&inode
->i_lock
);
416 state
= __nfs4_find_state_byowner(inode
, owner
);
417 spin_unlock(&inode
->i_lock
);
420 new = nfs4_alloc_open_state();
421 spin_lock(&owner
->so_lock
);
422 spin_lock(&inode
->i_lock
);
423 state
= __nfs4_find_state_byowner(inode
, owner
);
424 if (state
== NULL
&& new != NULL
) {
426 state
->owner
= owner
;
427 atomic_inc(&owner
->so_count
);
428 list_add(&state
->inode_states
, &nfsi
->open_states
);
429 state
->inode
= igrab(inode
);
430 spin_unlock(&inode
->i_lock
);
431 /* Note: The reclaim code dictates that we add stateless
432 * and read-only stateids to the end of the list */
433 list_add_tail(&state
->open_states
, &owner
->so_states
);
434 spin_unlock(&owner
->so_lock
);
436 spin_unlock(&inode
->i_lock
);
437 spin_unlock(&owner
->so_lock
);
439 nfs4_free_open_state(new);
446 * Beware! Caller must be holding exactly one
447 * reference to clp->cl_sem!
449 void nfs4_put_open_state(struct nfs4_state
*state
)
451 struct inode
*inode
= state
->inode
;
452 struct nfs4_state_owner
*owner
= state
->owner
;
454 if (!atomic_dec_and_lock(&state
->count
, &owner
->so_lock
))
456 spin_lock(&inode
->i_lock
);
457 list_del(&state
->inode_states
);
458 list_del(&state
->open_states
);
459 spin_unlock(&inode
->i_lock
);
460 spin_unlock(&owner
->so_lock
);
462 nfs4_free_open_state(state
);
463 nfs4_put_state_owner(owner
);
467 * Close the current file.
469 static void __nfs4_close(struct path
*path
, struct nfs4_state
*state
, mode_t mode
, int wait
)
471 struct nfs4_state_owner
*owner
= state
->owner
;
475 atomic_inc(&owner
->so_count
);
476 /* Protect against nfs4_find_state() */
477 spin_lock(&owner
->so_lock
);
478 switch (mode
& (FMODE_READ
| FMODE_WRITE
)) {
485 case FMODE_READ
|FMODE_WRITE
:
488 newstate
= FMODE_READ
|FMODE_WRITE
;
489 if (state
->n_rdwr
== 0) {
490 if (state
->n_rdonly
== 0) {
491 newstate
&= ~FMODE_READ
;
492 call_close
|= test_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
493 call_close
|= test_bit(NFS_O_RDWR_STATE
, &state
->flags
);
495 if (state
->n_wronly
== 0) {
496 newstate
&= ~FMODE_WRITE
;
497 call_close
|= test_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
498 call_close
|= test_bit(NFS_O_RDWR_STATE
, &state
->flags
);
501 clear_bit(NFS_DELEGATED_STATE
, &state
->flags
);
503 nfs4_state_set_mode_locked(state
, newstate
);
504 spin_unlock(&owner
->so_lock
);
507 nfs4_put_open_state(state
);
508 nfs4_put_state_owner(owner
);
510 nfs4_do_close(path
, state
, wait
);
513 void nfs4_close_state(struct path
*path
, struct nfs4_state
*state
, mode_t mode
)
515 __nfs4_close(path
, state
, mode
, 0);
518 void nfs4_close_sync(struct path
*path
, struct nfs4_state
*state
, mode_t mode
)
520 __nfs4_close(path
, state
, mode
, 1);
524 * Search the state->lock_states for an existing lock_owner
525 * that is compatible with current->files
527 static struct nfs4_lock_state
*
528 __nfs4_find_lock_state(struct nfs4_state
*state
, fl_owner_t fl_owner
)
530 struct nfs4_lock_state
*pos
;
531 list_for_each_entry(pos
, &state
->lock_states
, ls_locks
) {
532 if (pos
->ls_owner
!= fl_owner
)
534 atomic_inc(&pos
->ls_count
);
541 * Return a compatible lock_state. If no initialized lock_state structure
542 * exists, return an uninitialized one.
545 static struct nfs4_lock_state
*nfs4_alloc_lock_state(struct nfs4_state
*state
, fl_owner_t fl_owner
)
547 struct nfs4_lock_state
*lsp
;
548 struct nfs_client
*clp
= state
->owner
->so_client
;
550 lsp
= kzalloc(sizeof(*lsp
), GFP_KERNEL
);
553 rpc_init_wait_queue(&lsp
->ls_sequence
.wait
, "lock_seqid_waitqueue");
554 spin_lock_init(&lsp
->ls_sequence
.lock
);
555 INIT_LIST_HEAD(&lsp
->ls_sequence
.list
);
556 lsp
->ls_seqid
.sequence
= &lsp
->ls_sequence
;
557 atomic_set(&lsp
->ls_count
, 1);
558 lsp
->ls_owner
= fl_owner
;
559 spin_lock(&clp
->cl_lock
);
560 nfs_alloc_unique_id(&clp
->cl_lockowner_id
, &lsp
->ls_id
, 1, 64);
561 spin_unlock(&clp
->cl_lock
);
562 INIT_LIST_HEAD(&lsp
->ls_locks
);
566 static void nfs4_free_lock_state(struct nfs4_lock_state
*lsp
)
568 struct nfs_client
*clp
= lsp
->ls_state
->owner
->so_client
;
570 spin_lock(&clp
->cl_lock
);
571 nfs_free_unique_id(&clp
->cl_lockowner_id
, &lsp
->ls_id
);
572 spin_unlock(&clp
->cl_lock
);
573 rpc_destroy_wait_queue(&lsp
->ls_sequence
.wait
);
578 * Return a compatible lock_state. If no initialized lock_state structure
579 * exists, return an uninitialized one.
581 * The caller must be holding clp->cl_sem
583 static struct nfs4_lock_state
*nfs4_get_lock_state(struct nfs4_state
*state
, fl_owner_t owner
)
585 struct nfs4_lock_state
*lsp
, *new = NULL
;
588 spin_lock(&state
->state_lock
);
589 lsp
= __nfs4_find_lock_state(state
, owner
);
593 new->ls_state
= state
;
594 list_add(&new->ls_locks
, &state
->lock_states
);
595 set_bit(LK_STATE_IN_USE
, &state
->flags
);
600 spin_unlock(&state
->state_lock
);
601 new = nfs4_alloc_lock_state(state
, owner
);
605 spin_unlock(&state
->state_lock
);
607 nfs4_free_lock_state(new);
612 * Release reference to lock_state, and free it if we see that
613 * it is no longer in use
615 void nfs4_put_lock_state(struct nfs4_lock_state
*lsp
)
617 struct nfs4_state
*state
;
621 state
= lsp
->ls_state
;
622 if (!atomic_dec_and_lock(&lsp
->ls_count
, &state
->state_lock
))
624 list_del(&lsp
->ls_locks
);
625 if (list_empty(&state
->lock_states
))
626 clear_bit(LK_STATE_IN_USE
, &state
->flags
);
627 spin_unlock(&state
->state_lock
);
628 nfs4_free_lock_state(lsp
);
631 static void nfs4_fl_copy_lock(struct file_lock
*dst
, struct file_lock
*src
)
633 struct nfs4_lock_state
*lsp
= src
->fl_u
.nfs4_fl
.owner
;
635 dst
->fl_u
.nfs4_fl
.owner
= lsp
;
636 atomic_inc(&lsp
->ls_count
);
639 static void nfs4_fl_release_lock(struct file_lock
*fl
)
641 nfs4_put_lock_state(fl
->fl_u
.nfs4_fl
.owner
);
644 static struct file_lock_operations nfs4_fl_lock_ops
= {
645 .fl_copy_lock
= nfs4_fl_copy_lock
,
646 .fl_release_private
= nfs4_fl_release_lock
,
649 int nfs4_set_lock_state(struct nfs4_state
*state
, struct file_lock
*fl
)
651 struct nfs4_lock_state
*lsp
;
653 if (fl
->fl_ops
!= NULL
)
655 lsp
= nfs4_get_lock_state(state
, fl
->fl_owner
);
658 fl
->fl_u
.nfs4_fl
.owner
= lsp
;
659 fl
->fl_ops
= &nfs4_fl_lock_ops
;
664 * Byte-range lock aware utility to initialize the stateid of read/write
667 void nfs4_copy_stateid(nfs4_stateid
*dst
, struct nfs4_state
*state
, fl_owner_t fl_owner
)
669 struct nfs4_lock_state
*lsp
;
673 seq
= read_seqbegin(&state
->seqlock
);
674 memcpy(dst
, &state
->stateid
, sizeof(*dst
));
675 } while (read_seqretry(&state
->seqlock
, seq
));
676 if (test_bit(LK_STATE_IN_USE
, &state
->flags
) == 0)
679 spin_lock(&state
->state_lock
);
680 lsp
= __nfs4_find_lock_state(state
, fl_owner
);
681 if (lsp
!= NULL
&& (lsp
->ls_flags
& NFS_LOCK_INITIALIZED
) != 0)
682 memcpy(dst
, &lsp
->ls_stateid
, sizeof(*dst
));
683 spin_unlock(&state
->state_lock
);
684 nfs4_put_lock_state(lsp
);
687 struct nfs_seqid
*nfs_alloc_seqid(struct nfs_seqid_counter
*counter
)
689 struct nfs_seqid
*new;
691 new = kmalloc(sizeof(*new), GFP_KERNEL
);
693 new->sequence
= counter
;
694 INIT_LIST_HEAD(&new->list
);
699 void nfs_free_seqid(struct nfs_seqid
*seqid
)
701 if (!list_empty(&seqid
->list
)) {
702 struct rpc_sequence
*sequence
= seqid
->sequence
->sequence
;
704 spin_lock(&sequence
->lock
);
705 list_del(&seqid
->list
);
706 spin_unlock(&sequence
->lock
);
707 rpc_wake_up(&sequence
->wait
);
713 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
714 * failed with a seqid incrementing error -
715 * see comments nfs_fs.h:seqid_mutating_error()
717 static void nfs_increment_seqid(int status
, struct nfs_seqid
*seqid
)
719 BUG_ON(list_first_entry(&seqid
->sequence
->sequence
->list
, struct nfs_seqid
, list
) != seqid
);
723 case -NFS4ERR_BAD_SEQID
:
724 if (seqid
->sequence
->flags
& NFS_SEQID_CONFIRMED
)
726 printk(KERN_WARNING
"NFS: v4 server returned a bad"
727 " sequence-id error on an"
728 " unconfirmed sequence %p!\n",
730 case -NFS4ERR_STALE_CLIENTID
:
731 case -NFS4ERR_STALE_STATEID
:
732 case -NFS4ERR_BAD_STATEID
:
733 case -NFS4ERR_BADXDR
:
734 case -NFS4ERR_RESOURCE
:
735 case -NFS4ERR_NOFILEHANDLE
:
736 /* Non-seqid mutating errors */
740 * Note: no locking needed as we are guaranteed to be first
741 * on the sequence list
743 seqid
->sequence
->counter
++;
746 void nfs_increment_open_seqid(int status
, struct nfs_seqid
*seqid
)
748 if (status
== -NFS4ERR_BAD_SEQID
) {
749 struct nfs4_state_owner
*sp
= container_of(seqid
->sequence
,
750 struct nfs4_state_owner
, so_seqid
);
751 nfs4_drop_state_owner(sp
);
753 nfs_increment_seqid(status
, seqid
);
757 * Increment the seqid if the LOCK/LOCKU succeeded, or
758 * failed with a seqid incrementing error -
759 * see comments nfs_fs.h:seqid_mutating_error()
761 void nfs_increment_lock_seqid(int status
, struct nfs_seqid
*seqid
)
763 nfs_increment_seqid(status
, seqid
);
766 int nfs_wait_on_sequence(struct nfs_seqid
*seqid
, struct rpc_task
*task
)
768 struct rpc_sequence
*sequence
= seqid
->sequence
->sequence
;
771 spin_lock(&sequence
->lock
);
772 if (list_empty(&seqid
->list
))
773 list_add_tail(&seqid
->list
, &sequence
->list
);
774 if (list_first_entry(&sequence
->list
, struct nfs_seqid
, list
) == seqid
)
776 rpc_sleep_on(&sequence
->wait
, task
, NULL
);
779 spin_unlock(&sequence
->lock
);
783 static int reclaimer(void *);
785 static inline void nfs4_clear_recover_bit(struct nfs_client
*clp
)
787 smp_mb__before_clear_bit();
788 clear_bit(NFS4CLNT_STATE_RECOVER
, &clp
->cl_state
);
789 smp_mb__after_clear_bit();
790 wake_up_bit(&clp
->cl_state
, NFS4CLNT_STATE_RECOVER
);
791 rpc_wake_up(&clp
->cl_rpcwaitq
);
795 * State recovery routine
797 static void nfs4_recover_state(struct nfs_client
*clp
)
799 struct task_struct
*task
;
801 __module_get(THIS_MODULE
);
802 atomic_inc(&clp
->cl_count
);
803 task
= kthread_run(reclaimer
, clp
, "%s-reclaim",
804 rpc_peeraddr2str(clp
->cl_rpcclient
,
808 nfs4_clear_recover_bit(clp
);
810 module_put(THIS_MODULE
);
814 * Schedule a state recovery attempt
816 void nfs4_schedule_state_recovery(struct nfs_client
*clp
)
820 if (test_and_set_bit(NFS4CLNT_STATE_RECOVER
, &clp
->cl_state
) == 0)
821 nfs4_recover_state(clp
);
824 static int nfs4_state_mark_reclaim_reboot(struct nfs_client
*clp
, struct nfs4_state
*state
)
827 set_bit(NFS_STATE_RECLAIM_REBOOT
, &state
->flags
);
828 /* Don't recover state that expired before the reboot */
829 if (test_bit(NFS_STATE_RECLAIM_NOGRACE
, &state
->flags
)) {
830 clear_bit(NFS_STATE_RECLAIM_REBOOT
, &state
->flags
);
833 set_bit(NFS4CLNT_RECLAIM_REBOOT
, &clp
->cl_state
);
837 static int nfs4_state_mark_reclaim_nograce(struct nfs_client
*clp
, struct nfs4_state
*state
)
839 set_bit(NFS_STATE_RECLAIM_NOGRACE
, &state
->flags
);
840 clear_bit(NFS_STATE_RECLAIM_REBOOT
, &state
->flags
);
841 set_bit(NFS4CLNT_RECLAIM_NOGRACE
, &clp
->cl_state
);
845 static int nfs4_reclaim_locks(struct nfs4_state
*state
, const struct nfs4_state_recovery_ops
*ops
)
847 struct inode
*inode
= state
->inode
;
848 struct file_lock
*fl
;
851 for (fl
= inode
->i_flock
; fl
!= NULL
; fl
= fl
->fl_next
) {
852 if (!(fl
->fl_flags
& (FL_POSIX
|FL_FLOCK
)))
854 if (nfs_file_open_context(fl
->fl_file
)->state
!= state
)
856 status
= ops
->recover_lock(state
, fl
);
861 printk(KERN_ERR
"%s: unhandled error %d. Zeroing state\n",
863 case -NFS4ERR_EXPIRED
:
864 case -NFS4ERR_NO_GRACE
:
865 case -NFS4ERR_RECLAIM_BAD
:
866 case -NFS4ERR_RECLAIM_CONFLICT
:
867 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
869 case -NFS4ERR_STALE_CLIENTID
:
878 static int nfs4_reclaim_open_state(struct nfs4_state_owner
*sp
, const struct nfs4_state_recovery_ops
*ops
)
880 struct nfs4_state
*state
;
881 struct nfs4_lock_state
*lock
;
884 /* Note: we rely on the sp->so_states list being ordered
885 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
887 * This is needed to ensure that the server won't give us any
888 * read delegations that we have to return if, say, we are
889 * recovering after a network partition or a reboot from a
890 * server that doesn't support a grace period.
892 list_for_each_entry(state
, &sp
->so_states
, open_states
) {
893 if (!test_and_clear_bit(ops
->state_flag_bit
, &state
->flags
))
895 if (state
->state
== 0)
897 status
= ops
->recover_open(sp
, state
);
899 status
= nfs4_reclaim_locks(state
, ops
);
901 list_for_each_entry(lock
, &state
->lock_states
, ls_locks
) {
902 if (!(lock
->ls_flags
& NFS_LOCK_INITIALIZED
))
903 printk("%s: Lock reclaim failed!\n",
911 printk(KERN_ERR
"%s: unhandled error %d. Zeroing state\n",
916 * Open state on this file cannot be recovered
917 * All we can do is revert to using the zero stateid.
919 memset(state
->stateid
.data
, 0,
920 sizeof(state
->stateid
.data
));
921 /* Mark the file as being 'closed' */
924 case -NFS4ERR_RECLAIM_BAD
:
925 case -NFS4ERR_RECLAIM_CONFLICT
:
926 nfs4_state_mark_reclaim_nograce(sp
->so_client
, state
);
928 case -NFS4ERR_EXPIRED
:
929 case -NFS4ERR_NO_GRACE
:
930 nfs4_state_mark_reclaim_nograce(sp
->so_client
, state
);
931 case -NFS4ERR_STALE_CLIENTID
:
940 static void nfs4_clear_open_state(struct nfs4_state
*state
)
942 struct nfs4_lock_state
*lock
;
944 clear_bit(NFS_DELEGATED_STATE
, &state
->flags
);
945 clear_bit(NFS_O_RDONLY_STATE
, &state
->flags
);
946 clear_bit(NFS_O_WRONLY_STATE
, &state
->flags
);
947 clear_bit(NFS_O_RDWR_STATE
, &state
->flags
);
948 list_for_each_entry(lock
, &state
->lock_states
, ls_locks
) {
949 lock
->ls_seqid
.counter
= 0;
950 lock
->ls_seqid
.flags
= 0;
951 lock
->ls_flags
&= ~NFS_LOCK_INITIALIZED
;
955 static void nfs4_state_mark_reclaim_helper(struct nfs_client
*clp
, int (*mark_reclaim
)(struct nfs_client
*clp
, struct nfs4_state
*state
))
957 struct nfs4_state_owner
*sp
;
959 struct nfs4_state
*state
;
961 /* Reset all sequence ids to zero */
962 for (pos
= rb_first(&clp
->cl_state_owners
); pos
!= NULL
; pos
= rb_next(pos
)) {
963 sp
= rb_entry(pos
, struct nfs4_state_owner
, so_client_node
);
964 sp
->so_seqid
.counter
= 0;
965 sp
->so_seqid
.flags
= 0;
966 spin_lock(&sp
->so_lock
);
967 list_for_each_entry(state
, &sp
->so_states
, open_states
) {
968 if (mark_reclaim(clp
, state
))
969 nfs4_clear_open_state(state
);
971 spin_unlock(&sp
->so_lock
);
975 static void nfs4_state_start_reclaim_reboot(struct nfs_client
*clp
)
977 /* Mark all delegations for reclaim */
978 nfs_delegation_mark_reclaim(clp
);
979 nfs4_state_mark_reclaim_helper(clp
, nfs4_state_mark_reclaim_reboot
);
982 static void nfs4_state_end_reclaim_reboot(struct nfs_client
*clp
)
984 struct nfs4_state_owner
*sp
;
986 struct nfs4_state
*state
;
988 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT
, &clp
->cl_state
))
991 for (pos
= rb_first(&clp
->cl_state_owners
); pos
!= NULL
; pos
= rb_next(pos
)) {
992 sp
= rb_entry(pos
, struct nfs4_state_owner
, so_client_node
);
993 spin_lock(&sp
->so_lock
);
994 list_for_each_entry(state
, &sp
->so_states
, open_states
) {
995 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT
, &state
->flags
))
997 nfs4_state_mark_reclaim_nograce(clp
, state
);
999 spin_unlock(&sp
->so_lock
);
1002 nfs_delegation_reap_unclaimed(clp
);
1005 static void nfs_delegation_clear_all(struct nfs_client
*clp
)
1007 nfs_delegation_mark_reclaim(clp
);
1008 nfs_delegation_reap_unclaimed(clp
);
1011 static void nfs4_state_start_reclaim_nograce(struct nfs_client
*clp
)
1013 nfs_delegation_clear_all(clp
);
1014 nfs4_state_mark_reclaim_helper(clp
, nfs4_state_mark_reclaim_nograce
);
1017 static void nfs4_state_end_reclaim_nograce(struct nfs_client
*clp
)
1019 clear_bit(NFS4CLNT_RECLAIM_NOGRACE
, &clp
->cl_state
);
1022 static int nfs4_do_reclaim(struct nfs_client
*clp
, const struct nfs4_state_recovery_ops
*ops
)
1024 struct rb_node
*pos
;
1027 /* Note: list is protected by exclusive lock on cl->cl_sem */
1028 for (pos
= rb_first(&clp
->cl_state_owners
); pos
!= NULL
; pos
= rb_next(pos
)) {
1029 struct nfs4_state_owner
*sp
= rb_entry(pos
, struct nfs4_state_owner
, so_client_node
);
1030 status
= nfs4_reclaim_open_state(sp
, ops
);
1037 static int nfs4_check_lease(struct nfs_client
*clp
)
1039 struct rpc_cred
*cred
;
1040 int status
= -NFS4ERR_EXPIRED
;
1042 /* Are there any open files on this volume? */
1043 cred
= nfs4_get_renew_cred(clp
);
1045 /* Yes there are: try to renew the old lease */
1046 status
= nfs4_proc_renew(clp
, cred
);
1049 case -NFS4ERR_CB_PATH_DOWN
:
1050 set_bit(NFS4CLNT_CB_PATH_DOWN
, &clp
->cl_state
);
1052 case -NFS4ERR_STALE_CLIENTID
:
1053 case -NFS4ERR_LEASE_MOVED
:
1054 set_bit(NFS4CLNT_LEASE_EXPIRED
, &clp
->cl_state
);
1055 nfs4_state_start_reclaim_reboot(clp
);
1057 case -NFS4ERR_EXPIRED
:
1058 set_bit(NFS4CLNT_LEASE_EXPIRED
, &clp
->cl_state
);
1059 nfs4_state_start_reclaim_nograce(clp
);
1064 /* "reboot" to ensure we clear all state on the server */
1065 clp
->cl_boot_time
= CURRENT_TIME
;
1066 set_bit(NFS4CLNT_LEASE_EXPIRED
, &clp
->cl_state
);
1070 static int nfs4_reclaim_lease(struct nfs_client
*clp
)
1072 struct rpc_cred
*cred
;
1073 int status
= -ENOENT
;
1075 cred
= nfs4_get_setclientid_cred(clp
);
1077 status
= nfs4_init_client(clp
, cred
);
1079 /* Handle case where the user hasn't set up machine creds */
1080 if (status
== -EACCES
&& cred
== clp
->cl_machine_cred
) {
1081 nfs4_clear_machine_cred(clp
);
1088 static int reclaimer(void *ptr
)
1090 struct nfs_client
*clp
= ptr
;
1093 allow_signal(SIGKILL
);
1095 /* Ensure exclusive access to NFSv4 state */
1096 down_write(&clp
->cl_sem
);
1097 while (!list_empty(&clp
->cl_superblocks
)) {
1098 status
= nfs4_check_lease(clp
);
1100 if (test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED
, &clp
->cl_state
)) {
1101 /* We're going to have to re-establish a clientid */
1102 status
= nfs4_reclaim_lease(clp
);
1104 set_bit(NFS4CLNT_LEASE_EXPIRED
, &clp
->cl_state
);
1105 if (status
== -EAGAIN
)
1111 /* First recover reboot state... */
1112 if (test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT
, &clp
->cl_state
)) {
1113 /* Note: list is protected by exclusive lock on cl->cl_sem */
1114 status
= nfs4_do_reclaim(clp
, &nfs4_reboot_recovery_ops
);
1115 if (status
== -NFS4ERR_STALE_CLIENTID
) {
1116 set_bit(NFS4CLNT_RECLAIM_REBOOT
, &clp
->cl_state
);
1119 nfs4_state_end_reclaim_reboot(clp
);
1123 /* Now recover expired state... */
1124 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE
, &clp
->cl_state
)) {
1125 /* Note: list is protected by exclusive lock on cl->cl_sem */
1126 status
= nfs4_do_reclaim(clp
, &nfs4_nograce_recovery_ops
);
1128 set_bit(NFS4CLNT_RECLAIM_NOGRACE
, &clp
->cl_state
);
1129 if (status
== -NFS4ERR_STALE_CLIENTID
)
1131 if (status
== -NFS4ERR_EXPIRED
)
1135 nfs4_state_end_reclaim_nograce(clp
);
1141 up_write(&clp
->cl_sem
);
1142 if (test_and_clear_bit(NFS4CLNT_CB_PATH_DOWN
, &clp
->cl_state
))
1143 nfs_handle_cb_pathdown(clp
);
1144 nfs4_clear_recover_bit(clp
);
1145 nfs_put_client(clp
);
1146 module_put_and_exit(0);
1149 printk(KERN_WARNING
"Error: state recovery failed on NFSv4 server %s"
1150 " with error %d\n", clp
->cl_hostname
, -status
);
1151 if (test_bit(NFS4CLNT_RECLAIM_REBOOT
, &clp
->cl_state
))
1152 nfs4_state_end_reclaim_reboot(clp
);