From a4c3f5f46e850c977cda81c251036475aab8313c Mon Sep 17 00:00:00 2001 From: Adhemerval Zanella Date: Thu, 23 Nov 2023 14:29:14 -0300 Subject: [PATCH] elf: Add a way to check if tunable is set (BZ 27069) Content-type: text/plain; charset=UTF-8 The patch adds two new macros, TUNABLE_GET_DEFAULT and TUNABLE_IS_INITIALIZED, here the former get the default value with a signature similar to TUNABLE_GET, while the later returns whether the tunable was set by the environment variable. Checked on x86_64-linux-gnu. Reviewed-by: DJ Delorie Tested-by: Zhangfei Gao Conflicts: elf/Versions (removed to preserve ABI) elf/dl-tunable-types.h (line numbers) scripts/gen-tunables.awk (account for missing TUNABLE_SECLEVEL patch) --- elf/dl-tunable-types.h | 1 + elf/dl-tunables.c | 40 ++++++++++++++++++++++++++++++++++++++++ elf/dl-tunables.h | 28 ++++++++++++++++++++++++++++ elf/dl-tunables.list | 1 + scripts/gen-tunables.awk | 4 ++-- 6 files changed, 73 insertions(+), 2 deletions(-) diff -rup a/elf/dl-tunable-types.h b/elf/dl-tunable-types.h --- a/elf/dl-tunable-types.h 2021-08-01 21:33:43.000000000 -0400 +++ b/elf/dl-tunable-types.h 2024-03-26 18:23:22.211504813 -0400 @@ -61,6 +61,7 @@ struct _tunable { const char name[TUNABLE_NAME_MAX]; /* Internal name of the tunable. */ tunable_type_t type; /* Data type of the tunable. */ + const tunable_val_t def; /* The value. */ tunable_val_t val; /* The value. */ bool initialized; /* Flag to indicate that the tunable is initialized. */ diff -rup a/elf/dl-tunables.c b/elf/dl-tunables.c --- a/elf/dl-tunables.c 2024-03-26 18:21:10.090681748 -0400 +++ b/elf/dl-tunables.c 2024-03-26 18:23:22.214504923 -0400 @@ -152,6 +152,13 @@ tunable_initialize (tunable_t *cur, cons do_tunable_update_val (cur, &val, NULL, NULL); } +bool +__tunable_is_initialized (tunable_id_t id) +{ + return tunable_list[id].initialized; +} +rtld_hidden_def (__tunable_is_initialized) + void __tunable_set_val (tunable_id_t id, tunable_val_t *valp, tunable_num_t *minp, tunable_num_t *maxp) @@ -399,6 +406,39 @@ __tunables_print (void) } } +void +__tunable_get_default (tunable_id_t id, void *valp) +{ + tunable_t *cur = &tunable_list[id]; + + switch (cur->type.type_code) + { + case TUNABLE_TYPE_UINT_64: + { + *((uint64_t *) valp) = (uint64_t) cur->def.numval; + break; + } + case TUNABLE_TYPE_INT_32: + { + *((int32_t *) valp) = (int32_t) cur->def.numval; + break; + } + case TUNABLE_TYPE_SIZE_T: + { + *((size_t *) valp) = (size_t) cur->def.numval; + break; + } + case TUNABLE_TYPE_STRING: + { + *((const char **)valp) = cur->def.strval; + break; + } + default: + __builtin_unreachable (); + } +} +rtld_hidden_def (__tunable_get_default) + /* Set the tunable value. This is called by the module that the tunable exists in. */ void diff -rup a/elf/dl-tunables.h b/elf/dl-tunables.h --- a/elf/dl-tunables.h 2021-08-01 21:33:43.000000000 -0400 +++ b/elf/dl-tunables.h 2024-03-26 18:23:22.217505032 -0400 @@ -53,18 +53,26 @@ typedef void (*tunable_callback_t) (tuna extern void __tunables_init (char **); extern void __tunables_print (void); +extern bool __tunable_is_initialized (tunable_id_t); extern void __tunable_get_val (tunable_id_t, void *, tunable_callback_t); extern void __tunable_set_val (tunable_id_t, tunable_val_t *, tunable_num_t *, tunable_num_t *); +extern void __tunable_get_default (tunable_id_t id, void *valp); rtld_hidden_proto (__tunables_init) rtld_hidden_proto (__tunables_print) +rtld_hidden_proto (__tunable_is_initialized) rtld_hidden_proto (__tunable_get_val) rtld_hidden_proto (__tunable_set_val) +rtld_hidden_proto (__tunable_get_default) /* Define TUNABLE_GET and TUNABLE_SET in short form if TOP_NAMESPACE and TUNABLE_NAMESPACE are defined. This is useful shorthand to get and set tunables within a module. */ #if defined TOP_NAMESPACE && defined TUNABLE_NAMESPACE +# define TUNABLE_IS_INITIALIZED(__id) \ + TUNABLE_IS_INITIALIZED_FULL(TOP_NAMESPACE, TUNABLE_NAMESPACE, __id) +# define TUNABLE_GET_DEFAULT(__id, __type) \ + TUNABLE_GET_DEFAULT_FULL(TOP_NAMESPACE, TUNABLE_NAMESPACE,__id, __type) # define TUNABLE_GET(__id, __type, __cb) \ TUNABLE_GET_FULL (TOP_NAMESPACE, TUNABLE_NAMESPACE, __id, __type, __cb) # define TUNABLE_SET(__id, __val) \ @@ -73,6 +81,10 @@ rtld_hidden_proto (__tunable_set_val) TUNABLE_SET_WITH_BOUNDS_FULL (TOP_NAMESPACE, TUNABLE_NAMESPACE, __id, \ __val, __min, __max) #else +# define TUNABLE_IS_INITIALIZED(__top, __ns, __id) \ + TUNABLE_IS_INITIALIZED_FULL(__top, __ns, __id) +# define TUNABLE_GET_DEFAULT(__top, __ns, __type) \ + TUNABLE_GET_DEFAULT_FULL(__top, __ns, __id, __type) # define TUNABLE_GET(__top, __ns, __id, __type, __cb) \ TUNABLE_GET_FULL (__top, __ns, __id, __type, __cb) # define TUNABLE_SET(__top, __ns, __id, __val) \ @@ -81,6 +93,22 @@ rtld_hidden_proto (__tunable_set_val) TUNABLE_SET_WITH_BOUNDS_FULL (__top, __ns, __id, __val, __min, __max) #endif +/* Return whether the tunable was initialized by the environment variable. */ +#define TUNABLE_IS_INITIALIZED_FULL(__top, __ns, __id) \ +({ \ + tunable_id_t id = TUNABLE_ENUM_NAME (__top, __ns, __id); \ + __tunable_is_initialized (id); \ +}) + +/* Return the default value of the tunable. */ +#define TUNABLE_GET_DEFAULT_FULL(__top, __ns, __id, __type) \ +({ \ + tunable_id_t id = TUNABLE_ENUM_NAME (__top, __ns, __id); \ + __type __ret; \ + __tunable_get_default (id, &__ret); \ + __ret; \ +}) + /* Get and return a tunable value. If the tunable was set externally and __CB is defined then call __CB before returning the value. */ # define TUNABLE_GET_FULL(__top, __ns, __id, __type, __cb) \ diff -rup a/elf/dl-tunables.list b/elf/dl-tunables.list --- a/elf/dl-tunables.list 2024-03-26 18:21:09.664666196 -0400 +++ b/elf/dl-tunables.list 2024-03-26 18:23:22.220505142 -0400 @@ -20,6 +20,7 @@ # type: Defaults to STRING # minval: Optional minimum acceptable value # maxval: Optional maximum acceptable value +# default: Optional default value (if not specified it will be 0 or "") # env_alias: An alias environment variable # security_level: Specify security level of the tunable for AT_SECURE binaries. # Valid values are: diff -rup a/scripts/gen-tunables.awk b/scripts/gen-tunables.awk --- a/scripts/gen-tunables.awk 2024-03-26 18:21:09.523661049 -0400 +++ b/scripts/gen-tunables.awk 2024-03-26 18:34:45.385462341 -0400 @@ -236,8 +236,8 @@ END { n = indices[2]; m = indices[3]; printf (" {TUNABLE_NAME_S(%s, %s, %s)", t, n, m) - printf (", {TUNABLE_TYPE_%s, %s, %s}, {%s}, NULL, TUNABLE_SECLEVEL_%s, %s},\n", - types[t,n,m], minvals[t,n,m], maxvals[t,n,m], + printf (", {TUNABLE_TYPE_%s, %s, %s}, {%s}, {%s}, NULL, TUNABLE_SECLEVEL_%s, %s},\n", + types[t,n,m], minvals[t,n,m], maxvals[t,n,m],default_val[t,n,m], default_val[t,n,m], security_level[t,n,m], env_alias[t,n,m]); } print "};"