/* * CDDL HEADER START * * The contents of this file are subject to the terms of the * Common Development and Distribution License (the "License"). * You may not use this file except in compliance with the License. * * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE * or http://www.opensolaris.org/os/licensing. * See the License for the specific language governing permissions * and limitations under the License. * * When distributing Covered Code, include this CDDL HEADER in each * file and include the License file at usr/src/OPENSOLARIS.LICENSE. * If applicable, add the following below this CDDL HEADER, with the * fields enclosed by brackets "[]" replaced with your own identifying * information: Portions Copyright [yyyy] [name of copyright owner] * * CDDL HEADER END */ /* * Copyright (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. */ #include #include #include #include #include #include #include #include #include #include #include #include #include "sctp_impl.h" #include "sctp_asconf.h" /* Timer block states. */ typedef enum { SCTP_TB_RUNNING = 1, SCTP_TB_IDLE, /* Could not stop/free before mblk got queued */ SCTP_TB_RESCHED, /* sctp_tb_time_left contains tick count */ SCTP_TB_CANCELLED, SCTP_TB_TO_BE_FREED } timer_block_state; typedef struct sctp_tb_s { timer_block_state sctp_tb_state; timeout_id_t sctp_tb_tid; mblk_t *sctp_tb_mp; clock_t sctp_tb_time_left; } sctp_tb_t; /* * Early abort threshold when the system is under pressure, sctps_reclaim * is on. * * sctp_pa_early_abort: number of strikes per association before abort * sctp_pp_early_abort: number of strikes per peer address before abort */ uint32_t sctp_pa_early_abort = 5; uint32_t sctp_pp_early_abort = 3; static void sctp_timer_fire(sctp_tb_t *); /* * sctp_timer mechanism. * * Each timer is represented by a timer mblk. When the * timer fires, and the sctp_t is busy, the timer mblk will be put on * the associated sctp_t timer queue so that it can be executed when * the thread holding the lock on the sctp_t is done with its job. * * Note that there is no lock to protect the timer mblk state. The reason * is that the timer state can only be changed by a thread holding the * lock on the sctp_t. * * The interface consists of 4 entry points: * sctp_timer_alloc - create a timer mblk * sctp_timer_free - free a timer mblk * sctp_timer - start, restart, stop the timer * sctp_timer_valid - called by sctp_process_recvq to verify that * the timer did indeed fire. */ /* * Start, restart, stop the timer. * If "tim" is -1 the timer is stopped. * Otherwise, the timer is stopped if it is already running, and * set to fire tim clock ticks from now. */ void sctp_timer(sctp_t *sctp, mblk_t *mp, clock_t tim) { sctp_tb_t *sctp_tb; int state; ASSERT(sctp != NULL && mp != NULL); ASSERT((mp->b_rptr - mp->b_datap->db_base) == sizeof (sctp_tb_t)); ASSERT(mp->b_datap->db_type == M_PCSIG); sctp_tb = (sctp_tb_t *)mp->b_datap->db_base; if (tim >= 0) { state = sctp_tb->sctp_tb_state; sctp_tb->sctp_tb_time_left = tim; if (state == SCTP_TB_RUNNING) { if (untimeout(sctp_tb->sctp_tb_tid) < 0) { sctp_tb->sctp_tb_state = SCTP_TB_RESCHED; /* sctp_timer_valid will start timer */ return; } } else if (state != SCTP_TB_IDLE) { ASSERT(state != SCTP_TB_TO_BE_FREED); if (state == SCTP_TB_CANCELLED) { sctp_tb->sctp_tb_state = SCTP_TB_RESCHED; /* sctp_timer_valid will start timer */ return; } if (state == SCTP_TB_RESCHED) { /* sctp_timer_valid will start timer */ return; } } else { SCTP_REFHOLD(sctp); } sctp_tb->sctp_tb_state = SCTP_TB_RUNNING; sctp_tb->sctp_tb_tid = timeout((pfv_t)sctp_timer_fire, sctp_tb, tim); return; } switch (tim) { case -1: sctp_timer_stop(mp); break; default: ASSERT(0); break; } } /* * sctp_timer_alloc is called by sctp_init to allocate and initialize a * sctp timer. * * Allocate an M_PCSIG timer message. The space between db_base and * b_rptr is used by the sctp_timer mechanism, and after b_rptr there is * space for sctpt_t. */ mblk_t * sctp_timer_alloc(sctp_t *sctp, pfv_t func, int sleep) { mblk_t *mp; sctp_tb_t *sctp_tb; sctpt_t *sctpt; sctp_stack_t *sctps = sctp->sctp_sctps; if (sleep == KM_SLEEP) { mp = allocb_wait(sizeof (sctp_t) + sizeof (sctp_tb_t), BPRI_HI, STR_NOSIG, NULL); } else { mp = allocb(sizeof (sctp_t) + sizeof (sctp_tb_t), BPRI_HI); } if (mp != NULL) { mp->b_datap->db_type = M_PCSIG; sctp_tb = (sctp_tb_t *)mp->b_datap->db_base; mp->b_rptr = (uchar_t *)&sctp_tb[1]; mp->b_wptr = mp->b_rptr + sizeof (sctpt_t); sctp_tb->sctp_tb_state = SCTP_TB_IDLE; sctp_tb->sctp_tb_mp = mp; sctpt = (sctpt_t *)mp->b_rptr; sctpt->sctpt_sctp = sctp; sctpt->sctpt_faddr = NULL; /* set when starting timer */ sctpt->sctpt_pfv = func; return (mp); } SCTP_KSTAT(sctps, sctp_add_timer); return (NULL); } /* * timeout() callback function. * Put the message on the process control block's queue. * If the timer is stopped or freed after * it has fired then sctp_timer() and sctp_timer_valid() will clean * things up. */ static void sctp_timer_fire(sctp_tb_t *sctp_tb) { mblk_t *mp; sctp_t *sctp; sctpt_t *sctpt; mp = sctp_tb->sctp_tb_mp; ASSERT(sctp_tb == (sctp_tb_t *)mp->b_datap->db_base); ASSERT(mp->b_datap->db_type == M_PCSIG); sctpt = (sctpt_t *)mp->b_rptr; sctp = sctpt->sctpt_sctp; ASSERT(sctp != NULL); mutex_enter(&sctp->sctp_lock); if (sctp->sctp_running) { /* * Put the timer mblk to the special sctp_timer_mp list. * This timer will be handled when the thread using this * SCTP is done with its job. */ if (sctp->sctp_timer_mp == NULL) { SCTP_REFHOLD(sctp); sctp->sctp_timer_mp = mp; } else { linkb(sctp->sctp_timer_mp, mp); } mp->b_cont = NULL; mutex_exit(&sctp->sctp_lock); } else { sctp->sctp_running = B_TRUE; mutex_exit(&sctp->sctp_lock); sctp_timer_call(sctp, mp); WAKE_SCTP(sctp); } SCTP_REFRELE(sctp); } /* * Logically free a timer mblk (that might have a pending timeout().) * If the timer has fired and the mblk has been put on the queue then * sctp_timer_valid will free the mblk. */ void sctp_timer_free(mblk_t *mp) { sctp_tb_t *sctp_tb; int state; sctpt_t *sctpt; ASSERT(mp != NULL); ASSERT((mp->b_rptr - mp->b_datap->db_base) == sizeof (sctp_tb_t)); ASSERT(mp->b_datap->db_type == M_PCSIG); sctp_tb = (sctp_tb_t *)mp->b_datap->db_base; state = sctp_tb->sctp_tb_state; dprint(5, ("sctp_timer_free %p state %d\n", (void *)mp, state)); if (state == SCTP_TB_RUNNING) { if (untimeout(sctp_tb->sctp_tb_tid) < 0) { sctp_tb->sctp_tb_state = SCTP_TB_TO_BE_FREED; /* sctp_timer_valid will free the mblk */ return; } sctpt = (sctpt_t *)mp->b_rptr; SCTP_REFRELE(sctpt->sctpt_sctp); } else if (state != SCTP_TB_IDLE) { ASSERT(state != SCTP_TB_TO_BE_FREED); sctp_tb->sctp_tb_state = SCTP_TB_TO_BE_FREED; /* sctp_timer_valid will free the mblk */ return; } freeb(mp); } /* * Called from sctp_timer(,,-1) */ void sctp_timer_stop(mblk_t *mp) { sctp_tb_t *sctp_tb; int state; sctpt_t *sctpt; ASSERT(mp != NULL); ASSERT(mp->b_datap->db_type == M_PCSIG); sctp_tb = (sctp_tb_t *)mp->b_datap->db_base; state = sctp_tb->sctp_tb_state; dprint(5, ("sctp_timer_stop %p %d\n", (void *)mp, state)); if (state == SCTP_TB_RUNNING) { if (untimeout(sctp_tb->sctp_tb_tid) < 0) { sctp_tb->sctp_tb_state = SCTP_TB_CANCELLED; } else { sctp_tb->sctp_tb_state = SCTP_TB_IDLE; sctpt = (sctpt_t *)mp->b_rptr; SCTP_REFRELE(sctpt->sctpt_sctp); } } else if (state == SCTP_TB_RESCHED) { sctp_tb->sctp_tb_state = SCTP_TB_CANCELLED; } } /* * The user of the sctp_timer mechanism is required to call * sctp_timer_valid() for each M_PCSIG message processed in the * service procedures. * sctp_timer_valid will return "true" if the timer actually did fire. */ static boolean_t sctp_timer_valid(mblk_t *mp) { sctp_tb_t *sctp_tb; int state; sctpt_t *sctpt; ASSERT(mp != NULL); ASSERT(mp->b_datap->db_type == M_PCSIG); sctp_tb = (sctp_tb_t *)DB_BASE(mp); sctpt = (sctpt_t *)mp->b_rptr; state = sctp_tb->sctp_tb_state; if (state != SCTP_TB_RUNNING) { ASSERT(state != SCTP_TB_IDLE); if (state == SCTP_TB_TO_BE_FREED) { /* * sctp_timer_free was called after the message * was putq'ed. */ freeb(mp); return (B_FALSE); } if (state == SCTP_TB_CANCELLED) { /* The timer was stopped after the mblk was putq'ed */ sctp_tb->sctp_tb_state = SCTP_TB_IDLE; return (B_FALSE); } if (state == SCTP_TB_RESCHED) { /* * The timer was stopped and then restarted after * the mblk was putq'ed. * sctp_tb_time_left contains the number of ticks that * the timer was restarted with. * The sctp will not be disapper between the time * the sctpt_t is marked SCTP_TB_RESCHED and when * we get here as sctp_add_recvq() does a refhold. */ sctp_tb->sctp_tb_state = SCTP_TB_RUNNING; sctp_tb->sctp_tb_tid = timeout((pfv_t)sctp_timer_fire, sctp_tb, sctp_tb->sctp_tb_time_left); SCTP_REFHOLD(sctpt->sctpt_sctp); return (B_FALSE); } } sctp_tb->sctp_tb_state = SCTP_TB_IDLE; return (B_TRUE); } /* * The SCTP timer call. Calls sctp_timer_valid() to verify whether * timer was cancelled or not. */ void sctp_timer_call(sctp_t *sctp, mblk_t *mp) { sctpt_t *sctpt = (sctpt_t *)mp->b_rptr; if (sctp_timer_valid(mp)) { (*sctpt->sctpt_pfv)(sctp, sctpt->sctpt_faddr); } } /* * Delayed ack */ void sctp_ack_timer(sctp_t *sctp) { sctp_stack_t *sctps = sctp->sctp_sctps; sctp->sctp_ack_timer_running = 0; sctp->sctp_sack_toggle = sctps->sctps_deferred_acks_max; SCTPS_BUMP_MIB(sctps, sctpOutAckDelayed); (void) sctp_sack(sctp, NULL); } /* * Peer address heartbeat timer handler */ void sctp_heartbeat_timer(sctp_t *sctp) { sctp_faddr_t *fp; int64_t now; int64_t earliest_expiry; int cnt; sctp_stack_t *sctps = sctp->sctp_sctps; int pp_max_retr; if (sctp->sctp_strikes >= sctp->sctp_pa_max_rxt) { /* * If there is a peer address with no strikes, don't give up * yet unless we are under memory pressure. If enough other * peer address are down, we could otherwise fail the * association prematurely. This is a byproduct of our * aggressive probe approach when a heartbeat fails to * connect. We may wish to revisit this... */ if (sctps->sctps_reclaim || !sctp_is_a_faddr_clean(sctp)) { /* time to give up */ SCTPS_BUMP_MIB(sctps, sctpAborted); SCTPS_BUMP_MIB(sctps, sctpTimHeartBeatDrop); sctp_assoc_event(sctp, SCTP_COMM_LOST, 0, NULL); sctp_clean_death(sctp, sctp->sctp_client_errno ? sctp->sctp_client_errno : ETIMEDOUT); return; } } /* Only send heartbeats in the established state */ if (sctp->sctp_state != SCTPS_ESTABLISHED) { dprint(5, ("sctp_heartbeat_timer: not in ESTABLISHED\n")); return; } now = ddi_get_lbolt64(); earliest_expiry = 0; cnt = sctps->sctps_maxburst; /* * Walk through all faddrs. Since the timer should run infrequently * and the number of peer addresses should not be big, this should * be OK. */ for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) { if (sctps->sctps_reclaim) pp_max_retr = MIN(sctp_pp_early_abort, fp->sf_max_retr); else pp_max_retr = fp->sf_max_retr; /* * If the peer is unreachable because there is no available * source address, call sctp_get_dest() to see if it is * reachable now. If it is OK, the state will become * unconfirmed. And the following code to handle unconfirmed * address will be executed. If it is still not OK, * re-schedule. If heartbeat is enabled, only try this * up to the normal heartbeat max times. But if heartbeat * is disable, this retry may go on forever. */ if (fp->sf_state == SCTP_FADDRS_UNREACH) { sctp_get_dest(sctp, fp); if (fp->sf_state == SCTP_FADDRS_UNREACH) { if (fp->sf_hb_enabled && ++fp->sf_strikes > pp_max_retr && sctp_faddr_dead(sctp, fp, SCTP_FADDRS_DOWN) == -1) { /* Assoc is dead */ return; } fp->sf_hb_expiry = now + SET_HB_INTVL(fp); goto set_expiry; } else { /* Send a heartbeat immediately. */ fp->sf_hb_expiry = now; } } /* * Don't send heartbeat to this address if it is not * hb_enabled and the address has been confirmed. */ if (!fp->sf_hb_enabled && fp->sf_state != SCTP_FADDRS_UNCONFIRMED) { continue; } /* * The heartbeat timer is expired. If the address is dead, * we still send heartbeat to it in case it becomes alive * again. But we will only send once in a while, calculated * by SET_HB_INTVL(). * * If the address is alive and there is a hearbeat pending, * resend the heartbeat and start exponential backoff on the * heartbeat timeout value. If there is no heartbeat pending, * just send out one. */ if (now >= fp->sf_hb_expiry) { if (fp->sf_hb_pending) { /* * If an address is not confirmed, no need * to bump the overall counter as it doesn't * matter as we will not use it to send data * and it should not affect the association. */ switch (fp->sf_state) { case SCTP_FADDRS_ALIVE: sctp->sctp_strikes++; /* FALLTHRU */ case SCTP_FADDRS_UNCONFIRMED: /* * Retransmission implies that RTO * is probably not correct. */ fp->sf_rtt_updates = 0; fp->sf_strikes++; if (fp->sf_strikes > pp_max_retr) { if (sctp_faddr_dead(sctp, fp, SCTP_FADDRS_DOWN) == -1) { /* Assoc is dead */ return; } /* * Addr is down; keep initial * RTO */ fp->sf_rto = sctp->sctp_rto_initial; goto dead_addr; } else { SCTP_CALC_RXT(sctp, fp, sctp->sctp_rto_max); fp->sf_hb_expiry = now + fp->sf_rto; } break; case SCTP_FADDRS_DOWN: dead_addr: fp->sf_hb_expiry = now + SET_HB_INTVL(fp); break; default: continue; } } else { /* * If there is unack'ed data, no need to * send a heart beat. */ if (fp->sf_suna > 0) { fp->sf_hb_expiry = now + SET_HB_INTVL(fp); goto set_expiry; } else { fp->sf_hb_expiry = now + fp->sf_rto; } } /* * Note that the total number of heartbeat we can send * out simultaneously is limited by sctp_maxburst. If * the limit is exceeded, we need to wait for the next * timeout to send them. This should only happen if * there is unconfirmed address. Note that hb_pending * is set in sctp_send_heartbeat(). So if a heartbeat * is not sent, it will not affect the state of the * peer address. */ if (fp->sf_state != SCTP_FADDRS_UNCONFIRMED || cnt-- > 0) sctp_send_heartbeat(sctp, fp); } set_expiry: if (fp->sf_hb_expiry < earliest_expiry || earliest_expiry == 0) earliest_expiry = fp->sf_hb_expiry; } if (sctp->sctp_autoclose != 0) { int64_t expire; expire = sctp->sctp_active + sctp->sctp_autoclose; if (expire <= now) { dprint(3, ("sctp_heartbeat_timer: autoclosing\n")); sctp_send_shutdown(sctp, 0); return; } if (expire < earliest_expiry || earliest_expiry == 0) earliest_expiry = expire; } earliest_expiry -= now; if (earliest_expiry < 0) earliest_expiry = 1; sctp_timer(sctp, sctp->sctp_heartbeat_mp, earliest_expiry); } void sctp_rexmit_timer(sctp_t *sctp, sctp_faddr_t *fp) { mblk_t *mp; uint32_t rto_max = sctp->sctp_rto_max; sctp_stack_t *sctps = sctp->sctp_sctps; int pp_max_retr, pa_max_retr; ASSERT(fp != NULL); dprint(3, ("sctp_timer: faddr=%x:%x:%x:%x\n", SCTP_PRINTADDR(fp->sf_faddr))); fp->sf_timer_running = 0; if (!sctps->sctps_reclaim) { pp_max_retr = fp->sf_max_retr; pa_max_retr = sctp->sctp_pa_max_rxt; } else { /* App may have set a very aggressive retransmission limit. */ pp_max_retr = MIN(sctp_pp_early_abort, fp->sf_max_retr); pa_max_retr = MIN(sctp_pa_early_abort, sctp->sctp_pa_max_rxt); } /* Check is we've reached the max for retries */ if (sctp->sctp_state < SCTPS_ESTABLISHED) { if (fp->sf_strikes >= sctp->sctp_max_init_rxt) { /* time to give up */ SCTPS_BUMP_MIB(sctps, sctpAborted); SCTPS_BUMP_MIB(sctps, sctpTimRetransDrop); sctp_assoc_event(sctp, SCTP_CANT_STR_ASSOC, 0, NULL); sctp_clean_death(sctp, sctp->sctp_client_errno ? sctp->sctp_client_errno : ETIMEDOUT); return; } } else if (sctp->sctp_state >= SCTPS_ESTABLISHED) { if (sctp->sctp_strikes >= pa_max_retr) { /* time to give up */ SCTPS_BUMP_MIB(sctps, sctpAborted); SCTPS_BUMP_MIB(sctps, sctpTimRetransDrop); sctp_assoc_event(sctp, SCTP_COMM_LOST, 0, NULL); sctp_clean_death(sctp, sctp->sctp_client_errno ? sctp->sctp_client_errno : ETIMEDOUT); return; } } if (fp->sf_strikes >= pp_max_retr) { if (sctp_faddr_dead(sctp, fp, SCTP_FADDRS_DOWN) == -1) { return; } } switch (sctp->sctp_state) { case SCTPS_SHUTDOWN_RECEIVED: (void) sctp_shutdown_received(sctp, NULL, B_FALSE, B_TRUE, NULL); /* FALLTHRU */ case SCTPS_ESTABLISHED: case SCTPS_SHUTDOWN_PENDING: if (sctp->sctp_xmit_head == NULL && sctp->sctp_xmit_unsent == NULL) { /* Nothing to retransmit */ if (sctp->sctp_state == SCTPS_SHUTDOWN_PENDING) { sctp_send_shutdown(sctp, 1); } return; } SCTPS_BUMP_MIB(sctps, sctpTimRetrans); sctp_rexmit(sctp, fp); /* * sctp_rexmit() will increase the strikes and restart the * timer, so return here. */ return; case SCTPS_COOKIE_WAIT: BUMP_LOCAL(sctp->sctp_T1expire); rxmit_init: /* retransmit init */ /* * We don't take the conn hash lock here since the source * address list won't be modified (it would have been done * the first time around). */ mp = sctp_init_mp(sctp, fp); if (mp != NULL) { SCTPS_BUMP_MIB(sctps, sctpTimRetrans); (void) conn_ip_output(mp, fp->sf_ixa); BUMP_LOCAL(sctp->sctp_opkts); } rto_max = sctp->sctp_rto_max_init; break; case SCTPS_COOKIE_ECHOED: BUMP_LOCAL(sctp->sctp_T1expire); if (sctp->sctp_cookie_mp == NULL) { sctp->sctp_state = SCTPS_COOKIE_WAIT; goto rxmit_init; } mp = dupmsg(sctp->sctp_cookie_mp); if (mp == NULL) break; (void) conn_ip_output(mp, fp->sf_ixa); BUMP_LOCAL(sctp->sctp_opkts); SCTPS_BUMP_MIB(sctps, sctpTimRetrans); rto_max = sctp->sctp_rto_max_init; break; case SCTPS_SHUTDOWN_SENT: BUMP_LOCAL(sctp->sctp_T2expire); sctp_send_shutdown(sctp, 1); SCTPS_BUMP_MIB(sctps, sctpTimRetrans); break; case SCTPS_SHUTDOWN_ACK_SENT: /* We shouldn't have any more outstanding data */ ASSERT(sctp->sctp_xmit_head == NULL); ASSERT(sctp->sctp_xmit_unsent == NULL); BUMP_LOCAL(sctp->sctp_T2expire); (void) sctp_shutdown_received(sctp, NULL, B_FALSE, B_TRUE, NULL); SCTPS_BUMP_MIB(sctps, sctpTimRetrans); break; default: ASSERT(0); break; } fp->sf_strikes++; sctp->sctp_strikes++; SCTP_CALC_RXT(sctp, fp, rto_max); SCTP_FADDR_TIMER_RESTART(sctp, fp, fp->sf_rto); } /* * RTO calculation. timesent and now are both in ms. */ void sctp_update_rtt(sctp_t *sctp, sctp_faddr_t *fp, clock_t delta) { int rtt; /* Calculate the RTT in ms */ rtt = (int)delta; rtt = rtt > 0 ? rtt : 1; dprint(5, ("sctp_update_rtt: fp = %p, rtt = %d\n", (void *)fp, rtt)); /* Is this the first RTT measurement? */ if (fp->sf_srtt == -1) { fp->sf_srtt = rtt; fp->sf_rttvar = rtt / 2; fp->sf_rto = 3 * rtt; /* == rtt + 4 * rttvar ( == rtt / 2) */ } else { int abs; /* * Versions of the RTO equations that use fixed-point math. * alpha and beta are NOT tunable in this implementation, * and so are hard-coded in. alpha = 1/8, beta = 1/4. */ abs = fp->sf_srtt - rtt; abs = abs >= 0 ? abs : -abs; fp->sf_rttvar = (3 * fp->sf_rttvar + abs) >> 2; fp->sf_rttvar = fp->sf_rttvar != 0 ? fp->sf_rttvar : 1; fp->sf_srtt = (7 * fp->sf_srtt + rtt) >> 3; fp->sf_rto = fp->sf_srtt + 4 * fp->sf_rttvar; } dprint(5, ("sctp_update_rtt: srtt = %d, rttvar = %d, rto = %d\n", fp->sf_srtt, fp->sf_rttvar, fp->sf_rto)); /* Bound the RTO by configured min and max values */ if (fp->sf_rto < sctp->sctp_rto_min) { fp->sf_rto = sctp->sctp_rto_min; } if (fp->sf_rto > sctp->sctp_rto_max) { fp->sf_rto = sctp->sctp_rto_max; } SCTP_MAX_RTO(sctp, fp); fp->sf_rtt_updates++; } void sctp_free_faddr_timers(sctp_t *sctp) { sctp_faddr_t *fp; for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) { if (fp->sf_timer_mp != NULL) { sctp_timer_free(fp->sf_timer_mp); fp->sf_timer_mp = NULL; fp->sf_timer_running = 0; } if (fp->sf_rc_timer_mp != NULL) { sctp_timer_free(fp->sf_rc_timer_mp); fp->sf_rc_timer_mp = NULL; fp->sf_rc_timer_running = 0; } } } void sctp_stop_faddr_timers(sctp_t *sctp) { sctp_faddr_t *fp; for (fp = sctp->sctp_faddrs; fp != NULL; fp = fp->sf_next) { SCTP_FADDR_TIMER_STOP(fp); SCTP_FADDR_RC_TIMER_STOP(fp); } } void sctp_process_timer(sctp_t *sctp) { mblk_t *mp; ASSERT(sctp->sctp_running); ASSERT(MUTEX_HELD(&sctp->sctp_lock)); while ((mp = sctp->sctp_timer_mp) != NULL) { ASSERT(DB_TYPE(mp) == M_PCSIG); /* * Since the timer mblk can be freed in sctp_timer_call(), * we need to grab the b_cont before that. */ sctp->sctp_timer_mp = mp->b_cont; mp->b_cont = NULL; /* * We have a reference on the sctp, the lock must be * dropped to avoid deadlocks with functions potentially * called in this context which in turn call untimeout(). */ mutex_exit(&sctp->sctp_lock); sctp_timer_call(sctp, mp); mutex_enter(&sctp->sctp_lock); } SCTP_REFRELE(sctp); }