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/session/session.h>
  23 #include <vnet/fib/fib.h>
  24 #include <vnet/dpo/load_balance.h>
  25 #include <vnet/dpo/receive_dpo.h>
  26 #include <vnet/ip-neighbor/ip_neighbor.h>
  27 #include <math.h>
  28
  29 tcp_main_t tcp_main;
  30
  31 typedef struct
  32 {
  33   fib_protocol_t nh_proto;
  34   vnet_link_t link_type;
  35   ip46_address_t ip;
  36   u32 sw_if_index;
  37   u8 is_add;
  38 } tcp_add_del_adj_args_t;
  39
  40 static void
  41 tcp_add_del_adj_cb (tcp_add_del_adj_args_t * args)
  42 {
  43   u32 ai;
  44   if (args->is_add)
  45     {
  46       adj_nbr_add_or_lock (args->nh_proto, args->link_type, &args->ip,
  47                            args->sw_if_index);
  48     }
  49   else
  50     {
  51       ai = adj_nbr_find (FIB_PROTOCOL_IP6, VNET_LINK_IP6, &args->ip,
  52                          args->sw_if_index);
  53       if (ai != ADJ_INDEX_INVALID)
  54         adj_unlock (ai);
  55     }
  56 }
  57
  58 static void
  59 tcp_add_del_adjacency (tcp_connection_t * tc, u8 is_add)
  60 {
  61   tcp_add_del_adj_args_t args = {
  62     .nh_proto = FIB_PROTOCOL_IP6,
  63     .link_type = VNET_LINK_IP6,
  64     .ip = tc->c_rmt_ip,
  65     .sw_if_index = tc->sw_if_index,
  66     .is_add = is_add
  67   };
  68   vlib_rpc_call_main_thread (tcp_add_del_adj_cb, (u8 *) & args,
  69                              sizeof (args));
  70 }
  71
  72 static void
  73 tcp_cc_init (tcp_connection_t * tc)
  74 {
  75   tc->cc_algo->init (tc);
  76 }
  77
  78 static void
  79 tcp_cc_cleanup (tcp_connection_t * tc)
  80 {
  81   if (tc->cc_algo->cleanup)
  82     tc->cc_algo->cleanup (tc);
  83 }
  84
  85 void
  86 tcp_cc_algo_register (tcp_cc_algorithm_type_e type,
  87                       const tcp_cc_algorithm_t * vft)
  88 {
  89   tcp_main_t *tm = vnet_get_tcp_main ();
  90   vec_validate (tm->cc_algos, type);
  91
  92   tm->cc_algos[type] = *vft;
  93   hash_set_mem (tm->cc_algo_by_name, vft->name, type);
  94 }
  95
  96 tcp_cc_algorithm_t *
  97 tcp_cc_algo_get (tcp_cc_algorithm_type_e type)
  98 {
  99   tcp_main_t *tm = vnet_get_tcp_main ();
 100   return &tm->cc_algos[type];
 101 }
 102
 103 tcp_cc_algorithm_type_e
 104 tcp_cc_algo_new_type (const tcp_cc_algorithm_t * vft)
 105 {
 106   tcp_main_t *tm = vnet_get_tcp_main ();
 107   tcp_cc_algo_register (++tm->cc_last_type, vft);
 108   return tm->cc_last_type;
 109 }
 110
 111 static u32
 112 tcp_connection_bind (u32 session_index, transport_endpoint_t * lcl)
 113 {
 114   tcp_main_t *tm = &tcp_main;
 115   tcp_connection_t *listener;
 116   void *iface_ip;
 117
 118   pool_get (tm->listener_pool, listener);
 119   clib_memset (listener, 0, sizeof (*listener));
 120
 121   listener->c_c_index = listener - tm->listener_pool;
 122   listener->c_lcl_port = lcl->port;
 123
 124   /* If we are provided a sw_if_index, bind using one of its ips */
 125   if (ip_is_zero (&lcl->ip, 1) && lcl->sw_if_index != ENDPOINT_INVALID_INDEX)
 126     {
 127       if ((iface_ip = ip_interface_get_first_ip (lcl->sw_if_index,
 128                                                  lcl->is_ip4)))
 129         ip_set (&lcl->ip, iface_ip, lcl->is_ip4);
 130     }
 131   ip_copy (&listener->c_lcl_ip, &lcl->ip, lcl->is_ip4);
 132   listener->c_is_ip4 = lcl->is_ip4;
 133   listener->c_proto = TRANSPORT_PROTO_TCP;
 134   listener->c_s_index = session_index;
 135   listener->c_fib_index = lcl->fib_index;
 136   listener->state = TCP_STATE_LISTEN;
 137   listener->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo);
 138
 139   tcp_connection_timers_init (listener);
 140
 141   TCP_EVT (TCP_EVT_BIND, listener);
 142
 143   return listener->c_c_index;
 144 }
 145
 146 static u32
 147 tcp_session_bind (u32 session_index, transport_endpoint_t * tep)
 148 {
 149   return tcp_connection_bind (session_index, tep);
 150 }
 151
 152 static void
 153 tcp_connection_unbind (u32 listener_index)
 154 {
 155   tcp_main_t *tm = vnet_get_tcp_main ();
 156   tcp_connection_t *tc;
 157
 158   tc = pool_elt_at_index (tm->listener_pool, listener_index);
 159
 160   TCP_EVT (TCP_EVT_UNBIND, tc);
 161
 162   /* Poison the entry */
 163   if (CLIB_DEBUG > 0)
 164     clib_memset (tc, 0xFA, sizeof (*tc));
 165
 166   pool_put_index (tm->listener_pool, listener_index);
 167 }
 168
 169 static u32
 170 tcp_session_unbind (u32 listener_index)
 171 {
 172   tcp_connection_unbind (listener_index);
 173   return 0;
 174 }
 175
 176 static transport_connection_t *
 177 tcp_session_get_listener (u32 listener_index)
 178 {
 179   tcp_main_t *tm = vnet_get_tcp_main ();
 180   tcp_connection_t *tc;
 181   tc = pool_elt_at_index (tm->listener_pool, listener_index);
 182   return &tc->connection;
 183 }
 184
 185 /**
 186  * Cleanup half-open connection
 187  *
 188  */
 189 static void
 190 tcp_half_open_connection_del (tcp_connection_t * tc)
 191 {
 192   tcp_main_t *tm = vnet_get_tcp_main ();
 193   clib_spinlock_lock_if_init (&tm->half_open_lock);
 194   if (CLIB_DEBUG)
 195     clib_memset (tc, 0xFA, sizeof (*tc));
 196   pool_put (tm->half_open_connections, tc);
 197   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 198 }
 199
 200 /**
 201  * Try to cleanup half-open connection
 202  *
 203  * If called from a thread that doesn't own tc, the call won't have any
 204  * effect.
 205  *
 206  * @param tc - connection to be cleaned up
 207  * @return non-zero if cleanup failed.
 208  */
 209 int
 210 tcp_half_open_connection_cleanup (tcp_connection_t * tc)
 211 {
 212   /* Make sure this is the owning thread */
 213   if (tc->c_thread_index != vlib_get_thread_index ())
 214     return 1;
 215   tcp_timer_reset (tc, TCP_TIMER_RETRANSMIT_SYN);
 216   tcp_half_open_connection_del (tc);
 217   return 0;
 218 }
 219
 220 static tcp_connection_t *
 221 tcp_half_open_connection_new (void)
 222 {
 223   tcp_main_t *tm = vnet_get_tcp_main ();
 224   tcp_connection_t *tc = 0;
 225   ASSERT (vlib_get_thread_index () == 0);
 226   pool_get (tm->half_open_connections, tc);
 227   clib_memset (tc, 0, sizeof (*tc));
 228   tc->c_c_index = tc - tm->half_open_connections;
 229   return tc;
 230 }
 231
 232 /**
 233  * Cleans up connection state.
 234  *
 235  * No notifications.
 236  */
 237 void
 238 tcp_connection_cleanup (tcp_connection_t * tc)
 239 {
 240   TCP_EVT (TCP_EVT_DELETE, tc);
 241
 242   /* Cleanup local endpoint if this was an active connect */
 243   if (!(tc->cfg_flags & TCP_CFG_F_NO_ENDPOINT))
 244     transport_endpoint_cleanup (TRANSPORT_PROTO_TCP, &tc->c_lcl_ip,
 245                                 tc->c_lcl_port);
 246
 247   /* Check if connection is not yet fully established */
 248   if (tc->state == TCP_STATE_SYN_SENT)
 249     {
 250       /* Try to remove the half-open connection. If this is not the owning
 251        * thread, tc won't be removed. Retransmit or establish timers will
 252        * eventually expire and call again cleanup on the right thread. */
 253       if (tcp_half_open_connection_cleanup (tc))
 254         tc->flags |= TCP_CONN_HALF_OPEN_DONE;
 255     }
 256   else
 257     {
 258       /* Make sure all timers are cleared */
 259       tcp_connection_timers_reset (tc);
 260
 261       if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
 262         tcp_add_del_adjacency (tc, 0);
 263
 264       tcp_cc_cleanup (tc);
 265       vec_free (tc->snd_sacks);
 266       vec_free (tc->snd_sacks_fl);
 267       vec_free (tc->rcv_opts.sacks);
 268       pool_free (tc->sack_sb.holes);
 269
 270       if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
 271         tcp_bt_cleanup (tc);
 272
 273       tcp_connection_free (tc);
 274     }
 275 }
 276
 277 /**
 278  * Connection removal.
 279  *
 280  * This should be called only once connection enters CLOSED state. Note
 281  * that it notifies the session of the removal event, so if the goal is to
 282  * just remove the connection, call tcp_connection_cleanup instead.
 283  */
 284 void
 285 tcp_connection_del (tcp_connection_t * tc)
 286 {
 287   session_transport_delete_notify (&tc->connection);
 288   tcp_connection_cleanup (tc);
 289 }
 290
 291 tcp_connection_t *
 292 tcp_connection_alloc (u8 thread_index)
 293 {
 294   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
 295   tcp_connection_t *tc;
 296
 297   pool_get (wrk->connections, tc);
 298   clib_memset (tc, 0, sizeof (*tc));
 299   tc->c_c_index = tc - wrk->connections;
 300   tc->c_thread_index = thread_index;
 301   return tc;
 302 }
 303
 304 tcp_connection_t *
 305 tcp_connection_alloc_w_base (u8 thread_index, tcp_connection_t * base)
 306 {
 307   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
 308   tcp_connection_t *tc;
 309
 310   pool_get (wrk->connections, tc);
 311   clib_memcpy_fast (tc, base, sizeof (*tc));
 312   tc->c_c_index = tc - wrk->connections;
 313   tc->c_thread_index = thread_index;
 314   return tc;
 315 }
 316
 317 void
 318 tcp_connection_free (tcp_connection_t * tc)
 319 {
 320   tcp_worker_ctx_t *wrk = tcp_get_worker (tc->c_thread_index);
 321   if (CLIB_DEBUG)
 322     {
 323       clib_memset (tc, 0xFA, sizeof (*tc));
 324       pool_put (wrk->connections, tc);
 325       return;
 326     }
 327   pool_put (wrk->connections, tc);
 328 }
 329
 330 /**
 331  * Begin connection closing procedure.
 332  *
 333  * If at the end the connection is not in CLOSED state, it is not removed.
 334  * Instead, we rely on on TCP to advance through state machine to either
 335  * 1) LAST_ACK (passive close) whereby when the last ACK is received
 336  * tcp_connection_del is called. This notifies session of the delete and
 337  * calls cleanup.
 338  * 2) TIME_WAIT (active close) whereby after 2MSL the 2MSL timer triggers
 339  * and cleanup is called.
 340  *
 341  * N.B. Half-close connections are not supported
 342  */
 343 void
 344 tcp_connection_close (tcp_connection_t * tc)
 345 {
 346   TCP_EVT (TCP_EVT_CLOSE, tc);
 347
 348   /* Send/Program FIN if needed and switch state */
 349   switch (tc->state)
 350     {
 351     case TCP_STATE_SYN_SENT:
 352       /* Try to cleanup. If not on the right thread, mark as half-open done.
 353        * Connection will be cleaned up when establish timer pops */
 354       tcp_connection_cleanup (tc);
 355       break;
 356     case TCP_STATE_SYN_RCVD:
 357       tcp_connection_timers_reset (tc);
 358       tcp_send_fin (tc);
 359       tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
 360       tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait1_time);
 361       break;
 362     case TCP_STATE_ESTABLISHED:
 363       /* If closing with unread data, reset the connection */
 364       if (transport_max_rx_dequeue (&tc->connection))
 365         {
 366           tcp_send_reset (tc);
 367           tcp_connection_timers_reset (tc);
 368           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
 369           tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.closewait_time);
 370           session_transport_closed_notify (&tc->connection);
 371           tcp_worker_stats_inc (tc->c_thread_index, rst_unread, 1);
 372           break;
 373         }
 374       if (!transport_max_tx_dequeue (&tc->connection))
 375         tcp_send_fin (tc);
 376       else
 377         tc->flags |= TCP_CONN_FINPNDG;
 378       tcp_connection_set_state (tc, TCP_STATE_FIN_WAIT_1);
 379       /* Set a timer in case the peer stops responding. Otherwise the
 380        * connection will be stuck here forever. */
 381       ASSERT (tc->timers[TCP_TIMER_WAITCLOSE] == TCP_TIMER_HANDLE_INVALID);
 382       tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait1_time);
 383       break;
 384     case TCP_STATE_CLOSE_WAIT:
 385       if (!transport_max_tx_dequeue (&tc->connection))
 386         {
 387           tcp_send_fin (tc);
 388           tcp_connection_timers_reset (tc);
 389           tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
 390           tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time);
 391         }
 392       else
 393         tc->flags |= TCP_CONN_FINPNDG;
 394       break;
 395     case TCP_STATE_FIN_WAIT_1:
 396       tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.finwait1_time);
 397       break;
 398     case TCP_STATE_CLOSED:
 399       tcp_connection_timers_reset (tc);
 400       /* Delete connection but instead of doing it now wait until next
 401        * dispatch cycle to give the session layer a chance to clear
 402        * unhandled events */
 403       tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
 404       break;
 405     default:
 406       TCP_DBG ("state: %u", tc->state);
 407     }
 408 }
 409
 410 static void
 411 tcp_session_close (u32 conn_index, u32 thread_index)
 412 {
 413   tcp_connection_t *tc;
 414   tc = tcp_connection_get (conn_index, thread_index);
 415   tcp_connection_close (tc);
 416 }
 417
 418 static void
 419 tcp_session_cleanup (u32 conn_index, u32 thread_index)
 420 {
 421   tcp_connection_t *tc;
 422   tc = tcp_connection_get (conn_index, thread_index);
 423   if (!tc)
 424     return;
 425   tcp_connection_set_state (tc, TCP_STATE_CLOSED);
 426   tcp_connection_cleanup (tc);
 427 }
 428
 429 static void
 430 tcp_session_reset (u32 conn_index, u32 thread_index)
 431 {
 432   tcp_connection_t *tc;
 433   tc = tcp_connection_get (conn_index, thread_index);
 434   session_transport_closed_notify (&tc->connection);
 435   tcp_send_reset (tc);
 436   tcp_connection_timers_reset (tc);
 437   tcp_cong_recovery_off (tc);
 438   tcp_connection_set_state (tc, TCP_STATE_CLOSED);
 439   tcp_timer_update (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
 440 }
 441
 442 /**
 443  * Initialize all connection timers as invalid
 444  */
 445 void
 446 tcp_connection_timers_init (tcp_connection_t * tc)
 447 {
 448   int i;
 449
 450   /* Set all to invalid */
 451   for (i = 0; i < TCP_N_TIMERS; i++)
 452     {
 453       tc->timers[i] = TCP_TIMER_HANDLE_INVALID;
 454     }
 455
 456   tc->rto = TCP_RTO_INIT;
 457 }
 458
 459 /**
 460  * Stop all connection timers
 461  */
 462 void
 463 tcp_connection_timers_reset (tcp_connection_t * tc)
 464 {
 465   int i;
 466   for (i = 0; i < TCP_N_TIMERS; i++)
 467     {
 468       tcp_timer_reset (tc, i);
 469     }
 470 }
 471
 472 #if 0
 473 typedef struct ip4_tcp_hdr
 474 {
 475   ip4_header_t ip;
 476   tcp_header_t tcp;
 477 } ip4_tcp_hdr_t;
 478
 479 typedef struct ip6_tcp_hdr
 480 {
 481   ip6_header_t ip;
 482   tcp_header_t tcp;
 483 } ip6_tcp_hdr_t;
 484
 485 static void
 486 tcp_connection_select_lb_bucket (tcp_connection_t * tc, const dpo_id_t * dpo,
 487                                  dpo_id_t * result)
 488 {
 489   const dpo_id_t *choice;
 490   load_balance_t *lb;
 491   int hash;
 492
 493   lb = load_balance_get (dpo->dpoi_index);
 494   if (tc->c_is_ip4)
 495     {
 496       ip4_tcp_hdr_t hdr;
 497       clib_memset (&hdr, 0, sizeof (hdr));
 498       hdr.ip.protocol = IP_PROTOCOL_TCP;
 499       hdr.ip.address_pair.src.as_u32 = tc->c_lcl_ip.ip4.as_u32;
 500       hdr.ip.address_pair.dst.as_u32 = tc->c_rmt_ip.ip4.as_u32;
 501       hdr.tcp.src_port = tc->c_lcl_port;
 502       hdr.tcp.dst_port = tc->c_rmt_port;
 503       hash = ip4_compute_flow_hash (&hdr.ip, lb->lb_hash_config);
 504     }
 505   else
 506     {
 507       ip6_tcp_hdr_t hdr;
 508       clib_memset (&hdr, 0, sizeof (hdr));
 509       hdr.ip.protocol = IP_PROTOCOL_TCP;
 510       clib_memcpy_fast (&hdr.ip.src_address, &tc->c_lcl_ip.ip6,
 511                         sizeof (ip6_address_t));
 512       clib_memcpy_fast (&hdr.ip.dst_address, &tc->c_rmt_ip.ip6,
 513                         sizeof (ip6_address_t));
 514       hdr.tcp.src_port = tc->c_lcl_port;
 515       hdr.tcp.dst_port = tc->c_rmt_port;
 516       hash = ip6_compute_flow_hash (&hdr.ip, lb->lb_hash_config);
 517     }
 518   choice = load_balance_get_bucket_i (lb, hash & lb->lb_n_buckets_minus_1);
 519   dpo_copy (result, choice);
 520 }
 521
 522 fib_node_index_t
 523 tcp_lookup_rmt_in_fib (tcp_connection_t * tc)
 524 {
 525   fib_prefix_t prefix;
 526   u32 fib_index;
 527
 528   clib_memcpy_fast (&prefix.fp_addr, &tc->c_rmt_ip, sizeof (prefix.fp_addr));
 529   prefix.fp_proto = tc->c_is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6;
 530   prefix.fp_len = tc->c_is_ip4 ? 32 : 128;
 531   fib_index = fib_table_find (prefix.fp_proto, tc->c_fib_index);
 532   return fib_table_lookup (fib_index, &prefix);
 533 }
 534
 535 static int
 536 tcp_connection_stack_on_fib_entry (tcp_connection_t * tc)
 537 {
 538   dpo_id_t choice = DPO_INVALID;
 539   u32 output_node_index;
 540   fib_entry_t *fe;
 541
 542   fe = fib_entry_get (tc->c_rmt_fei);
 543   if (fe->fe_lb.dpoi_type != DPO_LOAD_BALANCE)
 544     return -1;
 545
 546   tcp_connection_select_lb_bucket (tc, &fe->fe_lb, &choice);
 547
 548   output_node_index =
 549     tc->c_is_ip4 ? tcp4_output_node.index : tcp6_output_node.index;
 550   dpo_stack_from_node (output_node_index, &tc->c_rmt_dpo, &choice);
 551   return 0;
 552 }
 553
 554 /** Stack tcp connection on peer's fib entry.
 555  *
 556  * This ultimately populates the dpo the connection will use to send packets.
 557  */
 558 static void
 559 tcp_connection_fib_attach (tcp_connection_t * tc)
 560 {
 561   tc->c_rmt_fei = tcp_lookup_rmt_in_fib (tc);
 562
 563   ASSERT (tc->c_rmt_fei != FIB_NODE_INDEX_INVALID);
 564
 565   tcp_connection_stack_on_fib_entry (tc);
 566 }
 567 #endif /* 0 */
 568
 569 /**
 570  * Generate random iss as per rfc6528
 571  */
 572 static u32
 573 tcp_generate_random_iss (tcp_connection_t * tc)
 574 {
 575   tcp_main_t *tm = &tcp_main;
 576   u64 tmp;
 577
 578   if (tc->c_is_ip4)
 579     tmp = (u64) tc->c_lcl_ip.ip4.as_u32 << 32 | (u64) tc->c_rmt_ip.ip4.as_u32;
 580   else
 581     tmp = tc->c_lcl_ip.ip6.as_u64[0] ^ tc->c_lcl_ip.ip6.as_u64[1]
 582       ^ tc->c_rmt_ip.ip6.as_u64[0] ^ tc->c_rmt_ip.ip6.as_u64[1];
 583
 584   tmp ^= tm->iss_seed.first | ((u64) tc->c_lcl_port << 16 | tc->c_rmt_port);
 585   tmp ^= tm->iss_seed.second;
 586   tmp = clib_xxhash (tmp) + clib_cpu_time_now ();
 587   return ((tmp >> 32) ^ (tmp & 0xffffffff));
 588 }
 589
 590 /**
 591  * Initialize max segment size we're able to process.
 592  *
 593  * The value is constrained by the output interface's MTU and by the size
 594  * of the IP and TCP headers (see RFC6691). It is also what we advertise
 595  * to our peer.
 596  */
 597 static void
 598 tcp_init_rcv_mss (tcp_connection_t * tc)
 599 {
 600   u8 ip_hdr_len;
 601
 602   /* Already provided at connection init time */
 603   if (tc->mss)
 604     return;
 605
 606   ip_hdr_len = tc->c_is_ip4 ? sizeof (ip4_header_t) : sizeof (ip6_header_t);
 607   tc->mss = tcp_cfg.default_mtu - sizeof (tcp_header_t) - ip_hdr_len;
 608 }
 609
 610 static void
 611 tcp_init_mss (tcp_connection_t * tc)
 612 {
 613   u16 default_min_mss = 536;
 614
 615   tcp_init_rcv_mss (tc);
 616
 617   /* TODO consider PMTU discovery */
 618   tc->snd_mss = clib_min (tc->rcv_opts.mss, tc->mss);
 619
 620   if (tc->snd_mss < 45)
 621     {
 622       /* Assume that at least the min default mss works */
 623       tc->snd_mss = default_min_mss;
 624       tc->rcv_opts.mss = default_min_mss;
 625     }
 626
 627   /* We should have enough space for 40 bytes of options */
 628   ASSERT (tc->snd_mss > 45);
 629
 630   /* If we use timestamp option, account for it */
 631   if (tcp_opts_tstamp (&tc->rcv_opts))
 632     tc->snd_mss -= TCP_OPTION_LEN_TIMESTAMP;
 633 }
 634
 635 /**
 636  * Initialize connection send variables.
 637  */
 638 void
 639 tcp_init_snd_vars (tcp_connection_t * tc)
 640 {
 641   /*
 642    * We use the time to randomize iss and for setting up the initial
 643    * timestamp. Make sure it's updated otherwise syn and ack in the
 644    * handshake may make it look as if time has flown in the opposite
 645    * direction for us.
 646    */
 647   tcp_set_time_now (tcp_get_worker (vlib_get_thread_index ()));
 648
 649   tcp_init_rcv_mss (tc);
 650   tc->iss = tcp_generate_random_iss (tc);
 651   tc->snd_una = tc->iss;
 652   tc->snd_nxt = tc->iss + 1;
 653   tc->snd_una_max = tc->snd_nxt;
 654   tc->srtt = 100;               /* 100 ms */
 655
 656   if (!tcp_cfg.csum_offload)
 657     tc->cfg_flags |= TCP_CFG_F_NO_CSUM_OFFLOAD;
 658 }
 659
 660 void
 661 tcp_enable_pacing (tcp_connection_t * tc)
 662 {
 663   u32 byte_rate;
 664   byte_rate = tc->cwnd / (tc->srtt * TCP_TICK);
 665   transport_connection_tx_pacer_init (&tc->connection, byte_rate, tc->cwnd);
 666   tc->mrtt_us = (u32) ~ 0;
 667 }
 668
 669 /** Initialize tcp connection variables
 670  *
 671  * Should be called after having received a msg from the peer, i.e., a SYN or
 672  * a SYNACK, such that connection options have already been exchanged. */
 673 void
 674 tcp_connection_init_vars (tcp_connection_t * tc)
 675 {
 676   tcp_connection_timers_init (tc);
 677   tcp_init_mss (tc);
 678   scoreboard_init (&tc->sack_sb);
 679   if (tc->state == TCP_STATE_SYN_RCVD)
 680     tcp_init_snd_vars (tc);
 681
 682   tcp_cc_init (tc);
 683
 684   if (!tc->c_is_ip4 && ip6_address_is_link_local_unicast (&tc->c_rmt_ip6))
 685     tcp_add_del_adjacency (tc, 1);
 686
 687   /*  tcp_connection_fib_attach (tc); */
 688
 689   if (transport_connection_is_tx_paced (&tc->connection)
 690       || tcp_cfg.enable_tx_pacing)
 691     tcp_enable_pacing (tc);
 692
 693   if (tc->cfg_flags & TCP_CFG_F_RATE_SAMPLE)
 694     tcp_bt_init (tc);
 695
 696   if (!tcp_cfg.allow_tso)
 697     tc->cfg_flags |= TCP_CFG_F_NO_TSO;
 698
 699   tc->start_ts = tcp_time_now_us (tc->c_thread_index);
 700 }
 701
 702 static int
 703 tcp_alloc_custom_local_endpoint (tcp_main_t * tm, ip46_address_t * lcl_addr,
 704                                  u16 * lcl_port, u8 is_ip4)
 705 {
 706   int index, port;
 707   if (is_ip4)
 708     {
 709       index = tm->last_v4_addr_rotor++;
 710       if (tm->last_v4_addr_rotor >= vec_len (tcp_cfg.ip4_src_addrs))
 711         tm->last_v4_addr_rotor = 0;
 712       lcl_addr->ip4.as_u32 = tcp_cfg.ip4_src_addrs[index].as_u32;
 713     }
 714   else
 715     {
 716       index = tm->last_v6_addr_rotor++;
 717       if (tm->last_v6_addr_rotor >= vec_len (tcp_cfg.ip6_src_addrs))
 718         tm->last_v6_addr_rotor = 0;
 719       clib_memcpy_fast (&lcl_addr->ip6, &tcp_cfg.ip6_src_addrs[index],
 720                         sizeof (ip6_address_t));
 721     }
 722   port = transport_alloc_local_port (TRANSPORT_PROTO_TCP, lcl_addr);
 723   if (port < 1)
 724     {
 725       clib_warning ("Failed to allocate src port");
 726       return -1;
 727     }
 728   *lcl_port = port;
 729   return 0;
 730 }
 731
 732 static int
 733 tcp_session_open (transport_endpoint_cfg_t * rmt)
 734 {
 735   tcp_main_t *tm = vnet_get_tcp_main ();
 736   tcp_connection_t *tc;
 737   ip46_address_t lcl_addr;
 738   u16 lcl_port;
 739   int rv;
 740
 741   /*
 742    * Allocate local endpoint
 743    */
 744   if ((rmt->is_ip4 && vec_len (tcp_cfg.ip4_src_addrs))
 745       || (!rmt->is_ip4 && vec_len (tcp_cfg.ip6_src_addrs)))
 746     rv = tcp_alloc_custom_local_endpoint (tm, &lcl_addr, &lcl_port,
 747                                           rmt->is_ip4);
 748   else
 749     rv = transport_alloc_local_endpoint (TRANSPORT_PROTO_TCP,
 750                                          rmt, &lcl_addr, &lcl_port);
 751
 752   if (rv)
 753     return -1;
 754
 755   /*
 756    * Create connection and send SYN
 757    */
 758   clib_spinlock_lock_if_init (&tm->half_open_lock);
 759   tc = tcp_half_open_connection_new ();
 760   ip_copy (&tc->c_rmt_ip, &rmt->ip, rmt->is_ip4);
 761   ip_copy (&tc->c_lcl_ip, &lcl_addr, rmt->is_ip4);
 762   tc->c_rmt_port = rmt->port;
 763   tc->c_lcl_port = clib_host_to_net_u16 (lcl_port);
 764   tc->c_is_ip4 = rmt->is_ip4;
 765   tc->c_proto = TRANSPORT_PROTO_TCP;
 766   tc->c_fib_index = rmt->fib_index;
 767   tc->cc_algo = tcp_cc_algo_get (tcp_cfg.cc_algo);
 768   /* The other connection vars will be initialized after SYN ACK */
 769   tcp_connection_timers_init (tc);
 770   tc->mss = rmt->mss;
 771
 772   TCP_EVT (TCP_EVT_OPEN, tc);
 773   tc->state = TCP_STATE_SYN_SENT;
 774   tcp_init_snd_vars (tc);
 775   tcp_send_syn (tc);
 776   clib_spinlock_unlock_if_init (&tm->half_open_lock);
 777
 778   return tc->c_c_index;
 779 }
 780
 781 const char *tcp_fsm_states[] = {
 782 #define _(sym, str) str,
 783   foreach_tcp_fsm_state
 784 #undef _
 785 };
 786
 787 u8 *
 788 format_tcp_state (u8 * s, va_list * args)
 789 {
 790   u32 state = va_arg (*args, u32);
 791
 792   if (state < TCP_N_STATES)
 793     s = format (s, "%s", tcp_fsm_states[state]);
 794   else
 795     s = format (s, "UNKNOWN (%d (0x%x))", state, state);
 796   return s;
 797 }
 798
 799 const char *tcp_cfg_flags_str[] = {
 800 #define _(sym, str) str,
 801   foreach_tcp_cfg_flag
 802 #undef _
 803 };
 804
 805 static u8 *
 806 format_tcp_cfg_flags (u8 * s, va_list * args)
 807 {
 808   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 809   int i, last = -1;
 810
 811   for (i = 0; i < TCP_CFG_N_FLAG_BITS; i++)
 812     if (tc->cfg_flags & (1 << i))
 813       last = i;
 814   for (i = 0; i < last; i++)
 815     {
 816       if (tc->cfg_flags & (1 << i))
 817         s = format (s, "%s, ", tcp_cfg_flags_str[i]);
 818     }
 819   if (last >= 0)
 820     s = format (s, "%s", tcp_cfg_flags_str[last]);
 821   return s;
 822 }
 823
 824 const char *tcp_connection_flags_str[] = {
 825 #define _(sym, str) str,
 826   foreach_tcp_connection_flag
 827 #undef _
 828 };
 829
 830 static u8 *
 831 format_tcp_connection_flags (u8 * s, va_list * args)
 832 {
 833   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 834   int i, last = -1;
 835
 836   for (i = 0; i < TCP_CONN_N_FLAG_BITS; i++)
 837     if (tc->flags & (1 << i))
 838       last = i;
 839   for (i = 0; i < last; i++)
 840     {
 841       if (tc->flags & (1 << i))
 842         s = format (s, "%s, ", tcp_connection_flags_str[i]);
 843     }
 844   if (last >= 0)
 845     s = format (s, "%s", tcp_connection_flags_str[last]);
 846   return s;
 847 }
 848
 849 const char *tcp_conn_timers[] = {
 850 #define _(sym, str) str,
 851   foreach_tcp_timer
 852 #undef _
 853 };
 854
 855 static u8 *
 856 format_tcp_timers (u8 * s, va_list * args)
 857 {
 858   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 859   int i, last = -1;
 860
 861   for (i = 0; i < TCP_N_TIMERS; i++)
 862     if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
 863       last = i;
 864
 865   for (i = 0; i < last; i++)
 866     {
 867       if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
 868         s = format (s, "%s,", tcp_conn_timers[i]);
 869     }
 870
 871   if (last >= 0)
 872     s = format (s, "%s", tcp_conn_timers[i]);
 873
 874   return s;
 875 }
 876
 877 static u8 *
 878 format_tcp_congestion_status (u8 * s, va_list * args)
 879 {
 880   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 881   if (tcp_in_recovery (tc))
 882     s = format (s, "recovery");
 883   else if (tcp_in_fastrecovery (tc))
 884     s = format (s, "fastrecovery");
 885   else
 886     s = format (s, "none");
 887   return s;
 888 }
 889
 890 static i32
 891 tcp_rcv_wnd_available (tcp_connection_t * tc)
 892 {
 893   return (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
 894 }
 895
 896 static u8 *
 897 format_tcp_congestion (u8 * s, va_list * args)
 898 {
 899   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 900   u32 indent = format_get_indent (s), prr_space = 0;
 901
 902   s = format (s, "%U ", format_tcp_congestion_status, tc);
 903   s = format (s, "algo %s cwnd %u ssthresh %u bytes_acked %u\n",
 904               tc->cc_algo->name, tc->cwnd, tc->ssthresh, tc->bytes_acked);
 905   s = format (s, "%Ucc space %u prev_cwnd %u prev_ssthresh %u\n",
 906               format_white_space, indent, tcp_available_cc_snd_space (tc),
 907               tc->prev_cwnd, tc->prev_ssthresh);
 908   s = format (s, "%Usnd_cong %u dupack %u limited_tx %u\n",
 909               format_white_space, indent, tc->snd_congestion - tc->iss,
 910               tc->rcv_dupacks, tc->limited_transmit - tc->iss);
 911   s = format (s, "%Urxt_bytes %u rxt_delivered %u rxt_head %u rxt_ts %u\n",
 912               format_white_space, indent, tc->snd_rxt_bytes,
 913               tc->rxt_delivered, tc->rxt_head - tc->iss,
 914               tcp_time_now_w_thread (tc->c_thread_index) - tc->snd_rxt_ts);
 915   if (tcp_in_fastrecovery (tc))
 916     prr_space = tcp_fastrecovery_prr_snd_space (tc);
 917   s = format (s, "%Uprr_start %u prr_delivered %u prr space %u\n",
 918               format_white_space, indent, tc->prr_start - tc->iss,
 919               tc->prr_delivered, prr_space);
 920   return s;
 921 }
 922
 923 static u8 *
 924 format_tcp_stats (u8 * s, va_list * args)
 925 {
 926   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 927   u32 indent = format_get_indent (s);
 928   s = format (s, "in segs %lu dsegs %lu bytes %lu dupacks %u\n",
 929               tc->segs_in, tc->data_segs_in, tc->bytes_in, tc->dupacks_in);
 930   s = format (s, "%Uout segs %lu dsegs %lu bytes %lu dupacks %u\n",
 931               format_white_space, indent, tc->segs_out,
 932               tc->data_segs_out, tc->bytes_out, tc->dupacks_out);
 933   s = format (s, "%Ufr %u tr %u rxt segs %lu bytes %lu duration %.3f\n",
 934               format_white_space, indent, tc->fr_occurences,
 935               tc->tr_occurences, tc->segs_retrans, tc->bytes_retrans,
 936               tcp_time_now_us (tc->c_thread_index) - tc->start_ts);
 937   s = format (s, "%Uerr wnd data below %u above %u ack below %u above %u",
 938               format_white_space, indent, tc->errors.below_data_wnd,
 939               tc->errors.above_data_wnd, tc->errors.below_ack_wnd,
 940               tc->errors.above_ack_wnd);
 941   return s;
 942 }
 943
 944 static u8 *
 945 format_tcp_vars (u8 * s, va_list * args)
 946 {
 947   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 948   s = format (s, " index: %u cfg: %U flags: %U timers: %U\n", tc->c_c_index,
 949               format_tcp_cfg_flags, tc, format_tcp_connection_flags, tc,
 950               format_tcp_timers, tc);
 951   s = format (s, " snd_una %u snd_nxt %u snd_una_max %u",
 952               tc->snd_una - tc->iss, tc->snd_nxt - tc->iss,
 953               tc->snd_una_max - tc->iss);
 954   s = format (s, " rcv_nxt %u rcv_las %u\n",
 955               tc->rcv_nxt - tc->irs, tc->rcv_las - tc->irs);
 956   s = format (s, " snd_wnd %u rcv_wnd %u rcv_wscale %u ",
 957               tc->snd_wnd, tc->rcv_wnd, tc->rcv_wscale);
 958   s = format (s, "snd_wl1 %u snd_wl2 %u\n", tc->snd_wl1 - tc->irs,
 959               tc->snd_wl2 - tc->iss);
 960   s = format (s, " flight size %u out space %u rcv_wnd_av %u",
 961               tcp_flight_size (tc), tcp_available_output_snd_space (tc),
 962               tcp_rcv_wnd_available (tc));
 963   s = format (s, " tsval_recent %u\n", tc->tsval_recent);
 964   s = format (s, " tsecr %u tsecr_last_ack %u tsval_recent_age %u",
 965               tc->rcv_opts.tsecr, tc->tsecr_last_ack,
 966               tcp_time_now () - tc->tsval_recent_age);
 967   s = format (s, " snd_mss %u\n", tc->snd_mss);
 968   s = format (s, " rto %u rto_boff %u srtt %u us %.3f rttvar %u rtt_ts %.4f",
 969               tc->rto, tc->rto_boff, tc->srtt, tc->mrtt_us * 1000, tc->rttvar,
 970               tc->rtt_ts);
 971   s = format (s, " rtt_seq %u\n", tc->rtt_seq - tc->iss);
 972   s = format (s, " next_node %u opaque 0x%x fib_index %u\n",
 973               tc->next_node_index, tc->next_node_opaque, tc->c_fib_index);
 974   s = format (s, " cong:   %U", format_tcp_congestion, tc);
 975
 976   if (tc->state >= TCP_STATE_ESTABLISHED)
 977     {
 978       s = format (s, " sboard: %U\n", format_tcp_scoreboard, &tc->sack_sb,
 979                   tc);
 980       s = format (s, " stats: %U\n", format_tcp_stats, tc);
 981     }
 982   if (vec_len (tc->snd_sacks))
 983     s = format (s, " sacks tx: %U\n", format_tcp_sacks, tc);
 984
 985   return s;
 986 }
 987
 988 u8 *
 989 format_tcp_connection_id (u8 * s, va_list * args)
 990 {
 991   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 992   if (!tc)
 993     return s;
 994   if (tc->c_is_ip4)
 995     {
 996       s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index,
 997                   tc->c_s_index, "T", format_ip4_address, &tc->c_lcl_ip4,
 998                   clib_net_to_host_u16 (tc->c_lcl_port), format_ip4_address,
 999                   &tc->c_rmt_ip4, clib_net_to_host_u16 (tc->c_rmt_port));
1000     }
1001   else
1002     {
1003       s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index,
1004                   tc->c_s_index, "T", format_ip6_address, &tc->c_lcl_ip6,
1005                   clib_net_to_host_u16 (tc->c_lcl_port), format_ip6_address,
1006                   &tc->c_rmt_ip6, clib_net_to_host_u16 (tc->c_rmt_port));
1007     }
1008
1009   return s;
1010 }
1011
1012 u8 *
1013 format_tcp_connection (u8 * s, va_list * args)
1014 {
1015   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
1016   u32 verbose = va_arg (*args, u32);
1017
1018   if (!tc)
1019     return s;
1020   s = format (s, "%-50U", format_tcp_connection_id, tc);
1021   if (verbose)
1022     {
1023       s = format (s, "%-15U", format_tcp_state, tc->state);
1024       if (verbose > 1)
1025         s = format (s, "\n%U", format_tcp_vars, tc);
1026     }
1027
1028   return s;
1029 }
1030
1031 static u8 *
1032 format_tcp_session (u8 * s, va_list * args)
1033 {
1034   u32 tci = va_arg (*args, u32);
1035   u32 thread_index = va_arg (*args, u32);
1036   u32 verbose = va_arg (*args, u32);
1037   tcp_connection_t *tc;
1038
1039   tc = tcp_connection_get (tci, thread_index);
1040   if (tc)
1041     s = format (s, "%U", format_tcp_connection, tc, verbose);
1042   else
1043     s = format (s, "empty\n");
1044   return s;
1045 }
1046
1047 static u8 *
1048 format_tcp_listener_session (u8 * s, va_list * args)
1049 {
1050   u32 tci = va_arg (*args, u32);
1051   u32 __clib_unused thread_index = va_arg (*args, u32);
1052   u32 verbose = va_arg (*args, u32);
1053   tcp_connection_t *tc = tcp_listener_get (tci);
1054   s = format (s, "%-50U", format_tcp_connection_id, tc);
1055   if (verbose)
1056     s = format (s, "%-15U", format_tcp_state, tc->state);
1057   return s;
1058 }
1059
1060 static u8 *
1061 format_tcp_half_open_session (u8 * s, va_list * args)
1062 {
1063   u32 tci = va_arg (*args, u32);
1064   u32 __clib_unused thread_index = va_arg (*args, u32);
1065   tcp_connection_t *tc = tcp_half_open_connection_get (tci);
1066   return format (s, "%U", format_tcp_connection_id, tc);
1067 }
1068
1069 u8 *
1070 format_tcp_sacks (u8 * s, va_list * args)
1071 {
1072   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
1073   sack_block_t *sacks = tc->snd_sacks;
1074   sack_block_t *block;
1075   int i, len = 0;
1076
1077   len = vec_len (sacks);
1078   for (i = 0; i < len - 1; i++)
1079     {
1080       block = &sacks[i];
1081       s = format (s, " start %u end %u\n", block->start - tc->irs,
1082                   block->end - tc->irs);
1083     }
1084   if (len)
1085     {
1086       block = &sacks[len - 1];
1087       s = format (s, " start %u end %u", block->start - tc->irs,
1088                   block->end - tc->irs);
1089     }
1090   return s;
1091 }
1092
1093 u8 *
1094 format_tcp_rcv_sacks (u8 * s, va_list * args)
1095 {
1096   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
1097   sack_block_t *sacks = tc->rcv_opts.sacks;
1098   sack_block_t *block;
1099   int i, len = 0;
1100
1101   len = vec_len (sacks);
1102   for (i = 0; i < len - 1; i++)
1103     {
1104       block = &sacks[i];
1105       s = format (s, " start %u end %u\n", block->start - tc->iss,
1106                   block->end - tc->iss);
1107     }
1108   if (len)
1109     {
1110       block = &sacks[len - 1];
1111       s = format (s, " start %u end %u", block->start - tc->iss,
1112                   block->end - tc->iss);
1113     }
1114   return s;
1115 }
1116
1117 static u8 *
1118 format_tcp_sack_hole (u8 * s, va_list * args)
1119 {
1120   sack_scoreboard_hole_t *hole = va_arg (*args, sack_scoreboard_hole_t *);
1121   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
1122   if (tc)
1123     s = format (s, "  [%u, %u]", hole->start - tc->iss, hole->end - tc->iss);
1124   else
1125     s = format (s, "  [%u, %u]", hole->start, hole->end);
1126   return s;
1127 }
1128
1129 u8 *
1130 format_tcp_scoreboard (u8 * s, va_list * args)
1131 {
1132   sack_scoreboard_t *sb = va_arg (*args, sack_scoreboard_t *);
1133   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
1134   sack_scoreboard_hole_t *hole;
1135   u32 indent = format_get_indent (s);
1136
1137   s = format (s, "sacked %u last_sacked %u lost %u last_lost %u"
1138               " rxt_sacked %u\n",
1139               sb->sacked_bytes, sb->last_sacked_bytes, sb->lost_bytes,
1140               sb->last_lost_bytes, sb->rxt_sacked);
1141   s = format (s, "%Ulast_delivered %u high_sacked %u is_reneging %u\n",
1142               format_white_space, indent, sb->last_bytes_delivered,
1143               sb->high_sacked - tc->iss, sb->is_reneging);
1144   s = format (s, "%Ucur_rxt_hole %u high_rxt %u rescue_rxt %u",
1145               format_white_space, indent, sb->cur_rxt_hole,
1146               sb->high_rxt - tc->iss, sb->rescue_rxt - tc->iss);
1147
1148   hole = scoreboard_first_hole (sb);
1149   if (hole)
1150     s = format (s, "\n%Uhead %u tail %u %u holes:\n%U", format_white_space,
1151                 indent, sb->head, sb->tail, pool_elts (sb->holes),
1152                 format_white_space, indent);
1153
1154   while (hole)
1155     {
1156       s = format (s, "%U", format_tcp_sack_hole, hole, tc);
1157       hole = scoreboard_next_hole (sb, hole);
1158     }
1159
1160   return s;
1161 }
1162
1163 static transport_connection_t *
1164 tcp_session_get_transport (u32 conn_index, u32 thread_index)
1165 {
1166   tcp_connection_t *tc = tcp_connection_get (conn_index, thread_index);
1167   if (PREDICT_FALSE (!tc))
1168     return 0;
1169   return &tc->connection;
1170 }
1171
1172 static transport_connection_t *
1173 tcp_half_open_session_get_transport (u32 conn_index)
1174 {
1175   tcp_connection_t *tc = tcp_half_open_connection_get (conn_index);
1176   return &tc->connection;
1177 }
1178
1179 static u16
1180 tcp_session_cal_goal_size (tcp_connection_t * tc)
1181 {
1182   u16 goal_size = tc->snd_mss;
1183
1184   goal_size = TCP_MAX_GSO_SZ - tc->snd_mss % TCP_MAX_GSO_SZ;
1185   goal_size = clib_min (goal_size, tc->snd_wnd / 2);
1186
1187   return goal_size > tc->snd_mss ? goal_size : tc->snd_mss;
1188 }
1189
1190 /**
1191  * Compute maximum segment size for session layer.
1192  *
1193  * Since the result needs to be the actual data length, it first computes
1194  * the tcp options to be used in the next burst and subtracts their
1195  * length from the connection's snd_mss.
1196  */
1197 static u16
1198 tcp_session_send_mss (transport_connection_t * trans_conn)
1199 {
1200   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
1201
1202   /* Ensure snd_mss does accurately reflect the amount of data we can push
1203    * in a segment. This also makes sure that options are updated according to
1204    * the current state of the connection. */
1205   tcp_update_burst_snd_vars (tc);
1206
1207   if (PREDICT_FALSE (tc->cfg_flags & TCP_CFG_F_TSO))
1208     return tcp_session_cal_goal_size (tc);
1209
1210   return tc->snd_mss;
1211 }
1212
1213 always_inline u32
1214 tcp_round_snd_space (tcp_connection_t * tc, u32 snd_space)
1215 {
1216   if (PREDICT_FALSE (tc->snd_wnd < tc->snd_mss))
1217     {
1218       return tc->snd_wnd <= snd_space ? tc->snd_wnd : 0;
1219     }
1220
1221   /* If not snd_wnd constrained and we can't write at least a segment,
1222    * don't try at all */
1223   if (PREDICT_FALSE (snd_space < tc->snd_mss))
1224     return snd_space < tc->cwnd ? 0 : snd_space;
1225
1226   /* round down to mss multiple */
1227   return snd_space - (snd_space % tc->snd_mss);
1228 }
1229
1230 /**
1231  * Compute tx window session is allowed to fill.
1232  *
1233  * Takes into account available send space, snd_mss and the congestion
1234  * state of the connection. If possible, the value returned is a multiple
1235  * of snd_mss.
1236  *
1237  * @param tc tcp connection
1238  * @return number of bytes session is allowed to write
1239  */
1240 static inline u32
1241 tcp_snd_space_inline (tcp_connection_t * tc)
1242 {
1243   int snd_space;
1244
1245   if (PREDICT_FALSE (tcp_in_fastrecovery (tc)
1246                      || tc->state == TCP_STATE_CLOSED))
1247     return 0;
1248
1249   snd_space = tcp_available_output_snd_space (tc);
1250
1251   /* If we got dupacks or sacked bytes but we're not yet in recovery, try
1252    * to force the peer to send enough dupacks to start retransmitting as
1253    * per Limited Transmit (RFC3042)
1254    */
1255   if (PREDICT_FALSE (tc->rcv_dupacks != 0 || tc->sack_sb.sacked_bytes))
1256     {
1257       if (tc->limited_transmit != tc->snd_nxt
1258           && (seq_lt (tc->limited_transmit, tc->snd_nxt - 2 * tc->snd_mss)
1259               || seq_gt (tc->limited_transmit, tc->snd_nxt)))
1260         tc->limited_transmit = tc->snd_nxt;
1261
1262       ASSERT (seq_leq (tc->limited_transmit, tc->snd_nxt));
1263
1264       int snt_limited = tc->snd_nxt - tc->limited_transmit;
1265       snd_space = clib_max ((int) 2 * tc->snd_mss - snt_limited, 0);
1266     }
1267   return tcp_round_snd_space (tc, snd_space);
1268 }
1269
1270 u32
1271 tcp_snd_space (tcp_connection_t * tc)
1272 {
1273   return tcp_snd_space_inline (tc);
1274 }
1275
1276 static u32
1277 tcp_session_send_space (transport_connection_t * trans_conn)
1278 {
1279   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
1280   return clib_min (tcp_snd_space_inline (tc),
1281                    tc->snd_wnd - (tc->snd_nxt - tc->snd_una));
1282 }
1283
1284 static u32
1285 tcp_session_tx_fifo_offset (transport_connection_t * trans_conn)
1286 {
1287   tcp_connection_t *tc = (tcp_connection_t *) trans_conn;
1288
1289   ASSERT (seq_geq (tc->snd_nxt, tc->snd_una));
1290
1291   /* This still works if fast retransmit is on */
1292   return (tc->snd_nxt - tc->snd_una);
1293 }
1294
1295 static void
1296 tcp_timer_waitclose_handler (tcp_connection_t * tc)
1297 {
1298   switch (tc->state)
1299     {
1300     case TCP_STATE_CLOSE_WAIT:
1301       tcp_connection_timers_reset (tc);
1302       session_transport_closed_notify (&tc->connection);
1303       /* App never returned with a close */
1304       if (!(tc->flags & TCP_CONN_FINPNDG))
1305         {
1306           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1307           tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
1308           tcp_worker_stats_inc (tc->c_thread_index, to_closewait, 1);
1309           break;
1310         }
1311
1312       /* Send FIN either way and switch to LAST_ACK. */
1313       tcp_cong_recovery_off (tc);
1314       /* Make sure we don't try to send unsent data */
1315       tc->snd_nxt = tc->snd_una;
1316       tcp_send_fin (tc);
1317       tcp_connection_set_state (tc, TCP_STATE_LAST_ACK);
1318
1319       /* Make sure we don't wait in LAST ACK forever */
1320       tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.lastack_time);
1321       tcp_worker_stats_inc (tc->c_thread_index, to_closewait2, 1);
1322
1323       /* Don't delete the connection yet */
1324       break;
1325     case TCP_STATE_FIN_WAIT_1:
1326       tcp_connection_timers_reset (tc);
1327       session_transport_closed_notify (&tc->connection);
1328       if (tc->flags & TCP_CONN_FINPNDG)
1329         {
1330           /* If FIN pending, we haven't sent everything, but we did try.
1331            * Notify session layer that transport is closed. */
1332           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1333           tcp_send_reset (tc);
1334           tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
1335         }
1336       else
1337         {
1338           /* We've sent the fin but no progress. Close the connection and
1339            * to make sure everything is flushed, setup a cleanup timer */
1340           tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1341           tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
1342         }
1343       tcp_worker_stats_inc (tc->c_thread_index, to_finwait1, 1);
1344       break;
1345     case TCP_STATE_LAST_ACK:
1346       tcp_connection_timers_reset (tc);
1347       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1348       tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
1349       session_transport_closed_notify (&tc->connection);
1350       tcp_worker_stats_inc (tc->c_thread_index, to_lastack, 1);
1351       break;
1352     case TCP_STATE_CLOSING:
1353       tcp_connection_timers_reset (tc);
1354       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1355       tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
1356       session_transport_closed_notify (&tc->connection);
1357       tcp_worker_stats_inc (tc->c_thread_index, to_closing, 1);
1358       break;
1359     case TCP_STATE_FIN_WAIT_2:
1360       tcp_send_reset (tc);
1361       tcp_connection_timers_reset (tc);
1362       tcp_connection_set_state (tc, TCP_STATE_CLOSED);
1363       session_transport_closed_notify (&tc->connection);
1364       tcp_timer_set (tc, TCP_TIMER_WAITCLOSE, tcp_cfg.cleanup_time);
1365       tcp_worker_stats_inc (tc->c_thread_index, to_finwait2, 1);
1366       break;
1367     default:
1368       tcp_connection_del (tc);
1369       break;
1370     }
1371 }
1372
1373 /* *INDENT-OFF* */
1374 static timer_expiration_handler *timer_expiration_handlers[TCP_N_TIMERS] =
1375 {
1376     tcp_timer_retransmit_handler,
1377     tcp_timer_delack_handler,
1378     tcp_timer_persist_handler,
1379     tcp_timer_waitclose_handler,
1380     tcp_timer_retransmit_syn_handler,
1381 };
1382 /* *INDENT-ON* */
1383
1384 static void
1385 tcp_dispatch_pending_timers (tcp_worker_ctx_t * wrk)
1386 {
1387   u32 n_timers, connection_index, timer_id, thread_index, timer_handle;
1388   tcp_connection_t *tc;
1389   int i;
1390
1391   if (!(n_timers = clib_fifo_elts (wrk->pending_timers)))
1392     return;
1393
1394   thread_index = wrk->vm->thread_index;
1395   for (i = 0; i < clib_min (n_timers, 32); i++)
1396     {
1397       clib_fifo_sub1 (wrk->pending_timers, timer_handle);
1398       connection_index = timer_handle & 0x0FFFFFFF;
1399       timer_id = timer_handle >> 28;
1400
1401       if (PREDICT_TRUE (timer_id != TCP_TIMER_RETRANSMIT_SYN))
1402         tc = tcp_connection_get (connection_index, thread_index);
1403       else
1404         tc = tcp_half_open_connection_get (connection_index);
1405
1406       if (PREDICT_FALSE (!tc))
1407         continue;
1408
1409       /* Skip timer if it was rearmed while pending dispatch */
1410       if (PREDICT_FALSE (tc->timers[timer_id] != TCP_TIMER_HANDLE_INVALID))
1411         continue;
1412
1413       (*timer_expiration_handlers[timer_id]) (tc);
1414     }
1415 }
1416
1417 /**
1418  * Flush ip lookup tx frames populated by timer pops
1419  */
1420 static void
1421 tcp_flush_frames_to_output (tcp_worker_ctx_t * wrk)
1422 {
1423   if (wrk->ip_lookup_tx_frames[0])
1424     {
1425       vlib_put_frame_to_node (wrk->vm, ip4_lookup_node.index,
1426                               wrk->ip_lookup_tx_frames[0]);
1427       wrk->ip_lookup_tx_frames[0] = 0;
1428     }
1429   if (wrk->ip_lookup_tx_frames[1])
1430     {
1431       vlib_put_frame_to_node (wrk->vm, ip6_lookup_node.index,
1432                               wrk->ip_lookup_tx_frames[1]);
1433       wrk->ip_lookup_tx_frames[1] = 0;
1434     }
1435 }
1436
1437 static void
1438 tcp_update_time (f64 now, u8 thread_index)
1439 {
1440   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
1441
1442   tcp_set_time_now (wrk);
1443   tw_timer_expire_timers_16t_2w_512sl (&wrk->timer_wheel, now);
1444   tcp_dispatch_pending_timers (wrk);
1445   tcp_flush_frames_to_output (wrk);
1446 }
1447
1448 static void
1449 tcp_session_flush_data (transport_connection_t * tconn)
1450 {
1451   tcp_connection_t *tc = (tcp_connection_t *) tconn;
1452   if (tc->flags & TCP_CONN_PSH_PENDING)
1453     return;
1454   tc->flags |= TCP_CONN_PSH_PENDING;
1455   tc->psh_seq = tc->snd_una + transport_max_tx_dequeue (tconn) - 1;
1456 }
1457
1458 /* *INDENT-OFF* */
1459 const static transport_proto_vft_t tcp_proto = {
1460   .enable = vnet_tcp_enable_disable,
1461   .start_listen = tcp_session_bind,
1462   .stop_listen = tcp_session_unbind,
1463   .push_header = tcp_session_push_header,
1464   .get_connection = tcp_session_get_transport,
1465   .get_listener = tcp_session_get_listener,
1466   .get_half_open = tcp_half_open_session_get_transport,
1467   .connect = tcp_session_open,
1468   .close = tcp_session_close,
1469   .cleanup = tcp_session_cleanup,
1470   .reset = tcp_session_reset,
1471   .send_mss = tcp_session_send_mss,
1472   .send_space = tcp_session_send_space,
1473   .update_time = tcp_update_time,
1474   .tx_fifo_offset = tcp_session_tx_fifo_offset,
1475   .flush_data = tcp_session_flush_data,
1476   .custom_tx = tcp_session_custom_tx,
1477   .format_connection = format_tcp_session,
1478   .format_listener = format_tcp_listener_session,
1479   .format_half_open = format_tcp_half_open_session,
1480   .transport_options = {
1481     .tx_type = TRANSPORT_TX_PEEK,
1482     .service_type = TRANSPORT_SERVICE_VC,
1483   },
1484 };
1485 /* *INDENT-ON* */
1486
1487 void
1488 tcp_connection_tx_pacer_update (tcp_connection_t * tc)
1489 {
1490   if (!transport_connection_is_tx_paced (&tc->connection))
1491     return;
1492
1493   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
1494
1495   transport_connection_tx_pacer_update (&tc->connection,
1496                                         tcp_cc_get_pacing_rate (tc),
1497                                         srtt * CLIB_US_TIME_FREQ);
1498 }
1499
1500 void
1501 tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window,
1502                                u32 start_bucket)
1503 {
1504   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
1505   transport_connection_tx_pacer_reset (&tc->connection,
1506                                        tcp_cc_get_pacing_rate (tc),
1507                                        start_bucket,
1508                                        srtt * CLIB_US_TIME_FREQ);
1509 }
1510
1511 static void
1512 tcp_expired_timers_dispatch (u32 * expired_timers)
1513 {
1514   u32 thread_index = vlib_get_thread_index ();
1515   u32 connection_index, timer_id, n_expired;
1516   tcp_worker_ctx_t *wrk;
1517   tcp_connection_t *tc;
1518   int i;
1519
1520   wrk = tcp_get_worker (thread_index);
1521   n_expired = vec_len (expired_timers);
1522   tcp_workerp_stats_inc (wrk, timer_expirations, n_expired);
1523
1524   /*
1525    * Invalidate all timer handles before dispatching. This avoids dangling
1526    * index references to timer wheel pool entries that have been freed.
1527    */
1528   for (i = 0; i < n_expired; i++)
1529     {
1530       connection_index = expired_timers[i] & 0x0FFFFFFF;
1531       timer_id = expired_timers[i] >> 28;
1532
1533       if (timer_id != TCP_TIMER_RETRANSMIT_SYN)
1534         tc = tcp_connection_get (connection_index, thread_index);
1535       else
1536         tc = tcp_half_open_connection_get (connection_index);
1537
1538       TCP_EVT (TCP_EVT_TIMER_POP, connection_index, timer_id);
1539
1540       tc->timers[timer_id] = TCP_TIMER_HANDLE_INVALID;
1541     }
1542
1543   clib_fifo_add (wrk->pending_timers, expired_timers, n_expired);
1544 }
1545
1546 static void
1547 tcp_initialize_timer_wheels (tcp_main_t * tm)
1548 {
1549   tw_timer_wheel_16t_2w_512sl_t *tw;
1550   /* *INDENT-OFF* */
1551   foreach_vlib_main (({
1552     tw = &tm->wrk_ctx[ii].timer_wheel;
1553     tw_timer_wheel_init_16t_2w_512sl (tw, tcp_expired_timers_dispatch,
1554                                       TCP_TIMER_TICK, ~0);
1555     tw->last_run_time = vlib_time_now (this_vlib_main);
1556   }));
1557   /* *INDENT-ON* */
1558 }
1559
1560 static void
1561 tcp_initialize_iss_seed (tcp_main_t * tm)
1562 {
1563   u32 default_seed = random_default_seed ();
1564   u64 time_now = clib_cpu_time_now ();
1565
1566   tm->iss_seed.first = (u64) random_u32 (&default_seed) << 32;
1567   tm->iss_seed.second = random_u64 (&time_now);
1568 }
1569
1570 static clib_error_t *
1571 tcp_main_enable (vlib_main_t * vm)
1572 {
1573   vlib_thread_main_t *vtm = vlib_get_thread_main ();
1574   u32 num_threads, n_workers, prealloc_conn_per_wrk;
1575   tcp_connection_t *tc __attribute__ ((unused));
1576   tcp_main_t *tm = vnet_get_tcp_main ();
1577   tcp_worker_ctx_t *wrk;
1578   clib_error_t *error = 0;
1579   int thread;
1580
1581   if ((error = vlib_call_init_function (vm, ip_main_init)))
1582     return error;
1583   if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
1584     return error;
1585   if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
1586     return error;
1587
1588   /*
1589    * Registrations
1590    */
1591
1592   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
1593   ip6_register_protocol (IP_PROTOCOL_TCP, tcp6_input_node.index);
1594
1595   /*
1596    * Initialize data structures
1597    */
1598
1599   num_threads = 1 /* main thread */  + vtm->n_threads;
1600   vec_validate (tm->wrk_ctx, num_threads - 1);
1601   n_workers = num_threads == 1 ? 1 : vtm->n_threads;
1602   prealloc_conn_per_wrk = tcp_cfg.preallocated_connections / n_workers;
1603
1604   for (thread = 0; thread < num_threads; thread++)
1605     {
1606       wrk = &tm->wrk_ctx[thread];
1607
1608       vec_validate (wrk->pending_deq_acked, 255);
1609       vec_validate (wrk->pending_disconnects, 255);
1610       vec_validate (wrk->pending_resets, 255);
1611       vec_reset_length (wrk->pending_deq_acked);
1612       vec_reset_length (wrk->pending_disconnects);
1613       vec_reset_length (wrk->pending_resets);
1614       wrk->vm = vlib_mains[thread];
1615
1616       /*
1617        * Preallocate connections. Assume that thread 0 won't
1618        * use preallocated threads when running multi-core
1619        */
1620       if ((thread > 0 || num_threads == 1) && prealloc_conn_per_wrk)
1621         pool_init_fixed (wrk->connections, prealloc_conn_per_wrk);
1622     }
1623
1624   /*
1625    * Use a preallocated half-open connection pool?
1626    */
1627   if (tcp_cfg.preallocated_half_open_connections)
1628     pool_init_fixed (tm->half_open_connections,
1629                      tcp_cfg.preallocated_half_open_connections);
1630
1631   /* Initialize clocks per tick for TCP timestamp. Used to compute
1632    * monotonically increasing timestamps. */
1633   tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
1634     / TCP_TSTAMP_RESOLUTION;
1635
1636   if (num_threads > 1)
1637     {
1638       clib_spinlock_init (&tm->half_open_lock);
1639     }
1640
1641   tcp_initialize_timer_wheels (tm);
1642   tcp_initialize_iss_seed (tm);
1643
1644   tm->bytes_per_buffer = vlib_buffer_get_default_data_size (vm);
1645   tm->cc_last_type = TCP_CC_LAST;
1646   return error;
1647 }
1648
1649 clib_error_t *
1650 vnet_tcp_enable_disable (vlib_main_t * vm, u8 is_en)
1651 {
1652   if (is_en)
1653     {
1654       if (tcp_main.is_enabled)
1655         return 0;
1656
1657       return tcp_main_enable (vm);
1658     }
1659   else
1660     {
1661       tcp_main.is_enabled = 0;
1662     }
1663
1664   return 0;
1665 }
1666
1667 void
1668 tcp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
1669 {
1670   tcp_main_t *tm = &tcp_main;
1671   if (is_ip4)
1672     tm->punt_unknown4 = is_add;
1673   else
1674     tm->punt_unknown6 = is_add;
1675 }
1676
1677 /**
1678  * Initialize default values for tcp parameters
1679  */
1680 static void
1681 tcp_configuration_init (void)
1682 {
1683   /* Initial wnd for SYN. Fifos are not allocated at that point so use some
1684    * predefined value. For SYN-ACK we still want the scale to be computed in
1685    * the same way */
1686   tcp_cfg.max_rx_fifo = 32 << 20;
1687   tcp_cfg.min_rx_fifo = 4 << 10;
1688
1689   tcp_cfg.default_mtu = 1500;
1690   tcp_cfg.initial_cwnd_multiplier = 0;
1691   tcp_cfg.enable_tx_pacing = 1;
1692   tcp_cfg.allow_tso = 0;
1693   tcp_cfg.csum_offload = 1;
1694   tcp_cfg.cc_algo = TCP_CC_NEWRENO;
1695   tcp_cfg.rwnd_min_update_ack = 1;
1696
1697   /* Time constants defined as timer tick (100ms) multiples */
1698   tcp_cfg.delack_time = 1;      /* 0.1s */
1699   tcp_cfg.closewait_time = 20;  /* 2s */
1700   tcp_cfg.timewait_time = 100;  /* 10s */
1701   tcp_cfg.finwait1_time = 600;  /* 60s */
1702   tcp_cfg.lastack_time = 300;   /* 30s */
1703   tcp_cfg.finwait2_time = 300;  /* 30s */
1704   tcp_cfg.closing_time = 300;   /* 30s */
1705   tcp_cfg.cleanup_time = 1;     /* 0.1s */
1706 }
1707
1708 static clib_error_t *
1709 tcp_init (vlib_main_t * vm)
1710 {
1711   tcp_main_t *tm = vnet_get_tcp_main ();
1712   ip_main_t *im = &ip_main;
1713   ip_protocol_info_t *pi;
1714
1715   /* Session layer, and by implication tcp, are disabled by default */
1716   tm->is_enabled = 0;
1717
1718   /* Register with IP for header parsing */
1719   pi = ip_get_protocol_info (im, IP_PROTOCOL_TCP);
1720   if (pi == 0)
1721     return clib_error_return (0, "TCP protocol info AWOL");
1722   pi->format_header = format_tcp_header;
1723   pi->unformat_pg_edit = unformat_pg_tcp_header;
1724
1725   /* Register as transport with session layer */
1726   transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
1727                                FIB_PROTOCOL_IP4, tcp4_output_node.index);
1728   transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
1729                                FIB_PROTOCOL_IP6, tcp6_output_node.index);
1730
1731   tcp_api_reference ();
1732   tcp_configuration_init ();
1733
1734   tm->cc_algo_by_name = hash_create_string (0, sizeof (uword));
1735
1736   return 0;
1737 }
1738
1739 VLIB_INIT_FUNCTION (tcp_init);
1740
1741 uword
1742 unformat_tcp_cc_algo (unformat_input_t * input, va_list * va)
1743 {
1744   tcp_cc_algorithm_type_e *result = va_arg (*va, tcp_cc_algorithm_type_e *);
1745   tcp_main_t *tm = &tcp_main;
1746   char *cc_algo_name;
1747   u8 found = 0;
1748   uword *p;
1749
1750   if (unformat (input, "%s", &cc_algo_name)
1751       && ((p = hash_get_mem (tm->cc_algo_by_name, cc_algo_name))))
1752     {
1753       *result = *p;
1754       found = 1;
1755     }
1756
1757   vec_free (cc_algo_name);
1758   return found;
1759 }
1760
1761 uword
1762 unformat_tcp_cc_algo_cfg (unformat_input_t * input, va_list * va)
1763 {
1764   tcp_main_t *tm = vnet_get_tcp_main ();
1765   tcp_cc_algorithm_t *cc_alg;
1766   unformat_input_t sub_input;
1767   int found = 0;
1768
1769   vec_foreach (cc_alg, tm->cc_algos)
1770   {
1771     if (!unformat (input, cc_alg->name))
1772       continue;
1773
1774     if (cc_alg->unformat_cfg
1775         && unformat (input, "%U", unformat_vlib_cli_sub_input, &sub_input))
1776       {
1777         if (cc_alg->unformat_cfg (&sub_input))
1778           found = 1;
1779       }
1780   }
1781   return found;
1782 }
1783
1784 static clib_error_t *
1785 tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
1786 {
1787   u32 cwnd_multiplier, tmp_time;
1788   uword memory_size;
1789
1790   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1791     {
1792       if (unformat (input, "preallocated-connections %d",
1793                     &tcp_cfg.preallocated_connections))
1794         ;
1795       else if (unformat (input, "preallocated-half-open-connections %d",
1796                          &tcp_cfg.preallocated_half_open_connections))
1797         ;
1798       else if (unformat (input, "buffer-fail-fraction %f",
1799                          &tcp_cfg.buffer_fail_fraction))
1800         ;
1801       else if (unformat (input, "max-rx-fifo %U", unformat_memory_size,
1802                          &memory_size))
1803         {
1804           if (memory_size >= 0x100000000)
1805             {
1806               return clib_error_return
1807                 (0, "max-rx-fifo %llu (0x%llx) too large", memory_size,
1808                  memory_size);
1809             }
1810           tcp_cfg.max_rx_fifo = memory_size;
1811         }
1812       else if (unformat (input, "min-rx-fifo %U", unformat_memory_size,
1813                          &memory_size))
1814         {
1815           if (memory_size >= 0x100000000)
1816             {
1817               return clib_error_return
1818                 (0, "min-rx-fifo %llu (0x%llx) too large", memory_size,
1819                  memory_size);
1820             }
1821           tcp_cfg.min_rx_fifo = memory_size;
1822         }
1823       else if (unformat (input, "mtu %u", &tcp_cfg.default_mtu))
1824         ;
1825       else if (unformat (input, "rwnd-min-update-ack %d",
1826                          &tcp_cfg.rwnd_min_update_ack))
1827         ;
1828       else if (unformat (input, "initial-cwnd-multiplier %u",
1829                          &cwnd_multiplier))
1830         tcp_cfg.initial_cwnd_multiplier = cwnd_multiplier;
1831       else if (unformat (input, "no-tx-pacing"))
1832         tcp_cfg.enable_tx_pacing = 0;
1833       else if (unformat (input, "tso"))
1834         tcp_cfg.allow_tso = 1;
1835       else if (unformat (input, "no-csum-offload"))
1836         tcp_cfg.csum_offload = 0;
1837       else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo,
1838                          &tcp_cfg.cc_algo))
1839         ;
1840       else if (unformat (input, "%U", unformat_tcp_cc_algo_cfg))
1841         ;
1842       else if (unformat (input, "closewait-time %u", &tmp_time))
1843         tcp_cfg.closewait_time = tmp_time / TCP_TIMER_TICK;
1844       else if (unformat (input, "timewait-time %u", &tmp_time))
1845         tcp_cfg.timewait_time = tmp_time / TCP_TIMER_TICK;
1846       else if (unformat (input, "finwait1-time %u", &tmp_time))
1847         tcp_cfg.finwait1_time = tmp_time / TCP_TIMER_TICK;
1848       else if (unformat (input, "finwait2-time %u", &tmp_time))
1849         tcp_cfg.finwait2_time = tmp_time / TCP_TIMER_TICK;
1850       else if (unformat (input, "lastack-time %u", &tmp_time))
1851         tcp_cfg.lastack_time = tmp_time / TCP_TIMER_TICK;
1852       else if (unformat (input, "closing-time %u", &tmp_time))
1853         tcp_cfg.closing_time = tmp_time / TCP_TIMER_TICK;
1854       else if (unformat (input, "cleanup-time %u", &tmp_time))
1855         tcp_cfg.cleanup_time = tmp_time / TCP_TIMER_TICK;
1856       else
1857         return clib_error_return (0, "unknown input `%U'",
1858                                   format_unformat_error, input);
1859     }
1860   return 0;
1861 }
1862
1863 VLIB_CONFIG_FUNCTION (tcp_config_fn, "tcp");
1864
1865
1866 /**
1867  * \brief Configure an ipv4 source address range
1868  * @param vm vlib_main_t pointer
1869  * @param start first ipv4 address in the source address range
1870  * @param end last ipv4 address in the source address range
1871  * @param table_id VRF / table ID, 0 for the default FIB
1872  * @return 0 if all OK, else an error indication from api_errno.h
1873  */
1874
1875 int
1876 tcp_configure_v4_source_address_range (vlib_main_t * vm,
1877                                        ip4_address_t * start,
1878                                        ip4_address_t * end, u32 table_id)
1879 {
1880   u32 start_host_byte_order, end_host_byte_order;
1881   fib_prefix_t prefix;
1882   fib_node_index_t fei;
1883   u32 fib_index = 0;
1884   u32 sw_if_index;
1885   int rv;
1886
1887   clib_memset (&prefix, 0, sizeof (prefix));
1888
1889   fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
1890
1891   if (fib_index == ~0)
1892     return VNET_API_ERROR_NO_SUCH_FIB;
1893
1894   start_host_byte_order = clib_net_to_host_u32 (start->as_u32);
1895   end_host_byte_order = clib_net_to_host_u32 (end->as_u32);
1896
1897   /* sanity check for reversed args or some such */
1898   if ((end_host_byte_order - start_host_byte_order) > (10 << 10))
1899     return VNET_API_ERROR_INVALID_ARGUMENT;
1900
1901   /* Lookup the last address, to identify the interface involved */
1902   prefix.fp_len = 32;
1903   prefix.fp_proto = FIB_PROTOCOL_IP4;
1904   memcpy (&prefix.fp_addr.ip4, end, sizeof (ip4_address_t));
1905
1906   fei = fib_table_lookup (fib_index, &prefix);
1907
1908   /* Couldn't find route to destination. Bail out. */
1909   if (fei == FIB_NODE_INDEX_INVALID)
1910     return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
1911
1912   sw_if_index = fib_entry_get_resolving_interface (fei);
1913
1914   /* Configure proxy arp across the range */
1915   rv = ip4_neighbor_proxy_add (fib_index, start, end);
1916
1917   if (rv)
1918     return rv;
1919
1920   rv = ip4_neighbor_proxy_enable (sw_if_index);
1921
1922   if (rv)
1923     return rv;
1924
1925   do
1926     {
1927       dpo_id_t dpo = DPO_INVALID;
1928
1929       vec_add1 (tcp_cfg.ip4_src_addrs, start[0]);
1930
1931       /* Add local adjacencies for the range */
1932
1933       receive_dpo_add_or_lock (DPO_PROTO_IP4, ~0 /* sw_if_index */ ,
1934                                NULL, &dpo);
1935       prefix.fp_len = 32;
1936       prefix.fp_proto = FIB_PROTOCOL_IP4;
1937       prefix.fp_addr.ip4.as_u32 = start->as_u32;
1938
1939       fib_table_entry_special_dpo_update (fib_index,
1940                                           &prefix,
1941                                           FIB_SOURCE_API,
1942                                           FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
1943       dpo_reset (&dpo);
1944
1945       start_host_byte_order++;
1946       start->as_u32 = clib_host_to_net_u32 (start_host_byte_order);
1947     }
1948   while (start_host_byte_order <= end_host_byte_order);
1949
1950   return 0;
1951 }
1952
1953 /**
1954  * \brief Configure an ipv6 source address range
1955  * @param vm vlib_main_t pointer
1956  * @param start first ipv6 address in the source address range
1957  * @param end last ipv6 address in the source address range
1958  * @param table_id VRF / table ID, 0 for the default FIB
1959  * @return 0 if all OK, else an error indication from api_errno.h
1960  */
1961
1962 int
1963 tcp_configure_v6_source_address_range (vlib_main_t * vm,
1964                                        ip6_address_t * start,
1965                                        ip6_address_t * end, u32 table_id)
1966 {
1967   fib_prefix_t prefix;
1968   u32 fib_index = 0;
1969   fib_node_index_t fei;
1970   u32 sw_if_index;
1971
1972   clib_memset (&prefix, 0, sizeof (prefix));
1973
1974   fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id);
1975
1976   if (fib_index == ~0)
1977     return VNET_API_ERROR_NO_SUCH_FIB;
1978
1979   while (1)
1980     {
1981       int i;
1982       ip6_address_t tmp;
1983       dpo_id_t dpo = DPO_INVALID;
1984
1985       /* Remember this address */
1986       vec_add1 (tcp_cfg.ip6_src_addrs, start[0]);
1987
1988       /* Lookup the prefix, to identify the interface involved */
1989       prefix.fp_len = 128;
1990       prefix.fp_proto = FIB_PROTOCOL_IP6;
1991       memcpy (&prefix.fp_addr.ip6, start, sizeof (ip6_address_t));
1992
1993       fei = fib_table_lookup (fib_index, &prefix);
1994
1995       /* Couldn't find route to destination. Bail out. */
1996       if (fei == FIB_NODE_INDEX_INVALID)
1997         return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
1998
1999       sw_if_index = fib_entry_get_resolving_interface (fei);
2000
2001       if (sw_if_index == (u32) ~ 0)
2002         return VNET_API_ERROR_NO_MATCHING_INTERFACE;
2003
2004       /* Add a proxy neighbor discovery entry for this address */
2005       ip6_neighbor_proxy_add (sw_if_index, start);
2006
2007       /* Add a receive adjacency for this address */
2008       receive_dpo_add_or_lock (DPO_PROTO_IP6, ~0 /* sw_if_index */ ,
2009                                NULL, &dpo);
2010
2011       fib_table_entry_special_dpo_update (fib_index,
2012                                           &prefix,
2013                                           FIB_SOURCE_API,
2014                                           FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
2015       dpo_reset (&dpo);
2016
2017       /* Done with the entire range? */
2018       if (!memcmp (start, end, sizeof (start[0])))
2019         break;
2020
2021       /* Increment the address. DGMS. */
2022       tmp = start[0];
2023       for (i = 15; i >= 0; i--)
2024         {
2025           tmp.as_u8[i] += 1;
2026           if (tmp.as_u8[i] != 0)
2027             break;
2028         }
2029       start[0] = tmp;
2030     }
2031   return 0;
2032 }
2033
2034 static clib_error_t *
2035 tcp_src_address_fn (vlib_main_t * vm,
2036                     unformat_input_t * input, vlib_cli_command_t * cmd_arg)
2037 {
2038   ip4_address_t v4start, v4end;
2039   ip6_address_t v6start, v6end;
2040   u32 table_id = 0;
2041   int v4set = 0;
2042   int v6set = 0;
2043   int rv;
2044
2045   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2046     {
2047       if (unformat (input, "%U - %U", unformat_ip4_address, &v4start,
2048                     unformat_ip4_address, &v4end))
2049         v4set = 1;
2050       else if (unformat (input, "%U", unformat_ip4_address, &v4start))
2051         {
2052           memcpy (&v4end, &v4start, sizeof (v4start));
2053           v4set = 1;
2054         }
2055       else if (unformat (input, "%U - %U", unformat_ip6_address, &v6start,
2056                          unformat_ip6_address, &v6end))
2057         v6set = 1;
2058       else if (unformat (input, "%U", unformat_ip6_address, &v6start))
2059         {
2060           memcpy (&v6end, &v6start, sizeof (v6start));
2061           v6set = 1;
2062         }
2063       else if (unformat (input, "fib-table %d", &table_id))
2064         ;
2065       else
2066         break;
2067     }
2068
2069   if (!v4set && !v6set)
2070     return clib_error_return (0, "at least one v4 or v6 address required");
2071
2072   if (v4set)
2073     {
2074       rv = tcp_configure_v4_source_address_range (vm, &v4start, &v4end,
2075                                                   table_id);
2076       switch (rv)
2077         {
2078         case 0:
2079           break;
2080
2081         case VNET_API_ERROR_NO_SUCH_FIB:
2082           return clib_error_return (0, "Invalid table-id %d", table_id);
2083
2084         case VNET_API_ERROR_INVALID_ARGUMENT:
2085           return clib_error_return (0, "Invalid address range %U - %U",
2086                                     format_ip4_address, &v4start,
2087                                     format_ip4_address, &v4end);
2088         default:
2089           return clib_error_return (0, "error %d", rv);
2090           break;
2091         }
2092     }
2093   if (v6set)
2094     {
2095       rv = tcp_configure_v6_source_address_range (vm, &v6start, &v6end,
2096                                                   table_id);
2097       switch (rv)
2098         {
2099         case 0:
2100           break;
2101
2102         case VNET_API_ERROR_NO_SUCH_FIB:
2103           return clib_error_return (0, "Invalid table-id %d", table_id);
2104
2105         default:
2106           return clib_error_return (0, "error %d", rv);
2107           break;
2108         }
2109     }
2110   return 0;
2111 }
2112
2113 /* *INDENT-OFF* */
2114 VLIB_CLI_COMMAND (tcp_src_address_command, static) =
2115 {
2116   .path = "tcp src-address",
2117   .short_help = "tcp src-address <ip-addr> [- <ip-addr>] add src address range",
2118   .function = tcp_src_address_fn,
2119 };
2120 /* *INDENT-ON* */
2121
2122 static u8 *
2123 tcp_scoreboard_dump_trace (u8 * s, sack_scoreboard_t * sb)
2124 {
2125 #if TCP_SCOREBOARD_TRACE
2126
2127   scoreboard_trace_elt_t *block;
2128   int i = 0;
2129
2130   if (!sb->trace)
2131     return s;
2132
2133   s = format (s, "scoreboard trace:");
2134   vec_foreach (block, sb->trace)
2135   {
2136     s = format (s, "{%u, %u, %u, %u, %u}, ", block->start, block->end,
2137                 block->ack, block->snd_una_max, block->group);
2138     if ((++i % 3) == 0)
2139       s = format (s, "\n");
2140   }
2141   return s;
2142 #else
2143   return 0;
2144 #endif
2145 }
2146
2147 static clib_error_t *
2148 tcp_show_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input,
2149                               vlib_cli_command_t * cmd_arg)
2150 {
2151   transport_connection_t *tconn = 0;
2152   tcp_connection_t *tc;
2153   u8 *s = 0;
2154   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2155     {
2156       if (unformat (input, "%U", unformat_transport_connection, &tconn,
2157                     TRANSPORT_PROTO_TCP))
2158         ;
2159       else
2160         return clib_error_return (0, "unknown input `%U'",
2161                                   format_unformat_error, input);
2162     }
2163
2164   if (!TCP_SCOREBOARD_TRACE)
2165     {
2166       vlib_cli_output (vm, "scoreboard tracing not enabled");
2167       return 0;
2168     }
2169
2170   tc = tcp_get_connection_from_transport (tconn);
2171   s = tcp_scoreboard_dump_trace (s, &tc->sack_sb);
2172   vlib_cli_output (vm, "%v", s);
2173   return 0;
2174 }
2175
2176 /* *INDENT-OFF* */
2177 VLIB_CLI_COMMAND (tcp_show_scoreboard_trace_command, static) =
2178 {
2179   .path = "show tcp scoreboard trace",
2180   .short_help = "show tcp scoreboard trace <connection>",
2181   .function = tcp_show_scoreboard_trace_fn,
2182 };
2183 /* *INDENT-ON* */
2184
2185 u8 *
2186 tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose)
2187 {
2188   int i, trace_len;
2189   scoreboard_trace_elt_t *trace;
2190   u32 next_ack, left, group, has_new_ack = 0;
2191   tcp_connection_t _dummy_tc, *dummy_tc = &_dummy_tc;
2192   sack_block_t *block;
2193
2194   if (!TCP_SCOREBOARD_TRACE)
2195     {
2196       s = format (s, "scoreboard tracing not enabled");
2197       return s;
2198     }
2199
2200   if (!tc)
2201     return s;
2202
2203   clib_memset (dummy_tc, 0, sizeof (*dummy_tc));
2204   tcp_connection_timers_init (dummy_tc);
2205   scoreboard_init (&dummy_tc->sack_sb);
2206   dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
2207
2208 #if TCP_SCOREBOARD_TRACE
2209   trace = tc->sack_sb.trace;
2210   trace_len = vec_len (tc->sack_sb.trace);
2211 #endif
2212
2213   for (i = 0; i < trace_len; i++)
2214     {
2215       if (trace[i].ack != 0)
2216         {
2217           dummy_tc->snd_una = trace[i].ack - 1448;
2218           dummy_tc->snd_una_max = trace[i].ack;
2219         }
2220     }
2221
2222   left = 0;
2223   while (left < trace_len)
2224     {
2225       group = trace[left].group;
2226       vec_reset_length (dummy_tc->rcv_opts.sacks);
2227       has_new_ack = 0;
2228       while (trace[left].group == group)
2229         {
2230           if (trace[left].ack != 0)
2231             {
2232               if (verbose)
2233                 s = format (s, "Adding ack %u, snd_una_max %u, segs: ",
2234                             trace[left].ack, trace[left].snd_una_max);
2235               dummy_tc->snd_una_max = trace[left].snd_una_max;
2236               next_ack = trace[left].ack;
2237               has_new_ack = 1;
2238             }
2239           else
2240             {
2241               if (verbose)
2242                 s = format (s, "[%u, %u], ", trace[left].start,
2243                             trace[left].end);
2244               vec_add2 (dummy_tc->rcv_opts.sacks, block, 1);
2245               block->start = trace[left].start;
2246               block->end = trace[left].end;
2247             }
2248           left++;
2249         }
2250
2251       /* Push segments */
2252       tcp_rcv_sacks (dummy_tc, next_ack);
2253       if (has_new_ack)
2254         dummy_tc->snd_una = next_ack;
2255
2256       if (verbose)
2257         s = format (s, "result: %U", format_tcp_scoreboard,
2258                     &dummy_tc->sack_sb);
2259
2260     }
2261   s = format (s, "result: %U", format_tcp_scoreboard, &dummy_tc->sack_sb);
2262
2263   return s;
2264 }
2265
2266 static clib_error_t *
2267 tcp_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input,
2268                          vlib_cli_command_t * cmd_arg)
2269 {
2270   transport_connection_t *tconn = 0;
2271   tcp_connection_t *tc = 0;
2272   u8 *str = 0;
2273   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2274     {
2275       if (unformat (input, "%U", unformat_transport_connection, &tconn,
2276                     TRANSPORT_PROTO_TCP))
2277         ;
2278       else
2279         return clib_error_return (0, "unknown input `%U'",
2280                                   format_unformat_error, input);
2281     }
2282
2283   if (!TCP_SCOREBOARD_TRACE)
2284     {
2285       vlib_cli_output (vm, "scoreboard tracing not enabled");
2286       return 0;
2287     }
2288
2289   tc = tcp_get_connection_from_transport (tconn);
2290   if (!tc)
2291     {
2292       vlib_cli_output (vm, "connection not found");
2293       return 0;
2294     }
2295   str = tcp_scoreboard_replay (str, tc, 1);
2296   vlib_cli_output (vm, "%v", str);
2297   return 0;
2298 }
2299
2300 /* *INDENT-OFF* */
2301 VLIB_CLI_COMMAND (tcp_replay_scoreboard_command, static) =
2302 {
2303   .path = "tcp replay scoreboard",
2304   .short_help = "tcp replay scoreboard <connection>",
2305   .function = tcp_scoreboard_trace_fn,
2306 };
2307 /* *INDENT-ON* */
2308
2309 static clib_error_t *
2310 show_tcp_punt_fn (vlib_main_t * vm, unformat_input_t * input,
2311                   vlib_cli_command_t * cmd_arg)
2312 {
2313   tcp_main_t *tm = vnet_get_tcp_main ();
2314   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2315     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
2316                               input);
2317   vlib_cli_output (vm, "IPv4 TCP punt: %s",
2318                    tm->punt_unknown4 ? "enabled" : "disabled");
2319   vlib_cli_output (vm, "IPv6 TCP punt: %s",
2320                    tm->punt_unknown6 ? "enabled" : "disabled");
2321   return 0;
2322 }
2323 /* *INDENT-OFF* */
2324 VLIB_CLI_COMMAND (show_tcp_punt_command, static) =
2325 {
2326   .path = "show tcp punt",
2327   .short_help = "show tcp punt",
2328   .function = show_tcp_punt_fn,
2329 };
2330 /* *INDENT-ON* */
2331
2332 static clib_error_t *
2333 show_tcp_stats_fn (vlib_main_t * vm, unformat_input_t * input,
2334                    vlib_cli_command_t * cmd)
2335 {
2336   tcp_main_t *tm = vnet_get_tcp_main ();
2337   tcp_worker_ctx_t *wrk;
2338   u32 thread;
2339
2340   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2341     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
2342                               input);
2343   for (thread = 0; thread < vec_len (tm->wrk_ctx); thread++)
2344     {
2345       wrk = tcp_get_worker (thread);
2346       vlib_cli_output (vm, "Thread %u:\n", thread);
2347
2348       if (clib_fifo_elts (wrk->pending_timers))
2349         vlib_cli_output (vm, " %lu pending timers",
2350                          clib_fifo_elts (wrk->pending_timers));
2351
2352 #define _(name,type,str)                                        \
2353   if (wrk->stats.name)                                          \
2354     vlib_cli_output (vm, " %lu %s", wrk->stats.name, str);
2355       foreach_tcp_wrk_stat
2356 #undef _
2357     }
2358
2359   return 0;
2360 }
2361
2362 /* *INDENT-OFF* */
2363 VLIB_CLI_COMMAND (show_tcp_stats_command, static) =
2364 {
2365   .path = "show tcp stats",
2366   .short_help = "show tcp stats",
2367   .function = show_tcp_stats_fn,
2368 };
2369 /* *INDENT-ON* */
2370
2371 static clib_error_t *
2372 clear_tcp_stats_fn (vlib_main_t * vm, unformat_input_t * input,
2373                     vlib_cli_command_t * cmd)
2374 {
2375   tcp_main_t *tm = vnet_get_tcp_main ();
2376   tcp_worker_ctx_t *wrk;
2377   u32 thread;
2378
2379   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2380     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
2381                               input);
2382
2383   for (thread = 0; thread < vec_len (tm->wrk_ctx); thread++)
2384     {
2385       wrk = tcp_get_worker (thread);
2386       clib_memset (&wrk->stats, 0, sizeof (wrk->stats));
2387     }
2388
2389   return 0;
2390 }
2391
2392 /* *INDENT-OFF* */
2393 VLIB_CLI_COMMAND (clear_tcp_stats_command, static) =
2394 {
2395   .path = "clear tcp stats",
2396   .short_help = "clear tcp stats",
2397   .function = clear_tcp_stats_fn,
2398 };
2399 /* *INDENT-ON* */
2400
2401 /*
2402  * fd.io coding-style-patch-verification: ON
2403  *
2404  * Local Variables:
2405  * eval: (c-set-style "gnu")
2406  * End:
2407  */