From c0a7313e92e8969abb1a45e67637c711fc81e763 Mon Sep 17 00:00:00 2001 From: DistroBaker Date: Fri, 19 Feb 2021 18:21:03 +0000 Subject: [PATCH] Merged update from upstream sources This is an automated DistroBaker update from upstream sources. If you do not know what this is about or would like to opt out, contact the OSCI team. Source: https://src.fedoraproject.org/rpms/glibc.git#40ad858c64f2a5eb509c81e29d63a1ad65c86256 --- glibc-upstream-2.33-1.patch | 42 +++++ glibc-upstream-2.33-2.patch | 364 ++++++++++++++++++++++++++++++++++++ glibc-upstream-2.33-3.patch | 35 ++++ glibc-upstream-2.33-4.patch | 67 +++++++ glibc-upstream-2.33-5.patch | 62 ++++++ glibc-upstream-2.33-6.patch | 52 ++++++ glibc.spec | 30 ++- sources | 2 +- 8 files changed, 648 insertions(+), 6 deletions(-) create mode 100644 glibc-upstream-2.33-1.patch create mode 100644 glibc-upstream-2.33-2.patch create mode 100644 glibc-upstream-2.33-3.patch create mode 100644 glibc-upstream-2.33-4.patch create mode 100644 glibc-upstream-2.33-5.patch create mode 100644 glibc-upstream-2.33-6.patch diff --git a/glibc-upstream-2.33-1.patch b/glibc-upstream-2.33-1.patch new file mode 100644 index 0000000..eca0f85 --- /dev/null +++ b/glibc-upstream-2.33-1.patch @@ -0,0 +1,42 @@ +commit 17f0ff097887008b2d3dca270c8ffbb4b43a8749 +Author: Sergei Trofimovich +Date: Fri Feb 5 07:32:18 2021 +0000 + + nsswitch: return result when nss database is locked [BZ #27343] + + Before the change nss_database_check_reload_and_get() did not populate + the '*result' value when it returned success in a case of chroot + detection. This caused initgroups() to use garage pointer in the + following test (extracted from unbound): + + ``` + + int main() { + // load some NSS modules + struct passwd * pw = getpwnam("root"); + + chdir("/tmp"); + chroot("/tmp"); + chdir("/"); + // access nsswitch.conf in a chroot + initgroups("root", 0); + } + ``` + + Reviewed-by: DJ Delorie + +diff --git a/nss/nss_database.c b/nss/nss_database.c +index cf0306adc47f12d9..e1bef6bd75ce0160 100644 +--- a/nss/nss_database.c ++++ b/nss/nss_database.c +@@ -398,8 +398,9 @@ nss_database_check_reload_and_get (struct nss_database_state *local, + && (str.st_ino != local->root_ino + || str.st_dev != local->root_dev))) + { +- /* Change detected; disable reloading. */ ++ /* Change detected; disable reloading and return current state. */ + atomic_store_release (&local->data.reload_disabled, 1); ++ *result = local->data.services[database_index]; + __libc_lock_unlock (local->lock); + __nss_module_disable_loading (); + return true; diff --git a/glibc-upstream-2.33-2.patch b/glibc-upstream-2.33-2.patch new file mode 100644 index 0000000..cab93f3 --- /dev/null +++ b/glibc-upstream-2.33-2.patch @@ -0,0 +1,364 @@ +commit 15afd6b8d8263010ed41bca09e62fefec1b7b3f8 +Author: Siddhesh Poyarekar +Date: Fri Feb 5 13:18:58 2021 +0530 + + tunables: Simplify TUNABLE_SET interface + + 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) + +diff --git a/elf/dl-tunable-types.h b/elf/dl-tunable-types.h +index 3fcc0806f5f2ec04..626ca334be105e69 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; + + /* Security level for tunables. This decides what to do with individual +diff --git a/elf/dl-tunables.c b/elf/dl-tunables.c +index b1a50b84693d15de..a2be9cde2f7333ea 100644 +--- a/elf/dl-tunables.c ++++ b/elf/dl-tunables.c +@@ -93,87 +93,45 @@ get_next_env (char **envp, char **name, size_t *namelen, char **val, + return NULL; + } + +-#define TUNABLE_SET_VAL_IF_VALID_RANGE(__cur, __val, __type) \ +-({ \ +- __type min = (__cur)->type.min; \ +- __type max = (__cur)->type.max; \ +- \ +- if ((__type) (__val) >= min && (__type) (__val) <= max) \ +- { \ +- (__cur)->val.numval = (__val); \ +- (__cur)->initialized = true; \ +- } \ +-}) +- +-#define TUNABLE_SET_BOUNDS_IF_VALID(__cur, __minp, __maxp, __type) \ +-({ \ +- if (__minp != NULL) \ +- { \ +- /* MIN is specified. */ \ +- __type min = *((__type *) __minp); \ +- if (__maxp != NULL) \ +- { \ +- /* Both MIN and MAX are specified. */ \ +- __type max = *((__type *) __maxp); \ +- if (max >= min \ +- && max <= (__cur)->type.max \ +- && min >= (__cur)->type.min) \ +- { \ +- (__cur)->type.min = min; \ +- (__cur)->type.max = max; \ +- } \ +- } \ +- else if (min > (__cur)->type.min && min <= (__cur)->type.max) \ +- { \ +- /* Only MIN is specified. */ \ +- (__cur)->type.min = min; \ +- } \ +- } \ +- else if (__maxp != NULL) \ +- { \ +- /* Only MAX is specified. */ \ +- __type max = *((__type *) __maxp); \ +- if (max < (__cur)->type.max && max >= (__cur)->type.min) \ +- (__cur)->type.max = 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; + +- if (cur->type.type_code != TUNABLE_TYPE_STRING) +- val = *((int64_t *) valp); ++ if (cur->type.type_code == TUNABLE_TYPE_STRING) ++ { ++ cur->val.strval = valp->strval; ++ cur->initialized = true; ++ return; ++ } + +- switch (cur->type.type_code) ++ val = valp->numval; ++ min = minp != NULL ? *minp : cur->type.min; ++ max = maxp != NULL ? *maxp : cur->type.max; ++ ++ /* We allow only increasingly restrictive bounds. */ ++ if (min < cur->type.min) ++ min = cur->type.min; ++ ++ if (max > cur->type.max) ++ max = 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 = valp; +- break; +- } +- default: +- __builtin_unreachable (); ++ min = cur->type.min; ++ max = cur->type.max; ++ } ++ ++ /* Write everything out if the value and the bounds are valid. */ ++ if (min <= val && val <= max) ++ { ++ cur->val.numval = val; ++ cur->type.min = min; ++ cur->type.max = max; ++ cur->initialized = true; + } + } + +@@ -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; + + if (cur->type.type_code != TUNABLE_TYPE_STRING) +- { +- val = _dl_strtoul (strval, NULL); +- valp = &val; +- } ++ val.numval = (tunable_num_t) _dl_strtoul (strval, NULL); + else +- { +- cur->initialized = true; +- valp = strval; +- } +- do_tunable_update_val (cur, valp, NULL, NULL); ++ val.strval = strval; ++ do_tunable_update_val (cur, &val, NULL, NULL); + } + + 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 = &tunable_list[id]; + +diff --git a/elf/dl-tunables.h b/elf/dl-tunables.h +index 971376ba8d3bad1c..ba7ae6b52ecea7a3 100644 +--- a/elf/dl-tunables.h ++++ b/elf/dl-tunables.h +@@ -33,9 +33,11 @@ __tunables_init (char **unused __attribute__ ((unused))) + # include + # include + ++typedef intmax_t tunable_num_t; ++ + typedef union + { +- int64_t numval; ++ tunable_num_t numval; + const char *strval; + } tunable_val_t; + +@@ -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_num_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, __val) +-# 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 + + /* Get and return a tunable value. If the tunable was set externally and __CB +@@ -91,19 +92,19 @@ rtld_hidden_proto (__tunable_set_val) + }) + + /* 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 = __val}, NULL, NULL); \ + }) + + /* 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 = __val}, \ ++ & (tunable_num_t) {__min}, \ ++ & (tunable_num_t) {__max}); \ + }) + + /* Namespace sanity for callback functions. Use this macro to keep the +diff --git a/manual/README.tunables b/manual/README.tunables +index d8c768abcc70b5a4..605ddd78cd52b5ef 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. + + Tunables in the module can be updated using: + +- TUNABLE_SET (check, int32_t, val) ++ TUNABLE_SET (check, val) + +-where 'check' is the tunable name, 'int32_t' is the C type of the tunable and +-'val' is a value of same type. ++where 'check' is the tunable name and 'val' is a value of same type. + + To get and set tunables in a different namespace from that module, use the full + form of the macros as follows: + + val = TUNABLE_GET_FULL (glibc, cpu, hwcap_mask, uint64_t, NULL) + +- TUNABLE_SET_FULL (glibc, cpu, hwcap_mask, uint64_t, val) ++ TUNABLE_SET_FULL (glibc, cpu, hwcap_mask, val) + + where 'glibc' is the top namespace, 'cpu' is the tunable namespace and the + 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 value + using: + +- TUNABLE_SET_WITH_BOUNDS (check, int32_t, val, min, max) ++ TUNABLE_SET_WITH_BOUNDS (check, val, min, max) + +-where 'check' is the tunable name, 'int32_t' is the C type of the tunable, +-'val' is a value of same type, 'min' and 'max' are the minimum and maximum +-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. + + To set the minimum and maximum values of tunables in a different namespace + from that module, use the full form of the macros as follows: + + val = TUNABLE_GET_FULL (glibc, cpu, hwcap_mask, uint64_t, NULL) + +- TUNABLE_SET_WITH_BOUNDS_FULL (glibc, cpu, hwcap_mask, uint64_t, val, min, max) ++ TUNABLE_SET_WITH_BOUNDS_FULL (glibc, cpu, hwcap_mask, val, min, max) + + where 'glibc' is the top namespace, 'cpu' is the tunable namespace and the + remaining arguments are the same as the short form macros. +diff --git a/sysdeps/unix/sysv/linux/aarch64/cpu-features.c b/sysdeps/unix/sysv/linux/aarch64/cpu-features.c +index fe52b6308ee0ff72..db6aa3516c1b5cb1 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 = (GLRO (dl_hwcap2) & HWCAP2_MTE) ? mte_state : 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 + + if (cpu_features->mte_state & 2) +diff --git a/sysdeps/x86/dl-cacheinfo.h b/sysdeps/x86/dl-cacheinfo.h +index a31fa0783a23a9d8..e0a72568d8174db7 100644 +--- a/sysdeps/x86/dl-cacheinfo.h ++++ b/sysdeps/x86/dl-cacheinfo.h +@@ -917,17 +917,14 @@ dl_init_cacheinfo (struct cpu_features *cpu_features) + rep_stosb_threshold = TUNABLE_GET (x86_rep_stosb_threshold, + long int, NULL); + +- 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_threshold, + 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 + + cpu_features->data_cache_size = data; diff --git a/glibc-upstream-2.33-3.patch b/glibc-upstream-2.33-3.patch new file mode 100644 index 0000000..c596a9c --- /dev/null +++ b/glibc-upstream-2.33-3.patch @@ -0,0 +1,35 @@ +commit 905fdc7071638612027739d74d63fc91debb0325 +Author: Siddhesh Poyarekar +Date: Wed Feb 3 20:03:19 2021 +0530 + + x86: Use SIZE_MAX instead of (long int)-1 for tunable range value + + The tunable types are SIZE_T, so set the ranges to the correct maximum + value, i.e. SIZE_MAX. + + (cherry picked from commit a1b8b06a55c1ee581d5ef860cec214b0c27a66f0) + +diff --git a/sysdeps/x86/dl-cacheinfo.h b/sysdeps/x86/dl-cacheinfo.h +index e0a72568d8174db7..6f91651f0da1d46a 100644 +--- a/sysdeps/x86/dl-cacheinfo.h ++++ b/sysdeps/x86/dl-cacheinfo.h +@@ -917,14 +917,14 @@ dl_init_cacheinfo (struct cpu_features *cpu_features) + rep_stosb_threshold = TUNABLE_GET (x86_rep_stosb_threshold, + long int, NULL); + +- 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_data_cache_size, data, 0, SIZE_MAX); ++ TUNABLE_SET_WITH_BOUNDS (x86_shared_cache_size, shared, 0, SIZE_MAX); + TUNABLE_SET_WITH_BOUNDS (x86_non_temporal_threshold, non_temporal_threshold, +- 0, (long int) -1); ++ 0, SIZE_MAX); + TUNABLE_SET_WITH_BOUNDS (x86_rep_movsb_threshold, rep_movsb_threshold, +- minimum_rep_movsb_threshold, (long int) -1); ++ minimum_rep_movsb_threshold, SIZE_MAX); + TUNABLE_SET_WITH_BOUNDS (x86_rep_stosb_threshold, rep_stosb_threshold, 1, +- (long int) -1); ++ SIZE_MAX); + #endif + + cpu_features->data_cache_size = data; diff --git a/glibc-upstream-2.33-4.patch b/glibc-upstream-2.33-4.patch new file mode 100644 index 0000000..602a7a7 --- /dev/null +++ b/glibc-upstream-2.33-4.patch @@ -0,0 +1,67 @@ +commit c5e354589729c0ca63899923f18783fa6803462d +Author: Siddhesh Poyarekar +Date: Fri Feb 5 14:09:24 2021 +0530 + + tunables: Disallow negative values for some tunables + + The glibc.malloc.mmap_max tunable as well as al of the INT_32 tunables + don't have use for negative values, so pin the hardcoded limits in the + non-negative range of INT. There's no real benefit in any of those + use cases for the extended range of unsigned, so I have avoided added + a new type to keep things simple. + + (cherry picked from commit 228f30ab4724d4087d5f52018873fde22efea6e2) + +diff --git a/elf/dl-tunables.list b/elf/dl-tunables.list +index 3cf0ad83eca89200..8ddd4a23142a941b 100644 +--- a/elf/dl-tunables.list ++++ b/elf/dl-tunables.list +@@ -64,6 +64,7 @@ glibc { + type: INT_32 + env_alias: MALLOC_MMAP_MAX_ + security_level: SXID_IGNORE ++ minval: 0 + } + arena_max { + type: SIZE_T +@@ -109,22 +110,27 @@ glibc { + skip_lock_busy { + type: INT_32 + default: 3 ++ minval: 0 + } + skip_lock_internal_abort { + type: INT_32 + default: 3 ++ minval: 0 + } + skip_lock_after_retries { + type: INT_32 + default: 3 ++ minval: 0 + } + tries { + type: INT_32 + default: 3 ++ minval: 0 + } + skip_trylock_internal_abort { + type: INT_32 + default: 3 ++ minval: 0 + } + } + +diff --git a/elf/tst-rtld-list-tunables.exp b/elf/tst-rtld-list-tunables.exp +index 4f3f7ee4e30a2b42..9f66c528855fb21d 100644 +--- a/elf/tst-rtld-list-tunables.exp ++++ b/elf/tst-rtld-list-tunables.exp +@@ -1,7 +1,7 @@ + glibc.malloc.arena_max: 0x0 (min: 0x1, max: 0x[f]+) + glibc.malloc.arena_test: 0x0 (min: 0x1, max: 0x[f]+) + glibc.malloc.check: 0 (min: 0, max: 3) +-glibc.malloc.mmap_max: 0 (min: -2147483648, max: 2147483647) ++glibc.malloc.mmap_max: 0 (min: 0, max: 2147483647) + glibc.malloc.mmap_threshold: 0x0 (min: 0x0, max: 0x[f]+) + glibc.malloc.mxfast: 0x0 (min: 0x0, max: 0x[f]+) + glibc.malloc.perturb: 0 (min: 0, max: 255) diff --git a/glibc-upstream-2.33-5.patch b/glibc-upstream-2.33-5.patch new file mode 100644 index 0000000..6020f1b --- /dev/null +++ b/glibc-upstream-2.33-5.patch @@ -0,0 +1,62 @@ +commit 6efa2d44c8a5aeb34bd1f26b707c1713aac5bdd4 +Author: Stefan Liebler +Date: Tue Feb 16 16:18:56 2021 +0100 + + S390: Add new hwcap values. + + The new hwcap values indicate support for arch14 architecture. + + (cherry picked from commit 25251c0707fe34f30a27381a5fabc35435a96621) + +diff --git a/sysdeps/s390/dl-procinfo.c b/sysdeps/s390/dl-procinfo.c +index 0c334a2551c79be8..c174e27b3559c57c 100644 +--- a/sysdeps/s390/dl-procinfo.c ++++ b/sysdeps/s390/dl-procinfo.c +@@ -46,12 +46,13 @@ + #if !defined PROCINFO_DECL && defined SHARED + ._dl_s390_cap_flags + #else +-PROCINFO_CLASS const char _dl_s390_cap_flags[19][9] ++PROCINFO_CLASS const char _dl_s390_cap_flags[21][9] + #endif + #ifndef PROCINFO_DECL + = { + "esan3", "zarch", "stfle", "msa", "ldisp", "eimm", "dfp", "edat", "etf3eh", +- "highgprs", "te", "vx", "vxd", "vxe", "gs", "vxe2", "vxp", "sort", "dflt" ++ "highgprs", "te", "vx", "vxd", "vxe", "gs", "vxe2", "vxp", "sort", "dflt", ++ "vxp2", "nnpa" + } + #endif + #if !defined SHARED || defined PROCINFO_DECL +diff --git a/sysdeps/s390/dl-procinfo.h b/sysdeps/s390/dl-procinfo.h +index 9e1a8c7ba9b8e01b..2d9c3058083e5dda 100644 +--- a/sysdeps/s390/dl-procinfo.h ++++ b/sysdeps/s390/dl-procinfo.h +@@ -21,7 +21,7 @@ + #define _DL_PROCINFO_H 1 + #include + +-#define _DL_HWCAP_COUNT 19 ++#define _DL_HWCAP_COUNT 21 + + #define _DL_PLATFORMS_COUNT 10 + +@@ -61,6 +61,8 @@ enum + HWCAP_S390_VXRS_PDE = 1 << 16, + HWCAP_S390_SORT = 1 << 17, + HWCAP_S390_DFLT = 1 << 18, ++ HWCAP_S390_VXRS_PDE2 = 1 << 19, ++ HWCAP_S390_NNPA = 1 << 20, + }; + + #define HWCAP_IMPORTANT (HWCAP_S390_ZARCH | HWCAP_S390_LDISP \ +diff --git a/sysdeps/unix/sysv/linux/s390/bits/hwcap.h b/sysdeps/unix/sysv/linux/s390/bits/hwcap.h +index 696616e77923f654..e9bd3684db862d1b 100644 +--- a/sysdeps/unix/sysv/linux/s390/bits/hwcap.h ++++ b/sysdeps/unix/sysv/linux/s390/bits/hwcap.h +@@ -46,3 +46,5 @@ + #define HWCAP_S390_VXRS_PDE 65536 + #define HWCAP_S390_SORT 131072 + #define HWCAP_S390_DFLT 262144 ++#define HWCAP_S390_VXRS_PDE2 524288 ++#define HWCAP_S390_NNPA 1048576 diff --git a/glibc-upstream-2.33-6.patch b/glibc-upstream-2.33-6.patch new file mode 100644 index 0000000..29b65b2 --- /dev/null +++ b/glibc-upstream-2.33-6.patch @@ -0,0 +1,52 @@ +commit 8d4241b8976273513e72cc1c5f6b1af3e11f0792 +Author: Florian Weimer +Date: Fri Feb 19 13:29:00 2021 +0100 + + string: Work around GCC PR 98512 in rawmemchr + + (cherry picked from commit 044e603b698093cf48f6e6229e0b66acf05227e4) + +diff --git a/string/rawmemchr.c b/string/rawmemchr.c +index 59bbeeaa42e51056..b8523118e5b3586e 100644 +--- a/string/rawmemchr.c ++++ b/string/rawmemchr.c +@@ -22,24 +22,28 @@ + # define RAWMEMCHR __rawmemchr + #endif + +-/* Find the first occurrence of C in S. */ +-void * +-RAWMEMCHR (const void *s, int c) +-{ +- DIAG_PUSH_NEEDS_COMMENT; ++/* The pragmata should be nested inside RAWMEMCHR below, but that ++ triggers GCC PR 98512. */ ++DIAG_PUSH_NEEDS_COMMENT; + #if __GNUC_PREREQ (7, 0) +- /* GCC 8 warns about the size passed to memchr being larger than +- PTRDIFF_MAX; the use of SIZE_MAX is deliberate here. */ +- DIAG_IGNORE_NEEDS_COMMENT (8, "-Wstringop-overflow="); ++/* GCC 8 warns about the size passed to memchr being larger than ++ PTRDIFF_MAX; the use of SIZE_MAX is deliberate here. */ ++DIAG_IGNORE_NEEDS_COMMENT (8, "-Wstringop-overflow="); + #endif + #if __GNUC_PREREQ (11, 0) +- /* Likewise GCC 11, with a different warning option. */ +- DIAG_IGNORE_NEEDS_COMMENT (11, "-Wstringop-overread"); ++/* Likewise GCC 11, with a different warning option. */ ++DIAG_IGNORE_NEEDS_COMMENT (11, "-Wstringop-overread"); + #endif ++ ++/* Find the first occurrence of C in S. */ ++void * ++RAWMEMCHR (const void *s, int c) ++{ + if (c != '\0') + return memchr (s, c, (size_t)-1); +- DIAG_POP_NEEDS_COMMENT; + return (char *)s + strlen (s); + } + libc_hidden_def (__rawmemchr) + weak_alias (__rawmemchr, rawmemchr) ++ ++DIAG_POP_NEEDS_COMMENT; diff --git a/glibc.spec b/glibc.spec index e5bbfcc..8fb3d7e 100644 --- a/glibc.spec +++ b/glibc.spec @@ -1,5 +1,5 @@ -%define glibcsrcdir glibc-2.32.9000-573-gdf359a25ba -%define glibcversion 2.32.9000 +%define glibcsrcdir glibc-2.33 +%define glibcversion 2.33 # Pre-release tarballs are pulled in from git using a command that is # effectively: # @@ -27,8 +27,8 @@ %bcond_without benchtests # Default: Not bootstrapping. %bcond_with bootstrap -# Default: Disable -Werror due to GCC PR98512. -%bcond_with werror +# Default: Treat warnings as errors. +%bcond_without werror # Default: Always build documentation. %bcond_without docs @@ -96,7 +96,7 @@ Summary: The GNU libc libraries Name: glibc Version: %{glibcversion} -Release: 29%{?dist} +Release: 2%{?dist} # In general, GPLv2+ is used by programs, LGPLv2+ is used for # libraries. @@ -155,6 +155,12 @@ Patch23: glibc-python3.patch Patch29: glibc-fedora-nsswitch.patch Patch30: glibc-deprecated-selinux-makedb.patch Patch31: glibc-deprecated-selinux-nscd.patch +Patch32: glibc-upstream-2.33-1.patch +Patch33: glibc-upstream-2.33-2.patch +Patch34: glibc-upstream-2.33-3.patch +Patch35: glibc-upstream-2.33-4.patch +Patch36: glibc-upstream-2.33-5.patch +Patch37: glibc-upstream-2.33-6.patch ############################################################################## # Continued list of core "glibc" package information: @@ -2290,6 +2296,20 @@ fi %files -f compat-libpthread-nonshared.filelist -n compat-libpthread-nonshared %changelog +* Fri Feb 19 2021 Florian Weimer - 2.33-2 +- Re-enable -Werror; GCC PR 98512 workaround applied upstream +- Import patches from the upstream glibc 2.33 branch, up to commit + 8d4241b8976273513e72cc1c5f6b1af3e11f0792. +- string: Work around GCC PR 98512 in rawmemchr +- S390: Add new hwcap values. +- tunables: Disallow negative values for some tunables +- x86: Use SIZE_MAX instead of (long int)-1 for tunable range value +- tunables: Simplify TUNABLE_SET interface +- nsswitch: return result when nss database is locked [BZ #27343] + +* Mon Feb 15 2021 Florian Weimer - 2.33-1 +- Switch to glibc 2.33 upstream release tarball + * Wed Jan 27 2021 Arjun Shankar - 2.32.9000-29 - Auto-sync with upstream branch master, commit df359a25ba6f6bda06104229fbfe284c1fb30915: diff --git a/sources b/sources index 7ca9589..06d649e 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (glibc-2.32.9000-573-gdf359a25ba.tar.xz) = d5457c1756810308d4ec643c4f1a19a575656b9617db34909848c9ed877d09045bc1bd447189dccce59bcbe905bac56154e7a5896c9ebcb9b89f0a22643f816f +SHA512 (glibc-2.33.tar.xz) = 4cb5777b68b22b746cc51669e0e9282b43c83f6944e42656e6db7195ebb68f2f9260f130fdeb4e3cfc64efae4f58d96c43d388f52be1eb024ca448084684abdb