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