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