]>
git.saurik.com Git - apple/xnu.git/blob - bsd/kern/uipc_socket2.c
2 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
4 * @APPLE_LICENSE_HEADER_START@
6 * The contents of this file constitute Original Code as defined in and
7 * are subject to the Apple Public Source License Version 1.1 (the
8 * "License"). You may not use this file except in compliance with the
9 * License. Please obtain a copy of the License at
10 * http://www.apple.com/publicsource and read it before using this file.
12 * This Original Code and all software distributed under the License are
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17 * License for the specific language governing rights and limitations
20 * @APPLE_LICENSE_HEADER_END@
22 /* Copyright (c) 1998, 1999 Apple Computer, Inc. All Rights Reserved */
23 /* Copyright (c) 1995 NeXT Computer, Inc. All Rights Reserved */
25 * Copyright (c) 1982, 1986, 1988, 1990, 1993
26 * The Regents of the University of California. All rights reserved.
28 * Redistribution and use in source and binary forms, with or without
29 * modification, are permitted provided that the following conditions
31 * 1. Redistributions of source code must retain the above copyright
32 * notice, this list of conditions and the following disclaimer.
33 * 2. Redistributions in binary form must reproduce the above copyright
34 * notice, this list of conditions and the following disclaimer in the
35 * documentation and/or other materials provided with the distribution.
36 * 3. All advertising materials mentioning features or use of this software
37 * must display the following acknowledgement:
38 * This product includes software developed by the University of
39 * California, Berkeley and its contributors.
40 * 4. Neither the name of the University nor the names of its contributors
41 * may be used to endorse or promote products derived from this software
42 * without specific prior written permission.
44 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
45 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
46 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
47 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
48 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
49 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
50 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
51 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
52 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
53 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 * @(#)uipc_socket2.c 8.1 (Berkeley) 6/10/93
57 * $FreeBSD: src/sys/kern/uipc_socket2.c,v 1.55.2.9 2001/07/26 18:53:02 peter Exp $
60 #include <sys/param.h>
61 #include <sys/systm.h>
62 #include <sys/domain.h>
63 #include <sys/kernel.h>
65 #include <sys/malloc.h>
67 #include <sys/protosw.h>
69 #include <sys/socket.h>
70 #include <sys/socketvar.h>
71 #include <sys/signalvar.h>
72 #include <sys/sysctl.h>
75 #include <sys/kdebug.h>
77 #define DBG_FNC_SBDROP NETDBG_CODE(DBG_NETSOCK, 4)
78 #define DBG_FNC_SBAPPEND NETDBG_CODE(DBG_NETSOCK, 5)
82 * Primitive routines for operating on sockets and socket buffers
85 u_long sb_max
= SB_MAX
; /* XXX should be static */
87 static u_long sb_efficiency
= 8; /* parameter for sbreserve() */
90 * Procedures to manipulate state flags of socket
91 * and do appropriate wakeups. Normal sequence from the
92 * active (originating) side is that soisconnecting() is
93 * called during processing of connect() call,
94 * resulting in an eventual call to soisconnected() if/when the
95 * connection is established. When the connection is torn down
96 * soisdisconnecting() is called during processing of disconnect() call,
97 * and soisdisconnected() is called when the connection to the peer
98 * is totally severed. The semantics of these routines are such that
99 * connectionless protocols can call soisconnected() and soisdisconnected()
100 * only, bypassing the in-progress calls when setting up a ``connection''
103 * From the passive side, a socket is created with
104 * two queues of sockets: so_incomp for connections in progress
105 * and so_comp for connections already made and awaiting user acceptance.
106 * As a protocol is preparing incoming connections, it creates a socket
107 * structure queued on so_incomp by calling sonewconn(). When the connection
108 * is established, soisconnected() is called, and transfers the
109 * socket structure to so_comp, making it available to accept().
111 * If a socket is closed with sockets on either
112 * so_incomp or so_comp, these sockets are dropped.
114 * If higher level protocols are implemented in
115 * the kernel, the wakeups done here will sometimes
116 * cause software-interrupt process scheduling.
121 register struct socket
*so
;
124 so
->so_state
&= ~(SS_ISCONNECTED
|SS_ISDISCONNECTING
);
125 so
->so_state
|= SS_ISCONNECTING
;
132 struct socket
*head
= so
->so_head
;
137 if (kp
->e_soif
&& kp
->e_soif
->sf_soisconnected
) {
138 if ((*kp
->e_soif
->sf_soisconnected
)(so
, kp
))
144 so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISDISCONNECTING
|SS_ISCONFIRMING
);
145 so
->so_state
|= SS_ISCONNECTED
;
146 if (head
&& (so
->so_state
& SS_INCOMP
)) {
147 postevent(head
,0,EV_RCONN
);
148 TAILQ_REMOVE(&head
->so_incomp
, so
, so_list
);
150 so
->so_state
&= ~SS_INCOMP
;
151 TAILQ_INSERT_TAIL(&head
->so_comp
, so
, so_list
);
152 so
->so_state
|= SS_COMP
;
154 wakeup_one(&head
->so_timeo
);
156 postevent(so
,0,EV_WCONN
);
157 wakeup((caddr_t
)&so
->so_timeo
);
164 soisdisconnecting(so
)
165 register struct socket
*so
;
167 register struct kextcb
*kp
;
171 if (kp
->e_soif
&& kp
->e_soif
->sf_soisdisconnecting
) {
172 if ((*kp
->e_soif
->sf_soisdisconnecting
)(so
, kp
))
178 so
->so_state
&= ~SS_ISCONNECTING
;
179 so
->so_state
|= (SS_ISDISCONNECTING
|SS_CANTRCVMORE
|SS_CANTSENDMORE
);
180 wakeup((caddr_t
)&so
->so_timeo
);
187 register struct socket
*so
;
189 register struct kextcb
*kp
;
193 if (kp
->e_soif
&& kp
->e_soif
->sf_soisdisconnected
) {
194 if ((*kp
->e_soif
->sf_soisdisconnected
)(so
, kp
))
200 so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISCONNECTED
|SS_ISDISCONNECTING
);
201 so
->so_state
|= (SS_CANTRCVMORE
|SS_CANTSENDMORE
|SS_ISDISCONNECTED
);
202 wakeup((caddr_t
)&so
->so_timeo
);
208 * Return a random connection that hasn't been serviced yet and
209 * is eligible for discard. There is a one in qlen chance that
210 * we will return a null, saying that there are no dropable
211 * requests. In this case, the protocol specific code should drop
212 * the new request. This insures fairness.
214 * This may be used in conjunction with protocol specific queue
215 * congestion routines.
219 register struct socket
*head
;
221 register struct socket
*so
;
222 unsigned int i
, j
, qlen
;
224 static struct timeval old_runtime
;
225 static unsigned int cur_cnt
, old_cnt
;
229 if ((i
= (tv
.tv_sec
- old_runtime
.tv_sec
)) != 0) {
231 old_cnt
= cur_cnt
/ i
;
235 so
= TAILQ_FIRST(&head
->so_incomp
);
239 qlen
= head
->so_incqlen
;
240 if (++cur_cnt
> qlen
|| old_cnt
> qlen
) {
241 rnd
= (314159 * rnd
+ 66329) & 0xffff;
242 j
= ((qlen
+ 1) * rnd
) >> 16;
245 so
= TAILQ_NEXT(so
, so_list
);
252 * When an attempt at a new connection is noted on a socket
253 * which accepts connections, sonewconn is called. If the
254 * connection is possible (subject to space constraints, etc.)
255 * then we allocate a new structure, propoerly linked into the
256 * data structure of the original socket, and return this.
257 * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
260 sonewconn(head
, connstatus
)
261 register struct socket
*head
;
265 register struct socket
*so
;
266 register struct kextcb
*kp
;
268 if (head
->so_qlen
> 3 * head
->so_qlimit
/ 2)
269 return ((struct socket
*)0);
270 so
= soalloc(1, head
->so_proto
->pr_domain
->dom_family
, head
->so_type
);
272 return ((struct socket
*)0);
273 /* check if head was closed during the soalloc */
274 if (head
->so_proto
== NULL
) {
276 return ((struct socket
*)0);
280 so
->so_type
= head
->so_type
;
281 so
->so_options
= head
->so_options
&~ SO_ACCEPTCONN
;
282 so
->so_linger
= head
->so_linger
;
283 so
->so_state
= head
->so_state
| SS_NOFDREF
;
284 so
->so_proto
= head
->so_proto
;
285 so
->so_timeo
= head
->so_timeo
;
286 so
->so_pgid
= head
->so_pgid
;
287 so
->so_uid
= head
->so_uid
;
289 /* Attach socket filters for this protocol */
290 if (so
->so_proto
->pr_sfilter
.tqh_first
)
291 error
= sfilter_init(so
);
294 return ((struct socket
*)0);
297 /* Call socket filters' sonewconn1 function if set */
300 if (kp
->e_soif
&& kp
->e_soif
->sf_sonewconn
) {
301 error
= (int)(*kp
->e_soif
->sf_sonewconn
)(so
, connstatus
, kp
);
302 if (error
== EJUSTRETURN
) {
304 } else if (error
!= 0) {
312 if (soreserve(so
, head
->so_snd
.sb_hiwat
, head
->so_rcv
.sb_hiwat
) ||
313 (*so
->so_proto
->pr_usrreqs
->pru_attach
)(so
, 0, NULL
)) {
316 return ((struct socket
*)0);
319 so
->so_proto
->pr_domain
->dom_refs
++;
323 TAILQ_INSERT_TAIL(&head
->so_comp
, so
, so_list
);
324 so
->so_state
|= SS_COMP
;
326 TAILQ_INSERT_TAIL(&head
->so_incomp
, so
, so_list
);
327 so
->so_state
|= SS_INCOMP
;
333 wakeup((caddr_t
)&head
->so_timeo
);
334 so
->so_state
|= connstatus
;
337 so
->so_rcv
.sb_so
= so
->so_snd
.sb_so
= so
;
338 TAILQ_INIT(&so
->so_evlist
);
344 * Socantsendmore indicates that no more data will be sent on the
345 * socket; it would normally be applied to a socket when the user
346 * informs the system that no more data is to be sent, by the protocol
347 * code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data
348 * will be received, and will normally be applied to the socket by a
349 * protocol when it detects that the peer will send no more data.
350 * Data queued for reading in the socket may yet be read.
357 register struct kextcb
*kp
;
361 if (kp
->e_soif
&& kp
->e_soif
->sf_socantsendmore
) {
362 if ((*kp
->e_soif
->sf_socantsendmore
)(so
, kp
))
369 so
->so_state
|= SS_CANTSENDMORE
;
377 register struct kextcb
*kp
;
381 if (kp
->e_soif
&& kp
->e_soif
->sf_socantrcvmore
) {
382 if ((*kp
->e_soif
->sf_socantrcvmore
)(so
, kp
))
389 so
->so_state
|= SS_CANTRCVMORE
;
394 * Wait for data to arrive at/drain from a socket buffer.
401 sb
->sb_flags
|= SB_WAIT
;
402 return (tsleep((caddr_t
)&sb
->sb_cc
,
403 (sb
->sb_flags
& SB_NOINTR
) ? PSOCK
: PSOCK
| PCATCH
, "sbwait",
408 * Lock a sockbuf already known to be locked;
409 * return any error returned from sleep (EINTR).
413 register struct sockbuf
*sb
;
417 while (sb
->sb_flags
& SB_LOCK
) {
418 sb
->sb_flags
|= SB_WANT
;
419 error
= tsleep((caddr_t
)&sb
->sb_flags
,
420 (sb
->sb_flags
& SB_NOINTR
) ? PSOCK
: PSOCK
|PCATCH
,
425 sb
->sb_flags
|= SB_LOCK
;
430 * Wakeup processes waiting on a socket buffer.
431 * Do asynchronous notification via SIGIO
432 * if the socket has the SS_ASYNC flag set.
436 register struct socket
*so
;
437 register struct sockbuf
*sb
;
439 struct proc
*p
= current_proc();
440 /* We clear the flag before calling selwakeup. */
441 /* BSD calls selwakeup then sets the flag */
442 sb
->sb_flags
&= ~SB_SEL
;
443 selwakeup(&sb
->sb_sel
);
444 if (sb
->sb_flags
& SB_WAIT
) {
445 sb
->sb_flags
&= ~SB_WAIT
;
446 wakeup((caddr_t
)&sb
->sb_cc
);
448 if (so
->so_state
& SS_ASYNC
) {
450 gsignal(-so
->so_pgid
, SIGIO
);
451 else if (so
->so_pgid
> 0 && (p
= pfind(so
->so_pgid
)) != 0)
454 if (sb
->sb_flags
& SB_UPCALL
)
455 (*so
->so_upcall
)(so
, so
->so_upcallarg
, M_DONTWAIT
);
456 if (sb
->sb_flags
& SB_KNOTE
&&
457 !(sb
->sb_sel
.si_flags
& SI_INITED
))
458 KNOTE(&sb
->sb_sel
.si_note
, 0);
462 * Socket buffer (struct sockbuf) utility routines.
464 * Each socket contains two socket buffers: one for sending data and
465 * one for receiving data. Each buffer contains a queue of mbufs,
466 * information about the number of mbufs and amount of data in the
467 * queue, and other fields allowing select() statements and notification
468 * on data availability to be implemented.
470 * Data stored in a socket buffer is maintained as a list of records.
471 * Each record is a list of mbufs chained together with the m_next
472 * field. Records are chained together with the m_nextpkt field. The upper
473 * level routine soreceive() expects the following conventions to be
474 * observed when placing information in the receive buffer:
476 * 1. If the protocol requires each message be preceded by the sender's
477 * name, then a record containing that name must be present before
478 * any associated data (mbuf's must be of type MT_SONAME).
479 * 2. If the protocol supports the exchange of ``access rights'' (really
480 * just additional data associated with the message), and there are
481 * ``rights'' to be received, then a record containing this data
482 * should be present (mbuf's must be of type MT_RIGHTS).
483 * 3. If a name or rights record exists, then it must be followed by
484 * a data record, perhaps of zero length.
486 * Before using a new socket structure it is first necessary to reserve
487 * buffer space to the socket, by calling sbreserve(). This should commit
488 * some of the available buffer space in the system buffer pool for the
489 * socket (currently, it does nothing but enforce limits). The space
490 * should be released by calling sbrelease() when the socket is destroyed.
494 soreserve(so
, sndcc
, rcvcc
)
495 register struct socket
*so
;
498 register struct kextcb
*kp
;
502 if (kp
->e_soif
&& kp
->e_soif
->sf_soreserve
) {
503 if ((*kp
->e_soif
->sf_soreserve
)(so
, sndcc
, rcvcc
, kp
))
509 if (sbreserve(&so
->so_snd
, sndcc
) == 0)
511 if (sbreserve(&so
->so_rcv
, rcvcc
) == 0)
513 if (so
->so_rcv
.sb_lowat
== 0)
514 so
->so_rcv
.sb_lowat
= 1;
515 if (so
->so_snd
.sb_lowat
== 0)
516 so
->so_snd
.sb_lowat
= MCLBYTES
;
517 if (so
->so_snd
.sb_lowat
> so
->so_snd
.sb_hiwat
)
518 so
->so_snd
.sb_lowat
= so
->so_snd
.sb_hiwat
;
522 selthreadclear(&so
->so_snd
.sb_sel
);
524 sbrelease(&so
->so_snd
);
530 * Allot mbufs to a sockbuf.
531 * Attempt to scale mbmax so that mbcnt doesn't become limiting
532 * if buffering efficiency is near the normal case.
539 if ((u_quad_t
)cc
> (u_quad_t
)sb_max
* MCLBYTES
/ (MSIZE
+ MCLBYTES
))
542 sb
->sb_mbmax
= min(cc
* sb_efficiency
, sb_max
);
543 if (sb
->sb_lowat
> sb
->sb_hiwat
)
544 sb
->sb_lowat
= sb
->sb_hiwat
;
549 * Free mbufs held by a socket, and reserved mbuf space.
551 /* WARNING needs to do selthreadclear() before calling this */
564 * Routines to add and remove
565 * data from an mbuf queue.
567 * The routines sbappend() or sbappendrecord() are normally called to
568 * append new mbufs to a socket buffer, after checking that adequate
569 * space is available, comparing the function sbspace() with the amount
570 * of data to be added. sbappendrecord() differs from sbappend() in
571 * that data supplied is treated as the beginning of a new record.
572 * To place a sender's address, optional access rights, and data in a
573 * socket receive buffer, sbappendaddr() should be used. To place
574 * access rights and data in a socket receive buffer, sbappendrights()
575 * should be used. In either case, the new data begins a new record.
576 * Note that unlike sbappend() and sbappendrecord(), these routines check
577 * for the caller that there will be enough space to store the data.
578 * Each fails if there is not enough space, or if it cannot find mbufs
579 * to store additional information in.
581 * Reliable protocols may use the socket send buffer to hold data
582 * awaiting acknowledgement. Data is normally copied from a socket
583 * send buffer in a protocol with m_copy for output to a peer,
584 * and then removing the data from the socket buffer with sbdrop()
585 * or sbdroprecord() when the data is acknowledged by the peer.
589 * Append mbuf chain m to the last record in the
590 * socket buffer sb. The additional space associated
591 * the mbuf chain is recorded in sb. Empty mbufs are
592 * discarded and mbufs are compacted where possible.
600 register struct mbuf
*n
;
603 KERNEL_DEBUG((DBG_FNC_SBAPPEND
| DBG_FUNC_START
), sb
, m
->m_len
, 0, 0, 0);
607 kp
= sotokextcb(sbtoso(sb
));
609 if (kp
->e_sout
&& kp
->e_sout
->su_sbappend
) {
610 if ((*kp
->e_sout
->su_sbappend
)(sb
, m
, kp
)) {
611 KERNEL_DEBUG((DBG_FNC_SBAPPEND
| DBG_FUNC_END
), sb
, sb
->sb_cc
, kp
, 0, 0);
622 if (n
->m_flags
& M_EOR
) {
623 sbappendrecord(sb
, m
); /* XXXXXX!!!! */
624 KERNEL_DEBUG((DBG_FNC_SBAPPEND
| DBG_FUNC_END
), sb
, sb
->sb_cc
, 0, 0, 0);
627 } while (n
->m_next
&& (n
= n
->m_next
));
629 sbcompress(sb
, m
, n
);
631 KERNEL_DEBUG((DBG_FNC_SBAPPEND
| DBG_FUNC_END
), sb
, sb
->sb_cc
, 0, 0, 0);
637 register struct sockbuf
*sb
;
639 register struct mbuf
*m
;
640 register struct mbuf
*n
= 0;
641 register u_long len
= 0, mbcnt
= 0;
643 for (m
= sb
->sb_mb
; m
; m
= n
) {
645 for (; m
; m
= m
->m_next
) {
648 if (m
->m_flags
& M_EXT
) /*XXX*/ /* pretty sure this is bogus */
649 mbcnt
+= m
->m_ext
.ext_size
;
653 if (len
!= sb
->sb_cc
|| mbcnt
!= sb
->sb_mbcnt
) {
654 printf("cc %ld != %ld || mbcnt %ld != %ld\n", len
, sb
->sb_cc
,
655 mbcnt
, sb
->sb_mbcnt
);
659 if (len
!= sb
->sb_cc
)
660 printf("sbcheck len %ld != sb_cc %ld\n", len
, sb
->sb_cc
);
661 if (mbcnt
!= sb
->sb_mbcnt
)
662 printf("sbcheck mbcnt %ld != sb_mbcnt %ld\n", mbcnt
, sb
->sb_mbcnt
);
668 * As above, except the mbuf chain
669 * begins a new record.
672 sbappendrecord(sb
, m0
)
673 register struct sockbuf
*sb
;
674 register struct mbuf
*m0
;
676 register struct mbuf
*m
;
677 register struct kextcb
*kp
;
682 kp
= sotokextcb(sbtoso(sb
));
684 { if (kp
->e_sout
&& kp
->e_sout
->su_sbappendrecord
)
685 { if ((*kp
->e_sout
->su_sbappendrecord
)(sb
, m0
, kp
))
696 * Put the first mbuf on the queue.
697 * Note this permits zero length records.
706 if (m
&& (m0
->m_flags
& M_EOR
)) {
707 m0
->m_flags
&= ~M_EOR
;
710 sbcompress(sb
, m
, m0
);
714 * As above except that OOB data
715 * is inserted at the beginning of the sockbuf,
716 * but after any other OOB data.
720 register struct sockbuf
*sb
;
721 register struct mbuf
*m0
;
723 register struct mbuf
*m
;
724 register struct mbuf
**mp
;
725 register struct kextcb
*kp
;
730 kp
= sotokextcb(sbtoso(sb
));
732 { if (kp
->e_sout
&& kp
->e_sout
->su_sbinsertoob
)
733 { if ((*kp
->e_sout
->su_sbinsertoob
)(sb
, m0
, kp
))
739 for (mp
= &sb
->sb_mb
; *mp
; mp
= &((*mp
)->m_nextpkt
)) {
745 continue; /* WANT next train */
750 goto again
; /* inspect THIS train further */
755 * Put the first mbuf on the queue.
756 * Note this permits zero length records.
763 if (m
&& (m0
->m_flags
& M_EOR
)) {
764 m0
->m_flags
&= ~M_EOR
;
767 sbcompress(sb
, m
, m0
);
771 * Append address and data, and optionally, control (ancillary) data
772 * to the receive queue of a socket. If present,
773 * m0 must include a packet header with total length.
774 * Returns 0 if no space in sockbuf or insufficient mbufs.
777 sbappendaddr(sb
, asa
, m0
, control
)
778 register struct sockbuf
*sb
;
779 struct sockaddr
*asa
;
780 struct mbuf
*m0
, *control
;
782 register struct mbuf
*m
, *n
;
783 int space
= asa
->sa_len
;
784 register struct kextcb
*kp
;
786 if (m0
&& (m0
->m_flags
& M_PKTHDR
) == 0)
787 panic("sbappendaddr");
789 kp
= sotokextcb(sbtoso(sb
));
791 { if (kp
->e_sout
&& kp
->e_sout
->su_sbappendaddr
)
792 { if ((*kp
->e_sout
->su_sbappendaddr
)(sb
, asa
, m0
, control
, kp
))
799 space
+= m0
->m_pkthdr
.len
;
800 for (n
= control
; n
; n
= n
->m_next
) {
802 if (n
->m_next
== 0) /* keep pointer to last control buf */
805 if (space
> sbspace(sb
))
807 if (asa
->sa_len
> MLEN
)
809 MGET(m
, M_DONTWAIT
, MT_SONAME
);
812 m
->m_len
= asa
->sa_len
;
813 bcopy((caddr_t
)asa
, mtod(m
, caddr_t
), asa
->sa_len
);
815 n
->m_next
= m0
; /* concatenate data to control */
819 for (n
= m
; n
; n
= n
->m_next
)
828 postevent(0,sb
,EV_RWBYTES
);
833 sbappendcontrol(sb
, m0
, control
)
835 struct mbuf
*control
, *m0
;
837 register struct mbuf
*m
, *n
;
839 register struct kextcb
*kp
;
842 panic("sbappendcontrol");
844 kp
= sotokextcb(sbtoso(sb
));
846 { if (kp
->e_sout
&& kp
->e_sout
->su_sbappendcontrol
)
847 { if ((*kp
->e_sout
->su_sbappendcontrol
)(sb
, m0
, control
, kp
))
853 for (m
= control
; ; m
= m
->m_next
) {
858 n
= m
; /* save pointer to last control buffer */
859 for (m
= m0
; m
; m
= m
->m_next
)
861 if (space
> sbspace(sb
))
863 n
->m_next
= m0
; /* concatenate data to control */
864 for (m
= control
; m
; m
= m
->m_next
)
870 n
->m_nextpkt
= control
;
873 postevent(0,sb
,EV_RWBYTES
);
878 * Compress mbuf chain m into the socket
879 * buffer sb following mbuf n. If n
880 * is null, the buffer is presumed empty.
884 register struct sockbuf
*sb
;
885 register struct mbuf
*m
, *n
;
887 register int eor
= 0;
888 register struct mbuf
*o
;
891 eor
|= m
->m_flags
& M_EOR
;
894 (((o
= m
->m_next
) || (o
= n
)) &&
895 o
->m_type
== m
->m_type
))) {
899 if (n
&& (n
->m_flags
& M_EOR
) == 0 &&
903 m
->m_len
<= MCLBYTES
/ 4 && /* XXX: Don't copy too much */
904 m
->m_len
<= M_TRAILINGSPACE(n
) &&
905 n
->m_type
== m
->m_type
) {
906 bcopy(mtod(m
, caddr_t
), mtod(n
, caddr_t
) + n
->m_len
,
908 n
->m_len
+= m
->m_len
;
909 sb
->sb_cc
+= m
->m_len
;
919 m
->m_flags
&= ~M_EOR
;
927 printf("semi-panic: sbcompress\n");
929 postevent(0,sb
, EV_RWBYTES
);
933 * Free all mbufs in a sockbuf.
934 * Check that all resources are reclaimed.
938 register struct sockbuf
*sb
;
940 register struct kextcb
*kp
;
942 kp
= sotokextcb(sbtoso(sb
));
944 if (kp
->e_sout
&& kp
->e_sout
->su_sbflush
) {
945 if ((*kp
->e_sout
->su_sbflush
)(sb
, kp
))
951 (void)sblock(sb
, M_WAIT
);
952 while (sb
->sb_mbcnt
) {
954 * Don't call sbdrop(sb, 0) if the leading mbuf is non-empty:
955 * we would loop forever. Panic instead.
957 if (!sb
->sb_cc
&& (sb
->sb_mb
== NULL
|| sb
->sb_mb
->m_len
))
959 sbdrop(sb
, (int)sb
->sb_cc
);
961 if (sb
->sb_cc
|| sb
->sb_mb
|| sb
->sb_mbcnt
)
962 panic("sbflush: cc %ld || mb %p || mbcnt %ld", sb
->sb_cc
, (void *)sb
->sb_mb
, sb
->sb_mbcnt
);
966 postevent(0, sb
, EV_RWBYTES
);
970 * Drop data from (the front of) a sockbuf.
971 * use m_freem_list to free the mbuf structures
972 * under a single lock... this is done by pruning
973 * the top of the tree from the body by keeping track
974 * of where we get to in the tree and then zeroing the
975 * two pertinent pointers m_nextpkt and m_next
976 * the socket buffer is then updated to point at the new
977 * top of the tree and the pruned area is released via
982 register struct sockbuf
*sb
;
985 register struct mbuf
*m
, *free_list
, *ml
;
986 struct mbuf
*next
, *last
;
987 register struct kextcb
*kp
;
989 KERNEL_DEBUG((DBG_FNC_SBDROP
| DBG_FUNC_START
), sb
, len
, 0, 0, 0);
991 kp
= sotokextcb(sbtoso(sb
));
993 if (kp
->e_sout
&& kp
->e_sout
->su_sbdrop
) {
994 if ((*kp
->e_sout
->su_sbdrop
)(sb
, len
, kp
)) {
995 KERNEL_DEBUG((DBG_FNC_SBDROP
| DBG_FUNC_END
), sb
, len
, kp
, 0, 0);
1001 next
= (m
= sb
->sb_mb
) ? m
->m_nextpkt
: 0;
1002 free_list
= last
= m
;
1003 ml
= (struct mbuf
*)0;
1008 /* temporarily replacing this panic with printf because
1009 * it occurs occasionally when closing a socket when there
1010 * is no harm in ignoring it. This problem will be investigated
1013 /* panic("sbdrop"); */
1014 printf("sbdrop - count not zero\n");
1016 /* zero the counts. if we have no mbufs, we have no data (PR-2986815) */
1022 next
= m
->m_nextpkt
;
1025 if (m
->m_len
> len
) {
1037 while (m
&& m
->m_len
== 0) {
1044 ml
->m_next
= (struct mbuf
*)0;
1045 last
->m_nextpkt
= (struct mbuf
*)0;
1046 m_freem_list(free_list
);
1050 m
->m_nextpkt
= next
;
1054 postevent(0, sb
, EV_RWBYTES
);
1056 KERNEL_DEBUG((DBG_FNC_SBDROP
| DBG_FUNC_END
), sb
, 0, 0, 0, 0);
1060 * Drop a record off the front of a sockbuf
1061 * and move the next record to the front.
1065 register struct sockbuf
*sb
;
1067 register struct mbuf
*m
, *mn
;
1068 register struct kextcb
*kp
;
1070 kp
= sotokextcb(sbtoso(sb
));
1072 if (kp
->e_sout
&& kp
->e_sout
->su_sbdroprecord
) {
1073 if ((*kp
->e_sout
->su_sbdroprecord
)(sb
, kp
))
1081 sb
->sb_mb
= m
->m_nextpkt
;
1088 postevent(0, sb
, EV_RWBYTES
);
1092 * Create a "control" mbuf containing the specified data
1093 * with the specified type for presentation on a socket buffer.
1096 sbcreatecontrol(p
, size
, type
, level
)
1101 register struct cmsghdr
*cp
;
1104 if (CMSG_SPACE((u_int
)size
) > MLEN
)
1105 return ((struct mbuf
*) NULL
);
1106 if ((m
= m_get(M_DONTWAIT
, MT_CONTROL
)) == NULL
)
1107 return ((struct mbuf
*) NULL
);
1108 cp
= mtod(m
, struct cmsghdr
*);
1109 /* XXX check size? */
1110 (void)memcpy(CMSG_DATA(cp
), p
, size
);
1111 m
->m_len
= CMSG_SPACE(size
);
1112 cp
->cmsg_len
= CMSG_LEN(size
);
1113 cp
->cmsg_level
= level
;
1114 cp
->cmsg_type
= type
;
1119 * Some routines that return EOPNOTSUPP for entry points that are not
1120 * supported by a protocol. Fill in as needed.
1123 pru_abort_notsupp(struct socket
*so
)
1130 pru_accept_notsupp(struct socket
*so
, struct sockaddr
**nam
)
1136 pru_attach_notsupp(struct socket
*so
, int proto
, struct proc
*p
)
1142 pru_bind_notsupp(struct socket
*so
, struct sockaddr
*nam
, struct proc
*p
)
1148 pru_connect_notsupp(struct socket
*so
, struct sockaddr
*nam
, struct proc
*p
)
1154 pru_connect2_notsupp(struct socket
*so1
, struct socket
*so2
)
1160 pru_control_notsupp(struct socket
*so
, u_long cmd
, caddr_t data
,
1161 struct ifnet
*ifp
, struct proc
*p
)
1167 pru_detach_notsupp(struct socket
*so
)
1173 pru_disconnect_notsupp(struct socket
*so
)
1179 pru_listen_notsupp(struct socket
*so
, struct proc
*p
)
1185 pru_peeraddr_notsupp(struct socket
*so
, struct sockaddr
**nam
)
1191 pru_rcvd_notsupp(struct socket
*so
, int flags
)
1197 pru_rcvoob_notsupp(struct socket
*so
, struct mbuf
*m
, int flags
)
1203 pru_send_notsupp(struct socket
*so
, int flags
, struct mbuf
*m
,
1204 struct sockaddr
*addr
, struct mbuf
*control
,
1213 * This isn't really a ``null'' operation, but it's the default one
1214 * and doesn't do anything destructive.
1217 pru_sense_null(struct socket
*so
, struct stat
*sb
)
1219 sb
->st_blksize
= so
->so_snd
.sb_hiwat
;
1224 int pru_sosend_notsupp(struct socket
*so
, struct sockaddr
*addr
,
1225 struct uio
*uio
, struct mbuf
*top
,
1226 struct mbuf
*control
, int flags
)
1232 int pru_soreceive_notsupp(struct socket
*so
,
1233 struct sockaddr
**paddr
,
1234 struct uio
*uio
, struct mbuf
**mp0
,
1235 struct mbuf
**controlp
, int *flagsp
)
1242 pru_shutdown_notsupp(struct socket
*so
)
1248 pru_sockaddr_notsupp(struct socket
*so
, struct sockaddr
**nam
)
1253 int pru_sosend(struct socket
*so
, struct sockaddr
*addr
,
1254 struct uio
*uio
, struct mbuf
*top
,
1255 struct mbuf
*control
, int flags
)
1260 int pru_soreceive(struct socket
*so
,
1261 struct sockaddr
**paddr
,
1262 struct uio
*uio
, struct mbuf
**mp0
,
1263 struct mbuf
**controlp
, int *flagsp
)
1269 int pru_sopoll_notsupp(struct socket
*so
, int events
,
1278 * The following are macros on BSD and functions on Darwin
1282 * Do we need to notify the other side when I/O is possible?
1286 sb_notify(struct sockbuf
*sb
)
1288 return ((sb
->sb_flags
& (SB_WAIT
|SB_SEL
|SB_ASYNC
|SB_UPCALL
|SB_KNOTE
)) != 0);
1292 * How much space is there in a socket buffer (so->so_snd or so->so_rcv)?
1293 * This is problematical if the fields are unsigned, as the space might
1294 * still be negative (cc > hiwat or mbcnt > mbmax). Should detect
1295 * overflow and return 0. Should use "lmin" but it doesn't exist now.
1298 sbspace(struct sockbuf
*sb
)
1300 return ((long) imin((int)(sb
->sb_hiwat
- sb
->sb_cc
),
1301 (int)(sb
->sb_mbmax
- sb
->sb_mbcnt
)));
1304 /* do we have to send all at once on a socket? */
1306 sosendallatonce(struct socket
*so
)
1308 return (so
->so_proto
->pr_flags
& PR_ATOMIC
);
1311 /* can we read something from so? */
1313 soreadable(struct socket
*so
)
1315 return (so
->so_rcv
.sb_cc
>= so
->so_rcv
.sb_lowat
||
1316 (so
->so_state
& SS_CANTRCVMORE
) ||
1317 so
->so_comp
.tqh_first
|| so
->so_error
);
1320 /* can we write something to so? */
1323 sowriteable(struct socket
*so
)
1325 return ((sbspace(&(so
)->so_snd
) >= (so
)->so_snd
.sb_lowat
&&
1326 ((so
->so_state
&SS_ISCONNECTED
) ||
1327 (so
->so_proto
->pr_flags
&PR_CONNREQUIRED
)==0)) ||
1328 (so
->so_state
& SS_CANTSENDMORE
) ||
1332 /* adjust counters in sb reflecting allocation of m */
1335 sballoc(struct sockbuf
*sb
, struct mbuf
*m
)
1337 sb
->sb_cc
+= m
->m_len
;
1338 sb
->sb_mbcnt
+= MSIZE
;
1339 if (m
->m_flags
& M_EXT
)
1340 sb
->sb_mbcnt
+= m
->m_ext
.ext_size
;
1343 /* adjust counters in sb reflecting freeing of m */
1345 sbfree(struct sockbuf
*sb
, struct mbuf
*m
)
1347 sb
->sb_cc
-= m
->m_len
;
1348 sb
->sb_mbcnt
-= MSIZE
;
1349 if (m
->m_flags
& M_EXT
)
1350 sb
->sb_mbcnt
-= m
->m_ext
.ext_size
;
1354 * Set lock on sockbuf sb; sleep if lock is already held.
1355 * Unless SB_NOINTR is set on sockbuf, sleep is interruptible.
1356 * Returns error without lock if sleep is interrupted.
1359 sblock(struct sockbuf
*sb
, int wf
)
1361 return(sb
->sb_flags
& SB_LOCK
?
1362 ((wf
== M_WAIT
) ? sb_lock(sb
) : EWOULDBLOCK
) :
1363 (sb
->sb_flags
|= SB_LOCK
), 0);
1366 /* release lock on sockbuf sb */
1368 sbunlock(struct sockbuf
*sb
)
1370 sb
->sb_flags
&= ~SB_LOCK
;
1371 if (sb
->sb_flags
& SB_WANT
) {
1372 sb
->sb_flags
&= ~SB_WANT
;
1373 wakeup((caddr_t
)&(sb
)->sb_flags
);
1378 sorwakeup(struct socket
* so
)
1380 if (sb_notify(&so
->so_rcv
))
1381 sowakeup(so
, &so
->so_rcv
);
1385 sowwakeup(struct socket
* so
)
1387 if (sb_notify(&so
->so_snd
))
1388 sowakeup(so
, &so
->so_snd
);
1393 * Make a copy of a sockaddr in a malloced buffer of type M_SONAME.
1396 dup_sockaddr(sa
, canwait
)
1397 struct sockaddr
*sa
;
1400 struct sockaddr
*sa2
;
1402 MALLOC(sa2
, struct sockaddr
*, sa
->sa_len
, M_SONAME
,
1403 canwait
? M_WAITOK
: M_NOWAIT
);
1405 bcopy(sa
, sa2
, sa
->sa_len
);
1410 * Create an external-format (``xsocket'') structure using the information
1411 * in the kernel-format socket structure pointed to by so. This is done
1412 * to reduce the spew of irrelevant information over this interface,
1413 * to isolate user code from changes in the kernel structure, and
1414 * potentially to provide information-hiding if we decide that
1415 * some of this information should be hidden from users.
1418 sotoxsocket(struct socket
*so
, struct xsocket
*xso
)
1420 xso
->xso_len
= sizeof *xso
;
1422 xso
->so_type
= so
->so_type
;
1423 xso
->so_options
= so
->so_options
;
1424 xso
->so_linger
= so
->so_linger
;
1425 xso
->so_state
= so
->so_state
;
1426 xso
->so_pcb
= so
->so_pcb
;
1427 xso
->xso_protocol
= so
->so_proto
->pr_protocol
;
1428 xso
->xso_family
= so
->so_proto
->pr_domain
->dom_family
;
1429 xso
->so_qlen
= so
->so_qlen
;
1430 xso
->so_incqlen
= so
->so_incqlen
;
1431 xso
->so_qlimit
= so
->so_qlimit
;
1432 xso
->so_timeo
= so
->so_timeo
;
1433 xso
->so_error
= so
->so_error
;
1434 xso
->so_pgid
= so
->so_pgid
;
1435 xso
->so_oobmark
= so
->so_oobmark
;
1436 sbtoxsockbuf(&so
->so_snd
, &xso
->so_snd
);
1437 sbtoxsockbuf(&so
->so_rcv
, &xso
->so_rcv
);
1438 xso
->so_uid
= so
->so_uid
;
1442 * This does the same for sockbufs. Note that the xsockbuf structure,
1443 * since it is always embedded in a socket, does not include a self
1444 * pointer nor a length. We make this entry point public in case
1445 * some other mechanism needs it.
1448 sbtoxsockbuf(struct sockbuf
*sb
, struct xsockbuf
*xsb
)
1450 xsb
->sb_cc
= sb
->sb_cc
;
1451 xsb
->sb_hiwat
= sb
->sb_hiwat
;
1452 xsb
->sb_mbcnt
= sb
->sb_mbcnt
;
1453 xsb
->sb_mbmax
= sb
->sb_mbmax
;
1454 xsb
->sb_lowat
= sb
->sb_lowat
;
1455 xsb
->sb_flags
= sb
->sb_flags
;
1456 xsb
->sb_timeo
= sb
->sb_timeo
;
1460 * Here is the definition of some of the basic objects in the kern.ipc
1461 * branch of the MIB.
1463 SYSCTL_NODE(_kern
, KERN_IPC
, ipc
, CTLFLAG_RW
, 0, "IPC");
1465 /* This takes the place of kern.maxsockbuf, which moved to kern.ipc. */
1467 SYSCTL_INT(_kern
, KERN_DUMMY
, dummy
, CTLFLAG_RW
, &dummy
, 0, "");
1469 SYSCTL_INT(_kern_ipc
, KIPC_MAXSOCKBUF
, maxsockbuf
, CTLFLAG_RW
,
1470 &sb_max
, 0, "Maximum socket buffer size");
1471 SYSCTL_INT(_kern_ipc
, OID_AUTO
, maxsockets
, CTLFLAG_RD
,
1472 &maxsockets
, 0, "Maximum number of sockets avaliable");
1473 SYSCTL_INT(_kern_ipc
, KIPC_SOCKBUF_WASTE
, sockbuf_waste_factor
, CTLFLAG_RW
,
1474 &sb_efficiency
, 0, "");
1475 SYSCTL_INT(_kern_ipc
, KIPC_NMBCLUSTERS
, nmbclusters
, CTLFLAG_RD
, &nmbclusters
, 0, "");