blob: 6d263ed79e92d56f8e65deca2ff12d24226f7926 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/nfs/nfs4state.c
3 *
4 * Client-side XDR for NFSv4.
5 *
6 * Copyright (c) 2002 The Regents of the University of Michigan.
7 * All rights reserved.
8 *
9 * Kendrick Smith <kmsmith@umich.edu>
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 *
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
25 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
26 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
27 * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
31 * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
32 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
33 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
34 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 *
36 * Implementation of the NFSv4 state model. For the time being,
37 * this is minimal, but will be made much more complex in a
38 * subsequent patch.
39 */
40
Trond Myklebust6f43ddc2007-07-08 16:49:11 -040041#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#include <linux/slab.h>
43#include <linux/smp_lock.h>
44#include <linux/nfs_fs.h>
45#include <linux/nfs_idmap.h>
Trond Myklebust5043e902006-01-03 09:55:23 +010046#include <linux/kthread.h>
47#include <linux/module.h>
Trond Myklebust9f958ab2007-07-02 13:58:33 -040048#include <linux/random.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include <linux/workqueue.h>
50#include <linux/bitops.h>
51
Trond Myklebust4ce79712005-06-22 17:16:21 +000052#include "nfs4_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include "callback.h"
54#include "delegation.h"
David Howells24c8dbb2006-08-22 20:06:10 -040055#include "internal.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070056
57#define OPENOWNER_POOL_SIZE 8
58
Trond Myklebust4ce79712005-06-22 17:16:21 +000059const nfs4_stateid zero_stateid;
60
Linus Torvalds1da177e2005-04-16 15:20:36 -070061static LIST_HEAD(nfs4_clientid_list);
62
Andy Adamson591d71c2009-04-01 09:22:47 -040063int nfs4_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -070064{
Chuck Leverf738f512009-03-18 20:48:06 -040065 unsigned short port;
66 int status;
67
68 port = nfs_callback_tcpport;
69 if (clp->cl_addr.ss_family == AF_INET6)
70 port = nfs_callback_tcpport6;
71
72 status = nfs4_proc_setclientid(clp, NFS4_CALLBACK, port, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 if (status == 0)
Trond Myklebust286d7d62006-01-03 09:55:26 +010074 status = nfs4_proc_setclientid_confirm(clp, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -070075 if (status == 0)
76 nfs4_schedule_state_renewal(clp);
77 return status;
78}
79
Andy Adamsona7b72102009-04-01 09:22:46 -040080struct rpc_cred *nfs4_get_machine_cred_locked(struct nfs_client *clp)
Trond Myklebusta2b2bb82008-04-08 16:02:17 -040081{
82 struct rpc_cred *cred = NULL;
83
Trond Myklebusta2b2bb82008-04-08 16:02:17 -040084 if (clp->cl_machine_cred != NULL)
85 cred = get_rpccred(clp->cl_machine_cred);
Trond Myklebusta2b2bb82008-04-08 16:02:17 -040086 return cred;
87}
88
89static void nfs4_clear_machine_cred(struct nfs_client *clp)
90{
91 struct rpc_cred *cred;
92
93 spin_lock(&clp->cl_lock);
94 cred = clp->cl_machine_cred;
95 clp->cl_machine_cred = NULL;
96 spin_unlock(&clp->cl_lock);
97 if (cred != NULL)
98 put_rpccred(cred);
99}
100
Trond Myklebust6dc9d572008-12-23 15:21:41 -0500101struct rpc_cred *nfs4_get_renew_cred_locked(struct nfs_client *clp)
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100102{
103 struct nfs4_state_owner *sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400104 struct rb_node *pos;
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100105 struct rpc_cred *cred = NULL;
106
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400107 for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
108 sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
Trond Myklebustb4454fe2006-01-03 09:55:25 +0100109 if (list_empty(&sp->so_states))
110 continue;
111 cred = get_rpccred(sp->so_cred);
112 break;
113 }
114 return cred;
115}
116
Andy Adamsonb4b82602009-04-01 09:22:49 -0400117#if defined(CONFIG_NFS_V4_1)
118
Ricardo Labiaga9430fb62009-12-06 12:23:46 -0500119static int nfs41_setup_state_renewal(struct nfs_client *clp)
120{
121 int status;
122 struct nfs_fsinfo fsinfo;
123
124 status = nfs4_proc_get_lease_time(clp, &fsinfo);
125 if (status == 0) {
126 /* Update lease time and schedule renewal */
127 spin_lock(&clp->cl_lock);
128 clp->cl_lease_time = fsinfo.lease_time * HZ;
129 clp->cl_last_renewal = jiffies;
130 spin_unlock(&clp->cl_lock);
131
132 nfs4_schedule_state_renewal(clp);
133 }
134
135 return status;
136}
137
Alexandros Batsakis5601a002009-12-14 21:27:58 -0800138static void nfs4_end_drain_session(struct nfs_client *clp)
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500139{
Alexandros Batsakis5601a002009-12-14 21:27:58 -0800140 struct nfs4_session *ses = clp->cl_session;
Alexandros Batsakis689cf5c2009-12-14 21:27:56 -0800141 int max_slots;
142
143 if (test_and_clear_bit(NFS4CLNT_SESSION_DRAINING, &clp->cl_state)) {
144 spin_lock(&ses->fc_slot_table.slot_tbl_lock);
145 max_slots = ses->fc_slot_table.max_slots;
146 while (max_slots--) {
147 struct rpc_task *task;
148
149 task = rpc_wake_up_next(&ses->fc_slot_table.
150 slot_tbl_waitq);
151 if (!task)
152 break;
153 rpc_task_set_priority(task, RPC_PRIORITY_PRIVILEGED);
154 }
155 spin_unlock(&ses->fc_slot_table.slot_tbl_lock);
156 }
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500157}
158
Alexandros Batsakis5601a002009-12-14 21:27:58 -0800159static int nfs4_begin_drain_session(struct nfs_client *clp)
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500160{
Alexandros Batsakis5601a002009-12-14 21:27:58 -0800161 struct nfs4_session *ses = clp->cl_session;
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -0500162 struct nfs4_slot_table *tbl = &ses->fc_slot_table;
163
164 spin_lock(&tbl->slot_tbl_lock);
165 set_bit(NFS4CLNT_SESSION_DRAINING, &clp->cl_state);
166 if (tbl->highest_used_slotid != -1) {
167 INIT_COMPLETION(ses->complete);
168 spin_unlock(&tbl->slot_tbl_lock);
169 return wait_for_completion_interruptible(&ses->complete);
170 }
171 spin_unlock(&tbl->slot_tbl_lock);
172 return 0;
173}
174
Andy Adamson4d643d12009-12-04 15:52:24 -0500175int nfs41_init_clientid(struct nfs_client *clp, struct rpc_cred *cred)
176{
177 int status;
178
Trond Myklebust38045412009-12-15 17:36:57 -0500179 nfs4_begin_drain_session(clp);
Andy Adamson4d643d12009-12-04 15:52:24 -0500180 status = nfs4_proc_exchange_id(clp, cred);
Ricardo Labiaga9430fb62009-12-06 12:23:46 -0500181 if (status != 0)
182 goto out;
183 status = nfs4_proc_create_session(clp);
184 if (status != 0)
185 goto out;
186 nfs41_setup_state_renewal(clp);
187 nfs_mark_client_ready(clp, NFS_CS_READY);
188out:
Andy Adamson4d643d12009-12-04 15:52:24 -0500189 return status;
190}
191
Andy Adamsonb4b82602009-04-01 09:22:49 -0400192struct rpc_cred *nfs4_get_exchange_id_cred(struct nfs_client *clp)
193{
194 struct rpc_cred *cred;
195
196 spin_lock(&clp->cl_lock);
197 cred = nfs4_get_machine_cred_locked(clp);
198 spin_unlock(&clp->cl_lock);
199 return cred;
200}
201
202#endif /* CONFIG_NFS_V4_1 */
203
Andy Adamsona7b72102009-04-01 09:22:46 -0400204struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
Trond Myklebust286d7d62006-01-03 09:55:26 +0100205{
206 struct nfs4_state_owner *sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400207 struct rb_node *pos;
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400208 struct rpc_cred *cred;
Trond Myklebust286d7d62006-01-03 09:55:26 +0100209
Trond Myklebust6dc9d572008-12-23 15:21:41 -0500210 spin_lock(&clp->cl_lock);
211 cred = nfs4_get_machine_cred_locked(clp);
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400212 if (cred != NULL)
213 goto out;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400214 pos = rb_first(&clp->cl_state_owners);
215 if (pos != NULL) {
216 sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400217 cred = get_rpccred(sp->so_cred);
Trond Myklebust286d7d62006-01-03 09:55:26 +0100218 }
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400219out:
Trond Myklebust6dc9d572008-12-23 15:21:41 -0500220 spin_unlock(&clp->cl_lock);
Trond Myklebusta2b2bb82008-04-08 16:02:17 -0400221 return cred;
Trond Myklebust286d7d62006-01-03 09:55:26 +0100222}
223
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400224static void nfs_alloc_unique_id(struct rb_root *root, struct nfs_unique_id *new,
225 __u64 minval, int maxbits)
226{
227 struct rb_node **p, *parent;
228 struct nfs_unique_id *pos;
229 __u64 mask = ~0ULL;
230
231 if (maxbits < 64)
232 mask = (1ULL << maxbits) - 1ULL;
233
234 /* Ensure distribution is more or less flat */
235 get_random_bytes(&new->id, sizeof(new->id));
236 new->id &= mask;
237 if (new->id < minval)
238 new->id += minval;
239retry:
240 p = &root->rb_node;
241 parent = NULL;
242
243 while (*p != NULL) {
244 parent = *p;
245 pos = rb_entry(parent, struct nfs_unique_id, rb_node);
246
247 if (new->id < pos->id)
248 p = &(*p)->rb_left;
249 else if (new->id > pos->id)
250 p = &(*p)->rb_right;
251 else
252 goto id_exists;
253 }
254 rb_link_node(&new->rb_node, parent, p);
255 rb_insert_color(&new->rb_node, root);
256 return;
257id_exists:
258 for (;;) {
259 new->id++;
260 if (new->id < minval || (new->id & mask) != new->id) {
261 new->id = minval;
262 break;
263 }
264 parent = rb_next(parent);
265 if (parent == NULL)
266 break;
267 pos = rb_entry(parent, struct nfs_unique_id, rb_node);
268 if (new->id < pos->id)
269 break;
270 }
271 goto retry;
272}
273
274static void nfs_free_unique_id(struct rb_root *root, struct nfs_unique_id *id)
275{
276 rb_erase(&id->rb_node, root);
277}
278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279static struct nfs4_state_owner *
Trond Myklebust6f2e64d2007-07-06 10:53:21 -0400280nfs4_find_state_owner(struct nfs_server *server, struct rpc_cred *cred)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
Trond Myklebust6f2e64d2007-07-06 10:53:21 -0400282 struct nfs_client *clp = server->nfs_client;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400283 struct rb_node **p = &clp->cl_state_owners.rb_node,
284 *parent = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 struct nfs4_state_owner *sp, *res = NULL;
286
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400287 while (*p != NULL) {
288 parent = *p;
289 sp = rb_entry(parent, struct nfs4_state_owner, so_client_node);
290
Trond Myklebust6f2e64d2007-07-06 10:53:21 -0400291 if (server < sp->so_server) {
292 p = &parent->rb_left;
293 continue;
294 }
295 if (server > sp->so_server) {
296 p = &parent->rb_right;
297 continue;
298 }
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400299 if (cred < sp->so_cred)
300 p = &parent->rb_left;
301 else if (cred > sp->so_cred)
302 p = &parent->rb_right;
303 else {
304 atomic_inc(&sp->so_count);
305 res = sp;
306 break;
307 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 }
309 return res;
310}
311
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400312static struct nfs4_state_owner *
313nfs4_insert_state_owner(struct nfs_client *clp, struct nfs4_state_owner *new)
314{
315 struct rb_node **p = &clp->cl_state_owners.rb_node,
316 *parent = NULL;
317 struct nfs4_state_owner *sp;
318
319 while (*p != NULL) {
320 parent = *p;
321 sp = rb_entry(parent, struct nfs4_state_owner, so_client_node);
322
Trond Myklebust6f2e64d2007-07-06 10:53:21 -0400323 if (new->so_server < sp->so_server) {
324 p = &parent->rb_left;
325 continue;
326 }
327 if (new->so_server > sp->so_server) {
328 p = &parent->rb_right;
329 continue;
330 }
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400331 if (new->so_cred < sp->so_cred)
332 p = &parent->rb_left;
333 else if (new->so_cred > sp->so_cred)
334 p = &parent->rb_right;
335 else {
336 atomic_inc(&sp->so_count);
337 return sp;
338 }
339 }
340 nfs_alloc_unique_id(&clp->cl_openowner_id, &new->so_owner_id, 1, 64);
341 rb_link_node(&new->so_client_node, parent, p);
342 rb_insert_color(&new->so_client_node, &clp->cl_state_owners);
343 return new;
344}
345
346static void
347nfs4_remove_state_owner(struct nfs_client *clp, struct nfs4_state_owner *sp)
348{
349 if (!RB_EMPTY_NODE(&sp->so_client_node))
350 rb_erase(&sp->so_client_node, &clp->cl_state_owners);
351 nfs_free_unique_id(&clp->cl_openowner_id, &sp->so_owner_id);
352}
353
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354/*
355 * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
356 * create a new state_owner.
357 *
358 */
359static struct nfs4_state_owner *
360nfs4_alloc_state_owner(void)
361{
362 struct nfs4_state_owner *sp;
363
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700364 sp = kzalloc(sizeof(*sp),GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 if (!sp)
366 return NULL;
Trond Myklebustec073422005-10-20 14:22:47 -0700367 spin_lock_init(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368 INIT_LIST_HEAD(&sp->so_states);
369 INIT_LIST_HEAD(&sp->so_delegations);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700370 rpc_init_wait_queue(&sp->so_sequence.wait, "Seqid_waitqueue");
371 sp->so_seqid.sequence = &sp->so_sequence;
372 spin_lock_init(&sp->so_sequence.lock);
373 INIT_LIST_HEAD(&sp->so_sequence.list);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 atomic_set(&sp->so_count, 1);
375 return sp;
376}
377
Adrian Bunk1d2e88e2008-05-02 13:42:45 -0700378static void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379nfs4_drop_state_owner(struct nfs4_state_owner *sp)
380{
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400381 if (!RB_EMPTY_NODE(&sp->so_client_node)) {
382 struct nfs_client *clp = sp->so_client;
383
384 spin_lock(&clp->cl_lock);
385 rb_erase(&sp->so_client_node, &clp->cl_state_owners);
386 RB_CLEAR_NODE(&sp->so_client_node);
387 spin_unlock(&clp->cl_lock);
388 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389}
390
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, struct rpc_cred *cred)
392{
David Howells7539bba2006-08-22 20:06:09 -0400393 struct nfs_client *clp = server->nfs_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 struct nfs4_state_owner *sp, *new;
395
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396 spin_lock(&clp->cl_lock);
Trond Myklebust6f2e64d2007-07-06 10:53:21 -0400397 sp = nfs4_find_state_owner(server, cred);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 spin_unlock(&clp->cl_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 if (sp != NULL)
400 return sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400401 new = nfs4_alloc_state_owner();
402 if (new == NULL)
403 return NULL;
404 new->so_client = clp;
Trond Myklebust6f2e64d2007-07-06 10:53:21 -0400405 new->so_server = server;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400406 new->so_cred = cred;
407 spin_lock(&clp->cl_lock);
408 sp = nfs4_insert_state_owner(clp, new);
409 spin_unlock(&clp->cl_lock);
410 if (sp == new)
411 get_rpccred(cred);
Trond Myklebustf6a1cc82008-02-22 17:06:55 -0500412 else {
413 rpc_destroy_wait_queue(&new->so_sequence.wait);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400414 kfree(new);
Trond Myklebustf6a1cc82008-02-22 17:06:55 -0500415 }
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400416 return sp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417}
418
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419void nfs4_put_state_owner(struct nfs4_state_owner *sp)
420{
David Howellsadfa6f92006-08-22 20:06:08 -0400421 struct nfs_client *clp = sp->so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 struct rpc_cred *cred = sp->so_cred;
423
424 if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
425 return;
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400426 nfs4_remove_state_owner(clp, sp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 spin_unlock(&clp->cl_lock);
Trond Myklebustf6a1cc82008-02-22 17:06:55 -0500428 rpc_destroy_wait_queue(&sp->so_sequence.wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429 put_rpccred(cred);
430 kfree(sp);
431}
432
433static struct nfs4_state *
434nfs4_alloc_open_state(void)
435{
436 struct nfs4_state *state;
437
Trond Myklebuste7616922006-01-03 09:55:13 +0100438 state = kzalloc(sizeof(*state), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 if (!state)
440 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 atomic_set(&state->count, 1);
442 INIT_LIST_HEAD(&state->lock_states);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000443 spin_lock_init(&state->state_lock);
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400444 seqlock_init(&state->seqlock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 return state;
446}
447
Trond Myklebust4cecb762005-11-04 15:32:58 -0500448void
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500449nfs4_state_set_mode_locked(struct nfs4_state *state, fmode_t fmode)
Trond Myklebust4cecb762005-11-04 15:32:58 -0500450{
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500451 if (state->state == fmode)
Trond Myklebust4cecb762005-11-04 15:32:58 -0500452 return;
453 /* NB! List reordering - see the reclaim code for why. */
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500454 if ((fmode & FMODE_WRITE) != (state->state & FMODE_WRITE)) {
455 if (fmode & FMODE_WRITE)
Trond Myklebust4cecb762005-11-04 15:32:58 -0500456 list_move(&state->open_states, &state->owner->so_states);
457 else
458 list_move_tail(&state->open_states, &state->owner->so_states);
459 }
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500460 state->state = fmode;
Trond Myklebust4cecb762005-11-04 15:32:58 -0500461}
462
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463static struct nfs4_state *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464__nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
465{
466 struct nfs_inode *nfsi = NFS_I(inode);
467 struct nfs4_state *state;
468
469 list_for_each_entry(state, &nfsi->open_states, inode_states) {
Trond Myklebust1c816ef2007-07-03 14:41:19 -0400470 if (state->owner != owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 continue;
Trond Myklebust1c816ef2007-07-03 14:41:19 -0400472 if (atomic_inc_not_zero(&state->count))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 return state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 }
475 return NULL;
476}
477
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478static void
479nfs4_free_open_state(struct nfs4_state *state)
480{
481 kfree(state);
482}
483
484struct nfs4_state *
485nfs4_get_open_state(struct inode *inode, struct nfs4_state_owner *owner)
486{
487 struct nfs4_state *state, *new;
488 struct nfs_inode *nfsi = NFS_I(inode);
489
490 spin_lock(&inode->i_lock);
491 state = __nfs4_find_state_byowner(inode, owner);
492 spin_unlock(&inode->i_lock);
493 if (state)
494 goto out;
495 new = nfs4_alloc_open_state();
Trond Myklebustec073422005-10-20 14:22:47 -0700496 spin_lock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 spin_lock(&inode->i_lock);
498 state = __nfs4_find_state_byowner(inode, owner);
499 if (state == NULL && new != NULL) {
500 state = new;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 state->owner = owner;
502 atomic_inc(&owner->so_count);
503 list_add(&state->inode_states, &nfsi->open_states);
504 state->inode = igrab(inode);
505 spin_unlock(&inode->i_lock);
Trond Myklebustec073422005-10-20 14:22:47 -0700506 /* Note: The reclaim code dictates that we add stateless
507 * and read-only stateids to the end of the list */
508 list_add_tail(&state->open_states, &owner->so_states);
509 spin_unlock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 } else {
511 spin_unlock(&inode->i_lock);
Trond Myklebustec073422005-10-20 14:22:47 -0700512 spin_unlock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513 if (new)
514 nfs4_free_open_state(new);
515 }
516out:
517 return state;
518}
519
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520void nfs4_put_open_state(struct nfs4_state *state)
521{
522 struct inode *inode = state->inode;
523 struct nfs4_state_owner *owner = state->owner;
524
Trond Myklebustec073422005-10-20 14:22:47 -0700525 if (!atomic_dec_and_lock(&state->count, &owner->so_lock))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 return;
Trond Myklebustec073422005-10-20 14:22:47 -0700527 spin_lock(&inode->i_lock);
Trond Myklebustba6830312007-07-27 10:23:05 -0400528 list_del(&state->inode_states);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529 list_del(&state->open_states);
Trond Myklebustec073422005-10-20 14:22:47 -0700530 spin_unlock(&inode->i_lock);
531 spin_unlock(&owner->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 iput(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 nfs4_free_open_state(state);
534 nfs4_put_state_owner(owner);
535}
536
537/*
Trond Myklebust83c9d412005-10-18 14:20:13 -0700538 * Close the current file.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 */
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500540static void __nfs4_close(struct path *path, struct nfs4_state *state, fmode_t fmode, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 struct nfs4_state_owner *owner = state->owner;
Trond Myklebust003707c2007-07-05 18:07:55 -0400543 int call_close = 0;
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500544 fmode_t newstate;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
546 atomic_inc(&owner->so_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /* Protect against nfs4_find_state() */
Trond Myklebustec073422005-10-20 14:22:47 -0700548 spin_lock(&owner->so_lock);
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500549 switch (fmode & (FMODE_READ | FMODE_WRITE)) {
Trond Myklebuste7616922006-01-03 09:55:13 +0100550 case FMODE_READ:
551 state->n_rdonly--;
552 break;
553 case FMODE_WRITE:
554 state->n_wronly--;
555 break;
556 case FMODE_READ|FMODE_WRITE:
557 state->n_rdwr--;
558 }
Trond Myklebust003707c2007-07-05 18:07:55 -0400559 newstate = FMODE_READ|FMODE_WRITE;
Trond Myklebuste7616922006-01-03 09:55:13 +0100560 if (state->n_rdwr == 0) {
Trond Myklebust003707c2007-07-05 18:07:55 -0400561 if (state->n_rdonly == 0) {
Trond Myklebuste7616922006-01-03 09:55:13 +0100562 newstate &= ~FMODE_READ;
Trond Myklebust003707c2007-07-05 18:07:55 -0400563 call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
564 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
565 }
566 if (state->n_wronly == 0) {
Trond Myklebuste7616922006-01-03 09:55:13 +0100567 newstate &= ~FMODE_WRITE;
Trond Myklebust003707c2007-07-05 18:07:55 -0400568 call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
569 call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
570 }
571 if (newstate == 0)
572 clear_bit(NFS_DELEGATED_STATE, &state->flags);
Trond Myklebuste7616922006-01-03 09:55:13 +0100573 }
Trond Myklebust003707c2007-07-05 18:07:55 -0400574 nfs4_state_set_mode_locked(state, newstate);
Trond Myklebustec073422005-10-20 14:22:47 -0700575 spin_unlock(&owner->so_lock);
Trond Myklebust4cecb762005-11-04 15:32:58 -0500576
Trond Myklebust003707c2007-07-05 18:07:55 -0400577 if (!call_close) {
Trond Myklebustb39e6252007-06-11 23:05:07 -0400578 nfs4_put_open_state(state);
579 nfs4_put_state_owner(owner);
580 } else
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400581 nfs4_do_close(path, state, wait);
582}
583
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500584void nfs4_close_state(struct path *path, struct nfs4_state *state, fmode_t fmode)
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400585{
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500586 __nfs4_close(path, state, fmode, 0);
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400587}
588
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500589void nfs4_close_sync(struct path *path, struct nfs4_state *state, fmode_t fmode)
Trond Myklebusta49c3c72007-10-18 18:03:27 -0400590{
Trond Myklebustdc0b0272008-12-23 15:21:56 -0500591 __nfs4_close(path, state, fmode, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592}
593
594/*
595 * Search the state->lock_states for an existing lock_owner
596 * that is compatible with current->files
597 */
598static struct nfs4_lock_state *
599__nfs4_find_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
600{
601 struct nfs4_lock_state *pos;
602 list_for_each_entry(pos, &state->lock_states, ls_locks) {
603 if (pos->ls_owner != fl_owner)
604 continue;
605 atomic_inc(&pos->ls_count);
606 return pos;
607 }
608 return NULL;
609}
610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611/*
612 * Return a compatible lock_state. If no initialized lock_state structure
613 * exists, return an uninitialized one.
614 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 */
616static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, fl_owner_t fl_owner)
617{
618 struct nfs4_lock_state *lsp;
David Howellsadfa6f92006-08-22 20:06:08 -0400619 struct nfs_client *clp = state->owner->so_client;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700621 lsp = kzalloc(sizeof(*lsp), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 if (lsp == NULL)
623 return NULL;
Trond Myklebustd0dc3702008-01-10 16:07:54 -0500624 rpc_init_wait_queue(&lsp->ls_sequence.wait, "lock_seqid_waitqueue");
625 spin_lock_init(&lsp->ls_sequence.lock);
626 INIT_LIST_HEAD(&lsp->ls_sequence.list);
627 lsp->ls_seqid.sequence = &lsp->ls_sequence;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 atomic_set(&lsp->ls_count, 1);
Trond Myklebustb64aec82009-07-21 16:47:46 -0400629 lsp->ls_state = state;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 lsp->ls_owner = fl_owner;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 spin_lock(&clp->cl_lock);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400632 nfs_alloc_unique_id(&clp->cl_lockowner_id, &lsp->ls_id, 1, 64);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 spin_unlock(&clp->cl_lock);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000634 INIT_LIST_HEAD(&lsp->ls_locks);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 return lsp;
636}
637
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400638static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
639{
640 struct nfs_client *clp = lsp->ls_state->owner->so_client;
641
642 spin_lock(&clp->cl_lock);
643 nfs_free_unique_id(&clp->cl_lockowner_id, &lsp->ls_id);
644 spin_unlock(&clp->cl_lock);
Trond Myklebustf6a1cc82008-02-22 17:06:55 -0500645 rpc_destroy_wait_queue(&lsp->ls_sequence.wait);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400646 kfree(lsp);
647}
648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649/*
650 * Return a compatible lock_state. If no initialized lock_state structure
651 * exists, return an uninitialized one.
652 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 */
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000654static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_owner_t owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700655{
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000656 struct nfs4_lock_state *lsp, *new = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000658 for(;;) {
659 spin_lock(&state->state_lock);
660 lsp = __nfs4_find_lock_state(state, owner);
661 if (lsp != NULL)
662 break;
663 if (new != NULL) {
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000664 list_add(&new->ls_locks, &state->lock_states);
665 set_bit(LK_STATE_IN_USE, &state->flags);
666 lsp = new;
667 new = NULL;
668 break;
669 }
670 spin_unlock(&state->state_lock);
671 new = nfs4_alloc_lock_state(state, owner);
672 if (new == NULL)
673 return NULL;
674 }
675 spin_unlock(&state->state_lock);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400676 if (new != NULL)
677 nfs4_free_lock_state(new);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 return lsp;
679}
680
681/*
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000682 * Release reference to lock_state, and free it if we see that
683 * it is no longer in use
684 */
Trond Myklebustfaf5f492005-10-18 14:20:15 -0700685void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000686{
687 struct nfs4_state *state;
688
689 if (lsp == NULL)
690 return;
691 state = lsp->ls_state;
692 if (!atomic_dec_and_lock(&lsp->ls_count, &state->state_lock))
693 return;
694 list_del(&lsp->ls_locks);
695 if (list_empty(&state->lock_states))
696 clear_bit(LK_STATE_IN_USE, &state->flags);
697 spin_unlock(&state->state_lock);
Trond Myklebust9f958ab2007-07-02 13:58:33 -0400698 nfs4_free_lock_state(lsp);
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000699}
700
701static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
702{
703 struct nfs4_lock_state *lsp = src->fl_u.nfs4_fl.owner;
704
705 dst->fl_u.nfs4_fl.owner = lsp;
706 atomic_inc(&lsp->ls_count);
707}
708
709static void nfs4_fl_release_lock(struct file_lock *fl)
710{
711 nfs4_put_lock_state(fl->fl_u.nfs4_fl.owner);
712}
713
Alexey Dobriyan6aed6282009-09-21 17:01:11 -0700714static const struct file_lock_operations nfs4_fl_lock_ops = {
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000715 .fl_copy_lock = nfs4_fl_copy_lock,
716 .fl_release_private = nfs4_fl_release_lock,
717};
718
719int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
720{
721 struct nfs4_lock_state *lsp;
722
723 if (fl->fl_ops != NULL)
724 return 0;
725 lsp = nfs4_get_lock_state(state, fl->fl_owner);
726 if (lsp == NULL)
727 return -ENOMEM;
728 fl->fl_u.nfs4_fl.owner = lsp;
729 fl->fl_ops = &nfs4_fl_lock_ops;
730 return 0;
731}
732
733/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 * Byte-range lock aware utility to initialize the stateid of read/write
735 * requests.
736 */
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000737void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000739 struct nfs4_lock_state *lsp;
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400740 int seq;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741
Trond Myklebust8bda4e42007-07-09 10:45:42 -0400742 do {
743 seq = read_seqbegin(&state->seqlock);
744 memcpy(dst, &state->stateid, sizeof(*dst));
745 } while (read_seqretry(&state->seqlock, seq));
Trond Myklebust8d0a8a92005-06-22 17:16:32 +0000746 if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
747 return;
748
749 spin_lock(&state->state_lock);
750 lsp = __nfs4_find_lock_state(state, fl_owner);
751 if (lsp != NULL && (lsp->ls_flags & NFS_LOCK_INITIALIZED) != 0)
752 memcpy(dst, &lsp->ls_stateid, sizeof(*dst));
753 spin_unlock(&state->state_lock);
754 nfs4_put_lock_state(lsp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755}
756
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700757struct nfs_seqid *nfs_alloc_seqid(struct nfs_seqid_counter *counter)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758{
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700759 struct nfs_seqid *new;
760
761 new = kmalloc(sizeof(*new), GFP_KERNEL);
762 if (new != NULL) {
763 new->sequence = counter;
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500764 INIT_LIST_HEAD(&new->list);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700765 }
766 return new;
767}
768
Trond Myklebust72211db2009-12-15 14:47:36 -0500769void nfs_release_seqid(struct nfs_seqid *seqid)
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700770{
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500771 if (!list_empty(&seqid->list)) {
772 struct rpc_sequence *sequence = seqid->sequence->sequence;
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700773
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500774 spin_lock(&sequence->lock);
Trond Myklebust72211db2009-12-15 14:47:36 -0500775 list_del_init(&seqid->list);
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500776 spin_unlock(&sequence->lock);
777 rpc_wake_up(&sequence->wait);
778 }
Trond Myklebust72211db2009-12-15 14:47:36 -0500779}
780
781void nfs_free_seqid(struct nfs_seqid *seqid)
782{
783 nfs_release_seqid(seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700784 kfree(seqid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785}
786
Linus Torvalds1da177e2005-04-16 15:20:36 -0700787/*
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700788 * Increment the seqid if the OPEN/OPEN_DOWNGRADE/CLOSE succeeded, or
789 * failed with a seqid incrementing error -
790 * see comments nfs_fs.h:seqid_mutating_error()
791 */
Trond Myklebust88d90932007-07-02 14:03:03 -0400792static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793{
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500794 BUG_ON(list_first_entry(&seqid->sequence->sequence->list, struct nfs_seqid, list) != seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700795 switch (status) {
796 case 0:
797 break;
798 case -NFS4ERR_BAD_SEQID:
Trond Myklebust6f43ddc2007-07-08 16:49:11 -0400799 if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
800 return;
801 printk(KERN_WARNING "NFS: v4 server returned a bad"
Dan Muntz497799e2008-02-13 13:09:35 -0800802 " sequence-id error on an"
803 " unconfirmed sequence %p!\n",
Trond Myklebust6f43ddc2007-07-08 16:49:11 -0400804 seqid->sequence);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700805 case -NFS4ERR_STALE_CLIENTID:
806 case -NFS4ERR_STALE_STATEID:
807 case -NFS4ERR_BAD_STATEID:
808 case -NFS4ERR_BADXDR:
809 case -NFS4ERR_RESOURCE:
810 case -NFS4ERR_NOFILEHANDLE:
811 /* Non-seqid mutating errors */
812 return;
813 };
814 /*
815 * Note: no locking needed as we are guaranteed to be first
816 * on the sequence list
817 */
818 seqid->sequence->counter++;
819}
820
821void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
822{
Benny Halevy34dc1ad2009-04-01 09:22:52 -0400823 struct nfs4_state_owner *sp = container_of(seqid->sequence,
824 struct nfs4_state_owner, so_seqid);
825 struct nfs_server *server = sp->so_server;
826
827 if (status == -NFS4ERR_BAD_SEQID)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 nfs4_drop_state_owner(sp);
Benny Halevy34dc1ad2009-04-01 09:22:52 -0400829 if (!nfs4_has_session(server->nfs_client))
830 nfs_increment_seqid(status, seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700831}
832
833/*
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700834 * Increment the seqid if the LOCK/LOCKU succeeded, or
835 * failed with a seqid incrementing error -
836 * see comments nfs_fs.h:seqid_mutating_error()
837 */
838void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
839{
Trond Myklebust88d90932007-07-02 14:03:03 -0400840 nfs_increment_seqid(status, seqid);
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700841}
842
843int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
844{
845 struct rpc_sequence *sequence = seqid->sequence->sequence;
846 int status = 0;
847
848 spin_lock(&sequence->lock);
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500849 if (list_empty(&seqid->list))
850 list_add_tail(&seqid->list, &sequence->list);
851 if (list_first_entry(&sequence->list, struct nfs_seqid, list) == seqid)
852 goto unlock;
Trond Myklebust5d008372008-02-22 16:34:17 -0500853 rpc_sleep_on(&sequence->wait, task, NULL);
Trond Myklebust2f74c0a2008-01-08 17:56:07 -0500854 status = -EAGAIN;
855unlock:
Trond Myklebustcee54fc2005-10-18 14:20:12 -0700856 spin_unlock(&sequence->lock);
857 return status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858}
859
Trond Myklebuste005e802008-12-23 15:21:48 -0500860static int nfs4_run_state_manager(void *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Trond Myklebuste005e802008-12-23 15:21:48 -0500862static void nfs4_clear_state_manager_bit(struct nfs_client *clp)
Trond Myklebust433fbe42006-01-03 09:55:22 +0100863{
864 smp_mb__before_clear_bit();
Trond Myklebuste005e802008-12-23 15:21:48 -0500865 clear_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state);
Trond Myklebust433fbe42006-01-03 09:55:22 +0100866 smp_mb__after_clear_bit();
Trond Myklebuste005e802008-12-23 15:21:48 -0500867 wake_up_bit(&clp->cl_state, NFS4CLNT_MANAGER_RUNNING);
Trond Myklebust433fbe42006-01-03 09:55:22 +0100868 rpc_wake_up(&clp->cl_rpcwaitq);
869}
870
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871/*
Trond Myklebuste005e802008-12-23 15:21:48 -0500872 * Schedule the nfs_client asynchronous state management routine
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 */
Trond Myklebustb0d3ded2008-12-23 15:21:50 -0500874void nfs4_schedule_state_manager(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875{
Trond Myklebust5043e902006-01-03 09:55:23 +0100876 struct task_struct *task;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877
Trond Myklebuste005e802008-12-23 15:21:48 -0500878 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
879 return;
Trond Myklebust5043e902006-01-03 09:55:23 +0100880 __module_get(THIS_MODULE);
881 atomic_inc(&clp->cl_count);
Trond Myklebuste005e802008-12-23 15:21:48 -0500882 task = kthread_run(nfs4_run_state_manager, clp, "%s-manager",
Chuck Lever5d8515c2007-12-10 14:57:16 -0500883 rpc_peeraddr2str(clp->cl_rpcclient,
884 RPC_DISPLAY_ADDR));
Trond Myklebust5043e902006-01-03 09:55:23 +0100885 if (!IS_ERR(task))
886 return;
Trond Myklebuste005e802008-12-23 15:21:48 -0500887 nfs4_clear_state_manager_bit(clp);
David Howells24c8dbb2006-08-22 20:06:10 -0400888 nfs_put_client(clp);
Trond Myklebust5043e902006-01-03 09:55:23 +0100889 module_put(THIS_MODULE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890}
891
892/*
893 * Schedule a state recovery attempt
894 */
David Howellsadfa6f92006-08-22 20:06:08 -0400895void nfs4_schedule_state_recovery(struct nfs_client *clp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896{
897 if (!clp)
898 return;
Trond Myklebuste598d842008-12-23 15:21:42 -0500899 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
900 set_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
Trond Myklebuste005e802008-12-23 15:21:48 -0500901 nfs4_schedule_state_manager(clp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902}
903
Trond Myklebustb79a4a12008-12-23 15:21:41 -0500904static int nfs4_state_mark_reclaim_reboot(struct nfs_client *clp, struct nfs4_state *state)
905{
906
907 set_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
908 /* Don't recover state that expired before the reboot */
909 if (test_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags)) {
910 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
911 return 0;
912 }
Trond Myklebust7eff03a2008-12-23 15:21:43 -0500913 set_bit(NFS_OWNER_RECLAIM_REBOOT, &state->owner->so_flags);
Trond Myklebustb79a4a12008-12-23 15:21:41 -0500914 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
915 return 1;
916}
917
Trond Myklebust9e33bed2008-12-23 15:21:46 -0500918int nfs4_state_mark_reclaim_nograce(struct nfs_client *clp, struct nfs4_state *state)
Trond Myklebustb79a4a12008-12-23 15:21:41 -0500919{
920 set_bit(NFS_STATE_RECLAIM_NOGRACE, &state->flags);
921 clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags);
Trond Myklebust7eff03a2008-12-23 15:21:43 -0500922 set_bit(NFS_OWNER_RECLAIM_NOGRACE, &state->owner->so_flags);
Trond Myklebustb79a4a12008-12-23 15:21:41 -0500923 set_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state);
924 return 1;
925}
926
Trond Myklebust02860012008-12-23 15:21:40 -0500927static int nfs4_reclaim_locks(struct nfs4_state *state, const struct nfs4_state_recovery_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928{
929 struct inode *inode = state->inode;
Trond Myklebust19e03c52008-12-23 15:21:44 -0500930 struct nfs_inode *nfsi = NFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 struct file_lock *fl;
932 int status = 0;
933
Trond Myklebust3f09df72009-06-17 13:23:00 -0700934 if (inode->i_flock == NULL)
935 return 0;
936
937 /* Guard against delegation returns and new lock/unlock calls */
Trond Myklebust19e03c52008-12-23 15:21:44 -0500938 down_write(&nfsi->rwsem);
Trond Myklebust3f09df72009-06-17 13:23:00 -0700939 /* Protect inode->i_flock using the BKL */
940 lock_kernel();
Harvey Harrison90dc7d22008-02-20 13:03:05 -0800941 for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
Trond Myklebust43b2a332005-11-04 15:35:30 -0500942 if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 continue;
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400944 if (nfs_file_open_context(fl->fl_file)->state != state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 continue;
Trond Myklebust3f09df72009-06-17 13:23:00 -0700946 unlock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947 status = ops->recover_lock(state, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 switch (status) {
Trond Myklebust965b5d62009-06-17 13:22:59 -0700949 case 0:
950 break;
951 case -ESTALE:
952 case -NFS4ERR_ADMIN_REVOKED:
953 case -NFS4ERR_STALE_STATEID:
954 case -NFS4ERR_BAD_STATEID:
955 case -NFS4ERR_EXPIRED:
956 case -NFS4ERR_NO_GRACE:
957 case -NFS4ERR_STALE_CLIENTID:
Trond Myklebust9c4c7612009-12-03 15:58:56 -0500958 case -NFS4ERR_BADSESSION:
959 case -NFS4ERR_BADSLOT:
960 case -NFS4ERR_BAD_HIGH_SLOT:
961 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
Trond Myklebust965b5d62009-06-17 13:22:59 -0700962 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 default:
964 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -0700965 __func__, status);
Trond Myklebust965b5d62009-06-17 13:22:59 -0700966 case -ENOMEM:
967 case -NFS4ERR_DENIED:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 case -NFS4ERR_RECLAIM_BAD:
969 case -NFS4ERR_RECLAIM_CONFLICT:
Trond Myklebust43b2a332005-11-04 15:35:30 -0500970 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
Trond Myklebust965b5d62009-06-17 13:22:59 -0700971 status = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972 }
Trond Myklebust3f09df72009-06-17 13:23:00 -0700973 lock_kernel();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
Trond Myklebust3f09df72009-06-17 13:23:00 -0700975 unlock_kernel();
Trond Myklebust965b5d62009-06-17 13:22:59 -0700976out:
Trond Myklebust19e03c52008-12-23 15:21:44 -0500977 up_write(&nfsi->rwsem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 return status;
979}
980
Trond Myklebust02860012008-12-23 15:21:40 -0500981static int nfs4_reclaim_open_state(struct nfs4_state_owner *sp, const struct nfs4_state_recovery_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700982{
983 struct nfs4_state *state;
984 struct nfs4_lock_state *lock;
985 int status = 0;
986
987 /* Note: we rely on the sp->so_states list being ordered
988 * so that we always reclaim open(O_RDWR) and/or open(O_WRITE)
989 * states first.
990 * This is needed to ensure that the server won't give us any
991 * read delegations that we have to return if, say, we are
992 * recovering after a network partition or a reboot from a
993 * server that doesn't support a grace period.
994 */
Trond Myklebustfe1d8192008-12-23 15:21:43 -0500995restart:
996 spin_lock(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 list_for_each_entry(state, &sp->so_states, open_states) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -0500998 if (!test_and_clear_bit(ops->state_flag_bit, &state->flags))
999 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 if (state->state == 0)
1001 continue;
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001002 atomic_inc(&state->count);
1003 spin_unlock(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 status = ops->recover_open(sp, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 if (status >= 0) {
Trond Myklebust02860012008-12-23 15:21:40 -05001006 status = nfs4_reclaim_locks(state, ops);
1007 if (status >= 0) {
1008 list_for_each_entry(lock, &state->lock_states, ls_locks) {
1009 if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
1010 printk("%s: Lock reclaim failed!\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001011 __func__);
Trond Myklebust02860012008-12-23 15:21:40 -05001012 }
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001013 nfs4_put_open_state(state);
1014 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 }
1017 switch (status) {
1018 default:
1019 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
Harvey Harrison3110ff82008-05-02 13:42:44 -07001020 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 case -ENOENT:
Trond Myklebust965b5d62009-06-17 13:22:59 -07001022 case -ENOMEM:
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001023 case -ESTALE:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 /*
1025 * Open state on this file cannot be recovered
1026 * All we can do is revert to using the zero stateid.
1027 */
1028 memset(state->stateid.data, 0,
1029 sizeof(state->stateid.data));
1030 /* Mark the file as being 'closed' */
1031 state->state = 0;
1032 break;
Trond Myklebust965b5d62009-06-17 13:22:59 -07001033 case -NFS4ERR_ADMIN_REVOKED:
1034 case -NFS4ERR_STALE_STATEID:
1035 case -NFS4ERR_BAD_STATEID:
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001036 case -NFS4ERR_RECLAIM_BAD:
1037 case -NFS4ERR_RECLAIM_CONFLICT:
1038 nfs4_state_mark_reclaim_nograce(sp->so_client, state);
1039 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 case -NFS4ERR_EXPIRED:
1041 case -NFS4ERR_NO_GRACE:
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001042 nfs4_state_mark_reclaim_nograce(sp->so_client, state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 case -NFS4ERR_STALE_CLIENTID:
Trond Myklebust9c4c7612009-12-03 15:58:56 -05001044 case -NFS4ERR_BADSESSION:
1045 case -NFS4ERR_BADSLOT:
1046 case -NFS4ERR_BAD_HIGH_SLOT:
1047 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 goto out_err;
1049 }
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001050 nfs4_put_open_state(state);
1051 goto restart;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 }
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001053 spin_unlock(&sp->so_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 return 0;
1055out_err:
Trond Myklebustfe1d8192008-12-23 15:21:43 -05001056 nfs4_put_open_state(state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 return status;
1058}
1059
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001060static void nfs4_clear_open_state(struct nfs4_state *state)
1061{
1062 struct nfs4_lock_state *lock;
1063
1064 clear_bit(NFS_DELEGATED_STATE, &state->flags);
1065 clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1066 clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1067 clear_bit(NFS_O_RDWR_STATE, &state->flags);
1068 list_for_each_entry(lock, &state->lock_states, ls_locks) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001069 lock->ls_seqid.flags = 0;
1070 lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
1071 }
1072}
1073
1074static void nfs4_state_mark_reclaim_helper(struct nfs_client *clp, int (*mark_reclaim)(struct nfs_client *clp, struct nfs4_state *state))
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001075{
1076 struct nfs4_state_owner *sp;
Trond Myklebust9f958ab2007-07-02 13:58:33 -04001077 struct rb_node *pos;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001078 struct nfs4_state *state;
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001079
1080 /* Reset all sequence ids to zero */
Trond Myklebust9f958ab2007-07-02 13:58:33 -04001081 for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
1082 sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001083 sp->so_seqid.flags = 0;
Trond Myklebustec073422005-10-20 14:22:47 -07001084 spin_lock(&sp->so_lock);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001085 list_for_each_entry(state, &sp->so_states, open_states) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001086 if (mark_reclaim(clp, state))
1087 nfs4_clear_open_state(state);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001088 }
Trond Myklebustec073422005-10-20 14:22:47 -07001089 spin_unlock(&sp->so_lock);
Trond Myklebustcee54fc2005-10-18 14:20:12 -07001090 }
1091}
1092
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001093static void nfs4_state_start_reclaim_reboot(struct nfs_client *clp)
1094{
1095 /* Mark all delegations for reclaim */
1096 nfs_delegation_mark_reclaim(clp);
1097 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_reboot);
1098}
1099
Ricardo Labiagafce5c832009-12-05 16:08:41 -05001100static void nfs4_reclaim_complete(struct nfs_client *clp,
1101 const struct nfs4_state_recovery_ops *ops)
1102{
1103 /* Notify the server we're done reclaiming our state */
1104 if (ops->reclaim_complete)
1105 (void)ops->reclaim_complete(clp);
1106}
1107
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001108static void nfs4_state_end_reclaim_reboot(struct nfs_client *clp)
1109{
1110 struct nfs4_state_owner *sp;
1111 struct rb_node *pos;
1112 struct nfs4_state *state;
1113
1114 if (!test_and_clear_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1115 return;
1116
Ricardo Labiaga7cab89b2009-12-08 14:35:28 -05001117 nfs4_reclaim_complete(clp,
1118 nfs4_reboot_recovery_ops[clp->cl_minorversion]);
1119
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001120 for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
1121 sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
1122 spin_lock(&sp->so_lock);
1123 list_for_each_entry(state, &sp->so_states, open_states) {
1124 if (!test_and_clear_bit(NFS_STATE_RECLAIM_REBOOT, &state->flags))
1125 continue;
1126 nfs4_state_mark_reclaim_nograce(clp, state);
1127 }
1128 spin_unlock(&sp->so_lock);
1129 }
1130
1131 nfs_delegation_reap_unclaimed(clp);
1132}
1133
1134static void nfs_delegation_clear_all(struct nfs_client *clp)
1135{
1136 nfs_delegation_mark_reclaim(clp);
1137 nfs_delegation_reap_unclaimed(clp);
1138}
1139
1140static void nfs4_state_start_reclaim_nograce(struct nfs_client *clp)
1141{
1142 nfs_delegation_clear_all(clp);
1143 nfs4_state_mark_reclaim_helper(clp, nfs4_state_mark_reclaim_nograce);
1144}
1145
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001146static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
Trond Myklebuste598d842008-12-23 15:21:42 -05001147{
1148 switch (error) {
1149 case -NFS4ERR_CB_PATH_DOWN:
Trond Myklebust707fb4b2008-12-23 15:21:47 -05001150 nfs_handle_cb_pathdown(clp);
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001151 return 0;
Trond Myklebustc8b7ae3d2009-12-03 15:53:21 -05001152 case -NFS4ERR_NO_GRACE:
1153 nfs4_state_end_reclaim_reboot(clp);
1154 return 0;
Trond Myklebuste598d842008-12-23 15:21:42 -05001155 case -NFS4ERR_STALE_CLIENTID:
1156 case -NFS4ERR_LEASE_MOVED:
1157 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
Trond Myklebuste345e882009-12-03 15:52:41 -05001158 nfs4_state_end_reclaim_reboot(clp);
Trond Myklebuste598d842008-12-23 15:21:42 -05001159 nfs4_state_start_reclaim_reboot(clp);
1160 break;
1161 case -NFS4ERR_EXPIRED:
1162 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1163 nfs4_state_start_reclaim_nograce(clp);
Andy Adamson8ba9bf82009-12-04 15:55:34 -05001164 break;
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001165 case -NFS4ERR_BADSESSION:
1166 case -NFS4ERR_BADSLOT:
1167 case -NFS4ERR_BAD_HIGH_SLOT:
1168 case -NFS4ERR_DEADSESSION:
1169 case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
1170 case -NFS4ERR_SEQ_FALSE_RETRY:
1171 case -NFS4ERR_SEQ_MISORDERED:
Andy Adamson6df08182009-12-04 15:55:05 -05001172 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
Andy Adamson0b9e2d42009-12-04 16:02:14 -05001173 /* Zero session reset errors */
1174 return 0;
Trond Myklebuste598d842008-12-23 15:21:42 -05001175 }
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001176 return error;
Trond Myklebuste598d842008-12-23 15:21:42 -05001177}
1178
Trond Myklebust02860012008-12-23 15:21:40 -05001179static int nfs4_do_reclaim(struct nfs_client *clp, const struct nfs4_state_recovery_ops *ops)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180{
Trond Myklebust9f958ab2007-07-02 13:58:33 -04001181 struct rb_node *pos;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182 int status = 0;
1183
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001184restart:
1185 spin_lock(&clp->cl_lock);
Trond Myklebust02860012008-12-23 15:21:40 -05001186 for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
1187 struct nfs4_state_owner *sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001188 if (!test_and_clear_bit(ops->owner_flag_bit, &sp->so_flags))
1189 continue;
1190 atomic_inc(&sp->so_count);
1191 spin_unlock(&clp->cl_lock);
Trond Myklebust02860012008-12-23 15:21:40 -05001192 status = nfs4_reclaim_open_state(sp, ops);
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001193 if (status < 0) {
1194 set_bit(ops->owner_flag_bit, &sp->so_flags);
1195 nfs4_put_state_owner(sp);
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001196 return nfs4_recovery_handle_error(clp, status);
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001197 }
1198 nfs4_put_state_owner(sp);
1199 goto restart;
Trond Myklebust02860012008-12-23 15:21:40 -05001200 }
Trond Myklebust7eff03a2008-12-23 15:21:43 -05001201 spin_unlock(&clp->cl_lock);
Trond Myklebust02860012008-12-23 15:21:40 -05001202 return status;
1203}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
Trond Myklebust02860012008-12-23 15:21:40 -05001205static int nfs4_check_lease(struct nfs_client *clp)
1206{
1207 struct rpc_cred *cred;
Benny Halevy8e69514f2009-04-01 09:22:45 -04001208 struct nfs4_state_maintenance_ops *ops =
1209 nfs4_state_renewal_ops[clp->cl_minorversion];
Trond Myklebust02860012008-12-23 15:21:40 -05001210 int status = -NFS4ERR_EXPIRED;
1211
Trond Myklebust0f605b52008-12-23 15:21:42 -05001212 /* Is the client already known to have an expired lease? */
1213 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1214 return 0;
Andy Adamsona7b72102009-04-01 09:22:46 -04001215 spin_lock(&clp->cl_lock);
1216 cred = ops->get_state_renewal_cred_locked(clp);
1217 spin_unlock(&clp->cl_lock);
Trond Myklebust0f605b52008-12-23 15:21:42 -05001218 if (cred == NULL) {
1219 cred = nfs4_get_setclientid_cred(clp);
1220 if (cred == NULL)
1221 goto out;
Trond Myklebust02860012008-12-23 15:21:40 -05001222 }
Benny Halevy8e69514f2009-04-01 09:22:45 -04001223 status = ops->renew_lease(clp, cred);
Trond Myklebust0f605b52008-12-23 15:21:42 -05001224 put_rpccred(cred);
1225out:
Trond Myklebust4f7cdf12009-12-03 15:53:20 -05001226 return nfs4_recovery_handle_error(clp, status);
Trond Myklebust02860012008-12-23 15:21:40 -05001227}
1228
1229static int nfs4_reclaim_lease(struct nfs_client *clp)
1230{
1231 struct rpc_cred *cred;
Andy Adamson591d71c2009-04-01 09:22:47 -04001232 struct nfs4_state_recovery_ops *ops =
1233 nfs4_reboot_recovery_ops[clp->cl_minorversion];
Trond Myklebust02860012008-12-23 15:21:40 -05001234 int status = -ENOENT;
1235
Andy Adamson90a16612009-04-01 09:22:48 -04001236 cred = ops->get_clid_cred(clp);
Trond Myklebust02860012008-12-23 15:21:40 -05001237 if (cred != NULL) {
Andy Adamson591d71c2009-04-01 09:22:47 -04001238 status = ops->establish_clid(clp, cred);
Trond Myklebust02860012008-12-23 15:21:40 -05001239 put_rpccred(cred);
1240 /* Handle case where the user hasn't set up machine creds */
1241 if (status == -EACCES && cred == clp->cl_machine_cred) {
1242 nfs4_clear_machine_cred(clp);
1243 status = -EAGAIN;
1244 }
Benny Halevyc2e713d2009-04-01 09:21:51 -04001245 if (status == -NFS4ERR_MINOR_VERS_MISMATCH)
1246 status = -EPROTONOSUPPORT;
Trond Myklebust02860012008-12-23 15:21:40 -05001247 }
1248 return status;
1249}
1250
Andy Adamson76db6d92009-04-01 09:22:38 -04001251#ifdef CONFIG_NFS_V4_1
Alexandros Batsakis0629e372009-12-05 13:46:14 -05001252void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
1253{
1254 if (!flags)
1255 return;
1256 else if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED) {
1257 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1258 nfs4_state_start_reclaim_reboot(clp);
1259 nfs4_schedule_state_recovery(clp);
1260 } else if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED |
1261 SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED |
1262 SEQ4_STATUS_ADMIN_STATE_REVOKED |
1263 SEQ4_STATUS_RECALLABLE_STATE_REVOKED |
1264 SEQ4_STATUS_LEASE_MOVED)) {
1265 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1266 nfs4_state_start_reclaim_nograce(clp);
1267 nfs4_schedule_state_recovery(clp);
1268 } else if (flags & (SEQ4_STATUS_CB_PATH_DOWN |
1269 SEQ4_STATUS_BACKCHANNEL_FAULT |
1270 SEQ4_STATUS_CB_PATH_DOWN_SESSION))
1271 nfs_expire_all_delegations(clp);
1272}
1273
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001274static int nfs4_reset_session(struct nfs_client *clp)
1275{
1276 int status;
1277
Trond Myklebust38045412009-12-15 17:36:57 -05001278 nfs4_begin_drain_session(clp);
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001279 status = nfs4_proc_destroy_session(clp->cl_session);
1280 if (status && status != -NFS4ERR_BADSESSION &&
1281 status != -NFS4ERR_DEADSESSION) {
Ricardo Labiagaf4558482009-12-07 09:16:09 -05001282 status = nfs4_recovery_handle_error(clp, status);
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001283 goto out;
1284 }
1285
1286 memset(clp->cl_session->sess_id.data, 0, NFS4_MAX_SESSIONID_LEN);
Trond Myklebustf26468f2009-12-05 19:32:11 -05001287 status = nfs4_proc_create_session(clp);
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001288 if (status)
Ricardo Labiagaf4558482009-12-07 09:16:09 -05001289 status = nfs4_recovery_handle_error(clp, status);
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -05001290
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001291out:
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -05001292 /*
1293 * Let the state manager reestablish state
Ricardo Labiaga9dfdf402009-12-06 12:57:34 -05001294 */
Alexandros Batsakis5601a002009-12-14 21:27:58 -08001295 if (!test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) &&
1296 status == 0)
1297 nfs41_setup_state_renewal(clp);
1298
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001299 return status;
1300}
Andy Adamson76db6d92009-04-01 09:22:38 -04001301
Andy Adamson76db6d92009-04-01 09:22:38 -04001302#else /* CONFIG_NFS_V4_1 */
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001303static int nfs4_reset_session(struct nfs_client *clp) { return 0; }
Alexandros Batsakis5601a002009-12-14 21:27:58 -08001304static int nfs4_end_drain_session(struct nfs_client *clp) { return 0; }
Andy Adamson76db6d92009-04-01 09:22:38 -04001305#endif /* CONFIG_NFS_V4_1 */
1306
Andy Adamson78722e92009-06-16 14:43:15 -04001307/* Set NFS4CLNT_LEASE_EXPIRED for all v4.0 errors and for recoverable errors
1308 * on EXCHANGE_ID for v4.1
1309 */
1310static void nfs4_set_lease_expired(struct nfs_client *clp, int status)
1311{
1312 if (nfs4_has_session(clp)) {
1313 switch (status) {
1314 case -NFS4ERR_DELAY:
1315 case -NFS4ERR_CLID_INUSE:
1316 case -EAGAIN:
1317 break;
1318
1319 case -NFS4ERR_NOT_SAME: /* FixMe: implement recovery
1320 * in nfs4_exchange_id */
1321 default:
1322 return;
1323 }
1324 }
1325 set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
1326}
1327
Trond Myklebuste005e802008-12-23 15:21:48 -05001328static void nfs4_state_manager(struct nfs_client *clp)
Trond Myklebust02860012008-12-23 15:21:40 -05001329{
Trond Myklebust02860012008-12-23 15:21:40 -05001330 int status = 0;
1331
Trond Myklebust02860012008-12-23 15:21:40 -05001332 /* Ensure exclusive access to NFSv4 state */
Trond Myklebustf3c76492008-12-23 15:21:48 -05001333 for(;;) {
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001334 if (test_and_clear_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state)) {
1335 /* We're going to have to re-establish a clientid */
1336 status = nfs4_reclaim_lease(clp);
1337 if (status) {
Andy Adamson78722e92009-06-16 14:43:15 -04001338 nfs4_set_lease_expired(clp, status);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001339 if (test_bit(NFS4CLNT_LEASE_EXPIRED,
1340 &clp->cl_state))
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001341 continue;
Andy Adamson76db6d92009-04-01 09:22:38 -04001342 if (clp->cl_cons_state ==
1343 NFS_CS_SESSION_INITING)
1344 nfs_mark_client_ready(clp, status);
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001345 goto out_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346 }
Trond Myklebuste598d842008-12-23 15:21:42 -05001347 clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state);
Ricardo Labiaga7cab89b2009-12-08 14:35:28 -05001348 set_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state);
Trond Myklebuste598d842008-12-23 15:21:42 -05001349 }
1350
1351 if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
1352 status = nfs4_check_lease(clp);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001353 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
Trond Myklebuste598d842008-12-23 15:21:42 -05001354 continue;
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001355 if (status < 0 && status != -NFS4ERR_CB_PATH_DOWN)
1356 goto out_error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 }
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001358
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001359 /* Initialize or reset the session */
Andy Adamson6df08182009-12-04 15:55:05 -05001360 if (test_and_clear_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)
Trond Myklebust7111dc72009-08-24 19:21:29 -04001361 && nfs4_has_session(clp)) {
Andy Adamson4d643d12009-12-04 15:52:24 -05001362 status = nfs4_reset_session(clp);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001363 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
1364 continue;
1365 if (status < 0)
Andy Adamson76db6d92009-04-01 09:22:38 -04001366 goto out_error;
Andy Adamson76db6d92009-04-01 09:22:38 -04001367 }
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001368
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001369 /* First recover reboot state... */
Trond Myklebuste345e882009-12-03 15:52:41 -05001370 if (test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state)) {
Andy Adamson591d71c2009-04-01 09:22:47 -04001371 status = nfs4_do_reclaim(clp,
1372 nfs4_reboot_recovery_ops[clp->cl_minorversion]);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001373 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
Andy Adamson6df08182009-12-04 15:55:05 -05001374 test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state))
Andy Adamsonc3fad1b2009-04-01 09:22:39 -04001375 continue;
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001376 nfs4_state_end_reclaim_reboot(clp);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001377 if (test_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state))
1378 continue;
1379 if (status < 0)
1380 goto out_error;
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001381 }
1382
1383 /* Now recover expired state... */
1384 if (test_and_clear_bit(NFS4CLNT_RECLAIM_NOGRACE, &clp->cl_state)) {
Andy Adamson591d71c2009-04-01 09:22:47 -04001385 status = nfs4_do_reclaim(clp,
1386 nfs4_nograce_recovery_ops[clp->cl_minorversion]);
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001387 if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) ||
Andy Adamson6df08182009-12-04 15:55:05 -05001388 test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state) ||
Trond Myklebustb6d408b2009-12-03 15:53:22 -05001389 test_bit(NFS4CLNT_RECLAIM_REBOOT, &clp->cl_state))
1390 continue;
1391 if (status < 0)
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001392 goto out_error;
Trond Myklebustb79a4a12008-12-23 15:21:41 -05001393 }
Trond Myklebust707fb4b2008-12-23 15:21:47 -05001394
Alexandros Batsakis5601a002009-12-14 21:27:58 -08001395 nfs4_end_drain_session(clp);
Trond Myklebust707fb4b2008-12-23 15:21:47 -05001396 if (test_and_clear_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state)) {
1397 nfs_client_return_marked_delegations(clp);
1398 continue;
1399 }
Trond Myklebuste005e802008-12-23 15:21:48 -05001400
1401 nfs4_clear_state_manager_bit(clp);
Trond Myklebustf3c76492008-12-23 15:21:48 -05001402 /* Did we race with an attempt to give us more work? */
1403 if (clp->cl_state == 0)
1404 break;
1405 if (test_and_set_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) != 0)
1406 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 }
Trond Myklebuste005e802008-12-23 15:21:48 -05001408 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409out_error:
Trond Myklebuste005e802008-12-23 15:21:48 -05001410 printk(KERN_WARNING "Error: state manager failed on NFSv4 server %s"
Chuck Lever5d8515c2007-12-10 14:57:16 -05001411 " with error %d\n", clp->cl_hostname, -status);
Alexandros Batsakis5601a002009-12-14 21:27:58 -08001412 nfs4_end_drain_session(clp);
Trond Myklebuste005e802008-12-23 15:21:48 -05001413 nfs4_clear_state_manager_bit(clp);
1414}
1415
1416static int nfs4_run_state_manager(void *ptr)
1417{
1418 struct nfs_client *clp = ptr;
1419
1420 allow_signal(SIGKILL);
1421 nfs4_state_manager(clp);
1422 nfs_put_client(clp);
1423 module_put_and_exit(0);
1424 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425}
1426
1427/*
1428 * Local variables:
1429 * c-basic-offset: 8
1430 * End:
1431 */