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 BFC4AC433EF for ; Wed, 2 Feb 2022 11:04:14 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id BB4DD6B031F; Wed, 2 Feb 2022 06:04:07 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id B5E5A6B0321; Wed, 2 Feb 2022 06:04:07 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 963B46B0322; Wed, 2 Feb 2022 06:04:07 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0181.hostedemail.com [216.40.44.181]) by kanga.kvack.org (Postfix) with ESMTP id 7E4A06B031F for ; Wed, 2 Feb 2022 06:04:07 -0500 (EST) Received: from smtpin08.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay03.hostedemail.com (Postfix) with ESMTP id 37452824C424 for ; Wed, 2 Feb 2022 11:04:07 +0000 (UTC) X-FDA: 79097555334.08.B00774C Received: from mail-lf1-f48.google.com (mail-lf1-f48.google.com [209.85.167.48]) by imf10.hostedemail.com (Postfix) with ESMTP id CF1E4C0003 for ; Wed, 2 Feb 2022 11:04:06 +0000 (UTC) Received: by mail-lf1-f48.google.com with SMTP id bu18so39828799lfb.5 for ; Wed, 02 Feb 2022 03:04:06 -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=wo9oDoTr9+opMofUsU18MLG30yml/POvjUCw9DWmUTs=; b=o1rU8PIpltWepZP+5N7r9V3PtFLNLH6wMPx4DvttXOwgoPXYQwal3K/obrXKLZKnei xomAfrBY+phjcjzRAb5SNwF7M4SiVFifEGk8CxBQOi0pjuHLIVm4eznqRwc5/ffNpPDa k7aDs693+btHlT7VO8DXe/MbvK/VaSx9lrkknyPlzOtFgNIXIb30ZSFiOiEQHl1Sukj0 OhGrRKQKrObo9gH+6LWd3Zg0t1IsDoDy4fbv5VSaaE0OFLW3l10ZmDgTvm1H5jsG/bzi 8UURER61P1arBEEAGlNX/aMMp0DcJsvjwMDXkPf/PumUehl+ig8rK/tLGogD7jG67dZn 4Mgg== 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=wo9oDoTr9+opMofUsU18MLG30yml/POvjUCw9DWmUTs=; b=PgrR4SZw5940CBvQePoi7kKthDy3KJyxGvD5luH+yp6SrrJVBwaB/ojvZHmF26XLfC BkhIZGIWsMbRwbX+sy6qitHGwZWnVlJyb94vv9YfS75cNvt/fne/DnyyR+zn7ceKdQSe 9iTXTHooxwILDidd9nBXb+7m6zhs1l8zGnf0iSt5Y4pKINX5LckUyPwb2D4Rq+paV09U FqLDbPYh2Y7sCEL47T8WMbCewTQSjs3x7R7CIqrCYci9Z7i100bS19j/naMa7R387/Ky /m79M1tgAp2+lGtcn7abBQvzgJguHmhSy8SbnrvdYNZoHBhtltOOT0hPJMZGunmiFyfX OLsw== X-Gm-Message-State: AOAM532PyKGemcJ0LX0VA2QsMBOGoQTWkfRVOqbnJKW6hF4A36KMOp8Q uPIvuxfpZ+y9iStVZVTVXVzGBr3gc4o= X-Google-Smtp-Source: ABdhPJzBr1HreI0HQmXg87ltcy+WXra0I0o3KQK3FcN0ytPZkFQs4PFCGIqH7poEXFJckzhnH7oZ4Q== X-Received: by 2002:a05:6512:2295:: with SMTP id f21mr22525606lfu.435.1643799845442; Wed, 02 Feb 2022 03:04:05 -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.04 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 02 Feb 2022 03:04:05 -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 13/16] memblock tests: Add memblock_reserve tests Date: Wed, 2 Feb 2022 12:03:12 +0100 Message-Id: X-Mailer: git-send-email 2.30.2 In-Reply-To: References: MIME-Version: 1.0 X-Rspamd-Server: rspam03 X-Rspamd-Queue-Id: CF1E4C0003 X-Stat-Signature: ry1inmb5fx4paji1po4ta1dy3yiiygkf Authentication-Results: imf10.hostedemail.com; dkim=pass header.d=gmail.com header.s=20210112 header.b=o1rU8PIp; dmarc=pass (policy=none) header.from=gmail.com; spf=pass (imf10.hostedemail.com: domain of karolinadrobnik@gmail.com designates 209.85.167.48 as permitted sender) smtp.mailfrom=karolinadrobnik@gmail.com X-Rspam-User: nil X-HE-Tag: 1643799846-846194 Content-Transfer-Encoding: quoted-printable X-Bogosity: Ham, tests=bogofilter, spamicity=0.000278, version=1.2.4 Sender: owner-linux-mm@kvack.org Precedence: bulk X-Loop: owner-majordomo@kvack.org List-ID: Add checks for marking a region as reserved in different scenarios: - The region does not overlap with existing entries - The region overlaps with one of the previous 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 - The same region is marked as reserved twice Signed-off-by: Karolina Drobnik --- tools/testing/memblock/tests/basic_api.c | 213 +++++++++++++++++++++++ 1 file changed, 213 insertions(+) diff --git a/tools/testing/memblock/tests/basic_api.c b/tools/testing/mem= block/tests/basic_api.c index 6c047b7b31ab..b055ff262d23 100644 --- a/tools/testing/memblock/tests/basic_api.c +++ b/tools/testing/memblock/tests/basic_api.c @@ -239,9 +239,222 @@ static int memblock_add_checks(void) return 0; } =20 + /* + * A simple test that marks a memory block of a specified base address + * and size as reserved and to the collection of reserved memory region= s + * (memblock.reserved). It checks if a new entry was created and if reg= ion + * counter and total memory size were correctly updated. + */ +static int memblock_reserve_simple_check(void) +{ + struct memblock_region *rgn; + + rgn =3D &memblock.reserved.regions[0]; + + struct region r =3D { + .base =3D SZ_2G, + .size =3D SZ_128M + }; + + reset_memblock(); + memblock_reserve(r.base, r.size); + + assert(rgn->base =3D=3D r.base); + assert(rgn->size =3D=3D r.size); + + return 0; +} + +/* + * A test that tries to mark two memory blocks that don't overlap as res= erved + * and checks if two entries were correctly added to the collection of r= eserved + * memory regions (memblock.reserved) and if this change was reflected i= n + * memblock.reserved's total size and region counter. + */ +static int memblock_reserve_disjoint_check(void) +{ + struct memblock_region *rgn1, *rgn2; + + rgn1 =3D &memblock.reserved.regions[0]; + rgn2 =3D &memblock.reserved.regions[1]; + + struct region r1 =3D { + .base =3D SZ_256M, + .size =3D SZ_16M + }; + struct region r2 =3D { + .base =3D SZ_512M, + .size =3D SZ_512M + }; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_reserve(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); + assert(rgn2->size =3D=3D r2.size); + + assert(memblock.reserved.cnt =3D=3D 2); + assert(memblock.reserved.total_size =3D=3D r1.size + r2.size); + + return 0; +} + +/* + * A test that tries to mark two memory blocks as reserved, where the se= cond one + * overlaps with the beginning of the first (that is r1.base < r2.base += r2.size). + * It checks if two entries are merged into one region that starts at r2= .base + * and has size of two regions minus their intersection. The test also v= erifies + * that memblock can still see only one entry and has a correct total si= ze of + * the reserved memory. + */ +static int memblock_reserve_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_1G, + .size =3D SZ_1G + }; + struct region r2 =3D { + .base =3D SZ_128M, + .size =3D SZ_1G + }; + + total_size =3D (r1.base - r2.base) + r1.size; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_reserve(r2.base, r2.size); + + assert(rgn->base =3D=3D r2.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 mark two memory blocks as reserved, where the se= cond + * one overlaps with the end of the first entry (that is r2.base < r1.ba= se + r1.size). + * It checks if two entries are merged into one region that starts at r1= .base + * and has size of two regions minus their intersection. It verifies tha= t memblock + * can still see only one entry and has a correct total size of the rese= rved memory. + */ +static int memblock_reserve_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_2K, + .size =3D SZ_128K + }; + struct region r2 =3D { + .base =3D SZ_128K, + .size =3D SZ_128K + }; + + total_size =3D (r2.base - r1.base) + r2.size; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_reserve(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 mark two memory blocks as reserved, where the se= cond one + * is within the range of the first entry (that is (r1.base < r2.base) &= & + * (r2.base + r2.size < r1.base + r1.size)). It checks if two entries ar= e merged + * into one region that stays the same. The counter and total size of av= ailable + * memory are expected to not be updated. + */ +static int memblock_reserve_within_check(void) +{ + struct memblock_region *rgn; + + rgn =3D &memblock.reserved.regions[0]; + + struct region r1 =3D { + .base =3D SZ_1M, + .size =3D SZ_8M + }; + struct region r2 =3D { + .base =3D SZ_2M, + .size =3D SZ_64K + }; + + reset_memblock(); + memblock_reserve(r1.base, r1.size); + memblock_reserve(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 simple test that tries to reserve the same memory block twice. + * The region counter and total size of reserved memory are expected to = not + * be updated. + */ +static int memblock_reserve_twice_check(void) +{ + struct region r =3D { + .base =3D SZ_16K, + .size =3D SZ_2M + }; + + reset_memblock(); + + memblock_reserve(r.base, r.size); + memblock_reserve(r.base, r.size); + + assert(memblock.reserved.cnt =3D=3D 1); + assert(memblock.reserved.total_size =3D=3D r.size); + + return 0; +} + +static int memblock_reserve_checks(void) +{ + memblock_reserve_simple_check(); + memblock_reserve_disjoint_check(); + memblock_reserve_overlap_top_check(); + memblock_reserve_overlap_bottom_check(); + memblock_reserve_within_check(); + memblock_reserve_twice_check(); + + return 0; +} + int memblock_basic_checks(void) { memblock_initialization_check(); memblock_add_checks(); + memblock_reserve_checks(); + return 0; } --=20 2.30.2