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