Home | History | Annotate | Line # | Download | only in kern
uipc_socket.c revision 1.115.6.2
      1  1.115.6.2    kardel /*	$NetBSD: uipc_socket.c,v 1.115.6.2 2006/06/01 22:38:09 kardel Exp $	*/
      2       1.64   thorpej 
      3       1.64   thorpej /*-
      4       1.64   thorpej  * Copyright (c) 2002 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.64   thorpej  * by Jason R. Thorpe of Wasabi Systems, Inc.
      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  * 3. All advertising materials mentioning features or use of this software
     19       1.64   thorpej  *    must display the following acknowledgement:
     20       1.64   thorpej  *	This product includes software developed by the NetBSD
     21       1.64   thorpej  *	Foundation, Inc. and its contributors.
     22       1.64   thorpej  * 4. Neither the name of The NetBSD Foundation nor the names of its
     23       1.64   thorpej  *    contributors may be used to endorse or promote products derived
     24       1.64   thorpej  *    from this software without specific prior written permission.
     25       1.64   thorpej  *
     26       1.64   thorpej  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     27       1.64   thorpej  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     28       1.64   thorpej  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     29       1.64   thorpej  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     30       1.64   thorpej  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     31       1.64   thorpej  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     32       1.64   thorpej  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     33       1.64   thorpej  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     34       1.64   thorpej  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     35       1.64   thorpej  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     36       1.64   thorpej  * POSSIBILITY OF SUCH DAMAGE.
     37       1.64   thorpej  */
     38       1.16       cgd 
     39        1.1       cgd /*
     40       1.15   mycroft  * Copyright (c) 1982, 1986, 1988, 1990, 1993
     41       1.15   mycroft  *	The Regents of the University of California.  All rights reserved.
     42        1.1       cgd  *
     43        1.1       cgd  * Redistribution and use in source and binary forms, with or without
     44        1.1       cgd  * modification, are permitted provided that the following conditions
     45        1.1       cgd  * are met:
     46        1.1       cgd  * 1. Redistributions of source code must retain the above copyright
     47        1.1       cgd  *    notice, this list of conditions and the following disclaimer.
     48        1.1       cgd  * 2. Redistributions in binary form must reproduce the above copyright
     49        1.1       cgd  *    notice, this list of conditions and the following disclaimer in the
     50        1.1       cgd  *    documentation and/or other materials provided with the distribution.
     51       1.85       agc  * 3. Neither the name of the University nor the names of its contributors
     52        1.1       cgd  *    may be used to endorse or promote products derived from this software
     53        1.1       cgd  *    without specific prior written permission.
     54        1.1       cgd  *
     55        1.1       cgd  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     56        1.1       cgd  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     57        1.1       cgd  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     58        1.1       cgd  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     59        1.1       cgd  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     60        1.1       cgd  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     61        1.1       cgd  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     62        1.1       cgd  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     63        1.1       cgd  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     64        1.1       cgd  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     65        1.1       cgd  * SUCH DAMAGE.
     66        1.1       cgd  *
     67       1.32      fvdl  *	@(#)uipc_socket.c	8.6 (Berkeley) 5/2/95
     68        1.1       cgd  */
     69       1.59     lukem 
     70       1.59     lukem #include <sys/cdefs.h>
     71  1.115.6.2    kardel __KERNEL_RCSID(0, "$NetBSD: uipc_socket.c,v 1.115.6.2 2006/06/01 22:38:09 kardel Exp $");
     72       1.64   thorpej 
     73       1.64   thorpej #include "opt_sock_counters.h"
     74       1.64   thorpej #include "opt_sosend_loan.h"
     75       1.81    martin #include "opt_mbuftrace.h"
     76       1.84     ragge #include "opt_somaxkva.h"
     77        1.1       cgd 
     78        1.9   mycroft #include <sys/param.h>
     79        1.9   mycroft #include <sys/systm.h>
     80        1.9   mycroft #include <sys/proc.h>
     81        1.9   mycroft #include <sys/file.h>
     82        1.9   mycroft #include <sys/malloc.h>
     83        1.9   mycroft #include <sys/mbuf.h>
     84        1.9   mycroft #include <sys/domain.h>
     85        1.9   mycroft #include <sys/kernel.h>
     86        1.9   mycroft #include <sys/protosw.h>
     87        1.9   mycroft #include <sys/socket.h>
     88        1.9   mycroft #include <sys/socketvar.h>
     89       1.21  christos #include <sys/signalvar.h>
     90        1.9   mycroft #include <sys/resourcevar.h>
     91       1.37   thorpej #include <sys/pool.h>
     92       1.72  jdolecek #include <sys/event.h>
     93       1.89  christos #include <sys/poll.h>
     94  1.115.6.2    kardel #include <sys/kauth.h>
     95       1.37   thorpej 
     96       1.64   thorpej #include <uvm/uvm.h>
     97       1.64   thorpej 
     98      1.100    simonb POOL_INIT(socket_pool, sizeof(struct socket), 0, 0, 0, "sockpl", NULL);
     99       1.77   thorpej 
    100       1.77   thorpej MALLOC_DEFINE(M_SOOPTS, "soopts", "socket options");
    101       1.77   thorpej MALLOC_DEFINE(M_SONAME, "soname", "socket name");
    102       1.37   thorpej 
    103       1.54     lukem extern int	somaxconn;			/* patchable (XXX sysctl) */
    104       1.54     lukem int		somaxconn = SOMAXCONN;
    105       1.49  jonathan 
    106       1.64   thorpej #ifdef SOSEND_COUNTERS
    107       1.64   thorpej #include <sys/device.h>
    108       1.64   thorpej 
    109      1.113   thorpej static struct evcnt sosend_loan_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    110       1.64   thorpej     NULL, "sosend", "loan big");
    111      1.113   thorpej static struct evcnt sosend_copy_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    112       1.64   thorpej     NULL, "sosend", "copy big");
    113      1.113   thorpej static struct evcnt sosend_copy_small = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    114       1.64   thorpej     NULL, "sosend", "copy small");
    115      1.113   thorpej static struct evcnt sosend_kvalimit = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,
    116       1.64   thorpej     NULL, "sosend", "kva limit");
    117       1.64   thorpej 
    118       1.64   thorpej #define	SOSEND_COUNTER_INCR(ev)		(ev)->ev_count++
    119       1.64   thorpej 
    120      1.101      matt EVCNT_ATTACH_STATIC(sosend_loan_big);
    121      1.101      matt EVCNT_ATTACH_STATIC(sosend_copy_big);
    122      1.101      matt EVCNT_ATTACH_STATIC(sosend_copy_small);
    123      1.101      matt EVCNT_ATTACH_STATIC(sosend_kvalimit);
    124       1.64   thorpej #else
    125       1.64   thorpej 
    126       1.64   thorpej #define	SOSEND_COUNTER_INCR(ev)		/* nothing */
    127       1.64   thorpej 
    128       1.64   thorpej #endif /* SOSEND_COUNTERS */
    129       1.64   thorpej 
    130  1.115.6.2    kardel static struct callback_entry sokva_reclaimerentry;
    131        1.1       cgd 
    132       1.71   thorpej #ifdef SOSEND_NO_LOAN
    133       1.71   thorpej int use_sosend_loan = 0;
    134       1.71   thorpej #else
    135       1.65   thorpej int use_sosend_loan = 1;
    136       1.65   thorpej #endif
    137       1.64   thorpej 
    138      1.113   thorpej static struct simplelock so_pendfree_slock = SIMPLELOCK_INITIALIZER;
    139      1.113   thorpej static struct mbuf *so_pendfree;
    140       1.64   thorpej 
    141       1.84     ragge #ifndef SOMAXKVA
    142       1.84     ragge #define	SOMAXKVA (16 * 1024 * 1024)
    143       1.84     ragge #endif
    144       1.84     ragge int somaxkva = SOMAXKVA;
    145      1.113   thorpej static int socurkva;
    146      1.113   thorpej static int sokvawaiters;
    147       1.64   thorpej 
    148       1.64   thorpej #define	SOCK_LOAN_THRESH	4096
    149       1.64   thorpej #define	SOCK_LOAN_CHUNK		65536
    150       1.64   thorpej 
    151  1.115.6.1    simonb static size_t sodopendfree(void);
    152  1.115.6.1    simonb static size_t sodopendfreel(void);
    153       1.93      yamt 
    154      1.113   thorpej static vsize_t
    155       1.95      yamt sokvareserve(struct socket *so, vsize_t len)
    156       1.80      yamt {
    157       1.80      yamt 	int s;
    158       1.98  christos 	int error;
    159       1.80      yamt 
    160       1.93      yamt 	s = splvm();
    161       1.93      yamt 	simple_lock(&so_pendfree_slock);
    162       1.80      yamt 	while (socurkva + len > somaxkva) {
    163       1.93      yamt 		size_t freed;
    164       1.93      yamt 
    165       1.93      yamt 		/*
    166       1.93      yamt 		 * try to do pendfree.
    167       1.93      yamt 		 */
    168       1.93      yamt 
    169  1.115.6.1    simonb 		freed = sodopendfreel();
    170       1.93      yamt 
    171       1.93      yamt 		/*
    172       1.93      yamt 		 * if some kva was freed, try again.
    173       1.93      yamt 		 */
    174       1.93      yamt 
    175       1.93      yamt 		if (freed)
    176       1.80      yamt 			continue;
    177       1.93      yamt 
    178       1.80      yamt 		SOSEND_COUNTER_INCR(&sosend_kvalimit);
    179       1.80      yamt 		sokvawaiters++;
    180       1.98  christos 		error = ltsleep(&socurkva, PVM | PCATCH, "sokva", 0,
    181       1.98  christos 		    &so_pendfree_slock);
    182       1.80      yamt 		sokvawaiters--;
    183       1.98  christos 		if (error) {
    184       1.98  christos 			len = 0;
    185       1.98  christos 			break;
    186       1.98  christos 		}
    187       1.80      yamt 	}
    188       1.93      yamt 	socurkva += len;
    189       1.93      yamt 	simple_unlock(&so_pendfree_slock);
    190       1.93      yamt 	splx(s);
    191       1.98  christos 	return len;
    192       1.95      yamt }
    193       1.95      yamt 
    194      1.113   thorpej static void
    195       1.95      yamt sokvaunreserve(vsize_t len)
    196       1.95      yamt {
    197       1.95      yamt 	int s;
    198       1.95      yamt 
    199       1.95      yamt 	s = splvm();
    200       1.95      yamt 	simple_lock(&so_pendfree_slock);
    201       1.95      yamt 	socurkva -= len;
    202       1.95      yamt 	if (sokvawaiters)
    203       1.95      yamt 		wakeup(&socurkva);
    204       1.95      yamt 	simple_unlock(&so_pendfree_slock);
    205       1.95      yamt 	splx(s);
    206       1.95      yamt }
    207       1.95      yamt 
    208       1.95      yamt /*
    209       1.95      yamt  * sokvaalloc: allocate kva for loan.
    210       1.95      yamt  */
    211       1.95      yamt 
    212       1.95      yamt vaddr_t
    213       1.95      yamt sokvaalloc(vsize_t len, struct socket *so)
    214       1.95      yamt {
    215       1.95      yamt 	vaddr_t lva;
    216       1.95      yamt 
    217       1.95      yamt 	/*
    218       1.95      yamt 	 * reserve kva.
    219       1.95      yamt 	 */
    220       1.95      yamt 
    221       1.98  christos 	if (sokvareserve(so, len) == 0)
    222       1.98  christos 		return 0;
    223       1.93      yamt 
    224       1.93      yamt 	/*
    225       1.93      yamt 	 * allocate kva.
    226       1.93      yamt 	 */
    227       1.80      yamt 
    228      1.109      yamt 	lva = uvm_km_alloc(kernel_map, len, 0, UVM_KMF_VAONLY | UVM_KMF_WAITVA);
    229       1.95      yamt 	if (lva == 0) {
    230       1.95      yamt 		sokvaunreserve(len);
    231       1.80      yamt 		return (0);
    232       1.95      yamt 	}
    233       1.80      yamt 
    234       1.80      yamt 	return lva;
    235       1.80      yamt }
    236       1.80      yamt 
    237       1.93      yamt /*
    238       1.93      yamt  * sokvafree: free kva for loan.
    239       1.93      yamt  */
    240       1.93      yamt 
    241       1.80      yamt void
    242       1.80      yamt sokvafree(vaddr_t sva, vsize_t len)
    243       1.80      yamt {
    244       1.93      yamt 
    245       1.93      yamt 	/*
    246       1.93      yamt 	 * free kva.
    247       1.93      yamt 	 */
    248       1.80      yamt 
    249      1.109      yamt 	uvm_km_free(kernel_map, sva, len, UVM_KMF_VAONLY);
    250       1.93      yamt 
    251       1.93      yamt 	/*
    252       1.93      yamt 	 * unreserve kva.
    253       1.93      yamt 	 */
    254       1.93      yamt 
    255       1.95      yamt 	sokvaunreserve(len);
    256       1.80      yamt }
    257       1.80      yamt 
    258       1.64   thorpej static void
    259       1.79   thorpej sodoloanfree(struct vm_page **pgs, caddr_t buf, size_t size)
    260       1.64   thorpej {
    261       1.64   thorpej 	vaddr_t va, sva, eva;
    262       1.64   thorpej 	vsize_t len;
    263       1.64   thorpej 	paddr_t pa;
    264       1.64   thorpej 	int i, npgs;
    265       1.64   thorpej 
    266       1.64   thorpej 	eva = round_page((vaddr_t) buf + size);
    267       1.64   thorpej 	sva = trunc_page((vaddr_t) buf);
    268       1.64   thorpej 	len = eva - sva;
    269       1.64   thorpej 	npgs = len >> PAGE_SHIFT;
    270       1.64   thorpej 
    271       1.79   thorpej 	if (__predict_false(pgs == NULL)) {
    272       1.79   thorpej 		pgs = alloca(npgs * sizeof(*pgs));
    273       1.64   thorpej 
    274       1.79   thorpej 		for (i = 0, va = sva; va < eva; i++, va += PAGE_SIZE) {
    275       1.79   thorpej 			if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)
    276       1.79   thorpej 				panic("sodoloanfree: va 0x%lx not mapped", va);
    277       1.79   thorpej 			pgs[i] = PHYS_TO_VM_PAGE(pa);
    278       1.79   thorpej 		}
    279       1.64   thorpej 	}
    280       1.64   thorpej 
    281       1.64   thorpej 	pmap_kremove(sva, len);
    282       1.64   thorpej 	pmap_update(pmap_kernel());
    283       1.64   thorpej 	uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);
    284       1.80      yamt 	sokvafree(sva, len);
    285       1.64   thorpej }
    286       1.64   thorpej 
    287       1.64   thorpej static size_t
    288  1.115.6.1    simonb sodopendfree()
    289       1.64   thorpej {
    290       1.64   thorpej 	int s;
    291       1.93      yamt 	size_t rv;
    292       1.64   thorpej 
    293       1.64   thorpej 	s = splvm();
    294       1.93      yamt 	simple_lock(&so_pendfree_slock);
    295  1.115.6.1    simonb 	rv = sodopendfreel();
    296       1.93      yamt 	simple_unlock(&so_pendfree_slock);
    297       1.93      yamt 	splx(s);
    298       1.93      yamt 
    299       1.93      yamt 	return rv;
    300       1.93      yamt }
    301       1.93      yamt 
    302       1.93      yamt /*
    303       1.93      yamt  * sodopendfreel: free mbufs on "pendfree" list.
    304       1.93      yamt  * unlock and relock so_pendfree_slock when freeing mbufs.
    305       1.93      yamt  *
    306       1.93      yamt  * => called with so_pendfree_slock held.
    307       1.93      yamt  * => called at splvm.
    308       1.93      yamt  */
    309       1.93      yamt 
    310       1.93      yamt static size_t
    311  1.115.6.1    simonb sodopendfreel()
    312       1.93      yamt {
    313       1.93      yamt 	size_t rv = 0;
    314       1.93      yamt 
    315       1.93      yamt 	LOCK_ASSERT(simple_lock_held(&so_pendfree_slock));
    316       1.64   thorpej 
    317       1.64   thorpej 	for (;;) {
    318       1.93      yamt 		struct mbuf *m;
    319       1.93      yamt 		struct mbuf *next;
    320       1.93      yamt 
    321       1.64   thorpej 		m = so_pendfree;
    322       1.64   thorpej 		if (m == NULL)
    323       1.64   thorpej 			break;
    324       1.93      yamt 		so_pendfree = NULL;
    325       1.93      yamt 		simple_unlock(&so_pendfree_slock);
    326       1.93      yamt 		/* XXX splx */
    327       1.93      yamt 
    328       1.93      yamt 		for (; m != NULL; m = next) {
    329       1.93      yamt 			next = m->m_next;
    330       1.93      yamt 
    331       1.93      yamt 			rv += m->m_ext.ext_size;
    332       1.93      yamt 			sodoloanfree((m->m_flags & M_EXT_PAGES) ?
    333       1.93      yamt 			    m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,
    334       1.93      yamt 			    m->m_ext.ext_size);
    335       1.93      yamt 			pool_cache_put(&mbpool_cache, m);
    336       1.93      yamt 		}
    337       1.64   thorpej 
    338       1.93      yamt 		/* XXX splvm */
    339       1.93      yamt 		simple_lock(&so_pendfree_slock);
    340       1.64   thorpej 	}
    341       1.64   thorpej 
    342       1.64   thorpej 	return (rv);
    343       1.64   thorpej }
    344       1.64   thorpej 
    345       1.80      yamt void
    346       1.76   thorpej soloanfree(struct mbuf *m, caddr_t buf, size_t size, void *arg)
    347       1.64   thorpej {
    348       1.64   thorpej 	int s;
    349       1.64   thorpej 
    350       1.64   thorpej 	if (m == NULL) {
    351       1.93      yamt 
    352       1.93      yamt 		/*
    353       1.93      yamt 		 * called from MEXTREMOVE.
    354       1.93      yamt 		 */
    355       1.93      yamt 
    356       1.79   thorpej 		sodoloanfree(NULL, buf, size);
    357       1.64   thorpej 		return;
    358       1.64   thorpej 	}
    359       1.64   thorpej 
    360       1.93      yamt 	/*
    361       1.93      yamt 	 * postpone freeing mbuf.
    362       1.93      yamt 	 *
    363       1.93      yamt 	 * we can't do it in interrupt context
    364       1.93      yamt 	 * because we need to put kva back to kernel_map.
    365       1.93      yamt 	 */
    366       1.93      yamt 
    367       1.64   thorpej 	s = splvm();
    368       1.93      yamt 	simple_lock(&so_pendfree_slock);
    369       1.92      yamt 	m->m_next = so_pendfree;
    370       1.92      yamt 	so_pendfree = m;
    371       1.64   thorpej 	if (sokvawaiters)
    372       1.64   thorpej 		wakeup(&socurkva);
    373       1.93      yamt 	simple_unlock(&so_pendfree_slock);
    374       1.93      yamt 	splx(s);
    375       1.64   thorpej }
    376       1.64   thorpej 
    377       1.64   thorpej static long
    378       1.64   thorpej sosend_loan(struct socket *so, struct uio *uio, struct mbuf *m, long space)
    379       1.64   thorpej {
    380       1.64   thorpej 	struct iovec *iov = uio->uio_iov;
    381       1.64   thorpej 	vaddr_t sva, eva;
    382       1.64   thorpej 	vsize_t len;
    383       1.64   thorpej 	vaddr_t lva, va;
    384       1.80      yamt 	int npgs, i, error;
    385       1.64   thorpej 
    386  1.115.6.1    simonb 	if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))
    387       1.64   thorpej 		return (0);
    388       1.64   thorpej 
    389       1.64   thorpej 	if (iov->iov_len < (size_t) space)
    390       1.64   thorpej 		space = iov->iov_len;
    391       1.64   thorpej 	if (space > SOCK_LOAN_CHUNK)
    392       1.64   thorpej 		space = SOCK_LOAN_CHUNK;
    393       1.64   thorpej 
    394       1.64   thorpej 	eva = round_page((vaddr_t) iov->iov_base + space);
    395       1.64   thorpej 	sva = trunc_page((vaddr_t) iov->iov_base);
    396       1.64   thorpej 	len = eva - sva;
    397       1.64   thorpej 	npgs = len >> PAGE_SHIFT;
    398       1.64   thorpej 
    399       1.79   thorpej 	/* XXX KDASSERT */
    400       1.79   thorpej 	KASSERT(npgs <= M_EXT_MAXPAGES);
    401       1.79   thorpej 
    402       1.80      yamt 	lva = sokvaalloc(len, so);
    403       1.64   thorpej 	if (lva == 0)
    404       1.80      yamt 		return 0;
    405       1.64   thorpej 
    406  1.115.6.1    simonb 	error = uvm_loan(&uio->uio_vmspace->vm_map, sva, len,
    407       1.79   thorpej 	    m->m_ext.ext_pgs, UVM_LOAN_TOPAGE);
    408       1.64   thorpej 	if (error) {
    409       1.80      yamt 		sokvafree(lva, len);
    410       1.64   thorpej 		return (0);
    411       1.64   thorpej 	}
    412       1.64   thorpej 
    413       1.64   thorpej 	for (i = 0, va = lva; i < npgs; i++, va += PAGE_SIZE)
    414       1.79   thorpej 		pmap_kenter_pa(va, VM_PAGE_TO_PHYS(m->m_ext.ext_pgs[i]),
    415       1.79   thorpej 		    VM_PROT_READ);
    416       1.64   thorpej 	pmap_update(pmap_kernel());
    417       1.64   thorpej 
    418       1.64   thorpej 	lva += (vaddr_t) iov->iov_base & PAGE_MASK;
    419       1.64   thorpej 
    420       1.64   thorpej 	MEXTADD(m, (caddr_t) lva, space, M_MBUF, soloanfree, so);
    421       1.79   thorpej 	m->m_flags |= M_EXT_PAGES | M_EXT_ROMAP;
    422       1.64   thorpej 
    423       1.64   thorpej 	uio->uio_resid -= space;
    424       1.64   thorpej 	/* uio_offset not updated, not set/used for write(2) */
    425       1.64   thorpej 	uio->uio_iov->iov_base = (caddr_t) uio->uio_iov->iov_base + space;
    426       1.64   thorpej 	uio->uio_iov->iov_len -= space;
    427       1.64   thorpej 	if (uio->uio_iov->iov_len == 0) {
    428       1.64   thorpej 		uio->uio_iov++;
    429       1.64   thorpej 		uio->uio_iovcnt--;
    430       1.64   thorpej 	}
    431       1.64   thorpej 
    432       1.64   thorpej 	return (space);
    433       1.64   thorpej }
    434       1.64   thorpej 
    435  1.115.6.2    kardel static int
    436  1.115.6.2    kardel sokva_reclaim_callback(struct callback_entry *ce, void *obj, void *arg)
    437  1.115.6.2    kardel {
    438  1.115.6.2    kardel 
    439  1.115.6.2    kardel 	KASSERT(ce == &sokva_reclaimerentry);
    440  1.115.6.2    kardel 	KASSERT(obj == NULL);
    441  1.115.6.2    kardel 
    442  1.115.6.2    kardel 	sodopendfree();
    443  1.115.6.2    kardel 	if (!vm_map_starved_p(kernel_map)) {
    444  1.115.6.2    kardel 		return CALLBACK_CHAIN_ABORT;
    445  1.115.6.2    kardel 	}
    446  1.115.6.2    kardel 	return CALLBACK_CHAIN_CONTINUE;
    447  1.115.6.2    kardel }
    448  1.115.6.2    kardel 
    449  1.115.6.2    kardel void
    450  1.115.6.2    kardel soinit(void)
    451  1.115.6.2    kardel {
    452  1.115.6.2    kardel 
    453  1.115.6.2    kardel 	/* Set the initial adjusted socket buffer size. */
    454  1.115.6.2    kardel 	if (sb_max_set(sb_max))
    455  1.115.6.2    kardel 		panic("bad initial sb_max value: %lu", sb_max);
    456  1.115.6.2    kardel 
    457  1.115.6.2    kardel 	callback_register(&vm_map_to_kernel(kernel_map)->vmk_reclaim_callback,
    458  1.115.6.2    kardel 	    &sokva_reclaimerentry, NULL, sokva_reclaim_callback);
    459  1.115.6.2    kardel }
    460  1.115.6.2    kardel 
    461        1.1       cgd /*
    462        1.1       cgd  * Socket operation routines.
    463        1.1       cgd  * These routines are called by the routines in
    464        1.1       cgd  * sys_socket.c or from a system process, and
    465        1.1       cgd  * implement the semantics of socket operations by
    466        1.1       cgd  * switching out to the protocol specific routines.
    467        1.1       cgd  */
    468        1.1       cgd /*ARGSUSED*/
    469        1.3    andrew int
    470      1.114  christos socreate(int dom, struct socket **aso, int type, int proto, struct lwp *l)
    471        1.1       cgd {
    472       1.99      matt 	const struct protosw	*prp;
    473       1.54     lukem 	struct socket	*so;
    474      1.115      yamt 	uid_t		uid;
    475       1.54     lukem 	int		error, s;
    476        1.1       cgd 
    477        1.1       cgd 	if (proto)
    478        1.1       cgd 		prp = pffindproto(dom, proto, type);
    479        1.1       cgd 	else
    480        1.1       cgd 		prp = pffindtype(dom, type);
    481       1.15   mycroft 	if (prp == 0 || prp->pr_usrreq == 0)
    482        1.1       cgd 		return (EPROTONOSUPPORT);
    483        1.1       cgd 	if (prp->pr_type != type)
    484        1.1       cgd 		return (EPROTOTYPE);
    485       1.39      matt 	s = splsoftnet();
    486       1.37   thorpej 	so = pool_get(&socket_pool, PR_WAITOK);
    487       1.38     perry 	memset((caddr_t)so, 0, sizeof(*so));
    488       1.31   thorpej 	TAILQ_INIT(&so->so_q0);
    489       1.31   thorpej 	TAILQ_INIT(&so->so_q);
    490        1.1       cgd 	so->so_type = type;
    491        1.1       cgd 	so->so_proto = prp;
    492       1.33      matt 	so->so_send = sosend;
    493       1.33      matt 	so->so_receive = soreceive;
    494       1.78      matt #ifdef MBUFTRACE
    495       1.78      matt 	so->so_rcv.sb_mowner = &prp->pr_domain->dom_mowner;
    496       1.78      matt 	so->so_snd.sb_mowner = &prp->pr_domain->dom_mowner;
    497       1.78      matt 	so->so_mowner = &prp->pr_domain->dom_mowner;
    498       1.78      matt #endif
    499      1.115      yamt 	if (l != NULL) {
    500  1.115.6.2    kardel 		uid = kauth_cred_geteuid(l->l_proc->p_cred);
    501      1.115      yamt 	} else {
    502      1.115      yamt 		uid = 0;
    503      1.115      yamt 	}
    504      1.115      yamt 	so->so_uidinfo = uid_find(uid);
    505       1.22   mycroft 	error = (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,
    506      1.114  christos 	    (struct mbuf *)(long)proto, (struct mbuf *)0, l);
    507        1.1       cgd 	if (error) {
    508        1.1       cgd 		so->so_state |= SS_NOFDREF;
    509        1.1       cgd 		sofree(so);
    510       1.39      matt 		splx(s);
    511        1.1       cgd 		return (error);
    512        1.1       cgd 	}
    513       1.39      matt 	splx(s);
    514        1.1       cgd 	*aso = so;
    515        1.1       cgd 	return (0);
    516        1.1       cgd }
    517        1.1       cgd 
    518        1.3    andrew int
    519      1.114  christos sobind(struct socket *so, struct mbuf *nam, struct lwp *l)
    520        1.1       cgd {
    521       1.54     lukem 	int	s, error;
    522        1.1       cgd 
    523       1.54     lukem 	s = splsoftnet();
    524       1.22   mycroft 	error = (*so->so_proto->pr_usrreq)(so, PRU_BIND, (struct mbuf *)0,
    525      1.114  christos 	    nam, (struct mbuf *)0, l);
    526        1.1       cgd 	splx(s);
    527        1.1       cgd 	return (error);
    528        1.1       cgd }
    529        1.1       cgd 
    530        1.3    andrew int
    531       1.54     lukem solisten(struct socket *so, int backlog)
    532        1.1       cgd {
    533       1.54     lukem 	int	s, error;
    534        1.1       cgd 
    535       1.54     lukem 	s = splsoftnet();
    536       1.22   mycroft 	error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, (struct mbuf *)0,
    537      1.114  christos 	    (struct mbuf *)0, (struct mbuf *)0, (struct lwp *)0);
    538        1.1       cgd 	if (error) {
    539        1.1       cgd 		splx(s);
    540        1.1       cgd 		return (error);
    541        1.1       cgd 	}
    542       1.63      matt 	if (TAILQ_EMPTY(&so->so_q))
    543        1.1       cgd 		so->so_options |= SO_ACCEPTCONN;
    544        1.1       cgd 	if (backlog < 0)
    545        1.1       cgd 		backlog = 0;
    546       1.49  jonathan 	so->so_qlimit = min(backlog, somaxconn);
    547        1.1       cgd 	splx(s);
    548        1.1       cgd 	return (0);
    549        1.1       cgd }
    550        1.1       cgd 
    551       1.21  christos void
    552       1.54     lukem sofree(struct socket *so)
    553        1.1       cgd {
    554        1.1       cgd 
    555       1.43   mycroft 	if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
    556        1.1       cgd 		return;
    557       1.43   mycroft 	if (so->so_head) {
    558       1.43   mycroft 		/*
    559       1.43   mycroft 		 * We must not decommission a socket that's on the accept(2)
    560       1.43   mycroft 		 * queue.  If we do, then accept(2) may hang after select(2)
    561       1.43   mycroft 		 * indicated that the listening socket was ready.
    562       1.43   mycroft 		 */
    563       1.43   mycroft 		if (!soqremque(so, 0))
    564       1.43   mycroft 			return;
    565       1.43   mycroft 	}
    566       1.98  christos 	if (so->so_rcv.sb_hiwat)
    567      1.110  christos 		(void)chgsbsize(so->so_uidinfo, &so->so_rcv.sb_hiwat, 0,
    568       1.98  christos 		    RLIM_INFINITY);
    569       1.98  christos 	if (so->so_snd.sb_hiwat)
    570      1.110  christos 		(void)chgsbsize(so->so_uidinfo, &so->so_snd.sb_hiwat, 0,
    571       1.98  christos 		    RLIM_INFINITY);
    572       1.98  christos 	sbrelease(&so->so_snd, so);
    573        1.1       cgd 	sorflush(so);
    574       1.37   thorpej 	pool_put(&socket_pool, so);
    575        1.1       cgd }
    576        1.1       cgd 
    577        1.1       cgd /*
    578        1.1       cgd  * Close a socket on last file table reference removal.
    579        1.1       cgd  * Initiate disconnect if connected.
    580        1.1       cgd  * Free socket when disconnect complete.
    581        1.1       cgd  */
    582        1.3    andrew int
    583       1.54     lukem soclose(struct socket *so)
    584        1.1       cgd {
    585       1.54     lukem 	struct socket	*so2;
    586       1.54     lukem 	int		s, error;
    587        1.1       cgd 
    588       1.54     lukem 	error = 0;
    589       1.54     lukem 	s = splsoftnet();		/* conservative */
    590        1.1       cgd 	if (so->so_options & SO_ACCEPTCONN) {
    591       1.63      matt 		while ((so2 = TAILQ_FIRST(&so->so_q0)) != 0) {
    592       1.42   mycroft 			(void) soqremque(so2, 0);
    593       1.41   mycroft 			(void) soabort(so2);
    594       1.41   mycroft 		}
    595       1.63      matt 		while ((so2 = TAILQ_FIRST(&so->so_q)) != 0) {
    596       1.42   mycroft 			(void) soqremque(so2, 1);
    597       1.41   mycroft 			(void) soabort(so2);
    598       1.41   mycroft 		}
    599        1.1       cgd 	}
    600        1.1       cgd 	if (so->so_pcb == 0)
    601        1.1       cgd 		goto discard;
    602        1.1       cgd 	if (so->so_state & SS_ISCONNECTED) {
    603        1.1       cgd 		if ((so->so_state & SS_ISDISCONNECTING) == 0) {
    604        1.1       cgd 			error = sodisconnect(so);
    605        1.1       cgd 			if (error)
    606        1.1       cgd 				goto drop;
    607        1.1       cgd 		}
    608        1.1       cgd 		if (so->so_options & SO_LINGER) {
    609        1.1       cgd 			if ((so->so_state & SS_ISDISCONNECTING) &&
    610        1.1       cgd 			    (so->so_state & SS_NBIO))
    611        1.1       cgd 				goto drop;
    612       1.21  christos 			while (so->so_state & SS_ISCONNECTED) {
    613       1.21  christos 				error = tsleep((caddr_t)&so->so_timeo,
    614       1.21  christos 					       PSOCK | PCATCH, netcls,
    615       1.30   thorpej 					       so->so_linger * hz);
    616       1.21  christos 				if (error)
    617        1.1       cgd 					break;
    618       1.21  christos 			}
    619        1.1       cgd 		}
    620        1.1       cgd 	}
    621       1.54     lukem  drop:
    622        1.1       cgd 	if (so->so_pcb) {
    623       1.22   mycroft 		int error2 = (*so->so_proto->pr_usrreq)(so, PRU_DETACH,
    624       1.22   mycroft 		    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0,
    625      1.114  christos 		    (struct lwp *)0);
    626        1.1       cgd 		if (error == 0)
    627        1.1       cgd 			error = error2;
    628        1.1       cgd 	}
    629       1.54     lukem  discard:
    630        1.1       cgd 	if (so->so_state & SS_NOFDREF)
    631        1.1       cgd 		panic("soclose: NOFDREF");
    632        1.1       cgd 	so->so_state |= SS_NOFDREF;
    633        1.1       cgd 	sofree(so);
    634        1.1       cgd 	splx(s);
    635        1.1       cgd 	return (error);
    636        1.1       cgd }
    637        1.1       cgd 
    638        1.1       cgd /*
    639       1.20   mycroft  * Must be called at splsoftnet...
    640        1.1       cgd  */
    641        1.3    andrew int
    642       1.54     lukem soabort(struct socket *so)
    643        1.1       cgd {
    644        1.1       cgd 
    645       1.22   mycroft 	return (*so->so_proto->pr_usrreq)(so, PRU_ABORT, (struct mbuf *)0,
    646      1.114  christos 	    (struct mbuf *)0, (struct mbuf *)0, (struct lwp *)0);
    647        1.1       cgd }
    648        1.1       cgd 
    649        1.3    andrew int
    650       1.54     lukem soaccept(struct socket *so, struct mbuf *nam)
    651        1.1       cgd {
    652       1.54     lukem 	int	s, error;
    653        1.1       cgd 
    654       1.54     lukem 	error = 0;
    655       1.54     lukem 	s = splsoftnet();
    656        1.1       cgd 	if ((so->so_state & SS_NOFDREF) == 0)
    657        1.1       cgd 		panic("soaccept: !NOFDREF");
    658        1.1       cgd 	so->so_state &= ~SS_NOFDREF;
    659       1.55   thorpej 	if ((so->so_state & SS_ISDISCONNECTED) == 0 ||
    660       1.55   thorpej 	    (so->so_proto->pr_flags & PR_ABRTACPTDIS) == 0)
    661       1.41   mycroft 		error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,
    662      1.114  christos 		    (struct mbuf *)0, nam, (struct mbuf *)0, (struct lwp *)0);
    663       1.41   mycroft 	else
    664       1.53    itojun 		error = ECONNABORTED;
    665       1.52    itojun 
    666        1.1       cgd 	splx(s);
    667        1.1       cgd 	return (error);
    668        1.1       cgd }
    669        1.1       cgd 
    670        1.3    andrew int
    671      1.114  christos soconnect(struct socket *so, struct mbuf *nam, struct lwp *l)
    672        1.1       cgd {
    673       1.54     lukem 	int		s, error;
    674        1.1       cgd 
    675        1.1       cgd 	if (so->so_options & SO_ACCEPTCONN)
    676        1.1       cgd 		return (EOPNOTSUPP);
    677       1.20   mycroft 	s = splsoftnet();
    678        1.1       cgd 	/*
    679        1.1       cgd 	 * If protocol is connection-based, can only connect once.
    680        1.1       cgd 	 * Otherwise, if connected, try to disconnect first.
    681        1.1       cgd 	 * This allows user to disconnect by connecting to, e.g.,
    682        1.1       cgd 	 * a null address.
    683        1.1       cgd 	 */
    684        1.1       cgd 	if (so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING) &&
    685        1.1       cgd 	    ((so->so_proto->pr_flags & PR_CONNREQUIRED) ||
    686        1.1       cgd 	    (error = sodisconnect(so))))
    687        1.1       cgd 		error = EISCONN;
    688        1.1       cgd 	else
    689        1.1       cgd 		error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,
    690      1.114  christos 		    (struct mbuf *)0, nam, (struct mbuf *)0, l);
    691        1.1       cgd 	splx(s);
    692        1.1       cgd 	return (error);
    693        1.1       cgd }
    694        1.1       cgd 
    695        1.3    andrew int
    696       1.54     lukem soconnect2(struct socket *so1, struct socket *so2)
    697        1.1       cgd {
    698       1.54     lukem 	int	s, error;
    699        1.1       cgd 
    700       1.54     lukem 	s = splsoftnet();
    701       1.22   mycroft 	error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,
    702       1.22   mycroft 	    (struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0,
    703      1.114  christos 	    (struct lwp *)0);
    704        1.1       cgd 	splx(s);
    705        1.1       cgd 	return (error);
    706        1.1       cgd }
    707        1.1       cgd 
    708        1.3    andrew int
    709       1.54     lukem sodisconnect(struct socket *so)
    710        1.1       cgd {
    711       1.54     lukem 	int	s, error;
    712        1.1       cgd 
    713       1.54     lukem 	s = splsoftnet();
    714        1.1       cgd 	if ((so->so_state & SS_ISCONNECTED) == 0) {
    715        1.1       cgd 		error = ENOTCONN;
    716        1.1       cgd 		goto bad;
    717        1.1       cgd 	}
    718        1.1       cgd 	if (so->so_state & SS_ISDISCONNECTING) {
    719        1.1       cgd 		error = EALREADY;
    720        1.1       cgd 		goto bad;
    721        1.1       cgd 	}
    722       1.22   mycroft 	error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,
    723       1.22   mycroft 	    (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0,
    724      1.114  christos 	    (struct lwp *)0);
    725       1.54     lukem  bad:
    726        1.1       cgd 	splx(s);
    727  1.115.6.1    simonb 	sodopendfree();
    728        1.1       cgd 	return (error);
    729        1.1       cgd }
    730        1.1       cgd 
    731       1.15   mycroft #define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
    732        1.1       cgd /*
    733        1.1       cgd  * Send on a socket.
    734        1.1       cgd  * If send must go all at once and message is larger than
    735        1.1       cgd  * send buffering, then hard error.
    736        1.1       cgd  * Lock against other senders.
    737        1.1       cgd  * If must go all at once and not enough room now, then
    738        1.1       cgd  * inform user that this would block and do nothing.
    739        1.1       cgd  * Otherwise, if nonblocking, send as much as possible.
    740        1.1       cgd  * The data to be sent is described by "uio" if nonzero,
    741        1.1       cgd  * otherwise by the mbuf chain "top" (which must be null
    742        1.1       cgd  * if uio is not).  Data provided in mbuf chain must be small
    743        1.1       cgd  * enough to send all at once.
    744        1.1       cgd  *
    745        1.1       cgd  * Returns nonzero on error, timeout or signal; callers
    746        1.1       cgd  * must check for short counts if EINTR/ERESTART are returned.
    747        1.1       cgd  * Data and control buffers are freed on return.
    748        1.1       cgd  */
    749        1.3    andrew int
    750       1.54     lukem sosend(struct socket *so, struct mbuf *addr, struct uio *uio, struct mbuf *top,
    751      1.114  christos 	struct mbuf *control, int flags, struct lwp *l)
    752        1.1       cgd {
    753       1.54     lukem 	struct mbuf	**mp, *m;
    754      1.114  christos 	struct proc	*p;
    755       1.58  jdolecek 	long		space, len, resid, clen, mlen;
    756       1.58  jdolecek 	int		error, s, dontroute, atomic;
    757       1.54     lukem 
    758      1.114  christos 	p = l->l_proc;
    759  1.115.6.1    simonb 	sodopendfree();
    760       1.64   thorpej 
    761       1.54     lukem 	clen = 0;
    762       1.54     lukem 	atomic = sosendallatonce(so) || top;
    763        1.1       cgd 	if (uio)
    764        1.1       cgd 		resid = uio->uio_resid;
    765        1.1       cgd 	else
    766        1.1       cgd 		resid = top->m_pkthdr.len;
    767        1.7       cgd 	/*
    768        1.7       cgd 	 * In theory resid should be unsigned.
    769        1.7       cgd 	 * However, space must be signed, as it might be less than 0
    770        1.7       cgd 	 * if we over-committed, and we must use a signed comparison
    771        1.7       cgd 	 * of space and resid.  On the other hand, a negative resid
    772        1.7       cgd 	 * causes us to loop sending 0-length segments to the protocol.
    773        1.7       cgd 	 */
    774       1.29   mycroft 	if (resid < 0) {
    775       1.29   mycroft 		error = EINVAL;
    776       1.29   mycroft 		goto out;
    777       1.29   mycroft 	}
    778        1.1       cgd 	dontroute =
    779        1.1       cgd 	    (flags & MSG_DONTROUTE) && (so->so_options & SO_DONTROUTE) == 0 &&
    780        1.1       cgd 	    (so->so_proto->pr_flags & PR_ATOMIC);
    781      1.102  jonathan 	if (p)
    782      1.102  jonathan 		p->p_stats->p_ru.ru_msgsnd++;
    783        1.1       cgd 	if (control)
    784        1.1       cgd 		clen = control->m_len;
    785        1.1       cgd #define	snderr(errno)	{ error = errno; splx(s); goto release; }
    786        1.1       cgd 
    787       1.54     lukem  restart:
    788       1.21  christos 	if ((error = sblock(&so->so_snd, SBLOCKWAIT(flags))) != 0)
    789        1.1       cgd 		goto out;
    790        1.1       cgd 	do {
    791       1.20   mycroft 		s = splsoftnet();
    792        1.1       cgd 		if (so->so_state & SS_CANTSENDMORE)
    793        1.1       cgd 			snderr(EPIPE);
    794       1.48   thorpej 		if (so->so_error) {
    795       1.48   thorpej 			error = so->so_error;
    796       1.48   thorpej 			so->so_error = 0;
    797       1.48   thorpej 			splx(s);
    798       1.48   thorpej 			goto release;
    799       1.48   thorpej 		}
    800        1.1       cgd 		if ((so->so_state & SS_ISCONNECTED) == 0) {
    801        1.1       cgd 			if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
    802        1.1       cgd 				if ((so->so_state & SS_ISCONFIRMING) == 0 &&
    803        1.1       cgd 				    !(resid == 0 && clen != 0))
    804        1.1       cgd 					snderr(ENOTCONN);
    805        1.1       cgd 			} else if (addr == 0)
    806        1.1       cgd 				snderr(EDESTADDRREQ);
    807        1.1       cgd 		}
    808        1.1       cgd 		space = sbspace(&so->so_snd);
    809        1.1       cgd 		if (flags & MSG_OOB)
    810        1.1       cgd 			space += 1024;
    811       1.21  christos 		if ((atomic && resid > so->so_snd.sb_hiwat) ||
    812       1.11   mycroft 		    clen > so->so_snd.sb_hiwat)
    813       1.11   mycroft 			snderr(EMSGSIZE);
    814       1.96   mycroft 		if (space < resid + clen &&
    815        1.1       cgd 		    (atomic || space < so->so_snd.sb_lowat || space < clen)) {
    816        1.1       cgd 			if (so->so_state & SS_NBIO)
    817        1.1       cgd 				snderr(EWOULDBLOCK);
    818        1.1       cgd 			sbunlock(&so->so_snd);
    819        1.1       cgd 			error = sbwait(&so->so_snd);
    820        1.1       cgd 			splx(s);
    821        1.1       cgd 			if (error)
    822        1.1       cgd 				goto out;
    823        1.1       cgd 			goto restart;
    824        1.1       cgd 		}
    825        1.1       cgd 		splx(s);
    826        1.1       cgd 		mp = &top;
    827        1.1       cgd 		space -= clen;
    828        1.1       cgd 		do {
    829       1.45        tv 			if (uio == NULL) {
    830       1.45        tv 				/*
    831       1.45        tv 				 * Data is prepackaged in "top".
    832       1.45        tv 				 */
    833       1.45        tv 				resid = 0;
    834       1.45        tv 				if (flags & MSG_EOR)
    835       1.45        tv 					top->m_flags |= M_EOR;
    836       1.45        tv 			} else do {
    837       1.45        tv 				if (top == 0) {
    838       1.78      matt 					m = m_gethdr(M_WAIT, MT_DATA);
    839       1.45        tv 					mlen = MHLEN;
    840       1.45        tv 					m->m_pkthdr.len = 0;
    841       1.45        tv 					m->m_pkthdr.rcvif = (struct ifnet *)0;
    842       1.45        tv 				} else {
    843       1.78      matt 					m = m_get(M_WAIT, MT_DATA);
    844       1.45        tv 					mlen = MLEN;
    845       1.45        tv 				}
    846       1.78      matt 				MCLAIM(m, so->so_snd.sb_mowner);
    847       1.65   thorpej 				if (use_sosend_loan &&
    848       1.65   thorpej 				    uio->uio_iov->iov_len >= SOCK_LOAN_THRESH &&
    849       1.64   thorpej 				    space >= SOCK_LOAN_THRESH &&
    850       1.64   thorpej 				    (len = sosend_loan(so, uio, m,
    851       1.64   thorpej 						       space)) != 0) {
    852       1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_loan_big);
    853       1.64   thorpej 					space -= len;
    854       1.64   thorpej 					goto have_data;
    855       1.64   thorpej 				}
    856       1.45        tv 				if (resid >= MINCLSIZE && space >= MCLBYTES) {
    857       1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_copy_big);
    858       1.78      matt 					m_clget(m, M_WAIT);
    859       1.45        tv 					if ((m->m_flags & M_EXT) == 0)
    860       1.45        tv 						goto nopages;
    861       1.45        tv 					mlen = MCLBYTES;
    862       1.45        tv 					if (atomic && top == 0) {
    863       1.58  jdolecek 						len = lmin(MCLBYTES - max_hdr,
    864       1.54     lukem 						    resid);
    865       1.45        tv 						m->m_data += max_hdr;
    866       1.45        tv 					} else
    867       1.58  jdolecek 						len = lmin(MCLBYTES, resid);
    868       1.45        tv 					space -= len;
    869       1.45        tv 				} else {
    870       1.64   thorpej  nopages:
    871       1.64   thorpej 					SOSEND_COUNTER_INCR(&sosend_copy_small);
    872       1.58  jdolecek 					len = lmin(lmin(mlen, resid), space);
    873       1.45        tv 					space -= len;
    874       1.45        tv 					/*
    875       1.45        tv 					 * For datagram protocols, leave room
    876       1.45        tv 					 * for protocol headers in first mbuf.
    877       1.45        tv 					 */
    878       1.45        tv 					if (atomic && top == 0 && len < mlen)
    879       1.45        tv 						MH_ALIGN(m, len);
    880       1.45        tv 				}
    881       1.54     lukem 				error = uiomove(mtod(m, caddr_t), (int)len,
    882       1.54     lukem 				    uio);
    883       1.64   thorpej  have_data:
    884       1.45        tv 				resid = uio->uio_resid;
    885       1.45        tv 				m->m_len = len;
    886       1.45        tv 				*mp = m;
    887       1.45        tv 				top->m_pkthdr.len += len;
    888       1.45        tv 				if (error)
    889       1.45        tv 					goto release;
    890       1.45        tv 				mp = &m->m_next;
    891       1.45        tv 				if (resid <= 0) {
    892       1.45        tv 					if (flags & MSG_EOR)
    893       1.45        tv 						top->m_flags |= M_EOR;
    894       1.45        tv 					break;
    895       1.45        tv 				}
    896       1.45        tv 			} while (space > 0 && atomic);
    897      1.108     perry 
    898       1.46  sommerfe 			s = splsoftnet();
    899       1.46  sommerfe 
    900       1.46  sommerfe 			if (so->so_state & SS_CANTSENDMORE)
    901       1.46  sommerfe 				snderr(EPIPE);
    902       1.45        tv 
    903       1.45        tv 			if (dontroute)
    904       1.45        tv 				so->so_options |= SO_DONTROUTE;
    905       1.45        tv 			if (resid > 0)
    906       1.45        tv 				so->so_state |= SS_MORETOCOME;
    907       1.46  sommerfe 			error = (*so->so_proto->pr_usrreq)(so,
    908       1.46  sommerfe 			    (flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,
    909      1.114  christos 			    top, addr, control, curlwp);	/* XXX */
    910       1.45        tv 			if (dontroute)
    911       1.45        tv 				so->so_options &= ~SO_DONTROUTE;
    912       1.45        tv 			if (resid > 0)
    913       1.45        tv 				so->so_state &= ~SS_MORETOCOME;
    914       1.46  sommerfe 			splx(s);
    915       1.46  sommerfe 
    916       1.45        tv 			clen = 0;
    917       1.45        tv 			control = 0;
    918       1.45        tv 			top = 0;
    919       1.45        tv 			mp = &top;
    920        1.1       cgd 			if (error)
    921        1.1       cgd 				goto release;
    922        1.1       cgd 		} while (resid && space > 0);
    923        1.1       cgd 	} while (resid);
    924        1.1       cgd 
    925       1.54     lukem  release:
    926        1.1       cgd 	sbunlock(&so->so_snd);
    927       1.54     lukem  out:
    928        1.1       cgd 	if (top)
    929        1.1       cgd 		m_freem(top);
    930        1.1       cgd 	if (control)
    931        1.1       cgd 		m_freem(control);
    932        1.1       cgd 	return (error);
    933        1.1       cgd }
    934        1.1       cgd 
    935        1.1       cgd /*
    936        1.1       cgd  * Implement receive operations on a socket.
    937        1.1       cgd  * We depend on the way that records are added to the sockbuf
    938        1.1       cgd  * by sbappend*.  In particular, each record (mbufs linked through m_next)
    939        1.1       cgd  * must begin with an address if the protocol so specifies,
    940        1.1       cgd  * followed by an optional mbuf or mbufs containing ancillary data,
    941        1.1       cgd  * and then zero or more mbufs of data.
    942        1.1       cgd  * In order to avoid blocking network interrupts for the entire time here,
    943        1.1       cgd  * we splx() while doing the actual copy to user space.
    944        1.1       cgd  * Although the sockbuf is locked, new data may still be appended,
    945        1.1       cgd  * and thus we must maintain consistency of the sockbuf during that time.
    946        1.1       cgd  *
    947        1.1       cgd  * The caller may receive the data as a single mbuf chain by supplying
    948        1.1       cgd  * an mbuf **mp0 for use in returning the chain.  The uio is then used
    949        1.1       cgd  * only for the count in uio_resid.
    950        1.1       cgd  */
    951        1.3    andrew int
    952       1.54     lukem soreceive(struct socket *so, struct mbuf **paddr, struct uio *uio,
    953       1.54     lukem 	struct mbuf **mp0, struct mbuf **controlp, int *flagsp)
    954        1.1       cgd {
    955  1.115.6.1    simonb 	struct lwp *l = curlwp;
    956       1.54     lukem 	struct mbuf	*m, **mp;
    957       1.54     lukem 	int		flags, len, error, s, offset, moff, type, orig_resid;
    958       1.99      matt 	const struct protosw	*pr;
    959       1.54     lukem 	struct mbuf	*nextrecord;
    960       1.67        he 	int		mbuf_removed = 0;
    961       1.64   thorpej 
    962       1.54     lukem 	pr = so->so_proto;
    963        1.1       cgd 	mp = mp0;
    964       1.54     lukem 	type = 0;
    965       1.54     lukem 	orig_resid = uio->uio_resid;
    966      1.102  jonathan 
    967        1.1       cgd 	if (paddr)
    968        1.1       cgd 		*paddr = 0;
    969        1.1       cgd 	if (controlp)
    970        1.1       cgd 		*controlp = 0;
    971        1.1       cgd 	if (flagsp)
    972        1.1       cgd 		flags = *flagsp &~ MSG_EOR;
    973        1.1       cgd 	else
    974        1.1       cgd 		flags = 0;
    975       1.66     enami 
    976       1.66     enami 	if ((flags & MSG_DONTWAIT) == 0)
    977  1.115.6.1    simonb 		sodopendfree();
    978       1.66     enami 
    979        1.1       cgd 	if (flags & MSG_OOB) {
    980        1.1       cgd 		m = m_get(M_WAIT, MT_DATA);
    981       1.17       cgd 		error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,
    982      1.102  jonathan 		    (struct mbuf *)(long)(flags & MSG_PEEK),
    983      1.114  christos 		    (struct mbuf *)0, l);
    984        1.1       cgd 		if (error)
    985        1.1       cgd 			goto bad;
    986        1.1       cgd 		do {
    987        1.1       cgd 			error = uiomove(mtod(m, caddr_t),
    988        1.1       cgd 			    (int) min(uio->uio_resid, m->m_len), uio);
    989        1.1       cgd 			m = m_free(m);
    990        1.1       cgd 		} while (uio->uio_resid && error == 0 && m);
    991       1.54     lukem  bad:
    992        1.1       cgd 		if (m)
    993        1.1       cgd 			m_freem(m);
    994        1.1       cgd 		return (error);
    995        1.1       cgd 	}
    996        1.1       cgd 	if (mp)
    997        1.1       cgd 		*mp = (struct mbuf *)0;
    998        1.1       cgd 	if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)
    999       1.22   mycroft 		(*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
   1000      1.114  christos 		    (struct mbuf *)0, (struct mbuf *)0, l);
   1001        1.1       cgd 
   1002       1.54     lukem  restart:
   1003       1.21  christos 	if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)
   1004        1.1       cgd 		return (error);
   1005       1.20   mycroft 	s = splsoftnet();
   1006        1.1       cgd 
   1007        1.1       cgd 	m = so->so_rcv.sb_mb;
   1008        1.1       cgd 	/*
   1009        1.1       cgd 	 * If we have less data than requested, block awaiting more
   1010        1.1       cgd 	 * (subject to any timeout) if:
   1011       1.15   mycroft 	 *   1. the current count is less than the low water mark,
   1012        1.1       cgd 	 *   2. MSG_WAITALL is set, and it is possible to do the entire
   1013       1.15   mycroft 	 *	receive operation at once if we block (resid <= hiwat), or
   1014       1.15   mycroft 	 *   3. MSG_DONTWAIT is not set.
   1015        1.1       cgd 	 * If MSG_WAITALL is set but resid is larger than the receive buffer,
   1016        1.1       cgd 	 * we have to do the receive in sections, and thus risk returning
   1017        1.1       cgd 	 * a short count if a timeout or signal occurs after we start.
   1018        1.1       cgd 	 */
   1019       1.21  christos 	if (m == 0 || (((flags & MSG_DONTWAIT) == 0 &&
   1020       1.15   mycroft 	    so->so_rcv.sb_cc < uio->uio_resid) &&
   1021        1.1       cgd 	    (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
   1022        1.1       cgd 	    ((flags & MSG_WAITALL) && uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
   1023       1.21  christos 	    m->m_nextpkt == 0 && (pr->pr_flags & PR_ATOMIC) == 0)) {
   1024        1.1       cgd #ifdef DIAGNOSTIC
   1025        1.1       cgd 		if (m == 0 && so->so_rcv.sb_cc)
   1026        1.1       cgd 			panic("receive 1");
   1027        1.1       cgd #endif
   1028        1.1       cgd 		if (so->so_error) {
   1029        1.1       cgd 			if (m)
   1030       1.15   mycroft 				goto dontblock;
   1031        1.1       cgd 			error = so->so_error;
   1032        1.1       cgd 			if ((flags & MSG_PEEK) == 0)
   1033        1.1       cgd 				so->so_error = 0;
   1034        1.1       cgd 			goto release;
   1035        1.1       cgd 		}
   1036        1.1       cgd 		if (so->so_state & SS_CANTRCVMORE) {
   1037        1.1       cgd 			if (m)
   1038       1.15   mycroft 				goto dontblock;
   1039        1.1       cgd 			else
   1040        1.1       cgd 				goto release;
   1041        1.1       cgd 		}
   1042        1.1       cgd 		for (; m; m = m->m_next)
   1043        1.1       cgd 			if (m->m_type == MT_OOBDATA  || (m->m_flags & M_EOR)) {
   1044        1.1       cgd 				m = so->so_rcv.sb_mb;
   1045        1.1       cgd 				goto dontblock;
   1046        1.1       cgd 			}
   1047        1.1       cgd 		if ((so->so_state & (SS_ISCONNECTED|SS_ISCONNECTING)) == 0 &&
   1048        1.1       cgd 		    (so->so_proto->pr_flags & PR_CONNREQUIRED)) {
   1049        1.1       cgd 			error = ENOTCONN;
   1050        1.1       cgd 			goto release;
   1051        1.1       cgd 		}
   1052        1.1       cgd 		if (uio->uio_resid == 0)
   1053        1.1       cgd 			goto release;
   1054       1.15   mycroft 		if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
   1055        1.1       cgd 			error = EWOULDBLOCK;
   1056        1.1       cgd 			goto release;
   1057        1.1       cgd 		}
   1058       1.69   thorpej 		SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 1");
   1059       1.69   thorpej 		SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 1");
   1060        1.1       cgd 		sbunlock(&so->so_rcv);
   1061        1.1       cgd 		error = sbwait(&so->so_rcv);
   1062        1.1       cgd 		splx(s);
   1063        1.1       cgd 		if (error)
   1064        1.1       cgd 			return (error);
   1065        1.1       cgd 		goto restart;
   1066        1.1       cgd 	}
   1067       1.54     lukem  dontblock:
   1068       1.69   thorpej 	/*
   1069       1.69   thorpej 	 * On entry here, m points to the first record of the socket buffer.
   1070       1.69   thorpej 	 * While we process the initial mbufs containing address and control
   1071       1.69   thorpej 	 * info, we save a copy of m->m_nextpkt into nextrecord.
   1072       1.69   thorpej 	 */
   1073      1.114  christos 	if (l)
   1074      1.114  christos 		l->l_proc->p_stats->p_ru.ru_msgrcv++;
   1075       1.69   thorpej 	KASSERT(m == so->so_rcv.sb_mb);
   1076       1.69   thorpej 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 1");
   1077       1.69   thorpej 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 1");
   1078        1.1       cgd 	nextrecord = m->m_nextpkt;
   1079        1.1       cgd 	if (pr->pr_flags & PR_ADDR) {
   1080        1.1       cgd #ifdef DIAGNOSTIC
   1081        1.1       cgd 		if (m->m_type != MT_SONAME)
   1082        1.1       cgd 			panic("receive 1a");
   1083        1.1       cgd #endif
   1084        1.3    andrew 		orig_resid = 0;
   1085        1.1       cgd 		if (flags & MSG_PEEK) {
   1086        1.1       cgd 			if (paddr)
   1087        1.1       cgd 				*paddr = m_copy(m, 0, m->m_len);
   1088        1.1       cgd 			m = m->m_next;
   1089        1.1       cgd 		} else {
   1090        1.1       cgd 			sbfree(&so->so_rcv, m);
   1091       1.67        he 			mbuf_removed = 1;
   1092        1.1       cgd 			if (paddr) {
   1093        1.1       cgd 				*paddr = m;
   1094        1.1       cgd 				so->so_rcv.sb_mb = m->m_next;
   1095        1.1       cgd 				m->m_next = 0;
   1096        1.1       cgd 				m = so->so_rcv.sb_mb;
   1097        1.1       cgd 			} else {
   1098        1.1       cgd 				MFREE(m, so->so_rcv.sb_mb);
   1099        1.1       cgd 				m = so->so_rcv.sb_mb;
   1100        1.1       cgd 			}
   1101        1.1       cgd 		}
   1102        1.1       cgd 	}
   1103        1.1       cgd 	while (m && m->m_type == MT_CONTROL && error == 0) {
   1104        1.1       cgd 		if (flags & MSG_PEEK) {
   1105        1.1       cgd 			if (controlp)
   1106        1.1       cgd 				*controlp = m_copy(m, 0, m->m_len);
   1107        1.1       cgd 			m = m->m_next;
   1108        1.1       cgd 		} else {
   1109        1.1       cgd 			sbfree(&so->so_rcv, m);
   1110       1.67        he 			mbuf_removed = 1;
   1111        1.1       cgd 			if (controlp) {
   1112      1.102  jonathan 				struct domain *dom = pr->pr_domain;
   1113      1.114  christos 				if (dom->dom_externalize && l &&
   1114        1.1       cgd 				    mtod(m, struct cmsghdr *)->cmsg_type ==
   1115        1.1       cgd 				    SCM_RIGHTS)
   1116      1.114  christos 					error = (*dom->dom_externalize)(m, l);
   1117        1.1       cgd 				*controlp = m;
   1118        1.1       cgd 				so->so_rcv.sb_mb = m->m_next;
   1119        1.1       cgd 				m->m_next = 0;
   1120        1.1       cgd 				m = so->so_rcv.sb_mb;
   1121        1.1       cgd 			} else {
   1122      1.106    itojun 				/*
   1123      1.106    itojun 				 * Dispose of any SCM_RIGHTS message that went
   1124      1.106    itojun 				 * through the read path rather than recv.
   1125      1.106    itojun 				 */
   1126      1.106    itojun 				if (pr->pr_domain->dom_dispose &&
   1127      1.106    itojun 				    mtod(m, struct cmsghdr *)->cmsg_type == SCM_RIGHTS)
   1128      1.106    itojun 					(*pr->pr_domain->dom_dispose)(m);
   1129        1.1       cgd 				MFREE(m, so->so_rcv.sb_mb);
   1130        1.1       cgd 				m = so->so_rcv.sb_mb;
   1131        1.1       cgd 			}
   1132        1.1       cgd 		}
   1133        1.3    andrew 		if (controlp) {
   1134        1.3    andrew 			orig_resid = 0;
   1135        1.1       cgd 			controlp = &(*controlp)->m_next;
   1136        1.3    andrew 		}
   1137        1.1       cgd 	}
   1138       1.69   thorpej 
   1139       1.69   thorpej 	/*
   1140       1.69   thorpej 	 * If m is non-NULL, we have some data to read.  From now on,
   1141       1.69   thorpej 	 * make sure to keep sb_lastrecord consistent when working on
   1142       1.69   thorpej 	 * the last packet on the chain (nextrecord == NULL) and we
   1143       1.69   thorpej 	 * change m->m_nextpkt.
   1144       1.69   thorpej 	 */
   1145        1.1       cgd 	if (m) {
   1146       1.69   thorpej 		if ((flags & MSG_PEEK) == 0) {
   1147        1.1       cgd 			m->m_nextpkt = nextrecord;
   1148       1.69   thorpej 			/*
   1149       1.69   thorpej 			 * If nextrecord == NULL (this is a single chain),
   1150       1.69   thorpej 			 * then sb_lastrecord may not be valid here if m
   1151       1.69   thorpej 			 * was changed earlier.
   1152       1.69   thorpej 			 */
   1153       1.69   thorpej 			if (nextrecord == NULL) {
   1154       1.69   thorpej 				KASSERT(so->so_rcv.sb_mb == m);
   1155       1.69   thorpej 				so->so_rcv.sb_lastrecord = m;
   1156       1.69   thorpej 			}
   1157       1.69   thorpej 		}
   1158        1.1       cgd 		type = m->m_type;
   1159        1.1       cgd 		if (type == MT_OOBDATA)
   1160        1.1       cgd 			flags |= MSG_OOB;
   1161       1.69   thorpej 	} else {
   1162       1.69   thorpej 		if ((flags & MSG_PEEK) == 0) {
   1163       1.69   thorpej 			KASSERT(so->so_rcv.sb_mb == m);
   1164       1.69   thorpej 			so->so_rcv.sb_mb = nextrecord;
   1165       1.70   thorpej 			SB_EMPTY_FIXUP(&so->so_rcv);
   1166       1.69   thorpej 		}
   1167        1.1       cgd 	}
   1168       1.69   thorpej 	SBLASTRECORDCHK(&so->so_rcv, "soreceive 2");
   1169       1.69   thorpej 	SBLASTMBUFCHK(&so->so_rcv, "soreceive 2");
   1170       1.69   thorpej 
   1171        1.1       cgd 	moff = 0;
   1172        1.1       cgd 	offset = 0;
   1173        1.1       cgd 	while (m && uio->uio_resid > 0 && error == 0) {
   1174        1.1       cgd 		if (m->m_type == MT_OOBDATA) {
   1175        1.1       cgd 			if (type != MT_OOBDATA)
   1176        1.1       cgd 				break;
   1177        1.1       cgd 		} else if (type == MT_OOBDATA)
   1178        1.1       cgd 			break;
   1179        1.1       cgd #ifdef DIAGNOSTIC
   1180        1.1       cgd 		else if (m->m_type != MT_DATA && m->m_type != MT_HEADER)
   1181        1.1       cgd 			panic("receive 3");
   1182        1.1       cgd #endif
   1183        1.1       cgd 		so->so_state &= ~SS_RCVATMARK;
   1184        1.1       cgd 		len = uio->uio_resid;
   1185        1.1       cgd 		if (so->so_oobmark && len > so->so_oobmark - offset)
   1186        1.1       cgd 			len = so->so_oobmark - offset;
   1187        1.1       cgd 		if (len > m->m_len - moff)
   1188        1.1       cgd 			len = m->m_len - moff;
   1189        1.1       cgd 		/*
   1190        1.1       cgd 		 * If mp is set, just pass back the mbufs.
   1191        1.1       cgd 		 * Otherwise copy them out via the uio, then free.
   1192        1.1       cgd 		 * Sockbuf must be consistent here (points to current mbuf,
   1193        1.1       cgd 		 * it points to next record) when we drop priority;
   1194        1.1       cgd 		 * we must note any additions to the sockbuf when we
   1195        1.1       cgd 		 * block interrupts again.
   1196        1.1       cgd 		 */
   1197        1.1       cgd 		if (mp == 0) {
   1198       1.69   thorpej 			SBLASTRECORDCHK(&so->so_rcv, "soreceive uiomove");
   1199       1.69   thorpej 			SBLASTMBUFCHK(&so->so_rcv, "soreceive uiomove");
   1200        1.1       cgd 			splx(s);
   1201        1.1       cgd 			error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);
   1202       1.20   mycroft 			s = splsoftnet();
   1203       1.67        he 			if (error) {
   1204       1.67        he 				/*
   1205       1.67        he 				 * If any part of the record has been removed
   1206       1.67        he 				 * (such as the MT_SONAME mbuf, which will
   1207       1.67        he 				 * happen when PR_ADDR, and thus also
   1208       1.67        he 				 * PR_ATOMIC, is set), then drop the entire
   1209       1.67        he 				 * record to maintain the atomicity of the
   1210       1.67        he 				 * receive operation.
   1211       1.67        he 				 *
   1212       1.67        he 				 * This avoids a later panic("receive 1a")
   1213       1.67        he 				 * when compiled with DIAGNOSTIC.
   1214       1.67        he 				 */
   1215       1.67        he 				if (m && mbuf_removed
   1216       1.67        he 				    && (pr->pr_flags & PR_ATOMIC))
   1217       1.67        he 					(void) sbdroprecord(&so->so_rcv);
   1218       1.67        he 
   1219       1.57  jdolecek 				goto release;
   1220       1.67        he 			}
   1221        1.1       cgd 		} else
   1222        1.1       cgd 			uio->uio_resid -= len;
   1223        1.1       cgd 		if (len == m->m_len - moff) {
   1224        1.1       cgd 			if (m->m_flags & M_EOR)
   1225        1.1       cgd 				flags |= MSG_EOR;
   1226        1.1       cgd 			if (flags & MSG_PEEK) {
   1227        1.1       cgd 				m = m->m_next;
   1228        1.1       cgd 				moff = 0;
   1229        1.1       cgd 			} else {
   1230        1.1       cgd 				nextrecord = m->m_nextpkt;
   1231        1.1       cgd 				sbfree(&so->so_rcv, m);
   1232        1.1       cgd 				if (mp) {
   1233        1.1       cgd 					*mp = m;
   1234        1.1       cgd 					mp = &m->m_next;
   1235        1.1       cgd 					so->so_rcv.sb_mb = m = m->m_next;
   1236        1.1       cgd 					*mp = (struct mbuf *)0;
   1237        1.1       cgd 				} else {
   1238        1.1       cgd 					MFREE(m, so->so_rcv.sb_mb);
   1239        1.1       cgd 					m = so->so_rcv.sb_mb;
   1240        1.1       cgd 				}
   1241       1.69   thorpej 				/*
   1242       1.69   thorpej 				 * If m != NULL, we also know that
   1243       1.69   thorpej 				 * so->so_rcv.sb_mb != NULL.
   1244       1.69   thorpej 				 */
   1245       1.69   thorpej 				KASSERT(so->so_rcv.sb_mb == m);
   1246       1.69   thorpej 				if (m) {
   1247        1.1       cgd 					m->m_nextpkt = nextrecord;
   1248       1.69   thorpej 					if (nextrecord == NULL)
   1249       1.69   thorpej 						so->so_rcv.sb_lastrecord = m;
   1250       1.69   thorpej 				} else {
   1251       1.69   thorpej 					so->so_rcv.sb_mb = nextrecord;
   1252       1.70   thorpej 					SB_EMPTY_FIXUP(&so->so_rcv);
   1253       1.69   thorpej 				}
   1254       1.69   thorpej 				SBLASTRECORDCHK(&so->so_rcv, "soreceive 3");
   1255       1.69   thorpej 				SBLASTMBUFCHK(&so->so_rcv, "soreceive 3");
   1256        1.1       cgd 			}
   1257        1.1       cgd 		} else {
   1258        1.1       cgd 			if (flags & MSG_PEEK)
   1259        1.1       cgd 				moff += len;
   1260        1.1       cgd 			else {
   1261        1.1       cgd 				if (mp)
   1262        1.1       cgd 					*mp = m_copym(m, 0, len, M_WAIT);
   1263        1.1       cgd 				m->m_data += len;
   1264        1.1       cgd 				m->m_len -= len;
   1265        1.1       cgd 				so->so_rcv.sb_cc -= len;
   1266        1.1       cgd 			}
   1267        1.1       cgd 		}
   1268        1.1       cgd 		if (so->so_oobmark) {
   1269        1.1       cgd 			if ((flags & MSG_PEEK) == 0) {
   1270        1.1       cgd 				so->so_oobmark -= len;
   1271        1.1       cgd 				if (so->so_oobmark == 0) {
   1272        1.1       cgd 					so->so_state |= SS_RCVATMARK;
   1273        1.1       cgd 					break;
   1274        1.1       cgd 				}
   1275        1.7       cgd 			} else {
   1276        1.1       cgd 				offset += len;
   1277        1.7       cgd 				if (offset == so->so_oobmark)
   1278        1.7       cgd 					break;
   1279        1.7       cgd 			}
   1280        1.1       cgd 		}
   1281        1.1       cgd 		if (flags & MSG_EOR)
   1282        1.1       cgd 			break;
   1283        1.1       cgd 		/*
   1284        1.1       cgd 		 * If the MSG_WAITALL flag is set (for non-atomic socket),
   1285        1.1       cgd 		 * we must not quit until "uio->uio_resid == 0" or an error
   1286        1.1       cgd 		 * termination.  If a signal/timeout occurs, return
   1287        1.1       cgd 		 * with a short count but without error.
   1288        1.1       cgd 		 * Keep sockbuf locked against other readers.
   1289        1.1       cgd 		 */
   1290        1.1       cgd 		while (flags & MSG_WAITALL && m == 0 && uio->uio_resid > 0 &&
   1291        1.3    andrew 		    !sosendallatonce(so) && !nextrecord) {
   1292        1.1       cgd 			if (so->so_error || so->so_state & SS_CANTRCVMORE)
   1293        1.1       cgd 				break;
   1294       1.68      matt 			/*
   1295       1.68      matt 			 * If we are peeking and the socket receive buffer is
   1296       1.68      matt 			 * full, stop since we can't get more data to peek at.
   1297       1.68      matt 			 */
   1298       1.68      matt 			if ((flags & MSG_PEEK) && sbspace(&so->so_rcv) <= 0)
   1299       1.68      matt 				break;
   1300       1.68      matt 			/*
   1301       1.68      matt 			 * If we've drained the socket buffer, tell the
   1302       1.68      matt 			 * protocol in case it needs to do something to
   1303       1.68      matt 			 * get it filled again.
   1304       1.68      matt 			 */
   1305       1.68      matt 			if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb)
   1306       1.68      matt 				(*pr->pr_usrreq)(so, PRU_RCVD,
   1307       1.68      matt 				    (struct mbuf *)0,
   1308       1.68      matt 				    (struct mbuf *)(long)flags,
   1309      1.114  christos 				    (struct mbuf *)0, l);
   1310       1.69   thorpej 			SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");
   1311       1.69   thorpej 			SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");
   1312        1.1       cgd 			error = sbwait(&so->so_rcv);
   1313        1.1       cgd 			if (error) {
   1314        1.1       cgd 				sbunlock(&so->so_rcv);
   1315        1.1       cgd 				splx(s);
   1316        1.1       cgd 				return (0);
   1317        1.1       cgd 			}
   1318       1.21  christos 			if ((m = so->so_rcv.sb_mb) != NULL)
   1319        1.1       cgd 				nextrecord = m->m_nextpkt;
   1320        1.1       cgd 		}
   1321        1.1       cgd 	}
   1322        1.3    andrew 
   1323        1.3    andrew 	if (m && pr->pr_flags & PR_ATOMIC) {
   1324        1.3    andrew 		flags |= MSG_TRUNC;
   1325        1.3    andrew 		if ((flags & MSG_PEEK) == 0)
   1326        1.3    andrew 			(void) sbdroprecord(&so->so_rcv);
   1327        1.3    andrew 	}
   1328        1.1       cgd 	if ((flags & MSG_PEEK) == 0) {
   1329       1.69   thorpej 		if (m == 0) {
   1330       1.69   thorpej 			/*
   1331       1.70   thorpej 			 * First part is an inline SB_EMPTY_FIXUP().  Second
   1332       1.69   thorpej 			 * part makes sure sb_lastrecord is up-to-date if
   1333       1.69   thorpej 			 * there is still data in the socket buffer.
   1334       1.69   thorpej 			 */
   1335        1.1       cgd 			so->so_rcv.sb_mb = nextrecord;
   1336       1.69   thorpej 			if (so->so_rcv.sb_mb == NULL) {
   1337       1.69   thorpej 				so->so_rcv.sb_mbtail = NULL;
   1338       1.69   thorpej 				so->so_rcv.sb_lastrecord = NULL;
   1339       1.69   thorpej 			} else if (nextrecord->m_nextpkt == NULL)
   1340       1.69   thorpej 				so->so_rcv.sb_lastrecord = nextrecord;
   1341       1.69   thorpej 		}
   1342       1.69   thorpej 		SBLASTRECORDCHK(&so->so_rcv, "soreceive 4");
   1343       1.69   thorpej 		SBLASTMBUFCHK(&so->so_rcv, "soreceive 4");
   1344        1.1       cgd 		if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)
   1345       1.22   mycroft 			(*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,
   1346      1.114  christos 			    (struct mbuf *)(long)flags, (struct mbuf *)0, l);
   1347        1.1       cgd 	}
   1348        1.3    andrew 	if (orig_resid == uio->uio_resid && orig_resid &&
   1349        1.3    andrew 	    (flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {
   1350        1.3    andrew 		sbunlock(&so->so_rcv);
   1351        1.3    andrew 		splx(s);
   1352        1.3    andrew 		goto restart;
   1353        1.3    andrew 	}
   1354      1.108     perry 
   1355        1.1       cgd 	if (flagsp)
   1356        1.1       cgd 		*flagsp |= flags;
   1357       1.54     lukem  release:
   1358        1.1       cgd 	sbunlock(&so->so_rcv);
   1359        1.1       cgd 	splx(s);
   1360        1.1       cgd 	return (error);
   1361        1.1       cgd }
   1362        1.1       cgd 
   1363       1.14   mycroft int
   1364       1.54     lukem soshutdown(struct socket *so, int how)
   1365        1.1       cgd {
   1366       1.99      matt 	const struct protosw	*pr;
   1367       1.34    kleink 
   1368       1.54     lukem 	pr = so->so_proto;
   1369       1.34    kleink 	if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
   1370       1.34    kleink 		return (EINVAL);
   1371        1.1       cgd 
   1372       1.34    kleink 	if (how == SHUT_RD || how == SHUT_RDWR)
   1373        1.1       cgd 		sorflush(so);
   1374       1.34    kleink 	if (how == SHUT_WR || how == SHUT_RDWR)
   1375       1.22   mycroft 		return (*pr->pr_usrreq)(so, PRU_SHUTDOWN, (struct mbuf *)0,
   1376      1.114  christos 		    (struct mbuf *)0, (struct mbuf *)0, (struct lwp *)0);
   1377        1.1       cgd 	return (0);
   1378        1.1       cgd }
   1379        1.1       cgd 
   1380       1.14   mycroft void
   1381       1.54     lukem sorflush(struct socket *so)
   1382        1.1       cgd {
   1383       1.54     lukem 	struct sockbuf	*sb, asb;
   1384       1.99      matt 	const struct protosw	*pr;
   1385       1.54     lukem 	int		s;
   1386        1.1       cgd 
   1387       1.54     lukem 	sb = &so->so_rcv;
   1388       1.54     lukem 	pr = so->so_proto;
   1389        1.1       cgd 	sb->sb_flags |= SB_NOINTR;
   1390       1.15   mycroft 	(void) sblock(sb, M_WAITOK);
   1391       1.56   thorpej 	s = splnet();
   1392        1.1       cgd 	socantrcvmore(so);
   1393        1.1       cgd 	sbunlock(sb);
   1394        1.1       cgd 	asb = *sb;
   1395       1.86  wrstuden 	/*
   1396       1.86  wrstuden 	 * Clear most of the sockbuf structure, but leave some of the
   1397       1.86  wrstuden 	 * fields valid.
   1398       1.86  wrstuden 	 */
   1399       1.86  wrstuden 	memset(&sb->sb_startzero, 0,
   1400       1.86  wrstuden 	    sizeof(*sb) - offsetof(struct sockbuf, sb_startzero));
   1401        1.1       cgd 	splx(s);
   1402        1.1       cgd 	if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
   1403        1.1       cgd 		(*pr->pr_domain->dom_dispose)(asb.sb_mb);
   1404       1.98  christos 	sbrelease(&asb, so);
   1405        1.1       cgd }
   1406        1.1       cgd 
   1407       1.14   mycroft int
   1408       1.54     lukem sosetopt(struct socket *so, int level, int optname, struct mbuf *m0)
   1409        1.1       cgd {
   1410       1.54     lukem 	int		error;
   1411       1.54     lukem 	struct mbuf	*m;
   1412        1.1       cgd 
   1413       1.54     lukem 	error = 0;
   1414       1.54     lukem 	m = m0;
   1415        1.1       cgd 	if (level != SOL_SOCKET) {
   1416        1.1       cgd 		if (so->so_proto && so->so_proto->pr_ctloutput)
   1417        1.1       cgd 			return ((*so->so_proto->pr_ctloutput)
   1418        1.1       cgd 				  (PRCO_SETOPT, so, level, optname, &m0));
   1419        1.1       cgd 		error = ENOPROTOOPT;
   1420        1.1       cgd 	} else {
   1421        1.1       cgd 		switch (optname) {
   1422        1.1       cgd 
   1423        1.1       cgd 		case SO_LINGER:
   1424       1.36     perry 			if (m == NULL || m->m_len != sizeof(struct linger)) {
   1425        1.1       cgd 				error = EINVAL;
   1426        1.1       cgd 				goto bad;
   1427        1.1       cgd 			}
   1428      1.112   nathanw 			if (mtod(m, struct linger *)->l_linger < 0 ||
   1429      1.112   nathanw 			    mtod(m, struct linger *)->l_linger > (INT_MAX / hz)) {
   1430      1.112   nathanw 				error = EDOM;
   1431      1.112   nathanw 				goto bad;
   1432      1.112   nathanw 			}
   1433        1.1       cgd 			so->so_linger = mtod(m, struct linger *)->l_linger;
   1434        1.1       cgd 			/* fall thru... */
   1435        1.1       cgd 
   1436        1.1       cgd 		case SO_DEBUG:
   1437        1.1       cgd 		case SO_KEEPALIVE:
   1438        1.1       cgd 		case SO_DONTROUTE:
   1439        1.1       cgd 		case SO_USELOOPBACK:
   1440        1.1       cgd 		case SO_BROADCAST:
   1441        1.1       cgd 		case SO_REUSEADDR:
   1442       1.15   mycroft 		case SO_REUSEPORT:
   1443        1.1       cgd 		case SO_OOBINLINE:
   1444       1.26   thorpej 		case SO_TIMESTAMP:
   1445       1.36     perry 			if (m == NULL || m->m_len < sizeof(int)) {
   1446        1.1       cgd 				error = EINVAL;
   1447        1.1       cgd 				goto bad;
   1448        1.1       cgd 			}
   1449        1.1       cgd 			if (*mtod(m, int *))
   1450        1.1       cgd 				so->so_options |= optname;
   1451        1.1       cgd 			else
   1452        1.1       cgd 				so->so_options &= ~optname;
   1453        1.1       cgd 			break;
   1454        1.1       cgd 
   1455        1.1       cgd 		case SO_SNDBUF:
   1456        1.1       cgd 		case SO_RCVBUF:
   1457        1.1       cgd 		case SO_SNDLOWAT:
   1458        1.1       cgd 		case SO_RCVLOWAT:
   1459       1.28   thorpej 		    {
   1460       1.28   thorpej 			int optval;
   1461       1.28   thorpej 
   1462       1.36     perry 			if (m == NULL || m->m_len < sizeof(int)) {
   1463        1.1       cgd 				error = EINVAL;
   1464        1.1       cgd 				goto bad;
   1465        1.1       cgd 			}
   1466       1.28   thorpej 
   1467       1.28   thorpej 			/*
   1468       1.28   thorpej 			 * Values < 1 make no sense for any of these
   1469       1.28   thorpej 			 * options, so disallow them.
   1470       1.28   thorpej 			 */
   1471       1.28   thorpej 			optval = *mtod(m, int *);
   1472       1.28   thorpej 			if (optval < 1) {
   1473       1.28   thorpej 				error = EINVAL;
   1474       1.28   thorpej 				goto bad;
   1475       1.28   thorpej 			}
   1476       1.28   thorpej 
   1477        1.1       cgd 			switch (optname) {
   1478        1.1       cgd 
   1479        1.1       cgd 			case SO_SNDBUF:
   1480        1.1       cgd 			case SO_RCVBUF:
   1481        1.1       cgd 				if (sbreserve(optname == SO_SNDBUF ?
   1482        1.1       cgd 				    &so->so_snd : &so->so_rcv,
   1483       1.98  christos 				    (u_long) optval, so) == 0) {
   1484        1.1       cgd 					error = ENOBUFS;
   1485        1.1       cgd 					goto bad;
   1486        1.1       cgd 				}
   1487        1.1       cgd 				break;
   1488        1.1       cgd 
   1489       1.28   thorpej 			/*
   1490       1.28   thorpej 			 * Make sure the low-water is never greater than
   1491       1.28   thorpej 			 * the high-water.
   1492       1.28   thorpej 			 */
   1493        1.1       cgd 			case SO_SNDLOWAT:
   1494       1.28   thorpej 				so->so_snd.sb_lowat =
   1495       1.28   thorpej 				    (optval > so->so_snd.sb_hiwat) ?
   1496       1.28   thorpej 				    so->so_snd.sb_hiwat : optval;
   1497        1.1       cgd 				break;
   1498        1.1       cgd 			case SO_RCVLOWAT:
   1499       1.28   thorpej 				so->so_rcv.sb_lowat =
   1500       1.28   thorpej 				    (optval > so->so_rcv.sb_hiwat) ?
   1501       1.28   thorpej 				    so->so_rcv.sb_hiwat : optval;
   1502        1.1       cgd 				break;
   1503        1.1       cgd 			}
   1504        1.1       cgd 			break;
   1505       1.28   thorpej 		    }
   1506        1.1       cgd 
   1507        1.1       cgd 		case SO_SNDTIMEO:
   1508        1.1       cgd 		case SO_RCVTIMEO:
   1509        1.1       cgd 		    {
   1510        1.1       cgd 			struct timeval *tv;
   1511      1.104      yamt 			int val;
   1512        1.1       cgd 
   1513       1.36     perry 			if (m == NULL || m->m_len < sizeof(*tv)) {
   1514        1.1       cgd 				error = EINVAL;
   1515        1.1       cgd 				goto bad;
   1516        1.1       cgd 			}
   1517        1.1       cgd 			tv = mtod(m, struct timeval *);
   1518      1.104      yamt 			if (tv->tv_sec > (INT_MAX - tv->tv_usec / tick) / hz) {
   1519        1.1       cgd 				error = EDOM;
   1520        1.1       cgd 				goto bad;
   1521        1.1       cgd 			}
   1522        1.1       cgd 			val = tv->tv_sec * hz + tv->tv_usec / tick;
   1523       1.74    itojun 			if (val == 0 && tv->tv_usec != 0)
   1524       1.74    itojun 				val = 1;
   1525        1.1       cgd 
   1526        1.1       cgd 			switch (optname) {
   1527        1.1       cgd 
   1528        1.1       cgd 			case SO_SNDTIMEO:
   1529        1.1       cgd 				so->so_snd.sb_timeo = val;
   1530        1.1       cgd 				break;
   1531        1.1       cgd 			case SO_RCVTIMEO:
   1532        1.1       cgd 				so->so_rcv.sb_timeo = val;
   1533        1.1       cgd 				break;
   1534        1.1       cgd 			}
   1535        1.1       cgd 			break;
   1536        1.1       cgd 		    }
   1537        1.1       cgd 
   1538        1.1       cgd 		default:
   1539        1.1       cgd 			error = ENOPROTOOPT;
   1540        1.1       cgd 			break;
   1541        1.1       cgd 		}
   1542       1.15   mycroft 		if (error == 0 && so->so_proto && so->so_proto->pr_ctloutput) {
   1543       1.15   mycroft 			(void) ((*so->so_proto->pr_ctloutput)
   1544       1.15   mycroft 				  (PRCO_SETOPT, so, level, optname, &m0));
   1545       1.15   mycroft 			m = NULL;	/* freed by protocol */
   1546       1.15   mycroft 		}
   1547        1.1       cgd 	}
   1548       1.54     lukem  bad:
   1549        1.1       cgd 	if (m)
   1550        1.1       cgd 		(void) m_free(m);
   1551        1.1       cgd 	return (error);
   1552        1.1       cgd }
   1553        1.1       cgd 
   1554       1.14   mycroft int
   1555       1.54     lukem sogetopt(struct socket *so, int level, int optname, struct mbuf **mp)
   1556        1.1       cgd {
   1557       1.54     lukem 	struct mbuf	*m;
   1558        1.1       cgd 
   1559        1.1       cgd 	if (level != SOL_SOCKET) {
   1560        1.1       cgd 		if (so->so_proto && so->so_proto->pr_ctloutput) {
   1561        1.1       cgd 			return ((*so->so_proto->pr_ctloutput)
   1562        1.1       cgd 				  (PRCO_GETOPT, so, level, optname, mp));
   1563        1.1       cgd 		} else
   1564        1.1       cgd 			return (ENOPROTOOPT);
   1565        1.1       cgd 	} else {
   1566        1.1       cgd 		m = m_get(M_WAIT, MT_SOOPTS);
   1567       1.36     perry 		m->m_len = sizeof(int);
   1568        1.1       cgd 
   1569        1.1       cgd 		switch (optname) {
   1570        1.1       cgd 
   1571        1.1       cgd 		case SO_LINGER:
   1572       1.36     perry 			m->m_len = sizeof(struct linger);
   1573        1.1       cgd 			mtod(m, struct linger *)->l_onoff =
   1574        1.1       cgd 				so->so_options & SO_LINGER;
   1575        1.1       cgd 			mtod(m, struct linger *)->l_linger = so->so_linger;
   1576        1.1       cgd 			break;
   1577        1.1       cgd 
   1578        1.1       cgd 		case SO_USELOOPBACK:
   1579        1.1       cgd 		case SO_DONTROUTE:
   1580        1.1       cgd 		case SO_DEBUG:
   1581        1.1       cgd 		case SO_KEEPALIVE:
   1582        1.1       cgd 		case SO_REUSEADDR:
   1583       1.15   mycroft 		case SO_REUSEPORT:
   1584        1.1       cgd 		case SO_BROADCAST:
   1585        1.1       cgd 		case SO_OOBINLINE:
   1586       1.26   thorpej 		case SO_TIMESTAMP:
   1587        1.1       cgd 			*mtod(m, int *) = so->so_options & optname;
   1588        1.1       cgd 			break;
   1589        1.1       cgd 
   1590        1.1       cgd 		case SO_TYPE:
   1591        1.1       cgd 			*mtod(m, int *) = so->so_type;
   1592        1.1       cgd 			break;
   1593        1.1       cgd 
   1594        1.1       cgd 		case SO_ERROR:
   1595        1.1       cgd 			*mtod(m, int *) = so->so_error;
   1596        1.1       cgd 			so->so_error = 0;
   1597        1.1       cgd 			break;
   1598        1.1       cgd 
   1599        1.1       cgd 		case SO_SNDBUF:
   1600        1.1       cgd 			*mtod(m, int *) = so->so_snd.sb_hiwat;
   1601        1.1       cgd 			break;
   1602        1.1       cgd 
   1603        1.1       cgd 		case SO_RCVBUF:
   1604        1.1       cgd 			*mtod(m, int *) = so->so_rcv.sb_hiwat;
   1605        1.1       cgd 			break;
   1606        1.1       cgd 
   1607        1.1       cgd 		case SO_SNDLOWAT:
   1608        1.1       cgd 			*mtod(m, int *) = so->so_snd.sb_lowat;
   1609        1.1       cgd 			break;
   1610        1.1       cgd 
   1611        1.1       cgd 		case SO_RCVLOWAT:
   1612        1.1       cgd 			*mtod(m, int *) = so->so_rcv.sb_lowat;
   1613        1.1       cgd 			break;
   1614        1.1       cgd 
   1615        1.1       cgd 		case SO_SNDTIMEO:
   1616        1.1       cgd 		case SO_RCVTIMEO:
   1617        1.1       cgd 		    {
   1618        1.1       cgd 			int val = (optname == SO_SNDTIMEO ?
   1619        1.1       cgd 			     so->so_snd.sb_timeo : so->so_rcv.sb_timeo);
   1620        1.1       cgd 
   1621        1.1       cgd 			m->m_len = sizeof(struct timeval);
   1622        1.1       cgd 			mtod(m, struct timeval *)->tv_sec = val / hz;
   1623        1.1       cgd 			mtod(m, struct timeval *)->tv_usec =
   1624       1.27    kleink 			    (val % hz) * tick;
   1625        1.1       cgd 			break;
   1626        1.1       cgd 		    }
   1627        1.1       cgd 
   1628      1.107   darrenr 		case SO_OVERFLOWED:
   1629      1.107   darrenr 			*mtod(m, int *) = so->so_rcv.sb_overflowed;
   1630      1.107   darrenr 			break;
   1631      1.107   darrenr 
   1632        1.1       cgd 		default:
   1633        1.1       cgd 			(void)m_free(m);
   1634        1.1       cgd 			return (ENOPROTOOPT);
   1635        1.1       cgd 		}
   1636        1.1       cgd 		*mp = m;
   1637        1.1       cgd 		return (0);
   1638        1.1       cgd 	}
   1639        1.1       cgd }
   1640        1.1       cgd 
   1641       1.14   mycroft void
   1642       1.54     lukem sohasoutofband(struct socket *so)
   1643        1.1       cgd {
   1644       1.90  christos 	fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);
   1645        1.2       cgd 	selwakeup(&so->so_rcv.sb_sel);
   1646        1.1       cgd }
   1647       1.72  jdolecek 
   1648       1.72  jdolecek static void
   1649       1.72  jdolecek filt_sordetach(struct knote *kn)
   1650       1.72  jdolecek {
   1651       1.72  jdolecek 	struct socket	*so;
   1652       1.72  jdolecek 
   1653       1.72  jdolecek 	so = (struct socket *)kn->kn_fp->f_data;
   1654       1.73  christos 	SLIST_REMOVE(&so->so_rcv.sb_sel.sel_klist, kn, knote, kn_selnext);
   1655       1.73  christos 	if (SLIST_EMPTY(&so->so_rcv.sb_sel.sel_klist))
   1656       1.72  jdolecek 		so->so_rcv.sb_flags &= ~SB_KNOTE;
   1657       1.72  jdolecek }
   1658       1.72  jdolecek 
   1659       1.72  jdolecek /*ARGSUSED*/
   1660       1.72  jdolecek static int
   1661       1.72  jdolecek filt_soread(struct knote *kn, long hint)
   1662       1.72  jdolecek {
   1663       1.72  jdolecek 	struct socket	*so;
   1664       1.72  jdolecek 
   1665       1.72  jdolecek 	so = (struct socket *)kn->kn_fp->f_data;
   1666       1.72  jdolecek 	kn->kn_data = so->so_rcv.sb_cc;
   1667       1.72  jdolecek 	if (so->so_state & SS_CANTRCVMORE) {
   1668      1.108     perry 		kn->kn_flags |= EV_EOF;
   1669       1.72  jdolecek 		kn->kn_fflags = so->so_error;
   1670       1.72  jdolecek 		return (1);
   1671       1.72  jdolecek 	}
   1672       1.72  jdolecek 	if (so->so_error)	/* temporary udp error */
   1673       1.72  jdolecek 		return (1);
   1674       1.72  jdolecek 	if (kn->kn_sfflags & NOTE_LOWAT)
   1675       1.72  jdolecek 		return (kn->kn_data >= kn->kn_sdata);
   1676       1.72  jdolecek 	return (kn->kn_data >= so->so_rcv.sb_lowat);
   1677       1.72  jdolecek }
   1678       1.72  jdolecek 
   1679       1.72  jdolecek static void
   1680       1.72  jdolecek filt_sowdetach(struct knote *kn)
   1681       1.72  jdolecek {
   1682       1.72  jdolecek 	struct socket	*so;
   1683       1.72  jdolecek 
   1684       1.72  jdolecek 	so = (struct socket *)kn->kn_fp->f_data;
   1685       1.73  christos 	SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);
   1686       1.73  christos 	if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))
   1687       1.72  jdolecek 		so->so_snd.sb_flags &= ~SB_KNOTE;
   1688       1.72  jdolecek }
   1689       1.72  jdolecek 
   1690       1.72  jdolecek /*ARGSUSED*/
   1691       1.72  jdolecek static int
   1692       1.72  jdolecek filt_sowrite(struct knote *kn, long hint)
   1693       1.72  jdolecek {
   1694       1.72  jdolecek 	struct socket	*so;
   1695       1.72  jdolecek 
   1696       1.72  jdolecek 	so = (struct socket *)kn->kn_fp->f_data;
   1697       1.72  jdolecek 	kn->kn_data = sbspace(&so->so_snd);
   1698       1.72  jdolecek 	if (so->so_state & SS_CANTSENDMORE) {
   1699      1.108     perry 		kn->kn_flags |= EV_EOF;
   1700       1.72  jdolecek 		kn->kn_fflags = so->so_error;
   1701       1.72  jdolecek 		return (1);
   1702       1.72  jdolecek 	}
   1703       1.72  jdolecek 	if (so->so_error)	/* temporary udp error */
   1704       1.72  jdolecek 		return (1);
   1705       1.72  jdolecek 	if (((so->so_state & SS_ISCONNECTED) == 0) &&
   1706       1.72  jdolecek 	    (so->so_proto->pr_flags & PR_CONNREQUIRED))
   1707       1.72  jdolecek 		return (0);
   1708       1.72  jdolecek 	if (kn->kn_sfflags & NOTE_LOWAT)
   1709       1.72  jdolecek 		return (kn->kn_data >= kn->kn_sdata);
   1710       1.72  jdolecek 	return (kn->kn_data >= so->so_snd.sb_lowat);
   1711       1.72  jdolecek }
   1712       1.72  jdolecek 
   1713       1.72  jdolecek /*ARGSUSED*/
   1714       1.72  jdolecek static int
   1715       1.72  jdolecek filt_solisten(struct knote *kn, long hint)
   1716       1.72  jdolecek {
   1717       1.72  jdolecek 	struct socket	*so;
   1718       1.72  jdolecek 
   1719       1.72  jdolecek 	so = (struct socket *)kn->kn_fp->f_data;
   1720       1.72  jdolecek 
   1721       1.72  jdolecek 	/*
   1722       1.72  jdolecek 	 * Set kn_data to number of incoming connections, not
   1723       1.72  jdolecek 	 * counting partial (incomplete) connections.
   1724      1.108     perry 	 */
   1725       1.72  jdolecek 	kn->kn_data = so->so_qlen;
   1726       1.72  jdolecek 	return (kn->kn_data > 0);
   1727       1.72  jdolecek }
   1728       1.72  jdolecek 
   1729       1.72  jdolecek static const struct filterops solisten_filtops =
   1730       1.72  jdolecek 	{ 1, NULL, filt_sordetach, filt_solisten };
   1731       1.72  jdolecek static const struct filterops soread_filtops =
   1732       1.72  jdolecek 	{ 1, NULL, filt_sordetach, filt_soread };
   1733       1.72  jdolecek static const struct filterops sowrite_filtops =
   1734       1.72  jdolecek 	{ 1, NULL, filt_sowdetach, filt_sowrite };
   1735       1.72  jdolecek 
   1736       1.72  jdolecek int
   1737       1.72  jdolecek soo_kqfilter(struct file *fp, struct knote *kn)
   1738       1.72  jdolecek {
   1739       1.72  jdolecek 	struct socket	*so;
   1740       1.72  jdolecek 	struct sockbuf	*sb;
   1741       1.72  jdolecek 
   1742       1.72  jdolecek 	so = (struct socket *)kn->kn_fp->f_data;
   1743       1.72  jdolecek 	switch (kn->kn_filter) {
   1744       1.72  jdolecek 	case EVFILT_READ:
   1745       1.72  jdolecek 		if (so->so_options & SO_ACCEPTCONN)
   1746       1.72  jdolecek 			kn->kn_fop = &solisten_filtops;
   1747       1.72  jdolecek 		else
   1748       1.72  jdolecek 			kn->kn_fop = &soread_filtops;
   1749       1.72  jdolecek 		sb = &so->so_rcv;
   1750       1.72  jdolecek 		break;
   1751       1.72  jdolecek 	case EVFILT_WRITE:
   1752       1.72  jdolecek 		kn->kn_fop = &sowrite_filtops;
   1753       1.72  jdolecek 		sb = &so->so_snd;
   1754       1.72  jdolecek 		break;
   1755       1.72  jdolecek 	default:
   1756       1.72  jdolecek 		return (1);
   1757       1.72  jdolecek 	}
   1758       1.73  christos 	SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);
   1759       1.72  jdolecek 	sb->sb_flags |= SB_KNOTE;
   1760       1.72  jdolecek 	return (0);
   1761       1.72  jdolecek }
   1762       1.72  jdolecek 
   1763       1.94      yamt #include <sys/sysctl.h>
   1764       1.94      yamt 
   1765       1.94      yamt static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);
   1766       1.94      yamt 
   1767       1.94      yamt /*
   1768       1.94      yamt  * sysctl helper routine for kern.somaxkva.  ensures that the given
   1769       1.94      yamt  * value is not too small.
   1770       1.94      yamt  * (XXX should we maybe make sure it's not too large as well?)
   1771       1.94      yamt  */
   1772       1.94      yamt static int
   1773       1.94      yamt sysctl_kern_somaxkva(SYSCTLFN_ARGS)
   1774       1.94      yamt {
   1775       1.94      yamt 	int error, new_somaxkva;
   1776       1.94      yamt 	struct sysctlnode node;
   1777       1.94      yamt 	int s;
   1778       1.94      yamt 
   1779       1.94      yamt 	new_somaxkva = somaxkva;
   1780       1.94      yamt 	node = *rnode;
   1781       1.94      yamt 	node.sysctl_data = &new_somaxkva;
   1782       1.94      yamt 	error = sysctl_lookup(SYSCTLFN_CALL(&node));
   1783       1.94      yamt 	if (error || newp == NULL)
   1784       1.94      yamt 		return (error);
   1785       1.94      yamt 
   1786       1.94      yamt 	if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */
   1787       1.94      yamt 		return (EINVAL);
   1788       1.94      yamt 
   1789       1.94      yamt 	s = splvm();
   1790       1.94      yamt 	simple_lock(&so_pendfree_slock);
   1791       1.94      yamt 	somaxkva = new_somaxkva;
   1792       1.94      yamt 	wakeup(&socurkva);
   1793       1.94      yamt 	simple_unlock(&so_pendfree_slock);
   1794       1.94      yamt 	splx(s);
   1795       1.94      yamt 
   1796       1.94      yamt 	return (error);
   1797       1.94      yamt }
   1798       1.94      yamt 
   1799       1.94      yamt SYSCTL_SETUP(sysctl_kern_somaxkva_setup, "sysctl kern.somaxkva setup")
   1800       1.94      yamt {
   1801       1.94      yamt 
   1802       1.97    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1803       1.97    atatat 		       CTLFLAG_PERMANENT,
   1804       1.97    atatat 		       CTLTYPE_NODE, "kern", NULL,
   1805       1.97    atatat 		       NULL, 0, NULL, 0,
   1806       1.97    atatat 		       CTL_KERN, CTL_EOL);
   1807       1.97    atatat 
   1808       1.97    atatat 	sysctl_createv(clog, 0, NULL, NULL,
   1809       1.97    atatat 		       CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
   1810      1.103    atatat 		       CTLTYPE_INT, "somaxkva",
   1811      1.103    atatat 		       SYSCTL_DESCR("Maximum amount of kernel memory to be "
   1812      1.103    atatat 				    "used for socket buffers"),
   1813       1.94      yamt 		       sysctl_kern_somaxkva, 0, NULL, 0,
   1814       1.94      yamt 		       CTL_KERN, KERN_SOMAXKVA, CTL_EOL);
   1815       1.94      yamt }
   1816