2005-01-07 01:45:51 +00:00
|
|
|
/*-
|
1998-03-18 01:40:12 +00:00
|
|
|
* Copyright 1998 Massachusetts Institute of Technology
|
|
|
|
*
|
|
|
|
* Permission to use, copy, modify, and distribute this software and
|
|
|
|
* its documentation for any purpose and without fee is hereby
|
|
|
|
* granted, provided that both the above copyright notice and this
|
|
|
|
* permission notice appear in all copies, that both the above
|
|
|
|
* copyright notice and this permission notice appear in all
|
|
|
|
* supporting documentation, and that the name of M.I.T. not be used
|
|
|
|
* in advertising or publicity pertaining to distribution of the
|
|
|
|
* software without specific, written prior permission. M.I.T. makes
|
|
|
|
* no representations about the suitability of this software for any
|
|
|
|
* purpose. It is provided "as is" without express or implied
|
|
|
|
* warranty.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS
|
|
|
|
* ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
|
|
|
|
* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
|
|
* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
|
|
|
|
* SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
|
|
|
|
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
|
|
* SUCH DAMAGE.
|
|
|
|
*
|
1999-08-28 01:08:13 +00:00
|
|
|
* $FreeBSD$
|
1998-03-18 01:40:12 +00:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* if_vlan.c - pseudo-device driver for IEEE 802.1Q virtual LANs.
|
|
|
|
* Might be extended some day to also handle IEEE 802.1p priority
|
|
|
|
* tagging. This is sort of sneaky in the implementation, since
|
|
|
|
* we need to pretend to be enough of an Ethernet implementation
|
|
|
|
* to make arp work. The way we do this is by telling everyone
|
|
|
|
* that we are an Ethernet, and then catch the packets that
|
2000-03-26 15:24:53 +00:00
|
|
|
* ether_output() left on our output queue when it calls
|
1998-03-18 01:40:12 +00:00
|
|
|
* if_start(), rewrite them for use by the real outgoing interface,
|
|
|
|
* and ask it to send them.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "opt_inet.h"
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#include "opt_vlan.h"
|
1998-03-18 01:40:12 +00:00
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/kernel.h>
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#include <sys/lock.h>
|
1999-03-15 01:17:26 +00:00
|
|
|
#include <sys/malloc.h>
|
1998-03-18 01:40:12 +00:00
|
|
|
#include <sys/mbuf.h>
|
2001-01-31 07:58:58 +00:00
|
|
|
#include <sys/module.h>
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#include <sys/rwlock.h>
|
1999-03-15 01:17:26 +00:00
|
|
|
#include <sys/queue.h>
|
1998-03-18 01:40:12 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/sockio.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
|
|
|
#include <net/bpf.h>
|
|
|
|
#include <net/ethernet.h>
|
|
|
|
#include <net/if.h>
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
#include <net/if_clone.h>
|
1998-03-18 01:40:12 +00:00
|
|
|
#include <net/if_arp.h>
|
|
|
|
#include <net/if_dl.h>
|
|
|
|
#include <net/if_types.h>
|
|
|
|
#include <net/if_vlan_var.h>
|
|
|
|
|
|
|
|
#ifdef INET
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/if_ether.h>
|
|
|
|
#endif
|
|
|
|
|
2001-09-05 21:10:28 +00:00
|
|
|
#define VLANNAME "vlan"
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#define VLAN_DEF_HWIDTH 4
|
2006-01-31 16:41:05 +00:00
|
|
|
#define VLAN_IFFLAGS (IFF_BROADCAST | IFF_MULTICAST)
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
|
|
|
|
LIST_HEAD(ifvlanhead, ifvlan);
|
|
|
|
|
|
|
|
struct ifvlantrunk {
|
|
|
|
struct ifnet *parent; /* parent interface of this trunk */
|
|
|
|
struct rwlock rw;
|
|
|
|
#ifdef VLAN_ARRAY
|
2006-06-21 07:29:44 +00:00
|
|
|
#define VLAN_ARRAY_SIZE (EVL_VLID_MASK + 1)
|
|
|
|
struct ifvlan *vlans[VLAN_ARRAY_SIZE]; /* static table */
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#else
|
|
|
|
struct ifvlanhead *hash; /* dynamic hash-list table */
|
|
|
|
uint16_t hmask;
|
|
|
|
uint16_t hwidth;
|
|
|
|
#endif
|
|
|
|
int refcnt;
|
|
|
|
LIST_ENTRY(ifvlantrunk) trunk_entry;
|
|
|
|
};
|
|
|
|
static LIST_HEAD(, ifvlantrunk) trunk_list;
|
2001-09-05 21:10:28 +00:00
|
|
|
|
2002-11-14 23:43:16 +00:00
|
|
|
struct vlan_mc_entry {
|
|
|
|
struct ether_addr mc_addr;
|
|
|
|
SLIST_ENTRY(vlan_mc_entry) mc_entries;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ifvlan {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ifvlantrunk *ifv_trunk;
|
2005-06-10 16:49:24 +00:00
|
|
|
struct ifnet *ifv_ifp;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#define TRUNK(ifv) ((ifv)->ifv_trunk)
|
|
|
|
#define PARENT(ifv) ((ifv)->ifv_trunk->parent)
|
2005-10-03 02:24:21 +00:00
|
|
|
int ifv_pflags; /* special flags we have set on parent */
|
2002-11-14 23:43:16 +00:00
|
|
|
struct ifv_linkmib {
|
|
|
|
int ifvm_encaplen; /* encapsulation length */
|
|
|
|
int ifvm_mtufudge; /* MTU fudged by this much */
|
|
|
|
int ifvm_mintu; /* min transmission unit */
|
2006-08-15 16:56:43 +00:00
|
|
|
uint16_t ifvm_proto; /* encapsulation ethertype */
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
uint16_t ifvm_tag; /* tag to apply on packets leaving if */
|
2002-11-14 23:43:16 +00:00
|
|
|
} ifv_mib;
|
2006-06-29 07:30:39 +00:00
|
|
|
SLIST_HEAD(, vlan_mc_entry) vlan_mc_listhead;
|
2002-11-14 23:43:16 +00:00
|
|
|
LIST_ENTRY(ifvlan) ifv_list;
|
|
|
|
};
|
2006-08-15 16:56:43 +00:00
|
|
|
#define ifv_proto ifv_mib.ifvm_proto
|
2006-06-29 07:30:39 +00:00
|
|
|
#define ifv_tag ifv_mib.ifvm_tag
|
2002-11-14 23:43:16 +00:00
|
|
|
#define ifv_encaplen ifv_mib.ifvm_encaplen
|
|
|
|
#define ifv_mtufudge ifv_mib.ifvm_mtufudge
|
|
|
|
#define ifv_mintu ifv_mib.ifvm_mintu
|
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
/* Special flags we should propagate to parent. */
|
2005-10-03 02:24:21 +00:00
|
|
|
static struct {
|
|
|
|
int flag;
|
|
|
|
int (*func)(struct ifnet *, int);
|
|
|
|
} vlan_pflags[] = {
|
|
|
|
{IFF_PROMISC, ifpromisc},
|
|
|
|
{IFF_ALLMULTI, if_allmulti},
|
|
|
|
{0, NULL}
|
|
|
|
};
|
2002-11-14 23:43:16 +00:00
|
|
|
|
1999-04-07 23:26:43 +00:00
|
|
|
SYSCTL_DECL(_net_link);
|
2001-07-24 00:03:51 +00:00
|
|
|
SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW, 0, "IEEE 802.1Q VLAN");
|
1998-03-18 01:40:12 +00:00
|
|
|
SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0, "for consistency");
|
|
|
|
|
2006-08-11 17:09:27 +00:00
|
|
|
static int soft_pad = 0;
|
|
|
|
SYSCTL_INT(_net_link_vlan, OID_AUTO, soft_pad, CTLFLAG_RW, &soft_pad, 0,
|
|
|
|
"pad short frames before tagging");
|
|
|
|
|
2003-10-28 20:58:02 +00:00
|
|
|
static MALLOC_DEFINE(M_VLAN, VLANNAME, "802.1Q Virtual LAN Interface");
|
1998-03-18 01:40:12 +00:00
|
|
|
|
2006-06-21 07:29:44 +00:00
|
|
|
static eventhandler_tag ifdetach_tag;
|
|
|
|
|
2003-09-05 20:58:59 +00:00
|
|
|
/*
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
* We have a global mutex, that is used to serialize configuration
|
|
|
|
* changes and isn't used in normal packet delivery.
|
|
|
|
*
|
|
|
|
* We also have a per-trunk rwlock, that is locked shared on packet
|
|
|
|
* processing and exclusive when configuration is changed.
|
|
|
|
*
|
|
|
|
* The VLAN_ARRAY substitutes the dynamic hash with a static array
|
2006-08-25 08:25:35 +00:00
|
|
|
* with 4096 entries. In theory this can give a boost in processing,
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
* however on practice it does not. Probably this is because array
|
|
|
|
* is too big to fit into CPU cache.
|
2003-09-05 20:58:59 +00:00
|
|
|
*/
|
|
|
|
static struct mtx ifv_mtx;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#define VLAN_LOCK_INIT() mtx_init(&ifv_mtx, "vlan_global", NULL, MTX_DEF)
|
2003-09-05 20:58:59 +00:00
|
|
|
#define VLAN_LOCK_DESTROY() mtx_destroy(&ifv_mtx)
|
|
|
|
#define VLAN_LOCK_ASSERT() mtx_assert(&ifv_mtx, MA_OWNED)
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#define VLAN_LOCK() mtx_lock(&ifv_mtx)
|
|
|
|
#define VLAN_UNLOCK() mtx_unlock(&ifv_mtx)
|
|
|
|
#define TRUNK_LOCK_INIT(trunk) rw_init(&(trunk)->rw, VLANNAME)
|
|
|
|
#define TRUNK_LOCK_DESTROY(trunk) rw_destroy(&(trunk)->rw)
|
|
|
|
#define TRUNK_LOCK(trunk) rw_wlock(&(trunk)->rw)
|
|
|
|
#define TRUNK_UNLOCK(trunk) rw_wunlock(&(trunk)->rw)
|
|
|
|
#define TRUNK_LOCK_ASSERT(trunk) rw_assert(&(trunk)->rw, RA_WLOCKED)
|
|
|
|
#define TRUNK_RLOCK(trunk) rw_rlock(&(trunk)->rw)
|
|
|
|
#define TRUNK_RUNLOCK(trunk) rw_runlock(&(trunk)->rw)
|
|
|
|
#define TRUNK_LOCK_RASSERT(trunk) rw_assert(&(trunk)->rw, RA_RLOCKED)
|
|
|
|
|
|
|
|
#ifndef VLAN_ARRAY
|
|
|
|
static void vlan_inithash(struct ifvlantrunk *trunk);
|
|
|
|
static void vlan_freehash(struct ifvlantrunk *trunk);
|
|
|
|
static int vlan_inshash(struct ifvlantrunk *trunk, struct ifvlan *ifv);
|
|
|
|
static int vlan_remhash(struct ifvlantrunk *trunk, struct ifvlan *ifv);
|
|
|
|
static void vlan_growhash(struct ifvlantrunk *trunk, int howmuch);
|
|
|
|
static __inline struct ifvlan * vlan_gethash(struct ifvlantrunk *trunk,
|
|
|
|
uint16_t tag);
|
|
|
|
#endif
|
|
|
|
static void trunk_destroy(struct ifvlantrunk *trunk);
|
2003-09-05 20:58:59 +00:00
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
static void vlan_start(struct ifnet *ifp);
|
2006-06-29 07:30:39 +00:00
|
|
|
static void vlan_init(void *foo);
|
2002-11-14 23:43:16 +00:00
|
|
|
static void vlan_input(struct ifnet *ifp, struct mbuf *m);
|
1998-08-23 03:07:17 +00:00
|
|
|
static int vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr);
|
2005-10-03 02:24:21 +00:00
|
|
|
static int vlan_setflag(struct ifnet *ifp, int flag, int status,
|
|
|
|
int (*func)(struct ifnet *, int));
|
|
|
|
static int vlan_setflags(struct ifnet *ifp, int status);
|
1999-03-15 01:17:26 +00:00
|
|
|
static int vlan_setmulti(struct ifnet *ifp);
|
|
|
|
static int vlan_unconfig(struct ifnet *ifp);
|
2006-06-21 07:29:44 +00:00
|
|
|
static int vlan_unconfig_locked(struct ifnet *ifp);
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
static int vlan_config(struct ifvlan *ifv, struct ifnet *p, uint16_t tag);
|
2004-05-03 13:48:35 +00:00
|
|
|
static void vlan_link_state(struct ifnet *ifp, int link);
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
static void vlan_capabilities(struct ifvlan *ifv);
|
|
|
|
static void vlan_trunk_capabilities(struct ifnet *ifp);
|
1999-03-15 01:17:26 +00:00
|
|
|
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
static struct ifnet *vlan_clone_match_ethertag(struct if_clone *,
|
|
|
|
const char *, int *);
|
|
|
|
static int vlan_clone_match(struct if_clone *, const char *);
|
2006-07-09 06:04:01 +00:00
|
|
|
static int vlan_clone_create(struct if_clone *, char *, size_t, caddr_t);
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
static int vlan_clone_destroy(struct if_clone *, struct ifnet *);
|
|
|
|
|
2006-06-21 07:29:44 +00:00
|
|
|
static void vlan_ifdetach(void *arg, struct ifnet *ifp);
|
|
|
|
|
2005-01-23 23:10:33 +00:00
|
|
|
static struct if_clone vlan_cloner = IFC_CLONE_INITIALIZER(VLANNAME, NULL,
|
|
|
|
IF_MAXUNIT, NULL, vlan_clone_match, vlan_clone_create, vlan_clone_destroy);
|
2001-09-05 21:10:28 +00:00
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#ifndef VLAN_ARRAY
|
|
|
|
#define HASH(n, m) ((((n) >> 8) ^ ((n) >> 4) ^ (n)) & (m))
|
2006-06-29 07:30:39 +00:00
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
static void
|
|
|
|
vlan_inithash(struct ifvlantrunk *trunk)
|
|
|
|
{
|
|
|
|
int i, n;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The trunk must not be locked here since we call malloc(M_WAITOK).
|
|
|
|
* It is OK in case this function is called before the trunk struct
|
|
|
|
* gets hooked up and becomes visible from other threads.
|
|
|
|
*/
|
|
|
|
|
|
|
|
KASSERT(trunk->hwidth == 0 && trunk->hash == NULL,
|
|
|
|
("%s: hash already initialized", __func__));
|
|
|
|
|
|
|
|
trunk->hwidth = VLAN_DEF_HWIDTH;
|
|
|
|
n = 1 << trunk->hwidth;
|
|
|
|
trunk->hmask = n - 1;
|
|
|
|
trunk->hash = malloc(sizeof(struct ifvlanhead) * n, M_VLAN, M_WAITOK);
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
LIST_INIT(&trunk->hash[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vlan_freehash(struct ifvlantrunk *trunk)
|
|
|
|
{
|
|
|
|
#ifdef INVARIANTS
|
|
|
|
int i;
|
|
|
|
|
|
|
|
KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__));
|
|
|
|
for (i = 0; i < (1 << trunk->hwidth); i++)
|
|
|
|
KASSERT(LIST_EMPTY(&trunk->hash[i]),
|
|
|
|
("%s: hash table not empty", __func__));
|
|
|
|
#endif
|
|
|
|
free(trunk->hash, M_VLAN);
|
|
|
|
trunk->hash = NULL;
|
|
|
|
trunk->hwidth = trunk->hmask = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vlan_inshash(struct ifvlantrunk *trunk, struct ifvlan *ifv)
|
|
|
|
{
|
|
|
|
int i, b;
|
|
|
|
struct ifvlan *ifv2;
|
|
|
|
|
|
|
|
TRUNK_LOCK_ASSERT(trunk);
|
|
|
|
KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__));
|
|
|
|
|
|
|
|
b = 1 << trunk->hwidth;
|
|
|
|
i = HASH(ifv->ifv_tag, trunk->hmask);
|
|
|
|
LIST_FOREACH(ifv2, &trunk->hash[i], ifv_list)
|
|
|
|
if (ifv->ifv_tag == ifv2->ifv_tag)
|
|
|
|
return (EEXIST);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Grow the hash when the number of vlans exceeds half of the number of
|
|
|
|
* hash buckets squared. This will make the average linked-list length
|
|
|
|
* buckets/2.
|
|
|
|
*/
|
|
|
|
if (trunk->refcnt > (b * b) / 2) {
|
|
|
|
vlan_growhash(trunk, 1);
|
|
|
|
i = HASH(ifv->ifv_tag, trunk->hmask);
|
|
|
|
}
|
|
|
|
LIST_INSERT_HEAD(&trunk->hash[i], ifv, ifv_list);
|
|
|
|
trunk->refcnt++;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vlan_remhash(struct ifvlantrunk *trunk, struct ifvlan *ifv)
|
|
|
|
{
|
|
|
|
int i, b;
|
|
|
|
struct ifvlan *ifv2;
|
|
|
|
|
|
|
|
TRUNK_LOCK_ASSERT(trunk);
|
|
|
|
KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__));
|
|
|
|
|
|
|
|
b = 1 << trunk->hwidth;
|
|
|
|
i = HASH(ifv->ifv_tag, trunk->hmask);
|
|
|
|
LIST_FOREACH(ifv2, &trunk->hash[i], ifv_list)
|
|
|
|
if (ifv2 == ifv) {
|
|
|
|
trunk->refcnt--;
|
|
|
|
LIST_REMOVE(ifv2, ifv_list);
|
|
|
|
if (trunk->refcnt < (b * b) / 2)
|
|
|
|
vlan_growhash(trunk, -1);
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
panic("%s: vlan not found\n", __func__);
|
|
|
|
return (ENOENT); /*NOTREACHED*/
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Grow the hash larger or smaller if memory permits.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
vlan_growhash(struct ifvlantrunk *trunk, int howmuch)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
struct ifvlanhead *hash2;
|
|
|
|
int hwidth2, i, j, n, n2;
|
|
|
|
|
|
|
|
TRUNK_LOCK_ASSERT(trunk);
|
|
|
|
KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__));
|
|
|
|
|
|
|
|
if (howmuch == 0) {
|
|
|
|
/* Harmless yet obvious coding error */
|
|
|
|
printf("%s: howmuch is 0\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
hwidth2 = trunk->hwidth + howmuch;
|
|
|
|
n = 1 << trunk->hwidth;
|
|
|
|
n2 = 1 << hwidth2;
|
|
|
|
/* Do not shrink the table below the default */
|
|
|
|
if (hwidth2 < VLAN_DEF_HWIDTH)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/* M_NOWAIT because we're called with trunk mutex held */
|
|
|
|
hash2 = malloc(sizeof(struct ifvlanhead) * n2, M_VLAN, M_NOWAIT);
|
|
|
|
if (hash2 == NULL) {
|
|
|
|
printf("%s: out of memory -- hash size not changed\n",
|
|
|
|
__func__);
|
|
|
|
return; /* We can live with the old hash table */
|
|
|
|
}
|
|
|
|
for (j = 0; j < n2; j++)
|
|
|
|
LIST_INIT(&hash2[j]);
|
|
|
|
for (i = 0; i < n; i++)
|
|
|
|
while (!LIST_EMPTY(&trunk->hash[i])) {
|
|
|
|
ifv = LIST_FIRST(&trunk->hash[i]);
|
|
|
|
LIST_REMOVE(ifv, ifv_list);
|
|
|
|
j = HASH(ifv->ifv_tag, n2 - 1);
|
|
|
|
LIST_INSERT_HEAD(&hash2[j], ifv, ifv_list);
|
|
|
|
}
|
|
|
|
free(trunk->hash, M_VLAN);
|
|
|
|
trunk->hash = hash2;
|
|
|
|
trunk->hwidth = hwidth2;
|
|
|
|
trunk->hmask = n2 - 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __inline struct ifvlan *
|
|
|
|
vlan_gethash(struct ifvlantrunk *trunk, uint16_t tag)
|
|
|
|
{
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
|
|
|
|
TRUNK_LOCK_RASSERT(trunk);
|
|
|
|
|
|
|
|
LIST_FOREACH(ifv, &trunk->hash[HASH(tag, trunk->hmask)], ifv_list)
|
|
|
|
if (ifv->ifv_tag == tag)
|
|
|
|
return (ifv);
|
|
|
|
return (NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
/* Debugging code to view the hashtables. */
|
|
|
|
static void
|
|
|
|
vlan_dumphash(struct ifvlantrunk *trunk)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
|
|
|
|
for (i = 0; i < (1 << trunk->hwidth); i++) {
|
|
|
|
printf("%d: ", i);
|
|
|
|
LIST_FOREACH(ifv, &trunk->hash[i], ifv_list)
|
|
|
|
printf("%s ", ifv->ifv_ifp->if_xname);
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif /* 0 */
|
|
|
|
#endif /* !VLAN_ARRAY */
|
|
|
|
|
|
|
|
static void
|
|
|
|
trunk_destroy(struct ifvlantrunk *trunk)
|
|
|
|
{
|
|
|
|
VLAN_LOCK_ASSERT();
|
|
|
|
|
|
|
|
TRUNK_LOCK(trunk);
|
|
|
|
#ifndef VLAN_ARRAY
|
|
|
|
vlan_freehash(trunk);
|
|
|
|
#endif
|
|
|
|
trunk->parent->if_vlantrunk = NULL;
|
2006-02-24 17:25:16 +00:00
|
|
|
LIST_REMOVE(trunk, trunk_entry);
|
|
|
|
TRUNK_UNLOCK(trunk);
|
|
|
|
TRUNK_LOCK_DESTROY(trunk);
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
free(trunk, M_VLAN);
|
|
|
|
}
|
|
|
|
|
1999-03-15 01:17:26 +00:00
|
|
|
/*
|
|
|
|
* Program our multicast filter. What we're actually doing is
|
|
|
|
* programming the multicast filter of the parent. This has the
|
|
|
|
* side effect of causing the parent interface to receive multicast
|
|
|
|
* traffic that it doesn't really want, which ends up being discarded
|
|
|
|
* later by the upper protocol layers. Unfortunately, there's no way
|
|
|
|
* to avoid this: there really is only one physical interface.
|
2004-07-04 18:32:54 +00:00
|
|
|
*
|
|
|
|
* XXX: There is a possible race here if more than one thread is
|
|
|
|
* modifying the multicast state of the vlan interface at the same time.
|
1999-03-15 01:17:26 +00:00
|
|
|
*/
|
2001-01-31 07:58:58 +00:00
|
|
|
static int
|
|
|
|
vlan_setmulti(struct ifnet *ifp)
|
1999-03-15 01:17:26 +00:00
|
|
|
{
|
|
|
|
struct ifnet *ifp_p;
|
|
|
|
struct ifmultiaddr *ifma, *rifma = NULL;
|
|
|
|
struct ifvlan *sc;
|
|
|
|
struct vlan_mc_entry *mc = NULL;
|
|
|
|
struct sockaddr_dl sdl;
|
|
|
|
int error;
|
|
|
|
|
2004-07-04 18:32:54 +00:00
|
|
|
/*VLAN_LOCK_ASSERT();*/
|
|
|
|
|
1999-03-15 01:17:26 +00:00
|
|
|
/* Find the parent. */
|
|
|
|
sc = ifp->if_softc;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
ifp_p = PARENT(sc);
|
2001-07-24 17:14:37 +00:00
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
bzero((char *)&sdl, sizeof(sdl));
|
|
|
|
sdl.sdl_len = sizeof(sdl);
|
1999-03-15 01:17:26 +00:00
|
|
|
sdl.sdl_family = AF_LINK;
|
2001-05-02 16:12:58 +00:00
|
|
|
sdl.sdl_index = ifp_p->if_index;
|
|
|
|
sdl.sdl_type = IFT_ETHER;
|
2001-03-28 15:52:12 +00:00
|
|
|
sdl.sdl_alen = ETHER_ADDR_LEN;
|
1999-03-15 01:17:26 +00:00
|
|
|
|
|
|
|
/* First, remove any existing filter entries. */
|
2004-07-04 16:43:24 +00:00
|
|
|
while (SLIST_FIRST(&sc->vlan_mc_listhead) != NULL) {
|
2001-02-03 11:46:35 +00:00
|
|
|
mc = SLIST_FIRST(&sc->vlan_mc_listhead);
|
1999-03-15 01:17:26 +00:00
|
|
|
bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN);
|
|
|
|
error = if_delmulti(ifp_p, (struct sockaddr *)&sdl);
|
|
|
|
if (error)
|
2004-07-04 16:43:24 +00:00
|
|
|
return (error);
|
1999-03-15 01:17:26 +00:00
|
|
|
SLIST_REMOVE_HEAD(&sc->vlan_mc_listhead, mc_entries);
|
2001-09-05 21:10:28 +00:00
|
|
|
free(mc, M_VLAN);
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Now program new ones. */
|
2001-02-06 10:12:15 +00:00
|
|
|
TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
|
1999-03-15 01:17:26 +00:00
|
|
|
if (ifma->ifma_addr->sa_family != AF_LINK)
|
|
|
|
continue;
|
2004-07-04 18:32:54 +00:00
|
|
|
mc = malloc(sizeof(struct vlan_mc_entry), M_VLAN, M_NOWAIT);
|
|
|
|
if (mc == NULL)
|
|
|
|
return (ENOMEM);
|
1999-03-15 01:17:26 +00:00
|
|
|
bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
|
|
|
|
(char *)&mc->mc_addr, ETHER_ADDR_LEN);
|
|
|
|
SLIST_INSERT_HEAD(&sc->vlan_mc_listhead, mc, mc_entries);
|
2001-05-02 16:12:58 +00:00
|
|
|
bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
|
|
|
|
LLADDR(&sdl), ETHER_ADDR_LEN);
|
1999-03-15 01:17:26 +00:00
|
|
|
error = if_addmulti(ifp_p, (struct sockaddr *)&sdl, &rifma);
|
|
|
|
if (error)
|
2004-07-04 16:43:24 +00:00
|
|
|
return (error);
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
return (0);
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
1998-03-18 01:40:12 +00:00
|
|
|
|
2006-06-21 07:29:44 +00:00
|
|
|
/*
|
|
|
|
* A handler for network interface departure events.
|
|
|
|
* Track departure of trunks here so that we don't access invalid
|
|
|
|
* pointers or whatever if a trunk is ripped from under us, e.g.,
|
|
|
|
* by ejecting its hot-plug card.
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
vlan_ifdetach(void *arg __unused, struct ifnet *ifp)
|
|
|
|
{
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if it's a trunk interface first of all
|
|
|
|
* to avoid needless locking.
|
|
|
|
*/
|
|
|
|
if (ifp->if_vlantrunk == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
VLAN_LOCK();
|
|
|
|
/*
|
|
|
|
* OK, it's a trunk. Loop over and detach all vlan's on it.
|
|
|
|
* Check trunk pointer after each vlan_unconfig() as it will
|
|
|
|
* free it and set to NULL after the last vlan was detached.
|
|
|
|
*/
|
|
|
|
#ifdef VLAN_ARRAY
|
|
|
|
for (i = 0; i < VLAN_ARRAY_SIZE; i++)
|
|
|
|
if ((ifv = ifp->if_vlantrunk->vlans[i])) {
|
|
|
|
vlan_unconfig_locked(ifv->ifv_ifp);
|
|
|
|
if (ifp->if_vlantrunk == NULL)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#else /* VLAN_ARRAY */
|
|
|
|
restart:
|
|
|
|
for (i = 0; i < (1 << ifp->if_vlantrunk->hwidth); i++)
|
|
|
|
if ((ifv = LIST_FIRST(&ifp->if_vlantrunk->hash[i]))) {
|
|
|
|
vlan_unconfig_locked(ifv->ifv_ifp);
|
|
|
|
if (ifp->if_vlantrunk)
|
|
|
|
goto restart; /* trunk->hwidth can change */
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif /* VLAN_ARRAY */
|
|
|
|
/* Trunk should have been destroyed in vlan_unconfig(). */
|
|
|
|
KASSERT(ifp->if_vlantrunk == NULL, ("%s: purge failed", __func__));
|
|
|
|
VLAN_UNLOCK();
|
|
|
|
}
|
|
|
|
|
2002-11-14 23:43:16 +00:00
|
|
|
/*
|
|
|
|
* VLAN support can be loaded as a module. The only place in the
|
|
|
|
* system that's intimately aware of this is ether_input. We hook
|
|
|
|
* into this code through vlan_input_p which is defined there and
|
|
|
|
* set here. Noone else in the system should be aware of this so
|
|
|
|
* we use an explicit reference here.
|
|
|
|
*/
|
|
|
|
extern void (*vlan_input_p)(struct ifnet *, struct mbuf *);
|
|
|
|
|
2005-04-20 12:16:41 +00:00
|
|
|
/* For if_link_state_change() eyes only... */
|
2004-05-03 13:48:35 +00:00
|
|
|
extern void (*vlan_link_state_p)(struct ifnet *, int);
|
|
|
|
|
2001-01-31 07:58:58 +00:00
|
|
|
static int
|
2004-07-04 16:43:24 +00:00
|
|
|
vlan_modevent(module_t mod, int type, void *data)
|
|
|
|
{
|
2001-09-05 21:10:28 +00:00
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
switch (type) {
|
|
|
|
case MOD_LOAD:
|
2006-06-21 07:29:44 +00:00
|
|
|
ifdetach_tag = EVENTHANDLER_REGISTER(ifnet_departure_event,
|
|
|
|
vlan_ifdetach, NULL, EVENTHANDLER_PRI_ANY);
|
|
|
|
if (ifdetach_tag == NULL)
|
|
|
|
return (ENOMEM);
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
LIST_INIT(&trunk_list);
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_LOCK_INIT();
|
2001-09-05 21:10:28 +00:00
|
|
|
vlan_input_p = vlan_input;
|
2004-05-03 13:48:35 +00:00
|
|
|
vlan_link_state_p = vlan_link_state;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
vlan_trunk_cap_p = vlan_trunk_capabilities;
|
2001-09-05 21:10:28 +00:00
|
|
|
if_clone_attach(&vlan_cloner);
|
2004-07-04 16:43:24 +00:00
|
|
|
break;
|
|
|
|
case MOD_UNLOAD:
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
{
|
|
|
|
struct ifvlantrunk *trunk, *trunk1;
|
|
|
|
|
2001-09-05 21:10:28 +00:00
|
|
|
if_clone_detach(&vlan_cloner);
|
2006-06-21 07:29:44 +00:00
|
|
|
EVENTHANDLER_DEREGISTER(ifnet_departure_event, ifdetach_tag);
|
2001-09-05 21:10:28 +00:00
|
|
|
vlan_input_p = NULL;
|
2004-05-03 13:48:35 +00:00
|
|
|
vlan_link_state_p = NULL;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
vlan_trunk_cap_p = NULL;
|
|
|
|
VLAN_LOCK();
|
|
|
|
LIST_FOREACH_SAFE(trunk, &trunk_list, trunk_entry, trunk1)
|
|
|
|
trunk_destroy(trunk);
|
|
|
|
VLAN_UNLOCK();
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_LOCK_DESTROY();
|
2001-09-05 21:10:28 +00:00
|
|
|
break;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
}
|
2004-07-15 08:26:07 +00:00
|
|
|
default:
|
|
|
|
return (EOPNOTSUPP);
|
2004-07-04 16:43:24 +00:00
|
|
|
}
|
|
|
|
return (0);
|
|
|
|
}
|
2001-01-31 07:58:58 +00:00
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
static moduledata_t vlan_mod = {
|
|
|
|
"if_vlan",
|
|
|
|
vlan_modevent,
|
2001-01-31 07:58:58 +00:00
|
|
|
0
|
2004-07-04 16:43:24 +00:00
|
|
|
};
|
2001-01-31 07:58:58 +00:00
|
|
|
|
|
|
|
DECLARE_MODULE(if_vlan, vlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
|
2006-02-10 18:38:33 +00:00
|
|
|
MODULE_VERSION(if_vlan, 3);
|
2004-05-21 08:43:38 +00:00
|
|
|
MODULE_DEPEND(if_vlan, miibus, 1, 1, 1);
|
1998-03-18 01:40:12 +00:00
|
|
|
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
static struct ifnet *
|
|
|
|
vlan_clone_match_ethertag(struct if_clone *ifc, const char *name, int *tag)
|
|
|
|
{
|
|
|
|
const char *cp;
|
|
|
|
struct ifnet *ifp;
|
2004-07-04 16:43:24 +00:00
|
|
|
int t = 0;
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
|
|
|
|
/* Check for <etherif>.<vlan> style interface names. */
|
|
|
|
IFNET_RLOCK();
|
|
|
|
TAILQ_FOREACH(ifp, &ifnet, if_link) {
|
|
|
|
if (ifp->if_type != IFT_ETHER)
|
|
|
|
continue;
|
|
|
|
if (strncmp(ifp->if_xname, name, strlen(ifp->if_xname)) != 0)
|
|
|
|
continue;
|
|
|
|
cp = name + strlen(ifp->if_xname);
|
|
|
|
if (*cp != '.')
|
|
|
|
continue;
|
|
|
|
for(; *cp != '\0'; cp++) {
|
|
|
|
if (*cp < '0' || *cp > '9')
|
|
|
|
continue;
|
|
|
|
t = (t * 10) + (*cp - '0');
|
|
|
|
}
|
|
|
|
if (tag != NULL)
|
|
|
|
*tag = t;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
IFNET_RUNLOCK();
|
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
return (ifp);
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
}
|
|
|
|
|
2001-09-05 21:10:28 +00:00
|
|
|
static int
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
vlan_clone_match(struct if_clone *ifc, const char *name)
|
2001-09-05 21:10:28 +00:00
|
|
|
{
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
const char *cp;
|
|
|
|
|
|
|
|
if (vlan_clone_match_ethertag(ifc, name, NULL) != NULL)
|
|
|
|
return (1);
|
|
|
|
|
|
|
|
if (strncmp(VLANNAME, name, strlen(VLANNAME)) != 0)
|
|
|
|
return (0);
|
|
|
|
for (cp = name + 4; *cp != '\0'; cp++) {
|
|
|
|
if (*cp < '0' || *cp > '9')
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2006-07-09 06:04:01 +00:00
|
|
|
vlan_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params)
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
{
|
|
|
|
char *dp;
|
|
|
|
int wildcard;
|
|
|
|
int unit;
|
|
|
|
int error;
|
|
|
|
int tag;
|
|
|
|
int ethertag;
|
2001-09-05 21:10:28 +00:00
|
|
|
struct ifvlan *ifv;
|
|
|
|
struct ifnet *ifp;
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
struct ifnet *p;
|
2006-07-09 06:04:01 +00:00
|
|
|
struct vlanreq vlr;
|
2006-06-29 07:30:39 +00:00
|
|
|
static const u_char eaddr[6]; /* 00:00:00:00:00:00 */
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
|
2006-07-09 06:04:01 +00:00
|
|
|
/*
|
|
|
|
* There are 3 (ugh) ways to specify the cloned device:
|
|
|
|
* o pass a parameter block with the clone request.
|
|
|
|
* o specify parameters in the text of the clone device name
|
|
|
|
* o specify no parameters and get an unattached device that
|
|
|
|
* must be configured separately.
|
|
|
|
* The first technique is preferred; the latter two are
|
|
|
|
* supported for backwards compatibilty.
|
|
|
|
*/
|
|
|
|
if (params) {
|
|
|
|
error = copyin(params, &vlr, sizeof(vlr));
|
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
p = ifunit(vlr.vlr_parent);
|
|
|
|
if (p == NULL)
|
|
|
|
return ENXIO;
|
|
|
|
/*
|
|
|
|
* Don't let the caller set up a VLAN tag with
|
|
|
|
* anything except VLID bits.
|
|
|
|
*/
|
|
|
|
if (vlr.vlr_tag & ~EVL_VLID_MASK)
|
|
|
|
return (EINVAL);
|
|
|
|
error = ifc_name2unit(name, &unit);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
ethertag = 1;
|
|
|
|
tag = vlr.vlr_tag;
|
|
|
|
wildcard = (unit < 0);
|
|
|
|
} else if ((p = vlan_clone_match_ethertag(ifc, name, &tag)) != NULL) {
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
ethertag = 1;
|
|
|
|
unit = -1;
|
|
|
|
wildcard = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Don't let the caller set up a VLAN tag with
|
|
|
|
* anything except VLID bits.
|
|
|
|
*/
|
2004-07-04 16:43:24 +00:00
|
|
|
if (tag & ~EVL_VLID_MASK)
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
return (EINVAL);
|
|
|
|
} else {
|
|
|
|
ethertag = 0;
|
|
|
|
|
|
|
|
error = ifc_name2unit(name, &unit);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
wildcard = (unit < 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = ifc_alloc_unit(ifc, &unit);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
/* In the wildcard case, we need to update the name. */
|
|
|
|
if (wildcard) {
|
|
|
|
for (dp = name; *dp != '\0'; dp++);
|
|
|
|
if (snprintf(dp, len - (dp-name), "%d", unit) >
|
|
|
|
len - (dp-name) - 1) {
|
|
|
|
panic("%s: interface name too long", __func__);
|
|
|
|
}
|
|
|
|
}
|
2001-09-05 21:10:28 +00:00
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
ifv = malloc(sizeof(struct ifvlan), M_VLAN, M_WAITOK | M_ZERO);
|
2005-06-10 16:49:24 +00:00
|
|
|
ifp = ifv->ifv_ifp = if_alloc(IFT_ETHER);
|
|
|
|
if (ifp == NULL) {
|
|
|
|
ifc_free_unit(ifc, unit);
|
|
|
|
free(ifv, M_VLAN);
|
|
|
|
return (ENOSPC);
|
|
|
|
}
|
2001-09-05 21:10:28 +00:00
|
|
|
SLIST_INIT(&ifv->vlan_mc_listhead);
|
|
|
|
|
|
|
|
ifp->if_softc = ifv;
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
/*
|
2005-01-24 15:48:00 +00:00
|
|
|
* Set the name manually rather than using if_initname because
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
* we don't conform to the default naming convention for interfaces.
|
|
|
|
*/
|
|
|
|
strlcpy(ifp->if_xname, name, IFNAMSIZ);
|
|
|
|
ifp->if_dname = ifc->ifc_name;
|
|
|
|
ifp->if_dunit = unit;
|
2001-09-05 21:10:28 +00:00
|
|
|
/* NB: flags are not set here */
|
|
|
|
ifp->if_linkmib = &ifv->ifv_mib;
|
2004-07-04 16:43:24 +00:00
|
|
|
ifp->if_linkmiblen = sizeof(ifv->ifv_mib);
|
2001-09-05 21:10:28 +00:00
|
|
|
/* NB: mtu is not set here */
|
|
|
|
|
2006-06-29 07:30:39 +00:00
|
|
|
ifp->if_init = vlan_init;
|
2001-09-05 21:10:28 +00:00
|
|
|
ifp->if_start = vlan_start;
|
|
|
|
ifp->if_ioctl = vlan_ioctl;
|
|
|
|
ifp->if_snd.ifq_maxlen = ifqmaxlen;
|
2006-01-31 16:41:05 +00:00
|
|
|
ifp->if_flags = VLAN_IFFLAGS;
|
2005-06-10 16:49:24 +00:00
|
|
|
ether_ifattach(ifp, eaddr);
|
2001-09-05 21:10:28 +00:00
|
|
|
/* Now undo some of the damage... */
|
2001-10-15 19:21:01 +00:00
|
|
|
ifp->if_baudrate = 0;
|
2002-11-14 23:43:16 +00:00
|
|
|
ifp->if_type = IFT_L2VLAN;
|
|
|
|
ifp->if_hdrlen = ETHER_VLAN_ENCAP_LEN;
|
2001-09-05 21:10:28 +00:00
|
|
|
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
if (ethertag) {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
error = vlan_config(ifv, p, tag);
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
if (error != 0) {
|
|
|
|
/*
|
|
|
|
* Since we've partialy failed, we need to back
|
|
|
|
* out all the way, otherwise userland could get
|
|
|
|
* confused. Thus, we destroy the interface.
|
|
|
|
*/
|
|
|
|
ether_ifdetach(ifp);
|
2006-06-29 07:52:30 +00:00
|
|
|
vlan_unconfig(ifp);
|
2005-06-10 16:49:24 +00:00
|
|
|
if_free_type(ifp, IFT_ETHER);
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
free(ifv, M_VLAN);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2005-10-03 02:24:21 +00:00
|
|
|
/* Update flags on the parent, if necessary. */
|
|
|
|
vlan_setflags(ifp, 1);
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
}
|
|
|
|
|
2001-09-05 21:10:28 +00:00
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
static int
|
|
|
|
vlan_clone_destroy(struct if_clone *ifc, struct ifnet *ifp)
|
2001-09-05 21:10:28 +00:00
|
|
|
{
|
|
|
|
struct ifvlan *ifv = ifp->if_softc;
|
2006-06-29 07:30:39 +00:00
|
|
|
int unit = ifp->if_dunit;
|
2004-07-22 22:50:15 +00:00
|
|
|
|
2006-06-29 07:52:30 +00:00
|
|
|
ether_ifdetach(ifp); /* first, remove it from system-wide lists */
|
|
|
|
vlan_unconfig(ifp); /* now it can be unconfigured and freed */
|
2005-08-15 20:27:34 +00:00
|
|
|
if_free_type(ifp, IFT_ETHER);
|
2001-09-05 21:10:28 +00:00
|
|
|
free(ifv, M_VLAN);
|
2004-07-22 22:50:15 +00:00
|
|
|
ifc_free_unit(ifc, unit);
|
|
|
|
|
Major overhaul of pseudo-interface cloning. Highlights include:
- Split the code out into if_clone.[ch].
- Locked struct if_clone. [1]
- Add a per-cloner match function rather then simply matching names of
the form <name><unit> and <name>.
- Use the match function to allow creation of <interface>.<tag>
vlan interfaces. The old way is preserved unchanged!
- Also the match function to allow creation of stf(4) interfaces named
stf0, stf, or 6to4. This is the only major user visible change in
that "ifconfig stf" creates the interface stf rather then stf0 and
does not print "stf0" to stdout.
- Allow destroy functions to fail so they can refuse to delete
interfaces. Currently, we forbid the deletion of interfaces which
were created in the init function, particularly lo0, pflog0, and
pfsync0. In the case of lo0 this was a panic implementation so it
does not count as a user visiable change. :-)
- Since most interfaces do not need the new functionality, an family of
wrapper functions, ifc_simple_*(), were created to wrap old style
cloner functions.
- The IF_CLONE_INITIALIZER macro is replaced with a new incompatible
IFC_CLONE_INITIALIZER and ifc_simple consumers use IFC_SIMPLE_DECLARE
instead.
Submitted by: Maurycy Pawlowski-Wieronski <maurycy at fouk.org> [1]
Reviewed by: andre, mlaier
Discussed on: net
2004-06-22 20:13:25 +00:00
|
|
|
return (0);
|
2001-09-05 21:10:28 +00:00
|
|
|
}
|
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
/*
|
|
|
|
* The ifp->if_init entry point for vlan(4) is a no-op.
|
|
|
|
*/
|
1998-03-18 01:40:12 +00:00
|
|
|
static void
|
2006-06-29 07:30:39 +00:00
|
|
|
vlan_init(void *foo __unused)
|
1998-03-18 01:40:12 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2005-11-06 19:43:04 +00:00
|
|
|
/*
|
|
|
|
* The if_start method for vlan(4) interface. It doesn't
|
|
|
|
* raises the IFF_DRV_OACTIVE flag, since it is called
|
|
|
|
* only from IFQ_HANDOFF() macro in ether_output_frame().
|
|
|
|
* If the interface queue is full, and vlan_start() is
|
|
|
|
* not called, the queue would never get emptied and
|
|
|
|
* interface would stall forever.
|
|
|
|
*/
|
1998-03-18 01:40:12 +00:00
|
|
|
static void
|
|
|
|
vlan_start(struct ifnet *ifp)
|
|
|
|
{
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
struct ifnet *p;
|
2000-02-07 06:18:38 +00:00
|
|
|
struct mbuf *m;
|
2004-06-15 23:57:42 +00:00
|
|
|
int error;
|
1998-03-18 01:40:12 +00:00
|
|
|
|
|
|
|
ifv = ifp->if_softc;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
p = PARENT(ifv);
|
1998-03-18 01:40:12 +00:00
|
|
|
|
|
|
|
for (;;) {
|
|
|
|
IF_DEQUEUE(&ifp->if_snd, m);
|
|
|
|
if (m == 0)
|
|
|
|
break;
|
2002-11-14 23:43:16 +00:00
|
|
|
BPF_MTAP(ifp, m);
|
1998-03-18 01:40:12 +00:00
|
|
|
|
2001-03-28 15:52:12 +00:00
|
|
|
/*
|
|
|
|
* Do not run parent's if_start() if the parent is not up,
|
|
|
|
* or parent's driver will cause a system crash.
|
|
|
|
*/
|
2005-08-09 10:20:02 +00:00
|
|
|
if (!((p->if_flags & IFF_UP) &&
|
|
|
|
(p->if_drv_flags & IFF_DRV_RUNNING))) {
|
2001-03-28 15:52:12 +00:00
|
|
|
m_freem(m);
|
2002-11-14 23:43:16 +00:00
|
|
|
ifp->if_collisions++;
|
2001-03-28 15:52:12 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2006-08-11 17:09:27 +00:00
|
|
|
/*
|
|
|
|
* Pad the frame to the minimum size allowed if told to.
|
|
|
|
* This option is in accord with IEEE Std 802.1Q, 2003 Ed.,
|
|
|
|
* paragraph C.4.4.3.b. It can help to work around buggy
|
|
|
|
* bridges that violate paragraph C.4.4.3.a from the same
|
|
|
|
* document, i.e., fail to pad short frames after untagging.
|
|
|
|
* E.g., a tagged frame 66 bytes long (incl. FCS) is OK, but
|
|
|
|
* untagging it will produce a 62-byte frame, which is a runt
|
|
|
|
* and requires padding. There are VLAN-enabled network
|
|
|
|
* devices that just discard such runts instead or mishandle
|
|
|
|
* them somehow.
|
|
|
|
*/
|
|
|
|
if (soft_pad) {
|
|
|
|
static char pad[8]; /* just zeros */
|
|
|
|
int n;
|
|
|
|
|
|
|
|
for (n = ETHERMIN + ETHER_HDR_LEN - m->m_pkthdr.len;
|
|
|
|
n > 0; n -= sizeof(pad))
|
|
|
|
if (!m_append(m, min(n, sizeof(pad)), pad))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (n > 0) {
|
|
|
|
if_printf(ifp, "cannot pad short frame\n");
|
|
|
|
ifp->if_oerrors++;
|
|
|
|
m_freem(m);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
/*
|
2002-11-14 23:43:16 +00:00
|
|
|
* If underlying interface can do VLAN tag insertion itself,
|
|
|
|
* just pass the packet along. However, we need some way to
|
|
|
|
* tell the interface where the packet came from so that it
|
|
|
|
* knows how to find the VLAN tag to use, so we attach a
|
|
|
|
* packet tag that holds it.
|
1998-03-18 01:40:12 +00:00
|
|
|
*/
|
2004-05-23 22:32:15 +00:00
|
|
|
if (p->if_capenable & IFCAP_VLAN_HWTAGGING) {
|
2006-09-17 13:33:30 +00:00
|
|
|
m->m_pkthdr.ether_vtag = ifv->ifv_tag;
|
2005-08-30 14:14:08 +00:00
|
|
|
m->m_flags |= M_VLANTAG;
|
1999-03-15 01:17:26 +00:00
|
|
|
} else {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ether_vlan_header *evl;
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
M_PREPEND(m, ifv->ifv_encaplen, M_DONTWAIT);
|
2000-02-03 07:44:39 +00:00
|
|
|
if (m == NULL) {
|
2004-05-26 11:41:26 +00:00
|
|
|
if_printf(ifp,
|
|
|
|
"unable to prepend VLAN header\n");
|
2003-11-12 12:58:19 +00:00
|
|
|
ifp->if_oerrors++;
|
1999-03-15 01:17:26 +00:00
|
|
|
continue;
|
2000-02-03 07:44:39 +00:00
|
|
|
}
|
1999-03-15 01:17:26 +00:00
|
|
|
/* M_PREPEND takes care of m_len, m_pkthdr.len for us */
|
|
|
|
|
2002-11-14 23:43:16 +00:00
|
|
|
if (m->m_len < sizeof(*evl)) {
|
|
|
|
m = m_pullup(m, sizeof(*evl));
|
|
|
|
if (m == NULL) {
|
|
|
|
if_printf(ifp,
|
2004-05-26 11:41:26 +00:00
|
|
|
"cannot pullup VLAN header\n");
|
2003-11-12 12:58:19 +00:00
|
|
|
ifp->if_oerrors++;
|
2002-11-14 23:43:16 +00:00
|
|
|
continue;
|
|
|
|
}
|
2000-02-03 07:44:39 +00:00
|
|
|
}
|
|
|
|
|
1999-03-15 01:17:26 +00:00
|
|
|
/*
|
|
|
|
* Transform the Ethernet header into an Ethernet header
|
|
|
|
* with 802.1Q encapsulation.
|
|
|
|
*/
|
2002-11-14 23:43:16 +00:00
|
|
|
bcopy(mtod(m, char *) + ifv->ifv_encaplen,
|
2003-03-03 05:04:57 +00:00
|
|
|
mtod(m, char *), ETHER_HDR_LEN);
|
1999-03-15 01:17:26 +00:00
|
|
|
evl = mtod(m, struct ether_vlan_header *);
|
|
|
|
evl->evl_proto = evl->evl_encap_proto;
|
2006-08-15 16:56:43 +00:00
|
|
|
evl->evl_encap_proto = htons(ifv->ifv_proto);
|
1999-03-15 01:17:26 +00:00
|
|
|
evl->evl_tag = htons(ifv->ifv_tag);
|
|
|
|
#ifdef DEBUG
|
2005-09-16 20:38:33 +00:00
|
|
|
printf("%s: %*D\n", __func__, (int)sizeof(*evl),
|
|
|
|
(unsigned char *)evl, ":");
|
1999-03-15 01:17:26 +00:00
|
|
|
#endif
|
|
|
|
}
|
1998-03-18 01:40:12 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Send it, precisely as ether_output() would have.
|
|
|
|
* We are already running at splimp.
|
|
|
|
*/
|
2004-06-15 23:57:42 +00:00
|
|
|
IFQ_HANDOFF(p, m, error);
|
|
|
|
if (!error)
|
1999-03-15 01:17:26 +00:00
|
|
|
ifp->if_opackets++;
|
Lock down the network interface queues. The queue mutex must be obtained
before adding/removing packets from the queue. Also, the if_obytes and
if_omcasts fields should only be manipulated under protection of the mutex.
IF_ENQUEUE, IF_PREPEND, and IF_DEQUEUE perform all necessary locking on
the queue. An IF_LOCK macro is provided, as well as the old (mutex-less)
versions of the macros in the form _IF_ENQUEUE, _IF_QFULL, for code which
needs them, but their use is discouraged.
Two new macros are introduced: IF_DRAIN() to drain a queue, and IF_HANDOFF,
which takes care of locking/enqueue, and also statistics updating/start
if necessary.
2000-11-25 07:35:38 +00:00
|
|
|
else
|
|
|
|
ifp->if_oerrors++;
|
1998-03-18 01:40:12 +00:00
|
|
|
}
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
2002-11-14 23:43:16 +00:00
|
|
|
static void
|
|
|
|
vlan_input(struct ifnet *ifp, struct mbuf *m)
|
1999-03-15 01:17:26 +00:00
|
|
|
{
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ifvlantrunk *trunk = ifp->if_vlantrunk;
|
1999-03-15 01:17:26 +00:00
|
|
|
struct ifvlan *ifv;
|
2006-09-17 13:33:30 +00:00
|
|
|
int inenc = 0;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
uint16_t tag;
|
|
|
|
|
|
|
|
KASSERT(trunk != NULL, ("%s: no trunk", __func__));
|
1999-03-15 01:17:26 +00:00
|
|
|
|
2005-09-16 11:44:43 +00:00
|
|
|
if (m->m_flags & M_VLANTAG) {
|
2002-11-14 23:43:16 +00:00
|
|
|
/*
|
2005-09-16 11:58:58 +00:00
|
|
|
* Packet is tagged, but m contains a normal
|
2002-11-14 23:43:16 +00:00
|
|
|
* Ethernet frame; the tag is stored out-of-band.
|
|
|
|
*/
|
2006-09-17 13:33:30 +00:00
|
|
|
tag = EVL_VLANOFTAG(m->m_pkthdr.ether_vtag);
|
2005-02-18 22:31:19 +00:00
|
|
|
m->m_flags &= ~M_VLANTAG;
|
2002-11-14 23:43:16 +00:00
|
|
|
} else {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ether_vlan_header *evl;
|
|
|
|
|
2005-09-16 11:58:58 +00:00
|
|
|
/*
|
|
|
|
* Packet is tagged in-band as specified by 802.1q.
|
|
|
|
*/
|
2006-09-17 13:33:30 +00:00
|
|
|
inenc = 1;
|
2002-11-14 23:43:16 +00:00
|
|
|
switch (ifp->if_type) {
|
|
|
|
case IFT_ETHER:
|
2004-07-04 16:43:24 +00:00
|
|
|
if (m->m_len < sizeof(*evl) &&
|
|
|
|
(m = m_pullup(m, sizeof(*evl))) == NULL) {
|
2002-11-14 23:43:16 +00:00
|
|
|
if_printf(ifp, "cannot pullup VLAN header\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
evl = mtod(m, struct ether_vlan_header *);
|
2003-07-08 21:54:20 +00:00
|
|
|
tag = EVL_VLANOFTAG(ntohs(evl->evl_tag));
|
2006-08-03 09:50:15 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Restore the original ethertype. We'll remove
|
|
|
|
* the encapsulation after we've found the vlan
|
|
|
|
* interface corresponding to the tag.
|
|
|
|
*/
|
|
|
|
evl->evl_encap_proto = evl->evl_proto;
|
2002-11-14 23:43:16 +00:00
|
|
|
break;
|
|
|
|
default:
|
2006-08-03 09:50:15 +00:00
|
|
|
#ifdef INVARIANTS
|
2006-08-03 09:59:08 +00:00
|
|
|
panic("%s: %s has unsupported if_type %u",
|
|
|
|
__func__, ifp->if_xname, ifp->if_type);
|
2002-11-14 23:43:16 +00:00
|
|
|
#endif
|
2006-08-03 09:59:08 +00:00
|
|
|
m_freem(m);
|
|
|
|
ifp->if_noproto++;
|
|
|
|
return;
|
2002-11-14 23:43:16 +00:00
|
|
|
}
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
2006-06-21 13:48:34 +00:00
|
|
|
TRUNK_RLOCK(trunk);
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#ifdef VLAN_ARRAY
|
|
|
|
ifv = trunk->vlans[tag];
|
|
|
|
#else
|
|
|
|
ifv = vlan_gethash(trunk, tag);
|
2006-06-21 13:48:34 +00:00
|
|
|
#endif
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (ifv == NULL || (ifv->ifv_ifp->if_flags & IFF_UP) == 0) {
|
|
|
|
TRUNK_RUNLOCK(trunk);
|
|
|
|
m_freem(m);
|
|
|
|
ifp->if_noproto++;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
TRUNK_RUNLOCK(trunk);
|
1998-03-18 01:40:12 +00:00
|
|
|
|
2006-09-17 13:33:30 +00:00
|
|
|
if (inenc) {
|
2002-11-14 23:43:16 +00:00
|
|
|
/*
|
|
|
|
* Packet had an in-line encapsulation header;
|
2006-08-03 09:50:15 +00:00
|
|
|
* remove it. The original header has already
|
|
|
|
* been fixed up above.
|
2002-11-14 23:43:16 +00:00
|
|
|
*/
|
|
|
|
bcopy(mtod(m, caddr_t),
|
|
|
|
mtod(m, caddr_t) + ETHER_VLAN_ENCAP_LEN,
|
2006-08-03 09:50:15 +00:00
|
|
|
ETHER_HDR_LEN);
|
2002-11-14 23:43:16 +00:00
|
|
|
m_adj(m, ETHER_VLAN_ENCAP_LEN);
|
|
|
|
}
|
1998-03-18 01:40:12 +00:00
|
|
|
|
2005-06-10 16:49:24 +00:00
|
|
|
m->m_pkthdr.rcvif = ifv->ifv_ifp;
|
|
|
|
ifv->ifv_ifp->if_ipackets++;
|
2002-11-14 23:43:16 +00:00
|
|
|
|
|
|
|
/* Pass it back through the parent's input routine. */
|
2005-06-10 16:49:24 +00:00
|
|
|
(*ifp->if_input)(ifv->ifv_ifp, m);
|
1998-03-18 01:40:12 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
vlan_config(struct ifvlan *ifv, struct ifnet *p, uint16_t tag)
|
1998-03-18 01:40:12 +00:00
|
|
|
{
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ifvlantrunk *trunk;
|
2005-10-03 02:24:21 +00:00
|
|
|
struct ifnet *ifp;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
int error = 0;
|
1998-03-18 01:40:12 +00:00
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
/* VID numbers 0x0 and 0xFFF are reserved */
|
|
|
|
if (tag == 0 || tag == 0xFFF)
|
|
|
|
return (EINVAL);
|
2005-10-03 02:24:21 +00:00
|
|
|
if (p->if_type != IFT_ETHER)
|
2004-07-04 16:43:24 +00:00
|
|
|
return (EPROTONOSUPPORT);
|
2006-01-31 16:41:05 +00:00
|
|
|
if ((p->if_flags & VLAN_IFFLAGS) != VLAN_IFFLAGS)
|
|
|
|
return (EPROTONOSUPPORT);
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (ifv->ifv_trunk)
|
2004-07-04 16:43:24 +00:00
|
|
|
return (EBUSY);
|
1998-03-18 01:40:12 +00:00
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (p->if_vlantrunk == NULL) {
|
|
|
|
trunk = malloc(sizeof(struct ifvlantrunk),
|
|
|
|
M_VLAN, M_WAITOK | M_ZERO);
|
2006-02-02 22:11:38 +00:00
|
|
|
#ifndef VLAN_ARRAY
|
|
|
|
vlan_inithash(trunk);
|
|
|
|
#endif
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
VLAN_LOCK();
|
|
|
|
if (p->if_vlantrunk != NULL) {
|
|
|
|
/* A race that that is very unlikely to be hit. */
|
2006-02-02 22:11:38 +00:00
|
|
|
#ifndef VLAN_ARRAY
|
|
|
|
vlan_freehash(trunk);
|
|
|
|
#endif
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
free(trunk, M_VLAN);
|
|
|
|
goto exists;
|
|
|
|
}
|
|
|
|
TRUNK_LOCK_INIT(trunk);
|
|
|
|
LIST_INSERT_HEAD(&trunk_list, trunk, trunk_entry);
|
|
|
|
TRUNK_LOCK(trunk);
|
|
|
|
p->if_vlantrunk = trunk;
|
|
|
|
trunk->parent = p;
|
|
|
|
} else {
|
|
|
|
VLAN_LOCK();
|
|
|
|
exists:
|
|
|
|
trunk = p->if_vlantrunk;
|
|
|
|
TRUNK_LOCK(trunk);
|
|
|
|
}
|
|
|
|
|
2006-06-21 13:48:34 +00:00
|
|
|
ifv->ifv_tag = tag; /* must set this before vlan_inshash() */
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#ifdef VLAN_ARRAY
|
2006-06-21 13:48:34 +00:00
|
|
|
if (trunk->vlans[tag] != NULL) {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
error = EEXIST;
|
2006-06-21 13:48:34 +00:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
trunk->vlans[tag] = ifv;
|
|
|
|
trunk->refcnt++;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#else
|
|
|
|
error = vlan_inshash(trunk, ifv);
|
|
|
|
if (error)
|
|
|
|
goto done;
|
2006-06-21 13:48:34 +00:00
|
|
|
#endif
|
2006-08-15 16:56:43 +00:00
|
|
|
ifv->ifv_proto = ETHERTYPE_VLAN;
|
2002-11-14 23:43:16 +00:00
|
|
|
ifv->ifv_encaplen = ETHER_VLAN_ENCAP_LEN;
|
|
|
|
ifv->ifv_mintu = ETHERMIN;
|
2005-10-03 02:24:21 +00:00
|
|
|
ifv->ifv_pflags = 0;
|
2002-11-14 23:43:16 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If the parent supports the VLAN_MTU capability,
|
|
|
|
* i.e. can Tx/Rx larger than ETHER_MAX_LEN frames,
|
2004-05-25 14:30:12 +00:00
|
|
|
* use it.
|
2002-11-14 23:43:16 +00:00
|
|
|
*/
|
2004-05-25 14:30:12 +00:00
|
|
|
if (p->if_capenable & IFCAP_VLAN_MTU) {
|
2002-11-14 23:43:16 +00:00
|
|
|
/*
|
2004-05-25 14:30:12 +00:00
|
|
|
* No need to fudge the MTU since the parent can
|
|
|
|
* handle extended frames.
|
2002-11-14 23:43:16 +00:00
|
|
|
*/
|
|
|
|
ifv->ifv_mtufudge = 0;
|
2004-05-25 14:30:12 +00:00
|
|
|
} else {
|
2002-11-14 23:43:16 +00:00
|
|
|
/*
|
|
|
|
* Fudge the MTU by the encapsulation size. This
|
|
|
|
* makes us incompatible with strictly compliant
|
|
|
|
* 802.1Q implementations, but allows us to use
|
|
|
|
* the feature with other NetBSD implementations,
|
|
|
|
* which might still be useful.
|
|
|
|
*/
|
|
|
|
ifv->ifv_mtufudge = ifv->ifv_encaplen;
|
|
|
|
}
|
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
ifv->ifv_trunk = trunk;
|
2005-10-03 02:24:21 +00:00
|
|
|
ifp = ifv->ifv_ifp;
|
|
|
|
ifp->if_mtu = p->if_mtu - ifv->ifv_mtufudge;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
ifp->if_baudrate = p->if_baudrate;
|
1998-03-18 01:40:12 +00:00
|
|
|
/*
|
2001-03-28 15:52:12 +00:00
|
|
|
* Copy only a selected subset of flags from the parent.
|
|
|
|
* Other flags are none of our business.
|
1998-03-18 01:40:12 +00:00
|
|
|
*/
|
2006-01-31 16:41:05 +00:00
|
|
|
#define VLAN_COPY_FLAGS (IFF_SIMPLEX)
|
2005-10-03 02:24:21 +00:00
|
|
|
ifp->if_flags &= ~VLAN_COPY_FLAGS;
|
|
|
|
ifp->if_flags |= p->if_flags & VLAN_COPY_FLAGS;
|
|
|
|
#undef VLAN_COPY_FLAGS
|
|
|
|
|
|
|
|
ifp->if_link_state = p->if_link_state;
|
1998-03-18 01:40:12 +00:00
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
vlan_capabilities(ifv);
|
2002-11-14 23:43:16 +00:00
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
/*
|
|
|
|
* Set up our ``Ethernet address'' to reflect the underlying
|
|
|
|
* physical interface's.
|
|
|
|
*/
|
2005-11-11 07:36:14 +00:00
|
|
|
bcopy(IF_LLADDR(p), IF_LLADDR(ifp), ETHER_ADDR_LEN);
|
2001-07-24 17:14:37 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Configure multicast addresses that may already be
|
|
|
|
* joined on the vlan device.
|
|
|
|
*/
|
2005-10-03 02:24:21 +00:00
|
|
|
(void)vlan_setmulti(ifp); /* XXX: VLAN lock held */
|
2006-08-15 16:40:27 +00:00
|
|
|
|
|
|
|
/* We are ready for operation now. */
|
|
|
|
ifp->if_drv_flags |= IFF_DRV_RUNNING;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
done:
|
|
|
|
TRUNK_UNLOCK(trunk);
|
|
|
|
VLAN_UNLOCK();
|
|
|
|
|
|
|
|
return (error);
|
1998-03-18 01:40:12 +00:00
|
|
|
}
|
|
|
|
|
1999-03-15 01:17:26 +00:00
|
|
|
static int
|
|
|
|
vlan_unconfig(struct ifnet *ifp)
|
2006-06-21 07:29:44 +00:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
VLAN_LOCK();
|
|
|
|
ret = vlan_unconfig_locked(ifp);
|
|
|
|
VLAN_UNLOCK();
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
vlan_unconfig_locked(struct ifnet *ifp)
|
1999-03-15 01:17:26 +00:00
|
|
|
{
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ifvlantrunk *trunk;
|
1999-03-15 01:17:26 +00:00
|
|
|
struct vlan_mc_entry *mc;
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
int error;
|
|
|
|
|
2006-06-21 07:29:44 +00:00
|
|
|
VLAN_LOCK_ASSERT();
|
2003-09-05 20:58:59 +00:00
|
|
|
|
1999-03-15 01:17:26 +00:00
|
|
|
ifv = ifp->if_softc;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
trunk = ifv->ifv_trunk;
|
1999-03-15 01:17:26 +00:00
|
|
|
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (trunk) {
|
2001-07-24 17:14:37 +00:00
|
|
|
struct sockaddr_dl sdl;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ifnet *p = trunk->parent;
|
|
|
|
|
|
|
|
TRUNK_LOCK(trunk);
|
1999-03-15 01:17:26 +00:00
|
|
|
|
2001-07-24 17:14:37 +00:00
|
|
|
/*
|
|
|
|
* Since the interface is being unconfigured, we need to
|
|
|
|
* empty the list of multicast groups that we may have joined
|
|
|
|
* while we were alive from the parent's list.
|
|
|
|
*/
|
2004-07-04 16:43:24 +00:00
|
|
|
bzero((char *)&sdl, sizeof(sdl));
|
|
|
|
sdl.sdl_len = sizeof(sdl);
|
1999-03-15 01:17:26 +00:00
|
|
|
sdl.sdl_family = AF_LINK;
|
2001-07-24 17:14:37 +00:00
|
|
|
sdl.sdl_index = p->if_index;
|
|
|
|
sdl.sdl_type = IFT_ETHER;
|
|
|
|
sdl.sdl_alen = ETHER_ADDR_LEN;
|
|
|
|
|
|
|
|
while(SLIST_FIRST(&ifv->vlan_mc_listhead) != NULL) {
|
|
|
|
mc = SLIST_FIRST(&ifv->vlan_mc_listhead);
|
2004-07-04 16:43:24 +00:00
|
|
|
bcopy((char *)&mc->mc_addr, LLADDR(&sdl),
|
|
|
|
ETHER_ADDR_LEN);
|
2001-07-24 17:14:37 +00:00
|
|
|
error = if_delmulti(p, (struct sockaddr *)&sdl);
|
|
|
|
if (error)
|
2004-07-04 16:43:24 +00:00
|
|
|
return (error);
|
2001-07-24 17:14:37 +00:00
|
|
|
SLIST_REMOVE_HEAD(&ifv->vlan_mc_listhead, mc_entries);
|
2001-09-05 21:10:28 +00:00
|
|
|
free(mc, M_VLAN);
|
2001-07-24 17:14:37 +00:00
|
|
|
}
|
2002-11-14 23:43:16 +00:00
|
|
|
|
2005-10-03 02:24:21 +00:00
|
|
|
vlan_setflags(ifp, 0); /* clear special flags on parent */
|
2006-06-21 13:48:34 +00:00
|
|
|
#ifdef VLAN_ARRAY
|
|
|
|
trunk->vlans[ifv->ifv_tag] = NULL;
|
|
|
|
trunk->refcnt--;
|
|
|
|
#else
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
vlan_remhash(trunk, ifv);
|
|
|
|
#endif
|
|
|
|
ifv->ifv_trunk = NULL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if we were the last.
|
|
|
|
*/
|
|
|
|
if (trunk->refcnt == 0) {
|
2006-06-21 13:48:34 +00:00
|
|
|
trunk->parent->if_vlantrunk = NULL;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
/*
|
|
|
|
* XXXGL: If some ithread has already entered
|
|
|
|
* vlan_input() and is now blocked on the trunk
|
|
|
|
* lock, then it should preempt us right after
|
|
|
|
* unlock and finish its work. Then we will acquire
|
|
|
|
* lock again in trunk_destroy().
|
|
|
|
*/
|
|
|
|
TRUNK_UNLOCK(trunk);
|
|
|
|
trunk_destroy(trunk);
|
|
|
|
} else
|
|
|
|
TRUNK_UNLOCK(trunk);
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Disconnect from parent. */
|
2005-10-03 02:24:21 +00:00
|
|
|
if (ifv->ifv_pflags)
|
|
|
|
if_printf(ifp, "%s: ifv_pflags unclean\n", __func__);
|
2006-06-21 07:29:44 +00:00
|
|
|
ifp->if_mtu = ETHERMTU;
|
|
|
|
ifp->if_link_state = LINK_STATE_UNKNOWN;
|
|
|
|
ifp->if_drv_flags &= ~IFF_DRV_RUNNING;
|
1999-03-15 01:17:26 +00:00
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
return (0);
|
1999-03-15 01:17:26 +00:00
|
|
|
}
|
|
|
|
|
2005-10-03 02:24:21 +00:00
|
|
|
/* Handle a reference counted flag that should be set on the parent as well */
|
2002-11-14 23:43:16 +00:00
|
|
|
static int
|
2005-10-03 02:24:21 +00:00
|
|
|
vlan_setflag(struct ifnet *ifp, int flag, int status,
|
|
|
|
int (*func)(struct ifnet *, int))
|
2002-11-14 23:43:16 +00:00
|
|
|
{
|
2005-10-03 02:24:21 +00:00
|
|
|
struct ifvlan *ifv;
|
|
|
|
int error;
|
2002-11-14 23:43:16 +00:00
|
|
|
|
2005-10-03 02:24:21 +00:00
|
|
|
/* XXX VLAN_LOCK_ASSERT(); */
|
|
|
|
|
|
|
|
ifv = ifp->if_softc;
|
|
|
|
status = status ? (ifp->if_flags & flag) : 0;
|
|
|
|
/* Now "status" contains the flag value or 0 */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* See if recorded parent's status is different from what
|
|
|
|
* we want it to be. If it is, flip it. We record parent's
|
|
|
|
* status in ifv_pflags so that we won't clear parent's flag
|
|
|
|
* we haven't set. In fact, we don't clear or set parent's
|
|
|
|
* flags directly, but get or release references to them.
|
|
|
|
* That's why we can be sure that recorded flags still are
|
|
|
|
* in accord with actual parent's flags.
|
|
|
|
*/
|
|
|
|
if (status != (ifv->ifv_pflags & flag)) {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
error = (*func)(PARENT(ifv), status);
|
2005-10-03 02:24:21 +00:00
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
ifv->ifv_pflags &= ~flag;
|
|
|
|
ifv->ifv_pflags |= status;
|
2002-11-14 23:43:16 +00:00
|
|
|
}
|
2005-10-03 02:24:21 +00:00
|
|
|
return (0);
|
|
|
|
}
|
2002-11-14 23:43:16 +00:00
|
|
|
|
2005-10-03 02:24:21 +00:00
|
|
|
/*
|
|
|
|
* Handle IFF_* flags that require certain changes on the parent:
|
|
|
|
* if "status" is true, update parent's flags respective to our if_flags;
|
|
|
|
* if "status" is false, forcedly clear the flags set on parent.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
vlan_setflags(struct ifnet *ifp, int status)
|
|
|
|
{
|
|
|
|
int error, i;
|
|
|
|
|
|
|
|
for (i = 0; vlan_pflags[i].flag; i++) {
|
|
|
|
error = vlan_setflag(ifp, vlan_pflags[i].flag,
|
|
|
|
status, vlan_pflags[i].func);
|
|
|
|
if (error)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
return (0);
|
2002-11-14 23:43:16 +00:00
|
|
|
}
|
|
|
|
|
2004-05-03 13:48:35 +00:00
|
|
|
/* Inform all vlans that their parent has changed link state */
|
|
|
|
static void
|
|
|
|
vlan_link_state(struct ifnet *ifp, int link)
|
|
|
|
{
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
struct ifvlantrunk *trunk = ifp->if_vlantrunk;
|
2004-05-03 13:48:35 +00:00
|
|
|
struct ifvlan *ifv;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
int i;
|
|
|
|
|
|
|
|
TRUNK_LOCK(trunk);
|
|
|
|
#ifdef VLAN_ARRAY
|
2006-06-21 13:48:34 +00:00
|
|
|
for (i = 0; i < VLAN_ARRAY_SIZE; i++)
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (trunk->vlans[i] != NULL) {
|
|
|
|
ifv = trunk->vlans[i];
|
|
|
|
#else
|
2006-10-11 10:06:35 +00:00
|
|
|
for (i = 0; i < (1 << trunk->hwidth); i++)
|
|
|
|
LIST_FOREACH(ifv, &trunk->hash[i], ifv_list) {
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
#endif
|
2006-10-11 10:06:35 +00:00
|
|
|
ifv->ifv_ifp->if_baudrate = trunk->parent->if_baudrate;
|
2005-06-10 16:49:24 +00:00
|
|
|
if_link_state_change(ifv->ifv_ifp,
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
trunk->parent->if_link_state);
|
2006-10-11 10:06:35 +00:00
|
|
|
}
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
TRUNK_UNLOCK(trunk);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vlan_capabilities(struct ifvlan *ifv)
|
|
|
|
{
|
|
|
|
struct ifnet *p = PARENT(ifv);
|
|
|
|
struct ifnet *ifp = ifv->ifv_ifp;
|
|
|
|
|
|
|
|
TRUNK_LOCK_ASSERT(TRUNK(ifv));
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the parent interface can do checksum offloading
|
|
|
|
* on VLANs, then propagate its hardware-assisted
|
|
|
|
* checksumming flags. Also assert that checksum
|
|
|
|
* offloading requires hardware VLAN tagging.
|
|
|
|
*/
|
|
|
|
if (p->if_capabilities & IFCAP_VLAN_HWCSUM)
|
|
|
|
ifp->if_capabilities = p->if_capabilities & IFCAP_HWCSUM;
|
|
|
|
|
|
|
|
if (p->if_capenable & IFCAP_VLAN_HWCSUM &&
|
|
|
|
p->if_capenable & IFCAP_VLAN_HWTAGGING) {
|
|
|
|
ifp->if_capenable = p->if_capenable & IFCAP_HWCSUM;
|
|
|
|
ifp->if_hwassist = p->if_hwassist;
|
|
|
|
} else {
|
|
|
|
ifp->if_capenable = 0;
|
|
|
|
ifp->if_hwassist = 0;
|
2004-05-03 13:48:35 +00:00
|
|
|
}
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
vlan_trunk_capabilities(struct ifnet *ifp)
|
|
|
|
{
|
|
|
|
struct ifvlantrunk *trunk = ifp->if_vlantrunk;
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
TRUNK_LOCK(trunk);
|
|
|
|
#ifdef VLAN_ARRAY
|
2006-06-21 13:48:34 +00:00
|
|
|
for (i = 0; i < VLAN_ARRAY_SIZE; i++)
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (trunk->vlans[i] != NULL) {
|
|
|
|
ifv = trunk->vlans[i];
|
|
|
|
#else
|
|
|
|
for (i = 0; i < (1 << trunk->hwidth); i++) {
|
|
|
|
LIST_FOREACH(ifv, &trunk->hash[i], ifv_list)
|
|
|
|
#endif
|
|
|
|
vlan_capabilities(ifv);
|
|
|
|
}
|
|
|
|
TRUNK_UNLOCK(trunk);
|
2004-05-03 13:48:35 +00:00
|
|
|
}
|
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
static int
|
1998-08-23 03:07:17 +00:00
|
|
|
vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
|
1998-03-18 01:40:12 +00:00
|
|
|
{
|
|
|
|
struct ifaddr *ifa;
|
|
|
|
struct ifnet *p;
|
|
|
|
struct ifreq *ifr;
|
|
|
|
struct ifvlan *ifv;
|
|
|
|
struct vlanreq vlr;
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
ifr = (struct ifreq *)data;
|
|
|
|
ifa = (struct ifaddr *)data;
|
|
|
|
ifv = ifp->if_softc;
|
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case SIOCSIFADDR:
|
|
|
|
ifp->if_flags |= IFF_UP;
|
|
|
|
|
|
|
|
switch (ifa->ifa_addr->sa_family) {
|
|
|
|
#ifdef INET
|
|
|
|
case AF_INET:
|
2005-06-10 16:49:24 +00:00
|
|
|
arp_ifinit(ifv->ifv_ifp, ifa);
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
|
|
|
#endif
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCGIFADDR:
|
|
|
|
{
|
|
|
|
struct sockaddr *sa;
|
|
|
|
|
|
|
|
sa = (struct sockaddr *) &ifr->ifr_data;
|
2005-11-11 16:04:59 +00:00
|
|
|
bcopy(IF_LLADDR(ifp), (caddr_t)sa->sa_data,
|
2004-07-04 16:43:24 +00:00
|
|
|
ETHER_ADDR_LEN);
|
1998-03-18 01:40:12 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2003-01-22 23:30:26 +00:00
|
|
|
case SIOCGIFMEDIA:
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_LOCK();
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (TRUNK(ifv) != NULL) {
|
|
|
|
error = (*PARENT(ifv)->if_ioctl)(PARENT(ifv),
|
2003-09-05 20:58:59 +00:00
|
|
|
SIOCGIFMEDIA, data);
|
|
|
|
VLAN_UNLOCK();
|
2003-01-22 23:30:26 +00:00
|
|
|
/* Limit the result to the parent's current config. */
|
|
|
|
if (error == 0) {
|
|
|
|
struct ifmediareq *ifmr;
|
|
|
|
|
2004-07-04 16:43:24 +00:00
|
|
|
ifmr = (struct ifmediareq *)data;
|
2003-01-22 23:30:26 +00:00
|
|
|
if (ifmr->ifm_count >= 1 && ifmr->ifm_ulist) {
|
|
|
|
ifmr->ifm_count = 1;
|
|
|
|
error = copyout(&ifmr->ifm_current,
|
2004-07-04 16:43:24 +00:00
|
|
|
ifmr->ifm_ulist,
|
2003-01-22 23:30:26 +00:00
|
|
|
sizeof(int));
|
|
|
|
}
|
|
|
|
}
|
2003-09-05 20:58:59 +00:00
|
|
|
} else {
|
|
|
|
VLAN_UNLOCK();
|
2003-01-22 23:30:26 +00:00
|
|
|
error = EINVAL;
|
2003-09-05 20:58:59 +00:00
|
|
|
}
|
2003-01-22 23:30:26 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFMEDIA:
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
case SIOCSIFMTU:
|
|
|
|
/*
|
|
|
|
* Set the interface MTU.
|
|
|
|
*/
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_LOCK();
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (TRUNK(ifv) != NULL) {
|
2002-11-14 23:43:16 +00:00
|
|
|
if (ifr->ifr_mtu >
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
(PARENT(ifv)->if_mtu - ifv->ifv_mtufudge) ||
|
2002-11-14 23:43:16 +00:00
|
|
|
ifr->ifr_mtu <
|
|
|
|
(ifv->ifv_mintu - ifv->ifv_mtufudge))
|
|
|
|
error = EINVAL;
|
|
|
|
else
|
|
|
|
ifp->if_mtu = ifr->ifr_mtu;
|
|
|
|
} else
|
1998-03-18 01:40:12 +00:00
|
|
|
error = EINVAL;
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_UNLOCK();
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSETVLAN:
|
2004-07-04 16:43:24 +00:00
|
|
|
error = copyin(ifr->ifr_data, &vlr, sizeof(vlr));
|
1998-03-18 01:40:12 +00:00
|
|
|
if (error)
|
|
|
|
break;
|
|
|
|
if (vlr.vlr_parent[0] == '\0') {
|
1999-03-15 01:17:26 +00:00
|
|
|
vlan_unconfig(ifp);
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
p = ifunit(vlr.vlr_parent);
|
|
|
|
if (p == 0) {
|
|
|
|
error = ENOENT;
|
|
|
|
break;
|
|
|
|
}
|
2003-07-08 21:54:20 +00:00
|
|
|
/*
|
|
|
|
* Don't let the caller set up a VLAN tag with
|
|
|
|
* anything except VLID bits.
|
|
|
|
*/
|
|
|
|
if (vlr.vlr_tag & ~EVL_VLID_MASK) {
|
|
|
|
error = EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
error = vlan_config(ifv, p, vlr.vlr_tag);
|
|
|
|
if (error)
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
2002-11-14 23:43:16 +00:00
|
|
|
|
2005-10-03 02:24:21 +00:00
|
|
|
/* Update flags on the parent, if necessary. */
|
|
|
|
vlan_setflags(ifp, 1);
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
2004-07-04 16:43:24 +00:00
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
case SIOCGETVLAN:
|
2004-07-04 16:43:24 +00:00
|
|
|
bzero(&vlr, sizeof(vlr));
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_LOCK();
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (TRUNK(ifv) != NULL) {
|
|
|
|
strlcpy(vlr.vlr_parent, PARENT(ifv)->if_xname,
|
2003-10-31 18:32:15 +00:00
|
|
|
sizeof(vlr.vlr_parent));
|
1998-03-18 01:40:12 +00:00
|
|
|
vlr.vlr_tag = ifv->ifv_tag;
|
|
|
|
}
|
2003-09-05 20:58:59 +00:00
|
|
|
VLAN_UNLOCK();
|
2004-07-04 16:43:24 +00:00
|
|
|
error = copyout(&vlr, ifr->ifr_data, sizeof(vlr));
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFFLAGS:
|
|
|
|
/*
|
2005-10-03 02:24:21 +00:00
|
|
|
* We should propagate selected flags to the parent,
|
|
|
|
* e.g., promiscuous mode.
|
1998-03-18 01:40:12 +00:00
|
|
|
*/
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
if (TRUNK(ifv) != NULL)
|
2005-10-03 02:24:21 +00:00
|
|
|
error = vlan_setflags(ifp, 1);
|
1998-03-18 01:40:12 +00:00
|
|
|
break;
|
2002-11-14 23:43:16 +00:00
|
|
|
|
1999-03-15 01:17:26 +00:00
|
|
|
case SIOCADDMULTI:
|
|
|
|
case SIOCDELMULTI:
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
/*
|
|
|
|
* If we don't have a parent, just remember the membership for
|
|
|
|
* when we do.
|
|
|
|
*/
|
|
|
|
if (TRUNK(ifv) != NULL)
|
|
|
|
error = vlan_setmulti(ifp);
|
1999-03-15 01:17:26 +00:00
|
|
|
break;
|
Merge the //depot/user/yar/vlan branch into CVS. It contains some collective
work by yar, thompsa and myself. The checksum offloading part also involves
work done by Mihail Balikov.
The most important changes:
o Instead of global linked list of all vlan softc use a per-trunk
hash. The size of hash is dynamically adjusted, depending on
number of entries. This changes struct ifnet, replacing counter
of vlans with a pointer to trunk structure. This change is an
improvement for setups with big number of VLANs, several interfaces
and several CPUs. It is a small regression for a setup with a single
VLAN interface.
An alternative to dynamic hash is a per-trunk static array with
4096 entries, which is a compile time option - VLAN_ARRAY. In my
experiments the array is not an improvement, probably because such
a big trunk structure doesn't fit into CPU cache.
o Introduce an UMA zone for VLAN tags. Since drivers depend on it,
the zone is declared in kern_mbuf.c, not in optional vlan(4) driver.
This change is a big improvement for any setup utilizing vlan(4).
o Use rwlock(9) instead of mutex(9) for locking. We are the first
ones to do this! :)
o Some drivers can do hardware VLAN tagging + hardware checksum
offloading. Add an infrastructure for this. Whenever vlan(4) is
attached to a parent or parent configuration is changed, the flags
on vlan(4) interface are updated.
In collaboration with: yar, thompsa
In collaboration with: Mihail Balikov <mihail.balikov interbgc.com>
2006-01-30 13:45:15 +00:00
|
|
|
|
1998-03-18 01:40:12 +00:00
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
}
|
2004-07-04 16:43:24 +00:00
|
|
|
|
|
|
|
return (error);
|
1998-03-18 01:40:12 +00:00
|
|
|
}
|