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
71 * @vsi: pointer to vsi structure
72 * @buf: puda buffer to free
74 void i40iw_free_sqbuf(struct i40iw_sc_vsi
*vsi
, void *bufp
)
76 struct i40iw_puda_buf
*buf
= (struct i40iw_puda_buf
*)bufp
;
77 struct i40iw_puda_rsrc
*ilq
= vsi
->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_get_addr_info
212 * @cm_node: contains ip/tcp info
213 * @cm_info: to get a copy of the cm_node ip/tcp info
215 static void i40iw_get_addr_info(struct i40iw_cm_node
*cm_node
,
216 struct i40iw_cm_info
*cm_info
)
218 cm_info
->ipv4
= cm_node
->ipv4
;
219 cm_info
->vlan_id
= cm_node
->vlan_id
;
220 memcpy(cm_info
->loc_addr
, cm_node
->loc_addr
, sizeof(cm_info
->loc_addr
));
221 memcpy(cm_info
->rem_addr
, cm_node
->rem_addr
, sizeof(cm_info
->rem_addr
));
222 cm_info
->loc_port
= cm_node
->loc_port
;
223 cm_info
->rem_port
= cm_node
->rem_port
;
224 cm_info
->user_pri
= cm_node
->user_pri
;
228 * i40iw_get_cmevent_info - for cm event upcall
229 * @cm_node: connection's node
230 * @cm_id: upper layers cm struct for the event
231 * @event: upper layer's cm event
233 static inline void i40iw_get_cmevent_info(struct i40iw_cm_node
*cm_node
,
234 struct iw_cm_id
*cm_id
,
235 struct iw_cm_event
*event
)
237 memcpy(&event
->local_addr
, &cm_id
->m_local_addr
,
238 sizeof(event
->local_addr
));
239 memcpy(&event
->remote_addr
, &cm_id
->m_remote_addr
,
240 sizeof(event
->remote_addr
));
242 event
->private_data
= (void *)cm_node
->pdata_buf
;
243 event
->private_data_len
= (u8
)cm_node
->pdata
.size
;
244 event
->ird
= cm_node
->ird_size
;
245 event
->ord
= cm_node
->ord_size
;
250 * i40iw_send_cm_event - upcall cm's event handler
251 * @cm_node: connection's node
252 * @cm_id: upper layer's cm info struct
253 * @type: Event type to indicate
254 * @status: status for the event type
256 static int i40iw_send_cm_event(struct i40iw_cm_node
*cm_node
,
257 struct iw_cm_id
*cm_id
,
258 enum iw_cm_event_type type
,
261 struct iw_cm_event event
;
263 memset(&event
, 0, sizeof(event
));
265 event
.status
= status
;
267 case IW_CM_EVENT_CONNECT_REQUEST
:
269 i40iw_fill_sockaddr4(cm_node
, &event
);
271 i40iw_fill_sockaddr6(cm_node
, &event
);
272 event
.provider_data
= (void *)cm_node
;
273 event
.private_data
= (void *)cm_node
->pdata_buf
;
274 event
.private_data_len
= (u8
)cm_node
->pdata
.size
;
275 event
.ird
= cm_node
->ird_size
;
277 case IW_CM_EVENT_CONNECT_REPLY
:
278 i40iw_get_cmevent_info(cm_node
, cm_id
, &event
);
280 case IW_CM_EVENT_ESTABLISHED
:
281 event
.ird
= cm_node
->ird_size
;
282 event
.ord
= cm_node
->ord_size
;
284 case IW_CM_EVENT_DISCONNECT
:
286 case IW_CM_EVENT_CLOSE
:
289 i40iw_pr_err("event type received type = %d\n", type
);
292 return cm_id
->event_handler(cm_id
, &event
);
296 * i40iw_create_event - create cm event
297 * @cm_node: connection's node
298 * @type: Event type to generate
300 static struct i40iw_cm_event
*i40iw_create_event(struct i40iw_cm_node
*cm_node
,
301 enum i40iw_cm_event_type type
)
303 struct i40iw_cm_event
*event
;
308 event
= kzalloc(sizeof(*event
), GFP_ATOMIC
);
314 event
->cm_node
= cm_node
;
315 memcpy(event
->cm_info
.rem_addr
, cm_node
->rem_addr
, sizeof(event
->cm_info
.rem_addr
));
316 memcpy(event
->cm_info
.loc_addr
, cm_node
->loc_addr
, sizeof(event
->cm_info
.loc_addr
));
317 event
->cm_info
.rem_port
= cm_node
->rem_port
;
318 event
->cm_info
.loc_port
= cm_node
->loc_port
;
319 event
->cm_info
.cm_id
= cm_node
->cm_id
;
321 i40iw_debug(cm_node
->dev
,
323 "node=%p event=%p type=%u dst=%pI4 src=%pI4\n",
327 event
->cm_info
.loc_addr
,
328 event
->cm_info
.rem_addr
);
330 i40iw_cm_post_event(event
);
335 * i40iw_free_retrans_entry - free send entry
336 * @cm_node: connection's node
338 static void i40iw_free_retrans_entry(struct i40iw_cm_node
*cm_node
)
340 struct i40iw_device
*iwdev
= cm_node
->iwdev
;
341 struct i40iw_timer_entry
*send_entry
;
343 send_entry
= cm_node
->send_entry
;
345 cm_node
->send_entry
= NULL
;
346 i40iw_free_sqbuf(&iwdev
->vsi
, (void *)send_entry
->sqbuf
);
348 atomic_dec(&cm_node
->ref_count
);
353 * i40iw_cleanup_retrans_entry - free send entry with lock
354 * @cm_node: connection's node
356 static void i40iw_cleanup_retrans_entry(struct i40iw_cm_node
*cm_node
)
360 spin_lock_irqsave(&cm_node
->retrans_list_lock
, flags
);
361 i40iw_free_retrans_entry(cm_node
);
362 spin_unlock_irqrestore(&cm_node
->retrans_list_lock
, flags
);
366 * i40iw_form_cm_frame - get a free packet and build frame
367 * @cm_node: connection's node ionfo to use in frame
368 * @options: pointer to options info
369 * @hdr: pointer mpa header
370 * @pdata: pointer to private data
371 * @flags: indicates FIN or ACK
373 static struct i40iw_puda_buf
*i40iw_form_cm_frame(struct i40iw_cm_node
*cm_node
,
374 struct i40iw_kmem_info
*options
,
375 struct i40iw_kmem_info
*hdr
,
376 struct i40iw_kmem_info
*pdata
,
379 struct i40iw_puda_buf
*sqbuf
;
380 struct i40iw_sc_vsi
*vsi
= &cm_node
->iwdev
->vsi
;
385 struct ipv6hdr
*ip6h
;
388 u16 eth_hlen
= ETH_HLEN
;
394 sqbuf
= i40iw_puda_get_bufpool(vsi
->ilq
);
400 opts_len
= (u32
)options
->size
;
406 pd_len
= pdata
->size
;
408 if (cm_node
->vlan_id
< VLAN_TAG_PRESENT
)
412 packetsize
= sizeof(*iph
) + sizeof(*tcph
);
414 packetsize
= sizeof(*ip6h
) + sizeof(*tcph
);
415 packetsize
+= opts_len
+ hdr_len
+ pd_len
;
417 memset(buf
, 0x00, eth_hlen
+ packetsize
);
419 sqbuf
->totallen
= packetsize
+ eth_hlen
;
420 sqbuf
->maclen
= eth_hlen
;
421 sqbuf
->tcphlen
= sizeof(*tcph
) + opts_len
;
422 sqbuf
->scratch
= (void *)cm_node
;
424 ethh
= (struct ethhdr
*)buf
;
430 iph
= (struct iphdr
*)buf
;
432 tcph
= (struct tcphdr
*)buf
;
433 buf
+= sizeof(*tcph
);
435 ether_addr_copy(ethh
->h_dest
, cm_node
->rem_mac
);
436 ether_addr_copy(ethh
->h_source
, cm_node
->loc_mac
);
437 if (cm_node
->vlan_id
< VLAN_TAG_PRESENT
) {
438 ((struct vlan_ethhdr
*)ethh
)->h_vlan_proto
= htons(ETH_P_8021Q
);
439 vtag
= (cm_node
->user_pri
<< VLAN_PRIO_SHIFT
) | cm_node
->vlan_id
;
440 ((struct vlan_ethhdr
*)ethh
)->h_vlan_TCI
= htons(vtag
);
442 ((struct vlan_ethhdr
*)ethh
)->h_vlan_encapsulated_proto
= htons(ETH_P_IP
);
444 ethh
->h_proto
= htons(ETH_P_IP
);
447 iph
->version
= IPVERSION
;
448 iph
->ihl
= 5; /* 5 * 4Byte words, IP headr len */
449 iph
->tos
= cm_node
->tos
;
450 iph
->tot_len
= htons(packetsize
);
451 iph
->id
= htons(++cm_node
->tcp_cntxt
.loc_id
);
453 iph
->frag_off
= htons(0x4000);
455 iph
->protocol
= IPPROTO_TCP
;
456 iph
->saddr
= htonl(cm_node
->loc_addr
[0]);
457 iph
->daddr
= htonl(cm_node
->rem_addr
[0]);
460 ip6h
= (struct ipv6hdr
*)buf
;
461 buf
+= sizeof(*ip6h
);
462 tcph
= (struct tcphdr
*)buf
;
463 buf
+= sizeof(*tcph
);
465 ether_addr_copy(ethh
->h_dest
, cm_node
->rem_mac
);
466 ether_addr_copy(ethh
->h_source
, cm_node
->loc_mac
);
467 if (cm_node
->vlan_id
< VLAN_TAG_PRESENT
) {
468 ((struct vlan_ethhdr
*)ethh
)->h_vlan_proto
= htons(ETH_P_8021Q
);
469 vtag
= (cm_node
->user_pri
<< VLAN_PRIO_SHIFT
) | cm_node
->vlan_id
;
470 ((struct vlan_ethhdr
*)ethh
)->h_vlan_TCI
= htons(vtag
);
471 ((struct vlan_ethhdr
*)ethh
)->h_vlan_encapsulated_proto
= htons(ETH_P_IPV6
);
473 ethh
->h_proto
= htons(ETH_P_IPV6
);
476 ip6h
->priority
= cm_node
->tos
>> 4;
477 ip6h
->flow_lbl
[0] = cm_node
->tos
<< 4;
478 ip6h
->flow_lbl
[1] = 0;
479 ip6h
->flow_lbl
[2] = 0;
480 ip6h
->payload_len
= htons(packetsize
- sizeof(*ip6h
));
482 ip6h
->hop_limit
= 128;
483 i40iw_copy_ip_htonl(ip6h
->saddr
.in6_u
.u6_addr32
,
485 i40iw_copy_ip_htonl(ip6h
->daddr
.in6_u
.u6_addr32
,
489 tcph
->source
= htons(cm_node
->loc_port
);
490 tcph
->dest
= htons(cm_node
->rem_port
);
492 tcph
->seq
= htonl(cm_node
->tcp_cntxt
.loc_seq_num
);
494 if (flags
& SET_ACK
) {
495 cm_node
->tcp_cntxt
.loc_ack_num
= cm_node
->tcp_cntxt
.rcv_nxt
;
496 tcph
->ack_seq
= htonl(cm_node
->tcp_cntxt
.loc_ack_num
);
502 if (flags
& SET_SYN
) {
503 cm_node
->tcp_cntxt
.loc_seq_num
++;
506 cm_node
->tcp_cntxt
.loc_seq_num
+= hdr_len
+ pd_len
;
509 if (flags
& SET_FIN
) {
510 cm_node
->tcp_cntxt
.loc_seq_num
++;
517 tcph
->doff
= (u16
)((sizeof(*tcph
) + opts_len
+ 3) >> 2);
518 sqbuf
->tcphlen
= tcph
->doff
<< 2;
519 tcph
->window
= htons(cm_node
->tcp_cntxt
.rcv_wnd
);
523 memcpy(buf
, options
->addr
, opts_len
);
528 memcpy(buf
, hdr
->addr
, hdr_len
);
532 if (pdata
&& pdata
->addr
)
533 memcpy(buf
, pdata
->addr
, pdata
->size
);
535 atomic_set(&sqbuf
->refcount
, 1);
541 * i40iw_send_reset - Send RST packet
542 * @cm_node: connection's node
544 static int i40iw_send_reset(struct i40iw_cm_node
*cm_node
)
546 struct i40iw_puda_buf
*sqbuf
;
547 int flags
= SET_RST
| SET_ACK
;
549 sqbuf
= i40iw_form_cm_frame(cm_node
, NULL
, NULL
, NULL
, flags
);
551 i40iw_pr_err("no sqbuf\n");
555 return i40iw_schedule_cm_timer(cm_node
, sqbuf
, I40IW_TIMER_TYPE_SEND
, 0, 1);
559 * i40iw_active_open_err - send event for active side cm error
560 * @cm_node: connection's node
561 * @reset: Flag to send reset or not
563 static void i40iw_active_open_err(struct i40iw_cm_node
*cm_node
, bool reset
)
565 i40iw_cleanup_retrans_entry(cm_node
);
566 cm_node
->cm_core
->stats_connect_errs
++;
568 i40iw_debug(cm_node
->dev
,
570 "%s cm_node=%p state=%d\n",
574 atomic_inc(&cm_node
->ref_count
);
575 i40iw_send_reset(cm_node
);
578 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
579 i40iw_create_event(cm_node
, I40IW_CM_EVENT_ABORTED
);
583 * i40iw_passive_open_err - handle passive side cm error
584 * @cm_node: connection's node
585 * @reset: send reset or just free cm_node
587 static void i40iw_passive_open_err(struct i40iw_cm_node
*cm_node
, bool reset
)
589 i40iw_cleanup_retrans_entry(cm_node
);
590 cm_node
->cm_core
->stats_passive_errs
++;
591 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
592 i40iw_debug(cm_node
->dev
,
594 "%s cm_node=%p state =%d\n",
599 i40iw_send_reset(cm_node
);
601 i40iw_rem_ref_cm_node(cm_node
);
605 * i40iw_event_connect_error - to create connect error event
606 * @event: cm information for connect event
608 static void i40iw_event_connect_error(struct i40iw_cm_event
*event
)
610 struct i40iw_qp
*iwqp
;
611 struct iw_cm_id
*cm_id
;
613 cm_id
= event
->cm_node
->cm_id
;
617 iwqp
= cm_id
->provider_data
;
619 if (!iwqp
|| !iwqp
->iwdev
)
623 cm_id
->provider_data
= NULL
;
624 i40iw_send_cm_event(event
->cm_node
, cm_id
,
625 IW_CM_EVENT_CONNECT_REPLY
,
627 cm_id
->rem_ref(cm_id
);
628 i40iw_rem_ref_cm_node(event
->cm_node
);
632 * i40iw_process_options
633 * @cm_node: connection's node
634 * @optionsloc: point to start of options
635 * @optionsize: size of all options
636 * @syn_packet: flag if syn packet
638 static int i40iw_process_options(struct i40iw_cm_node
*cm_node
,
645 union all_known_options
*all_options
;
646 char got_mss_option
= 0;
648 while (offset
< optionsize
) {
649 all_options
= (union all_known_options
*)(optionsloc
+ offset
);
650 switch (all_options
->as_base
.optionnum
) {
651 case OPTION_NUMBER_END
:
654 case OPTION_NUMBER_NONE
:
657 case OPTION_NUMBER_MSS
:
658 i40iw_debug(cm_node
->dev
,
660 "%s: MSS Length: %d Offset: %d Size: %d\n",
662 all_options
->as_mss
.length
,
666 if (all_options
->as_mss
.length
!= 4)
668 tmp
= ntohs(all_options
->as_mss
.mss
);
669 if (tmp
> 0 && tmp
< cm_node
->tcp_cntxt
.mss
)
670 cm_node
->tcp_cntxt
.mss
= tmp
;
672 case OPTION_NUMBER_WINDOW_SCALE
:
673 cm_node
->tcp_cntxt
.snd_wscale
=
674 all_options
->as_windowscale
.shiftcount
;
677 i40iw_debug(cm_node
->dev
,
679 "TCP Option not understood: %x\n",
680 all_options
->as_base
.optionnum
);
683 offset
+= all_options
->as_base
.length
;
685 if (!got_mss_option
&& syn_packet
)
686 cm_node
->tcp_cntxt
.mss
= I40IW_CM_DEFAULT_MSS
;
691 * i40iw_handle_tcp_options -
692 * @cm_node: connection's node
693 * @tcph: pointer tcp header
694 * @optionsize: size of options rcvd
695 * @passive: active or passive flag
697 static int i40iw_handle_tcp_options(struct i40iw_cm_node
*cm_node
,
702 u8
*optionsloc
= (u8
*)&tcph
[1];
705 if (i40iw_process_options(cm_node
,
709 i40iw_debug(cm_node
->dev
,
711 "%s: Node %p, Sending RESET\n",
715 i40iw_passive_open_err(cm_node
, true);
717 i40iw_active_open_err(cm_node
, true);
722 cm_node
->tcp_cntxt
.snd_wnd
= ntohs(tcph
->window
) <<
723 cm_node
->tcp_cntxt
.snd_wscale
;
725 if (cm_node
->tcp_cntxt
.snd_wnd
> cm_node
->tcp_cntxt
.max_snd_wnd
)
726 cm_node
->tcp_cntxt
.max_snd_wnd
= cm_node
->tcp_cntxt
.snd_wnd
;
731 * i40iw_build_mpa_v1 - build a MPA V1 frame
732 * @cm_node: connection's node
733 * @mpa_key: to do read0 or write0
735 static void i40iw_build_mpa_v1(struct i40iw_cm_node
*cm_node
,
739 struct ietf_mpa_v1
*mpa_frame
= (struct ietf_mpa_v1
*)start_addr
;
742 case MPA_KEY_REQUEST
:
743 memcpy(mpa_frame
->key
, IEFT_MPA_KEY_REQ
, IETF_MPA_KEY_SIZE
);
746 memcpy(mpa_frame
->key
, IEFT_MPA_KEY_REP
, IETF_MPA_KEY_SIZE
);
751 mpa_frame
->flags
= IETF_MPA_FLAGS_CRC
;
752 mpa_frame
->rev
= cm_node
->mpa_frame_rev
;
753 mpa_frame
->priv_data_len
= htons(cm_node
->pdata
.size
);
757 * i40iw_build_mpa_v2 - build a MPA V2 frame
758 * @cm_node: connection's node
759 * @start_addr: buffer start address
760 * @mpa_key: to do read0 or write0
762 static void i40iw_build_mpa_v2(struct i40iw_cm_node
*cm_node
,
766 struct ietf_mpa_v2
*mpa_frame
= (struct ietf_mpa_v2
*)start_addr
;
767 struct ietf_rtr_msg
*rtr_msg
= &mpa_frame
->rtr_msg
;
768 u16 ctrl_ird
, ctrl_ord
;
770 /* initialize the upper 5 bytes of the frame */
771 i40iw_build_mpa_v1(cm_node
, start_addr
, mpa_key
);
772 mpa_frame
->flags
|= IETF_MPA_V2_FLAG
;
773 mpa_frame
->priv_data_len
+= htons(IETF_RTR_MSG_SIZE
);
775 /* initialize RTR msg */
776 if (cm_node
->mpav2_ird_ord
== IETF_NO_IRD_ORD
) {
777 ctrl_ird
= IETF_NO_IRD_ORD
;
778 ctrl_ord
= IETF_NO_IRD_ORD
;
780 ctrl_ird
= (cm_node
->ird_size
> IETF_NO_IRD_ORD
) ?
781 IETF_NO_IRD_ORD
: cm_node
->ird_size
;
782 ctrl_ord
= (cm_node
->ord_size
> IETF_NO_IRD_ORD
) ?
783 IETF_NO_IRD_ORD
: cm_node
->ord_size
;
786 ctrl_ird
|= IETF_PEER_TO_PEER
;
789 case MPA_KEY_REQUEST
:
790 ctrl_ord
|= IETF_RDMA0_WRITE
;
791 ctrl_ord
|= IETF_RDMA0_READ
;
794 switch (cm_node
->send_rdma0_op
) {
795 case SEND_RDMA_WRITE_ZERO
:
796 ctrl_ord
|= IETF_RDMA0_WRITE
;
798 case SEND_RDMA_READ_ZERO
:
799 ctrl_ord
|= IETF_RDMA0_READ
;
806 rtr_msg
->ctrl_ird
= htons(ctrl_ird
);
807 rtr_msg
->ctrl_ord
= htons(ctrl_ord
);
811 * i40iw_cm_build_mpa_frame - build mpa frame for mpa version 1 or version 2
812 * @cm_node: connection's node
813 * @mpa: mpa: data buffer
814 * @mpa_key: to do read0 or write0
816 static int i40iw_cm_build_mpa_frame(struct i40iw_cm_node
*cm_node
,
817 struct i40iw_kmem_info
*mpa
,
822 switch (cm_node
->mpa_frame_rev
) {
824 hdr_len
= sizeof(struct ietf_mpa_v1
);
825 i40iw_build_mpa_v1(cm_node
, mpa
->addr
, mpa_key
);
828 hdr_len
= sizeof(struct ietf_mpa_v2
);
829 i40iw_build_mpa_v2(cm_node
, mpa
->addr
, mpa_key
);
839 * i40iw_send_mpa_request - active node send mpa request to passive node
840 * @cm_node: connection's node
842 static int i40iw_send_mpa_request(struct i40iw_cm_node
*cm_node
)
844 struct i40iw_puda_buf
*sqbuf
;
847 i40iw_pr_err("cm_node == NULL\n");
851 cm_node
->mpa_hdr
.addr
= &cm_node
->mpa_frame
;
852 cm_node
->mpa_hdr
.size
= i40iw_cm_build_mpa_frame(cm_node
,
855 if (!cm_node
->mpa_hdr
.size
) {
856 i40iw_pr_err("mpa size = %d\n", cm_node
->mpa_hdr
.size
);
860 sqbuf
= i40iw_form_cm_frame(cm_node
,
866 i40iw_pr_err("sq_buf == NULL\n");
869 return i40iw_schedule_cm_timer(cm_node
, sqbuf
, I40IW_TIMER_TYPE_SEND
, 1, 0);
873 * i40iw_send_mpa_reject -
874 * @cm_node: connection's node
875 * @pdata: reject data for connection
876 * @plen: length of reject data
878 static int i40iw_send_mpa_reject(struct i40iw_cm_node
*cm_node
,
882 struct i40iw_puda_buf
*sqbuf
;
883 struct i40iw_kmem_info priv_info
;
885 cm_node
->mpa_hdr
.addr
= &cm_node
->mpa_frame
;
886 cm_node
->mpa_hdr
.size
= i40iw_cm_build_mpa_frame(cm_node
,
890 cm_node
->mpa_frame
.flags
|= IETF_MPA_FLAGS_REJECT
;
891 priv_info
.addr
= (void *)pdata
;
892 priv_info
.size
= plen
;
894 sqbuf
= i40iw_form_cm_frame(cm_node
,
900 i40iw_pr_err("no sqbuf\n");
903 cm_node
->state
= I40IW_CM_STATE_FIN_WAIT1
;
904 return i40iw_schedule_cm_timer(cm_node
, sqbuf
, I40IW_TIMER_TYPE_SEND
, 1, 0);
908 * recv_mpa - process an IETF MPA frame
909 * @cm_node: connection's node
910 * @buffer: Data pointer
911 * @type: to return accept or reject
912 * @len: Len of mpa buffer
914 static int i40iw_parse_mpa(struct i40iw_cm_node
*cm_node
, u8
*buffer
, u32
*type
, u32 len
)
916 struct ietf_mpa_v1
*mpa_frame
;
917 struct ietf_mpa_v2
*mpa_v2_frame
;
918 struct ietf_rtr_msg
*rtr_msg
;
922 *type
= I40IW_MPA_REQUEST_ACCEPT
;
924 if (len
< sizeof(struct ietf_mpa_v1
)) {
925 i40iw_pr_err("ietf buffer small (%x)\n", len
);
929 mpa_frame
= (struct ietf_mpa_v1
*)buffer
;
930 mpa_hdr_len
= sizeof(struct ietf_mpa_v1
);
931 priv_data_len
= ntohs(mpa_frame
->priv_data_len
);
933 if (priv_data_len
> IETF_MAX_PRIV_DATA_LEN
) {
934 i40iw_pr_err("large pri_data %d\n", priv_data_len
);
937 if (mpa_frame
->rev
!= IETF_MPA_V1
&& mpa_frame
->rev
!= IETF_MPA_V2
) {
938 i40iw_pr_err("unsupported mpa rev = %d\n", mpa_frame
->rev
);
941 if (mpa_frame
->rev
> cm_node
->mpa_frame_rev
) {
942 i40iw_pr_err("rev %d\n", mpa_frame
->rev
);
945 cm_node
->mpa_frame_rev
= mpa_frame
->rev
;
947 if (cm_node
->state
!= I40IW_CM_STATE_MPAREQ_SENT
) {
948 if (memcmp(mpa_frame
->key
, IEFT_MPA_KEY_REQ
, IETF_MPA_KEY_SIZE
)) {
949 i40iw_pr_err("Unexpected MPA Key received\n");
953 if (memcmp(mpa_frame
->key
, IEFT_MPA_KEY_REP
, IETF_MPA_KEY_SIZE
)) {
954 i40iw_pr_err("Unexpected MPA Key received\n");
959 if (priv_data_len
+ mpa_hdr_len
> len
) {
960 i40iw_pr_err("ietf buffer len(%x + %x != %x)\n",
961 priv_data_len
, mpa_hdr_len
, len
);
964 if (len
> MAX_CM_BUFFER
) {
965 i40iw_pr_err("ietf buffer large len = %d\n", len
);
969 switch (mpa_frame
->rev
) {
976 mpa_v2_frame
= (struct ietf_mpa_v2
*)buffer
;
977 mpa_hdr_len
+= IETF_RTR_MSG_SIZE
;
978 rtr_msg
= &mpa_v2_frame
->rtr_msg
;
980 /* parse rtr message */
981 ctrl_ord
= ntohs(rtr_msg
->ctrl_ord
);
982 ctrl_ird
= ntohs(rtr_msg
->ctrl_ird
);
983 ird_size
= ctrl_ird
& IETF_NO_IRD_ORD
;
984 ord_size
= ctrl_ord
& IETF_NO_IRD_ORD
;
986 if (!(ctrl_ird
& IETF_PEER_TO_PEER
))
989 if (ird_size
== IETF_NO_IRD_ORD
|| ord_size
== IETF_NO_IRD_ORD
) {
990 cm_node
->mpav2_ird_ord
= IETF_NO_IRD_ORD
;
994 if (cm_node
->state
!= I40IW_CM_STATE_MPAREQ_SENT
) {
996 if (!ord_size
&& (ctrl_ord
& IETF_RDMA0_READ
))
997 cm_node
->ird_size
= 1;
998 if (cm_node
->ord_size
> ird_size
)
999 cm_node
->ord_size
= ird_size
;
1002 if (!ird_size
&& (ctrl_ord
& IETF_RDMA0_READ
))
1004 if (cm_node
->ord_size
> ird_size
)
1005 cm_node
->ord_size
= ird_size
;
1007 if (cm_node
->ird_size
< ord_size
)
1008 /* no resources available */
1013 if (ctrl_ord
& IETF_RDMA0_READ
)
1014 cm_node
->send_rdma0_op
= SEND_RDMA_READ_ZERO
;
1015 else if (ctrl_ord
& IETF_RDMA0_WRITE
)
1016 cm_node
->send_rdma0_op
= SEND_RDMA_WRITE_ZERO
;
1017 else /* Not supported RDMA0 operation */
1019 i40iw_debug(cm_node
->dev
, I40IW_DEBUG_CM
,
1020 "MPAV2: Negotiated ORD: %d, IRD: %d\n",
1021 cm_node
->ord_size
, cm_node
->ird_size
);
1030 memcpy(cm_node
->pdata_buf
, buffer
+ mpa_hdr_len
, priv_data_len
);
1031 cm_node
->pdata
.size
= priv_data_len
;
1033 if (mpa_frame
->flags
& IETF_MPA_FLAGS_REJECT
)
1034 *type
= I40IW_MPA_REQUEST_REJECT
;
1036 if (mpa_frame
->flags
& IETF_MPA_FLAGS_MARKERS
)
1037 cm_node
->snd_mark_en
= true;
1043 * i40iw_schedule_cm_timer
1044 * @@cm_node: connection's node
1045 * @sqbuf: buffer to send
1046 * @type: if it es send ot close
1047 * @send_retrans: if rexmits to be done
1048 * @close_when_complete: is cm_node to be removed
1050 * note - cm_node needs to be protected before calling this. Encase in:
1051 * i40iw_rem_ref_cm_node(cm_core, cm_node);
1052 * i40iw_schedule_cm_timer(...)
1053 * atomic_inc(&cm_node->ref_count);
1055 int i40iw_schedule_cm_timer(struct i40iw_cm_node
*cm_node
,
1056 struct i40iw_puda_buf
*sqbuf
,
1057 enum i40iw_timer_type type
,
1059 int close_when_complete
)
1061 struct i40iw_sc_vsi
*vsi
= &cm_node
->iwdev
->vsi
;
1062 struct i40iw_cm_core
*cm_core
= cm_node
->cm_core
;
1063 struct i40iw_timer_entry
*new_send
;
1066 unsigned long flags
;
1068 new_send
= kzalloc(sizeof(*new_send
), GFP_ATOMIC
);
1070 i40iw_free_sqbuf(vsi
, (void *)sqbuf
);
1073 new_send
->retrycount
= I40IW_DEFAULT_RETRYS
;
1074 new_send
->retranscount
= I40IW_DEFAULT_RETRANS
;
1075 new_send
->sqbuf
= sqbuf
;
1076 new_send
->timetosend
= jiffies
;
1077 new_send
->type
= type
;
1078 new_send
->send_retrans
= send_retrans
;
1079 new_send
->close_when_complete
= close_when_complete
;
1081 if (type
== I40IW_TIMER_TYPE_CLOSE
) {
1082 new_send
->timetosend
+= (HZ
/ 10);
1083 if (cm_node
->close_entry
) {
1085 i40iw_free_sqbuf(vsi
, (void *)sqbuf
);
1086 i40iw_pr_err("already close entry\n");
1089 cm_node
->close_entry
= new_send
;
1092 if (type
== I40IW_TIMER_TYPE_SEND
) {
1093 spin_lock_irqsave(&cm_node
->retrans_list_lock
, flags
);
1094 cm_node
->send_entry
= new_send
;
1095 atomic_inc(&cm_node
->ref_count
);
1096 spin_unlock_irqrestore(&cm_node
->retrans_list_lock
, flags
);
1097 new_send
->timetosend
= jiffies
+ I40IW_RETRY_TIMEOUT
;
1099 atomic_inc(&sqbuf
->refcount
);
1100 i40iw_puda_send_buf(vsi
->ilq
, sqbuf
);
1101 if (!send_retrans
) {
1102 i40iw_cleanup_retrans_entry(cm_node
);
1103 if (close_when_complete
)
1104 i40iw_rem_ref_cm_node(cm_node
);
1109 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
1110 was_timer_set
= timer_pending(&cm_core
->tcp_timer
);
1112 if (!was_timer_set
) {
1113 cm_core
->tcp_timer
.expires
= new_send
->timetosend
;
1114 add_timer(&cm_core
->tcp_timer
);
1116 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1122 * i40iw_retrans_expired - Could not rexmit the packet
1123 * @cm_node: connection's node
1125 static void i40iw_retrans_expired(struct i40iw_cm_node
*cm_node
)
1127 struct iw_cm_id
*cm_id
= cm_node
->cm_id
;
1128 enum i40iw_cm_node_state state
= cm_node
->state
;
1130 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
1132 case I40IW_CM_STATE_SYN_RCVD
:
1133 case I40IW_CM_STATE_CLOSING
:
1134 i40iw_rem_ref_cm_node(cm_node
);
1136 case I40IW_CM_STATE_FIN_WAIT1
:
1137 case I40IW_CM_STATE_LAST_ACK
:
1139 cm_id
->rem_ref(cm_id
);
1140 i40iw_send_reset(cm_node
);
1143 atomic_inc(&cm_node
->ref_count
);
1144 i40iw_send_reset(cm_node
);
1145 i40iw_create_event(cm_node
, I40IW_CM_EVENT_ABORTED
);
1151 * i40iw_handle_close_entry - for handling retry/timeouts
1152 * @cm_node: connection's node
1153 * @rem_node: flag for remove cm_node
1155 static void i40iw_handle_close_entry(struct i40iw_cm_node
*cm_node
, u32 rem_node
)
1157 struct i40iw_timer_entry
*close_entry
= cm_node
->close_entry
;
1158 struct iw_cm_id
*cm_id
= cm_node
->cm_id
;
1159 struct i40iw_qp
*iwqp
;
1160 unsigned long flags
;
1164 iwqp
= (struct i40iw_qp
*)close_entry
->sqbuf
;
1166 spin_lock_irqsave(&iwqp
->lock
, flags
);
1168 iwqp
->hw_tcp_state
= I40IW_TCP_STATE_CLOSED
;
1169 iwqp
->hw_iwarp_state
= I40IW_QP_STATE_ERROR
;
1170 iwqp
->last_aeq
= I40IW_AE_RESET_SENT
;
1171 iwqp
->ibqp_state
= IB_QPS_ERR
;
1172 spin_unlock_irqrestore(&iwqp
->lock
, flags
);
1173 i40iw_cm_disconn(iwqp
);
1175 spin_unlock_irqrestore(&iwqp
->lock
, flags
);
1177 } else if (rem_node
) {
1178 /* TIME_WAIT state */
1179 i40iw_rem_ref_cm_node(cm_node
);
1182 cm_id
->rem_ref(cm_id
);
1184 cm_node
->close_entry
= NULL
;
1188 * i40iw_cm_timer_tick - system's timer expired callback
1189 * @pass: Pointing to cm_core
1191 static void i40iw_cm_timer_tick(unsigned long pass
)
1193 unsigned long nexttimeout
= jiffies
+ I40IW_LONG_TIME
;
1194 struct i40iw_cm_node
*cm_node
;
1195 struct i40iw_timer_entry
*send_entry
, *close_entry
;
1196 struct list_head
*list_core_temp
;
1197 struct i40iw_sc_vsi
*vsi
;
1198 struct list_head
*list_node
;
1199 struct i40iw_cm_core
*cm_core
= (struct i40iw_cm_core
*)pass
;
1201 unsigned long timetosend
;
1202 struct i40iw_sc_dev
*dev
;
1203 unsigned long flags
;
1205 struct list_head timer_list
;
1207 INIT_LIST_HEAD(&timer_list
);
1208 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
1210 list_for_each_safe(list_node
, list_core_temp
, &cm_core
->connected_nodes
) {
1211 cm_node
= container_of(list_node
, struct i40iw_cm_node
, list
);
1212 if (cm_node
->close_entry
|| cm_node
->send_entry
) {
1213 atomic_inc(&cm_node
->ref_count
);
1214 list_add(&cm_node
->timer_entry
, &timer_list
);
1217 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1219 list_for_each_safe(list_node
, list_core_temp
, &timer_list
) {
1220 cm_node
= container_of(list_node
,
1221 struct i40iw_cm_node
,
1223 close_entry
= cm_node
->close_entry
;
1226 if (time_after(close_entry
->timetosend
, jiffies
)) {
1227 if (nexttimeout
> close_entry
->timetosend
||
1229 nexttimeout
= close_entry
->timetosend
;
1233 i40iw_handle_close_entry(cm_node
, 1);
1237 spin_lock_irqsave(&cm_node
->retrans_list_lock
, flags
);
1239 send_entry
= cm_node
->send_entry
;
1242 if (time_after(send_entry
->timetosend
, jiffies
)) {
1243 if (cm_node
->state
!= I40IW_CM_STATE_OFFLOADED
) {
1244 if ((nexttimeout
> send_entry
->timetosend
) ||
1246 nexttimeout
= send_entry
->timetosend
;
1250 i40iw_free_retrans_entry(cm_node
);
1255 if ((cm_node
->state
== I40IW_CM_STATE_OFFLOADED
) ||
1256 (cm_node
->state
== I40IW_CM_STATE_CLOSED
)) {
1257 i40iw_free_retrans_entry(cm_node
);
1261 if (!send_entry
->retranscount
|| !send_entry
->retrycount
) {
1262 i40iw_free_retrans_entry(cm_node
);
1264 spin_unlock_irqrestore(&cm_node
->retrans_list_lock
, flags
);
1265 i40iw_retrans_expired(cm_node
);
1266 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
1267 spin_lock_irqsave(&cm_node
->retrans_list_lock
, flags
);
1270 cm_node
->cm_core
->stats_pkt_retrans
++;
1271 spin_unlock_irqrestore(&cm_node
->retrans_list_lock
, flags
);
1273 vsi
= &cm_node
->iwdev
->vsi
;
1275 atomic_inc(&send_entry
->sqbuf
->refcount
);
1276 i40iw_puda_send_buf(vsi
->ilq
, send_entry
->sqbuf
);
1277 spin_lock_irqsave(&cm_node
->retrans_list_lock
, flags
);
1278 if (send_entry
->send_retrans
) {
1279 send_entry
->retranscount
--;
1280 timetosend
= (I40IW_RETRY_TIMEOUT
<<
1281 (I40IW_DEFAULT_RETRANS
-
1282 send_entry
->retranscount
));
1284 send_entry
->timetosend
= jiffies
+
1285 min(timetosend
, I40IW_MAX_TIMEOUT
);
1286 if (nexttimeout
> send_entry
->timetosend
|| !settimer
) {
1287 nexttimeout
= send_entry
->timetosend
;
1291 int close_when_complete
;
1293 close_when_complete
= send_entry
->close_when_complete
;
1294 i40iw_debug(cm_node
->dev
,
1296 "cm_node=%p state=%d\n",
1299 i40iw_free_retrans_entry(cm_node
);
1300 if (close_when_complete
)
1301 i40iw_rem_ref_cm_node(cm_node
);
1304 spin_unlock_irqrestore(&cm_node
->retrans_list_lock
, flags
);
1305 i40iw_rem_ref_cm_node(cm_node
);
1309 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
1310 if (!timer_pending(&cm_core
->tcp_timer
)) {
1311 cm_core
->tcp_timer
.expires
= nexttimeout
;
1312 add_timer(&cm_core
->tcp_timer
);
1314 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1319 * i40iw_send_syn - send SYN packet
1320 * @cm_node: connection's node
1321 * @sendack: flag to set ACK bit or not
1323 int i40iw_send_syn(struct i40iw_cm_node
*cm_node
, u32 sendack
)
1325 struct i40iw_puda_buf
*sqbuf
;
1326 int flags
= SET_SYN
;
1327 char optionsbuffer
[sizeof(struct option_mss
) +
1328 sizeof(struct option_windowscale
) +
1329 sizeof(struct option_base
) + TCP_OPTIONS_PADDING
];
1330 struct i40iw_kmem_info opts
;
1332 int optionssize
= 0;
1333 /* Sending MSS option */
1334 union all_known_options
*options
;
1336 opts
.addr
= optionsbuffer
;
1338 i40iw_pr_err("no cm_node\n");
1342 options
= (union all_known_options
*)&optionsbuffer
[optionssize
];
1343 options
->as_mss
.optionnum
= OPTION_NUMBER_MSS
;
1344 options
->as_mss
.length
= sizeof(struct option_mss
);
1345 options
->as_mss
.mss
= htons(cm_node
->tcp_cntxt
.mss
);
1346 optionssize
+= sizeof(struct option_mss
);
1348 options
= (union all_known_options
*)&optionsbuffer
[optionssize
];
1349 options
->as_windowscale
.optionnum
= OPTION_NUMBER_WINDOW_SCALE
;
1350 options
->as_windowscale
.length
= sizeof(struct option_windowscale
);
1351 options
->as_windowscale
.shiftcount
= cm_node
->tcp_cntxt
.rcv_wscale
;
1352 optionssize
+= sizeof(struct option_windowscale
);
1353 options
= (union all_known_options
*)&optionsbuffer
[optionssize
];
1354 options
->as_end
= OPTION_NUMBER_END
;
1360 opts
.size
= optionssize
;
1362 sqbuf
= i40iw_form_cm_frame(cm_node
, &opts
, NULL
, NULL
, flags
);
1364 i40iw_pr_err("no sqbuf\n");
1367 return i40iw_schedule_cm_timer(cm_node
, sqbuf
, I40IW_TIMER_TYPE_SEND
, 1, 0);
1371 * i40iw_send_ack - Send ACK packet
1372 * @cm_node: connection's node
1374 static void i40iw_send_ack(struct i40iw_cm_node
*cm_node
)
1376 struct i40iw_puda_buf
*sqbuf
;
1377 struct i40iw_sc_vsi
*vsi
= &cm_node
->iwdev
->vsi
;
1379 sqbuf
= i40iw_form_cm_frame(cm_node
, NULL
, NULL
, NULL
, SET_ACK
);
1381 i40iw_puda_send_buf(vsi
->ilq
, sqbuf
);
1383 i40iw_pr_err("no sqbuf\n");
1387 * i40iw_send_fin - Send FIN pkt
1388 * @cm_node: connection's node
1390 static int i40iw_send_fin(struct i40iw_cm_node
*cm_node
)
1392 struct i40iw_puda_buf
*sqbuf
;
1394 sqbuf
= i40iw_form_cm_frame(cm_node
, NULL
, NULL
, NULL
, SET_ACK
| SET_FIN
);
1396 i40iw_pr_err("no sqbuf\n");
1399 return i40iw_schedule_cm_timer(cm_node
, sqbuf
, I40IW_TIMER_TYPE_SEND
, 1, 0);
1403 * i40iw_find_node - find a cm node that matches the reference cm node
1404 * @cm_core: cm's core
1405 * @rem_port: remote tcp port num
1406 * @rem_addr: remote ip addr
1407 * @loc_port: local tcp port num
1408 * @loc_addr: loc ip addr
1409 * @add_refcnt: flag to increment refcount of cm_node
1411 struct i40iw_cm_node
*i40iw_find_node(struct i40iw_cm_core
*cm_core
,
1418 struct list_head
*hte
;
1419 struct i40iw_cm_node
*cm_node
;
1420 unsigned long flags
;
1422 hte
= &cm_core
->connected_nodes
;
1424 /* walk list and find cm_node associated with this session ID */
1425 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
1426 list_for_each_entry(cm_node
, hte
, list
) {
1427 if (!memcmp(cm_node
->loc_addr
, loc_addr
, sizeof(cm_node
->loc_addr
)) &&
1428 (cm_node
->loc_port
== loc_port
) &&
1429 !memcmp(cm_node
->rem_addr
, rem_addr
, sizeof(cm_node
->rem_addr
)) &&
1430 (cm_node
->rem_port
== rem_port
)) {
1432 atomic_inc(&cm_node
->ref_count
);
1433 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1437 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1444 * i40iw_find_listener - find a cm node listening on this addr-port pair
1445 * @cm_core: cm's core
1446 * @dst_port: listener tcp port num
1447 * @dst_addr: listener ip addr
1448 * @listener_state: state to match with listen node's
1450 static struct i40iw_cm_listener
*i40iw_find_listener(
1451 struct i40iw_cm_core
*cm_core
,
1455 enum i40iw_cm_listener_state
1458 struct i40iw_cm_listener
*listen_node
;
1459 static const u32 ip_zero
[4] = { 0, 0, 0, 0 };
1462 unsigned long flags
;
1464 /* walk list and find cm_node associated with this session ID */
1465 spin_lock_irqsave(&cm_core
->listen_list_lock
, flags
);
1466 list_for_each_entry(listen_node
, &cm_core
->listen_nodes
, list
) {
1467 memcpy(listen_addr
, listen_node
->loc_addr
, sizeof(listen_addr
));
1468 listen_port
= listen_node
->loc_port
;
1469 /* compare node pair, return node handle if a match */
1470 if ((!memcmp(listen_addr
, dst_addr
, sizeof(listen_addr
)) ||
1471 !memcmp(listen_addr
, ip_zero
, sizeof(listen_addr
))) &&
1472 (listen_port
== dst_port
) &&
1473 (listener_state
& listen_node
->listener_state
)) {
1474 atomic_inc(&listen_node
->ref_count
);
1475 spin_unlock_irqrestore(&cm_core
->listen_list_lock
, flags
);
1479 spin_unlock_irqrestore(&cm_core
->listen_list_lock
, flags
);
1484 * i40iw_add_hte_node - add a cm node to the hash table
1485 * @cm_core: cm's core
1486 * @cm_node: connection's node
1488 static void i40iw_add_hte_node(struct i40iw_cm_core
*cm_core
,
1489 struct i40iw_cm_node
*cm_node
)
1491 struct list_head
*hte
;
1492 unsigned long flags
;
1494 if (!cm_node
|| !cm_core
) {
1495 i40iw_pr_err("cm_node or cm_core == NULL\n");
1498 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
1500 /* get a handle on the hash table element (list head for this slot) */
1501 hte
= &cm_core
->connected_nodes
;
1502 list_add_tail(&cm_node
->list
, hte
);
1503 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1507 * listen_port_in_use - determine if port is in use
1508 * @port: Listen port number
1510 static bool i40iw_listen_port_in_use(struct i40iw_cm_core
*cm_core
, u16 port
)
1512 struct i40iw_cm_listener
*listen_node
;
1513 unsigned long flags
;
1516 spin_lock_irqsave(&cm_core
->listen_list_lock
, flags
);
1517 list_for_each_entry(listen_node
, &cm_core
->listen_nodes
, list
) {
1518 if (listen_node
->loc_port
== port
) {
1523 spin_unlock_irqrestore(&cm_core
->listen_list_lock
, flags
);
1528 * i40iw_del_multiple_qhash - Remove qhash and child listens
1529 * @iwdev: iWarp device
1530 * @cm_info: CM info for parent listen node
1531 * @cm_parent_listen_node: The parent listen node
1533 static enum i40iw_status_code
i40iw_del_multiple_qhash(
1534 struct i40iw_device
*iwdev
,
1535 struct i40iw_cm_info
*cm_info
,
1536 struct i40iw_cm_listener
*cm_parent_listen_node
)
1538 struct i40iw_cm_listener
*child_listen_node
;
1539 enum i40iw_status_code ret
= I40IW_ERR_CONFIG
;
1540 struct list_head
*pos
, *tpos
;
1541 unsigned long flags
;
1543 spin_lock_irqsave(&iwdev
->cm_core
.listen_list_lock
, flags
);
1544 list_for_each_safe(pos
, tpos
, &cm_parent_listen_node
->child_listen_list
) {
1545 child_listen_node
= list_entry(pos
, struct i40iw_cm_listener
, child_listen_list
);
1546 if (child_listen_node
->ipv4
)
1547 i40iw_debug(&iwdev
->sc_dev
,
1549 "removing child listen for IP=%pI4, port=%d, vlan=%d\n",
1550 child_listen_node
->loc_addr
,
1551 child_listen_node
->loc_port
,
1552 child_listen_node
->vlan_id
);
1554 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_CM
,
1555 "removing child listen for IP=%pI6, port=%d, vlan=%d\n",
1556 child_listen_node
->loc_addr
,
1557 child_listen_node
->loc_port
,
1558 child_listen_node
->vlan_id
);
1560 memcpy(cm_info
->loc_addr
, child_listen_node
->loc_addr
,
1561 sizeof(cm_info
->loc_addr
));
1562 cm_info
->vlan_id
= child_listen_node
->vlan_id
;
1563 if (child_listen_node
->qhash_set
) {
1564 ret
= i40iw_manage_qhash(iwdev
, cm_info
,
1565 I40IW_QHASH_TYPE_TCP_SYN
,
1566 I40IW_QHASH_MANAGE_TYPE_DELETE
,
1568 child_listen_node
->qhash_set
= false;
1570 ret
= I40IW_SUCCESS
;
1572 i40iw_debug(&iwdev
->sc_dev
,
1574 "freed pointer = %p\n",
1576 kfree(child_listen_node
);
1577 cm_parent_listen_node
->cm_core
->stats_listen_nodes_destroyed
++;
1579 spin_unlock_irqrestore(&iwdev
->cm_core
.listen_list_lock
, flags
);
1585 * i40iw_netdev_vlan_ipv6 - Gets the netdev and mac
1586 * @addr: local IPv6 address
1587 * @vlan_id: vlan id for the given IPv6 address
1588 * @mac: mac address for the given IPv6 address
1590 * Returns the net_device of the IPv6 address and also sets the
1591 * vlan id and mac for that address.
1593 static struct net_device
*i40iw_netdev_vlan_ipv6(u32
*addr
, u16
*vlan_id
, u8
*mac
)
1595 struct net_device
*ip_dev
= NULL
;
1596 struct in6_addr laddr6
;
1598 if (!IS_ENABLED(CONFIG_IPV6
))
1600 i40iw_copy_ip_htonl(laddr6
.in6_u
.u6_addr32
, addr
);
1602 *vlan_id
= I40IW_NO_VLAN
;
1606 for_each_netdev_rcu(&init_net
, ip_dev
) {
1607 if (ipv6_chk_addr(&init_net
, &laddr6
, ip_dev
, 1)) {
1609 *vlan_id
= rdma_vlan_dev_vlan_id(ip_dev
);
1610 if (ip_dev
->dev_addr
&& mac
)
1611 ether_addr_copy(mac
, ip_dev
->dev_addr
);
1620 * i40iw_get_vlan_ipv4 - Returns the vlan_id for IPv4 address
1621 * @addr: local IPv4 address
1623 static u16
i40iw_get_vlan_ipv4(u32
*addr
)
1625 struct net_device
*netdev
;
1626 u16 vlan_id
= I40IW_NO_VLAN
;
1628 netdev
= ip_dev_find(&init_net
, htonl(addr
[0]));
1630 vlan_id
= rdma_vlan_dev_vlan_id(netdev
);
1637 * i40iw_add_mqh_6 - Adds multiple qhashes for IPv6
1638 * @iwdev: iWarp device
1639 * @cm_info: CM info for parent listen node
1640 * @cm_parent_listen_node: The parent listen node
1642 * Adds a qhash and a child listen node for every IPv6 address
1643 * on the adapter and adds the associated qhash filter
1645 static enum i40iw_status_code
i40iw_add_mqh_6(struct i40iw_device
*iwdev
,
1646 struct i40iw_cm_info
*cm_info
,
1647 struct i40iw_cm_listener
*cm_parent_listen_node
)
1649 struct net_device
*ip_dev
;
1650 struct inet6_dev
*idev
;
1651 struct inet6_ifaddr
*ifp
, *tmp
;
1652 enum i40iw_status_code ret
= 0;
1653 struct i40iw_cm_listener
*child_listen_node
;
1654 unsigned long flags
;
1657 for_each_netdev_rcu(&init_net
, ip_dev
) {
1658 if ((((rdma_vlan_dev_vlan_id(ip_dev
) < I40IW_NO_VLAN
) &&
1659 (rdma_vlan_dev_real_dev(ip_dev
) == iwdev
->netdev
)) ||
1660 (ip_dev
== iwdev
->netdev
)) && (ip_dev
->flags
& IFF_UP
)) {
1661 idev
= __in6_dev_get(ip_dev
);
1663 i40iw_pr_err("idev == NULL\n");
1666 list_for_each_entry_safe(ifp
, tmp
, &idev
->addr_list
, if_list
) {
1667 i40iw_debug(&iwdev
->sc_dev
,
1669 "IP=%pI6, vlan_id=%d, MAC=%pM\n",
1671 rdma_vlan_dev_vlan_id(ip_dev
),
1674 kzalloc(sizeof(*child_listen_node
), GFP_ATOMIC
);
1675 i40iw_debug(&iwdev
->sc_dev
,
1677 "Allocating child listener %p\n",
1679 if (!child_listen_node
) {
1680 ret
= I40IW_ERR_NO_MEMORY
;
1683 cm_info
->vlan_id
= rdma_vlan_dev_vlan_id(ip_dev
);
1684 cm_parent_listen_node
->vlan_id
= cm_info
->vlan_id
;
1686 memcpy(child_listen_node
, cm_parent_listen_node
,
1687 sizeof(*child_listen_node
));
1689 i40iw_copy_ip_ntohl(child_listen_node
->loc_addr
,
1690 ifp
->addr
.in6_u
.u6_addr32
);
1691 memcpy(cm_info
->loc_addr
, child_listen_node
->loc_addr
,
1692 sizeof(cm_info
->loc_addr
));
1694 ret
= i40iw_manage_qhash(iwdev
, cm_info
,
1695 I40IW_QHASH_TYPE_TCP_SYN
,
1696 I40IW_QHASH_MANAGE_TYPE_ADD
,
1699 child_listen_node
->qhash_set
= true;
1700 spin_lock_irqsave(&iwdev
->cm_core
.listen_list_lock
, flags
);
1701 list_add(&child_listen_node
->child_listen_list
,
1702 &cm_parent_listen_node
->child_listen_list
);
1703 spin_unlock_irqrestore(&iwdev
->cm_core
.listen_list_lock
, flags
);
1704 cm_parent_listen_node
->cm_core
->stats_listen_nodes_created
++;
1706 kfree(child_listen_node
);
1717 * i40iw_add_mqh_4 - Adds multiple qhashes for IPv4
1718 * @iwdev: iWarp device
1719 * @cm_info: CM info for parent listen node
1720 * @cm_parent_listen_node: The parent listen node
1722 * Adds a qhash and a child listen node for every IPv4 address
1723 * on the adapter and adds the associated qhash filter
1725 static enum i40iw_status_code
i40iw_add_mqh_4(
1726 struct i40iw_device
*iwdev
,
1727 struct i40iw_cm_info
*cm_info
,
1728 struct i40iw_cm_listener
*cm_parent_listen_node
)
1730 struct net_device
*dev
;
1731 struct in_device
*idev
;
1732 struct i40iw_cm_listener
*child_listen_node
;
1733 enum i40iw_status_code ret
= 0;
1734 unsigned long flags
;
1737 for_each_netdev(&init_net
, dev
) {
1738 if ((((rdma_vlan_dev_vlan_id(dev
) < I40IW_NO_VLAN
) &&
1739 (rdma_vlan_dev_real_dev(dev
) == iwdev
->netdev
)) ||
1740 (dev
== iwdev
->netdev
)) && (dev
->flags
& IFF_UP
)) {
1741 idev
= in_dev_get(dev
);
1743 i40iw_debug(&iwdev
->sc_dev
,
1745 "Allocating child CM Listener forIP=%pI4, vlan_id=%d, MAC=%pM\n",
1747 rdma_vlan_dev_vlan_id(dev
),
1749 child_listen_node
= kzalloc(sizeof(*child_listen_node
), GFP_ATOMIC
);
1750 cm_parent_listen_node
->cm_core
->stats_listen_nodes_created
++;
1751 i40iw_debug(&iwdev
->sc_dev
,
1753 "Allocating child listener %p\n",
1755 if (!child_listen_node
) {
1757 ret
= I40IW_ERR_NO_MEMORY
;
1760 cm_info
->vlan_id
= rdma_vlan_dev_vlan_id(dev
);
1761 cm_parent_listen_node
->vlan_id
= cm_info
->vlan_id
;
1762 memcpy(child_listen_node
,
1763 cm_parent_listen_node
,
1764 sizeof(*child_listen_node
));
1766 child_listen_node
->loc_addr
[0] = ntohl(ifa
->ifa_address
);
1767 memcpy(cm_info
->loc_addr
, child_listen_node
->loc_addr
,
1768 sizeof(cm_info
->loc_addr
));
1770 ret
= i40iw_manage_qhash(iwdev
,
1772 I40IW_QHASH_TYPE_TCP_SYN
,
1773 I40IW_QHASH_MANAGE_TYPE_ADD
,
1777 child_listen_node
->qhash_set
= true;
1778 spin_lock_irqsave(&iwdev
->cm_core
.listen_list_lock
, flags
);
1779 list_add(&child_listen_node
->child_listen_list
,
1780 &cm_parent_listen_node
->child_listen_list
);
1781 spin_unlock_irqrestore(&iwdev
->cm_core
.listen_list_lock
, flags
);
1783 kfree(child_listen_node
);
1784 cm_parent_listen_node
->cm_core
->stats_listen_nodes_created
--;
1797 * i40iw_dec_refcnt_listen - delete listener and associated cm nodes
1798 * @cm_core: cm's core
1799 * @free_hanging_nodes: to free associated cm_nodes
1800 * @apbvt_del: flag to delete the apbvt
1802 static int i40iw_dec_refcnt_listen(struct i40iw_cm_core
*cm_core
,
1803 struct i40iw_cm_listener
*listener
,
1804 int free_hanging_nodes
, bool apbvt_del
)
1808 struct list_head
*list_pos
;
1809 struct list_head
*list_temp
;
1810 struct i40iw_cm_node
*cm_node
;
1811 struct list_head reset_list
;
1812 struct i40iw_cm_info nfo
;
1813 struct i40iw_cm_node
*loopback
;
1814 enum i40iw_cm_node_state old_state
;
1815 unsigned long flags
;
1817 /* free non-accelerated child nodes for this listener */
1818 INIT_LIST_HEAD(&reset_list
);
1819 if (free_hanging_nodes
) {
1820 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
1821 list_for_each_safe(list_pos
, list_temp
, &cm_core
->connected_nodes
) {
1822 cm_node
= container_of(list_pos
, struct i40iw_cm_node
, list
);
1823 if ((cm_node
->listener
== listener
) && !cm_node
->accelerated
) {
1824 atomic_inc(&cm_node
->ref_count
);
1825 list_add(&cm_node
->reset_entry
, &reset_list
);
1828 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
1831 list_for_each_safe(list_pos
, list_temp
, &reset_list
) {
1832 cm_node
= container_of(list_pos
, struct i40iw_cm_node
, reset_entry
);
1833 loopback
= cm_node
->loopbackpartner
;
1834 if (cm_node
->state
>= I40IW_CM_STATE_FIN_WAIT1
) {
1835 i40iw_rem_ref_cm_node(cm_node
);
1838 i40iw_cleanup_retrans_entry(cm_node
);
1839 err
= i40iw_send_reset(cm_node
);
1841 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
1842 i40iw_pr_err("send reset\n");
1844 old_state
= cm_node
->state
;
1845 cm_node
->state
= I40IW_CM_STATE_LISTENER_DESTROYED
;
1846 if (old_state
!= I40IW_CM_STATE_MPAREQ_RCVD
)
1847 i40iw_rem_ref_cm_node(cm_node
);
1850 struct i40iw_cm_event event
;
1852 event
.cm_node
= loopback
;
1853 memcpy(event
.cm_info
.rem_addr
,
1854 loopback
->rem_addr
, sizeof(event
.cm_info
.rem_addr
));
1855 memcpy(event
.cm_info
.loc_addr
,
1856 loopback
->loc_addr
, sizeof(event
.cm_info
.loc_addr
));
1857 event
.cm_info
.rem_port
= loopback
->rem_port
;
1858 event
.cm_info
.loc_port
= loopback
->loc_port
;
1859 event
.cm_info
.cm_id
= loopback
->cm_id
;
1860 event
.cm_info
.ipv4
= loopback
->ipv4
;
1861 atomic_inc(&loopback
->ref_count
);
1862 loopback
->state
= I40IW_CM_STATE_CLOSED
;
1863 i40iw_event_connect_error(&event
);
1864 cm_node
->state
= I40IW_CM_STATE_LISTENER_DESTROYED
;
1865 i40iw_rem_ref_cm_node(cm_node
);
1870 if (!atomic_dec_return(&listener
->ref_count
)) {
1871 spin_lock_irqsave(&cm_core
->listen_list_lock
, flags
);
1872 list_del(&listener
->list
);
1873 spin_unlock_irqrestore(&cm_core
->listen_list_lock
, flags
);
1875 if (listener
->iwdev
) {
1876 if (apbvt_del
&& !i40iw_listen_port_in_use(cm_core
, listener
->loc_port
))
1877 i40iw_manage_apbvt(listener
->iwdev
,
1879 I40IW_MANAGE_APBVT_DEL
);
1881 memcpy(nfo
.loc_addr
, listener
->loc_addr
, sizeof(nfo
.loc_addr
));
1882 nfo
.loc_port
= listener
->loc_port
;
1883 nfo
.ipv4
= listener
->ipv4
;
1884 nfo
.vlan_id
= listener
->vlan_id
;
1885 nfo
.user_pri
= listener
->user_pri
;
1887 if (!list_empty(&listener
->child_listen_list
)) {
1888 i40iw_del_multiple_qhash(listener
->iwdev
, &nfo
, listener
);
1890 if (listener
->qhash_set
)
1891 i40iw_manage_qhash(listener
->iwdev
,
1893 I40IW_QHASH_TYPE_TCP_SYN
,
1894 I40IW_QHASH_MANAGE_TYPE_DELETE
,
1900 cm_core
->stats_listen_destroyed
++;
1902 cm_core
->stats_listen_nodes_destroyed
++;
1908 if (atomic_read(&listener
->pend_accepts_cnt
) > 0)
1909 i40iw_debug(cm_core
->dev
,
1911 "%s: listener (%p) pending accepts=%u\n",
1914 atomic_read(&listener
->pend_accepts_cnt
));
1921 * i40iw_cm_del_listen - delete a linstener
1922 * @cm_core: cm's core
1923 * @listener: passive connection's listener
1924 * @apbvt_del: flag to delete apbvt
1926 static int i40iw_cm_del_listen(struct i40iw_cm_core
*cm_core
,
1927 struct i40iw_cm_listener
*listener
,
1930 listener
->listener_state
= I40IW_CM_LISTENER_PASSIVE_STATE
;
1931 listener
->cm_id
= NULL
; /* going to be destroyed pretty soon */
1932 return i40iw_dec_refcnt_listen(cm_core
, listener
, 1, apbvt_del
);
1936 * i40iw_addr_resolve_neigh - resolve neighbor address
1937 * @iwdev: iwarp device structure
1938 * @src_ip: local ip address
1939 * @dst_ip: remote ip address
1940 * @arpindex: if there is an arp entry
1942 static int i40iw_addr_resolve_neigh(struct i40iw_device
*iwdev
,
1948 struct neighbour
*neigh
;
1950 struct net_device
*netdev
= iwdev
->netdev
;
1951 __be32 dst_ipaddr
= htonl(dst_ip
);
1952 __be32 src_ipaddr
= htonl(src_ip
);
1954 rt
= ip_route_output(&init_net
, dst_ipaddr
, src_ipaddr
, 0, 0);
1956 i40iw_pr_err("ip_route_output\n");
1960 if (netif_is_bond_slave(netdev
))
1961 netdev
= netdev_master_upper_dev_get(netdev
);
1963 neigh
= dst_neigh_lookup(&rt
->dst
, &dst_ipaddr
);
1967 if (neigh
->nud_state
& NUD_VALID
) {
1968 if (arpindex
>= 0) {
1969 if (ether_addr_equal(iwdev
->arp_table
[arpindex
].mac_addr
,
1971 /* Mac address same as arp table */
1972 goto resolve_neigh_exit
;
1973 i40iw_manage_arp_cache(iwdev
,
1974 iwdev
->arp_table
[arpindex
].mac_addr
,
1980 i40iw_manage_arp_cache(iwdev
, neigh
->ha
, &dst_ip
, true, I40IW_ARP_ADD
);
1981 rc
= i40iw_arp_table(iwdev
, &dst_ip
, true, NULL
, I40IW_ARP_RESOLVE
);
1983 neigh_event_send(neigh
, NULL
);
1990 neigh_release(neigh
);
1997 * i40iw_get_dst_ipv6
1999 static struct dst_entry
*i40iw_get_dst_ipv6(struct sockaddr_in6
*src_addr
,
2000 struct sockaddr_in6
*dst_addr
)
2002 struct dst_entry
*dst
;
2005 memset(&fl6
, 0, sizeof(fl6
));
2006 fl6
.daddr
= dst_addr
->sin6_addr
;
2007 fl6
.saddr
= src_addr
->sin6_addr
;
2008 if (ipv6_addr_type(&fl6
.daddr
) & IPV6_ADDR_LINKLOCAL
)
2009 fl6
.flowi6_oif
= dst_addr
->sin6_scope_id
;
2011 dst
= ip6_route_output(&init_net
, NULL
, &fl6
);
2016 * i40iw_addr_resolve_neigh_ipv6 - resolve neighbor ipv6 address
2017 * @iwdev: iwarp device structure
2018 * @dst_ip: remote ip address
2019 * @arpindex: if there is an arp entry
2021 static int i40iw_addr_resolve_neigh_ipv6(struct i40iw_device
*iwdev
,
2026 struct neighbour
*neigh
;
2028 struct net_device
*netdev
= iwdev
->netdev
;
2029 struct dst_entry
*dst
;
2030 struct sockaddr_in6 dst_addr
;
2031 struct sockaddr_in6 src_addr
;
2033 memset(&dst_addr
, 0, sizeof(dst_addr
));
2034 dst_addr
.sin6_family
= AF_INET6
;
2035 i40iw_copy_ip_htonl(dst_addr
.sin6_addr
.in6_u
.u6_addr32
, dest
);
2036 memset(&src_addr
, 0, sizeof(src_addr
));
2037 src_addr
.sin6_family
= AF_INET6
;
2038 i40iw_copy_ip_htonl(src_addr
.sin6_addr
.in6_u
.u6_addr32
, src
);
2039 dst
= i40iw_get_dst_ipv6(&src_addr
, &dst_addr
);
2040 if (!dst
|| dst
->error
) {
2043 i40iw_pr_err("ip6_route_output returned dst->error = %d\n",
2049 if (netif_is_bond_slave(netdev
))
2050 netdev
= netdev_master_upper_dev_get(netdev
);
2052 neigh
= dst_neigh_lookup(dst
, &dst_addr
);
2056 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_CM
, "dst_neigh_lookup MAC=%pM\n", neigh
->ha
);
2057 if (neigh
->nud_state
& NUD_VALID
) {
2058 if (arpindex
>= 0) {
2059 if (ether_addr_equal
2060 (iwdev
->arp_table
[arpindex
].mac_addr
,
2062 /* Mac address same as in arp table */
2063 goto resolve_neigh_exit6
;
2065 i40iw_manage_arp_cache(iwdev
,
2066 iwdev
->arp_table
[arpindex
].mac_addr
,
2071 i40iw_manage_arp_cache(iwdev
,
2076 rc
= i40iw_arp_table(iwdev
,
2082 neigh_event_send(neigh
, NULL
);
2086 resolve_neigh_exit6
:
2089 neigh_release(neigh
);
2095 * i40iw_ipv4_is_loopback - check if loopback
2096 * @loc_addr: local addr to compare
2097 * @rem_addr: remote address
2099 static bool i40iw_ipv4_is_loopback(u32 loc_addr
, u32 rem_addr
)
2101 return ipv4_is_loopback(htonl(rem_addr
)) || (loc_addr
== rem_addr
);
2105 * i40iw_ipv6_is_loopback - check if loopback
2106 * @loc_addr: local addr to compare
2107 * @rem_addr: remote address
2109 static bool i40iw_ipv6_is_loopback(u32
*loc_addr
, u32
*rem_addr
)
2111 struct in6_addr raddr6
;
2113 i40iw_copy_ip_htonl(raddr6
.in6_u
.u6_addr32
, rem_addr
);
2114 return !memcmp(loc_addr
, rem_addr
, 16) || ipv6_addr_loopback(&raddr6
);
2118 * i40iw_make_cm_node - create a new instance of a cm node
2119 * @cm_core: cm's core
2120 * @iwdev: iwarp device structure
2121 * @cm_info: quad info for connection
2122 * @listener: passive connection's listener
2124 static struct i40iw_cm_node
*i40iw_make_cm_node(
2125 struct i40iw_cm_core
*cm_core
,
2126 struct i40iw_device
*iwdev
,
2127 struct i40iw_cm_info
*cm_info
,
2128 struct i40iw_cm_listener
*listener
)
2130 struct i40iw_cm_node
*cm_node
;
2134 struct net_device
*netdev
= iwdev
->netdev
;
2136 /* create an hte and cm_node for this instance */
2137 cm_node
= kzalloc(sizeof(*cm_node
), GFP_ATOMIC
);
2141 /* set our node specific transport info */
2142 cm_node
->ipv4
= cm_info
->ipv4
;
2143 cm_node
->vlan_id
= cm_info
->vlan_id
;
2144 if ((cm_node
->vlan_id
== I40IW_NO_VLAN
) && iwdev
->dcb
)
2145 cm_node
->vlan_id
= 0;
2146 cm_node
->tos
= cm_info
->tos
;
2147 cm_node
->user_pri
= cm_info
->user_pri
;
2149 if (listener
->tos
!= cm_info
->tos
)
2150 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_DCB
,
2151 "application TOS[%d] and remote client TOS[%d] mismatch\n",
2152 listener
->tos
, cm_info
->tos
);
2153 cm_node
->tos
= max(listener
->tos
, cm_info
->tos
);
2154 cm_node
->user_pri
= rt_tos2priority(cm_node
->tos
);
2155 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_DCB
, "listener: TOS:[%d] UP:[%d]\n",
2156 cm_node
->tos
, cm_node
->user_pri
);
2158 memcpy(cm_node
->loc_addr
, cm_info
->loc_addr
, sizeof(cm_node
->loc_addr
));
2159 memcpy(cm_node
->rem_addr
, cm_info
->rem_addr
, sizeof(cm_node
->rem_addr
));
2160 cm_node
->loc_port
= cm_info
->loc_port
;
2161 cm_node
->rem_port
= cm_info
->rem_port
;
2163 cm_node
->mpa_frame_rev
= iwdev
->mpa_version
;
2164 cm_node
->send_rdma0_op
= SEND_RDMA_READ_ZERO
;
2165 cm_node
->ird_size
= I40IW_MAX_IRD_SIZE
;
2166 cm_node
->ord_size
= I40IW_MAX_ORD_SIZE
;
2168 cm_node
->listener
= listener
;
2169 cm_node
->cm_id
= cm_info
->cm_id
;
2170 ether_addr_copy(cm_node
->loc_mac
, netdev
->dev_addr
);
2171 spin_lock_init(&cm_node
->retrans_list_lock
);
2173 atomic_set(&cm_node
->ref_count
, 1);
2174 /* associate our parent CM core */
2175 cm_node
->cm_core
= cm_core
;
2176 cm_node
->tcp_cntxt
.loc_id
= I40IW_CM_DEF_LOCAL_ID
;
2177 cm_node
->tcp_cntxt
.rcv_wscale
= I40IW_CM_DEFAULT_RCV_WND_SCALE
;
2178 cm_node
->tcp_cntxt
.rcv_wnd
=
2179 I40IW_CM_DEFAULT_RCV_WND_SCALED
>> I40IW_CM_DEFAULT_RCV_WND_SCALE
;
2180 ts
= current_kernel_time();
2181 cm_node
->tcp_cntxt
.loc_seq_num
= ts
.tv_nsec
;
2182 cm_node
->tcp_cntxt
.mss
= iwdev
->vsi
.mss
;
2184 cm_node
->iwdev
= iwdev
;
2185 cm_node
->dev
= &iwdev
->sc_dev
;
2187 if ((cm_node
->ipv4
&&
2188 i40iw_ipv4_is_loopback(cm_node
->loc_addr
[0], cm_node
->rem_addr
[0])) ||
2189 (!cm_node
->ipv4
&& i40iw_ipv6_is_loopback(cm_node
->loc_addr
,
2190 cm_node
->rem_addr
))) {
2191 arpindex
= i40iw_arp_table(iwdev
,
2197 oldarpindex
= i40iw_arp_table(iwdev
,
2203 arpindex
= i40iw_addr_resolve_neigh(iwdev
,
2204 cm_info
->loc_addr
[0],
2205 cm_info
->rem_addr
[0],
2207 else if (IS_ENABLED(CONFIG_IPV6
))
2208 arpindex
= i40iw_addr_resolve_neigh_ipv6(iwdev
,
2216 i40iw_pr_err("cm_node arpindex\n");
2220 ether_addr_copy(cm_node
->rem_mac
, iwdev
->arp_table
[arpindex
].mac_addr
);
2221 i40iw_add_hte_node(cm_core
, cm_node
);
2222 cm_core
->stats_nodes_created
++;
2227 * i40iw_rem_ref_cm_node - destroy an instance of a cm node
2228 * @cm_node: connection's node
2230 static void i40iw_rem_ref_cm_node(struct i40iw_cm_node
*cm_node
)
2232 struct i40iw_cm_core
*cm_core
= cm_node
->cm_core
;
2233 struct i40iw_qp
*iwqp
;
2234 struct i40iw_cm_info nfo
;
2235 unsigned long flags
;
2237 spin_lock_irqsave(&cm_node
->cm_core
->ht_lock
, flags
);
2238 if (atomic_dec_return(&cm_node
->ref_count
)) {
2239 spin_unlock_irqrestore(&cm_node
->cm_core
->ht_lock
, flags
);
2242 list_del(&cm_node
->list
);
2243 spin_unlock_irqrestore(&cm_node
->cm_core
->ht_lock
, flags
);
2245 /* if the node is destroyed before connection was accelerated */
2246 if (!cm_node
->accelerated
&& cm_node
->accept_pend
) {
2247 pr_err("node destroyed before established\n");
2248 atomic_dec(&cm_node
->listener
->pend_accepts_cnt
);
2250 if (cm_node
->close_entry
)
2251 i40iw_handle_close_entry(cm_node
, 0);
2252 if (cm_node
->listener
) {
2253 i40iw_dec_refcnt_listen(cm_core
, cm_node
->listener
, 0, true);
2255 if (!i40iw_listen_port_in_use(cm_core
, cm_node
->loc_port
) &&
2256 cm_node
->apbvt_set
) {
2257 i40iw_manage_apbvt(cm_node
->iwdev
,
2259 I40IW_MANAGE_APBVT_DEL
);
2260 i40iw_get_addr_info(cm_node
, &nfo
);
2261 if (cm_node
->qhash_set
) {
2262 i40iw_manage_qhash(cm_node
->iwdev
,
2264 I40IW_QHASH_TYPE_TCP_ESTABLISHED
,
2265 I40IW_QHASH_MANAGE_TYPE_DELETE
,
2268 cm_node
->qhash_set
= 0;
2273 iwqp
= cm_node
->iwqp
;
2275 iwqp
->cm_node
= NULL
;
2276 i40iw_rem_ref(&iwqp
->ibqp
);
2277 cm_node
->iwqp
= NULL
;
2278 } else if (cm_node
->qhash_set
) {
2279 i40iw_get_addr_info(cm_node
, &nfo
);
2280 i40iw_manage_qhash(cm_node
->iwdev
,
2282 I40IW_QHASH_TYPE_TCP_ESTABLISHED
,
2283 I40IW_QHASH_MANAGE_TYPE_DELETE
,
2286 cm_node
->qhash_set
= 0;
2289 cm_node
->cm_core
->stats_nodes_destroyed
++;
2294 * i40iw_handle_fin_pkt - FIN packet received
2295 * @cm_node: connection's node
2297 static void i40iw_handle_fin_pkt(struct i40iw_cm_node
*cm_node
)
2301 switch (cm_node
->state
) {
2302 case I40IW_CM_STATE_SYN_RCVD
:
2303 case I40IW_CM_STATE_SYN_SENT
:
2304 case I40IW_CM_STATE_ESTABLISHED
:
2305 case I40IW_CM_STATE_MPAREJ_RCVD
:
2306 cm_node
->tcp_cntxt
.rcv_nxt
++;
2307 i40iw_cleanup_retrans_entry(cm_node
);
2308 cm_node
->state
= I40IW_CM_STATE_LAST_ACK
;
2309 i40iw_send_fin(cm_node
);
2311 case I40IW_CM_STATE_MPAREQ_SENT
:
2312 i40iw_create_event(cm_node
, I40IW_CM_EVENT_ABORTED
);
2313 cm_node
->tcp_cntxt
.rcv_nxt
++;
2314 i40iw_cleanup_retrans_entry(cm_node
);
2315 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2316 atomic_inc(&cm_node
->ref_count
);
2317 i40iw_send_reset(cm_node
);
2319 case I40IW_CM_STATE_FIN_WAIT1
:
2320 cm_node
->tcp_cntxt
.rcv_nxt
++;
2321 i40iw_cleanup_retrans_entry(cm_node
);
2322 cm_node
->state
= I40IW_CM_STATE_CLOSING
;
2323 i40iw_send_ack(cm_node
);
2325 * Wait for ACK as this is simultaneous close.
2326 * After we receive ACK, do not send anything.
2330 case I40IW_CM_STATE_FIN_WAIT2
:
2331 cm_node
->tcp_cntxt
.rcv_nxt
++;
2332 i40iw_cleanup_retrans_entry(cm_node
);
2333 cm_node
->state
= I40IW_CM_STATE_TIME_WAIT
;
2334 i40iw_send_ack(cm_node
);
2336 i40iw_schedule_cm_timer(cm_node
, NULL
, I40IW_TIMER_TYPE_CLOSE
, 1, 0);
2338 i40iw_pr_err("node %p state = %d\n", cm_node
, cm_node
->state
);
2340 case I40IW_CM_STATE_TIME_WAIT
:
2341 cm_node
->tcp_cntxt
.rcv_nxt
++;
2342 i40iw_cleanup_retrans_entry(cm_node
);
2343 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2344 i40iw_rem_ref_cm_node(cm_node
);
2346 case I40IW_CM_STATE_OFFLOADED
:
2348 i40iw_pr_err("bad state node %p state = %d\n", cm_node
, cm_node
->state
);
2354 * i40iw_handle_rst_pkt - process received RST packet
2355 * @cm_node: connection's node
2356 * @rbuf: receive buffer
2358 static void i40iw_handle_rst_pkt(struct i40iw_cm_node
*cm_node
,
2359 struct i40iw_puda_buf
*rbuf
)
2361 i40iw_cleanup_retrans_entry(cm_node
);
2362 switch (cm_node
->state
) {
2363 case I40IW_CM_STATE_SYN_SENT
:
2364 case I40IW_CM_STATE_MPAREQ_SENT
:
2365 switch (cm_node
->mpa_frame_rev
) {
2367 cm_node
->mpa_frame_rev
= IETF_MPA_V1
;
2368 /* send a syn and goto syn sent state */
2369 cm_node
->state
= I40IW_CM_STATE_SYN_SENT
;
2370 if (i40iw_send_syn(cm_node
, 0))
2371 i40iw_active_open_err(cm_node
, false);
2375 i40iw_active_open_err(cm_node
, false);
2379 case I40IW_CM_STATE_MPAREQ_RCVD
:
2380 atomic_add_return(1, &cm_node
->passive_state
);
2382 case I40IW_CM_STATE_ESTABLISHED
:
2383 case I40IW_CM_STATE_SYN_RCVD
:
2384 case I40IW_CM_STATE_LISTENING
:
2385 i40iw_pr_err("Bad state state = %d\n", cm_node
->state
);
2386 i40iw_passive_open_err(cm_node
, false);
2388 case I40IW_CM_STATE_OFFLOADED
:
2389 i40iw_active_open_err(cm_node
, false);
2391 case I40IW_CM_STATE_CLOSED
:
2393 case I40IW_CM_STATE_FIN_WAIT2
:
2394 case I40IW_CM_STATE_FIN_WAIT1
:
2395 case I40IW_CM_STATE_LAST_ACK
:
2396 cm_node
->cm_id
->rem_ref(cm_node
->cm_id
);
2397 case I40IW_CM_STATE_TIME_WAIT
:
2398 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2399 i40iw_rem_ref_cm_node(cm_node
);
2407 * i40iw_handle_rcv_mpa - Process a recv'd mpa buffer
2408 * @cm_node: connection's node
2409 * @rbuf: receive buffer
2411 static void i40iw_handle_rcv_mpa(struct i40iw_cm_node
*cm_node
,
2412 struct i40iw_puda_buf
*rbuf
)
2415 int datasize
= rbuf
->datalen
;
2416 u8
*dataloc
= rbuf
->data
;
2418 enum i40iw_cm_event_type type
= I40IW_CM_EVENT_UNKNOWN
;
2421 ret
= i40iw_parse_mpa(cm_node
, dataloc
, &res_type
, datasize
);
2423 if (cm_node
->state
== I40IW_CM_STATE_MPAREQ_SENT
)
2424 i40iw_active_open_err(cm_node
, true);
2426 i40iw_passive_open_err(cm_node
, true);
2430 switch (cm_node
->state
) {
2431 case I40IW_CM_STATE_ESTABLISHED
:
2432 if (res_type
== I40IW_MPA_REQUEST_REJECT
)
2433 i40iw_pr_err("state for reject\n");
2434 cm_node
->state
= I40IW_CM_STATE_MPAREQ_RCVD
;
2435 type
= I40IW_CM_EVENT_MPA_REQ
;
2436 i40iw_send_ack(cm_node
); /* ACK received MPA request */
2437 atomic_set(&cm_node
->passive_state
,
2438 I40IW_PASSIVE_STATE_INDICATED
);
2440 case I40IW_CM_STATE_MPAREQ_SENT
:
2441 i40iw_cleanup_retrans_entry(cm_node
);
2442 if (res_type
== I40IW_MPA_REQUEST_REJECT
) {
2443 type
= I40IW_CM_EVENT_MPA_REJECT
;
2444 cm_node
->state
= I40IW_CM_STATE_MPAREJ_RCVD
;
2446 type
= I40IW_CM_EVENT_CONNECTED
;
2447 cm_node
->state
= I40IW_CM_STATE_OFFLOADED
;
2449 i40iw_send_ack(cm_node
);
2452 pr_err("%s wrong cm_node state =%d\n", __func__
, cm_node
->state
);
2455 i40iw_create_event(cm_node
, type
);
2459 * i40iw_indicate_pkt_err - Send up err event to cm
2460 * @cm_node: connection's node
2462 static void i40iw_indicate_pkt_err(struct i40iw_cm_node
*cm_node
)
2464 switch (cm_node
->state
) {
2465 case I40IW_CM_STATE_SYN_SENT
:
2466 case I40IW_CM_STATE_MPAREQ_SENT
:
2467 i40iw_active_open_err(cm_node
, true);
2469 case I40IW_CM_STATE_ESTABLISHED
:
2470 case I40IW_CM_STATE_SYN_RCVD
:
2471 i40iw_passive_open_err(cm_node
, true);
2473 case I40IW_CM_STATE_OFFLOADED
:
2480 * i40iw_check_syn - Check for error on received syn ack
2481 * @cm_node: connection's node
2482 * @tcph: pointer tcp header
2484 static int i40iw_check_syn(struct i40iw_cm_node
*cm_node
, struct tcphdr
*tcph
)
2488 if (ntohl(tcph
->ack_seq
) != cm_node
->tcp_cntxt
.loc_seq_num
) {
2490 i40iw_active_open_err(cm_node
, true);
2496 * i40iw_check_seq - check seq numbers if OK
2497 * @cm_node: connection's node
2498 * @tcph: pointer tcp header
2500 static int i40iw_check_seq(struct i40iw_cm_node
*cm_node
, struct tcphdr
*tcph
)
2505 u32 loc_seq_num
= cm_node
->tcp_cntxt
.loc_seq_num
;
2506 u32 rcv_nxt
= cm_node
->tcp_cntxt
.rcv_nxt
;
2509 seq
= ntohl(tcph
->seq
);
2510 ack_seq
= ntohl(tcph
->ack_seq
);
2511 rcv_wnd
= cm_node
->tcp_cntxt
.rcv_wnd
;
2512 if (ack_seq
!= loc_seq_num
)
2514 else if (!between(seq
, rcv_nxt
, (rcv_nxt
+ rcv_wnd
)))
2517 i40iw_pr_err("seq number\n");
2518 i40iw_indicate_pkt_err(cm_node
);
2524 * i40iw_handle_syn_pkt - is for Passive node
2525 * @cm_node: connection's node
2526 * @rbuf: receive buffer
2528 static void i40iw_handle_syn_pkt(struct i40iw_cm_node
*cm_node
,
2529 struct i40iw_puda_buf
*rbuf
)
2531 struct tcphdr
*tcph
= (struct tcphdr
*)rbuf
->tcph
;
2535 struct i40iw_cm_info nfo
;
2537 optionsize
= (tcph
->doff
<< 2) - sizeof(struct tcphdr
);
2538 inc_sequence
= ntohl(tcph
->seq
);
2540 switch (cm_node
->state
) {
2541 case I40IW_CM_STATE_SYN_SENT
:
2542 case I40IW_CM_STATE_MPAREQ_SENT
:
2543 /* Rcvd syn on active open connection */
2544 i40iw_active_open_err(cm_node
, 1);
2546 case I40IW_CM_STATE_LISTENING
:
2548 if (atomic_read(&cm_node
->listener
->pend_accepts_cnt
) >
2549 cm_node
->listener
->backlog
) {
2550 cm_node
->cm_core
->stats_backlog_drops
++;
2551 i40iw_passive_open_err(cm_node
, false);
2554 ret
= i40iw_handle_tcp_options(cm_node
, tcph
, optionsize
, 1);
2556 i40iw_passive_open_err(cm_node
, false);
2560 cm_node
->tcp_cntxt
.rcv_nxt
= inc_sequence
+ 1;
2561 cm_node
->accept_pend
= 1;
2562 atomic_inc(&cm_node
->listener
->pend_accepts_cnt
);
2564 cm_node
->state
= I40IW_CM_STATE_SYN_RCVD
;
2565 i40iw_get_addr_info(cm_node
, &nfo
);
2566 ret
= i40iw_manage_qhash(cm_node
->iwdev
,
2568 I40IW_QHASH_TYPE_TCP_ESTABLISHED
,
2569 I40IW_QHASH_MANAGE_TYPE_ADD
,
2572 cm_node
->qhash_set
= true;
2574 case I40IW_CM_STATE_CLOSED
:
2575 i40iw_cleanup_retrans_entry(cm_node
);
2576 atomic_inc(&cm_node
->ref_count
);
2577 i40iw_send_reset(cm_node
);
2579 case I40IW_CM_STATE_OFFLOADED
:
2580 case I40IW_CM_STATE_ESTABLISHED
:
2581 case I40IW_CM_STATE_FIN_WAIT1
:
2582 case I40IW_CM_STATE_FIN_WAIT2
:
2583 case I40IW_CM_STATE_MPAREQ_RCVD
:
2584 case I40IW_CM_STATE_LAST_ACK
:
2585 case I40IW_CM_STATE_CLOSING
:
2586 case I40IW_CM_STATE_UNKNOWN
:
2593 * i40iw_handle_synack_pkt - Process SYN+ACK packet (active side)
2594 * @cm_node: connection's node
2595 * @rbuf: receive buffer
2597 static void i40iw_handle_synack_pkt(struct i40iw_cm_node
*cm_node
,
2598 struct i40iw_puda_buf
*rbuf
)
2600 struct tcphdr
*tcph
= (struct tcphdr
*)rbuf
->tcph
;
2605 optionsize
= (tcph
->doff
<< 2) - sizeof(struct tcphdr
);
2606 inc_sequence
= ntohl(tcph
->seq
);
2607 switch (cm_node
->state
) {
2608 case I40IW_CM_STATE_SYN_SENT
:
2609 i40iw_cleanup_retrans_entry(cm_node
);
2611 if (i40iw_check_syn(cm_node
, tcph
)) {
2612 i40iw_pr_err("check syn fail\n");
2615 cm_node
->tcp_cntxt
.rem_ack_num
= ntohl(tcph
->ack_seq
);
2617 ret
= i40iw_handle_tcp_options(cm_node
, tcph
, optionsize
, 0);
2619 i40iw_debug(cm_node
->dev
,
2621 "cm_node=%p tcp_options failed\n",
2625 i40iw_cleanup_retrans_entry(cm_node
);
2626 cm_node
->tcp_cntxt
.rcv_nxt
= inc_sequence
+ 1;
2627 i40iw_send_ack(cm_node
); /* ACK for the syn_ack */
2628 ret
= i40iw_send_mpa_request(cm_node
);
2630 i40iw_debug(cm_node
->dev
,
2632 "cm_node=%p i40iw_send_mpa_request failed\n",
2636 cm_node
->state
= I40IW_CM_STATE_MPAREQ_SENT
;
2638 case I40IW_CM_STATE_MPAREQ_RCVD
:
2639 i40iw_passive_open_err(cm_node
, true);
2641 case I40IW_CM_STATE_LISTENING
:
2642 cm_node
->tcp_cntxt
.loc_seq_num
= ntohl(tcph
->ack_seq
);
2643 i40iw_cleanup_retrans_entry(cm_node
);
2644 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2645 i40iw_send_reset(cm_node
);
2647 case I40IW_CM_STATE_CLOSED
:
2648 cm_node
->tcp_cntxt
.loc_seq_num
= ntohl(tcph
->ack_seq
);
2649 i40iw_cleanup_retrans_entry(cm_node
);
2650 atomic_inc(&cm_node
->ref_count
);
2651 i40iw_send_reset(cm_node
);
2653 case I40IW_CM_STATE_ESTABLISHED
:
2654 case I40IW_CM_STATE_FIN_WAIT1
:
2655 case I40IW_CM_STATE_FIN_WAIT2
:
2656 case I40IW_CM_STATE_LAST_ACK
:
2657 case I40IW_CM_STATE_OFFLOADED
:
2658 case I40IW_CM_STATE_CLOSING
:
2659 case I40IW_CM_STATE_UNKNOWN
:
2660 case I40IW_CM_STATE_MPAREQ_SENT
:
2667 * i40iw_handle_ack_pkt - process packet with ACK
2668 * @cm_node: connection's node
2669 * @rbuf: receive buffer
2671 static int i40iw_handle_ack_pkt(struct i40iw_cm_node
*cm_node
,
2672 struct i40iw_puda_buf
*rbuf
)
2674 struct tcphdr
*tcph
= (struct tcphdr
*)rbuf
->tcph
;
2678 u32 datasize
= rbuf
->datalen
;
2680 optionsize
= (tcph
->doff
<< 2) - sizeof(struct tcphdr
);
2682 if (i40iw_check_seq(cm_node
, tcph
))
2685 inc_sequence
= ntohl(tcph
->seq
);
2686 switch (cm_node
->state
) {
2687 case I40IW_CM_STATE_SYN_RCVD
:
2688 i40iw_cleanup_retrans_entry(cm_node
);
2689 ret
= i40iw_handle_tcp_options(cm_node
, tcph
, optionsize
, 1);
2692 cm_node
->tcp_cntxt
.rem_ack_num
= ntohl(tcph
->ack_seq
);
2693 cm_node
->state
= I40IW_CM_STATE_ESTABLISHED
;
2695 cm_node
->tcp_cntxt
.rcv_nxt
= inc_sequence
+ datasize
;
2696 i40iw_handle_rcv_mpa(cm_node
, rbuf
);
2699 case I40IW_CM_STATE_ESTABLISHED
:
2700 i40iw_cleanup_retrans_entry(cm_node
);
2702 cm_node
->tcp_cntxt
.rcv_nxt
= inc_sequence
+ datasize
;
2703 i40iw_handle_rcv_mpa(cm_node
, rbuf
);
2706 case I40IW_CM_STATE_MPAREQ_SENT
:
2707 cm_node
->tcp_cntxt
.rem_ack_num
= ntohl(tcph
->ack_seq
);
2709 cm_node
->tcp_cntxt
.rcv_nxt
= inc_sequence
+ datasize
;
2710 i40iw_handle_rcv_mpa(cm_node
, rbuf
);
2713 case I40IW_CM_STATE_LISTENING
:
2714 i40iw_cleanup_retrans_entry(cm_node
);
2715 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2716 i40iw_send_reset(cm_node
);
2718 case I40IW_CM_STATE_CLOSED
:
2719 i40iw_cleanup_retrans_entry(cm_node
);
2720 atomic_inc(&cm_node
->ref_count
);
2721 i40iw_send_reset(cm_node
);
2723 case I40IW_CM_STATE_LAST_ACK
:
2724 case I40IW_CM_STATE_CLOSING
:
2725 i40iw_cleanup_retrans_entry(cm_node
);
2726 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2727 if (!cm_node
->accept_pend
)
2728 cm_node
->cm_id
->rem_ref(cm_node
->cm_id
);
2729 i40iw_rem_ref_cm_node(cm_node
);
2731 case I40IW_CM_STATE_FIN_WAIT1
:
2732 i40iw_cleanup_retrans_entry(cm_node
);
2733 cm_node
->state
= I40IW_CM_STATE_FIN_WAIT2
;
2735 case I40IW_CM_STATE_SYN_SENT
:
2736 case I40IW_CM_STATE_FIN_WAIT2
:
2737 case I40IW_CM_STATE_OFFLOADED
:
2738 case I40IW_CM_STATE_MPAREQ_RCVD
:
2739 case I40IW_CM_STATE_UNKNOWN
:
2741 i40iw_cleanup_retrans_entry(cm_node
);
2748 * i40iw_process_packet - process cm packet
2749 * @cm_node: connection's node
2750 * @rbuf: receive buffer
2752 static void i40iw_process_packet(struct i40iw_cm_node
*cm_node
,
2753 struct i40iw_puda_buf
*rbuf
)
2755 enum i40iw_tcpip_pkt_type pkt_type
= I40IW_PKT_TYPE_UNKNOWN
;
2756 struct tcphdr
*tcph
= (struct tcphdr
*)rbuf
->tcph
;
2761 pkt_type
= I40IW_PKT_TYPE_RST
;
2762 } else if (tcph
->syn
) {
2763 pkt_type
= I40IW_PKT_TYPE_SYN
;
2765 pkt_type
= I40IW_PKT_TYPE_SYNACK
;
2766 } else if (tcph
->ack
) {
2767 pkt_type
= I40IW_PKT_TYPE_ACK
;
2773 case I40IW_PKT_TYPE_SYN
:
2774 i40iw_handle_syn_pkt(cm_node
, rbuf
);
2776 case I40IW_PKT_TYPE_SYNACK
:
2777 i40iw_handle_synack_pkt(cm_node
, rbuf
);
2779 case I40IW_PKT_TYPE_ACK
:
2780 ret
= i40iw_handle_ack_pkt(cm_node
, rbuf
);
2781 if (fin_set
&& !ret
)
2782 i40iw_handle_fin_pkt(cm_node
);
2784 case I40IW_PKT_TYPE_RST
:
2785 i40iw_handle_rst_pkt(cm_node
, rbuf
);
2789 (!i40iw_check_seq(cm_node
, (struct tcphdr
*)rbuf
->tcph
)))
2790 i40iw_handle_fin_pkt(cm_node
);
2796 * i40iw_make_listen_node - create a listen node with params
2797 * @cm_core: cm's core
2798 * @iwdev: iwarp device structure
2799 * @cm_info: quad info for connection
2801 static struct i40iw_cm_listener
*i40iw_make_listen_node(
2802 struct i40iw_cm_core
*cm_core
,
2803 struct i40iw_device
*iwdev
,
2804 struct i40iw_cm_info
*cm_info
)
2806 struct i40iw_cm_listener
*listener
;
2807 unsigned long flags
;
2809 /* cannot have multiple matching listeners */
2810 listener
= i40iw_find_listener(cm_core
, cm_info
->loc_addr
,
2813 I40IW_CM_LISTENER_EITHER_STATE
);
2815 (listener
->listener_state
== I40IW_CM_LISTENER_ACTIVE_STATE
)) {
2816 atomic_dec(&listener
->ref_count
);
2817 i40iw_debug(cm_core
->dev
,
2819 "Not creating listener since it already exists\n");
2824 /* create a CM listen node (1/2 node to compare incoming traffic to) */
2825 listener
= kzalloc(sizeof(*listener
), GFP_ATOMIC
);
2828 cm_core
->stats_listen_nodes_created
++;
2829 memcpy(listener
->loc_addr
, cm_info
->loc_addr
, sizeof(listener
->loc_addr
));
2830 listener
->loc_port
= cm_info
->loc_port
;
2832 INIT_LIST_HEAD(&listener
->child_listen_list
);
2834 atomic_set(&listener
->ref_count
, 1);
2836 listener
->reused_node
= 1;
2839 listener
->cm_id
= cm_info
->cm_id
;
2840 listener
->ipv4
= cm_info
->ipv4
;
2841 listener
->vlan_id
= cm_info
->vlan_id
;
2842 atomic_set(&listener
->pend_accepts_cnt
, 0);
2843 listener
->cm_core
= cm_core
;
2844 listener
->iwdev
= iwdev
;
2846 listener
->backlog
= cm_info
->backlog
;
2847 listener
->listener_state
= I40IW_CM_LISTENER_ACTIVE_STATE
;
2849 if (!listener
->reused_node
) {
2850 spin_lock_irqsave(&cm_core
->listen_list_lock
, flags
);
2851 list_add(&listener
->list
, &cm_core
->listen_nodes
);
2852 spin_unlock_irqrestore(&cm_core
->listen_list_lock
, flags
);
2859 * i40iw_create_cm_node - make a connection node with params
2860 * @cm_core: cm's core
2861 * @iwdev: iwarp device structure
2862 * @private_data_len: len to provate data for mpa request
2863 * @private_data: pointer to private data for connection
2864 * @cm_info: quad info for connection
2866 static struct i40iw_cm_node
*i40iw_create_cm_node(
2867 struct i40iw_cm_core
*cm_core
,
2868 struct i40iw_device
*iwdev
,
2869 u16 private_data_len
,
2871 struct i40iw_cm_info
*cm_info
)
2873 struct i40iw_cm_node
*cm_node
;
2874 struct i40iw_cm_listener
*loopback_remotelistener
;
2875 struct i40iw_cm_node
*loopback_remotenode
;
2876 struct i40iw_cm_info loopback_cm_info
;
2878 /* create a CM connection node */
2879 cm_node
= i40iw_make_cm_node(cm_core
, iwdev
, cm_info
, NULL
);
2881 return ERR_PTR(-ENOMEM
);
2882 /* set our node side to client (active) side */
2883 cm_node
->tcp_cntxt
.client
= 1;
2884 cm_node
->tcp_cntxt
.rcv_wscale
= I40IW_CM_DEFAULT_RCV_WND_SCALE
;
2886 if (!memcmp(cm_info
->loc_addr
, cm_info
->rem_addr
, sizeof(cm_info
->loc_addr
))) {
2887 loopback_remotelistener
= i40iw_find_listener(
2892 I40IW_CM_LISTENER_ACTIVE_STATE
);
2893 if (!loopback_remotelistener
) {
2894 i40iw_rem_ref_cm_node(cm_node
);
2895 return ERR_PTR(-ECONNREFUSED
);
2897 loopback_cm_info
= *cm_info
;
2898 loopback_cm_info
.loc_port
= cm_info
->rem_port
;
2899 loopback_cm_info
.rem_port
= cm_info
->loc_port
;
2900 loopback_cm_info
.cm_id
= loopback_remotelistener
->cm_id
;
2901 loopback_cm_info
.ipv4
= cm_info
->ipv4
;
2902 loopback_remotenode
= i40iw_make_cm_node(cm_core
,
2905 loopback_remotelistener
);
2906 if (!loopback_remotenode
) {
2907 i40iw_rem_ref_cm_node(cm_node
);
2908 return ERR_PTR(-ENOMEM
);
2910 cm_core
->stats_loopbacks
++;
2911 loopback_remotenode
->loopbackpartner
= cm_node
;
2912 loopback_remotenode
->tcp_cntxt
.rcv_wscale
=
2913 I40IW_CM_DEFAULT_RCV_WND_SCALE
;
2914 cm_node
->loopbackpartner
= loopback_remotenode
;
2915 memcpy(loopback_remotenode
->pdata_buf
, private_data
,
2917 loopback_remotenode
->pdata
.size
= private_data_len
;
2919 cm_node
->state
= I40IW_CM_STATE_OFFLOADED
;
2920 cm_node
->tcp_cntxt
.rcv_nxt
=
2921 loopback_remotenode
->tcp_cntxt
.loc_seq_num
;
2922 loopback_remotenode
->tcp_cntxt
.rcv_nxt
=
2923 cm_node
->tcp_cntxt
.loc_seq_num
;
2924 cm_node
->tcp_cntxt
.max_snd_wnd
=
2925 loopback_remotenode
->tcp_cntxt
.rcv_wnd
;
2926 loopback_remotenode
->tcp_cntxt
.max_snd_wnd
= cm_node
->tcp_cntxt
.rcv_wnd
;
2927 cm_node
->tcp_cntxt
.snd_wnd
= loopback_remotenode
->tcp_cntxt
.rcv_wnd
;
2928 loopback_remotenode
->tcp_cntxt
.snd_wnd
= cm_node
->tcp_cntxt
.rcv_wnd
;
2929 cm_node
->tcp_cntxt
.snd_wscale
= loopback_remotenode
->tcp_cntxt
.rcv_wscale
;
2930 loopback_remotenode
->tcp_cntxt
.snd_wscale
= cm_node
->tcp_cntxt
.rcv_wscale
;
2931 loopback_remotenode
->state
= I40IW_CM_STATE_MPAREQ_RCVD
;
2932 i40iw_create_event(loopback_remotenode
, I40IW_CM_EVENT_MPA_REQ
);
2937 cm_node
->pdata
.size
= private_data_len
;
2938 cm_node
->pdata
.addr
= cm_node
->pdata_buf
;
2940 memcpy(cm_node
->pdata_buf
, private_data
, private_data_len
);
2942 cm_node
->state
= I40IW_CM_STATE_SYN_SENT
;
2947 * i40iw_cm_reject - reject and teardown a connection
2948 * @cm_node: connection's node
2949 * @pdate: ptr to private data for reject
2950 * @plen: size of private data
2952 static int i40iw_cm_reject(struct i40iw_cm_node
*cm_node
, const void *pdata
, u8 plen
)
2957 struct iw_cm_id
*cm_id
= cm_node
->cm_id
;
2958 struct i40iw_cm_node
*loopback
= cm_node
->loopbackpartner
;
2960 if (cm_node
->tcp_cntxt
.client
)
2962 i40iw_cleanup_retrans_entry(cm_node
);
2965 passive_state
= atomic_add_return(1, &cm_node
->passive_state
);
2966 if (passive_state
== I40IW_SEND_RESET_EVENT
) {
2967 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2968 i40iw_rem_ref_cm_node(cm_node
);
2970 if (cm_node
->state
== I40IW_CM_STATE_LISTENER_DESTROYED
) {
2971 i40iw_rem_ref_cm_node(cm_node
);
2973 ret
= i40iw_send_mpa_reject(cm_node
, pdata
, plen
);
2975 cm_node
->state
= I40IW_CM_STATE_CLOSED
;
2976 err
= i40iw_send_reset(cm_node
);
2978 i40iw_pr_err("send reset failed\n");
2980 cm_id
->add_ref(cm_id
);
2985 cm_node
->cm_id
= NULL
;
2986 if (cm_node
->state
== I40IW_CM_STATE_LISTENER_DESTROYED
) {
2987 i40iw_rem_ref_cm_node(cm_node
);
2988 i40iw_rem_ref_cm_node(loopback
);
2990 ret
= i40iw_send_cm_event(loopback
,
2992 IW_CM_EVENT_CONNECT_REPLY
,
2994 i40iw_rem_ref_cm_node(cm_node
);
2995 loopback
->state
= I40IW_CM_STATE_CLOSING
;
2997 cm_id
= loopback
->cm_id
;
2998 i40iw_rem_ref_cm_node(loopback
);
2999 cm_id
->rem_ref(cm_id
);
3007 * i40iw_cm_close - close of cm connection
3008 * @cm_node: connection's node
3010 static int i40iw_cm_close(struct i40iw_cm_node
*cm_node
)
3017 switch (cm_node
->state
) {
3018 case I40IW_CM_STATE_SYN_RCVD
:
3019 case I40IW_CM_STATE_SYN_SENT
:
3020 case I40IW_CM_STATE_ONE_SIDE_ESTABLISHED
:
3021 case I40IW_CM_STATE_ESTABLISHED
:
3022 case I40IW_CM_STATE_ACCEPTING
:
3023 case I40IW_CM_STATE_MPAREQ_SENT
:
3024 case I40IW_CM_STATE_MPAREQ_RCVD
:
3025 i40iw_cleanup_retrans_entry(cm_node
);
3026 i40iw_send_reset(cm_node
);
3028 case I40IW_CM_STATE_CLOSE_WAIT
:
3029 cm_node
->state
= I40IW_CM_STATE_LAST_ACK
;
3030 i40iw_send_fin(cm_node
);
3032 case I40IW_CM_STATE_FIN_WAIT1
:
3033 case I40IW_CM_STATE_FIN_WAIT2
:
3034 case I40IW_CM_STATE_LAST_ACK
:
3035 case I40IW_CM_STATE_TIME_WAIT
:
3036 case I40IW_CM_STATE_CLOSING
:
3039 case I40IW_CM_STATE_LISTENING
:
3040 i40iw_cleanup_retrans_entry(cm_node
);
3041 i40iw_send_reset(cm_node
);
3043 case I40IW_CM_STATE_MPAREJ_RCVD
:
3044 case I40IW_CM_STATE_UNKNOWN
:
3045 case I40IW_CM_STATE_INITED
:
3046 case I40IW_CM_STATE_CLOSED
:
3047 case I40IW_CM_STATE_LISTENER_DESTROYED
:
3048 i40iw_rem_ref_cm_node(cm_node
);
3050 case I40IW_CM_STATE_OFFLOADED
:
3051 if (cm_node
->send_entry
)
3052 i40iw_pr_err("send_entry\n");
3053 i40iw_rem_ref_cm_node(cm_node
);
3060 * i40iw_receive_ilq - recv an ETHERNET packet, and process it
3062 * @vsi: pointer to the vsi structure
3063 * @rbuf: receive buffer
3065 void i40iw_receive_ilq(struct i40iw_sc_vsi
*vsi
, struct i40iw_puda_buf
*rbuf
)
3067 struct i40iw_cm_node
*cm_node
;
3068 struct i40iw_cm_listener
*listener
;
3070 struct ipv6hdr
*ip6h
;
3071 struct tcphdr
*tcph
;
3072 struct i40iw_cm_info cm_info
;
3073 struct i40iw_sc_dev
*dev
= vsi
->dev
;
3074 struct i40iw_device
*iwdev
= (struct i40iw_device
*)dev
->back_dev
;
3075 struct i40iw_cm_core
*cm_core
= &iwdev
->cm_core
;
3076 struct vlan_ethhdr
*ethh
;
3079 /* if vlan, then maclen = 18 else 14 */
3080 iph
= (struct iphdr
*)rbuf
->iph
;
3081 memset(&cm_info
, 0, sizeof(cm_info
));
3083 i40iw_debug_buf(dev
,
3085 "RECEIVE ILQ BUFFER",
3088 ethh
= (struct vlan_ethhdr
*)rbuf
->mem
.va
;
3090 if (ethh
->h_vlan_proto
== htons(ETH_P_8021Q
)) {
3091 vtag
= ntohs(ethh
->h_vlan_TCI
);
3092 cm_info
.user_pri
= (vtag
& VLAN_PRIO_MASK
) >> VLAN_PRIO_SHIFT
;
3093 cm_info
.vlan_id
= vtag
& VLAN_VID_MASK
;
3094 i40iw_debug(cm_core
->dev
,
3100 cm_info
.vlan_id
= I40IW_NO_VLAN
;
3102 tcph
= (struct tcphdr
*)rbuf
->tcph
;
3105 cm_info
.loc_addr
[0] = ntohl(iph
->daddr
);
3106 cm_info
.rem_addr
[0] = ntohl(iph
->saddr
);
3107 cm_info
.ipv4
= true;
3108 cm_info
.tos
= iph
->tos
;
3110 ip6h
= (struct ipv6hdr
*)rbuf
->iph
;
3111 i40iw_copy_ip_ntohl(cm_info
.loc_addr
,
3112 ip6h
->daddr
.in6_u
.u6_addr32
);
3113 i40iw_copy_ip_ntohl(cm_info
.rem_addr
,
3114 ip6h
->saddr
.in6_u
.u6_addr32
);
3115 cm_info
.ipv4
= false;
3116 cm_info
.tos
= (ip6h
->priority
<< 4) | (ip6h
->flow_lbl
[0] >> 4);
3118 cm_info
.loc_port
= ntohs(tcph
->dest
);
3119 cm_info
.rem_port
= ntohs(tcph
->source
);
3120 cm_node
= i40iw_find_node(cm_core
,
3128 /* Only type of packet accepted are for */
3129 /* the PASSIVE open (syn only) */
3130 if (!tcph
->syn
|| tcph
->ack
)
3133 i40iw_find_listener(cm_core
,
3137 I40IW_CM_LISTENER_ACTIVE_STATE
);
3139 cm_info
.cm_id
= NULL
;
3140 i40iw_debug(cm_core
->dev
,
3142 "%s no listener found\n",
3146 cm_info
.cm_id
= listener
->cm_id
;
3147 cm_node
= i40iw_make_cm_node(cm_core
, iwdev
, &cm_info
, listener
);
3149 i40iw_debug(cm_core
->dev
,
3151 "%s allocate node failed\n",
3153 atomic_dec(&listener
->ref_count
);
3156 if (!tcph
->rst
&& !tcph
->fin
) {
3157 cm_node
->state
= I40IW_CM_STATE_LISTENING
;
3159 i40iw_rem_ref_cm_node(cm_node
);
3162 atomic_inc(&cm_node
->ref_count
);
3163 } else if (cm_node
->state
== I40IW_CM_STATE_OFFLOADED
) {
3164 i40iw_rem_ref_cm_node(cm_node
);
3167 i40iw_process_packet(cm_node
, rbuf
);
3168 i40iw_rem_ref_cm_node(cm_node
);
3172 * i40iw_setup_cm_core - allocate a top level instance of a cm
3174 * @iwdev: iwarp device structure
3176 void i40iw_setup_cm_core(struct i40iw_device
*iwdev
)
3178 struct i40iw_cm_core
*cm_core
= &iwdev
->cm_core
;
3180 cm_core
->iwdev
= iwdev
;
3181 cm_core
->dev
= &iwdev
->sc_dev
;
3183 INIT_LIST_HEAD(&cm_core
->connected_nodes
);
3184 INIT_LIST_HEAD(&cm_core
->listen_nodes
);
3186 setup_timer(&cm_core
->tcp_timer
, i40iw_cm_timer_tick
,
3187 (unsigned long)cm_core
);
3189 spin_lock_init(&cm_core
->ht_lock
);
3190 spin_lock_init(&cm_core
->listen_list_lock
);
3192 cm_core
->event_wq
= alloc_ordered_workqueue("iwewq",
3195 cm_core
->disconn_wq
= alloc_ordered_workqueue("iwdwq",
3200 * i40iw_cleanup_cm_core - deallocate a top level instance of a
3202 * @cm_core: cm's core
3204 void i40iw_cleanup_cm_core(struct i40iw_cm_core
*cm_core
)
3206 unsigned long flags
;
3211 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
3212 if (timer_pending(&cm_core
->tcp_timer
))
3213 del_timer_sync(&cm_core
->tcp_timer
);
3214 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
3216 destroy_workqueue(cm_core
->event_wq
);
3217 destroy_workqueue(cm_core
->disconn_wq
);
3221 * i40iw_init_tcp_ctx - setup qp context
3222 * @cm_node: connection's node
3223 * @tcp_info: offload info for tcp
3224 * @iwqp: associate qp for the connection
3226 static void i40iw_init_tcp_ctx(struct i40iw_cm_node
*cm_node
,
3227 struct i40iw_tcp_offload_info
*tcp_info
,
3228 struct i40iw_qp
*iwqp
)
3230 tcp_info
->ipv4
= cm_node
->ipv4
;
3231 tcp_info
->drop_ooo_seg
= true;
3232 tcp_info
->wscale
= true;
3233 tcp_info
->ignore_tcp_opt
= true;
3234 tcp_info
->ignore_tcp_uns_opt
= true;
3235 tcp_info
->no_nagle
= false;
3237 tcp_info
->ttl
= I40IW_DEFAULT_TTL
;
3238 tcp_info
->rtt_var
= cpu_to_le32(I40IW_DEFAULT_RTT_VAR
);
3239 tcp_info
->ss_thresh
= cpu_to_le32(I40IW_DEFAULT_SS_THRESH
);
3240 tcp_info
->rexmit_thresh
= I40IW_DEFAULT_REXMIT_THRESH
;
3242 tcp_info
->tcp_state
= I40IW_TCP_STATE_ESTABLISHED
;
3243 tcp_info
->snd_wscale
= cm_node
->tcp_cntxt
.snd_wscale
;
3244 tcp_info
->rcv_wscale
= cm_node
->tcp_cntxt
.rcv_wscale
;
3246 tcp_info
->snd_nxt
= cpu_to_le32(cm_node
->tcp_cntxt
.loc_seq_num
);
3247 tcp_info
->snd_wnd
= cpu_to_le32(cm_node
->tcp_cntxt
.snd_wnd
);
3248 tcp_info
->rcv_nxt
= cpu_to_le32(cm_node
->tcp_cntxt
.rcv_nxt
);
3249 tcp_info
->snd_max
= cpu_to_le32(cm_node
->tcp_cntxt
.loc_seq_num
);
3251 tcp_info
->snd_una
= cpu_to_le32(cm_node
->tcp_cntxt
.loc_seq_num
);
3252 tcp_info
->cwnd
= cpu_to_le32(2 * cm_node
->tcp_cntxt
.mss
);
3253 tcp_info
->snd_wl1
= cpu_to_le32(cm_node
->tcp_cntxt
.rcv_nxt
);
3254 tcp_info
->snd_wl2
= cpu_to_le32(cm_node
->tcp_cntxt
.loc_seq_num
);
3255 tcp_info
->max_snd_window
= cpu_to_le32(cm_node
->tcp_cntxt
.max_snd_wnd
);
3256 tcp_info
->rcv_wnd
= cpu_to_le32(cm_node
->tcp_cntxt
.rcv_wnd
<<
3257 cm_node
->tcp_cntxt
.rcv_wscale
);
3259 tcp_info
->flow_label
= 0;
3260 tcp_info
->snd_mss
= cpu_to_le32(((u32
)cm_node
->tcp_cntxt
.mss
));
3261 if (cm_node
->vlan_id
< VLAN_TAG_PRESENT
) {
3262 tcp_info
->insert_vlan_tag
= true;
3263 tcp_info
->vlan_tag
= cpu_to_le16(cm_node
->vlan_id
);
3265 if (cm_node
->ipv4
) {
3266 tcp_info
->src_port
= cpu_to_le16(cm_node
->loc_port
);
3267 tcp_info
->dst_port
= cpu_to_le16(cm_node
->rem_port
);
3269 tcp_info
->dest_ip_addr3
= cpu_to_le32(cm_node
->rem_addr
[0]);
3270 tcp_info
->local_ipaddr3
= cpu_to_le32(cm_node
->loc_addr
[0]);
3272 cpu_to_le16((u16
)i40iw_arp_table(
3274 &tcp_info
->dest_ip_addr3
,
3277 I40IW_ARP_RESOLVE
));
3279 tcp_info
->src_port
= cpu_to_le16(cm_node
->loc_port
);
3280 tcp_info
->dst_port
= cpu_to_le16(cm_node
->rem_port
);
3281 tcp_info
->dest_ip_addr0
= cpu_to_le32(cm_node
->rem_addr
[0]);
3282 tcp_info
->dest_ip_addr1
= cpu_to_le32(cm_node
->rem_addr
[1]);
3283 tcp_info
->dest_ip_addr2
= cpu_to_le32(cm_node
->rem_addr
[2]);
3284 tcp_info
->dest_ip_addr3
= cpu_to_le32(cm_node
->rem_addr
[3]);
3285 tcp_info
->local_ipaddr0
= cpu_to_le32(cm_node
->loc_addr
[0]);
3286 tcp_info
->local_ipaddr1
= cpu_to_le32(cm_node
->loc_addr
[1]);
3287 tcp_info
->local_ipaddr2
= cpu_to_le32(cm_node
->loc_addr
[2]);
3288 tcp_info
->local_ipaddr3
= cpu_to_le32(cm_node
->loc_addr
[3]);
3290 cpu_to_le16((u16
)i40iw_arp_table(
3292 &tcp_info
->dest_ip_addr0
,
3295 I40IW_ARP_RESOLVE
));
3300 * i40iw_cm_init_tsa_conn - setup qp for RTS
3301 * @iwqp: associate qp for the connection
3302 * @cm_node: connection's node
3304 static void i40iw_cm_init_tsa_conn(struct i40iw_qp
*iwqp
,
3305 struct i40iw_cm_node
*cm_node
)
3307 struct i40iw_tcp_offload_info tcp_info
;
3308 struct i40iwarp_offload_info
*iwarp_info
;
3309 struct i40iw_qp_host_ctx_info
*ctx_info
;
3310 struct i40iw_device
*iwdev
= iwqp
->iwdev
;
3311 struct i40iw_sc_dev
*dev
= &iwqp
->iwdev
->sc_dev
;
3313 memset(&tcp_info
, 0x00, sizeof(struct i40iw_tcp_offload_info
));
3314 iwarp_info
= &iwqp
->iwarp_info
;
3315 ctx_info
= &iwqp
->ctx_info
;
3317 ctx_info
->tcp_info
= &tcp_info
;
3318 ctx_info
->send_cq_num
= iwqp
->iwscq
->sc_cq
.cq_uk
.cq_id
;
3319 ctx_info
->rcv_cq_num
= iwqp
->iwrcq
->sc_cq
.cq_uk
.cq_id
;
3321 iwarp_info
->ord_size
= cm_node
->ord_size
;
3322 iwarp_info
->ird_size
= i40iw_derive_hw_ird_setting(cm_node
->ird_size
);
3324 if (iwarp_info
->ord_size
== 1)
3325 iwarp_info
->ord_size
= 2;
3327 iwarp_info
->rd_enable
= true;
3328 iwarp_info
->rdmap_ver
= 1;
3329 iwarp_info
->ddp_ver
= 1;
3331 iwarp_info
->pd_id
= iwqp
->iwpd
->sc_pd
.pd_id
;
3333 ctx_info
->tcp_info_valid
= true;
3334 ctx_info
->iwarp_info_valid
= true;
3335 ctx_info
->add_to_qoslist
= true;
3336 ctx_info
->user_pri
= cm_node
->user_pri
;
3338 i40iw_init_tcp_ctx(cm_node
, &tcp_info
, iwqp
);
3339 if (cm_node
->snd_mark_en
) {
3340 iwarp_info
->snd_mark_en
= true;
3341 iwarp_info
->snd_mark_offset
= (tcp_info
.snd_nxt
&
3342 SNDMARKER_SEQNMASK
) + cm_node
->lsmm_size
;
3345 cm_node
->state
= I40IW_CM_STATE_OFFLOADED
;
3346 tcp_info
.tcp_state
= I40IW_TCP_STATE_ESTABLISHED
;
3347 tcp_info
.src_mac_addr_idx
= iwdev
->mac_ip_table_idx
;
3348 tcp_info
.tos
= cm_node
->tos
;
3350 dev
->iw_priv_qp_ops
->qp_setctx(&iwqp
->sc_qp
, (u64
*)(iwqp
->host_ctx
.va
), ctx_info
);
3352 /* once tcp_info is set, no need to do it again */
3353 ctx_info
->tcp_info_valid
= false;
3354 ctx_info
->iwarp_info_valid
= false;
3355 ctx_info
->add_to_qoslist
= false;
3359 * i40iw_cm_disconn - when a connection is being closed
3360 * @iwqp: associate qp for the connection
3362 void i40iw_cm_disconn(struct i40iw_qp
*iwqp
)
3364 struct disconn_work
*work
;
3365 struct i40iw_device
*iwdev
= iwqp
->iwdev
;
3366 struct i40iw_cm_core
*cm_core
= &iwdev
->cm_core
;
3367 unsigned long flags
;
3369 work
= kzalloc(sizeof(*work
), GFP_ATOMIC
);
3371 return; /* Timer will clean up */
3373 spin_lock_irqsave(&iwdev
->qptable_lock
, flags
);
3374 if (!iwdev
->qp_table
[iwqp
->ibqp
.qp_num
]) {
3375 spin_unlock_irqrestore(&iwdev
->qptable_lock
, flags
);
3376 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_CM
,
3377 "%s qp_id %d is already freed\n",
3378 __func__
, iwqp
->ibqp
.qp_num
);
3382 i40iw_add_ref(&iwqp
->ibqp
);
3383 spin_unlock_irqrestore(&iwdev
->qptable_lock
, flags
);
3386 INIT_WORK(&work
->work
, i40iw_disconnect_worker
);
3387 queue_work(cm_core
->disconn_wq
, &work
->work
);
3392 * i40iw_qp_disconnect - free qp and close cm
3393 * @iwqp: associate qp for the connection
3395 static void i40iw_qp_disconnect(struct i40iw_qp
*iwqp
)
3397 struct i40iw_device
*iwdev
;
3398 struct i40iw_ib_device
*iwibdev
;
3400 iwdev
= to_iwdev(iwqp
->ibqp
.device
);
3402 i40iw_pr_err("iwdev == NULL\n");
3406 iwibdev
= iwdev
->iwibdev
;
3408 if (iwqp
->active_conn
) {
3409 /* indicate this connection is NOT active */
3410 iwqp
->active_conn
= 0;
3412 /* Need to free the Last Streaming Mode Message */
3413 if (iwqp
->ietf_mem
.va
) {
3415 iwibdev
->ibdev
.dereg_mr(iwqp
->lsmm_mr
);
3416 i40iw_free_dma_mem(iwdev
->sc_dev
.hw
, &iwqp
->ietf_mem
);
3420 /* close the CM node down if it is still active */
3421 if (iwqp
->cm_node
) {
3422 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_CM
, "%s Call close API\n", __func__
);
3423 i40iw_cm_close(iwqp
->cm_node
);
3428 * i40iw_cm_disconn_true - called by worker thread to disconnect qp
3429 * @iwqp: associate qp for the connection
3431 static void i40iw_cm_disconn_true(struct i40iw_qp
*iwqp
)
3433 struct iw_cm_id
*cm_id
;
3434 struct i40iw_device
*iwdev
;
3435 struct i40iw_sc_qp
*qp
= &iwqp
->sc_qp
;
3437 u8 original_hw_tcp_state
;
3438 u8 original_ibqp_state
;
3439 int disconn_status
= 0;
3440 int issue_disconn
= 0;
3441 int issue_close
= 0;
3442 int issue_flush
= 0;
3443 struct ib_event ibevent
;
3444 unsigned long flags
;
3448 i40iw_pr_err("iwqp == NULL\n");
3452 spin_lock_irqsave(&iwqp
->lock
, flags
);
3453 cm_id
= iwqp
->cm_id
;
3454 /* make sure we havent already closed this connection */
3456 spin_unlock_irqrestore(&iwqp
->lock
, flags
);
3460 iwdev
= to_iwdev(iwqp
->ibqp
.device
);
3462 original_hw_tcp_state
= iwqp
->hw_tcp_state
;
3463 original_ibqp_state
= iwqp
->ibqp_state
;
3464 last_ae
= iwqp
->last_aeq
;
3466 if (qp
->term_flags
) {
3470 /*When term timer expires after cm_timer, don't want
3471 *terminate-handler to issue cm_disconn which can re-free
3472 *a QP even after its refcnt=0.
3474 i40iw_terminate_del_timer(qp
);
3475 if (!iwqp
->flush_issued
) {
3476 iwqp
->flush_issued
= 1;
3479 } else if ((original_hw_tcp_state
== I40IW_TCP_STATE_CLOSE_WAIT
) ||
3480 ((original_ibqp_state
== IB_QPS_RTS
) &&
3481 (last_ae
== I40IW_AE_LLP_CONNECTION_RESET
))) {
3483 if (last_ae
== I40IW_AE_LLP_CONNECTION_RESET
)
3484 disconn_status
= -ECONNRESET
;
3487 if (((original_hw_tcp_state
== I40IW_TCP_STATE_CLOSED
) ||
3488 (original_hw_tcp_state
== I40IW_TCP_STATE_TIME_WAIT
) ||
3489 (last_ae
== I40IW_AE_RDMAP_ROE_BAD_LLP_CLOSE
) ||
3490 (last_ae
== I40IW_AE_LLP_CONNECTION_RESET
) ||
3494 if (!iwqp
->flush_issued
) {
3495 iwqp
->flush_issued
= 1;
3500 spin_unlock_irqrestore(&iwqp
->lock
, flags
);
3501 if (issue_flush
&& !iwqp
->destroyed
) {
3502 /* Flush the queues */
3503 i40iw_flush_wqes(iwdev
, iwqp
);
3505 if (qp
->term_flags
&& iwqp
->ibqp
.event_handler
) {
3506 ibevent
.device
= iwqp
->ibqp
.device
;
3507 ibevent
.event
= (qp
->eventtype
== TERM_EVENT_QP_FATAL
) ?
3508 IB_EVENT_QP_FATAL
: IB_EVENT_QP_ACCESS_ERR
;
3509 ibevent
.element
.qp
= &iwqp
->ibqp
;
3510 iwqp
->ibqp
.event_handler(&ibevent
, iwqp
->ibqp
.qp_context
);
3514 if (cm_id
&& cm_id
->event_handler
) {
3515 if (issue_disconn
) {
3516 ret
= i40iw_send_cm_event(NULL
,
3518 IW_CM_EVENT_DISCONNECT
,
3522 i40iw_debug(&iwdev
->sc_dev
,
3524 "disconnect event failed %s: - cm_id = %p\n",
3528 i40iw_qp_disconnect(iwqp
);
3529 cm_id
->provider_data
= iwqp
;
3530 ret
= i40iw_send_cm_event(NULL
, cm_id
, IW_CM_EVENT_CLOSE
, 0);
3532 i40iw_debug(&iwdev
->sc_dev
,
3534 "close event failed %s: - cm_id = %p\n",
3536 cm_id
->rem_ref(cm_id
);
3542 * i40iw_disconnect_worker - worker for connection close
3543 * @work: points or disconn structure
3545 static void i40iw_disconnect_worker(struct work_struct
*work
)
3547 struct disconn_work
*dwork
= container_of(work
, struct disconn_work
, work
);
3548 struct i40iw_qp
*iwqp
= dwork
->iwqp
;
3551 i40iw_cm_disconn_true(iwqp
);
3552 i40iw_rem_ref(&iwqp
->ibqp
);
3556 * i40iw_accept - registered call for connection to be accepted
3557 * @cm_id: cm information for passive connection
3558 * @conn_param: accpet parameters
3560 int i40iw_accept(struct iw_cm_id
*cm_id
, struct iw_cm_conn_param
*conn_param
)
3563 struct i40iw_qp
*iwqp
;
3564 struct i40iw_device
*iwdev
;
3565 struct i40iw_sc_dev
*dev
;
3566 struct i40iw_cm_node
*cm_node
;
3567 struct ib_qp_attr attr
;
3570 struct i40iw_pd
*iwpd
;
3572 struct i40iw_kmem_info accept
;
3573 enum i40iw_status_code status
;
3576 memset(&attr
, 0, sizeof(attr
));
3577 ibqp
= i40iw_get_qp(cm_id
->device
, conn_param
->qpn
);
3581 iwqp
= to_iwqp(ibqp
);
3582 iwdev
= iwqp
->iwdev
;
3583 dev
= &iwdev
->sc_dev
;
3584 cm_node
= (struct i40iw_cm_node
*)cm_id
->provider_data
;
3586 if (((struct sockaddr_in
*)&cm_id
->local_addr
)->sin_family
== AF_INET
) {
3587 cm_node
->ipv4
= true;
3588 cm_node
->vlan_id
= i40iw_get_vlan_ipv4(cm_node
->loc_addr
);
3590 cm_node
->ipv4
= false;
3591 i40iw_netdev_vlan_ipv6(cm_node
->loc_addr
, &cm_node
->vlan_id
, NULL
);
3593 i40iw_debug(cm_node
->dev
,
3595 "Accept vlan_id=%d\n",
3597 if (cm_node
->state
== I40IW_CM_STATE_LISTENER_DESTROYED
) {
3598 if (cm_node
->loopbackpartner
)
3599 i40iw_rem_ref_cm_node(cm_node
->loopbackpartner
);
3600 i40iw_rem_ref_cm_node(cm_node
);
3604 passive_state
= atomic_add_return(1, &cm_node
->passive_state
);
3605 if (passive_state
== I40IW_SEND_RESET_EVENT
) {
3606 i40iw_rem_ref_cm_node(cm_node
);
3610 cm_node
->cm_core
->stats_accepts
++;
3611 iwqp
->cm_node
= (void *)cm_node
;
3612 cm_node
->iwqp
= iwqp
;
3614 buf_len
= conn_param
->private_data_len
+ I40IW_MAX_IETF_SIZE
;
3616 status
= i40iw_allocate_dma_mem(dev
->hw
, &iwqp
->ietf_mem
, buf_len
, 1);
3620 cm_node
->pdata
.size
= conn_param
->private_data_len
;
3621 accept
.addr
= iwqp
->ietf_mem
.va
;
3622 accept
.size
= i40iw_cm_build_mpa_frame(cm_node
, &accept
, MPA_KEY_REPLY
);
3623 memcpy(accept
.addr
+ accept
.size
, conn_param
->private_data
,
3624 conn_param
->private_data_len
);
3626 /* setup our first outgoing iWarp send WQE (the IETF frame response) */
3627 if ((cm_node
->ipv4
&&
3628 !i40iw_ipv4_is_loopback(cm_node
->loc_addr
[0], cm_node
->rem_addr
[0])) ||
3630 !i40iw_ipv6_is_loopback(cm_node
->loc_addr
, cm_node
->rem_addr
))) {
3632 tagged_offset
= (uintptr_t)iwqp
->ietf_mem
.va
;
3633 ibmr
= i40iw_reg_phys_mr(&iwpd
->ibpd
,
3636 IB_ACCESS_LOCAL_WRITE
,
3639 i40iw_free_dma_mem(dev
->hw
, &iwqp
->ietf_mem
);
3643 ibmr
->pd
= &iwpd
->ibpd
;
3644 ibmr
->device
= iwpd
->ibpd
.device
;
3645 iwqp
->lsmm_mr
= ibmr
;
3647 iwqp
->sc_qp
.qp_uk
.sq_base
= kmap(iwqp
->page
);
3648 dev
->iw_priv_qp_ops
->qp_send_lsmm(&iwqp
->sc_qp
,
3650 (accept
.size
+ conn_param
->private_data_len
),
3655 iwqp
->sc_qp
.qp_uk
.sq_base
= kmap(iwqp
->page
);
3656 dev
->iw_priv_qp_ops
->qp_send_lsmm(&iwqp
->sc_qp
, NULL
, 0, 0);
3662 iwqp
->cm_id
= cm_id
;
3663 cm_node
->cm_id
= cm_id
;
3665 cm_id
->provider_data
= (void *)iwqp
;
3666 iwqp
->active_conn
= 0;
3668 cm_node
->lsmm_size
= accept
.size
+ conn_param
->private_data_len
;
3669 i40iw_cm_init_tsa_conn(iwqp
, cm_node
);
3670 cm_id
->add_ref(cm_id
);
3671 i40iw_add_ref(&iwqp
->ibqp
);
3673 i40iw_send_cm_event(cm_node
, cm_id
, IW_CM_EVENT_ESTABLISHED
, 0);
3675 attr
.qp_state
= IB_QPS_RTS
;
3676 cm_node
->qhash_set
= false;
3677 i40iw_modify_qp(&iwqp
->ibqp
, &attr
, IB_QP_STATE
, NULL
);
3678 if (cm_node
->loopbackpartner
) {
3679 cm_node
->loopbackpartner
->pdata
.size
= conn_param
->private_data_len
;
3681 /* copy entire MPA frame to our cm_node's frame */
3682 memcpy(cm_node
->loopbackpartner
->pdata_buf
,
3683 conn_param
->private_data
,
3684 conn_param
->private_data_len
);
3685 i40iw_create_event(cm_node
->loopbackpartner
, I40IW_CM_EVENT_CONNECTED
);
3688 cm_node
->accelerated
= 1;
3689 if (cm_node
->accept_pend
) {
3690 if (!cm_node
->listener
)
3691 i40iw_pr_err("cm_node->listener NULL for passive node\n");
3692 atomic_dec(&cm_node
->listener
->pend_accepts_cnt
);
3693 cm_node
->accept_pend
= 0;
3699 * i40iw_reject - registered call for connection to be rejected
3700 * @cm_id: cm information for passive connection
3701 * @pdata: private data to be sent
3702 * @pdata_len: private data length
3704 int i40iw_reject(struct iw_cm_id
*cm_id
, const void *pdata
, u8 pdata_len
)
3706 struct i40iw_device
*iwdev
;
3707 struct i40iw_cm_node
*cm_node
;
3708 struct i40iw_cm_node
*loopback
;
3710 cm_node
= (struct i40iw_cm_node
*)cm_id
->provider_data
;
3711 loopback
= cm_node
->loopbackpartner
;
3712 cm_node
->cm_id
= cm_id
;
3713 cm_node
->pdata
.size
= pdata_len
;
3715 iwdev
= to_iwdev(cm_id
->device
);
3718 cm_node
->cm_core
->stats_rejects
++;
3720 if (pdata_len
+ sizeof(struct ietf_mpa_v2
) > MAX_CM_BUFFER
)
3724 memcpy(&loopback
->pdata_buf
, pdata
, pdata_len
);
3725 loopback
->pdata
.size
= pdata_len
;
3728 return i40iw_cm_reject(cm_node
, pdata
, pdata_len
);
3732 * i40iw_connect - registered call for connection to be established
3733 * @cm_id: cm information for passive connection
3734 * @conn_param: Information about the connection
3736 int i40iw_connect(struct iw_cm_id
*cm_id
, struct iw_cm_conn_param
*conn_param
)
3739 struct i40iw_qp
*iwqp
;
3740 struct i40iw_device
*iwdev
;
3741 struct i40iw_cm_node
*cm_node
;
3742 struct i40iw_cm_info cm_info
;
3743 struct sockaddr_in
*laddr
;
3744 struct sockaddr_in
*raddr
;
3745 struct sockaddr_in6
*laddr6
;
3746 struct sockaddr_in6
*raddr6
;
3747 bool qhash_set
= false;
3750 enum i40iw_status_code status
;
3752 ibqp
= i40iw_get_qp(cm_id
->device
, conn_param
->qpn
);
3755 iwqp
= to_iwqp(ibqp
);
3758 iwdev
= to_iwdev(iwqp
->ibqp
.device
);
3762 laddr
= (struct sockaddr_in
*)&cm_id
->m_local_addr
;
3763 raddr
= (struct sockaddr_in
*)&cm_id
->m_remote_addr
;
3764 laddr6
= (struct sockaddr_in6
*)&cm_id
->m_local_addr
;
3765 raddr6
= (struct sockaddr_in6
*)&cm_id
->m_remote_addr
;
3767 if (!(laddr
->sin_port
) || !(raddr
->sin_port
))
3770 iwqp
->active_conn
= 1;
3772 cm_id
->provider_data
= iwqp
;
3774 /* set up the connection params for the node */
3775 if (cm_id
->remote_addr
.ss_family
== AF_INET
) {
3776 cm_info
.ipv4
= true;
3777 memset(cm_info
.loc_addr
, 0, sizeof(cm_info
.loc_addr
));
3778 memset(cm_info
.rem_addr
, 0, sizeof(cm_info
.rem_addr
));
3779 cm_info
.loc_addr
[0] = ntohl(laddr
->sin_addr
.s_addr
);
3780 cm_info
.rem_addr
[0] = ntohl(raddr
->sin_addr
.s_addr
);
3781 cm_info
.loc_port
= ntohs(laddr
->sin_port
);
3782 cm_info
.rem_port
= ntohs(raddr
->sin_port
);
3783 cm_info
.vlan_id
= i40iw_get_vlan_ipv4(cm_info
.loc_addr
);
3785 cm_info
.ipv4
= false;
3786 i40iw_copy_ip_ntohl(cm_info
.loc_addr
,
3787 laddr6
->sin6_addr
.in6_u
.u6_addr32
);
3788 i40iw_copy_ip_ntohl(cm_info
.rem_addr
,
3789 raddr6
->sin6_addr
.in6_u
.u6_addr32
);
3790 cm_info
.loc_port
= ntohs(laddr6
->sin6_port
);
3791 cm_info
.rem_port
= ntohs(raddr6
->sin6_port
);
3792 i40iw_netdev_vlan_ipv6(cm_info
.loc_addr
, &cm_info
.vlan_id
, NULL
);
3794 cm_info
.cm_id
= cm_id
;
3795 cm_info
.tos
= cm_id
->tos
;
3796 cm_info
.user_pri
= rt_tos2priority(cm_id
->tos
);
3797 i40iw_debug(&iwdev
->sc_dev
, I40IW_DEBUG_DCB
, "%s TOS:[%d] UP:[%d]\n",
3798 __func__
, cm_id
->tos
, cm_info
.user_pri
);
3799 if ((cm_info
.ipv4
&& (laddr
->sin_addr
.s_addr
!= raddr
->sin_addr
.s_addr
)) ||
3800 (!cm_info
.ipv4
&& memcmp(laddr6
->sin6_addr
.in6_u
.u6_addr32
,
3801 raddr6
->sin6_addr
.in6_u
.u6_addr32
,
3802 sizeof(laddr6
->sin6_addr
.in6_u
.u6_addr32
)))) {
3803 status
= i40iw_manage_qhash(iwdev
,
3805 I40IW_QHASH_TYPE_TCP_ESTABLISHED
,
3806 I40IW_QHASH_MANAGE_TYPE_ADD
,
3813 status
= i40iw_manage_apbvt(iwdev
, cm_info
.loc_port
, I40IW_MANAGE_APBVT_ADD
);
3815 i40iw_manage_qhash(iwdev
,
3817 I40IW_QHASH_TYPE_TCP_ESTABLISHED
,
3818 I40IW_QHASH_MANAGE_TYPE_DELETE
,
3825 cm_id
->add_ref(cm_id
);
3826 cm_node
= i40iw_create_cm_node(&iwdev
->cm_core
, iwdev
,
3827 conn_param
->private_data_len
,
3828 (void *)conn_param
->private_data
,
3831 if (IS_ERR(cm_node
)) {
3832 err
= PTR_ERR(cm_node
);
3836 i40iw_record_ird_ord(cm_node
, (u16
)conn_param
->ird
, (u16
)conn_param
->ord
);
3837 if (cm_node
->send_rdma0_op
== SEND_RDMA_READ_ZERO
&&
3839 cm_node
->ord_size
= 1;
3841 cm_node
->apbvt_set
= apbvt_set
;
3842 cm_node
->qhash_set
= qhash_set
;
3843 iwqp
->cm_node
= cm_node
;
3844 cm_node
->iwqp
= iwqp
;
3845 iwqp
->cm_id
= cm_id
;
3846 i40iw_add_ref(&iwqp
->ibqp
);
3848 if (cm_node
->state
!= I40IW_CM_STATE_OFFLOADED
) {
3849 cm_node
->state
= I40IW_CM_STATE_SYN_SENT
;
3850 err
= i40iw_send_syn(cm_node
, 0);
3852 i40iw_rem_ref_cm_node(cm_node
);
3857 i40iw_debug(cm_node
->dev
,
3859 "Api - connect(): port=0x%04x, cm_node=%p, cm_id = %p.\n",
3867 i40iw_debug(&iwdev
->sc_dev
,
3869 "Api - connect() FAILED: dest addr=%pI4",
3872 i40iw_debug(&iwdev
->sc_dev
,
3874 "Api - connect() FAILED: dest addr=%pI6",
3878 i40iw_manage_qhash(iwdev
,
3880 I40IW_QHASH_TYPE_TCP_ESTABLISHED
,
3881 I40IW_QHASH_MANAGE_TYPE_DELETE
,
3885 if (apbvt_set
&& !i40iw_listen_port_in_use(&iwdev
->cm_core
,
3887 i40iw_manage_apbvt(iwdev
,
3889 I40IW_MANAGE_APBVT_DEL
);
3890 cm_id
->rem_ref(cm_id
);
3891 iwdev
->cm_core
.stats_connect_errs
++;
3896 * i40iw_create_listen - registered call creating listener
3897 * @cm_id: cm information for passive connection
3898 * @backlog: to max accept pending count
3900 int i40iw_create_listen(struct iw_cm_id
*cm_id
, int backlog
)
3902 struct i40iw_device
*iwdev
;
3903 struct i40iw_cm_listener
*cm_listen_node
;
3904 struct i40iw_cm_info cm_info
;
3905 enum i40iw_status_code ret
;
3906 struct sockaddr_in
*laddr
;
3907 struct sockaddr_in6
*laddr6
;
3908 bool wildcard
= false;
3910 iwdev
= to_iwdev(cm_id
->device
);
3914 laddr
= (struct sockaddr_in
*)&cm_id
->m_local_addr
;
3915 laddr6
= (struct sockaddr_in6
*)&cm_id
->m_local_addr
;
3916 memset(&cm_info
, 0, sizeof(cm_info
));
3917 if (laddr
->sin_family
== AF_INET
) {
3918 cm_info
.ipv4
= true;
3919 cm_info
.loc_addr
[0] = ntohl(laddr
->sin_addr
.s_addr
);
3920 cm_info
.loc_port
= ntohs(laddr
->sin_port
);
3922 if (laddr
->sin_addr
.s_addr
!= INADDR_ANY
)
3923 cm_info
.vlan_id
= i40iw_get_vlan_ipv4(cm_info
.loc_addr
);
3928 cm_info
.ipv4
= false;
3929 i40iw_copy_ip_ntohl(cm_info
.loc_addr
,
3930 laddr6
->sin6_addr
.in6_u
.u6_addr32
);
3931 cm_info
.loc_port
= ntohs(laddr6
->sin6_port
);
3932 if (ipv6_addr_type(&laddr6
->sin6_addr
) != IPV6_ADDR_ANY
)
3933 i40iw_netdev_vlan_ipv6(cm_info
.loc_addr
,
3939 cm_info
.backlog
= backlog
;
3940 cm_info
.cm_id
= cm_id
;
3942 cm_listen_node
= i40iw_make_listen_node(&iwdev
->cm_core
, iwdev
, &cm_info
);
3943 if (!cm_listen_node
) {
3944 i40iw_pr_err("cm_listen_node == NULL\n");
3948 cm_id
->provider_data
= cm_listen_node
;
3950 cm_listen_node
->tos
= cm_id
->tos
;
3951 cm_listen_node
->user_pri
= rt_tos2priority(cm_id
->tos
);
3952 cm_info
.user_pri
= cm_listen_node
->user_pri
;
3954 if (!cm_listen_node
->reused_node
) {
3957 ret
= i40iw_add_mqh_4(iwdev
,
3961 ret
= i40iw_add_mqh_6(iwdev
,
3967 ret
= i40iw_manage_apbvt(iwdev
,
3969 I40IW_MANAGE_APBVT_ADD
);
3974 ret
= i40iw_manage_qhash(iwdev
,
3976 I40IW_QHASH_TYPE_TCP_SYN
,
3977 I40IW_QHASH_MANAGE_TYPE_ADD
,
3982 cm_listen_node
->qhash_set
= true;
3983 ret
= i40iw_manage_apbvt(iwdev
,
3985 I40IW_MANAGE_APBVT_ADD
);
3990 cm_id
->add_ref(cm_id
);
3991 cm_listen_node
->cm_core
->stats_listen_created
++;
3994 i40iw_cm_del_listen(&iwdev
->cm_core
, (void *)cm_listen_node
, false);
3999 * i40iw_destroy_listen - registered call to destroy listener
4000 * @cm_id: cm information for passive connection
4002 int i40iw_destroy_listen(struct iw_cm_id
*cm_id
)
4004 struct i40iw_device
*iwdev
;
4006 iwdev
= to_iwdev(cm_id
->device
);
4007 if (cm_id
->provider_data
)
4008 i40iw_cm_del_listen(&iwdev
->cm_core
, cm_id
->provider_data
, true);
4010 i40iw_pr_err("cm_id->provider_data was NULL\n");
4012 cm_id
->rem_ref(cm_id
);
4018 * i40iw_cm_event_connected - handle connected active node
4019 * @event: the info for cm_node of connection
4021 static void i40iw_cm_event_connected(struct i40iw_cm_event
*event
)
4023 struct i40iw_qp
*iwqp
;
4024 struct i40iw_device
*iwdev
;
4025 struct i40iw_cm_node
*cm_node
;
4026 struct i40iw_sc_dev
*dev
;
4027 struct ib_qp_attr attr
;
4028 struct iw_cm_id
*cm_id
;
4032 cm_node
= event
->cm_node
;
4033 cm_id
= cm_node
->cm_id
;
4034 iwqp
= (struct i40iw_qp
*)cm_id
->provider_data
;
4035 iwdev
= to_iwdev(iwqp
->ibqp
.device
);
4036 dev
= &iwdev
->sc_dev
;
4038 if (iwqp
->destroyed
) {
4039 status
= -ETIMEDOUT
;
4042 i40iw_cm_init_tsa_conn(iwqp
, cm_node
);
4043 read0
= (cm_node
->send_rdma0_op
== SEND_RDMA_READ_ZERO
);
4045 iwqp
->sc_qp
.qp_uk
.sq_base
= kmap(iwqp
->page
);
4046 dev
->iw_priv_qp_ops
->qp_send_rtt(&iwqp
->sc_qp
, read0
);
4049 status
= i40iw_send_cm_event(cm_node
, cm_id
, IW_CM_EVENT_CONNECT_REPLY
, 0);
4051 i40iw_pr_err("send cm event\n");
4053 memset(&attr
, 0, sizeof(attr
));
4054 attr
.qp_state
= IB_QPS_RTS
;
4055 cm_node
->qhash_set
= false;
4056 i40iw_modify_qp(&iwqp
->ibqp
, &attr
, IB_QP_STATE
, NULL
);
4058 cm_node
->accelerated
= 1;
4059 if (cm_node
->accept_pend
) {
4060 if (!cm_node
->listener
)
4061 i40iw_pr_err("listener is null for passive node\n");
4062 atomic_dec(&cm_node
->listener
->pend_accepts_cnt
);
4063 cm_node
->accept_pend
= 0;
4069 cm_id
->provider_data
= NULL
;
4070 i40iw_send_cm_event(event
->cm_node
,
4072 IW_CM_EVENT_CONNECT_REPLY
,
4074 cm_id
->rem_ref(cm_id
);
4075 i40iw_rem_ref_cm_node(event
->cm_node
);
4079 * i40iw_cm_event_reset - handle reset
4080 * @event: the info for cm_node of connection
4082 static void i40iw_cm_event_reset(struct i40iw_cm_event
*event
)
4084 struct i40iw_cm_node
*cm_node
= event
->cm_node
;
4085 struct iw_cm_id
*cm_id
= cm_node
->cm_id
;
4086 struct i40iw_qp
*iwqp
;
4091 iwqp
= cm_id
->provider_data
;
4095 i40iw_debug(cm_node
->dev
,
4097 "reset event %p - cm_id = %p\n",
4098 event
->cm_node
, cm_id
);
4101 i40iw_send_cm_event(cm_node
, cm_node
->cm_id
, IW_CM_EVENT_DISCONNECT
, -ECONNRESET
);
4102 i40iw_send_cm_event(cm_node
, cm_node
->cm_id
, IW_CM_EVENT_CLOSE
, 0);
4106 * i40iw_cm_event_handler - worker thread callback to send event to cm upper layer
4107 * @work: pointer of cm event info.
4109 static void i40iw_cm_event_handler(struct work_struct
*work
)
4111 struct i40iw_cm_event
*event
= container_of(work
,
4112 struct i40iw_cm_event
,
4114 struct i40iw_cm_node
*cm_node
;
4116 if (!event
|| !event
->cm_node
|| !event
->cm_node
->cm_core
)
4119 cm_node
= event
->cm_node
;
4121 switch (event
->type
) {
4122 case I40IW_CM_EVENT_MPA_REQ
:
4123 i40iw_send_cm_event(cm_node
,
4125 IW_CM_EVENT_CONNECT_REQUEST
,
4128 case I40IW_CM_EVENT_RESET
:
4129 i40iw_cm_event_reset(event
);
4131 case I40IW_CM_EVENT_CONNECTED
:
4132 if (!event
->cm_node
->cm_id
||
4133 (event
->cm_node
->state
!= I40IW_CM_STATE_OFFLOADED
))
4135 i40iw_cm_event_connected(event
);
4137 case I40IW_CM_EVENT_MPA_REJECT
:
4138 if (!event
->cm_node
->cm_id
||
4139 (cm_node
->state
== I40IW_CM_STATE_OFFLOADED
))
4141 i40iw_send_cm_event(cm_node
,
4143 IW_CM_EVENT_CONNECT_REPLY
,
4146 case I40IW_CM_EVENT_ABORTED
:
4147 if (!event
->cm_node
->cm_id
||
4148 (event
->cm_node
->state
== I40IW_CM_STATE_OFFLOADED
))
4150 i40iw_event_connect_error(event
);
4153 i40iw_pr_err("event type = %d\n", event
->type
);
4157 event
->cm_info
.cm_id
->rem_ref(event
->cm_info
.cm_id
);
4158 i40iw_rem_ref_cm_node(event
->cm_node
);
4163 * i40iw_cm_post_event - queue event request for worker thread
4164 * @event: cm node's info for up event call
4166 static void i40iw_cm_post_event(struct i40iw_cm_event
*event
)
4168 atomic_inc(&event
->cm_node
->ref_count
);
4169 event
->cm_info
.cm_id
->add_ref(event
->cm_info
.cm_id
);
4170 INIT_WORK(&event
->event_work
, i40iw_cm_event_handler
);
4172 queue_work(event
->cm_node
->cm_core
->event_wq
, &event
->event_work
);
4176 * i40iw_qhash_ctrl - enable/disable qhash for list
4177 * @iwdev: device pointer
4178 * @parent_listen_node: parent listen node
4179 * @nfo: cm info node
4180 * @ipaddr: Pointer to IPv4 or IPv6 address
4181 * @ipv4: flag indicating IPv4 when true
4182 * @ifup: flag indicating interface up when true
4184 * Enables or disables the qhash for the node in the child
4185 * listen list that matches ipaddr. If no matching IP was found
4186 * it will allocate and add a new child listen node to the
4187 * parent listen node. The listen_list_lock is assumed to be
4190 static void i40iw_qhash_ctrl(struct i40iw_device
*iwdev
,
4191 struct i40iw_cm_listener
*parent_listen_node
,
4192 struct i40iw_cm_info
*nfo
,
4193 u32
*ipaddr
, bool ipv4
, bool ifup
)
4195 struct list_head
*child_listen_list
= &parent_listen_node
->child_listen_list
;
4196 struct i40iw_cm_listener
*child_listen_node
;
4197 struct list_head
*pos
, *tpos
;
4198 enum i40iw_status_code ret
;
4199 bool node_allocated
= false;
4200 enum i40iw_quad_hash_manage_type op
=
4201 ifup
? I40IW_QHASH_MANAGE_TYPE_ADD
: I40IW_QHASH_MANAGE_TYPE_DELETE
;
4203 list_for_each_safe(pos
, tpos
, child_listen_list
) {
4206 struct i40iw_cm_listener
,
4208 if (!memcmp(child_listen_node
->loc_addr
, ipaddr
, ipv4
? 4 : 16))
4212 /* if not found then add a child listener if interface is going up */
4215 child_listen_node
= kzalloc(sizeof(*child_listen_node
), GFP_ATOMIC
);
4216 if (!child_listen_node
)
4218 node_allocated
= true;
4219 memcpy(child_listen_node
, parent_listen_node
, sizeof(*child_listen_node
));
4221 memcpy(child_listen_node
->loc_addr
, ipaddr
, ipv4
? 4 : 16);
4224 memcpy(nfo
->loc_addr
,
4225 child_listen_node
->loc_addr
,
4226 sizeof(nfo
->loc_addr
));
4227 nfo
->vlan_id
= child_listen_node
->vlan_id
;
4228 ret
= i40iw_manage_qhash(iwdev
, nfo
,
4229 I40IW_QHASH_TYPE_TCP_SYN
,
4233 child_listen_node
->qhash_set
= ifup
;
4235 list_add(&child_listen_node
->child_listen_list
,
4236 &parent_listen_node
->child_listen_list
);
4237 } else if (node_allocated
) {
4238 kfree(child_listen_node
);
4243 * i40iw_cm_disconnect_all - disconnect all connected qp's
4244 * @iwdev: device pointer
4246 void i40iw_cm_disconnect_all(struct i40iw_device
*iwdev
)
4248 struct i40iw_cm_core
*cm_core
= &iwdev
->cm_core
;
4249 struct list_head
*list_core_temp
;
4250 struct list_head
*list_node
;
4251 struct i40iw_cm_node
*cm_node
;
4252 unsigned long flags
;
4253 struct list_head connected_list
;
4254 struct ib_qp_attr attr
;
4256 INIT_LIST_HEAD(&connected_list
);
4257 spin_lock_irqsave(&cm_core
->ht_lock
, flags
);
4258 list_for_each_safe(list_node
, list_core_temp
, &cm_core
->connected_nodes
) {
4259 cm_node
= container_of(list_node
, struct i40iw_cm_node
, list
);
4260 atomic_inc(&cm_node
->ref_count
);
4261 list_add(&cm_node
->connected_entry
, &connected_list
);
4263 spin_unlock_irqrestore(&cm_core
->ht_lock
, flags
);
4265 list_for_each_safe(list_node
, list_core_temp
, &connected_list
) {
4266 cm_node
= container_of(list_node
, struct i40iw_cm_node
, connected_entry
);
4267 attr
.qp_state
= IB_QPS_ERR
;
4268 i40iw_modify_qp(&cm_node
->iwqp
->ibqp
, &attr
, IB_QP_STATE
, NULL
);
4270 i40iw_cm_disconn(cm_node
->iwqp
);
4271 i40iw_rem_ref_cm_node(cm_node
);
4276 * i40iw_ifdown_notify - process an ifdown on an interface
4277 * @iwdev: device pointer
4278 * @ipaddr: Pointer to IPv4 or IPv6 address
4279 * @ipv4: flag indicating IPv4 when true
4280 * @ifup: flag indicating interface up when true
4282 void i40iw_if_notify(struct i40iw_device
*iwdev
, struct net_device
*netdev
,
4283 u32
*ipaddr
, bool ipv4
, bool ifup
)
4285 struct i40iw_cm_core
*cm_core
= &iwdev
->cm_core
;
4286 unsigned long flags
;
4287 struct i40iw_cm_listener
*listen_node
;
4288 static const u32 ip_zero
[4] = { 0, 0, 0, 0 };
4289 struct i40iw_cm_info nfo
;
4290 u16 vlan_id
= rdma_vlan_dev_vlan_id(netdev
);
4291 enum i40iw_status_code ret
;
4292 enum i40iw_quad_hash_manage_type op
=
4293 ifup
? I40IW_QHASH_MANAGE_TYPE_ADD
: I40IW_QHASH_MANAGE_TYPE_DELETE
;
4295 /* Disable or enable qhash for listeners */
4296 spin_lock_irqsave(&cm_core
->listen_list_lock
, flags
);
4297 list_for_each_entry(listen_node
, &cm_core
->listen_nodes
, list
) {
4298 if (vlan_id
== listen_node
->vlan_id
&&
4299 (!memcmp(listen_node
->loc_addr
, ipaddr
, ipv4
? 4 : 16) ||
4300 !memcmp(listen_node
->loc_addr
, ip_zero
, ipv4
? 4 : 16))) {
4301 memcpy(nfo
.loc_addr
, listen_node
->loc_addr
,
4302 sizeof(nfo
.loc_addr
));
4303 nfo
.loc_port
= listen_node
->loc_port
;
4304 nfo
.ipv4
= listen_node
->ipv4
;
4305 nfo
.vlan_id
= listen_node
->vlan_id
;
4306 nfo
.user_pri
= listen_node
->user_pri
;
4307 if (!list_empty(&listen_node
->child_listen_list
)) {
4308 i40iw_qhash_ctrl(iwdev
,
4311 ipaddr
, ipv4
, ifup
);
4312 } else if (memcmp(listen_node
->loc_addr
, ip_zero
,
4314 ret
= i40iw_manage_qhash(iwdev
,
4316 I40IW_QHASH_TYPE_TCP_SYN
,
4321 listen_node
->qhash_set
= ifup
;
4325 spin_unlock_irqrestore(&cm_core
->listen_list_lock
, flags
);
4327 /* disconnect any connected qp's on ifdown */
4329 i40iw_cm_disconnect_all(iwdev
);