4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
26 #include <sys/types.h>
27 #include <sys/stream.h>
28 #include <sys/strsubr.h>
29 #include <sys/stropts.h>
30 #include <sys/strsun.h>
31 #define _SUN_TPI_VERSION 2
32 #include <sys/tihdr.h>
34 #include <sys/sunddi.h>
35 #include <sys/xti_inet.h>
36 #include <sys/cmn_err.h>
37 #include <sys/debug.h>
38 #include <sys/vtrace.h>
40 #include <sys/cpuvar.h>
41 #include <sys/random.h>
43 #include <sys/sunldi.h>
45 #include <sys/errno.h>
46 #include <sys/signal.h>
47 #include <sys/socket.h>
48 #include <sys/isa_defs.h>
49 #include <netinet/in.h>
50 #include <netinet/tcp.h>
51 #include <netinet/ip6.h>
52 #include <netinet/icmp6.h>
53 #include <netinet/sctp.h>
56 #include <inet/common.h>
58 #include <inet/ip_if.h>
59 #include <inet/ip_ire.h>
62 #include <inet/mib2.h>
63 #include <inet/kstatcom.h>
64 #include <inet/optcom.h>
65 #include <inet/ipclassifier.h>
66 #include <inet/ipsec_impl.h>
67 #include <inet/sctp_ip.h>
68 #include <inet/sctp_crc32.h>
70 #include <inet/sctp/sctp_impl.h>
71 #include <inet/sctp/sctp_addr.h>
72 #include <inet/sctp/sctp_asconf.h>
75 sin6_t sctp_sin6_null
; /* Zero address for quick clears */
77 static void sctp_closei_local(sctp_t
*sctp
);
78 static int sctp_init_values(sctp_t
*, sctp_t
*, int);
79 static void sctp_icmp_error_ipv6(sctp_t
*sctp
, mblk_t
*mp
);
80 static void sctp_process_recvq(void *);
81 static void sctp_rq_tq_init(sctp_stack_t
*);
82 static void sctp_rq_tq_fini(sctp_stack_t
*);
83 static void sctp_conn_cache_init();
84 static void sctp_conn_cache_fini();
85 static int sctp_conn_cache_constructor();
86 static void sctp_conn_cache_destructor();
87 static void sctp_conn_clear(conn_t
*);
88 static void sctp_notify(void *, ip_xmit_attr_t
*, ixa_notify_type_t
,
91 static void *sctp_stack_init(netstackid_t stackid
, netstack_t
*ns
);
92 static void sctp_stack_fini(netstackid_t stackid
, void *arg
);
95 * SCTP receive queue taskq
97 * At SCTP initialization time, a default taskq is created for
98 * servicing packets received when the interrupt thread cannot
99 * get a hold on the sctp_t. The number of taskq can be increased in
100 * sctp_find_next_tq() when an existing taskq cannot be dispatched.
101 * The taskqs are never removed. But the max number of taskq which
102 * can be created is controlled by sctp_recvq_tq_list_max_sz. Note
103 * that SCTP recvq taskq is not tied to any specific CPU or ill.
105 * Those taskqs are stored in an array recvq_tq_list. And they are
106 * used in a round robin fashion. The current taskq being used is
107 * determined by recvq_tq_list_cur.
110 /* /etc/system variables */
111 /* The minimum number of threads for each taskq. */
112 int sctp_recvq_tq_thr_min
= 4;
113 /* The maximum number of threads for each taskq. */
114 int sctp_recvq_tq_thr_max
= 48;
115 /* The mnimum number of tasks for each taskq. */
116 int sctp_recvq_tq_task_min
= 8;
117 /* Default value of sctp_recvq_tq_list_max_sz. */
118 int sctp_recvq_tq_list_max
= 16;
121 * SCTP tunables related declarations. Definitions are in sctp_tunables.c
123 extern mod_prop_info_t sctp_propinfo_tbl
[];
124 extern int sctp_propinfo_count
;
126 /* sctp_t/conn_t kmem cache */
127 struct kmem_cache
*sctp_conn_cache
;
129 #define SCTP_CONDEMNED(sctp) \
130 mutex_enter(&(sctp)->sctp_reflock); \
131 ((sctp)->sctp_condemned = B_TRUE); \
132 mutex_exit(&(sctp)->sctp_reflock);
134 /* Link/unlink a sctp_t to/from the global list. */
135 #define SCTP_LINK(sctp, sctps) \
136 mutex_enter(&(sctps)->sctps_g_lock); \
137 list_insert_tail(&sctps->sctps_g_list, (sctp)); \
138 mutex_exit(&(sctps)->sctps_g_lock);
140 #define SCTP_UNLINK(sctp, sctps) \
141 mutex_enter(&(sctps)->sctps_g_lock); \
142 ASSERT((sctp)->sctp_condemned); \
143 list_remove(&(sctps)->sctps_g_list, (sctp)); \
144 mutex_exit(&(sctps)->sctps_g_lock);
147 * Hooks for Sun Cluster. On non-clustered nodes these will remain NULL.
150 void (*cl_sctp_listen
)(sa_family_t
, uchar_t
*, uint_t
, in_port_t
) = NULL
;
151 void (*cl_sctp_unlisten
)(sa_family_t
, uchar_t
*, uint_t
, in_port_t
) = NULL
;
152 void (*cl_sctp_connect
)(sa_family_t
, uchar_t
*, uint_t
, in_port_t
,
153 uchar_t
*, uint_t
, in_port_t
, boolean_t
, cl_sctp_handle_t
) = NULL
;
154 void (*cl_sctp_disconnect
)(sa_family_t
, cl_sctp_handle_t
) = NULL
;
155 void (*cl_sctp_assoc_change
)(sa_family_t
, uchar_t
*, size_t, uint_t
,
156 uchar_t
*, size_t, uint_t
, int, cl_sctp_handle_t
) = NULL
;
157 void (*cl_sctp_check_addrs
)(sa_family_t
, in_port_t
, uchar_t
**, size_t,
158 uint_t
*, boolean_t
) = NULL
;
160 * Return the version number of the SCTP kernel interface.
163 sctp_itf_ver(int cl_ver
)
165 if (cl_ver
!= SCTP_ITF_VER
)
167 return (SCTP_ITF_VER
);
171 * Called when we need a new sctp instantiation but don't really have a
172 * new q to hang it off of. Copy the priv flag from the passed in structure.
175 sctp_create_eager(sctp_t
*psctp
)
178 mblk_t
*ack_mp
, *hb_mp
;
181 sctp_stack_t
*sctps
= psctp
->sctp_sctps
;
183 if ((connp
= ipcl_conn_create(IPCL_SCTPCONN
, KM_NOSLEEP
,
184 sctps
->sctps_netstack
)) == NULL
) {
188 sctp
= CONN2SCTP(connp
);
189 sctp
->sctp_sctps
= sctps
;
191 if ((ack_mp
= sctp_timer_alloc(sctp
, sctp_ack_timer
,
192 KM_NOSLEEP
)) == NULL
||
193 (hb_mp
= sctp_timer_alloc(sctp
, sctp_heartbeat_timer
,
194 KM_NOSLEEP
)) == NULL
) {
197 sctp_conn_clear(connp
);
198 sctp
->sctp_sctps
= NULL
;
199 kmem_cache_free(sctp_conn_cache
, connp
);
203 sctp
->sctp_ack_mp
= ack_mp
;
204 sctp
->sctp_heartbeat_mp
= hb_mp
;
206 if (sctp_init_values(sctp
, psctp
, KM_NOSLEEP
) != 0) {
209 sctp_conn_clear(connp
);
210 sctp
->sctp_sctps
= NULL
;
211 kmem_cache_free(sctp_conn_cache
, connp
);
215 if ((credp
= psctp
->sctp_connp
->conn_cred
) != NULL
) {
216 connp
->conn_cred
= credp
;
220 sctp
->sctp_mss
= psctp
->sctp_mss
;
221 sctp
->sctp_detached
= B_TRUE
;
223 * Link to the global as soon as possible so that this sctp_t
226 SCTP_LINK(sctp
, sctps
);
228 /* If the listener has a limit, inherit the counter info. */
229 sctp
->sctp_listen_cnt
= psctp
->sctp_listen_cnt
;
235 * We are dying for some reason. Try to do it gracefully.
238 sctp_clean_death(sctp_t
*sctp
, int err
)
240 ASSERT(sctp
!= NULL
);
242 dprint(3, ("sctp_clean_death %p, state %d\n", (void *)sctp
,
245 sctp
->sctp_client_errno
= err
;
247 * Check to see if we need to notify upper layer.
249 if ((sctp
->sctp_state
>= SCTPS_COOKIE_WAIT
) &&
250 !SCTP_IS_DETACHED(sctp
)) {
251 if (sctp
->sctp_xmit_head
|| sctp
->sctp_xmit_unsent
) {
252 sctp_regift_xmitlist(sctp
);
254 if (sctp
->sctp_ulp_disconnected(sctp
->sctp_ulpd
, 0, err
)) {
256 * Socket is gone, detach.
258 sctp
->sctp_detached
= B_TRUE
;
259 sctp
->sctp_ulpd
= NULL
;
260 sctp
->sctp_upcalls
= NULL
;
264 /* Remove this sctp from all hashes. */
265 sctp_closei_local(sctp
);
268 * If the sctp_t is detached, we need to finish freeing up
269 * the resources. At this point, ip_fanout_sctp() should have
270 * a hold on this sctp_t. Some thread doing snmp stuff can
271 * have a hold. And a taskq can also have a hold waiting to
272 * work. sctp_unlink() the sctp_t from the global list so
273 * that no new thread can find it. Then do a SCTP_REFRELE().
274 * The sctp_t will be freed after all those threads are done.
276 if (SCTP_IS_DETACHED(sctp
)) {
277 SCTP_CONDEMNED(sctp
);
283 * Called by upper layer when it wants to close this association.
284 * Depending on the state of this assoication, we need to do
287 * If the state is below COOKIE_ECHOED or it is COOKIE_ECHOED but with
288 * no sent data, just remove this sctp from all the hashes. This
289 * makes sure that all packets from the other end will go to the default
290 * sctp handling. The upper layer will then do a sctp_close() to clean
293 * Otherwise, check and see if SO_LINGER is set. If it is set, check
294 * the value. If the value is 0, consider this an abortive close. Send
295 * an ABORT message and kill the associatiion.
299 sctp_disconnect(sctp_t
*sctp
)
302 conn_t
*connp
= sctp
->sctp_connp
;
304 dprint(3, ("sctp_disconnect %p, state %d\n", (void *)sctp
,
309 switch (sctp
->sctp_state
) {
314 case SCTPS_COOKIE_WAIT
:
315 case SCTPS_COOKIE_ECHOED
:
317 * Close during the connect 3-way handshake
318 * but here there may or may not be pending data
319 * already on queue. Process almost same as in
320 * the ESTABLISHED state.
322 if (sctp
->sctp_xmit_head
== NULL
&&
323 sctp
->sctp_xmit_unsent
== NULL
) {
329 * If SO_LINGER has set a zero linger time, terminate the
330 * association and send an ABORT.
332 if (connp
->conn_linger
&& connp
->conn_lingertime
== 0) {
333 sctp_user_abort(sctp
, NULL
);
339 * If there is unread data, send an ABORT and terminate the
342 if (sctp
->sctp_rxqueued
> 0 || sctp
->sctp_ulp_rxqueued
> 0) {
343 sctp_user_abort(sctp
, NULL
);
348 * Transmit the shutdown before detaching the sctp_t.
349 * After sctp_detach returns this queue/perimeter
350 * no longer owns the sctp_t thus others can modify it.
352 sctp_send_shutdown(sctp
, 0);
354 /* Pass gathered wisdom to IP for keeping */
355 sctp_update_dce(sctp
);
358 * If lingering on close then wait until the shutdown
359 * is complete, or the SO_LINGER time passes, or an
360 * ABORT is sent/received. Note that sctp_disconnect()
361 * can be called more than once. Make sure that only
364 if (connp
->conn_linger
&& connp
->conn_lingertime
> 0 &&
365 sctp
->sctp_state
>= SCTPS_ESTABLISHED
&&
366 !sctp
->sctp_lingering
) {
367 clock_t stoptime
; /* in ticks */
370 sctp
->sctp_lingering
= 1;
371 sctp
->sctp_client_errno
= 0;
372 stoptime
= ddi_get_lbolt() +
373 connp
->conn_lingertime
* hz
;
375 mutex_enter(&sctp
->sctp_lock
);
376 sctp
->sctp_running
= B_FALSE
;
377 while (sctp
->sctp_state
>= SCTPS_ESTABLISHED
&&
378 sctp
->sctp_client_errno
== 0) {
379 cv_signal(&sctp
->sctp_cv
);
380 ret
= cv_timedwait_sig(&sctp
->sctp_cv
,
381 &sctp
->sctp_lock
, stoptime
);
383 /* Stoptime has reached. */
384 sctp
->sctp_client_errno
= EWOULDBLOCK
;
386 } else if (ret
== 0) {
391 error
= sctp
->sctp_client_errno
;
392 sctp
->sctp_client_errno
= 0;
393 mutex_exit(&sctp
->sctp_lock
);
401 /* Remove this sctp from all hashes so nobody can find it. */
402 sctp_closei_local(sctp
);
408 sctp_close(sctp_t
*sctp
)
410 dprint(3, ("sctp_close %p, state %d\n", (void *)sctp
,
414 sctp
->sctp_detached
= 1;
415 sctp
->sctp_ulpd
= NULL
;
416 sctp
->sctp_upcalls
= NULL
;
417 bzero(&sctp
->sctp_events
, sizeof (sctp
->sctp_events
));
419 /* If the graceful shutdown has not been completed, just return. */
420 if (sctp
->sctp_state
!= SCTPS_IDLE
) {
426 * Since sctp_t is in SCTPS_IDLE state, so the only thread which
427 * can have a hold on the sctp_t is doing snmp stuff. Just do
428 * a SCTP_REFRELE() here after the SCTP_UNLINK(). It will
429 * be freed when the other thread is done.
431 SCTP_CONDEMNED(sctp
);
437 * Unlink from global list and do the eager close.
438 * Remove the refhold implicit in being on the global list.
441 sctp_close_eager(sctp_t
*sctp
)
443 SCTP_CONDEMNED(sctp
);
444 sctp_closei_local(sctp
);
449 * The sctp_t is going away. Remove it from all lists and set it
450 * to SCTPS_IDLE. The caller has to remove it from the
451 * global list. The freeing up of memory is deferred until
452 * sctp_free(). This is needed since a thread in sctp_input() might have
453 * done a SCTP_REFHOLD on this structure before it was removed from the
457 sctp_closei_local(sctp_t
*sctp
)
460 conn_t
*connp
= sctp
->sctp_connp
;
462 /* The counter is incremented only for established associations. */
463 if (sctp
->sctp_state
>= SCTPS_ESTABLISHED
)
464 SCTPS_ASSOC_DEC(sctp
->sctp_sctps
);
466 if (sctp
->sctp_listen_cnt
!= NULL
)
467 SCTP_DECR_LISTEN_CNT(sctp
);
469 /* Sanity check, don't do the same thing twice. */
470 if (connp
->conn_state_flags
& CONN_CLOSING
) {
471 ASSERT(sctp
->sctp_state
== SCTPS_IDLE
);
475 /* Stop and free the timers */
476 sctp_free_faddr_timers(sctp
);
477 if ((mp
= sctp
->sctp_heartbeat_mp
) != NULL
) {
479 sctp
->sctp_heartbeat_mp
= NULL
;
481 if ((mp
= sctp
->sctp_ack_mp
) != NULL
) {
483 sctp
->sctp_ack_mp
= NULL
;
486 /* Set the CONN_CLOSING flag so that IP will not cache IRE again. */
487 mutex_enter(&connp
->conn_lock
);
488 connp
->conn_state_flags
|= CONN_CLOSING
;
489 mutex_exit(&connp
->conn_lock
);
491 /* Remove from all hashes. */
492 sctp_bind_hash_remove(sctp
);
493 sctp_conn_hash_remove(sctp
);
494 sctp_listen_hash_remove(sctp
);
495 sctp
->sctp_state
= SCTPS_IDLE
;
498 * Clean up the recvq as much as possible. All those packets
499 * will be silently dropped as this sctp_t is now in idle state.
501 mutex_enter(&sctp
->sctp_recvq_lock
);
502 while ((mp
= sctp
->sctp_recvq
) != NULL
) {
503 sctp
->sctp_recvq
= mp
->b_next
;
506 if (ip_recv_attr_is_mblk(mp
))
507 mp
= ip_recv_attr_free_mblk(mp
);
511 mutex_exit(&sctp
->sctp_recvq_lock
);
515 * Free memory associated with the sctp/ip header template.
518 sctp_headers_free(sctp_t
*sctp
)
520 if (sctp
->sctp_iphc
!= NULL
) {
521 kmem_free(sctp
->sctp_iphc
, sctp
->sctp_iphc_len
);
522 sctp
->sctp_iphc
= NULL
;
523 sctp
->sctp_ipha
= NULL
;
524 sctp
->sctp_hdr_len
= 0;
525 sctp
->sctp_ip_hdr_len
= 0;
526 sctp
->sctp_iphc_len
= 0;
527 sctp
->sctp_sctph
= NULL
;
528 sctp
->sctp_hdr_len
= 0;
530 if (sctp
->sctp_iphc6
!= NULL
) {
531 kmem_free(sctp
->sctp_iphc6
, sctp
->sctp_iphc6_len
);
532 sctp
->sctp_iphc6
= NULL
;
533 sctp
->sctp_ip6h
= NULL
;
534 sctp
->sctp_hdr6_len
= 0;
535 sctp
->sctp_ip_hdr6_len
= 0;
536 sctp
->sctp_iphc6_len
= 0;
537 sctp
->sctp_sctph6
= NULL
;
538 sctp
->sctp_hdr6_len
= 0;
543 sctp_free_xmit_data(sctp_t
*sctp
)
550 sctp
->sctp_xmit_unacked
= NULL
;
551 ump
= sctp
->sctp_xmit_head
;
552 sctp
->sctp_xmit_tail
= sctp
->sctp_xmit_head
= NULL
;
554 for (; ump
!= NULL
; ump
= nump
) {
555 for (mp
= ump
->b_cont
; mp
!= NULL
; mp
= nmp
) {
561 ASSERT(DB_REF(ump
) == 1);
568 if ((ump
= sctp
->sctp_xmit_unsent
) == NULL
) {
569 ASSERT(sctp
->sctp_xmit_unsent_tail
== NULL
);
572 sctp
->sctp_xmit_unsent
= sctp
->sctp_xmit_unsent_tail
= NULL
;
577 * Cleanup all the messages in the stream queue and the reassembly lists.
578 * If 'free' is true, then delete the streams as well.
581 sctp_instream_cleanup(sctp_t
*sctp
, boolean_t free
)
587 if (sctp
->sctp_instr
!= NULL
) {
588 /* walk thru and flush out anything remaining in the Q */
589 for (i
= 0; i
< sctp
->sctp_num_istr
; i
++) {
590 mp
= sctp
->sctp_instr
[i
].istr_msgs
;
593 mp
->b_next
= mp
->b_prev
= NULL
;
597 sctp
->sctp_instr
[i
].istr_msgs
= NULL
;
598 sctp
->sctp_instr
[i
].istr_nmsgs
= 0;
599 sctp_free_reass((sctp
->sctp_instr
) + i
);
600 sctp
->sctp_instr
[i
].nextseq
= 0;
603 kmem_free(sctp
->sctp_instr
,
604 sizeof (*sctp
->sctp_instr
) * sctp
->sctp_num_istr
);
605 sctp
->sctp_instr
= NULL
;
606 sctp
->sctp_num_istr
= 0;
609 /* un-ordered fragments */
610 if (sctp
->sctp_uo_frags
!= NULL
) {
611 for (mp
= sctp
->sctp_uo_frags
; mp
!= NULL
; mp
= mp1
) {
613 mp
->b_next
= mp
->b_prev
= NULL
;
616 sctp
->sctp_uo_frags
= NULL
;
621 * Last reference to the sctp_t is gone. Free all memory associated with it.
622 * Called from SCTP_REFRELE. Called inline in sctp_close()
625 sctp_free(conn_t
*connp
)
627 sctp_t
*sctp
= CONN2SCTP(connp
);
629 sctp_stack_t
*sctps
= sctp
->sctp_sctps
;
631 ASSERT(sctps
!= NULL
);
632 /* Unlink it from the global list */
633 SCTP_UNLINK(sctp
, sctps
);
635 ASSERT(connp
->conn_ref
== 0);
636 ASSERT(connp
->conn_proto
== IPPROTO_SCTP
);
637 ASSERT(!MUTEX_HELD(&sctp
->sctp_reflock
));
638 ASSERT(sctp
->sctp_refcnt
== 0);
640 ASSERT(sctp
->sctp_ptpbhn
== NULL
&& sctp
->sctp_bind_hash
== NULL
);
641 ASSERT(sctp
->sctp_conn_hash_next
== NULL
&&
642 sctp
->sctp_conn_hash_prev
== NULL
);
645 /* Free up all the resources. */
647 /* blow away sctp stream management */
648 if (sctp
->sctp_ostrcntrs
!= NULL
) {
649 kmem_free(sctp
->sctp_ostrcntrs
,
650 sizeof (uint16_t) * sctp
->sctp_num_ostr
);
651 sctp
->sctp_ostrcntrs
= NULL
;
653 sctp_instream_cleanup(sctp
, B_TRUE
);
655 /* Remove all data transfer resources. */
656 sctp
->sctp_istr_nmsgs
= 0;
657 sctp
->sctp_rxqueued
= 0;
658 sctp_free_xmit_data(sctp
);
659 sctp
->sctp_unacked
= 0;
660 sctp
->sctp_unsent
= 0;
661 if (sctp
->sctp_cxmit_list
!= NULL
)
662 sctp_asconf_free_cxmit(sctp
, NULL
);
664 sctp
->sctp_lastdata
= NULL
;
666 /* Clear out default xmit settings */
667 sctp
->sctp_def_stream
= 0;
668 sctp
->sctp_def_flags
= 0;
669 sctp
->sctp_def_ppid
= 0;
670 sctp
->sctp_def_context
= 0;
671 sctp
->sctp_def_timetolive
= 0;
673 if (sctp
->sctp_sack_info
!= NULL
) {
674 sctp_free_set(sctp
->sctp_sack_info
);
675 sctp
->sctp_sack_info
= NULL
;
677 sctp
->sctp_sack_gaps
= 0;
679 if (sctp
->sctp_cookie_mp
!= NULL
) {
680 freemsg(sctp
->sctp_cookie_mp
);
681 sctp
->sctp_cookie_mp
= NULL
;
684 /* Remove all the address resources. */
685 sctp_zap_addrs(sctp
);
686 for (cnt
= 0; cnt
< SCTP_IPIF_HASH
; cnt
++) {
687 ASSERT(sctp
->sctp_saddrs
[cnt
].ipif_count
== 0);
688 list_destroy(&sctp
->sctp_saddrs
[cnt
].sctp_ipif_list
);
691 if (sctp
->sctp_hopopts
!= NULL
) {
692 mi_free(sctp
->sctp_hopopts
);
693 sctp
->sctp_hopopts
= NULL
;
694 sctp
->sctp_hopoptslen
= 0;
696 ASSERT(sctp
->sctp_hopoptslen
== 0);
697 if (sctp
->sctp_dstopts
!= NULL
) {
698 mi_free(sctp
->sctp_dstopts
);
699 sctp
->sctp_dstopts
= NULL
;
700 sctp
->sctp_dstoptslen
= 0;
702 ASSERT(sctp
->sctp_dstoptslen
== 0);
703 if (sctp
->sctp_rthdrdstopts
!= NULL
) {
704 mi_free(sctp
->sctp_rthdrdstopts
);
705 sctp
->sctp_rthdrdstopts
= NULL
;
706 sctp
->sctp_rthdrdstoptslen
= 0;
708 ASSERT(sctp
->sctp_rthdrdstoptslen
== 0);
709 if (sctp
->sctp_rthdr
!= NULL
) {
710 mi_free(sctp
->sctp_rthdr
);
711 sctp
->sctp_rthdr
= NULL
;
712 sctp
->sctp_rthdrlen
= 0;
714 ASSERT(sctp
->sctp_rthdrlen
== 0);
715 sctp_headers_free(sctp
);
717 sctp
->sctp_shutdown_faddr
= NULL
;
719 if (sctp
->sctp_err_chunks
!= NULL
) {
720 freemsg(sctp
->sctp_err_chunks
);
721 sctp
->sctp_err_chunks
= NULL
;
722 sctp
->sctp_err_len
= 0;
725 /* Clear all the bitfields. */
726 bzero(&sctp
->sctp_bits
, sizeof (sctp
->sctp_bits
));
728 /* It is time to update the global statistics. */
729 SCTPS_UPDATE_MIB(sctps
, sctpOutSCTPPkts
, sctp
->sctp_opkts
);
730 SCTPS_UPDATE_MIB(sctps
, sctpOutCtrlChunks
, sctp
->sctp_obchunks
);
731 SCTPS_UPDATE_MIB(sctps
, sctpOutOrderChunks
, sctp
->sctp_odchunks
);
732 SCTPS_UPDATE_MIB(sctps
, sctpOutUnorderChunks
, sctp
->sctp_oudchunks
);
733 SCTPS_UPDATE_MIB(sctps
, sctpRetransChunks
, sctp
->sctp_rxtchunks
);
734 SCTPS_UPDATE_MIB(sctps
, sctpInSCTPPkts
, sctp
->sctp_ipkts
);
735 SCTPS_UPDATE_MIB(sctps
, sctpInCtrlChunks
, sctp
->sctp_ibchunks
);
736 SCTPS_UPDATE_MIB(sctps
, sctpInOrderChunks
, sctp
->sctp_idchunks
);
737 SCTPS_UPDATE_MIB(sctps
, sctpInUnorderChunks
, sctp
->sctp_iudchunks
);
738 SCTPS_UPDATE_MIB(sctps
, sctpFragUsrMsgs
, sctp
->sctp_fragdmsgs
);
739 SCTPS_UPDATE_MIB(sctps
, sctpReasmUsrMsgs
, sctp
->sctp_reassmsgs
);
740 sctp
->sctp_opkts
= 0;
741 sctp
->sctp_obchunks
= 0;
742 sctp
->sctp_odchunks
= 0;
743 sctp
->sctp_oudchunks
= 0;
744 sctp
->sctp_rxtchunks
= 0;
745 sctp
->sctp_ipkts
= 0;
746 sctp
->sctp_ibchunks
= 0;
747 sctp
->sctp_idchunks
= 0;
748 sctp
->sctp_iudchunks
= 0;
749 sctp
->sctp_fragdmsgs
= 0;
750 sctp
->sctp_reassmsgs
= 0;
751 sctp
->sctp_outseqtsns
= 0;
752 sctp
->sctp_osacks
= 0;
753 sctp
->sctp_isacks
= 0;
754 sctp
->sctp_idupchunks
= 0;
755 sctp
->sctp_gapcnt
= 0;
756 sctp
->sctp_cum_obchunks
= 0;
757 sctp
->sctp_cum_odchunks
= 0;
758 sctp
->sctp_cum_oudchunks
= 0;
759 sctp
->sctp_cum_rxtchunks
= 0;
760 sctp
->sctp_cum_ibchunks
= 0;
761 sctp
->sctp_cum_idchunks
= 0;
762 sctp
->sctp_cum_iudchunks
= 0;
764 sctp
->sctp_autoclose
= 0;
765 sctp
->sctp_tx_adaptation_code
= 0;
767 sctp
->sctp_sctps
= NULL
;
769 sctp_conn_clear(connp
);
770 kmem_cache_free(sctp_conn_cache
, connp
);
774 * Initialize protocol control block. If a parent exists, inherit
775 * all values set through setsockopt().
778 sctp_init_values(sctp_t
*sctp
, sctp_t
*psctp
, int sleep
)
782 sctp_stack_t
*sctps
= sctp
->sctp_sctps
;
785 connp
= sctp
->sctp_connp
;
787 sctp
->sctp_nsaddrs
= 0;
788 for (cnt
= 0; cnt
< SCTP_IPIF_HASH
; cnt
++) {
789 sctp
->sctp_saddrs
[cnt
].ipif_count
= 0;
790 list_create(&sctp
->sctp_saddrs
[cnt
].sctp_ipif_list
,
791 sizeof (sctp_saddr_ipif_t
), offsetof(sctp_saddr_ipif_t
,
794 connp
->conn_ports
= 0;
795 sctp
->sctp_running
= B_FALSE
;
796 sctp
->sctp_state
= SCTPS_IDLE
;
798 sctp
->sctp_refcnt
= 1;
800 sctp
->sctp_strikes
= 0;
802 sctp
->sctp_last_mtu_probe
= ddi_get_lbolt64();
803 sctp
->sctp_mtu_probe_intvl
= sctps
->sctps_mtu_probe_interval
;
805 sctp
->sctp_sack_gaps
= 0;
806 /* So we will not delay sending the first SACK. */
807 sctp
->sctp_sack_toggle
= sctps
->sctps_deferred_acks_max
;
809 /* Only need to do the allocation if there is no "cached" one. */
810 if (sctp
->sctp_pad_mp
== NULL
) {
811 if (sleep
== KM_SLEEP
) {
812 sctp
->sctp_pad_mp
= allocb_wait(SCTP_ALIGN
, BPRI_MED
,
815 sctp
->sctp_pad_mp
= allocb(SCTP_ALIGN
, BPRI_MED
);
816 if (sctp
->sctp_pad_mp
== NULL
)
819 bzero(sctp
->sctp_pad_mp
->b_rptr
, SCTP_ALIGN
);
824 * Inherit from parent
826 * Start by inheriting from the conn_t, including conn_ixa and
829 err
= conn_inherit_parent(psctp
->sctp_connp
, connp
);
833 sctp
->sctp_upcalls
= psctp
->sctp_upcalls
;
835 sctp
->sctp_cookie_lifetime
= psctp
->sctp_cookie_lifetime
;
837 sctp
->sctp_cwnd_max
= psctp
->sctp_cwnd_max
;
838 sctp
->sctp_rwnd
= psctp
->sctp_rwnd
;
839 sctp
->sctp_arwnd
= psctp
->sctp_arwnd
;
840 sctp
->sctp_pd_point
= psctp
->sctp_pd_point
;
841 sctp
->sctp_rto_max
= psctp
->sctp_rto_max
;
842 sctp
->sctp_rto_max_init
= psctp
->sctp_rto_max_init
;
843 sctp
->sctp_rto_min
= psctp
->sctp_rto_min
;
844 sctp
->sctp_rto_initial
= psctp
->sctp_rto_initial
;
845 sctp
->sctp_pa_max_rxt
= psctp
->sctp_pa_max_rxt
;
846 sctp
->sctp_pp_max_rxt
= psctp
->sctp_pp_max_rxt
;
847 sctp
->sctp_max_init_rxt
= psctp
->sctp_max_init_rxt
;
849 sctp
->sctp_def_stream
= psctp
->sctp_def_stream
;
850 sctp
->sctp_def_flags
= psctp
->sctp_def_flags
;
851 sctp
->sctp_def_ppid
= psctp
->sctp_def_ppid
;
852 sctp
->sctp_def_context
= psctp
->sctp_def_context
;
853 sctp
->sctp_def_timetolive
= psctp
->sctp_def_timetolive
;
855 sctp
->sctp_num_istr
= psctp
->sctp_num_istr
;
856 sctp
->sctp_num_ostr
= psctp
->sctp_num_ostr
;
858 sctp
->sctp_hb_interval
= psctp
->sctp_hb_interval
;
859 sctp
->sctp_autoclose
= psctp
->sctp_autoclose
;
860 sctp
->sctp_tx_adaptation_code
= psctp
->sctp_tx_adaptation_code
;
862 /* xxx should be a better way to copy these flags xxx */
863 sctp
->sctp_bound_to_all
= psctp
->sctp_bound_to_all
;
864 sctp
->sctp_cansleep
= psctp
->sctp_cansleep
;
865 sctp
->sctp_send_adaptation
= psctp
->sctp_send_adaptation
;
866 sctp
->sctp_ndelay
= psctp
->sctp_ndelay
;
867 sctp
->sctp_events
= psctp
->sctp_events
;
870 * Set to system defaults
872 sctp
->sctp_cookie_lifetime
=
873 MSEC_TO_TICK(sctps
->sctps_cookie_life
);
874 connp
->conn_sndlowat
= sctps
->sctps_xmit_lowat
;
875 connp
->conn_sndbuf
= sctps
->sctps_xmit_hiwat
;
876 connp
->conn_rcvbuf
= sctps
->sctps_recv_hiwat
;
878 sctp
->sctp_cwnd_max
= sctps
->sctps_cwnd_max_
;
879 sctp
->sctp_rwnd
= connp
->conn_rcvbuf
;
880 sctp
->sctp_arwnd
= connp
->conn_rcvbuf
;
881 sctp
->sctp_pd_point
= sctp
->sctp_rwnd
;
882 sctp
->sctp_rto_max
= MSEC_TO_TICK(sctps
->sctps_rto_maxg
);
883 sctp
->sctp_rto_max_init
= sctp
->sctp_rto_max
;
884 sctp
->sctp_rto_min
= MSEC_TO_TICK(sctps
->sctps_rto_ming
);
885 sctp
->sctp_rto_initial
= MSEC_TO_TICK(
886 sctps
->sctps_rto_initialg
);
887 sctp
->sctp_pa_max_rxt
= sctps
->sctps_pa_max_retr
;
888 sctp
->sctp_pp_max_rxt
= sctps
->sctps_pp_max_retr
;
889 sctp
->sctp_max_init_rxt
= sctps
->sctps_max_init_retr
;
891 sctp
->sctp_num_istr
= sctps
->sctps_max_in_streams
;
892 sctp
->sctp_num_ostr
= sctps
->sctps_initial_out_streams
;
894 sctp
->sctp_hb_interval
=
895 MSEC_TO_TICK(sctps
->sctps_heartbeat_interval
);
897 if (connp
->conn_family
== AF_INET
)
898 connp
->conn_default_ttl
= sctps
->sctps_ipv4_ttl
;
900 connp
->conn_default_ttl
= sctps
->sctps_ipv6_hoplimit
;
902 connp
->conn_xmit_ipp
.ipp_unicast_hops
=
903 connp
->conn_default_ttl
;
906 * Initialize the header template
908 if ((err
= sctp_build_hdrs(sctp
, sleep
)) != 0) {
913 sctp
->sctp_understands_asconf
= B_TRUE
;
914 sctp
->sctp_understands_addip
= B_TRUE
;
915 sctp
->sctp_prsctp_aware
= B_FALSE
;
917 sctp
->sctp_connp
->conn_ref
= 1;
919 sctp
->sctp_prsctpdrop
= 0;
920 sctp
->sctp_msgcount
= 0;
925 sctp_headers_free(sctp
);
930 * Extracts the init tag from an INIT chunk and checks if it matches
931 * the sctp's verification tag. Returns 0 if it doesn't match, 1 if
935 sctp_icmp_verf(sctp_t
*sctp
, sctp_hdr_t
*sh
, mblk_t
*mp
)
937 sctp_chunk_hdr_t
*sch
;
940 sch
= (sctp_chunk_hdr_t
*)(sh
+ 1);
941 vp
= (uint32_t *)(sch
+ 1);
943 /* Need at least the data chunk hdr and the first 4 bytes of INIT */
944 if ((unsigned char *)(vp
+ 1) > mp
->b_wptr
) {
948 bcopy(vp
, &verf
, sizeof (verf
));
950 if (verf
== sctp
->sctp_lvtag
) {
957 * Update the SCTP state according to change of PMTU.
959 * Path MTU might have changed by either increase or decrease, so need to
960 * adjust the MSS based on the value of ixa_pmtu.
963 sctp_update_pmtu(sctp_t
*sctp
, sctp_faddr_t
*fp
, boolean_t decrease_only
)
967 ip_xmit_attr_t
*ixa
= fp
->sf_ixa
;
969 if (sctp
->sctp_state
< SCTPS_ESTABLISHED
)
973 * Always call ip_get_pmtu() to make sure that IP has updated
974 * ixa_flags properly.
976 pmtu
= ip_get_pmtu(ixa
);
979 * Calculate the MSS by decreasing the PMTU by sctp_hdr_len and
980 * IPsec overhead if applied. Make sure to use the most recent
983 mss
= pmtu
- conn_ipsec_length(sctp
->sctp_connp
);
984 if (ixa
->ixa_flags
& IXAF_IS_IPV4
)
985 mss
-= sctp
->sctp_hdr_len
;
987 mss
-= sctp
->sctp_hdr6_len
;
990 * Nothing to change, so just return.
992 if (mss
== fp
->sf_pmss
)
996 * Currently, for ICMP errors, only PMTU decrease is handled.
998 if (mss
> fp
->sf_pmss
&& decrease_only
)
1002 (void) printf("sctp_update_pmtu mss from %d to %d\n",
1005 DTRACE_PROBE2(sctp_update_pmtu
, int32_t, fp
->sf_pmss
, uint32_t, mss
);
1008 * Update ixa_fragsize and ixa_pmtu.
1010 ixa
->ixa_fragsize
= ixa
->ixa_pmtu
= pmtu
;
1013 * Make sure that sfa_pmss is a multiple of
1016 fp
->sf_pmss
= mss
& ~(SCTP_ALIGN
- 1);
1017 fp
->sf_pmtu_discovered
= 1;
1020 if (mss
< sctp
->sctp_sctps
->sctps_mss_min
)
1021 ixa
->ixa_flags
|= IXAF_PMTU_TOO_SMALL
;
1023 if (ixa
->ixa_flags
& IXAF_PMTU_TOO_SMALL
)
1024 ixa
->ixa_flags
&= ~(IXAF_DONTFRAG
| IXAF_PMTU_IPV4_DF
);
1027 * If below the min size then ip_get_pmtu cleared IXAF_PMTU_IPV4_DF.
1028 * Make sure to clear IXAF_DONTFRAG, which is used by IP to decide
1029 * whether to fragment the packet.
1031 if (ixa
->ixa_flags
& IXAF_IS_IPV4
) {
1032 if (!(ixa
->ixa_flags
& IXAF_PMTU_IPV4_DF
)) {
1033 fp
->sf_df
= B_FALSE
;
1034 if (fp
== sctp
->sctp_current
) {
1036 ipha_fragment_offset_and_flags
= 0;
1043 * Notify function registered with ip_xmit_attr_t. It's called in the context
1044 * of conn_ip_output so it's safe to update the SCTP state.
1045 * Currently only used for pmtu changes.
1049 sctp_notify(void *arg
, ip_xmit_attr_t
*ixa
, ixa_notify_type_t ntype
,
1050 ixa_notify_arg_t narg
)
1052 sctp_t
*sctp
= (sctp_t
*)arg
;
1057 /* Find the faddr based on the ip_xmit_attr_t pointer */
1058 for (fp
= sctp
->sctp_faddrs
; fp
!= NULL
; fp
= fp
->sf_next
) {
1059 if (fp
->sf_ixa
== ixa
)
1063 sctp_update_pmtu(sctp
, fp
, B_FALSE
);
1071 * sctp_icmp_error is called by sctp_input() to process ICMP error messages
1072 * passed up by IP. We need to find a sctp_t
1073 * that corresponds to the returned datagram. Passes the message back in on
1074 * the correct queue once it has located the connection.
1075 * Assumes that IP has pulled up everything up to and including
1079 sctp_icmp_error(sctp_t
*sctp
, mblk_t
*mp
)
1087 sctp_stack_t
*sctps
= sctp
->sctp_sctps
;
1089 dprint(1, ("sctp_icmp_error: sctp=%p, mp=%p\n", (void *)sctp
,
1092 ipha
= (ipha_t
*)mp
->b_rptr
;
1093 if (IPH_HDR_VERSION(ipha
) != IPV4_VERSION
) {
1094 ASSERT(IPH_HDR_VERSION(ipha
) == IPV6_VERSION
);
1095 sctp_icmp_error_ipv6(sctp
, mp
);
1099 /* account for the ip hdr from the icmp message */
1100 iph_hdr_length
= IPH_HDR_LENGTH(ipha
);
1101 icmph
= (icmph_t
*)&mp
->b_rptr
[iph_hdr_length
];
1102 /* now the ip hdr of message resulting in this icmp */
1103 ipha
= (ipha_t
*)&icmph
[1];
1104 iph_hdr_length
= IPH_HDR_LENGTH(ipha
);
1105 sctph
= (sctp_hdr_t
*)((char *)ipha
+ iph_hdr_length
);
1106 /* first_mp must expose the full sctp header. */
1107 if ((uchar_t
*)(sctph
+ 1) >= mp
->b_wptr
) {
1108 /* not enough data for SCTP header */
1113 switch (icmph
->icmph_type
) {
1114 case ICMP_DEST_UNREACHABLE
:
1115 switch (icmph
->icmph_code
) {
1116 case ICMP_FRAGMENTATION_NEEDED
:
1118 * Reduce the MSS based on the new MTU. This will
1119 * eliminate any fragmentation locally.
1120 * N.B. There may well be some funny side-effects on
1121 * the local send policy and the remote receive policy.
1122 * Pending further research, we provide
1123 * sctp_ignore_path_mtu just in case this proves
1124 * disastrous somewhere.
1126 * After updating the MSS, retransmit part of the
1127 * dropped segment using the new mss by calling
1128 * sctp_wput_slow(). Need to adjust all those
1129 * params to make sure sctp_wput_slow() work properly.
1131 if (sctps
->sctps_ignore_path_mtu
)
1134 /* find the offending faddr */
1135 IN6_IPADDR_TO_V4MAPPED(ipha
->ipha_dst
, &dst
);
1136 fp
= sctp_lookup_faddr(sctp
, &dst
);
1140 sctp_update_pmtu(sctp
, fp
, B_TRUE
);
1142 * It is possible, even likely that a fast retransmit
1143 * attempt has been dropped by ip as a result of this
1144 * error, retransmission bundles as much as possible.
1145 * A retransmit here prevents significant delays waiting
1146 * on the timer. Analogous to behaviour of TCP after
1149 sctp_rexmit(sctp
, fp
);
1151 case ICMP_PORT_UNREACHABLE
:
1152 case ICMP_PROTOCOL_UNREACHABLE
:
1153 switch (sctp
->sctp_state
) {
1154 case SCTPS_COOKIE_WAIT
:
1155 case SCTPS_COOKIE_ECHOED
:
1156 /* make sure the verification tag matches */
1157 if (!sctp_icmp_verf(sctp
, sctph
, mp
)) {
1160 SCTPS_BUMP_MIB(sctps
, sctpAborted
);
1161 sctp_assoc_event(sctp
, SCTP_CANT_STR_ASSOC
, 0,
1163 sctp_clean_death(sctp
, ECONNREFUSED
);
1167 case ICMP_HOST_UNREACHABLE
:
1168 case ICMP_NET_UNREACHABLE
:
1169 /* Record the error in case we finally time out. */
1170 sctp
->sctp_client_errno
= (icmph
->icmph_code
==
1171 ICMP_HOST_UNREACHABLE
) ? EHOSTUNREACH
: ENETUNREACH
;
1177 case ICMP_SOURCE_QUENCH
: {
1178 /* Reduce the sending rate as if we got a retransmit timeout */
1186 * sctp_icmp_error_ipv6() is called by sctp_icmp_error() to process ICMPv6
1187 * error messages passed up by IP.
1188 * Assumes that IP has pulled up all the extension headers as well
1189 * as the ICMPv6 header.
1192 sctp_icmp_error_ipv6(sctp_t
*sctp
, mblk_t
*mp
)
1196 uint16_t iph_hdr_length
;
1200 sctp_stack_t
*sctps
= sctp
->sctp_sctps
;
1202 ip6h
= (ip6_t
*)mp
->b_rptr
;
1203 iph_hdr_length
= (ip6h
->ip6_nxt
!= IPPROTO_SCTP
) ?
1204 ip_hdr_length_v6(mp
, ip6h
) : IPV6_HDR_LEN
;
1206 icmp6
= (icmp6_t
*)&mp
->b_rptr
[iph_hdr_length
];
1207 ip6h
= (ip6_t
*)&icmp6
[1];
1208 if (!ip_hdr_length_nexthdr_v6(mp
, ip6h
, &iph_hdr_length
, &nexthdrp
)) {
1212 ASSERT(*nexthdrp
== IPPROTO_SCTP
);
1214 /* XXX need ifindex to find connection */
1215 sctpha
= (sctp_hdr_t
*)((char *)ip6h
+ iph_hdr_length
);
1216 if ((uchar_t
*)sctpha
>= mp
->b_wptr
) {
1217 /* not enough data for SCTP header */
1221 switch (icmp6
->icmp6_type
) {
1222 case ICMP6_PACKET_TOO_BIG
:
1224 * Reduce the MSS based on the new MTU. This will
1225 * eliminate any fragmentation locally.
1226 * N.B. There may well be some funny side-effects on
1227 * the local send policy and the remote receive policy.
1228 * Pending further research, we provide
1229 * sctp_ignore_path_mtu just in case this proves
1230 * disastrous somewhere.
1232 * After updating the MSS, retransmit part of the
1233 * dropped segment using the new mss by calling
1234 * sctp_wput_slow(). Need to adjust all those
1235 * params to make sure sctp_wput_slow() work properly.
1237 if (sctps
->sctps_ignore_path_mtu
)
1240 /* find the offending faddr */
1241 fp
= sctp_lookup_faddr(sctp
, &ip6h
->ip6_dst
);
1246 sctp_update_pmtu(sctp
, fp
, B_TRUE
);
1248 * It is possible, even likely that a fast retransmit
1249 * attempt has been dropped by ip as a result of this
1250 * error, retransmission bundles as much as possible.
1251 * A retransmit here prevents significant delays waiting
1252 * on the timer. Analogous to behaviour of TCP after
1255 sctp_rexmit(sctp
, fp
);
1258 case ICMP6_DST_UNREACH
:
1259 switch (icmp6
->icmp6_code
) {
1260 case ICMP6_DST_UNREACH_NOPORT
:
1261 /* make sure the verification tag matches */
1262 if (!sctp_icmp_verf(sctp
, sctpha
, mp
)) {
1265 if (sctp
->sctp_state
== SCTPS_COOKIE_WAIT
||
1266 sctp
->sctp_state
== SCTPS_COOKIE_ECHOED
) {
1267 SCTPS_BUMP_MIB(sctps
, sctpAborted
);
1268 sctp_assoc_event(sctp
, SCTP_CANT_STR_ASSOC
, 0,
1270 sctp_clean_death(sctp
, ECONNREFUSED
);
1274 case ICMP6_DST_UNREACH_ADMIN
:
1275 case ICMP6_DST_UNREACH_NOROUTE
:
1276 case ICMP6_DST_UNREACH_NOTNEIGHBOR
:
1277 case ICMP6_DST_UNREACH_ADDR
:
1278 /* Record the error in case we finally time out. */
1279 sctp
->sctp_client_errno
= EHOSTUNREACH
;
1286 case ICMP6_PARAM_PROB
:
1287 /* If this corresponds to an ICMP_PROTOCOL_UNREACHABLE */
1288 if (icmp6
->icmp6_code
== ICMP6_PARAMPROB_NEXTHEADER
&&
1289 (uchar_t
*)ip6h
+ icmp6
->icmp6_pptr
==
1290 (uchar_t
*)nexthdrp
) {
1291 /* make sure the verification tag matches */
1292 if (!sctp_icmp_verf(sctp
, sctpha
, mp
)) {
1295 if (sctp
->sctp_state
== SCTPS_COOKIE_WAIT
) {
1296 SCTPS_BUMP_MIB(sctps
, sctpAborted
);
1297 sctp_assoc_event(sctp
, SCTP_CANT_STR_ASSOC
, 0,
1299 sctp_clean_death(sctp
, ECONNREFUSED
);
1305 case ICMP6_TIME_EXCEEDED
:
1313 * Called by sockfs to create a new sctp instance.
1315 * If parent pointer is passed in, inherit settings from it.
1318 sctp_create(void *ulpd
, sctp_t
*parent
, int family
, int type
, int flags
,
1319 sock_upcalls_t
*upcalls
, sctp_sockbuf_limits_t
*sbl
,
1322 sctp_t
*sctp
, *psctp
;
1324 mblk_t
*ack_mp
, *hb_mp
;
1325 int sleep
= flags
& SCTP_CAN_BLOCK
? KM_SLEEP
: KM_NOSLEEP
;
1327 sctp_stack_t
*sctps
;
1329 /* User must supply a credential. */
1333 psctp
= (sctp_t
*)parent
;
1334 if (psctp
!= NULL
) {
1335 sctps
= psctp
->sctp_sctps
;
1336 /* Increase here to have common decrease at end */
1337 netstack_hold(sctps
->sctps_netstack
);
1338 ASSERT(sctps
->sctps_recvq_tq_list_cur_sz
> 0);
1342 ns
= netstack_find_by_cred(credp
);
1343 sctps
= ns
->netstack_sctp
;
1345 * Check if the receive queue taskq for this sctp_stack_t has
1348 if (sctps
->sctps_recvq_tq_list_cur_sz
== 0)
1349 sctp_rq_tq_init(sctps
);
1352 * For exclusive stacks we set the zoneid to zero
1353 * to make SCTP operate as if in the global zone.
1355 if (sctps
->sctps_netstack
->netstack_stackid
!=
1357 zoneid
= GLOBAL_ZONEID
;
1359 zoneid
= crgetzoneid(credp
);
1361 if ((connp
= ipcl_conn_create(IPCL_SCTPCONN
, sleep
,
1362 sctps
->sctps_netstack
)) == NULL
) {
1363 netstack_rele(sctps
->sctps_netstack
);
1364 SCTP_KSTAT(sctps
, sctp_conn_create
);
1368 * ipcl_conn_create did a netstack_hold. Undo the hold that was
1369 * done at top of sctp_create.
1371 netstack_rele(sctps
->sctps_netstack
);
1372 sctp
= CONN2SCTP(connp
);
1373 sctp
->sctp_sctps
= sctps
;
1375 if ((ack_mp
= sctp_timer_alloc(sctp
, sctp_ack_timer
, sleep
)) == NULL
||
1376 (hb_mp
= sctp_timer_alloc(sctp
, sctp_heartbeat_timer
,
1380 sctp_conn_clear(connp
);
1381 sctp
->sctp_sctps
= NULL
;
1382 kmem_cache_free(sctp_conn_cache
, connp
);
1386 sctp
->sctp_ack_mp
= ack_mp
;
1387 sctp
->sctp_heartbeat_mp
= hb_mp
;
1390 * Have conn_ip_output drop packets should our outer source
1391 * go invalid, and tell us about mtu changes.
1393 connp
->conn_ixa
->ixa_flags
|= IXAF_SET_ULP_CKSUM
| IXAF_VERIFY_SOURCE
|
1395 connp
->conn_family
= family
;
1396 connp
->conn_so_type
= type
;
1398 if (sctp_init_values(sctp
, psctp
, sleep
) != 0) {
1401 sctp_conn_clear(connp
);
1402 sctp
->sctp_sctps
= NULL
;
1403 kmem_cache_free(sctp_conn_cache
, connp
);
1406 sctp
->sctp_cansleep
= ((flags
& SCTP_CAN_BLOCK
) == SCTP_CAN_BLOCK
);
1408 sctp
->sctp_mss
= sctps
->sctps_initial_mtu
- ((family
== AF_INET6
) ?
1409 sctp
->sctp_hdr6_len
: sctp
->sctp_hdr_len
);
1411 if (psctp
!= NULL
) {
1412 conn_t
*pconnp
= psctp
->sctp_connp
;
1416 * Inherit local address list, local port. Parent is either
1417 * in SCTPS_BOUND, or SCTPS_LISTEN state.
1419 ASSERT((psctp
->sctp_state
== SCTPS_BOUND
) ||
1420 (psctp
->sctp_state
== SCTPS_LISTEN
));
1421 if (sctp_dup_saddrs(psctp
, sctp
, sleep
)) {
1425 sctp_headers_free(sctp
);
1426 sctp_conn_clear(connp
);
1427 sctp
->sctp_sctps
= NULL
;
1428 kmem_cache_free(sctp_conn_cache
, connp
);
1433 * If the parent is specified, it'll be immediatelly
1434 * followed by sctp_connect(). So don't add this guy to
1437 connp
->conn_lport
= pconnp
->conn_lport
;
1438 sctp
->sctp_state
= SCTPS_BOUND
;
1441 ASSERT(connp
->conn_cred
== NULL
);
1442 connp
->conn_zoneid
= zoneid
;
1444 * conn_allzones can not be set this early, hence
1447 connp
->conn_ixa
->ixa_zoneid
= zoneid
;
1448 connp
->conn_open_time
= ddi_get_lbolt64();
1449 connp
->conn_cred
= credp
;
1451 connp
->conn_cpid
= curproc
->p_pid
;
1453 connp
->conn_zone_is_global
=
1454 (crgetzoneid(credp
) == GLOBAL_ZONEID
);
1457 /* Initialize SCTP instance values, our verf tag must never be 0 */
1458 (void) random_get_pseudo_bytes((uint8_t *)&sctp
->sctp_lvtag
,
1459 sizeof (sctp
->sctp_lvtag
));
1460 if (sctp
->sctp_lvtag
== 0)
1461 sctp
->sctp_lvtag
= (uint32_t)gethrtime();
1462 ASSERT(sctp
->sctp_lvtag
!= 0);
1464 sctp
->sctp_ltsn
= sctp
->sctp_lvtag
+ 1;
1465 sctp
->sctp_lcsn
= sctp
->sctp_ltsn
;
1466 sctp
->sctp_recovery_tsn
= sctp
->sctp_lastack_rxd
= sctp
->sctp_ltsn
- 1;
1467 sctp
->sctp_adv_pap
= sctp
->sctp_lastack_rxd
;
1469 /* Information required by upper layer */
1470 ASSERT(ulpd
!= NULL
);
1471 sctp
->sctp_ulpd
= ulpd
;
1473 ASSERT(upcalls
!= NULL
);
1474 sctp
->sctp_upcalls
= upcalls
;
1475 ASSERT(sbl
!= NULL
);
1476 /* Fill in the socket buffer limits for sctpsockfs */
1477 sbl
->sbl_txlowat
= connp
->conn_sndlowat
;
1478 sbl
->sbl_txbuf
= connp
->conn_sndbuf
;
1479 sbl
->sbl_rxbuf
= sctp
->sctp_rwnd
;
1480 sbl
->sbl_rxlowat
= SCTP_RECV_LOWATER
;
1482 /* Insert this in the global list. */
1483 SCTP_LINK(sctp
, sctps
);
1488 /* Run at module load time */
1490 sctp_ddi_g_init(void)
1492 /* Create sctp_t/conn_t cache */
1493 sctp_conn_cache_init();
1495 /* Create the faddr cache */
1498 /* Create the sets cache */
1501 /* Create the PR-SCTP sets cache */
1502 sctp_ftsn_sets_init();
1504 /* Initialize tables used for CRC calculation */
1508 * We want to be informed each time a stack is created or
1509 * destroyed in the kernel, so we can maintain the
1510 * set of sctp_stack_t's.
1512 netstack_register(NS_SCTP
, sctp_stack_init
, NULL
, sctp_stack_fini
);
1516 sctp_stack_init(netstackid_t stackid
, netstack_t
*ns
)
1518 sctp_stack_t
*sctps
;
1522 sctps
= kmem_zalloc(sizeof (*sctps
), KM_SLEEP
);
1523 sctps
->sctps_netstack
= ns
;
1525 /* Initialize locks */
1526 mutex_init(&sctps
->sctps_g_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1527 mutex_init(&sctps
->sctps_epriv_port_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1528 sctps
->sctps_g_num_epriv_ports
= SCTP_NUM_EPRIV_PORTS
;
1529 sctps
->sctps_g_epriv_ports
[0] = ULP_DEF_EPRIV_PORT1
;
1530 sctps
->sctps_g_epriv_ports
[1] = ULP_DEF_EPRIV_PORT2
;
1532 /* Initialize SCTP hash arrays. */
1533 sctp_hash_init(sctps
);
1535 arrsz
= sctp_propinfo_count
* sizeof (mod_prop_info_t
);
1536 sctps
->sctps_propinfo_tbl
= (mod_prop_info_t
*)kmem_alloc(arrsz
,
1538 bcopy(sctp_propinfo_tbl
, sctps
->sctps_propinfo_tbl
, arrsz
);
1541 sctp_saddr_init(sctps
);
1543 /* Global SCTP PCB list. */
1544 list_create(&sctps
->sctps_g_list
, sizeof (sctp_t
),
1545 offsetof(sctp_t
, sctp_list
));
1547 /* Initialize SCTP kstats. */
1548 sctps
->sctps_mibkp
= sctp_kstat_init(stackid
);
1549 sctps
->sctps_kstat
= sctp_kstat2_init(stackid
);
1551 mutex_init(&sctps
->sctps_reclaim_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1552 sctps
->sctps_reclaim
= B_FALSE
;
1553 sctps
->sctps_reclaim_tid
= 0;
1554 sctps
->sctps_reclaim_period
= sctps
->sctps_rto_maxg
;
1556 /* Allocate the per netstack stats */
1557 mutex_enter(&cpu_lock
);
1558 sctps
->sctps_sc_cnt
= MAX(ncpus
, boot_ncpus
);
1559 mutex_exit(&cpu_lock
);
1560 sctps
->sctps_sc
= kmem_zalloc(max_ncpus
* sizeof (sctp_stats_cpu_t
*),
1562 for (i
= 0; i
< sctps
->sctps_sc_cnt
; i
++) {
1563 sctps
->sctps_sc
[i
] = kmem_zalloc(sizeof (sctp_stats_cpu_t
),
1567 mutex_init(&sctps
->sctps_listener_conf_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1568 list_create(&sctps
->sctps_listener_conf
, sizeof (sctp_listener_t
),
1569 offsetof(sctp_listener_t
, sl_link
));
1575 * Called when the module is about to be unloaded.
1578 sctp_ddi_g_destroy(void)
1580 /* Destroy sctp_t/conn_t caches */
1581 sctp_conn_cache_fini();
1583 /* Destroy the faddr cache */
1586 /* Destroy the sets cache */
1589 /* Destroy the PR-SCTP sets cache */
1590 sctp_ftsn_sets_fini();
1592 netstack_unregister(NS_SCTP
);
1596 * Free the SCTP stack instance.
1599 sctp_stack_fini(netstackid_t stackid
, void *arg
)
1601 sctp_stack_t
*sctps
= (sctp_stack_t
*)arg
;
1605 * Set sctps_reclaim to false tells sctp_reclaim_timer() not to restart
1608 mutex_enter(&sctps
->sctps_reclaim_lock
);
1609 sctps
->sctps_reclaim
= B_FALSE
;
1610 mutex_exit(&sctps
->sctps_reclaim_lock
);
1611 if (sctps
->sctps_reclaim_tid
!= 0)
1612 (void) untimeout(sctps
->sctps_reclaim_tid
);
1613 mutex_destroy(&sctps
->sctps_reclaim_lock
);
1615 sctp_listener_conf_cleanup(sctps
);
1617 kmem_free(sctps
->sctps_propinfo_tbl
,
1618 sctp_propinfo_count
* sizeof (mod_prop_info_t
));
1619 sctps
->sctps_propinfo_tbl
= NULL
;
1621 /* Destroy the recvq taskqs. */
1622 sctp_rq_tq_fini(sctps
);
1625 sctp_saddr_fini(sctps
);
1627 /* Global SCTP PCB list. */
1628 list_destroy(&sctps
->sctps_g_list
);
1630 /* Destroy SCTP hash arrays. */
1631 sctp_hash_destroy(sctps
);
1633 /* Destroy SCTP kernel stats. */
1634 for (i
= 0; i
< sctps
->sctps_sc_cnt
; i
++)
1635 kmem_free(sctps
->sctps_sc
[i
], sizeof (sctp_stats_cpu_t
));
1636 kmem_free(sctps
->sctps_sc
, max_ncpus
* sizeof (sctp_stats_cpu_t
*));
1638 sctp_kstat_fini(stackid
, sctps
->sctps_mibkp
);
1639 sctps
->sctps_mibkp
= NULL
;
1640 sctp_kstat2_fini(stackid
, sctps
->sctps_kstat
);
1641 sctps
->sctps_kstat
= NULL
;
1643 mutex_destroy(&sctps
->sctps_g_lock
);
1644 mutex_destroy(&sctps
->sctps_epriv_port_lock
);
1646 kmem_free(sctps
, sizeof (*sctps
));
1650 sctp_rq_tq_init(sctp_stack_t
*sctps
)
1652 char tq_name
[TASKQ_NAMELEN
];
1656 mutex_enter(&sctps
->sctps_g_lock
);
1657 /* Someone may have beaten us in creating the taskqs. */
1658 if (sctps
->sctps_recvq_tq_list_cur_sz
> 0) {
1659 mutex_exit(&sctps
->sctps_g_lock
);
1663 thrs
= MIN(sctp_recvq_tq_thr_max
, MAX(sctp_recvq_tq_thr_min
,
1664 MAX(ncpus
, boot_ncpus
)));
1666 * Make sure that the maximum number of tasks is at least thrice as
1667 * large as the number of threads.
1669 max_tasks
= MAX(sctp_recvq_tq_task_min
, thrs
) * 3;
1672 * This helps differentiate the default taskqs in different IP stacks.
1674 (void) snprintf(tq_name
, sizeof (tq_name
), "sctp_def_rq_taskq_%d",
1675 sctps
->sctps_netstack
->netstack_stackid
);
1677 sctps
->sctps_recvq_tq_list_max_sz
= sctp_recvq_tq_list_max
;
1678 sctps
->sctps_recvq_tq_list_cur_sz
= 1;
1681 * Initialize the recvq_tq_list and create the first recvq taskq.
1682 * What to do if it fails?
1684 sctps
->sctps_recvq_tq_list
=
1685 kmem_zalloc(sctps
->sctps_recvq_tq_list_max_sz
* sizeof (taskq_t
*),
1687 sctps
->sctps_recvq_tq_list
[0] = taskq_create(tq_name
, thrs
,
1688 minclsyspri
, sctp_recvq_tq_task_min
, max_tasks
, TASKQ_PREPOPULATE
);
1689 mutex_init(&sctps
->sctps_rq_tq_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1691 mutex_exit(&sctps
->sctps_g_lock
);
1695 sctp_rq_tq_fini(sctp_stack_t
*sctps
)
1699 if (sctps
->sctps_recvq_tq_list_cur_sz
== 0)
1702 for (i
= 0; i
< sctps
->sctps_recvq_tq_list_cur_sz
; i
++) {
1703 ASSERT(sctps
->sctps_recvq_tq_list
[i
] != NULL
);
1704 taskq_destroy(sctps
->sctps_recvq_tq_list
[i
]);
1706 kmem_free(sctps
->sctps_recvq_tq_list
,
1707 sctps
->sctps_recvq_tq_list_max_sz
* sizeof (taskq_t
*));
1708 sctps
->sctps_recvq_tq_list
= NULL
;
1711 /* Add another taskq for a new ill. */
1713 sctp_inc_taskq(sctp_stack_t
*sctps
)
1716 char tq_name
[TASKQ_NAMELEN
];
1720 thrs
= MIN(sctp_recvq_tq_thr_max
, MAX(sctp_recvq_tq_thr_min
,
1721 MAX(ncpus
, boot_ncpus
)));
1723 * Make sure that the maximum number of tasks is at least thrice as
1724 * large as the number of threads.
1726 max_tasks
= MAX(sctp_recvq_tq_task_min
, thrs
) * 3;
1728 mutex_enter(&sctps
->sctps_rq_tq_lock
);
1729 if (sctps
->sctps_recvq_tq_list_cur_sz
+ 1 >
1730 sctps
->sctps_recvq_tq_list_max_sz
) {
1731 mutex_exit(&sctps
->sctps_rq_tq_lock
);
1732 cmn_err(CE_NOTE
, "Cannot create more SCTP recvq taskq");
1736 (void) snprintf(tq_name
, sizeof (tq_name
), "sctp_rq_taskq_%d_%u",
1737 sctps
->sctps_netstack
->netstack_stackid
,
1738 sctps
->sctps_recvq_tq_list_cur_sz
);
1739 tq
= taskq_create(tq_name
, thrs
, minclsyspri
, sctp_recvq_tq_task_min
,
1740 max_tasks
, TASKQ_PREPOPULATE
);
1742 mutex_exit(&sctps
->sctps_rq_tq_lock
);
1743 cmn_err(CE_NOTE
, "SCTP recvq taskq creation failed");
1746 ASSERT(sctps
->sctps_recvq_tq_list
[
1747 sctps
->sctps_recvq_tq_list_cur_sz
] == NULL
);
1748 sctps
->sctps_recvq_tq_list
[sctps
->sctps_recvq_tq_list_cur_sz
] = tq
;
1749 atomic_inc_32(&sctps
->sctps_recvq_tq_list_cur_sz
);
1750 mutex_exit(&sctps
->sctps_rq_tq_lock
);
1754 uint32_t recvq_loop_cnt
= 0;
1755 uint32_t recvq_call
= 0;
1759 * Find the next recvq_tq to use. This routine will go thru all the
1760 * taskqs until it can dispatch a job for the sctp. If this fails,
1761 * it will create a new taskq and try it.
1764 sctp_find_next_tq(sctp_t
*sctp
)
1768 sctp_stack_t
*sctps
= sctp
->sctp_sctps
;
1771 * Note that since we don't hold a lock on sctp_rq_tq_lock for
1772 * performance reason, recvq_ta_list_cur_sz can be changed during
1773 * this loop. The problem this will create is that the loop may
1774 * not have tried all the recvq_tq. This should be OK.
1776 next_tq
= atomic_inc_32_nv(&sctps
->sctps_recvq_tq_list_cur
) %
1777 sctps
->sctps_recvq_tq_list_cur_sz
;
1778 for (try = 0; try < sctps
->sctps_recvq_tq_list_cur_sz
; try++) {
1779 tq
= sctps
->sctps_recvq_tq_list
[next_tq
];
1780 if (taskq_dispatch(tq
, sctp_process_recvq
, sctp
,
1781 TQ_NOSLEEP
) != NULL
) {
1782 sctp
->sctp_recvq_tq
= tq
;
1785 next_tq
= (next_tq
+ 1) % sctps
->sctps_recvq_tq_list_cur_sz
;
1789 * Create one more taskq and try it. Note that sctp_inc_taskq()
1790 * may not have created another taskq if the number of recvq
1791 * taskqs is at the maximum. We are probably in a pretty bad
1792 * shape if this actually happens...
1794 sctp_inc_taskq(sctps
);
1795 tq
= sctps
->sctps_recvq_tq_list
[sctps
->sctps_recvq_tq_list_cur_sz
- 1];
1796 if (taskq_dispatch(tq
, sctp_process_recvq
, sctp
, TQ_NOSLEEP
) != NULL
) {
1797 sctp
->sctp_recvq_tq
= tq
;
1800 SCTP_KSTAT(sctps
, sctp_find_next_tq
);
1805 * To add a message to the recvq. Note that the sctp_timer_fire()
1806 * routine also uses this function to add the timer message to the
1807 * receive queue for later processing. And it should be the only
1808 * caller of sctp_add_recvq() which sets the try_harder argument
1811 * If the try_harder argument is B_TRUE, this routine sctp_find_next_tq()
1812 * will try very hard to dispatch the task. Refer to the comment
1813 * for that routine on how it does that.
1815 * On failure the message has been freed i.e., this routine always consumes the
1816 * message. It bumps ipIfStatsInDiscards and and uses ip_drop_input to drop.
1819 sctp_add_recvq(sctp_t
*sctp
, mblk_t
*mp
, boolean_t caller_hold_lock
,
1820 ip_recv_attr_t
*ira
)
1823 ip_stack_t
*ipst
= sctp
->sctp_sctps
->sctps_netstack
->netstack_ip
;
1825 ASSERT(ira
->ira_ill
== NULL
);
1827 if (!caller_hold_lock
)
1828 mutex_enter(&sctp
->sctp_recvq_lock
);
1830 /* If the taskq dispatch has not been scheduled, do it now. */
1831 if (sctp
->sctp_recvq_tq
== NULL
) {
1832 ASSERT(sctp
->sctp_recvq
== NULL
);
1833 if (!sctp_find_next_tq(sctp
)) {
1834 if (!caller_hold_lock
)
1835 mutex_exit(&sctp
->sctp_recvq_lock
);
1836 BUMP_MIB(&ipst
->ips_ip_mib
, ipIfStatsInDiscards
);
1837 ip_drop_input("ipIfStatsInDiscards", mp
, NULL
);
1841 /* Make sure the sctp_t will not go away. */
1845 attrmp
= ip_recv_attr_to_mblk(ira
);
1846 if (attrmp
== NULL
) {
1847 if (!caller_hold_lock
)
1848 mutex_exit(&sctp
->sctp_recvq_lock
);
1849 BUMP_MIB(&ipst
->ips_ip_mib
, ipIfStatsInDiscards
);
1850 ip_drop_input("ipIfStatsInDiscards", mp
, NULL
);
1854 ASSERT(attrmp
->b_cont
== NULL
);
1855 attrmp
->b_cont
= mp
;
1858 if (sctp
->sctp_recvq
== NULL
) {
1859 sctp
->sctp_recvq
= mp
;
1860 sctp
->sctp_recvq_tail
= mp
;
1862 sctp
->sctp_recvq_tail
->b_next
= mp
;
1863 sctp
->sctp_recvq_tail
= mp
;
1866 if (!caller_hold_lock
)
1867 mutex_exit(&sctp
->sctp_recvq_lock
);
1871 sctp_process_recvq(void *arg
)
1873 sctp_t
*sctp
= (sctp_t
*)arg
;
1876 uint32_t loop_cnt
= 0;
1878 ip_recv_attr_t iras
;
1881 #define IPVER(ip6h) ((((uint32_t *)ip6h)[0] >> 28) & 0x7)
1883 #define IPVER(ip6h) ((((uint32_t *)ip6h)[0] >> 4) & 0x7)
1887 mutex_enter(&sctp
->sctp_recvq_lock
);
1893 * Note that while we are in this loop, other thread can put
1894 * new packets in the receive queue. We may be looping for
1897 while ((mp
= sctp
->sctp_recvq
) != NULL
) {
1900 sctp
->sctp_recvq
= mp
->b_next
;
1901 mutex_exit(&sctp
->sctp_recvq_lock
);
1908 data_mp
= mp
->b_cont
;
1910 if (!ip_recv_attr_from_mblk(mp
, &iras
)) {
1911 ip_drop_input("ip_recv_attr_from_mblk", mp
, NULL
);
1913 ira_cleanup(&iras
, B_TRUE
);
1917 if (iras
.ira_flags
& IRAF_ICMP_ERROR
)
1918 sctp_icmp_error(sctp
, data_mp
);
1920 sctp_input_data(sctp
, data_mp
, &iras
);
1922 ira_cleanup(&iras
, B_TRUE
);
1923 mutex_enter(&sctp
->sctp_recvq_lock
);
1926 sctp
->sctp_recvq_tail
= NULL
;
1927 sctp
->sctp_recvq_tq
= NULL
;
1929 mutex_exit(&sctp
->sctp_recvq_lock
);
1934 if (loop_cnt
> recvq_loop_cnt
)
1935 recvq_loop_cnt
= loop_cnt
;
1937 /* Now it can go away. */
1943 sctp_conn_cache_constructor(void *buf
, void *cdrarg
, int kmflags
)
1945 conn_t
*connp
= (conn_t
*)buf
;
1946 sctp_t
*sctp
= (sctp_t
*)&connp
[1];
1949 bzero(connp
, sizeof (conn_t
));
1950 bzero(buf
, (char *)&sctp
[1] - (char *)buf
);
1952 mutex_init(&sctp
->sctp_reflock
, NULL
, MUTEX_DEFAULT
, NULL
);
1953 mutex_init(&sctp
->sctp_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1954 mutex_init(&sctp
->sctp_recvq_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1955 cv_init(&sctp
->sctp_cv
, NULL
, CV_DEFAULT
, NULL
);
1956 for (cnt
= 0; cnt
< SCTP_IPIF_HASH
; cnt
++) {
1957 rw_init(&sctp
->sctp_saddrs
[cnt
].ipif_hash_lock
, NULL
,
1961 mutex_init(&connp
->conn_lock
, NULL
, MUTEX_DEFAULT
, NULL
);
1962 cv_init(&connp
->conn_cv
, NULL
, CV_DEFAULT
, NULL
);
1963 connp
->conn_flags
= IPCL_SCTPCONN
;
1964 connp
->conn_proto
= IPPROTO_SCTP
;
1965 connp
->conn_sctp
= sctp
;
1966 sctp
->sctp_connp
= connp
;
1967 rw_init(&connp
->conn_ilg_lock
, NULL
, RW_DEFAULT
, NULL
);
1969 connp
->conn_ixa
= kmem_zalloc(sizeof (ip_xmit_attr_t
), kmflags
);
1970 if (connp
->conn_ixa
== NULL
) {
1973 connp
->conn_ixa
->ixa_refcnt
= 1;
1974 connp
->conn_ixa
->ixa_protocol
= connp
->conn_proto
;
1975 connp
->conn_ixa
->ixa_xmit_hint
= CONN_TO_XMIT_HINT(connp
);
1981 sctp_conn_cache_destructor(void *buf
, void *cdrarg
)
1983 conn_t
*connp
= (conn_t
*)buf
;
1984 sctp_t
*sctp
= (sctp_t
*)&connp
[1];
1987 ASSERT(sctp
->sctp_connp
== connp
);
1988 ASSERT(!MUTEX_HELD(&sctp
->sctp_lock
));
1989 ASSERT(!MUTEX_HELD(&sctp
->sctp_reflock
));
1990 ASSERT(!MUTEX_HELD(&sctp
->sctp_recvq_lock
));
1992 ASSERT(sctp
->sctp_conn_hash_next
== NULL
);
1993 ASSERT(sctp
->sctp_conn_hash_prev
== NULL
);
1994 ASSERT(sctp
->sctp_listen_hash_next
== NULL
);
1995 ASSERT(sctp
->sctp_listen_hash_prev
== NULL
);
1996 ASSERT(sctp
->sctp_listen_tfp
== NULL
);
1997 ASSERT(sctp
->sctp_conn_tfp
== NULL
);
1999 ASSERT(sctp
->sctp_faddrs
== NULL
);
2000 ASSERT(sctp
->sctp_nsaddrs
== 0);
2002 ASSERT(sctp
->sctp_ulpd
== NULL
);
2004 ASSERT(sctp
->sctp_lastfaddr
== NULL
);
2005 ASSERT(sctp
->sctp_primary
== NULL
);
2006 ASSERT(sctp
->sctp_current
== NULL
);
2007 ASSERT(sctp
->sctp_lastdata
== NULL
);
2009 ASSERT(sctp
->sctp_xmit_head
== NULL
);
2010 ASSERT(sctp
->sctp_xmit_tail
== NULL
);
2011 ASSERT(sctp
->sctp_xmit_unsent
== NULL
);
2012 ASSERT(sctp
->sctp_xmit_unsent_tail
== NULL
);
2014 ASSERT(sctp
->sctp_ostrcntrs
== NULL
);
2016 ASSERT(sctp
->sctp_sack_info
== NULL
);
2017 ASSERT(sctp
->sctp_ack_mp
== NULL
);
2018 ASSERT(sctp
->sctp_instr
== NULL
);
2020 ASSERT(sctp
->sctp_iphc
== NULL
);
2021 ASSERT(sctp
->sctp_iphc6
== NULL
);
2022 ASSERT(sctp
->sctp_ipha
== NULL
);
2023 ASSERT(sctp
->sctp_ip6h
== NULL
);
2024 ASSERT(sctp
->sctp_sctph
== NULL
);
2025 ASSERT(sctp
->sctp_sctph6
== NULL
);
2027 ASSERT(sctp
->sctp_cookie_mp
== NULL
);
2029 ASSERT(sctp
->sctp_refcnt
== 0);
2030 ASSERT(sctp
->sctp_timer_mp
== NULL
);
2031 ASSERT(sctp
->sctp_connp
->conn_ref
== 0);
2032 ASSERT(sctp
->sctp_heartbeat_mp
== NULL
);
2033 ASSERT(sctp
->sctp_ptpbhn
== NULL
&& sctp
->sctp_bind_hash
== NULL
);
2035 ASSERT(sctp
->sctp_shutdown_faddr
== NULL
);
2037 ASSERT(sctp
->sctp_cxmit_list
== NULL
);
2039 ASSERT(sctp
->sctp_recvq
== NULL
);
2040 ASSERT(sctp
->sctp_recvq_tail
== NULL
);
2041 ASSERT(sctp
->sctp_recvq_tq
== NULL
);
2044 * sctp_pad_mp can be NULL if the memory allocation fails
2045 * in sctp_init_values() and the conn_t is freed.
2047 if (sctp
->sctp_pad_mp
!= NULL
) {
2048 freeb(sctp
->sctp_pad_mp
);
2049 sctp
->sctp_pad_mp
= NULL
;
2052 mutex_destroy(&sctp
->sctp_reflock
);
2053 mutex_destroy(&sctp
->sctp_lock
);
2054 mutex_destroy(&sctp
->sctp_recvq_lock
);
2055 cv_destroy(&sctp
->sctp_cv
);
2056 for (cnt
= 0; cnt
< SCTP_IPIF_HASH
; cnt
++) {
2057 rw_destroy(&sctp
->sctp_saddrs
[cnt
].ipif_hash_lock
);
2060 mutex_destroy(&connp
->conn_lock
);
2061 cv_destroy(&connp
->conn_cv
);
2062 rw_destroy(&connp
->conn_ilg_lock
);
2064 /* Can be NULL if constructor failed */
2065 if (connp
->conn_ixa
!= NULL
) {
2066 ASSERT(connp
->conn_ixa
->ixa_refcnt
== 1);
2067 ASSERT(connp
->conn_ixa
->ixa_ire
== NULL
);
2068 ASSERT(connp
->conn_ixa
->ixa_nce
== NULL
);
2069 ixa_refrele(connp
->conn_ixa
);
2074 sctp_conn_cache_init()
2076 sctp_conn_cache
= kmem_cache_create("sctp_conn_cache",
2077 sizeof (sctp_t
) + sizeof (conn_t
), 0, sctp_conn_cache_constructor
,
2078 sctp_conn_cache_destructor
, sctp_conn_reclaim
, NULL
, NULL
, 0);
2082 sctp_conn_cache_fini()
2084 kmem_cache_destroy(sctp_conn_cache
);
2088 sctp_conn_init(conn_t
*connp
)
2090 ASSERT(connp
->conn_flags
== IPCL_SCTPCONN
);
2091 connp
->conn_rq
= connp
->conn_wq
= NULL
;
2092 connp
->conn_ixa
->ixa_flags
|= IXAF_SET_ULP_CKSUM
| IXAF_VERIFY_SOURCE
|
2095 ASSERT(connp
->conn_proto
== IPPROTO_SCTP
);
2096 ASSERT(connp
->conn_ixa
->ixa_protocol
== connp
->conn_proto
);
2097 connp
->conn_state_flags
|= CONN_INCIPIENT
;
2099 ASSERT(connp
->conn_sctp
!= NULL
);
2102 * Register sctp_notify to listen to capability changes detected by IP.
2103 * This upcall is made in the context of the call to conn_ip_output
2104 * thus it holds whatever locks sctp holds across conn_ip_output.
2106 connp
->conn_ixa
->ixa_notify
= sctp_notify
;
2107 connp
->conn_ixa
->ixa_notify_cookie
= connp
->conn_sctp
;
2111 sctp_conn_clear(conn_t
*connp
)
2113 /* Clean up conn_t stuff */
2114 if (connp
->conn_latch
!= NULL
) {
2115 IPLATCH_REFRELE(connp
->conn_latch
);
2116 connp
->conn_latch
= NULL
;
2118 if (connp
->conn_latch_in_policy
!= NULL
) {
2119 IPPOL_REFRELE(connp
->conn_latch_in_policy
);
2120 connp
->conn_latch_in_policy
= NULL
;
2122 if (connp
->conn_latch_in_action
!= NULL
) {
2123 IPACT_REFRELE(connp
->conn_latch_in_action
);
2124 connp
->conn_latch_in_action
= NULL
;
2126 if (connp
->conn_policy
!= NULL
) {
2127 IPPH_REFRELE(connp
->conn_policy
, connp
->conn_netstack
);
2128 connp
->conn_policy
= NULL
;
2130 if (connp
->conn_ipsec_opt_mp
!= NULL
) {
2131 freemsg(connp
->conn_ipsec_opt_mp
);
2132 connp
->conn_ipsec_opt_mp
= NULL
;
2134 netstack_rele(connp
->conn_netstack
);
2135 connp
->conn_netstack
= NULL
;
2137 /* Leave conn_ixa and other constructed fields in place */
2138 ipcl_conn_cleanup(connp
);