if (ep->com.remote_addr.ss_family == AF_INET6) {
struct sockaddr_in6 *sin6 =
(struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
cxgb4_clip_release(
ep->com.dev->rdev.lldi.ports[0],
dst_release(ep->dst);
cxgb4_l2t_release(ep->l2t);
}
--- if (test_bit(RELEASE_MAPINFO, &ep->com.flags)) {
--- print_addr(&ep->com, __func__, "remove_mapinfo/mapping");
--- iwpm_remove_mapinfo(&ep->com.local_addr,
--- &ep->com.mapped_local_addr);
--- iwpm_remove_mapping(&ep->com.local_addr, RDMA_NL_C4IW);
--- }
kfree(ep);
}
state_set(&ep->com, DEAD);
if (ep->com.remote_addr.ss_family == AF_INET6) {
struct sockaddr_in6 *sin6 =
--- (struct sockaddr_in6 *)&ep->com.mapped_local_addr;
+++ (struct sockaddr_in6 *)&ep->com.local_addr;
cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
(const u32 *)&sin6->sin6_addr.s6_addr, 1);
}
unsigned int flowclen = 80;
struct fw_flowc_wr *flowc;
int i;
++ + u16 vlan = ep->l2t->vlan;
++ + int nparams;
++ +
++ + if (vlan == CPL_L2T_VLAN_NONE)
++ + nparams = 8;
++ + else
++ + nparams = 9;
skb = get_skb(skb, flowclen, GFP_KERNEL);
flowc = (struct fw_flowc_wr *)__skb_put(skb, flowclen);
flowc->op_to_nparams = cpu_to_be32(FW_WR_OP_V(FW_FLOWC_WR) |
-- - FW_FLOWC_WR_NPARAMS_V(8));
++ + FW_FLOWC_WR_NPARAMS_V(nparams));
flowc->flowid_len16 = cpu_to_be32(FW_WR_LEN16_V(DIV_ROUND_UP(flowclen,
16)) | FW_WR_FLOWID_V(ep->hwtid));
flowc->mnemval[6].val = cpu_to_be32(ep->snd_win);
flowc->mnemval[7].mnemonic = FW_FLOWC_MNEM_MSS;
flowc->mnemval[7].val = cpu_to_be32(ep->emss);
-- - /* Pad WR to 16 byte boundary */
-- - flowc->mnemval[8].mnemonic = 0;
-- - flowc->mnemval[8].val = 0;
++ + if (nparams == 9) {
++ + u16 pri;
++ +
++ + pri = (vlan & VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
++ + flowc->mnemval[8].mnemonic = FW_FLOWC_MNEM_SCHEDCLASS;
++ + flowc->mnemval[8].val = cpu_to_be32(pri);
++ + } else {
++ + /* Pad WR to 16 byte boundary */
++ + flowc->mnemval[8].mnemonic = 0;
++ + flowc->mnemval[8].val = 0;
++ + }
for (i = 0; i < 9; i++) {
flowc->mnemval[i].r4[0] = 0;
flowc->mnemval[i].r4[1] = 0;
return c4iw_l2t_send(&ep->com.dev->rdev, skb, ep->l2t);
}
--- /*
--- * c4iw_form_pm_msg - Form a port mapper message with mapping info
--- */
--- static void c4iw_form_pm_msg(struct c4iw_ep *ep,
--- struct iwpm_sa_data *pm_msg)
--- {
--- memcpy(&pm_msg->loc_addr, &ep->com.local_addr,
--- sizeof(ep->com.local_addr));
--- memcpy(&pm_msg->rem_addr, &ep->com.remote_addr,
--- sizeof(ep->com.remote_addr));
--- }
---
--- /*
--- * c4iw_form_reg_msg - Form a port mapper message with dev info
--- */
--- static void c4iw_form_reg_msg(struct c4iw_dev *dev,
--- struct iwpm_dev_data *pm_msg)
--- {
--- memcpy(pm_msg->dev_name, dev->ibdev.name, IWPM_DEVNAME_SIZE);
--- memcpy(pm_msg->if_name, dev->rdev.lldi.ports[0]->name,
--- IWPM_IFNAME_SIZE);
--- }
---
--- static void c4iw_record_pm_msg(struct c4iw_ep *ep,
--- struct iwpm_sa_data *pm_msg)
--- {
--- memcpy(&ep->com.mapped_local_addr, &pm_msg->mapped_loc_addr,
--- sizeof(ep->com.mapped_local_addr));
--- memcpy(&ep->com.mapped_remote_addr, &pm_msg->mapped_rem_addr,
--- sizeof(ep->com.mapped_remote_addr));
--- }
---
--- static int get_remote_addr(struct c4iw_ep *parent_ep, struct c4iw_ep *child_ep)
--- {
--- int ret;
---
--- print_addr(&parent_ep->com, __func__, "get_remote_addr parent_ep ");
--- print_addr(&child_ep->com, __func__, "get_remote_addr child_ep ");
---
--- ret = iwpm_get_remote_info(&parent_ep->com.mapped_local_addr,
--- &child_ep->com.mapped_remote_addr,
--- &child_ep->com.remote_addr, RDMA_NL_C4IW);
--- if (ret)
--- PDBG("Unable to find remote peer addr info - err %d\n", ret);
---
--- return ret;
--- }
---
static void best_mtu(const unsigned short *mtus, unsigned short mtu,
unsigned int *idx, int use_ts, int ipv6)
{
int wscale;
int win, sizev4, sizev6, wrlen;
struct sockaddr_in *la = (struct sockaddr_in *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
struct sockaddr_in *ra = (struct sockaddr_in *)
--- &ep->com.mapped_remote_addr;
+++ &ep->com.remote_addr;
struct sockaddr_in6 *la6 = (struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
struct sockaddr_in6 *ra6 = (struct sockaddr_in6 *)
--- &ep->com.mapped_remote_addr;
+++ &ep->com.remote_addr;
int ret;
enum chip_type adapter_type = ep->com.dev->rdev.lldi.adapter_type;
u32 isn = (prandom_u32() & ~7UL) - 1;
L2T_IDX_V(ep->l2t->idx) |
TX_CHAN_V(ep->tx_chan) |
SMAC_SEL_V(ep->smac_idx) |
-- - DSCP_V(ep->tos) |
++ + DSCP_V(ep->tos >> 2) |
ULP_MODE_V(ULP_MODE_TCPDDP) |
RCV_BUFSIZ_V(win);
opt2 = RX_CHANNEL_V(0) |
req->le.filter = cpu_to_be32(cxgb4_select_ntuple(
ep->com.dev->rdev.lldi.ports[0],
ep->l2t));
--- sin = (struct sockaddr_in *)&ep->com.mapped_local_addr;
+++ sin = (struct sockaddr_in *)&ep->com.local_addr;
req->le.lport = sin->sin_port;
req->le.u.ipv4.lip = sin->sin_addr.s_addr;
--- sin = (struct sockaddr_in *)&ep->com.mapped_remote_addr;
+++ sin = (struct sockaddr_in *)&ep->com.remote_addr;
req->le.pport = sin->sin_port;
req->le.u.ipv4.pip = sin->sin_addr.s_addr;
req->tcb.t_state_to_astid =
L2T_IDX_V(ep->l2t->idx) |
TX_CHAN_V(ep->tx_chan) |
SMAC_SEL_V(ep->smac_idx) |
-- - DSCP_V(ep->tos) |
++ + DSCP_V(ep->tos >> 2) |
ULP_MODE_V(ULP_MODE_TCPDDP) |
RCV_BUFSIZ_V(win));
req->tcb.opt2 = (__force __be32) (PACE_V(1) |
static int import_ep(struct c4iw_ep *ep, int iptype, __u8 *peer_ip,
struct dst_entry *dst, struct c4iw_dev *cdev,
-- - bool clear_mpa_v1, enum chip_type adapter_type)
++ + bool clear_mpa_v1, enum chip_type adapter_type, u8 tos)
{
struct neighbour *n;
int err, step;
goto out;
}
ep->l2t = cxgb4_l2t_get(cdev->rdev.lldi.l2t,
-- - n, pdev, 0);
++ + n, pdev, rt_tos2priority(tos));
if (!ep->l2t)
goto out;
ep->mtu = pdev->mtu;
{
int err = 0;
struct sockaddr_in *laddr = (struct sockaddr_in *)
--- &ep->com.cm_id->local_addr;
+++ &ep->com.cm_id->m_local_addr;
struct sockaddr_in *raddr = (struct sockaddr_in *)
--- &ep->com.cm_id->remote_addr;
+++ &ep->com.cm_id->m_remote_addr;
struct sockaddr_in6 *laddr6 = (struct sockaddr_in6 *)
--- &ep->com.cm_id->local_addr;
+++ &ep->com.cm_id->m_local_addr;
struct sockaddr_in6 *raddr6 = (struct sockaddr_in6 *)
--- &ep->com.cm_id->remote_addr;
+++ &ep->com.cm_id->m_remote_addr;
int iptype;
__u8 *ra;
insert_handle(ep->com.dev, &ep->com.dev->atid_idr, ep, ep->atid);
/* find a route */
--- if (ep->com.cm_id->local_addr.ss_family == AF_INET) {
+++ if (ep->com.cm_id->m_local_addr.ss_family == AF_INET) {
ep->dst = find_route(ep->com.dev, laddr->sin_addr.s_addr,
raddr->sin_addr.s_addr, laddr->sin_port,
-- - raddr->sin_port, 0);
++ + raddr->sin_port, ep->com.cm_id->tos);
iptype = 4;
ra = (__u8 *)&raddr->sin_addr;
} else {
goto fail3;
}
err = import_ep(ep, iptype, ra, ep->dst, ep->com.dev, false,
-- - ep->com.dev->rdev.lldi.adapter_type);
++ + ep->com.dev->rdev.lldi.adapter_type,
++ + ep->com.cm_id->tos);
if (err) {
pr_err("%s - cannot alloc l2e.\n", __func__);
goto fail4;
ep->l2t->idx);
state_set(&ep->com, CONNECTING);
-- - ep->tos = 0;
++ + ep->tos = ep->com.cm_id->tos;
/* send connect request to rnic */
err = send_connect(ep);
struct sockaddr_in6 *ra6;
ep = lookup_atid(t, atid);
--- la = (struct sockaddr_in *)&ep->com.mapped_local_addr;
--- ra = (struct sockaddr_in *)&ep->com.mapped_remote_addr;
--- la6 = (struct sockaddr_in6 *)&ep->com.mapped_local_addr;
--- ra6 = (struct sockaddr_in6 *)&ep->com.mapped_remote_addr;
+++ la = (struct sockaddr_in *)&ep->com.local_addr;
+++ ra = (struct sockaddr_in *)&ep->com.remote_addr;
+++ la6 = (struct sockaddr_in6 *)&ep->com.local_addr;
+++ ra6 = (struct sockaddr_in6 *)&ep->com.remote_addr;
PDBG("%s ep %p atid %u status %u errno %d\n", __func__, ep, atid,
status, status2errno(status));
if (ep->com.remote_addr.ss_family == AF_INET6) {
struct sockaddr_in6 *sin6 =
(struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
cxgb4_clip_release(
ep->com.dev->rdev.lldi.ports[0],
(const u32 *)
if (ep->com.remote_addr.ss_family == AF_INET6) {
struct sockaddr_in6 *sin6 =
--- (struct sockaddr_in6 *)&ep->com.mapped_local_addr;
+++ (struct sockaddr_in6 *)&ep->com.local_addr;
cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
(const u32 *)&sin6->sin6_addr.s6_addr, 1);
}
u16 peer_mss = ntohs(req->tcpopt.mss);
int iptype;
unsigned short hdrs;
++ + u8 tos = PASS_OPEN_TOS_G(ntohl(req->tos_stid));
parent_ep = lookup_stid(t, stid);
if (!parent_ep) {
}
if (state_read(&parent_ep->com) != LISTEN) {
-- - printk(KERN_ERR "%s - listening ep not in LISTEN\n",
-- - __func__);
++ + PDBG("%s - listening ep not in LISTEN\n", __func__);
goto reject;
}
ntohs(peer_port), peer_mss);
dst = find_route(dev, *(__be32 *)local_ip, *(__be32 *)peer_ip,
local_port, peer_port,
-- - PASS_OPEN_TOS_G(ntohl(req->tos_stid)));
++ + tos);
} else {
PDBG("%s parent ep %p hwtid %u laddr %pI6 raddr %pI6 lport %d rport %d peer_mss %d\n"
, __func__, parent_ep, hwtid,
}
err = import_ep(child_ep, iptype, peer_ip, dst, dev, false,
-- - parent_ep->com.dev->rdev.lldi.adapter_type);
++ + parent_ep->com.dev->rdev.lldi.adapter_type, tos);
if (err) {
printk(KERN_ERR MOD "%s - failed to allocate l2t entry!\n",
__func__);
child_ep->com.dev = dev;
child_ep->com.cm_id = NULL;
--- /*
--- * The mapped_local and mapped_remote addresses get setup with
--- * the actual 4-tuple. The local address will be based on the
--- * actual local address of the connection, but on the port number
--- * of the parent listening endpoint. The remote address is
--- * setup based on a query to the IWPM since we don't know what it
--- * originally was before mapping. If no mapping was done, then
--- * mapped_remote == remote, and mapped_local == local.
--- */
if (iptype == 4) {
struct sockaddr_in *sin = (struct sockaddr_in *)
--- &child_ep->com.mapped_local_addr;
+++ &child_ep->com.local_addr;
sin->sin_family = PF_INET;
sin->sin_port = local_port;
&parent_ep->com.local_addr)->sin_port;
sin->sin_addr.s_addr = *(__be32 *)local_ip;
--- sin = (struct sockaddr_in *)&child_ep->com.mapped_remote_addr;
+++ sin = (struct sockaddr_in *)&child_ep->com.remote_addr;
sin->sin_family = PF_INET;
sin->sin_port = peer_port;
sin->sin_addr.s_addr = *(__be32 *)peer_ip;
} else {
--- sin6 = (struct sockaddr_in6 *)&child_ep->com.mapped_local_addr;
+++ sin6 = (struct sockaddr_in6 *)&child_ep->com.local_addr;
sin6->sin6_family = PF_INET6;
sin6->sin6_port = local_port;
memcpy(sin6->sin6_addr.s6_addr, local_ip, 16);
&parent_ep->com.local_addr)->sin6_port;
memcpy(sin6->sin6_addr.s6_addr, local_ip, 16);
--- sin6 = (struct sockaddr_in6 *)&child_ep->com.mapped_remote_addr;
+++ sin6 = (struct sockaddr_in6 *)&child_ep->com.remote_addr;
sin6->sin6_family = PF_INET6;
sin6->sin6_port = peer_port;
memcpy(sin6->sin6_addr.s6_addr, peer_ip, 16);
}
--- memcpy(&child_ep->com.remote_addr, &child_ep->com.mapped_remote_addr,
--- sizeof(child_ep->com.remote_addr));
--- get_remote_addr(parent_ep, child_ep);
c4iw_get_ep(&parent_ep->com);
child_ep->parent_ep = parent_ep;
-- - child_ep->tos = PASS_OPEN_TOS_G(ntohl(req->tos_stid));
++ + child_ep->tos = tos;
child_ep->dst = dst;
child_ep->hwtid = hwtid;
accept_cr(child_ep, skb, req);
set_bit(PASS_ACCEPT_REQ, &child_ep->com.history);
if (iptype == 6) {
--- sin6 = (struct sockaddr_in6 *)&child_ep->com.mapped_local_addr;
+++ sin6 = (struct sockaddr_in6 *)&child_ep->com.local_addr;
cxgb4_clip_get(child_ep->com.dev->rdev.lldi.ports[0],
(const u32 *)&sin6->sin6_addr.s6_addr, 1);
}
if (ep->com.remote_addr.ss_family == AF_INET6) {
struct sockaddr_in6 *sin6 =
(struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
cxgb4_clip_release(
ep->com.dev->rdev.lldi.ports[0],
(const u32 *)&sin6->sin6_addr.s6_addr,
{
struct in_device *ind;
int found = 0;
--- struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr;
--- struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr;
+++ struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
+++ struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->m_remote_addr;
ind = in_dev_get(dev->rdev.lldi.ports[0]);
if (!ind)
static int pick_local_ip6addrs(struct c4iw_dev *dev, struct iw_cm_id *cm_id)
{
struct in6_addr uninitialized_var(addr);
--- struct sockaddr_in6 *la6 = (struct sockaddr_in6 *)&cm_id->local_addr;
--- struct sockaddr_in6 *ra6 = (struct sockaddr_in6 *)&cm_id->remote_addr;
+++ struct sockaddr_in6 *la6 = (struct sockaddr_in6 *)&cm_id->m_local_addr;
+++ struct sockaddr_in6 *ra6 = (struct sockaddr_in6 *)&cm_id->m_remote_addr;
if (!get_lladdr(dev->rdev.lldi.ports[0], &addr, IFA_F_TENTATIVE)) {
memcpy(la6->sin6_addr.s6_addr, &addr, 16);
struct sockaddr_in *raddr;
struct sockaddr_in6 *laddr6;
struct sockaddr_in6 *raddr6;
--- struct iwpm_dev_data pm_reg_msg;
--- struct iwpm_sa_data pm_msg;
__u8 *ra;
int iptype;
--- int iwpm_err = 0;
if ((conn_param->ord > cur_max_read_depth(dev)) ||
(conn_param->ird > cur_max_read_depth(dev))) {
}
insert_handle(dev, &dev->atid_idr, ep, ep->atid);
--- memcpy(&ep->com.local_addr, &cm_id->local_addr,
+++ memcpy(&ep->com.local_addr, &cm_id->m_local_addr,
sizeof(ep->com.local_addr));
--- memcpy(&ep->com.remote_addr, &cm_id->remote_addr,
+++ memcpy(&ep->com.remote_addr, &cm_id->m_remote_addr,
sizeof(ep->com.remote_addr));
--- /* No port mapper available, go with the specified peer information */
--- memcpy(&ep->com.mapped_local_addr, &cm_id->local_addr,
--- sizeof(ep->com.mapped_local_addr));
--- memcpy(&ep->com.mapped_remote_addr, &cm_id->remote_addr,
--- sizeof(ep->com.mapped_remote_addr));
---
--- c4iw_form_reg_msg(dev, &pm_reg_msg);
--- iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_C4IW);
--- if (iwpm_err) {
--- PDBG("%s: Port Mapper reg pid fail (err = %d).\n",
--- __func__, iwpm_err);
--- }
--- if (iwpm_valid_pid() && !iwpm_err) {
--- c4iw_form_pm_msg(ep, &pm_msg);
--- iwpm_err = iwpm_add_and_query_mapping(&pm_msg, RDMA_NL_C4IW);
--- if (iwpm_err)
--- PDBG("%s: Port Mapper query fail (err = %d).\n",
--- __func__, iwpm_err);
--- else
--- c4iw_record_pm_msg(ep, &pm_msg);
--- }
--- if (iwpm_create_mapinfo(&ep->com.local_addr,
--- &ep->com.mapped_local_addr, RDMA_NL_C4IW)) {
--- iwpm_remove_mapping(&ep->com.local_addr, RDMA_NL_C4IW);
--- err = -ENOMEM;
--- goto fail1;
--- }
--- print_addr(&ep->com, __func__, "add_query/create_mapinfo");
--- set_bit(RELEASE_MAPINFO, &ep->com.flags);
---
--- laddr = (struct sockaddr_in *)&ep->com.mapped_local_addr;
--- raddr = (struct sockaddr_in *)&ep->com.mapped_remote_addr;
--- laddr6 = (struct sockaddr_in6 *)&ep->com.mapped_local_addr;
--- raddr6 = (struct sockaddr_in6 *) &ep->com.mapped_remote_addr;
+++ laddr = (struct sockaddr_in *)&ep->com.local_addr;
+++ raddr = (struct sockaddr_in *)&ep->com.remote_addr;
+++ laddr6 = (struct sockaddr_in6 *)&ep->com.local_addr;
+++ raddr6 = (struct sockaddr_in6 *) &ep->com.remote_addr;
--- if (cm_id->remote_addr.ss_family == AF_INET) {
+++ if (cm_id->m_remote_addr.ss_family == AF_INET) {
iptype = 4;
ra = (__u8 *)&raddr->sin_addr;
ra, ntohs(raddr->sin_port));
ep->dst = find_route(dev, laddr->sin_addr.s_addr,
raddr->sin_addr.s_addr, laddr->sin_port,
-- - raddr->sin_port, 0);
++ + raddr->sin_port, cm_id->tos);
} else {
iptype = 6;
ra = (__u8 *)&raddr6->sin6_addr;
}
err = import_ep(ep, iptype, ra, ep->dst, ep->com.dev, true,
-- - ep->com.dev->rdev.lldi.adapter_type);
++ + ep->com.dev->rdev.lldi.adapter_type, cm_id->tos);
if (err) {
printk(KERN_ERR MOD "%s - cannot alloc l2e.\n", __func__);
goto fail3;
ep->l2t->idx);
state_set(&ep->com, CONNECTING);
-- - ep->tos = 0;
++ + ep->tos = cm_id->tos;
/* send connect request to rnic */
err = send_connect(ep);
{
int err;
struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
if (ipv6_addr_type(&sin6->sin6_addr) != IPV6_ADDR_ANY) {
err = cxgb4_clip_get(ep->com.dev->rdev.lldi.ports[0],
{
int err;
struct sockaddr_in *sin = (struct sockaddr_in *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.local_addr;
if (dev->rdev.lldi.enable_fw_ofld_conn) {
do {
int err = 0;
struct c4iw_dev *dev = to_c4iw_dev(cm_id->device);
struct c4iw_listen_ep *ep;
--- struct iwpm_dev_data pm_reg_msg;
--- struct iwpm_sa_data pm_msg;
--- int iwpm_err = 0;
might_sleep();
ep->com.cm_id = cm_id;
ep->com.dev = dev;
ep->backlog = backlog;
--- memcpy(&ep->com.local_addr, &cm_id->local_addr,
+++ memcpy(&ep->com.local_addr, &cm_id->m_local_addr,
sizeof(ep->com.local_addr));
/*
if (dev->rdev.lldi.enable_fw_ofld_conn &&
ep->com.local_addr.ss_family == AF_INET)
ep->stid = cxgb4_alloc_sftid(dev->rdev.lldi.tids,
--- cm_id->local_addr.ss_family, ep);
+++ cm_id->m_local_addr.ss_family, ep);
else
ep->stid = cxgb4_alloc_stid(dev->rdev.lldi.tids,
--- cm_id->local_addr.ss_family, ep);
+++ cm_id->m_local_addr.ss_family, ep);
if (ep->stid == -1) {
printk(KERN_ERR MOD "%s - cannot alloc stid.\n", __func__);
}
insert_handle(dev, &dev->stid_idr, ep, ep->stid);
--- /* No port mapper available, go with the specified info */
--- memcpy(&ep->com.mapped_local_addr, &cm_id->local_addr,
--- sizeof(ep->com.mapped_local_addr));
---
--- c4iw_form_reg_msg(dev, &pm_reg_msg);
--- iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_C4IW);
--- if (iwpm_err) {
--- PDBG("%s: Port Mapper reg pid fail (err = %d).\n",
--- __func__, iwpm_err);
--- }
--- if (iwpm_valid_pid() && !iwpm_err) {
--- memcpy(&pm_msg.loc_addr, &ep->com.local_addr,
--- sizeof(ep->com.local_addr));
--- iwpm_err = iwpm_add_mapping(&pm_msg, RDMA_NL_C4IW);
--- if (iwpm_err)
--- PDBG("%s: Port Mapper query fail (err = %d).\n",
--- __func__, iwpm_err);
--- else
--- memcpy(&ep->com.mapped_local_addr,
--- &pm_msg.mapped_loc_addr,
--- sizeof(ep->com.mapped_local_addr));
--- }
--- if (iwpm_create_mapinfo(&ep->com.local_addr,
--- &ep->com.mapped_local_addr, RDMA_NL_C4IW)) {
--- err = -ENOMEM;
--- goto fail3;
--- }
--- print_addr(&ep->com, __func__, "add_mapping/create_mapinfo");
+++ memcpy(&ep->com.local_addr, &cm_id->m_local_addr,
+++ sizeof(ep->com.local_addr));
--- set_bit(RELEASE_MAPINFO, &ep->com.flags);
state_set(&ep->com, LISTEN);
if (ep->com.local_addr.ss_family == AF_INET)
err = create_server4(dev, ep);
goto out;
}
--- fail3:
cxgb4_free_stid(ep->com.dev->rdev.lldi.tids, ep->stid,
ep->com.local_addr.ss_family);
fail2:
goto done;
err = c4iw_wait_for_reply(&ep->com.dev->rdev, &ep->com.wr_wait,
0, 0, __func__);
--- sin6 = (struct sockaddr_in6 *)&ep->com.mapped_local_addr;
+++ sin6 = (struct sockaddr_in6 *)&ep->com.local_addr;
cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
(const u32 *)&sin6->sin6_addr.s6_addr, 1);
}
state_set(&ep->com, DEAD);
if (ep->com.remote_addr.ss_family == AF_INET6) {
struct sockaddr_in6 *sin6 =
--- (struct sockaddr_in6 *)&ep->com.mapped_local_addr;
+++ (struct sockaddr_in6 *)&ep->com.local_addr;
cxgb4_clip_release(ep->com.dev->rdev.lldi.ports[0],
(const u32 *)&sin6->sin6_addr.s6_addr, 1);
}
int pos;
};
--- /* registered cxgb4 netlink callbacks */
--- static struct ibnl_client_cbs c4iw_nl_cb_table[] = {
--- [RDMA_NL_IWPM_REG_PID] = {.dump = iwpm_register_pid_cb},
--- [RDMA_NL_IWPM_ADD_MAPPING] = {.dump = iwpm_add_mapping_cb},
--- [RDMA_NL_IWPM_QUERY_MAPPING] = {.dump = iwpm_add_and_query_mapping_cb},
--- [RDMA_NL_IWPM_HANDLE_ERR] = {.dump = iwpm_mapping_error_cb},
--- [RDMA_NL_IWPM_REMOTE_INFO] = {.dump = iwpm_remote_info_cb},
--- [RDMA_NL_IWPM_MAPINFO] = {.dump = iwpm_mapping_info_cb},
--- [RDMA_NL_IWPM_MAPINFO_NUM] = {.dump = iwpm_ack_mapping_info_cb}
--- };
---
static int count_idrs(int id, void *p, void *data)
{
int *countp = data;
if (qp->ep) {
if (qp->ep->com.local_addr.ss_family == AF_INET) {
struct sockaddr_in *lsin = (struct sockaddr_in *)
--- &qp->ep->com.local_addr;
+++ &qp->ep->com.cm_id->local_addr;
struct sockaddr_in *rsin = (struct sockaddr_in *)
--- &qp->ep->com.remote_addr;
+++ &qp->ep->com.cm_id->remote_addr;
struct sockaddr_in *mapped_lsin = (struct sockaddr_in *)
--- &qp->ep->com.mapped_local_addr;
+++ &qp->ep->com.cm_id->m_local_addr;
struct sockaddr_in *mapped_rsin = (struct sockaddr_in *)
--- &qp->ep->com.mapped_remote_addr;
+++ &qp->ep->com.cm_id->m_remote_addr;
cc = snprintf(qpd->buf + qpd->pos, space,
"rc qp sq id %u rq id %u state %u "
ntohs(mapped_rsin->sin_port));
} else {
struct sockaddr_in6 *lsin6 = (struct sockaddr_in6 *)
--- &qp->ep->com.local_addr;
+++ &qp->ep->com.cm_id->local_addr;
struct sockaddr_in6 *rsin6 = (struct sockaddr_in6 *)
--- &qp->ep->com.remote_addr;
+++ &qp->ep->com.cm_id->remote_addr;
struct sockaddr_in6 *mapped_lsin6 =
(struct sockaddr_in6 *)
--- &qp->ep->com.mapped_local_addr;
+++ &qp->ep->com.cm_id->m_local_addr;
struct sockaddr_in6 *mapped_rsin6 =
(struct sockaddr_in6 *)
--- &qp->ep->com.mapped_remote_addr;
+++ &qp->ep->com.cm_id->m_remote_addr;
cc = snprintf(qpd->buf + qpd->pos, space,
"rc qp sq id %u rq id %u state %u "
if (ep->com.local_addr.ss_family == AF_INET) {
struct sockaddr_in *lsin = (struct sockaddr_in *)
--- &ep->com.local_addr;
+++ &ep->com.cm_id->local_addr;
struct sockaddr_in *rsin = (struct sockaddr_in *)
--- &ep->com.remote_addr;
+++ &ep->com.cm_id->remote_addr;
struct sockaddr_in *mapped_lsin = (struct sockaddr_in *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.cm_id->m_local_addr;
struct sockaddr_in *mapped_rsin = (struct sockaddr_in *)
--- &ep->com.mapped_remote_addr;
+++ &ep->com.cm_id->m_remote_addr;
cc = snprintf(epd->buf + epd->pos, space,
"ep %p cm_id %p qp %p state %d flags 0x%lx "
ntohs(mapped_rsin->sin_port));
} else {
struct sockaddr_in6 *lsin6 = (struct sockaddr_in6 *)
--- &ep->com.local_addr;
+++ &ep->com.cm_id->local_addr;
struct sockaddr_in6 *rsin6 = (struct sockaddr_in6 *)
--- &ep->com.remote_addr;
+++ &ep->com.cm_id->remote_addr;
struct sockaddr_in6 *mapped_lsin6 = (struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.cm_id->m_local_addr;
struct sockaddr_in6 *mapped_rsin6 = (struct sockaddr_in6 *)
--- &ep->com.mapped_remote_addr;
+++ &ep->com.cm_id->m_remote_addr;
cc = snprintf(epd->buf + epd->pos, space,
"ep %p cm_id %p qp %p state %d flags 0x%lx "
if (ep->com.local_addr.ss_family == AF_INET) {
struct sockaddr_in *lsin = (struct sockaddr_in *)
--- &ep->com.local_addr;
+++ &ep->com.cm_id->local_addr;
struct sockaddr_in *mapped_lsin = (struct sockaddr_in *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.cm_id->m_local_addr;
cc = snprintf(epd->buf + epd->pos, space,
"ep %p cm_id %p state %d flags 0x%lx stid %d "
ntohs(mapped_lsin->sin_port));
} else {
struct sockaddr_in6 *lsin6 = (struct sockaddr_in6 *)
--- &ep->com.local_addr;
+++ &ep->com.cm_id->local_addr;
struct sockaddr_in6 *mapped_lsin6 = (struct sockaddr_in6 *)
--- &ep->com.mapped_local_addr;
+++ &ep->com.cm_id->m_local_addr;
cc = snprintf(epd->buf + epd->pos, space,
"ep %p cm_id %p state %d flags 0x%lx stid %d "
rdev->lldi.vr->qp.size,
rdev->lldi.vr->cq.start,
rdev->lldi.vr->cq.size);
-- - PDBG("udb len 0x%x udb base %p db_reg %p gts_reg %p "
++ + PDBG("udb %pR db_reg %p gts_reg %p "
"qpmask 0x%x cqmask 0x%x\n",
-- - (unsigned)pci_resource_len(rdev->lldi.pdev, 2),
-- - (void *)pci_resource_start(rdev->lldi.pdev, 2),
++ + &rdev->lldi.pdev->resource[2],
rdev->lldi.db_reg, rdev->lldi.gts_reg,
rdev->qpmask, rdev->cqmask);
printk(KERN_WARNING MOD
"could not create debugfs entry, continuing\n");
--- if (ibnl_add_client(RDMA_NL_C4IW, RDMA_NL_IWPM_NUM_OPS,
--- c4iw_nl_cb_table))
--- pr_err("%s[%u]: Failed to add netlink callback\n"
--- , __func__, __LINE__);
---
--- err = iwpm_init(RDMA_NL_C4IW);
--- if (err) {
--- pr_err("port mapper initialization failed with %d\n", err);
--- ibnl_remove_client(RDMA_NL_C4IW);
--- c4iw_cm_term();
--- debugfs_remove_recursive(c4iw_debugfs_root);
--- return err;
--- }
---
cxgb4_register_uld(CXGB4_ULD_RDMA, &c4iw_uld_info);
return 0;
}
mutex_unlock(&dev_mutex);
cxgb4_unregister_uld(CXGB4_ULD_RDMA);
--- iwpm_exit(RDMA_NL_C4IW);
--- ibnl_remove_client(RDMA_NL_C4IW);
c4iw_cm_term();
debugfs_remove_recursive(c4iw_debugfs_root);
}
wait_queue_head_t wait;
struct timer_list timer;
int sq_sig_all;
+++ struct completion rq_drained;
+++ struct completion sq_drained;
};
static inline struct c4iw_qp *to_c4iw_qp(struct ib_qp *ibqp)
CLOSE_SENT = 3,
TIMEOUT = 4,
QP_REFERENCED = 5,
--- RELEASE_MAPINFO = 6,
};
enum c4iw_ep_history {
struct mutex mutex;
struct sockaddr_storage local_addr;
struct sockaddr_storage remote_addr;
--- struct sockaddr_storage mapped_local_addr;
--- struct sockaddr_storage mapped_remote_addr;
struct c4iw_wr_wait wr_wait;
unsigned long flags;
unsigned long history;
struct c4iw_ep_stats stats;
};
--- static inline void print_addr(struct c4iw_ep_common *epc, const char *func,
--- const char *msg)
--- {
---
--- #define SINA(a) (&(((struct sockaddr_in *)(a))->sin_addr.s_addr))
--- #define SINP(a) ntohs(((struct sockaddr_in *)(a))->sin_port)
--- #define SIN6A(a) (&(((struct sockaddr_in6 *)(a))->sin6_addr))
--- #define SIN6P(a) ntohs(((struct sockaddr_in6 *)(a))->sin6_port)
---
--- if (c4iw_debug) {
--- switch (epc->local_addr.ss_family) {
--- case AF_INET:
--- PDBG("%s %s %pI4:%u/%u <-> %pI4:%u/%u\n",
--- func, msg, SINA(&epc->local_addr),
--- SINP(&epc->local_addr),
--- SINP(&epc->mapped_local_addr),
--- SINA(&epc->remote_addr),
--- SINP(&epc->remote_addr),
--- SINP(&epc->mapped_remote_addr));
--- break;
--- case AF_INET6:
--- PDBG("%s %s %pI6:%u/%u <-> %pI6:%u/%u\n",
--- func, msg, SIN6A(&epc->local_addr),
--- SIN6P(&epc->local_addr),
--- SIN6P(&epc->mapped_local_addr),
--- SIN6A(&epc->remote_addr),
--- SIN6P(&epc->remote_addr),
--- SIN6P(&epc->mapped_remote_addr));
--- break;
--- default:
--- break;
--- }
--- }
--- #undef SINA
--- #undef SINP
--- #undef SIN6A
--- #undef SIN6P
--- }
---
static inline struct c4iw_ep *to_ep(struct iw_cm_id *cm_id)
{
return cm_id->provider_data;
struct scatterlist *sg,
int sg_nents);
int c4iw_dealloc_mw(struct ib_mw *mw);
---struct ib_mw *c4iw_alloc_mw(struct ib_pd *pd, enum ib_mw_type type);
+++struct ib_mw *c4iw_alloc_mw(struct ib_pd *pd, enum ib_mw_type type,
+++ struct ib_udata *udata);
struct ib_mr *c4iw_reg_user_mr(struct ib_pd *pd, u64 start,
u64 length, u64 virt, int acc,
struct ib_udata *udata);
extern int db_fc_threshold;
extern int db_coalescing_threshold;
extern int use_dsgl;
+++void c4iw_drain_rq(struct ib_qp *qp);
+++void c4iw_drain_sq(struct ib_qp *qp);
#endif
#include <linux/moduleparam.h>
#include <rdma/ib_umem.h>
#include <linux/atomic.h>
+++#include <rdma/ib_user_verbs.h>
#include "iw_cxgb4.h"
return ERR_PTR(err);
}
---struct ib_mw *c4iw_alloc_mw(struct ib_pd *pd, enum ib_mw_type type)
+++struct ib_mw *c4iw_alloc_mw(struct ib_pd *pd, enum ib_mw_type type,
+++ struct ib_udata *udata)
{
struct c4iw_dev *rhp;
struct c4iw_pd *php;
int ret = 0;
int length = roundup(max_num_sg * sizeof(u64), 32);
++ + php = to_c4iw_pd(pd);
++ + rhp = php->rhp;
++ +
if (mr_type != IB_MR_TYPE_MEM_REG ||
-- - max_num_sg > t4_max_fr_depth(use_dsgl))
++ + max_num_sg > t4_max_fr_depth(&rhp->rdev.lldi.ulptx_memwrite_dsgl &&
++ + use_dsgl))
return ERR_PTR(-EINVAL);
-- - php = to_c4iw_pd(pd);
-- - rhp = php->rhp;
mhp = kzalloc(sizeof(*mhp), GFP_KERNEL);
if (!mhp) {
ret = -ENOMEM;
props->max_mr = c4iw_num_stags(&dev->rdev);
props->max_pd = T4_MAX_NUM_PD;
props->local_ca_ack_delay = 0;
-- - props->max_fast_reg_page_list_len = t4_max_fr_depth(use_dsgl);
++ + props->max_fast_reg_page_list_len =
++ + t4_max_fr_depth(dev->rdev.lldi.ulptx_memwrite_dsgl && use_dsgl);
return 0;
}
dev->ibdev.get_protocol_stats = c4iw_get_mib;
dev->ibdev.uverbs_abi_ver = C4IW_UVERBS_ABI_VERSION;
dev->ibdev.get_port_immutable = c4iw_port_immutable;
+++ dev->ibdev.drain_sq = c4iw_drain_sq;
+++ dev->ibdev.drain_rq = c4iw_drain_rq;
dev->ibdev.iwcm = kmalloc(sizeof(struct iw_cm_verbs), GFP_KERNEL);
if (!dev->ibdev.iwcm)
}
static int build_memreg(struct t4_sq *sq, union t4_wr *wqe,
-- - struct ib_reg_wr *wr, u8 *len16, u8 t5dev)
++ + struct ib_reg_wr *wr, u8 *len16, bool dsgl_supported)
{
struct c4iw_mr *mhp = to_c4iw_mr(wr->mr);
struct fw_ri_immd *imdp;
int pbllen = roundup(mhp->mpl_len * sizeof(u64), 32);
int rem;
-- - if (mhp->mpl_len > t4_max_fr_depth(use_dsgl))
++ + if (mhp->mpl_len > t4_max_fr_depth(dsgl_supported && use_dsgl))
return -EINVAL;
wqe->fr.qpbinde_to_dcacpu = 0;
wqe->fr.va_lo_fbo = cpu_to_be32(mhp->ibmr.iova &
0xffffffff);
-- - if (t5dev && use_dsgl && (pbllen > max_fr_immd)) {
++ + if (dsgl_supported && use_dsgl && (pbllen > max_fr_immd)) {
struct fw_ri_dsgl *sglp;
for (i = 0; i < mhp->mpl_len; i++)
fw_opcode = FW_RI_FR_NSMR_WR;
swsqe->opcode = FW_RI_FAST_REGISTER;
err = build_memreg(&qhp->wq.sq, wqe, reg_wr(wr), &len16,
-- - is_t5(
-- - qhp->rhp->rdev.lldi.adapter_type) ?
-- - 1 : 0);
++ + qhp->rhp->rdev.lldi.ulptx_memwrite_dsgl);
break;
case IB_WR_LOCAL_INV:
if (wr->send_flags & IB_SEND_FENCE)
unsigned int sqsize, rqsize;
struct c4iw_ucontext *ucontext;
int ret;
-- - struct c4iw_mm_entry *mm1, *mm2, *mm3, *mm4, *mm5 = NULL;
++ + struct c4iw_mm_entry *sq_key_mm, *rq_key_mm = NULL, *sq_db_key_mm;
++ + struct c4iw_mm_entry *rq_db_key_mm = NULL, *ma_sync_key_mm = NULL;
PDBG("%s ib_pd %p\n", __func__, pd);
qhp->attr.max_ird = 0;
qhp->sq_sig_all = attrs->sq_sig_type == IB_SIGNAL_ALL_WR;
spin_lock_init(&qhp->lock);
+++ init_completion(&qhp->sq_drained);
+++ init_completion(&qhp->rq_drained);
mutex_init(&qhp->mutex);
init_waitqueue_head(&qhp->wait);
atomic_set(&qhp->refcnt, 1);
goto err2;
if (udata) {
-- - mm1 = kmalloc(sizeof *mm1, GFP_KERNEL);
-- - if (!mm1) {
++ + sq_key_mm = kmalloc(sizeof(*sq_key_mm), GFP_KERNEL);
++ + if (!sq_key_mm) {
ret = -ENOMEM;
goto err3;
}
-- - mm2 = kmalloc(sizeof *mm2, GFP_KERNEL);
-- - if (!mm2) {
++ + rq_key_mm = kmalloc(sizeof(*rq_key_mm), GFP_KERNEL);
++ + if (!rq_key_mm) {
ret = -ENOMEM;
goto err4;
}
-- - mm3 = kmalloc(sizeof *mm3, GFP_KERNEL);
-- - if (!mm3) {
++ + sq_db_key_mm = kmalloc(sizeof(*sq_db_key_mm), GFP_KERNEL);
++ + if (!sq_db_key_mm) {
ret = -ENOMEM;
goto err5;
}
-- - mm4 = kmalloc(sizeof *mm4, GFP_KERNEL);
-- - if (!mm4) {
++ + rq_db_key_mm = kmalloc(sizeof(*rq_db_key_mm), GFP_KERNEL);
++ + if (!rq_db_key_mm) {
ret = -ENOMEM;
goto err6;
}
if (t4_sq_onchip(&qhp->wq.sq)) {
-- - mm5 = kmalloc(sizeof *mm5, GFP_KERNEL);
-- - if (!mm5) {
++ + ma_sync_key_mm = kmalloc(sizeof(*ma_sync_key_mm),
++ + GFP_KERNEL);
++ + if (!ma_sync_key_mm) {
ret = -ENOMEM;
goto err7;
}
uresp.rq_size = qhp->wq.rq.size;
uresp.rq_memsize = qhp->wq.rq.memsize;
spin_lock(&ucontext->mmap_lock);
-- - if (mm5) {
++ + if (ma_sync_key_mm) {
uresp.ma_sync_key = ucontext->key;
ucontext->key += PAGE_SIZE;
} else {
ret = ib_copy_to_udata(udata, &uresp, sizeof uresp);
if (ret)
goto err8;
-- - mm1->key = uresp.sq_key;
-- - mm1->addr = qhp->wq.sq.phys_addr;
-- - mm1->len = PAGE_ALIGN(qhp->wq.sq.memsize);
-- - insert_mmap(ucontext, mm1);
-- - mm2->key = uresp.rq_key;
-- - mm2->addr = virt_to_phys(qhp->wq.rq.queue);
-- - mm2->len = PAGE_ALIGN(qhp->wq.rq.memsize);
-- - insert_mmap(ucontext, mm2);
-- - mm3->key = uresp.sq_db_gts_key;
-- - mm3->addr = (__force unsigned long)qhp->wq.sq.bar2_pa;
-- - mm3->len = PAGE_SIZE;
-- - insert_mmap(ucontext, mm3);
-- - mm4->key = uresp.rq_db_gts_key;
-- - mm4->addr = (__force unsigned long)qhp->wq.rq.bar2_pa;
-- - mm4->len = PAGE_SIZE;
-- - insert_mmap(ucontext, mm4);
-- - if (mm5) {
-- - mm5->key = uresp.ma_sync_key;
-- - mm5->addr = (pci_resource_start(rhp->rdev.lldi.pdev, 0)
-- - + PCIE_MA_SYNC_A) & PAGE_MASK;
-- - mm5->len = PAGE_SIZE;
-- - insert_mmap(ucontext, mm5);
++ + sq_key_mm->key = uresp.sq_key;
++ + sq_key_mm->addr = qhp->wq.sq.phys_addr;
++ + sq_key_mm->len = PAGE_ALIGN(qhp->wq.sq.memsize);
++ + insert_mmap(ucontext, sq_key_mm);
++ + rq_key_mm->key = uresp.rq_key;
++ + rq_key_mm->addr = virt_to_phys(qhp->wq.rq.queue);
++ + rq_key_mm->len = PAGE_ALIGN(qhp->wq.rq.memsize);
++ + insert_mmap(ucontext, rq_key_mm);
++ + sq_db_key_mm->key = uresp.sq_db_gts_key;
++ + sq_db_key_mm->addr = (u64)(unsigned long)qhp->wq.sq.bar2_pa;
++ + sq_db_key_mm->len = PAGE_SIZE;
++ + insert_mmap(ucontext, sq_db_key_mm);
++ + rq_db_key_mm->key = uresp.rq_db_gts_key;
++ + rq_db_key_mm->addr = (u64)(unsigned long)qhp->wq.rq.bar2_pa;
++ + rq_db_key_mm->len = PAGE_SIZE;
++ + insert_mmap(ucontext, rq_db_key_mm);
++ + if (ma_sync_key_mm) {
++ + ma_sync_key_mm->key = uresp.ma_sync_key;
++ + ma_sync_key_mm->addr =
++ + (pci_resource_start(rhp->rdev.lldi.pdev, 0) +
++ + PCIE_MA_SYNC_A) & PAGE_MASK;
++ + ma_sync_key_mm->len = PAGE_SIZE;
++ + insert_mmap(ucontext, ma_sync_key_mm);
}
}
qhp->ibqp.qp_num = qhp->wq.sq.qid;
qhp->wq.rq.memsize, attrs->cap.max_recv_wr);
return &qhp->ibqp;
err8:
-- - kfree(mm5);
++ + kfree(ma_sync_key_mm);
err7:
-- - kfree(mm4);
++ + kfree(rq_db_key_mm);
err6:
-- - kfree(mm3);
++ + kfree(sq_db_key_mm);
err5:
-- - kfree(mm2);
++ + kfree(rq_key_mm);
err4:
-- - kfree(mm1);
++ + kfree(sq_key_mm);
err3:
remove_handle(rhp, &rhp->qpidr, qhp->wq.sq.qid);
err2:
init_attr->sq_sig_type = qhp->sq_sig_all ? IB_SIGNAL_ALL_WR : 0;
return 0;
}
+++
+++void c4iw_drain_sq(struct ib_qp *ibqp)
+++{
+++ struct c4iw_qp *qp = to_c4iw_qp(ibqp);
+++
+++ wait_for_completion(&qp->sq_drained);
+++}
+++
+++void c4iw_drain_rq(struct ib_qp *ibqp)
+++{
+++ struct c4iw_qp *qp = to_c4iw_qp(ibqp);
+++
+++ wait_for_completion(&qp->rq_drained);
+++}
iph->ttl = 0x40;
iph->protocol = 0x06; /* IPPROTO_TCP */
--- iph->saddr = htonl(cm_node->mapped_loc_addr);
--- iph->daddr = htonl(cm_node->mapped_rem_addr);
+++ iph->saddr = htonl(cm_node->loc_addr);
+++ iph->daddr = htonl(cm_node->rem_addr);
--- tcph->source = htons(cm_node->mapped_loc_port);
--- tcph->dest = htons(cm_node->mapped_rem_port);
+++ tcph->source = htons(cm_node->loc_port);
+++ tcph->dest = htons(cm_node->rem_port);
tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num);
if (flags & SET_ACK) {
cm_packets_created++;
}
--- /*
--- * nes_create_sockaddr - Record ip addr and tcp port in a sockaddr struct
--- */
--- static void nes_create_sockaddr(__be32 ip_addr, __be16 port,
--- struct sockaddr_storage *addr)
--- {
--- struct sockaddr_in *nes_sockaddr = (struct sockaddr_in *)addr;
--- nes_sockaddr->sin_family = AF_INET;
--- memcpy(&nes_sockaddr->sin_addr.s_addr, &ip_addr, sizeof(__be32));
--- nes_sockaddr->sin_port = port;
--- }
---
--- /*
--- * nes_create_mapinfo - Create a mapinfo object in the port mapper data base
--- */
--- static int nes_create_mapinfo(struct nes_cm_info *cm_info)
--- {
--- struct sockaddr_storage local_sockaddr;
--- struct sockaddr_storage mapped_sockaddr;
---
--- nes_create_sockaddr(htonl(cm_info->loc_addr), htons(cm_info->loc_port),
--- &local_sockaddr);
--- nes_create_sockaddr(htonl(cm_info->mapped_loc_addr),
--- htons(cm_info->mapped_loc_port), &mapped_sockaddr);
---
--- return iwpm_create_mapinfo(&local_sockaddr,
--- &mapped_sockaddr, RDMA_NL_NES);
--- }
---
--- /*
--- * nes_remove_mapinfo - Remove a mapinfo object from the port mapper data base
--- * and send a remove mapping op message to
--- * the userspace port mapper
--- */
--- static int nes_remove_mapinfo(u32 loc_addr, u16 loc_port,
--- u32 mapped_loc_addr, u16 mapped_loc_port)
--- {
--- struct sockaddr_storage local_sockaddr;
--- struct sockaddr_storage mapped_sockaddr;
---
--- nes_create_sockaddr(htonl(loc_addr), htons(loc_port), &local_sockaddr);
--- nes_create_sockaddr(htonl(mapped_loc_addr), htons(mapped_loc_port),
--- &mapped_sockaddr);
---
--- iwpm_remove_mapinfo(&local_sockaddr, &mapped_sockaddr);
--- return iwpm_remove_mapping(&local_sockaddr, RDMA_NL_NES);
--- }
---
--- /*
--- * nes_form_pm_msg - Form a port mapper message with mapping info
--- */
--- static void nes_form_pm_msg(struct nes_cm_info *cm_info,
--- struct iwpm_sa_data *pm_msg)
--- {
--- nes_create_sockaddr(htonl(cm_info->loc_addr), htons(cm_info->loc_port),
--- &pm_msg->loc_addr);
--- nes_create_sockaddr(htonl(cm_info->rem_addr), htons(cm_info->rem_port),
--- &pm_msg->rem_addr);
--- }
---
--- /*
--- * nes_form_reg_msg - Form a port mapper message with dev info
--- */
--- static void nes_form_reg_msg(struct nes_vnic *nesvnic,
--- struct iwpm_dev_data *pm_msg)
--- {
--- memcpy(pm_msg->dev_name, nesvnic->nesibdev->ibdev.name,
--- IWPM_DEVNAME_SIZE);
--- memcpy(pm_msg->if_name, nesvnic->netdev->name, IWPM_IFNAME_SIZE);
--- }
---
--- static void record_sockaddr_info(struct sockaddr_storage *addr_info,
--- nes_addr_t *ip_addr, u16 *port_num)
--- {
--- struct sockaddr_in *in_addr = (struct sockaddr_in *)addr_info;
---
--- if (in_addr->sin_family == AF_INET) {
--- *ip_addr = ntohl(in_addr->sin_addr.s_addr);
--- *port_num = ntohs(in_addr->sin_port);
--- }
--- }
---
--- /*
--- * nes_record_pm_msg - Save the received mapping info
--- */
--- static void nes_record_pm_msg(struct nes_cm_info *cm_info,
--- struct iwpm_sa_data *pm_msg)
--- {
--- record_sockaddr_info(&pm_msg->mapped_loc_addr,
--- &cm_info->mapped_loc_addr, &cm_info->mapped_loc_port);
---
--- record_sockaddr_info(&pm_msg->mapped_rem_addr,
--- &cm_info->mapped_rem_addr, &cm_info->mapped_rem_port);
--- }
---
--- /*
--- * nes_get_reminfo - Get the address info of the remote connecting peer
--- */
--- static int nes_get_remote_addr(struct nes_cm_node *cm_node)
--- {
--- struct sockaddr_storage mapped_loc_addr, mapped_rem_addr;
--- struct sockaddr_storage remote_addr;
--- int ret;
---
--- nes_create_sockaddr(htonl(cm_node->mapped_loc_addr),
--- htons(cm_node->mapped_loc_port), &mapped_loc_addr);
--- nes_create_sockaddr(htonl(cm_node->mapped_rem_addr),
--- htons(cm_node->mapped_rem_port), &mapped_rem_addr);
---
--- ret = iwpm_get_remote_info(&mapped_loc_addr, &mapped_rem_addr,
--- &remote_addr, RDMA_NL_NES);
--- if (ret)
--- nes_debug(NES_DBG_CM, "Unable to find remote peer address info\n");
--- else
--- record_sockaddr_info(&remote_addr, &cm_node->rem_addr,
--- &cm_node->rem_port);
--- return ret;
--- }
---
/**
* print_core - dump a cm core
*/
loc_addr, loc_port,
cm_node->rem_addr, cm_node->rem_port,
rem_addr, rem_port);
--- if ((cm_node->mapped_loc_addr == loc_addr) &&
--- (cm_node->mapped_loc_port == loc_port) &&
--- (cm_node->mapped_rem_addr == rem_addr) &&
--- (cm_node->mapped_rem_port == rem_port)) {
---
+++ if ((cm_node->loc_addr == loc_addr) &&
+++ (cm_node->loc_port == loc_port) &&
+++ (cm_node->rem_addr == rem_addr) &&
+++ (cm_node->rem_port == rem_port)) {
add_ref_cm_node(cm_node);
spin_unlock_irqrestore(&cm_core->ht_lock, flags);
return cm_node;
* find_listener - find a cm node listening on this addr-port pair
*/
static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
--- nes_addr_t dst_addr, u16 dst_port,
--- enum nes_cm_listener_state listener_state, int local)
+++ nes_addr_t dst_addr, u16 dst_port,
+++ enum nes_cm_listener_state listener_state)
{
unsigned long flags;
struct nes_cm_listener *listen_node;
/* walk list and find cm_node associated with this session ID */
spin_lock_irqsave(&cm_core->listen_list_lock, flags);
list_for_each_entry(listen_node, &cm_core->listen_list.list, list) {
--- if (local) {
--- listen_addr = listen_node->loc_addr;
--- listen_port = listen_node->loc_port;
--- } else {
--- listen_addr = listen_node->mapped_loc_addr;
--- listen_port = listen_node->mapped_loc_port;
--- }
+++ listen_addr = listen_node->loc_addr;
+++ listen_port = listen_node->loc_port;
+++
/* compare node pair, return node handle if a match */
if (((listen_addr == dst_addr) ||
listen_addr == 0x00000000) &&
if (listener->nesvnic) {
nes_manage_apbvt(listener->nesvnic,
--- listener->mapped_loc_port,
+++ listener->loc_port,
PCI_FUNC(listener->nesvnic->nesdev->pcidev->devfn),
NES_MANAGE_APBVT_DEL);
--- nes_remove_mapinfo(listener->loc_addr,
--- listener->loc_port,
--- listener->mapped_loc_addr,
--- listener->mapped_loc_port);
nes_debug(NES_DBG_NLMSG,
--- "Delete APBVT mapped_loc_port = %04X\n",
--- listener->mapped_loc_port);
+++ "Delete APBVT loc_port = %04X\n",
+++ listener->loc_port);
}
nes_debug(NES_DBG_CM, "destroying listener (%p)\n", listener);
cm_node->rem_addr = cm_info->rem_addr;
cm_node->rem_port = cm_info->rem_port;
--- cm_node->mapped_loc_addr = cm_info->mapped_loc_addr;
--- cm_node->mapped_rem_addr = cm_info->mapped_rem_addr;
--- cm_node->mapped_loc_port = cm_info->mapped_loc_port;
--- cm_node->mapped_rem_port = cm_info->mapped_rem_port;
---
cm_node->mpa_frame_rev = mpa_version;
cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
cm_node->mpav2_ird_ord = 0;
cm_node->loopbackpartner = NULL;
/* get the mac addr for the remote node */
--- oldarpindex = nes_arp_table(nesdev, cm_node->mapped_rem_addr,
--- NULL, NES_ARP_RESOLVE);
--- arpindex = nes_addr_resolve_neigh(nesvnic,
--- cm_node->mapped_rem_addr, oldarpindex);
+++ oldarpindex = nes_arp_table(nesdev, cm_node->rem_addr,
+++ NULL, NES_ARP_RESOLVE);
+++ arpindex = nes_addr_resolve_neigh(nesvnic, cm_node->rem_addr,
+++ oldarpindex);
if (arpindex < 0) {
kfree(cm_node);
return NULL;
mini_cm_dec_refcnt_listen(cm_core, cm_node->listener, 0);
} else {
if (cm_node->apbvt_set && cm_node->nesvnic) {
--- nes_manage_apbvt(cm_node->nesvnic, cm_node->mapped_loc_port,
+++ nes_manage_apbvt(cm_node->nesvnic, cm_node->loc_port,
PCI_FUNC(cm_node->nesvnic->nesdev->pcidev->devfn),
NES_MANAGE_APBVT_DEL);
}
--- nes_debug(NES_DBG_NLMSG, "Delete APBVT mapped_loc_port = %04X\n",
--- cm_node->mapped_loc_port);
--- nes_remove_mapinfo(cm_node->loc_addr, cm_node->loc_port,
--- cm_node->mapped_loc_addr, cm_node->mapped_loc_port);
+++ nes_debug(NES_DBG_NLMSG, "Delete APBVT loc_port = %04X\n",
+++ cm_node->loc_port);
}
atomic_dec(&cm_core->node_cnt);
cm_node->state = NES_CM_STATE_ESTABLISHED;
if (datasize) {
cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
--- nes_get_remote_addr(cm_node);
handle_rcv_mpa(cm_node, skb);
} else { /* rcvd ACK only */
dev_kfree_skb_any(skb);
struct nes_vnic *nesvnic, struct nes_cm_info *cm_info)
{
struct nes_cm_listener *listener;
--- struct iwpm_dev_data pm_reg_msg;
--- struct iwpm_sa_data pm_msg;
unsigned long flags;
--- int iwpm_err = 0;
nes_debug(NES_DBG_CM, "Search for 0x%08x : 0x%04x\n",
cm_info->loc_addr, cm_info->loc_port);
/* cannot have multiple matching listeners */
listener = find_listener(cm_core, cm_info->loc_addr, cm_info->loc_port,
--- NES_CM_LISTENER_EITHER_STATE, 1);
+++ NES_CM_LISTENER_EITHER_STATE);
if (listener && listener->listener_state == NES_CM_LISTENER_ACTIVE_STATE) {
/* find automatically incs ref count ??? */
}
if (!listener) {
--- nes_form_reg_msg(nesvnic, &pm_reg_msg);
--- iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_NES);
--- if (iwpm_err) {
--- nes_debug(NES_DBG_NLMSG,
--- "Port Mapper reg pid fail (err = %d).\n", iwpm_err);
--- }
--- if (iwpm_valid_pid() && !iwpm_err) {
--- nes_form_pm_msg(cm_info, &pm_msg);
--- iwpm_err = iwpm_add_mapping(&pm_msg, RDMA_NL_NES);
--- if (iwpm_err)
--- nes_debug(NES_DBG_NLMSG,
--- "Port Mapper query fail (err = %d).\n", iwpm_err);
--- else
--- nes_record_pm_msg(cm_info, &pm_msg);
--- }
---
/* create a CM listen node (1/2 node to compare incoming traffic to) */
listener = kzalloc(sizeof(*listener), GFP_ATOMIC);
if (!listener) {
listener->loc_addr = cm_info->loc_addr;
listener->loc_port = cm_info->loc_port;
--- listener->mapped_loc_addr = cm_info->mapped_loc_addr;
--- listener->mapped_loc_port = cm_info->mapped_loc_port;
listener->reused_node = 0;
atomic_set(&listener->ref_count, 1);
if (cm_info->loc_addr == cm_info->rem_addr) {
loopbackremotelistener = find_listener(cm_core,
--- cm_node->mapped_loc_addr, cm_node->mapped_rem_port,
--- NES_CM_LISTENER_ACTIVE_STATE, 0);
+++ cm_node->loc_addr, cm_node->rem_port,
+++ NES_CM_LISTENER_ACTIVE_STATE);
if (loopbackremotelistener == NULL) {
create_event(cm_node, NES_CM_EVENT_ABORTED);
} else {
loopback_cm_info = *cm_info;
loopback_cm_info.loc_port = cm_info->rem_port;
loopback_cm_info.rem_port = cm_info->loc_port;
--- loopback_cm_info.mapped_loc_port =
--- cm_info->mapped_rem_port;
--- loopback_cm_info.mapped_rem_port =
--- cm_info->mapped_loc_port;
+++ loopback_cm_info.loc_port =
+++ cm_info->rem_port;
+++ loopback_cm_info.rem_port =
+++ cm_info->loc_port;
loopback_cm_info.cm_id = loopbackremotelistener->cm_id;
loopbackremotenode = make_cm_node(cm_core, nesvnic,
&loopback_cm_info, loopbackremotelistener);
nfo.rem_addr = ntohl(iph->saddr);
nfo.rem_port = ntohs(tcph->source);
--- /* If port mapper is available these should be mapped address info */
--- nfo.mapped_loc_addr = ntohl(iph->daddr);
--- nfo.mapped_loc_port = ntohs(tcph->dest);
--- nfo.mapped_rem_addr = ntohl(iph->saddr);
--- nfo.mapped_rem_port = ntohs(tcph->source);
---
tmp_daddr = cpu_to_be32(iph->daddr);
tmp_saddr = cpu_to_be32(iph->saddr);
do {
cm_node = find_node(cm_core,
--- nfo.mapped_rem_port, nfo.mapped_rem_addr,
--- nfo.mapped_loc_port, nfo.mapped_loc_addr);
+++ nfo.rem_port, nfo.rem_addr,
+++ nfo.loc_port, nfo.loc_addr);
if (!cm_node) {
/* Only type of packet accepted are for */
skb_handled = 0;
break;
}
--- listener = find_listener(cm_core, nfo.mapped_loc_addr,
--- nfo.mapped_loc_port,
--- NES_CM_LISTENER_ACTIVE_STATE, 0);
+++ listener = find_listener(cm_core, nfo.loc_addr,
+++ nfo.loc_port,
+++ NES_CM_LISTENER_ACTIVE_STATE);
if (!listener) {
nfo.cm_id = NULL;
nfo.conn_type = 0;
nes_debug(NES_DBG_CM, "Enable QUEUE EVENTS\n");
cm_core->event_wq = create_singlethread_workqueue("nesewq");
+ ++ if (!cm_core->event_wq)
+ ++ goto out_free_cmcore;
cm_core->post_event = nes_cm_post_event;
nes_debug(NES_DBG_CM, "Enable QUEUE DISCONNECTS\n");
cm_core->disconn_wq = create_singlethread_workqueue("nesdwq");
+ ++ if (!cm_core->disconn_wq)
+ ++ goto out_free_wq;
print_core(cm_core);
return cm_core;
+ ++
+ ++out_free_wq:
+ ++ destroy_workqueue(cm_core->event_wq);
+ ++out_free_cmcore:
+ ++ kfree(cm_core);
+ ++ return NULL;
}
atomic_inc(&cm_disconnects);
cm_event.event = IW_CM_EVENT_DISCONNECT;
cm_event.status = disconn_status;
--- cm_event.local_addr = cm_id->local_addr;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.local_addr = cm_id->m_local_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = NULL;
cm_event.private_data_len = 0;
cm_event.event = IW_CM_EVENT_CLOSE;
cm_event.status = 0;
cm_event.provider_data = cm_id->provider_data;
--- cm_event.local_addr = cm_id->local_addr;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.local_addr = cm_id->m_local_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = NULL;
cm_event.private_data_len = 0;
u8 *start_ptr = &start_addr;
u8 **start_buff = &start_ptr;
u16 buff_len = 0;
--- struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr;
--- struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr;
+++ struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
+++ struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->m_remote_addr;
ibqp = nes_get_qp(cm_id->device, conn_param->qpn);
if (!ibqp)
nes_cm_init_tsa_conn(nesqp, cm_node);
nesqp->nesqp_context->tcpPorts[0] =
--- cpu_to_le16(cm_node->mapped_loc_port);
+++ cpu_to_le16(cm_node->loc_port);
nesqp->nesqp_context->tcpPorts[1] =
--- cpu_to_le16(cm_node->mapped_rem_port);
+++ cpu_to_le16(cm_node->rem_port);
--- nesqp->nesqp_context->ip0 = cpu_to_le32(cm_node->mapped_rem_addr);
+++ nesqp->nesqp_context->ip0 = cpu_to_le32(cm_node->rem_addr);
nesqp->nesqp_context->misc2 |= cpu_to_le32(
(u32)PCI_FUNC(nesdev->pcidev->devfn) <<
memset(&nes_quad, 0, sizeof(nes_quad));
nes_quad.DstIpAdrIndex =
cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24);
--- nes_quad.SrcIpadr = htonl(cm_node->mapped_rem_addr);
--- nes_quad.TcpPorts[0] = htons(cm_node->mapped_rem_port);
--- nes_quad.TcpPorts[1] = htons(cm_node->mapped_loc_port);
+++ nes_quad.SrcIpadr = htonl(cm_node->rem_addr);
+++ nes_quad.TcpPorts[0] = htons(cm_node->rem_port);
+++ nes_quad.TcpPorts[1] = htons(cm_node->loc_port);
/* Produce hash key */
crc_value = get_crc_value(&nes_quad);
cm_event.event = IW_CM_EVENT_ESTABLISHED;
cm_event.status = 0;
cm_event.provider_data = (void *)nesqp;
--- cm_event.local_addr = cm_id->local_addr;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.local_addr = cm_id->m_local_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = NULL;
cm_event.private_data_len = 0;
cm_event.ird = cm_node->ird_size;
struct nes_cm_node *cm_node;
struct nes_cm_info cm_info;
int apbvt_set = 0;
--- struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr;
--- struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr;
--- struct iwpm_dev_data pm_reg_msg;
--- struct iwpm_sa_data pm_msg;
--- int iwpm_err = 0;
+++ struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
+++ struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->m_remote_addr;
if (cm_id->remote_addr.ss_family != AF_INET)
return -ENOSYS;
cm_info.cm_id = cm_id;
cm_info.conn_type = NES_CM_IWARP_CONN_TYPE;
--- /* No port mapper available, go with the specified peer information */
--- cm_info.mapped_loc_addr = cm_info.loc_addr;
--- cm_info.mapped_loc_port = cm_info.loc_port;
--- cm_info.mapped_rem_addr = cm_info.rem_addr;
--- cm_info.mapped_rem_port = cm_info.rem_port;
---
--- nes_form_reg_msg(nesvnic, &pm_reg_msg);
--- iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_NES);
--- if (iwpm_err) {
--- nes_debug(NES_DBG_NLMSG,
--- "Port Mapper reg pid fail (err = %d).\n", iwpm_err);
--- }
--- if (iwpm_valid_pid() && !iwpm_err) {
--- nes_form_pm_msg(&cm_info, &pm_msg);
--- iwpm_err = iwpm_add_and_query_mapping(&pm_msg, RDMA_NL_NES);
--- if (iwpm_err)
--- nes_debug(NES_DBG_NLMSG,
--- "Port Mapper query fail (err = %d).\n", iwpm_err);
--- else
--- nes_record_pm_msg(&cm_info, &pm_msg);
--- }
---
if (laddr->sin_addr.s_addr != raddr->sin_addr.s_addr) {
--- nes_manage_apbvt(nesvnic, cm_info.mapped_loc_port,
--- PCI_FUNC(nesdev->pcidev->devfn), NES_MANAGE_APBVT_ADD);
+++ nes_manage_apbvt(nesvnic, cm_info.loc_port,
+++ PCI_FUNC(nesdev->pcidev->devfn),
+++ NES_MANAGE_APBVT_ADD);
apbvt_set = 1;
}
--- if (nes_create_mapinfo(&cm_info))
--- return -ENOMEM;
---
cm_id->add_ref(cm_id);
/* create a connect CM node connection */
&cm_info);
if (!cm_node) {
if (apbvt_set)
--- nes_manage_apbvt(nesvnic, cm_info.mapped_loc_port,
+++ nes_manage_apbvt(nesvnic, cm_info.loc_port,
PCI_FUNC(nesdev->pcidev->devfn),
NES_MANAGE_APBVT_DEL);
--- nes_debug(NES_DBG_NLMSG, "Delete mapped_loc_port = %04X\n",
--- cm_info.mapped_loc_port);
--- nes_remove_mapinfo(cm_info.loc_addr, cm_info.loc_port,
--- cm_info.mapped_loc_addr, cm_info.mapped_loc_port);
+++ nes_debug(NES_DBG_NLMSG, "Delete loc_port = %04X\n",
+++ cm_info.loc_port);
cm_id->rem_ref(cm_id);
return -ENOMEM;
}
struct nes_cm_listener *cm_node;
struct nes_cm_info cm_info;
int err;
--- struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr;
+++ struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
nes_debug(NES_DBG_CM, "cm_id = %p, local port = 0x%04X.\n",
cm_id, ntohs(laddr->sin_port));
--- if (cm_id->local_addr.ss_family != AF_INET)
+++ if (cm_id->m_local_addr.ss_family != AF_INET)
return -ENOSYS;
nesvnic = to_nesvnic(cm_id->device);
if (!nesvnic)
cm_info.conn_type = NES_CM_IWARP_CONN_TYPE;
--- /* No port mapper available, go with the specified info */
--- cm_info.mapped_loc_addr = cm_info.loc_addr;
--- cm_info.mapped_loc_port = cm_info.loc_port;
---
cm_node = g_cm_core->api->listen(g_cm_core, nesvnic, &cm_info);
if (!cm_node) {
printk(KERN_ERR "%s[%u] Error returned from listen API call\n",
cm_node->tos = cm_id->tos;
if (!cm_node->reused_node) {
--- if (nes_create_mapinfo(&cm_info))
--- return -ENOMEM;
---
--- err = nes_manage_apbvt(nesvnic, cm_node->mapped_loc_port,
+++ err = nes_manage_apbvt(nesvnic, cm_node->loc_port,
PCI_FUNC(nesvnic->nesdev->pcidev->devfn),
NES_MANAGE_APBVT_ADD);
if (err) {
nesvnic = to_nesvnic(nesqp->ibqp.device);
nesdev = nesvnic->nesdev;
nesadapter = nesdev->nesadapter;
--- laddr = (struct sockaddr_in *)&cm_id->local_addr;
--- raddr = (struct sockaddr_in *)&cm_id->remote_addr;
+++ laddr = (struct sockaddr_in *)&cm_id->m_local_addr;
+++ raddr = (struct sockaddr_in *)&cm_id->m_remote_addr;
cm_event_laddr = (struct sockaddr_in *)&cm_event.local_addr;
if (nesqp->destroyed)
/* set the QP tsa context */
nesqp->nesqp_context->tcpPorts[0] =
--- cpu_to_le16(cm_node->mapped_loc_port);
+++ cpu_to_le16(cm_node->loc_port);
nesqp->nesqp_context->tcpPorts[1] =
--- cpu_to_le16(cm_node->mapped_rem_port);
--- nesqp->nesqp_context->ip0 = cpu_to_le32(cm_node->mapped_rem_addr);
+++ cpu_to_le16(cm_node->rem_port);
+++ nesqp->nesqp_context->ip0 = cpu_to_le32(cm_node->rem_addr);
nesqp->nesqp_context->misc2 |= cpu_to_le32(
(u32)PCI_FUNC(nesdev->pcidev->devfn) <<
nes_quad.DstIpAdrIndex =
cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24);
--- nes_quad.SrcIpadr = htonl(cm_node->mapped_rem_addr);
--- nes_quad.TcpPorts[0] = htons(cm_node->mapped_rem_port);
--- nes_quad.TcpPorts[1] = htons(cm_node->mapped_loc_port);
+++ nes_quad.SrcIpadr = htonl(cm_node->rem_addr);
+++ nes_quad.TcpPorts[0] = htons(cm_node->rem_port);
+++ nes_quad.TcpPorts[1] = htons(cm_node->loc_port);
/* Produce hash key */
crc_value = get_crc_value(&nes_quad);
cm_event.provider_data = cm_id->provider_data;
cm_event_laddr->sin_family = AF_INET;
cm_event_laddr->sin_port = laddr->sin_port;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = (void *)event->cm_node->mpa_frame_buf;
cm_event.private_data_len = (u8)event->cm_node->mpa_frame_size;
cm_event.ird = cm_node->ird_size;
cm_event.ord = cm_node->ord_size;
--- cm_event_laddr->sin_addr.s_addr = htonl(event->cm_info.rem_addr);
+++ cm_event_laddr->sin_addr.s_addr = htonl(event->cm_info.loc_addr);
ret = cm_id->event_handler(cm_id, &cm_event);
nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret);
cm_event.event = IW_CM_EVENT_CONNECT_REPLY;
cm_event.status = -ECONNRESET;
cm_event.provider_data = cm_id->provider_data;
--- cm_event.local_addr = cm_id->local_addr;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.local_addr = cm_id->m_local_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = NULL;
cm_event.private_data_len = 0;
cm_event.event = IW_CM_EVENT_DISCONNECT;
cm_event.status = -ECONNRESET;
cm_event.provider_data = cm_id->provider_data;
--- cm_event.local_addr = cm_id->local_addr;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.local_addr = cm_id->m_local_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = NULL;
cm_event.private_data_len = 0;
cm_event.event = IW_CM_EVENT_CLOSE;
cm_event.status = 0;
cm_event.provider_data = cm_id->provider_data;
--- cm_event.local_addr = cm_id->local_addr;
--- cm_event.remote_addr = cm_id->remote_addr;
+++ cm_event.local_addr = cm_id->m_local_addr;
+++ cm_event.remote_addr = cm_id->m_remote_addr;
cm_event.private_data = NULL;
cm_event.private_data_len = 0;
nes_debug(NES_DBG_CM, "NODE %p Generating CLOSE\n", event->cm_node);
/**
* nes_alloc_mw
*/
---static struct ib_mw *nes_alloc_mw(struct ib_pd *ibpd, enum ib_mw_type type)
+++static struct ib_mw *nes_alloc_mw(struct ib_pd *ibpd, enum ib_mw_type type,
+++ struct ib_udata *udata)
{
struct nes_pd *nespd = to_nespd(ibpd);
struct nes_vnic *nesvnic = to_nesvnic(ibpd->device);
nesibdev->ibdev.iwcm->create_listen = nes_create_listen;
nesibdev->ibdev.iwcm->destroy_listen = nes_destroy_listen;
nesibdev->ibdev.get_port_immutable = nes_port_immutable;
+++ memcpy(nesibdev->ibdev.iwcm->ifname, netdev->name,
+++ sizeof(nesibdev->ibdev.iwcm->ifname));
return nesibdev;
}
projects / karo-tx-linux.git / commitdiff