src/vnet/pg/cli.c

   1 /*
   2  * Copyright (c) 2015 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  * pg_cli.c: packet generator cli
  17  *
  18  * Copyright (c) 2008 Eliot Dresselhaus
  19  *
  20  * Permission is hereby granted, free of charge, to any person obtaining
  21  * a copy of this software and associated documentation files (the
  22  * "Software"), to deal in the Software without restriction, including
  23  * without limitation the rights to use, copy, modify, merge, publish,
  24  * distribute, sublicense, and/or sell copies of the Software, and to
  25  * permit persons to whom the Software is furnished to do so, subject to
  26  * the following conditions:
  27  *
  28  * The above copyright notice and this permission notice shall be
  29  * included in all copies or substantial portions of the Software.
  30  *
  31  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  32  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  33  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  34  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  35  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  36  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  37  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  38  */
  39
  40 #include <sys/stat.h>
  41
  42 #include <vnet/vnet.h>
  43 #include <vnet/pg/pg.h>
  44
  45 #include <strings.h>
  46 #include <vppinfra/pcap.h>
  47
  48
  49 /* Root of all packet generator cli commands. */
  50 /* *INDENT-OFF* */
  51 VLIB_CLI_COMMAND (vlib_cli_pg_command, static) = {
  52   .path = "packet-generator",
  53   .short_help = "Packet generator commands",
  54 };
  55 /* *INDENT-ON* */
  56
  57 void
  58 pg_enable_disable (u32 stream_index, int is_enable)
  59 {
  60   pg_main_t *pg = &pg_main;
  61   pg_stream_t *s;
  62
  63   if (stream_index == ~0)
  64     {
  65       /* No stream specified: enable/disable all streams. */
  66       /* *INDENT-OFF* */
  67         pool_foreach (s, pg->streams, ({
  68             pg_stream_enable_disable (pg, s, is_enable);
  69         }));
  70         /* *INDENT-ON* */
  71     }
  72   else
  73     {
  74       /* enable/disable specified stream. */
  75       s = pool_elt_at_index (pg->streams, stream_index);
  76       pg_stream_enable_disable (pg, s, is_enable);
  77     }
  78 }
  79
  80 clib_error_t *
  81 pg_capture (pg_capture_args_t * a)
  82 {
  83   pg_main_t *pg = &pg_main;
  84   pg_interface_t *pi;
  85
  86   if (a->is_enabled == 1)
  87     {
  88       struct stat sb;
  89       if (stat ((char *) a->pcap_file_name, &sb) != -1)
  90         return clib_error_return (0, "Cannot create pcap file");
  91     }
  92
  93   pi = pool_elt_at_index (pg->interfaces, a->dev_instance);
  94   vec_free (pi->pcap_file_name);
  95   clib_memset (&pi->pcap_main, 0, sizeof (pi->pcap_main));
  96
  97   if (a->is_enabled == 0)
  98     return 0;
  99
 100   pi->pcap_file_name = a->pcap_file_name;
 101   pi->pcap_main.file_name = (char *) pi->pcap_file_name;
 102   pi->pcap_main.n_packets_to_capture = a->count;
 103   pi->pcap_main.packet_type = PCAP_PACKET_TYPE_ethernet;
 104
 105   return 0;
 106 }
 107
 108 static clib_error_t *
 109 enable_disable_stream (vlib_main_t * vm,
 110                        unformat_input_t * input, vlib_cli_command_t * cmd)
 111 {
 112   unformat_input_t _line_input, *line_input = &_line_input;
 113   pg_main_t *pg = &pg_main;
 114   int is_enable = cmd->function_arg != 0;
 115   u32 stream_index = ~0;
 116
 117   if (!unformat_user (input, unformat_line_input, line_input))
 118     goto doit;
 119
 120   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 121     {
 122       if (unformat (line_input, "%U", unformat_hash_vec_string,
 123                     pg->stream_index_by_name, &stream_index))
 124         ;
 125       else
 126         return clib_error_create ("unknown input `%U'",
 127                                   format_unformat_error, line_input);
 128     }
 129   unformat_free (line_input);
 130
 131 doit:
 132   pg_enable_disable (stream_index, is_enable);
 133
 134   return 0;
 135 }
 136
 137 /* *INDENT-OFF* */
 138 VLIB_CLI_COMMAND (enable_streams_cli, static) = {
 139   .path = "packet-generator enable-stream",
 140   .short_help = "Enable packet generator streams",
 141   .function = enable_disable_stream,
 142   .function_arg = 1,            /* is_enable */
 143 };
 144 /* *INDENT-ON* */
 145
 146 /* *INDENT-OFF* */
 147 VLIB_CLI_COMMAND (disable_streams_cli, static) = {
 148   .path = "packet-generator disable-stream",
 149   .short_help = "Disable packet generator streams",
 150   .function = enable_disable_stream,
 151   .function_arg = 0,            /* is_enable */
 152 };
 153 /* *INDENT-ON* */
 154
 155 static u8 *
 156 format_pg_edit_group (u8 * s, va_list * va)
 157 {
 158   pg_edit_group_t *g = va_arg (*va, pg_edit_group_t *);
 159
 160   s =
 161     format (s, "hdr-size %d, offset %d, ", g->n_packet_bytes,
 162             g->start_byte_offset);
 163   if (g->edit_function)
 164     {
 165       u8 *function_name;
 166       u8 *junk_after_name;
 167       function_name = format (0, "%U%c", format_clib_elf_symbol_with_address,
 168                               g->edit_function, 0);
 169       junk_after_name = function_name;
 170       while (*junk_after_name && *junk_after_name != ' ')
 171         junk_after_name++;
 172       *junk_after_name = 0;
 173       s = format (s, "edit-function %s, ", function_name);
 174       vec_free (function_name);
 175     }
 176
 177   return s;
 178 }
 179
 180 static u8 *
 181 format_pg_stream (u8 * s, va_list * va)
 182 {
 183   pg_stream_t *t = va_arg (*va, pg_stream_t *);
 184   int verbose = va_arg (*va, int);
 185
 186   if (!t)
 187     return format (s, "%-16s%=12s%=16s%s",
 188                    "Name", "Enabled", "Count", "Parameters");
 189
 190   s = format (s, "%-16v%=12s%=16Ld",
 191               t->name,
 192               pg_stream_is_enabled (t) ? "Yes" : "No",
 193               t->n_packets_generated);
 194
 195   int indent = format_get_indent (s);
 196
 197   s = format (s, "limit %Ld, ", t->n_packets_limit);
 198   s = format (s, "rate %.2e pps, ", t->rate_packets_per_second);
 199   s = format (s, "size %d%c%d, ",
 200               t->min_packet_bytes,
 201               t->packet_size_edit_type == PG_EDIT_RANDOM ? '+' : '-',
 202               t->max_packet_bytes);
 203   s = format (s, "buffer-size %d, ", t->buffer_bytes);
 204   s = format (s, "worker %d, ", t->worker_index);
 205
 206   if (verbose)
 207     {
 208       pg_edit_group_t *g;
 209   /* *INDENT-OFF* */
 210   vec_foreach (g, t->edit_groups)
 211     {
 212       s = format (s, "\n%U%U", format_white_space, indent, format_pg_edit_group, g);
 213     }
 214   /* *INDENT-ON* */
 215     }
 216
 217   return s;
 218 }
 219
 220 static clib_error_t *
 221 show_streams (vlib_main_t * vm,
 222               unformat_input_t * input, vlib_cli_command_t * cmd)
 223 {
 224   pg_main_t *pg = &pg_main;
 225   pg_stream_t *s;
 226   int verbose = 0;
 227
 228   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 229     {
 230       if (unformat (input, "verbose"))
 231         verbose = 1;
 232       else
 233         break;
 234     }
 235
 236   if (pool_elts (pg->streams) == 0)
 237     {
 238       vlib_cli_output (vm, "no streams currently defined");
 239       goto done;
 240     }
 241
 242   vlib_cli_output (vm, "%U", format_pg_stream, 0, 0);
 243   /* *INDENT-OFF* */
 244   pool_foreach (s, pg->streams, ({
 245       vlib_cli_output (vm, "%U", format_pg_stream, s, verbose);
 246     }));
 247   /* *INDENT-ON* */
 248
 249 done:
 250   return 0;
 251 }
 252
 253 /* *INDENT-OFF* */
 254 VLIB_CLI_COMMAND (show_streams_cli, static) = {
 255   .path = "show packet-generator ",
 256   .short_help = "show packet-generator [verbose]",
 257   .function = show_streams,
 258 };
 259 /* *INDENT-ON* */
 260
 261 static clib_error_t *
 262 pg_pcap_read (pg_stream_t * s, char *file_name)
 263 {
 264 #ifndef CLIB_UNIX
 265   return clib_error_return (0, "no pcap support");
 266 #else
 267   pcap_main_t pm;
 268   clib_error_t *error;
 269   clib_memset (&pm, 0, sizeof (pm));
 270   pm.file_name = file_name;
 271   error = pcap_read (&pm);
 272   s->replay_packet_templates = pm.packets_read;
 273   s->replay_packet_timestamps = pm.timestamps;
 274   s->min_packet_bytes = pm.min_packet_bytes;
 275   s->max_packet_bytes = pm.max_packet_bytes;
 276   s->buffer_bytes = pm.max_packet_bytes;
 277
 278   if (s->n_packets_limit == 0)
 279     s->n_packets_limit = vec_len (pm.packets_read);
 280
 281   return error;
 282 #endif /* CLIB_UNIX */
 283 }
 284
 285 static uword
 286 unformat_pg_stream_parameter (unformat_input_t * input, va_list * args)
 287 {
 288   pg_stream_t *s = va_arg (*args, pg_stream_t *);
 289   f64 x;
 290
 291   if (unformat (input, "limit %f", &x))
 292     s->n_packets_limit = x;
 293
 294   else if (unformat (input, "rate %f", &x))
 295     s->rate_packets_per_second = x;
 296
 297   else if (unformat (input, "size %d-%d", &s->min_packet_bytes,
 298                      &s->max_packet_bytes))
 299     s->packet_size_edit_type = PG_EDIT_INCREMENT;
 300
 301   else if (unformat (input, "size %d+%d", &s->min_packet_bytes,
 302                      &s->max_packet_bytes))
 303     s->packet_size_edit_type = PG_EDIT_RANDOM;
 304
 305   else if (unformat (input, "buffer-size %d", &s->buffer_bytes))
 306     ;
 307
 308   else
 309     return 0;
 310
 311   return 1;
 312 }
 313
 314 static clib_error_t *
 315 validate_stream (pg_stream_t * s)
 316 {
 317   if (s->max_packet_bytes < s->min_packet_bytes)
 318     return clib_error_create ("max-size < min-size");
 319
 320   u32 hdr_size = pg_edit_group_n_bytes (s, 0);
 321   if (s->min_packet_bytes < hdr_size)
 322     return clib_error_create ("min-size < total header size %d", hdr_size);
 323   if (s->buffer_bytes == 0)
 324     return clib_error_create ("buffer-size must be positive");
 325
 326   if (s->rate_packets_per_second < 0)
 327     return clib_error_create ("negative rate");
 328
 329   return 0;
 330 }
 331
 332 static clib_error_t *
 333 new_stream (vlib_main_t * vm,
 334             unformat_input_t * input, vlib_cli_command_t * cmd)
 335 {
 336   clib_error_t *error = 0;
 337   u8 *tmp = 0;
 338   u32 hw_if_index;
 339   unformat_input_t sub_input = { 0 };
 340   int sub_input_given = 0;
 341   vnet_main_t *vnm = vnet_get_main ();
 342   pg_main_t *pg = &pg_main;
 343   pg_stream_t s = { 0 };
 344   char *pcap_file_name;
 345
 346   s.sw_if_index[VLIB_RX] = s.sw_if_index[VLIB_TX] = ~0;
 347   s.node_index = ~0;
 348   s.max_packet_bytes = s.min_packet_bytes = 64;
 349   s.buffer_bytes = vlib_buffer_get_default_data_size (vm);
 350   s.if_id = 0;
 351   pcap_file_name = 0;
 352   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 353     {
 354       if (unformat (input, "name %v", &tmp))
 355         {
 356           if (s.name)
 357             vec_free (s.name);
 358           s.name = tmp;
 359         }
 360
 361       else if (unformat (input, "node %U",
 362                          unformat_vnet_hw_interface, vnm, &hw_if_index))
 363         {
 364           vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 365
 366           s.node_index = hi->output_node_index;
 367           s.sw_if_index[VLIB_TX] = hi->sw_if_index;
 368         }
 369
 370       else if (unformat (input, "source pg%u", &s.if_id))
 371         ;
 372
 373       else if (unformat (input, "node %U",
 374                          unformat_vlib_node, vm, &s.node_index))
 375         ;
 376
 377       else if (unformat (input, "worker %u", &s.worker_index))
 378         ;
 379
 380       else if (unformat (input, "interface %U",
 381                          unformat_vnet_sw_interface, vnm,
 382                          &s.sw_if_index[VLIB_RX]))
 383         ;
 384       else if (unformat (input, "tx-interface %U",
 385                          unformat_vnet_sw_interface, vnm,
 386                          &s.sw_if_index[VLIB_TX]))
 387         ;
 388
 389       else if (unformat (input, "pcap %s", &pcap_file_name))
 390         ;
 391
 392       else if (!sub_input_given
 393                && unformat (input, "data %U", unformat_input, &sub_input))
 394         sub_input_given++;
 395
 396       else if (unformat_user (input, unformat_pg_stream_parameter, &s))
 397         ;
 398
 399       else
 400         {
 401           error = clib_error_create ("unknown input `%U'",
 402                                      format_unformat_error, input);
 403           goto done;
 404         }
 405     }
 406
 407   if (!sub_input_given && !pcap_file_name)
 408     {
 409       error = clib_error_create ("no packet data given");
 410       goto done;
 411     }
 412
 413   if (s.node_index == ~0)
 414     {
 415       if (pcap_file_name != 0)
 416         {
 417           vlib_node_t *n =
 418             vlib_get_node_by_name (vm, (u8 *) "ethernet-input");
 419           s.node_index = n->index;
 420         }
 421       else
 422         {
 423           error = clib_error_create ("output interface or node not given");
 424           goto done;
 425         }
 426     }
 427
 428   {
 429     pg_node_t *n;
 430
 431     if (s.node_index < vec_len (pg->nodes))
 432       n = pg->nodes + s.node_index;
 433     else
 434       n = 0;
 435
 436     if (s.worker_index >= vlib_num_workers ())
 437       s.worker_index = 0;
 438
 439     if (pcap_file_name != 0)
 440       {
 441         error = pg_pcap_read (&s, pcap_file_name);
 442         if (error)
 443           goto done;
 444         vec_free (pcap_file_name);
 445       }
 446
 447     else if (n && n->unformat_edit
 448              && unformat_user (&sub_input, n->unformat_edit, &s))
 449       ;
 450
 451     else if (!unformat_user (&sub_input, unformat_pg_payload, &s))
 452       {
 453         error = clib_error_create
 454           ("failed to parse packet data from `%U'",
 455            format_unformat_error, &sub_input);
 456         goto done;
 457       }
 458   }
 459
 460   error = validate_stream (&s);
 461   if (error)
 462     return error;
 463
 464   pg_stream_add (pg, &s);
 465   return 0;
 466
 467 done:
 468   pg_stream_free (&s);
 469   unformat_free (&sub_input);
 470   return error;
 471 }
 472
 473 /* *INDENT-OFF* */
 474 VLIB_CLI_COMMAND (new_stream_cli, static) = {
 475   .path = "packet-generator new",
 476   .function = new_stream,
 477   .short_help = "Create packet generator stream",
 478   .long_help =
 479   "Create packet generator stream\n"
 480   "\n"
 481   "Arguments:\n"
 482   "\n"
 483   "name STRING          sets stream name\n"
 484   "interface STRING     interface for stream output \n"
 485   "node NODE-NAME       node for stream output\n"
 486   "data STRING          specifies packet data\n"
 487   "pcap FILENAME        read packet data from pcap file\n",
 488 };
 489 /* *INDENT-ON* */
 490
 491 static clib_error_t *
 492 del_stream (vlib_main_t * vm,
 493             unformat_input_t * input, vlib_cli_command_t * cmd)
 494 {
 495   pg_main_t *pg = &pg_main;
 496   u32 i;
 497
 498   if (!unformat (input, "%U",
 499                  &unformat_hash_vec_string, pg->stream_index_by_name, &i))
 500     return clib_error_create ("expected stream name `%U'",
 501                               format_unformat_error, input);
 502
 503   pg_stream_del (pg, i);
 504   return 0;
 505 }
 506
 507 /* *INDENT-OFF* */
 508 VLIB_CLI_COMMAND (del_stream_cli, static) = {
 509   .path = "packet-generator delete",
 510   .function = del_stream,
 511   .short_help = "Delete stream with given name",
 512 };
 513 /* *INDENT-ON* */
 514
 515 static clib_error_t *
 516 change_stream_parameters (vlib_main_t * vm,
 517                           unformat_input_t * input, vlib_cli_command_t * cmd)
 518 {
 519   pg_main_t *pg = &pg_main;
 520   pg_stream_t *s, s_new;
 521   u32 stream_index = ~0;
 522   clib_error_t *error;
 523
 524   if (unformat (input, "%U", unformat_hash_vec_string,
 525                 pg->stream_index_by_name, &stream_index))
 526     ;
 527   else
 528     return clib_error_create ("expecting stream name; got `%U'",
 529                               format_unformat_error, input);
 530
 531   s = pool_elt_at_index (pg->streams, stream_index);
 532   s_new = s[0];
 533
 534   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 535     {
 536       if (unformat_user (input, unformat_pg_stream_parameter, &s_new))
 537         ;
 538
 539       else
 540         return clib_error_create ("unknown input `%U'",
 541                                   format_unformat_error, input);
 542     }
 543
 544   error = validate_stream (&s_new);
 545   if (!error)
 546     {
 547       s[0] = s_new;
 548       pg_stream_change (pg, s);
 549     }
 550
 551   return error;
 552 }
 553
 554 /* *INDENT-OFF* */
 555 VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = {
 556   .path = "packet-generator configure",
 557   .short_help = "Change packet generator stream parameters",
 558   .function = change_stream_parameters,
 559 };
 560 /* *INDENT-ON* */
 561
 562 static clib_error_t *
 563 pg_capture_cmd_fn (vlib_main_t * vm,
 564                    unformat_input_t * input, vlib_cli_command_t * cmd)
 565 {
 566   clib_error_t *error = 0;
 567   vnet_main_t *vnm = vnet_get_main ();
 568   unformat_input_t _line_input, *line_input = &_line_input;
 569   vnet_hw_interface_t *hi = 0;
 570   u8 *pcap_file_name = 0;
 571   u32 hw_if_index;
 572   u32 is_disable = 0;
 573   u32 count = ~0;
 574
 575   if (!unformat_user (input, unformat_line_input, line_input))
 576     return 0;
 577
 578   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 579     {
 580       if (unformat (line_input, "%U",
 581                     unformat_vnet_hw_interface, vnm, &hw_if_index))
 582         {
 583           hi = vnet_get_hw_interface (vnm, hw_if_index);
 584         }
 585
 586       else if (unformat (line_input, "pcap %s", &pcap_file_name))
 587         ;
 588       else if (unformat (line_input, "count %u", &count))
 589         ;
 590       else if (unformat (line_input, "disable"))
 591         is_disable = 1;
 592
 593       else
 594         {
 595           error = clib_error_create ("unknown input `%U'",
 596                                      format_unformat_error, line_input);
 597           goto done;
 598         }
 599     }
 600
 601   if (!hi)
 602     {
 603       error = clib_error_return (0, "Please specify interface name");
 604       goto done;
 605     }
 606
 607   if (hi->dev_class_index != pg_dev_class.index)
 608     {
 609       error =
 610         clib_error_return (0, "Please specify packet-generator interface");
 611       goto done;
 612     }
 613
 614   if (!pcap_file_name && is_disable == 0)
 615     {
 616       error = clib_error_return (0, "Please specify pcap file name");
 617       goto done;
 618     }
 619
 620
 621   pg_capture_args_t _a, *a = &_a;
 622
 623   a->hw_if_index = hw_if_index;
 624   a->dev_instance = hi->dev_instance;
 625   a->is_enabled = !is_disable;
 626   a->pcap_file_name = pcap_file_name;
 627   a->count = count;
 628
 629   error = pg_capture (a);
 630
 631 done:
 632   unformat_free (line_input);
 633
 634   return error;
 635 }
 636
 637 /* *INDENT-OFF* */
 638 VLIB_CLI_COMMAND (pg_capture_cmd, static) = {
 639   .path = "packet-generator capture",
 640   .short_help = "packet-generator capture <interface name> pcap <filename> [count <n>]",
 641   .function = pg_capture_cmd_fn,
 642 };
 643 /* *INDENT-ON* */
 644
 645 static clib_error_t *
 646 create_pg_if_cmd_fn (vlib_main_t * vm,
 647                      unformat_input_t * input, vlib_cli_command_t * cmd)
 648 {
 649   pg_main_t *pg = &pg_main;
 650   unformat_input_t _line_input, *line_input = &_line_input;
 651   u32 if_id;
 652   clib_error_t *error = NULL;
 653
 654   if (!unformat_user (input, unformat_line_input, line_input))
 655     return 0;
 656
 657   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 658     {
 659       if (unformat (line_input, "interface pg%u", &if_id))
 660         ;
 661
 662       else
 663         {
 664           error = clib_error_create ("unknown input `%U'",
 665                                      format_unformat_error, line_input);
 666           goto done;
 667         }
 668     }
 669
 670   pg_interface_add_or_get (pg, if_id);
 671
 672 done:
 673   unformat_free (line_input);
 674
 675   return error;
 676 }
 677
 678 /* *INDENT-OFF* */
 679 VLIB_CLI_COMMAND (create_pg_if_cmd, static) = {
 680   .path = "create packet-generator",
 681   .short_help = "create packet-generator interface <interface name>",
 682   .function = create_pg_if_cmd_fn,
 683 };
 684 /* *INDENT-ON* */
 685
 686 /* Dummy init function so that we can be linked in. */
 687 static clib_error_t *
 688 pg_cli_init (vlib_main_t * vm)
 689 {
 690   return 0;
 691 }
 692
 693 VLIB_INIT_FUNCTION (pg_cli_init);
 694
 695 /*
 696  * fd.io coding-style-patch-verification: ON
 697  *
 698  * Local Variables:
 699  * eval: (c-set-style "gnu")
 700  * End:
 701  */