src/vnet/tcp/tcp.c

   1 /*
   2  * Copyright (c) 2016-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 /**
  17  * @file
  18  * @brief TCP host stack utilities
  19  */
  20
  21 #include <vnet/tcp/tcp.h>
  22 #include <vnet/tcp/tcp_inlines.h>
  23 #include <vnet/session/session.h>
  24 #include <vnet/fib/fib.h>
  25 #include <vnet/dpo/load_balance.h>
  26 #include <math.h>
  27
  28 tcp_main_t tcp_main;
  29
  30 typedef struct
  31 {
  32   fib_protocol_t nh_proto;
  33   vnet_link_t link_type;
  34   ip46_address_t ip;
  35   u32 sw_if_index;
  36   u8 is_add;
  37 } tcp_add_del_adj_args_t;
  38
  39 static void
  40 tcp_add_del_adj_cb (tcp_add_del_adj_args_t * args)
  41 {
  42   u32 ai;
  43   if (args->is_add)
  44     {
  45       adj_nbr_add_or_lock (args->nh_proto, args->link_type, &args->ip,
  46                            args->sw_if_index);
  47     }
  48   else
  49     {
  50       ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &args->ip,
  51                          args->sw_if_index);
  52       if (ai != ADJ_INDEX_INVALID)
  53         adj_unlock (ai);
  54     }
  55 }
  56
  57 static void
  58 tcp_add_del_adjacency (tcp_connection_t * tc, u8 is_add)
  59 {
  60   tcp_add_del_adj_args_t args = {
  61     .nh_proto = FIB_PROTOCOL_IP6,
  62     .link_type = VNET_LINK_IP6,
  63     .ip = tc->c_rmt_ip,
  64     .sw_if_index = tc->sw_if_index,
  65     .is_add = is_add
  66   };
  67   vlib_rpc_call_main_thread (tcp_add_del_adj_cb, (u8 *) & args,
  68                              sizeof (args));
  69 }
  70
  71 static void
  72 tcp_cc_init (tcp_connection_t * tc)
  73 {
  74   /* As per RFC 6582 initialize "recover" to iss */
  75   if (tcp_opts_sack_permitted (&tc->rcv_opts))
  76     tc->snd_congestion = tc->iss;
  77
  78   tc->cc_algo->init (tc);
  79 }
  80
  81 static void
  82 tcp_cc_cleanup (tcp_connection_t * tc)
  83 {
  84   if (tc->cc_algo->cleanup)
  85     tc->cc_algo->cleanup (tc);
  86 }
  87
  88 void
  89 tcp_cc_algo_register (tcp_cc_algorithm_type_e type,
  90                       const tcp_cc_algorithm_t * vft)
  91 {
  92   tcp_main_t *tm = vnet_get_tcp_main ();
  93   vec_validate (tm->cc_algos, type);
  94
  95   tm->cc_algos[type] = *vft;
  96   hash_set_mem (tm->cc_algo_by_name, vft->name, type);
  97 }
  98
  99 tcp_cc_algorithm_t *
 100 tcp_cc_algo_get (tcp_cc_algorithm_type_e type)
 101 {
 102   tcp_main_t *tm = vnet_get_tcp_main ();
 103   return &tm->cc_algos[type];
 104 }
 105
 106 tcp_cc_algorithm_type_e
 107 tcp_cc_algo_new_type (const tcp_cc_algorithm_t * vft)
 108 {
 109   tcp_main_t *tm = vnet_get_tcp_main ();
 110   tcp_cc_algo_register (++tm->cc_last_type, vft);
 111   return tm->cc_last_type;
 112 }
 113
 114 static u32
 115 tcp_connection_bind (u32 session_index, transport_endpoint_cfg_t *lcl)
 116 {
 117   tcp_main_t *tm = &tcp_main;
 118   tcp_connection_t *listener;
 119   void *iface_ip;
 120
 121   pool_get (tm->listener_pool, listener);
 122   clib_memset (listener, 0, sizeof (*listener));
 123
 124   listener->c_c_index = listener - tm->listener_pool;
 125   listener->c_lcl_port = lcl->port;
 126
 127   /* If we are provided a sw_if_index, bind using one of its ips */
 128   if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX)
 129     {
 130       if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index,
 131                                                  lcl->is_ip4)))
 132         ip_set (&lcl->ip, iface_ip, lcl->is_ip4);
 133     }
 134   ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4);
 135   listener->c_is_ip4 = lcl->is_ip4;
 136   listener->c_proto = TRANSPORT_PROTO_TCP;
 137   listener->c_s_index = session_index;
 138   listener->c_fib_index = lcl->fib_index;
 139   listener->state = TCP_STATE_LISTEN;
 140   listener->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo);
 141
 142   tcp_connection_timers_init (listener);
 143
 144   TCP_EVT (TCP_EVT_BIND, listener);
 145
 146   return listener->c_c_index;
 147 }
 148
 149 static u32
 150 tcp_session_bind (u32 session_index, transport_endpoint_cfg_t *tep)
 151 {
 152   return tcp_connection_bind (session_index, tep);
 153 }
 154
 155 static void
 156 tcp_connection_unbind (u32 listener_index)
 157 {
 158   tcp_main_t *tm = vnet_get_tcp_main ();
 159   tcp_connection_t *tc;
 160
 161   tc = pool_elt_at_index (tm->listener_pool, listener_index);
 162
 163   TCP_EVT (TCP_EVT_UNBIND, tc);
 164
 165   /* Poison the entry */
 166   if (CLIB_DEBUG > 0)
 167     clib_memset (tc, 0xFA, sizeof (*tc));
 168
 169   pool_put_index (tm->listener_pool, listener_index);
 170 }
 171
 172 static u32
 173 tcp_session_unbind (u32 listener_index)
 174 {
 175   tcp_connection_unbind (listener_index);
 176   return 0;
 177 }
 178
 179 static transport_connection_t *
 180 tcp_session_get_listener (u32 listener_index)
 181 {
 182   tcp_main_t *tm = vnet_get_tcp_main ();
 183   tcp_connection_t *tc;
 184   tc = pool_elt_at_index (tm->listener_pool, listener_index);
 185   return &tc->connection;
 186 }
 187
 188 static tcp_connection_t *
 189 tcp_half_open_connection_alloc (void)
 190 {
 191   return tcp_connection_alloc (transport_cl_thread ());
 192 }
 193
 194 /**
 195  * Cleanup half-open connection
 196  *
 197  */
 198 static void
 199 tcp_half_open_connection_free (tcp_connection_t * tc)
 200 {
 201   ASSERT (vlib_get_thread_index () == tc->c_thread_index ||
 202           vlib_thread_is_main_w_barrier ());
 203   return tcp_connection_free (tc);
 204 }
 205
 206 /**
 207  * Try to cleanup half-open connection
 208  *
 209  * If called from a thread that doesn't own tc, the call won't have any
 210  * effect.
 211  *
 212  * @param tc - connection to be cleaned up
 213  * @return non-zero if cleanup failed.
 214  */
 215 int
 216 tcp_half_open_connection_cleanup (tcp_connection_t * tc)
 217 {
 218   tcp_worker_ctx_t *wrk;
 219
 220   /* Make sure this is the owning thread */
 221   if (tc->c_thread_index != vlib_get_thread_index ())
 222     return 1;
 223
 224   session_half_open_delete_notify (&tc->connection);
 225   wrk = tcp_get_worker (tc->c_thread_index);
 226   tcp_timer_reset (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN);
 227   tcp_half_open_connection_free (tc);
 228   return 0;
 229 }
 230
 231 /**
 232  * Cleans up connection state.
 233  *
 234  * No notifications.
 235  */
 236 void
 237 tcp_connection_cleanup (tcp_connection_t * tc)
 238 {
 239   TCP_EVT (TCP_EVT_DELETE, tc);
 240
 241   /* Cleanup local endpoint if this was an active connect */
 242   if (!(tc->cfg_flags & TCP_CFG_F_NO_ENDPOINT))
 243     transport_release_local_endpoint (TRANSPORT_PROTO_TCP, &tc->c_lcl_ip,
 244                                       tc->c_lcl_port);
 245
 246   /* Check if connection is not yet fully established */
 247   if (tc->state == TCP_STATE_SYN_SENT)
 248     {
 249       /* Try to remove the half-open connection. If this is not the owning
 250        * thread, tc won't be removed. Retransmit or establish timers will
 251        * eventually expire and call again cleanup on the right thread. */
 252       if (tcp_half_open_connection_cleanup (tc))
 253         tc->flags |= TCP_CONN_HALF_OPEN_DONE;
 254     }
 255   else
 256     {
 257       /* Make sure all timers are cleared */
 258       tcp_connection_timers_reset (tc);
 259
 260       if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
 261         tcp_add_del_adjacency (tc, 0);
 262
 263       tcp_cc_cleanup (tc);
 264       vec_free (tc->snd_sacks);
 265       vec_free (tc->snd_sacks_fl);
 266       vec_free (tc->rcv_opts.sacks);
 267       pool_free (tc->sack_sb.holes);
 268
 269       if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
 270         tcp_bt_cleanup (tc);
 271
 272       tcp_connection_free (tc);
 273     }
 274 }
 275
 276 /**
 277  * Connection removal.
 278  *
 279  * This should be called only once connection enters CLOSED state. Note
 280  * that it notifies the session of the removal event, so if the goal is to
 281  * just remove the connection, call tcp_connection_cleanup instead.
 282  */
 283 void
 284 tcp_connection_del (tcp_connection_t * tc)
 285 {
 286   session_transport_delete_notify (&tc->connection);
 287   tcp_connection_cleanup (tc);
 288 }
 289
 290 tcp_connection_t *
 291 tcp_connection_alloc (u8 thread_index)
 292 {
 293   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
 294   tcp_connection_t *tc;
 295
 296   pool_get_aligned_safe (wrk->connections, tc, CLIB_CACHE_LINE_BYTES);
 297   clib_memset (tc, 0, sizeof (*tc));
 298   tc->c_c_index = tc - wrk->connections;
 299   tc->c_thread_index = thread_index;
 300   return tc;
 301 }
 302
 303 tcp_connection_t *
 304 tcp_connection_alloc_w_base (u8 thread_index, tcp_connection_t **base)
 305 {
 306   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
 307   tcp_connection_t *tc;
 308
 309   /* Make sure connection is still valid if pool moves */
 310   if ((*base)->c_thread_index == thread_index)
 311     {
 312       u32 base_index = (*base)->c_c_index;
 313       pool_get_aligned_safe (wrk->connections, tc, CLIB_CACHE_LINE_BYTES);
 314       *base = tcp_connection_get (base_index, thread_index);
 315     }
 316   else
 317     {
 318       pool_get_aligned_safe (wrk->connections, tc, CLIB_CACHE_LINE_BYTES);
 319     }
 320   clib_memcpy_fast (tc, *base, sizeof (*tc));
 321   tc->c_c_index = tc - wrk->connections;
 322   tc->c_thread_index = thread_index;
 323   return tc;
 324 }
 325
 326 void
 327 tcp_connection_free (tcp_connection_t * tc)
 328 {
 329   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 330   if (CLIB_DEBUG)
 331     {
 332       clib_memset (tc, 0xFA, sizeof (*tc));
 333       pool_put (wrk->connections, tc);
 334       return;
 335     }
 336   pool_put (wrk->connections, tc);
 337 }
 338
 339 void
 340 tcp_program_cleanup (tcp_worker_ctx_t * wrk, tcp_connection_t * tc)
 341 {
 342   tcp_cleanup_req_t *req;
 343   clib_time_type_t now;
 344
 345   now = tcp_time_now_us (tc->c_thread_index);
 346   clib_fifo_add2 (wrk->pending_cleanups, req);
 347   req->connection_index = tc->c_c_index;
 348   req->free_time = now + tcp_cfg.cleanup_time;
 349 }
 350
 351 /**
 352  * Begin connection closing procedure.
 353  *
 354  * If at the end the connection is not in CLOSED state, it is not removed.
 355  * Instead, we rely on on TCP to advance through state machine to either
 356  * 1) LAST_ACK (passive close) whereby when the last ACK is received
 357  * tcp_connection_del is called. This notifies session of the delete and
 358  * calls cleanup.
 359  * 2) TIME_WAIT (active close) whereby after 2MSL the 2MSL timer triggers
 360  * and cleanup is called.
 361  *
 362  */
 363 void
 364 tcp_connection_close (tcp_connection_t * tc)
 365 {
 366   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 367
 368   TCP_EVT (TCP_EVT_CLOSE, tc);
 369
 370   /* Send/Program FIN if needed and switch state */
 371   switch (tc->state)
 372     {
 373     case TCP_STATE_SYN_SENT:
 374       /* Try to cleanup. If not on the right thread, mark as half-open done.
 375        * Connection will be cleaned up when establish timer pops */
 376       tcp_connection_cleanup (tc);
 377       break;
 378     case TCP_STATE_SYN_RCVD:
 379       tcp_connection_timers_reset (tc);
 380       tcp_send_fin (tc);
 381       tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
 382       tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 383                         tcp_cfg.finwait1_time);
 384       break;
 385     case TCP_STATE_ESTABLISHED:
 386       /* If closing with unread data, reset the connection */
 387       if (transport_max_rx_dequeue (&tc->connection))
 388         {
 389           tcp_send_reset (tc);
 390           tcp_connection_timers_reset (tc);
 391           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
 392           session_transport_closed_notify (&tc->connection);
 393           tcp_program_cleanup (tcp_get_worker (tc->c_thread_index), tc);
 394           tcp_worker_stats_inc (wrk, rst_unread, 1);
 395           break;
 396         }
 397       if (!transport_max_tx_dequeue (&tc->connection))
 398         tcp_send_fin (tc);
 399       else
 400         tc->flags |= TCP_CONN_FINPNDG;
 401       tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
 402       /* Set a timer in case the peer stops responding. Otherwise the
 403        * connection will be stuck here forever. */
 404       ASSERT (tc->timers[TCP_TIMER_WAITCLOSE] == TCP_TIMER_HANDLE_INVALID);
 405       tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 406                      tcp_cfg.finwait1_time);
 407       break;
 408     case TCP_STATE_CLOSE_WAIT:
 409       if (!transport_max_tx_dequeue (&tc->connection))
 410         {
 411           tcp_send_fin (tc);
 412           tcp_connection_timers_reset (tc);
 413           tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
 414           tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 415                             tcp_cfg.lastack_time);
 416         }
 417       else
 418         tc->flags |= TCP_CONN_FINPNDG;
 419       break;
 420     case TCP_STATE_FIN_WAIT_1:
 421       tcp_timer_update (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 422                         tcp_cfg.finwait1_time);
 423       break;
 424     case TCP_STATE_CLOSED:
 425       /* Cleanup should've been programmed already */
 426       break;
 427     default:
 428       TCP_DBG ("state: %u", tc->state);
 429     }
 430 }
 431
 432 static void
 433 tcp_session_half_close (u32 conn_index, u32 thread_index)
 434 {
 435   tcp_worker_ctx_t *wrk;
 436   tcp_connection_t *tc;
 437
 438   tc = tcp_connection_get (conn_index, thread_index);
 439   wrk = tcp_get_worker (tc->c_thread_index);
 440
 441   /* If the connection is not in ESTABLISHED state, ignore it */
 442   if (tc->state != TCP_STATE_ESTABLISHED)
 443     return;
 444   if (!transport_max_tx_dequeue (&tc->connection))
 445     tcp_send_fin (tc);
 446   else
 447     tc->flags |= TCP_CONN_FINPNDG;
 448   tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
 449   /* Set a timer in case the peer stops responding. Otherwise the
 450    * connection will be stuck here forever. */
 451   ASSERT (tc->timers[TCP_TIMER_WAITCLOSE] == TCP_TIMER_HANDLE_INVALID);
 452   tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
 453                  tcp_cfg.finwait1_time);
 454 }
 455
 456 static void
 457 tcp_session_close (u32 conn_index, u32 thread_index)
 458 {
 459   tcp_connection_t *tc;
 460   tc = tcp_connection_get (conn_index, thread_index);
 461   tcp_connection_close (tc);
 462 }
 463
 464 static void
 465 tcp_session_cleanup (u32 conn_index, u32 thread_index)
 466 {
 467   tcp_connection_t *tc;
 468   tc = tcp_connection_get (conn_index, thread_index);
 469   if (!tc)
 470     return;
 471   tcp_connection_set_state (tc, TCP_STATE_CLOSED);
 472   tcp_connection_cleanup (tc);
 473 }
 474
 475 static void
 476 tcp_session_cleanup_ho (u32 conn_index)
 477 {
 478   tcp_worker_ctx_t *wrk;
 479   tcp_connection_t *tc;
 480
 481   tc = tcp_half_open_connection_get (conn_index);
 482   wrk = tcp_get_worker (tc->c_thread_index);
 483   tcp_timer_reset (&wrk->timer_wheel, tc, TCP_TIMER_RETRANSMIT_SYN);
 484   tcp_half_open_connection_free (tc);
 485 }
 486
 487 static void
 488 tcp_session_reset (u32 conn_index, u32 thread_index)
 489 {
 490   tcp_connection_t *tc;
 491   tc = tcp_connection_get (conn_index, thread_index);
 492   tcp_send_reset (tc);
 493   tcp_connection_timers_reset (tc);
 494   tcp_cong_recovery_off (tc);
 495   tcp_connection_set_state (tc, TCP_STATE_CLOSED);
 496   session_transport_closed_notify (&tc->connection);
 497   tcp_program_cleanup (tcp_get_worker (thread_index), tc);
 498 }
 499
 500 /**
 501  * Initialize all connection timers as invalid
 502  */
 503 void
 504 tcp_connection_timers_init (tcp_connection_t * tc)
 505 {
 506   int i;
 507
 508   /* Set all to invalid */
 509   for (i = 0; i < TCP_N_TIMERS; i++)
 510     {
 511       tc->timers[i] = TCP_TIMER_HANDLE_INVALID;
 512     }
 513
 514   tc->rto = TCP_RTO_INIT;
 515 }
 516
 517 /**
 518  * Stop all connection timers
 519  */
 520 void
 521 tcp_connection_timers_reset (tcp_connection_t * tc)
 522 {
 523   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 524   int i;
 525
 526   for (i = 0; i < TCP_N_TIMERS; i++)
 527     tcp_timer_reset (&wrk->timer_wheel, tc, i);
 528 }
 529
 530 #if 0
 531 typedef struct ip4_tcp_hdr
 532 {
 533   ip4_header_t ip;
 534   tcp_header_t tcp;
 535 } ip4_tcp_hdr_t;
 536
 537 typedef struct ip6_tcp_hdr
 538 {
 539   ip6_header_t ip;
 540   tcp_header_t tcp;
 541 } ip6_tcp_hdr_t;
 542
 543 static void
 544 tcp_connection_select_lb_bucket (tcp_connection_t * tc, const dpo_id_t * dpo,
 545                                  dpo_id_t * result)
 546 {
 547   const dpo_id_t *choice;
 548   load_balance_t *lb;
 549   int hash;
 550
 551   lb = load_balance_get (dpo->dpoi_index);
 552   if (tc->c_is_ip4)
 553     {
 554       ip4_tcp_hdr_t hdr;
 555       clib_memset (&hdr, 0, sizeof (hdr));
 556       hdr.ip.protocol = IP_PROTOCOL_TCP;
 557       hdr.ip.address_pair.src.as_u32 = tc->c_lcl_ip.ip4.as_u32;
 558       hdr.ip.address_pair.dst.as_u32 = tc->c_rmt_ip.ip4.as_u32;
 559       hdr.tcp.src_port = tc->c_lcl_port;
 560       hdr.tcp.dst_port = tc->c_rmt_port;
 561       hash = ip4_compute_flow_hash (&hdr.ip, lb->lb_hash_config);
 562     }
 563   else
 564     {
 565       ip6_tcp_hdr_t hdr;
 566       clib_memset (&hdr, 0, sizeof (hdr));
 567       hdr.ip.protocol = IP_PROTOCOL_TCP;
 568       clib_memcpy_fast (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
 569                         sizeof (ip6_address_t));
 570       clib_memcpy_fast (&hdr.ip.dst_address, &tc->c_rmt_ip.ip6,
 571                         sizeof (ip6_address_t));
 572       hdr.tcp.src_port = tc->c_lcl_port;
 573       hdr.tcp.dst_port = tc->c_rmt_port;
 574       hash = ip6_compute_flow_hash (&hdr.ip, lb->lb_hash_config);
 575     }
 576   choice = load_balance_get_bucket_i (lb, hash & lb->lb_n_buckets_minus_1);
 577   dpo_copy (result, choice);
 578 }
 579
 580 fib_node_index_t
 581 tcp_lookup_rmt_in_fib (tcp_connection_t * tc)
 582 {
 583   fib_prefix_t prefix;
 584   u32 fib_index;
 585
 586   clib_memcpy_fast (&prefix.fp_addr, &tc->c_rmt_ip, sizeof (prefix.fp_addr));
 587   prefix.fp_proto = tc->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
 588   prefix.fp_len = tc->c_is_ip4 ? 32 : 128;
 589   fib_index = fib_table_find (prefix.fp_proto, tc->c_fib_index);
 590   return fib_table_lookup (fib_index, &prefix);
 591 }
 592
 593 static int
 594 tcp_connection_stack_on_fib_entry (tcp_connection_t * tc)
 595 {
 596   dpo_id_t choice = DPO_INVALID;
 597   u32 output_node_index;
 598   fib_entry_t *fe;
 599
 600   fe = fib_entry_get (tc->c_rmt_fei);
 601   if (fe->fe_lb.dpoi_type != DPO_LOAD_BALANCE)
 602     return -1;
 603
 604   tcp_connection_select_lb_bucket (tc, &fe->fe_lb, &choice);
 605
 606   output_node_index =
 607     tc->c_is_ip4 ? tcp4_output_node.index : tcp6_output_node.index;
 608   dpo_stack_from_node (output_node_index, &tc->c_rmt_dpo, &choice);
 609   return 0;
 610 }
 611
 612 /** Stack tcp connection on peer's fib entry.
 613  *
 614  * This ultimately populates the dpo the connection will use to send packets.
 615  */
 616 static void
 617 tcp_connection_fib_attach (tcp_connection_t * tc)
 618 {
 619   tc->c_rmt_fei = tcp_lookup_rmt_in_fib (tc);
 620
 621   ASSERT (tc->c_rmt_fei != FIB_NODE_INDEX_INVALID);
 622
 623   tcp_connection_stack_on_fib_entry (tc);
 624 }
 625 #endif /* 0 */
 626
 627 /**
 628  * Generate random iss as per rfc6528
 629  */
 630 static u32
 631 tcp_generate_random_iss (tcp_connection_t * tc)
 632 {
 633   tcp_main_t *tm = &tcp_main;
 634   u64 tmp;
 635
 636   if (tc->c_is_ip4)
 637     tmp = (u64) tc->c_lcl_ip.ip4.as_u32 << 32 | (u64) tc->c_rmt_ip.ip4.as_u32;
 638   else
 639     tmp = tc->c_lcl_ip.ip6.as_u64[0] ^ tc->c_lcl_ip.ip6.as_u64[1]
 640       ^ tc->c_rmt_ip.ip6.as_u64[0] ^ tc->c_rmt_ip.ip6.as_u64[1];
 641
 642   tmp ^= tm->iss_seed.first | ((u64) tc->c_lcl_port << 16 | tc->c_rmt_port);
 643   tmp ^= tm->iss_seed.second;
 644   tmp = clib_xxhash (tmp) + clib_cpu_time_now ();
 645   return ((tmp >> 32) ^ (tmp & 0xffffffff));
 646 }
 647
 648 /**
 649  * Initialize max segment size we're able to process.
 650  *
 651  * The value is constrained by the output interface's MTU and by the size
 652  * of the IP and TCP headers (see RFC6691). It is also what we advertise
 653  * to our peer.
 654  */
 655 static void
 656 tcp_init_rcv_mss (tcp_connection_t * tc)
 657 {
 658   u8 ip_hdr_len;
 659
 660   /* Already provided at connection init time */
 661   if (tc->mss)
 662     return;
 663
 664   ip_hdr_len = tc->c_is_ip4 ? sizeof (ip4_header_t) : sizeof (ip6_header_t);
 665   tc->mss = tcp_cfg.default_mtu - sizeof (tcp_header_t) - ip_hdr_len;
 666 }
 667
 668 static void
 669 tcp_init_mss (tcp_connection_t * tc)
 670 {
 671   u16 default_min_mss = 536;
 672
 673   tcp_init_rcv_mss (tc);
 674
 675   /* TODO consider PMTU discovery */
 676   tc->snd_mss = clib_min (tc->rcv_opts.mss, tc->mss);
 677
 678   if (tc->snd_mss < 45)
 679     {
 680       /* Assume that at least the min default mss works */
 681       tc->snd_mss = default_min_mss;
 682       tc->rcv_opts.mss = default_min_mss;
 683     }
 684
 685   /* We should have enough space for 40 bytes of options */
 686   ASSERT (tc->snd_mss > 45);
 687
 688   /* If we use timestamp option, account for it and make sure
 689    * the options are 4-byte aligned */
 690   if (tcp_opts_tstamp (&tc->rcv_opts))
 691     tc->snd_mss -= TCP_OPTION_LEN_TIMESTAMP + 2 /* alignment */;
 692 }
 693
 694 /**
 695  * Initialize connection send variables.
 696  */
 697 void
 698 tcp_init_snd_vars (tcp_connection_t * tc)
 699 {
 700   /*
 701    * We use the time to randomize iss and for setting up the initial
 702    * timestamp. Make sure it's updated otherwise syn and ack in the
 703    * handshake may make it look as if time has flown in the opposite
 704    * direction for us.
 705    */
 706   tcp_update_time_now (tcp_get_worker (vlib_get_thread_index ()));
 707
 708   tcp_init_rcv_mss (tc);
 709   /*
 710    * In special case of early-kill of timewait socket, the iss will already
 711    * be initialized to ensure it is greater than the last incarnation of the
 712    * connection. see syn_during_timewait() for more details.
 713    */
 714   if (!tc->iss)
 715     tc->iss = tcp_generate_random_iss (tc);
 716   tc->snd_una = tc->iss;
 717   tc->snd_nxt = tc->iss + 1;
 718   tc->srtt = 0.1 * THZ;         /* 100 ms */
 719
 720   if (!tcp_cfg.csum_offload)
 721     tc->cfg_flags |= TCP_CFG_F_NO_CSUM_OFFLOAD;
 722 }
 723
 724 void
 725 tcp_enable_pacing (tcp_connection_t * tc)
 726 {
 727   u32 byte_rate;
 728   byte_rate = tc->cwnd / (tc->srtt * TCP_TICK);
 729   transport_connection_tx_pacer_init (&tc->connection, byte_rate, tc->cwnd);
 730   tc->mrtt_us = (u32) ~ 0;
 731 }
 732
 733 /** Initialize tcp connection variables
 734  *
 735  * Should be called after having received a msg from the peer, i.e., a SYN or
 736  * a SYNACK, such that connection options have already been exchanged. */
 737 void
 738 tcp_connection_init_vars (tcp_connection_t * tc)
 739 {
 740   tcp_connection_timers_init (tc);
 741   tcp_init_mss (tc);
 742   scoreboard_init (&tc->sack_sb);
 743   if (tc->state == TCP_STATE_SYN_RCVD)
 744     tcp_init_snd_vars (tc);
 745
 746   tcp_cc_init (tc);
 747
 748   if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
 749     tcp_add_del_adjacency (tc, 1);
 750
 751   /*  tcp_connection_fib_attach (tc); */
 752
 753   if (transport_connection_is_tx_paced (&tc->connection)
 754       || tcp_cfg.enable_tx_pacing)
 755     tcp_enable_pacing (tc);
 756
 757   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
 758     tcp_bt_init (tc);
 759
 760   if (!tcp_cfg.allow_tso)
 761     tc->cfg_flags |= TCP_CFG_F_NO_TSO;
 762
 763   tc->start_ts = tcp_time_now_us (tc->c_thread_index);
 764 }
 765
 766 static int
 767 tcp_alloc_custom_local_endpoint (tcp_main_t * tm, ip46_address_t * lcl_addr,
 768                                  u16 * lcl_port, u8 is_ip4)
 769 {
 770   int index, port;
 771   if (is_ip4)
 772     {
 773       index = tm->last_v4_addr_rotor++;
 774       if (tm->last_v4_addr_rotor >= vec_len (tcp_cfg.ip4_src_addrs))
 775         tm->last_v4_addr_rotor = 0;
 776       clib_memset (lcl_addr, 0, sizeof (*lcl_addr));
 777       lcl_addr->ip4.as_u32 = tcp_cfg.ip4_src_addrs[index].as_u32;
 778     }
 779   else
 780     {
 781       index = tm->last_v6_addr_rotor++;
 782       if (tm->last_v6_addr_rotor >= vec_len (tcp_cfg.ip6_src_addrs))
 783         tm->last_v6_addr_rotor = 0;
 784       clib_memcpy_fast (&lcl_addr->ip6, &tcp_cfg.ip6_src_addrs[index],
 785                         sizeof (ip6_address_t));
 786     }
 787   port = transport_alloc_local_port (TRANSPORT_PROTO_TCP, lcl_addr);
 788   if (port < 1)
 789     return SESSION_E_NOPORT;
 790   *lcl_port = port;
 791   return 0;
 792 }
 793
 794 static int
 795 tcp_session_open (transport_endpoint_cfg_t * rmt)
 796 {
 797   tcp_main_t *tm = vnet_get_tcp_main ();
 798   tcp_connection_t *tc;
 799   ip46_address_t lcl_addr;
 800   u16 lcl_port;
 801   int rv;
 802
 803   /*
 804    * Allocate local endpoint
 805    */
 806   if ((rmt->is_ip4 && vec_len (tcp_cfg.ip4_src_addrs))
 807       || (!rmt->is_ip4 && vec_len (tcp_cfg.ip6_src_addrs)))
 808     rv = tcp_alloc_custom_local_endpoint (tm, &lcl_addr, &lcl_port,
 809                                           rmt->is_ip4);
 810   else
 811     rv = transport_alloc_local_endpoint (TRANSPORT_PROTO_TCP,
 812                                          rmt, &lcl_addr, &lcl_port);
 813
 814   if (rv)
 815     {
 816       if (rv != SESSION_E_PORTINUSE)
 817         return rv;
 818
 819       if (session_lookup_connection (rmt->fib_index, &lcl_addr, &rmt->ip,
 820                                      lcl_port, rmt->port, TRANSPORT_PROTO_TCP,
 821                                      rmt->is_ip4))
 822         return SESSION_E_PORTINUSE;
 823
 824       /* 5-tuple is available so increase lcl endpoint refcount and proceed
 825        * with connection allocation */
 826       transport_share_local_endpoint (TRANSPORT_PROTO_TCP, &lcl_addr,
 827                                       lcl_port);
 828     }
 829
 830   /*
 831    * Create connection and send SYN
 832    */
 833   tc = tcp_half_open_connection_alloc ();
 834   ip_copy (&tc->c_rmt_ip, &rmt->ip, rmt->is_ip4);
 835   ip_copy (&tc->c_lcl_ip, &lcl_addr, rmt->is_ip4);
 836   tc->c_rmt_port = rmt->port;
 837   tc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
 838   tc->c_is_ip4 = rmt->is_ip4;
 839   tc->c_proto = TRANSPORT_PROTO_TCP;
 840   tc->c_fib_index = rmt->fib_index;
 841   tc->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo);
 842   /* The other connection vars will be initialized after SYN ACK */
 843   tcp_connection_timers_init (tc);
 844   tc->mss = rmt->mss;
 845   if (rmt->peer.sw_if_index != ENDPOINT_INVALID_INDEX)
 846     tc->sw_if_index = rmt->peer.sw_if_index;
 847   tc->next_node_index = rmt->next_node_index;
 848   tc->next_node_opaque = rmt->next_node_opaque;
 849
 850   TCP_EVT (TCP_EVT_OPEN, tc);
 851   tc->state = TCP_STATE_SYN_SENT;
 852   tcp_init_snd_vars (tc);
 853   tcp_send_syn (tc);
 854
 855   return tc->c_c_index;
 856 }
 857
 858 static u8 *
 859 format_tcp_session (u8 * s, va_list * args)
 860 {
 861   u32 tci = va_arg (*args, u32);
 862   u32 thread_index = va_arg (*args, u32);
 863   u32 verbose = va_arg (*args, u32);
 864   tcp_connection_t *tc;
 865
 866   tc = tcp_connection_get (tci, thread_index);
 867   if (tc)
 868     s = format (s, "%U", format_tcp_connection, tc, verbose);
 869   else
 870     s = format (s, "empty\n");
 871   return s;
 872 }
 873
 874 static u8 *
 875 format_tcp_listener_session (u8 * s, va_list * args)
 876 {
 877   u32 tci = va_arg (*args, u32);
 878   u32 __clib_unused thread_index = va_arg (*args, u32);
 879   u32 verbose = va_arg (*args, u32);
 880   tcp_connection_t *tc = tcp_listener_get (tci);
 881   s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_tcp_connection_id, tc);
 882   if (verbose)
 883     s = format (s, "%-" SESSION_CLI_STATE_LEN "U", format_tcp_state,
 884                 tc->state);
 885   return s;
 886 }
 887
 888 static u8 *
 889 format_tcp_half_open_session (u8 * s, va_list * args)
 890 {
 891   u32 tci = va_arg (*args, u32);
 892   u32 __clib_unused thread_index = va_arg (*args, u32);
 893   u32 verbose = va_arg (*args, u32);
 894   tcp_connection_t *tc;
 895   u8 *state = 0;
 896
 897   tc = tcp_half_open_connection_get (tci);
 898   if (tc->flags & TCP_CONN_HALF_OPEN_DONE)
 899     state = format (state, "%s", "CLOSED");
 900   else
 901     state = format (state, "%U", format_tcp_state, tc->state);
 902   s = format (s, "%-" SESSION_CLI_ID_LEN "U", format_tcp_connection_id, tc);
 903   if (verbose)
 904     s = format (s, "%-" SESSION_CLI_STATE_LEN "v", state);
 905   vec_free (state);
 906   return s;
 907 }
 908
 909 static transport_connection_t *
 910 tcp_session_get_transport (u32 conn_index, u32 thread_index)
 911 {
 912   tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index);
 913   if (PREDICT_FALSE (!tc))
 914     return 0;
 915   return &tc->connection;
 916 }
 917
 918 static transport_connection_t *
 919 tcp_half_open_session_get_transport (u32 conn_index)
 920 {
 921   tcp_connection_t *tc = tcp_half_open_connection_get (conn_index);
 922   return &tc->connection;
 923 }
 924
 925 static int
 926 tcp_set_attribute (tcp_connection_t *tc, transport_endpt_attr_t *attr)
 927 {
 928   int rv = 0;
 929
 930   switch (attr->type)
 931     {
 932     case TRANSPORT_ENDPT_ATTR_NEXT_OUTPUT_NODE:
 933       tc->next_node_index = attr->next_output_node & 0xffffffff;
 934       tc->next_node_opaque = attr->next_output_node >> 32;
 935       break;
 936     case TRANSPORT_ENDPT_ATTR_MSS:
 937       tc->mss = attr->mss;
 938       tc->snd_mss = clib_min (tc->snd_mss, tc->mss);
 939       break;
 940     case TRANSPORT_ENDPT_ATTR_FLAGS:
 941       if (attr->flags & TRANSPORT_ENDPT_ATTR_F_CSUM_OFFLOAD)
 942         tc->cfg_flags |= TCP_CFG_F_NO_CSUM_OFFLOAD;
 943       else
 944         tc->cfg_flags &= ~TCP_CFG_F_NO_CSUM_OFFLOAD;
 945       if (attr->flags & TRANSPORT_ENDPT_ATTR_F_GSO)
 946         {
 947           if (!(tc->cfg_flags & TCP_CFG_F_TSO))
 948             tcp_check_gso (tc);
 949           tc->cfg_flags &= ~TCP_CFG_F_NO_TSO;
 950         }
 951       else
 952         {
 953           tc->cfg_flags |= TCP_CFG_F_NO_TSO;
 954           tc->cfg_flags &= ~TCP_CFG_F_TSO;
 955         }
 956       if (attr->flags & TRANSPORT_ENDPT_ATTR_F_RATE_SAMPLING)
 957         {
 958           if (!(tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE))
 959             tcp_bt_init (tc);
 960           tc->cfg_flags |= TCP_CFG_F_RATE_SAMPLE;
 961         }
 962       else
 963         {
 964           if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
 965             tcp_bt_cleanup (tc);
 966           tc->cfg_flags &= ~TCP_CFG_F_RATE_SAMPLE;
 967         }
 968       break;
 969     case TRANSPORT_ENDPT_ATTR_CC_ALGO:
 970       if (tc->cc_algo == tcp_cc_algo_get (attr->cc_algo))
 971         break;
 972       tcp_cc_cleanup (tc);
 973       tc->cc_algo = tcp_cc_algo_get (attr->cc_algo);
 974       tcp_cc_init (tc);
 975       break;
 976     default:
 977       rv = -1;
 978       break;
 979     }
 980
 981   return rv;
 982 }
 983
 984 static int
 985 tcp_get_attribute (tcp_connection_t *tc, transport_endpt_attr_t *attr)
 986 {
 987   int rv = 0;
 988   u64 non;
 989
 990   switch (attr->type)
 991     {
 992     case TRANSPORT_ENDPT_ATTR_NEXT_OUTPUT_NODE:
 993       non = (u64) tc->next_node_opaque << 32 | tc->next_node_index;
 994       attr->next_output_node = non;
 995       break;
 996     case TRANSPORT_ENDPT_ATTR_MSS:
 997       attr->mss = tc->snd_mss;
 998       break;
 999     case TRANSPORT_ENDPT_ATTR_FLAGS:
1000       attr->flags = 0;
1001       if (!(tc->cfg_flags & TCP_CFG_F_NO_CSUM_OFFLOAD))
1002         attr->flags |= TRANSPORT_ENDPT_ATTR_F_CSUM_OFFLOAD;
1003       if (tc->cfg_flags & TCP_CFG_F_TSO)
1004         attr->flags |= TRANSPORT_ENDPT_ATTR_F_GSO;
1005       if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
1006         attr->flags |= TRANSPORT_ENDPT_ATTR_F_RATE_SAMPLING;
1007       break;
1008     case TRANSPORT_ENDPT_ATTR_CC_ALGO:
1009       attr->cc_algo = tc->cc_algo - tcp_main.cc_algos;
1010       break;
1011     default:
1012       rv = -1;
1013       break;
1014     }
1015
1016   return rv;
1017 }
1018
1019 static int
1020 tcp_session_attribute (u32 conn_index, u32 thread_index, u8 is_get,
1021                        transport_endpt_attr_t *attr)
1022 {
1023   tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index);
1024
1025   if (PREDICT_FALSE (!tc))
1026     return -1;
1027
1028   if (is_get)
1029     return tcp_get_attribute (tc, attr);
1030   else
1031     return tcp_set_attribute (tc, attr);
1032 }
1033
1034 static u16
1035 tcp_session_cal_goal_size (tcp_connection_t * tc)
1036 {
1037   u16 goal_size = tc->snd_mss;
1038
1039   goal_size = tcp_cfg.max_gso_size - tc->snd_mss % tcp_cfg.max_gso_size;
1040   goal_size = clib_min (goal_size, tc->snd_wnd / 2);
1041
1042   return goal_size > tc->snd_mss ? goal_size : tc->snd_mss;
1043 }
1044
1045 always_inline u32
1046 tcp_round_snd_space (tcp_connection_t * tc, u32 snd_space)
1047 {
1048   if (PREDICT_FALSE (tc->snd_wnd < tc->snd_mss))
1049     {
1050       return tc->snd_wnd <= snd_space ? tc->snd_wnd : 0;
1051     }
1052
1053   /* If not snd_wnd constrained and we can't write at least a segment,
1054    * don't try at all */
1055   if (PREDICT_FALSE (snd_space < tc->snd_mss))
1056     return snd_space < tc->cwnd ? 0 : snd_space;
1057
1058   /* round down to mss multiple */
1059   return snd_space - (snd_space % tc->snd_mss);
1060 }
1061
1062 /**
1063  * Compute tx window session is allowed to fill.
1064  *
1065  * Takes into account available send space, snd_mss and the congestion
1066  * state of the connection. If possible, the value returned is a multiple
1067  * of snd_mss.
1068  *
1069  * @param tc tcp connection
1070  * @return number of bytes session is allowed to write
1071  */
1072 static inline u32
1073 tcp_snd_space_inline (tcp_connection_t * tc)
1074 {
1075   int snd_space;
1076
1077   /* Fast path is disabled when recovery is on. @ref tcp_session_custom_tx
1078    * controls both retransmits and the sending of new data while congested
1079    */
1080   if (PREDICT_FALSE (tcp_in_cong_recovery (tc)
1081                      || tc->state == TCP_STATE_CLOSED))
1082     return 0;
1083
1084   snd_space = tcp_available_output_snd_space (tc);
1085
1086   /* If we got dupacks or sacked bytes but we're not yet in recovery, try
1087    * to force the peer to send enough dupacks to start retransmitting as
1088    * per Limited Transmit (RFC3042)
1089    */
1090   if (PREDICT_FALSE (tc->rcv_dupacks || tc->sack_sb.sacked_bytes))
1091     {
1092       int snt_limited, n_pkts;
1093
1094       n_pkts = tcp_opts_sack_permitted (&tc->rcv_opts)
1095         ? tc->sack_sb.reorder - 1 : 2;
1096
1097       if ((seq_lt (tc->limited_transmit, tc->snd_nxt - n_pkts * tc->snd_mss)
1098            || seq_gt (tc->limited_transmit, tc->snd_nxt)))
1099         tc->limited_transmit = tc->snd_nxt;
1100
1101       ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt));
1102
1103       snt_limited = tc->snd_nxt - tc->limited_transmit;
1104       snd_space = clib_max (n_pkts * tc->snd_mss - snt_limited, 0);
1105     }
1106   return tcp_round_snd_space (tc, snd_space);
1107 }
1108
1109 u32
1110 tcp_snd_space (tcp_connection_t * tc)
1111 {
1112   return tcp_snd_space_inline (tc);
1113 }
1114
1115 static int
1116 tcp_session_send_params (transport_connection_t * trans_conn,
1117                          transport_send_params_t * sp)
1118 {
1119   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
1120
1121   /* Ensure snd_mss does accurately reflect the amount of data we can push
1122    * in a segment. This also makes sure that options are updated according to
1123    * the current state of the connection. */
1124   tcp_update_burst_snd_vars (tc);
1125
1126   if (PREDICT_FALSE (tc->cfg_flags & TCP_CFG_F_TSO))
1127     sp->snd_mss = tcp_session_cal_goal_size (tc);
1128   else
1129     sp->snd_mss = tc->snd_mss;
1130
1131   sp->snd_space = clib_min (tcp_snd_space_inline (tc),
1132                             tc->snd_wnd - (tc->snd_nxt - tc->snd_una));
1133
1134   ASSERT (seq_geq (tc->snd_nxt, tc->snd_una));
1135   /* This still works if fast retransmit is on */
1136   sp->tx_offset = tc->snd_nxt - tc->snd_una;
1137
1138   sp->flags = sp->snd_space ? 0 : TRANSPORT_SND_F_DESCHED;
1139
1140   return 0;
1141 }
1142
1143 static void
1144 tcp_timer_waitclose_handler (tcp_connection_t * tc)
1145 {
1146   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
1147
1148   switch (tc->state)
1149     {
1150     case TCP_STATE_CLOSE_WAIT:
1151       tcp_connection_timers_reset (tc);
1152       /* App never returned with a close */
1153       if (!(tc->flags & TCP_CONN_FINPNDG))
1154         {
1155           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1156           session_transport_closed_notify (&tc->connection);
1157           tcp_program_cleanup (wrk, tc);
1158           tcp_worker_stats_inc (wrk, to_closewait, 1);
1159           break;
1160         }
1161
1162       /* Send FIN either way and switch to LAST_ACK. */
1163       tcp_cong_recovery_off (tc);
1164       /* Make sure we don't try to send unsent data */
1165       tc->snd_nxt = tc->snd_una;
1166       tcp_send_fin (tc);
1167       tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
1168       session_transport_closed_notify (&tc->connection);
1169
1170       /* Make sure we don't wait in LAST ACK forever */
1171       tcp_timer_set (&wrk->timer_wheel, tc, TCP_TIMER_WAITCLOSE,
1172                      tcp_cfg.lastack_time);
1173       tcp_worker_stats_inc (wrk, to_closewait2, 1);
1174
1175       /* Don't delete the connection yet */
1176       break;
1177     case TCP_STATE_FIN_WAIT_1:
1178       tcp_connection_timers_reset (tc);
1179       if (tc->flags & TCP_CONN_FINPNDG)
1180         {
1181           /* If FIN pending, we haven't sent everything, but we did try.
1182            * Notify session layer that transport is closed. */
1183           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1184           tcp_send_reset (tc);
1185           tcp_program_cleanup (wrk, tc);
1186         }
1187       else
1188         {
1189           /* We've sent the fin but no progress. Close the connection and
1190            * to make sure everything is flushed, setup a cleanup timer */
1191           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1192           tcp_program_cleanup (wrk, tc);
1193         }
1194       session_transport_closed_notify (&tc->connection);
1195       tcp_worker_stats_inc (wrk, to_finwait1, 1);
1196       break;
1197     case TCP_STATE_LAST_ACK:
1198       tcp_connection_timers_reset (tc);
1199       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1200       session_transport_closed_notify (&tc->connection);
1201       tcp_program_cleanup (wrk, tc);
1202       tcp_worker_stats_inc (wrk, to_lastack, 1);
1203       break;
1204     case TCP_STATE_CLOSING:
1205       tcp_connection_timers_reset (tc);
1206       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1207       session_transport_closed_notify (&tc->connection);
1208       tcp_program_cleanup (wrk, tc);
1209       tcp_worker_stats_inc (wrk, to_closing, 1);
1210       break;
1211     case TCP_STATE_FIN_WAIT_2:
1212       tcp_send_reset (tc);
1213       tcp_connection_timers_reset (tc);
1214       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1215       session_transport_closed_notify (&tc->connection);
1216       tcp_program_cleanup (wrk, tc);
1217       tcp_worker_stats_inc (wrk, to_finwait2, 1);
1218       break;
1219     case TCP_STATE_TIME_WAIT:
1220       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1221       tcp_program_cleanup (wrk, tc);
1222       break;
1223     default:
1224       clib_warning ("waitclose in state: %U", format_tcp_state, tc->state);
1225       break;
1226     }
1227 }
1228
1229 /* *INDENT-OFF* */
1230 static timer_expiration_handler *timer_expiration_handlers[TCP_N_TIMERS] =
1231 {
1232     tcp_timer_retransmit_handler,
1233     tcp_timer_persist_handler,
1234     tcp_timer_waitclose_handler,
1235     tcp_timer_retransmit_syn_handler,
1236 };
1237 /* *INDENT-ON* */
1238
1239 static void
1240 tcp_dispatch_pending_timers (tcp_worker_ctx_t * wrk)
1241 {
1242   u32 n_timers, connection_index, timer_id, thread_index, timer_handle;
1243   tcp_connection_t *tc;
1244   int i;
1245
1246   if (!(n_timers = clib_fifo_elts (wrk->pending_timers)))
1247     return;
1248
1249   thread_index = wrk->vm->thread_index;
1250   for (i = 0; i < clib_min (n_timers, wrk->max_timers_per_loop); i++)
1251     {
1252       clib_fifo_sub1 (wrk->pending_timers, timer_handle);
1253       connection_index = timer_handle & 0x0FFFFFFF;
1254       timer_id = timer_handle >> 28;
1255
1256       if (PREDICT_TRUE (timer_id != TCP_TIMER_RETRANSMIT_SYN))
1257         tc = tcp_connection_get (connection_index, thread_index);
1258       else
1259         tc = tcp_half_open_connection_get (connection_index);
1260
1261       if (PREDICT_FALSE (!tc))
1262         continue;
1263
1264       /* Skip if the timer is not pending. Probably it was reset while
1265        * waiting for dispatch */
1266       if (PREDICT_FALSE (!(tc->pending_timers & (1 << timer_id))))
1267         continue;
1268
1269       tc->pending_timers &= ~(1 << timer_id);
1270
1271       /* Skip timer if it was rearmed while pending dispatch */
1272       if (PREDICT_FALSE (tc->timers[timer_id] != TCP_TIMER_HANDLE_INVALID))
1273         continue;
1274
1275       (*timer_expiration_handlers[timer_id]) (tc);
1276     }
1277
1278   if (thread_index == 0 && clib_fifo_elts (wrk->pending_timers))
1279     session_queue_run_on_main_thread (wrk->vm);
1280 }
1281
1282 static void
1283 tcp_handle_cleanups (tcp_worker_ctx_t * wrk, clib_time_type_t now)
1284 {
1285   u32 thread_index = wrk->vm->thread_index;
1286   tcp_cleanup_req_t *req;
1287   tcp_connection_t *tc;
1288
1289   while (clib_fifo_elts (wrk->pending_cleanups))
1290     {
1291       req = clib_fifo_head (wrk->pending_cleanups);
1292       if (req->free_time > now)
1293         break;
1294       clib_fifo_sub2 (wrk->pending_cleanups, req);
1295       tc = tcp_connection_get (req->connection_index, thread_index);
1296       if (PREDICT_FALSE (!tc))
1297         continue;
1298       session_transport_delete_notify (&tc->connection);
1299       tcp_connection_cleanup (tc);
1300     }
1301 }
1302
1303 static void
1304 tcp_update_time (f64 now, u8 thread_index)
1305 {
1306   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
1307
1308   tcp_set_time_now (wrk, now);
1309   tcp_handle_cleanups (wrk, now);
1310   tcp_timer_expire_timers (&wrk->timer_wheel, now);
1311   tcp_dispatch_pending_timers (wrk);
1312 }
1313
1314 static void
1315 tcp_session_flush_data (transport_connection_t * tconn)
1316 {
1317   tcp_connection_t *tc = (tcp_connection_t *) tconn;
1318   if (tc->flags & TCP_CONN_PSH_PENDING)
1319     return;
1320   tc->flags |= TCP_CONN_PSH_PENDING;
1321   tc->psh_seq = tc->snd_una + transport_max_tx_dequeue (tconn) - 1;
1322 }
1323
1324 static int
1325 tcp_session_app_rx_evt (transport_connection_t *conn)
1326 {
1327   tcp_connection_t *tc = (tcp_connection_t *) conn;
1328   u32 min_free, lo = 4 << 10, hi = 128 << 10;
1329
1330   if (!(tc->flags & TCP_CONN_ZERO_RWND_SENT))
1331     return 0;
1332
1333   min_free = clib_clamp (transport_rx_fifo_size (conn) >> 3, lo, hi);
1334   if (transport_max_rx_enqueue (conn) < min_free)
1335     {
1336       transport_rx_fifo_req_deq_ntf (conn);
1337       return 0;
1338     }
1339
1340   tcp_send_ack (tc);
1341
1342   return 0;
1343 }
1344
1345 /* *INDENT-OFF* */
1346 const static transport_proto_vft_t tcp_proto = {
1347   .enable = vnet_tcp_enable_disable,
1348   .start_listen = tcp_session_bind,
1349   .stop_listen = tcp_session_unbind,
1350   .push_header = tcp_session_push_header,
1351   .get_connection = tcp_session_get_transport,
1352   .get_listener = tcp_session_get_listener,
1353   .get_half_open = tcp_half_open_session_get_transport,
1354   .attribute = tcp_session_attribute,
1355   .connect = tcp_session_open,
1356   .half_close = tcp_session_half_close,
1357   .close = tcp_session_close,
1358   .cleanup = tcp_session_cleanup,
1359   .cleanup_ho = tcp_session_cleanup_ho,
1360   .reset = tcp_session_reset,
1361   .send_params = tcp_session_send_params,
1362   .update_time = tcp_update_time,
1363   .flush_data = tcp_session_flush_data,
1364   .custom_tx = tcp_session_custom_tx,
1365   .app_rx_evt = tcp_session_app_rx_evt,
1366   .format_connection = format_tcp_session,
1367   .format_listener = format_tcp_listener_session,
1368   .format_half_open = format_tcp_half_open_session,
1369   .transport_options = {
1370     .name = "tcp",
1371     .short_name = "T",
1372     .tx_type = TRANSPORT_TX_PEEK,
1373     .service_type = TRANSPORT_SERVICE_VC,
1374   },
1375 };
1376 /* *INDENT-ON* */
1377
1378 void
1379 tcp_connection_tx_pacer_update (tcp_connection_t * tc)
1380 {
1381   if (!transport_connection_is_tx_paced (&tc->connection))
1382     return;
1383
1384   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
1385
1386   transport_connection_tx_pacer_update (&tc->connection,
1387                                         tcp_cc_get_pacing_rate (tc),
1388                                         srtt * CLIB_US_TIME_FREQ);
1389 }
1390
1391 void
1392 tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window,
1393                                u32 start_bucket)
1394 {
1395   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
1396   transport_connection_tx_pacer_reset (&tc->connection,
1397                                        tcp_cc_get_pacing_rate (tc),
1398                                        start_bucket,
1399                                        srtt * CLIB_US_TIME_FREQ);
1400 }
1401
1402 void
1403 tcp_reschedule (tcp_connection_t * tc)
1404 {
1405   if (tcp_in_cong_recovery (tc) || tcp_snd_space_inline (tc))
1406     transport_connection_reschedule (&tc->connection);
1407 }
1408
1409 static void
1410 tcp_expired_timers_dispatch (u32 * expired_timers)
1411 {
1412   u32 thread_index = vlib_get_thread_index (), n_left, max_per_loop;
1413   u32 connection_index, timer_id, n_expired, max_loops;
1414   tcp_worker_ctx_t *wrk;
1415   tcp_connection_t *tc;
1416   int i;
1417
1418   wrk = tcp_get_worker (thread_index);
1419   n_expired = vec_len (expired_timers);
1420   tcp_worker_stats_inc (wrk, timer_expirations, n_expired);
1421   n_left = clib_fifo_elts (wrk->pending_timers);
1422
1423   /*
1424    * Invalidate all timer handles before dispatching. This avoids dangling
1425    * index references to timer wheel pool entries that have been freed.
1426    */
1427   for (i = 0; i < n_expired; i++)
1428     {
1429       connection_index = expired_timers[i] & 0x0FFFFFFF;
1430       timer_id = expired_timers[i] >> 28;
1431
1432       if (timer_id != TCP_TIMER_RETRANSMIT_SYN)
1433         tc = tcp_connection_get (connection_index, thread_index);
1434       else
1435         tc = tcp_half_open_connection_get (connection_index);
1436
1437       TCP_EVT (TCP_EVT_TIMER_POP, connection_index, timer_id);
1438
1439       tc->timers[timer_id] = TCP_TIMER_HANDLE_INVALID;
1440       tc->pending_timers |= (1 << timer_id);
1441     }
1442
1443   clib_fifo_add (wrk->pending_timers, expired_timers, n_expired);
1444
1445   max_loops =
1446     clib_max ((u32) 0.5 * TCP_TIMER_TICK * wrk->vm->loops_per_second, 1);
1447   max_per_loop = clib_max ((n_left + n_expired) / max_loops, 10);
1448   max_per_loop = clib_min (max_per_loop, VLIB_FRAME_SIZE);
1449   wrk->max_timers_per_loop = clib_max (n_left ? wrk->max_timers_per_loop : 0,
1450                                        max_per_loop);
1451
1452   if (thread_index == 0)
1453     session_queue_run_on_main_thread (wrk->vm);
1454 }
1455
1456 static void
1457 tcp_initialize_iss_seed (tcp_main_t * tm)
1458 {
1459   u32 default_seed = random_default_seed ();
1460   u64 time_now = clib_cpu_time_now ();
1461
1462   tm->iss_seed.first = (u64) random_u32 (&default_seed) << 32;
1463   tm->iss_seed.second = random_u64 (&time_now);
1464 }
1465
1466 static clib_error_t *
1467 tcp_main_enable (vlib_main_t * vm)
1468 {
1469   vlib_thread_main_t *vtm = vlib_get_thread_main ();
1470   u32 num_threads, n_workers, prealloc_conn_per_wrk;
1471   tcp_connection_t *tc __attribute__ ((unused));
1472   tcp_main_t *tm = vnet_get_tcp_main ();
1473   tcp_worker_ctx_t *wrk;
1474   clib_error_t *error = 0;
1475   int thread;
1476
1477   if ((error = vlib_call_init_function (vm, ip_main_init)))
1478     return error;
1479   if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
1480     return error;
1481   if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
1482     return error;
1483
1484   /*
1485    * Registrations
1486    */
1487
1488   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
1489   ip6_register_protocol (IP_PROTOCOL_TCP, tcp6_input_node.index);
1490
1491   /*
1492    * Initialize data structures
1493    */
1494
1495   num_threads = 1 /* main thread */  + vtm->n_threads;
1496   vec_validate (tm->wrk_ctx, num_threads - 1);
1497   n_workers = num_threads == 1 ? 1 : vtm->n_threads;
1498   prealloc_conn_per_wrk = tcp_cfg.preallocated_connections / n_workers;
1499
1500   wrk = &tm->wrk_ctx[0];
1501   wrk->tco_next_node[0] = vlib_node_get_next (vm, session_queue_node.index,
1502                                               tcp4_output_node.index);
1503   wrk->tco_next_node[1] = vlib_node_get_next (vm, session_queue_node.index,
1504                                               tcp6_output_node.index);
1505
1506   for (thread = 0; thread < num_threads; thread++)
1507     {
1508       wrk = &tm->wrk_ctx[thread];
1509
1510       vec_validate (wrk->pending_deq_acked, 255);
1511       vec_validate (wrk->pending_disconnects, 255);
1512       vec_validate (wrk->pending_resets, 255);
1513       vec_reset_length (wrk->pending_deq_acked);
1514       vec_reset_length (wrk->pending_disconnects);
1515       vec_reset_length (wrk->pending_resets);
1516       wrk->vm = vlib_get_main_by_index (thread);
1517       wrk->max_timers_per_loop = 10;
1518
1519       if (thread > 0)
1520         {
1521           wrk->tco_next_node[0] = tm->wrk_ctx[0].tco_next_node[0];
1522           wrk->tco_next_node[1] = tm->wrk_ctx[0].tco_next_node[1];
1523         }
1524
1525       /*
1526        * Preallocate connections. Assume that thread 0 won't
1527        * use preallocated threads when running multi-core
1528        */
1529       if ((thread > 0 || num_threads == 1) && prealloc_conn_per_wrk)
1530         pool_init_fixed (wrk->connections, prealloc_conn_per_wrk);
1531
1532       tcp_timer_initialize_wheel (&wrk->timer_wheel,
1533                                   tcp_expired_timers_dispatch,
1534                                   vlib_time_now (vm));
1535     }
1536
1537   tcp_initialize_iss_seed (tm);
1538
1539   tm->bytes_per_buffer = vlib_buffer_get_default_data_size (vm);
1540   tm->cc_last_type = TCP_CC_LAST;
1541
1542   tm->ipl_next_node[0] = vlib_node_get_next (vm, session_queue_node.index,
1543                                              ip4_lookup_node.index);
1544   tm->ipl_next_node[1] = vlib_node_get_next (vm, session_queue_node.index,
1545                                              ip6_lookup_node.index);
1546   return error;
1547 }
1548
1549 clib_error_t *
1550 vnet_tcp_enable_disable (vlib_main_t * vm, u8 is_en)
1551 {
1552   if (is_en)
1553     {
1554       if (tcp_main.is_enabled)
1555         return 0;
1556
1557       return tcp_main_enable (vm);
1558     }
1559   else
1560     {
1561       tcp_main.is_enabled = 0;
1562     }
1563
1564   return 0;
1565 }
1566
1567 void
1568 tcp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
1569 {
1570   tcp_main_t *tm = &tcp_main;
1571   if (is_ip4)
1572     tm->punt_unknown4 = is_add;
1573   else
1574     tm->punt_unknown6 = is_add;
1575 }
1576
1577 /**
1578  * Initialize default values for tcp parameters
1579  */
1580 static void
1581 tcp_configuration_init (void)
1582 {
1583   /* Initial wnd for SYN. Fifos are not allocated at that point so use some
1584    * predefined value. For SYN-ACK we still want the scale to be computed in
1585    * the same way */
1586   tcp_cfg.max_rx_fifo = 32 << 20;
1587   tcp_cfg.min_rx_fifo = 4 << 10;
1588
1589   tcp_cfg.default_mtu = 1500;
1590   tcp_cfg.initial_cwnd_multiplier = 0;
1591   tcp_cfg.enable_tx_pacing = 1;
1592   tcp_cfg.allow_tso = 0;
1593   tcp_cfg.csum_offload = 1;
1594   tcp_cfg.cc_algo = TCP_CC_CUBIC;
1595   tcp_cfg.rwnd_min_update_ack = 1;
1596   tcp_cfg.max_gso_size = TCP_MAX_GSO_SZ;
1597
1598   /* Time constants defined as timer tick (100us) multiples */
1599   tcp_cfg.closewait_time = 20000;       /* 2s */
1600   tcp_cfg.timewait_time = 100000;       /* 10s */
1601   tcp_cfg.finwait1_time = 600000;       /* 60s */
1602   tcp_cfg.lastack_time = 300000;        /* 30s */
1603   tcp_cfg.finwait2_time = 300000;       /* 30s */
1604   tcp_cfg.closing_time = 300000;        /* 30s */
1605   tcp_cfg.alloc_err_timeout = 1000;     /* 100ms */
1606
1607   /* This value is seconds */
1608   tcp_cfg.cleanup_time = 0.1;   /* 100ms */
1609 }
1610
1611 static clib_error_t *
1612 tcp_init (vlib_main_t * vm)
1613 {
1614   tcp_main_t *tm = vnet_get_tcp_main ();
1615   ip_main_t *im = &ip_main;
1616   ip_protocol_info_t *pi;
1617
1618   /* Session layer, and by implication tcp, are disabled by default */
1619   tm->is_enabled = 0;
1620
1621   /* Register with IP for header parsing */
1622   pi = ip_get_protocol_info (im, IP_PROTOCOL_TCP);
1623   if (pi == 0)
1624     return clib_error_return (0, "TCP protocol info AWOL");
1625   pi->format_header = format_tcp_header;
1626   pi->unformat_pg_edit = unformat_pg_tcp_header;
1627
1628   /* Register as transport with session layer */
1629   transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
1630                                FIB_PROTOCOL_IP4, tcp4_output_node.index);
1631   transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
1632                                FIB_PROTOCOL_IP6, tcp6_output_node.index);
1633
1634   tcp_configuration_init ();
1635
1636   tm->cc_algo_by_name = hash_create_string (0, sizeof (uword));
1637
1638   return 0;
1639 }
1640
1641 VLIB_INIT_FUNCTION (tcp_init);
1642
1643 /*
1644  * fd.io coding-style-patch-verification: ON
1645  *
1646  * Local Variables:
1647  * eval: (c-set-style "gnu")
1648  * End:
1649  */