1 /*
2 * CDDL HEADER START
3 *
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.
7 *
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.
12 *
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]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 #include <sys/types.h>
27 #include <sys/systm.h>
28 #include <sys/stream.h>
29 #include <sys/cmn_err.h>
30 #include <sys/strsubr.h>
31 #include <sys/strsun.h>
32
33 #include <netinet/in.h>
34 #include <netinet/ip6.h>
35
36 #include <inet/common.h>
37 #include <inet/ip.h>
38 #include <inet/mib2.h>
39 #include <inet/ipclassifier.h>
40 #include "sctp_impl.h"
41 #include "sctp_asconf.h"
42
43 /* Timer block states. */
44 typedef enum {
45 SCTP_TB_RUNNING = 1,
46 SCTP_TB_IDLE,
47 /* Could not stop/free before mblk got queued */
48 SCTP_TB_RESCHED, /* sctp_tb_time_left contains tick count */
49 SCTP_TB_CANCELLED,
50 SCTP_TB_TO_BE_FREED
51 } timer_block_state;
52
53 typedef struct sctp_tb_s {
54 timer_block_state sctp_tb_state;
55 timeout_id_t sctp_tb_tid;
56 mblk_t *sctp_tb_mp;
57 clock_t sctp_tb_time_left;
58 } sctp_tb_t;
59
60 /*
61 * Early abort threshold when the system is under pressure, sctps_reclaim
62 * is on.
63 *
64 * sctp_pa_early_abort: number of strikes per association before abort
65 * sctp_pp_early_abort: number of strikes per peer address before abort
66 */
67 uint32_t sctp_pa_early_abort = 5;
68 uint32_t sctp_pp_early_abort = 3;
69
70 static void sctp_timer_fire(sctp_tb_t *);
71
72 /*
73 * sctp_timer mechanism.
74 *
75 * Each timer is represented by a timer mblk. When the
76 * timer fires, and the sctp_t is busy, the timer mblk will be put on
77 * the associated sctp_t timer queue so that it can be executed when
78 * the thread holding the lock on the sctp_t is done with its job.
79 *
80 * Note that there is no lock to protect the timer mblk state. The reason
81 * is that the timer state can only be changed by a thread holding the
82 * lock on the sctp_t.
83 *
84 * The interface consists of 4 entry points:
85 * sctp_timer_alloc - create a timer mblk
86 * sctp_timer_free - free a timer mblk
87 * sctp_timer - start, restart, stop the timer
88 * sctp_timer_valid - called by sctp_process_recvq to verify that
89 * the timer did indeed fire.
90 */
91
92
93 /*
94 * Start, restart, stop the timer.
95 * If "tim" is -1 the timer is stopped.
96 * Otherwise, the timer is stopped if it is already running, and
97 * set to fire tim clock ticks from now.
98 */
99 void
sctp_timer(sctp_t * sctp,mblk_t * mp,clock_t tim)100 sctp_timer(sctp_t *sctp, mblk_t *mp, clock_t tim)
101 {
102 sctp_tb_t *sctp_tb;
103 int state;
104
105 ASSERT(sctp != NULL && mp != NULL);
106 ASSERT((mp->b_rptr - mp->b_datap->db_base) == sizeof (sctp_tb_t));
107 ASSERT(mp->b_datap->db_type == M_PCSIG);
108
109 sctp_tb = (sctp_tb_t *)mp->b_datap->db_base;
110 if (tim >= 0) {
111 state = sctp_tb->sctp_tb_state;
112 sctp_tb->sctp_tb_time_left = tim;
113 if (state == SCTP_TB_RUNNING) {
114 if (untimeout(sctp_tb->sctp_tb_tid) < 0) {
115 sctp_tb->sctp_tb_state = SCTP_TB_RESCHED;
116 /* sctp_timer_valid will start timer */
117 return;
118 }
119 } else if (state != SCTP_TB_IDLE) {
120 ASSERT(state != SCTP_TB_TO_BE_FREED);
121 if (state == SCTP_TB_CANCELLED) {
122 sctp_tb->sctp_tb_state = SCTP_TB_RESCHED;
123 /* sctp_timer_valid will start timer */
124 return;
125 }
126 if (state == SCTP_TB_RESCHED) {
127 /* sctp_timer_valid will start timer */
128 return;
129 }
130 } else {
131 SCTP_REFHOLD(sctp);
132 }
133 sctp_tb->sctp_tb_state = SCTP_TB_RUNNING;
134 sctp_tb->sctp_tb_tid =
135 timeout((pfv_t)sctp_timer_fire, sctp_tb, tim);
136 return;
137 }
138 switch (tim) {
139 case -1:
140 sctp_timer_stop(mp);
141 break;
142 default:
143 ASSERT(0);
144 break;
145 }
146 }
147
148 /*
149 * sctp_timer_alloc is called by sctp_init to allocate and initialize a
150 * sctp timer.
151 *
152 * Allocate an M_PCSIG timer message. The space between db_base and
153 * b_rptr is used by the sctp_timer mechanism, and after b_rptr there is
154 * space for sctpt_t.
155 */
156 mblk_t *
sctp_timer_alloc(sctp_t * sctp,pfv_t func,int sleep)157 sctp_timer_alloc(sctp_t *sctp, pfv_t func, int sleep)
158 {
159 mblk_t *mp;
160 sctp_tb_t *sctp_tb;
161 sctpt_t *sctpt;
162 sctp_stack_t *sctps = sctp->sctp_sctps;
163
164 if (sleep == KM_SLEEP) {
165 mp = allocb_wait(sizeof (sctp_t) + sizeof (sctp_tb_t), BPRI_HI,
166 STR_NOSIG, NULL);
167 } else {
168 mp = allocb(sizeof (sctp_t) + sizeof (sctp_tb_t), BPRI_HI);
169 }
170 if (mp != NULL) {
171 mp->b_datap->db_type = M_PCSIG;
172 sctp_tb = (sctp_tb_t *)mp->b_datap->db_base;
173 mp->b_rptr = (uchar_t *)&sctp_tb[1];
174 mp->b_wptr = mp->b_rptr + sizeof (sctpt_t);
175 sctp_tb->sctp_tb_state = SCTP_TB_IDLE;
176 sctp_tb->sctp_tb_mp = mp;
177
178 sctpt = (sctpt_t *)mp->b_rptr;
179 sctpt->sctpt_sctp = sctp;
180 sctpt->sctpt_faddr = NULL; /* set when starting timer */
181 sctpt->sctpt_pfv = func;
182 return (mp);
183 }
184 SCTP_KSTAT(sctps, sctp_add_timer);
185 return (NULL);
186 }
187
188 /*
189 * timeout() callback function.
190 * Put the message on the process control block's queue.
191 * If the timer is stopped or freed after
192 * it has fired then sctp_timer() and sctp_timer_valid() will clean
193 * things up.
194 */
195 static void
sctp_timer_fire(sctp_tb_t * sctp_tb)196 sctp_timer_fire(sctp_tb_t *sctp_tb)
197 {
198 mblk_t *mp;
199 sctp_t *sctp;
200 sctpt_t *sctpt;
201
202 mp = sctp_tb->sctp_tb_mp;
203 ASSERT(sctp_tb == (sctp_tb_t *)mp->b_datap->db_base);
204 ASSERT(mp->b_datap->db_type == M_PCSIG);
205
206 sctpt = (sctpt_t *)mp->b_rptr;
207 sctp = sctpt->sctpt_sctp;
208 ASSERT(sctp != NULL);
209
210 mutex_enter(&sctp->sctp_lock);
211 if (sctp->sctp_running) {
212 /*
213 * Put the timer mblk to the special sctp_timer_mp list.
214 * This timer will be handled when the thread using this
215 * SCTP is done with its job.
216 */
217 if (sctp->sctp_timer_mp == NULL) {
218 SCTP_REFHOLD(sctp);
219 sctp->sctp_timer_mp = mp;
220 } else {
221 linkb(sctp->sctp_timer_mp, mp);
222 }
223 mp->b_cont = NULL;
224 mutex_exit(&sctp->sctp_lock);
225 } else {
226 sctp->sctp_running = B_TRUE;
227 mutex_exit(&sctp->sctp_lock);
228
229 sctp_timer_call(sctp, mp);
230 WAKE_SCTP(sctp);
231 }
232 SCTP_REFRELE(sctp);
233 }
234
235 /*
236 * Logically free a timer mblk (that might have a pending timeout().)
237 * If the timer has fired and the mblk has been put on the queue then
238 * sctp_timer_valid will free the mblk.
239 */
240 void
sctp_timer_free(mblk_t * mp)241 sctp_timer_free(mblk_t *mp)
242 {
243 sctp_tb_t *sctp_tb;
244 int state;
245 sctpt_t *sctpt;
246
247 ASSERT(mp != NULL);
248 ASSERT((mp->b_rptr - mp->b_datap->db_base) == sizeof (sctp_tb_t));
249 ASSERT(mp->b_datap->db_type == M_PCSIG);
250
251 sctp_tb = (sctp_tb_t *)mp->b_datap->db_base;
252 state = sctp_tb->sctp_tb_state;
253
254 dprint(5, ("sctp_timer_free %p state %d\n", (void *)mp, state));
255
256 if (state == SCTP_TB_RUNNING) {
257 if (untimeout(sctp_tb->sctp_tb_tid) < 0) {
258 sctp_tb->sctp_tb_state = SCTP_TB_TO_BE_FREED;
259 /* sctp_timer_valid will free the mblk */
260 return;
261 }
262 sctpt = (sctpt_t *)mp->b_rptr;
263 SCTP_REFRELE(sctpt->sctpt_sctp);
264 } else if (state != SCTP_TB_IDLE) {
265 ASSERT(state != SCTP_TB_TO_BE_FREED);
266 sctp_tb->sctp_tb_state = SCTP_TB_TO_BE_FREED;
267 /* sctp_timer_valid will free the mblk */
268 return;
269 }
270 freeb(mp);
271 }
272
273 /*
274 * Called from sctp_timer(,,-1)
275 */
276 void
sctp_timer_stop(mblk_t * mp)277 sctp_timer_stop(mblk_t *mp)
278 {
279 sctp_tb_t *sctp_tb;
280 int state;
281 sctpt_t *sctpt;
282
283 ASSERT(mp != NULL);
284 ASSERT(mp->b_datap->db_type == M_PCSIG);
285
286 sctp_tb = (sctp_tb_t *)mp->b_datap->db_base;
287 state = sctp_tb->sctp_tb_state;
288
289 dprint(5, ("sctp_timer_stop %p %d\n", (void *)mp, state));
290
291 if (state == SCTP_TB_RUNNING) {
292 if (untimeout(sctp_tb->sctp_tb_tid) < 0) {
293 sctp_tb->sctp_tb_state = SCTP_TB_CANCELLED;
294 } else {
295 sctp_tb->sctp_tb_state = SCTP_TB_IDLE;
296 sctpt = (sctpt_t *)mp->b_rptr;
297 SCTP_REFRELE(sctpt->sctpt_sctp);
298 }
299 } else if (state == SCTP_TB_RESCHED) {
300 sctp_tb->sctp_tb_state = SCTP_TB_CANCELLED;
301 }
302 }
303
304 /*
305 * The user of the sctp_timer mechanism is required to call
306 * sctp_timer_valid() for each M_PCSIG message processed in the
307 * service procedures.
308 * sctp_timer_valid will return "true" if the timer actually did fire.
309 */
310
311 static boolean_t
sctp_timer_valid(mblk_t * mp)312 sctp_timer_valid(mblk_t *mp)
313 {
314 sctp_tb_t *sctp_tb;
315 int state;
316 sctpt_t *sctpt;
317
318 ASSERT(mp != NULL);
319 ASSERT(mp->b_datap->db_type == M_PCSIG);
320
321 sctp_tb = (sctp_tb_t *)DB_BASE(mp);
322 sctpt = (sctpt_t *)mp->b_rptr;
323 state = sctp_tb->sctp_tb_state;
324 if (state != SCTP_TB_RUNNING) {
325 ASSERT(state != SCTP_TB_IDLE);
326 if (state == SCTP_TB_TO_BE_FREED) {
327 /*
328 * sctp_timer_free was called after the message
329 * was putq'ed.
330 */
331 freeb(mp);
332 return (B_FALSE);
333 }
334 if (state == SCTP_TB_CANCELLED) {
335 /* The timer was stopped after the mblk was putq'ed */
336 sctp_tb->sctp_tb_state = SCTP_TB_IDLE;
337 return (B_FALSE);
338 }
339 if (state == SCTP_TB_RESCHED) {
340 /*
341 * The timer was stopped and then restarted after
342 * the mblk was putq'ed.
343 * sctp_tb_time_left contains the number of ticks that
344 * the timer was restarted with.
345 * The sctp will not be disapper between the time
346 * the sctpt_t is marked SCTP_TB_RESCHED and when
347 * we get here as sctp_add_recvq() does a refhold.
348 */
349 sctp_tb->sctp_tb_state = SCTP_TB_RUNNING;
350 sctp_tb->sctp_tb_tid = timeout((pfv_t)sctp_timer_fire,
351 sctp_tb, sctp_tb->sctp_tb_time_left);
352 SCTP_REFHOLD(sctpt->sctpt_sctp);
353 return (B_FALSE);
354 }
355 }
356 sctp_tb->sctp_tb_state = SCTP_TB_IDLE;
357 return (B_TRUE);
358 }
359
360 /*
361 * The SCTP timer call. Calls sctp_timer_valid() to verify whether
362 * timer was cancelled or not.
363 */
364 void
sctp_timer_call(sctp_t * sctp,mblk_t * mp)365 sctp_timer_call(sctp_t *sctp, mblk_t *mp)
366 {
367 sctpt_t *sctpt = (sctpt_t *)mp->b_rptr;
368
369 if (sctp_timer_valid(mp)) {
370 (*sctpt->sctpt_pfv)(sctp, sctpt->sctpt_faddr);
371 }
372 }
373
374 /*
375 * Delayed ack
376 */
377 void
sctp_ack_timer(sctp_t * sctp)378 sctp_ack_timer(sctp_t *sctp)
379 {
380 sctp_stack_t *sctps = sctp->sctp_sctps;
381
382 sctp->sctp_ack_timer_running = 0;
383 sctp->sctp_sack_toggle = sctps->sctps_deferred_acks_max;
384 SCTPS_BUMP_MIB(sctps, sctpOutAckDelayed);
385 (void) sctp_sack(sctp, NULL);
386 }
387
388 /*
389 * Peer address heartbeat timer handler
390 */
391 void
sctp_heartbeat_timer(sctp_t * sctp)392 sctp_heartbeat_timer(sctp_t *sctp)
393 {
394 sctp_faddr_t *fp;
395 int64_t now;
396 int64_t earliest_expiry;
397 int cnt;
398 sctp_stack_t *sctps = sctp->sctp_sctps;
399 int pp_max_retr;
400
401 if (sctp->sctp_strikes >= sctp->sctp_pa_max_rxt) {
402 /*
403 * If there is a peer address with no strikes, don't give up
404 * yet unless we are under memory pressure. If enough other
405 * peer address are down, we could otherwise fail the
406 * association prematurely. This is a byproduct of our
407 * aggressive probe approach when a heartbeat fails to
408 * connect. We may wish to revisit this...
409 */
410 if (sctps->sctps_reclaim || !sctp_is_a_faddr_clean(sctp)) {
411 /* time to give up */
412 SCTPS_BUMP_MIB(sctps, sctpAborted);
413 SCTPS_BUMP_MIB(sctps, sctpTimHeartBeatDrop);
414 sctp_assoc_event(sctp, SCTP_COMM_LOST, 0, NULL);
415 sctp_clean_death(sctp, sctp->sctp_client_errno ?
416 sctp->sctp_client_errno : ETIMEDOUT);
417 return;
418 }
419 }
420
421 /* Only send heartbeats in the established state */
422 if (sctp->sctp_state != SCTPS_ESTABLISHED) {
423 dprint(5, ("sctp_heartbeat_timer: not in ESTABLISHED\n"));
424 return;
425 }
426
427 now = ddi_get_lbolt64();
428 earliest_expiry = 0;
429 cnt = sctps->sctps_maxburst;
430
431 /*
432 * Walk through all faddrs. Since the timer should run infrequently
433 * and the number of peer addresses should not be big, this should
434 * be OK.
435 */
436 for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) {
437 if (sctps->sctps_reclaim)
438 pp_max_retr = MIN(sctp_pp_early_abort, fp->sf_max_retr);
439 else
440 pp_max_retr = fp->sf_max_retr;
441
442 /*
443 * If the peer is unreachable because there is no available
444 * source address, call sctp_get_dest() to see if it is
445 * reachable now. If it is OK, the state will become
446 * unconfirmed. And the following code to handle unconfirmed
447 * address will be executed. If it is still not OK,
448 * re-schedule. If heartbeat is enabled, only try this
449 * up to the normal heartbeat max times. But if heartbeat
450 * is disable, this retry may go on forever.
451 */
452 if (fp->sf_state == SCTP_FADDRS_UNREACH) {
453 sctp_get_dest(sctp, fp);
454 if (fp->sf_state == SCTP_FADDRS_UNREACH) {
455 if (fp->sf_hb_enabled &&
456 ++fp->sf_strikes > pp_max_retr &&
457 sctp_faddr_dead(sctp, fp,
458 SCTP_FADDRS_DOWN) == -1) {
459 /* Assoc is dead */
460 return;
461 }
462 fp->sf_hb_expiry = now + SET_HB_INTVL(fp);
463 goto set_expiry;
464 } else {
465 /* Send a heartbeat immediately. */
466 fp->sf_hb_expiry = now;
467 }
468 }
469 /*
470 * Don't send heartbeat to this address if it is not
471 * hb_enabled and the address has been confirmed.
472 */
473 if (!fp->sf_hb_enabled && fp->sf_state !=
474 SCTP_FADDRS_UNCONFIRMED) {
475 continue;
476 }
477
478 /*
479 * The heartbeat timer is expired. If the address is dead,
480 * we still send heartbeat to it in case it becomes alive
481 * again. But we will only send once in a while, calculated
482 * by SET_HB_INTVL().
483 *
484 * If the address is alive and there is a hearbeat pending,
485 * resend the heartbeat and start exponential backoff on the
486 * heartbeat timeout value. If there is no heartbeat pending,
487 * just send out one.
488 */
489 if (now >= fp->sf_hb_expiry) {
490 if (fp->sf_hb_pending) {
491 /*
492 * If an address is not confirmed, no need
493 * to bump the overall counter as it doesn't
494 * matter as we will not use it to send data
495 * and it should not affect the association.
496 */
497 switch (fp->sf_state) {
498 case SCTP_FADDRS_ALIVE:
499 sctp->sctp_strikes++;
500 /* FALLTHRU */
501 case SCTP_FADDRS_UNCONFIRMED:
502 /*
503 * Retransmission implies that RTO
504 * is probably not correct.
505 */
506 fp->sf_rtt_updates = 0;
507 fp->sf_strikes++;
508 if (fp->sf_strikes > pp_max_retr) {
509 if (sctp_faddr_dead(sctp, fp,
510 SCTP_FADDRS_DOWN) == -1) {
511 /* Assoc is dead */
512 return;
513 }
514 /*
515 * Addr is down; keep initial
516 * RTO
517 */
518 fp->sf_rto =
519 sctp->sctp_rto_initial;
520 goto dead_addr;
521 } else {
522 SCTP_CALC_RXT(sctp, fp,
523 sctp->sctp_rto_max);
524 fp->sf_hb_expiry = now +
525 fp->sf_rto;
526 }
527 break;
528 case SCTP_FADDRS_DOWN:
529 dead_addr:
530 fp->sf_hb_expiry = now +
531 SET_HB_INTVL(fp);
532 break;
533 default:
534 continue;
535 }
536 } else {
537 /*
538 * If there is unack'ed data, no need to
539 * send a heart beat.
540 */
541 if (fp->sf_suna > 0) {
542 fp->sf_hb_expiry = now +
543 SET_HB_INTVL(fp);
544 goto set_expiry;
545 } else {
546 fp->sf_hb_expiry = now + fp->sf_rto;
547 }
548 }
549 /*
550 * Note that the total number of heartbeat we can send
551 * out simultaneously is limited by sctp_maxburst. If
552 * the limit is exceeded, we need to wait for the next
553 * timeout to send them. This should only happen if
554 * there is unconfirmed address. Note that hb_pending
555 * is set in sctp_send_heartbeat(). So if a heartbeat
556 * is not sent, it will not affect the state of the
557 * peer address.
558 */
559 if (fp->sf_state != SCTP_FADDRS_UNCONFIRMED ||
560 cnt-- > 0)
561 sctp_send_heartbeat(sctp, fp);
562 }
563 set_expiry:
564 if (fp->sf_hb_expiry < earliest_expiry || earliest_expiry == 0)
565 earliest_expiry = fp->sf_hb_expiry;
566 }
567 if (sctp->sctp_autoclose != 0) {
568 int64_t expire;
569
570 expire = sctp->sctp_active + sctp->sctp_autoclose;
571
572 if (expire <= now) {
573 dprint(3, ("sctp_heartbeat_timer: autoclosing\n"));
574 sctp_send_shutdown(sctp, 0);
575 return;
576 }
577 if (expire < earliest_expiry || earliest_expiry == 0)
578 earliest_expiry = expire;
579 }
580
581 earliest_expiry -= now;
582 if (earliest_expiry < 0)
583 earliest_expiry = 1;
584 sctp_timer(sctp, sctp->sctp_heartbeat_mp, earliest_expiry);
585 }
586
587 void
sctp_rexmit_timer(sctp_t * sctp,sctp_faddr_t * fp)588 sctp_rexmit_timer(sctp_t *sctp, sctp_faddr_t *fp)
589 {
590 mblk_t *mp;
591 uint32_t rto_max = sctp->sctp_rto_max;
592 sctp_stack_t *sctps = sctp->sctp_sctps;
593 int pp_max_retr, pa_max_retr;
594
595 ASSERT(fp != NULL);
596
597 dprint(3, ("sctp_timer: faddr=%x:%x:%x:%x\n",
598 SCTP_PRINTADDR(fp->sf_faddr)));
599
600 fp->sf_timer_running = 0;
601
602 if (!sctps->sctps_reclaim) {
603 pp_max_retr = fp->sf_max_retr;
604 pa_max_retr = sctp->sctp_pa_max_rxt;
605 } else {
606 /* App may have set a very aggressive retransmission limit. */
607 pp_max_retr = MIN(sctp_pp_early_abort, fp->sf_max_retr);
608 pa_max_retr = MIN(sctp_pa_early_abort, sctp->sctp_pa_max_rxt);
609 }
610
611 /* Check is we've reached the max for retries */
612 if (sctp->sctp_state < SCTPS_ESTABLISHED) {
613 if (fp->sf_strikes >= sctp->sctp_max_init_rxt) {
614 /* time to give up */
615 SCTPS_BUMP_MIB(sctps, sctpAborted);
616 SCTPS_BUMP_MIB(sctps, sctpTimRetransDrop);
617 sctp_assoc_event(sctp, SCTP_CANT_STR_ASSOC, 0, NULL);
618 sctp_clean_death(sctp, sctp->sctp_client_errno ?
619 sctp->sctp_client_errno : ETIMEDOUT);
620 return;
621 }
622 } else if (sctp->sctp_state >= SCTPS_ESTABLISHED) {
623 if (sctp->sctp_strikes >= pa_max_retr) {
624 /* time to give up */
625 SCTPS_BUMP_MIB(sctps, sctpAborted);
626 SCTPS_BUMP_MIB(sctps, sctpTimRetransDrop);
627 sctp_assoc_event(sctp, SCTP_COMM_LOST, 0, NULL);
628 sctp_clean_death(sctp, sctp->sctp_client_errno ?
629 sctp->sctp_client_errno : ETIMEDOUT);
630 return;
631 }
632 }
633
634 if (fp->sf_strikes >= pp_max_retr) {
635 if (sctp_faddr_dead(sctp, fp, SCTP_FADDRS_DOWN) == -1) {
636 return;
637 }
638 }
639
640 switch (sctp->sctp_state) {
641 case SCTPS_SHUTDOWN_RECEIVED:
642 (void) sctp_shutdown_received(sctp, NULL, B_FALSE, B_TRUE,
643 NULL);
644
645 /* FALLTHRU */
646 case SCTPS_ESTABLISHED:
647 case SCTPS_SHUTDOWN_PENDING:
648 if (sctp->sctp_xmit_head == NULL &&
649 sctp->sctp_xmit_unsent == NULL) {
650 /* Nothing to retransmit */
651 if (sctp->sctp_state == SCTPS_SHUTDOWN_PENDING) {
652 sctp_send_shutdown(sctp, 1);
653 }
654 return;
655 }
656
657 SCTPS_BUMP_MIB(sctps, sctpTimRetrans);
658
659 sctp_rexmit(sctp, fp);
660 /*
661 * sctp_rexmit() will increase the strikes and restart the
662 * timer, so return here.
663 */
664 return;
665 case SCTPS_COOKIE_WAIT:
666 BUMP_LOCAL(sctp->sctp_T1expire);
667 rxmit_init:
668 /* retransmit init */
669 /*
670 * We don't take the conn hash lock here since the source
671 * address list won't be modified (it would have been done
672 * the first time around).
673 */
674 mp = sctp_init_mp(sctp, fp);
675 if (mp != NULL) {
676 SCTPS_BUMP_MIB(sctps, sctpTimRetrans);
677 (void) conn_ip_output(mp, fp->sf_ixa);
678 BUMP_LOCAL(sctp->sctp_opkts);
679 }
680 rto_max = sctp->sctp_rto_max_init;
681 break;
682 case SCTPS_COOKIE_ECHOED:
683 BUMP_LOCAL(sctp->sctp_T1expire);
684 if (sctp->sctp_cookie_mp == NULL) {
685 sctp->sctp_state = SCTPS_COOKIE_WAIT;
686 goto rxmit_init;
687 }
688 mp = dupmsg(sctp->sctp_cookie_mp);
689 if (mp == NULL)
690 break;
691 (void) conn_ip_output(mp, fp->sf_ixa);
692 BUMP_LOCAL(sctp->sctp_opkts);
693 SCTPS_BUMP_MIB(sctps, sctpTimRetrans);
694 rto_max = sctp->sctp_rto_max_init;
695 break;
696 case SCTPS_SHUTDOWN_SENT:
697 BUMP_LOCAL(sctp->sctp_T2expire);
698 sctp_send_shutdown(sctp, 1);
699 SCTPS_BUMP_MIB(sctps, sctpTimRetrans);
700 break;
701 case SCTPS_SHUTDOWN_ACK_SENT:
702 /* We shouldn't have any more outstanding data */
703 ASSERT(sctp->sctp_xmit_head == NULL);
704 ASSERT(sctp->sctp_xmit_unsent == NULL);
705
706 BUMP_LOCAL(sctp->sctp_T2expire);
707 (void) sctp_shutdown_received(sctp, NULL, B_FALSE, B_TRUE,
708 NULL);
709 SCTPS_BUMP_MIB(sctps, sctpTimRetrans);
710 break;
711 default:
712 ASSERT(0);
713 break;
714 }
715
716 fp->sf_strikes++;
717 sctp->sctp_strikes++;
718 SCTP_CALC_RXT(sctp, fp, rto_max);
719
720 SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto);
721 }
722
723 /*
724 * RTO calculation. timesent and now are both in ms.
725 */
726 void
sctp_update_rtt(sctp_t * sctp,sctp_faddr_t * fp,clock_t delta)727 sctp_update_rtt(sctp_t *sctp, sctp_faddr_t *fp, clock_t delta)
728 {
729 int rtt;
730
731 /* Calculate the RTT in ms */
732 rtt = (int)delta;
733 rtt = rtt > 0 ? rtt : 1;
734
735 dprint(5, ("sctp_update_rtt: fp = %p, rtt = %d\n", (void *)fp, rtt));
736
737 /* Is this the first RTT measurement? */
738 if (fp->sf_srtt == -1) {
739 fp->sf_srtt = rtt;
740 fp->sf_rttvar = rtt / 2;
741 fp->sf_rto = 3 * rtt; /* == rtt + 4 * rttvar ( == rtt / 2) */
742 } else {
743 int abs;
744 /*
745 * Versions of the RTO equations that use fixed-point math.
746 * alpha and beta are NOT tunable in this implementation,
747 * and so are hard-coded in. alpha = 1/8, beta = 1/4.
748 */
749 abs = fp->sf_srtt - rtt;
750 abs = abs >= 0 ? abs : -abs;
751 fp->sf_rttvar = (3 * fp->sf_rttvar + abs) >> 2;
752 fp->sf_rttvar = fp->sf_rttvar != 0 ? fp->sf_rttvar : 1;
753
754 fp->sf_srtt = (7 * fp->sf_srtt + rtt) >> 3;
755 fp->sf_rto = fp->sf_srtt + 4 * fp->sf_rttvar;
756 }
757
758 dprint(5, ("sctp_update_rtt: srtt = %d, rttvar = %d, rto = %d\n",
759 fp->sf_srtt, fp->sf_rttvar, fp->sf_rto));
760
761 /* Bound the RTO by configured min and max values */
762 if (fp->sf_rto < sctp->sctp_rto_min) {
763 fp->sf_rto = sctp->sctp_rto_min;
764 }
765 if (fp->sf_rto > sctp->sctp_rto_max) {
766 fp->sf_rto = sctp->sctp_rto_max;
767 }
768
769 SCTP_MAX_RTO(sctp, fp);
770 fp->sf_rtt_updates++;
771 }
772
773 void
sctp_free_faddr_timers(sctp_t * sctp)774 sctp_free_faddr_timers(sctp_t *sctp)
775 {
776 sctp_faddr_t *fp;
777
778 for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) {
779 if (fp->sf_timer_mp != NULL) {
780 sctp_timer_free(fp->sf_timer_mp);
781 fp->sf_timer_mp = NULL;
782 fp->sf_timer_running = 0;
783 }
784 if (fp->sf_rc_timer_mp != NULL) {
785 sctp_timer_free(fp->sf_rc_timer_mp);
786 fp->sf_rc_timer_mp = NULL;
787 fp->sf_rc_timer_running = 0;
788 }
789 }
790 }
791
792 void
sctp_stop_faddr_timers(sctp_t * sctp)793 sctp_stop_faddr_timers(sctp_t *sctp)
794 {
795 sctp_faddr_t *fp;
796
797 for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) {
798 SCTP_FADDR_TIMER_STOP(fp);
799 SCTP_FADDR_RC_TIMER_STOP(fp);
800 }
801 }
802
803 void
sctp_process_timer(sctp_t * sctp)804 sctp_process_timer(sctp_t *sctp)
805 {
806 mblk_t *mp;
807
808 ASSERT(sctp->sctp_running);
809 ASSERT(MUTEX_HELD(&sctp->sctp_lock));
810 while ((mp = sctp->sctp_timer_mp) != NULL) {
811 ASSERT(DB_TYPE(mp) == M_PCSIG);
812 /*
813 * Since the timer mblk can be freed in sctp_timer_call(),
814 * we need to grab the b_cont before that.
815 */
816 sctp->sctp_timer_mp = mp->b_cont;
817 mp->b_cont = NULL;
818 /*
819 * We have a reference on the sctp, the lock must be
820 * dropped to avoid deadlocks with functions potentially
821 * called in this context which in turn call untimeout().
822 */
823 mutex_exit(&sctp->sctp_lock);
824 sctp_timer_call(sctp, mp);
825 mutex_enter(&sctp->sctp_lock);
826 }
827 SCTP_REFRELE(sctp);
828 }
829