X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=datapath%2Fvport-netdev.c;h=2583566b1afd884005e084542122ffc2840fbbbb;hb=431488e6638d3fbb53d215fa10d2ff2d8f1c2824;hp=517249556c40cf4f96c7580b49a7d068880646a4;hpb=fceb2a5bb2063023777fc75c68a2670b5169fa13;p=sliver-openvswitch.git diff --git a/datapath/vport-netdev.c b/datapath/vport-netdev.c index 517249556..2583566b1 100644 --- a/datapath/vport-netdev.c +++ b/datapath/vport-netdev.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2010 Nicira Networks. + * Copyright (c) 2010, 2011 Nicira Networks. * Distributed under the terms of the GNU GPL version 2. * * Significant portions of this file may be copied from parts of the Linux @@ -16,40 +16,74 @@ #include +#include "checksum.h" #include "datapath.h" +#include "vlan.h" #include "vport-internal_dev.h" #include "vport-netdev.h" -#include "compat.h" +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37) && \ + !defined(HAVE_VLAN_BUG_WORKAROUND) +#include + +static int vlan_tso __read_mostly = 0; +module_param(vlan_tso, int, 0644); +MODULE_PARM_DESC(vlan_tso, "Enable TSO for VLAN packets"); +#else +#define vlan_tso true +#endif /* If the native device stats aren't 64 bit use the vport stats tracking instead. */ #define USE_VPORT_STATS (sizeof(((struct net_device_stats *)0)->rx_bytes) < sizeof(u64)) -static void netdev_port_receive(struct net_bridge_port *, struct sk_buff *); +static void netdev_port_receive(struct vport *vport, struct sk_buff *skb); + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36) +/* Called with rcu_read_lock and bottom-halves disabled. */ +static struct sk_buff *netdev_frame_hook(struct sk_buff *skb) +{ + struct vport *vport; + + if (unlikely(skb->pkt_type == PACKET_LOOPBACK)) + return skb; + + vport = netdev_get_vport(skb->dev); + netdev_port_receive(vport, skb); + + return NULL; +} +#elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) /* * Used as br_handle_frame_hook. (Cannot run bridge at the same time, even on * different set of devices!) */ -#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,22) /* Called with rcu_read_lock and bottom-halves disabled. */ static struct sk_buff *netdev_frame_hook(struct net_bridge_port *p, struct sk_buff *skb) { - netdev_port_receive(p, skb); + netdev_port_receive((struct vport *)p, skb); return NULL; } #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) +/* + * Used as br_handle_frame_hook. (Cannot run bridge at the same time, even on + * different set of devices!) + */ /* Called with rcu_read_lock and bottom-halves disabled. */ static int netdev_frame_hook(struct net_bridge_port *p, struct sk_buff **pskb) { - netdev_port_receive(p, *pskb); + netdev_port_receive((struct vport *)p, *pskb); return 1; } #else #error #endif +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,36) +static int netdev_init(void) { return 0; } +static void netdev_exit(void) { } +#else static int netdev_init(void) { /* Hook into callback used by the bridge to intercept packets. @@ -59,19 +93,19 @@ static int netdev_init(void) return 0; } -static void -netdev_exit(void) +static void netdev_exit(void) { br_handle_frame_hook = NULL; } +#endif -static struct vport *netdev_create(const char *name, const void __user *config) +static struct vport *netdev_create(const struct vport_parms *parms) { struct vport *vport; struct netdev_vport *netdev_vport; int err; - vport = vport_alloc(sizeof(struct netdev_vport), &netdev_vport_ops); + vport = vport_alloc(sizeof(struct netdev_vport), &netdev_vport_ops, parms); if (IS_ERR(vport)) { err = PTR_ERR(vport); goto error; @@ -79,7 +113,7 @@ static struct vport *netdev_create(const char *name, const void __user *config) netdev_vport = netdev_vport_priv(vport); - netdev_vport->dev = dev_get_by_name(&init_net, name); + netdev_vport->dev = dev_get_by_name(&init_net, parms->name); if (!netdev_vport->dev) { err = -ENODEV; goto error_free_vport; @@ -92,21 +126,25 @@ static struct vport *netdev_create(const char *name, const void __user *config) goto error_put; } - if (netdev_vport->dev->br_port) { - err = -EBUSY; - goto error_put; - } - /* If we are using the vport stats layer initialize it to the current * values so we are roughly consistent with the device stats. */ if (USE_VPORT_STATS) { - struct odp_vport_stats stats; + struct rtnl_link_stats64 stats; err = netdev_get_stats(vport, &stats); if (!err) vport_set_stats(vport, &stats); } + err = netdev_rx_handler_register(netdev_vport->dev, netdev_frame_hook, + vport); + if (err) + goto error_put; + + dev_set_promiscuity(netdev_vport->dev, 1); + dev_disable_lro(netdev_vport->dev); + netdev_vport->dev->priv_flags |= IFF_OVS_DATAPATH; + return vport; error_put: @@ -121,29 +159,14 @@ static int netdev_destroy(struct vport *vport) { struct netdev_vport *netdev_vport = netdev_vport_priv(vport); - dev_put(netdev_vport->dev); - vport_free(vport); - - return 0; -} - -static int netdev_attach(struct vport *vport) -{ - struct netdev_vport *netdev_vport = netdev_vport_priv(vport); - - dev_set_promiscuity(netdev_vport->dev, 1); - dev_disable_lro(netdev_vport->dev); - rcu_assign_pointer(netdev_vport->dev->br_port, (struct net_bridge_port *)vport); - - return 0; -} + netdev_vport->dev->priv_flags &= ~IFF_OVS_DATAPATH; + netdev_rx_handler_unregister(netdev_vport->dev); + dev_set_promiscuity(netdev_vport->dev, -1); -static int netdev_detach(struct vport *vport) -{ - struct netdev_vport *netdev_vport = netdev_vport_priv(vport); + synchronize_rcu(); - rcu_assign_pointer(netdev_vport->dev->br_port, NULL); - dev_set_promiscuity(netdev_vport->dev, -1); + dev_put(netdev_vport->dev); + vport_free(vport); return 0; } @@ -183,26 +206,10 @@ struct kobject *netdev_get_kobj(const struct vport *vport) return &netdev_vport->dev->NETDEV_DEV_MEMBER.kobj; } -int netdev_get_stats(const struct vport *vport, struct odp_vport_stats *stats) +int netdev_get_stats(const struct vport *vport, struct rtnl_link_stats64 *stats) { const struct netdev_vport *netdev_vport = netdev_vport_priv(vport); - const struct net_device_stats *netdev_stats; - - netdev_stats = dev_get_stats(netdev_vport->dev); - - stats->rx_bytes = netdev_stats->rx_bytes; - stats->rx_packets = netdev_stats->rx_packets; - stats->tx_bytes = netdev_stats->tx_bytes; - stats->tx_packets = netdev_stats->tx_packets; - stats->rx_dropped = netdev_stats->rx_dropped; - stats->rx_errors = netdev_stats->rx_errors; - stats->rx_frame_err = netdev_stats->rx_frame_errors; - stats->rx_over_err = netdev_stats->rx_over_errors; - stats->rx_crc_err = netdev_stats->rx_crc_errors; - stats->tx_dropped = netdev_stats->tx_dropped; - stats->tx_errors = netdev_stats->tx_errors; - stats->collisions = netdev_stats->collisions; - + dev_get_stats(netdev_vport->dev, stats); return 0; } @@ -224,8 +231,7 @@ unsigned char netdev_get_operstate(const struct vport *vport) return netdev_vport->dev->operstate; } -int -netdev_get_ifindex(const struct vport *vport) +int netdev_get_ifindex(const struct vport *vport) { const struct netdev_vport *netdev_vport = netdev_vport_priv(vport); return netdev_vport->dev->ifindex; @@ -244,33 +250,112 @@ int netdev_get_mtu(const struct vport *vport) } /* Must be called with rcu_read_lock. */ -static void netdev_port_receive(struct net_bridge_port *p, struct sk_buff *skb) +static void netdev_port_receive(struct vport *vport, struct sk_buff *skb) { - struct vport *vport = (struct vport *)p; - /* Make our own copy of the packet. Otherwise we will mangle the * packet for anyone who came before us (e.g. tcpdump via AF_PACKET). * (No one comes after us, since we tell handle_bridge() that we took * the packet.) */ skb = skb_share_check(skb, GFP_ATOMIC); - if (!skb) + if (unlikely(!skb)) return; - /* Push the Ethernet header back on. */ + skb_warn_if_lro(skb); + skb_push(skb, ETH_HLEN); - skb_reset_mac_header(skb); compute_ip_summed(skb, false); + vlan_copy_skb_tci(skb); vport_receive(vport, skb); } +static bool dev_supports_vlan_tx(struct net_device *dev) +{ +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,37) + /* Software fallback means every device supports vlan_tci on TX. */ + return true; +#elif defined(HAVE_VLAN_BUG_WORKAROUND) + return dev->features & NETIF_F_HW_VLAN_TX; +#else + /* Assume that the driver is buggy. */ + return false; +#endif +} + static int netdev_send(struct vport *vport, struct sk_buff *skb) { struct netdev_vport *netdev_vport = netdev_vport_priv(vport); - int len = skb->len; + int len; skb->dev = netdev_vport->dev; forward_ip_summed(skb); + + if (vlan_tx_tag_present(skb) && !dev_supports_vlan_tx(skb->dev)) { + int err; + int features = 0; + +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26) + features = skb->dev->features & skb->dev->vlan_features; +#endif + + err = vswitch_skb_checksum_setup(skb); + if (unlikely(err)) { + kfree_skb(skb); + return 0; + } + + if (!vlan_tso) + features &= ~(NETIF_F_TSO | NETIF_F_TSO6 | + NETIF_F_UFO | NETIF_F_FSO); + + if (skb_is_gso(skb) && + (!skb_gso_ok(skb, features) || + unlikely(skb->ip_summed != CHECKSUM_PARTIAL))) { + struct sk_buff *nskb; + + nskb = skb_gso_segment(skb, features); + if (!nskb) { + if (unlikely(skb_cloned(skb) && + pskb_expand_head(skb, 0, 0, GFP_ATOMIC))) { + kfree_skb(skb); + return 0; + } + + skb_shinfo(skb)->gso_type &= ~SKB_GSO_DODGY; + goto tag; + } + + kfree_skb(skb); + skb = nskb; + if (IS_ERR(skb)) + return 0; + + len = 0; + do { + nskb = skb->next; + skb->next = NULL; + + skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb)); + if (likely(skb)) { + len += skb->len; + vlan_set_tci(skb, 0); + dev_queue_xmit(skb); + } + + skb = nskb; + } while (skb); + + return len; + } + +tag: + skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb)); + if (unlikely(!skb)) + return 0; + vlan_set_tci(skb, 0); + } + + len = skb->len; dev_queue_xmit(skb); return len; @@ -279,19 +364,28 @@ static int netdev_send(struct vport *vport, struct sk_buff *skb) /* Returns null if this device is not attached to a datapath. */ struct vport *netdev_get_vport(struct net_device *dev) { - return (struct vport *)dev->br_port; +#ifdef IFF_BRIDGE_PORT +#if IFF_BRIDGE_PORT != IFF_OVS_DATAPATH + if (likely(dev->priv_flags & IFF_OVS_DATAPATH)) +#else + if (likely(rcu_access_pointer(dev->rx_handler) == netdev_frame_hook)) +#endif + return (struct vport *)rcu_dereference_rtnl(dev->rx_handler_data); + else + return NULL; +#else + return (struct vport *)rcu_dereference_rtnl(dev->br_port); +#endif } -struct vport_ops netdev_vport_ops = { - .type = "netdev", +const struct vport_ops netdev_vport_ops = { + .type = ODP_VPORT_TYPE_NETDEV, .flags = (VPORT_F_REQUIRED | (USE_VPORT_STATS ? VPORT_F_GEN_STATS : 0)), .init = netdev_init, .exit = netdev_exit, .create = netdev_create, .destroy = netdev_destroy, - .attach = netdev_attach, - .detach = netdev_detach, .set_mtu = netdev_set_mtu, .set_addr = netdev_set_addr, .get_name = netdev_get_name, @@ -307,10 +401,12 @@ struct vport_ops netdev_vport_ops = { .send = netdev_send, }; +#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,36) /* - * Open vSwitch cannot safely coexist with the Linux bridge module on any - * released version of Linux, because there is only a single bridge hook - * function and only a single br_port member in struct net_device. + * In kernels earlier than 2.6.36, Open vSwitch cannot safely coexist with + * the Linux bridge module on any released version of Linux, because there + * is only a single bridge hook function and only a single br_port member + * in struct net_device. * * Declaring and exporting this symbol enforces mutual exclusion. The bridge * module also exports the same symbol, so the module loader will refuse to @@ -322,3 +418,4 @@ struct vport_ops netdev_vport_ops = { */ typeof(br_should_route_hook) br_should_route_hook; EXPORT_SYMBOL(br_should_route_hook); +#endif