From 5f35090dc809872fb7b8f381c1ccf995b75f03a0 Mon Sep 17 00:00:00 2001 From: Andrew Geissler Date: Fri, 23 Jul 2021 13:09:54 -0400 Subject: poky: subtree update:2834c2f853..17aabc0127 MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Adam Romanek (3): bitbake: fetch/git: run gc in foreground to avoid race with tar bitbake: fetch2/s3: allow to use credentials from environment variables own-mirrors: Add support for s3:// scheme in SOURCE_MIRROR_URL Alexander Kanavin (44): devtool upgrade: rebase override-only patches as well cmake: update 3.20.3 -> 3.20.4 gnu-config: update to latest revision bash: update 5.1 -> 5.1.8 dnf: updatee 4.7.0 -> 4.8.0 vulkan-samples: update to latest revision bind: upgrade 9.16.16 -> 9.16.18 bluez5: upgrade 5.58 -> 5.59 dejagnu: upgrade 1.6.2 -> 1.6.3 libdnf: upgrade 0.63.0 -> 0.63.1 libpcre: upgrade 8.44 -> 8.45 libxi: upgrade 1.7.10 -> 1.7.99.2 mtools: upgrade 4.0.29 -> 4.0.31 python3-git: upgrade 3.1.17 -> 3.1.18 sqlite3: upgrade 3.35.5 -> 3.36.0 vte: upgrade 0.64.1 -> 0.64.2 x264: upgrade to latest revision python3: apply test skipping patch unconditionally pypi: set SRC_URI with _prepend, not with += man-pages: upgrade 5.11 -> 5.12 rt-tests: update 1.10 -> 2.1 python3-iniparse: update 0.4 -> 0.5 iputils: correct upstream version check texinfo: update 6.7 -> 6.8 xserver-xorg: exclude development snapshots from upstream version checks xwayland: exclude development snapshots from upstream version checks devtool: correctly handle non-standard source tree locations in upgrades llvm: make upgradable via devtool xserver-xorg: update 1.20.11 -> 1.20.12 libmodulemd: update 2.12.1 -> 2.13.0 bluez5: upgrade 5.59 -> 5.60 createrepo-c: upgrade 0.17.3 -> 0.17.4 ethtool: upgrade 5.12 -> 5.13 gtk+3: upgrade 3.24.29 -> 3.24.30 harfbuzz: upgrade 2.8.1 -> 2.8.2 iproute2: upgrade 5.12.0 -> 5.13.0 libgit2: upgrade 1.1.0 -> 1.1.1 mpg123: upgrade 1.28.0 -> 1.28.2 mtools: upgrade 4.0.31 -> 4.0.32 ruby: upgrade 3.0.1 -> 3.0.2 stress-ng: upgrade 0.12.11 -> 0.12.12 webkitgtk: upgrade 2.32.1 -> 2.32.2 xwayland: upgrade 21.1.1 -> 21.1.2 tcl: fix upstream version check Alexey Brodkin (3): dpkg: Add ARC support default-distrovars.inc: Remove seccomp for ARC dhcpcd: add ARC support Andreas Müller (4): libdrm: upgrade 2.4.106 -> 2.4.107 mesa: upgrade 21.1.3 -> 21.1.4 pango: upgrade 1.48.5 -> 1.48.7 mesa: upgrade 21.1.4 -> 21.1.5 Andrej Valek (1): busybox: add tmpdir option into mktemp applet Armin Kuster (1): maintainers.inc: remove myself as a Maintainer Asfak Rahman (1): openssh: Remove temporary keys before generating new ones Bruce Ashfield (24): linux-yocto/5.10: update to v5.10.46 linux-yocto/5.10: features/nft_tables: refresh config options linux-yocto/5.4: update to v5.4.128 linux-yocto/5.10: rcu: Fix stall-warning deadlock due to non-release of rcu_node ->lock linux-yocto/5.10: update to v5.10.47 linux-yocto/5.4: update to v5.4.129 linux-yocto/5.10: scsi-debug needs scsi-disk linux-libc-headers: update to 5.13 kernel-devsrc: fix scripts/prepare for ARM64 kernel-devsrc: fix scripts prepare for powerpc kernel-devsrc: powerpc64 add scripts prepare support linux-yocto: introduce 5.13 recipes linux-yocto/5.13: add devupstream support linux-yocto-rt/5.13: integrate -rt1 linux-yocto: add vfat KERNEL_FEATURE when MACHINE_FEATURES include vfat linux-yocto/5.10: update to v5.10.49 linux-yocto/5.4: update to v5.4.131 linux-yocto/5.13: update to v5.13.2 linux-yocto/5.10: update to v5.10.50 linux-yocto/5.4: update to v5.4.132 linux-yocto/5.13: update to v5.13.3 linux-yocto/5.13: update to v5.13.4 linux-yocto/5.10: update to v5.10.52 linux-yocto/5.4: update to v5.4.134 Changhyeok Bae (1): iputils: Update to 20210202 Changqing Li (1): boost-build-native: workaround one rarely hang problem on fedora34 Christoph Muellner (1): ldconfig-native: Add RISC-V support Damian Wrobel (1): gobject-introspection: Fix the license (add MIT) Denys Dmytriyenko (1): bitbake: providers: replace newly added logger.warn() with logger.warning() Fabio Berton (1): lib/oe/package_manager: Don't ignore installation failures in install_complementary Florian Amstutz (1): devtool: deploy-target: Fix preserving attributes when using --strip Jose Quaresma (3): glslang: upgrade 11.4.0 -> 11.5.0 shaderc: upgrade 2021.0 -> 2021.1 spirv-tools: upgrade 2021.1 -> 2021.2 Joshua Watt (3): ref-manual: Document BUILDHISTORY_PATH_PREFIX_STRIP bitbake: bitbake: Add piping compression library bitbake: server: Fix early parsing errors preventing zombie bitbake Khem Raj (7): glib-2.0: Fix signature of close_range gnome-desktop-testing: Fix non-literal format string warning util-linux: Disable chfn-chsh on non-target builds libseccomp: Update to main branch systemd: Fix libseccomp testcase involving __NR_ppoll util-linux: Fix signature of close_range() gpgme: Use glibc provided closefrom API when available Lee Chee Yang (1): qemu: fix CVE-2021-3527 Marek Vasut (2): pulseaudio: Drop pulseaudio-conf update-rc.d: update SRCREV to pull in fix for non-bash shell support Mark Hatle (1): populate_sdk_ext: Error if trying to generate an eSDK from a mulitconfig Max Krummenacher (1): xwayland: port packageconfig from xserver-xorg recipe Michael Halstead (1): releases: update to include 3.1.9 Michael Ho (1): sstate.bbclass: fix errors about read-only sstate mirrors Mike Crowe (1): licence_image: Add lic-pkgs IMAGE_FEATURE Mingli Yu (4): pulseaudio: check if NEON code can be compiled on arm perlcross: check the file if patched or not perl: correct libpth and glibpth parselogs.py: ignore rndr initialization failure Patrick Williams (1): docs: remove image-mklibs references Paul Barker (1): linux-yocto: Fix devupstream SRCREV assignment Peter Bergin (1): Revert "libubootenv: inherit uboot-config" Quentin Schulz (1): docs: replace remaining ``FOO`` by :term:`FOO` Ralph Siemsen (1): oeqa/manual/toaster: fix small typo Richard Purdie (26): package_pkgdata: Avoid task hash mismatches for generic task changes selftest/fetch: Avoid occasional selftest failure from poor temp file name choice kernel: Fix interaction when packaging disabled kernel-devicetree: Fix interaction when packaging disabled python3-pip/python3-pbr: Drop obsolete md5sum at upgrade oeqa/selftest/runcmd: Tweal test timeouts bash: Fix a rare make race build failure sstate/staging: Handle directory creation race issue oeqa/selftest/archiver: Allow tests to ignore empty directories dwarfsrcfiles: Avoid races over debug-link files oeqa/selftest/multiprocesslauch: Fix test race runqemu: Remove potential lock races around tap device handling glibc-testsuite: Fix build failures when directly running recipe license: Drop adding RRECOMMENDS for license packages report-error: Drop pointless inherit pseudo: Add uninative configuration sanity check pseudo: Update to latest version including statx fix sstate: Drop pseudo exclusion oeqa/qemurunner: Handle files no longer existing gracefully python3: Add a fix for a make install race Add README link to README.poky README.OE-Core/README.qemu: Move to markdown format bitbake: data_smart/parse: Allow ':' characters in variable/function names zstd: Include pzstd in the build buildtools-tarball: Add lz4 and ztsd (including pzstd) build-appliance-image: Update to master head revision Ross Burton (29): glibc: backport MTE improvements from master glibc: re-enable memory tagging libgudev: fix SRC_URI cantarell-fonts: fix SRC_URI shadow: generate alternative links for chfn and chsh util-linux: build chfn and chsh util-linux: add missing ptest dependencies util-linux: backport test suite fixes util-linux: rewrite the ptest integration glib-2.0: fix g-file-into modification time test oeqa/selftest/recipetool: update socat version to fix failing download parted: improve ptest execution tcl: suffix all Tcl man pages instead of using alternatives tcl: EXTRA_OECONF already passes --libdir, don't do it again tcl: mark a patch as upstreamable tcl: use tcl-core instead of patching out packages tcl: use AUTOTOOLS_SCRIPT_PATH tcl: remove redundant file creation tcl: detect tests that error as well as fail tcl: clock.test needs a timezone to be set tcl: fix race in interp.test parted: remove obsolete patch parted: fix ptest RRECOMMENDS busybox: support mounting swap via labels meta: remove redundant ${libdir}/cmake from FILES_${PN}-dev cups: update to 2.3.3op2 parted: skip tests that need vfat support avahi: fix CVE-2021-36217, crash on pinging '.local' parted: add device mappper PACKAGECONFIG Sakib Sajal (3): buildstats.bbclass: log host data on failure to task specific file oe-time-dd-test.sh: add options and refactor scripts/oe-time-dd-test.sh: run "uptime" on each iteration Saul Wold (4): qemurunner: Add info log for qemu startup oeqa/qemurunner: add support qmp cmd args oeqa/dump.py: Add support for QMP command arguments testimage.bbclass: Add dump-guest-memory cmd Scott Weaver (1): meta-skeleton: update to satisfy yocto-check-layer tests Tim Orling (6): python3-importlib-metadata: upgrade 4.5.0 -> 4.6.0 python3-packaging: upgrade 20.9 -> 21.0 python3-hypothesis: upgrade 6.14.0 -> 6.14.1 python3-zipp: upgrade 3.4.1 -> 3.5.0 at-spi2-core: upgrade 2.40.2 -> 2.40.3 python3-hypothesis: upgrade 6.14.1 -> 6.14.3 Tony Tascioglu (1): valgrind: skip flaky ptest fb_test_amd64 Trevor Gamblin (2): python3-pip: upgrade 20.0.2 -> 21.1.2 python3-pip: add multiprocessing to RDEPENDS Yi Zhao (1): libffi: disable use of static exec trampolines Zoltán Böszörményi (1): tzdata: Allow controlling zoneinfo binary format Zqiang (1): ifupdown: Skip wrong test item bkylerussell@gmail.com (1): gstreamer: add libgst packages to PACKAGES_DYNAMIC jbouchard (1): Use the label provided when formating a dos partition wangmy (19): libcap: upgrade 2.50 -> 2.51 libhandy: upgrade 1.2.2 -> 1.2.3 libva: upgrade 2.11.0 -> 2.12.0 libxcrypt: upgrade 4.4.22 -> 4.4.23 python3-numpy: upgrade 1.20.3 -> 1.21.0 python3-pbr: upgrade 5.4.4 -> 5.6.0 cmake: upgrade 3.20.4 -> 3.20.5 gpgme: upgrade 1.15.1 -> 1.16.0 libglu: upgrade 9.0.1 -> 9.0.2 stress-ng: upgrade 0.12.10 -> 0.12.11 xf86-input-libinput: upgrade 1.0.1 -> 1.1.0 vulkan-headers: upgrade 1.2.176 -> 1.2.182 vulkan-loader: upgrade 1.2.176 -> 1.2.182 vulkan-tools: upgrade 1.2.176 -> 1.2.182 gnome-desktop-testing: upgrade 2018.1 -> 2021.1 python3-importlib-metadata: upgrade 4.6.0 -> 4.6.1 u-boot: upgrade 2021.04 -> 2021.07 python3-setuptools: upgrade 57.0.0 -> 57.1.0 btrfs-tools: upgrade 5.12.1 -> 5.13 zangrc (1): python3-pip: upgrade 21.1.2 -> 21.1.3 zhengruoqin (3): libffi: upgrade 3.3 -> 3.4.2 python3: upgrade 3.9.5 -> 3.9.6 python3-pathlib2: upgrade 2.3.5 -> 2.3.6 Signed-off-by: Andrew Geissler Change-Id: If493204235c3a1ce4e7fe65438168512d17a900e --- .../recipes-core/glibc/glibc-testsuite_2.33.bb | 1 + .../recipes-core/glibc/glibc/mte-backports.patch | 1238 ++++++++++++++++++++ poky/meta/recipes-core/glibc/glibc_2.33.bb | 3 +- .../ldconfig-native-2.12.1/add-riscv-support.patch | 79 ++ .../recipes-core/glibc/ldconfig-native_2.12.1.bb | 1 + 5 files changed, 1321 insertions(+), 1 deletion(-) create mode 100644 poky/meta/recipes-core/glibc/glibc/mte-backports.patch create mode 100644 poky/meta/recipes-core/glibc/ldconfig-native-2.12.1/add-riscv-support.patch (limited to 'poky/meta/recipes-core/glibc') diff --git a/poky/meta/recipes-core/glibc/glibc-testsuite_2.33.bb b/poky/meta/recipes-core/glibc/glibc-testsuite_2.33.bb index d887aeff7..659d3132f 100644 --- a/poky/meta/recipes-core/glibc/glibc-testsuite_2.33.bb +++ b/poky/meta/recipes-core/glibc/glibc-testsuite_2.33.bb @@ -61,3 +61,4 @@ addtask do_check after do_compile inherit nopackages deltask do_stash_locale deltask do_install +deltask do_populate_sysroot diff --git a/poky/meta/recipes-core/glibc/glibc/mte-backports.patch b/poky/meta/recipes-core/glibc/glibc/mte-backports.patch new file mode 100644 index 000000000..d9604fdf4 --- /dev/null +++ b/poky/meta/recipes-core/glibc/glibc/mte-backports.patch @@ -0,0 +1,1238 @@ +Backport a number of patches from master to improve Arm MTE support. + +Upstream-Status: Backport [will be in 2.34] +Signed-off-by: Ross Burton + +From 2643466c2928a93de7b80a61f6a8f61a653862e1 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Thu, 11 Mar 2021 14:09:56 +0000 +Subject: [PATCH 01/11] malloc: Fix a potential realloc issue with memory + tagging + +At an _int_free call site in realloc the wrong size was used for tag +clearing: the chunk header of the next chunk was also cleared which +in practice may work, but logically wrong. + +The tag clearing is moved before the memcpy to save a tag computation, +this avoids a chunk2mem. Another chunk2mem is removed because newmem +does not have to be recomputed. Whitespaces got fixed too. + +Reviewed-by: DJ Delorie +--- + malloc/malloc.c | 14 +++++++------- + 1 file changed, 7 insertions(+), 7 deletions(-) + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 8f8f12c276..51cec67e55 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -4851,14 +4851,14 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize, + } + else + { +- void *oldmem = chunk2mem (oldp); ++ void *oldmem = chunk2rawmem (oldp); ++ size_t sz = CHUNK_AVAILABLE_SIZE (oldp) - CHUNK_HDR_SZ; ++ (void) TAG_REGION (oldmem, sz); + newmem = TAG_NEW_USABLE (newmem); +- memcpy (newmem, oldmem, +- CHUNK_AVAILABLE_SIZE (oldp) - CHUNK_HDR_SZ); +- (void) TAG_REGION (chunk2rawmem (oldp), oldsize); +- _int_free (av, oldp, 1); +- check_inuse_chunk (av, newp); +- return chunk2mem (newp); ++ memcpy (newmem, oldmem, sz); ++ _int_free (av, oldp, 1); ++ check_inuse_chunk (av, newp); ++ return newmem; + } + } + } +-- +2.25.1 + + +From 32f3132be063e4b16a5cdb058980af354126e2f4 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Thu, 28 Jan 2021 17:34:36 +0000 +Subject: [PATCH 02/11] malloc: Move MTAG_MMAP_FLAGS definition + +This is only used internally in malloc.c, the extern declaration +was wrong, __mtag_mmap_flags has internal linkage. + +Reviewed-by: DJ Delorie +--- + include/malloc.h | 7 ------- + malloc/malloc.c | 2 ++ + 2 files changed, 2 insertions(+), 7 deletions(-) + +diff --git a/include/malloc.h b/include/malloc.h +index 7ae08d53d3..b77761f74d 100644 +--- a/include/malloc.h ++++ b/include/malloc.h +@@ -16,11 +16,4 @@ typedef struct malloc_state *mstate; + + # endif /* !_ISOMAC */ + +-#ifdef USE_MTAG +-extern int __mtag_mmap_flags; +-#define MTAG_MMAP_FLAGS __mtag_mmap_flags +-#else +-#define MTAG_MMAP_FLAGS 0 +-#endif +- + #endif +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 51cec67e55..61c25d0f93 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -463,11 +463,13 @@ static void *(*__tag_region)(void *, size_t) = __default_tag_region; + static void *(*__tag_new_usable)(void *) = __default_tag_nop; + static void *(*__tag_at)(void *) = __default_tag_nop; + ++# define MTAG_MMAP_FLAGS __mtag_mmap_flags + # define TAG_NEW_MEMSET(ptr, val, size) __tag_new_memset (ptr, val, size) + # define TAG_REGION(ptr, size) __tag_region (ptr, size) + # define TAG_NEW_USABLE(ptr) __tag_new_usable (ptr) + # define TAG_AT(ptr) __tag_at (ptr) + #else ++# define MTAG_MMAP_FLAGS 0 + # define TAG_NEW_MEMSET(ptr, val, size) memset (ptr, val, size) + # define TAG_REGION(ptr, size) (ptr) + # define TAG_NEW_USABLE(ptr) (ptr) +-- +2.25.1 + + +From 4b13f77fb97f9618a7868ab767d05e0c2d7c6f6f Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Thu, 4 Feb 2021 11:38:23 +0000 +Subject: [PATCH 03/11] malloc: Simplify __mtag_tag_new_usable + +The chunk cannot be a dumped one here. The only non-obvious cases +are free and realloc which may be called on a dumped area chunk, +but in both cases it can be verified that tagging is already +avoided for dumped area chunks. + +Reviewed-by: DJ Delorie +--- + malloc/arena.c | 5 ----- + 1 file changed, 5 deletions(-) + +diff --git a/malloc/arena.c b/malloc/arena.c +index bf17be27d4..0777dc70c6 100644 +--- a/malloc/arena.c ++++ b/malloc/arena.c +@@ -298,11 +298,6 @@ __mtag_tag_new_usable (void *ptr) + if (ptr) + { + mchunkptr cp = mem2chunk(ptr); +- /* This likely will never happen, but we can't handle retagging +- chunks from the dumped main arena. So just return the +- existing pointer. */ +- if (DUMPED_MAIN_ARENA_CHUNK (cp)) +- return ptr; + ptr = __libc_mtag_tag_region (__libc_mtag_new_tag (ptr), + CHUNK_AVAILABLE_SIZE (cp) - CHUNK_HDR_SZ); + } +-- +2.25.1 + + +From 4f05837ba6934c5b8bbc6738f8883890493f50b6 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Thu, 4 Feb 2021 11:52:14 +0000 +Subject: [PATCH 04/11] malloc: Avoid taggig mmaped memory on free + +Either the memory belongs to the dumped area, in which case we don't +want to tag (the dumped area has the same tag as malloc internal data +so tagging is unnecessary, but chunks there may not have the right +alignment for the tag granule), or the memory will be unmapped +immediately (and thus tagging is not useful). + +Reviewed-by: DJ Delorie +--- + malloc/malloc.c | 7 ++++--- + 1 file changed, 4 insertions(+), 3 deletions(-) + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 61c25d0f93..ecb87350b0 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -3284,9 +3284,6 @@ __libc_free (void *mem) + + p = mem2chunk (mem); + +- /* Mark the chunk as belonging to the library again. */ +- (void)TAG_REGION (chunk2rawmem (p), CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); +- + if (chunk_is_mmapped (p)) /* release mmapped memory. */ + { + /* See if the dynamic brk/mmap threshold needs adjusting. +@@ -3307,6 +3304,10 @@ __libc_free (void *mem) + { + MAYBE_INIT_TCACHE (); + ++ /* Mark the chunk as belonging to the library again. */ ++ (void)TAG_REGION (chunk2rawmem (p), ++ CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); ++ + ar_ptr = arena_for_chunk (p); + _int_free (ar_ptr, p, 0); + } +-- +2.25.1 + + +From 673fad3798846101b77a89595cfa17f334a1c898 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Tue, 16 Feb 2021 14:12:25 +0000 +Subject: [PATCH 05/11] malloc: Refactor TAG_ macros to avoid indirection + +This does not change behaviour, just removes one layer of indirection +in the internal memory tagging logic. + +Use tag_ and mtag_ prefixes instead of __tag_ and __mtag_ since these +are all symbols with internal linkage, private to malloc.c, so there +is no user namespace pollution issue. + +Reviewed-by: DJ Delorie +--- + malloc/arena.c | 16 +++++----- + malloc/hooks.c | 10 +++--- + malloc/malloc.c | 81 +++++++++++++++++++++++-------------------------- + 3 files changed, 51 insertions(+), 56 deletions(-) + +diff --git a/malloc/arena.c b/malloc/arena.c +index 0777dc70c6..d0778fea92 100644 +--- a/malloc/arena.c ++++ b/malloc/arena.c +@@ -332,12 +332,12 @@ ptmalloc_init (void) + if (__MTAG_SBRK_UNTAGGED) + __morecore = __failing_morecore; + +- __mtag_mmap_flags = __MTAG_MMAP_FLAGS; +- __tag_new_memset = __mtag_tag_new_memset; +- __tag_region = __libc_mtag_tag_region; +- __tag_new_usable = __mtag_tag_new_usable; +- __tag_at = __libc_mtag_address_get_tag; +- __mtag_granule_mask = ~(size_t)(__MTAG_GRANULE_SIZE - 1); ++ mtag_mmap_flags = __MTAG_MMAP_FLAGS; ++ tag_new_memset = __mtag_tag_new_memset; ++ tag_region = __libc_mtag_tag_region; ++ tag_new_usable = __mtag_tag_new_usable; ++ tag_at = __libc_mtag_address_get_tag; ++ mtag_granule_mask = ~(size_t)(__MTAG_GRANULE_SIZE - 1); + } + #endif + +@@ -557,7 +557,7 @@ new_heap (size_t size, size_t top_pad) + } + } + } +- if (__mprotect (p2, size, MTAG_MMAP_FLAGS | PROT_READ | PROT_WRITE) != 0) ++ if (__mprotect (p2, size, mtag_mmap_flags | PROT_READ | PROT_WRITE) != 0) + { + __munmap (p2, HEAP_MAX_SIZE); + return 0; +@@ -587,7 +587,7 @@ grow_heap (heap_info *h, long diff) + { + if (__mprotect ((char *) h + h->mprotect_size, + (unsigned long) new_size - h->mprotect_size, +- MTAG_MMAP_FLAGS | PROT_READ | PROT_WRITE) != 0) ++ mtag_mmap_flags | PROT_READ | PROT_WRITE) != 0) + return -2; + + h->mprotect_size = new_size; +diff --git a/malloc/hooks.c b/malloc/hooks.c +index efec05f0a8..d8e304c31c 100644 +--- a/malloc/hooks.c ++++ b/malloc/hooks.c +@@ -68,7 +68,7 @@ __malloc_check_init (void) + tags, so fetch the tag at each location before dereferencing + it. */ + #define SAFE_CHAR_OFFSET(p,offset) \ +- ((unsigned char *) TAG_AT (((unsigned char *) p) + offset)) ++ ((unsigned char *) tag_at (((unsigned char *) p) + offset)) + + /* A simple, standard set of debugging hooks. Overhead is `only' one + byte per chunk; still this will catch most cases of double frees or +@@ -249,7 +249,7 @@ malloc_check (size_t sz, const void *caller) + top_check (); + victim = _int_malloc (&main_arena, nb); + __libc_lock_unlock (main_arena.mutex); +- return mem2mem_check (TAG_NEW_USABLE (victim), sz); ++ return mem2mem_check (tag_new_usable (victim), sz); + } + + static void +@@ -280,7 +280,7 @@ free_check (void *mem, const void *caller) + else + { + /* Mark the chunk as belonging to the library again. */ +- (void)TAG_REGION (chunk2rawmem (p), CHUNK_AVAILABLE_SIZE (p) ++ (void)tag_region (chunk2rawmem (p), CHUNK_AVAILABLE_SIZE (p) + - CHUNK_HDR_SZ); + _int_free (&main_arena, p, 1); + __libc_lock_unlock (main_arena.mutex); +@@ -375,7 +375,7 @@ invert: + + __libc_lock_unlock (main_arena.mutex); + +- return mem2mem_check (TAG_NEW_USABLE (newmem), bytes); ++ return mem2mem_check (tag_new_usable (newmem), bytes); + } + + static void * +@@ -417,7 +417,7 @@ memalign_check (size_t alignment, size_t bytes, const void *caller) + top_check (); + mem = _int_memalign (&main_arena, alignment, bytes + 1); + __libc_lock_unlock (main_arena.mutex); +- return mem2mem_check (TAG_NEW_USABLE (mem), bytes); ++ return mem2mem_check (tag_new_usable (mem), bytes); + } + + #if SHLIB_COMPAT (libc, GLIBC_2_0, GLIBC_2_25) +diff --git a/malloc/malloc.c b/malloc/malloc.c +index ecb87350b0..62d00f54cc 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -413,26 +413,26 @@ void *(*__morecore)(ptrdiff_t) = __default_morecore; + operations can continue to be used. Support macros are used to do + this: + +- void *TAG_NEW_MEMSET (void *ptr, int, val, size_t size) ++ void *tag_new_memset (void *ptr, int, val, size_t size) + + Has the same interface as memset(), but additionally allocates a + new tag, colors the memory with that tag and returns a pointer that + is correctly colored for that location. The non-tagging version + will simply call memset. + +- void *TAG_REGION (void *ptr, size_t size) ++ void *tag_region (void *ptr, size_t size) + + Color the region of memory pointed to by PTR and size SIZE with + the color of PTR. Returns the original pointer. + +- void *TAG_NEW_USABLE (void *ptr) ++ void *tag_new_usable (void *ptr) + + Allocate a new random color and use it to color the user region of + a chunk; this may include data from the subsequent chunk's header + if tagging is sufficiently fine grained. Returns PTR suitably + recolored for accessing the memory there. + +- void *TAG_AT (void *ptr) ++ void *tag_at (void *ptr) + + Read the current color of the memory at the address pointed to by + PTR (ignoring it's current color) and return PTR recolored to that +@@ -455,25 +455,20 @@ __default_tag_nop (void *ptr) + return ptr; + } + +-static int __mtag_mmap_flags = 0; +-static size_t __mtag_granule_mask = ~(size_t)0; ++static int mtag_mmap_flags = 0; ++static size_t mtag_granule_mask = ~(size_t)0; + +-static void *(*__tag_new_memset)(void *, int, size_t) = memset; +-static void *(*__tag_region)(void *, size_t) = __default_tag_region; +-static void *(*__tag_new_usable)(void *) = __default_tag_nop; +-static void *(*__tag_at)(void *) = __default_tag_nop; ++static void *(*tag_new_memset)(void *, int, size_t) = memset; ++static void *(*tag_region)(void *, size_t) = __default_tag_region; ++static void *(*tag_new_usable)(void *) = __default_tag_nop; ++static void *(*tag_at)(void *) = __default_tag_nop; + +-# define MTAG_MMAP_FLAGS __mtag_mmap_flags +-# define TAG_NEW_MEMSET(ptr, val, size) __tag_new_memset (ptr, val, size) +-# define TAG_REGION(ptr, size) __tag_region (ptr, size) +-# define TAG_NEW_USABLE(ptr) __tag_new_usable (ptr) +-# define TAG_AT(ptr) __tag_at (ptr) + #else +-# define MTAG_MMAP_FLAGS 0 +-# define TAG_NEW_MEMSET(ptr, val, size) memset (ptr, val, size) +-# define TAG_REGION(ptr, size) (ptr) +-# define TAG_NEW_USABLE(ptr) (ptr) +-# define TAG_AT(ptr) (ptr) ++# define mtag_mmap_flags 0 ++# define tag_new_memset(ptr, val, size) memset (ptr, val, size) ++# define tag_region(ptr, size) (ptr) ++# define tag_new_usable(ptr) (ptr) ++# define tag_at(ptr) (ptr) + #endif + + #include +@@ -1305,8 +1300,8 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + /* Convert between user mem pointers and chunk pointers, updating any + memory tags on the pointer to respect the tag value at that + location. */ +-#define chunk2mem(p) ((void*)TAG_AT (((char*)(p) + CHUNK_HDR_SZ))) +-#define mem2chunk(mem) ((mchunkptr)TAG_AT (((char*)(mem) - CHUNK_HDR_SZ))) ++#define chunk2mem(p) ((void *)tag_at (((char*)(p) + CHUNK_HDR_SZ))) ++#define mem2chunk(mem) ((mchunkptr)tag_at (((char*)(mem) - CHUNK_HDR_SZ))) + + /* The smallest possible chunk */ + #define MIN_CHUNK_SIZE (offsetof(struct malloc_chunk, fd_nextsize)) +@@ -1337,7 +1332,7 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + #ifdef USE_MTAG + #define CHUNK_AVAILABLE_SIZE(p) \ + ((chunksize (p) + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) \ +- & __mtag_granule_mask) ++ & mtag_granule_mask) + #else + #define CHUNK_AVAILABLE_SIZE(p) \ + (chunksize (p) + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) +@@ -1361,7 +1356,7 @@ checked_request2size (size_t req, size_t *sz) __nonnull (1) + number. Ideally, this would be part of request2size(), but that + must be a macro that produces a compile time constant if passed + a constant literal. */ +- req = (req + ~__mtag_granule_mask) & __mtag_granule_mask; ++ req = (req + ~mtag_granule_mask) & mtag_granule_mask; + #endif + + *sz = request2size (req); +@@ -2467,7 +2462,7 @@ sysmalloc (INTERNAL_SIZE_T nb, mstate av) + if ((unsigned long) (size) > (unsigned long) (nb)) + { + mm = (char *) (MMAP (0, size, +- MTAG_MMAP_FLAGS | PROT_READ | PROT_WRITE, 0)); ++ mtag_mmap_flags | PROT_READ | PROT_WRITE, 0)); + + if (mm != MAP_FAILED) + { +@@ -2665,7 +2660,7 @@ sysmalloc (INTERNAL_SIZE_T nb, mstate av) + if ((unsigned long) (size) > (unsigned long) (nb)) + { + char *mbrk = (char *) (MMAP (0, size, +- MTAG_MMAP_FLAGS | PROT_READ | PROT_WRITE, ++ mtag_mmap_flags | PROT_READ | PROT_WRITE, + 0)); + + if (mbrk != MAP_FAILED) +@@ -3221,14 +3216,14 @@ __libc_malloc (size_t bytes) + && tcache->counts[tc_idx] > 0) + { + victim = tcache_get (tc_idx); +- return TAG_NEW_USABLE (victim); ++ return tag_new_usable (victim); + } + DIAG_POP_NEEDS_COMMENT; + #endif + + if (SINGLE_THREAD_P) + { +- victim = TAG_NEW_USABLE (_int_malloc (&main_arena, bytes)); ++ victim = tag_new_usable (_int_malloc (&main_arena, bytes)); + assert (!victim || chunk_is_mmapped (mem2chunk (victim)) || + &main_arena == arena_for_chunk (mem2chunk (victim))); + return victim; +@@ -3249,7 +3244,7 @@ __libc_malloc (size_t bytes) + if (ar_ptr != NULL) + __libc_lock_unlock (ar_ptr->mutex); + +- victim = TAG_NEW_USABLE (victim); ++ victim = tag_new_usable (victim); + + assert (!victim || chunk_is_mmapped (mem2chunk (victim)) || + ar_ptr == arena_for_chunk (mem2chunk (victim))); +@@ -3305,7 +3300,7 @@ __libc_free (void *mem) + MAYBE_INIT_TCACHE (); + + /* Mark the chunk as belonging to the library again. */ +- (void)TAG_REGION (chunk2rawmem (p), ++ (void)tag_region (chunk2rawmem (p), + CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); + + ar_ptr = arena_for_chunk (p); +@@ -3408,7 +3403,7 @@ __libc_realloc (void *oldmem, size_t bytes) + reused. There's a performance hit for both us and the + caller for doing this, so we might want to + reconsider. */ +- return TAG_NEW_USABLE (newmem); ++ return tag_new_usable (newmem); + } + #endif + /* Note the extra SIZE_SZ overhead. */ +@@ -3451,7 +3446,7 @@ __libc_realloc (void *oldmem, size_t bytes) + { + size_t sz = CHUNK_AVAILABLE_SIZE (oldp) - CHUNK_HDR_SZ; + memcpy (newp, oldmem, sz); +- (void) TAG_REGION (chunk2rawmem (oldp), sz); ++ (void) tag_region (chunk2rawmem (oldp), sz); + _int_free (ar_ptr, oldp, 0); + } + } +@@ -3509,7 +3504,7 @@ _mid_memalign (size_t alignment, size_t bytes, void *address) + p = _int_memalign (&main_arena, alignment, bytes); + assert (!p || chunk_is_mmapped (mem2chunk (p)) || + &main_arena == arena_for_chunk (mem2chunk (p))); +- return TAG_NEW_USABLE (p); ++ return tag_new_usable (p); + } + + arena_get (ar_ptr, bytes + alignment + MINSIZE); +@@ -3527,7 +3522,7 @@ _mid_memalign (size_t alignment, size_t bytes, void *address) + + assert (!p || chunk_is_mmapped (mem2chunk (p)) || + ar_ptr == arena_for_chunk (mem2chunk (p))); +- return TAG_NEW_USABLE (p); ++ return tag_new_usable (p); + } + /* For ISO C11. */ + weak_alias (__libc_memalign, aligned_alloc) +@@ -3544,7 +3539,7 @@ __libc_valloc (size_t bytes) + void *address = RETURN_ADDRESS (0); + size_t pagesize = GLRO (dl_pagesize); + p = _mid_memalign (pagesize, bytes, address); +- return TAG_NEW_USABLE (p); ++ return tag_new_usable (p); + } + + void * +@@ -3569,7 +3564,7 @@ __libc_pvalloc (size_t bytes) + rounded_bytes = rounded_bytes & -(pagesize - 1); + + p = _mid_memalign (pagesize, rounded_bytes, address); +- return TAG_NEW_USABLE (p); ++ return tag_new_usable (p); + } + + void * +@@ -3666,7 +3661,7 @@ __libc_calloc (size_t n, size_t elem_size) + regardless of MORECORE_CLEARS, so we zero the whole block while + doing so. */ + #ifdef USE_MTAG +- return TAG_NEW_MEMSET (mem, 0, CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); ++ return tag_new_memset (mem, 0, CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); + #else + INTERNAL_SIZE_T csz = chunksize (p); + +@@ -4821,7 +4816,7 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize, + av->top = chunk_at_offset (oldp, nb); + set_head (av->top, (newsize - nb) | PREV_INUSE); + check_inuse_chunk (av, oldp); +- return TAG_NEW_USABLE (chunk2rawmem (oldp)); ++ return tag_new_usable (chunk2rawmem (oldp)); + } + + /* Try to expand forward into next chunk; split off remainder below */ +@@ -4856,8 +4851,8 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize, + { + void *oldmem = chunk2rawmem (oldp); + size_t sz = CHUNK_AVAILABLE_SIZE (oldp) - CHUNK_HDR_SZ; +- (void) TAG_REGION (oldmem, sz); +- newmem = TAG_NEW_USABLE (newmem); ++ (void) tag_region (oldmem, sz); ++ newmem = tag_new_usable (newmem); + memcpy (newmem, oldmem, sz); + _int_free (av, oldp, 1); + check_inuse_chunk (av, newp); +@@ -4881,7 +4876,7 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize, + { + remainder = chunk_at_offset (newp, nb); + /* Clear any user-space tags before writing the header. */ +- remainder = TAG_REGION (remainder, remainder_size); ++ remainder = tag_region (remainder, remainder_size); + set_head_size (newp, nb | (av != &main_arena ? NON_MAIN_ARENA : 0)); + set_head (remainder, remainder_size | PREV_INUSE | + (av != &main_arena ? NON_MAIN_ARENA : 0)); +@@ -4891,7 +4886,7 @@ _int_realloc(mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize, + } + + check_inuse_chunk (av, newp); +- return TAG_NEW_USABLE (chunk2rawmem (newp)); ++ return tag_new_usable (chunk2rawmem (newp)); + } + + /* +@@ -5108,7 +5103,7 @@ musable (void *mem) + /* The usable space may be reduced if memory tagging is needed, + since we cannot share the user-space data with malloc's internal + data structure. */ +- result &= __mtag_granule_mask; ++ result &= mtag_granule_mask; + #endif + return result; + } +-- +2.25.1 + + +From f0ea41e819f40aacedf25431bedd95da9c5db534 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Wed, 27 Jan 2021 15:45:43 +0000 +Subject: [PATCH 06/11] malloc: Use global flag instead of function pointer + dispatch for mtag + +A flag check can be faster than function pointers because of how +branch prediction and speculation works and it can also remove a layer +of indirection when there is a mismatch between the malloc internal +tag_* api and __libc_mtag_* target hooks. + +Memory tagging wrapper functions are moved to malloc.c from arena.c and +the logic now checks mmap_enabled. The definition of tag_new_usable is +moved after chunk related definitions. + +This refactoring also allows using mtag_enabled checks instead of +USE_MTAG ifdefs when memory tagging support only changes code logic +when memory tagging is enabled at runtime. Note: an "if (false)" code +block is optimized away even at -O0 by gcc. + +Reviewed-by: DJ Delorie +--- + malloc/arena.c | 33 +--------------------------- + malloc/malloc.c | 58 ++++++++++++++++++++++++++++++++----------------- + 2 files changed, 39 insertions(+), 52 deletions(-) + +diff --git a/malloc/arena.c b/malloc/arena.c +index d0778fea92..1e83bb66bd 100644 +--- a/malloc/arena.c ++++ b/malloc/arena.c +@@ -287,34 +287,6 @@ extern struct dl_open_hook *_dl_open_hook; + libc_hidden_proto (_dl_open_hook); + #endif + +-#ifdef USE_MTAG +- +-/* Generate a new (random) tag value for PTR and tag the memory it +- points to upto the end of the usable size for the chunk containing +- it. Return the newly tagged pointer. */ +-static void * +-__mtag_tag_new_usable (void *ptr) +-{ +- if (ptr) +- { +- mchunkptr cp = mem2chunk(ptr); +- ptr = __libc_mtag_tag_region (__libc_mtag_new_tag (ptr), +- CHUNK_AVAILABLE_SIZE (cp) - CHUNK_HDR_SZ); +- } +- return ptr; +-} +- +-/* Generate a new (random) tag value for PTR, set the tags for the +- memory to the new tag and initialize the memory contents to VAL. +- In practice this function will only be called with VAL=0, but we +- keep this parameter to maintain the same prototype as memset. */ +-static void * +-__mtag_tag_new_memset (void *ptr, int val, size_t size) +-{ +- return __libc_mtag_memset_with_tag (__libc_mtag_new_tag (ptr), val, size); +-} +-#endif +- + static void + ptmalloc_init (void) + { +@@ -332,11 +304,8 @@ ptmalloc_init (void) + if (__MTAG_SBRK_UNTAGGED) + __morecore = __failing_morecore; + ++ mtag_enabled = true; + mtag_mmap_flags = __MTAG_MMAP_FLAGS; +- tag_new_memset = __mtag_tag_new_memset; +- tag_region = __libc_mtag_tag_region; +- tag_new_usable = __mtag_tag_new_usable; +- tag_at = __libc_mtag_address_get_tag; + mtag_granule_mask = ~(size_t)(__MTAG_GRANULE_SIZE - 1); + } + #endif +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 62d00f54cc..253a919ec5 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -441,35 +441,41 @@ void *(*__morecore)(ptrdiff_t) = __default_morecore; + */ + + #ifdef USE_MTAG ++static bool mtag_enabled = false; ++static int mtag_mmap_flags = 0; ++static size_t mtag_granule_mask = ~(size_t)0; ++#else ++# define mtag_enabled false ++# define mtag_mmap_flags 0 ++#endif + +-/* Default implementaions when memory tagging is supported, but disabled. */ +-static void * +-__default_tag_region (void *ptr, size_t size) ++static __always_inline void * ++tag_region (void *ptr, size_t size) + { ++ if (__glibc_unlikely (mtag_enabled)) ++ return __libc_mtag_tag_region (ptr, size); + return ptr; + } + +-static void * +-__default_tag_nop (void *ptr) ++static __always_inline void * ++tag_new_memset (void *ptr, int val, size_t size) + { +- return ptr; ++ if (__glibc_unlikely (mtag_enabled)) ++ return __libc_mtag_memset_with_tag (__libc_mtag_new_tag (ptr), val, size); ++ return memset (ptr, val, size); + } + +-static int mtag_mmap_flags = 0; +-static size_t mtag_granule_mask = ~(size_t)0; +- +-static void *(*tag_new_memset)(void *, int, size_t) = memset; +-static void *(*tag_region)(void *, size_t) = __default_tag_region; +-static void *(*tag_new_usable)(void *) = __default_tag_nop; +-static void *(*tag_at)(void *) = __default_tag_nop; ++/* Defined later. */ ++static void * ++tag_new_usable (void *ptr); + +-#else +-# define mtag_mmap_flags 0 +-# define tag_new_memset(ptr, val, size) memset (ptr, val, size) +-# define tag_region(ptr, size) (ptr) +-# define tag_new_usable(ptr) (ptr) +-# define tag_at(ptr) (ptr) +-#endif ++static __always_inline void * ++tag_at (void *ptr) ++{ ++ if (__glibc_unlikely (mtag_enabled)) ++ return __libc_mtag_address_get_tag (ptr); ++ return ptr; ++} + + #include + +@@ -1460,6 +1466,18 @@ checked_request2size (size_t req, size_t *sz) __nonnull (1) + #pragma GCC poison mchunk_size + #pragma GCC poison mchunk_prev_size + ++static __always_inline void * ++tag_new_usable (void *ptr) ++{ ++ if (__glibc_unlikely (mtag_enabled) && ptr) ++ { ++ mchunkptr cp = mem2chunk(ptr); ++ ptr = __libc_mtag_tag_region (__libc_mtag_new_tag (ptr), ++ CHUNK_AVAILABLE_SIZE (cp) - CHUNK_HDR_SZ); ++ } ++ return ptr; ++} ++ + /* + -------------------- Internal data structures -------------------- + +-- +2.25.1 + + +From 8597244d5c3edbd672b285eea5f6dea833256f9d Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Wed, 17 Feb 2021 10:39:37 +0000 +Subject: [PATCH 07/11] malloc: Ensure the generic mtag hooks are not used + +Use inline functions instead of macros, because macros can cause unused +variable warnings and type conversion issues. We assume these functions +may appear in the code but only in dead code paths (hidden by a runtime +check), so it's important that they can compile with correct types, but +if they are actually used that should be an error. + +Currently the hooks are only used when USE_MTAG is true which only +happens on aarch64 and then the aarch64 specific code is used not this +generic header. However followup refactoring will allow the hooks to +be used with !USE_MTAG. + +Note: the const qualifier in the comment was wrong: changing tags is a +write operation. + +Reviewed-by: DJ Delorie +--- + sysdeps/generic/libc-mtag.h | 41 ++++++++++++++++++++++++++++--------- + 1 file changed, 31 insertions(+), 10 deletions(-) + +diff --git a/sysdeps/generic/libc-mtag.h b/sysdeps/generic/libc-mtag.h +index 1a866cdc0c..e8fc236b6c 100644 +--- a/sysdeps/generic/libc-mtag.h ++++ b/sysdeps/generic/libc-mtag.h +@@ -31,22 +31,43 @@ + /* Extra flags to pass to mmap() to request a tagged region of memory. */ + #define __MTAG_MMAP_FLAGS 0 + ++/* Memory tagging target hooks are only called when memory tagging is ++ enabled at runtime. The generic definitions here must not be used. */ ++void __libc_mtag_link_error (void); ++ + /* Set the tags for a region of memory, which must have size and alignment +- that are multiples of __MTAG_GRANULE_SIZE. Size cannot be zero. +- void *__libc_mtag_tag_region (const void *, size_t) */ +-#define __libc_mtag_tag_region(p, s) (p) ++ that are multiples of __MTAG_GRANULE_SIZE. Size cannot be zero. */ ++static inline void * ++__libc_mtag_tag_region (void *p, size_t n) ++{ ++ __libc_mtag_link_error (); ++ return p; ++} + + /* Optimized equivalent to __libc_mtag_tag_region followed by memset. */ +-#define __libc_mtag_memset_with_tag memset ++static inline void * ++__libc_mtag_memset_with_tag (void *p, int c, size_t n) ++{ ++ __libc_mtag_link_error (); ++ return memset (p, c, n); ++} + + /* Convert address P to a pointer that is tagged correctly for that +- location. +- void *__libc_mtag_address_get_tag (void*) */ +-#define __libc_mtag_address_get_tag(p) (p) ++ location. */ ++static inline void * ++__libc_mtag_address_get_tag (void *p) ++{ ++ __libc_mtag_link_error (); ++ return p; ++} + + /* Assign a new (random) tag to a pointer P (does not adjust the tag on +- the memory addressed). +- void *__libc_mtag_new_tag (void*) */ +-#define __libc_mtag_new_tag(p) (p) ++ the memory addressed). */ ++static inline void * ++__libc_mtag_new_tag (void *p) ++{ ++ __libc_mtag_link_error (); ++ return p; ++} + + #endif /* _GENERIC_LIBC_MTAG_H */ +-- +2.25.1 + + +From 3d9e16280ad881d038aedba0b6fcbd9e78b29072 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Fri, 29 Jan 2021 17:07:28 +0000 +Subject: [PATCH 08/11] malloc: Only support zeroing and not arbitrary memset + with mtag + +The memset api is suboptimal and does not provide much benefit. Memory +tagging only needs a zeroing memset (and only for memory that's sized +and aligned to multiples of the tag granule), so change the internal +api and the target hooks accordingly. This is to simplify the +implementation of the target hook. + +Reviewed-by: DJ Delorie +--- + malloc/malloc.c | 17 ++++++++--------- + sysdeps/aarch64/Makefile | 2 +- + ...g_memset_tag.S => __mtag_tag_zero_region.S} | 18 +++++++----------- + sysdeps/aarch64/libc-mtag.h | 4 ++-- + sysdeps/generic/libc-mtag.h | 6 +++--- + 5 files changed, 21 insertions(+), 26 deletions(-) + rename sysdeps/aarch64/{__mtag_memset_tag.S => __mtag_tag_zero_region.S} (82%) + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 253a919ec5..01cf6e9325 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -413,12 +413,11 @@ void *(*__morecore)(ptrdiff_t) = __default_morecore; + operations can continue to be used. Support macros are used to do + this: + +- void *tag_new_memset (void *ptr, int, val, size_t size) ++ void *tag_new_zero_region (void *ptr, size_t size) + +- Has the same interface as memset(), but additionally allocates a +- new tag, colors the memory with that tag and returns a pointer that +- is correctly colored for that location. The non-tagging version +- will simply call memset. ++ Allocates a new tag, colors the memory with that tag, zeros the ++ memory and returns a pointer that is correctly colored for that ++ location. The non-tagging version will simply call memset with 0. + + void *tag_region (void *ptr, size_t size) + +@@ -458,11 +457,11 @@ tag_region (void *ptr, size_t size) + } + + static __always_inline void * +-tag_new_memset (void *ptr, int val, size_t size) ++tag_new_zero_region (void *ptr, size_t size) + { + if (__glibc_unlikely (mtag_enabled)) +- return __libc_mtag_memset_with_tag (__libc_mtag_new_tag (ptr), val, size); +- return memset (ptr, val, size); ++ return __libc_mtag_tag_zero_region (__libc_mtag_new_tag (ptr), size); ++ return memset (ptr, 0, size); + } + + /* Defined later. */ +@@ -3679,7 +3678,7 @@ __libc_calloc (size_t n, size_t elem_size) + regardless of MORECORE_CLEARS, so we zero the whole block while + doing so. */ + #ifdef USE_MTAG +- return tag_new_memset (mem, 0, CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); ++ return tag_new_zero_region (mem, CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); + #else + INTERNAL_SIZE_T csz = chunksize (p); + +diff --git a/sysdeps/aarch64/Makefile b/sysdeps/aarch64/Makefile +index d3ab37a40a..259070cfad 100644 +--- a/sysdeps/aarch64/Makefile ++++ b/sysdeps/aarch64/Makefile +@@ -41,7 +41,7 @@ endif + ifeq ($(subdir),misc) + sysdep_headers += sys/ifunc.h + sysdep_routines += __mtag_address_get_tag \ +- __mtag_memset_tag \ ++ __mtag_tag_zero_region \ + __mtag_new_tag \ + __mtag_tag_region + +diff --git a/sysdeps/aarch64/__mtag_memset_tag.S b/sysdeps/aarch64/__mtag_tag_zero_region.S +similarity index 82% +rename from sysdeps/aarch64/__mtag_memset_tag.S +rename to sysdeps/aarch64/__mtag_tag_zero_region.S +index 3c202888a4..74d398bba5 100644 +--- a/sysdeps/aarch64/__mtag_memset_tag.S ++++ b/sysdeps/aarch64/__mtag_tag_zero_region.S +@@ -20,9 +20,6 @@ + + #ifdef USE_MTAG + +-/* Use the same register names and assignments as memset. */ +-#include "memset-reg.h" +- + .arch armv8.5-a + .arch_extension memtag + +@@ -31,16 +28,15 @@ + /* FIXME: This is a minimal implementation. We could do much better than + this for large values of COUNT. */ + +-ENTRY(__libc_mtag_memset_with_tag) ++#define dstin x0 ++#define count x1 ++#define dst x2 + +- and valw, valw, 255 +- orr valw, valw, valw, lsl 8 +- orr valw, valw, valw, lsl 16 +- orr val, val, val, lsl 32 +- mov dst, dstin ++ENTRY(__libc_mtag_tag_zero_region) + ++ mov dst, dstin + L(loop): +- stgp val, val, [dst], #16 ++ stzg dst, [dst], #16 + subs count, count, 16 + bne L(loop) + #if 0 +@@ -49,5 +45,5 @@ L(loop): + ldg dstin, [dstin] // Recover the tag created (might be untagged). + #endif + ret +-END (__libc_mtag_memset_with_tag) ++END (__libc_mtag_tag_zero_region) + #endif /* USE_MTAG */ +diff --git a/sysdeps/aarch64/libc-mtag.h b/sysdeps/aarch64/libc-mtag.h +index 979cbb743e..f58402ccf9 100644 +--- a/sysdeps/aarch64/libc-mtag.h ++++ b/sysdeps/aarch64/libc-mtag.h +@@ -39,8 +39,8 @@ + void *__libc_mtag_tag_region (const void *, size_t) */ + void *__libc_mtag_tag_region (void *, size_t); + +-/* Optimized equivalent to __libc_mtag_tag_region followed by memset. */ +-void *__libc_mtag_memset_with_tag (void *, int, size_t); ++/* Optimized equivalent to __libc_mtag_tag_region followed by memset to 0. */ ++void *__libc_mtag_tag_zero_region (void *, size_t); + + /* Convert address P to a pointer that is tagged correctly for that + location. +diff --git a/sysdeps/generic/libc-mtag.h b/sysdeps/generic/libc-mtag.h +index e8fc236b6c..4743e873f1 100644 +--- a/sysdeps/generic/libc-mtag.h ++++ b/sysdeps/generic/libc-mtag.h +@@ -44,12 +44,12 @@ __libc_mtag_tag_region (void *p, size_t n) + return p; + } + +-/* Optimized equivalent to __libc_mtag_tag_region followed by memset. */ ++/* Optimized equivalent to __libc_mtag_tag_region followed by memset to 0. */ + static inline void * +-__libc_mtag_memset_with_tag (void *p, int c, size_t n) ++__libc_mtag_tag_zero_region (void *p, size_t n) + { + __libc_mtag_link_error (); +- return memset (p, c, n); ++ return memset (p, 0, n); + } + + /* Convert address P to a pointer that is tagged correctly for that +-- +2.25.1 + + +From 4d596cb72342ba0734dc847653431e078a70edfc Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Tue, 16 Feb 2021 17:02:44 +0000 +Subject: [PATCH 09/11] malloc: Change calloc when tagging is disabled + +When glibc is built with memory tagging support (USE_MTAG) but it is not +enabled at runtime (mtag_enabled) then unconditional memset was used +even though that can be often avoided. + +This is for performance when tagging is supported but not enabled. +The extra check should have no overhead: tag_new_zero_region already +had a runtime check which the compiler can now optimize away. + +Reviewed-by: DJ Delorie +--- + malloc/malloc.c | 10 ++++------ + 1 file changed, 4 insertions(+), 6 deletions(-) + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 01cf6e9325..0b2aff3768 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -3591,11 +3591,9 @@ __libc_calloc (size_t n, size_t elem_size) + mchunkptr oldtop; + INTERNAL_SIZE_T sz, oldtopsize; + void *mem; +-#ifndef USE_MTAG + unsigned long clearsize; + unsigned long nclears; + INTERNAL_SIZE_T *d; +-#endif + ptrdiff_t bytes; + + if (__glibc_unlikely (__builtin_mul_overflow (n, elem_size, &bytes))) +@@ -3674,12 +3672,13 @@ __libc_calloc (size_t n, size_t elem_size) + return 0; + + mchunkptr p = mem2chunk (mem); ++ + /* If we are using memory tagging, then we need to set the tags + regardless of MORECORE_CLEARS, so we zero the whole block while + doing so. */ +-#ifdef USE_MTAG +- return tag_new_zero_region (mem, CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); +-#else ++ if (__glibc_unlikely (mtag_enabled)) ++ return tag_new_zero_region (mem, CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ); ++ + INTERNAL_SIZE_T csz = chunksize (p); + + /* Two optional cases in which clearing not necessary */ +@@ -3733,7 +3732,6 @@ __libc_calloc (size_t n, size_t elem_size) + } + + return mem; +-#endif + } + + /* +-- +2.25.1 + + +From 287a35fba55a0a817db7af71ee966a37b7642bf0 Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Mon, 8 Feb 2021 12:39:01 +0000 +Subject: [PATCH 10/11] malloc: Use branches instead of mtag_granule_mask + +The branches may be better optimized since mtag_enabled is widely used. + +Granule size larger than a chunk header is not supported since then we +cannot have both the chunk header and user area granule aligned. To +fix that for targets with large granule, the chunk layout has to change. + +So code that attempted to handle the granule mask generally was changed. +This simplified CHUNK_AVAILABLE_SIZE and the logic in malloc_usable_size. + +Reviewed-by: DJ Delorie +--- + malloc/arena.c | 1 - + malloc/malloc.c | 34 ++++++++++++++-------------------- + 2 files changed, 14 insertions(+), 21 deletions(-) + +diff --git a/malloc/arena.c b/malloc/arena.c +index 1e83bb66bd..9fbbb38a15 100644 +--- a/malloc/arena.c ++++ b/malloc/arena.c +@@ -306,7 +306,6 @@ ptmalloc_init (void) + + mtag_enabled = true; + mtag_mmap_flags = __MTAG_MMAP_FLAGS; +- mtag_granule_mask = ~(size_t)(__MTAG_GRANULE_SIZE - 1); + } + #endif + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 0b2aff3768..849bd8e2c9 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -442,7 +442,6 @@ void *(*__morecore)(ptrdiff_t) = __default_morecore; + #ifdef USE_MTAG + static bool mtag_enabled = false; + static int mtag_mmap_flags = 0; +-static size_t mtag_granule_mask = ~(size_t)0; + #else + # define mtag_enabled false + # define mtag_mmap_flags 0 +@@ -1333,15 +1332,16 @@ nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ + ((req) + SIZE_SZ + MALLOC_ALIGN_MASK) & ~MALLOC_ALIGN_MASK) + + /* Available size of chunk. This is the size of the real usable data +- in the chunk, plus the chunk header. */ +-#ifdef USE_MTAG +-#define CHUNK_AVAILABLE_SIZE(p) \ +- ((chunksize (p) + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) \ +- & mtag_granule_mask) +-#else +-#define CHUNK_AVAILABLE_SIZE(p) \ +- (chunksize (p) + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) +-#endif ++ in the chunk, plus the chunk header. Note: If memory tagging is ++ enabled the layout changes to accomodate the granule size, this is ++ wasteful for small allocations so not done by default. The logic ++ does not work if chunk headers are not granule aligned. */ ++_Static_assert (__MTAG_GRANULE_SIZE <= CHUNK_HDR_SZ, ++ "memory tagging is not supported with large granule."); ++#define CHUNK_AVAILABLE_SIZE(p) \ ++ (__MTAG_GRANULE_SIZE > SIZE_SZ && __glibc_unlikely (mtag_enabled) ? \ ++ chunksize (p) : \ ++ chunksize (p) + (chunk_is_mmapped (p) ? 0 : SIZE_SZ)) + + /* Check if REQ overflows when padded and aligned and if the resulting value + is less than PTRDIFF_T. Returns TRUE and the requested size or MINSIZE in +@@ -1353,7 +1353,6 @@ checked_request2size (size_t req, size_t *sz) __nonnull (1) + if (__glibc_unlikely (req > PTRDIFF_MAX)) + return false; + +-#ifdef USE_MTAG + /* When using tagged memory, we cannot share the end of the user + block with the header for the next chunk, so ensure that we + allocate blocks that are rounded up to the granule size. Take +@@ -1361,8 +1360,9 @@ checked_request2size (size_t req, size_t *sz) __nonnull (1) + number. Ideally, this would be part of request2size(), but that + must be a macro that produces a compile time constant if passed + a constant literal. */ +- req = (req + ~mtag_granule_mask) & mtag_granule_mask; +-#endif ++ if (__glibc_unlikely (mtag_enabled)) ++ req = (req + (__MTAG_GRANULE_SIZE - 1)) & ++ ~(size_t)(__MTAG_GRANULE_SIZE - 1); + + *sz = request2size (req); + return true; +@@ -5112,14 +5112,8 @@ musable (void *mem) + result = chunksize (p) - CHUNK_HDR_SZ; + } + else if (inuse (p)) +- result = chunksize (p) - SIZE_SZ; ++ result = CHUNK_AVAILABLE_SIZE (p) - CHUNK_HDR_SZ; + +-#ifdef USE_MTAG +- /* The usable space may be reduced if memory tagging is needed, +- since we cannot share the user-space data with malloc's internal +- data structure. */ +- result &= mtag_granule_mask; +-#endif + return result; + } + return 0; +-- +2.25.1 + + +From 66de173bf919e601e408dc78772c6841ad6388ab Mon Sep 17 00:00:00 2001 +From: Szabolcs Nagy +Date: Wed, 17 Feb 2021 10:15:18 +0000 +Subject: [PATCH 11/11] malloc: Use mtag_enabled instead of USE_MTAG + +Use the runtime check where possible: it should not cause slow down in +the !USE_MTAG case since then mtag_enabled is constant false, but it +allows compiling the tagging logic so it's less likely to break or +diverge when developers only test the !USE_MTAG case. + +Reviewed-by: DJ Delorie +--- + malloc/hooks.c | 10 ++++------ + malloc/malloc.c | 10 ++++------ + 2 files changed, 8 insertions(+), 12 deletions(-) + +diff --git a/malloc/hooks.c b/malloc/hooks.c +index d8e304c31c..9474e199c3 100644 +--- a/malloc/hooks.c ++++ b/malloc/hooks.c +@@ -262,11 +262,10 @@ free_check (void *mem, const void *caller) + + int err = errno; + +-#ifdef USE_MTAG + /* Quickly check that the freed pointer matches the tag for the memory. + This gives a useful double-free detection. */ +- *(volatile char *)mem; +-#endif ++ if (__glibc_unlikely (mtag_enabled)) ++ *(volatile char *)mem; + + __libc_lock_lock (main_arena.mutex); + p = mem2chunk_check (mem, NULL); +@@ -310,11 +309,10 @@ realloc_check (void *oldmem, size_t bytes, const void *caller) + return NULL; + } + +-#ifdef USE_MTAG + /* Quickly check that the freed pointer matches the tag for the memory. + This gives a useful double-free detection. */ +- *(volatile char *)oldmem; +-#endif ++ if (__glibc_unlikely (mtag_enabled)) ++ *(volatile char *)oldmem; + + __libc_lock_lock (main_arena.mutex); + const mchunkptr oldp = mem2chunk_check (oldmem, &magic_p); +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 849bd8e2c9..36583120ce 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -3286,11 +3286,10 @@ __libc_free (void *mem) + if (mem == 0) /* free(0) has no effect */ + return; + +-#ifdef USE_MTAG + /* Quickly check that the freed pointer matches the tag for the memory. + This gives a useful double-free detection. */ +- *(volatile char *)mem; +-#endif ++ if (__glibc_unlikely (mtag_enabled)) ++ *(volatile char *)mem; + + int err = errno; + +@@ -3352,11 +3351,10 @@ __libc_realloc (void *oldmem, size_t bytes) + if (oldmem == 0) + return __libc_malloc (bytes); + +-#ifdef USE_MTAG + /* Perform a quick check to ensure that the pointer's tag matches the + memory's tag. */ +- *(volatile char*) oldmem; +-#endif ++ if (__glibc_unlikely (mtag_enabled)) ++ *(volatile char*) oldmem; + + /* chunk corresponding to oldmem */ + const mchunkptr oldp = mem2chunk (oldmem); +-- +2.25.1 + diff --git a/poky/meta/recipes-core/glibc/glibc_2.33.bb b/poky/meta/recipes-core/glibc/glibc_2.33.bb index caa2e2ae1..925efe8cc 100644 --- a/poky/meta/recipes-core/glibc/glibc_2.33.bb +++ b/poky/meta/recipes-core/glibc/glibc_2.33.bb @@ -56,6 +56,7 @@ SRC_URI = "${GLIBC_GIT_URI};branch=${SRCBRANCH};name=glibc \ file://0028-readlib-Add-OECORE_KNOWN_INTERPRETER_NAMES-to-known-.patch \ file://0029-wordsize.h-Unify-the-header-between-arm-and-aarch64.patch \ file://0030-powerpc-Do-not-ask-compiler-for-finding-arch.patch \ + file://mte-backports.patch \ " S = "${WORKDIR}/git" B = "${WORKDIR}/build-${TARGET_SYS}" @@ -91,7 +92,7 @@ EXTRA_OECONF += "${@get_libc_fpu_setting(bb, d)}" EXTRA_OECONF_append_x86 = " --enable-cet" EXTRA_OECONF_append_x86-64 = " --enable-cet" -PACKAGECONFIG ??= "nscd" +PACKAGECONFIG ??= "nscd memory-tagging" PACKAGECONFIG[nscd] = "--enable-nscd,--disable-nscd" PACKAGECONFIG[memory-tagging] = "--enable-memory-tagging,--disable-memory-tagging" diff --git a/poky/meta/recipes-core/glibc/ldconfig-native-2.12.1/add-riscv-support.patch b/poky/meta/recipes-core/glibc/ldconfig-native-2.12.1/add-riscv-support.patch new file mode 100644 index 000000000..fc41aee26 --- /dev/null +++ b/poky/meta/recipes-core/glibc/ldconfig-native-2.12.1/add-riscv-support.patch @@ -0,0 +1,79 @@ +From fd50228cc213d2d87f5e3cf1f123acb3fda9b04e Mon Sep 17 00:00:00 2001 +From: Christoph Muellner +Date: Mon, 28 Jun 2021 00:34:12 +0200 +Subject: [PATCH] ldconfig: Add RISC-V support + +ldconfig-native does not support RISC-V at the moment. +Let's pull the reqired constants from upstream and add +the required parsing code. + +Upstream-Status: Backport + +Signed-off-by: Christoph Muellner +--- + cache.c | 6 ++++++ + ldconfig.h | 2 ++ + readelflib.c | 10 ++++++++++ + 3 files changed, 18 insertions(+) + +diff --git a/cache.c b/cache.c +index c4f5411..a3b9e70 100644 +--- a/cache.c ++++ b/cache.c +@@ -125,6 +125,12 @@ print_entry (const char *lib, int flag, unsigned int osversion, + case FLAG_AARCH64_LIB64: + fputs (",AArch64", stdout); + break; ++ case FLAG_RISCV_FLOAT_ABI_SOFT: ++ fputs (",soft-float", stdout); ++ break; ++ case FLAG_RISCV_FLOAT_ABI_DOUBLE: ++ fputs (",double-float", stdout); ++ break; + case 0: + break; + default: +diff --git a/ldconfig.h b/ldconfig.h +index 6a8a750..2e5e379 100644 +--- a/ldconfig.h ++++ b/ldconfig.h +@@ -38,6 +38,8 @@ + #define FLAG_ARM_LIBHF 0x0900 + #define FLAG_AARCH64_LIB64 0x0a00 + #define FLAG_ARM_LIBSF 0x0b00 ++#define FLAG_RISCV_FLOAT_ABI_SOFT 0x0f00 ++#define FLAG_RISCV_FLOAT_ABI_DOUBLE 0x1000 + + /* Name of auxiliary cache. */ + #define _PATH_LDCONFIG_AUX_CACHE "/var/cache/ldconfig/aux-cache" +diff --git a/readelflib.c b/readelflib.c +index 9ec0a54..a01e1ce 100644 +--- a/readelflib.c ++++ b/readelflib.c +@@ -33,6 +33,10 @@ + #define EM_AARCH64 183 /* ARM AARCH64 */ + #endif + ++#ifndef EM_RISCV ++#define EM_RISCV 243 /* RISC-V */ ++#endif ++ + #undef check_ptr + #define check_ptr(ptr) \ + do \ +@@ -331,6 +335,12 @@ process_elf_file64 (const char *file_name, const char *lib, int *flag, + /* see sysdeps/unix/sysv/linux/arm/readelflib.c */ + *flag |= FLAG_AARCH64_LIB64|FLAG_ELF_LIBC6; + break; ++ case EM_RISCV: ++ /* RISC-V libraries are always libc.so.6+. */ ++ /* NOTE: This does not correctly handle soft-float binaries */ ++ /* see sysdeps/unix/sysv/linux/riscv/readelflib.c */ ++ *flag |= FLAG_RISCV_FLOAT_ABI_DOUBLE|FLAG_ELF_LIBC6; ++ break; + default: + error(0, 0, "%s is a 64-bit ELF for unknown machine %lx\n", + file_name, (long)elf_header->e_machine); +-- +2.25.1 + diff --git a/poky/meta/recipes-core/glibc/ldconfig-native_2.12.1.bb b/poky/meta/recipes-core/glibc/ldconfig-native_2.12.1.bb index 919d11417..fd1630b73 100644 --- a/poky/meta/recipes-core/glibc/ldconfig-native_2.12.1.bb +++ b/poky/meta/recipes-core/glibc/ldconfig-native_2.12.1.bb @@ -15,6 +15,7 @@ SRC_URI = "file://ldconfig-native-2.12.1.tar.bz2 \ file://endian-ness_handling_fix.patch \ file://add-64-bit-flag-for-ELF64-entries.patch \ file://no-aux-cache.patch \ + file://add-riscv-support.patch \ " PR = "r2" -- cgit v1.2.3