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 vma_flags_t vma_flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 26 VMA_MAYREAD_BIT, VMA_MAYWRITE_BIT); 27 struct mm_struct mm = {}; 28 bool need_locks = false; 29 VMA_ITERATOR(vmi, &mm, 0); 30 struct vm_area_struct *vma, *vma_new, *vma_next; 31 32 /* Move backwards and do not merge. */ 33 34 vma = alloc_and_link_vma(&mm, 0x3000, 0x5000, 3, vma_flags); 35 vma_new = copy_vma(&vma, 0, 0x2000, 0, &need_locks); 36 ASSERT_NE(vma_new, vma); 37 ASSERT_EQ(vma_new->vm_start, 0); 38 ASSERT_EQ(vma_new->vm_end, 0x2000); 39 ASSERT_EQ(vma_new->vm_pgoff, 0); 40 vma_assert_attached(vma_new); 41 42 cleanup_mm(&mm, &vmi); 43 44 /* Move a VMA into position next to another and merge the two. */ 45 46 vma = alloc_and_link_vma(&mm, 0, 0x2000, 0, vma_flags); 47 vma_next = alloc_and_link_vma(&mm, 0x6000, 0x8000, 6, vma_flags); 48 vma_new = copy_vma(&vma, 0x4000, 0x2000, 4, &need_locks); 49 vma_assert_attached(vma_new); 50 51 ASSERT_EQ(vma_new, vma_next); 52 53 cleanup_mm(&mm, &vmi); 54 return true; 55 } 56 57 static bool test_vma_flags_unchanged(void) 58 { 59 vma_flags_t flags = EMPTY_VMA_FLAGS; 60 vm_flags_t legacy_flags = 0; 61 int bit; 62 struct vm_area_struct vma; 63 struct vm_area_desc desc; 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 /* Ensure that vma_flags_empty() works correctly. */ 367 static bool test_vma_flags_empty(void) 368 { 369 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 370 VMA_EXEC_BIT, 64, 65); 371 372 ASSERT_FLAGS_NONEMPTY(&flags); 373 vma_flags_clear(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 374 #if NUM_VMA_FLAG_BITS > 64 375 ASSERT_FLAGS_NONEMPTY(&flags); 376 vma_flags_clear(&flags, 64, 65); 377 ASSERT_FLAGS_EMPTY(&flags); 378 #else 379 ASSERT_FLAGS_EMPTY(&flags); 380 #endif 381 382 return true; 383 } 384 385 /* Ensure that vma_flags_diff_pair() works correctly. */ 386 static bool test_vma_flags_diff(void) 387 { 388 vma_flags_t flags1 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 389 VMA_EXEC_BIT, 64, 65); 390 vma_flags_t flags2 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 391 VMA_EXEC_BIT, VMA_MAYWRITE_BIT, 392 VMA_MAYEXEC_BIT, 64, 65, 66, 67); 393 vma_flags_t diff = vma_flags_diff_pair(&flags1, &flags2); 394 395 #if NUM_VMA_FLAG_BITS > 64 396 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT, 66, 67); 397 #else 398 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT); 399 #endif 400 /* Should be the same even if re-ordered. */ 401 diff = vma_flags_diff_pair(&flags2, &flags1); 402 #if NUM_VMA_FLAG_BITS > 64 403 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT, 66, 67); 404 #else 405 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT); 406 #endif 407 408 /* Should be no difference when applied against themselves. */ 409 diff = vma_flags_diff_pair(&flags1, &flags1); 410 ASSERT_FLAGS_EMPTY(&diff); 411 diff = vma_flags_diff_pair(&flags2, &flags2); 412 ASSERT_FLAGS_EMPTY(&diff); 413 414 /* One set of flags against an empty one should equal the original. */ 415 flags2 = EMPTY_VMA_FLAGS; 416 diff = vma_flags_diff_pair(&flags1, &flags2); 417 ASSERT_FLAGS_SAME_MASK(&diff, flags1); 418 419 /* A subset should work too. */ 420 flags2 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT); 421 diff = vma_flags_diff_pair(&flags1, &flags2); 422 #if NUM_VMA_FLAG_BITS > 64 423 ASSERT_FLAGS_SAME(&diff, VMA_EXEC_BIT, 64, 65); 424 #else 425 ASSERT_FLAGS_SAME(&diff, VMA_EXEC_BIT); 426 #endif 427 428 return true; 429 } 430 431 /* Ensure that vma_flags_and() and friends work correctly. */ 432 static bool test_vma_flags_and(void) 433 { 434 vma_flags_t flags1 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 435 VMA_EXEC_BIT, 64, 65); 436 vma_flags_t flags2 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 437 VMA_EXEC_BIT, VMA_MAYWRITE_BIT, 438 VMA_MAYEXEC_BIT, 64, 65, 66, 67); 439 vma_flags_t flags3 = mk_vma_flags(VMA_IO_BIT, VMA_MAYBE_GUARD_BIT, 440 68, 69); 441 vma_flags_t and = vma_flags_and_mask(&flags1, flags2); 442 443 #if NUM_VMA_FLAG_BITS > 64 444 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 445 64, 65); 446 #else 447 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 448 #endif 449 450 and = vma_flags_and_mask(&flags1, flags1); 451 ASSERT_FLAGS_SAME_MASK(&and, flags1); 452 453 and = vma_flags_and_mask(&flags2, flags2); 454 ASSERT_FLAGS_SAME_MASK(&and, flags2); 455 456 and = vma_flags_and_mask(&flags1, flags3); 457 ASSERT_FLAGS_EMPTY(&and); 458 and = vma_flags_and_mask(&flags2, flags3); 459 ASSERT_FLAGS_EMPTY(&and); 460 461 and = vma_flags_and(&flags1, VMA_READ_BIT); 462 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT); 463 464 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT); 465 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT); 466 467 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 468 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 469 470 #if NUM_VMA_FLAG_BITS > 64 471 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 472 64); 473 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64); 474 475 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 476 64, 65); 477 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 478 65); 479 #endif 480 481 /* And against some missing values. */ 482 483 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 484 VMA_IO_BIT); 485 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 486 487 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 488 VMA_IO_BIT, VMA_RAND_READ_BIT); 489 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 490 491 #if NUM_VMA_FLAG_BITS > 64 492 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 493 VMA_IO_BIT, VMA_RAND_READ_BIT, 69); 494 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 495 #endif 496 497 return true; 498 } 499 500 static void run_vma_tests(int *num_tests, int *num_fail) 501 { 502 TEST(copy_vma); 503 TEST(vma_flags_unchanged); 504 TEST(vma_flags_cleared); 505 TEST(vma_flags_word); 506 TEST(vma_flags_test); 507 TEST(vma_flags_test_any); 508 TEST(vma_flags_clear); 509 TEST(vma_flags_empty); 510 TEST(vma_flags_diff); 511 TEST(vma_flags_and); 512 } 513