Lines Matching full:flags
41 mm_flags_t flags; /* Must use mm_flags_* helpers to access */
45 unsigned long flags;
163 /* Flags that reuse flags above. */
255 /* Despite the naming, these are FLAGS not bits. */
346 /* Temporary until VMA flags conversion complete. */
351 /* VMA basic access permission flags */
415 * Flags for bug emulation.
448 static __always_inline bool vma_flags_empty(const vma_flags_t *flags)
450 const unsigned long *bitmap = flags->__vma_flags;
555 * Flags, see mm.h.
560 vma_flags_t flags;
746 unsigned long flags;
794 return test_bit(flag, ACCESS_PRIVATE(&mm->flags, __mm_flags));
798 * Copy value to the first system word of VMA flags, non-atomically.
803 static __always_inline void vma_flags_overwrite_word(vma_flags_t *flags,
806 unsigned long *bitmap = flags->__vma_flags;
812 * Copy value to the first system word of VMA flags ONCE, non-atomically.
817 static __always_inline void vma_flags_overwrite_word_once(vma_flags_t *flags,
820 unsigned long *bitmap = flags->__vma_flags;
825 /* Update the first system word of VMA flags setting bits, non-atomically. */
826 static __always_inline void vma_flags_set_word(vma_flags_t *flags,
829 unsigned long *bitmap = flags->__vma_flags;
834 /* Update the first system word of VMA flags clearing bits, non-atomically. */
835 static __always_inline void vma_flags_clear_word(vma_flags_t *flags,
838 unsigned long *bitmap = flags->__vma_flags;
843 static __always_inline void vma_flags_clear_all(vma_flags_t *flags)
845 bitmap_zero(ACCESS_PRIVATE(flags, __vma_flags), NUM_VMA_FLAG_BITS);
850 * value. This is only valid if the input flags value can be expressed in a
853 * Will be removed once the conversion to VMA flags is complete.
855 static __always_inline vm_flags_t vma_flags_to_legacy(vma_flags_t flags)
857 return (vm_flags_t)flags.__vma_flags[0];
864 * Will be removed once the conversion to VMA flags is complete.
866 static __always_inline vma_flags_t legacy_to_vma_flags(vm_flags_t flags)
870 vma_flags_overwrite_word(&ret, flags);
874 static __always_inline void vma_flags_set_flag(vma_flags_t *flags,
877 unsigned long *bitmap = ACCESS_PRIVATE(flags, __vma_flags);
884 vm_flags_t flags)
886 vma_flags_clear_all(&vma->flags);
887 vma_flags_overwrite_word(&vma->flags, flags);
896 vm_flags_t flags)
899 vm_flags_init(vma, flags);
903 vma_flags_t *flags)
905 const unsigned long word = flags->__vma_flags[0];
908 vma_flags_overwrite_word_once(&vma->flags, word);
911 unsigned long *dst = &vma->flags.__vma_flags[1];
912 const unsigned long *src = &flags->__vma_flags[1];
919 vm_flags_t flags)
922 vma_flags_set_word(&vma->flags, flags);
926 vm_flags_t flags)
929 vma_flags_clear_word(&vma->flags, flags);
932 static __always_inline vma_flags_t __mk_vma_flags(vma_flags_t flags,
938 vma_flags_set_flag(&flags, bits[i]);
939 return flags;
945 #define append_vma_flags(flags, ...) __mk_vma_flags(flags, \
948 static __always_inline int vma_flags_count(const vma_flags_t *flags)
950 const unsigned long *bitmap = flags->__vma_flags;
955 static __always_inline bool vma_flags_test(const vma_flags_t *flags,
958 const unsigned long *bitmap = flags->__vma_flags;
963 static __always_inline vma_flags_t vma_flags_and_mask(const vma_flags_t *flags,
968 const unsigned long *bitmap = flags->__vma_flags;
975 #define vma_flags_and(flags, ...) \
976 vma_flags_and_mask(flags, mk_vma_flags(__VA_ARGS__))
978 static __always_inline bool vma_flags_test_any_mask(const vma_flags_t *flags,
981 const unsigned long *bitmap = flags->__vma_flags;
987 #define vma_flags_test_any(flags, ...) \
988 vma_flags_test_any_mask(flags, mk_vma_flags(__VA_ARGS__))
990 static __always_inline bool vma_flags_test_all_mask(const vma_flags_t *flags,
993 const unsigned long *bitmap = flags->__vma_flags;
999 #define vma_flags_test_all(flags, ...) \
1000 vma_flags_test_all_mask(flags, mk_vma_flags(__VA_ARGS__))
1002 static __always_inline bool vma_flags_test_single_mask(const vma_flags_t *flags,
1007 return vma_flags_test_any_mask(flags, flagmask);
1010 static __always_inline void vma_flags_set_mask(vma_flags_t *flags, vma_flags_t to_set)
1012 unsigned long *bitmap = flags->__vma_flags;
1018 #define vma_flags_set(flags, ...) \
1019 vma_flags_set_mask(flags, mk_vma_flags(__VA_ARGS__))
1021 static __always_inline void vma_flags_clear_mask(vma_flags_t *flags, vma_flags_t to_clear)
1023 unsigned long *bitmap = flags->__vma_flags;
1029 #define vma_flags_clear(flags, ...) \
1030 vma_flags_clear_mask(flags, mk_vma_flags(__VA_ARGS__))
1032 static __always_inline vma_flags_t vma_flags_diff_pair(const vma_flags_t *flags,
1037 const unsigned long *bitmap = flags->__vma_flags;
1044 static __always_inline bool vma_flags_same_pair(const vma_flags_t *flags,
1047 const unsigned long *bitmap = flags->__vma_flags;
1053 static __always_inline bool vma_flags_same_mask(const vma_flags_t *flags,
1056 const unsigned long *bitmap = flags->__vma_flags;
1062 #define vma_flags_same(flags, ...) \
1063 vma_flags_same_mask(flags, mk_vma_flags(__VA_ARGS__))
1068 return vma_flags_test(&vma->flags, bit);
1072 vma_flags_t flags)
1074 return vma_flags_test_any_mask(&vma->flags, flags);
1081 vma_flags_t flags)
1083 return vma_flags_test_all_mask(&vma->flags, flags);
1092 return vma_flags_test_single_mask(&vma->flags, flagmask);
1096 vma_flags_t flags)
1098 vma_flags_set_mask(&vma->flags, flags);
1105 vma_flags_t flags)
1107 vma_flags_clear_mask(&vma->flags, flags);
1120 vma_flags_t flags)
1122 return vma_flags_test_any_mask(&desc->vma_flags, flags);
1129 vma_flags_t flags)
1131 return vma_flags_test_all_mask(&desc->vma_flags, flags);
1138 vma_flags_t flags)
1140 vma_flags_set_mask(&desc->vma_flags, flags);
1147 vma_flags_t flags)
1149 vma_flags_clear_mask(&desc->vma_flags, flags);
1155 static inline bool is_shared_maywrite(const vma_flags_t *flags)
1157 return vma_flags_test_all(flags, VMA_SHARED_BIT, VMA_MAYWRITE_BIT);
1162 return is_shared_maywrite(&vma->flags);
1165 static inline bool vma_flags_is_cow_mapping(const vma_flags_t *flags)
1167 return vma_flags_test(flags, VMA_MAYWRITE_BIT) &&
1168 !vma_flags_test(flags, VMA_SHARED_BIT);
1173 return vma_flags_is_cow_mapping(&vma->flags);
1240 #define is_exec_mapping(flags) \
1241 ((flags & (VM_EXEC | VM_WRITE | VM_STACK)) == VM_EXEC)
1243 #define is_stack_mapping(flags) \
1244 (((flags & VM_STACK) == VM_STACK) || (flags & VM_SHADOW_STACK))
1246 #define is_data_mapping(flags) \
1247 ((flags & (VM_WRITE | VM_SHARED | VM_STACK)) == VM_WRITE)
1249 static inline void vm_stat_account(struct mm_struct *mm, vm_flags_t flags,
1254 if (is_exec_mapping(flags))
1256 else if (is_stack_mapping(flags))
1258 else if (is_data_mapping(flags))
1315 desc->vma_flags = vma->flags;
1622 return vma_flags_to_page_prot(vma->flags);