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 #ifdef CLIB_UNIX
  46 #include <vnet/unix/pcap.h>
  47 #endif
  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   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   pg_main_t *pg = &pg_main;
 113   int is_enable = cmd->function_arg != 0;
 114   u32 stream_index = ~0;
 115
 116   if (unformat (input, "%U", unformat_eof))
 117     ;
 118   else if (unformat (input, "%U", unformat_hash_vec_string,
 119                      pg->stream_index_by_name, &stream_index))
 120     ;
 121   else
 122     return clib_error_create ("unknown input `%U'",
 123                               format_unformat_error, input);
 124
 125   pg_enable_disable (stream_index, is_enable);
 126
 127   return 0;
 128 }
 129
 130 /* *INDENT-OFF* */
 131 VLIB_CLI_COMMAND (enable_streams_cli, static) = {
 132   .path = "packet-generator enable-stream",
 133   .short_help = "Enable packet generator streams",
 134   .function = enable_disable_stream,
 135   .function_arg = 1,            /* is_enable */
 136 };
 137 /* *INDENT-ON* */
 138
 139 /* *INDENT-OFF* */
 140 VLIB_CLI_COMMAND (disable_streams_cli, static) = {
 141   .path = "packet-generator disable-stream",
 142   .short_help = "Disable packet generator streams",
 143   .function = enable_disable_stream,
 144   .function_arg = 0,            /* is_enable */
 145 };
 146 /* *INDENT-ON* */
 147
 148 static u8 *
 149 format_pg_stream (u8 * s, va_list * va)
 150 {
 151   pg_stream_t *t = va_arg (*va, pg_stream_t *);
 152   u8 *v;
 153
 154   if (!t)
 155     return format (s, "%=16s%=12s%=16s%s",
 156                    "Name", "Enabled", "Count", "Parameters");
 157
 158   s = format (s, "%-16v%=12s%16Ld",
 159               t->name,
 160               pg_stream_is_enabled (t) ? "Yes" : "No",
 161               t->n_packets_generated);
 162
 163   v = 0;
 164
 165   v = format (v, "limit %Ld, ", t->n_packets_limit);
 166
 167   v = format (v, "rate %.2e pps, ", t->rate_packets_per_second);
 168
 169   v = format (v, "size %d%c%d, ",
 170               t->min_packet_bytes,
 171               t->packet_size_edit_type == PG_EDIT_RANDOM ? '+' : '-',
 172               t->max_packet_bytes);
 173
 174   v = format (v, "buffer-size %d, ", t->buffer_bytes);
 175
 176   v = format (v, "worker %d, ", t->worker_index);
 177
 178   if (v)
 179     {
 180       s = format (s, "  %v", v);
 181       vec_free (v);
 182     }
 183
 184   return s;
 185 }
 186
 187 static clib_error_t *
 188 show_streams (vlib_main_t * vm,
 189               unformat_input_t * input, vlib_cli_command_t * cmd)
 190 {
 191   pg_main_t *pg = &pg_main;
 192   pg_stream_t *s;
 193
 194   if (pool_elts (pg->streams) == 0)
 195     {
 196       vlib_cli_output (vm, "no streams currently defined");
 197       goto done;
 198     }
 199
 200   vlib_cli_output (vm, "%U", format_pg_stream, 0);
 201   /* *INDENT-OFF* */
 202   pool_foreach (s, pg->streams, ({
 203       vlib_cli_output (vm, "%U", format_pg_stream, s);
 204     }));
 205   /* *INDENT-ON* */
 206
 207 done:
 208   return 0;
 209 }
 210
 211 /* *INDENT-OFF* */
 212 VLIB_CLI_COMMAND (show_streams_cli, static) = {
 213   .path = "show packet-generator",
 214   .short_help = "Show packet generator streams",
 215   .function = show_streams,
 216 };
 217 /* *INDENT-ON* */
 218
 219 static clib_error_t *
 220 pg_pcap_read (pg_stream_t * s, char *file_name)
 221 {
 222 #ifndef CLIB_UNIX
 223   return clib_error_return (0, "no pcap support");
 224 #else
 225   pcap_main_t pm;
 226   clib_error_t *error;
 227   memset (&pm, 0, sizeof (pm));
 228   pm.file_name = file_name;
 229   error = pcap_read (&pm);
 230   s->replay_packet_templates = pm.packets_read;
 231   s->replay_packet_timestamps = pm.timestamps;
 232   s->min_packet_bytes = pm.min_packet_bytes;
 233   s->max_packet_bytes = pm.max_packet_bytes;
 234   s->buffer_bytes = pm.max_packet_bytes;
 235   /* For PCAP buffers we never re-use buffers. */
 236   s->flags |= PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE;
 237
 238   if (s->n_packets_limit == 0)
 239     s->n_packets_limit = vec_len (pm.packets_read);
 240
 241   return error;
 242 #endif /* CLIB_UNIX */
 243 }
 244
 245 static uword
 246 unformat_pg_stream_parameter (unformat_input_t * input, va_list * args)
 247 {
 248   pg_stream_t *s = va_arg (*args, pg_stream_t *);
 249   f64 x;
 250
 251   if (unformat (input, "limit %f", &x))
 252     s->n_packets_limit = x;
 253
 254   else if (unformat (input, "rate %f", &x))
 255     s->rate_packets_per_second = x;
 256
 257   else if (unformat (input, "size %d-%d", &s->min_packet_bytes,
 258                      &s->max_packet_bytes))
 259     s->packet_size_edit_type = PG_EDIT_INCREMENT;
 260
 261   else if (unformat (input, "size %d+%d", &s->min_packet_bytes,
 262                      &s->max_packet_bytes))
 263     s->packet_size_edit_type = PG_EDIT_RANDOM;
 264
 265   else if (unformat (input, "buffer-size %d", &s->buffer_bytes))
 266     ;
 267
 268   else
 269     return 0;
 270
 271   return 1;
 272 }
 273
 274 static clib_error_t *
 275 validate_stream (pg_stream_t * s)
 276 {
 277   if (s->max_packet_bytes < s->min_packet_bytes)
 278     return clib_error_create ("max-size < min-size");
 279
 280   if (s->buffer_bytes >= 4096 || s->buffer_bytes == 0)
 281     return
 282       clib_error_create ("buffer-size must be positive and < 4096, given %d",
 283                          s->buffer_bytes);
 284
 285   if (s->rate_packets_per_second < 0)
 286     return clib_error_create ("negative rate");
 287
 288   return 0;
 289 }
 290
 291 static clib_error_t *
 292 new_stream (vlib_main_t * vm,
 293             unformat_input_t * input, vlib_cli_command_t * cmd)
 294 {
 295   clib_error_t *error = 0;
 296   u8 *tmp = 0;
 297   u32 hw_if_index;
 298   unformat_input_t sub_input = { 0 };
 299   int sub_input_given = 0;
 300   vnet_main_t *vnm = vnet_get_main ();
 301   pg_main_t *pg = &pg_main;
 302   pg_stream_t s = { 0 };
 303   char *pcap_file_name;
 304
 305   s.sw_if_index[VLIB_RX] = s.sw_if_index[VLIB_TX] = ~0;
 306   s.node_index = ~0;
 307   s.max_packet_bytes = s.min_packet_bytes = 64;
 308   s.buffer_bytes = VLIB_BUFFER_DEFAULT_FREE_LIST_BYTES;
 309   s.if_id = 0;
 310   pcap_file_name = 0;
 311   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 312     {
 313       if (unformat (input, "name %v", &tmp))
 314         {
 315           if (s.name)
 316             vec_free (s.name);
 317           s.name = tmp;
 318         }
 319
 320       else if (unformat (input, "node %U",
 321                          unformat_vnet_hw_interface, vnm, &hw_if_index))
 322         {
 323           vnet_hw_interface_t *hi = vnet_get_hw_interface (vnm, hw_if_index);
 324
 325           s.node_index = hi->output_node_index;
 326           s.sw_if_index[VLIB_TX] = hi->sw_if_index;
 327         }
 328
 329       else if (unformat (input, "source pg%u", &s.if_id))
 330         ;
 331
 332       else if (unformat (input, "node %U",
 333                          unformat_vlib_node, vm, &s.node_index))
 334         ;
 335
 336       else if (unformat (input, "worker %u", &s.worker_index))
 337         ;
 338
 339       else if (unformat (input, "interface %U",
 340                          unformat_vnet_sw_interface, vnm,
 341                          &s.sw_if_index[VLIB_RX]))
 342         ;
 343
 344       else if (unformat (input, "pcap %s", &pcap_file_name))
 345         ;
 346
 347       else if (!sub_input_given
 348                && unformat (input, "data %U", unformat_input, &sub_input))
 349         sub_input_given++;
 350
 351       else if (unformat_user (input, unformat_pg_stream_parameter, &s))
 352         ;
 353
 354       else if (unformat (input, "no-recycle"))
 355         s.flags |= PG_STREAM_FLAGS_DISABLE_BUFFER_RECYCLE;
 356
 357       else
 358         {
 359           error = clib_error_create ("unknown input `%U'",
 360                                      format_unformat_error, input);
 361           goto done;
 362         }
 363     }
 364
 365   error = validate_stream (&s);
 366   if (error)
 367     return error;
 368
 369   if (!sub_input_given && !pcap_file_name)
 370     {
 371       error = clib_error_create ("no packet data given");
 372       goto done;
 373     }
 374
 375   if (s.node_index == ~0)
 376     {
 377       if (pcap_file_name != 0)
 378         {
 379           vlib_node_t *n =
 380             vlib_get_node_by_name (vm, (u8 *) "ethernet-input");
 381           s.node_index = n->index;
 382         }
 383       else
 384         {
 385           error = clib_error_create ("output interface or node not given");
 386           goto done;
 387         }
 388     }
 389
 390   {
 391     pg_node_t *n;
 392
 393     if (s.node_index < vec_len (pg->nodes))
 394       n = pg->nodes + s.node_index;
 395     else
 396       n = 0;
 397
 398     if (s.worker_index >= vlib_num_workers ())
 399       s.worker_index = 0;
 400
 401     if (pcap_file_name != 0)
 402       {
 403         error = pg_pcap_read (&s, pcap_file_name);
 404         if (error)
 405           goto done;
 406         vec_free (pcap_file_name);
 407       }
 408
 409     else if (n && n->unformat_edit
 410              && unformat_user (&sub_input, n->unformat_edit, &s))
 411       ;
 412
 413     else if (!unformat_user (&sub_input, unformat_pg_payload, &s))
 414       {
 415         error = clib_error_create
 416           ("failed to parse packet data from `%U'",
 417            format_unformat_error, &sub_input);
 418         goto done;
 419       }
 420   }
 421
 422   pg_stream_add (pg, &s);
 423   return 0;
 424
 425 done:
 426   pg_stream_free (&s);
 427   unformat_free (&sub_input);
 428   return error;
 429 }
 430
 431 /* *INDENT-OFF* */
 432 VLIB_CLI_COMMAND (new_stream_cli, static) = {
 433   .path = "packet-generator new",
 434   .function = new_stream,
 435   .short_help = "Create packet generator stream",
 436   .long_help =
 437   "Create packet generator stream\n"
 438   "\n"
 439   "Arguments:\n"
 440   "\n"
 441   "name STRING          sets stream name\n"
 442   "interface STRING     interface for stream output \n"
 443   "node NODE-NAME       node for stream output\n"
 444   "data STRING          specifies packet data\n"
 445   "pcap FILENAME        read packet data from pcap file\n",
 446 };
 447 /* *INDENT-ON* */
 448
 449 static clib_error_t *
 450 del_stream (vlib_main_t * vm,
 451             unformat_input_t * input, vlib_cli_command_t * cmd)
 452 {
 453   pg_main_t *pg = &pg_main;
 454   u32 i;
 455
 456   if (!unformat (input, "%U",
 457                  &unformat_hash_vec_string, pg->stream_index_by_name, &i))
 458     return clib_error_create ("expected stream name `%U'",
 459                               format_unformat_error, input);
 460
 461   pg_stream_del (pg, i);
 462   return 0;
 463 }
 464
 465 /* *INDENT-OFF* */
 466 VLIB_CLI_COMMAND (del_stream_cli, static) = {
 467   .path = "packet-generator delete",
 468   .function = del_stream,
 469   .short_help = "Delete stream with given name",
 470 };
 471 /* *INDENT-ON* */
 472
 473 static clib_error_t *
 474 change_stream_parameters (vlib_main_t * vm,
 475                           unformat_input_t * input, vlib_cli_command_t * cmd)
 476 {
 477   pg_main_t *pg = &pg_main;
 478   pg_stream_t *s, s_new;
 479   u32 stream_index = ~0;
 480   clib_error_t *error;
 481
 482   if (unformat (input, "%U", unformat_hash_vec_string,
 483                 pg->stream_index_by_name, &stream_index))
 484     ;
 485   else
 486     return clib_error_create ("expecting stream name; got `%U'",
 487                               format_unformat_error, input);
 488
 489   s = pool_elt_at_index (pg->streams, stream_index);
 490   s_new = s[0];
 491
 492   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 493     {
 494       if (unformat_user (input, unformat_pg_stream_parameter, &s_new))
 495         ;
 496
 497       else
 498         return clib_error_create ("unknown input `%U'",
 499                                   format_unformat_error, input);
 500     }
 501
 502   error = validate_stream (&s_new);
 503   if (!error)
 504     s[0] = s_new;
 505
 506   return error;
 507 }
 508
 509 /* *INDENT-OFF* */
 510 VLIB_CLI_COMMAND (change_stream_parameters_cli, static) = {
 511   .path = "packet-generator configure",
 512   .short_help = "Change packet generator stream parameters",
 513   .function = change_stream_parameters,
 514 };
 515 /* *INDENT-ON* */
 516
 517 static clib_error_t *
 518 pg_capture_cmd_fn (vlib_main_t * vm,
 519                    unformat_input_t * input, vlib_cli_command_t * cmd)
 520 {
 521   clib_error_t *error = 0;
 522   vnet_main_t *vnm = vnet_get_main ();
 523   unformat_input_t _line_input, *line_input = &_line_input;
 524   vnet_hw_interface_t *hi = 0;
 525   u8 *pcap_file_name = 0;
 526   u32 hw_if_index;
 527   u32 is_disable = 0;
 528   u32 count = ~0;
 529
 530   if (!unformat_user (input, unformat_line_input, line_input))
 531     return 0;
 532
 533   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 534     {
 535       if (unformat (line_input, "%U",
 536                     unformat_vnet_hw_interface, vnm, &hw_if_index))
 537         {
 538           hi = vnet_get_hw_interface (vnm, hw_if_index);
 539         }
 540
 541       else if (unformat (line_input, "pcap %s", &pcap_file_name))
 542         ;
 543       else if (unformat (line_input, "count %u", &count))
 544         ;
 545       else if (unformat (line_input, "disable"))
 546         is_disable = 1;
 547
 548       else
 549         {
 550           error = clib_error_create ("unknown input `%U'",
 551                                      format_unformat_error, line_input);
 552           goto done;
 553         }
 554     }
 555
 556   if (!hi)
 557     {
 558       error = clib_error_return (0, "Please specify interface name");
 559       goto done;
 560     }
 561
 562   if (hi->dev_class_index != pg_dev_class.index)
 563     {
 564       error =
 565         clib_error_return (0, "Please specify packet-generator interface");
 566       goto done;
 567     }
 568
 569   if (!pcap_file_name && is_disable == 0)
 570     {
 571       error = clib_error_return (0, "Please specify pcap file name");
 572       goto done;
 573     }
 574
 575
 576   pg_capture_args_t _a, *a = &_a;
 577
 578   a->hw_if_index = hw_if_index;
 579   a->dev_instance = hi->dev_instance;
 580   a->is_enabled = !is_disable;
 581   a->pcap_file_name = pcap_file_name;
 582   a->count = count;
 583
 584   error = pg_capture (a);
 585
 586 done:
 587   unformat_free (line_input);
 588
 589   return error;
 590 }
 591
 592 /* *INDENT-OFF* */
 593 VLIB_CLI_COMMAND (pg_capture_cmd, static) = {
 594   .path = "packet-generator capture",
 595   .short_help = "packet-generator capture <interface name> pcap <filename> [count <n>]",
 596   .function = pg_capture_cmd_fn,
 597 };
 598 /* *INDENT-ON* */
 599
 600 static clib_error_t *
 601 create_pg_if_cmd_fn (vlib_main_t * vm,
 602                      unformat_input_t * input, vlib_cli_command_t * cmd)
 603 {
 604   pg_main_t *pg = &pg_main;
 605   unformat_input_t _line_input, *line_input = &_line_input;
 606   u32 if_id;
 607   clib_error_t *error = NULL;
 608
 609   if (!unformat_user (input, unformat_line_input, line_input))
 610     return 0;
 611
 612   while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
 613     {
 614       if (unformat (line_input, "interface pg%u", &if_id))
 615         ;
 616
 617       else
 618         {
 619           error = clib_error_create ("unknown input `%U'",
 620                                      format_unformat_error, line_input);
 621           goto done;
 622         }
 623     }
 624
 625   pg_interface_add_or_get (pg, if_id);
 626
 627 done:
 628   unformat_free (line_input);
 629
 630   return error;
 631 }
 632
 633 /* *INDENT-OFF* */
 634 VLIB_CLI_COMMAND (create_pg_if_cmd, static) = {
 635   .path = "create packet-generator",
 636   .short_help = "create packet-generator interface <interface name>",
 637   .function = create_pg_if_cmd_fn,
 638 };
 639 /* *INDENT-ON* */
 640
 641 /* Dummy init function so that we can be linked in. */
 642 static clib_error_t *
 643 pg_cli_init (vlib_main_t * vm)
 644 {
 645   return 0;
 646 }
 647
 648 VLIB_INIT_FUNCTION (pg_cli_init);
 649
 650 /*
 651  * fd.io coding-style-patch-verification: ON
 652  *
 653  * Local Variables:
 654  * eval: (c-set-style "gnu")
 655  * End:
 656  */