elf/tst-tunables.c

   1 /* Check GLIBC_TUNABLES parsing.
   2    Copyright (C) 2023-2024 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 /* The test uses the tunable_list size, which is only exported for
  21    ld.so.  This will result in a copy of tunable_list, which is ununsed by
  22    the test itself.  */
  23 #define TUNABLES_INTERNAL 1
  24 #include <dl-tunables.h>
  25 #include <getopt.h>
  26 #include <intprops.h>
  27 #include <stdint.h>
  28 #include <stdlib.h>
  29 #include <support/capture_subprocess.h>
  30 #include <support/check.h>
  31 #include <support/support.h>
  32
  33 static int restart;
  34 #define CMDLINE_OPTIONS \
  35   { "restart", no_argument, &restart, 1 },
  36
  37 static struct test_t
  38 {
  39   const char *name;
  40   const char *value;
  41   int32_t expected_malloc_check;
  42   size_t expected_mmap_threshold;
  43   int32_t expected_perturb;
  44 } tests[] =
  45 {
  46   /* Expected tunable format.  */
  47   {
  48     "GLIBC_TUNABLES",
  49     "glibc.malloc.check=2",
  50     2,
  51     0,
  52     0,
  53   },
  54   {
  55     "GLIBC_TUNABLES",
  56     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096",
  57     2,
  58     4096,
  59     0,
  60   },
  61   {
  62     "GLIBC_TUNABLES",
  63     "glibc.malloc.mmap_threshold=-1",
  64     0,
  65     SIZE_MAX,
  66     0,
  67   },
  68   /* Empty tunable are ignored.  */
  69   {
  70     "GLIBC_TUNABLES",
  71     "glibc.malloc.check=2::glibc.malloc.mmap_threshold=4096",
  72     2,
  73     4096,
  74     0,
  75   },
  76   /* As well empty values.  */
  77   {
  78     "GLIBC_TUNABLES",
  79     "glibc.malloc.check=:glibc.malloc.mmap_threshold=4096",
  80     0,
  81     4096,
  82     0,
  83   },
  84   /* Tunable are processed from left to right, so last one is the one set.  */
  85   {
  86     "GLIBC_TUNABLES",
  87     "glibc.malloc.check=1:glibc.malloc.check=2",
  88     2,
  89     0,
  90     0,
  91   },
  92   {
  93     "GLIBC_TUNABLES",
  94     "glibc.malloc.check=1:glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096",
  95     2,
  96     4096,
  97     0,
  98   },
  99   {
 100     "GLIBC_TUNABLES",
 101     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096:glibc.malloc.check=1",
 102     1,
 103     4096,
 104     0,
 105   },
 106   /* 0x800 is larger than tunable maxval (0xff), so the tunable is unchanged.  */
 107   {
 108     "GLIBC_TUNABLES",
 109     "glibc.malloc.perturb=0x800",
 110     0,
 111     0,
 112     0,
 113   },
 114   {
 115     "GLIBC_TUNABLES",
 116     "glibc.malloc.perturb=0x55",
 117     0,
 118     0,
 119     0x55,
 120   },
 121   /* Out of range values are just ignored.  */
 122   {
 123     "GLIBC_TUNABLES",
 124     "glibc.malloc.perturb=0x800:glibc.malloc.mmap_threshold=4096",
 125     0,
 126     4096,
 127     0,
 128   },
 129   /* Invalid keys are ignored.  */
 130   {
 131     "GLIBC_TUNABLES",
 132     ":glibc.malloc.garbage=2:glibc.malloc.check=1",
 133     1,
 134     0,
 135     0,
 136   },
 137   {
 138     "GLIBC_TUNABLES",
 139     "glibc.malloc.perturb=0x800:not_valid.malloc.check=2:glibc.malloc.mmap_threshold=4096",
 140     0,
 141     4096,
 142     0,
 143   },
 144   {
 145     "GLIBC_TUNABLES",
 146     "glibc.not_valid.check=2:glibc.malloc.mmap_threshold=4096",
 147     0,
 148     4096,
 149     0,
 150   },
 151   {
 152     "GLIBC_TUNABLES",
 153     "not_valid.malloc.check=2:glibc.malloc.mmap_threshold=4096",
 154     0,
 155     4096,
 156     0,
 157   },
 158   /* Invalid subkeys are ignored.  */
 159   {
 160     "GLIBC_TUNABLES",
 161     "glibc.malloc.garbage=2:glibc.maoc.mmap_threshold=4096:glibc.malloc.check=2",
 162     2,
 163     0,
 164     0,
 165   },
 166   {
 167     "GLIBC_TUNABLES",
 168     "glibc.malloc.check=4:glibc.malloc.garbage=2:glibc.maoc.mmap_threshold=4096",
 169     0,
 170     0,
 171     0,
 172   },
 173   {
 174     "GLIBC_TUNABLES",
 175     "not_valid.malloc.check=2",
 176     0,
 177     0,
 178     0,
 179   },
 180   {
 181     "GLIBC_TUNABLES",
 182     "glibc.not_valid.check=2",
 183     0,
 184     0,
 185     0,
 186   },
 187   /* An ill-formatted tunable in the for key=key=value will considere the
 188      value as 'key=value' (which can not be parsed as an integer).  */
 189   {
 190     "GLIBC_TUNABLES",
 191     "glibc.malloc.mmap_threshold=glibc.malloc.mmap_threshold=4096",
 192     0,
 193     0,
 194     0,
 195   },
 196   /* Ill-formatted tunables string is not parsed.  */
 197   {
 198     "GLIBC_TUNABLES",
 199     "glibc.malloc.mmap_threshold=glibc.malloc.mmap_threshold=4096:glibc.malloc.check=2",
 200     0,
 201     0,
 202     0,
 203   },
 204   {
 205     "GLIBC_TUNABLES",
 206     "glibc.malloc.check=2=2",
 207     0,
 208     0,
 209     0,
 210   },
 211   {
 212     "GLIBC_TUNABLES",
 213     "glibc.malloc.check=2=2:glibc.malloc.mmap_threshold=4096",
 214     0,
 215     0,
 216     0,
 217   },
 218   {
 219     "GLIBC_TUNABLES",
 220     "glibc.malloc.check=2=2:glibc.malloc.check=2",
 221     0,
 222     0,
 223     0,
 224   },
 225   {
 226     "GLIBC_TUNABLES",
 227     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096=4096",
 228     0,
 229     0,
 230     0,
 231   },
 232   {
 233     "GLIBC_TUNABLES",
 234     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=4096=4096",
 235     0,
 236     0,
 237     0,
 238   },
 239   /* Invalid numbers are ignored.  */
 240   {
 241     "GLIBC_TUNABLES",
 242     "glibc.malloc.check=abc:glibc.malloc.mmap_threshold=4096",
 243     0,
 244     4096,
 245     0,
 246   },
 247   {
 248     "GLIBC_TUNABLES",
 249     "glibc.malloc.check=2:glibc.malloc.mmap_threshold=abc",
 250     2,
 251     0,
 252     0,
 253   },
 254   {
 255     "GLIBC_TUNABLES",
 256     /* SIZE_MAX + 1 */
 257     "glibc.malloc.mmap_threshold=18446744073709551616",
 258     0,
 259     0,
 260     0,
 261   },
 262   /* Also check some tunable aliases.  */
 263   {
 264     "MALLOC_CHECK_",
 265     "2",
 266     2,
 267     0,
 268     0,
 269   },
 270   {
 271     "MALLOC_MMAP_THRESHOLD_",
 272     "4096",
 273     0,
 274     4096,
 275     0,
 276   },
 277   {
 278     "MALLOC_PERTURB_",
 279     "0x55",
 280     0,
 281     0,
 282     0x55,
 283   },
 284   /* 0x800 is larger than tunable maxval (0xff), so the tunable is unchanged.  */
 285   {
 286     "MALLOC_PERTURB_",
 287     "0x800",
 288     0,
 289     0,
 290     0,
 291   },
 292   /* Also check for repeated tunables with a count larger than the total number
 293      of tunables.  */
 294   {
 295     "GLIBC_TUNABLES",
 296     NULL,
 297     2,
 298     0,
 299     0,
 300   },
 301   {
 302     "GLIBC_TUNABLES",
 303     NULL,
 304     1,
 305     0,
 306     0,
 307   },
 308   {
 309     "GLIBC_TUNABLES",
 310     NULL,
 311     0,
 312     0,
 313     0,
 314   },
 315 };
 316
 317 static int
 318 handle_restart (int i)
 319 {
 320   TEST_COMPARE (tests[i].expected_malloc_check,
 321                 TUNABLE_GET_FULL (glibc, malloc, check, int32_t, NULL));
 322   TEST_COMPARE (tests[i].expected_mmap_threshold,
 323                 TUNABLE_GET_FULL (glibc, malloc, mmap_threshold, size_t, NULL));
 324   TEST_COMPARE (tests[i].expected_perturb,
 325                 TUNABLE_GET_FULL (glibc, malloc, perturb, int32_t, NULL));
 326   return 0;
 327 }
 328
 329 static int
 330 do_test (int argc, char *argv[])
 331 {
 332   /* We must have either:
 333      - One our fource parameters left if called initially:
 334        + path to ld.so         optional
 335        + "--library-path"      optional
 336        + the library path      optional
 337        + the application name
 338        + the test to check  */
 339
 340   TEST_VERIFY_EXIT (argc == 2 || argc == 5);
 341
 342   if (restart)
 343     return handle_restart (atoi (argv[1]));
 344
 345   char nteststr[INT_BUFSIZE_BOUND (int)];
 346
 347   char *spargv[10];
 348   {
 349     int i = 0;
 350     for (; i < argc - 1; i++)
 351       spargv[i] = argv[i + 1];
 352     spargv[i++] = (char *) "--direct";
 353     spargv[i++] = (char *) "--restart";
 354     spargv[i++] = nteststr;
 355     spargv[i] = NULL;
 356   }
 357
 358   /* Create a tunable line with the duplicate values with a total number
 359      larger than the different number of tunables.  */
 360   {
 361     enum { tunables_list_size = array_length (tunable_list) };
 362     const char *value = "";
 363     for (int i = 0; i < tunables_list_size; i++)
 364       value = xasprintf ("%sglibc.malloc.check=2%c",
 365                          value,
 366                          i == (tunables_list_size - 1) ? '\0' : ':');
 367     tests[33].value = value;
 368   }
 369   /* Same as before, but the last tunable values is differen than the
 370      rest.  */
 371   {
 372     enum { tunables_list_size = array_length (tunable_list) };
 373     const char *value = "";
 374     for (int i = 0; i < tunables_list_size - 1; i++)
 375       value = xasprintf ("%sglibc.malloc.check=2:", value);
 376     value = xasprintf ("%sglibc.malloc.check=1", value);
 377     tests[34].value = value;
 378   }
 379   /* Same as before, but with an invalid last entry.  */
 380   {
 381     enum { tunables_list_size = array_length (tunable_list) };
 382     const char *value = "";
 383     for (int i = 0; i < tunables_list_size - 1; i++)
 384       value = xasprintf ("%sglibc.malloc.check=2:", value);
 385     value = xasprintf ("%sglibc.malloc.check=1=1", value);
 386     tests[35].value = value;
 387   }
 388
 389   for (int i = 0; i < array_length (tests); i++)
 390     {
 391       snprintf (nteststr, sizeof nteststr, "%d", i);
 392
 393       printf ("[%d] Spawned test for %s=%s\n",
 394               i,
 395               tests[i].name,
 396               tests[i].value);
 397       setenv (tests[i].name, tests[i].value, 1);
 398       struct support_capture_subprocess result
 399         = support_capture_subprogram (spargv[0], spargv, NULL);
 400       support_capture_subprocess_check (&result, "tst-tunables", 0,
 401                                         sc_allow_stderr);
 402       support_capture_subprocess_free (&result);
 403       unsetenv (tests[i].name);
 404     }
 405
 406   return 0;
 407 }
 408
 409 #define TEST_FUNCTION_ARGV do_test
 410 #include <support/test-driver.c>