#include "ofp-print.h"
#include "ofproto-dpif-governor.h"
#include "ofproto-dpif-ipfix.h"
+#include "ofproto-dpif-mirror.h"
#include "ofproto-dpif-sflow.h"
#include "ofproto-dpif-xlate.h"
#include "poll-loop.h"
static void rule_get_stats(struct rule *, uint64_t *packets, uint64_t *bytes);
static void rule_invalidate(const struct rule_dpif *);
-static void mirror_destroy(struct ofmirror *);
-static void update_mirror_stats(struct ofproto_dpif *ofproto,
- mirror_mask_t mirrors,
- uint64_t packets, uint64_t bytes);
-
static void bundle_remove(struct ofport *);
static void bundle_update(struct ofbundle *);
static void bundle_destroy(struct ofbundle *);
* for debugging the asynchronous flow_mod implementation.) */
static bool clogged;
+/* By default, flows in the datapath are wildcarded (megaflows). They
+ * may be disabled with the "ovs-appctl dpif/disable-megaflows" command. */
+static bool enable_megaflows = true;
+
/* All existing ofproto_dpif instances, indexed by ->up.name. */
static struct hmap all_ofproto_dpifs = HMAP_INITIALIZER(&all_ofproto_dpifs);
char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
const char *dp_port;
- if (!iter->tnl_port) {
+ if (!iter->is_tunnel) {
continue;
}
}
iter->odp_port = node ? u32_to_odp(node->data) : ODPP_NONE;
- if (tnl_port_reconfigure(&iter->up, iter->odp_port,
- &iter->tnl_port)) {
+ if (tnl_port_reconfigure(iter, iter->up.netdev,
+ iter->odp_port)) {
backer->need_revalidate = REV_RECONFIGURE;
}
}
free(backer_name);
if (error) {
VLOG_ERR("failed to open datapath of type %s: %s", type,
- strerror(error));
+ ovs_strerror(error));
free(backer);
return error;
}
error = dpif_recv_set(backer->dpif, backer->recv_set_enable);
if (error) {
VLOG_ERR("failed to listen on datapath of type %s: %s",
- type, strerror(error));
+ type, ovs_strerror(error));
close_dpif_backer(backer);
return error;
}
ofproto->stp = NULL;
hmap_init(&ofproto->bundles);
ofproto->ml = mac_learning_create(MAC_ENTRY_DEFAULT_IDLE_TIME);
- for (i = 0; i < MAX_MIRRORS; i++) {
- ofproto->mirrors[i] = NULL;
- }
+ ofproto->mbridge = mbridge_create();
ofproto->has_bonded_bundles = false;
classifier_init(&ofproto->facets);
ofproto_dpif_unixctl_init();
- ofproto->has_mirrors = false;
- ofproto->has_bundle_action = false;
-
hmap_init(&ofproto->vlandev_map);
hmap_init(&ofproto->realdev_vid_map);
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
struct rule_dpif *rule, *next_rule;
struct oftable *table;
- int i;
ofproto->backer->need_revalidate = REV_RECONFIGURE;
hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node);
}
}
- for (i = 0; i < MAX_MIRRORS; i++) {
- mirror_destroy(ofproto->mirrors[i]);
- }
+ mbridge_unref(ofproto->mbridge);
netflow_destroy(ofproto->netflow);
- dpif_sflow_destroy(ofproto->sflow);
+ dpif_sflow_unref(ofproto->sflow);
hmap_destroy(&ofproto->bundles);
- mac_learning_destroy(ofproto->ml);
+ mac_learning_unref(ofproto->ml);
classifier_destroy(&ofproto->facets);
complete_operations(ofproto);
}
+ if (mbridge_need_revalidate(ofproto->mbridge)) {
+ ofproto->backer->need_revalidate = REV_RECONFIGURE;
+ mac_learning_flush(ofproto->ml, NULL);
+ }
+
/* Do not perform any periodic activity below required by 'ofproto' while
* waiting for flow restore to complete. */
if (ofproto_get_flow_restore_wait()) {
port->may_enable = true;
port->stp_port = NULL;
port->stp_state = STP_DISABLED;
- port->tnl_port = NULL;
+ port->is_tunnel = false;
port->peer = NULL;
hmap_init(&port->priorities);
port->realdev_ofp_port = 0;
port->odp_port = dpif_port.port_no;
if (netdev_get_tunnel_config(netdev)) {
- port->tnl_port = tnl_port_add(&port->up, port->odp_port);
+ tnl_port_add(port, port->up.netdev, port->odp_port);
+ port->is_tunnel = true;
} else {
/* Sanity-check that a mapping doesn't already exist. This
* shouldn't happen for non-tunnel ports. */
}
hmap_insert(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node,
- hash_int(odp_to_u32(port->odp_port), 0));
+ hash_odp_port(port->odp_port));
}
dpif_port_destroy(&dpif_port);
char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
const char *dp_port_name;
+ ofproto->backer->need_revalidate = REV_RECONFIGURE;
+
dp_port_name = netdev_vport_get_dpif_port(port->up.netdev, namebuf,
sizeof namebuf);
if (dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
* happens when the ofproto is being destroyed, since the caller
* assumes that removal of attached ports will happen as part of
* destruction. */
- if (!port->tnl_port) {
+ if (!port->is_tunnel) {
dpif_port_del(ofproto->backer->dpif, port->odp_port);
}
- ofproto->backer->need_revalidate = REV_RECONFIGURE;
}
if (port->peer) {
port->peer = NULL;
}
- if (port->odp_port != ODPP_NONE && !port->tnl_port) {
+ if (port->odp_port != ODPP_NONE && !port->is_tunnel) {
hmap_remove(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node);
}
- tnl_port_del(port->tnl_port);
+ tnl_port_del(port);
sset_find_and_delete(&ofproto->ports, devname);
sset_find_and_delete(&ofproto->ghost_ports, devname);
- ofproto->backer->need_revalidate = REV_RECONFIGURE;
bundle_remove(port_);
set_cfm(port_, NULL);
set_bfd(port_, NULL);
cfm_set_netdev(port->cfm, port->up.netdev);
}
- if (port->tnl_port && tnl_port_reconfigure(&port->up, port->odp_port,
- &port->tnl_port)) {
- ofproto_dpif_cast(port->up.ofproto)->backer->need_revalidate = true;
+ if (port->is_tunnel && tnl_port_reconfigure(port, port->up.netdev,
+ port->odp_port)) {
+ ofproto_dpif_cast(port->up.ofproto)->backer->need_revalidate =
+ REV_RECONFIGURE;
}
ofport_update_peer(port);
dpif_sflow_set_options(ds, sflow_options);
} else {
if (ds) {
- dpif_sflow_destroy(ds);
+ dpif_sflow_unref(ds);
ofproto->backer->need_revalidate = REV_RECONFIGURE;
ofproto->sflow = NULL;
}
n_flow_exporters_options);
} else {
if (di) {
- dpif_ipfix_destroy(di);
+ dpif_ipfix_unref(di);
ofproto->ipfix = NULL;
}
}
error = EINVAL;
}
- cfm_destroy(ofport->cfm);
+ cfm_unref(ofport->cfm);
ofport->cfm = NULL;
return error;
}
return NULL;
}
-/* Looks up each of the 'n_auxes' pointers in 'auxes' as bundles and adds the
- * ones that are found to 'bundles'. */
-static void
-bundle_lookup_multiple(struct ofproto_dpif *ofproto,
- void **auxes, size_t n_auxes,
- struct hmapx *bundles)
-{
- size_t i;
-
- hmapx_init(bundles);
- for (i = 0; i < n_auxes; i++) {
- struct ofbundle *bundle = bundle_lookup(ofproto, auxes[i]);
- if (bundle) {
- hmapx_add(bundles, bundle);
- }
- }
-}
-
static void
bundle_update(struct ofbundle *bundle)
{
{
struct ofproto_dpif *ofproto;
struct ofport_dpif *port, *next_port;
- int i;
if (!bundle) {
return;
}
ofproto = bundle->ofproto;
- for (i = 0; i < MAX_MIRRORS; i++) {
- struct ofmirror *m = ofproto->mirrors[i];
- if (m) {
- if (m->out == bundle) {
- mirror_destroy(m);
- } else if (hmapx_find_and_delete(&m->srcs, bundle)
- || hmapx_find_and_delete(&m->dsts, bundle)) {
- ofproto->backer->need_revalidate = REV_RECONFIGURE;
- }
- }
- }
+ mbridge_unregister_bundle(ofproto->mbridge, bundle->aux);
LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
bundle_del_port(port);
hmap_remove(&ofproto->bundles, &bundle->hmap_node);
free(bundle->name);
free(bundle->trunks);
- lacp_destroy(bundle->lacp);
- bond_destroy(bundle->bond);
+ lacp_unref(bundle->lacp);
+ bond_unref(bundle->bond);
free(bundle);
}
bundle->bond = NULL;
bundle->floodable = true;
-
- bundle->src_mirrors = 0;
- bundle->dst_mirrors = 0;
- bundle->mirror_out = 0;
+ mbridge_register_bundle(ofproto->mbridge, bundle);
}
if (!bundle->name || strcmp(s->name, bundle->name)) {
}
lacp_configure(bundle->lacp, s->lacp);
} else {
- lacp_destroy(bundle->lacp);
+ lacp_unref(bundle->lacp);
bundle->lacp = NULL;
}
bond_slave_register(bundle->bond, port, port->up.netdev);
}
} else {
- bond_destroy(bundle->bond);
+ bond_unref(bundle->bond);
bundle->bond = NULL;
}
if (list_is_empty(&bundle->ports)) {
bundle_destroy(bundle);
} else if (list_is_short(&bundle->ports)) {
- bond_destroy(bundle->bond);
+ bond_unref(bundle->bond);
bundle->bond = NULL;
}
}
} else {
VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
"%s (%s)", port->bundle->name,
- netdev_get_name(port->up.netdev), strerror(error));
+ netdev_get_name(port->up.netdev), ovs_strerror(error));
}
}
static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
"packets, last error was: %s",
- bundle->name, n_errors, n_packets, strerror(error));
+ bundle->name, n_errors, n_packets, ovs_strerror(error));
} else {
VLOG_DBG("bond %s: sent %d gratuitous learning packets",
bundle->name, n_packets);
/* Mirrors. */
static int
-mirror_scan(struct ofproto_dpif *ofproto)
-{
- int idx;
-
- for (idx = 0; idx < MAX_MIRRORS; idx++) {
- if (!ofproto->mirrors[idx]) {
- return idx;
- }
- }
- return -1;
-}
-
-static struct ofmirror *
-mirror_lookup(struct ofproto_dpif *ofproto, void *aux)
-{
- int i;
-
- for (i = 0; i < MAX_MIRRORS; i++) {
- struct ofmirror *mirror = ofproto->mirrors[i];
- if (mirror && mirror->aux == aux) {
- return mirror;
- }
- }
-
- return NULL;
-}
-
-/* Update the 'dup_mirrors' member of each of the ofmirrors in 'ofproto'. */
-static void
-mirror_update_dups(struct ofproto_dpif *ofproto)
-{
- int i;
-
- for (i = 0; i < MAX_MIRRORS; i++) {
- struct ofmirror *m = ofproto->mirrors[i];
-
- if (m) {
- m->dup_mirrors = MIRROR_MASK_C(1) << i;
- }
- }
-
- for (i = 0; i < MAX_MIRRORS; i++) {
- struct ofmirror *m1 = ofproto->mirrors[i];
- int j;
-
- if (!m1) {
- continue;
- }
-
- for (j = i + 1; j < MAX_MIRRORS; j++) {
- struct ofmirror *m2 = ofproto->mirrors[j];
-
- if (m2 && m1->out == m2->out && m1->out_vlan == m2->out_vlan) {
- m1->dup_mirrors |= MIRROR_MASK_C(1) << j;
- m2->dup_mirrors |= m1->dup_mirrors;
- }
- }
- }
-}
-
-static int
-mirror_set(struct ofproto *ofproto_, void *aux,
- const struct ofproto_mirror_settings *s)
+mirror_set__(struct ofproto *ofproto_, void *aux,
+ const struct ofproto_mirror_settings *s)
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
- mirror_mask_t mirror_bit;
- struct ofbundle *bundle;
- struct ofmirror *mirror;
- struct ofbundle *out;
- struct hmapx srcs; /* Contains "struct ofbundle *"s. */
- struct hmapx dsts; /* Contains "struct ofbundle *"s. */
- int out_vlan;
+ struct ofbundle **srcs, **dsts;
+ int error;
+ size_t i;
- mirror = mirror_lookup(ofproto, aux);
if (!s) {
- mirror_destroy(mirror);
- return 0;
- }
- if (!mirror) {
- int idx;
-
- idx = mirror_scan(ofproto);
- if (idx < 0) {
- VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
- "cannot create %s",
- ofproto->up.name, MAX_MIRRORS, s->name);
- return EFBIG;
- }
-
- mirror = ofproto->mirrors[idx] = xzalloc(sizeof *mirror);
- mirror->ofproto = ofproto;
- mirror->idx = idx;
- mirror->aux = aux;
- mirror->out_vlan = -1;
- mirror->name = NULL;
- }
-
- if (!mirror->name || strcmp(s->name, mirror->name)) {
- free(mirror->name);
- mirror->name = xstrdup(s->name);
- }
-
- /* Get the new configuration. */
- if (s->out_bundle) {
- out = bundle_lookup(ofproto, s->out_bundle);
- if (!out) {
- mirror_destroy(mirror);
- return EINVAL;
- }
- out_vlan = -1;
- } else {
- out = NULL;
- out_vlan = s->out_vlan;
- }
- bundle_lookup_multiple(ofproto, s->srcs, s->n_srcs, &srcs);
- bundle_lookup_multiple(ofproto, s->dsts, s->n_dsts, &dsts);
-
- /* If the configuration has not changed, do nothing. */
- if (hmapx_equals(&srcs, &mirror->srcs)
- && hmapx_equals(&dsts, &mirror->dsts)
- && vlan_bitmap_equal(mirror->vlans, s->src_vlans)
- && mirror->out == out
- && mirror->out_vlan == out_vlan)
- {
- hmapx_destroy(&srcs);
- hmapx_destroy(&dsts);
+ mirror_destroy(ofproto->mbridge, aux);
return 0;
}
- hmapx_swap(&srcs, &mirror->srcs);
- hmapx_destroy(&srcs);
-
- hmapx_swap(&dsts, &mirror->dsts);
- hmapx_destroy(&dsts);
-
- free(mirror->vlans);
- mirror->vlans = vlan_bitmap_clone(s->src_vlans);
-
- mirror->out = out;
- mirror->out_vlan = out_vlan;
-
- /* Update bundles. */
- mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
- HMAP_FOR_EACH (bundle, hmap_node, &mirror->ofproto->bundles) {
- if (hmapx_contains(&mirror->srcs, bundle)) {
- bundle->src_mirrors |= mirror_bit;
- } else {
- bundle->src_mirrors &= ~mirror_bit;
- }
-
- if (hmapx_contains(&mirror->dsts, bundle)) {
- bundle->dst_mirrors |= mirror_bit;
- } else {
- bundle->dst_mirrors &= ~mirror_bit;
- }
-
- if (mirror->out == bundle) {
- bundle->mirror_out |= mirror_bit;
- } else {
- bundle->mirror_out &= ~mirror_bit;
- }
- }
-
- ofproto->backer->need_revalidate = REV_RECONFIGURE;
- ofproto->has_mirrors = true;
- mac_learning_flush(ofproto->ml,
- &ofproto->backer->revalidate_set);
- mirror_update_dups(ofproto);
+ srcs = xmalloc(s->n_srcs * sizeof *srcs);
+ dsts = xmalloc(s->n_dsts * sizeof *dsts);
- return 0;
-}
-
-static void
-mirror_destroy(struct ofmirror *mirror)
-{
- struct ofproto_dpif *ofproto;
- mirror_mask_t mirror_bit;
- struct ofbundle *bundle;
- int i;
-
- if (!mirror) {
- return;
+ for (i = 0; i < s->n_srcs; i++) {
+ srcs[i] = bundle_lookup(ofproto, s->srcs[i]);
}
- ofproto = mirror->ofproto;
- ofproto->backer->need_revalidate = REV_RECONFIGURE;
- mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
-
- mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
- HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
- bundle->src_mirrors &= ~mirror_bit;
- bundle->dst_mirrors &= ~mirror_bit;
- bundle->mirror_out &= ~mirror_bit;
+ for (i = 0; i < s->n_dsts; i++) {
+ dsts[i] = bundle_lookup(ofproto, s->dsts[i]);
}
- hmapx_destroy(&mirror->srcs);
- hmapx_destroy(&mirror->dsts);
- free(mirror->vlans);
-
- ofproto->mirrors[mirror->idx] = NULL;
- free(mirror->name);
- free(mirror);
-
- mirror_update_dups(ofproto);
-
- ofproto->has_mirrors = false;
- for (i = 0; i < MAX_MIRRORS; i++) {
- if (ofproto->mirrors[i]) {
- ofproto->has_mirrors = true;
- break;
- }
- }
+ error = mirror_set(ofproto->mbridge, aux, s->name, srcs, s->n_srcs, dsts,
+ s->n_dsts, s->src_vlans,
+ bundle_lookup(ofproto, s->out_bundle), s->out_vlan);
+ free(srcs);
+ free(dsts);
+ return error;
}
static int
-mirror_get_stats(struct ofproto *ofproto_, void *aux,
- uint64_t *packets, uint64_t *bytes)
+mirror_get_stats__(struct ofproto *ofproto, void *aux,
+ uint64_t *packets, uint64_t *bytes)
{
- struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
- struct ofmirror *mirror = mirror_lookup(ofproto, aux);
-
- if (!mirror) {
- *packets = *bytes = UINT64_MAX;
- return 0;
- }
-
push_all_stats();
-
- *packets = mirror->packet_count;
- *bytes = mirror->byte_count;
-
- return 0;
+ return mirror_get_stats(ofproto_dpif_cast(ofproto)->mbridge, aux, packets,
+ bytes);
}
static int
{
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
struct ofbundle *bundle = bundle_lookup(ofproto, aux);
- return bundle && bundle->mirror_out != 0;
+ return bundle && mirror_bundle_out(ofproto->mbridge, bundle) != 0;
}
static void
}
backer = ofproto_dpif_cast(ofport->up.ofproto)->backer;
- backer->need_revalidate = true;
+ backer->need_revalidate = REV_RECONFIGURE;
if (ofport->peer) {
ofport->peer->peer = NULL;
if (ofport->may_enable != enable) {
struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
-
- if (ofproto->has_bundle_action) {
- ofproto->backer->need_revalidate = REV_PORT_TOGGLED;
- }
+ ofproto->backer->need_revalidate = REV_PORT_TOGGLED;
}
ofport->may_enable = enable;
sset_find_and_delete(&ofproto->ghost_ports,
netdev_get_name(ofport->up.netdev));
ofproto->backer->need_revalidate = REV_RECONFIGURE;
- if (!ofport->tnl_port) {
+ if (!ofport->is_tunnel) {
error = dpif_port_del(ofproto->backer->dpif, ofport->odp_port);
if (!error) {
/* The caller is going to close ofport->up.netdev. If this is a
struct dpif_backer *backer = miss->ofproto->backer;
uint32_t hash;
+ switch (flow_miss_model) {
+ case OFPROTO_HANDLE_MISS_AUTO:
+ break;
+ case OFPROTO_HANDLE_MISS_WITH_FACETS:
+ return true;
+ case OFPROTO_HANDLE_MISS_WITHOUT_FACETS:
+ return false;
+ }
+
if (!backer->governor) {
size_t n_subfacets;
subfacet->path = want_path;
ofpbuf_use_stack(&op->mask, &op->maskbuf, sizeof op->maskbuf);
- odp_flow_key_from_mask(&op->mask, &facet->xout.wc.masks,
- &miss->flow, UINT32_MAX);
+ if (enable_megaflows) {
+ odp_flow_key_from_mask(&op->mask, &facet->xout.wc.masks,
+ &miss->flow, UINT32_MAX);
+ }
op->xout_garbage = false;
op->dpif_op.type = DPIF_OP_FLOW_PUT;
if (error && !VLOG_DROP_WARN(&rl)) {
struct ds ds = DS_EMPTY_INITIALIZER;
odp_flow_key_format(drop_key->key, drop_key->key_len, &ds);
- VLOG_WARN("Failed to delete drop key (%s) (%s)", strerror(error),
- ds_cstr(&ds));
+ VLOG_WARN("Failed to delete drop key (%s) (%s)",
+ ovs_strerror(error), ds_cstr(&ds));
ds_destroy(&ds);
}
}
port = (tnl_port_should_receive(flow)
- ? ofport_dpif_cast(tnl_port_receive(flow))
+ ? tnl_port_receive(flow)
: odp_port_to_ofport(backer, flow->in_port.odp_port));
flow->in_port.ofp_port = port ? port->up.ofp_port : OFPP_NONE;
if (!port) {
facet->prev_used = facet->used;
in_port = get_ofp_port(ofproto, facet->flow.in_port.ofp_port);
- if (in_port && in_port->tnl_port) {
+ if (in_port && in_port->is_tunnel) {
netdev_vport_inc_rx(in_port->up.netdev, &stats);
}
netflow_flow_update_time(ofproto->netflow, &facet->nf_flow,
facet->used);
netflow_flow_update_flags(&facet->nf_flow, facet->tcp_flags);
- update_mirror_stats(ofproto, facet->xout.mirrors, stats.n_packets,
- stats.n_bytes);
+ mirror_update_stats(ofproto->mbridge, facet->xout.mirrors,
+ stats.n_packets, stats.n_bytes);
xlate_in_init(&xin, ofproto, &facet->flow, facet->rule,
stats.tcp_flags, NULL);
}
ofpbuf_use_stack(&mask, &maskbuf, sizeof maskbuf);
- odp_flow_key_from_mask(&mask, &facet->xout.wc.masks,
- &facet->flow, UINT32_MAX);
+ if (enable_megaflows) {
+ odp_flow_key_from_mask(&mask, &facet->xout.wc.masks,
+ &facet->flow, UINT32_MAX);
+ }
ret = dpif_flow_put(subfacet->backer->dpif, flags, subfacet->key,
subfacet->key_len, mask.data, mask.size,
}
if (wc) {
+ memset(&wc->masks.dl_type, 0xff, sizeof wc->masks.dl_type);
wc->masks.nw_frag |= FLOW_NW_FRAG_MASK;
}
if (error) {
VLOG_WARN_RL(&rl, "%s: failed to send packet on port %s (%s)",
ofproto->up.name, netdev_get_name(ofport->up.netdev),
- strerror(error));
+ ovs_strerror(error));
}
ofproto->stats.tx_packets++;
return odp_put_userspace_action(pid, cookie, cookie_size, odp_actions);
}
-
-static void
-update_mirror_stats(struct ofproto_dpif *ofproto, mirror_mask_t mirrors,
- uint64_t packets, uint64_t bytes)
+tag_type
+calculate_flow_tag(struct ofproto_dpif *ofproto, const struct flow *flow,
+ uint8_t table_id, struct rule_dpif *rule)
{
- if (!mirrors) {
- return;
- }
-
- for (; mirrors; mirrors = zero_rightmost_1bit(mirrors)) {
- struct ofmirror *m;
-
- m = ofproto->mirrors[mirror_mask_ffs(mirrors) - 1];
-
- if (!m) {
- /* In normal circumstances 'm' will not be NULL. However,
- * if mirrors are reconfigured, we can temporarily get out
- * of sync in facet_revalidate(). We could "correct" the
- * mirror list before reaching here, but doing that would
- * not properly account the traffic stats we've currently
- * accumulated for previous mirror configuration. */
- continue;
+ if (table_id > 0 && table_id < N_TABLES) {
+ struct table_dpif *table = &ofproto->tables[table_id];
+ if (table->other_table) {
+ return (rule && rule->tag
+ ? rule->tag
+ : rule_calculate_tag(flow, &table->other_table->mask,
+ table->basis));
}
-
- m->packet_count += packets;
- m->byte_count += bytes;
}
-}
+ return 0;
+}
\f
/* Optimized flow revalidation.
*
{
const struct dpif_backer *backer;
struct ofproto_dpif *ofproto;
- struct ofpbuf odp_key;
+ struct ofpbuf odp_key, odp_mask;
struct ofpbuf *packet;
struct ds result;
struct flow flow;
backer = NULL;
ds_init(&result);
ofpbuf_init(&odp_key, 0);
+ ofpbuf_init(&odp_mask, 0);
/* Handle "-generate" or a hex string as the last argument. */
if (!strcmp(argv[argc - 1], "-generate")) {
* bridge is specified. If function odp_flow_key_from_string()
* returns 0, the flow is a odp_flow. If function
* parse_ofp_exact_flow() returns 0, the flow is a br_flow. */
- if (!odp_flow_from_string(argv[argc - 1], NULL, &odp_key, NULL)) {
+ if (!odp_flow_from_string(argv[argc - 1], NULL, &odp_key, &odp_mask)) {
/* If the odp_flow is the second argument,
* the datapath name is the first argument. */
if (argc == 3) {
ds_destroy(&result);
ofpbuf_delete(packet);
ofpbuf_uninit(&odp_key);
+ ofpbuf_uninit(&odp_mask);
}
void
ds_destroy(&ds);
}
+/* Disable using the megaflows.
+ *
+ * This command is only needed for advanced debugging, so it's not
+ * documented in the man page. */
+static void
+ofproto_unixctl_dpif_disable_megaflows(struct unixctl_conn *conn,
+ int argc OVS_UNUSED,
+ const char *argv[] OVS_UNUSED,
+ void *aux OVS_UNUSED)
+{
+ struct ofproto_dpif *ofproto;
+
+ enable_megaflows = false;
+
+ HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
+ flush(&ofproto->up);
+ }
+
+ unixctl_command_reply(conn, "megaflows disabled");
+}
+
+/* Re-enable using megaflows.
+ *
+ * This command is only needed for advanced debugging, so it's not
+ * documented in the man page. */
+static void
+ofproto_unixctl_dpif_enable_megaflows(struct unixctl_conn *conn,
+ int argc OVS_UNUSED,
+ const char *argv[] OVS_UNUSED,
+ void *aux OVS_UNUSED)
+{
+ struct ofproto_dpif *ofproto;
+
+ enable_megaflows = true;
+
+ HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
+ flush(&ofproto->up);
+ }
+
+ unixctl_command_reply(conn, "megaflows enabled");
+}
+
static void
ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn,
int argc OVS_UNUSED, const char *argv[],
ofproto_unixctl_dpif_del_flows, NULL);
unixctl_command_register("dpif/dump-megaflows", "bridge", 1, 1,
ofproto_unixctl_dpif_dump_megaflows, NULL);
+ unixctl_command_register("dpif/disable-megaflows", "", 0, 0,
+ ofproto_unixctl_dpif_disable_megaflows, NULL);
+ unixctl_command_register("dpif/enable-megaflows", "", 0, 0,
+ ofproto_unixctl_dpif_enable_megaflows, NULL);
}
\f
/* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
struct vlan_splinter *vsp;
HMAP_FOR_EACH_WITH_HASH (vsp, vlandev_node,
- hash_int(ofp_to_u16(vlandev_ofp_port), 0),
+ hash_ofp_port(vlandev_ofp_port),
&ofproto->vlandev_map) {
if (vsp->vlandev_ofp_port == vlandev_ofp_port) {
return vsp;
vsp = xmalloc(sizeof *vsp);
hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node,
- hash_int(ofp_to_u16(port->up.ofp_port), 0));
+ hash_ofp_port(port->up.ofp_port));
hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node,
hash_realdev_vid(realdev_ofp_port, vid));
vsp->realdev_ofp_port = realdev_ofp_port;
{
struct ofport_dpif *port;
- HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node,
- hash_int(odp_to_u32(odp_port), 0),
+ HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node, hash_odp_port(odp_port),
&backer->odp_to_ofport_map) {
if (port->odp_port == odp_port) {
return port;
set_queues,
bundle_set,
bundle_remove,
- mirror_set,
- mirror_get_stats,
+ mirror_set__,
+ mirror_get_stats__,
set_flood_vlans,
is_mirror_output_bundle,
forward_bpdu_changed,
set_mac_table_config,
set_realdev,
+ NULL, /* meter_get_features */
+ NULL, /* meter_set */
+ NULL, /* meter_get */
+ NULL, /* meter_del */
};
git://git.onelab.eu / sliver-openvswitch.git / blobdiff