smb: server: make use of smbdirect_{socket_init_accepting,connection_wait_for_connected}()

+29 -713

1 changed file

expand all

smb

server

+29 -713

fs/smb/server/transport_rdma.c

··· 197 197 { 198 198 struct smb_direct_transport *t; 199 199 struct smbdirect_socket *sc; 200 - struct smbdirect_socket_parameters *sp; 200 + const struct smbdirect_socket_parameters *sp; 201 201 202 202 if (kt->ops != &ksmbd_smb_direct_transport_ops) 203 203 return 0; 204 204 205 205 t = SMBD_TRANS(kt); 206 206 sc = &t->socket; 207 - sp = &sc->parameters; 207 + sp = smbdirect_socket_get_current_parameters(sc); 208 208 209 209 return sp->max_read_write_size; 210 210 } ··· 216 216 struct smbdirect_socket_parameters init_params = {}; 217 217 struct smbdirect_socket_parameters *sp; 218 218 struct ksmbd_conn *conn; 219 + int ret; 219 220 220 221 /* 221 222 * Create the initial parameters ··· 238 237 if (!t) 239 238 return NULL; 240 239 sc = &t->socket; 241 - smbdirect_socket_prepare_create(sc, sp, smb_direct_wq); 240 + ret = smbdirect_socket_init_accepting(cm_id, sc); 241 + if (ret) 242 + goto socket_init_failed; 242 243 smbdirect_socket_set_logging(sc, NULL, 243 244 smb_direct_logging_needed, 244 245 smb_direct_logging_vaprintf); 245 - sc->ib.poll_ctx = IB_POLL_WORKQUEUE; 246 - sc->send_io.mem.gfp_mask = KSMBD_DEFAULT_GFP; 247 - sc->recv_io.mem.gfp_mask = KSMBD_DEFAULT_GFP; 248 - sc->rw_io.mem.gfp_mask = KSMBD_DEFAULT_GFP; 249 - /* 250 - * from here we operate on the copy. 251 - */ 252 - sp = &sc->parameters; 253 - 254 - sc->rdma.cm_id = cm_id; 255 - cm_id->context = sc; 256 - 257 - sc->ib.dev = sc->rdma.cm_id->device; 246 + ret = smbdirect_socket_set_initial_parameters(sc, sp); 247 + if (ret) 248 + goto set_params_failed; 249 + ret = smbdirect_socket_set_kernel_settings(sc, IB_POLL_WORKQUEUE, KSMBD_DEFAULT_GFP); 250 + if (ret) 251 + goto set_settings_failed; 252 + ret = smbdirect_socket_set_custom_workqueue(sc, smb_direct_wq); 253 + if (ret) 254 + goto set_workqueue_failed; 258 255 259 256 conn = ksmbd_conn_alloc(); 260 257 if (!conn) 261 - goto err; 258 + goto conn_alloc_failed; 262 259 263 260 down_write(&conn_list_lock); 264 261 hash_add(conn_list, &conn->hlist, 0); ··· 266 267 KSMBD_TRANS(t)->conn = conn; 267 268 KSMBD_TRANS(t)->ops = &ksmbd_smb_direct_transport_ops; 268 269 return t; 269 - err: 270 + 271 + conn_alloc_failed: 272 + set_workqueue_failed: 273 + set_settings_failed: 274 + set_params_failed: 275 + socket_init_failed: 270 276 kfree(t); 271 277 return NULL; 272 278 } ··· 288 284 smbdirect_socket_destroy_sync(sc); 289 285 290 286 ksmbd_conn_free(KSMBD_TRANS(t)->conn); 291 - } 292 - 293 - static int smb_direct_check_recvmsg(struct smbdirect_recv_io *recvmsg) 294 - { 295 - struct smbdirect_socket *sc = recvmsg->socket; 296 - 297 - switch (sc->recv_io.expected) { 298 - case SMBDIRECT_EXPECT_DATA_TRANSFER: { 299 - struct smbdirect_data_transfer *req = 300 - (struct smbdirect_data_transfer *)recvmsg->packet; 301 - struct smb2_hdr *hdr = (struct smb2_hdr *)(recvmsg->packet 302 - + le32_to_cpu(req->data_offset)); 303 - ksmbd_debug(RDMA, 304 - "CreditGranted: %u, CreditRequested: %u, DataLength: %u, RemainingDataLength: %u, SMB: %x, Command: %u\n", 305 - le16_to_cpu(req->credits_granted), 306 - le16_to_cpu(req->credits_requested), 307 - req->data_length, req->remaining_data_length, 308 - hdr->ProtocolId, hdr->Command); 309 - return 0; 310 - } 311 - case SMBDIRECT_EXPECT_NEGOTIATE_REQ: { 312 - struct smbdirect_negotiate_req *req = 313 - (struct smbdirect_negotiate_req *)recvmsg->packet; 314 - ksmbd_debug(RDMA, 315 - "MinVersion: %u, MaxVersion: %u, CreditRequested: %u, MaxSendSize: %u, MaxRecvSize: %u, MaxFragmentedSize: %u\n", 316 - le16_to_cpu(req->min_version), 317 - le16_to_cpu(req->max_version), 318 - le16_to_cpu(req->credits_requested), 319 - le32_to_cpu(req->preferred_send_size), 320 - le32_to_cpu(req->max_receive_size), 321 - le32_to_cpu(req->max_fragmented_size)); 322 - if (le16_to_cpu(req->min_version) > 0x0100 || 323 - le16_to_cpu(req->max_version) < 0x0100) 324 - return -EOPNOTSUPP; 325 - if (le16_to_cpu(req->credits_requested) <= 0 || 326 - le32_to_cpu(req->max_receive_size) <= 128 || 327 - le32_to_cpu(req->max_fragmented_size) <= 328 - 128 * 1024) 329 - return -ECONNABORTED; 330 - 331 - return 0; 332 - } 333 - case SMBDIRECT_EXPECT_NEGOTIATE_REP: 334 - /* client only */ 335 - break; 336 - } 337 - 338 - /* This is an internal error */ 339 - return -EINVAL; 340 - } 341 - 342 - static void recv_done(struct ib_cq *cq, struct ib_wc *wc) 343 - { 344 - struct smbdirect_recv_io *recvmsg; 345 - struct smbdirect_socket *sc; 346 - struct smbdirect_socket_parameters *sp; 347 - 348 - recvmsg = container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe); 349 - sc = recvmsg->socket; 350 - sp = &sc->parameters; 351 - 352 - if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) { 353 - smbdirect_connection_put_recv_io(recvmsg); 354 - if (wc->status != IB_WC_WR_FLUSH_ERR) { 355 - pr_err("Recv error. status='%s (%d)' opcode=%d\n", 356 - ib_wc_status_msg(wc->status), wc->status, 357 - wc->opcode); 358 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 359 - } 360 - return; 361 - } 362 - 363 - ksmbd_debug(RDMA, "Recv completed. status='%s (%d)', opcode=%d\n", 364 - ib_wc_status_msg(wc->status), wc->status, 365 - wc->opcode); 366 - 367 - ib_dma_sync_single_for_cpu(wc->qp->device, recvmsg->sge.addr, 368 - recvmsg->sge.length, DMA_FROM_DEVICE); 369 - 370 - /* 371 - * Reset timer to the keepalive interval in 372 - * order to trigger our next keepalive message. 373 - */ 374 - sc->idle.keepalive = SMBDIRECT_KEEPALIVE_NONE; 375 - mod_delayed_work(sc->workqueue, &sc->idle.timer_work, 376 - msecs_to_jiffies(sp->keepalive_interval_msec)); 377 - 378 - switch (sc->recv_io.expected) { 379 - case SMBDIRECT_EXPECT_NEGOTIATE_REQ: 380 - /* see smb_direct_negotiate_recv_done */ 381 - break; 382 - case SMBDIRECT_EXPECT_DATA_TRANSFER: { 383 - struct smbdirect_data_transfer *data_transfer = 384 - (struct smbdirect_data_transfer *)recvmsg->packet; 385 - u32 remaining_data_length, data_offset, data_length; 386 - int current_recv_credits; 387 - u16 old_recv_credit_target; 388 - 389 - if (wc->byte_len < 390 - offsetof(struct smbdirect_data_transfer, padding)) { 391 - smbdirect_connection_put_recv_io(recvmsg); 392 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 393 - return; 394 - } 395 - 396 - remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length); 397 - data_length = le32_to_cpu(data_transfer->data_length); 398 - data_offset = le32_to_cpu(data_transfer->data_offset); 399 - if (wc->byte_len < data_offset || 400 - wc->byte_len < (u64)data_offset + data_length) { 401 - smbdirect_connection_put_recv_io(recvmsg); 402 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 403 - return; 404 - } 405 - if (remaining_data_length > sp->max_fragmented_recv_size || 406 - data_length > sp->max_fragmented_recv_size || 407 - (u64)remaining_data_length + (u64)data_length > 408 - (u64)sp->max_fragmented_recv_size) { 409 - smbdirect_connection_put_recv_io(recvmsg); 410 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 411 - return; 412 - } 413 - 414 - if (data_length) { 415 - if (sc->recv_io.reassembly.full_packet_received) 416 - recvmsg->first_segment = true; 417 - 418 - if (le32_to_cpu(data_transfer->remaining_data_length)) 419 - sc->recv_io.reassembly.full_packet_received = false; 420 - else 421 - sc->recv_io.reassembly.full_packet_received = true; 422 - } 423 - 424 - atomic_dec(&sc->recv_io.posted.count); 425 - current_recv_credits = atomic_dec_return(&sc->recv_io.credits.count); 426 - 427 - old_recv_credit_target = sc->recv_io.credits.target; 428 - sc->recv_io.credits.target = 429 - le16_to_cpu(data_transfer->credits_requested); 430 - sc->recv_io.credits.target = 431 - min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max); 432 - sc->recv_io.credits.target = 433 - max_t(u16, sc->recv_io.credits.target, 1); 434 - atomic_add(le16_to_cpu(data_transfer->credits_granted), 435 - &sc->send_io.credits.count); 436 - 437 - if (le16_to_cpu(data_transfer->flags) & 438 - SMBDIRECT_FLAG_RESPONSE_REQUESTED) 439 - queue_work(sc->workqueue, &sc->idle.immediate_work); 440 - 441 - if (atomic_read(&sc->send_io.credits.count) > 0) 442 - wake_up(&sc->send_io.credits.wait_queue); 443 - 444 - if (data_length) { 445 - if (current_recv_credits <= (sc->recv_io.credits.target / 4) || 446 - sc->recv_io.credits.target > old_recv_credit_target) 447 - queue_work(sc->workqueue, &sc->recv_io.posted.refill_work); 448 - 449 - smbdirect_connection_reassembly_append_recv_io(sc, recvmsg, data_length); 450 - wake_up(&sc->recv_io.reassembly.wait_queue); 451 - } else 452 - smbdirect_connection_put_recv_io(recvmsg); 453 - 454 - return; 455 - } 456 - case SMBDIRECT_EXPECT_NEGOTIATE_REP: 457 - /* client only */ 458 - break; 459 - } 460 - 461 - /* 462 - * This is an internal error! 463 - */ 464 - WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_DATA_TRANSFER); 465 - smbdirect_connection_put_recv_io(recvmsg); 466 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 467 - } 468 - 469 - static void smb_direct_negotiate_recv_work(struct work_struct *work); 470 - 471 - static void smb_direct_negotiate_recv_done(struct ib_cq *cq, struct ib_wc *wc) 472 - { 473 - struct smbdirect_recv_io *recv_io = 474 - container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe); 475 - struct smbdirect_socket *sc = recv_io->socket; 476 - unsigned long flags; 477 - 478 - /* 479 - * reset the common recv_done for later reuse. 480 - */ 481 - recv_io->cqe.done = recv_done; 482 - 483 - if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) { 484 - smbdirect_connection_put_recv_io(recv_io); 485 - if (wc->status != IB_WC_WR_FLUSH_ERR) { 486 - pr_err("Negotiate Recv error. status='%s (%d)' opcode=%d\n", 487 - ib_wc_status_msg(wc->status), wc->status, 488 - wc->opcode); 489 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 490 - } 491 - return; 492 - } 493 - 494 - ksmbd_debug(RDMA, "Negotiate Recv completed. status='%s (%d)', opcode=%d\n", 495 - ib_wc_status_msg(wc->status), wc->status, 496 - wc->opcode); 497 - 498 - ib_dma_sync_single_for_cpu(sc->ib.dev, 499 - recv_io->sge.addr, 500 - recv_io->sge.length, 501 - DMA_FROM_DEVICE); 502 - 503 - /* 504 - * This is an internal error! 505 - */ 506 - if (WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_NEGOTIATE_REQ)) { 507 - smbdirect_connection_put_recv_io(recv_io); 508 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 509 - return; 510 - } 511 - 512 - /* 513 - * Don't reset timer to the keepalive interval in 514 - * this will be done in smb_direct_negotiate_recv_work. 515 - */ 516 - 517 - /* 518 - * Only remember the recv_io if it has enough bytes, 519 - * this gives smb_direct_negotiate_recv_work enough 520 - * information in order to disconnect if it was not 521 - * valid. 522 - */ 523 - sc->recv_io.reassembly.full_packet_received = true; 524 - if (wc->byte_len >= sizeof(struct smbdirect_negotiate_req)) 525 - smbdirect_connection_reassembly_append_recv_io(sc, recv_io, 0); 526 - else 527 - smbdirect_connection_put_recv_io(recv_io); 528 - 529 - /* 530 - * Some drivers (at least mlx5_ib and irdma in roce mode) 531 - * might post a recv completion before RDMA_CM_EVENT_ESTABLISHED, 532 - * we need to adjust our expectation in that case. 533 - * 534 - * So we defer further processing of the negotiation 535 - * to smb_direct_negotiate_recv_work(). 536 - * 537 - * If we are already in SMBDIRECT_SOCKET_NEGOTIATE_NEEDED 538 - * we queue the work directly otherwise 539 - * smb_direct_cm_handler() will do it, when 540 - * RDMA_CM_EVENT_ESTABLISHED arrived. 541 - */ 542 - spin_lock_irqsave(&sc->connect.lock, flags); 543 - if (!sc->first_error) { 544 - INIT_WORK(&sc->connect.work, smb_direct_negotiate_recv_work); 545 - if (sc->status == SMBDIRECT_SOCKET_NEGOTIATE_NEEDED) 546 - queue_work(sc->workqueue, &sc->connect.work); 547 - } 548 - spin_unlock_irqrestore(&sc->connect.lock, flags); 549 - } 550 - 551 - static void smb_direct_negotiate_recv_work(struct work_struct *work) 552 - { 553 - struct smbdirect_socket *sc = 554 - container_of(work, struct smbdirect_socket, connect.work); 555 - const struct smbdirect_socket_parameters *sp = &sc->parameters; 556 - struct smbdirect_recv_io *recv_io; 557 - 558 - if (sc->first_error) 559 - return; 560 - 561 - ksmbd_debug(RDMA, "Negotiate Recv Work running\n"); 562 - 563 - /* 564 - * Reset timer to the keepalive interval in 565 - * order to trigger our next keepalive message. 566 - */ 567 - sc->idle.keepalive = SMBDIRECT_KEEPALIVE_NONE; 568 - mod_delayed_work(sc->workqueue, &sc->idle.timer_work, 569 - msecs_to_jiffies(sp->keepalive_interval_msec)); 570 - 571 - /* 572 - * If smb_direct_negotiate_recv_done() detected an 573 - * invalid request we want to disconnect. 574 - */ 575 - recv_io = smbdirect_connection_reassembly_first_recv_io(sc); 576 - if (!recv_io) { 577 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 578 - return; 579 - } 580 - 581 - if (SMBDIRECT_CHECK_STATUS_WARN(sc, SMBDIRECT_SOCKET_NEGOTIATE_NEEDED)) { 582 - smbdirect_socket_schedule_cleanup(sc, -ECONNABORTED); 583 - return; 584 - } 585 - sc->status = SMBDIRECT_SOCKET_NEGOTIATE_RUNNING; 586 - wake_up(&sc->status_wait); 587 287 } 588 288 589 289 static int smb_direct_read(struct ksmbd_transport *t, char *buf, ··· 365 657 366 658 ksmbd_debug(RDMA, "smb-direct shutdown cm_id=%p\n", sc->rdma.cm_id); 367 659 368 - smbdirect_socket_cleanup_work(&sc->disconnect_work); 369 - } 370 - 371 - static int smb_direct_cm_handler(struct rdma_cm_id *cm_id, 372 - struct rdma_cm_event *event) 373 - { 374 - struct smbdirect_socket *sc = cm_id->context; 375 - unsigned long flags; 376 - 377 - ksmbd_debug(RDMA, "RDMA CM event. cm_id=%p event=%s (%d)\n", 378 - cm_id, rdma_event_msg(event->event), event->event); 379 - 380 - switch (event->event) { 381 - case RDMA_CM_EVENT_ESTABLISHED: { 382 - /* 383 - * Some drivers (at least mlx5_ib and irdma in roce mode) 384 - * might post a recv completion before RDMA_CM_EVENT_ESTABLISHED, 385 - * we need to adjust our expectation in that case. 386 - * 387 - * If smb_direct_negotiate_recv_done was called first 388 - * it initialized sc->connect.work only for us to 389 - * start, so that we turned into 390 - * SMBDIRECT_SOCKET_NEGOTIATE_NEEDED, before 391 - * smb_direct_negotiate_recv_work() runs. 392 - * 393 - * If smb_direct_negotiate_recv_done didn't happen 394 - * yet. sc->connect.work is still be disabled and 395 - * queue_work() is a no-op. 396 - */ 397 - if (SMBDIRECT_CHECK_STATUS_DISCONNECT(sc, SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING)) 398 - break; 399 - sc->status = SMBDIRECT_SOCKET_NEGOTIATE_NEEDED; 400 - spin_lock_irqsave(&sc->connect.lock, flags); 401 - if (!sc->first_error) 402 - queue_work(sc->workqueue, &sc->connect.work); 403 - spin_unlock_irqrestore(&sc->connect.lock, flags); 404 - wake_up(&sc->status_wait); 405 - break; 406 - } 407 - case RDMA_CM_EVENT_DEVICE_REMOVAL: 408 - case RDMA_CM_EVENT_DISCONNECTED: { 409 - sc->status = SMBDIRECT_SOCKET_DISCONNECTED; 410 - smbdirect_socket_cleanup_work(&sc->disconnect_work); 411 - if (sc->ib.qp) 412 - ib_drain_qp(sc->ib.qp); 413 - break; 414 - } 415 - case RDMA_CM_EVENT_CONNECT_ERROR: { 416 - sc->status = SMBDIRECT_SOCKET_DISCONNECTED; 417 - smbdirect_socket_cleanup_work(&sc->disconnect_work); 418 - break; 419 - } 420 - default: 421 - pr_err("Unexpected RDMA CM event. cm_id=%p, event=%s (%d)\n", 422 - cm_id, rdma_event_msg(event->event), 423 - event->event); 424 - break; 425 - } 426 - return 0; 427 - } 428 - 429 - static int smb_direct_send_negotiate_response(struct smbdirect_socket *sc, 430 - int failed) 431 - { 432 - struct smbdirect_socket_parameters *sp = &sc->parameters; 433 - struct smbdirect_send_io *sendmsg; 434 - struct smbdirect_negotiate_resp *resp; 435 - int ret; 436 - 437 - sendmsg = smbdirect_connection_alloc_send_io(sc); 438 - if (IS_ERR(sendmsg)) 439 - return -ENOMEM; 440 - 441 - resp = (struct smbdirect_negotiate_resp *)sendmsg->packet; 442 - if (failed) { 443 - memset(resp, 0, sizeof(*resp)); 444 - resp->min_version = SMB_DIRECT_VERSION_LE; 445 - resp->max_version = SMB_DIRECT_VERSION_LE; 446 - resp->status = STATUS_NOT_SUPPORTED; 447 - 448 - sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED; 449 - } else { 450 - resp->status = STATUS_SUCCESS; 451 - resp->min_version = SMB_DIRECT_VERSION_LE; 452 - resp->max_version = SMB_DIRECT_VERSION_LE; 453 - resp->negotiated_version = SMB_DIRECT_VERSION_LE; 454 - resp->reserved = 0; 455 - resp->credits_requested = 456 - cpu_to_le16(sp->send_credit_target); 457 - resp->credits_granted = cpu_to_le16(smbdirect_connection_grant_recv_credits(sc)); 458 - resp->max_readwrite_size = cpu_to_le32(sp->max_read_write_size); 459 - resp->preferred_send_size = cpu_to_le32(sp->max_send_size); 460 - resp->max_receive_size = cpu_to_le32(sp->max_recv_size); 461 - resp->max_fragmented_size = 462 - cpu_to_le32(sp->max_fragmented_recv_size); 463 - 464 - atomic_set(&sc->send_io.bcredits.count, 1); 465 - sc->recv_io.expected = SMBDIRECT_EXPECT_DATA_TRANSFER; 466 - sc->status = SMBDIRECT_SOCKET_CONNECTED; 467 - } 468 - 469 - sendmsg->sge[0].addr = ib_dma_map_single(sc->ib.dev, 470 - (void *)resp, sizeof(*resp), 471 - DMA_TO_DEVICE); 472 - ret = ib_dma_mapping_error(sc->ib.dev, sendmsg->sge[0].addr); 473 - if (ret) { 474 - smbdirect_connection_free_send_io(sendmsg); 475 - return ret; 476 - } 477 - 478 - sendmsg->num_sge = 1; 479 - sendmsg->sge[0].length = sizeof(*resp); 480 - sendmsg->sge[0].lkey = sc->ib.pd->local_dma_lkey; 481 - 482 - ret = smbdirect_connection_post_send_io(sc, NULL, sendmsg); 483 - if (ret) { 484 - smbdirect_connection_free_send_io(sendmsg); 485 - return ret; 486 - } 487 - 488 - wait_event(sc->send_io.pending.zero_wait_queue, 489 - atomic_read(&sc->send_io.pending.count) == 0 || 490 - sc->status != SMBDIRECT_SOCKET_CONNECTED); 491 - if (sc->status != SMBDIRECT_SOCKET_CONNECTED) 492 - return -ENOTCONN; 493 - 494 - return 0; 495 - } 496 - 497 - static int smb_direct_accept_client(struct smbdirect_socket *sc) 498 - { 499 - struct smbdirect_socket_parameters *sp = &sc->parameters; 500 - struct rdma_conn_param conn_param; 501 - __be32 ird_ord_hdr[2]; 502 - int ret; 503 - 504 - /* 505 - * smb_direct_handle_connect_request() 506 - * already negotiated sp->initiator_depth 507 - * and sp->responder_resources 508 - */ 509 - memset(&conn_param, 0, sizeof(conn_param)); 510 - conn_param.initiator_depth = sp->initiator_depth; 511 - conn_param.responder_resources = sp->responder_resources; 512 - 513 - if (sc->rdma.legacy_iwarp) { 514 - ird_ord_hdr[0] = cpu_to_be32(conn_param.responder_resources); 515 - ird_ord_hdr[1] = cpu_to_be32(conn_param.initiator_depth); 516 - conn_param.private_data = ird_ord_hdr; 517 - conn_param.private_data_len = sizeof(ird_ord_hdr); 518 - } else { 519 - conn_param.private_data = NULL; 520 - conn_param.private_data_len = 0; 521 - } 522 - conn_param.retry_count = SMB_DIRECT_CM_RETRY; 523 - conn_param.rnr_retry_count = SMB_DIRECT_CM_RNR_RETRY; 524 - conn_param.flow_control = 0; 525 - 526 - /* 527 - * start with the negotiate timeout and SMBDIRECT_KEEPALIVE_PENDING 528 - * so that the timer will cause a disconnect. 529 - */ 530 - sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING; 531 - mod_delayed_work(sc->workqueue, &sc->idle.timer_work, 532 - msecs_to_jiffies(sp->negotiate_timeout_msec)); 533 - 534 - WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED); 535 - sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING; 536 - ret = rdma_accept(sc->rdma.cm_id, &conn_param); 537 - if (ret) { 538 - pr_err("error at rdma_accept: %d\n", ret); 539 - return ret; 540 - } 541 - return 0; 542 - } 543 - 544 - static int smb_direct_prepare_negotiation(struct smbdirect_socket *sc) 545 - { 546 - struct smbdirect_recv_io *recvmsg; 547 - bool recv_posted = false; 548 - int ret; 549 - 550 - WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_CREATED); 551 - sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED; 552 - 553 - sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REQ; 554 - 555 - recvmsg = smbdirect_connection_get_recv_io(sc); 556 - if (!recvmsg) 557 - return -ENOMEM; 558 - recvmsg->cqe.done = smb_direct_negotiate_recv_done; 559 - 560 - ret = smbdirect_connection_post_recv_io(recvmsg); 561 - if (ret) { 562 - pr_err("Can't post recv: %d\n", ret); 563 - goto out_err; 564 - } 565 - recv_posted = true; 566 - 567 - ret = smb_direct_accept_client(sc); 568 - if (ret) { 569 - pr_err("Can't accept client\n"); 570 - goto out_err; 571 - } 572 - 573 - return 0; 574 - out_err: 575 - /* 576 - * If the recv was never posted, return it to the free list. 577 - * If it was posted, leave it alone so disconnect teardown can 578 - * drain the QP and complete it (flush) and the completion path 579 - * will unmap it exactly once. 580 - */ 581 - if (!recv_posted) 582 - smbdirect_connection_put_recv_io(recvmsg); 583 - return ret; 584 - } 585 - 586 - static int smb_direct_init_params(struct smbdirect_socket *sc) 587 - { 588 - struct smbdirect_socket_parameters *sp = &sc->parameters; 589 - int max_send_sges; 590 - unsigned int maxpages; 591 - 592 - /* need 3 more sge. because a SMB_DIRECT header, SMB2 header, 593 - * SMB2 response could be mapped. 594 - */ 595 - max_send_sges = DIV_ROUND_UP(sp->max_send_size, PAGE_SIZE) + 3; 596 - if (max_send_sges > SMBDIRECT_SEND_IO_MAX_SGE) { 597 - pr_err("max_send_size %d is too large\n", sp->max_send_size); 598 - return -EINVAL; 599 - } 600 - 601 - atomic_set(&sc->send_io.lcredits.count, sp->send_credit_target); 602 - 603 - maxpages = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE); 604 - sc->rw_io.credits.max = rdma_rw_mr_factor(sc->ib.dev, 605 - sc->rdma.cm_id->port_num, 606 - maxpages); 607 - sc->rw_io.credits.num_pages = DIV_ROUND_UP(maxpages, sc->rw_io.credits.max); 608 - /* add one extra in order to handle unaligned pages */ 609 - sc->rw_io.credits.max += 1; 610 - 611 - sc->recv_io.credits.target = 1; 612 - 613 - atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max); 614 - 615 - return 0; 660 + smbdirect_socket_shutdown(sc); 616 661 } 617 662 618 663 static int smb_direct_prepare(struct ksmbd_transport *t) 619 664 { 620 665 struct smb_direct_transport *st = SMBD_TRANS(t); 621 666 struct smbdirect_socket *sc = &st->socket; 622 - struct smbdirect_socket_parameters *sp = &sc->parameters; 623 - struct smbdirect_recv_io *recvmsg; 624 - struct smbdirect_negotiate_req *req; 625 - unsigned long flags; 626 667 int ret; 627 668 628 - /* 629 - * We are waiting to pass the following states: 630 - * 631 - * SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED 632 - * SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING 633 - * SMBDIRECT_SOCKET_NEGOTIATE_NEEDED 634 - * 635 - * To finally get to SMBDIRECT_SOCKET_NEGOTIATE_RUNNING 636 - * in order to continue below. 637 - * 638 - * Everything else is unexpected and an error. 639 - */ 640 - ksmbd_debug(RDMA, "Waiting for SMB_DIRECT negotiate request\n"); 641 - ret = wait_event_interruptible_timeout(sc->status_wait, 642 - sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED && 643 - sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING && 644 - sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED, 645 - msecs_to_jiffies(sp->negotiate_timeout_msec)); 646 - if (ret <= 0 || sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING) 647 - return ret < 0 ? ret : -ETIMEDOUT; 648 - 649 - recvmsg = smbdirect_connection_reassembly_first_recv_io(sc); 650 - if (!recvmsg) 651 - return -ECONNABORTED; 652 - 653 - ret = smb_direct_check_recvmsg(recvmsg); 654 - if (ret) 655 - goto put; 656 - 657 - req = (struct smbdirect_negotiate_req *)recvmsg->packet; 658 - sp->max_recv_size = min_t(u32, sp->max_recv_size, 659 - le32_to_cpu(req->preferred_send_size)); 660 - sp->max_send_size = min_t(u32, sp->max_send_size, 661 - le32_to_cpu(req->max_receive_size)); 662 - sp->max_fragmented_send_size = 663 - le32_to_cpu(req->max_fragmented_size); 664 - /* 665 - * The maximum fragmented upper-layer payload receive size supported 666 - * 667 - * Assume max_payload_per_credit is 668 - * smb_direct_receive_credit_max - 24 = 1340 669 - * 670 - * The maximum number would be 671 - * smb_direct_receive_credit_max * max_payload_per_credit 672 - * 673 - * 1340 * 255 = 341700 (0x536C4) 674 - * 675 - * The minimum value from the spec is 131072 (0x20000) 676 - * 677 - * For now we use the logic we used before: 678 - * (1364 * 255) / 2 = 173910 (0x2A756) 679 - * 680 - * We need to adjust this here in case the peer 681 - * lowered sp->max_recv_size. 682 - * 683 - * TODO: instead of adjusting max_fragmented_recv_size 684 - * we should adjust the number of available buffers, 685 - * but for now we keep the current logic. 686 - */ 687 - sp->max_fragmented_recv_size = 688 - (sp->recv_credit_max * sp->max_recv_size) / 2; 689 - sc->recv_io.credits.target = le16_to_cpu(req->credits_requested); 690 - sc->recv_io.credits.target = min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max); 691 - sc->recv_io.credits.target = max_t(u16, sc->recv_io.credits.target, 1); 692 - 693 - put: 694 - spin_lock_irqsave(&sc->recv_io.reassembly.lock, flags); 695 - sc->recv_io.reassembly.queue_length--; 696 - list_del(&recvmsg->list); 697 - spin_unlock_irqrestore(&sc->recv_io.reassembly.lock, flags); 698 - smbdirect_connection_put_recv_io(recvmsg); 699 - 700 - if (ret == -ECONNABORTED) 701 - return ret; 702 - 703 - if (ret) 704 - goto respond; 705 - 706 - /* 707 - * We negotiated with success, so we need to refill the recv queue. 708 - * 709 - * The message that grants the credits to the client is 710 - * the negotiate response. 711 - */ 712 - ret = smbdirect_connection_recv_io_refill(sc); 713 - if (ret < 0) 714 - return ret; 715 - ret = 0; 716 - 717 - respond: 718 - ret = smb_direct_send_negotiate_response(sc, ret); 719 - if (ret) 720 - return ret; 721 - 722 - INIT_WORK(&sc->recv_io.posted.refill_work, smbdirect_connection_recv_io_refill_work); 723 - INIT_WORK(&sc->idle.immediate_work, smbdirect_connection_send_immediate_work); 724 - 725 - return 0; 726 - } 727 - 728 - static int smb_direct_connect(struct smbdirect_socket *sc) 729 - { 730 - struct smbdirect_recv_io *recv_io; 731 - int ret; 732 - 733 - sc->rdma.cm_id->event_handler = smb_direct_cm_handler; 734 - 735 - ret = smb_direct_init_params(sc); 669 + ksmbd_debug(RDMA, "SMB_DIRECT Waiting for connection\n"); 670 + ret = smbdirect_connection_wait_for_connected(sc); 736 671 if (ret) { 737 - pr_err("Can't configure RDMA parameters\n"); 672 + ksmbd_debug(RDMA, "SMB_DIRECT connection failed %d => %1pe\n", 673 + ret, ERR_PTR(ret)); 738 674 return ret; 739 675 } 740 676 741 - ret = smbdirect_connection_create_mem_pools(sc); 742 - if (ret) { 743 - pr_err("Can't init RDMA pool: %d\n", ret); 744 - return ret; 745 - } 746 - 747 - list_for_each_entry(recv_io, &sc->recv_io.free.list, list) 748 - recv_io->cqe.done = recv_done; 749 - 750 - ret = smbdirect_connection_create_qp(sc); 751 - if (ret) { 752 - pr_err("Can't accept RDMA client: %d\n", ret); 753 - return ret; 754 - } 755 - 756 - ret = smb_direct_prepare_negotiation(sc); 757 - if (ret) { 758 - pr_err("Can't negotiate: %d\n", ret); 759 - return ret; 760 - } 677 + ksmbd_debug(RDMA, "SMB_DIRECT connection ready\n"); 761 678 return 0; 762 679 } 763 680 ··· 392 1059 struct smb_direct_listener *listener = new_cm_id->context; 393 1060 struct smb_direct_transport *t; 394 1061 struct smbdirect_socket *sc; 395 - struct smbdirect_socket_parameters *sp; 396 1062 struct task_struct *handler; 397 - u8 peer_initiator_depth; 398 - u8 peer_responder_resources; 399 1063 int ret; 400 1064 401 1065 if (!smbdirect_frwr_is_supported(&new_cm_id->device->attrs)) { ··· 406 1076 if (!t) 407 1077 return -ENOMEM; 408 1078 sc = &t->socket; 409 - sp = &sc->parameters; 410 1079 411 - /* 412 - * First set what the we as server are able to support 413 - */ 414 - sp->initiator_depth = min_t(u8, sp->initiator_depth, 415 - sc->ib.dev->attrs.max_qp_rd_atom); 416 - 417 - peer_initiator_depth = event->param.conn.initiator_depth; 418 - peer_responder_resources = event->param.conn.responder_resources; 419 - smbdirect_connection_negotiate_rdma_resources(sc, 420 - peer_initiator_depth, 421 - peer_responder_resources, 422 - &event->param.conn); 423 - 424 - ret = smb_direct_connect(sc); 1080 + ret = smbdirect_accept_connect_request(sc, &event->param.conn); 425 1081 if (ret) 426 1082 goto out_err; 427 1083

Configure Feed

Configure Feed