/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1999-2007 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_HEADER_START@
- *
- * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
*
* 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. Please obtain a copy of the License at
- * http://www.opensource.apple.com/apsl/ and read it before using this
- * file.
+ * 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.
+ *
+ * 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
* 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 (c) 1999 Apple Computer, Inc.
- *
* Data Link Inteface Layer
* Author: Ted Walker
*/
-
-
+/*
+ * NOTICE: This file was modified by SPARTA, Inc. in 2005 to introduce
+ * support for mandatory and extensible security protections. This notice
+ * is included in support of clause 2.2 (b) of the Apple Public License,
+ * Version 2.0.
+ */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
+#include <sys/domain.h>
+#include <sys/user.h>
+#include <sys/random.h>
#include <net/if_dl.h>
#include <net/if.h>
+#include <net/route.h>
#include <net/if_var.h>
#include <net/dlil.h>
+#include <net/if_arp.h>
#include <sys/kern_event.h>
#include <sys/kdebug.h>
-#include <string.h>
+#include <kern/assert.h>
#include <kern/task.h>
#include <kern/thread.h>
#include <kern/sched_prim.h>
+#include <kern/locks.h>
+#include <net/kpi_protocol.h>
-#include <net/netisr.h>
#include <net/if_types.h>
+#include <net/kpi_interfacefilter.h>
+
+#include <libkern/OSAtomic.h>
#include <machine/machine_routines.h>
-#define DBG_LAYER_BEG DLILDBG_CODE(DBG_DLIL_STATIC, 0)
-#define DBG_LAYER_END DLILDBG_CODE(DBG_DLIL_STATIC, 2)
+#include <mach/thread_act.h>
+
+#if CONFIG_MACF_NET
+#include <security/mac_framework.h>
+#endif /* MAC_NET */
+
+#define DBG_LAYER_BEG DLILDBG_CODE(DBG_DLIL_STATIC, 0)
+#define DBG_LAYER_END DLILDBG_CODE(DBG_DLIL_STATIC, 2)
#define DBG_FNC_DLIL_INPUT DLILDBG_CODE(DBG_DLIL_STATIC, (1 << 8))
#define DBG_FNC_DLIL_OUTPUT DLILDBG_CODE(DBG_DLIL_STATIC, (2 << 8))
#define DBG_FNC_DLIL_IFOUT DLILDBG_CODE(DBG_DLIL_STATIC, (3 << 8))
-#define MAX_DL_TAGS 16
-#define MAX_DLIL_FILTERS 16
#define MAX_FRAME_TYPE_SIZE 4 /* LONGWORDS */
#define MAX_LINKADDR 4 /* LONGWORDS */
#define M_NKE M_IFADDR
-#define PFILT(x) ((struct dlil_filterq_entry *) (x))->variants.pr_filter
-#define IFILT(x) ((struct dlil_filterq_entry *) (x))->variants.if_filter
+#if 1
+#define DLIL_PRINTF printf
+#else
+#define DLIL_PRINTF kprintf
+#endif
+
-struct dl_tag_str {
- struct ifnet *ifp;
- struct if_proto *proto;
- struct dlil_filterq_head *pr_flt_head;
+enum {
+ kProtoKPI_v1 = 1,
+ kProtoKPI_v2 = 2
};
+struct if_proto {
+ SLIST_ENTRY(if_proto) next_hash;
+ int refcount;
+ int detaching;
+ struct ifnet *ifp;
+ struct domain *dl_domain;
+ protocol_family_t protocol_family;
+ int proto_kpi;
+ union {
+ struct {
+ proto_media_input input;
+ proto_media_preout pre_output;
+ proto_media_event event;
+ proto_media_ioctl ioctl;
+ proto_media_detached detached;
+ proto_media_resolve_multi resolve_multi;
+ proto_media_send_arp send_arp;
+ } v1;
+ struct {
+ proto_media_input_v2 input;
+ proto_media_preout pre_output;
+ proto_media_event event;
+ proto_media_ioctl ioctl;
+ proto_media_detached detached;
+ proto_media_resolve_multi resolve_multi;
+ proto_media_send_arp send_arp;
+ } v2;
+ } kpi;
+};
+
+SLIST_HEAD(proto_hash_entry, if_proto);
+
struct dlil_ifnet {
/* ifnet and drvr_ext are used by the stack and drivers
drvr_ext extends the public ifnet and must follow dl_if */
struct ifnet dl_if; /* public ifnet */
- void *drvr_ext[4]; /* driver reserved (e.g arpcom extension for enet) */
/* dlil private fields */
TAILQ_ENTRY(dlil_ifnet) dl_if_link; /* dlil_ifnet are link together */
/* it is not the ifnet list */
void *if_uniqueid; /* unique id identifying the interface */
size_t if_uniqueid_len;/* length of the unique id */
- char if_namestorage[IFNAMSIZ]; /* interface name storage for detached interfaces */
-};
-
-struct dlil_stats_str {
- int inject_pr_in1;
- int inject_pr_in2;
- int inject_pr_out1;
- int inject_pr_out2;
- int inject_if_in1;
- int inject_if_in2;
- int inject_if_out1;
- int inject_if_out2;
+ char if_namestorage[IFNAMSIZ]; /* interface name storage */
};
-
-struct dlil_filter_id_str {
- int type;
- struct dlil_filterq_head *head;
- struct dlil_filterq_entry *filter_ptr;
- struct ifnet *ifp;
- struct if_proto *proto;
+struct ifnet_filter {
+ TAILQ_ENTRY(ifnet_filter) filt_next;
+ ifnet_t filt_ifp;
+ int filt_detaching;
+
+ const char *filt_name;
+ void *filt_cookie;
+ protocol_family_t filt_protocol;
+ iff_input_func filt_input;
+ iff_output_func filt_output;
+ iff_event_func filt_event;
+ iff_ioctl_func filt_ioctl;
+ iff_detached_func filt_detached;
};
+struct proto_input_entry;
+
+static TAILQ_HEAD(, dlil_ifnet) dlil_ifnet_head;
+static lck_grp_t *dlil_lock_group;
+static lck_grp_t *ifnet_lock_group;
+static lck_grp_t *ifnet_head_lock_group;
+static lck_attr_t *ifnet_lock_attr;
+static lck_rw_t *ifnet_head_mutex;
+static lck_mtx_t *dlil_ifnet_mutex;
+static lck_mtx_t *dlil_mutex;
+static unsigned long dlil_read_count = 0;
+static unsigned long dlil_detach_waiting = 0;
+extern u_int32_t ipv4_ll_arp_aware;
+
+static struct dlil_threading_info dlil_lo_thread;
+__private_extern__ struct dlil_threading_info *dlil_lo_thread_ptr = &dlil_lo_thread;
+
+static struct mbuf *dlil_lo_input_mbuf_head = NULL;
+static struct mbuf *dlil_lo_input_mbuf_tail = NULL;
+
+#if IFNET_INPUT_SANITY_CHK
+static int dlil_lo_input_mbuf_count = 0;
+int dlil_input_sanity_check = 0; /* sanity checking of input packet lists received */
+#endif
+int dlil_multithreaded_input = 1;
+static int cur_dlil_input_threads = 0;
+static int dlil_event_internal(struct ifnet *ifp, struct kev_msg *msg);
+static int dlil_detach_filter_internal(interface_filter_t filter, int detached);
+static void dlil_call_delayed_detach_thread(void);
-struct if_family_str {
- TAILQ_ENTRY(if_family_str) if_fam_next;
- u_long if_family;
- int refcnt;
- int flags;
+static void dlil_read_begin(void);
+static __inline__ void dlil_read_end(void);
+static int dlil_write_begin(void);
+static void dlil_write_end(void);
-#define DLIL_SHUTDOWN 1
+unsigned int net_affinity = 1;
+static kern_return_t dlil_affinity_set(struct thread *, u_int32_t);
- int (*add_if)(struct ifnet *ifp);
- int (*del_if)(struct ifnet *ifp);
- int (*init_if)(struct ifnet *ifp);
- int (*add_proto)(struct ddesc_head_str *demux_desc_head,
- struct if_proto *proto, u_long dl_tag);
- int (*del_proto)(struct if_proto *proto, u_long dl_tag);
- int (*ifmod_ioctl)(struct ifnet *ifp, u_long command, caddr_t data);
- int (*shutdown)();
-};
+extern void bpfdetach(struct ifnet*);
+extern void proto_input_run(void); // new run_netisr
+void dlil_input_packet_list(struct ifnet *ifp, struct mbuf *m);
+static void dlil_input_thread_func(struct dlil_threading_info *inpthread);
+__private_extern__ int dlil_create_input_thread(
+ ifnet_t, struct dlil_threading_info *);
+__private_extern__ void dlil_terminate_input_thread(
+ struct dlil_threading_info *);
+__private_extern__ void link_rtrequest(int, struct rtentry *, struct sockaddr *);
-struct dlil_stats_str dlil_stats;
+int dlil_expand_mcl;
-static
-struct dlil_filter_id_str *dlil_filters;
+extern u_int32_t inject_buckets;
-static
-struct dl_tag_str *dl_tag_array;
+static const u_int32_t dlil_writer_waiting = 0x80000000;
+static lck_grp_attr_t *dlil_grp_attributes = NULL;
+static lck_attr_t *dlil_lck_attributes = NULL;
+static lck_grp_t *dlil_input_lock_grp = NULL;
-static
-TAILQ_HEAD(, dlil_ifnet) dlil_ifnet_head;
+static inline void*
+_cast_non_const(const void * ptr) {
+ union {
+ const void* cval;
+ void* val;
+ } ret;
+
+ ret.cval = ptr;
+ return (ret.val);
+}
-static
-TAILQ_HEAD(, if_family_str) if_family_head;
+/* Should these be inline? */
+static void
+dlil_read_begin(void)
+{
+ unsigned long new_value;
+ unsigned long old_value;
+ struct uthread *uth = get_bsdthread_info(current_thread());
+
+ if (uth->dlil_incremented_read == dlil_writer_waiting)
+ panic("dlil_read_begin - thread is already a writer");
+
+ do {
+again:
+ old_value = dlil_read_count;
+
+ if ((old_value & dlil_writer_waiting) != 0 && uth->dlil_incremented_read == 0)
+ {
+ tsleep(&dlil_read_count, PRIBIO, "dlil_read_count", 1);
+ goto again;
+ }
+
+ new_value = old_value + 1;
+ } while (!OSCompareAndSwap((UInt32)old_value, (UInt32)new_value, (UInt32*)&dlil_read_count));
+
+ uth->dlil_incremented_read++;
+}
-static ifnet_inited = 0;
-static u_long dl_tag_nb = 0;
-static u_long dlil_filters_nb = 0;
+static void
+dlil_read_end(void)
+{
+ struct uthread *uth = get_bsdthread_info(current_thread());
+
+ OSDecrementAtomic((SInt32*)&dlil_read_count);
+ uth->dlil_incremented_read--;
+ if (dlil_read_count == dlil_writer_waiting)
+ wakeup(_cast_non_const(&dlil_writer_waiting));
+}
-int dlil_initialized = 0;
-decl_simple_lock_data(, dlil_input_lock)
-int dlil_input_thread_wakeup = 0;
-int dlil_expand_mcl;
-static struct mbuf *dlil_input_mbuf_head = NULL;
-static struct mbuf *dlil_input_mbuf_tail = NULL;
-#if NLOOP > 1
-#error dlil_input() needs to be revised to support more than on loopback interface
-#endif
-static struct mbuf *dlil_input_loop_head = NULL;
-static struct mbuf *dlil_input_loop_tail = NULL;
+static int
+dlil_write_begin(void)
+{
+ struct uthread *uth = get_bsdthread_info(current_thread());
+
+ if (uth->dlil_incremented_read != 0) {
+ return EDEADLK;
+ }
+ lck_mtx_lock(dlil_mutex);
+ OSBitOrAtomic((UInt32)dlil_writer_waiting, (UInt32*)&dlil_read_count);
+again:
+ if (dlil_read_count == dlil_writer_waiting) {
+ uth->dlil_incremented_read = dlil_writer_waiting;
+ return 0;
+ }
+ else {
+ tsleep(_cast_non_const(&dlil_writer_waiting), PRIBIO, "dlil_writer_waiting", 1);
+ goto again;
+ }
+}
-static void dlil_input_thread(void);
-extern void run_netisr(void);
-extern void bpfdetach(struct ifnet*);
+static void
+dlil_write_end(void)
+{
+ struct uthread *uth = get_bsdthread_info(current_thread());
+
+ if (uth->dlil_incremented_read != dlil_writer_waiting)
+ panic("dlil_write_end - thread is not a writer");
+ OSBitAndAtomic((UInt32)~dlil_writer_waiting, (UInt32*)&dlil_read_count);
+ lck_mtx_unlock(dlil_mutex);
+ uth->dlil_incremented_read = 0;
+ wakeup(&dlil_read_count);
+}
+#define PROTO_HASH_SLOTS 0x5
/*
* Internal functions.
*/
-static
-struct if_family_str *find_family_module(u_long if_family)
+static int
+proto_hash_value(u_long protocol_family)
{
- struct if_family_str *mod = NULL;
-
- TAILQ_FOREACH(mod, &if_family_head, if_fam_next) {
- if (mod->if_family == (if_family & 0xffff))
- break;
- }
-
- return mod;
+ /*
+ * dlil_proto_unplumb_all() depends on the mapping between
+ * the hash bucket index and the protocol family defined
+ * here; future changes must be applied there as well.
+ */
+ switch(protocol_family) {
+ case PF_INET:
+ return 0;
+ case PF_INET6:
+ return 1;
+ case PF_APPLETALK:
+ return 2;
+ case PF_VLAN:
+ return 3;
+ default:
+ return 4;
+ }
}
-
-/*
- * Public functions.
- */
-
-struct ifnet *ifbyfamily(u_long family, short unit)
+static struct if_proto*
+find_attached_proto(struct ifnet *ifp, u_long protocol_family)
{
- struct ifnet *ifp;
-
- TAILQ_FOREACH(ifp, &ifnet, if_link)
- if ((family == ifp->if_family) &&
- (ifp->if_unit == unit))
- return ifp;
-
- return 0;
+ struct if_proto *proto = NULL;
+ u_long i = proto_hash_value(protocol_family);
+ if (ifp->if_proto_hash) {
+ proto = SLIST_FIRST(&ifp->if_proto_hash[i]);
+ }
+
+ while(proto && proto->protocol_family != protocol_family) {
+ proto = SLIST_NEXT(proto, next_hash);
+ }
+
+ return proto;
}
-struct if_proto *dlttoproto(u_long dl_tag)
+static void
+if_proto_ref(struct if_proto *proto)
{
- if (dl_tag < dl_tag_nb && dl_tag_array[dl_tag].ifp)
- return dl_tag_array[dl_tag].proto;
- return 0;
+ OSAddAtomic(1, (SInt32*)&proto->refcount);
}
-
-static int dlil_ifp_proto_count(struct ifnet * ifp)
+static void
+if_proto_free(struct if_proto *proto)
{
- int count = 0;
- struct if_proto * proto;
- struct dlil_proto_head * tmp;
-
- tmp = (struct dlil_proto_head *) &ifp->proto_head;
-
- TAILQ_FOREACH(proto, tmp, next)
- count++;
-
- return count;
+ int oldval = OSAddAtomic(-1, (SInt32*)&proto->refcount);
+
+ if (oldval == 1) { /* This was the last reference */
+ FREE(proto, M_IFADDR);
+ }
}
-u_long ifptodlt(struct ifnet *ifp, u_long proto_family)
+__private_extern__ void
+ifnet_lock_assert(
+ __unused struct ifnet *ifp,
+ __unused int what)
{
- struct if_proto *proto;
- struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
+#if IFNET_RW_LOCK
+ /*
+ * Not implemented for rw locks.
+ *
+ * Function exists so when/if we use mutex we can
+ * enable this check.
+ */
+#else
+ lck_mtx_assert(ifp->if_lock, what);
+#endif
+}
+__private_extern__ void
+ifnet_lock_shared(
+ struct ifnet *ifp)
+{
+#if IFNET_RW_LOCK
+ lck_rw_lock_shared(ifp->if_lock);
+#else
+ lck_mtx_assert(ifp->if_lock, LCK_MTX_ASSERT_NOTOWNED);
+ lck_mtx_lock(ifp->if_lock);
+#endif
+}
- TAILQ_FOREACH(proto, tmp, next)
- if (proto->protocol_family == proto_family)
- return proto->dl_tag;
+__private_extern__ void
+ifnet_lock_exclusive(
+ struct ifnet *ifp)
+{
+#if IFNET_RW_LOCK
+ lck_rw_lock_exclusive(ifp->if_lock);
+#else
+ lck_mtx_assert(ifp->if_lock, LCK_MTX_ASSERT_NOTOWNED);
+ lck_mtx_lock(ifp->if_lock);
+#endif
+}
- return 0;
+__private_extern__ void
+ifnet_lock_done(
+ struct ifnet *ifp)
+{
+#if IFNET_RW_LOCK
+ lck_rw_done(ifp->if_lock);
+#else
+ lck_mtx_assert(ifp->if_lock, LCK_MTX_ASSERT_OWNED);
+ lck_mtx_unlock(ifp->if_lock);
+#endif
}
-
-int dlil_find_dltag(u_long if_family, short unit, u_long proto_family, u_long *dl_tag)
+__private_extern__ void
+ifnet_head_lock_shared(void)
{
- struct ifnet *ifp;
+ lck_rw_lock_shared(ifnet_head_mutex);
+}
- ifp = ifbyfamily(if_family, unit);
- if (!ifp)
- return ENOENT;
+__private_extern__ void
+ifnet_head_lock_exclusive(void)
+{
+ lck_rw_lock_exclusive(ifnet_head_mutex);
+}
- *dl_tag = ifptodlt(ifp, proto_family);
- if (*dl_tag == 0)
- return EPROTONOSUPPORT;
- else
- return 0;
+__private_extern__ void
+ifnet_head_done(void)
+{
+ lck_rw_done(ifnet_head_mutex);
}
+static int dlil_ifp_proto_count(struct ifnet * ifp)
+{
+ int count = 0;
+ int i;
+
+ if (ifp->if_proto_hash != NULL) {
+ for (i = 0; i < PROTO_HASH_SLOTS; i++) {
+ struct if_proto *proto;
+ SLIST_FOREACH(proto, &ifp->if_proto_hash[i], next_hash) {
+ count++;
+ }
+ }
+ }
+
+ return count;
+}
-void dlil_post_msg(struct ifnet *ifp, u_long event_subclass, u_long event_code,
+__private_extern__ void
+dlil_post_msg(struct ifnet *ifp, u_long event_subclass, u_long event_code,
struct net_event_data *event_data, u_long event_data_len)
{
- struct net_event_data ev_data;
- struct kev_msg ev_msg;
-
- /*
- * a net event always start with a net_event_data structure
- * but the caller can generate a simple net event or
- * provide a longer event structure to post
- */
-
- ev_msg.vendor_code = KEV_VENDOR_APPLE;
- ev_msg.kev_class = KEV_NETWORK_CLASS;
- ev_msg.kev_subclass = event_subclass;
- ev_msg.event_code = event_code;
-
- if (event_data == 0) {
- event_data = &ev_data;
- event_data_len = sizeof(struct net_event_data);
- }
-
- strncpy(&event_data->if_name[0], ifp->if_name, IFNAMSIZ);
- event_data->if_family = ifp->if_family;
- event_data->if_unit = (unsigned long) ifp->if_unit;
-
- ev_msg.dv[0].data_length = event_data_len;
- ev_msg.dv[0].data_ptr = event_data;
- ev_msg.dv[1].data_length = 0;
-
- kev_post_msg(&ev_msg);
+ struct net_event_data ev_data;
+ struct kev_msg ev_msg;
+
+ /*
+ * a net event always starts with a net_event_data structure
+ * but the caller can generate a simple net event or
+ * provide a longer event structure to post
+ */
+
+ ev_msg.vendor_code = KEV_VENDOR_APPLE;
+ ev_msg.kev_class = KEV_NETWORK_CLASS;
+ ev_msg.kev_subclass = event_subclass;
+ ev_msg.event_code = event_code;
+
+ if (event_data == 0) {
+ event_data = &ev_data;
+ event_data_len = sizeof(struct net_event_data);
+ }
+
+ strncpy(&event_data->if_name[0], ifp->if_name, IFNAMSIZ);
+ event_data->if_family = ifp->if_family;
+ event_data->if_unit = (unsigned long) ifp->if_unit;
+
+ ev_msg.dv[0].data_length = event_data_len;
+ ev_msg.dv[0].data_ptr = event_data;
+ ev_msg.dv[1].data_length = 0;
+
+ dlil_event_internal(ifp, &ev_msg);
}
-
-
-void
-dlil_init()
+__private_extern__ int
+dlil_create_input_thread(
+ ifnet_t ifp, struct dlil_threading_info *inputthread)
{
- int i;
+ int error;
- TAILQ_INIT(&dlil_ifnet_head);
- TAILQ_INIT(&if_family_head);
+ bzero(inputthread, sizeof(*inputthread));
+ // loopback ifp may not be configured at dlil_init time.
+ if (ifp == lo_ifp)
+ strlcat(inputthread->input_name, "dlil_input_main_thread_mtx", 32);
+ else
+ snprintf(inputthread->input_name, 32, "dlil_input_%s%d_mtx", ifp->if_name, ifp->if_unit);
+
+ inputthread->lck_grp = lck_grp_alloc_init(inputthread->input_name, dlil_grp_attributes);
+ inputthread->input_lck = lck_mtx_alloc_init(inputthread->lck_grp, dlil_lck_attributes);
+
+ error= kernel_thread_start((thread_continue_t)dlil_input_thread_func, inputthread, &inputthread->input_thread);
+ if (error == 0) {
+ ml_thread_policy(inputthread->input_thread, MACHINE_GROUP,
+ (MACHINE_NETWORK_GROUP|MACHINE_NETWORK_NETISR));
+ /*
+ * Except for the loopback dlil input thread, we create
+ * an affinity set so that the matching workloop thread
+ * can be scheduled on the same processor set.
+ */
+ if (net_affinity && inputthread != dlil_lo_thread_ptr) {
+ struct thread *tp = inputthread->input_thread;
+ u_int32_t tag;
+ /*
+ * Randomize to reduce the probability
+ * of affinity tag namespace collision.
+ */
+ read_random(&tag, sizeof (tag));
+ if (dlil_affinity_set(tp, tag) == KERN_SUCCESS) {
+ thread_reference(tp);
+ inputthread->tag = tag;
+ inputthread->net_affinity = TRUE;
+ }
+ }
+ } else {
+ panic("dlil_create_input_thread: couldn't create thread\n");
+ }
+ OSAddAtomic(1, (SInt32*)&cur_dlil_input_threads);
+#if DLIL_DEBUG
+ printf("dlil_create_input_thread: threadinfo: %p input_thread=%p threads: cur=%d max=%d\n",
+ inputthread, inputthread->input_thread, dlil_multithreaded_input, cur_dlil_input_threads);
+#endif
+ return error;
+}
+__private_extern__ void
+dlil_terminate_input_thread(
+ struct dlil_threading_info *inputthread)
+{
+ OSAddAtomic(-1, (SInt32*)&cur_dlil_input_threads);
- // create the dl tag array
- MALLOC(dl_tag_array, void *, sizeof(struct dl_tag_str) * MAX_DL_TAGS, M_NKE, M_WAITOK);
- if (dl_tag_array == 0) {
- printf("dlil_init tags array allocation failed\n");
- return; //very bad
- }
- bzero(dl_tag_array, sizeof(struct dl_tag_str) * MAX_DL_TAGS);
- dl_tag_nb = MAX_DL_TAGS;
-
- // create the dl filters array
- MALLOC(dlil_filters, void *, sizeof(struct dlil_filter_id_str) * MAX_DLIL_FILTERS, M_NKE, M_WAITOK);
- if (dlil_filters == 0) {
- printf("dlil_init filters array allocation failed\n");
- return; //very bad
- }
- bzero(dlil_filters, sizeof(struct dlil_filter_id_str) * MAX_DLIL_FILTERS);
- dlil_filters_nb = MAX_DLIL_FILTERS;
+ lck_mtx_unlock(inputthread->input_lck);
+ lck_mtx_free(inputthread->input_lck, inputthread->lck_grp);
+ lck_grp_free(inputthread->lck_grp);
- bzero(&dlil_stats, sizeof(dlil_stats));
+ FREE(inputthread, M_NKE);
- simple_lock_init(&dlil_input_lock);
+ /* For the extra reference count from kernel_thread_start() */
+ thread_deallocate(current_thread());
- /*
- * Start up the dlil input thread once everything is initialized
- */
- (void) kernel_thread(kernel_task, dlil_input_thread);
+ thread_terminate(current_thread());
}
-u_long get_new_filter_id()
+static kern_return_t
+dlil_affinity_set(struct thread *tp, u_int32_t tag)
{
- u_long i;
- u_char *p;
-
- for (i=1; i < dlil_filters_nb; i++)
- if (dlil_filters[i].type == 0)
- break;
-
- if (i == dlil_filters_nb) {
- // expand the filters array by MAX_DLIL_FILTERS
- MALLOC(p, u_char *, sizeof(struct dlil_filter_id_str) * (dlil_filters_nb + MAX_DLIL_FILTERS), M_NKE, M_WAITOK);
- if (p == 0)
- return 0;
-
- bcopy(dlil_filters, p, sizeof(struct dlil_filter_id_str) * dlil_filters_nb);
- bzero(p + sizeof(struct dlil_filter_id_str) * dlil_filters_nb, sizeof(struct dlil_filter_id_str) * MAX_DL_TAGS);
- dlil_filters_nb += MAX_DLIL_FILTERS;
- FREE(dlil_filters, M_NKE);
- dlil_filters = (struct dlil_filter_id_str *)p;
- }
-
- return i;
-}
+ thread_affinity_policy_data_t policy;
+ bzero(&policy, sizeof (policy));
+ policy.affinity_tag = tag;
+ return (thread_policy_set(tp, THREAD_AFFINITY_POLICY,
+ (thread_policy_t)&policy, THREAD_AFFINITY_POLICY_COUNT));
+}
-int dlil_attach_interface_filter(struct ifnet *ifp,
- struct dlil_if_flt_str *if_filter,
- u_long *filter_id,
- int insertion_point)
+void
+dlil_init(void)
{
- int s;
- int retval = 0;
- struct dlil_filterq_entry *tmp_ptr;
- struct dlil_filterq_entry *if_filt;
- struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- boolean_t funnel_state;
-
- MALLOC(tmp_ptr, struct dlil_filterq_entry *, sizeof(*tmp_ptr), M_NKE, M_WAITOK);
- if (tmp_ptr == NULL)
- return (ENOBUFS);
-
- bcopy((caddr_t) if_filter, (caddr_t) &tmp_ptr->variants.if_filter,
- sizeof(struct dlil_if_flt_str));
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
+ PE_parse_boot_arg("net_affinity", &net_affinity);
+
+ TAILQ_INIT(&dlil_ifnet_head);
+ TAILQ_INIT(&ifnet_head);
+
+ /* Setup the lock groups we will use */
+ dlil_grp_attributes = lck_grp_attr_alloc_init();
- *filter_id = get_new_filter_id();
- if (*filter_id == 0) {
- FREE(tmp_ptr, M_NKE);
- retval = ENOMEM;
- goto end;
- }
-
- dlil_filters[*filter_id].filter_ptr = tmp_ptr;
- dlil_filters[*filter_id].head = (struct dlil_filterq_head *) &ifp->if_flt_head;
- dlil_filters[*filter_id].type = DLIL_IF_FILTER;
- dlil_filters[*filter_id].ifp = ifp;
- tmp_ptr->filter_id = *filter_id;
- tmp_ptr->type = DLIL_IF_FILTER;
-
- if (insertion_point != DLIL_LAST_FILTER) {
- TAILQ_FOREACH(if_filt, fhead, que)
- if (insertion_point == if_filt->filter_id) {
- TAILQ_INSERT_BEFORE(if_filt, tmp_ptr, que);
- break;
- }
- }
- else
- TAILQ_INSERT_TAIL(fhead, tmp_ptr, que);
+ dlil_lock_group = lck_grp_alloc_init("dlil internal locks", dlil_grp_attributes);
+ ifnet_lock_group = lck_grp_alloc_init("ifnet locks", dlil_grp_attributes);
+ ifnet_head_lock_group = lck_grp_alloc_init("ifnet head lock", dlil_grp_attributes);
+ dlil_input_lock_grp = lck_grp_alloc_init("dlil input lock", dlil_grp_attributes);
+
+ /* Setup the lock attributes we will use */
+ dlil_lck_attributes = lck_attr_alloc_init();
+
+ ifnet_lock_attr = lck_attr_alloc_init();
+
+
+ ifnet_head_mutex = lck_rw_alloc_init(ifnet_head_lock_group, dlil_lck_attributes);
+ dlil_ifnet_mutex = lck_mtx_alloc_init(dlil_lock_group, dlil_lck_attributes);
+ dlil_mutex = lck_mtx_alloc_init(dlil_lock_group, dlil_lck_attributes);
+
+ lck_attr_free(dlil_lck_attributes);
+ dlil_lck_attributes = NULL;
+
+ /*
+ * Create and start up the first dlil input thread once everything is initialized
+ */
+ dlil_create_input_thread(0, dlil_lo_thread_ptr);
-end:
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
+ (void) kernel_thread(kernel_task, dlil_call_delayed_detach_thread);
}
-
-int dlil_attach_protocol_filter(u_long dl_tag,
- struct dlil_pr_flt_str *pr_filter,
- u_long *filter_id,
- int insertion_point)
+__private_extern__ int
+dlil_attach_filter(
+ struct ifnet *ifp,
+ const struct iff_filter *if_filter,
+ interface_filter_t *filter_ref)
{
- struct dlil_filterq_entry *tmp_ptr, *pr_filt;
- int s;
int retval = 0;
- boolean_t funnel_state;
+ struct ifnet_filter *filter;
- if (dl_tag >= dl_tag_nb || dl_tag_array[dl_tag].ifp == 0)
- return (ENOENT);
-
- MALLOC(tmp_ptr, struct dlil_filterq_entry *, sizeof(*tmp_ptr), M_NKE, M_WAITOK);
- if (tmp_ptr == NULL)
- return (ENOBUFS);
+ MALLOC(filter, struct ifnet_filter *, sizeof(*filter), M_NKE, M_WAITOK);
+ if (filter == NULL)
+ return ENOMEM;
+ bzero(filter, sizeof(*filter));
- bcopy((caddr_t) pr_filter, (caddr_t) &tmp_ptr->variants.pr_filter,
- sizeof(struct dlil_pr_flt_str));
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
-
- *filter_id = get_new_filter_id();
- if (*filter_id == 0) {
- FREE(tmp_ptr, M_NKE);
- retval = ENOMEM;
- goto end;
- }
- dlil_filters[*filter_id].filter_ptr = tmp_ptr;
- dlil_filters[*filter_id].head = dl_tag_array[dl_tag].pr_flt_head;
- dlil_filters[*filter_id].type = DLIL_PR_FILTER;
- dlil_filters[*filter_id].proto = dl_tag_array[dl_tag].proto;
- dlil_filters[*filter_id].ifp = dl_tag_array[dl_tag].ifp;
- tmp_ptr->filter_id = *filter_id;
- tmp_ptr->type = DLIL_PR_FILTER;
-
- if (insertion_point != DLIL_LAST_FILTER) {
- TAILQ_FOREACH(pr_filt, dl_tag_array[dl_tag].pr_flt_head, que)
- if (insertion_point == pr_filt->filter_id) {
- TAILQ_INSERT_BEFORE(pr_filt, tmp_ptr, que);
- break;
- }
- }
- else
- TAILQ_INSERT_TAIL(dl_tag_array[dl_tag].pr_flt_head, tmp_ptr, que);
-
-end:
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
+ filter->filt_ifp = ifp;
+ filter->filt_cookie = if_filter->iff_cookie;
+ filter->filt_name = if_filter->iff_name;
+ filter->filt_protocol = if_filter->iff_protocol;
+ filter->filt_input = if_filter->iff_input;
+ filter->filt_output = if_filter->iff_output;
+ filter->filt_event = if_filter->iff_event;
+ filter->filt_ioctl = if_filter->iff_ioctl;
+ filter->filt_detached = if_filter->iff_detached;
+
+ if ((retval = dlil_write_begin()) != 0) {
+ /* Failed to acquire the write lock */
+ FREE(filter, M_NKE);
+ return retval;
+ }
+ TAILQ_INSERT_TAIL(&ifp->if_flt_head, filter, filt_next);
+ dlil_write_end();
+ *filter_ref = filter;
+ return retval;
}
+static int
+dlil_detach_filter_internal(
+ interface_filter_t filter,
+ int detached)
+{
+ int retval = 0;
+
+ if (detached == 0) {
+ ifnet_t ifp = NULL;
+ interface_filter_t entry = NULL;
+
+ /* Take the write lock */
+ retval = dlil_write_begin();
+ if (retval != 0 && retval != EDEADLK)
+ return retval;
+
+ /*
+ * At this point either we have the write lock (retval == 0)
+ * or we couldn't get it (retval == EDEADLK) because someone
+ * else up the stack is holding the read lock. It is safe to
+ * read, either the read or write is held. Verify the filter
+ * parameter before proceeding.
+ */
+ ifnet_head_lock_shared();
+ TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
+ TAILQ_FOREACH(entry, &ifp->if_flt_head, filt_next) {
+ if (entry == filter)
+ break;
+ }
+ if (entry == filter)
+ break;
+ }
+ ifnet_head_done();
+
+ if (entry != filter) {
+ /* filter parameter is not a valid filter ref */
+ if (retval == 0) {
+ dlil_write_end();
+ }
+ return EINVAL;
+ }
+
+ if (retval == EDEADLK) {
+ /* Perform a delayed detach */
+ filter->filt_detaching = 1;
+ dlil_detach_waiting = 1;
+ wakeup(&dlil_detach_waiting);
+ return 0;
+ }
+
+ /* Remove the filter from the list */
+ TAILQ_REMOVE(&ifp->if_flt_head, filter, filt_next);
+ dlil_write_end();
+ }
+
+ /* Call the detached funciton if there is one */
+ if (filter->filt_detached)
+ filter->filt_detached(filter->filt_cookie, filter->filt_ifp);
+
+ /* Free the filter */
+ FREE(filter, M_NKE);
+
+ return retval;
+}
-int
-dlil_detach_filter(u_long filter_id)
+__private_extern__ void
+dlil_detach_filter(interface_filter_t filter)
{
- struct dlil_filter_id_str *flt;
- int s, retval = 0;
- boolean_t funnel_state;
+ if (filter == NULL)
+ return;
+ dlil_detach_filter_internal(filter, 0);
+}
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
-
- if (filter_id >= dlil_filters_nb || dlil_filters[filter_id].type == 0) {
- retval = ENOENT;
- goto end;
- }
+static void
+dlil_input_thread_func(
+ struct dlil_threading_info *inputthread)
+{
+ while (1) {
+ struct mbuf *m = NULL, *m_loop = NULL;
+#if IFNET_INPUT_SANITY_CHK
+ int loop_cnt = 0, mbuf_cnt;
+ int count;
+ struct mbuf *m1;
+#endif /* IFNET_INPUT_SANITY_CHK */
+
+ lck_mtx_lock(inputthread->input_lck);
+
+ /* Wait until there is work to be done */
+ while ((inputthread->input_waiting & ~DLIL_INPUT_RUNNING) == 0) {
+ inputthread->input_waiting &= ~DLIL_INPUT_RUNNING;
+ msleep(&inputthread->input_waiting, inputthread->input_lck, 0, inputthread->input_name, 0);
+ }
- flt = &dlil_filters[filter_id];
+
+ lck_mtx_assert(inputthread->input_lck, LCK_MTX_ASSERT_OWNED);
+
+ m = inputthread->mbuf_head;
+ inputthread->mbuf_head = NULL;
+ inputthread->mbuf_tail = NULL;
+
+ if (inputthread->input_waiting & DLIL_INPUT_TERMINATE) {
+ if (m)
+ mbuf_freem_list(m);
+ /* this is the end */
+ dlil_terminate_input_thread(inputthread);
+ return;
+ }
- if (flt->type == DLIL_IF_FILTER) {
- if (IFILT(flt->filter_ptr).filter_detach)
- (*IFILT(flt->filter_ptr).filter_detach)(IFILT(flt->filter_ptr).cookie);
- }
- else {
- if (flt->type == DLIL_PR_FILTER) {
- if (PFILT(flt->filter_ptr).filter_detach)
- (*PFILT(flt->filter_ptr).filter_detach)(PFILT(flt->filter_ptr).cookie);
- }
- }
+ inputthread->input_waiting |= DLIL_INPUT_RUNNING;
+ inputthread->input_waiting &= ~DLIL_INPUT_WAITING;
- TAILQ_REMOVE(flt->head, flt->filter_ptr, que);
- FREE(flt->filter_ptr, M_NKE);
- flt->type = 0;
+ if (inputthread == dlil_lo_thread_ptr) {
+ m_loop = dlil_lo_input_mbuf_head;
+ dlil_lo_input_mbuf_head = NULL;
+ dlil_lo_input_mbuf_tail = NULL;
+ }
-end:
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
-}
+#if IFNET_INPUT_SANITY_CHK
+ if (dlil_input_sanity_check != 0) {
+ mbuf_cnt = inputthread->mbuf_count;
+ inputthread->mbuf_count = 0;
+ if (inputthread == dlil_lo_thread_ptr) {
+ loop_cnt = dlil_lo_input_mbuf_count;
+ dlil_lo_input_mbuf_count = 0;
+ }
+
+ lck_mtx_unlock(inputthread->input_lck);
+
+ for (m1 = m, count = 0; m1; m1 = mbuf_nextpkt(m1)) {
+ count++;
+ }
+ if (count != mbuf_cnt) {
+ panic("dlil_input_func - thread=%p reg. loop queue has %d packets, should have %d\n",
+ inputthread, count, mbuf_cnt);
+ }
+
+ if (inputthread == dlil_lo_thread_ptr) {
+ for (m1 = m_loop, count = 0; m1; m1 = mbuf_nextpkt(m1)) {
+ count++;
+ }
+ if (count != loop_cnt) {
+ panic("dlil_input_func - thread=%p loop queue has %d packets, should have %d\n",
+ inputthread, count, loop_cnt);
+ }
+ }
+ } else
+#endif /* IFNET_INPUT_SANITY_CHK */
+ {
+ lck_mtx_unlock(inputthread->input_lck);
+ }
-void
-dlil_input_thread_continue(void)
-{
- while (1) {
- struct mbuf *m, *m_loop;
- int expand_mcl;
-
- usimple_lock(&dlil_input_lock);
- m = dlil_input_mbuf_head;
- dlil_input_mbuf_head = NULL;
- dlil_input_mbuf_tail = NULL;
- m_loop = dlil_input_loop_head;
- dlil_input_loop_head = NULL;
- dlil_input_loop_tail = NULL;
- usimple_unlock(&dlil_input_lock);
-
- MBUF_LOCK();
- expand_mcl = dlil_expand_mcl;
- dlil_expand_mcl = 0;
- MBUF_UNLOCK();
- if (expand_mcl) {
- caddr_t p;
- MCLALLOC(p, M_WAIT);
- if (p) MCLFREE(p);
- }
-
- /*
- * NOTE warning %%% attention !!!!
- * We should think about putting some thread starvation safeguards if
- * we deal with long chains of packets.
- */
- while (m) {
- struct mbuf *m0 = m->m_nextpkt;
- void *header = m->m_pkthdr.header;
-
- m->m_nextpkt = NULL;
- m->m_pkthdr.header = NULL;
- (void) dlil_input_packet(m->m_pkthdr.rcvif, m, header);
- m = m0;
- }
- m = m_loop;
- while (m) {
- struct mbuf *m0 = m->m_nextpkt;
- void *header = m->m_pkthdr.header;
- struct ifnet *ifp = &loif[0];
-
- m->m_nextpkt = NULL;
- m->m_pkthdr.header = NULL;
- (void) dlil_input_packet(ifp, m, header);
- m = m0;
- }
+ /*
+ * NOTE warning %%% attention !!!!
+ * We should think about putting some thread starvation safeguards if
+ * we deal with long chains of packets.
+ */
+ if (m_loop) {
+ if (inputthread == dlil_lo_thread_ptr)
+ dlil_input_packet_list(lo_ifp, m_loop);
+#if IFNET_INPUT_SANITY_CHK
+ else
+ panic("dlil_input_func - thread=%p loop queue has %d packets, should have none!\n",
+ inputthread, loop_cnt);
+#endif /* IFNET_INPUT_SANITY_CHK */
+ }
- if (netisr != 0)
- run_netisr();
- if (dlil_input_mbuf_head == NULL &&
- dlil_input_loop_head == NULL &&
- netisr == 0) {
- assert_wait(&dlil_input_thread_wakeup, THREAD_UNINT);
- (void) thread_block(dlil_input_thread_continue);
- /* NOTREACHED */
- }
- }
-}
+ if (m)
+ dlil_input_packet_list(0, m);
-void dlil_input_thread(void)
-{
- register thread_t self = current_thread();
- extern void stack_privilege(thread_t thread);
- /*
- * Make sure that this thread
- * always has a kernel stack, and
- * bind it to the master cpu.
- */
- stack_privilege(self);
- ml_thread_policy(current_thread(), MACHINE_GROUP,
- (MACHINE_NETWORK_GROUP|MACHINE_NETWORK_NETISR));
-
- /* The dlil thread is always funneled */
- thread_funnel_set(network_flock, TRUE);
- dlil_initialized = 1;
- dlil_input_thread_continue();
-}
+ lck_mtx_lock(inputthread->input_lck);
-int
-dlil_input(struct ifnet *ifp, struct mbuf *m_head, struct mbuf *m_tail)
-{
- /* WARNING
- * Because of loopbacked multicast we cannot stuff the ifp in
- * the rcvif of the packet header: loopback has its own dlil
- * input queue
- */
-
- usimple_lock(&dlil_input_lock);
- if (ifp->if_type != IFT_LOOP) {
- if (dlil_input_mbuf_head == NULL)
- dlil_input_mbuf_head = m_head;
- else if (dlil_input_mbuf_tail != NULL)
- dlil_input_mbuf_tail->m_nextpkt = m_head;
- dlil_input_mbuf_tail = m_tail ? m_tail : m_head;
- } else {
- if (dlil_input_loop_head == NULL)
- dlil_input_loop_head = m_head;
- else if (dlil_input_loop_tail != NULL)
- dlil_input_loop_tail->m_nextpkt = m_head;
- dlil_input_loop_tail = m_tail ? m_tail : m_head;
- }
- usimple_unlock(&dlil_input_lock);
-
- wakeup((caddr_t)&dlil_input_thread_wakeup);
-
- return 0;
+ if ((inputthread->input_waiting & (DLIL_PROTO_WAITING | DLIL_PROTO_REGISTER)) != 0) {
+ lck_mtx_unlock(inputthread->input_lck);
+ proto_input_run();
+ }
+ else
+ lck_mtx_unlock(inputthread->input_lck);
+ }
}
-int
-dlil_input_packet(struct ifnet *ifp, struct mbuf *m,
- char *frame_header)
+errno_t
+ifnet_input(
+ ifnet_t ifp,
+ mbuf_t m_head,
+ const struct ifnet_stat_increment_param *stats)
{
- struct ifnet *orig_ifp = 0;
- struct dlil_filterq_entry *tmp;
- int retval;
- struct if_proto *ifproto = 0;
- struct if_proto *proto;
- struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
-
-
- KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_START,0,0,0,0,0);
-
- /*
- * Run interface filters
- */
+ struct thread *tp = current_thread();
+ mbuf_t m_tail;
+ struct dlil_threading_info *inp;
+#if IFNET_INPUT_SANITY_CHK
+ u_int32_t pkt_count = 0;
+#endif /* IFNET_INPUT_SANITY_CHK */
+
+ if (ifp == NULL || m_head == NULL) {
+ if (m_head)
+ mbuf_freem_list(m_head);
+ return EINVAL;
+ }
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
-
- TAILQ_FOREACH_REVERSE(tmp, fhead, que, dlil_filterq_head) {
- if (IFILT(tmp).filter_if_input) {
- retval = (*IFILT(tmp).filter_if_input)(IFILT(tmp).cookie,
- &ifp,
- &m,
- &frame_header);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
+ m_tail = m_head;
+ while (1) {
+#if IFNET_INPUT_SANITY_CHK
+ if (dlil_input_sanity_check != 0) {
+ ifnet_t rcvif;
+
+ rcvif = mbuf_pkthdr_rcvif(m_tail);
+ pkt_count++;
+
+ if (rcvif == NULL ||
+ (ifp->if_type != IFT_LOOP && rcvif != ifp) ||
+ (mbuf_flags(m_head) & MBUF_PKTHDR) == 0) {
+ panic("ifnet_input - invalid mbuf %p\n", m_tail);
+ }
}
- }
-
- if (ifp != orig_ifp)
- break;
+#endif /* IFNET_INPUT_SANITY_CHK */
+ if (mbuf_nextpkt(m_tail) == NULL)
+ break;
+ m_tail = mbuf_nextpkt(m_tail);
}
- }
- ifp->if_lastchange = time;
-
- /*
- * Call family demux module. If the demux module finds a match
- * for the frame it will fill-in the ifproto pointer.
- */
+ inp = ifp->if_input_thread;
- retval = (*ifp->if_demux)(ifp, m, frame_header, &ifproto );
+ if (dlil_multithreaded_input == 0 || inp == NULL)
+ inp = dlil_lo_thread_ptr;
- if (m->m_flags & (M_BCAST|M_MCAST))
- ifp->if_imcasts++;
-
- if ((retval) && (retval != EJUSTRETURN) && (ifp->offercnt)) {
/*
- * No match was found, look for any offers.
+ * If there is a matching dlil input thread associated with an
+ * affinity set, associate this workloop thread with the same set.
+ * We will only do this once.
*/
- struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
- TAILQ_FOREACH(proto, tmp, next) {
- if ((proto->dl_offer) && (proto->dl_offer(m, frame_header) == 0)) {
- ifproto = proto;
- retval = 0;
- break;
- }
+ lck_mtx_lock(inp->input_lck);
+ if (inp->net_affinity && inp->workloop_thread == NULL) {
+ u_int32_t tag = inp->tag;
+ inp->workloop_thread = tp;
+ lck_mtx_unlock(inp->input_lck);
+
+ /* Associated the current thread with the new affinity tag */
+ (void) dlil_affinity_set(tp, tag);
+
+ /*
+ * Take a reference on the workloop (current) thread; during
+ * detach, we will need to refer to it in order ot tear down
+ * its affinity.
+ */
+ thread_reference(tp);
+ lck_mtx_lock(inp->input_lck);
}
- }
- if (retval) {
- if (retval != EJUSTRETURN) {
- m_freem(m);
- return retval;
- }
- else
- return 0;
- }
- else
- if (ifproto == 0) {
- printf("ERROR - dlil_input - if_demux didn't return an if_proto pointer\n");
- m_freem(m);
- return 0;
- }
-
-/*
- * Call any attached protocol filters.
- */
-
- TAILQ_FOREACH_REVERSE(tmp, &ifproto->pr_flt_head, que, dlil_filterq_head) {
- if (PFILT(tmp).filter_dl_input) {
- retval = (*PFILT(tmp).filter_dl_input)(PFILT(tmp).cookie,
- &m,
- &frame_header,
- &ifp);
+ /* WARNING
+ * Because of loopbacked multicast we cannot stuff the ifp in
+ * the rcvif of the packet header: loopback has its own dlil
+ * input queue
+ */
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
+ if (inp == dlil_lo_thread_ptr && ifp->if_type == IFT_LOOP) {
+ if (dlil_lo_input_mbuf_head == NULL)
+ dlil_lo_input_mbuf_head = m_head;
+ else if (dlil_lo_input_mbuf_tail != NULL)
+ dlil_lo_input_mbuf_tail->m_nextpkt = m_head;
+ dlil_lo_input_mbuf_tail = m_tail;
+#if IFNET_INPUT_SANITY_CHK
+ if (dlil_input_sanity_check != 0) {
+ dlil_lo_input_mbuf_count += pkt_count;
+ inp->input_mbuf_cnt += pkt_count;
+ inp->input_wake_cnt++;
+
+ lck_mtx_assert(inp->input_lck, LCK_MTX_ASSERT_OWNED);
}
- }
- }
- }
-
+#endif
+ }
+ else {
+ if (inp->mbuf_head == NULL)
+ inp->mbuf_head = m_head;
+ else if (inp->mbuf_tail != NULL)
+ inp->mbuf_tail->m_nextpkt = m_head;
+ inp->mbuf_tail = m_tail;
+#if IFNET_INPUT_SANITY_CHK
+ if (dlil_input_sanity_check != 0) {
+ inp->mbuf_count += pkt_count;
+ inp->input_mbuf_cnt += pkt_count;
+ inp->input_wake_cnt++;
+
+ lck_mtx_assert(inp->input_lck, LCK_MTX_ASSERT_OWNED);
+ }
+#endif
+ }
- retval = (*ifproto->dl_input)(m, frame_header,
- ifp, ifproto->dl_tag,
- TRUE);
-
- if (retval == EJUSTRETURN)
- retval = 0;
- else
- if (retval)
- m_freem(m);
+ inp->input_waiting |= DLIL_INPUT_WAITING;
+ if ((inp->input_waiting & DLIL_INPUT_RUNNING) == 0) {
+ wakeup((caddr_t)&inp->input_waiting);
+ }
+ if (stats) {
+ ifp->if_data.ifi_ipackets += stats->packets_in;
+ ifp->if_data.ifi_ibytes += stats->bytes_in;
+ ifp->if_data.ifi_ierrors += stats->errors_in;
+
+ ifp->if_data.ifi_opackets += stats->packets_out;
+ ifp->if_data.ifi_obytes += stats->bytes_out;
+ ifp->if_data.ifi_oerrors += stats->errors_out;
+
+ ifp->if_data.ifi_collisions += stats->collisions;
+ ifp->if_data.ifi_iqdrops += stats->dropped;
+ }
- KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_END,0,0,0,0,0);
- return retval;
+ lck_mtx_unlock(inp->input_lck);
+
+ return 0;
}
-
-
-void ether_input(ifp, eh, m)
- struct ifnet *ifp;
- struct ether_header *eh;
- struct mbuf *m;
-
+static int
+dlil_interface_filters_input(struct ifnet * ifp, struct mbuf * * m_p,
+ char * * frame_header_p,
+ protocol_family_t protocol_family)
{
- kprintf("Someone is calling ether_input!!\n");
-
- dlil_input(ifp, m, NULL);
+ struct ifnet_filter * filter;
+
+ TAILQ_FOREACH(filter, &ifp->if_flt_head, filt_next) {
+ int result;
+
+ if (filter->filt_input
+ && (filter->filt_protocol == 0
+ || filter->filt_protocol == protocol_family)) {
+ result = (*filter->filt_input)(filter->filt_cookie,
+ ifp, protocol_family,
+ m_p, frame_header_p);
+ if (result != 0) {
+ return (result);
+ }
+ }
+ }
+ return (0);
}
-
-int
-dlil_event(struct ifnet *ifp, struct kern_event_msg *event)
+static void
+dlil_ifproto_input(struct if_proto * ifproto, mbuf_t m)
{
- struct dlil_filterq_entry *filt;
- int retval = 0;
- struct ifnet *orig_ifp = 0;
- struct if_proto *proto;
- struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- struct kev_msg kev_msg;
- struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
- boolean_t funnel_state;
-
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
-
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
-
- TAILQ_FOREACH_REVERSE(filt, fhead, que, dlil_filterq_head) {
- if (IFILT(filt).filter_if_event) {
- retval = (*IFILT(filt).filter_if_event)(IFILT(filt).cookie,
- &ifp,
- &event);
-
- if (retval) {
- (void) thread_funnel_set(network_flock, funnel_state);
- if (retval == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
- }
-
- if (ifp != orig_ifp)
- break;
+ int error;
+
+ if (ifproto->proto_kpi == kProtoKPI_v1) {
+ /* Version 1 protocols get one packet at a time */
+ while (m != NULL) {
+ char * frame_header;
+ mbuf_t next_packet;
+
+ next_packet = m->m_nextpkt;
+ m->m_nextpkt = NULL;
+ frame_header = m->m_pkthdr.header;
+ m->m_pkthdr.header = NULL;
+ error = (*ifproto->kpi.v1.input)(ifproto->ifp,
+ ifproto->protocol_family,
+ m, frame_header);
+ if (error != 0 && error != EJUSTRETURN)
+ m_freem(m);
+ m = next_packet;
+ }
}
- }
-
-
- /*
- * Call Interface Module event hook, if any.
- */
-
- if (ifp->if_event) {
- retval = ifp->if_event(ifp, (caddr_t) event);
-
- if (retval) {
- (void) thread_funnel_set(network_flock, funnel_state);
-
- if (retval == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
- }
-
- /*
- * Call dl_event entry point for all protocols attached to this interface
- */
-
- TAILQ_FOREACH(proto, tmp, next) {
- /*
- * Call any attached protocol filters.
- */
-
- TAILQ_FOREACH_REVERSE(filt, &proto->pr_flt_head, que, dlil_filterq_head) {
- if (PFILT(filt).filter_dl_event) {
- retval = (*PFILT(filt).filter_dl_event)(PFILT(filt).cookie,
- event);
-
- if (retval) {
- (void) thread_funnel_set(network_flock, funnel_state);
- if (retval == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
- }
- }
-
+ else if (ifproto->proto_kpi == kProtoKPI_v2) {
+ /* Version 2 protocols support packet lists */
+ error = (*ifproto->kpi.v2.input)(ifproto->ifp,
+ ifproto->protocol_family,
+ m);
+ if (error != 0 && error != EJUSTRETURN)
+ m_freem_list(m);
+ }
+ return;
+}
- /*
- * Finally, call the dl_event entry point (if any)
- */
+__private_extern__ void
+dlil_input_packet_list(struct ifnet * ifp_param, struct mbuf *m)
+{
+ int error = 0;
+ int locked = 0;
+ protocol_family_t protocol_family;
+ mbuf_t next_packet;
+ ifnet_t ifp = ifp_param;
+ char * frame_header;
+ struct if_proto * last_ifproto = NULL;
+ mbuf_t pkt_first = NULL;
+ mbuf_t * pkt_next = NULL;
+
+ KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_START,0,0,0,0,0);
+
+ while (m != NULL) {
+ struct if_proto * ifproto = NULL;
+
+ next_packet = m->m_nextpkt;
+ m->m_nextpkt = NULL;
+ if (ifp_param == NULL)
+ ifp = m->m_pkthdr.rcvif;
+ frame_header = m->m_pkthdr.header;
+ m->m_pkthdr.header = NULL;
+
+ if (locked == 0) {
+ /* dlil lock protects the demux and interface filters */
+ locked = 1;
+ dlil_read_begin();
+ }
+ /* find which protocol family this packet is for */
+ error = (*ifp->if_demux)(ifp, m, frame_header,
+ &protocol_family);
+ if (error != 0) {
+ if (error == EJUSTRETURN) {
+ goto next;
+ }
+ protocol_family = 0;
+ }
+
+ /* DANGER!!! */
+ if (m->m_flags & (M_BCAST|M_MCAST))
+ ifp->if_imcasts++;
+
+ /* run interface filters, exclude VLAN packets PR-3586856 */
+ if ((m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) == 0) {
+ int filter_result;
+
+ filter_result = dlil_interface_filters_input(ifp, &m,
+ &frame_header,
+ protocol_family);
+ if (filter_result != 0) {
+ if (filter_result != EJUSTRETURN) {
+ m_freem(m);
+ }
+ goto next;
+ }
+ }
+ if (error != 0 || ((m->m_flags & M_PROMISC) != 0) ) {
+ m_freem(m);
+ goto next;
+ }
+
+ /* Lookup the protocol attachment to this interface */
+ if (protocol_family == 0) {
+ ifproto = NULL;
+ }
+ else if (last_ifproto != NULL
+ && last_ifproto->ifp == ifp
+ && (last_ifproto->protocol_family
+ == protocol_family)) {
+ ifproto = last_ifproto;
+ }
+ else {
+ ifproto = find_attached_proto(ifp, protocol_family);
+ }
+ if (ifproto == NULL) {
+ /* no protocol for this packet, discard */
+ m_freem(m);
+ goto next;
+ }
+ if (ifproto != last_ifproto) {
+ /* make sure ifproto can't go away during input */
+ if_proto_ref(ifproto);
+ if (last_ifproto != NULL) {
+ /* pass up the list for the previous protocol */
+ dlil_read_end();
+
+ dlil_ifproto_input(last_ifproto, pkt_first);
+ pkt_first = NULL;
+ if_proto_free(last_ifproto);
+ dlil_read_begin();
+ }
+ last_ifproto = ifproto;
+ }
+ /* extend the list */
+ m->m_pkthdr.header = frame_header;
+ if (pkt_first == NULL) {
+ pkt_first = m;
+ } else {
+ *pkt_next = m;
+ }
+ pkt_next = &m->m_nextpkt;
- if (proto->dl_event)
- retval = (*proto->dl_event)(event, proto->dl_tag);
+ next:
+ if (next_packet == NULL && last_ifproto != NULL) {
+ /* pass up the last list of packets */
+ dlil_read_end();
- if (retval == EJUSTRETURN) {
- (void) thread_funnel_set(network_flock, funnel_state);
- return 0;
- }
- }
-
+ dlil_ifproto_input(last_ifproto, pkt_first);
+ if_proto_free(last_ifproto);
+ locked = 0;
+ }
+ m = next_packet;
- /*
- * Now, post this event to the Kernel Event message queue
- */
+ }
+ if (locked != 0) {
+ dlil_read_end();
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_END,0,0,0,0,0);
+ return;
+}
- kev_msg.vendor_code = event->vendor_code;
- kev_msg.kev_class = event->kev_class;
- kev_msg.kev_subclass = event->kev_subclass;
- kev_msg.event_code = event->event_code;
- kev_msg.dv[0].data_ptr = &event->event_data[0];
- kev_msg.dv[0].data_length = event->total_size - KEV_MSG_HEADER_SIZE;
- kev_msg.dv[1].data_length = 0;
+static int
+dlil_event_internal(struct ifnet *ifp, struct kev_msg *event)
+{
+ struct ifnet_filter *filter;
+
+ if (ifp_use(ifp, kIfNetUseCount_MustNotBeZero) == 0) {
+ dlil_read_begin();
+
+ /* Pass the event to the interface filters */
+ TAILQ_FOREACH(filter, &ifp->if_flt_head, filt_next) {
+ if (filter->filt_event)
+ filter->filt_event(filter->filt_cookie, ifp, filter->filt_protocol, event);
+ }
+
+ if (ifp->if_proto_hash) {
+ int i;
+
+ for (i = 0; i < PROTO_HASH_SLOTS; i++) {
+ struct if_proto *proto;
+
+ SLIST_FOREACH(proto, &ifp->if_proto_hash[i], next_hash) {
+ proto_media_event eventp = proto->proto_kpi == kProtoKPI_v1
+ ? proto->kpi.v1.event : proto->kpi.v2.event;
+
+ if (eventp)
+ eventp(ifp, proto->protocol_family, event);
+ }
+ }
+ }
+
+ dlil_read_end();
+
+ /* Pass the event to the interface */
+ if (ifp->if_event)
+ ifp->if_event(ifp, event);
+
+ if (ifp_unuse(ifp))
+ ifp_use_reached_zero(ifp);
+ }
+
+ return kev_post_msg(event);
+}
- kev_post_msg(&kev_msg);
+errno_t
+ifnet_event(
+ ifnet_t ifp,
+ struct kern_event_msg *event)
+{
+ struct kev_msg kev_msg;
+ int result = 0;
+
+ if (ifp == NULL || event == NULL) return EINVAL;
+
+ kev_msg.vendor_code = event->vendor_code;
+ kev_msg.kev_class = event->kev_class;
+ kev_msg.kev_subclass = event->kev_subclass;
+ kev_msg.event_code = event->event_code;
+ kev_msg.dv[0].data_ptr = &event->event_data[0];
+ kev_msg.dv[0].data_length = event->total_size - KEV_MSG_HEADER_SIZE;
+ kev_msg.dv[1].data_length = 0;
+
+ result = dlil_event_internal(ifp, &kev_msg);
- (void) thread_funnel_set(network_flock, funnel_state);
- return 0;
+ return result;
}
+#if CONFIG_MACF_NET
+#include <netinet/ip6.h>
+#include <netinet/ip.h>
+static int dlil_get_socket_type(struct mbuf **mp, int family, int raw)
+{
+ struct mbuf *m;
+ struct ip *ip;
+ struct ip6_hdr *ip6;
+ int type = SOCK_RAW;
+
+ if (!raw) {
+ switch (family) {
+ case PF_INET:
+ m = m_pullup(*mp, sizeof(struct ip));
+ if (m == NULL)
+ break;
+ *mp = m;
+ ip = mtod(m, struct ip *);
+ if (ip->ip_p == IPPROTO_TCP)
+ type = SOCK_STREAM;
+ else if (ip->ip_p == IPPROTO_UDP)
+ type = SOCK_DGRAM;
+ break;
+ case PF_INET6:
+ m = m_pullup(*mp, sizeof(struct ip6_hdr));
+ if (m == NULL)
+ break;
+ *mp = m;
+ ip6 = mtod(m, struct ip6_hdr *);
+ if (ip6->ip6_nxt == IPPROTO_TCP)
+ type = SOCK_STREAM;
+ else if (ip6->ip6_nxt == IPPROTO_UDP)
+ type = SOCK_DGRAM;
+ break;
+ }
+ }
+ return (type);
+}
+#endif
+#if 0
int
-dlil_output(u_long dl_tag,
- struct mbuf *m,
- caddr_t route,
- struct sockaddr *dest,
- int raw
- )
+dlil_output_list(
+ struct ifnet* ifp,
+ u_long proto_family,
+ struct mbuf *packetlist,
+ caddr_t route,
+ const struct sockaddr *dest,
+ int raw)
{
- char *frame_type;
- char *dst_linkaddr;
- struct ifnet *orig_ifp = 0;
- struct ifnet *ifp;
- struct if_proto *proto;
- struct dlil_filterq_entry *tmp;
- int retval = 0;
- char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
- char dst_linkaddr_buffer[MAX_LINKADDR * 4];
- struct dlil_filterq_head *fhead;
-
- KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_START,0,0,0,0,0);
-
- if (dl_tag >= dl_tag_nb || dl_tag_array[dl_tag].ifp == 0) {
- m_freem(m);
- return ENOENT;
- }
+ char *frame_type = NULL;
+ char *dst_linkaddr = NULL;
+ int retval = 0;
+ char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
+ char dst_linkaddr_buffer[MAX_LINKADDR * 4];
+ struct ifnet_filter *filter;
+ struct if_proto *proto = 0;
+ mbuf_t m;
+ mbuf_t send_head = NULL;
+ mbuf_t *send_tail = &send_head;
+
+ KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_START,0,0,0,0,0);
+
+ dlil_read_begin();
+
+ frame_type = frame_type_buffer;
+ dst_linkaddr = dst_linkaddr_buffer;
+
+ if (raw == 0) {
+ proto = find_attached_proto(ifp, proto_family);
+ if (proto == NULL) {
+ retval = ENXIO;
+ goto cleanup;
+ }
+ }
+
+preout_again:
+ if (packetlist == NULL)
+ goto cleanup;
+ m = packetlist;
+ packetlist = packetlist->m_nextpkt;
+ m->m_nextpkt = NULL;
+
+ if (raw == 0) {
+ proto_media_preout preoutp = proto->proto_kpi == kProtoKPI_v1
+ ? proto->kpi.v1.pre_output : proto->kpi.v2.pre_output;
+ retval = 0;
+ if (preoutp)
+ retval = preoutp(ifp, proto_family, &m, dest, route, frame_type, dst_linkaddr);
+
+ if (retval) {
+ if (retval == EJUSTRETURN) {
+ goto preout_again;
+ }
+
+ m_freem(m);
+ goto cleanup;
+ }
+ }
- ifp = dl_tag_array[dl_tag].ifp;
- proto = dl_tag_array[dl_tag].proto;
+ do {
+#if CONFIG_MACF_NET
+ retval = mac_ifnet_check_transmit(ifp, m, proto_family,
+ dlil_get_socket_type(&m, proto_family, raw));
+ if (retval) {
+ m_freem(m);
+ goto cleanup;
+ }
+#endif
+
+ if (raw == 0 && ifp->if_framer) {
+ retval = ifp->if_framer(ifp, &m, dest, dst_linkaddr, frame_type);
+ if (retval) {
+ if (retval != EJUSTRETURN) {
+ m_freem(m);
+ }
+ goto next;
+ }
+ }
+
+#if BRIDGE
+ /* !!!LOCKING!!!
+ *
+ * Need to consider how to handle this.
+ * Also note that return should be a goto cleanup
+ */
+ broken-locking
+ if (do_bridge) {
+ struct mbuf *m0 = m;
+ struct ether_header *eh = mtod(m, struct ether_header *);
+
+ if (m->m_pkthdr.rcvif)
+ m->m_pkthdr.rcvif = NULL;
+ ifp = bridge_dst_lookup(eh);
+ bdg_forward(&m0, ifp);
+ if (m0)
+ m_freem(m0);
+
+ return 0 - should be goto cleanup?
+ }
+#endif
- frame_type = frame_type_buffer;
- dst_linkaddr = dst_linkaddr_buffer;
+ /*
+ * Let interface filters (if any) do their thing ...
+ */
+ /* Do not pass VLAN tagged packets to filters PR-3586856 */
+ if ((m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) == 0) {
+ TAILQ_FOREACH(filter, &ifp->if_flt_head, filt_next) {
+ if ((filter->filt_protocol == 0 || (filter->filt_protocol == proto_family)) &&
+ filter->filt_output) {
+ retval = filter->filt_output(filter->filt_cookie, ifp, proto_family, &m);
+ if (retval) {
+ if (retval != EJUSTRETURN)
+ m_freem(m);
+ goto next;
+ }
+ }
+ }
+ }
+
+ /*
+ * Finally, call the driver.
+ */
+
+ if ((ifp->if_eflags & IFEF_SENDLIST) != 0) {
+ *send_tail = m;
+ send_tail = &m->m_nextpkt;
+ }
+ else {
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_START, 0,0,0,0,0);
+ retval = ifp->if_output(ifp, m);
+ if (retval) {
+ printf("dlil_output: output error retval = %x\n", retval);
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
+next:
+ m = packetlist;
+ if (m) {
+ packetlist = packetlist->m_nextpkt;
+ m->m_nextpkt = NULL;
+ }
+ } while (m);
- if ((raw == 0) && (proto->dl_pre_output)) {
- retval = (*proto->dl_pre_output)(ifp, &m, dest, route,
- frame_type, dst_linkaddr, dl_tag);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
+ if (send_head) {
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_START, 0,0,0,0,0);
+ retval = ifp->if_output(ifp, send_head);
+ if (retval) {
+ printf("dlil_output: output error retval = %x\n", retval);
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
}
- }
-
+
+ KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_END,0,0,0,0,0);
+
+cleanup:
+ dlil_read_end();
+ if (packetlist) /* if any packet left, clean up */
+ mbuf_freem_list(packetlist);
+ if (retval == EJUSTRETURN)
+ retval = 0;
+ return retval;
+}
+#endif
+
/*
- * Run any attached protocol filters.
+ * dlil_output
+ *
+ * Caller should have a lock on the protocol domain if the protocol
+ * doesn't support finer grained locking. In most cases, the lock
+ * will be held from the socket layer and won't be released until
+ * we return back to the socket layer.
+ *
+ * This does mean that we must take a protocol lock before we take
+ * an interface lock if we're going to take both. This makes sense
+ * because a protocol is likely to interact with an ifp while it
+ * is under the protocol lock.
*/
-
- if (TAILQ_EMPTY(dl_tag_array[dl_tag].pr_flt_head) == 0) {
- TAILQ_FOREACH(tmp, dl_tag_array[dl_tag].pr_flt_head, que) {
- if (PFILT(tmp).filter_dl_output) {
- retval = (*PFILT(tmp).filter_dl_output)(PFILT(tmp).cookie,
- &m, &ifp, &dest, dst_linkaddr, frame_type);
+__private_extern__ errno_t
+dlil_output(
+ ifnet_t ifp,
+ protocol_family_t proto_family,
+ mbuf_t packetlist,
+ void *route,
+ const struct sockaddr *dest,
+ int raw)
+{
+ char *frame_type = NULL;
+ char *dst_linkaddr = NULL;
+ int retval = 0;
+ char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
+ char dst_linkaddr_buffer[MAX_LINKADDR * 4];
+ struct ifnet_filter *filter;
+ struct if_proto *proto = 0;
+ mbuf_t m;
+ mbuf_t send_head = NULL;
+ mbuf_t *send_tail = &send_head;
+
+ KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_START,0,0,0,0,0);
+
+ dlil_read_begin();
+
+ frame_type = frame_type_buffer;
+ dst_linkaddr = dst_linkaddr_buffer;
+
+ if (raw == 0) {
+ proto = find_attached_proto(ifp, proto_family);
+ if (proto == NULL) {
+ retval = ENXIO;
+ goto cleanup;
+ }
+ }
+
+preout_again:
+ if (packetlist == NULL)
+ goto cleanup;
+ m = packetlist;
+ packetlist = packetlist->m_nextpkt;
+ m->m_nextpkt = NULL;
+
+ if (raw == 0) {
+ proto_media_preout preoutp = proto->proto_kpi == kProtoKPI_v1
+ ? proto->kpi.v1.pre_output : proto->kpi.v2.pre_output;
+ retval = 0;
+ if (preoutp)
+ retval = preoutp(ifp, proto_family, &m, dest, route, frame_type, dst_linkaddr);
+
if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
+ if (retval == EJUSTRETURN) {
+ goto preout_again;
+ }
+
m_freem(m);
- return retval;
- }
+ goto cleanup;
}
- }
}
- }
-
-/*
- * Call framing module
- */
- if ((raw == 0) && (ifp->if_framer)) {
- retval = (*ifp->if_framer)(ifp, &m, dest, dst_linkaddr, frame_type);
+#if CONFIG_MACF_NET
+ retval = mac_ifnet_check_transmit(ifp, m, proto_family,
+ dlil_get_socket_type(&m, proto_family, raw));
if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else
- {
m_freem(m);
- return retval;
- }
+ goto cleanup;
}
- }
+#endif
-#if BRIDGE
- if (do_bridge) {
- struct mbuf *m0 = m ;
- struct ether_header *eh = mtod(m, struct ether_header *);
+ do {
+ if (raw == 0 && ifp->if_framer) {
+ retval = ifp->if_framer(ifp, &m, dest, dst_linkaddr, frame_type);
+ if (retval) {
+ if (retval != EJUSTRETURN) {
+ m_freem(m);
+ }
+ goto next;
+ }
+ }
- if (m->m_pkthdr.rcvif)
- m->m_pkthdr.rcvif = NULL ;
- ifp = bridge_dst_lookup(eh);
- bdg_forward(&m0, ifp);
- if (m0)
- m_freem(m0);
-
- return 0;
- }
+#if BRIDGE
+ /* !!!LOCKING!!!
+ *
+ * Need to consider how to handle this.
+ * Also note that return should be a goto cleanup
+ */
+ broken-locking
+ if (do_bridge) {
+ struct mbuf *m0 = m;
+ struct ether_header *eh = mtod(m, struct ether_header *);
+
+ if (m->m_pkthdr.rcvif)
+ m->m_pkthdr.rcvif = NULL;
+ ifp = bridge_dst_lookup(eh);
+ bdg_forward(&m0, ifp);
+ if (m0)
+ m_freem(m0);
+
+ return 0 - should be goto cleanup?
+ }
#endif
-
-/*
- * Let interface filters (if any) do their thing ...
- */
-
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- if (TAILQ_EMPTY(fhead) == 0) {
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
- TAILQ_FOREACH(tmp, fhead, que) {
- if (IFILT(tmp).filter_if_output) {
- retval = (*IFILT(tmp).filter_if_output)(IFILT(tmp).cookie,
- &ifp,
- &m);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
+ /*
+ * Let interface filters (if any) do their thing ...
+ */
+ /* Do not pass VLAN tagged packets to filters PR-3586856 */
+ if ((m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) == 0) {
+ TAILQ_FOREACH(filter, &ifp->if_flt_head, filt_next) {
+ if ((filter->filt_protocol == 0 || (filter->filt_protocol == proto_family)) &&
+ filter->filt_output) {
+ retval = filter->filt_output(filter->filt_cookie, ifp, proto_family, &m);
+ if (retval) {
+ if (retval != EJUSTRETURN)
+ m_freem(m);
+ goto next;
+ }
+ }
}
- }
+ }
+ /*
+ * If the underlying interface is not capable of handling a
+ * packet whose data portion spans across physically disjoint
+ * pages, we need to "normalize" the packet so that we pass
+ * down a chain of mbufs where each mbuf points to a span that
+ * resides in the system page boundary. If the packet does
+ * not cross page(s), the following is a no-op.
+ */
+ if (!(ifp->if_hwassist & IFNET_MULTIPAGES)) {
+ if ((m = m_normalize(m)) == NULL)
+ goto next;
}
-
- if (ifp != orig_ifp)
- break;
- }
- }
- }
-/*
- * Finally, call the driver.
- */
+ /*
+ * Finally, call the driver.
+ */
+
+ if ((ifp->if_eflags & IFEF_SENDLIST) != 0) {
+ *send_tail = m;
+ send_tail = &m->m_nextpkt;
+ }
+ else {
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_START, 0,0,0,0,0);
+ retval = ifp->if_output(ifp, m);
+ if (retval) {
+ printf("dlil_output: output error retval = %x\n", retval);
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
- KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_START, 0,0,0,0,0);
- retval = (*ifp->if_output)(ifp, m);
- KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
+next:
+ m = packetlist;
+ if (m) {
+ packetlist = packetlist->m_nextpkt;
+ m->m_nextpkt = NULL;
+ }
+ } while (m);
- KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_END,0,0,0,0,0);
+ if (send_head) {
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_START, 0,0,0,0,0);
+ retval = ifp->if_output(ifp, send_head);
+ if (retval) {
+ printf("dlil_output: output error retval = %x\n", retval);
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
+ }
+
+ KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_END,0,0,0,0,0);
- if ((retval == 0) || (retval == EJUSTRETURN))
- return 0;
- else
+cleanup:
+ dlil_read_end();
+ if (packetlist) /* if any packet left, clean up */
+ mbuf_freem_list(packetlist);
+ if (retval == EJUSTRETURN)
+ retval = 0;
return retval;
}
-
-int
-dlil_ioctl(u_long proto_fam,
- struct ifnet *ifp,
- u_long ioctl_code,
- caddr_t ioctl_arg)
+errno_t
+ifnet_ioctl(
+ ifnet_t ifp,
+ protocol_family_t proto_fam,
+ u_int32_t ioctl_code,
+ void *ioctl_arg)
{
- struct dlil_filterq_entry *tmp;
- struct dlil_filterq_head *fhead;
- int retval = EOPNOTSUPP;
- int retval2 = EOPNOTSUPP;
- u_long dl_tag;
- struct if_family_str *if_family;
-
+ struct ifnet_filter *filter;
+ int retval = EOPNOTSUPP;
+ int result = 0;
+ int holding_read = 0;
+
+ if (ifp == NULL || ioctl_code == 0)
+ return EINVAL;
+
+ /* Attempt to increment the use count. If it's zero, bail out, the ifp is invalid */
+ result = ifp_use(ifp, kIfNetUseCount_MustNotBeZero);
+ if (result != 0)
+ return EOPNOTSUPP;
+
+ dlil_read_begin();
+ holding_read = 1;
+
+ /* Run the interface filters first.
+ * We want to run all filters before calling the protocol,
+ * interface family, or interface.
+ */
+ TAILQ_FOREACH(filter, &ifp->if_flt_head, filt_next) {
+ if ((filter->filt_protocol == 0 || (filter->filt_protocol == proto_fam)) &&
+ filter->filt_ioctl != NULL) {
+ result = filter->filt_ioctl(filter->filt_cookie, ifp, proto_fam, ioctl_code, ioctl_arg);
+ /* Only update retval if no one has handled the ioctl */
+ if (retval == EOPNOTSUPP || result == EJUSTRETURN) {
+ if (result == ENOTSUP)
+ result = EOPNOTSUPP;
+ retval = result;
+ if (retval && retval != EOPNOTSUPP) {
+ goto cleanup;
+ }
+ }
+ }
+ }
+
+ /* Allow the protocol to handle the ioctl */
+ if (proto_fam) {
+ struct if_proto *proto = find_attached_proto(ifp, proto_fam);
+
+ if (proto != 0) {
+ proto_media_ioctl ioctlp = proto->proto_kpi == kProtoKPI_v1
+ ? proto->kpi.v1.ioctl : proto->kpi.v2.ioctl;
+ result = EOPNOTSUPP;
+ if (ioctlp)
+ result = ioctlp(ifp, proto_fam, ioctl_code, ioctl_arg);
+
+ /* Only update retval if no one has handled the ioctl */
+ if (retval == EOPNOTSUPP || result == EJUSTRETURN) {
+ if (result == ENOTSUP)
+ result = EOPNOTSUPP;
+ retval = result;
+ if (retval && retval != EOPNOTSUPP) {
+ goto cleanup;
+ }
+ }
+ }
+ }
+
+ /*
+ * Since we have incremented the use count on the ifp, we are guaranteed
+ * that the ifp will not go away (the function pointers may not be changed).
+ * We release the dlil read lock so the interface ioctl may trigger a
+ * protocol attach. This happens with vlan and may occur with other virtual
+ * interfaces.
+ */
+ dlil_read_end();
+ holding_read = 0;
+
+ /* retval is either 0 or EOPNOTSUPP */
+
+ /*
+ * Let the interface handle this ioctl.
+ * If it returns EOPNOTSUPP, ignore that, we may have
+ * already handled this in the protocol or family.
+ */
+ if (ifp->if_ioctl)
+ result = (*ifp->if_ioctl)(ifp, ioctl_code, ioctl_arg);
+
+ /* Only update retval if no one has handled the ioctl */
+ if (retval == EOPNOTSUPP || result == EJUSTRETURN) {
+ if (result == ENOTSUP)
+ result = EOPNOTSUPP;
+ retval = result;
+ if (retval && retval != EOPNOTSUPP) {
+ goto cleanup;
+ }
+ }
+
+cleanup:
+ if (holding_read)
+ dlil_read_end();
+ if (ifp_unuse(ifp))
+ ifp_use_reached_zero(ifp);
- if (proto_fam) {
- retval = dlil_find_dltag(ifp->if_family, ifp->if_unit,
- proto_fam, &dl_tag);
+ if (retval == EJUSTRETURN)
+ retval = 0;
+ return retval;
+}
- if (retval == 0) {
- if (dl_tag_array[dl_tag].ifp != ifp)
- return ENOENT;
+__private_extern__ errno_t
+dlil_set_bpf_tap(
+ ifnet_t ifp,
+ bpf_tap_mode mode,
+ bpf_packet_func callback)
+{
+ errno_t error = 0;
-/*
- * Run any attached protocol filters.
- */
- TAILQ_FOREACH(tmp, dl_tag_array[dl_tag].pr_flt_head, que) {
- if (PFILT(tmp).filter_dl_ioctl) {
- retval =
- (*PFILT(tmp).filter_dl_ioctl)(PFILT(tmp).cookie,
- dl_tag_array[dl_tag].ifp,
- ioctl_code,
- ioctl_arg);
-
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
- }
- }
-
- if (dl_tag_array[dl_tag].proto->dl_ioctl)
- retval =
- (*dl_tag_array[dl_tag].proto->dl_ioctl)(dl_tag,
- dl_tag_array[dl_tag].ifp,
- ioctl_code,
- ioctl_arg);
- else
- retval = EOPNOTSUPP;
- }
- else
- retval = 0;
- }
-
- if ((retval) && (retval != EOPNOTSUPP)) {
- if (retval == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
-
-
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- TAILQ_FOREACH(tmp, fhead, que) {
- if (IFILT(tmp).filter_if_ioctl) {
- retval2 = (*IFILT(tmp).filter_if_ioctl)(IFILT(tmp).cookie, ifp,
- ioctl_code, ioctl_arg);
- if (retval2) {
- if (retval2 == EJUSTRETURN)
- return 0;
- else
- return retval2;
- }
- }
- }
-
-
- if_family = find_family_module(ifp->if_family);
- if ((if_family) && (if_family->ifmod_ioctl)) {
- retval2 = (*if_family->ifmod_ioctl)(ifp, ioctl_code, ioctl_arg);
-
- if ((retval2) && (retval2 != EOPNOTSUPP)) {
- if (retval2 == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
-
- if (retval == EOPNOTSUPP)
- retval = retval2;
- }
-
- if (ifp->if_ioctl)
- retval2 = (*ifp->if_ioctl)(ifp, ioctl_code, ioctl_arg);
-
- if (retval == EOPNOTSUPP)
- return retval2;
- else {
- if (retval2 == EOPNOTSUPP)
- return 0;
- else
- return retval2;
- }
+ dlil_read_begin();
+ if (ifp->if_set_bpf_tap)
+ error = ifp->if_set_bpf_tap(ifp, mode, callback);
+ dlil_read_end();
+
+ return error;
}
-
-int
-dlil_attach_protocol(struct dlil_proto_reg_str *proto,
- u_long *dl_tag)
+errno_t
+dlil_resolve_multi(
+ struct ifnet *ifp,
+ const struct sockaddr *proto_addr,
+ struct sockaddr *ll_addr,
+ size_t ll_len)
{
- struct ifnet *ifp;
- struct if_proto *ifproto;
- u_long i;
- struct if_family_str *if_family;
- struct dlil_proto_head *tmp;
- struct kev_dl_proto_data ev_pr_data;
- int s, retval = 0;
- boolean_t funnel_state;
- u_char *p;
-
- if ((proto->protocol_family == 0) || (proto->interface_family == 0))
- return EINVAL;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
- if_family = find_family_module(proto->interface_family);
- if ((!if_family) || (if_family->flags & DLIL_SHUTDOWN)) {
- kprintf("dlil_attach_protocol -- no interface family module %d",
- proto->interface_family);
- retval = ENOENT;
- goto end;
- }
-
- ifp = ifbyfamily(proto->interface_family, proto->unit_number);
- if (!ifp) {
- kprintf("dlil_attach_protocol -- no such interface %d unit %d\n",
- proto->interface_family, proto->unit_number);
- retval = ENOENT;
- goto end;
- }
-
- if (dlil_find_dltag(proto->interface_family, proto->unit_number,
- proto->protocol_family, &i) == 0) {
- retval = EEXIST;
- goto end;
- }
-
- for (i=1; i < dl_tag_nb; i++)
- if (dl_tag_array[i].ifp == 0)
- break;
-
- if (i == dl_tag_nb) {
- // expand the tag array by MAX_DL_TAGS
- MALLOC(p, u_char *, sizeof(struct dl_tag_str) * (dl_tag_nb + MAX_DL_TAGS), M_NKE, M_WAITOK);
- if (p == 0) {
- retval = ENOBUFS;
- goto end;
- }
- bcopy(dl_tag_array, p, sizeof(struct dl_tag_str) * dl_tag_nb);
- bzero(p + sizeof(struct dl_tag_str) * dl_tag_nb, sizeof(struct dl_tag_str) * MAX_DL_TAGS);
- dl_tag_nb += MAX_DL_TAGS;
- FREE(dl_tag_array, M_NKE);
- dl_tag_array = (struct dl_tag_str *)p;
- }
-
- /*
- * Allocate and init a new if_proto structure
- */
-
- ifproto = _MALLOC(sizeof(struct if_proto), M_IFADDR, M_WAITOK);
- if (!ifproto) {
- printf("ERROR - DLIL failed if_proto allocation\n");
- retval = ENOMEM;
- goto end;
- }
-
- bzero(ifproto, sizeof(struct if_proto));
-
- dl_tag_array[i].ifp = ifp;
- dl_tag_array[i].proto = ifproto;
- dl_tag_array[i].pr_flt_head = &ifproto->pr_flt_head;
- ifproto->dl_tag = i;
- *dl_tag = i;
-
- if (proto->default_proto) {
- if (ifp->if_data.default_proto == 0)
- ifp->if_data.default_proto = i;
- else
- printf("ERROR - dlil_attach_protocol -- Attempt to attach more than one default protocol\n");
- }
-
- ifproto->protocol_family = proto->protocol_family;
- ifproto->dl_input = proto->input;
- ifproto->dl_pre_output = proto->pre_output;
- ifproto->dl_event = proto->event;
- ifproto->dl_offer = proto->offer;
- ifproto->dl_ioctl = proto->ioctl;
- ifproto->ifp = ifp;
- TAILQ_INIT(&ifproto->pr_flt_head);
-
- /*
- * Call family module add_proto routine so it can refine the
- * demux descriptors as it wishes.
- */
- retval = (*if_family->add_proto)(&proto->demux_desc_head, ifproto, *dl_tag);
- if (retval) {
- dl_tag_array[i].ifp = 0;
- FREE(ifproto, M_IFADDR);
- goto end;
- }
-
- /*
- * Add to if_proto list for this interface
- */
-
- tmp = (struct dlil_proto_head *) &ifp->proto_head;
- TAILQ_INSERT_TAIL(tmp, ifproto, next);
- ifp->refcnt++;
- if (ifproto->dl_offer)
- ifp->offercnt++;
-
- /* the reserved field carries the number of protocol still attached (subject to change) */
- ev_pr_data.proto_family = proto->protocol_family;
- ev_pr_data.proto_remaining_count = dlil_ifp_proto_count(ifp);
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_PROTO_ATTACHED,
- (struct net_event_data *)&ev_pr_data,
- sizeof(struct kev_dl_proto_data));
-
-end:
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
+ errno_t result = EOPNOTSUPP;
+ struct if_proto *proto;
+ const struct sockaddr *verify;
+ proto_media_resolve_multi resolvep;
+
+ dlil_read_begin();
+
+ bzero(ll_addr, ll_len);
+
+ /* Call the protocol first */
+ proto = find_attached_proto(ifp, proto_addr->sa_family);
+ if (proto != NULL) {
+ resolvep = proto->proto_kpi == kProtoKPI_v1
+ ? proto->kpi.v1.resolve_multi : proto->kpi.v2.resolve_multi;
+ if (resolvep != NULL)
+ result = resolvep(ifp, proto_addr,(struct sockaddr_dl*)ll_addr,
+ ll_len);
+ }
+
+ /* Let the interface verify the multicast address */
+ if ((result == EOPNOTSUPP || result == 0) && ifp->if_check_multi) {
+ if (result == 0)
+ verify = ll_addr;
+ else
+ verify = proto_addr;
+ result = ifp->if_check_multi(ifp, verify);
+ }
+
+ dlil_read_end();
+
+ return result;
}
-
-
-int
-dlil_detach_protocol(u_long dl_tag)
+__private_extern__ errno_t
+dlil_send_arp_internal(
+ ifnet_t ifp,
+ u_short arpop,
+ const struct sockaddr_dl* sender_hw,
+ const struct sockaddr* sender_proto,
+ const struct sockaddr_dl* target_hw,
+ const struct sockaddr* target_proto)
{
- struct ifnet *ifp;
- struct ifnet *orig_ifp=0;
- struct if_proto *proto;
- struct dlil_proto_head *tmp;
- struct if_family_str *if_family;
- struct dlil_filterq_entry *filter;
- int s, retval = 0;
- struct dlil_filterq_head *fhead;
- struct kev_dl_proto_data ev_pr_data;
- boolean_t funnel_state;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
-
- if (dl_tag >= dl_tag_nb || dl_tag_array[dl_tag].ifp == 0) {
- retval = ENOENT;
- goto end;
- }
-
- ifp = dl_tag_array[dl_tag].ifp;
- proto = dl_tag_array[dl_tag].proto;
-
- if_family = find_family_module(ifp->if_family);
- if (if_family == NULL) {
- retval = ENOENT;
- goto end;
- }
-
- tmp = (struct dlil_proto_head *) &ifp->proto_head;
-
- /*
- * Call family module del_proto
- */
-
- (*if_family->del_proto)(proto, dl_tag);
-
-
- /*
- * Remove and deallocate any attached protocol filters
- */
-
- while (filter = TAILQ_FIRST(&proto->pr_flt_head))
- dlil_detach_filter(filter->filter_id);
-
- if (proto->dl_offer)
- ifp->offercnt--;
-
- if (ifp->if_data.default_proto == dl_tag)
- ifp->if_data.default_proto = 0;
- dl_tag_array[dl_tag].ifp = 0;
+ struct if_proto *proto;
+ errno_t result = 0;
- /* the reserved field carries the number of protocol still attached (subject to change) */
- ev_pr_data.proto_family = proto->protocol_family;
-
- /*
- * Cleanup routes that may still be in the routing table for that interface/protocol pair.
- */
-
- if_rtproto_del(ifp, proto->protocol_family);
-
- TAILQ_REMOVE(tmp, proto, next);
- FREE(proto, M_IFADDR);
-
- ifp->refcnt--;
- ev_pr_data.proto_remaining_count = dlil_ifp_proto_count(ifp);
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_PROTO_DETACHED,
- (struct net_event_data *)&ev_pr_data,
- sizeof(struct kev_dl_proto_data));
-
- if (ifp->refcnt == 0) {
-
- TAILQ_REMOVE(&ifnet, ifp, if_link);
-
- (*if_family->del_if)(ifp);
-
- if (--if_family->refcnt == 0) {
- if (if_family->shutdown)
- (*if_family->shutdown)();
-
- TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
- FREE(if_family, M_IFADDR);
+ dlil_read_begin();
+
+ proto = find_attached_proto(ifp, target_proto->sa_family);
+ if (proto == NULL) {
+ result = ENOTSUP;
}
+ else {
+ proto_media_send_arp arpp;
+ arpp = proto->proto_kpi == kProtoKPI_v1
+ ? proto->kpi.v1.send_arp : proto->kpi.v2.send_arp;
+ if (arpp == NULL)
+ result = ENOTSUP;
+ else
+ result = arpp(ifp, arpop, sender_hw, sender_proto, target_hw,
+ target_proto);
+ }
+
+ dlil_read_end();
+
+ return result;
+}
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
+static __inline__ int
+_is_announcement(const struct sockaddr_in * sender_sin,
+ const struct sockaddr_in * target_sin)
+{
+ if (sender_sin == NULL) {
+ return FALSE;
+ }
+ return (sender_sin->sin_addr.s_addr == target_sin->sin_addr.s_addr);
+}
- TAILQ_FOREACH(filter, fhead, que) {
- if (IFILT(filter).filter_if_free) {
- retval = (*IFILT(filter).filter_if_free)(IFILT(filter).cookie, ifp);
- if (retval) {
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
- }
+__private_extern__ errno_t
+dlil_send_arp(
+ ifnet_t ifp,
+ u_short arpop,
+ const struct sockaddr_dl* sender_hw,
+ const struct sockaddr* sender_proto,
+ const struct sockaddr_dl* target_hw,
+ const struct sockaddr* target_proto)
+{
+ errno_t result = 0;
+ const struct sockaddr_in * sender_sin;
+ const struct sockaddr_in * target_sin;
+
+ if (target_proto == NULL || (sender_proto &&
+ sender_proto->sa_family != target_proto->sa_family))
+ return EINVAL;
+
+ /*
+ * If this is an ARP request and the target IP is IPv4LL,
+ * send the request on all interfaces. The exception is
+ * an announcement, which must only appear on the specific
+ * interface.
+ */
+ sender_sin = (const struct sockaddr_in *)sender_proto;
+ target_sin = (const struct sockaddr_in *)target_proto;
+ if (target_proto->sa_family == AF_INET
+ && IN_LINKLOCAL(ntohl(target_sin->sin_addr.s_addr))
+ && ipv4_ll_arp_aware != 0
+ && arpop == ARPOP_REQUEST
+ && !_is_announcement(target_sin, sender_sin)) {
+ ifnet_t *ifp_list;
+ u_int32_t count;
+ u_int32_t ifp_on;
+
+ result = ENOTSUP;
+
+ if (ifnet_list_get(IFNET_FAMILY_ANY, &ifp_list, &count) == 0) {
+ for (ifp_on = 0; ifp_on < count; ifp_on++) {
+ errno_t new_result;
+ ifaddr_t source_hw = NULL;
+ ifaddr_t source_ip = NULL;
+ struct sockaddr_in source_ip_copy;
+
+ /*
+ * Only arp on interfaces marked for IPv4LL ARPing. This may
+ * mean that we don't ARP on the interface the subnet route
+ * points to.
+ */
+ if ((ifp_list[ifp_on]->if_eflags & IFEF_ARPLL) == 0) {
+ continue;
+ }
+
+ source_hw = TAILQ_FIRST(&ifp_list[ifp_on]->if_addrhead);
+
+ /* Find the source IP address */
+ ifnet_lock_shared(ifp_list[ifp_on]);
+ TAILQ_FOREACH(source_ip, &ifp_list[ifp_on]->if_addrhead,
+ ifa_link) {
+ if (source_ip->ifa_addr &&
+ source_ip->ifa_addr->sa_family == AF_INET) {
+ break;
+ }
+ }
+
+ /* No IP Source, don't arp */
+ if (source_ip == NULL) {
+ ifnet_lock_done(ifp_list[ifp_on]);
+ continue;
+ }
+
+ /* Copy the source IP address */
+ source_ip_copy = *(struct sockaddr_in*)source_ip->ifa_addr;
+
+ ifnet_lock_done(ifp_list[ifp_on]);
+
+ /* Send the ARP */
+ new_result = dlil_send_arp_internal(ifp_list[ifp_on], arpop,
+ (struct sockaddr_dl*)source_hw->ifa_addr,
+ (struct sockaddr*)&source_ip_copy, NULL,
+ target_proto);
+
+ if (result == ENOTSUP) {
+ result = new_result;
+ }
+ }
}
- if (ifp != orig_ifp)
- break;
- }
+
+ ifnet_list_free(ifp_list);
+ }
+ else {
+ result = dlil_send_arp_internal(ifp, arpop, sender_hw, sender_proto,
+ target_hw, target_proto);
}
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHED, 0, 0);
-
- (*ifp->if_free)(ifp);
- }
-
-end:
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
+ return result;
}
-
-
-
-
-int
-dlil_if_attach(struct ifnet *ifp)
+__private_extern__ int
+ifp_use(
+ struct ifnet *ifp,
+ int handle_zero)
{
- u_long interface_family = ifp->if_family;
- struct if_family_str *if_family;
- struct dlil_proto_head *tmp;
- int stat;
- int s;
- boolean_t funnel_state;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
- if (ifnet_inited == 0) {
- TAILQ_INIT(&ifnet);
- ifnet_inited = 1;
- }
-
- if_family = find_family_module(interface_family);
-
- if ((!if_family) || (if_family->flags & DLIL_SHUTDOWN)) {
- splx(s);
- kprintf("Attempt to attach interface without family module - %d\n",
- interface_family);
- thread_funnel_set(network_flock, funnel_state);
- return ENODEV;
- }
-
- if (ifp->refcnt == 0) {
- /*
- * Call the family module to fill in the appropriate fields in the
- * ifnet structure.
- */
-
- stat = (*if_family->add_if)(ifp);
- if (stat) {
- splx(s);
- kprintf("dlil_if_attach -- add_if failed with %d\n", stat);
- thread_funnel_set(network_flock, funnel_state);
- return stat;
- }
- if_family->refcnt++;
-
- /*
- * Add the ifp to the interface list.
- */
-
- tmp = (struct dlil_proto_head *) &ifp->proto_head;
- TAILQ_INIT(tmp);
-
- ifp->if_data.default_proto = 0;
- ifp->offercnt = 0;
- TAILQ_INIT(&ifp->if_flt_head);
- old_if_attach(ifp);
-
- if (if_family->init_if) {
- stat = (*if_family->init_if)(ifp);
- if (stat) {
- kprintf("dlil_if_attach -- init_if failed with %d\n", stat);
- }
- }
- }
-
- ifp->refcnt++;
-
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_ATTACHED, 0, 0);
-
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
+ int old_value;
+ int retval = 0;
+
+ do {
+ old_value = ifp->if_usecnt;
+ if (old_value == 0 && handle_zero == kIfNetUseCount_MustNotBeZero) {
+ retval = ENXIO; // ifp is invalid
+ break;
+ }
+ } while (!OSCompareAndSwap((UInt32)old_value, (UInt32)old_value + 1, (UInt32*)&ifp->if_usecnt));
+
+ return retval;
}
-
-int
-dlil_if_detach(struct ifnet *ifp)
+/* ifp_unuse is broken into two pieces.
+ *
+ * ifp_use and ifp_unuse must be called between when the caller calls
+ * dlil_write_begin and dlil_write_end. ifp_unuse needs to perform some
+ * operations after dlil_write_end has been called. For this reason,
+ * anyone calling ifp_unuse must call ifp_use_reached_zero if ifp_unuse
+ * returns a non-zero value. The caller must call ifp_use_reached_zero
+ * after the caller has called dlil_write_end.
+ */
+__private_extern__ void
+ifp_use_reached_zero(
+ struct ifnet *ifp)
{
- struct if_proto *proto;
- struct dlil_filterq_entry *if_filter;
- struct if_family_str *if_family;
- struct dlil_filterq_head *fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- int s;
- struct kev_msg ev_msg;
- boolean_t funnel_state;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
-
- if_family = find_family_module(ifp->if_family);
-
- if (!if_family) {
- kprintf("Attempt to detach interface without family module - %s\n",
- ifp->if_name);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENODEV;
- }
-
- while (if_filter = TAILQ_FIRST(fhead))
- dlil_detach_filter(if_filter->filter_id);
-
- ifp->refcnt--;
-
- if (ifp->refcnt == 0) {
- /* Let BPF know the interface is detaching. */
- bpfdetach(ifp);
- TAILQ_REMOVE(&ifnet, ifp, if_link);
+ ifnet_detached_func free_func;
- (*if_family->del_if)(ifp);
-
- if (--if_family->refcnt == 0) {
- if (if_family->shutdown)
- (*if_family->shutdown)();
-
- TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
- FREE(if_family, M_IFADDR);
+ dlil_read_begin();
+
+ if (ifp->if_usecnt != 0)
+ panic("ifp_use_reached_zero: ifp->if_usecnt != 0");
+
+ ifnet_head_lock_exclusive();
+ ifnet_lock_exclusive(ifp);
+
+ /* Remove ourselves from the list */
+ TAILQ_REMOVE(&ifnet_head, ifp, if_link);
+ ifnet_addrs[ifp->if_index - 1] = NULL;
+
+ /* ifp should be removed from the interface list */
+ while (ifp->if_multiaddrs.lh_first) {
+ struct ifmultiaddr *ifma = ifp->if_multiaddrs.lh_first;
+
+ /*
+ * When the interface is gone, we will no longer
+ * be listening on these multicasts. Various bits
+ * of the stack may be referencing these multicasts,
+ * release only our reference.
+ */
+ LIST_REMOVE(ifma, ifma_link);
+ ifma->ifma_ifp = NULL;
+ ifma_release(ifma);
}
+ ifnet_head_done();
+
+ ifp->if_eflags &= ~IFEF_DETACHING; // clear the detaching flag
+ ifnet_lock_done(ifp);
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHED, 0, 0);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
- }
- else
- {
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHING, 0, 0);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return DLIL_WAIT_FOR_FREE;
- }
+ free_func = ifp->if_free;
+ dlil_read_end();
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHED, NULL, 0);
+
+ if (free_func)
+ free_func(ifp);
}
-
-int
-dlil_reg_if_modules(u_long interface_family,
- struct dlil_ifmod_reg_str *ifmod)
+__private_extern__ int
+ifp_unuse(
+ struct ifnet *ifp)
{
- struct if_family_str *if_family;
- int s;
- boolean_t funnel_state;
-
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
- if (find_family_module(interface_family)) {
- kprintf("Attempt to register dlil family module more than once - %d\n",
- interface_family);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return EEXIST;
- }
+ int oldval;
+ oldval = OSDecrementAtomic((SInt32*)&ifp->if_usecnt);
+ if (oldval == 0)
+ panic("ifp_unuse: ifp(%s%d)->if_usecnt was zero\n", ifp->if_name, ifp->if_unit);
+
+ if (oldval > 1)
+ return 0;
+
+ if ((ifp->if_eflags & IFEF_DETACHING) == 0)
+ panic("ifp_unuse: use count reached zero but detching flag is not set!");
+
+ return 1; /* caller must call ifp_use_reached_zero */
+}
- if ((!ifmod->add_if) || (!ifmod->del_if) ||
- (!ifmod->add_proto) || (!ifmod->del_proto)) {
- kprintf("dlil_reg_if_modules passed at least one null pointer\n");
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return EINVAL;
- }
-
- /*
- * The following is a gross hack to keep from breaking
- * Vicomsoft's internet gateway on Jaguar. Vicomsoft
- * does not zero the reserved fields in dlil_ifmod_reg_str.
- * As a result, we have to zero any function that used to
- * be reserved fields at the time Vicomsoft built their
- * kext. Radar #2974305
- */
- if (ifmod->reserved[0] != 0 || ifmod->reserved[1] != 0 || ifmod->reserved[2]) {
- if (interface_family == 123) { /* Vicom */
- ifmod->init_if = 0;
- } else {
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return EINVAL;
- }
- }
+extern lck_mtx_t *domain_proto_mtx;
- if_family = (struct if_family_str *) _MALLOC(sizeof(struct if_family_str), M_IFADDR, M_WAITOK);
- if (!if_family) {
- kprintf("dlil_reg_if_modules failed allocation\n");
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOMEM;
- }
+static errno_t
+dlil_attach_protocol_internal(
+ struct if_proto *proto,
+ const struct ifnet_demux_desc *demux_list,
+ u_int32_t demux_count)
+{
+ struct kev_dl_proto_data ev_pr_data;
+ struct ifnet *ifp = proto->ifp;
+ int retval = 0;
+ u_long hash_value = proto_hash_value(proto->protocol_family);
- bzero(if_family, sizeof(struct if_family_str));
-
- if_family->if_family = interface_family & 0xffff;
- if_family->shutdown = ifmod->shutdown;
- if_family->add_if = ifmod->add_if;
- if_family->del_if = ifmod->del_if;
- if_family->init_if = ifmod->init_if;
- if_family->add_proto = ifmod->add_proto;
- if_family->del_proto = ifmod->del_proto;
- if_family->ifmod_ioctl = ifmod->ifmod_ioctl;
- if_family->refcnt = 1;
- if_family->flags = 0;
-
- TAILQ_INSERT_TAIL(&if_family_head, if_family, if_fam_next);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
+ /* setup some of the common values */
+ {
+ struct domain *dp;
+ lck_mtx_lock(domain_proto_mtx);
+ dp = domains;
+ while (dp && (protocol_family_t)dp->dom_family != proto->protocol_family)
+ dp = dp->dom_next;
+ proto->dl_domain = dp;
+ lck_mtx_unlock(domain_proto_mtx);
+ }
+
+ /*
+ * Take the write lock to protect readers and exclude other writers.
+ */
+ if ((retval = dlil_write_begin()) != 0) {
+ printf("dlil_attach_protocol_internal - dlil_write_begin returned %d\n", retval);
+ return retval;
+ }
+
+ /* Check that the interface isn't currently detaching */
+ ifnet_lock_shared(ifp);
+ if ((ifp->if_eflags & IFEF_DETACHING) != 0) {
+ ifnet_lock_done(ifp);
+ dlil_write_end();
+ return ENXIO;
+ }
+ ifnet_lock_done(ifp);
+
+ if (find_attached_proto(ifp, proto->protocol_family) != NULL) {
+ dlil_write_end();
+ return EEXIST;
+ }
+
+ /*
+ * Call family module add_proto routine so it can refine the
+ * demux descriptors as it wishes.
+ */
+ retval = ifp->if_add_proto(ifp, proto->protocol_family, demux_list, demux_count);
+ if (retval) {
+ dlil_write_end();
+ return retval;
+ }
+
+ /*
+ * We can't fail from this point on.
+ * Increment the number of uses (protocol attachments + interface attached).
+ */
+ ifp_use(ifp, kIfNetUseCount_MustNotBeZero);
+
+ /*
+ * Insert the protocol in the hash
+ */
+ {
+ struct if_proto* prev_proto = SLIST_FIRST(&ifp->if_proto_hash[hash_value]);
+ while (prev_proto && SLIST_NEXT(prev_proto, next_hash) != NULL)
+ prev_proto = SLIST_NEXT(prev_proto, next_hash);
+ if (prev_proto)
+ SLIST_INSERT_AFTER(prev_proto, proto, next_hash);
+ else
+ SLIST_INSERT_HEAD(&ifp->if_proto_hash[hash_value], proto, next_hash);
+ }
+
+ /*
+ * Add to if_proto list for this interface
+ */
+ if_proto_ref(proto);
+ dlil_write_end();
+
+ /* the reserved field carries the number of protocol still attached (subject to change) */
+ ev_pr_data.proto_family = proto->protocol_family;
+ ev_pr_data.proto_remaining_count = dlil_ifp_proto_count(ifp);
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_PROTO_ATTACHED,
+ (struct net_event_data *)&ev_pr_data,
+ sizeof(struct kev_dl_proto_data));
+#if 0
+ DLIL_PRINTF("dlil. Attached protocol %d to %s%d - %d\n", proto->protocol_family,
+ ifp->if_name, ifp->if_unit, retval);
+#endif
+ return retval;
}
-int dlil_dereg_if_modules(u_long interface_family)
+errno_t
+ifnet_attach_protocol(ifnet_t ifp, protocol_family_t protocol,
+ const struct ifnet_attach_proto_param *proto_details)
{
- struct if_family_str *if_family;
- int s, ret = 0;
- boolean_t funnel_state;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
- if_family = find_family_module(interface_family);
- if (if_family == 0) {
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOENT;
- }
-
- if (--if_family->refcnt == 0) {
- if (if_family->shutdown)
- (*if_family->shutdown)();
+ int retval = 0;
+ struct if_proto *ifproto = NULL;
- TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
- FREE(if_family, M_IFADDR);
- }
- else {
- if_family->flags |= DLIL_SHUTDOWN;
- ret = DLIL_WAIT_FOR_FREE;
- }
-
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ret;
+ if (ifp == NULL || protocol == 0 || proto_details == NULL)
+ return EINVAL;
+
+ ifproto = _MALLOC(sizeof(struct if_proto), M_IFADDR, M_WAITOK);
+ if (ifproto == 0) {
+ DLIL_PRINTF("ERROR - dlil failed if_proto allocation\n");
+ retval = ENOMEM;
+ goto end;
+ }
+ bzero(ifproto, sizeof(*ifproto));
+
+ ifproto->ifp = ifp;
+ ifproto->protocol_family = protocol;
+ ifproto->proto_kpi = kProtoKPI_v1;
+ ifproto->kpi.v1.input = proto_details->input;
+ ifproto->kpi.v1.pre_output = proto_details->pre_output;
+ ifproto->kpi.v1.event = proto_details->event;
+ ifproto->kpi.v1.ioctl = proto_details->ioctl;
+ ifproto->kpi.v1.detached = proto_details->detached;
+ ifproto->kpi.v1.resolve_multi = proto_details->resolve;
+ ifproto->kpi.v1.send_arp = proto_details->send_arp;
+
+ retval = dlil_attach_protocol_internal(ifproto,
+ proto_details->demux_list, proto_details->demux_count);
+
+end:
+ if (retval && ifproto)
+ FREE(ifproto, M_IFADDR);
+ return retval;
}
-
-
-
-
-/*
- * Old if_attach no-op'ed function defined here for temporary backwards compatibility
- */
-
-void if_attach(ifp)
- struct ifnet *ifp;
+errno_t
+ifnet_attach_protocol_v2(ifnet_t ifp, protocol_family_t protocol,
+ const struct ifnet_attach_proto_param_v2 *proto_details)
{
- dlil_if_attach(ifp);
+ int retval = 0;
+ struct if_proto *ifproto = NULL;
+
+ if (ifp == NULL || protocol == 0 || proto_details == NULL)
+ return EINVAL;
+
+ ifproto = _MALLOC(sizeof(struct if_proto), M_IFADDR, M_WAITOK);
+ if (ifproto == 0) {
+ DLIL_PRINTF("ERROR - dlil failed if_proto allocation\n");
+ retval = ENOMEM;
+ goto end;
+ }
+ bzero(ifproto, sizeof(*ifproto));
+
+ ifproto->ifp = ifp;
+ ifproto->protocol_family = protocol;
+ ifproto->proto_kpi = kProtoKPI_v2;
+ ifproto->kpi.v2.input = proto_details->input;
+ ifproto->kpi.v2.pre_output = proto_details->pre_output;
+ ifproto->kpi.v2.event = proto_details->event;
+ ifproto->kpi.v2.ioctl = proto_details->ioctl;
+ ifproto->kpi.v2.detached = proto_details->detached;
+ ifproto->kpi.v2.resolve_multi = proto_details->resolve;
+ ifproto->kpi.v2.send_arp = proto_details->send_arp;
+
+ retval = dlil_attach_protocol_internal(ifproto,
+ proto_details->demux_list, proto_details->demux_count);
+
+end:
+ if (retval && ifproto)
+ FREE(ifproto, M_IFADDR);
+ return retval;
}
+extern void if_rtproto_del(struct ifnet *ifp, int protocol);
-
-int
-dlil_inject_if_input(struct mbuf *m, char *frame_header, u_long from_id)
+static int
+dlil_detach_protocol_internal(
+ struct if_proto *proto)
{
- struct ifnet *orig_ifp = 0;
- struct ifnet *ifp;
- struct if_proto *ifproto;
- struct if_proto *proto;
- struct dlil_filterq_entry *tmp;
- int retval = 0;
- struct dlil_filterq_head *fhead;
- int match_found;
-
- dlil_stats.inject_if_in1++;
-
- if (from_id >= dlil_filters_nb || dlil_filters[from_id].type != DLIL_IF_FILTER)
- return ENOENT;
-
- ifp = dlil_filters[from_id].ifp;
-
-/*
- * Let interface filters (if any) do their thing ...
- */
-
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- match_found = 0;
-
- if (TAILQ_EMPTY(fhead) == 0) {
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
- TAILQ_FOREACH_REVERSE(tmp, fhead, que, dlil_filterq_head) {
- if ((match_found) && (IFILT(tmp).filter_if_input)) {
- retval = (*IFILT(tmp).filter_if_input)(IFILT(tmp).cookie,
- &ifp,
- &m,
- &frame_header);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
- }
-
- }
-
- if (ifp != orig_ifp)
- break;
-
- if (from_id == tmp->filter_id)
- match_found = 1;
- }
+ struct ifnet *ifp = proto->ifp;
+ u_long proto_family = proto->protocol_family;
+ struct kev_dl_proto_data ev_pr_data;
+
+ if (proto->proto_kpi == kProtoKPI_v1) {
+ if (proto->kpi.v1.detached)
+ proto->kpi.v1.detached(ifp, proto->protocol_family);
}
- }
-
- ifp->if_lastchange = time;
-
- /*
- * Call family demux module. If the demux module finds a match
- * for the frame it will fill-in the ifproto pointer.
- */
-
- retval = (*ifp->if_demux)(ifp, m, frame_header, &ifproto );
-
- if (m->m_flags & (M_BCAST|M_MCAST))
- ifp->if_imcasts++;
+ if (proto->proto_kpi == kProtoKPI_v2) {
+ if (proto->kpi.v2.detached)
+ proto->kpi.v2.detached(ifp, proto->protocol_family);
+ }
+ if_proto_free(proto);
- if ((retval) && (ifp->offercnt)) {
/*
- * No match was found, look for any offers.
+ * Cleanup routes that may still be in the routing table for that interface/protocol pair.
*/
- struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
- TAILQ_FOREACH(proto, tmp, next) {
- if ((proto->dl_offer) && (proto->dl_offer(m, frame_header) == 0)) {
- ifproto = proto;
- retval = 0;
- break;
- }
- }
- }
+
+ if_rtproto_del(ifp, proto_family);
+
+ /* the reserved field carries the number of protocol still attached (subject to change) */
+ ev_pr_data.proto_family = proto_family;
+ ev_pr_data.proto_remaining_count = dlil_ifp_proto_count(ifp);
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_PROTO_DETACHED,
+ (struct net_event_data *)&ev_pr_data,
+ sizeof(struct kev_dl_proto_data));
+ return 0;
+}
- if (retval) {
- if (retval != EJUSTRETURN) {
- m_freem(m);
- return retval;
+errno_t
+ifnet_detach_protocol(ifnet_t ifp, protocol_family_t proto_family)
+{
+ struct if_proto *proto = NULL;
+ int retval = 0;
+ int use_reached_zero = 0;
+
+ if (ifp == NULL || proto_family == 0) return EINVAL;
+
+ if ((retval = dlil_write_begin()) != 0) {
+ if (retval == EDEADLK) {
+ retval = 0;
+ dlil_read_begin();
+ proto = find_attached_proto(ifp, proto_family);
+ if (proto == 0) {
+ retval = ENXIO;
+ }
+ else {
+ proto->detaching = 1;
+ dlil_detach_waiting = 1;
+ wakeup(&dlil_detach_waiting);
+ }
+ dlil_read_end();
+ }
+ goto end;
}
- else
- return 0;
- }
- else
- if (ifproto == 0) {
- printf("ERROR - dlil_inject_if_input -- if_demux didn't return an if_proto pointer\n");
- m_freem(m);
- return 0;
+
+ proto = find_attached_proto(ifp, proto_family);
+
+ if (proto == NULL) {
+ retval = ENXIO;
+ dlil_write_end();
+ goto end;
}
-
-/*
- * Call any attached protocol filters.
- */
- TAILQ_FOREACH_REVERSE(tmp, &ifproto->pr_flt_head, que, dlil_filterq_head) {
- if (PFILT(tmp).filter_dl_input) {
- retval = (*PFILT(tmp).filter_dl_input)(PFILT(tmp).cookie,
- &m,
- &frame_header,
- &ifp);
-
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
- }
- }
- }
-
-
+
+ /*
+ * Call family module del_proto
+ */
+
+ if (ifp->if_del_proto)
+ ifp->if_del_proto(ifp, proto->protocol_family);
- retval = (*ifproto->dl_input)(m, frame_header,
- ifp, ifproto->dl_tag,
- FALSE);
-
- dlil_stats.inject_if_in2++;
- if (retval == EJUSTRETURN)
- retval = 0;
- else
- if (retval)
- m_freem(m);
+ SLIST_REMOVE(&ifp->if_proto_hash[proto_hash_value(proto_family)], proto, if_proto, next_hash);
+
+ /*
+ * We can do the rest of the work outside of the write lock.
+ */
+ use_reached_zero = ifp_unuse(ifp);
+ dlil_write_end();
+
+ dlil_detach_protocol_internal(proto);
+ /*
+ * Only handle the case where the interface will go away after
+ * we've sent the message. This way post message can send the
+ * message to the interface safely.
+ */
+
+ if (use_reached_zero)
+ ifp_use_reached_zero(ifp);
+
+end:
return retval;
-
}
-
-
-
-
-int
-dlil_inject_pr_input(struct mbuf *m, char *frame_header, u_long from_id)
-{
- struct ifnet *orig_ifp = 0;
- struct dlil_filterq_entry *tmp;
- int retval;
- struct if_proto *ifproto = 0;
- int match_found;
- struct ifnet *ifp;
-
- dlil_stats.inject_pr_in1++;
- if (from_id >= dlil_filters_nb || dlil_filters[from_id].type != DLIL_PR_FILTER)
- return ENOENT;
-
- ifproto = dlil_filters[from_id].proto;
- ifp = dlil_filters[from_id].ifp;
-
/*
- * Call any attached protocol filters.
+ * dlil_delayed_detach_thread is responsible for detaching
+ * protocols, protocol filters, and interface filters after
+ * an attempt was made to detach one of those items while
+ * it was not safe to do so (i.e. called dlil_read_begin).
+ *
+ * This function will take the dlil write lock and walk
+ * through each of the interfaces looking for items with
+ * the detaching flag set. When an item is found, it is
+ * detached from the interface and placed on a local list.
+ * After all of the items have been collected, we drop the
+ * write lock and performed the post detach. This is done
+ * so we only have to take the write lock once.
+ *
+ * When detaching a protocol filter, if we find that we
+ * have detached the very last protocol and we need to call
+ * ifp_use_reached_zero, we have to break out of our work
+ * to drop the write lock so we can call ifp_use_reached_zero.
*/
-
- match_found = 0;
- TAILQ_FOREACH_REVERSE(tmp, &ifproto->pr_flt_head, que, dlil_filterq_head) {
- if ((match_found) && (PFILT(tmp).filter_dl_input)) {
- retval = (*PFILT(tmp).filter_dl_input)(PFILT(tmp).cookie,
- &m,
- &frame_header,
- &ifp);
-
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
- }
- }
+
+static void
+dlil_delayed_detach_thread(__unused void* foo, __unused wait_result_t wait)
+{
+ thread_t self = current_thread();
+ int asserted = 0;
- if (tmp->filter_id == from_id)
- match_found = 1;
- }
-
-
- retval = (*ifproto->dl_input)(m, frame_header,
- ifp, ifproto->dl_tag,
- FALSE);
-
- if (retval == EJUSTRETURN)
- retval = 0;
- else
- if (retval)
- m_freem(m);
+ ml_thread_policy(self, MACHINE_GROUP,
+ (MACHINE_NETWORK_GROUP|MACHINE_NETWORK_NETISR));
- dlil_stats.inject_pr_in2++;
- return retval;
+
+ while (1) {
+ if (dlil_detach_waiting != 0 && dlil_write_begin() == 0) {
+ struct ifnet *ifp;
+ struct proto_hash_entry detached_protos;
+ struct ifnet_filter_head detached_filters;
+ struct if_proto *proto;
+ struct if_proto *next_proto;
+ struct ifnet_filter *filt;
+ struct ifnet_filter *next_filt;
+ int reached_zero;
+
+ reached_zero = 0;
+
+ /* Clear the detach waiting flag */
+ dlil_detach_waiting = 0;
+ TAILQ_INIT(&detached_filters);
+ SLIST_INIT(&detached_protos);
+
+ ifnet_head_lock_shared();
+ TAILQ_FOREACH(ifp, &ifnet_head, if_link) {
+ int i;
+
+ // Look for protocols and protocol filters
+ for (i = 0; i < PROTO_HASH_SLOTS && !reached_zero; i++) {
+ struct if_proto **prev_nextptr = &SLIST_FIRST(&ifp->if_proto_hash[i]);
+ for (proto = *prev_nextptr; proto; proto = *prev_nextptr) {
+
+ // Detach this protocol
+ if (proto->detaching) {
+ if (ifp->if_del_proto)
+ ifp->if_del_proto(ifp, proto->protocol_family);
+ *prev_nextptr = SLIST_NEXT(proto, next_hash);
+ SLIST_INSERT_HEAD(&detached_protos, proto, next_hash);
+ reached_zero = ifp_unuse(ifp);
+ if (reached_zero) {
+ break;
+ }
+ }
+ else {
+ // Update prev_nextptr to point to our next ptr
+ prev_nextptr = &SLIST_NEXT(proto, next_hash);
+ }
+ }
+ }
+
+ // look for interface filters that need to be detached
+ for (filt = TAILQ_FIRST(&ifp->if_flt_head); filt; filt = next_filt) {
+ next_filt = TAILQ_NEXT(filt, filt_next);
+ if (filt->filt_detaching != 0) {
+ // take this interface filter off the interface filter list
+ TAILQ_REMOVE(&ifp->if_flt_head, filt, filt_next);
+
+ // put this interface filter on the detached filters list
+ TAILQ_INSERT_TAIL(&detached_filters, filt, filt_next);
+ }
+ }
+
+ if (ifp->if_delayed_detach) {
+ ifp->if_delayed_detach = 0;
+ reached_zero = ifp_unuse(ifp);
+ }
+
+ if (reached_zero)
+ break;
+ }
+ ifnet_head_done();
+ dlil_write_end();
+
+ for (filt = TAILQ_FIRST(&detached_filters); filt; filt = next_filt) {
+ next_filt = TAILQ_NEXT(filt, filt_next);
+ /*
+ * dlil_detach_filter_internal won't remove an item from
+ * the list if it is already detached (second parameter).
+ * The item will be freed though.
+ */
+ dlil_detach_filter_internal(filt, 1);
+ }
+
+ for (proto = SLIST_FIRST(&detached_protos); proto; proto = next_proto) {
+ next_proto = SLIST_NEXT(proto, next_hash);
+ dlil_detach_protocol_internal(proto);
+ }
+
+ if (reached_zero) {
+ ifp_use_reached_zero(ifp);
+ dlil_detach_waiting = 1; // we may have missed something
+ }
+ }
+
+ if (!asserted && dlil_detach_waiting == 0) {
+ asserted = 1;
+ assert_wait(&dlil_detach_waiting, THREAD_UNINT);
+ }
+
+ if (dlil_detach_waiting == 0) {
+ asserted = 0;
+ thread_block(dlil_delayed_detach_thread);
+ }
+ }
}
+static void
+dlil_call_delayed_detach_thread(void) {
+ dlil_delayed_detach_thread(NULL, THREAD_RESTART);
+}
+extern int if_next_index(void);
-int
-dlil_inject_pr_output(struct mbuf *m,
- struct sockaddr *dest,
- int raw,
- char *frame_type,
- char *dst_linkaddr,
- u_long from_id)
+errno_t
+ifnet_attach(
+ ifnet_t ifp,
+ const struct sockaddr_dl *ll_addr)
{
- struct ifnet *orig_ifp = 0;
- struct ifnet *ifp;
- struct dlil_filterq_entry *tmp;
- int retval = 0;
- char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
- char dst_linkaddr_buffer[MAX_LINKADDR * 4];
- struct dlil_filterq_head *fhead;
- int match_found;
- u_long dl_tag;
-
- dlil_stats.inject_pr_out1++;
- if (raw == 0) {
- if (frame_type)
- bcopy(frame_type, &frame_type_buffer[0], MAX_FRAME_TYPE_SIZE * 4);
- else
- return EINVAL;
-
- if (dst_linkaddr)
- bcopy(dst_linkaddr, &dst_linkaddr_buffer, MAX_LINKADDR * 4);
- else
- return EINVAL;
- }
-
- if (from_id >= dlil_filters_nb || dlil_filters[from_id].type != DLIL_PR_FILTER)
- return ENOENT;
-
- ifp = dlil_filters[from_id].ifp;
- dl_tag = dlil_filters[from_id].proto->dl_tag;
-
- frame_type = frame_type_buffer;
- dst_linkaddr = dst_linkaddr_buffer;
-
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
-
-/*
- * Run any attached protocol filters.
- */
- match_found = 0;
+ u_long interface_family;
+ struct ifnet *tmp_if;
+ struct proto_hash_entry *new_proto_list = NULL;
+ int locked = 0;
+
+ if (ifp == NULL) return EINVAL;
+ if (ll_addr && ifp->if_addrlen == 0) {
+ ifp->if_addrlen = ll_addr->sdl_alen;
+ }
+ else if (ll_addr && ll_addr->sdl_alen != ifp->if_addrlen) {
+ return EINVAL;
+ }
+
+ interface_family = ifp->if_family;
+
+ ifnet_head_lock_shared();
- if (TAILQ_EMPTY(dl_tag_array[dl_tag].pr_flt_head) == 0) {
- TAILQ_FOREACH(tmp, dl_tag_array[dl_tag].pr_flt_head, que) {
- if ((match_found) && (PFILT(tmp).filter_dl_output)) {
- retval = (*PFILT(tmp).filter_dl_output)(PFILT(tmp).cookie,
- &m, &ifp, &dest, dst_linkaddr, frame_type);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
+ /* Verify we aren't already on the list */
+ TAILQ_FOREACH(tmp_if, &ifnet_head, if_link) {
+ if (tmp_if == ifp) {
+ ifnet_head_done();
+ return EEXIST;
}
- }
-
- if (tmp->filter_id == from_id)
- match_found = 1;
}
- }
-
+
+ ifnet_head_done();
+
+ if ((ifp->if_eflags & IFEF_REUSE) == 0 || ifp->if_lock == 0)
+#if IFNET_RW_LOCK
+ ifp->if_lock = lck_rw_alloc_init(ifnet_lock_group, ifnet_lock_attr);
+#else
+ ifp->if_lock = lck_mtx_alloc_init(ifnet_lock_group, ifnet_lock_attr);
+#endif
-/*
- * Call framing module
- */
- if ((raw == 0) && (ifp->if_framer)) {
- retval = (*ifp->if_framer)(ifp, &m, dest, dst_linkaddr, frame_type);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else
- {
- m_freem(m);
- return retval;
- }
+ if (ifp->if_lock == 0) {
+ return ENOMEM;
}
- }
-
-#if BRIDGE
- if (do_bridge) {
- struct mbuf *m0 = m ;
- struct ether_header *eh = mtod(m, struct ether_header *);
+ /*
+ * Allow interfaces withouth protocol families to attach
+ * only if they have the necessary fields filled out.
+ */
- if (m->m_pkthdr.rcvif)
- m->m_pkthdr.rcvif = NULL ;
- ifp = bridge_dst_lookup(eh);
- bdg_forward(&m0, ifp);
- if (m0)
- m_freem(m0);
-
- return 0;
- }
-#endif
+ if (ifp->if_add_proto == 0 || ifp->if_del_proto == 0) {
+ DLIL_PRINTF("dlil Attempt to attach interface without family module - %ld\n",
+ interface_family);
+ return ENODEV;
+ }
+
+ if ((ifp->if_eflags & IFEF_REUSE) == 0 || ifp->if_proto_hash == NULL) {
+ MALLOC(new_proto_list, struct proto_hash_entry*, sizeof(struct proto_hash_entry) * PROTO_HASH_SLOTS,
+ M_NKE, M_WAITOK);
+ if (new_proto_list == 0) {
+ return ENOBUFS;
+ }
+ }
-/*
- * Let interface filters (if any) do their thing ...
- */
+ dlil_write_begin();
+ locked = 1;
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- if (TAILQ_EMPTY(fhead) == 0) {
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
- TAILQ_FOREACH(tmp, fhead, que) {
- if (IFILT(tmp).filter_if_output) {
- retval = (*IFILT(tmp).filter_if_output)(IFILT(tmp).cookie,
- &ifp,
- &m);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
+ TAILQ_INIT(&ifp->if_flt_head);
+
+
+ if (new_proto_list) {
+ bzero(new_proto_list, (PROTO_HASH_SLOTS * sizeof(struct proto_hash_entry)));
+ ifp->if_proto_hash = new_proto_list;
+ new_proto_list = NULL;
+ }
+
+ /* old_if_attach */
+ {
+ char workbuf[64];
+ int namelen, masklen, socksize, ifasize;
+ struct ifaddr *ifa = NULL;
+
+ if (ifp->if_snd.ifq_maxlen == 0)
+ ifp->if_snd.ifq_maxlen = ifqmaxlen;
+ TAILQ_INIT(&ifp->if_prefixhead);
+ LIST_INIT(&ifp->if_multiaddrs);
+ ifnet_touch_lastchange(ifp);
+
+ /* usecount to track attachment to the ifnet list */
+ ifp_use(ifp, kIfNetUseCount_MayBeZero);
+
+ /* Lock the list of interfaces */
+ ifnet_head_lock_exclusive();
+ ifnet_lock_exclusive(ifp);
+
+ if ((ifp->if_eflags & IFEF_REUSE) == 0 || ifp->if_index == 0)
+ ifp->if_index = if_next_index();
+ else
+ ifa = TAILQ_FIRST(&ifp->if_addrhead);
+
+ namelen = snprintf(workbuf, sizeof(workbuf), "%s%d", ifp->if_name, ifp->if_unit);
+#define _offsetof(t, m) ((int)((caddr_t)&((t *)0)->m))
+ masklen = _offsetof(struct sockaddr_dl, sdl_data[0]) + namelen;
+ socksize = masklen + ifp->if_addrlen;
+#define ROUNDUP(a) (1 + (((a) - 1) | (sizeof(long) - 1)))
+ if ((u_long)socksize < sizeof(struct sockaddr_dl))
+ socksize = sizeof(struct sockaddr_dl);
+ socksize = ROUNDUP(socksize);
+ ifasize = sizeof(struct ifaddr) + 2 * socksize;
+
+ /*
+ * Allocate a new ifa if we don't have one
+ * or the old one is too small.
+ */
+ if (ifa == NULL || socksize > ifa->ifa_addr->sa_len) {
+ if (ifa)
+ if_detach_ifa(ifp, ifa);
+ ifa = (struct ifaddr*)_MALLOC(ifasize, M_IFADDR, M_WAITOK);
+ }
+
+ if (ifa) {
+ struct sockaddr_dl *sdl = (struct sockaddr_dl *)(ifa + 1);
+ ifnet_addrs[ifp->if_index - 1] = ifa;
+ bzero(ifa, ifasize);
+ sdl->sdl_len = socksize;
+ sdl->sdl_family = AF_LINK;
+ bcopy(workbuf, sdl->sdl_data, namelen);
+ sdl->sdl_nlen = namelen;
+ sdl->sdl_index = ifp->if_index;
+ sdl->sdl_type = ifp->if_type;
+ if (ll_addr) {
+ sdl->sdl_alen = ll_addr->sdl_alen;
+ if (ll_addr->sdl_alen != ifp->if_addrlen)
+ panic("ifnet_attach - ll_addr->sdl_alen != ifp->if_addrlen");
+ bcopy(CONST_LLADDR(ll_addr), LLADDR(sdl), sdl->sdl_alen);
}
- }
+ ifa->ifa_ifp = ifp;
+ ifa->ifa_rtrequest = link_rtrequest;
+ ifa->ifa_addr = (struct sockaddr*)sdl;
+ sdl = (struct sockaddr_dl*)(socksize + (caddr_t)sdl);
+ ifa->ifa_netmask = (struct sockaddr*)sdl;
+ sdl->sdl_len = masklen;
+ while (namelen != 0)
+ sdl->sdl_data[--namelen] = 0xff;
+ }
+ TAILQ_INIT(&ifp->if_addrhead);
+ ifa = ifnet_addrs[ifp->if_index - 1];
+
+ if (ifa) {
+ /*
+ * We don't use if_attach_ifa because we want
+ * this address to be first on the list.
+ */
+ ifaref(ifa);
+ ifa->ifa_debug |= IFA_ATTACHED;
+ TAILQ_INSERT_HEAD(&ifp->if_addrhead, ifa, ifa_link);
}
+#if CONFIG_MACF_NET
+ mac_ifnet_label_associate(ifp);
+#endif
- if (ifp != orig_ifp)
- break;
- }
+ TAILQ_INSERT_TAIL(&ifnet_head, ifp, if_link);
+ ifindex2ifnet[ifp->if_index] = ifp;
+
+ ifnet_head_done();
}
- }
-/*
- * Finally, call the driver.
- */
+ /*
+ * A specific dlil input thread is created per Ethernet interface.
+ * pseudo interfaces or other types of interfaces use the main ("loopback") thread.
+ * If the sysctl "net.link.generic.system.multi_threaded_input" is set to zero, all packets will
+ * be handled by the main loopback thread, reverting to 10.4.x behaviour.
+ *
+ */
- retval = (*ifp->if_output)(ifp, m);
- dlil_stats.inject_pr_out2++;
- if ((retval == 0) || (retval == EJUSTRETURN))
- return 0;
- else
- return retval;
-}
+ if (ifp->if_type == IFT_ETHER) {
+ int err;
+
+ if (dlil_multithreaded_input > 0) {
+ ifp->if_input_thread = _MALLOC(sizeof(struct dlil_threading_info), M_NKE, M_WAITOK);
+ if (ifp->if_input_thread == NULL)
+ panic("ifnet_attach ifp=%p couldn't alloc threading\n", ifp);
+ if ((err = dlil_create_input_thread(ifp, ifp->if_input_thread)) != 0)
+ panic("ifnet_attach ifp=%p couldn't get a thread. err=%x\n", ifp, err);
+#ifdef DLIL_DEBUG
+ printf("ifnet_attach: dlil thread for ifp=%p if_index=%x\n", ifp, ifp->if_index);
+#endif
+ }
+ }
+ dlil_write_end();
+ ifnet_lock_done(ifp);
+
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_ATTACHED, NULL, 0);
+ return 0;
+}
-int
-dlil_inject_if_output(struct mbuf *m, u_long from_id)
+errno_t
+ifnet_detach(
+ ifnet_t ifp)
{
- struct ifnet *orig_ifp = 0;
- struct ifnet *ifp;
- struct dlil_filterq_entry *tmp;
- int retval = 0;
- struct dlil_filterq_head *fhead;
- int match_found;
-
- dlil_stats.inject_if_out1++;
- if (from_id > dlil_filters_nb || dlil_filters[from_id].type != DLIL_IF_FILTER)
- return ENOENT;
-
- ifp = dlil_filters[from_id].ifp;
+ struct ifnet_filter *filter;
+ struct ifnet_filter *filter_next;
+ int zeroed = 0;
+ int retval = 0;
+ struct ifnet_filter_head fhead;
+ struct dlil_threading_info *inputthread;
+
+ if (ifp == NULL) return EINVAL;
+
+ ifnet_lock_exclusive(ifp);
+
+ if ((ifp->if_eflags & IFEF_DETACHING) != 0) {
+ /* Interface has already been detached */
+ ifnet_lock_done(ifp);
+ return ENXIO;
+ }
+
+ /*
+ * Indicate this interface is being detached.
+ *
+ * This should prevent protocols from attaching
+ * from this point on. Interface will remain on
+ * the list until all of the protocols are detached.
+ */
+ ifp->if_eflags |= IFEF_DETACHING;
+ ifnet_lock_done(ifp);
+
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHING, NULL, 0);
+
+ /* Let BPF know we're detaching */
+ bpfdetach(ifp);
+
+ if ((retval = dlil_write_begin()) != 0) {
+ if (retval == EDEADLK) {
+ retval = 0;
+
+ /* We need to perform a delayed detach */
+ ifp->if_delayed_detach = 1;
+ dlil_detach_waiting = 1;
+ wakeup(&dlil_detach_waiting);
+ }
+ return retval;
+ }
+
+ /* Steal the list of interface filters */
+ fhead = ifp->if_flt_head;
+ TAILQ_INIT(&ifp->if_flt_head);
-/*
- * Let interface filters (if any) do their thing ...
- */
+ /* unuse the interface */
+ zeroed = ifp_unuse(ifp);
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- match_found = 0;
-
- if (TAILQ_EMPTY(fhead) == 0) {
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
- TAILQ_FOREACH(tmp, fhead, que) {
- if ((match_found) && (IFILT(tmp).filter_if_output)) {
- retval = (*IFILT(tmp).filter_if_output)(IFILT(tmp).cookie,
- &ifp,
- &m);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
+ /*
+ * If thread affinity was set for the workloop thread, we will need
+ * to tear down the affinity and release the extra reference count
+ * taken at attach time;
+ */
+ if ((inputthread = ifp->if_input_thread) != NULL) {
+ if (inputthread->net_affinity) {
+ struct thread *tp;
+
+ if (inputthread == dlil_lo_thread_ptr)
+ panic("Thread affinity should not be enabled "
+ "on the loopback dlil input thread\n");
+
+ lck_mtx_lock(inputthread->input_lck);
+ tp = inputthread->workloop_thread;
+ inputthread->workloop_thread = NULL;
+ inputthread->tag = 0;
+ inputthread->net_affinity = FALSE;
+ lck_mtx_unlock(inputthread->input_lck);
+
+ /* Tear down workloop thread affinity */
+ if (tp != NULL) {
+ (void) dlil_affinity_set(tp,
+ THREAD_AFFINITY_TAG_NULL);
+ thread_deallocate(tp);
}
- }
+ /* Tear down dlil input thread affinity */
+ tp = inputthread->input_thread;
+ (void) dlil_affinity_set(tp, THREAD_AFFINITY_TAG_NULL);
+ thread_deallocate(tp);
}
-
- if (ifp != orig_ifp)
- break;
- if (from_id == tmp->filter_id)
- match_found = 1;
- }
- }
- }
+ /* cleanup ifp dlil input thread, if any */
+ ifp->if_input_thread = NULL;
-/*
- * Finally, call the driver.
- */
-
- retval = (*ifp->if_output)(ifp, m);
- dlil_stats.inject_if_out2++;
- if ((retval == 0) || (retval == EJUSTRETURN))
- return 0;
- else
+ if (inputthread != dlil_lo_thread_ptr) {
+#ifdef DLIL_DEBUG
+ printf("ifnet_detach: wakeup thread threadinfo: %p "
+ "input_thread=%p threads: cur=%d max=%d\n",
+ inputthread, inputthread->input_thread,
+ dlil_multithreaded_input, cur_dlil_input_threads);
+#endif
+ lck_mtx_lock(inputthread->input_lck);
+
+ inputthread->input_waiting |= DLIL_INPUT_TERMINATE;
+ if ((inputthread->input_waiting & DLIL_INPUT_RUNNING) == 0) {
+ wakeup((caddr_t)&inputthread->input_waiting);
+ }
+ lck_mtx_unlock(inputthread->input_lck);
+ }
+ }
+ dlil_write_end();
+
+ for (filter = TAILQ_FIRST(&fhead); filter; filter = filter_next) {
+ filter_next = TAILQ_NEXT(filter, filt_next);
+ dlil_detach_filter_internal(filter, 1);
+ }
+
+ if (zeroed != 0) {
+ ifp_use_reached_zero(ifp);
+ }
+
return retval;
}
-static
-int dlil_recycle_ioctl(struct ifnet *ifnet_ptr, u_long ioctl_code, void *ioctl_arg)
+static errno_t
+dlil_recycle_ioctl(
+ __unused ifnet_t ifnet_ptr,
+ __unused u_int32_t ioctl_code,
+ __unused void *ioctl_arg)
{
-
return EOPNOTSUPP;
}
-static
-int dlil_recycle_output(struct ifnet *ifnet_ptr, struct mbuf *m)
+static int
+dlil_recycle_output(
+ __unused struct ifnet *ifnet_ptr,
+ struct mbuf *m)
{
-
m_freem(m);
return 0;
}
-static
-int dlil_recycle_free(struct ifnet *ifnet_ptr)
+static void
+dlil_recycle_free(
+ __unused ifnet_t ifnet_ptr)
{
- return 0;
}
-static
-int dlil_recycle_set_bpf_tap(struct ifnet *ifp, int mode,
- int (*bpf_callback)(struct ifnet *, struct mbuf *))
+static errno_t
+dlil_recycle_set_bpf_tap(
+ __unused ifnet_t ifp,
+ __unused bpf_tap_mode mode,
+ __unused bpf_packet_func callback)
{
/* XXX not sure what to do here */
return 0;
}
-int dlil_if_acquire(u_long family, void *uniqueid, size_t uniqueid_len,
- struct ifnet **ifp)
+__private_extern__
+int dlil_if_acquire(
+ u_long family,
+ const void *uniqueid,
+ size_t uniqueid_len,
+ struct ifnet **ifp)
{
struct ifnet *ifp1 = NULL;
struct dlil_ifnet *dlifp1 = NULL;
- int s, ret = 0;
- boolean_t funnel_state;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
+ int ret = 0;
+ lck_mtx_lock(dlil_ifnet_mutex);
TAILQ_FOREACH(dlifp1, &dlil_ifnet_head, dl_if_link) {
ifp1 = (struct ifnet *)dlifp1;
}
}
else {
-
- ifp1->if_eflags |= (IFEF_INUSE + IFEF_REUSE);
+ if (!ifp1->if_lock)
+ panic("ifp's lock is gone\n");
+ ifnet_lock_exclusive(ifp1);
+ ifp1->if_eflags |= (IFEF_INUSE | IFEF_REUSE);
+ ifnet_lock_done(ifp1);
*ifp = ifp1;
goto end;
}
ifp1 = (struct ifnet *)dlifp1;
ifp1->if_eflags |= IFEF_INUSE;
+ ifp1->if_name = dlifp1->if_namestorage;
+#if CONFIG_MACF_NET
+ mac_ifnet_label_init(ifp1);
+#endif
TAILQ_INSERT_TAIL(&dlil_ifnet_head, dlifp1, dl_if_link);
*ifp = ifp1;
end:
+ lck_mtx_unlock(dlil_ifnet_mutex);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
return ret;
}
-void dlil_if_release(struct ifnet *ifp)
+__private_extern__ void
+dlil_if_release(
+ ifnet_t ifp)
{
struct dlil_ifnet *dlifp = (struct dlil_ifnet *)ifp;
- int s;
- boolean_t funnel_state;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
+ /* Interface does not have a lock until it is attached - radar 3713951 */
+ if (ifp->if_lock)
+ ifnet_lock_exclusive(ifp);
ifp->if_eflags &= ~IFEF_INUSE;
ifp->if_ioctl = dlil_recycle_ioctl;
ifp->if_output = dlil_recycle_output;
strncpy(dlifp->if_namestorage, ifp->if_name, IFNAMSIZ);
ifp->if_name = dlifp->if_namestorage;
+#if CONFIG_MACF_NET
+ /*
+ * We can either recycle the MAC label here or in dlil_if_acquire().
+ * It seems logical to do it here but this means that anything that
+ * still has a handle on ifp will now see it as unlabeled.
+ * Since the interface is "dead" that may be OK. Revisit later.
+ */
+ mac_ifnet_label_recycle(ifp);
+#endif
+ if (ifp->if_lock)
+ ifnet_lock_done(ifp);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
}
+__private_extern__ void
+dlil_proto_unplumb_all(struct ifnet *ifp)
+{
+ /*
+ * if_proto_hash[0-3] are for PF_INET, PF_INET6, PF_APPLETALK
+ * and PF_VLAN, where each bucket contains exactly one entry;
+ * PF_VLAN does not need an explicit unplumb.
+ *
+ * if_proto_hash[4] is for other protocols; we expect anything
+ * in this bucket to respond to the DETACHING event (which would
+ * have happened by now) and do the unplumb then.
+ */
+ (void) proto_unplumb(PF_INET, ifp);
+#if INET6
+ (void) proto_unplumb(PF_INET6, ifp);
+#endif /* INET6 */
+#if NETAT
+ (void) proto_unplumb(PF_APPLETALK, ifp);
+#endif /* NETAT */
+}
projects / apple / xnu.git / blobdiff