 @@ -1,2539 +1,2545 @@
-/*	$NetBSD: uipc_socket.c,v 1.263 2018/04/26 19:50:09 maxv Exp $	*/
+/*	$NetBSD: uipc_socket.c,v 1.264 2018/06/06 09:46:46 roy Exp $	*/
 /*-
  * Copyright (c) 2002, 2007, 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of Wasabi Systems, Inc, and by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 2004 The FreeBSD Foundation
  * Copyright (c) 2004 Robert Watson
  * Copyright (c) 1982, 1986, 1988, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)uipc_socket.c	8.6 (Berkeley) 5/2/95
  */
 /*
  * Socket operation routines.
+ *
  * These routines are called by the routines in sys_socket.c or from a
  * system process, and implement the semantics of socket operations by
  * switching out to the protocol specific routines.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.263 2018/04/26 19:50:09 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.264 2018/06/06 09:46:46 roy Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_compat_netbsd.h"
 #include "opt_sock_counters.h"
 #include "opt_sosend_loan.h"
 #include "opt_mbuftrace.h"
 #include "opt_somaxkva.h"
 #include "opt_multiprocessor.h"	/* XXX */
 #include "opt_sctp.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/filedesc.h>
 #include <sys/kmem.h>
 #include <sys/mbuf.h>
 #include <sys/domain.h>
 #include <sys/kernel.h>
 #include <sys/protosw.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/signalvar.h>
 #include <sys/resourcevar.h>
 #include <sys/uidinfo.h>
 #include <sys/event.h>
 #include <sys/poll.h>
 #include <sys/kauth.h>
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #include <sys/kthread.h>
 #ifdef COMPAT_50
 #include <compat/sys/time.h>
 #include <compat/sys/socket.h>
 #endif
 #include <uvm/uvm_extern.h>
 #include <uvm/uvm_loan.h>
 #include <uvm/uvm_page.h>
 MALLOC_DEFINE(M_SONAME, "soname", "socket name");
 extern const struct fileops socketops;
 extern int	somaxconn;			/* patchable (XXX sysctl) */
 int		somaxconn = SOMAXCONN;
 kmutex_t	*softnet_lock;
 #ifdef SOSEND_COUNTERS
 #include <sys/device.h>
 static struct evcnt sosend_loan_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
     NULL, "sosend", "loan big");
 static struct evcnt sosend_copy_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
     NULL, "sosend", "copy big");
 static struct evcnt sosend_copy_small = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
     NULL, "sosend", "copy small");
 static struct evcnt sosend_kvalimit = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
     NULL, "sosend", "kva limit");
 #define	SOSEND_COUNTER_INCR(ev)		(ev)->ev_count++
 EVCNT_ATTACH_STATIC(sosend_loan_big);
 EVCNT_ATTACH_STATIC(sosend_copy_big);
 EVCNT_ATTACH_STATIC(sosend_copy_small);
 EVCNT_ATTACH_STATIC(sosend_kvalimit);
 #else
 #define	SOSEND_COUNTER_INCR(ev)		/* nothing */
 #endif /* SOSEND_COUNTERS */
 #if defined(SOSEND_NO_LOAN) || defined(MULTIPROCESSOR)
 int sock_loan_thresh = -1;
 #else
 int sock_loan_thresh = 4096;
 #endif
 static kmutex_t so_pendfree_lock;
 static struct mbuf *so_pendfree = NULL;
 #ifndef SOMAXKVA
 #define	SOMAXKVA (16 * 1024 * 1024)
 #endif
 int somaxkva = SOMAXKVA;
 static int socurkva;
 static kcondvar_t socurkva_cv;
 static kauth_listener_t socket_listener;
 #define	SOCK_LOAN_CHUNK		65536
 static void sopendfree_thread(void *);
 static kcondvar_t pendfree_thread_cv;
 static lwp_t *sopendfree_lwp;
 static void sysctl_kern_socket_setup(void);
 static struct sysctllog *socket_sysctllog;
 static vsize_t
 sokvareserve(struct socket *so, vsize_t len)
+{
 	int error;
 	mutex_enter(&so_pendfree_lock);
 	while (socurkva + len > somaxkva) {
 		SOSEND_COUNTER_INCR(&sosend_kvalimit);
 		error = cv_wait_sig(&socurkva_cv, &so_pendfree_lock);
 		if (error) {
 			len = 0;
 			break;
+		}
+	}
 	socurkva += len;
 	mutex_exit(&so_pendfree_lock);
 	return len;
+}
 static void
 sokvaunreserve(vsize_t len)
+{
 	mutex_enter(&so_pendfree_lock);
 	socurkva -= len;
 	cv_broadcast(&socurkva_cv);
 	mutex_exit(&so_pendfree_lock);
+}
 /*
  * sokvaalloc: allocate kva for loan.
  */
 vaddr_t
 sokvaalloc(vaddr_t sva, vsize_t len, struct socket *so)
+{
 	vaddr_t lva;
 	/*
 	 * reserve kva.
 	 */
 	if (sokvareserve(so, len) == 0)
 		return 0;
 	/*
 	 * allocate kva.
 	 */
 	lva = uvm_km_alloc(kernel_map, len, atop(sva) & uvmexp.colormask,
 	    UVM_KMF_COLORMATCH | UVM_KMF_VAONLY | UVM_KMF_WAITVA);
 	if (lva == 0) {
 		sokvaunreserve(len);
 		return (0);
+	}
 	return lva;
+}
 /*
  * sokvafree: free kva for loan.
  */
 void
 sokvafree(vaddr_t sva, vsize_t len)
+{
 	/*
 	 * free kva.
 	 */
 	uvm_km_free(kernel_map, sva, len, UVM_KMF_VAONLY);
 	/*
 	 * unreserve kva.
 	 */
 	sokvaunreserve(len);
+}
 static void
 sodoloanfree(struct vm_page **pgs, void *buf, size_t size)
+{
 	vaddr_t sva, eva;
 	vsize_t len;
 	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;
 	pmap_kremove(sva, len);
 	pmap_update(pmap_kernel());
 	uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);
 	sokvafree(sva, len);
+}
 /*
  * sopendfree_thread: free mbufs on "pendfree" list.
  * unlock and relock so_pendfree_lock when freeing mbufs.
  */
 static void
 sopendfree_thread(void *v)
+{
 	struct mbuf *m, *next;
 	size_t rv;
 	mutex_enter(&so_pendfree_lock);
 	for (;;) {
 		rv = 0;
 		while (so_pendfree != NULL) {
 			m = so_pendfree;
 			so_pendfree = NULL;
 			mutex_exit(&so_pendfree_lock);
 			for (; m != NULL; m = next) {
 				next = m->m_next;
 				KASSERT((~m->m_flags & (M_EXT|M_EXT_PAGES)) ==
 );
 				KASSERT(m->m_ext.ext_refcnt == 0);
 				rv += m->m_ext.ext_size;
 				sodoloanfree(m->m_ext.ext_pgs, m->m_ext.ext_buf,
 				    m->m_ext.ext_size);
 				pool_cache_put(mb_cache, m);
+			}
 			mutex_enter(&so_pendfree_lock);
+		}
 		if (rv)
 			cv_broadcast(&socurkva_cv);
 		cv_wait(&pendfree_thread_cv, &so_pendfree_lock);
+	}
 	panic("sopendfree_thread");
 	/* NOTREACHED */
+}
 void
 soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)
+{
 	KASSERT(m != NULL);
 	/*
 	 * postpone freeing mbuf.
+	 *
 	 * we can't do it in interrupt context
 	 * because we need to put kva back to kernel_map.
 	 */
 	mutex_enter(&so_pendfree_lock);
 	m->m_next = so_pendfree;
 	so_pendfree = m;
 	cv_signal(&pendfree_thread_cv);
 	mutex_exit(&so_pendfree_lock);
+}
 static long
 sosend_loan(struct socket *so, struct uio *uio, struct mbuf *m, long space)
+{
 	struct iovec *iov = uio->uio_iov;
 	vaddr_t sva, eva;
 	vsize_t len;
 	vaddr_t lva;
 	int npgs, error;
 	vaddr_t va;
 	int i;
 	if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))
 		return (0);
 	if (iov->iov_len < (size_t) space)
 		space = iov->iov_len;
 	if (space > SOCK_LOAN_CHUNK)
 		space = SOCK_LOAN_CHUNK;
 	eva = round_page((vaddr_t) iov->iov_base + space);
 	sva = trunc_page((vaddr_t) iov->iov_base);
 	len = eva - sva;
 	npgs = len >> PAGE_SHIFT;
 	KASSERT(npgs <= M_EXT_MAXPAGES);
 	lva = sokvaalloc(sva, len, so);
 	if (lva == 0)
 		return 0;
 	error = uvm_loan(&uio->uio_vmspace->vm_map, sva, len,
 	    m->m_ext.ext_pgs, UVM_LOAN_TOPAGE);
 	if (error) {
 		sokvafree(lva, len);
 		return (0);
+	}
 	for (i = 0, va = lva; i < npgs; i++, va += PAGE_SIZE)
 		pmap_kenter_pa(va, VM_PAGE_TO_PHYS(m->m_ext.ext_pgs[i]),
 		    VM_PROT_READ, 0);
 	pmap_update(pmap_kernel());
 	lva += (vaddr_t) iov->iov_base & PAGE_MASK;
 	MEXTADD(m, (void *) lva, space, M_MBUF, soloanfree, so);
 	m->m_flags |= M_EXT_PAGES | M_EXT_ROMAP;
 	uio->uio_resid -= space;
 	/* uio_offset not updated, not set/used for write(2) */
 	uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + space;
 	uio->uio_iov->iov_len -= space;
 	if (uio->uio_iov->iov_len == 0) {
 		uio->uio_iov++;
 		uio->uio_iovcnt--;
+	}
 	return (space);
+}
 struct mbuf *
 getsombuf(struct socket *so, int type)
+{
 	struct mbuf *m;
 	m = m_get(M_WAIT, type);
 	MCLAIM(m, so->so_mowner);
 	return m;
+}
 static int
 socket_listener_cb(kauth_cred_t cred, kauth_action_t action, void *cookie,
     void *arg0, void *arg1, void *arg2, void *arg3)
+{
 	int result;
 	enum kauth_network_req req;
 	result = KAUTH_RESULT_DEFER;
 	req = (enum kauth_network_req)arg0;
 	if ((action != KAUTH_NETWORK_SOCKET) &&
 	    (action != KAUTH_NETWORK_BIND))
 		return result;
 	switch (req) {
 	case KAUTH_REQ_NETWORK_BIND_PORT:
 		result = KAUTH_RESULT_ALLOW;
 		break;
 	case KAUTH_REQ_NETWORK_SOCKET_DROP: {
 		/* Normal users can only drop their own connections. */
 		struct socket *so = (struct socket *)arg1;
 		if (so->so_cred && proc_uidmatch(cred, so->so_cred) == 0)
 			result = KAUTH_RESULT_ALLOW;
 		break;
+		}
 	case KAUTH_REQ_NETWORK_SOCKET_OPEN:
 		/* We allow "raw" routing/bluetooth sockets to anyone. */
 		switch ((u_long)arg1) {
 		case PF_ROUTE:
 		case PF_OROUTE:
 		case PF_BLUETOOTH:
 		case PF_CAN:
 			result = KAUTH_RESULT_ALLOW;
 			break;
 		default:
 			/* Privileged, let secmodel handle this. */
 			if ((u_long)arg2 == SOCK_RAW)
 				break;
 			result = KAUTH_RESULT_ALLOW;
 			break;
+		}
 		break;
 	case KAUTH_REQ_NETWORK_SOCKET_CANSEE:
 		result = KAUTH_RESULT_ALLOW;
 		break;
 	default:
 		break;
+	}
 	return result;
+}
 void
 soinit(void)
+{
 	sysctl_kern_socket_setup();
 	mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);
 	softnet_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
 	cv_init(&socurkva_cv, "sokva");
 	cv_init(&pendfree_thread_cv, "sopendfr");
 	soinit2();
 	/* Set the initial adjusted socket buffer size. */
 	if (sb_max_set(sb_max))
 		panic("bad initial sb_max value: %lu", sb_max);
 	socket_listener = kauth_listen_scope(KAUTH_SCOPE_NETWORK,
 	    socket_listener_cb, NULL);
+}
 void
 soinit1(void)
+{
 	int error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
 	    sopendfree_thread, NULL, &sopendfree_lwp, "sopendfree");
 	if (error)
 		panic("soinit1 %d", error);
+}
 /*
  * socreate: create a new socket of the specified type and the protocol.
+ *
  * => Caller may specify another socket for lock sharing (must not be held).
  * => Returns the new socket without lock held.
  */
 int
 socreate(int dom, struct socket **aso, int type, int proto, struct lwp *l,
 	 struct socket *lockso)
+{
 	const struct protosw	*prp;
 	struct socket	*so;
 	uid_t		uid;
 	int		error;
 	kmutex_t	*lock;
 	error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,
 	    KAUTH_REQ_NETWORK_SOCKET_OPEN, KAUTH_ARG(dom), KAUTH_ARG(type),
 	    KAUTH_ARG(proto));
 	if (error != 0)
 		return error;
 	if (proto)
 		prp = pffindproto(dom, proto, type);
 	else
 		prp = pffindtype(dom, type);
 	if (prp == NULL) {
 		/* no support for domain */
 		if (pffinddomain(dom) == 0)
 			return EAFNOSUPPORT;
 		/* no support for socket type */
 		if (proto == 0 && type != 0)
 			return EPROTOTYPE;
 		return EPROTONOSUPPORT;
+	}
 	if (prp->pr_usrreqs == NULL)
 		return EPROTONOSUPPORT;
 	if (prp->pr_type != type)
 		return EPROTOTYPE;
 	so = soget(true);
 	so->so_type = type;
 	so->so_proto = prp;
 	so->so_send = sosend;
 	so->so_receive = soreceive;
 #ifdef MBUFTRACE
 	so->so_rcv.sb_mowner = &prp->pr_domain->dom_mowner;
 	so->so_snd.sb_mowner = &prp->pr_domain->dom_mowner;
 	so->so_mowner = &prp->pr_domain->dom_mowner;
 #endif
 	uid = kauth_cred_geteuid(l->l_cred);
 	so->so_uidinfo = uid_find(uid);
 	so->so_cpid = l->l_proc->p_pid;
 	/*
 	 * Lock assigned and taken during PCB attach, unless we share
 	 * the lock with another socket, e.g. socketpair(2) case.
 	 */
 	if (lockso) {
 		lock = lockso->so_lock;
 		so->so_lock = lock;
 		mutex_obj_hold(lock);
 		mutex_enter(lock);
+	}
 	/* Attach the PCB (returns with the socket lock held). */
 	error = (*prp->pr_usrreqs->pr_attach)(so, proto);
 	KASSERT(solocked(so));
 	if (error) {
 		KASSERT(so->so_pcb == NULL);
 		so->so_state |= SS_NOFDREF;
 		sofree(so);
 		return error;
+	}
 	so->so_cred = kauth_cred_dup(l->l_cred);
 	sounlock(so);
 	*aso = so;
 	return 0;
+}
 /*
  * fsocreate: create a socket and a file descriptor associated with it.
+ *
  * => 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 proto, int *fdout)
+{
 	lwp_t *l = curlwp;
 	int error, fd, flags;
 	struct socket *so;
 	struct file *fp;
 	if ((error = fd_allocfile(&fp, &fd)) != 0) {
 		return error;
+	}
 	flags = type & SOCK_FLAGS_MASK;
 	fd_set_exclose(l, fd, (flags & SOCK_CLOEXEC) != 0);
 	fp->f_flag = FREAD|FWRITE|((flags & SOCK_NONBLOCK) ? FNONBLOCK : 0)|
 	    ((flags & SOCK_NOSIGPIPE) ? FNOSIGPIPE : 0);
 	fp->f_type = DTYPE_SOCKET;
 	fp->f_ops = &socketops;
 	type &= ~SOCK_FLAGS_MASK;
 	error = socreate(domain, &so, type, proto, l, NULL);
 	if (error) {
 		fd_abort(curproc, fp, fd);
 		return error;
+	}
 	if (flags & SOCK_NONBLOCK) {
 		so->so_state |= SS_NBIO;
+	}
 	fp->f_socket = so;
 	fd_affix(curproc, fp, fd);
 	if (sop != NULL) {
 		*sop = so;
+	}
 	*fdout = fd;
 	return error;
+}
 int
 sofamily(const struct socket *so)
+{
 	const struct protosw *pr;
 	const struct domain *dom;
 	if ((pr = so->so_proto) == NULL)
 		return AF_UNSPEC;
 	if ((dom = pr->pr_domain) == NULL)
 		return AF_UNSPEC;
 	return dom->dom_family;
+}
 int
 sobind(struct socket *so, struct sockaddr *nam, struct lwp *l)
+{
 	int	error;
 	solock(so);
 	if (nam->sa_family != so->so_proto->pr_domain->dom_family) {
 		sounlock(so);
 		return EAFNOSUPPORT;
+	}
 	error = (*so->so_proto->pr_usrreqs->pr_bind)(so, nam, l);
 	sounlock(so);
 	return error;
+}
 int
 solisten(struct socket *so, int backlog, struct lwp *l)
+{
 	int	error;
 	short	oldopt, oldqlimit;
 	solock(so);
 	if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
 	    SS_ISDISCONNECTING)) != 0) {
 		sounlock(so);
 		return EINVAL;
+	}
 	oldopt = so->so_options;
 	oldqlimit = so->so_qlimit;
 	if (TAILQ_EMPTY(&so->so_q))
 		so->so_options |= SO_ACCEPTCONN;
 	if (backlog < 0)
 		backlog = 0;
 	so->so_qlimit = min(backlog, somaxconn);
 	error = (*so->so_proto->pr_usrreqs->pr_listen)(so, l);
 	if (error != 0) {
 		so->so_options = oldopt;
 		so->so_qlimit = oldqlimit;
 		sounlock(so);
 		return error;
+	}
 	sounlock(so);
 	return 0;
+}
 void
 sofree(struct socket *so)
+{
 	u_int refs;
 	KASSERT(solocked(so));
 	if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0) {
 		sounlock(so);
 		return;
+	}
 	if (so->so_head) {
 		/*
 		 * We must not decommission a socket that's on the accept(2)
 		 * queue.  If we do, then accept(2) may hang after select(2)
 		 * indicated that the listening socket was ready.
 		 */
 		if (!soqremque(so, 0)) {
 			sounlock(so);
 			return;
+		}
+	}
 	if (so->so_rcv.sb_hiwat)
 		(void)chgsbsize(so->so_uidinfo, &so->so_rcv.sb_hiwat, 0,
 		    RLIM_INFINITY);
 	if (so->so_snd.sb_hiwat)
 		(void)chgsbsize(so->so_uidinfo, &so->so_snd.sb_hiwat, 0,
 		    RLIM_INFINITY);
 	sbrelease(&so->so_snd, so);
 	KASSERT(!cv_has_waiters(&so->so_cv));
 	KASSERT(!cv_has_waiters(&so->so_rcv.sb_cv));
 	KASSERT(!cv_has_waiters(&so->so_snd.sb_cv));
 	sorflush(so);
 	refs = so->so_aborting;	/* XXX */
 	/* Remove acccept filter if one is present. */
 	if (so->so_accf != NULL)
 		(void)accept_filt_clear(so);
 	sounlock(so);
 	if (refs == 0)		/* XXX */
 		soput(so);
+}
 /*
  * soclose: close a socket on last file table reference removal.
  * Initiate disconnect if connected.  Free socket when disconnect complete.
  */
 int
 soclose(struct socket *so)
+{
 	struct socket *so2;
 	int error = 0;
 	solock(so);
 	if (so->so_options & SO_ACCEPTCONN) {
 		for (;;) {
 			if ((so2 = TAILQ_FIRST(&so->so_q0)) != 0) {
 				KASSERT(solocked2(so, so2));
 				(void) soqremque(so2, 0);
 				/* soabort drops the lock. */
 				(void) soabort(so2);
 				solock(so);
 				continue;
+			}
 			if ((so2 = TAILQ_FIRST(&so->so_q)) != 0) {
 				KASSERT(solocked2(so, so2));
 				(void) soqremque(so2, 1);
 				/* soabort drops the lock. */
 				(void) soabort(so2);
 				solock(so);
 				continue;
+			}
 			break;
+		}
+	}
 	if (so->so_pcb == NULL)
 		goto discard;
 	if (so->so_state & SS_ISCONNECTED) {
 		if ((so->so_state & SS_ISDISCONNECTING) == 0) {
 			error = sodisconnect(so);
 			if (error)
 				goto drop;
+		}
 		if (so->so_options & SO_LINGER) {
 			if ((so->so_state & (SS_ISDISCONNECTING|SS_NBIO)) ==
 			    (SS_ISDISCONNECTING|SS_NBIO))
 				goto drop;
 			while (so->so_state & SS_ISCONNECTED) {
 				error = sowait(so, true, so->so_linger * hz);
 				if (error)
 					break;
+			}
+		}
+	}
  drop:
 	if (so->so_pcb) {
 		KASSERT(solocked(so));
 		(*so->so_proto->pr_usrreqs->pr_detach)(so);
+	}
  discard:
 	KASSERT((so->so_state & SS_NOFDREF) == 0);
 	kauth_cred_free(so->so_cred);
 	so->so_state |= SS_NOFDREF;
 	sofree(so);
 	return error;
+}
 /*
  * Must be called with the socket locked..  Will return with it unlocked.
  */
 int
 soabort(struct socket *so)
+{
 	u_int refs;
 	int error;
 	KASSERT(solocked(so));
 	KASSERT(so->so_head == NULL);
 	so->so_aborting++;		/* XXX */
 	error = (*so->so_proto->pr_usrreqs->pr_abort)(so);
 	refs = --so->so_aborting;	/* XXX */
 	if (error || (refs == 0)) {
 		sofree(so);
 	} else {
 		sounlock(so);
+	}
 	return error;
+}
 int
 soaccept(struct socket *so, struct sockaddr *nam)
+{
 	int error;
 	KASSERT(solocked(so));
 	KASSERT((so->so_state & SS_NOFDREF) != 0);
 	so->so_state &= ~SS_NOFDREF;
 	if ((so->so_state & SS_ISDISCONNECTED) == 0 ||
 	    (so->so_proto->pr_flags & PR_ABRTACPTDIS) == 0)
 		error = (*so->so_proto->pr_usrreqs->pr_accept)(so, nam);
 	else
 		error = ECONNABORTED;
 	return error;
+}
 int
 soconnect(struct socket *so, struct sockaddr *nam, struct lwp *l)
+{
 	int error;
 	KASSERT(solocked(so));
 	if (so->so_options & SO_ACCEPTCONN)
 		return EOPNOTSUPP;
 	/*
 	 * If protocol is connection-based, can only connect once.
 	 * Otherwise, if connected, try to disconnect first.
 	 * This allows user to disconnect by connecting to, e.g.,
 	 * a null address.
 	 */
 	if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
 	    ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
 	    (error = sodisconnect(so)))) {
 		error = EISCONN;
 	} else {
 		if (nam->sa_family != so->so_proto->pr_domain->dom_family) {
 			return EAFNOSUPPORT;
+		}
 		error = (*so->so_proto->pr_usrreqs->pr_connect)(so, nam, l);
+	}
 	return error;
+}
 int
 soconnect2(struct socket *so1, struct socket *so2)
+{
 	KASSERT(solocked2(so1, so2));
 	return (*so1->so_proto->pr_usrreqs->pr_connect2)(so1, so2);
+}
 int
 sodisconnect(struct socket *so)
+{
 	int	error;
 	KASSERT(solocked(so));
 	if ((so->so_state & SS_ISCONNECTED) == 0) {
 		error = ENOTCONN;
 	} else if (so->so_state & SS_ISDISCONNECTING) {
 		error = EALREADY;
 	} else {
 		error = (*so->so_proto->pr_usrreqs->pr_disconnect)(so);
+	}
 	return (error);
+}
 #define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
 /*
  * Send on a socket.
  * If send must go all at once and message is larger than
  * send buffering, then hard error.
  * Lock against other senders.
  * If must go all at once and not enough room now, then
  * inform user that this would block and do nothing.
  * Otherwise, if nonblocking, send as much as possible.
  * The data to be sent is described by "uio" if nonzero,
  * otherwise by the mbuf chain "top" (which must be null
  * if uio is not).  Data provided in mbuf chain must be small
  * enough to send all at once.
+ *
  * Returns nonzero on error, timeout or signal; callers
  * must check for short counts if EINTR/ERESTART are returned.
  * Data and control buffers are freed on return.
  */
 int
 sosend(struct socket *so, struct sockaddr *addr, struct uio *uio,
 	struct mbuf *top, struct mbuf *control, int flags, struct lwp *l)
+{
 	struct mbuf	**mp, *m;
 	long		space, len, resid, clen, mlen;
 	int		error, s, dontroute, atomic;
 	short		wakeup_state = 0;
 	clen = 0;
 	/*
 	 * solock() provides atomicity of access.  splsoftnet() prevents
 	 * protocol processing soft interrupts from interrupting us and
 	 * blocking (expensive).
 	 */
 	s = splsoftnet();
 	solock(so);
 	atomic = sosendallatonce(so) || top;
 	if (uio)
 		resid = uio->uio_resid;
 	else
 		resid = top->m_pkthdr.len;
 	/*
 	 * In theory resid should be unsigned.
 	 * However, space must be signed, as it might be less than 0
 	 * if we over-committed, and we must use a signed comparison
 	 * of space and resid.  On the other hand, a negative resid
 	 * causes us to loop sending 0-length segments to the protocol.
 	 */
 	if (resid < 0) {
 		error = EINVAL;
 		goto out;
+	}
 	dontroute =
 	    (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
 	    (so->so_proto->pr_flags & PR_ATOMIC);
 	l->l_ru.ru_msgsnd++;
 	if (control)
 		clen = control->m_len;
  restart:
 	if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
 		goto out;
 	do {
 		if (so->so_state & SS_CANTSENDMORE) {
 			error = EPIPE;
 			goto release;
+		}
 		if (so->so_error) {
 			error = so->so_error;
 			so->so_error = 0;
 			goto release;
+		}
 		if ((so->so_state & SS_ISCONNECTED) == 0) {
 			if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
 				if (resid || clen == 0) {
 					error = ENOTCONN;
 					goto release;
+				}
 			} else if (addr == NULL) {
 				error = EDESTADDRREQ;
 				goto release;
+			}
+		}
 		space = sbspace(&so->so_snd);
 		if (flags & MSG_OOB)
 			space += 1024;
 		if ((atomic && resid > so->so_snd.sb_hiwat) ||
 		    clen > so->so_snd.sb_hiwat) {
 			error = EMSGSIZE;
 			goto release;
+		}
 		if (space < resid + clen &&
 		    (atomic || space < so->so_snd.sb_lowat || space < clen)) {
 			if ((so->so_state & SS_NBIO) || (flags & MSG_NBIO)) {
 				error = EWOULDBLOCK;
 				goto release;
+			}
 			sbunlock(&so->so_snd);
 			if (wakeup_state & SS_RESTARTSYS) {
 				error = ERESTART;
 				goto out;
+			}
 			error = sbwait(&so->so_snd);
 			if (error)
 				goto out;
 			wakeup_state = so->so_state;
 			goto restart;
+		}
 		wakeup_state = 0;
 		mp = &top;
 		space -= clen;
 		do {
 			if (uio == NULL) {
 				/*
 				 * Data is prepackaged in "top".
 				 */
 				resid = 0;
 				if (flags & MSG_EOR)
 					top->m_flags |= M_EOR;
 			} else do {
 				sounlock(so);
 				splx(s);
 				if (top == NULL) {
 					m = m_gethdr(M_WAIT, MT_DATA);
 					mlen = MHLEN;
 					m->m_pkthdr.len = 0;
 					m_reset_rcvif(m);
 				} else {
 					m = m_get(M_WAIT, MT_DATA);
 					mlen = MLEN;
+				}
 				MCLAIM(m, so->so_snd.sb_mowner);
 				if (sock_loan_thresh >= 0 &&
 				    uio->uio_iov->iov_len >= sock_loan_thresh &&
 				    space >= sock_loan_thresh &&
 				    (len = sosend_loan(so, uio, m,
 						       space)) != 0) {
 					SOSEND_COUNTER_INCR(&sosend_loan_big);
 					space -= len;
 					goto have_data;
+				}
 				if (resid >= MINCLSIZE && space >= MCLBYTES) {
 					SOSEND_COUNTER_INCR(&sosend_copy_big);
 					m_clget(m, M_DONTWAIT);
 					if ((m->m_flags & M_EXT) == 0)
 						goto nopages;
 					mlen = MCLBYTES;
 					if (atomic && top == 0) {
 						len = lmin(MCLBYTES - max_hdr,
 						    resid);
 						m->m_data += max_hdr;
 					} else
 						len = lmin(MCLBYTES, resid);
 					space -= len;
 				} else {
  nopages:
 					SOSEND_COUNTER_INCR(&sosend_copy_small);
 					len = lmin(lmin(mlen, resid), space);
 					space -= len;
 					/*
 					 * For datagram protocols, leave room
 					 * for protocol headers in first mbuf.
 					 */
 					if (atomic && top == 0 && len < mlen)
 						MH_ALIGN(m, len);
+				}
 				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;
 				s = splsoftnet();
 				solock(so);
 				if (error != 0)
 					goto release;
 				mp = &m->m_next;
 				if (resid <= 0) {
 					if (flags & MSG_EOR)
 						top->m_flags |= M_EOR;
 					break;
+				}
 			} while (space > 0 && atomic);
 			if (so->so_state & SS_CANTSENDMORE) {
 				error = EPIPE;
 				goto release;
+			}
 			if (dontroute)
 				so->so_options |= SO_DONTROUTE;
 			if (resid > 0)
 				so->so_state |= SS_MORETOCOME;
 			if (flags & MSG_OOB) {
 				error = (*so->so_proto->pr_usrreqs->pr_sendoob)(
 				    so, top, control);
 			} else {
 				error = (*so->so_proto->pr_usrreqs->pr_send)(so,
 				    top, addr, control, l);
+			}
 			if (dontroute)
 				so->so_options &= ~SO_DONTROUTE;
 			if (resid > 0)
 				so->so_state &= ~SS_MORETOCOME;
 			clen = 0;
 			control = NULL;
 			top = NULL;
 			mp = &top;
 			if (error != 0)
 				goto release;
 		} while (resid && space > 0);
 	} while (resid);
  release:
 	sbunlock(&so->so_snd);
  out:
 	sounlock(so);
 	splx(s);
 	if (top)
 		m_freem(top);
 	if (control)
 		m_freem(control);
 	return (error);
+}
 /*
  * Following replacement or removal of the first mbuf on the first
  * mbuf chain of a socket buffer, push necessary state changes back
  * into the socket buffer so that other consumers see the values
  * consistently.  'nextrecord' is the callers locally stored value of
  * the original value of sb->sb_mb->m_nextpkt which must be restored
  * when the lead mbuf changes.  NOTE: 'nextrecord' may be NULL.
  */
 static void
 sbsync(struct sockbuf *sb, struct mbuf *nextrecord)
+{
 	KASSERT(solocked(sb->sb_so));
 	/*
 	 * First, update for the new value of nextrecord.  If necessary,
 	 * make it the first record.
 	 */
 	if (sb->sb_mb != NULL)
 		sb->sb_mb->m_nextpkt = nextrecord;
 	else
 		sb->sb_mb = nextrecord;
         /*
          * Now update any dependent socket buffer fields to reflect
          * the new state.  This is an inline of SB_EMPTY_FIXUP, with
          * the addition of a second clause that takes care of the
          * case where sb_mb has been updated, but remains the last
          * record.
          */
         if (sb->sb_mb == NULL) {
                 sb->sb_mbtail = NULL;
                 sb->sb_lastrecord = NULL;
         } else if (sb->sb_mb->m_nextpkt == NULL)
                 sb->sb_lastrecord = sb->sb_mb;
+}
 /*
  * Implement receive operations on a socket.
  * We depend on the way that records are added to the sockbuf
  * by sbappend*.  In particular, each record (mbufs linked through m_next)
  * must begin with an address if the protocol so specifies,
  * followed by an optional mbuf or mbufs containing ancillary data,
  * and then zero or more mbufs of data.
  * In order to avoid blocking network interrupts for the entire time here,
  * we splx() while doing the actual copy to user space.
  * Although the sockbuf is locked, new data may still be appended,
  * and thus we must maintain consistency of the sockbuf during that time.
+ *
  * The caller may receive the data as a single mbuf chain by supplying
  * an mbuf **mp0 for use in returning the chain.  The uio is then used
  * only for the count in uio_resid.
  */
 int
 soreceive(struct socket *so, struct mbuf **paddr, struct uio *uio,
 	struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
+{
 	struct lwp *l = curlwp;
 	struct mbuf	*m, **mp, *mt;
 	size_t len, offset, moff, orig_resid;
 	int atomic, flags, error, s, type;
 	const struct protosw	*pr;
 	struct mbuf	*nextrecord;
 	int		mbuf_removed = 0;
 	const struct domain *dom;
 	short		wakeup_state = 0;
 	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 != NULL)
 		*paddr = NULL;
 	if (controlp != NULL)
 		*controlp = NULL;
 	if (flagsp != NULL)
 		flags = *flagsp &~ MSG_EOR;
 	else
 		flags = 0;
 	if (flags & MSG_OOB) {
 		m = m_get(M_WAIT, MT_DATA);
 		solock(so);
 		error = (*pr->pr_usrreqs->pr_recvoob)(so, m, flags & MSG_PEEK);
 		sounlock(so);
 		if (error)
 			goto bad;
 		do {
 			error = uiomove(mtod(m, void *),
 			    MIN(uio->uio_resid, m->m_len), uio);
 			m = m_free(m);
 		} while (uio->uio_resid > 0 && error == 0 && m);
  bad:
 		if (m != NULL)
 			m_freem(m);
 		return error;
+	}
 	if (mp != NULL)
 		*mp = NULL;
 	/*
 	 * solock() provides atomicity of access.  splsoftnet() prevents
 	 * protocol processing soft interrupts from interrupting us and
 	 * blocking (expensive).
 	 */
 	s = splsoftnet();
 	solock(so);
  restart:
 	if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0) {
 		sounlock(so);
 		splx(s);
 		return error;
+	}
 	m = so->so_rcv.sb_mb;
 	/*
 	 * If we have less data than requested, block awaiting more
 	 * (subject to any timeout) if:
 	 *   1. the current count is less than the low water mark,
 	 *   2. MSG_WAITALL is set, and it is possible to do the entire
 	 *	receive operation at once if we block (resid <= hiwat), or
 	 *   3. MSG_DONTWAIT is not set.
 	 * If MSG_WAITALL is set but resid is larger than the receive buffer,
 	 * 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 == 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 == NULL && so->so_rcv.sb_cc)
 			panic("receive 1");
 #endif
-		if (so->so_error) {
+		if (so->so_error || so->so_rerror) {
 			if (m != NULL)
 				goto dontblock;
-			error = so->so_error;
+			if (so->so_error) {
-			so->so_error = 0;
+				error = so->so_error;
 				so->so_error = 0;
 			} else {
 				error = so->so_rerror;
 				so->so_rerror = 0;
+			}
 			goto release;
+		}
 		if (so->so_state & SS_CANTRCVMORE) {
 			if (m != NULL)
 				goto dontblock;
 			else
 				goto release;
+		}
 		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;
+			}
 		if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
 		    (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
 			error = ENOTCONN;
 			goto release;
+		}
 		if (uio->uio_resid == 0)
 			goto release;
 		if ((so->so_state & SS_NBIO) ||
 		    (flags & (MSG_DONTWAIT|MSG_NBIO))) {
 			error = EWOULDBLOCK;
 			goto release;
+		}
 		SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 1");
 		SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 1");
 		sbunlock(&so->so_rcv);
 		if (wakeup_state & SS_RESTARTSYS)
 			error = ERESTART;
 		else
 			error = sbwait(&so->so_rcv);
 		if (error != 0) {
 			sounlock(so);
 			splx(s);
 			return error;
+		}
 		wakeup_state = so->so_state;
 		goto restart;
+	}
  dontblock:
 	/*
 	 * On entry here, m points to the first record of the socket buffer.
 	 * From this point onward, we maintain 'nextrecord' as a cache of the
 	 * pointer to the next record in the socket buffer.  We must keep the
 	 * various socket buffer pointers and local stack versions of the
 	 * pointers in sync, pushing out modifications before dropping the
 	 * socket lock, and re-reading them when picking it up.
+	 *
 	 * Otherwise, we will race with the network stack appending new data
 	 * or records onto the socket buffer by using inconsistent/stale
 	 * versions of the field, possibly resulting in socket buffer
 	 * corruption.
+	 *
 	 * By holding the high-level sblock(), we prevent simultaneous
 	 * readers from pulling off the front of the socket buffer.
 	 */
 	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");
 	nextrecord = m->m_nextpkt;
 	if (pr->pr_flags & PR_ADDR) {
 #ifdef DIAGNOSTIC
 		if (m->m_type != MT_SONAME)
 			panic("receive 1a");
 #endif
 		orig_resid = 0;
 		if (flags & MSG_PEEK) {
 			if (paddr)
 				*paddr = m_copym(m, 0, m->m_len, M_DONTWAIT);
 			m = m->m_next;
 		} else {
 			sbfree(&so->so_rcv, m);
 			mbuf_removed = 1;
 			if (paddr != NULL) {
 				*paddr = m;
 				so->so_rcv.sb_mb = m->m_next;
 				m->m_next = NULL;
 				m = so->so_rcv.sb_mb;
 			} else {
 				m = so->so_rcv.sb_mb = m_free(m);
+			}
 			sbsync(&so->so_rcv, nextrecord);
+		}
+	}
 	if (pr->pr_flags & PR_ADDR_OPT) {
 		/*
 		 * For SCTP we may be getting a
 		 * whole message OR a partial delivery.
 		 */
 		if (m->m_type == MT_SONAME) {
 			orig_resid = 0;
 			if (flags & MSG_PEEK) {
 				if (paddr)
 					*paddr = m_copym(m, 0, m->m_len, M_DONTWAIT);
 				m = m->m_next;
 			} else {
 				sbfree(&so->so_rcv, m);
 				if (paddr) {
 					*paddr = m;
 					so->so_rcv.sb_mb = m->m_next;
 					m->m_next = 0;
 					m = so->so_rcv.sb_mb;
 				} else {
 					m = so->so_rcv.sb_mb = m_free(m);
+				}
+			}
+		}
+	}
 	/*
 	 * Process one or more MT_CONTROL mbufs present before any data mbufs
 	 * in the first mbuf chain on the socket buffer.  If MSG_PEEK, we
 	 * just copy the data; if !MSG_PEEK, we call into the protocol to
 	 * perform externalization (or freeing if controlp == NULL).
 	 */
 	if (__predict_false(m != NULL && m->m_type == MT_CONTROL)) {
 		struct mbuf *cm = NULL, *cmn;
 		struct mbuf **cme = &cm;
 		do {
 			if (flags & MSG_PEEK) {
 				if (controlp != NULL) {
 					*controlp = m_copym(m, 0, m->m_len, M_DONTWAIT);
 					controlp = &(*controlp)->m_next;
+				}
 				m = m->m_next;
 			} else {
 				sbfree(&so->so_rcv, m);
 				so->so_rcv.sb_mb = m->m_next;
 				m->m_next = NULL;
 				*cme = m;
 				cme = &(*cme)->m_next;
 				m = so->so_rcv.sb_mb;
+			}
 		} while (m != NULL && m->m_type == MT_CONTROL);
 		if ((flags & MSG_PEEK) == 0)
 			sbsync(&so->so_rcv, nextrecord);
 		for (; cm != NULL; cm = cmn) {
 			cmn = cm->m_next;
 			cm->m_next = NULL;
 			type = mtod(cm, struct cmsghdr *)->cmsg_type;
 			if (controlp != NULL) {
 				if (dom->dom_externalize != NULL &&
 				    type == SCM_RIGHTS) {
 					sounlock(so);
 					splx(s);
 					error = (*dom->dom_externalize)(cm, l,
 					    (flags & MSG_CMSG_CLOEXEC) ?
 					    O_CLOEXEC : 0);
 					s = splsoftnet();
 					solock(so);
+				}
 				*controlp = cm;
 				while (*controlp != NULL)
 					controlp = &(*controlp)->m_next;
 			} else {
 				/*
 				 * Dispose of any SCM_RIGHTS message that went
 				 * through the read path rather than recv.
 				 */
 				if (dom->dom_dispose != NULL &&
 				    type == SCM_RIGHTS) {
 					sounlock(so);
 					(*dom->dom_dispose)(cm);
 					solock(so);
+				}
 				m_freem(cm);
+			}
+		}
 		if (m != NULL)
 			nextrecord = so->so_rcv.sb_mb->m_nextpkt;
 		else
 			nextrecord = so->so_rcv.sb_mb;
 		orig_resid = 0;
+	}
 	/* If m is non-NULL, we have some data to read. */
 	if (__predict_true(m != NULL)) {
 		type = m->m_type;
 		if (type == MT_OOBDATA)
 			flags |= MSG_OOB;
+	}
 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 2");
 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 2");
 	moff = 0;
 	offset = 0;
 	while (m != NULL && uio->uio_resid > 0 && error == 0) {
 		if (m->m_type == MT_OOBDATA) {
 			if (type != MT_OOBDATA)
 				break;
 		} else if (type == MT_OOBDATA)
 			break;
 #ifdef DIAGNOSTIC
 		else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
 			panic("receive 3");
 #endif
 		so->so_state &= ~SS_RCVATMARK;
 		wakeup_state = 0;
 		len = uio->uio_resid;
 		if (so->so_oobmark && len > so->so_oobmark - offset)
 			len = so->so_oobmark - offset;
 		if (len > m->m_len - moff)
 			len = m->m_len - moff;
 		/*
 		 * If mp is set, just pass back the mbufs.
 		 * Otherwise copy them out via the uio, then free.
 		 * Sockbuf must be consistent here (points to current mbuf,
 		 * it points to next record) when we drop priority;
 		 * we must note any additions to the sockbuf when we
 		 * block interrupts again.
 		 */
 		if (mp == NULL) {
 			SBLASTRECORDCHK(&so->so_rcv, "soreceive uiomove");
 			SBLASTMBUFCHK(&so->so_rcv, "soreceive uiomove");
 			sounlock(so);
 			splx(s);
 			error = uiomove(mtod(m, char *) + moff, len, uio);
 			s = splsoftnet();
 			solock(so);
 			if (error != 0) {
 				/*
 				 * If any part of the record has been removed
 				 * (such as the MT_SONAME mbuf, which will
 				 * happen when PR_ADDR, and thus also
 				 * PR_ATOMIC, is set), then drop the entire
 				 * record to maintain the atomicity of the
 				 * receive operation.
+				 *
 				 * This avoids a later panic("receive 1a")
 				 * when compiled with DIAGNOSTIC.
 				 */
 				if (m && mbuf_removed && atomic)
 					(void) sbdroprecord(&so->so_rcv);
 				goto release;
+			}
 		} else
 			uio->uio_resid -= len;
 		if (len == m->m_len - moff) {
 			if (m->m_flags & M_EOR)
 				flags |= MSG_EOR;
 #ifdef SCTP
 			if (m->m_flags & M_NOTIFICATION)
 				flags |= MSG_NOTIFICATION;
 #endif /* SCTP */
 			if (flags & MSG_PEEK) {
 				m = m->m_next;
 				moff = 0;
 			} else {
 				nextrecord = m->m_nextpkt;
 				sbfree(&so->so_rcv, m);
 				if (mp) {
 					*mp = m;
 					mp = &m->m_next;
 					so->so_rcv.sb_mb = m = m->m_next;
 					*mp = NULL;
 				} else {
 					m = so->so_rcv.sb_mb = m_free(m);
+				}
 				/*
 				 * If m != NULL, we also know that
 				 * so->so_rcv.sb_mb != NULL.
 				 */
 				KASSERT(so->so_rcv.sb_mb == m);
 				if (m) {
 					m->m_nextpkt = nextrecord;
 					if (nextrecord == NULL)
 						so->so_rcv.sb_lastrecord = m;
 				} else {
 					so->so_rcv.sb_mb = nextrecord;
 					SB_EMPTY_FIXUP(&so->so_rcv);
+				}
 				SBLASTRECORDCHK(&so->so_rcv, "soreceive 3");
 				SBLASTMBUFCHK(&so->so_rcv, "soreceive 3");
+			}
 		} else if (flags & MSG_PEEK)
 			moff += len;
 		else {
 			if (mp != NULL) {
 				mt = m_copym(m, 0, len, M_NOWAIT);
 				if (__predict_false(mt == NULL)) {
 					sounlock(so);
 					mt = m_copym(m, 0, len, M_WAIT);
 					solock(so);
+				}
 				*mp = mt;
+			}
 			m->m_data += len;
 			m->m_len -= len;
 			so->so_rcv.sb_cc -= len;
+		}
 		if (so->so_oobmark) {
 			if ((flags & MSG_PEEK) == 0) {
 				so->so_oobmark -= len;
 				if (so->so_oobmark == 0) {
 					so->so_state |= SS_RCVATMARK;
 					break;
+				}
 			} else {
 				offset += len;
 				if (offset == so->so_oobmark)
 					break;
+			}
+		}
 		if (flags & MSG_EOR)
 			break;
 		/*
 		 * If the MSG_WAITALL flag is set (for non-atomic socket),
 		 * we must not quit until "uio->uio_resid == 0" or an error
 		 * termination.  If a signal/timeout occurs, return
 		 * with a short count but without error.
 		 * Keep sockbuf locked against other readers.
 		 */
 		while (flags & MSG_WAITALL && m == NULL && uio->uio_resid > 0 &&
 		    !sosendallatonce(so) && !nextrecord) {
-			if (so->so_error || so->so_state & SS_CANTRCVMORE)
+			if (so->so_error || so->so_rerror ||
 			    so->so_state & SS_CANTRCVMORE)
 				break;
 			/*
 			 * If we are peeking and the socket receive buffer is
 			 * full, stop since we can't get more data to peek at.
 			 */
 			if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
 				break;
 			/*
 			 * If we've drained the socket buffer, tell the
 			 * protocol in case it needs to do something to
 			 * get it filled again.
 			 */
 			if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb)
 				(*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
 			SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");
 			SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");
 			if (wakeup_state & SS_RESTARTSYS)
 				error = ERESTART;
 			else
 				error = sbwait(&so->so_rcv);
 			if (error != 0) {
 				sbunlock(&so->so_rcv);
 				sounlock(so);
 				splx(s);
 				return 0;
+			}
 			if ((m = so->so_rcv.sb_mb) != NULL)
 				nextrecord = m->m_nextpkt;
 			wakeup_state = so->so_state;
+		}
+	}
 	if (m && atomic) {
 		flags |= MSG_TRUNC;
 		if ((flags & MSG_PEEK) == 0)
 			(void) sbdroprecord(&so->so_rcv);
+	}
 	if ((flags & MSG_PEEK) == 0) {
 		if (m == NULL) {
 			/*
 			 * First part is an inline SB_EMPTY_FIXUP().  Second
 			 * part makes sure sb_lastrecord is up-to-date if
 			 * there is still data in the socket buffer.
 			 */
 			so->so_rcv.sb_mb = nextrecord;
 			if (so->so_rcv.sb_mb == NULL) {
 				so->so_rcv.sb_mbtail = NULL;
 				so->so_rcv.sb_lastrecord = NULL;
 			} else if (nextrecord->m_nextpkt == NULL)
 				so->so_rcv.sb_lastrecord = nextrecord;
+		}
 		SBLASTRECORDCHK(&so->so_rcv, "soreceive 4");
 		SBLASTMBUFCHK(&so->so_rcv, "soreceive 4");
 		if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
 			(*pr->pr_usrreqs->pr_rcvd)(so, flags, l);
+	}
 	if (orig_resid == uio->uio_resid && orig_resid &&
 	    (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
 		sbunlock(&so->so_rcv);
 		goto restart;
+	}
 	if (flagsp != NULL)
 		*flagsp |= flags;
  release:
 	sbunlock(&so->so_rcv);
 	sounlock(so);
 	splx(s);
 	return error;
+}
 int
 soshutdown(struct socket *so, int how)
+{
 	const struct protosw	*pr;
 	int	error;
 	KASSERT(solocked(so));
 	pr = so->so_proto;
 	if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
 		return (EINVAL);
 	if (how == SHUT_RD || how == SHUT_RDWR) {
 		sorflush(so);
 		error = 0;
+	}
 	if (how == SHUT_WR || how == SHUT_RDWR)
 		error = (*pr->pr_usrreqs->pr_shutdown)(so);
 	return error;
+}
 void
 sorestart(struct socket *so)
+{
 	/*
 	 * An application has called close() on an fd on which another
 	 * of its threads has called a socket system call.
 	 * Mark this and wake everyone up, and code that would block again
 	 * instead returns ERESTART.
 	 * On system call re-entry the fd is validated and EBADF returned.
 	 * Any other fd will block again on the 2nd syscall.
 	 */
 	solock(so);
 	so->so_state |= SS_RESTARTSYS;
 	cv_broadcast(&so->so_cv);
 	cv_broadcast(&so->so_snd.sb_cv);
 	cv_broadcast(&so->so_rcv.sb_cv);
 	sounlock(so);
+}
 void
 sorflush(struct socket *so)
+{
 	struct sockbuf	*sb, asb;
 	const struct protosw	*pr;
 	KASSERT(solocked(so));
 	sb = &so->so_rcv;
 	pr = so->so_proto;
 	socantrcvmore(so);
 	sb->sb_flags |= SB_NOINTR;
 	(void )sblock(sb, M_WAITOK);
 	sbunlock(sb);
 	asb = *sb;
 	/*
 	 * Clear most of the sockbuf structure, but leave some of the
 	 * fields valid.
 	 */
 	memset(&sb->sb_startzero, 0,
 	    sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
 	if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose) {
 		sounlock(so);
 		(*pr->pr_domain->dom_dispose)(asb.sb_mb);
 		solock(so);
+	}
 	sbrelease(&asb, so);
+}
 /*
  * internal set SOL_SOCKET options
  */
 static int
 sosetopt1(struct socket *so, const struct sockopt *sopt)
+{
 	int error = EINVAL, opt;
 	int optval = 0; /* XXX: gcc */
 	struct linger l;
 	struct timeval tv;
 	switch ((opt = sopt->sopt_name)) {
 	case SO_ACCEPTFILTER:
 		error = accept_filt_setopt(so, sopt);
 		KASSERT(solocked(so));
 		break;
 	case SO_LINGER:
 		error = sockopt_get(sopt, &l, sizeof(l));
 		solock(so);
 		if (error)
 			break;
 		if (l.l_linger < 0 || l.l_linger > USHRT_MAX ||
 		    l.l_linger > (INT_MAX / hz)) {
 			error = EDOM;
 			break;
+		}
 		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:
 	case SO_NOSIGPIPE:
 #ifdef SO_OTIMESTAMP
 	case SO_OTIMESTAMP:
 #endif
 		error = sockopt_getint(sopt, &optval);
 		solock(so);
 		if (error)
 			break;
 		if (optval)
 			so->so_options |= opt;
 		else
 			so->so_options &= ~opt;
 		break;
 	case SO_SNDBUF:
 	case SO_RCVBUF:
 	case SO_SNDLOWAT:
 	case SO_RCVLOWAT:
 		error = sockopt_getint(sopt, &optval);
 		solock(so);
 		if (error)
 			break;
 		/*
 		 * Values < 1 make no sense for any of these
 		 * options, so disallow them.
 		 */
 		if (optval < 1) {
 			error = EINVAL;
 			break;
+		}
 		switch (opt) {
 		case SO_SNDBUF:
 			if (sbreserve(&so->so_snd, (u_long)optval, so) == 0) {
 				error = ENOBUFS;
 				break;
+			}
 			so->so_snd.sb_flags &= ~SB_AUTOSIZE;
 			break;
 		case SO_RCVBUF:
 			if (sbreserve(&so->so_rcv, (u_long)optval, so) == 0) {
 				error = ENOBUFS;
 				break;
+			}
 			so->so_rcv.sb_flags &= ~SB_AUTOSIZE;
 			break;
 		/*
 		 * Make sure the low-water is never greater than
 		 * the high-water.
 		 */
 		case SO_SNDLOWAT:
 			if (optval > so->so_snd.sb_hiwat)
 				optval = so->so_snd.sb_hiwat;
 			so->so_snd.sb_lowat = optval;
 			break;
 		case SO_RCVLOWAT:
 			if (optval > so->so_rcv.sb_hiwat)
 				optval = so->so_rcv.sb_hiwat;
 			so->so_rcv.sb_lowat = optval;
 			break;
+		}
 		break;
 #ifdef COMPAT_50
 	case SO_OSNDTIMEO:
 	case SO_ORCVTIMEO: {
 		struct timeval50 otv;
 		error = sockopt_get(sopt, &otv, sizeof(otv));
 		if (error) {
 			solock(so);
 			break;
+		}
 		timeval50_to_timeval(&otv, &tv);
 		opt = opt == SO_OSNDTIMEO ? SO_SNDTIMEO : SO_RCVTIMEO;
 		error = 0;
 		/*FALLTHROUGH*/
+	}
 #endif /* COMPAT_50 */
 	case SO_SNDTIMEO:
 	case SO_RCVTIMEO:
 		if (error)
 			error = sockopt_get(sopt, &tv, sizeof(tv));
 		solock(so);
 		if (error)
 			break;
 		if (tv.tv_sec > (INT_MAX - tv.tv_usec / tick) / hz) {
 			error = EDOM;
 			break;
+		}
 		optval = tv.tv_sec * hz + tv.tv_usec / tick;
 		if (optval == 0 && tv.tv_usec != 0)
 			optval = 1;
 		switch (opt) {
 		case SO_SNDTIMEO:
 			so->so_snd.sb_timeo = optval;
 			break;
 		case SO_RCVTIMEO:
 			so->so_rcv.sb_timeo = optval;
 			break;
+		}
 		break;
 	default:
 		solock(so);
 		error = ENOPROTOOPT;
 		break;
+	}
 	KASSERT(solocked(so));
 	return error;
+}
 int
 sosetopt(struct socket *so, struct sockopt *sopt)
+{
 	int error, prerr;
 	if (sopt->sopt_level == SOL_SOCKET) {
 		error = sosetopt1(so, sopt);
 		KASSERT(solocked(so));
 	} else {
 		error = ENOPROTOOPT;
 		solock(so);
+	}
 	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, sopt);
 		if (prerr == 0)
 			error = 0;
 		else if (prerr != ENOPROTOOPT)
 			error = prerr;
+	}
 	sounlock(so);
 	return error;
+}
 /*
  * so_setsockopt() is a wrapper providing a sockopt structure for sosetopt()
  */
 int
 so_setsockopt(struct lwp *l, struct socket *so, int level, int name,
     const void *val, size_t valsize)
+{
 	struct sockopt sopt;
 	int error;
 	KASSERT(valsize == 0 || val != NULL);
 	sockopt_init(&sopt, level, name, valsize);
 	sockopt_set(&sopt, val, valsize);
 	error = sosetopt(so, &sopt);
 	sockopt_destroy(&sopt);
 	return error;
+}
 /*
  * internal get SOL_SOCKET options
  */
 static int
 sogetopt1(struct socket *so, struct sockopt *sopt)
+{
 	int error, optval, opt;
 	struct linger l;
 	struct timeval tv;
 	switch ((opt = sopt->sopt_name)) {
 	case SO_ACCEPTFILTER:
 		error = accept_filt_getopt(so, sopt);
 		break;
 	case SO_LINGER:
 		l.l_onoff = (so->so_options & SO_LINGER) ? 1 : 0;
 		l.l_linger = so->so_linger;
 		error = sockopt_set(sopt, &l, sizeof(l));
 		break;
 	case SO_USELOOPBACK:
 	case SO_DONTROUTE:
 	case SO_DEBUG:
 	case SO_KEEPALIVE:
 	case SO_REUSEADDR:
 	case SO_REUSEPORT:
 	case SO_BROADCAST:
 	case SO_OOBINLINE:
 	case SO_TIMESTAMP:
 	case SO_NOSIGPIPE:
 #ifdef SO_OTIMESTAMP
 	case SO_OTIMESTAMP:
 #endif
 	case SO_ACCEPTCONN:
 		error = sockopt_setint(sopt, (so->so_options & opt) ? 1 : 0);
 		break;
 	case SO_TYPE:
 		error = sockopt_setint(sopt, so->so_type);
 		break;
 	case SO_ERROR:
 		error = sockopt_setint(sopt, so->so_error);
 		so->so_error = 0;
 		break;
 	case SO_SNDBUF:
 		error = sockopt_setint(sopt, so->so_snd.sb_hiwat);
 		break;
 	case SO_RCVBUF:
 		error = sockopt_setint(sopt, so->so_rcv.sb_hiwat);
 		break;
 	case SO_SNDLOWAT:
 		error = sockopt_setint(sopt, so->so_snd.sb_lowat);
 		break;
 	case SO_RCVLOWAT:
 		error = sockopt_setint(sopt, so->so_rcv.sb_lowat);
 		break;
 #ifdef COMPAT_50
 	case SO_OSNDTIMEO:
 	case SO_ORCVTIMEO: {
 		struct timeval50 otv;
 		optval = (opt == SO_OSNDTIMEO ?
 		     so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
 		otv.tv_sec = optval / hz;
 		otv.tv_usec = (optval % hz) * tick;
 		error = sockopt_set(sopt, &otv, sizeof(otv));
 		break;
+	}
 #endif /* COMPAT_50 */
 	case SO_SNDTIMEO:
 	case SO_RCVTIMEO:
 		optval = (opt == SO_SNDTIMEO ?
 		     so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
 		tv.tv_sec = optval / hz;
 		tv.tv_usec = (optval % hz) * tick;
 		error = sockopt_set(sopt, &tv, sizeof(tv));
 		break;
 	case SO_OVERFLOWED:
 		error = sockopt_setint(sopt, so->so_rcv.sb_overflowed);
 		break;
 	default:
 		error = ENOPROTOOPT;
 		break;
+	}
 	return (error);
+}
 int
 sogetopt(struct socket *so, struct sockopt *sopt)
+{
 	int		error;
 	solock(so);
 	if (sopt->sopt_level != SOL_SOCKET) {
 		if (so->so_proto && so->so_proto->pr_ctloutput) {
 			error = ((*so->so_proto->pr_ctloutput)
 			    (PRCO_GETOPT, so, sopt));
 		} else
 			error = (ENOPROTOOPT);
 	} else {
 		error = sogetopt1(so, sopt);
+	}
 	sounlock(so);
 	return (error);
+}
 /*
  * alloc sockopt data buffer buffer
  *	- will be released at destroy
  */
 static int
 sockopt_alloc(struct sockopt *sopt, size_t len, km_flag_t kmflag)
+{
 	KASSERT(sopt->sopt_size == 0);
 	if (len > sizeof(sopt->sopt_buf)) {
 		sopt->sopt_data = kmem_zalloc(len, kmflag);
 		if (sopt->sopt_data == NULL)
 			return ENOMEM;
 	} else
 		sopt->sopt_data = sopt->sopt_buf;
 	sopt->sopt_size = len;
 	return 0;
+}
 /*
  * initialise sockopt storage
  *	- MAY sleep during allocation
  */
 void
 sockopt_init(struct sockopt *sopt, int level, int name, size_t size)
+{
 	memset(sopt, 0, sizeof(*sopt));
 	sopt->sopt_level = level;
 	sopt->sopt_name = name;
 	(void)sockopt_alloc(sopt, size, KM_SLEEP);
+}
 /*
  * destroy sockopt storage
  *	- will release any held memory references
  */
 void
 sockopt_destroy(struct sockopt *sopt)
+{
 	if (sopt->sopt_data != sopt->sopt_buf)
 		kmem_free(sopt->sopt_data, sopt->sopt_size);
 	memset(sopt, 0, sizeof(*sopt));
+}
 /*
  * set sockopt value
  *	- value is copied into sockopt
  *	- memory is allocated when necessary, will not sleep
  */
 int
 sockopt_set(struct sockopt *sopt, const void *buf, size_t len)
+{
 	int error;
 	if (sopt->sopt_size == 0) {
 		error = sockopt_alloc(sopt, len, KM_NOSLEEP);
 		if (error)
 			return error;
+	}
 	if (sopt->sopt_size < len)
 		return EINVAL;
 	memcpy(sopt->sopt_data, buf, len);
 	sopt->sopt_retsize = len;
 	return 0;
+}
 /*
  * common case of set sockopt integer value
  */
 int
 sockopt_setint(struct sockopt *sopt, int val)
+{
 	return sockopt_set(sopt, &val, sizeof(int));
+}
 /*
  * get sockopt value
  *	- correct size must be given
  */
 int
 sockopt_get(const struct sockopt *sopt, void *buf, size_t len)
+{
 	if (sopt->sopt_size != len)
 		return EINVAL;
 	memcpy(buf, sopt->sopt_data, len);
 	return 0;
+}
 /*
  * common case of get sockopt integer value
  */
 int
 sockopt_getint(const struct sockopt *sopt, int *valp)
+{
 	return sockopt_get(sopt, valp, sizeof(int));
+}
 /*
  * set sockopt value from mbuf
  *	- ONLY for legacy code
  *	- mbuf is released by sockopt
  *	- will not sleep
  */
 int
 sockopt_setmbuf(struct sockopt *sopt, struct mbuf *m)
+{
 	size_t len;
 	int error;
 	len = m_length(m);
 	if (sopt->sopt_size == 0) {
 		error = sockopt_alloc(sopt, len, KM_NOSLEEP);
 		if (error)
 			return error;
+	}
 	if (sopt->sopt_size < len)
 		return EINVAL;
 	m_copydata(m, 0, len, sopt->sopt_data);
 	m_freem(m);
 	sopt->sopt_retsize = len;
 	return 0;
+}
 /*
  * get sockopt value into mbuf
  *	- ONLY for legacy code
  *	- mbuf to be released by the caller
  *	- will not sleep
  */
 struct mbuf *
 sockopt_getmbuf(const struct sockopt *sopt)
+{
 	struct mbuf *m;
 	if (sopt->sopt_size > MCLBYTES)
 		return NULL;
 	m = m_get(M_DONTWAIT, MT_SOOPTS);
 	if (m == NULL)
 		return NULL;
 	if (sopt->sopt_size > MLEN) {
 		MCLGET(m, M_DONTWAIT);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return NULL;
+		}
+	}
 	memcpy(mtod(m, void *), sopt->sopt_data, sopt->sopt_size);
 	m->m_len = sopt->sopt_size;
 	return m;
+}
 void
 sohasoutofband(struct socket *so)
+{
 	fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);
 	selnotify(&so->so_rcv.sb_sel, POLLPRI | POLLRDBAND, NOTE_SUBMIT);
+}
 static void
 filt_sordetach(struct knote *kn)
+{
 	struct socket	*so;
 	so = ((file_t *)kn->kn_obj)->f_socket;
 	solock(so);
 	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;
 	sounlock(so);
+}
 /*ARGSUSED*/
 static int
 filt_soread(struct knote *kn, long hint)
+{
 	struct socket	*so;
 	int rv;
 	so = ((file_t *)kn->kn_obj)->f_socket;
 	if (hint != NOTE_SUBMIT)
 		solock(so);
 	kn->kn_data = so->so_rcv.sb_cc;
 	if (so->so_state & SS_CANTRCVMORE) {
 		kn->kn_flags |= EV_EOF;
 		kn->kn_fflags = so->so_error;
 		rv = 1;
-	} else if (so->so_error)
+	} else if (so->so_error || so->so_rerror)
 		rv = 1;
 	else if (kn->kn_sfflags & NOTE_LOWAT)
 		rv = (kn->kn_data >= kn->kn_sdata);
 	else
 		rv = (kn->kn_data >= so->so_rcv.sb_lowat);
 	if (hint != NOTE_SUBMIT)
 		sounlock(so);
 	return rv;
+}
 static void
 filt_sowdetach(struct knote *kn)
+{
 	struct socket	*so;
 	so = ((file_t *)kn->kn_obj)->f_socket;
 	solock(so);
 	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;
 	sounlock(so);
+}
 /*ARGSUSED*/
 static int
 filt_sowrite(struct knote *kn, long hint)
+{
 	struct socket	*so;
 	int rv;
 	so = ((file_t *)kn->kn_obj)->f_socket;
 	if (hint != NOTE_SUBMIT)
 		solock(so);
 	kn->kn_data = sbspace(&so->so_snd);
 	if (so->so_state & SS_CANTSENDMORE) {
 		kn->kn_flags |= EV_EOF;
 		kn->kn_fflags = so->so_error;
 		rv = 1;
 	} else if (so->so_error)
 		rv = 1;
 	else if (((so->so_state & SS_ISCONNECTED) == 0) &&
 	    (so->so_proto->pr_flags & PR_CONNREQUIRED))
 		rv = 0;
 	else if (kn->kn_sfflags & NOTE_LOWAT)
 		rv = (kn->kn_data >= kn->kn_sdata);
 	else
 		rv = (kn->kn_data >= so->so_snd.sb_lowat);
 	if (hint != NOTE_SUBMIT)
 		sounlock(so);
 	return rv;
+}
 /*ARGSUSED*/
 static int
 filt_solisten(struct knote *kn, long hint)
+{
 	struct socket	*so;
 	int rv;
 	so = ((file_t *)kn->kn_obj)->f_socket;
 	/*
 	 * Set kn_data to number of incoming connections, not
 	 * counting partial (incomplete) connections.
 	 */
 	if (hint != NOTE_SUBMIT)
 		solock(so);
 	kn->kn_data = so->so_qlen;
 	rv = (kn->kn_data > 0);
 	if (hint != NOTE_SUBMIT)
 		sounlock(so);
 	return rv;
+}
 static const struct filterops solisten_filtops = {
 	.f_isfd = 1,
 	.f_attach = NULL,
 	.f_detach = filt_sordetach,
 	.f_event = filt_solisten,
 };
 static const struct filterops soread_filtops = {
 	.f_isfd = 1,
 	.f_attach = NULL,
 	.f_detach = filt_sordetach,
 	.f_event = filt_soread,
 };
 static const struct filterops sowrite_filtops = {
 	.f_isfd = 1,
 	.f_attach = NULL,
 	.f_detach = filt_sowdetach,
 	.f_event = filt_sowrite,
 };
 int
 soo_kqfilter(struct file *fp, struct knote *kn)
+{
 	struct socket	*so;
 	struct sockbuf	*sb;
 	so = ((file_t *)kn->kn_obj)->f_socket;
 	solock(so);
 	switch (kn->kn_filter) {
 	case EVFILT_READ:
 		if (so->so_options & SO_ACCEPTCONN)
 			kn->kn_fop = &solisten_filtops;
 		else
 			kn->kn_fop = &soread_filtops;
 		sb = &so->so_rcv;
 		break;
 	case EVFILT_WRITE:
 		kn->kn_fop = &sowrite_filtops;
 		sb = &so->so_snd;
 		break;
 	default:
 		sounlock(so);
 		return (EINVAL);
+	}
 	SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);
 	sb->sb_flags |= SB_KNOTE;
 	sounlock(so);
 	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;
 #ifndef DIAGNOSTIC
 	/*
 	 * Do a quick, unlocked check in expectation that the socket
 	 * will be ready for I/O.  Don't do this check if DIAGNOSTIC,
 	 * as the solocked() assertions will fail.
 	 */
 	if ((revents = sodopoll(so, events)) != 0)
 		return revents;
 #endif
 	solock(so);
 	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_NOTIFY;
+		}
 		if (events & (POLLOUT | POLLWRNORM)) {
 			selrecord(curlwp, &so->so_snd.sb_sel);
 			so->so_snd.sb_flags |= SB_NOTIFY;
+		}
+	}
 	sounlock(so);
 	return revents;
+}
 struct mbuf **
 sbsavetimestamp(int opt, struct mbuf **mp)
+{
 	struct timeval tv;
 	microtime(&tv);
 #ifdef SO_OTIMESTAMP
 	if (opt & SO_OTIMESTAMP) {
 		struct timeval50 tv50;
 		timeval_to_timeval50(&tv, &tv50);
 		*mp = sbcreatecontrol(&tv50, sizeof(tv50),
 		    SCM_OTIMESTAMP, SOL_SOCKET);
 		if (*mp)
 			mp = &(*mp)->m_next;
 	} else
 #endif
 	if (opt & SO_TIMESTAMP) {
 		*mp = sbcreatecontrol(&tv, sizeof(tv),
 		    SCM_TIMESTAMP, SOL_SOCKET);
 		if (*mp)
 			mp = &(*mp)->m_next;
+	}
 	return mp;
+}
 #include <sys/sysctl.h>
 static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);
 static int sysctl_kern_sbmax(SYSCTLFN_PROTO);
 /*
  * sysctl helper routine for kern.somaxkva.  ensures that the given
  * value is not too small.
  * (XXX should we maybe make sure it's not too large as well?)
  */
 static int
 sysctl_kern_somaxkva(SYSCTLFN_ARGS)
+{
 	int error, new_somaxkva;
 	struct sysctlnode node;
 	new_somaxkva = somaxkva;
 	node = *rnode;
 	node.sysctl_data = &new_somaxkva;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return (error);
 	if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */
 		return (EINVAL);
 	mutex_enter(&so_pendfree_lock);
 	somaxkva = new_somaxkva;
 	cv_broadcast(&socurkva_cv);
 	mutex_exit(&so_pendfree_lock);
 	return (error);
+}
 /*
  * sysctl helper routine for kern.sbmax. Basically just ensures that
  * any new value is not too small.
  */
 static int
 sysctl_kern_sbmax(SYSCTLFN_ARGS)
+{
 	int error, new_sbmax;
 	struct sysctlnode node;
 	new_sbmax = sb_max;
 	node = *rnode;
 	node.sysctl_data = &new_sbmax;
 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
 	if (error || newp == NULL)
 		return (error);
 	KERNEL_LOCK(1, NULL);
 	error = sb_max_set(new_sbmax);
 	KERNEL_UNLOCK_ONE(NULL);
 	return (error);
+}
 static void
 sysctl_kern_socket_setup(void)
+{
 	KASSERT(socket_sysctllog == NULL);
 	sysctl_createv(&socket_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 		       CTLTYPE_INT, "somaxkva",
 		       SYSCTL_DESCR("Maximum amount of kernel memory to be "
 				    "used for socket buffers"),
 		       sysctl_kern_somaxkva, 0, NULL, 0,
 		       CTL_KERN, KERN_SOMAXKVA, CTL_EOL);
 	sysctl_createv(&socket_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
 		       CTLTYPE_INT, "sbmax",
 		       SYSCTL_DESCR("Maximum socket buffer size"),
 		       sysctl_kern_sbmax, 0, NULL, 0,
 		       CTL_KERN, KERN_SBMAX, CTL_EOL);
+}

 @@ -1,1506 +1,1506 @@
-/*	$NetBSD: uipc_socket2.c,v 1.129 2018/04/29 07:13:10 maxv Exp $	*/
+/*	$NetBSD: uipc_socket2.c,v 1.130 2018/06/06 09:46:46 roy Exp $	*/
 /*-
  * Copyright (c) 2008 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1982, 1986, 1988, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)uipc_socket2.c	8.2 (Berkeley) 2/14/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uipc_socket2.c,v 1.129 2018/04/29 07:13:10 maxv Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uipc_socket2.c,v 1.130 2018/06/06 09:46:46 roy Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_mbuftrace.h"
 #include "opt_sb_max.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/file.h>
 #include <sys/buf.h>
 #include <sys/mbuf.h>
 #include <sys/protosw.h>
 #include <sys/domain.h>
 #include <sys/poll.h>
 #include <sys/socket.h>
 #include <sys/socketvar.h>
 #include <sys/signalvar.h>
 #include <sys/kauth.h>
 #include <sys/pool.h>
 #include <sys/uidinfo.h>
 /*
  * Primitive routines for operating on sockets and socket buffers.
+ *
  * Connection life-cycle:
+ *
  *	Normal sequence from the active (originating) side:
+ *
  *	- soisconnecting() is called during processing of connect() call,
  *	- resulting in an eventual call to soisconnected() if/when the
  *	  connection is established.
+ *
  *	When the connection is torn down during processing of disconnect():
+ *
  *	- soisdisconnecting() is called and,
  *	- soisdisconnected() is called when the connection to the peer
  *	  is totally severed.
+ *
  *	The semantics of these routines are such that connectionless protocols
  *	can call soisconnected() and soisdisconnected() only, bypassing the
  *	in-progress calls when setting up a ``connection'' takes no time.
+ *
  *	From the passive side, a socket is created with two queues of sockets:
+ *
  *	- so_q0 (0) for partial connections (i.e. connections in progress)
  *	- so_q (1) for connections already made and awaiting user acceptance.
+ *
  *	As a protocol is preparing incoming connections, it creates a socket
  *	structure queued on so_q0 by calling sonewconn().  When the connection
  *	is established, soisconnected() is called, and transfers the
  *	socket structure to so_q, making it available to accept().
+ *
  *	If a socket is closed with sockets on either so_q0 or so_q, these
  *	sockets are dropped.
+ *
  * Locking rules and assumptions:
+ *
  * o socket::so_lock can change on the fly.  The low level routines used
  *   to lock sockets are aware of this.  When so_lock is acquired, the
  *   routine locking must check to see if so_lock still points to the
  *   lock that was acquired.  If so_lock has changed in the meantime, the
  *   now irrelevant lock that was acquired must be dropped and the lock
  *   operation retried.  Although not proven here, this is completely safe
  *   on a multiprocessor system, even with relaxed memory ordering, given
  *   the next two rules:
+ *
  * o In order to mutate so_lock, the lock pointed to by the current value
  *   of so_lock must be held: i.e., the socket must be held locked by the
  *   changing thread.  The thread must issue membar_exit() to prevent
  *   memory accesses being reordered, and can set so_lock to the desired
  *   value.  If the lock pointed to by the new value of so_lock is not
  *   held by the changing thread, the socket must then be considered
  *   unlocked.
+ *
  * o If so_lock is mutated, and the previous lock referred to by so_lock
  *   could still be visible to other threads in the system (e.g. via file
  *   descriptor or protocol-internal reference), then the old lock must
  *   remain valid until the socket and/or protocol control block has been
  *   torn down.
+ *
  * o If a socket has a non-NULL so_head value (i.e. is in the process of
  *   connecting), then locking the socket must also lock the socket pointed
  *   to by so_head: their lock pointers must match.
+ *
  * o If a socket has connections in progress (so_q, so_q0 not empty) then
  *   locking the socket must also lock the sockets attached to both queues.
  *   Again, their lock pointers must match.
+ *
  * o Beyond the initial lock assignment in socreate(), assigning locks to
  *   sockets is the responsibility of the individual protocols / protocol
  *   domains.
  */
 static pool_cache_t	socket_cache;
 u_long			sb_max = SB_MAX;/* maximum socket buffer size */
 static u_long		sb_max_adj;	/* adjusted sb_max */
 void
 soisconnecting(struct socket *so)
+{
 	KASSERT(solocked(so));
 	so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING);
 	so->so_state |= SS_ISCONNECTING;
+}
 void
 soisconnected(struct socket *so)
+{
 	struct socket	*head;
 	head = so->so_head;
 	KASSERT(solocked(so));
 	KASSERT(head == NULL || solocked2(so, head));
 	so->so_state &= ~(SS_ISCONNECTING | SS_ISDISCONNECTING);
 	so->so_state |= SS_ISCONNECTED;
 	if (head && so->so_onq == &head->so_q0) {
 		if ((so->so_options & SO_ACCEPTFILTER) == 0) {
 			/*
 			 * Re-enqueue and wake up any waiters, e.g.
 			 * processes blocking on accept().
 			 */
 			soqremque(so, 0);
 			soqinsque(head, so, 1);
 			sorwakeup(head);
 			cv_broadcast(&head->so_cv);
 		} else {
 			so->so_upcall =
 			    head->so_accf->so_accept_filter->accf_callback;
 			so->so_upcallarg = head->so_accf->so_accept_filter_arg;
 			so->so_rcv.sb_flags |= SB_UPCALL;
 			so->so_options &= ~SO_ACCEPTFILTER;
 			(*so->so_upcall)(so, so->so_upcallarg,
 					 POLLIN|POLLRDNORM, M_DONTWAIT);
+		}
 	} else {
 		cv_broadcast(&so->so_cv);
 		sorwakeup(so);
 		sowwakeup(so);
+	}
+}
 void
 soisdisconnecting(struct socket *so)
+{
 	KASSERT(solocked(so));
 	so->so_state &= ~SS_ISCONNECTING;
 	so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE);
 	cv_broadcast(&so->so_cv);
 	sowwakeup(so);
 	sorwakeup(so);
+}
 void
 soisdisconnected(struct socket *so)
+{
 	KASSERT(solocked(so));
 	so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING);
 	so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE|SS_ISDISCONNECTED);
 	cv_broadcast(&so->so_cv);
 	sowwakeup(so);
 	sorwakeup(so);
+}
 void
 soinit2(void)
+{
 	socket_cache = pool_cache_init(sizeof(struct socket), 0, 0, 0,
 	    "socket", NULL, IPL_SOFTNET, NULL, NULL, NULL);
+}
 /*
  * sonewconn: accept a new connection.
+ *
  * When an attempt at a new connection is noted on a socket which accepts
  * connections, sonewconn(9) is called.  If the connection is possible
  * (subject to space constraints, etc) then we allocate a new structure,
  * properly linked into the data structure of the original socket.
+ *
  * => If 'soready' is true, then socket will become ready for accept() i.e.
  *    inserted into the so_q queue, SS_ISCONNECTED set and waiters awoken.
  * => May be called from soft-interrupt context.
  * => Listening socket should be locked.
  * => Returns the new socket locked.
  */
 struct socket *
 sonewconn(struct socket *head, bool soready)
+{
 	struct socket *so;
 	int soqueue, error;
 	KASSERT(solocked(head));
 	if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2) {
 		/*
 		 * Listen queue overflow.  If there is an accept filter
 		 * active, pass through the oldest cxn it's handling.
 		 */
 		if (head->so_accf == NULL) {
 			return NULL;
 		} else {
 			struct socket *so2, *next;
 			/* Pass the oldest connection waiting in the
 			   accept filter */
 			for (so2 = TAILQ_FIRST(&head->so_q0);
 			     so2 != NULL; so2 = next) {
 				next = TAILQ_NEXT(so2, so_qe);
 				if (so2->so_upcall == NULL) {
 					continue;
+				}
 				so2->so_upcall = NULL;
 				so2->so_upcallarg = NULL;
 				so2->so_options &= ~SO_ACCEPTFILTER;
 				so2->so_rcv.sb_flags &= ~SB_UPCALL;
 				soisconnected(so2);
 				break;
+			}
 			/* If nothing was nudged out of the acept filter, bail
 			 * out; otherwise proceed allocating the socket. */
 			if (so2 == NULL) {
 				return NULL;
+			}
+		}
+	}
 	if ((head->so_options & SO_ACCEPTFILTER) != 0) {
 		soready = false;
+	}
 	soqueue = soready ? 1 : 0;
 	if ((so = soget(false)) == NULL) {
 		return NULL;
+	}
 	so->so_type = head->so_type;
 	so->so_options = head->so_options & ~SO_ACCEPTCONN;
 	so->so_linger = head->so_linger;
 	so->so_state = head->so_state | SS_NOFDREF;
 	so->so_proto = head->so_proto;
 	so->so_timeo = head->so_timeo;
 	so->so_pgid = head->so_pgid;
 	so->so_send = head->so_send;
 	so->so_receive = head->so_receive;
 	so->so_uidinfo = head->so_uidinfo;
 	so->so_cpid = head->so_cpid;
 	/*
 	 * Share the lock with the listening-socket, it may get unshared
 	 * once the connection is complete.
 	 */
 	mutex_obj_hold(head->so_lock);
 	so->so_lock = head->so_lock;
 	/*
 	 * Reserve the space for socket buffers.
 	 */
 #ifdef MBUFTRACE
 	so->so_mowner = head->so_mowner;
 	so->so_rcv.sb_mowner = head->so_rcv.sb_mowner;
 	so->so_snd.sb_mowner = head->so_snd.sb_mowner;
 #endif
 	if (soreserve(so, head->so_snd.sb_hiwat, head->so_rcv.sb_hiwat)) {
 		goto out;
+	}
 	so->so_snd.sb_lowat = head->so_snd.sb_lowat;
 	so->so_rcv.sb_lowat = head->so_rcv.sb_lowat;
 	so->so_rcv.sb_timeo = head->so_rcv.sb_timeo;
 	so->so_snd.sb_timeo = head->so_snd.sb_timeo;
 	so->so_rcv.sb_flags |= head->so_rcv.sb_flags & (SB_AUTOSIZE | SB_ASYNC);
 	so->so_snd.sb_flags |= head->so_snd.sb_flags & (SB_AUTOSIZE | SB_ASYNC);
 	/*
 	 * Finally, perform the protocol attach.  Note: a new socket
 	 * lock may be assigned at this point (if so, it will be held).
 	 */
 	error = (*so->so_proto->pr_usrreqs->pr_attach)(so, 0);
 	if (error) {
 out:
 		KASSERT(solocked(so));
 		KASSERT(so->so_accf == NULL);
 		soput(so);
 		/* Note: the listening socket shall stay locked. */
 		KASSERT(solocked(head));
 		return NULL;
+	}
 	KASSERT(solocked2(head, so));
 	/*
 	 * Insert into the queue.  If ready, update the connection status
 	 * and wake up any waiters, e.g. processes blocking on accept().
 	 */
 	soqinsque(head, so, soqueue);
 	if (soready) {
 		so->so_state |= SS_ISCONNECTED;
 		sorwakeup(head);
 		cv_broadcast(&head->so_cv);
+	}
 	return so;
+}
 struct socket *
 soget(bool waitok)
+{
 	struct socket *so;
 	so = pool_cache_get(socket_cache, (waitok ? PR_WAITOK : PR_NOWAIT));
 	if (__predict_false(so == NULL))
 		return (NULL);
 	memset(so, 0, sizeof(*so));
 	TAILQ_INIT(&so->so_q0);
 	TAILQ_INIT(&so->so_q);
 	cv_init(&so->so_cv, "socket");
 	cv_init(&so->so_rcv.sb_cv, "netio");
 	cv_init(&so->so_snd.sb_cv, "netio");
 	selinit(&so->so_rcv.sb_sel);
 	selinit(&so->so_snd.sb_sel);
 	so->so_rcv.sb_so = so;
 	so->so_snd.sb_so = so;
 	return so;
+}
 void
 soput(struct socket *so)
+{
 	KASSERT(!cv_has_waiters(&so->so_cv));
 	KASSERT(!cv_has_waiters(&so->so_rcv.sb_cv));
 	KASSERT(!cv_has_waiters(&so->so_snd.sb_cv));
 	seldestroy(&so->so_rcv.sb_sel);
 	seldestroy(&so->so_snd.sb_sel);
 	mutex_obj_free(so->so_lock);
 	cv_destroy(&so->so_cv);
 	cv_destroy(&so->so_rcv.sb_cv);
 	cv_destroy(&so->so_snd.sb_cv);
 	pool_cache_put(socket_cache, so);
+}
 /*
  * soqinsque: insert socket of a new connection into the specified
  * accept queue of the listening socket (head).
+ *
  *	q = 0: queue of partial connections
  *	q = 1: queue of incoming connections
  */
 void
 soqinsque(struct socket *head, struct socket *so, int q)
+{
 	KASSERT(q == 0 || q == 1);
 	KASSERT(solocked2(head, so));
 	KASSERT(so->so_onq == NULL);
 	KASSERT(so->so_head == NULL);
 	so->so_head = head;
 	if (q == 0) {
 		head->so_q0len++;
 		so->so_onq = &head->so_q0;
 	} else {
 		head->so_qlen++;
 		so->so_onq = &head->so_q;
+	}
 	TAILQ_INSERT_TAIL(so->so_onq, so, so_qe);
+}
 /*
  * soqremque: remove socket from the specified queue.
+ *
  * => Returns true if socket was removed from the specified queue.
  * => False if socket was not removed (because it was in other queue).
  */
 bool
 soqremque(struct socket *so, int q)
+{
 	struct socket *head = so->so_head;
 	KASSERT(q == 0 || q == 1);
 	KASSERT(solocked(so));
 	KASSERT(so->so_onq != NULL);
 	KASSERT(head != NULL);
 	if (q == 0) {
 		if (so->so_onq != &head->so_q0)
 			return false;
 		head->so_q0len--;
 	} else {
 		if (so->so_onq != &head->so_q)
 			return false;
 		head->so_qlen--;
+	}
 	KASSERT(solocked2(so, head));
 	TAILQ_REMOVE(so->so_onq, so, so_qe);
 	so->so_onq = NULL;
 	so->so_head = NULL;
 	return true;
+}
 /*
  * socantsendmore: indicates that no more data will be sent on the
  * socket; it would normally be applied to a socket when the user
  * informs the system that no more data is to be sent, by the protocol
  * code (in case pr_shutdown()).
  */
 void
 socantsendmore(struct socket *so)
+{
 	KASSERT(solocked(so));
 	so->so_state |= SS_CANTSENDMORE;
 	sowwakeup(so);
+}
 /*
  * socantrcvmore(): indicates that no more data will be received and
  * will normally be applied to the socket by a protocol when it detects
  * that the peer will send no more data.  Data queued for reading in
  * the socket may yet be read.
  */
 void
 socantrcvmore(struct socket *so)
+{
 	KASSERT(solocked(so));
 	so->so_state |= SS_CANTRCVMORE;
 	sorwakeup(so);
+}
 /*
  * soroverflow(): indicates that data was attempted to be sent
  * but the receiving buffer overflowed.
  */
 void
 soroverflow(struct socket *so)
+{
 	KASSERT(solocked(so));
 	so->so_rcv.sb_overflowed++;
-	so->so_error = ENOBUFS;
+	so->so_rerror = ENOBUFS;
 	sorwakeup(so);
+}
 /*
  * Wait for data to arrive at/drain from a socket buffer.
  */
 int
 sbwait(struct sockbuf *sb)
+{
 	struct socket *so;
 	kmutex_t *lock;
 	int error;
 	so = sb->sb_so;
 	KASSERT(solocked(so));
 	sb->sb_flags |= SB_NOTIFY;
 	lock = so->so_lock;
 	if ((sb->sb_flags & SB_NOINTR) != 0)
 		error = cv_timedwait(&sb->sb_cv, lock, sb->sb_timeo);
 	else
 		error = cv_timedwait_sig(&sb->sb_cv, lock, sb->sb_timeo);
 	if (__predict_false(lock != so->so_lock))
 		solockretry(so, lock);
 	return error;
+}
 /*
  * Wakeup processes waiting on a socket buffer.
  * Do asynchronous notification via SIGIO
  * if the socket buffer has the SB_ASYNC flag set.
  */
 void
 sowakeup(struct socket *so, struct sockbuf *sb, int code)
+{
 	int band;
 	KASSERT(solocked(so));
 	KASSERT(sb->sb_so == so);
 	if (code == POLL_IN)
 		band = POLLIN|POLLRDNORM;
 	else
 		band = POLLOUT|POLLWRNORM;
 	sb->sb_flags &= ~SB_NOTIFY;
 	selnotify(&sb->sb_sel, band, NOTE_SUBMIT);
 	cv_broadcast(&sb->sb_cv);
 	if (sb->sb_flags & SB_ASYNC)
 		fownsignal(so->so_pgid, SIGIO, code, band, so);
 	if (sb->sb_flags & SB_UPCALL)
 		(*so->so_upcall)(so, so->so_upcallarg, band, M_DONTWAIT);
+}
 /*
  * Reset a socket's lock pointer.  Wake all threads waiting on the
  * socket's condition variables so that they can restart their waits
  * using the new lock.  The existing lock must be held.
  */
 void
 solockreset(struct socket *so, kmutex_t *lock)
+{
 	KASSERT(solocked(so));
 	so->so_lock = lock;
 	cv_broadcast(&so->so_snd.sb_cv);
 	cv_broadcast(&so->so_rcv.sb_cv);
 	cv_broadcast(&so->so_cv);
+}
 /*
  * Socket buffer (struct sockbuf) utility routines.
+ *
  * Each socket contains two socket buffers: one for sending data and
  * one for receiving data.  Each buffer contains a queue of mbufs,
  * information about the number of mbufs and amount of data in the
  * queue, and other fields allowing poll() statements and notification
  * on data availability to be implemented.
+ *
  * Data stored in a socket buffer is maintained as a list of records.
  * Each record is a list of mbufs chained together with the m_next
  * field.  Records are chained together with the m_nextpkt field. The upper
  * level routine soreceive() expects the following conventions to be
  * observed when placing information in the receive buffer:
+ *
  * 1. If the protocol requires each message be preceded by the sender's
  *    name, then a record containing that name must be present before
  *    any associated data (mbuf's must be of type MT_SONAME).
  * 2. If the protocol supports the exchange of ``access rights'' (really
  *    just additional data associated with the message), and there are
  *    ``rights'' to be received, then a record containing this data
  *    should be present (mbuf's must be of type MT_CONTROL).
  * 3. If a name or rights record exists, then it must be followed by
  *    a data record, perhaps of zero length.
+ *
  * Before using a new socket structure it is first necessary to reserve
  * buffer space to the socket, by calling sbreserve().  This should commit
  * some of the available buffer space in the system buffer pool for the
  * socket (currently, it does nothing but enforce limits).  The space
  * should be released by calling sbrelease() when the socket is destroyed.
  */
 int
 sb_max_set(u_long new_sbmax)
+{
 	int s;
 	if (new_sbmax < (16 * 1024))
 		return (EINVAL);
 	s = splsoftnet();
 	sb_max = new_sbmax;
 	sb_max_adj = (u_quad_t)new_sbmax * MCLBYTES / (MSIZE + MCLBYTES);
 	splx(s);
 	return (0);
+}
 int
 soreserve(struct socket *so, u_long sndcc, u_long rcvcc)
+{
 	KASSERT(so->so_pcb == NULL || solocked(so));
 	/*
 	 * there's at least one application (a configure script of screen)
 	 * which expects a fifo is writable even if it has "some" bytes
 	 * in its buffer.
 	 * so we want to make sure (hiwat - lowat) >= (some bytes).
+	 *
 	 * PIPE_BUF here is an arbitrary value chosen as (some bytes) above.
 	 * we expect it's large enough for such applications.
 	 */
 	u_long  lowat = MAX(sock_loan_thresh, MCLBYTES);
 	u_long  hiwat = lowat + PIPE_BUF;
 	if (sndcc < hiwat)
 		sndcc = hiwat;
 	if (sbreserve(&so->so_snd, sndcc, so) == 0)
 		goto bad;
 	if (sbreserve(&so->so_rcv, rcvcc, so) == 0)
 		goto bad2;
 	if (so->so_rcv.sb_lowat == 0)
 		so->so_rcv.sb_lowat = 1;
 	if (so->so_snd.sb_lowat == 0)
 		so->so_snd.sb_lowat = lowat;
 	if (so->so_snd.sb_lowat > so->so_snd.sb_hiwat)
 		so->so_snd.sb_lowat = so->so_snd.sb_hiwat;
 	return (0);
  bad2:
 	sbrelease(&so->so_snd, so);
  bad:
 	return (ENOBUFS);
+}
 /*
  * Allot mbufs to a sockbuf.
  * Attempt to scale mbmax so that mbcnt doesn't become limiting
  * if buffering efficiency is near the normal case.
  */
 int
 sbreserve(struct sockbuf *sb, u_long cc, struct socket *so)
+{
 	struct lwp *l = curlwp; /* XXX */
 	rlim_t maxcc;
 	struct uidinfo *uidinfo;
 	KASSERT(so->so_pcb == NULL || solocked(so));
 	KASSERT(sb->sb_so == so);
 	KASSERT(sb_max_adj != 0);
 	if (cc == 0 || cc > sb_max_adj)
 		return (0);
 	maxcc = l->l_proc->p_rlimit[RLIMIT_SBSIZE].rlim_cur;
 	uidinfo = so->so_uidinfo;
 	if (!chgsbsize(uidinfo, &sb->sb_hiwat, cc, maxcc))
 		return 0;
 	sb->sb_mbmax = min(cc * 2, sb_max);
 	if (sb->sb_lowat > sb->sb_hiwat)
 		sb->sb_lowat = sb->sb_hiwat;
 	return (1);
+}
 /*
  * Free mbufs held by a socket, and reserved mbuf space.  We do not assert
  * that the socket is held locked here: see sorflush().
  */
 void
 sbrelease(struct sockbuf *sb, struct socket *so)
+{
 	KASSERT(sb->sb_so == so);
 	sbflush(sb);
 	(void)chgsbsize(so->so_uidinfo, &sb->sb_hiwat, 0, RLIM_INFINITY);
 	sb->sb_mbmax = 0;
+}
 /*
  * Routines to add and remove
  * data from an mbuf queue.
+ *
  * The routines sbappend() or sbappendrecord() are normally called to
  * append new mbufs to a socket buffer, after checking that adequate
  * space is available, comparing the function sbspace() with the amount
  * of data to be added.  sbappendrecord() differs from sbappend() in
  * that data supplied is treated as the beginning of a new record.
  * To place a sender's address, optional access rights, and data in a
  * socket receive buffer, sbappendaddr() should be used.  To place
  * access rights and data in a socket receive buffer, sbappendrights()
  * should be used.  In either case, the new data begins a new record.
  * Note that unlike sbappend() and sbappendrecord(), these routines check
  * for the caller that there will be enough space to store the data.
  * Each fails if there is not enough space, or if it cannot find mbufs
  * to store additional information in.
+ *
  * Reliable protocols may use the socket send buffer to hold data
  * awaiting acknowledgement.  Data is normally copied from a socket
  * send buffer in a protocol with m_copym for output to a peer,
  * and then removing the data from the socket buffer with sbdrop()
  * or sbdroprecord() when the data is acknowledged by the peer.
  */
 #ifdef SOCKBUF_DEBUG
 void
 sblastrecordchk(struct sockbuf *sb, const char *where)
+{
 	struct mbuf *m = sb->sb_mb;
 	KASSERT(solocked(sb->sb_so));
 	while (m && m->m_nextpkt)
 		m = m->m_nextpkt;
 	if (m != sb->sb_lastrecord) {
 		printf("sblastrecordchk: sb_mb %p sb_lastrecord %p last %p\n",
 		    sb->sb_mb, sb->sb_lastrecord, m);
 		printf("packet chain:\n");
 		for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt)
 			printf("\t%p\n", m);
 		panic("sblastrecordchk from %s", where);
+	}
+}
 void
 sblastmbufchk(struct sockbuf *sb, const char *where)
+{
 	struct mbuf *m = sb->sb_mb;
 	struct mbuf *n;
 	KASSERT(solocked(sb->sb_so));
 	while (m && m->m_nextpkt)
 		m = m->m_nextpkt;
 	while (m && m->m_next)
 		m = m->m_next;
 	if (m != sb->sb_mbtail) {
 		printf("sblastmbufchk: sb_mb %p sb_mbtail %p last %p\n",
 		    sb->sb_mb, sb->sb_mbtail, m);
 		printf("packet tree:\n");
 		for (m = sb->sb_mb; m != NULL; m = m->m_nextpkt) {
 			printf("\t");
 			for (n = m; n != NULL; n = n->m_next)
 				printf("%p ", n);
 			printf("\n");
+		}
 		panic("sblastmbufchk from %s", where);
+	}
+}
 #endif /* SOCKBUF_DEBUG */
 /*
  * Link a chain of records onto a socket buffer
  */
 #define	SBLINKRECORDCHAIN(sb, m0, mlast)				\
 do {									\
 	if ((sb)->sb_lastrecord != NULL)				\
 		(sb)->sb_lastrecord->m_nextpkt = (m0);			\
 	else								\
 		(sb)->sb_mb = (m0);					\
 	(sb)->sb_lastrecord = (mlast);					\
 } while (/*CONSTCOND*/0)
 #define	SBLINKRECORD(sb, m0)						\
     SBLINKRECORDCHAIN(sb, m0, m0)
 /*
  * Append mbuf chain m to the last record in the
  * socket buffer sb.  The additional space associated
  * the mbuf chain is recorded in sb.  Empty mbufs are
  * discarded and mbufs are compacted where possible.
  */
 void
 sbappend(struct sockbuf *sb, struct mbuf *m)
+{
 	struct mbuf	*n;
 	KASSERT(solocked(sb->sb_so));
 	if (m == NULL)
 		return;
 #ifdef MBUFTRACE
 	m_claimm(m, sb->sb_mowner);
 #endif
 	SBLASTRECORDCHK(sb, "sbappend 1");
 	if ((n = sb->sb_lastrecord) != NULL) {
 		/*
 		 * XXX Would like to simply use sb_mbtail here, but
 		 * XXX I need to verify that I won't miss an EOR that
 		 * XXX way.
 		 */
 		do {
 			if (n->m_flags & M_EOR) {
 				sbappendrecord(sb, m); /* XXXXXX!!!! */
 				return;
+			}
 		} while (n->m_next && (n = n->m_next));
 	} else {
 		/*
 		 * If this is the first record in the socket buffer, it's
 		 * also the last record.
 		 */
 		sb->sb_lastrecord = m;
+	}
 	sbcompress(sb, m, n);
 	SBLASTRECORDCHK(sb, "sbappend 2");
+}
 /*
  * This version of sbappend() should only be used when the caller
  * absolutely knows that there will never be more than one record
  * in the socket buffer, that is, a stream protocol (such as TCP).
  */
 void
 sbappendstream(struct sockbuf *sb, struct mbuf *m)
+{
 	KASSERT(solocked(sb->sb_so));
 	KDASSERT(m->m_nextpkt == NULL);
 	KASSERT(sb->sb_mb == sb->sb_lastrecord);
 	SBLASTMBUFCHK(sb, __func__);
 #ifdef MBUFTRACE
 	m_claimm(m, sb->sb_mowner);
 #endif
 	sbcompress(sb, m, sb->sb_mbtail);
 	sb->sb_lastrecord = sb->sb_mb;
 	SBLASTRECORDCHK(sb, __func__);
+}
 #ifdef SOCKBUF_DEBUG
 void
 sbcheck(struct sockbuf *sb)
+{
 	struct mbuf	*m, *m2;
 	u_long		len, mbcnt;
 	KASSERT(solocked(sb->sb_so));
 	len = 0;
 	mbcnt = 0;
 	for (m = sb->sb_mb; m; m = m->m_nextpkt) {
 		for (m2 = m; m2 != NULL; m2 = m2->m_next) {
 			len += m2->m_len;
 			mbcnt += MSIZE;
 			if (m2->m_flags & M_EXT)
 				mbcnt += m2->m_ext.ext_size;
 			if (m2->m_nextpkt != NULL)
 				panic("sbcheck nextpkt");
+		}
+	}
 	if (len != sb->sb_cc || mbcnt != sb->sb_mbcnt) {
 		printf("cc %lu != %lu || mbcnt %lu != %lu\n", len, sb->sb_cc,
 		    mbcnt, sb->sb_mbcnt);
 		panic("sbcheck");
+	}
+}
 #endif
 /*
  * As above, except the mbuf chain
  * begins a new record.
  */
 void
 sbappendrecord(struct sockbuf *sb, struct mbuf *m0)
+{
 	struct mbuf	*m;
 	KASSERT(solocked(sb->sb_so));
 	if (m0 == NULL)
 		return;
 #ifdef MBUFTRACE
 	m_claimm(m0, sb->sb_mowner);
 #endif
 	/*
 	 * Put the first mbuf on the queue.
 	 * Note this permits zero length records.
 	 */
 	sballoc(sb, m0);
 	SBLASTRECORDCHK(sb, "sbappendrecord 1");
 	SBLINKRECORD(sb, m0);
 	m = m0->m_next;
 	m0->m_next = 0;
 	if (m && (m0->m_flags & M_EOR)) {
 		m0->m_flags &= ~M_EOR;
 		m->m_flags |= M_EOR;
+	}
 	sbcompress(sb, m, m0);
 	SBLASTRECORDCHK(sb, "sbappendrecord 2");
+}
 /*
  * As above except that OOB data
  * is inserted at the beginning of the sockbuf,
  * but after any other OOB data.
  */
 void
 sbinsertoob(struct sockbuf *sb, struct mbuf *m0)
+{
 	struct mbuf	*m, **mp;
 	KASSERT(solocked(sb->sb_so));
 	if (m0 == NULL)
 		return;
 	SBLASTRECORDCHK(sb, "sbinsertoob 1");
 	for (mp = &sb->sb_mb; (m = *mp) != NULL; mp = &((*mp)->m_nextpkt)) {
 	    again:
 		switch (m->m_type) {
 		case MT_OOBDATA:
 			continue;		/* WANT next train */
 		case MT_CONTROL:
 			if ((m = m->m_next) != NULL)
 				goto again;	/* inspect THIS train further */
+		}
 		break;
+	}
 	/*
 	 * Put the first mbuf on the queue.
 	 * Note this permits zero length records.
 	 */
 	sballoc(sb, m0);
 	m0->m_nextpkt = *mp;
 	if (*mp == NULL) {
 		/* m0 is actually the new tail */
 		sb->sb_lastrecord = m0;
+	}
 	*mp = m0;
 	m = m0->m_next;
 	m0->m_next = 0;
 	if (m && (m0->m_flags & M_EOR)) {
 		m0->m_flags &= ~M_EOR;
 		m->m_flags |= M_EOR;
+	}
 	sbcompress(sb, m, m0);
 	SBLASTRECORDCHK(sb, "sbinsertoob 2");
+}
 /*
  * Append address and data, and optionally, control (ancillary) data
  * to the receive queue of a socket.  If present,
  * m0 must include a packet header with total length.
  * Returns 0 if no space in sockbuf or insufficient mbufs.
  */
 int
 sbappendaddr(struct sockbuf *sb, const struct sockaddr *asa, struct mbuf *m0,
 	struct mbuf *control)
+{
 	struct mbuf	*m, *n, *nlast;
 	int		space, len;
 	KASSERT(solocked(sb->sb_so));
 	space = asa->sa_len;
 	if (m0 != NULL) {
 		if ((m0->m_flags & M_PKTHDR) == 0)
 			panic("sbappendaddr");
 		space += m0->m_pkthdr.len;
 #ifdef MBUFTRACE
 		m_claimm(m0, sb->sb_mowner);
 #endif
+	}
 	for (n = control; n; n = n->m_next) {
 		space += n->m_len;
 		MCLAIM(n, sb->sb_mowner);
 		if (n->m_next == NULL)	/* keep pointer to last control buf */
 			break;
+	}
 	if (space > sbspace(sb))
 		return (0);
 	m = m_get(M_DONTWAIT, MT_SONAME);
 	if (m == NULL)
 		return (0);
 	MCLAIM(m, sb->sb_mowner);
 	/*
 	 * XXX avoid 'comparison always true' warning which isn't easily
 	 * avoided.
 	 */
 	len = asa->sa_len;
 	if (len > MLEN) {
 		MEXTMALLOC(m, asa->sa_len, M_NOWAIT);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return (0);
+		}
+	}
 	m->m_len = asa->sa_len;
 	memcpy(mtod(m, void *), asa, asa->sa_len);
 	if (n)
 		n->m_next = m0;		/* concatenate data to control */
 	else
 		control = m0;
 	m->m_next = control;
 	SBLASTRECORDCHK(sb, "sbappendaddr 1");
 	for (n = m; n->m_next != NULL; n = n->m_next)
 		sballoc(sb, n);
 	sballoc(sb, n);
 	nlast = n;
 	SBLINKRECORD(sb, m);
 	sb->sb_mbtail = nlast;
 	SBLASTMBUFCHK(sb, "sbappendaddr");
 	SBLASTRECORDCHK(sb, "sbappendaddr 2");
 	return (1);
+}
 /*
  * Helper for sbappendchainaddr: prepend a struct sockaddr* to
  * an mbuf chain.
  */
 static inline struct mbuf *
 m_prepend_sockaddr(struct sockbuf *sb, struct mbuf *m0,
 		   const struct sockaddr *asa)
+{
 	struct mbuf *m;
 	const int salen = asa->sa_len;
 	KASSERT(solocked(sb->sb_so));
 	/* only the first in each chain need be a pkthdr */
 	m = m_gethdr(M_DONTWAIT, MT_SONAME);
 	if (m == NULL)
 		return NULL;
 	MCLAIM(m, sb->sb_mowner);
 #ifdef notyet
 	if (salen > MHLEN) {
 		MEXTMALLOC(m, salen, M_NOWAIT);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return NULL;
+		}
+	}
 #else
 	KASSERT(salen <= MHLEN);
 #endif
 	m->m_len = salen;
 	memcpy(mtod(m, void *), asa, salen);
 	m->m_next = m0;
 	m->m_pkthdr.len = salen + m0->m_pkthdr.len;
 	return m;
+}
 int
 sbappendaddrchain(struct sockbuf *sb, const struct sockaddr *asa,
 		  struct mbuf *m0, int sbprio)
+{
 	struct mbuf *m, *n, *n0, *nlast;
 	int error;
 	KASSERT(solocked(sb->sb_so));
 	/*
 	 * XXX sbprio reserved for encoding priority of this* request:
 	 *  SB_PRIO_NONE --> honour normal sb limits
 	 *  SB_PRIO_ONESHOT_OVERFLOW --> if socket has any space,
 	 *	take whole chain. Intended for large requests
 	 *      that should be delivered atomically (all, or none).
 	 * SB_PRIO_OVERDRAFT -- allow a small (2*MLEN) overflow
 	 *       over normal socket limits, for messages indicating
 	 *       buffer overflow in earlier normal/lower-priority messages
 	 * SB_PRIO_BESTEFFORT -->  ignore limits entirely.
 	 *       Intended for  kernel-generated messages only.
 	 *        Up to generator to avoid total mbuf resource exhaustion.
 	 */
 	(void)sbprio;
 	if (m0 && (m0->m_flags & M_PKTHDR) == 0)
 		panic("sbappendaddrchain");
 #ifdef notyet
 	space = sbspace(sb);
 	/*
 	 * Enforce SB_PRIO_* limits as described above.
 	 */
 #endif
 	n0 = NULL;
 	nlast = NULL;
 	for (m = m0; m; m = m->m_nextpkt) {
 		struct mbuf *np;
 #ifdef MBUFTRACE
 		m_claimm(m, sb->sb_mowner);
 #endif
 		/* Prepend sockaddr to this record (m) of input chain m0 */
 	  	n = m_prepend_sockaddr(sb, m, asa);
 		if (n == NULL) {
 			error = ENOBUFS;
 			goto bad;
+		}
 		/* Append record (asa+m) to end of new chain n0 */
 		if (n0 == NULL) {
 			n0 = n;
 		} else {
 			nlast->m_nextpkt = n;
+		}
 		/* Keep track of last record on new chain */
 		nlast = n;
 		for (np = n; np; np = np->m_next)
 			sballoc(sb, np);
+	}
 	SBLASTRECORDCHK(sb, "sbappendaddrchain 1");
 	/* Drop the entire chain of (asa+m) records onto the socket */
 	SBLINKRECORDCHAIN(sb, n0, nlast);
 	SBLASTRECORDCHK(sb, "sbappendaddrchain 2");
 	for (m = nlast; m->m_next; m = m->m_next)
+		;
 	sb->sb_mbtail = m;
 	SBLASTMBUFCHK(sb, "sbappendaddrchain");
 	return (1);
 bad:
 	/*
 	 * On error, free the prepended addreseses. For consistency
 	 * with sbappendaddr(), leave it to our caller to free
 	 * the input record chain passed to us as m0.
 	 */
 	while ((n = n0) != NULL) {
 	  	struct mbuf *np;
 		/* Undo the sballoc() of this record */
 		for (np = n; np; np = np->m_next)
 			sbfree(sb, np);
 		n0 = n->m_nextpkt;	/* iterate at next prepended address */
 		np = m_free(n);		/* free prepended address (not data) */
+	}
 	return error;
+}
 int
 sbappendcontrol(struct sockbuf *sb, struct mbuf *m0, struct mbuf *control)
+{
 	struct mbuf	*m, *mlast, *n;
 	int		space;
 	KASSERT(solocked(sb->sb_so));
 	space = 0;
 	if (control == NULL)
 		panic("sbappendcontrol");
 	for (m = control; ; m = m->m_next) {
 		space += m->m_len;
 		MCLAIM(m, sb->sb_mowner);
 		if (m->m_next == NULL)
 			break;
+	}
 	n = m;			/* save pointer to last control buffer */
 	for (m = m0; m; m = m->m_next) {
 		MCLAIM(m, sb->sb_mowner);
 		space += m->m_len;
+	}
 	if (space > sbspace(sb))
 		return (0);
 	n->m_next = m0;			/* concatenate data to control */
 	SBLASTRECORDCHK(sb, "sbappendcontrol 1");
 	for (m = control; m->m_next != NULL; m = m->m_next)
 		sballoc(sb, m);
 	sballoc(sb, m);
 	mlast = m;
 	SBLINKRECORD(sb, control);
 	sb->sb_mbtail = mlast;
 	SBLASTMBUFCHK(sb, "sbappendcontrol");
 	SBLASTRECORDCHK(sb, "sbappendcontrol 2");
 	return (1);
+}
 /*
  * Compress mbuf chain m into the socket
  * buffer sb following mbuf n.  If n
  * is null, the buffer is presumed empty.
  */
 void
 sbcompress(struct sockbuf *sb, struct mbuf *m, struct mbuf *n)
+{
 	int		eor;
 	struct mbuf	*o;
 	KASSERT(solocked(sb->sb_so));
 	eor = 0;
 	while (m) {
 		eor |= m->m_flags & M_EOR;
 		if (m->m_len == 0 &&
 		    (eor == 0 ||
 		     (((o = m->m_next) || (o = n)) &&
 		      o->m_type == m->m_type))) {
 			if (sb->sb_lastrecord == m)
 				sb->sb_lastrecord = m->m_next;
 			m = m_free(m);
 			continue;
+		}
 		if (n && (n->m_flags & M_EOR) == 0 &&
 		    /* M_TRAILINGSPACE() checks buffer writeability */
 		    m->m_len <= MCLBYTES / 4 && /* XXX Don't copy too much */
 		    m->m_len <= M_TRAILINGSPACE(n) &&
 		    n->m_type == m->m_type) {
 			memcpy(mtod(n, char *) + n->m_len, mtod(m, void *),
 			    (unsigned)m->m_len);
 			n->m_len += m->m_len;
 			sb->sb_cc += m->m_len;
 			m = m_free(m);
 			continue;
+		}
 		if (n)
 			n->m_next = m;
 		else
 			sb->sb_mb = m;
 		sb->sb_mbtail = m;
 		sballoc(sb, m);
 		n = m;
 		m->m_flags &= ~M_EOR;
 		m = m->m_next;
 		n->m_next = 0;
+	}
 	if (eor) {
 		if (n)
 			n->m_flags |= eor;
 		else
 			printf("semi-panic: sbcompress\n");
+	}
 	SBLASTMBUFCHK(sb, __func__);
+}
 /*
  * Free all mbufs in a sockbuf.
  * Check that all resources are reclaimed.
  */
 void
 sbflush(struct sockbuf *sb)
+{
 	KASSERT(solocked(sb->sb_so));
 	KASSERT((sb->sb_flags & SB_LOCK) == 0);
 	while (sb->sb_mbcnt)
 		sbdrop(sb, (int)sb->sb_cc);
 	KASSERT(sb->sb_cc == 0);
 	KASSERT(sb->sb_mb == NULL);
 	KASSERT(sb->sb_mbtail == NULL);
 	KASSERT(sb->sb_lastrecord == NULL);
+}
 /*
  * Drop data from (the front of) a sockbuf.
  */
 void
 sbdrop(struct sockbuf *sb, int len)
+{
 	struct mbuf	*m, *next;
 	KASSERT(solocked(sb->sb_so));
 	next = (m = sb->sb_mb) ? m->m_nextpkt : NULL;
 	while (len > 0) {
 		if (m == NULL) {
 			if (next == NULL)
 				panic("sbdrop(%p,%d): cc=%lu",
 				    sb, len, sb->sb_cc);
 			m = next;
 			next = m->m_nextpkt;
 			continue;
+		}
 		if (m->m_len > len) {
 			m->m_len -= len;
 			m->m_data += len;
 			sb->sb_cc -= len;
 			break;
+		}
 		len -= m->m_len;
 		sbfree(sb, m);
 		m = m_free(m);
+	}
 	while (m && m->m_len == 0) {
 		sbfree(sb, m);
 		m = m_free(m);
+	}
 	if (m) {
 		sb->sb_mb = m;
 		m->m_nextpkt = next;
 	} else
 		sb->sb_mb = next;
 	/*
 	 * First part is an inline SB_EMPTY_FIXUP().  Second part
 	 * makes sure sb_lastrecord is up-to-date if we dropped
 	 * part of the last record.
 	 */
 	m = sb->sb_mb;
 	if (m == NULL) {
 		sb->sb_mbtail = NULL;
 		sb->sb_lastrecord = NULL;
 	} else if (m->m_nextpkt == NULL)
 		sb->sb_lastrecord = m;
+}
 /*
  * Drop a record off the front of a sockbuf
  * and move the next record to the front.
  */
 void
 sbdroprecord(struct sockbuf *sb)
+{
 	struct mbuf	*m, *mn;
 	KASSERT(solocked(sb->sb_so));
 	m = sb->sb_mb;
 	if (m) {
 		sb->sb_mb = m->m_nextpkt;
 		do {
 			sbfree(sb, m);
 			mn = m_free(m);
 		} while ((m = mn) != NULL);
+	}
 	SB_EMPTY_FIXUP(sb);
+}
 /*
  * Create a "control" mbuf containing the specified data
  * with the specified type for presentation on a socket buffer.
  */
 struct mbuf *
 sbcreatecontrol1(void **p, int size, int type, int level, int flags)
+{
 	struct cmsghdr	*cp;
 	struct mbuf	*m;
 	int space = CMSG_SPACE(size);
 	if ((flags & M_DONTWAIT) && space > MCLBYTES) {
 		printf("%s: message too large %d\n", __func__, space);
 		return NULL;
+	}
 	if ((m = m_get(flags, MT_CONTROL)) == NULL)
 		return NULL;
 	if (space > MLEN) {
 		if (space > MCLBYTES)
 			MEXTMALLOC(m, space, M_WAITOK);
 		else
 			MCLGET(m, flags);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return NULL;
+		}
+	}
 	cp = mtod(m, struct cmsghdr *);
 	*p = CMSG_DATA(cp);
 	m->m_len = space;
 	cp->cmsg_len = CMSG_LEN(size);
 	cp->cmsg_level = level;
 	cp->cmsg_type = type;
 	return m;
+}
 struct mbuf *
 sbcreatecontrol(void *p, int size, int type, int level)
+{
 	struct mbuf *m;
 	void *v;
 	m = sbcreatecontrol1(&v, size, type, level, M_DONTWAIT);
 	if (m == NULL)
 		return NULL;
 	memcpy(v, p, size);
 	return m;
+}
 void
 solockretry(struct socket *so, kmutex_t *lock)
+{
 	while (lock != so->so_lock) {
 		mutex_exit(lock);
 		lock = so->so_lock;
 		mutex_enter(lock);
+	}
+}
 bool
 solocked(const struct socket *so)
+{
 	return mutex_owned(so->so_lock);
+}
 bool
 solocked2(const struct socket *so1, const struct socket *so2)
+{
 	const kmutex_t *lock;
 	lock = so1->so_lock;
 	if (lock != so2->so_lock)
 		return false;
 	return mutex_owned(lock);
+}
 /*
  * sosetlock: assign a default lock to a new socket.
  */
 void
 sosetlock(struct socket *so)
+{
 	if (so->so_lock == NULL) {
 		kmutex_t *lock = softnet_lock;
 		so->so_lock = lock;
 		mutex_obj_hold(lock);
 		mutex_enter(lock);
+	}
 	KASSERT(solocked(so));
+}
 /*
  * Set lock on sockbuf sb; sleep if lock is already held.
  * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
  * Returns error without lock if sleep is interrupted.
  */
 int
 sblock(struct sockbuf *sb, int wf)
+{
 	struct socket *so;
 	kmutex_t *lock;
 	int error;
 	KASSERT(solocked(sb->sb_so));
 	for (;;) {
 		if (__predict_true((sb->sb_flags & SB_LOCK) == 0)) {
 			sb->sb_flags |= SB_LOCK;
 			return 0;
+		}
 		if (wf != M_WAITOK)
 			return EWOULDBLOCK;
 		so = sb->sb_so;
 		lock = so->so_lock;
 		if ((sb->sb_flags & SB_NOINTR) != 0) {
 			cv_wait(&so->so_cv, lock);
 			error = 0;
 		} else
 			error = cv_wait_sig(&so->so_cv, lock);
 		if (__predict_false(lock != so->so_lock))
 			solockretry(so, lock);

 @@ -1,580 +1,581 @@
-/*	$NetBSD: socketvar.h,v 1.155 2018/05/04 08:35:07 christos Exp $	*/
+/*	$NetBSD: socketvar.h,v 1.156 2018/06/06 09:46:46 roy Exp $	*/
 /*-
  * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*-
  * Copyright (c) 1982, 1986, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	@(#)socketvar.h	8.3 (Berkeley) 2/19/95
  */
 #ifndef _SYS_SOCKETVAR_H_
 #define	_SYS_SOCKETVAR_H_
 #include <sys/select.h>
 #include <sys/selinfo.h>		/* for struct selinfo */
 #include <sys/queue.h>
 #include <sys/mutex.h>
 #include <sys/condvar.h>
 #if !defined(_KERNEL)
 struct uio;
 struct lwp;
 struct uidinfo;
 #else
 #include <sys/uidinfo.h>
 #endif
 TAILQ_HEAD(soqhead, socket);
 /*
  * Variables for socket buffering.
  */
 struct sockbuf {
 	struct selinfo sb_sel;		/* process selecting read/write */
 	struct mowner *sb_mowner;	/* who owns data for this sockbuf */
 	struct socket *sb_so;		/* back pointer to socket */
 	kcondvar_t sb_cv;		/* notifier */
 	/* When re-zeroing this struct, we zero from sb_startzero to the end */
 #define	sb_startzero	sb_cc
 	u_long	sb_cc;			/* actual chars in buffer */
 	u_long	sb_hiwat;		/* max actual char count */
 	u_long	sb_mbcnt;		/* chars of mbufs used */
 	u_long	sb_mbmax;		/* max chars of mbufs to use */
 	u_long	sb_lowat;		/* low water mark */
 	struct mbuf *sb_mb;		/* the mbuf chain */
 	struct mbuf *sb_mbtail;		/* the last mbuf in the chain */
 	struct mbuf *sb_lastrecord;	/* first mbuf of last record in
 					   socket buffer */
 	int	sb_flags;		/* flags, see below */
 	int	sb_timeo;		/* timeout for read/write */
 	u_long	sb_overflowed;		/* # of drops due to full buffer */
 };
 #ifndef SB_MAX
 #define	SB_MAX		(256*1024)	/* default for max chars in sockbuf */
 #endif
 #define	SB_LOCK		0x01		/* lock on data queue */
 #define	SB_NOTIFY	0x04		/* someone is waiting for data/space */
 #define	SB_ASYNC	0x10		/* ASYNC I/O, need signals */
 #define	SB_UPCALL	0x20		/* someone wants an upcall */
 #define	SB_NOINTR	0x40		/* operations not interruptible */
 #define	SB_KNOTE	0x100		/* kernel note attached */
 #define	SB_AUTOSIZE	0x800		/* automatically size socket buffer */
 /*
  * Kernel structure per socket.
  * Contains send and receive buffer queues,
  * handle on protocol and pointer to protocol
  * private data and error information.
  */
 struct so_accf {
 	struct accept_filter	*so_accept_filter;
 	void	*so_accept_filter_arg;	/* saved filter args */
 	char	*so_accept_filter_str;	/* saved user args */
 };
 struct sockaddr;
 struct socket {
 	kmutex_t * volatile so_lock;	/* pointer to lock on structure */
 	kcondvar_t	so_cv;		/* notifier */
 	short		so_type;	/* generic type, see socket.h */
 	short		so_options;	/* from socket call, see socket.h */
 	u_short		so_linger;	/* time to linger while closing */
 	short		so_state;	/* internal state flags SS_*, below */
 	int		so_unused;	/* used to be so_nbio */
 	void		*so_pcb;	/* protocol control block */
 	const struct protosw *so_proto;	/* protocol handle */
 /*
  * Variables for connection queueing.
  * Socket where accepts occur is so_head in all subsidiary sockets.
  * If so_head is 0, socket is not related to an accept.
  * For head socket so_q0 queues partially completed connections,
  * while so_q is a queue of connections ready to be accepted.
  * If a connection is aborted and it has so_head set, then
  * it has to be pulled out of either so_q0 or so_q.
  * We allow connections to queue up based on current queue lengths
  * and limit on number of queued connections for this socket.
  */
 	struct socket	*so_head;	/* back pointer to accept socket */
 	struct soqhead	*so_onq;	/* queue (q or q0) that we're on */
 	struct soqhead	so_q0;		/* queue of partial connections */
 	struct soqhead	so_q;		/* queue of incoming connections */
 	TAILQ_ENTRY(socket) so_qe;	/* our queue entry (q or q0) */
 	short		so_q0len;	/* partials on so_q0 */
 	short		so_qlen;	/* number of connections on so_q */
 	short		so_qlimit;	/* max number queued connections */
 	short		so_timeo;	/* connection timeout */
 	u_short		so_error;	/* error affecting connection */
 	u_short		so_rerror;	/* error affecting receiving */
 	u_short		so_aborting;	/* references from soabort() */
 	pid_t		so_pgid;	/* pgid for signals */
 	u_long		so_oobmark;	/* chars to oob mark */
 	struct sockbuf	so_snd;		/* send buffer */
 	struct sockbuf	so_rcv;		/* receive buffer */
 	void		*so_internal;	/* Space for svr4 stream data */
 	void		(*so_upcall) (struct socket *, void *, int, int);
 	void *		so_upcallarg;	/* Arg for above */
 	int		(*so_send) (struct socket *, struct sockaddr *,
 					struct uio *, struct mbuf *,
 					struct mbuf *, int, struct lwp *);
 	int		(*so_receive) (struct socket *,
 					struct mbuf **,
 					struct uio *, struct mbuf **,
 					struct mbuf **, int *);
 	struct mowner	*so_mowner;	/* who owns mbufs for this socket */
 	struct uidinfo	*so_uidinfo;	/* who opened the socket */
 	gid_t		so_egid;	/* creator effective gid */
 	pid_t		so_cpid;	/* creator pid */
 	struct so_accf	*so_accf;
 	kauth_cred_t	so_cred;	/* socket credentials */
 };
 /*
  * Socket state bits.
  */
 #define	SS_NOFDREF		0x001	/* no file table ref any more */
 #define	SS_ISCONNECTED		0x002	/* socket connected to a peer */
 #define	SS_ISCONNECTING		0x004	/* in process of connecting to peer */
 #define	SS_ISDISCONNECTING	0x008	/* in process of disconnecting */
 #define	SS_CANTSENDMORE		0x010	/* can't send more data to peer */
 #define	SS_CANTRCVMORE		0x020	/* can't receive more data from peer */
 #define	SS_RCVATMARK		0x040	/* at mark on input */
 #define	SS_ISABORTING		0x080	/* aborting fd references - close() */
 #define	SS_RESTARTSYS		0x100	/* restart blocked system calls */
 #define	SS_ISDISCONNECTED	0x800	/* socket disconnected from peer */
 #define	SS_ASYNC		0x100	/* async i/o notify */
 #define	SS_MORETOCOME		0x400	/*
 					 * hint from sosend to lower layer;
 					 * more data coming
 					 */
 #define	SS_ISAPIPE 		0x1000	/* socket is implementing a pipe */
 #define	SS_NBIO			0x2000	/* socket is in non blocking I/O */
 #ifdef _KERNEL
 struct accept_filter {
 	char	accf_name[16];
 	void	(*accf_callback)
 		(struct socket *, void *, int, int);
 	void *	(*accf_create)
 		(struct socket *, char *);
 	void	(*accf_destroy)
 		(struct socket *);
 	LIST_ENTRY(accept_filter) accf_next;
 	u_int	accf_refcnt;
 };
 struct sockopt {
 	int		sopt_level;		/* option level */
 	int		sopt_name;		/* option name */
 	size_t		sopt_size;		/* data length */
 	size_t		sopt_retsize;		/* returned data length */
 	void *		sopt_data;		/* data pointer */
 	uint8_t		sopt_buf[sizeof(int)];	/* internal storage */
 };
 #define	SB_EMPTY_FIXUP(sb)						\
 do {									\
 	KASSERT(solocked((sb)->sb_so));					\
 	if ((sb)->sb_mb == NULL) {					\
 		(sb)->sb_mbtail = NULL;					\
 		(sb)->sb_lastrecord = NULL;				\
 	}								\
 } while (/*CONSTCOND*/0)
 extern u_long		sb_max;
 extern int		somaxkva;
 extern int		sock_loan_thresh;
 extern kmutex_t		*softnet_lock;
 struct mbuf;
 struct lwp;
 struct msghdr;
 struct stat;
 struct knote;
 struct sockaddr_big;
 enum uio_seg;
 struct	mbuf *getsombuf(struct socket *, int);
 /* 0x400 is SO_OTIMESTAMP */
 #define SOOPT_TIMESTAMP(o)     ((o) & (SO_TIMESTAMP | 0x400))
 /*
  * File operations on sockets.
  */
 int	soo_read(file_t *, off_t *, struct uio *, kauth_cred_t, int);
 int	soo_write(file_t *, off_t *, struct uio *, kauth_cred_t, int);
 int	soo_fcntl(file_t *, u_int cmd, void *);
 int	soo_ioctl(file_t *, u_long cmd, void *);
 int	soo_poll(file_t *, int);
 int	soo_kqfilter(file_t *, struct knote *);
 int 	soo_close(file_t *);
 int	soo_stat(file_t *, struct stat *);
 void	soo_restart(file_t *);
 void	sbappend(struct sockbuf *, struct mbuf *);
 void	sbappendstream(struct sockbuf *, struct mbuf *);
 int	sbappendaddr(struct sockbuf *, const struct sockaddr *, struct mbuf *,
 	    struct mbuf *);
 int	sbappendaddrchain(struct sockbuf *, const struct sockaddr *,
 	     struct mbuf *, int);
 int	sbappendcontrol(struct sockbuf *, struct mbuf *, struct mbuf *);
 void	sbappendrecord(struct sockbuf *, struct mbuf *);
 void	sbcheck(struct sockbuf *);
 void	sbcompress(struct sockbuf *, struct mbuf *, struct mbuf *);
 struct mbuf *
 	sbcreatecontrol(void *, int, int, int);
 struct mbuf *
 	sbcreatecontrol1(void **, int, int, int, int);
 struct mbuf **
 	sbsavetimestamp(int, struct mbuf **);
 void	sbdrop(struct sockbuf *, int);
 void	sbdroprecord(struct sockbuf *);
 void	sbflush(struct sockbuf *);
 void	sbinsertoob(struct sockbuf *, struct mbuf *);
 void	sbrelease(struct sockbuf *, struct socket *);
 int	sbreserve(struct sockbuf *, u_long, struct socket *);
 int	sbwait(struct sockbuf *);
 int	sb_max_set(u_long);
 void	soinit(void);
 void	soinit1(void);
 void	soinit2(void);
 int	soabort(struct socket *);
 int	soaccept(struct socket *, struct sockaddr *);
 int	sofamily(const struct socket *);
 int	sobind(struct socket *, struct sockaddr *, struct lwp *);
 void	socantrcvmore(struct socket *);
 void	socantsendmore(struct socket *);
 void	soroverflow(struct socket *);
 int	soclose(struct socket *);
 int	soconnect(struct socket *, struct sockaddr *, struct lwp *);
 int	soconnect2(struct socket *, struct socket *);
 int	socreate(int, struct socket **, int, int, struct lwp *,
 		 struct socket *);
 int	fsocreate(int, struct socket **, int, int, int *);
 int	sodisconnect(struct socket *);
 void	sofree(struct socket *);
 int	sogetopt(struct socket *, struct sockopt *);
 void	sohasoutofband(struct socket *);
 void	soisconnected(struct socket *);
 void	soisconnecting(struct socket *);
 void	soisdisconnected(struct socket *);
 void	soisdisconnecting(struct socket *);
 int	solisten(struct socket *, int, struct lwp *);
 struct socket *
 	sonewconn(struct socket *, bool);
 void	soqinsque(struct socket *, struct socket *, int);
 bool	soqremque(struct socket *, int);
 int	soreceive(struct socket *, struct mbuf **, struct uio *,
 	    struct mbuf **, struct mbuf **, int *);
 int	soreserve(struct socket *, u_long, u_long);
 void	sorflush(struct socket *);
 int	sosend(struct socket *, struct sockaddr *, struct uio *,
 	    struct mbuf *, struct mbuf *, int, struct lwp *);
 int	sosetopt(struct socket *, struct sockopt *);
 int	so_setsockopt(struct lwp *, struct socket *, int, int, const void *, size_t);
 int	soshutdown(struct socket *, int);
 void	sorestart(struct socket *);
 void	sowakeup(struct socket *, struct sockbuf *, int);
 int	sockargs(struct mbuf **, const void *, size_t, enum uio_seg, int);
 int	sopoll(struct socket *, int);
 struct	socket *soget(bool);
 void	soput(struct socket *);
 bool	solocked(const struct socket *);
 bool	solocked2(const struct socket *, const struct socket *);
 int	sblock(struct sockbuf *, int);
 void	sbunlock(struct sockbuf *);
 int	sowait(struct socket *, bool, int);
 void	solockretry(struct socket *, kmutex_t *);
 void	sosetlock(struct socket *);
 void	solockreset(struct socket *, kmutex_t *);
 void	sockopt_init(struct sockopt *, int, int, size_t);
 void	sockopt_destroy(struct sockopt *);
 int	sockopt_set(struct sockopt *, const void *, size_t);
 int	sockopt_setint(struct sockopt *, int);
 int	sockopt_get(const struct sockopt *, void *, size_t);
 int	sockopt_getint(const struct sockopt *, int *);
 int	sockopt_setmbuf(struct sockopt *, struct mbuf *);
 struct mbuf *sockopt_getmbuf(const struct sockopt *);
 int	copyout_sockname(struct sockaddr *, unsigned int *, int, struct mbuf *);
 int	copyout_sockname_sb(struct sockaddr *, unsigned int *,
     int , struct sockaddr_big *);
 int	copyout_msg_control(struct lwp *, struct msghdr *, struct mbuf *);
 void	free_control_mbuf(struct lwp *, struct mbuf *, struct mbuf *);
 int	do_sys_getpeername(int, struct sockaddr *);
 int	do_sys_getsockname(int, struct sockaddr *);
 int	do_sys_sendmsg(struct lwp *, int, struct msghdr *, int, register_t *);
 int	do_sys_sendmsg_so(struct lwp *, int, struct socket *, file_t *,
 	    struct msghdr *, int, register_t *);
 int	do_sys_recvmsg(struct lwp *, int, struct msghdr *,
 	    struct mbuf **, struct mbuf **, register_t *);
 int	do_sys_recvmsg_so(struct lwp *, int, struct socket *,
 	    struct msghdr *mp, struct mbuf **, struct mbuf **, register_t *);
 int	do_sys_bind(struct lwp *, int, struct sockaddr *);
 int	do_sys_connect(struct lwp *, int, struct sockaddr *);
 int	do_sys_accept(struct lwp *, int, struct sockaddr *, register_t *,
 	    const sigset_t *, int, int);
 /*
  * Inline functions for sockets and socket buffering.
  */
 #include <sys/protosw.h>
 #include <sys/mbuf.h>
 /*
  * Do we need to notify the other side when I/O is possible?
  */
 static __inline int
 sb_notify(struct sockbuf *sb)
+{
 	KASSERT(solocked(sb->sb_so));
 	return sb->sb_flags & (SB_NOTIFY | SB_ASYNC | SB_UPCALL | SB_KNOTE);
+}
 /*
  * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
  * Since the fields are unsigned, detect overflow and return 0.
  */
 static __inline u_long
 sbspace(const struct sockbuf *sb)
+{
 	KASSERT(solocked(sb->sb_so));
 	if (sb->sb_hiwat <= sb->sb_cc || sb->sb_mbmax <= sb->sb_mbcnt)
 		return 0;
 	return lmin(sb->sb_hiwat - sb->sb_cc, sb->sb_mbmax - sb->sb_mbcnt);
+}
 /* do we have to send all at once on a socket? */
 static __inline int
 sosendallatonce(const struct socket *so)
+{
 	return so->so_proto->pr_flags & PR_ATOMIC;
+}
 /* can we read something from so? */
 static __inline int
 soreadable(const struct socket *so)
+{
 	KASSERT(solocked(so));
 	return so->so_rcv.sb_cc >= so->so_rcv.sb_lowat ||
 	    (so->so_state & SS_CANTRCVMORE) != 0 ||
 	    so->so_qlen != 0 || so->so_error != 0;
+}
 /* can we write something to so? */
 static __inline int
 sowritable(const struct socket *so)
+{
 	KASSERT(solocked(so));
 	return (sbspace(&so->so_snd) >= so->so_snd.sb_lowat &&
 	    ((so->so_state & SS_ISCONNECTED) != 0 ||
 	    (so->so_proto->pr_flags & PR_CONNREQUIRED) == 0)) ||
 	    (so->so_state & SS_CANTSENDMORE) != 0 ||
 	    so->so_error != 0;
+}
 /* adjust counters in sb reflecting allocation of m */
 static __inline void
 sballoc(struct sockbuf *sb, struct mbuf *m)
+{
 	KASSERT(solocked(sb->sb_so));
 	sb->sb_cc += m->m_len;
 	sb->sb_mbcnt += MSIZE;
 	if (m->m_flags & M_EXT)
 		sb->sb_mbcnt += m->m_ext.ext_size;
+}
 /* adjust counters in sb reflecting freeing of m */
 static __inline void
 sbfree(struct sockbuf *sb, struct mbuf *m)
+{
 	KASSERT(solocked(sb->sb_so));
 	sb->sb_cc -= m->m_len;
 	sb->sb_mbcnt -= MSIZE;
 	if (m->m_flags & M_EXT)
 		sb->sb_mbcnt -= m->m_ext.ext_size;
+}
 static __inline void
 sorwakeup(struct socket *so)
+{
 	KASSERT(solocked(so));
 	if (sb_notify(&so->so_rcv))
 		sowakeup(so, &so->so_rcv, POLL_IN);
+}
 static __inline void
 sowwakeup(struct socket *so)
+{
 	KASSERT(solocked(so));
 	if (sb_notify(&so->so_snd))
 		sowakeup(so, &so->so_snd, POLL_OUT);
+}
 static __inline void
 solock(struct socket *so)
+{
 	kmutex_t *lock;
 	lock = so->so_lock;
 	mutex_enter(lock);
 	if (__predict_false(lock != so->so_lock))
 		solockretry(so, lock);
+}
 static __inline void
 sounlock(struct socket *so)
+{
 	mutex_exit(so->so_lock);
+}
 #ifdef SOCKBUF_DEBUG
 /*
  * SBLASTRECORDCHK: check sb->sb_lastrecord is maintained correctly.
  * SBLASTMBUFCHK: check sb->sb_mbtail is maintained correctly.
+ *
  * => panic if the socket buffer is inconsistent.
  * => 'where' is used for a panic message.
  */
 void	sblastrecordchk(struct sockbuf *, const char *);
 #define	SBLASTRECORDCHK(sb, where)	sblastrecordchk((sb), (where))
 void	sblastmbufchk(struct sockbuf *, const char *);
 #define	SBLASTMBUFCHK(sb, where)	sblastmbufchk((sb), (where))
 #define	SBCHECK(sb)			sbcheck(sb)
 #else
 #define	SBLASTRECORDCHK(sb, where)	/* nothing */
 #define	SBLASTMBUFCHK(sb, where)	/* nothing */
 #define	SBCHECK(sb)			/* nothing */
 #endif /* SOCKBUF_DEBUG */
 /* sosend loan */
 vaddr_t	sokvaalloc(vaddr_t, vsize_t, struct socket *);
 void	sokvafree(vaddr_t, vsize_t);
 void	soloanfree(struct mbuf *, void *, size_t, void *);
 /*
  * Values for socket-buffer-append priority argument to sbappendaddrchain().
  * The following flags are reserved for future implementation:
+ *
  *  SB_PRIO_NONE:  honour normal socket-buffer limits.
+ *
  *  SB_PRIO_ONESHOT_OVERFLOW:  if the socket has any space,
  *	deliver the entire chain. Intended for large requests
  *      that should be delivered in their entirety, or not at all.
+ *
  * SB_PRIO_OVERDRAFT:  allow a small (2*MLEN) overflow, over and
  *	aboce normal socket limits. Intended messages indicating
  *      buffer overflow in earlier normal/lower-priority messages .
+ *
  * SB_PRIO_BESTEFFORT: Ignore  limits entirely.  Intended only for
  * 	kernel-generated messages to specially-marked scokets which
  *	require "reliable" delivery, nd where the source socket/protocol
  *	message generator enforce some hard limit (but possibly well
  *	above kern.sbmax). It is entirely up to the in-kernel source to
  *	avoid complete mbuf exhaustion or DoS scenarios.
  */
 #define SB_PRIO_NONE 	 	0
 #define SB_PRIO_ONESHOT_OVERFLOW 1
 #define SB_PRIO_OVERDRAFT	2
 #define SB_PRIO_BESTEFFORT	3
 /*
  * Accept filter functions (duh).
  */
 int	accept_filt_getopt(struct socket *, struct sockopt *);
 int	accept_filt_setopt(struct socket *, const struct sockopt *);
 int	accept_filt_clear(struct socket *);
 int	accept_filt_add(struct accept_filter *);
 int	accept_filt_del(struct accept_filter *);
 struct	accept_filter *accept_filt_get(char *);
 #ifdef ACCEPT_FILTER_MOD
 #ifdef SYSCTL_DECL
 SYSCTL_DECL(_net_inet_accf);
 #endif
 void	accept_filter_init(void);
 #endif
 #endif /* _KERNEL */
 #endif /* !_SYS_SOCKETVAR_H_ */