Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552// SPDX-License-Identifier: GPL-2.0-or-later#include "basic_api.h"#include <string.h>#include <linux/memblock.h>
#define EXPECTED_MEMBLOCK_REGIONS 128#define FUNC_ADD "memblock_add"#define FUNC_RESERVE "memblock_reserve"#define FUNC_REMOVE "memblock_remove"#define FUNC_FREE "memblock_free"#define FUNC_TRIM "memblock_trim_memory"
static int memblock_initialization_check(void){ PREFIX_PUSH();
ASSERT_NE(memblock.memory.regions, NULL); ASSERT_EQ(memblock.memory.cnt, 0); ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS); ASSERT_EQ(strcmp(memblock.memory.name, "memory"), 0);
ASSERT_NE(memblock.reserved.regions, NULL); ASSERT_EQ(memblock.reserved.cnt, 0); ASSERT_EQ(memblock.memory.max, EXPECTED_MEMBLOCK_REGIONS); ASSERT_EQ(strcmp(memblock.reserved.name, "reserved"), 0);
ASSERT_EQ(memblock.bottom_up, false); ASSERT_EQ(memblock.current_limit, MEMBLOCK_ALLOC_ANYWHERE);
test_pass_pop();
return 0;}
/* * A simple test that adds a memory block of a specified base address * and size to the collection of available memory regions (memblock.memory). * Expect to create a new entry. The region counter and total memory get * updated. */static int memblock_add_simple_check(void){ struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r = { .base = SZ_1G, .size = SZ_4M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r.base, r.size);
ASSERT_EQ(rgn->base, r.base); ASSERT_EQ(rgn->size, r.size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, r.size);
test_pass_pop();
return 0;}
/* * A simple test that adds a memory block of a specified base address, size, * NUMA node and memory flags to the collection of available memory regions. * Expect to create a new entry. The region counter and total memory get * updated. */static int memblock_add_node_simple_check(void){ struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r = { .base = SZ_1M, .size = SZ_16M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add_node(r.base, r.size, 1, MEMBLOCK_HOTPLUG);
ASSERT_EQ(rgn->base, r.base); ASSERT_EQ(rgn->size, r.size);#ifdef CONFIG_NUMA ASSERT_EQ(rgn->nid, 1);#endif ASSERT_EQ(rgn->flags, MEMBLOCK_HOTPLUG);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, r.size);
test_pass_pop();
return 0;}
/* * A test that tries to add two memory blocks that don't overlap with one * another: * * | +--------+ +--------+ | * | | r1 | | r2 | | * +--------+--------+--------+--------+--+ * * Expect to add two correctly initialized entries to the collection of * available memory regions (memblock.memory). The total size and * region counter fields get updated. */static int memblock_add_disjoint_check(void){ struct memblock_region *rgn1, *rgn2;
rgn1 = &memblock.memory.regions[0]; rgn2 = &memblock.memory.regions[1];
struct region r1 = { .base = SZ_1G, .size = SZ_8K }; struct region r2 = { .base = SZ_1G + SZ_16K, .size = SZ_8K };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, r1.size);
ASSERT_EQ(rgn2->base, r2.base); ASSERT_EQ(rgn2->size, r2.size);
ASSERT_EQ(memblock.memory.cnt, 2); ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
test_pass_pop();
return 0;}
/* * A test that tries to add two memory blocks r1 and r2, where r2 overlaps * with the beginning of r1 (that is r1.base < r2.base + r2.size): * * | +----+----+------------+ | * | | |r2 | r1 | | * +----+----+----+------------+----------+ * ^ ^ * | | * | r1.base * | * r2.base * * Expect to merge the two entries into one region that starts at r2.base * and has size of two regions minus their intersection. The total size of * the available memory is updated, and the region counter stays the same. */static int memblock_add_overlap_top_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_512M, .size = SZ_1G }; struct region r2 = { .base = SZ_256M, .size = SZ_512M };
PREFIX_PUSH();
total_size = (r1.base - r2.base) + r1.size;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size);
ASSERT_EQ(rgn->base, r2.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to add two memory blocks r1 and r2, where r2 overlaps * with the end of r1 (that is r2.base < r1.base + r1.size): * * | +--+------+----------+ | * | | | r1 | r2 | | * +--+--+------+----------+--------------+ * ^ ^ * | | * | r2.base * | * r1.base * * Expect to merge the two entries into one region that starts at r1.base * and has size of two regions minus their intersection. The total size of * the available memory is updated, and the region counter stays the same. */static int memblock_add_overlap_bottom_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_128M, .size = SZ_512M }; struct region r2 = { .base = SZ_256M, .size = SZ_1G };
PREFIX_PUSH();
total_size = (r2.base - r1.base) + r2.size;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to add two memory blocks r1 and r2, where r2 is * within the range of r1 (that is r1.base < r2.base && * r2.base + r2.size < r1.base + r1.size): * * | +-------+--+-----------------------+ * | | |r2| r1 | * +---+-------+--+-----------------------+ * ^ * | * r1.base * * Expect to merge two entries into one region that stays the same. * The counter and total size of available memory are not updated. */static int memblock_add_within_check(void){ struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_8M, .size = SZ_32M }; struct region r2 = { .base = SZ_16M, .size = SZ_1M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, r1.size);
test_pass_pop();
return 0;}
/* * A simple test that tries to add the same memory block twice. Expect * the counter and total size of available memory to not be updated. */static int memblock_add_twice_check(void){ struct region r = { .base = SZ_16K, .size = SZ_2M };
PREFIX_PUSH();
reset_memblock_regions();
memblock_add(r.base, r.size); memblock_add(r.base, r.size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, r.size);
test_pass_pop();
return 0;}
/* * A test that tries to add two memory blocks that don't overlap with one * another and then add a third memory block in the space between the first two: * * | +--------+--------+--------+ | * | | r1 | r3 | r2 | | * +--------+--------+--------+--------+--+ * * Expect to merge the three entries into one region that starts at r1.base * and has size of r1.size + r2.size + r3.size. The region counter and total * size of the available memory are updated. */static int memblock_add_between_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_1G, .size = SZ_8K }; struct region r2 = { .base = SZ_1G + SZ_16K, .size = SZ_8K }; struct region r3 = { .base = SZ_1G + SZ_8K, .size = SZ_8K };
PREFIX_PUSH();
total_size = r1.size + r2.size + r3.size;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size); memblock_add(r3.base, r3.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A simple test that tries to add a memory block r when r extends past * PHYS_ADDR_MAX: * * +--------+ * | r | * +--------+ * | +----+ * | | rgn| * +----------------------------+----+ * * Expect to add a memory block of size PHYS_ADDR_MAX - r.base. Expect the * total size of available memory and the counter to be updated. */static int memblock_add_near_max_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r = { .base = PHYS_ADDR_MAX - SZ_1M, .size = SZ_2M };
PREFIX_PUSH();
total_size = PHYS_ADDR_MAX - r.base;
reset_memblock_regions(); memblock_add(r.base, r.size);
ASSERT_EQ(rgn->base, r.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that trying to add the 129th memory block. * Expect to trigger memblock_double_array() to double the * memblock.memory.max, find a new valid memory as * memory.regions. */static int memblock_add_many_check(void){ int i; void *orig_region; struct region r = { .base = SZ_16K, .size = SZ_16K, }; phys_addr_t new_memory_regions_size; phys_addr_t base, size = SZ_64; phys_addr_t gap_size = SZ_64;
PREFIX_PUSH();
reset_memblock_regions(); memblock_allow_resize();
dummy_physical_memory_init(); /* * We allocated enough memory by using dummy_physical_memory_init(), and * split it into small block. First we split a large enough memory block * as the memory region which will be choosed by memblock_double_array(). */ base = PAGE_ALIGN(dummy_physical_memory_base()); new_memory_regions_size = PAGE_ALIGN(INIT_MEMBLOCK_REGIONS * 2 * sizeof(struct memblock_region)); memblock_add(base, new_memory_regions_size);
/* This is the base of small memory block. */ base += new_memory_regions_size + gap_size;
orig_region = memblock.memory.regions;
for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) { /* * Add these small block to fulfill the memblock. We keep a * gap between the nearby memory to avoid being merged. */ memblock_add(base, size); base += size + gap_size;
ASSERT_EQ(memblock.memory.cnt, i + 2); ASSERT_EQ(memblock.memory.total_size, new_memory_regions_size + (i + 1) * size); }
/* * At there, memblock_double_array() has been succeed, check if it * update the memory.max. */ ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2);
/* memblock_double_array() will reserve the memory it used. Check it. */ ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, new_memory_regions_size);
/* * Now memblock_double_array() works fine. Let's check after the * double_array(), the memblock_add() still works as normal. */ memblock_add(r.base, r.size); ASSERT_EQ(memblock.memory.regions[0].base, r.base); ASSERT_EQ(memblock.memory.regions[0].size, r.size);
ASSERT_EQ(memblock.memory.cnt, INIT_MEMBLOCK_REGIONS + 2); ASSERT_EQ(memblock.memory.total_size, INIT_MEMBLOCK_REGIONS * size + new_memory_regions_size + r.size); ASSERT_EQ(memblock.memory.max, INIT_MEMBLOCK_REGIONS * 2);
dummy_physical_memory_cleanup();
/* * The current memory.regions is occupying a range of memory that * allocated from dummy_physical_memory_init(). After free the memory, * we must not use it. So restore the origin memory region to make sure * the tests can run as normal and not affected by the double array. */ memblock.memory.regions = orig_region; memblock.memory.cnt = INIT_MEMBLOCK_REGIONS;
test_pass_pop();
return 0;}
static int memblock_add_checks(void){ prefix_reset(); prefix_push(FUNC_ADD); test_print("Running %s tests...\n", FUNC_ADD);
memblock_add_simple_check(); memblock_add_node_simple_check(); memblock_add_disjoint_check(); memblock_add_overlap_top_check(); memblock_add_overlap_bottom_check(); memblock_add_within_check(); memblock_add_twice_check(); memblock_add_between_check(); memblock_add_near_max_check(); memblock_add_many_check();
prefix_pop();
return 0;}
/* * A simple test that marks a memory block of a specified base address * and size as reserved and to the collection of reserved memory regions * (memblock.reserved). Expect to create a new entry. The region counter * and total memory size are updated. */static int memblock_reserve_simple_check(void){ struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r = { .base = SZ_2G, .size = SZ_128M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_reserve(r.base, r.size);
ASSERT_EQ(rgn->base, r.base); ASSERT_EQ(rgn->size, r.size);
test_pass_pop();
return 0;}
/* * A test that tries to mark two memory blocks that don't overlap as reserved: * * | +--+ +----------------+ | * | |r1| | r2 | | * +--------+--+------+----------------+--+ * * Expect to add two entries to the collection of reserved memory regions * (memblock.reserved). The total size and region counter for * memblock.reserved are updated. */static int memblock_reserve_disjoint_check(void){ struct memblock_region *rgn1, *rgn2;
rgn1 = &memblock.reserved.regions[0]; rgn2 = &memblock.reserved.regions[1];
struct region r1 = { .base = SZ_256M, .size = SZ_16M }; struct region r2 = { .base = SZ_512M, .size = SZ_512M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, r1.size);
ASSERT_EQ(rgn2->base, r2.base); ASSERT_EQ(rgn2->size, r2.size);
ASSERT_EQ(memblock.reserved.cnt, 2); ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
test_pass_pop();
return 0;}
/* * A test that tries to mark two memory blocks r1 and r2 as reserved, * where r2 overlaps with the beginning of r1 (that is * r1.base < r2.base + r2.size): * * | +--------------+--+--------------+ | * | | r2 | | r1 | | * +--+--------------+--+--------------+--+ * ^ ^ * | | * | r1.base * | * r2.base * * Expect to merge two entries into one region that starts at r2.base and * has size of two regions minus their intersection. The total size of the * reserved memory is updated, and the region counter is not updated. */static int memblock_reserve_overlap_top_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_1G, .size = SZ_1G }; struct region r2 = { .base = SZ_128M, .size = SZ_1G };
PREFIX_PUSH();
total_size = (r1.base - r2.base) + r1.size;
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size);
ASSERT_EQ(rgn->base, r2.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to mark two memory blocks r1 and r2 as reserved, * where r2 overlaps with the end of r1 (that is * r2.base < r1.base + r1.size): * * | +--------------+--+--------------+ | * | | r1 | | r2 | | * +--+--------------+--+--------------+--+ * ^ ^ * | | * | r2.base * | * r1.base * * Expect to merge two entries into one region that starts at r1.base and * has size of two regions minus their intersection. The total size of the * reserved memory is updated, and the region counter is not updated. */static int memblock_reserve_overlap_bottom_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_2K, .size = SZ_128K }; struct region r2 = { .base = SZ_128K, .size = SZ_128K };
PREFIX_PUSH();
total_size = (r2.base - r1.base) + r2.size;
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to mark two memory blocks r1 and r2 as reserved, * where r2 is within the range of r1 (that is * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)): * * | +-----+--+---------------------------| * | | |r2| r1 | * +-+-----+--+---------------------------+ * ^ ^ * | | * | r2.base * | * r1.base * * Expect to merge two entries into one region that stays the same. The * counter and total size of available memory are not updated. */static int memblock_reserve_within_check(void){ struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_1M, .size = SZ_8M }; struct region r2 = { .base = SZ_2M, .size = SZ_64K };
PREFIX_PUSH();
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, r1.size);
test_pass_pop();
return 0;}
/* * A simple test that tries to reserve the same memory block twice. * Expect the region counter and total size of reserved memory to not * be updated. */static int memblock_reserve_twice_check(void){ struct region r = { .base = SZ_16K, .size = SZ_2M };
PREFIX_PUSH();
reset_memblock_regions();
memblock_reserve(r.base, r.size); memblock_reserve(r.base, r.size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, r.size);
test_pass_pop();
return 0;}
/* * A test that tries to mark two memory blocks that don't overlap as reserved * and then reserve a third memory block in the space between the first two: * * | +--------+--------+--------+ | * | | r1 | r3 | r2 | | * +--------+--------+--------+--------+--+ * * Expect to merge the three entries into one reserved region that starts at * r1.base and has size of r1.size + r2.size + r3.size. The region counter and * total for memblock.reserved are updated. */static int memblock_reserve_between_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_1G, .size = SZ_8K }; struct region r2 = { .base = SZ_1G + SZ_16K, .size = SZ_8K }; struct region r3 = { .base = SZ_1G + SZ_8K, .size = SZ_8K };
PREFIX_PUSH();
total_size = r1.size + r2.size + r3.size;
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size); memblock_reserve(r3.base, r3.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A simple test that tries to reserve a memory block r when r extends past * PHYS_ADDR_MAX: * * +--------+ * | r | * +--------+ * | +----+ * | | rgn| * +----------------------------+----+ * * Expect to reserve a memory block of size PHYS_ADDR_MAX - r.base. Expect the * total size of reserved memory and the counter to be updated. */static int memblock_reserve_near_max_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r = { .base = PHYS_ADDR_MAX - SZ_1M, .size = SZ_2M };
PREFIX_PUSH();
total_size = PHYS_ADDR_MAX - r.base;
reset_memblock_regions(); memblock_reserve(r.base, r.size);
ASSERT_EQ(rgn->base, r.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that trying to reserve the 129th memory block. * Expect to trigger memblock_double_array() to double the * memblock.memory.max, find a new valid memory as * reserved.regions. */static int memblock_reserve_many_check(void){ int i; void *orig_region; struct region r = { .base = SZ_16K, .size = SZ_16K, }; phys_addr_t memory_base = SZ_128K; phys_addr_t new_reserved_regions_size;
PREFIX_PUSH();
reset_memblock_regions(); memblock_allow_resize();
/* Add a valid memory region used by double_array(). */ dummy_physical_memory_init(); memblock_add(dummy_physical_memory_base(), MEM_SIZE);
for (i = 0; i < INIT_MEMBLOCK_REGIONS; i++) { /* Reserve some fakes memory region to fulfill the memblock. */ memblock_reserve(memory_base, MEM_SIZE);
ASSERT_EQ(memblock.reserved.cnt, i + 1); ASSERT_EQ(memblock.reserved.total_size, (i + 1) * MEM_SIZE);
/* Keep the gap so these memory region will not be merged. */ memory_base += MEM_SIZE * 2; }
orig_region = memblock.reserved.regions;
/* This reserve the 129 memory_region, and makes it double array. */ memblock_reserve(memory_base, MEM_SIZE);
/* * This is the memory region size used by the doubled reserved.regions, * and it has been reserved due to it has been used. The size is used to * calculate the total_size that the memblock.reserved have now. */ new_reserved_regions_size = PAGE_ALIGN((INIT_MEMBLOCK_REGIONS * 2) * sizeof(struct memblock_region)); /* * The double_array() will find a free memory region as the new * reserved.regions, and the used memory region will be reserved, so * there will be one more region exist in the reserved memblock. And the * one more reserved region's size is new_reserved_regions_size. */ ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2); ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE + new_reserved_regions_size); ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
/* * Now memblock_double_array() works fine. Let's check after the * double_array(), the memblock_reserve() still works as normal. */ memblock_reserve(r.base, r.size); ASSERT_EQ(memblock.reserved.regions[0].base, r.base); ASSERT_EQ(memblock.reserved.regions[0].size, r.size);
ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3); ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE + new_reserved_regions_size + r.size); ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
dummy_physical_memory_cleanup();
/* * The current reserved.regions is occupying a range of memory that * allocated from dummy_physical_memory_init(). After free the memory, * we must not use it. So restore the origin memory region to make sure * the tests can run as normal and not affected by the double array. */ memblock.reserved.regions = orig_region; memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS;
test_pass_pop();
return 0;}
/* * A test that trying to reserve the 129th memory block at all locations. * Expect to trigger memblock_double_array() to double the * memblock.memory.max, find a new valid memory as reserved.regions. * * 0 1 2 128 * +-------+ +-------+ +-------+ +-------+ * | 32K | | 32K | | 32K | ... | 32K | * +-------+-------+-------+-------+-------+ +-------+ * |<-32K->| |<-32K->| * *//* Keep the gap so these memory region will not be merged. */#define MEMORY_BASE(idx) (SZ_128K + (MEM_SIZE * 2) * (idx))static int memblock_reserve_all_locations_check(void){ int i, skip; void *orig_region; struct region r = { .base = SZ_16K, .size = SZ_16K, }; phys_addr_t new_reserved_regions_size;
PREFIX_PUSH();
/* Reserve the 129th memory block for all possible positions*/ for (skip = 0; skip < INIT_MEMBLOCK_REGIONS + 1; skip++) { reset_memblock_regions(); memblock_allow_resize();
/* Add a valid memory region used by double_array(). */ dummy_physical_memory_init(); memblock_add(dummy_physical_memory_base(), MEM_SIZE);
for (i = 0; i < INIT_MEMBLOCK_REGIONS + 1; i++) { if (i == skip) continue;
/* Reserve some fakes memory region to fulfill the memblock. */ memblock_reserve(MEMORY_BASE(i), MEM_SIZE);
if (i < skip) { ASSERT_EQ(memblock.reserved.cnt, i + 1); ASSERT_EQ(memblock.reserved.total_size, (i + 1) * MEM_SIZE); } else { ASSERT_EQ(memblock.reserved.cnt, i); ASSERT_EQ(memblock.reserved.total_size, i * MEM_SIZE); } }
orig_region = memblock.reserved.regions;
/* This reserve the 129 memory_region, and makes it double array. */ memblock_reserve(MEMORY_BASE(skip), MEM_SIZE);
/* * This is the memory region size used by the doubled reserved.regions, * and it has been reserved due to it has been used. The size is used to * calculate the total_size that the memblock.reserved have now. */ new_reserved_regions_size = PAGE_ALIGN((INIT_MEMBLOCK_REGIONS * 2) * sizeof(struct memblock_region)); /* * The double_array() will find a free memory region as the new * reserved.regions, and the used memory region will be reserved, so * there will be one more region exist in the reserved memblock. And the * one more reserved region's size is new_reserved_regions_size. */ ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2); ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE + new_reserved_regions_size); ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
/* * Now memblock_double_array() works fine. Let's check after the * double_array(), the memblock_reserve() still works as normal. */ memblock_reserve(r.base, r.size); ASSERT_EQ(memblock.reserved.regions[0].base, r.base); ASSERT_EQ(memblock.reserved.regions[0].size, r.size);
ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3); ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE + new_reserved_regions_size + r.size); ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
dummy_physical_memory_cleanup();
/* * The current reserved.regions is occupying a range of memory that * allocated from dummy_physical_memory_init(). After free the memory, * we must not use it. So restore the origin memory region to make sure * the tests can run as normal and not affected by the double array. */ memblock.reserved.regions = orig_region; memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS; }
test_pass_pop();
return 0;}
/* * A test that trying to reserve the 129th memory block at all locations. * Expect to trigger memblock_double_array() to double the * memblock.memory.max, find a new valid memory as reserved.regions. And make * sure it doesn't conflict with the range we want to reserve. * * For example, we have 128 regions in reserved and now want to reserve * the skipped one. Since reserved is full, memblock_double_array() would find * an available range in memory for the new array. We intended to put two * ranges in memory with one is the exact range of the skipped one. Before * commit 48c3b583bbdd ("mm/memblock: fix overlapping allocation when doubling * reserved array"), the new array would sits in the skipped range which is a * conflict. The expected new array should be allocated from memory.regions[0]. * * 0 1 * memory +-------+ +-------+ * | 32K | | 32K | * +-------+ ------+-------+-------+-------+ * |<-32K->|<-32K->|<-32K->| * * 0 skipped 127 * reserved +-------+ ......... +-------+ * | 32K | . 32K . ... | 32K | * +-------+-------+-------+ +-------+ * |<-32K->| * ^ * | * | * skipped one *//* Keep the gap so these memory region will not be merged. */#define MEMORY_BASE_OFFSET(idx, offset) ((offset) + (MEM_SIZE * 2) * (idx))static int memblock_reserve_many_may_conflict_check(void){ int i, skip; void *orig_region; struct region r = { .base = SZ_16K, .size = SZ_16K, }; phys_addr_t new_reserved_regions_size;
/* * 0 1 129 * +---+ +---+ +---+ * |32K| |32K| .. |32K| * +---+ +---+ +---+ * * Pre-allocate the range for 129 memory block + one range for double * memblock.reserved.regions at idx 0. */ dummy_physical_memory_init(); phys_addr_t memory_base = dummy_physical_memory_base(); phys_addr_t offset = PAGE_ALIGN(memory_base);
PREFIX_PUSH();
/* Reserve the 129th memory block for all possible positions*/ for (skip = 1; skip <= INIT_MEMBLOCK_REGIONS + 1; skip++) { reset_memblock_regions(); memblock_allow_resize();
reset_memblock_attributes(); /* Add a valid memory region used by double_array(). */ memblock_add(MEMORY_BASE_OFFSET(0, offset), MEM_SIZE); /* * Add a memory region which will be reserved as 129th memory * region. This is not expected to be used by double_array(). */ memblock_add(MEMORY_BASE_OFFSET(skip, offset), MEM_SIZE);
for (i = 1; i <= INIT_MEMBLOCK_REGIONS + 1; i++) { if (i == skip) continue;
/* Reserve some fakes memory region to fulfill the memblock. */ memblock_reserve(MEMORY_BASE_OFFSET(i, offset), MEM_SIZE);
if (i < skip) { ASSERT_EQ(memblock.reserved.cnt, i); ASSERT_EQ(memblock.reserved.total_size, i * MEM_SIZE); } else { ASSERT_EQ(memblock.reserved.cnt, i - 1); ASSERT_EQ(memblock.reserved.total_size, (i - 1) * MEM_SIZE); } }
orig_region = memblock.reserved.regions;
/* This reserve the 129 memory_region, and makes it double array. */ memblock_reserve(MEMORY_BASE_OFFSET(skip, offset), MEM_SIZE);
/* * This is the memory region size used by the doubled reserved.regions, * and it has been reserved due to it has been used. The size is used to * calculate the total_size that the memblock.reserved have now. */ new_reserved_regions_size = PAGE_ALIGN((INIT_MEMBLOCK_REGIONS * 2) * sizeof(struct memblock_region)); /* * The double_array() will find a free memory region as the new * reserved.regions, and the used memory region will be reserved, so * there will be one more region exist in the reserved memblock. And the * one more reserved region's size is new_reserved_regions_size. */ ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 2); ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE + new_reserved_regions_size); ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
/* * The first reserved region is allocated for double array * with the size of new_reserved_regions_size and the base to be * MEMORY_BASE_OFFSET(0, offset) + SZ_32K - new_reserved_regions_size */ ASSERT_EQ(memblock.reserved.regions[0].base + memblock.reserved.regions[0].size, MEMORY_BASE_OFFSET(0, offset) + SZ_32K); ASSERT_EQ(memblock.reserved.regions[0].size, new_reserved_regions_size);
/* * Now memblock_double_array() works fine. Let's check after the * double_array(), the memblock_reserve() still works as normal. */ memblock_reserve(r.base, r.size); ASSERT_EQ(memblock.reserved.regions[0].base, r.base); ASSERT_EQ(memblock.reserved.regions[0].size, r.size);
ASSERT_EQ(memblock.reserved.cnt, INIT_MEMBLOCK_REGIONS + 3); ASSERT_EQ(memblock.reserved.total_size, (INIT_MEMBLOCK_REGIONS + 1) * MEM_SIZE + new_reserved_regions_size + r.size); ASSERT_EQ(memblock.reserved.max, INIT_MEMBLOCK_REGIONS * 2);
/* * The current reserved.regions is occupying a range of memory that * allocated from dummy_physical_memory_init(). After free the memory, * we must not use it. So restore the origin memory region to make sure * the tests can run as normal and not affected by the double array. */ memblock.reserved.regions = orig_region; memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS; }
dummy_physical_memory_cleanup();
test_pass_pop();
return 0;}
static int memblock_reserve_checks(void){ prefix_reset(); prefix_push(FUNC_RESERVE); test_print("Running %s tests...\n", FUNC_RESERVE);
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(); memblock_reserve_between_check(); memblock_reserve_near_max_check(); memblock_reserve_many_check(); memblock_reserve_all_locations_check(); memblock_reserve_many_may_conflict_check();
prefix_pop();
return 0;}
/* * A simple test that tries to remove a region r1 from the array of * available memory regions. By "removing" a region we mean overwriting it * with the next region r2 in memblock.memory: * * | ...... +----------------+ | * | : r1 : | r2 | | * +--+----+----------+----------------+--+ * ^ * | * rgn.base * * Expect to add two memory blocks r1 and r2 and then remove r1 so that * r2 is the first available region. The region counter and total size * are updated. */static int memblock_remove_simple_check(void){ struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_2K, .size = SZ_4K }; struct region r2 = { .base = SZ_128K, .size = SZ_4M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size); memblock_remove(r1.base, r1.size);
ASSERT_EQ(rgn->base, r2.base); ASSERT_EQ(rgn->size, r2.size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, r2.size);
test_pass_pop();
return 0;}
/* * A test that tries to remove a region r2 that was not registered as * available memory (i.e. has no corresponding entry in memblock.memory): * * +----------------+ * | r2 | * +----------------+ * | +----+ | * | | r1 | | * +--+----+------------------------------+ * ^ * | * rgn.base * * Expect the array, regions counter and total size to not be modified. */static int memblock_remove_absent_check(void){ struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_512K, .size = SZ_4M }; struct region r2 = { .base = SZ_64M, .size = SZ_1G };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, r1.size);
test_pass_pop();
return 0;}
/* * A test that tries to remove a region r2 that overlaps with the * beginning of the already existing entry r1 * (that is r1.base < r2.base + r2.size): * * +-----------------+ * | r2 | * +-----------------+ * | .........+--------+ | * | : r1 | rgn | | * +-----------------+--------+--------+--+ * ^ ^ * | | * | rgn.base * r1.base * * Expect that only the intersection of both regions is removed from the * available memory pool. The regions counter and total size are updated. */static int memblock_remove_overlap_top_check(void){ struct memblock_region *rgn; phys_addr_t r1_end, r2_end, total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_32M, .size = SZ_32M }; struct region r2 = { .base = SZ_16M, .size = SZ_32M };
PREFIX_PUSH();
r1_end = r1.base + r1.size; r2_end = r2.base + r2.size; total_size = r1_end - r2_end;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base + r2.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to remove a region r2 that overlaps with the end of * the already existing region r1 (that is r2.base < r1.base + r1.size): * * +--------------------------------+ * | r2 | * +--------------------------------+ * | +---+..... | * | |rgn| r1 : | * +-+---+----+---------------------------+ * ^ * | * r1.base * * Expect that only the intersection of both regions is removed from the * available memory pool. The regions counter and total size are updated. */static int memblock_remove_overlap_bottom_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_2M, .size = SZ_64M }; struct region r2 = { .base = SZ_32M, .size = SZ_256M };
PREFIX_PUSH();
total_size = r2.base - r1.base;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to remove a region r2 that is within the range of * the already existing entry r1 (that is * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)): * * +----+ * | r2 | * +----+ * | +-------------+....+---------------+ | * | | rgn1 | r1 | rgn2 | | * +-+-------------+----+---------------+-+ * ^ * | * r1.base * * Expect that the region is split into two - one that ends at r2.base and * another that starts at r2.base + r2.size, with appropriate sizes. The * region counter and total size are updated. */static int memblock_remove_within_check(void){ struct memblock_region *rgn1, *rgn2; phys_addr_t r1_size, r2_size, total_size;
rgn1 = &memblock.memory.regions[0]; rgn2 = &memblock.memory.regions[1];
struct region r1 = { .base = SZ_1M, .size = SZ_32M }; struct region r2 = { .base = SZ_16M, .size = SZ_1M };
PREFIX_PUSH();
r1_size = r2.base - r1.base; r2_size = (r1.base + r1.size) - (r2.base + r2.size); total_size = r1_size + r2_size;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, r1_size);
ASSERT_EQ(rgn2->base, r2.base + r2.size); ASSERT_EQ(rgn2->size, r2_size);
ASSERT_EQ(memblock.memory.cnt, 2); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A simple test that tries to remove a region r1 from the array of * available memory regions when r1 is the only available region. * Expect to add a memory block r1 and then remove r1 so that a dummy * region is added. The region counter stays the same, and the total size * is updated. */static int memblock_remove_only_region_check(void){ struct memblock_region *rgn;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = SZ_2K, .size = SZ_4K };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_remove(r1.base, r1.size);
ASSERT_EQ(rgn->base, 0); ASSERT_EQ(rgn->size, 0);
ASSERT_EQ(memblock.memory.cnt, 0); ASSERT_EQ(memblock.memory.total_size, 0);
test_pass_pop();
return 0;}
/* * A simple test that tries remove a region r2 from the array of available * memory regions when r2 extends past PHYS_ADDR_MAX: * * +--------+ * | r2 | * +--------+ * | +---+....+ * | |rgn| | * +------------------------+---+----+ * * Expect that only the portion between PHYS_ADDR_MAX and r2.base is removed. * Expect the total size of available memory to be updated and the counter to * not be updated. */static int memblock_remove_near_max_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = PHYS_ADDR_MAX - SZ_2M, .size = SZ_2M };
struct region r2 = { .base = PHYS_ADDR_MAX - SZ_1M, .size = SZ_2M };
PREFIX_PUSH();
total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_remove(r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.memory.cnt, 1); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to remove a region r3 that overlaps with two existing * regions r1 and r2: * * +----------------+ * | r3 | * +----------------+ * | +----+..... ........+--------+ * | | |r1 : : |r2 | | * +----+----+----+---+-------+--------+-----+ * * Expect that only the intersections of r1 with r3 and r2 with r3 are removed * from the available memory pool. Expect the total size of available memory to * be updated and the counter to not be updated. */static int memblock_remove_overlap_two_check(void){ struct memblock_region *rgn1, *rgn2; phys_addr_t new_r1_size, new_r2_size, r2_end, r3_end, total_size;
rgn1 = &memblock.memory.regions[0]; rgn2 = &memblock.memory.regions[1];
struct region r1 = { .base = SZ_16M, .size = SZ_32M }; struct region r2 = { .base = SZ_64M, .size = SZ_64M }; struct region r3 = { .base = SZ_32M, .size = SZ_64M };
PREFIX_PUSH();
r2_end = r2.base + r2.size; r3_end = r3.base + r3.size; new_r1_size = r3.base - r1.base; new_r2_size = r2_end - r3_end; total_size = new_r1_size + new_r2_size;
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size); memblock_remove(r3.base, r3.size);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, new_r1_size);
ASSERT_EQ(rgn2->base, r3_end); ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.memory.cnt, 2); ASSERT_EQ(memblock.memory.total_size, total_size);
test_pass_pop();
return 0;}
static int memblock_remove_checks(void){ prefix_reset(); prefix_push(FUNC_REMOVE); test_print("Running %s tests...\n", FUNC_REMOVE);
memblock_remove_simple_check(); memblock_remove_absent_check(); memblock_remove_overlap_top_check(); memblock_remove_overlap_bottom_check(); memblock_remove_within_check(); memblock_remove_only_region_check(); memblock_remove_near_max_check(); memblock_remove_overlap_two_check();
prefix_pop();
return 0;}
/* * A simple test that tries to free a memory block r1 that was marked * earlier as reserved. By "freeing" a region we mean overwriting it with * the next entry r2 in memblock.reserved: * * | ...... +----+ | * | : r1 : | r2 | | * +--------------+----+-----------+----+-+ * ^ * | * rgn.base * * Expect to reserve two memory regions and then erase r1 region with the * value of r2. The region counter and total size are updated. */static int memblock_free_simple_check(void){ struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_4M, .size = SZ_1M }; struct region r2 = { .base = SZ_8M, .size = SZ_1M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size); memblock_free((void *)r1.base, r1.size);
ASSERT_EQ(rgn->base, r2.base); ASSERT_EQ(rgn->size, r2.size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, r2.size);
test_pass_pop();
return 0;}
/* * A test that tries to free a region r2 that was not marked as reserved * (i.e. has no corresponding entry in memblock.reserved): * * +----------------+ * | r2 | * +----------------+ * | +----+ | * | | r1 | | * +--+----+------------------------------+ * ^ * | * rgn.base * * The array, regions counter and total size are not modified. */static int memblock_free_absent_check(void){ struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_2M, .size = SZ_8K }; struct region r2 = { .base = SZ_16M, .size = SZ_128M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, r1.size);
test_pass_pop();
return 0;}
/* * A test that tries to free a region r2 that overlaps with the beginning * of the already existing entry r1 (that is r1.base < r2.base + r2.size): * * +----+ * | r2 | * +----+ * | ...+--------------+ | * | : | r1 | | * +----+--+--------------+---------------+ * ^ ^ * | | * | rgn.base * | * r1.base * * Expect that only the intersection of both regions is freed. The * regions counter and total size are updated. */static int memblock_free_overlap_top_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_8M, .size = SZ_32M }; struct region r2 = { .base = SZ_1M, .size = SZ_8M };
PREFIX_PUSH();
total_size = (r1.size + r1.base) - (r2.base + r2.size);
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r2.base + r2.size); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to free a region r2 that overlaps with the end of * the already existing entry r1 (that is r2.base < r1.base + r1.size): * * +----------------+ * | r2 | * +----------------+ * | +-----------+..... | * | | r1 | : | * +----+-----------+----+----------------+ * * Expect that only the intersection of both regions is freed. The * regions counter and total size are updated. */static int memblock_free_overlap_bottom_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_8M, .size = SZ_32M }; struct region r2 = { .base = SZ_32M, .size = SZ_32M };
PREFIX_PUSH();
total_size = r2.base - r1.base;
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to free a region r2 that is within the range of the * already existing entry r1 (that is * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)): * * +----+ * | r2 | * +----+ * | +------------+....+---------------+ * | | rgn1 | r1 | rgn2 | * +----+------------+----+---------------+ * ^ * | * r1.base * * Expect that the region is split into two - one that ends at r2.base and * another that starts at r2.base + r2.size, with appropriate sizes. The * region counter and total size fields are updated. */static int memblock_free_within_check(void){ struct memblock_region *rgn1, *rgn2; phys_addr_t r1_size, r2_size, total_size;
rgn1 = &memblock.reserved.regions[0]; rgn2 = &memblock.reserved.regions[1];
struct region r1 = { .base = SZ_1M, .size = SZ_8M }; struct region r2 = { .base = SZ_4M, .size = SZ_1M };
PREFIX_PUSH();
r1_size = r2.base - r1.base; r2_size = (r1.base + r1.size) - (r2.base + r2.size); total_size = r1_size + r2_size;
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, r1_size);
ASSERT_EQ(rgn2->base, r2.base + r2.size); ASSERT_EQ(rgn2->size, r2_size);
ASSERT_EQ(memblock.reserved.cnt, 2); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A simple test that tries to free a memory block r1 that was marked * earlier as reserved when r1 is the only available region. * Expect to reserve a memory block r1 and then free r1 so that r1 is * overwritten with a dummy region. The region counter stays the same, * and the total size is updated. */static int memblock_free_only_region_check(void){ struct memblock_region *rgn;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = SZ_2K, .size = SZ_4K };
PREFIX_PUSH();
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_free((void *)r1.base, r1.size);
ASSERT_EQ(rgn->base, 0); ASSERT_EQ(rgn->size, 0);
ASSERT_EQ(memblock.reserved.cnt, 0); ASSERT_EQ(memblock.reserved.total_size, 0);
test_pass_pop();
return 0;}
/* * A simple test that tries free a region r2 when r2 extends past PHYS_ADDR_MAX: * * +--------+ * | r2 | * +--------+ * | +---+....+ * | |rgn| | * +------------------------+---+----+ * * Expect that only the portion between PHYS_ADDR_MAX and r2.base is freed. * Expect the total size of reserved memory to be updated and the counter to * not be updated. */static int memblock_free_near_max_check(void){ struct memblock_region *rgn; phys_addr_t total_size;
rgn = &memblock.reserved.regions[0];
struct region r1 = { .base = PHYS_ADDR_MAX - SZ_2M, .size = SZ_2M };
struct region r2 = { .base = PHYS_ADDR_MAX - SZ_1M, .size = SZ_2M };
PREFIX_PUSH();
total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_free((void *)r2.base, r2.size);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, total_size);
ASSERT_EQ(memblock.reserved.cnt, 1); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
/* * A test that tries to free a reserved region r3 that overlaps with two * existing reserved regions r1 and r2: * * +----------------+ * | r3 | * +----------------+ * | +----+..... ........+--------+ * | | |r1 : : |r2 | | * +----+----+----+---+-------+--------+-----+ * * Expect that only the intersections of r1 with r3 and r2 with r3 are freed * from the collection of reserved memory. Expect the total size of reserved * memory to be updated and the counter to not be updated. */static int memblock_free_overlap_two_check(void){ struct memblock_region *rgn1, *rgn2; phys_addr_t new_r1_size, new_r2_size, r2_end, r3_end, total_size;
rgn1 = &memblock.reserved.regions[0]; rgn2 = &memblock.reserved.regions[1];
struct region r1 = { .base = SZ_16M, .size = SZ_32M }; struct region r2 = { .base = SZ_64M, .size = SZ_64M }; struct region r3 = { .base = SZ_32M, .size = SZ_64M };
PREFIX_PUSH();
r2_end = r2.base + r2.size; r3_end = r3.base + r3.size; new_r1_size = r3.base - r1.base; new_r2_size = r2_end - r3_end; total_size = new_r1_size + new_r2_size;
reset_memblock_regions(); memblock_reserve(r1.base, r1.size); memblock_reserve(r2.base, r2.size); memblock_free((void *)r3.base, r3.size);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, new_r1_size);
ASSERT_EQ(rgn2->base, r3_end); ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.reserved.cnt, 2); ASSERT_EQ(memblock.reserved.total_size, total_size);
test_pass_pop();
return 0;}
static int memblock_free_checks(void){ prefix_reset(); prefix_push(FUNC_FREE); test_print("Running %s tests...\n", FUNC_FREE);
memblock_free_simple_check(); memblock_free_absent_check(); memblock_free_overlap_top_check(); memblock_free_overlap_bottom_check(); memblock_free_within_check(); memblock_free_only_region_check(); memblock_free_near_max_check(); memblock_free_overlap_two_check();
prefix_pop();
return 0;}
static int memblock_set_bottom_up_check(void){ prefix_push("memblock_set_bottom_up");
memblock_set_bottom_up(false); ASSERT_EQ(memblock.bottom_up, false); memblock_set_bottom_up(true); ASSERT_EQ(memblock.bottom_up, true);
reset_memblock_attributes(); test_pass_pop();
return 0;}
static int memblock_bottom_up_check(void){ prefix_push("memblock_bottom_up");
memblock_set_bottom_up(false); ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up); ASSERT_EQ(memblock_bottom_up(), false); memblock_set_bottom_up(true); ASSERT_EQ(memblock_bottom_up(), memblock.bottom_up); ASSERT_EQ(memblock_bottom_up(), true);
reset_memblock_attributes(); test_pass_pop();
return 0;}
static int memblock_bottom_up_checks(void){ test_print("Running memblock_*bottom_up tests...\n");
prefix_reset(); memblock_set_bottom_up_check(); prefix_reset(); memblock_bottom_up_check();
return 0;}
/* * A test that tries to trim memory when both ends of the memory region are * aligned. Expect that the memory will not be trimmed. Expect the counter to * not be updated. */static int memblock_trim_memory_aligned_check(void){ struct memblock_region *rgn; const phys_addr_t alignment = SMP_CACHE_BYTES;
rgn = &memblock.memory.regions[0];
struct region r = { .base = alignment, .size = alignment * 4 };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r.base, r.size); memblock_trim_memory(alignment);
ASSERT_EQ(rgn->base, r.base); ASSERT_EQ(rgn->size, r.size);
ASSERT_EQ(memblock.memory.cnt, 1);
test_pass_pop();
return 0;}
/* * A test that tries to trim memory when there are two available regions, r1 and * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end * and smaller than the alignment: * * alignment * |--------| * | +-----------------+ +------+ | * | | r1 | | r2 | | * +--------+-----------------+--------+------+---+ * ^ ^ ^ ^ ^ * |________|________|________| | * | Unaligned address * Aligned addresses * * Expect that r1 will not be trimmed and r2 will be removed. Expect the * counter to be updated. */static int memblock_trim_memory_too_small_check(void){ struct memblock_region *rgn; const phys_addr_t alignment = SMP_CACHE_BYTES;
rgn = &memblock.memory.regions[0];
struct region r1 = { .base = alignment, .size = alignment * 2 }; struct region r2 = { .base = alignment * 4, .size = alignment - SZ_2 };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size); memblock_trim_memory(alignment);
ASSERT_EQ(rgn->base, r1.base); ASSERT_EQ(rgn->size, r1.size);
ASSERT_EQ(memblock.memory.cnt, 1);
test_pass_pop();
return 0;}
/* * A test that tries to trim memory when there are two available regions, r1 and * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base * and aligned at the end: * * Unaligned address * | * v * | +-----------------+ +---------------+ | * | | r1 | | r2 | | * +--------+-----------------+----------+---------------+---+ * ^ ^ ^ ^ ^ ^ * |________|________|________|________|________| * | * Aligned addresses * * Expect that r1 will not be trimmed and r2 will be trimmed at the base. * Expect the counter to not be updated. */static int memblock_trim_memory_unaligned_base_check(void){ struct memblock_region *rgn1, *rgn2; const phys_addr_t alignment = SMP_CACHE_BYTES; phys_addr_t offset = SZ_2; phys_addr_t new_r2_base, new_r2_size;
rgn1 = &memblock.memory.regions[0]; rgn2 = &memblock.memory.regions[1];
struct region r1 = { .base = alignment, .size = alignment * 2 }; struct region r2 = { .base = alignment * 4 + offset, .size = alignment * 2 - offset };
PREFIX_PUSH();
new_r2_base = r2.base + (alignment - offset); new_r2_size = r2.size - (alignment - offset);
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size); memblock_trim_memory(alignment);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, r1.size);
ASSERT_EQ(rgn2->base, new_r2_base); ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.memory.cnt, 2);
test_pass_pop();
return 0;}
/* * A test that tries to trim memory when there are two available regions, r1 and * r2. Region r1 is aligned on both ends and region r2 is aligned at the base * and unaligned at the end: * * Unaligned address * | * v * | +-----------------+ +---------------+ | * | | r1 | | r2 | | * +--------+-----------------+--------+---------------+---+ * ^ ^ ^ ^ ^ ^ * |________|________|________|________|________| * | * Aligned addresses * * Expect that r1 will not be trimmed and r2 will be trimmed at the end. * Expect the counter to not be updated. */static int memblock_trim_memory_unaligned_end_check(void){ struct memblock_region *rgn1, *rgn2; const phys_addr_t alignment = SMP_CACHE_BYTES; phys_addr_t offset = SZ_2; phys_addr_t new_r2_size;
rgn1 = &memblock.memory.regions[0]; rgn2 = &memblock.memory.regions[1];
struct region r1 = { .base = alignment, .size = alignment * 2 }; struct region r2 = { .base = alignment * 4, .size = alignment * 2 - offset };
PREFIX_PUSH();
new_r2_size = r2.size - (alignment - offset);
reset_memblock_regions(); memblock_add(r1.base, r1.size); memblock_add(r2.base, r2.size); memblock_trim_memory(alignment);
ASSERT_EQ(rgn1->base, r1.base); ASSERT_EQ(rgn1->size, r1.size);
ASSERT_EQ(rgn2->base, r2.base); ASSERT_EQ(rgn2->size, new_r2_size);
ASSERT_EQ(memblock.memory.cnt, 2);
test_pass_pop();
return 0;}
static int memblock_trim_memory_checks(void){ prefix_reset(); prefix_push(FUNC_TRIM); test_print("Running %s tests...\n", FUNC_TRIM);
memblock_trim_memory_aligned_check(); memblock_trim_memory_too_small_check(); memblock_trim_memory_unaligned_base_check(); memblock_trim_memory_unaligned_end_check();
prefix_pop();
return 0;}
static int memblock_overlaps_region_check(void){ struct region r = { .base = SZ_1G, .size = SZ_4M };
PREFIX_PUSH();
reset_memblock_regions(); memblock_add(r.base, r.size);
/* Far Away */ ASSERT_FALSE(memblock_overlaps_region(&memblock.memory, SZ_1M, SZ_1M)); ASSERT_FALSE(memblock_overlaps_region(&memblock.memory, SZ_2G, SZ_1M));
/* Neighbor */ ASSERT_FALSE(memblock_overlaps_region(&memblock.memory, SZ_1G - SZ_1M, SZ_1M)); ASSERT_FALSE(memblock_overlaps_region(&memblock.memory, SZ_1G + SZ_4M, SZ_1M));
/* Partial Overlap */ ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G - SZ_1M, SZ_2M)); ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G + SZ_2M, SZ_2M));
/* Totally Overlap */ ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G, SZ_4M)); ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G - SZ_2M, SZ_8M)); ASSERT_TRUE(memblock_overlaps_region(&memblock.memory, SZ_1G + SZ_1M, SZ_1M));
test_pass_pop();
return 0;}
static int memblock_overlaps_region_checks(void){ prefix_reset(); prefix_push("memblock_overlaps_region"); test_print("Running memblock_overlaps_region tests...\n");
memblock_overlaps_region_check();
prefix_pop();
return 0;}
#ifdef CONFIG_NUMAstatic int memblock_set_node_check(void){ unsigned long i, max_reserved; struct memblock_region *rgn; void *orig_region;
PREFIX_PUSH();
reset_memblock_regions(); memblock_allow_resize();
dummy_physical_memory_init(); memblock_add(dummy_physical_memory_base(), MEM_SIZE); orig_region = memblock.reserved.regions;
/* Equally Split range to node 0 and 1*/ memblock_set_node(memblock_start_of_DRAM(), memblock_phys_mem_size() / 2, &memblock.memory, 0); memblock_set_node(memblock_start_of_DRAM() + memblock_phys_mem_size() / 2, memblock_phys_mem_size() / 2, &memblock.memory, 1);
ASSERT_EQ(memblock.memory.cnt, 2); rgn = &memblock.memory.regions[0]; ASSERT_EQ(rgn->base, memblock_start_of_DRAM()); ASSERT_EQ(rgn->size, memblock_phys_mem_size() / 2); ASSERT_EQ(memblock_get_region_node(rgn), 0); rgn = &memblock.memory.regions[1]; ASSERT_EQ(rgn->base, memblock_start_of_DRAM() + memblock_phys_mem_size() / 2); ASSERT_EQ(rgn->size, memblock_phys_mem_size() / 2); ASSERT_EQ(memblock_get_region_node(rgn), 1);
/* Reserve 126 regions with the last one across node boundary */ for (i = 0; i < 125; i++) memblock_reserve(memblock_start_of_DRAM() + SZ_16 * i, SZ_8);
memblock_reserve(memblock_start_of_DRAM() + memblock_phys_mem_size() / 2 - SZ_8, SZ_16);
/* * Commit 61167ad5fecd ("mm: pass nid to reserve_bootmem_region()") * do following process to set nid to each memblock.reserved region. * But it may miss some region if memblock_set_node() double the * array. * * By checking 'max', we make sure all region nid is set properly. */repeat: max_reserved = memblock.reserved.max; for_each_mem_region(rgn) { int nid = memblock_get_region_node(rgn);
memblock_set_node(rgn->base, rgn->size, &memblock.reserved, nid); } if (max_reserved != memblock.reserved.max) goto repeat;
/* Confirm each region has valid node set */ for_each_reserved_mem_region(rgn) { ASSERT_TRUE(numa_valid_node(memblock_get_region_node(rgn))); if (rgn == (memblock.reserved.regions + memblock.reserved.cnt - 1)) ASSERT_EQ(1, memblock_get_region_node(rgn)); else ASSERT_EQ(0, memblock_get_region_node(rgn)); }
dummy_physical_memory_cleanup();
/* * The current reserved.regions is occupying a range of memory that * allocated from dummy_physical_memory_init(). After free the memory, * we must not use it. So restore the origin memory region to make sure * the tests can run as normal and not affected by the double array. */ memblock.reserved.regions = orig_region; memblock.reserved.cnt = INIT_MEMBLOCK_RESERVED_REGIONS;
test_pass_pop();
return 0;}
static int memblock_set_node_checks(void){ prefix_reset(); prefix_push("memblock_set_node"); test_print("Running memblock_set_node tests...\n");
memblock_set_node_check();
prefix_pop();
return 0;}#elsestatic int memblock_set_node_checks(void){ return 0;}#endif
int memblock_basic_checks(void){ memblock_initialization_check(); memblock_add_checks(); memblock_reserve_checks(); memblock_remove_checks(); memblock_free_checks(); memblock_bottom_up_checks(); memblock_trim_memory_checks(); memblock_overlaps_region_checks(); memblock_set_node_checks();
return 0;}