Skip to content

Commit 4151477

Browse files
ChiaHungDuanChiaHungDuan
committed
[scudo] Switch to use MemMap in tests
Reviewed By: cferris Differential Revision: https://reviews.llvm.org/D146570
1 parent 0923963 commit 4151477

File tree

4 files changed

+72
-52
lines changed

4 files changed

+72
-52
lines changed

‎compiler-rt/lib/scudo/standalone/tests/combined_test.cpp‎

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -12,6 +12,7 @@
1212
#include "allocator_config.h"
1313
#include "chunk.h"
1414
#include "combined.h"
15+
#include "mem_map.h"
1516

1617
#include <condition_variable>
1718
#include <memory>
@@ -495,11 +496,12 @@ SCUDO_TYPED_TEST(ScudoCombinedTest, ThreadedCombined) {
495496
// process's signal handlers (GWP-ASan used to do this).
496497
TEST(ScudoCombinedDeathTest, SKIP_ON_FUCHSIA(testSEGV)) {
497498
const scudo::uptr Size = 4 * scudo::getPageSizeCached();
498-
scudo::MapPlatformData Data = {};
499-
void *P = scudo::map(nullptr, Size, "testSEGV", MAP_NOACCESS, &Data);
500-
EXPECT_NE(P, nullptr);
499+
scudo::ReservedMemoryT ReservedMemory;
500+
ASSERT_TRUE(ReservedMemory.create(/*Addr=*/0U, Size, "testSEGV"));
501+
void *P = reinterpret_cast<void *>(ReservedMemory.getBase());
502+
ASSERT_NE(P, nullptr);
501503
EXPECT_DEATH(memset(P, 0xaa, Size), "");
502-
scudo::unmap(P, Size, UNMAP_ALL, &Data);
504+
ReservedMemory.release();
503505
}
504506

505507
struct DeathSizeClassConfig {

‎compiler-rt/lib/scudo/standalone/tests/common_test.cpp‎

Lines changed: 12 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
#include "tests/scudo_unit_test.h"
1111

1212
#include "common.h"
13+
#include "mem_map.h"
1314
#include <algorithm>
1415
#include <fstream>
1516

@@ -34,39 +35,39 @@ TEST(ScudoCommonTest, SKIP_ON_FUCHSIA(ResidentMemorySize)) {
3435
const uptr Size = 1ull << 30;
3536
const uptr Threshold = Size >> 3;
3637

37-
MapPlatformData Data = {};
38-
void *P = map(nullptr, Size, "ResidentMemorySize", 0, &Data);
39-
ASSERT_NE(nullptr, P);
38+
MemMapT MemMap;
39+
ASSERT_TRUE(MemMap.map(/*Addr=*/0U, Size, "ResidentMemorySize"));
40+
void *P = reinterpret_cast<void *>(MemMap.getBase());
4041
EXPECT_LT(getResidentMemorySize(), OnStart + Threshold);
4142

4243
memset(P, 1, Size);
4344
EXPECT_GT(getResidentMemorySize(), OnStart + Size - Threshold);
4445

45-
releasePagesToOS((uptr)P, 0, Size, &Data);
46+
MemMap.releasePagesToOS(MemMap.getBase(), Size);
4647
EXPECT_LT(getResidentMemorySize(), OnStart + Threshold);
4748

4849
memset(P, 1, Size);
4950
EXPECT_GT(getResidentMemorySize(), OnStart + Size - Threshold);
5051

51-
unmap(P, Size, 0, &Data);
52+
MemMap.unmap(MemMap.getBase(), Size);
5253
}
5354

5455
TEST(ScudoCommonTest, Zeros) {
5556
const uptr Size = 1ull << 20;
5657

57-
MapPlatformData Data = {};
58-
uptr *P = reinterpret_cast<uptr *>(map(nullptr, Size, "Zeros", 0, &Data));
59-
const ptrdiff_t N = Size / sizeof(*P);
60-
ASSERT_NE(nullptr, P);
58+
MemMapT MemMap;
59+
ASSERT_TRUE(MemMap.map(/*Addr=*/0U, Size, "Zeros"));
60+
uptr *P = reinterpret_cast<uptr *>(MemMap.getBase());
61+
const ptrdiff_t N = Size / sizeof(uptr);
6162
EXPECT_EQ(std::count(P, P + N, 0), N);
6263

6364
memset(P, 1, Size);
6465
EXPECT_EQ(std::count(P, P + N, 0), 0);
6566

66-
releasePagesToOS((uptr)P, 0, Size, &Data);
67+
MemMap.releasePagesToOS(MemMap.getBase(), Size);
6768
EXPECT_EQ(std::count(P, P + N, 0), N);
6869

69-
unmap(P, Size, 0, &Data);
70+
MemMap.unmap(MemMap.getBase(), Size);
7071
}
7172

7273
#if 0

‎compiler-rt/lib/scudo/standalone/tests/map_test.cpp‎

Lines changed: 43 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,7 @@
99
#include "tests/scudo_unit_test.h"
1010

1111
#include "common.h"
12+
#include "mem_map.h"
1213

1314
#include <string.h>
1415
#include <unistd.h>
@@ -22,11 +23,15 @@ TEST(ScudoMapTest, PageSize) {
2223

2324
TEST(ScudoMapDeathTest, MapNoAccessUnmap) {
2425
const scudo::uptr Size = 4 * scudo::getPageSizeCached();
25-
scudo::MapPlatformData Data = {};
26-
void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &Data);
27-
EXPECT_NE(P, nullptr);
28-
EXPECT_DEATH(memset(P, 0xaa, Size), "");
29-
scudo::unmap(P, Size, UNMAP_ALL, &Data);
26+
scudo::ReservedMemoryT ReservedMemory;
27+
28+
ASSERT_TRUE(ReservedMemory.create(/*Addr=*/0U, Size, MappingName));
29+
EXPECT_NE(ReservedMemory.getBase(), 0U);
30+
EXPECT_DEATH(
31+
memset(reinterpret_cast<void *>(ReservedMemory.getBase()), 0xaa, Size),
32+
"");
33+
34+
ReservedMemory.release();
3035
}
3136

3237
TEST(ScudoMapDeathTest, MapUnmap) {
@@ -36,11 +41,13 @@ TEST(ScudoMapDeathTest, MapUnmap) {
3641
// Repeat few time to avoid missing crash if it's mmaped by unrelated
3742
// code.
3843
for (int i = 0; i < 10; ++i) {
39-
void *P = scudo::map(nullptr, Size, MappingName, 0, nullptr);
40-
if (!P)
44+
scudo::MemMapT MemMap;
45+
MemMap.map(/*Addr=*/0U, Size, MappingName);
46+
scudo::uptr P = MemMap.getBase();
47+
if (P == 0U)
4148
continue;
42-
scudo::unmap(P, Size, 0, nullptr);
43-
memset(P, 0xbb, Size);
49+
MemMap.unmap(MemMap.getBase(), Size);
50+
memset(reinterpret_cast<void *>(P), 0xbb, Size);
4451
}
4552
},
4653
"");
@@ -49,30 +56,36 @@ TEST(ScudoMapDeathTest, MapUnmap) {
4956
TEST(ScudoMapDeathTest, MapWithGuardUnmap) {
5057
const scudo::uptr PageSize = scudo::getPageSizeCached();
5158
const scudo::uptr Size = 4 * PageSize;
52-
scudo::MapPlatformData Data = {};
53-
void *P = scudo::map(nullptr, Size + 2 * PageSize, MappingName, MAP_NOACCESS,
54-
&Data);
55-
EXPECT_NE(P, nullptr);
56-
void *Q =
57-
reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
58-
EXPECT_EQ(scudo::map(Q, Size, MappingName, 0, &Data), Q);
59-
memset(Q, 0xaa, Size);
60-
EXPECT_DEATH(memset(Q, 0xaa, Size + 1), "");
61-
scudo::unmap(P, Size + 2 * PageSize, UNMAP_ALL, &Data);
59+
scudo::ReservedMemoryT ReservedMemory;
60+
ASSERT_TRUE(
61+
ReservedMemory.create(/*Addr=*/0U, Size + 2 * PageSize, MappingName));
62+
ASSERT_NE(ReservedMemory.getBase(), 0U);
63+
64+
scudo::MemMapT MemMap =
65+
ReservedMemory.dispatch(ReservedMemory.getBase(), Size + 2 * PageSize);
66+
ASSERT_TRUE(MemMap.isAllocated());
67+
scudo::uptr Q = MemMap.getBase() + PageSize;
68+
ASSERT_TRUE(MemMap.remap(Q, Size, MappingName));
69+
memset(reinterpret_cast<void *>(Q), 0xaa, Size);
70+
EXPECT_DEATH(memset(reinterpret_cast<void *>(Q), 0xaa, Size + 1), "");
71+
MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
6272
}
6373

6474
TEST(ScudoMapTest, MapGrowUnmap) {
6575
const scudo::uptr PageSize = scudo::getPageSizeCached();
6676
const scudo::uptr Size = 4 * PageSize;
67-
scudo::MapPlatformData Data = {};
68-
void *P = scudo::map(nullptr, Size, MappingName, MAP_NOACCESS, &Data);
69-
EXPECT_NE(P, nullptr);
70-
void *Q =
71-
reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(P) + PageSize);
72-
EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &Data), Q);
73-
memset(Q, 0xaa, PageSize);
74-
Q = reinterpret_cast<void *>(reinterpret_cast<scudo::uptr>(Q) + PageSize);
75-
EXPECT_EQ(scudo::map(Q, PageSize, MappingName, 0, &Data), Q);
76-
memset(Q, 0xbb, PageSize);
77-
scudo::unmap(P, Size, UNMAP_ALL, &Data);
77+
scudo::ReservedMemoryT ReservedMemory;
78+
ReservedMemory.create(/*Addr=*/0U, Size, MappingName);
79+
ASSERT_TRUE(ReservedMemory.isCreated());
80+
81+
scudo::MemMapT MemMap =
82+
ReservedMemory.dispatch(ReservedMemory.getBase(), Size);
83+
ASSERT_TRUE(MemMap.isAllocated());
84+
scudo::uptr Q = MemMap.getBase() + PageSize;
85+
ASSERT_TRUE(MemMap.remap(Q, PageSize, MappingName));
86+
memset(reinterpret_cast<void *>(Q), 0xaa, PageSize);
87+
Q += PageSize;
88+
ASSERT_TRUE(MemMap.remap(Q, PageSize, MappingName));
89+
memset(reinterpret_cast<void *>(Q), 0xbb, PageSize);
90+
MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
7891
}

‎compiler-rt/lib/scudo/standalone/tests/memtag_test.cpp‎

Lines changed: 11 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@
77
//===----------------------------------------------------------------------===//
88

99
#include "common.h"
10+
#include "mem_map.h"
1011
#include "memtag.h"
1112
#include "platform.h"
1213
#include "tests/scudo_unit_test.h"
@@ -45,20 +46,23 @@ class MemtagTest : public Test {
4546
GTEST_SKIP() << "Memory tagging is not supported";
4647

4748
BufferSize = getPageSizeCached();
48-
Buffer = reinterpret_cast<u8 *>(
49-
map(nullptr, BufferSize, "MemtagTest", MAP_MEMTAG, &Data));
50-
Addr = reinterpret_cast<uptr>(Buffer);
49+
scudo::MemMapT MemMap;
50+
ASSERT_TRUE(MemMap.map(/*Addr=*/0U, BufferSize, "MemtagTest", MAP_MEMTAG));
51+
Addr = MemMap.getBase();
52+
Buffer = reinterpret_cast<u8 *>(Addr);
5153
EXPECT_TRUE(isAligned(Addr, archMemoryTagGranuleSize()));
5254
EXPECT_EQ(Addr, untagPointer(Addr));
5355
}
5456

5557
void TearDown() override {
56-
if (Buffer)
57-
unmap(Buffer, BufferSize, 0, &Data);
58+
if (Buffer) {
59+
ASSERT_TRUE(MemMap.isAllocated());
60+
MemMap.unmap(MemMap.getBase(), MemMap.getCapacity());
61+
}
5862
}
5963

6064
uptr BufferSize = 0;
61-
MapPlatformData Data = {};
65+
scudo::MemMapT MemMap;
6266
u8 *Buffer = nullptr;
6367
uptr Addr = 0;
6468
};
@@ -179,7 +183,7 @@ TEST_F(MemtagTest, StoreTags) {
179183
EXPECT_EQ(LoadPtr, loadTag(LoadPtr));
180184

181185
// Reset tags without using StoreTags.
182-
releasePagesToOS(Addr, 0, BufferSize, &Data);
186+
MemMap.releasePagesToOS(Addr, BufferSize);
183187
}
184188
}
185189

0 commit comments

Comments
 (0)