Home | History | Annotate | Line # | Download | only in kern
uipc_socket.c revision 1.177.4.4
      1  1.177.4.4       riz /*	$NetBSD: uipc_socket.c,v 1.177.4.4 2011/08/08 19:45:57 riz Exp $	*/
      2       1.64   thorpej 
      3       1.64   thorpej /*-
      4  1.177.4.2       snj  * Copyright (c) 2002, 2007, 2008, 2009 The NetBSD Foundation, Inc.
      5       1.64   thorpej  * All rights reserved.
      6       1.64   thorpej  *
      7       1.64   thorpej  * This code is derived from software contributed to The NetBSD Foundation
      8  1.177.4.2       snj  * by Jason R. Thorpe of Wasabi Systems, Inc, and by Andrew Doran.
      9       1.64   thorpej  *
     10       1.64   thorpej  * Redistribution and use in source and binary forms, with or without
     11       1.64   thorpej  * modification, are permitted provided that the following conditions
     12       1.64   thorpej  * are met:
     13       1.64   thorpej  * 1. Redistributions of source code must retain the above copyright
     14       1.64   thorpej  *    notice, this list of conditions and the following disclaimer.
     15       1.64   thorpej  * 2. Redistributions in binary form must reproduce the above copyright
     16       1.64   thorpej  *    notice, this list of conditions and the following disclaimer in the
     17       1.64   thorpej  *    documentation and/or other materials provided with the distribution.
     18       1.64   thorpej  *
     19       1.64   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     20       1.64   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     21       1.64   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     22       1.64   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     23       1.64   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     24       1.64   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     25       1.64   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     26       1.64   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     27       1.64   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     28       1.64   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     29       1.64   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     30       1.64   thorpej  */
     31       1.16       cgd 
     32        1.1       cgd /*
     33      1.159        ad  * Copyright (c) 2004 The FreeBSD Foundation
     34      1.159        ad  * Copyright (c) 2004 Robert Watson
     35       1.15   mycroft  * Copyright (c) 1982, 1986, 1988, 1990, 1993
     36       1.15   mycroft  *	The Regents of the University of California.  All rights reserved.
     37        1.1       cgd  *
     38        1.1       cgd  * Redistribution and use in source and binary forms, with or without
     39        1.1       cgd  * modification, are permitted provided that the following conditions
     40        1.1       cgd  * are met:
     41        1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     42        1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     43        1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     44        1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     45        1.1       cgd  *    documentation and/or other materials provided with the distribution.
     46       1.85       agc  * 3. Neither the name of the University nor the names of its contributors
     47        1.1       cgd  *    may be used to endorse or promote products derived from this software
     48        1.1       cgd  *    without specific prior written permission.
     49        1.1       cgd  *
     50        1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     51        1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     52        1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     53        1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     54        1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     55        1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     56        1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     57        1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     58        1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     59        1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     60        1.1       cgd  * SUCH DAMAGE.
     61        1.1       cgd  *
     62       1.32      fvdl  *	@(#)uipc_socket.c	8.6 (Berkeley) 5/2/95
     63        1.1       cgd  */
     64       1.59     lukem 
     65       1.59     lukem #include <sys/cdefs.h>
     66  1.177.4.4       riz __KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.177.4.4 2011/08/08 19:45:57 riz Exp $");
     67       1.64   thorpej 
     68       1.64   thorpej #include "opt_sock_counters.h"
     69       1.64   thorpej #include "opt_sosend_loan.h"
     70       1.81    martin #include "opt_mbuftrace.h"
     71       1.84     ragge #include "opt_somaxkva.h"
     72      1.167        ad #include "opt_multiprocessor.h"	/* XXX */
     73        1.1       cgd 
     74        1.9   mycroft #include <sys/param.h>
     75        1.9   mycroft #include <sys/systm.h>
     76        1.9   mycroft #include <sys/proc.h>
     77        1.9   mycroft #include <sys/file.h>
     78      1.142    dyoung #include <sys/filedesc.h>
     79      1.173    plunky #include <sys/kmem.h>
     80        1.9   mycroft #include <sys/mbuf.h>
     81        1.9   mycroft #include <sys/domain.h>
     82        1.9   mycroft #include <sys/kernel.h>
     83        1.9   mycroft #include <sys/protosw.h>
     84        1.9   mycroft #include <sys/socket.h>
     85        1.9   mycroft #include <sys/socketvar.h>
     86       1.21  christos #include <sys/signalvar.h>
     87        1.9   mycroft #include <sys/resourcevar.h>
     88      1.174     pooka #include <sys/uidinfo.h>
     89       1.72  jdolecek #include <sys/event.h>
     90       1.89  christos #include <sys/poll.h>
     91      1.118      elad #include <sys/kauth.h>
     92      1.136        ad #include <sys/mutex.h>
     93      1.136        ad #include <sys/condvar.h>
     94  1.177.4.4       riz #include <sys/kthread.h>
     95       1.37   thorpej 
     96       1.64   thorpej #include <uvm/uvm.h>
     97       1.64   thorpej 
     98       1.77   thorpej MALLOC_DEFINE(M_SOOPTS, "soopts", "socket options");
     99       1.77   thorpej MALLOC_DEFINE(M_SONAME, "soname", "socket name");
    100       1.37   thorpej 
    101      1.142    dyoung extern const struct fileops socketops;
    102      1.142    dyoung 
    103       1.54     lukem extern int	somaxconn;			/* patchable (XXX sysctl) */
    104       1.54     lukem int		somaxconn = SOMAXCONN;
    105      1.160        ad kmutex_t	*softnet_lock;
    106       1.49  jonathan 
    107       1.64   thorpej #ifdef SOSEND_COUNTERS
    108       1.64   thorpej #include <sys/device.h>
    109       1.64   thorpej 
    110      1.113   thorpej static struct evcnt sosend_loan_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    111       1.64   thorpej     NULL, "sosend", "loan big");
    112      1.113   thorpej static struct evcnt sosend_copy_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    113       1.64   thorpej     NULL, "sosend", "copy big");
    114      1.113   thorpej static struct evcnt sosend_copy_small = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    115       1.64   thorpej     NULL, "sosend", "copy small");
    116      1.113   thorpej static struct evcnt sosend_kvalimit = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    117       1.64   thorpej     NULL, "sosend", "kva limit");
    118       1.64   thorpej 
    119       1.64   thorpej #define	SOSEND_COUNTER_INCR(ev)		(ev)->ev_count++
    120       1.64   thorpej 
    121      1.101      matt EVCNT_ATTACH_STATIC(sosend_loan_big);
    122      1.101      matt EVCNT_ATTACH_STATIC(sosend_copy_big);
    123      1.101      matt EVCNT_ATTACH_STATIC(sosend_copy_small);
    124      1.101      matt EVCNT_ATTACH_STATIC(sosend_kvalimit);
    125       1.64   thorpej #else
    126       1.64   thorpej 
    127       1.64   thorpej #define	SOSEND_COUNTER_INCR(ev)		/* nothing */
    128       1.64   thorpej 
    129       1.64   thorpej #endif /* SOSEND_COUNTERS */
    130       1.64   thorpej 
    131      1.119      yamt static struct callback_entry sokva_reclaimerentry;
    132        1.1       cgd 
    133      1.167        ad #if defined(SOSEND_NO_LOAN) || defined(MULTIPROCESSOR)
    134      1.121      yamt int sock_loan_thresh = -1;
    135       1.71   thorpej #else
    136      1.121      yamt int sock_loan_thresh = 4096;
    137       1.65   thorpej #endif
    138       1.64   thorpej 
    139      1.136        ad static kmutex_t so_pendfree_lock;
    140  1.177.4.4       riz static struct mbuf *so_pendfree = NULL;
    141       1.64   thorpej 
    142       1.84     ragge #ifndef SOMAXKVA
    143       1.84     ragge #define	SOMAXKVA (16 * 1024 * 1024)
    144       1.84     ragge #endif
    145       1.84     ragge int somaxkva = SOMAXKVA;
    146      1.113   thorpej static int socurkva;
    147      1.136        ad static kcondvar_t socurkva_cv;
    148       1.64   thorpej 
    149       1.64   thorpej #define	SOCK_LOAN_CHUNK		65536
    150       1.64   thorpej 
    151  1.177.4.4       riz static void sopendfree_thread(void *);
    152  1.177.4.4       riz static kcondvar_t pendfree_thread_cv;
    153  1.177.4.4       riz static lwp_t *sopendfree_lwp;
    154       1.93      yamt 
    155      1.113   thorpej static vsize_t
    156      1.129      yamt sokvareserve(struct socket *so, vsize_t len)
    157       1.80      yamt {
    158       1.98  christos 	int error;
    159       1.80      yamt 
    160      1.136        ad 	mutex_enter(&so_pendfree_lock);
    161       1.80      yamt 	while (socurkva + len > somaxkva) {
    162       1.80      yamt 		SOSEND_COUNTER_INCR(&sosend_kvalimit);
    163      1.136        ad 		error = cv_wait_sig(&socurkva_cv, &so_pendfree_lock);
    164       1.98  christos 		if (error) {
    165       1.98  christos 			len = 0;
    166       1.98  christos 			break;
    167       1.98  christos 		}
    168       1.80      yamt 	}
    169       1.93      yamt 	socurkva += len;
    170      1.136        ad 	mutex_exit(&so_pendfree_lock);
    171       1.98  christos 	return len;
    172       1.95      yamt }
    173       1.95      yamt 
    174      1.113   thorpej static void
    175       1.95      yamt sokvaunreserve(vsize_t len)
    176       1.95      yamt {
    177       1.95      yamt 
    178      1.136        ad 	mutex_enter(&so_pendfree_lock);
    179       1.95      yamt 	socurkva -= len;
    180      1.136        ad 	cv_broadcast(&socurkva_cv);
    181      1.136        ad 	mutex_exit(&so_pendfree_lock);
    182       1.95      yamt }
    183       1.95      yamt 
    184       1.95      yamt /*
    185       1.95      yamt  * sokvaalloc: allocate kva for loan.
    186       1.95      yamt  */
    187       1.95      yamt 
    188       1.95      yamt vaddr_t
    189       1.95      yamt sokvaalloc(vsize_t len, struct socket *so)
    190       1.95      yamt {
    191       1.95      yamt 	vaddr_t lva;
    192       1.95      yamt 
    193       1.95      yamt 	/*
    194       1.95      yamt 	 * reserve kva.
    195       1.95      yamt 	 */
    196       1.95      yamt 
    197       1.98  christos 	if (sokvareserve(so, len) == 0)
    198       1.98  christos 		return 0;
    199       1.93      yamt 
    200       1.93      yamt 	/*
    201       1.93      yamt 	 * allocate kva.
    202       1.93      yamt 	 */
    203       1.80      yamt 
    204      1.109      yamt 	lva = uvm_km_alloc(kernel_map, len, 0, UVM_KMF_VAONLY | UVM_KMF_WAITVA);
    205       1.95      yamt 	if (lva == 0) {
    206       1.95      yamt 		sokvaunreserve(len);
    207       1.80      yamt 		return (0);
    208       1.95      yamt 	}
    209       1.80      yamt 
    210       1.80      yamt 	return lva;
    211       1.80      yamt }
    212       1.80      yamt 
    213       1.93      yamt /*
    214       1.93      yamt  * sokvafree: free kva for loan.
    215       1.93      yamt  */
    216       1.93      yamt 
    217       1.80      yamt void
    218       1.80      yamt sokvafree(vaddr_t sva, vsize_t len)
    219       1.80      yamt {
    220       1.93      yamt 
    221       1.93      yamt 	/*
    222       1.93      yamt 	 * free kva.
    223       1.93      yamt 	 */
    224       1.80      yamt 
    225      1.109      yamt 	uvm_km_free(kernel_map, sva, len, UVM_KMF_VAONLY);
    226       1.93      yamt 
    227       1.93      yamt 	/*
    228       1.93      yamt 	 * unreserve kva.
    229       1.93      yamt 	 */
    230       1.93      yamt 
    231       1.95      yamt 	sokvaunreserve(len);
    232       1.80      yamt }
    233       1.80      yamt 
    234       1.64   thorpej static void
    235      1.134  christos sodoloanfree(struct vm_page **pgs, void *buf, size_t size)
    236       1.64   thorpej {
    237      1.156      yamt 	vaddr_t sva, eva;
    238       1.64   thorpej 	vsize_t len;
    239      1.156      yamt 	int npgs;
    240      1.156      yamt 
    241      1.156      yamt 	KASSERT(pgs != NULL);
    242       1.64   thorpej 
    243       1.64   thorpej 	eva = round_page((vaddr_t) buf + size);
    244       1.64   thorpej 	sva = trunc_page((vaddr_t) buf);
    245       1.64   thorpej 	len = eva - sva;
    246       1.64   thorpej 	npgs = len >> PAGE_SHIFT;
    247       1.64   thorpej 
    248       1.64   thorpej 	pmap_kremove(sva, len);
    249       1.64   thorpej 	pmap_update(pmap_kernel());
    250       1.64   thorpej 	uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);
    251       1.80      yamt 	sokvafree(sva, len);
    252       1.64   thorpej }
    253       1.64   thorpej 
    254       1.93      yamt /*
    255  1.177.4.4       riz  * sopendfree_thread: free mbufs on "pendfree" list.
    256      1.136        ad  * unlock and relock so_pendfree_lock when freeing mbufs.
    257       1.93      yamt  */
    258       1.93      yamt 
    259  1.177.4.4       riz static void
    260  1.177.4.4       riz sopendfree_thread(void *v)
    261       1.93      yamt {
    262      1.137        ad 	struct mbuf *m, *next;
    263  1.177.4.4       riz 	size_t rv;
    264       1.64   thorpej 
    265  1.177.4.4       riz 	mutex_enter(&so_pendfree_lock);
    266       1.93      yamt 
    267  1.177.4.4       riz 	for (;;) {
    268  1.177.4.4       riz 		rv = 0;
    269  1.177.4.4       riz 		while (so_pendfree != NULL) {
    270  1.177.4.4       riz 			m = so_pendfree;
    271  1.177.4.4       riz 			so_pendfree = NULL;
    272  1.177.4.4       riz 			mutex_exit(&so_pendfree_lock);
    273  1.177.4.4       riz 
    274  1.177.4.4       riz 			for (; m != NULL; m = next) {
    275  1.177.4.4       riz 				next = m->m_next;
    276  1.177.4.4       riz 				KASSERT((~m->m_flags & (M_EXT|M_EXT_PAGES)) == 0);
    277  1.177.4.4       riz 				KASSERT(m->m_ext.ext_refcnt == 0);
    278  1.177.4.4       riz 
    279  1.177.4.4       riz 				rv += m->m_ext.ext_size;
    280  1.177.4.4       riz 				sodoloanfree(m->m_ext.ext_pgs, m->m_ext.ext_buf,
    281  1.177.4.4       riz 				    m->m_ext.ext_size);
    282  1.177.4.4       riz 				pool_cache_put(mb_cache, m);
    283  1.177.4.4       riz 			}
    284       1.93      yamt 
    285  1.177.4.4       riz 			mutex_enter(&so_pendfree_lock);
    286       1.93      yamt 		}
    287  1.177.4.4       riz 		if (rv)
    288  1.177.4.4       riz 			cv_broadcast(&socurkva_cv);
    289  1.177.4.4       riz 		cv_wait(&pendfree_thread_cv, &so_pendfree_lock);
    290       1.64   thorpej 	}
    291  1.177.4.4       riz 	panic("sopendfree_thread");
    292  1.177.4.4       riz 	/* NOTREACHED */
    293       1.64   thorpej }
    294       1.64   thorpej 
    295       1.80      yamt void
    296      1.134  christos soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)
    297       1.64   thorpej {
    298       1.64   thorpej 
    299      1.156      yamt 	KASSERT(m != NULL);
    300       1.64   thorpej 
    301       1.93      yamt 	/*
    302       1.93      yamt 	 * postpone freeing mbuf.
    303       1.93      yamt 	 *
    304       1.93      yamt 	 * we can't do it in interrupt context
    305       1.93      yamt 	 * because we need to put kva back to kernel_map.
    306       1.93      yamt 	 */
    307       1.93      yamt 
    308      1.136        ad 	mutex_enter(&so_pendfree_lock);
    309       1.92      yamt 	m->m_next = so_pendfree;
    310       1.92      yamt 	so_pendfree = m;
    311  1.177.4.4       riz 	cv_signal(&pendfree_thread_cv);
    312      1.136        ad 	mutex_exit(&so_pendfree_lock);
    313       1.64   thorpej }
    314       1.64   thorpej 
    315       1.64   thorpej static long
    316       1.64   thorpej sosend_loan(struct socket *so, struct uio *uio, struct mbuf *m, long space)
    317       1.64   thorpej {
    318       1.64   thorpej 	struct iovec *iov = uio->uio_iov;
    319       1.64   thorpej 	vaddr_t sva, eva;
    320       1.64   thorpej 	vsize_t len;
    321      1.156      yamt 	vaddr_t lva;
    322      1.156      yamt 	int npgs, error;
    323      1.156      yamt 	vaddr_t va;
    324      1.156      yamt 	int i;
    325       1.64   thorpej 
    326      1.116      yamt 	if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))
    327       1.64   thorpej 		return (0);
    328       1.64   thorpej 
    329       1.64   thorpej 	if (iov->iov_len < (size_t) space)
    330       1.64   thorpej 		space = iov->iov_len;
    331       1.64   thorpej 	if (space > SOCK_LOAN_CHUNK)
    332       1.64   thorpej 		space = SOCK_LOAN_CHUNK;
    333       1.64   thorpej 
    334       1.64   thorpej 	eva = round_page((vaddr_t) iov->iov_base + space);
    335       1.64   thorpej 	sva = trunc_page((vaddr_t) iov->iov_base);
    336       1.64   thorpej 	len = eva - sva;
    337       1.64   thorpej 	npgs = len >> PAGE_SHIFT;
    338       1.64   thorpej 
    339       1.79   thorpej 	KASSERT(npgs <= M_EXT_MAXPAGES);
    340       1.79   thorpej 
    341       1.80      yamt 	lva = sokvaalloc(len, so);
    342       1.64   thorpej 	if (lva == 0)
    343       1.80      yamt 		return 0;
    344       1.64   thorpej 
    345      1.116      yamt 	error = uvm_loan(&uio->uio_vmspace->vm_map, sva, len,
    346       1.79   thorpej 	    m->m_ext.ext_pgs, UVM_LOAN_TOPAGE);
    347       1.64   thorpej 	if (error) {
    348       1.80      yamt 		sokvafree(lva, len);
    349       1.64   thorpej 		return (0);
    350       1.64   thorpej 	}
    351       1.64   thorpej 
    352       1.64   thorpej 	for (i = 0, va = lva; i < npgs; i++, va += PAGE_SIZE)
    353       1.79   thorpej 		pmap_kenter_pa(va, VM_PAGE_TO_PHYS(m->m_ext.ext_pgs[i]),
    354       1.79   thorpej 		    VM_PROT_READ);
    355       1.64   thorpej 	pmap_update(pmap_kernel());
    356       1.64   thorpej 
    357       1.64   thorpej 	lva += (vaddr_t) iov->iov_base & PAGE_MASK;
    358       1.64   thorpej 
    359      1.134  christos 	MEXTADD(m, (void *) lva, space, M_MBUF, soloanfree, so);
    360       1.79   thorpej 	m->m_flags |= M_EXT_PAGES | M_EXT_ROMAP;
    361       1.64   thorpej 
    362       1.64   thorpej 	uio->uio_resid -= space;
    363       1.64   thorpej 	/* uio_offset not updated, not set/used for write(2) */
    364      1.134  christos 	uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + space;
    365       1.64   thorpej 	uio->uio_iov->iov_len -= space;
    366       1.64   thorpej 	if (uio->uio_iov->iov_len == 0) {
    367       1.64   thorpej 		uio->uio_iov++;
    368       1.64   thorpej 		uio->uio_iovcnt--;
    369       1.64   thorpej 	}
    370       1.64   thorpej 
    371       1.64   thorpej 	return (space);
    372       1.64   thorpej }
    373       1.64   thorpej 
    374      1.119      yamt static int
    375      1.129      yamt sokva_reclaim_callback(struct callback_entry *ce, void *obj, void *arg)
    376      1.119      yamt {
    377      1.119      yamt 
    378      1.119      yamt 	KASSERT(ce == &sokva_reclaimerentry);
    379      1.119      yamt 	KASSERT(obj == NULL);
    380      1.119      yamt 
    381      1.119      yamt 	if (!vm_map_starved_p(kernel_map)) {
    382      1.119      yamt 		return CALLBACK_CHAIN_ABORT;
    383      1.119      yamt 	}
    384      1.119      yamt 	return CALLBACK_CHAIN_CONTINUE;
    385      1.119      yamt }
    386      1.119      yamt 
    387      1.142    dyoung struct mbuf *
    388      1.147    dyoung getsombuf(struct socket *so, int type)
    389      1.142    dyoung {
    390      1.142    dyoung 	struct mbuf *m;
    391      1.142    dyoung 
    392      1.147    dyoung 	m = m_get(M_WAIT, type);
    393      1.142    dyoung 	MCLAIM(m, so->so_mowner);
    394      1.142    dyoung 	return m;
    395      1.142    dyoung }
    396      1.142    dyoung 
    397      1.119      yamt void
    398  1.177.4.4       riz soinit()
    399      1.119      yamt {
    400      1.148        ad 	mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);
    401      1.160        ad 	softnet_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
    402      1.136        ad 	cv_init(&socurkva_cv, "sokva");
    403  1.177.4.4       riz 	cv_init(&pendfree_thread_cv, "sopendfr");
    404      1.166        ad 	soinit2();
    405      1.136        ad 
    406  1.177.4.4       riz 
    407      1.119      yamt 	/* Set the initial adjusted socket buffer size. */
    408      1.119      yamt 	if (sb_max_set(sb_max))
    409      1.119      yamt 		panic("bad initial sb_max value: %lu", sb_max);
    410      1.119      yamt 
    411      1.119      yamt 	callback_register(&vm_map_to_kernel(kernel_map)->vmk_reclaim_callback,
    412      1.119      yamt 	    &sokva_reclaimerentry, NULL, sokva_reclaim_callback);
    413      1.119      yamt }
    414      1.119      yamt 
    415  1.177.4.4       riz void
    416  1.177.4.4       riz soinit1(void)
    417  1.177.4.4       riz {
    418  1.177.4.4       riz 	int error = kthread_create(PRI_NONE, KTHREAD_MPSAFE, NULL,
    419  1.177.4.4       riz 	    sopendfree_thread, NULL, &sopendfree_lwp, "sopendfree");
    420  1.177.4.4       riz 	if (error)
    421  1.177.4.4       riz 		panic("soinit1 %d", error);
    422  1.177.4.4       riz }
    423  1.177.4.4       riz 
    424        1.1       cgd /*
    425        1.1       cgd  * Socket operation routines.
    426        1.1       cgd  * These routines are called by the routines in
    427        1.1       cgd  * sys_socket.c or from a system process, and
    428        1.1       cgd  * implement the semantics of socket operations by
    429        1.1       cgd  * switching out to the protocol specific routines.
    430        1.1       cgd  */
    431        1.1       cgd /*ARGSUSED*/
    432        1.3    andrew int
    433      1.160        ad socreate(int dom, struct socket **aso, int type, int proto, struct lwp *l,
    434      1.160        ad 	 struct socket *lockso)
    435        1.1       cgd {
    436       1.99      matt 	const struct protosw	*prp;
    437       1.54     lukem 	struct socket	*so;
    438      1.115      yamt 	uid_t		uid;
    439      1.160        ad 	int		error;
    440      1.160        ad 	kmutex_t	*lock;
    441        1.1       cgd 
    442      1.132      elad 	error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,
    443      1.132      elad 	    KAUTH_REQ_NETWORK_SOCKET_OPEN, KAUTH_ARG(dom), KAUTH_ARG(type),
    444      1.132      elad 	    KAUTH_ARG(proto));
    445      1.140    dyoung 	if (error != 0)
    446      1.140    dyoung 		return error;
    447      1.127      elad 
    448        1.1       cgd 	if (proto)
    449        1.1       cgd 		prp = pffindproto(dom, proto, type);
    450        1.1       cgd 	else
    451        1.1       cgd 		prp = pffindtype(dom, type);
    452      1.140    dyoung 	if (prp == NULL) {
    453      1.120  ginsbach 		/* no support for domain */
    454      1.120  ginsbach 		if (pffinddomain(dom) == 0)
    455      1.140    dyoung 			return EAFNOSUPPORT;
    456      1.120  ginsbach 		/* no support for socket type */
    457      1.120  ginsbach 		if (proto == 0 && type != 0)
    458      1.140    dyoung 			return EPROTOTYPE;
    459      1.140    dyoung 		return EPROTONOSUPPORT;
    460      1.120  ginsbach 	}
    461      1.140    dyoung 	if (prp->pr_usrreq == NULL)
    462      1.140    dyoung 		return EPROTONOSUPPORT;
    463        1.1       cgd 	if (prp->pr_type != type)
    464      1.140    dyoung 		return EPROTOTYPE;
    465      1.160        ad 
    466      1.160        ad 	so = soget(true);
    467        1.1       cgd 	so->so_type = type;
    468        1.1       cgd 	so->so_proto = prp;
    469       1.33      matt 	so->so_send = sosend;
    470       1.33      matt 	so->so_receive = soreceive;
    471       1.78      matt #ifdef MBUFTRACE
    472       1.78      matt 	so->so_rcv.sb_mowner = &prp->pr_domain->dom_mowner;
    473       1.78      matt 	so->so_snd.sb_mowner = &prp->pr_domain->dom_mowner;
    474       1.78      matt 	so->so_mowner = &prp->pr_domain->dom_mowner;
    475       1.78      matt #endif
    476      1.138     rmind 	uid = kauth_cred_geteuid(l->l_cred);
    477      1.115      yamt 	so->so_uidinfo = uid_find(uid);
    478      1.168      yamt 	so->so_egid = kauth_cred_getegid(l->l_cred);
    479      1.168      yamt 	so->so_cpid = l->l_proc->p_pid;
    480      1.160        ad 	if (lockso != NULL) {
    481      1.160        ad 		/* Caller wants us to share a lock. */
    482      1.160        ad 		lock = lockso->so_lock;
    483      1.160        ad 		so->so_lock = lock;
    484      1.160        ad 		mutex_obj_hold(lock);
    485      1.160        ad 		mutex_enter(lock);
    486      1.160        ad 	} else {
    487      1.160        ad 		/* Lock assigned and taken during PRU_ATTACH. */
    488      1.160        ad 	}
    489      1.140    dyoung 	error = (*prp->pr_usrreq)(so, PRU_ATTACH, NULL,
    490      1.140    dyoung 	    (struct mbuf *)(long)proto, NULL, l);
    491      1.160        ad 	KASSERT(solocked(so));
    492      1.140    dyoung 	if (error != 0) {
    493        1.1       cgd 		so->so_state |= SS_NOFDREF;
    494        1.1       cgd 		sofree(so);
    495      1.140    dyoung 		return error;
    496        1.1       cgd 	}
    497      1.160        ad 	sounlock(so);
    498        1.1       cgd 	*aso = so;
    499      1.140    dyoung 	return 0;
    500        1.1       cgd }
    501        1.1       cgd 
    502      1.142    dyoung /* On success, write file descriptor to fdout and return zero.  On
    503      1.142    dyoung  * failure, return non-zero; *fdout will be undefined.
    504      1.142    dyoung  */
    505      1.142    dyoung int
    506      1.142    dyoung fsocreate(int domain, struct socket **sop, int type, int protocol,
    507      1.142    dyoung     struct lwp *l, int *fdout)
    508      1.142    dyoung {
    509      1.142    dyoung 	struct socket	*so;
    510      1.142    dyoung 	struct file	*fp;
    511      1.142    dyoung 	int		fd, error;
    512      1.142    dyoung 
    513      1.155        ad 	if ((error = fd_allocfile(&fp, &fd)) != 0)
    514      1.142    dyoung 		return (error);
    515      1.142    dyoung 	fp->f_flag = FREAD|FWRITE;
    516      1.142    dyoung 	fp->f_type = DTYPE_SOCKET;
    517      1.142    dyoung 	fp->f_ops = &socketops;
    518      1.160        ad 	error = socreate(domain, &so, type, protocol, l, NULL);
    519      1.142    dyoung 	if (error != 0) {
    520      1.155        ad 		fd_abort(curproc, fp, fd);
    521      1.142    dyoung 	} else {
    522      1.142    dyoung 		if (sop != NULL)
    523      1.142    dyoung 			*sop = so;
    524      1.142    dyoung 		fp->f_data = so;
    525      1.155        ad 		fd_affix(curproc, fp, fd);
    526      1.142    dyoung 		*fdout = fd;
    527      1.142    dyoung 	}
    528      1.142    dyoung 	return error;
    529      1.142    dyoung }
    530      1.142    dyoung 
    531        1.3    andrew int
    532      1.114  christos sobind(struct socket *so, struct mbuf *nam, struct lwp *l)
    533        1.1       cgd {
    534      1.160        ad 	int	error;
    535        1.1       cgd 
    536      1.160        ad 	solock(so);
    537      1.140    dyoung 	error = (*so->so_proto->pr_usrreq)(so, PRU_BIND, NULL, nam, NULL, l);
    538      1.160        ad 	sounlock(so);
    539      1.140    dyoung 	return error;
    540        1.1       cgd }
    541        1.1       cgd 
    542        1.3    andrew int
    543      1.150      elad solisten(struct socket *so, int backlog, struct lwp *l)
    544        1.1       cgd {
    545      1.160        ad 	int	error;
    546        1.1       cgd 
    547      1.160        ad 	solock(so);
    548      1.158        ad 	if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
    549      1.163        ad 	    SS_ISDISCONNECTING)) != 0) {
    550      1.163        ad 	    	sounlock(so);
    551      1.158        ad 		return (EOPNOTSUPP);
    552      1.163        ad 	}
    553      1.140    dyoung 	error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, NULL,
    554      1.150      elad 	    NULL, NULL, l);
    555      1.140    dyoung 	if (error != 0) {
    556      1.160        ad 		sounlock(so);
    557      1.140    dyoung 		return error;
    558        1.1       cgd 	}
    559       1.63      matt 	if (TAILQ_EMPTY(&so->so_q))
    560        1.1       cgd 		so->so_options |= SO_ACCEPTCONN;
    561        1.1       cgd 	if (backlog < 0)
    562        1.1       cgd 		backlog = 0;
    563       1.49  jonathan 	so->so_qlimit = min(backlog, somaxconn);
    564      1.160        ad 	sounlock(so);
    565      1.140    dyoung 	return 0;
    566        1.1       cgd }
    567        1.1       cgd 
    568       1.21  christos void
    569       1.54     lukem sofree(struct socket *so)
    570        1.1       cgd {
    571      1.161        ad 	u_int refs;
    572        1.1       cgd 
    573      1.160        ad 	KASSERT(solocked(so));
    574      1.160        ad 
    575      1.160        ad 	if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0) {
    576      1.160        ad 		sounlock(so);
    577        1.1       cgd 		return;
    578      1.160        ad 	}
    579       1.43   mycroft 	if (so->so_head) {
    580       1.43   mycroft 		/*
    581       1.43   mycroft 		 * We must not decommission a socket that's on the accept(2)
    582       1.43   mycroft 		 * queue.  If we do, then accept(2) may hang after select(2)
    583       1.43   mycroft 		 * indicated that the listening socket was ready.
    584       1.43   mycroft 		 */
    585      1.160        ad 		if (!soqremque(so, 0)) {
    586      1.160        ad 			sounlock(so);
    587       1.43   mycroft 			return;
    588      1.160        ad 		}
    589       1.43   mycroft 	}
    590       1.98  christos 	if (so->so_rcv.sb_hiwat)
    591      1.110  christos 		(void)chgsbsize(so->so_uidinfo, &so->so_rcv.sb_hiwat, 0,
    592       1.98  christos 		    RLIM_INFINITY);
    593       1.98  christos 	if (so->so_snd.sb_hiwat)
    594      1.110  christos 		(void)chgsbsize(so->so_uidinfo, &so->so_snd.sb_hiwat, 0,
    595       1.98  christos 		    RLIM_INFINITY);
    596       1.98  christos 	sbrelease(&so->so_snd, so);
    597      1.160        ad 	KASSERT(!cv_has_waiters(&so->so_cv));
    598      1.160        ad 	KASSERT(!cv_has_waiters(&so->so_rcv.sb_cv));
    599      1.160        ad 	KASSERT(!cv_has_waiters(&so->so_snd.sb_cv));
    600        1.1       cgd 	sorflush(so);
    601      1.161        ad 	refs = so->so_aborting;	/* XXX */
    602      1.177        ad 	/* Remove acccept filter if one is present. */
    603      1.170       tls 	if (so->so_accf != NULL)
    604      1.177        ad 		(void)accept_filt_clear(so);
    605      1.160        ad 	sounlock(so);
    606      1.161        ad 	if (refs == 0)		/* XXX */
    607      1.161        ad 		soput(so);
    608        1.1       cgd }
    609        1.1       cgd 
    610        1.1       cgd /*
    611        1.1       cgd  * Close a socket on last file table reference removal.
    612        1.1       cgd  * Initiate disconnect if connected.
    613        1.1       cgd  * Free socket when disconnect complete.
    614        1.1       cgd  */
    615        1.3    andrew int
    616       1.54     lukem soclose(struct socket *so)
    617        1.1       cgd {
    618       1.54     lukem 	struct socket	*so2;
    619      1.160        ad 	int		error;
    620      1.160        ad 	int		error2;
    621        1.1       cgd 
    622       1.54     lukem 	error = 0;
    623      1.160        ad 	solock(so);
    624        1.1       cgd 	if (so->so_options & SO_ACCEPTCONN) {
    625      1.172        ad 		for (;;) {
    626      1.172        ad 			if ((so2 = TAILQ_FIRST(&so->so_q0)) != 0) {
    627      1.160        ad 				KASSERT(solocked2(so, so2));
    628      1.160        ad 				(void) soqremque(so2, 0);
    629      1.160        ad 				/* soabort drops the lock. */
    630      1.160        ad 				(void) soabort(so2);
    631      1.160        ad 				solock(so);
    632      1.172        ad 				continue;
    633      1.160        ad 			}
    634      1.172        ad 			if ((so2 = TAILQ_FIRST(&so->so_q)) != 0) {
    635      1.160        ad 				KASSERT(solocked2(so, so2));
    636      1.160        ad 				(void) soqremque(so2, 1);
    637      1.160        ad 				/* soabort drops the lock. */
    638      1.160        ad 				(void) soabort(so2);
    639      1.160        ad 				solock(so);
    640      1.172        ad 				continue;
    641      1.160        ad 			}
    642      1.172        ad 			break;
    643      1.172        ad 		}
    644        1.1       cgd 	}
    645        1.1       cgd 	if (so->so_pcb == 0)
    646        1.1       cgd 		goto discard;
    647        1.1       cgd 	if (so->so_state & SS_ISCONNECTED) {
    648        1.1       cgd 		if ((so->so_state & SS_ISDISCONNECTING) == 0) {
    649        1.1       cgd 			error = sodisconnect(so);
    650        1.1       cgd 			if (error)
    651        1.1       cgd 				goto drop;
    652        1.1       cgd 		}
    653        1.1       cgd 		if (so->so_options & SO_LINGER) {
    654      1.151        ad 			if ((so->so_state & SS_ISDISCONNECTING) && so->so_nbio)
    655        1.1       cgd 				goto drop;
    656       1.21  christos 			while (so->so_state & SS_ISCONNECTED) {
    657  1.177.4.1       snj 				error = sowait(so, true, so->so_linger * hz);
    658       1.21  christos 				if (error)
    659        1.1       cgd 					break;
    660       1.21  christos 			}
    661        1.1       cgd 		}
    662        1.1       cgd 	}
    663       1.54     lukem  drop:
    664        1.1       cgd 	if (so->so_pcb) {
    665      1.160        ad 		error2 = (*so->so_proto->pr_usrreq)(so, PRU_DETACH,
    666      1.140    dyoung 		    NULL, NULL, NULL, NULL);
    667        1.1       cgd 		if (error == 0)
    668        1.1       cgd 			error = error2;
    669        1.1       cgd 	}
    670       1.54     lukem  discard:
    671        1.1       cgd 	if (so->so_state & SS_NOFDREF)
    672        1.1       cgd 		panic("soclose: NOFDREF");
    673        1.1       cgd 	so->so_state |= SS_NOFDREF;
    674        1.1       cgd 	sofree(so);
    675        1.1       cgd 	return (error);
    676        1.1       cgd }
    677        1.1       cgd 
    678        1.1       cgd /*
    679      1.160        ad  * Must be called with the socket locked..  Will return with it unlocked.
    680        1.1       cgd  */
    681        1.3    andrew int
    682       1.54     lukem soabort(struct socket *so)
    683        1.1       cgd {
    684      1.161        ad 	u_int refs;
    685      1.139      yamt 	int error;
    686      1.160        ad 
    687      1.160        ad 	KASSERT(solocked(so));
    688      1.160        ad 	KASSERT(so->so_head == NULL);
    689        1.1       cgd 
    690      1.161        ad 	so->so_aborting++;		/* XXX */
    691      1.140    dyoung 	error = (*so->so_proto->pr_usrreq)(so, PRU_ABORT, NULL,
    692      1.140    dyoung 	    NULL, NULL, NULL);
    693      1.161        ad 	refs = --so->so_aborting;	/* XXX */
    694      1.164  drochner 	if (error || (refs == 0)) {
    695      1.139      yamt 		sofree(so);
    696      1.160        ad 	} else {
    697      1.160        ad 		sounlock(so);
    698      1.139      yamt 	}
    699      1.139      yamt 	return error;
    700        1.1       cgd }
    701        1.1       cgd 
    702        1.3    andrew int
    703       1.54     lukem soaccept(struct socket *so, struct mbuf *nam)
    704        1.1       cgd {
    705      1.160        ad 	int	error;
    706      1.160        ad 
    707      1.160        ad 	KASSERT(solocked(so));
    708        1.1       cgd 
    709       1.54     lukem 	error = 0;
    710        1.1       cgd 	if ((so->so_state & SS_NOFDREF) == 0)
    711        1.1       cgd 		panic("soaccept: !NOFDREF");
    712        1.1       cgd 	so->so_state &= ~SS_NOFDREF;
    713       1.55   thorpej 	if ((so->so_state & SS_ISDISCONNECTED) == 0 ||
    714       1.55   thorpej 	    (so->so_proto->pr_flags & PR_ABRTACPTDIS) == 0)
    715       1.41   mycroft 		error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,
    716      1.140    dyoung 		    NULL, nam, NULL, NULL);
    717       1.41   mycroft 	else
    718       1.53    itojun 		error = ECONNABORTED;
    719       1.52    itojun 
    720        1.1       cgd 	return (error);
    721        1.1       cgd }
    722        1.1       cgd 
    723        1.3    andrew int
    724      1.114  christos soconnect(struct socket *so, struct mbuf *nam, struct lwp *l)
    725        1.1       cgd {
    726      1.160        ad 	int		error;
    727      1.160        ad 
    728      1.160        ad 	KASSERT(solocked(so));
    729        1.1       cgd 
    730        1.1       cgd 	if (so->so_options & SO_ACCEPTCONN)
    731        1.1       cgd 		return (EOPNOTSUPP);
    732        1.1       cgd 	/*
    733        1.1       cgd 	 * If protocol is connection-based, can only connect once.
    734        1.1       cgd 	 * Otherwise, if connected, try to disconnect first.
    735        1.1       cgd 	 * This allows user to disconnect by connecting to, e.g.,
    736        1.1       cgd 	 * a null address.
    737        1.1       cgd 	 */
    738        1.1       cgd 	if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
    739        1.1       cgd 	    ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
    740        1.1       cgd 	    (error = sodisconnect(so))))
    741        1.1       cgd 		error = EISCONN;
    742        1.1       cgd 	else
    743        1.1       cgd 		error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,
    744      1.140    dyoung 		    NULL, nam, NULL, l);
    745        1.1       cgd 	return (error);
    746        1.1       cgd }
    747        1.1       cgd 
    748        1.3    andrew int
    749       1.54     lukem soconnect2(struct socket *so1, struct socket *so2)
    750        1.1       cgd {
    751      1.160        ad 	int	error;
    752      1.160        ad 
    753      1.160        ad 	KASSERT(solocked2(so1, so2));
    754        1.1       cgd 
    755       1.22   mycroft 	error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,
    756      1.140    dyoung 	    NULL, (struct mbuf *)so2, NULL, NULL);
    757        1.1       cgd 	return (error);
    758        1.1       cgd }
    759        1.1       cgd 
    760        1.3    andrew int
    761       1.54     lukem sodisconnect(struct socket *so)
    762        1.1       cgd {
    763      1.160        ad 	int	error;
    764      1.160        ad 
    765      1.160        ad 	KASSERT(solocked(so));
    766        1.1       cgd 
    767        1.1       cgd 	if ((so->so_state & SS_ISCONNECTED) == 0) {
    768        1.1       cgd 		error = ENOTCONN;
    769      1.160        ad 	} else if (so->so_state & SS_ISDISCONNECTING) {
    770        1.1       cgd 		error = EALREADY;
    771      1.160        ad 	} else {
    772      1.160        ad 		error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
    773      1.160        ad 		    NULL, NULL, NULL, NULL);
    774        1.1       cgd 	}
    775        1.1       cgd 	return (error);
    776        1.1       cgd }
    777        1.1       cgd 
    778       1.15   mycroft #define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
    779        1.1       cgd /*
    780        1.1       cgd  * Send on a socket.
    781        1.1       cgd  * If send must go all at once and message is larger than
    782        1.1       cgd  * send buffering, then hard error.
    783        1.1       cgd  * Lock against other senders.
    784        1.1       cgd  * If must go all at once and not enough room now, then
    785        1.1       cgd  * inform user that this would block and do nothing.
    786        1.1       cgd  * Otherwise, if nonblocking, send as much as possible.
    787        1.1       cgd  * The data to be sent is described by "uio" if nonzero,
    788        1.1       cgd  * otherwise by the mbuf chain "top" (which must be null
    789        1.1       cgd  * if uio is not).  Data provided in mbuf chain must be small
    790        1.1       cgd  * enough to send all at once.
    791        1.1       cgd  *
    792        1.1       cgd  * Returns nonzero on error, timeout or signal; callers
    793        1.1       cgd  * must check for short counts if EINTR/ERESTART are returned.
    794        1.1       cgd  * Data and control buffers are freed on return.
    795        1.1       cgd  */
    796        1.3    andrew int
    797       1.54     lukem sosend(struct socket *so, struct mbuf *addr, struct uio *uio, struct mbuf *top,
    798      1.114  christos 	struct mbuf *control, int flags, struct lwp *l)
    799        1.1       cgd {
    800       1.54     lukem 	struct mbuf	**mp, *m;
    801      1.114  christos 	struct proc	*p;
    802       1.58  jdolecek 	long		space, len, resid, clen, mlen;
    803       1.58  jdolecek 	int		error, s, dontroute, atomic;
    804       1.54     lukem 
    805      1.114  christos 	p = l->l_proc;
    806      1.160        ad 	clen = 0;
    807       1.64   thorpej 
    808      1.160        ad 	/*
    809      1.160        ad 	 * solock() provides atomicity of access.  splsoftnet() prevents
    810      1.160        ad 	 * protocol processing soft interrupts from interrupting us and
    811      1.160        ad 	 * blocking (expensive).
    812      1.160        ad 	 */
    813      1.160        ad 	s = splsoftnet();
    814      1.160        ad 	solock(so);
    815       1.54     lukem 	atomic = sosendallatonce(so) || top;
    816        1.1       cgd 	if (uio)
    817        1.1       cgd 		resid = uio->uio_resid;
    818        1.1       cgd 	else
    819        1.1       cgd 		resid = top->m_pkthdr.len;
    820        1.7       cgd 	/*
    821        1.7       cgd 	 * In theory resid should be unsigned.
    822        1.7       cgd 	 * However, space must be signed, as it might be less than 0
    823        1.7       cgd 	 * if we over-committed, and we must use a signed comparison
    824        1.7       cgd 	 * of space and resid.  On the other hand, a negative resid
    825        1.7       cgd 	 * causes us to loop sending 0-length segments to the protocol.
    826        1.7       cgd 	 */
    827       1.29   mycroft 	if (resid < 0) {
    828       1.29   mycroft 		error = EINVAL;
    829       1.29   mycroft 		goto out;
    830       1.29   mycroft 	}
    831        1.1       cgd 	dontroute =
    832        1.1       cgd 	    (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
    833        1.1       cgd 	    (so->so_proto->pr_flags & PR_ATOMIC);
    834      1.165  christos 	l->l_ru.ru_msgsnd++;
    835        1.1       cgd 	if (control)
    836        1.1       cgd 		clen = control->m_len;
    837       1.54     lukem  restart:
    838       1.21  christos 	if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
    839        1.1       cgd 		goto out;
    840        1.1       cgd 	do {
    841      1.160        ad 		if (so->so_state & SS_CANTSENDMORE) {
    842      1.160        ad 			error = EPIPE;
    843      1.160        ad 			goto release;
    844      1.160        ad 		}
    845       1.48   thorpej 		if (so->so_error) {
    846       1.48   thorpej 			error = so->so_error;
    847       1.48   thorpej 			so->so_error = 0;
    848       1.48   thorpej 			goto release;
    849       1.48   thorpej 		}
    850        1.1       cgd 		if ((so->so_state & SS_ISCONNECTED) == 0) {
    851        1.1       cgd 			if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
    852        1.1       cgd 				if ((so->so_state & SS_ISCONFIRMING) == 0 &&
    853      1.160        ad 				    !(resid == 0 && clen != 0)) {
    854      1.160        ad 					error = ENOTCONN;
    855      1.160        ad 					goto release;
    856      1.160        ad 				}
    857      1.160        ad 			} else if (addr == 0) {
    858      1.160        ad 				error = EDESTADDRREQ;
    859      1.160        ad 				goto release;
    860      1.160        ad 			}
    861        1.1       cgd 		}
    862        1.1       cgd 		space = sbspace(&so->so_snd);
    863        1.1       cgd 		if (flags & MSG_OOB)
    864        1.1       cgd 			space += 1024;
    865       1.21  christos 		if ((atomic && resid > so->so_snd.sb_hiwat) ||
    866      1.160        ad 		    clen > so->so_snd.sb_hiwat) {
    867      1.160        ad 			error = EMSGSIZE;
    868      1.160        ad 			goto release;
    869      1.160        ad 		}
    870       1.96   mycroft 		if (space < resid + clen &&
    871        1.1       cgd 		    (atomic || space < so->so_snd.sb_lowat || space < clen)) {
    872      1.160        ad 			if (so->so_nbio) {
    873      1.160        ad 				error = EWOULDBLOCK;
    874      1.160        ad 				goto release;
    875      1.160        ad 			}
    876        1.1       cgd 			sbunlock(&so->so_snd);
    877        1.1       cgd 			error = sbwait(&so->so_snd);
    878        1.1       cgd 			if (error)
    879        1.1       cgd 				goto out;
    880        1.1       cgd 			goto restart;
    881        1.1       cgd 		}
    882        1.1       cgd 		mp = &top;
    883        1.1       cgd 		space -= clen;
    884        1.1       cgd 		do {
    885       1.45        tv 			if (uio == NULL) {
    886       1.45        tv 				/*
    887       1.45        tv 				 * Data is prepackaged in "top".
    888       1.45        tv 				 */
    889       1.45        tv 				resid = 0;
    890       1.45        tv 				if (flags & MSG_EOR)
    891       1.45        tv 					top->m_flags |= M_EOR;
    892       1.45        tv 			} else do {
    893      1.160        ad 				sounlock(so);
    894      1.160        ad 				splx(s);
    895      1.144    dyoung 				if (top == NULL) {
    896       1.78      matt 					m = m_gethdr(M_WAIT, MT_DATA);
    897       1.45        tv 					mlen = MHLEN;
    898       1.45        tv 					m->m_pkthdr.len = 0;
    899      1.140    dyoung 					m->m_pkthdr.rcvif = NULL;
    900       1.45        tv 				} else {
    901       1.78      matt 					m = m_get(M_WAIT, MT_DATA);
    902       1.45        tv 					mlen = MLEN;
    903       1.45        tv 				}
    904       1.78      matt 				MCLAIM(m, so->so_snd.sb_mowner);
    905      1.121      yamt 				if (sock_loan_thresh >= 0 &&
    906      1.121      yamt 				    uio->uio_iov->iov_len >= sock_loan_thresh &&
    907      1.121      yamt 				    space >= sock_loan_thresh &&
    908       1.64   thorpej 				    (len = sosend_loan(so, uio, m,
    909       1.64   thorpej 						       space)) != 0) {
    910       1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_loan_big);
    911       1.64   thorpej 					space -= len;
    912       1.64   thorpej 					goto have_data;
    913       1.64   thorpej 				}
    914       1.45        tv 				if (resid >= MINCLSIZE && space >= MCLBYTES) {
    915       1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_copy_big);
    916       1.78      matt 					m_clget(m, M_WAIT);
    917       1.45        tv 					if ((m->m_flags & M_EXT) == 0)
    918       1.45        tv 						goto nopages;
    919       1.45        tv 					mlen = MCLBYTES;
    920       1.45        tv 					if (atomic && top == 0) {
    921       1.58  jdolecek 						len = lmin(MCLBYTES - max_hdr,
    922       1.54     lukem 						    resid);
    923       1.45        tv 						m->m_data += max_hdr;
    924       1.45        tv 					} else
    925       1.58  jdolecek 						len = lmin(MCLBYTES, resid);
    926       1.45        tv 					space -= len;
    927       1.45        tv 				} else {
    928       1.64   thorpej  nopages:
    929       1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_copy_small);
    930       1.58  jdolecek 					len = lmin(lmin(mlen, resid), space);
    931       1.45        tv 					space -= len;
    932       1.45        tv 					/*
    933       1.45        tv 					 * For datagram protocols, leave room
    934       1.45        tv 					 * for protocol headers in first mbuf.
    935       1.45        tv 					 */
    936       1.45        tv 					if (atomic && top == 0 && len < mlen)
    937       1.45        tv 						MH_ALIGN(m, len);
    938       1.45        tv 				}
    939      1.144    dyoung 				error = uiomove(mtod(m, void *), (int)len, uio);
    940       1.64   thorpej  have_data:
    941       1.45        tv 				resid = uio->uio_resid;
    942       1.45        tv 				m->m_len = len;
    943       1.45        tv 				*mp = m;
    944       1.45        tv 				top->m_pkthdr.len += len;
    945      1.160        ad 				s = splsoftnet();
    946      1.160        ad 				solock(so);
    947      1.144    dyoung 				if (error != 0)
    948       1.45        tv 					goto release;
    949       1.45        tv 				mp = &m->m_next;
    950       1.45        tv 				if (resid <= 0) {
    951       1.45        tv 					if (flags & MSG_EOR)
    952       1.45        tv 						top->m_flags |= M_EOR;
    953       1.45        tv 					break;
    954       1.45        tv 				}
    955       1.45        tv 			} while (space > 0 && atomic);
    956      1.108     perry 
    957      1.160        ad 			if (so->so_state & SS_CANTSENDMORE) {
    958      1.160        ad 				error = EPIPE;
    959      1.160        ad 				goto release;
    960      1.160        ad 			}
    961       1.45        tv 			if (dontroute)
    962       1.45        tv 				so->so_options |= SO_DONTROUTE;
    963       1.45        tv 			if (resid > 0)
    964       1.45        tv 				so->so_state |= SS_MORETOCOME;
    965       1.46  sommerfe 			error = (*so->so_proto->pr_usrreq)(so,
    966       1.46  sommerfe 			    (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
    967      1.160        ad 			    top, addr, control, curlwp);
    968       1.45        tv 			if (dontroute)
    969       1.45        tv 				so->so_options &= ~SO_DONTROUTE;
    970       1.45        tv 			if (resid > 0)
    971       1.45        tv 				so->so_state &= ~SS_MORETOCOME;
    972       1.45        tv 			clen = 0;
    973      1.144    dyoung 			control = NULL;
    974      1.144    dyoung 			top = NULL;
    975       1.45        tv 			mp = &top;
    976      1.144    dyoung 			if (error != 0)
    977        1.1       cgd 				goto release;
    978        1.1       cgd 		} while (resid && space > 0);
    979        1.1       cgd 	} while (resid);
    980        1.1       cgd 
    981       1.54     lukem  release:
    982        1.1       cgd 	sbunlock(&so->so_snd);
    983       1.54     lukem  out:
    984      1.160        ad 	sounlock(so);
    985      1.160        ad 	splx(s);
    986        1.1       cgd 	if (top)
    987        1.1       cgd 		m_freem(top);
    988        1.1       cgd 	if (control)
    989        1.1       cgd 		m_freem(control);
    990        1.1       cgd 	return (error);
    991        1.1       cgd }
    992        1.1       cgd 
    993        1.1       cgd /*
    994      1.159        ad  * Following replacement or removal of the first mbuf on the first
    995      1.159        ad  * mbuf chain of a socket buffer, push necessary state changes back
    996      1.159        ad  * into the socket buffer so that other consumers see the values
    997      1.159        ad  * consistently.  'nextrecord' is the callers locally stored value of
    998      1.159        ad  * the original value of sb->sb_mb->m_nextpkt which must be restored
    999      1.159        ad  * when the lead mbuf changes.  NOTE: 'nextrecord' may be NULL.
   1000      1.159        ad  */
   1001      1.159        ad static void
   1002      1.159        ad sbsync(struct sockbuf *sb, struct mbuf *nextrecord)
   1003      1.159        ad {
   1004      1.159        ad 
   1005      1.160        ad 	KASSERT(solocked(sb->sb_so));
   1006      1.160        ad 
   1007      1.159        ad 	/*
   1008      1.159        ad 	 * First, update for the new value of nextrecord.  If necessary,
   1009      1.159        ad 	 * make it the first record.
   1010      1.159        ad 	 */
   1011      1.159        ad 	if (sb->sb_mb != NULL)
   1012      1.159        ad 		sb->sb_mb->m_nextpkt = nextrecord;
   1013      1.159        ad 	else
   1014      1.159        ad 		sb->sb_mb = nextrecord;
   1015      1.159        ad 
   1016      1.159        ad         /*
   1017      1.159        ad          * Now update any dependent socket buffer fields to reflect
   1018      1.159        ad          * the new state.  This is an inline of SB_EMPTY_FIXUP, with
   1019      1.159        ad          * the addition of a second clause that takes care of the
   1020      1.159        ad          * case where sb_mb has been updated, but remains the last
   1021      1.159        ad          * record.
   1022      1.159        ad          */
   1023      1.159        ad         if (sb->sb_mb == NULL) {
   1024      1.159        ad                 sb->sb_mbtail = NULL;
   1025      1.159        ad                 sb->sb_lastrecord = NULL;
   1026      1.159        ad         } else if (sb->sb_mb->m_nextpkt == NULL)
   1027      1.159        ad                 sb->sb_lastrecord = sb->sb_mb;
   1028      1.159        ad }
   1029      1.159        ad 
   1030      1.159        ad /*
   1031        1.1       cgd  * Implement receive operations on a socket.
   1032        1.1       cgd  * We depend on the way that records are added to the sockbuf
   1033        1.1       cgd  * by sbappend*.  In particular, each record (mbufs linked through m_next)
   1034        1.1       cgd  * must begin with an address if the protocol so specifies,
   1035        1.1       cgd  * followed by an optional mbuf or mbufs containing ancillary data,
   1036        1.1       cgd  * and then zero or more mbufs of data.
   1037        1.1       cgd  * In order to avoid blocking network interrupts for the entire time here,
   1038        1.1       cgd  * we splx() while doing the actual copy to user space.
   1039        1.1       cgd  * Although the sockbuf is locked, new data may still be appended,
   1040        1.1       cgd  * and thus we must maintain consistency of the sockbuf during that time.
   1041        1.1       cgd  *
   1042        1.1       cgd  * The caller may receive the data as a single mbuf chain by supplying
   1043        1.1       cgd  * an mbuf **mp0 for use in returning the chain.  The uio is then used
   1044        1.1       cgd  * only for the count in uio_resid.
   1045        1.1       cgd  */
   1046        1.3    andrew int
   1047       1.54     lukem soreceive(struct socket *so, struct mbuf **paddr, struct uio *uio,
   1048       1.54     lukem 	struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
   1049        1.1       cgd {
   1050      1.116      yamt 	struct lwp *l = curlwp;
   1051      1.160        ad 	struct mbuf	*m, **mp, *mt;
   1052      1.146    dyoung 	int atomic, flags, len, error, s, offset, moff, type, orig_resid;
   1053       1.99      matt 	const struct protosw	*pr;
   1054       1.54     lukem 	struct mbuf	*nextrecord;
   1055       1.67        he 	int		mbuf_removed = 0;
   1056      1.146    dyoung 	const struct domain *dom;
   1057       1.64   thorpej 
   1058       1.54     lukem 	pr = so->so_proto;
   1059      1.146    dyoung 	atomic = pr->pr_flags & PR_ATOMIC;
   1060      1.146    dyoung 	dom = pr->pr_domain;
   1061        1.1       cgd 	mp = mp0;
   1062       1.54     lukem 	type = 0;
   1063       1.54     lukem 	orig_resid = uio->uio_resid;
   1064      1.102  jonathan 
   1065      1.144    dyoung 	if (paddr != NULL)
   1066      1.144    dyoung 		*paddr = NULL;
   1067      1.144    dyoung 	if (controlp != NULL)
   1068      1.144    dyoung 		*controlp = NULL;
   1069      1.144    dyoung 	if (flagsp != NULL)
   1070        1.1       cgd 		flags = *flagsp &~ MSG_EOR;
   1071        1.1       cgd 	else
   1072        1.1       cgd 		flags = 0;
   1073       1.66     enami 
   1074        1.1       cgd 	if (flags & MSG_OOB) {
   1075        1.1       cgd 		m = m_get(M_WAIT, MT_DATA);
   1076      1.160        ad 		solock(so);
   1077       1.17       cgd 		error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,
   1078      1.140    dyoung 		    (struct mbuf *)(long)(flags & MSG_PEEK), NULL, l);
   1079      1.160        ad 		sounlock(so);
   1080        1.1       cgd 		if (error)
   1081        1.1       cgd 			goto bad;
   1082        1.1       cgd 		do {
   1083      1.134  christos 			error = uiomove(mtod(m, void *),
   1084        1.1       cgd 			    (int) min(uio->uio_resid, m->m_len), uio);
   1085        1.1       cgd 			m = m_free(m);
   1086      1.144    dyoung 		} while (uio->uio_resid > 0 && error == 0 && m);
   1087       1.54     lukem  bad:
   1088      1.144    dyoung 		if (m != NULL)
   1089        1.1       cgd 			m_freem(m);
   1090      1.144    dyoung 		return error;
   1091        1.1       cgd 	}
   1092      1.144    dyoung 	if (mp != NULL)
   1093      1.140    dyoung 		*mp = NULL;
   1094      1.160        ad 
   1095      1.160        ad 	/*
   1096      1.160        ad 	 * solock() provides atomicity of access.  splsoftnet() prevents
   1097      1.160        ad 	 * protocol processing soft interrupts from interrupting us and
   1098      1.160        ad 	 * blocking (expensive).
   1099      1.160        ad 	 */
   1100      1.160        ad 	s = splsoftnet();
   1101      1.160        ad 	solock(so);
   1102        1.1       cgd 	if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
   1103      1.140    dyoung 		(*pr->pr_usrreq)(so, PRU_RCVD, NULL, NULL, NULL, l);
   1104        1.1       cgd 
   1105       1.54     lukem  restart:
   1106      1.160        ad 	if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0) {
   1107      1.160        ad 		sounlock(so);
   1108      1.160        ad 		splx(s);
   1109      1.144    dyoung 		return error;
   1110      1.160        ad 	}
   1111        1.1       cgd 
   1112        1.1       cgd 	m = so->so_rcv.sb_mb;
   1113        1.1       cgd 	/*
   1114        1.1       cgd 	 * If we have less data than requested, block awaiting more
   1115        1.1       cgd 	 * (subject to any timeout) if:
   1116       1.15   mycroft 	 *   1. the current count is less than the low water mark,
   1117        1.1       cgd 	 *   2. MSG_WAITALL is set, and it is possible to do the entire
   1118       1.15   mycroft 	 *	receive operation at once if we block (resid <= hiwat), or
   1119       1.15   mycroft 	 *   3. MSG_DONTWAIT is not set.
   1120        1.1       cgd 	 * If MSG_WAITALL is set but resid is larger than the receive buffer,
   1121        1.1       cgd 	 * we have to do the receive in sections, and thus risk returning
   1122        1.1       cgd 	 * a short count if a timeout or signal occurs after we start.
   1123        1.1       cgd 	 */
   1124      1.144    dyoung 	if (m == NULL ||
   1125      1.144    dyoung 	    ((flags & MSG_DONTWAIT) == 0 &&
   1126      1.144    dyoung 	     so->so_rcv.sb_cc < uio->uio_resid &&
   1127      1.144    dyoung 	     (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
   1128      1.144    dyoung 	      ((flags & MSG_WAITALL) &&
   1129      1.144    dyoung 	       uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
   1130      1.146    dyoung 	     m->m_nextpkt == NULL && !atomic)) {
   1131        1.1       cgd #ifdef DIAGNOSTIC
   1132      1.144    dyoung 		if (m == NULL && so->so_rcv.sb_cc)
   1133        1.1       cgd 			panic("receive 1");
   1134        1.1       cgd #endif
   1135        1.1       cgd 		if (so->so_error) {
   1136      1.144    dyoung 			if (m != NULL)
   1137       1.15   mycroft 				goto dontblock;
   1138        1.1       cgd 			error = so->so_error;
   1139        1.1       cgd 			if ((flags & MSG_PEEK) == 0)
   1140        1.1       cgd 				so->so_error = 0;
   1141        1.1       cgd 			goto release;
   1142        1.1       cgd 		}
   1143        1.1       cgd 		if (so->so_state & SS_CANTRCVMORE) {
   1144      1.144    dyoung 			if (m != NULL)
   1145       1.15   mycroft 				goto dontblock;
   1146        1.1       cgd 			else
   1147        1.1       cgd 				goto release;
   1148        1.1       cgd 		}
   1149      1.144    dyoung 		for (; m != NULL; m = m->m_next)
   1150        1.1       cgd 			if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
   1151        1.1       cgd 				m = so->so_rcv.sb_mb;
   1152        1.1       cgd 				goto dontblock;
   1153        1.1       cgd 			}
   1154        1.1       cgd 		if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
   1155        1.1       cgd 		    (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
   1156        1.1       cgd 			error = ENOTCONN;
   1157        1.1       cgd 			goto release;
   1158        1.1       cgd 		}
   1159        1.1       cgd 		if (uio->uio_resid == 0)
   1160        1.1       cgd 			goto release;
   1161      1.151        ad 		if (so->so_nbio || (flags & MSG_DONTWAIT)) {
   1162        1.1       cgd 			error = EWOULDBLOCK;
   1163        1.1       cgd 			goto release;
   1164        1.1       cgd 		}
   1165       1.69   thorpej 		SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 1");
   1166       1.69   thorpej 		SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 1");
   1167        1.1       cgd 		sbunlock(&so->so_rcv);
   1168        1.1       cgd 		error = sbwait(&so->so_rcv);
   1169      1.160        ad 		if (error != 0) {
   1170      1.160        ad 			sounlock(so);
   1171      1.160        ad 			splx(s);
   1172      1.144    dyoung 			return error;
   1173      1.160        ad 		}
   1174        1.1       cgd 		goto restart;
   1175        1.1       cgd 	}
   1176       1.54     lukem  dontblock:
   1177       1.69   thorpej 	/*
   1178       1.69   thorpej 	 * On entry here, m points to the first record of the socket buffer.
   1179      1.159        ad 	 * From this point onward, we maintain 'nextrecord' as a cache of the
   1180      1.159        ad 	 * pointer to the next record in the socket buffer.  We must keep the
   1181      1.159        ad 	 * various socket buffer pointers and local stack versions of the
   1182      1.159        ad 	 * pointers in sync, pushing out modifications before dropping the
   1183      1.160        ad 	 * socket lock, and re-reading them when picking it up.
   1184      1.159        ad 	 *
   1185      1.159        ad 	 * Otherwise, we will race with the network stack appending new data
   1186      1.159        ad 	 * or records onto the socket buffer by using inconsistent/stale
   1187      1.159        ad 	 * versions of the field, possibly resulting in socket buffer
   1188      1.159        ad 	 * corruption.
   1189      1.159        ad 	 *
   1190      1.159        ad 	 * By holding the high-level sblock(), we prevent simultaneous
   1191      1.159        ad 	 * readers from pulling off the front of the socket buffer.
   1192       1.69   thorpej 	 */
   1193      1.144    dyoung 	if (l != NULL)
   1194      1.157        ad 		l->l_ru.ru_msgrcv++;
   1195       1.69   thorpej 	KASSERT(m == so->so_rcv.sb_mb);
   1196       1.69   thorpej 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 1");
   1197       1.69   thorpej 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 1");
   1198        1.1       cgd 	nextrecord = m->m_nextpkt;
   1199        1.1       cgd 	if (pr->pr_flags & PR_ADDR) {
   1200        1.1       cgd #ifdef DIAGNOSTIC
   1201        1.1       cgd 		if (m->m_type != MT_SONAME)
   1202        1.1       cgd 			panic("receive 1a");
   1203        1.1       cgd #endif
   1204        1.3    andrew 		orig_resid = 0;
   1205        1.1       cgd 		if (flags & MSG_PEEK) {
   1206        1.1       cgd 			if (paddr)
   1207        1.1       cgd 				*paddr = m_copy(m, 0, m->m_len);
   1208        1.1       cgd 			m = m->m_next;
   1209        1.1       cgd 		} else {
   1210        1.1       cgd 			sbfree(&so->so_rcv, m);
   1211       1.67        he 			mbuf_removed = 1;
   1212      1.144    dyoung 			if (paddr != NULL) {
   1213        1.1       cgd 				*paddr = m;
   1214        1.1       cgd 				so->so_rcv.sb_mb = m->m_next;
   1215      1.144    dyoung 				m->m_next = NULL;
   1216        1.1       cgd 				m = so->so_rcv.sb_mb;
   1217        1.1       cgd 			} else {
   1218        1.1       cgd 				MFREE(m, so->so_rcv.sb_mb);
   1219        1.1       cgd 				m = so->so_rcv.sb_mb;
   1220        1.1       cgd 			}
   1221      1.159        ad 			sbsync(&so->so_rcv, nextrecord);
   1222        1.1       cgd 		}
   1223        1.1       cgd 	}
   1224      1.159        ad 
   1225      1.159        ad 	/*
   1226      1.159        ad 	 * Process one or more MT_CONTROL mbufs present before any data mbufs
   1227      1.159        ad 	 * in the first mbuf chain on the socket buffer.  If MSG_PEEK, we
   1228      1.159        ad 	 * just copy the data; if !MSG_PEEK, we call into the protocol to
   1229      1.159        ad 	 * perform externalization (or freeing if controlp == NULL).
   1230      1.159        ad 	 */
   1231      1.159        ad 	if (__predict_false(m != NULL && m->m_type == MT_CONTROL)) {
   1232      1.159        ad 		struct mbuf *cm = NULL, *cmn;
   1233      1.159        ad 		struct mbuf **cme = &cm;
   1234      1.159        ad 
   1235      1.159        ad 		do {
   1236      1.159        ad 			if (flags & MSG_PEEK) {
   1237      1.159        ad 				if (controlp != NULL) {
   1238      1.159        ad 					*controlp = m_copy(m, 0, m->m_len);
   1239      1.159        ad 					controlp = &(*controlp)->m_next;
   1240      1.159        ad 				}
   1241      1.159        ad 				m = m->m_next;
   1242      1.159        ad 			} else {
   1243      1.159        ad 				sbfree(&so->so_rcv, m);
   1244        1.1       cgd 				so->so_rcv.sb_mb = m->m_next;
   1245      1.144    dyoung 				m->m_next = NULL;
   1246      1.159        ad 				*cme = m;
   1247      1.159        ad 				cme = &(*cme)->m_next;
   1248        1.1       cgd 				m = so->so_rcv.sb_mb;
   1249      1.159        ad 			}
   1250      1.159        ad 		} while (m != NULL && m->m_type == MT_CONTROL);
   1251      1.159        ad 		if ((flags & MSG_PEEK) == 0)
   1252      1.159        ad 			sbsync(&so->so_rcv, nextrecord);
   1253      1.159        ad 		for (; cm != NULL; cm = cmn) {
   1254      1.159        ad 			cmn = cm->m_next;
   1255      1.159        ad 			cm->m_next = NULL;
   1256      1.159        ad 			type = mtod(cm, struct cmsghdr *)->cmsg_type;
   1257      1.159        ad 			if (controlp != NULL) {
   1258      1.159        ad 				if (dom->dom_externalize != NULL &&
   1259      1.159        ad 				    type == SCM_RIGHTS) {
   1260      1.160        ad 					sounlock(so);
   1261      1.159        ad 					splx(s);
   1262      1.159        ad 					error = (*dom->dom_externalize)(cm, l);
   1263      1.159        ad 					s = splsoftnet();
   1264      1.160        ad 					solock(so);
   1265      1.159        ad 				}
   1266      1.159        ad 				*controlp = cm;
   1267      1.159        ad 				while (*controlp != NULL)
   1268      1.159        ad 					controlp = &(*controlp)->m_next;
   1269        1.1       cgd 			} else {
   1270      1.106    itojun 				/*
   1271      1.106    itojun 				 * Dispose of any SCM_RIGHTS message that went
   1272      1.106    itojun 				 * through the read path rather than recv.
   1273      1.106    itojun 				 */
   1274      1.159        ad 				if (dom->dom_dispose != NULL &&
   1275      1.159        ad 				    type == SCM_RIGHTS) {
   1276      1.160        ad 				    	sounlock(so);
   1277      1.159        ad 					(*dom->dom_dispose)(cm);
   1278      1.160        ad 					solock(so);
   1279      1.159        ad 				}
   1280      1.159        ad 				m_freem(cm);
   1281        1.1       cgd 			}
   1282        1.1       cgd 		}
   1283      1.159        ad 		if (m != NULL)
   1284      1.159        ad 			nextrecord = so->so_rcv.sb_mb->m_nextpkt;
   1285      1.159        ad 		else
   1286      1.159        ad 			nextrecord = so->so_rcv.sb_mb;
   1287      1.159        ad 		orig_resid = 0;
   1288        1.1       cgd 	}
   1289       1.69   thorpej 
   1290      1.159        ad 	/* If m is non-NULL, we have some data to read. */
   1291      1.159        ad 	if (__predict_true(m != NULL)) {
   1292        1.1       cgd 		type = m->m_type;
   1293        1.1       cgd 		if (type == MT_OOBDATA)
   1294        1.1       cgd 			flags |= MSG_OOB;
   1295        1.1       cgd 	}
   1296       1.69   thorpej 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 2");
   1297       1.69   thorpej 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 2");
   1298       1.69   thorpej 
   1299        1.1       cgd 	moff = 0;
   1300        1.1       cgd 	offset = 0;
   1301      1.144    dyoung 	while (m != NULL && uio->uio_resid > 0 && error == 0) {
   1302        1.1       cgd 		if (m->m_type == MT_OOBDATA) {
   1303        1.1       cgd 			if (type != MT_OOBDATA)
   1304        1.1       cgd 				break;
   1305        1.1       cgd 		} else if (type == MT_OOBDATA)
   1306        1.1       cgd 			break;
   1307        1.1       cgd #ifdef DIAGNOSTIC
   1308        1.1       cgd 		else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
   1309        1.1       cgd 			panic("receive 3");
   1310        1.1       cgd #endif
   1311        1.1       cgd 		so->so_state &= ~SS_RCVATMARK;
   1312        1.1       cgd 		len = uio->uio_resid;
   1313        1.1       cgd 		if (so->so_oobmark && len > so->so_oobmark - offset)
   1314        1.1       cgd 			len = so->so_oobmark - offset;
   1315        1.1       cgd 		if (len > m->m_len - moff)
   1316        1.1       cgd 			len = m->m_len - moff;
   1317        1.1       cgd 		/*
   1318        1.1       cgd 		 * If mp is set, just pass back the mbufs.
   1319        1.1       cgd 		 * Otherwise copy them out via the uio, then free.
   1320        1.1       cgd 		 * Sockbuf must be consistent here (points to current mbuf,
   1321        1.1       cgd 		 * it points to next record) when we drop priority;
   1322        1.1       cgd 		 * we must note any additions to the sockbuf when we
   1323        1.1       cgd 		 * block interrupts again.
   1324        1.1       cgd 		 */
   1325      1.144    dyoung 		if (mp == NULL) {
   1326       1.69   thorpej 			SBLASTRECORDCHK(&so->so_rcv, "soreceive uiomove");
   1327       1.69   thorpej 			SBLASTMBUFCHK(&so->so_rcv, "soreceive uiomove");
   1328      1.160        ad 			sounlock(so);
   1329        1.1       cgd 			splx(s);
   1330      1.134  christos 			error = uiomove(mtod(m, char *) + moff, (int)len, uio);
   1331       1.20   mycroft 			s = splsoftnet();
   1332      1.160        ad 			solock(so);
   1333      1.144    dyoung 			if (error != 0) {
   1334       1.67        he 				/*
   1335       1.67        he 				 * If any part of the record has been removed
   1336       1.67        he 				 * (such as the MT_SONAME mbuf, which will
   1337       1.67        he 				 * happen when PR_ADDR, and thus also
   1338       1.67        he 				 * PR_ATOMIC, is set), then drop the entire
   1339       1.67        he 				 * record to maintain the atomicity of the
   1340       1.67        he 				 * receive operation.
   1341       1.67        he 				 *
   1342       1.67        he 				 * This avoids a later panic("receive 1a")
   1343       1.67        he 				 * when compiled with DIAGNOSTIC.
   1344       1.67        he 				 */
   1345      1.146    dyoung 				if (m && mbuf_removed && atomic)
   1346       1.67        he 					(void) sbdroprecord(&so->so_rcv);
   1347       1.67        he 
   1348       1.57  jdolecek 				goto release;
   1349       1.67        he 			}
   1350        1.1       cgd 		} else
   1351        1.1       cgd 			uio->uio_resid -= len;
   1352        1.1       cgd 		if (len == m->m_len - moff) {
   1353        1.1       cgd 			if (m->m_flags & M_EOR)
   1354        1.1       cgd 				flags |= MSG_EOR;
   1355        1.1       cgd 			if (flags & MSG_PEEK) {
   1356        1.1       cgd 				m = m->m_next;
   1357        1.1       cgd 				moff = 0;
   1358        1.1       cgd 			} else {
   1359        1.1       cgd 				nextrecord = m->m_nextpkt;
   1360        1.1       cgd 				sbfree(&so->so_rcv, m);
   1361        1.1       cgd 				if (mp) {
   1362        1.1       cgd 					*mp = m;
   1363        1.1       cgd 					mp = &m->m_next;
   1364        1.1       cgd 					so->so_rcv.sb_mb = m = m->m_next;
   1365      1.140    dyoung 					*mp = NULL;
   1366        1.1       cgd 				} else {
   1367        1.1       cgd 					MFREE(m, so->so_rcv.sb_mb);
   1368        1.1       cgd 					m = so->so_rcv.sb_mb;
   1369        1.1       cgd 				}
   1370       1.69   thorpej 				/*
   1371       1.69   thorpej 				 * If m != NULL, we also know that
   1372       1.69   thorpej 				 * so->so_rcv.sb_mb != NULL.
   1373       1.69   thorpej 				 */
   1374       1.69   thorpej 				KASSERT(so->so_rcv.sb_mb == m);
   1375       1.69   thorpej 				if (m) {
   1376        1.1       cgd 					m->m_nextpkt = nextrecord;
   1377       1.69   thorpej 					if (nextrecord == NULL)
   1378       1.69   thorpej 						so->so_rcv.sb_lastrecord = m;
   1379       1.69   thorpej 				} else {
   1380       1.69   thorpej 					so->so_rcv.sb_mb = nextrecord;
   1381       1.70   thorpej 					SB_EMPTY_FIXUP(&so->so_rcv);
   1382       1.69   thorpej 				}
   1383       1.69   thorpej 				SBLASTRECORDCHK(&so->so_rcv, "soreceive 3");
   1384       1.69   thorpej 				SBLASTMBUFCHK(&so->so_rcv, "soreceive 3");
   1385        1.1       cgd 			}
   1386      1.144    dyoung 		} else if (flags & MSG_PEEK)
   1387      1.144    dyoung 			moff += len;
   1388      1.144    dyoung 		else {
   1389      1.160        ad 			if (mp != NULL) {
   1390      1.160        ad 				mt = m_copym(m, 0, len, M_NOWAIT);
   1391      1.160        ad 				if (__predict_false(mt == NULL)) {
   1392      1.160        ad 					sounlock(so);
   1393      1.160        ad 					mt = m_copym(m, 0, len, M_WAIT);
   1394      1.160        ad 					solock(so);
   1395      1.160        ad 				}
   1396      1.160        ad 				*mp = mt;
   1397      1.160        ad 			}
   1398      1.144    dyoung 			m->m_data += len;
   1399      1.144    dyoung 			m->m_len -= len;
   1400      1.144    dyoung 			so->so_rcv.sb_cc -= len;
   1401        1.1       cgd 		}
   1402        1.1       cgd 		if (so->so_oobmark) {
   1403        1.1       cgd 			if ((flags & MSG_PEEK) == 0) {
   1404        1.1       cgd 				so->so_oobmark -= len;
   1405        1.1       cgd 				if (so->so_oobmark == 0) {
   1406        1.1       cgd 					so->so_state |= SS_RCVATMARK;
   1407        1.1       cgd 					break;
   1408        1.1       cgd 				}
   1409        1.7       cgd 			} else {
   1410        1.1       cgd 				offset += len;
   1411        1.7       cgd 				if (offset == so->so_oobmark)
   1412        1.7       cgd 					break;
   1413        1.7       cgd 			}
   1414        1.1       cgd 		}
   1415        1.1       cgd 		if (flags & MSG_EOR)
   1416        1.1       cgd 			break;
   1417        1.1       cgd 		/*
   1418        1.1       cgd 		 * If the MSG_WAITALL flag is set (for non-atomic socket),
   1419        1.1       cgd 		 * we must not quit until "uio->uio_resid == 0" or an error
   1420        1.1       cgd 		 * termination.  If a signal/timeout occurs, return
   1421        1.1       cgd 		 * with a short count but without error.
   1422        1.1       cgd 		 * Keep sockbuf locked against other readers.
   1423        1.1       cgd 		 */
   1424      1.144    dyoung 		while (flags & MSG_WAITALL && m == NULL && uio->uio_resid > 0 &&
   1425        1.3    andrew 		    !sosendallatonce(so) && !nextrecord) {
   1426        1.1       cgd 			if (so->so_error || so->so_state & SS_CANTRCVMORE)
   1427        1.1       cgd 				break;
   1428       1.68      matt 			/*
   1429       1.68      matt 			 * If we are peeking and the socket receive buffer is
   1430       1.68      matt 			 * full, stop since we can't get more data to peek at.
   1431       1.68      matt 			 */
   1432       1.68      matt 			if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
   1433       1.68      matt 				break;
   1434       1.68      matt 			/*
   1435       1.68      matt 			 * If we've drained the socket buffer, tell the
   1436       1.68      matt 			 * protocol in case it needs to do something to
   1437       1.68      matt 			 * get it filled again.
   1438       1.68      matt 			 */
   1439       1.68      matt 			if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb)
   1440       1.68      matt 				(*pr->pr_usrreq)(so, PRU_RCVD,
   1441      1.140    dyoung 				    NULL, (struct mbuf *)(long)flags, NULL, l);
   1442       1.69   thorpej 			SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");
   1443       1.69   thorpej 			SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");
   1444        1.1       cgd 			error = sbwait(&so->so_rcv);
   1445      1.144    dyoung 			if (error != 0) {
   1446        1.1       cgd 				sbunlock(&so->so_rcv);
   1447      1.160        ad 				sounlock(so);
   1448        1.1       cgd 				splx(s);
   1449      1.144    dyoung 				return 0;
   1450        1.1       cgd 			}
   1451       1.21  christos 			if ((m = so->so_rcv.sb_mb) != NULL)
   1452        1.1       cgd 				nextrecord = m->m_nextpkt;
   1453        1.1       cgd 		}
   1454        1.1       cgd 	}
   1455        1.3    andrew 
   1456      1.146    dyoung 	if (m && atomic) {
   1457        1.3    andrew 		flags |= MSG_TRUNC;
   1458        1.3    andrew 		if ((flags & MSG_PEEK) == 0)
   1459        1.3    andrew 			(void) sbdroprecord(&so->so_rcv);
   1460        1.3    andrew 	}
   1461        1.1       cgd 	if ((flags & MSG_PEEK) == 0) {
   1462      1.144    dyoung 		if (m == NULL) {
   1463       1.69   thorpej 			/*
   1464       1.70   thorpej 			 * First part is an inline SB_EMPTY_FIXUP().  Second
   1465       1.69   thorpej 			 * part makes sure sb_lastrecord is up-to-date if
   1466       1.69   thorpej 			 * there is still data in the socket buffer.
   1467       1.69   thorpej 			 */
   1468        1.1       cgd 			so->so_rcv.sb_mb = nextrecord;
   1469       1.69   thorpej 			if (so->so_rcv.sb_mb == NULL) {
   1470       1.69   thorpej 				so->so_rcv.sb_mbtail = NULL;
   1471       1.69   thorpej 				so->so_rcv.sb_lastrecord = NULL;
   1472       1.69   thorpej 			} else if (nextrecord->m_nextpkt == NULL)
   1473       1.69   thorpej 				so->so_rcv.sb_lastrecord = nextrecord;
   1474       1.69   thorpej 		}
   1475       1.69   thorpej 		SBLASTRECORDCHK(&so->so_rcv, "soreceive 4");
   1476       1.69   thorpej 		SBLASTMBUFCHK(&so->so_rcv, "soreceive 4");
   1477        1.1       cgd 		if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
   1478      1.140    dyoung 			(*pr->pr_usrreq)(so, PRU_RCVD, NULL,
   1479      1.140    dyoung 			    (struct mbuf *)(long)flags, NULL, l);
   1480        1.1       cgd 	}
   1481        1.3    andrew 	if (orig_resid == uio->uio_resid && orig_resid &&
   1482        1.3    andrew 	    (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
   1483        1.3    andrew 		sbunlock(&so->so_rcv);
   1484        1.3    andrew 		goto restart;
   1485        1.3    andrew 	}
   1486      1.108     perry 
   1487      1.144    dyoung 	if (flagsp != NULL)
   1488        1.1       cgd 		*flagsp |= flags;
   1489       1.54     lukem  release:
   1490        1.1       cgd 	sbunlock(&so->so_rcv);
   1491      1.160        ad 	sounlock(so);
   1492        1.1       cgd 	splx(s);
   1493      1.144    dyoung 	return error;
   1494        1.1       cgd }
   1495        1.1       cgd 
   1496       1.14   mycroft int
   1497       1.54     lukem soshutdown(struct socket *so, int how)
   1498        1.1       cgd {
   1499       1.99      matt 	const struct protosw	*pr;
   1500      1.160        ad 	int	error;
   1501      1.160        ad 
   1502      1.160        ad 	KASSERT(solocked(so));
   1503       1.34    kleink 
   1504       1.54     lukem 	pr = so->so_proto;
   1505       1.34    kleink 	if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
   1506       1.34    kleink 		return (EINVAL);
   1507        1.1       cgd 
   1508      1.160        ad 	if (how == SHUT_RD || how == SHUT_RDWR) {
   1509        1.1       cgd 		sorflush(so);
   1510      1.160        ad 		error = 0;
   1511      1.160        ad 	}
   1512       1.34    kleink 	if (how == SHUT_WR || how == SHUT_RDWR)
   1513      1.160        ad 		error = (*pr->pr_usrreq)(so, PRU_SHUTDOWN, NULL,
   1514      1.140    dyoung 		    NULL, NULL, NULL);
   1515      1.160        ad 
   1516      1.160        ad 	return error;
   1517        1.1       cgd }
   1518        1.1       cgd 
   1519  1.177.4.2       snj int
   1520  1.177.4.2       snj sodrain(struct socket *so)
   1521  1.177.4.2       snj {
   1522  1.177.4.2       snj 	int error;
   1523  1.177.4.2       snj 
   1524  1.177.4.2       snj 	solock(so);
   1525  1.177.4.2       snj 	so->so_state |= SS_ISDRAINING;
   1526  1.177.4.2       snj 	cv_broadcast(&so->so_cv);
   1527  1.177.4.2       snj 	error = soshutdown(so, SHUT_RDWR);
   1528  1.177.4.2       snj 	sounlock(so);
   1529  1.177.4.2       snj 
   1530  1.177.4.2       snj 	return error;
   1531  1.177.4.2       snj }
   1532  1.177.4.2       snj 
   1533       1.14   mycroft void
   1534       1.54     lukem sorflush(struct socket *so)
   1535        1.1       cgd {
   1536       1.54     lukem 	struct sockbuf	*sb, asb;
   1537       1.99      matt 	const struct protosw	*pr;
   1538      1.160        ad 
   1539      1.160        ad 	KASSERT(solocked(so));
   1540        1.1       cgd 
   1541       1.54     lukem 	sb = &so->so_rcv;
   1542       1.54     lukem 	pr = so->so_proto;
   1543      1.160        ad 	socantrcvmore(so);
   1544        1.1       cgd 	sb->sb_flags |= SB_NOINTR;
   1545      1.160        ad 	(void )sblock(sb, M_WAITOK);
   1546        1.1       cgd 	sbunlock(sb);
   1547        1.1       cgd 	asb = *sb;
   1548       1.86  wrstuden 	/*
   1549       1.86  wrstuden 	 * Clear most of the sockbuf structure, but leave some of the
   1550       1.86  wrstuden 	 * fields valid.
   1551       1.86  wrstuden 	 */
   1552       1.86  wrstuden 	memset(&sb->sb_startzero, 0,
   1553       1.86  wrstuden 	    sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
   1554      1.160        ad 	if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose) {
   1555      1.160        ad 		sounlock(so);
   1556        1.1       cgd 		(*pr->pr_domain->dom_dispose)(asb.sb_mb);
   1557      1.160        ad 		solock(so);
   1558      1.160        ad 	}
   1559       1.98  christos 	sbrelease(&asb, so);
   1560        1.1       cgd }
   1561        1.1       cgd 
   1562      1.171    plunky /*
   1563      1.171    plunky  * internal set SOL_SOCKET options
   1564      1.171    plunky  */
   1565      1.142    dyoung static int
   1566      1.171    plunky sosetopt1(struct socket *so, const struct sockopt *sopt)
   1567        1.1       cgd {
   1568      1.171    plunky 	int error, optval;
   1569      1.171    plunky 	struct linger l;
   1570      1.171    plunky 	struct timeval tv;
   1571      1.142    dyoung 
   1572      1.171    plunky 	switch (sopt->sopt_name) {
   1573      1.142    dyoung 
   1574      1.170       tls 	case SO_ACCEPTFILTER:
   1575      1.177        ad 		error = accept_filt_setopt(so, sopt);
   1576      1.177        ad 		KASSERT(solocked(so));
   1577      1.170       tls 		break;
   1578      1.170       tls 
   1579      1.171    plunky   	case SO_LINGER:
   1580      1.171    plunky  		error = sockopt_get(sopt, &l, sizeof(l));
   1581      1.177        ad 		solock(so);
   1582      1.171    plunky  		if (error)
   1583      1.177        ad  			break;
   1584      1.171    plunky  		if (l.l_linger < 0 || l.l_linger > USHRT_MAX ||
   1585      1.177        ad  		    l.l_linger > (INT_MAX / hz)) {
   1586      1.177        ad 			error = EDOM;
   1587      1.177        ad 			break;
   1588      1.177        ad 		}
   1589      1.171    plunky  		so->so_linger = l.l_linger;
   1590      1.171    plunky  		if (l.l_onoff)
   1591      1.171    plunky  			so->so_options |= SO_LINGER;
   1592      1.171    plunky  		else
   1593      1.171    plunky  			so->so_options &= ~SO_LINGER;
   1594      1.177        ad    		break;
   1595        1.1       cgd 
   1596      1.142    dyoung 	case SO_DEBUG:
   1597      1.142    dyoung 	case SO_KEEPALIVE:
   1598      1.142    dyoung 	case SO_DONTROUTE:
   1599      1.142    dyoung 	case SO_USELOOPBACK:
   1600      1.142    dyoung 	case SO_BROADCAST:
   1601      1.142    dyoung 	case SO_REUSEADDR:
   1602      1.142    dyoung 	case SO_REUSEPORT:
   1603      1.142    dyoung 	case SO_OOBINLINE:
   1604      1.142    dyoung 	case SO_TIMESTAMP:
   1605      1.171    plunky 		error = sockopt_getint(sopt, &optval);
   1606      1.177        ad 		solock(so);
   1607      1.171    plunky 		if (error)
   1608      1.177        ad 			break;
   1609      1.171    plunky 		if (optval)
   1610      1.171    plunky 			so->so_options |= sopt->sopt_name;
   1611      1.142    dyoung 		else
   1612      1.171    plunky 			so->so_options &= ~sopt->sopt_name;
   1613      1.142    dyoung 		break;
   1614      1.142    dyoung 
   1615      1.142    dyoung 	case SO_SNDBUF:
   1616      1.142    dyoung 	case SO_RCVBUF:
   1617      1.142    dyoung 	case SO_SNDLOWAT:
   1618      1.142    dyoung 	case SO_RCVLOWAT:
   1619      1.171    plunky 		error = sockopt_getint(sopt, &optval);
   1620      1.177        ad 		solock(so);
   1621      1.171    plunky 		if (error)
   1622      1.177        ad 			break;
   1623        1.1       cgd 
   1624      1.142    dyoung 		/*
   1625      1.142    dyoung 		 * Values < 1 make no sense for any of these
   1626      1.142    dyoung 		 * options, so disallow them.
   1627      1.142    dyoung 		 */
   1628      1.177        ad 		if (optval < 1) {
   1629      1.177        ad 			error = EINVAL;
   1630      1.177        ad 			break;
   1631      1.177        ad 		}
   1632        1.1       cgd 
   1633      1.171    plunky 		switch (sopt->sopt_name) {
   1634      1.171    plunky 		case SO_SNDBUF:
   1635      1.177        ad 			if (sbreserve(&so->so_snd, (u_long)optval, so) == 0) {
   1636      1.177        ad 				error = ENOBUFS;
   1637      1.177        ad 				break;
   1638      1.177        ad 			}
   1639      1.171    plunky 			so->so_snd.sb_flags &= ~SB_AUTOSIZE;
   1640      1.171    plunky 			break;
   1641        1.1       cgd 
   1642        1.1       cgd 		case SO_RCVBUF:
   1643      1.177        ad 			if (sbreserve(&so->so_rcv, (u_long)optval, so) == 0) {
   1644      1.177        ad 				error = ENOBUFS;
   1645      1.177        ad 				break;
   1646      1.177        ad 			}
   1647      1.171    plunky 			so->so_rcv.sb_flags &= ~SB_AUTOSIZE;
   1648      1.142    dyoung 			break;
   1649      1.142    dyoung 
   1650      1.142    dyoung 		/*
   1651      1.142    dyoung 		 * Make sure the low-water is never greater than
   1652      1.142    dyoung 		 * the high-water.
   1653      1.142    dyoung 		 */
   1654        1.1       cgd 		case SO_SNDLOWAT:
   1655      1.171    plunky 			if (optval > so->so_snd.sb_hiwat)
   1656      1.171    plunky 				optval = so->so_snd.sb_hiwat;
   1657      1.171    plunky 
   1658      1.171    plunky 			so->so_snd.sb_lowat = optval;
   1659      1.142    dyoung 			break;
   1660      1.171    plunky 
   1661        1.1       cgd 		case SO_RCVLOWAT:
   1662      1.171    plunky 			if (optval > so->so_rcv.sb_hiwat)
   1663      1.171    plunky 				optval = so->so_rcv.sb_hiwat;
   1664      1.171    plunky 
   1665      1.171    plunky 			so->so_rcv.sb_lowat = optval;
   1666      1.142    dyoung 			break;
   1667      1.142    dyoung 		}
   1668      1.142    dyoung 		break;
   1669       1.28   thorpej 
   1670      1.142    dyoung 	case SO_SNDTIMEO:
   1671      1.142    dyoung 	case SO_RCVTIMEO:
   1672      1.171    plunky 		error = sockopt_get(sopt, &tv, sizeof(tv));
   1673      1.177        ad 		solock(so);
   1674      1.171    plunky 		if (error)
   1675      1.177        ad 			break;
   1676      1.171    plunky 
   1677      1.177        ad 		if (tv.tv_sec > (INT_MAX - tv.tv_usec / tick) / hz) {
   1678      1.177        ad 			error = EDOM;
   1679      1.177        ad 			break;
   1680      1.177        ad 		}
   1681       1.28   thorpej 
   1682      1.171    plunky 		optval = tv.tv_sec * hz + tv.tv_usec / tick;
   1683      1.171    plunky 		if (optval == 0 && tv.tv_usec != 0)
   1684      1.171    plunky 			optval = 1;
   1685       1.28   thorpej 
   1686      1.171    plunky 		switch (sopt->sopt_name) {
   1687      1.142    dyoung 		case SO_SNDTIMEO:
   1688      1.171    plunky 			so->so_snd.sb_timeo = optval;
   1689        1.1       cgd 			break;
   1690        1.1       cgd 		case SO_RCVTIMEO:
   1691      1.171    plunky 			so->so_rcv.sb_timeo = optval;
   1692      1.142    dyoung 			break;
   1693      1.142    dyoung 		}
   1694      1.142    dyoung 		break;
   1695        1.1       cgd 
   1696      1.142    dyoung 	default:
   1697      1.177        ad 		solock(so);
   1698      1.177        ad 		error = ENOPROTOOPT;
   1699      1.177        ad 		break;
   1700      1.142    dyoung 	}
   1701      1.177        ad 	KASSERT(solocked(so));
   1702      1.177        ad 	return error;
   1703      1.142    dyoung }
   1704        1.1       cgd 
   1705      1.142    dyoung int
   1706      1.171    plunky sosetopt(struct socket *so, struct sockopt *sopt)
   1707      1.142    dyoung {
   1708      1.142    dyoung 	int error, prerr;
   1709        1.1       cgd 
   1710      1.177        ad 	if (sopt->sopt_level == SOL_SOCKET) {
   1711      1.171    plunky 		error = sosetopt1(so, sopt);
   1712      1.177        ad 		KASSERT(solocked(so));
   1713      1.177        ad 	} else {
   1714      1.142    dyoung 		error = ENOPROTOOPT;
   1715      1.177        ad 		solock(so);
   1716      1.177        ad 	}
   1717        1.1       cgd 
   1718      1.142    dyoung 	if ((error == 0 || error == ENOPROTOOPT) &&
   1719      1.142    dyoung 	    so->so_proto != NULL && so->so_proto->pr_ctloutput != NULL) {
   1720      1.142    dyoung 		/* give the protocol stack a shot */
   1721      1.171    plunky 		prerr = (*so->so_proto->pr_ctloutput)(PRCO_SETOPT, so, sopt);
   1722      1.142    dyoung 		if (prerr == 0)
   1723      1.142    dyoung 			error = 0;
   1724      1.142    dyoung 		else if (prerr != ENOPROTOOPT)
   1725      1.142    dyoung 			error = prerr;
   1726      1.171    plunky 	}
   1727      1.160        ad 	sounlock(so);
   1728      1.142    dyoung 	return error;
   1729        1.1       cgd }
   1730        1.1       cgd 
   1731      1.171    plunky /*
   1732      1.171    plunky  * so_setsockopt() is a wrapper providing a sockopt structure for sosetopt()
   1733      1.171    plunky  */
   1734      1.171    plunky int
   1735      1.171    plunky so_setsockopt(struct lwp *l, struct socket *so, int level, int name,
   1736      1.171    plunky     const void *val, size_t valsize)
   1737      1.171    plunky {
   1738      1.171    plunky 	struct sockopt sopt;
   1739      1.171    plunky 	int error;
   1740      1.171    plunky 
   1741      1.171    plunky 	KASSERT(valsize == 0 || val != NULL);
   1742      1.171    plunky 
   1743      1.171    plunky 	sockopt_init(&sopt, level, name, valsize);
   1744      1.171    plunky 	sockopt_set(&sopt, val, valsize);
   1745      1.171    plunky 
   1746      1.171    plunky 	error = sosetopt(so, &sopt);
   1747      1.171    plunky 
   1748      1.171    plunky 	sockopt_destroy(&sopt);
   1749      1.171    plunky 
   1750      1.171    plunky 	return error;
   1751      1.171    plunky }
   1752      1.171    plunky 
   1753      1.171    plunky /*
   1754      1.171    plunky  * internal get SOL_SOCKET options
   1755      1.171    plunky  */
   1756      1.171    plunky static int
   1757      1.171    plunky sogetopt1(struct socket *so, struct sockopt *sopt)
   1758      1.171    plunky {
   1759      1.171    plunky 	int error, optval;
   1760      1.171    plunky 	struct linger l;
   1761      1.171    plunky 	struct timeval tv;
   1762      1.171    plunky 
   1763      1.171    plunky 	switch (sopt->sopt_name) {
   1764      1.171    plunky 
   1765      1.171    plunky 	case SO_ACCEPTFILTER:
   1766      1.177        ad 		error = accept_filt_getopt(so, sopt);
   1767      1.171    plunky 		break;
   1768      1.171    plunky 
   1769      1.171    plunky 	case SO_LINGER:
   1770      1.171    plunky 		l.l_onoff = (so->so_options & SO_LINGER) ? 1 : 0;
   1771      1.171    plunky 		l.l_linger = so->so_linger;
   1772      1.171    plunky 
   1773      1.171    plunky 		error = sockopt_set(sopt, &l, sizeof(l));
   1774      1.171    plunky 		break;
   1775      1.171    plunky 
   1776      1.171    plunky 	case SO_USELOOPBACK:
   1777      1.171    plunky 	case SO_DONTROUTE:
   1778      1.171    plunky 	case SO_DEBUG:
   1779      1.171    plunky 	case SO_KEEPALIVE:
   1780      1.171    plunky 	case SO_REUSEADDR:
   1781      1.171    plunky 	case SO_REUSEPORT:
   1782      1.171    plunky 	case SO_BROADCAST:
   1783      1.171    plunky 	case SO_OOBINLINE:
   1784      1.171    plunky 	case SO_TIMESTAMP:
   1785      1.171    plunky 		error = sockopt_setint(sopt,
   1786      1.171    plunky 		    (so->so_options & sopt->sopt_name) ? 1 : 0);
   1787      1.171    plunky 		break;
   1788      1.171    plunky 
   1789      1.171    plunky 	case SO_TYPE:
   1790      1.171    plunky 		error = sockopt_setint(sopt, so->so_type);
   1791      1.171    plunky 		break;
   1792      1.171    plunky 
   1793      1.171    plunky 	case SO_ERROR:
   1794      1.171    plunky 		error = sockopt_setint(sopt, so->so_error);
   1795      1.171    plunky 		so->so_error = 0;
   1796      1.171    plunky 		break;
   1797      1.171    plunky 
   1798      1.171    plunky 	case SO_SNDBUF:
   1799      1.171    plunky 		error = sockopt_setint(sopt, so->so_snd.sb_hiwat);
   1800      1.171    plunky 		break;
   1801      1.171    plunky 
   1802      1.171    plunky 	case SO_RCVBUF:
   1803      1.171    plunky 		error = sockopt_setint(sopt, so->so_rcv.sb_hiwat);
   1804      1.171    plunky 		break;
   1805      1.171    plunky 
   1806      1.171    plunky 	case SO_SNDLOWAT:
   1807      1.171    plunky 		error = sockopt_setint(sopt, so->so_snd.sb_lowat);
   1808      1.171    plunky 		break;
   1809      1.171    plunky 
   1810      1.171    plunky 	case SO_RCVLOWAT:
   1811      1.171    plunky 		error = sockopt_setint(sopt, so->so_rcv.sb_lowat);
   1812      1.171    plunky 		break;
   1813      1.171    plunky 
   1814      1.171    plunky 	case SO_SNDTIMEO:
   1815      1.171    plunky 	case SO_RCVTIMEO:
   1816      1.171    plunky 		optval = (sopt->sopt_name == SO_SNDTIMEO ?
   1817      1.171    plunky 		     so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
   1818      1.171    plunky 
   1819      1.171    plunky 		tv.tv_sec = optval / hz;
   1820      1.171    plunky 		tv.tv_usec = (optval % hz) * tick;
   1821      1.171    plunky 
   1822      1.171    plunky 		error = sockopt_set(sopt, &tv, sizeof(tv));
   1823      1.171    plunky 		break;
   1824      1.171    plunky 
   1825      1.171    plunky 	case SO_OVERFLOWED:
   1826      1.171    plunky 		error = sockopt_setint(sopt, so->so_rcv.sb_overflowed);
   1827      1.171    plunky 		break;
   1828      1.171    plunky 
   1829      1.171    plunky 	default:
   1830      1.171    plunky 		error = ENOPROTOOPT;
   1831      1.171    plunky 		break;
   1832      1.171    plunky 	}
   1833      1.171    plunky 
   1834      1.171    plunky 	return (error);
   1835      1.171    plunky }
   1836      1.171    plunky 
   1837       1.14   mycroft int
   1838      1.171    plunky sogetopt(struct socket *so, struct sockopt *sopt)
   1839        1.1       cgd {
   1840      1.160        ad 	int		error;
   1841        1.1       cgd 
   1842      1.160        ad 	solock(so);
   1843      1.171    plunky 	if (sopt->sopt_level != SOL_SOCKET) {
   1844        1.1       cgd 		if (so->so_proto && so->so_proto->pr_ctloutput) {
   1845      1.160        ad 			error = ((*so->so_proto->pr_ctloutput)
   1846      1.171    plunky 			    (PRCO_GETOPT, so, sopt));
   1847        1.1       cgd 		} else
   1848      1.160        ad 			error = (ENOPROTOOPT);
   1849        1.1       cgd 	} else {
   1850      1.171    plunky 		error = sogetopt1(so, sopt);
   1851      1.171    plunky 	}
   1852      1.171    plunky 	sounlock(so);
   1853      1.171    plunky 	return (error);
   1854      1.171    plunky }
   1855      1.171    plunky 
   1856      1.171    plunky /*
   1857      1.171    plunky  * alloc sockopt data buffer buffer
   1858      1.171    plunky  *	- will be released at destroy
   1859      1.171    plunky  */
   1860      1.176    plunky static int
   1861      1.176    plunky sockopt_alloc(struct sockopt *sopt, size_t len, km_flag_t kmflag)
   1862      1.171    plunky {
   1863      1.171    plunky 
   1864      1.171    plunky 	KASSERT(sopt->sopt_size == 0);
   1865      1.171    plunky 
   1866      1.176    plunky 	if (len > sizeof(sopt->sopt_buf)) {
   1867      1.176    plunky 		sopt->sopt_data = kmem_zalloc(len, kmflag);
   1868      1.176    plunky 		if (sopt->sopt_data == NULL)
   1869      1.176    plunky 			return ENOMEM;
   1870      1.176    plunky 	} else
   1871      1.171    plunky 		sopt->sopt_data = sopt->sopt_buf;
   1872      1.171    plunky 
   1873      1.171    plunky 	sopt->sopt_size = len;
   1874      1.176    plunky 	return 0;
   1875      1.171    plunky }
   1876      1.171    plunky 
   1877      1.171    plunky /*
   1878      1.171    plunky  * initialise sockopt storage
   1879      1.176    plunky  *	- MAY sleep during allocation
   1880      1.171    plunky  */
   1881      1.171    plunky void
   1882      1.171    plunky sockopt_init(struct sockopt *sopt, int level, int name, size_t size)
   1883      1.171    plunky {
   1884        1.1       cgd 
   1885      1.171    plunky 	memset(sopt, 0, sizeof(*sopt));
   1886        1.1       cgd 
   1887      1.171    plunky 	sopt->sopt_level = level;
   1888      1.171    plunky 	sopt->sopt_name = name;
   1889      1.176    plunky 	(void)sockopt_alloc(sopt, size, KM_SLEEP);
   1890      1.171    plunky }
   1891      1.171    plunky 
   1892      1.171    plunky /*
   1893      1.171    plunky  * destroy sockopt storage
   1894      1.171    plunky  *	- will release any held memory references
   1895      1.171    plunky  */
   1896      1.171    plunky void
   1897      1.171    plunky sockopt_destroy(struct sockopt *sopt)
   1898      1.171    plunky {
   1899      1.171    plunky 
   1900      1.171    plunky 	if (sopt->sopt_data != sopt->sopt_buf)
   1901      1.173    plunky 		kmem_free(sopt->sopt_data, sopt->sopt_size);
   1902      1.171    plunky 
   1903      1.171    plunky 	memset(sopt, 0, sizeof(*sopt));
   1904      1.171    plunky }
   1905      1.171    plunky 
   1906      1.171    plunky /*
   1907      1.171    plunky  * set sockopt value
   1908      1.171    plunky  *	- value is copied into sockopt
   1909      1.176    plunky  * 	- memory is allocated when necessary, will not sleep
   1910      1.171    plunky  */
   1911      1.171    plunky int
   1912      1.171    plunky sockopt_set(struct sockopt *sopt, const void *buf, size_t len)
   1913      1.171    plunky {
   1914      1.176    plunky 	int error;
   1915      1.171    plunky 
   1916      1.176    plunky 	if (sopt->sopt_size == 0) {
   1917      1.176    plunky 		error = sockopt_alloc(sopt, len, KM_NOSLEEP);
   1918      1.176    plunky 		if (error)
   1919      1.176    plunky 			return error;
   1920      1.176    plunky 	}
   1921      1.171    plunky 
   1922      1.171    plunky 	KASSERT(sopt->sopt_size == len);
   1923      1.171    plunky 	memcpy(sopt->sopt_data, buf, len);
   1924      1.171    plunky 	return 0;
   1925      1.171    plunky }
   1926      1.171    plunky 
   1927      1.171    plunky /*
   1928      1.171    plunky  * common case of set sockopt integer value
   1929      1.171    plunky  */
   1930      1.171    plunky int
   1931      1.171    plunky sockopt_setint(struct sockopt *sopt, int val)
   1932      1.171    plunky {
   1933      1.171    plunky 
   1934      1.171    plunky 	return sockopt_set(sopt, &val, sizeof(int));
   1935      1.171    plunky }
   1936      1.171    plunky 
   1937      1.171    plunky /*
   1938      1.171    plunky  * get sockopt value
   1939      1.171    plunky  *	- correct size must be given
   1940      1.171    plunky  */
   1941      1.171    plunky int
   1942      1.171    plunky sockopt_get(const struct sockopt *sopt, void *buf, size_t len)
   1943      1.171    plunky {
   1944      1.170       tls 
   1945      1.171    plunky 	if (sopt->sopt_size != len)
   1946      1.171    plunky 		return EINVAL;
   1947        1.1       cgd 
   1948      1.171    plunky 	memcpy(buf, sopt->sopt_data, len);
   1949      1.171    plunky 	return 0;
   1950      1.171    plunky }
   1951        1.1       cgd 
   1952      1.171    plunky /*
   1953      1.171    plunky  * common case of get sockopt integer value
   1954      1.171    plunky  */
   1955      1.171    plunky int
   1956      1.171    plunky sockopt_getint(const struct sockopt *sopt, int *valp)
   1957      1.171    plunky {
   1958        1.1       cgd 
   1959      1.171    plunky 	return sockopt_get(sopt, valp, sizeof(int));
   1960      1.171    plunky }
   1961        1.1       cgd 
   1962      1.171    plunky /*
   1963      1.171    plunky  * set sockopt value from mbuf
   1964      1.171    plunky  *	- ONLY for legacy code
   1965      1.171    plunky  *	- mbuf is released by sockopt
   1966      1.176    plunky  *	- will not sleep
   1967      1.171    plunky  */
   1968      1.171    plunky int
   1969      1.171    plunky sockopt_setmbuf(struct sockopt *sopt, struct mbuf *m)
   1970      1.171    plunky {
   1971      1.171    plunky 	size_t len;
   1972      1.176    plunky 	int error;
   1973        1.1       cgd 
   1974      1.171    plunky 	len = m_length(m);
   1975        1.1       cgd 
   1976      1.176    plunky 	if (sopt->sopt_size == 0) {
   1977      1.176    plunky 		error = sockopt_alloc(sopt, len, KM_NOSLEEP);
   1978      1.176    plunky 		if (error)
   1979      1.176    plunky 			return error;
   1980      1.176    plunky 	}
   1981        1.1       cgd 
   1982      1.171    plunky 	KASSERT(sopt->sopt_size == len);
   1983      1.171    plunky 	m_copydata(m, 0, len, sopt->sopt_data);
   1984      1.171    plunky 	m_freem(m);
   1985        1.1       cgd 
   1986      1.171    plunky 	return 0;
   1987      1.171    plunky }
   1988        1.1       cgd 
   1989      1.171    plunky /*
   1990      1.171    plunky  * get sockopt value into mbuf
   1991      1.171    plunky  *	- ONLY for legacy code
   1992      1.171    plunky  *	- mbuf to be released by the caller
   1993      1.176    plunky  *	- will not sleep
   1994      1.171    plunky  */
   1995      1.171    plunky struct mbuf *
   1996      1.171    plunky sockopt_getmbuf(const struct sockopt *sopt)
   1997      1.171    plunky {
   1998      1.171    plunky 	struct mbuf *m;
   1999      1.107   darrenr 
   2000      1.176    plunky 	if (sopt->sopt_size > MCLBYTES)
   2001      1.176    plunky 		return NULL;
   2002      1.176    plunky 
   2003      1.176    plunky 	m = m_get(M_DONTWAIT, MT_SOOPTS);
   2004      1.171    plunky 	if (m == NULL)
   2005      1.171    plunky 		return NULL;
   2006      1.171    plunky 
   2007      1.176    plunky 	if (sopt->sopt_size > MLEN) {
   2008      1.176    plunky 		MCLGET(m, M_DONTWAIT);
   2009      1.176    plunky 		if ((m->m_flags & M_EXT) == 0) {
   2010      1.176    plunky 			m_free(m);
   2011      1.176    plunky 			return NULL;
   2012      1.176    plunky 		}
   2013        1.1       cgd 	}
   2014      1.176    plunky 
   2015      1.176    plunky 	memcpy(mtod(m, void *), sopt->sopt_data, sopt->sopt_size);
   2016      1.176    plunky 	m->m_len = sopt->sopt_size;
   2017      1.160        ad 
   2018      1.171    plunky 	return m;
   2019        1.1       cgd }
   2020        1.1       cgd 
   2021       1.14   mycroft void
   2022       1.54     lukem sohasoutofband(struct socket *so)
   2023        1.1       cgd {
   2024      1.153     rmind 
   2025       1.90  christos 	fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);
   2026  1.177.4.3    bouyer 	selnotify(&so->so_rcv.sb_sel, POLLPRI | POLLRDBAND, NOTE_SUBMIT);
   2027        1.1       cgd }
   2028       1.72  jdolecek 
   2029       1.72  jdolecek static void
   2030       1.72  jdolecek filt_sordetach(struct knote *kn)
   2031       1.72  jdolecek {
   2032       1.72  jdolecek 	struct socket	*so;
   2033       1.72  jdolecek 
   2034      1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2035      1.160        ad 	solock(so);
   2036       1.73  christos 	SLIST_REMOVE(&so->so_rcv.sb_sel.sel_klist, kn, knote, kn_selnext);
   2037       1.73  christos 	if (SLIST_EMPTY(&so->so_rcv.sb_sel.sel_klist))
   2038       1.72  jdolecek 		so->so_rcv.sb_flags &= ~SB_KNOTE;
   2039      1.160        ad 	sounlock(so);
   2040       1.72  jdolecek }
   2041       1.72  jdolecek 
   2042       1.72  jdolecek /*ARGSUSED*/
   2043       1.72  jdolecek static int
   2044      1.129      yamt filt_soread(struct knote *kn, long hint)
   2045       1.72  jdolecek {
   2046       1.72  jdolecek 	struct socket	*so;
   2047      1.160        ad 	int rv;
   2048       1.72  jdolecek 
   2049      1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2050      1.160        ad 	if (hint != NOTE_SUBMIT)
   2051      1.160        ad 		solock(so);
   2052       1.72  jdolecek 	kn->kn_data = so->so_rcv.sb_cc;
   2053       1.72  jdolecek 	if (so->so_state & SS_CANTRCVMORE) {
   2054      1.108     perry 		kn->kn_flags |= EV_EOF;
   2055       1.72  jdolecek 		kn->kn_fflags = so->so_error;
   2056      1.160        ad 		rv = 1;
   2057      1.160        ad 	} else if (so->so_error)	/* temporary udp error */
   2058      1.160        ad 		rv = 1;
   2059      1.160        ad 	else if (kn->kn_sfflags & NOTE_LOWAT)
   2060      1.160        ad 		rv = (kn->kn_data >= kn->kn_sdata);
   2061      1.160        ad 	else
   2062      1.160        ad 		rv = (kn->kn_data >= so->so_rcv.sb_lowat);
   2063      1.160        ad 	if (hint != NOTE_SUBMIT)
   2064      1.160        ad 		sounlock(so);
   2065      1.160        ad 	return rv;
   2066       1.72  jdolecek }
   2067       1.72  jdolecek 
   2068       1.72  jdolecek static void
   2069       1.72  jdolecek filt_sowdetach(struct knote *kn)
   2070       1.72  jdolecek {
   2071       1.72  jdolecek 	struct socket	*so;
   2072       1.72  jdolecek 
   2073      1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2074      1.160        ad 	solock(so);
   2075       1.73  christos 	SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);
   2076       1.73  christos 	if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))
   2077       1.72  jdolecek 		so->so_snd.sb_flags &= ~SB_KNOTE;
   2078      1.160        ad 	sounlock(so);
   2079       1.72  jdolecek }
   2080       1.72  jdolecek 
   2081       1.72  jdolecek /*ARGSUSED*/
   2082       1.72  jdolecek static int
   2083      1.129      yamt filt_sowrite(struct knote *kn, long hint)
   2084       1.72  jdolecek {
   2085       1.72  jdolecek 	struct socket	*so;
   2086      1.160        ad 	int rv;
   2087       1.72  jdolecek 
   2088      1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2089      1.160        ad 	if (hint != NOTE_SUBMIT)
   2090      1.160        ad 		solock(so);
   2091       1.72  jdolecek 	kn->kn_data = sbspace(&so->so_snd);
   2092       1.72  jdolecek 	if (so->so_state & SS_CANTSENDMORE) {
   2093      1.108     perry 		kn->kn_flags |= EV_EOF;
   2094       1.72  jdolecek 		kn->kn_fflags = so->so_error;
   2095      1.160        ad 		rv = 1;
   2096      1.160        ad 	} else if (so->so_error)	/* temporary udp error */
   2097      1.160        ad 		rv = 1;
   2098      1.160        ad 	else if (((so->so_state & SS_ISCONNECTED) == 0) &&
   2099       1.72  jdolecek 	    (so->so_proto->pr_flags & PR_CONNREQUIRED))
   2100      1.160        ad 		rv = 0;
   2101      1.160        ad 	else if (kn->kn_sfflags & NOTE_LOWAT)
   2102      1.160        ad 		rv = (kn->kn_data >= kn->kn_sdata);
   2103      1.160        ad 	else
   2104      1.160        ad 		rv = (kn->kn_data >= so->so_snd.sb_lowat);
   2105      1.160        ad 	if (hint != NOTE_SUBMIT)
   2106      1.160        ad 		sounlock(so);
   2107      1.160        ad 	return rv;
   2108       1.72  jdolecek }
   2109       1.72  jdolecek 
   2110       1.72  jdolecek /*ARGSUSED*/
   2111       1.72  jdolecek static int
   2112      1.129      yamt filt_solisten(struct knote *kn, long hint)
   2113       1.72  jdolecek {
   2114       1.72  jdolecek 	struct socket	*so;
   2115      1.160        ad 	int rv;
   2116       1.72  jdolecek 
   2117      1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2118       1.72  jdolecek 
   2119       1.72  jdolecek 	/*
   2120       1.72  jdolecek 	 * Set kn_data to number of incoming connections, not
   2121       1.72  jdolecek 	 * counting partial (incomplete) connections.
   2122      1.108     perry 	 */
   2123      1.160        ad 	if (hint != NOTE_SUBMIT)
   2124      1.160        ad 		solock(so);
   2125       1.72  jdolecek 	kn->kn_data = so->so_qlen;
   2126      1.160        ad 	rv = (kn->kn_data > 0);
   2127      1.160        ad 	if (hint != NOTE_SUBMIT)
   2128      1.160        ad 		sounlock(so);
   2129      1.160        ad 	return rv;
   2130       1.72  jdolecek }
   2131       1.72  jdolecek 
   2132       1.72  jdolecek static const struct filterops solisten_filtops =
   2133       1.72  jdolecek 	{ 1, NULL, filt_sordetach, filt_solisten };
   2134       1.72  jdolecek static const struct filterops soread_filtops =
   2135       1.72  jdolecek 	{ 1, NULL, filt_sordetach, filt_soread };
   2136       1.72  jdolecek static const struct filterops sowrite_filtops =
   2137       1.72  jdolecek 	{ 1, NULL, filt_sowdetach, filt_sowrite };
   2138       1.72  jdolecek 
   2139       1.72  jdolecek int
   2140      1.129      yamt soo_kqfilter(struct file *fp, struct knote *kn)
   2141       1.72  jdolecek {
   2142       1.72  jdolecek 	struct socket	*so;
   2143       1.72  jdolecek 	struct sockbuf	*sb;
   2144       1.72  jdolecek 
   2145      1.155        ad 	so = ((file_t *)kn->kn_obj)->f_data;
   2146      1.160        ad 	solock(so);
   2147       1.72  jdolecek 	switch (kn->kn_filter) {
   2148       1.72  jdolecek 	case EVFILT_READ:
   2149       1.72  jdolecek 		if (so->so_options & SO_ACCEPTCONN)
   2150       1.72  jdolecek 			kn->kn_fop = &solisten_filtops;
   2151       1.72  jdolecek 		else
   2152       1.72  jdolecek 			kn->kn_fop = &soread_filtops;
   2153       1.72  jdolecek 		sb = &so->so_rcv;
   2154       1.72  jdolecek 		break;
   2155       1.72  jdolecek 	case EVFILT_WRITE:
   2156       1.72  jdolecek 		kn->kn_fop = &sowrite_filtops;
   2157       1.72  jdolecek 		sb = &so->so_snd;
   2158       1.72  jdolecek 		break;
   2159       1.72  jdolecek 	default:
   2160      1.160        ad 		sounlock(so);
   2161      1.149     pooka 		return (EINVAL);
   2162       1.72  jdolecek 	}
   2163       1.73  christos 	SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);
   2164       1.72  jdolecek 	sb->sb_flags |= SB_KNOTE;
   2165      1.160        ad 	sounlock(so);
   2166       1.72  jdolecek 	return (0);
   2167       1.72  jdolecek }
   2168       1.72  jdolecek 
   2169      1.154        ad static int
   2170      1.154        ad sodopoll(struct socket *so, int events)
   2171      1.154        ad {
   2172      1.154        ad 	int revents;
   2173      1.154        ad 
   2174      1.154        ad 	revents = 0;
   2175      1.154        ad 
   2176      1.154        ad 	if (events & (POLLIN | POLLRDNORM))
   2177      1.154        ad 		if (soreadable(so))
   2178      1.154        ad 			revents |= events & (POLLIN | POLLRDNORM);
   2179      1.154        ad 
   2180      1.154        ad 	if (events & (POLLOUT | POLLWRNORM))
   2181      1.154        ad 		if (sowritable(so))
   2182      1.154        ad 			revents |= events & (POLLOUT | POLLWRNORM);
   2183      1.154        ad 
   2184      1.154        ad 	if (events & (POLLPRI | POLLRDBAND))
   2185      1.154        ad 		if (so->so_oobmark || (so->so_state & SS_RCVATMARK))
   2186      1.154        ad 			revents |= events & (POLLPRI | POLLRDBAND);
   2187      1.154        ad 
   2188      1.154        ad 	return revents;
   2189      1.154        ad }
   2190      1.154        ad 
   2191      1.154        ad int
   2192      1.154        ad sopoll(struct socket *so, int events)
   2193      1.154        ad {
   2194      1.154        ad 	int revents = 0;
   2195      1.154        ad 
   2196      1.160        ad #ifndef DIAGNOSTIC
   2197      1.160        ad 	/*
   2198      1.160        ad 	 * Do a quick, unlocked check in expectation that the socket
   2199      1.160        ad 	 * will be ready for I/O.  Don't do this check if DIAGNOSTIC,
   2200      1.160        ad 	 * as the solocked() assertions will fail.
   2201      1.160        ad 	 */
   2202      1.154        ad 	if ((revents = sodopoll(so, events)) != 0)
   2203      1.154        ad 		return revents;
   2204      1.160        ad #endif
   2205      1.154        ad 
   2206      1.160        ad 	solock(so);
   2207      1.154        ad 	if ((revents = sodopoll(so, events)) == 0) {
   2208      1.154        ad 		if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {
   2209      1.154        ad 			selrecord(curlwp, &so->so_rcv.sb_sel);
   2210      1.160        ad 			so->so_rcv.sb_flags |= SB_NOTIFY;
   2211      1.154        ad 		}
   2212      1.154        ad 
   2213      1.154        ad 		if (events & (POLLOUT | POLLWRNORM)) {
   2214      1.154        ad 			selrecord(curlwp, &so->so_snd.sb_sel);
   2215      1.160        ad 			so->so_snd.sb_flags |= SB_NOTIFY;
   2216      1.154        ad 		}
   2217      1.154        ad 	}
   2218      1.160        ad 	sounlock(so);
   2219      1.154        ad 
   2220      1.154        ad 	return revents;
   2221      1.154        ad }
   2222      1.154        ad 
   2223      1.154        ad 
   2224       1.94      yamt #include <sys/sysctl.h>
   2225       1.94      yamt 
   2226       1.94      yamt static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);
   2227       1.94      yamt 
   2228       1.94      yamt /*
   2229       1.94      yamt  * sysctl helper routine for kern.somaxkva.  ensures that the given
   2230       1.94      yamt  * value is not too small.
   2231       1.94      yamt  * (XXX should we maybe make sure it's not too large as well?)
   2232       1.94      yamt  */
   2233       1.94      yamt static int
   2234       1.94      yamt sysctl_kern_somaxkva(SYSCTLFN_ARGS)
   2235       1.94      yamt {
   2236       1.94      yamt 	int error, new_somaxkva;
   2237       1.94      yamt 	struct sysctlnode node;
   2238       1.94      yamt 
   2239       1.94      yamt 	new_somaxkva = somaxkva;
   2240       1.94      yamt 	node = *rnode;
   2241       1.94      yamt 	node.sysctl_data = &new_somaxkva;
   2242       1.94      yamt 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   2243       1.94      yamt 	if (error || newp == NULL)
   2244       1.94      yamt 		return (error);
   2245       1.94      yamt 
   2246       1.94      yamt 	if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */
   2247       1.94      yamt 		return (EINVAL);
   2248       1.94      yamt 
   2249      1.136        ad 	mutex_enter(&so_pendfree_lock);
   2250       1.94      yamt 	somaxkva = new_somaxkva;
   2251      1.136        ad 	cv_broadcast(&socurkva_cv);
   2252      1.136        ad 	mutex_exit(&so_pendfree_lock);
   2253       1.94      yamt 
   2254       1.94      yamt 	return (error);
   2255       1.94      yamt }
   2256       1.94      yamt 
   2257       1.94      yamt SYSCTL_SETUP(sysctl_kern_somaxkva_setup, "sysctl kern.somaxkva setup")
   2258       1.94      yamt {
   2259       1.94      yamt 
   2260       1.97    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   2261       1.97    atatat 		       CTLFLAG_PERMANENT,
   2262       1.97    atatat 		       CTLTYPE_NODE, "kern", NULL,
   2263       1.97    atatat 		       NULL, 0, NULL, 0,
   2264       1.97    atatat 		       CTL_KERN, CTL_EOL);
   2265       1.97    atatat 
   2266       1.97    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   2267       1.97    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   2268      1.103    atatat 		       CTLTYPE_INT, "somaxkva",
   2269      1.103    atatat 		       SYSCTL_DESCR("Maximum amount of kernel memory to be "
   2270      1.103    atatat 				    "used for socket buffers"),
   2271       1.94      yamt 		       sysctl_kern_somaxkva, 0, NULL, 0,
   2272       1.94      yamt 		       CTL_KERN, KERN_SOMAXKVA, CTL_EOL);
   2273       1.94      yamt }
   2274