static void log_flow_put(struct dpif *, int error,
const struct odp_flow_put *);
static bool should_log_flow_message(int error);
-static void check_rw_odp_flow(struct odp_flow *);
+static void check_rw_flow_actions(struct odp_flow *);
+static void check_rw_flow_key(struct odp_flow *);
static void
dp_initialize(void)
COVERAGE_INC(dpif_flow_get);
- check_rw_odp_flow(flow);
+ check_rw_flow_actions(flow);
error = dpif->dpif_class->flow_get(dpif, flow, 1);
if (!error) {
error = flow->stats.error;
COVERAGE_ADD(dpif_flow_get, n);
for (i = 0; i < n; i++) {
- check_rw_odp_flow(&flows[i]);
+ check_rw_flow_actions(&flows[i]);
}
error = dpif->dpif_class->flow_get(dpif, flows, n);
COVERAGE_INC(dpif_flow_del);
- check_rw_odp_flow(flow);
+ check_rw_flow_actions(flow);
memset(&flow->stats, 0, sizeof flow->stats);
error = dpif->dpif_class->flow_del(dpif, flow);
return error;
}
-/* Stores up to 'n' flows in 'dpif' into 'flows', including their statistics
- * but not including any information about their actions. If successful,
- * returns 0 and sets '*n_out' to the number of flows actually present in
- * 'dpif', which might be greater than the number stored (if 'dpif' has more
- * than 'n' flows). On failure, returns a negative errno value and sets
- * '*n_out' to 0. */
-int
-dpif_flow_list(const struct dpif *dpif, struct odp_flow flows[], size_t n,
- size_t *n_out)
+/* Initializes 'dump' to begin dumping the flows in a dpif.
+ *
+ * This function provides no status indication. An error status for the entire
+ * dump operation is provided when it is completed by calling
+ * dpif_flow_dump_done().
+ */
+void
+dpif_flow_dump_start(struct dpif_flow_dump *dump, const struct dpif *dpif)
{
- uint32_t i;
- int retval;
-
- COVERAGE_INC(dpif_flow_query_list);
- if (RUNNING_ON_VALGRIND) {
- memset(flows, 0, n * sizeof *flows);
- } else {
- for (i = 0; i < n; i++) {
- flows[i].actions = NULL;
- flows[i].actions_len = 0;
- }
- }
- retval = dpif->dpif_class->flow_list(dpif, flows, n);
- if (retval < 0) {
- *n_out = 0;
- VLOG_WARN_RL(&error_rl, "%s: flow list failed (%s)",
- dpif_name(dpif), strerror(-retval));
- return -retval;
- } else {
- COVERAGE_ADD(dpif_flow_query_list_n, retval);
- *n_out = MIN(n, retval);
- VLOG_DBG_RL(&dpmsg_rl, "%s: listed %zu flows (of %d)",
- dpif_name(dpif), *n_out, retval);
- return 0;
- }
+ dump->dpif = dpif;
+ dump->error = dpif->dpif_class->flow_dump_start(dpif, &dump->state);
+ log_operation(dpif, "flow_dump_start", dump->error);
}
-/* Retrieves all of the flows in 'dpif'.
- *
- * If successful, returns 0 and stores in '*flowsp' a pointer to a newly
- * allocated array of flows, including their statistics but not including any
- * information about their actions, and sets '*np' to the number of flows in
- * '*flowsp'. The caller is responsible for freeing '*flowsp' by calling
- * free().
+/* Attempts to retrieve another flow from 'dump', which must have been
+ * initialized with dpif_flow_dump_start(). On success, stores a new odp_flow
+ * into 'flow' and returns true. Failure might indicate an actual error or
+ * merely the end of the flow table. An error status for the entire dump
+ * operation is provided when it is completed by calling dpif_flow_dump_done().
*
- * On failure, returns a positive errno value and sets '*flowsp' to NULL and
- * '*np' to 0. */
-int
-dpif_flow_list_all(const struct dpif *dpif,
- struct odp_flow **flowsp, size_t *np)
+ * Dumping flow actions is optional. To avoid dumping actions initialize
+ * 'flow->actions' to NULL and 'flow->actions_len' to 0. Otherwise, point
+ * 'flow->actions' to an array of struct nlattr and initialize
+ * 'flow->actions_len' with the number of bytes of Netlink attributes.
+ * dpif_flow_dump_next() will fill in as many actions as will fit into the
+ * provided array and update 'flow->actions_len' with the number of bytes
+ * required (regardless of whether they fit in the provided space). */
+bool
+dpif_flow_dump_next(struct dpif_flow_dump *dump, struct odp_flow *flow)
{
- struct odp_stats stats;
- struct odp_flow *flows;
- size_t n_flows;
- int error;
+ const struct dpif *dpif = dump->dpif;
- *flowsp = NULL;
- *np = 0;
+ check_rw_flow_actions(flow);
+ check_rw_flow_key(flow);
- error = dpif_get_dp_stats(dpif, &stats);
- if (error) {
- return error;
+ if (dump->error) {
+ return false;
}
- flows = xmalloc(sizeof *flows * stats.n_flows);
- error = dpif_flow_list(dpif, flows, stats.n_flows, &n_flows);
- if (error) {
- free(flows);
- return error;
+ dump->error = dpif->dpif_class->flow_dump_next(dpif, dump->state, flow);
+ if (dump->error == EOF) {
+ VLOG_DBG_RL(&dpmsg_rl, "%s: dumped all flows", dpif_name(dpif));
+ } else {
+ if (dump->error) {
+ flow->key_len = 0;
+ }
+ if (should_log_flow_message(dump->error)) {
+ log_flow_operation(dpif, "flow_dump_next", dump->error, flow);
+ }
}
- if (stats.n_flows != n_flows) {
- VLOG_WARN_RL(&error_rl, "%s: datapath stats reported %"PRIu32" "
- "flows but flow listing reported %zu",
- dpif_name(dpif), stats.n_flows, n_flows);
+ if (dump->error) {
+ dpif->dpif_class->flow_dump_done(dpif, dump->state);
+ return false;
}
- *flowsp = flows;
- *np = n_flows;
- return 0;
+ return true;
+}
+
+/* Completes flow table dump operation 'dump', which must have been initialized
+ * with dpif_flow_dump_start(). Returns 0 if the dump operation was
+ * error-free, otherwise a positive errno value describing the problem. */
+int
+dpif_flow_dump_done(struct dpif_flow_dump *dump)
+{
+ const struct dpif *dpif = dump->dpif;
+ if (!dump->error) {
+ dump->error = dpif->dpif_class->flow_dump_done(dpif, dump->state);
+ log_operation(dpif, "flow_dump_done", dump->error);
+ }
+ return dump->error == EOF ? 0 : dump->error;
}
/* Causes 'dpif' to perform the 'actions_len' bytes of actions in 'actions' on
return error;
}
-/* Attempts to receive a message from 'dpif'. If successful, stores the
- * message into '*packetp'. The message, if one is received, will begin with
- * 'struct odp_msg' as a header, and will have at least DPIF_RECV_MSG_PADDING
- * bytes of headroom. Only messages of the types selected with
- * dpif_set_listen_mask() will ordinarily be received (but if a message type is
+/* Polls for an upcall from 'dpif'. If successful, stores the upcall into
+ * '*upcall'. Only upcalls of the types selected with the set_listen_mask
+ * member function will ordinarily be received (but if a message type is
* enabled and then later disabled, some stragglers might pop up).
*
+ * The caller takes ownership of the data that 'upcall' points to.
+ * 'upcall->key' and 'upcall->actions' (if nonnull) point into data owned by
+ * 'upcall->packet', so their memory cannot be freed separately. (This is
+ * hardly a great way to do things but it works out OK for the dpif providers
+ * and clients that exist so far.)
+ *
* Returns 0 if successful, otherwise a positive errno value. Returns EAGAIN
- * if no message is immediately available. */
+ * if no upcall is immediately available. */
int
-dpif_recv(struct dpif *dpif, struct ofpbuf **packetp)
+dpif_recv(struct dpif *dpif, struct dpif_upcall *upcall)
{
- int error = dpif->dpif_class->recv(dpif, packetp);
- if (!error) {
- struct ofpbuf *buf = *packetp;
-
- assert(ofpbuf_headroom(buf) >= DPIF_RECV_MSG_PADDING);
- if (VLOG_IS_DBG_ENABLED()) {
- struct odp_msg *msg = buf->data;
- void *payload = msg + 1;
- size_t payload_len = buf->size - sizeof *msg;
- char *s = ofp_packet_to_string(payload, payload_len, payload_len);
- VLOG_DBG_RL(&dpmsg_rl, "%s: received %s message of length "
- "%zu on port %"PRIu16": %s", dpif_name(dpif),
- (msg->type == _ODPL_MISS_NR ? "miss"
- : msg->type == _ODPL_ACTION_NR ? "action"
- : msg->type == _ODPL_SFLOW_NR ? "sFlow"
- : "<unknown>"),
- payload_len, msg->port, s);
- free(s);
- }
- } else {
- *packetp = NULL;
+ int error = dpif->dpif_class->recv(dpif, upcall);
+ if (!error && !VLOG_DROP_DBG(&dpmsg_rl)) {
+ struct flow flow;
+ char *s;
+
+ s = ofp_packet_to_string(upcall->packet->data,
+ upcall->packet->size, upcall->packet->size);
+ odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
+
+ VLOG_DBG("%s: %s upcall on port %"PRIu16": %s", dpif_name(dpif),
+ (upcall->type == _ODPL_MISS_NR ? "miss"
+ : upcall->type == _ODPL_ACTION_NR ? "action"
+ : upcall->type == _ODPL_SFLOW_NR ? "sFlow"
+ : "<unknown>"),
+ flow.in_port, s);
+ free(s);
}
return error;
}
}
for (i = 0; i < stats.max_miss_queue + stats.max_action_queue + stats.max_sflow_queue; i++) {
- struct ofpbuf *buf;
- error = dpif_recv(dpif, &buf);
+ struct dpif_upcall upcall;
+ error = dpif_recv(dpif, &upcall);
if (error) {
return error == EAGAIN ? 0 : error;
}
- ofpbuf_delete(buf);
+ ofpbuf_delete(upcall.packet);
}
return 0;
}
static void
log_flow_message(const struct dpif *dpif, int error, const char *operation,
- const struct odp_flow_key *flow,
+ const struct nlattr *key, size_t key_len,
const struct odp_flow_stats *stats,
const struct nlattr *actions, size_t actions_len)
{
if (error) {
ds_put_format(&ds, "(%s) ", strerror(error));
}
- format_odp_flow_key(&ds, flow);
+ odp_flow_key_format(key, key_len, &ds);
if (stats) {
ds_put_cstr(&ds, ", ");
format_odp_flow_stats(&ds, stats);
struct odp_flow *flow)
{
if (error) {
+ flow->key_len = 0;
flow->actions_len = 0;
}
- log_flow_message(dpif, error, operation, &flow->key,
- !error ? &flow->stats : NULL,
+ log_flow_message(dpif, error, operation,
+ flow->key, flow->key_len, !error ? &flow->stats : NULL,
flow->actions, flow->actions_len);
}
if (put->flags & ~ODPPF_ALL) {
ds_put_format(&s, "[%x]", put->flags & ~ODPPF_ALL);
}
- log_flow_message(dpif, error, ds_cstr(&s), &put->flow.key,
+ log_flow_message(dpif, error, ds_cstr(&s),
+ put->flow.key, put->flow.key_len,
!error ? &put->flow.stats : NULL,
put->flow.actions, put->flow.actions_len);
ds_destroy(&s);
* "actions" or "actions_len" was not initialized.
*/
static void
-check_rw_odp_flow(struct odp_flow *flow)
+check_rw_flow_actions(struct odp_flow *flow)
{
if (flow->actions_len) {
memset(&flow->actions[0], 0xcc, sizeof flow->actions[0]);
}
}
+
+/* Same as check_rw_flow_actions() but for flow->key. */
+static void
+check_rw_flow_key(struct odp_flow *flow)
+{
+ if (flow->key_len) {
+ memset(&flow->key[0], 0xcc, sizeof flow->key[0]);
+ }
+}