#include <config.h>
#include <arpa/inet.h>
-#include <assert.h>
#include <errno.h>
#include <getopt.h>
#include <inttypes.h>
VLOG_DEFINE_THIS_MODULE(dpctl);
-/* -s, --statistics: Print port statistics? */
+/* -s, --statistics: Print port/flow statistics? */
static bool print_statistics;
+/* --clear: Reset existing statistics to zero when modifying a flow? */
+static bool zero_statistics;
+
+/* --may-create: Allow mod-flows command to create a new flow? */
+static bool may_create;
+
/* -m, --more: Output verbosity.
*
* So far only undocumented commands honor this option, so we don't document
parse_options(int argc, char *argv[])
{
enum {
- OPT_DUMMY = UCHAR_MAX + 1,
+ OPT_CLEAR = UCHAR_MAX + 1,
+ OPT_MAY_CREATE,
VLOG_OPTION_ENUMS
};
static struct option long_options[] = {
{"statistics", no_argument, NULL, 's'},
+ {"clear", no_argument, NULL, OPT_CLEAR},
+ {"may-create", no_argument, NULL, OPT_MAY_CREATE},
{"more", no_argument, NULL, 'm'},
{"timeout", required_argument, NULL, 't'},
{"help", no_argument, NULL, 'h'},
print_statistics = true;
break;
+ case OPT_CLEAR:
+ zero_statistics = true;
+ break;
+
+ case OPT_MAY_CREATE:
+ may_create = true;
+ break;
+
case 'm':
verbosity++;
break;
" 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"
+ " add-flow DP FLOW ACTIONS add FLOW with ACTIONS to DP\n"
+ " mod-flow DP FLOW ACTIONS change FLOW actions to ACTIONS in DP\n"
+ " del-flow DP FLOW delete FLOW from DP\n"
" del-flows DP delete all flows from 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"
+ printf("\nOptions for show and mod-flow:\n"
+ " -s, --statistics print statistics for port or flow\n"
+ "\nOptions for mod-flow:\n"
+ " --may-create create flow if it doesn't exist\n"
+ " --clear reset existing stats to zero\n"
+ "\nOther options:\n"
" -t, --timeout=SECS give up after SECS seconds\n"
" -h, --help display this help message\n"
" -V, --version display version information\n");
}
}
\f
-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)
{
return retval;
}
+/* Retrieve the name of the datapath if exactly one exists. The caller
+ * is responsible for freeing the returned string. If there is not one
+ * datapath, aborts with an error message. */
+static char *
+get_one_dp(void)
+{
+ struct sset types;
+ const char *type;
+ char *dp_name = NULL;
+ size_t count = 0;
+
+ sset_init(&types);
+ dp_enumerate_types(&types);
+ SSET_FOR_EACH (type, &types) {
+ struct sset names;
+
+ sset_init(&names);
+ if (!dp_enumerate_names(type, &names)) {
+ count += sset_count(&names);
+ if (!dp_name && count == 1) {
+ dp_name = xasprintf("%s@%s", type, SSET_FIRST(&names));
+ }
+ }
+ sset_destroy(&names);
+ }
+ sset_destroy(&types);
+
+ if (!count) {
+ ovs_fatal(0, "no datapaths exist");
+ } else if (count > 1) {
+ ovs_fatal(0, "multiple datapaths, specify one");
+ }
+
+ return dp_name;
+}
+
static int
parsed_dpif_open(const char *arg_, bool create, struct dpif **dpifp)
{
}
static void
-do_add_dp(int argc OVS_UNUSED, char *argv[])
+dpctl_add_dp(int argc OVS_UNUSED, char *argv[])
{
struct dpif *dpif;
run(parsed_dpif_open(argv[1], true, &dpif), "add_dp");
dpif_close(dpif);
if (argc > 2) {
- do_add_if(argc, argv);
+ dpctl_add_if(argc, argv);
}
}
static void
-do_del_dp(int argc OVS_UNUSED, char *argv[])
+dpctl_del_dp(int argc OVS_UNUSED, char *argv[])
{
struct dpif *dpif;
run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
}
static void
-do_add_if(int argc OVS_UNUSED, char *argv[])
+dpctl_add_if(int argc OVS_UNUSED, char *argv[])
{
bool failure = false;
struct dpif *dpif;
char *save_ptr = NULL;
struct netdev *netdev = NULL;
struct smap args;
+ uint32_t port_no = UINT32_MAX;
char *option;
int error;
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);
}
goto next;
}
- error = dpif_port_add(dpif, netdev, NULL);
+ error = dpif_port_add(dpif, netdev, &port_no);
if (error) {
ovs_error(error, "adding %s to %s failed", name, argv[1]);
goto next;
}
static void
-do_set_if(int argc, char *argv[])
+dpctl_set_if(int argc, char *argv[])
{
bool failure = false;
struct dpif *dpif;
char *type = NULL;
const char *name;
struct smap args;
+ uint32_t port_no;
char *option;
int error;
goto next;
}
type = xstrdup(dpif_port.type);
+ port_no = dpif_port.port_no;
dpif_port_destroy(&dpif_port);
/* Retrieve its existing configuration. */
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 {
}
static bool
-get_port_number(struct dpif *dpif, const char *name, uint16_t *port)
+get_port_number(struct dpif *dpif, const char *name, uint32_t *port)
{
struct dpif_port dpif_port;
}
static void
-do_del_if(int argc OVS_UNUSED, char *argv[])
+dpctl_del_if(int argc OVS_UNUSED, char *argv[])
{
bool failure = false;
struct dpif *dpif;
run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
for (i = 2; i < argc; i++) {
const char *name = argv[i];
- uint16_t port;
+ uint32_t port;
int error;
if (!name[strspn(name, "0123456789")]) {
}
static void
-do_show(int argc, char *argv[])
+dpctl_show(int argc, char *argv[])
{
bool failure = false;
if (argc > 1) {
}
static void
-do_dump_dps(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
+dpctl_dump_dps(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
{
struct sset dpif_names, dpif_types;
const char *type;
}
static void
-do_dump_flows(int argc OVS_UNUSED, char *argv[])
+dpctl_dump_flows(int argc, char *argv[])
{
const struct dpif_flow_stats *stats;
const struct nlattr *actions;
struct dpif *dpif;
size_t key_len;
struct ds ds;
+ char *name;
- run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
+ name = (argc == 2) ? xstrdup(argv[1]) : get_one_dp();
+ run(parsed_dpif_open(name, false, &dpif), "opening datapath");
+ free(name);
ds_init(&ds);
dpif_flow_dump_start(&dump, dpif);
}
static void
-do_del_flows(int argc OVS_UNUSED, char *argv[])
+dpctl_put_flow(int argc, char *argv[], enum dpif_flow_put_flags flags)
{
+ const char *key_s = argv[argc - 2];
+ const char *actions_s = argv[argc - 1];
+ struct dpif_flow_stats stats;
+ struct ofpbuf actions;
+ struct ofpbuf key;
struct dpif *dpif;
+ char *dp_name;
+
+ ofpbuf_init(&key, 0);
+ run(odp_flow_key_from_string(key_s, NULL, &key), "parsing flow key");
+
+ ofpbuf_init(&actions, 0);
+ run(odp_actions_from_string(actions_s, NULL, &actions), "parsing actions");
+
+ dp_name = argc == 3 ? xstrdup(argv[1]) : get_one_dp();
+ run(parsed_dpif_open(dp_name, false, &dpif), "opening datapath");
+ free(dp_name);
+
+ run(dpif_flow_put(dpif, flags,
+ key.data, key.size,
+ actions.data, actions.size,
+ print_statistics ? &stats : NULL),
+ "updating flow table");
+
+ ofpbuf_uninit(&key);
+ ofpbuf_uninit(&actions);
+
+ if (print_statistics) {
+ struct ds s;
+
+ ds_init(&s);
+ dpif_flow_stats_format(&stats, &s);
+ puts(ds_cstr(&s));
+ ds_destroy(&s);
+ }
+}
+
+static void
+dpctl_add_flow(int argc, char *argv[])
+{
+ dpctl_put_flow(argc, argv, DPIF_FP_CREATE);
+}
+
+static void
+dpctl_mod_flow(int argc OVS_UNUSED, char *argv[])
+{
+ enum dpif_flow_put_flags flags;
+
+ flags = DPIF_FP_MODIFY;
+ if (may_create) {
+ flags |= DPIF_FP_CREATE;
+ }
+ if (zero_statistics) {
+ flags |= DPIF_FP_ZERO_STATS;
+ }
+
+ dpctl_put_flow(argc, argv, flags);
+}
+
+static void
+dpctl_del_flow(int argc, char *argv[])
+{
+ const char *key_s = argv[argc - 1];
+ struct dpif_flow_stats stats;
+ struct ofpbuf key;
+ struct dpif *dpif;
+ char *dp_name;
+
+ ofpbuf_init(&key, 0);
+ run(odp_flow_key_from_string(key_s, NULL, &key), "parsing flow key");
+
+ dp_name = argc == 2 ? xstrdup(argv[1]) : get_one_dp();
+ run(parsed_dpif_open(dp_name, false, &dpif), "opening datapath");
+ free(dp_name);
+
+ run(dpif_flow_del(dpif,
+ key.data, key.size,
+ print_statistics ? &stats : NULL), "deleting flow");
+
+ ofpbuf_uninit(&key);
+
+ if (print_statistics) {
+ struct ds s;
+
+ ds_init(&s);
+ dpif_flow_stats_format(&stats, &s);
+ puts(ds_cstr(&s));
+ ds_destroy(&s);
+ }
+}
+
+static void
+dpctl_del_flows(int argc, char *argv[])
+{
+ struct dpif *dpif;
+ char *name;
+
+ name = (argc == 2) ? xstrdup(argv[1]) : get_one_dp();
+ run(parsed_dpif_open(name, false, &dpif), "opening datapath");
+ free(name);
- run(parsed_dpif_open(argv[1], false, &dpif), "opening datapath");
run(dpif_flow_flush(dpif), "deleting all flows");
dpif_close(dpif);
}
static void
-do_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
+dpctl_help(int argc OVS_UNUSED, char *argv[] OVS_UNUSED)
{
usage();
}
/* Undocumented commands for unit testing. */
static void
-do_parse_actions(int argc, char *argv[])
+dpctl_parse_actions(int argc, char *argv[])
{
int i;
size_t bytes = (uint8_t *) end - (uint8_t *) first;
size_t n = bytes / NL_A_U32_SIZE;
- assert(bytes % NL_A_U32_SIZE == 0);
+ ovs_assert(bytes % NL_A_U32_SIZE == 0);
qsort(first, n, NL_A_U32_SIZE, compare_output_actions);
}
* The idea here generalizes beyond VLANs (e.g. to setting other fields) but
* so far the implementation only covers VLANs. */
static void
-do_normalize_actions(int argc, char *argv[])
+dpctl_normalize_actions(int argc, char *argv[])
{
struct simap port_names;
struct ofpbuf keybuf;
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) {
+ const struct ovs_action_push_vlan *push;
+ switch(nl_attr_type(a)) {
+ case 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;
+ case OVS_ACTION_ATTR_PUSH_VLAN:
push = nl_attr_get_unspec(a, sizeof *push);
flow.vlan_tci = push->vlan_tci;
continue;
HMAP_FOR_EACH (af, hmap_node, &actions_per_flow) {
afs[i++] = af;
}
- assert(i == n_afs);
+ ovs_assert(i == n_afs);
qsort(afs, n_afs, sizeof *afs, compare_actions_for_flow);
printf("no vlan: ");
}
+ if (af->flow.mpls_depth) {
+ printf("mpls(label=%"PRIu32",tc=%d,ttl=%d): ",
+ mpls_lse_to_label(af->flow.mpls_lse),
+ mpls_lse_to_tc(af->flow.mpls_lse),
+ mpls_lse_to_ttl(af->flow.mpls_lse));
+ } else {
+ printf("no mpls: ");
+ }
+
ds_clear(&s);
format_odp_actions(&s, af->actions.data, af->actions.size);
puts(ds_cstr(&s));
}
static const 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 },
- { "set-if", 2, INT_MAX, do_set_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 },
- { "help", 0, INT_MAX, do_help },
+ { "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", 0, 1, dpctl_dump_flows },
+ { "add-flow", 2, 3, dpctl_add_flow },
+ { "mod-flow", 2, 3, dpctl_mod_flow },
+ { "del-flow", 1, 2, dpctl_del_flow },
+ { "del-flows", 0, 1, dpctl_del_flows },
+ { "help", 0, INT_MAX, dpctl_help },
/* Undocumented commands for testing. */
- { "parse-actions", 1, INT_MAX, do_parse_actions },
- { "normalize-actions", 2, INT_MAX, do_normalize_actions },
+ { "parse-actions", 1, INT_MAX, dpctl_parse_actions },
+ { "normalize-actions", 2, INT_MAX, dpctl_normalize_actions },
{ NULL, 0, 0, NULL },
};
git://git.onelab.eu / sliver-openvswitch.git / blobdiff