1 #ifndef _LINUX_RMAP_H 2 #define _LINUX_RMAP_H 3 /* 4 * Declarations for Reverse Mapping functions in mm/rmap.c 5 */ 6 7 #include <linux/list.h> 8 #include <linux/slab.h> 9 #include <linux/mm.h> 10 #include <linux/spinlock.h> 11 #include <linux/memcontrol.h> 12 13 /* 14 * The anon_vma heads a list of private "related" vmas, to scan if 15 * an anonymous page pointing to this anon_vma needs to be unmapped: 16 * the vmas on the list will be related by forking, or by splitting. 17 * 18 * Since vmas come and go as they are split and merged (particularly 19 * in mprotect), the mapping field of an anonymous page cannot point 20 * directly to a vma: instead it points to an anon_vma, on whose list 21 * the related vmas can be easily linked or unlinked. 22 * 23 * After unlinking the last vma on the list, we must garbage collect 24 * the anon_vma object itself: we're guaranteed no page can be 25 * pointing to this anon_vma once its vma list is empty. 26 */ 27 struct anon_vma { 28 spinlock_t lock; /* Serialize access to vma list */ 29 #ifdef CONFIG_KSM 30 atomic_t ksm_refcount; 31 #endif 32 /* 33 * NOTE: the LSB of the head.next is set by 34 * mm_take_all_locks() _after_ taking the above lock. So the 35 * head must only be read/written after taking the above lock 36 * to be sure to see a valid next pointer. The LSB bit itself 37 * is serialized by a system wide lock only visible to 38 * mm_take_all_locks() (mm_all_locks_mutex). 39 */ 40 struct list_head head; /* Chain of private "related" vmas */ 41 }; 42 43 /* 44 * The copy-on-write semantics of fork mean that an anon_vma 45 * can become associated with multiple processes. Furthermore, 46 * each child process will have its own anon_vma, where new 47 * pages for that process are instantiated. 48 * 49 * This structure allows us to find the anon_vmas associated 50 * with a VMA, or the VMAs associated with an anon_vma. 51 * The "same_vma" list contains the anon_vma_chains linking 52 * all the anon_vmas associated with this VMA. 53 * The "same_anon_vma" list contains the anon_vma_chains 54 * which link all the VMAs associated with this anon_vma. 55 */ 56 struct anon_vma_chain { 57 struct vm_area_struct *vma; 58 struct anon_vma *anon_vma; 59 struct list_head same_vma; /* locked by mmap_sem & page_table_lock */ 60 struct list_head same_anon_vma; /* locked by anon_vma->lock */ 61 }; 62 63 #ifdef CONFIG_MMU 64 #ifdef CONFIG_KSM 65 static inline void ksm_refcount_init(struct anon_vma *anon_vma) 66 { 67 atomic_set(&anon_vma->ksm_refcount, 0); 68 } 69 70 static inline int ksm_refcount(struct anon_vma *anon_vma) 71 { 72 return atomic_read(&anon_vma->ksm_refcount); 73 } 74 #else 75 static inline void ksm_refcount_init(struct anon_vma *anon_vma) 76 { 77 } 78 79 static inline int ksm_refcount(struct anon_vma *anon_vma) 80 { 81 return 0; 82 } 83 #endif /* CONFIG_KSM */ 84 85 static inline struct anon_vma *page_anon_vma(struct page *page) 86 { 87 if (((unsigned long)page->mapping & PAGE_MAPPING_FLAGS) != 88 PAGE_MAPPING_ANON) 89 return NULL; 90 return page_rmapping(page); 91 } 92 93 static inline void anon_vma_lock(struct vm_area_struct *vma) 94 { 95 struct anon_vma *anon_vma = vma->anon_vma; 96 if (anon_vma) 97 spin_lock(&anon_vma->lock); 98 } 99 100 static inline void anon_vma_unlock(struct vm_area_struct *vma) 101 { 102 struct anon_vma *anon_vma = vma->anon_vma; 103 if (anon_vma) 104 spin_unlock(&anon_vma->lock); 105 } 106 107 /* 108 * anon_vma helper functions. 109 */ 110 void anon_vma_init(void); /* create anon_vma_cachep */ 111 int anon_vma_prepare(struct vm_area_struct *); 112 void unlink_anon_vmas(struct vm_area_struct *); 113 int anon_vma_clone(struct vm_area_struct *, struct vm_area_struct *); 114 int anon_vma_fork(struct vm_area_struct *, struct vm_area_struct *); 115 void __anon_vma_link(struct vm_area_struct *); 116 void anon_vma_free(struct anon_vma *); 117 118 static inline void anon_vma_merge(struct vm_area_struct *vma, 119 struct vm_area_struct *next) 120 { 121 VM_BUG_ON(vma->anon_vma != next->anon_vma); 122 unlink_anon_vmas(next); 123 } 124 125 /* 126 * rmap interfaces called when adding or removing pte of page 127 */ 128 void page_move_anon_rmap(struct page *, struct vm_area_struct *, unsigned long); 129 void page_add_anon_rmap(struct page *, struct vm_area_struct *, unsigned long); 130 void page_add_new_anon_rmap(struct page *, struct vm_area_struct *, unsigned long); 131 void page_add_file_rmap(struct page *); 132 void page_remove_rmap(struct page *); 133 134 static inline void page_dup_rmap(struct page *page) 135 { 136 atomic_inc(&page->_mapcount); 137 } 138 139 /* 140 * Called from mm/vmscan.c to handle paging out 141 */ 142 int page_referenced(struct page *, int is_locked, 143 struct mem_cgroup *cnt, unsigned long *vm_flags); 144 int page_referenced_one(struct page *, struct vm_area_struct *, 145 unsigned long address, unsigned int *mapcount, unsigned long *vm_flags); 146 147 enum ttu_flags { 148 TTU_UNMAP = 0, /* unmap mode */ 149 TTU_MIGRATION = 1, /* migration mode */ 150 TTU_MUNLOCK = 2, /* munlock mode */ 151 TTU_ACTION_MASK = 0xff, 152 153 TTU_IGNORE_MLOCK = (1 << 8), /* ignore mlock */ 154 TTU_IGNORE_ACCESS = (1 << 9), /* don't age */ 155 TTU_IGNORE_HWPOISON = (1 << 10),/* corrupted page is recoverable */ 156 }; 157 #define TTU_ACTION(x) ((x) & TTU_ACTION_MASK) 158 159 int try_to_unmap(struct page *, enum ttu_flags flags); 160 int try_to_unmap_one(struct page *, struct vm_area_struct *, 161 unsigned long address, enum ttu_flags flags); 162 163 /* 164 * Called from mm/filemap_xip.c to unmap empty zero page 165 */ 166 pte_t *page_check_address(struct page *, struct mm_struct *, 167 unsigned long, spinlock_t **, int); 168 169 /* 170 * Used by swapoff to help locate where page is expected in vma. 171 */ 172 unsigned long page_address_in_vma(struct page *, struct vm_area_struct *); 173 174 /* 175 * Cleans the PTEs of shared mappings. 176 * (and since clean PTEs should also be readonly, write protects them too) 177 * 178 * returns the number of cleaned PTEs. 179 */ 180 int page_mkclean(struct page *); 181 182 /* 183 * called in munlock()/munmap() path to check for other vmas holding 184 * the page mlocked. 185 */ 186 int try_to_munlock(struct page *); 187 188 /* 189 * Called by memory-failure.c to kill processes. 190 */ 191 struct anon_vma *page_lock_anon_vma(struct page *page); 192 void page_unlock_anon_vma(struct anon_vma *anon_vma); 193 int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma); 194 195 /* 196 * Called by migrate.c to remove migration ptes, but might be used more later. 197 */ 198 int rmap_walk(struct page *page, int (*rmap_one)(struct page *, 199 struct vm_area_struct *, unsigned long, void *), void *arg); 200 201 #else /* !CONFIG_MMU */ 202 203 #define anon_vma_init() do {} while (0) 204 #define anon_vma_prepare(vma) (0) 205 #define anon_vma_link(vma) do {} while (0) 206 207 static inline int page_referenced(struct page *page, int is_locked, 208 struct mem_cgroup *cnt, 209 unsigned long *vm_flags) 210 { 211 *vm_flags = 0; 212 return 0; 213 } 214 215 #define try_to_unmap(page, refs) SWAP_FAIL 216 217 static inline int page_mkclean(struct page *page) 218 { 219 return 0; 220 } 221 222 223 #endif /* CONFIG_MMU */ 224 225 /* 226 * Return values of try_to_unmap 227 */ 228 #define SWAP_SUCCESS 0 229 #define SWAP_AGAIN 1 230 #define SWAP_FAIL 2 231 #define SWAP_MLOCK 3 232 233 #endif /* _LINUX_RMAP_H */ 234