X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=utilities%2Fovs-dpctl.c;h=622423777673ecd29580aab9bb00360e70cd461c;hb=3c7126b933c3ccb263648c59ffd010e97f2fb634;hp=886cdb3ac5318750a1e805b2d84d1f1d788136ad;hpb=c4fca56af2c5cfc8ecfb33648bf4722d3bec5388;p=sliver-openvswitch.git diff --git a/utilities/ovs-dpctl.c b/utilities/ovs-dpctl.c index 886cdb3ac..622423777 100644 --- a/utilities/ovs-dpctl.c +++ b/utilities/ovs-dpctl.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,9 +16,11 @@ #include #include +#include #include #include #include +#include #include #include #include @@ -34,77 +36,61 @@ #include "dirs.h" #include "dpif.h" #include "dynamic-string.h" +#include "flow.h" #include "netdev.h" +#include "netlink.h" #include "odp-util.h" -#include "svec.h" +#include "ofpbuf.h" +#include "packets.h" +#include "shash.h" +#include "simap.h" +#include "smap.h" +#include "sset.h" #include "timeval.h" #include "util.h" - #include "vlog.h" -#define THIS_MODULE VLM_dpctl -struct command { - const char *name; - int min_args; - int max_args; - void (*handler)(int argc, char *argv[]); -}; +VLOG_DEFINE_THIS_MODULE(dpctl); -static struct command all_commands[]; +/* -s, --statistics: Print port statistics? */ +static bool print_statistics; + +/* -m, --more: Output verbosity. + * + * So far only undocumented commands honor this option, so we don't document + * the option itself. */ +static int verbosity; + +static const struct command all_commands[]; static void usage(void) NO_RETURN; static void parse_options(int argc, char *argv[]); -int main(int argc, char *argv[]) +int +main(int argc, char *argv[]) { - struct command *p; - set_program_name(argv[0]); - time_init(); - vlog_init(); parse_options(argc, argv); signal(SIGPIPE, SIG_IGN); - - argc -= optind; - argv += optind; - if (argc < 1) - ovs_fatal(0, "missing command name; use --help for help"); - - for (p = all_commands; p->name != NULL; p++) { - if (!strcmp(p->name, argv[0])) { - int n_arg = argc - 1; - if (n_arg < p->min_args) - ovs_fatal(0, "'%s' command requires at least %d arguments", - p->name, p->min_args); - else if (n_arg > p->max_args) - ovs_fatal(0, "'%s' command takes at most %d arguments", - p->name, p->max_args); - else { - p->handler(argc, argv); - if (ferror(stdout)) { - ovs_fatal(0, "write to stdout failed"); - } - if (ferror(stderr)) { - ovs_fatal(0, "write to stderr failed"); - } - exit(0); - } - } - } - ovs_fatal(0, "unknown command '%s'; use --help for help", argv[0]); - + run_command(argc - optind, argv + optind, all_commands); return 0; } static void parse_options(int argc, char *argv[]) { + enum { + OPT_DUMMY = UCHAR_MAX + 1, + VLOG_OPTION_ENUMS + }; static struct option long_options[] = { - {"timeout", required_argument, 0, 't'}, - {"verbose", optional_argument, 0, 'v'}, - {"help", no_argument, 0, 'h'}, - {"version", no_argument, 0, 'V'}, - {0, 0, 0, 0}, + {"statistics", no_argument, NULL, 's'}, + {"more", no_argument, NULL, 'm'}, + {"timeout", required_argument, NULL, 't'}, + {"help", no_argument, NULL, 'h'}, + {"version", no_argument, NULL, 'V'}, + VLOG_LONG_OPTIONS, + {NULL, 0, NULL, 0}, }; char *short_options = long_options_to_short_options(long_options); @@ -118,6 +104,14 @@ parse_options(int argc, char *argv[]) } switch (c) { + case 's': + print_statistics = true; + break; + + case 'm': + verbosity++; + break; + case 't': timeout = strtoul(optarg, NULL, 10); if (timeout <= 0) { @@ -132,12 +126,10 @@ parse_options(int argc, char *argv[]) usage(); case 'V': - OVS_PRINT_VERSION(0, 0); + ovs_print_version(0, 0); exit(EXIT_SUCCESS); - case 'v': - vlog_set_verbosity(optarg); - break; + VLOG_OPTION_HANDLERS case '?': exit(EXIT_FAILURE); @@ -157,13 +149,16 @@ usage(void) " add-dp DP [IFACE...] add new datapath DP (with IFACEs)\n" " del-dp DP delete local datapath DP\n" " add-if DP IFACE... add each IFACE as a port on DP\n" + " set-if DP IFACE... reconfigure each IFACE within DP\n" " del-if DP IFACE... delete each IFACE from DP\n" " dump-dps display names of all datapaths\n" " show show basic info on all datapaths\n" " show DP... show basic info on each DP\n" " dump-flows DP display flows in DP\n" " del-flows DP delete all flows from DP\n" - " dump-groups DP display port groups in DP\n", + "Each IFACE on add-dp, add-if, and set-if may be followed by\n" + "comma-separated options. See ovs-dpctl(8) for syntax, or the\n" + "Interface table in ovs-vswitchd.conf.db(5) for an options list.\n", program_name, program_name); vlog_usage(); printf("\nOther options:\n" @@ -181,28 +176,19 @@ static void run(int retval, const char *message, ...) if (retval) { va_list args; - fprintf(stderr, "%s: ", program_name); va_start(args, message); - vfprintf(stderr, message, args); - va_end(args); - if (retval == EOF) { - fputs(": unexpected end of file\n", stderr); - } else { - fprintf(stderr, ": %s\n", strerror(retval)); - } - - exit(EXIT_FAILURE); + ovs_fatal_valist(retval, message, args); } } -static void do_add_if(int argc, char *argv[]); +static void dpctl_add_if(int argc, char *argv[]); static int if_up(const char *netdev_name) { struct netdev *netdev; int retval; - retval = netdev_open(netdev_name, NETDEV_ETH_TYPE_NONE, &netdev); + retval = netdev_open(netdev_name, "system", &netdev); if (!retval) { retval = netdev_turn_flags_on(netdev, NETDEV_UP, true); netdev_close(netdev); @@ -210,131 +196,220 @@ static int if_up(const char *netdev_name) return retval; } -static void -do_add_dp(int argc UNUSED, char *argv[]) +static int +parsed_dpif_open(const char *arg_, bool create, struct dpif **dpifp) { - struct dpif dpif; - run(dpif_create(argv[1], &dpif), "add_dp"); - dpif_close(&dpif); - if (argc > 2) { - do_add_if(argc, argv); + int result; + char *name, *type; + + dp_parse_name(arg_, &name, &type); + + if (create) { + result = dpif_create(name, type, dpifp); + } else { + result = dpif_open(name, type, dpifp); } + + free(name); + free(type); + return result; } static void -do_del_dp(int argc UNUSED, char *argv[]) +dpctl_add_dp(int argc OVS_UNUSED, char *argv[]) { - struct dpif dpif; - run(dpif_open(argv[1], &dpif), "opening datapath"); - run(dpif_delete(&dpif), "del_dp"); - dpif_close(&dpif); + struct dpif *dpif; + run(parsed_dpif_open(argv[1], true, &dpif), "add_dp"); + dpif_close(dpif); + if (argc > 2) { + dpctl_add_if(argc, argv); + } } -static int -compare_ports(const void *a_, const void *b_) +static void +dpctl_del_dp(int argc OVS_UNUSED, char *argv[]) { - const struct odp_port *a = a_; - const struct odp_port *b = b_; - return a->port < b->port ? -1 : a->port > b->port; + struct dpif *dpif; + run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath"); + run(dpif_delete(dpif), "del_dp"); + dpif_close(dpif); } static void -query_ports(struct dpif *dpif, struct odp_port **ports, size_t *n_ports) +dpctl_add_if(int argc OVS_UNUSED, char *argv[]) { - run(dpif_port_list(dpif, ports, n_ports), "listing ports"); - qsort(*ports, *n_ports, sizeof **ports, compare_ports); -} + bool failure = false; + struct dpif *dpif; + int i; -static uint16_t -get_free_port(struct dpif *dpif) -{ - struct odp_port *ports; - size_t n_ports; - int port_no; - - query_ports(dpif, &ports, &n_ports); - for (port_no = 0; port_no <= UINT16_MAX; port_no++) { - size_t i; - for (i = 0; i < n_ports; i++) { - if (ports[i].port == port_no) { - goto next_portno; + run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath"); + for (i = 2; i < argc; i++) { + const char *name, *type; + char *save_ptr = NULL; + struct netdev *netdev = NULL; + struct smap args; + uint16_t port_no = UINT16_MAX; + char *option; + int error; + + name = strtok_r(argv[i], ",", &save_ptr); + type = "system"; + + if (!name) { + ovs_error(0, "%s is not a valid network device name", argv[i]); + failure = true; + continue; + } + + smap_init(&args); + while ((option = strtok_r(NULL, ",", &save_ptr)) != NULL) { + char *save_ptr_2 = NULL; + char *key, *value; + + key = strtok_r(option, "=", &save_ptr_2); + value = strtok_r(NULL, "", &save_ptr_2); + if (!value) { + value = ""; + } + + if (!strcmp(key, "type")) { + type = value; + } else if (!strcmp(key, "port_no")) { + port_no = atoi(value); + } else if (!smap_add_once(&args, key, value)) { + ovs_error(0, "duplicate \"%s\" option", key); } } - free(ports); - return port_no; - next_portno: ; + error = netdev_open(name, type, &netdev); + if (error) { + ovs_error(error, "%s: failed to open network device", name); + goto next; + } + + error = netdev_set_config(netdev, &args); + if (error) { + ovs_error(error, "%s: failed to configure network device", name); + goto next; + } + + error = dpif_port_add(dpif, netdev, &port_no); + if (error) { + ovs_error(error, "adding %s to %s failed", name, argv[1]); + goto next; + } + + error = if_up(name); + +next: + netdev_close(netdev); + if (error) { + failure = true; + } + } + dpif_close(dpif); + if (failure) { + exit(EXIT_FAILURE); } - ovs_fatal(0, "no free datapath ports"); } static void -do_add_if(int argc UNUSED, char *argv[]) +dpctl_set_if(int argc, char *argv[]) { bool failure = false; - struct dpif dpif; + struct dpif *dpif; int i; - run(dpif_open(argv[1], &dpif), "opening datapath"); + run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath"); for (i = 2; i < argc; i++) { + struct netdev *netdev = NULL; + struct dpif_port dpif_port; char *save_ptr = NULL; - char *devname, *suboptions; - int port = -1; - int flags = 0; + char *type = NULL; + const char *name; + struct smap args; + uint32_t port_no; + char *option; int error; - devname = strtok_r(argv[i], ",", &save_ptr); - if (!devname) { + name = strtok_r(argv[i], ",", &save_ptr); + if (!name) { ovs_error(0, "%s is not a valid network device name", argv[i]); + failure = true; continue; } - suboptions = strtok_r(NULL, "", &save_ptr); - if (suboptions) { - enum { - AP_PORT, - AP_INTERNAL - }; - static char *options[] = { - "port", - "internal" - }; - - while (*suboptions != '\0') { - char *value; - - switch (getsubopt(&suboptions, options, &value)) { - case AP_PORT: - if (!value) { - ovs_error(0, "'port' suboption requires a value"); - } - port = atoi(value); - break; + /* Get the port's type from the datapath. */ + error = dpif_port_query_by_name(dpif, name, &dpif_port); + if (error) { + ovs_error(error, "%s: failed to query port in %s", name, argv[1]); + goto next; + } + type = xstrdup(dpif_port.type); + port_no = dpif_port.port_no; + dpif_port_destroy(&dpif_port); + + /* Retrieve its existing configuration. */ + error = netdev_open(name, type, &netdev); + if (error) { + ovs_error(error, "%s: failed to open network device", name); + goto next; + } + + smap_init(&args); + error = netdev_get_config(netdev, &args); + if (error) { + ovs_error(error, "%s: failed to fetch configuration", name); + goto next; + } - case AP_INTERNAL: - flags |= ODP_PORT_INTERNAL; - break; + /* Parse changes to configuration. */ + while ((option = strtok_r(NULL, ",", &save_ptr)) != NULL) { + char *save_ptr_2 = NULL; + char *key, *value; - default: - ovs_error(0, "unknown suboption '%s'", value); - break; + key = strtok_r(option, "=", &save_ptr_2); + value = strtok_r(NULL, "", &save_ptr_2); + if (!value) { + value = ""; + } + + if (!strcmp(key, "type")) { + if (strcmp(value, type)) { + ovs_error(0, "%s: can't change type from %s to %s", + name, type, value); + failure = true; + } + } else if (!strcmp(key, "port_no")) { + if (port_no != atoi(value)) { + ovs_error(0, "%s: can't change port number from " + "%"PRIu32" to %d", + name, port_no, atoi(value)); + failure = true; } + } else if (value[0] == '\0') { + smap_remove(&args, key); + } else { + smap_replace(&args, key, value); } } - if (port < 0) { - port = get_free_port(&dpif); + + /* Update configuration. */ + error = netdev_set_config(netdev, &args); + smap_destroy(&args); + if (error) { + ovs_error(error, "%s: failed to configure network device", name); + goto next; } - error = dpif_port_add(&dpif, devname, port, flags); +next: + free(type); + netdev_close(netdev); if (error) { - ovs_error(error, "adding %s as port %"PRIu16" of %s failed", - devname, port, argv[1]); - failure = true; - } else if (if_up(devname)) { failure = true; } } - dpif_close(&dpif); + dpif_close(dpif); if (failure) { exit(EXIT_FAILURE); } @@ -343,31 +418,26 @@ do_add_if(int argc UNUSED, char *argv[]) static bool get_port_number(struct dpif *dpif, const char *name, uint16_t *port) { - struct odp_port *ports; - size_t n_ports; - size_t i; - - query_ports(dpif, &ports, &n_ports); - for (i = 0; i < n_ports; i++) { - if (!strcmp(name, ports[i].devname)) { - *port = ports[i].port; - free(ports); - return true; - } + struct dpif_port dpif_port; + + if (!dpif_port_query_by_name(dpif, name, &dpif_port)) { + *port = dpif_port.port_no; + dpif_port_destroy(&dpif_port); + return true; + } else { + ovs_error(0, "no port named %s", name); + return false; } - free(ports); - ovs_error(0, "no port named %s", name); - return false; } static void -do_del_if(int argc UNUSED, char *argv[]) +dpctl_del_if(int argc OVS_UNUSED, char *argv[]) { bool failure = false; - struct dpif dpif; + struct dpif *dpif; int i; - run(dpif_open(argv[1], &dpif), "opening datapath"); + run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath"); for (i = 2; i < argc; i++) { const char *name = argv[i]; uint16_t port; @@ -375,92 +445,195 @@ do_del_if(int argc UNUSED, char *argv[]) if (!name[strspn(name, "0123456789")]) { port = atoi(name); - } else if (!get_port_number(&dpif, name, &port)) { + } else if (!get_port_number(dpif, name, &port)) { failure = true; continue; } - error = dpif_port_del(&dpif, port); + error = dpif_port_del(dpif, port); if (error) { ovs_error(error, "deleting port %s from %s failed", name, argv[1]); failure = true; } } - dpif_close(&dpif); + dpif_close(dpif); if (failure) { exit(EXIT_FAILURE); } } +static void +print_stat(const char *leader, uint64_t value) +{ + fputs(leader, stdout); + if (value != UINT64_MAX) { + printf("%"PRIu64, value); + } else { + putchar('?'); + } +} + +static void +print_human_size(uint64_t value) +{ + if (value == UINT64_MAX) { + /* Nothing to do. */ + } else if (value >= 1024ULL * 1024 * 1024 * 1024) { + printf(" (%.1f TiB)", value / (1024.0 * 1024 * 1024 * 1024)); + } else if (value >= 1024ULL * 1024 * 1024) { + printf(" (%.1f GiB)", value / (1024.0 * 1024 * 1024)); + } else if (value >= 1024ULL * 1024) { + printf(" (%.1f MiB)", value / (1024.0 * 1024)); + } else if (value >= 1024) { + printf(" (%.1f KiB)", value / 1024.0); + } +} + static void show_dpif(struct dpif *dpif) { - struct odp_port *ports; - struct odp_stats stats; - size_t n_ports; - size_t i; + struct dpif_port_dump dump; + struct dpif_port dpif_port; + struct dpif_dp_stats stats; + struct netdev *netdev; - printf("dp%u:\n", dpif_id(dpif)); + printf("%s:\n", dpif_name(dpif)); if (!dpif_get_dp_stats(dpif, &stats)) { - printf("\tflows: cur:%"PRIu32", soft-max:%"PRIu32", " - "hard-max:%"PRIu32"\n", - stats.n_flows, stats.cur_capacity, stats.max_capacity); - printf("\tports: cur:%"PRIu32", max:%"PRIu32"\n", - stats.n_ports, stats.max_ports); - printf("\tgroups: max:%"PRIu16"\n", stats.max_groups); - printf("\tlookups: frags:%"PRIu64", hit:%"PRIu64", missed:%"PRIu64", " - "lost:%"PRIu64"\n", - stats.n_frags, stats.n_hit, stats.n_missed, stats.n_lost); - printf("\tqueues: max-miss:%"PRIu16", max-action:%"PRIu16"\n", - stats.max_miss_queue, stats.max_action_queue); + printf("\tlookups: hit:%"PRIu64" missed:%"PRIu64" lost:%"PRIu64"\n" + "\tflows: %"PRIu64"\n", + stats.n_hit, stats.n_missed, stats.n_lost, stats.n_flows); } - query_ports(dpif, &ports, &n_ports); - for (i = 0; i < n_ports; i++) { - printf("\tport %u: %s", ports[i].port, ports[i].devname); - if (ports[i].flags & ODP_PORT_INTERNAL) { - printf(" (internal)"); + DPIF_PORT_FOR_EACH (&dpif_port, &dump, dpif) { + printf("\tport %u: %s", dpif_port.port_no, dpif_port.name); + + if (strcmp(dpif_port.type, "system")) { + int error; + + printf (" (%s", dpif_port.type); + + error = netdev_open(dpif_port.name, dpif_port.type, &netdev); + if (!error) { + struct smap config; + + smap_init(&config); + error = netdev_get_config(netdev, &config); + if (!error) { + const struct smap_node **nodes; + size_t i; + + nodes = smap_sort(&config); + for (i = 0; i < smap_count(&config); i++) { + const struct smap_node *node = nodes[i]; + printf("%c %s=%s", i ? ',' : ':', node->key, + node->value); + } + free(nodes); + } else { + printf(", could not retrieve configuration (%s)", + strerror(error)); + } + smap_destroy(&config); + + netdev_close(netdev); + } else { + printf(": open failed (%s)", strerror(error)); + } + putchar(')'); + } + putchar('\n'); + + if (print_statistics) { + struct netdev_stats s; + int error; + + error = netdev_open(dpif_port.name, dpif_port.type, &netdev); + if (error) { + printf(", open failed (%s)", strerror(error)); + continue; + } + error = netdev_get_stats(netdev, &s); + if (error) { + printf(", could not retrieve stats (%s)", strerror(error)); + continue; + } + + netdev_close(netdev); + print_stat("\t\tRX packets:", s.rx_packets); + print_stat(" errors:", s.rx_errors); + print_stat(" dropped:", s.rx_dropped); + print_stat(" overruns:", s.rx_over_errors); + print_stat(" frame:", s.rx_frame_errors); + printf("\n"); + + print_stat("\t\tTX packets:", s.tx_packets); + print_stat(" errors:", s.tx_errors); + print_stat(" dropped:", s.tx_dropped); + print_stat(" aborted:", s.tx_aborted_errors); + print_stat(" carrier:", s.tx_carrier_errors); + printf("\n"); + + print_stat("\t\tcollisions:", s.collisions); + printf("\n"); + + print_stat("\t\tRX bytes:", s.rx_bytes); + print_human_size(s.rx_bytes); + print_stat(" TX bytes:", s.tx_bytes); + print_human_size(s.tx_bytes); + printf("\n"); } - printf("\n"); } - free(ports); dpif_close(dpif); } static void -do_show(int argc, char *argv[]) +dpctl_show(int argc, char *argv[]) { bool failure = false; if (argc > 1) { int i; for (i = 1; i < argc; i++) { const char *name = argv[i]; - struct dpif dpif; + struct dpif *dpif; int error; - error = dpif_open(name, &dpif); + error = parsed_dpif_open(name, false, &dpif); if (!error) { - show_dpif(&dpif); + show_dpif(dpif); } else { ovs_error(error, "opening datapath %s failed", name); failure = true; } } } else { - unsigned int i; - for (i = 0; i < ODP_MAX; i++) { - char name[128]; - struct dpif dpif; - int error; + struct sset types; + const char *type; - sprintf(name, "dp%u", i); - error = dpif_open(name, &dpif); - if (!error) { - show_dpif(&dpif); - } else if (error != ENODEV) { - ovs_error(error, "opening datapath %s failed", name); + sset_init(&types); + dp_enumerate_types(&types); + SSET_FOR_EACH (type, &types) { + struct sset names; + const char *name; + + sset_init(&names); + if (dp_enumerate_names(type, &names)) { failure = true; + continue; + } + SSET_FOR_EACH (name, &names) { + struct dpif *dpif; + int error; + + error = dpif_open(name, type, &dpif); + if (!error) { + show_dpif(dpif); + } else { + ovs_error(error, "opening datapath %s failed", name); + failure = true; + } } + sset_destroy(&names); } + sset_destroy(&types); } if (failure) { exit(EXIT_FAILURE); @@ -468,117 +641,323 @@ do_show(int argc, char *argv[]) } static void -do_dump_dps(int argc UNUSED, char *argv[] UNUSED) +dpctl_dump_dps(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) { - struct svec all_dps; - unsigned int i; - int error; + struct sset dpif_names, dpif_types; + const char *type; + int error = 0; - svec_init(&all_dps); - error = dp_enumerate(&all_dps); + sset_init(&dpif_names); + sset_init(&dpif_types); + dp_enumerate_types(&dpif_types); - for (i = 0; i < all_dps.n; i++) { - struct dpif dpif; - char dpif_name[IF_NAMESIZE]; + SSET_FOR_EACH (type, &dpif_types) { + const char *name; + int retval; - if (dpif_open(all_dps.names[i], &dpif)) { - continue; + retval = dp_enumerate_names(type, &dpif_names); + if (retval) { + error = retval; } - if (!dpif_get_name(&dpif, dpif_name, sizeof dpif_name)) { - printf("%s\n", dpif_name); + + SSET_FOR_EACH (name, &dpif_names) { + struct dpif *dpif; + if (!dpif_open(name, type, &dpif)) { + printf("%s\n", dpif_name(dpif)); + dpif_close(dpif); + } } - dpif_close(&dpif); } - svec_destroy(&all_dps); + sset_destroy(&dpif_names); + sset_destroy(&dpif_types); if (error) { exit(EXIT_FAILURE); } } static void -do_dump_flows(int argc UNUSED, char *argv[]) +dpctl_dump_flows(int argc OVS_UNUSED, char *argv[]) { - struct odp_flow *flows; - struct dpif dpif; - size_t n_flows; + const struct dpif_flow_stats *stats; + const struct nlattr *actions; + struct dpif_flow_dump dump; + const struct nlattr *key; + size_t actions_len; + struct dpif *dpif; + size_t key_len; struct ds ds; - size_t i; - run(dpif_open(argv[1], &dpif), "opening datapath"); - run(dpif_flow_list_all(&dpif, &flows, &n_flows), "listing all flows"); + run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath"); ds_init(&ds); - for (i = 0; i < n_flows; i++) { - struct odp_flow *f = &flows[i]; - enum { MAX_ACTIONS = 4096 / sizeof(union odp_action) }; - union odp_action actions[MAX_ACTIONS]; - - f->actions = actions; - f->n_actions = MAX_ACTIONS; - dpif_flow_get(&dpif, f); - + dpif_flow_dump_start(&dump, dpif); + while (dpif_flow_dump_next(&dump, &key, &key_len, + &actions, &actions_len, &stats)) { ds_clear(&ds); - format_odp_flow(&ds, f); + odp_flow_key_format(key, key_len, &ds); + ds_put_cstr(&ds, ", "); + dpif_flow_stats_format(stats, &ds); + ds_put_cstr(&ds, ", actions:"); + format_odp_actions(&ds, actions, actions_len); printf("%s\n", ds_cstr(&ds)); } + dpif_flow_dump_done(&dump); ds_destroy(&ds); - dpif_close(&dpif); + dpif_close(dpif); } static void -do_del_flows(int argc UNUSED, char *argv[]) +dpctl_del_flows(int argc OVS_UNUSED, char *argv[]) { - struct dpif dpif; + struct dpif *dpif; - run(dpif_open(argv[1], &dpif), "opening datapath"); - run(dpif_flow_flush(&dpif), "deleting all flows"); - dpif_close(&dpif); + run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath"); + run(dpif_flow_flush(dpif), "deleting all flows"); + dpif_close(dpif); +} + +static void +dpctl_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED) +{ + usage(); } + +/* Undocumented commands for unit testing. */ static void -do_dump_groups(int argc UNUSED, char *argv[]) +dpctl_parse_actions(int argc, char *argv[]) +{ + int i; + + for (i = 1; i < argc; i++) { + struct ofpbuf actions; + struct ds s; + + ofpbuf_init(&actions, 0); + run(odp_actions_from_string(argv[i], NULL, &actions), + "odp_actions_from_string"); + + ds_init(&s); + format_odp_actions(&s, actions.data, actions.size); + puts(ds_cstr(&s)); + ds_destroy(&s); + + ofpbuf_uninit(&actions); + } +} + +struct actions_for_flow { + struct hmap_node hmap_node; + struct flow flow; + struct ofpbuf actions; +}; + +static struct actions_for_flow * +get_actions_for_flow(struct hmap *actions_per_flow, const struct flow *flow) +{ + uint32_t hash = flow_hash(flow, 0); + struct actions_for_flow *af; + + HMAP_FOR_EACH_WITH_HASH (af, hmap_node, hash, actions_per_flow) { + if (flow_equal(&af->flow, flow)) { + return af; + } + } + + af = xmalloc(sizeof *af); + af->flow = *flow; + ofpbuf_init(&af->actions, 0); + hmap_insert(actions_per_flow, &af->hmap_node, hash); + return af; +} + +static int +compare_actions_for_flow(const void *a_, const void *b_) { - struct odp_stats stats; - struct dpif dpif; - unsigned int i; - - run(dpif_open(argv[1], &dpif), "opening datapath"); - run(dpif_get_dp_stats(&dpif, &stats), "get datapath stats"); - for (i = 0; i < stats.max_groups; i++) { - uint16_t ports[UINT16_MAX]; - size_t n_ports; - - if (!dpif_port_group_get(&dpif, i, ports, - ARRAY_SIZE(ports), &n_ports) && n_ports) { - size_t j; - - printf("group %u:", i); - for (j = 0; j < n_ports; j++) { - printf(" %"PRIu16, ports[j]); + struct actions_for_flow *const *a = a_; + struct actions_for_flow *const *b = b_; + + return flow_compare_3way(&(*a)->flow, &(*b)->flow); +} + +static int +compare_output_actions(const void *a_, const void *b_) +{ + const struct nlattr *a = a_; + const struct nlattr *b = b_; + uint32_t a_port = nl_attr_get_u32(a); + uint32_t b_port = nl_attr_get_u32(b); + + return a_port < b_port ? -1 : a_port > b_port; +} + +static void +sort_output_actions__(struct nlattr *first, struct nlattr *end) +{ + size_t bytes = (uint8_t *) end - (uint8_t *) first; + size_t n = bytes / NL_A_U32_SIZE; + + assert(bytes % NL_A_U32_SIZE == 0); + qsort(first, n, NL_A_U32_SIZE, compare_output_actions); +} + +static void +sort_output_actions(struct nlattr *actions, size_t length) +{ + struct nlattr *first_output = NULL; + struct nlattr *a; + int left; + + NL_ATTR_FOR_EACH (a, left, actions, length) { + if (nl_attr_type(a) == OVS_ACTION_ATTR_OUTPUT) { + if (!first_output) { + first_output = a; + } + } else { + if (first_output) { + sort_output_actions__(first_output, a); + first_output = NULL; } - printf("\n"); } } - dpif_close(&dpif); + if (first_output) { + uint8_t *end = (uint8_t *) actions + length; + sort_output_actions__(first_output, (struct nlattr *) end); + } } +/* usage: "ovs-dpctl normalize-actions FLOW ACTIONS" where FLOW and ACTIONS + * have the syntax used by "ovs-dpctl dump-flows". + * + * This command prints ACTIONS in a format that shows what happens for each + * VLAN, independent of the order of the ACTIONS. For example, there is more + * than one way to output a packet on VLANs 9 and 11, but this command will + * print the same output for any form. + * + * The idea here generalizes beyond VLANs (e.g. to setting other fields) but + * so far the implementation only covers VLANs. */ static void -do_help(int argc UNUSED, char *argv[] UNUSED) +dpctl_normalize_actions(int argc, char *argv[]) { - usage(); + struct simap port_names; + struct ofpbuf keybuf; + struct flow flow; + struct ofpbuf odp_actions; + struct hmap actions_per_flow; + struct actions_for_flow **afs; + struct actions_for_flow *af; + struct nlattr *a; + size_t n_afs; + struct ds s; + int left; + int i; + + ds_init(&s); + + simap_init(&port_names); + for (i = 3; i < argc; i++) { + char name[16]; + int number; + int n = -1; + + if (sscanf(argv[i], "%15[^=]=%d%n", name, &number, &n) > 0 && n > 0) { + uintptr_t n = number; + simap_put(&port_names, name, n); + } else { + ovs_fatal(0, "%s: expected NAME=NUMBER", argv[i]); + } + } + + /* Parse flow key. */ + ofpbuf_init(&keybuf, 0); + run(odp_flow_key_from_string(argv[1], &port_names, &keybuf), + "odp_flow_key_from_string"); + + ds_clear(&s); + odp_flow_key_format(keybuf.data, keybuf.size, &s); + printf("input flow: %s\n", ds_cstr(&s)); + + run(odp_flow_key_to_flow(keybuf.data, keybuf.size, &flow), + "odp_flow_key_to_flow"); + ofpbuf_uninit(&keybuf); + + /* Parse actions. */ + ofpbuf_init(&odp_actions, 0); + run(odp_actions_from_string(argv[2], &port_names, &odp_actions), + "odp_actions_from_string"); + + if (verbosity) { + ds_clear(&s); + format_odp_actions(&s, odp_actions.data, odp_actions.size); + printf("input actions: %s\n", ds_cstr(&s)); + } + + hmap_init(&actions_per_flow); + NL_ATTR_FOR_EACH (a, left, odp_actions.data, odp_actions.size) { + if (nl_attr_type(a) == OVS_ACTION_ATTR_POP_VLAN) { + flow.vlan_tci = htons(0); + continue; + } + + if (nl_attr_type(a) == OVS_ACTION_ATTR_PUSH_VLAN) { + const struct ovs_action_push_vlan *push; + + push = nl_attr_get_unspec(a, sizeof *push); + flow.vlan_tci = push->vlan_tci; + continue; + } + + af = get_actions_for_flow(&actions_per_flow, &flow); + nl_msg_put_unspec(&af->actions, nl_attr_type(a), + nl_attr_get(a), nl_attr_get_size(a)); + } + + n_afs = hmap_count(&actions_per_flow); + afs = xmalloc(n_afs * sizeof *afs); + i = 0; + HMAP_FOR_EACH (af, hmap_node, &actions_per_flow) { + afs[i++] = af; + } + assert(i == n_afs); + + qsort(afs, n_afs, sizeof *afs, compare_actions_for_flow); + + for (i = 0; i < n_afs; i++) { + const struct actions_for_flow *af = afs[i]; + + sort_output_actions(af->actions.data, af->actions.size); + + if (af->flow.vlan_tci != htons(0)) { + printf("vlan(vid=%"PRIu16",pcp=%d): ", + vlan_tci_to_vid(af->flow.vlan_tci), + vlan_tci_to_pcp(af->flow.vlan_tci)); + } else { + printf("no vlan: "); + } + + ds_clear(&s); + format_odp_actions(&s, af->actions.data, af->actions.size); + puts(ds_cstr(&s)); + } + ds_destroy(&s); } -static struct command all_commands[] = { - { "add-dp", 1, INT_MAX, do_add_dp }, - { "del-dp", 1, 1, do_del_dp }, - { "add-if", 2, INT_MAX, do_add_if }, - { "del-if", 2, INT_MAX, do_del_if }, - { "dump-dps", 0, 0, do_dump_dps }, - { "show", 0, INT_MAX, do_show }, - { "dump-flows", 1, 1, do_dump_flows }, - { "del-flows", 1, 1, do_del_flows }, - { "dump-groups", 1, 1, do_dump_groups }, - { "help", 0, INT_MAX, do_help }, +static const struct command all_commands[] = { + { "add-dp", 1, INT_MAX, dpctl_add_dp }, + { "del-dp", 1, 1, dpctl_del_dp }, + { "add-if", 2, INT_MAX, dpctl_add_if }, + { "del-if", 2, INT_MAX, dpctl_del_if }, + { "set-if", 2, INT_MAX, dpctl_set_if }, + { "dump-dps", 0, 0, dpctl_dump_dps }, + { "show", 0, INT_MAX, dpctl_show }, + { "dump-flows", 1, 1, dpctl_dump_flows }, + { "del-flows", 1, 1, dpctl_del_flows }, + { "help", 0, INT_MAX, dpctl_help }, + + /* Undocumented commands for testing. */ + { "parse-actions", 1, INT_MAX, dpctl_parse_actions }, + { "normalize-actions", 2, INT_MAX, dpctl_normalize_actions }, + { NULL, 0, 0, NULL }, };