mir/openvswitch
2
0
Fork 0
mirror of https://github.com/openvswitch/ovs synced 2025-10-19 14:37:21 +00:00
Code Issues Releases Wiki Activity
Files
17e42975c2d42574072925f3743cc64bfd5a8fc1
openvswitch/datapath/vport.c

1330 lines
31 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
/*
* Copyright (c) 2010 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
* kernel, by Linus Torvalds and others.
*/
treewide: Use pr_fmt and pr_<level> Signed-off-by: Joe Perches <joe@perches.com> Acked-by: Simon Horman <horms@verge.net.au> [Jesse: Added missing pr_fmt in vport-gre.c and dp_sysfs_dp.c] Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-08-30 00:24:54 -07:00
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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/dcache.h>
#include <linux/etherdevice.h>
#include <linux/if.h>
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07: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/list.h>
#include <linux/mutex.h>
#include <linux/percpu.h>
#include <linux/rtnetlink.h>
datapath: Add 32-bit compatibility ioctls. When a 32-bit userspace program runs on a 64-bit kernel, data structures that contain members whose sizes or alignments change from 32- to 64-bit must be translated when they are passed to ioctls. This commit adds such support for openvswitch_mod. We should really reconsider some parts of the Open vSwitch ioctl interface to avoid needing as much translation as we do. Lightly tested with 32-bit userspace on sparc64.
2010-05-13 15:25:27 -07:00
#include <linux/compat.h>
datapath: Add support for CAPWAP UDP transport. Add support for the transport portion of the CAPWAP protocol as an alternative to GRE for L2 over L3 tunneling. This is not full support for the CAPWAP protocol. CAPWAP covers management of wireless access points and describes a control protocol for setting those devices up. It also describes a data plane protocol that allows packets to be tunneled to a controller for inspection. This data plane protocol is the only component covered by this commit. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-08-11 20:55:58 -04: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
#include "vport.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-internal_dev.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
vport: Move 'extern' declarations of vports to header. Since vport implementations have no header files they needed to be declared as extern before being used. They are currently declared in vport.c but this isn't safe because the compiler will silently accept it if the type is incorrect. This moves those declarations into vport.h, which is included by all implementations and will cause errors about conflicting types if there is a mismatch.
2010-06-10 13:48:08 -07:00
/* List of statically compiled vport implementations. Don't forget to also
* add yours to the list at the bottom of vport.h. */
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 vport_ops *base_vport_ops_list[] = {
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_vport_ops,
&internal_vport_ops,
datapath: Add 'patch' vport. Adds a new 'patch' vport that acts like a virtual patch cable to connect together two datapaths.
2010-05-10 13:07:28 -07:00
&patch_vport_ops,
tunneling: Add datapath GRE support. Add a new vport type that implements GRE support inside of the datapath instead of relying on Linux devices. This provides greater scalability, performance, and control. The new GRE implementation supports nearly all features of the Linux implementation. It does not currently support multicast, NBMA tunnels, or non-Ethernet devices. This implementation of GRE has several important benefits over the existing Linux implementation. The first is simply that is not a Linux device. Linux devices are fairly heavy weight both in terms of memory consumption and interactions with the rest of the system (notifications, processes polling, etc.). There are many pieces of code that make assumptions about the maximum reasonable number of ports. Simply maintaining the state of several thousand devices is enough to full occupy the CPU. A tighter coupling between the GRE implementation and datapath also allows more flexibility. The key can be set and retrieved from the flow table, which allows even greater scalability. There will probably be additional use cases in the future.
2010-04-17 15:23:31 -04:00
&gre_vport_ops,
datapath: Add support for CAPWAP UDP transport. Add support for the transport portion of the CAPWAP protocol as an alternative to GRE for L2 over L3 tunneling. This is not full support for the CAPWAP protocol. CAPWAP covers management of wireless access points and describes a control protocol for setting those devices up. It also describes a data plane protocol that allows packets to be tunneled to a controller for inspection. This data plane protocol is the only component covered by this commit. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-08-11 20:55:58 -04:00
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,26)
&capwap_vport_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
};
static const struct vport_ops **vport_ops_list;
static int n_vport_types;
static struct hlist_head *dev_table;
#define VPORT_HASH_BUCKETS 1024
/* Both RTNL lock and vport_mutex need to be held when updating dev_table.
*
* If you use vport_locate and then perform some operations, you need to hold
* one of these locks if you don't want the vport to be deleted out from under
* you.
*
* If you get a reference to a vport through a dp_port, it is protected
* by RCU and you need to hold rcu_read_lock instead when reading.
*
* If multiple locks are taken, the hierarchy is:
* 1. RTNL
* 2. DP
* 3. vport
*/
static DEFINE_MUTEX(vport_mutex);
/**
* vport_lock - acquire vport lock
*
* Acquire global vport lock. See above comment about locking requirements
* and specific function definitions. May sleep.
*/
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
void vport_lock(void)
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
{
mutex_lock(&vport_mutex);
}
/**
* vport_unlock - release vport lock
*
* Release lock acquired with vport_lock.
*/
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
void vport_unlock(void)
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
{
mutex_unlock(&vport_mutex);
}
treewide: Use pr_fmt and pr_<level> Signed-off-by: Joe Perches <joe@perches.com> Acked-by: Simon Horman <horms@verge.net.au> [Jesse: Added missing pr_fmt in vport-gre.c and dp_sysfs_dp.c] Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-08-30 00:24:54 -07:00
#define ASSERT_VPORT() \
do { \
if (unlikely(!mutex_is_locked(&vport_mutex))) { \
pr_err("vport lock not held at %s (%d)\n", \
__FILE__, __LINE__); \
dump_stack(); \
} \
} while (0)
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_init - initialize vport subsystem
*
* Called at module load time to initialize the vport subsystem and any
* compiled in vport types.
*/
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 vport_init(void)
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
{
int err;
int i;
dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
GFP_KERNEL);
if (!dev_table) {
err = -ENOMEM;
goto error;
}
vport_ops_list = kmalloc(ARRAY_SIZE(base_vport_ops_list) *
sizeof(struct vport_ops *), GFP_KERNEL);
if (!vport_ops_list) {
err = -ENOMEM;
goto error_dev_table;
}
for (i = 0; i < ARRAY_SIZE(base_vport_ops_list); i++) {
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 *new_ops = base_vport_ops_list[i];
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 (new_ops->init)
err = new_ops->init();
else
err = 0;
if (!err)
vport_ops_list[n_vport_types++] = new_ops;
else if (new_ops->flags & VPORT_F_REQUIRED) {
vport_exit();
goto error;
}
}
return 0;
error_dev_table:
kfree(dev_table);
error:
return err;
}
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 vport_del_all(void)
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
{
int i;
rtnl_lock();
vport_lock();
for (i = 0; i < VPORT_HASH_BUCKETS; i++) {
struct hlist_head *bucket = &dev_table[i];
struct vport *vport;
struct hlist_node *node, *next;
hlist_for_each_entry_safe(vport, node, next, bucket, hash_node)
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
vport_del(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
}
vport_unlock();
rtnl_unlock();
}
/**
* vport_exit - shutdown vport subsystem
*
* Called at module exit time to shutdown the vport subsystem and any
* initialized vport types.
*/
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
void vport_exit(void)
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
{
int i;
vport_del_all();
for (i = 0; i < n_vport_types; i++) {
if (vport_ops_list[i]->exit)
vport_ops_list[i]->exit();
}
kfree(vport_ops_list);
kfree(dev_table);
}
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 do_vport_add(struct odp_vport_add *vport_config)
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;
int err = 0;
datapath: Prepare to support 32-bit compatibility ioctls. This commit prepares the core of datapath.c and vport.c to reduce the amount of new code duplication when the following commit adds support for 32-bit compatibility ioctls. It breaks a number of functions apart into pairs of functions: one that copies data to and from userspace and another that does the real work. This change is a pure refactoring that should not change behavior.
2010-05-13 13:21:33 -07:00
vport_config->port_type[VPORT_TYPE_SIZE - 1] = '\0';
vport_config->devname[IFNAMSIZ - 1] = '\0';
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
rtnl_lock();
datapath: Prepare to support 32-bit compatibility ioctls. This commit prepares the core of datapath.c and vport.c to reduce the amount of new code duplication when the following commit adds support for 32-bit compatibility ioctls. It breaks a number of functions apart into pairs of functions: one that copies data to and from userspace and another that does the real work. This change is a pure refactoring that should not change behavior.
2010-05-13 13:21:33 -07:00
vport = vport_locate(vport_config->devname);
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 (vport) {
vport: Use EBUSY to represent already attached device. We currently use EEXIST to represent both a device that is already attached and for GRE devices that are the same as another one. Instead use EBUSY for already attached devices to disambiguate the two situations.
2010-07-14 19:02:10 -07:00
err = -EBUSY;
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
goto out;
}
vport_lock();
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
vport = vport_add(vport_config->devname, vport_config->port_type,
vport_config->config);
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_unlock();
if (IS_ERR(vport))
err = PTR_ERR(vport);
out:
rtnl_unlock();
return err;
}
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
/**
* vport_user_add - add vport device (for userspace callers)
*
* @uvport_config: New port configuration.
*
* Creates a new vport with the specified configuration (which is dependent
* on device type). This function is for userspace callers and assumes no
* locks are held.
*/
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 vport_user_add(const struct odp_vport_add __user *uvport_config)
datapath: Prepare to support 32-bit compatibility ioctls. This commit prepares the core of datapath.c and vport.c to reduce the amount of new code duplication when the following commit adds support for 32-bit compatibility ioctls. It breaks a number of functions apart into pairs of functions: one that copies data to and from userspace and another that does the real work. This change is a pure refactoring that should not change behavior.
2010-05-13 13:21:33 -07:00
{
struct odp_vport_add vport_config;
if (copy_from_user(&vport_config, uvport_config, sizeof(struct odp_vport_add)))
return -EFAULT;
return do_vport_add(&vport_config);
}
datapath: Add 32-bit compatibility ioctls. When a 32-bit userspace program runs on a 64-bit kernel, data structures that contain members whose sizes or alignments change from 32- to 64-bit must be translated when they are passed to ioctls. This commit adds such support for openvswitch_mod. We should really reconsider some parts of the Open vSwitch ioctl interface to avoid needing as much translation as we do. Lightly tested with 32-bit userspace on sparc64.
2010-05-13 15:25:27 -07:00
#ifdef CONFIG_COMPAT
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 compat_vport_user_add(struct compat_odp_vport_add *ucompat)
datapath: Add 32-bit compatibility ioctls. When a 32-bit userspace program runs on a 64-bit kernel, data structures that contain members whose sizes or alignments change from 32- to 64-bit must be translated when they are passed to ioctls. This commit adds such support for openvswitch_mod. We should really reconsider some parts of the Open vSwitch ioctl interface to avoid needing as much translation as we do. Lightly tested with 32-bit userspace on sparc64.
2010-05-13 15:25:27 -07:00
{
struct compat_odp_vport_add compat;
struct odp_vport_add vport_config;
if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_add)))
return -EFAULT;
memcpy(vport_config.port_type, compat.port_type, VPORT_TYPE_SIZE);
memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
vport_config.config = compat_ptr(compat.config);
return do_vport_add(&vport_config);
}
#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 int do_vport_mod(struct odp_vport_mod *vport_config)
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;
int err;
datapath: Prepare to support 32-bit compatibility ioctls. This commit prepares the core of datapath.c and vport.c to reduce the amount of new code duplication when the following commit adds support for 32-bit compatibility ioctls. It breaks a number of functions apart into pairs of functions: one that copies data to and from userspace and another that does the real work. This change is a pure refactoring that should not change behavior.
2010-05-13 13:21:33 -07:00
vport_config->devname[IFNAMSIZ - 1] = '\0';
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
rtnl_lock();
datapath: Prepare to support 32-bit compatibility ioctls. This commit prepares the core of datapath.c and vport.c to reduce the amount of new code duplication when the following commit adds support for 32-bit compatibility ioctls. It breaks a number of functions apart into pairs of functions: one that copies data to and from userspace and another that does the real work. This change is a pure refactoring that should not change behavior.
2010-05-13 13:21:33 -07:00
vport = vport_locate(vport_config->devname);
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 (!vport) {
err = -ENODEV;
goto out;
}
vport_lock();
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
err = vport_mod(vport, vport_config->config);
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_unlock();
out:
rtnl_unlock();
return err;
}
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
/**
* vport_user_mod - modify existing vport device (for userspace callers)
*
* @uvport_config: New configuration for vport
*
* Modifies an existing device with the specified configuration (which is
* dependent on device type). This function is for userspace callers and
* assumes no locks are held.
*/
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 vport_user_mod(const struct odp_vport_mod __user *uvport_config)
datapath: Prepare to support 32-bit compatibility ioctls. This commit prepares the core of datapath.c and vport.c to reduce the amount of new code duplication when the following commit adds support for 32-bit compatibility ioctls. It breaks a number of functions apart into pairs of functions: one that copies data to and from userspace and another that does the real work. This change is a pure refactoring that should not change behavior.
2010-05-13 13:21:33 -07:00
{
struct odp_vport_mod vport_config;
if (copy_from_user(&vport_config, uvport_config, sizeof(struct odp_vport_mod)))
return -EFAULT;
return do_vport_mod(&vport_config);
}
datapath: Add 32-bit compatibility ioctls. When a 32-bit userspace program runs on a 64-bit kernel, data structures that contain members whose sizes or alignments change from 32- to 64-bit must be translated when they are passed to ioctls. This commit adds such support for openvswitch_mod. We should really reconsider some parts of the Open vSwitch ioctl interface to avoid needing as much translation as we do. Lightly tested with 32-bit userspace on sparc64.
2010-05-13 15:25:27 -07:00
#ifdef CONFIG_COMPAT
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 compat_vport_user_mod(struct compat_odp_vport_mod *ucompat)
datapath: Add 32-bit compatibility ioctls. When a 32-bit userspace program runs on a 64-bit kernel, data structures that contain members whose sizes or alignments change from 32- to 64-bit must be translated when they are passed to ioctls. This commit adds such support for openvswitch_mod. We should really reconsider some parts of the Open vSwitch ioctl interface to avoid needing as much translation as we do. Lightly tested with 32-bit userspace on sparc64.
2010-05-13 15:25:27 -07:00
{
struct compat_odp_vport_mod compat;
struct odp_vport_mod vport_config;
if (copy_from_user(&compat, ucompat, sizeof(struct compat_odp_vport_mod)))
return -EFAULT;
memcpy(vport_config.devname, compat.devname, IFNAMSIZ);
vport_config.config = compat_ptr(compat.config);
return do_vport_mod(&vport_config);
}
#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
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_user_del - delete existing vport device (for userspace callers)
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
*
* @udevname: Name of device to delete
*
* Deletes the specified device. Detaches the device from a datapath first
* if it is attached. Deleting the device will fail if it does not exist or it
* is the datapath local port. It is also possible to fail for less obvious
* reasons, such as lack of memory. This function is for userspace callers and
* assumes no locks are held.
*/
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 vport_user_del(const char __user *udevname)
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
{
char devname[IFNAMSIZ];
struct vport *vport;
struct dp_port *dp_port;
int err = 0;
vport: Better handle too-long network device names in vport_del(). The 'count' argument to strncpy_from_user() is supposed to include space for the null terminator, so add it in. Also, refuse names that have more than IFNAMSIZ-1 characters outright, instead of truncating them.
2010-04-27 12:41:11 -07:00
int retval;
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: Better handle too-long network device names in vport_del(). The 'count' argument to strncpy_from_user() is supposed to include space for the null terminator, so add it in. Also, refuse names that have more than IFNAMSIZ-1 characters outright, instead of truncating them.
2010-04-27 12:41:11 -07:00
retval = strncpy_from_user(devname, udevname, IFNAMSIZ);
if (retval < 0)
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 -EFAULT;
vport: Better handle too-long network device names in vport_del(). The 'count' argument to strncpy_from_user() is supposed to include space for the null terminator, so add it in. Also, refuse names that have more than IFNAMSIZ-1 characters outright, instead of truncating them.
2010-04-27 12:41:11 -07:00
else if (retval >= IFNAMSIZ)
return -ENAMETOOLONG;
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
rtnl_lock();
vport = vport_locate(devname);
if (!vport) {
err = -ENODEV;
goto out;
}
dp_port = vport_get_dp_port(vport);
if (dp_port) {
struct datapath *dp = dp_port->dp;
mutex_lock(&dp->mutex);
if (!strcmp(dp_name(dp), devname)) {
err = -EINVAL;
goto dp_port_out;
}
err = dp_detach_port(dp_port, 0);
dp_port_out:
mutex_unlock(&dp->mutex);
if (err)
goto out;
}
vport_lock();
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
err = vport_del(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
vport_unlock();
out:
rtnl_unlock();
return err;
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_user_stats_get - retrieve device stats (for userspace callers)
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
*
* @ustats_req: Stats request parameters.
*
* Retrieves transmit, receive, and error stats for the given device. This
* function is for userspace callers and assumes no locks are held.
*/
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 vport_user_stats_get(struct odp_vport_stats_req __user *ustats_req)
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 odp_vport_stats_req stats_req;
struct vport *vport;
int err;
if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
return -EFAULT;
stats_req.devname[IFNAMSIZ - 1] = '\0';
vport_lock();
vport = vport_locate(stats_req.devname);
if (!vport) {
err = -ENODEV;
goto out;
}
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
err = vport_get_stats(vport, &stats_req.stats);
datapath: Hold rcu_read_lock where we claim to. Many of the vport operations require that either RTNL lock or rcu_read_lock be held. However, operations from userspace often hold a different lock so grab rcu_read_lock as well.
2010-05-12 13:45:49 -07:00
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
out:
vport_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
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
if (!err)
if (copy_to_user(ustats_req, &stats_req, sizeof(struct odp_vport_stats_req)))
err = -EFAULT;
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: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
return err;
}
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: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
/**
* vport_user_stats_set - sets offset device stats (for userspace callers)
*
* @ustats_req: Stats set parameters.
*
* Provides a set of transmit, receive, and error stats to be added as an
* offset to the collect data when stats are retreived. Some devices may not
* support setting the stats, in which case the result will always be
* -EOPNOTSUPP. This function is for userspace callers and assumes no locks
* are held.
*/
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 vport_user_stats_set(struct odp_vport_stats_req __user *ustats_req)
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
{
struct odp_vport_stats_req stats_req;
struct vport *vport;
int err;
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: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
if (copy_from_user(&stats_req, ustats_req, sizeof(struct odp_vport_stats_req)))
return -EFAULT;
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: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
stats_req.devname[IFNAMSIZ - 1] = '\0';
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: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
rtnl_lock();
vport_lock();
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: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
vport = vport_locate(stats_req.devname);
if (!vport) {
err = -ENODEV;
goto out;
}
err = vport_set_stats(vport, &stats_req.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
out:
vport_unlock();
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
rtnl_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 err;
}
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -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
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_user_ether_get - retrieve device Ethernet address (for userspace callers)
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
*
* @uvport_ether: Ethernet address request parameters.
*
* Retrieves the Ethernet address of the given device. This function is for
* userspace callers and assumes no locks are held.
*/
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 vport_user_ether_get(struct odp_vport_ether __user *uvport_ether)
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 odp_vport_ether vport_ether;
struct vport *vport;
int err = 0;
if (copy_from_user(&vport_ether, uvport_ether, sizeof(struct odp_vport_ether)))
return -EFAULT;
vport_ether.devname[IFNAMSIZ - 1] = '\0';
vport_lock();
vport = vport_locate(vport_ether.devname);
if (!vport) {
err = -ENODEV;
goto out;
}
datapath: Hold rcu_read_lock where we claim to. Many of the vport operations require that either RTNL lock or rcu_read_lock be held. However, operations from userspace often hold a different lock so grab rcu_read_lock as well.
2010-05-12 13:45:49 -07:00
rcu_read_lock();
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
memcpy(vport_ether.ether_addr, vport_get_addr(vport), ETH_ALEN);
datapath: Hold rcu_read_lock where we claim to. Many of the vport operations require that either RTNL lock or rcu_read_lock be held. However, operations from userspace often hold a different lock so grab rcu_read_lock as well.
2010-05-12 13:45:49 -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
out:
vport_unlock();
if (!err)
if (copy_to_user(uvport_ether, &vport_ether, sizeof(struct odp_vport_ether)))
err = -EFAULT;
return err;
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_user_ether_set - set device Ethernet address (for userspace callers)
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
*
* @uvport_ether: Ethernet address request parameters.
*
* Sets the Ethernet address of the given device. Some devices may not support
* setting the Ethernet address, in which case the result will always be
* -EOPNOTSUPP. This function is for userspace callers and assumes no locks
* are held.
*/
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 vport_user_ether_set(struct odp_vport_ether __user *uvport_ether)
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 odp_vport_ether vport_ether;
struct vport *vport;
int err;
if (copy_from_user(&vport_ether, uvport_ether, sizeof(struct odp_vport_ether)))
return -EFAULT;
vport_ether.devname[IFNAMSIZ - 1] = '\0';
rtnl_lock();
vport_lock();
vport = vport_locate(vport_ether.devname);
if (!vport) {
err = -ENODEV;
goto out;
}
err = vport_set_addr(vport, vport_ether.ether_addr);
out:
vport_unlock();
rtnl_unlock();
return err;
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_user_mtu_get - retrieve device MTU (for userspace callers)
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
*
* @uvport_mtu: MTU request parameters.
*
* Retrieves the MTU of the given device. This function is for userspace
* callers and assumes no locks are held.
*/
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 vport_user_mtu_get(struct odp_vport_mtu __user *uvport_mtu)
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 odp_vport_mtu vport_mtu;
struct vport *vport;
int err = 0;
if (copy_from_user(&vport_mtu, uvport_mtu, sizeof(struct odp_vport_mtu)))
return -EFAULT;
vport_mtu.devname[IFNAMSIZ - 1] = '\0';
vport_lock();
vport = vport_locate(vport_mtu.devname);
if (!vport) {
err = -ENODEV;
goto out;
}
vport_mtu.mtu = vport_get_mtu(vport);
out:
vport_unlock();
if (!err)
if (copy_to_user(uvport_mtu, &vport_mtu, sizeof(struct odp_vport_mtu)))
err = -EFAULT;
return err;
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_user_mtu_set - set device MTU (for userspace callers)
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
*
* @uvport_mtu: MTU request parameters.
*
* Sets the MTU of the given device. Some devices may not support setting the
* MTU, in which case the result will always be -EOPNOTSUPP. This function is
* for userspace callers and assumes no locks are held.
*/
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 vport_user_mtu_set(struct odp_vport_mtu __user *uvport_mtu)
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 odp_vport_mtu vport_mtu;
struct vport *vport;
int err;
if (copy_from_user(&vport_mtu, uvport_mtu, sizeof(struct odp_vport_mtu)))
return -EFAULT;
vport_mtu.devname[IFNAMSIZ - 1] = '\0';
rtnl_lock();
vport_lock();
vport = vport_locate(vport_mtu.devname);
if (!vport) {
err = -ENODEV;
goto out;
}
err = vport_set_mtu(vport, vport_mtu.mtu);
out:
vport_unlock();
rtnl_unlock();
return err;
}
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 struct hlist_head *hash_bucket(const char *name)
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
{
unsigned int hash = full_name_hash(name, strlen(name));
return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
}
/**
* vport_locate - find a port that has already been created
*
* @name: name of port to find
*
* Either RTNL or vport lock must be acquired before calling this function
* and held while using the found port. See the locking comments at the
* top of the file.
*/
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 *vport_locate(const char *name)
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 hlist_head *bucket = hash_bucket(name);
struct vport *vport;
struct hlist_node *node;
if (unlikely(!mutex_is_locked(&vport_mutex) && !rtnl_is_locked())) {
treewide: Use pr_fmt and pr_<level> Signed-off-by: Joe Perches <joe@perches.com> Acked-by: Simon Horman <horms@verge.net.au> [Jesse: Added missing pr_fmt in vport-gre.c and dp_sysfs_dp.c] Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-08-30 00:24:54 -07:00
pr_err("neither RTNL nor vport lock held in vport_locate\n");
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
dump_stack();
}
datapath: Hold rcu_read_lock where we claim to. Many of the vport operations require that either RTNL lock or rcu_read_lock be held. However, operations from userspace often hold a different lock so grab rcu_read_lock as well.
2010-05-12 13:45:49 -07:00
rcu_read_lock();
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
hlist_for_each_entry(vport, node, bucket, hash_node)
if (!strcmp(name, vport_get_name(vport)))
datapath: Hold rcu_read_lock where we claim to. Many of the vport operations require that either RTNL lock or rcu_read_lock be held. However, operations from userspace often hold a different lock so grab rcu_read_lock as well.
2010-05-12 13:45:49 -07:00
goto out;
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: Hold rcu_read_lock where we claim to. Many of the vport operations require that either RTNL lock or rcu_read_lock be held. However, operations from userspace often hold a different lock so grab rcu_read_lock as well.
2010-05-12 13:45:49 -07:00
vport = NULL;
out:
rcu_read_unlock();
return 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
}
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 register_vport(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
{
hlist_add_head(&vport->hash_node, hash_bucket(vport_get_name(vport)));
}
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 unregister_vport(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
{
hlist_del(&vport->hash_node);
}
/**
* vport_alloc - allocate and initialize new vport
*
* @priv_size: Size of private data area to allocate.
* @ops: vport device ops
*
* Allocate and initialize a new vport defined by @ops. The vport will contain
* a private data area of size @priv_size that can be accessed using
* vport_priv(). vports that are no longer needed should be released with
* vport_free().
*/
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 *vport_alloc(int priv_size, const struct vport_ops *ops)
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;
size_t alloc_size;
alloc_size = sizeof(struct vport);
if (priv_size) {
alloc_size = ALIGN(alloc_size, VPORT_ALIGN);
alloc_size += priv_size;
}
vport = kzalloc(alloc_size, GFP_KERNEL);
if (!vport)
return ERR_PTR(-ENOMEM);
vport->ops = ops;
if (vport->ops->flags & VPORT_F_GEN_STATS) {
vport->percpu_stats = alloc_percpu(struct vport_percpu_stats);
if (!vport->percpu_stats)
return ERR_PTR(-ENOMEM);
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
spin_lock_init(&vport->stats_lock);
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;
}
/**
* vport_free - uninitialize and free vport
*
* @vport: vport to free
*
* Frees a vport allocated with vport_alloc() when it is no longer needed.
*/
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
void vport_free(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
{
if (vport->ops->flags & VPORT_F_GEN_STATS)
free_percpu(vport->percpu_stats);
kfree(vport);
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_add - add vport device (for kernel callers)
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
*
* @name: Name of new device.
* @type: Type of new device (to be matched against types in registered vport
* ops).
* @config: Device type specific configuration. Userspace pointer.
*
* Creates a new vport with the specified configuration (which is dependent
* on device type). Both RTNL and vport locks must be held.
*/
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 *vport_add(const char *name, const char *type, const void __user *config)
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;
int err = 0;
int i;
ASSERT_RTNL();
ASSERT_VPORT();
for (i = 0; i < n_vport_types; i++) {
if (!strcmp(vport_ops_list[i]->type, type)) {
vport = vport_ops_list[i]->create(name, config);
if (IS_ERR(vport)) {
err = PTR_ERR(vport);
goto out;
}
register_vport(vport);
return vport;
}
}
err = -EAFNOSUPPORT;
out:
return ERR_PTR(err);
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_mod - modify existing vport device (for kernel callers)
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: vport to modify.
* @config: Device type specific configuration. Userspace pointer.
*
* Modifies an existing device with the specified configuration (which is
* dependent on device type). Both RTNL and vport locks must be held.
*/
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 vport_mod(struct vport *vport, const void __user *config)
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
{
ASSERT_RTNL();
ASSERT_VPORT();
if (vport->ops->modify)
return vport->ops->modify(vport, config);
else
return -EOPNOTSUPP;
}
/**
vport: Rename userspace functions. The vport library can be accessed from both userspace and the kernel using different sets of functions. These functions were named similarly, so add _user to the userspace variants to distinguish them.
2010-05-28 18:09:27 -07:00
* vport_del - delete existing vport device (for kernel callers)
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: vport to delete.
*
* Deletes the specified device. The device must not be currently attached to
* a datapath. It is possible to fail for reasons such as lack of memory.
* Both RTNL and vport locks must be held.
*/
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 vport_del(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
{
ASSERT_RTNL();
ASSERT_VPORT();
BUG_ON(vport_get_dp_port(vport));
unregister_vport(vport);
return vport->ops->destroy(vport);
}
/**
* vport_attach - attach a vport to a datapath
*
* @vport: vport to attach.
* @dp_port: Datapath port to attach the vport to.
*
* Attaches a vport to a specific datapath so that packets may be exchanged.
* Both ports must be currently unattached. @dp_port must be successfully
* attached to a vport before it is connected to a datapath and must not be
* modified while connected. RTNL lock and the appropriate DP mutex must be held.
*/
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 vport_attach(struct vport *vport, struct dp_port *dp_port)
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
{
ASSERT_RTNL();
if (vport_get_dp_port(vport))
return -EBUSY;
if (vport->ops->attach) {
int err;
err = vport->ops->attach(vport);
if (err)
return err;
}
rcu_assign_pointer(vport->dp_port, dp_port);
return 0;
}
/**
* vport_detach - detach a vport from a datapath
*
* @vport: vport to detach.
*
* Detaches a vport from a datapath. May fail for a variety of reasons,
* including lack of memory. RTNL lock and the appropriate DP mutex must be held.
*/
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 vport_detach(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 dp_port *dp_port;
ASSERT_RTNL();
dp_port = vport_get_dp_port(vport);
if (!dp_port)
return -EINVAL;
rcu_assign_pointer(vport->dp_port, NULL);
if (vport->ops->detach)
return vport->ops->detach(vport);
else
return 0;
}
/**
* vport_set_mtu - set device MTU (for kernel callers)
*
* @vport: vport on which to set MTU.
* @mtu: New MTU.
*
* Sets the MTU of the given device. Some devices may not support setting the
* MTU, in which case the result will always be -EOPNOTSUPP. RTNL lock must
* be held.
*/
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 vport_set_mtu(struct vport *vport, int mtu)
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
{
ASSERT_RTNL();
if (mtu < 68)
return -EINVAL;
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
if (vport->ops->set_mtu) {
int ret;
ret = vport->ops->set_mtu(vport, mtu);
if (!ret && !is_internal_vport(vport)) {
struct dp_port *dp_port = vport_get_dp_port(vport);
if (dp_port)
set_internal_devs_mtu(dp_port->dp);
}
return ret;
} else
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;
}
/**
* vport_set_addr - set device Ethernet address (for kernel callers)
*
* @vport: vport on which to set Ethernet address.
* @addr: New address.
*
* Sets the Ethernet address of the given device. Some devices may not support
* setting the Ethernet address, in which case the result will always be
* -EOPNOTSUPP. RTNL lock must be held.
*/
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 vport_set_addr(struct vport *vport, const unsigned char *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
{
ASSERT_RTNL();
if (!is_valid_ether_addr(addr))
return -EADDRNOTAVAIL;
if (vport->ops->set_addr)
return vport->ops->set_addr(vport, addr);
else
return -EOPNOTSUPP;
}
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
/**
* vport_set_stats - sets offset device stats (for kernel callers)
*
* @vport: vport on which to set stats
* @stats: stats to set
*
* Provides a set of transmit, receive, and error stats to be added as an
* offset to the collect data when stats are retreived. Some devices may not
* support setting the stats, in which case the result will always be
* -EOPNOTSUPP. RTNL lock must be held.
*/
datapath: Use "struct rtnl_link_stats64" instead of "struct odp_vport_stats". Linux 2.6.35 added struct rtnl_link_stats64, which as a set of 64-bit network device counters is what the OVS datapath needs. We might as well use it instead of our own. This commit moves the if_link.h compat header from datapath/ into the top-level include/ directory so that it is visible both to kernel and userspace code. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-09 13:48:57 -08:00
int vport_set_stats(struct vport *vport, struct rtnl_link_stats64 *stats)
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
{
ASSERT_RTNL();
if (vport->ops->flags & VPORT_F_GEN_STATS) {
spin_lock_bh(&vport->stats_lock);
datapath: Use struct assignment in place of memcpy() for copying stats. We might as well take advantage of type safety when we can get it. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-04 13:49:19 -07:00
vport->offset_stats = *stats;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
spin_unlock_bh(&vport->stats_lock);
return 0;
} else if (vport->ops->set_stats)
return vport->ops->set_stats(vport, stats);
else
return -EOPNOTSUPP;
}
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_get_name - retrieve device name
*
* @vport: vport from which to retrieve the name.
*
* Retrieves the name of the given device. Either RTNL lock or rcu_read_lock
* must be held for the entire duration that the name is in use.
*/
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
const char *vport_get_name(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->get_name(vport);
}
/**
* vport_get_type - retrieve device type
*
* @vport: vport from which to retrieve the type.
*
* Retrieves the type of the given device. Either RTNL lock or rcu_read_lock
* must be held for the entire duration that the type is in use.
*/
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
const char *vport_get_type(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->type;
}
/**
* vport_get_addr - retrieve device Ethernet address (for kernel callers)
*
* @vport: vport from which to retrieve the Ethernet address.
*
* Retrieves the Ethernet address of the given device. Either RTNL lock or
* rcu_read_lock must be held for the entire duration that the Ethernet address
* is in use.
*/
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
const unsigned char *vport_get_addr(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->get_addr(vport);
}
/**
* vport_get_dp_port - retrieve attached datapath port
*
* @vport: vport from which to retrieve the datapath port.
*
* Retrieves the attached datapath port or null if not attached. Either RTNL
* lock or rcu_read_lock must be held for the entire duration that the datapath
* port is being accessed.
*/
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 dp_port *vport_get_dp_port(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 rcu_dereference(vport->dp_port);
}
/**
* vport_get_kobj - retrieve associated kobj
*
* @vport: vport from which to retrieve the associated kobj
*
* Retrieves the associated kobj or null if no kobj. The returned kobj is
* valid for as long as the vport exists.
*/
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 kobject *vport_get_kobj(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
{
if (vport->ops->get_kobj)
return vport->ops->get_kobj(vport);
else
return NULL;
}
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
/**
* vport_get_stats - retrieve device stats (for kernel callers)
*
* @vport: vport from which to retrieve the stats
* @stats: location to store stats
*
* Retrieves transmit, receive, and error stats for the given device.
*/
datapath: Use "struct rtnl_link_stats64" instead of "struct odp_vport_stats". Linux 2.6.35 added struct rtnl_link_stats64, which as a set of 64-bit network device counters is what the OVS datapath needs. We might as well use it instead of our own. This commit moves the if_link.h compat header from datapath/ into the top-level include/ directory so that it is visible both to kernel and userspace code. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-09 13:48:57 -08:00
int vport_get_stats(struct vport *vport, struct rtnl_link_stats64 *stats)
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
{
datapath: Use "struct rtnl_link_stats64" instead of "struct odp_vport_stats". Linux 2.6.35 added struct rtnl_link_stats64, which as a set of 64-bit network device counters is what the OVS datapath needs. We might as well use it instead of our own. This commit moves the if_link.h compat header from datapath/ into the top-level include/ directory so that it is visible both to kernel and userspace code. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-09 13:48:57 -08:00
struct rtnl_link_stats64 dev_stats;
struct rtnl_link_stats64 *dev_statsp = NULL;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
int err;
if (vport->ops->get_stats) {
if (vport->ops->flags & VPORT_F_GEN_STATS)
dev_statsp = &dev_stats;
else
dev_statsp = stats;
rcu_read_lock();
err = vport->ops->get_stats(vport, dev_statsp);
rcu_read_unlock();
if (err)
goto out;
}
if (vport->ops->flags & VPORT_F_GEN_STATS) {
int i;
/* We potentially have 3 sources of stats that need to be
* combined: those we have collected (split into err_stats and
* percpu_stats), offset_stats from set_stats(), and device
* error stats from get_stats() (for errors that happen
* downstream and therefore aren't reported through our
* vport_record_error() function). */
spin_lock_bh(&vport->stats_lock);
datapath: Use struct assignment in place of memcpy() for copying stats. We might as well take advantage of type safety when we can get it. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-04 13:49:19 -07:00
*stats = vport->offset_stats;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
vport: Remove unused error types. We currently track rx_over_errors, rx_crc_errors, rx_frame_errors, and collisions but never increment these counters. It seems likely that we will never use them since they are primarily hardware errors and we pull hardware stats directly from the NIC. This removes those counters, saving 32 bytes per port. Signed-off-by: Jesse Gross <jesse@nicira.com> Acked-by: Ben Pfaff <blp@nicira.com>
2010-11-19 13:49:54 -08:00
stats->rx_errors += vport->err_stats.rx_errors;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
stats->tx_errors += vport->err_stats.tx_errors;
stats->tx_dropped += vport->err_stats.tx_dropped;
stats->rx_dropped += vport->err_stats.rx_dropped;
spin_unlock_bh(&vport->stats_lock);
if (dev_statsp) {
datapath: Use "struct rtnl_link_stats64" instead of "struct odp_vport_stats". Linux 2.6.35 added struct rtnl_link_stats64, which as a set of 64-bit network device counters is what the OVS datapath needs. We might as well use it instead of our own. This commit moves the if_link.h compat header from datapath/ into the top-level include/ directory so that it is visible both to kernel and userspace code. Signed-off-by: Ben Pfaff <blp@nicira.com> Acked-by: Jesse Gross <jesse@nicira.com>
2010-11-09 13:48:57 -08:00
stats->rx_packets += dev_statsp->rx_packets;
stats->tx_packets += dev_statsp->tx_packets;
stats->rx_bytes += dev_statsp->rx_bytes;
stats->tx_bytes += dev_statsp->tx_bytes;
stats->rx_errors += dev_statsp->rx_errors;
stats->tx_errors += dev_statsp->tx_errors;
stats->rx_dropped += dev_statsp->rx_dropped;
stats->tx_dropped += dev_statsp->tx_dropped;
stats->multicast += dev_statsp->multicast;
stats->collisions += dev_statsp->collisions;
stats->rx_length_errors += dev_statsp->rx_length_errors;
stats->rx_over_errors += dev_statsp->rx_over_errors;
stats->rx_crc_errors += dev_statsp->rx_crc_errors;
stats->rx_frame_errors += dev_statsp->rx_frame_errors;
stats->rx_fifo_errors += dev_statsp->rx_fifo_errors;
stats->rx_missed_errors += dev_statsp->rx_missed_errors;
stats->tx_aborted_errors += dev_statsp->tx_aborted_errors;
stats->tx_carrier_errors += dev_statsp->tx_carrier_errors;
stats->tx_fifo_errors += dev_statsp->tx_fifo_errors;
stats->tx_heartbeat_errors += dev_statsp->tx_heartbeat_errors;
stats->tx_window_errors += dev_statsp->tx_window_errors;
stats->rx_compressed += dev_statsp->rx_compressed;
stats->tx_compressed += dev_statsp->tx_compressed;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
}
for_each_possible_cpu(i) {
const struct vport_percpu_stats *percpu_stats;
datpath: Avoid reporting half updated statistics. We enforce mutual exclusion when updating statistics by disabling bottom halves and only writing to per-CPU state. However, reading requires looking at the statistics for foreign CPUs, which could be in the process of updating them since there isn't a lock. This means we could get garbage values for 64-bit values on 32-bit machines or byte counts that don't correspond to packet counts, etc. This commit introduces a sequence lock for statistics values to avoid this problem. Getting a write lock is very cheap - it only requires incrementing a counter plus a memory barrier (which is compiled away on x86) to acquire or release the lock and will never block. On read we spin until the sequence number hasn't changed in the middle of the operation, indicating that the we have a consistent set of values. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-07-28 18:20:43 -07:00
struct vport_percpu_stats local_stats;
unsigned seqcount;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
datpath: Avoid reporting half updated statistics. We enforce mutual exclusion when updating statistics by disabling bottom halves and only writing to per-CPU state. However, reading requires looking at the statistics for foreign CPUs, which could be in the process of updating them since there isn't a lock. This means we could get garbage values for 64-bit values on 32-bit machines or byte counts that don't correspond to packet counts, etc. This commit introduces a sequence lock for statistics values to avoid this problem. Getting a write lock is very cheap - it only requires incrementing a counter plus a memory barrier (which is compiled away on x86) to acquire or release the lock and will never block. On read we spin until the sequence number hasn't changed in the middle of the operation, indicating that the we have a consistent set of values. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-07-28 18:20:43 -07:00
do {
seqcount = read_seqcount_begin(&percpu_stats->seqlock);
local_stats = *percpu_stats;
} while (read_seqcount_retry(&percpu_stats->seqlock, seqcount));
stats->rx_bytes += local_stats.rx_bytes;
stats->rx_packets += local_stats.rx_packets;
stats->tx_bytes += local_stats.tx_bytes;
stats->tx_packets += local_stats.tx_packets;
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
}
err = 0;
} else
err = -EOPNOTSUPP;
out:
return err;
}
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_get_flags - retrieve device flags
*
* @vport: vport from which to retrieve the flags
*
* Retrieves the flags of the given device. Either RTNL lock or rcu_read_lock
* must be held.
*/
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
unsigned vport_get_flags(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->get_dev_flags(vport);
}
/**
* vport_get_flags - check whether device is running
*
* @vport: vport on which to check status.
*
* Checks whether the given device is running. Either RTNL lock or
* rcu_read_lock must be held.
*/
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 vport_is_running(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->is_running(vport);
}
/**
* vport_get_flags - retrieve device operating state
*
* @vport: vport from which to check status
*
* Retrieves the RFC2863 operstate of the given device. Either RTNL lock or
* rcu_read_lock must be held.
*/
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
unsigned char vport_get_operstate(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->get_operstate(vport);
}
/**
* vport_get_ifindex - retrieve device system interface index
*
* @vport: vport from which to retrieve index
*
* Retrieves the system interface index of the given device. Not all devices
* will have system indexes, in which case the index of the datapath local
* port is returned. Returns a negative index on error. Either RTNL lock or
* rcu_read_lock must be held.
*/
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 vport_get_ifindex(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
{
const struct dp_port *dp_port;
if (vport->ops->get_ifindex)
return vport->ops->get_ifindex(vport);
/* If we don't actually have an ifindex, use the local port's.
* Userspace doesn't check it anyways. */
dp_port = vport_get_dp_port(vport);
if (!dp_port)
return -EAGAIN;
return vport_get_ifindex(dp_port->dp->ports[ODPP_LOCAL]->vport);
}
/**
* vport_get_iflink - retrieve device system link index
*
* @vport: vport from which to retrieve index
*
* Retrieves the system link index of the given device. The link is the index
* of the interface on which the packet will actually be sent. In most cases
* this is the same as the ifindex but may be different for tunnel devices.
* Returns a negative index on error. Either RTNL lock or rcu_read_lock must
* be held.
*/
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 vport_get_iflink(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
{
if (vport->ops->get_iflink)
return vport->ops->get_iflink(vport);
/* If we don't have an iflink, use the ifindex. In most cases they
* are the same. */
return vport_get_ifindex(vport);
}
/**
* vport_get_mtu - retrieve device MTU (for kernel callers)
*
* @vport: vport from which to retrieve MTU
*
* Retrieves the MTU of the given device. Either RTNL lock or rcu_read_lock
* must be held.
*/
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 vport_get_mtu(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->get_mtu(vport);
}
/**
* vport_receive - pass up received packet to the datapath for processing
*
* @vport: vport that received the packet
* @skb: skb that was received
*
datapath: Don't expect bottom-halves to be disabled. We currently document that BHs need to be disabled when handling received packets. However, this isn't actually generally the case (usually preemption is disabled but not BHs). Only one place actually relies on BHs being disabled so fix that and update the documentation of our expectations.
2010-05-12 12:40:45 -07:00
* Must be called with rcu_read_lock. The packet cannot be shared and
* skb->data should point to the Ethernet header. The caller must have already
* called compute_ip_summed() to initialize the checksumming fields.
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
void vport_receive(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 dp_port *dp_port = vport_get_dp_port(vport);
vport: Record and free packets on unattached ports. We throw away packets that are received on vports not attached to a datapath but we are actually leaking them. This records that an error took place and frees the skb.
2010-05-10 16:16:33 -07:00
if (!dp_port) {
vport_record_error(vport, VPORT_E_RX_DROPPED);
kfree_skb(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
return;
vport: Record and free packets on unattached ports. We throw away packets that are received on vports not attached to a datapath but we are actually leaking them. This records that an error took place and frees the skb.
2010-05-10 16:16:33 -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
if (vport->ops->flags & VPORT_F_GEN_STATS) {
struct vport_percpu_stats *stats;
local_bh_disable();
stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
datpath: Avoid reporting half updated statistics. We enforce mutual exclusion when updating statistics by disabling bottom halves and only writing to per-CPU state. However, reading requires looking at the statistics for foreign CPUs, which could be in the process of updating them since there isn't a lock. This means we could get garbage values for 64-bit values on 32-bit machines or byte counts that don't correspond to packet counts, etc. This commit introduces a sequence lock for statistics values to avoid this problem. Getting a write lock is very cheap - it only requires incrementing a counter plus a memory barrier (which is compiled away on x86) to acquire or release the lock and will never block. On read we spin until the sequence number hasn't changed in the middle of the operation, indicating that the we have a consistent set of values. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-07-28 18:20:43 -07:00
write_seqcount_begin(&stats->seqlock);
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
stats->rx_packets++;
stats->rx_bytes += skb->len;
datpath: Avoid reporting half updated statistics. We enforce mutual exclusion when updating statistics by disabling bottom halves and only writing to per-CPU state. However, reading requires looking at the statistics for foreign CPUs, which could be in the process of updating them since there isn't a lock. This means we could get garbage values for 64-bit values on 32-bit machines or byte counts that don't correspond to packet counts, etc. This commit introduces a sequence lock for statistics values to avoid this problem. Getting a write lock is very cheap - it only requires incrementing a counter plus a memory barrier (which is compiled away on x86) to acquire or release the lock and will never block. On read we spin until the sequence number hasn't changed in the middle of the operation, indicating that the we have a consistent set of values. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-07-28 18:20:43 -07:00
write_seqcount_end(&stats->seqlock);
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
local_bh_enable();
}
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
if (!(vport->ops->flags & VPORT_F_FLOW))
OVS_CB(skb)->flow = NULL;
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 (!(vport->ops->flags & VPORT_F_TUN_ID))
OVS_CB(skb)->tun_id = 0;
dp_process_received_packet(dp_port, skb);
}
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 inline unsigned packet_length(const struct sk_buff *skb)
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07:00
{
unsigned length = skb->len - ETH_HLEN;
if (skb->protocol == htons(ETH_P_8021Q))
length -= VLAN_HLEN;
return length;
}
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_send - send a packet on a device
*
* @vport: vport on which to send the packet
* @skb: skb to send
*
* Sends the given packet and returns the length of data sent. Either RTNL
* lock or rcu_read_lock must be held.
*/
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 vport_send(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
{
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07:00
int mtu;
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
int sent;
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07:00
mtu = vport_get_mtu(vport);
if (unlikely(packet_length(skb) > mtu && !skb_is_gso(skb))) {
if (net_ratelimit())
treewide: Use pr_fmt and pr_<level> Signed-off-by: Joe Perches <joe@perches.com> Acked-by: Simon Horman <horms@verge.net.au> [Jesse: Added missing pr_fmt in vport-gre.c and dp_sysfs_dp.c] Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-08-30 00:24:54 -07:00
pr_warn("%s: dropped over-mtu packet: %d > %d\n",
dp_name(vport_get_dp_port(vport)->dp),
packet_length(skb), mtu);
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07:00
goto error;
datapath: Add loop checking. New types of vports such as patch and GRE make it possible to connect multiple (or the same) datapaths together, which introduces the possibility of loops on a single machine. Local loops are even worse than network loops because they will quickly crash the machine once the kernel stack is exhausted. This adds loop checking within the OVS datapath that will drop packets that have been seen more than 5 times. CC: Paul Ingram <paul@nicira.com>
2010-07-12 13:13:17 -07:00
}
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07:00
sent = vport->ops->send(vport, 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
if (vport->ops->flags & VPORT_F_GEN_STATS && sent > 0) {
struct vport_percpu_stats *stats;
local_bh_disable();
stats = per_cpu_ptr(vport->percpu_stats, smp_processor_id());
datpath: Avoid reporting half updated statistics. We enforce mutual exclusion when updating statistics by disabling bottom halves and only writing to per-CPU state. However, reading requires looking at the statistics for foreign CPUs, which could be in the process of updating them since there isn't a lock. This means we could get garbage values for 64-bit values on 32-bit machines or byte counts that don't correspond to packet counts, etc. This commit introduces a sequence lock for statistics values to avoid this problem. Getting a write lock is very cheap - it only requires incrementing a counter plus a memory barrier (which is compiled away on x86) to acquire or release the lock and will never block. On read we spin until the sequence number hasn't changed in the middle of the operation, indicating that the we have a consistent set of values. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-07-28 18:20:43 -07:00
write_seqcount_begin(&stats->seqlock);
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
stats->tx_packets++;
stats->tx_bytes += sent;
datpath: Avoid reporting half updated statistics. We enforce mutual exclusion when updating statistics by disabling bottom halves and only writing to per-CPU state. However, reading requires looking at the statistics for foreign CPUs, which could be in the process of updating them since there isn't a lock. This means we could get garbage values for 64-bit values on 32-bit machines or byte counts that don't correspond to packet counts, etc. This commit introduces a sequence lock for statistics values to avoid this problem. Getting a write lock is very cheap - it only requires incrementing a counter plus a memory barrier (which is compiled away on x86) to acquire or release the lock and will never block. On read we spin until the sequence number hasn't changed in the middle of the operation, indicating that the we have a consistent set of values. Signed-off-by: Jesse Gross <jesse@nicira.com>
2010-07-28 18:20:43 -07:00
write_seqcount_end(&stats->seqlock);
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
local_bh_enable();
}
datapath: Detect and suppress flows that are implicated in loops. In-kernel loops need to be suppressed; otherwise, they cause high CPU consumption, even to the point that the machine becomes unusable. Ideally these flows should never be added to the Open vSwitch flow table, but it is fairly easy for a buggy controller to create them given the menagerie of tunnels, patches, etc. that OVS makes available. Commit ecbb6953b "datapath: Add loop checking" did the initial work toward suppressing loops, by dropping packets that recursed more than 5 times. This at least prevented the kernel stack from overflowing and thereby OOPSing the machine. But even with this commit, it is still possible to waste a lot of CPU time due to loops. The problem is not limited to 5 recursive calls per packet: any packet can be sent to multiple destinations, which in turn can themselves be sent to multiple destinations, and so on. We have actually seen in practice a case where each packet was, apparently, sent to at least 2 destinations per hop, so that each packet actually consumed CPU time for 2**5 == 32 packets, possibly more. This commit takes loop suppression a step further, by clearing the actions of flows that are implicated in loops. Thus, after the first packet in such a flow, later packets for either the "root" flow or for flows that it ends up looping through are simply discarded, saving a huge amount of CPU time. This version of the commit just clears the actions from the flows that a part of the loop. Probably, there should be some additional action to tell ovs-vswitchd that a loop has been detected, so that it can in turn inform the controller one way or another. My test case was this: ovs-controller -H --max-idle=permanent punix:/tmp/controller ovs-vsctl -- \ set-controller br0 unix:/tmp/controller -- \ add-port br0 patch00 -- \ add-port br0 patch01 -- \ add-port br0 patch10 -- \ add-port br0 patch11 -- \ add-port br0 patch20 -- \ add-port br0 patch21 -- \ add-port br0 patch30 -- \ add-port br0 patch31 -- \ set Interface patch00 type=patch options:peer=patch01 -- \ set Interface patch01 type=patch options:peer=patch00 -- \ set Interface patch10 type=patch options:peer=patch11 -- \ set Interface patch11 type=patch options:peer=patch10 -- \ set Interface patch20 type=patch options:peer=patch21 -- \ set Interface patch21 type=patch options:peer=patch20 -- \ set Interface patch30 type=patch options:peer=patch31 -- \ set Interface patch31 type=patch options:peer=patch30 followed by sending a single "ping" packet from an attached Ethernet port into the bridge. After this, without this commit the vswitch userspace and kernel consume 50-75% of the machine's CPU (in my KVM test setup on a single physical host); with this commit, some CPU is consumed initially but it converges on 0% quickly. A more challenging test sends a series of packets in multiple flows; I used "hping3" with its default options. Without this commit, the vswitch consumes 100% of the machine's CPU, most of which is in the kernel. With this commit, the vswitch consumes "only" 33-50% CPU, most of which is in userspace, so the machine is more responsive. A refinement on this commit would be to pass the loop counter down to userspace as part of the odp_msg struct and then back up as part of the ODP_EXECUTE command arguments. This would, presumably, reduce the CPU requirements, since it would allow loop detection to happen earlier, during initial setup of flows, instead of just on the second and subsequent packets of flows.
2010-08-03 14:40:29 -07:00
return sent;
datapath: Move over-MTU checking into vport_send(). We currently check for packets that are over the MTU in do_output(). There is a one-to-one correlation between this function and vport_send() so move the MTU check there for consistency with other error checking.
2010-07-12 13:27:57 -07:00
error:
kfree_skb(skb);
vport_record_error(vport, VPORT_E_TX_DROPPED);
datapath: Detect and suppress flows that are implicated in loops. In-kernel loops need to be suppressed; otherwise, they cause high CPU consumption, even to the point that the machine becomes unusable. Ideally these flows should never be added to the Open vSwitch flow table, but it is fairly easy for a buggy controller to create them given the menagerie of tunnels, patches, etc. that OVS makes available. Commit ecbb6953b "datapath: Add loop checking" did the initial work toward suppressing loops, by dropping packets that recursed more than 5 times. This at least prevented the kernel stack from overflowing and thereby OOPSing the machine. But even with this commit, it is still possible to waste a lot of CPU time due to loops. The problem is not limited to 5 recursive calls per packet: any packet can be sent to multiple destinations, which in turn can themselves be sent to multiple destinations, and so on. We have actually seen in practice a case where each packet was, apparently, sent to at least 2 destinations per hop, so that each packet actually consumed CPU time for 2**5 == 32 packets, possibly more. This commit takes loop suppression a step further, by clearing the actions of flows that are implicated in loops. Thus, after the first packet in such a flow, later packets for either the "root" flow or for flows that it ends up looping through are simply discarded, saving a huge amount of CPU time. This version of the commit just clears the actions from the flows that a part of the loop. Probably, there should be some additional action to tell ovs-vswitchd that a loop has been detected, so that it can in turn inform the controller one way or another. My test case was this: ovs-controller -H --max-idle=permanent punix:/tmp/controller ovs-vsctl -- \ set-controller br0 unix:/tmp/controller -- \ add-port br0 patch00 -- \ add-port br0 patch01 -- \ add-port br0 patch10 -- \ add-port br0 patch11 -- \ add-port br0 patch20 -- \ add-port br0 patch21 -- \ add-port br0 patch30 -- \ add-port br0 patch31 -- \ set Interface patch00 type=patch options:peer=patch01 -- \ set Interface patch01 type=patch options:peer=patch00 -- \ set Interface patch10 type=patch options:peer=patch11 -- \ set Interface patch11 type=patch options:peer=patch10 -- \ set Interface patch20 type=patch options:peer=patch21 -- \ set Interface patch21 type=patch options:peer=patch20 -- \ set Interface patch30 type=patch options:peer=patch31 -- \ set Interface patch31 type=patch options:peer=patch30 followed by sending a single "ping" packet from an attached Ethernet port into the bridge. After this, without this commit the vswitch userspace and kernel consume 50-75% of the machine's CPU (in my KVM test setup on a single physical host); with this commit, some CPU is consumed initially but it converges on 0% quickly. A more challenging test sends a series of packets in multiple flows; I used "hping3" with its default options. Without this commit, the vswitch consumes 100% of the machine's CPU, most of which is in the kernel. With this commit, the vswitch consumes "only" 33-50% CPU, most of which is in userspace, so the machine is more responsive. A refinement on this commit would be to pass the loop counter down to userspace as part of the odp_msg struct and then back up as part of the ODP_EXECUTE command arguments. This would, presumably, reduce the CPU requirements, since it would allow loop detection to happen earlier, during initial setup of flows, instead of just on the second and subsequent packets of flows.
2010-08-03 14:40:29 -07:00
return 0;
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_record_error - indicate device error to generic stats layer
*
* @vport: vport that encountered the error
* @err_type: one of enum vport_err_type types to indicate the error type
*
* If using the vport generic stats layer indicate that an error of the given
* type has occured.
*/
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
void vport_record_error(struct vport *vport, enum vport_err_type err_type)
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 (vport->ops->flags & VPORT_F_GEN_STATS) {
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
spin_lock_bh(&vport->stats_lock);
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
switch (err_type) {
case VPORT_E_RX_DROPPED:
vport->err_stats.rx_dropped++;
break;
case VPORT_E_RX_ERROR:
vport->err_stats.rx_errors++;
break;
case VPORT_E_TX_DROPPED:
vport->err_stats.tx_dropped++;
break;
case VPORT_E_TX_ERROR:
vport->err_stats.tx_errors++;
break;
};
vport: Allow offsets to be set for stats. Adds a method to set a group of stats to be added to the values gathered normally. This is needed for the fake bond device to show the stats of its underlying slaves. Also enables devices that use the generic stats layer to define a get_stats() function to provide additional error counts.
2010-05-19 17:18:08 -07:00
spin_unlock_bh(&vport->stats_lock);
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