X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fdpif.c;h=708b5347eee01a69f88bcde6b7470c04a077ae2e;hb=b0ec0f279ea4537cb421eba807254aba8f1971f2;hp=e117bdf9cd29e5b4906d83015d7182894d0417bd;hpb=71ce92352cbcb96f179f8ec19dd1e843d91d8828;p=sliver-openvswitch.git diff --git a/lib/dpif.c b/lib/dpif.c index e117bdf9c..708b5347e 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -27,6 +27,7 @@ #include "coverage.h" #include "dynamic-string.h" #include "flow.h" +#include "netdev.h" #include "netlink.h" #include "odp-util.h" #include "ofp-print.h" @@ -42,6 +43,18 @@ VLOG_DEFINE_THIS_MODULE(dpif); +COVERAGE_DEFINE(dpif_destroy); +COVERAGE_DEFINE(dpif_port_add); +COVERAGE_DEFINE(dpif_port_del); +COVERAGE_DEFINE(dpif_flow_flush); +COVERAGE_DEFINE(dpif_flow_get); +COVERAGE_DEFINE(dpif_flow_put); +COVERAGE_DEFINE(dpif_flow_del); +COVERAGE_DEFINE(dpif_flow_query_list); +COVERAGE_DEFINE(dpif_flow_query_list_n); +COVERAGE_DEFINE(dpif_execute); +COVERAGE_DEFINE(dpif_purge); + static const struct dpif_class *base_dpif_classes[] = { #ifdef HAVE_NETLINK &dpif_linux_class, @@ -50,7 +63,7 @@ static const struct dpif_class *base_dpif_classes[] = { }; struct registered_dpif_class { - struct dpif_class dpif_class; + const struct dpif_class *dpif_class; int refcount; }; static struct shash dpif_classes = SHASH_INITIALIZER(&dpif_classes); @@ -70,7 +83,8 @@ static void log_flow_operation(const struct dpif *, const char *operation, 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) @@ -97,8 +111,8 @@ dp_run(void) struct shash_node *node; SHASH_FOR_EACH(node, &dpif_classes) { const struct registered_dpif_class *registered_class = node->data; - if (registered_class->dpif_class.run) { - registered_class->dpif_class.run(); + if (registered_class->dpif_class->run) { + registered_class->dpif_class->run(); } } } @@ -113,8 +127,8 @@ dp_wait(void) struct shash_node *node; SHASH_FOR_EACH(node, &dpif_classes) { const struct registered_dpif_class *registered_class = node->data; - if (registered_class->dpif_class.wait) { - registered_class->dpif_class.wait(); + if (registered_class->dpif_class->wait) { + registered_class->dpif_class->wait(); } } } @@ -133,8 +147,7 @@ dp_register_provider(const struct dpif_class *new_class) } registered_class = xmalloc(sizeof *registered_class); - memcpy(®istered_class->dpif_class, new_class, - sizeof registered_class->dpif_class); + registered_class->dpif_class = new_class; registered_class->refcount = 0; shash_add(&dpif_classes, new_class->type, registered_class); @@ -182,7 +195,7 @@ dp_enumerate_types(struct svec *types) SHASH_FOR_EACH(node, &dpif_classes) { const struct registered_dpif_class *registered_class = node->data; - svec_add(types, registered_class->dpif_class.type); + svec_add(types, registered_class->dpif_class->type); } } @@ -208,7 +221,7 @@ dp_enumerate_names(const char *type, struct svec *names) return EAFNOSUPPORT; } - dpif_class = ®istered_class->dpif_class; + dpif_class = registered_class->dpif_class; error = dpif_class->enumerate ? dpif_class->enumerate(names) : 0; if (error) { @@ -259,8 +272,10 @@ do_open(const char *name, const char *type, bool create, struct dpif **dpifp) goto exit; } - error = registered_class->dpif_class.open(name, type, create, &dpif); + error = registered_class->dpif_class->open(registered_class->dpif_class, + name, create, &dpif); if (!error) { + assert(dpif->dpif_class == registered_class->dpif_class); registered_class->refcount++; } @@ -374,6 +389,7 @@ dpif_get_all_names(const struct dpif *dpif, struct svec *all_names) } } + /* Destroys the datapath that 'dpif' is connected to, first removing all of its * ports. After calling this function, it does not make sense to pass 'dpif' * to any functions other than dpif_name() or dpif_close(). */ @@ -429,27 +445,26 @@ dpif_set_drop_frags(struct dpif *dpif, bool drop_frags) return error; } -/* Attempts to add 'devname' as a port on 'dpif', given the combination of - * ODP_PORT_* flags in 'flags'. If successful, returns 0 and sets '*port_nop' - * to the new port's port number (if 'port_nop' is non-null). On failure, - * returns a positive errno value and sets '*port_nop' to UINT16_MAX (if - * 'port_nop' is non-null). */ +/* Attempts to add 'netdev' as a port on 'dpif'. If successful, returns 0 and + * sets '*port_nop' to the new port's port number (if 'port_nop' is non-null). + * On failure, returns a positive errno value and sets '*port_nop' to + * UINT16_MAX (if 'port_nop' is non-null). */ int -dpif_port_add(struct dpif *dpif, const char *devname, uint16_t flags, - uint16_t *port_nop) +dpif_port_add(struct dpif *dpif, struct netdev *netdev, uint16_t *port_nop) { + const char *netdev_name = netdev_get_name(netdev); uint16_t port_no; int error; COVERAGE_INC(dpif_port_add); - error = dpif->dpif_class->port_add(dpif, devname, flags, &port_no); + error = dpif->dpif_class->port_add(dpif, netdev, &port_no); if (!error) { VLOG_DBG_RL(&dpmsg_rl, "%s: added %s as port %"PRIu16, - dpif_name(dpif), devname, port_no); + dpif_name(dpif), netdev_name, port_no); } else { VLOG_WARN_RL(&error_rl, "%s: failed to add %s as port: %s", - dpif_name(dpif), devname, strerror(error)); + dpif_name(dpif), netdev_name, strerror(error)); port_no = UINT16_MAX; } if (port_nop) { @@ -468,7 +483,12 @@ dpif_port_del(struct dpif *dpif, uint16_t port_no) COVERAGE_INC(dpif_port_del); error = dpif->dpif_class->port_del(dpif, port_no); - log_operation(dpif, "port_del", error); + if (!error) { + VLOG_DBG_RL(&dpmsg_rl, "%s: port_del(%"PRIu16")", + dpif_name(dpif), port_no); + } else { + log_operation(dpif, "port_del", error); + } return error; } @@ -536,60 +556,62 @@ dpif_port_get_name(struct dpif *dpif, uint16_t port_no, return error; } -/* Obtains a list of all the ports in 'dpif'. +/* Initializes 'dump' to begin dumping the ports in a dpif. * - * If successful, returns 0 and sets '*portsp' to point to an array of - * appropriately initialized port structures and '*n_portsp' to the number of - * ports in the array. The caller is responsible for freeing '*portp' by - * calling free(). + * This function provides no status indication. An error status for the entire + * dump operation is provided when it is completed by calling + * dpif_port_dump_done(). + */ +void +dpif_port_dump_start(struct dpif_port_dump *dump, const struct dpif *dpif) +{ + dump->dpif = dpif; + dump->error = dpif->dpif_class->port_dump_start(dpif, &dump->state); + log_operation(dpif, "port_dump_start", dump->error); +} + +/* Attempts to retrieve another port from 'dump', which must have been + * initialized with dpif_port_dump_start(). On success, stores a new odp_port + * into 'port' and returns true. On failure, returns false. * - * On failure, returns a positive errno value and sets '*portsp' to NULL and - * '*n_portsp' to 0. */ -int -dpif_port_list(const struct dpif *dpif, - struct odp_port **portsp, size_t *n_portsp) + * Failure might indicate an actual error or merely that the last port has been + * dumped. An error status for the entire dump operation is provided when it + * is completed by calling dpif_port_dump_done(). */ +bool +dpif_port_dump_next(struct dpif_port_dump *dump, struct odp_port *port) { - struct odp_port *ports; - size_t n_ports = 0; - int error; + const struct dpif *dpif = dump->dpif; - for (;;) { - struct odp_stats stats; - int retval; + if (dump->error) { + return false; + } - error = dpif_get_dp_stats(dpif, &stats); - if (error) { - goto exit; - } + dump->error = dpif->dpif_class->port_dump_next(dpif, dump->state, port); + if (dump->error == EOF) { + VLOG_DBG_RL(&dpmsg_rl, "%s: dumped all ports", dpif_name(dpif)); + } else { + log_operation(dpif, "port_dump_next", dump->error); + } - ports = xcalloc(stats.n_ports, sizeof *ports); - retval = dpif->dpif_class->port_list(dpif, ports, stats.n_ports); - if (retval < 0) { - /* Hard error. */ - error = -retval; - free(ports); - goto exit; - } else if (retval <= stats.n_ports) { - /* Success. */ - error = 0; - n_ports = retval; - goto exit; - } else { - /* Soft error: port count increased behind our back. Try again. */ - free(ports); - } + if (dump->error) { + dpif->dpif_class->port_dump_done(dpif, dump->state); + return false; } + return true; +} -exit: - if (error) { - *portsp = NULL; - *n_portsp = 0; - } else { - *portsp = ports; - *n_portsp = n_ports; +/* Completes port table dump operation 'dump', which must have been initialized + * with dpif_port_dump_start(). Returns 0 if the dump operation was + * error-free, otherwise a positive errno value describing the problem. */ +int +dpif_port_dump_done(struct dpif_port_dump *dump) +{ + const struct dpif *dpif = dump->dpif; + if (!dump->error) { + dump->error = dpif->dpif_class->port_dump_done(dpif, dump->state); + log_operation(dpif, "port_dump_done", dump->error); } - log_operation(dpif, "port_list", error); - return error; + return dump->error == EOF ? 0 : dump->error; } /* Polls for changes in the set of ports in 'dpif'. If the set of ports in @@ -643,13 +665,13 @@ dpif_flow_flush(struct dpif *dpif) /* Queries 'dpif' for a flow entry matching 'flow->key'. * * If a flow matching 'flow->key' exists in 'dpif', stores statistics for the - * flow into 'flow->stats'. If 'flow->n_actions' is zero, then 'flow->actions' - * is ignored. If 'flow->n_actions' is nonzero, then 'flow->actions' should - * point to an array of the specified number of actions. At most that many of - * the flow's actions will be copied into that array. 'flow->n_actions' will - * be updated to the number of actions actually present in the flow, which may - * be greater than the number stored if the flow has more actions than space - * available in the array. + * 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. * * If no flow matching 'flow->key' exists in 'dpif', returns ENOENT. On other * failure, returns a positive errno value. */ @@ -660,7 +682,7 @@ dpif_flow_get(const struct dpif *dpif, struct odp_flow *flow) 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; @@ -668,7 +690,7 @@ dpif_flow_get(const struct dpif *dpif, struct odp_flow *flow) if (error) { /* Make the results predictable on error. */ memset(&flow->stats, 0, sizeof flow->stats); - flow->n_actions = 0; + flow->actions_len = 0; } if (should_log_flow_message(error)) { log_flow_operation(dpif, "flow_get", error, flow); @@ -683,13 +705,13 @@ dpif_flow_get(const struct dpif *dpif, struct odp_flow *flow) * Stores 0 into 'flow->stats.error' and stores statistics for the flow * into 'flow->stats'. * - * If 'flow->n_actions' is zero, then 'flow->actions' is ignored. If - * 'flow->n_actions' is nonzero, then 'flow->actions' should point to an - * array of the specified number of actions. At most that many of the - * flow's actions will be copied into that array. 'flow->n_actions' will - * be updated to the number of actions actually present in the flow, which - * may be greater than the number stored if the flow has more actions than - * space available in the array. + * 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 @@ -713,7 +735,7 @@ dpif_flow_get_multiple(const struct dpif *dpif, 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); @@ -754,8 +776,8 @@ dpif_flow_put(struct dpif *dpif, struct odp_flow_put *put) /* Deletes a flow matching 'flow->key' from 'dpif' or returns ENOENT if 'dpif' * does not contain such a flow. * - * If successful, updates 'flow->stats', 'flow->n_actions', and 'flow->actions' - * as described for dpif_flow_get(). */ + * If successful, updates 'flow->stats', 'flow->actions_len', and + * 'flow->actions' as described for dpif_flow_get(). */ int dpif_flow_del(struct dpif *dpif, struct odp_flow *flow) { @@ -763,7 +785,7 @@ dpif_flow_del(struct dpif *dpif, struct odp_flow *flow) 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); @@ -773,101 +795,92 @@ dpif_flow_del(struct dpif *dpif, struct odp_flow *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].n_actions = 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 'n_actions' actions in 'actions' on the - * Ethernet frame specified in 'packet'. +/* Causes 'dpif' to perform the 'actions_len' bytes of actions in 'actions' on + * the Ethernet frame specified in 'packet'. * * Returns 0 if successful, otherwise a positive errno value. */ int dpif_execute(struct dpif *dpif, - const union odp_action actions[], size_t n_actions, + const struct nlattr *actions, size_t actions_len, const struct ofpbuf *buf) { int error; COVERAGE_INC(dpif_execute); - if (n_actions > 0) { - error = dpif->dpif_class->execute(dpif, actions, n_actions, buf); + if (actions_len > 0) { + error = dpif->dpif_class->execute(dpif, actions, actions_len, buf); } else { error = 0; } @@ -876,7 +889,7 @@ dpif_execute(struct dpif *dpif, struct ds ds = DS_EMPTY_INITIALIZER; char *packet = ofp_packet_to_string(buf->data, buf->size, buf->size); ds_put_format(&ds, "%s: execute ", dpif_name(dpif)); - format_odp_actions(&ds, actions, n_actions); + format_odp_actions(&ds, actions, actions_len); if (error) { ds_put_format(&ds, " failed (%s)", strerror(error)); } @@ -948,39 +961,38 @@ dpif_set_sflow_probability(struct dpif *dpif, uint32_t probability) 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" - : ""), - 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" + : ""), + flow.in_port, s); + free(s); } return error; } @@ -1002,12 +1014,12 @@ dpif_recv_purge(struct dpif *dpif) } 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; } @@ -1111,9 +1123,9 @@ should_log_flow_message(int error) 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 union odp_action *actions, size_t n_actions) + const struct nlattr *actions, size_t actions_len) { struct ds ds = DS_EMPTY_INITIALIZER; ds_put_format(&ds, "%s: ", dpif_name(dpif)); @@ -1124,14 +1136,14 @@ log_flow_message(const struct dpif *dpif, int error, const char *operation, 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); } - if (actions || n_actions) { + if (actions || actions_len) { ds_put_cstr(&ds, ", actions:"); - format_odp_actions(&ds, actions, n_actions); + format_odp_actions(&ds, actions, actions_len); } vlog(THIS_MODULE, flow_message_log_level(error), "%s", ds_cstr(&ds)); ds_destroy(&ds); @@ -1142,11 +1154,12 @@ log_flow_operation(const struct dpif *dpif, const char *operation, int error, struct odp_flow *flow) { if (error) { - flow->n_actions = 0; + flow->key_len = 0; + flow->actions_len = 0; } - log_flow_message(dpif, error, operation, &flow->key, - !error ? &flow->stats : NULL, - flow->actions, flow->n_actions); + log_flow_message(dpif, error, operation, + flow->key, flow->key_len, !error ? &flow->stats : NULL, + flow->actions, flow->actions_len); } static void @@ -1169,14 +1182,15 @@ log_flow_put(struct dpif *dpif, int error, const struct odp_flow_put *put) 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.n_actions); + 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 "n_actions" members. + * 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. * @@ -1189,12 +1203,21 @@ log_flow_put(struct dpif *dpif, int error, const struct odp_flow_put *put) * easy-to-identify error later if it is dereferenced, etc. * * - Triggering a warning on uninitialized memory from Valgrind if - * "actions" or "n_actions" was not initialized. + * "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->n_actions) { + 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]); + } +}