]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/infiniband/hw/i40iw/i40iw_cm.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
i40iw: add files for iwarp interface
[mirror_ubuntu-artful-kernel.git] / drivers / infiniband / hw / i40iw / i40iw_cm.c
CommitLineData
f27b4746
FL		 1/*******************************************************************************
2*
3* Copyright (c) 2015-2016 Intel Corporation. All rights reserved.
4*
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:
10*
11* Redistribution and use in source and binary forms, with or
12* without modification, are permitted provided that the following
13* conditions are met:
14*
15* - Redistributions of source code must retain the above
16* copyright notice, this list of conditions and the following
17* disclaimer.
18*
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.
23*
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
31* SOFTWARE.
32*
33*******************************************************************************/
34
35#include <linux/atomic.h>
36#include <linux/ip.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>
53#include <net/arp.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>
60#include <net/tcp.h>
61#include <asm/checksum.h>
62
63#include "i40iw.h"
64
65static void i40iw_rem_ref_cm_node(struct i40iw_cm_node *);
66static void i40iw_cm_post_event(struct i40iw_cm_event *event);
67static void i40iw_disconnect_worker(struct work_struct *work);
68
69/**
70 * i40iw_free_sqbuf - put back puda buffer if refcount = 0
71 * @dev: FPK device
72 * @buf: puda buffer to free
73 */
74void i40iw_free_sqbuf(struct i40iw_sc_dev *dev, void *bufp)
75{
76 struct i40iw_puda_buf *buf = (struct i40iw_puda_buf *)bufp;
77 struct i40iw_puda_rsrc *ilq = dev->ilq;
78
79 if (!atomic_dec_return(&buf->refcount))
80 i40iw_puda_ret_bufpool(ilq, buf);
81}
82
83/**
84 * i40iw_derive_hw_ird_setting - Calculate IRD
85 *
86 * @cm_ird: IRD of connection's node
87 *
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
90 * qp_ctx
91 */
92static u8 i40iw_derive_hw_ird_setting(u16 cm_ird)
93{
94 u8 encoded_ird_size;
95 u8 pof2_cm_ird = 1;
96
97 /* round-off to next powerof2 */
98 while (pof2_cm_ird < cm_ird)
99 pof2_cm_ird *= 2;
100
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;
105 break;
106 case I40IW_HW_IRD_SETTING_32:
107 case I40IW_HW_IRD_SETTING_16:
108 encoded_ird_size = 2;
109 break;
110 case I40IW_HW_IRD_SETTING_8:
111 case I40IW_HW_IRD_SETTING_4:
112 encoded_ird_size = 1;
113 break;
114 case I40IW_HW_IRD_SETTING_2:
115 default:
116 encoded_ird_size = 0;
117 break;
118 }
119 return encoded_ird_size;
120}
121
122/**
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
127 */
128static void i40iw_record_ird_ord(struct i40iw_cm_node *cm_node, u16 conn_ird, u16 conn_ord)
129{
130 if (conn_ird > I40IW_MAX_IRD_SIZE)
131 conn_ird = I40IW_MAX_IRD_SIZE;
132
133 if (conn_ord > I40IW_MAX_ORD_SIZE)
134 conn_ord = I40IW_MAX_ORD_SIZE;
135
136 cm_node->ird_size = conn_ird;
137 cm_node->ord_size = conn_ord;
138}
139
140/**
141 * i40iw_copy_ip_ntohl - change network to host ip
142 * @dst: host ip
143 * @src: big endian
144 */
145void i40iw_copy_ip_ntohl(u32 *dst, __be32 *src)
146{
147 *dst++ = ntohl(*src++);
148 *dst++ = ntohl(*src++);
149 *dst++ = ntohl(*src++);
150 *dst = ntohl(*src);
151}
152
153/**
154 * i40iw_copy_ip_htonl - change host addr to network ip
155 * @dst: host ip
156 * @src: little endian
157 */
158static inline void i40iw_copy_ip_htonl(__be32 *dst, u32 *src)
159{
160 *dst++ = htonl(*src++);
161 *dst++ = htonl(*src++);
162 *dst++ = htonl(*src++);
163 *dst = htonl(*src);
164}
165
166/**
167 * i40iw_fill_sockaddr4 - get addr info for passive connection
168 * @cm_node: connection's node
169 * @event: upper layer's cm event
170 */
171static inline void i40iw_fill_sockaddr4(struct i40iw_cm_node *cm_node,
172 struct iw_cm_event *event)
173{
174 struct sockaddr_in *laddr = (struct sockaddr_in *)&event->local_addr;
175 struct sockaddr_in *raddr = (struct sockaddr_in *)&event->remote_addr;
176
177 laddr->sin_family = AF_INET;
178 raddr->sin_family = AF_INET;
179
180 laddr->sin_port = htons(cm_node->loc_port);
181 raddr->sin_port = htons(cm_node->rem_port);
182
183 laddr->sin_addr.s_addr = htonl(cm_node->loc_addr[0]);
184 raddr->sin_addr.s_addr = htonl(cm_node->rem_addr[0]);
185}
186
187/**
188 * i40iw_fill_sockaddr6 - get ipv6 addr info for passive side
189 * @cm_node: connection's node
190 * @event: upper layer's cm event
191 */
192static inline void i40iw_fill_sockaddr6(struct i40iw_cm_node *cm_node,
193 struct iw_cm_event *event)
194{
195 struct sockaddr_in6 *laddr6 = (struct sockaddr_in6 *)&event->local_addr;
196 struct sockaddr_in6 *raddr6 = (struct sockaddr_in6 *)&event->remote_addr;
197
198 laddr6->sin6_family = AF_INET6;
199 raddr6->sin6_family = AF_INET6;
200
201 laddr6->sin6_port = htons(cm_node->loc_port);
202 raddr6->sin6_port = htons(cm_node->rem_port);
203
204 i40iw_copy_ip_htonl(laddr6->sin6_addr.in6_u.u6_addr32,
205 cm_node->loc_addr);
206 i40iw_copy_ip_htonl(raddr6->sin6_addr.in6_u.u6_addr32,
207 cm_node->rem_addr);
208}
209
210/**
211 * i40iw_set_sockaddr - Record ip addr and tcp port in a sockaddr storage
212 * @ip_addr: v4/v6 ip addr
213 * @port: tcp port
214 * @addr: sockaddr to store ip/tcp info
215 */
216static void i40iw_set_sockaddr(u32 *ip_addr,
217 u16 port,
218 struct sockaddr_storage *addr,
219 bool ipv4)
220{
221 if (ipv4) {
222 struct sockaddr_in *in4_addr = (struct sockaddr_in *)addr;
223
224 in4_addr->sin_family = AF_INET;
225 in4_addr->sin_addr.s_addr = htonl(ip_addr[0]);
226 in4_addr->sin_port = htons(port);
227 } else {
228 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)addr;
229
230 in6_addr->sin6_family = AF_INET6;
231 i40iw_copy_ip_htonl(in6_addr->sin6_addr.in6_u.u6_addr32,
232 ip_addr);
233 in6_addr->sin6_port = htons(port);
234 }
235}
236
237/**
238 * i40iw_get_sockaddr - Get ip addr and tcp port from a sockaddr storage
239 * @addr: sockaddr to get ip/tcp info
240 * @ip_addr: v4/v6 ip addr
241 * @port: tcp port
242 */
243static void i40iw_get_addrinfo(struct sockaddr_storage *addr, u32 *ip_addr, u16 *port)
244{
245 if (addr->ss_family == AF_INET) {
246 struct sockaddr_in *in4_addr = (struct sockaddr_in *)addr;
247
248 ip_addr[0] = ntohl(in4_addr->sin_addr.s_addr);
249 *port = ntohs(in4_addr->sin_port);
250 } else {
251 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)addr;
252
253 i40iw_copy_ip_ntohl(ip_addr,
254 in6_addr->sin6_addr.in6_u.u6_addr32);
255 *port = ntohs(in6_addr->sin6_port);
256 }
257}
258
259/**
260 * i40iw_is_wildcard - Check if it is a wildcard ip address
261 * @addr: sockaddr containing the ip to check
262 */
263static bool i40iw_is_wildcard(struct sockaddr_storage *addr)
264{
265 if (addr->ss_family == AF_INET) {
266 struct sockaddr_in *in4_addr = (struct sockaddr_in *)addr;
267
268 return (in4_addr->sin_addr.s_addr == INADDR_ANY);
269 } else {
270 struct sockaddr_in6 *in6_addr = (struct sockaddr_in6 *)addr;
271
272 return (ipv6_addr_type(&in6_addr->sin6_addr) == IPV6_ADDR_ANY);
273 }
274}
275
276/**
277 * i40iw_create_mapinfo - Create a mapinfo object in the port mapper data base
278 * @cm_info: contains ip/tcp info
279 */
280static int i40iw_create_mapinfo(struct i40iw_cm_info *cm_info)
281{
282 struct sockaddr_storage local_sockaddr;
283 struct sockaddr_storage mapped_sockaddr;
284
285 i40iw_set_sockaddr(cm_info->loc_addr, cm_info->loc_port,
286 &local_sockaddr, cm_info->ipv4);
287 i40iw_set_sockaddr(cm_info->map_loc_addr, cm_info->map_loc_port,
288 &mapped_sockaddr, cm_info->ipv4);
289 return iwpm_create_mapinfo(&local_sockaddr,
290 &mapped_sockaddr,
291 RDMA_NL_I40IW);
292}
293
294/**
295 * i40iw_remove_mapinfo - Remove a mapinfo object
296 * @cm_info: contains ip/tcp info
297 *
298 * Removes a mapinfo object from the port mapper data base
299 * and sends a remove mapping message to the userspace port mapper
300 */
301static int i40iw_remove_mapinfo(struct i40iw_cm_info *cm_info)
302{
303 struct sockaddr_storage local_sockaddr;
304 struct sockaddr_storage mapped_sockaddr;
305
306 i40iw_set_sockaddr(cm_info->loc_addr, cm_info->loc_port,
307 &local_sockaddr, cm_info->ipv4);
308 i40iw_set_sockaddr(cm_info->map_loc_addr, cm_info->map_loc_port,
309 &mapped_sockaddr, cm_info->ipv4);
310
311 iwpm_remove_mapinfo(&local_sockaddr, &mapped_sockaddr);
312 return iwpm_remove_mapping(&local_sockaddr, RDMA_NL_I40IW);
313}
314
315/**
316 * i40iw_form_reg_msg - Form a port mapper message with dev info
317 * @iwdev: iWarp device
318 * @pm_msg: msg to record device data
319 */
320static void i40iw_form_reg_msg(struct i40iw_device *iwdev, struct iwpm_dev_data *pm_msg)
321{
322 memcpy(pm_msg->dev_name, iwdev->iwibdev->ibdev.name, IWPM_DEVNAME_SIZE);
323 memcpy(pm_msg->if_name, iwdev->netdev->name, IWPM_IFNAME_SIZE);
324}
325
326/**
327 * i40iw_form_pm_msg - Form a port mapper message with mapping info
328 * @cm_info: contains ip/tcp info
329 * @pm_msg: msg to record ip/tcp info
330 */
331static void i40iw_form_pm_msg(struct i40iw_cm_info *cm_info,
332 struct iwpm_sa_data *pm_msg)
333{
334 i40iw_set_sockaddr(cm_info->loc_addr, cm_info->loc_port,
335 &pm_msg->loc_addr, cm_info->ipv4);
336 i40iw_set_sockaddr(cm_info->rem_addr, cm_info->rem_port,
337 &pm_msg->rem_addr, cm_info->ipv4);
338}
339
340/**
341 * i40iw_record_pm_msg - Record the received mapping info
342 * @cm_info: ip/tcp info to be updated with mapped info
343 * @pm_msg: received msg with mapped ip/tcp
344 */
345static void i40iw_record_pm_msg(struct i40iw_cm_info *cm_info,
346 struct iwpm_sa_data *pm_msg,
347 bool remote)
348{
349 i40iw_get_addrinfo(&pm_msg->mapped_loc_addr,
350 cm_info->map_loc_addr,
351 &cm_info->map_loc_port);
352 if (remote) {
353 i40iw_get_addrinfo(&pm_msg->mapped_rem_addr,
354 cm_info->map_rem_addr, &cm_info->map_rem_port);
355 if (i40iw_is_wildcard(&pm_msg->mapped_rem_addr))
356 memcpy(cm_info->map_rem_addr, cm_info->rem_addr,
357 sizeof(cm_info->map_rem_addr));
358 }
359}
360
361/**
362 * i40iw_get_reminfo - Get the address info of the remote connecting peer
363 * @cm_node: provides mapped ip/tcp info (local and remote)
364 *
365 * Gets the actual non-mapped ip/tcp info of the remote connecting peer
366 * from the port mapper data base
367 */
368static int i40iw_get_remote_addr(struct i40iw_cm_node *cm_node)
369{
370 struct sockaddr_storage mapped_loc_addr, mapped_rem_addr;
371 struct sockaddr_storage remote_addr;
372 int ret;
373
374 i40iw_set_sockaddr(cm_node->map_loc_addr,
375 cm_node->map_loc_port,
376 &mapped_loc_addr,
377 cm_node->ipv4);
378 i40iw_set_sockaddr(cm_node->map_rem_addr,
379 cm_node->map_rem_port,
380 &mapped_rem_addr,
381 cm_node->ipv4);
382 ret = iwpm_get_remote_info(&mapped_loc_addr,
383 &mapped_rem_addr,
384 &remote_addr,
385 RDMA_NL_I40IW);
386 if (ret)
387 i40iw_debug(cm_node->dev,
388 I40IW_DEBUG_CM,
389 "Unable to find remote peer address info\n");
390 else
391 i40iw_get_addrinfo(&remote_addr,
392 cm_node->rem_addr,
393 &cm_node->rem_port);
394 return ret;
395}
396
397/**
398 * i40iw_init_mapinfo - Initialize the mapped ip/tcp info
399 * @cm_info: ip/tcp info (actual and mapped)
400*/
401static void i40iw_init_mapinfo(struct i40iw_cm_info *cm_info)
402{
403 memcpy(cm_info->map_loc_addr, cm_info->loc_addr,
404 sizeof(cm_info->map_loc_addr));
405 memcpy(cm_info->map_rem_addr, cm_info->rem_addr,
406 sizeof(cm_info->map_rem_addr));
407 cm_info->map_loc_port = cm_info->loc_port;
408 cm_info->map_rem_port = cm_info->rem_port;
409}
410
411/**
412 * i40iw_get_addr_info
413 * @cm_node: contains ip/tcp info
414 * @cm_info: to get a copy of the cm_node ip/tcp info
415*/
416static void i40iw_get_addr_info(struct i40iw_cm_node *cm_node,
417 struct i40iw_cm_info *cm_info)
418{
419 cm_info->ipv4 = cm_node->ipv4;
420 cm_info->vlan_id = cm_node->vlan_id;
421 memcpy(cm_info->loc_addr, cm_node->loc_addr, sizeof(cm_info->loc_addr));
422 memcpy(cm_info->rem_addr, cm_node->rem_addr, sizeof(cm_info->rem_addr));
423 memcpy(cm_info->map_loc_addr, cm_node->map_loc_addr, sizeof(cm_info->map_loc_addr));
424 memcpy(cm_info->map_rem_addr, cm_node->map_rem_addr, sizeof(cm_info->map_rem_addr));
425 cm_info->loc_port = cm_node->loc_port;
426 cm_info->rem_port = cm_node->rem_port;
427 cm_info->map_loc_port = cm_node->map_loc_port;
428 cm_info->map_rem_port = cm_node->map_rem_port;
429}
430
431/**
432 * i40iw_get_cmevent_info - for cm event upcall
433 * @cm_node: connection's node
434 * @cm_id: upper layers cm struct for the event
435 * @event: upper layer's cm event
436 */
437static inline void i40iw_get_cmevent_info(struct i40iw_cm_node *cm_node,
438 struct iw_cm_id *cm_id,
439 struct iw_cm_event *event)
440{
441 memcpy(&event->local_addr, &cm_id->local_addr,
442 sizeof(event->local_addr));
443 memcpy(&event->remote_addr, &cm_id->remote_addr,
444 sizeof(event->remote_addr));
445 if (cm_node) {
446 event->private_data = (void *)cm_node->pdata_buf;
447 event->private_data_len = (u8)cm_node->pdata.size;
448 event->ird = cm_node->ird_size;
449 event->ord = cm_node->ord_size;
450 }
451}
452
453/**
454 * i40iw_send_cm_event - upcall cm's event handler
455 * @cm_node: connection's node
456 * @cm_id: upper layer's cm info struct
457 * @type: Event type to indicate
458 * @status: status for the event type
459 */
460static int i40iw_send_cm_event(struct i40iw_cm_node *cm_node,
461 struct iw_cm_id *cm_id,
462 enum iw_cm_event_type type,
463 int status)
464{
465 struct iw_cm_event event;
466
467 memset(&event, 0, sizeof(event));
468 event.event = type;
469 event.status = status;
470 switch (type) {
471 case IW_CM_EVENT_CONNECT_REQUEST:
472 if (cm_node->ipv4)
473 i40iw_fill_sockaddr4(cm_node, &event);
474 else
475 i40iw_fill_sockaddr6(cm_node, &event);
476 event.provider_data = (void *)cm_node;
477 event.private_data = (void *)cm_node->pdata_buf;
478 event.private_data_len = (u8)cm_node->pdata.size;
479 break;
480 case IW_CM_EVENT_CONNECT_REPLY:
481 i40iw_get_cmevent_info(cm_node, cm_id, &event);
482 break;
483 case IW_CM_EVENT_ESTABLISHED:
484 event.ird = cm_node->ird_size;
485 event.ord = cm_node->ord_size;
486 break;
487 case IW_CM_EVENT_DISCONNECT:
488 break;
489 case IW_CM_EVENT_CLOSE:
490 break;
491 default:
492 i40iw_pr_err("event type received type = %d\n", type);
493 return -1;
494 }
495 return cm_id->event_handler(cm_id, &event);
496}
497
498/**
499 * i40iw_create_event - create cm event
500 * @cm_node: connection's node
501 * @type: Event type to generate
502 */
503static struct i40iw_cm_event *i40iw_create_event(struct i40iw_cm_node *cm_node,
504 enum i40iw_cm_event_type type)
505{
506 struct i40iw_cm_event *event;
507
508 if (!cm_node->cm_id)
509 return NULL;
510
511 event = kzalloc(sizeof(*event), GFP_ATOMIC);
512
513 if (!event)
514 return NULL;
515
516 event->type = type;
517 event->cm_node = cm_node;
518 memcpy(event->cm_info.rem_addr, cm_node->rem_addr, sizeof(event->cm_info.rem_addr));
519 memcpy(event->cm_info.loc_addr, cm_node->loc_addr, sizeof(event->cm_info.loc_addr));
520 event->cm_info.rem_port = cm_node->rem_port;
521 event->cm_info.loc_port = cm_node->loc_port;
522 event->cm_info.cm_id = cm_node->cm_id;
523
524 i40iw_debug(cm_node->dev,
525 I40IW_DEBUG_CM,
526 "node=%p event=%p type=%u dst=%pI4 src=%pI4\n",
527 cm_node,
528 event,
529 type,
530 event->cm_info.loc_addr,
531 event->cm_info.rem_addr);
532
533 i40iw_cm_post_event(event);
534 return event;
535}
536
537/**
538 * i40iw_free_retrans_entry - free send entry
539 * @cm_node: connection's node
540 */
541static void i40iw_free_retrans_entry(struct i40iw_cm_node *cm_node)
542{
543 struct i40iw_sc_dev *dev = cm_node->dev;
544 struct i40iw_timer_entry *send_entry;
545
546 send_entry = cm_node->send_entry;
547 if (send_entry) {
548 cm_node->send_entry = NULL;
549 i40iw_free_sqbuf(dev, (void *)send_entry->sqbuf);
550 kfree(send_entry);
551 atomic_dec(&cm_node->ref_count);
552 }
553}
554
555/**
556 * i40iw_cleanup_retrans_entry - free send entry with lock
557 * @cm_node: connection's node
558 */
559static void i40iw_cleanup_retrans_entry(struct i40iw_cm_node *cm_node)
560{
561 unsigned long flags;
562
563 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
564 i40iw_free_retrans_entry(cm_node);
565 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
566}
567
568static bool is_remote_ne020_or_chelsio(struct i40iw_cm_node *cm_node)
569{
570 if ((cm_node->rem_mac[0] == 0x0) &&
571 (((cm_node->rem_mac[1] == 0x12) && (cm_node->rem_mac[2] == 0x55)) ||
572 ((cm_node->rem_mac[1] == 0x07 && (cm_node->rem_mac[2] == 0x43)))))
573 return true;
574 return false;
575}
576
577/**
578 * i40iw_form_cm_frame - get a free packet and build frame
579 * @cm_node: connection's node ionfo to use in frame
580 * @options: pointer to options info
581 * @hdr: pointer mpa header
582 * @pdata: pointer to private data
583 * @flags: indicates FIN or ACK
584 */
585static struct i40iw_puda_buf *i40iw_form_cm_frame(struct i40iw_cm_node *cm_node,
586 struct i40iw_kmem_info *options,
587 struct i40iw_kmem_info *hdr,
588 struct i40iw_kmem_info *pdata,
589 u8 flags)
590{
591 struct i40iw_puda_buf *sqbuf;
592 struct i40iw_sc_dev *dev = cm_node->dev;
593 u8 *buf;
594
595 struct tcphdr *tcph;
596 struct iphdr *iph;
597 struct ipv6hdr *ip6h;
598 struct ethhdr *ethh;
599 u16 packetsize;
600 u16 eth_hlen = ETH_HLEN;
601 u32 opts_len = 0;
602 u32 pd_len = 0;
603 u32 hdr_len = 0;
604
605 sqbuf = i40iw_puda_get_bufpool(dev->ilq);
606 if (!sqbuf)
607 return NULL;
608 buf = sqbuf->mem.va;
609
610 if (options)
611 opts_len = (u32)options->size;
612
613 if (hdr)
614 hdr_len = hdr->size;
615
616 if (pdata) {
617 pd_len = pdata->size;
618 if (!is_remote_ne020_or_chelsio(cm_node))
619 pd_len += MPA_ZERO_PAD_LEN;
620 }
621
622 if (cm_node->vlan_id < VLAN_TAG_PRESENT)
623 eth_hlen += 4;
624
625 if (cm_node->ipv4)
626 packetsize = sizeof(*iph) + sizeof(*tcph);
627 else
628 packetsize = sizeof(*ip6h) + sizeof(*tcph);
629 packetsize += opts_len + hdr_len + pd_len;
630
631 memset(buf, 0x00, eth_hlen + packetsize);
632
633 sqbuf->totallen = packetsize + eth_hlen;
634 sqbuf->maclen = eth_hlen;
635 sqbuf->tcphlen = sizeof(*tcph) + opts_len;
636 sqbuf->scratch = (void *)cm_node;
637
638 ethh = (struct ethhdr *)buf;
639 buf += eth_hlen;
640
641 if (cm_node->ipv4) {
642 sqbuf->ipv4 = true;
643
644 iph = (struct iphdr *)buf;
645 buf += sizeof(*iph);
646 tcph = (struct tcphdr *)buf;
647 buf += sizeof(*tcph);
648
649 ether_addr_copy(ethh->h_dest, cm_node->rem_mac);
650 ether_addr_copy(ethh->h_source, cm_node->loc_mac);
651 if (cm_node->vlan_id < VLAN_TAG_PRESENT) {
652 ((struct vlan_ethhdr *)ethh)->h_vlan_proto = htons(ETH_P_8021Q);
653 ((struct vlan_ethhdr *)ethh)->h_vlan_TCI = htons(cm_node->vlan_id);
654
655 ((struct vlan_ethhdr *)ethh)->h_vlan_encapsulated_proto = htons(ETH_P_IP);
656 } else {
657 ethh->h_proto = htons(ETH_P_IP);
658 }
659
660 iph->version = IPVERSION;
661 iph->ihl = 5; /* 5 * 4Byte words, IP headr len */
662 iph->tos = 0;
663 iph->tot_len = htons(packetsize);
664 iph->id = htons(++cm_node->tcp_cntxt.loc_id);
665
666 iph->frag_off = htons(0x4000);
667 iph->ttl = 0x40;
668 iph->protocol = IPPROTO_TCP;
669
670 iph->saddr = htonl(cm_node->map_loc_addr[0]);
671 iph->daddr = htonl(cm_node->map_rem_addr[0]);
672 } else {
673 sqbuf->ipv4 = false;
674 ip6h = (struct ipv6hdr *)buf;
675 buf += sizeof(*ip6h);
676 tcph = (struct tcphdr *)buf;
677 buf += sizeof(*tcph);
678
679 ether_addr_copy(ethh->h_dest, cm_node->rem_mac);
680 ether_addr_copy(ethh->h_source, cm_node->loc_mac);
681 if (cm_node->vlan_id < VLAN_TAG_PRESENT) {
682 ((struct vlan_ethhdr *)ethh)->h_vlan_proto = htons(ETH_P_8021Q);
683 ((struct vlan_ethhdr *)ethh)->h_vlan_TCI = htons(cm_node->vlan_id);
684 ((struct vlan_ethhdr *)ethh)->h_vlan_encapsulated_proto = htons(ETH_P_IPV6);
685 } else {
686 ethh->h_proto = htons(ETH_P_IPV6);
687 }
688 ip6h->version = 6;
689 ip6h->flow_lbl[0] = 0;
690 ip6h->flow_lbl[1] = 0;
691 ip6h->flow_lbl[2] = 0;
692 ip6h->payload_len = htons(packetsize - sizeof(*ip6h));
693 ip6h->nexthdr = 6;
694 ip6h->hop_limit = 128;
695
696 i40iw_copy_ip_htonl(ip6h->saddr.in6_u.u6_addr32,
697 cm_node->map_loc_addr);
698 i40iw_copy_ip_htonl(ip6h->daddr.in6_u.u6_addr32,
699 cm_node->map_rem_addr);
700 }
701
702 tcph->source = htons(cm_node->map_loc_port);
703 tcph->dest = htons(cm_node->map_rem_port);
704
705 tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num);
706
707 if (flags & SET_ACK) {
708 cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt;
709 tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num);
710 tcph->ack = 1;
711 } else {
712 tcph->ack_seq = 0;
713 }
714
715 if (flags & SET_SYN) {
716 cm_node->tcp_cntxt.loc_seq_num++;
717 tcph->syn = 1;
718 } else {
719 cm_node->tcp_cntxt.loc_seq_num += hdr_len + pd_len;
720 }
721
722 if (flags & SET_FIN) {
723 cm_node->tcp_cntxt.loc_seq_num++;
724 tcph->fin = 1;
725 }
726
727 if (flags & SET_RST)
728 tcph->rst = 1;
729
730 tcph->doff = (u16)((sizeof(*tcph) + opts_len + 3) >> 2);
731 sqbuf->tcphlen = tcph->doff << 2;
732 tcph->window = htons(cm_node->tcp_cntxt.rcv_wnd);
733 tcph->urg_ptr = 0;
734
735 if (opts_len) {
736 memcpy(buf, options->addr, opts_len);
737 buf += opts_len;
738 }
739
740 if (hdr_len) {
741 memcpy(buf, hdr->addr, hdr_len);
742 buf += hdr_len;
743 }
744
745 if (pd_len)
746 memcpy(buf, pdata->addr, pd_len);
747
748 atomic_set(&sqbuf->refcount, 1);
749
750 return sqbuf;
751}
752
753/**
754 * i40iw_send_reset - Send RST packet
755 * @cm_node: connection's node
756 */
757static int i40iw_send_reset(struct i40iw_cm_node *cm_node)
758{
759 struct i40iw_puda_buf *sqbuf;
760 int flags = SET_RST | SET_ACK;
761
762 sqbuf = i40iw_form_cm_frame(cm_node, NULL, NULL, NULL, flags);
763 if (!sqbuf) {
764 i40iw_pr_err("no sqbuf\n");
765 return -1;
766 }
767
768 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 0, 1);
769}
770
771/**
772 * i40iw_active_open_err - send event for active side cm error
773 * @cm_node: connection's node
774 * @reset: Flag to send reset or not
775 */
776static void i40iw_active_open_err(struct i40iw_cm_node *cm_node, bool reset)
777{
778 i40iw_cleanup_retrans_entry(cm_node);
779 cm_node->cm_core->stats_connect_errs++;
780 if (reset) {
781 i40iw_debug(cm_node->dev,
782 I40IW_DEBUG_CM,
783 "%s cm_node=%p state=%d\n",
784 __func__,
785 cm_node,
786 cm_node->state);
787 atomic_inc(&cm_node->ref_count);
788 i40iw_send_reset(cm_node);
789 }
790
791 cm_node->state = I40IW_CM_STATE_CLOSED;
792 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
793}
794
795/**
796 * i40iw_passive_open_err - handle passive side cm error
797 * @cm_node: connection's node
798 * @reset: send reset or just free cm_node
799 */
800static void i40iw_passive_open_err(struct i40iw_cm_node *cm_node, bool reset)
801{
802 i40iw_cleanup_retrans_entry(cm_node);
803 cm_node->cm_core->stats_passive_errs++;
804 cm_node->state = I40IW_CM_STATE_CLOSED;
805 i40iw_debug(cm_node->dev,
806 I40IW_DEBUG_CM,
807 "%s cm_node=%p state =%d\n",
808 __func__,
809 cm_node,
810 cm_node->state);
811 if (reset)
812 i40iw_send_reset(cm_node);
813 else
814 i40iw_rem_ref_cm_node(cm_node);
815}
816
817/**
818 * i40iw_event_connect_error - to create connect error event
819 * @event: cm information for connect event
820 */
821static void i40iw_event_connect_error(struct i40iw_cm_event *event)
822{
823 struct i40iw_qp *iwqp;
824 struct iw_cm_id *cm_id;
825
826 cm_id = event->cm_node->cm_id;
827 if (!cm_id)
828 return;
829
830 iwqp = cm_id->provider_data;
831
832 if (!iwqp || !iwqp->iwdev)
833 return;
834
835 iwqp->cm_id = NULL;
836 cm_id->provider_data = NULL;
837 i40iw_send_cm_event(event->cm_node, cm_id,
838 IW_CM_EVENT_CONNECT_REPLY,
839 -ECONNRESET);
840 cm_id->rem_ref(cm_id);
841 i40iw_rem_ref_cm_node(event->cm_node);
842}
843
844/**
845 * i40iw_process_options
846 * @cm_node: connection's node
847 * @optionsloc: point to start of options
848 * @optionsize: size of all options
849 * @syn_packet: flag if syn packet
850 */
851static int i40iw_process_options(struct i40iw_cm_node *cm_node,
852 u8 *optionsloc,
853 u32 optionsize,
854 u32 syn_packet)
855{
856 u32 tmp;
857 u32 offset = 0;
858 union all_known_options *all_options;
859 char got_mss_option = 0;
860
861 while (offset < optionsize) {
862 all_options = (union all_known_options *)(optionsloc + offset);
863 switch (all_options->as_base.optionnum) {
864 case OPTION_NUMBER_END:
865 offset = optionsize;
866 break;
867 case OPTION_NUMBER_NONE:
868 offset += 1;
869 continue;
870 case OPTION_NUMBER_MSS:
871 i40iw_debug(cm_node->dev,
872 I40IW_DEBUG_CM,
873 "%s: MSS Length: %d Offset: %d Size: %d\n",
874 __func__,
875 all_options->as_mss.length,
876 offset,
877 optionsize);
878 got_mss_option = 1;
879 if (all_options->as_mss.length != 4)
880 return -1;
881 tmp = ntohs(all_options->as_mss.mss);
882 if (tmp > 0 && tmp < cm_node->tcp_cntxt.mss)
883 cm_node->tcp_cntxt.mss = tmp;
884 break;
885 case OPTION_NUMBER_WINDOW_SCALE:
886 cm_node->tcp_cntxt.snd_wscale =
887 all_options->as_windowscale.shiftcount;
888 break;
889 default:
890 i40iw_debug(cm_node->dev,
891 I40IW_DEBUG_CM,
892 "TCP Option not understood: %x\n",
893 all_options->as_base.optionnum);
894 break;
895 }
896 offset += all_options->as_base.length;
897 }
898 if (!got_mss_option && syn_packet)
899 cm_node->tcp_cntxt.mss = I40IW_CM_DEFAULT_MSS;
900 return 0;
901}
902
903/**
904 * i40iw_handle_tcp_options -
905 * @cm_node: connection's node
906 * @tcph: pointer tcp header
907 * @optionsize: size of options rcvd
908 * @passive: active or passive flag
909 */
910static int i40iw_handle_tcp_options(struct i40iw_cm_node *cm_node,
911 struct tcphdr *tcph,
912 int optionsize,
913 int passive)
914{
915 u8 *optionsloc = (u8 *)&tcph[1];
916
917 if (optionsize) {
918 if (i40iw_process_options(cm_node,
919 optionsloc,
920 optionsize,
921 (u32)tcph->syn)) {
922 i40iw_debug(cm_node->dev,
923 I40IW_DEBUG_CM,
924 "%s: Node %p, Sending RESET\n",
925 __func__,
926 cm_node);
927 if (passive)
928 i40iw_passive_open_err(cm_node, true);
929 else
930 i40iw_active_open_err(cm_node, true);
931 return -1;
932 }
933 }
934
935 cm_node->tcp_cntxt.snd_wnd = ntohs(tcph->window) <<
936 cm_node->tcp_cntxt.snd_wscale;
937
938 if (cm_node->tcp_cntxt.snd_wnd > cm_node->tcp_cntxt.max_snd_wnd)
939 cm_node->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.snd_wnd;
940 return 0;
941}
942
943/**
944 * i40iw_build_mpa_v1 - build a MPA V1 frame
945 * @cm_node: connection's node
946 * @mpa_key: to do read0 or write0
947 */
948static void i40iw_build_mpa_v1(struct i40iw_cm_node *cm_node,
949 void *start_addr,
950 u8 mpa_key)
951{
952 struct ietf_mpa_v1 *mpa_frame = (struct ietf_mpa_v1 *)start_addr;
953
954 switch (mpa_key) {
955 case MPA_KEY_REQUEST:
956 memcpy(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE);
957 break;
958 case MPA_KEY_REPLY:
959 memcpy(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE);
960 break;
961 default:
962 break;
963 }
964 mpa_frame->flags = IETF_MPA_FLAGS_CRC;
965 mpa_frame->rev = cm_node->mpa_frame_rev;
966 mpa_frame->priv_data_len = htons(cm_node->pdata.size);
967}
968
969/**
970 * i40iw_build_mpa_v2 - build a MPA V2 frame
971 * @cm_node: connection's node
972 * @start_addr: buffer start address
973 * @mpa_key: to do read0 or write0
974 */
975static void i40iw_build_mpa_v2(struct i40iw_cm_node *cm_node,
976 void *start_addr,
977 u8 mpa_key)
978{
979 struct ietf_mpa_v2 *mpa_frame = (struct ietf_mpa_v2 *)start_addr;
980 struct ietf_rtr_msg *rtr_msg = &mpa_frame->rtr_msg;
981
982 /* initialize the upper 5 bytes of the frame */
983 i40iw_build_mpa_v1(cm_node, start_addr, mpa_key);
984 mpa_frame->flags |= IETF_MPA_V2_FLAG;
985 mpa_frame->priv_data_len += htons(IETF_RTR_MSG_SIZE);
986
987 /* initialize RTR msg */
988 if (cm_node->mpav2_ird_ord == IETF_NO_IRD_ORD) {
989 rtr_msg->ctrl_ird = IETF_NO_IRD_ORD;
990 rtr_msg->ctrl_ord = IETF_NO_IRD_ORD;
991 } else {
992 rtr_msg->ctrl_ird = (cm_node->ird_size > IETF_NO_IRD_ORD) ?
993 IETF_NO_IRD_ORD : cm_node->ird_size;
994 rtr_msg->ctrl_ord = (cm_node->ord_size > IETF_NO_IRD_ORD) ?
995 IETF_NO_IRD_ORD : cm_node->ord_size;
996 }
997
998 rtr_msg->ctrl_ird |= IETF_PEER_TO_PEER;
999 rtr_msg->ctrl_ird |= IETF_FLPDU_ZERO_LEN;
1000
1001 switch (mpa_key) {
1002 case MPA_KEY_REQUEST:
1003 rtr_msg->ctrl_ord |= IETF_RDMA0_WRITE;
1004 rtr_msg->ctrl_ord |= IETF_RDMA0_READ;
1005 break;
1006 case MPA_KEY_REPLY:
1007 switch (cm_node->send_rdma0_op) {
1008 case SEND_RDMA_WRITE_ZERO:
1009 rtr_msg->ctrl_ord |= IETF_RDMA0_WRITE;
1010 break;
1011 case SEND_RDMA_READ_ZERO:
1012 rtr_msg->ctrl_ord |= IETF_RDMA0_READ;
1013 break;
1014 }
1015 break;
1016 default:
1017 break;
1018 }
1019 rtr_msg->ctrl_ird = htons(rtr_msg->ctrl_ird);
1020 rtr_msg->ctrl_ord = htons(rtr_msg->ctrl_ord);
1021}
1022
1023/**
1024 * i40iw_cm_build_mpa_frame - build mpa frame for mpa version 1 or version 2
1025 * @cm_node: connection's node
1026 * @mpa: mpa: data buffer
1027 * @mpa_key: to do read0 or write0
1028 */
1029static int i40iw_cm_build_mpa_frame(struct i40iw_cm_node *cm_node,
1030 struct i40iw_kmem_info *mpa,
1031 u8 mpa_key)
1032{
1033 int hdr_len = 0;
1034
1035 switch (cm_node->mpa_frame_rev) {
1036 case IETF_MPA_V1:
1037 hdr_len = sizeof(struct ietf_mpa_v1);
1038 i40iw_build_mpa_v1(cm_node, mpa->addr, mpa_key);
1039 break;
1040 case IETF_MPA_V2:
1041 hdr_len = sizeof(struct ietf_mpa_v2);
1042 i40iw_build_mpa_v2(cm_node, mpa->addr, mpa_key);
1043 break;
1044 default:
1045 break;
1046 }
1047
1048 return hdr_len;
1049}
1050
1051/**
1052 * i40iw_send_mpa_request - active node send mpa request to passive node
1053 * @cm_node: connection's node
1054 */
1055static int i40iw_send_mpa_request(struct i40iw_cm_node *cm_node)
1056{
1057 struct i40iw_puda_buf *sqbuf;
1058
1059 if (!cm_node) {
1060 i40iw_pr_err("cm_node == NULL\n");
1061 return -1;
1062 }
1063
1064 cm_node->mpa_hdr.addr = &cm_node->mpa_frame;
1065 cm_node->mpa_hdr.size = i40iw_cm_build_mpa_frame(cm_node,
1066 &cm_node->mpa_hdr,
1067 MPA_KEY_REQUEST);
1068 if (!cm_node->mpa_hdr.size) {
1069 i40iw_pr_err("mpa size = %d\n", cm_node->mpa_hdr.size);
1070 return -1;
1071 }
1072
1073 sqbuf = i40iw_form_cm_frame(cm_node,
1074 NULL,
1075 &cm_node->mpa_hdr,
1076 &cm_node->pdata,
1077 SET_ACK);
1078 if (!sqbuf) {
1079 i40iw_pr_err("sq_buf == NULL\n");
1080 return -1;
1081 }
1082
1083 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1084}
1085
1086/**
1087 * i40iw_send_mpa_reject -
1088 * @cm_node: connection's node
1089 * @pdata: reject data for connection
1090 * @plen: length of reject data
1091 */
1092static int i40iw_send_mpa_reject(struct i40iw_cm_node *cm_node,
1093 const void *pdata,
1094 u8 plen)
1095{
1096 struct i40iw_puda_buf *sqbuf;
1097 struct i40iw_kmem_info priv_info;
1098
1099 cm_node->mpa_hdr.addr = &cm_node->mpa_frame;
1100 cm_node->mpa_hdr.size = i40iw_cm_build_mpa_frame(cm_node,
1101 &cm_node->mpa_hdr,
1102 MPA_KEY_REPLY);
1103
1104 cm_node->mpa_frame.flags |= IETF_MPA_FLAGS_REJECT;
1105 priv_info.addr = (void *)pdata;
1106 priv_info.size = plen;
1107
1108 sqbuf = i40iw_form_cm_frame(cm_node,
1109 NULL,
1110 &cm_node->mpa_hdr,
1111 &priv_info,
1112 SET_ACK | SET_FIN);
1113 if (!sqbuf) {
1114 i40iw_pr_err("no sqbuf\n");
1115 return -ENOMEM;
1116 }
1117 cm_node->state = I40IW_CM_STATE_FIN_WAIT1;
1118 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1119}
1120
1121/**
1122 * recv_mpa - process an IETF MPA frame
1123 * @cm_node: connection's node
1124 * @buffer: Data pointer
1125 * @type: to return accept or reject
1126 * @len: Len of mpa buffer
1127 */
1128static int i40iw_parse_mpa(struct i40iw_cm_node *cm_node, u8 *buffer, u32 *type, u32 len)
1129{
1130 struct ietf_mpa_v1 *mpa_frame;
1131 struct ietf_mpa_v2 *mpa_v2_frame;
1132 struct ietf_rtr_msg *rtr_msg;
1133 int mpa_hdr_len;
1134 int priv_data_len;
1135
1136 *type = I40IW_MPA_REQUEST_ACCEPT;
1137
1138 if (len < sizeof(struct ietf_mpa_v1)) {
1139 i40iw_pr_err("ietf buffer small (%x)\n", len);
1140 return -1;
1141 }
1142
1143 mpa_frame = (struct ietf_mpa_v1 *)buffer;
1144 mpa_hdr_len = sizeof(struct ietf_mpa_v1);
1145 priv_data_len = ntohs(mpa_frame->priv_data_len);
1146
1147 if (priv_data_len > IETF_MAX_PRIV_DATA_LEN) {
1148 i40iw_pr_err("large pri_data %d\n", priv_data_len);
1149 return -1;
1150 }
1151 if (mpa_frame->rev != IETF_MPA_V1 && mpa_frame->rev != IETF_MPA_V2) {
1152 i40iw_pr_err("unsupported mpa rev = %d\n", mpa_frame->rev);
1153 return -1;
1154 }
1155 if (mpa_frame->rev > cm_node->mpa_frame_rev) {
1156 i40iw_pr_err("rev %d\n", mpa_frame->rev);
1157 return -1;
1158 }
1159 cm_node->mpa_frame_rev = mpa_frame->rev;
1160
1161 if (cm_node->state != I40IW_CM_STATE_MPAREQ_SENT) {
1162 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE)) {
1163 i40iw_pr_err("Unexpected MPA Key received\n");
1164 return -1;
1165 }
1166 } else {
1167 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE)) {
1168 i40iw_pr_err("Unexpected MPA Key received\n");
1169 return -1;
1170 }
1171 }
1172
1173 if (priv_data_len + mpa_hdr_len > len) {
1174 i40iw_pr_err("ietf buffer len(%x + %x != %x)\n",
1175 priv_data_len, mpa_hdr_len, len);
1176 return -1;
1177 }
1178 if (len > MAX_CM_BUFFER) {
1179 i40iw_pr_err("ietf buffer large len = %d\n", len);
1180 return -1;
1181 }
1182
1183 switch (mpa_frame->rev) {
1184 case IETF_MPA_V2:{
1185 u16 ird_size;
1186 u16 ord_size;
1187 u16 ctrl_ord;
1188 u16 ctrl_ird;
1189
1190 mpa_v2_frame = (struct ietf_mpa_v2 *)buffer;
1191 mpa_hdr_len += IETF_RTR_MSG_SIZE;
1192 rtr_msg = &mpa_v2_frame->rtr_msg;
1193
1194 /* parse rtr message */
1195 ctrl_ord = ntohs(rtr_msg->ctrl_ord);
1196 ctrl_ird = ntohs(rtr_msg->ctrl_ird);
1197 ird_size = ctrl_ird & IETF_NO_IRD_ORD;
1198 ord_size = ctrl_ord & IETF_NO_IRD_ORD;
1199
1200 if (!(ctrl_ird & IETF_PEER_TO_PEER))
1201 return -1;
1202
1203 if (ird_size == IETF_NO_IRD_ORD || ord_size == IETF_NO_IRD_ORD) {
1204 cm_node->mpav2_ird_ord = IETF_NO_IRD_ORD;
1205 goto negotiate_done;
1206 }
1207
1208 if (cm_node->state != I40IW_CM_STATE_MPAREQ_SENT) {
1209 /* responder */
1210 if (!ord_size && (ctrl_ord & IETF_RDMA0_READ))
1211 cm_node->ird_size = 1;
1212 if (cm_node->ord_size > ird_size)
1213 cm_node->ord_size = ird_size;
1214 } else {
1215 /* initiator */
1216 if (!ird_size && (ctrl_ord & IETF_RDMA0_READ))
1217 return -1;
1218 if (cm_node->ord_size > ird_size)
1219 cm_node->ord_size = ird_size;
1220
1221 if (cm_node->ird_size < ord_size)
1222 /* no resources available */
1223 return -1;
1224 }
1225
1226negotiate_done:
1227 if (ctrl_ord & IETF_RDMA0_READ)
1228 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
1229 else if (ctrl_ord & IETF_RDMA0_WRITE)
1230 cm_node->send_rdma0_op = SEND_RDMA_WRITE_ZERO;
1231 else /* Not supported RDMA0 operation */
1232 return -1;
1233 i40iw_debug(cm_node->dev, I40IW_DEBUG_CM,
1234 "MPAV2: Negotiated ORD: %d, IRD: %d\n",
1235 cm_node->ord_size, cm_node->ird_size);
1236 break;
1237 }
1238 break;
1239 case IETF_MPA_V1:
1240 default:
1241 break;
1242 }
1243
1244 memcpy(cm_node->pdata_buf, buffer + mpa_hdr_len, priv_data_len);
1245 cm_node->pdata.size = priv_data_len;
1246
1247 if (mpa_frame->flags & IETF_MPA_FLAGS_REJECT)
1248 *type = I40IW_MPA_REQUEST_REJECT;
1249
1250 if (mpa_frame->flags & IETF_MPA_FLAGS_MARKERS)
1251 cm_node->snd_mark_en = true;
1252
1253 return 0;
1254}
1255
1256/**
1257 * i40iw_schedule_cm_timer
1258 * @@cm_node: connection's node
1259 * @sqbuf: buffer to send
1260 * @type: if it es send ot close
1261 * @send_retrans: if rexmits to be done
1262 * @close_when_complete: is cm_node to be removed
1263 *
1264 * note - cm_node needs to be protected before calling this. Encase in:
1265 * i40iw_rem_ref_cm_node(cm_core, cm_node);
1266 * i40iw_schedule_cm_timer(...)
1267 * atomic_inc(&cm_node->ref_count);
1268 */
1269int i40iw_schedule_cm_timer(struct i40iw_cm_node *cm_node,
1270 struct i40iw_puda_buf *sqbuf,
1271 enum i40iw_timer_type type,
1272 int send_retrans,
1273 int close_when_complete)
1274{
1275 struct i40iw_sc_dev *dev = cm_node->dev;
1276 struct i40iw_cm_core *cm_core = cm_node->cm_core;
1277 struct i40iw_timer_entry *new_send;
1278 int ret = 0;
1279 u32 was_timer_set;
1280 unsigned long flags;
1281
1282 new_send = kzalloc(sizeof(*new_send), GFP_ATOMIC);
1283 if (!new_send) {
1284 i40iw_free_sqbuf(cm_node->dev, (void *)sqbuf);
1285 return -ENOMEM;
1286 }
1287 new_send->retrycount = I40IW_DEFAULT_RETRYS;
1288 new_send->retranscount = I40IW_DEFAULT_RETRANS;
1289 new_send->sqbuf = sqbuf;
1290 new_send->timetosend = jiffies;
1291 new_send->type = type;
1292 new_send->send_retrans = send_retrans;
1293 new_send->close_when_complete = close_when_complete;
1294
1295 if (type == I40IW_TIMER_TYPE_CLOSE) {
1296 new_send->timetosend += (HZ / 10);
1297 if (cm_node->close_entry) {
1298 kfree(new_send);
1299 i40iw_free_sqbuf(cm_node->dev, (void *)sqbuf);
1300 i40iw_pr_err("already close entry\n");
1301 return -EINVAL;
1302 }
1303 cm_node->close_entry = new_send;
1304 }
1305
1306 if (type == I40IW_TIMER_TYPE_SEND) {
1307 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1308 cm_node->send_entry = new_send;
1309 atomic_inc(&cm_node->ref_count);
1310 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1311 new_send->timetosend = jiffies + I40IW_RETRY_TIMEOUT;
1312
1313 atomic_inc(&sqbuf->refcount);
1314 i40iw_puda_send_buf(dev->ilq, sqbuf);
1315 if (!send_retrans) {
1316 i40iw_cleanup_retrans_entry(cm_node);
1317 if (close_when_complete)
1318 i40iw_rem_ref_cm_node(cm_node);
1319 return ret;
1320 }
1321 }
1322
1323 spin_lock_irqsave(&cm_core->ht_lock, flags);
1324 was_timer_set = timer_pending(&cm_core->tcp_timer);
1325
1326 if (!was_timer_set) {
1327 cm_core->tcp_timer.expires = new_send->timetosend;
1328 add_timer(&cm_core->tcp_timer);
1329 }
1330 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1331
1332 return ret;
1333}
1334
1335/**
1336 * i40iw_retrans_expired - Could not rexmit the packet
1337 * @cm_node: connection's node
1338 */
1339static void i40iw_retrans_expired(struct i40iw_cm_node *cm_node)
1340{
1341 struct iw_cm_id *cm_id = cm_node->cm_id;
1342 enum i40iw_cm_node_state state = cm_node->state;
1343
1344 cm_node->state = I40IW_CM_STATE_CLOSED;
1345 switch (state) {
1346 case I40IW_CM_STATE_SYN_RCVD:
1347 case I40IW_CM_STATE_CLOSING:
1348 i40iw_rem_ref_cm_node(cm_node);
1349 break;
1350 case I40IW_CM_STATE_FIN_WAIT1:
1351 case I40IW_CM_STATE_LAST_ACK:
1352 if (cm_node->cm_id)
1353 cm_id->rem_ref(cm_id);
1354 i40iw_send_reset(cm_node);
1355 break;
1356 default:
1357 atomic_inc(&cm_node->ref_count);
1358 i40iw_send_reset(cm_node);
1359 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
1360 break;
1361 }
1362}
1363
1364/**
1365 * i40iw_handle_close_entry - for handling retry/timeouts
1366 * @cm_node: connection's node
1367 * @rem_node: flag for remove cm_node
1368 */
1369static void i40iw_handle_close_entry(struct i40iw_cm_node *cm_node, u32 rem_node)
1370{
1371 struct i40iw_timer_entry *close_entry = cm_node->close_entry;
1372 struct iw_cm_id *cm_id = cm_node->cm_id;
1373 struct i40iw_qp *iwqp;
1374 unsigned long flags;
1375
1376 if (!close_entry)
1377 return;
1378 iwqp = (struct i40iw_qp *)close_entry->sqbuf;
1379 if (iwqp) {
1380 spin_lock_irqsave(&iwqp->lock, flags);
1381 if (iwqp->cm_id) {
1382 iwqp->hw_tcp_state = I40IW_TCP_STATE_CLOSED;
1383 iwqp->hw_iwarp_state = I40IW_QP_STATE_ERROR;
1384 iwqp->last_aeq = I40IW_AE_RESET_SENT;
1385 iwqp->ibqp_state = IB_QPS_ERR;
1386 spin_unlock_irqrestore(&iwqp->lock, flags);
1387 i40iw_cm_disconn(iwqp);
1388 } else {
1389 spin_unlock_irqrestore(&iwqp->lock, flags);
1390 }
1391 } else if (rem_node) {
1392 /* TIME_WAIT state */
1393 i40iw_rem_ref_cm_node(cm_node);
1394 }
1395 if (cm_id)
1396 cm_id->rem_ref(cm_id);
1397 kfree(close_entry);
1398 cm_node->close_entry = NULL;
1399}
1400
1401/**
1402 * i40iw_cm_timer_tick - system's timer expired callback
1403 * @pass: Pointing to cm_core
1404 */
1405static void i40iw_cm_timer_tick(unsigned long pass)
1406{
1407 unsigned long nexttimeout = jiffies + I40IW_LONG_TIME;
1408 struct i40iw_cm_node *cm_node;
1409 struct i40iw_timer_entry *send_entry, *close_entry;
1410 struct list_head *list_core_temp;
1411 struct list_head *list_node;
1412 struct i40iw_cm_core *cm_core = (struct i40iw_cm_core *)pass;
1413 u32 settimer = 0;
1414 unsigned long timetosend;
1415 struct i40iw_sc_dev *dev;
1416 unsigned long flags;
1417
1418 struct list_head timer_list;
1419
1420 INIT_LIST_HEAD(&timer_list);
1421 spin_lock_irqsave(&cm_core->ht_lock, flags);
1422
1423 list_for_each_safe(list_node, list_core_temp, &cm_core->connected_nodes) {
1424 cm_node = container_of(list_node, struct i40iw_cm_node, list);
1425 if (cm_node->close_entry || cm_node->send_entry) {
1426 atomic_inc(&cm_node->ref_count);
1427 list_add(&cm_node->timer_entry, &timer_list);
1428 }
1429 }
1430 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1431
1432 list_for_each_safe(list_node, list_core_temp, &timer_list) {
1433 cm_node = container_of(list_node,
1434 struct i40iw_cm_node,
1435 timer_entry);
1436 close_entry = cm_node->close_entry;
1437
1438 if (close_entry) {
1439 if (time_after(close_entry->timetosend, jiffies)) {
1440 if (nexttimeout > close_entry->timetosend ||
1441 !settimer) {
1442 nexttimeout = close_entry->timetosend;
1443 settimer = 1;
1444 }
1445 } else {
1446 i40iw_handle_close_entry(cm_node, 1);
1447 }
1448 }
1449
1450 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1451
1452 send_entry = cm_node->send_entry;
1453 if (!send_entry)
1454 goto done;
1455 if (time_after(send_entry->timetosend, jiffies)) {
1456 if (cm_node->state != I40IW_CM_STATE_OFFLOADED) {
1457 if ((nexttimeout > send_entry->timetosend) ||
1458 !settimer) {
1459 nexttimeout = send_entry->timetosend;
1460 settimer = 1;
1461 }
1462 } else {
1463 i40iw_free_retrans_entry(cm_node);
1464 }
1465 goto done;
1466 }
1467
1468 if ((cm_node->state == I40IW_CM_STATE_OFFLOADED) ||
1469 (cm_node->state == I40IW_CM_STATE_CLOSED)) {
1470 i40iw_free_retrans_entry(cm_node);
1471 goto done;
1472 }
1473
1474 if (!send_entry->retranscount || !send_entry->retrycount) {
1475 i40iw_free_retrans_entry(cm_node);
1476
1477 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1478 i40iw_retrans_expired(cm_node);
1479 cm_node->state = I40IW_CM_STATE_CLOSED;
1480 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1481 goto done;
1482 }
1483 cm_node->cm_core->stats_pkt_retrans++;
1484 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1485
1486 dev = cm_node->dev;
1487 atomic_inc(&send_entry->sqbuf->refcount);
1488 i40iw_puda_send_buf(dev->ilq, send_entry->sqbuf);
1489 spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
1490 if (send_entry->send_retrans) {
1491 send_entry->retranscount--;
1492 timetosend = (I40IW_RETRY_TIMEOUT <<
1493 (I40IW_DEFAULT_RETRANS -
1494 send_entry->retranscount));
1495
1496 send_entry->timetosend = jiffies +
1497 min(timetosend, I40IW_MAX_TIMEOUT);
1498 if (nexttimeout > send_entry->timetosend || !settimer) {
1499 nexttimeout = send_entry->timetosend;
1500 settimer = 1;
1501 }
1502 } else {
1503 int close_when_complete;
1504
1505 close_when_complete = send_entry->close_when_complete;
1506 i40iw_debug(cm_node->dev,
1507 I40IW_DEBUG_CM,
1508 "cm_node=%p state=%d\n",
1509 cm_node,
1510 cm_node->state);
1511 i40iw_free_retrans_entry(cm_node);
1512 if (close_when_complete)
1513 i40iw_rem_ref_cm_node(cm_node);
1514 }
1515done:
1516 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
1517 i40iw_rem_ref_cm_node(cm_node);
1518 }
1519
1520 if (settimer) {
1521 spin_lock_irqsave(&cm_core->ht_lock, flags);
1522 if (!timer_pending(&cm_core->tcp_timer)) {
1523 cm_core->tcp_timer.expires = nexttimeout;
1524 add_timer(&cm_core->tcp_timer);
1525 }
1526 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1527 }
1528}
1529
1530/**
1531 * i40iw_send_syn - send SYN packet
1532 * @cm_node: connection's node
1533 * @sendack: flag to set ACK bit or not
1534 */
1535int i40iw_send_syn(struct i40iw_cm_node *cm_node, u32 sendack)
1536{
1537 struct i40iw_puda_buf *sqbuf;
1538 int flags = SET_SYN;
1539 char optionsbuffer[sizeof(struct option_mss) +
1540 sizeof(struct option_windowscale) +
1541 sizeof(struct option_base) + TCP_OPTIONS_PADDING];
1542 struct i40iw_kmem_info opts;
1543
1544 int optionssize = 0;
1545 /* Sending MSS option */
1546 union all_known_options *options;
1547
1548 opts.addr = optionsbuffer;
1549 if (!cm_node) {
1550 i40iw_pr_err("no cm_node\n");
1551 return -EINVAL;
1552 }
1553
1554 options = (union all_known_options *)&optionsbuffer[optionssize];
1555 options->as_mss.optionnum = OPTION_NUMBER_MSS;
1556 options->as_mss.length = sizeof(struct option_mss);
1557 options->as_mss.mss = htons(cm_node->tcp_cntxt.mss);
1558 optionssize += sizeof(struct option_mss);
1559
1560 options = (union all_known_options *)&optionsbuffer[optionssize];
1561 options->as_windowscale.optionnum = OPTION_NUMBER_WINDOW_SCALE;
1562 options->as_windowscale.length = sizeof(struct option_windowscale);
1563 options->as_windowscale.shiftcount = cm_node->tcp_cntxt.rcv_wscale;
1564 optionssize += sizeof(struct option_windowscale);
1565 options = (union all_known_options *)&optionsbuffer[optionssize];
1566 options->as_end = OPTION_NUMBER_END;
1567 optionssize += 1;
1568
1569 if (sendack)
1570 flags |= SET_ACK;
1571
1572 opts.size = optionssize;
1573
1574 sqbuf = i40iw_form_cm_frame(cm_node, &opts, NULL, NULL, flags);
1575 if (!sqbuf) {
1576 i40iw_pr_err("no sqbuf\n");
1577 return -1;
1578 }
1579 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1580}
1581
1582/**
1583 * i40iw_send_ack - Send ACK packet
1584 * @cm_node: connection's node
1585 */
1586static void i40iw_send_ack(struct i40iw_cm_node *cm_node)
1587{
1588 struct i40iw_puda_buf *sqbuf;
1589
1590 sqbuf = i40iw_form_cm_frame(cm_node, NULL, NULL, NULL, SET_ACK);
1591 if (sqbuf)
1592 i40iw_puda_send_buf(cm_node->dev->ilq, sqbuf);
1593 else
1594 i40iw_pr_err("no sqbuf\n");
1595}
1596
1597/**
1598 * i40iw_send_fin - Send FIN pkt
1599 * @cm_node: connection's node
1600 */
1601static int i40iw_send_fin(struct i40iw_cm_node *cm_node)
1602{
1603 struct i40iw_puda_buf *sqbuf;
1604
1605 sqbuf = i40iw_form_cm_frame(cm_node, NULL, NULL, NULL, SET_ACK | SET_FIN);
1606 if (!sqbuf) {
1607 i40iw_pr_err("no sqbuf\n");
1608 return -1;
1609 }
1610 return i40iw_schedule_cm_timer(cm_node, sqbuf, I40IW_TIMER_TYPE_SEND, 1, 0);
1611}
1612
1613/**
1614 * i40iw_find_node - find a cm node that matches the reference cm node
1615 * @cm_core: cm's core
1616 * @rem_port: remote tcp port num
1617 * @rem_addr: remote ip addr
1618 * @loc_port: local tcp port num
1619 * @loc_addr: loc ip addr
1620 * @add_refcnt: flag to increment refcount of cm_node
1621 */
1622struct i40iw_cm_node *i40iw_find_node(struct i40iw_cm_core *cm_core,
1623 u16 rem_port,
1624 u32 *rem_addr,
1625 u16 loc_port,
1626 u32 *loc_addr,
1627 bool add_refcnt)
1628{
1629 struct list_head *hte;
1630 struct i40iw_cm_node *cm_node;
1631 unsigned long flags;
1632
1633 hte = &cm_core->connected_nodes;
1634
1635 /* walk list and find cm_node associated with this session ID */
1636 spin_lock_irqsave(&cm_core->ht_lock, flags);
1637 list_for_each_entry(cm_node, hte, list) {
1638 if (!memcmp(cm_node->map_loc_addr, loc_addr, sizeof(cm_node->map_loc_addr)) &&
1639 (cm_node->map_loc_port == loc_port) &&
1640 !memcmp(cm_node->map_rem_addr, rem_addr, sizeof(cm_node->map_rem_addr)) &&
1641 (cm_node->map_rem_port == rem_port)) {
1642 if (add_refcnt)
1643 atomic_inc(&cm_node->ref_count);
1644 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1645 return cm_node;
1646 }
1647 }
1648 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1649
1650 /* no owner node */
1651 return NULL;
1652}
1653
1654/**
1655 * i40iw_find_listener - find a cm node listening on this addr-port pair
1656 * @cm_core: cm's core
1657 * @dst_port: listener tcp port num
1658 * @dst_addr: listener ip addr
1659 * @listener_state: state to match with listen node's
1660 */
1661static struct i40iw_cm_listener *i40iw_find_listener(
1662 struct i40iw_cm_core *cm_core,
1663 u32 *dst_addr,
1664 u16 dst_port,
1665 u16 vlan_id,
1666 enum i40iw_cm_listener_state
1667 listener_state,
1668 bool mapped)
1669{
1670 struct i40iw_cm_listener *listen_node;
1671 static const u32 ip_zero[4] = { 0, 0, 0, 0 };
1672 u32 listen_addr[4];
1673 u16 listen_port;
1674 unsigned long flags;
1675
1676 /* walk list and find cm_node associated with this session ID */
1677 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
1678 list_for_each_entry(listen_node, &cm_core->listen_nodes, list) {
1679 if (mapped) {
1680 memcpy(listen_addr, listen_node->map_loc_addr, sizeof(listen_addr));
1681 listen_port = listen_node->map_loc_port;
1682 } else {
1683 memcpy(listen_addr, listen_node->loc_addr, sizeof(listen_addr));
1684 listen_port = listen_node->loc_port;
1685 }
1686 /* compare node pair, return node handle if a match */
1687 if ((!memcmp(listen_addr, dst_addr, sizeof(listen_addr)) ||
1688 !memcmp(listen_addr, ip_zero, sizeof(listen_addr))) &&
1689 (listen_port == dst_port) &&
1690 (listener_state & listen_node->listener_state)) {
1691 atomic_inc(&listen_node->ref_count);
1692 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
1693 return listen_node;
1694 }
1695 }
1696 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
1697 return NULL;
1698}
1699
1700/**
1701 * i40iw_add_hte_node - add a cm node to the hash table
1702 * @cm_core: cm's core
1703 * @cm_node: connection's node
1704 */
1705static void i40iw_add_hte_node(struct i40iw_cm_core *cm_core,
1706 struct i40iw_cm_node *cm_node)
1707{
1708 struct list_head *hte;
1709 unsigned long flags;
1710
1711 if (!cm_node || !cm_core) {
1712 i40iw_pr_err("cm_node or cm_core == NULL\n");
1713 return;
1714 }
1715 spin_lock_irqsave(&cm_core->ht_lock, flags);
1716
1717 /* get a handle on the hash table element (list head for this slot) */
1718 hte = &cm_core->connected_nodes;
1719 list_add_tail(&cm_node->list, hte);
1720 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
1721}
1722
1723/**
1724 * listen_port_in_use - determine if port is in use
1725 * @port: Listen port number
1726 */
1727static bool i40iw_listen_port_in_use(struct i40iw_cm_core *cm_core, u16 port)
1728{
1729 struct i40iw_cm_listener *listen_node;
1730 unsigned long flags;
1731 bool ret = false;
1732
1733 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
1734 list_for_each_entry(listen_node, &cm_core->listen_nodes, list) {
1735 if (listen_node->map_loc_port == port) {
1736 ret = true;
1737 break;
1738 }
1739 }
1740 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
1741 return ret;
1742}
1743
1744/**
1745 * i40iw_del_multiple_qhash - Remove qhash and child listens
1746 * @iwdev: iWarp device
1747 * @cm_info: CM info for parent listen node
1748 * @cm_parent_listen_node: The parent listen node
1749 */
1750static enum i40iw_status_code i40iw_del_multiple_qhash(
1751 struct i40iw_device *iwdev,
1752 struct i40iw_cm_info *cm_info,
1753 struct i40iw_cm_listener *cm_parent_listen_node)
1754{
1755 struct i40iw_cm_listener *child_listen_node;
1756 enum i40iw_status_code ret = I40IW_ERR_CONFIG;
1757 struct list_head *pos, *tpos;
1758 unsigned long flags;
1759
1760 spin_lock_irqsave(&iwdev->cm_core.listen_list_lock, flags);
1761 list_for_each_safe(pos, tpos, &cm_parent_listen_node->child_listen_list) {
1762 child_listen_node = list_entry(pos, struct i40iw_cm_listener, child_listen_list);
1763 if (child_listen_node->ipv4)
1764 i40iw_debug(&iwdev->sc_dev,
1765 I40IW_DEBUG_CM,
1766 "removing child listen for IP=%pI4, port=%d, vlan=%d\n",
1767 child_listen_node->loc_addr,
1768 child_listen_node->loc_port,
1769 child_listen_node->vlan_id);
1770 else
1771 i40iw_debug(&iwdev->sc_dev, I40IW_DEBUG_CM,
1772 "removing child listen for IP=%pI6, port=%d, vlan=%d\n",
1773 child_listen_node->loc_addr,
1774 child_listen_node->loc_port,
1775 child_listen_node->vlan_id);
1776 list_del(pos);
1777 memcpy(cm_info->map_loc_addr, child_listen_node->map_loc_addr,
1778 sizeof(cm_info->map_loc_addr));
1779 memcpy(cm_info->loc_addr, child_listen_node->loc_addr,
1780 sizeof(cm_info->loc_addr));
1781 cm_info->vlan_id = child_listen_node->vlan_id;
1782 ret = i40iw_manage_qhash(iwdev, cm_info,
1783 I40IW_QHASH_TYPE_TCP_SYN,
1784 I40IW_QHASH_MANAGE_TYPE_DELETE, NULL, false);
1785 kfree(child_listen_node);
1786 cm_parent_listen_node->cm_core->stats_listen_nodes_destroyed++;
1787 i40iw_debug(&iwdev->sc_dev,
1788 I40IW_DEBUG_CM,
1789 "freed pointer = %p\n",
1790 child_listen_node);
1791 }
1792 spin_unlock_irqrestore(&iwdev->cm_core.listen_list_lock, flags);
1793
1794 return ret;
1795}
1796
1797/**
1798 * i40iw_netdev_vlan_ipv6 - Gets the netdev and mac
1799 * @addr: local IPv6 address
1800 * @vlan_id: vlan id for the given IPv6 address
1801 * @mac: mac address for the given IPv6 address
1802 *
1803 * Returns the net_device of the IPv6 address and also sets the
1804 * vlan id and mac for that address.
1805 */
1806static struct net_device *i40iw_netdev_vlan_ipv6(u32 *addr, u16 *vlan_id, u8 *mac)
1807{
1808 struct net_device *ip_dev = NULL;
1809#if IS_ENABLED(CONFIG_IPV6)
1810 struct in6_addr laddr6;
1811
1812 i40iw_copy_ip_htonl(laddr6.in6_u.u6_addr32, addr);
1813 if (vlan_id)
1814 *vlan_id = I40IW_NO_VLAN;
1815 if (mac)
1816 eth_zero_addr(mac);
1817 rcu_read_lock();
1818 for_each_netdev_rcu(&init_net, ip_dev) {
1819 if (ipv6_chk_addr(&init_net, &laddr6, ip_dev, 1)) {
1820 if (vlan_id)
1821 *vlan_id = rdma_vlan_dev_vlan_id(ip_dev);
1822 if (ip_dev->dev_addr && mac)
1823 ether_addr_copy(mac, ip_dev->dev_addr);
1824 break;
1825 }
1826 }
1827 rcu_read_unlock();
1828#endif
1829 return ip_dev;
1830}
1831
1832/**
1833 * i40iw_get_vlan_ipv4 - Returns the vlan_id for IPv4 address
1834 * @addr: local IPv4 address
1835 */
1836static u16 i40iw_get_vlan_ipv4(u32 *addr)
1837{
1838 struct net_device *netdev;
1839 u16 vlan_id = I40IW_NO_VLAN;
1840
1841 netdev = ip_dev_find(&init_net, htonl(addr[0]));
1842 if (netdev) {
1843 vlan_id = rdma_vlan_dev_vlan_id(netdev);
1844 dev_put(netdev);
1845 }
1846 return vlan_id;
1847}
1848
1849/**
1850 * i40iw_add_mqh_6 - Adds multiple qhashes for IPv6
1851 * @iwdev: iWarp device
1852 * @cm_info: CM info for parent listen node
1853 * @cm_parent_listen_node: The parent listen node
1854 *
1855 * Adds a qhash and a child listen node for every IPv6 address
1856 * on the adapter and adds the associated qhash filter
1857 */
1858static enum i40iw_status_code i40iw_add_mqh_6(struct i40iw_device *iwdev,
1859 struct i40iw_cm_info *cm_info,
1860 struct i40iw_cm_listener *cm_parent_listen_node)
1861{
1862 struct net_device *ip_dev;
1863 struct inet6_dev *idev;
1864 struct inet6_ifaddr *ifp;
1865 enum i40iw_status_code ret = 0;
1866 struct i40iw_cm_listener *child_listen_node;
1867 unsigned long flags;
1868
1869 rtnl_lock();
1870 for_each_netdev_rcu(&init_net, ip_dev) {
1871 if ((((rdma_vlan_dev_vlan_id(ip_dev) < I40IW_NO_VLAN) &&
1872 (rdma_vlan_dev_real_dev(ip_dev) == iwdev->netdev)) ||
1873 (ip_dev == iwdev->netdev)) && (ip_dev->flags & IFF_UP)) {
1874 idev = __in6_dev_get(ip_dev);
1875 if (!idev) {
1876 i40iw_pr_err("idev == NULL\n");
1877 break;
1878 }
1879 list_for_each_entry(ifp, &idev->addr_list, if_list) {
1880 i40iw_debug(&iwdev->sc_dev,
1881 I40IW_DEBUG_CM,
1882 "IP=%pI6, vlan_id=%d, MAC=%pM\n",
1883 &ifp->addr,
1884 rdma_vlan_dev_vlan_id(ip_dev),
1885 ip_dev->dev_addr);
1886 child_listen_node =
1887 kzalloc(sizeof(*child_listen_node), GFP_ATOMIC);
1888 i40iw_debug(&iwdev->sc_dev,
1889 I40IW_DEBUG_CM,
1890 "Allocating child listener %p\n",
1891 child_listen_node);
1892 if (!child_listen_node) {
1893 i40iw_pr_err("listener memory allocation\n");
1894 ret = I40IW_ERR_NO_MEMORY;
1895 goto exit;
1896 }
1897 cm_info->vlan_id = rdma_vlan_dev_vlan_id(ip_dev);
1898 cm_parent_listen_node->vlan_id = cm_info->vlan_id;
1899
1900 memcpy(child_listen_node, cm_parent_listen_node,
1901 sizeof(*child_listen_node));
1902
1903 i40iw_copy_ip_ntohl(child_listen_node->loc_addr,
1904 ifp->addr.in6_u.u6_addr32);
1905 i40iw_copy_ip_ntohl(child_listen_node->map_loc_addr,
1906 ifp->addr.in6_u.u6_addr32);
1907
1908 memcpy(cm_info->map_loc_addr, child_listen_node->map_loc_addr,
1909 sizeof(cm_info->map_loc_addr));
1910 memcpy(cm_info->loc_addr, child_listen_node->loc_addr,
1911 sizeof(cm_info->loc_addr));
1912
1913 ret = i40iw_manage_qhash(iwdev, cm_info,
1914 I40IW_QHASH_TYPE_TCP_SYN,
1915 I40IW_QHASH_MANAGE_TYPE_ADD,
1916 NULL, true);
1917 if (!ret) {
1918 spin_lock_irqsave(&iwdev->cm_core.listen_list_lock, flags);
1919 list_add(&child_listen_node->child_listen_list,
1920 &cm_parent_listen_node->child_listen_list);
1921 spin_unlock_irqrestore(&iwdev->cm_core.listen_list_lock, flags);
1922 cm_parent_listen_node->cm_core->stats_listen_nodes_created++;
1923 } else {
1924 kfree(child_listen_node);
1925 }
1926 }
1927 }
1928 }
1929exit:
1930 rtnl_unlock();
1931 return ret;
1932}
1933
1934/**
1935 * i40iw_add_mqh_4 - Adds multiple qhashes for IPv4
1936 * @iwdev: iWarp device
1937 * @cm_info: CM info for parent listen node
1938 * @cm_parent_listen_node: The parent listen node
1939 *
1940 * Adds a qhash and a child listen node for every IPv4 address
1941 * on the adapter and adds the associated qhash filter
1942 */
1943static enum i40iw_status_code i40iw_add_mqh_4(
1944 struct i40iw_device *iwdev,
1945 struct i40iw_cm_info *cm_info,
1946 struct i40iw_cm_listener *cm_parent_listen_node)
1947{
1948 struct net_device *dev;
1949 struct in_device *idev;
1950 struct i40iw_cm_listener *child_listen_node;
1951 enum i40iw_status_code ret = 0;
1952 unsigned long flags;
1953
1954 rtnl_lock();
1955 for_each_netdev(&init_net, dev) {
1956 if ((((rdma_vlan_dev_vlan_id(dev) < I40IW_NO_VLAN) &&
1957 (rdma_vlan_dev_real_dev(dev) == iwdev->netdev)) ||
1958 (dev == iwdev->netdev)) && (dev->flags & IFF_UP)) {
1959 idev = in_dev_get(dev);
1960 for_ifa(idev) {
1961 i40iw_debug(&iwdev->sc_dev,
1962 I40IW_DEBUG_CM,
1963 "Allocating child CM Listener forIP=%pI4, vlan_id=%d, MAC=%pM\n",
1964 &ifa->ifa_address,
1965 rdma_vlan_dev_vlan_id(dev),
1966 dev->dev_addr);
1967 child_listen_node = kzalloc(sizeof(*child_listen_node), GFP_ATOMIC);
1968 cm_parent_listen_node->cm_core->stats_listen_nodes_created++;
1969 i40iw_debug(&iwdev->sc_dev,
1970 I40IW_DEBUG_CM,
1971 "Allocating child listener %p\n",
1972 child_listen_node);
1973 if (!child_listen_node) {
1974 i40iw_pr_err("listener memory allocation\n");
1975 in_dev_put(idev);
1976 ret = I40IW_ERR_NO_MEMORY;
1977 goto exit;
1978 }
1979 cm_info->vlan_id = rdma_vlan_dev_vlan_id(dev);
1980 cm_parent_listen_node->vlan_id = cm_info->vlan_id;
1981 memcpy(child_listen_node,
1982 cm_parent_listen_node,
1983 sizeof(*child_listen_node));
1984
1985 child_listen_node->loc_addr[0] = ntohl(ifa->ifa_address);
1986 child_listen_node->map_loc_addr[0] = ntohl(ifa->ifa_address);
1987
1988 memcpy(cm_info->map_loc_addr, child_listen_node->map_loc_addr,
1989 sizeof(cm_info->map_loc_addr));
1990 memcpy(cm_info->loc_addr, child_listen_node->loc_addr,
1991 sizeof(cm_info->loc_addr));
1992
1993 ret = i40iw_manage_qhash(iwdev,
1994 cm_info,
1995 I40IW_QHASH_TYPE_TCP_SYN,
1996 I40IW_QHASH_MANAGE_TYPE_ADD,
1997 NULL,
1998 true);
1999 if (!ret) {
2000 spin_lock_irqsave(&iwdev->cm_core.listen_list_lock, flags);
2001 list_add(&child_listen_node->child_listen_list,
2002 &cm_parent_listen_node->child_listen_list);
2003 spin_unlock_irqrestore(&iwdev->cm_core.listen_list_lock, flags);
2004 } else {
2005 kfree(child_listen_node);
2006 cm_parent_listen_node->cm_core->stats_listen_nodes_created--;
2007 }
2008 }
2009 endfor_ifa(idev);
2010 in_dev_put(idev);
2011 }
2012 }
2013exit:
2014 rtnl_unlock();
2015 return ret;
2016}
2017
2018/**
2019 * i40iw_dec_refcnt_listen - delete listener and associated cm nodes
2020 * @cm_core: cm's core
2021 * @free_hanging_nodes: to free associated cm_nodes
2022 * @apbvt_del: flag to delete the apbvt
2023 */
2024static int i40iw_dec_refcnt_listen(struct i40iw_cm_core *cm_core,
2025 struct i40iw_cm_listener *listener,
2026 int free_hanging_nodes, bool apbvt_del)
2027{
2028 int ret = -EINVAL;
2029 int err = 0;
2030 struct list_head *list_pos;
2031 struct list_head *list_temp;
2032 struct i40iw_cm_node *cm_node;
2033 struct list_head reset_list;
2034 struct i40iw_cm_info nfo;
2035 struct i40iw_cm_node *loopback;
2036 enum i40iw_cm_node_state old_state;
2037 unsigned long flags;
2038
2039 /* free non-accelerated child nodes for this listener */
2040 INIT_LIST_HEAD(&reset_list);
2041 if (free_hanging_nodes) {
2042 spin_lock_irqsave(&cm_core->ht_lock, flags);
2043 list_for_each_safe(list_pos, list_temp, &cm_core->connected_nodes) {
2044 cm_node = container_of(list_pos, struct i40iw_cm_node, list);
2045 if ((cm_node->listener == listener) && !cm_node->accelerated) {
2046 atomic_inc(&cm_node->ref_count);
2047 list_add(&cm_node->reset_entry, &reset_list);
2048 }
2049 }
2050 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
2051 }
2052
2053 list_for_each_safe(list_pos, list_temp, &reset_list) {
2054 cm_node = container_of(list_pos, struct i40iw_cm_node, reset_entry);
2055 loopback = cm_node->loopbackpartner;
2056 if (cm_node->state >= I40IW_CM_STATE_FIN_WAIT1) {
2057 i40iw_rem_ref_cm_node(cm_node);
2058 } else {
2059 if (!loopback) {
2060 i40iw_cleanup_retrans_entry(cm_node);
2061 err = i40iw_send_reset(cm_node);
2062 if (err) {
2063 cm_node->state = I40IW_CM_STATE_CLOSED;
2064 i40iw_pr_err("send reset\n");
2065 } else {
2066 old_state = cm_node->state;
2067 cm_node->state = I40IW_CM_STATE_LISTENER_DESTROYED;
2068 if (old_state != I40IW_CM_STATE_MPAREQ_RCVD)
2069 i40iw_rem_ref_cm_node(cm_node);
2070 }
2071 } else {
2072 struct i40iw_cm_event event;
2073
2074 event.cm_node = loopback;
2075 memcpy(event.cm_info.rem_addr,
2076 loopback->rem_addr, sizeof(event.cm_info.rem_addr));
2077 memcpy(event.cm_info.loc_addr,
2078 loopback->loc_addr, sizeof(event.cm_info.loc_addr));
2079 event.cm_info.rem_port = loopback->rem_port;
2080 event.cm_info.loc_port = loopback->loc_port;
2081 event.cm_info.cm_id = loopback->cm_id;
2082 event.cm_info.ipv4 = loopback->ipv4;
2083 atomic_inc(&loopback->ref_count);
2084 loopback->state = I40IW_CM_STATE_CLOSED;
2085 i40iw_event_connect_error(&event);
2086 cm_node->state = I40IW_CM_STATE_LISTENER_DESTROYED;
2087 i40iw_rem_ref_cm_node(cm_node);
2088 }
2089 }
2090 }
2091
2092 if (!atomic_dec_return(&listener->ref_count)) {
2093 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
2094 list_del(&listener->list);
2095 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
2096
2097 if (listener->iwdev) {
2098 if (apbvt_del && !i40iw_listen_port_in_use(cm_core, listener->map_loc_port))
2099 i40iw_manage_apbvt(listener->iwdev,
2100 listener->map_loc_port,
2101 I40IW_MANAGE_APBVT_DEL);
2102
2103 memcpy(nfo.loc_addr, listener->loc_addr, sizeof(nfo.loc_addr));
2104 memcpy(nfo.map_loc_addr, listener->map_loc_addr, sizeof(nfo.map_loc_addr));
2105 nfo.loc_port = listener->loc_port;
2106 nfo.map_loc_port = listener->map_loc_port;
2107 nfo.ipv4 = listener->ipv4;
2108 nfo.vlan_id = listener->vlan_id;
2109
2110 i40iw_remove_mapinfo(&nfo);
2111
2112 if (!list_empty(&listener->child_listen_list)) {
2113 i40iw_del_multiple_qhash(listener->iwdev, &nfo, listener);
2114 } else {
2115 if (listener->qhash_set)
2116 i40iw_manage_qhash(listener->iwdev,
2117 &nfo,
2118 I40IW_QHASH_TYPE_TCP_SYN,
2119 I40IW_QHASH_MANAGE_TYPE_DELETE,
2120 NULL,
2121 false);
2122 }
2123 }
2124
2125 cm_core->stats_listen_destroyed++;
2126 kfree(listener);
2127 cm_core->stats_listen_nodes_destroyed++;
2128 listener = NULL;
2129 ret = 0;
2130 }
2131
2132 if (listener) {
2133 if (atomic_read(&listener->pend_accepts_cnt) > 0)
2134 i40iw_debug(cm_core->dev,
2135 I40IW_DEBUG_CM,
2136 "%s: listener (%p) pending accepts=%u\n",
2137 __func__,
2138 listener,
2139 atomic_read(&listener->pend_accepts_cnt));
2140 }
2141
2142 return ret;
2143}
2144
2145/**
2146 * i40iw_cm_del_listen - delete a linstener
2147 * @cm_core: cm's core
2148 * @listener: passive connection's listener
2149 * @apbvt_del: flag to delete apbvt
2150 */
2151static int i40iw_cm_del_listen(struct i40iw_cm_core *cm_core,
2152 struct i40iw_cm_listener *listener,
2153 bool apbvt_del)
2154{
2155 listener->listener_state = I40IW_CM_LISTENER_PASSIVE_STATE;
2156 listener->cm_id = NULL; /* going to be destroyed pretty soon */
2157 return i40iw_dec_refcnt_listen(cm_core, listener, 1, apbvt_del);
2158}
2159
2160/**
2161 * i40iw_addr_resolve_neigh - resolve neighbor address
2162 * @iwdev: iwarp device structure
2163 * @src_ip: local ip address
2164 * @dst_ip: remote ip address
2165 * @arpindex: if there is an arp entry
2166 */
2167static int i40iw_addr_resolve_neigh(struct i40iw_device *iwdev,
2168 u32 src_ip,
2169 u32 dst_ip,
2170 int arpindex)
2171{
2172 struct rtable *rt;
2173 struct neighbour *neigh;
2174 int rc = arpindex;
2175 struct net_device *netdev = iwdev->netdev;
2176 __be32 dst_ipaddr = htonl(dst_ip);
2177 __be32 src_ipaddr = htonl(src_ip);
2178
2179 rt = ip_route_output(&init_net, dst_ipaddr, src_ipaddr, 0, 0);
2180 if (IS_ERR(rt)) {
2181 i40iw_pr_err("ip_route_output\n");
2182 return rc;
2183 }
2184
2185 if (netif_is_bond_slave(netdev))
2186 netdev = netdev_master_upper_dev_get(netdev);
2187
2188 neigh = dst_neigh_lookup(&rt->dst, &dst_ipaddr);
2189
2190 rcu_read_lock();
2191 if (neigh) {
2192 if (neigh->nud_state & NUD_VALID) {
2193 if (arpindex >= 0) {
2194 if (ether_addr_equal(iwdev->arp_table[arpindex].mac_addr,
2195 neigh->ha))
2196 /* Mac address same as arp table */
2197 goto resolve_neigh_exit;
2198 i40iw_manage_arp_cache(iwdev,
2199 iwdev->arp_table[arpindex].mac_addr,
2200 &dst_ip,
2201 true,
2202 I40IW_ARP_DELETE);
2203 }
2204
2205 i40iw_manage_arp_cache(iwdev, neigh->ha, &dst_ip, true, I40IW_ARP_ADD);
2206 rc = i40iw_arp_table(iwdev, &dst_ip, true, NULL, I40IW_ARP_RESOLVE);
2207 } else {
2208 neigh_event_send(neigh, NULL);
2209 }
2210 }
2211 resolve_neigh_exit:
2212
2213 rcu_read_unlock();
2214 if (neigh)
2215 neigh_release(neigh);
2216
2217 ip_rt_put(rt);
2218 return rc;
2219}
2220
2221/**
2222 * i40iw_get_dst_ipv6
2223 */
2224#if IS_ENABLED(CONFIG_IPV6)
2225static struct dst_entry *i40iw_get_dst_ipv6(struct sockaddr_in6 *src_addr,
2226 struct sockaddr_in6 *dst_addr)
2227{
2228 struct dst_entry *dst;
2229 struct flowi6 fl6;
2230
2231 memset(&fl6, 0, sizeof(fl6));
2232 fl6.daddr = dst_addr->sin6_addr;
2233 fl6.saddr = src_addr->sin6_addr;
2234 if (ipv6_addr_type(&fl6.daddr) & IPV6_ADDR_LINKLOCAL)
2235 fl6.flowi6_oif = dst_addr->sin6_scope_id;
2236
2237 dst = ip6_route_output(&init_net, NULL, &fl6);
2238 return dst;
2239}
2240#endif
2241
2242/**
2243 * i40iw_addr_resolve_neigh_ipv6 - resolve neighbor ipv6 address
2244 * @iwdev: iwarp device structure
2245 * @dst_ip: remote ip address
2246 * @arpindex: if there is an arp entry
2247 */
2248#if IS_ENABLED(CONFIG_IPV6)
2249static int i40iw_addr_resolve_neigh_ipv6(struct i40iw_device *iwdev,
2250 u32 *src,
2251 u32 *dest,
2252 int arpindex)
2253{
2254 struct neighbour *neigh;
2255 int rc = arpindex;
2256 struct net_device *netdev = iwdev->netdev;
2257 struct dst_entry *dst;
2258 struct sockaddr_in6 dst_addr;
2259 struct sockaddr_in6 src_addr;
2260
2261 memset(&dst_addr, 0, sizeof(dst_addr));
2262 dst_addr.sin6_family = AF_INET6;
2263 i40iw_copy_ip_htonl(dst_addr.sin6_addr.in6_u.u6_addr32, dest);
2264 memset(&src_addr, 0, sizeof(src_addr));
2265 src_addr.sin6_family = AF_INET6;
2266 i40iw_copy_ip_htonl(src_addr.sin6_addr.in6_u.u6_addr32, src);
2267 dst = i40iw_get_dst_ipv6(&src_addr, &dst_addr);
2268 if (!dst || dst->error) {
2269 if (dst) {
2270 dst_release(dst);
2271 i40iw_pr_err("ip6_route_output returned dst->error = %d\n",
2272 dst->error);
2273 }
2274 return rc;
2275 }
2276
2277 if (netif_is_bond_slave(netdev))
2278 netdev = netdev_master_upper_dev_get(netdev);
2279
2280 neigh = dst_neigh_lookup(dst, &dst_addr);
2281
2282 rcu_read_lock();
2283 if (neigh) {
2284 i40iw_debug(&iwdev->sc_dev, I40IW_DEBUG_CM, "dst_neigh_lookup MAC=%pM\n", neigh->ha);
2285 if (neigh->nud_state & NUD_VALID) {
2286 if (arpindex >= 0) {
2287 if (ether_addr_equal
2288 (iwdev->arp_table[arpindex].mac_addr,
2289 neigh->ha)) {
2290 /* Mac address same as in arp table */
2291 goto resolve_neigh_exit6;
2292 }
2293 i40iw_manage_arp_cache(iwdev,
2294 iwdev->arp_table[arpindex].mac_addr,
2295 dest,
2296 false,
2297 I40IW_ARP_DELETE);
2298 }
2299 i40iw_manage_arp_cache(iwdev,
2300 neigh->ha,
2301 dest,
2302 false,
2303 I40IW_ARP_ADD);
2304 rc = i40iw_arp_table(iwdev,
2305 dest,
2306 false,
2307 NULL,
2308 I40IW_ARP_RESOLVE);
2309 } else {
2310 neigh_event_send(neigh, NULL);
2311 }
2312 }
2313
2314 resolve_neigh_exit6:
2315 rcu_read_unlock();
2316 if (neigh)
2317 neigh_release(neigh);
2318 dst_release(dst);
2319 return rc;
2320}
2321#endif
2322
2323/**
2324 * i40iw_ipv4_is_loopback - check if loopback
2325 * @loc_addr: local addr to compare
2326 * @rem_addr: remote address
2327 */
2328static bool i40iw_ipv4_is_loopback(u32 loc_addr, u32 rem_addr)
2329{
2330 return ipv4_is_loopback(htonl(rem_addr)) || (loc_addr == rem_addr);
2331}
2332
2333/**
2334 * i40iw_ipv6_is_loopback - check if loopback
2335 * @loc_addr: local addr to compare
2336 * @rem_addr: remote address
2337 */
2338static bool i40iw_ipv6_is_loopback(u32 *loc_addr, u32 *rem_addr)
2339{
2340 struct in6_addr raddr6;
2341
2342 i40iw_copy_ip_htonl(raddr6.in6_u.u6_addr32, rem_addr);
2343 return (!memcmp(loc_addr, rem_addr, 16) || ipv6_addr_loopback(&raddr6));
2344}
2345
2346/**
2347 * i40iw_make_cm_node - create a new instance of a cm node
2348 * @cm_core: cm's core
2349 * @iwdev: iwarp device structure
2350 * @cm_info: quad info for connection
2351 * @listener: passive connection's listener
2352 */
2353static struct i40iw_cm_node *i40iw_make_cm_node(
2354 struct i40iw_cm_core *cm_core,
2355 struct i40iw_device *iwdev,
2356 struct i40iw_cm_info *cm_info,
2357 struct i40iw_cm_listener *listener)
2358{
2359 struct i40iw_cm_node *cm_node;
2360 struct timespec ts;
2361 int oldarpindex;
2362 int arpindex;
2363 struct net_device *netdev = iwdev->netdev;
2364
2365 /* create an hte and cm_node for this instance */
2366 cm_node = kzalloc(sizeof(*cm_node), GFP_ATOMIC);
2367 if (!cm_node)
2368 return NULL;
2369
2370 /* set our node specific transport info */
2371 cm_node->ipv4 = cm_info->ipv4;
2372 cm_node->vlan_id = cm_info->vlan_id;
2373 memcpy(cm_node->loc_addr, cm_info->loc_addr, sizeof(cm_node->loc_addr));
2374 memcpy(cm_node->rem_addr, cm_info->rem_addr, sizeof(cm_node->rem_addr));
2375 memcpy(cm_node->map_loc_addr, cm_info->map_loc_addr,
2376 sizeof(cm_node->map_loc_addr));
2377 memcpy(cm_node->map_rem_addr, cm_info->map_rem_addr,
2378 sizeof(cm_node->map_rem_addr));
2379 cm_node->loc_port = cm_info->loc_port;
2380 cm_node->rem_port = cm_info->rem_port;
2381 cm_node->map_loc_port = cm_info->map_loc_port;
2382 cm_node->map_rem_port = cm_info->map_rem_port;
2383
2384 cm_node->mpa_frame_rev = iwdev->mpa_version;
2385 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
2386 cm_node->ird_size = I40IW_MAX_IRD_SIZE;
2387 cm_node->ord_size = I40IW_MAX_ORD_SIZE;
2388
2389 cm_node->listener = listener;
2390 cm_node->cm_id = cm_info->cm_id;
2391 ether_addr_copy(cm_node->loc_mac, netdev->dev_addr);
2392 spin_lock_init(&cm_node->retrans_list_lock);
2393
2394 atomic_set(&cm_node->ref_count, 1);
2395 /* associate our parent CM core */
2396 cm_node->cm_core = cm_core;
2397 cm_node->tcp_cntxt.loc_id = I40IW_CM_DEF_LOCAL_ID;
2398 cm_node->tcp_cntxt.rcv_wscale = I40IW_CM_DEFAULT_RCV_WND_SCALE;
2399 cm_node->tcp_cntxt.rcv_wnd =
2400 I40IW_CM_DEFAULT_RCV_WND_SCALED >> I40IW_CM_DEFAULT_RCV_WND_SCALE;
2401 ts = current_kernel_time();
2402 cm_node->tcp_cntxt.loc_seq_num = htonl(ts.tv_nsec);
2403 cm_node->tcp_cntxt.mss = iwdev->mss;
2404
2405 cm_node->iwdev = iwdev;
2406 cm_node->dev = &iwdev->sc_dev;
2407
2408 if ((cm_node->ipv4 &&
2409 i40iw_ipv4_is_loopback(cm_node->loc_addr[0], cm_node->rem_addr[0])) ||
2410 (!cm_node->ipv4 && i40iw_ipv6_is_loopback(cm_node->loc_addr,
2411 cm_node->rem_addr))) {
2412 arpindex = i40iw_arp_table(iwdev,
2413 cm_node->map_rem_addr,
2414 false,
2415 NULL,
2416 I40IW_ARP_RESOLVE);
2417 } else {
2418 oldarpindex = i40iw_arp_table(iwdev,
2419 cm_node->map_rem_addr,
2420 false,
2421 NULL,
2422 I40IW_ARP_RESOLVE);
2423 if (cm_node->ipv4)
2424 arpindex = i40iw_addr_resolve_neigh(iwdev,
2425 cm_info->map_loc_addr[0],
2426 cm_info->map_rem_addr[0],
2427 oldarpindex);
2428#if IS_ENABLED(CONFIG_IPV6)
2429 else
2430 arpindex = i40iw_addr_resolve_neigh_ipv6(iwdev,
2431 cm_info->map_loc_addr,
2432 cm_info->map_rem_addr,
2433 oldarpindex);
2434#endif
2435 }
2436 if (arpindex < 0) {
2437 i40iw_pr_err("cm_node arpindex\n");
2438 kfree(cm_node);
2439 return NULL;
2440 }
2441 ether_addr_copy(cm_node->rem_mac, iwdev->arp_table[arpindex].mac_addr);
2442 i40iw_add_hte_node(cm_core, cm_node);
2443 cm_core->stats_nodes_created++;
2444 return cm_node;
2445}
2446
2447/**
2448 * i40iw_rem_ref_cm_node - destroy an instance of a cm node
2449 * @cm_node: connection's node
2450 */
2451static void i40iw_rem_ref_cm_node(struct i40iw_cm_node *cm_node)
2452{
2453 struct i40iw_cm_core *cm_core = cm_node->cm_core;
2454 struct i40iw_qp *iwqp;
2455 struct i40iw_cm_info nfo;
2456 unsigned long flags;
2457
2458 spin_lock_irqsave(&cm_node->cm_core->ht_lock, flags);
2459 if (atomic_dec_return(&cm_node->ref_count)) {
2460 spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags);
2461 return;
2462 }
2463 list_del(&cm_node->list);
2464 spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags);
2465
2466 /* if the node is destroyed before connection was accelerated */
2467 if (!cm_node->accelerated && cm_node->accept_pend) {
2468 pr_err("node destroyed before established\n");
2469 atomic_dec(&cm_node->listener->pend_accepts_cnt);
2470 }
2471 if (cm_node->close_entry)
2472 i40iw_handle_close_entry(cm_node, 0);
2473 if (cm_node->listener) {
2474 i40iw_dec_refcnt_listen(cm_core, cm_node->listener, 0, true);
2475 } else {
2476 if (!i40iw_listen_port_in_use(cm_core, htons(cm_node->map_loc_port)) &&
2477 cm_node->apbvt_set && cm_node->iwdev) {
2478 i40iw_manage_apbvt(cm_node->iwdev,
2479 cm_node->map_loc_port,
2480 I40IW_MANAGE_APBVT_DEL);
2481 i40iw_get_addr_info(cm_node, &nfo);
2482 i40iw_remove_mapinfo(&nfo);
2483 if (cm_node->qhash_set) {
2484 i40iw_manage_qhash(cm_node->iwdev,
2485 &nfo,
2486 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
2487 I40IW_QHASH_MANAGE_TYPE_DELETE,
2488 NULL,
2489 false);
2490 cm_node->qhash_set = 0;
2491 }
2492 }
2493 }
2494
2495 iwqp = cm_node->iwqp;
2496 if (iwqp) {
2497 iwqp->cm_node = NULL;
2498 i40iw_rem_ref(&iwqp->ibqp);
2499 cm_node->iwqp = NULL;
2500 } else if (cm_node->qhash_set) {
2501 i40iw_get_addr_info(cm_node, &nfo);
2502 i40iw_remove_mapinfo(&nfo);
2503 i40iw_manage_qhash(cm_node->iwdev,
2504 &nfo,
2505 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
2506 I40IW_QHASH_MANAGE_TYPE_DELETE,
2507 NULL,
2508 false);
2509 cm_node->qhash_set = 0;
2510 }
2511
2512 cm_node->cm_core->stats_nodes_destroyed++;
2513 kfree(cm_node);
2514}
2515
2516/**
2517 * i40iw_handle_fin_pkt - FIN packet received
2518 * @cm_node: connection's node
2519 */
2520static void i40iw_handle_fin_pkt(struct i40iw_cm_node *cm_node)
2521{
2522 u32 ret;
2523
2524 switch (cm_node->state) {
2525 case I40IW_CM_STATE_SYN_RCVD:
2526 case I40IW_CM_STATE_SYN_SENT:
2527 case I40IW_CM_STATE_ESTABLISHED:
2528 case I40IW_CM_STATE_MPAREJ_RCVD:
2529 cm_node->tcp_cntxt.rcv_nxt++;
2530 i40iw_cleanup_retrans_entry(cm_node);
2531 cm_node->state = I40IW_CM_STATE_LAST_ACK;
2532 i40iw_send_fin(cm_node);
2533 break;
2534 case I40IW_CM_STATE_MPAREQ_SENT:
2535 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
2536 cm_node->tcp_cntxt.rcv_nxt++;
2537 i40iw_cleanup_retrans_entry(cm_node);
2538 cm_node->state = I40IW_CM_STATE_CLOSED;
2539 atomic_inc(&cm_node->ref_count);
2540 i40iw_send_reset(cm_node);
2541 break;
2542 case I40IW_CM_STATE_FIN_WAIT1:
2543 cm_node->tcp_cntxt.rcv_nxt++;
2544 i40iw_cleanup_retrans_entry(cm_node);
2545 cm_node->state = I40IW_CM_STATE_CLOSING;
2546 i40iw_send_ack(cm_node);
2547 /*
2548 * Wait for ACK as this is simultaneous close.
2549 * After we receive ACK, do not send anything.
2550 * Just rm the node.
2551 */
2552 break;
2553 case I40IW_CM_STATE_FIN_WAIT2:
2554 cm_node->tcp_cntxt.rcv_nxt++;
2555 i40iw_cleanup_retrans_entry(cm_node);
2556 cm_node->state = I40IW_CM_STATE_TIME_WAIT;
2557 i40iw_send_ack(cm_node);
2558 ret =
2559 i40iw_schedule_cm_timer(cm_node, NULL, I40IW_TIMER_TYPE_CLOSE, 1, 0);
2560 if (ret)
2561 i40iw_pr_err("node %p state = %d\n", cm_node, cm_node->state);
2562 break;
2563 case I40IW_CM_STATE_TIME_WAIT:
2564 cm_node->tcp_cntxt.rcv_nxt++;
2565 i40iw_cleanup_retrans_entry(cm_node);
2566 cm_node->state = I40IW_CM_STATE_CLOSED;
2567 i40iw_rem_ref_cm_node(cm_node);
2568 break;
2569 case I40IW_CM_STATE_OFFLOADED:
2570 default:
2571 i40iw_pr_err("bad state node %p state = %d\n", cm_node, cm_node->state);
2572 break;
2573 }
2574}
2575
2576/**
2577 * i40iw_handle_rst_pkt - process received RST packet
2578 * @cm_node: connection's node
2579 * @rbuf: receive buffer
2580 */
2581static void i40iw_handle_rst_pkt(struct i40iw_cm_node *cm_node,
2582 struct i40iw_puda_buf *rbuf)
2583{
2584 i40iw_cleanup_retrans_entry(cm_node);
2585 switch (cm_node->state) {
2586 case I40IW_CM_STATE_SYN_SENT:
2587 case I40IW_CM_STATE_MPAREQ_SENT:
2588 switch (cm_node->mpa_frame_rev) {
2589 case IETF_MPA_V2:
2590 cm_node->mpa_frame_rev = IETF_MPA_V1;
2591 /* send a syn and goto syn sent state */
2592 cm_node->state = I40IW_CM_STATE_SYN_SENT;
2593 if (i40iw_send_syn(cm_node, 0))
2594 i40iw_active_open_err(cm_node, false);
2595 break;
2596 case IETF_MPA_V1:
2597 default:
2598 i40iw_active_open_err(cm_node, false);
2599 break;
2600 }
2601 break;
2602 case I40IW_CM_STATE_MPAREQ_RCVD:
2603 atomic_add_return(1, &cm_node->passive_state);
2604 break;
2605 case I40IW_CM_STATE_ESTABLISHED:
2606 case I40IW_CM_STATE_SYN_RCVD:
2607 case I40IW_CM_STATE_LISTENING:
2608 i40iw_pr_err("Bad state state = %d\n", cm_node->state);
2609 i40iw_passive_open_err(cm_node, false);
2610 break;
2611 case I40IW_CM_STATE_OFFLOADED:
2612 i40iw_active_open_err(cm_node, false);
2613 break;
2614 case I40IW_CM_STATE_CLOSED:
2615 break;
2616 case I40IW_CM_STATE_FIN_WAIT2:
2617 case I40IW_CM_STATE_FIN_WAIT1:
2618 case I40IW_CM_STATE_LAST_ACK:
2619 cm_node->cm_id->rem_ref(cm_node->cm_id);
2620 case I40IW_CM_STATE_TIME_WAIT:
2621 cm_node->state = I40IW_CM_STATE_CLOSED;
2622 i40iw_rem_ref_cm_node(cm_node);
2623 break;
2624 default:
2625 break;
2626 }
2627}
2628
2629/**
2630 * i40iw_handle_rcv_mpa - Process a recv'd mpa buffer
2631 * @cm_node: connection's node
2632 * @rbuf: receive buffer
2633 */
2634static void i40iw_handle_rcv_mpa(struct i40iw_cm_node *cm_node,
2635 struct i40iw_puda_buf *rbuf)
2636{
2637 int ret;
2638 int datasize = rbuf->datalen;
2639 u8 *dataloc = rbuf->data;
2640
2641 enum i40iw_cm_event_type type = I40IW_CM_EVENT_UNKNOWN;
2642 u32 res_type;
2643
2644 ret = i40iw_parse_mpa(cm_node, dataloc, &res_type, datasize);
2645 if (ret) {
2646 if (cm_node->state == I40IW_CM_STATE_MPAREQ_SENT)
2647 i40iw_active_open_err(cm_node, true);
2648 else
2649 i40iw_passive_open_err(cm_node, true);
2650 return;
2651 }
2652
2653 switch (cm_node->state) {
2654 case I40IW_CM_STATE_ESTABLISHED:
2655 if (res_type == I40IW_MPA_REQUEST_REJECT)
2656 i40iw_pr_err("state for reject\n");
2657 cm_node->state = I40IW_CM_STATE_MPAREQ_RCVD;
2658 type = I40IW_CM_EVENT_MPA_REQ;
2659 i40iw_send_ack(cm_node); /* ACK received MPA request */
2660 atomic_set(&cm_node->passive_state,
2661 I40IW_PASSIVE_STATE_INDICATED);
2662 break;
2663 case I40IW_CM_STATE_MPAREQ_SENT:
2664 i40iw_cleanup_retrans_entry(cm_node);
2665 if (res_type == I40IW_MPA_REQUEST_REJECT) {
2666 type = I40IW_CM_EVENT_MPA_REJECT;
2667 cm_node->state = I40IW_CM_STATE_MPAREJ_RCVD;
2668 } else {
2669 type = I40IW_CM_EVENT_CONNECTED;
2670 cm_node->state = I40IW_CM_STATE_OFFLOADED;
2671 i40iw_send_ack(cm_node);
2672 }
2673 break;
2674 default:
2675 pr_err("%s wrong cm_node state =%d\n", __func__, cm_node->state);
2676 break;
2677 }
2678 i40iw_create_event(cm_node, type);
2679}
2680
2681/**
2682 * i40iw_indicate_pkt_err - Send up err event to cm
2683 * @cm_node: connection's node
2684 */
2685static void i40iw_indicate_pkt_err(struct i40iw_cm_node *cm_node)
2686{
2687 switch (cm_node->state) {
2688 case I40IW_CM_STATE_SYN_SENT:
2689 case I40IW_CM_STATE_MPAREQ_SENT:
2690 i40iw_active_open_err(cm_node, true);
2691 break;
2692 case I40IW_CM_STATE_ESTABLISHED:
2693 case I40IW_CM_STATE_SYN_RCVD:
2694 i40iw_passive_open_err(cm_node, true);
2695 break;
2696 case I40IW_CM_STATE_OFFLOADED:
2697 default:
2698 break;
2699 }
2700}
2701
2702/**
2703 * i40iw_check_syn - Check for error on received syn ack
2704 * @cm_node: connection's node
2705 * @tcph: pointer tcp header
2706 */
2707static int i40iw_check_syn(struct i40iw_cm_node *cm_node, struct tcphdr *tcph)
2708{
2709 int err = 0;
2710
2711 if (ntohl(tcph->ack_seq) != cm_node->tcp_cntxt.loc_seq_num) {
2712 err = 1;
2713 i40iw_active_open_err(cm_node, true);
2714 }
2715 return err;
2716}
2717
2718/**
2719 * i40iw_check_seq - check seq numbers if OK
2720 * @cm_node: connection's node
2721 * @tcph: pointer tcp header
2722 */
2723static int i40iw_check_seq(struct i40iw_cm_node *cm_node, struct tcphdr *tcph)
2724{
2725 int err = 0;
2726 u32 seq;
2727 u32 ack_seq;
2728 u32 loc_seq_num = cm_node->tcp_cntxt.loc_seq_num;
2729 u32 rcv_nxt = cm_node->tcp_cntxt.rcv_nxt;
2730 u32 rcv_wnd;
2731
2732 seq = ntohl(tcph->seq);
2733 ack_seq = ntohl(tcph->ack_seq);
2734 rcv_wnd = cm_node->tcp_cntxt.rcv_wnd;
2735 if (ack_seq != loc_seq_num)
2736 err = -1;
2737 else if (!between(seq, rcv_nxt, (rcv_nxt + rcv_wnd)))
2738 err = -1;
2739 if (err) {
2740 i40iw_pr_err("seq number\n");
2741 i40iw_indicate_pkt_err(cm_node);
2742 }
2743 return err;
2744}
2745
2746/**
2747 * i40iw_handle_syn_pkt - is for Passive node
2748 * @cm_node: connection's node
2749 * @rbuf: receive buffer
2750 */
2751static void i40iw_handle_syn_pkt(struct i40iw_cm_node *cm_node,
2752 struct i40iw_puda_buf *rbuf)
2753{
2754 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2755 int ret;
2756 u32 inc_sequence;
2757 int optionsize;
2758 struct i40iw_cm_info nfo;
2759
2760 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
2761 inc_sequence = ntohl(tcph->seq);
2762
2763 switch (cm_node->state) {
2764 case I40IW_CM_STATE_SYN_SENT:
2765 case I40IW_CM_STATE_MPAREQ_SENT:
2766 /* Rcvd syn on active open connection */
2767 i40iw_active_open_err(cm_node, 1);
2768 break;
2769 case I40IW_CM_STATE_LISTENING:
2770 /* Passive OPEN */
2771 if (atomic_read(&cm_node->listener->pend_accepts_cnt) >
2772 cm_node->listener->backlog) {
2773 cm_node->cm_core->stats_backlog_drops++;
2774 i40iw_passive_open_err(cm_node, false);
2775 break;
2776 }
2777 ret = i40iw_handle_tcp_options(cm_node, tcph, optionsize, 1);
2778 if (ret) {
2779 i40iw_passive_open_err(cm_node, false);
2780 /* drop pkt */
2781 break;
2782 }
2783 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
2784 cm_node->accept_pend = 1;
2785 atomic_inc(&cm_node->listener->pend_accepts_cnt);
2786
2787 cm_node->state = I40IW_CM_STATE_SYN_RCVD;
2788 i40iw_get_addr_info(cm_node, &nfo);
2789 ret = i40iw_manage_qhash(cm_node->iwdev,
2790 &nfo,
2791 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
2792 I40IW_QHASH_MANAGE_TYPE_ADD,
2793 (void *)cm_node,
2794 false);
2795 cm_node->qhash_set = true;
2796 break;
2797 case I40IW_CM_STATE_CLOSED:
2798 i40iw_cleanup_retrans_entry(cm_node);
2799 atomic_inc(&cm_node->ref_count);
2800 i40iw_send_reset(cm_node);
2801 break;
2802 case I40IW_CM_STATE_OFFLOADED:
2803 case I40IW_CM_STATE_ESTABLISHED:
2804 case I40IW_CM_STATE_FIN_WAIT1:
2805 case I40IW_CM_STATE_FIN_WAIT2:
2806 case I40IW_CM_STATE_MPAREQ_RCVD:
2807 case I40IW_CM_STATE_LAST_ACK:
2808 case I40IW_CM_STATE_CLOSING:
2809 case I40IW_CM_STATE_UNKNOWN:
2810 default:
2811 break;
2812 }
2813}
2814
2815/**
2816 * i40iw_handle_synack_pkt - Process SYN+ACK packet (active side)
2817 * @cm_node: connection's node
2818 * @rbuf: receive buffer
2819 */
2820static void i40iw_handle_synack_pkt(struct i40iw_cm_node *cm_node,
2821 struct i40iw_puda_buf *rbuf)
2822{
2823 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2824 int ret;
2825 u32 inc_sequence;
2826 int optionsize;
2827
2828 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
2829 inc_sequence = ntohl(tcph->seq);
2830 switch (cm_node->state) {
2831 case I40IW_CM_STATE_SYN_SENT:
2832 i40iw_cleanup_retrans_entry(cm_node);
2833 /* active open */
2834 if (i40iw_check_syn(cm_node, tcph)) {
2835 i40iw_pr_err("check syn fail\n");
2836 return;
2837 }
2838 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2839 /* setup options */
2840 ret = i40iw_handle_tcp_options(cm_node, tcph, optionsize, 0);
2841 if (ret) {
2842 i40iw_debug(cm_node->dev,
2843 I40IW_DEBUG_CM,
2844 "cm_node=%p tcp_options failed\n",
2845 cm_node);
2846 break;
2847 }
2848 i40iw_cleanup_retrans_entry(cm_node);
2849 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
2850 i40iw_send_ack(cm_node); /* ACK for the syn_ack */
2851 ret = i40iw_send_mpa_request(cm_node);
2852 if (ret) {
2853 i40iw_debug(cm_node->dev,
2854 I40IW_DEBUG_CM,
2855 "cm_node=%p i40iw_send_mpa_request failed\n",
2856 cm_node);
2857 break;
2858 }
2859 cm_node->state = I40IW_CM_STATE_MPAREQ_SENT;
2860 break;
2861 case I40IW_CM_STATE_MPAREQ_RCVD:
2862 i40iw_passive_open_err(cm_node, true);
2863 break;
2864 case I40IW_CM_STATE_LISTENING:
2865 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
2866 i40iw_cleanup_retrans_entry(cm_node);
2867 cm_node->state = I40IW_CM_STATE_CLOSED;
2868 i40iw_send_reset(cm_node);
2869 break;
2870 case I40IW_CM_STATE_CLOSED:
2871 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
2872 i40iw_cleanup_retrans_entry(cm_node);
2873 atomic_inc(&cm_node->ref_count);
2874 i40iw_send_reset(cm_node);
2875 break;
2876 case I40IW_CM_STATE_ESTABLISHED:
2877 case I40IW_CM_STATE_FIN_WAIT1:
2878 case I40IW_CM_STATE_FIN_WAIT2:
2879 case I40IW_CM_STATE_LAST_ACK:
2880 case I40IW_CM_STATE_OFFLOADED:
2881 case I40IW_CM_STATE_CLOSING:
2882 case I40IW_CM_STATE_UNKNOWN:
2883 case I40IW_CM_STATE_MPAREQ_SENT:
2884 default:
2885 break;
2886 }
2887}
2888
2889/**
2890 * i40iw_handle_ack_pkt - process packet with ACK
2891 * @cm_node: connection's node
2892 * @rbuf: receive buffer
2893 */
2894static int i40iw_handle_ack_pkt(struct i40iw_cm_node *cm_node,
2895 struct i40iw_puda_buf *rbuf)
2896{
2897 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2898 u32 inc_sequence;
2899 int ret = 0;
2900 int optionsize;
2901 u32 datasize = rbuf->datalen;
2902
2903 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
2904
2905 if (i40iw_check_seq(cm_node, tcph))
2906 return -EINVAL;
2907
2908 inc_sequence = ntohl(tcph->seq);
2909 switch (cm_node->state) {
2910 case I40IW_CM_STATE_SYN_RCVD:
2911 i40iw_cleanup_retrans_entry(cm_node);
2912 ret = i40iw_handle_tcp_options(cm_node, tcph, optionsize, 1);
2913 if (ret)
2914 break;
2915 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2916 cm_node->state = I40IW_CM_STATE_ESTABLISHED;
2917 if (datasize) {
2918 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2919 i40iw_get_remote_addr(cm_node);
2920 i40iw_handle_rcv_mpa(cm_node, rbuf);
2921 }
2922 break;
2923 case I40IW_CM_STATE_ESTABLISHED:
2924 i40iw_cleanup_retrans_entry(cm_node);
2925 if (datasize) {
2926 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2927 i40iw_handle_rcv_mpa(cm_node, rbuf);
2928 }
2929 break;
2930 case I40IW_CM_STATE_MPAREQ_SENT:
2931 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
2932 if (datasize) {
2933 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
2934 i40iw_handle_rcv_mpa(cm_node, rbuf);
2935 }
2936 break;
2937 case I40IW_CM_STATE_LISTENING:
2938 i40iw_cleanup_retrans_entry(cm_node);
2939 cm_node->state = I40IW_CM_STATE_CLOSED;
2940 i40iw_send_reset(cm_node);
2941 break;
2942 case I40IW_CM_STATE_CLOSED:
2943 i40iw_cleanup_retrans_entry(cm_node);
2944 atomic_inc(&cm_node->ref_count);
2945 i40iw_send_reset(cm_node);
2946 break;
2947 case I40IW_CM_STATE_LAST_ACK:
2948 case I40IW_CM_STATE_CLOSING:
2949 i40iw_cleanup_retrans_entry(cm_node);
2950 cm_node->state = I40IW_CM_STATE_CLOSED;
2951 if (!cm_node->accept_pend)
2952 cm_node->cm_id->rem_ref(cm_node->cm_id);
2953 i40iw_rem_ref_cm_node(cm_node);
2954 break;
2955 case I40IW_CM_STATE_FIN_WAIT1:
2956 i40iw_cleanup_retrans_entry(cm_node);
2957 cm_node->state = I40IW_CM_STATE_FIN_WAIT2;
2958 break;
2959 case I40IW_CM_STATE_SYN_SENT:
2960 case I40IW_CM_STATE_FIN_WAIT2:
2961 case I40IW_CM_STATE_OFFLOADED:
2962 case I40IW_CM_STATE_MPAREQ_RCVD:
2963 case I40IW_CM_STATE_UNKNOWN:
2964 default:
2965 i40iw_cleanup_retrans_entry(cm_node);
2966 break;
2967 }
2968 return ret;
2969}
2970
2971/**
2972 * i40iw_process_packet - process cm packet
2973 * @cm_node: connection's node
2974 * @rbuf: receive buffer
2975 */
2976static void i40iw_process_packet(struct i40iw_cm_node *cm_node,
2977 struct i40iw_puda_buf *rbuf)
2978{
2979 enum i40iw_tcpip_pkt_type pkt_type = I40IW_PKT_TYPE_UNKNOWN;
2980 struct tcphdr *tcph = (struct tcphdr *)rbuf->tcph;
2981 u32 fin_set = 0;
2982 int ret;
2983
2984 if (tcph->rst) {
2985 pkt_type = I40IW_PKT_TYPE_RST;
2986 } else if (tcph->syn) {
2987 pkt_type = I40IW_PKT_TYPE_SYN;
2988 if (tcph->ack)
2989 pkt_type = I40IW_PKT_TYPE_SYNACK;
2990 } else if (tcph->ack) {
2991 pkt_type = I40IW_PKT_TYPE_ACK;
2992 }
2993 if (tcph->fin)
2994 fin_set = 1;
2995
2996 switch (pkt_type) {
2997 case I40IW_PKT_TYPE_SYN:
2998 i40iw_handle_syn_pkt(cm_node, rbuf);
2999 break;
3000 case I40IW_PKT_TYPE_SYNACK:
3001 i40iw_handle_synack_pkt(cm_node, rbuf);
3002 break;
3003 case I40IW_PKT_TYPE_ACK:
3004 ret = i40iw_handle_ack_pkt(cm_node, rbuf);
3005 if (fin_set && !ret)
3006 i40iw_handle_fin_pkt(cm_node);
3007 break;
3008 case I40IW_PKT_TYPE_RST:
3009 i40iw_handle_rst_pkt(cm_node, rbuf);
3010 break;
3011 default:
3012 if (fin_set &&
3013 (!i40iw_check_seq(cm_node, (struct tcphdr *)rbuf->tcph)))
3014 i40iw_handle_fin_pkt(cm_node);
3015 break;
3016 }
3017}
3018
3019/**
3020 * i40iw_make_listen_node - create a listen node with params
3021 * @cm_core: cm's core
3022 * @iwdev: iwarp device structure
3023 * @cm_info: quad info for connection
3024 */
3025static struct i40iw_cm_listener *i40iw_make_listen_node(
3026 struct i40iw_cm_core *cm_core,
3027 struct i40iw_device *iwdev,
3028 struct i40iw_cm_info *cm_info)
3029{
3030 struct i40iw_cm_listener *listener;
3031 struct iwpm_dev_data pm_reg_msg;
3032 struct iwpm_sa_data pm_msg;
3033 int iwpm_err;
3034 unsigned long flags;
3035
3036 /* cannot have multiple matching listeners */
3037 listener = i40iw_find_listener(cm_core, cm_info->loc_addr,
3038 cm_info->loc_port,
3039 cm_info->vlan_id,
3040 I40IW_CM_LISTENER_EITHER_STATE,
3041 false);
3042 if (listener &&
3043 (listener->listener_state == I40IW_CM_LISTENER_ACTIVE_STATE)) {
3044 atomic_dec(&listener->ref_count);
3045 i40iw_debug(cm_core->dev,
3046 I40IW_DEBUG_CM,
3047 "Not creating listener since it already exists\n");
3048 return NULL;
3049 }
3050
3051 if (!listener) {
3052 i40iw_form_reg_msg(iwdev, &pm_reg_msg);
3053 iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_I40IW);
3054 if (iwpm_err)
3055 i40iw_pr_err("PM register fail err = %d\n",
3056 iwpm_err);
3057
3058 if (iwpm_valid_pid() && !iwpm_err) {
3059 i40iw_form_pm_msg(cm_info, &pm_msg);
3060 iwpm_err = iwpm_add_mapping(&pm_msg, RDMA_NL_I40IW);
3061 if (iwpm_err)
3062 i40iw_pr_err("PM query fail err = %d\n",
3063 iwpm_err);
3064 else
3065 i40iw_record_pm_msg(cm_info, &pm_msg, false);
3066 }
3067
3068 /* create a CM listen node (1/2 node to compare incoming traffic to) */
3069 listener = kzalloc(sizeof(*listener), GFP_ATOMIC);
3070 if (!listener)
3071 return NULL;
3072 cm_core->stats_listen_nodes_created++;
3073 memcpy(listener->loc_addr, cm_info->loc_addr, sizeof(listener->loc_addr));
3074 memcpy(listener->map_loc_addr, cm_info->map_loc_addr,
3075 sizeof(listener->map_loc_addr));
3076 listener->loc_port = cm_info->loc_port;
3077 listener->map_loc_port = cm_info->map_loc_port;
3078
3079 INIT_LIST_HEAD(&listener->child_listen_list);
3080
3081 atomic_set(&listener->ref_count, 1);
3082 } else {
3083 listener->reused_node = 1;
3084 }
3085
3086 listener->cm_id = cm_info->cm_id;
3087 listener->ipv4 = cm_info->ipv4;
3088 listener->vlan_id = cm_info->vlan_id;
3089 atomic_set(&listener->pend_accepts_cnt, 0);
3090 listener->cm_core = cm_core;
3091 listener->iwdev = iwdev;
3092
3093 listener->backlog = cm_info->backlog;
3094 listener->listener_state = I40IW_CM_LISTENER_ACTIVE_STATE;
3095
3096 if (!listener->reused_node) {
3097 spin_lock_irqsave(&cm_core->listen_list_lock, flags);
3098 list_add(&listener->list, &cm_core->listen_nodes);
3099 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
3100 }
3101
3102 return listener;
3103}
3104
3105/**
3106 * i40iw_create_cm_node - make a connection node with params
3107 * @cm_core: cm's core
3108 * @iwdev: iwarp device structure
3109 * @private_data_len: len to provate data for mpa request
3110 * @private_data: pointer to private data for connection
3111 * @cm_info: quad info for connection
3112 */
3113static struct i40iw_cm_node *i40iw_create_cm_node(
3114 struct i40iw_cm_core *cm_core,
3115 struct i40iw_device *iwdev,
3116 u16 private_data_len,
3117 void *private_data,
3118 struct i40iw_cm_info *cm_info)
3119{
3120 int ret;
3121 struct i40iw_cm_node *cm_node;
3122 struct i40iw_cm_listener *loopback_remotelistener;
3123 struct i40iw_cm_node *loopback_remotenode;
3124 struct i40iw_cm_info loopback_cm_info;
3125
3126 /* create a CM connection node */
3127 cm_node = i40iw_make_cm_node(cm_core, iwdev, cm_info, NULL);
3128 if (!cm_node)
3129 return NULL;
3130 /* set our node side to client (active) side */
3131 cm_node->tcp_cntxt.client = 1;
3132 cm_node->tcp_cntxt.rcv_wscale = I40IW_CM_DEFAULT_RCV_WND_SCALE;
3133
3134 if (!memcmp(cm_info->loc_addr, cm_info->rem_addr, sizeof(cm_info->loc_addr))) {
3135 loopback_remotelistener = i40iw_find_listener(
3136 cm_core,
3137 cm_info->map_rem_addr,
3138 cm_node->map_rem_port,
3139 cm_node->vlan_id,
3140 I40IW_CM_LISTENER_ACTIVE_STATE,
3141 true);
3142 if (!loopback_remotelistener) {
3143 i40iw_create_event(cm_node, I40IW_CM_EVENT_ABORTED);
3144 } else {
3145 loopback_cm_info = *cm_info;
3146 loopback_cm_info.loc_port = cm_info->rem_port;
3147 loopback_cm_info.rem_port = cm_info->loc_port;
3148 loopback_cm_info.map_loc_port = cm_info->map_rem_port;
3149 loopback_cm_info.map_rem_port = cm_info->map_loc_port;
3150 loopback_cm_info.cm_id = loopback_remotelistener->cm_id;
3151 loopback_cm_info.ipv4 = cm_info->ipv4;
3152 loopback_remotenode = i40iw_make_cm_node(cm_core,
3153 iwdev,
3154 &loopback_cm_info,
3155 loopback_remotelistener);
3156 if (!loopback_remotenode) {
3157 i40iw_rem_ref_cm_node(cm_node);
3158 return NULL;
3159 }
3160 cm_core->stats_loopbacks++;
3161 loopback_remotenode->loopbackpartner = cm_node;
3162 loopback_remotenode->tcp_cntxt.rcv_wscale =
3163 I40IW_CM_DEFAULT_RCV_WND_SCALE;
3164 cm_node->loopbackpartner = loopback_remotenode;
3165 memcpy(loopback_remotenode->pdata_buf, private_data,
3166 private_data_len);
3167 loopback_remotenode->pdata.size = private_data_len;
3168
3169 cm_node->state = I40IW_CM_STATE_OFFLOADED;
3170 cm_node->tcp_cntxt.rcv_nxt =
3171 loopback_remotenode->tcp_cntxt.loc_seq_num;
3172 loopback_remotenode->tcp_cntxt.rcv_nxt =
3173 cm_node->tcp_cntxt.loc_seq_num;
3174 cm_node->tcp_cntxt.max_snd_wnd =
3175 loopback_remotenode->tcp_cntxt.rcv_wnd;
3176 loopback_remotenode->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.rcv_wnd;
3177 cm_node->tcp_cntxt.snd_wnd = loopback_remotenode->tcp_cntxt.rcv_wnd;
3178 loopback_remotenode->tcp_cntxt.snd_wnd = cm_node->tcp_cntxt.rcv_wnd;
3179 cm_node->tcp_cntxt.snd_wscale = loopback_remotenode->tcp_cntxt.rcv_wscale;
3180 loopback_remotenode->tcp_cntxt.snd_wscale = cm_node->tcp_cntxt.rcv_wscale;
3181 loopback_remotenode->state = I40IW_CM_STATE_MPAREQ_RCVD;
3182 i40iw_create_event(loopback_remotenode, I40IW_CM_EVENT_MPA_REQ);
3183 }
3184 return cm_node;
3185 }
3186
3187 cm_node->pdata.size = private_data_len;
3188 cm_node->pdata.addr = cm_node->pdata_buf;
3189
3190 memcpy(cm_node->pdata_buf, private_data, private_data_len);
3191
3192 cm_node->state = I40IW_CM_STATE_SYN_SENT;
3193 ret = i40iw_send_syn(cm_node, 0);
3194
3195 if (ret) {
3196 if (cm_node->ipv4)
3197 i40iw_debug(cm_node->dev,
3198 I40IW_DEBUG_CM,
3199 "Api - connect() FAILED: dest addr=%pI4",
3200 cm_node->rem_addr);
3201 else
3202 i40iw_debug(cm_node->dev, I40IW_DEBUG_CM,
3203 "Api - connect() FAILED: dest addr=%pI6",
3204 cm_node->rem_addr);
3205 i40iw_rem_ref_cm_node(cm_node);
3206 cm_node = NULL;
3207 }
3208
3209 if (cm_node)
3210 i40iw_debug(cm_node->dev,
3211 I40IW_DEBUG_CM,
3212 "Api - connect(): port=0x%04x, cm_node=%p, cm_id = %p.\n",
3213 cm_node->rem_port,
3214 cm_node,
3215 cm_node->cm_id);
3216
3217 return cm_node;
3218}
3219
3220/**
3221 * i40iw_cm_reject - reject and teardown a connection
3222 * @cm_node: connection's node
3223 * @pdate: ptr to private data for reject
3224 * @plen: size of private data
3225 */
3226static int i40iw_cm_reject(struct i40iw_cm_node *cm_node, const void *pdata, u8 plen)
3227{
3228 int ret = 0;
3229 int err;
3230 int passive_state;
3231 struct iw_cm_id *cm_id = cm_node->cm_id;
3232 struct i40iw_cm_node *loopback = cm_node->loopbackpartner;
3233
3234 if (cm_node->tcp_cntxt.client)
3235 return ret;
3236 i40iw_cleanup_retrans_entry(cm_node);
3237
3238 if (!loopback) {
3239 passive_state = atomic_add_return(1, &cm_node->passive_state);
3240 if (passive_state == I40IW_SEND_RESET_EVENT) {
3241 cm_node->state = I40IW_CM_STATE_CLOSED;
3242 i40iw_rem_ref_cm_node(cm_node);
3243 } else {
3244 if (cm_node->state == I40IW_CM_STATE_LISTENER_DESTROYED) {
3245 i40iw_rem_ref_cm_node(cm_node);
3246 } else {
3247 ret = i40iw_send_mpa_reject(cm_node, pdata, plen);
3248 if (ret) {
3249 cm_node->state = I40IW_CM_STATE_CLOSED;
3250 err = i40iw_send_reset(cm_node);
3251 if (err)
3252 i40iw_pr_err("send reset failed\n");
3253 } else {
3254 cm_id->add_ref(cm_id);
3255 }
3256 }
3257 }
3258 } else {
3259 cm_node->cm_id = NULL;
3260 if (cm_node->state == I40IW_CM_STATE_LISTENER_DESTROYED) {
3261 i40iw_rem_ref_cm_node(cm_node);
3262 i40iw_rem_ref_cm_node(loopback);
3263 } else {
3264 ret = i40iw_send_cm_event(loopback,
3265 loopback->cm_id,
3266 IW_CM_EVENT_CONNECT_REPLY,
3267 -ECONNREFUSED);
3268 i40iw_rem_ref_cm_node(cm_node);
3269 loopback->state = I40IW_CM_STATE_CLOSING;
3270
3271 cm_id = loopback->cm_id;
3272 i40iw_rem_ref_cm_node(loopback);
3273 cm_id->rem_ref(cm_id);
3274 }
3275 }
3276
3277 return ret;
3278}
3279
3280/**
3281 * i40iw_cm_close - close of cm connection
3282 * @cm_node: connection's node
3283 */
3284static int i40iw_cm_close(struct i40iw_cm_node *cm_node)
3285{
3286 int ret = 0;
3287
3288 if (!cm_node)
3289 return -EINVAL;
3290
3291 switch (cm_node->state) {
3292 case I40IW_CM_STATE_SYN_RCVD:
3293 case I40IW_CM_STATE_SYN_SENT:
3294 case I40IW_CM_STATE_ONE_SIDE_ESTABLISHED:
3295 case I40IW_CM_STATE_ESTABLISHED:
3296 case I40IW_CM_STATE_ACCEPTING:
3297 case I40IW_CM_STATE_MPAREQ_SENT:
3298 case I40IW_CM_STATE_MPAREQ_RCVD:
3299 i40iw_cleanup_retrans_entry(cm_node);
3300 i40iw_send_reset(cm_node);
3301 break;
3302 case I40IW_CM_STATE_CLOSE_WAIT:
3303 cm_node->state = I40IW_CM_STATE_LAST_ACK;
3304 i40iw_send_fin(cm_node);
3305 break;
3306 case I40IW_CM_STATE_FIN_WAIT1:
3307 case I40IW_CM_STATE_FIN_WAIT2:
3308 case I40IW_CM_STATE_LAST_ACK:
3309 case I40IW_CM_STATE_TIME_WAIT:
3310 case I40IW_CM_STATE_CLOSING:
3311 ret = -1;
3312 break;
3313 case I40IW_CM_STATE_LISTENING:
3314 i40iw_cleanup_retrans_entry(cm_node);
3315 i40iw_send_reset(cm_node);
3316 break;
3317 case I40IW_CM_STATE_MPAREJ_RCVD:
3318 case I40IW_CM_STATE_UNKNOWN:
3319 case I40IW_CM_STATE_INITED:
3320 case I40IW_CM_STATE_CLOSED:
3321 case I40IW_CM_STATE_LISTENER_DESTROYED:
3322 i40iw_rem_ref_cm_node(cm_node);
3323 break;
3324 case I40IW_CM_STATE_OFFLOADED:
3325 if (cm_node->send_entry)
3326 i40iw_pr_err("send_entry\n");
3327 i40iw_rem_ref_cm_node(cm_node);
3328 break;
3329 }
3330 return ret;
3331}
3332
3333/**
3334 * i40iw_receive_ilq - recv an ETHERNET packet, and process it
3335 * through CM
3336 * @dev: FPK dev struct
3337 * @rbuf: receive buffer
3338 */
3339void i40iw_receive_ilq(struct i40iw_sc_dev *dev, struct i40iw_puda_buf *rbuf)
3340{
3341 struct i40iw_cm_node *cm_node;
3342 struct i40iw_cm_listener *listener;
3343 struct iphdr *iph;
3344 struct ipv6hdr *ip6h;
3345 struct tcphdr *tcph;
3346 struct i40iw_cm_info cm_info;
3347 struct i40iw_device *iwdev = (struct i40iw_device *)dev->back_dev;
3348 struct i40iw_cm_core *cm_core = &iwdev->cm_core;
3349 struct vlan_ethhdr *ethh;
3350
3351 /* if vlan, then maclen = 18 else 14 */
3352 iph = (struct iphdr *)rbuf->iph;
3353 memset(&cm_info, 0, sizeof(cm_info));
3354
3355 i40iw_debug_buf(dev,
3356 I40IW_DEBUG_ILQ,
3357 "RECEIVE ILQ BUFFER",
3358 rbuf->mem.va,
3359 rbuf->totallen);
3360 ethh = (struct vlan_ethhdr *)rbuf->mem.va;
3361
3362 if (ethh->h_vlan_proto == htons(ETH_P_8021Q)) {
3363 cm_info.vlan_id = ntohs(ethh->h_vlan_TCI) & VLAN_VID_MASK;
3364 i40iw_debug(cm_core->dev,
3365 I40IW_DEBUG_CM,
3366 "%s vlan_id=%d\n",
3367 __func__,
3368 cm_info.vlan_id);
3369 } else {
3370 cm_info.vlan_id = I40IW_NO_VLAN;
3371 }
3372 tcph = (struct tcphdr *)rbuf->tcph;
3373
3374 if (rbuf->ipv4) {
3375 cm_info.loc_addr[0] = ntohl(iph->daddr);
3376 cm_info.rem_addr[0] = ntohl(iph->saddr);
3377 cm_info.ipv4 = true;
3378 } else {
3379 ip6h = (struct ipv6hdr *)rbuf->iph;
3380 i40iw_copy_ip_ntohl(cm_info.loc_addr,
3381 ip6h->daddr.in6_u.u6_addr32);
3382 i40iw_copy_ip_ntohl(cm_info.rem_addr,
3383 ip6h->saddr.in6_u.u6_addr32);
3384 cm_info.ipv4 = false;
3385 }
3386 cm_info.loc_port = ntohs(tcph->dest);
3387 cm_info.rem_port = ntohs(tcph->source);
3388 i40iw_init_mapinfo(&cm_info);
3389
3390 cm_node = i40iw_find_node(cm_core,
3391 cm_info.map_rem_port,
3392 cm_info.map_rem_addr,
3393 cm_info.map_loc_port,
3394 cm_info.map_loc_addr,
3395 true);
3396
3397 if (!cm_node) {
3398 /* Only type of packet accepted are for */
3399 /* the PASSIVE open (syn only) */
3400 if (!tcph->syn || tcph->ack)
3401 return;
3402 listener =
3403 i40iw_find_listener(cm_core,
3404 cm_info.map_loc_addr,
3405 cm_info.map_loc_port,
3406 cm_info.vlan_id,
3407 I40IW_CM_LISTENER_ACTIVE_STATE,
3408 true);
3409 if (!listener) {
3410 cm_info.cm_id = NULL;
3411 i40iw_debug(cm_core->dev,
3412 I40IW_DEBUG_CM,
3413 "%s no listener found\n",
3414 __func__);
3415 return;
3416 }
3417 cm_info.cm_id = listener->cm_id;
3418 cm_node = i40iw_make_cm_node(cm_core, iwdev, &cm_info, listener);
3419 if (!cm_node) {
3420 i40iw_debug(cm_core->dev,
3421 I40IW_DEBUG_CM,
3422 "%s allocate node failed\n",
3423 __func__);
3424 atomic_dec(&listener->ref_count);
3425 return;
3426 }
3427 if (!tcph->rst && !tcph->fin) {
3428 cm_node->state = I40IW_CM_STATE_LISTENING;
3429 } else {
3430 i40iw_rem_ref_cm_node(cm_node);
3431 return;
3432 }
3433 atomic_inc(&cm_node->ref_count);
3434 } else if (cm_node->state == I40IW_CM_STATE_OFFLOADED) {
3435 i40iw_rem_ref_cm_node(cm_node);
3436 return;
3437 }
3438 i40iw_process_packet(cm_node, rbuf);
3439 i40iw_rem_ref_cm_node(cm_node);
3440}
3441
3442/**
3443 * i40iw_setup_cm_core - allocate a top level instance of a cm
3444 * core
3445 * @iwdev: iwarp device structure
3446 */
3447void i40iw_setup_cm_core(struct i40iw_device *iwdev)
3448{
3449 struct i40iw_cm_core *cm_core = &iwdev->cm_core;
3450
3451 cm_core->iwdev = iwdev;
3452 cm_core->dev = &iwdev->sc_dev;
3453
3454 INIT_LIST_HEAD(&cm_core->connected_nodes);
3455 INIT_LIST_HEAD(&cm_core->listen_nodes);
3456
3457 init_timer(&cm_core->tcp_timer);
3458 cm_core->tcp_timer.function = i40iw_cm_timer_tick;
3459 cm_core->tcp_timer.data = (unsigned long)cm_core;
3460
3461 spin_lock_init(&cm_core->ht_lock);
3462 spin_lock_init(&cm_core->listen_list_lock);
3463
3464 cm_core->event_wq = create_singlethread_workqueue("iwewq");
3465 cm_core->disconn_wq = create_singlethread_workqueue("iwdwq");
3466}
3467
3468/**
3469 * i40iw_cleanup_cm_core - deallocate a top level instance of a
3470 * cm core
3471 * @cm_core: cm's core
3472 */
3473void i40iw_cleanup_cm_core(struct i40iw_cm_core *cm_core)
3474{
3475 unsigned long flags;
3476
3477 if (!cm_core)
3478 return;
3479
3480 spin_lock_irqsave(&cm_core->ht_lock, flags);
3481 if (timer_pending(&cm_core->tcp_timer))
3482 del_timer_sync(&cm_core->tcp_timer);
3483 spin_unlock_irqrestore(&cm_core->ht_lock, flags);
3484
3485 destroy_workqueue(cm_core->event_wq);
3486 destroy_workqueue(cm_core->disconn_wq);
3487}
3488
3489/**
3490 * i40iw_init_tcp_ctx - setup qp context
3491 * @cm_node: connection's node
3492 * @tcp_info: offload info for tcp
3493 * @iwqp: associate qp for the connection
3494 */
3495static void i40iw_init_tcp_ctx(struct i40iw_cm_node *cm_node,
3496 struct i40iw_tcp_offload_info *tcp_info,
3497 struct i40iw_qp *iwqp)
3498{
3499 tcp_info->ipv4 = cm_node->ipv4;
3500 tcp_info->drop_ooo_seg = true;
3501 tcp_info->wscale = true;
3502 tcp_info->ignore_tcp_opt = true;
3503 tcp_info->ignore_tcp_uns_opt = true;
3504 tcp_info->no_nagle = false;
3505
3506 tcp_info->ttl = I40IW_DEFAULT_TTL;
3507 tcp_info->rtt_var = cpu_to_le32(I40IW_DEFAULT_RTT_VAR);
3508 tcp_info->ss_thresh = cpu_to_le32(I40IW_DEFAULT_SS_THRESH);
3509 tcp_info->rexmit_thresh = I40IW_DEFAULT_REXMIT_THRESH;
3510
3511 tcp_info->tcp_state = I40IW_TCP_STATE_ESTABLISHED;
3512 tcp_info->snd_wscale = cm_node->tcp_cntxt.snd_wscale;
3513 tcp_info->rcv_wscale = cm_node->tcp_cntxt.rcv_wscale;
3514
3515 tcp_info->snd_nxt = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3516 tcp_info->snd_wnd = cpu_to_le32(cm_node->tcp_cntxt.snd_wnd);
3517 tcp_info->rcv_nxt = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt);
3518 tcp_info->snd_max = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3519
3520 tcp_info->snd_una = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3521 tcp_info->cwnd = cpu_to_le32(2 * cm_node->tcp_cntxt.mss);
3522 tcp_info->snd_wl1 = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt);
3523 tcp_info->snd_wl2 = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num);
3524 tcp_info->max_snd_window = cpu_to_le32(cm_node->tcp_cntxt.max_snd_wnd);
3525 tcp_info->rcv_wnd = cpu_to_le32(cm_node->tcp_cntxt.rcv_wnd <<
3526 cm_node->tcp_cntxt.rcv_wscale);
3527
3528 tcp_info->flow_label = 0;
3529 tcp_info->snd_mss = cpu_to_le32(((u32)cm_node->tcp_cntxt.mss));
3530 if (cm_node->vlan_id < VLAN_TAG_PRESENT) {
3531 tcp_info->insert_vlan_tag = true;
3532 tcp_info->vlan_tag = cpu_to_le16(cm_node->vlan_id);
3533 }
3534 if (cm_node->ipv4) {
3535 tcp_info->src_port = cpu_to_le16(cm_node->map_loc_port);
3536 tcp_info->dst_port = cpu_to_le16(cm_node->map_rem_port);
3537
3538 tcp_info->dest_ip_addr3 = cpu_to_le32(cm_node->map_rem_addr[0]);
3539 tcp_info->local_ipaddr3 = cpu_to_le32(cm_node->map_loc_addr[0]);
3540 tcp_info->arp_idx = cpu_to_le32(i40iw_arp_table(iwqp->iwdev,
3541 &tcp_info->dest_ip_addr3,
3542 true,
3543 NULL,
3544 I40IW_ARP_RESOLVE));
3545 } else {
3546 tcp_info->src_port = cpu_to_le16(cm_node->map_loc_port);
3547 tcp_info->dst_port = cpu_to_le16(cm_node->map_rem_port);
3548 tcp_info->dest_ip_addr0 = cpu_to_le32(cm_node->map_rem_addr[0]);
3549 tcp_info->dest_ip_addr1 = cpu_to_le32(cm_node->map_rem_addr[1]);
3550 tcp_info->dest_ip_addr2 = cpu_to_le32(cm_node->map_rem_addr[2]);
3551 tcp_info->dest_ip_addr3 = cpu_to_le32(cm_node->map_rem_addr[3]);
3552 tcp_info->local_ipaddr0 = cpu_to_le32(cm_node->map_loc_addr[0]);
3553 tcp_info->local_ipaddr1 = cpu_to_le32(cm_node->map_loc_addr[1]);
3554 tcp_info->local_ipaddr2 = cpu_to_le32(cm_node->map_loc_addr[2]);
3555 tcp_info->local_ipaddr3 = cpu_to_le32(cm_node->map_loc_addr[3]);
3556 tcp_info->arp_idx = cpu_to_le32(i40iw_arp_table(
3557 iwqp->iwdev,
3558 &tcp_info->dest_ip_addr0,
3559 false,
3560 NULL,
3561 I40IW_ARP_RESOLVE));
3562 }
3563}
3564
3565/**
3566 * i40iw_cm_init_tsa_conn - setup qp for RTS
3567 * @iwqp: associate qp for the connection
3568 * @cm_node: connection's node
3569 */
3570static void i40iw_cm_init_tsa_conn(struct i40iw_qp *iwqp,
3571 struct i40iw_cm_node *cm_node)
3572{
3573 struct i40iw_tcp_offload_info tcp_info;
3574 struct i40iwarp_offload_info *iwarp_info;
3575 struct i40iw_qp_host_ctx_info *ctx_info;
3576 struct i40iw_device *iwdev = iwqp->iwdev;
3577 struct i40iw_sc_dev *dev = &iwqp->iwdev->sc_dev;
3578
3579 memset(&tcp_info, 0x00, sizeof(struct i40iw_tcp_offload_info));
3580 iwarp_info = &iwqp->iwarp_info;
3581 ctx_info = &iwqp->ctx_info;
3582
3583 ctx_info->tcp_info = &tcp_info;
3584 ctx_info->send_cq_num = iwqp->iwscq->sc_cq.cq_uk.cq_id;
3585 ctx_info->rcv_cq_num = iwqp->iwrcq->sc_cq.cq_uk.cq_id;
3586
3587 iwarp_info->ord_size = cm_node->ord_size;
3588 iwarp_info->ird_size = i40iw_derive_hw_ird_setting(cm_node->ird_size);
3589
3590 if (iwarp_info->ord_size == 1)
3591 iwarp_info->ord_size = 2;
3592
3593 iwarp_info->rd_enable = true;
3594 iwarp_info->rdmap_ver = 1;
3595 iwarp_info->ddp_ver = 1;
3596
3597 iwarp_info->pd_id = iwqp->iwpd->sc_pd.pd_id;
3598
3599 ctx_info->tcp_info_valid = true;
3600 ctx_info->iwarp_info_valid = true;
3601
3602 i40iw_init_tcp_ctx(cm_node, &tcp_info, iwqp);
3603 if (cm_node->snd_mark_en) {
3604 iwarp_info->snd_mark_en = true;
3605 iwarp_info->snd_mark_offset = (tcp_info.snd_nxt &
3606 SNDMARKER_SEQNMASK) + cm_node->lsmm_size;
3607 }
3608
3609 cm_node->state = I40IW_CM_STATE_OFFLOADED;
3610 tcp_info.tcp_state = I40IW_TCP_STATE_ESTABLISHED;
3611 tcp_info.src_mac_addr_idx = iwdev->mac_ip_table_idx;
3612
3613 dev->iw_priv_qp_ops->qp_setctx(&iwqp->sc_qp, (u64 *)(iwqp->host_ctx.va), ctx_info);
3614
3615 /* once tcp_info is set, no need to do it again */
3616 ctx_info->tcp_info_valid = false;
3617 ctx_info->iwarp_info_valid = false;
3618}
3619
3620/**
3621 * i40iw_cm_disconn - when a connection is being closed
3622 * @iwqp: associate qp for the connection
3623 */
3624int i40iw_cm_disconn(struct i40iw_qp *iwqp)
3625{
3626 struct disconn_work *work;
3627 struct i40iw_device *iwdev = iwqp->iwdev;
3628 struct i40iw_cm_core *cm_core = &iwdev->cm_core;
3629
3630 work = kzalloc(sizeof(*work), GFP_ATOMIC);
3631 if (!work)
3632 return -ENOMEM; /* Timer will clean up */
3633
3634 i40iw_add_ref(&iwqp->ibqp);
3635 work->iwqp = iwqp;
3636 INIT_WORK(&work->work, i40iw_disconnect_worker);
3637 queue_work(cm_core->disconn_wq, &work->work);
3638 return 0;
3639}
3640
3641/**
3642 * i40iw_loopback_nop - Send a nop
3643 * @qp: associated hw qp
3644 */
3645static void i40iw_loopback_nop(struct i40iw_sc_qp *qp)
3646{
3647 u64 *wqe;
3648 u64 header;
3649
3650 wqe = qp->qp_uk.sq_base->elem;
3651 set_64bit_val(wqe, 0, 0);
3652 set_64bit_val(wqe, 8, 0);
3653 set_64bit_val(wqe, 16, 0);
3654
3655 header = LS_64(I40IWQP_OP_NOP, I40IWQPSQ_OPCODE) |
3656 LS_64(0, I40IWQPSQ_SIGCOMPL) |
3657 LS_64(qp->qp_uk.swqe_polarity, I40IWQPSQ_VALID);
3658 set_64bit_val(wqe, 24, header);
3659}
3660
3661/**
3662 * i40iw_qp_disconnect - free qp and close cm
3663 * @iwqp: associate qp for the connection
3664 */
3665static void i40iw_qp_disconnect(struct i40iw_qp *iwqp)
3666{
3667 struct i40iw_device *iwdev;
3668 struct i40iw_ib_device *iwibdev;
3669
3670 iwdev = to_iwdev(iwqp->ibqp.device);
3671 if (!iwdev) {
3672 i40iw_pr_err("iwdev == NULL\n");
3673 return;
3674 }
3675
3676 iwibdev = iwdev->iwibdev;
3677
3678 if (iwqp->active_conn) {
3679 /* indicate this connection is NOT active */
3680 iwqp->active_conn = 0;
3681 } else {
3682 /* Need to free the Last Streaming Mode Message */
3683 if (iwqp->ietf_mem.va) {
3684 if (iwqp->lsmm_mr)
3685 iwibdev->ibdev.dereg_mr(iwqp->lsmm_mr);
3686 i40iw_free_dma_mem(iwdev->sc_dev.hw, &iwqp->ietf_mem);
3687 }
3688 }
3689
3690 /* close the CM node down if it is still active */
3691 if (iwqp->cm_node) {
3692 i40iw_debug(&iwdev->sc_dev, I40IW_DEBUG_CM, "%s Call close API\n", __func__);
3693 i40iw_cm_close(iwqp->cm_node);
3694 }
3695}
3696
3697/**
3698 * i40iw_cm_disconn_true - called by worker thread to disconnect qp
3699 * @iwqp: associate qp for the connection
3700 */
3701static void i40iw_cm_disconn_true(struct i40iw_qp *iwqp)
3702{
3703 struct iw_cm_id *cm_id;
3704 struct i40iw_device *iwdev;
3705 struct i40iw_sc_qp *qp = &iwqp->sc_qp;
3706 u16 last_ae;
3707 u8 original_hw_tcp_state;
3708 u8 original_ibqp_state;
3709 int disconn_status = 0;
3710 int issue_disconn = 0;
3711 int issue_close = 0;
3712 int issue_flush = 0;
3713 struct ib_event ibevent;
3714 unsigned long flags;
3715 int ret;
3716
3717 if (!iwqp) {
3718 i40iw_pr_err("iwqp == NULL\n");
3719 return;
3720 }
3721
3722 spin_lock_irqsave(&iwqp->lock, flags);
3723 cm_id = iwqp->cm_id;
3724 /* make sure we havent already closed this connection */
3725 if (!cm_id) {
3726 spin_unlock_irqrestore(&iwqp->lock, flags);
3727 return;
3728 }
3729
3730 iwdev = to_iwdev(iwqp->ibqp.device);
3731
3732 original_hw_tcp_state = iwqp->hw_tcp_state;
3733 original_ibqp_state = iwqp->ibqp_state;
3734 last_ae = iwqp->last_aeq;
3735
3736 if (qp->term_flags) {
3737 issue_disconn = 1;
3738 issue_close = 1;
3739 iwqp->cm_id = NULL;
3740 /*When term timer expires after cm_timer, don't want
3741 *terminate-handler to issue cm_disconn which can re-free
3742 *a QP even after its refcnt=0.
3743 */
3744 del_timer(&iwqp->terminate_timer);
3745 if (!iwqp->flush_issued) {
3746 iwqp->flush_issued = 1;
3747 issue_flush = 1;
3748 }
3749 } else if ((original_hw_tcp_state == I40IW_TCP_STATE_CLOSE_WAIT) ||
3750 ((original_ibqp_state == IB_QPS_RTS) &&
3751 (last_ae == I40IW_AE_LLP_CONNECTION_RESET))) {
3752 issue_disconn = 1;
3753 if (last_ae == I40IW_AE_LLP_CONNECTION_RESET)
3754 disconn_status = -ECONNRESET;
3755 }
3756
3757 if (((original_hw_tcp_state == I40IW_TCP_STATE_CLOSED) ||
3758 (original_hw_tcp_state == I40IW_TCP_STATE_TIME_WAIT) ||
3759 (last_ae == I40IW_AE_RDMAP_ROE_BAD_LLP_CLOSE) ||
3760 (last_ae == I40IW_AE_LLP_CONNECTION_RESET))) {
3761 issue_close = 1;
3762 iwqp->cm_id = NULL;
3763 if (!iwqp->flush_issued) {
3764 iwqp->flush_issued = 1;
3765 issue_flush = 1;
3766 }
3767 }
3768
3769 spin_unlock_irqrestore(&iwqp->lock, flags);
3770 if (issue_flush && !iwqp->destroyed) {
3771 /* Flush the queues */
3772 i40iw_flush_wqes(iwdev, iwqp);
3773
3774 if (qp->term_flags) {
3775 ibevent.device = iwqp->ibqp.device;
3776 ibevent.event = (qp->eventtype == TERM_EVENT_QP_FATAL) ?
3777 IB_EVENT_QP_FATAL : IB_EVENT_QP_ACCESS_ERR;
3778 ibevent.element.qp = &iwqp->ibqp;
3779 iwqp->ibqp.event_handler(&ibevent, iwqp->ibqp.qp_context);
3780 }
3781 }
3782
3783 if (cm_id && cm_id->event_handler) {
3784 if (issue_disconn) {
3785 ret = i40iw_send_cm_event(NULL,
3786 cm_id,
3787 IW_CM_EVENT_DISCONNECT,
3788 disconn_status);
3789
3790 if (ret)
3791 i40iw_debug(&iwdev->sc_dev,
3792 I40IW_DEBUG_CM,
3793 "disconnect event failed %s: - cm_id = %p\n",
3794 __func__, cm_id);
3795 }
3796 if (issue_close) {
3797 i40iw_qp_disconnect(iwqp);
3798 cm_id->provider_data = iwqp;
3799 ret = i40iw_send_cm_event(NULL, cm_id, IW_CM_EVENT_CLOSE, 0);
3800 if (ret)
3801 i40iw_debug(&iwdev->sc_dev,
3802 I40IW_DEBUG_CM,
3803 "close event failed %s: - cm_id = %p\n",
3804 __func__, cm_id);
3805 cm_id->rem_ref(cm_id);
3806 }
3807 }
3808}
3809
3810/**
3811 * i40iw_disconnect_worker - worker for connection close
3812 * @work: points or disconn structure
3813 */
3814static void i40iw_disconnect_worker(struct work_struct *work)
3815{
3816 struct disconn_work *dwork = container_of(work, struct disconn_work, work);
3817 struct i40iw_qp *iwqp = dwork->iwqp;
3818
3819 kfree(dwork);
3820 i40iw_cm_disconn_true(iwqp);
3821 i40iw_rem_ref(&iwqp->ibqp);
3822}
3823
3824/**
3825 * i40iw_accept - registered call for connection to be accepted
3826 * @cm_id: cm information for passive connection
3827 * @conn_param: accpet parameters
3828 */
3829int i40iw_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
3830{
3831 struct ib_qp *ibqp;
3832 struct i40iw_qp *iwqp;
3833 struct i40iw_device *iwdev;
3834 struct i40iw_sc_dev *dev;
3835 struct i40iw_cm_node *cm_node;
3836 struct ib_qp_attr attr;
3837 int passive_state;
3838 struct i40iw_ib_device *iwibdev;
3839 struct ib_mr *ibmr;
3840 struct i40iw_pd *iwpd;
3841 u16 buf_len = 0;
3842 struct i40iw_kmem_info accept;
3843 enum i40iw_status_code status;
3844 u64 tagged_offset;
3845
3846 memset(&attr, 0, sizeof(attr));
3847 ibqp = i40iw_get_qp(cm_id->device, conn_param->qpn);
3848 if (!ibqp)
3849 return -EINVAL;
3850
3851 iwqp = to_iwqp(ibqp);
3852 iwdev = iwqp->iwdev;
3853 dev = &iwdev->sc_dev;
3854 cm_node = (struct i40iw_cm_node *)cm_id->provider_data;
3855
3856 if (((struct sockaddr_in *)&cm_id->local_addr)->sin_family == AF_INET) {
3857 cm_node->ipv4 = true;
3858 cm_node->vlan_id = i40iw_get_vlan_ipv4(cm_node->loc_addr);
3859 } else {
3860 cm_node->ipv4 = false;
3861 i40iw_netdev_vlan_ipv6(cm_node->loc_addr, &cm_node->vlan_id, NULL);
3862 }
3863 i40iw_debug(cm_node->dev,
3864 I40IW_DEBUG_CM,
3865 "Accept vlan_id=%d\n",
3866 cm_node->vlan_id);
3867 if (cm_node->state == I40IW_CM_STATE_LISTENER_DESTROYED) {
3868 if (cm_node->loopbackpartner)
3869 i40iw_rem_ref_cm_node(cm_node->loopbackpartner);
3870 i40iw_rem_ref_cm_node(cm_node);
3871 return -EINVAL;
3872 }
3873
3874 passive_state = atomic_add_return(1, &cm_node->passive_state);
3875 if (passive_state == I40IW_SEND_RESET_EVENT) {
3876 i40iw_rem_ref_cm_node(cm_node);
3877 return -ECONNRESET;
3878 }
3879
3880 cm_node->cm_core->stats_accepts++;
3881 iwqp->cm_node = (void *)cm_node;
3882 cm_node->iwqp = iwqp;
3883
3884 buf_len = conn_param->private_data_len + I40IW_MAX_IETF_SIZE + MPA_ZERO_PAD_LEN;
3885
3886 status = i40iw_allocate_dma_mem(dev->hw, &iwqp->ietf_mem, buf_len, 1);
3887
3888 if (status)
3889 return -ENOMEM;
3890 cm_node->pdata.size = conn_param->private_data_len;
3891 accept.addr = iwqp->ietf_mem.va;
3892 accept.size = i40iw_cm_build_mpa_frame(cm_node, &accept, MPA_KEY_REPLY);
3893 memcpy(accept.addr + accept.size, conn_param->private_data,
3894 conn_param->private_data_len);
3895
3896 /* setup our first outgoing iWarp send WQE (the IETF frame response) */
3897 if ((cm_node->ipv4 &&
3898 !i40iw_ipv4_is_loopback(cm_node->loc_addr[0], cm_node->rem_addr[0])) ||
3899 (!cm_node->ipv4 &&
3900 !i40iw_ipv6_is_loopback(cm_node->loc_addr, cm_node->rem_addr))) {
3901 iwibdev = iwdev->iwibdev;
3902 iwpd = iwqp->iwpd;
3903 tagged_offset = (uintptr_t)iwqp->ietf_mem.va;
3904 ibmr = i40iw_reg_phys_mr(&iwpd->ibpd,
3905 iwqp->ietf_mem.pa,
3906 buf_len,
3907 IB_ACCESS_LOCAL_WRITE,
3908 &tagged_offset);
3909 if (IS_ERR(ibmr)) {
3910 i40iw_free_dma_mem(dev->hw, &iwqp->ietf_mem);
3911 return -ENOMEM;
3912 }
3913
3914 ibmr->pd = &iwpd->ibpd;
3915 ibmr->device = iwpd->ibpd.device;
3916 iwqp->lsmm_mr = ibmr;
3917 if (iwqp->page)
3918 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page);
3919 if (is_remote_ne020_or_chelsio(cm_node))
3920 dev->iw_priv_qp_ops->qp_send_lsmm(
3921 &iwqp->sc_qp,
3922 iwqp->ietf_mem.va,
3923 (accept.size + conn_param->private_data_len),
3924 ibmr->lkey);
3925 else
3926 dev->iw_priv_qp_ops->qp_send_lsmm(
3927 &iwqp->sc_qp,
3928 iwqp->ietf_mem.va,
3929 (accept.size + conn_param->private_data_len + MPA_ZERO_PAD_LEN),
3930 ibmr->lkey);
3931
3932 } else {
3933 if (iwqp->page)
3934 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page);
3935 i40iw_loopback_nop(&iwqp->sc_qp);
3936 }
3937
3938 if (iwqp->page)
3939 kunmap(iwqp->page);
3940
3941 iwqp->cm_id = cm_id;
3942 cm_node->cm_id = cm_id;
3943
3944 cm_id->provider_data = (void *)iwqp;
3945 iwqp->active_conn = 0;
3946
3947 cm_node->lsmm_size = accept.size + conn_param->private_data_len;
3948 i40iw_cm_init_tsa_conn(iwqp, cm_node);
3949 cm_id->add_ref(cm_id);
3950 i40iw_add_ref(&iwqp->ibqp);
3951
3952 i40iw_send_cm_event(cm_node, cm_id, IW_CM_EVENT_ESTABLISHED, 0);
3953
3954 attr.qp_state = IB_QPS_RTS;
3955 cm_node->qhash_set = false;
3956 i40iw_modify_qp(&iwqp->ibqp, &attr, IB_QP_STATE, NULL);
3957 if (cm_node->loopbackpartner) {
3958 cm_node->loopbackpartner->pdata.size = conn_param->private_data_len;
3959
3960 /* copy entire MPA frame to our cm_node's frame */
3961 memcpy(cm_node->loopbackpartner->pdata_buf,
3962 conn_param->private_data,
3963 conn_param->private_data_len);
3964 i40iw_create_event(cm_node->loopbackpartner, I40IW_CM_EVENT_CONNECTED);
3965 }
3966
3967 cm_node->accelerated = 1;
3968 if (cm_node->accept_pend) {
3969 if (!cm_node->listener)
3970 i40iw_pr_err("cm_node->listener NULL for passive node\n");
3971 atomic_dec(&cm_node->listener->pend_accepts_cnt);
3972 cm_node->accept_pend = 0;
3973 }
3974 return 0;
3975}
3976
3977/**
3978 * i40iw_reject - registered call for connection to be rejected
3979 * @cm_id: cm information for passive connection
3980 * @pdata: private data to be sent
3981 * @pdata_len: private data length
3982 */
3983int i40iw_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len)
3984{
3985 struct i40iw_device *iwdev;
3986 struct i40iw_cm_node *cm_node;
3987 struct i40iw_cm_node *loopback;
3988
3989 cm_node = (struct i40iw_cm_node *)cm_id->provider_data;
3990 loopback = cm_node->loopbackpartner;
3991 cm_node->cm_id = cm_id;
3992 cm_node->pdata.size = pdata_len;
3993
3994 iwdev = to_iwdev(cm_id->device);
3995 if (!iwdev)
3996 return -EINVAL;
3997 cm_node->cm_core->stats_rejects++;
3998
3999 if (pdata_len + sizeof(struct ietf_mpa_v2) > MAX_CM_BUFFER)
4000 return -EINVAL;
4001
4002 if (loopback) {
4003 memcpy(&loopback->pdata_buf, pdata, pdata_len);
4004 loopback->pdata.size = pdata_len;
4005 }
4006
4007 return i40iw_cm_reject(cm_node, pdata, pdata_len);
4008}
4009
4010/**
4011 * i40iw_connect - registered call for connection to be established
4012 * @cm_id: cm information for passive connection
4013 * @conn_param: Information about the connection
4014 */
4015int i40iw_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param)
4016{
4017 struct ib_qp *ibqp;
4018 struct i40iw_qp *iwqp;
4019 struct i40iw_device *iwdev;
4020 struct i40iw_cm_node *cm_node;
4021 struct i40iw_cm_info cm_info;
4022 struct sockaddr_in *laddr;
4023 struct sockaddr_in *raddr;
4024 struct sockaddr_in6 *laddr6;
4025 struct sockaddr_in6 *raddr6;
4026 struct iwpm_dev_data pm_reg_msg;
4027 struct iwpm_sa_data pm_msg;
4028 int apbvt_set = 0;
4029 enum i40iw_status_code status;
4030 int iwpm_err;
4031
4032 ibqp = i40iw_get_qp(cm_id->device, conn_param->qpn);
4033 if (!ibqp)
4034 return -EINVAL;
4035 iwqp = to_iwqp(ibqp);
4036 if (!iwqp)
4037 return -EINVAL;
4038 iwdev = to_iwdev(iwqp->ibqp.device);
4039 if (!iwdev)
4040 return -EINVAL;
4041
4042 laddr = (struct sockaddr_in *)&cm_id->local_addr;
4043 raddr = (struct sockaddr_in *)&cm_id->remote_addr;
4044 laddr6 = (struct sockaddr_in6 *)&cm_id->local_addr;
4045 raddr6 = (struct sockaddr_in6 *)&cm_id->remote_addr;
4046
4047 if (!(laddr->sin_port) || !(raddr->sin_port))
4048 return -EINVAL;
4049
4050 iwqp->active_conn = 1;
4051 iwqp->cm_id = NULL;
4052 cm_id->provider_data = iwqp;
4053
4054 /* set up the connection params for the node */
4055 if (cm_id->remote_addr.ss_family == AF_INET) {
4056 cm_info.ipv4 = true;
4057 memset(cm_info.loc_addr, 0, sizeof(cm_info.loc_addr));
4058 memset(cm_info.rem_addr, 0, sizeof(cm_info.rem_addr));
4059 cm_info.loc_addr[0] = ntohl(laddr->sin_addr.s_addr);
4060 cm_info.rem_addr[0] = ntohl(raddr->sin_addr.s_addr);
4061 cm_info.loc_port = ntohs(laddr->sin_port);
4062 cm_info.rem_port = ntohs(raddr->sin_port);
4063 cm_info.vlan_id = i40iw_get_vlan_ipv4(cm_info.loc_addr);
4064 } else {
4065 cm_info.ipv4 = false;
4066 i40iw_copy_ip_ntohl(cm_info.loc_addr,
4067 laddr6->sin6_addr.in6_u.u6_addr32);
4068 i40iw_copy_ip_ntohl(cm_info.rem_addr,
4069 raddr6->sin6_addr.in6_u.u6_addr32);
4070 cm_info.loc_port = ntohs(laddr6->sin6_port);
4071 cm_info.rem_port = ntohs(raddr6->sin6_port);
4072 i40iw_netdev_vlan_ipv6(cm_info.loc_addr, &cm_info.vlan_id, NULL);
4073 }
4074 i40iw_init_mapinfo(&cm_info);
4075 cm_info.cm_id = cm_id;
4076
4077 i40iw_form_reg_msg(iwdev, &pm_reg_msg);
4078 iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_I40IW);
4079 if (iwpm_err)
4080 i40iw_pr_err("PM register fail err = %d\n",
4081 iwpm_err);
4082
4083 if (iwpm_valid_pid() && !iwpm_err) {
4084 i40iw_form_pm_msg(&cm_info, &pm_msg);
4085 iwpm_err = iwpm_add_and_query_mapping(&pm_msg, RDMA_NL_I40IW);
4086 if (iwpm_err)
4087 i40iw_pr_err("PM query fail err = %d\n",
4088 iwpm_err);
4089 else
4090 i40iw_record_pm_msg(&cm_info, &pm_msg, true);
4091 }
4092
4093 if (i40iw_create_mapinfo(&cm_info)) {
4094 i40iw_pr_err("Fail to create mapinfo\n");
4095 return -ENOMEM;
4096 }
4097
4098 if ((cm_info.ipv4 && (laddr->sin_addr.s_addr != raddr->sin_addr.s_addr)) ||
4099 (!cm_info.ipv4 && memcmp(laddr6->sin6_addr.in6_u.u6_addr32,
4100 raddr6->sin6_addr.in6_u.u6_addr32,
4101 sizeof(laddr6->sin6_addr.in6_u.u6_addr32)))) {
4102 status = i40iw_manage_qhash(iwdev,
4103 &cm_info,
4104 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
4105 I40IW_QHASH_MANAGE_TYPE_ADD,
4106 NULL,
4107 true);
4108 if (status) {
4109 i40iw_remove_mapinfo(&cm_info);
4110 return -EINVAL;
4111 }
4112 }
4113 status = i40iw_manage_apbvt(iwdev, cm_info.map_loc_port, I40IW_MANAGE_APBVT_ADD);
4114 if (status) {
4115 i40iw_remove_mapinfo(&cm_info);
4116 i40iw_manage_qhash(iwdev,
4117 &cm_info,
4118 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
4119 I40IW_QHASH_MANAGE_TYPE_DELETE,
4120 NULL,
4121 false);
4122 return -EINVAL;
4123 }
4124
4125 apbvt_set = 1;
4126 cm_id->add_ref(cm_id);
4127 cm_node = i40iw_create_cm_node(&iwdev->cm_core, iwdev,
4128 conn_param->private_data_len,
4129 (void *)conn_param->private_data,
4130 &cm_info);
4131 if (!cm_node) {
4132 i40iw_manage_qhash(iwdev,
4133 &cm_info,
4134 I40IW_QHASH_TYPE_TCP_ESTABLISHED,
4135 I40IW_QHASH_MANAGE_TYPE_DELETE,
4136 NULL,
4137 false);
4138
4139 if (apbvt_set && !i40iw_listen_port_in_use(&iwdev->cm_core,
4140 cm_info.map_loc_port))
4141 i40iw_manage_apbvt(iwdev,
4142 cm_info.map_loc_port,
4143 I40IW_MANAGE_APBVT_DEL);
4144
4145 i40iw_remove_mapinfo(&cm_info);
4146 cm_id->rem_ref(cm_id);
4147 iwdev->cm_core.stats_connect_errs++;
4148 return -ENOMEM;
4149 }
4150
4151 i40iw_record_ird_ord(cm_node, (u16)conn_param->ird, (u16)conn_param->ord);
4152 if (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO &&
4153 !cm_node->ord_size)
4154 cm_node->ord_size = 1;
4155
4156 cm_node->apbvt_set = apbvt_set;
4157 cm_node->qhash_set = true;
4158 iwqp->cm_node = cm_node;
4159 cm_node->iwqp = iwqp;
4160 iwqp->cm_id = cm_id;
4161 i40iw_add_ref(&iwqp->ibqp);
4162 return 0;
4163}
4164
4165/**
4166 * i40iw_create_listen - registered call creating listener
4167 * @cm_id: cm information for passive connection
4168 * @backlog: to max accept pending count
4169 */
4170int i40iw_create_listen(struct iw_cm_id *cm_id, int backlog)
4171{
4172 struct i40iw_device *iwdev;
4173 struct i40iw_cm_listener *cm_listen_node;
4174 struct i40iw_cm_info cm_info;
4175 enum i40iw_status_code ret;
4176 struct sockaddr_in *laddr;
4177 struct sockaddr_in6 *laddr6;
4178 bool wildcard = false;
4179
4180 iwdev = to_iwdev(cm_id->device);
4181 if (!iwdev)
4182 return -EINVAL;
4183
4184 laddr = (struct sockaddr_in *)&cm_id->local_addr;
4185 laddr6 = (struct sockaddr_in6 *)&cm_id->local_addr;
4186 memset(&cm_info, 0, sizeof(cm_info));
4187 if (laddr->sin_family == AF_INET) {
4188 cm_info.ipv4 = true;
4189 cm_info.loc_addr[0] = ntohl(laddr->sin_addr.s_addr);
4190 cm_info.loc_port = ntohs(laddr->sin_port);
4191
4192 if (laddr->sin_addr.s_addr != INADDR_ANY)
4193 cm_info.vlan_id = i40iw_get_vlan_ipv4(cm_info.loc_addr);
4194 else
4195 wildcard = true;
4196
4197 } else {
4198 cm_info.ipv4 = false;
4199 i40iw_copy_ip_ntohl(cm_info.loc_addr,
4200 laddr6->sin6_addr.in6_u.u6_addr32);
4201 cm_info.loc_port = ntohs(laddr6->sin6_port);
4202 if (ipv6_addr_type(&laddr6->sin6_addr) != IPV6_ADDR_ANY)
4203 i40iw_netdev_vlan_ipv6(cm_info.loc_addr,
4204 &cm_info.vlan_id,
4205 NULL);
4206 else
4207 wildcard = true;
4208 }
4209 i40iw_init_mapinfo(&cm_info);
4210 cm_info.backlog = backlog;
4211 cm_info.cm_id = cm_id;
4212
4213 cm_listen_node = i40iw_make_listen_node(&iwdev->cm_core, iwdev, &cm_info);
4214 if (!cm_listen_node) {
4215 i40iw_pr_err("cm_listen_node == NULL\n");
4216 return -ENOMEM;
4217 }
4218
4219 cm_id->provider_data = cm_listen_node;
4220
4221 if (!cm_listen_node->reused_node) {
4222 if (i40iw_create_mapinfo(&cm_info))
4223 goto error;
4224 if (wildcard) {
4225 if (cm_info.ipv4)
4226 ret = i40iw_add_mqh_4(iwdev,
4227 &cm_info,
4228 cm_listen_node);
4229 else
4230 ret = i40iw_add_mqh_6(iwdev,
4231 &cm_info,
4232 cm_listen_node);
4233 if (ret)
4234 goto error;
4235
4236 ret = i40iw_manage_apbvt(iwdev,
4237 cm_info.map_loc_port,
4238 I40IW_MANAGE_APBVT_ADD);
4239
4240 if (ret)
4241 goto error;
4242 } else {
4243 ret = i40iw_manage_qhash(iwdev,
4244 &cm_info,
4245 I40IW_QHASH_TYPE_TCP_SYN,
4246 I40IW_QHASH_MANAGE_TYPE_ADD,
4247 NULL,
4248 true);
4249 if (ret)
4250 goto error;
4251 cm_listen_node->qhash_set = true;
4252 ret = i40iw_manage_apbvt(iwdev,
4253 cm_info.map_loc_port,
4254 I40IW_MANAGE_APBVT_ADD);
4255 if (ret)
4256 goto error;
4257 }
4258 }
4259 cm_id->add_ref(cm_id);
4260 cm_listen_node->cm_core->stats_listen_created++;
4261 return 0;
4262 error:
4263 i40iw_cm_del_listen(&iwdev->cm_core, (void *)cm_listen_node, false);
4264 return -EINVAL;
4265}
4266
4267/**
4268 * i40iw_destroy_listen - registered call to destroy listener
4269 * @cm_id: cm information for passive connection
4270 */
4271int i40iw_destroy_listen(struct iw_cm_id *cm_id)
4272{
4273 struct i40iw_device *iwdev;
4274
4275 iwdev = to_iwdev(cm_id->device);
4276 if (cm_id->provider_data)
4277 i40iw_cm_del_listen(&iwdev->cm_core, cm_id->provider_data, true);
4278 else
4279 i40iw_pr_err("cm_id->provider_data was NULL\n");
4280
4281 cm_id->rem_ref(cm_id);
4282
4283 return 0;
4284}
4285
4286/**
4287 * i40iw_cm_event_connected - handle connected active node
4288 * @event: the info for cm_node of connection
4289 */
4290static void i40iw_cm_event_connected(struct i40iw_cm_event *event)
4291{
4292 struct i40iw_qp *iwqp;
4293 struct i40iw_device *iwdev;
4294 struct i40iw_cm_node *cm_node;
4295 struct i40iw_sc_dev *dev;
4296 struct ib_qp_attr attr;
4297 struct iw_cm_id *cm_id;
4298 int status;
4299 bool read0;
4300
4301 cm_node = event->cm_node;
4302 cm_id = cm_node->cm_id;
4303 iwqp = (struct i40iw_qp *)cm_id->provider_data;
4304 iwdev = to_iwdev(iwqp->ibqp.device);
4305 dev = &iwdev->sc_dev;
4306
4307 if (iwqp->destroyed) {
4308 status = -ETIMEDOUT;
4309 goto error;
4310 }
4311 i40iw_cm_init_tsa_conn(iwqp, cm_node);
4312 read0 = (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO);
4313 if (iwqp->page)
4314 iwqp->sc_qp.qp_uk.sq_base = kmap(iwqp->page);
4315 dev->iw_priv_qp_ops->qp_send_rtt(&iwqp->sc_qp, read0);
4316 if (iwqp->page)
4317 kunmap(iwqp->page);
4318 status = i40iw_send_cm_event(cm_node, cm_id, IW_CM_EVENT_CONNECT_REPLY, 0);
4319 if (status)
4320 i40iw_pr_err("send cm event\n");
4321
4322 memset(&attr, 0, sizeof(attr));
4323 attr.qp_state = IB_QPS_RTS;
4324 cm_node->qhash_set = false;
4325 i40iw_modify_qp(&iwqp->ibqp, &attr, IB_QP_STATE, NULL);
4326
4327 cm_node->accelerated = 1;
4328 if (cm_node->accept_pend) {
4329 if (!cm_node->listener)
4330 i40iw_pr_err("listener is null for passive node\n");
4331 atomic_dec(&cm_node->listener->pend_accepts_cnt);
4332 cm_node->accept_pend = 0;
4333 }
4334 return;
4335
4336error:
4337 iwqp->cm_id = NULL;
4338 cm_id->provider_data = NULL;
4339 i40iw_send_cm_event(event->cm_node,
4340 cm_id,
4341 IW_CM_EVENT_CONNECT_REPLY,
4342 status);
4343 cm_id->rem_ref(cm_id);
4344 i40iw_rem_ref_cm_node(event->cm_node);
4345}
4346
4347/**
4348 * i40iw_cm_event_reset - handle reset
4349 * @event: the info for cm_node of connection
4350 */
4351static void i40iw_cm_event_reset(struct i40iw_cm_event *event)
4352{
4353 struct i40iw_cm_node *cm_node = event->cm_node;
4354 struct iw_cm_id *cm_id = cm_node->cm_id;
4355 struct i40iw_qp *iwqp;
4356
4357 if (!cm_id)
4358 return;
4359
4360 iwqp = cm_id->provider_data;
4361 if (!iwqp)
4362 return;
4363
4364 i40iw_debug(cm_node->dev,
4365 I40IW_DEBUG_CM,
4366 "reset event %p - cm_id = %p\n",
4367 event->cm_node, cm_id);
4368 iwqp->cm_id = NULL;
4369
4370 i40iw_send_cm_event(cm_node, cm_node->cm_id, IW_CM_EVENT_DISCONNECT, -ECONNRESET);
4371 i40iw_send_cm_event(cm_node, cm_node->cm_id, IW_CM_EVENT_CLOSE, 0);
4372}
4373
4374/**
4375 * i40iw_cm_event_handler - worker thread callback to send event to cm upper layer
4376 * @work: pointer of cm event info.
4377 */
4378static void i40iw_cm_event_handler(struct work_struct *work)
4379{
4380 struct i40iw_cm_event *event = container_of(work,
4381 struct i40iw_cm_event,
4382 event_work);
4383 struct i40iw_cm_node *cm_node;
4384
4385 if (!event || !event->cm_node || !event->cm_node->cm_core)
4386 return;
4387
4388 cm_node = event->cm_node;
4389
4390 switch (event->type) {
4391 case I40IW_CM_EVENT_MPA_REQ:
4392 i40iw_send_cm_event(cm_node,
4393 cm_node->cm_id,
4394 IW_CM_EVENT_CONNECT_REQUEST,
4395 0);
4396 break;
4397 case I40IW_CM_EVENT_RESET:
4398 i40iw_cm_event_reset(event);
4399 break;
4400 case I40IW_CM_EVENT_CONNECTED:
4401 if (!event->cm_node->cm_id ||
4402 (event->cm_node->state != I40IW_CM_STATE_OFFLOADED))
4403 break;
4404 i40iw_cm_event_connected(event);
4405 break;
4406 case I40IW_CM_EVENT_MPA_REJECT:
4407 if (!event->cm_node->cm_id ||
4408 (cm_node->state == I40IW_CM_STATE_OFFLOADED))
4409 break;
4410 i40iw_send_cm_event(cm_node,
4411 cm_node->cm_id,
4412 IW_CM_EVENT_CONNECT_REPLY,
4413 -ECONNREFUSED);
4414 break;
4415 case I40IW_CM_EVENT_ABORTED:
4416 if (!event->cm_node->cm_id ||
4417 (event->cm_node->state == I40IW_CM_STATE_OFFLOADED))
4418 break;
4419 i40iw_event_connect_error(event);
4420 break;
4421 default:
4422 i40iw_pr_err("event type = %d\n", event->type);
4423 break;
4424 }
4425
4426 event->cm_info.cm_id->rem_ref(event->cm_info.cm_id);
4427 i40iw_rem_ref_cm_node(event->cm_node);
4428 kfree(event);
4429}
4430
4431/**
4432 * i40iw_cm_post_event - queue event request for worker thread
4433 * @event: cm node's info for up event call
4434 */
4435static void i40iw_cm_post_event(struct i40iw_cm_event *event)
4436{
4437 atomic_inc(&event->cm_node->ref_count);
4438 event->cm_info.cm_id->add_ref(event->cm_info.cm_id);
4439 INIT_WORK(&event->event_work, i40iw_cm_event_handler);
4440
4441 queue_work(event->cm_node->cm_core->event_wq, &event->event_work);
4442}
Ubuntu Artful kernel mirror