1 // SPDX-License-Identifier: GPL-2.0-or-later 2 3 static bool compare_legacy_flags(vm_flags_t legacy_flags, vma_flags_t flags) 4 { 5 const unsigned long legacy_val = legacy_flags; 6 /* The lower word should contain the precise same value. */ 7 const unsigned long flags_lower = flags.__vma_flags[0]; 8 #if NUM_VMA_FLAGS > BITS_PER_LONG 9 int i; 10 11 /* All bits in higher flag values should be zero. */ 12 for (i = 1; i < NUM_VMA_FLAGS / BITS_PER_LONG; i++) { 13 if (flags.__vma_flags[i] != 0) 14 return false; 15 } 16 #endif 17 18 static_assert(sizeof(legacy_flags) == sizeof(unsigned long)); 19 20 return legacy_val == flags_lower; 21 } 22 23 static bool test_copy_vma(void) 24 { 25 vm_flags_t vm_flags = VM_READ | VM_WRITE | VM_MAYREAD | VM_MAYWRITE; 26 struct mm_struct mm = {}; 27 bool need_locks = false; 28 VMA_ITERATOR(vmi, &mm, 0); 29 struct vm_area_struct *vma, *vma_new, *vma_next; 30 31 /* Move backwards and do not merge. */ 32 33 vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vm_flags); 34 vma_new = copy_vma(&vma, 0, 0x2000, 0, &need_locks); 35 ASSERT_NE(vma_new, vma); 36 ASSERT_EQ(vma_new->vm_start, 0); 37 ASSERT_EQ(vma_new->vm_end, 0x2000); 38 ASSERT_EQ(vma_new->vm_pgoff, 0); 39 vma_assert_attached(vma_new); 40 41 cleanup_mm(&mm, &vmi); 42 43 /* Move a VMA into position next to another and merge the two. */ 44 45 vma = alloc_and_link_vma(&mm, 0, 0x2000, 0, vm_flags); 46 vma_next = alloc_and_link_vma(&mm, 0x6000, 0x8000, 6, vm_flags); 47 vma_new = copy_vma(&vma, 0x4000, 0x2000, 4, &need_locks); 48 vma_assert_attached(vma_new); 49 50 ASSERT_EQ(vma_new, vma_next); 51 52 cleanup_mm(&mm, &vmi); 53 return true; 54 } 55 56 static bool test_vma_flags_unchanged(void) 57 { 58 vma_flags_t flags = EMPTY_VMA_FLAGS; 59 vm_flags_t legacy_flags = 0; 60 int bit; 61 struct vm_area_struct vma; 62 struct vm_area_desc desc; 63 64 65 vma.flags = EMPTY_VMA_FLAGS; 66 desc.vma_flags = EMPTY_VMA_FLAGS; 67 68 for (bit = 0; bit < BITS_PER_LONG; bit++) { 69 vma_flags_t mask = mk_vma_flags(bit); 70 71 legacy_flags |= (1UL << bit); 72 73 /* Individual flags. */ 74 vma_flags_set(&flags, bit); 75 ASSERT_TRUE(compare_legacy_flags(legacy_flags, flags)); 76 77 /* Via mask. */ 78 vma_flags_set_mask(&flags, mask); 79 ASSERT_TRUE(compare_legacy_flags(legacy_flags, flags)); 80 81 /* Same for VMA. */ 82 vma_set_flags(&vma, bit); 83 ASSERT_TRUE(compare_legacy_flags(legacy_flags, vma.flags)); 84 vma_set_flags_mask(&vma, mask); 85 ASSERT_TRUE(compare_legacy_flags(legacy_flags, vma.flags)); 86 87 /* Same for VMA descriptor. */ 88 vma_desc_set_flags(&desc, bit); 89 ASSERT_TRUE(compare_legacy_flags(legacy_flags, desc.vma_flags)); 90 vma_desc_set_flags_mask(&desc, mask); 91 ASSERT_TRUE(compare_legacy_flags(legacy_flags, desc.vma_flags)); 92 } 93 94 return true; 95 } 96 97 static bool test_vma_flags_cleared(void) 98 { 99 const vma_flags_t empty = EMPTY_VMA_FLAGS; 100 vma_flags_t flags; 101 int i; 102 103 /* Set all bits high. */ 104 memset(&flags, 1, sizeof(flags)); 105 /* Try to clear. */ 106 vma_flags_clear_all(&flags); 107 /* Equal to EMPTY_VMA_FLAGS? */ 108 ASSERT_EQ(memcmp(&empty, &flags, sizeof(flags)), 0); 109 /* Make sure every unsigned long entry in bitmap array zero. */ 110 for (i = 0; i < sizeof(flags) / BITS_PER_LONG; i++) { 111 const unsigned long val = flags.__vma_flags[i]; 112 113 ASSERT_EQ(val, 0); 114 } 115 116 return true; 117 } 118 119 /* 120 * Assert that VMA flag functions that operate at the system word level function 121 * correctly. 122 */ 123 static bool test_vma_flags_word(void) 124 { 125 vma_flags_t flags = EMPTY_VMA_FLAGS; 126 const vma_flags_t comparison = 127 mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 64, 65); 128 129 /* Set some custom high flags. */ 130 vma_flags_set(&flags, 64, 65); 131 /* Now overwrite the first word. */ 132 vma_flags_overwrite_word(&flags, VM_READ | VM_WRITE); 133 /* Ensure they are equal. */ 134 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 135 136 flags = EMPTY_VMA_FLAGS; 137 vma_flags_set(&flags, 64, 65); 138 139 /* Do the same with the _once() equivalent. */ 140 vma_flags_overwrite_word_once(&flags, VM_READ | VM_WRITE); 141 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 142 143 flags = EMPTY_VMA_FLAGS; 144 vma_flags_set(&flags, 64, 65); 145 146 /* Make sure we can set a word without disturbing other bits. */ 147 vma_flags_set(&flags, VMA_WRITE_BIT); 148 vma_flags_set_word(&flags, VM_READ); 149 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 150 151 flags = EMPTY_VMA_FLAGS; 152 vma_flags_set(&flags, 64, 65); 153 154 /* Make sure we can clear a word without disturbing other bits. */ 155 vma_flags_set(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 156 vma_flags_clear_word(&flags, VM_EXEC); 157 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 158 159 return true; 160 } 161 162 /* Ensure that vma_flags_test() and friends works correctly. */ 163 static bool test_vma_flags_test(void) 164 { 165 const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 166 VMA_EXEC_BIT, 64, 65); 167 struct vm_area_desc desc = { 168 .vma_flags = flags, 169 }; 170 171 #define do_test(_flag) \ 172 ASSERT_TRUE(vma_flags_test(&flags, _flag)); \ 173 ASSERT_TRUE(vma_desc_test(&desc, _flag)) 174 175 #define do_test_false(_flag) \ 176 ASSERT_FALSE(vma_flags_test(&flags, _flag)); \ 177 ASSERT_FALSE(vma_desc_test(&desc, _flag)) 178 179 do_test(VMA_READ_BIT); 180 do_test(VMA_WRITE_BIT); 181 do_test(VMA_EXEC_BIT); 182 #if NUM_VMA_FLAG_BITS > 64 183 do_test(64); 184 do_test(65); 185 #endif 186 do_test_false(VMA_MAYWRITE_BIT); 187 #if NUM_VMA_FLAG_BITS > 64 188 do_test_false(66); 189 #endif 190 191 #undef do_test 192 #undef do_test_false 193 194 return true; 195 } 196 197 /* Ensure that vma_flags_test_any() and friends works correctly. */ 198 static bool test_vma_flags_test_any(void) 199 { 200 const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 201 VMA_EXEC_BIT, 64, 65); 202 struct vm_area_struct vma; 203 struct vm_area_desc desc; 204 205 vma.flags = flags; 206 desc.vma_flags = flags; 207 208 #define do_test(...) \ 209 ASSERT_TRUE(vma_flags_test_any(&flags, __VA_ARGS__)); \ 210 ASSERT_TRUE(vma_desc_test_any(&desc, __VA_ARGS__)) 211 212 #define do_test_all_true(...) \ 213 ASSERT_TRUE(vma_flags_test_all(&flags, __VA_ARGS__)); \ 214 ASSERT_TRUE(vma_test_all(&vma, __VA_ARGS__)) 215 216 #define do_test_all_false(...) \ 217 ASSERT_FALSE(vma_flags_test_all(&flags, __VA_ARGS__)); \ 218 ASSERT_FALSE(vma_test_all(&vma, __VA_ARGS__)) 219 220 /* 221 * Testing for some flags that are present, some that are not - should 222 * pass. ANY flags matching should work. 223 */ 224 do_test(VMA_READ_BIT, VMA_MAYREAD_BIT, VMA_SEQ_READ_BIT); 225 /* However, the ...test_all() variant should NOT pass. */ 226 do_test_all_false(VMA_READ_BIT, VMA_MAYREAD_BIT, VMA_SEQ_READ_BIT); 227 /* But should pass for flags present. */ 228 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 65); 229 /* Also subsets... */ 230 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64); 231 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 232 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT); 233 do_test_all_true(VMA_READ_BIT); 234 /* 235 * Check _mask variant. We don't need to test extensively as macro 236 * helper is the equivalent. 237 */ 238 ASSERT_TRUE(vma_flags_test_any_mask(&flags, flags)); 239 ASSERT_TRUE(vma_flags_test_all_mask(&flags, flags)); 240 241 /* Single bits. */ 242 do_test(VMA_READ_BIT); 243 do_test(VMA_WRITE_BIT); 244 do_test(VMA_EXEC_BIT); 245 #if NUM_VMA_FLAG_BITS > 64 246 do_test(64); 247 do_test(65); 248 #endif 249 250 /* Two bits. */ 251 do_test(VMA_READ_BIT, VMA_WRITE_BIT); 252 do_test(VMA_READ_BIT, VMA_EXEC_BIT); 253 do_test(VMA_WRITE_BIT, VMA_EXEC_BIT); 254 /* Ordering shouldn't matter. */ 255 do_test(VMA_WRITE_BIT, VMA_READ_BIT); 256 do_test(VMA_EXEC_BIT, VMA_READ_BIT); 257 do_test(VMA_EXEC_BIT, VMA_WRITE_BIT); 258 #if NUM_VMA_FLAG_BITS > 64 259 do_test(VMA_READ_BIT, 64); 260 do_test(VMA_WRITE_BIT, 64); 261 do_test(64, VMA_READ_BIT); 262 do_test(64, VMA_WRITE_BIT); 263 do_test(VMA_READ_BIT, 65); 264 do_test(VMA_WRITE_BIT, 65); 265 do_test(65, VMA_READ_BIT); 266 do_test(65, VMA_WRITE_BIT); 267 #endif 268 /* Three bits. */ 269 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 270 #if NUM_VMA_FLAG_BITS > 64 271 /* No need to consider every single permutation. */ 272 do_test(VMA_READ_BIT, VMA_WRITE_BIT, 64); 273 do_test(VMA_READ_BIT, VMA_WRITE_BIT, 65); 274 275 /* Four bits. */ 276 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64); 277 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 65); 278 279 /* Five bits. */ 280 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 65); 281 #endif 282 283 #undef do_test 284 #undef do_test_all_true 285 #undef do_test_all_false 286 287 return true; 288 } 289 290 /* Ensure that vma_flags_clear() and friends works correctly. */ 291 static bool test_vma_flags_clear(void) 292 { 293 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 294 VMA_EXEC_BIT, 64, 65); 295 vma_flags_t mask = mk_vma_flags(VMA_EXEC_BIT, 64); 296 struct vm_area_struct vma; 297 struct vm_area_desc desc; 298 299 vma.flags = flags; 300 desc.vma_flags = flags; 301 302 /* Cursory check of _mask() variant, as the helper macros imply. */ 303 vma_flags_clear_mask(&flags, mask); 304 vma_flags_clear_mask(&vma.flags, mask); 305 vma_desc_clear_flags_mask(&desc, mask); 306 ASSERT_FALSE(vma_flags_test_any(&flags, VMA_EXEC_BIT, 64)); 307 ASSERT_FALSE(vma_flags_test_any(&vma.flags, VMA_EXEC_BIT, 64)); 308 ASSERT_FALSE(vma_desc_test_any(&desc, VMA_EXEC_BIT, 64)); 309 /* Reset. */ 310 vma_flags_set(&flags, VMA_EXEC_BIT, 64); 311 vma_set_flags(&vma, VMA_EXEC_BIT, 64); 312 vma_desc_set_flags(&desc, VMA_EXEC_BIT, 64); 313 314 /* 315 * Clear the flags and assert clear worked, then reset flags back to 316 * include specified flags. 317 */ 318 #define do_test_and_reset(...) \ 319 vma_flags_clear(&flags, __VA_ARGS__); \ 320 vma_flags_clear(&vma.flags, __VA_ARGS__); \ 321 vma_desc_clear_flags(&desc, __VA_ARGS__); \ 322 ASSERT_FALSE(vma_flags_test_any(&flags, __VA_ARGS__)); \ 323 ASSERT_FALSE(vma_flags_test_any(&vma.flags, __VA_ARGS__)); \ 324 ASSERT_FALSE(vma_desc_test_any(&desc, __VA_ARGS__)); \ 325 vma_flags_set(&flags, __VA_ARGS__); \ 326 vma_set_flags(&vma, __VA_ARGS__); \ 327 vma_desc_set_flags(&desc, __VA_ARGS__) 328 329 /* Single flags. */ 330 do_test_and_reset(VMA_READ_BIT); 331 do_test_and_reset(VMA_WRITE_BIT); 332 do_test_and_reset(VMA_EXEC_BIT); 333 do_test_and_reset(64); 334 do_test_and_reset(65); 335 336 /* Two flags, in different orders. */ 337 do_test_and_reset(VMA_READ_BIT, VMA_WRITE_BIT); 338 do_test_and_reset(VMA_READ_BIT, VMA_EXEC_BIT); 339 do_test_and_reset(VMA_READ_BIT, 64); 340 do_test_and_reset(VMA_READ_BIT, 65); 341 do_test_and_reset(VMA_WRITE_BIT, VMA_READ_BIT); 342 do_test_and_reset(VMA_WRITE_BIT, VMA_EXEC_BIT); 343 do_test_and_reset(VMA_WRITE_BIT, 64); 344 do_test_and_reset(VMA_WRITE_BIT, 65); 345 do_test_and_reset(VMA_EXEC_BIT, VMA_READ_BIT); 346 do_test_and_reset(VMA_EXEC_BIT, VMA_WRITE_BIT); 347 do_test_and_reset(VMA_EXEC_BIT, 64); 348 do_test_and_reset(VMA_EXEC_BIT, 65); 349 do_test_and_reset(64, VMA_READ_BIT); 350 do_test_and_reset(64, VMA_WRITE_BIT); 351 do_test_and_reset(64, VMA_EXEC_BIT); 352 do_test_and_reset(64, 65); 353 do_test_and_reset(65, VMA_READ_BIT); 354 do_test_and_reset(65, VMA_WRITE_BIT); 355 do_test_and_reset(65, VMA_EXEC_BIT); 356 do_test_and_reset(65, 64); 357 358 /* Three flags. */ 359 360 #undef do_test_some_missing 361 #undef do_test_and_reset 362 363 return true; 364 } 365 366 static void run_vma_tests(int *num_tests, int *num_fail) 367 { 368 TEST(copy_vma); 369 TEST(vma_flags_unchanged); 370 TEST(vma_flags_cleared); 371 TEST(vma_flags_word); 372 TEST(vma_flags_test); 373 TEST(vma_flags_test_any); 374 TEST(vma_flags_clear); 375 } 376