mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
599 lines
14 KiB
599 lines
14 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* RDMA Transport Layer |
|
* |
|
* Copyright (c) 2014 - 2018 ProfitBricks GmbH. All rights reserved. |
|
* Copyright (c) 2018 - 2019 1&1 IONOS Cloud GmbH. All rights reserved. |
|
* Copyright (c) 2019 - 2020 1&1 IONOS SE. All rights reserved. |
|
*/ |
|
#undef pr_fmt |
|
#define pr_fmt(fmt) KBUILD_MODNAME " L" __stringify(__LINE__) ": " fmt |
|
|
|
#include <linux/module.h> |
|
#include <linux/inet.h> |
|
|
|
#include "rtrs-pri.h" |
|
#include "rtrs-log.h" |
|
|
|
MODULE_DESCRIPTION("RDMA Transport Core"); |
|
MODULE_LICENSE("GPL"); |
|
|
|
struct rtrs_iu *rtrs_iu_alloc(u32 queue_size, size_t size, gfp_t gfp_mask, |
|
struct ib_device *dma_dev, |
|
enum dma_data_direction dir, |
|
void (*done)(struct ib_cq *cq, struct ib_wc *wc)) |
|
{ |
|
struct rtrs_iu *ius, *iu; |
|
int i; |
|
|
|
ius = kcalloc(queue_size, sizeof(*ius), gfp_mask); |
|
if (!ius) |
|
return NULL; |
|
for (i = 0; i < queue_size; i++) { |
|
iu = &ius[i]; |
|
iu->direction = dir; |
|
iu->buf = kzalloc(size, gfp_mask); |
|
if (!iu->buf) |
|
goto err; |
|
|
|
iu->dma_addr = ib_dma_map_single(dma_dev, iu->buf, size, dir); |
|
if (ib_dma_mapping_error(dma_dev, iu->dma_addr)) |
|
goto err; |
|
|
|
iu->cqe.done = done; |
|
iu->size = size; |
|
} |
|
return ius; |
|
err: |
|
rtrs_iu_free(ius, dma_dev, i); |
|
return NULL; |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_iu_alloc); |
|
|
|
void rtrs_iu_free(struct rtrs_iu *ius, struct ib_device *ibdev, u32 queue_size) |
|
{ |
|
struct rtrs_iu *iu; |
|
int i; |
|
|
|
if (!ius) |
|
return; |
|
|
|
for (i = 0; i < queue_size; i++) { |
|
iu = &ius[i]; |
|
ib_dma_unmap_single(ibdev, iu->dma_addr, iu->size, iu->direction); |
|
kfree(iu->buf); |
|
} |
|
kfree(ius); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_iu_free); |
|
|
|
int rtrs_iu_post_recv(struct rtrs_con *con, struct rtrs_iu *iu) |
|
{ |
|
struct rtrs_sess *sess = con->sess; |
|
struct ib_recv_wr wr; |
|
struct ib_sge list; |
|
|
|
list.addr = iu->dma_addr; |
|
list.length = iu->size; |
|
list.lkey = sess->dev->ib_pd->local_dma_lkey; |
|
|
|
if (list.length == 0) { |
|
rtrs_wrn(con->sess, |
|
"Posting receive work request failed, sg list is empty\n"); |
|
return -EINVAL; |
|
} |
|
wr = (struct ib_recv_wr) { |
|
.wr_cqe = &iu->cqe, |
|
.sg_list = &list, |
|
.num_sge = 1, |
|
}; |
|
|
|
return ib_post_recv(con->qp, &wr, NULL); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_iu_post_recv); |
|
|
|
int rtrs_post_recv_empty(struct rtrs_con *con, struct ib_cqe *cqe) |
|
{ |
|
struct ib_recv_wr wr; |
|
|
|
wr = (struct ib_recv_wr) { |
|
.wr_cqe = cqe, |
|
}; |
|
|
|
return ib_post_recv(con->qp, &wr, NULL); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_post_recv_empty); |
|
|
|
static int rtrs_post_send(struct ib_qp *qp, struct ib_send_wr *head, |
|
struct ib_send_wr *wr) |
|
{ |
|
if (head) { |
|
struct ib_send_wr *tail = head; |
|
|
|
while (tail->next) |
|
tail = tail->next; |
|
tail->next = wr; |
|
} else { |
|
head = wr; |
|
} |
|
|
|
return ib_post_send(qp, head, NULL); |
|
} |
|
|
|
int rtrs_iu_post_send(struct rtrs_con *con, struct rtrs_iu *iu, size_t size, |
|
struct ib_send_wr *head) |
|
{ |
|
struct rtrs_sess *sess = con->sess; |
|
struct ib_send_wr wr; |
|
struct ib_sge list; |
|
|
|
if (WARN_ON(size == 0)) |
|
return -EINVAL; |
|
|
|
list.addr = iu->dma_addr; |
|
list.length = size; |
|
list.lkey = sess->dev->ib_pd->local_dma_lkey; |
|
|
|
wr = (struct ib_send_wr) { |
|
.wr_cqe = &iu->cqe, |
|
.sg_list = &list, |
|
.num_sge = 1, |
|
.opcode = IB_WR_SEND, |
|
.send_flags = IB_SEND_SIGNALED, |
|
}; |
|
|
|
return rtrs_post_send(con->qp, head, &wr); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_iu_post_send); |
|
|
|
int rtrs_iu_post_rdma_write_imm(struct rtrs_con *con, struct rtrs_iu *iu, |
|
struct ib_sge *sge, unsigned int num_sge, |
|
u32 rkey, u64 rdma_addr, u32 imm_data, |
|
enum ib_send_flags flags, |
|
struct ib_send_wr *head) |
|
{ |
|
struct ib_rdma_wr wr; |
|
int i; |
|
|
|
wr = (struct ib_rdma_wr) { |
|
.wr.wr_cqe = &iu->cqe, |
|
.wr.sg_list = sge, |
|
.wr.num_sge = num_sge, |
|
.rkey = rkey, |
|
.remote_addr = rdma_addr, |
|
.wr.opcode = IB_WR_RDMA_WRITE_WITH_IMM, |
|
.wr.ex.imm_data = cpu_to_be32(imm_data), |
|
.wr.send_flags = flags, |
|
}; |
|
|
|
/* |
|
* If one of the sges has 0 size, the operation will fail with a |
|
* length error |
|
*/ |
|
for (i = 0; i < num_sge; i++) |
|
if (WARN_ON(sge[i].length == 0)) |
|
return -EINVAL; |
|
|
|
return rtrs_post_send(con->qp, head, &wr.wr); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_iu_post_rdma_write_imm); |
|
|
|
int rtrs_post_rdma_write_imm_empty(struct rtrs_con *con, struct ib_cqe *cqe, |
|
u32 imm_data, enum ib_send_flags flags, |
|
struct ib_send_wr *head) |
|
{ |
|
struct ib_rdma_wr wr; |
|
|
|
wr = (struct ib_rdma_wr) { |
|
.wr.wr_cqe = cqe, |
|
.wr.send_flags = flags, |
|
.wr.opcode = IB_WR_RDMA_WRITE_WITH_IMM, |
|
.wr.ex.imm_data = cpu_to_be32(imm_data), |
|
}; |
|
|
|
return rtrs_post_send(con->qp, head, &wr.wr); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_post_rdma_write_imm_empty); |
|
|
|
static void qp_event_handler(struct ib_event *ev, void *ctx) |
|
{ |
|
struct rtrs_con *con = ctx; |
|
|
|
switch (ev->event) { |
|
case IB_EVENT_COMM_EST: |
|
rtrs_info(con->sess, "QP event %s (%d) received\n", |
|
ib_event_msg(ev->event), ev->event); |
|
rdma_notify(con->cm_id, IB_EVENT_COMM_EST); |
|
break; |
|
default: |
|
rtrs_info(con->sess, "Unhandled QP event %s (%d) received\n", |
|
ib_event_msg(ev->event), ev->event); |
|
break; |
|
} |
|
} |
|
|
|
static int create_cq(struct rtrs_con *con, int cq_vector, u16 cq_size, |
|
enum ib_poll_context poll_ctx) |
|
{ |
|
struct rdma_cm_id *cm_id = con->cm_id; |
|
struct ib_cq *cq; |
|
|
|
cq = ib_alloc_cq(cm_id->device, con, cq_size, |
|
cq_vector, poll_ctx); |
|
if (IS_ERR(cq)) { |
|
rtrs_err(con->sess, "Creating completion queue failed, errno: %ld\n", |
|
PTR_ERR(cq)); |
|
return PTR_ERR(cq); |
|
} |
|
con->cq = cq; |
|
|
|
return 0; |
|
} |
|
|
|
static int create_qp(struct rtrs_con *con, struct ib_pd *pd, |
|
u32 max_send_wr, u32 max_recv_wr, u32 max_sge) |
|
{ |
|
struct ib_qp_init_attr init_attr = {NULL}; |
|
struct rdma_cm_id *cm_id = con->cm_id; |
|
int ret; |
|
|
|
init_attr.cap.max_send_wr = max_send_wr; |
|
init_attr.cap.max_recv_wr = max_recv_wr; |
|
init_attr.cap.max_recv_sge = 1; |
|
init_attr.event_handler = qp_event_handler; |
|
init_attr.qp_context = con; |
|
init_attr.cap.max_send_sge = max_sge; |
|
|
|
init_attr.qp_type = IB_QPT_RC; |
|
init_attr.send_cq = con->cq; |
|
init_attr.recv_cq = con->cq; |
|
init_attr.sq_sig_type = IB_SIGNAL_REQ_WR; |
|
|
|
ret = rdma_create_qp(cm_id, pd, &init_attr); |
|
if (ret) { |
|
rtrs_err(con->sess, "Creating QP failed, err: %d\n", ret); |
|
return ret; |
|
} |
|
con->qp = cm_id->qp; |
|
|
|
return ret; |
|
} |
|
|
|
int rtrs_cq_qp_create(struct rtrs_sess *sess, struct rtrs_con *con, |
|
u32 max_send_sge, int cq_vector, int cq_size, |
|
u32 max_send_wr, u32 max_recv_wr, |
|
enum ib_poll_context poll_ctx) |
|
{ |
|
int err; |
|
|
|
err = create_cq(con, cq_vector, cq_size, poll_ctx); |
|
if (err) |
|
return err; |
|
|
|
err = create_qp(con, sess->dev->ib_pd, max_send_wr, max_recv_wr, |
|
max_send_sge); |
|
if (err) { |
|
ib_free_cq(con->cq); |
|
con->cq = NULL; |
|
return err; |
|
} |
|
con->sess = sess; |
|
|
|
return 0; |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_cq_qp_create); |
|
|
|
void rtrs_cq_qp_destroy(struct rtrs_con *con) |
|
{ |
|
if (con->qp) { |
|
rdma_destroy_qp(con->cm_id); |
|
con->qp = NULL; |
|
} |
|
if (con->cq) { |
|
ib_free_cq(con->cq); |
|
con->cq = NULL; |
|
} |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_cq_qp_destroy); |
|
|
|
static void schedule_hb(struct rtrs_sess *sess) |
|
{ |
|
queue_delayed_work(sess->hb_wq, &sess->hb_dwork, |
|
msecs_to_jiffies(sess->hb_interval_ms)); |
|
} |
|
|
|
void rtrs_send_hb_ack(struct rtrs_sess *sess) |
|
{ |
|
struct rtrs_con *usr_con = sess->con[0]; |
|
u32 imm; |
|
int err; |
|
|
|
imm = rtrs_to_imm(RTRS_HB_ACK_IMM, 0); |
|
err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm, |
|
0, NULL); |
|
if (err) { |
|
sess->hb_err_handler(usr_con); |
|
return; |
|
} |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_send_hb_ack); |
|
|
|
static void hb_work(struct work_struct *work) |
|
{ |
|
struct rtrs_con *usr_con; |
|
struct rtrs_sess *sess; |
|
u32 imm; |
|
int err; |
|
|
|
sess = container_of(to_delayed_work(work), typeof(*sess), hb_dwork); |
|
usr_con = sess->con[0]; |
|
|
|
if (sess->hb_missed_cnt > sess->hb_missed_max) { |
|
sess->hb_err_handler(usr_con); |
|
return; |
|
} |
|
if (sess->hb_missed_cnt++) { |
|
/* Reschedule work without sending hb */ |
|
schedule_hb(sess); |
|
return; |
|
} |
|
imm = rtrs_to_imm(RTRS_HB_MSG_IMM, 0); |
|
err = rtrs_post_rdma_write_imm_empty(usr_con, sess->hb_cqe, imm, |
|
0, NULL); |
|
if (err) { |
|
sess->hb_err_handler(usr_con); |
|
return; |
|
} |
|
|
|
schedule_hb(sess); |
|
} |
|
|
|
void rtrs_init_hb(struct rtrs_sess *sess, struct ib_cqe *cqe, |
|
unsigned int interval_ms, unsigned int missed_max, |
|
void (*err_handler)(struct rtrs_con *con), |
|
struct workqueue_struct *wq) |
|
{ |
|
sess->hb_cqe = cqe; |
|
sess->hb_interval_ms = interval_ms; |
|
sess->hb_err_handler = err_handler; |
|
sess->hb_wq = wq; |
|
sess->hb_missed_max = missed_max; |
|
sess->hb_missed_cnt = 0; |
|
INIT_DELAYED_WORK(&sess->hb_dwork, hb_work); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_init_hb); |
|
|
|
void rtrs_start_hb(struct rtrs_sess *sess) |
|
{ |
|
schedule_hb(sess); |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_start_hb); |
|
|
|
void rtrs_stop_hb(struct rtrs_sess *sess) |
|
{ |
|
cancel_delayed_work_sync(&sess->hb_dwork); |
|
sess->hb_missed_cnt = 0; |
|
sess->hb_missed_max = 0; |
|
} |
|
EXPORT_SYMBOL_GPL(rtrs_stop_hb); |
|
|
|
static int rtrs_str_gid_to_sockaddr(const char *addr, size_t len, |
|
short port, struct sockaddr_storage *dst) |
|
{ |
|
struct sockaddr_ib *dst_ib = (struct sockaddr_ib *)dst; |
|
int ret; |
|
|
|
/* |
|
* We can use some of the IPv6 functions since GID is a valid |
|
* IPv6 address format |
|
*/ |
|
ret = in6_pton(addr, len, dst_ib->sib_addr.sib_raw, '\0', NULL); |
|
if (ret == 0) |
|
return -EINVAL; |
|
|
|
dst_ib->sib_family = AF_IB; |
|
/* |
|
* Use the same TCP server port number as the IB service ID |
|
* on the IB port space range |
|
*/ |
|
dst_ib->sib_sid = cpu_to_be64(RDMA_IB_IP_PS_IB | port); |
|
dst_ib->sib_sid_mask = cpu_to_be64(0xffffffffffffffffULL); |
|
dst_ib->sib_pkey = cpu_to_be16(0xffff); |
|
|
|
return 0; |
|
} |
|
|
|
/** |
|
* rtrs_str_to_sockaddr() - Convert rtrs address string to sockaddr |
|
* @addr: String representation of an addr (IPv4, IPv6 or IB GID): |
|
* - "ip:192.168.1.1" |
|
* - "ip:fe80::200:5aee:feaa:20a2" |
|
* - "gid:fe80::200:5aee:feaa:20a2" |
|
* @len: String address length |
|
* @port: Destination port |
|
* @dst: Destination sockaddr structure |
|
* |
|
* Returns 0 if conversion successful. Non-zero on error. |
|
*/ |
|
static int rtrs_str_to_sockaddr(const char *addr, size_t len, |
|
u16 port, struct sockaddr_storage *dst) |
|
{ |
|
if (strncmp(addr, "gid:", 4) == 0) { |
|
return rtrs_str_gid_to_sockaddr(addr + 4, len - 4, port, dst); |
|
} else if (strncmp(addr, "ip:", 3) == 0) { |
|
char port_str[8]; |
|
char *cpy; |
|
int err; |
|
|
|
snprintf(port_str, sizeof(port_str), "%u", port); |
|
cpy = kstrndup(addr + 3, len - 3, GFP_KERNEL); |
|
err = cpy ? inet_pton_with_scope(&init_net, AF_UNSPEC, |
|
cpy, port_str, dst) : -ENOMEM; |
|
kfree(cpy); |
|
|
|
return err; |
|
} |
|
return -EPROTONOSUPPORT; |
|
} |
|
|
|
/** |
|
* sockaddr_to_str() - convert sockaddr to a string. |
|
* @addr: the sockadddr structure to be converted. |
|
* @buf: string containing socket addr. |
|
* @len: string length. |
|
* |
|
* The return value is the number of characters written into buf not |
|
* including the trailing '\0'. If len is == 0 the function returns 0.. |
|
*/ |
|
int sockaddr_to_str(const struct sockaddr *addr, char *buf, size_t len) |
|
{ |
|
|
|
switch (addr->sa_family) { |
|
case AF_IB: |
|
return scnprintf(buf, len, "gid:%pI6", |
|
&((struct sockaddr_ib *)addr)->sib_addr.sib_raw); |
|
case AF_INET: |
|
return scnprintf(buf, len, "ip:%pI4", |
|
&((struct sockaddr_in *)addr)->sin_addr); |
|
case AF_INET6: |
|
return scnprintf(buf, len, "ip:%pI6c", |
|
&((struct sockaddr_in6 *)addr)->sin6_addr); |
|
} |
|
return scnprintf(buf, len, "<invalid address family>"); |
|
} |
|
EXPORT_SYMBOL(sockaddr_to_str); |
|
|
|
/** |
|
* rtrs_addr_to_sockaddr() - convert path string "src,dst" or "src@dst" |
|
* to sockaddreses |
|
* @str: string containing source and destination addr of a path |
|
* separated by ',' or '@' I.e. "ip:1.1.1.1,ip:1.1.1.2" or |
|
* "ip:1.1.1.1@ip:1.1.1.2". If str contains only one address it's |
|
* considered to be destination. |
|
* @len: string length |
|
* @port: Destination port number. |
|
* @addr: will be set to the source/destination address or to NULL |
|
* if str doesn't contain any source address. |
|
* |
|
* Returns zero if conversion successful. Non-zero otherwise. |
|
*/ |
|
int rtrs_addr_to_sockaddr(const char *str, size_t len, u16 port, |
|
struct rtrs_addr *addr) |
|
{ |
|
const char *d; |
|
|
|
d = strchr(str, ','); |
|
if (!d) |
|
d = strchr(str, '@'); |
|
if (d) { |
|
if (rtrs_str_to_sockaddr(str, d - str, 0, addr->src)) |
|
return -EINVAL; |
|
d += 1; |
|
len -= d - str; |
|
str = d; |
|
|
|
} else { |
|
addr->src = NULL; |
|
} |
|
return rtrs_str_to_sockaddr(str, len, port, addr->dst); |
|
} |
|
EXPORT_SYMBOL(rtrs_addr_to_sockaddr); |
|
|
|
void rtrs_rdma_dev_pd_init(enum ib_pd_flags pd_flags, |
|
struct rtrs_rdma_dev_pd *pool) |
|
{ |
|
WARN_ON(pool->ops && (!pool->ops->alloc ^ !pool->ops->free)); |
|
INIT_LIST_HEAD(&pool->list); |
|
mutex_init(&pool->mutex); |
|
pool->pd_flags = pd_flags; |
|
} |
|
EXPORT_SYMBOL(rtrs_rdma_dev_pd_init); |
|
|
|
void rtrs_rdma_dev_pd_deinit(struct rtrs_rdma_dev_pd *pool) |
|
{ |
|
mutex_destroy(&pool->mutex); |
|
WARN_ON(!list_empty(&pool->list)); |
|
} |
|
EXPORT_SYMBOL(rtrs_rdma_dev_pd_deinit); |
|
|
|
static void dev_free(struct kref *ref) |
|
{ |
|
struct rtrs_rdma_dev_pd *pool; |
|
struct rtrs_ib_dev *dev; |
|
|
|
dev = container_of(ref, typeof(*dev), ref); |
|
pool = dev->pool; |
|
|
|
mutex_lock(&pool->mutex); |
|
list_del(&dev->entry); |
|
mutex_unlock(&pool->mutex); |
|
|
|
if (pool->ops && pool->ops->deinit) |
|
pool->ops->deinit(dev); |
|
|
|
ib_dealloc_pd(dev->ib_pd); |
|
|
|
if (pool->ops && pool->ops->free) |
|
pool->ops->free(dev); |
|
else |
|
kfree(dev); |
|
} |
|
|
|
int rtrs_ib_dev_put(struct rtrs_ib_dev *dev) |
|
{ |
|
return kref_put(&dev->ref, dev_free); |
|
} |
|
EXPORT_SYMBOL(rtrs_ib_dev_put); |
|
|
|
static int rtrs_ib_dev_get(struct rtrs_ib_dev *dev) |
|
{ |
|
return kref_get_unless_zero(&dev->ref); |
|
} |
|
|
|
struct rtrs_ib_dev * |
|
rtrs_ib_dev_find_or_add(struct ib_device *ib_dev, |
|
struct rtrs_rdma_dev_pd *pool) |
|
{ |
|
struct rtrs_ib_dev *dev; |
|
|
|
mutex_lock(&pool->mutex); |
|
list_for_each_entry(dev, &pool->list, entry) { |
|
if (dev->ib_dev->node_guid == ib_dev->node_guid && |
|
rtrs_ib_dev_get(dev)) |
|
goto out_unlock; |
|
} |
|
mutex_unlock(&pool->mutex); |
|
if (pool->ops && pool->ops->alloc) |
|
dev = pool->ops->alloc(); |
|
else |
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL); |
|
if (IS_ERR_OR_NULL(dev)) |
|
goto out_err; |
|
|
|
kref_init(&dev->ref); |
|
dev->pool = pool; |
|
dev->ib_dev = ib_dev; |
|
dev->ib_pd = ib_alloc_pd(ib_dev, pool->pd_flags); |
|
if (IS_ERR(dev->ib_pd)) |
|
goto out_free_dev; |
|
|
|
if (pool->ops && pool->ops->init && pool->ops->init(dev)) |
|
goto out_free_pd; |
|
|
|
mutex_lock(&pool->mutex); |
|
list_add(&dev->entry, &pool->list); |
|
out_unlock: |
|
mutex_unlock(&pool->mutex); |
|
return dev; |
|
|
|
out_free_pd: |
|
ib_dealloc_pd(dev->ib_pd); |
|
out_free_dev: |
|
if (pool->ops && pool->ops->free) |
|
pool->ops->free(dev); |
|
else |
|
kfree(dev); |
|
out_err: |
|
return NULL; |
|
} |
|
EXPORT_SYMBOL(rtrs_ib_dev_find_or_add);
|
|
|