#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");
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
-dpctl_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
-dpctl_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);
}
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);
}
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));
{ "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 },
+ { "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. */
git://git.onelab.eu / sliver-openvswitch.git / blobdiff