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