src/vnet/tcp/tcp_cli.c

   1 /*
   2  * Copyright (c) 2020 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 #include <vnet/tcp/tcp.h>
  17 #include <vnet/tcp/tcp_inlines.h>
  18 #include <vnet/dpo/receive_dpo.h>
  19 #include <vnet/ip-neighbor/ip_neighbor.h>
  20
  21 const char *tcp_fsm_states[] = {
  22 #define _(sym, str) str,
  23   foreach_tcp_fsm_state
  24 #undef _
  25 };
  26
  27 u8 *
  28 format_tcp_state (u8 * s, va_list * args)
  29 {
  30   u32 state = va_arg (*args, u32);
  31
  32   if (state < TCP_N_STATES)
  33     s = format (s, "%s", tcp_fsm_states[state]);
  34   else
  35     s = format (s, "UNKNOWN (%d (0x%x))", state, state);
  36   return s;
  37 }
  38
  39 const char *tcp_cfg_flags_str[] = {
  40 #define _(sym, str) str,
  41   foreach_tcp_cfg_flag
  42 #undef _
  43 };
  44
  45 static u8 *
  46 format_tcp_cfg_flags (u8 * s, va_list * args)
  47 {
  48   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
  49   int i, last = -1;
  50
  51   for (i = 0; i < TCP_CFG_N_FLAG_BITS; i++)
  52     if (tc->cfg_flags & (1 << i))
  53       last = i;
  54   for (i = 0; i < last; i++)
  55     {
  56       if (tc->cfg_flags & (1 << i))
  57         s = format (s, "%s, ", tcp_cfg_flags_str[i]);
  58     }
  59   if (last >= 0)
  60     s = format (s, "%s", tcp_cfg_flags_str[last]);
  61   return s;
  62 }
  63
  64 const char *tcp_connection_flags_str[] = {
  65 #define _(sym, str) str,
  66   foreach_tcp_connection_flag
  67 #undef _
  68 };
  69
  70 static u8 *
  71 format_tcp_connection_flags (u8 * s, va_list * args)
  72 {
  73   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
  74   int i, last = -1;
  75
  76   for (i = 0; i < TCP_CONN_N_FLAG_BITS; i++)
  77     if (tc->flags & (1 << i))
  78       last = i;
  79   for (i = 0; i < last; i++)
  80     {
  81       if (tc->flags & (1 << i))
  82         s = format (s, "%s, ", tcp_connection_flags_str[i]);
  83     }
  84   if (last >= 0)
  85     s = format (s, "%s", tcp_connection_flags_str[last]);
  86   return s;
  87 }
  88
  89 const char *tcp_conn_timers[] = {
  90 #define _(sym, str) str,
  91   foreach_tcp_timer
  92 #undef _
  93 };
  94
  95 static u8 *
  96 format_tcp_timers (u8 * s, va_list * args)
  97 {
  98   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
  99   int i, last = -1;
 100
 101   for (i = 0; i < TCP_N_TIMERS; i++)
 102     if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
 103       last = i;
 104
 105   for (i = 0; i < last; i++)
 106     {
 107       if (tc->timers[i] != TCP_TIMER_HANDLE_INVALID)
 108         s = format (s, "%s,", tcp_conn_timers[i]);
 109     }
 110
 111   if (last >= 0)
 112     s = format (s, "%s", tcp_conn_timers[i]);
 113
 114   return s;
 115 }
 116
 117 static u8 *
 118 format_tcp_congestion_status (u8 * s, va_list * args)
 119 {
 120   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 121   if (tcp_in_recovery (tc))
 122     s = format (s, "recovery");
 123   else if (tcp_in_fastrecovery (tc))
 124     s = format (s, "fastrecovery");
 125   else
 126     s = format (s, "none");
 127   return s;
 128 }
 129
 130 static i32
 131 tcp_rcv_wnd_available (tcp_connection_t * tc)
 132 {
 133   return (i32) tc->rcv_wnd - (tc->rcv_nxt - tc->rcv_las);
 134 }
 135
 136 static u8 *
 137 format_tcp_congestion (u8 * s, va_list * args)
 138 {
 139   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 140   u32 indent = format_get_indent (s), prr_space = 0;
 141
 142   s = format (s, "%U ", format_tcp_congestion_status, tc);
 143   s = format (s, "algo %s cwnd %u ssthresh %u bytes_acked %u\n",
 144               tc->cc_algo->name, tc->cwnd, tc->ssthresh, tc->bytes_acked);
 145   s = format (s, "%Ucc space %u prev_cwnd %u prev_ssthresh %u\n",
 146               format_white_space, indent, tcp_available_cc_snd_space (tc),
 147               tc->prev_cwnd, tc->prev_ssthresh);
 148   s = format (s, "%Usnd_cong %u dupack %u limited_tx %u\n",
 149               format_white_space, indent, tc->snd_congestion - tc->iss,
 150               tc->rcv_dupacks, tc->limited_transmit - tc->iss);
 151   s = format (s, "%Urxt_bytes %u rxt_delivered %u rxt_head %u rxt_ts %u\n",
 152               format_white_space, indent, tc->snd_rxt_bytes,
 153               tc->rxt_delivered, tc->rxt_head - tc->iss,
 154               tcp_time_now_w_thread (tc->c_thread_index) - tc->snd_rxt_ts);
 155   if (tcp_in_fastrecovery (tc))
 156     prr_space = tcp_fastrecovery_prr_snd_space (tc);
 157   s = format (s, "%Uprr_start %u prr_delivered %u prr space %u\n",
 158               format_white_space, indent, tc->prr_start - tc->iss,
 159               tc->prr_delivered, prr_space);
 160   return s;
 161 }
 162
 163 static u8 *
 164 format_tcp_stats (u8 * s, va_list * args)
 165 {
 166   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 167   u32 indent = format_get_indent (s);
 168   s = format (s, "in segs %lu dsegs %lu bytes %lu dupacks %u\n",
 169               tc->segs_in, tc->data_segs_in, tc->bytes_in, tc->dupacks_in);
 170   s = format (s, "%Uout segs %lu dsegs %lu bytes %lu dupacks %u\n",
 171               format_white_space, indent, tc->segs_out,
 172               tc->data_segs_out, tc->bytes_out, tc->dupacks_out);
 173   s = format (s, "%Ufr %u tr %u rxt segs %lu bytes %lu duration %.3f\n",
 174               format_white_space, indent, tc->fr_occurences,
 175               tc->tr_occurences, tc->segs_retrans, tc->bytes_retrans,
 176               tcp_time_now_us (tc->c_thread_index) - tc->start_ts);
 177   s = format (s, "%Uerr wnd data below %u above %u ack below %u above %u",
 178               format_white_space, indent, tc->errors.below_data_wnd,
 179               tc->errors.above_data_wnd, tc->errors.below_ack_wnd,
 180               tc->errors.above_ack_wnd);
 181   return s;
 182 }
 183
 184 static u8 *
 185 format_tcp_vars (u8 * s, va_list * args)
 186 {
 187   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 188   s = format (s, " index: %u cfg: %U flags: %U timers: %U\n", tc->c_c_index,
 189               format_tcp_cfg_flags, tc, format_tcp_connection_flags, tc,
 190               format_tcp_timers, tc);
 191   s = format (s, " snd_una %u snd_nxt %u snd_una_max %u",
 192               tc->snd_una - tc->iss, tc->snd_nxt - tc->iss,
 193               tc->snd_una_max - tc->iss);
 194   s = format (s, " rcv_nxt %u rcv_las %u\n",
 195               tc->rcv_nxt - tc->irs, tc->rcv_las - tc->irs);
 196   s = format (s, " snd_wnd %u rcv_wnd %u rcv_wscale %u ",
 197               tc->snd_wnd, tc->rcv_wnd, tc->rcv_wscale);
 198   s = format (s, "snd_wl1 %u snd_wl2 %u\n", tc->snd_wl1 - tc->irs,
 199               tc->snd_wl2 - tc->iss);
 200   s = format (s, " flight size %u out space %u rcv_wnd_av %u",
 201               tcp_flight_size (tc), tcp_available_output_snd_space (tc),
 202               tcp_rcv_wnd_available (tc));
 203   s = format (s, " tsval_recent %u\n", tc->tsval_recent);
 204   s = format (s, " tsecr %u tsecr_last_ack %u tsval_recent_age %u",
 205               tc->rcv_opts.tsecr, tc->tsecr_last_ack,
 206               tcp_time_now () - tc->tsval_recent_age);
 207   s = format (s, " snd_mss %u\n", tc->snd_mss);
 208   s = format (s, " rto %u rto_boff %u srtt %.1f us %.3f rttvar %.1f",
 209               tc->rto / 1000, tc->rto_boff, tc->srtt / 1000.0,
 210               tc->mrtt_us * 1e3, tc->rttvar / 1000.0);
 211   s = format (s, " rtt_ts %.4f rtt_seq %u\n", tc->rtt_ts,
 212               tc->rtt_seq - tc->iss);
 213   s = format (s, " next_node %u opaque 0x%x fib_index %u\n",
 214               tc->next_node_index, tc->next_node_opaque, tc->c_fib_index);
 215   s = format (s, " cong:   %U", format_tcp_congestion, tc);
 216
 217   if (tc->state >= TCP_STATE_ESTABLISHED)
 218     {
 219       s = format (s, " sboard: %U\n", format_tcp_scoreboard, &tc->sack_sb,
 220                   tc);
 221       s = format (s, " stats: %U\n", format_tcp_stats, tc);
 222     }
 223   if (vec_len (tc->snd_sacks))
 224     s = format (s, " sacks tx: %U\n", format_tcp_sacks, tc);
 225
 226   return s;
 227 }
 228
 229 u8 *
 230 format_tcp_connection_id (u8 * s, va_list * args)
 231 {
 232   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 233   if (!tc)
 234     return s;
 235   if (tc->c_is_ip4)
 236     {
 237       s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index,
 238                   tc->c_s_index, "T", format_ip4_address, &tc->c_lcl_ip4,
 239                   clib_net_to_host_u16 (tc->c_lcl_port), format_ip4_address,
 240                   &tc->c_rmt_ip4, clib_net_to_host_u16 (tc->c_rmt_port));
 241     }
 242   else
 243     {
 244       s = format (s, "[%d:%d][%s] %U:%d->%U:%d", tc->c_thread_index,
 245                   tc->c_s_index, "T", format_ip6_address, &tc->c_lcl_ip6,
 246                   clib_net_to_host_u16 (tc->c_lcl_port), format_ip6_address,
 247                   &tc->c_rmt_ip6, clib_net_to_host_u16 (tc->c_rmt_port));
 248     }
 249
 250   return s;
 251 }
 252
 253 u8 *
 254 format_tcp_connection (u8 * s, va_list * args)
 255 {
 256   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 257   u32 verbose = va_arg (*args, u32);
 258
 259   if (!tc)
 260     return s;
 261   s = format (s, "%-50U", format_tcp_connection_id, tc);
 262   if (verbose)
 263     {
 264       s = format (s, "%-15U", format_tcp_state, tc->state);
 265       if (verbose > 1)
 266         s = format (s, "\n%U", format_tcp_vars, tc);
 267     }
 268
 269   return s;
 270 }
 271
 272 u8 *
 273 format_tcp_sacks (u8 * s, va_list * args)
 274 {
 275   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 276   sack_block_t *sacks = tc->snd_sacks;
 277   sack_block_t *block;
 278   int i, len = 0;
 279
 280   len = vec_len (sacks);
 281   for (i = 0; i < len - 1; i++)
 282     {
 283       block = &sacks[i];
 284       s = format (s, " start %u end %u\n", block->start - tc->irs,
 285                   block->end - tc->irs);
 286     }
 287   if (len)
 288     {
 289       block = &sacks[len - 1];
 290       s = format (s, " start %u end %u", block->start - tc->irs,
 291                   block->end - tc->irs);
 292     }
 293   return s;
 294 }
 295
 296 u8 *
 297 format_tcp_rcv_sacks (u8 * s, va_list * args)
 298 {
 299   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 300   sack_block_t *sacks = tc->rcv_opts.sacks;
 301   sack_block_t *block;
 302   int i, len = 0;
 303
 304   len = vec_len (sacks);
 305   for (i = 0; i < len - 1; i++)
 306     {
 307       block = &sacks[i];
 308       s = format (s, " start %u end %u\n", block->start - tc->iss,
 309                   block->end - tc->iss);
 310     }
 311   if (len)
 312     {
 313       block = &sacks[len - 1];
 314       s = format (s, " start %u end %u", block->start - tc->iss,
 315                   block->end - tc->iss);
 316     }
 317   return s;
 318 }
 319
 320 static u8 *
 321 format_tcp_sack_hole (u8 * s, va_list * args)
 322 {
 323   sack_scoreboard_hole_t *hole = va_arg (*args, sack_scoreboard_hole_t *);
 324   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 325   if (tc)
 326     s = format (s, "  [%u, %u]", hole->start - tc->iss, hole->end - tc->iss);
 327   else
 328     s = format (s, "  [%u, %u]", hole->start, hole->end);
 329   return s;
 330 }
 331
 332 u8 *
 333 format_tcp_scoreboard (u8 * s, va_list * args)
 334 {
 335   sack_scoreboard_t *sb = va_arg (*args, sack_scoreboard_t *);
 336   tcp_connection_t *tc = va_arg (*args, tcp_connection_t *);
 337   sack_scoreboard_hole_t *hole;
 338   u32 indent = format_get_indent (s);
 339
 340   s = format (s, "sacked %u last_sacked %u lost %u last_lost %u"
 341               " rxt_sacked %u\n",
 342               sb->sacked_bytes, sb->last_sacked_bytes, sb->lost_bytes,
 343               sb->last_lost_bytes, sb->rxt_sacked);
 344   s = format (s, "%Ulast_delivered %u high_sacked %u is_reneging %u\n",
 345               format_white_space, indent, sb->last_bytes_delivered,
 346               sb->high_sacked - tc->iss, sb->is_reneging);
 347   s = format (s, "%Ucur_rxt_hole %u high_rxt %u rescue_rxt %u",
 348               format_white_space, indent, sb->cur_rxt_hole,
 349               sb->high_rxt - tc->iss, sb->rescue_rxt - tc->iss);
 350
 351   hole = scoreboard_first_hole (sb);
 352   if (hole)
 353     s = format (s, "\n%Uhead %u tail %u %u holes:\n%U", format_white_space,
 354                 indent, sb->head, sb->tail, pool_elts (sb->holes),
 355                 format_white_space, indent);
 356
 357   while (hole)
 358     {
 359       s = format (s, "%U", format_tcp_sack_hole, hole, tc);
 360       hole = scoreboard_next_hole (sb, hole);
 361     }
 362
 363   return s;
 364 }
 365
 366 /**
 367  * \brief Configure an ipv4 source address range
 368  * @param vm vlib_main_t pointer
 369  * @param start first ipv4 address in the source address range
 370  * @param end last ipv4 address in the source address range
 371  * @param table_id VRF / table ID, 0 for the default FIB
 372  * @return 0 if all OK, else an error indication from api_errno.h
 373  */
 374
 375 int
 376 tcp_configure_v4_source_address_range (vlib_main_t * vm,
 377                                        ip4_address_t * start,
 378                                        ip4_address_t * end, u32 table_id)
 379 {
 380   u32 start_host_byte_order, end_host_byte_order;
 381   fib_prefix_t prefix;
 382   fib_node_index_t fei;
 383   u32 fib_index = 0;
 384   u32 sw_if_index;
 385   int rv;
 386
 387   clib_memset (&prefix, 0, sizeof (prefix));
 388
 389   fib_index = fib_table_find (FIB_PROTOCOL_IP4, table_id);
 390
 391   if (fib_index == ~0)
 392     return VNET_API_ERROR_NO_SUCH_FIB;
 393
 394   start_host_byte_order = clib_net_to_host_u32 (start->as_u32);
 395   end_host_byte_order = clib_net_to_host_u32 (end->as_u32);
 396
 397   /* sanity check for reversed args or some such */
 398   if ((end_host_byte_order - start_host_byte_order) > (10 << 10))
 399     return VNET_API_ERROR_INVALID_ARGUMENT;
 400
 401   /* Lookup the last address, to identify the interface involved */
 402   prefix.fp_len = 32;
 403   prefix.fp_proto = FIB_PROTOCOL_IP4;
 404   memcpy (&prefix.fp_addr.ip4, end, sizeof (ip4_address_t));
 405
 406   fei = fib_table_lookup (fib_index, &prefix);
 407
 408   /* Couldn't find route to destination. Bail out. */
 409   if (fei == FIB_NODE_INDEX_INVALID)
 410     return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
 411
 412   sw_if_index = fib_entry_get_resolving_interface (fei);
 413
 414   /* Configure proxy arp across the range */
 415   rv = ip4_neighbor_proxy_add (fib_index, start, end);
 416
 417   if (rv)
 418     return rv;
 419
 420   rv = ip4_neighbor_proxy_enable (sw_if_index);
 421
 422   if (rv)
 423     return rv;
 424
 425   do
 426     {
 427       dpo_id_t dpo = DPO_INVALID;
 428
 429       vec_add1 (tcp_cfg.ip4_src_addrs, start[0]);
 430
 431       /* Add local adjacencies for the range */
 432
 433       receive_dpo_add_or_lock (DPO_PROTO_IP4, ~0 /* sw_if_index */ ,
 434                                NULL, &dpo);
 435       prefix.fp_len = 32;
 436       prefix.fp_proto = FIB_PROTOCOL_IP4;
 437       prefix.fp_addr.ip4.as_u32 = start->as_u32;
 438
 439       fib_table_entry_special_dpo_update (fib_index,
 440                                           &prefix,
 441                                           FIB_SOURCE_API,
 442                                           FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
 443       dpo_reset (&dpo);
 444
 445       start_host_byte_order++;
 446       start->as_u32 = clib_host_to_net_u32 (start_host_byte_order);
 447     }
 448   while (start_host_byte_order <= end_host_byte_order);
 449
 450   return 0;
 451 }
 452
 453 /**
 454  * \brief Configure an ipv6 source address range
 455  * @param vm vlib_main_t pointer
 456  * @param start first ipv6 address in the source address range
 457  * @param end last ipv6 address in the source address range
 458  * @param table_id VRF / table ID, 0 for the default FIB
 459  * @return 0 if all OK, else an error indication from api_errno.h
 460  */
 461
 462 int
 463 tcp_configure_v6_source_address_range (vlib_main_t * vm,
 464                                        ip6_address_t * start,
 465                                        ip6_address_t * end, u32 table_id)
 466 {
 467   fib_prefix_t prefix;
 468   u32 fib_index = 0;
 469   fib_node_index_t fei;
 470   u32 sw_if_index;
 471
 472   clib_memset (&prefix, 0, sizeof (prefix));
 473
 474   fib_index = fib_table_find (FIB_PROTOCOL_IP6, table_id);
 475
 476   if (fib_index == ~0)
 477     return VNET_API_ERROR_NO_SUCH_FIB;
 478
 479   while (1)
 480     {
 481       int i;
 482       ip6_address_t tmp;
 483       dpo_id_t dpo = DPO_INVALID;
 484
 485       /* Remember this address */
 486       vec_add1 (tcp_cfg.ip6_src_addrs, start[0]);
 487
 488       /* Lookup the prefix, to identify the interface involved */
 489       prefix.fp_len = 128;
 490       prefix.fp_proto = FIB_PROTOCOL_IP6;
 491       memcpy (&prefix.fp_addr.ip6, start, sizeof (ip6_address_t));
 492
 493       fei = fib_table_lookup (fib_index, &prefix);
 494
 495       /* Couldn't find route to destination. Bail out. */
 496       if (fei == FIB_NODE_INDEX_INVALID)
 497         return VNET_API_ERROR_NEXT_HOP_NOT_IN_FIB;
 498
 499       sw_if_index = fib_entry_get_resolving_interface (fei);
 500
 501       if (sw_if_index == (u32) ~ 0)
 502         return VNET_API_ERROR_NO_MATCHING_INTERFACE;
 503
 504       /* Add a proxy neighbor discovery entry for this address */
 505       ip6_neighbor_proxy_add (sw_if_index, start);
 506
 507       /* Add a receive adjacency for this address */
 508       receive_dpo_add_or_lock (DPO_PROTO_IP6, ~0 /* sw_if_index */ ,
 509                                NULL, &dpo);
 510
 511       fib_table_entry_special_dpo_update (fib_index,
 512                                           &prefix,
 513                                           FIB_SOURCE_API,
 514                                           FIB_ENTRY_FLAG_EXCLUSIVE, &dpo);
 515       dpo_reset (&dpo);
 516
 517       /* Done with the entire range? */
 518       if (!memcmp (start, end, sizeof (start[0])))
 519         break;
 520
 521       /* Increment the address. DGMS. */
 522       tmp = start[0];
 523       for (i = 15; i >= 0; i--)
 524         {
 525           tmp.as_u8[i] += 1;
 526           if (tmp.as_u8[i] != 0)
 527             break;
 528         }
 529       start[0] = tmp;
 530     }
 531   return 0;
 532 }
 533
 534 static clib_error_t *
 535 tcp_src_address_fn (vlib_main_t * vm,
 536                     unformat_input_t * input, vlib_cli_command_t * cmd_arg)
 537 {
 538   ip4_address_t v4start, v4end;
 539   ip6_address_t v6start, v6end;
 540   u32 table_id = 0;
 541   int v4set = 0;
 542   int v6set = 0;
 543   int rv;
 544
 545   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 546     {
 547       if (unformat (input, "%U - %U", unformat_ip4_address, &v4start,
 548                     unformat_ip4_address, &v4end))
 549         v4set = 1;
 550       else if (unformat (input, "%U", unformat_ip4_address, &v4start))
 551         {
 552           memcpy (&v4end, &v4start, sizeof (v4start));
 553           v4set = 1;
 554         }
 555       else if (unformat (input, "%U - %U", unformat_ip6_address, &v6start,
 556                          unformat_ip6_address, &v6end))
 557         v6set = 1;
 558       else if (unformat (input, "%U", unformat_ip6_address, &v6start))
 559         {
 560           memcpy (&v6end, &v6start, sizeof (v6start));
 561           v6set = 1;
 562         }
 563       else if (unformat (input, "fib-table %d", &table_id))
 564         ;
 565       else
 566         break;
 567     }
 568
 569   if (!v4set && !v6set)
 570     return clib_error_return (0, "at least one v4 or v6 address required");
 571
 572   if (v4set)
 573     {
 574       rv = tcp_configure_v4_source_address_range (vm, &v4start, &v4end,
 575                                                   table_id);
 576       switch (rv)
 577         {
 578         case 0:
 579           break;
 580
 581         case VNET_API_ERROR_NO_SUCH_FIB:
 582           return clib_error_return (0, "Invalid table-id %d", table_id);
 583
 584         case VNET_API_ERROR_INVALID_ARGUMENT:
 585           return clib_error_return (0, "Invalid address range %U - %U",
 586                                     format_ip4_address, &v4start,
 587                                     format_ip4_address, &v4end);
 588         default:
 589           return clib_error_return (0, "error %d", rv);
 590           break;
 591         }
 592     }
 593   if (v6set)
 594     {
 595       rv = tcp_configure_v6_source_address_range (vm, &v6start, &v6end,
 596                                                   table_id);
 597       switch (rv)
 598         {
 599         case 0:
 600           break;
 601
 602         case VNET_API_ERROR_NO_SUCH_FIB:
 603           return clib_error_return (0, "Invalid table-id %d", table_id);
 604
 605         default:
 606           return clib_error_return (0, "error %d", rv);
 607           break;
 608         }
 609     }
 610   return 0;
 611 }
 612
 613 /* *INDENT-OFF* */
 614 VLIB_CLI_COMMAND (tcp_src_address_command, static) =
 615 {
 616   .path = "tcp src-address",
 617   .short_help = "tcp src-address <ip-addr> [- <ip-addr>] add src address range",
 618   .function = tcp_src_address_fn,
 619 };
 620 /* *INDENT-ON* */
 621
 622 static u8 *
 623 tcp_scoreboard_dump_trace (u8 * s, sack_scoreboard_t * sb)
 624 {
 625 #if TCP_SCOREBOARD_TRACE
 626
 627   scoreboard_trace_elt_t *block;
 628   int i = 0;
 629
 630   if (!sb->trace)
 631     return s;
 632
 633   s = format (s, "scoreboard trace:");
 634   vec_foreach (block, sb->trace)
 635   {
 636     s = format (s, "{%u, %u, %u, %u, %u}, ", block->start, block->end,
 637                 block->ack, block->snd_una_max, block->group);
 638     if ((++i % 3) == 0)
 639       s = format (s, "\n");
 640   }
 641   return s;
 642 #else
 643   return 0;
 644 #endif
 645 }
 646
 647 static clib_error_t *
 648 tcp_show_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input,
 649                               vlib_cli_command_t * cmd_arg)
 650 {
 651   transport_connection_t *tconn = 0;
 652   tcp_connection_t *tc;
 653   u8 *s = 0;
 654   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 655     {
 656       if (unformat (input, "%U", unformat_transport_connection, &tconn,
 657                     TRANSPORT_PROTO_TCP))
 658         ;
 659       else
 660         return clib_error_return (0, "unknown input `%U'",
 661                                   format_unformat_error, input);
 662     }
 663
 664   if (!TCP_SCOREBOARD_TRACE)
 665     {
 666       vlib_cli_output (vm, "scoreboard tracing not enabled");
 667       return 0;
 668     }
 669
 670   tc = tcp_get_connection_from_transport (tconn);
 671   s = tcp_scoreboard_dump_trace (s, &tc->sack_sb);
 672   vlib_cli_output (vm, "%v", s);
 673   return 0;
 674 }
 675
 676 /* *INDENT-OFF* */
 677 VLIB_CLI_COMMAND (tcp_show_scoreboard_trace_command, static) =
 678 {
 679   .path = "show tcp scoreboard trace",
 680   .short_help = "show tcp scoreboard trace <connection>",
 681   .function = tcp_show_scoreboard_trace_fn,
 682 };
 683 /* *INDENT-ON* */
 684
 685 u8 *
 686 tcp_scoreboard_replay (u8 * s, tcp_connection_t * tc, u8 verbose)
 687 {
 688   int i, trace_len;
 689   scoreboard_trace_elt_t *trace;
 690   u32 next_ack, left, group, has_new_ack = 0;
 691   tcp_connection_t _dummy_tc, *dummy_tc = &_dummy_tc;
 692   sack_block_t *block;
 693
 694   if (!TCP_SCOREBOARD_TRACE)
 695     {
 696       s = format (s, "scoreboard tracing not enabled");
 697       return s;
 698     }
 699
 700   if (!tc)
 701     return s;
 702
 703   clib_memset (dummy_tc, 0, sizeof (*dummy_tc));
 704   tcp_connection_timers_init (dummy_tc);
 705   scoreboard_init (&dummy_tc->sack_sb);
 706   dummy_tc->rcv_opts.flags |= TCP_OPTS_FLAG_SACK;
 707
 708 #if TCP_SCOREBOARD_TRACE
 709   trace = tc->sack_sb.trace;
 710   trace_len = vec_len (tc->sack_sb.trace);
 711 #endif
 712
 713   for (i = 0; i < trace_len; i++)
 714     {
 715       if (trace[i].ack != 0)
 716         {
 717           dummy_tc->snd_una = trace[i].ack - 1448;
 718           dummy_tc->snd_una_max = trace[i].ack;
 719         }
 720     }
 721
 722   left = 0;
 723   while (left < trace_len)
 724     {
 725       group = trace[left].group;
 726       vec_reset_length (dummy_tc->rcv_opts.sacks);
 727       has_new_ack = 0;
 728       while (trace[left].group == group)
 729         {
 730           if (trace[left].ack != 0)
 731             {
 732               if (verbose)
 733                 s = format (s, "Adding ack %u, snd_una_max %u, segs: ",
 734                             trace[left].ack, trace[left].snd_una_max);
 735               dummy_tc->snd_una_max = trace[left].snd_una_max;
 736               next_ack = trace[left].ack;
 737               has_new_ack = 1;
 738             }
 739           else
 740             {
 741               if (verbose)
 742                 s = format (s, "[%u, %u], ", trace[left].start,
 743                             trace[left].end);
 744               vec_add2 (dummy_tc->rcv_opts.sacks, block, 1);
 745               block->start = trace[left].start;
 746               block->end = trace[left].end;
 747             }
 748           left++;
 749         }
 750
 751       /* Push segments */
 752       tcp_rcv_sacks (dummy_tc, next_ack);
 753       if (has_new_ack)
 754         dummy_tc->snd_una = next_ack;
 755
 756       if (verbose)
 757         s = format (s, "result: %U", format_tcp_scoreboard,
 758                     &dummy_tc->sack_sb);
 759
 760     }
 761   s = format (s, "result: %U", format_tcp_scoreboard, &dummy_tc->sack_sb);
 762
 763   return s;
 764 }
 765
 766 static clib_error_t *
 767 tcp_scoreboard_trace_fn (vlib_main_t * vm, unformat_input_t * input,
 768                          vlib_cli_command_t * cmd_arg)
 769 {
 770   transport_connection_t *tconn = 0;
 771   tcp_connection_t *tc = 0;
 772   u8 *str = 0;
 773   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 774     {
 775       if (unformat (input, "%U", unformat_transport_connection, &tconn,
 776                     TRANSPORT_PROTO_TCP))
 777         ;
 778       else
 779         return clib_error_return (0, "unknown input `%U'",
 780                                   format_unformat_error, input);
 781     }
 782
 783   if (!TCP_SCOREBOARD_TRACE)
 784     {
 785       vlib_cli_output (vm, "scoreboard tracing not enabled");
 786       return 0;
 787     }
 788
 789   tc = tcp_get_connection_from_transport (tconn);
 790   if (!tc)
 791     {
 792       vlib_cli_output (vm, "connection not found");
 793       return 0;
 794     }
 795   str = tcp_scoreboard_replay (str, tc, 1);
 796   vlib_cli_output (vm, "%v", str);
 797   return 0;
 798 }
 799
 800 /* *INDENT-OFF* */
 801 VLIB_CLI_COMMAND (tcp_replay_scoreboard_command, static) =
 802 {
 803   .path = "tcp replay scoreboard",
 804   .short_help = "tcp replay scoreboard <connection>",
 805   .function = tcp_scoreboard_trace_fn,
 806 };
 807 /* *INDENT-ON* */
 808
 809 static clib_error_t *
 810 show_tcp_punt_fn (vlib_main_t * vm, unformat_input_t * input,
 811                   vlib_cli_command_t * cmd_arg)
 812 {
 813   tcp_main_t *tm = vnet_get_tcp_main ();
 814   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 815     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
 816                               input);
 817   vlib_cli_output (vm, "IPv4 TCP punt: %s",
 818                    tm->punt_unknown4 ? "enabled" : "disabled");
 819   vlib_cli_output (vm, "IPv6 TCP punt: %s",
 820                    tm->punt_unknown6 ? "enabled" : "disabled");
 821   return 0;
 822 }
 823 /* *INDENT-OFF* */
 824 VLIB_CLI_COMMAND (show_tcp_punt_command, static) =
 825 {
 826   .path = "show tcp punt",
 827   .short_help = "show tcp punt",
 828   .function = show_tcp_punt_fn,
 829 };
 830 /* *INDENT-ON* */
 831
 832 static clib_error_t *
 833 show_tcp_stats_fn (vlib_main_t * vm, unformat_input_t * input,
 834                    vlib_cli_command_t * cmd)
 835 {
 836   tcp_main_t *tm = vnet_get_tcp_main ();
 837   tcp_worker_ctx_t *wrk;
 838   u32 thread;
 839
 840   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 841     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
 842                               input);
 843   for (thread = 0; thread < vec_len (tm->wrk_ctx); thread++)
 844     {
 845       wrk = tcp_get_worker (thread);
 846       vlib_cli_output (vm, "Thread %u:\n", thread);
 847
 848       if (clib_fifo_elts (wrk->pending_timers))
 849         vlib_cli_output (vm, " %lu pending timers",
 850                          clib_fifo_elts (wrk->pending_timers));
 851
 852 #define _(name,type,str)                                        \
 853   if (wrk->stats.name)                                          \
 854     vlib_cli_output (vm, " %lu %s", wrk->stats.name, str);
 855       foreach_tcp_wrk_stat
 856 #undef _
 857     }
 858
 859   return 0;
 860 }
 861
 862 /* *INDENT-OFF* */
 863 VLIB_CLI_COMMAND (show_tcp_stats_command, static) =
 864 {
 865   .path = "show tcp stats",
 866   .short_help = "show tcp stats",
 867   .function = show_tcp_stats_fn,
 868 };
 869 /* *INDENT-ON* */
 870
 871 static clib_error_t *
 872 clear_tcp_stats_fn (vlib_main_t * vm, unformat_input_t * input,
 873                     vlib_cli_command_t * cmd)
 874 {
 875   tcp_main_t *tm = vnet_get_tcp_main ();
 876   tcp_worker_ctx_t *wrk;
 877   u32 thread;
 878
 879   if (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 880     return clib_error_return (0, "unknown input `%U'", format_unformat_error,
 881                               input);
 882
 883   for (thread = 0; thread < vec_len (tm->wrk_ctx); thread++)
 884     {
 885       wrk = tcp_get_worker (thread);
 886       clib_memset (&wrk->stats, 0, sizeof (wrk->stats));
 887     }
 888
 889   return 0;
 890 }
 891
 892 /* *INDENT-OFF* */
 893 VLIB_CLI_COMMAND (clear_tcp_stats_command, static) =
 894 {
 895   .path = "clear tcp stats",
 896   .short_help = "clear tcp stats",
 897   .function = clear_tcp_stats_fn,
 898 };
 899 /* *INDENT-ON* */
 900
 901 static void
 902 tcp_show_half_open (vlib_main_t * vm, u32 start, u32 end, u8 verbose)
 903 {
 904   tcp_main_t *tm = &tcp_main;
 905   u8 output_suppressed = 0;
 906   u32 n_elts, count = 0;
 907   tcp_connection_t *tc;
 908   int max_index, i;
 909
 910   n_elts = pool_elts (tm->half_open_connections);
 911   max_index = clib_max (pool_len (tm->half_open_connections), 1) - 1;
 912   if (verbose && end == ~0 && n_elts > 50)
 913     {
 914       vlib_cli_output (vm, "Too many connections, use range <start> <end>");
 915       return;
 916     }
 917
 918   if (!verbose)
 919     {
 920       vlib_cli_output (vm, "%u tcp half-open connections", n_elts);
 921       return;
 922     }
 923
 924   for (i = start; i <= clib_min (end, max_index); i++)
 925     {
 926       if (pool_is_free_index (tm->half_open_connections, i))
 927         continue;
 928
 929       tc = pool_elt_at_index (tm->half_open_connections, i);
 930
 931       count += 1;
 932       if (verbose)
 933         {
 934           if (count > 50 || (verbose > 1 && count > 10))
 935             {
 936               output_suppressed = 1;
 937               continue;
 938             }
 939         }
 940       vlib_cli_output (vm, "%U", format_tcp_connection, tc, verbose);
 941     }
 942   if (!output_suppressed)
 943     vlib_cli_output (vm, "%u tcp half-open connections", n_elts);
 944   else
 945     vlib_cli_output (vm, "%u tcp half-open connections matched. Output "
 946                      "suppressed. Use finer grained filter.", count);
 947
 948 }
 949
 950 static clib_error_t *
 951 show_tcp_half_open_fn (vlib_main_t * vm, unformat_input_t * input,
 952                        vlib_cli_command_t * cmd)
 953 {
 954   unformat_input_t _line_input, *line_input = &_line_input;
 955   u32 start, end = ~0, verbose = 0;
 956   clib_error_t *error = 0;
 957
 958   session_cli_return_if_not_enabled ();
 959
 960   if (!unformat_user (input, unformat_line_input, line_input))
 961     {
 962       tcp_show_half_open (vm, 0, ~0, 0);
 963       return 0;
 964     }
 965
 966   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 967     {
 968       if (unformat (line_input, "range %u %u", &start, &end))
 969         ;
 970       else if (unformat (line_input, "verbose %d", &verbose))
 971         ;
 972       else if (unformat (line_input, "verbose"))
 973         verbose = 1;
 974       else
 975         {
 976           error = clib_error_return (0, "unknown input `%U'",
 977                                      format_unformat_error, input);
 978           goto done;
 979         }
 980     }
 981
 982   if (start > end)
 983     {
 984       error = clib_error_return (0, "invalid range start: %u end: %u", start,
 985                                  end);
 986       goto done;
 987     }
 988
 989   tcp_show_half_open (vm, start, end, verbose);
 990
 991 done:
 992   unformat_free (line_input);
 993   return error;
 994 }
 995
 996 /* *INDENT-OFF* */
 997 VLIB_CLI_COMMAND (show_tcp_half_open_command, static) =
 998 {
 999   .path = "show tcp half-open",
1000   .short_help = "show tcp half-open [verbose <n>] [range <start> <end>]",
1001   .function = show_tcp_half_open_fn,
1002 };
1003 /* *INDENT-ON* */
1004
1005 uword
1006 unformat_tcp_cc_algo (unformat_input_t * input, va_list * va)
1007 {
1008   tcp_cc_algorithm_type_e *result = va_arg (*va, tcp_cc_algorithm_type_e *);
1009   tcp_main_t *tm = &tcp_main;
1010   char *cc_algo_name;
1011   u8 found = 0;
1012   uword *p;
1013
1014   if (unformat (input, "%s", &cc_algo_name)
1015       && ((p = hash_get_mem (tm->cc_algo_by_name, cc_algo_name))))
1016     {
1017       *result = *p;
1018       found = 1;
1019     }
1020
1021   vec_free (cc_algo_name);
1022   return found;
1023 }
1024
1025 uword
1026 unformat_tcp_cc_algo_cfg (unformat_input_t * input, va_list * va)
1027 {
1028   tcp_main_t *tm = vnet_get_tcp_main ();
1029   tcp_cc_algorithm_t *cc_alg;
1030   unformat_input_t sub_input;
1031   int found = 0;
1032
1033   vec_foreach (cc_alg, tm->cc_algos)
1034   {
1035     if (!unformat (input, cc_alg->name))
1036       continue;
1037
1038     if (cc_alg->unformat_cfg
1039         && unformat (input, "%U", unformat_vlib_cli_sub_input, &sub_input))
1040       {
1041         if (cc_alg->unformat_cfg (&sub_input))
1042           found = 1;
1043       }
1044   }
1045   return found;
1046 }
1047
1048 static clib_error_t *
1049 tcp_config_fn (vlib_main_t * vm, unformat_input_t * input)
1050 {
1051   u32 cwnd_multiplier, tmp_time, mtu;
1052   uword memory_size;
1053
1054   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1055     {
1056       if (unformat (input, "preallocated-connections %d",
1057                     &tcp_cfg.preallocated_connections))
1058         ;
1059       else if (unformat (input, "preallocated-half-open-connections %d",
1060                          &tcp_cfg.preallocated_half_open_connections))
1061         ;
1062       else if (unformat (input, "buffer-fail-fraction %f",
1063                          &tcp_cfg.buffer_fail_fraction))
1064         ;
1065       else if (unformat (input, "max-rx-fifo %U", unformat_memory_size,
1066                          &memory_size))
1067         {
1068           if (memory_size >= 0x100000000)
1069             {
1070               return clib_error_return
1071                 (0, "max-rx-fifo %llu (0x%llx) too large", memory_size,
1072                  memory_size);
1073             }
1074           tcp_cfg.max_rx_fifo = memory_size;
1075         }
1076       else if (unformat (input, "min-rx-fifo %U", unformat_memory_size,
1077                          &memory_size))
1078         {
1079           if (memory_size >= 0x100000000)
1080             {
1081               return clib_error_return
1082                 (0, "min-rx-fifo %llu (0x%llx) too large", memory_size,
1083                  memory_size);
1084             }
1085           tcp_cfg.min_rx_fifo = memory_size;
1086         }
1087       else if (unformat (input, "mtu %u", &mtu))
1088         tcp_cfg.default_mtu = mtu;
1089       else if (unformat (input, "rwnd-min-update-ack %d",
1090                          &tcp_cfg.rwnd_min_update_ack))
1091         ;
1092       else if (unformat (input, "initial-cwnd-multiplier %u",
1093                          &cwnd_multiplier))
1094         tcp_cfg.initial_cwnd_multiplier = cwnd_multiplier;
1095       else if (unformat (input, "no-tx-pacing"))
1096         tcp_cfg.enable_tx_pacing = 0;
1097       else if (unformat (input, "tso"))
1098         tcp_cfg.allow_tso = 1;
1099       else if (unformat (input, "no-csum-offload"))
1100         tcp_cfg.csum_offload = 0;
1101       else if (unformat (input, "cc-algo %U", unformat_tcp_cc_algo,
1102                          &tcp_cfg.cc_algo))
1103         ;
1104       else if (unformat (input, "%U", unformat_tcp_cc_algo_cfg))
1105         ;
1106       else if (unformat (input, "closewait-time %u", &tmp_time))
1107         tcp_cfg.closewait_time = tmp_time / TCP_TIMER_TICK;
1108       else if (unformat (input, "timewait-time %u", &tmp_time))
1109         tcp_cfg.timewait_time = tmp_time / TCP_TIMER_TICK;
1110       else if (unformat (input, "finwait1-time %u", &tmp_time))
1111         tcp_cfg.finwait1_time = tmp_time / TCP_TIMER_TICK;
1112       else if (unformat (input, "finwait2-time %u", &tmp_time))
1113         tcp_cfg.finwait2_time = tmp_time / TCP_TIMER_TICK;
1114       else if (unformat (input, "lastack-time %u", &tmp_time))
1115         tcp_cfg.lastack_time = tmp_time / TCP_TIMER_TICK;
1116       else if (unformat (input, "closing-time %u", &tmp_time))
1117         tcp_cfg.closing_time = tmp_time / TCP_TIMER_TICK;
1118       else if (unformat (input, "cleanup-time %u", &tmp_time))
1119         tcp_cfg.cleanup_time = tmp_time / 1000.0;
1120       else
1121         return clib_error_return (0, "unknown input `%U'",
1122                                   format_unformat_error, input);
1123     }
1124   return 0;
1125 }
1126
1127 VLIB_CONFIG_FUNCTION (tcp_config_fn, "tcp");
1128
1129 /*
1130  * fd.io coding-style-patch-verification: ON
1131  *
1132  * Local Variables:
1133  * eval: (c-set-style "gnu")
1134  * End:
1135  */