1 /* The tunable framework. See the README.tunables to know how to use the
2 tunable in a glibc module.
4 Copyright (C) 2016-2024 Free Software Foundation, Inc.
5 This file is part of the GNU C Library.
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.
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.
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/>. */
21 /* Mark symbols hidden in static PIE for early self relocation to work. */
23 # pragma GCC visibility push(hidden)
33 #include <array_length.h>
34 #include <dl-minimal-malloc.h>
36 #define TUNABLES_INTERNAL 1
37 #include "dl-tunables.h"
40 get_next_env (char **envp
, char **name
, char **val
, char ***prev_envp
)
42 while (envp
!= NULL
&& *envp
!= NULL
)
45 char *envline
= *envp
++;
48 while (envline
[len
] != '\0' && envline
[len
] != '=')
51 /* Just the name and no value, go to the next one. */
52 if (envline
[len
] == '\0')
56 *val
= &envline
[len
+ 1];
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
)
70 tunable_num_t val
, min
, max
;
72 switch (cur
->type
.type_code
)
74 case TUNABLE_TYPE_STRING
:
75 cur
->val
.strval
= valp
->strval
;
76 cur
->initialized
= true;
78 case TUNABLE_TYPE_INT_32
:
79 val
= (int32_t) valp
->numval
;
81 case TUNABLE_TYPE_UINT_64
:
82 val
= (int64_t) valp
->numval
;
84 case TUNABLE_TYPE_SIZE_T
:
85 val
= (size_t) valp
->numval
;
88 __builtin_unreachable ();
91 bool unsigned_cmp
= unsigned_tunable_type (cur
->type
.type_code
);
93 min
= minp
!= NULL
? *minp
: cur
->type
.min
;
94 max
= maxp
!= NULL
? *maxp
: cur
->type
.max
;
96 /* We allow only increasingly restrictive bounds. */
97 if (tunable_val_lt (min
, cur
->type
.min
, unsigned_cmp
))
100 if (tunable_val_gt (max
, cur
->type
.max
, unsigned_cmp
))
103 /* Skip both bounds if they're inconsistent. */
104 if (tunable_val_gt (min
, max
, unsigned_cmp
))
110 /* Bail out if the bounds are not valid. */
111 if (tunable_val_lt (val
, min
, unsigned_cmp
)
112 || tunable_val_lt (max
, val
, unsigned_cmp
))
115 cur
->val
.numval
= val
;
118 cur
->initialized
= true;
121 /* Validate range of the input value and initialize the tunable CUR if it looks
124 tunable_initialize (tunable_t
*cur
, const char *strval
, size_t len
)
126 tunable_val_t val
= { 0 };
128 if (cur
->type
.type_code
!= TUNABLE_TYPE_STRING
)
131 uint64_t numval
= _dl_strtoul (strval
, &endptr
);
132 if (endptr
!= strval
+ len
)
134 val
.numval
= (tunable_num_t
) numval
;
137 val
.strval
= (struct tunable_str_t
) { strval
, len
};
138 do_tunable_update_val (cur
, &val
, NULL
, NULL
);
144 __tunable_is_initialized (tunable_id_t id
)
146 return tunable_list
[id
].initialized
;
148 rtld_hidden_def (__tunable_is_initialized
)
151 __tunable_set_val (tunable_id_t id
, tunable_val_t
*valp
, tunable_num_t
*minp
,
154 tunable_t
*cur
= &tunable_list
[id
];
156 do_tunable_update_val (cur
, valp
, minp
, maxp
);
159 struct tunable_toset_t
166 enum { tunables_list_size
= array_length (tunable_list
) };
168 /* Parse the tunable string VALSTRING and set TUNABLES with the found tunables
169 and their respective values. The VALSTRING is parsed in place, with the
170 tunable start and size recorded in TUNABLES.
171 Return the number of tunables found (including 0 if the string is empty)
172 or -1 if for an ill-formatted definition. */
174 parse_tunables_string (const char *valstring
, struct tunable_toset_t
*tunables
)
176 if (valstring
== NULL
|| *valstring
== '\0')
179 const char *p
= valstring
;
185 const char *name
= p
;
187 /* First, find where the name ends. */
188 while (*p
!= '=' && *p
!= ':' && *p
!= '\0')
191 /* If we reach the end of the string before getting a valid name-value
196 /* We did not find a valid name-value pair before encountering the
207 const char *value
= p
;
209 while (*p
!= '=' && *p
!= ':' && *p
!= '\0')
217 /* Add the tunable if it exists. */
218 for (size_t i
= 0; i
< tunables_list_size
; i
++)
220 tunable_t
*cur
= &tunable_list
[i
];
222 if (tunable_is_name (cur
->name
, name
))
224 tunables
[ntunables
++] =
225 (struct tunable_toset_t
) { cur
, value
, p
- value
};
235 parse_tunables (const char *valstring
)
237 struct tunable_toset_t tunables
[tunables_list_size
];
238 int ntunables
= parse_tunables_string (valstring
, tunables
);
242 "WARNING: ld.so: invalid GLIBC_TUNABLES `%s': ignored.\n", valstring
);
246 for (int i
= 0; i
< ntunables
; i
++)
247 if (!tunable_initialize (tunables
[i
].t
, tunables
[i
].value
,
249 _dl_error_printf ("WARNING: ld.so: invalid GLIBC_TUNABLES value `%.*s' "
250 "for option `%s': ignored.\n",
251 (int) tunables
[i
].len
,
253 tunables
[i
].t
->name
);
256 /* Initialize the tunables list from the environment. For now we only use the
257 ENV_ALIAS to find values. Later we will also use the tunable names to find
260 __tunables_init (char **envp
)
262 char *envname
= NULL
;
264 char **prev_envp
= envp
;
266 /* Ignore tunables for AT_SECURE programs. */
267 if (__libc_enable_secure
)
270 while ((envp
= get_next_env (envp
, &envname
, &envval
, &prev_envp
)) != NULL
)
272 /* The environment variable is allocated on the stack by the kernel, so
273 it is safe to keep the references to the suboptions for later parsing
274 of string tunables. */
275 if (tunable_is_name ("GLIBC_TUNABLES", envname
))
277 parse_tunables (envval
);
281 for (int i
= 0; i
< tunables_list_size
; i
++)
283 tunable_t
*cur
= &tunable_list
[i
];
285 /* Skip over tunables that have either been set already or should be
287 if (cur
->initialized
|| cur
->env_alias
[0] == '\0')
290 const char *name
= cur
->env_alias
;
292 /* We have a match. Initialize and move on to the next line. */
293 if (tunable_is_name (name
, envname
))
295 size_t envvallen
= 0;
296 /* The environment variable is always null-terminated. */
297 for (const char *p
= envval
; *p
!= '\0'; p
++, envvallen
++);
299 tunable_initialize (cur
, envval
, envvallen
);
307 __tunables_print (void)
309 for (int i
= 0; i
< array_length (tunable_list
); i
++)
311 const tunable_t
*cur
= &tunable_list
[i
];
312 if (cur
->type
.type_code
== TUNABLE_TYPE_STRING
313 && cur
->val
.strval
.str
== NULL
)
314 _dl_printf ("%s:\n", cur
->name
);
317 _dl_printf ("%s: ", cur
->name
);
318 switch (cur
->type
.type_code
)
320 case TUNABLE_TYPE_INT_32
:
321 _dl_printf ("%d (min: %d, max: %d)\n",
322 (int) cur
->val
.numval
,
324 (int) cur
->type
.max
);
326 case TUNABLE_TYPE_UINT_64
:
327 _dl_printf ("0x%lx (min: 0x%lx, max: 0x%lx)\n",
328 (long int) cur
->val
.numval
,
329 (long int) cur
->type
.min
,
330 (long int) cur
->type
.max
);
332 case TUNABLE_TYPE_SIZE_T
:
333 _dl_printf ("0x%zx (min: 0x%zx, max: 0x%zx)\n",
334 (size_t) cur
->val
.numval
,
335 (size_t) cur
->type
.min
,
336 (size_t) cur
->type
.max
);
338 case TUNABLE_TYPE_STRING
:
339 _dl_printf ("%.*s\n",
340 (int) cur
->val
.strval
.len
,
341 cur
->val
.strval
.str
);
344 __builtin_unreachable ();
351 __tunable_get_default (tunable_id_t id
, void *valp
)
353 tunable_t
*cur
= &tunable_list
[id
];
355 switch (cur
->type
.type_code
)
357 case TUNABLE_TYPE_UINT_64
:
359 *((uint64_t *) valp
) = (uint64_t) cur
->def
.numval
;
362 case TUNABLE_TYPE_INT_32
:
364 *((int32_t *) valp
) = (int32_t) cur
->def
.numval
;
367 case TUNABLE_TYPE_SIZE_T
:
369 *((size_t *) valp
) = (size_t) cur
->def
.numval
;
372 case TUNABLE_TYPE_STRING
:
374 *((const struct tunable_str_t
**)valp
) = &cur
->def
.strval
;
378 __builtin_unreachable ();
381 rtld_hidden_def (__tunable_get_default
)
383 /* Set the tunable value. This is called by the module that the tunable exists
386 __tunable_get_val (tunable_id_t id
, void *valp
, tunable_callback_t callback
)
388 tunable_t
*cur
= &tunable_list
[id
];
390 switch (cur
->type
.type_code
)
392 case TUNABLE_TYPE_UINT_64
:
394 *((uint64_t *) valp
) = (uint64_t) cur
->val
.numval
;
397 case TUNABLE_TYPE_INT_32
:
399 *((int32_t *) valp
) = (int32_t) cur
->val
.numval
;
402 case TUNABLE_TYPE_SIZE_T
:
404 *((size_t *) valp
) = (size_t) cur
->val
.numval
;
407 case TUNABLE_TYPE_STRING
:
409 *((const struct tunable_str_t
**) valp
) = &cur
->val
.strval
;
413 __builtin_unreachable ();
416 if (cur
->initialized
&& callback
!= NULL
)
417 callback (&cur
->val
);
420 rtld_hidden_def (__tunable_get_val
)