mir/openvswitch
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-10-21 14:49:41 +00:00
Code Issues Releases Wiki Activity
Files
9df6a67988a32ad65e5b358f460bacf9b4cf34a2
openvswitch/datapath/vport-internal_dev.c

305 lines
7.4 KiB
C
Raw Normal View History

datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
/*
datapath: Change vport type from string to integer enumeration. I plan to make the vport type part of the standard header stuck on each Netlink message related to a vport. As such, it is more convenient to use an integer than a string. In addition, by being fundamentally different from strings, using an integer may reduce the confusion we've had in the past over the differences in userspace and kernel names for network device and vport types. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-01-23 20:01:30 -08:00
* Copyright (c) 2009, 2010, 2011 Nicira Networks.
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
* Distributed under the terms of the GNU GPL version 2.
*
* Significant portions of this file may be copied from parts of the Linux
* kernel, by Linus Torvalds and others.
*/
datapath: Add missing header. The internal dev vport really needs hardirq.h but doesn't depend directly on it and has relied on it being included from other sources. Recent kernels broke this, so explicitly add the header. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-06-23 12:54:48 -07:00
#include <linux/hardirq.h>
datapath: Use vlan acceleration for vlan operations. Using the kernel vlan acceleration has a number of benefits: it enables hardware tagging, allows usage of TSO and checksum offloading, and is generally easier to manipulate. This switches the vlan actions to use skb->vlan_tci field for any necessary changes. In places that do not support vlan acceleration in a way that we can use (in particular kernels before 2.6.37) we perform any necessary conversions, such as tagging and GSO before the packet leaves Open vSwitch. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-29 22:13:15 -08:00
#include <linux/if_vlan.h>
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
#include <linux/skbuff.h>
datapath: Don't set dev->last_rx on kernels >= 2.6.29. dev->last_rx is used for rebalancing in Linux bonding. However, on a SMP machine it quickly becomes a very hot cacheline. On kernels 2.6.29 and later the networking core will update last_rx only if bonding is in use, so drivers do not need to set it at all. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-23 16:46:47 -08:00
#include <linux/version.h>
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
datapath: Consolidate checksum compatibility code. Checksum offloading has changed quite a bit across different kernel and Xen versions. Since it is part of the skb data structure it is unfortunately difficult to separate out into compatibility code. This consolidates all of the checksum code in one place which makes it easier read and remove as we prepare for upstreaming. On newer kernels it also puts everything in inline functions, eliminating the need to run through the compat code or make extra function calls. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-22 14:17:24 -08:00
#include "checksum.h"
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
#include "datapath.h"
datapath: Add vlan acceleration field for older kernels. Kernels prior to 2.6.27 did not have a vlan_tci field in struct sk_buff for vlan acceleration. It's very convenient to use this field for manipulating vlan tags, so we would like to use it as the primary mechanism. To enable this, this commit adds similar infrastructure to the OVS_CB on the kernels that need it and a set of functions to use the correct location. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-30 20:48:38 -08:00
#include "vlan.h"
vport: Extract common functions for virtual devices. Pull some generic implementations of vport functions out of the GRE vport so they can be used by others. Also move the code to set the MTUs of internal devices to the minimum of attached devices to the generic vport_set_mtu layer.
2010-05-10 17:40:22 -07:00
#include "vport-generic.h"
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
#include "vport-internal_dev.h"
#include "vport-netdev.h"
datapath: Add version check for struct netdev_ops. Linux 3.1 drops the symbol HAVE_NET_DEVICE_OPS that lets us know whether struct netdev_ops is present. As a result, we need to replace it with an explicit version check. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-09-20 19:12:32 -07:00
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,1,0)
#define HAVE_NET_DEVICE_OPS
#endif
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
struct internal_dev {
datapath: Merge vport "attach" into "create" and "detach" into "destroy". These steps are sequentially in lockstep, so we might as well combine them. This expands the region over which the vport_lock is held. I didn't carefully verify that this was OK. This also eliminates the synchronize_rcu() call from destruction of tunnel vports, since they didn't appear to me to need it. It should be possible to eliminate the synchronize_rcu() from the netdev, patch, and internal_dev vports, but this commit does not do that. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-12-03 15:44:51 -08:00
struct vport *vport;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
struct net_device_stats stats;
};
static inline struct internal_dev *internal_dev_priv(struct net_device *netdev)
{
return netdev_priv(netdev);
}
datapath: Always use generic stats for devices (vports) Currently ovs is using device stats for Linux devices and count them itself in other situations. This leads to overlap with hardware stats, inconsistencies, etc. It's much better to just always count the packets flowing through the switch and let userspace do any merging that it wants. Following patch removes vport->get_stats() interface. vport-stat is changed to use new `struct ovs_vport_stat` rather than rtnl_link_stats64. Definitions of rtnl_link_stats64 is removed from OVS. dipf_port->stat is also removed as aggregate stats are only available at netdev layer. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-09-15 19:36:17 -07:00
/* This function is only called by the kernel network layer.*/
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
static struct net_device_stats *internal_dev_sys_stats(struct net_device *netdev)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
struct vport *vport = internal_dev_get_vport(netdev);
struct net_device_stats *stats = &internal_dev_priv(netdev)->stats;
if (vport) {
datapath: Always use generic stats for devices (vports) Currently ovs is using device stats for Linux devices and count them itself in other situations. This leads to overlap with hardware stats, inconsistencies, etc. It's much better to just always count the packets flowing through the switch and let userspace do any merging that it wants. Following patch removes vport->get_stats() interface. vport-stat is changed to use new `struct ovs_vport_stat` rather than rtnl_link_stats64. Definitions of rtnl_link_stats64 is removed from OVS. dipf_port->stat is also removed as aggregate stats are only available at netdev layer. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-09-15 19:36:17 -07:00
struct ovs_vport_stats vport_stats;
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
vport_get_stats(vport, &vport_stats);
/* The tx and rx stats need to be swapped because the switch
* and host OS have opposite perspectives. */
stats->rx_packets = vport_stats.tx_packets;
stats->tx_packets = vport_stats.rx_packets;
stats->rx_bytes = vport_stats.tx_bytes;
stats->tx_bytes = vport_stats.rx_bytes;
stats->rx_errors = vport_stats.tx_errors;
stats->tx_errors = vport_stats.rx_errors;
stats->rx_dropped = vport_stats.tx_dropped;
stats->tx_dropped = vport_stats.rx_dropped;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
}
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
return stats;
}
static int internal_dev_mac_addr(struct net_device *dev, void *p)
{
struct sockaddr *addr = p;
if (!is_valid_ether_addr(addr->sa_data))
return -EADDRNOTAVAIL;
memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
return 0;
}
datapath: Fix recv path for CONFIG_PREEMPT_RCU. In case CONFIG_PREEMPT_RCU, rcu grace period waits only for RCU read-side critical sections that are delimited by rcu_read_lock() and rcu_read_unlock(). internal_dev_xmit() is called in rcu_read_lock_bh context. Therefore we need to explicitly take rcu lock to prevent race with call_rcu() in PREEMPT_RCU case. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-10-06 19:45:09 -07:00
/* Called with rcu_read_lock_bh. */
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
static int internal_dev_xmit(struct sk_buff *skb, struct net_device *netdev)
{
datapath: Further mirror checksum offloading state on old kernels. Older kernels (those before 2.6.22) rely on implicit assumptions to determine checksum offloading status. These assumptions tend to break down when doing switching because it sits in the middle of the transmit and receive path. Newer kernels deal with this problem by adding more explicit information about how to checksum. This replicates that behavior by mirroring the state from newer kernels in private OVS storage on the kernels that lack it. On ingress and egress we then map that state onto the appropriate location for the given kernel and can consistently manipulate it within OVS. Some of this was already done for the checksum type but this makes it more robust and expands it to the checksum start and offset as well. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-05-27 15:53:49 -07:00
if (unlikely(compute_ip_summed(skb, true))) {
kfree_skb(skb);
return 0;
}
datapath: Add vlan acceleration field for older kernels. Kernels prior to 2.6.27 did not have a vlan_tci field in struct sk_buff for vlan acceleration. It's very convenient to use this field for manipulating vlan tags, so we would like to use it as the primary mechanism. To enable this, this commit adds similar infrastructure to the OVS_CB on the kernels that need it and a set of functions to use the correct location. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-30 20:48:38 -08:00
vlan_copy_skb_tci(skb);
datapath: Enable usage of cached flows. An upcoming commit will add support for supplying cached flows for packets entering the datapath. This adds the code in the datapath itself to recognize these cached flows and use them instead of extracting the flow fields and doing a lookup. Signed-off-by: Jesse Gross <jesse@nicira.com> Reviewed-by: Ben Pfaff <blp@nicira.com>
2010-08-29 10:49:11 -07:00
OVS_CB(skb)->flow = NULL;
datapath: Enable offloading on internal devices. Enables checksum offloading, scatter/gather, and TSO on internal devices. While these optimizations were not previously enabled on internal ports we already could receive these types of packets from Xen guests. This has the obvious performance benefits when these packets can be passed directly to hardware. There is also a more subtle benefit for GRE on Xen. GRE packets pass through OVS twice - once before encapsulation and once after encapsulation, moving through an internal device in the process. If it is a SG packet (as is common on Xen), a copy was necessary to linearize for the internal device. However, Xen uses the memory allocator to track packets so when the original packet is freed after the copy netback notifies the guest that the packet has been sent, despite the fact that it is actually sitting in the transmit queue. The guest then sends packets as fast as the CPU can handle, overflowing the transmit queue. By enabling SG on the internal device, we avoid the copy and keep the accounting correct. In certain circumstances this patch can decrease performance for TCP. TCP has its own mechanism for tracking in-flight packets and therefore does not benefit from the corrected socket accounting. However, certain NICs do not like SG when it is not being used for TSO (these packets can no longer be handled by TSO after GRE encapsulation). These NICs presumably enable SG even though they can't handle it well because TSO requires SG. Tested controllers (all 1G): Marvell 88E8053 (large performance hit) Broadcom BCM5721 (small performance hit) Intel 82571EB (no change)
2010-04-22 08:11:50 -04:00
datapath: Fix recv path for CONFIG_PREEMPT_RCU. In case CONFIG_PREEMPT_RCU, rcu grace period waits only for RCU read-side critical sections that are delimited by rcu_read_lock() and rcu_read_unlock(). internal_dev_xmit() is called in rcu_read_lock_bh context. Therefore we need to explicitly take rcu lock to prevent race with call_rcu() in PREEMPT_RCU case. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-10-06 19:45:09 -07:00
rcu_read_lock();
datapath: Don't use RCU for internal dev vport. The vports are now attached and ready to go when they are allocated, so we don't have to worry about future changes. As a result, we can directly store the pointer in the internal dev's netdevice private space before it is registered. The registration process will handle the necessary write memory barriers and anyone who has a reference to the netdev will have done the read side barriers, we don't need to use RCU at all. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-08 19:21:40 -08:00
vport_receive(internal_dev_priv(netdev)->vport, skb);
datapath: Fix recv path for CONFIG_PREEMPT_RCU. In case CONFIG_PREEMPT_RCU, rcu grace period waits only for RCU read-side critical sections that are delimited by rcu_read_lock() and rcu_read_unlock(). internal_dev_xmit() is called in rcu_read_lock_bh context. Therefore we need to explicitly take rcu lock to prevent race with call_rcu() in PREEMPT_RCU case. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-10-06 19:45:09 -07:00
rcu_read_unlock();
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
return 0;
}
static int internal_dev_open(struct net_device *netdev)
{
netif_start_queue(netdev);
return 0;
}
static int internal_dev_stop(struct net_device *netdev)
{
netif_stop_queue(netdev);
return 0;
}
static void internal_dev_getinfo(struct net_device *netdev,
struct ethtool_drvinfo *info)
{
strcpy(info->driver, "openvswitch");
}
datapath: Constify ops structures. vport_ops, tunnel_ops, and ethtool_ops should not change at runtime. Therefore, mark them as const to keep them out of the hotpath and to prevent them from getting trampled. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-23 22:08:27 -08:00
static const struct ethtool_ops internal_dev_ethtool_ops = {
datapath: Enable offloading on internal devices. Enables checksum offloading, scatter/gather, and TSO on internal devices. While these optimizations were not previously enabled on internal ports we already could receive these types of packets from Xen guests. This has the obvious performance benefits when these packets can be passed directly to hardware. There is also a more subtle benefit for GRE on Xen. GRE packets pass through OVS twice - once before encapsulation and once after encapsulation, moving through an internal device in the process. If it is a SG packet (as is common on Xen), a copy was necessary to linearize for the internal device. However, Xen uses the memory allocator to track packets so when the original packet is freed after the copy netback notifies the guest that the packet has been sent, despite the fact that it is actually sitting in the transmit queue. The guest then sends packets as fast as the CPU can handle, overflowing the transmit queue. By enabling SG on the internal device, we avoid the copy and keep the accounting correct. In certain circumstances this patch can decrease performance for TCP. TCP has its own mechanism for tracking in-flight packets and therefore does not benefit from the corrected socket accounting. However, certain NICs do not like SG when it is not being used for TSO (these packets can no longer be handled by TSO after GRE encapsulation). These NICs presumably enable SG even though they can't handle it well because TSO requires SG. Tested controllers (all 1G): Marvell 88E8053 (large performance hit) Broadcom BCM5721 (small performance hit) Intel 82571EB (no change)
2010-04-22 08:11:50 -04:00
.get_drvinfo = internal_dev_getinfo,
.get_link = ethtool_op_get_link,
.get_sg = ethtool_op_get_sg,
.set_sg = ethtool_op_set_sg,
.get_tx_csum = ethtool_op_get_tx_csum,
.set_tx_csum = ethtool_op_set_tx_hw_csum,
.get_tso = ethtool_op_get_tso,
.set_tso = ethtool_op_set_tso,
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
};
static int internal_dev_change_mtu(struct net_device *netdev, int new_mtu)
{
if (new_mtu < 68)
return -EINVAL;
netdev->mtu = new_mtu;
return 0;
}
static int internal_dev_do_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
if (dp_ioctl_hook)
return dp_ioctl_hook(dev, ifr, cmd);
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
return -EOPNOTSUPP;
}
datapath: Don't free vport until all references are gone. We currently call vport_free() for internal devices after the device is unregistered. This takes care of callers that use either RTNL or RCU but not ones that have only a device reference. In particular, if stats are requested while a datapath is being unregistered we can try to use the vport data structures which have already been freed. Bug #4736 Reported-by: Brad Hall <brad@nicira.com> Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-02-24 14:16:24 -08:00
static void internal_dev_destructor(struct net_device *dev)
{
struct vport *vport = internal_dev_get_vport(dev);
vport_free(vport);
free_netdev(dev);
}
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
#ifdef HAVE_NET_DEVICE_OPS
static const struct net_device_ops internal_dev_netdev_ops = {
.ndo_open = internal_dev_open,
.ndo_stop = internal_dev_stop,
.ndo_start_xmit = internal_dev_xmit,
.ndo_set_mac_address = internal_dev_mac_addr,
.ndo_do_ioctl = internal_dev_do_ioctl,
.ndo_change_mtu = internal_dev_change_mtu,
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
.ndo_get_stats = internal_dev_sys_stats,
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
};
#endif
datapath: Put return type on same line as arguments for functions. In some places we would put the return type on the same line as the rest of the function definition and other places we wouldn't. Reformat everything to match kernel style.
2010-07-14 19:27:18 -07:00
static void do_setup(struct net_device *netdev)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
ether_setup(netdev);
#ifdef HAVE_NET_DEVICE_OPS
netdev->netdev_ops = &internal_dev_netdev_ops;
#else
netdev->do_ioctl = internal_dev_do_ioctl;
vport-internal: Convert internal devices to vport stats. Internal devices currently keep track of stats themselves. However, we now have stats tracking in the vport layer, so convert to use that instead to avoid code duplication and take advantage of additional features such as 64-bit counters.
2010-05-19 18:28:31 -07:00
netdev->get_stats = internal_dev_sys_stats;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
netdev->hard_start_xmit = internal_dev_xmit;
netdev->open = internal_dev_open;
netdev->stop = internal_dev_stop;
netdev->set_mac_address = internal_dev_mac_addr;
netdev->change_mtu = internal_dev_change_mtu;
#endif
datapath: Assert IFF_TX_SKB_SHARING on internal devices. Linux 3.1 adds a flag to check whether it's OK for shared skbs to be transmitted on devices. This generally isn't a problem for hardware devices but software devices such as OVS that hold state in the skb need to clear the flag, which is enabled by default. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-09-20 19:09:50 -07:00
netdev->priv_flags &= ~IFF_TX_SKB_SHARING;
datapath: Don't free vport until all references are gone. We currently call vport_free() for internal devices after the device is unregistered. This takes care of callers that use either RTNL or RCU but not ones that have only a device reference. In particular, if stats are requested while a datapath is being unregistered we can try to use the vport data structures which have already been freed. Bug #4736 Reported-by: Brad Hall <brad@nicira.com> Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-02-24 14:16:24 -08:00
netdev->destructor = internal_dev_destructor;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
SET_ETHTOOL_OPS(netdev, &internal_dev_ethtool_ops);
netdev->tx_queue_len = 0;
datapath: Allow skbs with a frag list. We can already receive packets with a frag list due to reassembly in CAPWAP tunneling. Since we can handle it, we might as well open it up to internal devices as well to prevent linearization. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-23 17:03:16 -08:00
netdev->features = NETIF_F_LLTX | NETIF_F_SG | NETIF_F_FRAGLIST |
NETIF_F_HIGHDMA | NETIF_F_HW_CSUM | NETIF_F_TSO;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
datapath: Enable vlan offload on internal devices. Although it is generally best to configure vlans directly though Open vSwitch, enabling vlan acceleration on internal devices can avoid some issues and hardware limitations if Linux vlan devices are used. It is only used on kernels that support modern vlan data structures, which are 2.6.27 and later. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-03-04 15:52:43 -08:00
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
netdev->vlan_features = netdev->features;
netdev->features |= NETIF_F_HW_VLAN_TX;
#endif
vport: Extract common functions for virtual devices. Pull some generic implementations of vport functions out of the GRE vport so they can be used by others. Also move the code to set the MTUs of internal devices to the minimum of attached devices to the generic vport_set_mtu layer.
2010-05-10 17:40:22 -07:00
vport_gen_rand_ether_addr(netdev->dev_addr);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
}
datapath: Encapsulate parameters for new vports in new struct vport_parms. Upcoming commits will keep needing to pass more information to the vport 'create' member function. It's annoying to have to modify a dozen pieces of code every time just to do this, so this commit encapsulates all of the parameters in a new struct and passes that instead. Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-04 16:32:57 -07:00
static struct vport *internal_dev_create(const struct vport_parms *parms)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
struct vport *vport;
struct netdev_vport *netdev_vport;
struct internal_dev *internal_dev;
int err;
datapath: Merge "struct dp_port" into "struct vport". After the previous commit, which changed the datapath to always create and attach a vport at the same time, and to always detach and delete a vport at the same time, there is no longer any real distinction between a dp_port and a vport. This commit, therefore, merges the two together to simplify code. It might even improve performance, although I have not checked. I wasn't sure at first whether the merged structure should be "struct dp_port" or "struct vport". I went with the latter since the "v" prefix sounds cool. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-12-03 13:09:26 -08:00
vport = vport_alloc(sizeof(struct netdev_vport), &internal_vport_ops, parms);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
if (IS_ERR(vport)) {
err = PTR_ERR(vport);
goto error;
}
netdev_vport = netdev_vport_priv(vport);
datapath: Encapsulate parameters for new vports in new struct vport_parms. Upcoming commits will keep needing to pass more information to the vport 'create' member function. It's annoying to have to modify a dozen pieces of code every time just to do this, so this commit encapsulates all of the parameters in a new struct and passes that instead. Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-04 16:32:57 -07:00
netdev_vport->dev = alloc_netdev(sizeof(struct internal_dev), parms->name, do_setup);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
if (!netdev_vport->dev) {
err = -ENOMEM;
goto error_free_vport;
}
internal_dev = internal_dev_priv(netdev_vport->dev);
datapath: Don't use RCU for internal dev vport. The vports are now attached and ready to go when they are allocated, so we don't have to worry about future changes. As a result, we can directly store the pointer in the internal dev's netdevice private space before it is registered. The registration process will handle the necessary write memory barriers and anyone who has a reference to the netdev will have done the read side barriers, we don't need to use RCU at all. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-08 19:21:40 -08:00
internal_dev->vport = vport;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
err = register_netdevice(netdev_vport->dev);
if (err)
goto error_free_netdev;
datapath: Merge vport "attach" into "create" and "detach" into "destroy". These steps are sequentially in lockstep, so we might as well combine them. This expands the region over which the vport_lock is held. I didn't carefully verify that this was OK. This also eliminates the synchronize_rcu() call from destruction of tunnel vports, since they didn't appear to me to need it. It should be possible to eliminate the synchronize_rcu() from the netdev, patch, and internal_dev vports, but this commit does not do that. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-12-03 15:44:51 -08:00
dev_set_promiscuity(netdev_vport->dev, 1);
netif_start_queue(netdev_vport->dev);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
return vport;
error_free_netdev:
free_netdev(netdev_vport->dev);
error_free_vport:
vport_free(vport);
error:
return ERR_PTR(err);
}
datapath: Improve kernel hash table Currently OVS uses its own hashing implmentation for hash tables which has some problems, e.g. error case on deletion code. Following patch replaces that with hlist based hash table which is consistent with other kernel hash tables. As Jesse suggested, flex-array is used for allocating hash buckets, So that we can have large hash-table without large contiguous kernel memory. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-09-09 19:09:47 -07:00
static void internal_dev_destroy(struct vport *vport)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
struct netdev_vport *netdev_vport = netdev_vport_priv(vport);
vport-internal: Set vport to NULL when detaching. 'struct net_device' is refcounted and can stick around for quite a while if someone is still holding a reference to it. However, we free the vport that it is attached to in the next RCU grace period after detach. This assigns the vport to NULL on detach and adds appropriate checks.
2010-07-29 15:59:36 -07:00
netif_stop_queue(netdev_vport->dev);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
dev_set_promiscuity(netdev_vport->dev, -1);
datapath: Merge vport "attach" into "create" and "detach" into "destroy". These steps are sequentially in lockstep, so we might as well combine them. This expands the region over which the vport_lock is held. I didn't carefully verify that this was OK. This also eliminates the synchronize_rcu() call from destruction of tunnel vports, since they didn't appear to me to need it. It should be possible to eliminate the synchronize_rcu() from the netdev, patch, and internal_dev vports, but this commit does not do that. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-12-03 15:44:51 -08:00
datapath: Eliminate vport_mutex by protecting vport table with RCU. The vport_mutex really only protects the vport dev_table, which isn't very much. By getting rid of it we take one step toward simplifying the vswitch locking, which will necessarily have to be based mainly around the Generic Netlink genl_mutex once we switch to Generic Netlink. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-01-26 09:42:28 -08:00
/* unregister_netdevice() waits for an RCU grace period. */
datapath: Don't free vport until all references are gone. We currently call vport_free() for internal devices after the device is unregistered. This takes care of callers that use either RTNL or RCU but not ones that have only a device reference. In particular, if stats are requested while a datapath is being unregistered we can try to use the vport data structures which have already been freed. Bug #4736 Reported-by: Brad Hall <brad@nicira.com> Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-02-24 14:16:24 -08:00
unregister_netdevice(netdev_vport->dev);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
}
datapath: Put return type on same line as arguments for functions. In some places we would put the return type on the same line as the rest of the function definition and other places we wouldn't. Reformat everything to match kernel style.
2010-07-14 19:27:18 -07:00
static int internal_dev_recv(struct vport *vport, struct sk_buff *skb)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
struct net_device *netdev = netdev_vport_priv(vport)->dev;
int len;
datapath: Use vlan acceleration for vlan operations. Using the kernel vlan acceleration has a number of benefits: it enables hardware tagging, allows usage of TSO and checksum offloading, and is generally easier to manipulate. This switches the vlan actions to use skb->vlan_tci field for any necessary changes. In places that do not support vlan acceleration in a way that we can use (in particular kernels before 2.6.37) we perform any necessary conversions, such as tagging and GSO before the packet leaves Open vSwitch. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-29 22:13:15 -08:00
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,37)
if (unlikely(vlan_deaccel_tag(skb)))
return 0;
#endif
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
len = skb->len;
datapath: Use vlan acceleration for vlan operations. Using the kernel vlan acceleration has a number of benefits: it enables hardware tagging, allows usage of TSO and checksum offloading, and is generally easier to manipulate. This switches the vlan actions to use skb->vlan_tci field for any necessary changes. In places that do not support vlan acceleration in a way that we can use (in particular kernels before 2.6.37) we perform any necessary conversions, such as tagging and GSO before the packet leaves Open vSwitch. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-29 22:13:15 -08:00
skb->dev = netdev;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
skb->pkt_type = PACKET_HOST;
skb->protocol = eth_type_trans(skb, netdev);
datapath: Further mirror checksum offloading state on old kernels. Older kernels (those before 2.6.22) rely on implicit assumptions to determine checksum offloading status. These assumptions tend to break down when doing switching because it sits in the middle of the transmit and receive path. Newer kernels deal with this problem by adding more explicit information about how to checksum. This replicates that behavior by mirroring the state from newer kernels in private OVS storage on the kernels that lack it. On ingress and egress we then map that state onto the appropriate location for the given kernel and can consistently manipulate it within OVS. Some of this was already done for the checksum type but this makes it more robust and expands it to the checksum start and offset as well. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2011-05-27 15:53:49 -07:00
forward_ip_summed(skb, false);
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
datapath: Remove RT kernel support. Following patch removes RT kernel support. This allows us to cleanup the loop detection. Along with this BH is now disabled while running execute_actions() for packet from user-space. As a result we can simplify the stats code as entire send and receive path runs in BH context on all supported platforms. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com> Bug #7621
2011-10-06 21:52:39 -07:00
netif_rx(skb);
datapath: Don't set dev->last_rx on kernels >= 2.6.29. dev->last_rx is used for rebalancing in Linux bonding. However, on a SMP machine it quickly becomes a very hot cacheline. On kernels 2.6.29 and later the networking core will update last_rx only if bonding is in use, so drivers do not need to set it at all. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-23 16:46:47 -08:00
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,29)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
netdev->last_rx = jiffies;
datapath: Don't set dev->last_rx on kernels >= 2.6.29. dev->last_rx is used for rebalancing in Linux bonding. However, on a SMP machine it quickly becomes a very hot cacheline. On kernels 2.6.29 and later the networking core will update last_rx only if bonding is in use, so drivers do not need to set it at all. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-23 16:46:47 -08:00
#endif
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
return len;
}
datapath: Constify ops structures. vport_ops, tunnel_ops, and ethtool_ops should not change at runtime. Therefore, mark them as const to keep them out of the hotpath and to prevent them from getting trampled. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-23 22:08:27 -08:00
const struct vport_ops internal_vport_ops = {
datapath: Use "OVS_*" as opposed to "ODP_*" for user<->kernel interactions. The prefix "ODP_*" is not overly descriptive in the context of the larger Linux tree. This commit changes the prefix to "OVS_*" for the userpace to kernel interactions. The userspace libraries still use "ODP_" in many of their interfaces since it is more descriptive in the OVS oeuvre. Feature #6904 Signed-off-by: Justin Pettit <jpettit@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-08-18 10:35:40 -07:00
.type = OVS_VPORT_TYPE_INTERNAL,
datapath: Always use generic stats for devices (vports) Currently ovs is using device stats for Linux devices and count them itself in other situations. This leads to overlap with hardware stats, inconsistencies, etc. It's much better to just always count the packets flowing through the switch and let userspace do any merging that it wants. Following patch removes vport->get_stats() interface. vport-stat is changed to use new `struct ovs_vport_stat` rather than rtnl_link_stats64. Definitions of rtnl_link_stats64 is removed from OVS. dipf_port->stat is also removed as aggregate stats are only available at netdev layer. Signed-off-by: Pravin B Shelar <pshelar@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2011-09-15 19:36:17 -07:00
.flags = VPORT_F_REQUIRED | VPORT_F_FLOW,
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
.create = internal_dev_create,
.destroy = internal_dev_destroy,
.set_addr = netdev_set_addr,
.get_name = netdev_get_name,
.get_addr = netdev_get_addr,
.get_kobj = netdev_get_kobj,
.get_dev_flags = netdev_get_dev_flags,
.is_running = netdev_is_running,
.get_operstate = netdev_get_operstate,
.get_ifindex = netdev_get_ifindex,
.get_mtu = netdev_get_mtu,
.send = internal_dev_recv,
};
int is_internal_dev(const struct net_device *netdev)
{
#ifdef HAVE_NET_DEVICE_OPS
return netdev->netdev_ops == &internal_dev_netdev_ops;
#else
return netdev->open == internal_dev_open;
#endif
}
datapath: Put return type on same line as arguments for functions. In some places we would put the return type on the same line as the rest of the function definition and other places we wouldn't. Reformat everything to match kernel style.
2010-07-14 19:27:18 -07:00
int is_internal_vport(const struct vport *vport)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
return vport->ops == &internal_vport_ops;
}
datapath: Put return type on same line as arguments for functions. In some places we would put the return type on the same line as the rest of the function definition and other places we wouldn't. Reformat everything to match kernel style.
2010-07-14 19:27:18 -07:00
struct vport *internal_dev_get_vport(struct net_device *netdev)
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
{
tunneling: Internal dev vport can be NULL. Commit 4bee42 "tunnel: Correctly check for internal device." fixed the call to internal_dev_get_vport() by first checking that the device is in fact an internal device. However, it also accidentally removed the check ensuring that the vport itself was not NULL. This adds that check back by redoing the previous change in a more robust manner. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-10-05 19:14:21 -07:00
if (!is_internal_dev(netdev))
return NULL;
datapath: Merge vport "attach" into "create" and "detach" into "destroy". These steps are sequentially in lockstep, so we might as well combine them. This expands the region over which the vport_lock is held. I didn't carefully verify that this was OK. This also eliminates the synchronize_rcu() call from destruction of tunnel vports, since they didn't appear to me to need it. It should be possible to eliminate the synchronize_rcu() from the netdev, patch, and internal_dev vports, but this commit does not do that. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-12-03 15:44:51 -08:00
datapath: Don't use RCU for internal dev vport. The vports are now attached and ready to go when they are allocated, so we don't have to worry about future changes. As a result, we can directly store the pointer in the internal dev's netdevice private space before it is registered. The registration process will handle the necessary write memory barriers and anyone who has a reference to the netdev will have done the read side barriers, we don't need to use RCU at all. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-12-08 19:21:40 -08:00
return internal_dev_priv(netdev)->vport;
datapath: Add generic virtual port layer. Currently the datapath directly accesses devices through their Linux functions. Obviously this doesn't work for virtual devices that are not backed by an actual Linux device. This creates a new virtual port layer which handles all interaction with devices. The existing support for Linux devices was then implemented on top of this layer as two device types. It splits out and renames dp_dev to internal_dev. There were several places where datapath devices had to handled in a special manner and this cleans that up by putting all the special casing in a single location.
2010-04-12 15:53:39 -04:00
}
Reference in New Issue Copy Permalink