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/config.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/workqueue.h>
47 #include <linux/bitops.h>
51 #include "delegation.h"
53 #define OPENOWNER_POOL_SIZE 8
55 const nfs4_stateid zero_stateid;
57 static DEFINE_SPINLOCK(state_spinlock);
58 static LIST_HEAD(nfs4_clientid_list);
60 static void nfs4_recover_state(void *);
63 init_nfsv4_state(struct nfs_server *server)
65 server->nfs4_state = NULL;
66 INIT_LIST_HEAD(&server->nfs4_siblings);
70 destroy_nfsv4_state(struct nfs_server *server)
72 if (server->mnt_path) {
73 kfree(server->mnt_path);
74 server->mnt_path = NULL;
76 if (server->nfs4_state) {
77 nfs4_put_client(server->nfs4_state);
78 server->nfs4_state = NULL;
83 * nfs4_get_client(): returns an empty client structure
84 * nfs4_put_client(): drops reference to client structure
86 * Since these are allocated/deallocated very rarely, we don't
87 * bother putting them in a slab cache...
89 static struct nfs4_client *
90 nfs4_alloc_client(struct in_addr *addr)
92 struct nfs4_client *clp;
94 if (nfs_callback_up() < 0)
96 if ((clp = kmalloc(sizeof(*clp), GFP_KERNEL)) == NULL) {
100 memset(clp, 0, sizeof(*clp));
101 memcpy(&clp->cl_addr, addr, sizeof(clp->cl_addr));
102 init_rwsem(&clp->cl_sem);
103 INIT_LIST_HEAD(&clp->cl_delegations);
104 INIT_LIST_HEAD(&clp->cl_state_owners);
105 INIT_LIST_HEAD(&clp->cl_unused);
106 spin_lock_init(&clp->cl_lock);
107 atomic_set(&clp->cl_count, 1);
108 INIT_WORK(&clp->cl_recoverd, nfs4_recover_state, clp);
109 INIT_WORK(&clp->cl_renewd, nfs4_renew_state, clp);
110 INIT_LIST_HEAD(&clp->cl_superblocks);
111 init_waitqueue_head(&clp->cl_waitq);
112 rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS4 client");
113 clp->cl_rpcclient = ERR_PTR(-EINVAL);
114 clp->cl_boot_time = CURRENT_TIME;
115 clp->cl_state = 1 << NFS4CLNT_OK;
120 nfs4_free_client(struct nfs4_client *clp)
122 struct nfs4_state_owner *sp;
124 while (!list_empty(&clp->cl_unused)) {
125 sp = list_entry(clp->cl_unused.next,
126 struct nfs4_state_owner,
128 list_del(&sp->so_list);
131 BUG_ON(!list_empty(&clp->cl_state_owners));
133 put_rpccred(clp->cl_cred);
134 nfs_idmap_delete(clp);
135 if (!IS_ERR(clp->cl_rpcclient))
136 rpc_shutdown_client(clp->cl_rpcclient);
141 static struct nfs4_client *__nfs4_find_client(struct in_addr *addr)
143 struct nfs4_client *clp;
144 list_for_each_entry(clp, &nfs4_clientid_list, cl_servers) {
145 if (memcmp(&clp->cl_addr, addr, sizeof(clp->cl_addr)) == 0) {
146 atomic_inc(&clp->cl_count);
153 struct nfs4_client *nfs4_find_client(struct in_addr *addr)
155 struct nfs4_client *clp;
156 spin_lock(&state_spinlock);
157 clp = __nfs4_find_client(addr);
158 spin_unlock(&state_spinlock);
163 nfs4_get_client(struct in_addr *addr)
165 struct nfs4_client *clp, *new = NULL;
167 spin_lock(&state_spinlock);
169 clp = __nfs4_find_client(addr);
174 list_add(&clp->cl_servers, &nfs4_clientid_list);
178 spin_unlock(&state_spinlock);
179 new = nfs4_alloc_client(addr);
180 spin_lock(&state_spinlock);
184 spin_unlock(&state_spinlock);
186 nfs4_free_client(new);
191 nfs4_put_client(struct nfs4_client *clp)
193 if (!atomic_dec_and_lock(&clp->cl_count, &state_spinlock))
195 list_del(&clp->cl_servers);
196 spin_unlock(&state_spinlock);
197 BUG_ON(!list_empty(&clp->cl_superblocks));
198 wake_up_all(&clp->cl_waitq);
199 rpc_wake_up(&clp->cl_rpcwaitq);
200 nfs4_kill_renewd(clp);
201 nfs4_free_client(clp);
204 static int __nfs4_init_client(struct nfs4_client *clp)
206 int status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, nfs_callback_tcpport);
208 status = nfs4_proc_setclientid_confirm(clp);
210 nfs4_schedule_state_renewal(clp);
214 int nfs4_init_client(struct nfs4_client *clp)
216 return nfs4_map_errors(__nfs4_init_client(clp));
220 nfs4_alloc_lockowner_id(struct nfs4_client *clp)
222 return clp->cl_lockowner_id ++;
225 static struct nfs4_state_owner *
226 nfs4_client_grab_unused(struct nfs4_client *clp, struct rpc_cred *cred)
228 struct nfs4_state_owner *sp = NULL;
230 if (!list_empty(&clp->cl_unused)) {
231 sp = list_entry(clp->cl_unused.next, struct nfs4_state_owner, so_list);
232 atomic_inc(&sp->so_count);
234 list_move(&sp->so_list, &clp->cl_state_owners);
240 static struct nfs4_state_owner *
241 nfs4_find_state_owner(struct nfs4_client *clp, struct rpc_cred *cred)
243 struct nfs4_state_owner *sp, *res = NULL;
245 list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
246 if (sp->so_cred != cred)
248 atomic_inc(&sp->so_count);
249 /* Move to the head of the list */
250 list_move(&sp->so_list, &clp->cl_state_owners);
258 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
259 * create a new state_owner.
262 static struct nfs4_state_owner *
263 nfs4_alloc_state_owner(void)
265 struct nfs4_state_owner *sp;
267 sp = kzalloc(sizeof(*sp),GFP_KERNEL);
270 init_MUTEX(&sp->so_sema);
271 INIT_LIST_HEAD(&sp->so_states);
272 INIT_LIST_HEAD(&sp->so_delegations);
273 rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue");
274 sp->so_seqid.sequence = &sp->so_sequence;
275 spin_lock_init(&sp->so_sequence.lock);
276 INIT_LIST_HEAD(&sp->so_sequence.list);
277 atomic_set(&sp->so_count, 1);
282 nfs4_drop_state_owner(struct nfs4_state_owner *sp)
284 struct nfs4_client *clp = sp->so_client;
285 spin_lock(&clp->cl_lock);
286 list_del_init(&sp->so_list);
287 spin_unlock(&clp->cl_lock);
291 * Note: must be called with clp->cl_sem held in order to prevent races
292 * with reboot recovery!
294 struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, struct rpc_cred *cred)
296 struct nfs4_client *clp = server->nfs4_state;
297 struct nfs4_state_owner *sp, *new;
300 new = nfs4_alloc_state_owner();
301 spin_lock(&clp->cl_lock);
302 sp = nfs4_find_state_owner(clp, cred);
304 sp = nfs4_client_grab_unused(clp, cred);
305 if (sp == NULL && new != NULL) {
306 list_add(&new->so_list, &clp->cl_state_owners);
307 new->so_client = clp;
308 new->so_id = nfs4_alloc_lockowner_id(clp);
313 spin_unlock(&clp->cl_lock);
323 * Must be called with clp->cl_sem held in order to avoid races
324 * with state recovery...
326 void nfs4_put_state_owner(struct nfs4_state_owner *sp)
328 struct nfs4_client *clp = sp->so_client;
329 struct rpc_cred *cred = sp->so_cred;
331 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
333 if (clp->cl_nunused >= OPENOWNER_POOL_SIZE)
335 if (list_empty(&sp->so_list))
337 list_move(&sp->so_list, &clp->cl_unused);
339 spin_unlock(&clp->cl_lock);
344 list_del(&sp->so_list);
345 spin_unlock(&clp->cl_lock);
350 static struct nfs4_state *
351 nfs4_alloc_open_state(void)
353 struct nfs4_state *state;
355 state = kmalloc(sizeof(*state), GFP_KERNEL);
362 memset(state->stateid.data, 0, sizeof(state->stateid.data));
363 atomic_set(&state->count, 1);
364 INIT_LIST_HEAD(&state->lock_states);
365 init_MUTEX(&state->lock_sema);
366 spin_lock_init(&state->state_lock);
370 static struct nfs4_state *
371 __nfs4_find_state(struct inode *inode, struct rpc_cred *cred, mode_t mode)
373 struct nfs_inode *nfsi = NFS_I(inode);
374 struct nfs4_state *state;
376 mode &= (FMODE_READ|FMODE_WRITE);
377 list_for_each_entry(state, &nfsi->open_states, inode_states) {
378 if (state->owner->so_cred != cred)
380 if ((mode & FMODE_READ) != 0 && state->nreaders == 0)
382 if ((mode & FMODE_WRITE) != 0 && state->nwriters == 0)
384 if ((state->state & mode) != mode)
386 atomic_inc(&state->count);
387 if (mode & FMODE_READ)
389 if (mode & FMODE_WRITE)
396 static struct nfs4_state *
397 __nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
399 struct nfs_inode *nfsi = NFS_I(inode);
400 struct nfs4_state *state;
402 list_for_each_entry(state, &nfsi->open_states, inode_states) {
403 /* Is this in the process of being freed? */
404 if (state->nreaders == 0 && state->nwriters == 0)
406 if (state->owner == owner) {
407 atomic_inc(&state->count);
415 nfs4_find_state(struct inode *inode, struct rpc_cred *cred, mode_t mode)
417 struct nfs4_state *state;
419 spin_lock(&inode->i_lock);
420 state = __nfs4_find_state(inode, cred, mode);
421 spin_unlock(&inode->i_lock);
426 nfs4_free_open_state(struct nfs4_state *state)
432 nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
434 struct nfs4_state *state, *new;
435 struct nfs_inode *nfsi = NFS_I(inode);
437 spin_lock(&inode->i_lock);
438 state = __nfs4_find_state_byowner(inode, owner);
439 spin_unlock(&inode->i_lock);
442 new = nfs4_alloc_open_state();
443 spin_lock(&inode->i_lock);
444 state = __nfs4_find_state_byowner(inode, owner);
445 if (state == NULL && new != NULL) {
447 /* Caller *must* be holding owner->so_sem */
448 /* Note: The reclaim code dictates that we add stateless
449 * and read-only stateids to the end of the list */
450 list_add_tail(&state->open_states, &owner->so_states);
451 state->owner = owner;
452 atomic_inc(&owner->so_count);
453 list_add(&state->inode_states, &nfsi->open_states);
454 state->inode = igrab(inode);
455 spin_unlock(&inode->i_lock);
457 spin_unlock(&inode->i_lock);
459 nfs4_free_open_state(new);
466 * Beware! Caller must be holding exactly one
467 * reference to clp->cl_sem and owner->so_sema!
469 void nfs4_put_open_state(struct nfs4_state *state)
471 struct inode *inode = state->inode;
472 struct nfs4_state_owner *owner = state->owner;
474 if (!atomic_dec_and_lock(&state->count, &inode->i_lock))
476 if (!list_empty(&state->inode_states))
477 list_del(&state->inode_states);
478 spin_unlock(&inode->i_lock);
479 list_del(&state->open_states);
481 BUG_ON (state->state != 0);
482 nfs4_free_open_state(state);
483 nfs4_put_state_owner(owner);
487 * Beware! Caller must be holding no references to clp->cl_sem!
490 void nfs4_close_state(struct nfs4_state *state, mode_t mode)
492 struct inode *inode = state->inode;
493 struct nfs4_state_owner *owner = state->owner;
494 struct nfs4_client *clp = owner->so_client;
497 atomic_inc(&owner->so_count);
498 down_read(&clp->cl_sem);
499 down(&owner->so_sema);
500 /* Protect against nfs4_find_state() */
501 spin_lock(&inode->i_lock);
502 if (mode & FMODE_READ)
504 if (mode & FMODE_WRITE)
506 if (state->nwriters == 0) {
507 if (state->nreaders == 0)
508 list_del_init(&state->inode_states);
509 /* See reclaim code */
510 list_move_tail(&state->open_states, &owner->so_states);
512 spin_unlock(&inode->i_lock);
514 if (state->state != 0) {
516 newstate |= FMODE_READ;
518 newstate |= FMODE_WRITE;
519 if (state->state == newstate)
521 if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
522 state->state = newstate;
525 if (nfs4_do_close(inode, state, newstate) == 0)
529 nfs4_put_open_state(state);
531 nfs4_put_state_owner(owner);
532 up_read(&clp->cl_sem);
536 * Search the state->lock_states for an existing lock_owner
537 * that is compatible with current->files
539 static struct nfs4_lock_state *
540 __nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
542 struct nfs4_lock_state *pos;
543 list_for_each_entry(pos, &state->lock_states, ls_locks) {
544 if (pos->ls_owner != fl_owner)
546 atomic_inc(&pos->ls_count);
553 * Return a compatible lock_state. If no initialized lock_state structure
554 * exists, return an uninitialized one.
556 * The caller must be holding state->lock_sema
558 static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
560 struct nfs4_lock_state *lsp;
561 struct nfs4_client *clp = state->owner->so_client;
563 lsp = kzalloc(sizeof(*lsp), GFP_KERNEL);
566 lsp->ls_seqid.sequence = &state->owner->so_sequence;
567 atomic_set(&lsp->ls_count, 1);
568 lsp->ls_owner = fl_owner;
569 spin_lock(&clp->cl_lock);
570 lsp->ls_id = nfs4_alloc_lockowner_id(clp);
571 spin_unlock(&clp->cl_lock);
572 INIT_LIST_HEAD(&lsp->ls_locks);
577 * Return a compatible lock_state. If no initialized lock_state structure
578 * exists, return an uninitialized one.
580 * The caller must be holding state->lock_sema and clp->cl_sem
582 static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
584 struct nfs4_lock_state *lsp, *new = NULL;
587 spin_lock(&state->state_lock);
588 lsp = __nfs4_find_lock_state(state, owner);
592 new->ls_state = state;
593 list_add(&new->ls_locks, &state->lock_states);
594 set_bit(LK_STATE_IN_USE, &state->flags);
599 spin_unlock(&state->state_lock);
600 new = nfs4_alloc_lock_state(state, owner);
604 spin_unlock(&state->state_lock);
610 * Release reference to lock_state, and free it if we see that
611 * it is no longer in use
613 static void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
615 struct nfs4_state *state;
619 state = lsp->ls_state;
620 if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
622 list_del(&lsp->ls_locks);
623 if (list_empty(&state->lock_states))
624 clear_bit(LK_STATE_IN_USE, &state->flags);
625 spin_unlock(&state->state_lock);
629 static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
631 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
633 dst->fl_u.nfs4_fl.owner = lsp;
634 atomic_inc(&lsp->ls_count);
637 static void nfs4_fl_release_lock(struct file_lock *fl)
639 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
642 static struct file_lock_operations nfs4_fl_lock_ops = {
643 .fl_copy_lock = nfs4_fl_copy_lock,
644 .fl_release_private = nfs4_fl_release_lock,
647 int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
649 struct nfs4_lock_state *lsp;
651 if (fl->fl_ops != NULL)
653 lsp = nfs4_get_lock_state(state, fl->fl_owner);
656 fl->fl_u.nfs4_fl.owner = lsp;
657 fl->fl_ops = &nfs4_fl_lock_ops;
662 * Byte-range lock aware utility to initialize the stateid of read/write
665 void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner)
667 struct nfs4_lock_state *lsp;
669 memcpy(dst, &state->stateid, sizeof(*dst));
670 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
673 spin_lock(&state->state_lock);
674 lsp = __nfs4_find_lock_state(state, fl_owner);
675 if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
676 memcpy(dst, &lsp->ls_stateid, sizeof(*dst));
677 spin_unlock(&state->state_lock);
678 nfs4_put_lock_state(lsp);
681 struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter)
683 struct rpc_sequence *sequence = counter->sequence;
684 struct nfs_seqid *new;
686 new = kmalloc(sizeof(*new), GFP_KERNEL);
688 new->sequence = counter;
690 spin_lock(&sequence->lock);
691 list_add_tail(&new->list, &sequence->list);
692 spin_unlock(&sequence->lock);
697 void nfs_free_seqid(struct nfs_seqid *seqid)
699 struct rpc_sequence *sequence = seqid->sequence->sequence;
700 struct rpc_task *next = NULL;
702 spin_lock(&sequence->lock);
703 list_del(&seqid->list);
704 if (!list_empty(&sequence->list)) {
705 next = list_entry(sequence->list.next, struct nfs_seqid, list)->task;
707 rpc_wake_up_task(next);
709 spin_unlock(&sequence->lock);
714 * Called with sp->so_sema and clp->cl_sem held.
716 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
717 * failed with a seqid incrementing error -
718 * see comments nfs_fs.h:seqid_mutating_error()
720 static inline void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
725 case -NFS4ERR_BAD_SEQID:
726 case -NFS4ERR_STALE_CLIENTID:
727 case -NFS4ERR_STALE_STATEID:
728 case -NFS4ERR_BAD_STATEID:
729 case -NFS4ERR_BADXDR:
730 case -NFS4ERR_RESOURCE:
731 case -NFS4ERR_NOFILEHANDLE:
732 /* Non-seqid mutating errors */
736 * Note: no locking needed as we are guaranteed to be first
737 * on the sequence list
739 seqid->sequence->counter++;
742 void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
744 if (status == -NFS4ERR_BAD_SEQID) {
745 struct nfs4_state_owner *sp = container_of(seqid->sequence,
746 struct nfs4_state_owner, so_seqid);
747 nfs4_drop_state_owner(sp);
749 return nfs_increment_seqid(status, seqid);
753 * Called with ls->lock_sema and clp->cl_sem held.
755 * Increment the seqid if the LOCK/LOCKU succeeded, or
756 * failed with a seqid incrementing error -
757 * see comments nfs_fs.h:seqid_mutating_error()
759 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
761 return nfs_increment_seqid(status, seqid);
764 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
766 struct rpc_sequence *sequence = seqid->sequence->sequence;
769 spin_lock(&sequence->lock);
770 if (sequence->list.next != &seqid->list) {
772 rpc_sleep_on(&sequence->wait, task, NULL, NULL);
775 spin_unlock(&sequence->lock);
779 static int reclaimer(void *);
780 struct reclaimer_args {
781 struct nfs4_client *clp;
782 struct completion complete;
786 * State recovery routine
789 nfs4_recover_state(void *data)
791 struct nfs4_client *clp = (struct nfs4_client *)data;
792 struct reclaimer_args args = {
797 init_completion(&args.complete);
799 if (kernel_thread(reclaimer, &args, CLONE_KERNEL) < 0)
800 goto out_failed_clear;
801 wait_for_completion(&args.complete);
804 set_bit(NFS4CLNT_OK, &clp->cl_state);
805 wake_up_all(&clp->cl_waitq);
806 rpc_wake_up(&clp->cl_rpcwaitq);
810 * Schedule a state recovery attempt
813 nfs4_schedule_state_recovery(struct nfs4_client *clp)
817 if (test_and_clear_bit(NFS4CLNT_OK, &clp->cl_state))
818 schedule_work(&clp->cl_recoverd);
821 static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_state *state)
823 struct inode *inode = state->inode;
824 struct file_lock *fl;
827 for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
828 if (!(fl->fl_flags & FL_POSIX))
830 if (((struct nfs_open_context *)fl->fl_file->private_data)->state != state)
832 status = ops->recover_lock(state, fl);
837 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
838 __FUNCTION__, status);
839 case -NFS4ERR_EXPIRED:
840 case -NFS4ERR_NO_GRACE:
841 case -NFS4ERR_RECLAIM_BAD:
842 case -NFS4ERR_RECLAIM_CONFLICT:
843 /* kill_proc(fl->fl_owner, SIGLOST, 1); */
845 case -NFS4ERR_STALE_CLIENTID:
854 static int nfs4_reclaim_open_state(struct nfs4_state_recovery_ops *ops, struct nfs4_state_owner *sp)
856 struct nfs4_state *state;
857 struct nfs4_lock_state *lock;
860 /* Note: we rely on the sp->so_states list being ordered
861 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
863 * This is needed to ensure that the server won't give us any
864 * read delegations that we have to return if, say, we are
865 * recovering after a network partition or a reboot from a
866 * server that doesn't support a grace period.
868 list_for_each_entry(state, &sp->so_states, open_states) {
869 if (state->state == 0)
871 status = ops->recover_open(sp, state);
873 status = nfs4_reclaim_locks(ops, state);
876 list_for_each_entry(lock, &state->lock_states, ls_locks) {
877 if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
878 printk("%s: Lock reclaim failed!\n",
885 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
886 __FUNCTION__, status);
888 case -NFS4ERR_RECLAIM_BAD:
889 case -NFS4ERR_RECLAIM_CONFLICT:
891 * Open state on this file cannot be recovered
892 * All we can do is revert to using the zero stateid.
894 memset(state->stateid.data, 0,
895 sizeof(state->stateid.data));
896 /* Mark the file as being 'closed' */
899 case -NFS4ERR_EXPIRED:
900 case -NFS4ERR_NO_GRACE:
901 case -NFS4ERR_STALE_CLIENTID:
910 static void nfs4_state_mark_reclaim(struct nfs4_client *clp)
912 struct nfs4_state_owner *sp;
913 struct nfs4_state *state;
914 struct nfs4_lock_state *lock;
916 /* Reset all sequence ids to zero */
917 list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
918 sp->so_seqid.counter = 0;
919 sp->so_seqid.flags = 0;
920 list_for_each_entry(state, &sp->so_states, open_states) {
921 list_for_each_entry(lock, &state->lock_states, ls_locks) {
922 lock->ls_seqid.counter = 0;
923 lock->ls_seqid.flags = 0;
924 lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
930 static int reclaimer(void *ptr)
932 struct reclaimer_args *args = (struct reclaimer_args *)ptr;
933 struct nfs4_client *clp = args->clp;
934 struct nfs4_state_owner *sp;
935 struct nfs4_state_recovery_ops *ops;
938 daemonize("%u.%u.%u.%u-reclaim", NIPQUAD(clp->cl_addr));
939 allow_signal(SIGKILL);
941 atomic_inc(&clp->cl_count);
942 complete(&args->complete);
944 /* Ensure exclusive access to NFSv4 state */
946 down_write(&clp->cl_sem);
947 /* Are there any NFS mounts out there? */
948 if (list_empty(&clp->cl_superblocks))
951 status = nfs4_proc_renew(clp);
954 case -NFS4ERR_CB_PATH_DOWN:
956 case -NFS4ERR_STALE_CLIENTID:
957 case -NFS4ERR_LEASE_MOVED:
958 ops = &nfs4_reboot_recovery_ops;
961 ops = &nfs4_network_partition_recovery_ops;
963 nfs4_state_mark_reclaim(clp);
964 status = __nfs4_init_client(clp);
967 /* Mark all delegations for reclaim */
968 nfs_delegation_mark_reclaim(clp);
969 /* Note: list is protected by exclusive lock on cl->cl_sem */
970 list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
971 status = nfs4_reclaim_open_state(ops, sp);
973 if (status == -NFS4ERR_NO_GRACE) {
974 ops = &nfs4_network_partition_recovery_ops;
975 status = nfs4_reclaim_open_state(ops, sp);
977 if (status == -NFS4ERR_STALE_CLIENTID)
979 if (status == -NFS4ERR_EXPIRED)
983 nfs_delegation_reap_unclaimed(clp);
985 set_bit(NFS4CLNT_OK, &clp->cl_state);
986 up_write(&clp->cl_sem);
988 wake_up_all(&clp->cl_waitq);
989 rpc_wake_up(&clp->cl_rpcwaitq);
990 if (status == -NFS4ERR_CB_PATH_DOWN)
991 nfs_handle_cb_pathdown(clp);
992 nfs4_put_client(clp);
995 printk(KERN_WARNING "Error: state recovery failed on NFSv4 server %u.%u.%u.%u with error %d\n",
996 NIPQUAD(clp->cl_addr.s_addr), -status);