src/sys/kern/uipc_socket.c - diff

Return to uipc_socket.c CVS log

Up to [cvs.NetBSD.org] / src / sys / kern

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

Diff for /src/sys/kern/uipc_socket.c between version 1.111 and 1.111.2.7

version 1.111, 2005/05/08 18:44:39

version 1.111.2.7, 2007/09/03 14:41:18

Line 1

/* $NetBSD$ */

/*-

* This code is derived from software contributed to The NetBSD Foundation

Line 91 __KERNEL_RCSID(0, "$NetBSD$");

#include <sys/pool.h>

#include <sys/event.h>

#include <sys/poll.h>

#include <sys/kauth.h>

#include <sys/mutex.h>

#include <sys/condvar.h>

#include <uvm/uvm.h>

POOL_INIT(socket_pool, sizeof(struct socket), 0, 0, 0, "sockpl", NULL);

POOL_INIT(socket_pool, sizeof(struct socket), 0, 0, 0, "sockpl", NULL,

IPL_SOFTNET);

MALLOC_DEFINE(M_SOOPTS, "soopts", "socket options");

MALLOC_DEFINE(M_SONAME, "soname", "socket name");

Line 105 int somaxconn = SOMAXCONN;

Line 109 int somaxconn = SOMAXCONN;

#ifdef SOSEND_COUNTERS

#include <sys/device.h>

struct evcnt sosend_loan_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

static struct evcnt sosend_loan_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "sosend", "loan big");

struct evcnt sosend_copy_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

static struct evcnt sosend_copy_big = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "sosend", "copy big");

struct evcnt sosend_copy_small = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

static struct evcnt sosend_copy_small = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "sosend", "copy small");

struct evcnt sosend_kvalimit = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

static struct evcnt sosend_kvalimit = EVCNT_INITIALIZER(EVCNT_TYPE_MISC,

NULL, "sosend", "kva limit");

#define SOSEND_COUNTER_INCR(ev) (ev)->ev_count++

Line 126 EVCNT_ATTACH_STATIC(sosend_kvalimit);

Line 130 EVCNT_ATTACH_STATIC(sosend_kvalimit);

#endif /* SOSEND_COUNTERS */

void

static struct callback_entry sokva_reclaimerentry;

soinit(void)

{

/* Set the initial adjusted socket buffer size. */

if (sb_max_set(sb_max))

panic("bad initial sb_max value: %lu", sb_max);

}

#ifdef SOSEND_NO_LOAN

int use_sosend_loan = 0;

int sock_loan_thresh = -1;

#else

int use_sosend_loan = 1;

int sock_loan_thresh = 4096;

#endif

struct simplelock so_pendfree_slock = SIMPLELOCK_INITIALIZER;

static kmutex_t so_pendfree_lock;

struct mbuf *so_pendfree;

static struct mbuf *so_pendfree;

#ifndef SOMAXKVA

#define SOMAXKVA (16 * 1024 * 1024)

#endif

int somaxkva = SOMAXKVA;

int socurkva;

static int socurkva;

int sokvawaiters;

static kcondvar_t socurkva_cv;

#define SOCK_LOAN_THRESH 4096

#define SOCK_LOAN_CHUNK 65536

static size_t sodopendfree(struct socket *);

static size_t sodopendfree(void);

static size_t sodopendfreel(struct socket *);

static size_t sodopendfreel(void);

static __inline vsize_t sokvareserve(struct socket *, vsize_t);

static __inline void sokvaunreserve(vsize_t);

static __inline vsize_t

static vsize_t

sokvareserve(struct socket *so, vsize_t len)

{

int s;

int error;

s = splvm();

mutex_enter(&so_pendfree_lock);

simple_lock(&so_pendfree_slock);

while (socurkva + len > somaxkva) {

size_t freed;

Line 175 sokvareserve(struct socket *so, vsize_t

Line 166 sokvareserve(struct socket *so, vsize_t

* try to do pendfree.

freed = sodopendfreel(so);

freed = sodopendfreel();

* if some kva was freed, try again.

Line 185 sokvareserve(struct socket *so, vsize_t

Line 176 sokvareserve(struct socket *so, vsize_t

continue;

SOSEND_COUNTER_INCR(&sosend_kvalimit);

sokvawaiters++;

error = cv_wait_sig(&socurkva_cv, &so_pendfree_lock);

error = ltsleep(&socurkva, PVM | PCATCH, "sokva", 0,

&so_pendfree_slock);

sokvawaiters--;

if (error) {

len = 0;

break;

}

socurkva += len;

simple_unlock(&so_pendfree_slock);

mutex_exit(&so_pendfree_lock);

splx(s);

return len;

}

static __inline void

static void

sokvaunreserve(vsize_t len)

{

int s;

s = splvm();

mutex_enter(&so_pendfree_lock);

simple_lock(&so_pendfree_slock);

socurkva -= len;

if (sokvawaiters)

cv_broadcast(&socurkva_cv);

wakeup(&socurkva);

mutex_exit(&so_pendfree_lock);

simple_unlock(&so_pendfree_slock);

splx(s);

}

Line 265 sokvafree(vaddr_t sva, vsize_t len)

Line 248 sokvafree(vaddr_t sva, vsize_t len)

}

static void

sodoloanfree(struct vm_page **pgs, caddr_t buf, size_t size)

sodoloanfree(struct vm_page **pgs, void *buf, size_t size, bool mapped)

{

vaddr_t va, sva, eva;

vaddr_t sva, eva;

vsize_t len;

paddr_t pa;

int npgs;

int i, npgs;

KASSERT(pgs != NULL);

eva = round_page((vaddr_t) buf + size);

sva = trunc_page((vaddr_t) buf);

len = eva - sva;

npgs = len >> PAGE_SHIFT;

if (__predict_false(pgs == NULL)) {

if (mapped) {

pgs = alloca(npgs * sizeof(*pgs));

pmap_kremove(sva, len);

pmap_update(pmap_kernel());

for (i = 0, va = sva; va < eva; i++, va += PAGE_SIZE) {

if (pmap_extract(pmap_kernel(), va, &pa) == FALSE)

panic("sodoloanfree: va 0x%lx not mapped", va);

pgs[i] = PHYS_TO_VM_PAGE(pa);

}

pmap_kremove(sva, len);

pmap_update(pmap_kernel());

uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);

sokvafree(sva, len);

}

static size_t

sodopendfree(struct socket *so)

sodopendfree()

{

int s;

size_t rv;

s = splvm();

mutex_enter(&so_pendfree_lock);

simple_lock(&so_pendfree_slock);

rv = sodopendfreel();

rv = sodopendfreel(so);

mutex_exit(&so_pendfree_lock);

simple_unlock(&so_pendfree_slock);

splx(s);

return rv;

}

* sodopendfreel: free mbufs on "pendfree" list.

* unlock and relock so_pendfree_slock when freeing mbufs.

* unlock and relock so_pendfree_lock when freeing mbufs.

* => called with so_pendfree_slock held.

* => called with so_pendfree_lock held.

* => called at splvm.

static size_t

sodopendfreel(struct socket *so)

sodopendfreel()

{

struct mbuf *m, *next;

size_t rv = 0;

int s;

LOCK_ASSERT(simple_lock_held(&so_pendfree_slock));

KASSERT(mutex_owned(&so_pendfree_lock));

for (;;) {

struct mbuf *m;

struct mbuf *next;

while (so_pendfree != NULL) {

m = so_pendfree;

if (m == NULL)

break;

so_pendfree = NULL;

simple_unlock(&so_pendfree_slock);

mutex_exit(&so_pendfree_lock);

/* XXX splx */

for (; m != NULL; m = next) {

next = m->m_next;

KASSERT((~m->m_flags & (M_EXT|M_EXT_PAGES)) == 0);

KASSERT(m->m_ext.ext_refcnt == 0);

rv += m->m_ext.ext_size;

sodoloanfree((m->m_flags & M_EXT_PAGES) ?

sodoloanfree(m->m_ext.ext_pgs, m->m_ext.ext_buf,

m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,

m->m_ext.ext_size,

m->m_ext.ext_size);

(m->m_ext.ext_flags & M_EXT_LAZY) == 0);

s = splvm();

pool_cache_put(&mbpool_cache, m);

splx(s);

}

/* XXX splvm */

mutex_enter(&so_pendfree_lock);

simple_lock(&so_pendfree_slock);

}

return (rv);

}

void

soloanfree(struct mbuf *m, caddr_t buf, size_t size, void *arg)

soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)

{

int s;

if (m == NULL) {

KASSERT(m != NULL);

* called from MEXTREMOVE.

sodoloanfree(NULL, buf, size);

return;

}

* postpone freeing mbuf.

Line 373 soloanfree(struct mbuf *m, caddr_t buf,

Line 335 soloanfree(struct mbuf *m, caddr_t buf,

* because we need to put kva back to kernel_map.

s = splvm();

mutex_enter(&so_pendfree_lock);

simple_lock(&so_pendfree_slock);

m->m_next = so_pendfree;

so_pendfree = m;

if (sokvawaiters)

cv_broadcast(&socurkva_cv);

wakeup(&socurkva);

mutex_exit(&so_pendfree_lock);

simple_unlock(&so_pendfree_slock);

splx(s);

}

static long

Line 389 sosend_loan(struct socket *so, struct ui

Line 348 sosend_loan(struct socket *so, struct ui

struct iovec *iov = uio->uio_iov;

vaddr_t sva, eva;

vsize_t len;

vaddr_t lva, va;

vaddr_t lva;

int npgs, i, error;

int npgs, error;

#if !defined(__HAVE_LAZY_MBUF)

vaddr_t va;

int i;

#endif /* !defined(__HAVE_LAZY_MBUF) */

if (uio->uio_segflg != UIO_USERSPACE)

if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))

return (0);

if (iov->iov_len < (size_t) space)

Line 407 sosend_loan(struct socket *so, struct ui

Line 370 sosend_loan(struct socket *so, struct ui

/* XXX KDASSERT */

KASSERT(npgs <= M_EXT_MAXPAGES);

KASSERT(uio->uio_procp != NULL);

lva = sokvaalloc(len, so);

if (lva == 0)

return 0;

error = uvm_loan(&uio->uio_procp->p_vmspace->vm_map, sva, len,

error = uvm_loan(&uio->uio_vmspace->vm_map, sva, len,

m->m_ext.ext_pgs, UVM_LOAN_TOPAGE);

if (error) {

sokvafree(lva, len);

return (0);

}

#if !defined(__HAVE_LAZY_MBUF)

for (i = 0, va = lva; i < npgs; i++, va += PAGE_SIZE)

pmap_kenter_pa(va, VM_PAGE_TO_PHYS(m->m_ext.ext_pgs[i]),

VM_PROT_READ);

pmap_update(pmap_kernel());

#endif /* !defined(__HAVE_LAZY_MBUF) */

lva += (vaddr_t) iov->iov_base & PAGE_MASK;

MEXTADD(m, (caddr_t) lva, space, M_MBUF, soloanfree, so);

MEXTADD(m, (void *) lva, space, M_MBUF, soloanfree, so);

m->m_flags |= M_EXT_PAGES | M_EXT_ROMAP;

#if defined(__HAVE_LAZY_MBUF)

m->m_flags |= M_EXT_LAZY;

m->m_ext.ext_flags |= M_EXT_LAZY;

#endif /* defined(__HAVE_LAZY_MBUF) */

uio->uio_resid -= space;

/* uio_offset not updated, not set/used for write(2) */

uio->uio_iov->iov_base = (caddr_t) uio->uio_iov->iov_base + space;

uio->uio_iov->iov_base = (char *)uio->uio_iov->iov_base + space;

uio->uio_iov->iov_len -= space;

if (uio->uio_iov->iov_len == 0) {

uio->uio_iov++;

Line 442 sosend_loan(struct socket *so, struct ui

Line 411 sosend_loan(struct socket *so, struct ui

return (space);

}

static int

sokva_reclaim_callback(struct callback_entry *ce, void *obj, void *arg)

{

KASSERT(ce == &sokva_reclaimerentry);

KASSERT(obj == NULL);

sodopendfree();

if (!vm_map_starved_p(kernel_map)) {

return CALLBACK_CHAIN_ABORT;

}

return CALLBACK_CHAIN_CONTINUE;

}

void

soinit(void)

{

mutex_init(&so_pendfree_lock, MUTEX_DRIVER, IPL_VM);

cv_init(&socurkva_cv, "sokva");

/* Set the initial adjusted socket buffer size. */

if (sb_max_set(sb_max))

panic("bad initial sb_max value: %lu", sb_max);

callback_register(&vm_map_to_kernel(kernel_map)->vmk_reclaim_callback,

&sokva_reclaimerentry, NULL, sokva_reclaim_callback);

}

* Socket operation routines.

* These routines are called by the routines in

Line 451 sosend_loan(struct socket *so, struct ui

Line 449 sosend_loan(struct socket *so, struct ui

/*ARGSUSED*/

int

socreate(int dom, struct socket **aso, int type, int proto, struct proc *p)

socreate(int dom, struct socket **aso, int type, int proto, struct lwp *l)

{

const struct protosw *prp;

struct socket *so;

uid_t uid;

int error, s;

error = kauth_authorize_network(l->l_cred, KAUTH_NETWORK_SOCKET,

KAUTH_REQ_NETWORK_SOCKET_OPEN, KAUTH_ARG(dom), KAUTH_ARG(type),

KAUTH_ARG(proto));

if (error != 0)

return error;

if (proto)

prp = pffindproto(dom, proto, type);

else

prp = pffindtype(dom, type);

if (prp == 0 || prp->pr_usrreq == 0)

if (prp == NULL) {

return (EPROTONOSUPPORT);

/* no support for domain */

if (pffinddomain(dom) == 0)

return EAFNOSUPPORT;

/* no support for socket type */

if (proto == 0 && type != 0)

return EPROTOTYPE;

return EPROTONOSUPPORT;

}

if (prp->pr_usrreq == NULL)

return EPROTONOSUPPORT;

if (prp->pr_type != type)

return (EPROTOTYPE);

return EPROTOTYPE;

s = splsoftnet();

so = pool_get(&socket_pool, PR_WAITOK);

memset((caddr_t)so, 0, sizeof(*so));

memset(so, 0, sizeof(*so));

TAILQ_INIT(&so->so_q0);

TAILQ_INIT(&so->so_q);

so->so_type = type;

Line 479 socreate(int dom, struct socket **aso, i

Line 493 socreate(int dom, struct socket **aso, i

so->so_snd.sb_mowner = &prp->pr_domain->dom_mowner;

so->so_mowner = &prp->pr_domain->dom_mowner;

#endif

if (p != 0)

uid = kauth_cred_geteuid(l->l_cred);

so->so_uidinfo = uid_find(p->p_ucred->cr_uid);

so->so_uidinfo = uid_find(uid);

else

error = (*prp->pr_usrreq)(so, PRU_ATTACH, NULL,

so->so_uidinfo = uid_find(0);

(struct mbuf *)(long)proto, NULL, l);

error = (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,

if (error != 0) {

(struct mbuf *)(long)proto, (struct mbuf *)0, p);

if (error) {

so->so_state |= SS_NOFDREF;

sofree(so);

splx(s);

return (error);

return error;

}

splx(s);

*aso = so;

return (0);

return 0;

}

int

sobind(struct socket *so, struct mbuf *nam, struct proc *p)

sobind(struct socket *so, struct mbuf *nam, struct lwp *l)

{

int s, error;

s = splsoftnet();

error = (*so->so_proto->pr_usrreq)(so, PRU_BIND, (struct mbuf *)0,

error = (*so->so_proto->pr_usrreq)(so, PRU_BIND, NULL, nam, NULL, l);

nam, (struct mbuf *)0, p);

splx(s);

return (error);

return error;

}

int

Line 514 solisten(struct socket *so, int backlog)

Line 525 solisten(struct socket *so, int backlog)

int s, error;

s = splsoftnet();

error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, (struct mbuf *)0,

error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, NULL,

(struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);

NULL, NULL, NULL);

if (error) {

if (error != 0) {

splx(s);

return (error);

return error;

}

if (TAILQ_EMPTY(&so->so_q))

so->so_options |= SO_ACCEPTCONN;

Line 526 solisten(struct socket *so, int backlog)

Line 537 solisten(struct socket *so, int backlog)

backlog = 0;

so->so_qlimit = min(backlog, somaxconn);

splx(s);

return (0);

return 0;

}

void

Line 591 soclose(struct socket *so)

Line 602 soclose(struct socket *so)

(so->so_state & SS_NBIO))

goto drop;

while (so->so_state & SS_ISCONNECTED) {

error = tsleep((caddr_t)&so->so_timeo,

error = tsleep((void *)&so->so_timeo,

PSOCK | PCATCH, netcls,

so->so_linger * hz);

if (error)

Line 602 soclose(struct socket *so)

Line 613 soclose(struct socket *so)

drop:

if (so->so_pcb) {

int error2 = (*so->so_proto->pr_usrreq)(so, PRU_DETACH,

(struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0,

NULL, NULL, NULL, NULL);

(struct proc *)0);

if (error == 0)

error = error2;

}

Line 622 soclose(struct socket *so)

Line 632 soclose(struct socket *so)

int

soabort(struct socket *so)

{

int error;

return (*so->so_proto->pr_usrreq)(so, PRU_ABORT, (struct mbuf *)0,

KASSERT(so->so_head == NULL);

(struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);

error = (*so->so_proto->pr_usrreq)(so, PRU_ABORT, NULL,

NULL, NULL, NULL);

if (error) {

sofree(so);

}

return error;

}

int

Line 640 soaccept(struct socket *so, struct mbuf

Line 656 soaccept(struct socket *so, struct mbuf

if ((so->so_state & SS_ISDISCONNECTED) == 0 ||

(so->so_proto->pr_flags & PR_ABRTACPTDIS) == 0)

error = (*so->so_proto->pr_usrreq)(so, PRU_ACCEPT,

(struct mbuf *)0, nam, (struct mbuf *)0, (struct proc *)0);

NULL, nam, NULL, NULL);

else

error = ECONNABORTED;

Line 649 soaccept(struct socket *so, struct mbuf

Line 665 soaccept(struct socket *so, struct mbuf

}

int

soconnect(struct socket *so, struct mbuf *nam, struct proc *p)

soconnect(struct socket *so, struct mbuf *nam, struct lwp *l)

{

int s, error;

Line 668 soconnect(struct socket *so, struct mbuf

Line 684 soconnect(struct socket *so, struct mbuf

error = EISCONN;

else

error = (*so->so_proto->pr_usrreq)(so, PRU_CONNECT,

(struct mbuf *)0, nam, (struct mbuf *)0, p);

NULL, nam, NULL, l);

splx(s);

return (error);

}

Line 680 soconnect2(struct socket *so1, struct so

Line 696 soconnect2(struct socket *so1, struct so

s = splsoftnet();

error = (*so1->so_proto->pr_usrreq)(so1, PRU_CONNECT2,

(struct mbuf *)0, (struct mbuf *)so2, (struct mbuf *)0,

NULL, (struct mbuf *)so2, NULL, NULL);

(struct proc *)0);

splx(s);

return (error);

}

Line 701 sodisconnect(struct socket *so)

Line 716 sodisconnect(struct socket *so)

goto bad;

}

error = (*so->so_proto->pr_usrreq)(so, PRU_DISCONNECT,

(struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0,

NULL, NULL, NULL, NULL);

(struct proc *)0);

bad:

splx(s);

sodopendfree(so);

sodopendfree();

return (error);

}

Line 729 sodisconnect(struct socket *so)

Line 743 sodisconnect(struct socket *so)

int

sosend(struct socket *so, struct mbuf *addr, struct uio *uio, struct mbuf *top,

struct mbuf *control, int flags, struct proc *p)

struct mbuf *control, int flags, struct lwp *l)

{

struct mbuf **mp, *m;

struct proc *p;

long space, len, resid, clen, mlen;

int error, s, dontroute, atomic;

sodopendfree(so);

p = l->l_proc;

sodopendfree();

clen = 0;

atomic = sosendallatonce(so) || top;

Line 817 sosend(struct socket *so, struct mbuf *a

Line 833 sosend(struct socket *so, struct mbuf *a

m = m_gethdr(M_WAIT, MT_DATA);

mlen = MHLEN;

m->m_pkthdr.len = 0;

m->m_pkthdr.rcvif = (struct ifnet *)0;

m->m_pkthdr.rcvif = NULL;

} else {

m = m_get(M_WAIT, MT_DATA);

mlen = MLEN;

}

MCLAIM(m, so->so_snd.sb_mowner);

if (use_sosend_loan &&

if (sock_loan_thresh >= 0 &&

uio->uio_iov->iov_len >= SOCK_LOAN_THRESH &&

uio->uio_iov->iov_len >= sock_loan_thresh &&

space >= SOCK_LOAN_THRESH &&

space >= sock_loan_thresh &&

(len = sosend_loan(so, uio, m,

space)) != 0) {

SOSEND_COUNTER_INCR(&sosend_loan_big);

Line 857 sosend(struct socket *so, struct mbuf *a

Line 873 sosend(struct socket *so, struct mbuf *a

if (atomic && top == 0 && len < mlen)

MH_ALIGN(m, len);

}

error = uiomove(mtod(m, caddr_t), (int)len,

error = uiomove(mtod(m, void *), (int)len,

uio);

have_data:

resid = uio->uio_resid;

Line 885 sosend(struct socket *so, struct mbuf *a

Line 901 sosend(struct socket *so, struct mbuf *a

so->so_state |= SS_MORETOCOME;

error = (*so->so_proto->pr_usrreq)(so,

(flags & MSG_OOB) ? PRU_SENDOOB : PRU_SEND,

top, addr, control, p);

top, addr, control, curlwp); /* XXX */

if (dontroute)

so->so_options &= ~SO_DONTROUTE;

if (resid > 0)

Line 931 int

Line 947 int

soreceive(struct socket *so, struct mbuf **paddr, struct uio *uio,

struct mbuf **mp0, struct mbuf **controlp, int *flagsp)

{

struct proc * p;

struct lwp *l = curlwp;

struct mbuf *m, **mp;

int flags, len, error, s, offset, moff, type, orig_resid;

const struct protosw *pr;

Line 942 soreceive(struct socket *so, struct mbuf

Line 958 soreceive(struct socket *so, struct mbuf

mp = mp0;

type = 0;

orig_resid = uio->uio_resid;

p = uio->uio_procp;

if (paddr)

*paddr = 0;

Line 954 soreceive(struct socket *so, struct mbuf

Line 969 soreceive(struct socket *so, struct mbuf

flags = 0;

if ((flags & MSG_DONTWAIT) == 0)

sodopendfree(so);

sodopendfree();

if (flags & MSG_OOB) {

m = m_get(M_WAIT, MT_DATA);

error = (*pr->pr_usrreq)(so, PRU_RCVOOB, m,

(struct mbuf *)(long)(flags & MSG_PEEK),

(struct mbuf *)(long)(flags & MSG_PEEK), NULL, l);

(struct mbuf *)0, p);

if (error)

goto bad;

do {

error = uiomove(mtod(m, caddr_t),

error = uiomove(mtod(m, void *),

(int) min(uio->uio_resid, m->m_len), uio);

m = m_free(m);

} while (uio->uio_resid && error == 0 && m);

Line 974 soreceive(struct socket *so, struct mbuf

Line 988 soreceive(struct socket *so, struct mbuf

return (error);

}

if (mp)

*mp = (struct mbuf *)0;

*mp = NULL;

if (so->so_state & SS_ISCONFIRMING && uio->uio_resid)

(*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,

(*pr->pr_usrreq)(so, PRU_RCVD, NULL, NULL, NULL, l);

(struct mbuf *)0, (struct mbuf *)0, p);

restart:

if ((error = sblock(&so->so_rcv, SBLOCKWAIT(flags))) != 0)

Line 1050 soreceive(struct socket *so, struct mbuf

Line 1063 soreceive(struct socket *so, struct mbuf

* While we process the initial mbufs containing address and control

* info, we save a copy of m->m_nextpkt into nextrecord.

if (p)

if (l)

p->p_stats->p_ru.ru_msgrcv++;

l->l_proc->p_stats->p_ru.ru_msgrcv++;

KASSERT(m == so->so_rcv.sb_mb);

SBLASTRECORDCHK(&so->so_rcv, "soreceive 1");

SBLASTMBUFCHK(&so->so_rcv, "soreceive 1");

Line 1090 soreceive(struct socket *so, struct mbuf

Line 1103 soreceive(struct socket *so, struct mbuf

mbuf_removed = 1;

if (controlp) {

struct domain *dom = pr->pr_domain;

if (dom->dom_externalize && p &&

if (dom->dom_externalize && l &&

mtod(m, struct cmsghdr *)->cmsg_type ==

SCM_RIGHTS)

error = (*dom->dom_externalize)(m, p);

error = (*dom->dom_externalize)(m, l);

*controlp = m;

so->so_rcv.sb_mb = m->m_next;

m->m_next = 0;

Line 1178 soreceive(struct socket *so, struct mbuf

Line 1191 soreceive(struct socket *so, struct mbuf

SBLASTRECORDCHK(&so->so_rcv, "soreceive uiomove");

SBLASTMBUFCHK(&so->so_rcv, "soreceive uiomove");

splx(s);

error = uiomove(mtod(m, caddr_t) + moff, (int)len, uio);

error = uiomove(mtod(m, char *) + moff, (int)len, uio);

s = splsoftnet();

if (error) {

Line 1213 soreceive(struct socket *so, struct mbuf

Line 1226 soreceive(struct socket *so, struct mbuf

*mp = m;

mp = &m->m_next;

so->so_rcv.sb_mb = m = m->m_next;

*mp = (struct mbuf *)0;

*mp = NULL;

} else {

MFREE(m, so->so_rcv.sb_mb);

m = so->so_rcv.sb_mb;

Line 1284 soreceive(struct socket *so, struct mbuf

Line 1297 soreceive(struct socket *so, struct mbuf

if ((pr->pr_flags & PR_WANTRCVD) && so->so_pcb)

(*pr->pr_usrreq)(so, PRU_RCVD,

(struct mbuf *)0,

NULL, (struct mbuf *)(long)flags, NULL, l);

(struct mbuf *)(long)flags,

(struct mbuf *)0, p);

SBLASTRECORDCHK(&so->so_rcv, "soreceive sbwait 2");

SBLASTMBUFCHK(&so->so_rcv, "soreceive sbwait 2");

error = sbwait(&so->so_rcv);

Line 1322 soreceive(struct socket *so, struct mbuf

Line 1333 soreceive(struct socket *so, struct mbuf

SBLASTRECORDCHK(&so->so_rcv, "soreceive 4");

SBLASTMBUFCHK(&so->so_rcv, "soreceive 4");

if (pr->pr_flags & PR_WANTRCVD && so->so_pcb)

(*pr->pr_usrreq)(so, PRU_RCVD, (struct mbuf *)0,

(*pr->pr_usrreq)(so, PRU_RCVD, NULL,

(struct mbuf *)(long)flags, (struct mbuf *)0, p);

(struct mbuf *)(long)flags, NULL, l);

}

if (orig_resid == uio->uio_resid && orig_resid &&

(flags & MSG_EOR) == 0 && (so->so_state & SS_CANTRCVMORE) == 0) {

Line 1352 soshutdown(struct socket *so, int how)

Line 1363 soshutdown(struct socket *so, int how)

if (how == SHUT_RD || how == SHUT_RDWR)

sorflush(so);

if (how == SHUT_WR || how == SHUT_RDWR)

return (*pr->pr_usrreq)(so, PRU_SHUTDOWN, (struct mbuf *)0,

return (*pr->pr_usrreq)(so, PRU_SHUTDOWN, NULL,

(struct mbuf *)0, (struct mbuf *)0, (struct proc *)0);

NULL, NULL, NULL);

return (0);

}

Line 1389 sosetopt(struct socket *so, int level, i

Line 1400 sosetopt(struct socket *so, int level, i

{

int error;

struct mbuf *m;

struct linger *l;

struct sockbuf *sb;

error = 0;

m = m0;

Line 1405 sosetopt(struct socket *so, int level, i

Line 1418 sosetopt(struct socket *so, int level, i

error = EINVAL;

goto bad;

}

so->so_linger = mtod(m, struct linger *)->l_linger;

l = mtod(m, struct linger *);

/* fall thru... */

if (l->l_linger < 0 || l->l_linger > USHRT_MAX ||

l->l_linger > (INT_MAX / hz)) {

error = EDOM;

goto bad;

}

so->so_linger = l->l_linger;

if (l->l_onoff)

so->so_options |= SO_LINGER;

else

so->so_options &= ~SO_LINGER;

break;

case SO_DEBUG:

case SO_KEEPALIVE:

Line 1453 sosetopt(struct socket *so, int level, i

Line 1476 sosetopt(struct socket *so, int level, i

case SO_SNDBUF:

case SO_RCVBUF:

if (sbreserve(optname == SO_SNDBUF ?

sb = (optname == SO_SNDBUF) ?

&so->so_snd : &so->so_rcv,

&so->so_snd : &so->so_rcv;

(u_long) optval, so) == 0) {

if (sbreserve(sb, (u_long)optval, so) == 0) {

error = ENOBUFS;

goto bad;

}

sb->sb_flags &= ~SB_AUTOSIZE;

break;

Line 1546 sogetopt(struct socket *so, int level, i

Line 1570 sogetopt(struct socket *so, int level, i

case SO_LINGER:

m->m_len = sizeof(struct linger);

mtod(m, struct linger *)->l_onoff =

so->so_options & SO_LINGER;

(so->so_options & SO_LINGER) ? 1 : 0;

mtod(m, struct linger *)->l_linger = so->so_linger;

break;

Line 1559 sogetopt(struct socket *so, int level, i

Line 1583 sogetopt(struct socket *so, int level, i

case SO_BROADCAST:

case SO_OOBINLINE:

case SO_TIMESTAMP:

*mtod(m, int *) = so->so_options & optname;

*mtod(m, int *) = (so->so_options & optname) ? 1 : 0;

break;

case SO_TYPE:

Line 1749 sysctl_kern_somaxkva(SYSCTLFN_ARGS)

Line 1773 sysctl_kern_somaxkva(SYSCTLFN_ARGS)

{

int error, new_somaxkva;

struct sysctlnode node;

int s;

new_somaxkva = somaxkva;

node = *rnode;

Line 1761 sysctl_kern_somaxkva(SYSCTLFN_ARGS)

Line 1784 sysctl_kern_somaxkva(SYSCTLFN_ARGS)

if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */

return (EINVAL);

s = splvm();

mutex_enter(&so_pendfree_lock);

simple_lock(&so_pendfree_slock);

somaxkva = new_somaxkva;

wakeup(&socurkva);

cv_broadcast(&socurkva_cv);

simple_unlock(&so_pendfree_slock);

mutex_exit(&so_pendfree_lock);

splx(s);

return (error);

}

CVSweb <webmaster@jp.NetBSD.org>