/*
 * 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;
}