1 /*******************************************************************************
3 * Copyright (c) 2015-2016 Intel Corporation. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenFabrics.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 *******************************************************************************/
35 #include <linux/atomic.h>
37 #include <linux/tcp.h>
38 #include <linux/init.h>
39 #include <linux/if_arp.h>
40 #include <linux/if_vlan.h>
41 #include <linux/notifier.h>
42 #include <linux/net.h>
43 #include <linux/types.h>
44 #include <linux/timer.h>
45 #include <linux/time.h>
46 #include <linux/delay.h>
47 #include <linux/etherdevice.h>
48 #include <linux/netdevice.h>
49 #include <linux/random.h>
50 #include <linux/list.h>
51 #include <linux/threads.h>
52 #include <linux/highmem.h>
54 #include <net/ndisc.h>
55 #include <net/neighbour.h>
56 #include <net/route.h>
57 #include <net/addrconf.h>
58 #include <net/ip6_route.h>
59 #include <net/ip_fib.h>
61 #include <asm/checksum.h>
65 static void i40iw_rem_ref_cm_node(struct i40iw_cm_node *);
66 static void i40iw_cm_post_event(struct i40iw_cm_event *event);
67 static void i40iw_disconnect_worker(struct work_struct *work);
70 * i40iw_free_sqbuf - put back puda buffer if refcount = 0
72 * @buf: puda buffer to free
74 void i40iw_free_sqbuf(struct i40iw_sc_dev *dev, void *bufp)
76 struct i40iw_puda_buf *buf = (struct i40iw_puda_buf *)bufp;
77 struct i40iw_puda_rsrc *ilq = dev->ilq;
79 if (!atomic_dec_return(&buf->refcount))
80 i40iw_puda_ret_bufpool(ilq, buf);
84 * i40iw_derive_hw_ird_setting - Calculate IRD
86 * @cm_ird: IRD of connection's node
88 * The ird from the connection is rounded to a supported HW
89 * setting (2,8,32,64) and then encoded for ird_size field of
92 static u8 i40iw_derive_hw_ird_setting(u16 cm_ird)
97 /* round-off to next powerof2 */
98 while (pof2_cm_ird < cm_ird)
101 /* ird_size field is encoded in qp_ctx */
102 switch (pof2_cm_ird) {
103 case I40IW_HW_IRD_SETTING_64:
104 encoded_ird_size = 3;
106 case I40IW_HW_IRD_SETTING_32:
107 case I40IW_HW_IRD_SETTING_16:
108 encoded_ird_size = 2;
110 case I40IW_HW_IRD_SETTING_8:
111 case I40IW_HW_IRD_SETTING_4:
112 encoded_ird_size = 1;
114 case I40IW_HW_IRD_SETTING_2:
116 encoded_ird_size = 0;
119 return encoded_ird_size;
123 * i40iw_record_ird_ord - Record IRD/ORD passed in
124 * @cm_node: connection's node
125 * @conn_ird: connection IRD
126 * @conn_ord: connection ORD
128 static void i40iw_record_ird_ord(struct i40iw_cm_node *cm_node, u16 conn_ird, u16 conn_ord)
130 if (conn_ird > I40IW_MAX_IRD_SIZE)
131 conn_ird = I40IW_MAX_IRD_SIZE;
133 if (conn_ord > I40IW_MAX_ORD_SIZE)
134 conn_ord = I40IW_MAX_ORD_SIZE;
136 cm_node->ird_size = conn_ird;
137 cm_node->ord_size = conn_ord;
141 * i40iw_copy_ip_ntohl - change network to host ip
145 void i40iw_copy_ip_ntohl(u32 *dst, __be32 *src)
147 *dst++ = ntohl(*src++);
148 *dst++ = ntohl(*src++);
149 *dst++ = ntohl(*src++);
154 * i40iw_copy_ip_htonl - change host addr to network ip
156 * @src: little endian
158 static inline void i40iw_copy_ip_htonl(__be32 *dst, u32 *src)
160 *dst++ = htonl(*src++);
161 *dst++ = htonl(*src++);
162 *dst++ = htonl(*src++);
167 * i40iw_fill_sockaddr4 - get addr info for passive connection
168 * @cm_node: connection's node
169 * @event: upper layer's cm event
171 static inline void i40iw_fill_sockaddr4(struct i40iw_cm_node *cm_node,
172 struct iw_cm_event *event)
174 struct sockaddr_in *laddr = (struct sockaddr_in *)&event->local_addr;
175 struct sockaddr_in *raddr = (struct sockaddr_in *)&event->remote_addr;
177 laddr->sin_family = AF_INET;
178 raddr->sin_family = AF_INET;
180 laddr->sin_port = htons(cm_node->loc_port);
181 raddr->sin_port = htons(cm_node->rem_port);
183 laddr->sin_addr.s_addr = htonl(cm_node->loc_addr[0]);
184 raddr->sin_addr.s_addr = htonl(cm_node->rem_addr[0]);
188 * i40iw_fill_sockaddr6 - get ipv6 addr info for passive side
189 * @cm_node: connection's node
190 * @event: upper layer's cm event
192 static inline void i40iw_fill_sockaddr6(struct i40iw_cm_node *cm_node,
193 struct iw_cm_event *event)
195 struct sockaddr_in6 *laddr6 = (struct sockaddr_in6 *)&event->local_addr;
196 struct sockaddr_in6 *raddr6 = (struct sockaddr_in6 *)&event->remote_addr;
198 laddr6->sin6_family = AF_INET6;
199 raddr6->sin6_family = AF_INET6;
201 laddr6->sin6_port = htons(cm_node->loc_port);
202 raddr6->sin6_port = htons(cm_node->rem_port);
204 i40iw_copy_ip_htonl(laddr6->sin6_addr.in6_u.u6_addr32,
206 i40iw_copy_ip_htonl(raddr6->sin6_addr.in6_u.u6_addr32,
211 * i40iw_set_sockaddr - Record ip addr and tcp port in a sockaddr storage
212 * @ip_addr: v4/v6 ip addr
214 * @addr: sockaddr to store ip/tcp info
216 static void i40iw_set_sockaddr(u32 *ip_addr,
218 struct sockaddr_storage *addr,
222 struct sockaddr_in *in4_addr = (struct sockaddr_in *)addr;
224 in4_addr->sin_family = AF_INET;
225 in4_addr->sin_addr.s_addr = htonl(ip_addr[0]);
226 in4_addr->sin_port = htons(port);
228 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)addr;
230 in6_addr->sin6_family = AF_INET6;
231 i40iw_copy_ip_htonl(in6_addr->sin6_addr.in6_u.u6_addr32,
233 in6_addr->sin6_port = htons(port);
238 * i40iw_get_sockaddr - Get ip addr and tcp port from a sockaddr storage
239 * @addr: sockaddr to get ip/tcp info
240 * @ip_addr: v4/v6 ip addr
243 static void i40iw_get_addrinfo(struct sockaddr_storage *addr, u32 *ip_addr, u16 *port)
245 if (addr->ss_family == AF_INET) {
246 struct sockaddr_in *in4_addr = (struct sockaddr_in *)addr;
248 ip_addr[0] = ntohl(in4_addr->sin_addr.s_addr);
249 *port = ntohs(in4_addr->sin_port);
251 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)addr;
253 i40iw_copy_ip_ntohl(ip_addr,
254 in6_addr->sin6_addr.in6_u.u6_addr32);
255 *port = ntohs(in6_addr->sin6_port);
260 * i40iw_is_wildcard - Check if it is a wildcard ip address
261 * @addr: sockaddr containing the ip to check
263 static bool i40iw_is_wildcard(struct sockaddr_storage *addr)
265 if (addr->ss_family == AF_INET) {
266 struct sockaddr_in *in4_addr = (struct sockaddr_in *)addr;
268 return (in4_addr->sin_addr.s_addr == INADDR_ANY);
270 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)addr;
272 return (ipv6_addr_type(&in6_addr->sin6_addr) == IPV6_ADDR_ANY);
277 * i40iw_create_mapinfo - Create a mapinfo object in the port mapper data base
278 * @cm_info: contains ip/tcp info
280 static int i40iw_create_mapinfo(struct i40iw_cm_info *cm_info)
282 struct sockaddr_storage local_sockaddr;
283 struct sockaddr_storage mapped_sockaddr;
285 i40iw_set_sockaddr(cm_info->loc_addr, cm_info->loc_port,
286 &local_sockaddr, cm_info->ipv4);
287 i40iw_set_sockaddr(cm_info->map_loc_addr, cm_info->map_loc_port,
288 &mapped_sockaddr, cm_info->ipv4);
289 return iwpm_create_mapinfo(&local_sockaddr,
295 * i40iw_remove_mapinfo - Remove a mapinfo object
296 * @cm_info: contains ip/tcp info
298 * Removes a mapinfo object from the port mapper data base
299 * and sends a remove mapping message to the userspace port mapper
301 static int i40iw_remove_mapinfo(struct i40iw_cm_info *cm_info)
303 struct sockaddr_storage local_sockaddr;
304 struct sockaddr_storage mapped_sockaddr;
306 i40iw_set_sockaddr(cm_info->loc_addr, cm_info->loc_port,
307 &local_sockaddr, cm_info->ipv4);
308 i40iw_set_sockaddr(cm_info->map_loc_addr, cm_info->map_loc_port,
309 &mapped_sockaddr, cm_info->ipv4);
311 iwpm_remove_mapinfo(&local_sockaddr, &mapped_sockaddr);
312 return iwpm_remove_mapping(&local_sockaddr, RDMA_NL_I40IW);
316 * i40iw_form_reg_msg - Form a port mapper message with dev info
317 * @iwdev: iWarp device
318 * @pm_msg: msg to record device data
320 static void i40iw_form_reg_msg(struct i40iw_device *iwdev, struct iwpm_dev_data *pm_msg)
322 memcpy(pm_msg->dev_name, iwdev->iwibdev->ibdev.name, IWPM_DEVNAME_SIZE);
323 memcpy(pm_msg->if_name, iwdev->netdev->name, IWPM_IFNAME_SIZE);
327 * i40iw_form_pm_msg - Form a port mapper message with mapping info
328 * @cm_info: contains ip/tcp info
329 * @pm_msg: msg to record ip/tcp info
331 static void i40iw_form_pm_msg(struct i40iw_cm_info *cm_info,
332 struct iwpm_sa_data *pm_msg)
334 i40iw_set_sockaddr(cm_info->loc_addr, cm_info->loc_port,
335 &pm_msg->loc_addr, cm_info->ipv4);
336 i40iw_set_sockaddr(cm_info->rem_addr, cm_info->rem_port,
337 &pm_msg->rem_addr, cm_info->ipv4);
341 * i40iw_record_pm_msg - Record the received mapping info
342 * @cm_info: ip/tcp info to be updated with mapped info
343 * @pm_msg: received msg with mapped ip/tcp
345 static void i40iw_record_pm_msg(struct i40iw_cm_info *cm_info,
346 struct iwpm_sa_data *pm_msg,
349 i40iw_get_addrinfo(&pm_msg->mapped_loc_addr,
350 cm_info->map_loc_addr,
351 &cm_info->map_loc_port);
353 i40iw_get_addrinfo(&pm_msg->mapped_rem_addr,
354 cm_info->map_rem_addr, &cm_info->map_rem_port);
355 if (i40iw_is_wildcard(&pm_msg->mapped_rem_addr))
356 memcpy(cm_info->map_rem_addr, cm_info->rem_addr,
357 sizeof(cm_info->map_rem_addr));
362 * i40iw_get_reminfo - Get the address info of the remote connecting peer
363 * @cm_node: provides mapped ip/tcp info (local and remote)
365 * Gets the actual non-mapped ip/tcp info of the remote connecting peer
366 * from the port mapper data base
368 static int i40iw_get_remote_addr(struct i40iw_cm_node *cm_node)
370 struct sockaddr_storage mapped_loc_addr, mapped_rem_addr;
371 struct sockaddr_storage remote_addr;
374 i40iw_set_sockaddr(cm_node->map_loc_addr,
375 cm_node->map_loc_port,
378 i40iw_set_sockaddr(cm_node->map_rem_addr,
379 cm_node->map_rem_port,
382 ret = iwpm_get_remote_info(&mapped_loc_addr,
387 i40iw_debug(cm_node->dev,
389 "Unable to find remote peer address info\n");
391 i40iw_get_addrinfo(&remote_addr,
398 * i40iw_init_mapinfo - Initialize the mapped ip/tcp info
399 * @cm_info: ip/tcp info (actual and mapped)
401 static void i40iw_init_mapinfo(struct i40iw_cm_info *cm_info)
403 memcpy(cm_info->map_loc_addr, cm_info->loc_addr,
404 sizeof(cm_info->map_loc_addr));
405 memcpy(cm_info->map_rem_addr, cm_info->rem_addr,
406 sizeof(cm_info->map_rem_addr));
407 cm_info->map_loc_port = cm_info->loc_port;
408 cm_info->map_rem_port = cm_info->rem_port;
412 * i40iw_get_addr_info
413 * @cm_node: contains ip/tcp info
414 * @cm_info: to get a copy of the cm_node ip/tcp info
416 static void i40iw_get_addr_info(struct i40iw_cm_node *cm_node,
417 struct i40iw_cm_info *cm_info)
419 cm_info->ipv4 = cm_node->ipv4;
420 cm_info->vlan_id = cm_node->vlan_id;
421 memcpy(cm_info->loc_addr, cm_node->loc_addr, sizeof(cm_info->loc_addr));
422 memcpy(cm_info->rem_addr, cm_node->rem_addr, sizeof(cm_info->rem_addr));
423 memcpy(cm_info->map_loc_addr, cm_node->map_loc_addr, sizeof(cm_info->map_loc_addr));
424 memcpy(cm_info->map_rem_addr, cm_node->map_rem_addr, sizeof(cm_info->map_rem_addr));
425 cm_info->loc_port = cm_node->loc_port;
426 cm_info->rem_port = cm_node->rem_port;
427 cm_info->map_loc_port = cm_node->map_loc_port;
428 cm_info->map_rem_port = cm_node->map_rem_port;
432 * i40iw_get_cmevent_info - for cm event upcall
433 * @cm_node: connection's node
434 * @cm_id: upper layers cm struct for the event
435 * @event: upper layer's cm event
437 static inline void i40iw_get_cmevent_info(struct i40iw_cm_node *cm_node,
438 struct iw_cm_id *cm_id,
439 struct iw_cm_event *event)
441 memcpy(&event->local_addr, &cm_id->local_addr,
442 sizeof(event->local_addr));
443 memcpy(&event->remote_addr, &cm_id->remote_addr,
444 sizeof(event->remote_addr));
446 event->private_data = (void *)cm_node->pdata_buf;
447 event->private_data_len = (u8)cm_node->pdata.size;
448 event->ird = cm_node->ird_size;
449 event->ord = cm_node->ord_size;
454 * i40iw_send_cm_event - upcall cm's event handler
455 * @cm_node: connection's node
456 * @cm_id: upper layer's cm info struct
457 * @type: Event type to indicate
458 * @status: status for the event type
460 static int i40iw_send_cm_event(struct i40iw_cm_node *cm_node,
461 struct iw_cm_id *cm_id,
462 enum iw_cm_event_type type,
465 struct iw_cm_event event;
467 memset(&event, 0, sizeof(event));
469 event.status = status;
471 case IW_CM_EVENT_CONNECT_REQUEST:
473 i40iw_fill_sockaddr4(cm_node, &event);
475 i40iw_fill_sockaddr6(cm_node, &event);
476 event.provider_data = (void *)cm_node;
477 event.private_data = (void *)cm_node->pdata_buf;
478 event.private_data_len = (u8)cm_node->pdata.size;
480 case IW_CM_EVENT_CONNECT_REPLY:
481 i40iw_get_cmevent_info(cm_node, cm_id, &event);
483 case IW_CM_EVENT_ESTABLISHED:
484 event.ird = cm_node->ird_size;
485 event.ord = cm_node->ord_size;
487 case IW_CM_EVENT_DISCONNECT:
489 case IW_CM_EVENT_CLOSE:
492 i40iw_pr_err("event type received type = %d\n", type);
495 return cm_id->event_handler(cm_id, &event);
499 * i40iw_create_event - create cm event
500 * @cm_node: connection's node
501 * @type: Event type to generate
503 static struct i40iw_cm_event *i40iw_create_event(struct i40iw_cm_node *cm_node,
504 enum i40iw_cm_event_type type)
506 struct i40iw_cm_event *event;
511 event = kzalloc(sizeof(*event), GFP_ATOMIC);
517 event->cm_node = cm_node;
518 memcpy(event->cm_info.rem_addr, cm_node->rem_addr, sizeof(event->cm_info.rem_addr));
519 memcpy(event->cm_info.loc_addr, cm_node->loc_addr, sizeof(event->cm_info.loc_addr));
520 event->cm_info.rem_port = cm_node->rem_port;
521 event->cm_info.loc_port = cm_node->loc_port;
522 event->cm_info.cm_id = cm_node->cm_id;
524 i40iw_debug(cm_node->dev,
526 "node=%p event=%p type=%u dst=%pI4 src=%pI4\n",
530 event->cm_info.loc_addr,
531 event->cm_info.rem_addr);
533 i40iw_cm_post_event(event);
538 * i40iw_free_retrans_entry - free send entry
539 * @cm_node: connection's node
541 static void i40iw_free_retrans_entry(struct i40iw_cm_node *cm_node)
543 struct i40iw_sc_dev *dev = cm_node->dev;
544 struct i40iw_timer_entry *send_entry;
546 send_entry = cm_node->send_entry;
548 cm_node->send_entry = NULL;
549 i40iw_free_sqbuf(dev, (void *)send_entry->sqbuf);
551 atomic_dec(&cm_node->ref_count);
556 * i40iw_cleanup_retrans_entry - free send entry with lock
557 * @cm_node: connection's node
559 static void i40iw_cleanup_retrans_entry(struct i40iw_cm_node *cm_node)
563 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
564 i40iw_free_retrans_entry(cm_node);
565 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
568 static bool is_remote_ne020_or_chelsio(struct i40iw_cm_node *cm_node)
570 if ((cm_node->rem_mac[0] == 0x0) &&
571 (((cm_node->rem_mac[1] == 0x12) && (cm_node->rem_mac[2] == 0x55)) ||
572 ((cm_node->rem_mac[1] == 0x07 && (cm_node->rem_mac[2] == 0x43)))))
578 * i40iw_form_cm_frame - get a free packet and build frame
579 * @cm_node: connection's node ionfo to use in frame
580 * @options: pointer to options info
581 * @hdr: pointer mpa header
582 * @pdata: pointer to private data
583 * @flags: indicates FIN or ACK
585 static struct i40iw_puda_buf *i40iw_form_cm_frame(struct i40iw_cm_node *cm_node,
586 struct i40iw_kmem_info *options,
587 struct i40iw_kmem_info *hdr,
588 struct i40iw_kmem_info *pdata,
591 struct i40iw_puda_buf *sqbuf;
592 struct i40iw_sc_dev *dev = cm_node->dev;
597 struct ipv6hdr *ip6h;
600 u16 eth_hlen = ETH_HLEN;
605 sqbuf = i40iw_puda_get_bufpool(dev->ilq);
611 opts_len = (u32)options->size;
617 pd_len = pdata->size;
618 if (!is_remote_ne020_or_chelsio(cm_node))
619 pd_len += MPA_ZERO_PAD_LEN;
622 if (cm_node->vlan_id < VLAN_TAG_PRESENT)
626 packetsize = sizeof(*iph) + sizeof(*tcph);
628 packetsize = sizeof(*ip6h) + sizeof(*tcph);
629 packetsize += opts_len + hdr_len + pd_len;
631 memset(buf, 0x00, eth_hlen + packetsize);
633 sqbuf->totallen = packetsize + eth_hlen;
634 sqbuf->maclen = eth_hlen;
635 sqbuf->tcphlen = sizeof(*tcph) + opts_len;
636 sqbuf->scratch = (void *)cm_node;
638 ethh = (struct ethhdr *)buf;
644 iph = (struct iphdr *)buf;
646 tcph = (struct tcphdr *)buf;
647 buf += sizeof(*tcph);
649 ether_addr_copy(ethh->h_dest, cm_node->rem_mac);
650 ether_addr_copy(ethh->h_source, cm_node->loc_mac);
651 if (cm_node->vlan_id < VLAN_TAG_PRESENT) {
652 ((struct vlan_ethhdr *)ethh)->h_vlan_proto = htons(ETH_P_8021Q);
653 ((struct vlan_ethhdr *)ethh)->h_vlan_TCI = htons(cm_node->vlan_id);
655 ((struct vlan_ethhdr *)ethh)->h_vlan_encapsulated_proto = htons(ETH_P_IP);
657 ethh->h_proto = htons(ETH_P_IP);
660 iph->version = IPVERSION;
661 iph->ihl = 5; /* 5 * 4Byte words, IP headr len */
663 iph->tot_len = htons(packetsize);
664 iph->id = htons(++cm_node->tcp_cntxt.loc_id);
666 iph->frag_off = htons(0x4000);
668 iph->protocol = IPPROTO_TCP;
670 iph->saddr = htonl(cm_node->map_loc_addr[0]);
671 iph->daddr = htonl(cm_node->map_rem_addr[0]);
674 ip6h = (struct ipv6hdr *)buf;
675 buf += sizeof(*ip6h);
676 tcph = (struct tcphdr *)buf;
677 buf += sizeof(*tcph);
679 ether_addr_copy(ethh->h_dest, cm_node->rem_mac);
680 ether_addr_copy(ethh->h_source, cm_node->loc_mac);
681 if (cm_node->vlan_id < VLAN_TAG_PRESENT) {
682 ((struct vlan_ethhdr *)ethh)->h_vlan_proto = htons(ETH_P_8021Q);
683 ((struct vlan_ethhdr *)ethh)->h_vlan_TCI = htons(cm_node->vlan_id);
684 ((struct vlan_ethhdr *)ethh)->h_vlan_encapsulated_proto = htons(ETH_P_IPV6);
686 ethh->h_proto = htons(ETH_P_IPV6);
689 ip6h->flow_lbl[0] = 0;
690 ip6h->flow_lbl[1] = 0;
691 ip6h->flow_lbl[2] = 0;
692 ip6h->payload_len = htons(packetsize - sizeof(*ip6h));
694 ip6h->hop_limit = 128;
696 i40iw_copy_ip_htonl(ip6h->saddr.in6_u.u6_addr32,
697 cm_node->map_loc_addr);
698 i40iw_copy_ip_htonl(ip6h->daddr.in6_u.u6_addr32,
699 cm_node->map_rem_addr);
702 tcph->source = htons(cm_node->map_loc_port);
703 tcph->dest = htons(cm_node->map_rem_port);
705 tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num);
707 if (flags & SET_ACK) {
708 cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt;
709 tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num);
715 if (flags & SET_SYN) {
716 cm_node->tcp_cntxt.loc_seq_num++;
719 cm_node->tcp_cntxt.loc_seq_num += hdr_len + pd_len;
722 if (flags & SET_FIN) {
723 cm_node->tcp_cntxt.loc_seq_num++;
730 tcph->doff = (u16)((sizeof(*tcph) + opts_len + 3) >> 2);
731 sqbuf->tcphlen = tcph->doff << 2;
732 tcph->window = htons(cm_node->tcp_cntxt.rcv_wnd);
736 memcpy(buf, options->addr, opts_len);
741 memcpy(buf, hdr->addr, hdr_len);
746 memcpy(buf, pdata->addr, pd_len);
748 atomic_set(&sqbuf->refcount, 1);
754 * i40iw_send_reset - Send RST packet
755 * @cm_node: connection's node
757 static int i40iw_send_reset(struct i40iw_cm_node *cm_node)
759 struct i40iw_puda_buf *sqbuf;
760 int flags = SET_RST | SET_ACK;
762 sqbuf = i40iw_form_cm_frame(cm_node, NULL, NULL, NULL, flags);
764 i40iw_pr_err("no sqbuf\n");
768 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 0, 1);
772 * i40iw_active_open_err - send event for active side cm error
773 * @cm_node: connection's node
774 * @reset: Flag to send reset or not
776 static void i40iw_active_open_err(struct i40iw_cm_node *cm_node, bool reset)
778 i40iw_cleanup_retrans_entry(cm_node);
779 cm_node->cm_core->stats_connect_errs++;
781 i40iw_debug(cm_node->dev,
783 "%s cm_node=%p state=%d\n",
787 atomic_inc(&cm_node->ref_count);
788 i40iw_send_reset(cm_node);
791 cm_node->state = I40IW_CM_STATE_CLOSED;
792 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
796 * i40iw_passive_open_err - handle passive side cm error
797 * @cm_node: connection's node
798 * @reset: send reset or just free cm_node
800 static void i40iw_passive_open_err(struct i40iw_cm_node *cm_node, bool reset)
802 i40iw_cleanup_retrans_entry(cm_node);
803 cm_node->cm_core->stats_passive_errs++;
804 cm_node->state = I40IW_CM_STATE_CLOSED;
805 i40iw_debug(cm_node->dev,
807 "%s cm_node=%p state =%d\n",
812 i40iw_send_reset(cm_node);
814 i40iw_rem_ref_cm_node(cm_node);
818 * i40iw_event_connect_error - to create connect error event
819 * @event: cm information for connect event
821 static void i40iw_event_connect_error(struct i40iw_cm_event *event)
823 struct i40iw_qp *iwqp;
824 struct iw_cm_id *cm_id;
826 cm_id = event->cm_node->cm_id;
830 iwqp = cm_id->provider_data;
832 if (!iwqp || !iwqp->iwdev)
836 cm_id->provider_data = NULL;
837 i40iw_send_cm_event(event->cm_node, cm_id,
838 IW_CM_EVENT_CONNECT_REPLY,
840 cm_id->rem_ref(cm_id);
841 i40iw_rem_ref_cm_node(event->cm_node);
845 * i40iw_process_options
846 * @cm_node: connection's node
847 * @optionsloc: point to start of options
848 * @optionsize: size of all options
849 * @syn_packet: flag if syn packet
851 static int i40iw_process_options(struct i40iw_cm_node *cm_node,
858 union all_known_options *all_options;
859 char got_mss_option = 0;
861 while (offset < optionsize) {
862 all_options = (union all_known_options *)(optionsloc + offset);
863 switch (all_options->as_base.optionnum) {
864 case OPTION_NUMBER_END:
867 case OPTION_NUMBER_NONE:
870 case OPTION_NUMBER_MSS:
871 i40iw_debug(cm_node->dev,
873 "%s: MSS Length: %d Offset: %d Size: %d\n",
875 all_options->as_mss.length,
879 if (all_options->as_mss.length != 4)
881 tmp = ntohs(all_options->as_mss.mss);
882 if (tmp > 0 && tmp < cm_node->tcp_cntxt.mss)
883 cm_node->tcp_cntxt.mss = tmp;
885 case OPTION_NUMBER_WINDOW_SCALE:
886 cm_node->tcp_cntxt.snd_wscale =
887 all_options->as_windowscale.shiftcount;
890 i40iw_debug(cm_node->dev,
892 "TCP Option not understood: %x\n",
893 all_options->as_base.optionnum);
896 offset += all_options->as_base.length;
898 if (!got_mss_option && syn_packet)
899 cm_node->tcp_cntxt.mss = I40IW_CM_DEFAULT_MSS;
904 * i40iw_handle_tcp_options -
905 * @cm_node: connection's node
906 * @tcph: pointer tcp header
907 * @optionsize: size of options rcvd
908 * @passive: active or passive flag
910 static int i40iw_handle_tcp_options(struct i40iw_cm_node *cm_node,
915 u8 *optionsloc = (u8 *)&tcph[1];
918 if (i40iw_process_options(cm_node,
922 i40iw_debug(cm_node->dev,
924 "%s: Node %p, Sending RESET\n",
928 i40iw_passive_open_err(cm_node, true);
930 i40iw_active_open_err(cm_node, true);
935 cm_node->tcp_cntxt.snd_wnd = ntohs(tcph->window) <<
936 cm_node->tcp_cntxt.snd_wscale;
938 if (cm_node->tcp_cntxt.snd_wnd > cm_node->tcp_cntxt.max_snd_wnd)
939 cm_node->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.snd_wnd;
944 * i40iw_build_mpa_v1 - build a MPA V1 frame
945 * @cm_node: connection's node
946 * @mpa_key: to do read0 or write0
948 static void i40iw_build_mpa_v1(struct i40iw_cm_node *cm_node,
952 struct ietf_mpa_v1 *mpa_frame = (struct ietf_mpa_v1 *)start_addr;
955 case MPA_KEY_REQUEST:
956 memcpy(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE);
959 memcpy(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE);
964 mpa_frame->flags = IETF_MPA_FLAGS_CRC;
965 mpa_frame->rev = cm_node->mpa_frame_rev;
966 mpa_frame->priv_data_len = htons(cm_node->pdata.size);
970 * i40iw_build_mpa_v2 - build a MPA V2 frame
971 * @cm_node: connection's node
972 * @start_addr: buffer start address
973 * @mpa_key: to do read0 or write0
975 static void i40iw_build_mpa_v2(struct i40iw_cm_node *cm_node,
979 struct ietf_mpa_v2 *mpa_frame = (struct ietf_mpa_v2 *)start_addr;
980 struct ietf_rtr_msg *rtr_msg = &mpa_frame->rtr_msg;
982 /* initialize the upper 5 bytes of the frame */
983 i40iw_build_mpa_v1(cm_node, start_addr, mpa_key);
984 mpa_frame->flags |= IETF_MPA_V2_FLAG;
985 mpa_frame->priv_data_len += htons(IETF_RTR_MSG_SIZE);
987 /* initialize RTR msg */
988 if (cm_node->mpav2_ird_ord == IETF_NO_IRD_ORD) {
989 rtr_msg->ctrl_ird = IETF_NO_IRD_ORD;
990 rtr_msg->ctrl_ord = IETF_NO_IRD_ORD;
992 rtr_msg->ctrl_ird = (cm_node->ird_size > IETF_NO_IRD_ORD) ?
993 IETF_NO_IRD_ORD : cm_node->ird_size;
994 rtr_msg->ctrl_ord = (cm_node->ord_size > IETF_NO_IRD_ORD) ?
995 IETF_NO_IRD_ORD : cm_node->ord_size;
998 rtr_msg->ctrl_ird |= IETF_PEER_TO_PEER;
999 rtr_msg->ctrl_ird |= IETF_FLPDU_ZERO_LEN;
1002 case MPA_KEY_REQUEST:
1003 rtr_msg->ctrl_ord |= IETF_RDMA0_WRITE;
1004 rtr_msg->ctrl_ord |= IETF_RDMA0_READ;
1007 switch (cm_node->send_rdma0_op) {
1008 case SEND_RDMA_WRITE_ZERO:
1009 rtr_msg->ctrl_ord |= IETF_RDMA0_WRITE;
1011 case SEND_RDMA_READ_ZERO:
1012 rtr_msg->ctrl_ord |= IETF_RDMA0_READ;
1019 rtr_msg->ctrl_ird = htons(rtr_msg->ctrl_ird);
1020 rtr_msg->ctrl_ord = htons(rtr_msg->ctrl_ord);
1024 * i40iw_cm_build_mpa_frame - build mpa frame for mpa version 1 or version 2
1025 * @cm_node: connection's node
1026 * @mpa: mpa: data buffer
1027 * @mpa_key: to do read0 or write0
1029 static int i40iw_cm_build_mpa_frame(struct i40iw_cm_node *cm_node,
1030 struct i40iw_kmem_info *mpa,
1035 switch (cm_node->mpa_frame_rev) {
1037 hdr_len = sizeof(struct ietf_mpa_v1);
1038 i40iw_build_mpa_v1(cm_node, mpa->addr, mpa_key);
1041 hdr_len = sizeof(struct ietf_mpa_v2);
1042 i40iw_build_mpa_v2(cm_node, mpa->addr, mpa_key);
1052 * i40iw_send_mpa_request - active node send mpa request to passive node
1053 * @cm_node: connection's node
1055 static int i40iw_send_mpa_request(struct i40iw_cm_node *cm_node)
1057 struct i40iw_puda_buf *sqbuf;
1060 i40iw_pr_err("cm_node == NULL\n");
1064 cm_node->mpa_hdr.addr = &cm_node->mpa_frame;
1065 cm_node->mpa_hdr.size = i40iw_cm_build_mpa_frame(cm_node,
1068 if (!cm_node->mpa_hdr.size) {
1069 i40iw_pr_err("mpa size = %d\n", cm_node->mpa_hdr.size);
1073 sqbuf = i40iw_form_cm_frame(cm_node,
1079 i40iw_pr_err("sq_buf == NULL\n");
1083 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1087 * i40iw_send_mpa_reject -
1088 * @cm_node: connection's node
1089 * @pdata: reject data for connection
1090 * @plen: length of reject data
1092 static int i40iw_send_mpa_reject(struct i40iw_cm_node *cm_node,
1096 struct i40iw_puda_buf *sqbuf;
1097 struct i40iw_kmem_info priv_info;
1099 cm_node->mpa_hdr.addr = &cm_node->mpa_frame;
1100 cm_node->mpa_hdr.size = i40iw_cm_build_mpa_frame(cm_node,
1104 cm_node->mpa_frame.flags |= IETF_MPA_FLAGS_REJECT;
1105 priv_info.addr = (void *)pdata;
1106 priv_info.size = plen;
1108 sqbuf = i40iw_form_cm_frame(cm_node,
1114 i40iw_pr_err("no sqbuf\n");
1117 cm_node->state = I40IW_CM_STATE_FIN_WAIT1;
1118 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1122 * recv_mpa - process an IETF MPA frame
1123 * @cm_node: connection's node
1124 * @buffer: Data pointer
1125 * @type: to return accept or reject
1126 * @len: Len of mpa buffer
1128 static int i40iw_parse_mpa(struct i40iw_cm_node *cm_node, u8 *buffer, u32 *type, u32 len)
1130 struct ietf_mpa_v1 *mpa_frame;
1131 struct ietf_mpa_v2 *mpa_v2_frame;
1132 struct ietf_rtr_msg *rtr_msg;
1136 *type = I40IW_MPA_REQUEST_ACCEPT;
1138 if (len < sizeof(struct ietf_mpa_v1)) {
1139 i40iw_pr_err("ietf buffer small (%x)\n", len);
1143 mpa_frame = (struct ietf_mpa_v1 *)buffer;
1144 mpa_hdr_len = sizeof(struct ietf_mpa_v1);
1145 priv_data_len = ntohs(mpa_frame->priv_data_len);
1147 if (priv_data_len > IETF_MAX_PRIV_DATA_LEN) {
1148 i40iw_pr_err("large pri_data %d\n", priv_data_len);
1151 if (mpa_frame->rev != IETF_MPA_V1 && mpa_frame->rev != IETF_MPA_V2) {
1152 i40iw_pr_err("unsupported mpa rev = %d\n", mpa_frame->rev);
1155 if (mpa_frame->rev > cm_node->mpa_frame_rev) {
1156 i40iw_pr_err("rev %d\n", mpa_frame->rev);
1159 cm_node->mpa_frame_rev = mpa_frame->rev;
1161 if (cm_node->state != I40IW_CM_STATE_MPAREQ_SENT) {
1162 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE)) {
1163 i40iw_pr_err("Unexpected MPA Key received\n");
1167 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE)) {
1168 i40iw_pr_err("Unexpected MPA Key received\n");
1173 if (priv_data_len + mpa_hdr_len > len) {
1174 i40iw_pr_err("ietf buffer len(%x + %x != %x)\n",
1175 priv_data_len, mpa_hdr_len, len);
1178 if (len > MAX_CM_BUFFER) {
1179 i40iw_pr_err("ietf buffer large len = %d\n", len);
1183 switch (mpa_frame->rev) {
1190 mpa_v2_frame = (struct ietf_mpa_v2 *)buffer;
1191 mpa_hdr_len += IETF_RTR_MSG_SIZE;
1192 rtr_msg = &mpa_v2_frame->rtr_msg;
1194 /* parse rtr message */
1195 ctrl_ord = ntohs(rtr_msg->ctrl_ord);
1196 ctrl_ird = ntohs(rtr_msg->ctrl_ird);
1197 ird_size = ctrl_ird & IETF_NO_IRD_ORD;
1198 ord_size = ctrl_ord & IETF_NO_IRD_ORD;
1200 if (!(ctrl_ird & IETF_PEER_TO_PEER))
1203 if (ird_size == IETF_NO_IRD_ORD || ord_size == IETF_NO_IRD_ORD) {
1204 cm_node->mpav2_ird_ord = IETF_NO_IRD_ORD;
1205 goto negotiate_done;
1208 if (cm_node->state != I40IW_CM_STATE_MPAREQ_SENT) {
1210 if (!ord_size && (ctrl_ord & IETF_RDMA0_READ))
1211 cm_node->ird_size = 1;
1212 if (cm_node->ord_size > ird_size)
1213 cm_node->ord_size = ird_size;
1216 if (!ird_size && (ctrl_ord & IETF_RDMA0_READ))
1218 if (cm_node->ord_size > ird_size)
1219 cm_node->ord_size = ird_size;
1221 if (cm_node->ird_size < ord_size)
1222 /* no resources available */
1227 if (ctrl_ord & IETF_RDMA0_READ)
1228 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
1229 else if (ctrl_ord & IETF_RDMA0_WRITE)
1230 cm_node->send_rdma0_op = SEND_RDMA_WRITE_ZERO;
1231 else /* Not supported RDMA0 operation */
1233 i40iw_debug(cm_node->dev, I40IW_DEBUG_CM,
1234 "MPAV2: Negotiated ORD: %d, IRD: %d\n",
1235 cm_node->ord_size, cm_node->ird_size);
1244 memcpy(cm_node->pdata_buf, buffer + mpa_hdr_len, priv_data_len);
1245 cm_node->pdata.size = priv_data_len;
1247 if (mpa_frame->flags & IETF_MPA_FLAGS_REJECT)
1248 *type = I40IW_MPA_REQUEST_REJECT;
1250 if (mpa_frame->flags & IETF_MPA_FLAGS_MARKERS)
1251 cm_node->snd_mark_en = true;
1257 * i40iw_schedule_cm_timer
1258 * @@cm_node: connection's node
1259 * @sqbuf: buffer to send
1260 * @type: if it es send ot close
1261 * @send_retrans: if rexmits to be done
1262 * @close_when_complete: is cm_node to be removed
1264 * note - cm_node needs to be protected before calling this. Encase in:
1265 * i40iw_rem_ref_cm_node(cm_core, cm_node);
1266 * i40iw_schedule_cm_timer(...)
1267 * atomic_inc(&cm_node->ref_count);
1269 int i40iw_schedule_cm_timer(struct i40iw_cm_node *cm_node,
1270 struct i40iw_puda_buf *sqbuf,
1271 enum i40iw_timer_type type,
1273 int close_when_complete)
1275 struct i40iw_sc_dev *dev = cm_node->dev;
1276 struct i40iw_cm_core *cm_core = cm_node->cm_core;
1277 struct i40iw_timer_entry *new_send;
1280 unsigned long flags;
1282 new_send = kzalloc(sizeof(*new_send), GFP_ATOMIC);
1284 i40iw_free_sqbuf(cm_node->dev, (void *)sqbuf);
1287 new_send->retrycount = I40IW_DEFAULT_RETRYS;
1288 new_send->retranscount = I40IW_DEFAULT_RETRANS;
1289 new_send->sqbuf = sqbuf;
1290 new_send->timetosend = jiffies;
1291 new_send->type = type;
1292 new_send->send_retrans = send_retrans;
1293 new_send->close_when_complete = close_when_complete;
1295 if (type == I40IW_TIMER_TYPE_CLOSE) {
1296 new_send->timetosend += (HZ / 10);
1297 if (cm_node->close_entry) {
1299 i40iw_free_sqbuf(cm_node->dev, (void *)sqbuf);
1300 i40iw_pr_err("already close entry\n");
1303 cm_node->close_entry = new_send;
1306 if (type == I40IW_TIMER_TYPE_SEND) {
1307 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1308 cm_node->send_entry = new_send;
1309 atomic_inc(&cm_node->ref_count);
1310 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1311 new_send->timetosend = jiffies + I40IW_RETRY_TIMEOUT;
1313 atomic_inc(&sqbuf->refcount);
1314 i40iw_puda_send_buf(dev->ilq, sqbuf);
1315 if (!send_retrans) {
1316 i40iw_cleanup_retrans_entry(cm_node);
1317 if (close_when_complete)
1318 i40iw_rem_ref_cm_node(cm_node);
1323 spin_lock_irqsave(&cm_core->ht_lock, flags);
1324 was_timer_set = timer_pending(&cm_core->tcp_timer);
1326 if (!was_timer_set) {
1327 cm_core->tcp_timer.expires = new_send->timetosend;
1328 add_timer(&cm_core->tcp_timer);
1330 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1336 * i40iw_retrans_expired - Could not rexmit the packet
1337 * @cm_node: connection's node
1339 static void i40iw_retrans_expired(struct i40iw_cm_node *cm_node)
1341 struct iw_cm_id *cm_id = cm_node->cm_id;
1342 enum i40iw_cm_node_state state = cm_node->state;
1344 cm_node->state = I40IW_CM_STATE_CLOSED;
1346 case I40IW_CM_STATE_SYN_RCVD:
1347 case I40IW_CM_STATE_CLOSING:
1348 i40iw_rem_ref_cm_node(cm_node);
1350 case I40IW_CM_STATE_FIN_WAIT1:
1351 case I40IW_CM_STATE_LAST_ACK:
1353 cm_id->rem_ref(cm_id);
1354 i40iw_send_reset(cm_node);
1357 atomic_inc(&cm_node->ref_count);
1358 i40iw_send_reset(cm_node);
1359 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
1365 * i40iw_handle_close_entry - for handling retry/timeouts
1366 * @cm_node: connection's node
1367 * @rem_node: flag for remove cm_node
1369 static void i40iw_handle_close_entry(struct i40iw_cm_node *cm_node, u32 rem_node)
1371 struct i40iw_timer_entry *close_entry = cm_node->close_entry;
1372 struct iw_cm_id *cm_id = cm_node->cm_id;
1373 struct i40iw_qp *iwqp;
1374 unsigned long flags;
1378 iwqp = (struct i40iw_qp *)close_entry->sqbuf;
1380 spin_lock_irqsave(&iwqp->lock, flags);
1382 iwqp->hw_tcp_state = I40IW_TCP_STATE_CLOSED;
1383 iwqp->hw_iwarp_state = I40IW_QP_STATE_ERROR;
1384 iwqp->last_aeq = I40IW_AE_RESET_SENT;
1385 iwqp->ibqp_state = IB_QPS_ERR;
1386 spin_unlock_irqrestore(&iwqp->lock, flags);
1387 i40iw_cm_disconn(iwqp);
1389 spin_unlock_irqrestore(&iwqp->lock, flags);
1391 } else if (rem_node) {
1392 /* TIME_WAIT state */
1393 i40iw_rem_ref_cm_node(cm_node);
1396 cm_id->rem_ref(cm_id);
1398 cm_node->close_entry = NULL;
1402 * i40iw_cm_timer_tick - system's timer expired callback
1403 * @pass: Pointing to cm_core
1405 static void i40iw_cm_timer_tick(unsigned long pass)
1407 unsigned long nexttimeout = jiffies + I40IW_LONG_TIME;
1408 struct i40iw_cm_node *cm_node;
1409 struct i40iw_timer_entry *send_entry, *close_entry;
1410 struct list_head *list_core_temp;
1411 struct list_head *list_node;
1412 struct i40iw_cm_core *cm_core = (struct i40iw_cm_core *)pass;
1414 unsigned long timetosend;
1415 struct i40iw_sc_dev *dev;
1416 unsigned long flags;
1418 struct list_head timer_list;
1420 INIT_LIST_HEAD(&timer_list);
1421 spin_lock_irqsave(&cm_core->ht_lock, flags);
1423 list_for_each_safe(list_node, list_core_temp, &cm_core->connected_nodes) {
1424 cm_node = container_of(list_node, struct i40iw_cm_node, list);
1425 if (cm_node->close_entry || cm_node->send_entry) {
1426 atomic_inc(&cm_node->ref_count);
1427 list_add(&cm_node->timer_entry, &timer_list);
1430 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1432 list_for_each_safe(list_node, list_core_temp, &timer_list) {
1433 cm_node = container_of(list_node,
1434 struct i40iw_cm_node,
1436 close_entry = cm_node->close_entry;
1439 if (time_after(close_entry->timetosend, jiffies)) {
1440 if (nexttimeout > close_entry->timetosend ||
1442 nexttimeout = close_entry->timetosend;
1446 i40iw_handle_close_entry(cm_node, 1);
1450 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1452 send_entry = cm_node->send_entry;
1455 if (time_after(send_entry->timetosend, jiffies)) {
1456 if (cm_node->state != I40IW_CM_STATE_OFFLOADED) {
1457 if ((nexttimeout > send_entry->timetosend) ||
1459 nexttimeout = send_entry->timetosend;
1463 i40iw_free_retrans_entry(cm_node);
1468 if ((cm_node->state == I40IW_CM_STATE_OFFLOADED) ||
1469 (cm_node->state == I40IW_CM_STATE_CLOSED)) {
1470 i40iw_free_retrans_entry(cm_node);
1474 if (!send_entry->retranscount || !send_entry->retrycount) {
1475 i40iw_free_retrans_entry(cm_node);
1477 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1478 i40iw_retrans_expired(cm_node);
1479 cm_node->state = I40IW_CM_STATE_CLOSED;
1480 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1483 cm_node->cm_core->stats_pkt_retrans++;
1484 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1487 atomic_inc(&send_entry->sqbuf->refcount);
1488 i40iw_puda_send_buf(dev->ilq, send_entry->sqbuf);
1489 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1490 if (send_entry->send_retrans) {
1491 send_entry->retranscount--;
1492 timetosend = (I40IW_RETRY_TIMEOUT <<
1493 (I40IW_DEFAULT_RETRANS -
1494 send_entry->retranscount));
1496 send_entry->timetosend = jiffies +
1497 min(timetosend, I40IW_MAX_TIMEOUT);
1498 if (nexttimeout > send_entry->timetosend || !settimer) {
1499 nexttimeout = send_entry->timetosend;
1503 int close_when_complete;
1505 close_when_complete = send_entry->close_when_complete;
1506 i40iw_debug(cm_node->dev,
1508 "cm_node=%p state=%d\n",
1511 i40iw_free_retrans_entry(cm_node);
1512 if (close_when_complete)
1513 i40iw_rem_ref_cm_node(cm_node);
1516 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1517 i40iw_rem_ref_cm_node(cm_node);
1521 spin_lock_irqsave(&cm_core->ht_lock, flags);
1522 if (!timer_pending(&cm_core->tcp_timer)) {
1523 cm_core->tcp_timer.expires = nexttimeout;
1524 add_timer(&cm_core->tcp_timer);
1526 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1531 * i40iw_send_syn - send SYN packet
1532 * @cm_node: connection's node
1533 * @sendack: flag to set ACK bit or not
1535 int i40iw_send_syn(struct i40iw_cm_node *cm_node, u32 sendack)
1537 struct i40iw_puda_buf *sqbuf;
1538 int flags = SET_SYN;
1539 char optionsbuffer[sizeof(struct option_mss) +
1540 sizeof(struct option_windowscale) +
1541 sizeof(struct option_base) + TCP_OPTIONS_PADDING];
1542 struct i40iw_kmem_info opts;
1544 int optionssize = 0;
1545 /* Sending MSS option */
1546 union all_known_options *options;
1548 opts.addr = optionsbuffer;
1550 i40iw_pr_err("no cm_node\n");
1554 options = (union all_known_options *)&optionsbuffer[optionssize];
1555 options->as_mss.optionnum = OPTION_NUMBER_MSS;
1556 options->as_mss.length = sizeof(struct option_mss);
1557 options->as_mss.mss = htons(cm_node->tcp_cntxt.mss);
1558 optionssize += sizeof(struct option_mss);
1560 options = (union all_known_options *)&optionsbuffer[optionssize];
1561 options->as_windowscale.optionnum = OPTION_NUMBER_WINDOW_SCALE;
1562 options->as_windowscale.length = sizeof(struct option_windowscale);
1563 options->as_windowscale.shiftcount = cm_node->tcp_cntxt.rcv_wscale;
1564 optionssize += sizeof(struct option_windowscale);
1565 options = (union all_known_options *)&optionsbuffer[optionssize];
1566 options->as_end = OPTION_NUMBER_END;
1572 opts.size = optionssize;
1574 sqbuf = i40iw_form_cm_frame(cm_node, &opts, NULL, NULL, flags);
1576 i40iw_pr_err("no sqbuf\n");
1579 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1583 * i40iw_send_ack - Send ACK packet
1584 * @cm_node: connection's node
1586 static void i40iw_send_ack(struct i40iw_cm_node *cm_node)
1588 struct i40iw_puda_buf *sqbuf;
1590 sqbuf = i40iw_form_cm_frame(cm_node, NULL, NULL, NULL, SET_ACK);
1592 i40iw_puda_send_buf(cm_node->dev->ilq, sqbuf);
1594 i40iw_pr_err("no sqbuf\n");
1598 * i40iw_send_fin - Send FIN pkt
1599 * @cm_node: connection's node
1601 static int i40iw_send_fin(struct i40iw_cm_node *cm_node)
1603 struct i40iw_puda_buf *sqbuf;
1605 sqbuf = i40iw_form_cm_frame(cm_node, NULL, NULL, NULL, SET_ACK | SET_FIN);
1607 i40iw_pr_err("no sqbuf\n");
1610 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1614 * i40iw_find_node - find a cm node that matches the reference cm node
1615 * @cm_core: cm's core
1616 * @rem_port: remote tcp port num
1617 * @rem_addr: remote ip addr
1618 * @loc_port: local tcp port num
1619 * @loc_addr: loc ip addr
1620 * @add_refcnt: flag to increment refcount of cm_node
1622 struct i40iw_cm_node *i40iw_find_node(struct i40iw_cm_core *cm_core,
1629 struct list_head *hte;
1630 struct i40iw_cm_node *cm_node;
1631 unsigned long flags;
1633 hte = &cm_core->connected_nodes;
1635 /* walk list and find cm_node associated with this session ID */
1636 spin_lock_irqsave(&cm_core->ht_lock, flags);
1637 list_for_each_entry(cm_node, hte, list) {
1638 if (!memcmp(cm_node->map_loc_addr, loc_addr, sizeof(cm_node->map_loc_addr)) &&
1639 (cm_node->map_loc_port == loc_port) &&
1640 !memcmp(cm_node->map_rem_addr, rem_addr, sizeof(cm_node->map_rem_addr)) &&
1641 (cm_node->map_rem_port == rem_port)) {
1643 atomic_inc(&cm_node->ref_count);
1644 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1648 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1655 * i40iw_find_listener - find a cm node listening on this addr-port pair
1656 * @cm_core: cm's core
1657 * @dst_port: listener tcp port num
1658 * @dst_addr: listener ip addr
1659 * @listener_state: state to match with listen node's
1661 static struct i40iw_cm_listener *i40iw_find_listener(
1662 struct i40iw_cm_core *cm_core,
1666 enum i40iw_cm_listener_state
1670 struct i40iw_cm_listener *listen_node;
1671 static const u32 ip_zero[4] = { 0, 0, 0, 0 };
1674 unsigned long flags;
1676 /* walk list and find cm_node associated with this session ID */
1677 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
1678 list_for_each_entry(listen_node, &cm_core->listen_nodes, list) {
1680 memcpy(listen_addr, listen_node->map_loc_addr, sizeof(listen_addr));
1681 listen_port = listen_node->map_loc_port;
1683 memcpy(listen_addr, listen_node->loc_addr, sizeof(listen_addr));
1684 listen_port = listen_node->loc_port;
1686 /* compare node pair, return node handle if a match */
1687 if ((!memcmp(listen_addr, dst_addr, sizeof(listen_addr)) ||
1688 !memcmp(listen_addr, ip_zero, sizeof(listen_addr))) &&
1689 (listen_port == dst_port) &&
1690 (listener_state & listen_node->listener_state)) {
1691 atomic_inc(&listen_node->ref_count);
1692 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
1696 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
1701 * i40iw_add_hte_node - add a cm node to the hash table
1702 * @cm_core: cm's core
1703 * @cm_node: connection's node
1705 static void i40iw_add_hte_node(struct i40iw_cm_core *cm_core,
1706 struct i40iw_cm_node *cm_node)
1708 struct list_head *hte;
1709 unsigned long flags;
1711 if (!cm_node || !cm_core) {
1712 i40iw_pr_err("cm_node or cm_core == NULL\n");
1715 spin_lock_irqsave(&cm_core->ht_lock, flags);
1717 /* get a handle on the hash table element (list head for this slot) */
1718 hte = &cm_core->connected_nodes;
1719 list_add_tail(&cm_node->list, hte);
1720 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1724 * listen_port_in_use - determine if port is in use
1725 * @port: Listen port number
1727 static bool i40iw_listen_port_in_use(struct i40iw_cm_core *cm_core, u16 port)
1729 struct i40iw_cm_listener *listen_node;
1730 unsigned long flags;
1733 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
1734 list_for_each_entry(listen_node, &cm_core->listen_nodes, list) {
1735 if (listen_node->map_loc_port == port) {
1740 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
1745 * i40iw_del_multiple_qhash - Remove qhash and child listens
1746 * @iwdev: iWarp device
1747 * @cm_info: CM info for parent listen node
1748 * @cm_parent_listen_node: The parent listen node
1750 static enum i40iw_status_code i40iw_del_multiple_qhash(
1751 struct i40iw_device *iwdev,
1752 struct i40iw_cm_info *cm_info,
1753 struct i40iw_cm_listener *cm_parent_listen_node)
1755 struct i40iw_cm_listener *child_listen_node;
1756 enum i40iw_status_code ret = I40IW_ERR_CONFIG;
1757 struct list_head *pos, *tpos;
1758 unsigned long flags;
1760 spin_lock_irqsave(&iwdev->cm_core.listen_list_lock, flags);
1761 list_for_each_safe(pos, tpos, &cm_parent_listen_node->child_listen_list) {
1762 child_listen_node = list_entry(pos, struct i40iw_cm_listener, child_listen_list);
1763 if (child_listen_node->ipv4)
1764 i40iw_debug(&iwdev->sc_dev,
1766 "removing child listen for IP=%pI4, port=%d, vlan=%d\n",
1767 child_listen_node->loc_addr,
1768 child_listen_node->loc_port,
1769 child_listen_node->vlan_id);
1771 i40iw_debug(&iwdev->sc_dev, I40IW_DEBUG_CM,
1772 "removing child listen for IP=%pI6, port=%d, vlan=%d\n",
1773 child_listen_node->loc_addr,
1774 child_listen_node->loc_port,
1775 child_listen_node->vlan_id);
1777 memcpy(cm_info->map_loc_addr, child_listen_node->map_loc_addr,
1778 sizeof(cm_info->map_loc_addr));
1779 memcpy(cm_info->loc_addr, child_listen_node->loc_addr,
1780 sizeof(cm_info->loc_addr));
1781 cm_info->vlan_id = child_listen_node->vlan_id;
1782 ret = i40iw_manage_qhash(iwdev, cm_info,
1783 I40IW_QHASH_TYPE_TCP_SYN,
1784 I40IW_QHASH_MANAGE_TYPE_DELETE, NULL, false);
1785 kfree(child_listen_node);
1786 cm_parent_listen_node->cm_core->stats_listen_nodes_destroyed++;
1787 i40iw_debug(&iwdev->sc_dev,
1789 "freed pointer = %p\n",
1792 spin_unlock_irqrestore(&iwdev->cm_core.listen_list_lock, flags);
1798 * i40iw_netdev_vlan_ipv6 - Gets the netdev and mac
1799 * @addr: local IPv6 address
1800 * @vlan_id: vlan id for the given IPv6 address
1801 * @mac: mac address for the given IPv6 address
1803 * Returns the net_device of the IPv6 address and also sets the
1804 * vlan id and mac for that address.
1806 static struct net_device *i40iw_netdev_vlan_ipv6(u32 *addr, u16 *vlan_id, u8 *mac)
1808 struct net_device *ip_dev = NULL;
1809 #if IS_ENABLED(CONFIG_IPV6)
1810 struct in6_addr laddr6;
1812 i40iw_copy_ip_htonl(laddr6.in6_u.u6_addr32, addr);
1814 *vlan_id = I40IW_NO_VLAN;
1818 for_each_netdev_rcu(&init_net, ip_dev) {
1819 if (ipv6_chk_addr(&init_net, &laddr6, ip_dev, 1)) {
1821 *vlan_id = rdma_vlan_dev_vlan_id(ip_dev);
1822 if (ip_dev->dev_addr && mac)
1823 ether_addr_copy(mac, ip_dev->dev_addr);
1833 * i40iw_get_vlan_ipv4 - Returns the vlan_id for IPv4 address
1834 * @addr: local IPv4 address
1836 static u16 i40iw_get_vlan_ipv4(u32 *addr)
1838 struct net_device *netdev;
1839 u16 vlan_id = I40IW_NO_VLAN;
1841 netdev = ip_dev_find(&init_net, htonl(addr[0]));
1843 vlan_id = rdma_vlan_dev_vlan_id(netdev);
1850 * i40iw_add_mqh_6 - Adds multiple qhashes for IPv6
1851 * @iwdev: iWarp device
1852 * @cm_info: CM info for parent listen node
1853 * @cm_parent_listen_node: The parent listen node
1855 * Adds a qhash and a child listen node for every IPv6 address
1856 * on the adapter and adds the associated qhash filter
1858 static enum i40iw_status_code i40iw_add_mqh_6(struct i40iw_device *iwdev,
1859 struct i40iw_cm_info *cm_info,
1860 struct i40iw_cm_listener *cm_parent_listen_node)
1862 struct net_device *ip_dev;
1863 struct inet6_dev *idev;
1864 struct inet6_ifaddr *ifp;
1865 enum i40iw_status_code ret = 0;
1866 struct i40iw_cm_listener *child_listen_node;
1867 unsigned long flags;
1870 for_each_netdev_rcu(&init_net, ip_dev) {
1871 if ((((rdma_vlan_dev_vlan_id(ip_dev) < I40IW_NO_VLAN) &&
1872 (rdma_vlan_dev_real_dev(ip_dev) == iwdev->netdev)) ||
1873 (ip_dev == iwdev->netdev)) && (ip_dev->flags & IFF_UP)) {
1874 idev = __in6_dev_get(ip_dev);
1876 i40iw_pr_err("idev == NULL\n");
1879 list_for_each_entry(ifp, &idev->addr_list, if_list) {
1880 i40iw_debug(&iwdev->sc_dev,
1882 "IP=%pI6, vlan_id=%d, MAC=%pM\n",
1884 rdma_vlan_dev_vlan_id(ip_dev),
1887 kzalloc(sizeof(*child_listen_node), GFP_ATOMIC);
1888 i40iw_debug(&iwdev->sc_dev,
1890 "Allocating child listener %p\n",
1892 if (!child_listen_node) {
1893 i40iw_pr_err("listener memory allocation\n");
1894 ret = I40IW_ERR_NO_MEMORY;
1897 cm_info->vlan_id = rdma_vlan_dev_vlan_id(ip_dev);
1898 cm_parent_listen_node->vlan_id = cm_info->vlan_id;
1900 memcpy(child_listen_node, cm_parent_listen_node,
1901 sizeof(*child_listen_node));
1903 i40iw_copy_ip_ntohl(child_listen_node->loc_addr,
1904 ifp->addr.in6_u.u6_addr32);
1905 i40iw_copy_ip_ntohl(child_listen_node->map_loc_addr,
1906 ifp->addr.in6_u.u6_addr32);
1908 memcpy(cm_info->map_loc_addr, child_listen_node->map_loc_addr,
1909 sizeof(cm_info->map_loc_addr));
1910 memcpy(cm_info->loc_addr, child_listen_node->loc_addr,
1911 sizeof(cm_info->loc_addr));
1913 ret = i40iw_manage_qhash(iwdev, cm_info,
1914 I40IW_QHASH_TYPE_TCP_SYN,
1915 I40IW_QHASH_MANAGE_TYPE_ADD,
1918 spin_lock_irqsave(&iwdev->cm_core.listen_list_lock, flags);
1919 list_add(&child_listen_node->child_listen_list,
1920 &cm_parent_listen_node->child_listen_list);
1921 spin_unlock_irqrestore(&iwdev->cm_core.listen_list_lock, flags);
1922 cm_parent_listen_node->cm_core->stats_listen_nodes_created++;
1924 kfree(child_listen_node);
1935 * i40iw_add_mqh_4 - Adds multiple qhashes for IPv4
1936 * @iwdev: iWarp device
1937 * @cm_info: CM info for parent listen node
1938 * @cm_parent_listen_node: The parent listen node
1940 * Adds a qhash and a child listen node for every IPv4 address
1941 * on the adapter and adds the associated qhash filter
1943 static enum i40iw_status_code i40iw_add_mqh_4(
1944 struct i40iw_device *iwdev,
1945 struct i40iw_cm_info *cm_info,
1946 struct i40iw_cm_listener *cm_parent_listen_node)
1948 struct net_device *dev;
1949 struct in_device *idev;
1950 struct i40iw_cm_listener *child_listen_node;
1951 enum i40iw_status_code ret = 0;
1952 unsigned long flags;
1955 for_each_netdev(&init_net, dev) {
1956 if ((((rdma_vlan_dev_vlan_id(dev) < I40IW_NO_VLAN) &&
1957 (rdma_vlan_dev_real_dev(dev) == iwdev->netdev)) ||
1958 (dev == iwdev->netdev)) && (dev->flags & IFF_UP)) {
1959 idev = in_dev_get(dev);
1961 i40iw_debug(&iwdev->sc_dev,
1963 "Allocating child CM Listener forIP=%pI4, vlan_id=%d, MAC=%pM\n",
1965 rdma_vlan_dev_vlan_id(dev),
1967 child_listen_node = kzalloc(sizeof(*child_listen_node), GFP_ATOMIC);
1968 cm_parent_listen_node->cm_core->stats_listen_nodes_created++;
1969 i40iw_debug(&iwdev->sc_dev,
1971 "Allocating child listener %p\n",
1973 if (!child_listen_node) {
1974 i40iw_pr_err("listener memory allocation\n");
1976 ret = I40IW_ERR_NO_MEMORY;
1979 cm_info->vlan_id = rdma_vlan_dev_vlan_id(dev);
1980 cm_parent_listen_node->vlan_id = cm_info->vlan_id;
1981 memcpy(child_listen_node,
1982 cm_parent_listen_node,
1983 sizeof(*child_listen_node));
1985 child_listen_node->loc_addr[0] = ntohl(ifa->ifa_address);
1986 child_listen_node->map_loc_addr[0] = ntohl(ifa->ifa_address);
1988 memcpy(cm_info->map_loc_addr, child_listen_node->map_loc_addr,
1989 sizeof(cm_info->map_loc_addr));
1990 memcpy(cm_info->loc_addr, child_listen_node->loc_addr,
1991 sizeof(cm_info->loc_addr));
1993 ret = i40iw_manage_qhash(iwdev,
1995 I40IW_QHASH_TYPE_TCP_SYN,
1996 I40IW_QHASH_MANAGE_TYPE_ADD,
2000 spin_lock_irqsave(&iwdev->cm_core.listen_list_lock, flags);
2001 list_add(&child_listen_node->child_listen_list,
2002 &cm_parent_listen_node->child_listen_list);
2003 spin_unlock_irqrestore(&iwdev->cm_core.listen_list_lock, flags);
2005 kfree(child_listen_node);
2006 cm_parent_listen_node->cm_core->stats_listen_nodes_created--;
2019 * i40iw_dec_refcnt_listen - delete listener and associated cm nodes
2020 * @cm_core: cm's core
2021 * @free_hanging_nodes: to free associated cm_nodes
2022 * @apbvt_del: flag to delete the apbvt
2024 static int i40iw_dec_refcnt_listen(struct i40iw_cm_core *cm_core,
2025 struct i40iw_cm_listener *listener,
2026 int free_hanging_nodes, bool apbvt_del)
2030 struct list_head *list_pos;
2031 struct list_head *list_temp;
2032 struct i40iw_cm_node *cm_node;
2033 struct list_head reset_list;
2034 struct i40iw_cm_info nfo;
2035 struct i40iw_cm_node *loopback;
2036 enum i40iw_cm_node_state old_state;
2037 unsigned long flags;
2039 /* free non-accelerated child nodes for this listener */
2040 INIT_LIST_HEAD(&reset_list);
2041 if (free_hanging_nodes) {
2042 spin_lock_irqsave(&cm_core->ht_lock, flags);
2043 list_for_each_safe(list_pos, list_temp, &cm_core->connected_nodes) {
2044 cm_node = container_of(list_pos, struct i40iw_cm_node, list);
2045 if ((cm_node->listener == listener) && !cm_node->accelerated) {
2046 atomic_inc(&cm_node->ref_count);
2047 list_add(&cm_node->reset_entry, &reset_list);
2050 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
2053 list_for_each_safe(list_pos, list_temp, &reset_list) {
2054 cm_node = container_of(list_pos, struct i40iw_cm_node, reset_entry);
2055 loopback = cm_node->loopbackpartner;
2056 if (cm_node->state >= I40IW_CM_STATE_FIN_WAIT1) {
2057 i40iw_rem_ref_cm_node(cm_node);
2060 i40iw_cleanup_retrans_entry(cm_node);
2061 err = i40iw_send_reset(cm_node);
2063 cm_node->state = I40IW_CM_STATE_CLOSED;
2064 i40iw_pr_err("send reset\n");
2066 old_state = cm_node->state;
2067 cm_node->state = I40IW_CM_STATE_LISTENER_DESTROYED;
2068 if (old_state != I40IW_CM_STATE_MPAREQ_RCVD)
2069 i40iw_rem_ref_cm_node(cm_node);
2072 struct i40iw_cm_event event;
2074 event.cm_node = loopback;
2075 memcpy(event.cm_info.rem_addr,
2076 loopback->rem_addr, sizeof(event.cm_info.rem_addr));
2077 memcpy(event.cm_info.loc_addr,
2078 loopback->loc_addr, sizeof(event.cm_info.loc_addr));
2079 event.cm_info.rem_port = loopback->rem_port;
2080 event.cm_info.loc_port = loopback->loc_port;
2081 event.cm_info.cm_id = loopback->cm_id;
2082 event.cm_info.ipv4 = loopback->ipv4;
2083 atomic_inc(&loopback->ref_count);
2084 loopback->state = I40IW_CM_STATE_CLOSED;
2085 i40iw_event_connect_error(&event);
2086 cm_node->state = I40IW_CM_STATE_LISTENER_DESTROYED;
2087 i40iw_rem_ref_cm_node(cm_node);
2092 if (!atomic_dec_return(&listener->ref_count)) {
2093 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
2094 list_del(&listener->list);
2095 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
2097 if (listener->iwdev) {
2098 if (apbvt_del && !i40iw_listen_port_in_use(cm_core, listener->map_loc_port))
2099 i40iw_manage_apbvt(listener->iwdev,
2100 listener->map_loc_port,
2101 I40IW_MANAGE_APBVT_DEL);
2103 memcpy(nfo.loc_addr, listener->loc_addr, sizeof(nfo.loc_addr));
2104 memcpy(nfo.map_loc_addr, listener->map_loc_addr, sizeof(nfo.map_loc_addr));
2105 nfo.loc_port = listener->loc_port;
2106 nfo.map_loc_port = listener->map_loc_port;
2107 nfo.ipv4 = listener->ipv4;
2108 nfo.vlan_id = listener->vlan_id;
2110 i40iw_remove_mapinfo(&nfo);
2112 if (!list_empty(&listener->child_listen_list)) {
2113 i40iw_del_multiple_qhash(listener->iwdev, &nfo, listener);
2115 if (listener->qhash_set)
2116 i40iw_manage_qhash(listener->iwdev,
2118 I40IW_QHASH_TYPE_TCP_SYN,
2119 I40IW_QHASH_MANAGE_TYPE_DELETE,
2125 cm_core->stats_listen_destroyed++;
2127 cm_core->stats_listen_nodes_destroyed++;
2133 if (atomic_read(&listener->pend_accepts_cnt) > 0)
2134 i40iw_debug(cm_core->dev,
2136 "%s: listener (%p) pending accepts=%u\n",
2139 atomic_read(&listener->pend_accepts_cnt));
2146 * i40iw_cm_del_listen - delete a linstener
2147 * @cm_core: cm's core
2148 * @listener: passive connection's listener
2149 * @apbvt_del: flag to delete apbvt
2151 static int i40iw_cm_del_listen(struct i40iw_cm_core *cm_core,
2152 struct i40iw_cm_listener *listener,
2155 listener->listener_state = I40IW_CM_LISTENER_PASSIVE_STATE;
2156 listener->cm_id = NULL; /* going to be destroyed pretty soon */
2157 return i40iw_dec_refcnt_listen(cm_core, listener, 1, apbvt_del);
2161 * i40iw_addr_resolve_neigh - resolve neighbor address
2162 * @iwdev: iwarp device structure
2163 * @src_ip: local ip address
2164 * @dst_ip: remote ip address
2165 * @arpindex: if there is an arp entry
2167 static int i40iw_addr_resolve_neigh(struct i40iw_device *iwdev,
2173 struct neighbour *neigh;
2175 struct net_device *netdev = iwdev->netdev;
2176 __be32 dst_ipaddr = htonl(dst_ip);
2177 __be32 src_ipaddr = htonl(src_ip);
2179 rt = ip_route_output(&init_net, dst_ipaddr, src_ipaddr, 0, 0);
2181 i40iw_pr_err("ip_route_output\n");
2185 if (netif_is_bond_slave(netdev))
2186 netdev = netdev_master_upper_dev_get(netdev);
2188 neigh = dst_neigh_lookup(&rt->dst, &dst_ipaddr);
2192 if (neigh->nud_state & NUD_VALID) {
2193 if (arpindex >= 0) {
2194 if (ether_addr_equal(iwdev->arp_table[arpindex].mac_addr,
2196 /* Mac address same as arp table */
2197 goto resolve_neigh_exit;
2198 i40iw_manage_arp_cache(iwdev,
2199 iwdev->arp_table[arpindex].mac_addr,
2205 i40iw_manage_arp_cache(iwdev, neigh->ha, &dst_ip, true, I40IW_ARP_ADD);
2206 rc = i40iw_arp_table(iwdev, &dst_ip, true, NULL, I40IW_ARP_RESOLVE);
2208 neigh_event_send(neigh, NULL);
2215 neigh_release(neigh);
2222 * i40iw_get_dst_ipv6
2224 #if IS_ENABLED(CONFIG_IPV6)
2225 static struct dst_entry *i40iw_get_dst_ipv6(struct sockaddr_in6 *src_addr,
2226 struct sockaddr_in6 *dst_addr)
2228 struct dst_entry *dst;
2231 memset(&fl6, 0, sizeof(fl6));
2232 fl6.daddr = dst_addr->sin6_addr;
2233 fl6.saddr = src_addr->sin6_addr;
2234 if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
2235 fl6.flowi6_oif = dst_addr->sin6_scope_id;
2237 dst = ip6_route_output(&init_net, NULL, &fl6);
2243 * i40iw_addr_resolve_neigh_ipv6 - resolve neighbor ipv6 address
2244 * @iwdev: iwarp device structure
2245 * @dst_ip: remote ip address
2246 * @arpindex: if there is an arp entry
2248 #if IS_ENABLED(CONFIG_IPV6)
2249 static int i40iw_addr_resolve_neigh_ipv6(struct i40iw_device *iwdev,
2254 struct neighbour *neigh;
2256 struct net_device *netdev = iwdev->netdev;
2257 struct dst_entry *dst;
2258 struct sockaddr_in6 dst_addr;
2259 struct sockaddr_in6 src_addr;
2261 memset(&dst_addr, 0, sizeof(dst_addr));
2262 dst_addr.sin6_family = AF_INET6;
2263 i40iw_copy_ip_htonl(dst_addr.sin6_addr.in6_u.u6_addr32, dest);
2264 memset(&src_addr, 0, sizeof(src_addr));
2265 src_addr.sin6_family = AF_INET6;
2266 i40iw_copy_ip_htonl(src_addr.sin6_addr.in6_u.u6_addr32, src);
2267 dst = i40iw_get_dst_ipv6(&src_addr, &dst_addr);
2268 if (!dst || dst->error) {
2271 i40iw_pr_err("ip6_route_output returned dst->error = %d\n",
2277 if (netif_is_bond_slave(netdev))
2278 netdev = netdev_master_upper_dev_get(netdev);
2280 neigh = dst_neigh_lookup(dst, &dst_addr);
2284 i40iw_debug(&iwdev->sc_dev, I40IW_DEBUG_CM, "dst_neigh_lookup MAC=%pM\n", neigh->ha);
2285 if (neigh->nud_state & NUD_VALID) {
2286 if (arpindex >= 0) {
2287 if (ether_addr_equal
2288 (iwdev->arp_table[arpindex].mac_addr,
2290 /* Mac address same as in arp table */
2291 goto resolve_neigh_exit6;
2293 i40iw_manage_arp_cache(iwdev,
2294 iwdev->arp_table[arpindex].mac_addr,
2299 i40iw_manage_arp_cache(iwdev,
2304 rc = i40iw_arp_table(iwdev,
2310 neigh_event_send(neigh, NULL);
2314 resolve_neigh_exit6:
2317 neigh_release(neigh);
2324 * i40iw_ipv4_is_loopback - check if loopback
2325 * @loc_addr: local addr to compare
2326 * @rem_addr: remote address
2328 static bool i40iw_ipv4_is_loopback(u32 loc_addr, u32 rem_addr)
2330 return ipv4_is_loopback(htonl(rem_addr)) || (loc_addr == rem_addr);
2334 * i40iw_ipv6_is_loopback - check if loopback
2335 * @loc_addr: local addr to compare
2336 * @rem_addr: remote address
2338 static bool i40iw_ipv6_is_loopback(u32 *loc_addr, u32 *rem_addr)
2340 struct in6_addr raddr6;
2342 i40iw_copy_ip_htonl(raddr6.in6_u.u6_addr32, rem_addr);
2343 return (!memcmp(loc_addr, rem_addr, 16) || ipv6_addr_loopback(&raddr6));
2347 * i40iw_make_cm_node - create a new instance of a cm node
2348 * @cm_core: cm's core
2349 * @iwdev: iwarp device structure
2350 * @cm_info: quad info for connection
2351 * @listener: passive connection's listener
2353 static struct i40iw_cm_node *i40iw_make_cm_node(
2354 struct i40iw_cm_core *cm_core,
2355 struct i40iw_device *iwdev,
2356 struct i40iw_cm_info *cm_info,
2357 struct i40iw_cm_listener *listener)
2359 struct i40iw_cm_node *cm_node;
2363 struct net_device *netdev = iwdev->netdev;
2365 /* create an hte and cm_node for this instance */
2366 cm_node = kzalloc(sizeof(*cm_node), GFP_ATOMIC);
2370 /* set our node specific transport info */
2371 cm_node->ipv4 = cm_info->ipv4;
2372 cm_node->vlan_id = cm_info->vlan_id;
2373 memcpy(cm_node->loc_addr, cm_info->loc_addr, sizeof(cm_node->loc_addr));
2374 memcpy(cm_node->rem_addr, cm_info->rem_addr, sizeof(cm_node->rem_addr));
2375 memcpy(cm_node->map_loc_addr, cm_info->map_loc_addr,
2376 sizeof(cm_node->map_loc_addr));
2377 memcpy(cm_node->map_rem_addr, cm_info->map_rem_addr,
2378 sizeof(cm_node->map_rem_addr));
2379 cm_node->loc_port = cm_info->loc_port;
2380 cm_node->rem_port = cm_info->rem_port;
2381 cm_node->map_loc_port = cm_info->map_loc_port;
2382 cm_node->map_rem_port = cm_info->map_rem_port;
2384 cm_node->mpa_frame_rev = iwdev->mpa_version;
2385 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
2386 cm_node->ird_size = I40IW_MAX_IRD_SIZE;
2387 cm_node->ord_size = I40IW_MAX_ORD_SIZE;
2389 cm_node->listener = listener;
2390 cm_node->cm_id = cm_info->cm_id;
2391 ether_addr_copy(cm_node->loc_mac, netdev->dev_addr);
2392 spin_lock_init(&cm_node->retrans_list_lock);
2394 atomic_set(&cm_node->ref_count, 1);
2395 /* associate our parent CM core */
2396 cm_node->cm_core = cm_core;
2397 cm_node->tcp_cntxt.loc_id = I40IW_CM_DEF_LOCAL_ID;
2398 cm_node->tcp_cntxt.rcv_wscale = I40IW_CM_DEFAULT_RCV_WND_SCALE;
2399 cm_node->tcp_cntxt.rcv_wnd =
2400 I40IW_CM_DEFAULT_RCV_WND_SCALED >> I40IW_CM_DEFAULT_RCV_WND_SCALE;
2401 ts = current_kernel_time();
2402 cm_node->tcp_cntxt.loc_seq_num = htonl(ts.tv_nsec);
2403 cm_node->tcp_cntxt.mss = iwdev->mss;
2405 cm_node->iwdev = iwdev;
2406 cm_node->dev = &iwdev->sc_dev;
2408 if ((cm_node->ipv4 &&
2409 i40iw_ipv4_is_loopback(cm_node->loc_addr[0], cm_node->rem_addr[0])) ||
2410 (!cm_node->ipv4 && i40iw_ipv6_is_loopback(cm_node->loc_addr,
2411 cm_node->rem_addr))) {
2412 arpindex = i40iw_arp_table(iwdev,
2413 cm_node->map_rem_addr,
2418 oldarpindex = i40iw_arp_table(iwdev,
2419 cm_node->map_rem_addr,
2424 arpindex = i40iw_addr_resolve_neigh(iwdev,
2425 cm_info->map_loc_addr[0],
2426 cm_info->map_rem_addr[0],
2428 #if IS_ENABLED(CONFIG_IPV6)
2430 arpindex = i40iw_addr_resolve_neigh_ipv6(iwdev,
2431 cm_info->map_loc_addr,
2432 cm_info->map_rem_addr,
2437 i40iw_pr_err("cm_node arpindex\n");
2441 ether_addr_copy(cm_node->rem_mac, iwdev->arp_table[arpindex].mac_addr);
2442 i40iw_add_hte_node(cm_core, cm_node);
2443 cm_core->stats_nodes_created++;
2448 * i40iw_rem_ref_cm_node - destroy an instance of a cm node
2449 * @cm_node: connection's node
2451 static void i40iw_rem_ref_cm_node(struct i40iw_cm_node *cm_node)
2453 struct i40iw_cm_core *cm_core = cm_node->cm_core;
2454 struct i40iw_qp *iwqp;
2455 struct i40iw_cm_info nfo;
2456 unsigned long flags;
2458 spin_lock_irqsave(&cm_node->cm_core->ht_lock, flags);
2459 if (atomic_dec_return(&cm_node->ref_count)) {
2460 spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags);
2463 list_del(&cm_node->list);
2464 spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags);
2466 /* if the node is destroyed before connection was accelerated */
2467 if (!cm_node->accelerated && cm_node->accept_pend) {
2468 pr_err("node destroyed before established\n");
2469 atomic_dec(&cm_node->listener->pend_accepts_cnt);
2471 if (cm_node->close_entry)
2472 i40iw_handle_close_entry(cm_node, 0);
2473 if (cm_node->listener) {
2474 i40iw_dec_refcnt_listen(cm_core, cm_node->listener, 0, true);
2476 if (!i40iw_listen_port_in_use(cm_core, htons(cm_node->map_loc_port)) &&
2477 cm_node->apbvt_set && cm_node->iwdev) {
2478 i40iw_manage_apbvt(cm_node->iwdev,
2479 cm_node->map_loc_port,
2480 I40IW_MANAGE_APBVT_DEL);
2481 i40iw_get_addr_info(cm_node, &nfo);
2482 i40iw_remove_mapinfo(&nfo);
2483 if (cm_node->qhash_set) {
2484 i40iw_manage_qhash(cm_node->iwdev,
2486 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
2487 I40IW_QHASH_MANAGE_TYPE_DELETE,
2490 cm_node->qhash_set = 0;
2495 iwqp = cm_node->iwqp;
2497 iwqp->cm_node = NULL;
2498 i40iw_rem_ref(&iwqp->ibqp);
2499 cm_node->iwqp = NULL;
2500 } else if (cm_node->qhash_set) {
2501 i40iw_get_addr_info(cm_node, &nfo);
2502 i40iw_remove_mapinfo(&nfo);
2503 i40iw_manage_qhash(cm_node->iwdev,
2505 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
2506 I40IW_QHASH_MANAGE_TYPE_DELETE,
2509 cm_node->qhash_set = 0;
2512 cm_node->cm_core->stats_nodes_destroyed++;
2517 * i40iw_handle_fin_pkt - FIN packet received
2518 * @cm_node: connection's node
2520 static void i40iw_handle_fin_pkt(struct i40iw_cm_node *cm_node)
2524 switch (cm_node->state) {
2525 case I40IW_CM_STATE_SYN_RCVD:
2526 case I40IW_CM_STATE_SYN_SENT:
2527 case I40IW_CM_STATE_ESTABLISHED:
2528 case I40IW_CM_STATE_MPAREJ_RCVD:
2529 cm_node->tcp_cntxt.rcv_nxt++;
2530 i40iw_cleanup_retrans_entry(cm_node);
2531 cm_node->state = I40IW_CM_STATE_LAST_ACK;
2532 i40iw_send_fin(cm_node);
2534 case I40IW_CM_STATE_MPAREQ_SENT:
2535 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
2536 cm_node->tcp_cntxt.rcv_nxt++;
2537 i40iw_cleanup_retrans_entry(cm_node);
2538 cm_node->state = I40IW_CM_STATE_CLOSED;
2539 atomic_inc(&cm_node->ref_count);
2540 i40iw_send_reset(cm_node);
2542 case I40IW_CM_STATE_FIN_WAIT1:
2543 cm_node->tcp_cntxt.rcv_nxt++;
2544 i40iw_cleanup_retrans_entry(cm_node);
2545 cm_node->state = I40IW_CM_STATE_CLOSING;
2546 i40iw_send_ack(cm_node);
2548 * Wait for ACK as this is simultaneous close.
2549 * After we receive ACK, do not send anything.
2553 case I40IW_CM_STATE_FIN_WAIT2:
2554 cm_node->tcp_cntxt.rcv_nxt++;
2555 i40iw_cleanup_retrans_entry(cm_node);
2556 cm_node->state = I40IW_CM_STATE_TIME_WAIT;
2557 i40iw_send_ack(cm_node);
2559 i40iw_schedule_cm_timer(cm_node, NULL, I40IW_TIMER_TYPE_CLOSE, 1, 0);
2561 i40iw_pr_err("node %p state = %d\n", cm_node, cm_node->state);
2563 case I40IW_CM_STATE_TIME_WAIT:
2564 cm_node->tcp_cntxt.rcv_nxt++;
2565 i40iw_cleanup_retrans_entry(cm_node);
2566 cm_node->state = I40IW_CM_STATE_CLOSED;
2567 i40iw_rem_ref_cm_node(cm_node);
2569 case I40IW_CM_STATE_OFFLOADED:
2571 i40iw_pr_err("bad state node %p state = %d\n", cm_node, cm_node->state);
2577 * i40iw_handle_rst_pkt - process received RST packet
2578 * @cm_node: connection's node
2579 * @rbuf: receive buffer
2581 static void i40iw_handle_rst_pkt(struct i40iw_cm_node *cm_node,
2582 struct i40iw_puda_buf *rbuf)
2584 i40iw_cleanup_retrans_entry(cm_node);
2585 switch (cm_node->state) {
2586 case I40IW_CM_STATE_SYN_SENT:
2587 case I40IW_CM_STATE_MPAREQ_SENT:
2588 switch (cm_node->mpa_frame_rev) {
2590 cm_node->mpa_frame_rev = IETF_MPA_V1;
2591 /* send a syn and goto syn sent state */
2592 cm_node->state = I40IW_CM_STATE_SYN_SENT;
2593 if (i40iw_send_syn(cm_node, 0))
2594 i40iw_active_open_err(cm_node, false);
2598 i40iw_active_open_err(cm_node, false);
2602 case I40IW_CM_STATE_MPAREQ_RCVD:
2603 atomic_add_return(1, &cm_node->passive_state);
2605 case I40IW_CM_STATE_ESTABLISHED:
2606 case I40IW_CM_STATE_SYN_RCVD:
2607 case I40IW_CM_STATE_LISTENING:
2608 i40iw_pr_err("Bad state state = %d\n", cm_node->state);
2609 i40iw_passive_open_err(cm_node, false);
2611 case I40IW_CM_STATE_OFFLOADED:
2612 i40iw_active_open_err(cm_node, false);
2614 case I40IW_CM_STATE_CLOSED:
2616 case I40IW_CM_STATE_FIN_WAIT2:
2617 case I40IW_CM_STATE_FIN_WAIT1:
2618 case I40IW_CM_STATE_LAST_ACK:
2619 cm_node->cm_id->rem_ref(cm_node->cm_id);
2620 case I40IW_CM_STATE_TIME_WAIT:
2621 cm_node->state = I40IW_CM_STATE_CLOSED;
2622 i40iw_rem_ref_cm_node(cm_node);
2630 * i40iw_handle_rcv_mpa - Process a recv'd mpa buffer
2631 * @cm_node: connection's node
2632 * @rbuf: receive buffer
2634 static void i40iw_handle_rcv_mpa(struct i40iw_cm_node *cm_node,
2635 struct i40iw_puda_buf *rbuf)
2638 int datasize = rbuf->datalen;
2639 u8 *dataloc = rbuf->data;
2641 enum i40iw_cm_event_type type = I40IW_CM_EVENT_UNKNOWN;
2644 ret = i40iw_parse_mpa(cm_node, dataloc, &res_type, datasize);
2646 if (cm_node->state == I40IW_CM_STATE_MPAREQ_SENT)
2647 i40iw_active_open_err(cm_node, true);
2649 i40iw_passive_open_err(cm_node, true);
2653 switch (cm_node->state) {
2654 case I40IW_CM_STATE_ESTABLISHED:
2655 if (res_type == I40IW_MPA_REQUEST_REJECT)
2656 i40iw_pr_err("state for reject\n");
2657 cm_node->state = I40IW_CM_STATE_MPAREQ_RCVD;
2658 type = I40IW_CM_EVENT_MPA_REQ;
2659 i40iw_send_ack(cm_node); /* ACK received MPA request */
2660 atomic_set(&cm_node->passive_state,
2661 I40IW_PASSIVE_STATE_INDICATED);
2663 case I40IW_CM_STATE_MPAREQ_SENT:
2664 i40iw_cleanup_retrans_entry(cm_node);
2665 if (res_type == I40IW_MPA_REQUEST_REJECT) {
2666 type = I40IW_CM_EVENT_MPA_REJECT;
2667 cm_node->state = I40IW_CM_STATE_MPAREJ_RCVD;
2669 type = I40IW_CM_EVENT_CONNECTED;
2670 cm_node->state = I40IW_CM_STATE_OFFLOADED;
2671 i40iw_send_ack(cm_node);
2675 pr_err("%s wrong cm_node state =%d\n", __func__, cm_node->state);
2678 i40iw_create_event(cm_node, type);
2682 * i40iw_indicate_pkt_err - Send up err event to cm
2683 * @cm_node: connection's node
2685 static void i40iw_indicate_pkt_err(struct i40iw_cm_node *cm_node)
2687 switch (cm_node->state) {
2688 case I40IW_CM_STATE_SYN_SENT:
2689 case I40IW_CM_STATE_MPAREQ_SENT:
2690 i40iw_active_open_err(cm_node, true);
2692 case I40IW_CM_STATE_ESTABLISHED:
2693 case I40IW_CM_STATE_SYN_RCVD:
2694 i40iw_passive_open_err(cm_node, true);
2696 case I40IW_CM_STATE_OFFLOADED:
2703 * i40iw_check_syn - Check for error on received syn ack
2704 * @cm_node: connection's node
2705 * @tcph: pointer tcp header
2707 static int i40iw_check_syn(struct i40iw_cm_node *cm_node, struct tcphdr *tcph)
2711 if (ntohl(tcph->ack_seq) != cm_node->tcp_cntxt.loc_seq_num) {
2713 i40iw_active_open_err(cm_node, true);
2719 * i40iw_check_seq - check seq numbers if OK
2720 * @cm_node: connection's node
2721 * @tcph: pointer tcp header
2723 static int i40iw_check_seq(struct i40iw_cm_node *cm_node, struct tcphdr *tcph)
2728 u32 loc_seq_num = cm_node->tcp_cntxt.loc_seq_num;
2729 u32 rcv_nxt = cm_node->tcp_cntxt.rcv_nxt;
2732 seq = ntohl(tcph->seq);
2733 ack_seq = ntohl(tcph->ack_seq);
2734 rcv_wnd = cm_node->tcp_cntxt.rcv_wnd;
2735 if (ack_seq != loc_seq_num)
2737 else if (!between(seq, rcv_nxt, (rcv_nxt + rcv_wnd)))
2740 i40iw_pr_err("seq number\n");
2741 i40iw_indicate_pkt_err(cm_node);
2747 * i40iw_handle_syn_pkt - is for Passive node
2748 * @cm_node: connection's node
2749 * @rbuf: receive buffer
2751 static void i40iw_handle_syn_pkt(struct i40iw_cm_node *cm_node,
2752 struct i40iw_puda_buf *rbuf)
2754 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2758 struct i40iw_cm_info nfo;
2760 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
2761 inc_sequence = ntohl(tcph->seq);
2763 switch (cm_node->state) {
2764 case I40IW_CM_STATE_SYN_SENT:
2765 case I40IW_CM_STATE_MPAREQ_SENT:
2766 /* Rcvd syn on active open connection */
2767 i40iw_active_open_err(cm_node, 1);
2769 case I40IW_CM_STATE_LISTENING:
2771 if (atomic_read(&cm_node->listener->pend_accepts_cnt) >
2772 cm_node->listener->backlog) {
2773 cm_node->cm_core->stats_backlog_drops++;
2774 i40iw_passive_open_err(cm_node, false);
2777 ret = i40iw_handle_tcp_options(cm_node, tcph, optionsize, 1);
2779 i40iw_passive_open_err(cm_node, false);
2783 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
2784 cm_node->accept_pend = 1;
2785 atomic_inc(&cm_node->listener->pend_accepts_cnt);
2787 cm_node->state = I40IW_CM_STATE_SYN_RCVD;
2788 i40iw_get_addr_info(cm_node, &nfo);
2789 ret = i40iw_manage_qhash(cm_node->iwdev,
2791 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
2792 I40IW_QHASH_MANAGE_TYPE_ADD,
2795 cm_node->qhash_set = true;
2797 case I40IW_CM_STATE_CLOSED:
2798 i40iw_cleanup_retrans_entry(cm_node);
2799 atomic_inc(&cm_node->ref_count);
2800 i40iw_send_reset(cm_node);
2802 case I40IW_CM_STATE_OFFLOADED:
2803 case I40IW_CM_STATE_ESTABLISHED:
2804 case I40IW_CM_STATE_FIN_WAIT1:
2805 case I40IW_CM_STATE_FIN_WAIT2:
2806 case I40IW_CM_STATE_MPAREQ_RCVD:
2807 case I40IW_CM_STATE_LAST_ACK:
2808 case I40IW_CM_STATE_CLOSING:
2809 case I40IW_CM_STATE_UNKNOWN:
2816 * i40iw_handle_synack_pkt - Process SYN+ACK packet (active side)
2817 * @cm_node: connection's node
2818 * @rbuf: receive buffer
2820 static void i40iw_handle_synack_pkt(struct i40iw_cm_node *cm_node,
2821 struct i40iw_puda_buf *rbuf)
2823 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2828 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
2829 inc_sequence = ntohl(tcph->seq);
2830 switch (cm_node->state) {
2831 case I40IW_CM_STATE_SYN_SENT:
2832 i40iw_cleanup_retrans_entry(cm_node);
2834 if (i40iw_check_syn(cm_node, tcph)) {
2835 i40iw_pr_err("check syn fail\n");
2838 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2840 ret = i40iw_handle_tcp_options(cm_node, tcph, optionsize, 0);
2842 i40iw_debug(cm_node->dev,
2844 "cm_node=%p tcp_options failed\n",
2848 i40iw_cleanup_retrans_entry(cm_node);
2849 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
2850 i40iw_send_ack(cm_node); /* ACK for the syn_ack */
2851 ret = i40iw_send_mpa_request(cm_node);
2853 i40iw_debug(cm_node->dev,
2855 "cm_node=%p i40iw_send_mpa_request failed\n",
2859 cm_node->state = I40IW_CM_STATE_MPAREQ_SENT;
2861 case I40IW_CM_STATE_MPAREQ_RCVD:
2862 i40iw_passive_open_err(cm_node, true);
2864 case I40IW_CM_STATE_LISTENING:
2865 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
2866 i40iw_cleanup_retrans_entry(cm_node);
2867 cm_node->state = I40IW_CM_STATE_CLOSED;
2868 i40iw_send_reset(cm_node);
2870 case I40IW_CM_STATE_CLOSED:
2871 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
2872 i40iw_cleanup_retrans_entry(cm_node);
2873 atomic_inc(&cm_node->ref_count);
2874 i40iw_send_reset(cm_node);
2876 case I40IW_CM_STATE_ESTABLISHED:
2877 case I40IW_CM_STATE_FIN_WAIT1:
2878 case I40IW_CM_STATE_FIN_WAIT2:
2879 case I40IW_CM_STATE_LAST_ACK:
2880 case I40IW_CM_STATE_OFFLOADED:
2881 case I40IW_CM_STATE_CLOSING:
2882 case I40IW_CM_STATE_UNKNOWN:
2883 case I40IW_CM_STATE_MPAREQ_SENT:
2890 * i40iw_handle_ack_pkt - process packet with ACK
2891 * @cm_node: connection's node
2892 * @rbuf: receive buffer
2894 static int i40iw_handle_ack_pkt(struct i40iw_cm_node *cm_node,
2895 struct i40iw_puda_buf *rbuf)
2897 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2901 u32 datasize = rbuf->datalen;
2903 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
2905 if (i40iw_check_seq(cm_node, tcph))
2908 inc_sequence = ntohl(tcph->seq);
2909 switch (cm_node->state) {
2910 case I40IW_CM_STATE_SYN_RCVD:
2911 i40iw_cleanup_retrans_entry(cm_node);
2912 ret = i40iw_handle_tcp_options(cm_node, tcph, optionsize, 1);
2915 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2916 cm_node->state = I40IW_CM_STATE_ESTABLISHED;
2918 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2919 i40iw_get_remote_addr(cm_node);
2920 i40iw_handle_rcv_mpa(cm_node, rbuf);
2923 case I40IW_CM_STATE_ESTABLISHED:
2924 i40iw_cleanup_retrans_entry(cm_node);
2926 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2927 i40iw_handle_rcv_mpa(cm_node, rbuf);
2930 case I40IW_CM_STATE_MPAREQ_SENT:
2931 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2933 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2934 i40iw_handle_rcv_mpa(cm_node, rbuf);
2937 case I40IW_CM_STATE_LISTENING:
2938 i40iw_cleanup_retrans_entry(cm_node);
2939 cm_node->state = I40IW_CM_STATE_CLOSED;
2940 i40iw_send_reset(cm_node);
2942 case I40IW_CM_STATE_CLOSED:
2943 i40iw_cleanup_retrans_entry(cm_node);
2944 atomic_inc(&cm_node->ref_count);
2945 i40iw_send_reset(cm_node);
2947 case I40IW_CM_STATE_LAST_ACK:
2948 case I40IW_CM_STATE_CLOSING:
2949 i40iw_cleanup_retrans_entry(cm_node);
2950 cm_node->state = I40IW_CM_STATE_CLOSED;
2951 if (!cm_node->accept_pend)
2952 cm_node->cm_id->rem_ref(cm_node->cm_id);
2953 i40iw_rem_ref_cm_node(cm_node);
2955 case I40IW_CM_STATE_FIN_WAIT1:
2956 i40iw_cleanup_retrans_entry(cm_node);
2957 cm_node->state = I40IW_CM_STATE_FIN_WAIT2;
2959 case I40IW_CM_STATE_SYN_SENT:
2960 case I40IW_CM_STATE_FIN_WAIT2:
2961 case I40IW_CM_STATE_OFFLOADED:
2962 case I40IW_CM_STATE_MPAREQ_RCVD:
2963 case I40IW_CM_STATE_UNKNOWN:
2965 i40iw_cleanup_retrans_entry(cm_node);
2972 * i40iw_process_packet - process cm packet
2973 * @cm_node: connection's node
2974 * @rbuf: receive buffer
2976 static void i40iw_process_packet(struct i40iw_cm_node *cm_node,
2977 struct i40iw_puda_buf *rbuf)
2979 enum i40iw_tcpip_pkt_type pkt_type = I40IW_PKT_TYPE_UNKNOWN;
2980 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2985 pkt_type = I40IW_PKT_TYPE_RST;
2986 } else if (tcph->syn) {
2987 pkt_type = I40IW_PKT_TYPE_SYN;
2989 pkt_type = I40IW_PKT_TYPE_SYNACK;
2990 } else if (tcph->ack) {
2991 pkt_type = I40IW_PKT_TYPE_ACK;
2997 case I40IW_PKT_TYPE_SYN:
2998 i40iw_handle_syn_pkt(cm_node, rbuf);
3000 case I40IW_PKT_TYPE_SYNACK:
3001 i40iw_handle_synack_pkt(cm_node, rbuf);
3003 case I40IW_PKT_TYPE_ACK:
3004 ret = i40iw_handle_ack_pkt(cm_node, rbuf);
3005 if (fin_set && !ret)
3006 i40iw_handle_fin_pkt(cm_node);
3008 case I40IW_PKT_TYPE_RST:
3009 i40iw_handle_rst_pkt(cm_node, rbuf);
3013 (!i40iw_check_seq(cm_node, (struct tcphdr *)rbuf->tcph)))
3014 i40iw_handle_fin_pkt(cm_node);
3020 * i40iw_make_listen_node - create a listen node with params
3021 * @cm_core: cm's core
3022 * @iwdev: iwarp device structure
3023 * @cm_info: quad info for connection
3025 static struct i40iw_cm_listener *i40iw_make_listen_node(
3026 struct i40iw_cm_core *cm_core,
3027 struct i40iw_device *iwdev,
3028 struct i40iw_cm_info *cm_info)
3030 struct i40iw_cm_listener *listener;
3031 struct iwpm_dev_data pm_reg_msg;
3032 struct iwpm_sa_data pm_msg;
3034 unsigned long flags;
3036 /* cannot have multiple matching listeners */
3037 listener = i40iw_find_listener(cm_core, cm_info->loc_addr,
3040 I40IW_CM_LISTENER_EITHER_STATE,
3043 (listener->listener_state == I40IW_CM_LISTENER_ACTIVE_STATE)) {
3044 atomic_dec(&listener->ref_count);
3045 i40iw_debug(cm_core->dev,
3047 "Not creating listener since it already exists\n");
3052 i40iw_form_reg_msg(iwdev, &pm_reg_msg);
3053 iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_I40IW);
3055 i40iw_pr_err("PM register fail err = %d\n",
3058 if (iwpm_valid_pid() && !iwpm_err) {
3059 i40iw_form_pm_msg(cm_info, &pm_msg);
3060 iwpm_err = iwpm_add_mapping(&pm_msg, RDMA_NL_I40IW);
3062 i40iw_pr_err("PM query fail err = %d\n",
3065 i40iw_record_pm_msg(cm_info, &pm_msg, false);
3068 /* create a CM listen node (1/2 node to compare incoming traffic to) */
3069 listener = kzalloc(sizeof(*listener), GFP_ATOMIC);
3072 cm_core->stats_listen_nodes_created++;
3073 memcpy(listener->loc_addr, cm_info->loc_addr, sizeof(listener->loc_addr));
3074 memcpy(listener->map_loc_addr, cm_info->map_loc_addr,
3075 sizeof(listener->map_loc_addr));
3076 listener->loc_port = cm_info->loc_port;
3077 listener->map_loc_port = cm_info->map_loc_port;
3079 INIT_LIST_HEAD(&listener->child_listen_list);
3081 atomic_set(&listener->ref_count, 1);
3083 listener->reused_node = 1;
3086 listener->cm_id = cm_info->cm_id;
3087 listener->ipv4 = cm_info->ipv4;
3088 listener->vlan_id = cm_info->vlan_id;
3089 atomic_set(&listener->pend_accepts_cnt, 0);
3090 listener->cm_core = cm_core;
3091 listener->iwdev = iwdev;
3093 listener->backlog = cm_info->backlog;
3094 listener->listener_state = I40IW_CM_LISTENER_ACTIVE_STATE;
3096 if (!listener->reused_node) {
3097 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
3098 list_add(&listener->list, &cm_core->listen_nodes);
3099 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
3106 * i40iw_create_cm_node - make a connection node with params
3107 * @cm_core: cm's core
3108 * @iwdev: iwarp device structure
3109 * @private_data_len: len to provate data for mpa request
3110 * @private_data: pointer to private data for connection
3111 * @cm_info: quad info for connection
3113 static struct i40iw_cm_node *i40iw_create_cm_node(
3114 struct i40iw_cm_core *cm_core,
3115 struct i40iw_device *iwdev,
3116 u16 private_data_len,
3118 struct i40iw_cm_info *cm_info)
3121 struct i40iw_cm_node *cm_node;
3122 struct i40iw_cm_listener *loopback_remotelistener;
3123 struct i40iw_cm_node *loopback_remotenode;
3124 struct i40iw_cm_info loopback_cm_info;
3126 /* create a CM connection node */
3127 cm_node = i40iw_make_cm_node(cm_core, iwdev, cm_info, NULL);
3130 /* set our node side to client (active) side */
3131 cm_node->tcp_cntxt.client = 1;
3132 cm_node->tcp_cntxt.rcv_wscale = I40IW_CM_DEFAULT_RCV_WND_SCALE;
3134 if (!memcmp(cm_info->loc_addr, cm_info->rem_addr, sizeof(cm_info->loc_addr))) {
3135 loopback_remotelistener = i40iw_find_listener(
3137 cm_info->map_rem_addr,
3138 cm_node->map_rem_port,
3140 I40IW_CM_LISTENER_ACTIVE_STATE,
3142 if (!loopback_remotelistener) {
3143 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
3145 loopback_cm_info = *cm_info;
3146 loopback_cm_info.loc_port = cm_info->rem_port;
3147 loopback_cm_info.rem_port = cm_info->loc_port;
3148 loopback_cm_info.map_loc_port = cm_info->map_rem_port;
3149 loopback_cm_info.map_rem_port = cm_info->map_loc_port;
3150 loopback_cm_info.cm_id = loopback_remotelistener->cm_id;
3151 loopback_cm_info.ipv4 = cm_info->ipv4;
3152 loopback_remotenode = i40iw_make_cm_node(cm_core,
3155 loopback_remotelistener);
3156 if (!loopback_remotenode) {
3157 i40iw_rem_ref_cm_node(cm_node);
3160 cm_core->stats_loopbacks++;
3161 loopback_remotenode->loopbackpartner = cm_node;
3162 loopback_remotenode->tcp_cntxt.rcv_wscale =
3163 I40IW_CM_DEFAULT_RCV_WND_SCALE;
3164 cm_node->loopbackpartner = loopback_remotenode;
3165 memcpy(loopback_remotenode->pdata_buf, private_data,
3167 loopback_remotenode->pdata.size = private_data_len;
3169 cm_node->state = I40IW_CM_STATE_OFFLOADED;
3170 cm_node->tcp_cntxt.rcv_nxt =
3171 loopback_remotenode->tcp_cntxt.loc_seq_num;
3172 loopback_remotenode->tcp_cntxt.rcv_nxt =
3173 cm_node->tcp_cntxt.loc_seq_num;
3174 cm_node->tcp_cntxt.max_snd_wnd =
3175 loopback_remotenode->tcp_cntxt.rcv_wnd;
3176 loopback_remotenode->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.rcv_wnd;
3177 cm_node->tcp_cntxt.snd_wnd = loopback_remotenode->tcp_cntxt.rcv_wnd;
3178 loopback_remotenode->tcp_cntxt.snd_wnd = cm_node->tcp_cntxt.rcv_wnd;
3179 cm_node->tcp_cntxt.snd_wscale = loopback_remotenode->tcp_cntxt.rcv_wscale;
3180 loopback_remotenode->tcp_cntxt.snd_wscale = cm_node->tcp_cntxt.rcv_wscale;
3181 loopback_remotenode->state = I40IW_CM_STATE_MPAREQ_RCVD;
3182 i40iw_create_event(loopback_remotenode, I40IW_CM_EVENT_MPA_REQ);
3187 cm_node->pdata.size = private_data_len;
3188 cm_node->pdata.addr = cm_node->pdata_buf;
3190 memcpy(cm_node->pdata_buf, private_data, private_data_len);
3192 cm_node->state = I40IW_CM_STATE_SYN_SENT;
3193 ret = i40iw_send_syn(cm_node, 0);
3197 i40iw_debug(cm_node->dev,
3199 "Api - connect() FAILED: dest addr=%pI4",
3202 i40iw_debug(cm_node->dev, I40IW_DEBUG_CM,
3203 "Api - connect() FAILED: dest addr=%pI6",
3205 i40iw_rem_ref_cm_node(cm_node);
3210 i40iw_debug(cm_node->dev,
3212 "Api - connect(): port=0x%04x, cm_node=%p, cm_id = %p.\n",
3221 * i40iw_cm_reject - reject and teardown a connection
3222 * @cm_node: connection's node
3223 * @pdate: ptr to private data for reject
3224 * @plen: size of private data
3226 static int i40iw_cm_reject(struct i40iw_cm_node *cm_node, const void *pdata, u8 plen)
3231 struct iw_cm_id *cm_id = cm_node->cm_id;
3232 struct i40iw_cm_node *loopback = cm_node->loopbackpartner;
3234 if (cm_node->tcp_cntxt.client)
3236 i40iw_cleanup_retrans_entry(cm_node);
3239 passive_state = atomic_add_return(1, &cm_node->passive_state);
3240 if (passive_state == I40IW_SEND_RESET_EVENT) {
3241 cm_node->state = I40IW_CM_STATE_CLOSED;
3242 i40iw_rem_ref_cm_node(cm_node);
3244 if (cm_node->state == I40IW_CM_STATE_LISTENER_DESTROYED) {
3245 i40iw_rem_ref_cm_node(cm_node);
3247 ret = i40iw_send_mpa_reject(cm_node, pdata, plen);
3249 cm_node->state = I40IW_CM_STATE_CLOSED;
3250 err = i40iw_send_reset(cm_node);
3252 i40iw_pr_err("send reset failed\n");
3254 cm_id->add_ref(cm_id);
3259 cm_node->cm_id = NULL;
3260 if (cm_node->state == I40IW_CM_STATE_LISTENER_DESTROYED) {
3261 i40iw_rem_ref_cm_node(cm_node);
3262 i40iw_rem_ref_cm_node(loopback);
3264 ret = i40iw_send_cm_event(loopback,
3266 IW_CM_EVENT_CONNECT_REPLY,
3268 i40iw_rem_ref_cm_node(cm_node);
3269 loopback->state = I40IW_CM_STATE_CLOSING;
3271 cm_id = loopback->cm_id;
3272 i40iw_rem_ref_cm_node(loopback);
3273 cm_id->rem_ref(cm_id);
3281 * i40iw_cm_close - close of cm connection
3282 * @cm_node: connection's node
3284 static int i40iw_cm_close(struct i40iw_cm_node *cm_node)
3291 switch (cm_node->state) {
3292 case I40IW_CM_STATE_SYN_RCVD:
3293 case I40IW_CM_STATE_SYN_SENT:
3294 case I40IW_CM_STATE_ONE_SIDE_ESTABLISHED:
3295 case I40IW_CM_STATE_ESTABLISHED:
3296 case I40IW_CM_STATE_ACCEPTING:
3297 case I40IW_CM_STATE_MPAREQ_SENT:
3298 case I40IW_CM_STATE_MPAREQ_RCVD:
3299 i40iw_cleanup_retrans_entry(cm_node);
3300 i40iw_send_reset(cm_node);
3302 case I40IW_CM_STATE_CLOSE_WAIT:
3303 cm_node->state = I40IW_CM_STATE_LAST_ACK;
3304 i40iw_send_fin(cm_node);
3306 case I40IW_CM_STATE_FIN_WAIT1:
3307 case I40IW_CM_STATE_FIN_WAIT2:
3308 case I40IW_CM_STATE_LAST_ACK:
3309 case I40IW_CM_STATE_TIME_WAIT:
3310 case I40IW_CM_STATE_CLOSING:
3313 case I40IW_CM_STATE_LISTENING:
3314 i40iw_cleanup_retrans_entry(cm_node);
3315 i40iw_send_reset(cm_node);
3317 case I40IW_CM_STATE_MPAREJ_RCVD:
3318 case I40IW_CM_STATE_UNKNOWN:
3319 case I40IW_CM_STATE_INITED:
3320 case I40IW_CM_STATE_CLOSED:
3321 case I40IW_CM_STATE_LISTENER_DESTROYED:
3322 i40iw_rem_ref_cm_node(cm_node);
3324 case I40IW_CM_STATE_OFFLOADED:
3325 if (cm_node->send_entry)
3326 i40iw_pr_err("send_entry\n");
3327 i40iw_rem_ref_cm_node(cm_node);
3334 * i40iw_receive_ilq - recv an ETHERNET packet, and process it
3336 * @dev: FPK dev struct
3337 * @rbuf: receive buffer
3339 void i40iw_receive_ilq(struct i40iw_sc_dev *dev, struct i40iw_puda_buf *rbuf)
3341 struct i40iw_cm_node *cm_node;
3342 struct i40iw_cm_listener *listener;
3344 struct ipv6hdr *ip6h;
3345 struct tcphdr *tcph;
3346 struct i40iw_cm_info cm_info;
3347 struct i40iw_device *iwdev = (struct i40iw_device *)dev->back_dev;
3348 struct i40iw_cm_core *cm_core = &iwdev->cm_core;
3349 struct vlan_ethhdr *ethh;
3351 /* if vlan, then maclen = 18 else 14 */
3352 iph = (struct iphdr *)rbuf->iph;
3353 memset(&cm_info, 0, sizeof(cm_info));
3355 i40iw_debug_buf(dev,
3357 "RECEIVE ILQ BUFFER",
3360 ethh = (struct vlan_ethhdr *)rbuf->mem.va;
3362 if (ethh->h_vlan_proto == htons(ETH_P_8021Q)) {
3363 cm_info.vlan_id = ntohs(ethh->h_vlan_TCI) & VLAN_VID_MASK;
3364 i40iw_debug(cm_core->dev,
3370 cm_info.vlan_id = I40IW_NO_VLAN;
3372 tcph = (struct tcphdr *)rbuf->tcph;
3375 cm_info.loc_addr[0] = ntohl(iph->daddr);
3376 cm_info.rem_addr[0] = ntohl(iph->saddr);
3377 cm_info.ipv4 = true;
3379 ip6h = (struct ipv6hdr *)rbuf->iph;
3380 i40iw_copy_ip_ntohl(cm_info.loc_addr,
3381 ip6h->daddr.in6_u.u6_addr32);
3382 i40iw_copy_ip_ntohl(cm_info.rem_addr,
3383 ip6h->saddr.in6_u.u6_addr32);
3384 cm_info.ipv4 = false;
3386 cm_info.loc_port = ntohs(tcph->dest);
3387 cm_info.rem_port = ntohs(tcph->source);
3388 i40iw_init_mapinfo(&cm_info);
3390 cm_node = i40iw_find_node(cm_core,
3391 cm_info.map_rem_port,
3392 cm_info.map_rem_addr,
3393 cm_info.map_loc_port,
3394 cm_info.map_loc_addr,
3398 /* Only type of packet accepted are for */
3399 /* the PASSIVE open (syn only) */
3400 if (!tcph->syn || tcph->ack)
3403 i40iw_find_listener(cm_core,
3404 cm_info.map_loc_addr,
3405 cm_info.map_loc_port,
3407 I40IW_CM_LISTENER_ACTIVE_STATE,
3410 cm_info.cm_id = NULL;
3411 i40iw_debug(cm_core->dev,
3413 "%s no listener found\n",
3417 cm_info.cm_id = listener->cm_id;
3418 cm_node = i40iw_make_cm_node(cm_core, iwdev, &cm_info, listener);
3420 i40iw_debug(cm_core->dev,
3422 "%s allocate node failed\n",
3424 atomic_dec(&listener->ref_count);
3427 if (!tcph->rst && !tcph->fin) {
3428 cm_node->state = I40IW_CM_STATE_LISTENING;
3430 i40iw_rem_ref_cm_node(cm_node);
3433 atomic_inc(&cm_node->ref_count);
3434 } else if (cm_node->state == I40IW_CM_STATE_OFFLOADED) {
3435 i40iw_rem_ref_cm_node(cm_node);
3438 i40iw_process_packet(cm_node, rbuf);
3439 i40iw_rem_ref_cm_node(cm_node);
3443 * i40iw_setup_cm_core - allocate a top level instance of a cm
3445 * @iwdev: iwarp device structure
3447 void i40iw_setup_cm_core(struct i40iw_device *iwdev)
3449 struct i40iw_cm_core *cm_core = &iwdev->cm_core;
3451 cm_core->iwdev = iwdev;
3452 cm_core->dev = &iwdev->sc_dev;
3454 INIT_LIST_HEAD(&cm_core->connected_nodes);
3455 INIT_LIST_HEAD(&cm_core->listen_nodes);
3457 init_timer(&cm_core->tcp_timer);
3458 cm_core->tcp_timer.function = i40iw_cm_timer_tick;
3459 cm_core->tcp_timer.data = (unsigned long)cm_core;
3461 spin_lock_init(&cm_core->ht_lock);
3462 spin_lock_init(&cm_core->listen_list_lock);
3464 cm_core->event_wq = create_singlethread_workqueue("iwewq");
3465 cm_core->disconn_wq = create_singlethread_workqueue("iwdwq");
3469 * i40iw_cleanup_cm_core - deallocate a top level instance of a
3471 * @cm_core: cm's core
3473 void i40iw_cleanup_cm_core(struct i40iw_cm_core *cm_core)
3475 unsigned long flags;
3480 spin_lock_irqsave(&cm_core->ht_lock, flags);
3481 if (timer_pending(&cm_core->tcp_timer))
3482 del_timer_sync(&cm_core->tcp_timer);
3483 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
3485 destroy_workqueue(cm_core->event_wq);
3486 destroy_workqueue(cm_core->disconn_wq);
3490 * i40iw_init_tcp_ctx - setup qp context
3491 * @cm_node: connection's node
3492 * @tcp_info: offload info for tcp
3493 * @iwqp: associate qp for the connection
3495 static void i40iw_init_tcp_ctx(struct i40iw_cm_node *cm_node,
3496 struct i40iw_tcp_offload_info *tcp_info,
3497 struct i40iw_qp *iwqp)
3499 tcp_info->ipv4 = cm_node->ipv4;
3500 tcp_info->drop_ooo_seg = true;
3501 tcp_info->wscale = true;
3502 tcp_info->ignore_tcp_opt = true;
3503 tcp_info->ignore_tcp_uns_opt = true;
3504 tcp_info->no_nagle = false;
3506 tcp_info->ttl = I40IW_DEFAULT_TTL;
3507 tcp_info->rtt_var = cpu_to_le32(I40IW_DEFAULT_RTT_VAR);
3508 tcp_info->ss_thresh = cpu_to_le32(I40IW_DEFAULT_SS_THRESH);
3509 tcp_info->rexmit_thresh = I40IW_DEFAULT_REXMIT_THRESH;
3511 tcp_info->tcp_state = I40IW_TCP_STATE_ESTABLISHED;
3512 tcp_info->snd_wscale = cm_node->tcp_cntxt.snd_wscale;
3513 tcp_info->rcv_wscale = cm_node->tcp_cntxt.rcv_wscale;
3515 tcp_info->snd_nxt = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3516 tcp_info->snd_wnd = cpu_to_le32(cm_node->tcp_cntxt.snd_wnd);
3517 tcp_info->rcv_nxt = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt);
3518 tcp_info->snd_max = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3520 tcp_info->snd_una = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3521 tcp_info->cwnd = cpu_to_le32(2 * cm_node->tcp_cntxt.mss);
3522 tcp_info->snd_wl1 = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt);
3523 tcp_info->snd_wl2 = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3524 tcp_info->max_snd_window = cpu_to_le32(cm_node->tcp_cntxt.max_snd_wnd);
3525 tcp_info->rcv_wnd = cpu_to_le32(cm_node->tcp_cntxt.rcv_wnd <<
3526 cm_node->tcp_cntxt.rcv_wscale);
3528 tcp_info->flow_label = 0;
3529 tcp_info->snd_mss = cpu_to_le32(((u32)cm_node->tcp_cntxt.mss));
3530 if (cm_node->vlan_id < VLAN_TAG_PRESENT) {
3531 tcp_info->insert_vlan_tag = true;
3532 tcp_info->vlan_tag = cpu_to_le16(cm_node->vlan_id);
3534 if (cm_node->ipv4) {
3535 tcp_info->src_port = cpu_to_le16(cm_node->map_loc_port);
3536 tcp_info->dst_port = cpu_to_le16(cm_node->map_rem_port);
3538 tcp_info->dest_ip_addr3 = cpu_to_le32(cm_node->map_rem_addr[0]);
3539 tcp_info->local_ipaddr3 = cpu_to_le32(cm_node->map_loc_addr[0]);
3540 tcp_info->arp_idx = cpu_to_le32(i40iw_arp_table(iwqp->iwdev,
3541 &tcp_info->dest_ip_addr3,
3544 I40IW_ARP_RESOLVE));
3546 tcp_info->src_port = cpu_to_le16(cm_node->map_loc_port);
3547 tcp_info->dst_port = cpu_to_le16(cm_node->map_rem_port);
3548 tcp_info->dest_ip_addr0 = cpu_to_le32(cm_node->map_rem_addr[0]);
3549 tcp_info->dest_ip_addr1 = cpu_to_le32(cm_node->map_rem_addr[1]);
3550 tcp_info->dest_ip_addr2 = cpu_to_le32(cm_node->map_rem_addr[2]);
3551 tcp_info->dest_ip_addr3 = cpu_to_le32(cm_node->map_rem_addr[3]);
3552 tcp_info->local_ipaddr0 = cpu_to_le32(cm_node->map_loc_addr[0]);
3553 tcp_info->local_ipaddr1 = cpu_to_le32(cm_node->map_loc_addr[1]);
3554 tcp_info->local_ipaddr2 = cpu_to_le32(cm_node->map_loc_addr[2]);
3555 tcp_info->local_ipaddr3 = cpu_to_le32(cm_node->map_loc_addr[3]);
3556 tcp_info->arp_idx = cpu_to_le32(i40iw_arp_table(
3558 &tcp_info->dest_ip_addr0,
3561 I40IW_ARP_RESOLVE));
3566 * i40iw_cm_init_tsa_conn - setup qp for RTS
3567 * @iwqp: associate qp for the connection
3568 * @cm_node: connection's node
3570 static void i40iw_cm_init_tsa_conn(struct i40iw_qp *iwqp,
3571 struct i40iw_cm_node *cm_node)
3573 struct i40iw_tcp_offload_info tcp_info;
3574 struct i40iwarp_offload_info *iwarp_info;
3575 struct i40iw_qp_host_ctx_info *ctx_info;
3576 struct i40iw_device *iwdev = iwqp->iwdev;
3577 struct i40iw_sc_dev *dev = &iwqp->iwdev->sc_dev;
3579 memset(&tcp_info, 0x00, sizeof(struct i40iw_tcp_offload_info));
3580 iwarp_info = &iwqp->iwarp_info;
3581 ctx_info = &iwqp->ctx_info;
3583 ctx_info->tcp_info = &tcp_info;
3584 ctx_info->send_cq_num = iwqp->iwscq->sc_cq.cq_uk.cq_id;
3585 ctx_info->rcv_cq_num = iwqp->iwrcq->sc_cq.cq_uk.cq_id;
3587 iwarp_info->ord_size = cm_node->ord_size;
3588 iwarp_info->ird_size = i40iw_derive_hw_ird_setting(cm_node->ird_size);
3590 if (iwarp_info->ord_size == 1)
3591 iwarp_info->ord_size = 2;
3593 iwarp_info->rd_enable = true;
3594 iwarp_info->rdmap_ver = 1;
3595 iwarp_info->ddp_ver = 1;
3597 iwarp_info->pd_id = iwqp->iwpd->sc_pd.pd_id;
3599 ctx_info->tcp_info_valid = true;
3600 ctx_info->iwarp_info_valid = true;
3602 i40iw_init_tcp_ctx(cm_node, &tcp_info, iwqp);
3603 if (cm_node->snd_mark_en) {
3604 iwarp_info->snd_mark_en = true;
3605 iwarp_info->snd_mark_offset = (tcp_info.snd_nxt &
3606 SNDMARKER_SEQNMASK) + cm_node->lsmm_size;
3609 cm_node->state = I40IW_CM_STATE_OFFLOADED;
3610 tcp_info.tcp_state = I40IW_TCP_STATE_ESTABLISHED;
3611 tcp_info.src_mac_addr_idx = iwdev->mac_ip_table_idx;
3613 dev->iw_priv_qp_ops->qp_setctx(&iwqp->sc_qp, (u64 *)(iwqp->host_ctx.va), ctx_info);
3615 /* once tcp_info is set, no need to do it again */
3616 ctx_info->tcp_info_valid = false;
3617 ctx_info->iwarp_info_valid = false;
3621 * i40iw_cm_disconn - when a connection is being closed
3622 * @iwqp: associate qp for the connection
3624 int i40iw_cm_disconn(struct i40iw_qp *iwqp)
3626 struct disconn_work *work;
3627 struct i40iw_device *iwdev = iwqp->iwdev;
3628 struct i40iw_cm_core *cm_core = &iwdev->cm_core;
3630 work = kzalloc(sizeof(*work), GFP_ATOMIC);
3632 return -ENOMEM; /* Timer will clean up */
3634 i40iw_add_ref(&iwqp->ibqp);
3636 INIT_WORK(&work->work, i40iw_disconnect_worker);
3637 queue_work(cm_core->disconn_wq, &work->work);
3642 * i40iw_loopback_nop - Send a nop
3643 * @qp: associated hw qp
3645 static void i40iw_loopback_nop(struct i40iw_sc_qp *qp)
3650 wqe = qp->qp_uk.sq_base->elem;
3651 set_64bit_val(wqe, 0, 0);
3652 set_64bit_val(wqe, 8, 0);
3653 set_64bit_val(wqe, 16, 0);
3655 header = LS_64(I40IWQP_OP_NOP, I40IWQPSQ_OPCODE) |
3656 LS_64(0, I40IWQPSQ_SIGCOMPL) |
3657 LS_64(qp->qp_uk.swqe_polarity, I40IWQPSQ_VALID);
3658 set_64bit_val(wqe, 24, header);
3662 * i40iw_qp_disconnect - free qp and close cm
3663 * @iwqp: associate qp for the connection
3665 static void i40iw_qp_disconnect(struct i40iw_qp *iwqp)
3667 struct i40iw_device *iwdev;
3668 struct i40iw_ib_device *iwibdev;
3670 iwdev = to_iwdev(iwqp->ibqp.device);
3672 i40iw_pr_err("iwdev == NULL\n");
3676 iwibdev = iwdev->iwibdev;
3678 if (iwqp->active_conn) {
3679 /* indicate this connection is NOT active */
3680 iwqp->active_conn = 0;
3682 /* Need to free the Last Streaming Mode Message */
3683 if (iwqp->ietf_mem.va) {
3685 iwibdev->ibdev.dereg_mr(iwqp->lsmm_mr);
3686 i40iw_free_dma_mem(iwdev->sc_dev.hw, &iwqp->ietf_mem);
3690 /* close the CM node down if it is still active */
3691 if (iwqp->cm_node) {
3692 i40iw_debug(&iwdev->sc_dev, I40IW_DEBUG_CM, "%s Call close API\n", __func__);
3693 i40iw_cm_close(iwqp->cm_node);
3698 * i40iw_cm_disconn_true - called by worker thread to disconnect qp
3699 * @iwqp: associate qp for the connection
3701 static void i40iw_cm_disconn_true(struct i40iw_qp *iwqp)
3703 struct iw_cm_id *cm_id;
3704 struct i40iw_device *iwdev;
3705 struct i40iw_sc_qp *qp = &iwqp->sc_qp;
3707 u8 original_hw_tcp_state;
3708 u8 original_ibqp_state;
3709 int disconn_status = 0;
3710 int issue_disconn = 0;
3711 int issue_close = 0;
3712 int issue_flush = 0;
3713 struct ib_event ibevent;
3714 unsigned long flags;
3718 i40iw_pr_err("iwqp == NULL\n");
3722 spin_lock_irqsave(&iwqp->lock, flags);
3723 cm_id = iwqp->cm_id;
3724 /* make sure we havent already closed this connection */
3726 spin_unlock_irqrestore(&iwqp->lock, flags);
3730 iwdev = to_iwdev(iwqp->ibqp.device);
3732 original_hw_tcp_state = iwqp->hw_tcp_state;
3733 original_ibqp_state = iwqp->ibqp_state;
3734 last_ae = iwqp->last_aeq;
3736 if (qp->term_flags) {
3740 /*When term timer expires after cm_timer, don't want
3741 *terminate-handler to issue cm_disconn which can re-free
3742 *a QP even after its refcnt=0.
3744 del_timer(&iwqp->terminate_timer);
3745 if (!iwqp->flush_issued) {
3746 iwqp->flush_issued = 1;
3749 } else if ((original_hw_tcp_state == I40IW_TCP_STATE_CLOSE_WAIT) ||
3750 ((original_ibqp_state == IB_QPS_RTS) &&
3751 (last_ae == I40IW_AE_LLP_CONNECTION_RESET))) {
3753 if (last_ae == I40IW_AE_LLP_CONNECTION_RESET)
3754 disconn_status = -ECONNRESET;
3757 if (((original_hw_tcp_state == I40IW_TCP_STATE_CLOSED) ||
3758 (original_hw_tcp_state == I40IW_TCP_STATE_TIME_WAIT) ||
3759 (last_ae == I40IW_AE_RDMAP_ROE_BAD_LLP_CLOSE) ||
3760 (last_ae == I40IW_AE_LLP_CONNECTION_RESET))) {
3763 if (!iwqp->flush_issued) {
3764 iwqp->flush_issued = 1;
3769 spin_unlock_irqrestore(&iwqp->lock, flags);
3770 if (issue_flush && !iwqp->destroyed) {
3771 /* Flush the queues */
3772 i40iw_flush_wqes(iwdev, iwqp);
3774 if (qp->term_flags) {
3775 ibevent.device = iwqp->ibqp.device;
3776 ibevent.event = (qp->eventtype == TERM_EVENT_QP_FATAL) ?
3777 IB_EVENT_QP_FATAL : IB_EVENT_QP_ACCESS_ERR;
3778 ibevent.element.qp = &iwqp->ibqp;
3779 iwqp->ibqp.event_handler(&ibevent, iwqp->ibqp.qp_context);
3783 if (cm_id && cm_id->event_handler) {
3784 if (issue_disconn) {
3785 ret = i40iw_send_cm_event(NULL,
3787 IW_CM_EVENT_DISCONNECT,
3791 i40iw_debug(&iwdev->sc_dev,
3793 "disconnect event failed %s: - cm_id = %p\n",
3797 i40iw_qp_disconnect(iwqp);
3798 cm_id->provider_data = iwqp;
3799 ret = i40iw_send_cm_event(NULL, cm_id, IW_CM_EVENT_CLOSE, 0);
3801 i40iw_debug(&iwdev->sc_dev,
3803 "close event failed %s: - cm_id = %p\n",
3805 cm_id->rem_ref(cm_id);
3811 * i40iw_disconnect_worker - worker for connection close
3812 * @work: points or disconn structure
3814 static void i40iw_disconnect_worker(struct work_struct *work)
3816 struct disconn_work *dwork = container_of(work, struct disconn_work, work);
3817 struct i40iw_qp *iwqp = dwork->iwqp;
3820 i40iw_cm_disconn_true(iwqp);
3821 i40iw_rem_ref(&iwqp->ibqp);
3825 * i40iw_accept - registered call for connection to be accepted
3826 * @cm_id: cm information for passive connection
3827 * @conn_param: accpet parameters
3829 int i40iw_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
3832 struct i40iw_qp *iwqp;
3833 struct i40iw_device *iwdev;
3834 struct i40iw_sc_dev *dev;
3835 struct i40iw_cm_node *cm_node;
3836 struct ib_qp_attr attr;
3838 struct i40iw_ib_device *iwibdev;
3840 struct i40iw_pd *iwpd;
3842 struct i40iw_kmem_info accept;
3843 enum i40iw_status_code status;
3846 memset(&attr, 0, sizeof(attr));
3847 ibqp = i40iw_get_qp(cm_id->device, conn_param->qpn);
3851 iwqp = to_iwqp(ibqp);
3852 iwdev = iwqp->iwdev;
3853 dev = &iwdev->sc_dev;
3854 cm_node = (struct i40iw_cm_node *)cm_id->provider_data;
3856 if (((struct sockaddr_in *)&cm_id->local_addr)->sin_family == AF_INET) {
3857 cm_node->ipv4 = true;
3858 cm_node->vlan_id = i40iw_get_vlan_ipv4(cm_node->loc_addr);
3860 cm_node->ipv4 = false;
3861 i40iw_netdev_vlan_ipv6(cm_node->loc_addr, &cm_node->vlan_id, NULL);
3863 i40iw_debug(cm_node->dev,
3865 "Accept vlan_id=%d\n",
3867 if (cm_node->state == I40IW_CM_STATE_LISTENER_DESTROYED) {
3868 if (cm_node->loopbackpartner)
3869 i40iw_rem_ref_cm_node(cm_node->loopbackpartner);
3870 i40iw_rem_ref_cm_node(cm_node);
3874 passive_state = atomic_add_return(1, &cm_node->passive_state);
3875 if (passive_state == I40IW_SEND_RESET_EVENT) {
3876 i40iw_rem_ref_cm_node(cm_node);
3880 cm_node->cm_core->stats_accepts++;
3881 iwqp->cm_node = (void *)cm_node;
3882 cm_node->iwqp = iwqp;
3884 buf_len = conn_param->private_data_len + I40IW_MAX_IETF_SIZE + MPA_ZERO_PAD_LEN;
3886 status = i40iw_allocate_dma_mem(dev->hw, &iwqp->ietf_mem, buf_len, 1);
3890 cm_node->pdata.size = conn_param->private_data_len;
3891 accept.addr = iwqp->ietf_mem.va;
3892 accept.size = i40iw_cm_build_mpa_frame(cm_node, &accept, MPA_KEY_REPLY);
3893 memcpy(accept.addr + accept.size, conn_param->private_data,
3894 conn_param->private_data_len);
3896 /* setup our first outgoing iWarp send WQE (the IETF frame response) */
3897 if ((cm_node->ipv4 &&
3898 !i40iw_ipv4_is_loopback(cm_node->loc_addr[0], cm_node->rem_addr[0])) ||
3900 !i40iw_ipv6_is_loopback(cm_node->loc_addr, cm_node->rem_addr))) {
3901 iwibdev = iwdev->iwibdev;
3903 tagged_offset = (uintptr_t)iwqp->ietf_mem.va;
3904 ibmr = i40iw_reg_phys_mr(&iwpd->ibpd,
3907 IB_ACCESS_LOCAL_WRITE,
3910 i40iw_free_dma_mem(dev->hw, &iwqp->ietf_mem);
3914 ibmr->pd = &iwpd->ibpd;
3915 ibmr->device = iwpd->ibpd.device;
3916 iwqp->lsmm_mr = ibmr;
3918 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page);
3919 if (is_remote_ne020_or_chelsio(cm_node))
3920 dev->iw_priv_qp_ops->qp_send_lsmm(
3923 (accept.size + conn_param->private_data_len),
3926 dev->iw_priv_qp_ops->qp_send_lsmm(
3929 (accept.size + conn_param->private_data_len + MPA_ZERO_PAD_LEN),
3934 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page);
3935 i40iw_loopback_nop(&iwqp->sc_qp);
3941 iwqp->cm_id = cm_id;
3942 cm_node->cm_id = cm_id;
3944 cm_id->provider_data = (void *)iwqp;
3945 iwqp->active_conn = 0;
3947 cm_node->lsmm_size = accept.size + conn_param->private_data_len;
3948 i40iw_cm_init_tsa_conn(iwqp, cm_node);
3949 cm_id->add_ref(cm_id);
3950 i40iw_add_ref(&iwqp->ibqp);
3952 i40iw_send_cm_event(cm_node, cm_id, IW_CM_EVENT_ESTABLISHED, 0);
3954 attr.qp_state = IB_QPS_RTS;
3955 cm_node->qhash_set = false;
3956 i40iw_modify_qp(&iwqp->ibqp, &attr, IB_QP_STATE, NULL);
3957 if (cm_node->loopbackpartner) {
3958 cm_node->loopbackpartner->pdata.size = conn_param->private_data_len;
3960 /* copy entire MPA frame to our cm_node's frame */
3961 memcpy(cm_node->loopbackpartner->pdata_buf,
3962 conn_param->private_data,
3963 conn_param->private_data_len);
3964 i40iw_create_event(cm_node->loopbackpartner, I40IW_CM_EVENT_CONNECTED);
3967 cm_node->accelerated = 1;
3968 if (cm_node->accept_pend) {
3969 if (!cm_node->listener)
3970 i40iw_pr_err("cm_node->listener NULL for passive node\n");
3971 atomic_dec(&cm_node->listener->pend_accepts_cnt);
3972 cm_node->accept_pend = 0;
3978 * i40iw_reject - registered call for connection to be rejected
3979 * @cm_id: cm information for passive connection
3980 * @pdata: private data to be sent
3981 * @pdata_len: private data length
3983 int i40iw_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
3985 struct i40iw_device *iwdev;
3986 struct i40iw_cm_node *cm_node;
3987 struct i40iw_cm_node *loopback;
3989 cm_node = (struct i40iw_cm_node *)cm_id->provider_data;
3990 loopback = cm_node->loopbackpartner;
3991 cm_node->cm_id = cm_id;
3992 cm_node->pdata.size = pdata_len;
3994 iwdev = to_iwdev(cm_id->device);
3997 cm_node->cm_core->stats_rejects++;
3999 if (pdata_len + sizeof(struct ietf_mpa_v2) > MAX_CM_BUFFER)
4003 memcpy(&loopback->pdata_buf, pdata, pdata_len);
4004 loopback->pdata.size = pdata_len;
4007 return i40iw_cm_reject(cm_node, pdata, pdata_len);
4011 * i40iw_connect - registered call for connection to be established
4012 * @cm_id: cm information for passive connection
4013 * @conn_param: Information about the connection
4015 int i40iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
4018 struct i40iw_qp *iwqp;
4019 struct i40iw_device *iwdev;
4020 struct i40iw_cm_node *cm_node;
4021 struct i40iw_cm_info cm_info;
4022 struct sockaddr_in *laddr;
4023 struct sockaddr_in *raddr;
4024 struct sockaddr_in6 *laddr6;
4025 struct sockaddr_in6 *raddr6;
4026 struct iwpm_dev_data pm_reg_msg;
4027 struct iwpm_sa_data pm_msg;
4029 enum i40iw_status_code status;
4032 ibqp = i40iw_get_qp(cm_id->device, conn_param->qpn);
4035 iwqp = to_iwqp(ibqp);
4038 iwdev = to_iwdev(iwqp->ibqp.device);
4042 laddr = (struct sockaddr_in *)&cm_id->local_addr;
4043 raddr = (struct sockaddr_in *)&cm_id->remote_addr;
4044 laddr6 = (struct sockaddr_in6 *)&cm_id->local_addr;
4045 raddr6 = (struct sockaddr_in6 *)&cm_id->remote_addr;
4047 if (!(laddr->sin_port) || !(raddr->sin_port))
4050 iwqp->active_conn = 1;
4052 cm_id->provider_data = iwqp;
4054 /* set up the connection params for the node */
4055 if (cm_id->remote_addr.ss_family == AF_INET) {
4056 cm_info.ipv4 = true;
4057 memset(cm_info.loc_addr, 0, sizeof(cm_info.loc_addr));
4058 memset(cm_info.rem_addr, 0, sizeof(cm_info.rem_addr));
4059 cm_info.loc_addr[0] = ntohl(laddr->sin_addr.s_addr);
4060 cm_info.rem_addr[0] = ntohl(raddr->sin_addr.s_addr);
4061 cm_info.loc_port = ntohs(laddr->sin_port);
4062 cm_info.rem_port = ntohs(raddr->sin_port);
4063 cm_info.vlan_id = i40iw_get_vlan_ipv4(cm_info.loc_addr);
4065 cm_info.ipv4 = false;
4066 i40iw_copy_ip_ntohl(cm_info.loc_addr,
4067 laddr6->sin6_addr.in6_u.u6_addr32);
4068 i40iw_copy_ip_ntohl(cm_info.rem_addr,
4069 raddr6->sin6_addr.in6_u.u6_addr32);
4070 cm_info.loc_port = ntohs(laddr6->sin6_port);
4071 cm_info.rem_port = ntohs(raddr6->sin6_port);
4072 i40iw_netdev_vlan_ipv6(cm_info.loc_addr, &cm_info.vlan_id, NULL);
4074 i40iw_init_mapinfo(&cm_info);
4075 cm_info.cm_id = cm_id;
4077 i40iw_form_reg_msg(iwdev, &pm_reg_msg);
4078 iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_I40IW);
4080 i40iw_pr_err("PM register fail err = %d\n",
4083 if (iwpm_valid_pid() && !iwpm_err) {
4084 i40iw_form_pm_msg(&cm_info, &pm_msg);
4085 iwpm_err = iwpm_add_and_query_mapping(&pm_msg, RDMA_NL_I40IW);
4087 i40iw_pr_err("PM query fail err = %d\n",
4090 i40iw_record_pm_msg(&cm_info, &pm_msg, true);
4093 if (i40iw_create_mapinfo(&cm_info)) {
4094 i40iw_pr_err("Fail to create mapinfo\n");
4098 if ((cm_info.ipv4 && (laddr->sin_addr.s_addr != raddr->sin_addr.s_addr)) ||
4099 (!cm_info.ipv4 && memcmp(laddr6->sin6_addr.in6_u.u6_addr32,
4100 raddr6->sin6_addr.in6_u.u6_addr32,
4101 sizeof(laddr6->sin6_addr.in6_u.u6_addr32)))) {
4102 status = i40iw_manage_qhash(iwdev,
4104 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
4105 I40IW_QHASH_MANAGE_TYPE_ADD,
4109 i40iw_remove_mapinfo(&cm_info);
4113 status = i40iw_manage_apbvt(iwdev, cm_info.map_loc_port, I40IW_MANAGE_APBVT_ADD);
4115 i40iw_remove_mapinfo(&cm_info);
4116 i40iw_manage_qhash(iwdev,
4118 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
4119 I40IW_QHASH_MANAGE_TYPE_DELETE,
4126 cm_id->add_ref(cm_id);
4127 cm_node = i40iw_create_cm_node(&iwdev->cm_core, iwdev,
4128 conn_param->private_data_len,
4129 (void *)conn_param->private_data,
4132 i40iw_manage_qhash(iwdev,
4134 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
4135 I40IW_QHASH_MANAGE_TYPE_DELETE,
4139 if (apbvt_set && !i40iw_listen_port_in_use(&iwdev->cm_core,
4140 cm_info.map_loc_port))
4141 i40iw_manage_apbvt(iwdev,
4142 cm_info.map_loc_port,
4143 I40IW_MANAGE_APBVT_DEL);
4145 i40iw_remove_mapinfo(&cm_info);
4146 cm_id->rem_ref(cm_id);
4147 iwdev->cm_core.stats_connect_errs++;
4151 i40iw_record_ird_ord(cm_node, (u16)conn_param->ird, (u16)conn_param->ord);
4152 if (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO &&
4154 cm_node->ord_size = 1;
4156 cm_node->apbvt_set = apbvt_set;
4157 cm_node->qhash_set = true;
4158 iwqp->cm_node = cm_node;
4159 cm_node->iwqp = iwqp;
4160 iwqp->cm_id = cm_id;
4161 i40iw_add_ref(&iwqp->ibqp);
4166 * i40iw_create_listen - registered call creating listener
4167 * @cm_id: cm information for passive connection
4168 * @backlog: to max accept pending count
4170 int i40iw_create_listen(struct iw_cm_id *cm_id, int backlog)
4172 struct i40iw_device *iwdev;
4173 struct i40iw_cm_listener *cm_listen_node;
4174 struct i40iw_cm_info cm_info;
4175 enum i40iw_status_code ret;
4176 struct sockaddr_in *laddr;
4177 struct sockaddr_in6 *laddr6;
4178 bool wildcard = false;
4180 iwdev = to_iwdev(cm_id->device);
4184 laddr = (struct sockaddr_in *)&cm_id->local_addr;
4185 laddr6 = (struct sockaddr_in6 *)&cm_id->local_addr;
4186 memset(&cm_info, 0, sizeof(cm_info));
4187 if (laddr->sin_family == AF_INET) {
4188 cm_info.ipv4 = true;
4189 cm_info.loc_addr[0] = ntohl(laddr->sin_addr.s_addr);
4190 cm_info.loc_port = ntohs(laddr->sin_port);
4192 if (laddr->sin_addr.s_addr != INADDR_ANY)
4193 cm_info.vlan_id = i40iw_get_vlan_ipv4(cm_info.loc_addr);
4198 cm_info.ipv4 = false;
4199 i40iw_copy_ip_ntohl(cm_info.loc_addr,
4200 laddr6->sin6_addr.in6_u.u6_addr32);
4201 cm_info.loc_port = ntohs(laddr6->sin6_port);
4202 if (ipv6_addr_type(&laddr6->sin6_addr) != IPV6_ADDR_ANY)
4203 i40iw_netdev_vlan_ipv6(cm_info.loc_addr,
4209 i40iw_init_mapinfo(&cm_info);
4210 cm_info.backlog = backlog;
4211 cm_info.cm_id = cm_id;
4213 cm_listen_node = i40iw_make_listen_node(&iwdev->cm_core, iwdev, &cm_info);
4214 if (!cm_listen_node) {
4215 i40iw_pr_err("cm_listen_node == NULL\n");
4219 cm_id->provider_data = cm_listen_node;
4221 if (!cm_listen_node->reused_node) {
4222 if (i40iw_create_mapinfo(&cm_info))
4226 ret = i40iw_add_mqh_4(iwdev,
4230 ret = i40iw_add_mqh_6(iwdev,
4236 ret = i40iw_manage_apbvt(iwdev,
4237 cm_info.map_loc_port,
4238 I40IW_MANAGE_APBVT_ADD);
4243 ret = i40iw_manage_qhash(iwdev,
4245 I40IW_QHASH_TYPE_TCP_SYN,
4246 I40IW_QHASH_MANAGE_TYPE_ADD,
4251 cm_listen_node->qhash_set = true;
4252 ret = i40iw_manage_apbvt(iwdev,
4253 cm_info.map_loc_port,
4254 I40IW_MANAGE_APBVT_ADD);
4259 cm_id->add_ref(cm_id);
4260 cm_listen_node->cm_core->stats_listen_created++;
4263 i40iw_cm_del_listen(&iwdev->cm_core, (void *)cm_listen_node, false);
4268 * i40iw_destroy_listen - registered call to destroy listener
4269 * @cm_id: cm information for passive connection
4271 int i40iw_destroy_listen(struct iw_cm_id *cm_id)
4273 struct i40iw_device *iwdev;
4275 iwdev = to_iwdev(cm_id->device);
4276 if (cm_id->provider_data)
4277 i40iw_cm_del_listen(&iwdev->cm_core, cm_id->provider_data, true);
4279 i40iw_pr_err("cm_id->provider_data was NULL\n");
4281 cm_id->rem_ref(cm_id);
4287 * i40iw_cm_event_connected - handle connected active node
4288 * @event: the info for cm_node of connection
4290 static void i40iw_cm_event_connected(struct i40iw_cm_event *event)
4292 struct i40iw_qp *iwqp;
4293 struct i40iw_device *iwdev;
4294 struct i40iw_cm_node *cm_node;
4295 struct i40iw_sc_dev *dev;
4296 struct ib_qp_attr attr;
4297 struct iw_cm_id *cm_id;
4301 cm_node = event->cm_node;
4302 cm_id = cm_node->cm_id;
4303 iwqp = (struct i40iw_qp *)cm_id->provider_data;
4304 iwdev = to_iwdev(iwqp->ibqp.device);
4305 dev = &iwdev->sc_dev;
4307 if (iwqp->destroyed) {
4308 status = -ETIMEDOUT;
4311 i40iw_cm_init_tsa_conn(iwqp, cm_node);
4312 read0 = (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO);
4314 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page);
4315 dev->iw_priv_qp_ops->qp_send_rtt(&iwqp->sc_qp, read0);
4318 status = i40iw_send_cm_event(cm_node, cm_id, IW_CM_EVENT_CONNECT_REPLY, 0);
4320 i40iw_pr_err("send cm event\n");
4322 memset(&attr, 0, sizeof(attr));
4323 attr.qp_state = IB_QPS_RTS;
4324 cm_node->qhash_set = false;
4325 i40iw_modify_qp(&iwqp->ibqp, &attr, IB_QP_STATE, NULL);
4327 cm_node->accelerated = 1;
4328 if (cm_node->accept_pend) {
4329 if (!cm_node->listener)
4330 i40iw_pr_err("listener is null for passive node\n");
4331 atomic_dec(&cm_node->listener->pend_accepts_cnt);
4332 cm_node->accept_pend = 0;
4338 cm_id->provider_data = NULL;
4339 i40iw_send_cm_event(event->cm_node,
4341 IW_CM_EVENT_CONNECT_REPLY,
4343 cm_id->rem_ref(cm_id);
4344 i40iw_rem_ref_cm_node(event->cm_node);
4348 * i40iw_cm_event_reset - handle reset
4349 * @event: the info for cm_node of connection
4351 static void i40iw_cm_event_reset(struct i40iw_cm_event *event)
4353 struct i40iw_cm_node *cm_node = event->cm_node;
4354 struct iw_cm_id *cm_id = cm_node->cm_id;
4355 struct i40iw_qp *iwqp;
4360 iwqp = cm_id->provider_data;
4364 i40iw_debug(cm_node->dev,
4366 "reset event %p - cm_id = %p\n",
4367 event->cm_node, cm_id);
4370 i40iw_send_cm_event(cm_node, cm_node->cm_id, IW_CM_EVENT_DISCONNECT, -ECONNRESET);
4371 i40iw_send_cm_event(cm_node, cm_node->cm_id, IW_CM_EVENT_CLOSE, 0);
4375 * i40iw_cm_event_handler - worker thread callback to send event to cm upper layer
4376 * @work: pointer of cm event info.
4378 static void i40iw_cm_event_handler(struct work_struct *work)
4380 struct i40iw_cm_event *event = container_of(work,
4381 struct i40iw_cm_event,
4383 struct i40iw_cm_node *cm_node;
4385 if (!event || !event->cm_node || !event->cm_node->cm_core)
4388 cm_node = event->cm_node;
4390 switch (event->type) {
4391 case I40IW_CM_EVENT_MPA_REQ:
4392 i40iw_send_cm_event(cm_node,
4394 IW_CM_EVENT_CONNECT_REQUEST,
4397 case I40IW_CM_EVENT_RESET:
4398 i40iw_cm_event_reset(event);
4400 case I40IW_CM_EVENT_CONNECTED:
4401 if (!event->cm_node->cm_id ||
4402 (event->cm_node->state != I40IW_CM_STATE_OFFLOADED))
4404 i40iw_cm_event_connected(event);
4406 case I40IW_CM_EVENT_MPA_REJECT:
4407 if (!event->cm_node->cm_id ||
4408 (cm_node->state == I40IW_CM_STATE_OFFLOADED))
4410 i40iw_send_cm_event(cm_node,
4412 IW_CM_EVENT_CONNECT_REPLY,
4415 case I40IW_CM_EVENT_ABORTED:
4416 if (!event->cm_node->cm_id ||
4417 (event->cm_node->state == I40IW_CM_STATE_OFFLOADED))
4419 i40iw_event_connect_error(event);
4422 i40iw_pr_err("event type = %d\n", event->type);
4426 event->cm_info.cm_id->rem_ref(event->cm_info.cm_id);
4427 i40iw_rem_ref_cm_node(event->cm_node);
4432 * i40iw_cm_post_event - queue event request for worker thread
4433 * @event: cm node's info for up event call
4435 static void i40iw_cm_post_event(struct i40iw_cm_event *event)
4437 atomic_inc(&event->cm_node->ref_count);
4438 event->cm_info.cm_id->add_ref(event->cm_info.cm_id);
4439 INIT_WORK(&event->event_work, i40iw_cm_event_handler);
4441 queue_work(event->cm_node->cm_core->event_wq, &event->event_work);