]>
Commit | Line | Data |
---|---|---|
ace71a19 KS |
1 | #include <linux/mm.h> |
2 | #include <linux/rmap.h> | |
3 | #include <linux/hugetlb.h> | |
4 | #include <linux/swap.h> | |
5 | #include <linux/swapops.h> | |
6 | ||
7 | #include "internal.h" | |
8 | ||
9 | static inline bool check_pmd(struct page_vma_mapped_walk *pvmw) | |
10 | { | |
11 | pmd_t pmde; | |
12 | /* | |
13 | * Make sure we don't re-load pmd between present and !trans_huge check. | |
14 | * We need a consistent view. | |
15 | */ | |
16 | pmde = READ_ONCE(*pvmw->pmd); | |
17 | return pmd_present(pmde) && !pmd_trans_huge(pmde); | |
18 | } | |
19 | ||
20 | static inline bool not_found(struct page_vma_mapped_walk *pvmw) | |
21 | { | |
22 | page_vma_mapped_walk_done(pvmw); | |
23 | return false; | |
24 | } | |
25 | ||
26 | static bool map_pte(struct page_vma_mapped_walk *pvmw) | |
27 | { | |
28 | pvmw->pte = pte_offset_map(pvmw->pmd, pvmw->address); | |
29 | if (!(pvmw->flags & PVMW_SYNC)) { | |
30 | if (pvmw->flags & PVMW_MIGRATION) { | |
31 | if (!is_swap_pte(*pvmw->pte)) | |
32 | return false; | |
33 | } else { | |
34 | if (!pte_present(*pvmw->pte)) | |
35 | return false; | |
36 | } | |
37 | } | |
38 | pvmw->ptl = pte_lockptr(pvmw->vma->vm_mm, pvmw->pmd); | |
39 | spin_lock(pvmw->ptl); | |
40 | return true; | |
41 | } | |
42 | ||
43 | static bool check_pte(struct page_vma_mapped_walk *pvmw) | |
44 | { | |
45 | if (pvmw->flags & PVMW_MIGRATION) { | |
46 | #ifdef CONFIG_MIGRATION | |
47 | swp_entry_t entry; | |
48 | if (!is_swap_pte(*pvmw->pte)) | |
49 | return false; | |
50 | entry = pte_to_swp_entry(*pvmw->pte); | |
51 | if (!is_migration_entry(entry)) | |
52 | return false; | |
53 | if (migration_entry_to_page(entry) - pvmw->page >= | |
54 | hpage_nr_pages(pvmw->page)) { | |
55 | return false; | |
56 | } | |
57 | if (migration_entry_to_page(entry) < pvmw->page) | |
58 | return false; | |
59 | #else | |
60 | WARN_ON_ONCE(1); | |
61 | #endif | |
62 | } else { | |
63 | if (!pte_present(*pvmw->pte)) | |
64 | return false; | |
65 | ||
66 | /* THP can be referenced by any subpage */ | |
67 | if (pte_page(*pvmw->pte) - pvmw->page >= | |
68 | hpage_nr_pages(pvmw->page)) { | |
69 | return false; | |
70 | } | |
71 | if (pte_page(*pvmw->pte) < pvmw->page) | |
72 | return false; | |
73 | } | |
74 | ||
75 | return true; | |
76 | } | |
77 | ||
78 | /** | |
79 | * page_vma_mapped_walk - check if @pvmw->page is mapped in @pvmw->vma at | |
80 | * @pvmw->address | |
81 | * @pvmw: pointer to struct page_vma_mapped_walk. page, vma, address and flags | |
82 | * must be set. pmd, pte and ptl must be NULL. | |
83 | * | |
84 | * Returns true if the page is mapped in the vma. @pvmw->pmd and @pvmw->pte point | |
85 | * to relevant page table entries. @pvmw->ptl is locked. @pvmw->address is | |
86 | * adjusted if needed (for PTE-mapped THPs). | |
87 | * | |
88 | * If @pvmw->pmd is set but @pvmw->pte is not, you have found PMD-mapped page | |
89 | * (usually THP). For PTE-mapped THP, you should run page_vma_mapped_walk() in | |
90 | * a loop to find all PTEs that map the THP. | |
91 | * | |
92 | * For HugeTLB pages, @pvmw->pte is set to the relevant page table entry | |
93 | * regardless of which page table level the page is mapped at. @pvmw->pmd is | |
94 | * NULL. | |
95 | * | |
96 | * Retruns false if there are no more page table entries for the page in | |
97 | * the vma. @pvmw->ptl is unlocked and @pvmw->pte is unmapped. | |
98 | * | |
99 | * If you need to stop the walk before page_vma_mapped_walk() returned false, | |
100 | * use page_vma_mapped_walk_done(). It will do the housekeeping. | |
101 | */ | |
102 | bool page_vma_mapped_walk(struct page_vma_mapped_walk *pvmw) | |
103 | { | |
104 | struct mm_struct *mm = pvmw->vma->vm_mm; | |
105 | struct page *page = pvmw->page; | |
106 | pgd_t *pgd; | |
c2febafc | 107 | p4d_t *p4d; |
ace71a19 KS |
108 | pud_t *pud; |
109 | ||
110 | /* The only possible pmd mapping has been handled on last iteration */ | |
111 | if (pvmw->pmd && !pvmw->pte) | |
112 | return not_found(pvmw); | |
113 | ||
d75450ff | 114 | if (pvmw->pte) |
ace71a19 | 115 | goto next_pte; |
ace71a19 KS |
116 | |
117 | if (unlikely(PageHuge(pvmw->page))) { | |
118 | /* when pud is not present, pte will be NULL */ | |
7868a208 PA |
119 | pvmw->pte = huge_pte_offset(mm, pvmw->address, |
120 | PAGE_SIZE << compound_order(page)); | |
ace71a19 KS |
121 | if (!pvmw->pte) |
122 | return false; | |
123 | ||
124 | pvmw->ptl = huge_pte_lockptr(page_hstate(page), mm, pvmw->pte); | |
125 | spin_lock(pvmw->ptl); | |
126 | if (!check_pte(pvmw)) | |
127 | return not_found(pvmw); | |
128 | return true; | |
129 | } | |
130 | restart: | |
131 | pgd = pgd_offset(mm, pvmw->address); | |
132 | if (!pgd_present(*pgd)) | |
133 | return false; | |
c2febafc KS |
134 | p4d = p4d_offset(pgd, pvmw->address); |
135 | if (!p4d_present(*p4d)) | |
136 | return false; | |
137 | pud = pud_offset(p4d, pvmw->address); | |
ace71a19 KS |
138 | if (!pud_present(*pud)) |
139 | return false; | |
140 | pvmw->pmd = pmd_offset(pud, pvmw->address); | |
141 | if (pmd_trans_huge(*pvmw->pmd)) { | |
142 | pvmw->ptl = pmd_lock(mm, pvmw->pmd); | |
143 | if (!pmd_present(*pvmw->pmd)) | |
144 | return not_found(pvmw); | |
145 | if (likely(pmd_trans_huge(*pvmw->pmd))) { | |
146 | if (pvmw->flags & PVMW_MIGRATION) | |
147 | return not_found(pvmw); | |
148 | if (pmd_page(*pvmw->pmd) != page) | |
149 | return not_found(pvmw); | |
150 | return true; | |
151 | } else { | |
152 | /* THP pmd was split under us: handle on pte level */ | |
153 | spin_unlock(pvmw->ptl); | |
154 | pvmw->ptl = NULL; | |
155 | } | |
156 | } else { | |
157 | if (!check_pmd(pvmw)) | |
158 | return false; | |
159 | } | |
160 | if (!map_pte(pvmw)) | |
161 | goto next_pte; | |
162 | while (1) { | |
163 | if (check_pte(pvmw)) | |
164 | return true; | |
d75450ff HD |
165 | next_pte: |
166 | /* Seek to next pte only makes sense for THP */ | |
167 | if (!PageTransHuge(pvmw->page) || PageHuge(pvmw->page)) | |
168 | return not_found(pvmw); | |
169 | do { | |
ace71a19 | 170 | pvmw->address += PAGE_SIZE; |
d75450ff HD |
171 | if (pvmw->address >= pvmw->vma->vm_end || |
172 | pvmw->address >= | |
ace71a19 KS |
173 | __vma_address(pvmw->page, pvmw->vma) + |
174 | hpage_nr_pages(pvmw->page) * PAGE_SIZE) | |
175 | return not_found(pvmw); | |
176 | /* Did we cross page table boundary? */ | |
177 | if (pvmw->address % PMD_SIZE == 0) { | |
178 | pte_unmap(pvmw->pte); | |
179 | if (pvmw->ptl) { | |
180 | spin_unlock(pvmw->ptl); | |
181 | pvmw->ptl = NULL; | |
182 | } | |
183 | goto restart; | |
184 | } else { | |
185 | pvmw->pte++; | |
186 | } | |
187 | } while (pte_none(*pvmw->pte)); | |
188 | ||
189 | if (!pvmw->ptl) { | |
190 | pvmw->ptl = pte_lockptr(mm, pvmw->pmd); | |
191 | spin_lock(pvmw->ptl); | |
192 | } | |
193 | } | |
194 | } | |
6a328a62 KS |
195 | |
196 | /** | |
197 | * page_mapped_in_vma - check whether a page is really mapped in a VMA | |
198 | * @page: the page to test | |
199 | * @vma: the VMA to test | |
200 | * | |
201 | * Returns 1 if the page is mapped into the page tables of the VMA, 0 | |
202 | * if the page is not mapped into the page tables of this VMA. Only | |
203 | * valid for normal file or anonymous VMAs. | |
204 | */ | |
205 | int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma) | |
206 | { | |
207 | struct page_vma_mapped_walk pvmw = { | |
208 | .page = page, | |
209 | .vma = vma, | |
210 | .flags = PVMW_SYNC, | |
211 | }; | |
212 | unsigned long start, end; | |
213 | ||
214 | start = __vma_address(page, vma); | |
215 | end = start + PAGE_SIZE * (hpage_nr_pages(page) - 1); | |
216 | ||
217 | if (unlikely(end < vma->vm_start || start >= vma->vm_end)) | |
218 | return 0; | |
219 | pvmw.address = max(start, vma->vm_start); | |
220 | if (!page_vma_mapped_walk(&pvmw)) | |
221 | return 0; | |
222 | page_vma_mapped_walk_done(&pvmw); | |
223 | return 1; | |
224 | } |