#include "svec.h"
#include "tag.h"
#include "timeval.h"
+#include "unaligned.h"
#include "unixctl.h"
#include "vconn.h"
#include "vlog.h"
int recurse; /* Recursion level, via xlate_table_action. */
int last_pop_priority; /* Offset in 'odp_actions' just past most
- * recently added ODPAT_SET_PRIORITY. */
+ * recent ODP_ACTION_ATTR_SET_PRIORITY. */
};
static void action_xlate_ctx_init(struct action_xlate_ctx *,
*
* - Do include packets and bytes that were obtained from the datapath
* when a flow was deleted (e.g. dpif_flow_del()) or when its
- * statistics were reset (e.g. dpif_flow_put() with ODPPF_ZERO_STATS).
+ * statistics were reset (e.g. dpif_flow_put() with
+ * DPIF_FP_ZERO_STATS).
*
* - Do not include any packets or bytes that can currently be obtained
* from the datapath by, e.g., dpif_flow_get().
static void facet_make_actions(struct ofproto *, struct facet *,
const struct ofpbuf *packet);
static void facet_update_stats(struct ofproto *, struct facet *,
- const struct odp_flow_stats *);
+ const struct dpif_flow_stats *);
/* ofproto supports two kinds of OpenFlow connections:
*
/* OFPT_PACKET_IN related data. */
struct rconn_packet_counter *packet_in_counter; /* # queued on 'rconn'. */
- struct pinsched *schedulers[2]; /* Indexed by reason code; see below. */
+#define N_SCHEDULERS 2
+ struct pinsched *schedulers[N_SCHEDULERS];
struct pktbuf *pktbuf; /* OpenFlow packet buffers. */
int miss_send_len; /* Bytes to send of buffered packets. */
enum ofproto_band band; /* In-band or out-of-band? */
};
-/* We use OFPR_NO_MATCH and OFPR_ACTION as indexes into struct ofconn's
- * "schedulers" array. Their values are 0 and 1, and their meanings and values
- * coincide with _ODPL_MISS_NR and _ODPL_ACTION_NR, so this is convenient. In
- * case anything ever changes, check their values here. */
-#define N_SCHEDULERS 2
-BUILD_ASSERT_DECL(OFPR_NO_MATCH == 0);
-BUILD_ASSERT_DECL(OFPR_NO_MATCH == _ODPL_MISS_NR);
-BUILD_ASSERT_DECL(OFPR_ACTION == 1);
-BUILD_ASSERT_DECL(OFPR_ACTION == _ODPL_ACTION_NR);
static struct ofconn *ofconn_create(struct ofproto *, struct rconn *,
enum ofconn_type);
VLOG_ERR("failed to open datapath %s: %s", datapath, strerror(error));
return error;
}
- error = dpif_recv_set_mask(dpif, ODPL_MISS | ODPL_ACTION | ODPL_SFLOW);
+ error = dpif_recv_set_mask(dpif,
+ ((1u << DPIF_UC_MISS) |
+ (1u << DPIF_UC_ACTION) |
+ (1u << DPIF_UC_SAMPLE)));
if (error) {
VLOG_ERR("failed to listen on datapath %s: %s",
datapath, strerror(error));
cinfo->pairs.n = 0;
- if (last_error == EOF) {
- cinfo->pairs.keys[cinfo->pairs.n] = "last_error";
- cinfo->pairs.values[cinfo->pairs.n++] = xstrdup("End of file");
- } else if (last_error > 0) {
+ if (last_error) {
cinfo->pairs.keys[cinfo->pairs.n] = "last_error";
cinfo->pairs.values[cinfo->pairs.n++] =
- xstrdup(strerror(last_error));
+ xstrdup(ovs_retval_to_string(last_error));
}
cinfo->pairs.keys[cinfo->pairs.n] = "state";
struct ofpbuf *packet)
{
if (actions_len == NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t))
- && odp_actions->nla_type == ODPAT_CONTROLLER) {
+ && odp_actions->nla_type == ODP_ACTION_ATTR_CONTROLLER) {
/* As an optimization, avoid a round-trip from userspace to kernel to
* userspace. This also avoids possibly filling up kernel packet
* buffers along the way. */
struct dpif_upcall upcall;
- upcall.type = _ODPL_ACTION_NR;
+ upcall.type = DPIF_UC_ACTION;
upcall.packet = packet;
upcall.key = NULL;
upcall.key_len = 0;
facet_execute(struct ofproto *ofproto, struct facet *facet,
struct ofpbuf *packet)
{
- struct odp_flow_stats stats;
+ struct dpif_flow_stats stats;
assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
}
static int
-facet_put__(struct ofproto *ofproto, struct facet *facet, int flags,
- struct odp_flow_put *put)
+facet_put__(struct ofproto *ofproto, struct facet *facet,
+ const struct nlattr *actions, size_t actions_len,
+ struct dpif_flow_stats *stats)
{
uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
+ enum dpif_flow_put_flags flags;
struct ofpbuf key;
+ flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
+ if (stats) {
+ flags |= DPIF_FP_ZERO_STATS;
+ }
+
ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
odp_flow_key_from_flow(&key, &facet->flow);
assert(key.base == keybuf);
- memset(&put->flow.stats, 0, sizeof put->flow.stats);
- put->flow.key = key.data;
- put->flow.key_len = key.size;
- put->flow.actions = facet->actions;
- put->flow.actions_len = facet->actions_len;
- put->flow.flags = 0;
- put->flags = flags;
- return dpif_flow_put(ofproto->dpif, put);
+ return dpif_flow_put(ofproto->dpif, flags, key.data, key.size,
+ actions, actions_len, stats);
}
/* If 'facet' is installable, inserts or re-inserts it into 'p''s datapath. If
static void
facet_install(struct ofproto *p, struct facet *facet, bool zero_stats)
{
- if (facet->may_install) {
- struct odp_flow_put put;
- int flags;
+ struct dpif_flow_stats stats;
- flags = ODPPF_CREATE | ODPPF_MODIFY;
- if (zero_stats) {
- flags |= ODPPF_ZERO_STATS;
- }
- if (!facet_put__(p, facet, flags, &put)) {
- facet->installed = true;
- }
+ if (facet->may_install
+ && !facet_put__(p, facet, facet->actions, facet->actions_len,
+ zero_stats ? &stats : NULL)) {
+ facet->installed = true;
}
}
{
if (facet->installed) {
uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
- struct odp_flow odp_flow;
+ struct dpif_flow_stats stats;
struct ofpbuf key;
ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
odp_flow_key_from_flow(&key, &facet->flow);
assert(key.base == keybuf);
- odp_flow.key = key.data;
- odp_flow.key_len = key.size;
- odp_flow.actions = NULL;
- odp_flow.actions_len = 0;
- odp_flow.flags = 0;
- if (!dpif_flow_del(p->dpif, &odp_flow)) {
- facet_update_stats(p, facet, &odp_flow.stats);
+ if (!dpif_flow_del(p->dpif, key.data, key.size, &stats)) {
+ facet_update_stats(p, facet, &stats);
}
facet->installed = false;
}
/* If the ODP actions changed or the installability changed, then we need
* to talk to the datapath. */
- if (actions_changed || facet->may_install != facet->installed) {
- if (facet->may_install) {
- uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
- struct odp_flow_put put;
- struct ofpbuf key;
-
- ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
- odp_flow_key_from_flow(&key, &facet->flow);
-
- memset(&put.flow.stats, 0, sizeof put.flow.stats);
- put.flow.key = key.data;
- put.flow.key_len = key.size;
- put.flow.actions = odp_actions->data;
- put.flow.actions_len = odp_actions->size;
- put.flow.flags = 0;
- put.flags = ODPPF_CREATE | ODPPF_MODIFY | ODPPF_ZERO_STATS;
- dpif_flow_put(ofproto->dpif, &put);
-
- facet_update_stats(ofproto, facet, &put.flow.stats);
+ if (actions_changed || ctx.may_set_up_flow != facet->installed) {
+ if (ctx.may_set_up_flow) {
+ struct dpif_flow_stats stats;
+
+ facet_put__(ofproto, facet,
+ odp_actions->data, odp_actions->size, &stats);
+ facet_update_stats(ofproto, facet, &stats);
} else {
facet_uninstall(ofproto, facet);
}
*/
}
- nl_msg_put_u32(ctx->odp_actions, ODPAT_OUTPUT, port);
+ nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_OUTPUT, port);
ctx->nf_output_iface = port;
}
HMAP_FOR_EACH (ofport, hmap_node, &ofproto->ports) {
uint16_t odp_port = ofport->odp_port;
if (odp_port != odp_in_port && !(ofport->opp.config & mask)) {
- nl_msg_put_u32(odp_actions, ODPAT_OUTPUT, odp_port);
+ nl_msg_put_u32(odp_actions, ODP_ACTION_ATTR_OUTPUT, odp_port);
}
}
*nf_output_iface = NF_OUT_FLOOD;
&ctx->nf_output_iface, ctx->odp_actions);
break;
case OFPP_CONTROLLER:
- nl_msg_put_u64(ctx->odp_actions, ODPAT_CONTROLLER, max_len);
+ nl_msg_put_u64(ctx->odp_actions, ODP_ACTION_ATTR_CONTROLLER, max_len);
break;
case OFPP_LOCAL:
add_output_action(ctx, ODPP_LOCAL);
add_pop_action(struct action_xlate_ctx *ctx)
{
if (ctx->odp_actions->size != ctx->last_pop_priority) {
- nl_msg_put_flag(ctx->odp_actions, ODPAT_POP_PRIORITY);
+ nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_POP_PRIORITY);
ctx->last_pop_priority = ctx->odp_actions->size;
}
}
/* Add ODP actions. */
remove_pop_action(ctx);
- nl_msg_put_u32(ctx->odp_actions, ODPAT_SET_PRIORITY, priority);
+ nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_SET_PRIORITY, priority);
add_output_action(ctx, odp_port);
add_pop_action(ctx);
}
remove_pop_action(ctx);
- nl_msg_put_u32(ctx->odp_actions, ODPAT_SET_PRIORITY, priority);
+ nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_SET_PRIORITY, priority);
}
static void
{
ovs_be16 tci = ctx->flow.vlan_tci;
if (!(tci & htons(VLAN_CFI))) {
- nl_msg_put_flag(ctx->odp_actions, ODPAT_STRIP_VLAN);
+ nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_STRIP_VLAN);
} else {
- nl_msg_put_be16(ctx->odp_actions, ODPAT_SET_DL_TCI,
+ nl_msg_put_be16(ctx->odp_actions, ODP_ACTION_ATTR_SET_DL_TCI,
tci & ~htons(VLAN_CFI));
}
}
xlate_set_dl_tci(ctx);
}
if (ctx->flow.tun_id != state->tun_id) {
- nl_msg_put_be64(ctx->odp_actions, ODPAT_SET_TUNNEL, ctx->flow.tun_id);
+ nl_msg_put_be64(ctx->odp_actions,
+ ODP_ACTION_ATTR_SET_TUNNEL, ctx->flow.tun_id);
}
}
case NXAST_SET_TUNNEL:
nast = (const struct nx_action_set_tunnel *) nah;
tun_id = htonll(ntohl(nast->tun_id));
- nl_msg_put_be64(ctx->odp_actions, ODPAT_SET_TUNNEL, tun_id);
+ nl_msg_put_be64(ctx->odp_actions, ODP_ACTION_ATTR_SET_TUNNEL, tun_id);
ctx->flow.tun_id = tun_id;
break;
case NXAST_DROP_SPOOFED_ARP:
if (ctx->flow.dl_type == htons(ETH_TYPE_ARP)) {
- nl_msg_put_flag(ctx->odp_actions, ODPAT_DROP_SPOOFED_ARP);
+ nl_msg_put_flag(ctx->odp_actions,
+ ODP_ACTION_ATTR_DROP_SPOOFED_ARP);
}
break;
case NXAST_SET_TUNNEL64:
tun_id = ((const struct nx_action_set_tunnel64 *) nah)->tun_id;
- nl_msg_put_be64(ctx->odp_actions, ODPAT_SET_TUNNEL, tun_id);
+ nl_msg_put_be64(ctx->odp_actions, ODP_ACTION_ATTR_SET_TUNNEL, tun_id);
ctx->flow.tun_id = tun_id;
break;
case OFPAT_SET_DL_SRC:
oada = ((struct ofp_action_dl_addr *) ia);
- nl_msg_put_unspec(ctx->odp_actions, ODPAT_SET_DL_SRC,
+ nl_msg_put_unspec(ctx->odp_actions, ODP_ACTION_ATTR_SET_DL_SRC,
oada->dl_addr, ETH_ADDR_LEN);
memcpy(ctx->flow.dl_src, oada->dl_addr, ETH_ADDR_LEN);
break;
case OFPAT_SET_DL_DST:
oada = ((struct ofp_action_dl_addr *) ia);
- nl_msg_put_unspec(ctx->odp_actions, ODPAT_SET_DL_DST,
+ nl_msg_put_unspec(ctx->odp_actions, ODP_ACTION_ATTR_SET_DL_DST,
oada->dl_addr, ETH_ADDR_LEN);
memcpy(ctx->flow.dl_dst, oada->dl_addr, ETH_ADDR_LEN);
break;
case OFPAT_SET_NW_SRC:
- nl_msg_put_be32(ctx->odp_actions, ODPAT_SET_NW_SRC,
+ nl_msg_put_be32(ctx->odp_actions, ODP_ACTION_ATTR_SET_NW_SRC,
ia->nw_addr.nw_addr);
ctx->flow.nw_src = ia->nw_addr.nw_addr;
break;
case OFPAT_SET_NW_DST:
- nl_msg_put_be32(ctx->odp_actions, ODPAT_SET_NW_DST,
+ nl_msg_put_be32(ctx->odp_actions, ODP_ACTION_ATTR_SET_NW_DST,
ia->nw_addr.nw_addr);
ctx->flow.nw_dst = ia->nw_addr.nw_addr;
break;
case OFPAT_SET_NW_TOS:
- nl_msg_put_u8(ctx->odp_actions, ODPAT_SET_NW_TOS,
+ nl_msg_put_u8(ctx->odp_actions, ODP_ACTION_ATTR_SET_NW_TOS,
ia->nw_tos.nw_tos);
ctx->flow.nw_tos = ia->nw_tos.nw_tos;
break;
case OFPAT_SET_TP_SRC:
- nl_msg_put_be16(ctx->odp_actions, ODPAT_SET_TP_SRC,
+ nl_msg_put_be16(ctx->odp_actions, ODP_ACTION_ATTR_SET_TP_SRC,
ia->tp_port.tp_port);
ctx->flow.tp_src = ia->tp_port.tp_port;
break;
case OFPAT_SET_TP_DST:
- nl_msg_put_be16(ctx->odp_actions, ODPAT_SET_TP_DST,
+ nl_msg_put_be16(ctx->odp_actions, ODP_ACTION_ATTR_SET_TP_DST,
ia->tp_port.tp_port);
ctx->flow.tp_dst = ia->tp_port.tp_port;
break;
? htonl(OFPFW_ALL) : htonl(OVSFW_ALL));
ots->max_entries = htonl(1024 * 1024); /* An arbitrary big number. */
ots->active_count = htonl(classifier_count(&p->cls));
- ots->lookup_count = htonll(0); /* XXX */
- ots->matched_count = htonll(0); /* XXX */
+ put_32aligned_be64(&ots->lookup_count, htonll(0)); /* XXX */
+ put_32aligned_be64(&ots->matched_count, htonll(0)); /* XXX */
queue_tx(msg, ofconn, ofconn->reply_counter);
return 0;
ops = append_ofp_stats_reply(sizeof *ops, ofconn, msgp);
ops->port_no = htons(port->opp.port_no);
memset(ops->pad, 0, sizeof ops->pad);
- ops->rx_packets = htonll(stats.rx_packets);
- ops->tx_packets = htonll(stats.tx_packets);
- ops->rx_bytes = htonll(stats.rx_bytes);
- ops->tx_bytes = htonll(stats.tx_bytes);
- ops->rx_dropped = htonll(stats.rx_dropped);
- ops->tx_dropped = htonll(stats.tx_dropped);
- ops->rx_errors = htonll(stats.rx_errors);
- ops->tx_errors = htonll(stats.tx_errors);
- ops->rx_frame_err = htonll(stats.rx_frame_errors);
- ops->rx_over_err = htonll(stats.rx_over_errors);
- ops->rx_crc_err = htonll(stats.rx_crc_errors);
- ops->collisions = htonll(stats.collisions);
+ put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets));
+ put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets));
+ put_32aligned_be64(&ops->rx_bytes, htonll(stats.rx_bytes));
+ put_32aligned_be64(&ops->tx_bytes, htonll(stats.tx_bytes));
+ put_32aligned_be64(&ops->rx_dropped, htonll(stats.rx_dropped));
+ put_32aligned_be64(&ops->tx_dropped, htonll(stats.tx_dropped));
+ put_32aligned_be64(&ops->rx_errors, htonll(stats.rx_errors));
+ put_32aligned_be64(&ops->tx_errors, htonll(stats.tx_errors));
+ put_32aligned_be64(&ops->rx_frame_err, htonll(stats.rx_frame_errors));
+ put_32aligned_be64(&ops->rx_over_err, htonll(stats.rx_over_errors));
+ put_32aligned_be64(&ops->rx_crc_err, htonll(stats.rx_crc_errors));
+ put_32aligned_be64(&ops->collisions, htonll(stats.collisions));
}
static int
packet_count = rule->packet_count;
byte_count = rule->byte_count;
- /* Ask the datapath for statistics on all of the rule's facets. (We could
- * batch up statistics requests using dpif_flow_get_multiple(), but that is
- * not yet implemented.)
+ /* Ask the datapath for statistics on all of the rule's facets.
*
* Also, add any statistics that are not tracked by the datapath for each
* facet. This includes, for example, statistics for packets that were
* to a rule. */
ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
LIST_FOR_EACH (facet, list_node, &rule->facets) {
- struct odp_flow odp_flow;
+ struct dpif_flow_stats stats;
ofpbuf_clear(&key);
odp_flow_key_from_flow(&key, &facet->flow);
+ dpif_flow_get(p->dpif, key.data, key.size, NULL, &stats);
- odp_flow.key = key.data;
- odp_flow.key_len = key.size;
- odp_flow.actions = NULL;
- odp_flow.actions_len = 0;
- odp_flow.flags = 0;
- if (!dpif_flow_get(p->dpif, &odp_flow)) {
- packet_count += odp_flow.stats.n_packets;
- byte_count += odp_flow.stats.n_bytes;
- }
-
- packet_count += facet->packet_count;
- byte_count += facet->byte_count;
+ packet_count += stats.n_packets + facet->packet_count;
+ byte_count += stats.n_bytes + facet->byte_count;
}
/* Return the stats to the caller. */
{
struct ofp_flow_stats *ofs;
uint64_t packet_count, byte_count;
+ ovs_be64 cookie;
size_t act_len, len;
if (rule_is_hidden(rule) || !rule_has_out_port(rule, out_port)) {
ofs->table_id = 0;
ofs->pad = 0;
ofputil_cls_rule_to_match(&rule->cr, ofconn->flow_format, &ofs->match,
- rule->flow_cookie, &ofs->cookie);
+ rule->flow_cookie, &cookie);
+ put_32aligned_be64(&ofs->cookie, cookie);
calc_flow_duration(rule->created, &ofs->duration_sec, &ofs->duration_nsec);
ofs->priority = htons(rule->cr.priority);
ofs->idle_timeout = htons(rule->idle_timeout);
ofs->hard_timeout = htons(rule->hard_timeout);
memset(ofs->pad2, 0, sizeof ofs->pad2);
- ofs->packet_count = htonll(packet_count);
- ofs->byte_count = htonll(byte_count);
+ put_32aligned_be64(&ofs->packet_count, htonll(packet_count));
+ put_32aligned_be64(&ofs->byte_count, htonll(byte_count));
if (rule->n_actions > 0) {
memcpy(ofs->actions, rule->actions, act_len);
}
}
oasr->flow_count = htonl(n_flows);
- oasr->packet_count = htonll(total_packets);
- oasr->byte_count = htonll(total_bytes);
+ put_32aligned_be64(&oasr->packet_count, htonll(total_packets));
+ put_32aligned_be64(&oasr->byte_count, htonll(total_bytes));
memset(oasr->pad, 0, sizeof oasr->pad);
}
reply->port_no = htons(cbdata->ofport->opp.port_no);
memset(reply->pad, 0, sizeof reply->pad);
reply->queue_id = htonl(queue_id);
- reply->tx_bytes = htonll(stats->tx_bytes);
- reply->tx_packets = htonll(stats->tx_packets);
- reply->tx_errors = htonll(stats->tx_errors);
+ put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes));
+ put_32aligned_be64(&reply->tx_packets, htonll(stats->tx_packets));
+ put_32aligned_be64(&reply->tx_errors, htonll(stats->tx_errors));
}
static void
return 0;
}
-static long long int
-msec_from_nsec(uint64_t sec, uint32_t nsec)
-{
- return !sec ? 0 : sec * 1000 + nsec / 1000000;
-}
-
static void
facet_update_time(struct ofproto *ofproto, struct facet *facet,
- const struct odp_flow_stats *stats)
+ const struct dpif_flow_stats *stats)
{
- long long int used = msec_from_nsec(stats->used_sec, stats->used_nsec);
+ long long int used = stats->used;
if (used > facet->used) {
facet->used = used;
if (used > facet->rule->used) {
* cleared out of the datapath. */
static void
facet_update_stats(struct ofproto *ofproto, struct facet *facet,
- const struct odp_flow_stats *stats)
+ const struct dpif_flow_stats *stats)
{
if (stats->n_packets) {
facet_update_time(ofproto, facet, stats);
struct ofpbuf odp_actions;
ofpbuf_init(&odp_actions, 32);
- nl_msg_put_u32(&odp_actions, ODPAT_OUTPUT, ODPP_LOCAL);
+ nl_msg_put_u32(&odp_actions, ODP_ACTION_ATTR_OUTPUT, ODPP_LOCAL);
dpif_execute(p->dpif, odp_actions.data, odp_actions.size,
upcall->packet);
ofpbuf_uninit(&odp_actions);
struct flow flow;
switch (upcall->type) {
- case _ODPL_ACTION_NR:
+ case DPIF_UC_ACTION:
COVERAGE_INC(ofproto_ctlr_action);
odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
send_packet_in(p, upcall, &flow, false);
break;
- case _ODPL_SFLOW_NR:
+ case DPIF_UC_SAMPLE:
if (p->sflow) {
odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
ofproto_sflow_received(p->sflow, upcall, &flow);
ofpbuf_delete(upcall->packet);
break;
- case _ODPL_MISS_NR:
+ case DPIF_UC_MISS:
handle_miss_upcall(p, upcall);
break;
+ case DPIF_N_UC_TYPES:
default:
VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32, upcall->type);
break;
static void
ofproto_update_used(struct ofproto *p)
{
+ const struct dpif_flow_stats *stats;
struct dpif_flow_dump dump;
+ const struct nlattr *key;
+ size_t key_len;
dpif_flow_dump_start(&dump, p->dpif);
- for (;;) {
- uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
+ while (dpif_flow_dump_next(&dump, &key, &key_len, NULL, NULL, &stats)) {
struct facet *facet;
- struct odp_flow f;
struct flow flow;
- memset(&f, 0, sizeof f);
- f.key = (struct nlattr *) keybuf;
- f.key_len = sizeof keybuf;
- if (!dpif_flow_dump_next(&dump, &f)) {
- break;
- }
-
- if (f.key_len > sizeof keybuf) {
- VLOG_WARN_RL(&rl, "ODP flow key overflowed buffer");
- continue;
- }
- if (odp_flow_key_to_flow(f.key, f.key_len, &flow)) {
+ if (odp_flow_key_to_flow(key, key_len, &flow)) {
struct ds s;
ds_init(&s);
- odp_flow_key_format(f.key, f.key_len, &s);
+ odp_flow_key_format(key, key_len, &s);
VLOG_WARN_RL(&rl, "failed to convert ODP flow key to flow: %s",
ds_cstr(&s));
ds_destroy(&s);
facet = facet_find(p, &flow);
if (facet && facet->installed) {
- facet_update_time(p, facet, &f.stats);
- facet_account(p, facet, f.stats.n_bytes);
+ facet_update_time(p, facet, stats);
+ facet_account(p, facet, stats->n_bytes);
} else {
/* There's a flow in the datapath that we know nothing about.
* Delete it. */
COVERAGE_INC(ofproto_unexpected_rule);
- dpif_flow_del(p->dpif, &f);
+ dpif_flow_del(p->dpif, key, key_len, NULL);
}
}
dpif_flow_dump_done(&dump);
if (ofproto->netflow && !facet_is_controller_flow(facet) &&
netflow_active_timeout_expired(ofproto->netflow, &facet->nf_flow)) {
struct ofexpired expired;
- struct odp_flow odp_flow;
- /* Get updated flow stats.
- *
- * XXX We could avoid this call entirely if (1) ofproto_update_used()
- * updated TCP flags and (2) the dpif_flow_list_all() in
- * ofproto_update_used() zeroed TCP flags. */
- memset(&odp_flow, 0, sizeof odp_flow);
if (facet->installed) {
- uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
- struct ofpbuf key;
+ struct dpif_flow_stats stats;
- ofpbuf_use_stack(&key, keybuf, sizeof keybuf);
- odp_flow_key_from_flow(&key, &facet->flow);
-
- odp_flow.key = key.data;
- odp_flow.key_len = key.size;
- odp_flow.flags = ODPFF_ZERO_TCP_FLAGS;
- dpif_flow_get(ofproto->dpif, &odp_flow);
-
- if (odp_flow.stats.n_packets) {
- facet_update_time(ofproto, facet, &odp_flow.stats);
- netflow_flow_update_flags(&facet->nf_flow,
- odp_flow.stats.tcp_flags);
- }
+ facet_put__(ofproto, facet, facet->actions, facet->actions_len,
+ &stats);
+ facet_update_stats(ofproto, facet, &stats);
}
expired.flow = facet->flow;
- expired.packet_count = facet->packet_count +
- odp_flow.stats.n_packets;
- expired.byte_count = facet->byte_count + odp_flow.stats.n_bytes;
+ expired.packet_count = facet->packet_count;
+ expired.byte_count = facet->byte_count;
expired.used = facet->used;
-
netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
}
}
int total_len, send_len;
struct ofpbuf *packet;
uint32_t buffer_id;
+ int idx;
/* Get OpenFlow buffer_id. */
- if (upcall->type == _ODPL_ACTION_NR) {
+ if (upcall->type == DPIF_UC_ACTION) {
buffer_id = UINT32_MAX;
} else if (ofproto->fail_open && fail_open_is_active(ofproto->fail_open)) {
buffer_id = pktbuf_get_null();
if (buffer_id != UINT32_MAX) {
send_len = MIN(send_len, ofconn->miss_send_len);
}
- if (upcall->type == _ODPL_ACTION_NR) {
+ if (upcall->type == DPIF_UC_ACTION) {
send_len = MIN(send_len, upcall->userdata);
}
opi->header.type = OFPT_PACKET_IN;
opi->total_len = htons(total_len);
opi->in_port = htons(odp_port_to_ofp_port(flow->in_port));
- opi->reason = upcall->type == _ODPL_MISS_NR ? OFPR_NO_MATCH : OFPR_ACTION;
+ opi->reason = upcall->type == DPIF_UC_MISS ? OFPR_NO_MATCH : OFPR_ACTION;
opi->buffer_id = htonl(buffer_id);
update_openflow_length(packet);
/* Hand over to packet scheduler. It might immediately call into
* do_send_packet_in() or it might buffer it for a while (until a later
* call to pinsched_run()). */
- pinsched_send(ofconn->schedulers[opi->reason], flow->in_port,
+ idx = upcall->type == DPIF_UC_MISS ? 0 : 1;
+ pinsched_send(ofconn->schedulers[idx], flow->in_port,
packet, do_send_packet_in, ofconn);
}
-/* Given 'upcall', of type _ODPL_ACTION_NR or _ODPL_MISS_NR, sends an
+/* Given 'upcall', of type DPIF_UC_ACTION or DPIF_UC_MISS, sends an
* OFPT_PACKET_IN message to each OpenFlow controller as necessary according to
* their individual configurations.
*
flood_packets(ofproto, flow->in_port, OFPPC_NO_FLOOD,
nf_output_iface, odp_actions);
} else if (out_port != flow->in_port) {
- nl_msg_put_u32(odp_actions, ODPAT_OUTPUT, out_port);
+ nl_msg_put_u32(odp_actions, ODP_ACTION_ATTR_OUTPUT, out_port);
*nf_output_iface = out_port;
} else {
/* Drop. */
projects / cascardo / ovs.git / blobdiff