utilities/ovs-dpctl.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18 #include <arpa/inet.h>
  19 #include <assert.h>
  20 #include <errno.h>
  21 #include <getopt.h>
  22 #include <inttypes.h>
  23 #include <sys/socket.h>
  24 #include <net/if.h>
  25 #include <netinet/in.h>
  26 #include <signal.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <sys/stat.h>
  32 #include <sys/time.h>
  33
  34 #include "command-line.h"
  35 #include "compiler.h"
  36 #include "dirs.h"
  37 #include "dpif.h"
  38 #include "dynamic-string.h"
  39 #include "flow.h"
  40 #include "netdev.h"
  41 #include "netlink.h"
  42 #include "odp-util.h"
  43 #include "ofpbuf.h"
  44 #include "packets.h"
  45 #include "shash.h"
  46 #include "sset.h"
  47 #include "timeval.h"
  48 #include "util.h"
  49 #include "vlog.h"
  50
  51 VLOG_DEFINE_THIS_MODULE(dpctl);
  52
  53 /* -s, --statistics: Print port statistics? */
  54 static bool print_statistics;
  55
  56 /* -m, --more: Output verbosity.
  57  *
  58  * So far only undocumented commands honor this option, so we don't document
  59  * the option itself. */
  60 static int verbosity;
  61
  62 static const struct command all_commands[];
  63
  64 static void usage(void) NO_RETURN;
  65 static void parse_options(int argc, char *argv[]);
  66
  67 int
  68 main(int argc, char *argv[])
  69 {
  70     set_program_name(argv[0]);
  71     parse_options(argc, argv);
  72     signal(SIGPIPE, SIG_IGN);
  73     run_command(argc - optind, argv + optind, all_commands);
  74     return 0;
  75 }
  76
  77 static void
  78 parse_options(int argc, char *argv[])
  79 {
  80     enum {
  81         OPT_DUMMY = UCHAR_MAX + 1,
  82         VLOG_OPTION_ENUMS
  83     };
  84     static struct option long_options[] = {
  85         {"statistics", no_argument, NULL, 's'},
  86         {"more", no_argument, NULL, 'm'},
  87         {"timeout", required_argument, NULL, 't'},
  88         {"help", no_argument, NULL, 'h'},
  89         {"version", no_argument, NULL, 'V'},
  90         VLOG_LONG_OPTIONS,
  91         {NULL, 0, NULL, 0},
  92     };
  93     char *short_options = long_options_to_short_options(long_options);
  94
  95     for (;;) {
  96         unsigned long int timeout;
  97         int c;
  98
  99         c = getopt_long(argc, argv, short_options, long_options, NULL);
 100         if (c == -1) {
 101             break;
 102         }
 103
 104         switch (c) {
 105         case 's':
 106             print_statistics = true;
 107             break;
 108
 109         case 'm':
 110             verbosity++;
 111             break;
 112
 113         case 't':
 114             timeout = strtoul(optarg, NULL, 10);
 115             if (timeout <= 0) {
 116                 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
 117                           optarg);
 118             } else {
 119                 time_alarm(timeout);
 120             }
 121             break;
 122
 123         case 'h':
 124             usage();
 125
 126         case 'V':
 127             ovs_print_version(0, 0);
 128             exit(EXIT_SUCCESS);
 129
 130         VLOG_OPTION_HANDLERS
 131
 132         case '?':
 133             exit(EXIT_FAILURE);
 134
 135         default:
 136             abort();
 137         }
 138     }
 139     free(short_options);
 140 }
 141
 142 static void
 143 usage(void)
 144 {
 145     printf("%s: Open vSwitch datapath management utility\n"
 146            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
 147            "  add-dp DP [IFACE...]     add new datapath DP (with IFACEs)\n"
 148            "  del-dp DP                delete local datapath DP\n"
 149            "  add-if DP IFACE...       add each IFACE as a port on DP\n"
 150            "  set-if DP IFACE...       reconfigure each IFACE within DP\n"
 151            "  del-if DP IFACE...       delete each IFACE from DP\n"
 152            "  dump-dps                 display names of all datapaths\n"
 153            "  show                     show basic info on all datapaths\n"
 154            "  show DP...               show basic info on each DP\n"
 155            "  dump-flows DP            display flows in DP\n"
 156            "  del-flows DP             delete all flows from DP\n"
 157            "Each IFACE on add-dp, add-if, and set-if may be followed by\n"
 158            "comma-separated options.  See ovs-dpctl(8) for syntax, or the\n"
 159            "Interface table in ovs-vswitchd.conf.db(5) for an options list.\n",
 160            program_name, program_name);
 161     vlog_usage();
 162     printf("\nOther options:\n"
 163            "  -t, --timeout=SECS          give up after SECS seconds\n"
 164            "  -h, --help                  display this help message\n"
 165            "  -V, --version               display version information\n");
 166     exit(EXIT_SUCCESS);
 167 }
 168
 169 static void run(int retval, const char *message, ...)
 170     PRINTF_FORMAT(2, 3);
 171
 172 static void run(int retval, const char *message, ...)
 173 {
 174     if (retval) {
 175         va_list args;
 176
 177         va_start(args, message);
 178         ovs_fatal_valist(retval, message, args);
 179     }
 180 }
 181 \f
 182 static void do_add_if(int argc, char *argv[]);
 183
 184 static int if_up(const char *netdev_name)
 185 {
 186     struct netdev *netdev;
 187     int retval;
 188
 189     retval = netdev_open(netdev_name, "system", &netdev);
 190     if (!retval) {
 191         retval = netdev_turn_flags_on(netdev, NETDEV_UP, true);
 192         netdev_close(netdev);
 193     }
 194     return retval;
 195 }
 196
 197 static int
 198 parsed_dpif_open(const char *arg_, bool create, struct dpif **dpifp)
 199 {
 200     int result;
 201     char *name, *type;
 202
 203     dp_parse_name(arg_, &name, &type);
 204
 205     if (create) {
 206         result = dpif_create(name, type, dpifp);
 207     } else {
 208         result = dpif_open(name, type, dpifp);
 209     }
 210
 211     free(name);
 212     free(type);
 213     return result;
 214 }
 215
 216 static void
 217 do_add_dp(int argc OVS_UNUSED, char *argv[])
 218 {
 219     struct dpif *dpif;
 220     run(parsed_dpif_open(argv[1], true, &dpif), "add_dp");
 221     dpif_close(dpif);
 222     if (argc > 2) {
 223         do_add_if(argc, argv);
 224     }
 225 }
 226
 227 static void
 228 do_del_dp(int argc OVS_UNUSED, char *argv[])
 229 {
 230     struct dpif *dpif;
 231     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 232     run(dpif_delete(dpif), "del_dp");
 233     dpif_close(dpif);
 234 }
 235
 236 static void
 237 do_add_if(int argc OVS_UNUSED, char *argv[])
 238 {
 239     bool failure = false;
 240     struct dpif *dpif;
 241     int i;
 242
 243     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 244     for (i = 2; i < argc; i++) {
 245         const char *name, *type;
 246         char *save_ptr = NULL;
 247         struct netdev *netdev = NULL;
 248         struct shash args;
 249         char *option;
 250         int error;
 251
 252         name = strtok_r(argv[i], ",", &save_ptr);
 253         type = "system";
 254
 255         if (!name) {
 256             ovs_error(0, "%s is not a valid network device name", argv[i]);
 257             failure = true;
 258             continue;
 259         }
 260
 261         shash_init(&args);
 262         while ((option = strtok_r(NULL, ",", &save_ptr)) != NULL) {
 263             char *save_ptr_2 = NULL;
 264             char *key, *value;
 265
 266             key = strtok_r(option, "=", &save_ptr_2);
 267             value = strtok_r(NULL, "", &save_ptr_2);
 268             if (!value) {
 269                 value = "";
 270             }
 271
 272             if (!strcmp(key, "type")) {
 273                 type = value;
 274             } else if (!shash_add_once(&args, key, value)) {
 275                 ovs_error(0, "duplicate \"%s\" option", key);
 276             }
 277         }
 278
 279         error = netdev_open(name, type, &netdev);
 280         if (error) {
 281             ovs_error(error, "%s: failed to open network device", name);
 282             goto next;
 283         }
 284
 285         error = netdev_set_config(netdev, &args);
 286         if (error) {
 287             ovs_error(error, "%s: failed to configure network device", name);
 288             goto next;
 289         }
 290
 291         error = dpif_port_add(dpif, netdev, NULL);
 292         if (error) {
 293             ovs_error(error, "adding %s to %s failed", name, argv[1]);
 294             goto next;
 295         }
 296
 297         error = if_up(name);
 298
 299 next:
 300         netdev_close(netdev);
 301         if (error) {
 302             failure = true;
 303         }
 304     }
 305     dpif_close(dpif);
 306     if (failure) {
 307         exit(EXIT_FAILURE);
 308     }
 309 }
 310
 311 static void
 312 do_set_if(int argc, char *argv[])
 313 {
 314     bool failure = false;
 315     struct dpif *dpif;
 316     int i;
 317
 318     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 319     for (i = 2; i < argc; i++) {
 320         struct netdev *netdev = NULL;
 321         struct dpif_port dpif_port;
 322         char *save_ptr = NULL;
 323         char *type = NULL;
 324         const char *name;
 325         struct shash args;
 326         char *option;
 327         int error;
 328
 329         name = strtok_r(argv[i], ",", &save_ptr);
 330         if (!name) {
 331             ovs_error(0, "%s is not a valid network device name", argv[i]);
 332             failure = true;
 333             continue;
 334         }
 335
 336         /* Get the port's type from the datapath. */
 337         error = dpif_port_query_by_name(dpif, name, &dpif_port);
 338         if (error) {
 339             ovs_error(error, "%s: failed to query port in %s", name, argv[1]);
 340             goto next;
 341         }
 342         type = xstrdup(dpif_port.type);
 343         dpif_port_destroy(&dpif_port);
 344
 345         /* Retrieve its existing configuration. */
 346         error = netdev_open(name, type, &netdev);
 347         if (error) {
 348             ovs_error(error, "%s: failed to open network device", name);
 349             goto next;
 350         }
 351
 352         shash_init(&args);
 353         error = netdev_get_config(netdev, &args);
 354         if (error) {
 355             ovs_error(error, "%s: failed to fetch configuration", name);
 356             goto next;
 357         }
 358
 359         /* Parse changes to configuration. */
 360         while ((option = strtok_r(NULL, ",", &save_ptr)) != NULL) {
 361             char *save_ptr_2 = NULL;
 362             char *key, *value;
 363
 364             key = strtok_r(option, "=", &save_ptr_2);
 365             value = strtok_r(NULL, "", &save_ptr_2);
 366             if (!value) {
 367                 value = "";
 368             }
 369
 370             if (!strcmp(key, "type")) {
 371                 if (strcmp(value, type)) {
 372                     ovs_error(0, "%s: can't change type from %s to %s",
 373                               name, type, value);
 374                     failure = true;
 375                 }
 376             } else if (value[0] == '\0') {
 377                 free(shash_find_and_delete(&args, key));
 378             } else {
 379                 free(shash_replace(&args, key, xstrdup(value)));
 380             }
 381         }
 382
 383         /* Update configuration. */
 384         error = netdev_set_config(netdev, &args);
 385         smap_destroy(&args);
 386         if (error) {
 387             ovs_error(error, "%s: failed to configure network device", name);
 388             goto next;
 389         }
 390
 391 next:
 392         free(type);
 393         netdev_close(netdev);
 394         if (error) {
 395             failure = true;
 396         }
 397     }
 398     dpif_close(dpif);
 399     if (failure) {
 400         exit(EXIT_FAILURE);
 401     }
 402 }
 403
 404 static bool
 405 get_port_number(struct dpif *dpif, const char *name, uint16_t *port)
 406 {
 407     struct dpif_port dpif_port;
 408
 409     if (!dpif_port_query_by_name(dpif, name, &dpif_port)) {
 410         *port = dpif_port.port_no;
 411         dpif_port_destroy(&dpif_port);
 412         return true;
 413     } else {
 414         ovs_error(0, "no port named %s", name);
 415         return false;
 416     }
 417 }
 418
 419 static void
 420 do_del_if(int argc OVS_UNUSED, char *argv[])
 421 {
 422     bool failure = false;
 423     struct dpif *dpif;
 424     int i;
 425
 426     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 427     for (i = 2; i < argc; i++) {
 428         const char *name = argv[i];
 429         uint16_t port;
 430         int error;
 431
 432         if (!name[strspn(name, "0123456789")]) {
 433             port = atoi(name);
 434         } else if (!get_port_number(dpif, name, &port)) {
 435             failure = true;
 436             continue;
 437         }
 438
 439         error = dpif_port_del(dpif, port);
 440         if (error) {
 441             ovs_error(error, "deleting port %s from %s failed", name, argv[1]);
 442             failure = true;
 443         }
 444     }
 445     dpif_close(dpif);
 446     if (failure) {
 447         exit(EXIT_FAILURE);
 448     }
 449 }
 450
 451 static void
 452 print_stat(const char *leader, uint64_t value)
 453 {
 454     fputs(leader, stdout);
 455     if (value != UINT64_MAX) {
 456         printf("%"PRIu64, value);
 457     } else {
 458         putchar('?');
 459     }
 460 }
 461
 462 static void
 463 print_human_size(uint64_t value)
 464 {
 465     if (value == UINT64_MAX) {
 466         /* Nothing to do. */
 467     } else if (value >= 1024ULL * 1024 * 1024 * 1024) {
 468         printf(" (%.1f TiB)", value / (1024.0 * 1024 * 1024 * 1024));
 469     } else if (value >= 1024ULL * 1024 * 1024) {
 470         printf(" (%.1f GiB)", value / (1024.0 * 1024 * 1024));
 471     } else if (value >= 1024ULL * 1024) {
 472         printf(" (%.1f MiB)", value / (1024.0 * 1024));
 473     } else if (value >= 1024) {
 474         printf(" (%.1f KiB)", value / 1024.0);
 475     }
 476 }
 477
 478 static void
 479 show_dpif(struct dpif *dpif)
 480 {
 481     struct dpif_port_dump dump;
 482     struct dpif_port dpif_port;
 483     struct dpif_dp_stats stats;
 484     struct netdev *netdev;
 485
 486     printf("%s:\n", dpif_name(dpif));
 487     if (!dpif_get_dp_stats(dpif, &stats)) {
 488         printf("\tlookups: hit:%"PRIu64" missed:%"PRIu64" lost:%"PRIu64"\n"
 489                "\tflows: %"PRIu64"\n",
 490                stats.n_hit, stats.n_missed, stats.n_lost, stats.n_flows);
 491     }
 492     DPIF_PORT_FOR_EACH (&dpif_port, &dump, dpif) {
 493         printf("\tport %u: %s", dpif_port.port_no, dpif_port.name);
 494
 495         if (strcmp(dpif_port.type, "system")) {
 496             int error;
 497
 498             printf (" (%s", dpif_port.type);
 499
 500             error = netdev_open(dpif_port.name, dpif_port.type, &netdev);
 501             if (!error) {
 502                 struct shash config;
 503
 504                 shash_init(&config);
 505                 error = netdev_get_config(netdev, &config);
 506                 if (!error) {
 507                     const struct shash_node **nodes;
 508                     size_t i;
 509
 510                     nodes = shash_sort(&config);
 511                     for (i = 0; i < shash_count(&config); i++) {
 512                         const struct shash_node *node = nodes[i];
 513                         printf("%c %s=%s", i ? ',' : ':',
 514                                node->name, (char *) node->data);
 515                     }
 516                     free(nodes);
 517                 } else {
 518                     printf(", could not retrieve configuration (%s)",
 519                            strerror(error));
 520                 }
 521                 shash_destroy_free_data(&config);
 522
 523                 netdev_close(netdev);
 524             } else {
 525                 printf(": open failed (%s)", strerror(error));
 526             }
 527             putchar(')');
 528         }
 529         putchar('\n');
 530
 531         if (print_statistics) {
 532             struct netdev_stats s;
 533             int error;
 534
 535             error = netdev_open(dpif_port.name, dpif_port.type, &netdev);
 536             if (error) {
 537                 printf(", open failed (%s)", strerror(error));
 538                 continue;
 539             }
 540             error = netdev_get_stats(netdev, &s);
 541             if (error) {
 542                 printf(", could not retrieve stats (%s)", strerror(error));
 543                 continue;
 544             }
 545
 546             netdev_close(netdev);
 547             print_stat("\t\tRX packets:", s.rx_packets);
 548             print_stat(" errors:", s.rx_errors);
 549             print_stat(" dropped:", s.rx_dropped);
 550             print_stat(" overruns:", s.rx_over_errors);
 551             print_stat(" frame:", s.rx_frame_errors);
 552             printf("\n");
 553
 554             print_stat("\t\tTX packets:", s.tx_packets);
 555             print_stat(" errors:", s.tx_errors);
 556             print_stat(" dropped:", s.tx_dropped);
 557             print_stat(" aborted:", s.tx_aborted_errors);
 558             print_stat(" carrier:", s.tx_carrier_errors);
 559             printf("\n");
 560
 561             print_stat("\t\tcollisions:", s.collisions);
 562             printf("\n");
 563
 564             print_stat("\t\tRX bytes:", s.rx_bytes);
 565             print_human_size(s.rx_bytes);
 566             print_stat("  TX bytes:", s.tx_bytes);
 567             print_human_size(s.tx_bytes);
 568             printf("\n");
 569         }
 570     }
 571     dpif_close(dpif);
 572 }
 573
 574 static void
 575 do_show(int argc, char *argv[])
 576 {
 577     bool failure = false;
 578     if (argc > 1) {
 579         int i;
 580         for (i = 1; i < argc; i++) {
 581             const char *name = argv[i];
 582             struct dpif *dpif;
 583             int error;
 584
 585             error = parsed_dpif_open(name, false, &dpif);
 586             if (!error) {
 587                 show_dpif(dpif);
 588             } else {
 589                 ovs_error(error, "opening datapath %s failed", name);
 590                 failure = true;
 591             }
 592         }
 593     } else {
 594         struct sset types;
 595         const char *type;
 596
 597         sset_init(&types);
 598         dp_enumerate_types(&types);
 599         SSET_FOR_EACH (type, &types) {
 600             struct sset names;
 601             const char *name;
 602
 603             sset_init(&names);
 604             if (dp_enumerate_names(type, &names)) {
 605                 failure = true;
 606                 continue;
 607             }
 608             SSET_FOR_EACH (name, &names) {
 609                 struct dpif *dpif;
 610                 int error;
 611
 612                 error = dpif_open(name, type, &dpif);
 613                 if (!error) {
 614                     show_dpif(dpif);
 615                 } else {
 616                     ovs_error(error, "opening datapath %s failed", name);
 617                     failure = true;
 618                 }
 619             }
 620             sset_destroy(&names);
 621         }
 622         sset_destroy(&types);
 623     }
 624     if (failure) {
 625         exit(EXIT_FAILURE);
 626     }
 627 }
 628
 629 static void
 630 do_dump_dps(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 631 {
 632     struct sset dpif_names, dpif_types;
 633     const char *type;
 634     int error = 0;
 635
 636     sset_init(&dpif_names);
 637     sset_init(&dpif_types);
 638     dp_enumerate_types(&dpif_types);
 639
 640     SSET_FOR_EACH (type, &dpif_types) {
 641         const char *name;
 642         int retval;
 643
 644         retval = dp_enumerate_names(type, &dpif_names);
 645         if (retval) {
 646             error = retval;
 647         }
 648
 649         SSET_FOR_EACH (name, &dpif_names) {
 650             struct dpif *dpif;
 651             if (!dpif_open(name, type, &dpif)) {
 652                 printf("%s\n", dpif_name(dpif));
 653                 dpif_close(dpif);
 654             }
 655         }
 656     }
 657
 658     sset_destroy(&dpif_names);
 659     sset_destroy(&dpif_types);
 660     if (error) {
 661         exit(EXIT_FAILURE);
 662     }
 663 }
 664
 665 static void
 666 do_dump_flows(int argc OVS_UNUSED, char *argv[])
 667 {
 668     const struct dpif_flow_stats *stats;
 669     const struct nlattr *actions;
 670     struct dpif_flow_dump dump;
 671     const struct nlattr *key;
 672     size_t actions_len;
 673     struct dpif *dpif;
 674     size_t key_len;
 675     struct ds ds;
 676
 677     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 678
 679     ds_init(&ds);
 680     dpif_flow_dump_start(&dump, dpif);
 681     while (dpif_flow_dump_next(&dump, &key, &key_len,
 682                                &actions, &actions_len, &stats)) {
 683         ds_clear(&ds);
 684         odp_flow_key_format(key, key_len, &ds);
 685         ds_put_cstr(&ds, ", ");
 686         dpif_flow_stats_format(stats, &ds);
 687         ds_put_cstr(&ds, ", actions:");
 688         format_odp_actions(&ds, actions, actions_len);
 689         printf("%s\n", ds_cstr(&ds));
 690     }
 691     dpif_flow_dump_done(&dump);
 692     ds_destroy(&ds);
 693     dpif_close(dpif);
 694 }
 695
 696 static void
 697 do_del_flows(int argc OVS_UNUSED, char *argv[])
 698 {
 699     struct dpif *dpif;
 700
 701     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 702     run(dpif_flow_flush(dpif), "deleting all flows");
 703     dpif_close(dpif);
 704 }
 705
 706 static void
 707 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 708 {
 709     usage();
 710 }
 711 \f
 712 /* Undocumented commands for unit testing. */
 713
 714 static void
 715 do_parse_actions(int argc, char *argv[])
 716 {
 717     int i;
 718
 719     for (i = 1; i < argc; i++) {
 720         struct ofpbuf actions;
 721         struct ds s;
 722
 723         ofpbuf_init(&actions, 0);
 724         run(odp_actions_from_string(argv[i], NULL, &actions),
 725             "odp_actions_from_string");
 726
 727         ds_init(&s);
 728         format_odp_actions(&s, actions.data, actions.size);
 729         puts(ds_cstr(&s));
 730         ds_destroy(&s);
 731
 732         ofpbuf_uninit(&actions);
 733     }
 734 }
 735
 736 struct actions_for_flow {
 737     struct hmap_node hmap_node;
 738     struct flow flow;
 739     struct ofpbuf actions;
 740 };
 741
 742 static struct actions_for_flow *
 743 get_actions_for_flow(struct hmap *actions_per_flow, const struct flow *flow)
 744 {
 745     uint32_t hash = flow_hash(flow, 0);
 746     struct actions_for_flow *af;
 747
 748     HMAP_FOR_EACH_WITH_HASH (af, hmap_node, hash, actions_per_flow) {
 749         if (flow_equal(&af->flow, flow)) {
 750             return af;
 751         }
 752     }
 753
 754     af = xmalloc(sizeof *af);
 755     af->flow = *flow;
 756     ofpbuf_init(&af->actions, 0);
 757     hmap_insert(actions_per_flow, &af->hmap_node, hash);
 758     return af;
 759 }
 760
 761 static int
 762 compare_actions_for_flow(const void *a_, const void *b_)
 763 {
 764     struct actions_for_flow *const *a = a_;
 765     struct actions_for_flow *const *b = b_;
 766
 767     return flow_compare_3way(&(*a)->flow, &(*b)->flow);
 768 }
 769
 770 static int
 771 compare_output_actions(const void *a_, const void *b_)
 772 {
 773     const struct nlattr *a = a_;
 774     const struct nlattr *b = b_;
 775     uint32_t a_port = nl_attr_get_u32(a);
 776     uint32_t b_port = nl_attr_get_u32(b);
 777
 778     return a_port < b_port ? -1 : a_port > b_port;
 779 }
 780
 781 static void
 782 sort_output_actions__(struct nlattr *first, struct nlattr *end)
 783 {
 784     size_t bytes = (uint8_t *) end - (uint8_t *) first;
 785     size_t n = bytes / NL_A_U32_SIZE;
 786
 787     assert(bytes % NL_A_U32_SIZE == 0);
 788     qsort(first, n, NL_A_U32_SIZE, compare_output_actions);
 789 }
 790
 791 static void
 792 sort_output_actions(struct nlattr *actions, size_t length)
 793 {
 794     struct nlattr *first_output = NULL;
 795     struct nlattr *a;
 796     int left;
 797
 798     NL_ATTR_FOR_EACH (a, left, actions, length) {
 799         if (nl_attr_type(a) == OVS_ACTION_ATTR_OUTPUT) {
 800             if (!first_output) {
 801                 first_output = a;
 802             }
 803         } else {
 804             if (first_output) {
 805                 sort_output_actions__(first_output, a);
 806                 first_output = NULL;
 807             }
 808         }
 809     }
 810     if (first_output) {
 811         uint8_t *end = (uint8_t *) actions + length;
 812         sort_output_actions__(first_output, (struct nlattr *) end);
 813     }
 814 }
 815
 816 /* usage: "ovs-dpctl normalize-actions FLOW ACTIONS" where FLOW and ACTIONS
 817  * have the syntax used by "ovs-dpctl dump-flows".
 818  *
 819  * This command prints ACTIONS in a format that shows what happens for each
 820  * VLAN, independent of the order of the ACTIONS.  For example, there is more
 821  * than one way to output a packet on VLANs 9 and 11, but this command will
 822  * print the same output for any form.
 823  *
 824  * The idea here generalizes beyond VLANs (e.g. to setting other fields) but
 825  * so far the implementation only covers VLANs. */
 826 static void
 827 do_normalize_actions(int argc, char *argv[])
 828 {
 829     struct shash port_names;
 830     struct ofpbuf keybuf;
 831     struct flow flow;
 832     struct ofpbuf odp_actions;
 833     struct hmap actions_per_flow;
 834     struct actions_for_flow **afs;
 835     struct actions_for_flow *af;
 836     struct nlattr *a;
 837     size_t n_afs;
 838     struct ds s;
 839     int left;
 840     int i;
 841
 842     ds_init(&s);
 843
 844     shash_init(&port_names);
 845     for (i = 3; i < argc; i++) {
 846         char name[16];
 847         int number;
 848         int n = -1;
 849
 850         if (sscanf(argv[i], "%15[^=]=%d%n", name, &number, &n) > 0 && n > 0) {
 851             uintptr_t n = number;
 852             shash_add(&port_names, name, (void *) n);
 853         } else {
 854             ovs_fatal(0, "%s: expected NAME=NUMBER", argv[i]);
 855         }
 856     }
 857
 858     /* Parse flow key. */
 859     ofpbuf_init(&keybuf, 0);
 860     run(odp_flow_key_from_string(argv[1], &port_names, &keybuf),
 861         "odp_flow_key_from_string");
 862
 863     ds_clear(&s);
 864     odp_flow_key_format(keybuf.data, keybuf.size, &s);
 865     printf("input flow: %s\n", ds_cstr(&s));
 866
 867     run(odp_flow_key_to_flow(keybuf.data, keybuf.size, &flow),
 868         "odp_flow_key_to_flow");
 869     ofpbuf_uninit(&keybuf);
 870
 871     /* Parse actions. */
 872     ofpbuf_init(&odp_actions, 0);
 873     run(odp_actions_from_string(argv[2], &port_names, &odp_actions),
 874         "odp_actions_from_string");
 875
 876     if (verbosity) {
 877         ds_clear(&s);
 878         format_odp_actions(&s, odp_actions.data, odp_actions.size);
 879         printf("input actions: %s\n", ds_cstr(&s));
 880     }
 881
 882     hmap_init(&actions_per_flow);
 883     NL_ATTR_FOR_EACH (a, left, odp_actions.data, odp_actions.size) {
 884         if (nl_attr_type(a) == OVS_ACTION_ATTR_POP_VLAN) {
 885             flow.vlan_tci = htons(0);
 886             continue;
 887         }
 888
 889         if (nl_attr_type(a) == OVS_ACTION_ATTR_PUSH_VLAN) {
 890             const struct ovs_action_push_vlan *push;
 891
 892             push = nl_attr_get_unspec(a, sizeof *push);
 893             flow.vlan_tci = push->vlan_tci;
 894             continue;
 895         }
 896
 897         af = get_actions_for_flow(&actions_per_flow, &flow);
 898         nl_msg_put_unspec(&af->actions, nl_attr_type(a),
 899                           nl_attr_get(a), nl_attr_get_size(a));
 900     }
 901
 902     n_afs = hmap_count(&actions_per_flow);
 903     afs = xmalloc(n_afs * sizeof *afs);
 904     i = 0;
 905     HMAP_FOR_EACH (af, hmap_node, &actions_per_flow) {
 906         afs[i++] = af;
 907     }
 908     assert(i == n_afs);
 909
 910     qsort(afs, n_afs, sizeof *afs, compare_actions_for_flow);
 911
 912     for (i = 0; i < n_afs; i++) {
 913         const struct actions_for_flow *af = afs[i];
 914
 915         sort_output_actions(af->actions.data, af->actions.size);
 916
 917         if (af->flow.vlan_tci != htons(0)) {
 918             printf("vlan(vid=%"PRIu16",pcp=%d): ",
 919                    vlan_tci_to_vid(af->flow.vlan_tci),
 920                    vlan_tci_to_pcp(af->flow.vlan_tci));
 921         } else {
 922             printf("no vlan: ");
 923         }
 924
 925         ds_clear(&s);
 926         format_odp_actions(&s, af->actions.data, af->actions.size);
 927         puts(ds_cstr(&s));
 928     }
 929     ds_destroy(&s);
 930 }
 931
 932 static const struct command all_commands[] = {
 933     { "add-dp", 1, INT_MAX, do_add_dp },
 934     { "del-dp", 1, 1, do_del_dp },
 935     { "add-if", 2, INT_MAX, do_add_if },
 936     { "del-if", 2, INT_MAX, do_del_if },
 937     { "set-if", 2, INT_MAX, do_set_if },
 938     { "dump-dps", 0, 0, do_dump_dps },
 939     { "show", 0, INT_MAX, do_show },
 940     { "dump-flows", 1, 1, do_dump_flows },
 941     { "del-flows", 1, 1, do_del_flows },
 942     { "help", 0, INT_MAX, do_help },
 943
 944     /* Undocumented commands for testing. */
 945     { "parse-actions", 1, INT_MAX, do_parse_actions },
 946     { "normalize-actions", 2, INT_MAX, do_normalize_actions },
 947
 948     { NULL, 0, 0, NULL },
 949 };