X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=lib%2Fdpif.c;h=4e3788d42e2b9c35be7e93316bbad13b4ca76d7f;hb=299016266ed13376a7d671f66d4e0181b41098e3;hp=487b60a3db614b0498912f81066c040ad0787105;hpb=feebdea2e5550a71c7accda936b6a55962f60a04;p=openvswitch diff --git a/lib/dpif.c b/lib/dpif.c index 487b60a3..4e3788d4 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -36,7 +36,8 @@ #include "packets.h" #include "poll-loop.h" #include "shash.h" -#include "svec.h" +#include "sset.h" +#include "timeval.h" #include "util.h" #include "valgrind.h" #include "vlog.h" @@ -79,7 +80,7 @@ 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 odp_flow_stats *stats, + 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); @@ -100,38 +101,6 @@ dp_initialize(void) } } -/* Performs periodic work needed by all the various kinds of dpifs. - * - * If your program opens any dpifs, it must call both this function and - * netdev_run() within its main poll loop. */ -void -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(); - } - } -} - -/* Arranges for poll_block() to wake up when dp_run() needs to be called. - * - * If your program opens any dpifs, it must call both this function and - * netdev_wait() within its main poll loop. */ -void -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(); - } - } -} - /* Registers a new datapath provider. After successful registration, new * datapaths of that type can be opened using dpif_open(). */ int @@ -183,36 +152,36 @@ dp_unregister_provider(const char *type) } /* Clears 'types' and enumerates the types of all currently registered datapath - * providers into it. The caller must first initialize the svec. */ + * providers into it. The caller must first initialize the sset. */ void -dp_enumerate_types(struct svec *types) +dp_enumerate_types(struct sset *types) { struct shash_node *node; dp_initialize(); - svec_clear(types); + sset_clear(types); SHASH_FOR_EACH(node, &dpif_classes) { const struct registered_dpif_class *registered_class = node->data; - svec_add(types, registered_class->dpif_class->type); + sset_add(types, registered_class->dpif_class->type); } } /* Clears 'names' and enumerates the names of all known created datapaths with - * the given 'type'. The caller must first initialize the svec. Returns 0 if + * the given 'type'. The caller must first initialize the sset. Returns 0 if * successful, otherwise a positive errno value. * * Some kinds of datapaths might not be practically enumerable. This is not * considered an error. */ int -dp_enumerate_names(const char *type, struct svec *names) +dp_enumerate_names(const char *type, struct sset *names) { const struct registered_dpif_class *registered_class; const struct dpif_class *dpif_class; int error; dp_initialize(); - svec_clear(names); + sset_clear(names); registered_class = shash_find_data(&dpif_classes, type); if (!registered_class) { @@ -231,8 +200,10 @@ dp_enumerate_names(const char *type, struct svec *names) return error; } -/* Parses 'datapath name', which is of the form type@name into its - * component pieces. 'name' and 'type' must be freed by the caller. */ +/* Parses 'datapath_name_', which is of the form [type@]name into its + * component pieces. 'name' and 'type' must be freed by the caller. + * + * The returned 'type' is normalized, as if by dpif_normalize_type(). */ void dp_parse_name(const char *datapath_name_, char **name, char **type) { @@ -243,10 +214,10 @@ dp_parse_name(const char *datapath_name_, char **name, char **type) if (separator) { *separator = '\0'; *type = datapath_name; - *name = xstrdup(separator + 1); + *name = xstrdup(dpif_normalize_type(separator + 1)); } else { *name = datapath_name; - *type = NULL; + *type = xstrdup(dpif_normalize_type(NULL)); } } @@ -259,9 +230,7 @@ do_open(const char *name, const char *type, bool create, struct dpif **dpifp) dp_initialize(); - if (!type || *type == '\0') { - type = "system"; - } + type = dpif_normalize_type(type); registered_class = shash_find_data(&dpif_classes, type); if (!registered_class) { @@ -346,6 +315,25 @@ dpif_close(struct dpif *dpif) } } +/* Performs periodic work needed by 'dpif'. */ +void +dpif_run(struct dpif *dpif) +{ + if (dpif->dpif_class->run) { + dpif->dpif_class->run(dpif); + } +} + +/* Arranges for poll_block() to wake up when dp_run() needs to be called for + * 'dpif'. */ +void +dpif_wait(struct dpif *dpif) +{ + if (dpif->dpif_class->wait) { + dpif->dpif_class->wait(dpif); + } +} + /* Returns the name of datapath 'dpif' prefixed with the type * (for use in log messages). */ const char * @@ -362,33 +350,16 @@ dpif_base_name(const struct dpif *dpif) return dpif->base_name; } -/* Enumerates all names that may be used to open 'dpif' into 'all_names'. The - * Linux datapath, for example, supports opening a datapath both by number, - * e.g. "dp0", and by the name of the datapath's local port. For some - * datapaths, this might be an infinite set (e.g. in a file name, slashes may - * be duplicated any number of times), in which case only the names most likely - * to be used will be enumerated. +/* Returns the fully spelled out name for the given datapath 'type'. * - * The caller must already have initialized 'all_names'. Any existing names in - * 'all_names' will not be disturbed. */ -int -dpif_get_all_names(const struct dpif *dpif, struct svec *all_names) + * Normalized type string can be compared with strcmp(). Unnormalized type + * string might be the same even if they have different spellings. */ +const char * +dpif_normalize_type(const char *type) { - if (dpif->dpif_class->get_all_names) { - int error = dpif->dpif_class->get_all_names(dpif, all_names); - if (error) { - VLOG_WARN_RL(&error_rl, - "failed to retrieve names for datpath %s: %s", - dpif_name(dpif), strerror(error)); - } - return error; - } else { - svec_add(all_names, dpif_base_name(dpif)); - return 0; - } + return type && type[0] ? type : "system"; } - /* 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(). */ @@ -498,6 +469,7 @@ dpif_port_clone(struct dpif_port *dst, const struct dpif_port *src) dst->name = xstrdup(src->name); dst->type = xstrdup(src->type); dst->port_no = src->port_no; + dst->stats = src->stats; } /* Frees memory allocated to members of 'dpif_port'. @@ -551,11 +523,14 @@ dpif_port_query_by_name(const struct dpif *dpif, const char *devname, } else { memset(port, 0, sizeof *port); - /* Log level is DBG here because all the current callers are interested - * in whether 'dpif' actually has a port 'devname', so that it's not an - * issue worth logging if it doesn't. */ - VLOG_DBG_RL(&error_rl, "%s: failed to query port %s: %s", - dpif_name(dpif), devname, strerror(error)); + /* For ENOENT or ENODEV we use DBG level because the caller is probably + * interested in whether 'dpif' actually has a port 'devname', so that + * it's not an issue worth logging if it doesn't. Other errors are + * uncommon and more likely to indicate a real problem. */ + VLOG_RL(&error_rl, + error == ENOENT || error == ENODEV ? VLL_DBG : VLL_WARN, + "%s: failed to query port %s: %s", + dpif_name(dpif), devname, strerror(error)); } return error; } @@ -687,6 +662,20 @@ dpif_port_poll_wait(const struct dpif *dpif) 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 @@ -716,16 +705,15 @@ dpif_flow_flush(struct dpif *dpif) * If 'stats' is nonnull, then on success it will be updated with the flow's * statistics. */ int -dpif_flow_get(const struct dpif *dpif, int flags, +dpif_flow_get(const struct dpif *dpif, const struct nlattr *key, size_t key_len, - struct ofpbuf **actionsp, struct odp_flow_stats *stats) + struct ofpbuf **actionsp, struct dpif_flow_stats *stats) { int error; COVERAGE_INC(dpif_flow_get); - error = dpif->dpif_class->flow_get(dpif, flags, key, key_len, actionsp, - stats); + error = dpif->dpif_class->flow_get(dpif, key, key_len, actionsp, stats); if (error) { if (actionsp) { *actionsp = NULL; @@ -754,32 +742,33 @@ dpif_flow_get(const struct dpif *dpif, int flags, /* 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'. + * types ODP_ACTION_ATTR_* in the 'actions_len' bytes starting at 'actions'. * * - If the flow's key does not exist in 'dpif', then the flow will be added if - * 'flags' includes ODPPF_CREATE. Otherwise the operation will fail with + * 'flags' includes DPIF_FP_CREATE. Otherwise the operation will fail with * ENOENT. * * 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 ODPPF_MODIFY. Otherwise the operation will + * 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 ODPPF_ZERO_STATS, and left as-is + * will be zeroed if 'flags' includes DPIF_FP_ZERO_STATS, and left as-is * otherwise. * * 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, int flags, +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 odp_flow_stats *stats) + 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, flags, key, key_len, actions, actions_len, stats); @@ -787,23 +776,19 @@ dpif_flow_put(struct dpif *dpif, int flags, memset(stats, 0, sizeof *stats); } if (should_log_flow_message(error)) { - enum { ODPPF_ALL = ODPPF_CREATE | ODPPF_MODIFY | ODPPF_ZERO_STATS }; struct ds s; ds_init(&s); ds_put_cstr(&s, "put"); - if (flags & ODPPF_CREATE) { + if (flags & DPIF_FP_CREATE) { ds_put_cstr(&s, "[create]"); } - if (flags & ODPPF_MODIFY) { + if (flags & DPIF_FP_MODIFY) { ds_put_cstr(&s, "[modify]"); } - if (flags & ODPPF_ZERO_STATS) { + if (flags & DPIF_FP_ZERO_STATS) { ds_put_cstr(&s, "[zero]"); } - if (flags & ~ODPPF_ALL) { - ds_put_format(&s, "[%x]", flags & ~ODPPF_ALL); - } log_flow_message(dpif, error, ds_cstr(&s), key, key_len, stats, actions, actions_len); ds_destroy(&s); @@ -820,7 +805,7 @@ dpif_flow_put(struct dpif *dpif, int flags, int dpif_flow_del(struct dpif *dpif, const struct nlattr *key, size_t key_len, - struct odp_flow_stats *stats) + struct dpif_flow_stats *stats) { int error; @@ -861,9 +846,9 @@ dpif_flow_dump_start(struct dpif_flow_dump *dump, const struct dpif *dpif) * 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. + * set to Netlink attributes with types ODP_ACTION_ATTR_* representing the + * dumped flow's actions. If 'stats' is nonnull then it will be set to the + * dumped flow's statistics. * * 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 @@ -873,7 +858,7 @@ bool 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 odp_flow_stats **stats) + const struct dpif_flow_stats **stats) { const struct dpif *dpif = dump->dpif; int error = dump->error; @@ -929,11 +914,15 @@ dpif_flow_dump_done(struct dpif_flow_dump *dump) } /* Causes 'dpif' to perform the 'actions_len' bytes of actions in 'actions' on - * the Ethernet frame specified in 'packet'. + * the Ethernet frame specified in 'packet' taken from the flow specified in + * the 'key_len' bytes of 'key'. ('key' is mostly redundant with 'packet', but + * it contains some metadata that cannot be recovered from 'packet', such as + * tun_id and in_port.) * * Returns 0 if successful, otherwise a positive errno value. */ int dpif_execute(struct dpif *dpif, + const struct nlattr *key, size_t key_len, const struct nlattr *actions, size_t actions_len, const struct ofpbuf *buf) { @@ -941,7 +930,8 @@ dpif_execute(struct dpif *dpif, COVERAGE_INC(dpif_execute); if (actions_len > 0) { - error = dpif->dpif_class->execute(dpif, actions, actions_len, buf); + error = dpif->dpif_class->execute(dpif, key, key_len, + actions, actions_len, buf); } else { error = 0; } @@ -962,9 +952,30 @@ dpif_execute(struct dpif *dpif, 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. */ +/* Returns a string that represents 'type', for use in log messages. */ +const char * +dpif_upcall_type_to_string(enum dpif_upcall_type type) +{ + switch (type) { + case DPIF_UC_MISS: return "miss"; + case DPIF_UC_ACTION: return "action"; + case DPIF_UC_SAMPLE: return "sample"; + case DPIF_N_UC_TYPES: default: return ""; + } +} + +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) { @@ -972,17 +983,23 @@ 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; } @@ -1023,7 +1040,7 @@ dpif_set_sflow_probability(struct dpif *dpif, uint32_t probability) } /* 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). * @@ -1040,20 +1057,22 @@ dpif_recv(struct dpif *dpif, struct dpif_upcall *upcall) { 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); + struct ds flow; + char *packet; + + packet = ofp_packet_to_string(upcall->packet->data, + upcall->packet->size, + upcall->packet->size); + + ds_init(&flow); + odp_flow_key_format(upcall->key, upcall->key_len, &flow); + + VLOG_DBG("%s: %s upcall:\n%s\n%s", + dpif_name(dpif), dpif_upcall_type_to_string(upcall->type), + ds_cstr(&flow), packet); + + ds_destroy(&flow); + free(packet); } return error; } @@ -1088,9 +1107,9 @@ dpif_get_netflow_ids(const struct dpif *dpif, } /* Translates OpenFlow queue ID 'queue_id' (in host byte order) into a priority - * value for use in the ODPAT_SET_PRIORITY action. On success, returns 0 and - * stores the priority into '*priority'. On failure, returns a positive errno - * value and stores 0 into '*priority'. */ + * value for use in the ODP_ACTION_ATTR_SET_PRIORITY action. On success, + * returns 0 and stores the priority into '*priority'. On failure, returns a + * positive errno value and stores 0 into '*priority'. */ int dpif_queue_to_priority(const struct dpif *dpif, uint32_t queue_id, uint32_t *priority) @@ -1169,7 +1188,7 @@ should_log_flow_message(int error) 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; @@ -1184,7 +1203,7 @@ log_flow_message(const struct dpif *dpif, int error, const char *operation, 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:");