1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * RDMA Transport Layer 4 * 5 * Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved. 6 * Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved. 7 * Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved. 8 */ 9 #undef pr_fmt 10 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt 11 12 #include <linux/module.h> 13 #include <linux/inet.h> 14 15 #include "rtrs-pri.h" 16 #include "rtrs-log.h" 17 18 MODULE_DESCRIPTION("RDMA Transport Core"); 19 MODULE_LICENSE("GPL"); 20 21 struct rtrs_iu *rtrs_iu_alloc(u32 iu_num, size_t size, gfp_t gfp_mask, 22 struct ib_device *dma_dev, 23 enum dma_data_direction dir, 24 void (*done)(struct ib_cq *cq, struct ib_wc *wc)) 25 { 26 struct rtrs_iu *ius, *iu; 27 int i; 28 29 ius = kcalloc(iu_num, sizeof(*ius), gfp_mask); 30 if (!ius) 31 return NULL; 32 for (i = 0; i < iu_num; i++) { 33 iu = &ius[i]; 34 iu->direction = dir; 35 iu->buf = kzalloc(size, gfp_mask); 36 if (!iu->buf) 37 goto err; 38 39 iu->dma_addr = ib_dma_map_single(dma_dev, iu->buf, size, dir); 40 if (ib_dma_mapping_error(dma_dev, iu->dma_addr)) 41 goto err; 42 43 iu->cqe.done = done; 44 iu->size = size; 45 } 46 return ius; 47 err: 48 rtrs_iu_free(ius, dma_dev, i); 49 return NULL; 50 } 51 EXPORT_SYMBOL_GPL(rtrs_iu_alloc); 52 53 void rtrs_iu_free(struct rtrs_iu *ius, struct ib_device *ibdev, u32 queue_num) 54 { 55 struct rtrs_iu *iu; 56 int i; 57 58 if (!ius) 59 return; 60 61 for (i = 0; i < queue_num; i++) { 62 iu = &ius[i]; 63 ib_dma_unmap_single(ibdev, iu->dma_addr, iu->size, iu->direction); 64 kfree(iu->buf); 65 } 66 kfree(ius); 67 } 68 EXPORT_SYMBOL_GPL(rtrs_iu_free); 69 70 int rtrs_iu_post_recv(struct rtrs_con *con, struct rtrs_iu *iu) 71 { 72 struct rtrs_path *path = con->path; 73 struct ib_recv_wr wr; 74 struct ib_sge list; 75 76 list.addr = iu->dma_addr; 77 list.length = iu->size; 78 list.lkey = path->dev->ib_pd->local_dma_lkey; 79 80 if (list.length == 0) { 81 rtrs_wrn(con->path, 82 "Posting receive work request failed, sg list is empty\n"); 83 return -EINVAL; 84 } 85 wr = (struct ib_recv_wr) { 86 .wr_cqe = &iu->cqe, 87 .sg_list = &list, 88 .num_sge = 1, 89 }; 90 91 return ib_post_recv(con->qp, &wr, NULL); 92 } 93 EXPORT_SYMBOL_GPL(rtrs_iu_post_recv); 94 95 int rtrs_post_recv_empty(struct rtrs_con *con, struct ib_cqe *cqe) 96 { 97 struct ib_recv_wr wr; 98 99 wr = (struct ib_recv_wr) { 100 .wr_cqe = cqe, 101 }; 102 103 return ib_post_recv(con->qp, &wr, NULL); 104 } 105 EXPORT_SYMBOL_GPL(rtrs_post_recv_empty); 106 107 static int rtrs_post_send(struct ib_qp *qp, struct ib_send_wr *head, 108 struct ib_send_wr *wr, struct ib_send_wr *tail) 109 { 110 if (head) { 111 struct ib_send_wr *next = head; 112 113 while (next->next) 114 next = next->next; 115 next->next = wr; 116 } else { 117 head = wr; 118 } 119 120 if (tail) 121 wr->next = tail; 122 123 return ib_post_send(qp, head, NULL); 124 } 125 126 int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size, 127 struct ib_send_wr *head) 128 { 129 struct rtrs_path *path = con->path; 130 struct ib_send_wr wr; 131 struct ib_sge list; 132 133 if (WARN_ON(size == 0)) 134 return -EINVAL; 135 136 list.addr = iu->dma_addr; 137 list.length = size; 138 list.lkey = path->dev->ib_pd->local_dma_lkey; 139 140 wr = (struct ib_send_wr) { 141 .wr_cqe = &iu->cqe, 142 .sg_list = &list, 143 .num_sge = 1, 144 .opcode = IB_WR_SEND, 145 .send_flags = IB_SEND_SIGNALED, 146 }; 147 148 return rtrs_post_send(con->qp, head, &wr, NULL); 149 } 150 EXPORT_SYMBOL_GPL(rtrs_iu_post_send); 151 152 int rtrs_iu_post_rdma_write_imm(struct rtrs_con *con, struct rtrs_iu *iu, 153 struct ib_sge *sge, unsigned int num_sge, 154 u32 rkey, u64 rdma_addr, u32 imm_data, 155 enum ib_send_flags flags, 156 struct ib_send_wr *head, 157 struct ib_send_wr *tail) 158 { 159 struct ib_rdma_wr wr; 160 int i; 161 162 wr = (struct ib_rdma_wr) { 163 .wr.wr_cqe = &iu->cqe, 164 .wr.sg_list = sge, 165 .wr.num_sge = num_sge, 166 .rkey = rkey, 167 .remote_addr = rdma_addr, 168 .wr.opcode = IB_WR_RDMA_WRITE_WITH_IMM, 169 .wr.ex.imm_data = cpu_to_be32(imm_data), 170 .wr.send_flags = flags, 171 }; 172 173 /* 174 * If one of the sges has 0 size, the operation will fail with a 175 * length error 176 */ 177 for (i = 0; i < num_sge; i++) 178 if (WARN_ON(sge[i].length == 0)) 179 return -EINVAL; 180 181 return rtrs_post_send(con->qp, head, &wr.wr, tail); 182 } 183 EXPORT_SYMBOL_GPL(rtrs_iu_post_rdma_write_imm); 184 185 static int rtrs_post_rdma_write_imm_empty(struct rtrs_con *con, 186 struct ib_cqe *cqe, 187 u32 imm_data, 188 struct ib_send_wr *head) 189 { 190 struct ib_rdma_wr wr; 191 struct rtrs_path *path = con->path; 192 enum ib_send_flags sflags; 193 194 atomic_dec_if_positive(&con->sq_wr_avail); 195 sflags = (atomic_inc_return(&con->wr_cnt) % path->signal_interval) ? 196 0 : IB_SEND_SIGNALED; 197 198 wr = (struct ib_rdma_wr) { 199 .wr.wr_cqe = cqe, 200 .wr.send_flags = sflags, 201 .wr.opcode = IB_WR_RDMA_WRITE_WITH_IMM, 202 .wr.ex.imm_data = cpu_to_be32(imm_data), 203 }; 204 205 return rtrs_post_send(con->qp, head, &wr.wr, NULL); 206 } 207 208 static void qp_event_handler(struct ib_event *ev, void *ctx) 209 { 210 struct rtrs_con *con = ctx; 211 212 switch (ev->event) { 213 case IB_EVENT_COMM_EST: 214 rtrs_info(con->path, "QP event %s (%d) received\n", 215 ib_event_msg(ev->event), ev->event); 216 rdma_notify(con->cm_id, IB_EVENT_COMM_EST); 217 break; 218 default: 219 rtrs_info(con->path, "Unhandled QP event %s (%d) received\n", 220 ib_event_msg(ev->event), ev->event); 221 break; 222 } 223 } 224 225 static bool is_pollqueue(struct rtrs_con *con) 226 { 227 return con->cid >= con->path->irq_con_num; 228 } 229 230 static int create_cq(struct rtrs_con *con, int cq_vector, int nr_cqe, 231 enum ib_poll_context poll_ctx) 232 { 233 struct rdma_cm_id *cm_id = con->cm_id; 234 struct ib_cq *cq; 235 236 if (is_pollqueue(con)) 237 cq = ib_alloc_cq(cm_id->device, con, nr_cqe, cq_vector, 238 poll_ctx); 239 else 240 cq = ib_cq_pool_get(cm_id->device, nr_cqe, cq_vector, poll_ctx); 241 242 if (IS_ERR(cq)) { 243 rtrs_err(con->path, "Creating completion queue failed, errno: %ld\n", 244 PTR_ERR(cq)); 245 return PTR_ERR(cq); 246 } 247 con->cq = cq; 248 con->nr_cqe = nr_cqe; 249 250 return 0; 251 } 252 253 static int create_qp(struct rtrs_con *con, struct ib_pd *pd, 254 u32 max_send_wr, u32 max_recv_wr, u32 max_sge) 255 { 256 struct ib_qp_init_attr init_attr = {NULL}; 257 struct rdma_cm_id *cm_id = con->cm_id; 258 int ret; 259 260 init_attr.cap.max_send_wr = max_send_wr; 261 init_attr.cap.max_recv_wr = max_recv_wr; 262 init_attr.cap.max_recv_sge = 1; 263 init_attr.event_handler = qp_event_handler; 264 init_attr.qp_context = con; 265 init_attr.cap.max_send_sge = max_sge; 266 267 init_attr.qp_type = IB_QPT_RC; 268 init_attr.send_cq = con->cq; 269 init_attr.recv_cq = con->cq; 270 init_attr.sq_sig_type = IB_SIGNAL_REQ_WR; 271 272 ret = rdma_create_qp(cm_id, pd, &init_attr); 273 if (ret) { 274 rtrs_err(con->path, "Creating QP failed, err: %d\n", ret); 275 return ret; 276 } 277 con->qp = cm_id->qp; 278 279 return ret; 280 } 281 282 static void destroy_cq(struct rtrs_con *con) 283 { 284 if (con->cq) { 285 if (is_pollqueue(con)) 286 ib_free_cq(con->cq); 287 else 288 ib_cq_pool_put(con->cq, con->nr_cqe); 289 } 290 con->cq = NULL; 291 } 292 293 int rtrs_cq_qp_create(struct rtrs_path *path, struct rtrs_con *con, 294 u32 max_send_sge, int cq_vector, int nr_cqe, 295 u32 max_send_wr, u32 max_recv_wr, 296 enum ib_poll_context poll_ctx) 297 { 298 int err; 299 300 err = create_cq(con, cq_vector, nr_cqe, poll_ctx); 301 if (err) 302 return err; 303 304 err = create_qp(con, path->dev->ib_pd, max_send_wr, max_recv_wr, 305 max_send_sge); 306 if (err) { 307 destroy_cq(con); 308 return err; 309 } 310 con->path = path; 311 312 return 0; 313 } 314 EXPORT_SYMBOL_GPL(rtrs_cq_qp_create); 315 316 void rtrs_cq_qp_destroy(struct rtrs_con *con) 317 { 318 if (con->qp) { 319 rdma_destroy_qp(con->cm_id); 320 con->qp = NULL; 321 } 322 destroy_cq(con); 323 } 324 EXPORT_SYMBOL_GPL(rtrs_cq_qp_destroy); 325 326 static void schedule_hb(struct rtrs_path *path) 327 { 328 queue_delayed_work(path->hb_wq, &path->hb_dwork, 329 msecs_to_jiffies(path->hb_interval_ms)); 330 } 331 332 void rtrs_send_hb_ack(struct rtrs_path *path) 333 { 334 struct rtrs_con *usr_con = path->con[0]; 335 u32 imm; 336 int err; 337 338 imm = rtrs_to_imm(RTRS_HB_ACK_IMM, 0); 339 err = rtrs_post_rdma_write_imm_empty(usr_con, path->hb_cqe, imm, 340 NULL); 341 if (err) { 342 rtrs_err(path, "send HB ACK failed, errno: %d\n", err); 343 path->hb_err_handler(usr_con); 344 return; 345 } 346 } 347 EXPORT_SYMBOL_GPL(rtrs_send_hb_ack); 348 349 static void hb_work(struct work_struct *work) 350 { 351 struct rtrs_con *usr_con; 352 struct rtrs_path *path; 353 u32 imm; 354 int err; 355 356 path = container_of(to_delayed_work(work), typeof(*path), hb_dwork); 357 usr_con = path->con[0]; 358 359 if (path->hb_missed_cnt > path->hb_missed_max) { 360 rtrs_err(path, "HB missed max reached.\n"); 361 path->hb_err_handler(usr_con); 362 return; 363 } 364 if (path->hb_missed_cnt++) { 365 /* Reschedule work without sending hb */ 366 schedule_hb(path); 367 return; 368 } 369 370 path->hb_last_sent = ktime_get(); 371 372 imm = rtrs_to_imm(RTRS_HB_MSG_IMM, 0); 373 err = rtrs_post_rdma_write_imm_empty(usr_con, path->hb_cqe, imm, 374 NULL); 375 if (err) { 376 rtrs_err(path, "HB send failed, errno: %d\n", err); 377 path->hb_err_handler(usr_con); 378 return; 379 } 380 381 schedule_hb(path); 382 } 383 384 void rtrs_init_hb(struct rtrs_path *path, struct ib_cqe *cqe, 385 unsigned int interval_ms, unsigned int missed_max, 386 void (*err_handler)(struct rtrs_con *con), 387 struct workqueue_struct *wq) 388 { 389 path->hb_cqe = cqe; 390 path->hb_interval_ms = interval_ms; 391 path->hb_err_handler = err_handler; 392 path->hb_wq = wq; 393 path->hb_missed_max = missed_max; 394 path->hb_missed_cnt = 0; 395 INIT_DELAYED_WORK(&path->hb_dwork, hb_work); 396 } 397 EXPORT_SYMBOL_GPL(rtrs_init_hb); 398 399 void rtrs_start_hb(struct rtrs_path *path) 400 { 401 schedule_hb(path); 402 } 403 EXPORT_SYMBOL_GPL(rtrs_start_hb); 404 405 void rtrs_stop_hb(struct rtrs_path *path) 406 { 407 cancel_delayed_work_sync(&path->hb_dwork); 408 path->hb_missed_cnt = 0; 409 } 410 EXPORT_SYMBOL_GPL(rtrs_stop_hb); 411 412 static int rtrs_str_gid_to_sockaddr(const char *addr, size_t len, 413 short port, struct sockaddr_storage *dst) 414 { 415 struct sockaddr_ib *dst_ib = (struct sockaddr_ib *)dst; 416 int ret; 417 418 /* 419 * We can use some of the IPv6 functions since GID is a valid 420 * IPv6 address format 421 */ 422 ret = in6_pton(addr, len, dst_ib->sib_addr.sib_raw, '\0', NULL); 423 if (ret == 0) 424 return -EINVAL; 425 426 dst_ib->sib_family = AF_IB; 427 /* 428 * Use the same TCP server port number as the IB service ID 429 * on the IB port space range 430 */ 431 dst_ib->sib_sid = cpu_to_be64(RDMA_IB_IP_PS_IB | port); 432 dst_ib->sib_sid_mask = cpu_to_be64(0xffffffffffffffffULL); 433 dst_ib->sib_pkey = cpu_to_be16(0xffff); 434 435 return 0; 436 } 437 438 /** 439 * rtrs_str_to_sockaddr() - Convert rtrs address string to sockaddr 440 * @addr: String representation of an addr (IPv4, IPv6 or IB GID): 441 * - "ip:192.168.1.1" 442 * - "ip:fe80::200:5aee:feaa:20a2" 443 * - "gid:fe80::200:5aee:feaa:20a2" 444 * @len: String address length 445 * @port: Destination port 446 * @dst: Destination sockaddr structure 447 * 448 * Returns 0 if conversion successful. Non-zero on error. 449 */ 450 static int rtrs_str_to_sockaddr(const char *addr, size_t len, 451 u16 port, struct sockaddr_storage *dst) 452 { 453 if (strncmp(addr, "gid:", 4) == 0) { 454 return rtrs_str_gid_to_sockaddr(addr + 4, len - 4, port, dst); 455 } else if (strncmp(addr, "ip:", 3) == 0) { 456 char port_str[8]; 457 char *cpy; 458 int err; 459 460 snprintf(port_str, sizeof(port_str), "%u", port); 461 cpy = kstrndup(addr + 3, len - 3, GFP_KERNEL); 462 err = cpy ? inet_pton_with_scope(&init_net, AF_UNSPEC, 463 cpy, port_str, dst) : -ENOMEM; 464 kfree(cpy); 465 466 return err; 467 } 468 return -EPROTONOSUPPORT; 469 } 470 471 /** 472 * sockaddr_to_str() - convert sockaddr to a string. 473 * @addr: the sockadddr structure to be converted. 474 * @buf: string containing socket addr. 475 * @len: string length. 476 * 477 * The return value is the number of characters written into buf not 478 * including the trailing '\0'. If len is == 0 the function returns 0.. 479 */ 480 int sockaddr_to_str(const struct sockaddr *addr, char *buf, size_t len) 481 { 482 switch (addr->sa_family) { 483 case AF_IB: 484 return scnprintf(buf, len, "gid:%pI6", 485 &((struct sockaddr_ib *)addr)->sib_addr.sib_raw); 486 case AF_INET: 487 return scnprintf(buf, len, "ip:%pI4", 488 &((struct sockaddr_in *)addr)->sin_addr); 489 case AF_INET6: 490 return scnprintf(buf, len, "ip:%pI6c", 491 &((struct sockaddr_in6 *)addr)->sin6_addr); 492 } 493 return scnprintf(buf, len, "<invalid address family>"); 494 } 495 EXPORT_SYMBOL(sockaddr_to_str); 496 497 /** 498 * rtrs_addr_to_str() - convert rtrs_addr to a string "src@dst" 499 * @addr: the rtrs_addr structure to be converted 500 * @buf: string containing source and destination addr of a path 501 * separated by '@' I.e. "ip:1.1.1.1@ip:1.1.1.2" 502 * "ip:1.1.1.1@ip:1.1.1.2". 503 * @len: string length 504 * 505 * The return value is the number of characters written into buf not 506 * including the trailing '\0'. 507 */ 508 int rtrs_addr_to_str(const struct rtrs_addr *addr, char *buf, size_t len) 509 { 510 int cnt; 511 512 cnt = sockaddr_to_str((struct sockaddr *)addr->src, 513 buf, len); 514 cnt += scnprintf(buf + cnt, len - cnt, "@"); 515 sockaddr_to_str((struct sockaddr *)addr->dst, 516 buf + cnt, len - cnt); 517 return cnt; 518 } 519 EXPORT_SYMBOL(rtrs_addr_to_str); 520 521 /** 522 * rtrs_addr_to_sockaddr() - convert path string "src,dst" or "src@dst" 523 * to sockaddreses 524 * @str: string containing source and destination addr of a path 525 * separated by ',' or '@' I.e. "ip:1.1.1.1,ip:1.1.1.2" or 526 * "ip:1.1.1.1@ip:1.1.1.2". If str contains only one address it's 527 * considered to be destination. 528 * @len: string length 529 * @port: Destination port number. 530 * @addr: will be set to the source/destination address or to NULL 531 * if str doesn't contain any source address. 532 * 533 * Returns zero if conversion successful. Non-zero otherwise. 534 */ 535 int rtrs_addr_to_sockaddr(const char *str, size_t len, u16 port, 536 struct rtrs_addr *addr) 537 { 538 const char *d; 539 540 d = strchr(str, ','); 541 if (!d) 542 d = strchr(str, '@'); 543 if (d) { 544 if (rtrs_str_to_sockaddr(str, d - str, 0, addr->src)) 545 return -EINVAL; 546 d += 1; 547 len -= d - str; 548 str = d; 549 550 } else { 551 addr->src = NULL; 552 } 553 return rtrs_str_to_sockaddr(str, len, port, addr->dst); 554 } 555 EXPORT_SYMBOL(rtrs_addr_to_sockaddr); 556 557 void rtrs_rdma_dev_pd_init(enum ib_pd_flags pd_flags, 558 struct rtrs_rdma_dev_pd *pool) 559 { 560 WARN_ON(pool->ops && (!pool->ops->alloc ^ !pool->ops->free)); 561 INIT_LIST_HEAD(&pool->list); 562 mutex_init(&pool->mutex); 563 pool->pd_flags = pd_flags; 564 } 565 EXPORT_SYMBOL(rtrs_rdma_dev_pd_init); 566 567 void rtrs_rdma_dev_pd_deinit(struct rtrs_rdma_dev_pd *pool) 568 { 569 mutex_destroy(&pool->mutex); 570 WARN_ON(!list_empty(&pool->list)); 571 } 572 EXPORT_SYMBOL(rtrs_rdma_dev_pd_deinit); 573 574 static void dev_free(struct kref *ref) 575 { 576 struct rtrs_rdma_dev_pd *pool; 577 struct rtrs_ib_dev *dev; 578 579 dev = container_of(ref, typeof(*dev), ref); 580 pool = dev->pool; 581 582 mutex_lock(&pool->mutex); 583 list_del(&dev->entry); 584 mutex_unlock(&pool->mutex); 585 586 if (pool->ops && pool->ops->deinit) 587 pool->ops->deinit(dev); 588 589 ib_dealloc_pd(dev->ib_pd); 590 591 if (pool->ops && pool->ops->free) 592 pool->ops->free(dev); 593 else 594 kfree(dev); 595 } 596 597 int rtrs_ib_dev_put(struct rtrs_ib_dev *dev) 598 { 599 return kref_put(&dev->ref, dev_free); 600 } 601 EXPORT_SYMBOL(rtrs_ib_dev_put); 602 603 static int rtrs_ib_dev_get(struct rtrs_ib_dev *dev) 604 { 605 return kref_get_unless_zero(&dev->ref); 606 } 607 608 struct rtrs_ib_dev * 609 rtrs_ib_dev_find_or_add(struct ib_device *ib_dev, 610 struct rtrs_rdma_dev_pd *pool) 611 { 612 struct rtrs_ib_dev *dev; 613 614 mutex_lock(&pool->mutex); 615 list_for_each_entry(dev, &pool->list, entry) { 616 if (dev->ib_dev->node_guid == ib_dev->node_guid && 617 rtrs_ib_dev_get(dev)) 618 goto out_unlock; 619 } 620 mutex_unlock(&pool->mutex); 621 if (pool->ops && pool->ops->alloc) 622 dev = pool->ops->alloc(); 623 else 624 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 625 if (IS_ERR_OR_NULL(dev)) 626 goto out_err; 627 628 kref_init(&dev->ref); 629 dev->pool = pool; 630 dev->ib_dev = ib_dev; 631 dev->ib_pd = ib_alloc_pd(ib_dev, pool->pd_flags); 632 if (IS_ERR(dev->ib_pd)) 633 goto out_free_dev; 634 635 if (pool->ops && pool->ops->init && pool->ops->init(dev)) 636 goto out_free_pd; 637 638 mutex_lock(&pool->mutex); 639 list_add(&dev->entry, &pool->list); 640 out_unlock: 641 mutex_unlock(&pool->mutex); 642 return dev; 643 644 out_free_pd: 645 ib_dealloc_pd(dev->ib_pd); 646 out_free_dev: 647 if (pool->ops && pool->ops->free) 648 pool->ops->free(dev); 649 else 650 kfree(dev); 651 out_err: 652 return NULL; 653 } 654 EXPORT_SYMBOL(rtrs_ib_dev_find_or_add); 655