kernel/net/sctp/sctp_misc.c

   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) 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 #include <sys/types.h>
  27 #include <inet/common.h>
  28 #include <inet/sctp/sctp_impl.h>
  29
  30 /* Control whether SCTP can enter defensive mode when under memory pressure. */
  31 static boolean_t sctp_do_reclaim = B_TRUE;
  32
  33 static void     sctp_reclaim_timer(void *);
  34
  35 /* Diagnostic routine used to return a string associated with the sctp state. */
  36 char *
  37 sctp_display(sctp_t *sctp, char *sup_buf)
  38 {
  39         char    *buf;
  40         char    buf1[30];
  41         static char     priv_buf[INET6_ADDRSTRLEN * 2 + 80];
  42         char    *cp;
  43         conn_t  *connp;
  44
  45         if (sctp == NULL)
  46                 return ("NULL_SCTP");
  47
  48         connp = sctp->sctp_connp;
  49         buf = (sup_buf != NULL) ? sup_buf : priv_buf;
  50
  51         switch (sctp->sctp_state) {
  52         case SCTPS_IDLE:
  53                 cp = "SCTP_IDLE";
  54                 break;
  55         case SCTPS_BOUND:
  56                 cp = "SCTP_BOUND";
  57                 break;
  58         case SCTPS_LISTEN:
  59                 cp = "SCTP_LISTEN";
  60                 break;
  61         case SCTPS_COOKIE_WAIT:
  62                 cp = "SCTP_COOKIE_WAIT";
  63                 break;
  64         case SCTPS_COOKIE_ECHOED:
  65                 cp = "SCTP_COOKIE_ECHOED";
  66                 break;
  67         case SCTPS_ESTABLISHED:
  68                 cp = "SCTP_ESTABLISHED";
  69                 break;
  70         case SCTPS_SHUTDOWN_PENDING:
  71                 cp = "SCTP_SHUTDOWN_PENDING";
  72                 break;
  73         case SCTPS_SHUTDOWN_SENT:
  74                 cp = "SCTPS_SHUTDOWN_SENT";
  75                 break;
  76         case SCTPS_SHUTDOWN_RECEIVED:
  77                 cp = "SCTPS_SHUTDOWN_RECEIVED";
  78                 break;
  79         case SCTPS_SHUTDOWN_ACK_SENT:
  80                 cp = "SCTPS_SHUTDOWN_ACK_SENT";
  81                 break;
  82         default:
  83                 (void) mi_sprintf(buf1, "SCTPUnkState(%d)", sctp->sctp_state);
  84                 cp = buf1;
  85                 break;
  86         }
  87         (void) mi_sprintf(buf, "[%u, %u] %s",
  88             ntohs(connp->conn_lport), ntohs(connp->conn_fport), cp);
  89
  90         return (buf);
  91 }
  92
  93 void
  94 sctp_display_all(sctp_stack_t *sctps)
  95 {
  96         sctp_t *sctp_walker;
  97
  98         mutex_enter(&sctps->sctps_g_lock);
  99         for (sctp_walker = list_head(&sctps->sctps_g_list);
 100             sctp_walker != NULL;
 101             sctp_walker = (sctp_t *)list_next(&sctps->sctps_g_list,
 102             sctp_walker)) {
 103                 (void) sctp_display(sctp_walker, NULL);
 104         }
 105         mutex_exit(&sctps->sctps_g_lock);
 106 }
 107
 108 /*
 109  * Given a sctp_stack_t and a port (in host byte order), find a listener
 110  * configuration for that port and return the ratio.
 111  */
 112 uint32_t
 113 sctp_find_listener_conf(sctp_stack_t *sctps, in_port_t port)
 114 {
 115         sctp_listener_t *sl;
 116         uint32_t ratio = 0;
 117
 118         mutex_enter(&sctps->sctps_listener_conf_lock);
 119         for (sl = list_head(&sctps->sctps_listener_conf); sl != NULL;
 120             sl = list_next(&sctps->sctps_listener_conf, sl)) {
 121                 if (sl->sl_port == port) {
 122                         ratio = sl->sl_ratio;
 123                         break;
 124                 }
 125         }
 126         mutex_exit(&sctps->sctps_listener_conf_lock);
 127         return (ratio);
 128 }
 129
 130 /*
 131  * To remove all listener limit configuration in a sctp_stack_t.
 132  */
 133 void
 134 sctp_listener_conf_cleanup(sctp_stack_t *sctps)
 135 {
 136         sctp_listener_t *sl;
 137
 138         mutex_enter(&sctps->sctps_listener_conf_lock);
 139         while ((sl = list_head(&sctps->sctps_listener_conf)) != NULL) {
 140                 list_remove(&sctps->sctps_listener_conf, sl);
 141                 kmem_free(sl, sizeof (sctp_listener_t));
 142         }
 143         mutex_destroy(&sctps->sctps_listener_conf_lock);
 144         list_destroy(&sctps->sctps_listener_conf);
 145 }
 146
 147
 148 /*
 149  * Timeout function to reset the SCTP stack variable sctps_reclaim to false.
 150  */
 151 static void
 152 sctp_reclaim_timer(void *arg)
 153 {
 154         sctp_stack_t *sctps = (sctp_stack_t *)arg;
 155         int64_t tot_assoc = 0;
 156         int i;
 157         extern pgcnt_t lotsfree, needfree;
 158
 159         for (i = 0; i < sctps->sctps_sc_cnt; i++)
 160                 tot_assoc += sctps->sctps_sc[i]->sctp_sc_assoc_cnt;
 161
 162         /*
 163          * This happens only when a stack is going away.  sctps_reclaim_tid
 164          * should not be reset to 0 when returning in this case.
 165          */
 166         mutex_enter(&sctps->sctps_reclaim_lock);
 167         if (!sctps->sctps_reclaim) {
 168                 mutex_exit(&sctps->sctps_reclaim_lock);
 169                 return;
 170         }
 171
 172         if ((freemem >= lotsfree + needfree) || tot_assoc < maxusers) {
 173                 sctps->sctps_reclaim = B_FALSE;
 174                 sctps->sctps_reclaim_tid = 0;
 175         } else {
 176                 /* Stay in defensive mode and restart the timer */
 177                 sctps->sctps_reclaim_tid = timeout(sctp_reclaim_timer,
 178                     sctps, MSEC_TO_TICK(sctps->sctps_reclaim_period));
 179         }
 180         mutex_exit(&sctps->sctps_reclaim_lock);
 181 }
 182
 183 /*
 184  * Kmem reclaim call back function.  When the system is under memory
 185  * pressure, we set the SCTP stack variable sctps_reclaim to true.  This
 186  * variable is reset to false after sctps_reclaim_period msecs.  During this
 187  * period, SCTP will be more aggressive in aborting connections not making
 188  * progress, meaning retransmitting for shorter time (sctp_pa_early_abort/
 189  * sctp_pp_early_abort number of strikes).
 190  */
 191 /* ARGSUSED */
 192 void
 193 sctp_conn_reclaim(void *arg)
 194 {
 195         netstack_handle_t nh;
 196         netstack_t *ns;
 197         sctp_stack_t *sctps;
 198         extern pgcnt_t lotsfree, needfree;
 199
 200         if (!sctp_do_reclaim)
 201                 return;
 202
 203         /*
 204          * The reclaim function may be called even when the system is not
 205          * really under memory pressure.
 206          */
 207         if (freemem >= lotsfree + needfree)
 208                 return;
 209
 210         netstack_next_init(&nh);
 211         while ((ns = netstack_next(&nh)) != NULL) {
 212                 int i;
 213                 int64_t tot_assoc = 0;
 214
 215                 /*
 216                  * During boot time, the first netstack_t is created and
 217                  * initialized before SCTP has registered with the netstack
 218                  * framework.  If this reclaim function is called before SCTP
 219                  * has finished its initialization, netstack_next() will
 220                  * return the first netstack_t (since its netstack_flags is
 221                  * not NSF_UNINIT).  And its netstack_sctp will be NULL.  We
 222                  * need to catch it.
 223                  *
 224                  * All subsequent netstack_t creation will not have this
 225                  * problem since the initialization is not finished until SCTP
 226                  * has finished its own sctp_stack_t initialization.  Hence
 227                  * netstack_next() will not return one with NULL netstack_sctp.
 228                  */
 229                 if ((sctps = ns->netstack_sctp) == NULL) {
 230                         netstack_rele(ns);
 231                         continue;
 232                 }
 233
 234                 /*
 235                  * Even if the system is under memory pressure, the reason may
 236                  * not be because of SCTP activity.  Check the number of
 237                  * associations in each stack.  If the number exceeds the
 238                  * threshold (maxusers), turn on defensive mode.
 239                  */
 240                 for (i = 0; i < sctps->sctps_sc_cnt; i++)
 241                         tot_assoc += sctps->sctps_sc[i]->sctp_sc_assoc_cnt;
 242                 if (tot_assoc < maxusers) {
 243                         netstack_rele(ns);
 244                         continue;
 245                 }
 246
 247                 mutex_enter(&sctps->sctps_reclaim_lock);
 248                 if (!sctps->sctps_reclaim) {
 249                         sctps->sctps_reclaim = B_TRUE;
 250                         sctps->sctps_reclaim_tid = timeout(sctp_reclaim_timer,
 251                             sctps, MSEC_TO_TICK(sctps->sctps_reclaim_period));
 252                         SCTP_KSTAT(sctps, sctp_reclaim_cnt);
 253                 }
 254                 mutex_exit(&sctps->sctps_reclaim_lock);
 255                 netstack_rele(ns);
 256         }
 257         netstack_next_fini(&nh);
 258 }
 259
 260 /*
 261  * When a CPU is added, we need to allocate the per CPU stats struct.
 262  */
 263 void
 264 sctp_stack_cpu_add(sctp_stack_t *sctps, processorid_t cpu_seqid)
 265 {
 266         int i;
 267
 268         if (cpu_seqid < sctps->sctps_sc_cnt)
 269                 return;
 270         for (i = sctps->sctps_sc_cnt; i <= cpu_seqid; i++) {
 271                 ASSERT(sctps->sctps_sc[i] == NULL);
 272                 sctps->sctps_sc[i] = kmem_zalloc(sizeof (sctp_stats_cpu_t),
 273                     KM_SLEEP);
 274         }
 275         membar_producer();
 276         sctps->sctps_sc_cnt = cpu_seqid + 1;
 277 }