/*
- * Copyright (c) 2003-2006 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003-2016 Apple Inc. All rights reserved.
*
* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
#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/multicast_list.h>
#include <net/ether_if_module.h>
-#define IF_MAXUNIT 0x7fff /* historical value */
-
#define VLANNAME "vlan"
typedef int (bpf_callback_func)(struct ifnet *, struct mbuf *);
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 {
- LIST_ENTRY(vlan_parent) vlp_parent_list;/* list of parents */
+ 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
+#define VLPF_SUPPORTS_VLAN_MTU 0x00000001
+#define VLPF_CHANGE_IN_PROGRESS 0x00000002
+#define VLPF_DETACHING 0x00000004
+#define VLPF_LINK_EVENT_REQUIRED 0x00000008
u_int32_t vlp_flags;
+ u_int32_t vlp_event_code;
struct ifdevmtu vlp_devmtu;
- SInt32 vlp_retain_count;
+ int32_t vlp_retain_count;
+ u_int32_t vlp_signature; /* VLP_SIGNATURE */
} vlan_parent, * vlan_parent_ref;
+#define IFV_SIGNATURE 0xbeefbeef
struct ifvlan {
- LIST_ENTRY(ifvlan) ifv_vlan_list;
+ 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 */
u_int32_t ifv_flags;
bpf_packet_func ifv_bpf_input;
bpf_packet_func ifv_bpf_output;
+ int32_t ifv_retain_count;
+ u_int32_t ifv_signature; /* IFV_SIGNATURE */
};
typedef struct ifvlan * ifvlan_ref;
#define ifv_encaplen ifv_mib.ifvm_encaplen
#define ifv_mtufudge ifv_mib.ifvm_mtufudge
+static void
+vlan_parent_retain(vlan_parent_ref vlp);
+
+static void
+vlan_parent_release(vlan_parent_ref vlp);
/**
** vlan_parent_ref vlp_flags in-lines
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;
}
+static __inline__ int
+vlan_parent_flags_link_event_required(vlan_parent_ref vlp)
+{
+ return ((vlp->vlp_flags & VLPF_LINK_EVENT_REQUIRED) != 0);
+}
+
+static __inline__ void
+vlan_parent_flags_set_link_event_required(vlan_parent_ref vlp)
+{
+ vlp->vlp_flags |= VLPF_LINK_EVENT_REQUIRED;
+ return;
+}
+
+static __inline__ void
+vlan_parent_flags_clear_link_event_required(vlan_parent_ref vlp)
+{
+ vlp->vlp_flags &= ~VLPF_LINK_EVENT_REQUIRED;
+ return;
+}
+
/**
** ifvlan_flags in-lines routines
return;
}
-static __inline__ void
-ifvlan_flags_clear_ready(ifvlan_ref ifv)
-{
- ifv->ifv_flags &= ~IFVF_READY;
- return;
-}
-
static __inline__ int
ifvlan_flags_detaching(ifvlan_ref ifv)
{
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 0
+#endif
#define M_VLAN M_DEVBUF
-static int vlan_clone_create(struct if_clone *, int);
-static void vlan_clone_destroy(struct ifnet *);
+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_ioctl(ifnet_t ifp, u_int32_t cmd, void * addr);
+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_setmulti(struct ifnet *ifp);
-static int vlan_unconfig(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 void vlan_remove(ifvlan_ref ifv);
-static void vlan_if_detach(struct ifnet * ifp);
-static int vlan_new_mtu(struct ifnet * ifp, int mtu);
+static int vlan_remove(ifvlan_ref ifv, int need_to_wait);
static struct if_clone vlan_cloner = IF_CLONE_INITIALIZER(VLANNAME,
vlan_clone_create,
vlan_clone_destroy,
0,
IF_MAXUNIT);
-static void interface_link_event(struct ifnet * ifp, u_long event_code);
-static void vlan_parent_link_event(vlan_parent_ref vlp,
- u_long event_code);
-extern void dlil_input_packet_list(struct ifnet *ifp, struct mbuf *m);
+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)
+{
+ u_int32_t 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 (vlp == NULL || 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_parent synchronization routines
**/
-static __inline__ void
+static void
vlan_parent_retain(vlan_parent_ref vlp)
{
+ if (vlp->vlp_signature != VLP_SIGNATURE) {
+ panic("vlan_parent_retain: signature is bad\n");
+ }
+ if (vlp->vlp_retain_count == 0) {
+ panic("vlan_parent_retain: retain count is 0\n");
+ }
OSIncrementAtomic(&vlp->vlp_retain_count);
}
-static __inline__ void
+static void
vlan_parent_release(vlan_parent_ref vlp)
{
- UInt32 old_retain_count;
+ u_int32_t 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:
printf("vlan_parent_release(%s%d)\n", ifnet_name(ifp),
ifnet_unit(ifp));
}
+ vlp->vlp_signature = 0;
FREE(vlp, M_VLAN);
break;
default:
static void
vlan_parent_signal(vlan_parent_ref vlp, const char * msg)
{
+ struct ifnet * vlp_ifp = vlp->vlp_ifp;
+
+ if (vlan_parent_flags_link_event_required(vlp)) {
+ vlan_parent_flags_clear_link_event_required(vlp);
+ if (!vlan_parent_flags_detaching(vlp)) {
+ u_int32_t event_code = vlp->vlp_event_code;
+ ifvlan_ref ifv;
+
+ vlan_unlock();
+
+ /* we can safely walk the list unlocked */
+ LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) {
+ struct ifnet * ifp = ifv->ifv_ifp;
+
+ interface_link_event(ifp, event_code);
+ }
+ if (g_vlan->verbose) {
+ printf("%s%d: propagated link event to vlans\n",
+ ifnet_name(vlp_ifp), ifnet_unit(vlp_ifp));
+ }
+ vlan_lock();
+ }
+ }
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);
+ printf("%s%d: %s wakeup\n",
+ ifnet_name(vlp_ifp), ifnet_unit(vlp_ifp), msg);
}
return;
}
-
/*
* Program our multicast filter. What we're actually doing is
* programming the multicast filter of the parent. This has the
int error = 0;
ifvlan_ref ifv;
struct ifnet * p;
- vlan_parent_ref vlp;
+ vlan_parent_ref vlp = NULL;
vlan_lock();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+ ifv = ifnet_get_ifvlan_retained(ifp);
+ if (ifv == NULL) {
goto unlock_done;
}
- vlp = ifv->ifv_vlp;
+ vlp = ifvlan_get_vlan_parent_retained(ifv);
if (vlp == NULL) {
/* no parent, no need to program the multicast filter */
goto unlock_done;
}
- if (vlan_parent_flags_detaching(vlp)) {
- goto unlock_done;
- }
- vlan_parent_retain(vlp);
vlan_parent_wait(vlp, "vlan_setmulti");
/* check again, things could have changed */
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
- goto signal_done;
- }
- if (ifv->ifv_vlp != vlp) {
- /* vlan parent changed */
- goto signal_done;
- }
- if (vlp == NULL) {
- /* no parent, no need to program the multicast filter */
+ if (ifnet_ifvlan_vlan_parent_ok(ifp, ifv, vlp) == FALSE) {
goto signal_done;
}
p = vlp->vlp_ifp;
unlock_done:
vlan_unlock();
+ if (ifv != NULL) {
+ ifvlan_release(ifv);
+ }
+ if (vlp != NULL) {
+ vlan_parent_release(vlp);
+ }
return (error);
}
vlan_parent_ref vlp;
*ret_vlp = NULL;
- vlp = _MALLOC(sizeof(*vlp), M_VLAN, M_WAITOK);
+ vlp = _MALLOC(sizeof(*vlp), M_VLAN, M_WAITOK | M_ZERO);
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",
}
LIST_INIT(&vlp->vlp_vlan_list);
vlp->vlp_ifp = p;
- vlan_parent_retain(vlp);
+ 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);
}
static void
-vlan_parent_remove_all_vlans(vlan_parent_ref vlp)
+vlan_parent_remove_all_vlans(struct ifnet * p)
{
ifvlan_ref ifv;
- struct ifnet * p;
-
- vlan_assert_lock_held();
+ int need_vlp_release = 0;
+ ifvlan_ref next;
+ vlan_parent_ref vlp;
- while ((ifv = LIST_FIRST(&vlp->vlp_vlan_list)) != NULL) {
- vlan_remove(ifv);
+ vlan_lock();
+ vlp = parent_list_lookup(p);
+ if (vlp == NULL || vlan_parent_flags_detaching(vlp)) {
+ /* no VLAN's */
vlan_unlock();
- vlan_if_detach(ifv->ifv_ifp);
- vlan_lock();
+ return;
+ }
+ vlan_parent_flags_set_detaching(vlp);
+ vlan_parent_retain(vlp);
+ vlan_parent_wait(vlp, "vlan_parent_remove_all_vlans");
+ need_vlp_release++;
+
+ /* check again */
+ if (parent_list_lookup(p) != vlp) {
+ goto signal_done;
+ }
+
+ for (ifv = LIST_FIRST(&vlp->vlp_vlan_list); ifv != NULL; ifv = next) {
+ struct ifnet * ifp = ifv->ifv_ifp;
+ int removed;
+
+ next = LIST_NEXT(ifv, ifv_vlan_list);
+ removed = vlan_remove(ifv, FALSE);
+ if (removed) {
+ vlan_unlock();
+ ifnet_detach(ifp);
+ vlan_lock();
+ }
}
/* the vlan parent has no more VLAN's */
- p = vlp->vlp_ifp;
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();
- vlan_parent_release(vlp);
- vlan_lock();
+ while (need_vlp_release--) {
+ vlan_parent_release(vlp);
+ }
return;
}
return;
}
-static void
+static int
vlan_clone_attach(void)
{
- if_clone_attach(&vlan_cloner);
+ int error;
+
+ error = if_clone_attach(&vlan_cloner);
+ if (error != 0)
+ return error;
vlan_lock_init();
- return;
+ return 0;
}
static int
-vlan_clone_create(struct if_clone *ifc, int unit)
+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;
+ struct ifnet_init_eparams vlan_init;
error = vlan_globals_init();
if (error != 0) {
return (error);
}
- ifv = _MALLOC(sizeof(struct ifvlan), M_VLAN, M_WAITOK);
- bzero(ifv, sizeof(struct ifvlan));
+ ifv = _MALLOC(sizeof(struct ifvlan), M_VLAN, M_WAITOK | M_ZERO);
+ if (ifv == NULL)
+ return ENOBUFS;
+ 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)) {
- FREE(ifv, M_VLAN);
- return (EINVAL);
+ 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.ver = IFNET_INIT_CURRENT_VERSION;
+ vlan_init.len = sizeof (vlan_init);
+ vlan_init.flags = IFNET_INIT_LEGACY;
vlan_init.uniqueid = ifv->ifv_name;
vlan_init.uniqueid_len = strlen(ifv->ifv_name);
vlan_init.name = ifc->ifc_name;
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.framer_extended = ether_frameout_extended;
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);
+ error = ifnet_allocate_extended(&vlan_init, &ifp);
if (error) {
- FREE(ifv, M_VLAN);
- return (error);
+ ifvlan_release(ifv);
+ return (error);
}
-#if 0
- /* NB: flags are not set here */
- ifnet_set_link_mib_data(ifp, &ifv->ifv_mib, sizeof ifv->ifv_mib);
- /* NB: mtu is not set here */
-#endif 0
-
ifnet_set_offload(ifp, 0);
ifnet_set_addrlen(ifp, ETHER_ADDR_LEN); /* XXX ethernet specific */
ifnet_set_baudrate(ifp, 0);
error = ifnet_attach(ifp, NULL);
if (error) {
- ifnet_release(ifp);
- FREE(ifv, M_VLAN);
- return (error);
+ ifnet_release(ifp);
+ ifvlan_release(ifv);
+ return (error);
}
ifv->ifv_ifp = ifp;
return (0);
}
-static void
-vlan_remove(ifvlan_ref ifv)
+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->ifv_ifp);
- return;
+ vlan_unconfig(ifv, need_to_wait);
+ return (1);
}
-static void
-vlan_if_detach(struct ifnet * ifp)
-{
- ifnet_detach(ifp);
- return;
-}
-static void
+static int
vlan_clone_destroy(struct ifnet *ifp)
{
ifvlan_ref ifv;
vlan_lock();
- ifv = ifnet_softc(ifp);
- if (ifv == NULL || ifnet_type(ifp) != IFT_L2VLAN) {
+ ifv = ifnet_get_ifvlan_retained(ifp);
+ if (ifv == NULL) {
vlan_unlock();
- return;
+ return 0;
}
- if (ifvlan_flags_detaching(ifv)) {
+ if (vlan_remove(ifv, TRUE) == 0) {
vlan_unlock();
- return;
+ ifvlan_release(ifv);
+ return 0;
}
- vlan_remove(ifv);
vlan_unlock();
- vlan_if_detach(ifp);
- return;
+ ifvlan_release(ifv);
+ ifnet_detach(ifp);
+
+ return 0;
}
static int
ifvlan_ref ifv;
vlan_lock();
- ifv = ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+ ifv = ifnet_get_ifvlan_retained(ifp);
+ if (ifv == NULL) {
vlan_unlock();
return (ENODEV);
}
break;
}
vlan_unlock();
+ ifvlan_release(ifv);
return 0;
}
struct ifnet * p;
int soft_vlan;
u_short tag;
- vlan_parent_ref vlp;
+ vlan_parent_ref vlp = NULL;
+ int err;
+ struct flowadv adv = { FADV_SUCCESS };
if (m == 0) {
return (0);
return (0);
}
vlan_lock();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)
- || ifvlan_flags_ready(ifv) == 0) {
- vlan_unlock();
- m_freem_list(m);
- return (0);
+ ifv = ifnet_get_ifvlan_retained(ifp);
+ if (ifv == NULL || ifvlan_flags_ready(ifv) == 0) {
+ goto unlock_done;
}
- vlp = ifv->ifv_vlp;
+ vlp = ifvlan_get_vlan_parent_retained(ifv);
if (vlp == NULL) {
- vlan_unlock();
- m_freem_list(m);
- return (0);
+ goto unlock_done;
}
p = vlp->vlp_ifp;
(void)ifnet_stat_increment_out(ifp, 1, m->m_pkthdr.len, 0);
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 */
if ((ifnet_flags(p) & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING)) {
m_freem(m);
- ifp->if_collisions++;
+ atomic_add_64(&ifp->if_collisions, 1);
return (0);
}
/*
m->m_pkthdr.csum_flags |= CSUM_VLAN_TAG_VALID;
m->m_pkthdr.vlan_tag = tag;
} else {
- M_PREPEND(m, encaplen, M_DONTWAIT);
+ M_PREPEND(m, encaplen, M_DONTWAIT, 1);
if (m == NULL) {
printf("%s%d: unable to prepend VLAN header\n", ifnet_name(ifp),
ifnet_unit(ifp));
- ifp->if_oerrors++;
+ atomic_add_64(&ifp->if_oerrors, 1);
return (0);
}
/* M_PREPEND takes care of m_len, m_pkthdr.len for us */
if (m == NULL) {
printf("%s%d: unable to pullup VLAN header\n", ifnet_name(ifp),
ifnet_unit(ifp));
- ifp->if_oerrors++;
+ atomic_add_64(&ifp->if_oerrors, 1);
return (0);
}
}
evl->evl_encap_proto = htons(ETHERTYPE_VLAN);
evl->evl_tag = htons(tag);
}
- return ifnet_output_raw(p, PF_VLAN, m);
+
+ err = dlil_output(p, PF_VLAN, m, NULL, NULL, 1, &adv);
+
+ if (err == 0) {
+ if (adv.code == FADV_FLOW_CONTROLLED) {
+ err = EQFULL;
+ } else if (adv.code == FADV_SUSPENDED) {
+ err = EQSUSPENDED;
+ }
+ }
+
+ return (err);
+
+ unlock_done:
+ vlan_unlock();
+ if (ifv != NULL) {
+ ifvlan_release(ifv);
+ }
+ if (vlp != NULL) {
+ vlan_parent_release(vlp);
+ }
+ m_freem_list(m);
+ return (0);
+
}
static int
m_freem(m);
return 0;
}
- evl = (struct ether_vlan_header *)frame_header;
+ evl = (struct ether_vlan_header *)(void *)frame_header;
if (ntohs(evl->evl_proto) == ETHERTYPE_VLAN) {
/* don't allow VLAN within VLAN */
m_freem(m);
ifnet_type(p));
m_freem(m);
return 0;
- break;
}
}
if (tag != 0) {
}
if (tag != 0) {
m->m_pkthdr.rcvif = ifp;
- m->m_pkthdr.header = frame_header;
+ m->m_pkthdr.pkt_hdr = 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,
/* We found a vlan interface, inject on that interface. */
dlil_input_packet_list(ifp, m);
} else {
+ m->m_pkthdr.pkt_hdr = frame_header;
/* Send priority-tagged packet up through the parent */
dlil_input_packet_list(p, m);
}
return 0;
}
-#define VLAN_CONFIG_PROGRESS_VLP_RETAINED 0x1
-#define VLAN_CONFIG_PROGRESS_IN_LIST 0x2
-
static int
vlan_config(struct ifnet * ifp, struct ifnet * p, int tag)
{
int error;
- int first_vlan = 0;
+ int first_vlan = FALSE;
ifvlan_ref ifv = NULL;
- vlan_parent_ref new_vlp = 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;
- u_int32_t progress = 0;
vlan_parent_ref vlp = NULL;
/* pre-allocate space for vlan_parent, in case we're first */
}
vlan_lock();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv != NULL && ifv->ifv_vlp != NULL) {
+ 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);
}
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;
}
}
else {
+ /* one for being in the list */
+ vlan_parent_retain(new_vlp);
+
/* 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++;
}
/* need to wait to ensure no one else is trying to add/remove */
- vlan_parent_retain(vlp);
- progress |= VLAN_CONFIG_PROGRESS_VLP_RETAINED;
vlan_parent_wait(vlp, "vlan_config");
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL) {
- error = EOPNOTSUPP;
+ 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 in */
+ /* 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;
}
if (vlan_parent_no_vlans(vlp)) {
- first_vlan = 1;
+ first_vlan = TRUE;
}
vlan_parent_add_vlan(vlp, ifv, tag);
- progress |= VLAN_CONFIG_PROGRESS_IN_LIST;
+ ifvlan_retain(ifv); /* parent references ifv */
+ ifv_added = TRUE;
/* check whether bond interface is using parent interface */
ifnet_lock_exclusive(p);
vlan_lock();
goto signal_done;
}
- /* mark the parent interface up */
- ifnet_set_flags(p, IFF_UP, IFF_UP);
- (void)ifnet_ioctl(p, 0, SIOCSIFFLAGS, (caddr_t)NULL);
}
/* configure parent to receive our multicast addresses */
}
/* set our ethernet address to that of the parent */
- ifnet_set_lladdr_and_type(ifp, ifnet_lladdr(p), ETHER_ADDR_LEN, IFT_ETHER);
+ ifnet_set_lladdr_and_type(ifp, IF_LLADDR(p), ETHER_ADDR_LEN, IFT_ETHER);
/* no failures past this point */
vlan_lock();
ifnet_set_flags(ifp, parent_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 (ifnet_offload(p) & IF_HWASSIST_VLAN_TAGGING) {
- ifnet_set_offload(ifp, IF_HWASSIST_CSUM_FLAGS(ifnet_offload(p)));
- }
+ /* 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);
/* throw it away, it wasn't needed */
vlan_parent_release(new_vlp);
}
+ if (ifv != NULL) {
+ ifvlan_release(ifv);
+ }
+ if (first_vlan) {
+ /* mark the parent interface up */
+ ifnet_set_flags(p, IFF_UP, IFF_UP);
+ (void)ifnet_ioctl(p, 0, SIOCSIFFLAGS, (caddr_t)NULL);
+ }
return 0;
signal_done:
vlan_assert_lock_held();
- vlan_parent_signal(vlp, "vlan_config");
- unlock_done:
- if ((progress & VLAN_CONFIG_PROGRESS_IN_LIST) != 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++;
+ }
}
- 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 = 1;
- }
+ vlan_parent_signal(vlp, "vlan_config");
+
+ unlock_done:
vlan_unlock();
- if ((progress & VLAN_CONFIG_PROGRESS_VLP_RETAINED) != 0) {
- vlan_parent_release(vlp);
- }
- if (need_vlp_release) {
+ 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);
}
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
+ if (ifnet_ioctl(p, 0, SIOCGIFMEDIA, &ifmr) == 0
&& ifmr.ifm_count > 0 && ifmr.ifm_status & IFM_AVALID) {
- u_long event;
+ u_int32_t event;
event = (ifmr.ifm_status & IFM_ACTIVE)
? KEV_DL_LINK_ON : KEV_DL_LINK_OFF;
}
static int
-vlan_unconfig(struct ifnet * ifp)
+vlan_unconfig(ifvlan_ref ifv, int need_to_wait)
{
- int error = 0;
- ifvlan_ref ifv;
- int last_vlan = 0;
+ 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();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL) {
- return (0);
- }
vlp = ifv->ifv_vlp;
if (vlp == NULL) {
return (0);
}
- vlan_parent_retain(vlp);
- vlan_parent_wait(vlp, "vlan_unconfig");
+ 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 */
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL) {
- goto signal_done;
- }
- if (ifv->ifv_vlp != vlp) {
- /* vlan parent changed */
- goto signal_done;
+ /* 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;
printf("vlan_unconfig: last vlan on %s%d\n",
ifnet_name(p), ifnet_unit(p));
}
- last_vlan = 1;
+ last_vlan = TRUE;
}
/* back-out any effect our mtu might have had on the parent */
- (void)vlan_new_mtu(ifp, ETHERMTU - ifv->ifv_mtufudge);
+ (void)ifvlan_new_mtu(ifv, ETHERMTU - ifv->ifv_mtufudge);
vlan_unlock();
- /* detach VLAN "protocol" */
- if (last_vlan) {
- (void)vlan_detach_protocol(p);
- }
-
/* 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);
- vlan_lock();
+ /* detach VLAN "protocol" */
+ if (last_vlan) {
+ (void)vlan_detach_protocol(p);
+ }
- /* Disconnect from parent. */
- vlan_parent_remove_vlan(vlp, ifv);
+ 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_flags = 0;
ifv->ifv_mtufudge = 0;
- if (!vlan_parent_flags_detaching(vlp) && vlan_parent_no_vlans(vlp)) {
+ /* 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:
- vlan_parent_signal(vlp, "vlan_unconfig");
+ if (need_to_wait) {
+ vlan_parent_signal(vlp, "vlan_unconfig");
+ }
vlan_unlock();
- vlan_parent_release(vlp); /* one because we waited */
-
- while (need_vlp_release--) {
+ while (need_ifv_release--) {
+ ifvlan_release(ifv);
+ }
+ while (need_vlp_release--) { /* references to vlp */
vlan_parent_release(vlp);
}
vlan_lock();
- return (error);
+ return (0);
}
static int
vlan_parent_ref vlp;
vlan_lock();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
- error = (ifv == NULL) ? EOPNOTSUPP : EBUSY;
+ ifv = ifnet_get_ifvlan_retained(ifp);
+ if (ifv == NULL) {
+ error = EBUSY;
goto done;
}
}
done:
vlan_unlock();
+ if (ifv != NULL) {
+ ifvlan_release(ifv);
+ }
return (error);
}
static int
-vlan_new_mtu(struct ifnet * ifp, int mtu)
+ifvlan_new_mtu(ifvlan_ref ifv, int mtu)
{
struct ifdevmtu * devmtu_p;
int error = 0;
- ifvlan_ref ifv;
+ struct ifnet * ifp = ifv->ifv_ifp;
int max_mtu;
int new_mtu = 0;
int req_mtu;
vlan_parent_ref vlp;
vlan_assert_lock_held();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
vlp = ifv->ifv_vlp;
devmtu_p = &vlp->vlp_devmtu;
req_mtu = mtu + ifv->ifv_mtufudge;
return (EINVAL);
}
vlan_lock();
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
+ ifv = ifnet_get_ifvlan_retained(ifp);
+ if (ifv == NULL) {
vlan_unlock();
- return ((ifv == NULL) ? EOPNOTSUPP : EBUSY);
+ return (EBUSY);
}
- vlp = ifv->ifv_vlp;
- if (vlp == NULL || vlan_parent_flags_detaching(vlp)) {
+ vlp = ifvlan_get_vlan_parent_retained(ifv);
+ if (vlp == NULL) {
vlan_unlock();
+ ifvlan_release(ifv);
if (mtu != 0) {
return (EINVAL);
}
return (0);
}
- vlan_parent_retain(vlp);
vlan_parent_wait(vlp, "vlan_set_mtu");
/* check again, something might have changed */
- ifv = (ifvlan_ref)ifnet_softc(ifp);
- if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
- error = (ifv == NULL) ? EOPNOTSUPP : EBUSY;
+ 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 (vlp == NULL || vlan_parent_flags_detaching(vlp)) {
+ if (vlan_parent_flags_detaching(vlp)) {
if (mtu != 0) {
error = EINVAL;
}
goto signal_done;
}
- error = vlan_new_mtu(ifp, mtu);
+ 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
-vlan_ioctl(ifnet_t ifp, u_int32_t cmd, void * data)
+vlan_ioctl(ifnet_t ifp, u_long cmd, void * data)
{
struct ifdevmtu * devmtu_p;
int error = 0;
struct ifaddr * ifa;
- struct ifmediareq64 * ifmr;
+ struct ifmediareq *ifmr;
struct ifreq * ifr;
ifvlan_ref ifv;
struct ifnet * p;
ifnet_set_flags(ifp, IFF_UP, IFF_UP);
break;
+ case SIOCGIFMEDIA32:
case SIOCGIFMEDIA64:
- case SIOCGIFMEDIA:
vlan_lock();
ifv = (ifvlan_ref)ifnet_softc(ifp);
if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
}
p = (ifv->ifv_vlp == NULL) ? NULL : ifv->ifv_vlp->vlp_ifp;
vlan_unlock();
- ifmr = (struct ifmediareq64 *)data;
- user_addr = proc_is64bit(current_proc())
- ? ifmr->ifm_ifmu.ifmu_ulist64
- : CAST_USER_ADDR_T(ifmr->ifm_ifmu.ifmu_ulist32);
+ 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 ifmediareq64 p_ifmr;
+ struct ifmediareq p_ifmr;
bzero(&p_ifmr, sizeof(p_ifmr));
error = ifnet_ioctl(p, 0, SIOCGIFMEDIA, &p_ifmr);
/* generate a link event based on the state of the parent */
vlan_link_event(ifp, p);
- } else {
+ }
+ else {
+ int need_link_event = FALSE;
+
vlan_lock();
ifv = (ifvlan_ref)ifnet_softc(ifp);
if (ifv == NULL || ifvlan_flags_detaching(ifv)) {
error = (ifv == NULL ? EOPNOTSUPP : EBUSY);
break;
}
- error = vlan_unconfig(ifp);
+ need_link_event = vlan_remove(ifv, TRUE);
vlan_unlock();
- if (error == 0) {
+ if (need_link_event) {
interface_link_event(ifp, KEV_DL_LINK_OFF);
}
}
if (ifp == NULL) {
return;
}
- vlan_lock();
ifv = (ifvlan_ref)ifnet_softc(ifp);
if (ifv == NULL) {
- vlan_unlock();
return;
}
- vlan_unlock();
+ ifvlan_release(ifv);
ifnet_release(ifp);
- FREE(ifv, M_VLAN);
+ return;
}
static void
vlan_event(struct ifnet * p, __unused protocol_family_t protocol,
const struct kev_msg * event)
{
- vlan_parent_ref vlp;
+ int event_code;
/* Check if the interface we are attached to is being detached */
if (event->vendor_code != KEV_VENDOR_APPLE
|| event->kev_subclass != KEV_DL_SUBCLASS) {
return;
}
- switch (event->event_code) {
- case KEV_DL_IF_DETACHING:
+ 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;
}
- 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;
- }
- switch (event->event_code) {
- case KEV_DL_IF_DETACHING:
- vlan_parent_flags_set_detaching(vlp);
- vlan_parent_remove_all_vlans(vlp);
- break;
-
- case KEV_DL_LINK_OFF:
- case KEV_DL_LINK_ON:
- vlan_parent_link_event(vlp, event->event_code);
- break;
- default:
- break;
- }
- vlan_unlock();
return;
}
+static errno_t
+vlan_detached(ifnet_t p, __unused protocol_family_t protocol)
+{
+ if (ifnet_is_attached(p, 0) == 0) {
+ /* if the parent isn't attached, remove all VLANs */
+ vlan_parent_remove_all_vlans(p);
+ }
+ return (0);
+}
+
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;
- u_long unit;
+ u_int32_t unit;
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.event_data[0] = ifnet_family(ifp);
- event.unit = (u_long) ifnet_unit(ifp);
- strncpy(event.if_name, ifnet_name(ifp), IFNAMSIZ);
+ event.unit = (u_int32_t) ifnet_unit(ifp);
+ strlcpy(event.if_name, ifnet_name(ifp), IFNAMSIZ);
ifnet_event(ifp, &event.header);
return;
}
static void
-vlan_parent_link_event(vlan_parent_ref vlp, u_long event_code)
+vlan_parent_link_event(struct ifnet * p, u_int32_t event_code)
{
- ifvlan_ref ifv;
+ vlan_parent_ref vlp;
- LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) {
- 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;
+ }
+ vlan_parent_flags_set_link_event_required(vlp);
+ vlp->vlp_event_code = event_code;
+ if (vlan_parent_flags_change_in_progress(vlp)) {
+ /* don't block waiting to generate an event */
+ vlan_unlock();
+ return;
+ }
+ vlan_parent_retain(vlp);
+ vlan_parent_wait(vlp, "vlan_parent_link_event");
+ vlan_parent_signal(vlp, "vlan_parent_link_event");
+ vlan_unlock();
+ vlan_parent_release(vlp);
return;
}
bzero(®, sizeof(reg));
reg.input = vlan_input;
reg.event = vlan_event;
+ reg.detached = vlan_detached;
error = ifnet_attach_protocol(ifp, PF_VLAN, ®);
if (error) {
printf("vlan_proto_attach(%s%d) ifnet_attach_protocol failed, %d\n",
}
#endif /* INET6 */
-static errno_t
-vlan_attach_at(struct ifnet *ifp, protocol_family_t protocol_family)
-{
- return (ether_attach_at(ifp, protocol_family));
-}
-
-static void
-vlan_detach_at(struct ifnet *ifp, protocol_family_t protocol_family)
-{
- ether_detach_at(ifp, protocol_family);
-}
-
__private_extern__ int
vlan_family_init(void)
{
goto done;
}
#endif
- error = proto_register_plumber(PF_APPLETALK, IFNET_FAMILY_VLAN,
- vlan_attach_at, vlan_detach_at);
+ error = vlan_clone_attach();
if (error != 0) {
- printf("proto_register_plumber failed for AF_APPLETALK error=%d\n",
- error);
- goto done;
+ printf("proto_register_plumber failed vlan_clone_attach error=%d\n",
+ error);
+ goto done;
}
- vlan_clone_attach();
+
done:
return (error);
projects / apple / xnu.git / blobdiff