1 // SPDX-License-Identifier: GPL-2.0-or-later
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.
10 #define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt
12 #include <linux/module.h>
13 #include <linux/inet.h>
18 MODULE_DESCRIPTION("RDMA Transport Core");
19 MODULE_LICENSE("GPL");
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))
26 struct rtrs_iu *ius, *iu;
29 ius = kcalloc(queue_size, sizeof(*ius), gfp_mask);
32 for (i = 0; i < queue_size; i++) {
35 iu->buf = kzalloc(size, gfp_mask);
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))
48 rtrs_iu_free(ius, dma_dev, i);
51 EXPORT_SYMBOL_GPL(rtrs_iu_alloc);
53 void rtrs_iu_free(struct rtrs_iu *ius, struct ib_device *ibdev, u32 queue_size)
61 for (i = 0; i < queue_size; i++) {
63 ib_dma_unmap_single(ibdev, iu->dma_addr, iu->size, iu->direction);
68 EXPORT_SYMBOL_GPL(rtrs_iu_free);
70 int rtrs_iu_post_recv(struct rtrs_con *con, struct rtrs_iu *iu)
72 struct rtrs_sess *sess = con->sess;
76 list.addr = iu->dma_addr;
77 list.length = iu->size;
78 list.lkey = sess->dev->ib_pd->local_dma_lkey;
80 if (list.length == 0) {
82 "Posting receive work request failed, sg list is empty\n");
85 wr = (struct ib_recv_wr) {
91 return ib_post_recv(con->qp, &wr, NULL);
93 EXPORT_SYMBOL_GPL(rtrs_iu_post_recv);
95 int rtrs_post_recv_empty(struct rtrs_con *con, struct ib_cqe *cqe)
99 wr = (struct ib_recv_wr) {
103 return ib_post_recv(con->qp, &wr, NULL);
105 EXPORT_SYMBOL_GPL(rtrs_post_recv_empty);
107 static int rtrs_post_send(struct ib_qp *qp, struct ib_send_wr *head,
108 struct ib_send_wr *wr)
111 struct ib_send_wr *tail = head;
120 return ib_post_send(qp, head, NULL);
123 int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size,
124 struct ib_send_wr *head)
126 struct rtrs_sess *sess = con->sess;
127 struct ib_send_wr wr;
130 if (WARN_ON(size == 0))
133 list.addr = iu->dma_addr;
135 list.lkey = sess->dev->ib_pd->local_dma_lkey;
137 wr = (struct ib_send_wr) {
141 .opcode = IB_WR_SEND,
142 .send_flags = IB_SEND_SIGNALED,
145 return rtrs_post_send(con->qp, head, &wr);
147 EXPORT_SYMBOL_GPL(rtrs_iu_post_send);
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)
155 struct ib_rdma_wr wr;
158 wr = (struct ib_rdma_wr) {
159 .wr.wr_cqe = &iu->cqe,
161 .wr.num_sge = num_sge,
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,
170 * If one of the sges has 0 size, the operation will fail with a
173 for (i = 0; i < num_sge; i++)
174 if (WARN_ON(sge[i].length == 0))
177 return rtrs_post_send(con->qp, head, &wr.wr);
179 EXPORT_SYMBOL_GPL(rtrs_iu_post_rdma_write_imm);
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)
185 struct ib_rdma_wr wr;
187 wr = (struct ib_rdma_wr) {
189 .wr.send_flags = flags,
190 .wr.opcode = IB_WR_RDMA_WRITE_WITH_IMM,
191 .wr.ex.imm_data = cpu_to_be32(imm_data),
194 return rtrs_post_send(con->qp, head, &wr.wr);
196 EXPORT_SYMBOL_GPL(rtrs_post_rdma_write_imm_empty);
198 static void qp_event_handler(struct ib_event *ev, void *ctx)
200 struct rtrs_con *con = ctx;
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);
209 rtrs_info(con->sess, "Unhandled QP event %s (%d) received\n",
210 ib_event_msg(ev->event), ev->event);
215 static int create_cq(struct rtrs_con *con, int cq_vector, u16 cq_size,
216 enum ib_poll_context poll_ctx)
218 struct rdma_cm_id *cm_id = con->cm_id;
221 cq = ib_alloc_cq(cm_id->device, con, cq_size,
222 cq_vector, poll_ctx);
224 rtrs_err(con->sess, "Creating completion queue failed, errno: %ld\n",
233 static int create_qp(struct rtrs_con *con, struct ib_pd *pd,
234 u32 max_send_wr, u32 max_recv_wr, u32 max_sge)
236 struct ib_qp_init_attr init_attr = {NULL};
237 struct rdma_cm_id *cm_id = con->cm_id;
240 init_attr.cap.max_send_wr = max_send_wr;
241 init_attr.cap.max_recv_wr = max_recv_wr;
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;
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;
252 ret = rdma_create_qp(cm_id, pd, &init_attr);
254 rtrs_err(con->sess, "Creating QP failed, err: %d\n", ret);
262 int rtrs_cq_qp_create(struct rtrs_sess *sess, struct rtrs_con *con,
263 u32 max_send_sge, int cq_vector, int cq_size,
264 u32 max_send_wr, u32 max_recv_wr,
265 enum ib_poll_context poll_ctx)
269 err = create_cq(con, cq_vector, cq_size, poll_ctx);
273 err = create_qp(con, sess->dev->ib_pd, max_send_wr, max_recv_wr,
284 EXPORT_SYMBOL_GPL(rtrs_cq_qp_create);
286 void rtrs_cq_qp_destroy(struct rtrs_con *con)
289 rdma_destroy_qp(con->cm_id);
297 EXPORT_SYMBOL_GPL(rtrs_cq_qp_destroy);
299 static void schedule_hb(struct rtrs_sess *sess)
301 queue_delayed_work(sess->hb_wq, &sess->hb_dwork,
302 msecs_to_jiffies(sess->hb_interval_ms));
305 void rtrs_send_hb_ack(struct rtrs_sess *sess)
307 struct rtrs_con *usr_con = sess->con[0];
311 imm = rtrs_to_imm(RTRS_HB_ACK_IMM, 0);
312 err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm,
315 sess->hb_err_handler(usr_con);
319 EXPORT_SYMBOL_GPL(rtrs_send_hb_ack);
321 static void hb_work(struct work_struct *work)
323 struct rtrs_con *usr_con;
324 struct rtrs_sess *sess;
328 sess = container_of(to_delayed_work(work), typeof(*sess), hb_dwork);
329 usr_con = sess->con[0];
331 if (sess->hb_missed_cnt > sess->hb_missed_max) {
332 sess->hb_err_handler(usr_con);
335 if (sess->hb_missed_cnt++) {
336 /* Reschedule work without sending hb */
340 imm = rtrs_to_imm(RTRS_HB_MSG_IMM, 0);
341 err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm,
344 sess->hb_err_handler(usr_con);
351 void rtrs_init_hb(struct rtrs_sess *sess, struct ib_cqe *cqe,
352 unsigned int interval_ms, unsigned int missed_max,
353 void (*err_handler)(struct rtrs_con *con),
354 struct workqueue_struct *wq)
357 sess->hb_interval_ms = interval_ms;
358 sess->hb_err_handler = err_handler;
360 sess->hb_missed_max = missed_max;
361 sess->hb_missed_cnt = 0;
362 INIT_DELAYED_WORK(&sess->hb_dwork, hb_work);
364 EXPORT_SYMBOL_GPL(rtrs_init_hb);
366 void rtrs_start_hb(struct rtrs_sess *sess)
370 EXPORT_SYMBOL_GPL(rtrs_start_hb);
372 void rtrs_stop_hb(struct rtrs_sess *sess)
374 cancel_delayed_work_sync(&sess->hb_dwork);
375 sess->hb_missed_cnt = 0;
376 sess->hb_missed_max = 0;
378 EXPORT_SYMBOL_GPL(rtrs_stop_hb);
380 static int rtrs_str_gid_to_sockaddr(const char *addr, size_t len,
381 short port, struct sockaddr_storage *dst)
383 struct sockaddr_ib *dst_ib = (struct sockaddr_ib *)dst;
387 * We can use some of the IPv6 functions since GID is a valid
388 * IPv6 address format
390 ret = in6_pton(addr, len, dst_ib->sib_addr.sib_raw, '\0', NULL);
394 dst_ib->sib_family = AF_IB;
396 * Use the same TCP server port number as the IB service ID
397 * on the IB port space range
399 dst_ib->sib_sid = cpu_to_be64(RDMA_IB_IP_PS_IB | port);
400 dst_ib->sib_sid_mask = cpu_to_be64(0xffffffffffffffffULL);
401 dst_ib->sib_pkey = cpu_to_be16(0xffff);
407 * rtrs_str_to_sockaddr() - Convert rtrs address string to sockaddr
408 * @addr: String representation of an addr (IPv4, IPv6 or IB GID):
410 * - "ip:fe80::200:5aee:feaa:20a2"
411 * - "gid:fe80::200:5aee:feaa:20a2"
412 * @len: String address length
413 * @port: Destination port
414 * @dst: Destination sockaddr structure
416 * Returns 0 if conversion successful. Non-zero on error.
418 static int rtrs_str_to_sockaddr(const char *addr, size_t len,
419 u16 port, struct sockaddr_storage *dst)
421 if (strncmp(addr, "gid:", 4) == 0) {
422 return rtrs_str_gid_to_sockaddr(addr + 4, len - 4, port, dst);
423 } else if (strncmp(addr, "ip:", 3) == 0) {
428 snprintf(port_str, sizeof(port_str), "%u", port);
429 cpy = kstrndup(addr + 3, len - 3, GFP_KERNEL);
430 err = cpy ? inet_pton_with_scope(&init_net, AF_UNSPEC,
431 cpy, port_str, dst) : -ENOMEM;
436 return -EPROTONOSUPPORT;
440 * sockaddr_to_str() - convert sockaddr to a string.
441 * @addr: the sockadddr structure to be converted.
442 * @buf: string containing socket addr.
443 * @len: string length.
445 * The return value is the number of characters written into buf not
446 * including the trailing '\0'. If len is == 0 the function returns 0..
448 int sockaddr_to_str(const struct sockaddr *addr, char *buf, size_t len)
451 switch (addr->sa_family) {
453 return scnprintf(buf, len, "gid:%pI6",
454 &((struct sockaddr_ib *)addr)->sib_addr.sib_raw);
456 return scnprintf(buf, len, "ip:%pI4",
457 &((struct sockaddr_in *)addr)->sin_addr);
459 return scnprintf(buf, len, "ip:%pI6c",
460 &((struct sockaddr_in6 *)addr)->sin6_addr);
462 return scnprintf(buf, len, "<invalid address family>");
464 EXPORT_SYMBOL(sockaddr_to_str);
467 * rtrs_addr_to_sockaddr() - convert path string "src,dst" or "src@dst"
469 * @str: string containing source and destination addr of a path
470 * separated by ',' or '@' I.e. "ip:1.1.1.1,ip:1.1.1.2" or
471 * "ip:1.1.1.1@ip:1.1.1.2". If str contains only one address it's
472 * considered to be destination.
473 * @len: string length
474 * @port: Destination port number.
475 * @addr: will be set to the source/destination address or to NULL
476 * if str doesn't contain any source address.
478 * Returns zero if conversion successful. Non-zero otherwise.
480 int rtrs_addr_to_sockaddr(const char *str, size_t len, u16 port,
481 struct rtrs_addr *addr)
485 d = strchr(str, ',');
487 d = strchr(str, '@');
489 if (rtrs_str_to_sockaddr(str, d - str, 0, addr->src))
498 return rtrs_str_to_sockaddr(str, len, port, addr->dst);
500 EXPORT_SYMBOL(rtrs_addr_to_sockaddr);
502 void rtrs_rdma_dev_pd_init(enum ib_pd_flags pd_flags,
503 struct rtrs_rdma_dev_pd *pool)
505 WARN_ON(pool->ops && (!pool->ops->alloc ^ !pool->ops->free));
506 INIT_LIST_HEAD(&pool->list);
507 mutex_init(&pool->mutex);
508 pool->pd_flags = pd_flags;
510 EXPORT_SYMBOL(rtrs_rdma_dev_pd_init);
512 void rtrs_rdma_dev_pd_deinit(struct rtrs_rdma_dev_pd *pool)
514 mutex_destroy(&pool->mutex);
515 WARN_ON(!list_empty(&pool->list));
517 EXPORT_SYMBOL(rtrs_rdma_dev_pd_deinit);
519 static void dev_free(struct kref *ref)
521 struct rtrs_rdma_dev_pd *pool;
522 struct rtrs_ib_dev *dev;
524 dev = container_of(ref, typeof(*dev), ref);
527 mutex_lock(&pool->mutex);
528 list_del(&dev->entry);
529 mutex_unlock(&pool->mutex);
531 if (pool->ops && pool->ops->deinit)
532 pool->ops->deinit(dev);
534 ib_dealloc_pd(dev->ib_pd);
536 if (pool->ops && pool->ops->free)
537 pool->ops->free(dev);
542 int rtrs_ib_dev_put(struct rtrs_ib_dev *dev)
544 return kref_put(&dev->ref, dev_free);
546 EXPORT_SYMBOL(rtrs_ib_dev_put);
548 static int rtrs_ib_dev_get(struct rtrs_ib_dev *dev)
550 return kref_get_unless_zero(&dev->ref);
554 rtrs_ib_dev_find_or_add(struct ib_device *ib_dev,
555 struct rtrs_rdma_dev_pd *pool)
557 struct rtrs_ib_dev *dev;
559 mutex_lock(&pool->mutex);
560 list_for_each_entry(dev, &pool->list, entry) {
561 if (dev->ib_dev->node_guid == ib_dev->node_guid &&
562 rtrs_ib_dev_get(dev))
565 mutex_unlock(&pool->mutex);
566 if (pool->ops && pool->ops->alloc)
567 dev = pool->ops->alloc();
569 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
570 if (IS_ERR_OR_NULL(dev))
573 kref_init(&dev->ref);
575 dev->ib_dev = ib_dev;
576 dev->ib_pd = ib_alloc_pd(ib_dev, pool->pd_flags);
577 if (IS_ERR(dev->ib_pd))
580 if (pool->ops && pool->ops->init && pool->ops->init(dev))
583 mutex_lock(&pool->mutex);
584 list_add(&dev->entry, &pool->list);
586 mutex_unlock(&pool->mutex);
590 ib_dealloc_pd(dev->ib_pd);
592 if (pool->ops && pool->ops->free)
593 pool->ops->free(dev);
599 EXPORT_SYMBOL(rtrs_ib_dev_find_or_add);