1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * linux/fs/9p/trans_rdma.c 4 * 5 * RDMA transport layer based on the trans_fd.c implementation. 6 * 7 * Copyright (C) 2008 by Tom Tucker <tom@opengridcomputing.com> 8 * Copyright (C) 2006 by Russ Cox <rsc@swtch.com> 9 * Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net> 10 * Copyright (C) 2004-2008 by Eric Van Hensbergen <ericvh@gmail.com> 11 * Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com> 12 */ 13 14#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 15 16#include <linux/in.h> 17#include <linux/module.h> 18#include <linux/net.h> 19#include <linux/ipv6.h> 20#include <linux/kthread.h> 21#include <linux/errno.h> 22#include <linux/kernel.h> 23#include <linux/un.h> 24#include <linux/uaccess.h> 25#include <linux/inet.h> 26#include <linux/idr.h> 27#include <linux/file.h> 28#include <linux/parser.h> 29#include <linux/semaphore.h> 30#include <linux/slab.h> 31#include <linux/seq_file.h> 32#include <net/9p/9p.h> 33#include <net/9p/client.h> 34#include <net/9p/transport.h> 35#include <rdma/ib_verbs.h> 36#include <rdma/rdma_cm.h> 37 38#define P9_PORT 5640 39#define P9_RDMA_SQ_DEPTH 32 40#define P9_RDMA_RQ_DEPTH 32 41#define P9_RDMA_SEND_SGE 4 42#define P9_RDMA_RECV_SGE 4 43#define P9_RDMA_IRD 0 44#define P9_RDMA_ORD 0 45#define P9_RDMA_TIMEOUT 30000 /* 30 seconds */ 46#define P9_RDMA_MAXSIZE (1024*1024) /* 1MB */ 47 48/** 49 * struct p9_trans_rdma - RDMA transport instance 50 * 51 * @state: tracks the transport state machine for connection setup and tear down 52 * @cm_id: The RDMA CM ID 53 * @pd: Protection Domain pointer 54 * @qp: Queue Pair pointer 55 * @cq: Completion Queue pointer 56 * @timeout: Number of uSecs to wait for connection management events 57 * @privport: Whether a privileged port may be used 58 * @port: The port to use 59 * @sq_depth: The depth of the Send Queue 60 * @sq_sem: Semaphore for the SQ 61 * @rq_depth: The depth of the Receive Queue. 62 * @rq_sem: Semaphore for the RQ 63 * @excess_rc : Amount of posted Receive Contexts without a pending request. 64 * See rdma_request() 65 * @addr: The remote peer's address 66 * @req_lock: Protects the active request list 67 * @cm_done: Completion event for connection management tracking 68 */ 69struct p9_trans_rdma { 70 enum { 71 P9_RDMA_INIT, 72 P9_RDMA_ADDR_RESOLVED, 73 P9_RDMA_ROUTE_RESOLVED, 74 P9_RDMA_CONNECTED, 75 P9_RDMA_FLUSHING, 76 P9_RDMA_CLOSING, 77 P9_RDMA_CLOSED, 78 } state; 79 struct rdma_cm_id *cm_id; 80 struct ib_pd *pd; 81 struct ib_qp *qp; 82 struct ib_cq *cq; 83 long timeout; 84 bool privport; 85 u16 port; 86 int sq_depth; 87 struct semaphore sq_sem; 88 int rq_depth; 89 struct semaphore rq_sem; 90 atomic_t excess_rc; 91 struct sockaddr_in addr; 92 spinlock_t req_lock; 93 94 struct completion cm_done; 95}; 96 97struct p9_rdma_req; 98 99/** 100 * struct p9_rdma_context - Keeps track of in-process WR 101 * 102 * @busa: Bus address to unmap when the WR completes 103 * @req: Keeps track of requests (send) 104 * @rc: Keepts track of replies (receive) 105 */ 106struct p9_rdma_context { 107 struct ib_cqe cqe; 108 dma_addr_t busa; 109 union { 110 struct p9_req_t *req; 111 struct p9_fcall rc; 112 }; 113}; 114 115/** 116 * struct p9_rdma_opts - Collection of mount options 117 * @port: port of connection 118 * @sq_depth: The requested depth of the SQ. This really doesn't need 119 * to be any deeper than the number of threads used in the client 120 * @rq_depth: The depth of the RQ. Should be greater than or equal to SQ depth 121 * @timeout: Time to wait in msecs for CM events 122 */ 123struct p9_rdma_opts { 124 short port; 125 bool privport; 126 int sq_depth; 127 int rq_depth; 128 long timeout; 129}; 130 131/* 132 * Option Parsing (code inspired by NFS code) 133 */ 134enum { 135 /* Options that take integer arguments */ 136 Opt_port, Opt_rq_depth, Opt_sq_depth, Opt_timeout, 137 /* Options that take no argument */ 138 Opt_privport, 139 Opt_err, 140}; 141 142static match_table_t tokens = { 143 {Opt_port, "port=%u"}, 144 {Opt_sq_depth, "sq=%u"}, 145 {Opt_rq_depth, "rq=%u"}, 146 {Opt_timeout, "timeout=%u"}, 147 {Opt_privport, "privport"}, 148 {Opt_err, NULL}, 149}; 150 151static int p9_rdma_show_options(struct seq_file *m, struct p9_client *clnt) 152{ 153 struct p9_trans_rdma *rdma = clnt->trans; 154 155 if (rdma->port != P9_PORT) 156 seq_printf(m, ",port=%u", rdma->port); 157 if (rdma->sq_depth != P9_RDMA_SQ_DEPTH) 158 seq_printf(m, ",sq=%u", rdma->sq_depth); 159 if (rdma->rq_depth != P9_RDMA_RQ_DEPTH) 160 seq_printf(m, ",rq=%u", rdma->rq_depth); 161 if (rdma->timeout != P9_RDMA_TIMEOUT) 162 seq_printf(m, ",timeout=%lu", rdma->timeout); 163 if (rdma->privport) 164 seq_puts(m, ",privport"); 165 return 0; 166} 167 168/** 169 * parse_opts - parse mount options into rdma options structure 170 * @params: options string passed from mount 171 * @opts: rdma transport-specific structure to parse options into 172 * 173 * Returns 0 upon success, -ERRNO upon failure 174 */ 175static int parse_opts(char *params, struct p9_rdma_opts *opts) 176{ 177 char *p; 178 substring_t args[MAX_OPT_ARGS]; 179 int option; 180 char *options, *tmp_options; 181 182 opts->port = P9_PORT; 183 opts->sq_depth = P9_RDMA_SQ_DEPTH; 184 opts->rq_depth = P9_RDMA_RQ_DEPTH; 185 opts->timeout = P9_RDMA_TIMEOUT; 186 opts->privport = false; 187 188 if (!params) 189 return 0; 190 191 tmp_options = kstrdup(params, GFP_KERNEL); 192 if (!tmp_options) { 193 p9_debug(P9_DEBUG_ERROR, 194 "failed to allocate copy of option string\n"); 195 return -ENOMEM; 196 } 197 options = tmp_options; 198 199 while ((p = strsep(&options, ",")) != NULL) { 200 int token; 201 int r; 202 if (!*p) 203 continue; 204 token = match_token(p, tokens, args); 205 if ((token != Opt_err) && (token != Opt_privport)) { 206 r = match_int(&args[0], &option); 207 if (r < 0) { 208 p9_debug(P9_DEBUG_ERROR, 209 "integer field, but no integer?\n"); 210 continue; 211 } 212 } 213 switch (token) { 214 case Opt_port: 215 opts->port = option; 216 break; 217 case Opt_sq_depth: 218 opts->sq_depth = option; 219 break; 220 case Opt_rq_depth: 221 opts->rq_depth = option; 222 break; 223 case Opt_timeout: 224 opts->timeout = option; 225 break; 226 case Opt_privport: 227 opts->privport = true; 228 break; 229 default: 230 continue; 231 } 232 } 233 /* RQ must be at least as large as the SQ */ 234 opts->rq_depth = max(opts->rq_depth, opts->sq_depth); 235 kfree(tmp_options); 236 return 0; 237} 238 239static int 240p9_cm_event_handler(struct rdma_cm_id *id, struct rdma_cm_event *event) 241{ 242 struct p9_client *c = id->context; 243 struct p9_trans_rdma *rdma = c->trans; 244 switch (event->event) { 245 case RDMA_CM_EVENT_ADDR_RESOLVED: 246 BUG_ON(rdma->state != P9_RDMA_INIT); 247 rdma->state = P9_RDMA_ADDR_RESOLVED; 248 break; 249 250 case RDMA_CM_EVENT_ROUTE_RESOLVED: 251 BUG_ON(rdma->state != P9_RDMA_ADDR_RESOLVED); 252 rdma->state = P9_RDMA_ROUTE_RESOLVED; 253 break; 254 255 case RDMA_CM_EVENT_ESTABLISHED: 256 BUG_ON(rdma->state != P9_RDMA_ROUTE_RESOLVED); 257 rdma->state = P9_RDMA_CONNECTED; 258 break; 259 260 case RDMA_CM_EVENT_DISCONNECTED: 261 if (rdma) 262 rdma->state = P9_RDMA_CLOSED; 263 c->status = Disconnected; 264 break; 265 266 case RDMA_CM_EVENT_TIMEWAIT_EXIT: 267 break; 268 269 case RDMA_CM_EVENT_ADDR_CHANGE: 270 case RDMA_CM_EVENT_ROUTE_ERROR: 271 case RDMA_CM_EVENT_DEVICE_REMOVAL: 272 case RDMA_CM_EVENT_MULTICAST_JOIN: 273 case RDMA_CM_EVENT_MULTICAST_ERROR: 274 case RDMA_CM_EVENT_REJECTED: 275 case RDMA_CM_EVENT_CONNECT_REQUEST: 276 case RDMA_CM_EVENT_CONNECT_RESPONSE: 277 case RDMA_CM_EVENT_CONNECT_ERROR: 278 case RDMA_CM_EVENT_ADDR_ERROR: 279 case RDMA_CM_EVENT_UNREACHABLE: 280 c->status = Disconnected; 281 rdma_disconnect(rdma->cm_id); 282 break; 283 default: 284 BUG(); 285 } 286 complete(&rdma->cm_done); 287 return 0; 288} 289 290static void 291recv_done(struct ib_cq *cq, struct ib_wc *wc) 292{ 293 struct p9_client *client = cq->cq_context; 294 struct p9_trans_rdma *rdma = client->trans; 295 struct p9_rdma_context *c = 296 container_of(wc->wr_cqe, struct p9_rdma_context, cqe); 297 struct p9_req_t *req; 298 int err = 0; 299 int16_t tag; 300 301 req = NULL; 302 ib_dma_unmap_single(rdma->cm_id->device, c->busa, client->msize, 303 DMA_FROM_DEVICE); 304 305 if (wc->status != IB_WC_SUCCESS) 306 goto err_out; 307 308 c->rc.size = wc->byte_len; 309 err = p9_parse_header(&c->rc, NULL, NULL, &tag, 1); 310 if (err) 311 goto err_out; 312 313 req = p9_tag_lookup(client, tag); 314 if (!req) 315 goto err_out; 316 317 /* Check that we have not yet received a reply for this request. 318 */ 319 if (unlikely(req->rc.sdata)) { 320 pr_err("Duplicate reply for request %d", tag); 321 goto err_out; 322 } 323 324 req->rc.size = c->rc.size; 325 req->rc.sdata = c->rc.sdata; 326 p9_client_cb(client, req, REQ_STATUS_RCVD); 327 328 out: 329 up(&rdma->rq_sem); 330 kfree(c); 331 return; 332 333 err_out: 334 p9_debug(P9_DEBUG_ERROR, "req %p err %d status %d\n", 335 req, err, wc->status); 336 rdma->state = P9_RDMA_FLUSHING; 337 client->status = Disconnected; 338 goto out; 339} 340 341static void 342send_done(struct ib_cq *cq, struct ib_wc *wc) 343{ 344 struct p9_client *client = cq->cq_context; 345 struct p9_trans_rdma *rdma = client->trans; 346 struct p9_rdma_context *c = 347 container_of(wc->wr_cqe, struct p9_rdma_context, cqe); 348 349 ib_dma_unmap_single(rdma->cm_id->device, 350 c->busa, c->req->tc.size, 351 DMA_TO_DEVICE); 352 up(&rdma->sq_sem); 353 p9_req_put(c->req); 354 kfree(c); 355} 356 357static void qp_event_handler(struct ib_event *event, void *context) 358{ 359 p9_debug(P9_DEBUG_ERROR, "QP event %d context %p\n", 360 event->event, context); 361} 362 363static void rdma_destroy_trans(struct p9_trans_rdma *rdma) 364{ 365 if (!rdma) 366 return; 367 368 if (rdma->qp && !IS_ERR(rdma->qp)) 369 ib_destroy_qp(rdma->qp); 370 371 if (rdma->pd && !IS_ERR(rdma->pd)) 372 ib_dealloc_pd(rdma->pd); 373 374 if (rdma->cq && !IS_ERR(rdma->cq)) 375 ib_free_cq(rdma->cq); 376 377 if (rdma->cm_id && !IS_ERR(rdma->cm_id)) 378 rdma_destroy_id(rdma->cm_id); 379 380 kfree(rdma); 381} 382 383static int 384post_recv(struct p9_client *client, struct p9_rdma_context *c) 385{ 386 struct p9_trans_rdma *rdma = client->trans; 387 struct ib_recv_wr wr; 388 struct ib_sge sge; 389 int ret; 390 391 c->busa = ib_dma_map_single(rdma->cm_id->device, 392 c->rc.sdata, client->msize, 393 DMA_FROM_DEVICE); 394 if (ib_dma_mapping_error(rdma->cm_id->device, c->busa)) 395 goto error; 396 397 c->cqe.done = recv_done; 398 399 sge.addr = c->busa; 400 sge.length = client->msize; 401 sge.lkey = rdma->pd->local_dma_lkey; 402 403 wr.next = NULL; 404 wr.wr_cqe = &c->cqe; 405 wr.sg_list = &sge; 406 wr.num_sge = 1; 407 408 ret = ib_post_recv(rdma->qp, &wr, NULL); 409 if (ret) 410 ib_dma_unmap_single(rdma->cm_id->device, c->busa, 411 client->msize, DMA_FROM_DEVICE); 412 return ret; 413 414 error: 415 p9_debug(P9_DEBUG_ERROR, "EIO\n"); 416 return -EIO; 417} 418 419static int rdma_request(struct p9_client *client, struct p9_req_t *req) 420{ 421 struct p9_trans_rdma *rdma = client->trans; 422 struct ib_send_wr wr; 423 struct ib_sge sge; 424 int err = 0; 425 unsigned long flags; 426 struct p9_rdma_context *c = NULL; 427 struct p9_rdma_context *rpl_context = NULL; 428 429 /* When an error occurs between posting the recv and the send, 430 * there will be a receive context posted without a pending request. 431 * Since there is no way to "un-post" it, we remember it and skip 432 * post_recv() for the next request. 433 * So here, 434 * see if we are this `next request' and need to absorb an excess rc. 435 * If yes, then drop and free our own, and do not recv_post(). 436 **/ 437 if (unlikely(atomic_read(&rdma->excess_rc) > 0)) { 438 if ((atomic_sub_return(1, &rdma->excess_rc) >= 0)) { 439 /* Got one! */ 440 p9_fcall_fini(&req->rc); 441 req->rc.sdata = NULL; 442 goto dont_need_post_recv; 443 } else { 444 /* We raced and lost. */ 445 atomic_inc(&rdma->excess_rc); 446 } 447 } 448 449 /* Allocate an fcall for the reply */ 450 rpl_context = kmalloc(sizeof *rpl_context, GFP_NOFS); 451 if (!rpl_context) { 452 err = -ENOMEM; 453 goto recv_error; 454 } 455 rpl_context->rc.sdata = req->rc.sdata; 456 457 /* 458 * Post a receive buffer for this request. We need to ensure 459 * there is a reply buffer available for every outstanding 460 * request. A flushed request can result in no reply for an 461 * outstanding request, so we must keep a count to avoid 462 * overflowing the RQ. 463 */ 464 if (down_interruptible(&rdma->rq_sem)) { 465 err = -EINTR; 466 goto recv_error; 467 } 468 469 err = post_recv(client, rpl_context); 470 if (err) { 471 p9_debug(P9_DEBUG_ERROR, "POST RECV failed: %d\n", err); 472 goto recv_error; 473 } 474 /* remove posted receive buffer from request structure */ 475 req->rc.sdata = NULL; 476 477dont_need_post_recv: 478 /* Post the request */ 479 c = kmalloc(sizeof *c, GFP_NOFS); 480 if (!c) { 481 err = -ENOMEM; 482 goto send_error; 483 } 484 c->req = req; 485 486 c->busa = ib_dma_map_single(rdma->cm_id->device, 487 c->req->tc.sdata, c->req->tc.size, 488 DMA_TO_DEVICE); 489 if (ib_dma_mapping_error(rdma->cm_id->device, c->busa)) { 490 err = -EIO; 491 goto send_error; 492 } 493 494 c->cqe.done = send_done; 495 496 sge.addr = c->busa; 497 sge.length = c->req->tc.size; 498 sge.lkey = rdma->pd->local_dma_lkey; 499 500 wr.next = NULL; 501 wr.wr_cqe = &c->cqe; 502 wr.opcode = IB_WR_SEND; 503 wr.send_flags = IB_SEND_SIGNALED; 504 wr.sg_list = &sge; 505 wr.num_sge = 1; 506 507 if (down_interruptible(&rdma->sq_sem)) { 508 err = -EINTR; 509 goto dma_unmap; 510 } 511 512 /* Mark request as `sent' *before* we actually send it, 513 * because doing if after could erase the REQ_STATUS_RCVD 514 * status in case of a very fast reply. 515 */ 516 req->status = REQ_STATUS_SENT; 517 err = ib_post_send(rdma->qp, &wr, NULL); 518 if (err) 519 goto dma_unmap; 520 521 /* Success */ 522 return 0; 523 524dma_unmap: 525 ib_dma_unmap_single(rdma->cm_id->device, c->busa, 526 c->req->tc.size, DMA_TO_DEVICE); 527 /* Handle errors that happened during or while preparing the send: */ 528 send_error: 529 req->status = REQ_STATUS_ERROR; 530 kfree(c); 531 p9_debug(P9_DEBUG_ERROR, "Error %d in rdma_request()\n", err); 532 533 /* Ach. 534 * We did recv_post(), but not send. We have one recv_post in excess. 535 */ 536 atomic_inc(&rdma->excess_rc); 537 return err; 538 539 /* Handle errors that happened during or while preparing post_recv(): */ 540 recv_error: 541 kfree(rpl_context); 542 spin_lock_irqsave(&rdma->req_lock, flags); 543 if (err != -EINTR && rdma->state < P9_RDMA_CLOSING) { 544 rdma->state = P9_RDMA_CLOSING; 545 spin_unlock_irqrestore(&rdma->req_lock, flags); 546 rdma_disconnect(rdma->cm_id); 547 } else 548 spin_unlock_irqrestore(&rdma->req_lock, flags); 549 return err; 550} 551 552static void rdma_close(struct p9_client *client) 553{ 554 struct p9_trans_rdma *rdma; 555 556 if (!client) 557 return; 558 559 rdma = client->trans; 560 if (!rdma) 561 return; 562 563 client->status = Disconnected; 564 rdma_disconnect(rdma->cm_id); 565 rdma_destroy_trans(rdma); 566} 567 568/** 569 * alloc_rdma - Allocate and initialize the rdma transport structure 570 * @opts: Mount options structure 571 */ 572static struct p9_trans_rdma *alloc_rdma(struct p9_rdma_opts *opts) 573{ 574 struct p9_trans_rdma *rdma; 575 576 rdma = kzalloc(sizeof(struct p9_trans_rdma), GFP_KERNEL); 577 if (!rdma) 578 return NULL; 579 580 rdma->port = opts->port; 581 rdma->privport = opts->privport; 582 rdma->sq_depth = opts->sq_depth; 583 rdma->rq_depth = opts->rq_depth; 584 rdma->timeout = opts->timeout; 585 spin_lock_init(&rdma->req_lock); 586 init_completion(&rdma->cm_done); 587 sema_init(&rdma->sq_sem, rdma->sq_depth); 588 sema_init(&rdma->rq_sem, rdma->rq_depth); 589 atomic_set(&rdma->excess_rc, 0); 590 591 return rdma; 592} 593 594static int rdma_cancel(struct p9_client *client, struct p9_req_t *req) 595{ 596 /* Nothing to do here. 597 * We will take care of it (if we have to) in rdma_cancelled() 598 */ 599 return 1; 600} 601 602/* A request has been fully flushed without a reply. 603 * That means we have posted one buffer in excess. 604 */ 605static int rdma_cancelled(struct p9_client *client, struct p9_req_t *req) 606{ 607 struct p9_trans_rdma *rdma = client->trans; 608 atomic_inc(&rdma->excess_rc); 609 return 0; 610} 611 612static int p9_rdma_bind_privport(struct p9_trans_rdma *rdma) 613{ 614 struct sockaddr_in cl = { 615 .sin_family = AF_INET, 616 .sin_addr.s_addr = htonl(INADDR_ANY), 617 }; 618 int port, err = -EINVAL; 619 620 for (port = P9_DEF_MAX_RESVPORT; port >= P9_DEF_MIN_RESVPORT; port--) { 621 cl.sin_port = htons((ushort)port); 622 err = rdma_bind_addr(rdma->cm_id, (struct sockaddr *)&cl); 623 if (err != -EADDRINUSE) 624 break; 625 } 626 return err; 627} 628 629/** 630 * rdma_create_trans - Transport method for creating a transport instance 631 * @client: client instance 632 * @addr: IP address string 633 * @args: Mount options string 634 */ 635static int 636rdma_create_trans(struct p9_client *client, const char *addr, char *args) 637{ 638 int err; 639 struct p9_rdma_opts opts; 640 struct p9_trans_rdma *rdma; 641 struct rdma_conn_param conn_param; 642 struct ib_qp_init_attr qp_attr; 643 644 if (addr == NULL) 645 return -EINVAL; 646 647 /* Parse the transport specific mount options */ 648 err = parse_opts(args, &opts); 649 if (err < 0) 650 return err; 651 652 /* Create and initialize the RDMA transport structure */ 653 rdma = alloc_rdma(&opts); 654 if (!rdma) 655 return -ENOMEM; 656 657 /* Create the RDMA CM ID */ 658 rdma->cm_id = rdma_create_id(&init_net, p9_cm_event_handler, client, 659 RDMA_PS_TCP, IB_QPT_RC); 660 if (IS_ERR(rdma->cm_id)) 661 goto error; 662 663 /* Associate the client with the transport */ 664 client->trans = rdma; 665 666 /* Bind to a privileged port if we need to */ 667 if (opts.privport) { 668 err = p9_rdma_bind_privport(rdma); 669 if (err < 0) { 670 pr_err("%s (%d): problem binding to privport: %d\n", 671 __func__, task_pid_nr(current), -err); 672 goto error; 673 } 674 } 675 676 /* Resolve the server's address */ 677 rdma->addr.sin_family = AF_INET; 678 rdma->addr.sin_addr.s_addr = in_aton(addr); 679 rdma->addr.sin_port = htons(opts.port); 680 err = rdma_resolve_addr(rdma->cm_id, NULL, 681 (struct sockaddr *)&rdma->addr, 682 rdma->timeout); 683 if (err) 684 goto error; 685 err = wait_for_completion_interruptible(&rdma->cm_done); 686 if (err || (rdma->state != P9_RDMA_ADDR_RESOLVED)) 687 goto error; 688 689 /* Resolve the route to the server */ 690 err = rdma_resolve_route(rdma->cm_id, rdma->timeout); 691 if (err) 692 goto error; 693 err = wait_for_completion_interruptible(&rdma->cm_done); 694 if (err || (rdma->state != P9_RDMA_ROUTE_RESOLVED)) 695 goto error; 696 697 /* Create the Completion Queue */ 698 rdma->cq = ib_alloc_cq_any(rdma->cm_id->device, client, 699 opts.sq_depth + opts.rq_depth + 1, 700 IB_POLL_SOFTIRQ); 701 if (IS_ERR(rdma->cq)) 702 goto error; 703 704 /* Create the Protection Domain */ 705 rdma->pd = ib_alloc_pd(rdma->cm_id->device, 0); 706 if (IS_ERR(rdma->pd)) 707 goto error; 708 709 /* Create the Queue Pair */ 710 memset(&qp_attr, 0, sizeof qp_attr); 711 qp_attr.event_handler = qp_event_handler; 712 qp_attr.qp_context = client; 713 qp_attr.cap.max_send_wr = opts.sq_depth; 714 qp_attr.cap.max_recv_wr = opts.rq_depth; 715 qp_attr.cap.max_send_sge = P9_RDMA_SEND_SGE; 716 qp_attr.cap.max_recv_sge = P9_RDMA_RECV_SGE; 717 qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR; 718 qp_attr.qp_type = IB_QPT_RC; 719 qp_attr.send_cq = rdma->cq; 720 qp_attr.recv_cq = rdma->cq; 721 err = rdma_create_qp(rdma->cm_id, rdma->pd, &qp_attr); 722 if (err) 723 goto error; 724 rdma->qp = rdma->cm_id->qp; 725 726 /* Request a connection */ 727 memset(&conn_param, 0, sizeof(conn_param)); 728 conn_param.private_data = NULL; 729 conn_param.private_data_len = 0; 730 conn_param.responder_resources = P9_RDMA_IRD; 731 conn_param.initiator_depth = P9_RDMA_ORD; 732 err = rdma_connect(rdma->cm_id, &conn_param); 733 if (err) 734 goto error; 735 err = wait_for_completion_interruptible(&rdma->cm_done); 736 if (err || (rdma->state != P9_RDMA_CONNECTED)) 737 goto error; 738 739 client->status = Connected; 740 741 return 0; 742 743error: 744 rdma_destroy_trans(rdma); 745 return -ENOTCONN; 746} 747 748static struct p9_trans_module p9_rdma_trans = { 749 .name = "rdma", 750 .maxsize = P9_RDMA_MAXSIZE, 751 .def = 0, 752 .owner = THIS_MODULE, 753 .create = rdma_create_trans, 754 .close = rdma_close, 755 .request = rdma_request, 756 .cancel = rdma_cancel, 757 .cancelled = rdma_cancelled, 758 .show_options = p9_rdma_show_options, 759}; 760 761/** 762 * p9_trans_rdma_init - Register the 9P RDMA transport driver 763 */ 764static int __init p9_trans_rdma_init(void) 765{ 766 v9fs_register_trans(&p9_rdma_trans); 767 return 0; 768} 769 770static void __exit p9_trans_rdma_exit(void) 771{ 772 v9fs_unregister_trans(&p9_rdma_trans); 773} 774 775module_init(p9_trans_rdma_init); 776module_exit(p9_trans_rdma_exit); 777 778MODULE_AUTHOR("Tom Tucker <tom@opengridcomputing.com>"); 779MODULE_DESCRIPTION("RDMA Transport for 9P"); 780MODULE_LICENSE("Dual BSD/GPL"); 781