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