X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fdpif.c;h=18ef790afac4d74abad7651e21166fa67b826848;hb=85b20fd6ee585f462e012fbcc7f966a81edab2ed;hp=d8134698ae7f79363b7aa25e9fcd3cf9c674ca8f;hpb=89625d1efb32461071837b5e81c1238b4ca63387;p=sliver-openvswitch.git diff --git a/lib/dpif.c b/lib/dpif.c index d8134698a..18ef790af 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011, 2012 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -58,10 +58,11 @@ COVERAGE_DEFINE(dpif_execute); COVERAGE_DEFINE(dpif_purge); static const struct dpif_class *base_dpif_classes[] = { -#ifdef HAVE_NETLINK +#ifdef LINUX_DATAPATH &dpif_linux_class, #endif &dpif_netdev_class, + &dpif_planetlab_class, }; struct registered_dpif_class { @@ -89,6 +90,8 @@ static void log_operation(const struct dpif *, const char *operation, static bool should_log_flow_message(int error); static void log_flow_put_message(struct dpif *, const struct dpif_flow_put *, int error); +static void log_flow_del_message(struct dpif *, const struct dpif_flow_del *, + int error); static void log_execute_message(struct dpif *, const struct dpif_execute *, int error); @@ -370,6 +373,13 @@ dpif_base_name(const struct dpif *dpif) return dpif->base_name; } +/* Returns the type of datapath 'dpif'. */ +const char * +dpif_type(const struct dpif *dpif) +{ + return dpif->dpif_class->type; +} + /* Returns the fully spelled out name for the given datapath 'type'. * * Normalized type string can be compared with strcmp(). Unnormalized type @@ -408,27 +418,52 @@ dpif_get_dp_stats(const struct dpif *dpif, struct dpif_dp_stats *stats) 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 - * UINT16_MAX (if 'port_nop' is non-null). */ +const char * +dpif_port_open_type(const char *datapath_type, const char *port_type) +{ + struct registered_dpif_class *registered_class; + + datapath_type = dpif_normalize_type(datapath_type); + + registered_class = shash_find_data(&dpif_classes, datapath_type); + if (!registered_class + || !registered_class->dpif_class->port_open_type) { + return port_type; + } + + return registered_class->dpif_class->port_open_type( + registered_class->dpif_class, port_type); +} + +/* Attempts to add 'netdev' as a port on 'dpif'. If 'port_nop' is + * non-null and its value is not UINT32_MAX, then attempts to use the + * value as the port number. + * + * 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 UINT32_MAX (if 'port_nop' is + * non-null). */ int -dpif_port_add(struct dpif *dpif, struct netdev *netdev, uint16_t *port_nop) +dpif_port_add(struct dpif *dpif, struct netdev *netdev, uint32_t *port_nop) { const char *netdev_name = netdev_get_name(netdev); - uint16_t port_no; + uint32_t port_no = UINT32_MAX; int error; COVERAGE_INC(dpif_port_add); + if (port_nop) { + port_no = *port_nop; + } + error = dpif->dpif_class->port_add(dpif, netdev, &port_no); if (!error) { - VLOG_DBG_RL(&dpmsg_rl, "%s: added %s as port %"PRIu16, + VLOG_DBG_RL(&dpmsg_rl, "%s: added %s as port %"PRIu32, dpif_name(dpif), netdev_name, port_no); } else { VLOG_WARN_RL(&error_rl, "%s: failed to add %s as port: %s", dpif_name(dpif), netdev_name, strerror(error)); - port_no = UINT16_MAX; + port_no = UINT32_MAX; } if (port_nop) { *port_nop = port_no; @@ -439,7 +474,7 @@ dpif_port_add(struct dpif *dpif, struct netdev *netdev, uint16_t *port_nop) /* Attempts to remove 'dpif''s port number 'port_no'. Returns 0 if successful, * otherwise a positive errno value. */ int -dpif_port_del(struct dpif *dpif, uint16_t port_no) +dpif_port_del(struct dpif *dpif, uint32_t port_no) { int error; @@ -447,7 +482,7 @@ dpif_port_del(struct dpif *dpif, uint16_t port_no) error = dpif->dpif_class->port_del(dpif, port_no); if (!error) { - VLOG_DBG_RL(&dpmsg_rl, "%s: port_del(%"PRIu16")", + VLOG_DBG_RL(&dpmsg_rl, "%s: port_del(%"PRIu32")", dpif_name(dpif), port_no); } else { log_operation(dpif, "port_del", error); @@ -476,6 +511,20 @@ dpif_port_destroy(struct dpif_port *dpif_port) free(dpif_port->type); } +/* Checks if port named 'devname' exists in 'dpif'. If so, returns + * true; otherwise, returns false. */ +bool +dpif_port_exists(const struct dpif *dpif, const char *devname) +{ + int error = dpif->dpif_class->port_query_by_name(dpif, devname, NULL); + if (error != 0 && error != ENOENT && error != ENODEV) { + VLOG_WARN_RL(&error_rl, "%s: failed to query port %s: %s", + dpif_name(dpif), devname, strerror(error)); + } + + return !error; +} + /* Looks up port number 'port_no' in 'dpif'. On success, returns 0 and * initializes '*port' appropriately; on failure, returns a positive errno * value. @@ -483,16 +532,16 @@ dpif_port_destroy(struct dpif_port *dpif_port) * The caller owns the data in 'port' and must free it with * dpif_port_destroy() when it is no longer needed. */ int -dpif_port_query_by_number(const struct dpif *dpif, uint16_t port_no, +dpif_port_query_by_number(const struct dpif *dpif, uint32_t port_no, struct dpif_port *port) { int error = dpif->dpif_class->port_query_by_number(dpif, port_no, port); if (!error) { - VLOG_DBG_RL(&dpmsg_rl, "%s: port %"PRIu16" is device %s", + VLOG_DBG_RL(&dpmsg_rl, "%s: port %"PRIu32" is device %s", dpif_name(dpif), port_no, port->name); } else { memset(port, 0, sizeof *port); - VLOG_WARN_RL(&error_rl, "%s: failed to query port %"PRIu16": %s", + VLOG_WARN_RL(&error_rl, "%s: failed to query port %"PRIu32": %s", dpif_name(dpif), port_no, strerror(error)); } return error; @@ -510,7 +559,7 @@ dpif_port_query_by_name(const struct dpif *dpif, const char *devname, { int error = dpif->dpif_class->port_query_by_name(dpif, devname, port); if (!error) { - VLOG_DBG_RL(&dpmsg_rl, "%s: device %s is on port %"PRIu16, + VLOG_DBG_RL(&dpmsg_rl, "%s: device %s is on port %"PRIu32, dpif_name(dpif), devname, port->port_no); } else { memset(port, 0, sizeof *port); @@ -539,13 +588,16 @@ dpif_get_max_ports(const struct dpif *dpif) * as the OVS_USERSPACE_ATTR_PID attribute's value, for use in flows whose * packets arrived on port 'port_no'. * + * A 'port_no' of UINT32_MAX is a special case: it returns a reserved PID, not + * allocated to any port, that the client may use for special purposes. + * * 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) +dpif_port_get_pid(const struct dpif *dpif, uint32_t port_no) { return (dpif->dpif_class->port_get_pid ? (dpif->dpif_class->port_get_pid)(dpif, port_no) @@ -557,7 +609,7 @@ dpif_port_get_pid(const struct dpif *dpif, uint16_t port_no) * result is null-terminated. On failure, returns a positive errno value and * makes 'name' the empty string. */ int -dpif_port_get_name(struct dpif *dpif, uint16_t port_no, +dpif_port_get_name(struct dpif *dpif, uint32_t port_no, char *name, size_t name_size) { struct dpif_port port; @@ -673,22 +725,15 @@ dpif_port_poll_wait(const struct dpif *dpif) /* Extracts the flow stats for a packet. The 'flow' and 'packet' * arguments must have been initialized through a call to flow_extract(). - */ + * 'used' is stored into stats->used. */ void -dpif_flow_stats_extract(const struct flow *flow, struct ofpbuf *packet, - struct dpif_flow_stats *stats) +dpif_flow_stats_extract(const struct flow *flow, const struct ofpbuf *packet, + long long int used, 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->tcp_flags = packet_get_tcp_flags(packet, flow); stats->n_bytes = packet->size; stats->n_packets = 1; + stats->used = used; } /* Appends a human-readable representation of 'stats' to 's'. */ @@ -702,7 +747,10 @@ dpif_flow_stats_format(const struct dpif_flow_stats *stats, struct ds *s) } else { ds_put_format(s, "never"); } - /* XXX tcp_flags? */ + if (stats->tcp_flags) { + ds_put_cstr(s, ", flags:"); + packet_format_tcp_flags(s, stats->tcp_flags); + } } /* Deletes all flows from 'dpif'. Returns 0 if successful, otherwise a @@ -822,6 +870,21 @@ dpif_flow_put(struct dpif *dpif, enum dpif_flow_put_flags flags, return dpif_flow_put__(dpif, &put); } +static int +dpif_flow_del__(struct dpif *dpif, struct dpif_flow_del *del) +{ + int error; + + COVERAGE_INC(dpif_flow_del); + + error = dpif->dpif_class->flow_del(dpif, del); + if (error && del->stats) { + memset(del->stats, 0, sizeof *del->stats); + } + log_flow_del_message(dpif, del, error); + return error; +} + /* 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 OVS_KEY_ATTR_* in the 'key_len' bytes starting at 'key'. @@ -833,19 +896,12 @@ 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); + struct dpif_flow_del del; - 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_message(dpif, error, "flow_del", key, key_len, - !error ? stats : NULL, NULL, 0); - } - return error; + del.key = key; + del.key_len = key_len; + del.stats = stats; + return dpif_flow_del__(dpif, &del); } /* Initializes 'dump' to begin dumping the flows in a dpif. @@ -960,7 +1016,7 @@ dpif_execute__(struct dpif *dpif, const struct dpif_execute *execute) * 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.) + * tunnel and in_port.) * * Returns 0 if successful, otherwise a positive errno value. */ int @@ -992,6 +1048,24 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops) if (dpif->dpif_class->operate) { dpif->dpif_class->operate(dpif, ops, n_ops); + + for (i = 0; i < n_ops; i++) { + struct dpif_op *op = ops[i]; + + switch (op->type) { + case DPIF_OP_FLOW_PUT: + log_flow_put_message(dpif, &op->u.flow_put, op->error); + break; + + case DPIF_OP_FLOW_DEL: + log_flow_del_message(dpif, &op->u.flow_del, op->error); + break; + + case DPIF_OP_EXECUTE: + log_execute_message(dpif, &op->u.execute, op->error); + break; + } + } return; } @@ -1003,6 +1077,10 @@ dpif_operate(struct dpif *dpif, struct dpif_op **ops, size_t n_ops) op->error = dpif_flow_put__(dpif, &op->u.flow_put); break; + case DPIF_OP_FLOW_DEL: + op->error = dpif_flow_del__(dpif, &op->u.flow_del); + break; + case DPIF_OP_EXECUTE: op->error = dpif_execute__(dpif, &op->u.execute); break; @@ -1041,21 +1119,20 @@ dpif_recv_set(struct dpif *dpif, bool enable) } /* Polls for an upcall from 'dpif'. If successful, stores the upcall into - * '*upcall'. Should only be called if dpif_recv_set() has been used to enable - * receiving packets on 'dpif'. + * '*upcall', using 'buf' for storage. Should only be called if + * dpif_recv_set() has been used to enable receiving packets on 'dpif'. * - * 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 + * 'upcall->packet' and 'upcall->key' point into data in the caller-provided + * 'buf', so their memory cannot be freed separately from 'buf'. (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 upcall is immediately available. */ int -dpif_recv(struct dpif *dpif, struct dpif_upcall *upcall) +dpif_recv(struct dpif *dpif, struct dpif_upcall *upcall, struct ofpbuf *buf) { - int error = dpif->dpif_class->recv(dpif, upcall); + int error = dpif->dpif_class->recv(dpif, upcall, buf); if (!error && !VLOG_DROP_DBG(&dpmsg_rl)) { struct ds flow; char *packet; @@ -1238,6 +1315,16 @@ log_flow_put_message(struct dpif *dpif, const struct dpif_flow_put *put, } } +static void +log_flow_del_message(struct dpif *dpif, const struct dpif_flow_del *del, + int error) +{ + if (should_log_flow_message(error)) { + log_flow_message(dpif, error, "flow_del", del->key, del->key_len, + !error ? del->stats : NULL, NULL, 0); + } +} + static void log_execute_message(struct dpif *dpif, const struct dpif_execute *execute, int error)