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_FLAG_BITS > BITS_PER_LONG 9 int i; 10 11 /* All bits in higher flag values should be zero. */ 12 for (i = 1; i < NUM_VMA_FLAG_BITS / 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 #if NUM_VMA_FLAG_BITS > 64 120 /* 121 * Assert that VMA flag functions that operate at the system word level function 122 * correctly. 123 */ 124 static bool test_vma_flags_word(void) 125 { 126 vma_flags_t flags = EMPTY_VMA_FLAGS; 127 const vma_flags_t comparison = 128 mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT 129 130 , 64, 65 131 ); 132 133 /* Set some custom high flags. */ 134 vma_flags_set(&flags, 64, 65); 135 136 /* Now overwrite the first word. */ 137 vma_flags_overwrite_word(&flags, VM_READ | VM_WRITE); 138 /* Ensure they are equal. */ 139 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 140 141 flags = EMPTY_VMA_FLAGS; 142 vma_flags_set(&flags, 64, 65); 143 144 /* Do the same with the _once() equivalent. */ 145 vma_flags_overwrite_word_once(&flags, VM_READ | VM_WRITE); 146 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 147 148 flags = EMPTY_VMA_FLAGS; 149 vma_flags_set(&flags, 64, 65); 150 151 /* Make sure we can set a word without disturbing other bits. */ 152 vma_flags_set(&flags, VMA_WRITE_BIT); 153 vma_flags_set_word(&flags, VM_READ); 154 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 155 156 flags = EMPTY_VMA_FLAGS; 157 vma_flags_set(&flags, 64, 65); 158 159 /* Make sure we can clear a word without disturbing other bits. */ 160 vma_flags_set(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 161 vma_flags_clear_word(&flags, VM_EXEC); 162 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0); 163 164 return true; 165 } 166 #endif /* NUM_VMA_FLAG_BITS > 64 */ 167 168 /* Ensure that vma_flags_test() and friends works correctly. */ 169 static bool test_vma_flags_test(void) 170 { 171 const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 172 VMA_EXEC_BIT 173 #if NUM_VMA_FLAG_BITS > 64 174 , 64, 65 175 #endif 176 ); 177 struct vm_area_desc desc = { 178 .vma_flags = flags, 179 }; 180 181 #define do_test(_flag) \ 182 ASSERT_TRUE(vma_flags_test(&flags, _flag)); \ 183 ASSERT_TRUE(vma_desc_test(&desc, _flag)) 184 185 #define do_test_false(_flag) \ 186 ASSERT_FALSE(vma_flags_test(&flags, _flag)); \ 187 ASSERT_FALSE(vma_desc_test(&desc, _flag)) 188 189 do_test(VMA_READ_BIT); 190 do_test(VMA_WRITE_BIT); 191 do_test(VMA_EXEC_BIT); 192 #if NUM_VMA_FLAG_BITS > 64 193 do_test(64); 194 do_test(65); 195 #endif 196 do_test_false(VMA_MAYWRITE_BIT); 197 #if NUM_VMA_FLAG_BITS > 64 198 do_test_false(66); 199 #endif 200 201 #undef do_test 202 #undef do_test_false 203 204 return true; 205 } 206 207 /* Ensure that vma_flags_test_any() and friends works correctly. */ 208 static bool test_vma_flags_test_any(void) 209 { 210 const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 211 VMA_EXEC_BIT 212 #if NUM_VMA_FLAG_BITS > 64 213 , 64, 65 214 #endif 215 ); 216 struct vm_area_struct vma; 217 struct vm_area_desc desc; 218 219 vma.flags = flags; 220 desc.vma_flags = flags; 221 222 #define do_test(...) \ 223 ASSERT_TRUE(vma_flags_test_any(&flags, __VA_ARGS__)); \ 224 ASSERT_TRUE(vma_desc_test_any(&desc, __VA_ARGS__)) 225 226 #define do_test_all_true(...) \ 227 ASSERT_TRUE(vma_flags_test_all(&flags, __VA_ARGS__)); \ 228 ASSERT_TRUE(vma_test_all(&vma, __VA_ARGS__)) 229 230 #define do_test_all_false(...) \ 231 ASSERT_FALSE(vma_flags_test_all(&flags, __VA_ARGS__)); \ 232 ASSERT_FALSE(vma_test_all(&vma, __VA_ARGS__)) 233 234 /* 235 * Testing for some flags that are present, some that are not - should 236 * pass. ANY flags matching should work. 237 */ 238 do_test(VMA_READ_BIT, VMA_MAYREAD_BIT, VMA_SEQ_READ_BIT); 239 /* However, the ...test_all() variant should NOT pass. */ 240 do_test_all_false(VMA_READ_BIT, VMA_MAYREAD_BIT, VMA_SEQ_READ_BIT); 241 #if NUM_VMA_FLAG_BITS > 64 242 /* But should pass for flags present. */ 243 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 65); 244 /* Also subsets... */ 245 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64); 246 #endif 247 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 248 do_test_all_true(VMA_READ_BIT, VMA_WRITE_BIT); 249 do_test_all_true(VMA_READ_BIT); 250 /* 251 * Check _mask variant. We don't need to test extensively as macro 252 * helper is the equivalent. 253 */ 254 ASSERT_TRUE(vma_flags_test_any_mask(&flags, flags)); 255 ASSERT_TRUE(vma_flags_test_all_mask(&flags, flags)); 256 257 /* Single bits. */ 258 do_test(VMA_READ_BIT); 259 do_test(VMA_WRITE_BIT); 260 do_test(VMA_EXEC_BIT); 261 #if NUM_VMA_FLAG_BITS > 64 262 do_test(64); 263 do_test(65); 264 #endif 265 266 /* Two bits. */ 267 do_test(VMA_READ_BIT, VMA_WRITE_BIT); 268 do_test(VMA_READ_BIT, VMA_EXEC_BIT); 269 do_test(VMA_WRITE_BIT, VMA_EXEC_BIT); 270 /* Ordering shouldn't matter. */ 271 do_test(VMA_WRITE_BIT, VMA_READ_BIT); 272 do_test(VMA_EXEC_BIT, VMA_READ_BIT); 273 do_test(VMA_EXEC_BIT, VMA_WRITE_BIT); 274 #if NUM_VMA_FLAG_BITS > 64 275 do_test(VMA_READ_BIT, 64); 276 do_test(VMA_WRITE_BIT, 64); 277 do_test(64, VMA_READ_BIT); 278 do_test(64, VMA_WRITE_BIT); 279 do_test(VMA_READ_BIT, 65); 280 do_test(VMA_WRITE_BIT, 65); 281 do_test(65, VMA_READ_BIT); 282 do_test(65, VMA_WRITE_BIT); 283 #endif 284 /* Three bits. */ 285 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 286 #if NUM_VMA_FLAG_BITS > 64 287 /* No need to consider every single permutation. */ 288 do_test(VMA_READ_BIT, VMA_WRITE_BIT, 64); 289 do_test(VMA_READ_BIT, VMA_WRITE_BIT, 65); 290 291 /* Four bits. */ 292 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64); 293 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 65); 294 295 /* Five bits. */ 296 do_test(VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 65); 297 #endif 298 299 #undef do_test 300 #undef do_test_all_true 301 #undef do_test_all_false 302 303 return true; 304 } 305 306 /* Ensure that vma_flags_clear() and friends works correctly. */ 307 static bool test_vma_flags_clear(void) 308 { 309 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 310 VMA_EXEC_BIT 311 #if NUM_VMA_FLAG_BITS > 64 312 , 64, 65 313 #endif 314 ); 315 vma_flags_t mask = mk_vma_flags(VMA_EXEC_BIT 316 #if NUM_VMA_FLAG_BITS > 64 317 , 64 318 #endif 319 ); 320 struct vm_area_struct vma; 321 struct vm_area_desc desc; 322 323 vma.flags = flags; 324 desc.vma_flags = flags; 325 326 /* Cursory check of _mask() variant, as the helper macros imply. */ 327 vma_flags_clear_mask(&flags, mask); 328 vma_flags_clear_mask(&vma.flags, mask); 329 vma_desc_clear_flags_mask(&desc, mask); 330 #if NUM_VMA_FLAG_BITS > 64 331 ASSERT_FALSE(vma_flags_test_any(&flags, VMA_EXEC_BIT, 64)); 332 ASSERT_FALSE(vma_flags_test_any(&vma.flags, VMA_EXEC_BIT, 64)); 333 ASSERT_FALSE(vma_desc_test_any(&desc, VMA_EXEC_BIT, 64)); 334 /* Reset. */ 335 vma_flags_set(&flags, VMA_EXEC_BIT, 64); 336 vma_set_flags(&vma, VMA_EXEC_BIT, 64); 337 vma_desc_set_flags(&desc, VMA_EXEC_BIT, 64); 338 #endif 339 340 /* 341 * Clear the flags and assert clear worked, then reset flags back to 342 * include specified flags. 343 */ 344 #define do_test_and_reset(...) \ 345 vma_flags_clear(&flags, __VA_ARGS__); \ 346 vma_flags_clear(&vma.flags, __VA_ARGS__); \ 347 vma_desc_clear_flags(&desc, __VA_ARGS__); \ 348 ASSERT_FALSE(vma_flags_test_any(&flags, __VA_ARGS__)); \ 349 ASSERT_FALSE(vma_flags_test_any(&vma.flags, __VA_ARGS__)); \ 350 ASSERT_FALSE(vma_desc_test_any(&desc, __VA_ARGS__)); \ 351 vma_flags_set(&flags, __VA_ARGS__); \ 352 vma_set_flags(&vma, __VA_ARGS__); \ 353 vma_desc_set_flags(&desc, __VA_ARGS__) 354 355 /* Single flags. */ 356 do_test_and_reset(VMA_READ_BIT); 357 do_test_and_reset(VMA_WRITE_BIT); 358 do_test_and_reset(VMA_EXEC_BIT); 359 #if NUM_VMA_FLAG_BITS > 64 360 do_test_and_reset(64); 361 do_test_and_reset(65); 362 #endif 363 364 /* Two flags, in different orders. */ 365 do_test_and_reset(VMA_READ_BIT, VMA_WRITE_BIT); 366 do_test_and_reset(VMA_READ_BIT, VMA_EXEC_BIT); 367 #if NUM_VMA_FLAG_BITS > 64 368 do_test_and_reset(VMA_READ_BIT, 64); 369 do_test_and_reset(VMA_READ_BIT, 65); 370 #endif 371 do_test_and_reset(VMA_WRITE_BIT, VMA_READ_BIT); 372 do_test_and_reset(VMA_WRITE_BIT, VMA_EXEC_BIT); 373 #if NUM_VMA_FLAG_BITS > 64 374 do_test_and_reset(VMA_WRITE_BIT, 64); 375 do_test_and_reset(VMA_WRITE_BIT, 65); 376 #endif 377 do_test_and_reset(VMA_EXEC_BIT, VMA_READ_BIT); 378 do_test_and_reset(VMA_EXEC_BIT, VMA_WRITE_BIT); 379 #if NUM_VMA_FLAG_BITS > 64 380 do_test_and_reset(VMA_EXEC_BIT, 64); 381 do_test_and_reset(VMA_EXEC_BIT, 65); 382 do_test_and_reset(64, VMA_READ_BIT); 383 do_test_and_reset(64, VMA_WRITE_BIT); 384 do_test_and_reset(64, VMA_EXEC_BIT); 385 do_test_and_reset(64, 65); 386 do_test_and_reset(65, VMA_READ_BIT); 387 do_test_and_reset(65, VMA_WRITE_BIT); 388 do_test_and_reset(65, VMA_EXEC_BIT); 389 do_test_and_reset(65, 64); 390 #endif 391 392 /* Three flags. */ 393 394 #undef do_test_some_missing 395 #undef do_test_and_reset 396 397 return true; 398 } 399 400 /* Ensure that vma_flags_empty() works correctly. */ 401 static bool test_vma_flags_empty(void) 402 { 403 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 404 VMA_EXEC_BIT 405 #if NUM_VMA_FLAG_BITS > 64 406 , 64, 65 407 #endif 408 ); 409 410 ASSERT_FLAGS_NONEMPTY(&flags); 411 vma_flags_clear(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 412 #if NUM_VMA_FLAG_BITS > 64 413 ASSERT_FLAGS_NONEMPTY(&flags); 414 vma_flags_clear(&flags, 64, 65); 415 ASSERT_FLAGS_EMPTY(&flags); 416 #else 417 ASSERT_FLAGS_EMPTY(&flags); 418 #endif 419 420 return true; 421 } 422 423 /* Ensure that vma_flags_diff_pair() works correctly. */ 424 static bool test_vma_flags_diff(void) 425 { 426 vma_flags_t flags1 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 427 VMA_EXEC_BIT 428 #if NUM_VMA_FLAG_BITS > 64 429 , 64, 65 430 #endif 431 ); 432 433 vma_flags_t flags2 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 434 VMA_EXEC_BIT, VMA_MAYWRITE_BIT, 435 VMA_MAYEXEC_BIT 436 #if NUM_VMA_FLAG_BITS > 64 437 , 64, 65, 66, 67 438 #endif 439 ); 440 vma_flags_t diff = vma_flags_diff_pair(&flags1, &flags2); 441 442 #if NUM_VMA_FLAG_BITS > 64 443 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT, 66, 67); 444 #else 445 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT); 446 #endif 447 /* Should be the same even if re-ordered. */ 448 diff = vma_flags_diff_pair(&flags2, &flags1); 449 #if NUM_VMA_FLAG_BITS > 64 450 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT, 66, 67); 451 #else 452 ASSERT_FLAGS_SAME(&diff, VMA_MAYWRITE_BIT, VMA_MAYEXEC_BIT); 453 #endif 454 455 /* Should be no difference when applied against themselves. */ 456 diff = vma_flags_diff_pair(&flags1, &flags1); 457 ASSERT_FLAGS_EMPTY(&diff); 458 diff = vma_flags_diff_pair(&flags2, &flags2); 459 ASSERT_FLAGS_EMPTY(&diff); 460 461 /* One set of flags against an empty one should equal the original. */ 462 flags2 = EMPTY_VMA_FLAGS; 463 diff = vma_flags_diff_pair(&flags1, &flags2); 464 ASSERT_FLAGS_SAME_MASK(&diff, flags1); 465 466 /* A subset should work too. */ 467 flags2 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT); 468 diff = vma_flags_diff_pair(&flags1, &flags2); 469 #if NUM_VMA_FLAG_BITS > 64 470 ASSERT_FLAGS_SAME(&diff, VMA_EXEC_BIT, 64, 65); 471 #else 472 ASSERT_FLAGS_SAME(&diff, VMA_EXEC_BIT); 473 #endif 474 475 return true; 476 } 477 478 /* Ensure that vma_flags_and() and friends work correctly. */ 479 static bool test_vma_flags_and(void) 480 { 481 vma_flags_t flags1 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 482 VMA_EXEC_BIT 483 #if NUM_VMA_FLAG_BITS > 64 484 , 64, 65 485 #endif 486 ); 487 vma_flags_t flags2 = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT, 488 VMA_EXEC_BIT, VMA_MAYWRITE_BIT, 489 VMA_MAYEXEC_BIT 490 #if NUM_VMA_FLAG_BITS > 64 491 , 64, 65, 66, 67 492 #endif 493 ); 494 vma_flags_t flags3 = mk_vma_flags(VMA_IO_BIT, VMA_MAYBE_GUARD_BIT 495 #if NUM_VMA_FLAG_BITS > 64 496 , 68, 69 497 #endif 498 ); 499 vma_flags_t and = vma_flags_and_mask(&flags1, flags2); 500 501 #if NUM_VMA_FLAG_BITS > 64 502 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 503 64, 65); 504 #else 505 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 506 #endif 507 508 and = vma_flags_and_mask(&flags1, flags1); 509 ASSERT_FLAGS_SAME_MASK(&and, flags1); 510 511 and = vma_flags_and_mask(&flags2, flags2); 512 ASSERT_FLAGS_SAME_MASK(&and, flags2); 513 514 and = vma_flags_and_mask(&flags1, flags3); 515 ASSERT_FLAGS_EMPTY(&and); 516 and = vma_flags_and_mask(&flags2, flags3); 517 ASSERT_FLAGS_EMPTY(&and); 518 519 and = vma_flags_and(&flags1, VMA_READ_BIT); 520 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT); 521 522 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT); 523 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT); 524 525 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 526 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 527 528 #if NUM_VMA_FLAG_BITS > 64 529 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 530 64); 531 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64); 532 533 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 534 64, 65); 535 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 64, 536 65); 537 #endif 538 539 /* And against some missing values. */ 540 541 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 542 VMA_IO_BIT); 543 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 544 545 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 546 VMA_IO_BIT, VMA_RAND_READ_BIT); 547 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 548 549 #if NUM_VMA_FLAG_BITS > 64 550 and = vma_flags_and(&flags1, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT, 551 VMA_IO_BIT, VMA_RAND_READ_BIT, 69); 552 ASSERT_FLAGS_SAME(&and, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT); 553 #endif 554 555 return true; 556 } 557 558 /* Ensure append_vma_flags() acts as expected. */ 559 static bool test_append_vma_flags(void) 560 { 561 vma_flags_t flags = append_vma_flags(VMA_REMAP_FLAGS, VMA_READ_BIT, 562 VMA_WRITE_BIT 563 #if NUM_VMA_FLAG_BITS > 64 564 , 64, 65 565 #endif 566 ); 567 568 ASSERT_FLAGS_SAME(&flags, VMA_IO_BIT, VMA_PFNMAP_BIT, 569 VMA_DONTEXPAND_BIT, VMA_DONTDUMP_BIT, VMA_READ_BIT, 570 VMA_WRITE_BIT 571 #if NUM_VMA_FLAG_BITS > 64 572 , 64, 65 573 #endif 574 ); 575 576 flags = append_vma_flags(EMPTY_VMA_FLAGS, VMA_READ_BIT, VMA_WRITE_BIT); 577 ASSERT_FLAGS_SAME(&flags, VMA_READ_BIT, VMA_WRITE_BIT); 578 579 return true; 580 } 581 582 static void run_vma_tests(int *num_tests, int *num_fail) 583 { 584 TEST(copy_vma); 585 TEST(vma_flags_unchanged); 586 TEST(vma_flags_cleared); 587 #if NUM_VMA_FLAG_BITS > 64 588 TEST(vma_flags_word); 589 #endif 590 TEST(vma_flags_test); 591 TEST(vma_flags_test_any); 592 TEST(vma_flags_clear); 593 TEST(vma_flags_empty); 594 TEST(vma_flags_diff); 595 TEST(vma_flags_and); 596 TEST(append_vma_flags); 597 } 598