elf/tst-tunables.c

   1 /* Check GLIBC_TUNABLES parsing.
   2    Copyright (C) 2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <array_length.h>
  20 #include <dl-tunables.h>
  21 #include <getopt.h>
  22 #include <intprops.h>
  23 #include <stdint.h>
  24 #include <stdlib.h>
  25 #include <support/capture_subprocess.h>
  26 #include <support/check.h>
  27
  28 static int restart;
  29 #define CMDLINE_OPTIONS \
  30   { "restart", no_argument, &restart, 1 },
  31
  32 static const struct test_t
  33 {
  34   const char *env;
  35   int32_t expected_malloc_check;
  36   size_t expected_mmap_threshold;
  37   int32_t expected_perturb;
  38 } tests[] =
  39 {
  40   /* Expected tunable format.  */
  41   {
  42     "glibc.malloc.check=2",
  43     2,
  44     0,
  45     0,
  46   },
  47   {
  48     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096",
  49     2,
  50     4096,
  51     0,
  52   },
  53   /* Empty tunable are ignored.  */
  54   {
  55     "glibc.malloc.check=2::glibc.malloc.mmap_threshold=4096",
  56     2,
  57     4096,
  58     0,
  59   },
  60   /* As well empty values.  */
  61   {
  62     "glibc.malloc.check=:glibc.malloc.mmap_threshold=4096",
  63     0,
  64     4096,
  65     0,
  66   },
  67   /* Tunable are processed from left to right, so last one is the one set.  */
  68   {
  69     "glibc.malloc.check=1:glibc.malloc.check=2",
  70     2,
  71     0,
  72     0,
  73   },
  74   {
  75     "glibc.malloc.check=1:glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096",
  76     2,
  77     4096,
  78     0,
  79   },
  80   {
  81     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096:glibc.malloc.check=1",
  82     1,
  83     4096,
  84     0,
  85   },
  86   /* 0x800 is larger than tunable maxval (0xff), so the tunable is unchanged.  */
  87   {
  88     "glibc.malloc.perturb=0x800",
  89     0,
  90     0,
  91     0,
  92   },
  93   {
  94     "glibc.malloc.perturb=0x55",
  95     0,
  96     0,
  97     0x55,
  98   },
  99   /* Out of range values are just ignored.  */
 100   {
 101     "glibc.malloc.perturb=0x800:glibc.malloc.mmap_threshold=4096",
 102     0,
 103     4096,
 104     0,
 105   },
 106   /* Invalid keys are ignored.  */
 107   {
 108     ":glibc.malloc.garbage=2:glibc.malloc.check=1",
 109     1,
 110     0,
 111     0,
 112   },
 113   {
 114     "glibc.malloc.perturb=0x800:not_valid.malloc.check=2:glibc.malloc.mmap_threshold=4096",
 115     0,
 116     4096,
 117     0,
 118   },
 119   {
 120     "glibc.not_valid.check=2:glibc.malloc.mmap_threshold=4096",
 121     0,
 122     4096,
 123     0,
 124   },
 125   {
 126     "not_valid.malloc.check=2:glibc.malloc.mmap_threshold=4096",
 127     0,
 128     4096,
 129     0,
 130   },
 131   /* Invalid subkeys are ignored.  */
 132   {
 133     "glibc.malloc.garbage=2:glibc.maoc.mmap_threshold=4096:glibc.malloc.check=2",
 134     2,
 135     0,
 136     0,
 137   },
 138   {
 139     "glibc.malloc.check=4:glibc.malloc.garbage=2:glibc.maoc.mmap_threshold=4096",
 140     0,
 141     0,
 142     0,
 143   },
 144   {
 145     "not_valid.malloc.check=2",
 146     0,
 147     0,
 148     0,
 149   },
 150   {
 151     "glibc.not_valid.check=2",
 152     0,
 153     0,
 154     0,
 155   },
 156   /* An ill-formatted tunable in the for key=key=value will considere the
 157      value as 'key=value' (which can not be parsed as an integer).  */
 158   {
 159     "glibc.malloc.mmap_threshold=glibc.malloc.mmap_threshold=4096",
 160     0,
 161     0,
 162     0,
 163   },
 164   /* Ill-formatted tunables string is not parsed.  */
 165   {
 166     "glibc.malloc.mmap_threshold=glibc.malloc.mmap_threshold=4096:glibc.malloc.check=2",
 167     0,
 168     0,
 169     0,
 170   },
 171   {
 172     "glibc.malloc.check=2=2",
 173     0,
 174     0,
 175     0,
 176   },
 177   {
 178     "glibc.malloc.check=2=2:glibc.malloc.mmap_threshold=4096",
 179     0,
 180     0,
 181     0,
 182   },
 183   {
 184     "glibc.malloc.check=2=2:glibc.malloc.check=2",
 185     0,
 186     0,
 187     0,
 188   },
 189   {
 190     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096=4096",
 191     0,
 192     0,
 193     0,
 194   },
 195   {
 196     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096=4096",
 197     0,
 198     0,
 199     0,
 200   },
 201 };
 202
 203 static int
 204 handle_restart (int i)
 205 {
 206   TEST_COMPARE (tests[i].expected_malloc_check,
 207                 TUNABLE_GET_FULL (glibc, malloc, check, int32_t, NULL));
 208   TEST_COMPARE (tests[i].expected_mmap_threshold,
 209                 TUNABLE_GET_FULL (glibc, malloc, mmap_threshold, size_t, NULL));
 210   TEST_COMPARE (tests[i].expected_perturb,
 211                 TUNABLE_GET_FULL (glibc, malloc, perturb, int32_t, NULL));
 212   return 0;
 213 }
 214
 215 static int
 216 do_test (int argc, char *argv[])
 217 {
 218   /* We must have either:
 219      - One our fource parameters left if called initially:
 220        + path to ld.so         optional
 221        + "--library-path"      optional
 222        + the library path      optional
 223        + the application name
 224        + the test to check  */
 225
 226   TEST_VERIFY_EXIT (argc == 2 || argc == 5);
 227
 228   if (restart)
 229     return handle_restart (atoi (argv[1]));
 230
 231   char nteststr[INT_BUFSIZE_BOUND (int)];
 232
 233   char *spargv[10];
 234   {
 235     int i = 0;
 236     for (; i < argc - 1; i++)
 237       spargv[i] = argv[i + 1];
 238     spargv[i++] = (char *) "--direct";
 239     spargv[i++] = (char *) "--restart";
 240     spargv[i++] = nteststr;
 241     spargv[i] = NULL;
 242   }
 243
 244   for (int i = 0; i < array_length (tests); i++)
 245     {
 246       snprintf (nteststr, sizeof nteststr, "%d", i);
 247
 248       printf ("[%d] Spawned test for %s\n", i, tests[i].env);
 249       setenv ("GLIBC_TUNABLES", tests[i].env, 1);
 250       struct support_capture_subprocess result
 251         = support_capture_subprogram (spargv[0], spargv);
 252       support_capture_subprocess_check (&result, "tst-tunables", 0,
 253                                         sc_allow_stderr);
 254       support_capture_subprocess_free (&result);
 255     }
 256
 257   return 0;
 258 }
 259
 260 #define TEST_FUNCTION_ARGV do_test
 261 #include <support/test-driver.c>