X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fnetdev-tunnel.c;h=574115e8243779a6dbf77d238cc8af5cfe4b9a4f;hb=8d25251929c8f325bed0fff24192d5a87034b32e;hp=3215b790c734943a674765be09ea84baa421ff61;hpb=a6e73618f53138eb6f55e2c66ff8c649794fd8dd;p=sliver-openvswitch.git diff --git a/lib/netdev-tunnel.c b/lib/netdev-tunnel.c index 3215b790c..574115e82 100644 --- a/lib/netdev-tunnel.c +++ b/lib/netdev-tunnel.c @@ -24,6 +24,7 @@ #include "flow.h" #include "list.h" +#include "dpif-netdev.h" #include "netdev-provider.h" #include "odp-util.h" #include "ofp-print.h" @@ -40,37 +41,40 @@ VLOG_DEFINE_THIS_MODULE(netdev_tunnel); struct netdev_tunnel { struct netdev up; + + /* Protects all members below. */ + struct ovs_mutex mutex; + uint8_t hwaddr[ETH_ADDR_LEN]; struct netdev_stats stats; enum netdev_flags flags; int sockfd; - struct sockaddr_in local_addr; - struct sockaddr_in remote_addr; + struct sockaddr_storage local_addr; + struct sockaddr_storage remote_addr; bool valid_remote_ip; bool valid_remote_port; bool connected; unsigned int change_seq; }; -struct netdev_rx_tunnel { - struct netdev_rx up; +struct netdev_rxq_tunnel { + struct netdev_rxq up; int fd; }; -static const struct netdev_rx_class netdev_rx_tunnel_class; - static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 20); -static struct shash tunnel_netdevs = SHASH_INITIALIZER(&tunnel_netdevs); +static struct ovs_mutex tunnel_netdevs_mutex = OVS_MUTEX_INITIALIZER; +static struct shash tunnel_netdevs OVS_GUARDED_BY(tunnel_netdevs_mutex) + = SHASH_INITIALIZER(&tunnel_netdevs); -static int netdev_tunnel_create(const struct netdev_class *, const char *, - struct netdev **); +static int netdev_tunnel_construct(struct netdev *netdevp_); static void netdev_tunnel_update_seq(struct netdev_tunnel *); static bool is_netdev_tunnel_class(const struct netdev_class *class) { - return class->create == netdev_tunnel_create; + return class->construct == netdev_tunnel_construct; } static struct netdev_tunnel * @@ -80,23 +84,30 @@ netdev_tunnel_cast(const struct netdev *netdev) return CONTAINER_OF(netdev, struct netdev_tunnel, up); } -static struct netdev_rx_tunnel * -netdev_rx_tunnel_cast(const struct netdev_rx *rx) +static struct netdev_rxq_tunnel * +netdev_rxq_tunnel_cast(const struct netdev_rxq *rx) +{ + ovs_assert(is_netdev_tunnel_class(netdev_get_class(rx->netdev))); + return CONTAINER_OF(rx, struct netdev_rxq_tunnel, up); +} + +static struct netdev * +netdev_tunnel_alloc(void) { - netdev_rx_assert_class(rx, &netdev_rx_tunnel_class); - return CONTAINER_OF(rx, struct netdev_rx_tunnel, up); + struct netdev_tunnel *netdev = xzalloc(sizeof *netdev); + return &netdev->up; } static int -netdev_tunnel_create(const struct netdev_class *class, const char *name, - struct netdev **netdevp) +netdev_tunnel_construct(struct netdev *netdev_) { - static unsigned int n = 0; - struct netdev_tunnel *netdev; - int error; + static atomic_uint next_n = ATOMIC_VAR_INIT(0); + struct netdev_tunnel *netdev = netdev_tunnel_cast(netdev_); + unsigned int n; - netdev = xzalloc(sizeof *netdev); - netdev_init(&netdev->up, name, class); + atomic_add(&next_n, 1, &n); + + ovs_mutex_init(&netdev->mutex); netdev->hwaddr[0] = 0xfe; netdev->hwaddr[1] = 0xff; netdev->hwaddr[2] = 0xff; @@ -111,38 +122,45 @@ netdev_tunnel_create(const struct netdev_class *class, const char *name, netdev->connected = false; - netdev->sockfd = inet_open_passive(SOCK_DGRAM, "", 0, &netdev->local_addr, 0); + netdev->sockfd = inet_open_passive(SOCK_DGRAM, "", 0, + &netdev->local_addr, 0); if (netdev->sockfd < 0) { - error = netdev->sockfd; - goto error; + return netdev->sockfd; } - shash_add(&tunnel_netdevs, name, netdev); + shash_add(&tunnel_netdevs, netdev_get_name(netdev_), netdev); n++; - *netdevp = &netdev->up; - - VLOG_DBG("tunnel_create: name=%s, fd=%d, port=%d", name, netdev->sockfd, netdev->local_addr.sin_port); + VLOG_DBG("tunnel_create: name=%s, fd=%d, port=%d", + netdev_get_name(netdev_), netdev->sockfd, ss_get_port(&netdev->local_addr)); return 0; -error: - free(netdev); - return error; } static void -netdev_tunnel_destroy(struct netdev *netdev_) +netdev_tunnel_destruct(struct netdev *netdev_) { struct netdev_tunnel *netdev = netdev_tunnel_cast(netdev_); + ovs_mutex_lock(&tunnel_netdevs_mutex); + if (netdev->sockfd != -1) close(netdev->sockfd); shash_find_and_delete(&tunnel_netdevs, netdev_get_name(netdev_)); + + ovs_mutex_destroy(&netdev->mutex); + ovs_mutex_unlock(&tunnel_netdevs_mutex); +} + +static void +netdev_tunnel_dealloc(struct netdev *netdev_) +{ + struct netdev_tunnel *netdev = netdev_tunnel_cast(netdev_); free(netdev); } @@ -151,30 +169,41 @@ netdev_tunnel_get_config(const struct netdev *dev_, struct smap *args) { struct netdev_tunnel *netdev = netdev_tunnel_cast(dev_); - if (netdev->valid_remote_ip) - smap_add_format(args, "remote_ip", IP_FMT, - IP_ARGS(netdev->remote_addr.sin_addr.s_addr)); + ovs_mutex_lock(&netdev->mutex); + if (netdev->valid_remote_ip) { + const struct sockaddr_in *sin = + ALIGNED_CAST(const struct sockaddr_in *, &netdev->remote_addr); + smap_add_format(args, "remote_ip", IP_FMT, + IP_ARGS(sin->sin_addr.s_addr)); + } if (netdev->valid_remote_port) smap_add_format(args, "remote_port", "%"PRIu16, - ntohs(netdev->remote_addr.sin_port)); + ss_get_port(&netdev->remote_addr)); + ovs_mutex_unlock(&netdev->mutex); return 0; } static int netdev_tunnel_connect(struct netdev_tunnel *dev) + OVS_REQUIRES(dev->mutex) { + char buf[1024]; + struct sockaddr_in *sin = + ALIGNED_CAST(struct sockaddr_in *, &dev->remote_addr); if (dev->sockfd < 0) return EBADF; if (!dev->valid_remote_ip || !dev->valid_remote_port) return 0; - dev->remote_addr.sin_family = AF_INET; - if (connect(dev->sockfd, (struct sockaddr*) &dev->remote_addr, sizeof(dev->remote_addr)) < 0) { + if (connect(dev->sockfd, (struct sockaddr*) sin, sizeof(*sin)) < 0) { + VLOG_DBG("%s: connect returned %s", netdev_get_name(&dev->up), + ovs_strerror(errno)); return errno; } dev->connected = true; netdev_tunnel_update_seq(dev); VLOG_DBG("%s: connected to (%s, %d)", netdev_get_name(&dev->up), - inet_ntoa(dev->remote_addr.sin_addr), ntohs(dev->remote_addr.sin_port)); + inet_ntop(AF_INET, &sin->sin_addr.s_addr, buf, 1024), + ss_get_port(&dev->remote_addr)); return 0; } @@ -183,123 +212,178 @@ netdev_tunnel_set_config(struct netdev *dev_, const struct smap *args) { struct netdev_tunnel *netdev = netdev_tunnel_cast(dev_); struct shash_node *node; + int error; + struct sockaddr_in *sin = + ALIGNED_CAST(struct sockaddr_in *, &netdev->remote_addr); + ovs_mutex_lock(&netdev->mutex); VLOG_DBG("tunnel_set_config(%s)", netdev_get_name(dev_)); SMAP_FOR_EACH(node, args) { VLOG_DBG("arg: %s->%s", node->name, (char*)node->data); - if (!strcmp(node->name, "remote_ip")) { - struct in_addr addr; - if (lookup_ip(node->data, &addr)) { - VLOG_WARN("%s: bad 'remote_ip'", node->name); - } else { - netdev->remote_addr.sin_addr = addr; - netdev->valid_remote_ip = true; - } - } else if (!strcmp(node->name, "remote_port")) { - netdev->remote_addr.sin_port = htons(atoi(node->data)); - netdev->valid_remote_port = true; - } else { - VLOG_WARN("%s: unknown argument '%s'", - netdev_get_name(dev_), node->name); - } + if (!strcmp(node->name, "remote_ip")) { + struct in_addr addr; + if (lookup_ip(node->data, &addr)) { + VLOG_WARN("%s: bad 'remote_ip'", node->name); + } else { + sin->sin_family = AF_INET; + sin->sin_addr = addr; + netdev->valid_remote_ip = true; + } + } else if (!strcmp(node->name, "remote_port")) { + sin->sin_port = htons(atoi(node->data)); + netdev->valid_remote_port = true; + } else { + VLOG_WARN("%s: unknown argument '%s'", + netdev_get_name(dev_), node->name); + } } - return netdev_tunnel_connect(netdev); + error = netdev_tunnel_connect(netdev); + ovs_mutex_unlock(&netdev->mutex); + return error; +} + +static struct netdev_rxq * +netdev_tunnel_rxq_alloc(void) +{ + struct netdev_rxq_tunnel *rx = xzalloc(sizeof *rx); + return &rx->up; } static int -netdev_tunnel_rx_open(struct netdev *netdev_, struct netdev_rx **rxp) +netdev_tunnel_rxq_construct(struct netdev_rxq *rx_) { - struct netdev_tunnel *netdev = - netdev_tunnel_cast(netdev_); - struct netdev_rx_tunnel *rx; - rx = xmalloc(sizeof *rx); - netdev_rx_init(&rx->up, netdev_, &netdev_rx_tunnel_class); + struct netdev_rxq_tunnel *rx = netdev_rxq_tunnel_cast(rx_); + struct netdev *netdev_ = rx->up.netdev; + struct netdev_tunnel *netdev = netdev_tunnel_cast(netdev_); + + ovs_mutex_lock(&netdev->mutex); rx->fd = netdev->sockfd; - *rxp = &rx->up; + ovs_mutex_unlock(&netdev->mutex); return 0; } static void -netdev_rx_tunnel_destroy(struct netdev_rx *rx_) +netdev_tunnel_rxq_destruct(struct netdev_rxq *rx_ OVS_UNUSED) { - struct netdev_rx_tunnel *rx = netdev_rx_tunnel_cast(rx_); +} + +static void +netdev_tunnel_rxq_dealloc(struct netdev_rxq *rx_) +{ + struct netdev_rxq_tunnel *rx = netdev_rxq_tunnel_cast(rx_); + free(rx); } static int -netdev_rx_tunnel_recv(struct netdev_rx *rx_, void *buffer, size_t size) +netdev_tunnel_rxq_recv(struct netdev_rxq *rx_, struct ofpbuf **packet, int *c) { - struct netdev_rx_tunnel *rx = netdev_rx_tunnel_cast(rx_); + struct netdev_rxq_tunnel *rx = netdev_rxq_tunnel_cast(rx_); struct netdev_tunnel *netdev = netdev_tunnel_cast(rx_->netdev); + struct ofpbuf *buffer = NULL; + void *data; + size_t size; + int error = 0; + if (!netdev->connected) - return -EAGAIN; + return EAGAIN; + buffer = ofpbuf_new_with_headroom(VLAN_ETH_HEADER_LEN + ETH_PAYLOAD_MAX, + DP_NETDEV_HEADROOM); + data = ofpbuf_data(buffer); + size = ofpbuf_tailroom(buffer); + for (;;) { ssize_t retval; - retval = recv(rx->fd, buffer, size, MSG_TRUNC); - VLOG_DBG("%s: recv(%"PRIxPTR", %zu, MSG_TRUNC) = %zd", - netdev_rx_get_name(rx_), (uintptr_t)buffer, size, retval); + retval = recv(rx->fd, data, size, MSG_TRUNC); + VLOG_DBG("%s: recv(%"PRIxPTR", %"PRIuSIZE", MSG_TRUNC) = %"PRIdSIZE, + netdev_rxq_get_name(rx_), (uintptr_t)data, size, retval); if (retval >= 0) { - netdev->stats.rx_packets++; - netdev->stats.rx_bytes += retval; + netdev->stats.rx_packets++; + netdev->stats.rx_bytes += retval; if (retval <= size) { - return retval; + ofpbuf_set_size(buffer, ofpbuf_size(buffer) + retval); + goto out; } else { netdev->stats.rx_errors++; netdev->stats.rx_length_errors++; - return -EMSGSIZE; + error = EMSGSIZE; + goto out; } } else if (errno != EINTR) { if (errno != EAGAIN) { VLOG_WARN_RL(&rl, "error receiveing Ethernet packet on %s: %s", - netdev_rx_get_name(rx_), strerror(errno)); - netdev->stats.rx_errors++; + netdev_rxq_get_name(rx_), ovs_strerror(errno)); + netdev->stats.rx_errors++; } - return -errno; + error = errno; + goto out; } } +out: + if (error) { + ofpbuf_delete(buffer); + } else { + dp_packet_pad(buffer); + packet[0] = buffer; + *c = 1; + } + + return error; } static void -netdev_rx_tunnel_wait(struct netdev_rx *rx_) +netdev_tunnel_rxq_wait(struct netdev_rxq *rx_) { - struct netdev_rx_tunnel *rx = - netdev_rx_tunnel_cast(rx_); + struct netdev_rxq_tunnel *rx = + netdev_rxq_tunnel_cast(rx_); if (rx->fd >= 0) { poll_fd_wait(rx->fd, POLLIN); } } static int -netdev_tunnel_send(struct netdev *netdev_, const void *buffer, size_t size) +netdev_tunnel_send(struct netdev *netdev_, struct ofpbuf *pkt, bool may_steal) { + const void *buffer = ofpbuf_data(pkt); + size_t size = ofpbuf_size(pkt); struct netdev_tunnel *dev = - netdev_tunnel_cast(netdev_); - if (!dev->connected) - return EAGAIN; + netdev_tunnel_cast(netdev_); + int error = 0; + if (!dev->connected) { + error = EAGAIN; + goto out; + } for (;;) { ssize_t retval; retval = send(dev->sockfd, buffer, size, 0); - VLOG_DBG("%s: send(%"PRIxPTR", %zu) = %zd", - netdev_get_name(netdev_), (uintptr_t)buffer, size, retval); + VLOG_DBG("%s: send(%"PRIxPTR", %"PRIuSIZE") = %"PRIdSIZE, + netdev_get_name(netdev_), (uintptr_t)buffer, size, retval); if (retval >= 0) { - dev->stats.tx_packets++; - dev->stats.tx_bytes += retval; - if (retval != size) { - VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%zd bytes of " - "%zu) on %s", retval, size, netdev_get_name(netdev_)); - dev->stats.tx_errors++; - } - return 0; + dev->stats.tx_packets++; + dev->stats.tx_bytes += retval; + if (retval != size) { + VLOG_WARN_RL(&rl, "sent partial Ethernet packet (%"PRIdSIZE" bytes of " + "%"PRIuSIZE") on %s", retval, size, netdev_get_name(netdev_)); + dev->stats.tx_errors++; + } + goto out; } else if (errno != EINTR) { if (errno != EAGAIN) { VLOG_WARN_RL(&rl, "error sending Ethernet packet on %s: %s", - netdev_get_name(netdev_), strerror(errno)); - dev->stats.tx_errors++; + netdev_get_name(netdev_), ovs_strerror(errno)); + dev->stats.tx_errors++; } - return errno; + error = errno; + goto out; } } +out: + if (may_steal) { + ofpbuf_delete(pkt); + } + + return error; } static void @@ -312,25 +396,25 @@ netdev_tunnel_send_wait(struct netdev *netdev_) } static int -netdev_rx_tunnel_drain(struct netdev_rx *rx_) +netdev_tunnel_rxq_drain(struct netdev_rxq *rx_) { struct netdev_tunnel *netdev = netdev_tunnel_cast(rx_->netdev); - struct netdev_rx_tunnel *rx = - netdev_rx_tunnel_cast(rx_); + struct netdev_rxq_tunnel *rx = + netdev_rxq_tunnel_cast(rx_); char buffer[128]; int error; if (!netdev->connected) - return 0; + return 0; for (;;) { - error = recv(rx->fd, buffer, 128, MSG_TRUNC); - if (error) { + error = recv(rx->fd, buffer, 128, MSG_TRUNC); + if (error) { if (error == -EAGAIN) - break; + break; else if (error != -EMSGSIZE) - return error; - } + return error; + } } return 0; } @@ -341,10 +425,12 @@ netdev_tunnel_set_etheraddr(struct netdev *netdev, { struct netdev_tunnel *dev = netdev_tunnel_cast(netdev); + ovs_mutex_lock(&dev->mutex); if (!eth_addr_equals(dev->hwaddr, mac)) { memcpy(dev->hwaddr, mac, ETH_ADDR_LEN); netdev_tunnel_update_seq(dev); } + ovs_mutex_unlock(&dev->mutex); return 0; } @@ -355,7 +441,9 @@ netdev_tunnel_get_etheraddr(const struct netdev *netdev, { const struct netdev_tunnel *dev = netdev_tunnel_cast(netdev); + ovs_mutex_lock(&dev->mutex); memcpy(mac, dev->hwaddr, ETH_ADDR_LEN); + ovs_mutex_unlock(&dev->mutex); return 0; } @@ -365,7 +453,9 @@ netdev_tunnel_get_stats(const struct netdev *netdev, struct netdev_stats *stats) { const struct netdev_tunnel *dev = netdev_tunnel_cast(netdev); + ovs_mutex_lock(&dev->mutex); *stats = dev->stats; + ovs_mutex_unlock(&dev->mutex); return 0; } @@ -374,7 +464,9 @@ netdev_tunnel_set_stats(struct netdev *netdev, const struct netdev_stats *stats) { struct netdev_tunnel *dev = netdev_tunnel_cast(netdev); + ovs_mutex_lock(&dev->mutex); dev->stats = *stats; + ovs_mutex_unlock(&dev->mutex); return 0; } @@ -385,9 +477,12 @@ netdev_tunnel_update_flags(struct netdev *dev_, { struct netdev_tunnel *netdev = netdev_tunnel_cast(dev_); + int error = 0; + ovs_mutex_lock(&netdev->mutex); if ((off | on) & ~(NETDEV_UP | NETDEV_PROMISC)) { - return EINVAL; + error = EINVAL; + goto out; } // XXX should we actually do something with these flags? @@ -397,19 +492,18 @@ netdev_tunnel_update_flags(struct netdev *dev_, if (*old_flagsp != netdev->flags) { netdev_tunnel_update_seq(netdev); } - return 0; -} -static unsigned int -netdev_tunnel_change_seq(const struct netdev *netdev) -{ - return netdev_tunnel_cast(netdev)->change_seq; +out: + ovs_mutex_unlock(&netdev->mutex); + return error; } + /* Helper functions. */ static void netdev_tunnel_update_seq(struct netdev_tunnel *dev) + OVS_REQUIRES(dev->mutex) { dev->change_seq++; if (!dev->change_seq) { @@ -424,14 +518,20 @@ netdev_tunnel_get_port(struct unixctl_conn *conn, struct netdev_tunnel *tunnel_dev; char buf[6]; + ovs_mutex_lock(&tunnel_netdevs_mutex); tunnel_dev = shash_find_data(&tunnel_netdevs, argv[1]); if (!tunnel_dev) { unixctl_command_reply_error(conn, "no such tunnel netdev"); - return; + goto out; } - sprintf(buf, "%d", ntohs(tunnel_dev->local_addr.sin_port)); + ovs_mutex_lock(&tunnel_dev->mutex); + sprintf(buf, "%d", ss_get_port(&tunnel_dev->local_addr)); + ovs_mutex_unlock(&tunnel_dev->mutex); + unixctl_command_reply(conn, buf); +out: + ovs_mutex_unlock(&tunnel_netdevs_mutex); } static void @@ -441,14 +541,19 @@ netdev_tunnel_get_tx_bytes(struct unixctl_conn *conn, struct netdev_tunnel *tunnel_dev; char buf[128]; + ovs_mutex_lock(&tunnel_netdevs_mutex); tunnel_dev = shash_find_data(&tunnel_netdevs, argv[1]); if (!tunnel_dev) { unixctl_command_reply_error(conn, "no such tunnel netdev"); - return; + goto out; } + ovs_mutex_lock(&tunnel_dev->mutex); sprintf(buf, "%"PRIu64, tunnel_dev->stats.tx_bytes); + ovs_mutex_unlock(&tunnel_dev->mutex); unixctl_command_reply(conn, buf); +out: + ovs_mutex_unlock(&tunnel_netdevs_mutex); } static void @@ -458,14 +563,17 @@ netdev_tunnel_get_rx_bytes(struct unixctl_conn *conn, struct netdev_tunnel *tunnel_dev; char buf[128]; + ovs_mutex_lock(&tunnel_netdevs_mutex); tunnel_dev = shash_find_data(&tunnel_netdevs, argv[1]); if (!tunnel_dev) { unixctl_command_reply_error(conn, "no such tunnel netdev"); - return; + goto out; } sprintf(buf, "%"PRIu64, tunnel_dev->stats.rx_bytes); unixctl_command_reply(conn, buf); +out: + ovs_mutex_unlock(&tunnel_netdevs_mutex); } @@ -481,20 +589,30 @@ netdev_tunnel_init(void) return 0; } +static void +netdev_tunnel_run(void) +{ +} + +static void +netdev_tunnel_wait(void) +{ +} + const struct netdev_class netdev_tunnel_class = { "tunnel", - netdev_tunnel_init, /* init */ - NULL, /* run */ - NULL, /* wait */ - - netdev_tunnel_create, - netdev_tunnel_destroy, + netdev_tunnel_init, + netdev_tunnel_run, + netdev_tunnel_wait, + + netdev_tunnel_alloc, + netdev_tunnel_construct, + netdev_tunnel_destruct, + netdev_tunnel_dealloc, netdev_tunnel_get_config, netdev_tunnel_set_config, NULL, /* get_tunnel_config */ - netdev_tunnel_rx_open, - netdev_tunnel_send, netdev_tunnel_send_wait, @@ -521,7 +639,9 @@ const struct netdev_class netdev_tunnel_class = { NULL, /* set_queue */ NULL, /* delete_queue */ NULL, /* get_queue_stats */ - NULL, /* dump_queues */ + NULL, /* queue_dump_start */ + NULL, /* queue_dump_next */ + NULL, /* queue_dump_done */ NULL, /* dump_queue_stats */ NULL, /* get_in4 */ @@ -529,19 +649,16 @@ const struct netdev_class netdev_tunnel_class = { NULL, /* get_in6 */ NULL, /* add_router */ NULL, /* get_next_hop */ - NULL, /* get_drv_info */ + NULL, /* get_status */ NULL, /* arp_lookup */ netdev_tunnel_update_flags, - netdev_tunnel_change_seq + netdev_tunnel_rxq_alloc, + netdev_tunnel_rxq_construct, + netdev_tunnel_rxq_destruct, + netdev_tunnel_rxq_dealloc, + netdev_tunnel_rxq_recv, + netdev_tunnel_rxq_wait, + netdev_tunnel_rxq_drain, }; - - -static const struct netdev_rx_class netdev_rx_tunnel_class = { - netdev_rx_tunnel_destroy, - netdev_rx_tunnel_recv, - netdev_rx_tunnel_wait, - netdev_rx_tunnel_drain, -}; -