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