xnu-1699.22.81.tar.gz

[apple/xnu.git] / bsd / net / if_vlan.c

diff --git a/bsd/net/if_vlan.c b/bsd/net/if_vlan.c
index 74f9e99ba61936f0152371b28d03e6d8c2081cff..cf090602d57821ebb41944997cce34e1171751ef 100644 (file)
--- a/bsd/net/if_vlan.c
+++ b/bsd/net/if_vlan.c
@@ -1,23 +1,29 @@
 /*
 /*

- * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003-2011 Apple Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
 /*
  * Copyright 1998 Massachusetts Institute of Technology
  */
 /*
  * Copyright 1998 Massachusetts Institute of Technology


@@ -73,141 +79,498 @@
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/kern_event.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/kern_event.h>

+#include <sys/mcache.h>

 
 #include <net/bpf.h>
 #include <net/ethernet.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <net/if_dl.h>
 
 #include <net/bpf.h>
 #include <net/ethernet.h>
 #include <net/if.h>
 #include <net/if_arp.h>
 #include <net/if_dl.h>

+#include <net/if_ether.h>

 #include <net/if_types.h>
 #include <net/if_vlan_var.h>
 #include <net/if_types.h>
 #include <net/if_vlan_var.h>

+#include <libkern/OSAtomic.h>

 
 #include <net/dlil.h>
 
 
 #include <net/dlil.h>
 

+#include <net/kpi_interface.h>
+#include <net/kpi_protocol.h>
+
+#include <kern/locks.h>
+

 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 #endif
 
 #include <net/if_media.h>
 #ifdef INET
 #include <netinet/in.h>
 #include <netinet/if_ether.h>
 #endif
 
 #include <net/if_media.h>

-
-#define        ETHER_VLAN_ENCAP_LEN    4       /* len of 802.1Q VLAN encapsulation */
-#define        IF_MAXUNIT      0x7fff          /* historical value */
-
-#define IFP2AC(p) ((struct arpcom *)p)
-
-#define VLAN_PROTO_FAMILY      0x766c616e /* 'vlan' */
+#include <net/multicast_list.h>
+#include <net/ether_if_module.h>

 
 #define VLANNAME       "vlan"
 
 typedef int (bpf_callback_func)(struct ifnet *, struct mbuf *);
 typedef int (if_set_bpf_tap_func)(struct ifnet *ifp, int mode, bpf_callback_func * func);
 
 
 #define VLANNAME       "vlan"
 
 typedef int (bpf_callback_func)(struct ifnet *, struct mbuf *);
 typedef int (if_set_bpf_tap_func)(struct ifnet *ifp, int mode, bpf_callback_func * func);
 

-struct vlan_mc_entry {
-    struct ether_addr          mc_addr;
-    SLIST_ENTRY(vlan_mc_entry) mc_entries;
-};
+/**
+ ** vlan locks
+ **/
+static __inline__ lck_grp_t *
+my_lck_grp_alloc_init(const char * grp_name)
+{
+    lck_grp_t *                grp;
+    lck_grp_attr_t *   grp_attrs;
+    
+    grp_attrs = lck_grp_attr_alloc_init();
+    grp = lck_grp_alloc_init(grp_name, grp_attrs);
+    lck_grp_attr_free(grp_attrs);
+    return (grp);
+}
+
+static __inline__ lck_mtx_t *
+my_lck_mtx_alloc_init(lck_grp_t * lck_grp)
+{
+    lck_attr_t *       lck_attrs;
+    lck_mtx_t *                lck_mtx;
+
+    lck_attrs = lck_attr_alloc_init();
+    lck_mtx = lck_mtx_alloc_init(lck_grp, lck_attrs);
+    lck_attr_free(lck_attrs);
+    return (lck_mtx);
+}
+
+static lck_mtx_t *     vlan_lck_mtx;
+
+static __inline__ void
+vlan_lock_init(void)
+{
+    lck_grp_t *                vlan_lck_grp;
+
+    vlan_lck_grp = my_lck_grp_alloc_init("if_vlan");
+    vlan_lck_mtx = my_lck_mtx_alloc_init(vlan_lck_grp);
+}
+
+static __inline__ void
+vlan_assert_lock_held(void)
+{
+    lck_mtx_assert(vlan_lck_mtx, LCK_MTX_ASSERT_OWNED);
+    return;
+}
+
+static __inline__ void
+vlan_assert_lock_not_held(void)
+{
+    lck_mtx_assert(vlan_lck_mtx, LCK_MTX_ASSERT_NOTOWNED);
+    return;
+}
+
+static __inline__ void
+vlan_lock(void)
+{
+    lck_mtx_lock(vlan_lck_mtx);
+    return;
+}
+
+static __inline__ void
+vlan_unlock(void)
+{
+    lck_mtx_unlock(vlan_lck_mtx);
+    return;
+}

 
 

-struct ifvlan {
-    char       ifv_name[IFNAMSIZ]; /* our unique id */
-    struct  ifnet *ifv_ifp;  /* our interface */
-    struct     ifnet *ifv_p;   /* parent interface of this vlan */
+/**
+ ** vlan structures, types
+ **/
+struct vlan_parent;
+LIST_HEAD(vlan_parent_list, vlan_parent);
+struct ifvlan;
+LIST_HEAD(ifvlan_list, ifvlan);
+
+typedef LIST_ENTRY(vlan_parent) 
+vlan_parent_entry;
+typedef LIST_ENTRY(ifvlan) 
+ifvlan_entry;
+
+#define VLP_SIGNATURE          0xfaceface
+typedef struct vlan_parent {
+    vlan_parent_entry          vlp_parent_list;/* list of parents */
+    struct ifnet *             vlp_ifp;        /* interface */
+    struct ifvlan_list         vlp_vlan_list;  /* list of VLAN's */
+#define VLPF_SUPPORTS_VLAN_MTU 0x1
+#define VLPF_CHANGE_IN_PROGRESS        0x2
+#define VLPF_DETACHING         0x4
+    u_int32_t                  vlp_flags;
+    struct ifdevmtu            vlp_devmtu;
+    SInt32                     vlp_retain_count;
+    UInt32                     vlp_signature;  /* VLP_SIGNATURE */
+} vlan_parent, * vlan_parent_ref;
+
+#define IFV_SIGNATURE          0xbeefbeef
+struct ifvlan {
+    ifvlan_entry               ifv_vlan_list;
+    char                       ifv_name[IFNAMSIZ]; /* our unique id */
+    struct ifnet *             ifv_ifp;        /* our interface */
+    vlan_parent_ref            ifv_vlp;        /* parent information */

     struct     ifv_linkmib {
     struct     ifv_linkmib {

-       int     ifvm_parent;
-       int     ifvm_encaplen;  /* encapsulation length */
-       int     ifvm_mtufudge;  /* MTU fudged by this much */
-       int     ifvm_mintu;     /* min transmission unit */
-       u_int16_t ifvm_proto; /* encapsulation ethertype */
-       u_int16_t ifvm_tag; /* tag to apply on packets leaving if */
+       u_int16_t ifvm_encaplen;/* encapsulation length */
+       u_int16_t ifvm_mtufudge;/* MTU fudged by this much */
+       u_int16_t ifvm_proto;   /* encapsulation ethertype */
+       u_int16_t ifvm_tag;     /* tag to apply on packets leaving if */

     }  ifv_mib;
     }  ifv_mib;

-    SLIST_HEAD(__vlan_mchead, vlan_mc_entry)   vlan_mc_listhead;
-    LIST_ENTRY(ifvlan) ifv_list;
-    int        ifv_flags;
-    int ifv_detaching;
-    u_long ifv_filter_id;
-    int ifv_filter_valid;
-    bpf_callback_func *        ifv_bpf_input;
-    bpf_callback_func * ifv_bpf_output;
+    struct multicast_list      ifv_multicast;
+#define        IFVF_PROMISC            0x1             /* promiscuous mode enabled */
+#define IFVF_DETACHING         0x2             /* interface is detaching */
+#define IFVF_READY             0x4             /* interface is ready */
+    u_int32_t                  ifv_flags;
+    bpf_packet_func            ifv_bpf_input;
+    bpf_packet_func            ifv_bpf_output;
+    SInt32                     ifv_retain_count;
+    UInt32                     ifv_signature;  /* IFV_SIGNATURE */

 };
 
 };
 

-#define        ifv_tag ifv_mib.ifvm_tag
+typedef struct ifvlan * ifvlan_ref;
+
+typedef struct vlan_globals_s {
+    struct vlan_parent_list    parent_list;
+    int                                verbose;
+} * vlan_globals_ref;
+    
+static vlan_globals_ref        g_vlan;
+
+#define        ifv_tag         ifv_mib.ifvm_tag

 #define        ifv_encaplen    ifv_mib.ifvm_encaplen
 #define        ifv_mtufudge    ifv_mib.ifvm_mtufudge
 #define        ifv_encaplen    ifv_mib.ifvm_encaplen
 #define        ifv_mtufudge    ifv_mib.ifvm_mtufudge

-#define        ifv_mintu       ifv_mib.ifvm_mintu

 
 

-#define        IFVF_PROMISC            0x01            /* promiscuous mode enabled */
+static void
+vlan_parent_retain(vlan_parent_ref vlp);

 
 

-#if 0
-SYSCTL_DECL(_net_link);
-SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW, 0, "IEEE 802.1Q VLAN");
-SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0, "for consistency");
-#endif 0
+static void
+vlan_parent_release(vlan_parent_ref vlp);

 
 

-#define M_VLAN                 M_DEVBUF
+/**
+ ** vlan_parent_ref vlp_flags in-lines
+ **/
+static __inline__ int
+vlan_parent_flags_supports_vlan_mtu(vlan_parent_ref vlp)
+{
+    return ((vlp->vlp_flags & VLPF_SUPPORTS_VLAN_MTU) != 0);
+}
+
+static __inline__ void
+vlan_parent_flags_set_supports_vlan_mtu(vlan_parent_ref vlp)
+{
+    vlp->vlp_flags |= VLPF_SUPPORTS_VLAN_MTU;
+    return;
+}
+
+static __inline__ void
+vlan_parent_flags_clear_supports_vlan_mtu(vlan_parent_ref vlp)
+{
+    vlp->vlp_flags &= ~VLPF_SUPPORTS_VLAN_MTU;
+    return;
+}
+
+static __inline__ int
+vlan_parent_flags_change_in_progress(vlan_parent_ref vlp)
+{
+    return ((vlp->vlp_flags & VLPF_CHANGE_IN_PROGRESS) != 0);
+}
+
+static __inline__ void
+vlan_parent_flags_set_change_in_progress(vlan_parent_ref vlp)
+{
+    vlp->vlp_flags |= VLPF_CHANGE_IN_PROGRESS;
+    return;
+}

 
 

-MALLOC_DEFINE(M_VLAN, VLANNAME, "802.1Q Virtual LAN Interface");
+static __inline__ void
+vlan_parent_flags_clear_change_in_progress(vlan_parent_ref vlp)
+{
+    vlp->vlp_flags &= ~VLPF_CHANGE_IN_PROGRESS;
+    return;
+}
+
+static __inline__ int
+vlan_parent_flags_detaching(struct vlan_parent * vlp)
+{
+    return ((vlp->vlp_flags & VLPF_DETACHING) != 0);
+}
+
+static __inline__ void
+vlan_parent_flags_set_detaching(struct vlan_parent * vlp)
+{
+    vlp->vlp_flags |= VLPF_DETACHING;
+    return;
+}
+
+
+/**
+ ** ifvlan_flags in-lines routines
+ **/
+static __inline__ int
+ifvlan_flags_promisc(ifvlan_ref ifv)
+{
+    return ((ifv->ifv_flags & IFVF_PROMISC) != 0);
+}
+
+static __inline__ void
+ifvlan_flags_set_promisc(ifvlan_ref ifv)
+{
+    ifv->ifv_flags |= IFVF_PROMISC;
+    return;
+}
+
+static __inline__ void
+ifvlan_flags_clear_promisc(ifvlan_ref ifv)
+{
+    ifv->ifv_flags &= ~IFVF_PROMISC;
+    return;
+}
+
+static __inline__ int
+ifvlan_flags_ready(ifvlan_ref ifv)
+{
+    return ((ifv->ifv_flags & IFVF_READY) != 0);
+}
+
+static __inline__ void
+ifvlan_flags_set_ready(ifvlan_ref ifv)
+{
+    ifv->ifv_flags |= IFVF_READY;
+    return;
+}
+
+static __inline__ void
+ifvlan_flags_clear_ready(ifvlan_ref ifv)
+{
+    ifv->ifv_flags &= ~IFVF_READY;
+    return;
+}

 
 

-static LIST_HEAD(, ifvlan) ifv_list;
+static __inline__ int
+ifvlan_flags_detaching(ifvlan_ref ifv)
+{
+    return ((ifv->ifv_flags & IFVF_DETACHING) != 0);
+}
+
+static __inline__ void
+ifvlan_flags_set_detaching(ifvlan_ref ifv)
+{
+    ifv->ifv_flags |= IFVF_DETACHING;
+    return;
+}

 
 #if 0
 
 #if 0

-/*
- * Locking: one lock is used to guard both the ifv_list and modification
- * to vlan data structures.  We are rather conservative here; probably
- * more than necessary.
- */
-static struct mtx ifv_mtx;
-#define        VLAN_LOCK_INIT()        mtx_init(&ifv_mtx, VLANNAME, NULL, MTX_DEF)
-#define        VLAN_LOCK_DESTROY()     mtx_destroy(&ifv_mtx)
-#define        VLAN_LOCK_ASSERT()      mtx_assert(&ifv_mtx, MA_OWNED)
-#define        VLAN_LOCK()     mtx_lock(&ifv_mtx)
-#define        VLAN_UNLOCK()   mtx_unlock(&ifv_mtx)
-#else
-#define        VLAN_LOCK_INIT()
-#define        VLAN_LOCK_DESTROY()
-#define        VLAN_LOCK_ASSERT()
-#define        VLAN_LOCK()
-#define        VLAN_UNLOCK()
-#endif 0
-
-static int vlan_clone_create(struct if_clone *, int);
-static void vlan_clone_destroy(struct ifnet *);
+SYSCTL_DECL(_net_link);
+SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "IEEE 802.1Q VLAN");
+SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "for consistency");
+#endif
+
+#define M_VLAN                 M_DEVBUF
+
+static int vlan_clone_create(struct if_clone *, u_int32_t, void *);
+static int vlan_clone_destroy(struct ifnet *);
+static int vlan_input(ifnet_t ifp, protocol_family_t protocol,
+                                          mbuf_t m, char *frame_header);

 static int vlan_output(struct ifnet *ifp, struct mbuf *m);
 static int vlan_output(struct ifnet *ifp, struct mbuf *m);

-static void vlan_ifinit(void *foo);
-static int vlan_ioctl(struct ifnet *ifp, u_long cmd, void * addr);
-static  int vlan_set_bpf_tap(struct ifnet * ifp, int mode,
-                            bpf_callback_func * func);
+static int vlan_ioctl(ifnet_t ifp, u_long cmd, void * addr);
+static  int vlan_set_bpf_tap(ifnet_t ifp, bpf_tap_mode mode,
+                            bpf_packet_func func);

 static         int vlan_attach_protocol(struct ifnet *ifp);
 static int vlan_detach_protocol(struct ifnet *ifp);
 static         int vlan_attach_protocol(struct ifnet *ifp);
 static int vlan_detach_protocol(struct ifnet *ifp);

-static         int vlan_attach_filter(struct ifnet * ifp, u_long * filter_id);
-static         int vlan_detach_filter(u_long filter_id);

 static int vlan_setmulti(struct ifnet *ifp);
 static int vlan_setmulti(struct ifnet *ifp);

-static int vlan_unconfig(struct ifnet *ifp);
-static int vlan_config(struct ifvlan *ifv, struct ifnet *p, int tag);
-static int vlan_if_free(struct ifnet * ifp);
+static int vlan_unconfig(ifvlan_ref ifv, int need_to_wait);
+static         int vlan_config(struct ifnet * ifp, struct ifnet * p, int tag);
+static void vlan_if_free(struct ifnet * ifp);
+static         int vlan_remove(ifvlan_ref ifv, int need_to_wait);

 
 static struct if_clone vlan_cloner = IF_CLONE_INITIALIZER(VLANNAME,
 
 static struct if_clone vlan_cloner = IF_CLONE_INITIALIZER(VLANNAME,

-                                                         vlan_clone_create, vlan_clone_destroy, 0, IF_MAXUNIT);
+                                                         vlan_clone_create, 
+                                                         vlan_clone_destroy, 
+                                                         0, 
+                                                         IF_MAXUNIT);
+static void interface_link_event(struct ifnet * ifp, u_int32_t event_code);
+static void vlan_parent_link_event(struct ifnet * p,
+                                   u_int32_t event_code);
+
+static         int ifvlan_new_mtu(ifvlan_ref ifv, int mtu);
+
+/**
+ ** ifvlan_ref routines
+ **/
+static void
+ifvlan_retain(ifvlan_ref ifv)
+{
+    if (ifv->ifv_signature != IFV_SIGNATURE) {
+       panic("ifvlan_retain: bad signature\n");
+    }
+    if (ifv->ifv_retain_count == 0) {
+       panic("ifvlan_retain: retain count is 0\n");
+    }
+    OSIncrementAtomic(&ifv->ifv_retain_count);
+}
+
+static void
+ifvlan_release(ifvlan_ref ifv)
+{
+    UInt32             old_retain_count;
+
+    if (ifv->ifv_signature != IFV_SIGNATURE) {
+       panic("ifvlan_release: bad signature\n");
+    }
+    old_retain_count = OSDecrementAtomic(&ifv->ifv_retain_count);
+    switch (old_retain_count) {
+    case 0:
+       panic("ifvlan_release: retain count is 0\n");
+       break;
+    case 1:
+       if (g_vlan->verbose) {
+           printf("ifvlan_release(%s)\n", ifv->ifv_name);
+       }
+       ifv->ifv_signature = 0;
+       FREE(ifv, M_VLAN);
+       break;
+    default:
+       break;
+    }
+    return;
+}
+
+static vlan_parent_ref
+ifvlan_get_vlan_parent_retained(ifvlan_ref ifv)
+{
+    vlan_parent_ref    vlp = ifv->ifv_vlp;
+
+    if (vlan_parent_flags_detaching(vlp)) {
+       return (NULL);
+    }
+    vlan_parent_retain(vlp);
+    return (vlp);
+}
+
+/**
+ ** ifnet_* routines
+ **/
+
+static ifvlan_ref
+ifnet_get_ifvlan(struct ifnet * ifp)
+{
+    ifvlan_ref         ifv;
+
+    ifv = (ifvlan_ref)ifnet_softc(ifp);
+    return (ifv);
+}
+
+static ifvlan_ref
+ifnet_get_ifvlan_retained(struct ifnet * ifp)
+{
+    ifvlan_ref         ifv;
+
+    ifv = ifnet_get_ifvlan(ifp);
+    if (ifv == NULL) {
+       return (NULL);
+    }
+    if (ifvlan_flags_detaching(ifv)) {
+       return (NULL);
+    }
+    ifvlan_retain(ifv);
+    return (ifv);
+}
+
+static int
+ifnet_ifvlan_vlan_parent_ok(struct ifnet * ifp, ifvlan_ref ifv,
+                           vlan_parent_ref vlp)
+{
+    ifvlan_ref         check_ifv;
+
+    check_ifv = ifnet_get_ifvlan(ifp);
+    if (check_ifv != ifv || ifvlan_flags_detaching(ifv)) {
+       /* ifvlan_ref no longer valid */
+       return (FALSE);
+    }
+    if (ifv->ifv_vlp != vlp) {
+       /* vlan_parent no longer valid */
+       return (FALSE);
+    }
+    if (vlan_parent_flags_detaching(vlp)) {
+       /* parent is detaching */
+       return (FALSE);
+    }
+    return (TRUE);
+}
+
+/**
+ ** vlan, etc. routines
+ **/
+
+static int
+vlan_globals_init(void)
+{
+    vlan_globals_ref   v;
+
+    vlan_assert_lock_not_held();
+
+    if (g_vlan != NULL) {
+       return (0);
+    }
+    v = _MALLOC(sizeof(*v), M_VLAN, M_WAITOK);
+    if (v != NULL) {
+       LIST_INIT(&v->parent_list);
+       v->verbose = 0;
+    }
+    vlan_lock();
+    if (g_vlan != NULL) {
+       vlan_unlock();
+       if (v != NULL) {
+           _FREE(v, M_VLAN);
+       }
+       return (0);
+    }
+    g_vlan = v;
+    vlan_unlock();
+    if (v == NULL) {
+       return (ENOMEM);
+    }
+    return (0);
+}

 
 

-static if_set_bpf_tap_func nop_if_bpf;
-static int nop_if_free(struct ifnet *);
-static int nop_if_ioctl(struct ifnet *, u_long, void *);
-static int nop_if_output(struct ifnet * ifp, struct mbuf * m);
+static int
+siocgifdevmtu(struct ifnet * ifp, struct ifdevmtu * ifdm_p)
+{
+    struct ifreq       ifr;
+    int                error;

 
 

-static         void interface_link_event(struct ifnet * ifp, u_long event_code);
+    bzero(&ifr, sizeof(ifr));
+    error = ifnet_ioctl(ifp, 0,SIOCGIFDEVMTU, &ifr);
+    if (error == 0) {
+       *ifdm_p = ifr.ifr_devmtu;
+    }
+    return (error);
+}
+
+static int
+siocsifaltmtu(struct ifnet * ifp, int mtu)
+{
+    struct ifreq       ifr;
+
+    bzero(&ifr, sizeof(ifr));
+    ifr.ifr_mtu = mtu;
+    return (ifnet_ioctl(ifp, 0, SIOCSIFALTMTU, &ifr));
+}

 
 static __inline__ void 
 vlan_bpf_output(struct ifnet * ifp, struct mbuf * m, 
 
 static __inline__ void 
 vlan_bpf_output(struct ifnet * ifp, struct mbuf * m, 

-               bpf_callback_func func)
+               bpf_packet_func func)

 {
     if (func != NULL) {
 {
     if (func != NULL) {

-       func(ifp, m);
+       (*func)(ifp, m);

     }
     return;
 }
 
 static __inline__ void 
 vlan_bpf_input(struct ifnet * ifp, struct mbuf * m, 
     }
     return;
 }
 
 static __inline__ void 
 vlan_bpf_input(struct ifnet * ifp, struct mbuf * m, 

-              bpf_callback_func func, char * frame_header,
+              bpf_packet_func func, char * frame_header,

               int frame_header_len, int encap_len)
 {
     if (func != NULL) {
               int frame_header_len, int encap_len)
 {
     if (func != NULL) {


@@ -217,7 +580,7 @@ vlan_bpf_input(struct ifnet * ifp, struct mbuf * m,
        }
        m->m_data -= frame_header_len;
        m->m_len += frame_header_len;
        }
        m->m_data -= frame_header_len;
        m->m_len += frame_header_len;

-       func(ifp, m);
+       (*func)(ifp, m);

        m->m_data += frame_header_len;
        m->m_len -= frame_header_len;
        if (encap_len > 0) {
        m->m_data += frame_header_len;
        m->m_len -= frame_header_len;
        if (encap_len > 0) {


@@ -228,13 +591,107 @@ vlan_bpf_input(struct ifnet * ifp, struct mbuf * m,
     return;
 }
 
     return;
 }
 

-static struct ifaddr * 
-ifaddr_byindex(unsigned int i)
+/**
+ ** vlan_parent synchronization routines
+ **/
+static void
+vlan_parent_retain(vlan_parent_ref vlp)

 {
 {

-    if (i > if_index || i == 0) {
-       return (NULL);
+    if (vlp->vlp_signature != VLP_SIGNATURE) {
+       panic("vlan_parent_retain: signature is bad\n");

     }
     }

-    return (ifnet_addrs[i - 1]);
+    if (vlp->vlp_retain_count == 0) {
+       panic("vlan_parent_retain: retain count is 0\n");
+    }
+    OSIncrementAtomic(&vlp->vlp_retain_count);
+}
+
+static void
+vlan_parent_release(vlan_parent_ref vlp)
+{
+    UInt32             old_retain_count;
+
+    if (vlp->vlp_signature != VLP_SIGNATURE) {
+       panic("vlan_parent_release: signature is bad\n");
+    }
+    old_retain_count = OSDecrementAtomic(&vlp->vlp_retain_count);
+    switch (old_retain_count) {
+    case 0:
+       panic("vlan_parent_release: retain count is 0\n");
+       break;
+    case 1:
+       if (g_vlan->verbose) {
+           struct ifnet * ifp = vlp->vlp_ifp;
+           printf("vlan_parent_release(%s%d)\n", ifnet_name(ifp),
+                  ifnet_unit(ifp));
+       }
+       vlp->vlp_signature = 0;
+       FREE(vlp, M_VLAN);
+       break;
+    default:
+       break;
+    }
+    return;
+}
+
+/*
+ * Function: vlan_parent_wait
+ * Purpose:
+ *   Allows a single thread to gain exclusive access to the vlan_parent
+ *   data structure.  Some operations take a long time to complete, 
+ *   and some have side-effects that we can't predict.  Holding the
+ *   vlan_lock() across such operations is not possible.
+ *
+ * Notes:
+ *   Before calling, you must be holding the vlan_lock and have taken
+ *   a reference on the vlan_parent_ref.
+ */
+static void
+vlan_parent_wait(vlan_parent_ref vlp, const char * msg)
+{
+    int                waited = 0;
+
+    /* other add/remove/multicast-change in progress */
+    while (vlan_parent_flags_change_in_progress(vlp)) {
+       if (g_vlan->verbose) {
+           struct ifnet * ifp = vlp->vlp_ifp;
+
+           printf("%s%d: %s msleep\n", ifnet_name(ifp), ifnet_unit(ifp), msg);
+       }
+       waited = 1;
+       (void)msleep(vlp, vlan_lck_mtx, PZERO, msg, 0);
+    }
+    /* prevent other vlan parent remove/add from taking place */
+    vlan_parent_flags_set_change_in_progress(vlp);
+    if (g_vlan->verbose && waited) {
+       struct ifnet * ifp = vlp->vlp_ifp;
+
+       printf("%s%d: %s woke up\n", ifnet_name(ifp), ifnet_unit(ifp), msg);
+    }
+    return;
+}
+
+/*
+ * Function: vlan_parent_signal
+ * Purpose:
+ *   Allows the thread that previously invoked vlan_parent_wait() to 
+ *   give up exclusive access to the vlan_parent data structure, and wake up
+ *   any other threads waiting to access
+ * Notes:
+ *   Before calling, you must be holding the vlan_lock and have taken
+ *   a reference on the vlan_parent_ref.
+ */
+static void
+vlan_parent_signal(vlan_parent_ref vlp, const char * msg)
+{
+    vlan_parent_flags_clear_change_in_progress(vlp);
+    wakeup((caddr_t)vlp);
+    if (g_vlan->verbose) {
+       struct ifnet * ifp = vlp->vlp_ifp;
+
+       printf("%s%d: %s wakeup\n", ifnet_name(ifp), ifnet_unit(ifp), msg);
+    }
+    return;

 }
 
 /*
 }
 
 /*


@@ -246,252 +703,358 @@ ifaddr_byindex(unsigned int i)
  * to avoid this: there really is only one physical interface.
  */
 static int
  * to avoid this: there really is only one physical interface.
  */
 static int

-vlan_setmulti(struct ifnet *ifp)
+vlan_setmulti(struct ifnet * ifp)

 {
 {

-    struct ifnet               *p;
-    struct ifmultiaddr *ifma, *rifma = NULL;
-    struct ifvlan              *sc;
-    struct vlan_mc_entry       *mc = NULL;
-    struct sockaddr_dl sdl;
-    int                        error;
+    int                        error = 0;
+    ifvlan_ref                 ifv;
+    struct ifnet *     p;
+    vlan_parent_ref    vlp = NULL;

 
 

-    /* Find the parent. */
-    sc = ifp->if_private;
-    p = sc->ifv_p;
-    if (p == NULL) {
-       /* no parent, so no need to program the multicast filter */
-       return (0);
+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL) {
+       goto unlock_done;

     }
     }

-
-    bzero((char *)&sdl, sizeof sdl);
-    sdl.sdl_len = sizeof sdl;
-    sdl.sdl_family = AF_LINK;
-    sdl.sdl_index = p->if_index;
-    sdl.sdl_type = IFT_ETHER;
-    sdl.sdl_alen = ETHER_ADDR_LEN;
-
-    /* First, remove any existing filter entries. */
-    while (SLIST_FIRST(&sc->vlan_mc_listhead) != NULL) {
-       mc = SLIST_FIRST(&sc->vlan_mc_listhead);
-       bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN);
-       error = if_delmulti(p, (struct sockaddr *)&sdl);
-       if (error)
-           return(error);
-       SLIST_REMOVE_HEAD(&sc->vlan_mc_listhead, mc_entries);
-       FREE(mc, M_VLAN);
+    vlp = ifvlan_get_vlan_parent_retained(ifv);
+    if (vlp == NULL) {
+       /* no parent, no need to program the multicast filter */
+       goto unlock_done;

     }
     }

+    vlan_parent_wait(vlp, "vlan_setmulti");

 
 

-    /* Now program new ones. */
-    LIST_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) {
-       if (ifma->ifma_addr->sa_family != AF_LINK)
-           continue;
-       mc = _MALLOC(sizeof(struct vlan_mc_entry), M_VLAN, M_WAITOK);
-       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);
-       bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr),
-             LLADDR(&sdl), ETHER_ADDR_LEN);
-       error = if_addmulti(p, (struct sockaddr *)&sdl, &rifma);
-       if (error)
-           return(error);
+    /* check again, things could have changed */
+    if (ifnet_ifvlan_vlan_parent_ok(ifp, ifv, vlp) == FALSE) {
+       goto signal_done;

     }
     }

+    p = vlp->vlp_ifp;
+    vlan_unlock();

 
 

-    return(0);
-}
-
-#if 0
-/*
- * 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.
- *
- * NB: Noone should ever need to check if vlan_input_p is null or
- *     not.  This is because interfaces have a count of the number
- *     of active vlans (if_nvlans) and this should never be bumped
- *     except by vlan_config--which is in this module so therefore
- *     the module must be loaded and vlan_input_p must be non-NULL.
- */
-extern void (*vlan_input_p)(struct ifnet *, struct mbuf *);
+    /* update parent interface with our multicast addresses */
+    error = multicast_list_program(&ifv->ifv_multicast, ifp, p);

 
 

-static int
-vlan_modevent(module_t mod, int type, void *data) 
-{ 
-
-    switch (type) { 
-    case MOD_LOAD: 
-       LIST_INIT(&ifv_list);
-       VLAN_LOCK_INIT();
-       vlan_input_p = vlan_input;
-       if_clone_attach(&vlan_cloner);
-       break; 
-    case MOD_UNLOAD: 
-       if_clone_detach(&vlan_cloner);
-       vlan_input_p = NULL;
-       while (!LIST_EMPTY(&ifv_list))
-           vlan_clone_destroy(LIST_FIRST(&ifv_list)->ifv_ifp);
-       VLAN_LOCK_DESTROY();
-       break;
-    } 
-    return 0; 
-} 
+    vlan_lock();

 
 

-static moduledata_t vlan_mod = { 
-    "if_vlan", 
-    vlan_modevent, 
-    0
-}; 
+ signal_done:
+    vlan_parent_signal(vlp, "vlan_setmulti");

 
 

-DECLARE_MODULE(if_vlan, vlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);
-
-#endif 0
+ unlock_done:
+    vlan_unlock();
+    if (ifv != NULL) {
+       ifvlan_release(ifv);
+    }
+    if (vlp != NULL) {
+       vlan_parent_release(vlp);
+    }
+    return (error);
+}

 
 

-static struct ifvlan * 
-vlan_lookup_ifp_and_tag(struct ifnet * ifp, int tag)
+/**
+ ** vlan_parent list manipulation/lookup routines
+ **/
+static vlan_parent_ref
+parent_list_lookup(struct ifnet * p)

 {
 {

-    struct ifvlan * ifv;
+    vlan_parent_ref    vlp;

 
 

-    LIST_FOREACH(ifv, &ifv_list, ifv_list) {
-       if (ifp == ifv->ifv_p && tag == ifv->ifv_tag) {
-           return (ifv);
+    LIST_FOREACH(vlp, &g_vlan->parent_list, vlp_parent_list) {
+       if (vlp->vlp_ifp == p) {
+           return (vlp);

        }
     }
     return (NULL);
 }
 
        }
     }
     return (NULL);
 }
 

-static struct ifvlan * 
-vlan_lookup_ifp(struct ifnet * ifp)
+static ifvlan_ref
+vlan_parent_lookup_tag(vlan_parent_ref vlp, int tag)

 {
 {

-    struct ifvlan * ifv;
+    ifvlan_ref         ifv;

 
 

-    LIST_FOREACH(ifv, &ifv_list, ifv_list) {
-       if (ifp == ifv->ifv_p) {
+    LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) {
+       if (tag == ifv->ifv_tag) {

            return (ifv);
        }
     }
     return (NULL);
 }
 
            return (ifv);
        }
     }
     return (NULL);
 }
 

-static void
-vlan_clone_attach(void)
+static ifvlan_ref 
+vlan_lookup_parent_and_tag(struct ifnet * p, int tag)

 {
 {

-    if_clone_attach(&vlan_cloner);
-    return;
+    vlan_parent_ref    vlp;
+
+    vlp = parent_list_lookup(p);
+    if (vlp != NULL) {
+       return (vlan_parent_lookup_tag(vlp, tag));
+    }
+    return (NULL);

 }
 
 static int
 }
 
 static int

-vlan_clone_create(struct if_clone *ifc, int unit)
+vlan_parent_find_max_mtu(vlan_parent_ref vlp, ifvlan_ref exclude_ifv)

 {
 {

-    int error;
-    struct ifvlan *ifv;
-    struct ifnet *ifp;
+    int                        max_mtu = 0;
+    ifvlan_ref         ifv;

 
 

-    ifv = _MALLOC(sizeof(struct ifvlan), M_VLAN, M_WAITOK);
-    bzero(ifv, sizeof(struct ifvlan));
-    SLIST_INIT(&ifv->vlan_mc_listhead);
+    LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) {
+       int     req_mtu;

 
 

-    /* use the interface name as the unique id for ifp recycle */
-    if (snprintf(ifv->ifv_name, sizeof(ifv->ifv_name), "%s%d",
-                ifc->ifc_name, unit) >= sizeof(ifv->ifv_name)) {
-       FREE(ifv, M_VLAN);
-       return (EINVAL);
+       if (exclude_ifv == ifv) {
+           continue;
+       }
+       req_mtu = ifnet_mtu(ifv->ifv_ifp) + ifv->ifv_mtufudge;
+       if (req_mtu > max_mtu) {
+           max_mtu = req_mtu;
+       }

     }
     }

-    error = dlil_if_acquire(APPLE_IF_FAM_VLAN,
-                           ifv->ifv_name,
-                           strlen(ifv->ifv_name),
-                           &ifp);
-    if (error) {
-       FREE(ifv, M_VLAN);
+    return (max_mtu);
+}
+
+/*
+ * Function: vlan_parent_create
+ * Purpose:
+ *   Create a vlan_parent structure to hold the VLAN's for the given
+ *   interface.  Add it to the list of VLAN parents.
+ */
+static int
+vlan_parent_create(struct ifnet * p, vlan_parent_ref * ret_vlp)
+{
+    int                        error;
+    vlan_parent_ref    vlp;
+
+    *ret_vlp = NULL;
+    vlp = _MALLOC(sizeof(*vlp), M_VLAN, M_WAITOK);
+    if (vlp == NULL) {
+       return (ENOMEM);
+    }
+    bzero(vlp, sizeof(*vlp));
+    error = siocgifdevmtu(p, &vlp->vlp_devmtu);
+    if (error != 0) {
+       printf("vlan_parent_create (%s%d): siocgifdevmtu failed, %d\n",
+              ifnet_name(p), ifnet_unit(p), error);
+       FREE(vlp, M_VLAN);

        return (error);
     }
        return (error);
     }

-    ifv->ifv_ifp = ifp;
-    ifp->if_private = ifv;
-    ifp->if_name = (char *)ifc->ifc_name;
-    ifp->if_unit = unit;
-    ifp->if_family = APPLE_IF_FAM_VLAN;
+    LIST_INIT(&vlp->vlp_vlan_list);
+    vlp->vlp_ifp = p;
+    vlp->vlp_retain_count = 1;
+    vlp->vlp_signature = VLP_SIGNATURE;
+    if (ifnet_offload(p)
+       & (IF_HWASSIST_VLAN_MTU | IF_HWASSIST_VLAN_TAGGING)) {
+       vlan_parent_flags_set_supports_vlan_mtu(vlp);
+    }
+    *ret_vlp = vlp;
+    return (0);
+}

 
 

-#if 0
-    /* NB: flags are not set here */
-    ifp->if_linkmib = &ifv->ifv_mib;
-    ifp->if_linkmiblen = sizeof ifv->ifv_mib;
-    /* NB: mtu is not set here */
-#endif 0
-
-    ifp->if_ioctl = vlan_ioctl;
-    ifp->if_set_bpf_tap = vlan_set_bpf_tap;
-    ifp->if_free = nop_if_free;
-    ifp->if_output = nop_if_output;
-    ifp->if_hwassist = 0;
-    ifp->if_addrlen = ETHER_ADDR_LEN; /* XXX ethernet specific */
-    ifp->if_baudrate = 0;
-    ifp->if_type = IFT_L2VLAN;
-    ifp->if_hdrlen = ETHER_VLAN_ENCAP_LEN;
-    error = dlil_if_attach(ifp);
-    if (error) {
-       dlil_if_release(ifp);
-       FREE(ifv, M_VLAN);
-       return (error);
+static void
+vlan_parent_remove_all_vlans(struct ifnet * p)
+{
+    ifvlan_ref                 ifv;
+    int                        need_vlp_release = 0;
+    ifvlan_ref         next;
+    vlan_parent_ref    vlp;
+
+    vlan_lock();
+    vlp = parent_list_lookup(p);
+    if (vlp == NULL || vlan_parent_flags_detaching(vlp)) {
+       /* no VLAN's */
+       vlan_unlock();
+       return;
+    }
+    vlan_parent_flags_set_detaching(vlp);
+    vlan_parent_retain(vlp);
+    vlan_parent_wait(vlp, "vlan_parent_remove_all_vlans");
+    need_vlp_release++;
+    vlp = parent_list_lookup(p);
+    /* check again */
+    if (vlp == NULL) {
+       goto signal_done;

     }
 
     }
 

-    /* attach as ethernet */
-    bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
+    for (ifv = LIST_FIRST(&vlp->vlp_vlan_list); ifv != NULL; ifv = next) {
+       struct ifnet *  ifp = ifv->ifv_ifp;
+       int             removed;

 
 

-    VLAN_LOCK();
-    LIST_INSERT_HEAD(&ifv_list, ifv, ifv_list);
-    VLAN_UNLOCK();
+       next = LIST_NEXT(ifv, ifv_vlan_list);
+       removed = vlan_remove(ifv, FALSE);
+       if (removed) {
+           vlan_unlock();
+           ifnet_detach(ifp);
+           vlan_lock();
+       }
+    }

 
 

-    return (0);
+    /* the vlan parent has no more VLAN's */
+    ifnet_set_eflags(p, 0, IFEF_VLAN); /* clear IFEF_VLAN */
+
+    LIST_REMOVE(vlp, vlp_parent_list);
+    need_vlp_release++;        /* one for being in the list */
+    need_vlp_release++; /* final reference */
+
+ signal_done:
+    vlan_parent_signal(vlp, "vlan_parent_remove_all_vlans");
+    vlan_unlock();
+
+    while (need_vlp_release--) {
+       vlan_parent_release(vlp);
+    }
+    return;
+}
+
+static __inline__ int
+vlan_parent_no_vlans(vlan_parent_ref vlp)
+{
+    return (LIST_EMPTY(&vlp->vlp_vlan_list));

 }
 
 static void
 }
 
 static void

-vlan_remove(struct ifvlan * ifv)
+vlan_parent_add_vlan(vlan_parent_ref vlp, ifvlan_ref ifv, int tag)

 {
 {

-    VLAN_LOCK_ASSERT();
-    ifv->ifv_detaching = 1;
-    vlan_unconfig(ifv->ifv_ifp);
-    LIST_REMOVE(ifv, ifv_list);
+    LIST_INSERT_HEAD(&vlp->vlp_vlan_list, ifv, ifv_vlan_list);
+    ifv->ifv_vlp = vlp;
+    ifv->ifv_tag = tag;

     return;
 }
 
 static void
     return;
 }
 
 static void

-vlan_if_detach(struct ifnet * ifp)
+vlan_parent_remove_vlan(__unused vlan_parent_ref vlp, ifvlan_ref ifv)

 {
 {

-    ifp->if_output = nop_if_output;
-    ifp->if_ioctl = nop_if_ioctl;
-    ifp->if_set_bpf_tap = &nop_if_bpf;
-    if (dlil_if_detach(ifp) == DLIL_WAIT_FOR_FREE) {
-       ifp->if_free = vlan_if_free;
-    } else {
-       vlan_if_free(ifp);
-    }
+    ifv->ifv_vlp = NULL;
+    LIST_REMOVE(ifv, ifv_vlan_list);

     return;
 }
 
     return;
 }
 

-static void
+static int
+vlan_clone_attach(void)
+{
+    int error;
+
+    error = if_clone_attach(&vlan_cloner);
+    if (error != 0)
+        return error;
+    vlan_lock_init();
+    return 0;
+}
+
+static int
+vlan_clone_create(struct if_clone *ifc, u_int32_t unit, __unused void *params)
+{
+       int                                                     error;
+       ifvlan_ref                                      ifv;
+       ifnet_t                                         ifp;
+       struct ifnet_init_params        vlan_init;
+       
+       error = vlan_globals_init();
+       if (error != 0) {
+               return (error);
+       }
+       ifv = _MALLOC(sizeof(struct ifvlan), M_VLAN, M_WAITOK);
+       if (ifv == NULL)
+               return ENOBUFS;
+       bzero(ifv, sizeof(struct ifvlan));
+       ifv->ifv_retain_count = 1;
+       ifv->ifv_signature = IFV_SIGNATURE;
+       multicast_list_init(&ifv->ifv_multicast);
+       
+       /* use the interface name as the unique id for ifp recycle */
+       if ((unsigned int)
+           snprintf(ifv->ifv_name, sizeof(ifv->ifv_name), "%s%d",
+                    ifc->ifc_name, unit) >= sizeof(ifv->ifv_name)) {
+           ifvlan_release(ifv);
+           return (EINVAL);
+       }
+       
+       bzero(&vlan_init, sizeof(vlan_init));
+       vlan_init.uniqueid = ifv->ifv_name;
+       vlan_init.uniqueid_len = strlen(ifv->ifv_name);
+       vlan_init.name = ifc->ifc_name;
+       vlan_init.unit = unit;
+       vlan_init.family = IFNET_FAMILY_VLAN;
+       vlan_init.type = IFT_L2VLAN;
+       vlan_init.output = vlan_output;
+       vlan_init.demux = ether_demux;
+       vlan_init.add_proto = ether_add_proto;
+       vlan_init.del_proto = ether_del_proto;
+       vlan_init.check_multi = ether_check_multi;
+       vlan_init.framer = ether_frameout;
+       vlan_init.softc = ifv;
+       vlan_init.ioctl = vlan_ioctl;
+       vlan_init.set_bpf_tap = vlan_set_bpf_tap;
+       vlan_init.detach = vlan_if_free;
+       vlan_init.broadcast_addr = etherbroadcastaddr;
+       vlan_init.broadcast_len = ETHER_ADDR_LEN;
+       error = ifnet_allocate(&vlan_init, &ifp);
+       
+       if (error) {
+           ifvlan_release(ifv);
+           return (error);
+       }
+       
+       ifnet_set_offload(ifp, 0);
+       ifnet_set_addrlen(ifp, ETHER_ADDR_LEN); /* XXX ethernet specific */
+       ifnet_set_baudrate(ifp, 0);
+       ifnet_set_hdrlen(ifp, ETHER_VLAN_ENCAP_LEN);
+       
+       error = ifnet_attach(ifp, NULL);
+       if (error) {
+           ifnet_release(ifp);
+           ifvlan_release(ifv);
+           return (error);
+       }
+       ifv->ifv_ifp = ifp;
+       
+       /* attach as ethernet */
+       bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header));
+       return (0);
+}
+
+static int
+vlan_remove(ifvlan_ref ifv, int need_to_wait)
+{
+    vlan_assert_lock_held();
+    if (ifvlan_flags_detaching(ifv)) {
+       return (0);
+    }
+    ifvlan_flags_set_detaching(ifv);
+    vlan_unconfig(ifv, need_to_wait);
+    return (1);
+}
+
+
+static int

 vlan_clone_destroy(struct ifnet *ifp)
 {
 vlan_clone_destroy(struct ifnet *ifp)
 {

-    struct ifvlan *ifv = ifp->if_private;
+    ifvlan_ref ifv;

 
 

-    if (ifv == NULL || ifp->if_type != IFT_L2VLAN) {
-       return;
+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL) {
+       vlan_unlock();
+       return 0;

     }
     }

-    VLAN_LOCK();
-    if (ifv->ifv_detaching) {
-       VLAN_UNLOCK();
-       return;
+    if (vlan_remove(ifv, TRUE) == 0) {
+       vlan_unlock();
+       ifvlan_release(ifv);
+       return 0;

     }
     }

-    vlan_remove(ifv);
-    VLAN_UNLOCK();
-    vlan_if_detach(ifp);
-    return;
+    vlan_unlock();
+    ifvlan_release(ifv);
+    ifnet_detach(ifp);
+
+    return 0;

 }
 
 static int 
 }
 
 static int 

-vlan_set_bpf_tap(struct ifnet * ifp, int mode, bpf_callback_func * func)
+vlan_set_bpf_tap(ifnet_t ifp, bpf_tap_mode mode, bpf_packet_func func)

 {
 {

-    struct ifvlan *ifv = ifp->if_private;
+    ifvlan_ref ifv;

 
 

+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL) {
+       vlan_unlock();
+       return (ENODEV);
+    }

     switch (mode) {
         case BPF_TAP_DISABLE:
             ifv->ifv_bpf_input = ifv->ifv_bpf_output = NULL;
     switch (mode) {
         case BPF_TAP_DISABLE:
             ifv->ifv_bpf_input = ifv->ifv_bpf_output = NULL;


@@ -511,46 +1074,56 @@ vlan_set_bpf_tap(struct ifnet * ifp, int mode, bpf_callback_func * func)
         default:
             break;
     }
         default:
             break;
     }

+    vlan_unlock();
+    ifvlan_release(ifv);

     return 0;
 }
 
     return 0;
 }
 

-static void
-vlan_ifinit(void *foo)
-{
-    return;
-}
-

 static int
 static int

-vlan_output(struct ifnet *ifp, struct mbuf *m)
+vlan_output(struct ifnet * ifp, struct mbuf * m)

 {
 {

-    struct ifvlan *ifv;
-    struct ifnet *p;
-    struct ether_vlan_header *evl;
-    int soft_vlan;
-
-    ifv = ifp->if_private;
-    p = ifv->ifv_p;
-    if (p == NULL) {
-       return (nop_if_output(ifp, m));
-    }
+    bpf_packet_func            bpf_func;
+    struct ether_vlan_header * evl;
+    int                                encaplen;
+    ifvlan_ref                 ifv;
+    struct ifnet *             p;
+    int                        soft_vlan;
+    u_short                    tag;
+    vlan_parent_ref            vlp = NULL;
+       

     if (m == 0) {
     if (m == 0) {

-       printf("%s: NULL output mbuf\n", ifv->ifv_name);
-       return (EINVAL);
+       return (0);

     }
     if ((m->m_flags & M_PKTHDR) == 0) {
     }
     if ((m->m_flags & M_PKTHDR) == 0) {

-       printf("%s: M_PKTHDR bit not set\n", ifv->ifv_name);
-       m_freem(m);
-       return (EINVAL);
+       m_freem_list(m);
+       return (0);

     }
     }

-    ifp->if_obytes += m->m_pkthdr.len;
-    ifp->if_opackets++;
-    soft_vlan = (p->if_hwassist & IF_HWASSIST_VLAN_TAGGING) == 0;
-    vlan_bpf_output(ifp, m, ifv->ifv_bpf_output);
-
+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL || ifvlan_flags_ready(ifv) == 0) {
+       goto unlock_done;
+    }
+    vlp = ifvlan_get_vlan_parent_retained(ifv);
+    if (vlp == NULL) {
+       goto unlock_done;
+    }
+    p = vlp->vlp_ifp;
+    (void)ifnet_stat_increment_out(ifp, 1, m->m_pkthdr.len, 0);
+    soft_vlan = (ifnet_offload(p) & IF_HWASSIST_VLAN_TAGGING) == 0;
+    bpf_func = ifv->ifv_bpf_output;
+    tag = ifv->ifv_tag;
+    encaplen = ifv->ifv_encaplen;
+    vlan_unlock();
+
+    ifvlan_release(ifv);
+    vlan_parent_release(vlp);
+
+    vlan_bpf_output(ifp, m, bpf_func);
+       

     /* do not run parent's if_output() if the parent is not up */
     /* do not run parent's if_output() if the parent is not up */

-    if ((p->if_flags & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING)) {
+    if ((ifnet_flags(p) & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING)) {

        m_freem(m);
        m_freem(m);

-       ifp->if_collisions++;
+       atomic_add_64(&ifp->if_collisions, 1);

        return (0);
     }
     /*
        return (0);
     }
     /*


@@ -563,22 +1136,22 @@ vlan_output(struct ifnet *ifp, struct mbuf *m)
      */
     if (soft_vlan == 0) {
        m->m_pkthdr.csum_flags |= CSUM_VLAN_TAG_VALID;
      */
     if (soft_vlan == 0) {
        m->m_pkthdr.csum_flags |= CSUM_VLAN_TAG_VALID;

-       m->m_pkthdr.vlan_tag = ifv->ifv_tag;
+       m->m_pkthdr.vlan_tag = tag;

     } else {
     } else {

-       M_PREPEND(m, ifv->ifv_encaplen, M_DONTWAIT);
+       M_PREPEND(m, encaplen, M_DONTWAIT);

        if (m == NULL) {
        if (m == NULL) {

-           printf("%s: unable to prepend VLAN header\n", 
-                  ifv->ifv_name);
-           ifp->if_ierrors++;
+           printf("%s%d: unable to prepend VLAN header\n", ifnet_name(ifp),
+                  ifnet_unit(ifp));
+           atomic_add_64(&ifp->if_oerrors, 1);

            return (0);
        }
        /* M_PREPEND takes care of m_len, m_pkthdr.len for us */
            return (0);
        }
        /* M_PREPEND takes care of m_len, m_pkthdr.len for us */

-       if (m->m_len < sizeof(*evl)) {
+       if (m->m_len < (int)sizeof(*evl)) {

            m = m_pullup(m, sizeof(*evl));
            if (m == NULL) {
            m = m_pullup(m, sizeof(*evl));
            if (m == NULL) {

-               printf("%s: cannot pullup VLAN header\n",
-                      ifv->ifv_name);
-               ifp->if_ierrors++;
+               printf("%s%d: unable to pullup VLAN header\n", ifnet_name(ifp),
+                      ifnet_unit(ifp));
+               atomic_add_64(&ifp->if_oerrors, 1);

                return (0);
            }
        }
                return (0);
            }
        }


@@ -587,31 +1160,37 @@ vlan_output(struct ifnet *ifp, struct mbuf *m)
         * Transform the Ethernet header into an Ethernet header
         * with 802.1Q encapsulation.
         */
         * Transform the Ethernet header into an Ethernet header
         * with 802.1Q encapsulation.
         */

-       bcopy(mtod(m, char *) + ifv->ifv_encaplen,
+       bcopy(mtod(m, char *) + encaplen,

              mtod(m, char *), ETHER_HDR_LEN);
        evl = mtod(m, struct ether_vlan_header *);
        evl->evl_proto = evl->evl_encap_proto;
        evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
              mtod(m, char *), ETHER_HDR_LEN);
        evl = mtod(m, struct ether_vlan_header *);
        evl->evl_proto = evl->evl_encap_proto;
        evl->evl_encap_proto = htons(ETHERTYPE_VLAN);

-       evl->evl_tag = htons(ifv->ifv_tag);
-       m->m_pkthdr.len += ifv->ifv_encaplen;
+       evl->evl_tag = htons(tag);

     }
     }

-       
-    /*
-     * Send it, precisely as ether_output() would have.
-     * We are already running at splimp.
-     */
-    return ((*p->if_output)(p, m));
+    return (ifnet_output_raw(p, PF_VLAN, m));
+
+ unlock_done:
+    vlan_unlock();
+    if (ifv != NULL) {
+       ifvlan_release(ifv);
+    }
+    if (vlp != NULL) {
+       vlan_parent_release(vlp);
+    }
+    m_freem_list(m);
+    return (0);
+

 }
 
 }
 

-extern int 
-vlan_demux(struct ifnet * ifp, struct mbuf * m, 
-          char * frame_header, struct if_proto * * proto)
+static int
+vlan_input(ifnet_t p, __unused protocol_family_t protocol,
+                                          mbuf_t m, char *frame_header)

 {
 {

-    register struct ether_header *eh = (struct ether_header *)frame_header;
-    struct ether_vlan_header *evl;
-    struct ifvlan *ifv = NULL;
-    int soft_vlan = 0;
-    u_int tag;
+    bpf_packet_func            bpf_func = NULL;
+    struct ether_vlan_header * evl;
+    struct ifnet *             ifp = NULL;
+    int                        soft_vlan = 0;
+    u_int                      tag = 0;

 
     if (m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) {
        /*
 
     if (m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) {
        /*


@@ -623,21 +1202,20 @@ vlan_demux(struct ifnet * ifp, struct mbuf * m,
        m->m_pkthdr.vlan_tag = 0;
     } else {
        soft_vlan = 1;
        m->m_pkthdr.vlan_tag = 0;
     } else {
        soft_vlan = 1;

-
-       switch (ifp->if_type) {
+       switch (ifnet_type(p)) {

        case IFT_ETHER:
            if (m->m_len < ETHER_VLAN_ENCAP_LEN) {
                m_freem(m);
        case IFT_ETHER:
            if (m->m_len < ETHER_VLAN_ENCAP_LEN) {
                m_freem(m);

-               return (EJUSTRETURN);
+               return 0;

            }
            evl = (struct ether_vlan_header *)frame_header;
            if (ntohs(evl->evl_proto) == ETHERTYPE_VLAN) {
                /* don't allow VLAN within VLAN */
                m_freem(m);
            }
            evl = (struct ether_vlan_header *)frame_header;
            if (ntohs(evl->evl_proto) == ETHERTYPE_VLAN) {
                /* don't allow VLAN within VLAN */
                m_freem(m);

-               return (EJUSTRETURN);
+               return (0);

            }
            tag = EVL_VLANOFTAG(ntohs(evl->evl_tag));
            }
            tag = EVL_VLANOFTAG(ntohs(evl->evl_tag));

-
+               

            /*
             * Restore the original ethertype.  We'll remove
             * the encapsulation after we've found the vlan
            /*
             * Restore the original ethertype.  We'll remove
             * the encapsulation after we've found the vlan


@@ -647,28 +1225,34 @@ vlan_demux(struct ifnet * ifp, struct mbuf * m,
            break;
        default:
            printf("vlan_demux: unsupported if type %u", 
            break;
        default:
            printf("vlan_demux: unsupported if type %u", 

-                  ifp->if_type);
+                  ifnet_type(p));

            m_freem(m);
            m_freem(m);

-           return (EJUSTRETURN);
+           return 0;

            break;
        }
     }
     if (tag != 0) {
            break;
        }
     }
     if (tag != 0) {

-       if (ifp->if_nvlans == 0) {
+       ifvlan_ref              ifv;
+
+       if ((ifnet_eflags(p) & IFEF_VLAN) == 0) {

            /* don't bother looking through the VLAN list */
            m_freem(m);
            /* don't bother looking through the VLAN list */
            m_freem(m);

-           ifp->if_noproto++;
-           return (EJUSTRETURN);
+           return 0;
+       }
+       vlan_lock();
+       ifv = vlan_lookup_parent_and_tag(p, tag);
+       if (ifv != NULL) {
+           ifp = ifv->ifv_ifp;

        }
        }

-       VLAN_LOCK();
-       ifv = vlan_lookup_ifp_and_tag(ifp, tag);
-       if (ifv == NULL || (ifv->ifv_ifp->if_flags & IFF_UP) == 0) {
-           VLAN_UNLOCK();
+       if (ifv == NULL 
+           || ifvlan_flags_ready(ifv) == 0
+           || (ifnet_flags(ifp) & IFF_UP) == 0) {
+           vlan_unlock();

            m_freem(m);
            m_freem(m);

-           ifp->if_noproto++;
-           return (EJUSTRETURN);
+           return 0;

        }
        }

-       VLAN_UNLOCK();          /* XXX extend below? */
+       bpf_func = ifv->ifv_bpf_input;
+       vlan_unlock();

     }
     if (soft_vlan) {
        /*
     }
     if (soft_vlan) {
        /*


@@ -682,105 +1266,152 @@ vlan_demux(struct ifnet * ifp, struct mbuf * m,
        m->m_pkthdr.csum_flags = 0; /* can't trust hardware checksum */
     }
     if (tag != 0) {
        m->m_pkthdr.csum_flags = 0; /* can't trust hardware checksum */
     }
     if (tag != 0) {

-       /* we found a vlan interface above, so send it up */
-       m->m_pkthdr.rcvif = ifv->ifv_ifp;
-       ifv->ifv_ifp->if_ipackets++;
-       ifv->ifv_ifp->if_ibytes += m->m_pkthdr.len;
-
-       vlan_bpf_input(ifv->ifv_ifp, m, ifv->ifv_bpf_input, frame_header,
-                      ETHER_HDR_LEN, soft_vlan ? ETHER_VLAN_ENCAP_LEN : 0);
-
-       /* Pass it back through the parent's demux routine. */
-       return ((*ifp->if_demux)(ifv->ifv_ifp, m, frame_header, proto));
+       m->m_pkthdr.rcvif = ifp;
+       m->m_pkthdr.header = frame_header;
+       (void)ifnet_stat_increment_in(ifp, 1, 
+                                     m->m_pkthdr.len + ETHER_HDR_LEN, 0);
+       vlan_bpf_input(ifp, m, bpf_func, frame_header, ETHER_HDR_LEN, 
+                      soft_vlan ? ETHER_VLAN_ENCAP_LEN : 0);
+       /* We found a vlan interface, inject on that interface. */
+       dlil_input_packet_list(ifp, m);
+    } else {
+       m->m_pkthdr.header = frame_header;
+       /* Send priority-tagged packet up through the parent */
+       dlil_input_packet_list(p, m);

     }
     }

-    /* Pass it back through calling demux routine. */
-    return ((*ifp->if_demux)(ifp, m, frame_header, proto));
+    return 0;

 }
 
 static int
 }
 
 static int

-vlan_config(struct ifvlan *ifv, struct ifnet *p, int tag)
+vlan_config(struct ifnet * ifp, struct ifnet * p, int tag)

 {
 {

-    struct ifnet * ifp;
-    struct ifaddr *ifa1, *ifa2;
-    struct sockaddr_dl *sdl1, *sdl2;
-    int supports_vlan_mtu = 0;
+    int                        error;
+    int                        first_vlan = FALSE;
+    ifvlan_ref                 ifv = NULL;
+    int                        ifv_added = FALSE;
+    int                        need_vlp_release = 0;
+    vlan_parent_ref    new_vlp = NULL;
+    ifnet_offload_t    offload;
+    u_int16_t          parent_flags;
+    vlan_parent_ref    vlp = NULL;
+
+    /* pre-allocate space for vlan_parent, in case we're first */
+    error = vlan_parent_create(p, &new_vlp);
+    if (error != 0) {
+       return (error);
+    }

 
 

-    VLAN_LOCK_ASSERT();
-    if (p->if_data.ifi_type != IFT_ETHER)
-       return EPROTONOSUPPORT;
-    if (ifv->ifv_p != NULL || ifv->ifv_detaching) {
-       return EBUSY;
+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL || ifv->ifv_vlp != NULL) {
+       vlan_unlock();
+       if (ifv != NULL) {
+           ifvlan_release(ifv);
+       }
+       vlan_parent_release(new_vlp);
+       return (EBUSY);

     }
     }

-    if (vlan_lookup_ifp_and_tag(p, tag) != NULL) {
-       /* already a VLAN with that tag on this interface */
-       return (EADDRINUSE);
+    vlp = parent_list_lookup(p);
+    if (vlp != NULL) {
+       vlan_parent_retain(vlp);
+       need_vlp_release++;
+       if (vlan_parent_lookup_tag(vlp, tag) != NULL) {
+           /* already a VLAN with that tag on this interface */
+           error = EADDRINUSE;
+           goto unlock_done;
+       }

     }
     }

-    ifp = ifv->ifv_ifp;
-    ifv->ifv_encaplen = ETHER_VLAN_ENCAP_LEN;
-    ifv->ifv_mintu = ETHERMIN;
-    ifv->ifv_flags = 0;
+    else {
+       /* one for being in the list */
+       vlan_parent_retain(new_vlp);

 
 

-    /*
-     * If the parent supports the VLAN_MTU capability,
-     * i.e. can Tx/Rx larger than ETHER_MAX_LEN frames,
-     * enable it.
-     */
-    if (p->if_hwassist & (IF_HWASSIST_VLAN_MTU | IF_HWASSIST_VLAN_TAGGING)) {
-       supports_vlan_mtu = 1;
+       /* we're the first VLAN on this interface */
+       LIST_INSERT_HEAD(&g_vlan->parent_list, new_vlp, vlp_parent_list);
+       vlp = new_vlp;
+
+       vlan_parent_retain(vlp);
+       need_vlp_release++;

     }
     }

-    if (p->if_nvlans == 0) {
-       u_long  dltag;
-       u_long  filter_id;
-       int     error;

 
 

-       /* attach our VLAN "interface filter" to the interface */
-       error = vlan_attach_filter(p, &filter_id);
-       if (error) {
-           return (error);
-       }
+    /* need to wait to ensure no one else is trying to add/remove */
+    vlan_parent_wait(vlp, "vlan_config");
+
+    if (ifnet_get_ifvlan(ifp) != ifv) {
+       error = EINVAL;
+       goto signal_done;
+    }
+
+    /* check again because someone might have gotten in */
+    if (parent_list_lookup(p) != vlp) {
+       error = EBUSY;
+       goto signal_done;
+    }
+
+    if (vlan_parent_flags_detaching(vlp)
+       || ifvlan_flags_detaching(ifv) || ifv->ifv_vlp != NULL) {
+       error = EBUSY;
+       goto signal_done;
+    }
+
+    /* check again because someone might have gotten the tag */
+    if (vlan_parent_lookup_tag(vlp, tag) != NULL) {
+       /* already a VLAN with that tag on this interface */
+       error = EADDRINUSE;
+       goto signal_done;
+    }

 
 

+    if (vlan_parent_no_vlans(vlp)) {
+       first_vlan = TRUE;
+    }
+    vlan_parent_add_vlan(vlp, ifv, tag);
+    ifvlan_retain(ifv);        /* parent references ifv */
+    ifv_added = TRUE;
+
+    /* check whether bond interface is using parent interface */
+    ifnet_lock_exclusive(p);
+    if ((ifnet_eflags(p) & IFEF_BOND) != 0) {
+       ifnet_lock_done(p);
+       /* don't allow VLAN over interface that's already part of a bond */
+       error = EBUSY;
+       goto signal_done;
+    }
+    /* prevent BOND interface from using it */
+    /* Can't use ifnet_set_eflags because that would take the lock */
+    p->if_eflags |= IFEF_VLAN;
+    ifnet_lock_done(p);
+    vlan_unlock();
+
+    if (first_vlan) {

        /* attach our VLAN "protocol" to the interface */
        error = vlan_attach_protocol(p);
        if (error) {
        /* attach our VLAN "protocol" to the interface */
        error = vlan_attach_protocol(p);
        if (error) {

-           (void)vlan_detach_filter(filter_id);
-           return (error);
-       }
-       ifv->ifv_filter_id = filter_id;
-       ifv->ifv_filter_valid = TRUE;
-#if 0
-       if (supports_vlan_mtu) {
-           /*
-            * Enable Tx/Rx of VLAN-sized frames.
-            */
-           p->if_capenable |= IFCAP_VLAN_MTU;
-           if (p->if_flags & IFF_UP) {
-               struct ifreq ifr;
-               int error;
-               
-               ifr.ifr_flags = p->if_flags;
-               error = (*p->if_ioctl)(p, SIOCSIFFLAGS,
-                                      (caddr_t) &ifr);
-               if (error) {
-                   if (p->if_nvlans == 0)
-                       p->if_capenable &= ~IFCAP_VLAN_MTU;
-                   return (error);
-               }
-           }
+           vlan_lock();
+           goto signal_done;

        }
        }

-#endif 0
-    } else {
-       struct ifvlan *         other_ifv;
+       /* mark the parent interface up */
+       ifnet_set_flags(p, IFF_UP, IFF_UP);
+       (void)ifnet_ioctl(p, 0, SIOCSIFFLAGS, (caddr_t)NULL);
+    }

 
 

-       other_ifv = vlan_lookup_ifp(p);
-       if (other_ifv == NULL) {
-           printf("vlan: other_ifv can't be NULL\n");
-           return (EINVAL);
+    /* configure parent to receive our multicast addresses */
+    error = multicast_list_program(&ifv->ifv_multicast, ifp, p);
+    if (error != 0) {
+       if (first_vlan) {
+           (void)vlan_detach_protocol(p);

        }
        }

-       ifv->ifv_filter_id = other_ifv->ifv_filter_id;
-       ifv->ifv_filter_valid = TRUE;
+       vlan_lock();
+       goto signal_done;

     }
     }

-    p->if_nvlans++;
-    if (supports_vlan_mtu) {
+
+    /* set our ethernet address to that of the parent */
+    ifnet_set_lladdr_and_type(ifp, ifnet_lladdr(p), ETHER_ADDR_LEN, IFT_ETHER);
+
+    /* no failures past this point */
+    vlan_lock();
+
+    ifv->ifv_encaplen = ETHER_VLAN_ENCAP_LEN;
+    ifv->ifv_flags = 0;
+    if (vlan_parent_flags_supports_vlan_mtu(vlp)) {

        ifv->ifv_mtufudge = 0;
     } else {
        /*
        ifv->ifv_mtufudge = 0;
     } else {
        /*


@@ -792,45 +1423,68 @@ vlan_config(struct ifvlan *ifv, struct ifnet *p, int tag)
         */
        ifv->ifv_mtufudge = ifv->ifv_encaplen;
     }
         */
        ifv->ifv_mtufudge = ifv->ifv_encaplen;
     }

+    ifnet_set_mtu(ifp, ETHERMTU - ifv->ifv_mtufudge);

 
 

-    ifv->ifv_p = p;
-    ifp->if_mtu = p->if_mtu - ifv->ifv_mtufudge;

     /*
      * Copy only a selected subset of flags from the parent.
      * Other flags are none of our business.
      */
     /*
      * Copy only a selected subset of flags from the parent.
      * Other flags are none of our business.
      */

-    ifp->if_flags |= (p->if_flags &
-                     (IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX));
-    /*
-     * If the parent interface can do hardware-assisted
-     * VLAN encapsulation, then propagate its hardware-
-     * assisted checksumming flags.
-     */
-    if (p->if_hwassist & IF_HWASSIST_VLAN_TAGGING) {
-       ifp->if_hwassist |= IF_HWASSIST_CSUM_FLAGS(p->if_hwassist);
+    parent_flags = ifnet_flags(p) 
+       & (IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX);
+    ifnet_set_flags(ifp, parent_flags,
+                   IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX);
+
+    /* use hwassist bits from parent interface, but exclude VLAN bits */
+    offload = ifnet_offload(p) & ~(IFNET_VLAN_TAGGING | IFNET_VLAN_MTU);
+    ifnet_set_offload(ifp, offload);
+
+    ifnet_set_flags(ifp, IFF_RUNNING, IFF_RUNNING);
+    ifvlan_flags_set_ready(ifv);
+    vlan_parent_signal(vlp, "vlan_config");
+    vlan_unlock();
+    if (new_vlp != vlp) {
+       /* throw it away, it wasn't needed */
+       vlan_parent_release(new_vlp);

     }
     }

-    /*
-     * Set up our ``Ethernet address'' to reflect the underlying
-     * physical interface's.
-     */
-    ifa1 = ifaddr_byindex(ifp->if_index);
-    ifa2 = ifaddr_byindex(p->if_index);
-    sdl1 = (struct sockaddr_dl *)ifa1->ifa_addr;
-    sdl2 = (struct sockaddr_dl *)ifa2->ifa_addr;
-    sdl1->sdl_type = IFT_ETHER;
-    sdl1->sdl_alen = ETHER_ADDR_LEN;
-    bcopy(LLADDR(sdl2), LLADDR(sdl1), ETHER_ADDR_LEN);
-    bcopy(LLADDR(sdl2), IFP2AC(ifp)->ac_enaddr, ETHER_ADDR_LEN);
+    if (ifv != NULL) {
+       ifvlan_release(ifv);
+    }
+    return 0;

 
 

-    /*
-     * Configure multicast addresses that may already be
-     * joined on the vlan device.
-     */
-    (void)vlan_setmulti(ifp);
-    ifp->if_output = vlan_output;
-    ifv->ifv_tag = tag;
+ signal_done:
+    vlan_assert_lock_held();

 
 

-    return 0;
+    if (ifv_added) {
+       vlan_parent_remove_vlan(vlp, ifv);
+       if (!vlan_parent_flags_detaching(vlp) && vlan_parent_no_vlans(vlp)) {
+           /* the vlan parent has no more VLAN's */
+           ifnet_set_eflags(p, 0, IFEF_VLAN);
+           LIST_REMOVE(vlp, vlp_parent_list);
+           /* release outside of the lock below */
+           need_vlp_release++;
+
+           /* one for being in the list */
+           need_vlp_release++;
+       }
+    }
+    vlan_parent_signal(vlp, "vlan_config");
+
+ unlock_done:
+    vlan_unlock();
+
+    while (need_vlp_release--) {
+       vlan_parent_release(vlp);
+    }
+    if (new_vlp != vlp) {
+       vlan_parent_release(new_vlp);
+    }
+    if (ifv != NULL) {
+       if (ifv_added) {
+           ifvlan_release(ifv);
+       }
+       ifvlan_release(ifv);
+    }
+    return (error);

 }
 
 static void
 }
 
 static void


@@ -838,268 +1492,436 @@ vlan_link_event(struct ifnet * ifp, struct ifnet * p)
 {
     struct ifmediareq ifmr;
 
 {
     struct ifmediareq ifmr;
 

-    /* generate a link event based on the state of the underlying interface */
-    bzero(&ifmr, sizeof(ifmr));
-    snprintf(ifmr.ifm_name, sizeof(ifmr.ifm_name),
-            "%s%d", p->if_name, p->if_unit);
-    if ((*p->if_ioctl)(p, SIOCGIFMEDIA, (caddr_t)&ifmr) == 0
-       && ifmr.ifm_count > 0 && ifmr.ifm_status & IFM_AVALID) {
-       u_long  event;
-       
-       event = (ifmr.ifm_status & IFM_ACTIVE)
-           ? KEV_DL_LINK_ON : KEV_DL_LINK_OFF;
-       interface_link_event(ifp, event);
+    /* generate a link event based on the state of the underlying interface */
+    bzero(&ifmr, sizeof(ifmr));
+    snprintf(ifmr.ifm_name, sizeof(ifmr.ifm_name),
+            "%s%d", ifnet_name(p), ifnet_unit(p));
+    if (ifnet_ioctl(p, 0, SIOCGIFMEDIA, &ifmr) == 0
+       && ifmr.ifm_count > 0 && ifmr.ifm_status & IFM_AVALID) {
+       u_int32_t       event;
+       
+       event = (ifmr.ifm_status & IFM_ACTIVE)
+           ? KEV_DL_LINK_ON : KEV_DL_LINK_OFF;
+       interface_link_event(ifp, event);
+    }
+    return;
+}
+
+static int
+vlan_unconfig(ifvlan_ref ifv, int need_to_wait)
+{
+    struct ifnet *     ifp = ifv->ifv_ifp;
+    int                        last_vlan = FALSE;
+    int                        need_ifv_release = 0;
+    int                        need_vlp_release = 0;
+    struct ifnet *     p;
+    vlan_parent_ref    vlp;
+
+    vlan_assert_lock_held();
+    vlp = ifv->ifv_vlp;
+    if (vlp == NULL) {
+       return (0);
+    }
+    if (need_to_wait) {
+       need_vlp_release++;
+       vlan_parent_retain(vlp);
+       vlan_parent_wait(vlp, "vlan_unconfig");
+
+        /* check again because another thread could be in vlan_unconfig */
+       if (ifv != ifnet_get_ifvlan(ifp)) {
+           goto signal_done;
+       }
+       if (ifv->ifv_vlp != vlp) {
+           /* vlan parent changed */
+           goto signal_done;
+       }
+    }
+
+    /* ifv has a reference on vlp, need to remove it */
+    need_vlp_release++;
+    p = vlp->vlp_ifp;
+
+    /* remember whether we're the last VLAN on the parent */
+    if (LIST_NEXT(LIST_FIRST(&vlp->vlp_vlan_list), ifv_vlan_list) == NULL) {
+       if (g_vlan->verbose) {
+           printf("vlan_unconfig: last vlan on %s%d\n",
+                  ifnet_name(p), ifnet_unit(p));
+       }
+       last_vlan = TRUE;
+    }
+
+    /* back-out any effect our mtu might have had on the parent */
+    (void)ifvlan_new_mtu(ifv, ETHERMTU - ifv->ifv_mtufudge);
+
+    vlan_unlock();
+
+    /* un-join multicast on parent interface */
+    (void)multicast_list_remove(&ifv->ifv_multicast);
+
+    /* Clear our MAC address. */
+    ifnet_set_lladdr_and_type(ifp, NULL, 0, IFT_L2VLAN);
+
+    /* detach VLAN "protocol" */
+    if (last_vlan) {
+       (void)vlan_detach_protocol(p);
+    }
+
+    vlan_lock();
+
+    /* return to the state we were in before SIFVLAN */
+    ifnet_set_mtu(ifp, 0);
+    ifnet_set_flags(ifp, 0, 
+                   IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX | IFF_RUNNING);
+    ifnet_set_offload(ifp, 0);
+    ifv->ifv_mtufudge = 0;
+
+    /* Disconnect from parent. */
+    vlan_parent_remove_vlan(vlp, ifv);
+    ifv->ifv_flags = 0;
+
+    /* vlan_parent has reference to ifv, remove it */
+    need_ifv_release++;
+
+    /* from this point on, no more referencing ifv */
+    if (last_vlan && !vlan_parent_flags_detaching(vlp)) {
+       /* the vlan parent has no more VLAN's */
+       ifnet_set_eflags(p, 0, IFEF_VLAN);
+       LIST_REMOVE(vlp, vlp_parent_list);
+
+       /* one for being in the list */
+       need_vlp_release++;
+
+       /* release outside of the lock below */
+       need_vlp_release++;
+    }
+
+ signal_done:
+    if (need_to_wait) {
+       vlan_parent_signal(vlp, "vlan_unconfig");

     }
     }

-    return;
+    vlan_unlock();
+    while (need_ifv_release--) {
+       ifvlan_release(ifv);
+    }
+    while (need_vlp_release--) {       /* references to vlp */
+       vlan_parent_release(vlp);
+    }
+    vlan_lock();
+    return (0);

 }
 
 static int
 }
 
 static int

-vlan_unconfig(struct ifnet *ifp)
+vlan_set_promisc(struct ifnet * ifp)

 {
 {

-    struct ifaddr *ifa;
-    struct sockaddr_dl *sdl;
-    struct vlan_mc_entry *mc;
-    struct ifvlan *ifv;
-    struct ifnet *p;
-    int error;
-
-    VLAN_LOCK_ASSERT();
-
-    ifv = ifp->if_private;
-
-    /* Disconnect from parent. */
-    p = ifv->ifv_p;
-    ifv->ifv_p = NULL;
+    int                        error = 0;
+    ifvlan_ref                 ifv;
+    vlan_parent_ref            vlp;

 
 

-    if (p != NULL) {
-       struct sockaddr_dl sdl;
+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL) {
+       error = EBUSY;
+       goto done;
+    }

 
 

-       /*
-        * 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.
-        */
-       bzero((char *)&sdl, sizeof sdl);
-       sdl.sdl_len = sizeof sdl;
-       sdl.sdl_family = AF_LINK;
-       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);
-           bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN);
-           error = if_delmulti(p, (struct sockaddr *)&sdl);
-           if (error) {
-               printf("vlan_unconfig: if_delmulti %s failed, %d\n", 
-                      ifv->ifv_name, error);
+    vlp = ifv->ifv_vlp;
+    if (vlp == NULL) {
+       goto done;
+    }
+    if ((ifnet_flags(ifp) & IFF_PROMISC) != 0) {
+       if (!ifvlan_flags_promisc(ifv)) {
+           error = ifnet_set_promiscuous(vlp->vlp_ifp, 1);
+           if (error == 0) {
+               ifvlan_flags_set_promisc(ifv);

            }
            }

-           SLIST_REMOVE_HEAD(&ifv->vlan_mc_listhead, mc_entries);
-           FREE(mc, M_VLAN);

        }
        }

-       p->if_nvlans--;
-       if (p->if_nvlans == 0) {
-           /* detach our VLAN "protocol" from the interface */
-           if (ifv->ifv_filter_valid) {
-               (void)vlan_detach_filter(ifv->ifv_filter_id);
-           }
-           (void)vlan_detach_protocol(p);
-#if 0
-           /*
-            * Disable Tx/Rx of VLAN-sized frames.
-            */
-           p->if_capenable &= ~IFCAP_VLAN_MTU;
-           if (p->if_flags & IFF_UP) {
-               struct ifreq ifr;
-               
-               ifr.ifr_flags = p->if_flags;
-               (*p->if_ioctl)(p, SIOCSIFFLAGS, (caddr_t) &ifr);
+    } else {
+       if (ifvlan_flags_promisc(ifv)) {
+           error = ifnet_set_promiscuous(vlp->vlp_ifp, 0);
+           if (error == 0) {
+               ifvlan_flags_clear_promisc(ifv);

            }
            }

-#endif 0

        }
     }
        }
     }

+ done:
+    vlan_unlock();
+    if (ifv != NULL) {
+       ifvlan_release(ifv);
+    }
+    return (error);
+}

 
 

-    /* return to the state we were in before SETVLAN */
-    ifp->if_mtu = 0;
-    ifp->if_flags &= ~(IFF_BROADCAST | IFF_MULTICAST 
-                      | IFF_SIMPLEX | IFF_RUNNING);
-    ifv->ifv_ifp->if_hwassist = 0;
-    ifv->ifv_flags = 0;
-    ifv->ifv_ifp->if_output = nop_if_output;
-    ifv->ifv_mtufudge = 0;
-    ifv->ifv_filter_valid = FALSE;
-
-    /* Clear our MAC address. */
-    ifa = ifaddr_byindex(ifv->ifv_ifp->if_index);
-    sdl = (struct sockaddr_dl *)(ifa->ifa_addr);
-    sdl->sdl_type = IFT_L2VLAN;
-    sdl->sdl_alen = 0;
-    bzero(LLADDR(sdl), ETHER_ADDR_LEN);
-    bzero(IFP2AC(ifv->ifv_ifp)->ac_enaddr, ETHER_ADDR_LEN);
-
-    /* send a link down event */
-    if (p != NULL) {
-       interface_link_event(ifv->ifv_ifp, KEV_DL_LINK_OFF);
+static int
+ifvlan_new_mtu(ifvlan_ref ifv, int mtu)
+{
+    struct ifdevmtu *  devmtu_p;
+    int                        error = 0;
+    struct ifnet *     ifp = ifv->ifv_ifp;
+    int                        max_mtu;
+    int                        new_mtu = 0;
+    int                        req_mtu;
+    vlan_parent_ref    vlp;
+
+    vlan_assert_lock_held();
+    vlp = ifv->ifv_vlp;
+    devmtu_p = &vlp->vlp_devmtu;
+    req_mtu = mtu + ifv->ifv_mtufudge;
+    if (req_mtu > devmtu_p->ifdm_max || req_mtu < devmtu_p->ifdm_min) {
+       return (EINVAL);

     }
     }

-    return 0;
+    max_mtu = vlan_parent_find_max_mtu(vlp, ifv);
+    if (req_mtu > max_mtu) {
+       new_mtu = req_mtu;
+    }
+    else if (max_mtu < devmtu_p->ifdm_current) {
+       new_mtu = max_mtu;
+    }
+    if (new_mtu != 0) {
+       struct ifnet *  p = vlp->vlp_ifp;
+       vlan_unlock();
+       error = siocsifaltmtu(p, new_mtu);
+       vlan_lock();
+    }
+    if (error == 0) {
+       if (new_mtu != 0) {
+           devmtu_p->ifdm_current = new_mtu;
+       }
+       ifnet_set_mtu(ifp, mtu);
+    }
+    return (error);

 }
 
 static int
 }
 
 static int

-vlan_set_promisc(struct ifnet *ifp)
+vlan_set_mtu(struct ifnet * ifp, int mtu)

 {
 {

-    struct ifvlan *ifv = ifp->if_private;
-    int error = 0;
+    int                        error = 0;
+    ifvlan_ref         ifv;
+    vlan_parent_ref    vlp;

 
 

-    if ((ifp->if_flags & IFF_PROMISC) != 0) {
-       if ((ifv->ifv_flags & IFVF_PROMISC) == 0) {
-           error = ifpromisc(ifv->ifv_p, 1);
-           if (error == 0)
-               ifv->ifv_flags |= IFVF_PROMISC;
+    if (mtu < IF_MINMTU) {
+       return (EINVAL);
+    }
+    vlan_lock();
+    ifv = ifnet_get_ifvlan_retained(ifp);
+    if (ifv == NULL) {
+       vlan_unlock();
+       return (EBUSY);
+    }
+    vlp = ifvlan_get_vlan_parent_retained(ifv);
+    if (vlp == NULL) {
+       vlan_unlock();
+       ifvlan_release(ifv);
+       if (mtu != 0) {
+           return (EINVAL);

        }
        }

-    } else {
-       if ((ifv->ifv_flags & IFVF_PROMISC) != 0) {
-           error = ifpromisc(ifv->ifv_p, 0);
-           if (error == 0)
-               ifv->ifv_flags &= ~IFVF_PROMISC;
+       return (0);
+    }
+    vlan_parent_wait(vlp, "vlan_set_mtu");
+
+    /* check again, something might have changed */
+    if (ifnet_get_ifvlan(ifp) != ifv
+       || ifvlan_flags_detaching(ifv)) {
+       error = EBUSY;
+       goto signal_done;
+    }
+    if (ifv->ifv_vlp != vlp) {
+       /* vlan parent changed */
+       goto signal_done;
+    }
+    if (vlan_parent_flags_detaching(vlp)) {
+       if (mtu != 0) {
+           error = EINVAL;

        }
        }

+       goto signal_done;

     }
     }

+    error = ifvlan_new_mtu(ifv, mtu);
+
+ signal_done:
+    vlan_parent_signal(vlp, "vlan_set_mtu");
+    vlan_unlock();
+    vlan_parent_release(vlp);
+    ifvlan_release(ifv);

 
     return (error);
 }
 
 static int
 
     return (error);
 }
 
 static int

-vlan_ioctl(struct ifnet *ifp, u_long cmd, void * data)
+vlan_ioctl(ifnet_t ifp, u_long cmd, void * data)

 {
 {

-    struct ifaddr *ifa;
-    struct ifnet *p;
-    struct ifreq *ifr;
-    struct ifvlan *ifv;
-    struct vlanreq vlr;
-    int error = 0;
-
+    struct ifdevmtu *  devmtu_p;
+    int                error = 0;
+    struct ifaddr *    ifa;
+    struct ifmediareq  *ifmr;
+    struct ifreq *     ifr;
+    ifvlan_ref         ifv;
+    struct ifnet *     p;
+    u_short            tag;
+    user_addr_t                user_addr;
+    vlan_parent_ref    vlp;
+    struct vlanreq     vlr;
+
+    if (ifnet_type(ifp) != IFT_L2VLAN) {
+       return (EOPNOTSUPP);
+    }

     ifr = (struct ifreq *)data;
     ifa = (struct ifaddr *)data;
     ifr = (struct ifreq *)data;
     ifa = (struct ifaddr *)data;

-    ifv = (struct ifvlan *)ifp->if_private;

 
     switch (cmd) {
     case SIOCSIFADDR:
 
     switch (cmd) {
     case SIOCSIFADDR:

-       ifp->if_flags |= IFF_UP;
+    ifnet_set_flags(ifp, IFF_UP, IFF_UP);

        break;
 
        break;
 

-    case SIOCGIFMEDIA:
-       VLAN_LOCK();
-       if (ifv->ifv_p != NULL) {
-           error = (*ifv->ifv_p->if_ioctl)(ifv->ifv_p,
-                                           SIOCGIFMEDIA, data);
-           VLAN_UNLOCK();
-           /* Limit the result to the parent's current config. */
-           if (error == 0) {
-               struct ifmediareq *ifmr;
+    case SIOCGIFMEDIA32:
+    case SIOCGIFMEDIA64:
+       vlan_lock();
+       ifv = (ifvlan_ref)ifnet_softc(ifp);
+       if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+           vlan_unlock();
+           return (ifv == NULL ? EOPNOTSUPP : EBUSY);
+       }
+       p = (ifv->ifv_vlp == NULL) ? NULL : ifv->ifv_vlp->vlp_ifp;
+       vlan_unlock();
+       ifmr = (struct ifmediareq *)data;
+       user_addr =  (cmd == SIOCGIFMEDIA64) ?
+           ((struct ifmediareq64 *)ifmr)->ifmu_ulist :
+           CAST_USER_ADDR_T(((struct ifmediareq32 *)ifmr)->ifmu_ulist);
+       if (p != NULL) {
+           struct ifmediareq p_ifmr;

 
 

-               ifmr = (struct ifmediareq *) data;
-               if (ifmr->ifm_count >= 1 && ifmr->ifm_ulist) {
+           bzero(&p_ifmr, sizeof(p_ifmr));
+           error = ifnet_ioctl(p, 0, SIOCGIFMEDIA, &p_ifmr);
+           if (error == 0) {
+               ifmr->ifm_active = p_ifmr.ifm_active;
+               ifmr->ifm_current = p_ifmr.ifm_current;
+               ifmr->ifm_mask = p_ifmr.ifm_mask;
+               ifmr->ifm_status = p_ifmr.ifm_status;
+               ifmr->ifm_count = p_ifmr.ifm_count;
+               /* Limit the result to the parent's current config. */
+               if (ifmr->ifm_count >= 1 && user_addr != USER_ADDR_NULL) {

                    ifmr->ifm_count = 1;
                    ifmr->ifm_count = 1;

-                   error = copyout(&ifmr->ifm_current,
-                                   ifmr->ifm_ulist, 
+                   error = copyout(&ifmr->ifm_current, user_addr, 

                                    sizeof(int));
                }
            }
        } else {
                                    sizeof(int));
                }
            }
        } else {

-           struct ifmediareq *ifmr;
-           VLAN_UNLOCK();
-           
-           ifmr = (struct ifmediareq *) data;
-           ifmr->ifm_current = 0;
+           ifmr->ifm_active = ifmr->ifm_current = IFM_NONE;

            ifmr->ifm_mask = 0;
            ifmr->ifm_status = IFM_AVALID;
            ifmr->ifm_mask = 0;
            ifmr->ifm_status = IFM_AVALID;

-           ifmr->ifm_active = 0;

            ifmr->ifm_count = 1;
            ifmr->ifm_count = 1;

-           if (ifmr->ifm_ulist) {
-               error = copyout(&ifmr->ifm_current,
-                               ifmr->ifm_ulist, 
-                               sizeof(int));
+           if (user_addr != USER_ADDR_NULL) {
+               error = copyout(&ifmr->ifm_current, user_addr, sizeof(int));

            }
            }

-           error = 0;

        }
        break;
 
     case SIOCSIFMEDIA:
        }
        break;
 
     case SIOCSIFMEDIA:

-       error = EINVAL;
-       break;
-
-    case SIOCSIFMTU:
-       /*
-        * Set the interface MTU.
-        */
-       VLAN_LOCK();
-       if (ifv->ifv_p != NULL) {
-           if (ifr->ifr_mtu > (ifv->ifv_p->if_mtu - ifv->ifv_mtufudge)
-               || ifr->ifr_mtu < (ifv->ifv_mintu - ifv->ifv_mtufudge)) {
-               error = EINVAL;
-           } else {
-               ifp->if_mtu = ifr->ifr_mtu;
-           }
-       } else {
-           error = EINVAL;
-       }
-       VLAN_UNLOCK();
+       error = EOPNOTSUPP;

        break;
 
        break;
 

-    case SIOCSETVLAN:
-       error = copyin(ifr->ifr_data, &vlr, sizeof(vlr));
-       if (error)
-           break;
-       if (vlr.vlr_parent[0] == '\0') {
-           VLAN_LOCK();
-           vlan_unconfig(ifp);
-#if 0
-           if (ifp->if_flags & IFF_UP)
-               if_down(ifp);
-           ifp->if_flags &= ~IFF_RUNNING;
-#endif 0
-           VLAN_UNLOCK();
-           break;
+    case SIOCGIFDEVMTU:
+       vlan_lock();
+       ifv = (ifvlan_ref)ifnet_softc(ifp);
+       if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+           vlan_unlock();
+           return (ifv == NULL ? EOPNOTSUPP : EBUSY);

        }
        }

-       p = ifunit(vlr.vlr_parent);
-       if (p == 0) {
-           error = ENOENT;
-           break;
+       vlp = ifv->ifv_vlp;
+       if (vlp != NULL) {
+           int         min_mtu = vlp->vlp_devmtu.ifdm_min - ifv->ifv_mtufudge;
+           devmtu_p = &ifr->ifr_devmtu;
+           devmtu_p->ifdm_current = ifnet_mtu(ifp);
+           devmtu_p->ifdm_min = max(min_mtu, IF_MINMTU);
+           devmtu_p->ifdm_max = vlp->vlp_devmtu.ifdm_max - ifv->ifv_mtufudge;

        }
        }

-       /*
-        * 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;
+       else {
+           devmtu_p = &ifr->ifr_devmtu;
+           devmtu_p->ifdm_current = 0;
+           devmtu_p->ifdm_min = 0;
+           devmtu_p->ifdm_max = 0;

        }
        }

-       VLAN_LOCK();
-       error = vlan_config(ifv, p, vlr.vlr_tag);
+       vlan_unlock();
+       break;
+
+    case SIOCSIFMTU:
+       error = vlan_set_mtu(ifp, ifr->ifr_mtu);
+       break;
+
+    case SIOCSIFVLAN:
+       user_addr = proc_is64bit(current_proc()) 
+           ? ifr->ifr_data64 : CAST_USER_ADDR_T(ifr->ifr_data);
+       error = copyin(user_addr, &vlr, sizeof(vlr));

        if (error) {
        if (error) {

-           VLAN_UNLOCK();

            break;
        }
            break;
        }

-       ifp->if_flags |= IFF_RUNNING;
-       VLAN_UNLOCK();
-
-       /* Update promiscuous mode, if necessary. */
-       vlan_set_promisc(ifp);
-
-       /* generate a link event */
-       vlan_link_event(ifp, p);
+       p = NULL;
+       if (vlr.vlr_parent[0] != '\0') {
+           if (vlr.vlr_tag & ~EVL_VLID_MASK) {
+               /*
+                * Don't let the caller set up a VLAN tag with
+                * anything except VLID bits.
+                */
+               error = EINVAL;
+               break;
+           }
+           p = ifunit(vlr.vlr_parent);
+           if (p == NULL) {
+               error = ENXIO;
+               break;
+           }
+           /* can't do VLAN over anything but ethernet or ethernet aggregate */
+           if (ifnet_type(p) != IFT_ETHER 
+               && ifnet_type(p) != IFT_IEEE8023ADLAG) {
+               error = EPROTONOSUPPORT;
+               break;
+           }
+           error = vlan_config(ifp, p, vlr.vlr_tag);
+           if (error) {
+               break;
+           }
+           
+           /* Update promiscuous mode, if necessary. */
+           (void)vlan_set_promisc(ifp);
+           
+           /* generate a link event based on the state of the parent */
+           vlan_link_event(ifp, p);
+       } 
+       else {
+           int         need_link_event = FALSE;
+
+           vlan_lock();
+           ifv = (ifvlan_ref)ifnet_softc(ifp);
+           if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+               vlan_unlock();
+               error = (ifv == NULL ? EOPNOTSUPP : EBUSY);
+               break;
+           }
+           need_link_event = vlan_remove(ifv, TRUE);
+           vlan_unlock();
+           if (need_link_event) {
+               interface_link_event(ifp, KEV_DL_LINK_OFF);
+           }
+       }

        break;
                
        break;
                

-    case SIOCGETVLAN:
+    case SIOCGIFVLAN:

        bzero(&vlr, sizeof vlr);
        bzero(&vlr, sizeof vlr);

-       VLAN_LOCK();
-       if (ifv->ifv_p != NULL) {
+       vlan_lock();
+       ifv = (ifvlan_ref)ifnet_softc(ifp);
+       if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+           vlan_unlock();
+           return (ifv == NULL ? EOPNOTSUPP : EBUSY);
+       }
+       p = (ifv->ifv_vlp == NULL) ? NULL : ifv->ifv_vlp->vlp_ifp;
+       tag = ifv->ifv_tag;
+       vlan_unlock();
+       if (p != NULL) {

            snprintf(vlr.vlr_parent, sizeof(vlr.vlr_parent),
            snprintf(vlr.vlr_parent, sizeof(vlr.vlr_parent),

-                    "%s%d", ifv->ifv_p->if_name, 
-                    ifv->ifv_p->if_unit);
-           vlr.vlr_tag = ifv->ifv_tag;
+                    "%s%d", ifnet_name(p), ifnet_unit(p));
+           vlr.vlr_tag = tag;

        }
        }

-       VLAN_UNLOCK();
-       error = copyout(&vlr, ifr->ifr_data, sizeof vlr);
+       user_addr = proc_is64bit(current_proc()) 
+           ? ifr->ifr_data64 : CAST_USER_ADDR_T(ifr->ifr_data);
+       error = copyout(&vlr, user_addr, sizeof(vlr));

        break;
                
     case SIOCSIFFLAGS:
        break;
                
     case SIOCSIFFLAGS:


@@ -1107,8 +1929,7 @@ vlan_ioctl(struct ifnet *ifp, u_long cmd, void * data)
         * For promiscuous mode, we enable promiscuous mode on
         * the parent if we need promiscuous on the VLAN interface.
         */
         * For promiscuous mode, we enable promiscuous mode on
         * the parent if we need promiscuous on the VLAN interface.
         */

-       if (ifv->ifv_p != NULL)
-           error = vlan_set_promisc(ifp);
+       error = vlan_set_promisc(ifp);

        break;
 
     case SIOCADDMULTI:
        break;
 
     case SIOCADDMULTI:


@@ -1121,280 +1942,147 @@ vlan_ioctl(struct ifnet *ifp, u_long cmd, void * data)
     return error;
 }
 
     return error;
 }
 

-static int 
-nop_if_ioctl(struct ifnet * ifp, u_long cmd, void * data)
-{
-    return EOPNOTSUPP;
-}
-
-static int 
-nop_if_bpf(struct ifnet *ifp, int mode, bpf_callback_func * func)
-{
-    return ENODEV;
-}
-
-static int 
-nop_if_free(struct ifnet * ifp)
-{
-    return 0;
-}
-
-static int 
-nop_if_output(struct ifnet * ifp, struct mbuf * m)
-{
-    if (m != NULL) {
-       m_freem_list(m);
-    }
-    return 0;
-}
-
-static int 
+static void 

 vlan_if_free(struct ifnet * ifp)
 {
 vlan_if_free(struct ifnet * ifp)
 {

-    struct ifvlan *ifv;
+    ifvlan_ref ifv;

 
     if (ifp == NULL) {
 
     if (ifp == NULL) {

-       return 0;
+       return;

     }
     }

-    ifv = (struct ifvlan *)ifp->if_private;
+    ifv = (ifvlan_ref)ifnet_softc(ifp);

     if (ifv == NULL) {
     if (ifv == NULL) {

-       return 0;
+       return;

     }
     }

-    ifp->if_private = NULL;
-    dlil_if_release(ifp);
-    FREE(ifv, M_VLAN);
-    return 0;
-}
-
-/*
- * Function: vlan_if_filter_detach
- * Purpose:
- *   Destroy all vlan interfaces that refer to the interface
- */
-static int
-vlan_if_filter_detach(caddr_t cookie)
-{
-    struct ifnet *     ifp;
-    struct ifvlan *    ifv;
-    struct ifnet *     p = (struct ifnet *)cookie;
-
-    VLAN_LOCK();
-    while (TRUE) {
-       ifv = vlan_lookup_ifp(p);
-       if (ifv == NULL) {
-           break;
-       }
-       if (ifv->ifv_detaching) {
-           continue;
-       }
-       /* make sure we don't invoke vlan_detach_filter */
-       ifv->ifv_filter_valid = FALSE;
-       vlan_remove(ifv);
-       ifp = ifv->ifv_ifp;
-       VLAN_UNLOCK();
-       vlan_if_detach(ifp);
-       VLAN_LOCK();
-    }
-    VLAN_UNLOCK();
-    return (0);
+    ifvlan_release(ifv);
+    ifnet_release(ifp);
+    return;

 }
 
 }
 

-/*
- * Function: vlan_attach_filter
- * Purpose:
- *   We attach an interface filter to detect when the underlying interface
- *   goes away.  We are forced to do that because dlil does not call our
- *   protocol's dl_event function for KEV_DL_IF_DETACHING.
- */
-
-static int
-vlan_attach_filter(struct ifnet * ifp, u_long * filter_id)
+static void
+vlan_event(struct ifnet        * p, __unused protocol_family_t protocol,
+                  const struct kev_msg * event)

 {
 {

-    int                                error;
-    struct dlil_if_flt_str     filt;
+    int                        event_code;

 
 

-    bzero(&filt, sizeof(filt));
-    filt.filter_detach = vlan_if_filter_detach;
-    filt.cookie = (caddr_t)ifp;
-    error = dlil_attach_interface_filter(ifp, &filt, filter_id, 
-                                        DLIL_LAST_FILTER);
-    if (error) {
-       printf("vlan: dlil_attach_interface_filter(%s%d) failed, %d\n",
-              ifp->if_name, ifp->if_unit, error);
+    /* Check if the interface we are attached to is being detached */
+    if (event->vendor_code != KEV_VENDOR_APPLE
+       || event->kev_class != KEV_NETWORK_CLASS
+       || event->kev_subclass != KEV_DL_SUBCLASS) {
+       return;

     }
     }

-    return (error);
-}
-
-/*
- * Function: vlan_detach_filter
- * Purpose:
- *   Remove our interface filter.
- */
-static int
-vlan_detach_filter(u_long filter_id)
-{
-    int        error;
-
-    error = dlil_detach_filter(filter_id);
-    if (error) {
-       printf("vlan: dlil_detach_filter failed, %d\n", error);
+    event_code = event->event_code;
+    switch (event_code) {
+    case KEV_DL_LINK_OFF:
+    case KEV_DL_LINK_ON:
+       vlan_parent_link_event(p, event_code);
+       break;
+    default:
+       return;

     }
     }

-    return (error);
-}
-
-/*
- * Function: vlan_proto_input
- * Purpose:
- *   This function is never called.  We aren't allowed to leave the
- *   function pointer NULL, so this function simply free's the mbuf.
- */
-static int
-vlan_proto_input(m, frame_header, ifp, dl_tag, sync_ok)
-    struct mbuf  *m;
-    char         *frame_header;
-    struct ifnet *ifp;
-    u_long          dl_tag;
-    int          sync_ok;
-{
-    m_freem(m);
-    return (EJUSTRETURN);
+    return;

 }
 
 }
 

-static struct ifnet *
-find_if_name_unit(const char * if_name, int unit)
+static errno_t
+vlan_detached(ifnet_t p, __unused protocol_family_t protocol)

 {
 {

-    struct ifnet * ifp;
-    
-    TAILQ_FOREACH(ifp, &ifnet, if_link) {
-       if (strcmp(if_name, ifp->if_name) == 0 && unit == ifp->if_unit) {
-           return (ifp);
-       }
+    if (ifnet_is_attached(p, 0) == 0) {
+       /* if the parent isn't attached, remove all VLANs */
+       vlan_parent_remove_all_vlans(p);

     }
     }

-    return (ifp);
+    return (0);

 }
 
 static void
 }
 
 static void

-interface_link_event(struct ifnet * ifp, u_long event_code)
+interface_link_event(struct ifnet * ifp, u_int32_t event_code)

 {
     struct {
        struct kern_event_msg   header;
 {
     struct {
        struct kern_event_msg   header;

-       u_long                  unit;
+       u_int32_t                       unit;

        char                    if_name[IFNAMSIZ];
     } event;
 
        char                    if_name[IFNAMSIZ];
     } event;
 

+    bzero(&event, sizeof(event));

     event.header.total_size    = sizeof(event);
     event.header.vendor_code   = KEV_VENDOR_APPLE;
     event.header.kev_class     = KEV_NETWORK_CLASS;
     event.header.kev_subclass  = KEV_DL_SUBCLASS;
     event.header.event_code    = event_code;
     event.header.total_size    = sizeof(event);
     event.header.vendor_code   = KEV_VENDOR_APPLE;
     event.header.kev_class     = KEV_NETWORK_CLASS;
     event.header.kev_subclass  = KEV_DL_SUBCLASS;
     event.header.event_code    = event_code;

-    event.header.event_data[0] = ifp->if_family;
-    event.unit                 = (u_long) ifp->if_unit;
-    strncpy(event.if_name, ifp->if_name, IFNAMSIZ);
-    dlil_event(ifp, &event.header);
+    event.header.event_data[0] = ifnet_family(ifp);
+    event.unit                 = (u_int32_t) ifnet_unit(ifp);
+    strncpy(event.if_name, ifnet_name(ifp), IFNAMSIZ);
+    ifnet_event(ifp, &event.header);

     return;
 }
 
 static void
     return;
 }
 
 static void

-parent_link_event(struct ifnet * p, u_long event_code)
+vlan_parent_link_event(struct ifnet * p, u_int32_t event_code)

 {
 {

-    struct ifvlan * ifv;
+    ifvlan_ref                 ifv;
+    vlan_parent_ref    vlp;

 
 

-    LIST_FOREACH(ifv, &ifv_list, ifv_list) {
-       if (p == ifv->ifv_p) {
-           interface_link_event(ifv->ifv_ifp, event_code);
-       }
+    vlan_lock();
+    if ((ifnet_eflags(p) & IFEF_VLAN) == 0) {
+       vlan_unlock();
+       /* no VLAN's */
+       return;
+    }
+    vlp = parent_list_lookup(p);
+    if (vlp == NULL) {
+       /* no VLAN's */
+       vlan_unlock();
+       return;

     }
     }

-    return;

 
 

-}
+    vlan_parent_retain(vlp);
+    vlan_parent_wait(vlp, "vlan_parent_link_event");
+    if (vlan_parent_flags_detaching(vlp)) {
+       goto signal_done;
+    }

 
 

-/* 
- * Function: vlan_dl_event
- * Purpose:
- *   Process DLIL events that interest us.  Currently, that is
- *   just the interface UP and DOWN.  Ideally, this would also
- *   include the KEV_DL_IF_DETACH{ING} messages, which would eliminate
- *   the need for an interface filter.
- */
-static int
-vlan_dl_event(struct kern_event_msg * event, u_long dl_tag)
-{
-    struct ifnet *             p;
-    struct net_event_data *    net_event;
+    vlan_unlock();

 
 

-    if (event->vendor_code != KEV_VENDOR_APPLE
-       || event->kev_class != KEV_NETWORK_CLASS
-       || event->kev_subclass != KEV_DL_SUBCLASS) {
-       goto done;
-    }
-    net_event = (struct net_event_data *)(event->event_data);
-    switch (event->event_code) {
-    case KEV_DL_LINK_OFF:
-    case KEV_DL_LINK_ON:
-       p = find_if_name_unit(net_event->if_name, net_event->if_unit);
-       if (p != NULL) {
-           parent_link_event(p, event->event_code);
-       }
-       break;
-#if 0
-    case KEV_DL_IF_DETACHING:
-    case KEV_DL_IF_DETACHED:
-       /* we don't get these, unfortunately */
-       break;
-#endif 0
-    default:
-       break;
+    /* vlan_parent_wait() gives us exclusive access to the list */
+    LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) {
+       struct ifnet *  ifp = ifv->ifv_ifp;
+
+       interface_link_event(ifp, event_code);

     }
 
     }
 

- done:
-    return (0);
+    vlan_lock();
+
+ signal_done:
+    vlan_parent_signal(vlp, "vlan_parent_link_event");
+    vlan_unlock();
+    vlan_parent_release(vlp);
+    return;
+

 }
 
 /*
  * Function: vlan_attach_protocol
  * Purpose:
  *   Attach a DLIL protocol to the interface, using the ETHERTYPE_VLAN
 }
 
 /*
  * Function: vlan_attach_protocol
  * Purpose:
  *   Attach a DLIL protocol to the interface, using the ETHERTYPE_VLAN

- *   demux ether type.  We're not a real protocol, we'll never receive
- *   any packets because they're intercepted by ether_demux before 
- *   our input routine would be called.
+ *   demux ether type.

  *
  *

- *   The reasons for attaching a protocol to the interface are:
- *   1) add a protocol reference to the interface so that the underlying
- *      interface automatically gets marked up while we're attached
- *   2) receive link status events which we can propagate to our
- *      VLAN interfaces.
+ *      The ethernet demux actually special cases VLAN to support hardware.
+ *      The demux here isn't used. The demux will return PF_VLAN for the
+ *      appropriate packets and our vlan_input function will be called.

  */
 static int
 vlan_attach_protocol(struct ifnet *ifp)
 {
  */
 static int
 vlan_attach_protocol(struct ifnet *ifp)
 {

-    struct dlil_demux_desc      desc;
-    u_long                     dl_tag;
-    u_short                    en_native = ETHERTYPE_VLAN;
-    int                        error;
-    int                        i;
-    struct dlil_proto_reg_str   reg;
-
-    TAILQ_INIT(&reg.demux_desc_head);
-    desc.type = DLIL_DESC_RAW;
-    desc.variants.bitmask.proto_id_length = 0;
-    desc.variants.bitmask.proto_id = 0;
-    desc.variants.bitmask.proto_id_mask = 0;
-    desc.native_type = (char *) &en_native;
-    TAILQ_INSERT_TAIL(&reg.demux_desc_head, &desc, next);
-    reg.interface_family = ifp->if_family;
-    reg.unit_number      = ifp->if_unit;
-    reg.input            = vlan_proto_input;
-    reg.pre_output       = 0;
-    reg.event            = vlan_dl_event;
-    reg.offer            = 0;
-    reg.ioctl            = 0;
-    reg.default_proto    = 0;
-    reg.protocol_family  = VLAN_PROTO_FAMILY;
-
-    error = dlil_attach_protocol(&reg, &dl_tag);
+    int                                                                error;
+    struct ifnet_attach_proto_param    reg;
+       
+    bzero(&reg, sizeof(reg));
+    reg.input            = vlan_input;
+    reg.event            = vlan_event;
+    reg.detached         = vlan_detached;
+    error = ifnet_attach_protocol(ifp, PF_VLAN, &reg);

     if (error) {
     if (error) {

-       printf("vlan_proto_attach(%s%d) dlil_attach_protocol failed, %d\n",
-              ifp->if_name, ifp->if_unit, error);
+       printf("vlan_proto_attach(%s%d) ifnet_attach_protocol failed, %d\n",
+              ifnet_name(ifp), ifnet_unit(ifp), error);

     }
     return (error);
 }
     }
     return (error);
 }


@@ -1407,148 +2095,102 @@ vlan_attach_protocol(struct ifnet *ifp)
 static int
 vlan_detach_protocol(struct ifnet *ifp)
 {
 static int
 vlan_detach_protocol(struct ifnet *ifp)
 {

-    u_long     dl_tag;

     int         error;
 
     int         error;
 

-    error = dlil_find_dltag(ifp->if_family, ifp->if_unit, 
-                           VLAN_PROTO_FAMILY, &dl_tag);
+    error = ifnet_detach_protocol(ifp, PF_VLAN);

     if (error) {
     if (error) {

-       printf("vlan_proto_detach(%s%d) dlil_find_dltag failed, %d\n",
-              ifp->if_name, ifp->if_unit, error);
-    } else {
-        error = dlil_detach_protocol(dl_tag);
-       if (error) {
-           printf("vlan_proto_detach(%s%d) dlil_detach_protocol failed, %d\n",
-                  ifp->if_name, ifp->if_unit, error);
-       }
+       printf("vlan_proto_detach(%s%d) ifnet_detach_protocol failed, %d\n",
+              ifnet_name(ifp), ifnet_unit(ifp), error);

     }
     }

+       

     return (error);
 }
 
 /*
  * DLIL interface family functions
     return (error);
 }
 
 /*
  * DLIL interface family functions

- *   We use the ethernet dlil functions, since that's all we support.
+ *   We use the ethernet plumb functions, since that's all we support.

  *   If we wanted to handle multiple LAN types (tokenring, etc.), we'd
  *   call the appropriate routines for that LAN type instead of hard-coding
  *   ethernet.
  */
  *   If we wanted to handle multiple LAN types (tokenring, etc.), we'd
  *   call the appropriate routines for that LAN type instead of hard-coding
  *   ethernet.
  */

-extern int ether_add_if(struct ifnet *ifp);
-extern int ether_del_if(struct ifnet *ifp);
-extern int ether_init_if(struct ifnet *ifp);
-extern int ether_add_proto(struct ddesc_head_str *desc_head, 
-                          struct if_proto *proto, u_long dl_tag);
-extern int ether_del_proto(struct if_proto *proto, u_long dl_tag);
-extern int ether_ifmod_ioctl(struct ifnet *ifp, u_long command,
-                            caddr_t data);
-extern int ether_del_proto(struct if_proto *proto, u_long dl_tag);
-extern int ether_add_proto(struct ddesc_head_str *desc_head, struct if_proto *proto, u_long dl_tag);
-
-extern int ether_attach_inet(struct ifnet *ifp, u_long *dl_tag);
-extern int ether_detach_inet(struct ifnet *ifp, u_long dl_tag);
-extern int ether_attach_inet6(struct ifnet *ifp, u_long *dl_tag);
-extern int ether_detach_inet6(struct ifnet *ifp, u_long dl_tag);
-
-static int
-vlan_attach_inet(struct ifnet *ifp, u_long *dl_tag)
-{
-    return (ether_attach_inet(ifp, dl_tag));
-}
-
-static int
-vlan_detach_inet(struct ifnet *ifp, u_long dl_tag)
-{
-    return (ether_detach_inet(ifp, dl_tag));
-}
-
-static int
-vlan_attach_inet6(struct ifnet *ifp, u_long *dl_tag)
+static errno_t
+vlan_attach_inet(struct ifnet *ifp, protocol_family_t protocol_family)

 {
 {

-    return (ether_attach_inet6(ifp, dl_tag));
+    return (ether_attach_inet(ifp, protocol_family));

 }
 
 }
 

-static int
-vlan_detach_inet6(struct ifnet *ifp, u_long dl_tag)
+static void
+vlan_detach_inet(struct ifnet *ifp, protocol_family_t protocol_family)

 {
 {

-    return (ether_detach_inet6(ifp, dl_tag));
+    ether_detach_inet(ifp, protocol_family);

 }
 
 }
 

-static int
-vlan_add_if(struct ifnet *ifp)
+#if INET6
+static errno_t
+vlan_attach_inet6(struct ifnet *ifp, protocol_family_t protocol_family)

 {
 {

-    return (ether_add_if(ifp));
+    return (ether_attach_inet6(ifp, protocol_family));

 }
 
 }
 

-static int
-vlan_del_if(struct ifnet *ifp)
+static void
+vlan_detach_inet6(struct ifnet *ifp, protocol_family_t protocol_family)

 {
 {

-    return (ether_del_if(ifp));
+    ether_detach_inet6(ifp, protocol_family);

 }
 }

+#endif /* INET6 */

 
 

-static int
-vlan_init_if(struct ifnet *ifp)
+#if NETAT
+static errno_t
+vlan_attach_at(struct ifnet *ifp, protocol_family_t protocol_family)

 {
 {

-    return (0);
+    return (ether_attach_at(ifp, protocol_family));

 }
 
 }
 

-static int
-vlan_shutdown()
+static void
+vlan_detach_at(struct ifnet *ifp, protocol_family_t protocol_family)

 {
 {

-    return 0;
+    ether_detach_at(ifp, protocol_family);

 }
 }

+#endif /* NETAT */

 
 __private_extern__ int
 
 __private_extern__ int

-vlan_family_init()
+vlan_family_init(void)

 {
 {

-    int  i, error=0;
-    struct dlil_ifmod_reg_str  ifmod_reg;
-    struct dlil_protomod_reg_str vlan_protoreg;
+    int error=0;

 
 

-#if 0
-    /* VLAN family is built-in, called from ether_family_init */
-    thread_funnel_switch(KERNEL_FUNNEL, NETWORK_FUNNEL);
-#endif 0
-
-    bzero(&ifmod_reg, sizeof(ifmod_reg));
-    ifmod_reg.add_if = vlan_add_if;
-    ifmod_reg.del_if = vlan_del_if;
-    ifmod_reg.init_if = vlan_init_if;
-    ifmod_reg.add_proto = ether_add_proto;
-    ifmod_reg.del_proto = ether_del_proto;
-    ifmod_reg.ifmod_ioctl = ether_ifmod_ioctl;
-    ifmod_reg.shutdown    = vlan_shutdown;
-
-    if (dlil_reg_if_modules(APPLE_IF_FAM_VLAN, &ifmod_reg)) {
-       printf("WARNING: vlan_family_init -- "
-              "Can't register if family modules\n");
-       error = EIO;
+    error = proto_register_plumber(PF_INET, IFNET_FAMILY_VLAN, 
+                                  vlan_attach_inet, vlan_detach_inet);
+    if (error != 0) {
+       printf("proto_register_plumber failed for AF_INET error=%d\n",
+              error);

        goto done;
     }
        goto done;
     }

-
-    /* Register protocol registration functions */
-    bzero(&vlan_protoreg, sizeof(vlan_protoreg));
-    vlan_protoreg.attach_proto = vlan_attach_inet;
-    vlan_protoreg.detach_proto = vlan_detach_inet;
-       
-    if (error = dlil_reg_proto_module(PF_INET, APPLE_IF_FAM_VLAN, 
-                                     &vlan_protoreg) != 0) {
-       kprintf("dlil_reg_proto_module failed for AF_INET6 error=%d\n",
-               error);
+#if INET6
+    error = proto_register_plumber(PF_INET6, IFNET_FAMILY_VLAN, 
+                                  vlan_attach_inet6, vlan_detach_inet6);
+    if (error != 0) {
+       printf("proto_register_plumber failed for AF_INET6 error=%d\n",
+              error);

        goto done;
     }
        goto done;
     }

-    vlan_protoreg.attach_proto = vlan_attach_inet6;
-    vlan_protoreg.detach_proto = vlan_detach_inet6;
-       
-    if (error = dlil_reg_proto_module(PF_INET6, APPLE_IF_FAM_VLAN, 
-                                     &vlan_protoreg) != 0) {
-       kprintf("dlil_reg_proto_module failed for AF_INET6 error=%d\n",
-               error);
+#endif
+#if NETAT
+    error = proto_register_plumber(PF_APPLETALK, IFNET_FAMILY_VLAN, 
+                                 vlan_attach_at, vlan_detach_at);
+    if (error != 0) {
+       printf("proto_register_plumber failed for AF_APPLETALK error=%d\n",
+              error);

        goto done;
     }
        goto done;
     }

-    vlan_clone_attach();
+#endif /* NETAT */
+    error = vlan_clone_attach();
+    if (error != 0) {
+        printf("proto_register_plumber failed vlan_clone_attach error=%d\n",
+               error);
+        goto done;
+    }
+

 
  done:
 
  done:

-#if 0
-    thread_funnel_switch(NETWORK_FUNNEL, KERNEL_FUNNEL);
-#endif 0

     return (error);
 }
     return (error);
 }