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