1/* 2 * Copyright (c) 2006 - 2014 Intel Corporation. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 * 32 */ 33 34 35#define TCPOPT_TIMESTAMP 8 36 37#include <linux/atomic.h> 38#include <linux/skbuff.h> 39#include <linux/ip.h> 40#include <linux/tcp.h> 41#include <linux/init.h> 42#include <linux/if_arp.h> 43#include <linux/if_vlan.h> 44#include <linux/notifier.h> 45#include <linux/net.h> 46#include <linux/types.h> 47#include <linux/timer.h> 48#include <linux/time.h> 49#include <linux/delay.h> 50#include <linux/etherdevice.h> 51#include <linux/netdevice.h> 52#include <linux/random.h> 53#include <linux/list.h> 54#include <linux/threads.h> 55#include <linux/highmem.h> 56#include <linux/slab.h> 57#include <net/arp.h> 58#include <net/neighbour.h> 59#include <net/route.h> 60#include <net/ip_fib.h> 61#include <net/tcp.h> 62#include <linux/fcntl.h> 63 64#include "nes.h" 65 66u32 cm_packets_sent; 67u32 cm_packets_bounced; 68u32 cm_packets_dropped; 69u32 cm_packets_retrans; 70u32 cm_packets_created; 71u32 cm_packets_received; 72atomic_t cm_listens_created; 73atomic_t cm_listens_destroyed; 74u32 cm_backlog_drops; 75atomic_t cm_loopbacks; 76atomic_t cm_nodes_created; 77atomic_t cm_nodes_destroyed; 78atomic_t cm_accel_dropped_pkts; 79atomic_t cm_resets_recvd; 80 81static inline int mini_cm_accelerated(struct nes_cm_core *, struct nes_cm_node *); 82static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *, struct nes_vnic *, struct nes_cm_info *); 83static int mini_cm_del_listen(struct nes_cm_core *, struct nes_cm_listener *); 84static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *, struct nes_vnic *, u16, void *, struct nes_cm_info *); 85static int mini_cm_close(struct nes_cm_core *, struct nes_cm_node *); 86static int mini_cm_accept(struct nes_cm_core *, struct nes_cm_node *); 87static int mini_cm_reject(struct nes_cm_core *, struct nes_cm_node *); 88static int mini_cm_recv_pkt(struct nes_cm_core *, struct nes_vnic *, struct sk_buff *); 89static int mini_cm_dealloc_core(struct nes_cm_core *); 90static int mini_cm_get(struct nes_cm_core *); 91static int mini_cm_set(struct nes_cm_core *, u32, u32); 92 93static void form_cm_frame(struct sk_buff *, struct nes_cm_node *, void *, u32, void *, u32, u8); 94static int add_ref_cm_node(struct nes_cm_node *); 95static int rem_ref_cm_node(struct nes_cm_core *, struct nes_cm_node *); 96 97static int nes_cm_disconn_true(struct nes_qp *); 98static int nes_cm_post_event(struct nes_cm_event *event); 99static int nes_disconnect(struct nes_qp *nesqp, int abrupt); 100static void nes_disconnect_worker(struct work_struct *work); 101 102static int send_mpa_request(struct nes_cm_node *, struct sk_buff *); 103static int send_mpa_reject(struct nes_cm_node *); 104static int send_syn(struct nes_cm_node *, u32, struct sk_buff *); 105static int send_reset(struct nes_cm_node *, struct sk_buff *); 106static int send_ack(struct nes_cm_node *cm_node, struct sk_buff *skb); 107static int send_fin(struct nes_cm_node *cm_node, struct sk_buff *skb); 108static void process_packet(struct nes_cm_node *, struct sk_buff *, struct nes_cm_core *); 109 110static void active_open_err(struct nes_cm_node *, struct sk_buff *, int); 111static void passive_open_err(struct nes_cm_node *, struct sk_buff *, int); 112static void cleanup_retrans_entry(struct nes_cm_node *); 113static void handle_rcv_mpa(struct nes_cm_node *, struct sk_buff *); 114static void free_retrans_entry(struct nes_cm_node *cm_node); 115static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph, struct sk_buff *skb, int optionsize, int passive); 116 117/* CM event handler functions */ 118static void cm_event_connected(struct nes_cm_event *); 119static void cm_event_connect_error(struct nes_cm_event *); 120static void cm_event_reset(struct nes_cm_event *); 121static void cm_event_mpa_req(struct nes_cm_event *); 122static void cm_event_mpa_reject(struct nes_cm_event *); 123static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node); 124 125/* MPA build functions */ 126static int cm_build_mpa_frame(struct nes_cm_node *, u8 **, u16 *, u8 *, u8); 127static void build_mpa_v2(struct nes_cm_node *, void *, u8); 128static void build_mpa_v1(struct nes_cm_node *, void *, u8); 129static void build_rdma0_msg(struct nes_cm_node *, struct nes_qp **); 130 131static void print_core(struct nes_cm_core *core); 132static void record_ird_ord(struct nes_cm_node *, u16, u16); 133 134/* External CM API Interface */ 135/* instance of function pointers for client API */ 136/* set address of this instance to cm_core->cm_ops at cm_core alloc */ 137static struct nes_cm_ops nes_cm_api = { 138 mini_cm_accelerated, 139 mini_cm_listen, 140 mini_cm_del_listen, 141 mini_cm_connect, 142 mini_cm_close, 143 mini_cm_accept, 144 mini_cm_reject, 145 mini_cm_recv_pkt, 146 mini_cm_dealloc_core, 147 mini_cm_get, 148 mini_cm_set 149}; 150 151static struct nes_cm_core *g_cm_core; 152 153atomic_t cm_connects; 154atomic_t cm_accepts; 155atomic_t cm_disconnects; 156atomic_t cm_closes; 157atomic_t cm_connecteds; 158atomic_t cm_connect_reqs; 159atomic_t cm_rejects; 160 161int nes_add_ref_cm_node(struct nes_cm_node *cm_node) 162{ 163 return add_ref_cm_node(cm_node); 164} 165 166int nes_rem_ref_cm_node(struct nes_cm_node *cm_node) 167{ 168 return rem_ref_cm_node(cm_node->cm_core, cm_node); 169} 170/** 171 * create_event 172 */ 173static struct nes_cm_event *create_event(struct nes_cm_node * cm_node, 174 enum nes_cm_event_type type) 175{ 176 struct nes_cm_event *event; 177 178 if (!cm_node->cm_id) 179 return NULL; 180 181 /* allocate an empty event */ 182 event = kzalloc(sizeof(*event), GFP_ATOMIC); 183 184 if (!event) 185 return NULL; 186 187 event->type = type; 188 event->cm_node = cm_node; 189 event->cm_info.rem_addr = cm_node->rem_addr; 190 event->cm_info.loc_addr = cm_node->loc_addr; 191 event->cm_info.rem_port = cm_node->rem_port; 192 event->cm_info.loc_port = cm_node->loc_port; 193 event->cm_info.cm_id = cm_node->cm_id; 194 195 nes_debug(NES_DBG_CM, "cm_node=%p Created event=%p, type=%u, " 196 "dst_addr=%08x[%x], src_addr=%08x[%x]\n", 197 cm_node, event, type, event->cm_info.loc_addr, 198 event->cm_info.loc_port, event->cm_info.rem_addr, 199 event->cm_info.rem_port); 200 201 nes_cm_post_event(event); 202 return event; 203} 204 205 206/** 207 * send_mpa_request 208 */ 209static int send_mpa_request(struct nes_cm_node *cm_node, struct sk_buff *skb) 210{ 211 u8 start_addr = 0; 212 u8 *start_ptr = &start_addr; 213 u8 **start_buff = &start_ptr; 214 u16 buff_len = 0; 215 216 if (!skb) { 217 nes_debug(NES_DBG_CM, "skb set to NULL\n"); 218 return -1; 219 } 220 221 /* send an MPA Request frame */ 222 cm_build_mpa_frame(cm_node, start_buff, &buff_len, NULL, MPA_KEY_REQUEST); 223 form_cm_frame(skb, cm_node, NULL, 0, *start_buff, buff_len, SET_ACK); 224 225 return schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0); 226} 227 228 229 230static int send_mpa_reject(struct nes_cm_node *cm_node) 231{ 232 struct sk_buff *skb = NULL; 233 u8 start_addr = 0; 234 u8 *start_ptr = &start_addr; 235 u8 **start_buff = &start_ptr; 236 u16 buff_len = 0; 237 struct ietf_mpa_v1 *mpa_frame; 238 239 skb = dev_alloc_skb(MAX_CM_BUFFER); 240 if (!skb) { 241 nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n"); 242 return -ENOMEM; 243 } 244 245 /* send an MPA reject frame */ 246 cm_build_mpa_frame(cm_node, start_buff, &buff_len, NULL, MPA_KEY_REPLY); 247 mpa_frame = (struct ietf_mpa_v1 *)*start_buff; 248 mpa_frame->flags |= IETF_MPA_FLAGS_REJECT; 249 form_cm_frame(skb, cm_node, NULL, 0, *start_buff, buff_len, SET_ACK | SET_FIN); 250 251 cm_node->state = NES_CM_STATE_FIN_WAIT1; 252 return schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0); 253} 254 255 256/** 257 * recv_mpa - process a received TCP pkt, we are expecting an 258 * IETF MPA frame 259 */ 260static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type, 261 u32 len) 262{ 263 struct ietf_mpa_v1 *mpa_frame; 264 struct ietf_mpa_v2 *mpa_v2_frame; 265 struct ietf_rtr_msg *rtr_msg; 266 int mpa_hdr_len; 267 int priv_data_len; 268 269 *type = NES_MPA_REQUEST_ACCEPT; 270 271 /* assume req frame is in tcp data payload */ 272 if (len < sizeof(struct ietf_mpa_v1)) { 273 nes_debug(NES_DBG_CM, "The received ietf buffer was too small (%x)\n", len); 274 return -EINVAL; 275 } 276 277 /* points to the beginning of the frame, which could be MPA V1 or V2 */ 278 mpa_frame = (struct ietf_mpa_v1 *)buffer; 279 mpa_hdr_len = sizeof(struct ietf_mpa_v1); 280 priv_data_len = ntohs(mpa_frame->priv_data_len); 281 282 /* make sure mpa private data len is less than 512 bytes */ 283 if (priv_data_len > IETF_MAX_PRIV_DATA_LEN) { 284 nes_debug(NES_DBG_CM, "The received Length of Private" 285 " Data field exceeds 512 octets\n"); 286 return -EINVAL; 287 } 288 /* 289 * make sure MPA receiver interoperate with the 290 * received MPA version and MPA key information 291 * 292 */ 293 if (mpa_frame->rev != IETF_MPA_V1 && mpa_frame->rev != IETF_MPA_V2) { 294 nes_debug(NES_DBG_CM, "The received mpa version" 295 " is not supported\n"); 296 return -EINVAL; 297 } 298 /* 299 * backwards compatibility only 300 */ 301 if (mpa_frame->rev > cm_node->mpa_frame_rev) { 302 nes_debug(NES_DBG_CM, "The received mpa version" 303 " can not be interoperated\n"); 304 return -EINVAL; 305 } else { 306 cm_node->mpa_frame_rev = mpa_frame->rev; 307 } 308 309 if (cm_node->state != NES_CM_STATE_MPAREQ_SENT) { 310 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE)) { 311 nes_debug(NES_DBG_CM, "Unexpected MPA Key received \n"); 312 return -EINVAL; 313 } 314 } else { 315 if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE)) { 316 nes_debug(NES_DBG_CM, "Unexpected MPA Key received \n"); 317 return -EINVAL; 318 } 319 } 320 321 if (priv_data_len + mpa_hdr_len != len) { 322 nes_debug(NES_DBG_CM, "The received ietf buffer was not right" 323 " complete (%x + %x != %x)\n", 324 priv_data_len, mpa_hdr_len, len); 325 return -EINVAL; 326 } 327 /* make sure it does not exceed the max size */ 328 if (len > MAX_CM_BUFFER) { 329 nes_debug(NES_DBG_CM, "The received ietf buffer was too large" 330 " (%x + %x != %x)\n", 331 priv_data_len, mpa_hdr_len, len); 332 return -EINVAL; 333 } 334 335 cm_node->mpa_frame_size = priv_data_len; 336 337 switch (mpa_frame->rev) { 338 case IETF_MPA_V2: { 339 u16 ird_size; 340 u16 ord_size; 341 u16 rtr_ctrl_ird; 342 u16 rtr_ctrl_ord; 343 344 mpa_v2_frame = (struct ietf_mpa_v2 *)buffer; 345 mpa_hdr_len += IETF_RTR_MSG_SIZE; 346 cm_node->mpa_frame_size -= IETF_RTR_MSG_SIZE; 347 rtr_msg = &mpa_v2_frame->rtr_msg; 348 349 /* parse rtr message */ 350 rtr_ctrl_ird = ntohs(rtr_msg->ctrl_ird); 351 rtr_ctrl_ord = ntohs(rtr_msg->ctrl_ord); 352 ird_size = rtr_ctrl_ird & IETF_NO_IRD_ORD; 353 ord_size = rtr_ctrl_ord & IETF_NO_IRD_ORD; 354 355 if (!(rtr_ctrl_ird & IETF_PEER_TO_PEER)) { 356 /* send reset */ 357 return -EINVAL; 358 } 359 if (ird_size == IETF_NO_IRD_ORD || ord_size == IETF_NO_IRD_ORD) 360 cm_node->mpav2_ird_ord = IETF_NO_IRD_ORD; 361 362 if (cm_node->mpav2_ird_ord != IETF_NO_IRD_ORD) { 363 /* responder */ 364 if (cm_node->state != NES_CM_STATE_MPAREQ_SENT) { 365 /* we are still negotiating */ 366 if (ord_size > NES_MAX_IRD) { 367 cm_node->ird_size = NES_MAX_IRD; 368 } else { 369 cm_node->ird_size = ord_size; 370 if (ord_size == 0 && 371 (rtr_ctrl_ord & IETF_RDMA0_READ)) { 372 cm_node->ird_size = 1; 373 nes_debug(NES_DBG_CM, 374 "%s: Remote peer doesn't support RDMA0_READ (ord=%u)\n", 375 __func__, ord_size); 376 } 377 } 378 if (ird_size > NES_MAX_ORD) 379 cm_node->ord_size = NES_MAX_ORD; 380 else 381 cm_node->ord_size = ird_size; 382 } else { /* initiator */ 383 if (ord_size > NES_MAX_IRD) { 384 nes_debug(NES_DBG_CM, 385 "%s: Unable to support the requested (ord =%u)\n", 386 __func__, ord_size); 387 return -EINVAL; 388 } 389 cm_node->ird_size = ord_size; 390 391 if (ird_size > NES_MAX_ORD) { 392 cm_node->ord_size = NES_MAX_ORD; 393 } else { 394 if (ird_size == 0 && 395 (rtr_ctrl_ord & IETF_RDMA0_READ)) { 396 nes_debug(NES_DBG_CM, 397 "%s: Remote peer doesn't support RDMA0_READ (ird=%u)\n", 398 __func__, ird_size); 399 return -EINVAL; 400 } else { 401 cm_node->ord_size = ird_size; 402 } 403 } 404 } 405 } 406 407 if (rtr_ctrl_ord & IETF_RDMA0_READ) { 408 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO; 409 410 } else if (rtr_ctrl_ord & IETF_RDMA0_WRITE) { 411 cm_node->send_rdma0_op = SEND_RDMA_WRITE_ZERO; 412 } else { /* Not supported RDMA0 operation */ 413 return -EINVAL; 414 } 415 break; 416 } 417 case IETF_MPA_V1: 418 default: 419 break; 420 } 421 422 /* copy entire MPA frame to our cm_node's frame */ 423 memcpy(cm_node->mpa_frame_buf, buffer + mpa_hdr_len, cm_node->mpa_frame_size); 424 425 if (mpa_frame->flags & IETF_MPA_FLAGS_REJECT) 426 *type = NES_MPA_REQUEST_REJECT; 427 return 0; 428} 429 430 431/** 432 * form_cm_frame - get a free packet and build empty frame Use 433 * node info to build. 434 */ 435static void form_cm_frame(struct sk_buff *skb, 436 struct nes_cm_node *cm_node, void *options, u32 optionsize, 437 void *data, u32 datasize, u8 flags) 438{ 439 struct tcphdr *tcph; 440 struct iphdr *iph; 441 struct ethhdr *ethh; 442 u8 *buf; 443 u16 packetsize = sizeof(*iph); 444 445 packetsize += sizeof(*tcph); 446 packetsize += optionsize + datasize; 447 448 skb_trim(skb, 0); 449 memset(skb->data, 0x00, ETH_HLEN + sizeof(*iph) + sizeof(*tcph)); 450 451 buf = skb_put(skb, packetsize + ETH_HLEN); 452 453 ethh = (struct ethhdr *)buf; 454 buf += ETH_HLEN; 455 456 iph = (struct iphdr *)buf; 457 buf += sizeof(*iph); 458 tcph = (struct tcphdr *)buf; 459 skb_reset_mac_header(skb); 460 skb_set_network_header(skb, ETH_HLEN); 461 skb_set_transport_header(skb, ETH_HLEN + sizeof(*iph)); 462 buf += sizeof(*tcph); 463 464 skb->ip_summed = CHECKSUM_PARTIAL; 465 if (!(cm_node->netdev->features & NETIF_F_IP_CSUM)) 466 skb->ip_summed = CHECKSUM_NONE; 467 skb->protocol = htons(0x800); 468 skb->data_len = 0; 469 skb->mac_len = ETH_HLEN; 470 471 memcpy(ethh->h_dest, cm_node->rem_mac, ETH_ALEN); 472 memcpy(ethh->h_source, cm_node->loc_mac, ETH_ALEN); 473 ethh->h_proto = htons(0x0800); 474 475 iph->version = IPVERSION; 476 iph->ihl = 5; /* 5 * 4Byte words, IP headr len */ 477 iph->tos = 0; 478 iph->tot_len = htons(packetsize); 479 iph->id = htons(++cm_node->tcp_cntxt.loc_id); 480 481 iph->frag_off = htons(0x4000); 482 iph->ttl = 0x40; 483 iph->protocol = 0x06; /* IPPROTO_TCP */ 484 485 iph->saddr = htonl(cm_node->mapped_loc_addr); 486 iph->daddr = htonl(cm_node->mapped_rem_addr); 487 488 tcph->source = htons(cm_node->mapped_loc_port); 489 tcph->dest = htons(cm_node->mapped_rem_port); 490 tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num); 491 492 if (flags & SET_ACK) { 493 cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt; 494 tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num); 495 tcph->ack = 1; 496 } else { 497 tcph->ack_seq = 0; 498 } 499 500 if (flags & SET_SYN) { 501 cm_node->tcp_cntxt.loc_seq_num++; 502 tcph->syn = 1; 503 } else { 504 cm_node->tcp_cntxt.loc_seq_num += datasize; 505 } 506 507 if (flags & SET_FIN) { 508 cm_node->tcp_cntxt.loc_seq_num++; 509 tcph->fin = 1; 510 } 511 512 if (flags & SET_RST) 513 tcph->rst = 1; 514 515 tcph->doff = (u16)((sizeof(*tcph) + optionsize + 3) >> 2); 516 tcph->window = htons(cm_node->tcp_cntxt.rcv_wnd); 517 tcph->urg_ptr = 0; 518 if (optionsize) 519 memcpy(buf, options, optionsize); 520 buf += optionsize; 521 if (datasize) 522 memcpy(buf, data, datasize); 523 524 skb_shinfo(skb)->nr_frags = 0; 525 cm_packets_created++; 526} 527 528/* 529 * nes_create_sockaddr - Record ip addr and tcp port in a sockaddr struct 530 */ 531static void nes_create_sockaddr(__be32 ip_addr, __be16 port, 532 struct sockaddr_storage *addr) 533{ 534 struct sockaddr_in *nes_sockaddr = (struct sockaddr_in *)addr; 535 nes_sockaddr->sin_family = AF_INET; 536 memcpy(&nes_sockaddr->sin_addr.s_addr, &ip_addr, sizeof(__be32)); 537 nes_sockaddr->sin_port = port; 538} 539 540/* 541 * nes_create_mapinfo - Create a mapinfo object in the port mapper data base 542 */ 543static int nes_create_mapinfo(struct nes_cm_info *cm_info) 544{ 545 struct sockaddr_storage local_sockaddr; 546 struct sockaddr_storage mapped_sockaddr; 547 548 nes_create_sockaddr(htonl(cm_info->loc_addr), htons(cm_info->loc_port), 549 &local_sockaddr); 550 nes_create_sockaddr(htonl(cm_info->mapped_loc_addr), 551 htons(cm_info->mapped_loc_port), &mapped_sockaddr); 552 553 return iwpm_create_mapinfo(&local_sockaddr, 554 &mapped_sockaddr, RDMA_NL_NES); 555} 556 557/* 558 * nes_remove_mapinfo - Remove a mapinfo object from the port mapper data base 559 * and send a remove mapping op message to 560 * the userspace port mapper 561 */ 562static int nes_remove_mapinfo(u32 loc_addr, u16 loc_port, 563 u32 mapped_loc_addr, u16 mapped_loc_port) 564{ 565 struct sockaddr_storage local_sockaddr; 566 struct sockaddr_storage mapped_sockaddr; 567 568 nes_create_sockaddr(htonl(loc_addr), htons(loc_port), &local_sockaddr); 569 nes_create_sockaddr(htonl(mapped_loc_addr), htons(mapped_loc_port), 570 &mapped_sockaddr); 571 572 iwpm_remove_mapinfo(&local_sockaddr, &mapped_sockaddr); 573 return iwpm_remove_mapping(&local_sockaddr, RDMA_NL_NES); 574} 575 576/* 577 * nes_form_pm_msg - Form a port mapper message with mapping info 578 */ 579static void nes_form_pm_msg(struct nes_cm_info *cm_info, 580 struct iwpm_sa_data *pm_msg) 581{ 582 nes_create_sockaddr(htonl(cm_info->loc_addr), htons(cm_info->loc_port), 583 &pm_msg->loc_addr); 584 nes_create_sockaddr(htonl(cm_info->rem_addr), htons(cm_info->rem_port), 585 &pm_msg->rem_addr); 586} 587 588/* 589 * nes_form_reg_msg - Form a port mapper message with dev info 590 */ 591static void nes_form_reg_msg(struct nes_vnic *nesvnic, 592 struct iwpm_dev_data *pm_msg) 593{ 594 memcpy(pm_msg->dev_name, nesvnic->nesibdev->ibdev.name, 595 IWPM_DEVNAME_SIZE); 596 memcpy(pm_msg->if_name, nesvnic->netdev->name, IWPM_IFNAME_SIZE); 597} 598 599static void record_sockaddr_info(struct sockaddr_storage *addr_info, 600 nes_addr_t *ip_addr, u16 *port_num) 601{ 602 struct sockaddr_in *in_addr = (struct sockaddr_in *)addr_info; 603 604 if (in_addr->sin_family == AF_INET) { 605 *ip_addr = ntohl(in_addr->sin_addr.s_addr); 606 *port_num = ntohs(in_addr->sin_port); 607 } 608} 609 610/* 611 * nes_record_pm_msg - Save the received mapping info 612 */ 613static void nes_record_pm_msg(struct nes_cm_info *cm_info, 614 struct iwpm_sa_data *pm_msg) 615{ 616 record_sockaddr_info(&pm_msg->mapped_loc_addr, 617 &cm_info->mapped_loc_addr, &cm_info->mapped_loc_port); 618 619 record_sockaddr_info(&pm_msg->mapped_rem_addr, 620 &cm_info->mapped_rem_addr, &cm_info->mapped_rem_port); 621} 622 623/* 624 * nes_get_reminfo - Get the address info of the remote connecting peer 625 */ 626static int nes_get_remote_addr(struct nes_cm_node *cm_node) 627{ 628 struct sockaddr_storage mapped_loc_addr, mapped_rem_addr; 629 struct sockaddr_storage remote_addr; 630 int ret; 631 632 nes_create_sockaddr(htonl(cm_node->mapped_loc_addr), 633 htons(cm_node->mapped_loc_port), &mapped_loc_addr); 634 nes_create_sockaddr(htonl(cm_node->mapped_rem_addr), 635 htons(cm_node->mapped_rem_port), &mapped_rem_addr); 636 637 ret = iwpm_get_remote_info(&mapped_loc_addr, &mapped_rem_addr, 638 &remote_addr, RDMA_NL_NES); 639 if (ret) 640 nes_debug(NES_DBG_CM, "Unable to find remote peer address info\n"); 641 else 642 record_sockaddr_info(&remote_addr, &cm_node->rem_addr, 643 &cm_node->rem_port); 644 return ret; 645} 646 647/** 648 * print_core - dump a cm core 649 */ 650static void print_core(struct nes_cm_core *core) 651{ 652 nes_debug(NES_DBG_CM, "---------------------------------------------\n"); 653 nes_debug(NES_DBG_CM, "CM Core -- (core = %p )\n", core); 654 if (!core) 655 return; 656 nes_debug(NES_DBG_CM, "---------------------------------------------\n"); 657 658 nes_debug(NES_DBG_CM, "State : %u \n", core->state); 659 660 nes_debug(NES_DBG_CM, "Listen Nodes : %u \n", atomic_read(&core->listen_node_cnt)); 661 nes_debug(NES_DBG_CM, "Active Nodes : %u \n", atomic_read(&core->node_cnt)); 662 663 nes_debug(NES_DBG_CM, "core : %p \n", core); 664 665 nes_debug(NES_DBG_CM, "-------------- end core ---------------\n"); 666} 667 668static void record_ird_ord(struct nes_cm_node *cm_node, 669 u16 conn_ird, u16 conn_ord) 670{ 671 if (conn_ird > NES_MAX_IRD) 672 conn_ird = NES_MAX_IRD; 673 674 if (conn_ord > NES_MAX_ORD) 675 conn_ord = NES_MAX_ORD; 676 677 cm_node->ird_size = conn_ird; 678 cm_node->ord_size = conn_ord; 679} 680 681/** 682 * cm_build_mpa_frame - build a MPA V1 frame or MPA V2 frame 683 */ 684static int cm_build_mpa_frame(struct nes_cm_node *cm_node, u8 **start_buff, 685 u16 *buff_len, u8 *pci_mem, u8 mpa_key) 686{ 687 int ret = 0; 688 689 *start_buff = (pci_mem) ? pci_mem : &cm_node->mpa_frame_buf[0]; 690 691 switch (cm_node->mpa_frame_rev) { 692 case IETF_MPA_V1: 693 *start_buff = (u8 *)*start_buff + sizeof(struct ietf_rtr_msg); 694 *buff_len = sizeof(struct ietf_mpa_v1) + cm_node->mpa_frame_size; 695 build_mpa_v1(cm_node, *start_buff, mpa_key); 696 break; 697 case IETF_MPA_V2: 698 *buff_len = sizeof(struct ietf_mpa_v2) + cm_node->mpa_frame_size; 699 build_mpa_v2(cm_node, *start_buff, mpa_key); 700 break; 701 default: 702 ret = -EINVAL; 703 } 704 return ret; 705} 706 707/** 708 * build_mpa_v2 - build a MPA V2 frame 709 */ 710static void build_mpa_v2(struct nes_cm_node *cm_node, 711 void *start_addr, u8 mpa_key) 712{ 713 struct ietf_mpa_v2 *mpa_frame = (struct ietf_mpa_v2 *)start_addr; 714 struct ietf_rtr_msg *rtr_msg = &mpa_frame->rtr_msg; 715 u16 ctrl_ird; 716 u16 ctrl_ord; 717 718 /* initialize the upper 5 bytes of the frame */ 719 build_mpa_v1(cm_node, start_addr, mpa_key); 720 mpa_frame->flags |= IETF_MPA_V2_FLAG; /* set a bit to indicate MPA V2 */ 721 mpa_frame->priv_data_len += htons(IETF_RTR_MSG_SIZE); 722 723 /* initialize RTR msg */ 724 if (cm_node->mpav2_ird_ord == IETF_NO_IRD_ORD) { 725 ctrl_ird = IETF_NO_IRD_ORD; 726 ctrl_ord = IETF_NO_IRD_ORD; 727 } else { 728 ctrl_ird = cm_node->ird_size & IETF_NO_IRD_ORD; 729 ctrl_ord = cm_node->ord_size & IETF_NO_IRD_ORD; 730 } 731 ctrl_ird |= IETF_PEER_TO_PEER; 732 ctrl_ird |= IETF_FLPDU_ZERO_LEN; 733 734 switch (mpa_key) { 735 case MPA_KEY_REQUEST: 736 ctrl_ord |= IETF_RDMA0_WRITE; 737 ctrl_ord |= IETF_RDMA0_READ; 738 break; 739 case MPA_KEY_REPLY: 740 switch (cm_node->send_rdma0_op) { 741 case SEND_RDMA_WRITE_ZERO: 742 ctrl_ord |= IETF_RDMA0_WRITE; 743 break; 744 case SEND_RDMA_READ_ZERO: 745 ctrl_ord |= IETF_RDMA0_READ; 746 break; 747 } 748 } 749 rtr_msg->ctrl_ird = htons(ctrl_ird); 750 rtr_msg->ctrl_ord = htons(ctrl_ord); 751} 752 753/** 754 * build_mpa_v1 - build a MPA V1 frame 755 */ 756static void build_mpa_v1(struct nes_cm_node *cm_node, void *start_addr, u8 mpa_key) 757{ 758 struct ietf_mpa_v1 *mpa_frame = (struct ietf_mpa_v1 *)start_addr; 759 760 switch (mpa_key) { 761 case MPA_KEY_REQUEST: 762 memcpy(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE); 763 break; 764 case MPA_KEY_REPLY: 765 memcpy(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE); 766 break; 767 } 768 mpa_frame->flags = IETF_MPA_FLAGS_CRC; 769 mpa_frame->rev = cm_node->mpa_frame_rev; 770 mpa_frame->priv_data_len = htons(cm_node->mpa_frame_size); 771} 772 773static void build_rdma0_msg(struct nes_cm_node *cm_node, struct nes_qp **nesqp_addr) 774{ 775 u64 u64temp; 776 struct nes_qp *nesqp = *nesqp_addr; 777 struct nes_hw_qp_wqe *wqe = &nesqp->hwqp.sq_vbase[0]; 778 779 u64temp = (unsigned long)nesqp->nesuqp_addr; 780 u64temp |= NES_SW_CONTEXT_ALIGN >> 1; 781 set_wqe_64bit_value(wqe->wqe_words, NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX, u64temp); 782 783 wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_LOW_IDX] = 0; 784 wqe->wqe_words[NES_IWARP_SQ_WQE_FRAG0_HIGH_IDX] = 0; 785 786 switch (cm_node->send_rdma0_op) { 787 case SEND_RDMA_WRITE_ZERO: 788 nes_debug(NES_DBG_CM, "Sending first write.\n"); 789 wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] = 790 cpu_to_le32(NES_IWARP_SQ_OP_RDMAW); 791 wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] = 0; 792 wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] = 0; 793 wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = 0; 794 break; 795 796 case SEND_RDMA_READ_ZERO: 797 default: 798 if (cm_node->send_rdma0_op != SEND_RDMA_READ_ZERO) 799 WARN(1, "Unsupported RDMA0 len operation=%u\n", 800 cm_node->send_rdma0_op); 801 nes_debug(NES_DBG_CM, "Sending first rdma operation.\n"); 802 wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] = 803 cpu_to_le32(NES_IWARP_SQ_OP_RDMAR); 804 wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_TO_LOW_IDX] = 1; 805 wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_TO_HIGH_IDX] = 0; 806 wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_LENGTH_IDX] = 0; 807 wqe->wqe_words[NES_IWARP_SQ_WQE_RDMA_STAG_IDX] = 1; 808 wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = 1; 809 break; 810 } 811 812 if (nesqp->sq_kmapped) { 813 nesqp->sq_kmapped = 0; 814 kunmap(nesqp->page); 815 } 816 817 /*use the reserved spot on the WQ for the extra first WQE*/ 818 nesqp->nesqp_context->ird_ord_sizes &= cpu_to_le32(~(NES_QPCONTEXT_ORDIRD_LSMM_PRESENT | 819 NES_QPCONTEXT_ORDIRD_WRPDU | 820 NES_QPCONTEXT_ORDIRD_ALSMM)); 821 nesqp->skip_lsmm = 1; 822 nesqp->hwqp.sq_tail = 0; 823} 824 825/** 826 * schedule_nes_timer 827 * note - cm_node needs to be protected before calling this. Encase in: 828 * rem_ref_cm_node(cm_core, cm_node);add_ref_cm_node(cm_node); 829 */ 830int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb, 831 enum nes_timer_type type, int send_retrans, 832 int close_when_complete) 833{ 834 unsigned long flags; 835 struct nes_cm_core *cm_core = cm_node->cm_core; 836 struct nes_timer_entry *new_send; 837 int ret = 0; 838 839 new_send = kzalloc(sizeof(*new_send), GFP_ATOMIC); 840 if (!new_send) 841 return -ENOMEM; 842 843 /* new_send->timetosend = currenttime */ 844 new_send->retrycount = NES_DEFAULT_RETRYS; 845 new_send->retranscount = NES_DEFAULT_RETRANS; 846 new_send->skb = skb; 847 new_send->timetosend = jiffies; 848 new_send->type = type; 849 new_send->netdev = cm_node->netdev; 850 new_send->send_retrans = send_retrans; 851 new_send->close_when_complete = close_when_complete; 852 853 if (type == NES_TIMER_TYPE_CLOSE) { 854 new_send->timetosend += (HZ / 10); 855 if (cm_node->recv_entry) { 856 kfree(new_send); 857 WARN_ON(1); 858 return -EINVAL; 859 } 860 cm_node->recv_entry = new_send; 861 } 862 863 if (type == NES_TIMER_TYPE_SEND) { 864 new_send->seq_num = ntohl(tcp_hdr(skb)->seq); 865 atomic_inc(&new_send->skb->users); 866 spin_lock_irqsave(&cm_node->retrans_list_lock, flags); 867 cm_node->send_entry = new_send; 868 add_ref_cm_node(cm_node); 869 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags); 870 new_send->timetosend = jiffies + NES_RETRY_TIMEOUT; 871 872 ret = nes_nic_cm_xmit(new_send->skb, cm_node->netdev); 873 if (ret != NETDEV_TX_OK) { 874 nes_debug(NES_DBG_CM, "Error sending packet %p " 875 "(jiffies = %lu)\n", new_send, jiffies); 876 new_send->timetosend = jiffies; 877 ret = NETDEV_TX_OK; 878 } else { 879 cm_packets_sent++; 880 if (!send_retrans) { 881 cleanup_retrans_entry(cm_node); 882 if (close_when_complete) 883 rem_ref_cm_node(cm_core, cm_node); 884 return ret; 885 } 886 } 887 } 888 889 if (!timer_pending(&cm_core->tcp_timer)) 890 mod_timer(&cm_core->tcp_timer, new_send->timetosend); 891 892 return ret; 893} 894 895static void nes_retrans_expired(struct nes_cm_node *cm_node) 896{ 897 struct iw_cm_id *cm_id = cm_node->cm_id; 898 enum nes_cm_node_state state = cm_node->state; 899 cm_node->state = NES_CM_STATE_CLOSED; 900 901 switch (state) { 902 case NES_CM_STATE_SYN_RCVD: 903 case NES_CM_STATE_CLOSING: 904 rem_ref_cm_node(cm_node->cm_core, cm_node); 905 break; 906 case NES_CM_STATE_LAST_ACK: 907 case NES_CM_STATE_FIN_WAIT1: 908 if (cm_node->cm_id) 909 cm_id->rem_ref(cm_id); 910 send_reset(cm_node, NULL); 911 break; 912 default: 913 add_ref_cm_node(cm_node); 914 send_reset(cm_node, NULL); 915 create_event(cm_node, NES_CM_EVENT_ABORTED); 916 } 917} 918 919static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node) 920{ 921 struct nes_timer_entry *recv_entry = cm_node->recv_entry; 922 struct iw_cm_id *cm_id = cm_node->cm_id; 923 struct nes_qp *nesqp; 924 unsigned long qplockflags; 925 926 if (!recv_entry) 927 return; 928 nesqp = (struct nes_qp *)recv_entry->skb; 929 if (nesqp) { 930 spin_lock_irqsave(&nesqp->lock, qplockflags); 931 if (nesqp->cm_id) { 932 nes_debug(NES_DBG_CM, "QP%u: cm_id = %p, " 933 "refcount = %d: HIT A " 934 "NES_TIMER_TYPE_CLOSE with something " 935 "to do!!!\n", nesqp->hwqp.qp_id, cm_id, 936 atomic_read(&nesqp->refcount)); 937 nesqp->hw_tcp_state = NES_AEQE_TCP_STATE_CLOSED; 938 nesqp->last_aeq = NES_AEQE_AEID_RESET_SENT; 939 nesqp->ibqp_state = IB_QPS_ERR; 940 spin_unlock_irqrestore(&nesqp->lock, qplockflags); 941 nes_cm_disconn(nesqp); 942 } else { 943 spin_unlock_irqrestore(&nesqp->lock, qplockflags); 944 nes_debug(NES_DBG_CM, "QP%u: cm_id = %p, " 945 "refcount = %d: HIT A " 946 "NES_TIMER_TYPE_CLOSE with nothing " 947 "to do!!!\n", nesqp->hwqp.qp_id, cm_id, 948 atomic_read(&nesqp->refcount)); 949 } 950 } else if (rem_node) { 951 /* TIME_WAIT state */ 952 rem_ref_cm_node(cm_node->cm_core, cm_node); 953 } 954 if (cm_node->cm_id) 955 cm_id->rem_ref(cm_id); 956 kfree(recv_entry); 957 cm_node->recv_entry = NULL; 958} 959 960/** 961 * nes_cm_timer_tick 962 */ 963static void nes_cm_timer_tick(unsigned long pass) 964{ 965 unsigned long flags; 966 unsigned long nexttimeout = jiffies + NES_LONG_TIME; 967 struct nes_cm_node *cm_node; 968 struct nes_timer_entry *send_entry, *recv_entry; 969 struct list_head *list_core_temp; 970 struct list_head *list_node; 971 struct nes_cm_core *cm_core = g_cm_core; 972 u32 settimer = 0; 973 unsigned long timetosend; 974 int ret = NETDEV_TX_OK; 975 976 struct list_head timer_list; 977 978 INIT_LIST_HEAD(&timer_list); 979 spin_lock_irqsave(&cm_core->ht_lock, flags); 980 981 list_for_each_safe(list_node, list_core_temp, 982 &cm_core->connected_nodes) { 983 cm_node = container_of(list_node, struct nes_cm_node, list); 984 if ((cm_node->recv_entry) || (cm_node->send_entry)) { 985 add_ref_cm_node(cm_node); 986 list_add(&cm_node->timer_entry, &timer_list); 987 } 988 } 989 spin_unlock_irqrestore(&cm_core->ht_lock, flags); 990 991 list_for_each_safe(list_node, list_core_temp, &timer_list) { 992 cm_node = container_of(list_node, struct nes_cm_node, 993 timer_entry); 994 recv_entry = cm_node->recv_entry; 995 996 if (recv_entry) { 997 if (time_after(recv_entry->timetosend, jiffies)) { 998 if (nexttimeout > recv_entry->timetosend || 999 !settimer) { 1000 nexttimeout = recv_entry->timetosend; 1001 settimer = 1; 1002 } 1003 } else { 1004 handle_recv_entry(cm_node, 1); 1005 } 1006 } 1007 1008 spin_lock_irqsave(&cm_node->retrans_list_lock, flags); 1009 do { 1010 send_entry = cm_node->send_entry; 1011 if (!send_entry) 1012 break; 1013 if (time_after(send_entry->timetosend, jiffies)) { 1014 if (cm_node->state != NES_CM_STATE_TSA) { 1015 if ((nexttimeout > 1016 send_entry->timetosend) || 1017 !settimer) { 1018 nexttimeout = 1019 send_entry->timetosend; 1020 settimer = 1; 1021 } 1022 } else { 1023 free_retrans_entry(cm_node); 1024 } 1025 break; 1026 } 1027 1028 if ((cm_node->state == NES_CM_STATE_TSA) || 1029 (cm_node->state == NES_CM_STATE_CLOSED)) { 1030 free_retrans_entry(cm_node); 1031 break; 1032 } 1033 1034 if (!send_entry->retranscount || 1035 !send_entry->retrycount) { 1036 cm_packets_dropped++; 1037 free_retrans_entry(cm_node); 1038 1039 spin_unlock_irqrestore( 1040 &cm_node->retrans_list_lock, flags); 1041 nes_retrans_expired(cm_node); 1042 cm_node->state = NES_CM_STATE_CLOSED; 1043 spin_lock_irqsave(&cm_node->retrans_list_lock, 1044 flags); 1045 break; 1046 } 1047 atomic_inc(&send_entry->skb->users); 1048 cm_packets_retrans++; 1049 nes_debug(NES_DBG_CM, "Retransmitting send_entry %p " 1050 "for node %p, jiffies = %lu, time to send = " 1051 "%lu, retranscount = %u, send_entry->seq_num = " 1052 "0x%08X, cm_node->tcp_cntxt.rem_ack_num = " 1053 "0x%08X\n", send_entry, cm_node, jiffies, 1054 send_entry->timetosend, 1055 send_entry->retranscount, 1056 send_entry->seq_num, 1057 cm_node->tcp_cntxt.rem_ack_num); 1058 1059 spin_unlock_irqrestore(&cm_node->retrans_list_lock, 1060 flags); 1061 ret = nes_nic_cm_xmit(send_entry->skb, cm_node->netdev); 1062 spin_lock_irqsave(&cm_node->retrans_list_lock, flags); 1063 if (ret != NETDEV_TX_OK) { 1064 nes_debug(NES_DBG_CM, "rexmit failed for " 1065 "node=%p\n", cm_node); 1066 cm_packets_bounced++; 1067 send_entry->retrycount--; 1068 nexttimeout = jiffies + NES_SHORT_TIME; 1069 settimer = 1; 1070 break; 1071 } else { 1072 cm_packets_sent++; 1073 } 1074 nes_debug(NES_DBG_CM, "Packet Sent: retrans count = " 1075 "%u, retry count = %u.\n", 1076 send_entry->retranscount, 1077 send_entry->retrycount); 1078 if (send_entry->send_retrans) { 1079 send_entry->retranscount--; 1080 timetosend = (NES_RETRY_TIMEOUT << 1081 (NES_DEFAULT_RETRANS - send_entry->retranscount)); 1082 1083 send_entry->timetosend = jiffies + 1084 min(timetosend, NES_MAX_TIMEOUT); 1085 if (nexttimeout > send_entry->timetosend || 1086 !settimer) { 1087 nexttimeout = send_entry->timetosend; 1088 settimer = 1; 1089 } 1090 } else { 1091 int close_when_complete; 1092 close_when_complete = 1093 send_entry->close_when_complete; 1094 nes_debug(NES_DBG_CM, "cm_node=%p state=%d\n", 1095 cm_node, cm_node->state); 1096 free_retrans_entry(cm_node); 1097 if (close_when_complete) 1098 rem_ref_cm_node(cm_node->cm_core, 1099 cm_node); 1100 } 1101 } while (0); 1102 1103 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags); 1104 rem_ref_cm_node(cm_node->cm_core, cm_node); 1105 } 1106 1107 if (settimer) { 1108 if (!timer_pending(&cm_core->tcp_timer)) 1109 mod_timer(&cm_core->tcp_timer, nexttimeout); 1110 } 1111} 1112 1113 1114/** 1115 * send_syn 1116 */ 1117static int send_syn(struct nes_cm_node *cm_node, u32 sendack, 1118 struct sk_buff *skb) 1119{ 1120 int ret; 1121 int flags = SET_SYN; 1122 char optionsbuffer[sizeof(struct option_mss) + 1123 sizeof(struct option_windowscale) + sizeof(struct option_base) + 1124 TCP_OPTIONS_PADDING]; 1125 1126 int optionssize = 0; 1127 /* Sending MSS option */ 1128 union all_known_options *options; 1129 1130 if (!cm_node) 1131 return -EINVAL; 1132 1133 options = (union all_known_options *)&optionsbuffer[optionssize]; 1134 options->as_mss.optionnum = OPTION_NUMBER_MSS; 1135 options->as_mss.length = sizeof(struct option_mss); 1136 options->as_mss.mss = htons(cm_node->tcp_cntxt.mss); 1137 optionssize += sizeof(struct option_mss); 1138 1139 options = (union all_known_options *)&optionsbuffer[optionssize]; 1140 options->as_windowscale.optionnum = OPTION_NUMBER_WINDOW_SCALE; 1141 options->as_windowscale.length = sizeof(struct option_windowscale); 1142 options->as_windowscale.shiftcount = cm_node->tcp_cntxt.rcv_wscale; 1143 optionssize += sizeof(struct option_windowscale); 1144 1145 if (sendack && !(NES_DRV_OPT_SUPRESS_OPTION_BC & nes_drv_opt)) { 1146 options = (union all_known_options *)&optionsbuffer[optionssize]; 1147 options->as_base.optionnum = OPTION_NUMBER_WRITE0; 1148 options->as_base.length = sizeof(struct option_base); 1149 optionssize += sizeof(struct option_base); 1150 /* we need the size to be a multiple of 4 */ 1151 options = (union all_known_options *)&optionsbuffer[optionssize]; 1152 options->as_end = 1; 1153 optionssize += 1; 1154 options = (union all_known_options *)&optionsbuffer[optionssize]; 1155 options->as_end = 1; 1156 optionssize += 1; 1157 } 1158 1159 options = (union all_known_options *)&optionsbuffer[optionssize]; 1160 options->as_end = OPTION_NUMBER_END; 1161 optionssize += 1; 1162 1163 if (!skb) 1164 skb = dev_alloc_skb(MAX_CM_BUFFER); 1165 if (!skb) { 1166 nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n"); 1167 return -1; 1168 } 1169 1170 if (sendack) 1171 flags |= SET_ACK; 1172 1173 form_cm_frame(skb, cm_node, optionsbuffer, optionssize, NULL, 0, flags); 1174 ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0); 1175 1176 return ret; 1177} 1178 1179 1180/** 1181 * send_reset 1182 */ 1183static int send_reset(struct nes_cm_node *cm_node, struct sk_buff *skb) 1184{ 1185 int ret; 1186 int flags = SET_RST | SET_ACK; 1187 1188 if (!skb) 1189 skb = dev_alloc_skb(MAX_CM_BUFFER); 1190 if (!skb) { 1191 nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n"); 1192 return -ENOMEM; 1193 } 1194 1195 form_cm_frame(skb, cm_node, NULL, 0, NULL, 0, flags); 1196 ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 0, 1); 1197 1198 return ret; 1199} 1200 1201 1202/** 1203 * send_ack 1204 */ 1205static int send_ack(struct nes_cm_node *cm_node, struct sk_buff *skb) 1206{ 1207 int ret; 1208 1209 if (!skb) 1210 skb = dev_alloc_skb(MAX_CM_BUFFER); 1211 1212 if (!skb) { 1213 nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n"); 1214 return -1; 1215 } 1216 1217 form_cm_frame(skb, cm_node, NULL, 0, NULL, 0, SET_ACK); 1218 ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 0, 0); 1219 1220 return ret; 1221} 1222 1223 1224/** 1225 * send_fin 1226 */ 1227static int send_fin(struct nes_cm_node *cm_node, struct sk_buff *skb) 1228{ 1229 int ret; 1230 1231 /* if we didn't get a frame get one */ 1232 if (!skb) 1233 skb = dev_alloc_skb(MAX_CM_BUFFER); 1234 1235 if (!skb) { 1236 nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n"); 1237 return -1; 1238 } 1239 1240 form_cm_frame(skb, cm_node, NULL, 0, NULL, 0, SET_ACK | SET_FIN); 1241 ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0); 1242 1243 return ret; 1244} 1245 1246 1247/** 1248 * find_node - find a cm node that matches the reference cm node 1249 */ 1250static struct nes_cm_node *find_node(struct nes_cm_core *cm_core, 1251 u16 rem_port, nes_addr_t rem_addr, u16 loc_port, nes_addr_t loc_addr) 1252{ 1253 unsigned long flags; 1254 struct list_head *hte; 1255 struct nes_cm_node *cm_node; 1256 1257 /* get a handle on the hte */ 1258 hte = &cm_core->connected_nodes; 1259 1260 /* walk list and find cm_node associated with this session ID */ 1261 spin_lock_irqsave(&cm_core->ht_lock, flags); 1262 list_for_each_entry(cm_node, hte, list) { 1263 /* compare quad, return node handle if a match */ 1264 nes_debug(NES_DBG_CM, "finding node %x:%x =? %x:%x ^ %x:%x =? %x:%x\n", 1265 cm_node->loc_addr, cm_node->loc_port, 1266 loc_addr, loc_port, 1267 cm_node->rem_addr, cm_node->rem_port, 1268 rem_addr, rem_port); 1269 if ((cm_node->mapped_loc_addr == loc_addr) && 1270 (cm_node->mapped_loc_port == loc_port) && 1271 (cm_node->mapped_rem_addr == rem_addr) && 1272 (cm_node->mapped_rem_port == rem_port)) { 1273 1274 add_ref_cm_node(cm_node); 1275 spin_unlock_irqrestore(&cm_core->ht_lock, flags); 1276 return cm_node; 1277 } 1278 } 1279 spin_unlock_irqrestore(&cm_core->ht_lock, flags); 1280 1281 /* no owner node */ 1282 return NULL; 1283} 1284 1285 1286/** 1287 * find_listener - find a cm node listening on this addr-port pair 1288 */ 1289static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core, 1290 nes_addr_t dst_addr, u16 dst_port, 1291 enum nes_cm_listener_state listener_state, int local) 1292{ 1293 unsigned long flags; 1294 struct nes_cm_listener *listen_node; 1295 nes_addr_t listen_addr; 1296 u16 listen_port; 1297 1298 /* walk list and find cm_node associated with this session ID */ 1299 spin_lock_irqsave(&cm_core->listen_list_lock, flags); 1300 list_for_each_entry(listen_node, &cm_core->listen_list.list, list) { 1301 if (local) { 1302 listen_addr = listen_node->loc_addr; 1303 listen_port = listen_node->loc_port; 1304 } else { 1305 listen_addr = listen_node->mapped_loc_addr; 1306 listen_port = listen_node->mapped_loc_port; 1307 } 1308 /* compare node pair, return node handle if a match */ 1309 if (((listen_addr == dst_addr) || 1310 listen_addr == 0x00000000) && 1311 (listen_port == dst_port) && 1312 (listener_state & listen_node->listener_state)) { 1313 atomic_inc(&listen_node->ref_count); 1314 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags); 1315 return listen_node; 1316 } 1317 } 1318 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags); 1319 1320 /* no listener */ 1321 return NULL; 1322} 1323 1324/** 1325 * add_hte_node - add a cm node to the hash table 1326 */ 1327static int add_hte_node(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node) 1328{ 1329 unsigned long flags; 1330 struct list_head *hte; 1331 1332 if (!cm_node || !cm_core) 1333 return -EINVAL; 1334 1335 nes_debug(NES_DBG_CM, "Adding Node %p to Active Connection HT\n", 1336 cm_node); 1337 1338 spin_lock_irqsave(&cm_core->ht_lock, flags); 1339 1340 /* get a handle on the hash table element (list head for this slot) */ 1341 hte = &cm_core->connected_nodes; 1342 list_add_tail(&cm_node->list, hte); 1343 atomic_inc(&cm_core->ht_node_cnt); 1344 1345 spin_unlock_irqrestore(&cm_core->ht_lock, flags); 1346 1347 return 0; 1348} 1349 1350 1351/** 1352 * mini_cm_dec_refcnt_listen 1353 */ 1354static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core, 1355 struct nes_cm_listener *listener, int free_hanging_nodes) 1356{ 1357 int ret = -EINVAL; 1358 int err = 0; 1359 unsigned long flags; 1360 struct list_head *list_pos = NULL; 1361 struct list_head *list_temp = NULL; 1362 struct nes_cm_node *cm_node = NULL; 1363 struct list_head reset_list; 1364 1365 nes_debug(NES_DBG_CM, "attempting listener= %p free_nodes= %d, " 1366 "refcnt=%d\n", listener, free_hanging_nodes, 1367 atomic_read(&listener->ref_count)); 1368 /* free non-accelerated child nodes for this listener */ 1369 INIT_LIST_HEAD(&reset_list); 1370 if (free_hanging_nodes) { 1371 spin_lock_irqsave(&cm_core->ht_lock, flags); 1372 list_for_each_safe(list_pos, list_temp, 1373 &g_cm_core->connected_nodes) { 1374 cm_node = container_of(list_pos, struct nes_cm_node, 1375 list); 1376 if ((cm_node->listener == listener) && 1377 (!cm_node->accelerated)) { 1378 add_ref_cm_node(cm_node); 1379 list_add(&cm_node->reset_entry, &reset_list); 1380 } 1381 } 1382 spin_unlock_irqrestore(&cm_core->ht_lock, flags); 1383 } 1384 1385 list_for_each_safe(list_pos, list_temp, &reset_list) { 1386 cm_node = container_of(list_pos, struct nes_cm_node, 1387 reset_entry); 1388 { 1389 struct nes_cm_node *loopback = cm_node->loopbackpartner; 1390 enum nes_cm_node_state old_state; 1391 if (NES_CM_STATE_FIN_WAIT1 <= cm_node->state) { 1392 rem_ref_cm_node(cm_node->cm_core, cm_node); 1393 } else { 1394 if (!loopback) { 1395 cleanup_retrans_entry(cm_node); 1396 err = send_reset(cm_node, NULL); 1397 if (err) { 1398 cm_node->state = 1399 NES_CM_STATE_CLOSED; 1400 WARN_ON(1); 1401 } else { 1402 old_state = cm_node->state; 1403 cm_node->state = NES_CM_STATE_LISTENER_DESTROYED; 1404 if (old_state != NES_CM_STATE_MPAREQ_RCVD) 1405 rem_ref_cm_node( 1406 cm_node->cm_core, 1407 cm_node); 1408 } 1409 } else { 1410 struct nes_cm_event event; 1411 1412 event.cm_node = loopback; 1413 event.cm_info.rem_addr = 1414 loopback->rem_addr; 1415 event.cm_info.loc_addr = 1416 loopback->loc_addr; 1417 event.cm_info.rem_port = 1418 loopback->rem_port; 1419 event.cm_info.loc_port = 1420 loopback->loc_port; 1421 event.cm_info.cm_id = loopback->cm_id; 1422 add_ref_cm_node(loopback); 1423 loopback->state = NES_CM_STATE_CLOSED; 1424 cm_event_connect_error(&event); 1425 cm_node->state = NES_CM_STATE_LISTENER_DESTROYED; 1426 1427 rem_ref_cm_node(cm_node->cm_core, 1428 cm_node); 1429 1430 } 1431 } 1432 } 1433 } 1434 1435 spin_lock_irqsave(&cm_core->listen_list_lock, flags); 1436 if (!atomic_dec_return(&listener->ref_count)) { 1437 list_del(&listener->list); 1438 1439 /* decrement our listen node count */ 1440 atomic_dec(&cm_core->listen_node_cnt); 1441 1442 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags); 1443 1444 if (listener->nesvnic) { 1445 nes_manage_apbvt(listener->nesvnic, 1446 listener->mapped_loc_port, 1447 PCI_FUNC(listener->nesvnic->nesdev->pcidev->devfn), 1448 NES_MANAGE_APBVT_DEL); 1449 1450 nes_remove_mapinfo(listener->loc_addr, 1451 listener->loc_port, 1452 listener->mapped_loc_addr, 1453 listener->mapped_loc_port); 1454 nes_debug(NES_DBG_NLMSG, 1455 "Delete APBVT mapped_loc_port = %04X\n", 1456 listener->mapped_loc_port); 1457 } 1458 1459 nes_debug(NES_DBG_CM, "destroying listener (%p)\n", listener); 1460 1461 kfree(listener); 1462 listener = NULL; 1463 ret = 0; 1464 atomic_inc(&cm_listens_destroyed); 1465 } else { 1466 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags); 1467 } 1468 if (listener) { 1469 if (atomic_read(&listener->pend_accepts_cnt) > 0) 1470 nes_debug(NES_DBG_CM, "destroying listener (%p)" 1471 " with non-zero pending accepts=%u\n", 1472 listener, atomic_read(&listener->pend_accepts_cnt)); 1473 } 1474 1475 return ret; 1476} 1477 1478 1479/** 1480 * mini_cm_del_listen 1481 */ 1482static int mini_cm_del_listen(struct nes_cm_core *cm_core, 1483 struct nes_cm_listener *listener) 1484{ 1485 listener->listener_state = NES_CM_LISTENER_PASSIVE_STATE; 1486 listener->cm_id = NULL; /* going to be destroyed pretty soon */ 1487 return mini_cm_dec_refcnt_listen(cm_core, listener, 1); 1488} 1489 1490 1491/** 1492 * mini_cm_accelerated 1493 */ 1494static inline int mini_cm_accelerated(struct nes_cm_core *cm_core, 1495 struct nes_cm_node *cm_node) 1496{ 1497 cm_node->accelerated = 1; 1498 1499 if (cm_node->accept_pend) { 1500 BUG_ON(!cm_node->listener); 1501 atomic_dec(&cm_node->listener->pend_accepts_cnt); 1502 cm_node->accept_pend = 0; 1503 BUG_ON(atomic_read(&cm_node->listener->pend_accepts_cnt) < 0); 1504 } 1505 1506 if (!timer_pending(&cm_core->tcp_timer)) 1507 mod_timer(&cm_core->tcp_timer, (jiffies + NES_SHORT_TIME)); 1508 1509 return 0; 1510} 1511 1512 1513/** 1514 * nes_addr_resolve_neigh 1515 */ 1516static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpindex) 1517{ 1518 struct rtable *rt; 1519 struct neighbour *neigh; 1520 int rc = arpindex; 1521 struct net_device *netdev; 1522 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter; 1523 1524 rt = ip_route_output(&init_net, htonl(dst_ip), 0, 0, 0); 1525 if (IS_ERR(rt)) { 1526 printk(KERN_ERR "%s: ip_route_output_key failed for 0x%08X\n", 1527 __func__, dst_ip); 1528 return rc; 1529 } 1530 1531 if (netif_is_bond_slave(nesvnic->netdev)) 1532 netdev = netdev_master_upper_dev_get(nesvnic->netdev); 1533 else 1534 netdev = nesvnic->netdev; 1535 1536 neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, netdev); 1537 1538 rcu_read_lock(); 1539 if (neigh) { 1540 if (neigh->nud_state & NUD_VALID) { 1541 nes_debug(NES_DBG_CM, "Neighbor MAC address for 0x%08X" 1542 " is %pM, Gateway is 0x%08X \n", dst_ip, 1543 neigh->ha, ntohl(rt->rt_gateway)); 1544 1545 if (arpindex >= 0) { 1546 if (ether_addr_equal(nesadapter->arp_table[arpindex].mac_addr, neigh->ha)) { 1547 /* Mac address same as in nes_arp_table */ 1548 goto out; 1549 } 1550 1551 nes_manage_arp_cache(nesvnic->netdev, 1552 nesadapter->arp_table[arpindex].mac_addr, 1553 dst_ip, NES_ARP_DELETE); 1554 } 1555 1556 nes_manage_arp_cache(nesvnic->netdev, neigh->ha, 1557 dst_ip, NES_ARP_ADD); 1558 rc = nes_arp_table(nesvnic->nesdev, dst_ip, NULL, 1559 NES_ARP_RESOLVE); 1560 } else { 1561 neigh_event_send(neigh, NULL); 1562 } 1563 } 1564out: 1565 rcu_read_unlock(); 1566 1567 if (neigh) 1568 neigh_release(neigh); 1569 1570 ip_rt_put(rt); 1571 return rc; 1572} 1573 1574/** 1575 * make_cm_node - create a new instance of a cm node 1576 */ 1577static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core, 1578 struct nes_vnic *nesvnic, struct nes_cm_info *cm_info, 1579 struct nes_cm_listener *listener) 1580{ 1581 struct nes_cm_node *cm_node; 1582 struct timespec ts; 1583 int oldarpindex = 0; 1584 int arpindex = 0; 1585 struct nes_device *nesdev; 1586 struct nes_adapter *nesadapter; 1587 1588 /* create an hte and cm_node for this instance */ 1589 cm_node = kzalloc(sizeof(*cm_node), GFP_ATOMIC); 1590 if (!cm_node) 1591 return NULL; 1592 1593 /* set our node specific transport info */ 1594 if (listener) { 1595 cm_node->loc_addr = listener->loc_addr; 1596 cm_node->loc_port = listener->loc_port; 1597 } else { 1598 cm_node->loc_addr = cm_info->loc_addr; 1599 cm_node->loc_port = cm_info->loc_port; 1600 } 1601 cm_node->rem_addr = cm_info->rem_addr; 1602 cm_node->rem_port = cm_info->rem_port; 1603 1604 cm_node->mapped_loc_addr = cm_info->mapped_loc_addr; 1605 cm_node->mapped_rem_addr = cm_info->mapped_rem_addr; 1606 cm_node->mapped_loc_port = cm_info->mapped_loc_port; 1607 cm_node->mapped_rem_port = cm_info->mapped_rem_port; 1608 1609 cm_node->mpa_frame_rev = mpa_version; 1610 cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO; 1611 cm_node->mpav2_ird_ord = 0; 1612 cm_node->ird_size = 0; 1613 cm_node->ord_size = 0; 1614 1615 nes_debug(NES_DBG_CM, "Make node addresses : loc = %pI4:%x, rem = %pI4:%x\n", 1616 &cm_node->loc_addr, cm_node->loc_port, 1617 &cm_node->rem_addr, cm_node->rem_port); 1618 cm_node->listener = listener; 1619 cm_node->netdev = nesvnic->netdev; 1620 cm_node->cm_id = cm_info->cm_id; 1621 memcpy(cm_node->loc_mac, nesvnic->netdev->dev_addr, ETH_ALEN); 1622 1623 nes_debug(NES_DBG_CM, "listener=%p, cm_id=%p\n", cm_node->listener, 1624 cm_node->cm_id); 1625 1626 spin_lock_init(&cm_node->retrans_list_lock); 1627 1628 cm_node->loopbackpartner = NULL; 1629 atomic_set(&cm_node->ref_count, 1); 1630 /* associate our parent CM core */ 1631 cm_node->cm_core = cm_core; 1632 cm_node->tcp_cntxt.loc_id = NES_CM_DEF_LOCAL_ID; 1633 cm_node->tcp_cntxt.rcv_wscale = NES_CM_DEFAULT_RCV_WND_SCALE; 1634 cm_node->tcp_cntxt.rcv_wnd = NES_CM_DEFAULT_RCV_WND_SCALED >> 1635 NES_CM_DEFAULT_RCV_WND_SCALE; 1636 ts = current_kernel_time(); 1637 cm_node->tcp_cntxt.loc_seq_num = htonl(ts.tv_nsec); 1638 cm_node->tcp_cntxt.mss = nesvnic->max_frame_size - sizeof(struct iphdr) - 1639 sizeof(struct tcphdr) - ETH_HLEN - VLAN_HLEN; 1640 cm_node->tcp_cntxt.rcv_nxt = 0; 1641 /* get a unique session ID , add thread_id to an upcounter to handle race */ 1642 atomic_inc(&cm_core->node_cnt); 1643 cm_node->conn_type = cm_info->conn_type; 1644 cm_node->apbvt_set = 0; 1645 cm_node->accept_pend = 0; 1646 1647 cm_node->nesvnic = nesvnic; 1648 /* get some device handles, for arp lookup */ 1649 nesdev = nesvnic->nesdev; 1650 nesadapter = nesdev->nesadapter; 1651 1652 cm_node->loopbackpartner = NULL; 1653 1654 /* get the mac addr for the remote node */ 1655 oldarpindex = nes_arp_table(nesdev, cm_node->mapped_rem_addr, 1656 NULL, NES_ARP_RESOLVE); 1657 arpindex = nes_addr_resolve_neigh(nesvnic, 1658 cm_node->mapped_rem_addr, oldarpindex); 1659 if (arpindex < 0) { 1660 kfree(cm_node); 1661 return NULL; 1662 } 1663 1664 /* copy the mac addr to node context */ 1665 memcpy(cm_node->rem_mac, nesadapter->arp_table[arpindex].mac_addr, ETH_ALEN); 1666 nes_debug(NES_DBG_CM, "Remote mac addr from arp table: %pM\n", 1667 cm_node->rem_mac); 1668 1669 add_hte_node(cm_core, cm_node); 1670 atomic_inc(&cm_nodes_created); 1671 1672 return cm_node; 1673} 1674 1675 1676/** 1677 * add_ref_cm_node - destroy an instance of a cm node 1678 */ 1679static int add_ref_cm_node(struct nes_cm_node *cm_node) 1680{ 1681 atomic_inc(&cm_node->ref_count); 1682 return 0; 1683} 1684 1685 1686/** 1687 * rem_ref_cm_node - destroy an instance of a cm node 1688 */ 1689static int rem_ref_cm_node(struct nes_cm_core *cm_core, 1690 struct nes_cm_node *cm_node) 1691{ 1692 unsigned long flags; 1693 struct nes_qp *nesqp; 1694 1695 if (!cm_node) 1696 return -EINVAL; 1697 1698 spin_lock_irqsave(&cm_node->cm_core->ht_lock, flags); 1699 if (atomic_dec_return(&cm_node->ref_count)) { 1700 spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags); 1701 return 0; 1702 } 1703 list_del(&cm_node->list); 1704 atomic_dec(&cm_core->ht_node_cnt); 1705 spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags); 1706 1707 /* if the node is destroyed before connection was accelerated */ 1708 if (!cm_node->accelerated && cm_node->accept_pend) { 1709 BUG_ON(!cm_node->listener); 1710 atomic_dec(&cm_node->listener->pend_accepts_cnt); 1711 BUG_ON(atomic_read(&cm_node->listener->pend_accepts_cnt) < 0); 1712 } 1713 WARN_ON(cm_node->send_entry); 1714 if (cm_node->recv_entry) 1715 handle_recv_entry(cm_node, 0); 1716 if (cm_node->listener) { 1717 mini_cm_dec_refcnt_listen(cm_core, cm_node->listener, 0); 1718 } else { 1719 if (cm_node->apbvt_set && cm_node->nesvnic) { 1720 nes_manage_apbvt(cm_node->nesvnic, cm_node->mapped_loc_port, 1721 PCI_FUNC(cm_node->nesvnic->nesdev->pcidev->devfn), 1722 NES_MANAGE_APBVT_DEL); 1723 } 1724 nes_debug(NES_DBG_NLMSG, "Delete APBVT mapped_loc_port = %04X\n", 1725 cm_node->mapped_loc_port); 1726 nes_remove_mapinfo(cm_node->loc_addr, cm_node->loc_port, 1727 cm_node->mapped_loc_addr, cm_node->mapped_loc_port); 1728 } 1729 1730 atomic_dec(&cm_core->node_cnt); 1731 atomic_inc(&cm_nodes_destroyed); 1732 nesqp = cm_node->nesqp; 1733 if (nesqp) { 1734 nesqp->cm_node = NULL; 1735 nes_rem_ref(&nesqp->ibqp); 1736 cm_node->nesqp = NULL; 1737 } 1738 1739 kfree(cm_node); 1740 return 0; 1741} 1742 1743/** 1744 * process_options 1745 */ 1746static int process_options(struct nes_cm_node *cm_node, u8 *optionsloc, 1747 u32 optionsize, u32 syn_packet) 1748{ 1749 u32 tmp; 1750 u32 offset = 0; 1751 union all_known_options *all_options; 1752 char got_mss_option = 0; 1753 1754 while (offset < optionsize) { 1755 all_options = (union all_known_options *)(optionsloc + offset); 1756 switch (all_options->as_base.optionnum) { 1757 case OPTION_NUMBER_END: 1758 offset = optionsize; 1759 break; 1760 case OPTION_NUMBER_NONE: 1761 offset += 1; 1762 continue; 1763 case OPTION_NUMBER_MSS: 1764 nes_debug(NES_DBG_CM, "%s: MSS Length: %d Offset: %d " 1765 "Size: %d\n", __func__, 1766 all_options->as_mss.length, offset, optionsize); 1767 got_mss_option = 1; 1768 if (all_options->as_mss.length != 4) { 1769 return 1; 1770 } else { 1771 tmp = ntohs(all_options->as_mss.mss); 1772 if (tmp > 0 && tmp < 1773 cm_node->tcp_cntxt.mss) 1774 cm_node->tcp_cntxt.mss = tmp; 1775 } 1776 break; 1777 case OPTION_NUMBER_WINDOW_SCALE: 1778 cm_node->tcp_cntxt.snd_wscale = 1779 all_options->as_windowscale.shiftcount; 1780 break; 1781 default: 1782 nes_debug(NES_DBG_CM, "TCP Option not understood: %x\n", 1783 all_options->as_base.optionnum); 1784 break; 1785 } 1786 offset += all_options->as_base.length; 1787 } 1788 if ((!got_mss_option) && (syn_packet)) 1789 cm_node->tcp_cntxt.mss = NES_CM_DEFAULT_MSS; 1790 return 0; 1791} 1792 1793static void drop_packet(struct sk_buff *skb) 1794{ 1795 atomic_inc(&cm_accel_dropped_pkts); 1796 dev_kfree_skb_any(skb); 1797} 1798 1799static void handle_fin_pkt(struct nes_cm_node *cm_node) 1800{ 1801 nes_debug(NES_DBG_CM, "Received FIN, cm_node = %p, state = %u. " 1802 "refcnt=%d\n", cm_node, cm_node->state, 1803 atomic_read(&cm_node->ref_count)); 1804 switch (cm_node->state) { 1805 case NES_CM_STATE_SYN_RCVD: 1806 case NES_CM_STATE_SYN_SENT: 1807 case NES_CM_STATE_ESTABLISHED: 1808 case NES_CM_STATE_MPAREJ_RCVD: 1809 cm_node->tcp_cntxt.rcv_nxt++; 1810 cleanup_retrans_entry(cm_node); 1811 cm_node->state = NES_CM_STATE_LAST_ACK; 1812 send_fin(cm_node, NULL); 1813 break; 1814 case NES_CM_STATE_MPAREQ_SENT: 1815 create_event(cm_node, NES_CM_EVENT_ABORTED); 1816 cm_node->tcp_cntxt.rcv_nxt++; 1817 cleanup_retrans_entry(cm_node); 1818 cm_node->state = NES_CM_STATE_CLOSED; 1819 add_ref_cm_node(cm_node); 1820 send_reset(cm_node, NULL); 1821 break; 1822 case NES_CM_STATE_FIN_WAIT1: 1823 cm_node->tcp_cntxt.rcv_nxt++; 1824 cleanup_retrans_entry(cm_node); 1825 cm_node->state = NES_CM_STATE_CLOSING; 1826 send_ack(cm_node, NULL); 1827 /* Wait for ACK as this is simultaneous close.. 1828 * After we receive ACK, do not send anything.. 1829 * Just rm the node.. Done.. */ 1830 break; 1831 case NES_CM_STATE_FIN_WAIT2: 1832 cm_node->tcp_cntxt.rcv_nxt++; 1833 cleanup_retrans_entry(cm_node); 1834 cm_node->state = NES_CM_STATE_TIME_WAIT; 1835 send_ack(cm_node, NULL); 1836 schedule_nes_timer(cm_node, NULL, NES_TIMER_TYPE_CLOSE, 1, 0); 1837 break; 1838 case NES_CM_STATE_TIME_WAIT: 1839 cm_node->tcp_cntxt.rcv_nxt++; 1840 cleanup_retrans_entry(cm_node); 1841 cm_node->state = NES_CM_STATE_CLOSED; 1842 rem_ref_cm_node(cm_node->cm_core, cm_node); 1843 break; 1844 case NES_CM_STATE_TSA: 1845 default: 1846 nes_debug(NES_DBG_CM, "Error Rcvd FIN for node-%p state = %d\n", 1847 cm_node, cm_node->state); 1848 break; 1849 } 1850} 1851 1852 1853static void handle_rst_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb, 1854 struct tcphdr *tcph) 1855{ 1856 1857 int reset = 0; /* whether to send reset in case of err.. */ 1858 atomic_inc(&cm_resets_recvd); 1859 nes_debug(NES_DBG_CM, "Received Reset, cm_node = %p, state = %u." 1860 " refcnt=%d\n", cm_node, cm_node->state, 1861 atomic_read(&cm_node->ref_count)); 1862 cleanup_retrans_entry(cm_node); 1863 switch (cm_node->state) { 1864 case NES_CM_STATE_SYN_SENT: 1865 case NES_CM_STATE_MPAREQ_SENT: 1866 nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p " 1867 "listener=%p state=%d\n", __func__, __LINE__, cm_node, 1868 cm_node->listener, cm_node->state); 1869 switch (cm_node->mpa_frame_rev) { 1870 case IETF_MPA_V2: 1871 cm_node->mpa_frame_rev = IETF_MPA_V1; 1872 /* send a syn and goto syn sent state */ 1873 cm_node->state = NES_CM_STATE_SYN_SENT; 1874 if (send_syn(cm_node, 0, NULL)) { 1875 active_open_err(cm_node, skb, reset); 1876 } 1877 break; 1878 case IETF_MPA_V1: 1879 default: 1880 active_open_err(cm_node, skb, reset); 1881 break; 1882 } 1883 break; 1884 case NES_CM_STATE_MPAREQ_RCVD: 1885 atomic_inc(&cm_node->passive_state); 1886 dev_kfree_skb_any(skb); 1887 break; 1888 case NES_CM_STATE_ESTABLISHED: 1889 case NES_CM_STATE_SYN_RCVD: 1890 case NES_CM_STATE_LISTENING: 1891 nes_debug(NES_DBG_CM, "Bad state %s[%u]\n", __func__, __LINE__); 1892 passive_open_err(cm_node, skb, reset); 1893 break; 1894 case NES_CM_STATE_TSA: 1895 active_open_err(cm_node, skb, reset); 1896 break; 1897 case NES_CM_STATE_CLOSED: 1898 drop_packet(skb); 1899 break; 1900 case NES_CM_STATE_FIN_WAIT2: 1901 case NES_CM_STATE_FIN_WAIT1: 1902 case NES_CM_STATE_LAST_ACK: 1903 cm_node->cm_id->rem_ref(cm_node->cm_id); 1904 case NES_CM_STATE_TIME_WAIT: 1905 cm_node->state = NES_CM_STATE_CLOSED; 1906 rem_ref_cm_node(cm_node->cm_core, cm_node); 1907 drop_packet(skb); 1908 break; 1909 default: 1910 drop_packet(skb); 1911 break; 1912 } 1913} 1914 1915 1916static void handle_rcv_mpa(struct nes_cm_node *cm_node, struct sk_buff *skb) 1917{ 1918 int ret = 0; 1919 int datasize = skb->len; 1920 u8 *dataloc = skb->data; 1921 1922 enum nes_cm_event_type type = NES_CM_EVENT_UNKNOWN; 1923 u32 res_type; 1924 1925 ret = parse_mpa(cm_node, dataloc, &res_type, datasize); 1926 if (ret) { 1927 nes_debug(NES_DBG_CM, "didn't like MPA Request\n"); 1928 if (cm_node->state == NES_CM_STATE_MPAREQ_SENT) { 1929 nes_debug(NES_DBG_CM, "%s[%u] create abort for " 1930 "cm_node=%p listener=%p state=%d\n", __func__, 1931 __LINE__, cm_node, cm_node->listener, 1932 cm_node->state); 1933 active_open_err(cm_node, skb, 1); 1934 } else { 1935 passive_open_err(cm_node, skb, 1); 1936 } 1937 return; 1938 } 1939 1940 switch (cm_node->state) { 1941 case NES_CM_STATE_ESTABLISHED: 1942 if (res_type == NES_MPA_REQUEST_REJECT) 1943 /*BIG problem as we are receiving the MPA.. So should 1944 * not be REJECT.. This is Passive Open.. We can 1945 * only receive it Reject for Active Open...*/ 1946 WARN_ON(1); 1947 cm_node->state = NES_CM_STATE_MPAREQ_RCVD; 1948 type = NES_CM_EVENT_MPA_REQ; 1949 atomic_set(&cm_node->passive_state, 1950 NES_PASSIVE_STATE_INDICATED); 1951 break; 1952 case NES_CM_STATE_MPAREQ_SENT: 1953 cleanup_retrans_entry(cm_node); 1954 if (res_type == NES_MPA_REQUEST_REJECT) { 1955 type = NES_CM_EVENT_MPA_REJECT; 1956 cm_node->state = NES_CM_STATE_MPAREJ_RCVD; 1957 } else { 1958 type = NES_CM_EVENT_CONNECTED; 1959 cm_node->state = NES_CM_STATE_TSA; 1960 } 1961 1962 break; 1963 default: 1964 WARN_ON(1); 1965 break; 1966 } 1967 dev_kfree_skb_any(skb); 1968 create_event(cm_node, type); 1969} 1970 1971static void indicate_pkt_err(struct nes_cm_node *cm_node, struct sk_buff *skb) 1972{ 1973 switch (cm_node->state) { 1974 case NES_CM_STATE_SYN_SENT: 1975 case NES_CM_STATE_MPAREQ_SENT: 1976 nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p " 1977 "listener=%p state=%d\n", __func__, __LINE__, cm_node, 1978 cm_node->listener, cm_node->state); 1979 active_open_err(cm_node, skb, 1); 1980 break; 1981 case NES_CM_STATE_ESTABLISHED: 1982 case NES_CM_STATE_SYN_RCVD: 1983 passive_open_err(cm_node, skb, 1); 1984 break; 1985 case NES_CM_STATE_TSA: 1986 default: 1987 drop_packet(skb); 1988 } 1989} 1990 1991static int check_syn(struct nes_cm_node *cm_node, struct tcphdr *tcph, 1992 struct sk_buff *skb) 1993{ 1994 int err; 1995 1996 err = ((ntohl(tcph->ack_seq) == cm_node->tcp_cntxt.loc_seq_num)) ? 0 : 1; 1997 if (err) 1998 active_open_err(cm_node, skb, 1); 1999 2000 return err; 2001} 2002 2003static int check_seq(struct nes_cm_node *cm_node, struct tcphdr *tcph, 2004 struct sk_buff *skb) 2005{ 2006 int err = 0; 2007 u32 seq; 2008 u32 ack_seq; 2009 u32 loc_seq_num = cm_node->tcp_cntxt.loc_seq_num; 2010 u32 rcv_nxt = cm_node->tcp_cntxt.rcv_nxt; 2011 u32 rcv_wnd; 2012 2013 seq = ntohl(tcph->seq); 2014 ack_seq = ntohl(tcph->ack_seq); 2015 rcv_wnd = cm_node->tcp_cntxt.rcv_wnd; 2016 if (ack_seq != loc_seq_num) 2017 err = 1; 2018 else if (!between(seq, rcv_nxt, (rcv_nxt + rcv_wnd))) 2019 err = 1; 2020 if (err) { 2021 nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p " 2022 "listener=%p state=%d\n", __func__, __LINE__, cm_node, 2023 cm_node->listener, cm_node->state); 2024 indicate_pkt_err(cm_node, skb); 2025 nes_debug(NES_DBG_CM, "seq ERROR cm_node =%p seq=0x%08X " 2026 "rcv_nxt=0x%08X rcv_wnd=0x%x\n", cm_node, seq, rcv_nxt, 2027 rcv_wnd); 2028 } 2029 return err; 2030} 2031 2032/* 2033 * handle_syn_pkt() is for Passive node. The syn packet is received when a node 2034 * is created with a listener or it may comein as rexmitted packet which in 2035 * that case will be just dropped. 2036 */ 2037static void handle_syn_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb, 2038 struct tcphdr *tcph) 2039{ 2040 int ret; 2041 u32 inc_sequence; 2042 int optionsize; 2043 2044 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr); 2045 skb_trim(skb, 0); 2046 inc_sequence = ntohl(tcph->seq); 2047 2048 switch (cm_node->state) { 2049 case NES_CM_STATE_SYN_SENT: 2050 case NES_CM_STATE_MPAREQ_SENT: 2051 /* Rcvd syn on active open connection*/ 2052 active_open_err(cm_node, skb, 1); 2053 break; 2054 case NES_CM_STATE_LISTENING: 2055 /* Passive OPEN */ 2056 if (atomic_read(&cm_node->listener->pend_accepts_cnt) > 2057 cm_node->listener->backlog) { 2058 nes_debug(NES_DBG_CM, "drop syn due to backlog " 2059 "pressure \n"); 2060 cm_backlog_drops++; 2061 passive_open_err(cm_node, skb, 0); 2062 break; 2063 } 2064 ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 2065 1); 2066 if (ret) { 2067 passive_open_err(cm_node, skb, 0); 2068 /* drop pkt */ 2069 break; 2070 } 2071 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1; 2072 BUG_ON(cm_node->send_entry); 2073 cm_node->accept_pend = 1; 2074 atomic_inc(&cm_node->listener->pend_accepts_cnt); 2075 2076 cm_node->state = NES_CM_STATE_SYN_RCVD; 2077 send_syn(cm_node, 1, skb); 2078 break; 2079 case NES_CM_STATE_CLOSED: 2080 cleanup_retrans_entry(cm_node); 2081 add_ref_cm_node(cm_node); 2082 send_reset(cm_node, skb); 2083 break; 2084 case NES_CM_STATE_TSA: 2085 case NES_CM_STATE_ESTABLISHED: 2086 case NES_CM_STATE_FIN_WAIT1: 2087 case NES_CM_STATE_FIN_WAIT2: 2088 case NES_CM_STATE_MPAREQ_RCVD: 2089 case NES_CM_STATE_LAST_ACK: 2090 case NES_CM_STATE_CLOSING: 2091 case NES_CM_STATE_UNKNOWN: 2092 default: 2093 drop_packet(skb); 2094 break; 2095 } 2096} 2097 2098static void handle_synack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb, 2099 struct tcphdr *tcph) 2100{ 2101 int ret; 2102 u32 inc_sequence; 2103 int optionsize; 2104 2105 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr); 2106 skb_trim(skb, 0); 2107 inc_sequence = ntohl(tcph->seq); 2108 switch (cm_node->state) { 2109 case NES_CM_STATE_SYN_SENT: 2110 cleanup_retrans_entry(cm_node); 2111 /* active open */ 2112 if (check_syn(cm_node, tcph, skb)) 2113 return; 2114 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq); 2115 /* setup options */ 2116 ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 0); 2117 if (ret) { 2118 nes_debug(NES_DBG_CM, "cm_node=%p tcp_options failed\n", 2119 cm_node); 2120 break; 2121 } 2122 cleanup_retrans_entry(cm_node); 2123 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1; 2124 send_mpa_request(cm_node, skb); 2125 cm_node->state = NES_CM_STATE_MPAREQ_SENT; 2126 break; 2127 case NES_CM_STATE_MPAREQ_RCVD: 2128 /* passive open, so should not be here */ 2129 passive_open_err(cm_node, skb, 1); 2130 break; 2131 case NES_CM_STATE_LISTENING: 2132 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq); 2133 cleanup_retrans_entry(cm_node); 2134 cm_node->state = NES_CM_STATE_CLOSED; 2135 send_reset(cm_node, skb); 2136 break; 2137 case NES_CM_STATE_CLOSED: 2138 cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq); 2139 cleanup_retrans_entry(cm_node); 2140 add_ref_cm_node(cm_node); 2141 send_reset(cm_node, skb); 2142 break; 2143 case NES_CM_STATE_ESTABLISHED: 2144 case NES_CM_STATE_FIN_WAIT1: 2145 case NES_CM_STATE_FIN_WAIT2: 2146 case NES_CM_STATE_LAST_ACK: 2147 case NES_CM_STATE_TSA: 2148 case NES_CM_STATE_CLOSING: 2149 case NES_CM_STATE_UNKNOWN: 2150 case NES_CM_STATE_MPAREQ_SENT: 2151 default: 2152 drop_packet(skb); 2153 break; 2154 } 2155} 2156 2157static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb, 2158 struct tcphdr *tcph) 2159{ 2160 int datasize = 0; 2161 u32 inc_sequence; 2162 int ret = 0; 2163 int optionsize; 2164 2165 optionsize = (tcph->doff << 2) - sizeof(struct tcphdr); 2166 2167 if (check_seq(cm_node, tcph, skb)) 2168 return -EINVAL; 2169 2170 skb_pull(skb, tcph->doff << 2); 2171 inc_sequence = ntohl(tcph->seq); 2172 datasize = skb->len; 2173 switch (cm_node->state) { 2174 case NES_CM_STATE_SYN_RCVD: 2175 /* Passive OPEN */ 2176 cleanup_retrans_entry(cm_node); 2177 ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 1); 2178 if (ret) 2179 break; 2180 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq); 2181 cm_node->state = NES_CM_STATE_ESTABLISHED; 2182 if (datasize) { 2183 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize; 2184 nes_get_remote_addr(cm_node); 2185 handle_rcv_mpa(cm_node, skb); 2186 } else { /* rcvd ACK only */ 2187 dev_kfree_skb_any(skb); 2188 } 2189 break; 2190 case NES_CM_STATE_ESTABLISHED: 2191 /* Passive OPEN */ 2192 cleanup_retrans_entry(cm_node); 2193 if (datasize) { 2194 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize; 2195 handle_rcv_mpa(cm_node, skb); 2196 } else { 2197 drop_packet(skb); 2198 } 2199 break; 2200 case NES_CM_STATE_MPAREQ_SENT: 2201 cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq); 2202 if (datasize) { 2203 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize; 2204 handle_rcv_mpa(cm_node, skb); 2205 } else { /* Could be just an ack pkt.. */ 2206 dev_kfree_skb_any(skb); 2207 } 2208 break; 2209 case NES_CM_STATE_LISTENING: 2210 cleanup_retrans_entry(cm_node); 2211 cm_node->state = NES_CM_STATE_CLOSED; 2212 send_reset(cm_node, skb); 2213 break; 2214 case NES_CM_STATE_CLOSED: 2215 cleanup_retrans_entry(cm_node); 2216 add_ref_cm_node(cm_node); 2217 send_reset(cm_node, skb); 2218 break; 2219 case NES_CM_STATE_LAST_ACK: 2220 case NES_CM_STATE_CLOSING: 2221 cleanup_retrans_entry(cm_node); 2222 cm_node->state = NES_CM_STATE_CLOSED; 2223 cm_node->cm_id->rem_ref(cm_node->cm_id); 2224 rem_ref_cm_node(cm_node->cm_core, cm_node); 2225 drop_packet(skb); 2226 break; 2227 case NES_CM_STATE_FIN_WAIT1: 2228 cleanup_retrans_entry(cm_node); 2229 drop_packet(skb); 2230 cm_node->state = NES_CM_STATE_FIN_WAIT2; 2231 break; 2232 case NES_CM_STATE_SYN_SENT: 2233 case NES_CM_STATE_FIN_WAIT2: 2234 case NES_CM_STATE_TSA: 2235 case NES_CM_STATE_MPAREQ_RCVD: 2236 case NES_CM_STATE_UNKNOWN: 2237 default: 2238 cleanup_retrans_entry(cm_node); 2239 drop_packet(skb); 2240 break; 2241 } 2242 return ret; 2243} 2244 2245 2246 2247static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph, 2248 struct sk_buff *skb, int optionsize, int passive) 2249{ 2250 u8 *optionsloc = (u8 *)&tcph[1]; 2251 2252 if (optionsize) { 2253 if (process_options(cm_node, optionsloc, optionsize, 2254 (u32)tcph->syn)) { 2255 nes_debug(NES_DBG_CM, "%s: Node %p, Sending RESET\n", 2256 __func__, cm_node); 2257 if (passive) 2258 passive_open_err(cm_node, skb, 1); 2259 else 2260 active_open_err(cm_node, skb, 1); 2261 return 1; 2262 } 2263 } 2264 2265 cm_node->tcp_cntxt.snd_wnd = ntohs(tcph->window) << 2266 cm_node->tcp_cntxt.snd_wscale; 2267 2268 if (cm_node->tcp_cntxt.snd_wnd > cm_node->tcp_cntxt.max_snd_wnd) 2269 cm_node->tcp_cntxt.max_snd_wnd = cm_node->tcp_cntxt.snd_wnd; 2270 return 0; 2271} 2272 2273/* 2274 * active_open_err() will send reset() if flag set.. 2275 * It will also send ABORT event. 2276 */ 2277static void active_open_err(struct nes_cm_node *cm_node, struct sk_buff *skb, 2278 int reset) 2279{ 2280 cleanup_retrans_entry(cm_node); 2281 if (reset) { 2282 nes_debug(NES_DBG_CM, "ERROR active err called for cm_node=%p, " 2283 "state=%d\n", cm_node, cm_node->state); 2284 add_ref_cm_node(cm_node); 2285 send_reset(cm_node, skb); 2286 } else { 2287 dev_kfree_skb_any(skb); 2288 } 2289 2290 cm_node->state = NES_CM_STATE_CLOSED; 2291 create_event(cm_node, NES_CM_EVENT_ABORTED); 2292} 2293 2294/* 2295 * passive_open_err() will either do a reset() or will free up the skb and 2296 * remove the cm_node. 2297 */ 2298static void passive_open_err(struct nes_cm_node *cm_node, struct sk_buff *skb, 2299 int reset) 2300{ 2301 cleanup_retrans_entry(cm_node); 2302 cm_node->state = NES_CM_STATE_CLOSED; 2303 if (reset) { 2304 nes_debug(NES_DBG_CM, "passive_open_err sending RST for " 2305 "cm_node=%p state =%d\n", cm_node, cm_node->state); 2306 send_reset(cm_node, skb); 2307 } else { 2308 dev_kfree_skb_any(skb); 2309 rem_ref_cm_node(cm_node->cm_core, cm_node); 2310 } 2311} 2312 2313/* 2314 * free_retrans_entry() routines assumes that the retrans_list_lock has 2315 * been acquired before calling. 2316 */ 2317static void free_retrans_entry(struct nes_cm_node *cm_node) 2318{ 2319 struct nes_timer_entry *send_entry; 2320 2321 send_entry = cm_node->send_entry; 2322 if (send_entry) { 2323 cm_node->send_entry = NULL; 2324 dev_kfree_skb_any(send_entry->skb); 2325 kfree(send_entry); 2326 rem_ref_cm_node(cm_node->cm_core, cm_node); 2327 } 2328} 2329 2330static void cleanup_retrans_entry(struct nes_cm_node *cm_node) 2331{ 2332 unsigned long flags; 2333 2334 spin_lock_irqsave(&cm_node->retrans_list_lock, flags); 2335 free_retrans_entry(cm_node); 2336 spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags); 2337} 2338 2339/** 2340 * process_packet 2341 * Returns skb if to be freed, else it will return NULL if already used.. 2342 */ 2343static void process_packet(struct nes_cm_node *cm_node, struct sk_buff *skb, 2344 struct nes_cm_core *cm_core) 2345{ 2346 enum nes_tcpip_pkt_type pkt_type = NES_PKT_TYPE_UNKNOWN; 2347 struct tcphdr *tcph = tcp_hdr(skb); 2348 u32 fin_set = 0; 2349 int ret = 0; 2350 2351 skb_pull(skb, ip_hdr(skb)->ihl << 2); 2352 2353 nes_debug(NES_DBG_CM, "process_packet: cm_node=%p state =%d syn=%d " 2354 "ack=%d rst=%d fin=%d\n", cm_node, cm_node->state, tcph->syn, 2355 tcph->ack, tcph->rst, tcph->fin); 2356 2357 if (tcph->rst) { 2358 pkt_type = NES_PKT_TYPE_RST; 2359 } else if (tcph->syn) { 2360 pkt_type = NES_PKT_TYPE_SYN; 2361 if (tcph->ack) 2362 pkt_type = NES_PKT_TYPE_SYNACK; 2363 } else if (tcph->ack) { 2364 pkt_type = NES_PKT_TYPE_ACK; 2365 } 2366 if (tcph->fin) 2367 fin_set = 1; 2368 2369 switch (pkt_type) { 2370 case NES_PKT_TYPE_SYN: 2371 handle_syn_pkt(cm_node, skb, tcph); 2372 break; 2373 case NES_PKT_TYPE_SYNACK: 2374 handle_synack_pkt(cm_node, skb, tcph); 2375 break; 2376 case NES_PKT_TYPE_ACK: 2377 ret = handle_ack_pkt(cm_node, skb, tcph); 2378 if (fin_set && !ret) 2379 handle_fin_pkt(cm_node); 2380 break; 2381 case NES_PKT_TYPE_RST: 2382 handle_rst_pkt(cm_node, skb, tcph); 2383 break; 2384 default: 2385 if ((fin_set) && (!check_seq(cm_node, tcph, skb))) 2386 handle_fin_pkt(cm_node); 2387 drop_packet(skb); 2388 break; 2389 } 2390} 2391 2392/** 2393 * mini_cm_listen - create a listen node with params 2394 */ 2395static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *cm_core, 2396 struct nes_vnic *nesvnic, struct nes_cm_info *cm_info) 2397{ 2398 struct nes_cm_listener *listener; 2399 struct iwpm_dev_data pm_reg_msg; 2400 struct iwpm_sa_data pm_msg; 2401 unsigned long flags; 2402 int iwpm_err = 0; 2403 2404 nes_debug(NES_DBG_CM, "Search for 0x%08x : 0x%04x\n", 2405 cm_info->loc_addr, cm_info->loc_port); 2406 2407 /* cannot have multiple matching listeners */ 2408 listener = find_listener(cm_core, cm_info->loc_addr, cm_info->loc_port, 2409 NES_CM_LISTENER_EITHER_STATE, 1); 2410 2411 if (listener && listener->listener_state == NES_CM_LISTENER_ACTIVE_STATE) { 2412 /* find automatically incs ref count ??? */ 2413 atomic_dec(&listener->ref_count); 2414 nes_debug(NES_DBG_CM, "Not creating listener since it already exists\n"); 2415 return NULL; 2416 } 2417 2418 if (!listener) { 2419 nes_form_reg_msg(nesvnic, &pm_reg_msg); 2420 iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_NES); 2421 if (iwpm_err) { 2422 nes_debug(NES_DBG_NLMSG, 2423 "Port Mapper reg pid fail (err = %d).\n", iwpm_err); 2424 } 2425 if (iwpm_valid_pid() && !iwpm_err) { 2426 nes_form_pm_msg(cm_info, &pm_msg); 2427 iwpm_err = iwpm_add_mapping(&pm_msg, RDMA_NL_NES); 2428 if (iwpm_err) 2429 nes_debug(NES_DBG_NLMSG, 2430 "Port Mapper query fail (err = %d).\n", iwpm_err); 2431 else 2432 nes_record_pm_msg(cm_info, &pm_msg); 2433 } 2434 2435 /* create a CM listen node (1/2 node to compare incoming traffic to) */ 2436 listener = kzalloc(sizeof(*listener), GFP_ATOMIC); 2437 if (!listener) { 2438 nes_debug(NES_DBG_CM, "Not creating listener memory allocation failed\n"); 2439 return NULL; 2440 } 2441 2442 listener->loc_addr = cm_info->loc_addr; 2443 listener->loc_port = cm_info->loc_port; 2444 listener->mapped_loc_addr = cm_info->mapped_loc_addr; 2445 listener->mapped_loc_port = cm_info->mapped_loc_port; 2446 listener->reused_node = 0; 2447 2448 atomic_set(&listener->ref_count, 1); 2449 } 2450 /* pasive case */ 2451 /* find already inc'ed the ref count */ 2452 else { 2453 listener->reused_node = 1; 2454 } 2455 2456 listener->cm_id = cm_info->cm_id; 2457 atomic_set(&listener->pend_accepts_cnt, 0); 2458 listener->cm_core = cm_core; 2459 listener->nesvnic = nesvnic; 2460 atomic_inc(&cm_core->node_cnt); 2461 2462 listener->conn_type = cm_info->conn_type; 2463 listener->backlog = cm_info->backlog; 2464 listener->listener_state = NES_CM_LISTENER_ACTIVE_STATE; 2465 2466 if (!listener->reused_node) { 2467 spin_lock_irqsave(&cm_core->listen_list_lock, flags); 2468 list_add(&listener->list, &cm_core->listen_list.list); 2469 spin_unlock_irqrestore(&cm_core->listen_list_lock, flags); 2470 atomic_inc(&cm_core->listen_node_cnt); 2471 } 2472 2473 nes_debug(NES_DBG_CM, "Api - listen(): addr=0x%08X, port=0x%04x," 2474 " listener = %p, backlog = %d, cm_id = %p.\n", 2475 cm_info->loc_addr, cm_info->loc_port, 2476 listener, listener->backlog, listener->cm_id); 2477 2478 return listener; 2479} 2480 2481 2482/** 2483 * mini_cm_connect - make a connection node with params 2484 */ 2485static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *cm_core, 2486 struct nes_vnic *nesvnic, u16 private_data_len, 2487 void *private_data, struct nes_cm_info *cm_info) 2488{ 2489 int ret = 0; 2490 struct nes_cm_node *cm_node; 2491 struct nes_cm_listener *loopbackremotelistener; 2492 struct nes_cm_node *loopbackremotenode; 2493 struct nes_cm_info loopback_cm_info; 2494 u8 *start_buff; 2495 2496 /* create a CM connection node */ 2497 cm_node = make_cm_node(cm_core, nesvnic, cm_info, NULL); 2498 if (!cm_node) 2499 return NULL; 2500 2501 /* set our node side to client (active) side */ 2502 cm_node->tcp_cntxt.client = 1; 2503 cm_node->tcp_cntxt.rcv_wscale = NES_CM_DEFAULT_RCV_WND_SCALE; 2504 2505 if (cm_info->loc_addr == cm_info->rem_addr) { 2506 loopbackremotelistener = find_listener(cm_core, 2507 cm_node->mapped_loc_addr, cm_node->mapped_rem_port, 2508 NES_CM_LISTENER_ACTIVE_STATE, 0); 2509 if (loopbackremotelistener == NULL) { 2510 create_event(cm_node, NES_CM_EVENT_ABORTED); 2511 } else { 2512 loopback_cm_info = *cm_info; 2513 loopback_cm_info.loc_port = cm_info->rem_port; 2514 loopback_cm_info.rem_port = cm_info->loc_port; 2515 loopback_cm_info.mapped_loc_port = 2516 cm_info->mapped_rem_port; 2517 loopback_cm_info.mapped_rem_port = 2518 cm_info->mapped_loc_port; 2519 loopback_cm_info.cm_id = loopbackremotelistener->cm_id; 2520 loopbackremotenode = make_cm_node(cm_core, nesvnic, 2521 &loopback_cm_info, loopbackremotelistener); 2522 if (!loopbackremotenode) { 2523 rem_ref_cm_node(cm_node->cm_core, cm_node); 2524 return NULL; 2525 } 2526 atomic_inc(&cm_loopbacks); 2527 loopbackremotenode->loopbackpartner = cm_node; 2528 loopbackremotenode->tcp_cntxt.rcv_wscale = 2529 NES_CM_DEFAULT_RCV_WND_SCALE; 2530 cm_node->loopbackpartner = loopbackremotenode; 2531 memcpy(loopbackremotenode->mpa_frame_buf, private_data, 2532 private_data_len); 2533 loopbackremotenode->mpa_frame_size = private_data_len; 2534 2535 /* we are done handling this state. */ 2536 /* set node to a TSA state */ 2537 cm_node->state = NES_CM_STATE_TSA; 2538 cm_node->tcp_cntxt.rcv_nxt = 2539 loopbackremotenode->tcp_cntxt.loc_seq_num; 2540 loopbackremotenode->tcp_cntxt.rcv_nxt = 2541 cm_node->tcp_cntxt.loc_seq_num; 2542 cm_node->tcp_cntxt.max_snd_wnd = 2543 loopbackremotenode->tcp_cntxt.rcv_wnd; 2544 loopbackremotenode->tcp_cntxt.max_snd_wnd = 2545 cm_node->tcp_cntxt.rcv_wnd; 2546 cm_node->tcp_cntxt.snd_wnd = 2547 loopbackremotenode->tcp_cntxt.rcv_wnd; 2548 loopbackremotenode->tcp_cntxt.snd_wnd = 2549 cm_node->tcp_cntxt.rcv_wnd; 2550 cm_node->tcp_cntxt.snd_wscale = 2551 loopbackremotenode->tcp_cntxt.rcv_wscale; 2552 loopbackremotenode->tcp_cntxt.snd_wscale = 2553 cm_node->tcp_cntxt.rcv_wscale; 2554 loopbackremotenode->state = NES_CM_STATE_MPAREQ_RCVD; 2555 create_event(loopbackremotenode, NES_CM_EVENT_MPA_REQ); 2556 } 2557 return cm_node; 2558 } 2559 2560 start_buff = &cm_node->mpa_frame_buf[0] + sizeof(struct ietf_mpa_v2); 2561 cm_node->mpa_frame_size = private_data_len; 2562 2563 memcpy(start_buff, private_data, private_data_len); 2564 2565 /* send a syn and goto syn sent state */ 2566 cm_node->state = NES_CM_STATE_SYN_SENT; 2567 ret = send_syn(cm_node, 0, NULL); 2568 2569 if (ret) { 2570 /* error in sending the syn free up the cm_node struct */ 2571 nes_debug(NES_DBG_CM, "Api - connect() FAILED: dest " 2572 "addr=0x%08X, port=0x%04x, cm_node=%p, cm_id = %p.\n", 2573 cm_node->rem_addr, cm_node->rem_port, cm_node, 2574 cm_node->cm_id); 2575 rem_ref_cm_node(cm_node->cm_core, cm_node); 2576 cm_node = NULL; 2577 } 2578 2579 if (cm_node) { 2580 nes_debug(NES_DBG_CM, "Api - connect(): dest addr=0x%08X," 2581 "port=0x%04x, cm_node=%p, cm_id = %p.\n", 2582 cm_node->rem_addr, cm_node->rem_port, cm_node, 2583 cm_node->cm_id); 2584 } 2585 2586 return cm_node; 2587} 2588 2589 2590/** 2591 * mini_cm_accept - accept a connection 2592 * This function is never called 2593 */ 2594static int mini_cm_accept(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node) 2595{ 2596 return 0; 2597} 2598 2599 2600/** 2601 * mini_cm_reject - reject and teardown a connection 2602 */ 2603static int mini_cm_reject(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node) 2604{ 2605 int ret = 0; 2606 int err = 0; 2607 int passive_state; 2608 struct nes_cm_event event; 2609 struct iw_cm_id *cm_id = cm_node->cm_id; 2610 struct nes_cm_node *loopback = cm_node->loopbackpartner; 2611 2612 nes_debug(NES_DBG_CM, "%s cm_node=%p type=%d state=%d\n", 2613 __func__, cm_node, cm_node->tcp_cntxt.client, cm_node->state); 2614 2615 if (cm_node->tcp_cntxt.client) 2616 return ret; 2617 cleanup_retrans_entry(cm_node); 2618 2619 if (!loopback) { 2620 passive_state = atomic_add_return(1, &cm_node->passive_state); 2621 if (passive_state == NES_SEND_RESET_EVENT) { 2622 cm_node->state = NES_CM_STATE_CLOSED; 2623 rem_ref_cm_node(cm_core, cm_node); 2624 } else { 2625 if (cm_node->state == NES_CM_STATE_LISTENER_DESTROYED) { 2626 rem_ref_cm_node(cm_core, cm_node); 2627 } else { 2628 ret = send_mpa_reject(cm_node); 2629 if (ret) { 2630 cm_node->state = NES_CM_STATE_CLOSED; 2631 err = send_reset(cm_node, NULL); 2632 if (err) 2633 WARN_ON(1); 2634 } else { 2635 cm_id->add_ref(cm_id); 2636 } 2637 } 2638 } 2639 } else { 2640 cm_node->cm_id = NULL; 2641 if (cm_node->state == NES_CM_STATE_LISTENER_DESTROYED) { 2642 rem_ref_cm_node(cm_core, cm_node); 2643 rem_ref_cm_node(cm_core, loopback); 2644 } else { 2645 event.cm_node = loopback; 2646 event.cm_info.rem_addr = loopback->rem_addr; 2647 event.cm_info.loc_addr = loopback->loc_addr; 2648 event.cm_info.rem_port = loopback->rem_port; 2649 event.cm_info.loc_port = loopback->loc_port; 2650 event.cm_info.cm_id = loopback->cm_id; 2651 cm_event_mpa_reject(&event); 2652 rem_ref_cm_node(cm_core, cm_node); 2653 loopback->state = NES_CM_STATE_CLOSING; 2654 2655 cm_id = loopback->cm_id; 2656 rem_ref_cm_node(cm_core, loopback); 2657 cm_id->rem_ref(cm_id); 2658 } 2659 } 2660 2661 return ret; 2662} 2663 2664 2665/** 2666 * mini_cm_close 2667 */ 2668static int mini_cm_close(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node) 2669{ 2670 int ret = 0; 2671 2672 if (!cm_core || !cm_node) 2673 return -EINVAL; 2674 2675 switch (cm_node->state) { 2676 case NES_CM_STATE_SYN_RCVD: 2677 case NES_CM_STATE_SYN_SENT: 2678 case NES_CM_STATE_ONE_SIDE_ESTABLISHED: 2679 case NES_CM_STATE_ESTABLISHED: 2680 case NES_CM_STATE_ACCEPTING: 2681 case NES_CM_STATE_MPAREQ_SENT: 2682 case NES_CM_STATE_MPAREQ_RCVD: 2683 cleanup_retrans_entry(cm_node); 2684 send_reset(cm_node, NULL); 2685 break; 2686 case NES_CM_STATE_CLOSE_WAIT: 2687 cm_node->state = NES_CM_STATE_LAST_ACK; 2688 send_fin(cm_node, NULL); 2689 break; 2690 case NES_CM_STATE_FIN_WAIT1: 2691 case NES_CM_STATE_FIN_WAIT2: 2692 case NES_CM_STATE_LAST_ACK: 2693 case NES_CM_STATE_TIME_WAIT: 2694 case NES_CM_STATE_CLOSING: 2695 ret = -1; 2696 break; 2697 case NES_CM_STATE_LISTENING: 2698 cleanup_retrans_entry(cm_node); 2699 send_reset(cm_node, NULL); 2700 break; 2701 case NES_CM_STATE_MPAREJ_RCVD: 2702 case NES_CM_STATE_UNKNOWN: 2703 case NES_CM_STATE_INITED: 2704 case NES_CM_STATE_CLOSED: 2705 case NES_CM_STATE_LISTENER_DESTROYED: 2706 ret = rem_ref_cm_node(cm_core, cm_node); 2707 break; 2708 case NES_CM_STATE_TSA: 2709 if (cm_node->send_entry) 2710 printk(KERN_ERR "ERROR Close got called from STATE_TSA " 2711 "send_entry=%p\n", cm_node->send_entry); 2712 ret = rem_ref_cm_node(cm_core, cm_node); 2713 break; 2714 } 2715 return ret; 2716} 2717 2718 2719/** 2720 * recv_pkt - recv an ETHERNET packet, and process it through CM 2721 * node state machine 2722 */ 2723static int mini_cm_recv_pkt(struct nes_cm_core *cm_core, 2724 struct nes_vnic *nesvnic, struct sk_buff *skb) 2725{ 2726 struct nes_cm_node *cm_node = NULL; 2727 struct nes_cm_listener *listener = NULL; 2728 struct iphdr *iph; 2729 struct tcphdr *tcph; 2730 struct nes_cm_info nfo; 2731 int skb_handled = 1; 2732 __be32 tmp_daddr, tmp_saddr; 2733 2734 if (!skb) 2735 return 0; 2736 if (skb->len < sizeof(struct iphdr) + sizeof(struct tcphdr)) 2737 return 0; 2738 2739 iph = (struct iphdr *)skb->data; 2740 tcph = (struct tcphdr *)(skb->data + sizeof(struct iphdr)); 2741 2742 nfo.loc_addr = ntohl(iph->daddr); 2743 nfo.loc_port = ntohs(tcph->dest); 2744 nfo.rem_addr = ntohl(iph->saddr); 2745 nfo.rem_port = ntohs(tcph->source); 2746 2747 /* If port mapper is available these should be mapped address info */ 2748 nfo.mapped_loc_addr = ntohl(iph->daddr); 2749 nfo.mapped_loc_port = ntohs(tcph->dest); 2750 nfo.mapped_rem_addr = ntohl(iph->saddr); 2751 nfo.mapped_rem_port = ntohs(tcph->source); 2752 2753 tmp_daddr = cpu_to_be32(iph->daddr); 2754 tmp_saddr = cpu_to_be32(iph->saddr); 2755 2756 nes_debug(NES_DBG_CM, "Received packet: dest=%pI4:0x%04X src=%pI4:0x%04X\n", 2757 &tmp_daddr, tcph->dest, &tmp_saddr, tcph->source); 2758 2759 do { 2760 cm_node = find_node(cm_core, 2761 nfo.mapped_rem_port, nfo.mapped_rem_addr, 2762 nfo.mapped_loc_port, nfo.mapped_loc_addr); 2763 2764 if (!cm_node) { 2765 /* Only type of packet accepted are for */ 2766 /* the PASSIVE open (syn only) */ 2767 if ((!tcph->syn) || (tcph->ack)) { 2768 skb_handled = 0; 2769 break; 2770 } 2771 listener = find_listener(cm_core, nfo.mapped_loc_addr, 2772 nfo.mapped_loc_port, 2773 NES_CM_LISTENER_ACTIVE_STATE, 0); 2774 if (!listener) { 2775 nfo.cm_id = NULL; 2776 nfo.conn_type = 0; 2777 nes_debug(NES_DBG_CM, "Unable to find listener for the pkt\n"); 2778 skb_handled = 0; 2779 break; 2780 } 2781 nfo.cm_id = listener->cm_id; 2782 nfo.conn_type = listener->conn_type; 2783 cm_node = make_cm_node(cm_core, nesvnic, &nfo, 2784 listener); 2785 if (!cm_node) { 2786 nes_debug(NES_DBG_CM, "Unable to allocate " 2787 "node\n"); 2788 cm_packets_dropped++; 2789 atomic_dec(&listener->ref_count); 2790 dev_kfree_skb_any(skb); 2791 break; 2792 } 2793 if (!tcph->rst && !tcph->fin) { 2794 cm_node->state = NES_CM_STATE_LISTENING; 2795 } else { 2796 cm_packets_dropped++; 2797 rem_ref_cm_node(cm_core, cm_node); 2798 dev_kfree_skb_any(skb); 2799 break; 2800 } 2801 add_ref_cm_node(cm_node); 2802 } else if (cm_node->state == NES_CM_STATE_TSA) { 2803 if (cm_node->nesqp->pau_mode) 2804 nes_queue_mgt_skbs(skb, nesvnic, cm_node->nesqp); 2805 else { 2806 rem_ref_cm_node(cm_core, cm_node); 2807 atomic_inc(&cm_accel_dropped_pkts); 2808 dev_kfree_skb_any(skb); 2809 } 2810 break; 2811 } 2812 skb_reset_network_header(skb); 2813 skb_set_transport_header(skb, sizeof(*tcph)); 2814 skb->len = ntohs(iph->tot_len); 2815 process_packet(cm_node, skb, cm_core); 2816 rem_ref_cm_node(cm_core, cm_node); 2817 } while (0); 2818 return skb_handled; 2819} 2820 2821 2822/** 2823 * nes_cm_alloc_core - allocate a top level instance of a cm core 2824 */ 2825static struct nes_cm_core *nes_cm_alloc_core(void) 2826{ 2827 struct nes_cm_core *cm_core; 2828 2829 /* setup the CM core */ 2830 /* alloc top level core control structure */ 2831 cm_core = kzalloc(sizeof(*cm_core), GFP_KERNEL); 2832 if (!cm_core) 2833 return NULL; 2834 2835 INIT_LIST_HEAD(&cm_core->connected_nodes); 2836 init_timer(&cm_core->tcp_timer); 2837 cm_core->tcp_timer.function = nes_cm_timer_tick; 2838 2839 cm_core->mtu = NES_CM_DEFAULT_MTU; 2840 cm_core->state = NES_CM_STATE_INITED; 2841 cm_core->free_tx_pkt_max = NES_CM_DEFAULT_FREE_PKTS; 2842 2843 atomic_set(&cm_core->events_posted, 0); 2844 2845 cm_core->api = &nes_cm_api; 2846 2847 spin_lock_init(&cm_core->ht_lock); 2848 spin_lock_init(&cm_core->listen_list_lock); 2849 2850 INIT_LIST_HEAD(&cm_core->listen_list.list); 2851 2852 nes_debug(NES_DBG_CM, "Init CM Core completed -- cm_core=%p\n", cm_core); 2853 2854 nes_debug(NES_DBG_CM, "Enable QUEUE EVENTS\n"); 2855 cm_core->event_wq = create_singlethread_workqueue("nesewq"); 2856 cm_core->post_event = nes_cm_post_event; 2857 nes_debug(NES_DBG_CM, "Enable QUEUE DISCONNECTS\n"); 2858 cm_core->disconn_wq = create_singlethread_workqueue("nesdwq"); 2859 2860 print_core(cm_core); 2861 return cm_core; 2862} 2863 2864 2865/** 2866 * mini_cm_dealloc_core - deallocate a top level instance of a cm core 2867 */ 2868static int mini_cm_dealloc_core(struct nes_cm_core *cm_core) 2869{ 2870 nes_debug(NES_DBG_CM, "De-Alloc CM Core (%p)\n", cm_core); 2871 2872 if (!cm_core) 2873 return -EINVAL; 2874 2875 barrier(); 2876 2877 if (timer_pending(&cm_core->tcp_timer)) 2878 del_timer(&cm_core->tcp_timer); 2879 2880 destroy_workqueue(cm_core->event_wq); 2881 destroy_workqueue(cm_core->disconn_wq); 2882 nes_debug(NES_DBG_CM, "\n"); 2883 kfree(cm_core); 2884 2885 return 0; 2886} 2887 2888 2889/** 2890 * mini_cm_get 2891 */ 2892static int mini_cm_get(struct nes_cm_core *cm_core) 2893{ 2894 return cm_core->state; 2895} 2896 2897 2898/** 2899 * mini_cm_set 2900 */ 2901static int mini_cm_set(struct nes_cm_core *cm_core, u32 type, u32 value) 2902{ 2903 int ret = 0; 2904 2905 switch (type) { 2906 case NES_CM_SET_PKT_SIZE: 2907 cm_core->mtu = value; 2908 break; 2909 case NES_CM_SET_FREE_PKT_Q_SIZE: 2910 cm_core->free_tx_pkt_max = value; 2911 break; 2912 default: 2913 /* unknown set option */ 2914 ret = -EINVAL; 2915 } 2916 2917 return ret; 2918} 2919 2920 2921/** 2922 * nes_cm_init_tsa_conn setup HW; MPA frames must be 2923 * successfully exchanged when this is called 2924 */ 2925static int nes_cm_init_tsa_conn(struct nes_qp *nesqp, struct nes_cm_node *cm_node) 2926{ 2927 int ret = 0; 2928 2929 if (!nesqp) 2930 return -EINVAL; 2931 2932 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_IPV4 | 2933 NES_QPCONTEXT_MISC_NO_NAGLE | NES_QPCONTEXT_MISC_DO_NOT_FRAG | 2934 NES_QPCONTEXT_MISC_DROS); 2935 2936 if (cm_node->tcp_cntxt.snd_wscale || cm_node->tcp_cntxt.rcv_wscale) 2937 nesqp->nesqp_context->misc |= cpu_to_le32(NES_QPCONTEXT_MISC_WSCALE); 2938 2939 nesqp->nesqp_context->misc2 |= cpu_to_le32(64 << NES_QPCONTEXT_MISC2_TTL_SHIFT); 2940 2941 nesqp->nesqp_context->mss |= cpu_to_le32(((u32)cm_node->tcp_cntxt.mss) << 16); 2942 2943 nesqp->nesqp_context->tcp_state_flow_label |= cpu_to_le32( 2944 (u32)NES_QPCONTEXT_TCPSTATE_EST << NES_QPCONTEXT_TCPFLOW_TCP_STATE_SHIFT); 2945 2946 nesqp->nesqp_context->pd_index_wscale |= cpu_to_le32( 2947 (cm_node->tcp_cntxt.snd_wscale << NES_QPCONTEXT_PDWSCALE_SND_WSCALE_SHIFT) & 2948 NES_QPCONTEXT_PDWSCALE_SND_WSCALE_MASK); 2949 2950 nesqp->nesqp_context->pd_index_wscale |= cpu_to_le32( 2951 (cm_node->tcp_cntxt.rcv_wscale << NES_QPCONTEXT_PDWSCALE_RCV_WSCALE_SHIFT) & 2952 NES_QPCONTEXT_PDWSCALE_RCV_WSCALE_MASK); 2953 2954 nesqp->nesqp_context->keepalive = cpu_to_le32(0x80); 2955 nesqp->nesqp_context->ts_recent = 0; 2956 nesqp->nesqp_context->ts_age = 0; 2957 nesqp->nesqp_context->snd_nxt = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num); 2958 nesqp->nesqp_context->snd_wnd = cpu_to_le32(cm_node->tcp_cntxt.snd_wnd); 2959 nesqp->nesqp_context->rcv_nxt = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt); 2960 nesqp->nesqp_context->rcv_wnd = cpu_to_le32(cm_node->tcp_cntxt.rcv_wnd << 2961 cm_node->tcp_cntxt.rcv_wscale); 2962 nesqp->nesqp_context->snd_max = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num); 2963 nesqp->nesqp_context->snd_una = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num); 2964 nesqp->nesqp_context->srtt = 0; 2965 nesqp->nesqp_context->rttvar = cpu_to_le32(0x6); 2966 nesqp->nesqp_context->ssthresh = cpu_to_le32(0x3FFFC000); 2967 nesqp->nesqp_context->cwnd = cpu_to_le32(2 * cm_node->tcp_cntxt.mss); 2968 nesqp->nesqp_context->snd_wl1 = cpu_to_le32(cm_node->tcp_cntxt.rcv_nxt); 2969 nesqp->nesqp_context->snd_wl2 = cpu_to_le32(cm_node->tcp_cntxt.loc_seq_num); 2970 nesqp->nesqp_context->max_snd_wnd = cpu_to_le32(cm_node->tcp_cntxt.max_snd_wnd); 2971 2972 nes_debug(NES_DBG_CM, "QP%u: rcv_nxt = 0x%08X, snd_nxt = 0x%08X," 2973 " Setting MSS to %u, PDWscale = 0x%08X, rcv_wnd = %u, context misc = 0x%08X.\n", 2974 nesqp->hwqp.qp_id, le32_to_cpu(nesqp->nesqp_context->rcv_nxt), 2975 le32_to_cpu(nesqp->nesqp_context->snd_nxt), 2976 cm_node->tcp_cntxt.mss, le32_to_cpu(nesqp->nesqp_context->pd_index_wscale), 2977 le32_to_cpu(nesqp->nesqp_context->rcv_wnd), 2978 le32_to_cpu(nesqp->nesqp_context->misc)); 2979 nes_debug(NES_DBG_CM, " snd_wnd = 0x%08X.\n", le32_to_cpu(nesqp->nesqp_context->snd_wnd)); 2980 nes_debug(NES_DBG_CM, " snd_cwnd = 0x%08X.\n", le32_to_cpu(nesqp->nesqp_context->cwnd)); 2981 nes_debug(NES_DBG_CM, " max_swnd = 0x%08X.\n", le32_to_cpu(nesqp->nesqp_context->max_snd_wnd)); 2982 2983 nes_debug(NES_DBG_CM, "Change cm_node state to TSA\n"); 2984 cm_node->state = NES_CM_STATE_TSA; 2985 2986 return ret; 2987} 2988 2989 2990/** 2991 * nes_cm_disconn 2992 */ 2993int nes_cm_disconn(struct nes_qp *nesqp) 2994{ 2995 struct disconn_work *work; 2996 2997 work = kzalloc(sizeof *work, GFP_ATOMIC); 2998 if (!work) 2999 return -ENOMEM; /* Timer will clean up */ 3000 3001 nes_add_ref(&nesqp->ibqp); 3002 work->nesqp = nesqp; 3003 INIT_WORK(&work->work, nes_disconnect_worker); 3004 queue_work(g_cm_core->disconn_wq, &work->work); 3005 return 0; 3006} 3007 3008 3009/** 3010 * nes_disconnect_worker 3011 */ 3012static void nes_disconnect_worker(struct work_struct *work) 3013{ 3014 struct disconn_work *dwork = container_of(work, struct disconn_work, work); 3015 struct nes_qp *nesqp = dwork->nesqp; 3016 3017 kfree(dwork); 3018 nes_debug(NES_DBG_CM, "processing AEQE id 0x%04X for QP%u.\n", 3019 nesqp->last_aeq, nesqp->hwqp.qp_id); 3020 nes_cm_disconn_true(nesqp); 3021 nes_rem_ref(&nesqp->ibqp); 3022} 3023 3024 3025/** 3026 * nes_cm_disconn_true 3027 */ 3028static int nes_cm_disconn_true(struct nes_qp *nesqp) 3029{ 3030 unsigned long flags; 3031 int ret = 0; 3032 struct iw_cm_id *cm_id; 3033 struct iw_cm_event cm_event; 3034 struct nes_vnic *nesvnic; 3035 u16 last_ae; 3036 u8 original_hw_tcp_state; 3037 u8 original_ibqp_state; 3038 int disconn_status = 0; 3039 int issue_disconn = 0; 3040 int issue_close = 0; 3041 int issue_flush = 0; 3042 u32 flush_q = NES_CQP_FLUSH_RQ; 3043 struct ib_event ibevent; 3044 3045 if (!nesqp) { 3046 nes_debug(NES_DBG_CM, "disconnect_worker nesqp is NULL\n"); 3047 return -1; 3048 } 3049 3050 spin_lock_irqsave(&nesqp->lock, flags); 3051 cm_id = nesqp->cm_id; 3052 /* make sure we havent already closed this connection */ 3053 if (!cm_id) { 3054 nes_debug(NES_DBG_CM, "QP%u disconnect_worker cmid is NULL\n", 3055 nesqp->hwqp.qp_id); 3056 spin_unlock_irqrestore(&nesqp->lock, flags); 3057 return -1; 3058 } 3059 3060 nesvnic = to_nesvnic(nesqp->ibqp.device); 3061 nes_debug(NES_DBG_CM, "Disconnecting QP%u\n", nesqp->hwqp.qp_id); 3062 3063 original_hw_tcp_state = nesqp->hw_tcp_state; 3064 original_ibqp_state = nesqp->ibqp_state; 3065 last_ae = nesqp->last_aeq; 3066 3067 if (nesqp->term_flags) { 3068 issue_disconn = 1; 3069 issue_close = 1; 3070 nesqp->cm_id = NULL; 3071 del_timer(&nesqp->terminate_timer); 3072 if (nesqp->flush_issued == 0) { 3073 nesqp->flush_issued = 1; 3074 issue_flush = 1; 3075 } 3076 } else if ((original_hw_tcp_state == NES_AEQE_TCP_STATE_CLOSE_WAIT) || 3077 ((original_ibqp_state == IB_QPS_RTS) && 3078 (last_ae == NES_AEQE_AEID_LLP_CONNECTION_RESET))) { 3079 issue_disconn = 1; 3080 if (last_ae == NES_AEQE_AEID_LLP_CONNECTION_RESET) 3081 disconn_status = -ECONNRESET; 3082 } 3083 3084 if (((original_hw_tcp_state == NES_AEQE_TCP_STATE_CLOSED) || 3085 (original_hw_tcp_state == NES_AEQE_TCP_STATE_TIME_WAIT) || 3086 (last_ae == NES_AEQE_AEID_RDMAP_ROE_BAD_LLP_CLOSE) || 3087 (last_ae == NES_AEQE_AEID_LLP_CONNECTION_RESET))) { 3088 issue_close = 1; 3089 nesqp->cm_id = NULL; 3090 if (nesqp->flush_issued == 0) { 3091 nesqp->flush_issued = 1; 3092 issue_flush = 1; 3093 } 3094 } 3095 3096 spin_unlock_irqrestore(&nesqp->lock, flags); 3097 3098 if ((issue_flush) && (nesqp->destroyed == 0)) { 3099 /* Flush the queue(s) */ 3100 if (nesqp->hw_iwarp_state >= NES_AEQE_IWARP_STATE_TERMINATE) 3101 flush_q |= NES_CQP_FLUSH_SQ; 3102 flush_wqes(nesvnic->nesdev, nesqp, flush_q, 1); 3103 3104 if (nesqp->term_flags) { 3105 ibevent.device = nesqp->ibqp.device; 3106 ibevent.event = nesqp->terminate_eventtype; 3107 ibevent.element.qp = &nesqp->ibqp; 3108 if (nesqp->ibqp.event_handler) 3109 nesqp->ibqp.event_handler(&ibevent, nesqp->ibqp.qp_context); 3110 } 3111 } 3112 3113 if ((cm_id) && (cm_id->event_handler)) { 3114 if (issue_disconn) { 3115 atomic_inc(&cm_disconnects); 3116 cm_event.event = IW_CM_EVENT_DISCONNECT; 3117 cm_event.status = disconn_status; 3118 cm_event.local_addr = cm_id->local_addr; 3119 cm_event.remote_addr = cm_id->remote_addr; 3120 cm_event.private_data = NULL; 3121 cm_event.private_data_len = 0; 3122 3123 nes_debug(NES_DBG_CM, "Generating a CM Disconnect Event" 3124 " for QP%u, SQ Head = %u, SQ Tail = %u. " 3125 "cm_id = %p, refcount = %u.\n", 3126 nesqp->hwqp.qp_id, nesqp->hwqp.sq_head, 3127 nesqp->hwqp.sq_tail, cm_id, 3128 atomic_read(&nesqp->refcount)); 3129 3130 ret = cm_id->event_handler(cm_id, &cm_event); 3131 if (ret) 3132 nes_debug(NES_DBG_CM, "OFA CM event_handler " 3133 "returned, ret=%d\n", ret); 3134 } 3135 3136 if (issue_close) { 3137 atomic_inc(&cm_closes); 3138 nes_disconnect(nesqp, 1); 3139 3140 cm_id->provider_data = nesqp; 3141 /* Send up the close complete event */ 3142 cm_event.event = IW_CM_EVENT_CLOSE; 3143 cm_event.status = 0; 3144 cm_event.provider_data = cm_id->provider_data; 3145 cm_event.local_addr = cm_id->local_addr; 3146 cm_event.remote_addr = cm_id->remote_addr; 3147 cm_event.private_data = NULL; 3148 cm_event.private_data_len = 0; 3149 3150 ret = cm_id->event_handler(cm_id, &cm_event); 3151 if (ret) 3152 nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret); 3153 3154 cm_id->rem_ref(cm_id); 3155 } 3156 } 3157 3158 return 0; 3159} 3160 3161 3162/** 3163 * nes_disconnect 3164 */ 3165static int nes_disconnect(struct nes_qp *nesqp, int abrupt) 3166{ 3167 int ret = 0; 3168 struct nes_vnic *nesvnic; 3169 struct nes_device *nesdev; 3170 struct nes_ib_device *nesibdev; 3171 3172 nesvnic = to_nesvnic(nesqp->ibqp.device); 3173 if (!nesvnic) 3174 return -EINVAL; 3175 3176 nesdev = nesvnic->nesdev; 3177 nesibdev = nesvnic->nesibdev; 3178 3179 nes_debug(NES_DBG_CM, "netdev refcnt = %u.\n", 3180 netdev_refcnt_read(nesvnic->netdev)); 3181 3182 if (nesqp->active_conn) { 3183 3184 /* indicate this connection is NOT active */ 3185 nesqp->active_conn = 0; 3186 } else { 3187 /* Need to free the Last Streaming Mode Message */ 3188 if (nesqp->ietf_frame) { 3189 if (nesqp->lsmm_mr) 3190 nesibdev->ibdev.dereg_mr(nesqp->lsmm_mr); 3191 pci_free_consistent(nesdev->pcidev, 3192 nesqp->private_data_len + nesqp->ietf_frame_size, 3193 nesqp->ietf_frame, nesqp->ietf_frame_pbase); 3194 } 3195 } 3196 3197 /* close the CM node down if it is still active */ 3198 if (nesqp->cm_node) { 3199 nes_debug(NES_DBG_CM, "Call close API\n"); 3200 3201 g_cm_core->api->close(g_cm_core, nesqp->cm_node); 3202 } 3203 3204 return ret; 3205} 3206 3207 3208/** 3209 * nes_accept 3210 */ 3211int nes_accept(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param) 3212{ 3213 u64 u64temp; 3214 struct ib_qp *ibqp; 3215 struct nes_qp *nesqp; 3216 struct nes_vnic *nesvnic; 3217 struct nes_device *nesdev; 3218 struct nes_cm_node *cm_node; 3219 struct nes_adapter *adapter; 3220 struct ib_qp_attr attr; 3221 struct iw_cm_event cm_event; 3222 struct nes_hw_qp_wqe *wqe; 3223 struct nes_v4_quad nes_quad; 3224 u32 crc_value; 3225 int ret; 3226 int passive_state; 3227 struct nes_ib_device *nesibdev; 3228 struct ib_mr *ibmr = NULL; 3229 struct ib_phys_buf ibphysbuf; 3230 struct nes_pd *nespd; 3231 u64 tagged_offset; 3232 u8 mpa_frame_offset = 0; 3233 struct ietf_mpa_v2 *mpa_v2_frame; 3234 u8 start_addr = 0; 3235 u8 *start_ptr = &start_addr; 3236 u8 **start_buff = &start_ptr; 3237 u16 buff_len = 0; 3238 struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr; 3239 struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr; 3240 3241 ibqp = nes_get_qp(cm_id->device, conn_param->qpn); 3242 if (!ibqp) 3243 return -EINVAL; 3244 3245 /* get all our handles */ 3246 nesqp = to_nesqp(ibqp); 3247 nesvnic = to_nesvnic(nesqp->ibqp.device); 3248 nesdev = nesvnic->nesdev; 3249 adapter = nesdev->nesadapter; 3250 3251 cm_node = (struct nes_cm_node *)cm_id->provider_data; 3252 nes_debug(NES_DBG_CM, "nes_accept: cm_node= %p nesvnic=%p, netdev=%p," 3253 "%s\n", cm_node, nesvnic, nesvnic->netdev, 3254 nesvnic->netdev->name); 3255 3256 if (NES_CM_STATE_LISTENER_DESTROYED == cm_node->state) { 3257 if (cm_node->loopbackpartner) 3258 rem_ref_cm_node(cm_node->cm_core, cm_node->loopbackpartner); 3259 rem_ref_cm_node(cm_node->cm_core, cm_node); 3260 return -EINVAL; 3261 } 3262 3263 passive_state = atomic_add_return(1, &cm_node->passive_state); 3264 if (passive_state == NES_SEND_RESET_EVENT) { 3265 rem_ref_cm_node(cm_node->cm_core, cm_node); 3266 return -ECONNRESET; 3267 } 3268 /* associate the node with the QP */ 3269 nesqp->cm_node = (void *)cm_node; 3270 cm_node->nesqp = nesqp; 3271 3272 3273 nes_debug(NES_DBG_CM, "QP%u, cm_node=%p, jiffies = %lu listener = %p\n", 3274 nesqp->hwqp.qp_id, cm_node, jiffies, cm_node->listener); 3275 atomic_inc(&cm_accepts); 3276 3277 nes_debug(NES_DBG_CM, "netdev refcnt = %u.\n", 3278 netdev_refcnt_read(nesvnic->netdev)); 3279 3280 nesqp->ietf_frame_size = sizeof(struct ietf_mpa_v2); 3281 /* allocate the ietf frame and space for private data */ 3282 nesqp->ietf_frame = pci_alloc_consistent(nesdev->pcidev, 3283 nesqp->ietf_frame_size + conn_param->private_data_len, 3284 &nesqp->ietf_frame_pbase); 3285 3286 if (!nesqp->ietf_frame) { 3287 nes_debug(NES_DBG_CM, "Unable to allocate memory for private data\n"); 3288 return -ENOMEM; 3289 } 3290 mpa_v2_frame = (struct ietf_mpa_v2 *)nesqp->ietf_frame; 3291 3292 if (cm_node->mpa_frame_rev == IETF_MPA_V1) 3293 mpa_frame_offset = 4; 3294 3295 if (cm_node->mpa_frame_rev == IETF_MPA_V1 || 3296 cm_node->mpav2_ird_ord == IETF_NO_IRD_ORD) { 3297 record_ird_ord(cm_node, (u16)conn_param->ird, (u16)conn_param->ord); 3298 } 3299 3300 memcpy(mpa_v2_frame->priv_data, conn_param->private_data, 3301 conn_param->private_data_len); 3302 3303 cm_build_mpa_frame(cm_node, start_buff, &buff_len, nesqp->ietf_frame, MPA_KEY_REPLY); 3304 nesqp->private_data_len = conn_param->private_data_len; 3305 3306 /* setup our first outgoing iWarp send WQE (the IETF frame response) */ 3307 wqe = &nesqp->hwqp.sq_vbase[0]; 3308 3309 if (raddr->sin_addr.s_addr != laddr->sin_addr.s_addr) { 3310 u64temp = (unsigned long)nesqp; 3311 nesibdev = nesvnic->nesibdev; 3312 nespd = nesqp->nespd; 3313 ibphysbuf.addr = nesqp->ietf_frame_pbase + mpa_frame_offset; 3314 ibphysbuf.size = buff_len; 3315 tagged_offset = (u64)(unsigned long)*start_buff; 3316 ibmr = nesibdev->ibdev.reg_phys_mr((struct ib_pd *)nespd, 3317 &ibphysbuf, 1, 3318 IB_ACCESS_LOCAL_WRITE, 3319 &tagged_offset); 3320 if (!ibmr) { 3321 nes_debug(NES_DBG_CM, "Unable to register memory region" 3322 "for lSMM for cm_node = %p \n", 3323 cm_node); 3324 pci_free_consistent(nesdev->pcidev, 3325 nesqp->private_data_len + nesqp->ietf_frame_size, 3326 nesqp->ietf_frame, nesqp->ietf_frame_pbase); 3327 return -ENOMEM; 3328 } 3329 3330 ibmr->pd = &nespd->ibpd; 3331 ibmr->device = nespd->ibpd.device; 3332 nesqp->lsmm_mr = ibmr; 3333 3334 u64temp |= NES_SW_CONTEXT_ALIGN >> 1; 3335 set_wqe_64bit_value(wqe->wqe_words, 3336 NES_IWARP_SQ_WQE_COMP_CTX_LOW_IDX, 3337 u64temp); 3338 wqe->wqe_words[NES_IWARP_SQ_WQE_MISC_IDX] = 3339 cpu_to_le32(NES_IWARP_SQ_WQE_STREAMING | 3340 NES_IWARP_SQ_WQE_WRPDU); 3341 wqe->wqe_words[NES_IWARP_SQ_WQE_TOTAL_PAYLOAD_IDX] = 3342 cpu_to_le32(buff_len); 3343 set_wqe_64bit_value(wqe->wqe_words, 3344 NES_IWARP_SQ_WQE_FRAG0_LOW_IDX, 3345 (u64)(unsigned long)(*start_buff)); 3346 wqe->wqe_words[NES_IWARP_SQ_WQE_LENGTH0_IDX] = 3347 cpu_to_le32(buff_len); 3348 wqe->wqe_words[NES_IWARP_SQ_WQE_STAG0_IDX] = ibmr->lkey; 3349 if (nesqp->sq_kmapped) { 3350 nesqp->sq_kmapped = 0; 3351 kunmap(nesqp->page); 3352 } 3353 3354 nesqp->nesqp_context->ird_ord_sizes |= 3355 cpu_to_le32(NES_QPCONTEXT_ORDIRD_LSMM_PRESENT | 3356 NES_QPCONTEXT_ORDIRD_WRPDU); 3357 } else { 3358 nesqp->nesqp_context->ird_ord_sizes |= 3359 cpu_to_le32(NES_QPCONTEXT_ORDIRD_WRPDU); 3360 } 3361 nesqp->skip_lsmm = 1; 3362 3363 /* Cache the cm_id in the qp */ 3364 nesqp->cm_id = cm_id; 3365 cm_node->cm_id = cm_id; 3366 3367 /* nesqp->cm_node = (void *)cm_id->provider_data; */ 3368 cm_id->provider_data = nesqp; 3369 nesqp->active_conn = 0; 3370 3371 if (cm_node->state == NES_CM_STATE_TSA) 3372 nes_debug(NES_DBG_CM, "Already state = TSA for cm_node=%p\n", 3373 cm_node); 3374 3375 nes_cm_init_tsa_conn(nesqp, cm_node); 3376 3377 nesqp->nesqp_context->tcpPorts[0] = 3378 cpu_to_le16(cm_node->mapped_loc_port); 3379 nesqp->nesqp_context->tcpPorts[1] = 3380 cpu_to_le16(cm_node->mapped_rem_port); 3381 3382 nesqp->nesqp_context->ip0 = cpu_to_le32(cm_node->mapped_rem_addr); 3383 3384 nesqp->nesqp_context->misc2 |= cpu_to_le32( 3385 (u32)PCI_FUNC(nesdev->pcidev->devfn) << 3386 NES_QPCONTEXT_MISC2_SRC_IP_SHIFT); 3387 3388 nesqp->nesqp_context->arp_index_vlan |= 3389 cpu_to_le32(nes_arp_table(nesdev, 3390 le32_to_cpu(nesqp->nesqp_context->ip0), NULL, 3391 NES_ARP_RESOLVE) << 16); 3392 3393 nesqp->nesqp_context->ts_val_delta = cpu_to_le32( 3394 jiffies - nes_read_indexed(nesdev, NES_IDX_TCP_NOW)); 3395 3396 nesqp->nesqp_context->ird_index = cpu_to_le32(nesqp->hwqp.qp_id); 3397 3398 nesqp->nesqp_context->ird_ord_sizes |= cpu_to_le32( 3399 ((u32)1 << NES_QPCONTEXT_ORDIRD_IWARP_MODE_SHIFT)); 3400 nesqp->nesqp_context->ird_ord_sizes |= 3401 cpu_to_le32((u32)cm_node->ord_size); 3402 3403 memset(&nes_quad, 0, sizeof(nes_quad)); 3404 nes_quad.DstIpAdrIndex = 3405 cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24); 3406 nes_quad.SrcIpadr = htonl(cm_node->mapped_rem_addr); 3407 nes_quad.TcpPorts[0] = htons(cm_node->mapped_rem_port); 3408 nes_quad.TcpPorts[1] = htons(cm_node->mapped_loc_port); 3409 3410 /* Produce hash key */ 3411 crc_value = get_crc_value(&nes_quad); 3412 nesqp->hte_index = cpu_to_be32(crc_value ^ 0xffffffff); 3413 nes_debug(NES_DBG_CM, "HTE Index = 0x%08X, CRC = 0x%08X\n", 3414 nesqp->hte_index, nesqp->hte_index & adapter->hte_index_mask); 3415 3416 nesqp->hte_index &= adapter->hte_index_mask; 3417 nesqp->nesqp_context->hte_index = cpu_to_le32(nesqp->hte_index); 3418 3419 cm_node->cm_core->api->accelerated(cm_node->cm_core, cm_node); 3420 3421 nes_debug(NES_DBG_CM, "QP%u, Destination IP = 0x%08X:0x%04X, local = " 3422 "0x%08X:0x%04X, rcv_nxt=0x%08X, snd_nxt=0x%08X, mpa + " 3423 "private data length=%u.\n", nesqp->hwqp.qp_id, 3424 ntohl(raddr->sin_addr.s_addr), ntohs(raddr->sin_port), 3425 ntohl(laddr->sin_addr.s_addr), ntohs(laddr->sin_port), 3426 le32_to_cpu(nesqp->nesqp_context->rcv_nxt), 3427 le32_to_cpu(nesqp->nesqp_context->snd_nxt), 3428 buff_len); 3429 3430 /* notify OF layer that accept event was successful */ 3431 cm_id->add_ref(cm_id); 3432 nes_add_ref(&nesqp->ibqp); 3433 3434 cm_event.event = IW_CM_EVENT_ESTABLISHED; 3435 cm_event.status = 0; 3436 cm_event.provider_data = (void *)nesqp; 3437 cm_event.local_addr = cm_id->local_addr; 3438 cm_event.remote_addr = cm_id->remote_addr; 3439 cm_event.private_data = NULL; 3440 cm_event.private_data_len = 0; 3441 cm_event.ird = cm_node->ird_size; 3442 cm_event.ord = cm_node->ord_size; 3443 3444 ret = cm_id->event_handler(cm_id, &cm_event); 3445 attr.qp_state = IB_QPS_RTS; 3446 nes_modify_qp(&nesqp->ibqp, &attr, IB_QP_STATE, NULL); 3447 if (cm_node->loopbackpartner) { 3448 cm_node->loopbackpartner->mpa_frame_size = 3449 nesqp->private_data_len; 3450 /* copy entire MPA frame to our cm_node's frame */ 3451 memcpy(cm_node->loopbackpartner->mpa_frame_buf, 3452 conn_param->private_data, conn_param->private_data_len); 3453 create_event(cm_node->loopbackpartner, NES_CM_EVENT_CONNECTED); 3454 } 3455 if (ret) 3456 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, " 3457 "ret=%d\n", __func__, __LINE__, ret); 3458 3459 return 0; 3460} 3461 3462 3463/** 3464 * nes_reject 3465 */ 3466int nes_reject(struct iw_cm_id *cm_id, const void *pdata, u8 pdata_len) 3467{ 3468 struct nes_cm_node *cm_node; 3469 struct nes_cm_node *loopback; 3470 struct nes_cm_core *cm_core; 3471 u8 *start_buff; 3472 3473 atomic_inc(&cm_rejects); 3474 cm_node = (struct nes_cm_node *)cm_id->provider_data; 3475 loopback = cm_node->loopbackpartner; 3476 cm_core = cm_node->cm_core; 3477 cm_node->cm_id = cm_id; 3478 3479 if (pdata_len + sizeof(struct ietf_mpa_v2) > MAX_CM_BUFFER) 3480 return -EINVAL; 3481 3482 if (loopback) { 3483 memcpy(&loopback->mpa_frame.priv_data, pdata, pdata_len); 3484 loopback->mpa_frame.priv_data_len = pdata_len; 3485 loopback->mpa_frame_size = pdata_len; 3486 } else { 3487 start_buff = &cm_node->mpa_frame_buf[0] + sizeof(struct ietf_mpa_v2); 3488 cm_node->mpa_frame_size = pdata_len; 3489 memcpy(start_buff, pdata, pdata_len); 3490 } 3491 return cm_core->api->reject(cm_core, cm_node); 3492} 3493 3494 3495/** 3496 * nes_connect 3497 * setup and launch cm connect node 3498 */ 3499int nes_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *conn_param) 3500{ 3501 struct ib_qp *ibqp; 3502 struct nes_qp *nesqp; 3503 struct nes_vnic *nesvnic; 3504 struct nes_device *nesdev; 3505 struct nes_cm_node *cm_node; 3506 struct nes_cm_info cm_info; 3507 int apbvt_set = 0; 3508 struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr; 3509 struct sockaddr_in *raddr = (struct sockaddr_in *)&cm_id->remote_addr; 3510 struct iwpm_dev_data pm_reg_msg; 3511 struct iwpm_sa_data pm_msg; 3512 int iwpm_err = 0; 3513 3514 if (cm_id->remote_addr.ss_family != AF_INET) 3515 return -ENOSYS; 3516 ibqp = nes_get_qp(cm_id->device, conn_param->qpn); 3517 if (!ibqp) 3518 return -EINVAL; 3519 nesqp = to_nesqp(ibqp); 3520 if (!nesqp) 3521 return -EINVAL; 3522 nesvnic = to_nesvnic(nesqp->ibqp.device); 3523 if (!nesvnic) 3524 return -EINVAL; 3525 nesdev = nesvnic->nesdev; 3526 if (!nesdev) 3527 return -EINVAL; 3528 3529 if (!laddr->sin_port || !raddr->sin_port) 3530 return -EINVAL; 3531 3532 nes_debug(NES_DBG_CM, "QP%u, current IP = 0x%08X, Destination IP = " 3533 "0x%08X:0x%04X, local = 0x%08X:0x%04X.\n", nesqp->hwqp.qp_id, 3534 ntohl(nesvnic->local_ipaddr), ntohl(raddr->sin_addr.s_addr), 3535 ntohs(raddr->sin_port), ntohl(laddr->sin_addr.s_addr), 3536 ntohs(laddr->sin_port)); 3537 3538 atomic_inc(&cm_connects); 3539 nesqp->active_conn = 1; 3540 3541 /* cache the cm_id in the qp */ 3542 nesqp->cm_id = cm_id; 3543 cm_id->provider_data = nesqp; 3544 nesqp->private_data_len = conn_param->private_data_len; 3545 3546 nes_debug(NES_DBG_CM, "requested ord = 0x%08X.\n", (u32)conn_param->ord); 3547 nes_debug(NES_DBG_CM, "mpa private data len =%u\n", 3548 conn_param->private_data_len); 3549 3550 /* set up the connection params for the node */ 3551 cm_info.loc_addr = ntohl(laddr->sin_addr.s_addr); 3552 cm_info.loc_port = ntohs(laddr->sin_port); 3553 cm_info.rem_addr = ntohl(raddr->sin_addr.s_addr); 3554 cm_info.rem_port = ntohs(raddr->sin_port); 3555 cm_info.cm_id = cm_id; 3556 cm_info.conn_type = NES_CM_IWARP_CONN_TYPE; 3557 3558 /* No port mapper available, go with the specified peer information */ 3559 cm_info.mapped_loc_addr = cm_info.loc_addr; 3560 cm_info.mapped_loc_port = cm_info.loc_port; 3561 cm_info.mapped_rem_addr = cm_info.rem_addr; 3562 cm_info.mapped_rem_port = cm_info.rem_port; 3563 3564 nes_form_reg_msg(nesvnic, &pm_reg_msg); 3565 iwpm_err = iwpm_register_pid(&pm_reg_msg, RDMA_NL_NES); 3566 if (iwpm_err) { 3567 nes_debug(NES_DBG_NLMSG, 3568 "Port Mapper reg pid fail (err = %d).\n", iwpm_err); 3569 } 3570 if (iwpm_valid_pid() && !iwpm_err) { 3571 nes_form_pm_msg(&cm_info, &pm_msg); 3572 iwpm_err = iwpm_add_and_query_mapping(&pm_msg, RDMA_NL_NES); 3573 if (iwpm_err) 3574 nes_debug(NES_DBG_NLMSG, 3575 "Port Mapper query fail (err = %d).\n", iwpm_err); 3576 else 3577 nes_record_pm_msg(&cm_info, &pm_msg); 3578 } 3579 3580 if (laddr->sin_addr.s_addr != raddr->sin_addr.s_addr) { 3581 nes_manage_apbvt(nesvnic, cm_info.mapped_loc_port, 3582 PCI_FUNC(nesdev->pcidev->devfn), NES_MANAGE_APBVT_ADD); 3583 apbvt_set = 1; 3584 } 3585 3586 if (nes_create_mapinfo(&cm_info)) 3587 return -ENOMEM; 3588 3589 cm_id->add_ref(cm_id); 3590 3591 /* create a connect CM node connection */ 3592 cm_node = g_cm_core->api->connect(g_cm_core, nesvnic, 3593 conn_param->private_data_len, (void *)conn_param->private_data, 3594 &cm_info); 3595 if (!cm_node) { 3596 if (apbvt_set) 3597 nes_manage_apbvt(nesvnic, cm_info.mapped_loc_port, 3598 PCI_FUNC(nesdev->pcidev->devfn), 3599 NES_MANAGE_APBVT_DEL); 3600 3601 nes_debug(NES_DBG_NLMSG, "Delete mapped_loc_port = %04X\n", 3602 cm_info.mapped_loc_port); 3603 nes_remove_mapinfo(cm_info.loc_addr, cm_info.loc_port, 3604 cm_info.mapped_loc_addr, cm_info.mapped_loc_port); 3605 cm_id->rem_ref(cm_id); 3606 return -ENOMEM; 3607 } 3608 3609 record_ird_ord(cm_node, (u16)conn_param->ird, (u16)conn_param->ord); 3610 if (cm_node->send_rdma0_op == SEND_RDMA_READ_ZERO && 3611 cm_node->ord_size == 0) 3612 cm_node->ord_size = 1; 3613 3614 cm_node->apbvt_set = apbvt_set; 3615 nesqp->cm_node = cm_node; 3616 cm_node->nesqp = nesqp; 3617 nes_add_ref(&nesqp->ibqp); 3618 3619 return 0; 3620} 3621 3622 3623/** 3624 * nes_create_listen 3625 */ 3626int nes_create_listen(struct iw_cm_id *cm_id, int backlog) 3627{ 3628 struct nes_vnic *nesvnic; 3629 struct nes_cm_listener *cm_node; 3630 struct nes_cm_info cm_info; 3631 int err; 3632 struct sockaddr_in *laddr = (struct sockaddr_in *)&cm_id->local_addr; 3633 3634 nes_debug(NES_DBG_CM, "cm_id = %p, local port = 0x%04X.\n", 3635 cm_id, ntohs(laddr->sin_port)); 3636 3637 if (cm_id->local_addr.ss_family != AF_INET) 3638 return -ENOSYS; 3639 nesvnic = to_nesvnic(cm_id->device); 3640 if (!nesvnic) 3641 return -EINVAL; 3642 3643 nes_debug(NES_DBG_CM, "nesvnic=%p, netdev=%p, %s\n", 3644 nesvnic, nesvnic->netdev, nesvnic->netdev->name); 3645 3646 nes_debug(NES_DBG_CM, "nesvnic->local_ipaddr=0x%08x, sin_addr.s_addr=0x%08x\n", 3647 nesvnic->local_ipaddr, laddr->sin_addr.s_addr); 3648 3649 /* setup listen params in our api call struct */ 3650 cm_info.loc_addr = ntohl(nesvnic->local_ipaddr); 3651 cm_info.loc_port = ntohs(laddr->sin_port); 3652 cm_info.backlog = backlog; 3653 cm_info.cm_id = cm_id; 3654 3655 cm_info.conn_type = NES_CM_IWARP_CONN_TYPE; 3656 3657 /* No port mapper available, go with the specified info */ 3658 cm_info.mapped_loc_addr = cm_info.loc_addr; 3659 cm_info.mapped_loc_port = cm_info.loc_port; 3660 3661 cm_node = g_cm_core->api->listen(g_cm_core, nesvnic, &cm_info); 3662 if (!cm_node) { 3663 printk(KERN_ERR "%s[%u] Error returned from listen API call\n", 3664 __func__, __LINE__); 3665 return -ENOMEM; 3666 } 3667 3668 cm_id->provider_data = cm_node; 3669 3670 if (!cm_node->reused_node) { 3671 if (nes_create_mapinfo(&cm_info)) 3672 return -ENOMEM; 3673 3674 err = nes_manage_apbvt(nesvnic, cm_node->mapped_loc_port, 3675 PCI_FUNC(nesvnic->nesdev->pcidev->devfn), 3676 NES_MANAGE_APBVT_ADD); 3677 if (err) { 3678 printk(KERN_ERR "nes_manage_apbvt call returned %d.\n", 3679 err); 3680 g_cm_core->api->stop_listener(g_cm_core, (void *)cm_node); 3681 return err; 3682 } 3683 atomic_inc(&cm_listens_created); 3684 } 3685 3686 cm_id->add_ref(cm_id); 3687 cm_id->provider_data = (void *)cm_node; 3688 3689 3690 return 0; 3691} 3692 3693 3694/** 3695 * nes_destroy_listen 3696 */ 3697int nes_destroy_listen(struct iw_cm_id *cm_id) 3698{ 3699 if (cm_id->provider_data) 3700 g_cm_core->api->stop_listener(g_cm_core, cm_id->provider_data); 3701 else 3702 nes_debug(NES_DBG_CM, "cm_id->provider_data was NULL\n"); 3703 3704 cm_id->rem_ref(cm_id); 3705 3706 return 0; 3707} 3708 3709 3710/** 3711 * nes_cm_recv 3712 */ 3713int nes_cm_recv(struct sk_buff *skb, struct net_device *netdevice) 3714{ 3715 int rc = 0; 3716 3717 cm_packets_received++; 3718 if ((g_cm_core) && (g_cm_core->api)) 3719 rc = g_cm_core->api->recv_pkt(g_cm_core, netdev_priv(netdevice), skb); 3720 else 3721 nes_debug(NES_DBG_CM, "Unable to process packet for CM," 3722 " cm is not setup properly.\n"); 3723 3724 return rc; 3725} 3726 3727 3728/** 3729 * nes_cm_start 3730 * Start and init a cm core module 3731 */ 3732int nes_cm_start(void) 3733{ 3734 nes_debug(NES_DBG_CM, "\n"); 3735 /* create the primary CM core, pass this handle to subsequent core inits */ 3736 g_cm_core = nes_cm_alloc_core(); 3737 if (g_cm_core) 3738 return 0; 3739 else 3740 return -ENOMEM; 3741} 3742 3743 3744/** 3745 * nes_cm_stop 3746 * stop and dealloc all cm core instances 3747 */ 3748int nes_cm_stop(void) 3749{ 3750 g_cm_core->api->destroy_cm_core(g_cm_core); 3751 return 0; 3752} 3753 3754 3755/** 3756 * cm_event_connected 3757 * handle a connected event, setup QPs and HW 3758 */ 3759static void cm_event_connected(struct nes_cm_event *event) 3760{ 3761 struct nes_qp *nesqp; 3762 struct nes_vnic *nesvnic; 3763 struct nes_device *nesdev; 3764 struct nes_cm_node *cm_node; 3765 struct nes_adapter *nesadapter; 3766 struct ib_qp_attr attr; 3767 struct iw_cm_id *cm_id; 3768 struct iw_cm_event cm_event; 3769 struct nes_v4_quad nes_quad; 3770 u32 crc_value; 3771 int ret; 3772 struct sockaddr_in *laddr; 3773 struct sockaddr_in *raddr; 3774 struct sockaddr_in *cm_event_laddr; 3775 3776 /* get all our handles */ 3777 cm_node = event->cm_node; 3778 cm_id = cm_node->cm_id; 3779 nes_debug(NES_DBG_CM, "cm_event_connected - %p - cm_id = %p\n", cm_node, cm_id); 3780 nesqp = (struct nes_qp *)cm_id->provider_data; 3781 nesvnic = to_nesvnic(nesqp->ibqp.device); 3782 nesdev = nesvnic->nesdev; 3783 nesadapter = nesdev->nesadapter; 3784 laddr = (struct sockaddr_in *)&cm_id->local_addr; 3785 raddr = (struct sockaddr_in *)&cm_id->remote_addr; 3786 cm_event_laddr = (struct sockaddr_in *)&cm_event.local_addr; 3787 3788 if (nesqp->destroyed) 3789 return; 3790 atomic_inc(&cm_connecteds); 3791 nes_debug(NES_DBG_CM, "QP%u attempting to connect to 0x%08X:0x%04X on" 3792 " local port 0x%04X. jiffies = %lu.\n", 3793 nesqp->hwqp.qp_id, ntohl(raddr->sin_addr.s_addr), 3794 ntohs(raddr->sin_port), ntohs(laddr->sin_port), jiffies); 3795 3796 nes_cm_init_tsa_conn(nesqp, cm_node); 3797 3798 /* set the QP tsa context */ 3799 nesqp->nesqp_context->tcpPorts[0] = 3800 cpu_to_le16(cm_node->mapped_loc_port); 3801 nesqp->nesqp_context->tcpPorts[1] = 3802 cpu_to_le16(cm_node->mapped_rem_port); 3803 nesqp->nesqp_context->ip0 = cpu_to_le32(cm_node->mapped_rem_addr); 3804 3805 nesqp->nesqp_context->misc2 |= cpu_to_le32( 3806 (u32)PCI_FUNC(nesdev->pcidev->devfn) << 3807 NES_QPCONTEXT_MISC2_SRC_IP_SHIFT); 3808 nesqp->nesqp_context->arp_index_vlan |= cpu_to_le32( 3809 nes_arp_table(nesdev, 3810 le32_to_cpu(nesqp->nesqp_context->ip0), 3811 NULL, NES_ARP_RESOLVE) << 16); 3812 nesqp->nesqp_context->ts_val_delta = cpu_to_le32( 3813 jiffies - nes_read_indexed(nesdev, NES_IDX_TCP_NOW)); 3814 nesqp->nesqp_context->ird_index = cpu_to_le32(nesqp->hwqp.qp_id); 3815 nesqp->nesqp_context->ird_ord_sizes |= 3816 cpu_to_le32((u32)1 << 3817 NES_QPCONTEXT_ORDIRD_IWARP_MODE_SHIFT); 3818 nesqp->nesqp_context->ird_ord_sizes |= 3819 cpu_to_le32((u32)cm_node->ord_size); 3820 3821 /* Adjust tail for not having a LSMM */ 3822 /*nesqp->hwqp.sq_tail = 1;*/ 3823 3824 build_rdma0_msg(cm_node, &nesqp); 3825 3826 nes_write32(nesdev->regs + NES_WQE_ALLOC, 3827 (1 << 24) | 0x00800000 | nesqp->hwqp.qp_id); 3828 3829 memset(&nes_quad, 0, sizeof(nes_quad)); 3830 3831 nes_quad.DstIpAdrIndex = 3832 cpu_to_le32((u32)PCI_FUNC(nesdev->pcidev->devfn) << 24); 3833 nes_quad.SrcIpadr = htonl(cm_node->mapped_rem_addr); 3834 nes_quad.TcpPorts[0] = htons(cm_node->mapped_rem_port); 3835 nes_quad.TcpPorts[1] = htons(cm_node->mapped_loc_port); 3836 3837 /* Produce hash key */ 3838 crc_value = get_crc_value(&nes_quad); 3839 nesqp->hte_index = cpu_to_be32(crc_value ^ 0xffffffff); 3840 nes_debug(NES_DBG_CM, "HTE Index = 0x%08X, After CRC = 0x%08X\n", 3841 nesqp->hte_index, nesqp->hte_index & nesadapter->hte_index_mask); 3842 3843 nesqp->hte_index &= nesadapter->hte_index_mask; 3844 nesqp->nesqp_context->hte_index = cpu_to_le32(nesqp->hte_index); 3845 3846 nesqp->ietf_frame = &cm_node->mpa_frame; 3847 nesqp->private_data_len = (u8)cm_node->mpa_frame_size; 3848 cm_node->cm_core->api->accelerated(cm_node->cm_core, cm_node); 3849 3850 /* notify OF layer we successfully created the requested connection */ 3851 cm_event.event = IW_CM_EVENT_CONNECT_REPLY; 3852 cm_event.status = 0; 3853 cm_event.provider_data = cm_id->provider_data; 3854 cm_event_laddr->sin_family = AF_INET; 3855 cm_event_laddr->sin_port = laddr->sin_port; 3856 cm_event.remote_addr = cm_id->remote_addr; 3857 3858 cm_event.private_data = (void *)event->cm_node->mpa_frame_buf; 3859 cm_event.private_data_len = (u8)event->cm_node->mpa_frame_size; 3860 cm_event.ird = cm_node->ird_size; 3861 cm_event.ord = cm_node->ord_size; 3862 3863 cm_event_laddr->sin_addr.s_addr = htonl(event->cm_info.rem_addr); 3864 ret = cm_id->event_handler(cm_id, &cm_event); 3865 nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret); 3866 3867 if (ret) 3868 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, " 3869 "ret=%d\n", __func__, __LINE__, ret); 3870 attr.qp_state = IB_QPS_RTS; 3871 nes_modify_qp(&nesqp->ibqp, &attr, IB_QP_STATE, NULL); 3872 3873 nes_debug(NES_DBG_CM, "Exiting connect thread for QP%u. jiffies = " 3874 "%lu\n", nesqp->hwqp.qp_id, jiffies); 3875 3876 return; 3877} 3878 3879 3880/** 3881 * cm_event_connect_error 3882 */ 3883static void cm_event_connect_error(struct nes_cm_event *event) 3884{ 3885 struct nes_qp *nesqp; 3886 struct iw_cm_id *cm_id; 3887 struct iw_cm_event cm_event; 3888 /* struct nes_cm_info cm_info; */ 3889 int ret; 3890 3891 if (!event->cm_node) 3892 return; 3893 3894 cm_id = event->cm_node->cm_id; 3895 if (!cm_id) 3896 return; 3897 3898 nes_debug(NES_DBG_CM, "cm_node=%p, cm_id=%p\n", event->cm_node, cm_id); 3899 nesqp = cm_id->provider_data; 3900 3901 if (!nesqp) 3902 return; 3903 3904 /* notify OF layer about this connection error event */ 3905 /* cm_id->rem_ref(cm_id); */ 3906 nesqp->cm_id = NULL; 3907 cm_id->provider_data = NULL; 3908 cm_event.event = IW_CM_EVENT_CONNECT_REPLY; 3909 cm_event.status = -ECONNRESET; 3910 cm_event.provider_data = cm_id->provider_data; 3911 cm_event.local_addr = cm_id->local_addr; 3912 cm_event.remote_addr = cm_id->remote_addr; 3913 cm_event.private_data = NULL; 3914 cm_event.private_data_len = 0; 3915 3916#ifdef CONFIG_INFINIBAND_NES_DEBUG 3917 { 3918 struct sockaddr_in *cm_event_laddr = (struct sockaddr_in *) 3919 &cm_event.local_addr; 3920 struct sockaddr_in *cm_event_raddr = (struct sockaddr_in *) 3921 &cm_event.remote_addr; 3922 nes_debug(NES_DBG_CM, "call CM_EVENT REJECTED, local_addr=%08x, remote_addr=%08x\n", 3923 cm_event_laddr->sin_addr.s_addr, cm_event_raddr->sin_addr.s_addr); 3924 } 3925#endif 3926 3927 ret = cm_id->event_handler(cm_id, &cm_event); 3928 nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret); 3929 if (ret) 3930 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, " 3931 "ret=%d\n", __func__, __LINE__, ret); 3932 cm_id->rem_ref(cm_id); 3933 3934 rem_ref_cm_node(event->cm_node->cm_core, event->cm_node); 3935 return; 3936} 3937 3938 3939/** 3940 * cm_event_reset 3941 */ 3942static void cm_event_reset(struct nes_cm_event *event) 3943{ 3944 struct nes_qp *nesqp; 3945 struct iw_cm_id *cm_id; 3946 struct iw_cm_event cm_event; 3947 /* struct nes_cm_info cm_info; */ 3948 int ret; 3949 3950 if (!event->cm_node) 3951 return; 3952 3953 if (!event->cm_node->cm_id) 3954 return; 3955 3956 cm_id = event->cm_node->cm_id; 3957 3958 nes_debug(NES_DBG_CM, "%p - cm_id = %p\n", event->cm_node, cm_id); 3959 nesqp = cm_id->provider_data; 3960 if (!nesqp) 3961 return; 3962 3963 nesqp->cm_id = NULL; 3964 /* cm_id->provider_data = NULL; */ 3965 cm_event.event = IW_CM_EVENT_DISCONNECT; 3966 cm_event.status = -ECONNRESET; 3967 cm_event.provider_data = cm_id->provider_data; 3968 cm_event.local_addr = cm_id->local_addr; 3969 cm_event.remote_addr = cm_id->remote_addr; 3970 cm_event.private_data = NULL; 3971 cm_event.private_data_len = 0; 3972 3973 cm_id->add_ref(cm_id); 3974 ret = cm_id->event_handler(cm_id, &cm_event); 3975 atomic_inc(&cm_closes); 3976 cm_event.event = IW_CM_EVENT_CLOSE; 3977 cm_event.status = 0; 3978 cm_event.provider_data = cm_id->provider_data; 3979 cm_event.local_addr = cm_id->local_addr; 3980 cm_event.remote_addr = cm_id->remote_addr; 3981 cm_event.private_data = NULL; 3982 cm_event.private_data_len = 0; 3983 nes_debug(NES_DBG_CM, "NODE %p Generating CLOSE\n", event->cm_node); 3984 ret = cm_id->event_handler(cm_id, &cm_event); 3985 3986 nes_debug(NES_DBG_CM, "OFA CM event_handler returned, ret=%d\n", ret); 3987 3988 3989 /* notify OF layer about this connection error event */ 3990 cm_id->rem_ref(cm_id); 3991 3992 return; 3993} 3994 3995 3996/** 3997 * cm_event_mpa_req 3998 */ 3999static void cm_event_mpa_req(struct nes_cm_event *event) 4000{ 4001 struct iw_cm_id *cm_id; 4002 struct iw_cm_event cm_event; 4003 int ret; 4004 struct nes_cm_node *cm_node; 4005 struct sockaddr_in *cm_event_laddr = (struct sockaddr_in *) 4006 &cm_event.local_addr; 4007 struct sockaddr_in *cm_event_raddr = (struct sockaddr_in *) 4008 &cm_event.remote_addr; 4009 4010 cm_node = event->cm_node; 4011 if (!cm_node) 4012 return; 4013 cm_id = cm_node->cm_id; 4014 4015 atomic_inc(&cm_connect_reqs); 4016 nes_debug(NES_DBG_CM, "cm_node = %p - cm_id = %p, jiffies = %lu\n", 4017 cm_node, cm_id, jiffies); 4018 4019 cm_event.event = IW_CM_EVENT_CONNECT_REQUEST; 4020 cm_event.status = 0; 4021 cm_event.provider_data = (void *)cm_node; 4022 4023 cm_event_laddr->sin_family = AF_INET; 4024 cm_event_laddr->sin_port = htons(event->cm_info.loc_port); 4025 cm_event_laddr->sin_addr.s_addr = htonl(event->cm_info.loc_addr); 4026 4027 cm_event_raddr->sin_family = AF_INET; 4028 cm_event_raddr->sin_port = htons(event->cm_info.rem_port); 4029 cm_event_raddr->sin_addr.s_addr = htonl(event->cm_info.rem_addr); 4030 cm_event.private_data = cm_node->mpa_frame_buf; 4031 cm_event.private_data_len = (u8)cm_node->mpa_frame_size; 4032 if (cm_node->mpa_frame_rev == IETF_MPA_V1) { 4033 cm_event.ird = NES_MAX_IRD; 4034 cm_event.ord = NES_MAX_ORD; 4035 } else { 4036 cm_event.ird = cm_node->ird_size; 4037 cm_event.ord = cm_node->ord_size; 4038 } 4039 4040 ret = cm_id->event_handler(cm_id, &cm_event); 4041 if (ret) 4042 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, ret=%d\n", 4043 __func__, __LINE__, ret); 4044 return; 4045} 4046 4047 4048static void cm_event_mpa_reject(struct nes_cm_event *event) 4049{ 4050 struct iw_cm_id *cm_id; 4051 struct iw_cm_event cm_event; 4052 struct nes_cm_node *cm_node; 4053 int ret; 4054 struct sockaddr_in *cm_event_laddr = (struct sockaddr_in *) 4055 &cm_event.local_addr; 4056 struct sockaddr_in *cm_event_raddr = (struct sockaddr_in *) 4057 &cm_event.remote_addr; 4058 4059 cm_node = event->cm_node; 4060 if (!cm_node) 4061 return; 4062 cm_id = cm_node->cm_id; 4063 4064 atomic_inc(&cm_connect_reqs); 4065 nes_debug(NES_DBG_CM, "cm_node = %p - cm_id = %p, jiffies = %lu\n", 4066 cm_node, cm_id, jiffies); 4067 4068 cm_event.event = IW_CM_EVENT_CONNECT_REPLY; 4069 cm_event.status = -ECONNREFUSED; 4070 cm_event.provider_data = cm_id->provider_data; 4071 4072 cm_event_laddr->sin_family = AF_INET; 4073 cm_event_laddr->sin_port = htons(event->cm_info.loc_port); 4074 cm_event_laddr->sin_addr.s_addr = htonl(event->cm_info.loc_addr); 4075 4076 cm_event_raddr->sin_family = AF_INET; 4077 cm_event_raddr->sin_port = htons(event->cm_info.rem_port); 4078 cm_event_raddr->sin_addr.s_addr = htonl(event->cm_info.rem_addr); 4079 4080 cm_event.private_data = cm_node->mpa_frame_buf; 4081 cm_event.private_data_len = (u8)cm_node->mpa_frame_size; 4082 4083 nes_debug(NES_DBG_CM, "call CM_EVENT_MPA_REJECTED, local_addr=%08x, " 4084 "remove_addr=%08x\n", 4085 cm_event_laddr->sin_addr.s_addr, 4086 cm_event_raddr->sin_addr.s_addr); 4087 4088 ret = cm_id->event_handler(cm_id, &cm_event); 4089 if (ret) 4090 printk(KERN_ERR "%s[%u] OFA CM event_handler returned, ret=%d\n", 4091 __func__, __LINE__, ret); 4092 4093 return; 4094} 4095 4096 4097static void nes_cm_event_handler(struct work_struct *); 4098 4099/** 4100 * nes_cm_post_event 4101 * post an event to the cm event handler 4102 */ 4103static int nes_cm_post_event(struct nes_cm_event *event) 4104{ 4105 atomic_inc(&event->cm_node->cm_core->events_posted); 4106 add_ref_cm_node(event->cm_node); 4107 event->cm_info.cm_id->add_ref(event->cm_info.cm_id); 4108 INIT_WORK(&event->event_work, nes_cm_event_handler); 4109 nes_debug(NES_DBG_CM, "cm_node=%p queue_work, event=%p\n", 4110 event->cm_node, event); 4111 4112 queue_work(event->cm_node->cm_core->event_wq, &event->event_work); 4113 4114 nes_debug(NES_DBG_CM, "Exit\n"); 4115 return 0; 4116} 4117 4118 4119/** 4120 * nes_cm_event_handler 4121 * worker function to handle cm events 4122 * will free instance of nes_cm_event 4123 */ 4124static void nes_cm_event_handler(struct work_struct *work) 4125{ 4126 struct nes_cm_event *event = container_of(work, struct nes_cm_event, 4127 event_work); 4128 struct nes_cm_core *cm_core; 4129 4130 if ((!event) || (!event->cm_node) || (!event->cm_node->cm_core)) 4131 return; 4132 4133 cm_core = event->cm_node->cm_core; 4134 nes_debug(NES_DBG_CM, "event=%p, event->type=%u, events posted=%u\n", 4135 event, event->type, atomic_read(&cm_core->events_posted)); 4136 4137 switch (event->type) { 4138 case NES_CM_EVENT_MPA_REQ: 4139 cm_event_mpa_req(event); 4140 nes_debug(NES_DBG_CM, "cm_node=%p CM Event: MPA REQUEST\n", 4141 event->cm_node); 4142 break; 4143 case NES_CM_EVENT_RESET: 4144 nes_debug(NES_DBG_CM, "cm_node = %p CM Event: RESET\n", 4145 event->cm_node); 4146 cm_event_reset(event); 4147 break; 4148 case NES_CM_EVENT_CONNECTED: 4149 if ((!event->cm_node->cm_id) || 4150 (event->cm_node->state != NES_CM_STATE_TSA)) 4151 break; 4152 cm_event_connected(event); 4153 nes_debug(NES_DBG_CM, "CM Event: CONNECTED\n"); 4154 break; 4155 case NES_CM_EVENT_MPA_REJECT: 4156 if ((!event->cm_node->cm_id) || 4157 (event->cm_node->state == NES_CM_STATE_TSA)) 4158 break; 4159 cm_event_mpa_reject(event); 4160 nes_debug(NES_DBG_CM, "CM Event: REJECT\n"); 4161 break; 4162 4163 case NES_CM_EVENT_ABORTED: 4164 if ((!event->cm_node->cm_id) || 4165 (event->cm_node->state == NES_CM_STATE_TSA)) 4166 break; 4167 cm_event_connect_error(event); 4168 nes_debug(NES_DBG_CM, "CM Event: ABORTED\n"); 4169 break; 4170 case NES_CM_EVENT_DROPPED_PKT: 4171 nes_debug(NES_DBG_CM, "CM Event: DROPPED PKT\n"); 4172 break; 4173 default: 4174 nes_debug(NES_DBG_CM, "CM Event: UNKNOWN EVENT TYPE\n"); 4175 break; 4176 } 4177 4178 atomic_dec(&cm_core->events_posted); 4179 event->cm_info.cm_id->rem_ref(event->cm_info.cm_id); 4180 rem_ref_cm_node(cm_core, event->cm_node); 4181 kfree(event); 4182 4183 return; 4184} 4185