Lines Matching defs:cm_node
25 * @cm_node: connection's node
29 static void irdma_record_ird_ord(struct irdma_cm_node *cm_node, u32 conn_ird,
32 if (conn_ird > cm_node->dev->hw_attrs.max_hw_ird)
33 conn_ird = cm_node->dev->hw_attrs.max_hw_ird;
35 if (conn_ord > cm_node->dev->hw_attrs.max_hw_ord)
36 conn_ord = cm_node->dev->hw_attrs.max_hw_ord;
37 else if (!conn_ord && cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO)
39 cm_node->ird_size = conn_ird;
40 cm_node->ord_size = conn_ord;
71 * @cm_node: contains ip/tcp info
72 * @cm_info: to get a copy of the cm_node ip/tcp info
74 static void irdma_get_addr_info(struct irdma_cm_node *cm_node,
78 cm_info->ipv4 = cm_node->ipv4;
79 cm_info->vlan_id = cm_node->vlan_id;
80 memcpy(cm_info->loc_addr, cm_node->loc_addr, sizeof(cm_info->loc_addr));
81 memcpy(cm_info->rem_addr, cm_node->rem_addr, sizeof(cm_info->rem_addr));
82 cm_info->loc_port = cm_node->loc_port;
83 cm_info->rem_port = cm_node->rem_port;
88 * @cm_node: connection's node
91 static inline void irdma_fill_sockaddr4(struct irdma_cm_node *cm_node,
100 laddr->sin_port = htons(cm_node->loc_port);
101 raddr->sin_port = htons(cm_node->rem_port);
103 laddr->sin_addr.s_addr = htonl(cm_node->loc_addr[0]);
104 raddr->sin_addr.s_addr = htonl(cm_node->rem_addr[0]);
109 * @cm_node: connection's node
112 static inline void irdma_fill_sockaddr6(struct irdma_cm_node *cm_node,
121 laddr6->sin6_port = htons(cm_node->loc_port);
122 raddr6->sin6_port = htons(cm_node->rem_port);
125 cm_node->loc_addr);
127 cm_node->rem_addr);
132 * @cm_node: connection's node
136 static inline void irdma_get_cmevent_info(struct irdma_cm_node *cm_node,
144 if (cm_node) {
145 event->private_data = cm_node->pdata_buf;
146 event->private_data_len = (u8)cm_node->pdata.size;
147 event->ird = cm_node->ird_size;
148 event->ord = cm_node->ord_size;
154 * @cm_node: connection's node
159 static int irdma_send_cm_event(struct irdma_cm_node *cm_node,
167 trace_irdma_send_cm_event(cm_node, cm_id, type, status,
170 ibdev_dbg(&cm_node->iwdev->ibdev,
171 "CM: cm_node %p cm_id=%p state=%d accel=%d event_type=%d status=%d\n",
172 cm_node, cm_id, cm_node->accelerated, cm_node->state, type,
177 if (cm_node->ipv4)
178 irdma_fill_sockaddr4(cm_node, &event);
180 irdma_fill_sockaddr6(cm_node, &event);
181 event.provider_data = cm_node;
182 event.private_data = cm_node->pdata_buf;
183 event.private_data_len = (u8)cm_node->pdata.size;
184 event.ird = cm_node->ird_size;
187 irdma_get_cmevent_info(cm_node, cm_id, &event);
190 event.ird = cm_node->ird_size;
191 event.ord = cm_node->ord_size;
196 if (!cm_node->accelerated)
197 wait_for_completion(&cm_node->establish_comp);
209 * @timer_list: a timer list to which cm_node will be selected
214 struct irdma_cm_node *cm_node;
217 hash_for_each_rcu(cm_core->cm_hash_tbl, bkt, cm_node, list) {
218 if ((cm_node->close_entry || cm_node->send_entry) &&
219 refcount_inc_not_zero(&cm_node->refcnt))
220 list_add(&cm_node->timer_entry, timer_list);
226 * @cm_node: connection's node
229 static struct irdma_cm_event *irdma_create_event(struct irdma_cm_node *cm_node,
234 if (!cm_node->cm_id)
243 event->cm_node = cm_node;
244 memcpy(event->cm_info.rem_addr, cm_node->rem_addr,
246 memcpy(event->cm_info.loc_addr, cm_node->loc_addr,
248 event->cm_info.rem_port = cm_node->rem_port;
249 event->cm_info.loc_port = cm_node->loc_port;
250 event->cm_info.cm_id = cm_node->cm_id;
251 ibdev_dbg(&cm_node->iwdev->ibdev,
252 "CM: node=%p event=%p type=%u dst=%pI4 src=%pI4\n", cm_node,
255 trace_irdma_create_event(cm_node, type, __builtin_return_address(0));
263 * @cm_node: connection's node
265 static void irdma_free_retrans_entry(struct irdma_cm_node *cm_node)
267 struct irdma_device *iwdev = cm_node->iwdev;
270 send_entry = cm_node->send_entry;
274 cm_node->send_entry = NULL;
277 refcount_dec(&cm_node->refcnt);
282 * @cm_node: connection's node
284 static void irdma_cleanup_retrans_entry(struct irdma_cm_node *cm_node)
288 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
289 irdma_free_retrans_entry(cm_node);
290 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
295 * @cm_node: connection's node ionfo to use in frame
301 static struct irdma_puda_buf *irdma_form_ah_cm_frame(struct irdma_cm_node *cm_node,
308 struct irdma_sc_vsi *vsi = &cm_node->iwdev->vsi;
316 if (!cm_node->ah || !cm_node->ah->ah_info.ah_valid) {
317 ibdev_dbg(&cm_node->iwdev->ibdev, "CM: AH invalid\n");
323 ibdev_dbg(&cm_node->iwdev->ibdev, "CM: SQ buf NULL\n");
327 sqbuf->ah_id = cm_node->ah->ah_info.ah_idx;
344 sqbuf->scratch = cm_node;
349 tcph->source = htons(cm_node->loc_port);
350 tcph->dest = htons(cm_node->rem_port);
351 tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num);
354 cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt;
355 tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num);
362 cm_node->tcp_cntxt.loc_seq_num++;
365 cm_node->tcp_cntxt.loc_seq_num += hdr_len + pd_len;
369 cm_node->tcp_cntxt.loc_seq_num++;
378 tcph->window = htons(cm_node->tcp_cntxt.rcv_wnd);
404 * @cm_node: connection's node ionfo to use in frame
410 static struct irdma_puda_buf *irdma_form_uda_cm_frame(struct irdma_cm_node *cm_node,
417 struct irdma_sc_vsi *vsi = &cm_node->iwdev->vsi;
447 if (cm_node->vlan_id < VLAN_N_VID)
450 if (cm_node->ipv4)
461 sqbuf->scratch = cm_node;
466 if (cm_node->do_lpb)
469 if (cm_node->ipv4) {
477 ether_addr_copy(ethh->h_dest, cm_node->rem_mac);
478 ether_addr_copy(ethh->h_source, cm_node->loc_mac);
479 if (cm_node->vlan_id < VLAN_N_VID) {
482 vtag = (cm_node->user_pri << VLAN_PRIO_SHIFT) |
483 cm_node->vlan_id;
494 iph->tos = cm_node->tos;
496 iph->id = htons(++cm_node->tcp_cntxt.loc_id);
501 iph->saddr = htonl(cm_node->loc_addr[0]);
502 iph->daddr = htonl(cm_node->rem_addr[0]);
510 ether_addr_copy(ethh->h_dest, cm_node->rem_mac);
511 ether_addr_copy(ethh->h_source, cm_node->loc_mac);
512 if (cm_node->vlan_id < VLAN_N_VID) {
515 vtag = (cm_node->user_pri << VLAN_PRIO_SHIFT) |
516 cm_node->vlan_id;
524 ip6h->priority = cm_node->tos >> 4;
525 ip6h->flow_lbl[0] = cm_node->tos << 4;
532 cm_node->loc_addr);
534 cm_node->rem_addr);
537 tcph->source = htons(cm_node->loc_port);
538 tcph->dest = htons(cm_node->rem_port);
539 tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num);
542 cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt;
543 tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num);
550 cm_node->tcp_cntxt.loc_seq_num++;
553 cm_node->tcp_cntxt.loc_seq_num += hdr_len + pd_len;
557 cm_node->tcp_cntxt.loc_seq_num++;
566 tcph->window = htons(cm_node->tcp_cntxt.rcv_wnd);
591 * @cm_node: connection's node
593 int irdma_send_reset(struct irdma_cm_node *cm_node)
598 trace_irdma_send_reset(cm_node, 0, __builtin_return_address(0));
599 sqbuf = cm_node->cm_core->form_cm_frame(cm_node, NULL, NULL, NULL,
604 ibdev_dbg(&cm_node->iwdev->ibdev,
605 "CM: caller: %pS cm_node %p cm_id=%p accel=%d state=%d rem_port=0x%04x, loc_port=0x%04x rem_addr=%pI4 loc_addr=%pI4\n",
606 __builtin_return_address(0), cm_node, cm_node->cm_id,
607 cm_node->accelerated, cm_node->state, cm_node->rem_port,
608 cm_node->loc_port, cm_node->rem_addr, cm_node->loc_addr);
610 return irdma_schedule_cm_timer(cm_node, sqbuf, IRDMA_TIMER_TYPE_SEND, 0,
616 * @cm_node: connection's node
619 static void irdma_active_open_err(struct irdma_cm_node *cm_node, bool reset)
621 trace_irdma_active_open_err(cm_node, reset,
623 irdma_cleanup_retrans_entry(cm_node);
624 cm_node->cm_core->stats_connect_errs++;
626 ibdev_dbg(&cm_node->iwdev->ibdev,
627 "CM: cm_node=%p state=%d\n", cm_node,
628 cm_node->state);
629 refcount_inc(&cm_node->refcnt);
630 irdma_send_reset(cm_node);
633 cm_node->state = IRDMA_CM_STATE_CLOSED;
634 irdma_create_event(cm_node, IRDMA_CM_EVENT_ABORTED);
639 * @cm_node: connection's node
640 * @reset: send reset or just free cm_node
642 static void irdma_passive_open_err(struct irdma_cm_node *cm_node, bool reset)
644 irdma_cleanup_retrans_entry(cm_node);
645 cm_node->cm_core->stats_passive_errs++;
646 cm_node->state = IRDMA_CM_STATE_CLOSED;
647 ibdev_dbg(&cm_node->iwdev->ibdev, "CM: cm_node=%p state =%d\n",
648 cm_node, cm_node->state);
649 trace_irdma_passive_open_err(cm_node, reset,
652 irdma_send_reset(cm_node);
654 irdma_rem_ref_cm_node(cm_node);
666 cm_id = event->cm_node->cm_id;
677 irdma_send_cm_event(event->cm_node, cm_id, IW_CM_EVENT_CONNECT_REPLY,
679 irdma_rem_ref_cm_node(event->cm_node);
684 * @cm_node: connection's node
689 static int irdma_process_options(struct irdma_cm_node *cm_node, u8 *optionsloc,
707 ibdev_dbg(&cm_node->iwdev->ibdev,
714 if ((cm_node->ipv4 &&
716 (!cm_node->ipv4 &&
719 if (tmp < cm_node->tcp_cntxt.mss)
720 cm_node->tcp_cntxt.mss = tmp;
723 cm_node->tcp_cntxt.snd_wscale =
727 ibdev_dbg(&cm_node->iwdev->ibdev,
735 cm_node->tcp_cntxt.mss = IRDMA_CM_DEFAULT_MSS;
742 * @cm_node: connection's node
747 static int irdma_handle_tcp_options(struct irdma_cm_node *cm_node,
755 ret = irdma_process_options(cm_node, optionsloc, optionsize,
758 ibdev_dbg(&cm_node->iwdev->ibdev,
759 "CM: Node %p, Sending Reset\n", cm_node);
761 irdma_passive_open_err(cm_node, true);
763 irdma_active_open_err(cm_node, true);
768 cm_node->tcp_cntxt.snd_wnd = ntohs(tcph->window)
769 << cm_node->tcp_cntxt.snd_wscale;
771 if (cm_node->tcp_cntxt.snd_wnd > cm_node->tcp_cntxt.max_snd_wnd)
772 cm_node->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.snd_wnd;
779 * @cm_node: connection's node
783 static void irdma_build_mpa_v1(struct irdma_cm_node *cm_node, void *start_addr,
799 mpa_frame->rev = cm_node->mpa_frame_rev;
800 mpa_frame->priv_data_len = htons(cm_node->pdata.size);
805 * @cm_node: connection's node
809 static void irdma_build_mpa_v2(struct irdma_cm_node *cm_node, void *start_addr,
817 irdma_build_mpa_v1(cm_node, start_addr, mpa_key);
819 if (cm_node->iwdev->iw_ooo) {
821 cm_node->rcv_mark_en = true;
827 if (cm_node->mpav2_ird_ord == IETF_NO_IRD_ORD) {
831 ctrl_ird = (cm_node->ird_size > IETF_NO_IRD_ORD) ?
833 cm_node->ird_size;
834 ctrl_ord = (cm_node->ord_size > IETF_NO_IRD_ORD) ?
836 cm_node->ord_size;
846 switch (cm_node->send_rdma0_op) {
864 * @cm_node: connection's node
868 static int irdma_cm_build_mpa_frame(struct irdma_cm_node *cm_node,
873 switch (cm_node->mpa_frame_rev) {
876 irdma_build_mpa_v1(cm_node, mpa->addr, mpa_key);
880 irdma_build_mpa_v2(cm_node, mpa->addr, mpa_key);
891 * @cm_node: connection's node
893 static int irdma_send_mpa_request(struct irdma_cm_node *cm_node)
897 cm_node->mpa_hdr.addr = &cm_node->mpa_v2_frame;
898 cm_node->mpa_hdr.size = irdma_cm_build_mpa_frame(cm_node,
899 &cm_node->mpa_hdr,
901 if (!cm_node->mpa_hdr.size) {
902 ibdev_dbg(&cm_node->iwdev->ibdev,
903 "CM: mpa size = %d\n", cm_node->mpa_hdr.size);
907 sqbuf = cm_node->cm_core->form_cm_frame(cm_node, NULL,
908 &cm_node->mpa_hdr,
909 &cm_node->pdata, SET_ACK);
913 return irdma_schedule_cm_timer(cm_node, sqbuf, IRDMA_TIMER_TYPE_SEND, 1,
919 * @cm_node: connection's node
923 static int irdma_send_mpa_reject(struct irdma_cm_node *cm_node,
929 cm_node->mpa_hdr.addr = &cm_node->mpa_v2_frame;
930 cm_node->mpa_hdr.size = irdma_cm_build_mpa_frame(cm_node,
931 &cm_node->mpa_hdr,
934 cm_node->mpa_frame.flags |= IETF_MPA_FLAGS_REJECT;
938 sqbuf = cm_node->cm_core->form_cm_frame(cm_node, NULL,
939 &cm_node->mpa_hdr, &priv_info,
944 cm_node->state = IRDMA_CM_STATE_FIN_WAIT1;
946 return irdma_schedule_cm_timer(cm_node, sqbuf, IRDMA_TIMER_TYPE_SEND, 1,
952 * @cm_node: connection's node
955 static int irdma_negotiate_mpa_v2_ird_ord(struct irdma_cm_node *cm_node,
978 cm_node->mpav2_ird_ord = IETF_NO_IRD_ORD;
982 if (cm_node->state != IRDMA_CM_STATE_MPAREQ_SENT) {
985 cm_node->ird_size = 1;
986 if (cm_node->ord_size > ird_size)
987 cm_node->ord_size = ird_size;
994 if (cm_node->ord_size > ird_size)
995 cm_node->ord_size = ird_size;
997 if (cm_node->ird_size < ord_size)
1004 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
1006 cm_node->send_rdma0_op = SEND_RDMA_WRITE_ZERO;
1011 ibdev_dbg(&cm_node->iwdev->ibdev,
1013 cm_node->ord_size, cm_node->ird_size);
1014 trace_irdma_negotiate_mpa_v2(cm_node);
1020 * @cm_node: connection's node
1025 static int irdma_parse_mpa(struct irdma_cm_node *cm_node, u8 *buf, u32 *type,
1034 ibdev_dbg(&cm_node->iwdev->ibdev,
1044 ibdev_dbg(&cm_node->iwdev->ibdev,
1050 ibdev_dbg(&cm_node->iwdev->ibdev,
1055 if (mpa_frame->rev > cm_node->mpa_frame_rev) {
1056 ibdev_dbg(&cm_node->iwdev->ibdev, "CM: rev %d\n",
1061 cm_node->mpa_frame_rev = mpa_frame->rev;
1062 if (cm_node->state != IRDMA_CM_STATE_MPAREQ_SENT) {
1065 ibdev_dbg(&cm_node->iwdev->ibdev,
1072 ibdev_dbg(&cm_node->iwdev->ibdev,
1079 ibdev_dbg(&cm_node->iwdev->ibdev,
1086 ibdev_dbg(&cm_node->iwdev->ibdev,
1094 ret = irdma_negotiate_mpa_v2_ird_ord(cm_node, buf);
1103 memcpy(cm_node->pdata_buf, buf + mpa_hdr_len, priv_data_len);
1104 cm_node->pdata.size = priv_data_len;
1110 cm_node->snd_mark_en = true;
1117 * @cm_node: connection's node
1121 * @close_when_complete: is cm_node to be removed
1123 * note - cm_node needs to be protected before calling this. Encase in:
1124 * irdma_rem_ref_cm_node(cm_core, cm_node);
1126 * refcount_inc(&cm_node->refcnt);
1128 int irdma_schedule_cm_timer(struct irdma_cm_node *cm_node,
1133 struct irdma_sc_vsi *vsi = &cm_node->iwdev->vsi;
1134 struct irdma_cm_core *cm_core = cm_node->cm_core;
1156 if (cm_node->close_entry) {
1158 ibdev_dbg(&cm_node->iwdev->ibdev,
1163 cm_node->close_entry = new_send;
1165 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1166 cm_node->send_entry = new_send;
1167 refcount_inc(&cm_node->refcnt);
1168 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1174 irdma_cleanup_retrans_entry(cm_node);
1176 irdma_rem_ref_cm_node(cm_node);
1195 * @cm_node: connection's node
1197 static void irdma_retrans_expired(struct irdma_cm_node *cm_node)
1199 enum irdma_cm_node_state state = cm_node->state;
1201 cm_node->state = IRDMA_CM_STATE_CLOSED;
1205 irdma_rem_ref_cm_node(cm_node);
1209 irdma_send_reset(cm_node);
1212 refcount_inc(&cm_node->refcnt);
1213 irdma_send_reset(cm_node);
1214 irdma_create_event(cm_node, IRDMA_CM_EVENT_ABORTED);
1221 * @cm_node: connection's node
1222 * @rem_node: flag for remove cm_node
1224 static void irdma_handle_close_entry(struct irdma_cm_node *cm_node,
1227 struct irdma_timer_entry *close_entry = cm_node->close_entry;
1248 irdma_rem_ref_cm_node(cm_node);
1252 cm_node->close_entry = NULL;
1262 struct irdma_cm_node *cm_node;
1280 cm_node = container_of(list_node, struct irdma_cm_node,
1282 close_entry = cm_node->close_entry;
1292 irdma_handle_close_entry(cm_node, 1);
1296 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1298 send_entry = cm_node->send_entry;
1302 if (cm_node->state != IRDMA_CM_STATE_OFFLOADED) {
1309 irdma_free_retrans_entry(cm_node);
1314 if (cm_node->state == IRDMA_CM_STATE_OFFLOADED ||
1315 cm_node->state == IRDMA_CM_STATE_CLOSED) {
1316 irdma_free_retrans_entry(cm_node);
1321 irdma_free_retrans_entry(cm_node);
1323 spin_unlock_irqrestore(&cm_node->retrans_list_lock,
1325 irdma_retrans_expired(cm_node);
1326 cm_node->state = IRDMA_CM_STATE_CLOSED;
1327 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1330 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1332 vsi = &cm_node->iwdev->vsi;
1333 if (!cm_node->ack_rcvd) {
1336 cm_node->cm_core->stats_pkt_retrans++;
1339 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1356 irdma_free_retrans_entry(cm_node);
1358 irdma_rem_ref_cm_node(cm_node);
1361 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1362 irdma_rem_ref_cm_node(cm_node);
1377 * @cm_node: connection's node
1380 int irdma_send_syn(struct irdma_cm_node *cm_node, u32 sendack)
1393 if (!cm_node)
1399 options->mss.mss = htons(cm_node->tcp_cntxt.mss);
1405 options->windowscale.shiftcount = cm_node->tcp_cntxt.rcv_wscale;
1416 sqbuf = cm_node->cm_core->form_cm_frame(cm_node, &opts, NULL, NULL,
1421 return irdma_schedule_cm_timer(cm_node, sqbuf, IRDMA_TIMER_TYPE_SEND, 1,
1427 * @cm_node: connection's node
1429 void irdma_send_ack(struct irdma_cm_node *cm_node)
1432 struct irdma_sc_vsi *vsi = &cm_node->iwdev->vsi;
1434 sqbuf = cm_node->cm_core->form_cm_frame(cm_node, NULL, NULL, NULL,
1442 * @cm_node: connection's node
1444 static int irdma_send_fin(struct irdma_cm_node *cm_node)
1448 sqbuf = cm_node->cm_core->form_cm_frame(cm_node, NULL, NULL, NULL,
1453 return irdma_schedule_cm_timer(cm_node, sqbuf, IRDMA_TIMER_TYPE_SEND, 1,
1477 /* walk list and find cm_node associated with this session ID */
1846 * @reset_list: a list to which cm_node will be selected
1852 struct irdma_cm_node *cm_node;
1855 hash_for_each_rcu(cm_core->cm_hash_tbl, bkt, cm_node, list) {
1856 if (cm_node->listener == listener &&
1857 !cm_node->accelerated &&
1858 refcount_inc_not_zero(&cm_node->refcnt))
1859 list_add(&cm_node->reset_entry, reset_list);
1877 struct irdma_cm_node *cm_node;
1893 cm_node = container_of(list_pos, struct irdma_cm_node,
1895 if (cm_node->state >= IRDMA_CM_STATE_FIN_WAIT1) {
1896 irdma_rem_ref_cm_node(cm_node);
1900 irdma_cleanup_retrans_entry(cm_node);
1901 err = irdma_send_reset(cm_node);
1903 cm_node->state = IRDMA_CM_STATE_CLOSED;
1904 ibdev_dbg(&cm_node->iwdev->ibdev,
1907 old_state = cm_node->state;
1908 cm_node->state = IRDMA_CM_STATE_LISTENER_DESTROYED;
1910 irdma_rem_ref_cm_node(cm_node);
2099 struct irdma_cm_node *cm_node;
2103 hash_for_each_possible_rcu(cm_core->cm_hash_tbl, cm_node, list, key) {
2104 if (cm_node->vlan_id == vlan_id &&
2105 cm_node->loc_port == loc_port && cm_node->rem_port == rem_port &&
2106 !memcmp(cm_node->loc_addr, loc_addr, sizeof(cm_node->loc_addr)) &&
2107 !memcmp(cm_node->rem_addr, rem_addr, sizeof(cm_node->rem_addr))) {
2108 if (!refcount_inc_not_zero(&cm_node->refcnt))
2111 trace_irdma_find_node(cm_node, 0, NULL);
2112 return cm_node;
2126 * @cm_node: connection's node
2129 struct irdma_cm_node *cm_node)
2132 u32 key = (cm_node->rem_port << 16) | cm_node->loc_port;
2135 hash_add_rcu(cm_core->cm_hash_tbl, &cm_node->list, key);
2165 * @cm_node: The connection manager node to create AH for
2168 static int irdma_cm_create_ah(struct irdma_cm_node *cm_node, bool wait)
2171 struct irdma_device *iwdev = cm_node->iwdev;
2176 ah_info.tc_tos = cm_node->tos;
2179 if (cm_node->ipv4) {
2181 ah_info.dest_ip_addr[0] = cm_node->rem_addr[0];
2182 ah_info.src_ip_addr[0] = cm_node->loc_addr[0];
2186 memcpy(ah_info.dest_ip_addr, cm_node->rem_addr,
2188 memcpy(ah_info.src_ip_addr, cm_node->loc_addr,
2194 ah_info.vlan_tag = cm_node->vlan_id;
2195 if (cm_node->vlan_id < VLAN_N_VID) {
2197 ah_info.vlan_tag |= cm_node->user_pri << VLAN_PRIO_SHIFT;
2205 IRDMA_PUDA_RSRC_TYPE_ILQ, cm_node,
2206 &cm_node->ah))
2209 trace_irdma_create_ah(cm_node);
2215 * @cm_node: The connection manager node to create AH for
2217 static void irdma_cm_free_ah(struct irdma_cm_node *cm_node)
2219 struct irdma_device *iwdev = cm_node->iwdev;
2221 trace_irdma_cm_free_ah(cm_node);
2222 irdma_puda_free_ah(&iwdev->rf->sc_dev, cm_node->ah);
2223 cm_node->ah = NULL;
2238 struct irdma_cm_node *cm_node;
2243 /* create an hte and cm_node for this instance */
2244 cm_node = kzalloc(sizeof(*cm_node), GFP_ATOMIC);
2245 if (!cm_node)
2249 cm_node->ipv4 = cm_info->ipv4;
2250 cm_node->vlan_id = cm_info->vlan_id;
2251 if (cm_node->vlan_id >= VLAN_N_VID && iwdev->dcb_vlan_mode)
2252 cm_node->vlan_id = 0;
2253 cm_node->tos = cm_info->tos;
2254 cm_node->user_pri = cm_info->user_pri;
2261 cm_node->user_pri = listener->user_pri;
2263 cm_node->tos = max(listener->tos, cm_info->tos);
2264 cm_node->user_pri = rt_tos2priority(cm_node->tos);
2265 cm_node->user_pri =
2267 cm_node->user_pri,
2271 "DCB: listener: TOS:[%d] UP:[%d]\n", cm_node->tos,
2272 cm_node->user_pri);
2273 trace_irdma_listener_tos(iwdev, cm_node->tos,
2274 cm_node->user_pri);
2276 memcpy(cm_node->loc_addr, cm_info->loc_addr, sizeof(cm_node->loc_addr));
2277 memcpy(cm_node->rem_addr, cm_info->rem_addr, sizeof(cm_node->rem_addr));
2278 cm_node->loc_port = cm_info->loc_port;
2279 cm_node->rem_port = cm_info->rem_port;
2281 cm_node->mpa_frame_rev = IRDMA_CM_DEFAULT_MPA_VER;
2282 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
2283 cm_node->iwdev = iwdev;
2284 cm_node->dev = &iwdev->rf->sc_dev;
2286 cm_node->ird_size = cm_node->dev->hw_attrs.max_hw_ird;
2287 cm_node->ord_size = cm_node->dev->hw_attrs.max_hw_ord;
2289 cm_node->listener = listener;
2290 cm_node->cm_id = cm_info->cm_id;
2291 ether_addr_copy(cm_node->loc_mac, netdev->dev_addr);
2292 spin_lock_init(&cm_node->retrans_list_lock);
2293 cm_node->ack_rcvd = false;
2295 init_completion(&cm_node->establish_comp);
2296 refcount_set(&cm_node->refcnt, 1);
2298 cm_node->cm_core = cm_core;
2299 cm_node->tcp_cntxt.loc_id = IRDMA_CM_DEFAULT_LOCAL_ID;
2300 cm_node->tcp_cntxt.rcv_wscale = iwdev->rcv_wscale;
2301 cm_node->tcp_cntxt.rcv_wnd = iwdev->rcv_wnd >> cm_node->tcp_cntxt.rcv_wscale;
2302 if (cm_node->ipv4) {
2303 cm_node->tcp_cntxt.loc_seq_num = secure_tcp_seq(htonl(cm_node->loc_addr[0]),
2304 htonl(cm_node->rem_addr[0]),
2305 htons(cm_node->loc_port),
2306 htons(cm_node->rem_port));
2307 cm_node->tcp_cntxt.mss = iwdev->vsi.mtu - IRDMA_MTU_TO_MSS_IPV4;
2310 htonl(cm_node->loc_addr[0]), htonl(cm_node->loc_addr[1]),
2311 htonl(cm_node->loc_addr[2]), htonl(cm_node->loc_addr[3])
2314 htonl(cm_node->rem_addr[0]), htonl(cm_node->rem_addr[1]),
2315 htonl(cm_node->rem_addr[2]), htonl(cm_node->rem_addr[3])
2317 cm_node->tcp_cntxt.loc_seq_num = secure_tcpv6_seq(loc, rem,
2318 htons(cm_node->loc_port),
2319 htons(cm_node->rem_port));
2320 cm_node->tcp_cntxt.mss = iwdev->vsi.mtu - IRDMA_MTU_TO_MSS_IPV6;
2323 if ((cm_node->ipv4 &&
2324 irdma_ipv4_is_lpb(cm_node->loc_addr[0], cm_node->rem_addr[0])) ||
2325 (!cm_node->ipv4 &&
2326 irdma_ipv6_is_lpb(cm_node->loc_addr, cm_node->rem_addr))) {
2327 cm_node->do_lpb = true;
2328 arpindex = irdma_arp_table(iwdev->rf, cm_node->rem_addr,
2329 cm_node->ipv4, NULL,
2332 oldarpindex = irdma_arp_table(iwdev->rf, cm_node->rem_addr,
2333 cm_node->ipv4, NULL,
2335 if (cm_node->ipv4)
2352 ether_addr_copy(cm_node->rem_mac,
2354 irdma_add_hte_node(cm_core, cm_node);
2356 return cm_node;
2359 kfree(cm_node);
2364 static void irdma_destroy_connection(struct irdma_cm_node *cm_node)
2366 struct irdma_cm_core *cm_core = cm_node->cm_core;
2371 if (!cm_node->accelerated && cm_node->accept_pend) {
2372 ibdev_dbg(&cm_node->iwdev->ibdev,
2374 atomic_dec(&cm_node->listener->pend_accepts_cnt);
2376 if (cm_node->close_entry)
2377 irdma_handle_close_entry(cm_node, 0);
2378 if (cm_node->listener) {
2379 irdma_dec_refcnt_listen(cm_core, cm_node->listener, 0, true);
2381 if (cm_node->apbvt_set) {
2382 irdma_del_apbvt(cm_node->iwdev, cm_node->apbvt_entry);
2383 cm_node->apbvt_set = 0;
2385 irdma_get_addr_info(cm_node, &nfo);
2386 if (cm_node->qhash_set) {
2387 nfo.qh_qpid = cm_node->iwdev->vsi.ilq->qp_id;
2388 irdma_manage_qhash(cm_node->iwdev, &nfo,
2392 cm_node->qhash_set = 0;
2396 iwqp = cm_node->iwqp;
2398 cm_node->cm_id->rem_ref(cm_node->cm_id);
2399 cm_node->cm_id = NULL;
2402 cm_node->iwqp = NULL;
2403 } else if (cm_node->qhash_set) {
2404 irdma_get_addr_info(cm_node, &nfo);
2405 nfo.qh_qpid = cm_node->iwdev->vsi.ilq->qp_id;
2406 irdma_manage_qhash(cm_node->iwdev, &nfo,
2409 cm_node->qhash_set = 0;
2412 cm_core->cm_free_ah(cm_node);
2417 * @cm_node: connection's node
2419 void irdma_rem_ref_cm_node(struct irdma_cm_node *cm_node)
2421 struct irdma_cm_core *cm_core = cm_node->cm_core;
2424 trace_irdma_rem_ref_cm_node(cm_node, 0, __builtin_return_address(0));
2427 if (!refcount_dec_and_test(&cm_node->refcnt)) {
2431 if (cm_node->iwqp) {
2432 cm_node->iwqp->cm_node = NULL;
2433 cm_node->iwqp->cm_id = NULL;
2435 hash_del_rcu(&cm_node->list);
2436 cm_node->cm_core->stats_nodes_destroyed++;
2440 irdma_destroy_connection(cm_node);
2442 kfree_rcu(cm_node, rcu_head);
2447 * @cm_node: connection's node
2449 static void irdma_handle_fin_pkt(struct irdma_cm_node *cm_node)
2451 switch (cm_node->state) {
2456 cm_node->tcp_cntxt.rcv_nxt++;
2457 irdma_cleanup_retrans_entry(cm_node);
2458 cm_node->state = IRDMA_CM_STATE_LAST_ACK;
2459 irdma_send_fin(cm_node);
2462 irdma_create_event(cm_node, IRDMA_CM_EVENT_ABORTED);
2463 cm_node->tcp_cntxt.rcv_nxt++;
2464 irdma_cleanup_retrans_entry(cm_node);
2465 cm_node->state = IRDMA_CM_STATE_CLOSED;
2466 refcount_inc(&cm_node->refcnt);
2467 irdma_send_reset(cm_node);
2470 cm_node->tcp_cntxt.rcv_nxt++;
2471 irdma_cleanup_retrans_entry(cm_node);
2472 cm_node->state = IRDMA_CM_STATE_CLOSING;
2473 irdma_send_ack(cm_node);
2481 cm_node->tcp_cntxt.rcv_nxt++;
2482 irdma_cleanup_retrans_entry(cm_node);
2483 cm_node->state = IRDMA_CM_STATE_TIME_WAIT;
2484 irdma_send_ack(cm_node);
2485 irdma_schedule_cm_timer(cm_node, NULL, IRDMA_TIMER_TYPE_CLOSE,
2489 cm_node->tcp_cntxt.rcv_nxt++;
2490 irdma_cleanup_retrans_entry(cm_node);
2491 cm_node->state = IRDMA_CM_STATE_CLOSED;
2492 irdma_rem_ref_cm_node(cm_node);
2496 ibdev_dbg(&cm_node->iwdev->ibdev,
2497 "CM: bad state node state = %d\n", cm_node->state);
2504 * @cm_node: connection's node
2507 static void irdma_handle_rst_pkt(struct irdma_cm_node *cm_node,
2510 ibdev_dbg(&cm_node->iwdev->ibdev,
2511 "CM: caller: %pS cm_node=%p state=%d rem_port=0x%04x loc_port=0x%04x rem_addr=%pI4 loc_addr=%pI4\n",
2512 __builtin_return_address(0), cm_node, cm_node->state,
2513 cm_node->rem_port, cm_node->loc_port, cm_node->rem_addr,
2514 cm_node->loc_addr);
2516 irdma_cleanup_retrans_entry(cm_node);
2517 switch (cm_node->state) {
2520 switch (cm_node->mpa_frame_rev) {
2523 cm_node->mpa_frame_rev = IETF_MPA_V1;
2525 cm_node->state = IRDMA_CM_STATE_SYN_SENT;
2526 if (irdma_send_syn(cm_node, 0))
2527 irdma_active_open_err(cm_node, false);
2531 irdma_active_open_err(cm_node, false);
2536 atomic_inc(&cm_node->passive_state);
2541 irdma_passive_open_err(cm_node, false);
2544 irdma_active_open_err(cm_node, false);
2552 cm_node->state = IRDMA_CM_STATE_CLOSED;
2553 irdma_rem_ref_cm_node(cm_node);
2562 * @cm_node: connection's node
2565 static void irdma_handle_rcv_mpa(struct irdma_cm_node *cm_node,
2575 err = irdma_parse_mpa(cm_node, dataloc, &res_type, datasize);
2577 if (cm_node->state == IRDMA_CM_STATE_MPAREQ_SENT)
2578 irdma_active_open_err(cm_node, true);
2580 irdma_passive_open_err(cm_node, true);
2584 switch (cm_node->state) {
2587 ibdev_dbg(&cm_node->iwdev->ibdev,
2589 cm_node->state = IRDMA_CM_STATE_MPAREQ_RCVD;
2591 irdma_send_ack(cm_node); /* ACK received MPA request */
2592 atomic_set(&cm_node->passive_state,
2596 irdma_cleanup_retrans_entry(cm_node);
2599 cm_node->state = IRDMA_CM_STATE_MPAREJ_RCVD;
2602 cm_node->state = IRDMA_CM_STATE_OFFLOADED;
2604 irdma_send_ack(cm_node);
2607 ibdev_dbg(&cm_node->iwdev->ibdev,
2608 "CM: wrong cm_node state =%d\n", cm_node->state);
2611 irdma_create_event(cm_node, type);
2616 * @cm_node: connection's node
2619 static int irdma_check_syn(struct irdma_cm_node *cm_node, struct tcphdr *tcph)
2621 if (ntohl(tcph->ack_seq) != cm_node->tcp_cntxt.loc_seq_num) {
2622 irdma_active_open_err(cm_node, true);
2631 * @cm_node: connection's node
2634 static int irdma_check_seq(struct irdma_cm_node *cm_node, struct tcphdr *tcph)
2638 u32 loc_seq_num = cm_node->tcp_cntxt.loc_seq_num;
2639 u32 rcv_nxt = cm_node->tcp_cntxt.rcv_nxt;
2645 rcv_wnd = cm_node->tcp_cntxt.rcv_wnd;
2650 ibdev_dbg(&cm_node->iwdev->ibdev,
2656 void irdma_add_conn_est_qh(struct irdma_cm_node *cm_node)
2660 irdma_get_addr_info(cm_node, &nfo);
2661 nfo.qh_qpid = cm_node->iwdev->vsi.ilq->qp_id;
2662 irdma_manage_qhash(cm_node->iwdev, &nfo,
2665 cm_node, false);
2666 cm_node->qhash_set = true;
2671 * @cm_node: connection's node
2674 static void irdma_handle_syn_pkt(struct irdma_cm_node *cm_node,
2685 switch (cm_node->state) {
2689 irdma_active_open_err(cm_node, 1);
2693 if (atomic_read(&cm_node->listener->pend_accepts_cnt) >
2694 cm_node->listener->backlog) {
2695 cm_node->cm_core->stats_backlog_drops++;
2696 irdma_passive_open_err(cm_node, false);
2699 err = irdma_handle_tcp_options(cm_node, tcph, optionsize, 1);
2701 irdma_passive_open_err(cm_node, false);
2705 err = cm_node->cm_core->cm_create_ah(cm_node, false);
2707 irdma_passive_open_err(cm_node, false);
2711 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
2712 cm_node->accept_pend = 1;
2713 atomic_inc(&cm_node->listener->pend_accepts_cnt);
2715 cm_node->state = IRDMA_CM_STATE_SYN_RCVD;
2718 irdma_cleanup_retrans_entry(cm_node);
2719 refcount_inc(&cm_node->refcnt);
2720 irdma_send_reset(cm_node);
2737 * @cm_node: connection's node
2740 static void irdma_handle_synack_pkt(struct irdma_cm_node *cm_node,
2750 switch (cm_node->state) {
2752 irdma_cleanup_retrans_entry(cm_node);
2754 if (irdma_check_syn(cm_node, tcph)) {
2755 ibdev_dbg(&cm_node->iwdev->ibdev,
2759 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2761 err = irdma_handle_tcp_options(cm_node, tcph, optionsize, 0);
2763 ibdev_dbg(&cm_node->iwdev->ibdev,
2764 "CM: cm_node=%p tcp_options failed\n",
2765 cm_node);
2768 irdma_cleanup_retrans_entry(cm_node);
2769 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
2770 irdma_send_ack(cm_node); /* ACK for the syn_ack */
2771 err = irdma_send_mpa_request(cm_node);
2773 ibdev_dbg(&cm_node->iwdev->ibdev,
2774 "CM: cm_node=%p irdma_send_mpa_request failed\n",
2775 cm_node);
2778 cm_node->state = IRDMA_CM_STATE_MPAREQ_SENT;
2781 irdma_passive_open_err(cm_node, true);
2784 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
2785 irdma_cleanup_retrans_entry(cm_node);
2786 cm_node->state = IRDMA_CM_STATE_CLOSED;
2787 irdma_send_reset(cm_node);
2790 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
2791 irdma_cleanup_retrans_entry(cm_node);
2792 refcount_inc(&cm_node->refcnt);
2793 irdma_send_reset(cm_node);
2810 * @cm_node: connection's node
2813 static int irdma_handle_ack_pkt(struct irdma_cm_node *cm_node,
2824 if (irdma_check_seq(cm_node, tcph))
2828 switch (cm_node->state) {
2830 irdma_cleanup_retrans_entry(cm_node);
2831 ret = irdma_handle_tcp_options(cm_node, tcph, optionsize, 1);
2834 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2835 cm_node->state = IRDMA_CM_STATE_ESTABLISHED;
2837 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2838 irdma_handle_rcv_mpa(cm_node, rbuf);
2842 irdma_cleanup_retrans_entry(cm_node);
2844 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2845 irdma_handle_rcv_mpa(cm_node, rbuf);
2849 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2851 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2852 cm_node->ack_rcvd = false;
2853 irdma_handle_rcv_mpa(cm_node, rbuf);
2855 cm_node->ack_rcvd = true;
2859 irdma_cleanup_retrans_entry(cm_node);
2860 cm_node->state = IRDMA_CM_STATE_CLOSED;
2861 irdma_send_reset(cm_node);
2864 irdma_cleanup_retrans_entry(cm_node);
2865 refcount_inc(&cm_node->refcnt);
2866 irdma_send_reset(cm_node);
2870 irdma_cleanup_retrans_entry(cm_node);
2871 cm_node->state = IRDMA_CM_STATE_CLOSED;
2872 irdma_rem_ref_cm_node(cm_node);
2875 irdma_cleanup_retrans_entry(cm_node);
2876 cm_node->state = IRDMA_CM_STATE_FIN_WAIT2;
2884 irdma_cleanup_retrans_entry(cm_node);
2893 * @cm_node: connection's node
2896 static void irdma_process_pkt(struct irdma_cm_node *cm_node,
2918 irdma_handle_syn_pkt(cm_node, rbuf);
2921 irdma_handle_synack_pkt(cm_node, rbuf);
2924 err = irdma_handle_ack_pkt(cm_node, rbuf);
2926 irdma_handle_fin_pkt(cm_node);
2929 irdma_handle_rst_pkt(cm_node, rbuf);
2933 (!irdma_check_seq(cm_node, (struct tcphdr *)rbuf->tcph)))
2934 irdma_handle_fin_pkt(cm_node);
3008 * @caller_cm_node: pointer to cm_node structure to return
3016 struct irdma_cm_node *cm_node;
3021 cm_node = irdma_make_cm_node(cm_core, iwdev, cm_info, NULL);
3022 if (!cm_node)
3026 cm_node->tcp_cntxt.client = 1;
3027 cm_node->tcp_cntxt.rcv_wscale = IRDMA_CM_DEFAULT_RCV_WND_SCALE;
3029 irdma_record_ird_ord(cm_node, conn_param->ird, conn_param->ord);
3031 cm_node->pdata.size = private_data_len;
3032 cm_node->pdata.addr = cm_node->pdata_buf;
3034 memcpy(cm_node->pdata_buf, private_data, private_data_len);
3035 *caller_cm_node = cm_node;
3042 * @cm_node: connection's node
3046 static int irdma_cm_reject(struct irdma_cm_node *cm_node, const void *pdata,
3052 if (cm_node->tcp_cntxt.client)
3055 irdma_cleanup_retrans_entry(cm_node);
3057 passive_state = atomic_add_return(1, &cm_node->passive_state);
3059 cm_node->state = IRDMA_CM_STATE_CLOSED;
3060 irdma_rem_ref_cm_node(cm_node);
3064 if (cm_node->state == IRDMA_CM_STATE_LISTENER_DESTROYED) {
3065 irdma_rem_ref_cm_node(cm_node);
3069 ret = irdma_send_mpa_reject(cm_node, pdata, plen);
3073 cm_node->state = IRDMA_CM_STATE_CLOSED;
3074 if (irdma_send_reset(cm_node))
3075 ibdev_dbg(&cm_node->iwdev->ibdev,
3083 * @cm_node: connection's node
3085 static int irdma_cm_close(struct irdma_cm_node *cm_node)
3087 switch (cm_node->state) {
3095 irdma_cleanup_retrans_entry(cm_node);
3096 irdma_send_reset(cm_node);
3099 cm_node->state = IRDMA_CM_STATE_LAST_ACK;
3100 irdma_send_fin(cm_node);
3109 irdma_cleanup_retrans_entry(cm_node);
3110 irdma_send_reset(cm_node);
3117 irdma_rem_ref_cm_node(cm_node);
3120 if (cm_node->send_entry)
3121 ibdev_dbg(&cm_node->iwdev->ibdev,
3123 irdma_rem_ref_cm_node(cm_node);
3138 struct irdma_cm_node *cm_node;
3194 cm_node = irdma_find_node(cm_core, cm_info.rem_port, cm_info.rem_addr,
3197 if (!cm_node) {
3218 cm_node = irdma_make_cm_node(cm_core, iwdev, &cm_info,
3220 if (!cm_node) {
3228 cm_node->state = IRDMA_CM_STATE_LISTENING;
3230 irdma_rem_ref_cm_node(cm_node);
3234 refcount_inc(&cm_node->refcnt);
3235 } else if (cm_node->state == IRDMA_CM_STATE_OFFLOADED) {
3236 irdma_rem_ref_cm_node(cm_node);
3240 irdma_process_pkt(cm_node, rbuf);
3241 irdma_rem_ref_cm_node(cm_node);
3244 static int irdma_add_qh(struct irdma_cm_node *cm_node, bool active)
3247 irdma_add_conn_est_qh(cm_node);
3251 static void irdma_cm_free_ah_nop(struct irdma_cm_node *cm_node)
3313 * @cm_node: connection's node
3317 static void irdma_init_tcp_ctx(struct irdma_cm_node *cm_node,
3321 tcp_info->ipv4 = cm_node->ipv4;
3334 tcp_info->snd_wscale = cm_node->tcp_cntxt.snd_wscale;
3335 tcp_info->rcv_wscale = cm_node->tcp_cntxt.rcv_wscale;
3337 tcp_info->snd_nxt = cm_node->tcp_cntxt.loc_seq_num;
3338 tcp_info->snd_wnd = cm_node->tcp_cntxt.snd_wnd;
3339 tcp_info->rcv_nxt = cm_node->tcp_cntxt.rcv_nxt;
3340 tcp_info->snd_max = cm_node->tcp_cntxt.loc_seq_num;
3342 tcp_info->snd_una = cm_node->tcp_cntxt.loc_seq_num;
3343 tcp_info->cwnd = 2 * cm_node->tcp_cntxt.mss;
3344 tcp_info->snd_wl1 = cm_node->tcp_cntxt.rcv_nxt;
3345 tcp_info->snd_wl2 = cm_node->tcp_cntxt.loc_seq_num;
3346 tcp_info->max_snd_window = cm_node->tcp_cntxt.max_snd_wnd;
3347 tcp_info->rcv_wnd = cm_node->tcp_cntxt.rcv_wnd
3348 << cm_node->tcp_cntxt.rcv_wscale;
3351 tcp_info->snd_mss = (u32)cm_node->tcp_cntxt.mss;
3352 tcp_info->tos = cm_node->tos;
3353 if (cm_node->vlan_id < VLAN_N_VID) {
3355 tcp_info->vlan_tag = cm_node->vlan_id;
3356 tcp_info->vlan_tag |= cm_node->user_pri << VLAN_PRIO_SHIFT;
3358 if (cm_node->ipv4) {
3359 tcp_info->src_port = cm_node->loc_port;
3360 tcp_info->dst_port = cm_node->rem_port;
3362 tcp_info->dest_ip_addr[3] = cm_node->rem_addr[0];
3363 tcp_info->local_ipaddr[3] = cm_node->loc_addr[0];
3369 tcp_info->src_port = cm_node->loc_port;
3370 tcp_info->dst_port = cm_node->rem_port;
3371 memcpy(tcp_info->dest_ip_addr, cm_node->rem_addr,
3373 memcpy(tcp_info->local_ipaddr, cm_node->loc_addr,
3386 * @cm_node: connection's node
3389 struct irdma_cm_node *cm_node)
3401 iwarp_info->ord_size = cm_node->ord_size;
3402 iwarp_info->ird_size = cm_node->ird_size;
3410 ctx_info->user_pri = cm_node->user_pri;
3412 irdma_init_tcp_ctx(cm_node, &iwqp->tcp_info, iwqp);
3413 if (cm_node->snd_mark_en) {
3416 cm_node->lsmm_size;
3419 cm_node->state = IRDMA_CM_STATE_OFFLOADED;
3423 if (cm_node->rcv_mark_en) {
3477 irdma_cm_close(iwqp->cm_node);
3566 if (!iwqp->cm_node) {
3570 refcount_inc(&iwqp->cm_node->refcnt);
3575 err = irdma_send_cm_event(iwqp->cm_node, cm_id,
3585 err = irdma_send_cm_event(iwqp->cm_node, cm_id,
3593 irdma_rem_ref_cm_node(iwqp->cm_node);
3641 struct irdma_cm_node *cm_node;
3659 cm_node = cm_id->provider_data;
3662 cm_node->ipv4 = true;
3663 cm_node->vlan_id = irdma_get_vlan_ipv4(cm_node->loc_addr);
3665 cm_node->ipv4 = false;
3666 irdma_get_vlan_mac_ipv6(cm_node->loc_addr, &cm_node->vlan_id,
3670 cm_node->vlan_id);
3672 trace_irdma_accept(cm_node, 0, NULL);
3674 if (cm_node->state == IRDMA_CM_STATE_LISTENER_DESTROYED) {
3679 passive_state = atomic_add_return(1, &cm_node->passive_state);
3695 cm_node->pdata.size = conn_param->private_data_len;
3697 accept.size = irdma_cm_build_mpa_frame(cm_node, &accept, MPA_KEY_REPLY);
3701 if (cm_node->dev->ws_add(iwqp->sc_qp.vsi, cm_node->user_pri)) {
3705 iwqp->sc_qp.user_pri = cm_node->user_pri;
3723 cm_node->lsmm_size = accept.size + conn_param->private_data_len;
3724 irdma_sc_send_lsmm(&iwqp->sc_qp, iwqp->ietf_mem.va, cm_node->lsmm_size,
3731 cm_node->cm_id = cm_id;
3735 iwqp->cm_node = cm_node;
3736 cm_node->iwqp = iwqp;
3737 irdma_cm_init_tsa_conn(iwqp, cm_node);
3742 cm_node->qhash_set = false;
3743 cm_node->cm_core->cm_free_ah(cm_node);
3752 "CM: Slow Connection: cm_node=%p, loc_port=%d, rem_port=%d, cm_id=%p\n",
3753 cm_node, cm_node->loc_port,
3754 cm_node->rem_port, cm_node->cm_id);
3760 irdma_send_cm_event(cm_node, cm_id, IW_CM_EVENT_ESTABLISHED, 0);
3761 cm_node->accelerated = true;
3762 complete(&cm_node->establish_comp);
3764 if (cm_node->accept_pend) {
3765 atomic_dec(&cm_node->listener->pend_accepts_cnt);
3766 cm_node->accept_pend = 0;
3770 "CM: rem_port=0x%04x, loc_port=0x%04x rem_addr=%pI4 loc_addr=%pI4 cm_node=%p cm_id=%p qp_id = %d\n\n",
3771 cm_node->rem_port, cm_node->loc_port, cm_node->rem_addr,
3772 cm_node->loc_addr, cm_node, cm_id, ibqp->qp_num);
3773 cm_node->cm_core->stats_accepts++;
3778 irdma_rem_ref_cm_node(cm_node);
3792 struct irdma_cm_node *cm_node;
3794 cm_node = cm_id->provider_data;
3795 cm_node->pdata.size = pdata_len;
3797 trace_irdma_reject(cm_node, 0, NULL);
3803 cm_node->cm_core->stats_rejects++;
3808 return irdma_cm_reject(cm_node, pdata, pdata_len);
3821 struct irdma_cm_node *cm_node;
3901 &cm_node);
3904 ret = cm_node->cm_core->cm_create_ah(cm_node, true);
3913 cm_node->qhash_set = true;
3915 cm_node->apbvt_entry = irdma_add_apbvt(iwdev, cm_info.loc_port);
3916 if (!cm_node->apbvt_entry) {
3921 cm_node->apbvt_set = true;
3922 iwqp->cm_node = cm_node;
3923 cm_node->iwqp = iwqp;
3928 if (cm_node->state != IRDMA_CM_STATE_OFFLOADED) {
3929 cm_node->state = IRDMA_CM_STATE_SYN_SENT;
3930 ret = irdma_send_syn(cm_node, 0);
3936 "CM: rem_port=0x%04x, loc_port=0x%04x rem_addr=%pI4 loc_addr=%pI4 cm_node=%p cm_id=%p qp_id = %d\n\n",
3937 cm_node->rem_port, cm_node->loc_port, cm_node->rem_addr,
3938 cm_node->loc_addr, cm_node, cm_id, ibqp->qp_num);
3940 trace_irdma_connect(cm_node, 0, NULL);
3953 irdma_rem_ref_cm_node(cm_node);
4105 * @teardown_list: a list to which cm_node will be selected
4116 struct irdma_cm_node *cm_node;
4119 hash_for_each_rcu(cm_core->cm_hash_tbl, bkt, cm_node, list) {
4121 (nfo->vlan_id == cm_node->vlan_id &&
4122 !memcmp(cm_node->loc_addr, ipaddr, nfo->ipv4 ? 4 : 16))) &&
4123 refcount_inc_not_zero(&cm_node->refcnt))
4124 list_add(&cm_node->teardown_entry, teardown_list);
4130 * @event: the info for cm_node of connection
4136 struct irdma_cm_node *cm_node;
4144 cm_node = event->cm_node;
4145 cm_id = cm_node->cm_id;
4154 irdma_cm_init_tsa_conn(iwqp, cm_node);
4155 read0 = (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO);
4163 cm_node->qhash_set = false;
4171 "CM: Slow Connection: cm_node=%p, loc_port=%d, rem_port=%d, cm_id=%p\n",
4172 cm_node, cm_node->loc_port,
4173 cm_node->rem_port, cm_node->cm_id);
4176 irdma_send_cm_event(cm_node, cm_id, IW_CM_EVENT_CONNECT_REPLY, 0);
4177 cm_node->accelerated = true;
4178 complete(&cm_node->establish_comp);
4179 cm_node->cm_core->cm_free_ah(cm_node);
4185 irdma_send_cm_event(event->cm_node, cm_id, IW_CM_EVENT_CONNECT_REPLY,
4187 irdma_rem_ref_cm_node(event->cm_node);
4192 * @event: the info for cm_node of connection
4196 struct irdma_cm_node *cm_node = event->cm_node;
4197 struct iw_cm_id *cm_id = cm_node->cm_id;
4207 ibdev_dbg(&cm_node->iwdev->ibdev,
4208 "CM: reset event %p - cm_id = %p\n", event->cm_node, cm_id);
4211 irdma_send_cm_event(cm_node, cm_node->cm_id, IW_CM_EVENT_DISCONNECT,
4213 irdma_send_cm_event(cm_node, cm_node->cm_id, IW_CM_EVENT_CLOSE, 0);
4223 struct irdma_cm_node *cm_node;
4225 if (!event || !event->cm_node || !event->cm_node->cm_core)
4228 cm_node = event->cm_node;
4229 trace_irdma_cm_event_handler(cm_node, event->type, NULL);
4233 irdma_send_cm_event(cm_node, cm_node->cm_id,
4240 if (!event->cm_node->cm_id ||
4241 event->cm_node->state != IRDMA_CM_STATE_OFFLOADED)
4246 if (!event->cm_node->cm_id ||
4247 cm_node->state == IRDMA_CM_STATE_OFFLOADED)
4249 irdma_send_cm_event(cm_node, cm_node->cm_id,
4253 if (!event->cm_node->cm_id ||
4254 event->cm_node->state == IRDMA_CM_STATE_OFFLOADED)
4259 ibdev_dbg(&cm_node->iwdev->ibdev,
4264 irdma_rem_ref_cm_node(event->cm_node);
4274 refcount_inc(&event->cm_node->refcnt);
4276 queue_work(event->cm_node->cm_core->event_wq, &event->event_work);
4295 struct irdma_cm_node *cm_node;
4306 cm_node = container_of(list_node, struct irdma_cm_node,
4309 irdma_modify_qp(&cm_node->iwqp->ibqp, &attr, IB_QP_STATE, NULL);
4311 irdma_cm_disconn(cm_node->iwqp);
4312 irdma_rem_ref_cm_node(cm_node);