2 * Copyright (c) 2005 Jeffrey M. Hsu. All rights reserved.
3 * Copyright (c) 1982, 1986, 1988, 1990, 1993
4 * The Regents of the University of California. All rights reserved.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 * 3. All advertising materials mentioning features or use of this software
15 * must display the following acknowledgement:
16 * This product includes software developed by the University of
17 * California, Berkeley and its contributors.
18 * 4. Neither the name of the University nor the names of its contributors
19 * may be used to endorse or promote products derived from this software
20 * without specific prior written permission.
22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * @(#)uipc_socket2.c 8.1 (Berkeley) 6/10/93
35 * $FreeBSD: src/sys/kern/uipc_socket2.c,v 1.55.2.17 2002/08/31 19:04:55 dwmalone Exp $
36 * $DragonFly: src/sys/kern/uipc_socket2.c,v 1.33 2008/09/02 16:17:52 dillon Exp $
39 #include "opt_param.h"
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/domain.h>
43 #include <sys/file.h> /* for maxfiles */
44 #include <sys/kernel.h>
46 #include <sys/malloc.h>
48 #include <sys/protosw.h>
49 #include <sys/resourcevar.h>
51 #include <sys/socket.h>
52 #include <sys/socketvar.h>
53 #include <sys/signalvar.h>
54 #include <sys/sysctl.h>
55 #include <sys/aio.h> /* for aio_swake proto */
56 #include <sys/event.h>
58 #include <sys/thread2.h>
59 #include <sys/msgport2.h>
64 * Primitive routines for operating on sockets and socket buffers
67 u_long sb_max
= SB_MAX
;
69 SB_MAX
* MCLBYTES
/ (MSIZE
+ MCLBYTES
); /* adjusted sb_max */
71 static u_long sb_efficiency
= 8; /* parameter for sbreserve() */
73 /************************************************************************
74 * signalsockbuf procedures *
75 ************************************************************************/
78 * Wait for data to arrive at/drain from a socket buffer.
81 ssb_wait(struct signalsockbuf
*ssb
)
84 ssb
->ssb_flags
|= SSB_WAIT
;
85 return (tsleep((caddr_t
)&ssb
->ssb_cc
,
86 ((ssb
->ssb_flags
& SSB_NOINTR
) ? 0 : PCATCH
),
92 * Lock a sockbuf already known to be locked;
93 * return any error returned from sleep (EINTR).
96 _ssb_lock(struct signalsockbuf
*ssb
)
100 while (ssb
->ssb_flags
& SSB_LOCK
) {
101 ssb
->ssb_flags
|= SSB_WANT
;
102 error
= tsleep((caddr_t
)&ssb
->ssb_flags
,
103 ((ssb
->ssb_flags
& SSB_NOINTR
) ? 0 : PCATCH
),
108 ssb
->ssb_flags
|= SSB_LOCK
;
113 * This does the same for sockbufs. Note that the xsockbuf structure,
114 * since it is always embedded in a socket, does not include a self
115 * pointer nor a length. We make this entry point public in case
116 * some other mechanism needs it.
119 ssbtoxsockbuf(struct signalsockbuf
*ssb
, struct xsockbuf
*xsb
)
121 xsb
->sb_cc
= ssb
->ssb_cc
;
122 xsb
->sb_hiwat
= ssb
->ssb_hiwat
;
123 xsb
->sb_mbcnt
= ssb
->ssb_mbcnt
;
124 xsb
->sb_mbmax
= ssb
->ssb_mbmax
;
125 xsb
->sb_lowat
= ssb
->ssb_lowat
;
126 xsb
->sb_flags
= ssb
->ssb_flags
;
127 xsb
->sb_timeo
= ssb
->ssb_timeo
;
131 /************************************************************************
132 * Procedures which manipulate socket state flags, wakeups, etc. *
133 ************************************************************************
135 * Normal sequence from the active (originating) side is that
136 * soisconnecting() is called during processing of connect() call, resulting
137 * in an eventual call to soisconnected() if/when the connection is
138 * established. When the connection is torn down soisdisconnecting() is
139 * called during processing of disconnect() call, and soisdisconnected() is
140 * called when the connection to the peer is totally severed.
142 * The semantics of these routines are such that connectionless protocols
143 * can call soisconnected() and soisdisconnected() only, bypassing the
144 * in-progress calls when setting up a ``connection'' takes no time.
146 * From the passive side, a socket is created with two queues of sockets:
147 * so_incomp for connections in progress and so_comp for connections
148 * already made and awaiting user acceptance. As a protocol is preparing
149 * incoming connections, it creates a socket structure queued on so_incomp
150 * by calling sonewconn(). When the connection is established,
151 * soisconnected() is called, and transfers the socket structure to so_comp,
152 * making it available to accept().
154 * If a socket is closed with sockets on either so_incomp or so_comp, these
155 * sockets are dropped.
157 * If higher level protocols are implemented in the kernel, the wakeups
158 * done here will sometimes cause software-interrupt process scheduling.
162 soisconnecting(struct socket
*so
)
164 so
->so_state
&= ~(SS_ISCONNECTED
|SS_ISDISCONNECTING
);
165 so
->so_state
|= SS_ISCONNECTING
;
169 soisconnected(struct socket
*so
)
171 struct socket
*head
= so
->so_head
;
173 so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISDISCONNECTING
|SS_ISCONFIRMING
);
174 so
->so_state
|= SS_ISCONNECTED
;
175 if (head
&& (so
->so_state
& SS_INCOMP
)) {
176 if ((so
->so_options
& SO_ACCEPTFILTER
) != 0) {
177 so
->so_upcall
= head
->so_accf
->so_accept_filter
->accf_callback
;
178 so
->so_upcallarg
= head
->so_accf
->so_accept_filter_arg
;
179 so
->so_rcv
.ssb_flags
|= SSB_UPCALL
;
180 so
->so_options
&= ~SO_ACCEPTFILTER
;
181 so
->so_upcall(so
, so
->so_upcallarg
, 0);
184 TAILQ_REMOVE(&head
->so_incomp
, so
, so_list
);
186 so
->so_state
&= ~SS_INCOMP
;
187 TAILQ_INSERT_TAIL(&head
->so_comp
, so
, so_list
);
189 so
->so_state
|= SS_COMP
;
191 wakeup_one(&head
->so_timeo
);
193 wakeup(&so
->so_timeo
);
200 soisdisconnecting(struct socket
*so
)
202 so
->so_state
&= ~SS_ISCONNECTING
;
203 so
->so_state
|= (SS_ISDISCONNECTING
|SS_CANTRCVMORE
|SS_CANTSENDMORE
);
204 wakeup((caddr_t
)&so
->so_timeo
);
210 soisdisconnected(struct socket
*so
)
212 so
->so_state
&= ~(SS_ISCONNECTING
|SS_ISCONNECTED
|SS_ISDISCONNECTING
);
213 so
->so_state
|= (SS_CANTRCVMORE
|SS_CANTSENDMORE
|SS_ISDISCONNECTED
);
214 wakeup((caddr_t
)&so
->so_timeo
);
215 sbdrop(&so
->so_snd
.sb
, so
->so_snd
.ssb_cc
);
221 * When an attempt at a new connection is noted on a socket
222 * which accepts connections, sonewconn is called. If the
223 * connection is possible (subject to space constraints, etc.)
224 * then we allocate a new structure, propoerly linked into the
225 * data structure of the original socket, and return this.
226 * Connstatus may be 0, or SO_ISCONFIRMING, or SO_ISCONNECTED.
229 sonewconn(struct socket
*head
, int connstatus
)
233 struct pru_attach_info ai
;
235 if (head
->so_qlen
> 3 * head
->so_qlimit
/ 2)
240 if ((head
->so_options
& SO_ACCEPTFILTER
) != 0)
243 so
->so_type
= head
->so_type
;
244 so
->so_options
= head
->so_options
&~ SO_ACCEPTCONN
;
245 so
->so_linger
= head
->so_linger
;
246 so
->so_state
= head
->so_state
| SS_NOFDREF
;
247 so
->so_proto
= head
->so_proto
;
248 so
->so_cred
= crhold(head
->so_cred
);
251 ai
.fd_rdir
= NULL
; /* jail code cruft XXX JH */
252 if (soreserve(so
, head
->so_snd
.ssb_hiwat
, head
->so_rcv
.ssb_hiwat
, NULL
) ||
253 /* Directly call function since we're already at protocol level. */
254 (*so
->so_proto
->pr_usrreqs
->pru_attach
)(so
, 0, &ai
)) {
258 so
->so_rcv
.ssb_lowat
= head
->so_rcv
.ssb_lowat
;
259 so
->so_snd
.ssb_lowat
= head
->so_snd
.ssb_lowat
;
260 so
->so_rcv
.ssb_timeo
= head
->so_rcv
.ssb_timeo
;
261 so
->so_snd
.ssb_timeo
= head
->so_snd
.ssb_timeo
;
262 so
->so_rcv
.ssb_flags
|= head
->so_rcv
.ssb_flags
&
263 (SSB_AUTOSIZE
| SSB_AUTOLOWAT
);
264 so
->so_snd
.ssb_flags
|= head
->so_snd
.ssb_flags
&
265 (SSB_AUTOSIZE
| SSB_AUTOLOWAT
);
267 TAILQ_INSERT_TAIL(&head
->so_comp
, so
, so_list
);
268 so
->so_state
|= SS_COMP
;
271 if (head
->so_incqlen
> head
->so_qlimit
) {
272 sp
= TAILQ_FIRST(&head
->so_incomp
);
273 TAILQ_REMOVE(&head
->so_incomp
, sp
, so_list
);
275 sp
->so_state
&= ~SS_INCOMP
;
279 TAILQ_INSERT_TAIL(&head
->so_incomp
, so
, so_list
);
280 so
->so_state
|= SS_INCOMP
;
285 wakeup((caddr_t
)&head
->so_timeo
);
286 so
->so_state
|= connstatus
;
292 * Socantsendmore indicates that no more data will be sent on the
293 * socket; it would normally be applied to a socket when the user
294 * informs the system that no more data is to be sent, by the protocol
295 * code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data
296 * will be received, and will normally be applied to the socket by a
297 * protocol when it detects that the peer will send no more data.
298 * Data queued for reading in the socket may yet be read.
301 socantsendmore(struct socket
*so
)
303 so
->so_state
|= SS_CANTSENDMORE
;
308 socantrcvmore(struct socket
*so
)
310 so
->so_state
|= SS_CANTRCVMORE
;
315 * Wakeup processes waiting on a socket buffer. Do asynchronous notification
316 * via SIGIO if the socket has the SS_ASYNC flag set.
318 * For users waiting on send/recv try to avoid unnecessary context switch
319 * thrashing. Particularly for senders of large buffers (needs to be
320 * extended to sel and aio? XXX)
323 sowakeup(struct socket
*so
, struct signalsockbuf
*ssb
)
325 struct selinfo
*selinfo
= &ssb
->ssb_sel
;
328 ssb
->ssb_flags
&= ~SSB_SEL
;
329 if (ssb
->ssb_flags
& SSB_WAIT
) {
330 if ((ssb
== &so
->so_snd
&& ssb_space(ssb
) >= ssb
->ssb_lowat
) ||
331 (ssb
== &so
->so_rcv
&& ssb
->ssb_cc
>= ssb
->ssb_lowat
) ||
332 (ssb
== &so
->so_snd
&& (so
->so_state
& SS_CANTSENDMORE
)) ||
333 (ssb
== &so
->so_rcv
&& (so
->so_state
& SS_CANTRCVMORE
))
335 ssb
->ssb_flags
&= ~SSB_WAIT
;
336 wakeup((caddr_t
)&ssb
->ssb_cc
);
339 if ((so
->so_state
& SS_ASYNC
) && so
->so_sigio
!= NULL
)
340 pgsigio(so
->so_sigio
, SIGIO
, 0);
341 if (ssb
->ssb_flags
& SSB_UPCALL
)
342 (*so
->so_upcall
)(so
, so
->so_upcallarg
, MB_DONTWAIT
);
343 if (ssb
->ssb_flags
& SSB_AIO
)
345 KNOTE(&selinfo
->si_note
, 0);
346 if (ssb
->ssb_flags
& SSB_MEVENT
) {
347 struct netmsg_so_notify
*msg
, *nmsg
;
349 TAILQ_FOREACH_MUTABLE(msg
, &selinfo
->si_mlist
, nm_list
, nmsg
) {
350 if (msg
->nm_predicate(&msg
->nm_netmsg
)) {
351 TAILQ_REMOVE(&selinfo
->si_mlist
, msg
, nm_list
);
352 lwkt_replymsg(&msg
->nm_netmsg
.nm_lmsg
,
353 msg
->nm_netmsg
.nm_lmsg
.ms_error
);
356 if (TAILQ_EMPTY(&ssb
->ssb_sel
.si_mlist
))
357 ssb
->ssb_flags
&= ~SSB_MEVENT
;
362 * Socket buffer (struct signalsockbuf) utility routines.
364 * Each socket contains two socket buffers: one for sending data and
365 * one for receiving data. Each buffer contains a queue of mbufs,
366 * information about the number of mbufs and amount of data in the
367 * queue, and other fields allowing select() statements and notification
368 * on data availability to be implemented.
370 * Data stored in a socket buffer is maintained as a list of records.
371 * Each record is a list of mbufs chained together with the m_next
372 * field. Records are chained together with the m_nextpkt field. The upper
373 * level routine soreceive() expects the following conventions to be
374 * observed when placing information in the receive buffer:
376 * 1. If the protocol requires each message be preceded by the sender's
377 * name, then a record containing that name must be present before
378 * any associated data (mbuf's must be of type MT_SONAME).
379 * 2. If the protocol supports the exchange of ``access rights'' (really
380 * just additional data associated with the message), and there are
381 * ``rights'' to be received, then a record containing this data
382 * should be present (mbuf's must be of type MT_RIGHTS).
383 * 3. If a name or rights record exists, then it must be followed by
384 * a data record, perhaps of zero length.
386 * Before using a new socket structure it is first necessary to reserve
387 * buffer space to the socket, by calling sbreserve(). This should commit
388 * some of the available buffer space in the system buffer pool for the
389 * socket (currently, it does nothing but enforce limits). The space
390 * should be released by calling ssb_release() when the socket is destroyed.
393 soreserve(struct socket
*so
, u_long sndcc
, u_long rcvcc
, struct rlimit
*rl
)
395 if (so
->so_snd
.ssb_lowat
== 0)
396 so
->so_snd
.ssb_flags
|= SSB_AUTOLOWAT
;
397 if (ssb_reserve(&so
->so_snd
, sndcc
, so
, rl
) == 0)
399 if (ssb_reserve(&so
->so_rcv
, rcvcc
, so
, rl
) == 0)
401 if (so
->so_rcv
.ssb_lowat
== 0)
402 so
->so_rcv
.ssb_lowat
= 1;
403 if (so
->so_snd
.ssb_lowat
== 0)
404 so
->so_snd
.ssb_lowat
= MCLBYTES
;
405 if (so
->so_snd
.ssb_lowat
> so
->so_snd
.ssb_hiwat
)
406 so
->so_snd
.ssb_lowat
= so
->so_snd
.ssb_hiwat
;
409 ssb_release(&so
->so_snd
, so
);
415 sysctl_handle_sb_max(SYSCTL_HANDLER_ARGS
)
418 u_long old_sb_max
= sb_max
;
420 error
= SYSCTL_OUT(req
, arg1
, sizeof(int));
421 if (error
|| !req
->newptr
)
423 error
= SYSCTL_IN(req
, arg1
, sizeof(int));
426 if (sb_max
< MSIZE
+ MCLBYTES
) {
430 sb_max_adj
= (u_quad_t
)sb_max
* MCLBYTES
/ (MSIZE
+ MCLBYTES
);
435 * Allot mbufs to a signalsockbuf.
437 * Attempt to scale mbmax so that mbcnt doesn't become limiting
438 * if buffering efficiency is near the normal case.
440 * sb_max only applies to user-sockets (where rl != NULL). It does
441 * not apply to kernel sockets or kernel-controlled sockets. Note
442 * that NFS overrides the sockbuf limits created when nfsd creates
446 ssb_reserve(struct signalsockbuf
*ssb
, u_long cc
, struct socket
*so
,
450 * rl will only be NULL when we're in an interrupt (eg, in tcp_input)
451 * or when called from netgraph (ie, ngd_attach)
453 if (rl
&& cc
> sb_max_adj
)
455 if (!chgsbsize(so
->so_cred
->cr_uidinfo
, &ssb
->ssb_hiwat
, cc
,
456 rl
? rl
->rlim_cur
: RLIM_INFINITY
)) {
460 ssb
->ssb_mbmax
= min(cc
* sb_efficiency
, sb_max
);
462 ssb
->ssb_mbmax
= cc
* sb_efficiency
;
465 * AUTOLOWAT is set on send buffers and prevents large writes
466 * from generating a huge number of context switches.
468 if (ssb
->ssb_flags
& SSB_AUTOLOWAT
) {
469 ssb
->ssb_lowat
= ssb
->ssb_hiwat
/ 2;
470 if (ssb
->ssb_lowat
< MCLBYTES
)
471 ssb
->ssb_lowat
= MCLBYTES
;
473 if (ssb
->ssb_lowat
> ssb
->ssb_hiwat
)
474 ssb
->ssb_lowat
= ssb
->ssb_hiwat
;
479 * Free mbufs held by a socket, and reserved mbuf space.
482 ssb_release(struct signalsockbuf
*ssb
, struct socket
*so
)
485 (void)chgsbsize(so
->so_cred
->cr_uidinfo
, &ssb
->ssb_hiwat
, 0,
491 * Some routines that return EOPNOTSUPP for entry points that are not
492 * supported by a protocol. Fill in as needed.
495 pru_accept_notsupp(struct socket
*so
, struct sockaddr
**nam
)
501 pru_bind_notsupp(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
507 pru_connect_notsupp(struct socket
*so
, struct sockaddr
*nam
, struct thread
*td
)
513 pru_connect2_notsupp(struct socket
*so1
, struct socket
*so2
)
519 pru_control_notsupp(struct socket
*so
, u_long cmd
, caddr_t data
,
520 struct ifnet
*ifp
, struct thread
*td
)
526 pru_disconnect_notsupp(struct socket
*so
)
532 pru_listen_notsupp(struct socket
*so
, struct thread
*td
)
538 pru_peeraddr_notsupp(struct socket
*so
, struct sockaddr
**nam
)
544 pru_rcvd_notsupp(struct socket
*so
, int flags
)
550 pru_rcvoob_notsupp(struct socket
*so
, struct mbuf
*m
, int flags
)
556 pru_shutdown_notsupp(struct socket
*so
)
562 pru_sockaddr_notsupp(struct socket
*so
, struct sockaddr
**nam
)
568 pru_sosend_notsupp(struct socket
*so
, struct sockaddr
*addr
, struct uio
*uio
,
569 struct mbuf
*top
, struct mbuf
*control
, int flags
,
580 pru_soreceive_notsupp(struct socket
*so
, struct sockaddr
**paddr
,
581 struct uio
*uio
, struct sockbuf
*sio
,
582 struct mbuf
**controlp
, int *flagsp
)
588 pru_sopoll_notsupp(struct socket
*so
, int events
,
589 struct ucred
*cred
, struct thread
*td
)
595 pru_ctloutput_notsupp(struct socket
*so
, struct sockopt
*sopt
)
601 * This isn't really a ``null'' operation, but it's the default one
602 * and doesn't do anything destructive.
605 pru_sense_null(struct socket
*so
, struct stat
*sb
)
607 sb
->st_blksize
= so
->so_snd
.ssb_hiwat
;
612 * Make a copy of a sockaddr in a malloced buffer of type M_SONAME. Callers
613 * of this routine assume that it always succeeds, so we have to use a
614 * blockable allocation even though we might be called from a critical thread.
617 dup_sockaddr(const struct sockaddr
*sa
)
619 struct sockaddr
*sa2
;
621 sa2
= kmalloc(sa
->sa_len
, M_SONAME
, M_INTWAIT
);
622 bcopy(sa
, sa2
, sa
->sa_len
);
627 * Create an external-format (``xsocket'') structure using the information
628 * in the kernel-format socket structure pointed to by so. This is done
629 * to reduce the spew of irrelevant information over this interface,
630 * to isolate user code from changes in the kernel structure, and
631 * potentially to provide information-hiding if we decide that
632 * some of this information should be hidden from users.
635 sotoxsocket(struct socket
*so
, struct xsocket
*xso
)
637 xso
->xso_len
= sizeof *xso
;
639 xso
->so_type
= so
->so_type
;
640 xso
->so_options
= so
->so_options
;
641 xso
->so_linger
= so
->so_linger
;
642 xso
->so_state
= so
->so_state
;
643 xso
->so_pcb
= so
->so_pcb
;
644 xso
->xso_protocol
= so
->so_proto
->pr_protocol
;
645 xso
->xso_family
= so
->so_proto
->pr_domain
->dom_family
;
646 xso
->so_qlen
= so
->so_qlen
;
647 xso
->so_incqlen
= so
->so_incqlen
;
648 xso
->so_qlimit
= so
->so_qlimit
;
649 xso
->so_timeo
= so
->so_timeo
;
650 xso
->so_error
= so
->so_error
;
651 xso
->so_pgid
= so
->so_sigio
? so
->so_sigio
->sio_pgid
: 0;
652 xso
->so_oobmark
= so
->so_oobmark
;
653 ssbtoxsockbuf(&so
->so_snd
, &xso
->so_snd
);
654 ssbtoxsockbuf(&so
->so_rcv
, &xso
->so_rcv
);
655 xso
->so_uid
= so
->so_cred
->cr_uid
;
659 * Here is the definition of some of the basic objects in the kern.ipc
662 SYSCTL_NODE(_kern
, KERN_IPC
, ipc
, CTLFLAG_RW
, 0, "IPC");
665 * This takes the place of kern.maxsockbuf, which moved to kern.ipc.
667 * NOTE! sb_max only applies to user-created socket buffers.
670 SYSCTL_INT(_kern
, KERN_DUMMY
, dummy
, CTLFLAG_RW
, &dummy
, 0, "");
671 SYSCTL_OID(_kern_ipc
, KIPC_MAXSOCKBUF
, maxsockbuf
, CTLTYPE_INT
|CTLFLAG_RW
,
672 &sb_max
, 0, sysctl_handle_sb_max
, "I", "Maximum socket buffer size");
673 SYSCTL_INT(_kern_ipc
, OID_AUTO
, maxsockets
, CTLFLAG_RD
,
674 &maxsockets
, 0, "Maximum number of sockets available");
675 SYSCTL_INT(_kern_ipc
, KIPC_SOCKBUF_WASTE
, sockbuf_waste_factor
, CTLFLAG_RW
,
676 &sb_efficiency
, 0, "");
679 * Initialize maxsockets
682 init_maxsockets(void *ignored
)
684 TUNABLE_INT_FETCH("kern.ipc.maxsockets", &maxsockets
);
685 maxsockets
= imax(maxsockets
, imax(maxfiles
, nmbclusters
));
687 SYSINIT(param
, SI_BOOT1_TUNABLES
, SI_ORDER_ANY
,
688 init_maxsockets
, NULL
);