Simplify vn_lock(), VOP_LOCK(), and VOP_UNLOCK() by removing the thread_t
[dragonfly.git] / sys / kern / uipc_syscalls.c
CommitLineData
984263bc
MD
1/*
2 * Copyright (c) 1982, 1986, 1989, 1990, 1993
3 * The Regents of the University of California. All rights reserved.
4 *
5 * sendfile(2) and related extensions:
6 * Copyright (c) 1998, David Greenman. All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. All advertising materials mentioning features or use of this software
17 * must display the following acknowledgement:
18 * This product includes software developed by the University of
19 * California, Berkeley and its contributors.
20 * 4. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 *
36 * @(#)uipc_syscalls.c 8.4 (Berkeley) 2/21/94
37 * $FreeBSD: src/sys/kern/uipc_syscalls.c,v 1.65.2.17 2003/04/04 17:11:16 tegge Exp $
ca466bae 38 * $DragonFly: src/sys/kern/uipc_syscalls.c,v 1.63 2006/05/05 21:15:09 dillon Exp $
984263bc
MD
39 */
40
984263bc 41#include "opt_ktrace.h"
78812139 42#include "opt_sctp.h"
984263bc
MD
43
44#include <sys/param.h>
45#include <sys/systm.h>
46#include <sys/kernel.h>
47#include <sys/sysproto.h>
48#include <sys/malloc.h>
49#include <sys/filedesc.h>
50#include <sys/event.h>
51#include <sys/proc.h>
52#include <sys/fcntl.h>
53#include <sys/file.h>
54#include <sys/filio.h>
5969a6f1 55#include <sys/kern_syscall.h>
984263bc
MD
56#include <sys/mbuf.h>
57#include <sys/protosw.h>
4860553a 58#include <sys/sfbuf.h>
984263bc
MD
59#include <sys/socket.h>
60#include <sys/socketvar.h>
6b6e0885 61#include <sys/socketops.h>
984263bc
MD
62#include <sys/uio.h>
63#include <sys/vnode.h>
64#include <sys/lock.h>
65#include <sys/mount.h>
66#ifdef KTRACE
67#include <sys/ktrace.h>
68#endif
69#include <vm/vm.h>
70#include <vm/vm_object.h>
71#include <vm/vm_page.h>
72#include <vm/vm_pageout.h>
73#include <vm/vm_kern.h>
74#include <vm/vm_extern.h>
dadab5e9 75#include <sys/file2.h>
770d4c4d 76#include <sys/signalvar.h>
df8d1020 77#include <sys/serialize.h>
984263bc 78
b44419cb
MD
79#include <sys/thread2.h>
80#include <sys/msgport2.h>
81
78812139
EN
82#ifdef SCTP
83#include <netinet/sctp_peeloff.h>
84#endif /* SCTP */
85
e66bab2b
MD
86struct sfbuf_mref {
87 struct sf_buf *sf;
88 int mref_count;
df8d1020 89 struct lwkt_serialize serializer;
e66bab2b
MD
90};
91
92static MALLOC_DEFINE(M_SENDFILE, "sendfile", "sendfile sfbuf ref structures");
93
984263bc
MD
94/*
95 * System call interface to the socket abstraction.
96 */
984263bc
MD
97
98extern struct fileops socketops;
99
41c20dac
MD
100/*
101 * socket_args(int domain, int type, int protocol)
102 */
984263bc 103int
75a872f8 104kern_socket(int domain, int type, int protocol, int *res)
984263bc 105{
dadab5e9
MD
106 struct thread *td = curthread;
107 struct proc *p = td->td_proc;
108 struct filedesc *fdp;
984263bc
MD
109 struct socket *so;
110 struct file *fp;
111 int fd, error;
112
dadab5e9
MD
113 KKASSERT(p);
114 fdp = p->p_fd;
115
984263bc
MD
116 error = falloc(p, &fp, &fd);
117 if (error)
118 return (error);
75a872f8 119 error = socreate(domain, &so, type, protocol, td);
984263bc 120 if (error) {
0679adc4 121 if (fdp->fd_files[fd].fp == fp) {
69908319 122 funsetfd(fdp, fd);
dadab5e9 123 fdrop(fp, td);
984263bc
MD
124 }
125 } else {
984263bc 126 fp->f_type = DTYPE_SOCKET;
fbb4eeab
JH
127 fp->f_flag = FREAD | FWRITE;
128 fp->f_ops = &socketops;
129 fp->f_data = so;
75a872f8 130 *res = fd;
984263bc 131 }
dadab5e9 132 fdrop(fp, td);
984263bc
MD
133 return (error);
134}
135
75a872f8
DRJ
136int
137socket(struct socket_args *uap)
138{
139 int error;
140
141 error = kern_socket(uap->domain, uap->type, uap->protocol,
142 &uap->sysmsg_result);
143
144 return (error);
145}
6b6e0885 146
02844a31 147int
5969a6f1 148kern_bind(int s, struct sockaddr *sa)
984263bc 149{
dadab5e9
MD
150 struct thread *td = curthread;
151 struct proc *p = td->td_proc;
984263bc 152 struct file *fp;
984263bc
MD
153 int error;
154
dadab5e9 155 KKASSERT(p);
d83b97b9 156 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
157 if (error)
158 return (error);
d83b97b9
MD
159 error = sobind((struct socket *)fp->f_data, sa, td);
160 fdrop(fp, td);
161 return (error);
162}
163
164/*
165 * bind_args(int s, caddr_t name, int namelen)
166 */
167int
168bind(struct bind_args *uap)
169{
170 struct sockaddr *sa;
171 int error;
172
984263bc 173 error = getsockaddr(&sa, uap->name, uap->namelen);
d83b97b9 174 if (error)
984263bc 175 return (error);
5969a6f1 176 error = kern_bind(uap->s, sa);
984263bc 177 FREE(sa, M_SONAME);
d83b97b9 178
984263bc
MD
179 return (error);
180}
181
984263bc 182int
5969a6f1 183kern_listen(int s, int backlog)
984263bc 184{
dadab5e9
MD
185 struct thread *td = curthread;
186 struct proc *p = td->td_proc;
984263bc
MD
187 struct file *fp;
188 int error;
189
dadab5e9 190 KKASSERT(p);
5969a6f1 191 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
192 if (error)
193 return (error);
5969a6f1 194 error = solisten((struct socket *)fp->f_data, backlog, td);
dadab5e9 195 fdrop(fp, td);
984263bc
MD
196 return(error);
197}
198
41c20dac 199/*
5969a6f1
DRJ
200 * listen_args(int s, int backlog)
201 */
202int
203listen(struct listen_args *uap)
204{
205 int error;
206
207 error = kern_listen(uap->s, uap->backlog);
208 return (error);
209}
210
f172717f
JH
211/*
212 * Returns the accepted socket as well.
213 */
214static boolean_t
215soaccept_predicate(struct netmsg *msg0)
216{
217 struct netmsg_so_notify *msg = (struct netmsg_so_notify *)msg0;
218 struct socket *head = msg->nm_so;
219
220 if (head->so_error != 0) {
221 msg->nm_lmsg.ms_error = head->so_error;
222 return (TRUE);
223 }
224 if (!TAILQ_EMPTY(&head->so_comp)) {
225 /* Abuse nm_so field as copy in/copy out parameter. XXX JH */
226 msg->nm_so = TAILQ_FIRST(&head->so_comp);
227 TAILQ_REMOVE(&head->so_comp, msg->nm_so, so_list);
228 head->so_qlen--;
229
230 msg->nm_lmsg.ms_error = 0;
231 return (TRUE);
232 }
233 if (head->so_state & SS_CANTRCVMORE) {
234 msg->nm_lmsg.ms_error = ECONNABORTED;
235 return (TRUE);
236 }
237 if (head->so_state & SS_NBIO) {
238 msg->nm_lmsg.ms_error = EWOULDBLOCK;
239 return (TRUE);
240 }
241
242 return (FALSE);
243}
244
5969a6f1
DRJ
245/*
246 * The second argument to kern_accept() is a handle to a struct sockaddr.
247 * This allows kern_accept() to return a pointer to an allocated struct
d83b97b9
MD
248 * sockaddr which must be freed later with FREE(). The caller must
249 * initialize *name to NULL.
41c20dac 250 */
02844a31 251int
5969a6f1 252kern_accept(int s, struct sockaddr **name, int *namelen, int *res)
984263bc 253{
dadab5e9
MD
254 struct thread *td = curthread;
255 struct proc *p = td->td_proc;
984263bc
MD
256 struct filedesc *fdp = p->p_fd;
257 struct file *lfp = NULL;
258 struct file *nfp = NULL;
259 struct sockaddr *sa;
984263bc 260 struct socket *head, *so;
f172717f
JH
261 struct netmsg_so_notify msg;
262 lwkt_port_t port;
984263bc
MD
263 int fd;
264 u_int fflag; /* type must match fp->f_flag */
f172717f 265 int error, tmp;
984263bc 266
d83b97b9
MD
267 if (name && namelen && *namelen < 0)
268 return (EINVAL);
269
270 error = holdsock(fdp, s, &lfp);
984263bc
MD
271 if (error)
272 return (error);
f172717f
JH
273
274 error = falloc(p, &nfp, &fd);
275 if (error) { /* Probably ran out of file descriptors. */
276 *res = -1;
277 fdrop(lfp, td);
278 return (error);
279 }
f172717f
JH
280 *res = fd;
281
984263bc
MD
282 head = (struct socket *)lfp->f_data;
283 if ((head->so_options & SO_ACCEPTCONN) == 0) {
984263bc
MD
284 error = EINVAL;
285 goto done;
286 }
f172717f
JH
287
288 /* optimize for uniprocessor case later XXX JH */
289 port = head->so_proto->pr_mport(head, NULL, PRU_PRED);
290 lwkt_initmsg(&msg.nm_lmsg, &curthread->td_msgport,
291 MSGF_PCATCH | MSGF_ABORTABLE,
292 lwkt_cmd_func(netmsg_so_notify),
293 lwkt_cmd_func(netmsg_so_notify_abort));
294 msg.nm_predicate = soaccept_predicate;
295 msg.nm_so = head;
296 msg.nm_etype = NM_REVENT;
297 error = lwkt_domsg(port, &msg.nm_lmsg);
298 if (error)
984263bc 299 goto done;
984263bc
MD
300
301 /*
f172717f 302 * At this point we have the connection that's ready to be accepted.
984263bc 303 */
f172717f 304 so = msg.nm_so;
984263bc
MD
305
306 fflag = lfp->f_flag;
984263bc
MD
307
308 /* connection has been removed from the listen queue */
309 KNOTE(&head->so_rcv.sb_sel.si_note, 0);
310
311 so->so_state &= ~SS_COMP;
312 so->so_head = NULL;
313 if (head->so_sigio != NULL)
314 fsetown(fgetown(head->so_sigio), &so->so_sigio);
315
fbb4eeab 316 nfp->f_type = DTYPE_SOCKET;
984263bc
MD
317 nfp->f_flag = fflag;
318 nfp->f_ops = &socketops;
fbb4eeab 319 nfp->f_data = so;
984263bc
MD
320 /* Sync socket nonblocking/async state with file flags */
321 tmp = fflag & FNONBLOCK;
dadab5e9 322 (void) fo_ioctl(nfp, FIONBIO, (caddr_t)&tmp, td);
984263bc 323 tmp = fflag & FASYNC;
dadab5e9 324 (void) fo_ioctl(nfp, FIOASYNC, (caddr_t)&tmp, td);
d83b97b9
MD
325
326 sa = NULL;
984263bc 327 error = soaccept(so, &sa);
d83b97b9
MD
328
329 /*
330 * Set the returned name and namelen as applicable. Set the returned
331 * namelen to 0 for older code which might ignore the return value
332 * from accept.
333 */
334 if (error == 0) {
335 if (sa && name && namelen) {
336 if (*namelen > sa->sa_len)
337 *namelen = sa->sa_len;
338 *name = sa;
339 } else {
340 if (sa)
341 FREE(sa, M_SONAME);
984263bc 342 }
984263bc 343 }
984263bc 344
f172717f 345done:
984263bc
MD
346 /*
347 * close the new descriptor, assuming someone hasn't ripped it
d83b97b9
MD
348 * out from under us. Note that *res is normally ignored if an
349 * error is returned but a syscall message will still have access
350 * to the result code.
984263bc
MD
351 */
352 if (error) {
d83b97b9 353 *res = -1;
0679adc4 354 if (fdp->fd_files[fd].fp == nfp) {
69908319 355 funsetfd(fdp, fd);
dadab5e9 356 fdrop(nfp, td);
984263bc
MD
357 }
358 }
984263bc
MD
359
360 /*
361 * Release explicitly held references before returning.
362 */
fad57d0e 363 if (nfp)
dadab5e9
MD
364 fdrop(nfp, td);
365 fdrop(lfp, td);
984263bc
MD
366 return (error);
367}
368
d83b97b9
MD
369/*
370 * accept_args(int s, caddr_t name, int *anamelen)
371 */
984263bc 372int
41c20dac 373accept(struct accept_args *uap)
984263bc 374{
d83b97b9
MD
375 struct sockaddr *sa = NULL;
376 int sa_len;
377 int error;
378
379 if (uap->name) {
380 error = copyin(uap->anamelen, &sa_len, sizeof(sa_len));
381 if (error)
382 return (error);
383
5969a6f1 384 error = kern_accept(uap->s, &sa, &sa_len, &uap->sysmsg_result);
d83b97b9
MD
385
386 if (error == 0)
387 error = copyout(sa, uap->name, sa_len);
388 if (error == 0) {
389 error = copyout(&sa_len, uap->anamelen,
390 sizeof(*uap->anamelen));
391 }
392 if (sa)
393 FREE(sa, M_SONAME);
394 } else {
5969a6f1 395 error = kern_accept(uap->s, NULL, 0, &uap->sysmsg_result);
d83b97b9
MD
396 }
397 return (error);
984263bc
MD
398}
399
b44419cb
MD
400/*
401 * Returns TRUE if predicate satisfied.
402 */
403static boolean_t
404soconnected_predicate(struct netmsg *msg0)
405{
406 struct netmsg_so_notify *msg = (struct netmsg_so_notify *)msg0;
407 struct socket *so = msg->nm_so;
408
409 /* check predicate */
410 if (!(so->so_state & SS_ISCONNECTING) || so->so_error != 0) {
411 msg->nm_lmsg.ms_error = so->so_error;
412 return (TRUE);
413 }
414
415 return (FALSE);
416}
417
02844a31 418int
5969a6f1 419kern_connect(int s, struct sockaddr *sa)
984263bc 420{
dadab5e9
MD
421 struct thread *td = curthread;
422 struct proc *p = td->td_proc;
984263bc 423 struct file *fp;
dadab5e9 424 struct socket *so;
d83b97b9 425 int error;
984263bc 426
d83b97b9 427 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
428 if (error)
429 return (error);
430 so = (struct socket *)fp->f_data;
431 if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
432 error = EALREADY;
433 goto done;
434 }
dadab5e9 435 error = soconnect(so, sa, td);
984263bc
MD
436 if (error)
437 goto bad;
438 if ((so->so_state & SS_NBIO) && (so->so_state & SS_ISCONNECTING)) {
984263bc
MD
439 error = EINPROGRESS;
440 goto done;
441 }
b44419cb
MD
442 if ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
443 struct netmsg_so_notify msg;
444 lwkt_port_t port;
445
1c770505 446 port = so->so_proto->pr_mport(so, sa, PRU_PRED);
b44419cb
MD
447 lwkt_initmsg(&msg.nm_lmsg,
448 &curthread->td_msgport,
449 MSGF_PCATCH | MSGF_ABORTABLE,
450 lwkt_cmd_func(netmsg_so_notify),
451 lwkt_cmd_func(netmsg_so_notify_abort));
452 msg.nm_predicate = soconnected_predicate;
453 msg.nm_so = so;
454 msg.nm_etype = NM_REVENT;
455 error = lwkt_domsg(port, &msg.nm_lmsg);
984263bc
MD
456 }
457 if (error == 0) {
458 error = so->so_error;
459 so->so_error = 0;
460 }
984263bc
MD
461bad:
462 so->so_state &= ~SS_ISCONNECTING;
984263bc
MD
463 if (error == ERESTART)
464 error = EINTR;
465done:
dadab5e9 466 fdrop(fp, td);
984263bc
MD
467 return (error);
468}
469
d83b97b9
MD
470/*
471 * connect_args(int s, caddr_t name, int namelen)
472 */
473int
474connect(struct connect_args *uap)
475{
476 struct sockaddr *sa;
477 int error;
478
479 error = getsockaddr(&sa, uap->name, uap->namelen);
480 if (error)
481 return (error);
5969a6f1 482 error = kern_connect(uap->s, sa);
d83b97b9
MD
483 FREE(sa, M_SONAME);
484
485 return (error);
486}
487
984263bc 488int
5969a6f1 489kern_socketpair(int domain, int type, int protocol, int *sv)
984263bc 490{
dadab5e9
MD
491 struct thread *td = curthread;
492 struct proc *p = td->td_proc;
493 struct filedesc *fdp;
984263bc
MD
494 struct file *fp1, *fp2;
495 struct socket *so1, *so2;
5969a6f1 496 int fd, error;
984263bc 497
dadab5e9
MD
498 KKASSERT(p);
499 fdp = p->p_fd;
5969a6f1 500 error = socreate(domain, &so1, type, protocol, td);
984263bc
MD
501 if (error)
502 return (error);
5969a6f1 503 error = socreate(domain, &so2, type, protocol, td);
984263bc
MD
504 if (error)
505 goto free1;
506 error = falloc(p, &fp1, &fd);
507 if (error)
508 goto free2;
984263bc 509 sv[0] = fd;
fbb4eeab 510 fp1->f_data = so1;
984263bc
MD
511 error = falloc(p, &fp2, &fd);
512 if (error)
513 goto free3;
fbb4eeab 514 fp2->f_data = so2;
984263bc
MD
515 sv[1] = fd;
516 error = soconnect2(so1, so2);
517 if (error)
518 goto free4;
5969a6f1 519 if (type == SOCK_DGRAM) {
984263bc
MD
520 /*
521 * Datagram socket connection is asymmetric.
522 */
523 error = soconnect2(so2, so1);
524 if (error)
525 goto free4;
526 }
fbb4eeab 527 fp1->f_type = fp2->f_type = DTYPE_SOCKET;
984263bc
MD
528 fp1->f_flag = fp2->f_flag = FREAD|FWRITE;
529 fp1->f_ops = fp2->f_ops = &socketops;
dadab5e9
MD
530 fdrop(fp1, td);
531 fdrop(fp2, td);
984263bc
MD
532 return (error);
533free4:
0679adc4 534 if (fdp->fd_files[sv[1]].fp == fp2) {
69908319 535 funsetfd(fdp, sv[1]);
dadab5e9 536 fdrop(fp2, td);
984263bc 537 }
dadab5e9 538 fdrop(fp2, td);
984263bc 539free3:
0679adc4 540 if (fdp->fd_files[sv[0]].fp == fp1) {
69908319 541 funsetfd(fdp, sv[0]);
dadab5e9 542 fdrop(fp1, td);
984263bc 543 }
dadab5e9 544 fdrop(fp1, td);
984263bc
MD
545free2:
546 (void)soclose(so2);
547free1:
548 (void)soclose(so1);
549 return (error);
550}
551
5969a6f1
DRJ
552/*
553 * socketpair(int domain, int type, int protocol, int *rsv)
554 */
555int
556socketpair(struct socketpair_args *uap)
557{
558 int error, sockv[2];
559
560 error = kern_socketpair(uap->domain, uap->type, uap->protocol, sockv);
561
562 if (error == 0)
563 error = copyout(sockv, uap->rsv, sizeof(sockv));
564 return (error);
565}
566
35fbb1d9 567int
3e1837ce
DRJ
568kern_sendmsg(int s, struct sockaddr *sa, struct uio *auio,
569 struct mbuf *control, int flags, int *res)
984263bc 570{
dadab5e9
MD
571 struct thread *td = curthread;
572 struct proc *p = td->td_proc;
984263bc 573 struct file *fp;
984263bc
MD
574 int len, error;
575 struct socket *so;
576#ifdef KTRACE
577 struct iovec *ktriov = NULL;
578 struct uio ktruio;
579#endif
580
581 error = holdsock(p->p_fd, s, &fp);
582 if (error)
583 return (error);
0bbfa91b
DRJ
584 if (auio->uio_resid < 0) {
585 error = EINVAL;
586 goto done;
587 }
984263bc 588#ifdef KTRACE
dadab5e9 589 if (KTRPOINT(td, KTR_GENIO)) {
3e1837ce 590 int iovlen = auio->uio_iovcnt * sizeof (struct iovec);
984263bc
MD
591
592 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
3e1837ce
DRJ
593 bcopy((caddr_t)auio->uio_iov, (caddr_t)ktriov, iovlen);
594 ktruio = *auio;
984263bc
MD
595 }
596#endif
3e1837ce 597 len = auio->uio_resid;
984263bc 598 so = (struct socket *)fp->f_data;
6b6e0885 599 error = so_pru_sosend(so, sa, auio, NULL, control, flags, td);
984263bc 600 if (error) {
3e1837ce 601 if (auio->uio_resid != len && (error == ERESTART ||
984263bc
MD
602 error == EINTR || error == EWOULDBLOCK))
603 error = 0;
604 if (error == EPIPE)
605 psignal(p, SIGPIPE);
606 }
984263bc
MD
607#ifdef KTRACE
608 if (ktriov != NULL) {
609 if (error == 0) {
610 ktruio.uio_iov = ktriov;
3e1837ce 611 ktruio.uio_resid = len - auio->uio_resid;
984263bc
MD
612 ktrgenio(p->p_tracep, s, UIO_WRITE, &ktruio, error);
613 }
614 FREE(ktriov, M_TEMP);
615 }
616#endif
35fbb1d9 617 if (error == 0)
3e1837ce 618 *res = len - auio->uio_resid;
0bbfa91b 619done:
dadab5e9 620 fdrop(fp, td);
984263bc
MD
621 return (error);
622}
623
41c20dac
MD
624/*
625 * sendto_args(int s, caddr_t buf, size_t len, int flags, caddr_t to, int tolen)
626 */
984263bc 627int
41c20dac 628sendto(struct sendto_args *uap)
984263bc 629{
3e1837ce
DRJ
630 struct thread *td = curthread;
631 struct uio auio;
984263bc 632 struct iovec aiov;
35fbb1d9
DRJ
633 struct sockaddr *sa = NULL;
634 int error;
984263bc 635
35fbb1d9
DRJ
636 if (uap->to) {
637 error = getsockaddr(&sa, uap->to, uap->tolen);
638 if (error)
639 return (error);
35fbb1d9 640 }
984263bc
MD
641 aiov.iov_base = uap->buf;
642 aiov.iov_len = uap->len;
3e1837ce
DRJ
643 auio.uio_iov = &aiov;
644 auio.uio_iovcnt = 1;
645 auio.uio_offset = 0;
646 auio.uio_resid = uap->len;
647 auio.uio_segflg = UIO_USERSPACE;
648 auio.uio_rw = UIO_WRITE;
649 auio.uio_td = td;
984263bc 650
3e1837ce
DRJ
651 error = kern_sendmsg(uap->s, sa, &auio, NULL, uap->flags,
652 &uap->sysmsg_result);
984263bc 653
35fbb1d9
DRJ
654 if (sa)
655 FREE(sa, M_SONAME);
656 return (error);
984263bc
MD
657}
658
41c20dac 659/*
35fbb1d9 660 * sendmsg_args(int s, caddr_t msg, int flags)
41c20dac 661 */
984263bc 662int
35fbb1d9 663sendmsg(struct sendmsg_args *uap)
984263bc 664{
3e1837ce 665 struct thread *td = curthread;
984263bc 666 struct msghdr msg;
3e1837ce 667 struct uio auio;
75a872f8 668 struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
35fbb1d9
DRJ
669 struct sockaddr *sa = NULL;
670 struct mbuf *control = NULL;
75a872f8 671 int error;
984263bc 672
35fbb1d9 673 error = copyin(uap->msg, (caddr_t)&msg, sizeof(msg));
984263bc
MD
674 if (error)
675 return (error);
35fbb1d9
DRJ
676
677 /*
678 * Conditionally copyin msg.msg_name.
679 */
680 if (msg.msg_name) {
681 error = getsockaddr(&sa, msg.msg_name, msg.msg_namelen);
682 if (error)
683 return (error);
35fbb1d9
DRJ
684 }
685
686 /*
3e1837ce 687 * Populate auio.
35fbb1d9 688 */
75a872f8 689 error = iovec_copyin(msg.msg_iov, &iov, aiov, msg.msg_iovlen,
ef5c76d7 690 &auio.uio_resid);
984263bc 691 if (error)
35fbb1d9 692 goto cleanup;
3e1837ce
DRJ
693 auio.uio_iov = iov;
694 auio.uio_iovcnt = msg.msg_iovlen;
695 auio.uio_offset = 0;
3e1837ce
DRJ
696 auio.uio_segflg = UIO_USERSPACE;
697 auio.uio_rw = UIO_WRITE;
698 auio.uio_td = td;
35fbb1d9
DRJ
699
700 /*
701 * Conditionally copyin msg.msg_control.
702 */
703 if (msg.msg_control) {
3e1837ce
DRJ
704 if (msg.msg_controllen < sizeof(struct cmsghdr) ||
705 msg.msg_controllen > MLEN) {
35fbb1d9
DRJ
706 error = EINVAL;
707 goto cleanup;
708 }
74f1caca 709 control = m_get(MB_WAIT, MT_CONTROL);
3e1837ce
DRJ
710 if (control == NULL) {
711 error = ENOBUFS;
35fbb1d9 712 goto cleanup;
3e1837ce
DRJ
713 }
714 control->m_len = msg.msg_controllen;
715 error = copyin(msg.msg_control, mtod(control, caddr_t),
716 msg.msg_controllen);
717 if (error) {
718 m_free(control);
719 goto cleanup;
720 }
35fbb1d9
DRJ
721 }
722
3e1837ce
DRJ
723 error = kern_sendmsg(uap->s, sa, &auio, control, uap->flags,
724 &uap->sysmsg_result);
35fbb1d9
DRJ
725
726cleanup:
727 if (sa)
728 FREE(sa, M_SONAME);
75a872f8 729 iovec_free(&iov, aiov);
984263bc
MD
730 return (error);
731}
984263bc 732
41c20dac 733/*
3e1837ce
DRJ
734 * kern_recvmsg() takes a handle to sa and control. If the handle is non-
735 * null, it returns a dynamically allocated struct sockaddr and an mbuf.
736 * Don't forget to FREE() and m_free() these if they are returned.
41c20dac 737 */
984263bc 738int
3e1837ce
DRJ
739kern_recvmsg(int s, struct sockaddr **sa, struct uio *auio,
740 struct mbuf **control, int *flags, int *res)
984263bc 741{
dadab5e9
MD
742 struct thread *td = curthread;
743 struct proc *p = td->td_proc;
984263bc 744 struct file *fp;
984263bc 745 int len, error;
984263bc 746 struct socket *so;
984263bc
MD
747#ifdef KTRACE
748 struct iovec *ktriov = NULL;
749 struct uio ktruio;
750#endif
751
752 error = holdsock(p->p_fd, s, &fp);
753 if (error)
754 return (error);
0bbfa91b
DRJ
755 if (auio->uio_resid < 0) {
756 error = EINVAL;
757 goto done;
758 }
984263bc 759#ifdef KTRACE
dadab5e9 760 if (KTRPOINT(td, KTR_GENIO)) {
3e1837ce 761 int iovlen = auio->uio_iovcnt * sizeof (struct iovec);
984263bc
MD
762
763 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
3e1837ce
DRJ
764 bcopy(auio->uio_iov, ktriov, iovlen);
765 ktruio = *auio;
984263bc
MD
766 }
767#endif
3e1837ce 768 len = auio->uio_resid;
984263bc 769 so = (struct socket *)fp->f_data;
6b6e0885 770 error = so_pru_soreceive(so, sa, auio, NULL, control, flags);
984263bc 771 if (error) {
3e1837ce 772 if (auio->uio_resid != len && (error == ERESTART ||
984263bc
MD
773 error == EINTR || error == EWOULDBLOCK))
774 error = 0;
775 }
776#ifdef KTRACE
777 if (ktriov != NULL) {
778 if (error == 0) {
779 ktruio.uio_iov = ktriov;
3e1837ce 780 ktruio.uio_resid = len - auio->uio_resid;
984263bc
MD
781 ktrgenio(p->p_tracep, s, UIO_READ, &ktruio, error);
782 }
783 FREE(ktriov, M_TEMP);
784 }
785#endif
35fbb1d9 786 if (error == 0)
3e1837ce 787 *res = len - auio->uio_resid;
0bbfa91b 788done:
dadab5e9 789 fdrop(fp, td);
984263bc
MD
790 return (error);
791}
792
41c20dac
MD
793/*
794 * recvfrom_args(int s, caddr_t buf, size_t len, int flags,
795 * caddr_t from, int *fromlenaddr)
796 */
984263bc 797int
41c20dac 798recvfrom(struct recvfrom_args *uap)
984263bc 799{
3e1837ce
DRJ
800 struct thread *td = curthread;
801 struct uio auio;
984263bc 802 struct iovec aiov;
3e1837ce 803 struct sockaddr *sa = NULL;
35fbb1d9 804 int error, fromlen;
984263bc 805
3e1837ce 806 if (uap->from && uap->fromlenaddr) {
35fbb1d9 807 error = copyin(uap->fromlenaddr, &fromlen, sizeof(fromlen));
984263bc
MD
808 if (error)
809 return (error);
3e1837ce
DRJ
810 if (fromlen < 0)
811 return (EINVAL);
35fbb1d9
DRJ
812 } else {
813 fromlen = 0;
814 }
984263bc
MD
815 aiov.iov_base = uap->buf;
816 aiov.iov_len = uap->len;
3e1837ce
DRJ
817 auio.uio_iov = &aiov;
818 auio.uio_iovcnt = 1;
819 auio.uio_offset = 0;
820 auio.uio_resid = uap->len;
821 auio.uio_segflg = UIO_USERSPACE;
822 auio.uio_rw = UIO_READ;
823 auio.uio_td = td;
984263bc 824
3e1837ce
DRJ
825 error = kern_recvmsg(uap->s, uap->from ? &sa : NULL, &auio, NULL,
826 &uap->flags, &uap->sysmsg_result);
984263bc 827
3e1837ce 828 if (error == 0 && uap->from) {
c3996757
MD
829 /* note: sa may still be NULL */
830 if (sa) {
831 fromlen = MIN(fromlen, sa->sa_len);
832 error = copyout(sa, uap->from, fromlen);
833 } else {
834 fromlen = 0;
835 }
836 if (error == 0) {
35fbb1d9 837 error = copyout(&fromlen, uap->fromlenaddr,
c3996757
MD
838 sizeof(fromlen));
839 }
35fbb1d9 840 }
3e1837ce
DRJ
841 if (sa)
842 FREE(sa, M_SONAME);
984263bc 843
984263bc
MD
844 return (error);
845}
984263bc 846
41c20dac
MD
847/*
848 * recvmsg_args(int s, struct msghdr *msg, int flags)
849 */
984263bc 850int
41c20dac 851recvmsg(struct recvmsg_args *uap)
984263bc 852{
3e1837ce 853 struct thread *td = curthread;
984263bc 854 struct msghdr msg;
3e1837ce 855 struct uio auio;
75a872f8
DRJ
856 struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
857 struct mbuf *m, *control = NULL;
3e1837ce 858 struct sockaddr *sa = NULL;
35fbb1d9 859 caddr_t ctlbuf;
3e1837ce 860 socklen_t *ufromlenp, *ucontrollenp;
75a872f8 861 int error, fromlen, controllen, len, flags, *uflagsp;
984263bc 862
35fbb1d9
DRJ
863 /*
864 * This copyin handles everything except the iovec.
865 */
866 error = copyin(uap->msg, &msg, sizeof(msg));
984263bc
MD
867 if (error)
868 return (error);
35fbb1d9 869
3e1837ce
DRJ
870 if (msg.msg_name && msg.msg_namelen < 0)
871 return (EINVAL);
872 if (msg.msg_control && msg.msg_controllen < 0)
873 return (EINVAL);
874
875 ufromlenp = (socklen_t *)((caddr_t)uap->msg + offsetof(struct msghdr,
35fbb1d9 876 msg_namelen));
35fbb1d9
DRJ
877 ucontrollenp = (socklen_t *)((caddr_t)uap->msg + offsetof(struct msghdr,
878 msg_controllen));
3e1837ce
DRJ
879 uflagsp = (int *)((caddr_t)uap->msg + offsetof(struct msghdr,
880 msg_flags));
35fbb1d9
DRJ
881
882 /*
3e1837ce 883 * Populate auio.
35fbb1d9 884 */
75a872f8 885 error = iovec_copyin(msg.msg_iov, &iov, aiov, msg.msg_iovlen,
ef5c76d7 886 &auio.uio_resid);
984263bc 887 if (error)
75a872f8 888 return (error);
3e1837ce
DRJ
889 auio.uio_iov = iov;
890 auio.uio_iovcnt = msg.msg_iovlen;
891 auio.uio_offset = 0;
3e1837ce
DRJ
892 auio.uio_segflg = UIO_USERSPACE;
893 auio.uio_rw = UIO_READ;
894 auio.uio_td = td;
35fbb1d9 895
b7ccd728 896 flags = uap->flags;
35fbb1d9 897
3e1837ce
DRJ
898 error = kern_recvmsg(uap->s, msg.msg_name ? &sa : NULL, &auio,
899 msg.msg_control ? &control : NULL, &flags, &uap->sysmsg_result);
35fbb1d9
DRJ
900
901 /*
3e1837ce 902 * Conditionally copyout the name and populate the namelen field.
35fbb1d9 903 */
3e1837ce
DRJ
904 if (error == 0 && msg.msg_name) {
905 fromlen = MIN(msg.msg_namelen, sa->sa_len);
906 error = copyout(sa, msg.msg_name, fromlen);
35fbb1d9 907 if (error == 0)
3e1837ce
DRJ
908 error = copyout(&fromlen, ufromlenp,
909 sizeof(*ufromlenp));
984263bc 910 }
35fbb1d9
DRJ
911
912 /*
913 * Copyout msg.msg_control and msg.msg_controllen.
914 */
3e1837ce 915 if (error == 0 && msg.msg_control) {
35fbb1d9 916 len = msg.msg_controllen;
3e1837ce
DRJ
917 m = control;
918 ctlbuf = (caddr_t)msg.msg_control;
35fbb1d9
DRJ
919
920 while(m && len > 0) {
921 unsigned int tocopy;
922
923 if (len >= m->m_len) {
924 tocopy = m->m_len;
925 } else {
926 msg.msg_flags |= MSG_CTRUNC;
927 tocopy = len;
928 }
929
930 error = copyout(mtod(m, caddr_t), ctlbuf, tocopy);
931 if (error)
932 goto cleanup;
933
934 ctlbuf += tocopy;
935 len -= tocopy;
936 m = m->m_next;
937 }
3e1837ce
DRJ
938 controllen = ctlbuf - (caddr_t)msg.msg_control;
939 error = copyout(&controllen, ucontrollenp,
35fbb1d9
DRJ
940 sizeof(*ucontrollenp));
941 }
942
3e1837ce
DRJ
943 if (error == 0)
944 error = copyout(&flags, uflagsp, sizeof(*uflagsp));
945
35fbb1d9 946cleanup:
3e1837ce
DRJ
947 if (sa)
948 FREE(sa, M_SONAME);
75a872f8 949 iovec_free(&iov, aiov);
3e1837ce
DRJ
950 if (control)
951 m_freem(control);
984263bc
MD
952 return (error);
953}
954
41c20dac 955/*
201305ad
DRJ
956 * If sopt->sopt_td == NULL, then sopt->sopt_val is treated as an
957 * in kernel pointer instead of a userland pointer. This allows us
958 * to manipulate socket options in the emulation code.
41c20dac 959 */
984263bc 960int
201305ad 961kern_setsockopt(int s, struct sockopt *sopt)
984263bc 962{
dadab5e9
MD
963 struct thread *td = curthread;
964 struct proc *p = td->td_proc;
984263bc 965 struct file *fp;
984263bc
MD
966 int error;
967
201305ad 968 if (sopt->sopt_val == 0 && sopt->sopt_valsize != 0)
984263bc 969 return (EFAULT);
201305ad 970 if (sopt->sopt_valsize < 0)
984263bc
MD
971 return (EINVAL);
972
201305ad 973 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
974 if (error)
975 return (error);
976
201305ad
DRJ
977 error = sosetopt((struct socket *)fp->f_data, sopt);
978 fdrop(fp, td);
979 return (error);
980}
981
982/*
983 * setsockopt_args(int s, int level, int name, caddr_t val, int valsize)
984 */
985int
986setsockopt(struct setsockopt_args *uap)
987{
988 struct thread *td = curthread;
989 struct sockopt sopt;
990 int error;
991
984263bc
MD
992 sopt.sopt_level = uap->level;
993 sopt.sopt_name = uap->name;
994 sopt.sopt_val = uap->val;
995 sopt.sopt_valsize = uap->valsize;
dadab5e9 996 sopt.sopt_td = td;
201305ad
DRJ
997
998 error = kern_setsockopt(uap->s, &sopt);
984263bc
MD
999 return(error);
1000}
1001
41c20dac 1002/*
201305ad
DRJ
1003 * If sopt->sopt_td == NULL, then sopt->sopt_val is treated as an
1004 * in kernel pointer instead of a userland pointer. This allows us
1005 * to manipulate socket options in the emulation code.
41c20dac 1006 */
984263bc 1007int
201305ad 1008kern_getsockopt(int s, struct sockopt *sopt)
984263bc 1009{
dadab5e9
MD
1010 struct thread *td = curthread;
1011 struct proc *p = td->td_proc;
201305ad
DRJ
1012 struct file *fp;
1013 int error;
984263bc 1014
201305ad
DRJ
1015 if (sopt->sopt_val == 0 && sopt->sopt_valsize != 0)
1016 return (EFAULT);
1017 if (sopt->sopt_valsize < 0)
1018 return (EINVAL);
1019
1020 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
1021 if (error)
1022 return (error);
201305ad
DRJ
1023
1024 error = sogetopt((struct socket *)fp->f_data, sopt);
1025 fdrop(fp, td);
1026 return (error);
1027}
1028
1029/*
1030 * getsockopt_Args(int s, int level, int name, caddr_t val, int *avalsize)
1031 */
1032int
1033getsockopt(struct getsockopt_args *uap)
1034{
1035 struct thread *td = curthread;
1036 struct sockopt sopt;
1037 int error, valsize;
1038
984263bc 1039 if (uap->val) {
201305ad
DRJ
1040 error = copyin(uap->avalsize, &valsize, sizeof(valsize));
1041 if (error)
984263bc 1042 return (error);
201305ad 1043 if (valsize < 0)
984263bc 1044 return (EINVAL);
984263bc
MD
1045 } else {
1046 valsize = 0;
1047 }
1048
984263bc
MD
1049 sopt.sopt_level = uap->level;
1050 sopt.sopt_name = uap->name;
1051 sopt.sopt_val = uap->val;
201305ad 1052 sopt.sopt_valsize = valsize;
dadab5e9 1053 sopt.sopt_td = td;
984263bc 1054
201305ad 1055 error = kern_getsockopt(uap->s, &sopt);
984263bc
MD
1056 if (error == 0) {
1057 valsize = sopt.sopt_valsize;
201305ad 1058 error = copyout(&valsize, uap->avalsize, sizeof(valsize));
984263bc 1059 }
984263bc
MD
1060 return (error);
1061}
1062
1063/*
5969a6f1
DRJ
1064 * The second argument to kern_getsockname() is a handle to a struct sockaddr.
1065 * This allows kern_getsockname() to return a pointer to an allocated struct
1066 * sockaddr which must be freed later with FREE(). The caller must
1067 * initialize *name to NULL.
984263bc 1068 */
5969a6f1
DRJ
1069int
1070kern_getsockname(int s, struct sockaddr **name, int *namelen)
984263bc 1071{
dadab5e9
MD
1072 struct thread *td = curthread;
1073 struct proc *p = td->td_proc;
984263bc 1074 struct file *fp;
dadab5e9 1075 struct socket *so;
5969a6f1
DRJ
1076 struct sockaddr *sa = NULL;
1077 int error;
984263bc 1078
5969a6f1 1079 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
1080 if (error)
1081 return (error);
5969a6f1 1082 if (*namelen < 0) {
dadab5e9 1083 fdrop(fp, td);
984263bc
MD
1084 return (EINVAL);
1085 }
1086 so = (struct socket *)fp->f_data;
6b6e0885 1087 error = so_pru_sockaddr(so, &sa);
5969a6f1
DRJ
1088 if (error == 0) {
1089 if (sa == 0) {
1090 *namelen = 0;
1091 } else {
1092 *namelen = MIN(*namelen, sa->sa_len);
1093 *name = sa;
1094 }
984263bc
MD
1095 }
1096
dadab5e9 1097 fdrop(fp, td);
984263bc
MD
1098 return (error);
1099}
1100
5969a6f1
DRJ
1101/*
1102 * getsockname_args(int fdes, caddr_t asa, int *alen)
1103 *
1104 * Get socket name.
1105 */
984263bc 1106int
41c20dac 1107getsockname(struct getsockname_args *uap)
984263bc 1108{
5969a6f1
DRJ
1109 struct sockaddr *sa = NULL;
1110 int error, sa_len;
1111
1112 error = copyin(uap->alen, &sa_len, sizeof(sa_len));
1113 if (error)
1114 return (error);
1115
1116 error = kern_getsockname(uap->fdes, &sa, &sa_len);
984263bc 1117
5969a6f1
DRJ
1118 if (error == 0)
1119 error = copyout(sa, uap->asa, sa_len);
1120 if (error == 0)
1121 error = copyout(&sa_len, uap->alen, sizeof(*uap->alen));
1122 if (sa)
1123 FREE(sa, M_SONAME);
1124 return (error);
984263bc
MD
1125}
1126
984263bc 1127/*
5969a6f1
DRJ
1128 * The second argument to kern_getpeername() is a handle to a struct sockaddr.
1129 * This allows kern_getpeername() to return a pointer to an allocated struct
1130 * sockaddr which must be freed later with FREE(). The caller must
1131 * initialize *name to NULL.
984263bc 1132 */
5969a6f1
DRJ
1133int
1134kern_getpeername(int s, struct sockaddr **name, int *namelen)
984263bc 1135{
dadab5e9
MD
1136 struct thread *td = curthread;
1137 struct proc *p = td->td_proc;
984263bc 1138 struct file *fp;
dadab5e9 1139 struct socket *so;
5969a6f1
DRJ
1140 struct sockaddr *sa = NULL;
1141 int error;
984263bc 1142
5969a6f1 1143 error = holdsock(p->p_fd, s, &fp);
984263bc
MD
1144 if (error)
1145 return (error);
5969a6f1
DRJ
1146 if (*namelen < 0) {
1147 fdrop(fp, td);
1148 return (EINVAL);
1149 }
984263bc
MD
1150 so = (struct socket *)fp->f_data;
1151 if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) {
dadab5e9 1152 fdrop(fp, td);
984263bc
MD
1153 return (ENOTCONN);
1154 }
6b6e0885 1155 error = so_pru_peeraddr(so, &sa);
5969a6f1
DRJ
1156 if (error == 0) {
1157 if (sa == 0) {
1158 *namelen = 0;
1159 } else {
1160 *namelen = MIN(*namelen, sa->sa_len);
1161 *name = sa;
1162 }
984263bc 1163 }
5969a6f1 1164
dadab5e9 1165 fdrop(fp, td);
984263bc
MD
1166 return (error);
1167}
1168
5969a6f1
DRJ
1169/*
1170 * getpeername_args(int fdes, caddr_t asa, int *alen)
1171 *
1172 * Get name of peer for connected socket.
1173 */
984263bc 1174int
41c20dac 1175getpeername(struct getpeername_args *uap)
984263bc 1176{
5969a6f1
DRJ
1177 struct sockaddr *sa = NULL;
1178 int error, sa_len;
1179
1180 error = copyin(uap->alen, &sa_len, sizeof(sa_len));
1181 if (error)
1182 return (error);
1183
1184 error = kern_getpeername(uap->fdes, &sa, &sa_len);
1185
1186 if (error == 0)
1187 error = copyout(sa, uap->asa, sa_len);
1188 if (error == 0)
1189 error = copyout(&sa_len, uap->alen, sizeof(*uap->alen));
1190 if (sa)
1191 FREE(sa, M_SONAME);
1192 return (error);
984263bc
MD
1193}
1194
984263bc 1195int
02844a31 1196getsockaddr(struct sockaddr **namp, caddr_t uaddr, size_t len)
984263bc
MD
1197{
1198 struct sockaddr *sa;
1199 int error;
1200
02844a31 1201 *namp = NULL;
984263bc
MD
1202 if (len > SOCK_MAXADDRLEN)
1203 return ENAMETOOLONG;
02844a31
MD
1204 if (len < offsetof(struct sockaddr, sa_data[0]))
1205 return EDOM;
984263bc
MD
1206 MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK);
1207 error = copyin(uaddr, sa, len);
1208 if (error) {
1209 FREE(sa, M_SONAME);
1210 } else {
75a872f8
DRJ
1211#if BYTE_ORDER != BIG_ENDIAN
1212 /*
1213 * The bind(), connect(), and sendto() syscalls were not
1214 * versioned for COMPAT_43. Thus, this check must stay.
1215 */
984263bc
MD
1216 if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1217 sa->sa_family = sa->sa_len;
1218#endif
1219 sa->sa_len = len;
1220 *namp = sa;
1221 }
1222 return error;
1223}
1224
1225/*
1226 * holdsock() - load the struct file pointer associated
1227 * with a socket into *fpp. If an error occurs, non-zero
1228 * will be returned and *fpp will be set to NULL.
1229 */
1230int
7db4334c 1231holdsock(struct filedesc *fdp, int fdes, struct file **fpp)
984263bc 1232{
7db4334c 1233 struct file *fp;
984263bc
MD
1234 int error = 0;
1235
7db4334c
JH
1236 *fpp = NULL;
1237 if ((unsigned)fdes >= fdp->fd_nfiles)
1238 return EBADF;
0679adc4 1239 if ((fp = fdp->fd_files[fdes].fp) == NULL)
7db4334c
JH
1240 return EBADF;
1241 if (fp->f_type != DTYPE_SOCKET)
1242 return ENOTSOCK;
1243 fhold(fp);
984263bc 1244 *fpp = fp;
7db4334c 1245 return (error);
984263bc
MD
1246}
1247
b4caac98
MD
1248/*
1249 * Detach a mapped page and release resources back to the system.
1250 * We must release our wiring and if the object is ripped out
1251 * from under the vm_page we become responsible for freeing the
df8d1020 1252 * page. These routines must be MPSAFE.
b4caac98
MD
1253 *
1254 * XXX HACK XXX TEMPORARY UNTIL WE IMPLEMENT EXT MBUF REFERENCE COUNTING
df8d1020
MD
1255 *
1256 * XXX vm_page_*() routines are not MPSAFE yet, the MP lock is required.
b4caac98
MD
1257 */
1258static void
013a4c0e 1259sf_buf_mref(void *arg)
b4caac98 1260{
e66bab2b
MD
1261 struct sfbuf_mref *sfm = arg;
1262
df8d1020
MD
1263 /*
1264 * We must already hold a ref so there is no race to 0, just
1265 * atomically increment the count.
1266 */
1267 atomic_add_int(&sfm->mref_count, 1);
b4caac98
MD
1268}
1269
1270static void
013a4c0e 1271sf_buf_mfree(void *arg)
b4caac98 1272{
e66bab2b 1273 struct sfbuf_mref *sfm = arg;
b4caac98 1274 vm_page_t m;
e66bab2b
MD
1275
1276 KKASSERT(sfm->mref_count > 0);
df8d1020
MD
1277 if (sfm->mref_count == 1) {
1278 /*
1279 * We are the only holder so no further locking is required,
1280 * the sfbuf can simply be freed.
1281 */
1282 sfm->mref_count = 0;
1283 goto freeit;
1284 } else {
1285 /*
1286 * There may be other holders, we must obtain the serializer
1287 * to protect against a sf_buf_mfree() race to 0. An atomic
1288 * operation is still required for races against
1289 * sf_buf_mref().
1290 *
1291 * XXX vm_page_*() and SFBUF routines not MPSAFE yet.
1292 */
1293 lwkt_serialize_enter(&sfm->serializer);
1294 atomic_subtract_int(&sfm->mref_count, 1);
1295 if (sfm->mref_count == 0) {
1296 lwkt_serialize_exit(&sfm->serializer);
1297freeit:
1298 get_mplock();
1299 crit_enter();
1300 m = sf_buf_page(sfm->sf);
1301 sf_buf_free(sfm->sf);
1302 vm_page_unwire(m, 0);
1303 if (m->wire_count == 0 && m->object == NULL)
1304 vm_page_try_to_free(m);
1305 crit_exit();
1306 rel_mplock();
1307 free(sfm, M_SENDFILE);
1308 } else {
1309 lwkt_serialize_exit(&sfm->serializer);
1310 }
b4caac98
MD
1311 }
1312}
1313
984263bc
MD
1314/*
1315 * sendfile(2).
1316 * int sendfile(int fd, int s, off_t offset, size_t nbytes,
1317 * struct sf_hdtr *hdtr, off_t *sbytes, int flags)
1318 *
1319 * Send a file specified by 'fd' and starting at 'offset' to a socket
1320 * specified by 's'. Send only 'nbytes' of the file or until EOF if
1321 * nbytes == 0. Optionally add a header and/or trailer to the socket
1322 * output. If specified, write the total number of bytes sent into *sbytes.
75a872f8
DRJ
1323 *
1324 * In FreeBSD kern/uipc_syscalls.c,v 1.103, a bug was fixed that caused
1325 * the headers to count against the remaining bytes to be sent from
1326 * the file descriptor. We may wish to implement a compatibility syscall
1327 * in the future.
984263bc
MD
1328 */
1329int
41c20dac 1330sendfile(struct sendfile_args *uap)
984263bc 1331{
dadab5e9
MD
1332 struct thread *td = curthread;
1333 struct proc *p = td->td_proc;
984263bc 1334 struct file *fp;
dadab5e9 1335 struct filedesc *fdp;
75a872f8 1336 struct vnode *vp = NULL;
984263bc 1337 struct sf_hdtr hdtr;
75a872f8
DRJ
1338 struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
1339 struct uio auio;
30eeba44 1340 struct mbuf *mheader = NULL;
75a872f8 1341 off_t hdtr_size = 0, sbytes;
30eeba44 1342 int error, hbytes = 0, tbytes;
984263bc 1343
dadab5e9
MD
1344 KKASSERT(p);
1345 fdp = p->p_fd;
1346
984263bc
MD
1347 /*
1348 * Do argument checking. Must be a regular file in, stream
1349 * type and connected socket out, positive offset.
1350 */
1351 fp = holdfp(fdp, uap->fd, FREAD);
1352 if (fp == NULL) {
f0846490 1353 return (EBADF);
984263bc
MD
1354 }
1355 if (fp->f_type != DTYPE_VNODE) {
f0846490
DRJ
1356 fdrop(fp, td);
1357 return (EINVAL);
984263bc
MD
1358 }
1359 vp = (struct vnode *)fp->f_data;
1360 vref(vp);
75a872f8
DRJ
1361 fdrop(fp, td);
1362
1363 /*
1364 * If specified, get the pointer to the sf_hdtr struct for
1365 * any headers/trailers.
1366 */
1367 if (uap->hdtr) {
1368 error = copyin(uap->hdtr, &hdtr, sizeof(hdtr));
1369 if (error)
1370 goto done;
1371 /*
1372 * Send any headers.
1373 */
1374 if (hdtr.headers) {
1375 error = iovec_copyin(hdtr.headers, &iov, aiov,
ef5c76d7 1376 hdtr.hdr_cnt, &hbytes);
75a872f8
DRJ
1377 if (error)
1378 goto done;
1379 auio.uio_iov = iov;
1380 auio.uio_iovcnt = hdtr.hdr_cnt;
1381 auio.uio_offset = 0;
1382 auio.uio_segflg = UIO_USERSPACE;
1383 auio.uio_rw = UIO_WRITE;
1384 auio.uio_td = td;
30eeba44 1385 auio.uio_resid = hbytes;
75a872f8 1386
e12241e1 1387 mheader = m_uiomove(&auio);
75a872f8
DRJ
1388
1389 iovec_free(&iov, aiov);
30eeba44 1390 if (mheader == NULL)
75a872f8 1391 goto done;
75a872f8
DRJ
1392 }
1393 }
1394
30eeba44 1395 error = kern_sendfile(vp, uap->s, uap->offset, uap->nbytes, mheader,
75a872f8
DRJ
1396 &sbytes, uap->flags);
1397 if (error)
1398 goto done;
1399
1400 /*
1401 * Send trailers. Wimp out and use writev(2).
1402 */
1403 if (uap->hdtr != NULL && hdtr.trailers != NULL) {
1404 error = iovec_copyin(hdtr.trailers, &iov, aiov,
ef5c76d7 1405 hdtr.trl_cnt, &auio.uio_resid);
75a872f8
DRJ
1406 if (error)
1407 goto done;
1408 auio.uio_iov = iov;
1409 auio.uio_iovcnt = hdtr.trl_cnt;
1410 auio.uio_offset = 0;
1411 auio.uio_segflg = UIO_USERSPACE;
1412 auio.uio_rw = UIO_WRITE;
1413 auio.uio_td = td;
1414
30eeba44 1415 error = kern_sendmsg(uap->s, NULL, &auio, NULL, 0, &tbytes);
75a872f8
DRJ
1416
1417 iovec_free(&iov, aiov);
1418 if (error)
1419 goto done;
30eeba44 1420 hdtr_size += tbytes; /* trailer bytes successfully sent */
75a872f8
DRJ
1421 }
1422
1423done:
1424 if (uap->sbytes != NULL) {
1425 sbytes += hdtr_size;
1426 copyout(&sbytes, uap->sbytes, sizeof(off_t));
1427 }
1428 if (vp)
1429 vrele(vp);
1430 return (error);
1431}
1432
1433int
06ecca5a 1434kern_sendfile(struct vnode *vp, int sfd, off_t offset, size_t nbytes,
30eeba44 1435 struct mbuf *mheader, off_t *sbytes, int flags)
75a872f8
DRJ
1436{
1437 struct thread *td = curthread;
1438 struct proc *p = td->td_proc;
1439 struct vm_object *obj;
1440 struct socket *so;
285332f0 1441 struct file *fp;
75a872f8
DRJ
1442 struct mbuf *m;
1443 struct sf_buf *sf;
e66bab2b 1444 struct sfbuf_mref *sfm;
75a872f8
DRJ
1445 struct vm_page *pg;
1446 off_t off, xfsize;
39b3370f 1447 off_t hbytes = 0;
75a872f8
DRJ
1448 int error = 0;
1449
7540ab49
MD
1450 if (vp->v_type != VREG) {
1451 error = EINVAL;
1452 goto done0;
1453 }
1454 if ((obj = vp->v_object) == NULL) {
984263bc 1455 error = EINVAL;
285332f0 1456 goto done0;
984263bc 1457 }
06ecca5a 1458 error = holdsock(p->p_fd, sfd, &fp);
984263bc 1459 if (error)
285332f0 1460 goto done0;
984263bc
MD
1461 so = (struct socket *)fp->f_data;
1462 if (so->so_type != SOCK_STREAM) {
1463 error = EINVAL;
1464 goto done;
1465 }
1466 if ((so->so_state & SS_ISCONNECTED) == 0) {
1467 error = ENOTCONN;
1468 goto done;
1469 }
75a872f8 1470 if (offset < 0) {
984263bc
MD
1471 error = EINVAL;
1472 goto done;
1473 }
1474
75a872f8 1475 *sbytes = 0;
984263bc
MD
1476 /*
1477 * Protect against multiple writers to the socket.
1478 */
1479 (void) sblock(&so->so_snd, M_WAITOK);
1480
1481 /*
1482 * Loop through the pages in the file, starting with the requested
1483 * offset. Get a file page (do I/O if necessary), map the file page
1484 * into an sf_buf, attach an mbuf header to the sf_buf, and queue
1485 * it on the socket.
1486 */
39b3370f 1487 for (off = offset; ; off += xfsize, *sbytes += xfsize + hbytes) {
984263bc
MD
1488 vm_pindex_t pindex;
1489 vm_offset_t pgoff;
1490
1491 pindex = OFF_TO_IDX(off);
1492retry_lookup:
1493 /*
1494 * Calculate the amount to transfer. Not to exceed a page,
1495 * the EOF, or the passed in nbytes.
1496 */
57f7b636 1497 xfsize = vp->v_filesize - off;
984263bc
MD
1498 if (xfsize > PAGE_SIZE)
1499 xfsize = PAGE_SIZE;
1500 pgoff = (vm_offset_t)(off & PAGE_MASK);
1501 if (PAGE_SIZE - pgoff < xfsize)
1502 xfsize = PAGE_SIZE - pgoff;
75a872f8
DRJ
1503 if (nbytes && xfsize > (nbytes - *sbytes))
1504 xfsize = nbytes - *sbytes;
984263bc
MD
1505 if (xfsize <= 0)
1506 break;
1507 /*
1508 * Optimize the non-blocking case by looking at the socket space
1509 * before going to the extra work of constituting the sf_buf.
1510 */
1511 if ((so->so_state & SS_NBIO) && sbspace(&so->so_snd) <= 0) {
1512 if (so->so_state & SS_CANTSENDMORE)
1513 error = EPIPE;
1514 else
1515 error = EAGAIN;
1516 sbunlock(&so->so_snd);
1517 goto done;
1518 }
1519 /*
1520 * Attempt to look up the page.
1521 *
06ecca5a 1522 * Allocate if not found, wait and loop if busy, then
5fd012e0
MD
1523 * wire the page. critical section protection is
1524 * required to maintain the object association (an
1525 * interrupt can free the page) through to the
1526 * vm_page_wire() call.
984263bc 1527 */
5fd012e0 1528 crit_enter();
984263bc 1529 pg = vm_page_lookup(obj, pindex);
984263bc
MD
1530 if (pg == NULL) {
1531 pg = vm_page_alloc(obj, pindex, VM_ALLOC_NORMAL);
1532 if (pg == NULL) {
659c6a07 1533 vm_wait();
5fd012e0 1534 crit_exit();
984263bc
MD
1535 goto retry_lookup;
1536 }
1537 vm_page_wakeup(pg);
1538 } else if (vm_page_sleep_busy(pg, TRUE, "sfpbsy")) {
5fd012e0 1539 crit_exit();
984263bc
MD
1540 goto retry_lookup;
1541 }
984263bc 1542 vm_page_wire(pg);
5fd012e0 1543 crit_exit();
984263bc
MD
1544
1545 /*
1546 * If page is not valid for what we need, initiate I/O
1547 */
1548
1549 if (!pg->valid || !vm_page_is_valid(pg, pgoff, xfsize)) {
1550 struct uio auio;
1551 struct iovec aiov;
1552 int bsize;
1553
1554 /*
1555 * Ensure that our page is still around when the I/O
1556 * completes.
1557 */
1558 vm_page_io_start(pg);
1559
1560 /*
1561 * Get the page from backing store.
1562 */
1563 bsize = vp->v_mount->mnt_stat.f_iosize;
1564 auio.uio_iov = &aiov;
1565 auio.uio_iovcnt = 1;
1566 aiov.iov_base = 0;
1567 aiov.iov_len = MAXBSIZE;
1568 auio.uio_resid = MAXBSIZE;
1569 auio.uio_offset = trunc_page(off);
1570 auio.uio_segflg = UIO_NOCOPY;
1571 auio.uio_rw = UIO_READ;
dadab5e9 1572 auio.uio_td = td;
ca466bae 1573 vn_lock(vp, LK_SHARED | LK_NOPAUSE | LK_RETRY);
dadab5e9
MD
1574 error = VOP_READ(vp, &auio,
1575 IO_VMIO | ((MAXBSIZE / bsize) << 16),
1576 p->p_ucred);
ca466bae 1577 VOP_UNLOCK(vp, 0);
984263bc
MD
1578 vm_page_flag_clear(pg, PG_ZERO);
1579 vm_page_io_finish(pg);
1580 if (error) {
f2555cdd 1581 crit_enter();
984263bc 1582 vm_page_unwire(pg, 0);
f2555cdd
MD
1583 vm_page_try_to_free(pg);
1584 crit_exit();
984263bc
MD
1585 sbunlock(&so->so_snd);
1586 goto done;
1587 }
1588 }
1589
1590
1591 /*
1592 * Get a sendfile buf. We usually wait as long as necessary,
1593 * but this wait can be interrupted.
1594 */
4f1640d6 1595 if ((sf = sf_buf_alloc(pg, SFB_CATCH)) == NULL) {
5fd012e0 1596 crit_enter();
984263bc 1597 vm_page_unwire(pg, 0);
f2555cdd 1598 vm_page_try_to_free(pg);
5fd012e0 1599 crit_exit();
984263bc
MD
1600 sbunlock(&so->so_snd);
1601 error = EINTR;
1602 goto done;
1603 }
1604
984263bc
MD
1605 /*
1606 * Get an mbuf header and set it up as having external storage.
1607 */
74f1caca 1608 MGETHDR(m, MB_WAIT, MT_DATA);
984263bc
MD
1609 if (m == NULL) {
1610 error = ENOBUFS;
b4caac98 1611 sf_buf_free(sf);
984263bc
MD
1612 sbunlock(&so->so_snd);
1613 goto done;
1614 }
e66bab2b
MD
1615
1616 /*
1617 * sfm is a temporary hack, use a per-cpu cache for this.
1618 */
1619 sfm = malloc(sizeof(struct sfbuf_mref), M_SENDFILE, M_WAITOK);
1620 sfm->sf = sf;
1621 sfm->mref_count = 1;
df8d1020 1622 lwkt_serialize_init(&sfm->serializer);
e66bab2b 1623
b542cd49
JS
1624 m->m_ext.ext_free = sf_buf_mfree;
1625 m->m_ext.ext_ref = sf_buf_mref;
e66bab2b 1626 m->m_ext.ext_arg = sfm;
984263bc
MD
1627 m->m_ext.ext_buf = (void *)sf->kva;
1628 m->m_ext.ext_size = PAGE_SIZE;
1629 m->m_data = (char *) sf->kva + pgoff;
013a4c0e 1630 m->m_flags |= M_EXT;
984263bc 1631 m->m_pkthdr.len = m->m_len = xfsize;
b542cd49 1632 KKASSERT((m->m_flags & (M_EXT_CLUSTER)) == 0);
30eeba44 1633
39b3370f
JH
1634 if (mheader != NULL) {
1635 hbytes = mheader->m_pkthdr.len;
30eeba44
JH
1636 mheader->m_pkthdr.len += m->m_pkthdr.len;
1637 m_cat(mheader, m);
1638 m = mheader;
1639 mheader = NULL;
39b3370f
JH
1640 } else
1641 hbytes = 0;
30eeba44 1642
984263bc
MD
1643 /*
1644 * Add the buffer to the socket buffer chain.
1645 */
5fd012e0 1646 crit_enter();
984263bc
MD
1647retry_space:
1648 /*
1649 * Make sure that the socket is still able to take more data.
1650 * CANTSENDMORE being true usually means that the connection
1651 * was closed. so_error is true when an error was sensed after
1652 * a previous send.
1653 * The state is checked after the page mapping and buffer
1654 * allocation above since those operations may block and make
1655 * any socket checks stale. From this point forward, nothing
1656 * blocks before the pru_send (or more accurately, any blocking
1657 * results in a loop back to here to re-check).
1658 */
1659 if ((so->so_state & SS_CANTSENDMORE) || so->so_error) {
1660 if (so->so_state & SS_CANTSENDMORE) {
1661 error = EPIPE;
1662 } else {
1663 error = so->so_error;
1664 so->so_error = 0;
1665 }
1666 m_freem(m);
1667 sbunlock(&so->so_snd);
5fd012e0 1668 crit_exit();
984263bc
MD
1669 goto done;
1670 }
1671 /*
1672 * Wait for socket space to become available. We do this just
1673 * after checking the connection state above in order to avoid
1674 * a race condition with sbwait().
1675 */
1676 if (sbspace(&so->so_snd) < so->so_snd.sb_lowat) {
1677 if (so->so_state & SS_NBIO) {
1678 m_freem(m);
1679 sbunlock(&so->so_snd);
5fd012e0 1680 crit_exit();
984263bc
MD
1681 error = EAGAIN;
1682 goto done;
1683 }
1684 error = sbwait(&so->so_snd);
1685 /*
1686 * An error from sbwait usually indicates that we've
1687 * been interrupted by a signal. If we've sent anything
1688 * then return bytes sent, otherwise return the error.
1689 */
1690 if (error) {
1691 m_freem(m);
1692 sbunlock(&so->so_snd);
5fd012e0 1693 crit_exit();
984263bc
MD
1694 goto done;
1695 }
1696 goto retry_space;
1697 }
3c6b2883 1698 error = so_pru_send(so, 0, m, NULL, NULL, td);
5fd012e0 1699 crit_exit();
984263bc
MD
1700 if (error) {
1701 sbunlock(&so->so_snd);
1702 goto done;
1703 }
1704 }
d785f69d 1705 if (mheader != NULL) {
39b3370f 1706 *sbytes += mheader->m_pkthdr.len;
d785f69d
JH
1707 error = so_pru_send(so, 0, mheader, NULL, NULL, td);
1708 mheader = NULL;
1709 }
984263bc
MD
1710 sbunlock(&so->so_snd);
1711
984263bc 1712done:
285332f0
JH
1713 fdrop(fp, td);
1714done0:
30eeba44
JH
1715 if (mheader != NULL)
1716 m_freem(mheader);
984263bc
MD
1717 return (error);
1718}
78812139
EN
1719
1720int
1721sctp_peeloff(struct sctp_peeloff_args *uap)
1722{
1723#ifdef SCTP
1724 struct thread *td = curthread;
1725 struct proc *p = td->td_proc;
1726 struct filedesc *fdp = p->p_fd;
1727 struct file *lfp = NULL;
1728 struct file *nfp = NULL;
1729 int error;
1730 struct socket *head, *so;
1731 caddr_t assoc_id;
1732 int fd;
1733 short fflag; /* type must match fp->f_flag */
1734
1735 assoc_id = uap->name;
1736 error = holdsock(fdp, uap->sd, &lfp);
1737 if (error) {
1738 return (error);
1739 }
1740 crit_enter();
1741 head = (struct socket *)lfp->f_data;
1742 error = sctp_can_peel_off(head, assoc_id);
1743 if (error) {
1744 crit_exit();
1745 goto done;
1746 }
1747 /*
1748 * At this point we know we do have a assoc to pull
1749 * we proceed to get the fd setup. This may block
1750 * but that is ok.
1751 */
1752
1753 fflag = lfp->f_flag;
1754 error = falloc(p, &nfp, &fd);
1755 if (error) {
1756 /*
1757 * Probably ran out of file descriptors. Put the
1758 * unaccepted connection back onto the queue and
1759 * do another wakeup so some other process might
1760 * have a chance at it.
1761 */
1762 crit_exit();
1763 goto done;
1764 }
1765 fhold(nfp);
1766 uap->sysmsg_result = fd;
1767
1768 so = sctp_get_peeloff(head, assoc_id, &error);
1769 if (so == NULL) {
1770 /*
1771 * Either someone else peeled it off OR
1772 * we can't get a socket.
1773 */
1774 goto noconnection;
1775 }
1776 so->so_state &= ~SS_COMP;
1777 so->so_state &= ~SS_NOFDREF;
1778 so->so_head = NULL;
1779 if (head->so_sigio != NULL)
1780 fsetown(fgetown(head->so_sigio), &so->so_sigio);
1781
fbb4eeab 1782 nfp->f_type = DTYPE_SOCKET;
78812139
EN
1783 nfp->f_flag = fflag;
1784 nfp->f_ops = &socketops;
fbb4eeab 1785 nfp->f_data = so;
78812139
EN
1786
1787noconnection:
1788 /*
1789 * close the new descriptor, assuming someone hasn't ripped it
1790 * out from under us.
1791 */
1792 if (error) {
1793 if (fdp->fd_files[fd].fp == nfp) {
1794 funsetfd(fdp, fd);
1795 fdrop(nfp, td);
1796 }
1797 }
1798 crit_exit();
1799 /*
1800 * Release explicitly held references before returning.
1801 */
1802done:
1803 if (nfp != NULL)
1804 fdrop(nfp, td);
1805 fdrop(lfp, td);
1806 return (error);
1807#else /* SCTP */
1808 return(EOPNOTSUPP);
1809#endif /* SCTP */
1810}