From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: by sourceware.org (Postfix, from userid 1944) id 6B3E73AAA050; Thu, 4 Mar 2021 16:25:44 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org 6B3E73AAA050 Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: Szabolcs Nagy To: glibc-cvs@sourceware.org Subject: [glibc/nsz/mtag] malloc: Use global flag instead of function pointer dispatch for mtag X-Act-Checkin: glibc X-Git-Author: Szabolcs Nagy X-Git-Refname: refs/heads/nsz/mtag X-Git-Oldrev: 7a7aa2e4dacc7a35e83bed9dbb6b32f7f990ff67 X-Git-Newrev: 853194b87e0600c43b2d9742250e36ce4bbaf74a Message-Id: <20210304162544.6B3E73AAA050@sourceware.org> Date: Thu, 4 Mar 2021 16:25:44 +0000 (GMT) X-BeenThere: glibc-cvs@sourceware.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Glibc-cvs mailing list List-Unsubscribe: , List-Archive: List-Help: List-Subscribe: , X-List-Received-Date: Thu, 04 Mar 2021 16:25:44 -0000 https://sourceware.org/git/gitweb.cgi?p=glibc.git;h=853194b87e0600c43b2d9742250e36ce4bbaf74a commit 853194b87e0600c43b2d9742250e36ce4bbaf74a Author: Szabolcs Nagy Date: Wed Jan 27 15:45:43 2021 +0000 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. Diff: --- 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 e5f520267b..caf34843f7 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 @@ -3185,6 +3191,18 @@ tcache_thread_shutdown (void) #endif /* !USE_TCACHE */ +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; +} + void * __libc_malloc (size_t bytes) {