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 = ⊤
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 = ⊤
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