sys/kern/uipc_syscalls.c

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