X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;ds=sidebyside;f=lib%2Fdpif.c;h=9cbf877179d2f2d0848f6b342219a50cf1cd93d0;hb=d60a2b538a2411019e401a0756c8c0aa1f3b6e98;hp=3786bb72d5c70285dcbfd4d6a2c6d878902d3974;hpb=d647f0a7442e7c9a0aa6026f55de2c74734599af;p=sliver-openvswitch.git diff --git a/lib/dpif.c b/lib/dpif.c index 3786bb72d..9cbf87717 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -68,6 +68,7 @@ struct registered_dpif_class { int refcount; }; static struct shash dpif_classes = SHASH_INITIALIZER(&dpif_classes); +static struct sset dpif_blacklist = SSET_INITIALIZER(&dpif_blacklist); /* Rate limit for individual messages going to or from the datapath, output at * DBG level. This is very high because, if these are enabled, it is because @@ -101,38 +102,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 @@ -140,6 +109,12 @@ dp_register_provider(const struct dpif_class *new_class) { struct registered_dpif_class *registered_class; + if (sset_contains(&dpif_blacklist, new_class->type)) { + VLOG_DBG("attempted to register blacklisted provider: %s", + new_class->type); + return EINVAL; + } + if (shash_find(&dpif_classes, new_class->type)) { VLOG_WARN("attempted to register duplicate datapath provider: %s", new_class->type); @@ -183,6 +158,14 @@ dp_unregister_provider(const char *type) return 0; } +/* Blacklists a provider. Causes future calls of dp_register_provider() with + * a dpif_class which implements 'type' to fail. */ +void +dp_blacklist_provider(const char *type) +{ + sset_add(&dpif_blacklist, type); +} + /* Clears 'types' and enumerates the types of all currently registered datapath * providers into it. The caller must first initialize the sset. */ void @@ -232,8 +215,10 @@ dp_enumerate_names(const char *type, struct sset *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) { @@ -244,10 +229,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)); } } @@ -345,6 +330,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 * @@ -389,7 +393,7 @@ dpif_delete(struct dpif *dpif) /* Retrieves statistics for 'dpif' into 'stats'. Returns 0 if successful, * otherwise a positive errno value. */ int -dpif_get_dp_stats(const struct dpif *dpif, struct odp_stats *stats) +dpif_get_dp_stats(const struct dpif *dpif, struct dpif_dp_stats *stats) { int error = dpif->dpif_class->get_stats(dpif, stats); if (error) { @@ -399,33 +403,6 @@ dpif_get_dp_stats(const struct dpif *dpif, struct odp_stats *stats) return error; } -/* Retrieves the current IP fragment handling policy for 'dpif' into - * '*drop_frags': true indicates that fragments are dropped, false indicates - * that fragments are treated in the same way as other IP packets (except that - * the L4 header cannot be read). Returns 0 if successful, otherwise a - * positive errno value. */ -int -dpif_get_drop_frags(const struct dpif *dpif, bool *drop_frags) -{ - int error = dpif->dpif_class->get_drop_frags(dpif, drop_frags); - if (error) { - *drop_frags = false; - } - log_operation(dpif, "get_drop_frags", error); - return error; -} - -/* Changes 'dpif''s treatment of IP fragments to 'drop_frags', whose meaning is - * the same as for the get_drop_frags member function. Returns 0 if - * successful, otherwise a positive errno value. */ -int -dpif_set_drop_frags(struct dpif *dpif, bool drop_frags) -{ - int error = dpif->dpif_class->set_drop_frags(dpif, drop_frags); - log_operation(dpif, "set_drop_frags", error); - return error; -} - /* 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 @@ -553,6 +530,23 @@ dpif_get_max_ports(const struct dpif *dpif) return dpif->dpif_class->get_max_ports(dpif); } +/* Returns the Netlink PID value to supply in OVS_ACTION_ATTR_USERSPACE actions + * as the OVS_USERSPACE_ATTR_PID attribute's value, for use in flows whose + * packets arrived on port 'port_no'. + * + * The return value is only meaningful when DPIF_UC_ACTION has been enabled in + * the 'dpif''s listen mask. It is allowed to change when DPIF_UC_ACTION is + * disabled and then re-enabled, so a client that does that must be prepared to + * update all of the flows that it installed that contain + * OVS_ACTION_ATTR_USERSPACE actions. */ +uint32_t +dpif_port_get_pid(const struct dpif *dpif, uint16_t port_no) +{ + return (dpif->dpif_class->port_get_pid + ? (dpif->dpif_class->port_get_pid)(dpif, port_no) + : 0); +} + /* Looks up port number 'port_no' in 'dpif'. On success, returns 0 and copies * the port's name into the 'name_size' bytes in 'name', ensuring that the * result is null-terminated. On failure, returns a positive errno value and @@ -672,6 +666,26 @@ dpif_port_poll_wait(const struct dpif *dpif) dpif->dpif_class->port_poll_wait(dpif); } +/* Extracts the flow stats for a packet. The 'flow' and 'packet' + * arguments must have been initialized through a call to flow_extract(). + */ +void +dpif_flow_stats_extract(const struct flow *flow, struct ofpbuf *packet, + struct dpif_flow_stats *stats) +{ + memset(stats, 0, sizeof(*stats)); + + if ((flow->dl_type == htons(ETH_TYPE_IP)) && packet->l4) { + if ((flow->nw_proto == IPPROTO_TCP) && packet->l7) { + struct tcp_header *tcp = packet->l4; + stats->tcp_flags = TCP_FLAGS(tcp->tcp_ctl); + } + } + + stats->n_bytes = packet->size; + stats->n_packets = 1; +} + /* Appends a human-readable representation of 'stats' to 's'. */ void dpif_flow_stats_format(const struct dpif_flow_stats *stats, struct ds *s) @@ -701,7 +715,7 @@ dpif_flow_flush(struct dpif *dpif) } /* 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 + * attributes with types OVS_KEY_ATTR_* in the 'key_len' bytes starting at * 'key'. * * Returns 0 if successful. If no flow matches, returns ENOENT. On other @@ -750,9 +764,9 @@ dpif_flow_get(const struct dpif *dpif, } /* 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 + * attributes with types OVS_KEY_ATTR_* in the 'key_len' bytes starting at * 'key'. The associated actions are specified by the Netlink attributes with - * types ODP_ACTION_ATTR_* in the 'actions_len' bytes starting at 'actions'. + * types OVS_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 DPIF_FP_CREATE. Otherwise the operation will fail with @@ -808,7 +822,7 @@ dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags, /* 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'. + * with types OVS_KEY_ATTR_* in the 'key_len' bytes starting at 'key'. * * If the operation succeeds, then 'stats', if nonnull, will be set to the * flow's statistics before its deletion. */ @@ -854,9 +868,9 @@ dpif_flow_dump_start(struct dpif_flow_dump *dump, const struct dpif *dpif) * 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 + * will be set to Netlink attributes with types OVS_KEY_ATTR_* representing the * dumped flow's key. If 'actions' and 'actions_len' are nonnull then they are - * set to Netlink attributes with types ODP_ACTION_ATTR_* representing the + * set to Netlink attributes with types OVS_ACTION_ATTR_* representing the * dumped flow's actions. If 'stats' is nonnull then it will be set to the * dumped flow's statistics. * @@ -924,11 +938,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) { @@ -936,7 +954,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; } @@ -957,12 +976,67 @@ dpif_execute(struct dpif *dpif, return error; } +/* Executes each of the 'n_ops' operations in 'ops' on 'dpif', in the order in + * which they are specified, placing each operation's results in the "output" + * members documented in comments. + * + * This function exists because some datapaths can perform batched operations + * faster than individual operations. */ +void +dpif_operate(struct dpif *dpif, union dpif_op **ops, size_t n_ops) +{ + size_t i; + + if (dpif->dpif_class->operate) { + dpif->dpif_class->operate(dpif, ops, n_ops); + return; + } + + for (i = 0; i < n_ops; i++) { + union dpif_op *op = ops[i]; + struct dpif_flow_put *put; + struct dpif_execute *execute; + + switch (op->type) { + case DPIF_OP_FLOW_PUT: + put = &op->flow_put; + put->error = dpif_flow_put(dpif, put->flags, + put->key, put->key_len, + put->actions, put->actions_len, + put->stats); + break; + + case DPIF_OP_EXECUTE: + execute = &op->execute; + execute->error = dpif_execute(dpif, execute->key, execute->key_len, + execute->actions, + execute->actions_len, + execute->packet); + break; + + default: + NOT_REACHED(); + } + } +} + + +/* 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_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))); + (1u << DPIF_UC_ACTION))); } /* Retrieves 'dpif''s "listen mask" into '*listen_mask'. A 1-bit of value 2**X @@ -984,7 +1058,12 @@ dpif_recv_get_mask(const struct dpif *dpif, int *listen_mask) /* 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. */ + * otherwise a positive errno value. + * + * Turning DPIF_UC_ACTION off and then back on may change the Netlink PID + * assignments returned by dpif_port_get_pid(). If the client does this, it + * must update all of the flows that have OVS_ACTION_ATTR_USERSPACE actions + * using the new PID assignment. */ int dpif_recv_set_mask(struct dpif *dpif, int listen_mask) { @@ -997,41 +1076,6 @@ dpif_recv_set_mask(struct dpif *dpif, int listen_mask) return error; } -/* Retrieve the sFlow sampling probability. '*probability' is expressed as the - * number of packets out of UINT_MAX to sample, e.g. probability/UINT_MAX is - * the probability of sampling a given packet. - * - * Returns 0 if successful, otherwise a positive errno value. EOPNOTSUPP - * indicates that 'dpif' does not support sFlow sampling. */ -int -dpif_get_sflow_probability(const struct dpif *dpif, uint32_t *probability) -{ - int error = (dpif->dpif_class->get_sflow_probability - ? dpif->dpif_class->get_sflow_probability(dpif, probability) - : EOPNOTSUPP); - if (error) { - *probability = 0; - } - log_operation(dpif, "get_sflow_probability", error); - return error; -} - -/* Set the sFlow sampling probability. 'probability' is expressed as the - * number of packets out of UINT_MAX to sample, e.g. probability/UINT_MAX is - * the probability of sampling a given packet. - * - * Returns 0 if successful, otherwise a positive errno value. EOPNOTSUPP - * indicates that 'dpif' does not support sFlow sampling. */ -int -dpif_set_sflow_probability(struct dpif *dpif, uint32_t probability) -{ - int error = (dpif->dpif_class->set_sflow_probability - ? dpif->dpif_class->set_sflow_probability(dpif, probability) - : EOPNOTSUPP); - log_operation(dpif, "set_sflow_probability", error); - return error; -} - /* Polls for an upcall from 'dpif'. If successful, stores the upcall into * '*upcall'. Only upcalls of the types selected with dpif_recv_set_mask() * member function will ordinarily be received (but if a message type is @@ -1050,20 +1094,24 @@ 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 == DPIF_UC_MISS ? "miss" - : upcall->type == DPIF_UC_ACTION ? "action" - : upcall->type == DPIF_UC_SAMPLE ? "sample" - : ""), - 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); + } else if (error && error != EAGAIN) { + log_operation(dpif, "recv", error); } return error; } @@ -1098,9 +1146,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 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'. */ + * value used for setting packet priority. + * 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)