src/plugins/nsim/nsim.c

   1 /*
   2  * nsim.c - skeleton vpp engine plug-in
   3  *
   4  * Copyright (c) <current-year> <your-organization>
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at:
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 /**
  19  * @file
  20  * @brief Network Delay Simulator
  21  */
  22 /*? %%clicmd:group_label Network Delay Simulator %% ?*/
  23
  24 #include <vnet/vnet.h>
  25 #include <vnet/plugin/plugin.h>
  26 #include <nsim/nsim.h>
  27
  28 #include <vlibapi/api.h>
  29 #include <vlibmemory/api.h>
  30 #include <vpp/app/version.h>
  31
  32 /* define message IDs */
  33 #include <nsim/nsim.api_enum.h>
  34 #include <nsim/nsim.api_types.h>
  35
  36 #define REPLY_MSG_ID_BASE nsm->msg_id_base
  37 #include <vlibapi/api_helper_macros.h>
  38
  39 nsim_main_t nsim_main;
  40
  41 /* Action functions shared between message handlers and debug CLI */
  42
  43 int
  44 nsim_cross_connect_enable_disable (nsim_main_t * nsm, u32 sw_if_index0,
  45                                    u32 sw_if_index1, int enable_disable)
  46 {
  47   vnet_sw_interface_t *sw;
  48   vnet_hw_interface_t *hw;
  49   int rv = 0;
  50
  51   if (nsm->is_configured == 0)
  52     return VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
  53
  54   /* Utterly wrong? */
  55   if (pool_is_free_index (nsm->vnet_main->interface_main.sw_interfaces,
  56                           sw_if_index0))
  57     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
  58
  59   if (pool_is_free_index (nsm->vnet_main->interface_main.sw_interfaces,
  60                           sw_if_index1))
  61     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
  62
  63   /* Not a physical port? */
  64   sw = vnet_get_sw_interface (nsm->vnet_main, sw_if_index0);
  65   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
  66     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
  67
  68   sw = vnet_get_sw_interface (nsm->vnet_main, sw_if_index1);
  69   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
  70     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
  71
  72   /* Add graph arcs for the input / wheel scraper node */
  73   hw = vnet_get_hw_interface (nsm->vnet_main, sw_if_index0);
  74   nsm->output_next_index0 =
  75     vlib_node_add_next (nsm->vlib_main,
  76                         nsim_input_node.index, hw->output_node_index);
  77
  78   hw = vnet_get_hw_interface (nsm->vnet_main, sw_if_index1);
  79   nsm->output_next_index1 =
  80     vlib_node_add_next (nsm->vlib_main,
  81                         nsim_input_node.index, hw->output_node_index);
  82
  83   nsm->sw_if_index0 = sw_if_index0;
  84   nsm->sw_if_index1 = sw_if_index1;
  85
  86   vnet_feature_enable_disable ("device-input", "nsim",
  87                                sw_if_index0, enable_disable, 0, 0);
  88   vnet_feature_enable_disable ("device-input", "nsim",
  89                                sw_if_index1, enable_disable, 0, 0);
  90
  91   return rv;
  92 }
  93
  94 int
  95 nsim_output_feature_enable_disable (nsim_main_t * nsm, u32 sw_if_index,
  96                                     int enable_disable)
  97 {
  98   vnet_sw_interface_t *sw;
  99   vnet_hw_interface_t *hw;
 100   int rv = 0;
 101
 102   if (nsm->is_configured == 0)
 103     return VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE;
 104
 105   /* Utterly wrong? */
 106   if (pool_is_free_index (nsm->vnet_main->interface_main.sw_interfaces,
 107                           sw_if_index))
 108     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 109
 110   /* Not a physical port? */
 111   sw = vnet_get_sw_interface (nsm->vnet_main, sw_if_index);
 112   if (sw->type != VNET_SW_INTERFACE_TYPE_HARDWARE)
 113     return VNET_API_ERROR_INVALID_SW_IF_INDEX;
 114
 115   /* Add a graph arc for the input / wheel scraper node */
 116   hw = vnet_get_hw_interface (nsm->vnet_main, sw_if_index);
 117   vec_validate_init_empty (nsm->output_next_index_by_sw_if_index, sw_if_index,
 118                            ~0);
 119   /* Note: use the tx node, this pkt has already visited the output node... */
 120   nsm->output_next_index_by_sw_if_index[sw_if_index] =
 121     vlib_node_add_next (nsm->vlib_main, nsim_input_node.index,
 122                         hw->tx_node_index);
 123
 124   vnet_feature_enable_disable ("interface-output", "nsim-output-feature",
 125                                sw_if_index, enable_disable, 0, 0);
 126   return rv;
 127 }
 128
 129 static nsim_wheel_t *
 130 nsim_wheel_alloc (nsim_main_t * nsm, u32 wheel_slots)
 131 {
 132   u32 pagesize = getpagesize ();
 133   nsim_wheel_t *wp;
 134
 135   nsm->mmap_size = sizeof (nsim_wheel_t)
 136     + wheel_slots * sizeof (nsim_wheel_entry_t);
 137
 138   nsm->mmap_size += pagesize - 1;
 139   nsm->mmap_size &= ~(pagesize - 1);
 140
 141   wp = clib_mem_vm_alloc (nsm->mmap_size);
 142   ASSERT (wp != 0);
 143   wp->wheel_size = wheel_slots;
 144   wp->cursize = 0;
 145   wp->head = 0;
 146   wp->tail = 0;
 147   wp->entries = (void *) (wp + 1);
 148
 149   return wp;
 150 }
 151
 152 static int
 153 nsim_configure (nsim_main_t * nsm, f64 bandwidth, f64 delay, f64 packet_size,
 154                 f64 drop_fraction, f64 reorder_fraction)
 155 {
 156   u64 total_buffer_size_in_bytes, per_worker_buffer_size, wheel_slots_per_wrk;
 157   int i, num_workers = vlib_num_workers ();
 158   vlib_main_t *vm = nsm->vlib_main;
 159
 160   if (bandwidth == 0.0)
 161     return VNET_API_ERROR_INVALID_VALUE;
 162
 163   if (delay == 0.0)
 164     return VNET_API_ERROR_INVALID_VALUE_2;
 165
 166   if (packet_size < 64.0 || packet_size > 9000.0)
 167     return VNET_API_ERROR_INVALID_VALUE_3;
 168
 169   if (reorder_fraction > 0.0 && delay == 0.0)
 170     return VNET_API_ERROR_INVALID_VALUE_4;
 171
 172   /* Toss the old wheel(s)... */
 173   if (nsm->is_configured)
 174     {
 175       for (i = 0; i < vec_len (nsm->wheel_by_thread); i++)
 176         {
 177           clib_mem_vm_free (nsm->wheel_by_thread[i], nsm->mmap_size);
 178           nsm->wheel_by_thread[i] = 0;
 179         }
 180     }
 181
 182   nsm->delay = delay;
 183   nsm->drop_fraction = drop_fraction;
 184   nsm->reorder_fraction = reorder_fraction;
 185
 186   /* delay in seconds, bandwidth in bits/sec */
 187   total_buffer_size_in_bytes = ((delay * bandwidth) / 8.0) + 0.5;
 188
 189   /*
 190    * Work out how much buffering each worker needs, assuming decent
 191    * RSS behavior.
 192    */
 193   if (num_workers)
 194     per_worker_buffer_size = total_buffer_size_in_bytes / num_workers;
 195   else
 196     per_worker_buffer_size = total_buffer_size_in_bytes;
 197
 198   wheel_slots_per_wrk = per_worker_buffer_size / packet_size;
 199   wheel_slots_per_wrk++;
 200
 201   /* Save these for the show command */
 202   nsm->bandwidth = bandwidth;
 203   nsm->packet_size = packet_size;
 204
 205   vec_validate (nsm->wheel_by_thread, num_workers);
 206
 207   /* Initialize the output scheduler wheels */
 208   i = (!nsm->poll_main_thread && num_workers) ? 1 : 0;
 209   for (; i < num_workers + 1; i++)
 210     nsm->wheel_by_thread[i] = nsim_wheel_alloc (nsm, wheel_slots_per_wrk);
 211
 212   vlib_worker_thread_barrier_sync (vm);
 213
 214   /* turn on the ring scrapers */
 215   i = (!nsm->poll_main_thread && num_workers) ? 1 : 0;
 216   for (; i < num_workers + 1; i++)
 217     {
 218       vlib_main_t *this_vm = vlib_mains[i];
 219
 220       vlib_node_set_state (this_vm, nsim_input_node.index,
 221                            VLIB_NODE_STATE_POLLING);
 222     }
 223
 224   vlib_worker_thread_barrier_release (vm);
 225
 226   nsm->is_configured = 1;
 227   return 0;
 228 }
 229
 230 /*
 231  * enable or disable the cross-connect
 232  */
 233 static clib_error_t *
 234 nsim_cross_connect_enable_disable_command_fn (vlib_main_t * vm,
 235                                               unformat_input_t * input,
 236                                               vlib_cli_command_t * cmd)
 237 {
 238   nsim_main_t *nsm = &nsim_main;
 239   unformat_input_t _line_input, *line_input = &_line_input;
 240   u32 sw_if_index0 = ~0;
 241   u32 sw_if_index1 = ~0;
 242   int enable_disable = 1;
 243   u32 tmp;
 244   int rv;
 245
 246   /* Get a line of input. */
 247   if (!unformat_user (input, unformat_line_input, line_input))
 248     return 0;
 249
 250   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 251     {
 252       if (unformat (line_input, "disable"))
 253         enable_disable = 0;
 254       else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
 255                          nsm->vnet_main, &tmp))
 256         {
 257           if (sw_if_index0 == ~0)
 258             sw_if_index0 = tmp;
 259           else
 260             sw_if_index1 = tmp;
 261         }
 262       else
 263         break;
 264     }
 265
 266   unformat_free (line_input);
 267
 268   if (sw_if_index0 == ~0 || sw_if_index1 == ~0)
 269     return clib_error_return (0, "Please specify two interfaces...");
 270
 271   rv = nsim_cross_connect_enable_disable (nsm, sw_if_index0,
 272                                           sw_if_index1, enable_disable);
 273
 274   switch (rv)
 275     {
 276     case 0:
 277       break;
 278
 279     case VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE:
 280       return clib_error_return (0, "Not configured, please 'set nsim' first");
 281
 282     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
 283       return clib_error_return
 284         (0, "Invalid interface, only works on physical ports");
 285       break;
 286
 287     case VNET_API_ERROR_UNIMPLEMENTED:
 288       return clib_error_return (0,
 289                                 "Device driver doesn't support redirection");
 290       break;
 291
 292     default:
 293       return clib_error_return (0, "nsim_enable_disable returned %d", rv);
 294     }
 295   return 0;
 296 }
 297
 298 static clib_error_t *
 299 nsim_config (vlib_main_t * vm, unformat_input_t * input)
 300 {
 301   nsim_main_t *nsm = &nsim_main;
 302
 303   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 304     {
 305       if (unformat (input, "poll-main-thread"))
 306         {
 307           nsm->poll_main_thread = 1;
 308         }
 309       else
 310         {
 311           return clib_error_return (0, "unknown input '%U'",
 312                                     format_unformat_error, input);
 313         }
 314     }
 315   return 0;
 316 }
 317
 318 VLIB_CONFIG_FUNCTION (nsim_config, "nsim");
 319
 320 /*?
 321  * Enable or disable network simulation cross-connect on two interfaces
 322  * The network simulator must have already been configured, see
 323  * the "nsim_configure" command.
 324  *
 325  * Place the interfaces into a bridge group, to ensure that
 326  * interfaces are in promiscuous mode.
 327  *
 328  * @cliexpar
 329  * To enable or disable network simulation cross-connect
 330  * @clistart
 331  * nsim cross-connect enable-disable TenGigabitEthernet2/0/0 TenGigabitEthernet2/0
 332  * nsim cross-connect enable-disable TenGigabitEthernet2/0/0 TenGigabitEthernet2/0 disable
 333  * @cliend
 334  * @cliexcmd{nsim enable-disable <intfc> <intfc> [disable]}
 335 ?*/
 336 /* *INDENT-OFF* */
 337 VLIB_CLI_COMMAND (nsim_enable_disable_command, static) =
 338 {
 339   .path = "nsim cross-connect enable-disable",
 340   .short_help =
 341   "nsim cross-connect enable-disable <interface-name-1> "
 342   "<interface-name-2> [disable]",
 343   .function = nsim_cross_connect_enable_disable_command_fn,
 344 };
 345 /* *INDENT-ON* */
 346
 347 /* API message handler */
 348 static void vl_api_nsim_cross_connect_enable_disable_t_handler
 349   (vl_api_nsim_cross_connect_enable_disable_t * mp)
 350 {
 351   vl_api_nsim_cross_connect_enable_disable_reply_t *rmp;
 352   nsim_main_t *nsm = &nsim_main;
 353   int rv;
 354   u32 sw_if_index0, sw_if_index1;
 355
 356   sw_if_index0 = clib_net_to_host_u32 (mp->sw_if_index0);
 357   sw_if_index1 = clib_net_to_host_u32 (mp->sw_if_index1);
 358
 359   if (!vnet_sw_if_index_is_api_valid (sw_if_index0))
 360     {
 361       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
 362       goto bad_sw_if_index;
 363     }
 364   if (!vnet_sw_if_index_is_api_valid (sw_if_index1))
 365     {
 366       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
 367       goto bad_sw_if_index;
 368     }
 369
 370   rv = nsim_cross_connect_enable_disable (nsm, sw_if_index0, sw_if_index1,
 371                                           (int) (mp->enable_disable));
 372
 373   BAD_SW_IF_INDEX_LABEL;
 374   REPLY_MACRO (VL_API_NSIM_CROSS_CONNECT_ENABLE_DISABLE_REPLY);
 375 }
 376
 377 /* API message handler */
 378 static void vl_api_nsim_output_feature_enable_disable_t_handler
 379   (vl_api_nsim_output_feature_enable_disable_t * mp)
 380 {
 381   vl_api_nsim_output_feature_enable_disable_reply_t *rmp;
 382   nsim_main_t *nsm = &nsim_main;
 383   int rv;
 384   VALIDATE_SW_IF_INDEX (mp);
 385
 386   rv = nsim_output_feature_enable_disable (nsm, ntohl (mp->sw_if_index),
 387                                            (int) (mp->enable_disable));
 388
 389   BAD_SW_IF_INDEX_LABEL;
 390   REPLY_MACRO (VL_API_NSIM_OUTPUT_FEATURE_ENABLE_DISABLE_REPLY);
 391 }
 392
 393 /* API message handler */
 394 static void
 395 vl_api_nsim_configure_t_handler (vl_api_nsim_configure_t * mp)
 396 {
 397   vl_api_nsim_configure_reply_t *rmp;
 398   nsim_main_t *nsm = &nsim_main;
 399   f64 delay, bandwidth, packet_size, drop_fraction = 0.0, reorder_rate = 0.0;
 400   u32 packets_per_drop;
 401   int rv;
 402
 403   delay = ((f64) (ntohl (mp->delay_in_usec))) * 1e-6;
 404   bandwidth = (f64) (clib_net_to_host_u64 (mp->bandwidth_in_bits_per_second));
 405   packet_size = (f64) (ntohl (mp->average_packet_size));
 406
 407   packets_per_drop = ntohl (mp->packets_per_drop);
 408   if (packets_per_drop > 0)
 409     drop_fraction = 1.0 / (f64) (packets_per_drop);
 410
 411   rv = nsim_configure (nsm, bandwidth, delay, packet_size, drop_fraction,
 412                        reorder_rate);
 413
 414   REPLY_MACRO (VL_API_NSIM_CONFIGURE_REPLY);
 415 }
 416
 417 static void
 418 vl_api_nsim_configure2_t_handler (vl_api_nsim_configure2_t * mp)
 419 {
 420   vl_api_nsim_configure_reply_t *rmp;
 421   nsim_main_t *nsm = &nsim_main;
 422   f64 delay, bandwidth, packet_size, drop_fraction = 0.0, reorder_rate = 0.0;
 423   u32 packets_per_drop, packets_per_reorder;
 424   int rv;
 425
 426   delay = ((f64) (ntohl (mp->delay_in_usec))) * 1e-6;
 427   bandwidth = (f64) (clib_net_to_host_u64 (mp->bandwidth_in_bits_per_second));
 428   packet_size = (f64) (ntohl (mp->average_packet_size));
 429
 430   packets_per_drop = ntohl (mp->packets_per_drop);
 431   if (packets_per_drop > 0)
 432     drop_fraction = 1.0 / (f64) (packets_per_drop);
 433
 434   packets_per_reorder = ntohl (mp->packets_per_reorder);
 435   if (packets_per_reorder > 0)
 436     reorder_rate = 1.0 / (f64) packets_per_reorder;
 437
 438   rv = nsim_configure (nsm, bandwidth, delay, packet_size, drop_fraction,
 439                        reorder_rate);
 440
 441   REPLY_MACRO (VL_API_NSIM_CONFIGURE2_REPLY);
 442 }
 443
 444
 445 /*
 446  * enable or disable the output_feature
 447  */
 448 static clib_error_t *
 449 nsim_output_feature_enable_disable_command_fn (vlib_main_t * vm,
 450                                                unformat_input_t * input,
 451                                                vlib_cli_command_t * cmd)
 452 {
 453   nsim_main_t *nsm = &nsim_main;
 454   unformat_input_t _line_input, *line_input = &_line_input;
 455   u32 sw_if_index = ~0;
 456   int enable_disable = 1;
 457   int rv;
 458
 459   /* Get a line of input. */
 460   if (!unformat_user (input, unformat_line_input, line_input))
 461     return 0;
 462
 463   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 464     {
 465       if (unformat (line_input, "disable"))
 466         enable_disable = 0;
 467       else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
 468                          nsm->vnet_main, &sw_if_index))
 469         ;
 470       else
 471         {
 472           clib_error_t *error = clib_error_return (0, "unknown input `%U'",
 473                                                    format_unformat_error,
 474                                                    line_input);
 475           unformat_free (line_input);
 476           return error;
 477         }
 478     }
 479
 480   unformat_free (line_input);
 481
 482   if (sw_if_index == ~0)
 483     return clib_error_return (0, "Please specify one interface...");
 484
 485   rv = nsim_output_feature_enable_disable (nsm, sw_if_index, enable_disable);
 486
 487   switch (rv)
 488     {
 489     case 0:
 490       break;
 491
 492     case VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE:
 493       return clib_error_return (0, "Not configured, please 'set nsim' first");
 494
 495     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
 496       return clib_error_return
 497         (0, "Invalid interface, only works on physical ports");
 498       break;
 499
 500     case VNET_API_ERROR_UNIMPLEMENTED:
 501       return clib_error_return (0,
 502                                 "Device driver doesn't support redirection");
 503       break;
 504
 505     default:
 506       return clib_error_return
 507         (0, "nsim_output_feature_enable_disable returned %d", rv);
 508     }
 509   return 0;
 510 }
 511
 512 /*?
 513  * Enable or disable network simulation output feature on an interface
 514  * The network simulator must have already been configured, see
 515  * the "nsim_configure" command.
 516  *
 517  * @cliexpar
 518  * To enable or disable network simulation output feature
 519  * @clistart
 520  * nsim output-feature enable-disable TenGigabitEthernet2/0/0
 521  * nsim output-feature enable-disable TenGigabitEthernet2/0/0 disable
 522  * @cliend
 523  * @cliexcmd{nsim output-feature enable-disable <intfc> [disable]}
 524 ?*/
 525 /* *INDENT-OFF* */
 526 VLIB_CLI_COMMAND (nsim_output_feature_enable_disable_command, static) =
 527 {
 528   .path = "nsim output-feature enable-disable",
 529   .short_help =
 530   "nsim output-feature enable-disable <interface-name> [disable]",
 531   .function = nsim_output_feature_enable_disable_command_fn,
 532 };
 533 /* *INDENT-ON* */
 534
 535 #include <nsim/nsim.api.c>
 536 static clib_error_t *
 537 nsim_init (vlib_main_t * vm)
 538 {
 539   nsim_main_t *nsm = &nsim_main;
 540
 541   nsm->vlib_main = vm;
 542   nsm->vnet_main = vnet_get_main ();
 543
 544   /* Ask for a correctly-sized block of API message decode slots */
 545   nsm->msg_id_base = setup_message_id_table ();
 546   nsm->arc_index = nsm->vnet_main->interface_main.output_feature_arc_index;
 547   return 0;
 548 }
 549
 550 VLIB_INIT_FUNCTION (nsim_init);
 551
 552 /* *INDENT-OFF* */
 553 VNET_FEATURE_INIT (nsim, static) =
 554 {
 555   .arc_name = "device-input",
 556   .node_name = "nsim",
 557   .runs_before = VNET_FEATURES ("ethernet-input"),
 558 };
 559 /* *INDENT-ON */
 560
 561 /* *INDENT-OFF* */
 562 VNET_FEATURE_INIT (nsim_feature, static) =
 563 {
 564   .arc_name = "interface-output",
 565   .node_name = "nsim-output-feature",
 566   .runs_before = VNET_FEATURES ("interface-tx"),
 567 };
 568 /* *INDENT-ON */
 569
 570 /* *INDENT-OFF* */
 571 VLIB_PLUGIN_REGISTER () =
 572 {
 573   .version = VPP_BUILD_VER,
 574   .description = "Network Delay Simulator",
 575 };
 576 /* *INDENT-ON* */
 577
 578 static uword
 579 unformat_delay (unformat_input_t * input, va_list * args)
 580 {
 581   f64 *result = va_arg (*args, f64 *);
 582   f64 tmp;
 583
 584   if (unformat (input, "%f us", &tmp))
 585     *result = tmp * 1e-6;
 586   else if (unformat (input, "%f ms", &tmp))
 587     *result = tmp * 1e-3;
 588   else if (unformat (input, "%f sec", &tmp))
 589     *result = tmp;
 590   else
 591     return 0;
 592
 593   return 1;
 594 }
 595
 596 static uword
 597 unformat_bandwidth (unformat_input_t * input, va_list * args)
 598 {
 599   f64 *result = va_arg (*args, f64 *);
 600   f64 tmp;
 601
 602   if (unformat (input, "%f gbit", &tmp))
 603     *result = tmp * 1e9;
 604   else if (unformat (input, "%f gbyte", &tmp))
 605     *result = tmp * 8e9;
 606   else
 607     return 0;
 608   return 1;
 609 }
 610
 611 static u8 *
 612 format_nsim_config (u8 * s, va_list * args)
 613 {
 614   int verbose = va_arg (*args, int);
 615   nsim_main_t *nsm = &nsim_main;
 616
 617   s = format (s, "configuration\n");
 618   s = format (s, " delay (ms): %.2f\n", nsm->delay * 1e3);
 619   if (nsm->drop_fraction)
 620     s = format (s, " drop fraction: %.5f\n", nsm->drop_fraction);
 621   else
 622     s = format (s, " drop fraction: 0\n");
 623   if (nsm->reorder_fraction)
 624     s = format (s, " reorder fraction: %.5f\n", nsm->reorder_fraction);
 625   else
 626     s = format (s, " reorder fraction: 0\n");
 627   s = format (s, " packet size: %u\n", nsm->packet_size);
 628   s = format (s, " throughput (Gbps): %.2f\n", nsm->bandwidth / 1e9);
 629
 630   if (verbose)
 631     {
 632       s = format (s, " poll main thread: %u\n", nsm->poll_main_thread);
 633       s = format (s, " memory: %U bytes per thread %U bytes total\n",
 634                   format_memory_size, nsm->mmap_size, format_memory_size,
 635                   nsm->mmap_size * vlib_num_workers ());
 636     }
 637
 638   s = format (s, "\n");
 639
 640   if (nsm->sw_if_index0 != 0)
 641     {
 642       s = format (s, "cross-connect\n %U and %U\n",
 643                   format_vnet_sw_if_index_name, nsm->vnet_main,
 644                   nsm->sw_if_index0, format_vnet_sw_if_index_name,
 645                   nsm->vnet_main, nsm->sw_if_index1);
 646     }
 647   else if (vec_len (nsm->output_next_index_by_sw_if_index))
 648     {
 649       int i;
 650       s = format (s, "output feature arcs to:\n");
 651       for (i = 0; i < vec_len (nsm->output_next_index_by_sw_if_index); i++)
 652         {
 653           if (nsm->output_next_index_by_sw_if_index[i] != ~0)
 654             s = format (s, " %U %u\n", format_vnet_sw_if_index_name,
 655                         nsm->vnet_main, i, i);
 656         }
 657     }
 658   else
 659     {
 660       s = format (s, " nsim not enabled\n");
 661     }
 662
 663   return s;
 664 }
 665
 666 static clib_error_t *
 667 set_nsim_command_fn (vlib_main_t * vm,
 668                      unformat_input_t * input, vlib_cli_command_t * cmd)
 669 {
 670   f64 drop_fraction = 0.0, reorder_fraction = 0.0;
 671   f64 delay, bandwidth, packet_size = 1500.0;
 672   u32 packets_per_drop, packets_per_reorder;
 673   nsim_main_t *nsm = &nsim_main;
 674   int rv;
 675
 676   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 677     {
 678       if (unformat (input, "delay %U", unformat_delay, &delay))
 679         ;
 680       else if (unformat (input, "bandwidth %U", unformat_bandwidth,
 681                          &bandwidth))
 682         ;
 683       else if (unformat (input, "packet-size %f", &packet_size))
 684         ;
 685       else if (unformat (input, "packets-per-drop %d", &packets_per_drop))
 686         {
 687           if (packets_per_drop > 0)
 688             drop_fraction = 1.0 / ((f64) packets_per_drop);
 689         }
 690       else if (unformat (input, "packets-per-reorder %d",
 691                          &packets_per_reorder))
 692         {
 693           if (packets_per_reorder > 0)
 694             reorder_fraction = 1.0 / ((f64) packets_per_reorder);
 695         }
 696       else if (unformat (input, "drop-fraction %f", &drop_fraction))
 697         {
 698           if (drop_fraction < 0.0 || drop_fraction > 1.0)
 699             return clib_error_return
 700               (0, "drop fraction must be between zero and 1");
 701         }
 702       else if (unformat (input, "reorder-fraction %f", &reorder_fraction))
 703         {
 704           if (reorder_fraction < 0.0 || reorder_fraction > 1.0)
 705             return clib_error_return
 706               (0, "reorder fraction must be between zero and 1");
 707         }
 708       else if (unformat (input, "poll-main-thread"))
 709         nsm->poll_main_thread = 1;
 710       else
 711         break;
 712     }
 713
 714   rv = nsim_configure (nsm, bandwidth, delay, packet_size, drop_fraction,
 715                        reorder_fraction);
 716
 717   switch (rv)
 718     {
 719     case VNET_API_ERROR_INVALID_VALUE:
 720       return clib_error_return (0, "invalid bandwidth %.2f", bandwidth);
 721
 722     case VNET_API_ERROR_INVALID_VALUE_2:
 723       return clib_error_return (0, "invalid delay %.2f", delay);
 724
 725     case VNET_API_ERROR_INVALID_VALUE_3:
 726       return clib_error_return (0, "invalid packet size %.2f", packet_size);
 727
 728     case VNET_API_ERROR_INVALID_VALUE_4:
 729       return clib_error_return (0, "invalid reorder fraction %.3f for "
 730                                 "delay %.2f", reorder_fraction, delay);
 731
 732     default:
 733       return clib_error_return (0, "error %d", rv);
 734
 735     case 0:
 736       break;
 737     }
 738
 739   vlib_cli_output (vm, "%U", format_nsim_config, 1);
 740
 741   return 0;
 742 }
 743
 744 /*?
 745  * Configure the network simulation cross-connect
 746  * Once the simulator is configured, use the "nsim enable-disable" command
 747  * to set up a cross-connect with the supplied delay characteristics.
 748  *
 749  * The cross connect configuration may be changed without restarting vpp
 750  * but it is good practice to shut down the interfaces.
 751  *
 752  * @cliexpar
 753  * To configure the network delay simulator:
 754  * @clistart
 755  * set nsim delay 10.0 ms bandwidth 5.5 gbit packet-size 128
 756  *
 757  * @cliend
 758  * @cliexcmd{set nsim delay <nn> bandwidth <bb> packet-size <nn>}
 759 ?*/
 760 /* *INDENT-OFF* */
 761 VLIB_CLI_COMMAND (set_nsim_command, static) =
 762 {
 763   .path = "set nsim",
 764   .short_help = "set nsim delay <time> bandwidth <bps> packet-size <nbytes>\n"
 765   "    [packets-per-drop <nn>][drop-fraction <f64: 0.0 - 1.0>]",
 766   .function = set_nsim_command_fn,
 767 };
 768 /* *INDENT-ON*/
 769
 770
 771 static clib_error_t *
 772 show_nsim_command_fn (vlib_main_t * vm,
 773                       unformat_input_t * input, vlib_cli_command_t * cmd)
 774 {
 775   nsim_main_t *nsm = &nsim_main;
 776   int verbose = 0;
 777
 778   if (nsm->is_configured == 0)
 779     return clib_error_return (0, "Network simulator not configured");
 780
 781   if (unformat (input, "verbose"))
 782     verbose = 1;
 783
 784   vlib_cli_output (vm, "%U", format_nsim_config, verbose);
 785
 786   return 0;
 787 }
 788
 789 /*?
 790  * Display state info for the network delay simulator.
 791  *
 792  * @cliexpar
 793  * To display the state of the network simulator
 794  * @clistart
 795  * show nsim verbose
 796  * Network simulator cross-connects TenGigabitEthernet2/0/0 and TenGigabitEthernet2/0/1
 797  * ...inserting link delay of 10.00 ms, 20.00 ms round-trip
 798  *  Configured bandwidth: 10.10 gbit/sec
 799  *  Configured packet size: 128
 800  *  Sim uses 157814784 bytes total
 801  * @cliend
 802  * @cliexcmd{show nsim}
 803 ?*/
 804
 805 /* *INDENT-OFF* */
 806 VLIB_CLI_COMMAND (show_nsim_command, static) =
 807 {
 808   .path = "show nsim",
 809   .short_help = "Display network delay simulator configuration",
 810   .function = show_nsim_command_fn,
 811 };
 812 /* *INDENT-ON* */
 813
 814 /*
 815  * fd.io coding-style-patch-verification: ON
 816  *
 817  * Local Variables:
 818  * eval: (c-set-style "gnu")
 819  * End:
 820  */