X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/89b3af67bb32e691275bf6fa803d1834b2284115..13f56ec4e58bf8687e2a68032c093c0213dd519b:/bsd/kern/uipc_domain.c

diff --git a/bsd/kern/uipc_domain.c b/bsd/kern/uipc_domain.c
index 9bf1001f4..1065d3683 100644
--- a/bsd/kern/uipc_domain.c
+++ b/bsd/kern/uipc_domain.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 1998-2011 Apple Inc. All rights reserved.
  *
  * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
  * 
@@ -25,7 +25,6 @@
  * 
  * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
  */
-/* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
 /*
  * Copyright (c) 1982, 1986, 1993
@@ -75,9 +74,18 @@
 #include <sys/syslog.h>
 #include <sys/queue.h>
 
-void	pffasttimo(void *);
+#include <pexpert/pexpert.h>
+
+void init_domain(struct domain *dp) __attribute__((section("__TEXT, initcode")));
+void prepend_domain(struct domain *dp) __attribute__((section("__TEXT, initcode")));
+
 void	pfslowtimo(void *);
 
+struct protosw *pffindprotonotype(int, int);
+struct protosw *pffindprotonotype_locked(int , int , int);
+struct domain *pffinddomain(int);
+static void net_update_uptime(void);
+
 /*
  * Add/delete 'domain': Link structure into system list,
  *  invoke the domain init, and then the proto inits.
@@ -90,7 +98,27 @@ static lck_grp_attr_t	*domain_proto_mtx_grp_attr;
 lck_mtx_t		*domain_proto_mtx;
 extern int		do_reclaim;
 
-void init_domain(register struct domain *dp)
+extern sysctlfn net_sysctl;
+
+static u_int64_t uptime;
+
+#ifdef INET6
+extern  void ip6_fin(void);
+#endif
+
+static void
+init_proto(struct protosw *pr)
+{
+	TAILQ_INIT(&pr->pr_filter_head);
+	if (pr->pr_init)
+		(*pr->pr_init)();
+
+	/* Make sure pr_init isn't called again!! */
+	pr->pr_init = 0;
+}
+
+void
+init_domain(struct domain *dp)
 {
 	struct protosw  *pr;
 	
@@ -110,8 +138,18 @@ void init_domain(register struct domain *dp)
 			      dp->dom_name, 
 			      (int)(pr - dp->dom_protosw));
 
-		if (pr->pr_init)
-			(*pr->pr_init)();
+#if __APPLE__
+	/*
+	 * Warn that pr_fasttimo (now pr_unused) is deprecated since rdar://7617868
+	 */
+		if (pr->pr_unused != NULL) {
+			printf("init_domain: warning %s, proto %d: pr_fasttimo is deprecated and won't be called\n", 
+				dp->dom_name, pr->pr_protocol);
+		}
+#endif
+
+		init_proto(pr);
+
 	}
 
 	/* Recompute for new protocol */
@@ -123,23 +161,23 @@ void init_domain(register struct domain *dp)
 	max_datalen = MHLEN - max_hdr;
 }
 
-void	concat_domain(struct domain *dp) 
-{
+void
+prepend_domain(struct domain *dp) 
+{	
 	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_OWNED);
 	dp->dom_next = domains; 
 	domains = dp; 
 }
 
 void
-net_add_domain(register struct domain *dp)
-{	register struct protosw *pr;
-
+net_add_domain(struct domain *dp)
+{
 	kprintf("Adding domain %s (family %d)\n", dp->dom_name,
 		dp->dom_family);
 	/* First, link in the domain */
 
 	lck_mtx_lock(domain_proto_mtx);
-	concat_domain(dp);
+	prepend_domain(dp);
 
 	init_domain(dp);
 	lck_mtx_unlock(domain_proto_mtx);
@@ -147,7 +185,7 @@ net_add_domain(register struct domain *dp)
 }
 
 int
-net_del_domain(register struct domain *dp)
+net_del_domain(struct domain *dp)
 {	register struct domain *dp1, *dp2;
 	register int retval = 0;
 
@@ -180,8 +218,7 @@ net_del_domain(register struct domain *dp)
  * note: protocols must use their own domain lock before calling net_add_proto
  */
 int
-net_add_proto(register struct protosw *pp,
-	      register struct domain *dp)
+net_add_proto(struct protosw *pp, struct domain *dp)
 {	register struct protosw *pp1, *pp2;
 
 	for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
@@ -195,13 +232,9 @@ net_add_proto(register struct protosw *pp,
 		dp->dom_protosw = pp;
 	else
 		pp2->pr_next = pp;
-	pp->pr_next = NULL;
-	TAILQ_INIT(&pp->pr_filter_head);
-	if (pp->pr_init)
-		(*pp->pr_init)();
 
-	/* Make sure pr_init isn't called again!! */
-	pp->pr_init = 0;
+	init_proto(pp);
+
 	return(0);
 }
 
@@ -213,10 +246,9 @@ net_add_proto(register struct protosw *pp,
  * note: protocols must use their own domain lock before calling net_del_proto
  */
 int
-net_del_proto(register int type,
-	      register int protocol,
-	      register struct domain *dp)
-{	register struct protosw *pp1, *pp2;
+net_del_proto(int type, int protocol, struct domain *dp)
+{
+	register struct protosw *pp1, *pp2;
 
 	for (pp2 = NULL, pp1 = dp->dom_protosw; pp1; pp1 = pp1->pr_next)
 	{	if (pp1->pr_type == type &&
@@ -235,32 +267,34 @@ net_del_proto(register int type,
 }
 
 
-void
-domaininit()
-{	register struct domain *dp;
-	register struct protosw *pr;
-	extern struct domain localdomain, routedomain, ndrvdomain, inetdomain;
-	extern struct domain systemdomain;
 #if NS
-	extern struct domain nsdomain;
+extern struct domain nsdomain;
 #endif
 #if ISO
-	extern struct domain isodomain;
+extern struct domain isodomain;
 #endif
 #if CCITT
-	extern struct domain ccittdomain;
+extern struct domain ccittdomain;
 #endif
 
 #if NETAT
-	extern struct domain atalkdomain;
+extern struct domain atalkdomain;
 #endif
 #if INET6
-	extern struct domain inet6domain;
+extern struct domain inet6domain;
 #endif
 #if IPSEC
-	extern struct domain keydomain;
+extern struct domain keydomain;
 #endif
 
+extern struct domain routedomain, ndrvdomain, inetdomain;
+extern struct domain systemdomain;
+
+void
+domaininit(void)
+{
+	register struct domain *dp;
+
 	/*
 	 * allocate lock group attribute and group for domain mutexes
 	 */
@@ -283,31 +317,32 @@ domaininit()
 
 	lck_mtx_lock(domain_proto_mtx);
 
-	concat_domain(&localdomain);
-	concat_domain(&routedomain);
-	concat_domain(&inetdomain);
+	prepend_domain(&localdomain);
+	prepend_domain(&inetdomain);
 #if NETAT
-	concat_domain(&atalkdomain);
+	prepend_domain(&atalkdomain);
 #endif
 #if INET6
-	concat_domain(&inet6domain);
+	prepend_domain(&inet6domain);
 #endif
+        prepend_domain(&routedomain);
+
 #if IPSEC
-	concat_domain(&keydomain);
+	prepend_domain(&keydomain);
 #endif
 
 #if NS
-	concat_domain(&nsdomain);
+	prepend_domain(&nsdomain);
 #endif
 #if ISO
-	concat_domain(&isodomain);
+	prepend_domain(&isodomain);
 #endif
 #if CCITT
-	concat_domain(&ccittdomain);
+	prepend_domain(&ccittdomain);
 #endif
-	concat_domain(&ndrvdomain);
+	prepend_domain(&ndrvdomain);
 
-	concat_domain(&systemdomain);
+	prepend_domain(&systemdomain);
 
 	/*
 	 * Now ask them all to init (XXX including the routing domain,
@@ -317,25 +352,45 @@ domaininit()
 		init_domain(dp);
 
 	lck_mtx_unlock(domain_proto_mtx);
-	timeout(pffasttimo, NULL, 1);
 	timeout(pfslowtimo, NULL, 1);
 }
 
+void
+domainfin(void)
+{
+#ifdef INET6
+	ip6_fin();
+#endif
+}
+
+static __inline__ struct domain *
+pffinddomain_locked(int pf)
+{
+	struct domain *dp;
+
+	dp = domains;
+	while (dp != NULL)
+	{	if (dp->dom_family == pf) {
+			break;
+		}
+		dp = dp->dom_next;
+	}
+	return (dp);
+}
+
 struct protosw *
-pffindtype(family, type)
-	int family, type;
+pffindtype(int family, int type)
 {
 	register struct domain *dp;
 	register struct protosw *pr;
 
 	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
 	lck_mtx_lock(domain_proto_mtx);
-	for (dp = domains; dp; dp = dp->dom_next)
-		if (dp->dom_family == family)
-			goto found;
+	dp = pffinddomain_locked(family);
+	if (dp == NULL) {
 	lck_mtx_unlock(domain_proto_mtx);
-	return (0);
-found:
+		return (NULL);
+	}
 	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
 		if (pr->pr_type && pr->pr_type == type) {
 			lck_mtx_unlock(domain_proto_mtx);
@@ -347,25 +402,18 @@ found:
 
 struct domain *
 pffinddomain(int pf)
-{	struct domain *dp;
+{
+	struct domain *dp;
 
 	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
 	lck_mtx_lock(domain_proto_mtx);
-	dp = domains;
-	while (dp)
-	{	if (dp->dom_family == pf) {
+	dp = pffinddomain_locked(pf);
 			lck_mtx_unlock(domain_proto_mtx);
 			return(dp);
 		}
-		dp = dp->dom_next;
-	}
-	lck_mtx_unlock(domain_proto_mtx);
-	return(NULL);
-}
 
 struct protosw *
-pffindproto(family, protocol, type)
-	int family, protocol, type;
+pffindproto(int family, int protocol, int type)
 {
 	register struct protosw *pr;
 	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
@@ -376,8 +424,7 @@ pffindproto(family, protocol, type)
 }
 
 struct protosw *
-pffindproto_locked(family, protocol, type)
-	int family, protocol, type;
+pffindproto_locked(int family, int protocol, int type)
 {
 	register struct domain *dp;
 	register struct protosw *pr;
@@ -385,11 +432,10 @@ pffindproto_locked(family, protocol, type)
 
 	if (family == 0)
 		return (0);
-	for (dp = domains; dp; dp = dp->dom_next)
-		if (dp->dom_family == family)
-			goto found;
-	return (0);
-found:
+	dp = pffinddomain_locked(family);
+	if (dp == NULL) {
+		return (NULL);
+	}
 	for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
 		if ((pr->pr_protocol == protocol) && (pr->pr_type == type))
 			return (pr);
@@ -401,9 +447,43 @@ found:
 	return (maybe);
 }
 
+struct protosw *
+pffindprotonotype_locked(int family, int protocol, __unused int type)
+{
+	register struct domain *dp;
+	register struct protosw *pr;
+
+	if (family == 0)
+		return (0);
+	dp = pffinddomain_locked(family);
+	if (dp == NULL) {
+		return (NULL);
+	}
+	for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
+		if (pr->pr_protocol == protocol) {
+			return (pr);
+		}
+	}
+	return (NULL);
+}
+
+struct protosw *
+pffindprotonotype(int family, int protocol)
+{
+	register struct protosw *pr;
+	if (protocol == 0) {
+		return (NULL);
+	}
+	lck_mtx_assert(domain_proto_mtx, LCK_MTX_ASSERT_NOTOWNED);
+	lck_mtx_lock(domain_proto_mtx);
+	pr = pffindprotonotype_locked(family, protocol, 0);
+	lck_mtx_unlock(domain_proto_mtx);
+	return (pr);
+}
+
 int
 net_sysctl(int *name, u_int namelen, user_addr_t oldp, size_t *oldlenp, 
-           user_addr_t newp, size_t newlen, struct proc *p)
+           user_addr_t newp, size_t newlen, __unused struct proc *p)
 {
 	register struct domain *dp;
 	register struct protosw *pr;
@@ -431,7 +511,7 @@ found:
 	for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
 		if (pr->pr_protocol == protocol && pr->pr_sysctl) {
 			error = (*pr->pr_sysctl)(name + 2, namelen - 2,
-			    oldp, oldlenp, newp, newlen);
+			    (void *)(uintptr_t)oldp, oldlenp, (void *)(uintptr_t)newp, newlen);
 			lck_mtx_unlock(domain_proto_mtx);
 			return (error);
 		}
@@ -440,18 +520,13 @@ found:
 }
 
 void
-pfctlinput(cmd, sa)
-	int cmd;
-	struct sockaddr *sa;
+pfctlinput(int cmd, struct sockaddr *sa)
 {
 	pfctlinput2(cmd, sa, (void*)0);
 }
 
 void
-pfctlinput2(cmd, sa, ctlparam)
-	int cmd;
-	struct sockaddr *sa;
-	void *ctlparam;
+pfctlinput2(int cmd, struct sockaddr *sa, void *ctlparam)
 {
 	struct domain *dp;
 	struct protosw *pr;
@@ -468,38 +543,52 @@ pfctlinput2(cmd, sa, ctlparam)
 }
 
 void
-pfslowtimo(arg)
-	void *arg;
+pfslowtimo(__unused void *arg)
 {
 	register struct domain *dp;
 	register struct protosw *pr;
 
+	/*
+	 * Update coarse-grained networking timestamp (in sec.); the idea
+	 * is to piggy-back on the periodic slow timeout callout to update
+	 * the counter returnable via net_uptime().
+	 */
+	net_update_uptime();
+
 	lck_mtx_lock(domain_proto_mtx);
 	for (dp = domains; dp; dp = dp->dom_next) 
 		for (pr = dp->dom_protosw; pr; pr = pr->pr_next) {
 			if (pr->pr_slowtimo)
 				(*pr->pr_slowtimo)();
-			if (do_reclaim && pr->pr_drain)
+			if ((do_reclaim || (pr->pr_flags & PR_AGGDRAIN)) &&
+			    pr->pr_drain)
 				(*pr->pr_drain)();
 		}
 	do_reclaim = 0;
 	lck_mtx_unlock(domain_proto_mtx);
-	timeout(pfslowtimo, NULL, hz/2);
-        
+	timeout(pfslowtimo, NULL, hz/PR_SLOWHZ);
 }
 
-void
-pffasttimo(arg)
-	void *arg;
+static void
+net_update_uptime(void)
 {
-	register struct domain *dp;
-	register struct protosw *pr;
+	struct timeval tv;
 
-	lck_mtx_lock(domain_proto_mtx);
-	for (dp = domains; dp; dp = dp->dom_next)
-		for (pr = dp->dom_protosw; pr; pr = pr->pr_next)
-			if (pr->pr_fasttimo)
-				(*pr->pr_fasttimo)();
-	lck_mtx_unlock(domain_proto_mtx);
-	timeout(pffasttimo, NULL, hz/5);
+	microuptime(&tv);
+	uptime = tv.tv_sec;
+}
+
+/*
+ * An alternative way to obtain the coarse-grained uptime (in seconds)
+ * for networking code which do not require high-precision timestamp,
+ * as this is significantly cheaper than microuptime().
+ */
+u_int64_t
+net_uptime(void)
+{
+	/* If we get here before pfslowtimo() fires for the first time */
+	if (uptime == 0)
+		net_update_uptime();
+
+	return (uptime);
 }