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