#include "poll-loop.h"
#include "shash.h"
#include "svec.h"
+#include "timeval.h"
#include "util.h"
#include "valgrind.h"
#include "vlog.h"
/* Not really much point in logging many dpif errors. */
static struct vlog_rate_limit error_rl = VLOG_RATE_LIMIT_INIT(60, 5);
+static void log_flow_message(const struct dpif *dpif, int error,
+ const char *operation,
+ const struct nlattr *key, size_t key_len,
+ const struct dpif_flow_stats *stats,
+ const struct nlattr *actions, size_t actions_len);
static void log_operation(const struct dpif *, const char *operation,
int error);
-static void log_flow_operation(const struct dpif *, const char *operation,
- int error, struct odp_flow *flow);
-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_flow_actions(struct odp_flow *);
-static void check_rw_flow_key(struct odp_flow *);
static void
dp_initialize(void)
dpif->dpif_class->port_poll_wait(dpif);
}
+/* Appends a human-readable representation of 'stats' to 's'. */
+void
+dpif_flow_stats_format(const struct dpif_flow_stats *stats, struct ds *s)
+{
+ ds_put_format(s, "packets:%"PRIu64", bytes:%"PRIu64", used:",
+ stats->n_packets, stats->n_bytes);
+ if (stats->used) {
+ ds_put_format(s, "%.3fs", (time_msec() - stats->used) / 1000.0);
+ } else {
+ ds_put_format(s, "never");
+ }
+ /* XXX tcp_flags? */
+}
+
/* Deletes all flows from 'dpif'. Returns 0 if successful, otherwise a
* positive errno value. */
int
return error;
}
-/* Queries 'dpif' for a flow entry matching 'flow->key'.
+/* Queries 'dpif' for a flow entry. The flow is specified by the Netlink
+ * attributes with types ODP_KEY_ATTR_* in the 'key_len' bytes starting at
+ * 'key'.
*
- * If a flow matching 'flow->key' exists in 'dpif', stores statistics for the
- * flow into 'flow->stats'. If 'flow->actions_len' is zero, then
- * 'flow->actions' is ignored. If 'flow->actions_len' is nonzero, then
- * 'flow->actions' should point to an array of the specified number of bytes.
- * At most that many bytes of the flow's actions will be copied into that
- * array. 'flow->actions_len' will be updated to the number of bytes of
- * actions actually present in the flow, which may be greater than the amount
- * stored if the flow has more actions than space available in the array.
+ * Returns 0 if successful. If no flow matches, returns ENOENT. On other
+ * failure, returns a positive errno value.
*
- * If no flow matching 'flow->key' exists in 'dpif', returns ENOENT. On other
- * failure, returns a positive errno value. */
+ * If 'actionsp' is nonnull, then on success '*actionsp' will be set to an
+ * ofpbuf owned by the caller that contains the Netlink attributes for the
+ * flow's actions. The caller must free the ofpbuf (with ofpbuf_delete()) when
+ * it is no longer needed.
+ *
+ * If 'stats' is nonnull, then on success it will be updated with the flow's
+ * statistics. */
int
-dpif_flow_get(const struct dpif *dpif, struct odp_flow *flow)
+dpif_flow_get(const struct dpif *dpif,
+ const struct nlattr *key, size_t key_len,
+ struct ofpbuf **actionsp, struct dpif_flow_stats *stats)
{
int error;
COVERAGE_INC(dpif_flow_get);
- check_rw_flow_actions(flow);
- error = dpif->dpif_class->flow_get(dpif, flow, 1);
- if (!error) {
- error = flow->stats.error;
- }
+ error = dpif->dpif_class->flow_get(dpif, key, key_len, actionsp, stats);
if (error) {
- /* Make the results predictable on error. */
- memset(&flow->stats, 0, sizeof flow->stats);
- flow->actions_len = 0;
+ if (actionsp) {
+ *actionsp = NULL;
+ }
+ if (stats) {
+ memset(stats, 0, sizeof *stats);
+ }
}
if (should_log_flow_message(error)) {
- log_flow_operation(dpif, "flow_get", error, flow);
- }
- return error;
-}
-
-/* For each flow 'flow' in the 'n' flows in 'flows':
- *
- * - If a flow matching 'flow->key' exists in 'dpif':
- *
- * Stores 0 into 'flow->stats.error' and stores statistics for the flow
- * into 'flow->stats'.
- *
- * If 'flow->actions_len' is zero, then 'flow->actions' is ignored. If
- * 'flow->actions_len' is nonzero, then 'flow->actions' should point to an
- * array of the specified number of bytes. At most that amount of flow's
- * actions will be copied into that array. 'flow->actions_len' will be
- * updated to the number of bytes of actions actually present in the flow,
- * which may be greater than the amount stored if the flow's actions are
- * longer than the available space.
- *
- * - Flow-specific errors are indicated by a positive errno value in
- * 'flow->stats.error'. In particular, ENOENT indicates that no flow
- * matching 'flow->key' exists in 'dpif'. When an error value is stored, the
- * contents of 'flow->key' are preserved but other members of 'flow' should
- * be treated as indeterminate.
- *
- * Returns 0 if all 'n' flows in 'flows' were updated (whether they were
- * individually successful or not is indicated by 'flow->stats.error',
- * however). Returns a positive errno value if an error that prevented this
- * update occurred, in which the caller must not depend on any elements in
- * 'flows' being updated or not updated.
- */
-int
-dpif_flow_get_multiple(const struct dpif *dpif,
- struct odp_flow flows[], size_t n)
-{
- int error;
- size_t i;
-
- COVERAGE_ADD(dpif_flow_get, n);
-
- for (i = 0; i < n; i++) {
- check_rw_flow_actions(&flows[i]);
+ const struct nlattr *actions;
+ size_t actions_len;
+
+ if (!error && actionsp) {
+ actions = (*actionsp)->data;
+ actions_len = (*actionsp)->size;
+ } else {
+ actions = NULL;
+ actions_len = 0;
+ }
+ log_flow_message(dpif, error, "flow_get", key, key_len, stats,
+ actions, actions_len);
}
-
- error = dpif->dpif_class->flow_get(dpif, flows, n);
- log_operation(dpif, "flow_get_multiple", error);
return error;
}
-/* Adds or modifies a flow in 'dpif' as specified in 'put':
+/* Adds or modifies a flow in 'dpif'. The flow is specified by the Netlink
+ * attributes with types ODP_KEY_ATTR_* in the 'key_len' bytes starting at
+ * 'key'. The associated actions are specified by the Netlink attributes with
+ * types ODPAT_* in the 'actions_len' bytes starting at 'actions'.
*
- * - If the flow specified in 'put->flow' does not exist in 'dpif', then
- * behavior depends on whether ODPPF_CREATE is specified in 'put->flags': if
- * it is, the flow will be added, otherwise the operation will fail with
+ * - If the flow's key does not exist in 'dpif', then the flow will be added if
+ * 'flags' includes DPIF_FP_CREATE. Otherwise the operation will fail with
* ENOENT.
*
- * - Otherwise, the flow specified in 'put->flow' does exist in 'dpif'.
- * Behavior in this case depends on whether ODPPF_MODIFY is specified in
- * 'put->flags': if it is, the flow's actions will be updated, otherwise the
- * operation will fail with EEXIST. If the flow's actions are updated, then
- * its statistics will be zeroed if ODPPF_ZERO_STATS is set in 'put->flags',
- * left as-is otherwise.
+ * If the operation succeeds, then 'stats', if nonnull, will be zeroed.
+ *
+ * - If the flow's key does exist in 'dpif', then the flow's actions will be
+ * updated if 'flags' includes DPIF_FP_MODIFY. Otherwise the operation will
+ * fail with EEXIST. If the flow's actions are updated, then its statistics
+ * will be zeroed if 'flags' includes DPIF_FP_ZERO_STATS, and left as-is
+ * otherwise.
*
- * Returns 0 if successful, otherwise a positive errno value.
+ * If the operation succeeds, then 'stats', if nonnull, will be set to the
+ * flow's statistics before the update.
*/
int
-dpif_flow_put(struct dpif *dpif, struct odp_flow_put *put)
+dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags,
+ const struct nlattr *key, size_t key_len,
+ const struct nlattr *actions, size_t actions_len,
+ struct dpif_flow_stats *stats)
{
int error;
COVERAGE_INC(dpif_flow_put);
+ assert(!(flags & ~(DPIF_FP_CREATE | DPIF_FP_MODIFY | DPIF_FP_ZERO_STATS)));
- error = dpif->dpif_class->flow_put(dpif, put);
+ error = dpif->dpif_class->flow_put(dpif, flags, key, key_len,
+ actions, actions_len, stats);
+ if (error && stats) {
+ memset(stats, 0, sizeof *stats);
+ }
if (should_log_flow_message(error)) {
- log_flow_put(dpif, error, put);
+ struct ds s;
+
+ ds_init(&s);
+ ds_put_cstr(&s, "put");
+ if (flags & DPIF_FP_CREATE) {
+ ds_put_cstr(&s, "[create]");
+ }
+ if (flags & DPIF_FP_MODIFY) {
+ ds_put_cstr(&s, "[modify]");
+ }
+ if (flags & DPIF_FP_ZERO_STATS) {
+ ds_put_cstr(&s, "[zero]");
+ }
+ log_flow_message(dpif, error, ds_cstr(&s), key, key_len, stats,
+ actions, actions_len);
+ ds_destroy(&s);
}
return error;
}
-/* Deletes a flow matching 'flow->key' from 'dpif' or returns ENOENT if 'dpif'
- * does not contain such a flow.
+/* Deletes a flow from 'dpif' and returns 0, or returns ENOENT if 'dpif' does
+ * not contain such a flow. The flow is specified by the Netlink attributes
+ * with types ODP_KEY_ATTR_* in the 'key_len' bytes starting at 'key'.
*
- * If successful, updates 'flow->stats', 'flow->actions_len', and
- * 'flow->actions' as described for dpif_flow_get(). */
+ * If the operation succeeds, then 'stats', if nonnull, will be set to the
+ * flow's statistics before its deletion. */
int
-dpif_flow_del(struct dpif *dpif, struct odp_flow *flow)
+dpif_flow_del(struct dpif *dpif,
+ const struct nlattr *key, size_t key_len,
+ struct dpif_flow_stats *stats)
{
int error;
COVERAGE_INC(dpif_flow_del);
- check_rw_flow_actions(flow);
- memset(&flow->stats, 0, sizeof flow->stats);
-
- error = dpif->dpif_class->flow_del(dpif, flow);
+ error = dpif->dpif_class->flow_del(dpif, key, key_len, stats);
+ if (error && stats) {
+ memset(stats, 0, sizeof *stats);
+ }
if (should_log_flow_message(error)) {
- log_flow_operation(dpif, "delete flow", error, flow);
+ log_flow_message(dpif, error, "flow_del", key, key_len,
+ !error ? stats : NULL, NULL, 0);
}
return error;
}
}
/* 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().
+ * initialized with dpif_flow_dump_start(). On success, updates the output
+ * parameters as described below and returns true. Otherwise, returns false.
+ * 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 success, if 'key' and 'key_len' are nonnull then '*key' and '*key_len'
+ * will be set to Netlink attributes with types ODP_KEY_ATTR_* representing the
+ * dumped flow's key. If 'actions' and 'actions_len' are nonnull then they are
+ * set to Netlink attributes with types ODPAT_* representing the dumped flow's
+ * actions. If 'stats' is nonnull then it will be set to the dumped flow's
+ * statistics.
*
- * 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). */
+ * All of the returned data is owned by 'dpif', not by the caller, and the
+ * caller must not modify or free it. 'dpif' guarantees that it remains
+ * accessible and unchanging until at least the next call to 'flow_dump_next'
+ * or 'flow_dump_done' for 'dump'. */
bool
-dpif_flow_dump_next(struct dpif_flow_dump *dump, struct odp_flow *flow)
+dpif_flow_dump_next(struct dpif_flow_dump *dump,
+ const struct nlattr **key, size_t *key_len,
+ const struct nlattr **actions, size_t *actions_len,
+ const struct dpif_flow_stats **stats)
{
const struct dpif *dpif = dump->dpif;
+ int error = dump->error;
- check_rw_flow_actions(flow);
- check_rw_flow_key(flow);
-
- if (dump->error) {
- return false;
+ if (!error) {
+ error = dpif->dpif_class->flow_dump_next(dpif, dump->state,
+ key, key_len,
+ actions, actions_len,
+ stats);
+ if (error) {
+ dpif->dpif_class->flow_dump_done(dpif, dump->state);
+ }
}
-
- 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 (error) {
+ if (key) {
+ *key = NULL;
+ *key_len = 0;
+ }
+ if (actions) {
+ *actions = NULL;
+ *actions_len = 0;
}
- if (should_log_flow_message(dump->error)) {
- log_flow_operation(dpif, "flow_dump_next", dump->error, flow);
+ if (stats) {
+ *stats = NULL;
}
}
-
- if (dump->error) {
- dpif->dpif_class->flow_dump_done(dpif, dump->state);
- return false;
+ if (!dump->error) {
+ if (error == EOF) {
+ VLOG_DBG_RL(&dpmsg_rl, "%s: dumped all flows", dpif_name(dpif));
+ } else if (should_log_flow_message(error)) {
+ log_flow_message(dpif, error, "flow_dump",
+ key ? *key : NULL, key ? *key_len : 0,
+ stats ? *stats : NULL, actions ? *actions : NULL,
+ actions ? *actions_len : 0);
+ }
}
- return true;
+ dump->error = error;
+ return !error;
}
/* Completes flow table dump operation 'dump', which must have been initialized
return error;
}
-/* Retrieves 'dpif''s "listen mask" into '*listen_mask'. Each ODPL_* bit set
- * in '*listen_mask' indicates that dpif_recv() will receive messages of that
- * type. Returns 0 if successful, otherwise a positive errno value. */
+static bool OVS_UNUSED
+is_valid_listen_mask(int listen_mask)
+{
+ return !(listen_mask & ~((1u << DPIF_UC_MISS) |
+ (1u << DPIF_UC_ACTION) |
+ (1u << DPIF_UC_SAMPLE)));
+}
+
+/* Retrieves 'dpif''s "listen mask" into '*listen_mask'. A 1-bit of value 2**X
+ * set in '*listen_mask' indicates that dpif_recv() will receive messages of
+ * the type (from "enum dpif_upcall_type") with value X. Returns 0 if
+ * successful, otherwise a positive errno value. */
int
dpif_recv_get_mask(const struct dpif *dpif, int *listen_mask)
{
if (error) {
*listen_mask = 0;
}
+ assert(is_valid_listen_mask(*listen_mask));
log_operation(dpif, "recv_get_mask", error);
return error;
}
-/* Sets 'dpif''s "listen mask" to 'listen_mask'. Each ODPL_* bit set in
- * '*listen_mask' requests that dpif_recv() receive messages of that type.
- * Returns 0 if successful, otherwise a positive errno value. */
+/* Sets 'dpif''s "listen mask" to 'listen_mask'. A 1-bit of value 2**X set in
+ * '*listen_mask' requests that dpif_recv() will receive messages of the type
+ * (from "enum dpif_upcall_type") with value X. Returns 0 if successful,
+ * otherwise a positive errno value. */
int
dpif_recv_set_mask(struct dpif *dpif, int listen_mask)
{
- int error = dpif->dpif_class->recv_set_mask(dpif, listen_mask);
+ int error;
+
+ assert(is_valid_listen_mask(listen_mask));
+
+ error = dpif->dpif_class->recv_set_mask(dpif, listen_mask);
log_operation(dpif, "recv_set_mask", error);
return error;
}
}
/* Polls for an upcall from 'dpif'. If successful, stores the upcall into
- * '*upcall'. Only upcalls of the types selected with the set_listen_mask
+ * '*upcall'. Only upcalls of the types selected with dpif_recv_set_mask()
* member function will ordinarily be received (but if a message type is
* enabled and then later disabled, some stragglers might pop up).
*
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"
+ (upcall->type == DPIF_UC_MISS ? "miss"
+ : upcall->type == DPIF_UC_ACTION ? "action"
+ : upcall->type == DPIF_UC_SAMPLE ? "sample"
: "<unknown>"),
flow.in_port, s);
free(s);
static void
log_flow_message(const struct dpif *dpif, int error, const char *operation,
const struct nlattr *key, size_t key_len,
- const struct odp_flow_stats *stats,
+ const struct dpif_flow_stats *stats,
const struct nlattr *actions, size_t actions_len)
{
struct ds ds = DS_EMPTY_INITIALIZER;
odp_flow_key_format(key, key_len, &ds);
if (stats) {
ds_put_cstr(&ds, ", ");
- format_odp_flow_stats(&ds, stats);
+ dpif_flow_stats_format(stats, &ds);
}
if (actions || actions_len) {
ds_put_cstr(&ds, ", actions:");
vlog(THIS_MODULE, flow_message_log_level(error), "%s", ds_cstr(&ds));
ds_destroy(&ds);
}
-
-static void
-log_flow_operation(const struct dpif *dpif, const char *operation, int error,
- struct odp_flow *flow)
-{
- if (error) {
- flow->key_len = 0;
- flow->actions_len = 0;
- }
- log_flow_message(dpif, error, operation,
- flow->key, flow->key_len, !error ? &flow->stats : NULL,
- flow->actions, flow->actions_len);
-}
-
-static void
-log_flow_put(struct dpif *dpif, int error, const struct odp_flow_put *put)
-{
- enum { ODPPF_ALL = ODPPF_CREATE | ODPPF_MODIFY | ODPPF_ZERO_STATS };
- struct ds s;
-
- ds_init(&s);
- ds_put_cstr(&s, "put");
- if (put->flags & ODPPF_CREATE) {
- ds_put_cstr(&s, "[create]");
- }
- if (put->flags & ODPPF_MODIFY) {
- ds_put_cstr(&s, "[modify]");
- }
- if (put->flags & ODPPF_ZERO_STATS) {
- ds_put_cstr(&s, "[zero]");
- }
- 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, put->flow.key_len,
- !error ? &put->flow.stats : NULL,
- put->flow.actions, put->flow.actions_len);
- ds_destroy(&s);
-}
-
-/* There is a tendency to construct odp_flow objects on the stack and to
- * forget to properly initialize their "actions" and "actions_len" members.
- * When this happens, we get memory corruption because the kernel
- * writes through the random pointer that is in the "actions" member.
- *
- * This function attempts to combat the problem by:
- *
- * - Forcing a segfault if "actions" points to an invalid region (instead
- * of just getting back EFAULT, which can be easily missed in the log).
- *
- * - Storing a distinctive value that is likely to cause an
- * easy-to-identify error later if it is dereferenced, etc.
- *
- * - Triggering a warning on uninitialized memory from Valgrind if
- * "actions" or "actions_len" was not initialized.
- */
-static void
-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]);
- }
-}