summaryrefslogtreecommitdiff
path: root/elf-Add-a-way-to-check-if-tunable-is-set-BZ-27069.patch
diff options
context:
space:
mode:
Diffstat (limited to 'elf-Add-a-way-to-check-if-tunable-is-set-BZ-27069.patch')
-rw-r--r--elf-Add-a-way-to-check-if-tunable-is-set-BZ-27069.patch202
1 files changed, 202 insertions, 0 deletions
diff --git a/elf-Add-a-way-to-check-if-tunable-is-set-BZ-27069.patch b/elf-Add-a-way-to-check-if-tunable-is-set-BZ-27069.patch
new file mode 100644
index 0000000..945a22e
--- /dev/null
+++ b/elf-Add-a-way-to-check-if-tunable-is-set-BZ-27069.patch
@@ -0,0 +1,202 @@
+From a4c3f5f46e850c977cda81c251036475aab8313c Mon Sep 17 00:00:00 2001
+From: Adhemerval Zanella <adhemerval.zanella@linaro.org>
+Date: Thu, 23 Nov 2023 14:29:14 -0300
+Subject: [PATCH] elf: Add a way to check if tunable is set (BZ 27069)
+
+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 <dj@redhat.com>
+Tested-by: Zhangfei Gao <zhangfei.gao@linaro.org>
+
+Conflict: this adapt the context of elf/Versions, scripts/gen-tunables.awk and
+ elf/dl-tunables.h
+---
+ elf/Versions | 1 +
+ 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 --git a/elf/Versions b/elf/Versions
+index 2af210b8..9318b44a 100644
+--- a/elf/Versions
++++ b/elf/Versions
+@@ -74,6 +74,7 @@ ld {
+ _dl_signal_error; _dl_catch_error;
+
+ # Set value of a tunable.
++ __tunable_is_initialized;
+ __tunable_get_val;
+ }
+ }
+diff --git a/elf/dl-tunable-types.h b/elf/dl-tunable-types.h
+index 39bf738d..d36b0d75 100644
+--- a/elf/dl-tunable-types.h
++++ b/elf/dl-tunable-types.h
+@@ -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 --git a/elf/dl-tunables.c b/elf/dl-tunables.c
+index 42631d39..a325e701 100644
+--- a/elf/dl-tunables.c
++++ b/elf/dl-tunables.c
+@@ -150,6 +150,13 @@ tunable_initialize (tunable_t *cur, const char *strval)
+ 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)
+@@ -397,6 +404,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 --git a/elf/dl-tunables.h b/elf/dl-tunables.h
+index 3880e4aa..9873c623 100644
+--- a/elf/dl-tunables.h
++++ b/elf/dl-tunables.h
+@@ -53,18 +53,26 @@ typedef void (*tunable_callback_t) (tunable_val_t *);
+
+ 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 --git a/elf/dl-tunables.list b/elf/dl-tunables.list
+index ea19387d..befecc34 100644
+--- a/elf/dl-tunables.list
++++ b/elf/dl-tunables.list
+@@ -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 --git a/scripts/gen-tunables.awk b/scripts/gen-tunables.awk
+index fa63e86d..29f94c63 100644
+--- a/scripts/gen-tunables.awk
++++ b/scripts/gen-tunables.awk
+@@ -177,8 +177,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 "};"
+--
+2.33.0
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-04-29 22:44:58 +0000