Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 1 | /* |
Andrew Walbran | 692b325 | 2019-03-07 15:51:31 +0000 | [diff] [blame] | 2 | * Copyright 2018 The Hafnium Authors. |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 3 | * |
Andrew Walbran | e959ec1 | 2020-06-17 15:01:09 +0100 | [diff] [blame] | 4 | * Use of this source code is governed by a BSD-style |
| 5 | * license that can be found in the LICENSE file or at |
| 6 | * https://opensource.org/licenses/BSD-3-Clause. |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 7 | */ |
| 8 | |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 9 | #include <gmock/gmock.h> |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 10 | |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 11 | extern "C" { |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 12 | #include "hf/arch/mm.h" |
| 13 | |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 14 | #include "hf/mm.h" |
| 15 | #include "hf/mpool.h" |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 16 | } |
| 17 | |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 18 | #include <limits> |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 19 | #include <memory> |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 20 | #include <span> |
| 21 | #include <vector> |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 22 | |
Andrew Scull | 3c25745 | 2019-11-26 13:32:50 +0000 | [diff] [blame] | 23 | #include "mm_test.hh" |
| 24 | |
Andrew Scull | 232d560 | 2018-10-15 11:07:45 +0100 | [diff] [blame] | 25 | namespace |
| 26 | { |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 27 | using namespace ::std::placeholders; |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 28 | |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 29 | using ::testing::AllOf; |
| 30 | using ::testing::Contains; |
| 31 | using ::testing::Each; |
| 32 | using ::testing::Eq; |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 33 | using ::testing::Not; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 34 | using ::testing::SizeIs; |
| 35 | using ::testing::Truly; |
| 36 | |
Andrew Scull | 3c25745 | 2019-11-26 13:32:50 +0000 | [diff] [blame] | 37 | using ::mm_test::get_ptable; |
| 38 | |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 39 | constexpr size_t TEST_HEAP_SIZE = PAGE_SIZE * 16; |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 40 | const mm_level_t TOP_LEVEL = arch_mm_stage2_max_level(); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 41 | const paddr_t VM_MEM_END = pa_init(0x200'0000'0000); |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 42 | |
| 43 | /** |
| 44 | * Calculates the size of the address space represented by a page table entry at |
| 45 | * the given level. |
| 46 | */ |
Andrew Scull | 232d560 | 2018-10-15 11:07:45 +0100 | [diff] [blame] | 47 | size_t mm_entry_size(int level) |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 48 | { |
| 49 | return UINT64_C(1) << (PAGE_BITS + level * PAGE_LEVEL_BITS); |
| 50 | } |
| 51 | |
| 52 | /** |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 53 | * Checks whether the address is mapped in the address space. |
| 54 | */ |
Karl Meakin | d64aaf8 | 2025-02-08 01:12:55 +0000 | [diff] [blame] | 55 | bool mm_vm_is_mapped(struct mm_ptable *ptable, ipaddr_t ipa) |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 56 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 57 | mm_mode_t mode; |
Karl Meakin | d64aaf8 | 2025-02-08 01:12:55 +0000 | [diff] [blame] | 58 | return mm_vm_get_mode(ptable, ipa, ipa_add(ipa, 1), &mode) && |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 59 | (mode & MM_MODE_INVALID) == 0; |
| 60 | } |
| 61 | |
| 62 | /** |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 63 | * Get an STL representation of the page table. |
Andrew Scull | 4e5f814 | 2018-10-12 14:37:19 +0100 | [diff] [blame] | 64 | */ |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 65 | std::span<pte_t, MM_PTE_PER_PAGE> get_table(paddr_t pa) |
Andrew Scull | 4e5f814 | 2018-10-12 14:37:19 +0100 | [diff] [blame] | 66 | { |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 67 | auto table = reinterpret_cast<struct mm_page_table *>( |
Andrew Scull | 4e5f814 | 2018-10-12 14:37:19 +0100 | [diff] [blame] | 68 | ptr_from_va(va_from_pa(pa))); |
Olivier Deprez | a4491a2 | 2021-04-20 17:34:42 +0200 | [diff] [blame] | 69 | return std::span<pte_t, MM_PTE_PER_PAGE>(table->entries, |
| 70 | std::end(table->entries)); |
Andrew Scull | 4e5f814 | 2018-10-12 14:37:19 +0100 | [diff] [blame] | 71 | } |
| 72 | |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 73 | class mm : public ::testing::Test |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 74 | { |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 75 | void SetUp() override |
| 76 | { |
| 77 | /* |
| 78 | * TODO: replace with direct use of stdlib allocator so |
| 79 | * sanitizers are more effective. |
| 80 | */ |
| 81 | test_heap = std::make_unique<uint8_t[]>(TEST_HEAP_SIZE); |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 82 | mpool_init(&ppool, sizeof(struct mm_page_table)); |
| 83 | mpool_add_chunk(&ppool, test_heap.get(), TEST_HEAP_SIZE); |
Karl Meakin | a485836 | 2025-02-13 16:04:28 +0000 | [diff] [blame] | 84 | ASSERT_TRUE(mm_vm_init(&ptable, 0, &ppool)); |
| 85 | } |
| 86 | |
| 87 | void TearDown() override |
| 88 | { |
| 89 | mm_vm_fini(&ptable, &ppool); |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 90 | } |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 91 | |
| 92 | std::unique_ptr<uint8_t[]> test_heap; |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 93 | |
| 94 | protected: |
| 95 | struct mpool ppool; |
Karl Meakin | a485836 | 2025-02-13 16:04:28 +0000 | [diff] [blame] | 96 | struct mm_ptable ptable; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 97 | }; |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 98 | |
| 99 | /** |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 100 | * A new table is initially empty. |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 101 | */ |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 102 | TEST_F(mm, ptable_init_empty) |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 103 | { |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 104 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 105 | get_ptable(ptable), |
| 106 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | /** |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 110 | * Each new concatenated table is initially empty. |
| 111 | */ |
| 112 | TEST_F(mm, ptable_init_concatenated_empty) |
| 113 | { |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 114 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 115 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 116 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | /** |
| 120 | * Only the first page is mapped with all others left absent. |
| 121 | */ |
| 122 | TEST_F(mm, map_first_page) |
| 123 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 124 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 125 | const paddr_t page_begin = pa_init(0); |
| 126 | const paddr_t page_end = pa_add(page_begin, PAGE_SIZE); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 127 | ASSERT_TRUE(mm_vm_identity_map(&ptable, page_begin, page_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 128 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 129 | |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 130 | auto tables = get_ptable(ptable); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 131 | EXPECT_THAT(tables, SizeIs(4)); |
| 132 | ASSERT_THAT(TOP_LEVEL, Eq(2)); |
| 133 | |
| 134 | /* Check that the first page is mapped and nothing else. */ |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 135 | EXPECT_THAT(std::span(tables).last(3), |
| 136 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 137 | |
| 138 | auto table_l2 = tables.front(); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 139 | EXPECT_THAT(table_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 140 | ASSERT_TRUE(arch_mm_pte_is_table(table_l2[0], TOP_LEVEL)); |
| 141 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 142 | auto table_l1 = |
| 143 | get_table(arch_mm_table_from_pte(table_l2[0], TOP_LEVEL)); |
| 144 | EXPECT_THAT(table_l1.subspan(1), |
| 145 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 146 | ASSERT_TRUE(arch_mm_pte_is_table(table_l1[0], TOP_LEVEL - 1)); |
| 147 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 148 | auto table_l0 = |
| 149 | get_table(arch_mm_table_from_pte(table_l1[0], TOP_LEVEL - 1)); |
| 150 | EXPECT_THAT(table_l0.subspan(1), |
| 151 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 152 | ASSERT_TRUE(arch_mm_pte_is_block(table_l0[0], TOP_LEVEL - 2)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 153 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(table_l0[0], TOP_LEVEL - 2)), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 154 | Eq(pa_addr(page_begin))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 155 | } |
| 156 | |
| 157 | /** |
| 158 | * The start address is rounded down and the end address is rounded up to page |
| 159 | * boundaries. |
| 160 | */ |
| 161 | TEST_F(mm, map_round_to_page) |
| 162 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 163 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 164 | const paddr_t map_begin = pa_init(0x200'0000'0000 - PAGE_SIZE + 23); |
| 165 | const paddr_t map_end = pa_add(map_begin, 268); |
| 166 | ipaddr_t ipa = ipa_init(-1); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 167 | ASSERT_TRUE(mm_vm_identity_map(&ptable, map_begin, map_end, mode, |
| 168 | &ppool, &ipa)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 169 | EXPECT_THAT(ipa_addr(ipa), Eq(pa_addr(map_begin))); |
| 170 | |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 171 | auto tables = get_ptable(ptable); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 172 | EXPECT_THAT(tables, SizeIs(4)); |
| 173 | ASSERT_THAT(TOP_LEVEL, Eq(2)); |
| 174 | |
| 175 | /* Check that the last page is mapped, and nothing else. */ |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 176 | EXPECT_THAT(std::span(tables).first(3), |
| 177 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 178 | |
| 179 | auto table_l2 = tables.back(); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 180 | EXPECT_THAT(table_l2.first(table_l2.size() - 1), |
| 181 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 182 | ASSERT_TRUE(arch_mm_pte_is_table(table_l2.last(1)[0], TOP_LEVEL)); |
| 183 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 184 | auto table_l1 = get_table( |
| 185 | arch_mm_table_from_pte(table_l2.last(1)[0], TOP_LEVEL)); |
| 186 | EXPECT_THAT(table_l1.first(table_l1.size() - 1), |
| 187 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 188 | ASSERT_TRUE(arch_mm_pte_is_table(table_l1.last(1)[0], TOP_LEVEL - 1)); |
| 189 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 190 | auto table_l0 = get_table( |
| 191 | arch_mm_table_from_pte(table_l1.last(1)[0], TOP_LEVEL - 1)); |
| 192 | EXPECT_THAT(table_l0.first(table_l0.size() - 1), |
| 193 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 194 | ASSERT_TRUE(arch_mm_pte_is_block(table_l0.last(1)[0], TOP_LEVEL - 2)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 195 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(table_l0.last(1)[0], |
| 196 | TOP_LEVEL - 2)), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 197 | Eq(0x200'0000'0000 - PAGE_SIZE)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 198 | } |
| 199 | |
| 200 | /** |
| 201 | * Map a two page range over the boundary of two tables. |
| 202 | */ |
| 203 | TEST_F(mm, map_across_tables) |
| 204 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 205 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 206 | const paddr_t map_begin = pa_init(0x80'0000'0000 - PAGE_SIZE); |
| 207 | const paddr_t map_end = pa_add(map_begin, 2 * PAGE_SIZE); |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 208 | ASSERT_TRUE(mm_vm_identity_map(&ptable, map_begin, map_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 209 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 210 | |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 211 | auto tables = get_ptable(ptable); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 212 | EXPECT_THAT(tables, SizeIs(4)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 213 | EXPECT_THAT(std::span(tables).last(2), |
| 214 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 215 | ASSERT_THAT(TOP_LEVEL, Eq(2)); |
| 216 | |
| 217 | /* Check only the last page of the first table is mapped. */ |
| 218 | auto table0_l2 = tables.front(); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 219 | EXPECT_THAT(table0_l2.first(table0_l2.size() - 1), |
| 220 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 221 | ASSERT_TRUE(arch_mm_pte_is_table(table0_l2.last(1)[0], TOP_LEVEL)); |
| 222 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 223 | auto table0_l1 = get_table( |
| 224 | arch_mm_table_from_pte(table0_l2.last(1)[0], TOP_LEVEL)); |
| 225 | EXPECT_THAT(table0_l1.first(table0_l1.size() - 1), |
| 226 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 227 | ASSERT_TRUE(arch_mm_pte_is_table(table0_l1.last(1)[0], TOP_LEVEL - 1)); |
| 228 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 229 | auto table0_l0 = get_table( |
| 230 | arch_mm_table_from_pte(table0_l1.last(1)[0], TOP_LEVEL - 1)); |
| 231 | EXPECT_THAT(table0_l0.first(table0_l0.size() - 1), |
| 232 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 233 | ASSERT_TRUE(arch_mm_pte_is_block(table0_l0.last(1)[0], TOP_LEVEL - 2)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 234 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(table0_l0.last(1)[0], |
| 235 | TOP_LEVEL - 2)), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 236 | Eq(pa_addr(map_begin))); |
| 237 | |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 238 | /* Check only the first page of the second table is mapped. */ |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 239 | auto table1_l2 = tables[1]; |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 240 | EXPECT_THAT(table1_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 241 | ASSERT_TRUE(arch_mm_pte_is_table(table1_l2[0], TOP_LEVEL)); |
| 242 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 243 | auto table1_l1 = |
| 244 | get_table(arch_mm_table_from_pte(table1_l2[0], TOP_LEVEL)); |
| 245 | EXPECT_THAT(table1_l1.subspan(1), |
| 246 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 247 | ASSERT_TRUE(arch_mm_pte_is_table(table1_l1[0], TOP_LEVEL - 1)); |
| 248 | |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 249 | auto table1_l0 = |
| 250 | get_table(arch_mm_table_from_pte(table1_l1[0], TOP_LEVEL - 1)); |
| 251 | EXPECT_THAT(table1_l0.subspan(1), |
| 252 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 253 | ASSERT_TRUE(arch_mm_pte_is_block(table1_l0[0], TOP_LEVEL - 2)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 254 | EXPECT_THAT( |
| 255 | pa_addr(arch_mm_block_from_pte(table1_l0[0], TOP_LEVEL - 2)), |
| 256 | Eq(pa_addr(pa_add(map_begin, PAGE_SIZE)))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 257 | } |
| 258 | |
| 259 | /** |
| 260 | * Mapping all of memory creates blocks at the highest level. |
| 261 | */ |
| 262 | TEST_F(mm, map_all_at_top_level) |
| 263 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 264 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 265 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 266 | &ppool, nullptr)); |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 267 | auto tables = get_ptable(ptable); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 268 | EXPECT_THAT( |
| 269 | tables, |
| 270 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 271 | _1, TOP_LEVEL)))))); |
| 272 | for (uint64_t i = 0; i < tables.size(); ++i) { |
| 273 | for (uint64_t j = 0; j < MM_PTE_PER_PAGE; ++j) { |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 274 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(tables[i][j], |
| 275 | TOP_LEVEL)), |
| 276 | Eq((i * mm_entry_size(TOP_LEVEL + 1)) + |
| 277 | (j * mm_entry_size(TOP_LEVEL)))) |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 278 | << "i=" << i << " j=" << j; |
| 279 | } |
| 280 | } |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 281 | } |
| 282 | |
| 283 | /** |
| 284 | * Map all memory then trying to map a page again doesn't introduce a special |
| 285 | * mapping for that particular page. |
| 286 | */ |
| 287 | TEST_F(mm, map_already_mapped) |
| 288 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 289 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 290 | ipaddr_t ipa = ipa_init(-1); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 291 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 292 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 293 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), pa_init(PAGE_SIZE), |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 294 | mode, &ppool, &ipa)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 295 | EXPECT_THAT(ipa_addr(ipa), Eq(0)); |
| 296 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 297 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 298 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 299 | _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 300 | } |
| 301 | |
| 302 | /** |
| 303 | * Mapping a reverse range, i.e. the end comes before the start, is treated as |
| 304 | * an empty range so no mappings are made. |
| 305 | */ |
| 306 | TEST_F(mm, map_reverse_range) |
| 307 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 308 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 309 | ipaddr_t ipa = ipa_init(-1); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 310 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0x1234'5678), |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 311 | pa_init(0x5000), mode, &ppool, &ipa)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 312 | EXPECT_THAT(ipa_addr(ipa), Eq(0x1234'5678)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 313 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 314 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 315 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 316 | } |
| 317 | |
| 318 | /** |
| 319 | * Mapping a reverse range in the same page will map the page because the start |
| 320 | * of the range is rounded down and the end is rounded up. |
| 321 | * |
| 322 | * This serves as a form of documentation of behaviour rather than a |
| 323 | * requirement. Check whether any code relies on this before changing it. |
| 324 | */ |
| 325 | TEST_F(mm, map_reverse_range_quirk) |
| 326 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 327 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 328 | ipaddr_t ipa = ipa_init(-1); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 329 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(20), pa_init(10), mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 330 | &ppool, &ipa)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 331 | EXPECT_THAT(ipa_addr(ipa), Eq(20)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 332 | EXPECT_TRUE(mm_vm_is_mapped(&ptable, ipa)); |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 333 | mm_vm_fini(&ptable, &ppool); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 334 | } |
| 335 | |
| 336 | /** |
| 337 | * Mapping a range up to the maximum address causes the range end to wrap to |
| 338 | * zero as it is rounded up to a page boundary meaning no memory is mapped. |
| 339 | * |
| 340 | * This serves as a form of documentation of behaviour rather than a |
| 341 | * requirement. Check whether any code relies on this before changing it. |
| 342 | */ |
| 343 | TEST_F(mm, map_last_address_quirk) |
| 344 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 345 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 346 | ipaddr_t ipa = ipa_init(-1); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 347 | ASSERT_TRUE(mm_vm_identity_map( |
| 348 | &ptable, pa_init(0), |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 349 | pa_init(std::numeric_limits<uintpaddr_t>::max()), mode, &ppool, |
| 350 | &ipa)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 351 | EXPECT_THAT(ipa_addr(ipa), Eq(0)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 352 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 353 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 354 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 355 | } |
| 356 | |
| 357 | /** |
| 358 | * Mapping a range that goes beyond the available memory clamps to the available |
| 359 | * range. |
| 360 | */ |
| 361 | TEST_F(mm, map_clamp_to_range) |
| 362 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 363 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 364 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), |
| 365 | pa_init(0xf32'0000'0000'0000), mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 366 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 367 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 368 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 369 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 370 | _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | /** |
| 374 | * Mapping a range outside of the available memory is ignored and doesn't alter |
| 375 | * the page tables. |
| 376 | */ |
| 377 | TEST_F(mm, map_ignore_out_of_range) |
| 378 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 379 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 380 | ipaddr_t ipa = ipa_init(-1); |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 381 | ASSERT_TRUE(mm_vm_identity_map(&ptable, VM_MEM_END, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 382 | pa_init(0xf0'0000'0000'0000), mode, |
| 383 | &ppool, &ipa)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 384 | EXPECT_THAT(ipa_addr(ipa), Eq(pa_addr(VM_MEM_END))); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 385 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 386 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 387 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 388 | } |
| 389 | |
| 390 | /** |
| 391 | * Map a single page and then map all of memory which replaces the single page |
| 392 | * mapping with a higher level block mapping. |
| 393 | */ |
| 394 | TEST_F(mm, map_block_replaces_table) |
| 395 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 396 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 397 | const paddr_t page_begin = pa_init(34567 * PAGE_SIZE); |
| 398 | const paddr_t page_end = pa_add(page_begin, PAGE_SIZE); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 399 | ASSERT_TRUE(mm_vm_identity_map(&ptable, page_begin, page_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 400 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 401 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 402 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 403 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 404 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 405 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 406 | _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 407 | } |
| 408 | |
| 409 | /** |
| 410 | * Map all memory at the top level, unmapping a page and remapping at a lower |
| 411 | * level does not result in all memory being mapped at the top level again. |
| 412 | */ |
| 413 | TEST_F(mm, map_does_not_defrag) |
| 414 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 415 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 416 | const paddr_t page_begin = pa_init(12000 * PAGE_SIZE); |
| 417 | const paddr_t page_end = pa_add(page_begin, PAGE_SIZE); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 418 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 419 | &ppool, nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 420 | ASSERT_TRUE(mm_vm_unmap(&ptable, page_begin, page_end, &ppool)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 421 | ASSERT_TRUE(mm_vm_identity_map(&ptable, page_begin, page_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 422 | &ppool, nullptr)); |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 423 | EXPECT_THAT(get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 424 | AllOf(SizeIs(4), |
| 425 | Each(Each(Truly(std::bind(arch_mm_pte_is_present, _1, |
| 426 | TOP_LEVEL)))), |
| 427 | Contains(Contains(Truly(std::bind( |
| 428 | arch_mm_pte_is_block, _1, TOP_LEVEL)))), |
| 429 | Contains(Contains(Truly(std::bind( |
| 430 | arch_mm_pte_is_table, _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 431 | } |
| 432 | |
| 433 | /** |
Andrew Scull | 73b8954 | 2019-11-20 17:31:26 +0000 | [diff] [blame] | 434 | * Mapping with a mode that indicates unmapping results in the addresses being |
| 435 | * unmapped with absent entries. |
| 436 | */ |
| 437 | TEST_F(mm, map_to_unmap) |
| 438 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 439 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 73b8954 | 2019-11-20 17:31:26 +0000 | [diff] [blame] | 440 | const paddr_t l0_begin = pa_init(uintpaddr_t(524421) * PAGE_SIZE); |
| 441 | const paddr_t l0_end = pa_add(l0_begin, 17 * PAGE_SIZE); |
| 442 | const paddr_t l1_begin = pa_init(3 * mm_entry_size(1)); |
| 443 | const paddr_t l1_end = pa_add(l1_begin, 5 * mm_entry_size(1)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 444 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l0_begin, l0_end, mode, &ppool, |
| 445 | nullptr)); |
| 446 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l1_begin, l1_end, mode, &ppool, |
| 447 | nullptr)); |
Andrew Scull | 73b8954 | 2019-11-20 17:31:26 +0000 | [diff] [blame] | 448 | EXPECT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 449 | MM_MODE_UNMAPPED_MASK, &ppool, nullptr)); |
Andrew Scull | 73b8954 | 2019-11-20 17:31:26 +0000 | [diff] [blame] | 450 | EXPECT_THAT( |
| 451 | get_ptable(ptable), |
| 452 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 73b8954 | 2019-11-20 17:31:26 +0000 | [diff] [blame] | 453 | } |
| 454 | |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 455 | /* |
| 456 | * Preparing and committing an address range works the same as mapping it. |
| 457 | */ |
| 458 | TEST_F(mm, prepare_and_commit_first_page) |
| 459 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 460 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 461 | const paddr_t page_begin = pa_init(0); |
| 462 | const paddr_t page_end = pa_add(page_begin, PAGE_SIZE); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 463 | ASSERT_TRUE(mm_vm_identity_prepare(&ptable, page_begin, page_end, mode, |
| 464 | &ppool)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 465 | mm_vm_identity_commit(&ptable, page_begin, page_end, mode, &ppool, |
| 466 | nullptr); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 467 | |
| 468 | auto tables = get_ptable(ptable); |
| 469 | EXPECT_THAT(tables, SizeIs(4)); |
| 470 | ASSERT_THAT(TOP_LEVEL, Eq(2)); |
| 471 | |
| 472 | /* Check that the first page is mapped and nothing else. */ |
| 473 | EXPECT_THAT(std::span(tables).last(3), |
| 474 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 475 | |
| 476 | auto table_l2 = tables.front(); |
| 477 | EXPECT_THAT(table_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 478 | ASSERT_TRUE(arch_mm_pte_is_table(table_l2[0], TOP_LEVEL)); |
| 479 | |
| 480 | auto table_l1 = |
| 481 | get_table(arch_mm_table_from_pte(table_l2[0], TOP_LEVEL)); |
| 482 | EXPECT_THAT(table_l1.subspan(1), |
| 483 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 484 | ASSERT_TRUE(arch_mm_pte_is_table(table_l1[0], TOP_LEVEL - 1)); |
| 485 | |
| 486 | auto table_l0 = |
| 487 | get_table(arch_mm_table_from_pte(table_l1[0], TOP_LEVEL - 1)); |
| 488 | EXPECT_THAT(table_l0.subspan(1), |
| 489 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
| 490 | ASSERT_TRUE(arch_mm_pte_is_block(table_l0[0], TOP_LEVEL - 2)); |
| 491 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(table_l0[0], TOP_LEVEL - 2)), |
| 492 | Eq(pa_addr(page_begin))); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 493 | } |
| 494 | |
| 495 | /** |
| 496 | * Disjoint address ranges can be prepared and committed together. |
| 497 | */ |
| 498 | TEST_F(mm, prepare_and_commit_disjoint_regions) |
| 499 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 500 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 501 | const paddr_t first_begin = pa_init(0); |
| 502 | const paddr_t first_end = pa_add(first_begin, PAGE_SIZE); |
| 503 | const paddr_t last_begin = pa_init(pa_addr(VM_MEM_END) - PAGE_SIZE); |
| 504 | const paddr_t last_end = VM_MEM_END; |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 505 | ASSERT_TRUE(mm_vm_identity_prepare(&ptable, first_begin, first_end, |
| 506 | mode, &ppool)); |
| 507 | ASSERT_TRUE(mm_vm_identity_prepare(&ptable, last_begin, last_end, mode, |
| 508 | &ppool)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 509 | mm_vm_identity_commit(&ptable, first_begin, first_end, mode, &ppool, |
| 510 | nullptr); |
| 511 | mm_vm_identity_commit(&ptable, last_begin, last_end, mode, &ppool, |
| 512 | nullptr); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 513 | |
| 514 | auto tables = get_ptable(ptable); |
| 515 | EXPECT_THAT(tables, SizeIs(4)); |
| 516 | ASSERT_THAT(TOP_LEVEL, Eq(2)); |
| 517 | |
| 518 | /* Check that the first and last pages are mapped and nothing else. */ |
| 519 | EXPECT_THAT(std::span(tables).subspan(1, 2), |
| 520 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 521 | |
| 522 | /* Check the first page. */ |
| 523 | auto table0_l2 = tables.front(); |
| 524 | EXPECT_THAT(table0_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 525 | ASSERT_TRUE(arch_mm_pte_is_table(table0_l2[0], TOP_LEVEL)); |
| 526 | |
| 527 | auto table0_l1 = |
| 528 | get_table(arch_mm_table_from_pte(table0_l2[0], TOP_LEVEL)); |
| 529 | EXPECT_THAT(table0_l1.subspan(1), |
| 530 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 531 | ASSERT_TRUE(arch_mm_pte_is_table(table0_l1[0], TOP_LEVEL - 1)); |
| 532 | |
| 533 | auto table0_l0 = |
| 534 | get_table(arch_mm_table_from_pte(table0_l1[0], TOP_LEVEL - 1)); |
| 535 | EXPECT_THAT(table0_l0.subspan(1), |
| 536 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
| 537 | ASSERT_TRUE(arch_mm_pte_is_block(table0_l0[0], TOP_LEVEL - 2)); |
| 538 | EXPECT_THAT( |
| 539 | pa_addr(arch_mm_block_from_pte(table0_l0[0], TOP_LEVEL - 2)), |
| 540 | Eq(pa_addr(first_begin))); |
| 541 | |
| 542 | /* Check the last page. */ |
| 543 | auto table3_l2 = tables.back(); |
| 544 | EXPECT_THAT(table3_l2.first(table3_l2.size() - 1), |
| 545 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 546 | ASSERT_TRUE(arch_mm_pte_is_table(table3_l2.last(1)[0], TOP_LEVEL)); |
| 547 | |
| 548 | auto table3_l1 = get_table( |
| 549 | arch_mm_table_from_pte(table3_l2.last(1)[0], TOP_LEVEL)); |
| 550 | EXPECT_THAT(table3_l1.first(table3_l1.size() - 1), |
| 551 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 552 | ASSERT_TRUE(arch_mm_pte_is_table(table3_l1.last(1)[0], TOP_LEVEL - 1)); |
| 553 | |
| 554 | auto table3_l0 = get_table( |
| 555 | arch_mm_table_from_pte(table3_l1.last(1)[0], TOP_LEVEL - 1)); |
| 556 | EXPECT_THAT(table3_l0.first(table3_l0.size() - 1), |
| 557 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
| 558 | ASSERT_TRUE(arch_mm_pte_is_block(table3_l0.last(1)[0], TOP_LEVEL - 2)); |
| 559 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(table3_l0.last(1)[0], |
| 560 | TOP_LEVEL - 2)), |
| 561 | Eq(pa_addr(last_begin))); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 562 | } |
| 563 | |
| 564 | /** |
| 565 | * Overlapping address ranges can be prepared and committed together. |
| 566 | */ |
| 567 | TEST_F(mm, prepare_and_commit_overlapping_regions) |
| 568 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 569 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 570 | const paddr_t low_begin = pa_init(0x80'0000'0000 - PAGE_SIZE); |
| 571 | const paddr_t high_begin = pa_add(low_begin, PAGE_SIZE); |
| 572 | const paddr_t map_end = pa_add(high_begin, PAGE_SIZE); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 573 | ASSERT_TRUE(mm_vm_identity_prepare(&ptable, high_begin, map_end, mode, |
| 574 | &ppool)); |
| 575 | ASSERT_TRUE(mm_vm_identity_prepare(&ptable, low_begin, map_end, mode, |
| 576 | &ppool)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 577 | mm_vm_identity_commit(&ptable, high_begin, map_end, mode, &ppool, |
| 578 | nullptr); |
| 579 | mm_vm_identity_commit(&ptable, low_begin, map_end, mode, &ppool, |
| 580 | nullptr); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 581 | |
| 582 | auto tables = get_ptable(ptable); |
| 583 | EXPECT_THAT(tables, SizeIs(4)); |
| 584 | EXPECT_THAT(std::span(tables).last(2), |
| 585 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 586 | ASSERT_THAT(TOP_LEVEL, Eq(2)); |
| 587 | |
| 588 | /* Check only the last page of the first table is mapped. */ |
| 589 | auto table0_l2 = tables.front(); |
| 590 | EXPECT_THAT(table0_l2.first(table0_l2.size() - 1), |
| 591 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 592 | ASSERT_TRUE(arch_mm_pte_is_table(table0_l2.last(1)[0], TOP_LEVEL)); |
| 593 | |
| 594 | auto table0_l1 = get_table( |
| 595 | arch_mm_table_from_pte(table0_l2.last(1)[0], TOP_LEVEL)); |
| 596 | EXPECT_THAT(table0_l1.first(table0_l1.size() - 1), |
| 597 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 598 | ASSERT_TRUE(arch_mm_pte_is_table(table0_l1.last(1)[0], TOP_LEVEL - 1)); |
| 599 | |
| 600 | auto table0_l0 = get_table( |
| 601 | arch_mm_table_from_pte(table0_l1.last(1)[0], TOP_LEVEL - 1)); |
| 602 | EXPECT_THAT(table0_l0.first(table0_l0.size() - 1), |
| 603 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
| 604 | ASSERT_TRUE(arch_mm_pte_is_block(table0_l0.last(1)[0], TOP_LEVEL - 2)); |
| 605 | EXPECT_THAT(pa_addr(arch_mm_block_from_pte(table0_l0.last(1)[0], |
| 606 | TOP_LEVEL - 2)), |
| 607 | Eq(pa_addr(low_begin))); |
| 608 | |
| 609 | /* Check only the first page of the second table is mapped. */ |
| 610 | auto table1_l2 = tables[1]; |
| 611 | EXPECT_THAT(table1_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 612 | ASSERT_TRUE(arch_mm_pte_is_table(table1_l2[0], TOP_LEVEL)); |
| 613 | |
| 614 | auto table1_l1 = |
| 615 | get_table(arch_mm_table_from_pte(table1_l2[0], TOP_LEVEL)); |
| 616 | EXPECT_THAT(table1_l1.subspan(1), |
| 617 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 618 | ASSERT_TRUE(arch_mm_pte_is_table(table1_l1[0], TOP_LEVEL - 1)); |
| 619 | |
| 620 | auto table1_l0 = |
| 621 | get_table(arch_mm_table_from_pte(table1_l1[0], TOP_LEVEL - 1)); |
| 622 | EXPECT_THAT(table1_l0.subspan(1), |
| 623 | Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
| 624 | ASSERT_TRUE(arch_mm_pte_is_block(table1_l0[0], TOP_LEVEL - 2)); |
| 625 | EXPECT_THAT( |
| 626 | pa_addr(arch_mm_block_from_pte(table1_l0[0], TOP_LEVEL - 2)), |
| 627 | Eq(pa_addr(high_begin))); |
Andrew Scull | 4e83cef | 2019-11-19 14:17:54 +0000 | [diff] [blame] | 628 | } |
| 629 | |
Andrew Scull | 73b8954 | 2019-11-20 17:31:26 +0000 | [diff] [blame] | 630 | /** |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 631 | * If range is not mapped, unmapping has no effect. |
| 632 | */ |
| 633 | TEST_F(mm, unmap_not_mapped) |
| 634 | { |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 635 | EXPECT_TRUE( |
| 636 | mm_vm_unmap(&ptable, pa_init(12345), pa_init(987652), &ppool)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 637 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 638 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 639 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 640 | } |
| 641 | |
| 642 | /** |
| 643 | * Unmapping everything should result in an empty page table with no subtables. |
| 644 | */ |
| 645 | TEST_F(mm, unmap_all) |
| 646 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 647 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 648 | const paddr_t l0_begin = pa_init(uintpaddr_t(524421) * PAGE_SIZE); |
| 649 | const paddr_t l0_end = pa_add(l0_begin, 17 * PAGE_SIZE); |
| 650 | const paddr_t l1_begin = pa_init(3 * mm_entry_size(1)); |
| 651 | const paddr_t l1_end = pa_add(l1_begin, 5 * mm_entry_size(1)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 652 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l0_begin, l0_end, mode, &ppool, |
| 653 | nullptr)); |
| 654 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l1_begin, l1_end, mode, &ppool, |
| 655 | nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 656 | EXPECT_TRUE(mm_vm_unmap(&ptable, pa_init(0), VM_MEM_END, &ppool)); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 657 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 658 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 659 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 660 | } |
| 661 | |
| 662 | /** |
| 663 | * Unmap range is rounded to the containing pages. |
| 664 | */ |
| 665 | TEST_F(mm, unmap_round_to_page) |
| 666 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 667 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 668 | const paddr_t map_begin = pa_init(0x160'0000'0000 + PAGE_SIZE); |
| 669 | const paddr_t map_end = pa_add(map_begin, PAGE_SIZE); |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 670 | |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 671 | ASSERT_TRUE(mm_vm_identity_map(&ptable, map_begin, map_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 672 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 673 | ASSERT_TRUE(mm_vm_unmap(&ptable, pa_add(map_begin, 93), |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 674 | pa_add(map_begin, 99), &ppool)); |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 675 | |
| 676 | auto tables = get_ptable(ptable); |
| 677 | constexpr auto l3_index = 2; |
| 678 | |
| 679 | /* Check all other top level entries are empty... */ |
| 680 | EXPECT_THAT(std::span(tables).first(l3_index), |
| 681 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 682 | EXPECT_THAT(std::span(tables).subspan(l3_index + 1), |
| 683 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 684 | |
| 685 | /* Except the mapped page which is absent. */ |
| 686 | auto table_l2 = tables[l3_index]; |
| 687 | constexpr auto l2_index = 384; |
| 688 | EXPECT_THAT(table_l2.first(l2_index), |
| 689 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 690 | ASSERT_TRUE(arch_mm_pte_is_table(table_l2[l2_index], TOP_LEVEL)); |
| 691 | EXPECT_THAT(table_l2.subspan(l2_index + 1), |
| 692 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 693 | |
| 694 | auto table_l1 = get_table( |
| 695 | arch_mm_table_from_pte(table_l2[l2_index], TOP_LEVEL)); |
| 696 | ASSERT_TRUE(arch_mm_pte_is_table(table_l1.first(1)[0], TOP_LEVEL - 1)); |
| 697 | EXPECT_THAT(table_l1.subspan(1), |
| 698 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 699 | |
| 700 | auto table_l0 = get_table( |
| 701 | arch_mm_table_from_pte(table_l1.first(1)[0], TOP_LEVEL - 1)); |
| 702 | EXPECT_THAT(table_l0, Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 703 | } |
| 704 | |
| 705 | /** |
| 706 | * Unmap a range that of page mappings that spans multiple concatenated tables. |
| 707 | */ |
| 708 | TEST_F(mm, unmap_across_tables) |
| 709 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 710 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 711 | const paddr_t map_begin = pa_init(0x180'0000'0000 - PAGE_SIZE); |
| 712 | const paddr_t map_end = pa_add(map_begin, 2 * PAGE_SIZE); |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 713 | |
Wedson Almeida Filho | 22d5eaa | 2018-12-16 00:38:49 +0000 | [diff] [blame] | 714 | ASSERT_TRUE(mm_vm_identity_map(&ptable, map_begin, map_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 715 | &ppool, nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 716 | ASSERT_TRUE(mm_vm_unmap(&ptable, map_begin, map_end, &ppool)); |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 717 | |
| 718 | auto tables = get_ptable(ptable); |
| 719 | |
| 720 | /* Check the untouched tables are empty. */ |
| 721 | EXPECT_THAT(std::span(tables).first(2), |
| 722 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 723 | |
| 724 | /* Check the last page is explicity marked as absent. */ |
| 725 | auto table2_l2 = tables[2]; |
| 726 | EXPECT_THAT(table2_l2.first(table2_l2.size() - 1), |
| 727 | Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 728 | ASSERT_TRUE(arch_mm_pte_is_table(table2_l2.last(1)[0], TOP_LEVEL)); |
| 729 | |
| 730 | auto table2_l1 = get_table( |
| 731 | arch_mm_table_from_pte(table2_l2.last(1)[0], TOP_LEVEL)); |
| 732 | EXPECT_THAT(table2_l1.first(table2_l1.size() - 1), |
| 733 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 734 | ASSERT_TRUE(arch_mm_pte_is_table(table2_l1.last(1)[0], TOP_LEVEL - 1)); |
| 735 | |
| 736 | auto table2_l0 = get_table( |
| 737 | arch_mm_table_from_pte(table2_l1.last(1)[0], TOP_LEVEL - 1)); |
| 738 | EXPECT_THAT(table2_l0, Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
| 739 | |
| 740 | /* Check the first page is explicitly marked as absent. */ |
| 741 | auto table3_l2 = tables[3]; |
| 742 | ASSERT_TRUE(arch_mm_pte_is_table(table3_l2.first(1)[0], TOP_LEVEL)); |
| 743 | EXPECT_THAT(table3_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 744 | |
| 745 | auto table3_l1 = get_table( |
| 746 | arch_mm_table_from_pte(table3_l2.first(1)[0], TOP_LEVEL)); |
| 747 | ASSERT_TRUE(arch_mm_pte_is_table(table3_l1.first(1)[0], TOP_LEVEL - 1)); |
| 748 | EXPECT_THAT(table3_l1.subspan(1), |
| 749 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 750 | |
| 751 | auto table3_l0 = get_table( |
| 752 | arch_mm_table_from_pte(table3_l1.first(1)[0], TOP_LEVEL - 1)); |
| 753 | EXPECT_THAT(table3_l0, Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 754 | } |
| 755 | |
| 756 | /** |
| 757 | * Unmapping outside the range of memory had no effect. |
| 758 | */ |
| 759 | TEST_F(mm, unmap_out_of_range) |
| 760 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 761 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 762 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 763 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 764 | ASSERT_TRUE(mm_vm_unmap(&ptable, VM_MEM_END, pa_init(0x4000'0000'0000), |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 765 | &ppool)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 766 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 767 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 768 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 769 | _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 770 | } |
| 771 | |
| 772 | /** |
| 773 | * Unmapping a reverse range, i.e. the end comes before the start, is treated as |
| 774 | * an empty range so no change is made. |
| 775 | */ |
| 776 | TEST_F(mm, unmap_reverse_range) |
| 777 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 778 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 779 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 780 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 781 | ASSERT_TRUE(mm_vm_unmap(&ptable, pa_init(0x80'a000'0000), pa_init(27), |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 782 | &ppool)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 783 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 784 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 785 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 786 | _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 787 | } |
| 788 | |
| 789 | /** |
| 790 | * Unmapping a reverse range in the same page will unmap the page because the |
| 791 | * start of the range is rounded down and the end is rounded up. |
| 792 | * |
| 793 | * This serves as a form of documentation of behaviour rather than a |
| 794 | * requirement. Check whether any code relies on this before changing it. |
| 795 | */ |
| 796 | TEST_F(mm, unmap_reverse_range_quirk) |
| 797 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 798 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 799 | const paddr_t page_begin = pa_init(0x180'0000'0000); |
| 800 | const paddr_t page_end = pa_add(page_begin, PAGE_SIZE); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 801 | ASSERT_TRUE(mm_vm_identity_map(&ptable, page_begin, page_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 802 | &ppool, nullptr)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 803 | ASSERT_TRUE(mm_vm_unmap(&ptable, pa_add(page_begin, 100), |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 804 | pa_add(page_begin, 50), &ppool)); |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 805 | |
| 806 | auto tables = get_ptable(ptable); |
| 807 | constexpr auto l3_index = 3; |
| 808 | |
| 809 | /* Check all other top level entries are empty... */ |
| 810 | EXPECT_THAT(std::span(tables).first(l3_index), |
| 811 | Each(Each(arch_mm_absent_pte(TOP_LEVEL)))); |
| 812 | |
| 813 | /* Except the mapped page which is absent. */ |
| 814 | auto table_l2 = tables[l3_index]; |
| 815 | ASSERT_TRUE(arch_mm_pte_is_table(table_l2.first(1)[0], TOP_LEVEL)); |
| 816 | EXPECT_THAT(table_l2.subspan(1), Each(arch_mm_absent_pte(TOP_LEVEL))); |
| 817 | |
| 818 | auto table_l1 = get_table( |
| 819 | arch_mm_table_from_pte(table_l2.first(1)[0], TOP_LEVEL)); |
| 820 | ASSERT_TRUE(arch_mm_pte_is_table(table_l1.first(1)[0], TOP_LEVEL - 1)); |
| 821 | EXPECT_THAT(table_l1.subspan(1), |
| 822 | Each(arch_mm_absent_pte(TOP_LEVEL - 1))); |
| 823 | |
| 824 | auto table_l0 = get_table( |
| 825 | arch_mm_table_from_pte(table_l1.first(1)[0], TOP_LEVEL - 1)); |
| 826 | EXPECT_THAT(table_l0, Each(arch_mm_absent_pte(TOP_LEVEL - 2))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 827 | } |
| 828 | |
| 829 | /** |
| 830 | * Unmapping a range up to the maximum address causes the range end to wrap to |
| 831 | * zero as it is rounded up to a page boundary meaning no change is made. |
| 832 | * |
| 833 | * This serves as a form of documentation of behaviour rather than a |
| 834 | * requirement. Check whether any code relies on this before changing it. |
| 835 | */ |
| 836 | TEST_F(mm, unmap_last_address_quirk) |
| 837 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 838 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 839 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 840 | &ppool, nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 841 | ASSERT_TRUE(mm_vm_unmap( |
| 842 | &ptable, pa_init(0), |
| 843 | pa_init(std::numeric_limits<uintpaddr_t>::max()), &ppool)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 844 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 845 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 846 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 847 | _1, TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 848 | } |
| 849 | |
| 850 | /** |
| 851 | * Mapping then unmapping a page does not defrag the table. |
| 852 | */ |
| 853 | TEST_F(mm, unmap_does_not_defrag) |
| 854 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 855 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 856 | const paddr_t l0_begin = pa_init(5555 * PAGE_SIZE); |
| 857 | const paddr_t l0_end = pa_add(l0_begin, 13 * PAGE_SIZE); |
| 858 | const paddr_t l1_begin = pa_init(666 * mm_entry_size(1)); |
| 859 | const paddr_t l1_end = pa_add(l1_begin, 5 * mm_entry_size(1)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 860 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l0_begin, l0_end, mode, &ppool, |
| 861 | nullptr)); |
| 862 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l1_begin, l1_end, mode, &ppool, |
| 863 | nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 864 | ASSERT_TRUE(mm_vm_unmap(&ptable, l0_begin, l0_end, &ppool)); |
| 865 | ASSERT_TRUE(mm_vm_unmap(&ptable, l1_begin, l1_end, &ppool)); |
Andrew Scull | 164f815 | 2019-11-19 14:29:55 +0000 | [diff] [blame] | 866 | EXPECT_THAT(get_ptable(ptable), |
| 867 | AllOf(SizeIs(4), |
| 868 | Not(Each(Each(arch_mm_absent_pte(TOP_LEVEL)))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 869 | } |
| 870 | |
| 871 | /** |
| 872 | * Nothing is mapped in an empty table. |
| 873 | */ |
| 874 | TEST_F(mm, is_mapped_empty) |
| 875 | { |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 876 | EXPECT_FALSE(mm_vm_is_mapped(&ptable, ipa_init(0))); |
| 877 | EXPECT_FALSE(mm_vm_is_mapped(&ptable, ipa_init(0x8123'2344))); |
| 878 | EXPECT_FALSE(mm_vm_is_mapped(&ptable, ipa_init(0x1e0'0000'0073))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 879 | } |
| 880 | |
| 881 | /** |
| 882 | * Everything is mapped in a full table. |
| 883 | */ |
| 884 | TEST_F(mm, is_mapped_all) |
| 885 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 886 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 887 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 888 | &ppool, nullptr)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 889 | EXPECT_TRUE(mm_vm_is_mapped(&ptable, ipa_init(0))); |
| 890 | EXPECT_TRUE(mm_vm_is_mapped(&ptable, ipa_init(0xf247'a7b3))); |
| 891 | EXPECT_TRUE(mm_vm_is_mapped(&ptable, ipa_init(0x1ff'7bfa'983b))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 892 | } |
| 893 | |
| 894 | /** |
| 895 | * A page is mapped for the range [begin, end). |
| 896 | */ |
| 897 | TEST_F(mm, is_mapped_page) |
| 898 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 899 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 900 | const paddr_t page_begin = pa_init(0x100'0000'0000); |
| 901 | const paddr_t page_end = pa_add(page_begin, PAGE_SIZE); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 902 | ASSERT_TRUE(mm_vm_identity_map(&ptable, page_begin, page_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 903 | &ppool, nullptr)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 904 | EXPECT_TRUE(mm_vm_is_mapped(&ptable, ipa_from_pa(page_begin))); |
| 905 | EXPECT_TRUE( |
| 906 | mm_vm_is_mapped(&ptable, ipa_from_pa(pa_add(page_begin, 127)))); |
| 907 | EXPECT_FALSE(mm_vm_is_mapped(&ptable, ipa_from_pa(page_end))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 908 | } |
| 909 | |
| 910 | /** |
| 911 | * Everything out of range is not mapped. |
| 912 | */ |
| 913 | TEST_F(mm, is_mapped_out_of_range) |
| 914 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 915 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 916 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 917 | &ppool, nullptr)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 918 | EXPECT_FALSE(mm_vm_is_mapped(&ptable, ipa_from_pa(VM_MEM_END))); |
| 919 | EXPECT_FALSE(mm_vm_is_mapped(&ptable, ipa_init(0x1000'adb7'8123))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 920 | EXPECT_FALSE(mm_vm_is_mapped( |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 921 | &ptable, ipa_init(std::numeric_limits<uintpaddr_t>::max()))); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 922 | } |
| 923 | |
| 924 | /** |
| 925 | * The mode of unmapped addresses can be retrieved and is set to invalid, |
| 926 | * unowned and shared. |
| 927 | */ |
| 928 | TEST_F(mm, get_mode_empty) |
| 929 | { |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 930 | constexpr int default_mode = |
| 931 | MM_MODE_INVALID | MM_MODE_UNOWNED | MM_MODE_SHARED; |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 932 | mm_mode_t read_mode; |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 933 | |
| 934 | read_mode = 0; |
| 935 | EXPECT_TRUE( |
| 936 | mm_vm_get_mode(&ptable, ipa_init(0), ipa_init(20), &read_mode)); |
| 937 | EXPECT_THAT(read_mode, Eq(default_mode)); |
| 938 | |
| 939 | read_mode = 0; |
| 940 | EXPECT_TRUE(mm_vm_get_mode(&ptable, ipa_init(0x3c97'654d), |
| 941 | ipa_init(0x3c97'e000), &read_mode)); |
| 942 | EXPECT_THAT(read_mode, Eq(default_mode)); |
| 943 | |
| 944 | read_mode = 0; |
| 945 | EXPECT_TRUE(mm_vm_get_mode(&ptable, ipa_init(0x5f'ffff'ffff), |
| 946 | ipa_init(0x1ff'ffff'ffff), &read_mode)); |
| 947 | EXPECT_THAT(read_mode, Eq(default_mode)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 948 | } |
| 949 | |
| 950 | /** |
| 951 | * Get the mode of a range comprised of individual pages which are either side |
| 952 | * of a root table boundary. |
| 953 | */ |
| 954 | TEST_F(mm, get_mode_pages_across_tables) |
| 955 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 956 | constexpr mm_mode_t mode = MM_MODE_INVALID | MM_MODE_SHARED; |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 957 | const paddr_t map_begin = pa_init(0x180'0000'0000 - PAGE_SIZE); |
| 958 | const paddr_t map_end = pa_add(map_begin, 2 * PAGE_SIZE); |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 959 | mm_mode_t read_mode; |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 960 | ASSERT_TRUE(mm_vm_identity_map(&ptable, map_begin, map_end, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 961 | &ppool, nullptr)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 962 | |
| 963 | read_mode = 0; |
| 964 | EXPECT_TRUE(mm_vm_get_mode(&ptable, ipa_from_pa(map_begin), |
| 965 | ipa_from_pa(pa_add(map_begin, PAGE_SIZE)), |
| 966 | &read_mode)); |
| 967 | EXPECT_THAT(read_mode, Eq(mode)); |
| 968 | |
| 969 | EXPECT_FALSE(mm_vm_get_mode(&ptable, ipa_init(0), |
| 970 | ipa_from_pa(pa_add(map_begin, PAGE_SIZE)), |
| 971 | &read_mode)); |
| 972 | |
| 973 | read_mode = 0; |
| 974 | EXPECT_TRUE(mm_vm_get_mode(&ptable, ipa_from_pa(map_begin), |
| 975 | ipa_from_pa(map_end), &read_mode)); |
| 976 | EXPECT_THAT(read_mode, Eq(mode)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 977 | } |
| 978 | |
| 979 | /** |
| 980 | * Anything out of range fail to retrieve the mode. |
| 981 | */ |
| 982 | TEST_F(mm, get_mode_out_of_range) |
| 983 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 984 | constexpr mm_mode_t mode = MM_MODE_UNOWNED; |
| 985 | mm_mode_t read_mode; |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 986 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 987 | &ppool, nullptr)); |
Andrew Scull | 81e8509 | 2018-12-12 12:56:20 +0000 | [diff] [blame] | 988 | EXPECT_FALSE(mm_vm_get_mode(&ptable, ipa_init(0), |
| 989 | ipa_from_pa(pa_add(VM_MEM_END, 1)), |
| 990 | &read_mode)); |
| 991 | EXPECT_FALSE(mm_vm_get_mode(&ptable, ipa_from_pa(VM_MEM_END), |
| 992 | ipa_from_pa(pa_add(VM_MEM_END, 1)), |
| 993 | &read_mode)); |
| 994 | EXPECT_FALSE(mm_vm_get_mode(&ptable, ipa_init(0x1'1234'1234'1234), |
| 995 | ipa_init(2'0000'0000'0000), &read_mode)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 996 | } |
| 997 | |
| 998 | /** |
| 999 | * Defragging an entirely empty table has no effect. |
| 1000 | */ |
| 1001 | TEST_F(mm, defrag_empty) |
| 1002 | { |
Olivier Deprez | 6f40037 | 2022-03-07 09:31:08 +0100 | [diff] [blame] | 1003 | mm_vm_defrag(&ptable, &ppool, false); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 1004 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 1005 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 1006 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1007 | } |
| 1008 | |
| 1009 | /** |
| 1010 | * Defragging a table with some empty subtables (even nested) results in |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 1011 | * an empty table. |
| 1012 | */ |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1013 | TEST_F(mm, defrag_empty_subtables) |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 1014 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 1015 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1016 | const paddr_t l0_begin = pa_init(120000 * PAGE_SIZE); |
| 1017 | const paddr_t l0_end = pa_add(l0_begin, PAGE_SIZE); |
| 1018 | const paddr_t l1_begin = pa_init(3 * mm_entry_size(1)); |
| 1019 | const paddr_t l1_end = pa_add(l1_begin, 5 * mm_entry_size(1)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 1020 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l0_begin, l0_end, mode, &ppool, |
| 1021 | nullptr)); |
| 1022 | ASSERT_TRUE(mm_vm_identity_map(&ptable, l1_begin, l1_end, mode, &ppool, |
| 1023 | nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 1024 | ASSERT_TRUE(mm_vm_unmap(&ptable, l0_begin, l0_end, &ppool)); |
| 1025 | ASSERT_TRUE(mm_vm_unmap(&ptable, l1_begin, l1_end, &ppool)); |
Olivier Deprez | 6f40037 | 2022-03-07 09:31:08 +0100 | [diff] [blame] | 1026 | mm_vm_defrag(&ptable, &ppool, false); |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 1027 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 1028 | get_ptable(ptable), |
Andrew Scull | 3681b8d | 2018-12-12 14:22:59 +0000 | [diff] [blame] | 1029 | AllOf(SizeIs(4), Each(Each(arch_mm_absent_pte(TOP_LEVEL))))); |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 1030 | } |
| 1031 | |
| 1032 | /** |
| 1033 | * Any subtable with all blocks with the same attributes should be replaced |
| 1034 | * with a single block. |
| 1035 | */ |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1036 | TEST_F(mm, defrag_block_subtables) |
Andrew Walbran | 9fa106c | 2018-09-28 14:19:29 +0100 | [diff] [blame] | 1037 | { |
Karl Meakin | 07a69ab | 2025-02-07 14:53:19 +0000 | [diff] [blame^] | 1038 | constexpr mm_mode_t mode = 0; |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1039 | const paddr_t begin = pa_init(39456 * mm_entry_size(1)); |
| 1040 | const paddr_t middle = pa_add(begin, 67 * PAGE_SIZE); |
| 1041 | const paddr_t end = pa_add(begin, 4 * mm_entry_size(1)); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1042 | ASSERT_TRUE(mm_vm_identity_map(&ptable, pa_init(0), VM_MEM_END, mode, |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 1043 | &ppool, nullptr)); |
Andrew Scull | da24197 | 2019-01-05 18:17:48 +0000 | [diff] [blame] | 1044 | ASSERT_TRUE(mm_vm_unmap(&ptable, begin, end, &ppool)); |
Andrew Walbran | 8ec2b9f | 2019-11-25 15:05:40 +0000 | [diff] [blame] | 1045 | ASSERT_TRUE(mm_vm_identity_map(&ptable, begin, middle, mode, &ppool, |
| 1046 | nullptr)); |
| 1047 | ASSERT_TRUE(mm_vm_identity_map(&ptable, middle, end, mode, &ppool, |
| 1048 | nullptr)); |
Olivier Deprez | 6f40037 | 2022-03-07 09:31:08 +0100 | [diff] [blame] | 1049 | mm_vm_defrag(&ptable, &ppool, false); |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1050 | EXPECT_THAT( |
Andrew Scull | da3df7f | 2019-01-05 17:49:27 +0000 | [diff] [blame] | 1051 | get_ptable(ptable), |
Andrew Scull | 1ba470e | 2018-10-31 15:14:31 +0000 | [diff] [blame] | 1052 | AllOf(SizeIs(4), Each(Each(Truly(std::bind(arch_mm_pte_is_block, |
| 1053 | _1, TOP_LEVEL)))))); |
Andrew Walbran | 6324fc9 | 2018-10-03 11:46:43 +0100 | [diff] [blame] | 1054 | } |
| 1055 | |
Andrew Scull | 232d560 | 2018-10-15 11:07:45 +0100 | [diff] [blame] | 1056 | } /* namespace */ |
Andrew Scull | 3c25745 | 2019-11-26 13:32:50 +0000 | [diff] [blame] | 1057 | |
| 1058 | namespace mm_test |
| 1059 | { |
| 1060 | /** |
| 1061 | * Get an STL representation of the ptable. |
| 1062 | */ |
| 1063 | std::vector<std::span<pte_t, MM_PTE_PER_PAGE>> get_ptable( |
| 1064 | const struct mm_ptable &ptable) |
| 1065 | { |
| 1066 | std::vector<std::span<pte_t, MM_PTE_PER_PAGE>> all; |
| 1067 | const uint8_t root_table_count = arch_mm_stage2_root_table_count(); |
| 1068 | for (uint8_t i = 0; i < root_table_count; ++i) { |
| 1069 | all.push_back(get_table( |
| 1070 | pa_add(ptable.root, i * sizeof(struct mm_page_table)))); |
| 1071 | } |
| 1072 | return all; |
| 1073 | } |
| 1074 | |
| 1075 | } /* namespace mm_test */ |