From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from us-smtp-delivery-124.mimecast.com (us-smtp-delivery-124.mimecast.com [170.10.133.124]) by sourceware.org (Postfix) with ESMTPS id C169C3858C50 for ; Wed, 5 Apr 2023 06:14:49 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org C169C3858C50 Authentication-Results: sourceware.org; dmarc=pass (p=none dis=none) header.from=redhat.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=redhat.com DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1680675289; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=rjwEaX2s9wBlccfeiU3wSALYWjluv22t0zMLuQ87/hQ=; b=JElKqQ6uRe0juVsxgB8TZAmFI0YZMlbY4Se/dwUR6fpSol6Qa620Yu6VBmPtyEXlmsxLUd nJiqqMsepl88Pg84oGfuU2GCbaWY98jjEDywkLVXbrL+4uzZtm4m6pcmYygV0zzIlBG611 /muc9+EvsxhXXLK+AB2Vig38F/onKzo= Received: from mail-yw1-f197.google.com (mail-yw1-f197.google.com [209.85.128.197]) by relay.mimecast.com with ESMTP with STARTTLS (version=TLSv1.3, cipher=TLS_AES_256_GCM_SHA384) id us-mta-664-AbKSI_05OFKr60IiID8v_Q-1; Wed, 05 Apr 2023 02:14:48 -0400 X-MC-Unique: AbKSI_05OFKr60IiID8v_Q-1 Received: by mail-yw1-f197.google.com with SMTP id 00721157ae682-545d3b026a8so295376467b3.7 for ; Tue, 04 Apr 2023 23:14:47 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; t=1680675287; h=content-transfer-encoding:in-reply-to:organization:from:references :cc:to:content-language:subject:user-agent:mime-version:date :message-id:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=rjwEaX2s9wBlccfeiU3wSALYWjluv22t0zMLuQ87/hQ=; b=SDBR52aiXU/XWMAjXhozDU5uBzwF0d2drtKTPQ2J8fbhLRw0AgtKtNJQlghMgOt1uz UZn40v/vNZcLs/L/oaPPwOhY/dFyXWjdECTJbUoPVr+hF4etzbWKJidQ2szOk+lnpIby PRadtyX5FFCHanek5oQxR1WB92+O7tQY1d5/neRCgohAikF9v8F6PIR+S8dhVGCQUc5a AVooOg2R1fPkxs7fo3HhX4DJ10ReuChxtaj+bf6vd/+kN+mVIo+kQ8xFOvFQlnmOURrl a+gfKY41kaCUX7/vvu1TQP9DBMGP69EKMzlaAddsti9n9z9tPYPYsx1pB7X2hLPYmv2A qMPQ== X-Gm-Message-State: AAQBX9cGtwroSTb9nbwsdrMVMmSlLidoyMFMrMvlH151tTJLHE6xQKzk BaTW4oTNYZ1NxxHUZtdHYZ30PSKiwHuk6ty+/LuXlcaJL155eSYXpmS6FxfrlRoOoVqBMN0y3R8 lPYWdLyPeXSkdZ0lGO5Fe X-Received: by 2002:a81:62d5:0:b0:538:77de:8efe with SMTP id w204-20020a8162d5000000b0053877de8efemr3734865ywb.47.1680675287390; Tue, 04 Apr 2023 23:14:47 -0700 (PDT) X-Google-Smtp-Source: AKy350ad048jinrizUNhNRpmHcHMWnS+2BDEJlBTYMqfoScSTujZwo5cuPTi/sB/Jrr+B0kG//ggMg== X-Received: by 2002:a81:62d5:0:b0:538:77de:8efe with SMTP id w204-20020a8162d5000000b0053877de8efemr3734859ywb.47.1680675287016; Tue, 04 Apr 2023 23:14:47 -0700 (PDT) Received: from [192.168.0.241] ([198.48.244.52]) by smtp.gmail.com with ESMTPSA id h65-20020a816c44000000b00545a081847esm3694376ywc.14.2023.04.04.23.14.46 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 04 Apr 2023 23:14:46 -0700 (PDT) Message-ID: Date: Wed, 5 Apr 2023 02:14:45 -0400 MIME-Version: 1.0 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:102.0) Gecko/20100101 Thunderbird/102.9.0 Subject: Re: [patch v2] malloc: set NON_MAIN_ARENA flag for reclaimed memalign chunk (BZ #30101) To: DJ Delorie Cc: libc-alpha@sourceware.org References: From: Carlos O'Donell Organization: Red Hat In-Reply-To: X-Mimecast-Spam-Score: 0 X-Mimecast-Originator: redhat.com Content-Language: en-US Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 7bit X-Spam-Status: No, score=-13.4 required=5.0 tests=BAYES_00,DKIMWL_WL_HIGH,DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,DKIM_VALID_EF,GIT_PATCH_0,KAM_SHORT,NICE_REPLY_A,RCVD_IN_DNSWL_NONE,RCVD_IN_MSPIKE_H2,SPF_HELO_NONE,SPF_NONE,TXREP autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org List-Id: On 4/4/23 22:27, DJ Delorie wrote: > "Carlos O'Donell" writes: >> (a) Fix both cases where this happens. The other is here: >> >> 5199 /* Also give back spare room at the end */ >> 5200 if (!chunk_is_mmapped (p)) >> 5201 { >> 5202 size = chunksize (p); >> 5203 if ((unsigned long) (size) > (unsigned long) (nb + MINSIZE)) >> 5204 { >> 5205 remainder_size = size - nb; >> 5206 remainder = chunk_at_offset (p, nb); >> 5207 set_head (remainder, remainder_size | PREV_INUSE | >> 5208 (av != &main_arena ? NON_MAIN_ARENA : 0)); >> 5209 set_head_size (p, nb); >> 5210 _int_free (av, remainder, 1); >> 5211 } >> 5212 } > > This is the opposite of what I'm fixing; here we set a flag where it > isn't required. Given we always use accessor functions (chunksize() and > chunsize_nomask()) it's no longer critical to follow the "not set when > not needed" rule. On line 5209 we don't set NON_MAIN_ARENA bits in the call to set_head_size(p, nb); e.g. set_head_size (p, nb | (av != &main_arena ? NON_MAIN_ARENA : 0)); Is this because p is expected to have already been a chunk with NON_MAIN_ARENA set correctly, and the set_head_size() macro correctly applies the existing bits? That p either came from the "discovered" already aligned chunk (whose bits you are correcting) or from _int_malloc? If that's the case then I agree the above does not need fixing. >> (b) Remove the comment that says NON_MAIN_ARENA flag is never set, >> and adjust the comment to say it's always set. > > Is this an "a or b" or "a and b"? My preference would be something like this: diff --git a/malloc/malloc.c b/malloc/malloc.c index 0315ac5d16..25c1f7ebe9 100644 --- a/malloc/malloc.c +++ b/malloc/malloc.c @@ -1359,8 +1359,7 @@ checked_request2size (size_t req) __nonnull (1) /* size field is or'ed with NON_MAIN_ARENA if the chunk was obtained - from a non-main arena. This is only set immediately before handing - the chunk to the user, if necessary. */ + from a non-main arena. */ #define NON_MAIN_ARENA 0x4 /* Check for chunk from main arena. */ @@ -1647,9 +1646,6 @@ unlink_chunk (mstate av, mchunkptr p) binning. So, basically, the unsorted_chunks list acts as a queue, with chunks being placed on it in free (and malloc_consolidate), and taken off (to be either used or placed in bins) in malloc. - - The NON_MAIN_ARENA flag is never set for unsorted chunks, so it - does not have to be taken into account in size comparisons. */ /* The otherwise unindexable 1-bin is used to hold unsorted chunks. */ --- >> I want a *strong* invariant here that the chunks have their flags set >> correctly when placed into any of the lists, to do otherwise is incredibly >> confusing and is the root cause of the assertion triggering (very good of >> you to add it in the first place). > > I see this as a restructuring to change the internal semantics of > malloc, and not in the scope of this simple bugfix. I don't oppose it > in general, but as any bugs would be hidden behind the accessor > functions, testing it and/or proving it correct would be difficult, and > needlessly delay getting this bug fixed. You're absolutely right. Lets continue with v2, but I'm very concerned about the invariant not being true, and that could lead to confusion in the future. > v2: > > * New test case included, same as first test case but runs in a thread. > Fails without the patch, passes with. > > * Fixed first test case to handle tcache better > > In some cases, when you memalign and a large chunk is found and split > up, the chunk may be larger than you expect if the excess was too > small to make a new chunk. In those cases, the chunk would be > free()'d to a different tcache than you expect. Thus, we must use > malloc_usable_size() to determine where it went, and how to get it > "back". > > Also, if the alignment is no more than the default alignment anyway, > memalign calls malloc, so the small alignment tests were increased to > force them to test the target logic. > > > From 1504a80d3783849c5da59dd7c627bc92c801a8c4 Mon Sep 17 00:00:00 2001 > From: DJ Delorie > Date: Mon, 3 Apr 2023 17:33:03 -0400 > Subject: malloc: set NON_MAIN_ARENA flag for reclaimed memalign chunk (BZ > #30101) > > Based on these comments in malloc.c: > > size field is or'ed with NON_MAIN_ARENA if the chunk was obtained > from a non-main arena. This is only set immediately before handing > the chunk to the user, if necessary. > > The NON_MAIN_ARENA flag is never set for unsorted chunks, so it > does not have to be taken into account in size comparisons. > > When we pull a chunk off the unsorted list (or any list) we need to > make sure that flag is set properly before returning the chunk. I'm honestly curious by what path a chunk gets into the unsorted list with NON_MAIN_ARENA unset? You don't need to answer this, but if you know it, then I'm curious about the path. > > diff --git a/malloc/Makefile b/malloc/Makefile > index f49675845e..e66247ed01 100644 > --- a/malloc/Makefile > +++ b/malloc/Makefile > @@ -43,7 +43,8 @@ tests := mallocbug tst-malloc tst-valloc tst-calloc tst-obstack \ > tst-tcfree1 tst-tcfree2 tst-tcfree3 \ > tst-safe-linking \ > tst-mallocalign1 \ > - tst-memalign-2 > + tst-memalign-2 \ > + tst-memalign-3 > > tests-static := \ > tst-interpose-static-nothread \ > @@ -71,7 +72,7 @@ test-srcs = tst-mtrace > # with MALLOC_CHECK_=3 because they expect a specific failure. > tests-exclude-malloc-check = tst-malloc-check tst-malloc-usable \ > tst-mxfast tst-safe-linking \ > - tst-compathooks-off tst-compathooks-on tst-memalign-2 > + tst-compathooks-off tst-compathooks-on tst-memalign-2 tst-memalign-3 > > # Run all tests with MALLOC_CHECK_=3 > tests-malloc-check = $(filter-out $(tests-exclude-malloc-check) \ > diff --git a/malloc/malloc.c b/malloc/malloc.c > index 0315ac5d16..66e7ca57dd 100644 > --- a/malloc/malloc.c > +++ b/malloc/malloc.c > @@ -5147,6 +5147,8 @@ _int_memalign (mstate av, size_t alignment, size_t bytes) > p = victim; > m = chunk2mem (p); > set_inuse (p); > + if (av != &main_arena) > + set_non_main_arena (p); > } > else > { > diff --git a/malloc/tst-memalign-2.c b/malloc/tst-memalign-2.c > index 4996578e9f..f229283dbf 100644 > --- a/malloc/tst-memalign-2.c > +++ b/malloc/tst-memalign-2.c > @@ -33,9 +33,10 @@ typedef struct TestCase { > } TestCase; > > static TestCase tcache_allocs[] = { > - { 24, 8, NULL, NULL }, > - { 24, 16, NULL, NULL }, > - { 128, 32, NULL, NULL } > + { 24, 32, NULL, NULL }, > + { 24, 64, NULL, NULL }, > + { 128, 128, NULL, NULL }, > + { 500, 128, NULL, NULL } > }; > #define TN array_length (tcache_allocs) > > @@ -70,11 +71,15 @@ do_test (void) > > for (i = 0; i < TN; ++ i) > { > + size_t sz2; > + > tcache_allocs[i].ptr1 = memalign (tcache_allocs[i].alignment, tcache_allocs[i].size); > CHECK (tcache_allocs[i].ptr1, tcache_allocs[i].alignment); > + sz2 = malloc_usable_size (tcache_allocs[i].ptr1); > free (tcache_allocs[i].ptr1); > + > /* This should return the same chunk as was just free'd. */ > - tcache_allocs[i].ptr2 = memalign (tcache_allocs[i].alignment, tcache_allocs[i].size); > + tcache_allocs[i].ptr2 = memalign (tcache_allocs[i].alignment, sz2); > CHECK (tcache_allocs[i].ptr2, tcache_allocs[i].alignment); > free (tcache_allocs[i].ptr2); > > diff --git a/malloc/tst-memalign-3.c b/malloc/tst-memalign-3.c > new file mode 100644 > index 0000000000..ab90d6ca9b > --- /dev/null > +++ b/malloc/tst-memalign-3.c > @@ -0,0 +1,173 @@ > +/* Test for memalign chunk reuse. > + Copyright (C) 2022 Free Software Foundation, Inc. > + This file is part of the GNU C Library. > + > + The GNU C Library is free software; you can redistribute it and/or > + modify it under the terms of the GNU Lesser General Public > + License as published by the Free Software Foundation; either > + version 2.1 of the License, or (at your option) any later version. > + > + The GNU C Library is distributed in the hope that it will be useful, > + but WITHOUT ANY WARRANTY; without even the implied warranty of > + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU > + Lesser General Public License for more details. > + > + You should have received a copy of the GNU Lesser General Public > + License along with the GNU C Library; if not, see > + . */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > + > +typedef struct TestCase { > + size_t size; > + size_t alignment; > + void *ptr1; > + void *ptr2; > +} TestCase; > + > +static TestCase tcache_allocs[] = { > + { 24, 32, NULL, NULL }, > + { 24, 64, NULL, NULL }, > + { 128, 128, NULL, NULL }, > + { 500, 128, NULL, NULL } > +}; > +#define TN array_length (tcache_allocs) > + > +static TestCase large_allocs[] = { > + { 23450, 64, NULL, NULL }, > + { 23450, 64, NULL, NULL }, > + { 23550, 64, NULL, NULL }, > + { 23550, 64, NULL, NULL }, > + { 23650, 64, NULL, NULL }, > + { 23650, 64, NULL, NULL }, > + { 33650, 64, NULL, NULL }, > + { 33650, 64, NULL, NULL } > +}; > +#define LN array_length (large_allocs) > + > +void *p; > + > +/* Sanity checks, ancillary to the actual test. */ > +#define CHECK(p,a) \ > + if (p == NULL || !PTR_IS_ALIGNED (p, a)) \ > + FAIL_EXIT1 ("NULL or misaligned memory detected.\n"); > + > +static void * > +mem_test (void *closure) > +{ > + int i; > + int j; > + int count; > + void *ptr[10]; > + void *p; > + > + /* TCache test. */ > + for (i = 0; i < TN; ++ i) > + { > + size_t sz2; > + > + tcache_allocs[i].ptr1 = memalign (tcache_allocs[i].alignment, tcache_allocs[i].size); > + CHECK (tcache_allocs[i].ptr1, tcache_allocs[i].alignment); > + sz2 = malloc_usable_size (tcache_allocs[i].ptr1); > + free (tcache_allocs[i].ptr1); > + > + /* This should return the same chunk as was just free'd. */ > + tcache_allocs[i].ptr2 = memalign (tcache_allocs[i].alignment, sz2); > + CHECK (tcache_allocs[i].ptr2, tcache_allocs[i].alignment); > + free (tcache_allocs[i].ptr2); > + > + TEST_VERIFY (tcache_allocs[i].ptr1 == tcache_allocs[i].ptr2); > + } > + > + /* Test for non-head tcache hits. */ > + for (i = 0; i < array_length (ptr); ++ i) > + { > + if (i == 4) > + { > + ptr[i] = memalign (64, 256); > + CHECK (ptr[i], 64); > + } > + else > + { > + ptr[i] = malloc (256); > + CHECK (ptr[i], 4); > + } > + } > + for (i = 0; i < array_length (ptr); ++ i) > + free (ptr[i]); > + > + p = memalign (64, 256); > + CHECK (p, 64); > + > + count = 0; > + for (i = 0; i < 10; ++ i) > + if (ptr[i] == p) > + ++ count; > + free (p); > + TEST_VERIFY (count > 0); > + > + /* Large bins test. */ > + > + for (i = 0; i < LN; ++ i) > + { > + large_allocs[i].ptr1 = memalign (large_allocs[i].alignment, large_allocs[i].size); > + CHECK (large_allocs[i].ptr1, large_allocs[i].alignment); > + /* Keep chunks from combining by fragmenting the heap. */ > + p = malloc (512); > + CHECK (p, 4); > + } > + > + for (i = 0; i < LN; ++ i) > + free (large_allocs[i].ptr1); > + > + /* Force the unsorted bins to be scanned and moved to small/large > + bins. */ > + p = malloc (60000); > + > + for (i = 0; i < LN; ++ i) > + { > + large_allocs[i].ptr2 = memalign (large_allocs[i].alignment, large_allocs[i].size); > + CHECK (large_allocs[i].ptr2, large_allocs[i].alignment); > + } > + > + count = 0; > + for (i = 0; i < LN; ++ i) > + { > + int ok = 0; > + for (j = 0; j < LN; ++ j) > + if (large_allocs[i].ptr1 == large_allocs[j].ptr2) > + ok = 1; > + if (ok == 1) > + count ++; > + } > + > + /* The allocation algorithm is complicated outside of the memalign > + logic, so just make sure it's working for most of the > + allocations. This avoids possible boundary conditions with > + empty/full heaps. */ > + TEST_VERIFY (count > LN / 2); > + > + return 0; > +} > + > +static int > +do_test (void) > +{ > + pthread_t p; > + > + p = xpthread_create (NULL, mem_test, NULL); > + xpthread_join (p); > + return 0; > +} > + > +#include > -- Cheers, Carlos.