* Author: Ted Walker
*/
-
-
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
+#include <sys/domain.h>
+#include <sys/user.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/thread.h>
+#include <kern/assert.h>
#include <kern/task.h>
-#include <net/netisr.h>
+#include <kern/thread.h>
+#include <kern/sched_prim.h>
+#include <kern/locks.h>
+
#include <net/if_types.h>
+#include <net/kpi_interfacefilter.h>
+
+#include <libkern/OSAtomic.h>
#include <machine/machine_routines.h>
#define DBG_FNC_DLIL_IFOUT DLILDBG_CODE(DBG_DLIL_STATIC, (3 << 8))
-#define MAX_DL_TAGS 50
-#define MAX_DLIL_FILTERS 50
+#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
-struct dl_tag_str {
- struct ifnet *ifp;
- struct if_proto *proto;
- struct dlil_filterq_head *pr_flt_head;
-};
+#if 0
+#define DLIL_PRINTF printf
+#else
+#define DLIL_PRINTF kprintf
+#endif
+enum {
+ kProtoKPI_DLIL = 0,
+ kProtoKPI_v1 = 1
+};
-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;
+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 {
+ dl_input_func dl_input;
+ dl_pre_output_func dl_pre_output;
+ dl_event_func dl_event;
+ dl_offer_func dl_offer;
+ dl_ioctl_func dl_ioctl;
+ dl_detached_func dl_detached;
+ } dlil;
+ 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;
+ } kpi;
};
+SLIST_HEAD(proto_hash_entry, if_proto);
-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 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 */
+
+ /* 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 */
+};
+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 if_family_str {
TAILQ_ENTRY(if_family_str) if_fam_next;
int (*add_if)(struct ifnet *ifp);
int (*del_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)();
+ int (*init_if)(struct ifnet *ifp);
+ int (*add_proto)(struct ifnet *ifp, u_long protocol_family, struct ddesc_head_str *demux_desc_head);
+ ifnet_del_proto_func del_proto;
+ ifnet_ioctl_func ifmod_ioctl;
+ int (*shutdown)(void);
};
+struct proto_family_str {
+ TAILQ_ENTRY(proto_family_str) proto_fam_next;
+ u_long proto_family;
+ u_long if_family;
+ int usecnt;
+ int (*attach_proto)(struct ifnet *ifp, u_long protocol_family);
+ int (*detach_proto)(struct ifnet *ifp, u_long protocol_family);
+};
-struct dlil_stats_str dlil_stats;
-
-static
-struct dlil_filter_id_str dlil_filters[MAX_DLIL_FILTERS+1];
-
-static
-struct dl_tag_str dl_tag_array[MAX_DL_TAGS+1];
-
-static
-TAILQ_HEAD(, if_family_str) if_family_head;
+enum {
+ kIfNetUseCount_MayBeZero = 0,
+ kIfNetUseCount_MustNotBeZero = 1
+};
-static ifnet_inited = 0;
+static TAILQ_HEAD(, dlil_ifnet) dlil_ifnet_head;
+static TAILQ_HEAD(, if_family_str) if_family_head;
+static TAILQ_HEAD(, proto_family_str) proto_family_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_mtx_t *proto_family_mutex;
+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;
int dlil_initialized = 0;
-decl_simple_lock_data(, dlil_input_lock)
+lck_spin_t *dlil_input_lock;
+__private_extern__ thread_t dlil_input_thread_ptr = 0;
int dlil_input_thread_wakeup = 0;
-int dlil_expand_mcl;
+__private_extern__ int dlil_output_thread_wakeup = 0;
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 void dlil_input_thread(void);
-extern void run_netisr(void);
+static int dlil_event_internal(struct ifnet *ifp, struct kev_msg *msg);
+struct ifnet *ifbyfamily(u_long family, short unit);
+static int dlil_detach_filter_internal(interface_filter_t filter, int detached);
+static void dlil_call_delayed_detach_thread(void);
+static void dlil_read_begin(void);
+static void dlil_read_end(void);
+static int dlil_write_begin(void);
+static void dlil_write_end(void);
-/*
- * Internal functions.
- */
+static int ifp_use(struct ifnet *ifp, int handle_zero);
+static int ifp_unuse(struct ifnet *ifp);
+static void ifp_use_reached_zero(struct ifnet *ifp);
-static
-struct if_family_str *find_family_module(u_long if_family)
-{
- struct if_family_str *mod = NULL;
+extern void bpfdetach(struct ifnet*);
+extern void proto_input_run(void); // new run_netisr
- TAILQ_FOREACH(mod, &if_family_head, if_fam_next) {
- if (mod->if_family == (if_family & 0xffff))
- break;
- }
- return mod;
-}
+int dlil_input_packet(struct ifnet *ifp, struct mbuf *m, char *frame_header);
+__private_extern__ void link_rtrequest(int, struct rtentry *, struct sockaddr *);
-/*
- * Public functions.
- */
+int dlil_expand_mcl;
-struct ifnet *ifbyfamily(u_long family, short unit)
-{
- struct ifnet *ifp;
+extern u_int32_t inject_buckets;
- TAILQ_FOREACH(ifp, &ifnet, if_link)
- if ((family == ifp->if_family) &&
- (ifp->if_unit == unit))
- return ifp;
+static const u_int32_t dlil_writer_waiting = 0x80000000;
- return 0;
+static __inline__ void*
+_cast_non_const(const void * ptr) {
+ union {
+ const void* cval;
+ void* val;
+ } ret;
+
+ ret.cval = ptr;
+ return (ret.val);
}
-struct if_proto *dlttoproto(dl_tag)
- u_long dl_tag;
+/* Should these be inline? */
+static void
+dlil_read_begin(void)
{
- return dl_tag_array[dl_tag].proto;
+ 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 int dlil_ifp_proto_count(struct ifnet * ifp)
+static void
+dlil_read_end(void)
{
- 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;
+ struct uthread *uth = get_bsdthread_info(current_thread());
+
+ OSDecrementAtomic((UInt32*)&dlil_read_count);
+ uth->dlil_incremented_read--;
+ if (dlil_read_count == dlil_writer_waiting)
+ wakeup(_cast_non_const(&dlil_writer_waiting));
}
-u_long ifptodlt(struct ifnet *ifp, u_long proto_family)
+static int
+dlil_write_begin(void)
{
- struct if_proto *proto;
- struct dlil_proto_head *tmp = (struct dlil_proto_head *) &ifp->proto_head;
-
-
- TAILQ_FOREACH(proto, tmp, next)
- if (proto->protocol_family == proto_family)
- return proto->dl_tag;
-
- return 0;
+ 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;
+ }
}
-
-int dlil_find_dltag(u_long if_family, short unit, u_long proto_family, u_long *dl_tag)
+static void
+dlil_write_end(void)
{
- struct ifnet *ifp;
-
- ifp = ifbyfamily(if_family, unit);
- if (!ifp)
- return ENOENT;
-
- *dl_tag = ifptodlt(ifp, proto_family);
- if (*dl_tag == 0)
- return EPROTONOSUPPORT;
- else
- return 0;
+ 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
-int dlil_get_next_dl_tag(u_long current_tag, struct dl_tag_attr_str *next)
-{
- int i;
+/*
+ * Internal functions.
+ */
- for (i = (current_tag+1); i < MAX_DL_TAGS; i++)
- if (dl_tag_array[i].ifp) {
- next->dl_tag = i;
- next->if_flags = dl_tag_array[i].ifp->if_flags;
- next->if_unit = dl_tag_array[i].ifp->if_unit;
- next->protocol_family = dl_tag_array[i].proto->protocol_family;
- next->if_family = dl_tag_array[i].ifp->if_family;
- return 0;
+static int
+proto_hash_value(u_long protocol_family)
+{
+ 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;
}
+}
- /*
- * If we got here, there are no more entries
- */
-
- return ENOENT;
-}
-
-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)
+static
+struct if_family_str *find_family_module(u_long if_family)
{
- struct net_event_data ev_data;
- struct kev_msg ev_msg;
+ struct if_family_str *mod = NULL;
- /*
- * 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);
+ TAILQ_FOREACH(mod, &if_family_head, if_fam_next) {
+ if (mod->if_family == (if_family & 0xffff))
+ break;
}
-
- 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);
+ return mod;
}
-
-
-void
-dlil_init()
+static
+struct proto_family_str*
+find_proto_module(u_long proto_family, u_long if_family)
{
- int i;
-
- printf("dlil_init\n");
+ struct proto_family_str *mod = NULL;
- TAILQ_INIT(&if_family_head);
- for (i=0; i < MAX_DL_TAGS; i++)
- dl_tag_array[i].ifp = 0;
-
- for (i=0; i < MAX_DLIL_FILTERS; i++)
- dlil_filters[i].type = 0;
-
- bzero(&dlil_stats, sizeof(dlil_stats));
-
- simple_lock_init(&dlil_input_lock);
+ TAILQ_FOREACH(mod, &proto_family_head, proto_fam_next) {
+ if ((mod->proto_family == (proto_family & 0xffff))
+ && (mod->if_family == (if_family & 0xffff)))
+ break;
+ }
- /*
- * Start up the dlil input thread once everything is initialized
- */
- (void) kernel_thread(kernel_task, dlil_input_thread);
+ return mod;
}
-
-u_long get_new_filter_id()
+static struct if_proto*
+find_attached_proto(struct ifnet *ifp, u_long protocol_family)
{
- u_long i;
-
- for (i=1; i < MAX_DLIL_FILTERS; i++)
- if (dlil_filters[i].type == 0)
- return i;
-
- 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;
}
-
-int dlil_attach_interface_filter(struct ifnet *ifp,
- struct dlil_if_flt_str *if_filter,
- u_long *filter_id,
- int insertion_point)
+static void
+if_proto_ref(struct if_proto *proto)
{
- int s;
- int retval;
- 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();
-
- 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);
-
- if (*filter_id = get_new_filter_id()) {
- 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;
- retval = 0;
- }
- else {
- kprintf("dlil_attach_interface_filter - can't alloc filter_id\n");
- TAILQ_REMOVE(fhead, tmp_ptr, que);
- FREE(tmp_ptr, M_NKE);
- retval = ENOMEM;
- }
-
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
+ OSAddAtomic(1, (UInt32*)&proto->refcount);
}
-
-int dlil_attach_protocol_filter(u_long dl_tag,
- struct dlil_pr_flt_str *pr_filter,
- u_long *filter_id,
- int insertion_point)
+static void
+if_proto_free(struct if_proto *proto)
{
- struct dlil_filterq_entry *tmp_ptr;
- struct dlil_filterq_entry *pr_filt;
- int s;
- int retval;
- boolean_t funnel_state;
-
- if (dl_tag > MAX_DL_TAGS)
- return ERANGE;
-
- if (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);
+ int oldval = OSAddAtomic(-1, (UInt32*)&proto->refcount);
+
+ if (oldval == 1) { /* This was the last reference */
+ FREE(proto, M_IFADDR);
+ }
+}
- bcopy((caddr_t) pr_filter, (caddr_t) &tmp_ptr->variants.pr_filter,
- sizeof(struct dlil_pr_flt_str));
+__private_extern__ void
+ifnet_lock_assert(
+ __unused struct ifnet *ifp,
+ __unused int what)
+{
+#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
+}
- funnel_state = thread_funnel_set(network_flock, TRUE);
+__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
+}
- s = splnet();
- 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);
+__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
+}
-
- if (*filter_id = get_new_filter_id()) {
- 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;
- retval = 0;
- }
- else {
- kprintf("dlil_attach_protocol_filter - can't alloc filter_id\n");
- TAILQ_REMOVE(dl_tag_array[dl_tag].pr_flt_head, tmp_ptr, que);
- FREE(tmp_ptr, M_NKE);
- retval = ENOMEM;
- }
+__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
+}
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return retval;
+__private_extern__ void
+ifnet_head_lock_shared()
+{
+ lck_rw_lock_shared(ifnet_head_mutex);
}
+__private_extern__ void
+ifnet_head_lock_exclusive()
+{
+ lck_rw_lock_exclusive(ifnet_head_mutex);
+}
-int
-dlil_detach_filter(u_long filter_id)
+__private_extern__ void
+ifnet_head_done()
{
- struct dlil_filter_id_str *flt;
- int s;
- boolean_t funnel_state;
+ lck_rw_done(ifnet_head_mutex);
+}
- if (filter_id > MAX_DLIL_FILTERS) {
- kprintf("dlil_detach_filter - Bad filter_id value %d\n", filter_id);
- return ERANGE;
- }
+/*
+ * Public functions.
+ */
+struct ifnet *ifbyfamily(u_long family, short unit)
+{
+ struct ifnet *ifp;
- funnel_state = thread_funnel_set(network_flock, TRUE);
- s = splnet();
- flt = &dlil_filters[filter_id];
- if (flt->type == 0) {
- kprintf("dlil_detach_filter - no such filter_id %d\n", filter_id);
- thread_funnel_set(network_flock, funnel_state);
- return ENOENT;
- }
+ ifnet_head_lock_shared();
+ TAILQ_FOREACH(ifp, &ifnet_head, if_link)
+ if ((family == ifp->if_family) && (ifp->if_unit == unit))
+ break;
+ ifnet_head_done();
+ return ifp;
+}
- 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);
+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++;
+ }
+ }
}
- }
-
- TAILQ_REMOVE(flt->head, flt->filter_ptr, que);
- FREE(flt->filter_ptr, M_NKE);
- flt->type = 0;
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
+
+ return count;
}
+__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;
+
+ dlil_event_internal(ifp, &ev_msg);
+}
+void dlil_init(void);
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 = (struct ifnet *) m->m_pkthdr.aux;
-
- m->m_nextpkt = NULL;
- m->m_pkthdr.header = NULL;
- m->m_pkthdr.aux = NULL;
- (void) dlil_input_packet(ifp, m, header);
- m = m0;
- }
-
- if (netisr != 0)
- run_netisr();
+dlil_init(void)
+{
+ lck_grp_attr_t *grp_attributes = 0;
+ lck_attr_t *lck_attributes = 0;
+ lck_grp_t *input_lock_grp = 0;
+
+ TAILQ_INIT(&dlil_ifnet_head);
+ TAILQ_INIT(&if_family_head);
+ TAILQ_INIT(&proto_family_head);
+ TAILQ_INIT(&ifnet_head);
+
+ /* Setup the lock groups we will use */
+ grp_attributes = lck_grp_attr_alloc_init();
- if (dlil_input_mbuf_head == NULL &&
- dlil_input_loop_head == NULL &&
- netisr == 0) {
- assert_wait(&dlil_input_thread_wakeup, THREAD_UNINT);
-#if defined (__i386__)
- thread_block(0);
+ dlil_lock_group = lck_grp_alloc_init("dlil internal locks", grp_attributes);
+#if IFNET_RW_LOCK
+ ifnet_lock_group = lck_grp_alloc_init("ifnet locks", grp_attributes);
#else
- thread_block(dlil_input_thread_continue);
+ ifnet_lock_group = lck_grp_alloc_init("ifnet locks", grp_attributes);
#endif
- /* NOTREACHED */
- }
- }
+ ifnet_head_lock_group = lck_grp_alloc_init("ifnet head lock", grp_attributes);
+ input_lock_grp = lck_grp_alloc_init("dlil input lock", grp_attributes);
+ lck_grp_attr_free(grp_attributes);
+ grp_attributes = 0;
+
+ /* Setup the lock attributes we will use */
+ lck_attributes = lck_attr_alloc_init();
+
+ ifnet_lock_attr = lck_attr_alloc_init();
+
+ dlil_input_lock = lck_spin_alloc_init(input_lock_grp, lck_attributes);
+ input_lock_grp = 0;
+
+ ifnet_head_mutex = lck_rw_alloc_init(ifnet_head_lock_group, lck_attributes);
+ proto_family_mutex = lck_mtx_alloc_init(dlil_lock_group, lck_attributes);
+ dlil_ifnet_mutex = lck_mtx_alloc_init(dlil_lock_group, lck_attributes);
+ dlil_mutex = lck_mtx_alloc_init(dlil_lock_group, lck_attributes);
+
+ lck_attr_free(lck_attributes);
+ lck_attributes = 0;
+
+ /*
+ * Start up the dlil input thread once everything is initialized
+ */
+ (void) kernel_thread(kernel_task, dlil_input_thread);
+ (void) kernel_thread(kernel_task, dlil_call_delayed_detach_thread);
}
-void dlil_input_thread(void)
+int
+dlil_attach_filter(
+ struct ifnet *ifp,
+ const struct iff_filter *if_filter,
+ interface_filter_t *filter_ref)
{
- register thread_t self = current_thread();
- extern void stack_privilege(thread_t thread);
-
- printf("dlil_input_thread %x\n", self);
-
- /*
- * 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();
-}
+ int retval = 0;
+ struct ifnet_filter *filter;
+
+ MALLOC(filter, struct ifnet_filter *, sizeof(*filter), M_NKE, M_WAITOK);
+ if (filter == NULL)
+ return ENOMEM;
+ bzero(filter, sizeof(*filter));
-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;
+
+ 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;
}
-int
-dlil_input_packet(struct ifnet *ifp, struct mbuf *m,
- char *frame_header)
+static int
+dlil_detach_filter_internal(interface_filter_t filter, int detached)
{
- 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
- */
-
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
+ int retval = 0;
- 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)
+ 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;
- else {
- m_freem(m);
- return retval;
- }
}
- }
-
- if (ifp != orig_ifp)
- break;
+
+ /* 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);
- 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.
- */
+ /* Free the filter */
+ FREE(filter, M_NKE);
+
+ return retval;
+}
- retval = (*ifp->if_demux)(ifp, m, frame_header, &ifproto );
+void
+dlil_detach_filter(interface_filter_t filter)
+{
+ if (filter == NULL)
+ return;
+ dlil_detach_filter_internal(filter, 0);
+}
- 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.
- */
- 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;
- }
+static void
+dlil_input_thread_continue(
+ __unused void* foo,
+ __unused wait_result_t wait)
+{
+ while (1) {
+ struct mbuf *m, *m_loop;
+
+ lck_spin_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;
+ lck_spin_unlock(dlil_input_lock);
+
+ /*
+ * 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;
+ }
+
+ proto_input_run();
+
+ if (dlil_input_mbuf_head == NULL &&
+ dlil_input_loop_head == NULL && inject_buckets == 0) {
+ assert_wait(&dlil_input_thread_wakeup, THREAD_UNINT);
+ (void) thread_block(dlil_input_thread_continue);
+ /* NOTREACHED */
+ }
}
- }
+}
+
+void dlil_input_thread(void)
+{
+ register thread_t self = current_thread();
+
+ ml_thread_policy(self, MACHINE_GROUP,
+ (MACHINE_NETWORK_GROUP|MACHINE_NETWORK_NETISR));
+
+ dlil_initialized = 1;
+ dlil_input_thread_ptr = current_thread();
+ dlil_input_thread_continue(NULL, THREAD_RESTART);
+}
- if (retval) {
- if (retval != EJUSTRETURN) {
- m_freem(m);
- return retval;
+int
+dlil_input_with_stats(
+ struct ifnet *ifp,
+ struct mbuf *m_head,
+ struct mbuf *m_tail,
+ const struct ifnet_stat_increment_param *stats)
+{
+ /* WARNING
+ * Because of loopbacked multicast we cannot stuff the ifp in
+ * the rcvif of the packet header: loopback has its own dlil
+ * input queue
+ */
+
+ lck_spin_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;
}
- 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;
+ 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;
}
-
-/*
- * 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;
- }
- }
- }
- }
-
-
-
- retval = (*ifproto->dl_input)(m, frame_header,
- ifp, ifproto->dl_tag,
- TRUE);
-
- if (retval == EJUSTRETURN)
- retval = 0;
- else
- if (retval)
- m_freem(m);
-
- KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_END,0,0,0,0,0);
- return retval;
+ lck_spin_unlock(dlil_input_lock);
+
+ wakeup((caddr_t)&dlil_input_thread_wakeup);
+
+ return 0;
}
-
-
-void ether_input(ifp, eh, m)
- struct ifnet *ifp;
- struct ether_header *eh;
- struct mbuf *m;
-
+int
+dlil_input(struct ifnet *ifp, struct mbuf *m_head, struct mbuf *m_tail)
{
- kprintf("Someone is calling ether_input!!\n");
-
- dlil_input(ifp, m, NULL);
+ return dlil_input_with_stats(ifp, m_head, m_tail, NULL);
}
-
int
-dlil_event(struct ifnet *ifp, struct kern_event_msg *event)
+dlil_input_packet(struct ifnet *ifp, struct mbuf *m,
+ char *frame_header)
{
- 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 retval;
+ struct if_proto *ifproto = 0;
+ protocol_family_t protocol_family;
+ struct ifnet_filter *filter;
- /*
- * Call Interface Module event hook, if any.
- */
+ KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_START,0,0,0,0,0);
+
+ /*
+ * Lock the interface while we run through
+ * the filters and the demux. This lock
+ * protects the filter list and the demux list.
+ */
+ dlil_read_begin();
- if (ifp->if_event) {
- retval = ifp->if_event(ifp, (caddr_t) event);
+ /*
+ * Call family demux module. If the demux module finds a match
+ * for the frame it will fill-in the ifproto pointer.
+ */
- if (retval) {
- (void) thread_funnel_set(network_flock, funnel_state);
+ retval = ifp->if_demux(ifp, m, frame_header, &protocol_family);
+ if (retval != 0)
+ protocol_family = 0;
+ if (retval == EJUSTRETURN) {
+ dlil_read_end();
+ return 0;
+ }
- if (retval == EJUSTRETURN)
- return 0;
- else
- return retval;
- }
- }
+ /* DANGER!!! */
+ if (m->m_flags & (M_BCAST|M_MCAST))
+ ifp->if_imcasts++;
- /*
- * Call dl_event entry point for all protocols attached to this interface
- */
+ /*
+ * Run interface filters
+ */
+
+ /* 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) {
+ int filter_result;
+ if (filter->filt_input && (filter->filt_protocol == 0 ||
+ filter->filt_protocol == protocol_family)) {
+ filter_result = filter->filt_input(filter->filt_cookie, ifp, protocol_family, &m, &frame_header);
+
+ if (filter_result) {
+ dlil_read_end();
+ if (filter_result == EJUSTRETURN) {
+ filter_result = 0;
+ }
+ else {
+ m_freem(m);
+ }
+
+ return filter_result;
+ }
+ }
+ }
+ }
- TAILQ_FOREACH(proto, tmp, next) {
+ /* Demux is done, interface filters have been processed, unlock the mutex */
+ if (retval || ((m->m_flags & M_PROMISC) != 0) ) {
+ dlil_read_end();
+ if (retval != EJUSTRETURN) {
+ m_freem(m);
+ return retval;
+ }
+ else
+ return 0;
+ }
+
+ ifproto = find_attached_proto(ifp, protocol_family);
+
+ if (ifproto == 0) {
+ dlil_read_end();
+ DLIL_PRINTF("ERROR - dlil_input - if_demux didn't return an if_proto pointer\n");
+ m_freem(m);
+ return 0;
+ }
+
/*
- * Call any attached protocol filters.
+ * Hand the packet off to the protocol.
*/
- 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;
- }
- }
- }
-
-
- /*
- * Finally, call the dl_event entry point (if any)
- */
-
- if (proto->dl_event)
- retval = (*proto->dl_event)(event, proto->dl_tag);
-
- if (retval == EJUSTRETURN) {
- (void) thread_funnel_set(network_flock, funnel_state);
- return 0;
- }
- }
-
+ if (ifproto->dl_domain && (ifproto->dl_domain->dom_flags & DOM_REENTRANT) == 0) {
+ lck_mtx_lock(ifproto->dl_domain->dom_mtx);
+ }
- /*
- * Now, post this event to the Kernel Event message queue
- */
+ if (ifproto->proto_kpi == kProtoKPI_DLIL)
+ retval = (*ifproto->kpi.dlil.dl_input)(m, frame_header,
+ ifp, ifproto->protocol_family,
+ TRUE);
+ else
+ retval = ifproto->kpi.v1.input(ifp, ifproto->protocol_family, m, frame_header);
- 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;
+ if (ifproto->dl_domain && (ifproto->dl_domain->dom_flags & DOM_REENTRANT) == 0) {
+ lck_mtx_unlock(ifproto->dl_domain->dom_mtx);
+ }
- kev_post_msg(&kev_msg);
+ dlil_read_end();
- (void) thread_funnel_set(network_flock, funnel_state);
- return 0;
-}
+ if (retval == EJUSTRETURN)
+ retval = 0;
+ else
+ if (retval)
+ m_freem(m);
+ KERNEL_DEBUG(DBG_FNC_DLIL_INPUT | DBG_FUNC_END,0,0,0,0,0);
+ return retval;
+}
+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) {
+ /* Pass the event to the protocol */
+ if (proto->proto_kpi == kProtoKPI_DLIL) {
+ if (proto->kpi.dlil.dl_event)
+ proto->kpi.dlil.dl_event(ifp, event);
+ }
+ else {
+ if (proto->kpi.v1.event)
+ proto->kpi.v1.event(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);
+}
int
-dlil_output(u_long dl_tag,
- struct mbuf *m,
- caddr_t route,
- 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);
-
- /*
- * Temporary hackery until all the existing protocols can become fully
- * "dl_tag aware". Some things only have the ifp, so this handles that
- * case for the time being.
- */
+dlil_event(struct ifnet *ifp, struct kern_event_msg *event)
+{
+ int result = 0;
- if (dl_tag > MAX_DL_TAGS) {
- /* dl_tag is really an ifnet pointer! */
+ struct kev_msg kev_msg;
- ifp = (struct ifnet *) dl_tag;
- dl_tag = ifp->if_data.default_proto;
- if (dl_tag)
- proto = dl_tag_array[dl_tag].proto;
- else
- retval = ENOENT;
- }
- else {
- if ((dl_tag == 0) || (dl_tag_array[dl_tag].ifp == 0))
- retval = ENOENT;
- else {
- ifp = dl_tag_array[dl_tag].ifp;
- proto = dl_tag_array[dl_tag].proto;
- }
- }
-
- if (retval) {
- m_freem(m);
- return retval;
- }
+ 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;
+
- frame_type = frame_type_buffer;
- dst_linkaddr = dst_linkaddr_buffer;
+ result = dlil_event_internal(ifp, &kev_msg);
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- 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;
- }
- }
- }
-
-/*
- * Run any attached protocol filters.
- */
+ return result;
+}
- 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);
- if (retval) {
- if (retval == EJUSTRETURN)
- return 0;
- else {
- m_freem(m);
- return retval;
- }
+int
+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 = 0;
+ char *dst_linkaddr = 0;
+ int error, 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;
+ struct mbuf *m;
+
+ KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_START,0,0,0,0,0);
+#if BRIDGE
+ if ((raw != 0) || proto_family != PF_INET || do_brige) {
+#else
+ if ((raw != 0) || proto_family != PF_INET) {
+#endif
+ while (packetlist) {
+ m = packetlist;
+ packetlist = packetlist->m_nextpkt;
+ m->m_nextpkt = NULL;
+ error = dlil_output(ifp, proto_family, m, route, dest, raw);
+ if (error) {
+ if (packetlist)
+ m_freem_list(packetlist);
+ return (error);
+ }
}
- }
+ return (0);
+ }
+
+ dlil_read_begin();
+
+ frame_type = frame_type_buffer;
+ dst_linkaddr = dst_linkaddr_buffer;
+ m = packetlist;
+ packetlist = packetlist->m_nextpkt;
+ m->m_nextpkt = NULL;
+
+ proto = find_attached_proto(ifp, proto_family);
+ if (proto == NULL) {
+ retval = ENXIO;
+ goto cleanup;
}
- }
+ retval = 0;
+ if (proto->proto_kpi == kProtoKPI_DLIL) {
+ if (proto->kpi.dlil.dl_pre_output)
+ retval = proto->kpi.dlil.dl_pre_output(ifp, proto_family, &m, dest, route, frame_type, dst_linkaddr);
+ }
+ else {
+ if (proto->kpi.v1.pre_output)
+ retval = proto->kpi.v1.pre_output(ifp, proto_family, &m, dest, route, frame_type, dst_linkaddr);
+ }
-/*
- * 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 (retval != EJUSTRETURN) {
+ m_freem(m);
+ }
+ goto cleanup;
}
- }
-#if BRIDGE
- if (do_bridge) {
- struct mbuf *m0 = m ;
+ do {
+
+
+ if (ifp->if_framer) {
+ retval = ifp->if_framer(ifp, &m, dest, dst_linkaddr, frame_type);
+ if (retval) {
+ if (retval != EJUSTRETURN) {
+ m_freem(m);
+ }
+ goto cleanup;
+ }
+ }
+
+ /*
+ * 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)
+ continue;
+ else {
+ m_freem(m);
+ }
+ goto cleanup;
+ }
+ }
+ }
+ }
+ /*
+ * Finally, call the driver.
+ */
- if (m->m_pkthdr.rcvif)
- m->m_pkthdr.rcvif = NULL ;
- ifp = bridge_dst_lookup(m);
- bdg_forward(&m0, ifp);
- if (m0)
- m_freem(m0);
+ 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_list: output error retval = %x\n", retval);
+ goto cleanup;
+ }
+ KERNEL_DEBUG(DBG_FNC_DLIL_IFOUT | DBG_FUNC_END, 0,0,0,0,0);
- return 0;
- }
-#endif
+ 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);
-/*
- * Let interface filters (if any) do their thing ...
- */
+cleanup:
+ dlil_read_end();
+ if (packetlist) /* if any packet left, clean up */
+ m_freem_list(packetlist);
+ if (retval == EJUSTRETURN)
+ retval = 0;
+ return retval;
+}
- 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;
+/*
+ * 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.
+ */
+int
+dlil_output(
+ struct ifnet* ifp,
+ u_long proto_family,
+ struct mbuf *m,
+ caddr_t route,
+ const struct sockaddr *dest,
+ int raw)
+{
+ char *frame_type = 0;
+ char *dst_linkaddr = 0;
+ int retval = 0;
+ char frame_type_buffer[MAX_FRAME_TYPE_SIZE * 4];
+ char dst_linkaddr_buffer[MAX_LINKADDR * 4];
+ struct ifnet_filter *filter;
+
+ 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) {
+ struct if_proto *proto = 0;
+
+ proto = find_attached_proto(ifp, proto_family);
+ if (proto == NULL) {
+ m_freem(m);
+ retval = ENXIO;
+ goto cleanup;
+ }
+
+ retval = 0;
+ if (proto->proto_kpi == kProtoKPI_DLIL) {
+ if (proto->kpi.dlil.dl_pre_output)
+ retval = proto->kpi.dlil.dl_pre_output(ifp, proto_family, &m, dest, route, frame_type, dst_linkaddr);
+ }
+ else {
+ if (proto->kpi.v1.pre_output)
+ retval = proto->kpi.v1.pre_output(ifp, proto_family, &m, dest, route, frame_type, dst_linkaddr);
+ }
+
+ if (retval) {
+ if (retval != EJUSTRETURN) {
+ m_freem(m);
}
- }
-
+ goto cleanup;
+ }
+ }
+
+ /*
+ * 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) {
+ m_freem(m);
+ }
+ goto cleanup;
}
+ }
+
+#if BRIDGE
+ /* !!!LOCKING!!!
+ *
+ * Need to consider how to handle this.
+ */
+ broken-locking
+ if (do_bridge) {
+ struct mbuf *m0 = m;
+ struct ether_header *eh = mtod(m, struct ether_header *);
- if (ifp != orig_ifp)
- break;
- }
+ 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;
}
- }
-
-/*
- * Finally, call the driver.
- */
-
- 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);
-
- KERNEL_DEBUG(DBG_FNC_DLIL_OUTPUT | DBG_FUNC_END,0,0,0,0,0);
+#endif
+
+
+ /*
+ * 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 cleanup;
+ }
+ }
+ }
+ }
+
+ /*
+ * Finally, call the driver.
+ */
+
+ 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);
+
+ 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 (retval == EJUSTRETURN)
+ retval = 0;
return retval;
}
-
int
dlil_ioctl(u_long proto_fam,
struct ifnet *ifp,
u_long ioctl_code,
caddr_t 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;
-
-
- if (proto_fam) {
- retval = dlil_find_dltag(ifp->if_family, ifp->if_unit,
- proto_fam, &dl_tag);
-
- if (retval == 0) {
- if (dl_tag_array[dl_tag].ifp != ifp)
- return ENOENT;
+ struct ifnet_filter *filter;
+ int retval = EOPNOTSUPP;
+ int result = 0;
+ struct if_family_str *if_family;
+ int holding_read = 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;
- }
-}
-
-
-int
-dlil_attach_protocol(struct dlil_proto_reg_str *proto,
- u_long *dl_tag)
-{
- struct ifnet *ifp;
- struct if_proto *ifproto;
- u_long i;
- struct if_family_str *if_family;
- int error;
- struct dlil_proto_head *tmp;
- struct kev_dl_proto_data ev_pr_data;
- int s;
- boolean_t funnel_state;
+ /* 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) {
+ result = EOPNOTSUPP;
+ if (proto->proto_kpi == kProtoKPI_DLIL) {
+ if (proto->kpi.dlil.dl_ioctl)
+ result = proto->kpi.dlil.dl_ioctl(proto_fam, ifp, ioctl_code, ioctl_arg);
+ }
+ else {
+ if (proto->kpi.v1.ioctl)
+ result = proto->kpi.v1.ioctl(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 family handle this ioctl.
+ * If it returns something non-zero and not EOPNOTSUPP, we're done.
+ * If it returns zero, the ioctl was handled, so set retval to zero.
+ */
+ if_family = find_family_module(ifp->if_family);
+ if ((if_family) && (if_family->ifmod_ioctl)) {
+ result = (*if_family->ifmod_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;
+ }
+ }
+ }
+
+ /*
+ * 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 (retval == EJUSTRETURN)
+ retval = 0;
+ return retval;
+}
- if ((proto->protocol_family == 0) || (proto->interface_family == 0))
- return EINVAL;
+__private_extern__ errno_t
+dlil_set_bpf_tap(
+ ifnet_t ifp,
+ bpf_tap_mode mode,
+ bpf_packet_func callback)
+{
+ errno_t error = 0;
+
+ dlil_read_begin();
+ if (ifp->if_set_bpf_tap)
+ error = ifp->if_set_bpf_tap(ifp, mode, callback);
+ dlil_read_end();
+
+ return error;
+}
- 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);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOENT;
- }
+__private_extern__ errno_t
+dlil_resolve_multi(
+ struct ifnet *ifp,
+ const struct sockaddr *proto_addr,
+ struct sockaddr *ll_addr,
+ size_t ll_len)
+{
+ errno_t result = EOPNOTSUPP;
+ struct if_proto *proto;
+ const struct sockaddr *verify;
+
+ dlil_read_begin();
+
+ bzero(ll_addr, ll_len);
+
+ /* Call the protocol first */
+ proto = find_attached_proto(ifp, proto_addr->sa_family);
+ if (proto != NULL && proto->proto_kpi != kProtoKPI_DLIL &&
+ proto->kpi.v1.resolve_multi != NULL) {
+ result = proto->kpi.v1.resolve_multi(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;
+}
- 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);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOENT;
- }
+__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 if_proto *proto;
+ errno_t result = 0;
+
+ dlil_read_begin();
+
+ proto = find_attached_proto(ifp, target_proto->sa_family);
+ if (proto == NULL || proto->proto_kpi == kProtoKPI_DLIL ||
+ proto->kpi.v1.send_arp == NULL) {
+ result = ENOTSUP;
+ }
+ else {
+ result = proto->kpi.v1.send_arp(ifp, arpop, sender_hw, sender_proto,
+ target_hw, target_proto);
+ }
+
+ dlil_read_end();
+
+ return result;
+}
- if (dlil_find_dltag(proto->interface_family, proto->unit_number,
- proto->protocol_family, &i) == 0) {
- thread_funnel_set(network_flock, funnel_state);
- return EEXIST;
- }
+__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;
+
+ 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.
+ */
+ if (IN_LINKLOCAL(((const struct sockaddr_in*)target_proto)->sin_addr.s_addr)
+ && ipv4_ll_arp_aware != 0 && target_proto->sa_family == AF_INET &&
+ arpop == ARPOP_REQUEST) {
+ 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;
+ }
+ }
+ }
+
+ ifnet_list_free(ifp_list);
+ }
+ else {
+ result = dlil_send_arp_internal(ifp, arpop, sender_hw, sender_proto,
+ target_hw, target_proto);
+ }
+
+ return result;
+}
- for (i=1; i < MAX_DL_TAGS; i++)
- if (dl_tag_array[i].ifp == 0)
- break;
+static int
+ifp_use(
+ struct ifnet *ifp,
+ int handle_zero)
+{
+ 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;
+}
- if (i >= MAX_DL_TAGS) {
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOMEM;
- }
+/* 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.
+ */
+static void
+ifp_use_reached_zero(
+ struct ifnet *ifp)
+{
+ struct if_family_str *if_family;
+ ifnet_detached_func free_func;
+
+ dlil_read_begin();
+
+ if (ifp->if_usecnt != 0)
+ panic("ifp_use_reached_zero: ifp->if_usecnt != 0");
+
+ /* Let BPF know we're detaching */
+ bpfdetach(ifp);
+
+ 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] = 0;
+
+ /* 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);
+
+ if_family = find_family_module(ifp->if_family);
+ if (if_family && if_family->del_if)
+ if_family->del_if(ifp);
+#if 0
+ if (--if_family->if_usecnt == 0) {
+ if (if_family->shutdown)
+ (*if_family->shutdown)();
+
+ TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
+ FREE(if_family, M_IFADDR);
+ }
+#endif
- /*
- * Allocate and init a new if_proto structure
- */
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHED, 0, 0);
+ free_func = ifp->if_free;
+ dlil_read_end();
+
+ if (free_func)
+ free_func(ifp);
+}
- ifproto = _MALLOC(sizeof(struct if_proto), M_IFADDR, M_WAITOK);
- if (!ifproto) {
- printf("ERROR - DLIL failed if_proto allocation\n");
- thread_funnel_set(network_flock, funnel_state);
- return ENOMEM;
- }
+static int
+ifp_unuse(
+ struct ifnet *ifp)
+{
+ int oldval;
+ oldval = OSDecrementAtomic((UInt32*)&ifp->if_usecnt);
+ if (oldval == 0)
+ panic("ifp_unuse: ifp(%s%n)->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 */
+}
+
+void
+ifp_reference(
+ struct ifnet *ifp)
+{
+ int oldval;
+ oldval = OSIncrementAtomic(&ifp->if_refcnt);
+}
+
+void
+ifp_release(
+ struct ifnet *ifp)
+{
+ int oldval;
+ oldval = OSDecrementAtomic((UInt32*)&ifp->if_refcnt);
+ if (oldval == 0)
+ panic("dlil_if_reference - refcount decremented past zero!");
+}
+
+extern lck_mtx_t *domain_proto_mtx;
+
+static int
+dlil_attach_protocol_internal(
+ struct if_proto *proto,
+ const struct ddesc_head_str *demux,
+ const struct ifnet_demux_desc *demux_list,
+ u_int32_t demux_count)
+{
+ struct ddesc_head_str temp_head;
+ 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);
+ int if_using_kpi = (ifp->if_eflags & IFEF_USEKPI) != 0;
+ void* free_me = NULL;
- bzero(ifproto, sizeof(struct if_proto));
+ /* setup some of the common values */
+
+ {
+ lck_mtx_lock(domain_proto_mtx);
+ struct domain *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);
+ }
+
+ /*
+ * Convert the demux descriptors to a type the interface
+ * will understand. Checking e_flags should be safe, this
+ * flag won't change.
+ */
+ if (if_using_kpi && demux) {
+ /* Convert the demux linked list to a demux_list */
+ struct dlil_demux_desc *demux_entry;
+ struct ifnet_demux_desc *temp_list = NULL;
+ u_int32_t i = 0;
+
+ TAILQ_FOREACH(demux_entry, demux, next) {
+ i++;
+ }
+
+ temp_list = _MALLOC(sizeof(struct ifnet_demux_desc) * i, M_TEMP, M_WAITOK);
+ free_me = temp_list;
+
+ if (temp_list == NULL)
+ return ENOMEM;
+
+ i = 0;
+ TAILQ_FOREACH(demux_entry, demux, next) {
+ /* dlil_demux_desc types 1, 2, and 3 are obsolete and can not be translated */
+ if (demux_entry->type == 1 ||
+ demux_entry->type == 2 ||
+ demux_entry->type == 3) {
+ FREE(free_me, M_TEMP);
+ return ENOTSUP;
+ }
+
+ temp_list[i].type = demux_entry->type;
+ temp_list[i].data = demux_entry->native_type;
+ temp_list[i].datalen = demux_entry->variants.native_type_length;
+ i++;
+ }
+ demux_count = i;
+ demux_list = temp_list;
+ }
+ else if (!if_using_kpi && demux_list != NULL) {
+ struct dlil_demux_desc *demux_entry;
+ u_int32_t i = 0;
+
+ demux_entry = _MALLOC(sizeof(struct dlil_demux_desc) * demux_count, M_TEMP, M_WAITOK);
+ free_me = demux_entry;
+ if (demux_entry == NULL)
+ return ENOMEM;
+
+ TAILQ_INIT(&temp_head);
+
+ for (i = 0; i < demux_count; i++) {
+ demux_entry[i].type = demux_list[i].type;
+ demux_entry[i].native_type = demux_list[i].data;
+ demux_entry[i].variants.native_type_length = demux_list[i].datalen;
+ TAILQ_INSERT_TAIL(&temp_head, &demux_entry[i], next);
+ }
+ demux = &temp_head;
+ }
+
+ /*
+ * Take the write lock to protect readers and exclude other writers.
+ */
+ dlil_write_begin();
+
+ /* 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();
+ if (free_me)
+ FREE(free_me, M_TEMP);
+ return ENXIO;
+ }
+ ifnet_lock_done(ifp);
+
+ if (find_attached_proto(ifp, proto->protocol_family) != NULL) {
+ dlil_write_end();
+ if (free_me)
+ FREE(free_me, M_TEMP);
+ return EEXIST;
+ }
+
+ /*
+ * Call family module add_proto routine so it can refine the
+ * demux descriptors as it wishes.
+ */
+ if (if_using_kpi)
+ retval = ifp->if_add_proto_u.kpi(ifp, proto->protocol_family, demux_list, demux_count);
+ else {
+ retval = ifp->if_add_proto_u.original(ifp, proto->protocol_family,
+ _cast_non_const(demux));
+ }
+ if (retval) {
+ dlil_write_end();
+ if (free_me)
+ FREE(free_me, M_TEMP);
+ 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);
+ }
- 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;
+ /*
+ * Add to if_proto list for this interface
+ */
+ if_proto_ref(proto);
+ if (proto->proto_kpi == kProtoKPI_DLIL && proto->kpi.dlil.dl_offer)
+ ifp->offercnt++;
+ 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));
+
+ DLIL_PRINTF("Attached protocol %d to %s%d - %d\n", proto->protocol_family,
+ ifp->if_name, ifp->if_unit, retval);
+ if (free_me)
+ FREE(free_me, M_TEMP);
+ return retval;
+}
- 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");
- }
+__private_extern__ int
+dlil_attach_protocol_kpi(ifnet_t ifp, protocol_family_t protocol,
+ const struct ifnet_attach_proto_param *proto_details)
+{
+ int retval = 0;
+ struct if_proto *ifproto = NULL;
+
+ 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, NULL,
+ proto_details->demux_list, proto_details->demux_count);
+
+end:
+ if (retval && ifproto)
+ FREE(ifproto, M_IFADDR);
+ return retval;
+}
- 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);
+int
+dlil_attach_protocol(struct dlil_proto_reg_str *proto)
+{
+ struct ifnet *ifp = NULL;
+ struct if_proto *ifproto = NULL;
+ int retval = 0;
- /*
- * Call family module add_proto routine so it can refine the
- * demux descriptors as it wishes.
- */
- error = (*if_family->add_proto)(&proto->demux_desc_head, ifproto, *dl_tag);
- if (error) {
- dl_tag_array[*dl_tag].ifp = 0;
- FREE(ifproto, M_IFADDR);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return error;
- }
+ /*
+ * Do everything we can before taking the write lock
+ */
+
+ if ((proto->protocol_family == 0) || (proto->interface_family == 0))
+ return EINVAL;
- /*
- * Add to if_proto list for this interface
- */
+ /*
+ * Allocate and init a new if_proto structure
+ */
+ ifproto = _MALLOC(sizeof(struct if_proto), M_IFADDR, M_WAITOK);
+ if (!ifproto) {
+ DLIL_PRINTF("ERROR - DLIL failed if_proto allocation\n");
+ retval = ENOMEM;
+ goto end;
+ }
+
- 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));
-
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
+ /* ifbyfamily returns us an ifp with an incremented if_usecnt */
+ ifp = ifbyfamily(proto->interface_family, proto->unit_number);
+ if (!ifp) {
+ DLIL_PRINTF("dlil_attach_protocol -- no such interface %d unit %d\n",
+ proto->interface_family, proto->unit_number);
+ retval = ENXIO;
+ goto end;
+ }
+
+ bzero(ifproto, sizeof(struct if_proto));
+
+ ifproto->ifp = ifp;
+ ifproto->protocol_family = proto->protocol_family;
+ ifproto->proto_kpi = kProtoKPI_DLIL;
+ ifproto->kpi.dlil.dl_input = proto->input;
+ ifproto->kpi.dlil.dl_pre_output = proto->pre_output;
+ ifproto->kpi.dlil.dl_event = proto->event;
+ ifproto->kpi.dlil.dl_offer = proto->offer;
+ ifproto->kpi.dlil.dl_ioctl = proto->ioctl;
+ ifproto->kpi.dlil.dl_detached = proto->detached;
+
+ retval = dlil_attach_protocol_internal(ifproto, &proto->demux_desc_head, NULL, 0);
+
+end:
+ if (retval && ifproto)
+ FREE(ifproto, M_IFADDR);
+ return retval;
}
+extern void if_rtproto_del(struct ifnet *ifp, int protocol);
+static int
+dlil_detach_protocol_internal(
+ struct if_proto *proto)
+{
+ 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_DLIL) {
+ if (proto->kpi.dlil.dl_detached)
+ proto->kpi.dlil.dl_detached(proto->protocol_family, ifp);
+ }
+ else {
+ if (proto->kpi.v1.detached)
+ proto->kpi.v1.detached(ifp, proto->protocol_family);
+ }
+ if_proto_free(proto);
+
+ /*
+ * Cleanup routes that may still be in the routing table for that interface/protocol pair.
+ */
+
+ 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;
+}
int
-dlil_detach_protocol(u_long dl_tag)
-{
- 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;
- struct dlil_filterq_head *fhead;
- struct kev_dl_proto_data ev_pr_data;
- boolean_t funnel_state;
-
-
- if (dl_tag > MAX_DL_TAGS)
- return ERANGE;
-
- funnel_state = thread_funnel_set(network_flock, TRUE);
-
- s = splnet();
- if (dl_tag_array[dl_tag].ifp == 0) {
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOENT;
- }
+dlil_detach_protocol(struct ifnet *ifp, u_long proto_family)
+{
+ struct if_proto *proto = NULL;
+ int retval = 0;
+ int use_reached_zero = 0;
+
- ifp = dl_tag_array[dl_tag].ifp;
- proto = dl_tag_array[dl_tag].proto;
+ 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;
+ }
+
+ proto = find_attached_proto(ifp, proto_family);
+
+ if (proto == NULL) {
+ retval = ENXIO;
+ dlil_write_end();
+ goto end;
+ }
+
+ /*
+ * Call family module del_proto
+ */
+
+ if (ifp->if_del_proto)
+ ifp->if_del_proto(ifp, proto->protocol_family);
- if_family = find_family_module(ifp->if_family);
- if (if_family == NULL) {
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return ENOENT;
- }
+ if (proto->proto_kpi == kProtoKPI_DLIL && proto->kpi.dlil.dl_offer)
+ ifp->offercnt--;
- tmp = (struct dlil_proto_head *) &ifp->proto_head;
+ 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);
- /*
- * Call family module del_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;
+}
- (*if_family->del_proto)(proto, dl_tag);
+/*
+ * 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.
+ */
+
+static void
+dlil_delayed_detach_thread(__unused void* foo, __unused wait_result_t wait)
+{
+ thread_t self = current_thread();
+ int asserted = 0;
+
+ ml_thread_policy(self, MACHINE_GROUP,
+ (MACHINE_NETWORK_GROUP|MACHINE_NETWORK_NETISR));
+
+ 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);
+ if (proto->proto_kpi == kProtoKPI_DLIL && proto->kpi.dlil.dl_offer)
+ ifp->offercnt--;
+ *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);
+ }
+ }
+}
- /*
- * Remove and deallocate any attached protocol filters
- */
+static void
+dlil_call_delayed_detach_thread(void) {
+ dlil_delayed_detach_thread(NULL, THREAD_RESTART);
+}
- while (filter = TAILQ_FIRST(&proto->pr_flt_head))
- dlil_detach_filter(filter->filter_id);
-
- if (proto->dl_offer)
- ifp->offercnt--;
+extern int if_next_index(void);
- if (ifp->if_data.default_proto == dl_tag)
- ifp->if_data.default_proto = 0;
- dl_tag_array[dl_tag].ifp = 0;
+__private_extern__ int
+dlil_if_attach_with_address(
+ struct ifnet *ifp,
+ const struct sockaddr_dl *ll_addr)
+{
+ u_long interface_family = ifp->if_family;
+ struct if_family_str *if_family = NULL;
+ int stat;
+ struct ifnet *tmp_if;
+ struct proto_hash_entry *new_proto_list = NULL;
+ int locked = 0;
+
+
+ ifnet_head_lock_shared();
+
+ /* 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;
+ }
+ }
+
+ 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
+
+ if (ifp->if_lock == 0) {
+ return ENOMEM;
+ }
+
+ // Only use family if this is not a KPI interface
+ if ((ifp->if_eflags & IFEF_USEKPI) == 0) {
+ if_family = find_family_module(interface_family);
+ }
+
+ /*
+ * Allow interfaces withouth protocol families to attach
+ * only if they have the necessary fields filled out.
+ */
+
+ if ((if_family == 0) &&
+ (ifp->if_add_proto == 0 || ifp->if_del_proto == 0)) {
+ DLIL_PRINTF("Attempt to attach interface without family module - %d\n",
+ interface_family);
+ return ENODEV;
+ }
- /* the reserved field carries the number of protocol still attached (subject to change) */
- ev_pr_data.proto_family = proto->protocol_family;
- TAILQ_REMOVE(tmp, proto, next);
- FREE(proto, M_IFADDR);
+ 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);
- 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 && (ifp->if_eflags & IFEF_DETACH_DISABLED) == 0) {
- if (ifp->if_flags & IFF_UP)
- printf("WARNING - dlil_detach_protocol - ifp refcnt 0, but IF still up\n");
-
- 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);
+ if (new_proto_list == 0) {
+ return ENOBUFS;
+ }
}
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
- while (orig_ifp != ifp) {
- orig_ifp = ifp;
+ dlil_write_begin();
+ locked = 1;
- 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;
- }
+ /*
+ * Call the family module to fill in the appropriate fields in the
+ * ifnet structure.
+ */
+
+ if (if_family) {
+ stat = if_family->add_if(ifp);
+ if (stat) {
+ DLIL_PRINTF("dlil_if_attach -- add_if failed with %d\n", stat);
+ dlil_write_end();
+ return stat;
}
- if (ifp != orig_ifp)
- break;
- }
+ ifp->if_add_proto_u.original = if_family->add_proto;
+ ifp->if_del_proto = if_family->del_proto;
+ if_family->refcnt++;
+ }
+
+ ifp->offercnt = 0;
+ 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 = 0;
}
- dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_DETACHED, 0, 0);
+ /* old_if_attach */
+ {
+ struct ifaddr *ifa = 0;
+
+ 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) {
+ char workbuf[64];
+ int namelen, masklen, socksize, ifasize;
+
+ ifp->if_index = if_next_index();
+
+ 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;
+ 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("dlil_if_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;
+ }
+ }
+ else {
+ /* preserve the first ifaddr */
+ ifnet_addrs[ifp->if_index - 1] = TAILQ_FIRST(&ifp->if_addrhead);
+ }
+
- (*ifp->if_free)(ifp);
- }
+ 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);
+ }
+
+ TAILQ_INSERT_TAIL(&ifnet_head, ifp, if_link);
+ ifindex2ifnet[ifp->if_index] = ifp;
+
+ ifnet_head_done();
+ }
+ dlil_write_end();
+
+ if (if_family && if_family->init_if) {
+ stat = if_family->init_if(ifp);
+ if (stat) {
+ DLIL_PRINTF("dlil_if_attach -- init_if failed with %d\n", stat);
+ }
+ }
+
+ dlil_post_msg(ifp, KEV_DL_SUBCLASS, KEV_DL_IF_ATTACHED, 0, 0);
+ ifnet_lock_done(ifp);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
return 0;
}
-
-
-
-
int
dlil_if_attach(struct ifnet *ifp)
{
- 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;
- }
-
-
- /*
- * 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;
- }
-
- /*
- * 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->refcnt = 1;
- ifp->offercnt = 0;
- TAILQ_INIT(&ifp->if_flt_head);
- old_if_attach(ifp);
- if_family->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;
+ dlil_if_attach_with_address(ifp, NULL);
}
int
dlil_if_detach(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 (ifp->if_flags & IFF_UP)
- printf("WARNING - dlil_if_detach called for UP interface\n");
-
- 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 && (ifp->if_eflags & IFEF_DETACH_DISABLED) == 0) {
- TAILQ_REMOVE(&ifnet, ifp, if_link);
+ struct ifnet_filter *filter;
+ struct ifnet_filter *filter_next;
+ int zeroed = 0;
+ int retval = 0;
+ struct ifnet_filter_head fhead;
- (*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);
+
+ ifnet_lock_exclusive(ifp);
+
+ if ((ifp->if_eflags & IFEF_DETACHING) != 0) {
+ /* Interface has already been detached */
+ ifnet_lock_done(ifp);
+ return ENXIO;
}
-
- 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;
- }
+
+ /*
+ * 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, 0, 0);
+
+ if ((retval = dlil_write_begin()) != 0) {
+ if (retval == EDEADLK) {
+ retval = DLIL_WAIT_FOR_FREE;
+
+ /* 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);
+
+ /* unuse the interface */
+ zeroed = ifp_unuse(ifp);
+
+ 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) {
+ retval = DLIL_WAIT_FOR_FREE;
+ }
+ else
+ {
+ ifp_use_reached_zero(ifp);
+ }
+
+ return retval;
}
struct dlil_ifmod_reg_str *ifmod)
{
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",
+ DLIL_PRINTF("Attempt to register dlil family module more than once - %d\n",
interface_family);
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
return EEXIST;
}
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);
+ DLIL_PRINTF("dlil_reg_if_modules passed at least one null pointer\n");
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 {
+ return EINVAL;
+ }
+ }
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);
+ DLIL_PRINTF("dlil_reg_if_modules failed allocation\n");
return ENOMEM;
}
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->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;
}
int dlil_dereg_if_modules(u_long interface_family)
{
struct if_family_str *if_family;
- int s;
- boolean_t funnel_state;
+ int ret = 0;
+
- 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;
+ return ENXIO;
}
if (--if_family->refcnt == 0) {
TAILQ_REMOVE(&if_family_head, if_family, if_fam_next);
FREE(if_family, M_IFADDR);
}
- else
+ else {
if_family->flags |= DLIL_SHUTDOWN;
+ ret = DLIL_WAIT_FOR_FREE;
+ }
- splx(s);
- thread_funnel_set(network_flock, funnel_state);
- return 0;
+ return ret;
}
-
-
-/*
- * Old if_attach no-op'ed function defined here for temporary backwards compatibility
- */
-
-void if_attach(ifp)
- struct ifnet *ifp;
-{
- dlil_if_attach(ifp);
-}
-
-
-
int
-dlil_inject_if_input(struct mbuf *m, char *frame_header, u_long from_id)
+dlil_reg_proto_module(
+ u_long protocol_family,
+ u_long interface_family,
+ int (*attach)(struct ifnet *ifp, u_long protocol_family),
+ int (*detach)(struct ifnet *ifp, u_long protocol_family))
{
- 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 > MAX_DLIL_FILTERS)
- return ERANGE;
-
- if (dlil_filters[from_id].type != DLIL_IF_FILTER)
- return ENOENT;
+ struct proto_family_str *proto_family;
- ifp = dlil_filters[from_id].ifp;
+ if (attach == NULL) return EINVAL;
-/*
- * 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;
- }
- }
-
+ lck_mtx_lock(proto_family_mutex);
+
+ TAILQ_FOREACH(proto_family, &proto_family_head, proto_fam_next) {
+ if (proto_family->proto_family == protocol_family &&
+ proto_family->if_family == interface_family) {
+ lck_mtx_unlock(proto_family_mutex);
+ return EEXIST;
}
-
- if (ifp != orig_ifp)
- break;
-
- if (from_id == tmp->filter_id)
- match_found = 1;
- }
- }
- }
-
- 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 ((retval) && (ifp->offercnt)) {
- /*
- * No match was found, look for any offers.
- */
- 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 (retval) {
- if (retval != EJUSTRETURN) {
- m_freem(m);
- return retval;
+ proto_family = (struct proto_family_str *) _MALLOC(sizeof(struct proto_family_str), M_IFADDR, M_WAITOK);
+ if (!proto_family) {
+ lck_mtx_unlock(proto_family_mutex);
+ return ENOMEM;
}
- 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;
- }
-
-/*
- * 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;
- }
- }
- }
- }
+ bzero(proto_family, sizeof(struct proto_family_str));
+ proto_family->proto_family = protocol_family;
+ proto_family->if_family = interface_family & 0xffff;
+ proto_family->attach_proto = attach;
+ proto_family->detach_proto = detach;
-
- 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);
-
- return retval;
-
+ TAILQ_INSERT_TAIL(&proto_family_head, proto_family, proto_fam_next);
+ lck_mtx_unlock(proto_family_mutex);
+ return 0;
}
-
-
-
-
-int
-dlil_inject_pr_input(struct mbuf *m, char *frame_header, u_long from_id)
+int dlil_dereg_proto_module(u_long protocol_family, u_long interface_family)
{
- 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 > MAX_DLIL_FILTERS)
- return ERANGE;
+ struct proto_family_str *proto_family;
+ int ret = 0;
- if (dlil_filters[from_id].type != DLIL_PR_FILTER)
- return ENOENT;
+ lck_mtx_lock(proto_family_mutex);
- ifproto = dlil_filters[from_id].proto;
- ifp = dlil_filters[from_id].ifp;
-
-
-/*
- * Call any attached protocol filters.
- */
+ proto_family = find_proto_module(protocol_family, interface_family);
+ if (proto_family == 0) {
+ lck_mtx_unlock(proto_family_mutex);
+ return ENXIO;
+ }
- 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;
- }
- }
- }
+ TAILQ_REMOVE(&proto_family_head, proto_family, proto_fam_next);
+ FREE(proto_family, M_IFADDR);
- 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);
-
- dlil_stats.inject_pr_in2++;
- return retval;
+ lck_mtx_unlock(proto_family_mutex);
+ return ret;
}
+int dlil_plumb_protocol(u_long protocol_family, struct ifnet *ifp)
+{
+ struct proto_family_str *proto_family;
+ int ret = 0;
+
+ lck_mtx_lock(proto_family_mutex);
+ proto_family = find_proto_module(protocol_family, ifp->if_family);
+ if (proto_family == 0) {
+ lck_mtx_unlock(proto_family_mutex);
+ return ENXIO;
+ }
+ ret = proto_family->attach_proto(ifp, protocol_family);
-int
-dlil_inject_pr_output(struct mbuf *m,
- struct sockaddr *dest,
- int raw,
- char *frame_type,
- char *dst_linkaddr,
- u_long from_id)
-{
- 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;
+ lck_mtx_unlock(proto_family_mutex);
+ return ret;
+}
- if (dst_linkaddr)
- bcopy(dst_linkaddr, &dst_linkaddr_buffer, MAX_LINKADDR * 4);
- else
- return EINVAL;
- }
- if (from_id > MAX_DLIL_FILTERS)
- return ERANGE;
+int dlil_unplumb_protocol(u_long protocol_family, struct ifnet *ifp)
+{
+ struct proto_family_str *proto_family;
+ int ret = 0;
- if (dlil_filters[from_id].type != DLIL_PR_FILTER)
- return ENOENT;
+ lck_mtx_lock(proto_family_mutex);
- ifp = dlil_filters[from_id].ifp;
- dl_tag = dlil_filters[from_id].proto->dl_tag;
+ proto_family = find_proto_module(protocol_family, ifp->if_family);
+ if (proto_family && proto_family->detach_proto)
+ ret = proto_family->detach_proto(ifp, protocol_family);
+ else
+ ret = dlil_detach_protocol(ifp, protocol_family);
+ lck_mtx_unlock(proto_family_mutex);
+ return ret;
+}
- frame_type = frame_type_buffer;
- dst_linkaddr = dst_linkaddr_buffer;
+static errno_t
+dlil_recycle_ioctl(
+ __unused ifnet_t ifnet_ptr,
+ __unused u_int32_t ioctl_code,
+ __unused void *ioctl_arg)
+{
+ return EOPNOTSUPP;
+}
- fhead = (struct dlil_filterq_head *) &ifp->if_flt_head;
-
-/*
- * Run any attached protocol filters.
- */
- match_found = 0;
+static int
+dlil_recycle_output(
+ __unused struct ifnet *ifnet_ptr,
+ struct mbuf *m)
+{
+ m_freem(m);
+ return 0;
+}
- 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;
- }
- }
- }
+static void
+dlil_recycle_free(
+ __unused ifnet_t ifnet_ptr)
+{
+}
- if (tmp->filter_id == from_id)
- match_found = 1;
- }
- }
+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,
+ const void *uniqueid,
+ size_t uniqueid_len,
+ struct ifnet **ifp)
+{
+ struct ifnet *ifp1 = NULL;
+ struct dlil_ifnet *dlifp1 = NULL;
+ int ret = 0;
+
+ lck_mtx_lock(dlil_ifnet_mutex);
+ TAILQ_FOREACH(dlifp1, &dlil_ifnet_head, dl_if_link) {
+
+ ifp1 = (struct ifnet *)dlifp1;
+
+ if (ifp1->if_family == family) {
+
+ /* same uniqueid and same len or no unique id specified */
+ if ((uniqueid_len == dlifp1->if_uniqueid_len)
+ && !bcmp(uniqueid, dlifp1->if_uniqueid, uniqueid_len)) {
+
+ /* check for matching interface in use */
+ if (ifp1->if_eflags & IFEF_INUSE) {
+ if (uniqueid_len) {
+ ret = EBUSY;
+ goto end;
+ }
+ }
+ else {
+ 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;
+ }
+ }
+ }
+ }
-/*
- * 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;
- }
- }
+ /* no interface found, allocate a new one */
+ MALLOC(dlifp1, struct dlil_ifnet *, sizeof(*dlifp1), M_NKE, M_WAITOK);
+ if (dlifp1 == 0) {
+ ret = ENOMEM;
+ goto end;
}
-
-#if BRIDGE
- if (do_bridge) {
- struct mbuf *m0 = m ;
-
- if (m->m_pkthdr.rcvif)
- m->m_pkthdr.rcvif = NULL ;
- ifp = bridge_dst_lookup(m);
- bdg_forward(&m0, ifp);
- if (m0)
- m_freem(m0);
-
- return 0;
+ bzero(dlifp1, sizeof(*dlifp1));
+
+ if (uniqueid_len) {
+ MALLOC(dlifp1->if_uniqueid, void *, uniqueid_len, M_NKE, M_WAITOK);
+ if (dlifp1->if_uniqueid == 0) {
+ FREE(dlifp1, M_NKE);
+ ret = ENOMEM;
+ goto end;
+ }
+ bcopy(uniqueid, dlifp1->if_uniqueid, uniqueid_len);
+ dlifp1->if_uniqueid_len = uniqueid_len;
}
-#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;
- }
- }
+ ifp1 = (struct ifnet *)dlifp1;
+ ifp1->if_eflags |= IFEF_INUSE;
+ ifp1->if_name = dlifp1->if_namestorage;
- }
-
- if (ifp != orig_ifp)
- break;
- }
- }
- }
+ TAILQ_INSERT_TAIL(&dlil_ifnet_head, dlifp1, dl_if_link);
+
+ *ifp = ifp1;
-/*
- * Finally, call the driver.
- */
+end:
+ lck_mtx_unlock(dlil_ifnet_mutex);
- retval = (*ifp->if_output)(ifp, m);
- dlil_stats.inject_pr_out2++;
- if ((retval == 0) || (retval == EJUSTRETURN))
- return 0;
- else
- return retval;
+ return ret;
}
-
-int
-dlil_inject_if_output(struct mbuf *m, u_long from_id)
+void dlil_if_release(struct ifnet *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 > MAX_DLIL_FILTERS)
- return ERANGE;
-
- if (dlil_filters[from_id].type != DLIL_IF_FILTER)
- return ENOENT;
-
- ifp = dlil_filters[from_id].ifp;
+ struct dlil_ifnet *dlifp = (struct dlil_ifnet *)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(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 (ifp != orig_ifp)
- break;
-
- if (from_id == tmp->filter_id)
- match_found = 1;
- }
- }
- }
-
-/*
- * Finally, call the driver.
- */
- retval = (*ifp->if_output)(ifp, m);
- dlil_stats.inject_if_out2++;
- if ((retval == 0) || (retval == EJUSTRETURN))
- return 0;
- else
- return retval;
+ /* 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;
+ ifp->if_free = dlil_recycle_free;
+ ifp->if_set_bpf_tap = dlil_recycle_set_bpf_tap;
+
+ strncpy(dlifp->if_namestorage, ifp->if_name, IFNAMSIZ);
+ ifp->if_name = dlifp->if_namestorage;
+ if (ifp->if_lock)
+ ifnet_lock_done(ifp);
+
}
projects / apple / xnu.git / blobdiff