Lines Matching defs:flags
3 static bool compare_legacy_flags(vm_flags_t legacy_flags, vma_flags_t flags)
7 const unsigned long flags_lower = flags.__vma_flags[0];
14 if (flags.__vma_flags[i] != 0)
23 ASSERT_FLAGS_SAME_MASK(&converted_flags, flags);
24 ASSERT_EQ(vma_flags_to_legacy(flags), legacy_flags);
109 vma_flags_t flags = EMPTY_VMA_FLAGS;
115 vma.flags = EMPTY_VMA_FLAGS;
123 /* Individual flags. */
124 vma_flags_set(&flags, bit);
125 ASSERT_TRUE(compare_legacy_flags(legacy_flags, flags));
128 vma_flags_set_mask(&flags, mask);
129 ASSERT_TRUE(compare_legacy_flags(legacy_flags, flags));
133 ASSERT_TRUE(compare_legacy_flags(legacy_flags, vma.flags));
135 ASSERT_TRUE(compare_legacy_flags(legacy_flags, vma.flags));
150 vma_flags_t flags;
154 memset(&flags, 1, sizeof(flags));
156 vma_flags_clear_all(&flags);
158 ASSERT_EQ(memcmp(&empty, &flags, sizeof(flags)), 0);
160 for (i = 0; i < sizeof(flags) / BITS_PER_LONG; i++) {
161 const unsigned long val = flags.__vma_flags[i];
176 vma_flags_t flags = EMPTY_VMA_FLAGS;
183 /* Set some custom high flags. */
184 vma_flags_set(&flags, 64, 65);
187 vma_flags_overwrite_word(&flags, VM_READ | VM_WRITE);
189 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
191 flags = EMPTY_VMA_FLAGS;
192 vma_flags_set(&flags, 64, 65);
195 vma_flags_overwrite_word_once(&flags, VM_READ | VM_WRITE);
196 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
198 flags = EMPTY_VMA_FLAGS;
199 vma_flags_set(&flags, 64, 65);
202 vma_flags_set(&flags, VMA_WRITE_BIT);
203 vma_flags_set_word(&flags, VM_READ);
204 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
206 flags = EMPTY_VMA_FLAGS;
207 vma_flags_set(&flags, 64, 65);
210 vma_flags_set(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT);
211 vma_flags_clear_word(&flags, VM_EXEC);
212 ASSERT_EQ(memcmp(&flags, &comparison, sizeof(flags)), 0);
221 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
228 .vma_flags = flags,
231 .flags = flags,
235 ASSERT_TRUE(vma_flags_test(&flags, _flag)); \
236 ASSERT_TRUE(vma_flags_test_single_mask(&flags, mk_vma_flags(_flag))); \
242 ASSERT_FALSE(vma_flags_test(&flags, _flag)); \
243 ASSERT_FALSE(vma_flags_test_single_mask(&flags, mk_vma_flags(_flag))); \
264 ASSERT_FALSE(vma_flags_test_single_mask(&flags, EMPTY_VMA_FLAGS));
266 /* Even when both flags and tested flag mask are empty! */
267 flags = EMPTY_VMA_FLAGS;
268 vma.flags = EMPTY_VMA_FLAGS;
269 ASSERT_FALSE(vma_flags_test_single_mask(&flags, EMPTY_VMA_FLAGS));
278 const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
285 .flags = flags,
288 .vma_flags = flags,
292 ASSERT_TRUE(vma_flags_test_any(&flags, __VA_ARGS__)); \
297 ASSERT_TRUE(vma_flags_test_all(&flags, __VA_ARGS__)); \
301 ASSERT_FALSE(vma_flags_test_all(&flags, __VA_ARGS__)); \
305 * Testing for some flags that are present, some that are not - should
306 * pass. ANY flags matching should work.
312 /* But should pass for flags present. */
324 ASSERT_TRUE(vma_flags_test_any_mask(&flags, flags));
325 ASSERT_TRUE(vma_flags_test_all_mask(&flags, flags));
369 /* Testing all flags against none trivially succeeds. */
370 ASSERT_TRUE(vma_flags_test_all_mask(&flags, EMPTY_VMA_FLAGS));
383 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
395 .flags = flags,
398 .vma_flags = flags,
402 vma_flags_clear_mask(&flags, mask);
406 ASSERT_FALSE(vma_flags_test_any(&flags, VMA_EXEC_BIT, 64));
410 vma_flags_set(&flags, VMA_EXEC_BIT, 64);
416 * Clear the flags and assert clear worked, then reset flags back to
417 * include specified flags.
420 vma_flags_clear(&flags, __VA_ARGS__); \
423 ASSERT_FALSE(vma_flags_test_any(&flags, __VA_ARGS__)); \
426 vma_flags_set(&flags, __VA_ARGS__); \
430 /* Single flags. */
439 /* Two flags, in different orders. */
467 /* Three flags. */
478 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
485 ASSERT_FLAGS_NONEMPTY(&flags);
486 vma_flags_clear(&flags, VMA_READ_BIT, VMA_WRITE_BIT, VMA_EXEC_BIT);
488 ASSERT_FLAGS_NONEMPTY(&flags);
489 vma_flags_clear(&flags, 64, 65);
490 ASSERT_FLAGS_EMPTY(&flags);
492 ASSERT_FLAGS_EMPTY(&flags);
536 /* One set of flags against an empty one should equal the original. */
636 vma_flags_t flags = append_vma_flags(VMA_REMAP_FLAGS, VMA_READ_BIT,
643 ASSERT_FLAGS_SAME(&flags, VMA_IO_BIT, VMA_PFNMAP_BIT,
651 flags = append_vma_flags(EMPTY_VMA_FLAGS, VMA_READ_BIT, VMA_WRITE_BIT);
652 ASSERT_FLAGS_SAME(&flags, VMA_READ_BIT, VMA_WRITE_BIT);
660 vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
668 ASSERT_EQ(vma_flags_count(&flags), 5);
669 vma_flags_clear(&flags, 64);
670 ASSERT_EQ(vma_flags_count(&flags), 4);
671 vma_flags_clear(&flags, 65);
673 ASSERT_EQ(vma_flags_count(&flags), 3);
674 vma_flags_clear(&flags, VMA_EXEC_BIT);
675 ASSERT_EQ(vma_flags_count(&flags), 2);
676 vma_flags_clear(&flags, VMA_WRITE_BIT);
677 ASSERT_EQ(vma_flags_count(&flags), 1);
678 vma_flags_clear(&flags, VMA_READ_BIT);
679 ASSERT_EQ(vma_flags_count(&flags), 0);