From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from kanga.kvack.org (kanga.kvack.org [205.233.56.17]) by smtp.lore.kernel.org (Postfix) with ESMTP id C03EEC433EF for ; Wed, 2 Feb 2022 11:04:20 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 856DD6B0326; Wed, 2 Feb 2022 06:04:12 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 7675B6B0327; Wed, 2 Feb 2022 06:04:12 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 5B9746B0328; Wed, 2 Feb 2022 06:04:12 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0088.hostedemail.com [216.40.44.88]) by kanga.kvack.org (Postfix) with ESMTP id 412C96B0326 for ; Wed, 2 Feb 2022 06:04:12 -0500 (EST) Received: from smtpin29.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay05.hostedemail.com (Postfix) with ESMTP id 00814181C193D for ; Wed, 2 Feb 2022 11:04:11 +0000 (UTC) X-FDA: 79097555544.29.E83EB77 Received: from mail-lf1-f47.google.com (mail-lf1-f47.google.com [209.85.167.47]) by imf01.hostedemail.com (Postfix) with ESMTP id 9C95040006 for ; Wed, 2 Feb 2022 11:04:11 +0000 (UTC) Received: by mail-lf1-f47.google.com with SMTP id k13so7543149lfg.9 for ; Wed, 02 Feb 2022 03:04:11 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=fXs9Z9PQYCruMdcrfaMtY0ndpO2Xn6EDlt3MZzXYgdU=; b=Dba5XaJ4YA9vpc0hY5gn45LFbLkG/VzuAUztdk53/XTRWBh6s761tDC/A3IF9fnCze /+glyw8MSR1ID6IHiJ/cnI0y/V9M7hQ9NCNTrfZPzRBvwQrtxytnB2KCDvQb6r+z2RtW 8622a/Asuu1bjdAq6NmBzW8+bCABmCKpi6MQR4a6GEU2wmDB4ICldMvLYK6rW+8aVrMV U+vMKFGCV3OOQYWwqTCQs0qm3T68s0XscVj7YpEbsaA8w9YEzjNveZLPo1W/MMa7l3p6 6Nck9ktAKT06GNvBgQlvPCzvETxBPW3zCbNi4vOYksN63nFZK57tFMrJPjJLWZF43eUF n4Ng== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=fXs9Z9PQYCruMdcrfaMtY0ndpO2Xn6EDlt3MZzXYgdU=; b=y81EgyclQWkSJZx+BbFXJIOxq6cXcwhKVvnSRihImgoBQwiMKoOrt5b6ivq+pWqilL fANtqdrmm+FnkYxZMLAHqRagSAk3wb1rkxuJyKs9F2J457I1AzNn06cb2OlU7QZvCykP cf/r0cPZLwX/Lug/QV3GieHEbDBmyid/qTbkZpFadJHzwZa3VwNqDHiu3UzzqXBuId1w rZvNz9ayKZi4VqynfSGKoLYGUC+k8t9R+stMDGnJOoXZ70JBlpjgvfDYS25GoL3TVZcY jzecSIBBcOo1tftHXxMoi8SqGnyfQHWUqf9grcbqFuwtPpC7zq0CNQsP51wGFZP7XSmU tHDA== X-Gm-Message-State: AOAM531FstM/UuxDpl0+u9eRcvNzUw6vpiz2iY1lMNA4vwbefFNCVOwq js6j3LJnkdvSXfkeYZv7oqMfyvBWUQY= X-Google-Smtp-Source: ABdhPJxR1zuszDMGjwGZeutMvY35G28bmpwlvPOGrKcn1rCWt6gy9RgtvgaRkVsAv3cFx97J4LRhBA== X-Received: by 2002:a05:6512:3f99:: with SMTP id x25mr10847382lfa.235.1643799850317; Wed, 02 Feb 2022 03:04:10 -0800 (PST) Received: from localhost.localdomain (staticline-31-183-164-222.toya.net.pl. [31.183.164.222]) by smtp.gmail.com with ESMTPSA id r14sm4503937lfr.129.2022.02.02.03.04.09 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 02 Feb 2022 03:04:09 -0800 (PST) From: Karolina Drobnik To: linux-mm@kvack.org Cc: akpm@linux-foundation.org, rppt@kernel.org, linux-kernel@vger.kernel.org, Karolina Drobnik Subject: [PATCH v2 16/16] memblock tests: Add memblock_free tests Date: Wed, 2 Feb 2022 12:03:15 +0100 Message-Id: <30af95c82754ad8029404c3b528a5ef1c05d1ed6.1643796665.git.karolinadrobnik@gmail.com> X-Mailer: git-send-email 2.30.2 In-Reply-To: References: MIME-Version: 1.0 X-Rspamd-Server: rspam09 X-Rspamd-Queue-Id: 9C95040006 X-Stat-Signature: ekzmdqgij6oqzodntkq59oijwo5mb68c X-Rspam-User: nil Authentication-Results: imf01.hostedemail.com; dkim=pass header.d=gmail.com header.s=20210112 header.b=Dba5XaJ4; spf=pass (imf01.hostedemail.com: domain of karolinadrobnik@gmail.com designates 209.85.167.47 as permitted sender) smtp.mailfrom=karolinadrobnik@gmail.com; dmarc=pass (policy=none) header.from=gmail.com X-HE-Tag: 1643799851-159266 Content-Transfer-Encoding: quoted-printable X-Bogosity: Ham, tests=bogofilter, spamicity=0.000000, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: Add checks for removing a region from reserved memory in different scenarios: - The requested region matches one in the collection of reserved memory regions - The requested region does not exist in memblock.reserved - The region overlaps with one of the entries: from the top (its end address is bigger than the base of the existing region) or from the bottom (its base address is smaller than the end address of one of the regions) - The region is within an already defined region Signed-off-by: Karolina Drobnik --- tools/testing/memblock/tests/basic_api.c | 199 +++++++++++++++++++++++ 1 file changed, 199 insertions(+) diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/mem= block/tests/basic_api.c index 02eb88358a58..568b05b52883 100644 --- a/tools/testing/memblock/tests/basic_api.c +++ b/tools/testing/memblock/tests/basic_api.c @@ -686,12 +686,211 @@ static int memblock_remove_checks(void) return 0; } =20 +/* + * A simple test that tries to free a memory block that was marked earli= er as + * reserved. By "freeing" a region we mean overwriting it with the next = entry + * in memblock.reserved. To check this is the case, the test reserves tw= o memory + * regions and verifies that the value of the latter was used to erase r= 1 region. + * The test also checks if the region counter and total size were update= d. + */ +static int memblock_free_simple_check(void) +{ + struct memblock_region *rgn; + + rgn =3D &memblock.reserved.regions[0]; + + struct region r1 =3D { + .base =3D SZ_4M, + .size =3D SZ_1M + }; + struct region r2 =3D { + .base =3D SZ_8M, + .size =3D SZ_1M + }; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_reserve(r2.base, r2.size); + memblock_free((void *)r1.base, r1.size); + + assert(rgn->base =3D=3D r2.base); + assert(rgn->size =3D=3D r2.size); + + assert(memblock.reserved.cnt =3D=3D 1); + assert(memblock.reserved.total_size =3D=3D r2.size); + + return 0; +} + + /* + * A test that tries to free a region that was not marked as reserved (= i.e. has + * no corresponding entry in memblock.reserved). It verifies that array= , regions + * counter and total size were not modified. + */ +static int memblock_free_absent_check(void) +{ + struct memblock_region *rgn; + + rgn =3D &memblock.reserved.regions[0]; + + struct region r1 =3D { + .base =3D SZ_2M, + .size =3D SZ_8K + }; + struct region r2 =3D { + .base =3D SZ_16M, + .size =3D SZ_128M + }; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_free((void *)r2.base, r2.size); + + assert(rgn->base =3D=3D r1.base); + assert(rgn->size =3D=3D r1.size); + + assert(memblock.reserved.cnt =3D=3D 1); + assert(memblock.reserved.total_size =3D=3D r1.size); + + return 0; +} + +/* + * A test that tries to free a region which overlaps with the beginning = of + * the already existing entry r1 (that is r1.base < r2.base + r2.size). = It + * checks if only the intersection of both regions is freed. The test al= so + * checks if the regions counter and total size are updated to expected = values. + */ +static int memblock_free_overlap_top_check(void) +{ + struct memblock_region *rgn; + phys_addr_t total_size; + + rgn =3D &memblock.reserved.regions[0]; + + struct region r1 =3D { + .base =3D SZ_8M, + .size =3D SZ_32M + }; + struct region r2 =3D { + .base =3D SZ_1M, + .size =3D SZ_8M + }; + + total_size =3D (r1.size + r1.base) - (r2.base + r2.size); + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_free((void *)r2.base, r2.size); + + assert(rgn->base =3D=3D r2.base + r2.size); + assert(rgn->size =3D=3D total_size); + + assert(memblock.reserved.cnt =3D=3D 1); + assert(memblock.reserved.total_size =3D=3D total_size); + + return 0; +} + +/* + * A test that tries to free a region which overlaps with the end of the + * first entry (that is r2.base < r1.base + r1.size). It checks if only = the + * intersection of both regions is freed. The test also checks if the re= gions + * counter and total size are updated to expected values. + */ +static int memblock_free_overlap_bottom_check(void) +{ + struct memblock_region *rgn; + phys_addr_t total_size; + + rgn =3D &memblock.reserved.regions[0]; + + struct region r1 =3D { + .base =3D SZ_8M, + .size =3D SZ_32M + }; + struct region r2 =3D { + .base =3D SZ_32M, + .size =3D SZ_32M + }; + + total_size =3D r2.base - r1.base; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_free((void *)r2.base, r2.size); + + assert(rgn->base =3D=3D r1.base); + assert(rgn->size =3D=3D total_size); + + assert(memblock.reserved.cnt =3D=3D 1); + assert(memblock.reserved.total_size =3D=3D total_size); + + return 0; +} + +/* + * A test that tries to free a region which is within the range of the a= lready + * existing entry (that is (r1.base < r2.base) && (r2.base + r2.size < r= 1.base + r1.size)). + * It checks if the region is split into two - one that ends at r2.base = and second + * that starts at r2.base + size, with appropriate sizes. It is expected= that + * the region counter and total size fields were updated t reflect that = change. + */ +static int memblock_free_within_check(void) +{ + struct memblock_region *rgn1, *rgn2; + phys_addr_t r1_size, r2_size, total_size; + + rgn1 =3D &memblock.reserved.regions[0]; + rgn2 =3D &memblock.reserved.regions[1]; + + struct region r1 =3D { + .base =3D SZ_1M, + .size =3D SZ_8M + }; + struct region r2 =3D { + .base =3D SZ_4M, + .size =3D SZ_1M + }; + + r1_size =3D r2.base - r1.base; + r2_size =3D (r1.base + r1.size) - (r2.base + r2.size); + total_size =3D r1_size + r2_size; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_free((void *)r2.base, r2.size); + + assert(rgn1->base =3D=3D r1.base); + assert(rgn1->size =3D=3D r1_size); + + assert(rgn2->base =3D=3D r2.base + r2.size); + assert(rgn2->size =3D=3D r2_size); + + assert(memblock.reserved.cnt =3D=3D 2); + assert(memblock.reserved.total_size =3D=3D total_size); + + return 0; +} + +static int memblock_free_checks(void) +{ + memblock_free_simple_check(); + memblock_free_absent_check(); + memblock_free_overlap_top_check(); + memblock_free_overlap_bottom_check(); + memblock_free_within_check(); + + return 0; +} + int memblock_basic_checks(void) { memblock_initialization_check(); memblock_add_checks(); memblock_reserve_checks(); memblock_remove_checks(); + memblock_free_checks(); =20 return 0; } --=20 2.30.2