From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from cyan.elm.relay.mailchannels.net (cyan.elm.relay.mailchannels.net [23.83.212.47]) by sourceware.org (Postfix) with ESMTPS id 16412397141C for ; Wed, 10 Feb 2021 14:04:24 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.3.2 sourceware.org 16412397141C X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from relay.mailchannels.net (localhost [127.0.0.1]) by relay.mailchannels.net (Postfix) with ESMTP id DE93B40391D for ; Wed, 10 Feb 2021 13:56:51 +0000 (UTC) Received: from pdx1-sub0-mail-a29.g.dreamhost.com (100-96-18-11.trex.outbound.svc.cluster.local [100.96.18.11]) (Authenticated sender: dreamhost) by relay.mailchannels.net (Postfix) with ESMTPA id 7ED18403B0E for ; Wed, 10 Feb 2021 13:56:51 +0000 (UTC) X-Sender-Id: dreamhost|x-authsender|siddhesh@gotplt.org Received: from pdx1-sub0-mail-a29.g.dreamhost.com (pop.dreamhost.com [64.90.62.162]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384) by 100.96.18.11 (trex/6.0.2); Wed, 10 Feb 2021 13:56:51 +0000 X-MC-Relay: Neutral X-MailChannels-SenderId: dreamhost|x-authsender|siddhesh@gotplt.org X-MailChannels-Auth-Id: dreamhost X-Eyes-Descriptive: 6c37555875df2e78_1612965411757_317604741 X-MC-Loop-Signature: 1612965411757:3561347757 X-MC-Ingress-Time: 1612965411756 Received: from pdx1-sub0-mail-a29.g.dreamhost.com (localhost [127.0.0.1]) by pdx1-sub0-mail-a29.g.dreamhost.com (Postfix) with ESMTP id 3316D7F2B3 for ; Wed, 10 Feb 2021 05:56:51 -0800 (PST) Received: from rhbox.redhat.com (unknown [1.186.101.110]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) (Authenticated sender: siddhesh@gotplt.org) by pdx1-sub0-mail-a29.g.dreamhost.com (Postfix) with ESMTPSA id CFD067F182 for ; Wed, 10 Feb 2021 05:56:49 -0800 (PST) X-DH-BACKEND: pdx1-sub0-mail-a29 From: Siddhesh Poyarekar To: libc-stable@sourceware.org Subject: [COMMITTED/2.33 1/3] tunables: Simplify TUNABLE_SET interface Date: Wed, 10 Feb 2021 19:26:02 +0530 Message-Id: <20210210135604.445223-1-siddhesh@sourceware.org> X-Mailer: git-send-email 2.29.2 MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable X-Spam-Status: No, score=-3495.2 required=5.0 tests=BAYES_00, GIT_PATCH_0, JMQ_SPF_NEUTRAL, KAM_DMARC_NONE, KAM_DMARC_STATUS, RCVD_IN_BARRACUDACENTRAL, RCVD_IN_DNSWL_NONE, RCVD_IN_MSPIKE_H2, SPF_HELO_NONE, SPF_NEUTRAL, TXREP autolearn=ham autolearn_force=no version=3.4.2 X-Spam-Checker-Version: SpamAssassin 3.4.2 (2018-09-13) on server2.sourceware.org X-BeenThere: libc-stable@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Libc-stable mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 10 Feb 2021 14:04:27 -0000 The TUNABLE_SET interface took a primitive C type argument, which resulted in inconsistent type conversions internally due to incorrect dereferencing of types, especialy on 32-bit architectures. This change simplifies the TUNABLE setting logic along with the interfaces. Now all numeric tunable values are stored as signed numbers in tunable_num_t, which is intmax_t. All calls to set tunables cast the input value to its primitive type and then to tunable_num_t for storage. This relies on gcc-specific (although I suspect other compilers woul also do the same) unsigned to signed integer conversion semantics, i.e. the bit pattern is conserved. The reverse conversion is guaranteed by the standard. (cherry picked from commit 61117bfa1b08ca048e6512c0652c568300fedf6a) --- elf/dl-tunable-types.h | 4 +- elf/dl-tunables.c | 128 ++++++------------ elf/dl-tunables.h | 37 ++--- manual/README.tunables | 16 +-- .../unix/sysv/linux/aarch64/cpu-features.c | 2 +- sysdeps/x86/dl-cacheinfo.h | 15 +- 6 files changed, 75 insertions(+), 127 deletions(-) diff --git a/elf/dl-tunable-types.h b/elf/dl-tunable-types.h index 3fcc0806f5..626ca334be 100644 --- a/elf/dl-tunable-types.h +++ b/elf/dl-tunable-types.h @@ -38,8 +38,8 @@ typedef enum typedef struct { tunable_type_code_t type_code; - int64_t min; - int64_t max; + tunable_num_t min; + tunable_num_t max; } tunable_type_t; =20 /* Security level for tunables. This decides what to do with individual diff --git a/elf/dl-tunables.c b/elf/dl-tunables.c index b1a50b8469..a2be9cde2f 100644 --- a/elf/dl-tunables.c +++ b/elf/dl-tunables.c @@ -93,87 +93,45 @@ get_next_env (char **envp, char **name, size_t *namel= en, char **val, return NULL; } =20 -#define TUNABLE_SET_VAL_IF_VALID_RANGE(__cur, __val, __type) \ -({ \ - __type min =3D (__cur)->type.min; \ - __type max =3D (__cur)->type.max; \ - \ - if ((__type) (__val) >=3D min && (__type) (__val) <=3D max) \ - { \ - (__cur)->val.numval =3D (__val); \ - (__cur)->initialized =3D true; \ - } \ -}) - -#define TUNABLE_SET_BOUNDS_IF_VALID(__cur, __minp, __maxp, __type) = \ -({ \ - if (__minp !=3D NULL) \ - { \ - /* MIN is specified. */ \ - __type min =3D *((__type *) __minp); \ - if (__maxp !=3D NULL) \ - { \ - /* Both MIN and MAX are specified. */ \ - __type max =3D *((__type *) __maxp); \ - if (max >=3D min \ - && max <=3D (__cur)->type.max \ - && min >=3D (__cur)->type.min) \ - { \ - (__cur)->type.min =3D min; \ - (__cur)->type.max =3D max; \ - } \ - } \ - else if (min > (__cur)->type.min && min <=3D (__cur)->type.max) = \ - { \ - /* Only MIN is specified. */ \ - (__cur)->type.min =3D min; \ - } \ - } \ - else if (__maxp !=3D NULL) \ - { \ - /* Only MAX is specified. */ \ - __type max =3D *((__type *) __maxp); \ - if (max < (__cur)->type.max && max >=3D (__cur)->type.min) = \ - (__cur)->type.max =3D max; \ - } \ -}) - static void -do_tunable_update_val (tunable_t *cur, const void *valp, - const void *minp, const void *maxp) +do_tunable_update_val (tunable_t *cur, const tunable_val_t *valp, + const tunable_num_t *minp, + const tunable_num_t *maxp) { - uint64_t val; + tunable_num_t val, min, max; =20 - if (cur->type.type_code !=3D TUNABLE_TYPE_STRING) - val =3D *((int64_t *) valp); + if (cur->type.type_code =3D=3D TUNABLE_TYPE_STRING) + { + cur->val.strval =3D valp->strval; + cur->initialized =3D true; + return; + } =20 - switch (cur->type.type_code) + val =3D valp->numval; + min =3D minp !=3D NULL ? *minp : cur->type.min; + max =3D maxp !=3D NULL ? *maxp : cur->type.max; + + /* We allow only increasingly restrictive bounds. */ + if (min < cur->type.min) + min =3D cur->type.min; + + if (max > cur->type.max) + max =3D cur->type.max; + + /* Skip both bounds if they're inconsistent. */ + if (min > max) { - case TUNABLE_TYPE_INT_32: - { - TUNABLE_SET_BOUNDS_IF_VALID (cur, minp, maxp, int64_t); - TUNABLE_SET_VAL_IF_VALID_RANGE (cur, val, int64_t); - break; - } - case TUNABLE_TYPE_UINT_64: - { - TUNABLE_SET_BOUNDS_IF_VALID (cur, minp, maxp, uint64_t); - TUNABLE_SET_VAL_IF_VALID_RANGE (cur, val, uint64_t); - break; - } - case TUNABLE_TYPE_SIZE_T: - { - TUNABLE_SET_BOUNDS_IF_VALID (cur, minp, maxp, uint64_t); - TUNABLE_SET_VAL_IF_VALID_RANGE (cur, val, uint64_t); - break; - } - case TUNABLE_TYPE_STRING: - { - cur->val.strval =3D valp; - break; - } - default: - __builtin_unreachable (); + min =3D cur->type.min; + max =3D cur->type.max; + } + + /* Write everything out if the value and the bounds are valid. */ + if (min <=3D val && val <=3D max) + { + cur->val.numval =3D val; + cur->type.min =3D min; + cur->type.max =3D max; + cur->initialized =3D true; } } =20 @@ -182,24 +140,18 @@ do_tunable_update_val (tunable_t *cur, const void *= valp, static void tunable_initialize (tunable_t *cur, const char *strval) { - uint64_t val; - const void *valp; + tunable_val_t val; =20 if (cur->type.type_code !=3D TUNABLE_TYPE_STRING) - { - val =3D _dl_strtoul (strval, NULL); - valp =3D &val; - } + val.numval =3D (tunable_num_t) _dl_strtoul (strval, NULL); else - { - cur->initialized =3D true; - valp =3D strval; - } - do_tunable_update_val (cur, valp, NULL, NULL); + val.strval =3D strval; + do_tunable_update_val (cur, &val, NULL, NULL); } =20 void -__tunable_set_val (tunable_id_t id, void *valp, void *minp, void *maxp) +__tunable_set_val (tunable_id_t id, tunable_val_t *valp, tunable_num_t *= minp, + tunable_num_t *maxp) { tunable_t *cur =3D &tunable_list[id]; =20 diff --git a/elf/dl-tunables.h b/elf/dl-tunables.h index 971376ba8d..ba7ae6b52e 100644 --- a/elf/dl-tunables.h +++ b/elf/dl-tunables.h @@ -33,9 +33,11 @@ __tunables_init (char **unused __attribute__ ((unused)= )) # include # include =20 +typedef intmax_t tunable_num_t; + typedef union { - int64_t numval; + tunable_num_t numval; const char *strval; } tunable_val_t; =20 @@ -52,7 +54,8 @@ typedef void (*tunable_callback_t) (tunable_val_t *); extern void __tunables_init (char **); extern void __tunables_print (void); extern void __tunable_get_val (tunable_id_t, void *, tunable_callback_t)= ; -extern void __tunable_set_val (tunable_id_t, void *, void *, void *); +extern void __tunable_set_val (tunable_id_t, tunable_val_t *, tunable_nu= m_t *, + tunable_num_t *); rtld_hidden_proto (__tunables_init) rtld_hidden_proto (__tunables_print) rtld_hidden_proto (__tunable_get_val) @@ -64,20 +67,18 @@ rtld_hidden_proto (__tunable_set_val) #if defined TOP_NAMESPACE && defined TUNABLE_NAMESPACE # define TUNABLE_GET(__id, __type, __cb) \ TUNABLE_GET_FULL (TOP_NAMESPACE, TUNABLE_NAMESPACE, __id, __type, __cb= ) -# define TUNABLE_SET(__id, __type, __val) \ - TUNABLE_SET_FULL (TOP_NAMESPACE, TUNABLE_NAMESPACE, __id, __type, __va= l) -# define TUNABLE_SET_WITH_BOUNDS(__id, __type, __val, __min, __max) \ +# define TUNABLE_SET(__id, __val) \ + TUNABLE_SET_FULL (TOP_NAMESPACE, TUNABLE_NAMESPACE, __id, __val) +# define TUNABLE_SET_WITH_BOUNDS(__id, __val, __min, __max) \ TUNABLE_SET_WITH_BOUNDS_FULL (TOP_NAMESPACE, TUNABLE_NAMESPACE, __id, = \ - __type, __val, __min, __max) + __val, __min, __max) #else # define TUNABLE_GET(__top, __ns, __id, __type, __cb) \ TUNABLE_GET_FULL (__top, __ns, __id, __type, __cb) -# define TUNABLE_SET(__top, __ns, __id, __type, __val) \ - TUNABLE_SET_FULL (__top, __ns, __id, __type, __val) -# define TUNABLE_SET_WITH_BOUNDS(__top, __ns, __id, __type, __val, \ - __min, __max) \ - TUNABLE_SET_WITH_BOUNDS_FULL (__top, __ns, __id, __type, __val, \ - __min, __max) +# define TUNABLE_SET(__top, __ns, __id, __val) \ + TUNABLE_SET_FULL (__top, __ns, __id, __val) +# define TUNABLE_SET_WITH_BOUNDS(__top, __ns, __id, __val, __min, __max)= \ + TUNABLE_SET_WITH_BOUNDS_FULL (__top, __ns, __id, __val, __min, __max) #endif =20 /* Get and return a tunable value. If the tunable was set externally an= d __CB @@ -91,19 +92,19 @@ rtld_hidden_proto (__tunable_set_val) }) =20 /* Set a tunable value. */ -# define TUNABLE_SET_FULL(__top, __ns, __id, __type, __val) \ +# define TUNABLE_SET_FULL(__top, __ns, __id, __val) \ ({ \ __tunable_set_val (TUNABLE_ENUM_NAME (__top, __ns, __id), \ - & (__type) {__val}, NULL, NULL); \ + & (tunable_val_t) {.numval =3D __val}, NULL, NULL); \ }) =20 /* Set a tunable value together with min/max values. */ -# define TUNABLE_SET_WITH_BOUNDS_FULL(__top, __ns, __id, __type, __val, = \ - __min, __max) \ +# define TUNABLE_SET_WITH_BOUNDS_FULL(__top, __ns, __id,__val, __min, __= max) \ ({ \ __tunable_set_val (TUNABLE_ENUM_NAME (__top, __ns, __id), \ - & (__type) {__val}, & (__type) {__min}, \ - & (__type) {__max}); \ + & (tunable_val_t) {.numval =3D __val}, \ + & (tunable_num_t) {__min}, \ + & (tunable_num_t) {__max}); \ }) =20 /* Namespace sanity for callback functions. Use this macro to keep the diff --git a/manual/README.tunables b/manual/README.tunables index d8c768abcc..605ddd78cd 100644 --- a/manual/README.tunables +++ b/manual/README.tunables @@ -98,17 +98,16 @@ where it can expect the tunable value to be passed in= VALP. =20 Tunables in the module can be updated using: =20 - TUNABLE_SET (check, int32_t, val) + TUNABLE_SET (check, val) =20 -where 'check' is the tunable name, 'int32_t' is the C type of the tunabl= e and -'val' is a value of same type. +where 'check' is the tunable name and 'val' is a value of same type. =20 To get and set tunables in a different namespace from that module, use t= he full form of the macros as follows: =20 val =3D TUNABLE_GET_FULL (glibc, cpu, hwcap_mask, uint64_t, NULL) =20 - TUNABLE_SET_FULL (glibc, cpu, hwcap_mask, uint64_t, val) + TUNABLE_SET_FULL (glibc, cpu, hwcap_mask, val) =20 where 'glibc' is the top namespace, 'cpu' is the tunable namespace and t= he remaining arguments are the same as the short form macros. @@ -116,18 +115,17 @@ remaining arguments are the same as the short form = macros. The minimum and maximum values can updated together with the tunable val= ue using: =20 - TUNABLE_SET_WITH_BOUNDS (check, int32_t, val, min, max) + TUNABLE_SET_WITH_BOUNDS (check, val, min, max) =20 -where 'check' is the tunable name, 'int32_t' is the C type of the tunabl= e, -'val' is a value of same type, 'min' and 'max' are the minimum and maxim= um -values of the tunable. +where 'check' is the tunable name, 'val' is a value of same type, 'min' = and +'max' are the minimum and maximum values of the tunable. =20 To set the minimum and maximum values of tunables in a different namespa= ce from that module, use the full form of the macros as follows: =20 val =3D TUNABLE_GET_FULL (glibc, cpu, hwcap_mask, uint64_t, NULL) =20 - TUNABLE_SET_WITH_BOUNDS_FULL (glibc, cpu, hwcap_mask, uint64_t, val, m= in, max) + TUNABLE_SET_WITH_BOUNDS_FULL (glibc, cpu, hwcap_mask, val, min, max) =20 where 'glibc' is the top namespace, 'cpu' is the tunable namespace and t= he remaining arguments are the same as the short form macros. diff --git a/sysdeps/unix/sysv/linux/aarch64/cpu-features.c b/sysdeps/uni= x/sysv/linux/aarch64/cpu-features.c index fe52b6308e..db6aa3516c 100644 --- a/sysdeps/unix/sysv/linux/aarch64/cpu-features.c +++ b/sysdeps/unix/sysv/linux/aarch64/cpu-features.c @@ -104,7 +104,7 @@ init_cpu_features (struct cpu_features *cpu_features) cpu_features->mte_state =3D (GLRO (dl_hwcap2) & HWCAP2_MTE) ? mte_stat= e : 0; /* If we lack the MTE feature, disable the tunable, since it will otherwise cause instructions that won't run on this CPU to be used.= */ - TUNABLE_SET (glibc, mem, tagging, unsigned, cpu_features->mte_state); + TUNABLE_SET (glibc, mem, tagging, cpu_features->mte_state); # endif =20 if (cpu_features->mte_state & 2) diff --git a/sysdeps/x86/dl-cacheinfo.h b/sysdeps/x86/dl-cacheinfo.h index a31fa0783a..e0a72568d8 100644 --- a/sysdeps/x86/dl-cacheinfo.h +++ b/sysdeps/x86/dl-cacheinfo.h @@ -917,17 +917,14 @@ dl_init_cacheinfo (struct cpu_features *cpu_feature= s) rep_stosb_threshold =3D TUNABLE_GET (x86_rep_stosb_threshold, long int, NULL); =20 - TUNABLE_SET_WITH_BOUNDS (x86_data_cache_size, long int, data, + TUNABLE_SET_WITH_BOUNDS (x86_data_cache_size, data, 0, (long int) -1); + TUNABLE_SET_WITH_BOUNDS (x86_shared_cache_size, shared, 0, (long int) = -1); + TUNABLE_SET_WITH_BOUNDS (x86_non_temporal_threshold, non_temporal_thre= shold, 0, (long int) -1); - TUNABLE_SET_WITH_BOUNDS (x86_shared_cache_size, long int, shared, - 0, (long int) -1); - TUNABLE_SET_WITH_BOUNDS (x86_non_temporal_threshold, long int, - non_temporal_threshold, 0, (long int) -1); - TUNABLE_SET_WITH_BOUNDS (x86_rep_movsb_threshold, long int, - rep_movsb_threshold, + TUNABLE_SET_WITH_BOUNDS (x86_rep_movsb_threshold, rep_movsb_threshold, minimum_rep_movsb_threshold, (long int) -1); - TUNABLE_SET_WITH_BOUNDS (x86_rep_stosb_threshold, long int, - rep_stosb_threshold, 1, (long int) -1); + TUNABLE_SET_WITH_BOUNDS (x86_rep_stosb_threshold, rep_stosb_threshold,= 1, + (long int) -1); #endif =20 cpu_features->data_cache_size =3D data; --=20 2.29.2