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, wrk->max_timers_per_loop); 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   if (thread_index == 0 && clib_fifo_elts (wrk->pending_timers))
1417     vlib_process_signal_event_mt (wrk->vm, session_queue_process_node.index,
1418                                   SESSION_Q_PROCESS_FLUSH_FRAMES, 0);
1419 }
1420
1421 /**
1422  * Flush ip lookup tx frames populated by timer pops
1423  */
1424 static void
1425 tcp_flush_frames_to_output (tcp_worker_ctx_t * wrk)
1426 {
1427   if (wrk->ip_lookup_tx_frames[0])
1428     {
1429       vlib_put_frame_to_node (wrk->vm, ip4_lookup_node.index,
1430                               wrk->ip_lookup_tx_frames[0]);
1431       wrk->ip_lookup_tx_frames[0] = 0;
1432     }
1433   if (wrk->ip_lookup_tx_frames[1])
1434     {
1435       vlib_put_frame_to_node (wrk->vm, ip6_lookup_node.index,
1436                               wrk->ip_lookup_tx_frames[1]);
1437       wrk->ip_lookup_tx_frames[1] = 0;
1438     }
1439 }
1440
1441 static void
1442 tcp_update_time (f64 now, u8 thread_index)
1443 {
1444   tcp_worker_ctx_t *wrk = tcp_get_worker (thread_index);
1445
1446   tcp_set_time_now (wrk);
1447   tw_timer_expire_timers_16t_2w_512sl (&wrk->timer_wheel, now);
1448   tcp_dispatch_pending_timers (wrk);
1449   tcp_flush_frames_to_output (wrk);
1450 }
1451
1452 static void
1453 tcp_session_flush_data (transport_connection_t * tconn)
1454 {
1455   tcp_connection_t *tc = (tcp_connection_t *) tconn;
1456   if (tc->flags & TCP_CONN_PSH_PENDING)
1457     return;
1458   tc->flags |= TCP_CONN_PSH_PENDING;
1459   tc->psh_seq = tc->snd_una + transport_max_tx_dequeue (tconn) - 1;
1460 }
1461
1462 /* *INDENT-OFF* */
1463 const static transport_proto_vft_t tcp_proto = {
1464   .enable = vnet_tcp_enable_disable,
1465   .start_listen = tcp_session_bind,
1466   .stop_listen = tcp_session_unbind,
1467   .push_header = tcp_session_push_header,
1468   .get_connection = tcp_session_get_transport,
1469   .get_listener = tcp_session_get_listener,
1470   .get_half_open = tcp_half_open_session_get_transport,
1471   .connect = tcp_session_open,
1472   .close = tcp_session_close,
1473   .cleanup = tcp_session_cleanup,
1474   .reset = tcp_session_reset,
1475   .send_mss = tcp_session_send_mss,
1476   .send_space = tcp_session_send_space,
1477   .update_time = tcp_update_time,
1478   .tx_fifo_offset = tcp_session_tx_fifo_offset,
1479   .flush_data = tcp_session_flush_data,
1480   .custom_tx = tcp_session_custom_tx,
1481   .format_connection = format_tcp_session,
1482   .format_listener = format_tcp_listener_session,
1483   .format_half_open = format_tcp_half_open_session,
1484   .transport_options = {
1485     .tx_type = TRANSPORT_TX_PEEK,
1486     .service_type = TRANSPORT_SERVICE_VC,
1487   },
1488 };
1489 /* *INDENT-ON* */
1490
1491 void
1492 tcp_connection_tx_pacer_update (tcp_connection_t * tc)
1493 {
1494   if (!transport_connection_is_tx_paced (&tc->connection))
1495     return;
1496
1497   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
1498
1499   transport_connection_tx_pacer_update (&tc->connection,
1500                                         tcp_cc_get_pacing_rate (tc),
1501                                         srtt * CLIB_US_TIME_FREQ);
1502 }
1503
1504 void
1505 tcp_connection_tx_pacer_reset (tcp_connection_t * tc, u32 window,
1506                                u32 start_bucket)
1507 {
1508   f64 srtt = clib_min ((f64) tc->srtt * TCP_TICK, tc->mrtt_us);
1509   transport_connection_tx_pacer_reset (&tc->connection,
1510                                        tcp_cc_get_pacing_rate (tc),
1511                                        start_bucket,
1512                                        srtt * CLIB_US_TIME_FREQ);
1513 }
1514
1515 static void
1516 tcp_expired_timers_dispatch (u32 * expired_timers)
1517 {
1518   u32 thread_index = vlib_get_thread_index (), n_left, max_per_loop;
1519   u32 connection_index, timer_id, n_expired, max_loops;
1520   tcp_worker_ctx_t *wrk;
1521   tcp_connection_t *tc;
1522   int i;
1523
1524   wrk = tcp_get_worker (thread_index);
1525   n_expired = vec_len (expired_timers);
1526   tcp_workerp_stats_inc (wrk, timer_expirations, n_expired);
1527   n_left = clib_fifo_elts (wrk->pending_timers);
1528
1529   /*
1530    * Invalidate all timer handles before dispatching. This avoids dangling
1531    * index references to timer wheel pool entries that have been freed.
1532    */
1533   for (i = 0; i < n_expired; i++)
1534     {
1535       connection_index = expired_timers[i] & 0x0FFFFFFF;
1536       timer_id = expired_timers[i] >> 28;
1537
1538       if (timer_id != TCP_TIMER_RETRANSMIT_SYN)
1539         tc = tcp_connection_get (connection_index, thread_index);
1540       else
1541         tc = tcp_half_open_connection_get (connection_index);
1542
1543       TCP_EVT (TCP_EVT_TIMER_POP, connection_index, timer_id);
1544
1545       tc->timers[timer_id] = TCP_TIMER_HANDLE_INVALID;
1546     }
1547
1548   clib_fifo_add (wrk->pending_timers, expired_timers, n_expired);
1549
1550   max_loops = clib_max (1, 0.5 * TCP_TIMER_TICK * wrk->vm->loops_per_second);
1551   max_per_loop = clib_max ((n_left + n_expired) / max_loops, 10);
1552   max_per_loop = clib_min (max_per_loop, VLIB_FRAME_SIZE);
1553   wrk->max_timers_per_loop = clib_max (n_left ? wrk->max_timers_per_loop : 0,
1554                                        max_per_loop);
1555
1556   if (thread_index == 0)
1557     vlib_process_signal_event_mt (wrk->vm, session_queue_process_node.index,
1558                                   SESSION_Q_PROCESS_FLUSH_FRAMES, 0);
1559 }
1560
1561 static void
1562 tcp_initialize_timer_wheels (tcp_main_t * tm)
1563 {
1564   tw_timer_wheel_16t_2w_512sl_t *tw;
1565   /* *INDENT-OFF* */
1566   foreach_vlib_main (({
1567     tw = &tm->wrk_ctx[ii].timer_wheel;
1568     tw_timer_wheel_init_16t_2w_512sl (tw, tcp_expired_timers_dispatch,
1569                                       TCP_TIMER_TICK, ~0);
1570     tw->last_run_time = vlib_time_now (this_vlib_main);
1571   }));
1572   /* *INDENT-ON* */
1573 }
1574
1575 static void
1576 tcp_initialize_iss_seed (tcp_main_t * tm)
1577 {
1578   u32 default_seed = random_default_seed ();
1579   u64 time_now = clib_cpu_time_now ();
1580
1581   tm->iss_seed.first = (u64) random_u32 (&default_seed) << 32;
1582   tm->iss_seed.second = random_u64 (&time_now);
1583 }
1584
1585 static clib_error_t *
1586 tcp_main_enable (vlib_main_t * vm)
1587 {
1588   vlib_thread_main_t *vtm = vlib_get_thread_main ();
1589   u32 num_threads, n_workers, prealloc_conn_per_wrk;
1590   tcp_connection_t *tc __attribute__ ((unused));
1591   tcp_main_t *tm = vnet_get_tcp_main ();
1592   tcp_worker_ctx_t *wrk;
1593   clib_error_t *error = 0;
1594   int thread;
1595
1596   if ((error = vlib_call_init_function (vm, ip_main_init)))
1597     return error;
1598   if ((error = vlib_call_init_function (vm, ip4_lookup_init)))
1599     return error;
1600   if ((error = vlib_call_init_function (vm, ip6_lookup_init)))
1601     return error;
1602
1603   /*
1604    * Registrations
1605    */
1606
1607   ip4_register_protocol (IP_PROTOCOL_TCP, tcp4_input_node.index);
1608   ip6_register_protocol (IP_PROTOCOL_TCP, tcp6_input_node.index);
1609
1610   /*
1611    * Initialize data structures
1612    */
1613
1614   num_threads = 1 /* main thread */  + vtm->n_threads;
1615   vec_validate (tm->wrk_ctx, num_threads - 1);
1616   n_workers = num_threads == 1 ? 1 : vtm->n_threads;
1617   prealloc_conn_per_wrk = tcp_cfg.preallocated_connections / n_workers;
1618
1619   for (thread = 0; thread < num_threads; thread++)
1620     {
1621       wrk = &tm->wrk_ctx[thread];
1622
1623       vec_validate (wrk->pending_deq_acked, 255);
1624       vec_validate (wrk->pending_disconnects, 255);
1625       vec_validate (wrk->pending_resets, 255);
1626       vec_reset_length (wrk->pending_deq_acked);
1627       vec_reset_length (wrk->pending_disconnects);
1628       vec_reset_length (wrk->pending_resets);
1629       wrk->vm = vlib_mains[thread];
1630       wrk->max_timers_per_loop = 10;
1631
1632       /*
1633        * Preallocate connections. Assume that thread 0 won't
1634        * use preallocated threads when running multi-core
1635        */
1636       if ((thread > 0 || num_threads == 1) && prealloc_conn_per_wrk)
1637         pool_init_fixed (wrk->connections, prealloc_conn_per_wrk);
1638     }
1639
1640   /*
1641    * Use a preallocated half-open connection pool?
1642    */
1643   if (tcp_cfg.preallocated_half_open_connections)
1644     pool_init_fixed (tm->half_open_connections,
1645                      tcp_cfg.preallocated_half_open_connections);
1646
1647   /* Initialize clocks per tick for TCP timestamp. Used to compute
1648    * monotonically increasing timestamps. */
1649   tm->tstamp_ticks_per_clock = vm->clib_time.seconds_per_clock
1650     / TCP_TSTAMP_RESOLUTION;
1651
1652   if (num_threads > 1)
1653     {
1654       clib_spinlock_init (&tm->half_open_lock);
1655     }
1656
1657   tcp_initialize_timer_wheels (tm);
1658   tcp_initialize_iss_seed (tm);
1659
1660   tm->bytes_per_buffer = vlib_buffer_get_default_data_size (vm);
1661   tm->cc_last_type = TCP_CC_LAST;
1662   return error;
1663 }
1664
1665 clib_error_t *
1666 vnet_tcp_enable_disable (vlib_main_t * vm, u8 is_en)
1667 {
1668   if (is_en)
1669     {
1670       if (tcp_main.is_enabled)
1671         return 0;
1672
1673       return tcp_main_enable (vm);
1674     }
1675   else
1676     {
1677       tcp_main.is_enabled = 0;
1678     }
1679
1680   return 0;
1681 }
1682
1683 void
1684 tcp_punt_unknown (vlib_main_t * vm, u8 is_ip4, u8 is_add)
1685 {
1686   tcp_main_t *tm = &tcp_main;
1687   if (is_ip4)
1688     tm->punt_unknown4 = is_add;
1689   else
1690     tm->punt_unknown6 = is_add;
1691 }
1692
1693 /**
1694  * Initialize default values for tcp parameters
1695  */
1696 static void
1697 tcp_configuration_init (void)
1698 {
1699   /* Initial wnd for SYN. Fifos are not allocated at that point so use some
1700    * predefined value. For SYN-ACK we still want the scale to be computed in
1701    * the same way */
1702   tcp_cfg.max_rx_fifo = 32 << 20;
1703   tcp_cfg.min_rx_fifo = 4 << 10;
1704
1705   tcp_cfg.default_mtu = 1500;
1706   tcp_cfg.initial_cwnd_multiplier = 0;
1707   tcp_cfg.enable_tx_pacing = 1;
1708   tcp_cfg.allow_tso = 0;
1709   tcp_cfg.csum_offload = 1;
1710   tcp_cfg.cc_algo = TCP_CC_NEWRENO;
1711   tcp_cfg.rwnd_min_update_ack = 1;
1712
1713   /* Time constants defined as timer tick (100ms) multiples */
1714   tcp_cfg.delack_time = 1;      /* 0.1s */
1715   tcp_cfg.closewait_time = 20;  /* 2s */
1716   tcp_cfg.timewait_time = 100;  /* 10s */
1717   tcp_cfg.finwait1_time = 600;  /* 60s */
1718   tcp_cfg.lastack_time = 300;   /* 30s */
1719   tcp_cfg.finwait2_time = 300;  /* 30s */
1720   tcp_cfg.closing_time = 300;   /* 30s */
1721   tcp_cfg.cleanup_time = 1;     /* 0.1s */
1722 }
1723
1724 static clib_error_t *
1725 tcp_init (vlib_main_t * vm)
1726 {
1727   tcp_main_t *tm = vnet_get_tcp_main ();
1728   ip_main_t *im = &ip_main;
1729   ip_protocol_info_t *pi;
1730
1731   /* Session layer, and by implication tcp, are disabled by default */
1732   tm->is_enabled = 0;
1733
1734   /* Register with IP for header parsing */
1735   pi = ip_get_protocol_info (im, IP_PROTOCOL_TCP);
1736   if (pi == 0)
1737     return clib_error_return (0, "TCP protocol info AWOL");
1738   pi->format_header = format_tcp_header;
1739   pi->unformat_pg_edit = unformat_pg_tcp_header;
1740
1741   /* Register as transport with session layer */
1742   transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
1743                                FIB_PROTOCOL_IP4, tcp4_output_node.index);
1744   transport_register_protocol (TRANSPORT_PROTO_TCP, &tcp_proto,
1745                                FIB_PROTOCOL_IP6, tcp6_output_node.index);
1746
1747   tcp_api_reference ();
1748   tcp_configuration_init ();
1749
1750   tm->cc_algo_by_name = hash_create_string (0, sizeof (uword));
1751
1752   return 0;
1753 }
1754
1755 VLIB_INIT_FUNCTION (tcp_init);
1756
1757 uword
1758 unformat_tcp_cc_algo (unformat_input_t * input, va_list * va)
1759 {
1760   tcp_cc_algorithm_type_e *result = va_arg (*va, tcp_cc_algorithm_type_e *);
1761   tcp_main_t *tm = &tcp_main;
1762   char *cc_algo_name;
1763   u8 found = 0;
1764   uword *p;
1765
1766   if (unformat (input, "%s", &cc_algo_name)
1767       && ((p = hash_get_mem (tm->cc_algo_by_name, cc_algo_name))))
1768     {
1769       *result = *p;
1770       found = 1;
1771     }
1772
1773   vec_free (cc_algo_name);
1774   return found;
1775 }
1776
1777 uword
1778 unformat_tcp_cc_algo_cfg (unformat_input_t * input, va_list * va)
1779 {
1780   tcp_main_t *tm = vnet_get_tcp_main ();
1781   tcp_cc_algorithm_t *cc_alg;
1782   unformat_input_t sub_input;
1783   int found = 0;
1784
1785   vec_foreach (cc_alg, tm->cc_algos)
1786   {
1787     if (!unformat (input, cc_alg->name))
1788       continue;
1789
1790     if (cc_alg->unformat_cfg
1791         && unformat (input, "%U", unformat_vlib_cli_sub_input, &sub_input))
1792       {
1793         if (cc_alg->unformat_cfg (&sub_input))
1794           found = 1;
1795       }
1796   }
1797   return found;
1798 }
1799
1800 static clib_error_t *
1801 tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
1802 {
1803   u32 cwnd_multiplier, tmp_time;
1804   uword memory_size;
1805
1806   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1807     {
1808       if (unformat (input, "preallocated-connections %d",
1809                     &tcp_cfg.preallocated_connections))
1810         ;
1811       else if (unformat (input, "preallocated-half-open-connections %d",
1812                          &tcp_cfg.preallocated_half_open_connections))
1813         ;
1814       else if (unformat (input, "buffer-fail-fraction %f",
1815                          &tcp_cfg.buffer_fail_fraction))
1816         ;
1817       else if (unformat (input, "max-rx-fifo %U", unformat_memory_size,
1818                          &memory_size))
1819         {
1820           if (memory_size >= 0x100000000)
1821             {
1822               return clib_error_return
1823                 (0, "max-rx-fifo %llu (0x%llx) too large", memory_size,
1824                  memory_size);
1825             }
1826           tcp_cfg.max_rx_fifo = memory_size;
1827         }
1828       else if (unformat (input, "min-rx-fifo %U", unformat_memory_size,
1829                          &memory_size))
1830         {
1831           if (memory_size >= 0x100000000)
1832             {
1833               return clib_error_return
1834                 (0, "min-rx-fifo %llu (0x%llx) too large", memory_size,
1835                  memory_size);
1836             }
1837           tcp_cfg.min_rx_fifo = memory_size;
1838         }
1839       else if (unformat (input, "mtu %u", &tcp_cfg.default_mtu))
1840         ;
1841       else if (unformat (input, "rwnd-min-update-ack %d",
1842                          &tcp_cfg.rwnd_min_update_ack))
1843         ;
1844       else if (unformat (input, "initial-cwnd-multiplier %u",
1845                          &cwnd_multiplier))
1846         tcp_cfg.initial_cwnd_multiplier = cwnd_multiplier;
1847       else if (unformat (input, "no-tx-pacing"))
1848         tcp_cfg.enable_tx_pacing = 0;
1849       else if (unformat (input, "tso"))
1850         tcp_cfg.allow_tso = 1;
1851       else if (unformat (input, "no-csum-offload"))
1852         tcp_cfg.csum_offload = 0;
1853       else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo,
1854                          &tcp_cfg.cc_algo))
1855         ;
1856       else if (unformat (input, "%U", unformat_tcp_cc_algo_cfg))
1857         ;
1858       else if (unformat (input, "closewait-time %u", &tmp_time))
1859         tcp_cfg.closewait_time = tmp_time / TCP_TIMER_TICK;
1860       else if (unformat (input, "timewait-time %u", &tmp_time))
1861         tcp_cfg.timewait_time = tmp_time / TCP_TIMER_TICK;
1862       else if (unformat (input, "finwait1-time %u", &tmp_time))
1863         tcp_cfg.finwait1_time = tmp_time / TCP_TIMER_TICK;
1864       else if (unformat (input, "finwait2-time %u", &tmp_time))
1865         tcp_cfg.finwait2_time = tmp_time / TCP_TIMER_TICK;
1866       else if (unformat (input, "lastack-time %u", &tmp_time))
1867         tcp_cfg.lastack_time = tmp_time / TCP_TIMER_TICK;
1868       else if (unformat (input, "closing-time %u", &tmp_time))
1869         tcp_cfg.closing_time = tmp_time / TCP_TIMER_TICK;
1870       else if (unformat (input, "cleanup-time %u", &tmp_time))
1871         tcp_cfg.cleanup_time = tmp_time / TCP_TIMER_TICK;
1872       else
1873         return clib_error_return (0, "unknown input `%U'",
1874                                   format_unformat_error, input);
1875     }
1876   return 0;
1877 }
1878
1879 VLIB_CONFIG_FUNCTION (tcp_config_fn, "tcp");
1880
1881
1882 /**
1883  * \brief Configure an ipv4 source address range
1884  * @param vm vlib_main_t pointer
1885  * @param start first ipv4 address in the source address range
1886  * @param end last ipv4 address in the source address range
1887  * @param table_id VRF / table ID, 0 for the default FIB
1888  * @return 0 if all OK, else an error indication from api_errno.h
1889  */
1890
1891 int
1892 tcp_configure_v4_source_address_range (vlib_main_t * vm,
1893                                        ip4_address_t * start,
1894                                        ip4_address_t * end, u32 table_id)
1895 {
1896   u32 start_host_byte_order, end_host_byte_order;
1897   fib_prefix_t prefix;
1898   fib_node_index_t fei;
1899   u32 fib_index = 0;
1900   u32 sw_if_index;
1901   int rv;
1902
1903   clib_memset (&prefix, 0, sizeof (prefix));
1904
1905   fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
1906
1907   if (fib_index == ~0)
1908     return VNET_API_ERROR_NO_SUCH_FIB;
1909
1910   start_host_byte_order = clib_net_to_host_u32 (start->as_u32);
1911   end_host_byte_order = clib_net_to_host_u32 (end->as_u32);
1912
1913   /* sanity check for reversed args or some such */
1914   if ((end_host_byte_order - start_host_byte_order) > (10 << 10))
1915     return VNET_API_ERROR_INVALID_ARGUMENT;
1916
1917   /* Lookup the last address, to identify the interface involved */
1918   prefix.fp_len = 32;
1919   prefix.fp_proto = FIB_PROTOCOL_IP4;
1920   memcpy (&prefix.fp_addr.ip4, end, sizeof (ip4_address_t));
1921
1922   fei = fib_table_lookup (fib_index, &prefix);
1923
1924   /* Couldn't find route to destination. Bail out. */
1925   if (fei == FIB_NODE_INDEX_INVALID)
1926     return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
1927
1928   sw_if_index = fib_entry_get_resolving_interface (fei);
1929
1930   /* Configure proxy arp across the range */
1931   rv = ip4_neighbor_proxy_add (fib_index, start, end);
1932
1933   if (rv)
1934     return rv;
1935
1936   rv = ip4_neighbor_proxy_enable (sw_if_index);
1937
1938   if (rv)
1939     return rv;
1940
1941   do
1942     {
1943       dpo_id_t dpo = DPO_INVALID;
1944
1945       vec_add1 (tcp_cfg.ip4_src_addrs, start[0]);
1946
1947       /* Add local adjacencies for the range */
1948
1949       receive_dpo_add_or_lock (DPO_PROTO_IP4, ~0 /* sw_if_index */ ,
1950                                NULL, &dpo);
1951       prefix.fp_len = 32;
1952       prefix.fp_proto = FIB_PROTOCOL_IP4;
1953       prefix.fp_addr.ip4.as_u32 = start->as_u32;
1954
1955       fib_table_entry_special_dpo_update (fib_index,
1956                                           &prefix,
1957                                           FIB_SOURCE_API,
1958                                           FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
1959       dpo_reset (&dpo);
1960
1961       start_host_byte_order++;
1962       start->as_u32 = clib_host_to_net_u32 (start_host_byte_order);
1963     }
1964   while (start_host_byte_order <= end_host_byte_order);
1965
1966   return 0;
1967 }
1968
1969 /**
1970  * \brief Configure an ipv6 source address range
1971  * @param vm vlib_main_t pointer
1972  * @param start first ipv6 address in the source address range
1973  * @param end last ipv6 address in the source address range
1974  * @param table_id VRF / table ID, 0 for the default FIB
1975  * @return 0 if all OK, else an error indication from api_errno.h
1976  */
1977
1978 int
1979 tcp_configure_v6_source_address_range (vlib_main_t * vm,
1980                                        ip6_address_t * start,
1981                                        ip6_address_t * end, u32 table_id)
1982 {
1983   fib_prefix_t prefix;
1984   u32 fib_index = 0;
1985   fib_node_index_t fei;
1986   u32 sw_if_index;
1987
1988   clib_memset (&prefix, 0, sizeof (prefix));
1989
1990   fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id);
1991
1992   if (fib_index == ~0)
1993     return VNET_API_ERROR_NO_SUCH_FIB;
1994
1995   while (1)
1996     {
1997       int i;
1998       ip6_address_t tmp;
1999       dpo_id_t dpo = DPO_INVALID;
2000
2001       /* Remember this address */
2002       vec_add1 (tcp_cfg.ip6_src_addrs, start[0]);
2003
2004       /* Lookup the prefix, to identify the interface involved */
2005       prefix.fp_len = 128;
2006       prefix.fp_proto = FIB_PROTOCOL_IP6;
2007       memcpy (&prefix.fp_addr.ip6, start, sizeof (ip6_address_t));
2008
2009       fei = fib_table_lookup (fib_index, &prefix);
2010
2011       /* Couldn't find route to destination. Bail out. */
2012       if (fei == FIB_NODE_INDEX_INVALID)
2013         return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
2014
2015       sw_if_index = fib_entry_get_resolving_interface (fei);
2016
2017       if (sw_if_index == (u32) ~ 0)
2018         return VNET_API_ERROR_NO_MATCHING_INTERFACE;
2019
2020       /* Add a proxy neighbor discovery entry for this address */
2021       ip6_neighbor_proxy_add (sw_if_index, start);
2022
2023       /* Add a receive adjacency for this address */
2024       receive_dpo_add_or_lock (DPO_PROTO_IP6, ~0 /* sw_if_index */ ,
2025                                NULL, &dpo);
2026
2027       fib_table_entry_special_dpo_update (fib_index,
2028                                           &prefix,
2029                                           FIB_SOURCE_API,
2030                                           FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
2031       dpo_reset (&dpo);
2032
2033       /* Done with the entire range? */
2034       if (!memcmp (start, end, sizeof (start[0])))
2035         break;
2036
2037       /* Increment the address. DGMS. */
2038       tmp = start[0];
2039       for (i = 15; i >= 0; i--)
2040         {
2041           tmp.as_u8[i] += 1;
2042           if (tmp.as_u8[i] != 0)
2043             break;
2044         }
2045       start[0] = tmp;
2046     }
2047   return 0;
2048 }
2049
2050 static clib_error_t *
2051 tcp_src_address_fn (vlib_main_t * vm,
2052                     unformat_input_t * input, vlib_cli_command_t * cmd_arg)
2053 {
2054   ip4_address_t v4start, v4end;
2055   ip6_address_t v6start, v6end;
2056   u32 table_id = 0;
2057   int v4set = 0;
2058   int v6set = 0;
2059   int rv;
2060
2061   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2062     {
2063       if (unformat (input, "%U - %U", unformat_ip4_address, &v4start,
2064                     unformat_ip4_address, &v4end))
2065         v4set = 1;
2066       else if (unformat (input, "%U", unformat_ip4_address, &v4start))
2067         {
2068           memcpy (&v4end, &v4start, sizeof (v4start));
2069           v4set = 1;
2070         }
2071       else if (unformat (input, "%U - %U", unformat_ip6_address, &v6start,
2072                          unformat_ip6_address, &v6end))
2073         v6set = 1;
2074       else if (unformat (input, "%U", unformat_ip6_address, &v6start))
2075         {
2076           memcpy (&v6end, &v6start, sizeof (v6start));
2077           v6set = 1;
2078         }
2079       else if (unformat (input, "fib-table %d", &table_id))
2080         ;
2081       else
2082         break;
2083     }
2084
2085   if (!v4set && !v6set)
2086     return clib_error_return (0, "at least one v4 or v6 address required");
2087
2088   if (v4set)
2089     {
2090       rv = tcp_configure_v4_source_address_range (vm, &v4start, &v4end,
2091                                                   table_id);
2092       switch (rv)
2093         {
2094         case 0:
2095           break;
2096
2097         case VNET_API_ERROR_NO_SUCH_FIB:
2098           return clib_error_return (0, "Invalid table-id %d", table_id);
2099
2100         case VNET_API_ERROR_INVALID_ARGUMENT:
2101           return clib_error_return (0, "Invalid address range %U - %U",
2102                                     format_ip4_address, &v4start,
2103                                     format_ip4_address, &v4end);
2104         default:
2105           return clib_error_return (0, "error %d", rv);
2106           break;
2107         }
2108     }
2109   if (v6set)
2110     {
2111       rv = tcp_configure_v6_source_address_range (vm, &v6start, &v6end,
2112                                                   table_id);
2113       switch (rv)
2114         {
2115         case 0:
2116           break;
2117
2118         case VNET_API_ERROR_NO_SUCH_FIB:
2119           return clib_error_return (0, "Invalid table-id %d", table_id);
2120
2121         default:
2122           return clib_error_return (0, "error %d", rv);
2123           break;
2124         }
2125     }
2126   return 0;
2127 }
2128
2129 /* *INDENT-OFF* */
2130 VLIB_CLI_COMMAND (tcp_src_address_command, static) =
2131 {
2132   .path = "tcp src-address",
2133   .short_help = "tcp src-address <ip-addr> [- <ip-addr>] add src address range",
2134   .function = tcp_src_address_fn,
2135 };
2136 /* *INDENT-ON* */
2137
2138 static u8 *
2139 tcp_scoreboard_dump_trace (u8 * s, sack_scoreboard_t * sb)
2140 {
2141 #if TCP_SCOREBOARD_TRACE
2142
2143   scoreboard_trace_elt_t *block;
2144   int i = 0;
2145
2146   if (!sb->trace)
2147     return s;
2148
2149   s = format (s, "scoreboard trace:");
2150   vec_foreach (block, sb->trace)
2151   {
2152     s = format (s, "{%u, %u, %u, %u, %u}, ", block->start, block->end,
2153                 block->ack, block->snd_una_max, block->group);
2154     if ((++i % 3) == 0)
2155       s = format (s, "\n");
2156   }
2157   return s;
2158 #else
2159   return 0;
2160 #endif
2161 }
2162
2163 static clib_error_t *
2164 tcp_show_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input,
2165                               vlib_cli_command_t * cmd_arg)
2166 {
2167   transport_connection_t *tconn = 0;
2168   tcp_connection_t *tc;
2169   u8 *s = 0;
2170   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2171     {
2172       if (unformat (input, "%U", unformat_transport_connection, &tconn,
2173                     TRANSPORT_PROTO_TCP))
2174         ;
2175       else
2176         return clib_error_return (0, "unknown input `%U'",
2177                                   format_unformat_error, input);
2178     }
2179
2180   if (!TCP_SCOREBOARD_TRACE)
2181     {
2182       vlib_cli_output (vm, "scoreboard tracing not enabled");
2183       return 0;
2184     }
2185
2186   tc = tcp_get_connection_from_transport (tconn);
2187   s = tcp_scoreboard_dump_trace (s, &tc->sack_sb);
2188   vlib_cli_output (vm, "%v", s);
2189   return 0;
2190 }
2191
2192 /* *INDENT-OFF* */
2193 VLIB_CLI_COMMAND (tcp_show_scoreboard_trace_command, static) =
2194 {
2195   .path = "show tcp scoreboard trace",
2196   .short_help = "show tcp scoreboard trace <connection>",
2197   .function = tcp_show_scoreboard_trace_fn,
2198 };
2199 /* *INDENT-ON* */
2200
2201 u8 *
2202 tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose)
2203 {
2204   int i, trace_len;
2205   scoreboard_trace_elt_t *trace;
2206   u32 next_ack, left, group, has_new_ack = 0;
2207   tcp_connection_t _dummy_tc, *dummy_tc = &_dummy_tc;
2208   sack_block_t *block;
2209
2210   if (!TCP_SCOREBOARD_TRACE)
2211     {
2212       s = format (s, "scoreboard tracing not enabled");
2213       return s;
2214     }
2215
2216   if (!tc)
2217     return s;
2218
2219   clib_memset (dummy_tc, 0, sizeof (*dummy_tc));
2220   tcp_connection_timers_init (dummy_tc);
2221   scoreboard_init (&dummy_tc->sack_sb);
2222   dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
2223
2224 #if TCP_SCOREBOARD_TRACE
2225   trace = tc->sack_sb.trace;
2226   trace_len = vec_len (tc->sack_sb.trace);
2227 #endif
2228
2229   for (i = 0; i < trace_len; i++)
2230     {
2231       if (trace[i].ack != 0)
2232         {
2233           dummy_tc->snd_una = trace[i].ack - 1448;
2234           dummy_tc->snd_una_max = trace[i].ack;
2235         }
2236     }
2237
2238   left = 0;
2239   while (left < trace_len)
2240     {
2241       group = trace[left].group;
2242       vec_reset_length (dummy_tc->rcv_opts.sacks);
2243       has_new_ack = 0;
2244       while (trace[left].group == group)
2245         {
2246           if (trace[left].ack != 0)
2247             {
2248               if (verbose)
2249                 s = format (s, "Adding ack %u, snd_una_max %u, segs: ",
2250                             trace[left].ack, trace[left].snd_una_max);
2251               dummy_tc->snd_una_max = trace[left].snd_una_max;
2252               next_ack = trace[left].ack;
2253               has_new_ack = 1;
2254             }
2255           else
2256             {
2257               if (verbose)
2258                 s = format (s, "[%u, %u], ", trace[left].start,
2259                             trace[left].end);
2260               vec_add2 (dummy_tc->rcv_opts.sacks, block, 1);
2261               block->start = trace[left].start;
2262               block->end = trace[left].end;
2263             }
2264           left++;
2265         }
2266
2267       /* Push segments */
2268       tcp_rcv_sacks (dummy_tc, next_ack);
2269       if (has_new_ack)
2270         dummy_tc->snd_una = next_ack;
2271
2272       if (verbose)
2273         s = format (s, "result: %U", format_tcp_scoreboard,
2274                     &dummy_tc->sack_sb);
2275
2276     }
2277   s = format (s, "result: %U", format_tcp_scoreboard, &dummy_tc->sack_sb);
2278
2279   return s;
2280 }
2281
2282 static clib_error_t *
2283 tcp_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input,
2284                          vlib_cli_command_t * cmd_arg)
2285 {
2286   transport_connection_t *tconn = 0;
2287   tcp_connection_t *tc = 0;
2288   u8 *str = 0;
2289   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2290     {
2291       if (unformat (input, "%U", unformat_transport_connection, &tconn,
2292                     TRANSPORT_PROTO_TCP))
2293         ;
2294       else
2295         return clib_error_return (0, "unknown input `%U'",
2296                                   format_unformat_error, input);
2297     }
2298
2299   if (!TCP_SCOREBOARD_TRACE)
2300     {
2301       vlib_cli_output (vm, "scoreboard tracing not enabled");
2302       return 0;
2303     }
2304
2305   tc = tcp_get_connection_from_transport (tconn);
2306   if (!tc)
2307     {
2308       vlib_cli_output (vm, "connection not found");
2309       return 0;
2310     }
2311   str = tcp_scoreboard_replay (str, tc, 1);
2312   vlib_cli_output (vm, "%v", str);
2313   return 0;
2314 }
2315
2316 /* *INDENT-OFF* */
2317 VLIB_CLI_COMMAND (tcp_replay_scoreboard_command, static) =
2318 {
2319   .path = "tcp replay scoreboard",
2320   .short_help = "tcp replay scoreboard <connection>",
2321   .function = tcp_scoreboard_trace_fn,
2322 };
2323 /* *INDENT-ON* */
2324
2325 static clib_error_t *
2326 show_tcp_punt_fn (vlib_main_t * vm, unformat_input_t * input,
2327                   vlib_cli_command_t * cmd_arg)
2328 {
2329   tcp_main_t *tm = vnet_get_tcp_main ();
2330   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2331     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
2332                               input);
2333   vlib_cli_output (vm, "IPv4 TCP punt: %s",
2334                    tm->punt_unknown4 ? "enabled" : "disabled");
2335   vlib_cli_output (vm, "IPv6 TCP punt: %s",
2336                    tm->punt_unknown6 ? "enabled" : "disabled");
2337   return 0;
2338 }
2339 /* *INDENT-OFF* */
2340 VLIB_CLI_COMMAND (show_tcp_punt_command, static) =
2341 {
2342   .path = "show tcp punt",
2343   .short_help = "show tcp punt",
2344   .function = show_tcp_punt_fn,
2345 };
2346 /* *INDENT-ON* */
2347
2348 static clib_error_t *
2349 show_tcp_stats_fn (vlib_main_t * vm, unformat_input_t * input,
2350                    vlib_cli_command_t * cmd)
2351 {
2352   tcp_main_t *tm = vnet_get_tcp_main ();
2353   tcp_worker_ctx_t *wrk;
2354   u32 thread;
2355
2356   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2357     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
2358                               input);
2359   for (thread = 0; thread < vec_len (tm->wrk_ctx); thread++)
2360     {
2361       wrk = tcp_get_worker (thread);
2362       vlib_cli_output (vm, "Thread %u:\n", thread);
2363
2364       if (clib_fifo_elts (wrk->pending_timers))
2365         vlib_cli_output (vm, " %lu pending timers",
2366                          clib_fifo_elts (wrk->pending_timers));
2367
2368 #define _(name,type,str)                                        \
2369   if (wrk->stats.name)                                          \
2370     vlib_cli_output (vm, " %lu %s", wrk->stats.name, str);
2371       foreach_tcp_wrk_stat
2372 #undef _
2373     }
2374
2375   return 0;
2376 }
2377
2378 /* *INDENT-OFF* */
2379 VLIB_CLI_COMMAND (show_tcp_stats_command, static) =
2380 {
2381   .path = "show tcp stats",
2382   .short_help = "show tcp stats",
2383   .function = show_tcp_stats_fn,
2384 };
2385 /* *INDENT-ON* */
2386
2387 static clib_error_t *
2388 clear_tcp_stats_fn (vlib_main_t * vm, unformat_input_t * input,
2389                     vlib_cli_command_t * cmd)
2390 {
2391   tcp_main_t *tm = vnet_get_tcp_main ();
2392   tcp_worker_ctx_t *wrk;
2393   u32 thread;
2394
2395   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
2396     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
2397                               input);
2398
2399   for (thread = 0; thread < vec_len (tm->wrk_ctx); thread++)
2400     {
2401       wrk = tcp_get_worker (thread);
2402       clib_memset (&wrk->stats, 0, sizeof (wrk->stats));
2403     }
2404
2405   return 0;
2406 }
2407
2408 /* *INDENT-OFF* */
2409 VLIB_CLI_COMMAND (clear_tcp_stats_command, static) =
2410 {
2411   .path = "clear tcp stats",
2412   .short_help = "clear tcp stats",
2413   .function = clear_tcp_stats_fn,
2414 };
2415 /* *INDENT-ON* */
2416
2417 /*
2418  * fd.io coding-style-patch-verification: ON
2419  *
2420  * Local Variables:
2421  * eval: (c-set-style "gnu")
2422  * End:
2423  */