inet/sctp/sctp_misc.c

/*
 * 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) 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/types.h>
#include <inet/common.h>
#include "sctp_impl.h"

/* Control whether SCTP can enter defensive mode when under memory pressure. */
static boolean_t sctp_do_reclaim = B_TRUE;

static void sctp_reclaim_timer(void *);

/* Diagnostic routine used to return a string associated with the sctp state. */
char *
sctp_display(sctp_t *sctp, char *sup_buf)
{
    char    *buf;
    char    buf1[30];
    static char priv_buf[INET6_ADDRSTRLEN * 2 + 80];
    char    *cp;
    conn_t  *connp;

    if (sctp == NULL)
        return ("NULL_SCTP");

    connp = sctp->sctp_connp;
    buf = (sup_buf != NULL) ? sup_buf : priv_buf;

    switch (sctp->sctp_state) {
    case SCTPS_IDLE:
        cp = "SCTP_IDLE";
        break;
    case SCTPS_BOUND:
        cp = "SCTP_BOUND";
        break;
    case SCTPS_LISTEN:
        cp = "SCTP_LISTEN";
        break;
    case SCTPS_COOKIE_WAIT:
        cp = "SCTP_COOKIE_WAIT";
        break;
    case SCTPS_COOKIE_ECHOED:
        cp = "SCTP_COOKIE_ECHOED";
        break;
    case SCTPS_ESTABLISHED:
        cp = "SCTP_ESTABLISHED";
        break;
    case SCTPS_SHUTDOWN_PENDING:
        cp = "SCTP_SHUTDOWN_PENDING";
        break;
    case SCTPS_SHUTDOWN_SENT:
        cp = "SCTPS_SHUTDOWN_SENT";
        break;
    case SCTPS_SHUTDOWN_RECEIVED:
        cp = "SCTPS_SHUTDOWN_RECEIVED";
        break;
    case SCTPS_SHUTDOWN_ACK_SENT:
        cp = "SCTPS_SHUTDOWN_ACK_SENT";
        break;
    default:
        (void) mi_sprintf(buf1, "SCTPUnkState(%d)", sctp->sctp_state);
        cp = buf1;
        break;
    }
    (void) mi_sprintf(buf, "[%u, %u] %s",
        ntohs(connp->conn_lport), ntohs(connp->conn_fport), cp);

    return (buf);
}

void
sctp_display_all(sctp_stack_t *sctps)
{
    sctp_t *sctp_walker;

    mutex_enter(&sctps->sctps_g_lock);
    for (sctp_walker = list_head(&sctps->sctps_g_list);
        sctp_walker != NULL;
        sctp_walker = (sctp_t *)list_next(&sctps->sctps_g_list,
        sctp_walker)) {
        (void) sctp_display(sctp_walker, NULL);
    }
    mutex_exit(&sctps->sctps_g_lock);
}

/*
 * Given a sctp_stack_t and a port (in host byte order), find a listener
 * configuration for that port and return the ratio.
 */
uint32_t
sctp_find_listener_conf(sctp_stack_t *sctps, in_port_t port)
{
    sctp_listener_t *sl;
    uint32_t ratio = 0;

    mutex_enter(&sctps->sctps_listener_conf_lock);
    for (sl = list_head(&sctps->sctps_listener_conf); sl != NULL;
        sl = list_next(&sctps->sctps_listener_conf, sl)) {
        if (sl->sl_port == port) {
            ratio = sl->sl_ratio;
            break;
        }
    }
    mutex_exit(&sctps->sctps_listener_conf_lock);
    return (ratio);
}

/*
 * To remove all listener limit configuration in a sctp_stack_t.
 */
void
sctp_listener_conf_cleanup(sctp_stack_t *sctps)
{
    sctp_listener_t *sl;

    mutex_enter(&sctps->sctps_listener_conf_lock);
    while ((sl = list_head(&sctps->sctps_listener_conf)) != NULL) {
        list_remove(&sctps->sctps_listener_conf, sl);
        kmem_free(sl, sizeof (sctp_listener_t));
    }
    mutex_destroy(&sctps->sctps_listener_conf_lock);
    list_destroy(&sctps->sctps_listener_conf);
}


/*
 * Timeout function to reset the SCTP stack variable sctps_reclaim to false.
 */
static void
sctp_reclaim_timer(void *arg)
{
    sctp_stack_t *sctps = (sctp_stack_t *)arg;
    int64_t tot_assoc = 0;
    int i;
    extern pgcnt_t lotsfree, needfree;

    for (i = 0; i < sctps->sctps_sc_cnt; i++)
        tot_assoc += sctps->sctps_sc[i]->sctp_sc_assoc_cnt;

    /*
     * This happens only when a stack is going away.  sctps_reclaim_tid
     * should not be reset to 0 when returning in this case.
     */
    mutex_enter(&sctps->sctps_reclaim_lock);
    if (!sctps->sctps_reclaim) {
        mutex_exit(&sctps->sctps_reclaim_lock);
        return;
    }

    if ((freemem >= lotsfree + needfree) || tot_assoc < maxusers) {
        sctps->sctps_reclaim = B_FALSE;
        sctps->sctps_reclaim_tid = 0;
    } else {
        /* Stay in defensive mode and restart the timer */
        sctps->sctps_reclaim_tid = timeout(sctp_reclaim_timer,
            sctps, MSEC_TO_TICK(sctps->sctps_reclaim_period));
    }
    mutex_exit(&sctps->sctps_reclaim_lock);
}

/*
 * Kmem reclaim call back function.  When the system is under memory
 * pressure, we set the SCTP stack variable sctps_reclaim to true.  This
 * variable is reset to false after sctps_reclaim_period msecs.  During this
 * period, SCTP will be more aggressive in aborting connections not making
 * progress, meaning retransmitting for shorter time (sctp_pa_early_abort/
 * sctp_pp_early_abort number of strikes).
 */
/* ARGSUSED */
void
sctp_conn_reclaim(void *arg)
{
    netstack_handle_t nh;
    netstack_t *ns;
    sctp_stack_t *sctps;
    extern pgcnt_t lotsfree, needfree;

    if (!sctp_do_reclaim)
        return;

    /*
     * The reclaim function may be called even when the system is not
     * really under memory pressure.
     */
    if (freemem >= lotsfree + needfree)
        return;

    netstack_next_init(&nh);
    while ((ns = netstack_next(&nh)) != NULL) {
        int i;
        int64_t tot_assoc = 0;

        /*
         * During boot time, the first netstack_t is created and
         * initialized before SCTP has registered with the netstack
         * framework.  If this reclaim function is called before SCTP
         * has finished its initialization, netstack_next() will
         * return the first netstack_t (since its netstack_flags is
         * not NSF_UNINIT).  And its netstack_sctp will be NULL.  We
         * need to catch it.
         *
         * All subsequent netstack_t creation will not have this
         * problem since the initialization is not finished until SCTP
         * has finished its own sctp_stack_t initialization.  Hence
         * netstack_next() will not return one with NULL netstack_sctp.
         */
        if ((sctps = ns->netstack_sctp) == NULL) {
            netstack_rele(ns);
            continue;
        }

        /*
         * Even if the system is under memory pressure, the reason may
         * not be because of SCTP activity.  Check the number of
         * associations in each stack.  If the number exceeds the
         * threshold (maxusers), turn on defensive mode.
         */
        for (i = 0; i < sctps->sctps_sc_cnt; i++)
            tot_assoc += sctps->sctps_sc[i]->sctp_sc_assoc_cnt;
        if (tot_assoc < maxusers) {
            netstack_rele(ns);
            continue;
        }

        mutex_enter(&sctps->sctps_reclaim_lock);
        if (!sctps->sctps_reclaim) {
            sctps->sctps_reclaim = B_TRUE;
            sctps->sctps_reclaim_tid = timeout(sctp_reclaim_timer,
                sctps, MSEC_TO_TICK(sctps->sctps_reclaim_period));
            SCTP_KSTAT(sctps, sctp_reclaim_cnt);
        }
        mutex_exit(&sctps->sctps_reclaim_lock);
        netstack_rele(ns);
    }
    netstack_next_fini(&nh);
}

/*
 * When a CPU is added, we need to allocate the per CPU stats struct.
 */
void
sctp_stack_cpu_add(sctp_stack_t *sctps, processorid_t cpu_seqid)
{
    int i;

    if (cpu_seqid < sctps->sctps_sc_cnt)
        return;
    for (i = sctps->sctps_sc_cnt; i <= cpu_seqid; i++) {
        ASSERT(sctps->sctps_sc[i] == NULL);
        sctps->sctps_sc[i] = kmem_zalloc(sizeof (sctp_stats_cpu_t),
            KM_SLEEP);
    }
    membar_producer();
    sctps->sctps_sc_cnt = cpu_seqid + 1;
}