elf/dl-tunables.c

   1 /* The tunable framework.  See the README.tunables to know how to use the
   2    tunable in a glibc module.
   3
   4    Copyright (C) 2016-2023 Free Software Foundation, Inc.
   5    This file is part of the GNU C Library.
   6
   7    The GNU C Library is free software; you can redistribute it and/or
   8    modify it under the terms of the GNU Lesser General Public
   9    License as published by the Free Software Foundation; either
  10    version 2.1 of the License, or (at your option) any later version.
  11
  12    The GNU C Library is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15    Lesser General Public License for more details.
  16
  17    You should have received a copy of the GNU Lesser General Public
  18    License along with the GNU C Library; if not, see
  19    <https://www.gnu.org/licenses/>.  */
  20
  21 /* Mark symbols hidden in static PIE for early self relocation to work.  */
  22 #if BUILD_PIE_DEFAULT
  23 # pragma GCC visibility push(hidden)
  24 #endif
  25 #include <startup.h>
  26 #include <stdint.h>
  27 #include <stdbool.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <sysdep.h>
  31 #include <fcntl.h>
  32 #include <ldsodefs.h>
  33 #include <array_length.h>
  34 #include <dl-minimal-malloc.h>
  35
  36 #define TUNABLES_INTERNAL 1
  37 #include "dl-tunables.h"
  38
  39 static char **
  40 get_next_env (char **envp, char **name, char **val, char ***prev_envp)
  41 {
  42   while (envp != NULL && *envp != NULL)
  43     {
  44       char **prev = envp;
  45       char *envline = *envp++;
  46       int len = 0;
  47
  48       while (envline[len] != '\0' && envline[len] != '=')
  49         len++;
  50
  51       /* Just the name and no value, go to the next one.  */
  52       if (envline[len] == '\0')
  53         continue;
  54
  55       *name = envline;
  56       *val = &envline[len + 1];
  57       *prev_envp = prev;
  58
  59       return envp;
  60     }
  61
  62   return NULL;
  63 }
  64
  65 static void
  66 do_tunable_update_val (tunable_t *cur, const tunable_val_t *valp,
  67                        const tunable_num_t *minp,
  68                        const tunable_num_t *maxp)
  69 {
  70   tunable_num_t val, min, max;
  71
  72   if (cur->type.type_code == TUNABLE_TYPE_STRING)
  73     {
  74       cur->val.strval = valp->strval;
  75       cur->initialized = true;
  76       return;
  77     }
  78
  79   bool unsigned_cmp = unsigned_tunable_type (cur->type.type_code);
  80
  81   val = valp->numval;
  82   min = minp != NULL ? *minp : cur->type.min;
  83   max = maxp != NULL ? *maxp : cur->type.max;
  84
  85   /* We allow only increasingly restrictive bounds.  */
  86   if (tunable_val_lt (min, cur->type.min, unsigned_cmp))
  87     min = cur->type.min;
  88
  89   if (tunable_val_gt (max, cur->type.max, unsigned_cmp))
  90     max = cur->type.max;
  91
  92   /* Skip both bounds if they're inconsistent.  */
  93   if (tunable_val_gt (min, max, unsigned_cmp))
  94     {
  95       min = cur->type.min;
  96       max = cur->type.max;
  97     }
  98
  99   /* Bail out if the bounds are not valid.  */
 100   if (tunable_val_lt (val, min, unsigned_cmp)
 101       || tunable_val_lt (max, val, unsigned_cmp))
 102     return;
 103
 104   cur->val.numval = val;
 105   cur->type.min = min;
 106   cur->type.max = max;
 107   cur->initialized = true;
 108 }
 109
 110 /* Validate range of the input value and initialize the tunable CUR if it looks
 111    good.  */
 112 static void
 113 tunable_initialize (tunable_t *cur, const char *strval, size_t len)
 114 {
 115   tunable_val_t val = { 0 };
 116
 117   if (cur->type.type_code != TUNABLE_TYPE_STRING)
 118     val.numval = (tunable_num_t) _dl_strtoul (strval, NULL);
 119   else
 120     val.strval = (struct tunable_str_t) { strval, len };
 121   do_tunable_update_val (cur, &val, NULL, NULL);
 122 }
 123
 124 bool
 125 __tunable_is_initialized (tunable_id_t id)
 126 {
 127   return tunable_list[id].initialized;
 128 }
 129 rtld_hidden_def (__tunable_is_initialized)
 130
 131 void
 132 __tunable_set_val (tunable_id_t id, tunable_val_t *valp, tunable_num_t *minp,
 133                    tunable_num_t *maxp)
 134 {
 135   tunable_t *cur = &tunable_list[id];
 136
 137   do_tunable_update_val (cur, valp, minp, maxp);
 138 }
 139
 140 struct tunable_toset_t
 141 {
 142   tunable_t *t;
 143   const char *value;
 144   size_t len;
 145 };
 146
 147 enum { tunables_list_size = array_length (tunable_list) };
 148
 149 /* Parse the tunable string VALSTRING and set TUNABLES with the found tunables
 150    and their respective values.  The VALSTRING is parsed in place, with the
 151    tunable start and size recorded in TUNABLES.
 152    Return the number of tunables found (including 0 if the string is empty)
 153    or -1 if for an ill-formatted definition.  */
 154 static int
 155 parse_tunables_string (const char *valstring, struct tunable_toset_t *tunables)
 156 {
 157   if (valstring == NULL || *valstring == '\0')
 158     return 0;
 159
 160   const char *p = valstring;
 161   bool done = false;
 162   int ntunables = 0;
 163
 164   while (!done)
 165     {
 166       const char *name = p;
 167
 168       /* First, find where the name ends.  */
 169       while (*p != '=' && *p != ':' && *p != '\0')
 170         p++;
 171
 172       /* If we reach the end of the string before getting a valid name-value
 173          pair, bail out.  */
 174       if (*p == '\0')
 175         return -1;
 176
 177       /* We did not find a valid name-value pair before encountering the
 178          colon.  */
 179       if (*p == ':')
 180         {
 181           p++;
 182           continue;
 183         }
 184
 185       /* Skip the '='.  */
 186       p++;
 187
 188       const char *value = p;
 189
 190       while (*p != '=' && *p != ':' && *p != '\0')
 191         p++;
 192
 193       if (*p == '=')
 194         return -1;
 195       else if (*p == '\0')
 196         done = true;
 197
 198       /* Add the tunable if it exists.  */
 199       for (size_t i = 0; i < tunables_list_size; i++)
 200         {
 201           tunable_t *cur = &tunable_list[i];
 202
 203           if (tunable_is_name (cur->name, name))
 204             {
 205               tunables[ntunables++] =
 206                 (struct tunable_toset_t) { cur, value, p - value };
 207               break;
 208             }
 209         }
 210     }
 211
 212   return ntunables;
 213 }
 214
 215 static void
 216 parse_tunables (const char *valstring)
 217 {
 218   struct tunable_toset_t tunables[tunables_list_size];
 219   int ntunables = parse_tunables_string (valstring, tunables);
 220   if (ntunables == -1)
 221     {
 222       _dl_error_printf (
 223         "WARNING: ld.so: invalid GLIBC_TUNABLES `%s': ignored.\n", valstring);
 224       return;
 225     }
 226
 227   for (int i = 0; i < ntunables; i++)
 228     tunable_initialize (tunables[i].t, tunables[i].value, tunables[i].len);
 229 }
 230
 231 /* Initialize the tunables list from the environment.  For now we only use the
 232    ENV_ALIAS to find values.  Later we will also use the tunable names to find
 233    values.  */
 234 void
 235 __tunables_init (char **envp)
 236 {
 237   char *envname = NULL;
 238   char *envval = NULL;
 239   char **prev_envp = envp;
 240
 241   /* Ignore tunables for AT_SECURE programs.  */
 242   if (__libc_enable_secure)
 243     return;
 244
 245   while ((envp = get_next_env (envp, &envname, &envval, &prev_envp)) != NULL)
 246     {
 247       /* The environment variable is allocated on the stack by the kernel, so
 248          it is safe to keep the references to the suboptions for later parsing
 249          of string tunables.  */
 250       if (tunable_is_name ("GLIBC_TUNABLES", envname))
 251         {
 252           parse_tunables (envval);
 253           continue;
 254         }
 255
 256       for (int i = 0; i < tunables_list_size; i++)
 257         {
 258           tunable_t *cur = &tunable_list[i];
 259
 260           /* Skip over tunables that have either been set already or should be
 261              skipped.  */
 262           if (cur->initialized || cur->env_alias[0] == '\0')
 263             continue;
 264
 265           const char *name = cur->env_alias;
 266
 267           /* We have a match.  Initialize and move on to the next line.  */
 268           if (tunable_is_name (name, envname))
 269             {
 270               size_t envvallen = 0;
 271               /* The environment variable is always null-terminated.  */
 272               for (const char *p = envval; *p != '\0'; p++, envvallen++);
 273
 274               tunable_initialize (cur, envval, envvallen);
 275               break;
 276             }
 277         }
 278     }
 279 }
 280
 281 void
 282 __tunables_print (void)
 283 {
 284   for (int i = 0; i < array_length (tunable_list); i++)
 285     {
 286       const tunable_t *cur = &tunable_list[i];
 287       if (cur->type.type_code == TUNABLE_TYPE_STRING
 288           && cur->val.strval.str == NULL)
 289         _dl_printf ("%s:\n", cur->name);
 290       else
 291         {
 292           _dl_printf ("%s: ", cur->name);
 293           switch (cur->type.type_code)
 294             {
 295             case TUNABLE_TYPE_INT_32:
 296               _dl_printf ("%d (min: %d, max: %d)\n",
 297                           (int) cur->val.numval,
 298                           (int) cur->type.min,
 299                           (int) cur->type.max);
 300               break;
 301             case TUNABLE_TYPE_UINT_64:
 302               _dl_printf ("0x%lx (min: 0x%lx, max: 0x%lx)\n",
 303                           (long int) cur->val.numval,
 304                           (long int) cur->type.min,
 305                           (long int) cur->type.max);
 306               break;
 307             case TUNABLE_TYPE_SIZE_T:
 308               _dl_printf ("0x%zx (min: 0x%zx, max: 0x%zx)\n",
 309                           (size_t) cur->val.numval,
 310                           (size_t) cur->type.min,
 311                           (size_t) cur->type.max);
 312               break;
 313             case TUNABLE_TYPE_STRING:
 314               _dl_printf ("%.*s\n",
 315                           (int) cur->val.strval.len,
 316                           cur->val.strval.str);
 317               break;
 318             default:
 319               __builtin_unreachable ();
 320             }
 321         }
 322     }
 323 }
 324
 325 void
 326 __tunable_get_default (tunable_id_t id, void *valp)
 327 {
 328   tunable_t *cur = &tunable_list[id];
 329
 330   switch (cur->type.type_code)
 331     {
 332     case TUNABLE_TYPE_UINT_64:
 333         {
 334           *((uint64_t *) valp) = (uint64_t) cur->def.numval;
 335           break;
 336         }
 337     case TUNABLE_TYPE_INT_32:
 338         {
 339           *((int32_t *) valp) = (int32_t) cur->def.numval;
 340           break;
 341         }
 342     case TUNABLE_TYPE_SIZE_T:
 343         {
 344           *((size_t *) valp) = (size_t) cur->def.numval;
 345           break;
 346         }
 347     case TUNABLE_TYPE_STRING:
 348         {
 349           *((const struct tunable_str_t **)valp) = &cur->def.strval;
 350           break;
 351         }
 352     default:
 353       __builtin_unreachable ();
 354     }
 355 }
 356 rtld_hidden_def (__tunable_get_default)
 357
 358 /* Set the tunable value.  This is called by the module that the tunable exists
 359    in. */
 360 void
 361 __tunable_get_val (tunable_id_t id, void *valp, tunable_callback_t callback)
 362 {
 363   tunable_t *cur = &tunable_list[id];
 364
 365   switch (cur->type.type_code)
 366     {
 367     case TUNABLE_TYPE_UINT_64:
 368         {
 369           *((uint64_t *) valp) = (uint64_t) cur->val.numval;
 370           break;
 371         }
 372     case TUNABLE_TYPE_INT_32:
 373         {
 374           *((int32_t *) valp) = (int32_t) cur->val.numval;
 375           break;
 376         }
 377     case TUNABLE_TYPE_SIZE_T:
 378         {
 379           *((size_t *) valp) = (size_t) cur->val.numval;
 380           break;
 381         }
 382     case TUNABLE_TYPE_STRING:
 383         {
 384           *((const struct tunable_str_t **) valp) = &cur->val.strval;
 385           break;
 386         }
 387     default:
 388       __builtin_unreachable ();
 389     }
 390
 391   if (cur->initialized && callback != NULL)
 392     callback (&cur->val);
 393 }
 394
 395 rtld_hidden_def (__tunable_get_val)