PageRenderTime 2446ms CodeModel.GetById 23ms RepoModel.GetById 2ms app.codeStats 1ms

/drivers/infiniband/hw/nes/nes_cm.c

https://bitbucket.org/abioy/linux
C | 3691 lines | 2842 code | 524 blank | 325 comment | 358 complexity | 59376caec3b2af1b2fa625e2df5cd44b MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0

Large files files are truncated, but you can click here to view the full file

  1. /*
  2. * Copyright (c) 2006 - 2009 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. #define TCPOPT_TIMESTAMP 8
  34. #include <asm/atomic.h>
  35. #include <linux/skbuff.h>
  36. #include <linux/ip.h>
  37. #include <linux/tcp.h>
  38. #include <linux/init.h>
  39. #include <linux/if_arp.h>
  40. #include <linux/if_vlan.h>
  41. #include <linux/notifier.h>
  42. #include <linux/net.h>
  43. #include <linux/types.h>
  44. #include <linux/timer.h>
  45. #include <linux/time.h>
  46. #include <linux/delay.h>
  47. #include <linux/etherdevice.h>
  48. #include <linux/netdevice.h>
  49. #include <linux/random.h>
  50. #include <linux/list.h>
  51. #include <linux/threads.h>
  52. #include <linux/highmem.h>
  53. #include <linux/slab.h>
  54. #include <net/arp.h>
  55. #include <net/neighbour.h>
  56. #include <net/route.h>
  57. #include <net/ip_fib.h>
  58. #include <net/tcp.h>
  59. #include "nes.h"
  60. u32 cm_packets_sent;
  61. u32 cm_packets_bounced;
  62. u32 cm_packets_dropped;
  63. u32 cm_packets_retrans;
  64. u32 cm_packets_created;
  65. u32 cm_packets_received;
  66. atomic_t cm_listens_created;
  67. atomic_t cm_listens_destroyed;
  68. u32 cm_backlog_drops;
  69. atomic_t cm_loopbacks;
  70. atomic_t cm_nodes_created;
  71. atomic_t cm_nodes_destroyed;
  72. atomic_t cm_accel_dropped_pkts;
  73. atomic_t cm_resets_recvd;
  74. static inline int mini_cm_accelerated(struct nes_cm_core *,
  75. struct nes_cm_node *);
  76. static struct nes_cm_listener *mini_cm_listen(struct nes_cm_core *,
  77. struct nes_vnic *, struct nes_cm_info *);
  78. static int mini_cm_del_listen(struct nes_cm_core *, struct nes_cm_listener *);
  79. static struct nes_cm_node *mini_cm_connect(struct nes_cm_core *,
  80. struct nes_vnic *, u16, void *, struct nes_cm_info *);
  81. static int mini_cm_close(struct nes_cm_core *, struct nes_cm_node *);
  82. static int mini_cm_accept(struct nes_cm_core *, struct ietf_mpa_frame *,
  83. struct nes_cm_node *);
  84. static int mini_cm_reject(struct nes_cm_core *, struct ietf_mpa_frame *,
  85. struct nes_cm_node *);
  86. static int mini_cm_recv_pkt(struct nes_cm_core *, struct nes_vnic *,
  87. struct sk_buff *);
  88. static int mini_cm_dealloc_core(struct nes_cm_core *);
  89. static int mini_cm_get(struct nes_cm_core *);
  90. static int mini_cm_set(struct nes_cm_core *, u32, u32);
  91. static void form_cm_frame(struct sk_buff *, struct nes_cm_node *,
  92. void *, u32, void *, u32, u8);
  93. static int add_ref_cm_node(struct nes_cm_node *);
  94. static int rem_ref_cm_node(struct nes_cm_core *, struct nes_cm_node *);
  95. static int nes_cm_disconn_true(struct nes_qp *);
  96. static int nes_cm_post_event(struct nes_cm_event *event);
  97. static int nes_disconnect(struct nes_qp *nesqp, int abrupt);
  98. static void nes_disconnect_worker(struct work_struct *work);
  99. static int send_mpa_request(struct nes_cm_node *, struct sk_buff *);
  100. static int send_mpa_reject(struct nes_cm_node *);
  101. static int send_syn(struct nes_cm_node *, u32, struct sk_buff *);
  102. static int send_reset(struct nes_cm_node *, struct sk_buff *);
  103. static int send_ack(struct nes_cm_node *cm_node, struct sk_buff *skb);
  104. static int send_fin(struct nes_cm_node *cm_node, struct sk_buff *skb);
  105. static void process_packet(struct nes_cm_node *, struct sk_buff *,
  106. struct nes_cm_core *);
  107. static void active_open_err(struct nes_cm_node *, struct sk_buff *, int);
  108. static void passive_open_err(struct nes_cm_node *, struct sk_buff *, int);
  109. static void cleanup_retrans_entry(struct nes_cm_node *);
  110. static void handle_rcv_mpa(struct nes_cm_node *, struct sk_buff *);
  111. static void free_retrans_entry(struct nes_cm_node *cm_node);
  112. static int handle_tcp_options(struct nes_cm_node *cm_node, struct tcphdr *tcph,
  113. struct sk_buff *skb, int optionsize, int passive);
  114. /* CM event handler functions */
  115. static void cm_event_connected(struct nes_cm_event *);
  116. static void cm_event_connect_error(struct nes_cm_event *);
  117. static void cm_event_reset(struct nes_cm_event *);
  118. static void cm_event_mpa_req(struct nes_cm_event *);
  119. static void cm_event_mpa_reject(struct nes_cm_event *);
  120. static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node);
  121. static void print_core(struct nes_cm_core *core);
  122. /* External CM API Interface */
  123. /* instance of function pointers for client API */
  124. /* set address of this instance to cm_core->cm_ops at cm_core alloc */
  125. static struct nes_cm_ops nes_cm_api = {
  126. mini_cm_accelerated,
  127. mini_cm_listen,
  128. mini_cm_del_listen,
  129. mini_cm_connect,
  130. mini_cm_close,
  131. mini_cm_accept,
  132. mini_cm_reject,
  133. mini_cm_recv_pkt,
  134. mini_cm_dealloc_core,
  135. mini_cm_get,
  136. mini_cm_set
  137. };
  138. static struct nes_cm_core *g_cm_core;
  139. atomic_t cm_connects;
  140. atomic_t cm_accepts;
  141. atomic_t cm_disconnects;
  142. atomic_t cm_closes;
  143. atomic_t cm_connecteds;
  144. atomic_t cm_connect_reqs;
  145. atomic_t cm_rejects;
  146. /**
  147. * create_event
  148. */
  149. static struct nes_cm_event *create_event(struct nes_cm_node *cm_node,
  150. enum nes_cm_event_type type)
  151. {
  152. struct nes_cm_event *event;
  153. if (!cm_node->cm_id)
  154. return NULL;
  155. /* allocate an empty event */
  156. event = kzalloc(sizeof(*event), GFP_ATOMIC);
  157. if (!event)
  158. return NULL;
  159. event->type = type;
  160. event->cm_node = cm_node;
  161. event->cm_info.rem_addr = cm_node->rem_addr;
  162. event->cm_info.loc_addr = cm_node->loc_addr;
  163. event->cm_info.rem_port = cm_node->rem_port;
  164. event->cm_info.loc_port = cm_node->loc_port;
  165. event->cm_info.cm_id = cm_node->cm_id;
  166. nes_debug(NES_DBG_CM, "cm_node=%p Created event=%p, type=%u, "
  167. "dst_addr=%08x[%x], src_addr=%08x[%x]\n",
  168. cm_node, event, type, event->cm_info.loc_addr,
  169. event->cm_info.loc_port, event->cm_info.rem_addr,
  170. event->cm_info.rem_port);
  171. nes_cm_post_event(event);
  172. return event;
  173. }
  174. /**
  175. * send_mpa_request
  176. */
  177. static int send_mpa_request(struct nes_cm_node *cm_node, struct sk_buff *skb)
  178. {
  179. if (!skb) {
  180. nes_debug(NES_DBG_CM, "skb set to NULL\n");
  181. return -1;
  182. }
  183. /* send an MPA Request frame */
  184. form_cm_frame(skb, cm_node, NULL, 0, &cm_node->mpa_frame,
  185. cm_node->mpa_frame_size, SET_ACK);
  186. return schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0);
  187. }
  188. static int send_mpa_reject(struct nes_cm_node *cm_node)
  189. {
  190. struct sk_buff *skb = NULL;
  191. skb = dev_alloc_skb(MAX_CM_BUFFER);
  192. if (!skb) {
  193. nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n");
  194. return -ENOMEM;
  195. }
  196. /* send an MPA reject frame */
  197. form_cm_frame(skb, cm_node, NULL, 0, &cm_node->mpa_frame,
  198. cm_node->mpa_frame_size, SET_ACK | SET_FIN);
  199. cm_node->state = NES_CM_STATE_FIN_WAIT1;
  200. return schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0);
  201. }
  202. /**
  203. * recv_mpa - process a received TCP pkt, we are expecting an
  204. * IETF MPA frame
  205. */
  206. static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
  207. u32 len)
  208. {
  209. struct ietf_mpa_frame *mpa_frame;
  210. *type = NES_MPA_REQUEST_ACCEPT;
  211. /* assume req frame is in tcp data payload */
  212. if (len < sizeof(struct ietf_mpa_frame)) {
  213. nes_debug(NES_DBG_CM, "The received ietf buffer was too small (%x)\n", len);
  214. return -EINVAL;
  215. }
  216. mpa_frame = (struct ietf_mpa_frame *)buffer;
  217. cm_node->mpa_frame_size = ntohs(mpa_frame->priv_data_len);
  218. /* make sure mpa private data len is less than 512 bytes */
  219. if (cm_node->mpa_frame_size > IETF_MAX_PRIV_DATA_LEN) {
  220. nes_debug(NES_DBG_CM, "The received Length of Private"
  221. " Data field exceeds 512 octets\n");
  222. return -EINVAL;
  223. }
  224. /*
  225. * make sure MPA receiver interoperate with the
  226. * received MPA version and MPA key information
  227. *
  228. */
  229. if (mpa_frame->rev != mpa_version) {
  230. nes_debug(NES_DBG_CM, "The received mpa version"
  231. " can not be interoperated\n");
  232. return -EINVAL;
  233. }
  234. if (cm_node->state != NES_CM_STATE_MPAREQ_SENT) {
  235. if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REQ, IETF_MPA_KEY_SIZE)) {
  236. nes_debug(NES_DBG_CM, "Unexpected MPA Key received \n");
  237. return -EINVAL;
  238. }
  239. } else {
  240. if (memcmp(mpa_frame->key, IEFT_MPA_KEY_REP, IETF_MPA_KEY_SIZE)) {
  241. nes_debug(NES_DBG_CM, "Unexpected MPA Key received \n");
  242. return -EINVAL;
  243. }
  244. }
  245. if (cm_node->mpa_frame_size + sizeof(struct ietf_mpa_frame) != len) {
  246. nes_debug(NES_DBG_CM, "The received ietf buffer was not right"
  247. " complete (%x + %x != %x)\n",
  248. cm_node->mpa_frame_size,
  249. (u32)sizeof(struct ietf_mpa_frame), len);
  250. return -EINVAL;
  251. }
  252. /* make sure it does not exceed the max size */
  253. if (len > MAX_CM_BUFFER) {
  254. nes_debug(NES_DBG_CM, "The received ietf buffer was too large"
  255. " (%x + %x != %x)\n",
  256. cm_node->mpa_frame_size,
  257. (u32)sizeof(struct ietf_mpa_frame), len);
  258. return -EINVAL;
  259. }
  260. /* copy entire MPA frame to our cm_node's frame */
  261. memcpy(cm_node->mpa_frame_buf, buffer + sizeof(struct ietf_mpa_frame),
  262. cm_node->mpa_frame_size);
  263. if (mpa_frame->flags & IETF_MPA_FLAGS_REJECT)
  264. *type = NES_MPA_REQUEST_REJECT;
  265. return 0;
  266. }
  267. /**
  268. * form_cm_frame - get a free packet and build empty frame Use
  269. * node info to build.
  270. */
  271. static void form_cm_frame(struct sk_buff *skb,
  272. struct nes_cm_node *cm_node, void *options, u32 optionsize,
  273. void *data, u32 datasize, u8 flags)
  274. {
  275. struct tcphdr *tcph;
  276. struct iphdr *iph;
  277. struct ethhdr *ethh;
  278. u8 *buf;
  279. u16 packetsize = sizeof(*iph);
  280. packetsize += sizeof(*tcph);
  281. packetsize += optionsize + datasize;
  282. memset(skb->data, 0x00, ETH_HLEN + sizeof(*iph) + sizeof(*tcph));
  283. skb->len = 0;
  284. buf = skb_put(skb, packetsize + ETH_HLEN);
  285. ethh = (struct ethhdr *) buf;
  286. buf += ETH_HLEN;
  287. iph = (struct iphdr *)buf;
  288. buf += sizeof(*iph);
  289. tcph = (struct tcphdr *)buf;
  290. skb_reset_mac_header(skb);
  291. skb_set_network_header(skb, ETH_HLEN);
  292. skb_set_transport_header(skb, ETH_HLEN+sizeof(*iph));
  293. buf += sizeof(*tcph);
  294. skb->ip_summed = CHECKSUM_PARTIAL;
  295. skb->protocol = htons(0x800);
  296. skb->data_len = 0;
  297. skb->mac_len = ETH_HLEN;
  298. memcpy(ethh->h_dest, cm_node->rem_mac, ETH_ALEN);
  299. memcpy(ethh->h_source, cm_node->loc_mac, ETH_ALEN);
  300. ethh->h_proto = htons(0x0800);
  301. iph->version = IPVERSION;
  302. iph->ihl = 5; /* 5 * 4Byte words, IP headr len */
  303. iph->tos = 0;
  304. iph->tot_len = htons(packetsize);
  305. iph->id = htons(++cm_node->tcp_cntxt.loc_id);
  306. iph->frag_off = htons(0x4000);
  307. iph->ttl = 0x40;
  308. iph->protocol = 0x06; /* IPPROTO_TCP */
  309. iph->saddr = htonl(cm_node->loc_addr);
  310. iph->daddr = htonl(cm_node->rem_addr);
  311. tcph->source = htons(cm_node->loc_port);
  312. tcph->dest = htons(cm_node->rem_port);
  313. tcph->seq = htonl(cm_node->tcp_cntxt.loc_seq_num);
  314. if (flags & SET_ACK) {
  315. cm_node->tcp_cntxt.loc_ack_num = cm_node->tcp_cntxt.rcv_nxt;
  316. tcph->ack_seq = htonl(cm_node->tcp_cntxt.loc_ack_num);
  317. tcph->ack = 1;
  318. } else
  319. tcph->ack_seq = 0;
  320. if (flags & SET_SYN) {
  321. cm_node->tcp_cntxt.loc_seq_num++;
  322. tcph->syn = 1;
  323. } else
  324. cm_node->tcp_cntxt.loc_seq_num += datasize;
  325. if (flags & SET_FIN) {
  326. cm_node->tcp_cntxt.loc_seq_num++;
  327. tcph->fin = 1;
  328. }
  329. if (flags & SET_RST)
  330. tcph->rst = 1;
  331. tcph->doff = (u16)((sizeof(*tcph) + optionsize + 3) >> 2);
  332. tcph->window = htons(cm_node->tcp_cntxt.rcv_wnd);
  333. tcph->urg_ptr = 0;
  334. if (optionsize)
  335. memcpy(buf, options, optionsize);
  336. buf += optionsize;
  337. if (datasize)
  338. memcpy(buf, data, datasize);
  339. skb_shinfo(skb)->nr_frags = 0;
  340. cm_packets_created++;
  341. }
  342. /**
  343. * print_core - dump a cm core
  344. */
  345. static void print_core(struct nes_cm_core *core)
  346. {
  347. nes_debug(NES_DBG_CM, "---------------------------------------------\n");
  348. nes_debug(NES_DBG_CM, "CM Core -- (core = %p )\n", core);
  349. if (!core)
  350. return;
  351. nes_debug(NES_DBG_CM, "---------------------------------------------\n");
  352. nes_debug(NES_DBG_CM, "State : %u \n", core->state);
  353. nes_debug(NES_DBG_CM, "Listen Nodes : %u \n", atomic_read(&core->listen_node_cnt));
  354. nes_debug(NES_DBG_CM, "Active Nodes : %u \n", atomic_read(&core->node_cnt));
  355. nes_debug(NES_DBG_CM, "core : %p \n", core);
  356. nes_debug(NES_DBG_CM, "-------------- end core ---------------\n");
  357. }
  358. /**
  359. * schedule_nes_timer
  360. * note - cm_node needs to be protected before calling this. Encase in:
  361. * rem_ref_cm_node(cm_core, cm_node);add_ref_cm_node(cm_node);
  362. */
  363. int schedule_nes_timer(struct nes_cm_node *cm_node, struct sk_buff *skb,
  364. enum nes_timer_type type, int send_retrans,
  365. int close_when_complete)
  366. {
  367. unsigned long flags;
  368. struct nes_cm_core *cm_core = cm_node->cm_core;
  369. struct nes_timer_entry *new_send;
  370. int ret = 0;
  371. u32 was_timer_set;
  372. new_send = kzalloc(sizeof(*new_send), GFP_ATOMIC);
  373. if (!new_send)
  374. return -ENOMEM;
  375. /* new_send->timetosend = currenttime */
  376. new_send->retrycount = NES_DEFAULT_RETRYS;
  377. new_send->retranscount = NES_DEFAULT_RETRANS;
  378. new_send->skb = skb;
  379. new_send->timetosend = jiffies;
  380. new_send->type = type;
  381. new_send->netdev = cm_node->netdev;
  382. new_send->send_retrans = send_retrans;
  383. new_send->close_when_complete = close_when_complete;
  384. if (type == NES_TIMER_TYPE_CLOSE) {
  385. new_send->timetosend += (HZ/10);
  386. if (cm_node->recv_entry) {
  387. kfree(new_send);
  388. WARN_ON(1);
  389. return -EINVAL;
  390. }
  391. cm_node->recv_entry = new_send;
  392. }
  393. if (type == NES_TIMER_TYPE_SEND) {
  394. new_send->seq_num = ntohl(tcp_hdr(skb)->seq);
  395. atomic_inc(&new_send->skb->users);
  396. spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
  397. cm_node->send_entry = new_send;
  398. add_ref_cm_node(cm_node);
  399. spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
  400. new_send->timetosend = jiffies + NES_RETRY_TIMEOUT;
  401. ret = nes_nic_cm_xmit(new_send->skb, cm_node->netdev);
  402. if (ret != NETDEV_TX_OK) {
  403. nes_debug(NES_DBG_CM, "Error sending packet %p "
  404. "(jiffies = %lu)\n", new_send, jiffies);
  405. new_send->timetosend = jiffies;
  406. ret = NETDEV_TX_OK;
  407. } else {
  408. cm_packets_sent++;
  409. if (!send_retrans) {
  410. cleanup_retrans_entry(cm_node);
  411. if (close_when_complete)
  412. rem_ref_cm_node(cm_core, cm_node);
  413. return ret;
  414. }
  415. }
  416. }
  417. was_timer_set = timer_pending(&cm_core->tcp_timer);
  418. if (!was_timer_set) {
  419. cm_core->tcp_timer.expires = new_send->timetosend;
  420. add_timer(&cm_core->tcp_timer);
  421. }
  422. return ret;
  423. }
  424. static void nes_retrans_expired(struct nes_cm_node *cm_node)
  425. {
  426. struct iw_cm_id *cm_id = cm_node->cm_id;
  427. switch (cm_node->state) {
  428. case NES_CM_STATE_SYN_RCVD:
  429. case NES_CM_STATE_CLOSING:
  430. rem_ref_cm_node(cm_node->cm_core, cm_node);
  431. break;
  432. case NES_CM_STATE_LAST_ACK:
  433. case NES_CM_STATE_FIN_WAIT1:
  434. if (cm_node->cm_id)
  435. cm_id->rem_ref(cm_id);
  436. cm_node->state = NES_CM_STATE_CLOSED;
  437. send_reset(cm_node, NULL);
  438. break;
  439. default:
  440. add_ref_cm_node(cm_node);
  441. send_reset(cm_node, NULL);
  442. create_event(cm_node, NES_CM_EVENT_ABORTED);
  443. }
  444. }
  445. static void handle_recv_entry(struct nes_cm_node *cm_node, u32 rem_node)
  446. {
  447. struct nes_timer_entry *recv_entry = cm_node->recv_entry;
  448. struct iw_cm_id *cm_id = cm_node->cm_id;
  449. struct nes_qp *nesqp;
  450. unsigned long qplockflags;
  451. if (!recv_entry)
  452. return;
  453. nesqp = (struct nes_qp *)recv_entry->skb;
  454. if (nesqp) {
  455. spin_lock_irqsave(&nesqp->lock, qplockflags);
  456. if (nesqp->cm_id) {
  457. nes_debug(NES_DBG_CM, "QP%u: cm_id = %p, "
  458. "refcount = %d: HIT A "
  459. "NES_TIMER_TYPE_CLOSE with something "
  460. "to do!!!\n", nesqp->hwqp.qp_id, cm_id,
  461. atomic_read(&nesqp->refcount));
  462. nesqp->hw_tcp_state = NES_AEQE_TCP_STATE_CLOSED;
  463. nesqp->last_aeq = NES_AEQE_AEID_RESET_SENT;
  464. nesqp->ibqp_state = IB_QPS_ERR;
  465. spin_unlock_irqrestore(&nesqp->lock, qplockflags);
  466. nes_cm_disconn(nesqp);
  467. } else {
  468. spin_unlock_irqrestore(&nesqp->lock, qplockflags);
  469. nes_debug(NES_DBG_CM, "QP%u: cm_id = %p, "
  470. "refcount = %d: HIT A "
  471. "NES_TIMER_TYPE_CLOSE with nothing "
  472. "to do!!!\n", nesqp->hwqp.qp_id, cm_id,
  473. atomic_read(&nesqp->refcount));
  474. }
  475. } else if (rem_node) {
  476. /* TIME_WAIT state */
  477. rem_ref_cm_node(cm_node->cm_core, cm_node);
  478. }
  479. if (cm_node->cm_id)
  480. cm_id->rem_ref(cm_id);
  481. kfree(recv_entry);
  482. cm_node->recv_entry = NULL;
  483. }
  484. /**
  485. * nes_cm_timer_tick
  486. */
  487. static void nes_cm_timer_tick(unsigned long pass)
  488. {
  489. unsigned long flags;
  490. unsigned long nexttimeout = jiffies + NES_LONG_TIME;
  491. struct nes_cm_node *cm_node;
  492. struct nes_timer_entry *send_entry, *recv_entry;
  493. struct list_head *list_core_temp;
  494. struct list_head *list_node;
  495. struct nes_cm_core *cm_core = g_cm_core;
  496. u32 settimer = 0;
  497. unsigned long timetosend;
  498. int ret = NETDEV_TX_OK;
  499. struct list_head timer_list;
  500. INIT_LIST_HEAD(&timer_list);
  501. spin_lock_irqsave(&cm_core->ht_lock, flags);
  502. list_for_each_safe(list_node, list_core_temp,
  503. &cm_core->connected_nodes) {
  504. cm_node = container_of(list_node, struct nes_cm_node, list);
  505. if ((cm_node->recv_entry) || (cm_node->send_entry)) {
  506. add_ref_cm_node(cm_node);
  507. list_add(&cm_node->timer_entry, &timer_list);
  508. }
  509. }
  510. spin_unlock_irqrestore(&cm_core->ht_lock, flags);
  511. list_for_each_safe(list_node, list_core_temp, &timer_list) {
  512. cm_node = container_of(list_node, struct nes_cm_node,
  513. timer_entry);
  514. recv_entry = cm_node->recv_entry;
  515. if (recv_entry) {
  516. if (time_after(recv_entry->timetosend, jiffies)) {
  517. if (nexttimeout > recv_entry->timetosend ||
  518. !settimer) {
  519. nexttimeout = recv_entry->timetosend;
  520. settimer = 1;
  521. }
  522. } else
  523. handle_recv_entry(cm_node, 1);
  524. }
  525. spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
  526. do {
  527. send_entry = cm_node->send_entry;
  528. if (!send_entry)
  529. break;
  530. if (time_after(send_entry->timetosend, jiffies)) {
  531. if (cm_node->state != NES_CM_STATE_TSA) {
  532. if ((nexttimeout >
  533. send_entry->timetosend) ||
  534. !settimer) {
  535. nexttimeout =
  536. send_entry->timetosend;
  537. settimer = 1;
  538. }
  539. } else {
  540. free_retrans_entry(cm_node);
  541. }
  542. break;
  543. }
  544. if ((cm_node->state == NES_CM_STATE_TSA) ||
  545. (cm_node->state == NES_CM_STATE_CLOSED)) {
  546. free_retrans_entry(cm_node);
  547. break;
  548. }
  549. if (!send_entry->retranscount ||
  550. !send_entry->retrycount) {
  551. cm_packets_dropped++;
  552. free_retrans_entry(cm_node);
  553. spin_unlock_irqrestore(
  554. &cm_node->retrans_list_lock, flags);
  555. nes_retrans_expired(cm_node);
  556. cm_node->state = NES_CM_STATE_CLOSED;
  557. spin_lock_irqsave(&cm_node->retrans_list_lock,
  558. flags);
  559. break;
  560. }
  561. atomic_inc(&send_entry->skb->users);
  562. cm_packets_retrans++;
  563. nes_debug(NES_DBG_CM, "Retransmitting send_entry %p "
  564. "for node %p, jiffies = %lu, time to send = "
  565. "%lu, retranscount = %u, send_entry->seq_num = "
  566. "0x%08X, cm_node->tcp_cntxt.rem_ack_num = "
  567. "0x%08X\n", send_entry, cm_node, jiffies,
  568. send_entry->timetosend,
  569. send_entry->retranscount,
  570. send_entry->seq_num,
  571. cm_node->tcp_cntxt.rem_ack_num);
  572. spin_unlock_irqrestore(&cm_node->retrans_list_lock,
  573. flags);
  574. ret = nes_nic_cm_xmit(send_entry->skb, cm_node->netdev);
  575. spin_lock_irqsave(&cm_node->retrans_list_lock, flags);
  576. if (ret != NETDEV_TX_OK) {
  577. nes_debug(NES_DBG_CM, "rexmit failed for "
  578. "node=%p\n", cm_node);
  579. cm_packets_bounced++;
  580. send_entry->retrycount--;
  581. nexttimeout = jiffies + NES_SHORT_TIME;
  582. settimer = 1;
  583. break;
  584. } else {
  585. cm_packets_sent++;
  586. }
  587. nes_debug(NES_DBG_CM, "Packet Sent: retrans count = "
  588. "%u, retry count = %u.\n",
  589. send_entry->retranscount,
  590. send_entry->retrycount);
  591. if (send_entry->send_retrans) {
  592. send_entry->retranscount--;
  593. timetosend = (NES_RETRY_TIMEOUT <<
  594. (NES_DEFAULT_RETRANS - send_entry->retranscount));
  595. send_entry->timetosend = jiffies +
  596. min(timetosend, NES_MAX_TIMEOUT);
  597. if (nexttimeout > send_entry->timetosend ||
  598. !settimer) {
  599. nexttimeout = send_entry->timetosend;
  600. settimer = 1;
  601. }
  602. } else {
  603. int close_when_complete;
  604. close_when_complete =
  605. send_entry->close_when_complete;
  606. nes_debug(NES_DBG_CM, "cm_node=%p state=%d\n",
  607. cm_node, cm_node->state);
  608. free_retrans_entry(cm_node);
  609. if (close_when_complete)
  610. rem_ref_cm_node(cm_node->cm_core,
  611. cm_node);
  612. }
  613. } while (0);
  614. spin_unlock_irqrestore(&cm_node->retrans_list_lock, flags);
  615. rem_ref_cm_node(cm_node->cm_core, cm_node);
  616. }
  617. if (settimer) {
  618. if (!timer_pending(&cm_core->tcp_timer)) {
  619. cm_core->tcp_timer.expires = nexttimeout;
  620. add_timer(&cm_core->tcp_timer);
  621. }
  622. }
  623. }
  624. /**
  625. * send_syn
  626. */
  627. static int send_syn(struct nes_cm_node *cm_node, u32 sendack,
  628. struct sk_buff *skb)
  629. {
  630. int ret;
  631. int flags = SET_SYN;
  632. char optionsbuffer[sizeof(struct option_mss) +
  633. sizeof(struct option_windowscale) + sizeof(struct option_base) +
  634. TCP_OPTIONS_PADDING];
  635. int optionssize = 0;
  636. /* Sending MSS option */
  637. union all_known_options *options;
  638. if (!cm_node)
  639. return -EINVAL;
  640. options = (union all_known_options *)&optionsbuffer[optionssize];
  641. options->as_mss.optionnum = OPTION_NUMBER_MSS;
  642. options->as_mss.length = sizeof(struct option_mss);
  643. options->as_mss.mss = htons(cm_node->tcp_cntxt.mss);
  644. optionssize += sizeof(struct option_mss);
  645. options = (union all_known_options *)&optionsbuffer[optionssize];
  646. options->as_windowscale.optionnum = OPTION_NUMBER_WINDOW_SCALE;
  647. options->as_windowscale.length = sizeof(struct option_windowscale);
  648. options->as_windowscale.shiftcount = cm_node->tcp_cntxt.rcv_wscale;
  649. optionssize += sizeof(struct option_windowscale);
  650. if (sendack && !(NES_DRV_OPT_SUPRESS_OPTION_BC & nes_drv_opt)) {
  651. options = (union all_known_options *)&optionsbuffer[optionssize];
  652. options->as_base.optionnum = OPTION_NUMBER_WRITE0;
  653. options->as_base.length = sizeof(struct option_base);
  654. optionssize += sizeof(struct option_base);
  655. /* we need the size to be a multiple of 4 */
  656. options = (union all_known_options *)&optionsbuffer[optionssize];
  657. options->as_end = 1;
  658. optionssize += 1;
  659. options = (union all_known_options *)&optionsbuffer[optionssize];
  660. options->as_end = 1;
  661. optionssize += 1;
  662. }
  663. options = (union all_known_options *)&optionsbuffer[optionssize];
  664. options->as_end = OPTION_NUMBER_END;
  665. optionssize += 1;
  666. if (!skb)
  667. skb = dev_alloc_skb(MAX_CM_BUFFER);
  668. if (!skb) {
  669. nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n");
  670. return -1;
  671. }
  672. if (sendack)
  673. flags |= SET_ACK;
  674. form_cm_frame(skb, cm_node, optionsbuffer, optionssize, NULL, 0, flags);
  675. ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0);
  676. return ret;
  677. }
  678. /**
  679. * send_reset
  680. */
  681. static int send_reset(struct nes_cm_node *cm_node, struct sk_buff *skb)
  682. {
  683. int ret;
  684. int flags = SET_RST | SET_ACK;
  685. if (!skb)
  686. skb = dev_alloc_skb(MAX_CM_BUFFER);
  687. if (!skb) {
  688. nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n");
  689. return -ENOMEM;
  690. }
  691. form_cm_frame(skb, cm_node, NULL, 0, NULL, 0, flags);
  692. ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 0, 1);
  693. return ret;
  694. }
  695. /**
  696. * send_ack
  697. */
  698. static int send_ack(struct nes_cm_node *cm_node, struct sk_buff *skb)
  699. {
  700. int ret;
  701. if (!skb)
  702. skb = dev_alloc_skb(MAX_CM_BUFFER);
  703. if (!skb) {
  704. nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n");
  705. return -1;
  706. }
  707. form_cm_frame(skb, cm_node, NULL, 0, NULL, 0, SET_ACK);
  708. ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 0, 0);
  709. return ret;
  710. }
  711. /**
  712. * send_fin
  713. */
  714. static int send_fin(struct nes_cm_node *cm_node, struct sk_buff *skb)
  715. {
  716. int ret;
  717. /* if we didn't get a frame get one */
  718. if (!skb)
  719. skb = dev_alloc_skb(MAX_CM_BUFFER);
  720. if (!skb) {
  721. nes_debug(NES_DBG_CM, "Failed to get a Free pkt\n");
  722. return -1;
  723. }
  724. form_cm_frame(skb, cm_node, NULL, 0, NULL, 0, SET_ACK | SET_FIN);
  725. ret = schedule_nes_timer(cm_node, skb, NES_TIMER_TYPE_SEND, 1, 0);
  726. return ret;
  727. }
  728. /**
  729. * find_node - find a cm node that matches the reference cm node
  730. */
  731. static struct nes_cm_node *find_node(struct nes_cm_core *cm_core,
  732. u16 rem_port, nes_addr_t rem_addr, u16 loc_port, nes_addr_t loc_addr)
  733. {
  734. unsigned long flags;
  735. struct list_head *hte;
  736. struct nes_cm_node *cm_node;
  737. /* get a handle on the hte */
  738. hte = &cm_core->connected_nodes;
  739. /* walk list and find cm_node associated with this session ID */
  740. spin_lock_irqsave(&cm_core->ht_lock, flags);
  741. list_for_each_entry(cm_node, hte, list) {
  742. /* compare quad, return node handle if a match */
  743. nes_debug(NES_DBG_CM, "finding node %x:%x =? %x:%x ^ %x:%x =? %x:%x\n",
  744. cm_node->loc_addr, cm_node->loc_port,
  745. loc_addr, loc_port,
  746. cm_node->rem_addr, cm_node->rem_port,
  747. rem_addr, rem_port);
  748. if ((cm_node->loc_addr == loc_addr) && (cm_node->loc_port == loc_port) &&
  749. (cm_node->rem_addr == rem_addr) && (cm_node->rem_port == rem_port)) {
  750. add_ref_cm_node(cm_node);
  751. spin_unlock_irqrestore(&cm_core->ht_lock, flags);
  752. return cm_node;
  753. }
  754. }
  755. spin_unlock_irqrestore(&cm_core->ht_lock, flags);
  756. /* no owner node */
  757. return NULL;
  758. }
  759. /**
  760. * find_listener - find a cm node listening on this addr-port pair
  761. */
  762. static struct nes_cm_listener *find_listener(struct nes_cm_core *cm_core,
  763. nes_addr_t dst_addr, u16 dst_port, enum nes_cm_listener_state listener_state)
  764. {
  765. unsigned long flags;
  766. struct nes_cm_listener *listen_node;
  767. /* walk list and find cm_node associated with this session ID */
  768. spin_lock_irqsave(&cm_core->listen_list_lock, flags);
  769. list_for_each_entry(listen_node, &cm_core->listen_list.list, list) {
  770. /* compare node pair, return node handle if a match */
  771. if (((listen_node->loc_addr == dst_addr) ||
  772. listen_node->loc_addr == 0x00000000) &&
  773. (listen_node->loc_port == dst_port) &&
  774. (listener_state & listen_node->listener_state)) {
  775. atomic_inc(&listen_node->ref_count);
  776. spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
  777. return listen_node;
  778. }
  779. }
  780. spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
  781. /* no listener */
  782. return NULL;
  783. }
  784. /**
  785. * add_hte_node - add a cm node to the hash table
  786. */
  787. static int add_hte_node(struct nes_cm_core *cm_core, struct nes_cm_node *cm_node)
  788. {
  789. unsigned long flags;
  790. struct list_head *hte;
  791. if (!cm_node || !cm_core)
  792. return -EINVAL;
  793. nes_debug(NES_DBG_CM, "Adding Node %p to Active Connection HT\n",
  794. cm_node);
  795. spin_lock_irqsave(&cm_core->ht_lock, flags);
  796. /* get a handle on the hash table element (list head for this slot) */
  797. hte = &cm_core->connected_nodes;
  798. list_add_tail(&cm_node->list, hte);
  799. atomic_inc(&cm_core->ht_node_cnt);
  800. spin_unlock_irqrestore(&cm_core->ht_lock, flags);
  801. return 0;
  802. }
  803. /**
  804. * mini_cm_dec_refcnt_listen
  805. */
  806. static int mini_cm_dec_refcnt_listen(struct nes_cm_core *cm_core,
  807. struct nes_cm_listener *listener, int free_hanging_nodes)
  808. {
  809. int ret = -EINVAL;
  810. int err = 0;
  811. unsigned long flags;
  812. struct list_head *list_pos = NULL;
  813. struct list_head *list_temp = NULL;
  814. struct nes_cm_node *cm_node = NULL;
  815. struct list_head reset_list;
  816. nes_debug(NES_DBG_CM, "attempting listener= %p free_nodes= %d, "
  817. "refcnt=%d\n", listener, free_hanging_nodes,
  818. atomic_read(&listener->ref_count));
  819. /* free non-accelerated child nodes for this listener */
  820. INIT_LIST_HEAD(&reset_list);
  821. if (free_hanging_nodes) {
  822. spin_lock_irqsave(&cm_core->ht_lock, flags);
  823. list_for_each_safe(list_pos, list_temp,
  824. &g_cm_core->connected_nodes) {
  825. cm_node = container_of(list_pos, struct nes_cm_node,
  826. list);
  827. if ((cm_node->listener == listener) &&
  828. (!cm_node->accelerated)) {
  829. add_ref_cm_node(cm_node);
  830. list_add(&cm_node->reset_entry, &reset_list);
  831. }
  832. }
  833. spin_unlock_irqrestore(&cm_core->ht_lock, flags);
  834. }
  835. list_for_each_safe(list_pos, list_temp, &reset_list) {
  836. cm_node = container_of(list_pos, struct nes_cm_node,
  837. reset_entry);
  838. {
  839. struct nes_cm_node *loopback = cm_node->loopbackpartner;
  840. enum nes_cm_node_state old_state;
  841. if (NES_CM_STATE_FIN_WAIT1 <= cm_node->state) {
  842. rem_ref_cm_node(cm_node->cm_core, cm_node);
  843. } else {
  844. if (!loopback) {
  845. cleanup_retrans_entry(cm_node);
  846. err = send_reset(cm_node, NULL);
  847. if (err) {
  848. cm_node->state =
  849. NES_CM_STATE_CLOSED;
  850. WARN_ON(1);
  851. } else {
  852. old_state = cm_node->state;
  853. cm_node->state = NES_CM_STATE_LISTENER_DESTROYED;
  854. if (old_state != NES_CM_STATE_MPAREQ_RCVD)
  855. rem_ref_cm_node(
  856. cm_node->cm_core,
  857. cm_node);
  858. }
  859. } else {
  860. struct nes_cm_event event;
  861. event.cm_node = loopback;
  862. event.cm_info.rem_addr =
  863. loopback->rem_addr;
  864. event.cm_info.loc_addr =
  865. loopback->loc_addr;
  866. event.cm_info.rem_port =
  867. loopback->rem_port;
  868. event.cm_info.loc_port =
  869. loopback->loc_port;
  870. event.cm_info.cm_id = loopback->cm_id;
  871. add_ref_cm_node(loopback);
  872. loopback->state = NES_CM_STATE_CLOSED;
  873. cm_event_connect_error(&event);
  874. cm_node->state = NES_CM_STATE_LISTENER_DESTROYED;
  875. rem_ref_cm_node(cm_node->cm_core,
  876. cm_node);
  877. }
  878. }
  879. }
  880. }
  881. spin_lock_irqsave(&cm_core->listen_list_lock, flags);
  882. if (!atomic_dec_return(&listener->ref_count)) {
  883. list_del(&listener->list);
  884. /* decrement our listen node count */
  885. atomic_dec(&cm_core->listen_node_cnt);
  886. spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
  887. if (listener->nesvnic) {
  888. nes_manage_apbvt(listener->nesvnic, listener->loc_port,
  889. PCI_FUNC(listener->nesvnic->nesdev->pcidev->devfn), NES_MANAGE_APBVT_DEL);
  890. }
  891. nes_debug(NES_DBG_CM, "destroying listener (%p)\n", listener);
  892. kfree(listener);
  893. listener = NULL;
  894. ret = 0;
  895. atomic_inc(&cm_listens_destroyed);
  896. } else {
  897. spin_unlock_irqrestore(&cm_core->listen_list_lock, flags);
  898. }
  899. if (listener) {
  900. if (atomic_read(&listener->pend_accepts_cnt) > 0)
  901. nes_debug(NES_DBG_CM, "destroying listener (%p)"
  902. " with non-zero pending accepts=%u\n",
  903. listener, atomic_read(&listener->pend_accepts_cnt));
  904. }
  905. return ret;
  906. }
  907. /**
  908. * mini_cm_del_listen
  909. */
  910. static int mini_cm_del_listen(struct nes_cm_core *cm_core,
  911. struct nes_cm_listener *listener)
  912. {
  913. listener->listener_state = NES_CM_LISTENER_PASSIVE_STATE;
  914. listener->cm_id = NULL; /* going to be destroyed pretty soon */
  915. return mini_cm_dec_refcnt_listen(cm_core, listener, 1);
  916. }
  917. /**
  918. * mini_cm_accelerated
  919. */
  920. static inline int mini_cm_accelerated(struct nes_cm_core *cm_core,
  921. struct nes_cm_node *cm_node)
  922. {
  923. u32 was_timer_set;
  924. cm_node->accelerated = 1;
  925. if (cm_node->accept_pend) {
  926. BUG_ON(!cm_node->listener);
  927. atomic_dec(&cm_node->listener->pend_accepts_cnt);
  928. cm_node->accept_pend = 0;
  929. BUG_ON(atomic_read(&cm_node->listener->pend_accepts_cnt) < 0);
  930. }
  931. was_timer_set = timer_pending(&cm_core->tcp_timer);
  932. if (!was_timer_set) {
  933. cm_core->tcp_timer.expires = jiffies + NES_SHORT_TIME;
  934. add_timer(&cm_core->tcp_timer);
  935. }
  936. return 0;
  937. }
  938. /**
  939. * nes_addr_resolve_neigh
  940. */
  941. static int nes_addr_resolve_neigh(struct nes_vnic *nesvnic, u32 dst_ip, int arpindex)
  942. {
  943. struct rtable *rt;
  944. struct flowi fl;
  945. struct neighbour *neigh;
  946. int rc = arpindex;
  947. struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
  948. memset(&fl, 0, sizeof fl);
  949. fl.nl_u.ip4_u.daddr = htonl(dst_ip);
  950. if (ip_route_output_key(&init_net, &rt, &fl)) {
  951. printk(KERN_ERR "%s: ip_route_output_key failed for 0x%08X\n",
  952. __func__, dst_ip);
  953. return rc;
  954. }
  955. neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, nesvnic->netdev);
  956. if (neigh) {
  957. if (neigh->nud_state & NUD_VALID) {
  958. nes_debug(NES_DBG_CM, "Neighbor MAC address for 0x%08X"
  959. " is %pM, Gateway is 0x%08X \n", dst_ip,
  960. neigh->ha, ntohl(rt->rt_gateway));
  961. if (arpindex >= 0) {
  962. if (!memcmp(nesadapter->arp_table[arpindex].mac_addr,
  963. neigh->ha, ETH_ALEN)){
  964. /* Mac address same as in nes_arp_table */
  965. neigh_release(neigh);
  966. ip_rt_put(rt);
  967. return rc;
  968. }
  969. nes_manage_arp_cache(nesvnic->netdev,
  970. nesadapter->arp_table[arpindex].mac_addr,
  971. dst_ip, NES_ARP_DELETE);
  972. }
  973. nes_manage_arp_cache(nesvnic->netdev, neigh->ha,
  974. dst_ip, NES_ARP_ADD);
  975. rc = nes_arp_table(nesvnic->nesdev, dst_ip, NULL,
  976. NES_ARP_RESOLVE);
  977. }
  978. neigh_release(neigh);
  979. }
  980. if ((neigh == NULL) || (!(neigh->nud_state & NUD_VALID)))
  981. neigh_event_send(rt->u.dst.neighbour, NULL);
  982. ip_rt_put(rt);
  983. return rc;
  984. }
  985. /**
  986. * make_cm_node - create a new instance of a cm node
  987. */
  988. static struct nes_cm_node *make_cm_node(struct nes_cm_core *cm_core,
  989. struct nes_vnic *nesvnic, struct nes_cm_info *cm_info,
  990. struct nes_cm_listener *listener)
  991. {
  992. struct nes_cm_node *cm_node;
  993. struct timespec ts;
  994. int oldarpindex = 0;
  995. int arpindex = 0;
  996. struct nes_device *nesdev;
  997. struct nes_adapter *nesadapter;
  998. /* create an hte and cm_node for this instance */
  999. cm_node = kzalloc(sizeof(*cm_node), GFP_ATOMIC);
  1000. if (!cm_node)
  1001. return NULL;
  1002. /* set our node specific transport info */
  1003. cm_node->loc_addr = cm_info->loc_addr;
  1004. cm_node->rem_addr = cm_info->rem_addr;
  1005. cm_node->loc_port = cm_info->loc_port;
  1006. cm_node->rem_port = cm_info->rem_port;
  1007. cm_node->send_write0 = send_first;
  1008. nes_debug(NES_DBG_CM, "Make node addresses : loc = %pI4:%x, rem = %pI4:%x\n",
  1009. &cm_node->loc_addr, cm_node->loc_port,
  1010. &cm_node->rem_addr, cm_node->rem_port);
  1011. cm_node->listener = listener;
  1012. cm_node->netdev = nesvnic->netdev;
  1013. cm_node->cm_id = cm_info->cm_id;
  1014. memcpy(cm_node->loc_mac, nesvnic->netdev->dev_addr, ETH_ALEN);
  1015. nes_debug(NES_DBG_CM, "listener=%p, cm_id=%p\n", cm_node->listener,
  1016. cm_node->cm_id);
  1017. spin_lock_init(&cm_node->retrans_list_lock);
  1018. cm_node->loopbackpartner = NULL;
  1019. atomic_set(&cm_node->ref_count, 1);
  1020. /* associate our parent CM core */
  1021. cm_node->cm_core = cm_core;
  1022. cm_node->tcp_cntxt.loc_id = NES_CM_DEF_LOCAL_ID;
  1023. cm_node->tcp_cntxt.rcv_wscale = NES_CM_DEFAULT_RCV_WND_SCALE;
  1024. cm_node->tcp_cntxt.rcv_wnd = NES_CM_DEFAULT_RCV_WND_SCALED >>
  1025. NES_CM_DEFAULT_RCV_WND_SCALE;
  1026. ts = current_kernel_time();
  1027. cm_node->tcp_cntxt.loc_seq_num = htonl(ts.tv_nsec);
  1028. cm_node->tcp_cntxt.mss = nesvnic->max_frame_size - sizeof(struct iphdr) -
  1029. sizeof(struct tcphdr) - ETH_HLEN - VLAN_HLEN;
  1030. cm_node->tcp_cntxt.rcv_nxt = 0;
  1031. /* get a unique session ID , add thread_id to an upcounter to handle race */
  1032. atomic_inc(&cm_core->node_cnt);
  1033. cm_node->conn_type = cm_info->conn_type;
  1034. cm_node->apbvt_set = 0;
  1035. cm_node->accept_pend = 0;
  1036. cm_node->nesvnic = nesvnic;
  1037. /* get some device handles, for arp lookup */
  1038. nesdev = nesvnic->nesdev;
  1039. nesadapter = nesdev->nesadapter;
  1040. cm_node->loopbackpartner = NULL;
  1041. /* get the mac addr for the remote node */
  1042. if (ipv4_is_loopback(htonl(cm_node->rem_addr)))
  1043. arpindex = nes_arp_table(nesdev, ntohl(nesvnic->local_ipaddr), NULL, NES_ARP_RESOLVE);
  1044. else {
  1045. oldarpindex = nes_arp_table(nesdev, cm_node->rem_addr, NULL, NES_ARP_RESOLVE);
  1046. arpindex = nes_addr_resolve_neigh(nesvnic, cm_info->rem_addr, oldarpindex);
  1047. }
  1048. if (arpindex < 0) {
  1049. kfree(cm_node);
  1050. return NULL;
  1051. }
  1052. /* copy the mac addr to node context */
  1053. memcpy(cm_node->rem_mac, nesadapter->arp_table[arpindex].mac_addr, ETH_ALEN);
  1054. nes_debug(NES_DBG_CM, "Remote mac addr from arp table: %pM\n",
  1055. cm_node->rem_mac);
  1056. add_hte_node(cm_core, cm_node);
  1057. atomic_inc(&cm_nodes_created);
  1058. return cm_node;
  1059. }
  1060. /**
  1061. * add_ref_cm_node - destroy an instance of a cm node
  1062. */
  1063. static int add_ref_cm_node(struct nes_cm_node *cm_node)
  1064. {
  1065. atomic_inc(&cm_node->ref_count);
  1066. return 0;
  1067. }
  1068. /**
  1069. * rem_ref_cm_node - destroy an instance of a cm node
  1070. */
  1071. static int rem_ref_cm_node(struct nes_cm_core *cm_core,
  1072. struct nes_cm_node *cm_node)
  1073. {
  1074. unsigned long flags;
  1075. struct nes_qp *nesqp;
  1076. if (!cm_node)
  1077. return -EINVAL;
  1078. spin_lock_irqsave(&cm_node->cm_core->ht_lock, flags);
  1079. if (atomic_dec_return(&cm_node->ref_count)) {
  1080. spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags);
  1081. return 0;
  1082. }
  1083. list_del(&cm_node->list);
  1084. atomic_dec(&cm_core->ht_node_cnt);
  1085. spin_unlock_irqrestore(&cm_node->cm_core->ht_lock, flags);
  1086. /* if the node is destroyed before connection was accelerated */
  1087. if (!cm_node->accelerated && cm_node->accept_pend) {
  1088. BUG_ON(!cm_node->listener);
  1089. atomic_dec(&cm_node->listener->pend_accepts_cnt);
  1090. BUG_ON(atomic_read(&cm_node->listener->pend_accepts_cnt) < 0);
  1091. }
  1092. WARN_ON(cm_node->send_entry);
  1093. if (cm_node->recv_entry)
  1094. handle_recv_entry(cm_node, 0);
  1095. if (cm_node->listener) {
  1096. mini_cm_dec_refcnt_listen(cm_core, cm_node->listener, 0);
  1097. } else {
  1098. if (cm_node->apbvt_set && cm_node->nesvnic) {
  1099. nes_manage_apbvt(cm_node->nesvnic, cm_node->loc_port,
  1100. PCI_FUNC(
  1101. cm_node->nesvnic->nesdev->pcidev->devfn),
  1102. NES_MANAGE_APBVT_DEL);
  1103. }
  1104. }
  1105. atomic_dec(&cm_core->node_cnt);
  1106. atomic_inc(&cm_nodes_destroyed);
  1107. nesqp = cm_node->nesqp;
  1108. if (nesqp) {
  1109. nesqp->cm_node = NULL;
  1110. nes_rem_ref(&nesqp->ibqp);
  1111. cm_node->nesqp = NULL;
  1112. }
  1113. kfree(cm_node);
  1114. return 0;
  1115. }
  1116. /**
  1117. * process_options
  1118. */
  1119. static int process_options(struct nes_cm_node *cm_node, u8 *optionsloc,
  1120. u32 optionsize, u32 syn_packet)
  1121. {
  1122. u32 tmp;
  1123. u32 offset = 0;
  1124. union all_known_options *all_options;
  1125. char got_mss_option = 0;
  1126. while (offset < optionsize) {
  1127. all_options = (union all_known_options *)(optionsloc + offset);
  1128. switch (all_options->as_base.optionnum) {
  1129. case OPTION_NUMBER_END:
  1130. offset = optionsize;
  1131. break;
  1132. case OPTION_NUMBER_NONE:
  1133. offset += 1;
  1134. continue;
  1135. case OPTION_NUMBER_MSS:
  1136. nes_debug(NES_DBG_CM, "%s: MSS Length: %d Offset: %d "
  1137. "Size: %d\n", __func__,
  1138. all_options->as_mss.length, offset, optionsize);
  1139. got_mss_option = 1;
  1140. if (all_options->as_mss.length != 4) {
  1141. return 1;
  1142. } else {
  1143. tmp = ntohs(all_options->as_mss.mss);
  1144. if (tmp > 0 && tmp <
  1145. cm_node->tcp_cntxt.mss)
  1146. cm_node->tcp_cntxt.mss = tmp;
  1147. }
  1148. break;
  1149. case OPTION_NUMBER_WINDOW_SCALE:
  1150. cm_node->tcp_cntxt.snd_wscale =
  1151. all_options->as_windowscale.shiftcount;
  1152. break;
  1153. case OPTION_NUMBER_WRITE0:
  1154. cm_node->send_write0 = 1;
  1155. break;
  1156. default:
  1157. nes_debug(NES_DBG_CM, "TCP Option not understood: %x\n",
  1158. all_options->as_base.optionnum);
  1159. break;
  1160. }
  1161. offset += all_options->as_base.length;
  1162. }
  1163. if ((!got_mss_option) && (syn_packet))
  1164. cm_node->tcp_cntxt.mss = NES_CM_DEFAULT_MSS;
  1165. return 0;
  1166. }
  1167. static void drop_packet(struct sk_buff *skb)
  1168. {
  1169. atomic_inc(&cm_accel_dropped_pkts);
  1170. dev_kfree_skb_any(skb);
  1171. }
  1172. static void handle_fin_pkt(struct nes_cm_node *cm_node)
  1173. {
  1174. nes_debug(NES_DBG_CM, "Received FIN, cm_node = %p, state = %u. "
  1175. "refcnt=%d\n", cm_node, cm_node->state,
  1176. atomic_read(&cm_node->ref_count));
  1177. switch (cm_node->state) {
  1178. case NES_CM_STATE_SYN_RCVD:
  1179. case NES_CM_STATE_SYN_SENT:
  1180. case NES_CM_STATE_ESTABLISHED:
  1181. case NES_CM_STATE_MPAREJ_RCVD:
  1182. cm_node->tcp_cntxt.rcv_nxt++;
  1183. cleanup_retrans_entry(cm_node);
  1184. cm_node->state = NES_CM_STATE_LAST_ACK;
  1185. send_fin(cm_node, NULL);
  1186. break;
  1187. case NES_CM_STATE_MPAREQ_SENT:
  1188. create_event(cm_node, NES_CM_EVENT_ABORTED);
  1189. cm_node->tcp_cntxt.rcv_nxt++;
  1190. cleanup_retrans_entry(cm_node);
  1191. cm_node->state = NES_CM_STATE_CLOSED;
  1192. add_ref_cm_node(cm_node);
  1193. send_reset(cm_node, NULL);
  1194. break;
  1195. case NES_CM_STATE_FIN_WAIT1:
  1196. cm_node->tcp_cntxt.rcv_nxt++;
  1197. cleanup_retrans_entry(cm_node);
  1198. cm_node->state = NES_CM_STATE_CLOSING;
  1199. send_ack(cm_node, NULL);
  1200. /* Wait for ACK as this is simultanous close..
  1201. * After we receive ACK, do not send anything..
  1202. * Just rm the node.. Done.. */
  1203. break;
  1204. case NES_CM_STATE_FIN_WAIT2:
  1205. cm_node->tcp_cntxt.rcv_nxt++;
  1206. cleanup_retrans_entry(cm_node);
  1207. cm_node->state = NES_CM_STATE_TIME_WAIT;
  1208. send_ack(cm_node, NULL);
  1209. schedule_nes_timer(cm_node, NULL, NES_TIMER_TYPE_CLOSE, 1, 0);
  1210. break;
  1211. case NES_CM_STATE_TIME_WAIT:
  1212. cm_node->tcp_cntxt.rcv_nxt++;
  1213. cleanup_retrans_entry(cm_node);
  1214. cm_node->state = NES_CM_STATE_CLOSED;
  1215. rem_ref_cm_node(cm_node->cm_core, cm_node);
  1216. break;
  1217. case NES_CM_STATE_TSA:
  1218. default:
  1219. nes_debug(NES_DBG_CM, "Error Rcvd FIN for node-%p state = %d\n",
  1220. cm_node, cm_node->state);
  1221. break;
  1222. }
  1223. }
  1224. static void handle_rst_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
  1225. struct tcphdr *tcph)
  1226. {
  1227. int reset = 0; /* whether to send reset in case of err.. */
  1228. int passive_state;
  1229. atomic_inc(&cm_resets_recvd);
  1230. nes_debug(NES_DBG_CM, "Received Reset, cm_node = %p, state = %u."
  1231. " refcnt=%d\n", cm_node, cm_node->state,
  1232. atomic_read(&cm_node->ref_count));
  1233. cleanup_retrans_entry(cm_node);
  1234. switch (cm_node->state) {
  1235. case NES_CM_STATE_SYN_SENT:
  1236. case NES_CM_STATE_MPAREQ_SENT:
  1237. nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
  1238. "listener=%p state=%d\n", __func__, __LINE__, cm_node,
  1239. cm_node->listener, cm_node->state);
  1240. active_open_err(cm_node, skb, reset);
  1241. break;
  1242. case NES_CM_STATE_MPAREQ_RCVD:
  1243. passive_state = atomic_add_return(1, &cm_node->passive_state);
  1244. if (passive_state == NES_SEND_RESET_EVENT)
  1245. create_event(cm_node, NES_CM_EVENT_RESET);
  1246. cm_node->state = NES_CM_STATE_CLOSED;
  1247. dev_kfree_skb_any(skb);
  1248. break;
  1249. case NES_CM_STATE_ESTABLISHED:
  1250. case NES_CM_STATE_SYN_RCVD:
  1251. case NES_CM_STATE_LISTENING:
  1252. nes_debug(NES_DBG_CM, "Bad state %s[%u]\n", __func__, __LINE__);
  1253. passive_open_err(cm_node, skb, reset);
  1254. break;
  1255. case NES_CM_STATE_TSA:
  1256. active_open_err(cm_node, skb, reset);
  1257. break;
  1258. case NES_CM_STATE_CLOSED:
  1259. drop_packet(skb);
  1260. break;
  1261. case NES_CM_STATE_FIN_WAIT1:
  1262. case NES_CM_STATE_LAST_ACK:
  1263. cm_node->cm_id->rem_ref(cm_node->cm_id);
  1264. case NES_CM_STATE_TIME_WAIT:
  1265. cm_node->state = NES_CM_STATE_CLOSED;
  1266. rem_ref_cm_node(cm_node->cm_core, cm_node);
  1267. drop_packet(skb);
  1268. break;
  1269. default:
  1270. drop_packet(skb);
  1271. break;
  1272. }
  1273. }
  1274. static void handle_rcv_mpa(struct nes_cm_node *cm_node, struct sk_buff *skb)
  1275. {
  1276. int ret = 0;
  1277. int datasize = skb->len;
  1278. u8 *dataloc = skb->data;
  1279. enum nes_cm_event_type type = NES_CM_EVENT_UNKNOWN;
  1280. u32 res_type;
  1281. ret = parse_mpa(cm_node, dataloc, &res_type, datasize);
  1282. if (ret) {
  1283. nes_debug(NES_DBG_CM, "didn't like MPA Request\n");
  1284. if (cm_node->state == NES_CM_STATE_MPAREQ_SENT) {
  1285. nes_debug(NES_DBG_CM, "%s[%u] create abort for "
  1286. "cm_node=%p listener=%p state=%d\n", __func__,
  1287. __LINE__, cm_node, cm_node->listener,
  1288. cm_node->state);
  1289. active_open_err(cm_node, skb, 1);
  1290. } else {
  1291. passive_open_err(cm_node, skb, 1);
  1292. }
  1293. return;
  1294. }
  1295. switch (cm_node->state) {
  1296. case NES_CM_STATE_ESTABLISHED:
  1297. if (res_type == NES_MPA_REQUEST_REJECT) {
  1298. /*BIG problem as we are receiving the MPA.. So should
  1299. * not be REJECT.. This is Passive Open.. We can
  1300. * only receive it Reject for Active Open...*/
  1301. WARN_ON(1);
  1302. }
  1303. cm_node->state = NES_CM_STATE_MPAREQ_RCVD;
  1304. type = NES_CM_EVENT_MPA_REQ;
  1305. atomic_set(&cm_node->passive_state,
  1306. NES_PASSIVE_STATE_INDICATED);
  1307. break;
  1308. case NES_CM_STATE_MPAREQ_SENT:
  1309. cleanup_retrans_entry(cm_node);
  1310. if (res_type == NES_MPA_REQUEST_REJECT) {
  1311. type = NES_CM_EVENT_MPA_REJECT;
  1312. cm_node->state = NES_CM_STATE_MPAREJ_RCVD;
  1313. } else {
  1314. type = NES_CM_EVENT_CONNECTED;
  1315. cm_node->state = NES_CM_STATE_TSA;
  1316. }
  1317. break;
  1318. default:
  1319. WARN_ON(1);
  1320. break;
  1321. }
  1322. dev_kfree_skb_any(skb);
  1323. create_event(cm_node, type);
  1324. }
  1325. static void indicate_pkt_err(struct nes_cm_node *cm_node, struct sk_buff *skb)
  1326. {
  1327. switch (cm_node->state) {
  1328. case NES_CM_STATE_SYN_SENT:
  1329. case NES_CM_STATE_MPAREQ_SENT:
  1330. nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
  1331. "listener=%p state=%d\n", __func__, __LINE__, cm_node,
  1332. cm_node->listener, cm_node->state);
  1333. active_open_err(cm_node, skb, 1);
  1334. break;
  1335. case NES_CM_STATE_ESTABLISHED:
  1336. case NES_CM_STATE_SYN_RCVD:
  1337. passive_open_err(cm_node, skb, 1);
  1338. break;
  1339. case NES_CM_STATE_TSA:
  1340. default:
  1341. drop_packet(skb);
  1342. }
  1343. }
  1344. static int check_syn(struct nes_cm_node *cm_node, struct tcphdr *tcph,
  1345. struct sk_buff *skb)
  1346. {
  1347. int err;
  1348. err = ((ntohl(tcph->ack_seq) == cm_node->tcp_cntxt.loc_seq_num))? 0 : 1;
  1349. if (err)
  1350. active_open_err(cm_node, skb, 1);
  1351. return err;
  1352. }
  1353. static int check_seq(struct nes_cm_node *cm_node, struct tcphdr *tcph,
  1354. struct sk_buff *skb)
  1355. {
  1356. int err = 0;
  1357. u32 seq;
  1358. u32 ack_seq;
  1359. u32 loc_seq_num = cm_node->tcp_cntxt.loc_seq_num;
  1360. u32 rcv_nxt = cm_node->tcp_cntxt.rcv_nxt;
  1361. u32 rcv_wnd;
  1362. seq = ntohl(tcph->seq);
  1363. ack_seq = ntohl(tcph->ack_seq);
  1364. rcv_wnd = cm_node->tcp_cntxt.rcv_wnd;
  1365. if (ack_seq != loc_seq_num)
  1366. err = 1;
  1367. else if (!between(seq, rcv_nxt, (rcv_nxt+rcv_wnd)))
  1368. err = 1;
  1369. if (err) {
  1370. nes_debug(NES_DBG_CM, "%s[%u] create abort for cm_node=%p "
  1371. "listener=%p state=%d\n", __func__, __LINE__, cm_node,
  1372. cm_node->listener, cm_node->state);
  1373. indicate_pkt_err(cm_node, skb);
  1374. nes_debug(NES_DBG_CM, "seq ERROR cm_node =%p seq=0x%08X "
  1375. "rcv_nxt=0x%08X rcv_wnd=0x%x\n", cm_node, seq, rcv_nxt,
  1376. rcv_wnd);
  1377. }
  1378. return err;
  1379. }
  1380. /*
  1381. * handle_syn_pkt() is for Passive node. The syn packet is received when a node
  1382. * is created with a listener or it may comein as rexmitted packet which in
  1383. * that case will be just dropped.
  1384. */
  1385. static void handle_syn_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
  1386. struct tcphdr *tcph)
  1387. {
  1388. int ret;
  1389. u32 inc_sequence;
  1390. int optionsize;
  1391. optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
  1392. skb_trim(skb, 0);
  1393. inc_sequence = ntohl(tcph->seq);
  1394. switch (cm_node->state) {
  1395. case NES_CM_STATE_SYN_SENT:
  1396. case NES_CM_STATE_MPAREQ_SENT:
  1397. /* Rcvd syn on active open connection*/
  1398. active_open_err(cm_node, skb, 1);
  1399. break;
  1400. case NES_CM_STATE_LISTENING:
  1401. /* Passive OPEN */
  1402. if (atomic_read(&cm_node->listener->pend_accepts_cnt) >
  1403. cm_node->listener->backlog) {
  1404. nes_debug(NES_DBG_CM, "drop syn due to backlog "
  1405. "pressure \n");
  1406. cm_backlog_drops++;
  1407. passive_open_err(cm_node, skb, 0);
  1408. break;
  1409. }
  1410. ret = handle_tcp_options(cm_node, tcph, skb, optionsize,
  1411. 1);
  1412. if (ret) {
  1413. passive_open_err(cm_node, skb, 0);
  1414. /* drop pkt */
  1415. break;
  1416. }
  1417. cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
  1418. BUG_ON(cm_node->send_entry);
  1419. cm_node->accept_pend = 1;
  1420. atomic_inc(&cm_node->listener->pend_accepts_cnt);
  1421. cm_node->state = NES_CM_STATE_SYN_RCVD;
  1422. send_syn(cm_node, 1, skb);
  1423. break;
  1424. case NES_CM_STATE_CLOSED:
  1425. cleanup_retrans_entry(cm_node);
  1426. add_ref_cm_node(cm_node);
  1427. send_reset(cm_node, skb);
  1428. break;
  1429. case NES_CM_STATE_TSA:
  1430. case NES_CM_STATE_ESTABLISHED:
  1431. case NES_CM_STATE_FIN_WAIT1:
  1432. case NES_CM_STATE_FIN_WAIT2:
  1433. case NES_CM_STATE_MPAREQ_RCVD:
  1434. case NES_CM_STATE_LAST_ACK:
  1435. case NES_CM_STATE_CLOSING:
  1436. case NES_CM_STATE_UNKNOWN:
  1437. default:
  1438. drop_packet(skb);
  1439. break;
  1440. }
  1441. }
  1442. static void handle_synack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
  1443. struct tcphdr *tcph)
  1444. {
  1445. int ret;
  1446. u32 inc_sequence;
  1447. int optionsize;
  1448. optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
  1449. skb_trim(skb, 0);
  1450. inc_sequence = ntohl(tcph->seq);
  1451. switch (cm_node->state) {
  1452. case NES_CM_STATE_SYN_SENT:
  1453. cleanup_retrans_entry(cm_node);
  1454. /* active open */
  1455. if (check_syn(cm_node, tcph, skb))
  1456. return;
  1457. cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
  1458. /* setup options */
  1459. ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 0);
  1460. if (ret) {
  1461. nes_debug(NES_DBG_CM, "cm_node=%p tcp_options failed\n",
  1462. cm_node);
  1463. break;
  1464. }
  1465. cleanup_retrans_entry(cm_node);
  1466. cm_node->tcp_cntxt.rcv_nxt = inc_sequence + 1;
  1467. send_mpa_request(cm_node, skb);
  1468. cm_node->state = NES_CM_STATE_MPAREQ_SENT;
  1469. break;
  1470. case NES_CM_STATE_MPAREQ_RCVD:
  1471. /* passive open, so should not be here */
  1472. passive_open_err(cm_node, skb, 1);
  1473. break;
  1474. case NES_CM_STATE_LISTENING:
  1475. cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
  1476. cleanup_retrans_entry(cm_node);
  1477. cm_node->state = NES_CM_STATE_CLOSED;
  1478. send_reset(cm_node, skb);
  1479. break;
  1480. case NES_CM_STATE_CLOSED:
  1481. cm_node->tcp_cntxt.loc_seq_num = ntohl(tcph->ack_seq);
  1482. cleanup_retrans_entry(cm_node);
  1483. add_ref_cm_node(cm_node);
  1484. send_reset(cm_node, skb);
  1485. break;
  1486. case NES_CM_STATE_ESTABLISHED:
  1487. case NES_CM_STATE_FIN_WAIT1:
  1488. case NES_CM_STATE_FIN_WAIT2:
  1489. case NES_CM_STATE_LAST_ACK:
  1490. case NES_CM_STATE_TSA:
  1491. case NES_CM_STATE_CLOSING:
  1492. case NES_CM_STATE_UNKNOWN:
  1493. case NES_CM_STATE_MPAREQ_SENT:
  1494. default:
  1495. drop_packet(skb);
  1496. break;
  1497. }
  1498. }
  1499. static int handle_ack_pkt(struct nes_cm_node *cm_node, struct sk_buff *skb,
  1500. struct tcphdr *tcph)
  1501. {
  1502. int datasize = 0;
  1503. u32 inc_sequence;
  1504. u32 rem_seq_ack;
  1505. u32 rem_seq;
  1506. int ret = 0;
  1507. int optionsize;
  1508. optionsize = (tcph->doff << 2) - sizeof(struct tcphdr);
  1509. if (check_seq(cm_node, tcph, skb))
  1510. return -EINVAL;
  1511. skb_pull(skb, tcph->doff << 2);
  1512. inc_sequence = ntohl(tcph->seq);
  1513. rem_seq = ntohl(tcph->seq);
  1514. rem_seq_ack = ntohl(tcph->ack_seq);
  1515. datasize = skb->len;
  1516. switch (cm_node->state) {
  1517. case NES_CM_STATE_SYN_RCVD:
  1518. /* Passive OPEN */
  1519. cleanup_retrans_entry(cm_node);
  1520. ret = handle_tcp_options(cm_node, tcph, skb, optionsize, 1);
  1521. if (ret)
  1522. break;
  1523. cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
  1524. cm_node->state = NES_CM_STATE_ESTABLISHED;
  1525. if (datasize) {
  1526. cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
  1527. handle_rcv_mpa(cm_node, skb);
  1528. } else /* rcvd ACK only */
  1529. dev_kfree_skb_any(skb);
  1530. break;
  1531. case NES_CM_STATE_ESTABLISHED:
  1532. /* Passive OPEN */
  1533. cleanup_retrans_entry(cm_node);
  1534. if (datasize) {
  1535. cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
  1536. handle_rcv_mpa(cm_node, skb);
  1537. } else
  1538. drop_packet(skb);
  1539. break;
  1540. case NES_CM_STATE_MPAREQ_SENT:
  1541. cm_node->tcp_cntxt.rem_ack_num = ntohl(tcph->ack_seq);
  1542. if (datasize) {
  1543. cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize;
  1544. handle_rcv_mpa(cm_node, skb);
  1545. } else /* Could be just an ack pkt.. */
  1546. dev_kfree_skb_any(skb);
  1547. break;
  1548. case NES_CM_STATE_LISTENING:
  1549. cleanup_retrans_entry(cm_node);
  1550. cm_node->state = NES_CM_STATE_CLOSED;
  1551. send_reset(cm_node, skb);
  1552. break;
  1553. case NES_CM_STATE_CLOSED:
  1554. cleanup_retrans_entry(cm_node);
  1555. add_ref_cm_node(cm_node);
  1556. send_reset(cm_node, skb);
  1557. break;
  1558. case NES_CM_STATE_LAST_ACK:
  1559. case NES_CM_STATE_CLOSING:
  1560. cleanup_retrans_entry(cm_node);
  1561. cm_node->state = NES_CM_STATE_CLOSED;
  1562. cm_node->cm_id->rem_ref(cm_node->cm_id);
  1563. rem_ref_cm_node(cm_node->cm_core, cm_node);
  1564. drop_packet(skb);
  1565. break;
  1566. case NES_CM_STATE_FIN_WAIT1:
  1567. cleanup_retrans_entry(cm_node);
  1568. drop_packet(skb);
  1569. cm_node->state = NES_CM_STATE

Large files files are truncated, but you can click here to view the full file