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; 76 nfs4_session_drain_complete(tbl->session, tbl); 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; 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; 175 (*p)->interrupted = 0; 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; 181 tbl->d_target_highest_slotid = 0; 182 tbl->d2_target_highest_slotid = 0; 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 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 229 if (nfs4_session_draining(tbl->session) && !args->sa_privileged) 230 return false; 231 slot->generation = tbl->generation; 232 args->sa_slot = slot; 233 res->sr_timestamp = jiffies; 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 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 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 { 294 if (tbl->target_highest_slotid == target_highest_slotid) 295 return; 296 tbl->target_highest_slotid = target_highest_slotid; 297 tbl->generation++; 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); 305 tbl->d_target_highest_slotid = 0; 306 tbl->d2_target_highest_slotid = 0; 307 nfs41_set_max_slotid_locked(tbl, target_highest_slotid); 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 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 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); 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); 382 nfs41_set_max_slotid_locked(tbl, res->sr_target_highest_slotid); 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 481 int nfs4_init_session(struct nfs_server *server) 482 { 483 struct nfs_client *clp = server->nfs_client; 484 struct nfs4_session *session; 485 unsigned int target_max_rqst_sz = NFS_MAX_FILE_IO_SIZE; 486 unsigned int target_max_resp_sz = NFS_MAX_FILE_IO_SIZE; 487 488 if (!nfs4_has_session(clp)) 489 return 0; 490 491 if (server->rsize != 0) 492 target_max_resp_sz = server->rsize; 493 target_max_resp_sz += nfs41_maxread_overhead; 494 495 if (server->wsize != 0) 496 target_max_rqst_sz = server->wsize; 497 target_max_rqst_sz += nfs41_maxwrite_overhead; 498 499 session = clp->cl_session; 500 spin_lock(&clp->cl_lock); 501 if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) { 502 /* Initialise targets and channel attributes */ 503 session->fc_target_max_rqst_sz = target_max_rqst_sz; 504 session->fc_attrs.max_rqst_sz = target_max_rqst_sz; 505 session->fc_target_max_resp_sz = target_max_resp_sz; 506 session->fc_attrs.max_resp_sz = target_max_resp_sz; 507 } else { 508 /* Just adjust the targets */ 509 if (target_max_rqst_sz > session->fc_target_max_rqst_sz) { 510 session->fc_target_max_rqst_sz = target_max_rqst_sz; 511 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 512 } 513 if (target_max_resp_sz > session->fc_target_max_resp_sz) { 514 session->fc_target_max_resp_sz = target_max_resp_sz; 515 set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state); 516 } 517 } 518 spin_unlock(&clp->cl_lock); 519 520 if (test_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state)) 521 nfs4_schedule_lease_recovery(clp); 522 523 return nfs41_check_session_ready(clp); 524 } 525 526 int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time) 527 { 528 struct nfs4_session *session = clp->cl_session; 529 int ret; 530 531 spin_lock(&clp->cl_lock); 532 if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) { 533 /* 534 * Do not set NFS_CS_CHECK_LEASE_TIME instead set the 535 * DS lease to be equal to the MDS lease. 536 */ 537 clp->cl_lease_time = lease_time; 538 clp->cl_last_renewal = jiffies; 539 } 540 spin_unlock(&clp->cl_lock); 541 542 ret = nfs41_check_session_ready(clp); 543 if (ret) 544 return ret; 545 /* Test for the DS role */ 546 if (!is_ds_client(clp)) 547 return -ENODEV; 548 return 0; 549 } 550 EXPORT_SYMBOL_GPL(nfs4_init_ds_session); 551 552 553