Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.

===================================================================
RCS file: /ftp/cvs/cvsroot/src/sys/kern/uipc_socket.c,v
rcsdiff: /ftp/cvs/cvsroot/src/sys/kern/uipc_socket.c,v: warning: Unknown phrases like `commitid ...;' are present.
retrieving revision 1.134.2.3
retrieving revision 1.157
diff -u -p -r1.134.2.3 -r1.157
--- src/sys/kern/uipc_socket.c	2007/06/08 14:17:27	1.134.2.3
+++ src/sys/kern/uipc_socket.c	2008/03/27 19:06:52	1.157
@@ -1,7 +1,7 @@
-/*	$NetBSD: uipc_socket.c,v 1.134.2.3 2007/06/08 14:17:27 ad Exp $	*/
+/*	$NetBSD: uipc_socket.c,v 1.157 2008/03/27 19:06:52 ad Exp $	*/
 
 /*-
- * Copyright (c) 2002, 2007 The NetBSD Foundation, Inc.
+ * Copyright (c) 2002, 2007, 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
  *
  * This code is derived from software contributed to The NetBSD Foundation
@@ -68,7 +68,7 @@
  */
 
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.134.2.3 2007/06/08 14:17:27 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.157 2008/03/27 19:06:52 ad Exp $");
 
 #include "opt_sock_counters.h"
 #include "opt_sosend_loan.h"
@@ -79,6 +79,7 @@ __KERNEL_RCSID(0, "$NetBSD: uipc_socket.
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/file.h>
+#include <sys/filedesc.h>
 #include <sys/malloc.h>
 #include <sys/mbuf.h>
 #include <sys/domain.h>
@@ -103,6 +104,8 @@ POOL_INIT(socket_pool, sizeof(struct soc
 MALLOC_DEFINE(M_SOOPTS, "soopts", "socket options");
 MALLOC_DEFINE(M_SONAME, "soname", "socket name");
 
+extern const struct fileops socketops;
+
 extern int	somaxconn;			/* patchable (XXX sysctl) */
 int		somaxconn = SOMAXCONN;
 
@@ -250,26 +253,17 @@ sokvafree(vaddr_t sva, vsize_t len)
 static void
 sodoloanfree(struct vm_page **pgs, void *buf, size_t size)
 {
-	vaddr_t va, sva, eva;
+	vaddr_t sva, eva;
 	vsize_t len;
-	paddr_t pa;
-	int i, npgs;
+	int npgs;
+
+	KASSERT(pgs != NULL);
 
 	eva = round_page((vaddr_t) buf + size);
 	sva = trunc_page((vaddr_t) buf);
 	len = eva - sva;
 	npgs = len >> PAGE_SHIFT;
 
-	if (__predict_false(pgs == NULL)) {
-		pgs = alloca(npgs * sizeof(*pgs));
-
-		for (i = 0, va = sva; va < eva; i++, va += PAGE_SIZE) {
-			if (pmap_extract(pmap_kernel(), va, &pa) == false)
-				panic("sodoloanfree: va 0x%lx not mapped", va);
-			pgs[i] = PHYS_TO_VM_PAGE(pa);
-		}
-	}
-
 	pmap_kremove(sva, len);
 	pmap_update(pmap_kernel());
 	uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);
@@ -277,7 +271,7 @@ sodoloanfree(struct vm_page **pgs, void 
 }
 
 static size_t
-sodopendfree()
+sodopendfree(void)
 {
 	size_t rv;
 
@@ -296,11 +290,10 @@ sodopendfree()
  */
 
 static size_t
-sodopendfreel()
+sodopendfreel(void)
 {
 	struct mbuf *m, *next;
 	size_t rv = 0;
-	int s;
 
 	KASSERT(mutex_owned(&so_pendfree_lock));
 
@@ -311,14 +304,13 @@ sodopendfreel()
 
 		for (; m != NULL; m = next) {
 			next = m->m_next;
+			KASSERT((~m->m_flags & (M_EXT|M_EXT_PAGES)) == 0);
+			KASSERT(m->m_ext.ext_refcnt == 0);
 
 			rv += m->m_ext.ext_size;
-			sodoloanfree((m->m_flags & M_EXT_PAGES) ?
-			    m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,
+			sodoloanfree(m->m_ext.ext_pgs, m->m_ext.ext_buf,
 			    m->m_ext.ext_size);
-			s = splvm();
-			pool_cache_put(&mbpool_cache, m);
-			splx(s);
+			pool_cache_put(mb_cache, m);
 		}
 
 		mutex_enter(&so_pendfree_lock);
@@ -331,15 +323,7 @@ void
 soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)
 {
 
-	if (m == NULL) {
-
-		/*
-		 * called from MEXTREMOVE.
-		 */
-
-		sodoloanfree(NULL, buf, size);
-		return;
-	}
+	KASSERT(m != NULL);
 
 	/*
 	 * postpone freeing mbuf.
@@ -361,8 +345,10 @@ sosend_loan(struct socket *so, struct ui
 	struct iovec *iov = uio->uio_iov;
 	vaddr_t sva, eva;
 	vsize_t len;
-	vaddr_t lva, va;
-	int npgs, i, error;
+	vaddr_t lva;
+	int npgs, error;
+	vaddr_t va;
+	int i;
 
 	if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))
 		return (0);
@@ -427,11 +413,32 @@ sokva_reclaim_callback(struct callback_e
 	return CALLBACK_CHAIN_CONTINUE;
 }
 
+struct mbuf *
+getsombuf(struct socket *so, int type)
+{
+	struct mbuf *m;
+
+	m = m_get(M_WAIT, type);
+	MCLAIM(m, so->so_mowner);
+	return m;
+}
+
+struct mbuf *
+m_intopt(struct socket *so, int val)
+{
+	struct mbuf *m;
+
+	m = getsombuf(so, MT_SOOPTS);
+	m->m_len = sizeof(int);
+	*mtod(m, int *) = val;
+	return m;
+}
+
 void
 soinit(void)
 {
 
-	mutex_init(&so_pendfree_lock, MUTEX_DRIVER, IPL_VM);
+	mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);
 	cv_init(&socurkva_cv, "sokva");
 
 	/* Set the initial adjusted socket buffer size. */
@@ -495,6 +502,8 @@ socreate(int dom, struct socket **aso, i
 	so->so_snd.sb_mowner = &prp->pr_domain->dom_mowner;
 	so->so_mowner = &prp->pr_domain->dom_mowner;
 #endif
+	selinit(&so->so_rcv.sb_sel);
+	selinit(&so->so_snd.sb_sel);
 	uid = kauth_cred_geteuid(l->l_cred);
 	so->so_uidinfo = uid_find(uid);
 	error = (*prp->pr_usrreq)(so, PRU_ATTACH, NULL,
@@ -510,6 +519,35 @@ socreate(int dom, struct socket **aso, i
 	return 0;
 }
 
+/* On success, write file descriptor to fdout and return zero.  On
+ * failure, return non-zero; *fdout will be undefined.
+ */
+int
+fsocreate(int domain, struct socket **sop, int type, int protocol,
+    struct lwp *l, int *fdout)
+{
+	struct socket	*so;
+	struct file	*fp;
+	int		fd, error;
+
+	if ((error = fd_allocfile(&fp, &fd)) != 0)
+		return (error);
+	fp->f_flag = FREAD|FWRITE;
+	fp->f_type = DTYPE_SOCKET;
+	fp->f_ops = &socketops;
+	error = socreate(domain, &so, type, protocol, l);
+	if (error != 0) {
+		fd_abort(curproc, fp, fd);
+	} else {
+		if (sop != NULL)
+			*sop = so;
+		fp->f_data = so;
+		fd_affix(curproc, fp, fd);
+		*fdout = fd;
+	}
+	return error;
+}
+
 int
 sobind(struct socket *so, struct mbuf *nam, struct lwp *l)
 {
@@ -522,13 +560,13 @@ sobind(struct socket *so, struct mbuf *n
 }
 
 int
-solisten(struct socket *so, int backlog)
+solisten(struct socket *so, int backlog, struct lwp *l)
 {
 	int	s, error;
 
 	s = splsoftnet();
 	error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, NULL,
-	    NULL, NULL, NULL);
+	    NULL, NULL, l);
 	if (error != 0) {
 		splx(s);
 		return error;
@@ -565,6 +603,8 @@ sofree(struct socket *so)
 		    RLIM_INFINITY);
 	sbrelease(&so->so_snd, so);
 	sorflush(so);
+	seldestroy(&so->so_rcv.sb_sel);
+	seldestroy(&so->so_snd.sb_sel);
 	pool_put(&socket_pool, so);
 }
 
@@ -600,8 +640,7 @@ soclose(struct socket *so)
 				goto drop;
 		}
 		if (so->so_options & SO_LINGER) {
-			if ((so->so_state & SS_ISDISCONNECTING) &&
-			    (so->so_state & SS_NBIO))
+			if ((so->so_state & SS_ISDISCONNECTING) && so->so_nbio)
 				goto drop;
 			while (so->so_state & SS_ISCONNECTED) {
 				error = tsleep((void *)&so->so_timeo,
@@ -775,8 +814,8 @@ sosend(struct socket *so, struct mbuf *a
 	dontroute =
 	    (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
 	    (so->so_proto->pr_flags & PR_ATOMIC);
-	if (p)
-		p->p_stats->p_ru.ru_msgsnd++;
+	if (l)
+		l->l_ru.ru_msgsnd++;
 	if (control)
 		clen = control->m_len;
 #define	snderr(errno)	{ error = errno; splx(s); goto release; }
@@ -810,7 +849,7 @@ sosend(struct socket *so, struct mbuf *a
 			snderr(EMSGSIZE);
 		if (space < resid + clen &&
 		    (atomic || space < so->so_snd.sb_lowat || space < clen)) {
-			if (so->so_state & SS_NBIO)
+			if (so->so_nbio)
 				snderr(EWOULDBLOCK);
 			sbunlock(&so->so_snd);
 			error = sbwait(&so->so_snd);
@@ -831,7 +870,7 @@ sosend(struct socket *so, struct mbuf *a
 				if (flags & MSG_EOR)
 					top->m_flags |= M_EOR;
 			} else do {
-				if (top == 0) {
+				if (top == NULL) {
 					m = m_gethdr(M_WAIT, MT_DATA);
 					mlen = MHLEN;
 					m->m_pkthdr.len = 0;
@@ -875,14 +914,13 @@ sosend(struct socket *so, struct mbuf *a
 					if (atomic && top == 0 && len < mlen)
 						MH_ALIGN(m, len);
 				}
-				error = uiomove(mtod(m, void *), (int)len,
-				    uio);
+				error = uiomove(mtod(m, void *), (int)len, uio);
  have_data:
 				resid = uio->uio_resid;
 				m->m_len = len;
 				*mp = m;
 				top->m_pkthdr.len += len;
-				if (error)
+				if (error != 0)
 					goto release;
 				mp = &m->m_next;
 				if (resid <= 0) {
@@ -911,10 +949,10 @@ sosend(struct socket *so, struct mbuf *a
 			splx(s);
 
 			clen = 0;
-			control = 0;
-			top = 0;
+			control = NULL;
+			top = NULL;
 			mp = &top;
-			if (error)
+			if (error != 0)
 				goto release;
 		} while (resid && space > 0);
 	} while (resid);
@@ -951,21 +989,24 @@ soreceive(struct socket *so, struct mbuf
 {
 	struct lwp *l = curlwp;
 	struct mbuf	*m, **mp;
-	int		flags, len, error, s, offset, moff, type, orig_resid;
+	int atomic, flags, len, error, s, offset, moff, type, orig_resid;
 	const struct protosw	*pr;
 	struct mbuf	*nextrecord;
 	int		mbuf_removed = 0;
+	const struct domain *dom;
 
 	pr = so->so_proto;
+	atomic = pr->pr_flags & PR_ATOMIC;
+	dom = pr->pr_domain;
 	mp = mp0;
 	type = 0;
 	orig_resid = uio->uio_resid;
 
-	if (paddr)
-		*paddr = 0;
-	if (controlp)
-		*controlp = 0;
-	if (flagsp)
+	if (paddr != NULL)
+		*paddr = NULL;
+	if (controlp != NULL)
+		*controlp = NULL;
+	if (flagsp != NULL)
 		flags = *flagsp &~ MSG_EOR;
 	else
 		flags = 0;
@@ -983,20 +1024,20 @@ soreceive(struct socket *so, struct mbuf
 			error = uiomove(mtod(m, void *),
 			    (int) min(uio->uio_resid, m->m_len), uio);
 			m = m_free(m);
-		} while (uio->uio_resid && error == 0 && m);
+		} while (uio->uio_resid > 0 && error == 0 && m);
  bad:
-		if (m)
+		if (m != NULL)
 			m_freem(m);
-		return (error);
+		return error;
 	}
-	if (mp)
+	if (mp != NULL)
 		*mp = NULL;
 	if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
 		(*pr->pr_usrreq)(so, PRU_RCVD, NULL, NULL, NULL, l);
 
  restart:
 	if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)
-		return (error);
+		return error;
 	s = splsoftnet();
 
 	m = so->so_rcv.sb_mb;
@@ -1011,17 +1052,19 @@ soreceive(struct socket *so, struct mbuf
 	 * we have to do the receive in sections, and thus risk returning
 	 * a short count if a timeout or signal occurs after we start.
 	 */
-	if (m == 0 || (((flags & MSG_DONTWAIT) == 0 &&
-	    so->so_rcv.sb_cc < uio->uio_resid) &&
-	    (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
-	    ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
-	    m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0)) {
+	if (m == NULL ||
+	    ((flags & MSG_DONTWAIT) == 0 &&
+	     so->so_rcv.sb_cc < uio->uio_resid &&
+	     (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
+	      ((flags & MSG_WAITALL) &&
+	       uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
+	     m->m_nextpkt == NULL && !atomic)) {
 #ifdef DIAGNOSTIC
-		if (m == 0 && so->so_rcv.sb_cc)
+		if (m == NULL && so->so_rcv.sb_cc)
 			panic("receive 1");
 #endif
 		if (so->so_error) {
-			if (m)
+			if (m != NULL)
 				goto dontblock;
 			error = so->so_error;
 			if ((flags & MSG_PEEK) == 0)
@@ -1029,12 +1072,12 @@ soreceive(struct socket *so, struct mbuf
 			goto release;
 		}
 		if (so->so_state & SS_CANTRCVMORE) {
-			if (m)
+			if (m != NULL)
 				goto dontblock;
 			else
 				goto release;
 		}
-		for (; m; m = m->m_next)
+		for (; m != NULL; m = m->m_next)
 			if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
 				m = so->so_rcv.sb_mb;
 				goto dontblock;
@@ -1046,7 +1089,7 @@ soreceive(struct socket *so, struct mbuf
 		}
 		if (uio->uio_resid == 0)
 			goto release;
-		if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
+		if (so->so_nbio || (flags & MSG_DONTWAIT)) {
 			error = EWOULDBLOCK;
 			goto release;
 		}
@@ -1055,8 +1098,8 @@ soreceive(struct socket *so, struct mbuf
 		sbunlock(&so->so_rcv);
 		error = sbwait(&so->so_rcv);
 		splx(s);
-		if (error)
-			return (error);
+		if (error != 0)
+			return error;
 		goto restart;
 	}
  dontblock:
@@ -1065,8 +1108,8 @@ soreceive(struct socket *so, struct mbuf
 	 * While we process the initial mbufs containing address and control
 	 * info, we save a copy of m->m_nextpkt into nextrecord.
 	 */
-	if (l)
-		l->l_proc->p_stats->p_ru.ru_msgrcv++;
+	if (l != NULL)
+		l->l_ru.ru_msgrcv++;
 	KASSERT(m == so->so_rcv.sb_mb);
 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 1");
 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 1");
@@ -1084,10 +1127,10 @@ soreceive(struct socket *so, struct mbuf
 		} else {
 			sbfree(&so->so_rcv, m);
 			mbuf_removed = 1;
-			if (paddr) {
+			if (paddr != NULL) {
 				*paddr = m;
 				so->so_rcv.sb_mb = m->m_next;
-				m->m_next = 0;
+				m->m_next = NULL;
 				m = so->so_rcv.sb_mb;
 			} else {
 				MFREE(m, so->so_rcv.sb_mb);
@@ -1095,37 +1138,36 @@ soreceive(struct socket *so, struct mbuf
 			}
 		}
 	}
-	while (m && m->m_type == MT_CONTROL && error == 0) {
+	while (m != NULL && m->m_type == MT_CONTROL && error == 0) {
 		if (flags & MSG_PEEK) {
-			if (controlp)
+			if (controlp != NULL)
 				*controlp = m_copy(m, 0, m->m_len);
 			m = m->m_next;
 		} else {
 			sbfree(&so->so_rcv, m);
 			mbuf_removed = 1;
-			if (controlp) {
-				struct domain *dom = pr->pr_domain;
+			if (controlp != NULL) {
 				if (dom->dom_externalize && l &&
 				    mtod(m, struct cmsghdr *)->cmsg_type ==
 				    SCM_RIGHTS)
 					error = (*dom->dom_externalize)(m, l);
 				*controlp = m;
 				so->so_rcv.sb_mb = m->m_next;
-				m->m_next = 0;
+				m->m_next = NULL;
 				m = so->so_rcv.sb_mb;
 			} else {
 				/*
 				 * Dispose of any SCM_RIGHTS message that went
 				 * through the read path rather than recv.
 				 */
-				if (pr->pr_domain->dom_dispose &&
+				if (dom->dom_dispose &&
 				    mtod(m, struct cmsghdr *)->cmsg_type == SCM_RIGHTS)
-					(*pr->pr_domain->dom_dispose)(m);
+					(*dom->dom_dispose)(m);
 				MFREE(m, so->so_rcv.sb_mb);
 				m = so->so_rcv.sb_mb;
 			}
 		}
-		if (controlp) {
+		if (controlp != NULL) {
 			orig_resid = 0;
 			controlp = &(*controlp)->m_next;
 		}
@@ -1137,7 +1179,7 @@ soreceive(struct socket *so, struct mbuf
 	 * the last packet on the chain (nextrecord == NULL) and we
 	 * change m->m_nextpkt.
 	 */
-	if (m) {
+	if (m != NULL) {
 		if ((flags & MSG_PEEK) == 0) {
 			m->m_nextpkt = nextrecord;
 			/*
@@ -1165,7 +1207,7 @@ soreceive(struct socket *so, struct mbuf
 
 	moff = 0;
 	offset = 0;
-	while (m && uio->uio_resid > 0 && error == 0) {
+	while (m != NULL && uio->uio_resid > 0 && error == 0) {
 		if (m->m_type == MT_OOBDATA) {
 			if (type != MT_OOBDATA)
 				break;
@@ -1189,13 +1231,13 @@ soreceive(struct socket *so, struct mbuf
 		 * we must note any additions to the sockbuf when we
 		 * block interrupts again.
 		 */
-		if (mp == 0) {
+		if (mp == NULL) {
 			SBLASTRECORDCHK(&so->so_rcv, "soreceive uiomove");
 			SBLASTMBUFCHK(&so->so_rcv, "soreceive uiomove");
 			splx(s);
 			error = uiomove(mtod(m, char *) + moff, (int)len, uio);
 			s = splsoftnet();
-			if (error) {
+			if (error != 0) {
 				/*
 				 * If any part of the record has been removed
 				 * (such as the MT_SONAME mbuf, which will
@@ -1207,8 +1249,7 @@ soreceive(struct socket *so, struct mbuf
 				 * This avoids a later panic("receive 1a")
 				 * when compiled with DIAGNOSTIC.
 				 */
-				if (m && mbuf_removed
-				    && (pr->pr_flags & PR_ATOMIC))
+				if (m && mbuf_removed && atomic)
 					(void) sbdroprecord(&so->so_rcv);
 
 				goto release;
@@ -1249,16 +1290,14 @@ soreceive(struct socket *so, struct mbuf
 				SBLASTRECORDCHK(&so->so_rcv, "soreceive 3");
 				SBLASTMBUFCHK(&so->so_rcv, "soreceive 3");
 			}
-		} else {
-			if (flags & MSG_PEEK)
-				moff += len;
-			else {
-				if (mp)
-					*mp = m_copym(m, 0, len, M_WAIT);
-				m->m_data += len;
-				m->m_len -= len;
-				so->so_rcv.sb_cc -= len;
-			}
+		} else if (flags & MSG_PEEK)
+			moff += len;
+		else {
+			if (mp != NULL)
+				*mp = m_copym(m, 0, len, M_WAIT);
+			m->m_data += len;
+			m->m_len -= len;
+			so->so_rcv.sb_cc -= len;
 		}
 		if (so->so_oobmark) {
 			if ((flags & MSG_PEEK) == 0) {
@@ -1282,7 +1321,7 @@ soreceive(struct socket *so, struct mbuf
 		 * with a short count but without error.
 		 * Keep sockbuf locked against other readers.
 		 */
-		while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
+		while (flags & MSG_WAITALL && m == NULL && uio->uio_resid > 0 &&
 		    !sosendallatonce(so) && !nextrecord) {
 			if (so->so_error || so->so_state & SS_CANTRCVMORE)
 				break;
@@ -1303,23 +1342,23 @@ soreceive(struct socket *so, struct mbuf
 			SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");
 			SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");
 			error = sbwait(&so->so_rcv);
-			if (error) {
+			if (error != 0) {
 				sbunlock(&so->so_rcv);
 				splx(s);
-				return (0);
+				return 0;
 			}
 			if ((m = so->so_rcv.sb_mb) != NULL)
 				nextrecord = m->m_nextpkt;
 		}
 	}
 
-	if (m && pr->pr_flags & PR_ATOMIC) {
+	if (m && atomic) {
 		flags |= MSG_TRUNC;
 		if ((flags & MSG_PEEK) == 0)
 			(void) sbdroprecord(&so->so_rcv);
 	}
 	if ((flags & MSG_PEEK) == 0) {
-		if (m == 0) {
+		if (m == NULL) {
 			/*
 			 * First part is an inline SB_EMPTY_FIXUP().  Second
 			 * part makes sure sb_lastrecord is up-to-date if
@@ -1345,12 +1384,12 @@ soreceive(struct socket *so, struct mbuf
 		goto restart;
 	}
 
-	if (flagsp)
+	if (flagsp != NULL)
 		*flagsp |= flags;
  release:
 	sbunlock(&so->so_rcv);
 	splx(s);
-	return (error);
+	return error;
 }
 
 int
@@ -1367,7 +1406,7 @@ soshutdown(struct socket *so, int how)
 	if (how == SHUT_WR || how == SHUT_RDWR)
 		return (*pr->pr_usrreq)(so, PRU_SHUTDOWN, NULL,
 		    NULL, NULL, NULL);
-	return (0);
+	return 0;
 }
 
 void
@@ -1397,157 +1436,140 @@ sorflush(struct socket *so)
 	sbrelease(&asb, so);
 }
 
-int
-sosetopt(struct socket *so, int level, int optname, struct mbuf *m0)
+static int
+sosetopt1(struct socket *so, int level, int optname, struct mbuf *m)
 {
-	int		error;
-	struct mbuf	*m;
+	int optval, val;
 	struct linger	*l;
+	struct sockbuf	*sb;
+	struct timeval *tv;
 
-	error = 0;
-	m = m0;
-	if (level != SOL_SOCKET) {
-		if (so->so_proto && so->so_proto->pr_ctloutput)
-			return ((*so->so_proto->pr_ctloutput)
-				  (PRCO_SETOPT, so, level, optname, &m0));
-		error = ENOPROTOOPT;
-	} else {
-		switch (optname) {
+	switch (optname) {
 
-		case SO_LINGER:
-			if (m == NULL || m->m_len != sizeof(struct linger)) {
-				error = EINVAL;
-				goto bad;
-			}
-			l = mtod(m, struct linger *);
-			if (l->l_linger < 0 || l->l_linger > USHRT_MAX ||
-			    l->l_linger > (INT_MAX / hz)) {
-				error = EDOM;
-				goto bad;
-			}
-			so->so_linger = l->l_linger;
-			if (l->l_onoff)
-				so->so_options |= SO_LINGER;
-			else
-				so->so_options &= ~SO_LINGER;
-			break;
+	case SO_LINGER:
+		if (m == NULL || m->m_len != sizeof(struct linger))
+			return EINVAL;
+		l = mtod(m, struct linger *);
+		if (l->l_linger < 0 || l->l_linger > USHRT_MAX ||
+		    l->l_linger > (INT_MAX / hz))
+			return EDOM;
+		so->so_linger = l->l_linger;
+		if (l->l_onoff)
+			so->so_options |= SO_LINGER;
+		else
+			so->so_options &= ~SO_LINGER;
+		break;
 
-		case SO_DEBUG:
-		case SO_KEEPALIVE:
-		case SO_DONTROUTE:
-		case SO_USELOOPBACK:
-		case SO_BROADCAST:
-		case SO_REUSEADDR:
-		case SO_REUSEPORT:
-		case SO_OOBINLINE:
-		case SO_TIMESTAMP:
-			if (m == NULL || m->m_len < sizeof(int)) {
-				error = EINVAL;
-				goto bad;
-			}
-			if (*mtod(m, int *))
-				so->so_options |= optname;
-			else
-				so->so_options &= ~optname;
-			break;
+	case SO_DEBUG:
+	case SO_KEEPALIVE:
+	case SO_DONTROUTE:
+	case SO_USELOOPBACK:
+	case SO_BROADCAST:
+	case SO_REUSEADDR:
+	case SO_REUSEPORT:
+	case SO_OOBINLINE:
+	case SO_TIMESTAMP:
+		if (m == NULL || m->m_len < sizeof(int))
+			return EINVAL;
+		if (*mtod(m, int *))
+			so->so_options |= optname;
+		else
+			so->so_options &= ~optname;
+		break;
+
+	case SO_SNDBUF:
+	case SO_RCVBUF:
+	case SO_SNDLOWAT:
+	case SO_RCVLOWAT:
+		if (m == NULL || m->m_len < sizeof(int))
+			return EINVAL;
+
+		/*
+		 * Values < 1 make no sense for any of these
+		 * options, so disallow them.
+		 */
+		optval = *mtod(m, int *);
+		if (optval < 1)
+			return EINVAL;
+
+		switch (optname) {
 
 		case SO_SNDBUF:
 		case SO_RCVBUF:
+			sb = (optname == SO_SNDBUF) ?
+			    &so->so_snd : &so->so_rcv;
+			if (sbreserve(sb, (u_long)optval, so) == 0)
+				return ENOBUFS;
+			sb->sb_flags &= ~SB_AUTOSIZE;
+			break;
+
+		/*
+		 * Make sure the low-water is never greater than
+		 * the high-water.
+		 */
 		case SO_SNDLOWAT:
+			so->so_snd.sb_lowat =
+			    (optval > so->so_snd.sb_hiwat) ?
+			    so->so_snd.sb_hiwat : optval;
+			break;
 		case SO_RCVLOWAT:
-		    {
-			int optval;
-
-			if (m == NULL || m->m_len < sizeof(int)) {
-				error = EINVAL;
-				goto bad;
-			}
-
-			/*
-			 * Values < 1 make no sense for any of these
-			 * options, so disallow them.
-			 */
-			optval = *mtod(m, int *);
-			if (optval < 1) {
-				error = EINVAL;
-				goto bad;
-			}
-
-			switch (optname) {
+			so->so_rcv.sb_lowat =
+			    (optval > so->so_rcv.sb_hiwat) ?
+			    so->so_rcv.sb_hiwat : optval;
+			break;
+		}
+		break;
 
-			case SO_SNDBUF:
-			case SO_RCVBUF:
-				if (sbreserve(optname == SO_SNDBUF ?
-				    &so->so_snd : &so->so_rcv,
-				    (u_long) optval, so) == 0) {
-					error = ENOBUFS;
-					goto bad;
-				}
-				break;
+	case SO_SNDTIMEO:
+	case SO_RCVTIMEO:
+		if (m == NULL || m->m_len < sizeof(*tv))
+			return EINVAL;
+		tv = mtod(m, struct timeval *);
+		if (tv->tv_sec > (INT_MAX - tv->tv_usec / tick) / hz)
+			return EDOM;
+		val = tv->tv_sec * hz + tv->tv_usec / tick;
+		if (val == 0 && tv->tv_usec != 0)
+			val = 1;
 
-			/*
-			 * Make sure the low-water is never greater than
-			 * the high-water.
-			 */
-			case SO_SNDLOWAT:
-				so->so_snd.sb_lowat =
-				    (optval > so->so_snd.sb_hiwat) ?
-				    so->so_snd.sb_hiwat : optval;
-				break;
-			case SO_RCVLOWAT:
-				so->so_rcv.sb_lowat =
-				    (optval > so->so_rcv.sb_hiwat) ?
-				    so->so_rcv.sb_hiwat : optval;
-				break;
-			}
-			break;
-		    }
+		switch (optname) {
 
 		case SO_SNDTIMEO:
+			so->so_snd.sb_timeo = val;
+			break;
 		case SO_RCVTIMEO:
-		    {
-			struct timeval *tv;
-			int val;
+			so->so_rcv.sb_timeo = val;
+			break;
+		}
+		break;
 
-			if (m == NULL || m->m_len < sizeof(*tv)) {
-				error = EINVAL;
-				goto bad;
-			}
-			tv = mtod(m, struct timeval *);
-			if (tv->tv_sec > (INT_MAX - tv->tv_usec / tick) / hz) {
-				error = EDOM;
-				goto bad;
-			}
-			val = tv->tv_sec * hz + tv->tv_usec / tick;
-			if (val == 0 && tv->tv_usec != 0)
-				val = 1;
+	default:
+		return ENOPROTOOPT;
+	}
+	return 0;
+}
 
-			switch (optname) {
+int
+sosetopt(struct socket *so, int level, int optname, struct mbuf *m)
+{
+	int error, prerr;
 
-			case SO_SNDTIMEO:
-				so->so_snd.sb_timeo = val;
-				break;
-			case SO_RCVTIMEO:
-				so->so_rcv.sb_timeo = val;
-				break;
-			}
-			break;
-		    }
+	if (level == SOL_SOCKET)
+		error = sosetopt1(so, level, optname, m);
+	else
+		error = ENOPROTOOPT;
 
-		default:
-			error = ENOPROTOOPT;
-			break;
-		}
-		if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
-			(void) ((*so->so_proto->pr_ctloutput)
-				  (PRCO_SETOPT, so, level, optname, &m0));
-			m = NULL;	/* freed by protocol */
-		}
-	}
- bad:
-	if (m)
-		(void) m_free(m);
-	return (error);
+	if ((error == 0 || error == ENOPROTOOPT) &&
+	    so->so_proto != NULL && so->so_proto->pr_ctloutput != NULL) {
+		/* give the protocol stack a shot */
+		prerr = (*so->so_proto->pr_ctloutput)(PRCO_SETOPT, so, level,
+		    optname, &m);
+		if (prerr == 0)
+			error = 0;
+		else if (prerr != ENOPROTOOPT)
+			error = prerr;
+	} else if (m != NULL)
+		(void)m_free(m);
+	return error;
 }
 
 int
@@ -1640,8 +1662,9 @@ sogetopt(struct socket *so, int level, i
 void
 sohasoutofband(struct socket *so)
 {
+
 	fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);
-	selwakeup(&so->so_rcv.sb_sel);
+	selnotify(&so->so_rcv.sb_sel, POLLPRI | POLLRDBAND, 0);
 }
 
 static void
@@ -1649,7 +1672,7 @@ filt_sordetach(struct knote *kn)
 {
 	struct socket	*so;
 
-	so = (struct socket *)kn->kn_fp->f_data;
+	so = ((file_t *)kn->kn_obj)->f_data;
 	SLIST_REMOVE(&so->so_rcv.sb_sel.sel_klist, kn, knote, kn_selnext);
 	if (SLIST_EMPTY(&so->so_rcv.sb_sel.sel_klist))
 		so->so_rcv.sb_flags &= ~SB_KNOTE;
@@ -1661,7 +1684,7 @@ filt_soread(struct knote *kn, long hint)
 {
 	struct socket	*so;
 
-	so = (struct socket *)kn->kn_fp->f_data;
+	so = ((file_t *)kn->kn_obj)->f_data;
 	kn->kn_data = so->so_rcv.sb_cc;
 	if (so->so_state & SS_CANTRCVMORE) {
 		kn->kn_flags |= EV_EOF;
@@ -1680,7 +1703,7 @@ filt_sowdetach(struct knote *kn)
 {
 	struct socket	*so;
 
-	so = (struct socket *)kn->kn_fp->f_data;
+	so = ((file_t *)kn->kn_obj)->f_data;
 	SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);
 	if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))
 		so->so_snd.sb_flags &= ~SB_KNOTE;
@@ -1692,7 +1715,7 @@ filt_sowrite(struct knote *kn, long hint
 {
 	struct socket	*so;
 
-	so = (struct socket *)kn->kn_fp->f_data;
+	so = ((file_t *)kn->kn_obj)->f_data;
 	kn->kn_data = sbspace(&so->so_snd);
 	if (so->so_state & SS_CANTSENDMORE) {
 		kn->kn_flags |= EV_EOF;
@@ -1715,7 +1738,7 @@ filt_solisten(struct knote *kn, long hin
 {
 	struct socket	*so;
 
-	so = (struct socket *)kn->kn_fp->f_data;
+	so = ((file_t *)kn->kn_obj)->f_data;
 
 	/*
 	 * Set kn_data to number of incoming connections, not
@@ -1738,7 +1761,7 @@ soo_kqfilter(struct file *fp, struct kno
 	struct socket	*so;
 	struct sockbuf	*sb;
 
-	so = (struct socket *)kn->kn_fp->f_data;
+	so = ((file_t *)kn->kn_obj)->f_data;
 	switch (kn->kn_filter) {
 	case EVFILT_READ:
 		if (so->so_options & SO_ACCEPTCONN)
@@ -1752,13 +1775,66 @@ soo_kqfilter(struct file *fp, struct kno
 		sb = &so->so_snd;
 		break;
 	default:
-		return (1);
+		return (EINVAL);
 	}
 	SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);
 	sb->sb_flags |= SB_KNOTE;
 	return (0);
 }
 
+static int
+sodopoll(struct socket *so, int events)
+{
+	int revents;
+
+	revents = 0;
+
+	if (events & (POLLIN | POLLRDNORM))
+		if (soreadable(so))
+			revents |= events & (POLLIN | POLLRDNORM);
+
+	if (events & (POLLOUT | POLLWRNORM))
+		if (sowritable(so))
+			revents |= events & (POLLOUT | POLLWRNORM);
+
+	if (events & (POLLPRI | POLLRDBAND))
+		if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
+			revents |= events & (POLLPRI | POLLRDBAND);
+
+	return revents;
+}
+
+int
+sopoll(struct socket *so, int events)
+{
+	int revents = 0;
+	int s;
+
+	if ((revents = sodopoll(so, events)) != 0)
+		return revents;
+
+	KERNEL_LOCK(1, curlwp);
+	s = splsoftnet();
+
+	if ((revents = sodopoll(so, events)) == 0) {
+		if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
+			selrecord(curlwp, &so->so_rcv.sb_sel);
+			so->so_rcv.sb_flags |= SB_SEL;
+		}
+
+		if (events & (POLLOUT | POLLWRNORM)) {
+			selrecord(curlwp, &so->so_snd.sb_sel);
+			so->so_snd.sb_flags |= SB_SEL;
+		}
+	}
+
+	splx(s);
+	KERNEL_UNLOCK_ONE(curlwp);
+
+	return revents;
+}
+
+
 #include <sys/sysctl.h>
 
 static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);