utilities/ovs-dpctl.c

   1 /*
   2  * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks.
   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 <errno.h>
  20 #include <getopt.h>
  21 #include <inttypes.h>
  22 #include <sys/socket.h>
  23 #include <net/if.h>
  24 #include <netinet/in.h>
  25 #include <signal.h>
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <unistd.h>
  30 #include <sys/stat.h>
  31 #include <sys/time.h>
  32
  33 #include "command-line.h"
  34 #include "compiler.h"
  35 #include "dirs.h"
  36 #include "dpif.h"
  37 #include "dynamic-string.h"
  38 #include "netdev.h"
  39 #include "odp-util.h"
  40 #include "shash.h"
  41 #include "sset.h"
  42 #include "timeval.h"
  43 #include "util.h"
  44 #include "vlog.h"
  45
  46 VLOG_DEFINE_THIS_MODULE(dpctl);
  47
  48 /* -s, --statistics: Print port statistics? */
  49 static bool print_statistics;
  50
  51 static const struct command all_commands[];
  52
  53 static void usage(void) NO_RETURN;
  54 static void parse_options(int argc, char *argv[]);
  55
  56 int
  57 main(int argc, char *argv[])
  58 {
  59     set_program_name(argv[0]);
  60     parse_options(argc, argv);
  61     signal(SIGPIPE, SIG_IGN);
  62     run_command(argc - optind, argv + optind, all_commands);
  63     return 0;
  64 }
  65
  66 static void
  67 parse_options(int argc, char *argv[])
  68 {
  69     enum {
  70         OPT_DUMMY = UCHAR_MAX + 1,
  71         VLOG_OPTION_ENUMS
  72     };
  73     static struct option long_options[] = {
  74         {"statistics", no_argument, NULL, 's'},
  75         {"timeout", required_argument, NULL, 't'},
  76         {"help", no_argument, NULL, 'h'},
  77         {"version", no_argument, NULL, 'V'},
  78         VLOG_LONG_OPTIONS,
  79         {NULL, 0, NULL, 0},
  80     };
  81     char *short_options = long_options_to_short_options(long_options);
  82
  83     for (;;) {
  84         unsigned long int timeout;
  85         int c;
  86
  87         c = getopt_long(argc, argv, short_options, long_options, NULL);
  88         if (c == -1) {
  89             break;
  90         }
  91
  92         switch (c) {
  93         case 's':
  94             print_statistics = true;
  95             break;
  96
  97         case 't':
  98             timeout = strtoul(optarg, NULL, 10);
  99             if (timeout <= 0) {
 100                 ovs_fatal(0, "value %s on -t or --timeout is not at least 1",
 101                           optarg);
 102             } else {
 103                 time_alarm(timeout);
 104             }
 105             break;
 106
 107         case 'h':
 108             usage();
 109
 110         case 'V':
 111             ovs_print_version(0, 0);
 112             exit(EXIT_SUCCESS);
 113
 114         VLOG_OPTION_HANDLERS
 115
 116         case '?':
 117             exit(EXIT_FAILURE);
 118
 119         default:
 120             abort();
 121         }
 122     }
 123     free(short_options);
 124 }
 125
 126 static void
 127 usage(void)
 128 {
 129     printf("%s: Open vSwitch datapath management utility\n"
 130            "usage: %s [OPTIONS] COMMAND [ARG...]\n"
 131            "  add-dp DP [IFACE...]     add new datapath DP (with IFACEs)\n"
 132            "  del-dp DP                delete local datapath DP\n"
 133            "  add-if DP IFACE...       add each IFACE as a port on DP\n"
 134            "  del-if DP IFACE...       delete each IFACE from DP\n"
 135            "  dump-dps                 display names of all datapaths\n"
 136            "  show                     show basic info on all datapaths\n"
 137            "  show DP...               show basic info on each DP\n"
 138            "  dump-flows DP            display flows in DP\n"
 139            "  del-flows DP             delete all flows from DP\n",
 140            program_name, program_name);
 141     vlog_usage();
 142     printf("\nOther options:\n"
 143            "  -t, --timeout=SECS          give up after SECS seconds\n"
 144            "  -h, --help                  display this help message\n"
 145            "  -V, --version               display version information\n");
 146     exit(EXIT_SUCCESS);
 147 }
 148
 149 static void run(int retval, const char *message, ...)
 150     PRINTF_FORMAT(2, 3);
 151
 152 static void run(int retval, const char *message, ...)
 153 {
 154     if (retval) {
 155         va_list args;
 156
 157         va_start(args, message);
 158         ovs_fatal_valist(retval, message, args);
 159     }
 160 }
 161 \f
 162 static void do_add_if(int argc, char *argv[]);
 163
 164 static int if_up(const char *netdev_name)
 165 {
 166     struct netdev *netdev;
 167     int retval;
 168
 169     retval = netdev_open(netdev_name, "system", &netdev);
 170     if (!retval) {
 171         retval = netdev_turn_flags_on(netdev, NETDEV_UP, true);
 172         netdev_close(netdev);
 173     }
 174     return retval;
 175 }
 176
 177 static int
 178 parsed_dpif_open(const char *arg_, bool create, struct dpif **dpifp)
 179 {
 180     int result;
 181     char *name, *type;
 182
 183     dp_parse_name(arg_, &name, &type);
 184
 185     if (create) {
 186         result = dpif_create(name, type, dpifp);
 187     } else {
 188         result = dpif_open(name, type, dpifp);
 189     }
 190
 191     free(name);
 192     free(type);
 193     return result;
 194 }
 195
 196 static void
 197 do_add_dp(int argc OVS_UNUSED, char *argv[])
 198 {
 199     struct dpif *dpif;
 200     run(parsed_dpif_open(argv[1], true, &dpif), "add_dp");
 201     dpif_close(dpif);
 202     if (argc > 2) {
 203         do_add_if(argc, argv);
 204     }
 205 }
 206
 207 static void
 208 do_del_dp(int argc OVS_UNUSED, char *argv[])
 209 {
 210     struct dpif *dpif;
 211     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 212     run(dpif_delete(dpif), "del_dp");
 213     dpif_close(dpif);
 214 }
 215
 216 static void
 217 do_add_if(int argc OVS_UNUSED, char *argv[])
 218 {
 219     bool failure = false;
 220     struct dpif *dpif;
 221     int i;
 222
 223     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 224     for (i = 2; i < argc; i++) {
 225         const char *name, *type;
 226         char *save_ptr = NULL;
 227         struct netdev *netdev = NULL;
 228         struct shash args;
 229         char *option;
 230         int error;
 231
 232         name = strtok_r(argv[i], ",", &save_ptr);
 233         type = "system";
 234
 235         if (!name) {
 236             ovs_error(0, "%s is not a valid network device name", argv[i]);
 237             continue;
 238         }
 239
 240         shash_init(&args);
 241         while ((option = strtok_r(NULL, ",", &save_ptr)) != NULL) {
 242             char *save_ptr_2 = NULL;
 243             char *key, *value;
 244
 245             key = strtok_r(option, "=", &save_ptr_2);
 246             value = strtok_r(NULL, "", &save_ptr_2);
 247             if (!value) {
 248                 value = "";
 249             }
 250
 251             if (!strcmp(key, "type")) {
 252                 type = value;
 253             } else if (!shash_add_once(&args, key, value)) {
 254                 ovs_error(0, "duplicate \"%s\" option", key);
 255             }
 256         }
 257
 258         error = netdev_open(name, type, &netdev);
 259         if (error) {
 260             ovs_error(error, "%s: failed to open network device", name);
 261             goto next;
 262         }
 263
 264         error = netdev_set_config(netdev, &args);
 265         if (error) {
 266             ovs_error(error, "%s: failed to configure network device", name);
 267             goto next;
 268         }
 269
 270         error = dpif_port_add(dpif, netdev, NULL);
 271         if (error) {
 272             ovs_error(error, "adding %s to %s failed", name, argv[1]);
 273             goto next;
 274         }
 275
 276         error = if_up(name);
 277
 278 next:
 279         netdev_close(netdev);
 280         if (error) {
 281             failure = true;
 282         }
 283     }
 284     dpif_close(dpif);
 285     if (failure) {
 286         exit(EXIT_FAILURE);
 287     }
 288 }
 289
 290 static bool
 291 get_port_number(struct dpif *dpif, const char *name, uint16_t *port)
 292 {
 293     struct dpif_port dpif_port;
 294
 295     if (!dpif_port_query_by_name(dpif, name, &dpif_port)) {
 296         *port = dpif_port.port_no;
 297         dpif_port_destroy(&dpif_port);
 298         return true;
 299     } else {
 300         ovs_error(0, "no port named %s", name);
 301         return false;
 302     }
 303 }
 304
 305 static void
 306 do_del_if(int argc OVS_UNUSED, char *argv[])
 307 {
 308     bool failure = false;
 309     struct dpif *dpif;
 310     int i;
 311
 312     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 313     for (i = 2; i < argc; i++) {
 314         const char *name = argv[i];
 315         uint16_t port;
 316         int error;
 317
 318         if (!name[strspn(name, "0123456789")]) {
 319             port = atoi(name);
 320         } else if (!get_port_number(dpif, name, &port)) {
 321             failure = true;
 322             continue;
 323         }
 324
 325         error = dpif_port_del(dpif, port);
 326         if (error) {
 327             ovs_error(error, "deleting port %s from %s failed", name, argv[1]);
 328             failure = true;
 329         }
 330     }
 331     dpif_close(dpif);
 332     if (failure) {
 333         exit(EXIT_FAILURE);
 334     }
 335 }
 336
 337 static void
 338 print_stat(const char *leader, uint64_t value)
 339 {
 340     fputs(leader, stdout);
 341     if (value != UINT64_MAX) {
 342         printf("%"PRIu64, value);
 343     } else {
 344         putchar('?');
 345     }
 346 }
 347
 348 static void
 349 print_human_size(uint64_t value)
 350 {
 351     if (value == UINT64_MAX) {
 352         /* Nothing to do. */
 353     } else if (value >= 1024ULL * 1024 * 1024 * 1024) {
 354         printf(" (%.1f TiB)", value / (1024.0 * 1024 * 1024 * 1024));
 355     } else if (value >= 1024ULL * 1024 * 1024) {
 356         printf(" (%.1f GiB)", value / (1024.0 * 1024 * 1024));
 357     } else if (value >= 1024ULL * 1024) {
 358         printf(" (%.1f MiB)", value / (1024.0 * 1024));
 359     } else if (value >= 1024) {
 360         printf(" (%.1f KiB)", value / 1024.0);
 361     }
 362 }
 363
 364 static void
 365 show_dpif(struct dpif *dpif)
 366 {
 367     struct dpif_port_dump dump;
 368     struct dpif_port dpif_port;
 369     struct ovs_dp_stats stats;
 370     struct netdev *netdev;
 371
 372     printf("%s:\n", dpif_name(dpif));
 373     if (!dpif_get_dp_stats(dpif, &stats)) {
 374         printf("\tlookups: frags:%llu, hit:%llu, missed:%llu, lost:%llu\n",
 375                (unsigned long long int) stats.n_frags,
 376                (unsigned long long int) stats.n_hit,
 377                (unsigned long long int) stats.n_missed,
 378                (unsigned long long int) stats.n_lost);
 379         printf("\tflows: %llu\n", (unsigned long long int)stats.n_flows);
 380     }
 381     DPIF_PORT_FOR_EACH (&dpif_port, &dump, dpif) {
 382         printf("\tport %u: %s", dpif_port.port_no, dpif_port.name);
 383
 384         if (strcmp(dpif_port.type, "system")) {
 385             int error;
 386
 387             printf (" (%s", dpif_port.type);
 388
 389             error = netdev_open(dpif_port.name, dpif_port.type, &netdev);
 390             if (!error) {
 391                 struct shash config;
 392
 393                 shash_init(&config);
 394                 error = netdev_get_config(netdev, &config);
 395                 if (!error) {
 396                     const struct shash_node **nodes;
 397                     size_t i;
 398
 399                     nodes = shash_sort(&config);
 400                     for (i = 0; i < shash_count(&config); i++) {
 401                         const struct shash_node *node = nodes[i];
 402                         printf("%c %s=%s", i ? ',' : ':',
 403                                node->name, (char *) node->data);
 404                     }
 405                     free(nodes);
 406                 } else {
 407                     printf(", could not retrieve configuration (%s)",
 408                            strerror(error));
 409                 }
 410                 shash_destroy_free_data(&config);
 411
 412                 netdev_close(netdev);
 413             } else {
 414                 printf(": open failed (%s)", strerror(error));
 415             }
 416             putchar(')');
 417         }
 418         putchar('\n');
 419
 420         if (print_statistics) {
 421             struct netdev_stats s;
 422             int error;
 423
 424             error = netdev_open(dpif_port.name, dpif_port.type, &netdev);
 425             if (error) {
 426                 printf(", open failed (%s)", strerror(error));
 427                 continue;
 428             }
 429             error = netdev_get_stats(netdev, &s);
 430             if (error) {
 431                 printf(", could not retrieve stats (%s)", strerror(error));
 432                 continue;
 433             }
 434
 435             netdev_close(netdev);
 436             print_stat("\t\tRX packets:", s.rx_packets);
 437             print_stat(" errors:", s.rx_errors);
 438             print_stat(" dropped:", s.rx_dropped);
 439             print_stat(" overruns:", s.rx_over_errors);
 440             print_stat(" frame:", s.rx_frame_errors);
 441             printf("\n");
 442
 443             print_stat("\t\tTX packets:", s.tx_packets);
 444             print_stat(" errors:", s.tx_errors);
 445             print_stat(" dropped:", s.tx_dropped);
 446             print_stat(" aborted:", s.tx_aborted_errors);
 447             print_stat(" carrier:", s.tx_carrier_errors);
 448             printf("\n");
 449
 450             print_stat("\t\tcollisions:", s.collisions);
 451             printf("\n");
 452
 453             print_stat("\t\tRX bytes:", s.rx_bytes);
 454             print_human_size(s.rx_bytes);
 455             print_stat("  TX bytes:", s.tx_bytes);
 456             print_human_size(s.tx_bytes);
 457             printf("\n");
 458         }
 459     }
 460     dpif_close(dpif);
 461 }
 462
 463 static void
 464 do_show(int argc, char *argv[])
 465 {
 466     bool failure = false;
 467     if (argc > 1) {
 468         int i;
 469         for (i = 1; i < argc; i++) {
 470             const char *name = argv[i];
 471             struct dpif *dpif;
 472             int error;
 473
 474             error = parsed_dpif_open(name, false, &dpif);
 475             if (!error) {
 476                 show_dpif(dpif);
 477             } else {
 478                 ovs_error(error, "opening datapath %s failed", name);
 479                 failure = true;
 480             }
 481         }
 482     } else {
 483         struct sset types;
 484         const char *type;
 485
 486         sset_init(&types);
 487         dp_enumerate_types(&types);
 488         SSET_FOR_EACH (type, &types) {
 489             struct sset names;
 490             const char *name;
 491
 492             sset_init(&names);
 493             if (dp_enumerate_names(type, &names)) {
 494                 failure = true;
 495                 continue;
 496             }
 497             SSET_FOR_EACH (name, &names) {
 498                 struct dpif *dpif;
 499                 int error;
 500
 501                 error = dpif_open(name, type, &dpif);
 502                 if (!error) {
 503                     show_dpif(dpif);
 504                 } else {
 505                     ovs_error(error, "opening datapath %s failed", name);
 506                     failure = true;
 507                 }
 508             }
 509             sset_destroy(&names);
 510         }
 511         sset_destroy(&types);
 512     }
 513     if (failure) {
 514         exit(EXIT_FAILURE);
 515     }
 516 }
 517
 518 static void
 519 do_dump_dps(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 520 {
 521     struct sset dpif_names, dpif_types;
 522     const char *type;
 523     int error = 0;
 524
 525     sset_init(&dpif_names);
 526     sset_init(&dpif_types);
 527     dp_enumerate_types(&dpif_types);
 528
 529     SSET_FOR_EACH (type, &dpif_types) {
 530         const char *name;
 531         int retval;
 532
 533         retval = dp_enumerate_names(type, &dpif_names);
 534         if (retval) {
 535             error = retval;
 536         }
 537
 538         SSET_FOR_EACH (name, &dpif_names) {
 539             struct dpif *dpif;
 540             if (!dpif_open(name, type, &dpif)) {
 541                 printf("%s\n", dpif_name(dpif));
 542                 dpif_close(dpif);
 543             }
 544         }
 545     }
 546
 547     sset_destroy(&dpif_names);
 548     sset_destroy(&dpif_types);
 549     if (error) {
 550         exit(EXIT_FAILURE);
 551     }
 552 }
 553
 554 static void
 555 do_dump_flows(int argc OVS_UNUSED, char *argv[])
 556 {
 557     const struct dpif_flow_stats *stats;
 558     const struct nlattr *actions;
 559     struct dpif_flow_dump dump;
 560     const struct nlattr *key;
 561     size_t actions_len;
 562     struct dpif *dpif;
 563     size_t key_len;
 564     struct ds ds;
 565
 566     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 567
 568     ds_init(&ds);
 569     dpif_flow_dump_start(&dump, dpif);
 570     while (dpif_flow_dump_next(&dump, &key, &key_len,
 571                                &actions, &actions_len, &stats)) {
 572         ds_clear(&ds);
 573         odp_flow_key_format(key, key_len, &ds);
 574         ds_put_cstr(&ds, ", ");
 575         dpif_flow_stats_format(stats, &ds);
 576         ds_put_cstr(&ds, ", actions:");
 577         format_odp_actions(&ds, actions, actions_len);
 578         printf("%s\n", ds_cstr(&ds));
 579     }
 580     dpif_flow_dump_done(&dump);
 581     ds_destroy(&ds);
 582     dpif_close(dpif);
 583 }
 584
 585 static void
 586 do_del_flows(int argc OVS_UNUSED, char *argv[])
 587 {
 588     struct dpif *dpif;
 589
 590     run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
 591     run(dpif_flow_flush(dpif), "deleting all flows");
 592     dpif_close(dpif);
 593 }
 594
 595 static void
 596 do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
 597 {
 598     usage();
 599 }
 600
 601 static const struct command all_commands[] = {
 602     { "add-dp", 1, INT_MAX, do_add_dp },
 603     { "del-dp", 1, 1, do_del_dp },
 604     { "add-if", 2, INT_MAX, do_add_if },
 605     { "del-if", 2, INT_MAX, do_del_if },
 606     { "dump-dps", 0, 0, do_dump_dps },
 607     { "show", 0, INT_MAX, do_show },
 608     { "dump-flows", 1, 1, do_dump_flows },
 609     { "del-flows", 1, 1, do_del_flows },
 610     { "help", 0, INT_MAX, do_help },
 611     { NULL, 0, 0, NULL },
 612 };