2011-10-26 02:26:31 +00:00
|
|
|
/*
|
2012-05-04 01:55:23 +00:00
|
|
|
* Copyright (c) 2007-2012 Nicira, Inc.
|
2011-10-26 02:26:31 +00:00
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of version 2 of the GNU General Public
|
|
|
|
* License as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful, but
|
|
|
|
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
* General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
|
|
* 02110-1301, USA
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/if.h>
|
|
|
|
#include <linux/if_vlan.h>
|
2012-02-23 03:58:59 +00:00
|
|
|
#include <linux/jhash.h>
|
2011-10-26 02:26:31 +00:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/percpu.h>
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
#include <linux/rtnetlink.h>
|
|
|
|
#include <linux/compat.h>
|
2012-02-23 03:58:59 +00:00
|
|
|
#include <net/net_namespace.h>
|
2011-10-26 02:26:31 +00:00
|
|
|
|
2012-02-23 03:58:59 +00:00
|
|
|
#include "datapath.h"
|
2011-10-26 02:26:31 +00:00
|
|
|
#include "vport.h"
|
|
|
|
#include "vport-internal_dev.h"
|
|
|
|
|
|
|
|
/* List of statically compiled vport implementations. Don't forget to also
|
|
|
|
* add yours to the list at the bottom of vport.h. */
|
|
|
|
static const struct vport_ops *vport_ops_list[] = {
|
|
|
|
&ovs_netdev_vport_ops,
|
|
|
|
&ovs_internal_vport_ops,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* Protected by RCU read lock for reading, RTNL lock for writing. */
|
|
|
|
static struct hlist_head *dev_table;
|
|
|
|
#define VPORT_HASH_BUCKETS 1024
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_init - initialize vport subsystem
|
|
|
|
*
|
|
|
|
* Called at module load time to initialize the vport subsystem.
|
|
|
|
*/
|
|
|
|
int ovs_vport_init(void)
|
|
|
|
{
|
|
|
|
dev_table = kzalloc(VPORT_HASH_BUCKETS * sizeof(struct hlist_head),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!dev_table)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_exit - shutdown vport subsystem
|
|
|
|
*
|
|
|
|
* Called at module exit time to shutdown the vport subsystem.
|
|
|
|
*/
|
|
|
|
void ovs_vport_exit(void)
|
|
|
|
{
|
|
|
|
kfree(dev_table);
|
|
|
|
}
|
|
|
|
|
2012-02-23 03:58:59 +00:00
|
|
|
static struct hlist_head *hash_bucket(struct net *net, const char *name)
|
2011-10-26 02:26:31 +00:00
|
|
|
{
|
2012-02-23 03:58:59 +00:00
|
|
|
unsigned int hash = jhash(name, strlen(name), (unsigned long) net);
|
2011-10-26 02:26:31 +00:00
|
|
|
return &dev_table[hash & (VPORT_HASH_BUCKETS - 1)];
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_locate - find a port that has already been created
|
|
|
|
*
|
|
|
|
* @name: name of port to find
|
|
|
|
*
|
|
|
|
* Must be called with RTNL or RCU read lock.
|
|
|
|
*/
|
2012-02-23 03:58:59 +00:00
|
|
|
struct vport *ovs_vport_locate(struct net *net, const char *name)
|
2011-10-26 02:26:31 +00:00
|
|
|
{
|
2012-02-23 03:58:59 +00:00
|
|
|
struct hlist_head *bucket = hash_bucket(net, name);
|
2011-10-26 02:26:31 +00:00
|
|
|
struct vport *vport;
|
|
|
|
|
hlist: drop the node parameter from iterators
I'm not sure why, but the hlist for each entry iterators were conceived
list_for_each_entry(pos, head, member)
The hlist ones were greedy and wanted an extra parameter:
hlist_for_each_entry(tpos, pos, head, member)
Why did they need an extra pos parameter? I'm not quite sure. Not only
they don't really need it, it also prevents the iterator from looking
exactly like the list iterator, which is unfortunate.
Besides the semantic patch, there was some manual work required:
- Fix up the actual hlist iterators in linux/list.h
- Fix up the declaration of other iterators based on the hlist ones.
- A very small amount of places were using the 'node' parameter, this
was modified to use 'obj->member' instead.
- Coccinelle didn't handle the hlist_for_each_entry_safe iterator
properly, so those had to be fixed up manually.
The semantic patch which is mostly the work of Peter Senna Tschudin is here:
@@
iterator name hlist_for_each_entry, hlist_for_each_entry_continue, hlist_for_each_entry_from, hlist_for_each_entry_rcu, hlist_for_each_entry_rcu_bh, hlist_for_each_entry_continue_rcu_bh, for_each_busy_worker, ax25_uid_for_each, ax25_for_each, inet_bind_bucket_for_each, sctp_for_each_hentry, sk_for_each, sk_for_each_rcu, sk_for_each_from, sk_for_each_safe, sk_for_each_bound, hlist_for_each_entry_safe, hlist_for_each_entry_continue_rcu, nr_neigh_for_each, nr_neigh_for_each_safe, nr_node_for_each, nr_node_for_each_safe, for_each_gfn_indirect_valid_sp, for_each_gfn_sp, for_each_host;
type T;
expression a,c,d,e;
identifier b;
statement S;
@@
-T b;
<+... when != b
(
hlist_for_each_entry(a,
- b,
c, d) S
|
hlist_for_each_entry_continue(a,
- b,
c) S
|
hlist_for_each_entry_from(a,
- b,
c) S
|
hlist_for_each_entry_rcu(a,
- b,
c, d) S
|
hlist_for_each_entry_rcu_bh(a,
- b,
c, d) S
|
hlist_for_each_entry_continue_rcu_bh(a,
- b,
c) S
|
for_each_busy_worker(a, c,
- b,
d) S
|
ax25_uid_for_each(a,
- b,
c) S
|
ax25_for_each(a,
- b,
c) S
|
inet_bind_bucket_for_each(a,
- b,
c) S
|
sctp_for_each_hentry(a,
- b,
c) S
|
sk_for_each(a,
- b,
c) S
|
sk_for_each_rcu(a,
- b,
c) S
|
sk_for_each_from
-(a, b)
+(a)
S
+ sk_for_each_from(a) S
|
sk_for_each_safe(a,
- b,
c, d) S
|
sk_for_each_bound(a,
- b,
c) S
|
hlist_for_each_entry_safe(a,
- b,
c, d, e) S
|
hlist_for_each_entry_continue_rcu(a,
- b,
c) S
|
nr_neigh_for_each(a,
- b,
c) S
|
nr_neigh_for_each_safe(a,
- b,
c, d) S
|
nr_node_for_each(a,
- b,
c) S
|
nr_node_for_each_safe(a,
- b,
c, d) S
|
- for_each_gfn_sp(a, c, d, b) S
+ for_each_gfn_sp(a, c, d) S
|
- for_each_gfn_indirect_valid_sp(a, c, d, b) S
+ for_each_gfn_indirect_valid_sp(a, c, d) S
|
for_each_host(a,
- b,
c) S
|
for_each_host_safe(a,
- b,
c, d) S
|
for_each_mesh_entry(a,
- b,
c, d) S
)
...+>
[akpm@linux-foundation.org: drop bogus change from net/ipv4/raw.c]
[akpm@linux-foundation.org: drop bogus hunk from net/ipv6/raw.c]
[akpm@linux-foundation.org: checkpatch fixes]
[akpm@linux-foundation.org: fix warnings]
[akpm@linux-foudnation.org: redo intrusive kvm changes]
Tested-by: Peter Senna Tschudin <peter.senna@gmail.com>
Acked-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Signed-off-by: Sasha Levin <sasha.levin@oracle.com>
Cc: Wu Fengguang <fengguang.wu@intel.com>
Cc: Marcelo Tosatti <mtosatti@redhat.com>
Cc: Gleb Natapov <gleb@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-02-28 01:06:00 +00:00
|
|
|
hlist_for_each_entry_rcu(vport, bucket, hash_node)
|
2012-02-23 03:58:59 +00:00
|
|
|
if (!strcmp(name, vport->ops->get_name(vport)) &&
|
|
|
|
net_eq(ovs_dp_get_net(vport->dp), net))
|
2011-10-26 02:26:31 +00:00
|
|
|
return vport;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_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().
|
|
|
|
*/
|
|
|
|
struct vport *ovs_vport_alloc(int priv_size, const struct vport_ops *ops,
|
|
|
|
const struct vport_parms *parms)
|
|
|
|
{
|
|
|
|
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->dp = parms->dp;
|
|
|
|
vport->port_no = parms->port_no;
|
2012-09-07 20:12:54 +00:00
|
|
|
vport->upcall_portid = parms->upcall_portid;
|
2011-10-26 02:26:31 +00:00
|
|
|
vport->ops = ops;
|
2012-08-23 19:40:54 +00:00
|
|
|
INIT_HLIST_NODE(&vport->dp_hash_node);
|
2011-10-26 02:26:31 +00:00
|
|
|
|
|
|
|
vport->percpu_stats = alloc_percpu(struct vport_percpu_stats);
|
2011-12-05 20:27:07 +00:00
|
|
|
if (!vport->percpu_stats) {
|
|
|
|
kfree(vport);
|
2011-10-26 02:26:31 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2011-12-05 20:27:07 +00:00
|
|
|
}
|
2011-10-26 02:26:31 +00:00
|
|
|
|
|
|
|
spin_lock_init(&vport->stats_lock);
|
|
|
|
|
|
|
|
return vport;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_free - uninitialize and free vport
|
|
|
|
*
|
|
|
|
* @vport: vport to free
|
|
|
|
*
|
|
|
|
* Frees a vport allocated with vport_alloc() when it is no longer needed.
|
|
|
|
*
|
|
|
|
* The caller must ensure that an RCU grace period has passed since the last
|
|
|
|
* time @vport was in a datapath.
|
|
|
|
*/
|
|
|
|
void ovs_vport_free(struct vport *vport)
|
|
|
|
{
|
|
|
|
free_percpu(vport->percpu_stats);
|
|
|
|
kfree(vport);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_add - add vport device (for kernel callers)
|
|
|
|
*
|
|
|
|
* @parms: Information about new vport.
|
|
|
|
*
|
|
|
|
* Creates a new vport with the specified configuration (which is dependent on
|
|
|
|
* device type). RTNL lock must be held.
|
|
|
|
*/
|
|
|
|
struct vport *ovs_vport_add(const struct vport_parms *parms)
|
|
|
|
{
|
|
|
|
struct vport *vport;
|
|
|
|
int err = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(vport_ops_list); i++) {
|
|
|
|
if (vport_ops_list[i]->type == parms->type) {
|
2012-02-23 03:58:59 +00:00
|
|
|
struct hlist_head *bucket;
|
|
|
|
|
2011-10-26 02:26:31 +00:00
|
|
|
vport = vport_ops_list[i]->create(parms);
|
|
|
|
if (IS_ERR(vport)) {
|
|
|
|
err = PTR_ERR(vport);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2012-02-23 03:58:59 +00:00
|
|
|
bucket = hash_bucket(ovs_dp_get_net(vport->dp),
|
|
|
|
vport->ops->get_name(vport));
|
|
|
|
hlist_add_head_rcu(&vport->hash_node, bucket);
|
2011-10-26 02:26:31 +00:00
|
|
|
return vport;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
err = -EAFNOSUPPORT;
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_set_options - modify existing vport device (for kernel callers)
|
|
|
|
*
|
|
|
|
* @vport: vport to modify.
|
|
|
|
* @port: New configuration.
|
|
|
|
*
|
|
|
|
* Modifies an existing device with the specified configuration (which is
|
|
|
|
* dependent on device type). RTNL lock must be held.
|
|
|
|
*/
|
|
|
|
int ovs_vport_set_options(struct vport *vport, struct nlattr *options)
|
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (!vport->ops->set_options)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
return vport->ops->set_options(vport, options);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_del - delete existing vport device
|
|
|
|
*
|
|
|
|
* @vport: vport to delete.
|
|
|
|
*
|
|
|
|
* Detaches @vport from its datapath and destroys it. It is possible to fail
|
|
|
|
* for reasons such as lack of memory. RTNL lock must be held.
|
|
|
|
*/
|
|
|
|
void ovs_vport_del(struct vport *vport)
|
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
hlist_del_rcu(&vport->hash_node);
|
|
|
|
|
|
|
|
vport->ops->destroy(vport);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_get_stats - retrieve device stats
|
|
|
|
*
|
|
|
|
* @vport: vport from which to retrieve the stats
|
|
|
|
* @stats: location to store stats
|
|
|
|
*
|
|
|
|
* Retrieves transmit, receive, and error stats for the given device.
|
|
|
|
*
|
|
|
|
* Must be called with RTNL lock or rcu_read_lock.
|
|
|
|
*/
|
|
|
|
void ovs_vport_get_stats(struct vport *vport, struct ovs_vport_stats *stats)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
memset(stats, 0, sizeof(*stats));
|
|
|
|
|
|
|
|
/* We potentially have 2 sources of stats that need to be combined:
|
|
|
|
* those we have collected (split into err_stats and percpu_stats) from
|
|
|
|
* set_stats() and device error stats from netdev->get_stats() (for
|
|
|
|
* errors that happen downstream and therefore aren't reported through
|
|
|
|
* our vport_record_error() function).
|
|
|
|
* Stats from first source are reported by ovs (OVS_VPORT_ATTR_STATS).
|
|
|
|
* netdev-stats can be directly read over netlink-ioctl.
|
|
|
|
*/
|
|
|
|
|
|
|
|
spin_lock_bh(&vport->stats_lock);
|
|
|
|
|
|
|
|
stats->rx_errors = vport->err_stats.rx_errors;
|
|
|
|
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);
|
|
|
|
|
|
|
|
for_each_possible_cpu(i) {
|
|
|
|
const struct vport_percpu_stats *percpu_stats;
|
|
|
|
struct vport_percpu_stats local_stats;
|
|
|
|
unsigned int start;
|
|
|
|
|
|
|
|
percpu_stats = per_cpu_ptr(vport->percpu_stats, i);
|
|
|
|
|
|
|
|
do {
|
|
|
|
start = u64_stats_fetch_begin_bh(&percpu_stats->sync);
|
|
|
|
local_stats = *percpu_stats;
|
|
|
|
} while (u64_stats_fetch_retry_bh(&percpu_stats->sync, start));
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_get_options - retrieve device options
|
|
|
|
*
|
|
|
|
* @vport: vport from which to retrieve the options.
|
|
|
|
* @skb: sk_buff where options should be appended.
|
|
|
|
*
|
|
|
|
* Retrieves the configuration of the given device, appending an
|
|
|
|
* %OVS_VPORT_ATTR_OPTIONS attribute that in turn contains nested
|
|
|
|
* vport-specific attributes to @skb.
|
|
|
|
*
|
|
|
|
* Returns 0 if successful, -EMSGSIZE if @skb has insufficient room, or another
|
|
|
|
* negative error code if a real error occurred. If an error occurs, @skb is
|
|
|
|
* left unmodified.
|
|
|
|
*
|
|
|
|
* Must be called with RTNL lock or rcu_read_lock.
|
|
|
|
*/
|
|
|
|
int ovs_vport_get_options(const struct vport *vport, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct nlattr *nla;
|
2013-04-02 22:30:43 +00:00
|
|
|
int err;
|
|
|
|
|
|
|
|
if (!vport->ops->get_options)
|
|
|
|
return 0;
|
2011-10-26 02:26:31 +00:00
|
|
|
|
|
|
|
nla = nla_nest_start(skb, OVS_VPORT_ATTR_OPTIONS);
|
|
|
|
if (!nla)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
2013-04-02 22:30:43 +00:00
|
|
|
err = vport->ops->get_options(vport, skb);
|
|
|
|
if (err) {
|
|
|
|
nla_nest_cancel(skb, nla);
|
|
|
|
return err;
|
2011-10-26 02:26:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nla_nest_end(skb, nla);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_vport_receive - pass up received packet to the datapath for processing
|
|
|
|
*
|
|
|
|
* @vport: vport that received the packet
|
|
|
|
* @skb: skb that was received
|
|
|
|
*
|
|
|
|
* Must be called with rcu_read_lock. The packet cannot be shared and
|
2013-02-22 11:41:26 +00:00
|
|
|
* skb->data should point to the Ethernet header.
|
2011-10-26 02:26:31 +00:00
|
|
|
*/
|
|
|
|
void ovs_vport_receive(struct vport *vport, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct vport_percpu_stats *stats;
|
|
|
|
|
2012-11-13 01:52:25 +00:00
|
|
|
stats = this_cpu_ptr(vport->percpu_stats);
|
2011-10-26 02:26:31 +00:00
|
|
|
u64_stats_update_begin(&stats->sync);
|
|
|
|
stats->rx_packets++;
|
|
|
|
stats->rx_bytes += skb->len;
|
|
|
|
u64_stats_update_end(&stats->sync);
|
|
|
|
|
|
|
|
ovs_dp_process_received_packet(vport, skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_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.
|
|
|
|
*/
|
|
|
|
int ovs_vport_send(struct vport *vport, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
int sent = vport->ops->send(vport, skb);
|
|
|
|
|
|
|
|
if (likely(sent)) {
|
|
|
|
struct vport_percpu_stats *stats;
|
|
|
|
|
2012-11-13 01:52:25 +00:00
|
|
|
stats = this_cpu_ptr(vport->percpu_stats);
|
2011-10-26 02:26:31 +00:00
|
|
|
|
|
|
|
u64_stats_update_begin(&stats->sync);
|
|
|
|
stats->tx_packets++;
|
|
|
|
stats->tx_bytes += sent;
|
|
|
|
u64_stats_update_end(&stats->sync);
|
|
|
|
}
|
|
|
|
return sent;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ovs_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.
|
|
|
|
*/
|
|
|
|
void ovs_vport_record_error(struct vport *vport, enum vport_err_type err_type)
|
|
|
|
{
|
|
|
|
spin_lock(&vport->stats_lock);
|
|
|
|
|
|
|
|
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;
|
2012-09-18 07:10:44 +00:00
|
|
|
}
|
2011-10-26 02:26:31 +00:00
|
|
|
|
|
|
|
spin_unlock(&vport->stats_lock);
|
|
|
|
}
|