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)
 131 {
 132   u32 pagesize = getpagesize ();
 133   nsim_wheel_t *wp;
 134
 135   nsm->mmap_size = sizeof (nsim_wheel_t) +
 136                    nsm->wheel_slots_per_wrk * 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 = nsm->wheel_slots_per_wrk;
 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, u32 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 || packet_size > 9000)
 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   nsm->wheel_slots_per_wrk = wheel_slots_per_wrk;
 205
 206   vec_validate (nsm->wheel_by_thread, num_workers);
 207
 208   /* Initialize the output scheduler wheels */
 209   i = (!nsm->poll_main_thread && num_workers) ? 1 : 0;
 210   for (; i < num_workers + 1; i++)
 211     nsm->wheel_by_thread[i] = nsim_wheel_alloc (nsm);
 212
 213   vlib_worker_thread_barrier_sync (vm);
 214
 215   /* turn on the ring scrapers */
 216   i = (!nsm->poll_main_thread && num_workers) ? 1 : 0;
 217   for (; i < num_workers + 1; i++)
 218     {
 219       vlib_main_t *this_vm = vlib_get_main_by_index (i);
 220
 221       vlib_node_set_state (this_vm, nsim_input_node.index,
 222                            VLIB_NODE_STATE_POLLING);
 223     }
 224
 225   vlib_worker_thread_barrier_release (vm);
 226
 227   nsm->is_configured = 1;
 228   return 0;
 229 }
 230
 231 /*
 232  * enable or disable the cross-connect
 233  */
 234 static clib_error_t *
 235 nsim_cross_connect_enable_disable_command_fn (vlib_main_t * vm,
 236                                               unformat_input_t * input,
 237                                               vlib_cli_command_t * cmd)
 238 {
 239   nsim_main_t *nsm = &nsim_main;
 240   unformat_input_t _line_input, *line_input = &_line_input;
 241   u32 sw_if_index0 = ~0;
 242   u32 sw_if_index1 = ~0;
 243   int enable_disable = 1;
 244   u32 tmp;
 245   int rv;
 246
 247   /* Get a line of input. */
 248   if (!unformat_user (input, unformat_line_input, line_input))
 249     return 0;
 250
 251   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 252     {
 253       if (unformat (line_input, "disable"))
 254         enable_disable = 0;
 255       else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
 256                          nsm->vnet_main, &tmp))
 257         {
 258           if (sw_if_index0 == ~0)
 259             sw_if_index0 = tmp;
 260           else
 261             sw_if_index1 = tmp;
 262         }
 263       else
 264         break;
 265     }
 266
 267   unformat_free (line_input);
 268
 269   if (sw_if_index0 == ~0 || sw_if_index1 == ~0)
 270     return clib_error_return (0, "Please specify two interfaces...");
 271
 272   rv = nsim_cross_connect_enable_disable (nsm, sw_if_index0,
 273                                           sw_if_index1, enable_disable);
 274
 275   switch (rv)
 276     {
 277     case 0:
 278       break;
 279
 280     case VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE:
 281       return clib_error_return (0, "Not configured, please 'set nsim' first");
 282
 283     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
 284       return clib_error_return
 285         (0, "Invalid interface, only works on physical ports");
 286       break;
 287
 288     case VNET_API_ERROR_UNIMPLEMENTED:
 289       return clib_error_return (0,
 290                                 "Device driver doesn't support redirection");
 291       break;
 292
 293     default:
 294       return clib_error_return (0, "nsim_enable_disable returned %d", rv);
 295     }
 296   return 0;
 297 }
 298
 299 static clib_error_t *
 300 nsim_config (vlib_main_t * vm, unformat_input_t * input)
 301 {
 302   nsim_main_t *nsm = &nsim_main;
 303
 304   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 305     {
 306       if (unformat (input, "poll-main-thread"))
 307         {
 308           nsm->poll_main_thread = 1;
 309         }
 310       else
 311         {
 312           return clib_error_return (0, "unknown input '%U'",
 313                                     format_unformat_error, input);
 314         }
 315     }
 316   return 0;
 317 }
 318
 319 VLIB_CONFIG_FUNCTION (nsim_config, "nsim");
 320
 321 /*?
 322  * Enable or disable network simulation cross-connect on two interfaces
 323  * The network simulator must have already been configured, see
 324  * the "nsim_configure" command.
 325  *
 326  * Place the interfaces into a bridge group, to ensure that
 327  * interfaces are in promiscuous mode.
 328  *
 329  * @cliexpar
 330  * To enable or disable network simulation cross-connect
 331  * @clistart
 332  * nsim cross-connect enable-disable TenGigabitEthernet2/0/0 TenGigabitEthernet2/0
 333  * nsim cross-connect enable-disable TenGigabitEthernet2/0/0 TenGigabitEthernet2/0 disable
 334  * @cliend
 335  * @cliexcmd{nsim enable-disable <intfc> <intfc> [disable]}
 336 ?*/
 337 /* *INDENT-OFF* */
 338 VLIB_CLI_COMMAND (nsim_enable_disable_command, static) =
 339 {
 340   .path = "nsim cross-connect enable-disable",
 341   .short_help =
 342   "nsim cross-connect enable-disable <interface-name-1> "
 343   "<interface-name-2> [disable]",
 344   .function = nsim_cross_connect_enable_disable_command_fn,
 345 };
 346 /* *INDENT-ON* */
 347
 348 /* API message handler */
 349 static void vl_api_nsim_cross_connect_enable_disable_t_handler
 350   (vl_api_nsim_cross_connect_enable_disable_t * mp)
 351 {
 352   vl_api_nsim_cross_connect_enable_disable_reply_t *rmp;
 353   nsim_main_t *nsm = &nsim_main;
 354   int rv;
 355   u32 sw_if_index0, sw_if_index1;
 356
 357   sw_if_index0 = clib_net_to_host_u32 (mp->sw_if_index0);
 358   sw_if_index1 = clib_net_to_host_u32 (mp->sw_if_index1);
 359
 360   if (!vnet_sw_if_index_is_api_valid (sw_if_index0))
 361     {
 362       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX;
 363       goto bad_sw_if_index;
 364     }
 365   if (!vnet_sw_if_index_is_api_valid (sw_if_index1))
 366     {
 367       rv = VNET_API_ERROR_INVALID_SW_IF_INDEX_2;
 368       goto bad_sw_if_index;
 369     }
 370
 371   rv = nsim_cross_connect_enable_disable (nsm, sw_if_index0, sw_if_index1,
 372                                           (int) (mp->enable_disable));
 373
 374   BAD_SW_IF_INDEX_LABEL;
 375   REPLY_MACRO (VL_API_NSIM_CROSS_CONNECT_ENABLE_DISABLE_REPLY);
 376 }
 377
 378 /* API message handler */
 379 static void vl_api_nsim_output_feature_enable_disable_t_handler
 380   (vl_api_nsim_output_feature_enable_disable_t * mp)
 381 {
 382   vl_api_nsim_output_feature_enable_disable_reply_t *rmp;
 383   nsim_main_t *nsm = &nsim_main;
 384   int rv;
 385   VALIDATE_SW_IF_INDEX (mp);
 386
 387   rv = nsim_output_feature_enable_disable (nsm, ntohl (mp->sw_if_index),
 388                                            (int) (mp->enable_disable));
 389
 390   BAD_SW_IF_INDEX_LABEL;
 391   REPLY_MACRO (VL_API_NSIM_OUTPUT_FEATURE_ENABLE_DISABLE_REPLY);
 392 }
 393
 394 /* API message handler */
 395 static void
 396 vl_api_nsim_configure_t_handler (vl_api_nsim_configure_t * mp)
 397 {
 398   vl_api_nsim_configure_reply_t *rmp;
 399   nsim_main_t *nsm = &nsim_main;
 400   f64 delay, bandwidth, packet_size, drop_fraction = 0.0, reorder_rate = 0.0;
 401   u32 packets_per_drop;
 402   int rv;
 403
 404   delay = ((f64) (ntohl (mp->delay_in_usec))) * 1e-6;
 405   bandwidth = (f64) (clib_net_to_host_u64 (mp->bandwidth_in_bits_per_second));
 406   packet_size = (f64) (ntohl (mp->average_packet_size));
 407
 408   packets_per_drop = ntohl (mp->packets_per_drop);
 409   if (packets_per_drop > 0)
 410     drop_fraction = 1.0 / (f64) (packets_per_drop);
 411
 412   rv = nsim_configure (nsm, bandwidth, delay, packet_size, drop_fraction,
 413                        reorder_rate);
 414
 415   REPLY_MACRO (VL_API_NSIM_CONFIGURE_REPLY);
 416 }
 417
 418 static void
 419 vl_api_nsim_configure2_t_handler (vl_api_nsim_configure2_t * mp)
 420 {
 421   vl_api_nsim_configure_reply_t *rmp;
 422   nsim_main_t *nsm = &nsim_main;
 423   f64 delay, bandwidth, packet_size, drop_fraction = 0.0, reorder_rate = 0.0;
 424   u32 packets_per_drop, packets_per_reorder;
 425   int rv;
 426
 427   delay = ((f64) (ntohl (mp->delay_in_usec))) * 1e-6;
 428   bandwidth = (f64) (clib_net_to_host_u64 (mp->bandwidth_in_bits_per_second));
 429   packet_size = (f64) (ntohl (mp->average_packet_size));
 430
 431   packets_per_drop = ntohl (mp->packets_per_drop);
 432   if (packets_per_drop > 0)
 433     drop_fraction = 1.0 / (f64) (packets_per_drop);
 434
 435   packets_per_reorder = ntohl (mp->packets_per_reorder);
 436   if (packets_per_reorder > 0)
 437     reorder_rate = 1.0 / (f64) packets_per_reorder;
 438
 439   rv = nsim_configure (nsm, bandwidth, delay, packet_size, drop_fraction,
 440                        reorder_rate);
 441
 442   REPLY_MACRO (VL_API_NSIM_CONFIGURE2_REPLY);
 443 }
 444
 445
 446 /*
 447  * enable or disable the output_feature
 448  */
 449 static clib_error_t *
 450 nsim_output_feature_enable_disable_command_fn (vlib_main_t * vm,
 451                                                unformat_input_t * input,
 452                                                vlib_cli_command_t * cmd)
 453 {
 454   nsim_main_t *nsm = &nsim_main;
 455   unformat_input_t _line_input, *line_input = &_line_input;
 456   u32 sw_if_index = ~0;
 457   int enable_disable = 1;
 458   int rv;
 459
 460   /* Get a line of input. */
 461   if (!unformat_user (input, unformat_line_input, line_input))
 462     return 0;
 463
 464   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 465     {
 466       if (unformat (line_input, "disable"))
 467         enable_disable = 0;
 468       else if (unformat (line_input, "%U", unformat_vnet_sw_interface,
 469                          nsm->vnet_main, &sw_if_index))
 470         ;
 471       else
 472         {
 473           clib_error_t *error = clib_error_return (0, "unknown input `%U'",
 474                                                    format_unformat_error,
 475                                                    line_input);
 476           unformat_free (line_input);
 477           return error;
 478         }
 479     }
 480
 481   unformat_free (line_input);
 482
 483   if (sw_if_index == ~0)
 484     return clib_error_return (0, "Please specify one interface...");
 485
 486   rv = nsim_output_feature_enable_disable (nsm, sw_if_index, enable_disable);
 487
 488   switch (rv)
 489     {
 490     case 0:
 491       break;
 492
 493     case VNET_API_ERROR_CANNOT_ENABLE_DISABLE_FEATURE:
 494       return clib_error_return (0, "Not configured, please 'set nsim' first");
 495
 496     case VNET_API_ERROR_INVALID_SW_IF_INDEX:
 497       return clib_error_return
 498         (0, "Invalid interface, only works on physical ports");
 499       break;
 500
 501     case VNET_API_ERROR_UNIMPLEMENTED:
 502       return clib_error_return (0,
 503                                 "Device driver doesn't support redirection");
 504       break;
 505
 506     default:
 507       return clib_error_return
 508         (0, "nsim_output_feature_enable_disable returned %d", rv);
 509     }
 510   return 0;
 511 }
 512
 513 /*?
 514  * Enable or disable network simulation output feature on an interface
 515  * The network simulator must have already been configured, see
 516  * the "nsim_configure" command.
 517  *
 518  * @cliexpar
 519  * To enable or disable network simulation output feature
 520  * @clistart
 521  * nsim output-feature enable-disable TenGigabitEthernet2/0/0
 522  * nsim output-feature enable-disable TenGigabitEthernet2/0/0 disable
 523  * @cliend
 524  * @cliexcmd{nsim output-feature enable-disable <intfc> [disable]}
 525 ?*/
 526 /* *INDENT-OFF* */
 527 VLIB_CLI_COMMAND (nsim_output_feature_enable_disable_command, static) =
 528 {
 529   .path = "nsim output-feature enable-disable",
 530   .short_help =
 531   "nsim output-feature enable-disable <interface-name> [disable]",
 532   .function = nsim_output_feature_enable_disable_command_fn,
 533 };
 534 /* *INDENT-ON* */
 535
 536 #include <nsim/nsim.api.c>
 537 static clib_error_t *
 538 nsim_init (vlib_main_t * vm)
 539 {
 540   nsim_main_t *nsm = &nsim_main;
 541
 542   nsm->vlib_main = vm;
 543   nsm->vnet_main = vnet_get_main ();
 544
 545   /* Ask for a correctly-sized block of API message decode slots */
 546   nsm->msg_id_base = setup_message_id_table ();
 547   nsm->arc_index = nsm->vnet_main->interface_main.output_feature_arc_index;
 548   return 0;
 549 }
 550
 551 VLIB_INIT_FUNCTION (nsim_init);
 552
 553 /* *INDENT-OFF* */
 554 VNET_FEATURE_INIT (nsim, static) =
 555 {
 556   .arc_name = "device-input",
 557   .node_name = "nsim",
 558   .runs_before = VNET_FEATURES ("ethernet-input"),
 559 };
 560 /* *INDENT-ON */
 561
 562 /* *INDENT-OFF* */
 563 VNET_FEATURE_INIT (nsim_feature, static) = {
 564   .arc_name = "interface-output",
 565   .node_name = "nsim-output-feature",
 566   .runs_before = VNET_FEATURES ("interface-output-arc-end"),
 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 if (unformat (input, "%f gbps", &tmp))
 607     *result = tmp * 1e9;
 608   else if (unformat (input, "%f mbps", &tmp))
 609     *result = tmp * 1e6;
 610   else if (unformat (input, "%f kbps", &tmp))
 611     *result = tmp * 1e3;
 612   else if (unformat (input, "%f bps", &tmp))
 613     *result = tmp;
 614   else
 615     return 0;
 616   return 1;
 617 }
 618
 619 static u8 *
 620 format_delay (u8 *s, va_list *args)
 621 {
 622   f64 delay = va_arg (*args, f64);
 623
 624   if (delay < 1e-3)
 625     s = format (s, "%.1f us", delay * 1e6);
 626   else if (delay < 1)
 627     s = format (s, "%.1f ms", delay * 1e3);
 628   else
 629     s = format (s, "%f sec", delay);
 630
 631   return s;
 632 }
 633
 634 static u8 *
 635 format_bandwidth (u8 *s, va_list *args)
 636 {
 637   f64 bandwidth = va_arg (*args, f64);
 638
 639   if (bandwidth >= 1e9)
 640     s = format (s, "%.1f gbps", bandwidth / 1e9);
 641   else if (bandwidth >= 1e6)
 642     s = format (s, "%.1f mbps", bandwidth / 1e6);
 643   else if (bandwidth >= 1e3)
 644     s = format (s, "%.1f kbps", bandwidth / 1e3);
 645   else
 646     s = format (s, "%f bps", bandwidth);
 647
 648   return s;
 649 }
 650
 651 static u8 *
 652 format_nsim_config (u8 * s, va_list * args)
 653 {
 654   int verbose = va_arg (*args, int);
 655   nsim_main_t *nsm = &nsim_main;
 656
 657   s = format (s, "configuration\n");
 658   s = format (s, " delay: %U\n", format_delay, nsm->delay);
 659   if (nsm->drop_fraction)
 660     s = format (s, " drop fraction: %.5f\n", nsm->drop_fraction);
 661   else
 662     s = format (s, " drop fraction: 0\n");
 663   if (nsm->reorder_fraction)
 664     s = format (s, " reorder fraction: %.5f\n", nsm->reorder_fraction);
 665   else
 666     s = format (s, " reorder fraction: 0\n");
 667   s = format (s, " packet size: %u\n", nsm->packet_size);
 668   s = format (s, " worker wheel size: %u\n", nsm->wheel_slots_per_wrk);
 669   s = format (s, " throughput: %U\n", format_bandwidth, nsm->bandwidth);
 670
 671   if (verbose)
 672     {
 673       s = format (s, " poll main thread: %u\n", nsm->poll_main_thread);
 674       s = format (s, " memory: %U bytes per thread %U bytes total\n",
 675                   format_memory_size, nsm->mmap_size, format_memory_size,
 676                   nsm->mmap_size * vlib_num_workers ());
 677     }
 678
 679   s = format (s, "\n");
 680
 681   if (nsm->sw_if_index0 != 0)
 682     {
 683       s = format (s, "cross-connect\n %U and %U\n",
 684                   format_vnet_sw_if_index_name, nsm->vnet_main,
 685                   nsm->sw_if_index0, format_vnet_sw_if_index_name,
 686                   nsm->vnet_main, nsm->sw_if_index1);
 687     }
 688   else if (vec_len (nsm->output_next_index_by_sw_if_index))
 689     {
 690       int i;
 691       s = format (s, "output feature arcs to:\n");
 692       for (i = 0; i < vec_len (nsm->output_next_index_by_sw_if_index); i++)
 693         {
 694           if (nsm->output_next_index_by_sw_if_index[i] != ~0)
 695             s = format (s, " %U %u\n", format_vnet_sw_if_index_name,
 696                         nsm->vnet_main, i, i);
 697         }
 698     }
 699   else
 700     {
 701       s = format (s, " nsim not enabled\n");
 702     }
 703
 704   return s;
 705 }
 706
 707 static clib_error_t *
 708 set_nsim_command_fn (vlib_main_t * vm,
 709                      unformat_input_t * input, vlib_cli_command_t * cmd)
 710 {
 711   f64 drop_fraction = 0.0, reorder_fraction = 0.0, delay, bandwidth;
 712   u32 packets_per_drop, packets_per_reorder, packet_size = 1500;
 713   nsim_main_t *nsm = &nsim_main;
 714   int rv;
 715
 716   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 717     {
 718       if (unformat (input, "delay %U", unformat_delay, &delay))
 719         ;
 720       else if (unformat (input, "bandwidth %U", unformat_bandwidth,
 721                          &bandwidth))
 722         ;
 723       else if (unformat (input, "packet-size %u", &packet_size))
 724         ;
 725       else if (unformat (input, "packets-per-drop %d", &packets_per_drop))
 726         {
 727           if (packets_per_drop > 0)
 728             drop_fraction = 1.0 / ((f64) packets_per_drop);
 729         }
 730       else if (unformat (input, "packets-per-reorder %d",
 731                          &packets_per_reorder))
 732         {
 733           if (packets_per_reorder > 0)
 734             reorder_fraction = 1.0 / ((f64) packets_per_reorder);
 735         }
 736       else if (unformat (input, "drop-fraction %f", &drop_fraction))
 737         {
 738           if (drop_fraction < 0.0 || drop_fraction > 1.0)
 739             return clib_error_return
 740               (0, "drop fraction must be between zero and 1");
 741         }
 742       else if (unformat (input, "reorder-fraction %f", &reorder_fraction))
 743         {
 744           if (reorder_fraction < 0.0 || reorder_fraction > 1.0)
 745             return clib_error_return
 746               (0, "reorder fraction must be between zero and 1");
 747         }
 748       else if (unformat (input, "poll-main-thread"))
 749         nsm->poll_main_thread = 1;
 750       else
 751         break;
 752     }
 753
 754   rv = nsim_configure (nsm, bandwidth, delay, packet_size, drop_fraction,
 755                        reorder_fraction);
 756
 757   switch (rv)
 758     {
 759     case VNET_API_ERROR_INVALID_VALUE:
 760       return clib_error_return (0, "invalid bandwidth %.2f", bandwidth);
 761
 762     case VNET_API_ERROR_INVALID_VALUE_2:
 763       return clib_error_return (0, "invalid delay %.2f", delay);
 764
 765     case VNET_API_ERROR_INVALID_VALUE_3:
 766       return clib_error_return (0, "invalid packet size %.2f", packet_size);
 767
 768     case VNET_API_ERROR_INVALID_VALUE_4:
 769       return clib_error_return (0, "invalid reorder fraction %.3f for "
 770                                 "delay %.2f", reorder_fraction, delay);
 771
 772     default:
 773       return clib_error_return (0, "error %d", rv);
 774
 775     case 0:
 776       break;
 777     }
 778
 779   vlib_cli_output (vm, "%U", format_nsim_config, 1);
 780
 781   return 0;
 782 }
 783
 784 /*?
 785  * Configure the network simulation cross-connect
 786  * Once the simulator is configured, use the "nsim enable-disable" command
 787  * to set up a cross-connect with the supplied delay characteristics.
 788  *
 789  * The cross connect configuration may be changed without restarting vpp
 790  * but it is good practice to shut down the interfaces.
 791  *
 792  * @cliexpar
 793  * To configure the network delay simulator:
 794  * @clistart
 795  * set nsim delay 10.0 ms bandwidth 5.5 gbit packet-size 128
 796  *
 797  * @cliend
 798  * @cliexcmd{set nsim delay <nn> bandwidth <bb> packet-size <nn>}
 799 ?*/
 800 /* *INDENT-OFF* */
 801 VLIB_CLI_COMMAND (set_nsim_command, static) =
 802 {
 803   .path = "set nsim",
 804   .short_help = "set nsim delay <time> bandwidth <bps> packet-size <nbytes>\n"
 805   "    [packets-per-drop <nn>][drop-fraction <f64: 0.0 - 1.0>]",
 806   .function = set_nsim_command_fn,
 807 };
 808 /* *INDENT-ON*/
 809
 810
 811 static clib_error_t *
 812 show_nsim_command_fn (vlib_main_t * vm,
 813                       unformat_input_t * input, vlib_cli_command_t * cmd)
 814 {
 815   nsim_main_t *nsm = &nsim_main;
 816   int verbose = 0;
 817
 818   if (nsm->is_configured == 0)
 819     return clib_error_return (0, "Network simulator not configured");
 820
 821   if (unformat (input, "verbose"))
 822     verbose = 1;
 823
 824   vlib_cli_output (vm, "%U", format_nsim_config, verbose);
 825
 826   return 0;
 827 }
 828
 829 /*?
 830  * Display state info for the network delay simulator.
 831  *
 832  * @cliexpar
 833  * To display the state of the network simulator
 834  * @clistart
 835  * show nsim verbose
 836  * Network simulator cross-connects TenGigabitEthernet2/0/0 and TenGigabitEthernet2/0/1
 837  * ...inserting link delay of 10.00 ms, 20.00 ms round-trip
 838  *  Configured bandwidth: 10.10 gbit/sec
 839  *  Configured packet size: 128
 840  *  Sim uses 157814784 bytes total
 841  * @cliend
 842  * @cliexcmd{show nsim}
 843 ?*/
 844
 845 /* *INDENT-OFF* */
 846 VLIB_CLI_COMMAND (show_nsim_command, static) =
 847 {
 848   .path = "show nsim",
 849   .short_help = "Display network delay simulator configuration",
 850   .function = show_nsim_command_fn,
 851 };
 852 /* *INDENT-ON* */
 853
 854 /*
 855  * fd.io coding-style-patch-verification: ON
 856  *
 857  * Local Variables:
 858  * eval: (c-set-style "gnu")
 859  * End:
 860  */