struct flow key;
/* Statistics. */
- struct timespec used; /* Last used time. */
+ long long int used; /* Last used time, in monotonic msecs. */
long long int packet_count; /* Number of packets matched. */
long long int byte_count; /* Number of bytes matched. */
uint16_t tcp_ctl; /* Bitwise-OR of seen tcp_ctl values. */
return NULL;
}
-/* The caller must fill in odp_flow->key itself. */
static void
-answer_flow_query(struct dp_netdev_flow *flow, uint32_t query_flags,
- struct odp_flow *odp_flow)
-{
- odp_flow->stats.n_packets = flow->packet_count;
- odp_flow->stats.n_bytes = flow->byte_count;
- odp_flow->stats.used_sec = flow->used.tv_sec;
- odp_flow->stats.used_nsec = flow->used.tv_nsec;
- odp_flow->stats.tcp_flags = TCP_FLAGS(flow->tcp_ctl);
- odp_flow->stats.reserved = 0;
- if (odp_flow->actions_len > 0) {
- memcpy(odp_flow->actions, flow->actions,
- MIN(odp_flow->actions_len, flow->actions_len));
- odp_flow->actions_len = flow->actions_len;
- }
-
- if (query_flags & ODPFF_ZERO_TCP_FLAGS) {
- flow->tcp_ctl = 0;
- }
+get_dpif_flow_stats(struct dp_netdev_flow *flow, struct dpif_flow_stats *stats)
+{
+ stats->n_packets = flow->packet_count;
+ stats->n_bytes = flow->byte_count;
+ stats->used = flow->used;
+ stats->tcp_flags = TCP_FLAGS(flow->tcp_ctl);
}
static int
}
static int
-dpif_netdev_flow_get(const struct dpif *dpif, struct odp_flow *odp_flow)
+dpif_netdev_flow_get(const struct dpif *dpif,
+ const struct nlattr *nl_key, size_t nl_key_len,
+ struct ofpbuf **actionsp, struct dpif_flow_stats *stats)
{
struct dp_netdev *dp = get_dp_netdev(dpif);
struct dp_netdev_flow *flow;
struct flow key;
int error;
- error = dpif_netdev_flow_from_nlattrs(odp_flow->key, odp_flow->key_len,
- &key);
+ error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
if (error) {
return error;
}
return ENOENT;
}
- answer_flow_query(flow, odp_flow->flags, odp_flow);
+ if (stats) {
+ get_dpif_flow_stats(flow, stats);
+ }
+ if (actionsp) {
+ *actionsp = ofpbuf_clone_data(flow->actions, flow->actions_len);
+ }
return 0;
}
}
switch (type) {
- case ODPAT_OUTPUT:
+ case ODP_ACTION_ATTR_OUTPUT:
if (nl_attr_get_u32(a) >= MAX_PORTS) {
return EINVAL;
}
break;
- case ODPAT_CONTROLLER:
- case ODPAT_DROP_SPOOFED_ARP:
+ case ODP_ACTION_ATTR_CONTROLLER:
+ case ODP_ACTION_ATTR_DROP_SPOOFED_ARP:
break;
- case ODPAT_SET_DL_TCI:
+ case ODP_ACTION_ATTR_SET_DL_TCI:
*mutates = true;
if (nl_attr_get_be16(a) & htons(VLAN_CFI)) {
return EINVAL;
}
break;
- case ODPAT_SET_NW_TOS:
+ case ODP_ACTION_ATTR_SET_NW_TOS:
*mutates = true;
if (nl_attr_get_u8(a) & IP_ECN_MASK) {
return EINVAL;
}
break;
- case ODPAT_STRIP_VLAN:
- case ODPAT_SET_DL_SRC:
- case ODPAT_SET_DL_DST:
- case ODPAT_SET_NW_SRC:
- case ODPAT_SET_NW_DST:
- case ODPAT_SET_TP_SRC:
- case ODPAT_SET_TP_DST:
+ case ODP_ACTION_ATTR_STRIP_VLAN:
+ case ODP_ACTION_ATTR_SET_DL_SRC:
+ case ODP_ACTION_ATTR_SET_DL_DST:
+ case ODP_ACTION_ATTR_SET_NW_SRC:
+ case ODP_ACTION_ATTR_SET_NW_DST:
+ case ODP_ACTION_ATTR_SET_TP_SRC:
+ case ODP_ACTION_ATTR_SET_TP_DST:
*mutates = true;
break;
- case ODPAT_SET_TUNNEL:
- case ODPAT_SET_PRIORITY:
- case ODPAT_POP_PRIORITY:
+ case ODP_ACTION_ATTR_SET_TUNNEL:
+ case ODP_ACTION_ATTR_SET_PRIORITY:
+ case ODP_ACTION_ATTR_POP_PRIORITY:
default:
return EOPNOTSUPP;
}
}
static int
-set_flow_actions(struct dp_netdev_flow *flow, struct odp_flow *odp_flow)
+set_flow_actions(struct dp_netdev_flow *flow,
+ const struct nlattr *actions, size_t actions_len)
{
bool mutates;
int error;
- error = dpif_netdev_validate_actions(odp_flow->actions,
- odp_flow->actions_len, &mutates);
+ error = dpif_netdev_validate_actions(actions, actions_len, &mutates);
if (error) {
return error;
}
- flow->actions = xrealloc(flow->actions, odp_flow->actions_len);
- flow->actions_len = odp_flow->actions_len;
- memcpy(flow->actions, odp_flow->actions, odp_flow->actions_len);
+ flow->actions = xrealloc(flow->actions, actions_len);
+ flow->actions_len = actions_len;
+ memcpy(flow->actions, actions, actions_len);
return 0;
}
static int
-add_flow(struct dpif *dpif, const struct flow *key, struct odp_flow *odp_flow)
+add_flow(struct dpif *dpif, const struct flow *key,
+ const struct nlattr *actions, size_t actions_len)
{
struct dp_netdev *dp = get_dp_netdev(dpif);
struct dp_netdev_flow *flow;
flow = xzalloc(sizeof *flow);
flow->key = *key;
- error = set_flow_actions(flow, odp_flow);
+ error = set_flow_actions(flow, actions, actions_len);
if (error) {
free(flow);
return error;
static void
clear_stats(struct dp_netdev_flow *flow)
{
- flow->used.tv_sec = 0;
- flow->used.tv_nsec = 0;
+ flow->used = 0;
flow->packet_count = 0;
flow->byte_count = 0;
flow->tcp_ctl = 0;
}
static int
-dpif_netdev_flow_put(struct dpif *dpif, struct odp_flow_put *put)
+dpif_netdev_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags,
+ const struct nlattr *nl_key, size_t nl_key_len,
+ const struct nlattr *actions, size_t actions_len,
+ struct dpif_flow_stats *stats)
{
struct dp_netdev *dp = get_dp_netdev(dpif);
struct dp_netdev_flow *flow;
struct flow key;
int error;
- error = dpif_netdev_flow_from_nlattrs(put->flow.key, put->flow.key_len,
- &key);
+ error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
if (error) {
return error;
}
flow = dp_netdev_lookup_flow(dp, &key);
if (!flow) {
- if (put->flags & ODPPF_CREATE) {
+ if (flags & DPIF_FP_CREATE) {
if (hmap_count(&dp->flow_table) < MAX_FLOWS) {
- return add_flow(dpif, &key, &put->flow);
+ if (stats) {
+ memset(stats, 0, sizeof *stats);
+ }
+ return add_flow(dpif, &key, actions, actions_len);
} else {
return EFBIG;
}
return ENOENT;
}
} else {
- if (put->flags & ODPPF_MODIFY) {
- int error = set_flow_actions(flow, &put->flow);
- if (!error && put->flags & ODPPF_ZERO_STATS) {
- clear_stats(flow);
+ if (flags & DPIF_FP_MODIFY) {
+ int error = set_flow_actions(flow, actions, actions_len);
+ if (!error) {
+ if (stats) {
+ get_dpif_flow_stats(flow, stats);
+ }
+ if (flags & DPIF_FP_ZERO_STATS) {
+ clear_stats(flow);
+ }
}
return error;
} else {
}
}
-
static int
-dpif_netdev_flow_del(struct dpif *dpif, struct odp_flow *odp_flow)
+dpif_netdev_flow_del(struct dpif *dpif,
+ const struct nlattr *nl_key, size_t nl_key_len,
+ struct dpif_flow_stats *stats)
{
struct dp_netdev *dp = get_dp_netdev(dpif);
struct dp_netdev_flow *flow;
struct flow key;
int error;
- error = dpif_netdev_flow_from_nlattrs(odp_flow->key, odp_flow->key_len,
- &key);
+ error = dpif_netdev_flow_from_nlattrs(nl_key, nl_key_len, &key);
if (error) {
return error;
}
flow = dp_netdev_lookup_flow(dp, &key);
if (flow) {
- answer_flow_query(flow, 0, odp_flow);
+ if (stats) {
+ get_dpif_flow_stats(flow, stats);
+ }
dp_netdev_free_flow(dp, flow);
return 0;
} else {
struct dp_netdev_flow_state {
uint32_t bucket;
uint32_t offset;
+ struct nlattr *actions;
+ uint32_t keybuf[ODPUTIL_FLOW_KEY_U32S];
+ struct dpif_flow_stats stats;
};
static int
dpif_netdev_flow_dump_start(const struct dpif *dpif OVS_UNUSED, void **statep)
{
- *statep = xzalloc(sizeof(struct dp_netdev_flow_state));
+ struct dp_netdev_flow_state *state;
+
+ *statep = state = xmalloc(sizeof *state);
+ state->bucket = 0;
+ state->offset = 0;
+ state->actions = NULL;
return 0;
}
static int
dpif_netdev_flow_dump_next(const struct dpif *dpif, void *state_,
- struct odp_flow *odp_flow)
+ const struct nlattr **key, size_t *key_len,
+ const struct nlattr **actions, size_t *actions_len,
+ const struct dpif_flow_stats **stats)
{
struct dp_netdev_flow_state *state = state_;
struct dp_netdev *dp = get_dp_netdev(dpif);
struct dp_netdev_flow *flow;
struct hmap_node *node;
- struct ofpbuf key;
node = hmap_at_position(&dp->flow_table, &state->bucket, &state->offset);
if (!node) {
flow = CONTAINER_OF(node, struct dp_netdev_flow, node);
- ofpbuf_use_stack(&key, odp_flow->key, odp_flow->key_len);
- odp_flow_key_from_flow(&key, &flow->key);
- odp_flow->key_len = key.size;
- ofpbuf_uninit(&key);
+ if (key) {
+ struct ofpbuf buf;
+
+ ofpbuf_use_stack(&buf, state->keybuf, sizeof state->keybuf);
+ odp_flow_key_from_flow(&buf, &flow->key);
+ assert(buf.base == state->keybuf);
+
+ *key = buf.data;
+ *key_len = buf.size;
+ }
+
+ if (actions) {
+ free(state->actions);
+ state->actions = xmemdup(flow->actions, flow->actions_len);
+
+ *actions = state->actions;
+ *actions_len = flow->actions_len;
+ }
- answer_flow_query(flow, 0, odp_flow);
+ if (stats) {
+ get_dpif_flow_stats(flow, &state->stats);
+ *stats = &state->stats;
+ }
return 0;
}
static int
-dpif_netdev_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state)
+dpif_netdev_flow_dump_done(const struct dpif *dpif OVS_UNUSED, void *state_)
{
+ struct dp_netdev_flow_state *state = state_;
+
+ free(state->actions);
free(state);
return 0;
}
dpif_netdev_recv_set_mask(struct dpif *dpif, int listen_mask)
{
struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif);
- if (!(listen_mask & ~ODPL_ALL)) {
- dpif_netdev->listen_mask = listen_mask;
- return 0;
- } else {
- return EINVAL;
- }
+ dpif_netdev->listen_mask = listen_mask;
+ return 0;
}
static struct dp_netdev_queue *
dp_netdev_flow_used(struct dp_netdev_flow *flow, struct flow *key,
const struct ofpbuf *packet)
{
- time_timespec(&flow->used);
+ flow->used = time_msec();
flow->packet_count++;
flow->byte_count += packet->size;
if (key->dl_type == htons(ETH_TYPE_IP) && key->nw_proto == IPPROTO_TCP) {
dp->n_hit++;
} else {
dp->n_missed++;
- dp_netdev_output_control(dp, packet, _ODPL_MISS_NR, &key, 0);
+ dp_netdev_output_control(dp, packet, DPIF_UC_MISS, &key, 0);
}
}
uint16_t type = nl_attr_type(a);
uint32_t *field;
- field = type == ODPAT_SET_NW_SRC ? &nh->ip_src : &nh->ip_dst;
+ field = type == ODP_ACTION_ATTR_SET_NW_SRC ? &nh->ip_src : &nh->ip_dst;
if (key->nw_proto == IP_TYPE_TCP && packet->l7) {
struct tcp_header *th = packet->l4;
th->tcp_csum = recalc_csum32(th->tcp_csum, *field, ip);
if (key->nw_proto == IPPROTO_TCP && packet->l7) {
struct tcp_header *th = packet->l4;
- field = type == ODPAT_SET_TP_SRC ? &th->tcp_src : &th->tcp_dst;
+ field = (type == ODP_ACTION_ATTR_SET_TP_SRC
+ ? &th->tcp_src : &th->tcp_dst);
th->tcp_csum = recalc_csum16(th->tcp_csum, *field, port);
*field = port;
} else if (key->nw_proto == IPPROTO_UDP && packet->l7) {
struct udp_header *uh = packet->l4;
- field = type == ODPAT_SET_TP_SRC ? &uh->udp_src : &uh->udp_dst;
+ field = (type == ODP_ACTION_ATTR_SET_TP_SRC
+ ? &uh->udp_src : &uh->udp_dst);
uh->udp_csum = recalc_csum16(uh->udp_csum, *field, port);
*field = port;
} else {
NL_ATTR_FOR_EACH_UNSAFE (a, left, actions, actions_len) {
switch (nl_attr_type(a)) {
- case ODPAT_OUTPUT:
+ case ODP_ACTION_ATTR_OUTPUT:
dp_netdev_output_port(dp, packet, nl_attr_get_u32(a));
break;
- case ODPAT_CONTROLLER:
- dp_netdev_output_control(dp, packet, _ODPL_ACTION_NR,
+ case ODP_ACTION_ATTR_CONTROLLER:
+ dp_netdev_output_control(dp, packet, DPIF_UC_ACTION,
key, nl_attr_get_u64(a));
break;
- case ODPAT_SET_DL_TCI:
+ case ODP_ACTION_ATTR_SET_DL_TCI:
dp_netdev_set_dl_tci(packet, nl_attr_get_be16(a));
break;
- case ODPAT_STRIP_VLAN:
+ case ODP_ACTION_ATTR_STRIP_VLAN:
dp_netdev_strip_vlan(packet);
break;
- case ODPAT_SET_DL_SRC:
+ case ODP_ACTION_ATTR_SET_DL_SRC:
dp_netdev_set_dl_src(packet, nl_attr_get_unspec(a, ETH_ADDR_LEN));
break;
- case ODPAT_SET_DL_DST:
+ case ODP_ACTION_ATTR_SET_DL_DST:
dp_netdev_set_dl_dst(packet, nl_attr_get_unspec(a, ETH_ADDR_LEN));
break;
- case ODPAT_SET_NW_SRC:
- case ODPAT_SET_NW_DST:
+ case ODP_ACTION_ATTR_SET_NW_SRC:
+ case ODP_ACTION_ATTR_SET_NW_DST:
dp_netdev_set_nw_addr(packet, key, a);
break;
- case ODPAT_SET_NW_TOS:
+ case ODP_ACTION_ATTR_SET_NW_TOS:
dp_netdev_set_nw_tos(packet, key, nl_attr_get_u8(a));
break;
- case ODPAT_SET_TP_SRC:
- case ODPAT_SET_TP_DST:
+ case ODP_ACTION_ATTR_SET_TP_SRC:
+ case ODP_ACTION_ATTR_SET_TP_DST:
dp_netdev_set_tp_port(packet, key, a);
break;
- case ODPAT_DROP_SPOOFED_ARP:
+ case ODP_ACTION_ATTR_DROP_SPOOFED_ARP:
if (dp_netdev_is_spoofed_arp(packet, key)) {
return 0;
}
NULL, /* enumerate */
dpif_netdev_open,
dpif_netdev_close,
- NULL, /* get_all_names */
dpif_netdev_destroy,
dpif_netdev_get_stats,
dpif_netdev_get_drop_frags,