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.76 2006/09/16 03:37:12 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                         ksignal(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 cleanup2;
 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         iovec_free(&iov, aiov);
 782 cleanup2:
 783         if (sa)
 784                 FREE(sa, M_SONAME);
 785         return (error);
 786 }
 787
 788 /*
 789  * kern_recvmsg() takes a handle to sa and control.  If the handle is non-
 790  * null, it returns a dynamically allocated struct sockaddr and an mbuf.
 791  * Don't forget to FREE() and m_free() these if they are returned.
 792  */
 793 int
 794 kern_recvmsg(int s, struct sockaddr **sa, struct uio *auio,
 795     struct mbuf **control, int *flags, int *res)
 796 {
 797         struct thread *td = curthread;
 798         struct proc *p = td->td_proc;
 799         struct file *fp;
 800         int len, error;
 801         int lflags;
 802         struct socket *so;
 803 #ifdef KTRACE
 804         struct iovec *ktriov = NULL;
 805         struct uio ktruio;
 806 #endif
 807
 808         error = holdsock(p->p_fd, s, &fp);
 809         if (error)
 810                 return (error);
 811         if (auio->uio_resid < 0) {
 812                 error = EINVAL;
 813                 goto done;
 814         }
 815 #ifdef KTRACE
 816         if (KTRPOINT(td, KTR_GENIO)) {
 817                 int iovlen = auio->uio_iovcnt * sizeof (struct iovec);
 818
 819                 MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 820                 bcopy(auio->uio_iov, ktriov, iovlen);
 821                 ktruio = *auio;
 822         }
 823 #endif
 824         len = auio->uio_resid;
 825         so = (struct socket *)fp->f_data;
 826
 827         if (flags == NULL || (*flags & (MSG_FNONBLOCKING|MSG_FBLOCKING)) == 0) {
 828                 if (fp->f_flag & FNONBLOCK) {
 829                         if (flags) {
 830                                 *flags |= MSG_FNONBLOCKING;
 831                         } else {
 832                                 lflags = MSG_FNONBLOCKING;
 833                                 flags = &lflags;
 834                         }
 835                 }
 836         }
 837
 838         error = so_pru_soreceive(so, sa, auio, NULL, control, flags);
 839         if (error) {
 840                 if (auio->uio_resid != len && (error == ERESTART ||
 841                     error == EINTR || error == EWOULDBLOCK))
 842                         error = 0;
 843         }
 844 #ifdef KTRACE
 845         if (ktriov != NULL) {
 846                 if (error == 0) {
 847                         ktruio.uio_iov = ktriov;
 848                         ktruio.uio_resid = len - auio->uio_resid;
 849                         ktrgenio(p, s, UIO_READ, &ktruio, error);
 850                 }
 851                 FREE(ktriov, M_TEMP);
 852         }
 853 #endif
 854         if (error == 0)
 855                 *res = len - auio->uio_resid;
 856 done:
 857         fdrop(fp);
 858         return (error);
 859 }
 860
 861 /*
 862  * recvfrom_args(int s, caddr_t buf, size_t len, int flags,
 863  *                      caddr_t from, int *fromlenaddr)
 864  */
 865 int
 866 sys_recvfrom(struct recvfrom_args *uap)
 867 {
 868         struct thread *td = curthread;
 869         struct uio auio;
 870         struct iovec aiov;
 871         struct sockaddr *sa = NULL;
 872         int error, fromlen;
 873
 874         if (uap->from && uap->fromlenaddr) {
 875                 error = copyin(uap->fromlenaddr, &fromlen, sizeof(fromlen));
 876                 if (error)
 877                         return (error);
 878                 if (fromlen < 0)
 879                         return (EINVAL);
 880         } else {
 881                 fromlen = 0;
 882         }
 883         aiov.iov_base = uap->buf;
 884         aiov.iov_len = uap->len;
 885         auio.uio_iov = &aiov;
 886         auio.uio_iovcnt = 1;
 887         auio.uio_offset = 0;
 888         auio.uio_resid = uap->len;
 889         auio.uio_segflg = UIO_USERSPACE;
 890         auio.uio_rw = UIO_READ;
 891         auio.uio_td = td;
 892
 893         error = kern_recvmsg(uap->s, uap->from ? &sa : NULL, &auio, NULL,
 894             &uap->flags, &uap->sysmsg_result);
 895
 896         if (error == 0 && uap->from) {
 897                 /* note: sa may still be NULL */
 898                 if (sa) {
 899                         fromlen = MIN(fromlen, sa->sa_len);
 900                         error = copyout(sa, uap->from, fromlen);
 901                 } else {
 902                         fromlen = 0;
 903                 }
 904                 if (error == 0) {
 905                         error = copyout(&fromlen, uap->fromlenaddr,
 906                                         sizeof(fromlen));
 907                 }
 908         }
 909         if (sa)
 910                 FREE(sa, M_SONAME);
 911
 912         return (error);
 913 }
 914
 915 /*
 916  * recvmsg_args(int s, struct msghdr *msg, int flags)
 917  */
 918 int
 919 sys_recvmsg(struct recvmsg_args *uap)
 920 {
 921         struct thread *td = curthread;
 922         struct msghdr msg;
 923         struct uio auio;
 924         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
 925         struct mbuf *m, *control = NULL;
 926         struct sockaddr *sa = NULL;
 927         caddr_t ctlbuf;
 928         socklen_t *ufromlenp, *ucontrollenp;
 929         int error, fromlen, controllen, len, flags, *uflagsp;
 930
 931         /*
 932          * This copyin handles everything except the iovec.
 933          */
 934         error = copyin(uap->msg, &msg, sizeof(msg));
 935         if (error)
 936                 return (error);
 937
 938         if (msg.msg_name && msg.msg_namelen < 0)
 939                 return (EINVAL);
 940         if (msg.msg_control && msg.msg_controllen < 0)
 941                 return (EINVAL);
 942
 943         ufromlenp = (socklen_t *)((caddr_t)uap->msg + offsetof(struct msghdr,
 944             msg_namelen));
 945         ucontrollenp = (socklen_t *)((caddr_t)uap->msg + offsetof(struct msghdr,
 946             msg_controllen));
 947         uflagsp = (int *)((caddr_t)uap->msg + offsetof(struct msghdr,
 948             msg_flags));
 949
 950         /*
 951          * Populate auio.
 952          */
 953         error = iovec_copyin(msg.msg_iov, &iov, aiov, msg.msg_iovlen,
 954                              &auio.uio_resid);
 955         if (error)
 956                 return (error);
 957         auio.uio_iov = iov;
 958         auio.uio_iovcnt = msg.msg_iovlen;
 959         auio.uio_offset = 0;
 960         auio.uio_segflg = UIO_USERSPACE;
 961         auio.uio_rw = UIO_READ;
 962         auio.uio_td = td;
 963
 964         flags = uap->flags;
 965
 966         error = kern_recvmsg(uap->s, msg.msg_name ? &sa : NULL, &auio,
 967             msg.msg_control ? &control : NULL, &flags, &uap->sysmsg_result);
 968
 969         /*
 970          * Conditionally copyout the name and populate the namelen field.
 971          */
 972         if (error == 0 && msg.msg_name) {
 973                 fromlen = MIN(msg.msg_namelen, sa->sa_len);
 974                 error = copyout(sa, msg.msg_name, fromlen);
 975                 if (error == 0)
 976                         error = copyout(&fromlen, ufromlenp,
 977                             sizeof(*ufromlenp));
 978         }
 979
 980         /*
 981          * Copyout msg.msg_control and msg.msg_controllen.
 982          */
 983         if (error == 0 && msg.msg_control) {
 984                 len = msg.msg_controllen;
 985                 m = control;
 986                 ctlbuf = (caddr_t)msg.msg_control;
 987
 988                 while(m && len > 0) {
 989                         unsigned int tocopy;
 990
 991                         if (len >= m->m_len) {
 992                                 tocopy = m->m_len;
 993                         } else {
 994                                 msg.msg_flags |= MSG_CTRUNC;
 995                                 tocopy = len;
 996                         }
 997
 998                         error = copyout(mtod(m, caddr_t), ctlbuf, tocopy);
 999                         if (error)
1000                                 goto cleanup;
1001
1002                         ctlbuf += tocopy;
1003                         len -= tocopy;
1004                         m = m->m_next;
1005                 }
1006                 controllen = ctlbuf - (caddr_t)msg.msg_control;
1007                 error = copyout(&controllen, ucontrollenp,
1008                     sizeof(*ucontrollenp));
1009         }
1010
1011         if (error == 0)
1012                 error = copyout(&flags, uflagsp, sizeof(*uflagsp));
1013
1014 cleanup:
1015         if (sa)
1016                 FREE(sa, M_SONAME);
1017         iovec_free(&iov, aiov);
1018         if (control)
1019                 m_freem(control);
1020         return (error);
1021 }
1022
1023 /*
1024  * If sopt->sopt_td == NULL, then sopt->sopt_val is treated as an
1025  * in kernel pointer instead of a userland pointer.  This allows us
1026  * to manipulate socket options in the emulation code.
1027  */
1028 int
1029 kern_setsockopt(int s, struct sockopt *sopt)
1030 {
1031         struct thread *td = curthread;
1032         struct proc *p = td->td_proc;
1033         struct file *fp;
1034         int error;
1035
1036         if (sopt->sopt_val == 0 && sopt->sopt_valsize != 0)
1037                 return (EFAULT);
1038         if (sopt->sopt_valsize < 0)
1039                 return (EINVAL);
1040
1041         error = holdsock(p->p_fd, s, &fp);
1042         if (error)
1043                 return (error);
1044
1045         error = sosetopt((struct socket *)fp->f_data, sopt);
1046         fdrop(fp);
1047         return (error);
1048 }
1049
1050 /*
1051  * setsockopt_args(int s, int level, int name, caddr_t val, int valsize)
1052  */
1053 int
1054 sys_setsockopt(struct setsockopt_args *uap)
1055 {
1056         struct thread *td = curthread;
1057         struct sockopt sopt;
1058         int error;
1059
1060         sopt.sopt_level = uap->level;
1061         sopt.sopt_name = uap->name;
1062         sopt.sopt_val = uap->val;
1063         sopt.sopt_valsize = uap->valsize;
1064         sopt.sopt_td = td;
1065
1066         error = kern_setsockopt(uap->s, &sopt);
1067         return(error);
1068 }
1069
1070 /*
1071  * If sopt->sopt_td == NULL, then sopt->sopt_val is treated as an
1072  * in kernel pointer instead of a userland pointer.  This allows us
1073  * to manipulate socket options in the emulation code.
1074  */
1075 int
1076 kern_getsockopt(int s, struct sockopt *sopt)
1077 {
1078         struct thread *td = curthread;
1079         struct proc *p = td->td_proc;
1080         struct file *fp;
1081         int error;
1082
1083         if (sopt->sopt_val == 0 && sopt->sopt_valsize != 0)
1084                 return (EFAULT);
1085         if (sopt->sopt_valsize < 0)
1086                 return (EINVAL);
1087
1088         error = holdsock(p->p_fd, s, &fp);
1089         if (error)
1090                 return (error);
1091
1092         error = sogetopt((struct socket *)fp->f_data, sopt);
1093         fdrop(fp);
1094         return (error);
1095 }
1096
1097 /*
1098  * getsockopt_Args(int s, int level, int name, caddr_t val, int *avalsize)
1099  */
1100 int
1101 sys_getsockopt(struct getsockopt_args *uap)
1102 {
1103         struct thread *td = curthread;
1104         struct  sockopt sopt;
1105         int     error, valsize;
1106
1107         if (uap->val) {
1108                 error = copyin(uap->avalsize, &valsize, sizeof(valsize));
1109                 if (error)
1110                         return (error);
1111                 if (valsize < 0)
1112                         return (EINVAL);
1113         } else {
1114                 valsize = 0;
1115         }
1116
1117         sopt.sopt_level = uap->level;
1118         sopt.sopt_name = uap->name;
1119         sopt.sopt_val = uap->val;
1120         sopt.sopt_valsize = valsize;
1121         sopt.sopt_td = td;
1122
1123         error = kern_getsockopt(uap->s, &sopt);
1124         if (error == 0) {
1125                 valsize = sopt.sopt_valsize;
1126                 error = copyout(&valsize, uap->avalsize, sizeof(valsize));
1127         }
1128         return (error);
1129 }
1130
1131 /*
1132  * The second argument to kern_getsockname() is a handle to a struct sockaddr.
1133  * This allows kern_getsockname() to return a pointer to an allocated struct
1134  * sockaddr which must be freed later with FREE().  The caller must
1135  * initialize *name to NULL.
1136  */
1137 int
1138 kern_getsockname(int s, struct sockaddr **name, int *namelen)
1139 {
1140         struct thread *td = curthread;
1141         struct proc *p = td->td_proc;
1142         struct file *fp;
1143         struct socket *so;
1144         struct sockaddr *sa = NULL;
1145         int error;
1146
1147         error = holdsock(p->p_fd, s, &fp);
1148         if (error)
1149                 return (error);
1150         if (*namelen < 0) {
1151                 fdrop(fp);
1152                 return (EINVAL);
1153         }
1154         so = (struct socket *)fp->f_data;
1155         error = so_pru_sockaddr(so, &sa);
1156         if (error == 0) {
1157                 if (sa == 0) {
1158                         *namelen = 0;
1159                 } else {
1160                         *namelen = MIN(*namelen, sa->sa_len);
1161                         *name = sa;
1162                 }
1163         }
1164
1165         fdrop(fp);
1166         return (error);
1167 }
1168
1169 /*
1170  * getsockname_args(int fdes, caddr_t asa, int *alen)
1171  *
1172  * Get socket name.
1173  */
1174 int
1175 sys_getsockname(struct getsockname_args *uap)
1176 {
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_getsockname(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);
1193 }
1194
1195 /*
1196  * The second argument to kern_getpeername() is a handle to a struct sockaddr.
1197  * This allows kern_getpeername() to return a pointer to an allocated struct
1198  * sockaddr which must be freed later with FREE().  The caller must
1199  * initialize *name to NULL.
1200  */
1201 int
1202 kern_getpeername(int s, struct sockaddr **name, int *namelen)
1203 {
1204         struct thread *td = curthread;
1205         struct proc *p = td->td_proc;
1206         struct file *fp;
1207         struct socket *so;
1208         struct sockaddr *sa = NULL;
1209         int error;
1210
1211         error = holdsock(p->p_fd, s, &fp);
1212         if (error)
1213                 return (error);
1214         if (*namelen < 0) {
1215                 fdrop(fp);
1216                 return (EINVAL);
1217         }
1218         so = (struct socket *)fp->f_data;
1219         if ((so->so_state & (SS_ISCONNECTED|SS_ISCONFIRMING)) == 0) {
1220                 fdrop(fp);
1221                 return (ENOTCONN);
1222         }
1223         error = so_pru_peeraddr(so, &sa);
1224         if (error == 0) {
1225                 if (sa == 0) {
1226                         *namelen = 0;
1227                 } else {
1228                         *namelen = MIN(*namelen, sa->sa_len);
1229                         *name = sa;
1230                 }
1231         }
1232
1233         fdrop(fp);
1234         return (error);
1235 }
1236
1237 /*
1238  * getpeername_args(int fdes, caddr_t asa, int *alen)
1239  *
1240  * Get name of peer for connected socket.
1241  */
1242 int
1243 sys_getpeername(struct getpeername_args *uap)
1244 {
1245         struct sockaddr *sa = NULL;
1246         int error, sa_len;
1247
1248         error = copyin(uap->alen, &sa_len, sizeof(sa_len));
1249         if (error)
1250                 return (error);
1251
1252         error = kern_getpeername(uap->fdes, &sa, &sa_len);
1253
1254         if (error == 0)
1255                 error = copyout(sa, uap->asa, sa_len);
1256         if (error == 0)
1257                 error = copyout(&sa_len, uap->alen, sizeof(*uap->alen));
1258         if (sa)
1259                 FREE(sa, M_SONAME);
1260         return (error);
1261 }
1262
1263 int
1264 getsockaddr(struct sockaddr **namp, caddr_t uaddr, size_t len)
1265 {
1266         struct sockaddr *sa;
1267         int error;
1268
1269         *namp = NULL;
1270         if (len > SOCK_MAXADDRLEN)
1271                 return ENAMETOOLONG;
1272         if (len < offsetof(struct sockaddr, sa_data[0]))
1273                 return EDOM;
1274         MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK);
1275         error = copyin(uaddr, sa, len);
1276         if (error) {
1277                 FREE(sa, M_SONAME);
1278         } else {
1279 #if BYTE_ORDER != BIG_ENDIAN
1280                 /*
1281                  * The bind(), connect(), and sendto() syscalls were not
1282                  * versioned for COMPAT_43.  Thus, this check must stay.
1283                  */
1284                 if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
1285                         sa->sa_family = sa->sa_len;
1286 #endif
1287                 sa->sa_len = len;
1288                 *namp = sa;
1289         }
1290         return error;
1291 }
1292
1293 /*
1294  * Detach a mapped page and release resources back to the system.
1295  * We must release our wiring and if the object is ripped out
1296  * from under the vm_page we become responsible for freeing the
1297  * page.  These routines must be MPSAFE.
1298  *
1299  * XXX HACK XXX TEMPORARY UNTIL WE IMPLEMENT EXT MBUF REFERENCE COUNTING
1300  *
1301  * XXX vm_page_*() routines are not MPSAFE yet, the MP lock is required.
1302  */
1303 static void
1304 sf_buf_mref(void *arg)
1305 {
1306         struct sfbuf_mref *sfm = arg;
1307
1308         /*
1309          * We must already hold a ref so there is no race to 0, just
1310          * atomically increment the count.
1311          */
1312         atomic_add_int(&sfm->mref_count, 1);
1313 }
1314
1315 static void
1316 sf_buf_mfree(void *arg)
1317 {
1318         struct sfbuf_mref *sfm = arg;
1319         vm_page_t m;
1320
1321         KKASSERT(sfm->mref_count > 0);
1322         if (sfm->mref_count == 1) {
1323                 /*
1324                  * We are the only holder so no further locking is required,
1325                  * the sfbuf can simply be freed.
1326                  */
1327                 sfm->mref_count = 0;
1328                 goto freeit;
1329         } else {
1330                 /*
1331                  * There may be other holders, we must obtain the serializer
1332                  * to protect against a sf_buf_mfree() race to 0.  An atomic
1333                  * operation is still required for races against
1334                  * sf_buf_mref().
1335                  *
1336                  * XXX vm_page_*() and SFBUF routines not MPSAFE yet.
1337                  */
1338                 lwkt_serialize_enter(&sfm->serializer);
1339                 atomic_subtract_int(&sfm->mref_count, 1);
1340                 if (sfm->mref_count == 0) {
1341                         lwkt_serialize_exit(&sfm->serializer);
1342 freeit:
1343                         get_mplock();
1344                         crit_enter();
1345                         m = sf_buf_page(sfm->sf);
1346                         sf_buf_free(sfm->sf);
1347                         vm_page_unwire(m, 0);
1348                         if (m->wire_count == 0 && m->object == NULL)
1349                                 vm_page_try_to_free(m);
1350                         crit_exit();
1351                         rel_mplock();
1352                         kfree(sfm, M_SENDFILE);
1353                 } else {
1354                         lwkt_serialize_exit(&sfm->serializer);
1355                 }
1356         }
1357 }
1358
1359 /*
1360  * sendfile(2).
1361  * int sendfile(int fd, int s, off_t offset, size_t nbytes,
1362  *       struct sf_hdtr *hdtr, off_t *sbytes, int flags)
1363  *
1364  * Send a file specified by 'fd' and starting at 'offset' to a socket
1365  * specified by 's'. Send only 'nbytes' of the file or until EOF if
1366  * nbytes == 0. Optionally add a header and/or trailer to the socket
1367  * output. If specified, write the total number of bytes sent into *sbytes.
1368  *
1369  * In FreeBSD kern/uipc_syscalls.c,v 1.103, a bug was fixed that caused
1370  * the headers to count against the remaining bytes to be sent from
1371  * the file descriptor.  We may wish to implement a compatibility syscall
1372  * in the future.
1373  */
1374 int
1375 sys_sendfile(struct sendfile_args *uap)
1376 {
1377         struct thread *td = curthread;
1378         struct proc *p = td->td_proc;
1379         struct file *fp;
1380         struct vnode *vp = NULL;
1381         struct sf_hdtr hdtr;
1382         struct iovec aiov[UIO_SMALLIOV], *iov = NULL;
1383         struct uio auio;
1384         struct mbuf *mheader = NULL;
1385         off_t hdtr_size = 0, sbytes;
1386         int error, hbytes = 0, tbytes;
1387
1388         KKASSERT(p);
1389
1390         /*
1391          * Do argument checking. Must be a regular file in, stream
1392          * type and connected socket out, positive offset.
1393          */
1394         fp = holdfp(p->p_fd, uap->fd, FREAD);
1395         if (fp == NULL) {
1396                 return (EBADF);
1397         }
1398         if (fp->f_type != DTYPE_VNODE) {
1399                 fdrop(fp);
1400                 return (EINVAL);
1401         }
1402         vp = (struct vnode *)fp->f_data;
1403         vref(vp);
1404         fdrop(fp);
1405
1406         /*
1407          * If specified, get the pointer to the sf_hdtr struct for
1408          * any headers/trailers.
1409          */
1410         if (uap->hdtr) {
1411                 error = copyin(uap->hdtr, &hdtr, sizeof(hdtr));
1412                 if (error)
1413                         goto done;
1414                 /*
1415                  * Send any headers.
1416                  */
1417                 if (hdtr.headers) {
1418                         error = iovec_copyin(hdtr.headers, &iov, aiov,
1419                                              hdtr.hdr_cnt, &hbytes);
1420                         if (error)
1421                                 goto done;
1422                         auio.uio_iov = iov;
1423                         auio.uio_iovcnt = hdtr.hdr_cnt;
1424                         auio.uio_offset = 0;
1425                         auio.uio_segflg = UIO_USERSPACE;
1426                         auio.uio_rw = UIO_WRITE;
1427                         auio.uio_td = td;
1428                         auio.uio_resid = hbytes;
1429
1430                         mheader = m_uiomove(&auio);
1431
1432                         iovec_free(&iov, aiov);
1433                         if (mheader == NULL)
1434                                 goto done;
1435                 }
1436         }
1437
1438         error = kern_sendfile(vp, uap->s, uap->offset, uap->nbytes, mheader,
1439             &sbytes, uap->flags);
1440         if (error)
1441                 goto done;
1442
1443         /*
1444          * Send trailers. Wimp out and use writev(2).
1445          */
1446         if (uap->hdtr != NULL && hdtr.trailers != NULL) {
1447                 error = iovec_copyin(hdtr.trailers, &iov, aiov,
1448                                      hdtr.trl_cnt, &auio.uio_resid);
1449                 if (error)
1450                         goto done;
1451                 auio.uio_iov = iov;
1452                 auio.uio_iovcnt = hdtr.trl_cnt;
1453                 auio.uio_offset = 0;
1454                 auio.uio_segflg = UIO_USERSPACE;
1455                 auio.uio_rw = UIO_WRITE;
1456                 auio.uio_td = td;
1457
1458                 error = kern_sendmsg(uap->s, NULL, &auio, NULL, 0, &tbytes);
1459
1460                 iovec_free(&iov, aiov);
1461                 if (error)
1462                         goto done;
1463                 hdtr_size += tbytes;    /* trailer bytes successfully sent */
1464         }
1465
1466 done:
1467         if (uap->sbytes != NULL) {
1468                 sbytes += hdtr_size;
1469                 copyout(&sbytes, uap->sbytes, sizeof(off_t));
1470         }
1471         if (vp)
1472                 vrele(vp);
1473         return (error);
1474 }
1475
1476 int
1477 kern_sendfile(struct vnode *vp, int sfd, off_t offset, size_t nbytes,
1478     struct mbuf *mheader, off_t *sbytes, int flags)
1479 {
1480         struct thread *td = curthread;
1481         struct proc *p = td->td_proc;
1482         struct vm_object *obj;
1483         struct socket *so;
1484         struct file *fp;
1485         struct mbuf *m;
1486         struct sf_buf *sf;
1487         struct sfbuf_mref *sfm;
1488         struct vm_page *pg;
1489         off_t off, xfsize;
1490         off_t hbytes = 0;
1491         int error = 0;
1492
1493         if (vp->v_type != VREG) {
1494                 error = EINVAL;
1495                 goto done0;
1496         }
1497         if ((obj = vp->v_object) == NULL) {
1498                 error = EINVAL;
1499                 goto done0;
1500         }
1501         error = holdsock(p->p_fd, sfd, &fp);
1502         if (error)
1503                 goto done0;
1504         so = (struct socket *)fp->f_data;
1505         if (so->so_type != SOCK_STREAM) {
1506                 error = EINVAL;
1507                 goto done;
1508         }
1509         if ((so->so_state & SS_ISCONNECTED) == 0) {
1510                 error = ENOTCONN;
1511                 goto done;
1512         }
1513         if (offset < 0) {
1514                 error = EINVAL;
1515                 goto done;
1516         }
1517
1518         *sbytes = 0;
1519         /*
1520          * Protect against multiple writers to the socket.
1521          */
1522         (void) sblock(&so->so_snd, M_WAITOK);
1523
1524         /*
1525          * Loop through the pages in the file, starting with the requested
1526          * offset. Get a file page (do I/O if necessary), map the file page
1527          * into an sf_buf, attach an mbuf header to the sf_buf, and queue
1528          * it on the socket.
1529          */
1530         for (off = offset; ; off += xfsize, *sbytes += xfsize + hbytes) {
1531                 vm_pindex_t pindex;
1532                 vm_offset_t pgoff;
1533
1534                 pindex = OFF_TO_IDX(off);
1535 retry_lookup:
1536                 /*
1537                  * Calculate the amount to transfer. Not to exceed a page,
1538                  * the EOF, or the passed in nbytes.
1539                  */
1540                 xfsize = vp->v_filesize - off;
1541                 if (xfsize > PAGE_SIZE)
1542                         xfsize = PAGE_SIZE;
1543                 pgoff = (vm_offset_t)(off & PAGE_MASK);
1544                 if (PAGE_SIZE - pgoff < xfsize)
1545                         xfsize = PAGE_SIZE - pgoff;
1546                 if (nbytes && xfsize > (nbytes - *sbytes))
1547                         xfsize = nbytes - *sbytes;
1548                 if (xfsize <= 0)
1549                         break;
1550                 /*
1551                  * Optimize the non-blocking case by looking at the socket space
1552                  * before going to the extra work of constituting the sf_buf.
1553                  */
1554                 if ((fp->f_flag & FNONBLOCK) && sbspace(&so->so_snd) <= 0) {
1555                         if (so->so_state & SS_CANTSENDMORE)
1556                                 error = EPIPE;
1557                         else
1558                                 error = EAGAIN;
1559                         sbunlock(&so->so_snd);
1560                         goto done;
1561                 }
1562                 /*
1563                  * Attempt to look up the page.
1564                  *
1565                  *      Allocate if not found, wait and loop if busy, then
1566                  *      wire the page.  critical section protection is
1567                  *      required to maintain the object association (an
1568                  *      interrupt can free the page) through to the
1569                  *      vm_page_wire() call.
1570                  */
1571                 crit_enter();
1572                 pg = vm_page_lookup(obj, pindex);
1573                 if (pg == NULL) {
1574                         pg = vm_page_alloc(obj, pindex, VM_ALLOC_NORMAL);
1575                         if (pg == NULL) {
1576                                 vm_wait();
1577                                 crit_exit();
1578                                 goto retry_lookup;
1579                         }
1580                         vm_page_wakeup(pg);
1581                 } else if (vm_page_sleep_busy(pg, TRUE, "sfpbsy")) {
1582                         crit_exit();
1583                         goto retry_lookup;
1584                 }
1585                 vm_page_wire(pg);
1586                 crit_exit();
1587
1588                 /*
1589                  * If page is not valid for what we need, initiate I/O
1590                  */
1591
1592                 if (!pg->valid || !vm_page_is_valid(pg, pgoff, xfsize)) {
1593                         struct uio auio;
1594                         struct iovec aiov;
1595                         int bsize;
1596
1597                         /*
1598                          * Ensure that our page is still around when the I/O
1599                          * completes.
1600                          */
1601                         vm_page_io_start(pg);
1602
1603                         /*
1604                          * Get the page from backing store.
1605                          */
1606                         bsize = vp->v_mount->mnt_stat.f_iosize;
1607                         auio.uio_iov = &aiov;
1608                         auio.uio_iovcnt = 1;
1609                         aiov.iov_base = 0;
1610                         aiov.iov_len = MAXBSIZE;
1611                         auio.uio_resid = MAXBSIZE;
1612                         auio.uio_offset = trunc_page(off);
1613                         auio.uio_segflg = UIO_NOCOPY;
1614                         auio.uio_rw = UIO_READ;
1615                         auio.uio_td = td;
1616                         vn_lock(vp, LK_SHARED | LK_RETRY);
1617                         error = VOP_READ(vp, &auio,
1618                                     IO_VMIO | ((MAXBSIZE / bsize) << 16),
1619                                     p->p_ucred);
1620                         vn_unlock(vp);
1621                         vm_page_flag_clear(pg, PG_ZERO);
1622                         vm_page_io_finish(pg);
1623                         if (error) {
1624                                 crit_enter();
1625                                 vm_page_unwire(pg, 0);
1626                                 vm_page_try_to_free(pg);
1627                                 crit_exit();
1628                                 sbunlock(&so->so_snd);
1629                                 goto done;
1630                         }
1631                 }
1632
1633
1634                 /*
1635                  * Get a sendfile buf. We usually wait as long as necessary,
1636                  * but this wait can be interrupted.
1637                  */
1638                 if ((sf = sf_buf_alloc(pg, SFB_CATCH)) == NULL) {
1639                         crit_enter();
1640                         vm_page_unwire(pg, 0);
1641                         vm_page_try_to_free(pg);
1642                         crit_exit();
1643                         sbunlock(&so->so_snd);
1644                         error = EINTR;
1645                         goto done;
1646                 }
1647
1648                 /*
1649                  * Get an mbuf header and set it up as having external storage.
1650                  */
1651                 MGETHDR(m, MB_WAIT, MT_DATA);
1652                 if (m == NULL) {
1653                         error = ENOBUFS;
1654                         sf_buf_free(sf);
1655                         sbunlock(&so->so_snd);
1656                         goto done;
1657                 }
1658
1659                 /*
1660                  * sfm is a temporary hack, use a per-cpu cache for this.
1661                  */
1662                 sfm = kmalloc(sizeof(struct sfbuf_mref), M_SENDFILE, M_WAITOK);
1663                 sfm->sf = sf;
1664                 sfm->mref_count = 1;
1665                 lwkt_serialize_init(&sfm->serializer);
1666
1667                 m->m_ext.ext_free = sf_buf_mfree;
1668                 m->m_ext.ext_ref = sf_buf_mref;
1669                 m->m_ext.ext_arg = sfm;
1670                 m->m_ext.ext_buf = (void *)sf->kva;
1671                 m->m_ext.ext_size = PAGE_SIZE;
1672                 m->m_data = (char *) sf->kva + pgoff;
1673                 m->m_flags |= M_EXT;
1674                 m->m_pkthdr.len = m->m_len = xfsize;
1675                 KKASSERT((m->m_flags & (M_EXT_CLUSTER)) == 0);
1676
1677                 if (mheader != NULL) {
1678                         hbytes = mheader->m_pkthdr.len;
1679                         mheader->m_pkthdr.len += m->m_pkthdr.len;
1680                         m_cat(mheader, m);
1681                         m = mheader;
1682                         mheader = NULL;
1683                 } else
1684                         hbytes = 0;
1685
1686                 /*
1687                  * Add the buffer to the socket buffer chain.
1688                  */
1689                 crit_enter();
1690 retry_space:
1691                 /*
1692                  * Make sure that the socket is still able to take more data.
1693                  * CANTSENDMORE being true usually means that the connection
1694                  * was closed. so_error is true when an error was sensed after
1695                  * a previous send.
1696                  * The state is checked after the page mapping and buffer
1697                  * allocation above since those operations may block and make
1698                  * any socket checks stale. From this point forward, nothing
1699                  * blocks before the pru_send (or more accurately, any blocking
1700                  * results in a loop back to here to re-check).
1701                  */
1702                 if ((so->so_state & SS_CANTSENDMORE) || so->so_error) {
1703                         if (so->so_state & SS_CANTSENDMORE) {
1704                                 error = EPIPE;
1705                         } else {
1706                                 error = so->so_error;
1707                                 so->so_error = 0;
1708                         }
1709                         m_freem(m);
1710                         sbunlock(&so->so_snd);
1711                         crit_exit();
1712                         goto done;
1713                 }
1714                 /*
1715                  * Wait for socket space to become available. We do this just
1716                  * after checking the connection state above in order to avoid
1717                  * a race condition with sbwait().
1718                  */
1719                 if (sbspace(&so->so_snd) < so->so_snd.sb_lowat) {
1720                         if (fp->f_flag & FNONBLOCK) {
1721                                 m_freem(m);
1722                                 sbunlock(&so->so_snd);
1723                                 crit_exit();
1724                                 error = EAGAIN;
1725                                 goto done;
1726                         }
1727                         error = sbwait(&so->so_snd);
1728                         /*
1729                          * An error from sbwait usually indicates that we've
1730                          * been interrupted by a signal. If we've sent anything
1731                          * then return bytes sent, otherwise return the error.
1732                          */
1733                         if (error) {
1734                                 m_freem(m);
1735                                 sbunlock(&so->so_snd);
1736                                 crit_exit();
1737                                 goto done;
1738                         }
1739                         goto retry_space;
1740                 }
1741                 error = so_pru_send(so, 0, m, NULL, NULL, td);
1742                 crit_exit();
1743                 if (error) {
1744                         sbunlock(&so->so_snd);
1745                         goto done;
1746                 }
1747         }
1748         if (mheader != NULL) {
1749                 *sbytes += mheader->m_pkthdr.len;
1750                 error = so_pru_send(so, 0, mheader, NULL, NULL, td);
1751                 mheader = NULL;
1752         }
1753         sbunlock(&so->so_snd);
1754
1755 done:
1756         fdrop(fp);
1757 done0:
1758         if (mheader != NULL)
1759                 m_freem(mheader);
1760         return (error);
1761 }
1762
1763 int
1764 sys_sctp_peeloff(struct sctp_peeloff_args *uap)
1765 {
1766 #ifdef SCTP
1767         struct thread *td = curthread;
1768         struct proc *p = td->td_proc;
1769         struct file *lfp = NULL;
1770         struct file *nfp = NULL;
1771         int error;
1772         struct socket *head, *so;
1773         caddr_t assoc_id;
1774         int fd;
1775         short fflag;            /* type must match fp->f_flag */
1776
1777         assoc_id = uap->name;
1778         error = holdsock(p->p_fd, uap->sd, &lfp);
1779         if (error) {
1780                 return (error);
1781         }
1782         crit_enter();
1783         head = (struct socket *)lfp->f_data;
1784         error = sctp_can_peel_off(head, assoc_id);
1785         if (error) {
1786                 crit_exit();
1787                 goto done;
1788         }
1789         /*
1790          * At this point we know we do have a assoc to pull
1791          * we proceed to get the fd setup. This may block
1792          * but that is ok.
1793          */
1794
1795         fflag = lfp->f_flag;
1796         error = falloc(p, &nfp, &fd);
1797         if (error) {
1798                 /*
1799                  * Probably ran out of file descriptors. Put the
1800                  * unaccepted connection back onto the queue and
1801                  * do another wakeup so some other process might
1802                  * have a chance at it.
1803                  */
1804                 crit_exit();
1805                 goto done;
1806         }
1807         uap->sysmsg_result = fd;
1808
1809         so = sctp_get_peeloff(head, assoc_id, &error);
1810         if (so == NULL) {
1811                 /*
1812                  * Either someone else peeled it off OR
1813                  * we can't get a socket.
1814                  */
1815                 goto noconnection;
1816         }
1817         so->so_state &= ~SS_COMP;
1818         so->so_state &= ~SS_NOFDREF;
1819         so->so_head = NULL;
1820         if (head->so_sigio != NULL)
1821                 fsetown(fgetown(head->so_sigio), &so->so_sigio);
1822
1823         nfp->f_type = DTYPE_SOCKET;
1824         nfp->f_flag = fflag;
1825         nfp->f_ops = &socketops;
1826         nfp->f_data = so;
1827
1828 noconnection:
1829         /*
1830          * Assign the file pointer to the reserved descriptor, or clear
1831          * the reserved descriptor if an error occured.
1832          */
1833         if (error)
1834                 fsetfd(p, NULL, fd);
1835         else
1836                 fsetfd(p, nfp, fd);
1837         crit_exit();
1838         /*
1839          * Release explicitly held references before returning.
1840          */
1841 done:
1842         if (nfp != NULL)
1843                 fdrop(nfp);
1844         fdrop(lfp);
1845         return (error);
1846 #else /* SCTP */
1847         return(EOPNOTSUPP);
1848 #endif /* SCTP */
1849 }