Commit | Line | Data |
---|---|---|
73e39aaa TM |
1 | /* |
2 | * fs/nfs/nfs4session.c | |
3 | * | |
4 | * Copyright (c) 2012 Trond Myklebust <Trond.Myklebust@netapp.com> | |
5 | * | |
6 | */ | |
7 | #include <linux/kernel.h> | |
8 | #include <linux/errno.h> | |
9 | #include <linux/string.h> | |
10 | #include <linux/printk.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/sunrpc/sched.h> | |
13 | #include <linux/sunrpc/bc_xprt.h> | |
14 | #include <linux/nfs.h> | |
15 | #include <linux/nfs4.h> | |
16 | #include <linux/nfs_fs.h> | |
17 | #include <linux/module.h> | |
18 | ||
19 | #include "nfs4_fs.h" | |
20 | #include "internal.h" | |
21 | #include "nfs4session.h" | |
22 | #include "callback.h" | |
23 | ||
24 | #define NFSDBG_FACILITY NFSDBG_STATE | |
25 | ||
744aa525 CL |
26 | static void nfs4_init_slot_table(struct nfs4_slot_table *tbl, const char *queue) |
27 | { | |
28 | tbl->highest_used_slotid = NFS4_NO_SLOT; | |
29 | spin_lock_init(&tbl->slot_tbl_lock); | |
30 | rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, queue); | |
31 | init_completion(&tbl->complete); | |
32 | } | |
33 | ||
73e39aaa TM |
34 | /* |
35 | * nfs4_shrink_slot_table - free retired slots from the slot table | |
36 | */ | |
37 | static void nfs4_shrink_slot_table(struct nfs4_slot_table *tbl, u32 newsize) | |
38 | { | |
39 | struct nfs4_slot **p; | |
40 | if (newsize >= tbl->max_slots) | |
41 | return; | |
42 | ||
43 | p = &tbl->slots; | |
44 | while (newsize--) | |
45 | p = &(*p)->next; | |
46 | while (*p) { | |
47 | struct nfs4_slot *slot = *p; | |
48 | ||
49 | *p = slot->next; | |
50 | kfree(slot); | |
51 | tbl->max_slots--; | |
52 | } | |
53 | } | |
54 | ||
9d33059c CL |
55 | /** |
56 | * nfs4_slot_tbl_drain_complete - wake waiters when drain is complete | |
57 | * @tbl - controlling slot table | |
58 | * | |
59 | */ | |
60 | void nfs4_slot_tbl_drain_complete(struct nfs4_slot_table *tbl) | |
61 | { | |
62 | if (nfs4_slot_tbl_draining(tbl)) | |
63 | complete(&tbl->complete); | |
64 | } | |
65 | ||
73e39aaa TM |
66 | /* |
67 | * nfs4_free_slot - free a slot and efficiently update slot table. | |
68 | * | |
69 | * freeing a slot is trivially done by clearing its respective bit | |
70 | * in the bitmap. | |
71 | * If the freed slotid equals highest_used_slotid we want to update it | |
72 | * so that the server would be able to size down the slot table if needed, | |
73 | * otherwise we know that the highest_used_slotid is still in use. | |
74 | * When updating highest_used_slotid there may be "holes" in the bitmap | |
75 | * so we need to scan down from highest_used_slotid to 0 looking for the now | |
76 | * highest slotid in use. | |
77 | * If none found, highest_used_slotid is set to NFS4_NO_SLOT. | |
78 | * | |
79 | * Must be called while holding tbl->slot_tbl_lock | |
80 | */ | |
81 | void nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot) | |
82 | { | |
83 | u32 slotid = slot->slot_nr; | |
84 | ||
85 | /* clear used bit in bitmap */ | |
86 | __clear_bit(slotid, tbl->used_slots); | |
87 | ||
88 | /* update highest_used_slotid when it is freed */ | |
89 | if (slotid == tbl->highest_used_slotid) { | |
90 | u32 new_max = find_last_bit(tbl->used_slots, slotid); | |
91 | if (new_max < slotid) | |
92 | tbl->highest_used_slotid = new_max; | |
93 | else { | |
94 | tbl->highest_used_slotid = NFS4_NO_SLOT; | |
774d5f14 | 95 | nfs4_slot_tbl_drain_complete(tbl); |
73e39aaa TM |
96 | } |
97 | } | |
e8d92382 | 98 | dprintk("%s: slotid %u highest_used_slotid %u\n", __func__, |
73e39aaa TM |
99 | slotid, tbl->highest_used_slotid); |
100 | } | |
101 | ||
102 | static struct nfs4_slot *nfs4_new_slot(struct nfs4_slot_table *tbl, | |
103 | u32 slotid, u32 seq_init, gfp_t gfp_mask) | |
104 | { | |
105 | struct nfs4_slot *slot; | |
106 | ||
107 | slot = kzalloc(sizeof(*slot), gfp_mask); | |
108 | if (slot) { | |
109 | slot->table = tbl; | |
110 | slot->slot_nr = slotid; | |
111 | slot->seq_nr = seq_init; | |
112 | } | |
113 | return slot; | |
114 | } | |
115 | ||
116 | static struct nfs4_slot *nfs4_find_or_create_slot(struct nfs4_slot_table *tbl, | |
117 | u32 slotid, u32 seq_init, gfp_t gfp_mask) | |
118 | { | |
119 | struct nfs4_slot **p, *slot; | |
120 | ||
121 | p = &tbl->slots; | |
122 | for (;;) { | |
123 | if (*p == NULL) { | |
124 | *p = nfs4_new_slot(tbl, tbl->max_slots, | |
125 | seq_init, gfp_mask); | |
126 | if (*p == NULL) | |
127 | break; | |
128 | tbl->max_slots++; | |
129 | } | |
130 | slot = *p; | |
131 | if (slot->slot_nr == slotid) | |
132 | return slot; | |
133 | p = &slot->next; | |
134 | } | |
135 | return ERR_PTR(-ENOMEM); | |
136 | } | |
137 | ||
138 | /* | |
139 | * nfs4_alloc_slot - efficiently look for a free slot | |
140 | * | |
141 | * nfs4_alloc_slot looks for an unset bit in the used_slots bitmap. | |
142 | * If found, we mark the slot as used, update the highest_used_slotid, | |
143 | * and respectively set up the sequence operation args. | |
144 | * | |
145 | * Note: must be called with under the slot_tbl_lock. | |
146 | */ | |
147 | struct nfs4_slot *nfs4_alloc_slot(struct nfs4_slot_table *tbl) | |
148 | { | |
149 | struct nfs4_slot *ret = ERR_PTR(-EBUSY); | |
150 | u32 slotid; | |
151 | ||
152 | dprintk("--> %s used_slots=%04lx highest_used=%u max_slots=%u\n", | |
153 | __func__, tbl->used_slots[0], tbl->highest_used_slotid, | |
154 | tbl->max_slotid + 1); | |
155 | slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slotid + 1); | |
156 | if (slotid > tbl->max_slotid) | |
157 | goto out; | |
158 | ret = nfs4_find_or_create_slot(tbl, slotid, 1, GFP_NOWAIT); | |
159 | if (IS_ERR(ret)) | |
160 | goto out; | |
161 | __set_bit(slotid, tbl->used_slots); | |
162 | if (slotid > tbl->highest_used_slotid || | |
163 | tbl->highest_used_slotid == NFS4_NO_SLOT) | |
164 | tbl->highest_used_slotid = slotid; | |
73e39aaa TM |
165 | ret->generation = tbl->generation; |
166 | ||
167 | out: | |
e8d92382 | 168 | dprintk("<-- %s used_slots=%04lx highest_used=%u slotid=%u\n", |
73e39aaa | 169 | __func__, tbl->used_slots[0], tbl->highest_used_slotid, |
e8d92382 | 170 | !IS_ERR(ret) ? ret->slot_nr : NFS4_NO_SLOT); |
73e39aaa TM |
171 | return ret; |
172 | } | |
173 | ||
174 | static int nfs4_grow_slot_table(struct nfs4_slot_table *tbl, | |
175 | u32 max_reqs, u32 ivalue) | |
176 | { | |
177 | if (max_reqs <= tbl->max_slots) | |
178 | return 0; | |
179 | if (!IS_ERR(nfs4_find_or_create_slot(tbl, max_reqs - 1, ivalue, GFP_NOFS))) | |
180 | return 0; | |
181 | return -ENOMEM; | |
182 | } | |
183 | ||
184 | static void nfs4_reset_slot_table(struct nfs4_slot_table *tbl, | |
185 | u32 server_highest_slotid, | |
186 | u32 ivalue) | |
187 | { | |
188 | struct nfs4_slot **p; | |
189 | ||
190 | nfs4_shrink_slot_table(tbl, server_highest_slotid + 1); | |
191 | p = &tbl->slots; | |
192 | while (*p) { | |
193 | (*p)->seq_nr = ivalue; | |
ac20d163 | 194 | (*p)->interrupted = 0; |
73e39aaa TM |
195 | p = &(*p)->next; |
196 | } | |
197 | tbl->highest_used_slotid = NFS4_NO_SLOT; | |
198 | tbl->target_highest_slotid = server_highest_slotid; | |
199 | tbl->server_highest_slotid = server_highest_slotid; | |
1fa80644 TM |
200 | tbl->d_target_highest_slotid = 0; |
201 | tbl->d2_target_highest_slotid = 0; | |
73e39aaa TM |
202 | tbl->max_slotid = server_highest_slotid; |
203 | } | |
204 | ||
205 | /* | |
206 | * (re)Initialise a slot table | |
207 | */ | |
208 | static int nfs4_realloc_slot_table(struct nfs4_slot_table *tbl, | |
209 | u32 max_reqs, u32 ivalue) | |
210 | { | |
211 | int ret; | |
212 | ||
e8d92382 | 213 | dprintk("--> %s: max_reqs=%u, tbl->max_slots %u\n", __func__, |
73e39aaa TM |
214 | max_reqs, tbl->max_slots); |
215 | ||
216 | if (max_reqs > NFS4_MAX_SLOT_TABLE) | |
217 | max_reqs = NFS4_MAX_SLOT_TABLE; | |
218 | ||
219 | ret = nfs4_grow_slot_table(tbl, max_reqs, ivalue); | |
220 | if (ret) | |
221 | goto out; | |
222 | ||
223 | spin_lock(&tbl->slot_tbl_lock); | |
224 | nfs4_reset_slot_table(tbl, max_reqs - 1, ivalue); | |
225 | spin_unlock(&tbl->slot_tbl_lock); | |
226 | ||
e8d92382 | 227 | dprintk("%s: tbl=%p slots=%p max_slots=%u\n", __func__, |
73e39aaa TM |
228 | tbl, tbl->slots, tbl->max_slots); |
229 | out: | |
230 | dprintk("<-- %s: return %d\n", __func__, ret); | |
231 | return ret; | |
232 | } | |
233 | ||
20b9a902 TM |
234 | /* |
235 | * nfs4_release_slot_table - release all slot table entries | |
236 | */ | |
237 | static void nfs4_release_slot_table(struct nfs4_slot_table *tbl) | |
238 | { | |
239 | nfs4_shrink_slot_table(tbl, 0); | |
240 | } | |
241 | ||
eb2a1cd3 | 242 | /** |
20b9a902 | 243 | * nfs4_shutdown_slot_table - release resources attached to a slot table |
eb2a1cd3 CL |
244 | * @tbl: slot table to shut down |
245 | * | |
246 | */ | |
20b9a902 | 247 | void nfs4_shutdown_slot_table(struct nfs4_slot_table *tbl) |
eb2a1cd3 | 248 | { |
20b9a902 TM |
249 | nfs4_release_slot_table(tbl); |
250 | rpc_destroy_wait_queue(&tbl->slot_tbl_waitq); | |
eb2a1cd3 CL |
251 | } |
252 | ||
744aa525 CL |
253 | /** |
254 | * nfs4_setup_slot_table - prepare a stand-alone slot table for use | |
255 | * @tbl: slot table to set up | |
256 | * @max_reqs: maximum number of requests allowed | |
257 | * @queue: name to give RPC wait queue | |
258 | * | |
259 | * Returns zero on success, or a negative errno. | |
260 | */ | |
261 | int nfs4_setup_slot_table(struct nfs4_slot_table *tbl, unsigned int max_reqs, | |
262 | const char *queue) | |
263 | { | |
264 | nfs4_init_slot_table(tbl, queue); | |
265 | return nfs4_realloc_slot_table(tbl, max_reqs, 0); | |
266 | } | |
267 | ||
b75ad4cd TM |
268 | static bool nfs41_assign_slot(struct rpc_task *task, void *pslot) |
269 | { | |
270 | struct nfs4_sequence_args *args = task->tk_msg.rpc_argp; | |
271 | struct nfs4_sequence_res *res = task->tk_msg.rpc_resp; | |
272 | struct nfs4_slot *slot = pslot; | |
273 | struct nfs4_slot_table *tbl = slot->table; | |
274 | ||
774d5f14 | 275 | if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged) |
b75ad4cd | 276 | return false; |
b75ad4cd TM |
277 | slot->generation = tbl->generation; |
278 | args->sa_slot = slot; | |
8e63b6a8 | 279 | res->sr_timestamp = jiffies; |
b75ad4cd TM |
280 | res->sr_slot = slot; |
281 | res->sr_status_flags = 0; | |
282 | res->sr_status = 1; | |
283 | return true; | |
284 | } | |
285 | ||
286 | static bool __nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl, | |
287 | struct nfs4_slot *slot) | |
288 | { | |
289 | if (rpc_wake_up_first(&tbl->slot_tbl_waitq, nfs41_assign_slot, slot)) | |
290 | return true; | |
291 | return false; | |
292 | } | |
293 | ||
294 | bool nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl, | |
295 | struct nfs4_slot *slot) | |
296 | { | |
297 | if (slot->slot_nr > tbl->max_slotid) | |
298 | return false; | |
299 | return __nfs41_wake_and_assign_slot(tbl, slot); | |
300 | } | |
301 | ||
302 | static bool nfs41_try_wake_next_slot_table_entry(struct nfs4_slot_table *tbl) | |
303 | { | |
304 | struct nfs4_slot *slot = nfs4_alloc_slot(tbl); | |
305 | if (!IS_ERR(slot)) { | |
306 | bool ret = __nfs41_wake_and_assign_slot(tbl, slot); | |
307 | if (ret) | |
308 | return ret; | |
309 | nfs4_free_slot(tbl, slot); | |
310 | } | |
311 | return false; | |
312 | } | |
313 | ||
314 | void nfs41_wake_slot_table(struct nfs4_slot_table *tbl) | |
315 | { | |
316 | for (;;) { | |
317 | if (!nfs41_try_wake_next_slot_table_entry(tbl)) | |
318 | break; | |
319 | } | |
320 | } | |
321 | ||
1cec16ab CL |
322 | #if defined(CONFIG_NFS_V4_1) |
323 | ||
b0ef9647 TM |
324 | static void nfs41_set_max_slotid_locked(struct nfs4_slot_table *tbl, |
325 | u32 target_highest_slotid) | |
326 | { | |
327 | u32 max_slotid; | |
328 | ||
329 | max_slotid = min(NFS4_MAX_SLOT_TABLE - 1, target_highest_slotid); | |
330 | if (max_slotid > tbl->server_highest_slotid) | |
331 | max_slotid = tbl->server_highest_slotid; | |
332 | if (max_slotid > tbl->target_highest_slotid) | |
333 | max_slotid = tbl->target_highest_slotid; | |
334 | tbl->max_slotid = max_slotid; | |
335 | nfs41_wake_slot_table(tbl); | |
336 | } | |
337 | ||
73e39aaa TM |
338 | /* Update the client's idea of target_highest_slotid */ |
339 | static void nfs41_set_target_slotid_locked(struct nfs4_slot_table *tbl, | |
340 | u32 target_highest_slotid) | |
341 | { | |
73e39aaa TM |
342 | if (tbl->target_highest_slotid == target_highest_slotid) |
343 | return; | |
344 | tbl->target_highest_slotid = target_highest_slotid; | |
345 | tbl->generation++; | |
73e39aaa TM |
346 | } |
347 | ||
348 | void nfs41_set_target_slotid(struct nfs4_slot_table *tbl, | |
349 | u32 target_highest_slotid) | |
350 | { | |
351 | spin_lock(&tbl->slot_tbl_lock); | |
352 | nfs41_set_target_slotid_locked(tbl, target_highest_slotid); | |
1fa80644 TM |
353 | tbl->d_target_highest_slotid = 0; |
354 | tbl->d2_target_highest_slotid = 0; | |
b0ef9647 | 355 | nfs41_set_max_slotid_locked(tbl, target_highest_slotid); |
73e39aaa TM |
356 | spin_unlock(&tbl->slot_tbl_lock); |
357 | } | |
358 | ||
359 | static void nfs41_set_server_slotid_locked(struct nfs4_slot_table *tbl, | |
360 | u32 highest_slotid) | |
361 | { | |
362 | if (tbl->server_highest_slotid == highest_slotid) | |
363 | return; | |
364 | if (tbl->highest_used_slotid > highest_slotid) | |
365 | return; | |
366 | /* Deallocate slots */ | |
367 | nfs4_shrink_slot_table(tbl, highest_slotid + 1); | |
368 | tbl->server_highest_slotid = highest_slotid; | |
369 | } | |
370 | ||
1fa80644 TM |
371 | static s32 nfs41_derivative_target_slotid(s32 s1, s32 s2) |
372 | { | |
373 | s1 -= s2; | |
374 | if (s1 == 0) | |
375 | return 0; | |
376 | if (s1 < 0) | |
377 | return (s1 - 1) >> 1; | |
378 | return (s1 + 1) >> 1; | |
379 | } | |
380 | ||
381 | static int nfs41_sign_s32(s32 s1) | |
382 | { | |
383 | if (s1 > 0) | |
384 | return 1; | |
385 | if (s1 < 0) | |
386 | return -1; | |
387 | return 0; | |
388 | } | |
389 | ||
390 | static bool nfs41_same_sign_or_zero_s32(s32 s1, s32 s2) | |
391 | { | |
392 | if (!s1 || !s2) | |
393 | return true; | |
394 | return nfs41_sign_s32(s1) == nfs41_sign_s32(s2); | |
395 | } | |
396 | ||
397 | /* Try to eliminate outliers by checking for sharp changes in the | |
398 | * derivatives and second derivatives | |
399 | */ | |
400 | static bool nfs41_is_outlier_target_slotid(struct nfs4_slot_table *tbl, | |
401 | u32 new_target) | |
402 | { | |
403 | s32 d_target, d2_target; | |
404 | bool ret = true; | |
405 | ||
406 | d_target = nfs41_derivative_target_slotid(new_target, | |
407 | tbl->target_highest_slotid); | |
408 | d2_target = nfs41_derivative_target_slotid(d_target, | |
409 | tbl->d_target_highest_slotid); | |
410 | /* Is first derivative same sign? */ | |
411 | if (nfs41_same_sign_or_zero_s32(d_target, tbl->d_target_highest_slotid)) | |
412 | ret = false; | |
413 | /* Is second derivative same sign? */ | |
414 | if (nfs41_same_sign_or_zero_s32(d2_target, tbl->d2_target_highest_slotid)) | |
415 | ret = false; | |
416 | tbl->d_target_highest_slotid = d_target; | |
417 | tbl->d2_target_highest_slotid = d2_target; | |
418 | return ret; | |
419 | } | |
420 | ||
73e39aaa TM |
421 | void nfs41_update_target_slotid(struct nfs4_slot_table *tbl, |
422 | struct nfs4_slot *slot, | |
423 | struct nfs4_sequence_res *res) | |
424 | { | |
425 | spin_lock(&tbl->slot_tbl_lock); | |
1fa80644 TM |
426 | if (!nfs41_is_outlier_target_slotid(tbl, res->sr_target_highest_slotid)) |
427 | nfs41_set_target_slotid_locked(tbl, res->sr_target_highest_slotid); | |
428 | if (tbl->generation == slot->generation) | |
429 | nfs41_set_server_slotid_locked(tbl, res->sr_highest_slotid); | |
b0ef9647 | 430 | nfs41_set_max_slotid_locked(tbl, res->sr_target_highest_slotid); |
73e39aaa TM |
431 | spin_unlock(&tbl->slot_tbl_lock); |
432 | } | |
433 | ||
20b9a902 | 434 | static void nfs4_release_session_slot_tables(struct nfs4_session *session) |
9d33059c | 435 | { |
eb2a1cd3 CL |
436 | nfs4_release_slot_table(&session->fc_slot_table); |
437 | nfs4_release_slot_table(&session->bc_slot_table); | |
9d33059c CL |
438 | } |
439 | ||
73e39aaa TM |
440 | /* |
441 | * Initialize or reset the forechannel and backchannel tables | |
442 | */ | |
443 | int nfs4_setup_session_slot_tables(struct nfs4_session *ses) | |
444 | { | |
445 | struct nfs4_slot_table *tbl; | |
446 | int status; | |
447 | ||
448 | dprintk("--> %s\n", __func__); | |
449 | /* Fore channel */ | |
450 | tbl = &ses->fc_slot_table; | |
451 | tbl->session = ses; | |
452 | status = nfs4_realloc_slot_table(tbl, ses->fc_attrs.max_reqs, 1); | |
453 | if (status) /* -ENOMEM */ | |
454 | return status; | |
455 | /* Back channel */ | |
456 | tbl = &ses->bc_slot_table; | |
457 | tbl->session = ses; | |
458 | status = nfs4_realloc_slot_table(tbl, ses->bc_attrs.max_reqs, 0); | |
459 | if (status && tbl->slots == NULL) | |
460 | /* Fore and back channel share a connection so get | |
461 | * both slot tables or neither */ | |
20b9a902 | 462 | nfs4_release_session_slot_tables(ses); |
73e39aaa TM |
463 | return status; |
464 | } | |
465 | ||
466 | struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp) | |
467 | { | |
468 | struct nfs4_session *session; | |
73e39aaa TM |
469 | |
470 | session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS); | |
471 | if (!session) | |
472 | return NULL; | |
473 | ||
744aa525 CL |
474 | nfs4_init_slot_table(&session->fc_slot_table, "ForeChannel Slot table"); |
475 | nfs4_init_slot_table(&session->bc_slot_table, "BackChannel Slot table"); | |
73e39aaa TM |
476 | session->session_state = 1<<NFS4_SESSION_INITING; |
477 | ||
478 | session->clp = clp; | |
479 | return session; | |
480 | } | |
481 | ||
20b9a902 TM |
482 | static void nfs4_destroy_session_slot_tables(struct nfs4_session *session) |
483 | { | |
484 | nfs4_shutdown_slot_table(&session->fc_slot_table); | |
485 | nfs4_shutdown_slot_table(&session->bc_slot_table); | |
486 | } | |
487 | ||
73e39aaa TM |
488 | void nfs4_destroy_session(struct nfs4_session *session) |
489 | { | |
490 | struct rpc_xprt *xprt; | |
491 | struct rpc_cred *cred; | |
492 | ||
73d8bde5 | 493 | cred = nfs4_get_clid_cred(session->clp); |
73e39aaa TM |
494 | nfs4_proc_destroy_session(session, cred); |
495 | if (cred) | |
496 | put_rpccred(cred); | |
497 | ||
498 | rcu_read_lock(); | |
499 | xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt); | |
500 | rcu_read_unlock(); | |
501 | dprintk("%s Destroy backchannel for xprt %p\n", | |
502 | __func__, xprt); | |
503 | xprt_destroy_backchannel(xprt, NFS41_BC_MIN_CALLBACKS); | |
eb2a1cd3 | 504 | nfs4_destroy_session_slot_tables(session); |
73e39aaa TM |
505 | kfree(session); |
506 | } | |
507 | ||
508 | /* | |
509 | * With sessions, the client is not marked ready until after a | |
510 | * successful EXCHANGE_ID and CREATE_SESSION. | |
511 | * | |
512 | * Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate | |
513 | * other versions of NFS can be tried. | |
514 | */ | |
515 | static int nfs41_check_session_ready(struct nfs_client *clp) | |
516 | { | |
517 | int ret; | |
518 | ||
519 | if (clp->cl_cons_state == NFS_CS_SESSION_INITING) { | |
520 | ret = nfs4_client_recover_expired_lease(clp); | |
521 | if (ret) | |
522 | return ret; | |
523 | } | |
524 | if (clp->cl_cons_state < NFS_CS_READY) | |
525 | return -EPROTONOSUPPORT; | |
526 | smp_rmb(); | |
527 | return 0; | |
528 | } | |
529 | ||
18aad3d5 | 530 | int nfs4_init_session(struct nfs_client *clp) |
73e39aaa | 531 | { |
73e39aaa TM |
532 | if (!nfs4_has_session(clp)) |
533 | return 0; | |
534 | ||
18aad3d5 | 535 | clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state); |
73e39aaa TM |
536 | return nfs41_check_session_ready(clp); |
537 | } | |
538 | ||
539 | int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time) | |
540 | { | |
541 | struct nfs4_session *session = clp->cl_session; | |
542 | int ret; | |
543 | ||
544 | spin_lock(&clp->cl_lock); | |
545 | if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) { | |
546 | /* | |
547 | * Do not set NFS_CS_CHECK_LEASE_TIME instead set the | |
548 | * DS lease to be equal to the MDS lease. | |
549 | */ | |
550 | clp->cl_lease_time = lease_time; | |
551 | clp->cl_last_renewal = jiffies; | |
552 | } | |
553 | spin_unlock(&clp->cl_lock); | |
554 | ||
555 | ret = nfs41_check_session_ready(clp); | |
556 | if (ret) | |
557 | return ret; | |
558 | /* Test for the DS role */ | |
559 | if (!is_ds_client(clp)) | |
560 | return -ENODEV; | |
561 | return 0; | |
562 | } | |
563 | EXPORT_SYMBOL_GPL(nfs4_init_ds_session); | |
564 | ||
9d33059c | 565 | #endif /* defined(CONFIG_NFS_V4_1) */ |