From 72865317a41d065fcc47a33fc68cdd2081cecb3d Mon Sep 17 00:00:00 2001 From: Ben Pfaff Date: Fri, 19 Jun 2009 14:09:39 -0700 Subject: [PATCH] New implementation of userspace datapath, based on the netdev library. --- lib/automake.mk | 1 + lib/dpif-netdev.c | 1322 ++++++++++++++++++++++++++++++++++++++++++ lib/dpif-provider.h | 1 + lib/dpif.c | 3 +- lib/hmap.h | 8 + lib/netdev.h | 3 +- lib/vlog-modules.def | 1 + vswitchd/bridge.c | 20 +- 8 files changed, 1353 insertions(+), 6 deletions(-) create mode 100644 lib/dpif-netdev.c diff --git a/lib/automake.mk b/lib/automake.mk index d2980d38f..80d85c330 100644 --- a/lib/automake.mk +++ b/lib/automake.mk @@ -33,6 +33,7 @@ lib_libopenvswitch_a_SOURCES = \ lib/dhparams.h \ lib/dirs.h \ lib/dpif-linux.c \ + lib/dpif-netdev.c \ lib/dpif-provider.h \ lib/dpif.c \ lib/dpif.h \ diff --git a/lib/dpif-netdev.c b/lib/dpif-netdev.c new file mode 100644 index 000000000..285693ab2 --- /dev/null +++ b/lib/dpif-netdev.c @@ -0,0 +1,1322 @@ +/* + * Copyright (c) 2009 Nicira Networks. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include "dpif.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "csum.h" +#include "dpif-provider.h" +#include "flow.h" +#include "hmap.h" +#include "list.h" +#include "netdev.h" +#include "odp-util.h" +#include "ofp-print.h" +#include "ofpbuf.h" +#include "packets.h" +#include "poll-loop.h" +#include "queue.h" +#include "timeval.h" +#include "util.h" + +#include "vlog.h" +#define THIS_MODULE VLM_dpif_netdev + +/* Configuration parameters. */ +enum { N_QUEUES = 2 }; /* Number of queues for dpif_recv(). */ +enum { MAX_QUEUE_LEN = 100 }; /* Maximum number of packets per queue. */ +enum { N_GROUPS = 16 }; /* Number of port groups. */ +enum { MAX_PORTS = 256 }; /* Maximum number of ports. */ +enum { MAX_FLOWS = 65536 }; /* Maximum number of flows in flow table. */ + +/* Enough headroom to add a vlan tag, plus an extra 2 bytes to allow IP + * headers to be aligned on a 4-byte boundary. */ +enum { DP_NETDEV_HEADROOM = 2 + VLAN_HEADER_LEN }; + +/* Datapath based on the network device interface from netdev.h. */ +struct dp_netdev { + struct list node; + int dp_idx; + int open_cnt; + bool deleted; + + bool drop_frags; /* Drop all IP fragments, if true. */ + struct ovs_queue queues[N_QUEUES]; /* Messages queued for dpif_recv(). */ + struct hmap flow_table; /* Flow table. */ + struct odp_port_group groups[N_GROUPS]; + + /* Statistics. */ + long long int n_frags; /* Number of dropped IP fragments. */ + long long int n_hit; /* Number of flow table matches. */ + long long int n_missed; /* Number of flow table misses. */ + long long int n_lost; /* Number of misses not passed to client. */ + + /* Ports. */ + int n_ports; + struct dp_netdev_port *ports[MAX_PORTS]; + struct list port_list; + unsigned int serial; +}; + +/* A port in a netdev-based datapath. */ +struct dp_netdev_port { + int port_no; /* Index into dp_netdev's 'ports'. */ + struct list node; /* Element in dp_netdev's 'port_list'. */ + struct netdev *netdev; + bool internal; /* Internal port (as ODP_PORT_INTERNAL)? */ +}; + +/* A flow in dp_netdev's 'flow_table'. */ +struct dp_netdev_flow { + struct hmap_node node; /* Element in dp_netdev's 'flow_table'. */ + flow_t key; + + /* Statistics. */ + struct timeval used; /* Last used time, in milliseconds. */ + long long int packet_count; /* Number of packets matched. */ + long long int byte_count; /* Number of bytes matched. */ + uint8_t ip_tos; /* IP TOS value. */ + uint16_t tcp_ctl; /* Bitwise-OR of seen tcp_ctl values. */ + + /* Actions. */ + union odp_action *actions; + unsigned int n_actions; +}; + +/* Interface to netdev-based datapath. */ +struct dpif_netdev { + struct dpif dpif; + struct dp_netdev *dp; + int listen_mask; + unsigned int dp_serial; +}; + +/* All netdev-based datapaths. */ +static struct dp_netdev *dp_netdevs[256]; +struct list dp_netdev_list = LIST_INITIALIZER(&dp_netdev_list); +enum { N_DP_NETDEVS = ARRAY_SIZE(dp_netdevs) }; + +/* Maximum port MTU seen so far. */ +static int max_mtu = ETH_PAYLOAD_MAX; + +static int get_port_by_number(struct dp_netdev *, uint16_t port_no, + struct dp_netdev_port **portp); +static int get_port_by_name(struct dp_netdev *, const char *devname, + struct dp_netdev_port **portp); +static void dp_netdev_free(struct dp_netdev *); +static void dp_netdev_flow_flush(struct dp_netdev *); +static int do_add_port(struct dp_netdev *, const char *devname, uint16_t flags, + uint16_t port_no); +static int do_del_port(struct dp_netdev *, uint16_t port_no); +static int dp_netdev_output_control(struct dp_netdev *, const struct ofpbuf *, + int queue_no, int port_no, uint32_t arg); +static int dp_netdev_execute_actions(struct dp_netdev *, + struct ofpbuf *, flow_t *, + const union odp_action *, int n); + +static struct dpif_netdev * +dpif_netdev_cast(const struct dpif *dpif) +{ + dpif_assert_class(dpif, &dpif_netdev_class); + return CONTAINER_OF(dpif, struct dpif_netdev, dpif); +} + +static struct dp_netdev * +get_dp_netdev(const struct dpif *dpif) +{ + return dpif_netdev_cast(dpif)->dp; +} + +static int +name_to_dp_idx(const char *name) +{ + if (!strncmp(name, "dp", 2) && isdigit(name[2])) { + int dp_idx = atoi(name + 2); + if (dp_idx >= 0 && dp_idx < N_DP_NETDEVS) { + return dp_idx; + } + } + return -1; +} + +static struct dp_netdev * +find_dp_netdev(const char *name) +{ + int dp_idx; + size_t i; + + dp_idx = name_to_dp_idx(name); + if (dp_idx >= 0) { + return dp_netdevs[dp_idx]; + } + + for (i = 0; i < N_DP_NETDEVS; i++) { + struct dp_netdev *dp = dp_netdevs[i]; + if (dp) { + struct dp_netdev_port *port; + if (!get_port_by_name(dp, name, &port)) { + return dp; + } + } + } + return NULL; +} + +static struct dpif * +create_dpif_netdev(struct dp_netdev *dp) +{ + struct dpif_netdev *dpif; + char *dpname; + + dp->open_cnt++; + + dpname = xasprintf("netdev:dp%d", dp->dp_idx); + dpif = xmalloc(sizeof *dpif); + dpif_init(&dpif->dpif, &dpif_netdev_class, dpname, dp->dp_idx, dp->dp_idx); + dpif->dp = dp; + dpif->listen_mask = 0; + dpif->dp_serial = dp->serial; + free(dpname); + + return &dpif->dpif; +} + +static int +create_dp_netdev(const char *name, int dp_idx, struct dpif **dpifp) +{ + struct dp_netdev *dp; + int error; + int i; + + if (dp_netdevs[dp_idx]) { + return EBUSY; + } + + /* Create datapath. */ + dp_netdevs[dp_idx] = dp = xcalloc(1, sizeof *dp); + list_push_back(&dp_netdev_list, &dp->node); + dp->dp_idx = dp_idx; + dp->open_cnt = 0; + dp->drop_frags = false; + for (i = 0; i < N_QUEUES; i++) { + queue_init(&dp->queues[i]); + } + hmap_init(&dp->flow_table); + for (i = 0; i < N_GROUPS; i++) { + dp->groups[i].ports = NULL; + dp->groups[i].n_ports = 0; + dp->groups[i].group = i; + } + list_init(&dp->port_list); + error = do_add_port(dp, name, ODP_PORT_INTERNAL, ODPP_LOCAL); + if (error) { + dp_netdev_free(dp); + return error; + } + + *dpifp = create_dpif_netdev(dp); + return 0; +} + +static int +dpif_netdev_open(const char *name UNUSED, char *suffix, bool create, + struct dpif **dpifp) +{ + if (create) { + if (find_dp_netdev(suffix)) { + return EEXIST; + } else { + int dp_idx = name_to_dp_idx(suffix); + if (dp_idx >= 0) { + return create_dp_netdev(suffix, dp_idx, dpifp); + } else { + /* Scan for unused dp_idx number. */ + for (dp_idx = 0; dp_idx < N_DP_NETDEVS; dp_idx++) { + int error = create_dp_netdev(suffix, dp_idx, dpifp); + if (error != EBUSY) { + return error; + } + } + + /* All datapath numbers in use. */ + return ENOBUFS; + } + } + } else { + struct dp_netdev *dp = find_dp_netdev(suffix); + if (dp) { + *dpifp = create_dpif_netdev(dp); + return 0; + } else { + return ENODEV; + } + } +} + +static void +dp_netdev_free(struct dp_netdev *dp) +{ + int i; + + dp_netdev_flow_flush(dp); + while (dp->n_ports > 0) { + struct dp_netdev_port *port = CONTAINER_OF( + dp->port_list.next, struct dp_netdev_port, node); + do_del_port(dp, port->port_no); + } + for (i = 0; i < N_QUEUES; i++) { + queue_destroy(&dp->queues[i]); + } + hmap_destroy(&dp->flow_table); + for (i = 0; i < N_GROUPS; i++) { + free(dp->groups[i].ports); + } + dp_netdevs[dp->dp_idx] = NULL; + list_remove(&dp->node); + free(dp); +} + +static void +dpif_netdev_close(struct dpif *dpif) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + assert(dp->open_cnt > 0); + if (--dp->open_cnt == 0 && dp->deleted) { + dp_netdev_free(dp); + } + free(dpif); +} + +static int +dpif_netdev_delete(struct dpif *dpif) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + dp->deleted = true; + return 0; +} + +static int +dpif_netdev_get_stats(const struct dpif *dpif, struct odp_stats *stats) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + memset(stats, 0, sizeof *stats); + stats->n_flows = hmap_count(&dp->flow_table); + stats->cur_capacity = hmap_capacity(&dp->flow_table); + stats->max_capacity = MAX_FLOWS; + stats->n_ports = dp->n_ports; + stats->max_ports = MAX_PORTS; + stats->max_groups = N_GROUPS; + stats->n_frags = dp->n_frags; + stats->n_hit = dp->n_hit; + stats->n_missed = dp->n_missed; + stats->n_lost = dp->n_lost; + stats->max_miss_queue = MAX_QUEUE_LEN; + stats->max_action_queue = MAX_QUEUE_LEN; + return 0; +} + +static int +dpif_netdev_get_drop_frags(const struct dpif *dpif, bool *drop_fragsp) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + *drop_fragsp = dp->drop_frags; + return 0; +} + +static int +dpif_netdev_set_drop_frags(struct dpif *dpif, bool drop_frags) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + dp->drop_frags = drop_frags; + return 0; +} + +static int +do_add_port(struct dp_netdev *dp, const char *devname, uint16_t flags, + uint16_t port_no) +{ + bool internal = (flags & ODP_PORT_INTERNAL) != 0; + struct dp_netdev_port *port; + struct netdev *netdev; + int mtu; + int error; + + /* XXX reject devices already in some dp_netdev. */ + + /* Open and validate network device. */ + if (!internal) { + error = netdev_open(devname, NETDEV_ETH_TYPE_ANY, &netdev); + } else { + error = netdev_open_tap(devname, &netdev); + } + if (error) { + return error; + } + /* XXX reject loopback devices */ + /* XXX reject non-Ethernet devices */ + + error = netdev_turn_flags_on(netdev, NETDEV_PROMISC, false); + if (error) { + netdev_close(netdev); + return error; + } + + port = xmalloc(sizeof *port); + port->port_no = port_no; + port->netdev = netdev; + port->internal = internal; + + mtu = netdev_get_mtu(netdev); + if (mtu > max_mtu) { + max_mtu = mtu; + } + + list_push_back(&dp->port_list, &port->node); + dp->ports[port_no] = port; + dp->n_ports++; + dp->serial++; + + return 0; +} + +static int +dpif_netdev_port_add(struct dpif *dpif, const char *devname, uint16_t flags, + uint16_t *port_nop) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + int port_no; + + for (port_no = 0; port_no < MAX_PORTS; port_no++) { + if (!dp->ports[port_no]) { + *port_nop = port_no; + return do_add_port(dp, devname, flags, port_no); + } + } + return EXFULL; +} + +static int +dpif_netdev_port_del(struct dpif *dpif, uint16_t port_no) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + return port_no == ODPP_LOCAL ? EINVAL : do_del_port(dp, port_no); +} + +static bool +is_valid_port_number(uint16_t port_no) +{ + return port_no < MAX_PORTS; +} + +static int +get_port_by_number(struct dp_netdev *dp, + uint16_t port_no, struct dp_netdev_port **portp) +{ + if (!is_valid_port_number(port_no)) { + *portp = NULL; + return EINVAL; + } else { + *portp = dp->ports[port_no]; + return *portp ? 0 : ENOENT; + } +} + +static int +get_port_by_name(struct dp_netdev *dp, + const char *devname, struct dp_netdev_port **portp) +{ + struct dp_netdev_port *port; + + LIST_FOR_EACH (port, struct dp_netdev_port, node, &dp->port_list) { + if (!strcmp(netdev_get_name(port->netdev), devname)) { + *portp = port; + return 0; + } + } + return ENOENT; +} + +static int +do_del_port(struct dp_netdev *dp, uint16_t port_no) +{ + struct dp_netdev_port *port; + int error; + + error = get_port_by_number(dp, port_no, &port); + if (error) { + return error; + } + + list_remove(&port->node); + dp->ports[port->port_no] = NULL; + dp->n_ports--; + dp->serial++; + + netdev_close(port->netdev); + free(port); + + return 0; +} + +static void +answer_port_query(const struct dp_netdev_port *port, struct odp_port *odp_port) +{ + memset(odp_port, 0, sizeof *odp_port); + ovs_strlcpy(odp_port->devname, netdev_get_name(port->netdev), + sizeof odp_port->devname); + odp_port->port = port->port_no; + odp_port->flags = port->internal ? ODP_PORT_INTERNAL : 0; +} + +static int +dpif_netdev_port_query_by_number(const struct dpif *dpif, uint16_t port_no, + struct odp_port *odp_port) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_port *port; + int error; + + error = get_port_by_number(dp, port_no, &port); + if (!error) { + answer_port_query(port, odp_port); + } + return error; +} + +static int +dpif_netdev_port_query_by_name(const struct dpif *dpif, const char *devname, + struct odp_port *odp_port) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_port *port; + int error; + + error = get_port_by_name(dp, devname, &port); + if (!error) { + answer_port_query(port, odp_port); + } + return error; +} + +static void +dp_netdev_free_flow(struct dp_netdev *dp, struct dp_netdev_flow *flow) +{ + hmap_remove(&dp->flow_table, &flow->node); + free(flow->actions); + free(flow); +} + +static void +dp_netdev_flow_flush(struct dp_netdev *dp) +{ + struct dp_netdev_flow *flow, *next; + + HMAP_FOR_EACH_SAFE (flow, next, struct dp_netdev_flow, node, + &dp->flow_table) { + dp_netdev_free_flow(dp, flow); + } +} + +static int +dpif_netdev_flow_flush(struct dpif *dpif) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + dp_netdev_flow_flush(dp); + return 0; +} + +static int +dpif_netdev_port_list(const struct dpif *dpif, struct odp_port *ports, int n) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_port *port; + int i; + + i = 0; + LIST_FOR_EACH (port, struct dp_netdev_port, node, &dp->port_list) { + struct odp_port *odp_port = &ports[i]; + if (i >= n) { + break; + } + answer_port_query(port, odp_port); + i++; + } + return dp->n_ports; +} + +static int +dpif_netdev_port_poll(const struct dpif *dpif_, char **devnamep UNUSED) +{ + struct dpif_netdev *dpif = dpif_netdev_cast(dpif_); + if (dpif->dp_serial != dpif->dp->serial) { + dpif->dp_serial = dpif->dp->serial; + return ENOBUFS; + } else { + return EAGAIN; + } +} + +static void +dpif_netdev_port_poll_wait(const struct dpif *dpif_) +{ + struct dpif_netdev *dpif = dpif_netdev_cast(dpif_); + if (dpif->dp_serial != dpif->dp->serial) { + poll_immediate_wake(); + } +} + +static int +get_port_group(const struct dpif *dpif, int group_no, + struct odp_port_group **groupp) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + + if (group_no >= 0 && group_no < N_GROUPS) { + *groupp = &dp->groups[group_no]; + return 0; + } else { + *groupp = NULL; + return EINVAL; + } +} + +static int +dpif_netdev_port_group_get(const struct dpif *dpif, int group_no, + uint16_t ports[], int n) +{ + struct odp_port_group *group; + int error; + + if (n < 0) { + return -EINVAL; + } + + error = get_port_group(dpif, group_no, &group); + if (!error) { + memcpy(ports, group->ports, MIN(n, group->n_ports) * sizeof *ports); + return group->n_ports; + } else { + return -error; + } +} + +static int +dpif_netdev_port_group_set(struct dpif *dpif, int group_no, + const uint16_t ports[], int n) +{ + struct odp_port_group *group; + int error; + + if (n < 0 || n > MAX_PORTS) { + return EINVAL; + } + + error = get_port_group(dpif, group_no, &group); + if (!error) { + free(group->ports); + group->ports = xmemdup(ports, n * sizeof *group->ports); + group->n_ports = n; + group->group = group_no; + } + return error; +} + +static struct dp_netdev_flow * +dp_netdev_lookup_flow(const struct dp_netdev *dp, const flow_t *key) +{ + struct dp_netdev_flow *flow; + + assert(key->reserved == 0); + HMAP_FOR_EACH_WITH_HASH (flow, struct dp_netdev_flow, node, + flow_hash(key, 0), &dp->flow_table) { + if (flow_equal(&flow->key, key)) { + return flow; + } + } + return NULL; +} + +static void +answer_flow_query(const struct dp_netdev_flow *flow, + struct odp_flow *odp_flow) +{ + if (flow) { + odp_flow->key = flow->key; + odp_flow->stats.n_packets = flow->packet_count; + odp_flow->stats.n_bytes = flow->byte_count; + odp_flow->stats.used_sec = flow->used.tv_sec; + odp_flow->stats.used_nsec = flow->used.tv_usec * 1000; + odp_flow->stats.tcp_flags = TCP_FLAGS(flow->tcp_ctl); + odp_flow->stats.ip_tos = flow->ip_tos; + odp_flow->stats.error = 0; + if (odp_flow->n_actions > 0) { + unsigned int n = MIN(odp_flow->n_actions, flow->n_actions); + memcpy(odp_flow->actions, flow->actions, + n * sizeof *odp_flow->actions); + odp_flow->n_actions = flow->n_actions; + } + } else { + odp_flow->stats.error = ENOENT; + } +} + +static int +dpif_netdev_flow_get(const struct dpif *dpif, struct odp_flow flows[], int n) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + int i; + + for (i = 0; i < n; i++) { + struct odp_flow *odp_flow = &flows[i]; + answer_flow_query(dp_netdev_lookup_flow(dp, &odp_flow->key), odp_flow); + } + return 0; +} + +static int +dpif_netdev_validate_actions(const union odp_action *actions, int n_actions, + bool *mutates) +{ + unsigned int i; + + *mutates = false; + for (i = 0; i < n_actions; i++) { + const union odp_action *a = &actions[i]; + switch (a->type) { + case ODPAT_OUTPUT: + if (a->output.port >= MAX_PORTS) { + return EINVAL; + } + break; + + case ODPAT_OUTPUT_GROUP: + *mutates = true; + if (a->output_group.group >= N_GROUPS) { + return EINVAL; + } + break; + + case ODPAT_CONTROLLER: + break; + + case ODPAT_SET_VLAN_VID: + *mutates = true; + if (a->vlan_vid.vlan_vid & htons(~VLAN_VID_MASK)) { + return EINVAL; + } + break; + + case ODPAT_SET_VLAN_PCP: + *mutates = true; + if (a->vlan_pcp.vlan_pcp & ~VLAN_PCP_MASK) { + return EINVAL; + } + break; + + case ODPAT_STRIP_VLAN: + case ODPAT_SET_DL_SRC: + case ODPAT_SET_DL_DST: + case ODPAT_SET_NW_SRC: + case ODPAT_SET_NW_DST: + case ODPAT_SET_TP_SRC: + case ODPAT_SET_TP_DST: + *mutates = true; + break; + + default: + return EOPNOTSUPP; + } + } + return 0; +} + +static int +set_flow_actions(struct dp_netdev_flow *flow, struct odp_flow *odp_flow) +{ + size_t n_bytes; + bool mutates; + int error; + + if (odp_flow->n_actions >= 4096 / sizeof *odp_flow->actions) { + return EINVAL; + } + error = dpif_netdev_validate_actions(odp_flow->actions, + odp_flow->n_actions, &mutates); + if (error) { + return error; + } + + n_bytes = odp_flow->n_actions * sizeof *flow->actions; + flow->actions = xrealloc(flow->actions, n_bytes); + flow->n_actions = odp_flow->n_actions; + memcpy(flow->actions, odp_flow->actions, n_bytes); + return 0; +} + +static int +add_flow(struct dpif *dpif, struct odp_flow *odp_flow) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_flow *flow; + int error; + + flow = xcalloc(1, sizeof *flow); + flow->key = odp_flow->key; + flow->key.reserved = 0; + + error = set_flow_actions(flow, odp_flow); + if (error) { + free(flow); + return error; + } + + hmap_insert(&dp->flow_table, &flow->node, flow_hash(&flow->key, 0)); + return 0; +} + +static void +clear_stats(struct dp_netdev_flow *flow) +{ + flow->used.tv_sec = 0; + flow->used.tv_usec = 0; + flow->packet_count = 0; + flow->byte_count = 0; + flow->ip_tos = 0; + flow->tcp_ctl = 0; +} + +static int +dpif_netdev_flow_put(struct dpif *dpif, struct odp_flow_put *put) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_flow *flow; + + flow = dp_netdev_lookup_flow(dp, &put->flow.key); + if (!flow) { + if (put->flags & ODPPF_CREATE) { + if (hmap_count(&dp->flow_table) < MAX_FLOWS) { + return add_flow(dpif, &put->flow); + } else { + return EXFULL; + } + } else { + return ENOENT; + } + } else { + if (put->flags & ODPPF_MODIFY) { + int error = set_flow_actions(flow, &put->flow); + if (!error && put->flags & ODPPF_ZERO_STATS) { + clear_stats(flow); + } + return error; + } else { + return EEXIST; + } + } +} + + +static int +dpif_netdev_flow_del(struct dpif *dpif, struct odp_flow *odp_flow) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_flow *flow; + + flow = dp_netdev_lookup_flow(dp, &odp_flow->key); + if (flow) { + answer_flow_query(flow, odp_flow); + dp_netdev_free_flow(dp, flow); + return 0; + } else { + return ENOENT; + } +} + +static int +dpif_netdev_flow_list(const struct dpif *dpif, struct odp_flow flows[], int n) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct dp_netdev_flow *flow; + int i; + + i = 0; + HMAP_FOR_EACH (flow, struct dp_netdev_flow, node, &dp->flow_table) { + if (i >= n) { + break; + } + answer_flow_query(flow, &flows[i++]); + } + return hmap_count(&dp->flow_table); +} + +static int +dpif_netdev_execute(struct dpif *dpif, uint16_t in_port, + const union odp_action actions[], int n_actions, + const struct ofpbuf *packet) +{ + struct dp_netdev *dp = get_dp_netdev(dpif); + struct ofpbuf copy; + bool mutates; + flow_t flow; + int error; + + if (packet->size < ETH_HLEN || packet->size > UINT16_MAX) { + return EINVAL; + } + + error = dpif_netdev_validate_actions(actions, n_actions, &mutates); + if (error) { + return error; + } + + if (mutates) { + /* We need a deep copy of 'packet' since we're going to modify its + * data. */ + ofpbuf_init(©, DP_NETDEV_HEADROOM + packet->size); + copy.data = (char*)copy.base + DP_NETDEV_HEADROOM; + ofpbuf_put(©, packet->data, packet->size); + } else { + /* We still need a shallow copy of 'packet', even though we won't + * modify its data, because flow_extract() modifies packet->l2, etc. + * We could probably get away with modifying those but it's more polite + * if we don't. */ + copy = *packet; + } + flow_extract(©, in_port, &flow); + error = dp_netdev_execute_actions(dp, ©, &flow, actions, n_actions); + if (mutates) { + ofpbuf_uninit(©); + } + return error; +} + +static int +dpif_netdev_recv_get_mask(const struct dpif *dpif, int *listen_mask) +{ + struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif); + *listen_mask = dpif_netdev->listen_mask; + return 0; +} + +static int +dpif_netdev_recv_set_mask(struct dpif *dpif, int listen_mask) +{ + struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif); + if (!(listen_mask & ~ODPL_ALL)) { + dpif_netdev->listen_mask = listen_mask; + return 0; + } else { + return EINVAL; + } +} + +static struct ovs_queue * +find_nonempty_queue(struct dpif *dpif) +{ + struct dpif_netdev *dpif_netdev = dpif_netdev_cast(dpif); + struct dp_netdev *dp = get_dp_netdev(dpif); + int mask = dpif_netdev->listen_mask; + int i; + + for (i = 0; i < N_QUEUES; i++) { + struct ovs_queue *q = &dp->queues[i]; + if (q->n && mask & (1u << i)) { + return q; + } + } + return NULL; +} + +static int +dpif_netdev_recv(struct dpif *dpif, struct ofpbuf **bufp) +{ + struct ovs_queue *q = find_nonempty_queue(dpif); + if (q) { + *bufp = queue_pop_head(q); + return 0; + } else { + return EAGAIN; + } +} + +static void +dpif_netdev_recv_wait(struct dpif *dpif) +{ + struct ovs_queue *q = find_nonempty_queue(dpif); + if (q) { + poll_immediate_wake(); + } else { + /* No messages ready to be received, and dp_wait() will ensure that we + * wake up to queue new messages, so there is nothing to do. */ + } +} + +static void +dp_netdev_flow_used(struct dp_netdev_flow *flow, const flow_t *key, + const struct ofpbuf *packet) +{ + time_timeval(&flow->used); + flow->packet_count++; + flow->byte_count += packet->size; + if (key->dl_type == htons(ETH_P_IP)) { + struct ip_header *nh = packet->l3; + flow->ip_tos = nh->ip_tos; + + if (key->nw_proto == IPPROTO_TCP) { + struct tcp_header *th = packet->l4; + flow->tcp_ctl |= th->tcp_ctl; + } + } +} + +static void +dp_netdev_port_input(struct dp_netdev *dp, struct dp_netdev_port *port, + struct ofpbuf *packet) +{ + struct dp_netdev_flow *flow; + flow_t key; + + if (flow_extract(packet, port->port_no, &key) && dp->drop_frags) { + dp->n_frags++; + return; + } + + flow = dp_netdev_lookup_flow(dp, &key); + if (flow) { + dp_netdev_flow_used(flow, &key, packet); + dp_netdev_execute_actions(dp, packet, &key, + flow->actions, flow->n_actions); + dp->n_hit++; + } else { + dp->n_missed++; + dp_netdev_output_control(dp, packet, _ODPL_MISS_NR, port->port_no, 0); + } +} + +static void +dp_netdev_run(void) +{ + struct ofpbuf packet; + struct dp_netdev *dp; + + ofpbuf_init(&packet, DP_NETDEV_HEADROOM + max_mtu); + LIST_FOR_EACH (dp, struct dp_netdev, node, &dp_netdev_list) { + struct dp_netdev_port *port; + + LIST_FOR_EACH (port, struct dp_netdev_port, node, &dp->port_list) { + int error; + + /* Reset packet contents. */ + packet.data = (char*)packet.base + DP_NETDEV_HEADROOM; + packet.size = 0; + + error = netdev_recv(port->netdev, &packet); + if (!error) { + dp_netdev_port_input(dp, port, &packet); + } else if (error != EAGAIN) { + struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); + VLOG_ERR_RL(&rl, "error receiving data from %s: %s", + netdev_get_name(port->netdev), strerror(error)); + } + } + } + ofpbuf_uninit(&packet); +} + +static void +dp_netdev_wait(void) +{ + struct dp_netdev *dp; + + LIST_FOR_EACH (dp, struct dp_netdev, node, &dp_netdev_list) { + struct dp_netdev_port *port; + LIST_FOR_EACH (port, struct dp_netdev_port, node, &dp->port_list) { + netdev_recv_wait(port->netdev); + } + } +} + +static void +dp_netdev_modify_vlan_tci(struct ofpbuf *packet, flow_t *key, + uint16_t tci, uint16_t mask) +{ + struct vlan_eth_header *veh; + + if (key->dl_vlan != htons(ODP_VLAN_NONE)) { + /* Modify 'mask' bits, but maintain other TCI bits. */ + veh = packet->l2; + veh->veth_tci &= ~htons(mask); + veh->veth_tci |= htons(tci); + } else { + /* Insert new 802.1Q header. */ + struct eth_header *eh = packet->l2; + struct vlan_eth_header tmp; + memcpy(tmp.veth_dst, eh->eth_dst, ETH_ADDR_LEN); + memcpy(tmp.veth_src, eh->eth_src, ETH_ADDR_LEN); + tmp.veth_type = htons(ETH_TYPE_VLAN); + tmp.veth_tci = htons(tci); + tmp.veth_next_type = eh->eth_type; + + veh = ofpbuf_push_uninit(packet, VLAN_HEADER_LEN); + memcpy(veh, &tmp, sizeof tmp); + packet->l2 = (char*)packet->l2 - VLAN_HEADER_LEN; + } + + key->dl_vlan = veh->veth_tci & htons(VLAN_VID_MASK); +} + +static void +dp_netdev_strip_vlan(struct ofpbuf *packet, flow_t *key) +{ + struct vlan_eth_header *veh = packet->l2; + if (veh->veth_type == htons(ETH_TYPE_VLAN)) { + struct eth_header tmp; + + memcpy(tmp.eth_dst, veh->veth_dst, ETH_ADDR_LEN); + memcpy(tmp.eth_src, veh->veth_src, ETH_ADDR_LEN); + tmp.eth_type = veh->veth_next_type; + + packet->size -= VLAN_HEADER_LEN; + packet->data = (char*)packet->data + VLAN_HEADER_LEN; + packet->l2 = (char*)packet->l2 + VLAN_HEADER_LEN; + memcpy(packet->data, &tmp, sizeof tmp); + + key->dl_vlan = htons(ODP_VLAN_NONE); + } +} + +static void +dp_netdev_set_dl_src(struct ofpbuf *packet, + const uint8_t dl_addr[ETH_ADDR_LEN]) +{ + struct eth_header *eh = packet->l2; + memcpy(eh->eth_src, dl_addr, sizeof eh->eth_src); +} + +static void +dp_netdev_set_dl_dst(struct ofpbuf *packet, + const uint8_t dl_addr[ETH_ADDR_LEN]) +{ + struct eth_header *eh = packet->l2; + memcpy(eh->eth_dst, dl_addr, sizeof eh->eth_dst); +} + +static void +dp_netdev_set_nw_addr(struct ofpbuf *packet, flow_t *key, + const struct odp_action_nw_addr *a) +{ + if (key->dl_type == htons(ETH_TYPE_IP)) { + struct ip_header *nh = packet->l3; + uint32_t *field; + + field = a->type == ODPAT_SET_NW_SRC ? &nh->ip_src : &nh->ip_dst; + if (key->nw_proto == IP_TYPE_TCP) { + struct tcp_header *th = packet->l4; + th->tcp_csum = recalc_csum32(th->tcp_csum, *field, a->nw_addr); + } else if (key->nw_proto == IP_TYPE_UDP) { + struct udp_header *uh = packet->l4; + if (uh->udp_csum) { + uh->udp_csum = recalc_csum32(uh->udp_csum, *field, a->nw_addr); + if (!uh->udp_csum) { + uh->udp_csum = 0xffff; + } + } + } + nh->ip_csum = recalc_csum32(nh->ip_csum, *field, a->nw_addr); + *field = a->nw_addr; + } +} + +static void +dp_netdev_set_tp_port(struct ofpbuf *packet, flow_t *key, + const struct odp_action_tp_port *a) +{ + if (key->dl_type == htons(ETH_P_IP)) { + uint16_t *field; + if (key->nw_proto == IPPROTO_TCP) { + struct tcp_header *th = packet->l4; + field = a->type == ODPAT_SET_TP_SRC ? &th->tcp_src : &th->tcp_dst; + th->tcp_csum = recalc_csum16(th->tcp_csum, *field, a->tp_port); + *field = a->tp_port; + } else if (key->nw_proto == IPPROTO_UDP) { + struct udp_header *uh = packet->l4; + field = a->type == ODPAT_SET_TP_SRC ? &uh->udp_src : &uh->udp_dst; + uh->udp_csum = recalc_csum16(uh->udp_csum, *field, a->tp_port); + *field = a->tp_port; + } + } +} + +static void +dp_netdev_output_port(struct dp_netdev *dp, struct ofpbuf *packet, + uint16_t out_port) +{ + struct dp_netdev_port *p = dp->ports[out_port]; + if (p) { + netdev_send(p->netdev, packet); + } +} + +static void +dp_netdev_output_group(struct dp_netdev *dp, uint16_t group, uint16_t in_port, + struct ofpbuf *packet) +{ + struct odp_port_group *g = &dp->groups[group]; + int i; + + for (i = 0; i < g->n_ports; i++) { + uint16_t out_port = g->ports[i]; + if (out_port != in_port) { + dp_netdev_output_port(dp, packet, out_port); + } + } +} + +static int +dp_netdev_output_control(struct dp_netdev *dp, const struct ofpbuf *packet, + int queue_no, int port_no, uint32_t arg) +{ + struct ovs_queue *q = &dp->queues[queue_no]; + struct odp_msg *header; + struct ofpbuf *msg; + size_t msg_size; + + if (q->n >= MAX_QUEUE_LEN) { + dp->n_lost++; + return ENOBUFS; + } + + msg_size = sizeof *header + packet->size; + msg = ofpbuf_new(msg_size); + header = ofpbuf_put_uninit(msg, sizeof *header); + header->type = queue_no; + header->length = msg_size; + header->port = port_no; + header->arg = arg; + ofpbuf_put(msg, packet->data, packet->size); + queue_push_tail(q, msg); + + return 0; +} + +static int +dp_netdev_execute_actions(struct dp_netdev *dp, + struct ofpbuf *packet, flow_t *key, + const union odp_action *actions, int n_actions) +{ + int i; + for (i = 0; i < n_actions; i++) { + const union odp_action *a = &actions[i]; + + switch (a->type) { + case ODPAT_OUTPUT: + dp_netdev_output_port(dp, packet, a->output.port); + break; + + case ODPAT_OUTPUT_GROUP: + dp_netdev_output_group(dp, a->output_group.group, key->in_port, + packet); + break; + + case ODPAT_CONTROLLER: + dp_netdev_output_control(dp, packet, _ODPL_ACTION_NR, + key->in_port, a->controller.arg); + break; + + case ODPAT_SET_VLAN_VID: + dp_netdev_modify_vlan_tci(packet, key, ntohs(a->vlan_vid.vlan_vid), + VLAN_VID_MASK); + break; + + case ODPAT_SET_VLAN_PCP: + dp_netdev_modify_vlan_tci(packet, key, a->vlan_pcp.vlan_pcp << 13, + VLAN_PCP_MASK); + break; + + case ODPAT_STRIP_VLAN: + dp_netdev_strip_vlan(packet, key); + break; + + case ODPAT_SET_DL_SRC: + dp_netdev_set_dl_src(packet, a->dl_addr.dl_addr); + break; + + case ODPAT_SET_DL_DST: + dp_netdev_set_dl_dst(packet, a->dl_addr.dl_addr); + break; + + case ODPAT_SET_NW_SRC: + case ODPAT_SET_NW_DST: + dp_netdev_set_nw_addr(packet, key, &a->nw_addr); + break; + + case ODPAT_SET_TP_SRC: + case ODPAT_SET_TP_DST: + dp_netdev_set_tp_port(packet, key, &a->tp_port); + break; + } + } + return 0; +} + +const struct dpif_class dpif_netdev_class = { + "netdev", + "netdev", + dp_netdev_run, + dp_netdev_wait, + dpif_netdev_open, + dpif_netdev_close, + dpif_netdev_delete, + dpif_netdev_get_stats, + dpif_netdev_get_drop_frags, + dpif_netdev_set_drop_frags, + dpif_netdev_port_add, + dpif_netdev_port_del, + dpif_netdev_port_query_by_number, + dpif_netdev_port_query_by_name, + dpif_netdev_port_list, + dpif_netdev_port_poll, + dpif_netdev_port_poll_wait, + dpif_netdev_port_group_get, + dpif_netdev_port_group_set, + dpif_netdev_flow_get, + dpif_netdev_flow_put, + dpif_netdev_flow_del, + dpif_netdev_flow_flush, + dpif_netdev_flow_list, + dpif_netdev_execute, + dpif_netdev_recv_get_mask, + dpif_netdev_recv_set_mask, + dpif_netdev_recv, + dpif_netdev_recv_wait, +}; diff --git a/lib/dpif-provider.h b/lib/dpif-provider.h index 35f6c744c..5abe5310a 100644 --- a/lib/dpif-provider.h +++ b/lib/dpif-provider.h @@ -265,5 +265,6 @@ struct dpif_class { }; extern const struct dpif_class dpif_linux_class; +extern const struct dpif_class dpif_netdev_class; #endif /* dpif-provider.h */ diff --git a/lib/dpif.c b/lib/dpif.c index d2ef845da..0e83a9e2a 100644 --- a/lib/dpif.c +++ b/lib/dpif.c @@ -39,8 +39,9 @@ #include "vlog.h" #define THIS_MODULE VLM_dpif -static struct dpif_class *dpif_classes[] = { +static const struct dpif_class *dpif_classes[] = { &dpif_linux_class, + &dpif_netdev_class, }; enum { N_DPIF_CLASSES = ARRAY_SIZE(dpif_classes) }; diff --git a/lib/hmap.h b/lib/hmap.h index 67c8e7041..1809a91b5 100644 --- a/lib/hmap.h +++ b/lib/hmap.h @@ -108,6 +108,14 @@ hmap_count(const struct hmap *hmap) return hmap->n; } +/* Returns the maximum number of nodes that 'hmap' may hold before it should be + * rehashed. */ +static inline size_t +hmap_capacity(const struct hmap *hmap) +{ + return hmap->mask * 2 + 1; +} + /* Returns true if 'hmap' currently contains no nodes, * false otherwise. */ static inline bool diff --git a/lib/netdev.h b/lib/netdev.h index de312d62d..6586ab2ee 100644 --- a/lib/netdev.h +++ b/lib/netdev.h @@ -34,7 +34,8 @@ struct svec; enum netdev_flags { NETDEV_UP = 0x0001, /* Device enabled? */ - NETDEV_PROMISC = 0x0002 /* Promiscuous mode? */ + NETDEV_PROMISC = 0x0002, /* Promiscuous mode? */ + NETDEV_LOOPBACK = 0x0004 /* This is a loopback device. */ }; enum netdev_pseudo_ethertype { diff --git a/lib/vlog-modules.def b/lib/vlog-modules.def index 5fbb59041..a9b46a472 100644 --- a/lib/vlog-modules.def +++ b/lib/vlog-modules.def @@ -31,6 +31,7 @@ VLOG_MODULE(dhcp_client) VLOG_MODULE(discovery) VLOG_MODULE(dpif) VLOG_MODULE(dpif_linux) +VLOG_MODULE(dpif_netdev) VLOG_MODULE(dpctl) VLOG_MODULE(executer) VLOG_MODULE(ezio_term) diff --git a/vswitchd/bridge.c b/vswitchd/bridge.c index f0aa9c03c..32647eaea 100644 --- a/vswitchd/bridge.c +++ b/vswitchd/bridge.c @@ -940,9 +940,16 @@ bridge_reconfigure_one(struct bridge *br) svec_init(&new_ports); cfg_get_all_keys(&new_ports, "bridge.%s.port", br->name); svec_sort(&new_ports); - if (bridge_get_controller(br) && !svec_contains(&new_ports, br->name)) { - svec_add(&new_ports, br->name); - svec_sort(&new_ports); + if (bridge_get_controller(br)) { + char local_name[IF_NAMESIZE]; + int error; + + error = dpif_port_get_name(br->dpif, ODPP_LOCAL, + local_name, sizeof local_name); + if (!error && !svec_contains(&new_ports, local_name)) { + svec_add(&new_ports, local_name); + svec_sort(&new_ports); + } } if (!svec_is_unique(&new_ports)) { VLOG_WARN("bridge %s: %s specified twice as bridge port", @@ -1074,6 +1081,7 @@ bridge_reconfigure_controller(struct bridge *br) cfg_get_bool(0, "%s.update-resolv.conf", pfx)); } else { + char local_name[IF_NAMESIZE]; struct netdev *netdev; bool in_band; int error; @@ -1084,7 +1092,11 @@ bridge_reconfigure_controller(struct bridge *br) ofproto_set_discovery(br->ofproto, false, NULL, NULL); ofproto_set_in_band(br->ofproto, in_band); - error = netdev_open(br->name, NETDEV_ETH_TYPE_NONE, &netdev); + error = dpif_port_get_name(br->dpif, ODPP_LOCAL, + local_name, sizeof local_name); + if (!error) { + error = netdev_open(local_name, NETDEV_ETH_TYPE_NONE, &netdev); + } if (!error) { if (cfg_is_valid(CFG_IP | CFG_REQUIRED, "%s.ip", pfx)) { struct in_addr ip, mask, gateway; -- 2.43.0