1
2
3
4
5
6
7
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
18MODULE_DESCRIPTION("RDMA Transport Core");
19MODULE_LICENSE("GPL");
20
21struct 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;
47err:
48 rtrs_iu_free(ius, dma_dev, i);
49 return NULL;
50}
51EXPORT_SYMBOL_GPL(rtrs_iu_alloc);
52
53void 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}
68EXPORT_SYMBOL_GPL(rtrs_iu_free);
69
70int 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}
93EXPORT_SYMBOL_GPL(rtrs_iu_post_recv);
94
95int 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}
105EXPORT_SYMBOL_GPL(rtrs_post_recv_empty);
106
107static 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
126int 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_sess *sess = con->sess;
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 = sess->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}
150EXPORT_SYMBOL_GPL(rtrs_iu_post_send);
151
152int 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
175
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}
183EXPORT_SYMBOL_GPL(rtrs_iu_post_rdma_write_imm);
184
185static 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_sess *sess = con->sess;
192 enum ib_send_flags sflags;
193
194 atomic_dec_if_positive(&con->sq_wr_avail);
195 sflags = (atomic_inc_return(&con->wr_cnt) % sess->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
208static 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->sess, "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->sess, "Unhandled QP event %s (%d) received\n",
220 ib_event_msg(ev->event), ev->event);
221 break;
222 }
223}
224
225static int create_cq(struct rtrs_con *con, int cq_vector, int nr_cqe,
226 enum ib_poll_context poll_ctx)
227{
228 struct rdma_cm_id *cm_id = con->cm_id;
229 struct ib_cq *cq;
230
231 cq = ib_cq_pool_get(cm_id->device, nr_cqe, cq_vector, poll_ctx);
232 if (IS_ERR(cq)) {
233 rtrs_err(con->sess, "Creating completion queue failed, errno: %ld\n",
234 PTR_ERR(cq));
235 return PTR_ERR(cq);
236 }
237 con->cq = cq;
238 con->nr_cqe = nr_cqe;
239
240 return 0;
241}
242
243static int create_qp(struct rtrs_con *con, struct ib_pd *pd,
244 u32 max_send_wr, u32 max_recv_wr, u32 max_sge)
245{
246 struct ib_qp_init_attr init_attr = {NULL};
247 struct rdma_cm_id *cm_id = con->cm_id;
248 int ret;
249
250 init_attr.cap.max_send_wr = max_send_wr;
251 init_attr.cap.max_recv_wr = max_recv_wr;
252 init_attr.cap.max_recv_sge = 1;
253 init_attr.event_handler = qp_event_handler;
254 init_attr.qp_context = con;
255 init_attr.cap.max_send_sge = max_sge;
256
257 init_attr.qp_type = IB_QPT_RC;
258 init_attr.send_cq = con->cq;
259 init_attr.recv_cq = con->cq;
260 init_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
261
262 ret = rdma_create_qp(cm_id, pd, &init_attr);
263 if (ret) {
264 rtrs_err(con->sess, "Creating QP failed, err: %d\n", ret);
265 return ret;
266 }
267 con->qp = cm_id->qp;
268
269 return ret;
270}
271
272int rtrs_cq_qp_create(struct rtrs_sess *sess, struct rtrs_con *con,
273 u32 max_send_sge, int cq_vector, int nr_cqe,
274 u32 max_send_wr, u32 max_recv_wr,
275 enum ib_poll_context poll_ctx)
276{
277 int err;
278
279 err = create_cq(con, cq_vector, nr_cqe, poll_ctx);
280 if (err)
281 return err;
282
283 err = create_qp(con, sess->dev->ib_pd, max_send_wr, max_recv_wr,
284 max_send_sge);
285 if (err) {
286 ib_cq_pool_put(con->cq, con->nr_cqe);
287 con->cq = NULL;
288 return err;
289 }
290 con->sess = sess;
291
292 return 0;
293}
294EXPORT_SYMBOL_GPL(rtrs_cq_qp_create);
295
296void rtrs_cq_qp_destroy(struct rtrs_con *con)
297{
298 if (con->qp) {
299 rdma_destroy_qp(con->cm_id);
300 con->qp = NULL;
301 }
302 if (con->cq) {
303 ib_cq_pool_put(con->cq, con->nr_cqe);
304 con->cq = NULL;
305 }
306}
307EXPORT_SYMBOL_GPL(rtrs_cq_qp_destroy);
308
309static void schedule_hb(struct rtrs_sess *sess)
310{
311 queue_delayed_work(sess->hb_wq, &sess->hb_dwork,
312 msecs_to_jiffies(sess->hb_interval_ms));
313}
314
315void rtrs_send_hb_ack(struct rtrs_sess *sess)
316{
317 struct rtrs_con *usr_con = sess->con[0];
318 u32 imm;
319 int err;
320
321 imm = rtrs_to_imm(RTRS_HB_ACK_IMM, 0);
322 err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm,
323 NULL);
324 if (err) {
325 rtrs_err(sess, "send HB ACK failed, errno: %d\n", err);
326 sess->hb_err_handler(usr_con);
327 return;
328 }
329}
330EXPORT_SYMBOL_GPL(rtrs_send_hb_ack);
331
332static void hb_work(struct work_struct *work)
333{
334 struct rtrs_con *usr_con;
335 struct rtrs_sess *sess;
336 u32 imm;
337 int err;
338
339 sess = container_of(to_delayed_work(work), typeof(*sess), hb_dwork);
340 usr_con = sess->con[0];
341
342 if (sess->hb_missed_cnt > sess->hb_missed_max) {
343 rtrs_err(sess, "HB missed max reached.\n");
344 sess->hb_err_handler(usr_con);
345 return;
346 }
347 if (sess->hb_missed_cnt++) {
348
349 schedule_hb(sess);
350 return;
351 }
352
353 sess->hb_last_sent = ktime_get();
354
355 imm = rtrs_to_imm(RTRS_HB_MSG_IMM, 0);
356 err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm,
357 NULL);
358 if (err) {
359 rtrs_err(sess, "HB send failed, errno: %d\n", err);
360 sess->hb_err_handler(usr_con);
361 return;
362 }
363
364 schedule_hb(sess);
365}
366
367void rtrs_init_hb(struct rtrs_sess *sess, struct ib_cqe *cqe,
368 unsigned int interval_ms, unsigned int missed_max,
369 void (*err_handler)(struct rtrs_con *con),
370 struct workqueue_struct *wq)
371{
372 sess->hb_cqe = cqe;
373 sess->hb_interval_ms = interval_ms;
374 sess->hb_err_handler = err_handler;
375 sess->hb_wq = wq;
376 sess->hb_missed_max = missed_max;
377 sess->hb_missed_cnt = 0;
378 INIT_DELAYED_WORK(&sess->hb_dwork, hb_work);
379}
380EXPORT_SYMBOL_GPL(rtrs_init_hb);
381
382void rtrs_start_hb(struct rtrs_sess *sess)
383{
384 schedule_hb(sess);
385}
386EXPORT_SYMBOL_GPL(rtrs_start_hb);
387
388void rtrs_stop_hb(struct rtrs_sess *sess)
389{
390 cancel_delayed_work_sync(&sess->hb_dwork);
391 sess->hb_missed_cnt = 0;
392}
393EXPORT_SYMBOL_GPL(rtrs_stop_hb);
394
395static int rtrs_str_gid_to_sockaddr(const char *addr, size_t len,
396 short port, struct sockaddr_storage *dst)
397{
398 struct sockaddr_ib *dst_ib = (struct sockaddr_ib *)dst;
399 int ret;
400
401
402
403
404
405 ret = in6_pton(addr, len, dst_ib->sib_addr.sib_raw, '\0', NULL);
406 if (ret == 0)
407 return -EINVAL;
408
409 dst_ib->sib_family = AF_IB;
410
411
412
413
414 dst_ib->sib_sid = cpu_to_be64(RDMA_IB_IP_PS_IB | port);
415 dst_ib->sib_sid_mask = cpu_to_be64(0xffffffffffffffffULL);
416 dst_ib->sib_pkey = cpu_to_be16(0xffff);
417
418 return 0;
419}
420
421
422
423
424
425
426
427
428
429
430
431
432
433static int rtrs_str_to_sockaddr(const char *addr, size_t len,
434 u16 port, struct sockaddr_storage *dst)
435{
436 if (strncmp(addr, "gid:", 4) == 0) {
437 return rtrs_str_gid_to_sockaddr(addr + 4, len - 4, port, dst);
438 } else if (strncmp(addr, "ip:", 3) == 0) {
439 char port_str[8];
440 char *cpy;
441 int err;
442
443 snprintf(port_str, sizeof(port_str), "%u", port);
444 cpy = kstrndup(addr + 3, len - 3, GFP_KERNEL);
445 err = cpy ? inet_pton_with_scope(&init_net, AF_UNSPEC,
446 cpy, port_str, dst) : -ENOMEM;
447 kfree(cpy);
448
449 return err;
450 }
451 return -EPROTONOSUPPORT;
452}
453
454
455
456
457
458
459
460
461
462
463int sockaddr_to_str(const struct sockaddr *addr, char *buf, size_t len)
464{
465
466 switch (addr->sa_family) {
467 case AF_IB:
468 return scnprintf(buf, len, "gid:%pI6",
469 &((struct sockaddr_ib *)addr)->sib_addr.sib_raw);
470 case AF_INET:
471 return scnprintf(buf, len, "ip:%pI4",
472 &((struct sockaddr_in *)addr)->sin_addr);
473 case AF_INET6:
474 return scnprintf(buf, len, "ip:%pI6c",
475 &((struct sockaddr_in6 *)addr)->sin6_addr);
476 }
477 return scnprintf(buf, len, "<invalid address family>");
478}
479EXPORT_SYMBOL(sockaddr_to_str);
480
481
482
483
484
485
486
487
488
489
490
491
492int rtrs_addr_to_str(const struct rtrs_addr *addr, char *buf, size_t len)
493{
494 int cnt;
495
496 cnt = sockaddr_to_str((struct sockaddr *)addr->src,
497 buf, len);
498 cnt += scnprintf(buf + cnt, len - cnt, "@");
499 sockaddr_to_str((struct sockaddr *)addr->dst,
500 buf + cnt, len - cnt);
501 return cnt;
502}
503EXPORT_SYMBOL(rtrs_addr_to_str);
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519int rtrs_addr_to_sockaddr(const char *str, size_t len, u16 port,
520 struct rtrs_addr *addr)
521{
522 const char *d;
523
524 d = strchr(str, ',');
525 if (!d)
526 d = strchr(str, '@');
527 if (d) {
528 if (rtrs_str_to_sockaddr(str, d - str, 0, addr->src))
529 return -EINVAL;
530 d += 1;
531 len -= d - str;
532 str = d;
533
534 } else {
535 addr->src = NULL;
536 }
537 return rtrs_str_to_sockaddr(str, len, port, addr->dst);
538}
539EXPORT_SYMBOL(rtrs_addr_to_sockaddr);
540
541void rtrs_rdma_dev_pd_init(enum ib_pd_flags pd_flags,
542 struct rtrs_rdma_dev_pd *pool)
543{
544 WARN_ON(pool->ops && (!pool->ops->alloc ^ !pool->ops->free));
545 INIT_LIST_HEAD(&pool->list);
546 mutex_init(&pool->mutex);
547 pool->pd_flags = pd_flags;
548}
549EXPORT_SYMBOL(rtrs_rdma_dev_pd_init);
550
551void rtrs_rdma_dev_pd_deinit(struct rtrs_rdma_dev_pd *pool)
552{
553 mutex_destroy(&pool->mutex);
554 WARN_ON(!list_empty(&pool->list));
555}
556EXPORT_SYMBOL(rtrs_rdma_dev_pd_deinit);
557
558static void dev_free(struct kref *ref)
559{
560 struct rtrs_rdma_dev_pd *pool;
561 struct rtrs_ib_dev *dev;
562
563 dev = container_of(ref, typeof(*dev), ref);
564 pool = dev->pool;
565
566 mutex_lock(&pool->mutex);
567 list_del(&dev->entry);
568 mutex_unlock(&pool->mutex);
569
570 if (pool->ops && pool->ops->deinit)
571 pool->ops->deinit(dev);
572
573 ib_dealloc_pd(dev->ib_pd);
574
575 if (pool->ops && pool->ops->free)
576 pool->ops->free(dev);
577 else
578 kfree(dev);
579}
580
581int rtrs_ib_dev_put(struct rtrs_ib_dev *dev)
582{
583 return kref_put(&dev->ref, dev_free);
584}
585EXPORT_SYMBOL(rtrs_ib_dev_put);
586
587static int rtrs_ib_dev_get(struct rtrs_ib_dev *dev)
588{
589 return kref_get_unless_zero(&dev->ref);
590}
591
592struct rtrs_ib_dev *
593rtrs_ib_dev_find_or_add(struct ib_device *ib_dev,
594 struct rtrs_rdma_dev_pd *pool)
595{
596 struct rtrs_ib_dev *dev;
597
598 mutex_lock(&pool->mutex);
599 list_for_each_entry(dev, &pool->list, entry) {
600 if (dev->ib_dev->node_guid == ib_dev->node_guid &&
601 rtrs_ib_dev_get(dev))
602 goto out_unlock;
603 }
604 mutex_unlock(&pool->mutex);
605 if (pool->ops && pool->ops->alloc)
606 dev = pool->ops->alloc();
607 else
608 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
609 if (IS_ERR_OR_NULL(dev))
610 goto out_err;
611
612 kref_init(&dev->ref);
613 dev->pool = pool;
614 dev->ib_dev = ib_dev;
615 dev->ib_pd = ib_alloc_pd(ib_dev, pool->pd_flags);
616 if (IS_ERR(dev->ib_pd))
617 goto out_free_dev;
618
619 if (pool->ops && pool->ops->init && pool->ops->init(dev))
620 goto out_free_pd;
621
622 mutex_lock(&pool->mutex);
623 list_add(&dev->entry, &pool->list);
624out_unlock:
625 mutex_unlock(&pool->mutex);
626 return dev;
627
628out_free_pd:
629 ib_dealloc_pd(dev->ib_pd);
630out_free_dev:
631 if (pool->ops && pool->ops->free)
632 pool->ops->free(dev);
633 else
634 kfree(dev);
635out_err:
636 return NULL;
637}
638EXPORT_SYMBOL(rtrs_ib_dev_find_or_add);
639