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