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