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 queue_size, 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(queue_size, sizeof(*ius), gfp_mask); 30 if (!ius) 31 return NULL; 32 for (i = 0; i < queue_size; 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_size) 54 { 55 struct rtrs_iu *iu; 56 int i; 57 58 if (!ius) 59 return; 60 61 for (i = 0; i < queue_size; 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_sess *sess = con->sess; 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 = sess->dev->ib_pd->local_dma_lkey; 79 80 if (list.length == 0) { 81 rtrs_wrn(con->sess, 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) 109 { 110 if (head) { 111 struct ib_send_wr *tail = head; 112 113 while (tail->next) 114 tail = tail->next; 115 tail->next = wr; 116 } else { 117 head = wr; 118 } 119 120 return ib_post_send(qp, head, NULL); 121 } 122 123 int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size, 124 struct ib_send_wr *head) 125 { 126 struct rtrs_sess *sess = con->sess; 127 struct ib_send_wr wr; 128 struct ib_sge list; 129 130 if (WARN_ON(size == 0)) 131 return -EINVAL; 132 133 list.addr = iu->dma_addr; 134 list.length = size; 135 list.lkey = sess->dev->ib_pd->local_dma_lkey; 136 137 wr = (struct ib_send_wr) { 138 .wr_cqe = &iu->cqe, 139 .sg_list = &list, 140 .num_sge = 1, 141 .opcode = IB_WR_SEND, 142 .send_flags = IB_SEND_SIGNALED, 143 }; 144 145 return rtrs_post_send(con->qp, head, &wr); 146 } 147 EXPORT_SYMBOL_GPL(rtrs_iu_post_send); 148 149 int rtrs_iu_post_rdma_write_imm(struct rtrs_con *con, struct rtrs_iu *iu, 150 struct ib_sge *sge, unsigned int num_sge, 151 u32 rkey, u64 rdma_addr, u32 imm_data, 152 enum ib_send_flags flags, 153 struct ib_send_wr *head) 154 { 155 struct ib_rdma_wr wr; 156 int i; 157 158 wr = (struct ib_rdma_wr) { 159 .wr.wr_cqe = &iu->cqe, 160 .wr.sg_list = sge, 161 .wr.num_sge = num_sge, 162 .rkey = rkey, 163 .remote_addr = rdma_addr, 164 .wr.opcode = IB_WR_RDMA_WRITE_WITH_IMM, 165 .wr.ex.imm_data = cpu_to_be32(imm_data), 166 .wr.send_flags = flags, 167 }; 168 169 /* 170 * If one of the sges has 0 size, the operation will fail with a 171 * length error 172 */ 173 for (i = 0; i < num_sge; i++) 174 if (WARN_ON(sge[i].length == 0)) 175 return -EINVAL; 176 177 return rtrs_post_send(con->qp, head, &wr.wr); 178 } 179 EXPORT_SYMBOL_GPL(rtrs_iu_post_rdma_write_imm); 180 181 int rtrs_post_rdma_write_imm_empty(struct rtrs_con *con, struct ib_cqe *cqe, 182 u32 imm_data, enum ib_send_flags flags, 183 struct ib_send_wr *head) 184 { 185 struct ib_send_wr wr; 186 187 wr = (struct ib_send_wr) { 188 .wr_cqe = cqe, 189 .send_flags = flags, 190 .opcode = IB_WR_RDMA_WRITE_WITH_IMM, 191 .ex.imm_data = cpu_to_be32(imm_data), 192 }; 193 194 return rtrs_post_send(con->qp, head, &wr); 195 } 196 EXPORT_SYMBOL_GPL(rtrs_post_rdma_write_imm_empty); 197 198 static void qp_event_handler(struct ib_event *ev, void *ctx) 199 { 200 struct rtrs_con *con = ctx; 201 202 switch (ev->event) { 203 case IB_EVENT_COMM_EST: 204 rtrs_info(con->sess, "QP event %s (%d) received\n", 205 ib_event_msg(ev->event), ev->event); 206 rdma_notify(con->cm_id, IB_EVENT_COMM_EST); 207 break; 208 default: 209 rtrs_info(con->sess, "Unhandled QP event %s (%d) received\n", 210 ib_event_msg(ev->event), ev->event); 211 break; 212 } 213 } 214 215 static int create_cq(struct rtrs_con *con, int cq_vector, u16 cq_size, 216 enum ib_poll_context poll_ctx) 217 { 218 struct rdma_cm_id *cm_id = con->cm_id; 219 struct ib_cq *cq; 220 221 cq = ib_alloc_cq(cm_id->device, con, cq_size, 222 cq_vector, poll_ctx); 223 if (IS_ERR(cq)) { 224 rtrs_err(con->sess, "Creating completion queue failed, errno: %ld\n", 225 PTR_ERR(cq)); 226 return PTR_ERR(cq); 227 } 228 con->cq = cq; 229 230 return 0; 231 } 232 233 static int create_qp(struct rtrs_con *con, struct ib_pd *pd, 234 u16 wr_queue_size, u32 max_sge) 235 { 236 struct ib_qp_init_attr init_attr = {NULL}; 237 struct rdma_cm_id *cm_id = con->cm_id; 238 int ret; 239 240 init_attr.cap.max_send_wr = wr_queue_size; 241 init_attr.cap.max_recv_wr = wr_queue_size; 242 init_attr.cap.max_recv_sge = 1; 243 init_attr.event_handler = qp_event_handler; 244 init_attr.qp_context = con; 245 init_attr.cap.max_send_sge = max_sge; 246 247 init_attr.qp_type = IB_QPT_RC; 248 init_attr.send_cq = con->cq; 249 init_attr.recv_cq = con->cq; 250 init_attr.sq_sig_type = IB_SIGNAL_REQ_WR; 251 252 ret = rdma_create_qp(cm_id, pd, &init_attr); 253 if (ret) { 254 rtrs_err(con->sess, "Creating QP failed, err: %d\n", ret); 255 return ret; 256 } 257 con->qp = cm_id->qp; 258 259 return ret; 260 } 261 262 int rtrs_cq_qp_create(struct rtrs_sess *sess, struct rtrs_con *con, 263 u32 max_send_sge, int cq_vector, u16 cq_size, 264 u16 wr_queue_size, enum ib_poll_context poll_ctx) 265 { 266 int err; 267 268 err = create_cq(con, cq_vector, cq_size, poll_ctx); 269 if (err) 270 return err; 271 272 err = create_qp(con, sess->dev->ib_pd, wr_queue_size, max_send_sge); 273 if (err) { 274 ib_free_cq(con->cq); 275 con->cq = NULL; 276 return err; 277 } 278 con->sess = sess; 279 280 return 0; 281 } 282 EXPORT_SYMBOL_GPL(rtrs_cq_qp_create); 283 284 void rtrs_cq_qp_destroy(struct rtrs_con *con) 285 { 286 if (con->qp) { 287 rdma_destroy_qp(con->cm_id); 288 con->qp = NULL; 289 } 290 if (con->cq) { 291 ib_free_cq(con->cq); 292 con->cq = NULL; 293 } 294 } 295 EXPORT_SYMBOL_GPL(rtrs_cq_qp_destroy); 296 297 static void schedule_hb(struct rtrs_sess *sess) 298 { 299 queue_delayed_work(sess->hb_wq, &sess->hb_dwork, 300 msecs_to_jiffies(sess->hb_interval_ms)); 301 } 302 303 void rtrs_send_hb_ack(struct rtrs_sess *sess) 304 { 305 struct rtrs_con *usr_con = sess->con[0]; 306 u32 imm; 307 int err; 308 309 imm = rtrs_to_imm(RTRS_HB_ACK_IMM, 0); 310 err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm, 311 IB_SEND_SIGNALED, NULL); 312 if (err) { 313 sess->hb_err_handler(usr_con); 314 return; 315 } 316 } 317 EXPORT_SYMBOL_GPL(rtrs_send_hb_ack); 318 319 static void hb_work(struct work_struct *work) 320 { 321 struct rtrs_con *usr_con; 322 struct rtrs_sess *sess; 323 u32 imm; 324 int err; 325 326 sess = container_of(to_delayed_work(work), typeof(*sess), hb_dwork); 327 usr_con = sess->con[0]; 328 329 if (sess->hb_missed_cnt > sess->hb_missed_max) { 330 sess->hb_err_handler(usr_con); 331 return; 332 } 333 if (sess->hb_missed_cnt++) { 334 /* Reschedule work without sending hb */ 335 schedule_hb(sess); 336 return; 337 } 338 imm = rtrs_to_imm(RTRS_HB_MSG_IMM, 0); 339 err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm, 340 IB_SEND_SIGNALED, NULL); 341 if (err) { 342 sess->hb_err_handler(usr_con); 343 return; 344 } 345 346 schedule_hb(sess); 347 } 348 349 void rtrs_init_hb(struct rtrs_sess *sess, struct ib_cqe *cqe, 350 unsigned int interval_ms, unsigned int missed_max, 351 void (*err_handler)(struct rtrs_con *con), 352 struct workqueue_struct *wq) 353 { 354 sess->hb_cqe = cqe; 355 sess->hb_interval_ms = interval_ms; 356 sess->hb_err_handler = err_handler; 357 sess->hb_wq = wq; 358 sess->hb_missed_max = missed_max; 359 sess->hb_missed_cnt = 0; 360 INIT_DELAYED_WORK(&sess->hb_dwork, hb_work); 361 } 362 EXPORT_SYMBOL_GPL(rtrs_init_hb); 363 364 void rtrs_start_hb(struct rtrs_sess *sess) 365 { 366 schedule_hb(sess); 367 } 368 EXPORT_SYMBOL_GPL(rtrs_start_hb); 369 370 void rtrs_stop_hb(struct rtrs_sess *sess) 371 { 372 cancel_delayed_work_sync(&sess->hb_dwork); 373 sess->hb_missed_cnt = 0; 374 sess->hb_missed_max = 0; 375 } 376 EXPORT_SYMBOL_GPL(rtrs_stop_hb); 377 378 static int rtrs_str_gid_to_sockaddr(const char *addr, size_t len, 379 short port, struct sockaddr_storage *dst) 380 { 381 struct sockaddr_ib *dst_ib = (struct sockaddr_ib *)dst; 382 int ret; 383 384 /* 385 * We can use some of the IPv6 functions since GID is a valid 386 * IPv6 address format 387 */ 388 ret = in6_pton(addr, len, dst_ib->sib_addr.sib_raw, '\0', NULL); 389 if (ret == 0) 390 return -EINVAL; 391 392 dst_ib->sib_family = AF_IB; 393 /* 394 * Use the same TCP server port number as the IB service ID 395 * on the IB port space range 396 */ 397 dst_ib->sib_sid = cpu_to_be64(RDMA_IB_IP_PS_IB | port); 398 dst_ib->sib_sid_mask = cpu_to_be64(0xffffffffffffffffULL); 399 dst_ib->sib_pkey = cpu_to_be16(0xffff); 400 401 return 0; 402 } 403 404 /** 405 * rtrs_str_to_sockaddr() - Convert rtrs address string to sockaddr 406 * @addr: String representation of an addr (IPv4, IPv6 or IB GID): 407 * - "ip:192.168.1.1" 408 * - "ip:fe80::200:5aee:feaa:20a2" 409 * - "gid:fe80::200:5aee:feaa:20a2" 410 * @len: String address length 411 * @port: Destination port 412 * @dst: Destination sockaddr structure 413 * 414 * Returns 0 if conversion successful. Non-zero on error. 415 */ 416 static int rtrs_str_to_sockaddr(const char *addr, size_t len, 417 u16 port, struct sockaddr_storage *dst) 418 { 419 if (strncmp(addr, "gid:", 4) == 0) { 420 return rtrs_str_gid_to_sockaddr(addr + 4, len - 4, port, dst); 421 } else if (strncmp(addr, "ip:", 3) == 0) { 422 char port_str[8]; 423 char *cpy; 424 int err; 425 426 snprintf(port_str, sizeof(port_str), "%u", port); 427 cpy = kstrndup(addr + 3, len - 3, GFP_KERNEL); 428 err = cpy ? inet_pton_with_scope(&init_net, AF_UNSPEC, 429 cpy, port_str, dst) : -ENOMEM; 430 kfree(cpy); 431 432 return err; 433 } 434 return -EPROTONOSUPPORT; 435 } 436 437 /** 438 * sockaddr_to_str() - convert sockaddr to a string. 439 * @addr: the sockadddr structure to be converted. 440 * @buf: string containing socket addr. 441 * @len: string length. 442 * 443 * The return value is the number of characters written into buf not 444 * including the trailing '\0'. If len is == 0 the function returns 0.. 445 */ 446 int sockaddr_to_str(const struct sockaddr *addr, char *buf, size_t len) 447 { 448 449 switch (addr->sa_family) { 450 case AF_IB: 451 return scnprintf(buf, len, "gid:%pI6", 452 &((struct sockaddr_ib *)addr)->sib_addr.sib_raw); 453 case AF_INET: 454 return scnprintf(buf, len, "ip:%pI4", 455 &((struct sockaddr_in *)addr)->sin_addr); 456 case AF_INET6: 457 return scnprintf(buf, len, "ip:%pI6c", 458 &((struct sockaddr_in6 *)addr)->sin6_addr); 459 } 460 return scnprintf(buf, len, "<invalid address family>"); 461 } 462 EXPORT_SYMBOL(sockaddr_to_str); 463 464 /** 465 * rtrs_addr_to_sockaddr() - convert path string "src,dst" or "src@dst" 466 * to sockaddreses 467 * @str: string containing source and destination addr of a path 468 * separated by ',' or '@' I.e. "ip:1.1.1.1,ip:1.1.1.2" or 469 * "ip:1.1.1.1@ip:1.1.1.2". If str contains only one address it's 470 * considered to be destination. 471 * @len: string length 472 * @port: Destination port number. 473 * @addr: will be set to the source/destination address or to NULL 474 * if str doesn't contain any source address. 475 * 476 * Returns zero if conversion successful. Non-zero otherwise. 477 */ 478 int rtrs_addr_to_sockaddr(const char *str, size_t len, u16 port, 479 struct rtrs_addr *addr) 480 { 481 const char *d; 482 483 d = strchr(str, ','); 484 if (!d) 485 d = strchr(str, '@'); 486 if (d) { 487 if (rtrs_str_to_sockaddr(str, d - str, 0, addr->src)) 488 return -EINVAL; 489 d += 1; 490 len -= d - str; 491 str = d; 492 493 } else { 494 addr->src = NULL; 495 } 496 return rtrs_str_to_sockaddr(str, len, port, addr->dst); 497 } 498 EXPORT_SYMBOL(rtrs_addr_to_sockaddr); 499 500 void rtrs_rdma_dev_pd_init(enum ib_pd_flags pd_flags, 501 struct rtrs_rdma_dev_pd *pool) 502 { 503 WARN_ON(pool->ops && (!pool->ops->alloc ^ !pool->ops->free)); 504 INIT_LIST_HEAD(&pool->list); 505 mutex_init(&pool->mutex); 506 pool->pd_flags = pd_flags; 507 } 508 EXPORT_SYMBOL(rtrs_rdma_dev_pd_init); 509 510 void rtrs_rdma_dev_pd_deinit(struct rtrs_rdma_dev_pd *pool) 511 { 512 mutex_destroy(&pool->mutex); 513 WARN_ON(!list_empty(&pool->list)); 514 } 515 EXPORT_SYMBOL(rtrs_rdma_dev_pd_deinit); 516 517 static void dev_free(struct kref *ref) 518 { 519 struct rtrs_rdma_dev_pd *pool; 520 struct rtrs_ib_dev *dev; 521 522 dev = container_of(ref, typeof(*dev), ref); 523 pool = dev->pool; 524 525 mutex_lock(&pool->mutex); 526 list_del(&dev->entry); 527 mutex_unlock(&pool->mutex); 528 529 if (pool->ops && pool->ops->deinit) 530 pool->ops->deinit(dev); 531 532 ib_dealloc_pd(dev->ib_pd); 533 534 if (pool->ops && pool->ops->free) 535 pool->ops->free(dev); 536 else 537 kfree(dev); 538 } 539 540 int rtrs_ib_dev_put(struct rtrs_ib_dev *dev) 541 { 542 return kref_put(&dev->ref, dev_free); 543 } 544 EXPORT_SYMBOL(rtrs_ib_dev_put); 545 546 static int rtrs_ib_dev_get(struct rtrs_ib_dev *dev) 547 { 548 return kref_get_unless_zero(&dev->ref); 549 } 550 551 struct rtrs_ib_dev * 552 rtrs_ib_dev_find_or_add(struct ib_device *ib_dev, 553 struct rtrs_rdma_dev_pd *pool) 554 { 555 struct rtrs_ib_dev *dev; 556 557 mutex_lock(&pool->mutex); 558 list_for_each_entry(dev, &pool->list, entry) { 559 if (dev->ib_dev->node_guid == ib_dev->node_guid && 560 rtrs_ib_dev_get(dev)) 561 goto out_unlock; 562 } 563 mutex_unlock(&pool->mutex); 564 if (pool->ops && pool->ops->alloc) 565 dev = pool->ops->alloc(); 566 else 567 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 568 if (IS_ERR_OR_NULL(dev)) 569 goto out_err; 570 571 kref_init(&dev->ref); 572 dev->pool = pool; 573 dev->ib_dev = ib_dev; 574 dev->ib_pd = ib_alloc_pd(ib_dev, pool->pd_flags); 575 if (IS_ERR(dev->ib_pd)) 576 goto out_free_dev; 577 578 if (pool->ops && pool->ops->init && pool->ops->init(dev)) 579 goto out_free_pd; 580 581 mutex_lock(&pool->mutex); 582 list_add(&dev->entry, &pool->list); 583 out_unlock: 584 mutex_unlock(&pool->mutex); 585 return dev; 586 587 out_free_pd: 588 ib_dealloc_pd(dev->ib_pd); 589 out_free_dev: 590 if (pool->ops && pool->ops->free) 591 pool->ops->free(dev); 592 else 593 kfree(dev); 594 out_err: 595 return NULL; 596 } 597 EXPORT_SYMBOL(rtrs_ib_dev_find_or_add); 598