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 B878AC433F5 for ; Thu, 27 Jan 2022 13:23:03 +0000 (UTC) Received: by kanga.kvack.org (Postfix) id 4C51C6B0096; Thu, 27 Jan 2022 08:23:03 -0500 (EST) Received: by kanga.kvack.org (Postfix, from userid 40) id 424DD6B0099; Thu, 27 Jan 2022 08:23:03 -0500 (EST) X-Delivered-To: int-list-linux-mm@kvack.org Received: by kanga.kvack.org (Postfix, from userid 63042) id 2C6AD6B009A; Thu, 27 Jan 2022 08:23:03 -0500 (EST) X-Delivered-To: linux-mm@kvack.org Received: from forelay.hostedemail.com (smtprelay0063.hostedemail.com [216.40.44.63]) by kanga.kvack.org (Postfix) with ESMTP id 1669D6B0096 for ; Thu, 27 Jan 2022 08:23:03 -0500 (EST) Received: from smtpin22.hostedemail.com (10.5.19.251.rfc1918.com [10.5.19.251]) by forelay02.hostedemail.com (Postfix) with ESMTP id D8FD89275C for ; Thu, 27 Jan 2022 13:23:02 +0000 (UTC) X-FDA: 79076132604.22.9CE37C3 Received: from mail-lf1-f43.google.com (mail-lf1-f43.google.com [209.85.167.43]) by imf29.hostedemail.com (Postfix) with ESMTP id 85F5D120087 for ; Thu, 27 Jan 2022 13:23:01 +0000 (UTC) Received: by mail-lf1-f43.google.com with SMTP id a28so5285376lfl.7 for ; Thu, 27 Jan 2022 05:23:01 -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=jP/+ihSr4g51rsEx0q+yw/44YG9CAcNNZB3nCAL6BfNzapzprh4l5M+lKCVLrDbYmb E4hBP5y6i9thwDqyUm40qQ99PtTsUQcuhuenOZujAhVV78ruxXA6D4vTQhbftnQTaZp0 lzmu4Y4gQHAdTlY6IXE616VAFkNk3PimSmI+Ew1T4ahiNsOAEd4HVgeKyo9qw5iDyWCY lQKyRY3kAPEh4uD8wQPgYYgr5NvCxbICgR/AnGK/MuCsvKKsontQOCWWW29UatoO6BpD raZES3d/+P+f8IuFCoEc1k18WzbBDZADts+aDwXu5MZUiUVr0Vie3USGi4wPj5yPMZJB MN4g== 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=xXlVOkeRGP/x9sOoV4/XgCHNAQOvaq2x+T9rgzv/W+ozgaecpth43YPSR4nYR2fpc9 tgpmoCsKJ1dqNVzi8hwa6d9sKJSQ9QBO8DHKPTlXLpkgA9uPAsKD9EHfXtA99LitRKdD lYFIxSQe8doG7LYC/d+1oU6LlZa5G7+g1t7jnnoQwGKzpVBYzZl++cme9bd4uyP1KiBL cS97FNuHyWYkv43cg8qRwqtWfEwoRYa3nwnEfPr1dyGRDMfKiDpVjyyo0iiU2wJ2WxMl YbhzOd8HapnmE2PdvWVqVkW1w2OwVYUBZ2877IwreSGHevLyVlVCCuiEAk+d48MSl1FT Ifvw== X-Gm-Message-State: AOAM531Ycj9C8gB1mgpR/cjVgwMyWAjZzUG2LvtDYdkRpLy/HgjDWJct UUp5n6r6DjzmhViTNVubUbbuhLq/AOg= X-Google-Smtp-Source: ABdhPJynVFbj7l9tFBplnLU9W06Hzj8764UyQPBLqnquPB33OyA2o7mk1idQQTMT4nn0O1PyggxmUw== X-Received: by 2002:a19:5f58:: with SMTP id a24mr2785650lfj.46.1643289780152; Thu, 27 Jan 2022 05:23:00 -0800 (PST) Received: from elysium.toya.net.pl (staticline-31-183-166-172.toya.net.pl. [31.183.166.172]) by smtp.gmail.com with ESMTPSA id s16sm1306918lfp.197.2022.01.27.05.22.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 27 Jan 2022 05:22:59 -0800 (PST) From: Karolina Drobnik To: linux-mm@kvack.org Cc: akpm@linux-foundation.org, mike.rapoport@gmail.com, linux-kernel@vger.kernel.org, Karolina Drobnik Subject: [PATCH 13/16] memblock tests: Add memblock_reserve tests Date: Thu, 27 Jan 2022 14:21:31 +0100 Message-Id: <4603629b76f8caf68b4487b7a040461dc18e9723.1643206612.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: 85F5D120087 X-Stat-Signature: bub14ckaccfb3ttkn1zsk51k6z9od8mb X-Rspam-User: nil Authentication-Results: imf29.hostedemail.com; dkim=pass header.d=gmail.com header.s=20210112 header.b="jP/+ihSr"; spf=pass (imf29.hostedemail.com: domain of karolinadrobnik@gmail.com designates 209.85.167.43 as permitted sender) smtp.mailfrom=karolinadrobnik@gmail.com; dmarc=pass (policy=none) header.from=gmail.com X-HE-Tag: 1643289781-151882 Content-Transfer-Encoding: quoted-printable X-Bogosity: Ham, tests=bogofilter, spamicity=0.006588, 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