1
2#ifndef _LINUX_HUGE_MM_H
3#define _LINUX_HUGE_MM_H
4
5#include <linux/sched/coredump.h>
6#include <linux/mm_types.h>
7
8#include <linux/fs.h>
9
10vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf);
11int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
12 pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr,
13 struct vm_area_struct *vma);
14void huge_pmd_set_accessed(struct vm_fault *vmf, pmd_t orig_pmd);
15int copy_huge_pud(struct mm_struct *dst_mm, struct mm_struct *src_mm,
16 pud_t *dst_pud, pud_t *src_pud, unsigned long addr,
17 struct vm_area_struct *vma);
18
19#ifdef CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD
20void huge_pud_set_accessed(struct vm_fault *vmf, pud_t orig_pud);
21#else
22static inline void huge_pud_set_accessed(struct vm_fault *vmf, pud_t orig_pud)
23{
24}
25#endif
26
27vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd);
28struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
29 unsigned long addr, pmd_t *pmd,
30 unsigned int flags);
31bool madvise_free_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,
32 pmd_t *pmd, unsigned long addr, unsigned long next);
33int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma, pmd_t *pmd,
34 unsigned long addr);
35int zap_huge_pud(struct mmu_gather *tlb, struct vm_area_struct *vma, pud_t *pud,
36 unsigned long addr);
37bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,
38 unsigned long new_addr, pmd_t *old_pmd, pmd_t *new_pmd);
39int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, unsigned long addr,
40 pgprot_t newprot, unsigned long cp_flags);
41vm_fault_t vmf_insert_pfn_pmd_prot(struct vm_fault *vmf, pfn_t pfn,
42 pgprot_t pgprot, bool write);
43
44
45
46
47
48
49
50
51
52
53
54
55static inline vm_fault_t vmf_insert_pfn_pmd(struct vm_fault *vmf, pfn_t pfn,
56 bool write)
57{
58 return vmf_insert_pfn_pmd_prot(vmf, pfn, vmf->vma->vm_page_prot, write);
59}
60vm_fault_t vmf_insert_pfn_pud_prot(struct vm_fault *vmf, pfn_t pfn,
61 pgprot_t pgprot, bool write);
62
63
64
65
66
67
68
69
70
71
72
73
74static inline vm_fault_t vmf_insert_pfn_pud(struct vm_fault *vmf, pfn_t pfn,
75 bool write)
76{
77 return vmf_insert_pfn_pud_prot(vmf, pfn, vmf->vma->vm_page_prot, write);
78}
79
80enum transparent_hugepage_flag {
81 TRANSPARENT_HUGEPAGE_FLAG,
82 TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG,
83 TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG,
84 TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG,
85 TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG,
86 TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG,
87 TRANSPARENT_HUGEPAGE_DEFRAG_KHUGEPAGED_FLAG,
88 TRANSPARENT_HUGEPAGE_USE_ZERO_PAGE_FLAG,
89#ifdef CONFIG_DEBUG_VM
90 TRANSPARENT_HUGEPAGE_DEBUG_COW_FLAG,
91#endif
92};
93
94struct kobject;
95struct kobj_attribute;
96
97ssize_t single_hugepage_flag_store(struct kobject *kobj,
98 struct kobj_attribute *attr,
99 const char *buf, size_t count,
100 enum transparent_hugepage_flag flag);
101ssize_t single_hugepage_flag_show(struct kobject *kobj,
102 struct kobj_attribute *attr, char *buf,
103 enum transparent_hugepage_flag flag);
104extern struct kobj_attribute shmem_enabled_attr;
105
106#define HPAGE_PMD_ORDER (HPAGE_PMD_SHIFT-PAGE_SHIFT)
107#define HPAGE_PMD_NR (1<<HPAGE_PMD_ORDER)
108
109#ifdef CONFIG_TRANSPARENT_HUGEPAGE
110#define HPAGE_PMD_SHIFT PMD_SHIFT
111#define HPAGE_PMD_SIZE ((1UL) << HPAGE_PMD_SHIFT)
112#define HPAGE_PMD_MASK (~(HPAGE_PMD_SIZE - 1))
113
114#define HPAGE_PUD_SHIFT PUD_SHIFT
115#define HPAGE_PUD_SIZE ((1UL) << HPAGE_PUD_SHIFT)
116#define HPAGE_PUD_MASK (~(HPAGE_PUD_SIZE - 1))
117
118extern unsigned long transparent_hugepage_flags;
119
120
121
122
123
124static inline bool __transparent_hugepage_enabled(struct vm_area_struct *vma)
125{
126 if (vma->vm_flags & VM_NOHUGEPAGE)
127 return false;
128
129 if (vma_is_temporary_stack(vma))
130 return false;
131
132 if (test_bit(MMF_DISABLE_THP, &vma->vm_mm->flags))
133 return false;
134
135 if (transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_FLAG))
136 return true;
137
138
139
140
141
142
143 if (vma_is_dax(vma))
144 return true;
145
146 if (transparent_hugepage_flags &
147 (1 << TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG))
148 return !!(vma->vm_flags & VM_HUGEPAGE);
149
150 return false;
151}
152
153bool transparent_hugepage_enabled(struct vm_area_struct *vma);
154
155#define HPAGE_CACHE_INDEX_MASK (HPAGE_PMD_NR - 1)
156
157static inline bool transhuge_vma_suitable(struct vm_area_struct *vma,
158 unsigned long haddr)
159{
160
161 if (!vma_is_anonymous(vma)) {
162 if (((vma->vm_start >> PAGE_SHIFT) & HPAGE_CACHE_INDEX_MASK) !=
163 (vma->vm_pgoff & HPAGE_CACHE_INDEX_MASK))
164 return false;
165 }
166
167 if (haddr < vma->vm_start || haddr + HPAGE_PMD_SIZE > vma->vm_end)
168 return false;
169 return true;
170}
171
172#define transparent_hugepage_use_zero_page() \
173 (transparent_hugepage_flags & \
174 (1<<TRANSPARENT_HUGEPAGE_USE_ZERO_PAGE_FLAG))
175
176unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
177 unsigned long len, unsigned long pgoff, unsigned long flags);
178
179void prep_transhuge_page(struct page *page);
180void free_transhuge_page(struct page *page);
181bool is_transparent_hugepage(struct page *page);
182
183bool can_split_huge_page(struct page *page, int *pextra_pins);
184int split_huge_page_to_list(struct page *page, struct list_head *list);
185static inline int split_huge_page(struct page *page)
186{
187 return split_huge_page_to_list(page, NULL);
188}
189void deferred_split_huge_page(struct page *page);
190
191void __split_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
192 unsigned long address, bool freeze, struct page *page);
193
194#define split_huge_pmd(__vma, __pmd, __address) \
195 do { \
196 pmd_t *____pmd = (__pmd); \
197 if (is_swap_pmd(*____pmd) || pmd_trans_huge(*____pmd) \
198 || pmd_devmap(*____pmd)) \
199 __split_huge_pmd(__vma, __pmd, __address, \
200 false, NULL); \
201 } while (0)
202
203
204void split_huge_pmd_address(struct vm_area_struct *vma, unsigned long address,
205 bool freeze, struct page *page);
206
207void __split_huge_pud(struct vm_area_struct *vma, pud_t *pud,
208 unsigned long address);
209
210#define split_huge_pud(__vma, __pud, __address) \
211 do { \
212 pud_t *____pud = (__pud); \
213 if (pud_trans_huge(*____pud) \
214 || pud_devmap(*____pud)) \
215 __split_huge_pud(__vma, __pud, __address); \
216 } while (0)
217
218int hugepage_madvise(struct vm_area_struct *vma, unsigned long *vm_flags,
219 int advice);
220void vma_adjust_trans_huge(struct vm_area_struct *vma, unsigned long start,
221 unsigned long end, long adjust_next);
222spinlock_t *__pmd_trans_huge_lock(pmd_t *pmd, struct vm_area_struct *vma);
223spinlock_t *__pud_trans_huge_lock(pud_t *pud, struct vm_area_struct *vma);
224
225static inline int is_swap_pmd(pmd_t pmd)
226{
227 return !pmd_none(pmd) && !pmd_present(pmd);
228}
229
230
231static inline spinlock_t *pmd_trans_huge_lock(pmd_t *pmd,
232 struct vm_area_struct *vma)
233{
234 if (is_swap_pmd(*pmd) || pmd_trans_huge(*pmd) || pmd_devmap(*pmd))
235 return __pmd_trans_huge_lock(pmd, vma);
236 else
237 return NULL;
238}
239static inline spinlock_t *pud_trans_huge_lock(pud_t *pud,
240 struct vm_area_struct *vma)
241{
242 if (pud_trans_huge(*pud) || pud_devmap(*pud))
243 return __pud_trans_huge_lock(pud, vma);
244 else
245 return NULL;
246}
247
248
249
250
251
252static inline struct page *thp_head(struct page *page)
253{
254 return compound_head(page);
255}
256
257
258
259
260
261static inline unsigned int thp_order(struct page *page)
262{
263 VM_BUG_ON_PGFLAGS(PageTail(page), page);
264 if (PageHead(page))
265 return HPAGE_PMD_ORDER;
266 return 0;
267}
268
269
270
271
272
273static inline int thp_nr_pages(struct page *page)
274{
275 VM_BUG_ON_PGFLAGS(PageTail(page), page);
276 if (PageHead(page))
277 return HPAGE_PMD_NR;
278 return 1;
279}
280
281struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
282 pmd_t *pmd, int flags, struct dev_pagemap **pgmap);
283struct page *follow_devmap_pud(struct vm_area_struct *vma, unsigned long addr,
284 pud_t *pud, int flags, struct dev_pagemap **pgmap);
285
286vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd);
287
288extern struct page *huge_zero_page;
289
290static inline bool is_huge_zero_page(struct page *page)
291{
292 return READ_ONCE(huge_zero_page) == page;
293}
294
295static inline bool is_huge_zero_pmd(pmd_t pmd)
296{
297 return is_huge_zero_page(pmd_page(pmd));
298}
299
300static inline bool is_huge_zero_pud(pud_t pud)
301{
302 return false;
303}
304
305struct page *mm_get_huge_zero_page(struct mm_struct *mm);
306void mm_put_huge_zero_page(struct mm_struct *mm);
307
308#define mk_huge_pmd(page, prot) pmd_mkhuge(mk_pmd(page, prot))
309
310static inline bool thp_migration_supported(void)
311{
312 return IS_ENABLED(CONFIG_ARCH_ENABLE_THP_MIGRATION);
313}
314
315static inline struct list_head *page_deferred_list(struct page *page)
316{
317
318
319
320
321 return &page[2].deferred_list;
322}
323
324#else
325#define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; })
326#define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; })
327#define HPAGE_PMD_SIZE ({ BUILD_BUG(); 0; })
328
329#define HPAGE_PUD_SHIFT ({ BUILD_BUG(); 0; })
330#define HPAGE_PUD_MASK ({ BUILD_BUG(); 0; })
331#define HPAGE_PUD_SIZE ({ BUILD_BUG(); 0; })
332
333static inline struct page *thp_head(struct page *page)
334{
335 VM_BUG_ON_PGFLAGS(PageTail(page), page);
336 return page;
337}
338
339static inline unsigned int thp_order(struct page *page)
340{
341 VM_BUG_ON_PGFLAGS(PageTail(page), page);
342 return 0;
343}
344
345static inline int thp_nr_pages(struct page *page)
346{
347 VM_BUG_ON_PGFLAGS(PageTail(page), page);
348 return 1;
349}
350
351static inline bool __transparent_hugepage_enabled(struct vm_area_struct *vma)
352{
353 return false;
354}
355
356static inline bool transparent_hugepage_enabled(struct vm_area_struct *vma)
357{
358 return false;
359}
360
361static inline bool transhuge_vma_suitable(struct vm_area_struct *vma,
362 unsigned long haddr)
363{
364 return false;
365}
366
367static inline void prep_transhuge_page(struct page *page) {}
368
369static inline bool is_transparent_hugepage(struct page *page)
370{
371 return false;
372}
373
374#define transparent_hugepage_flags 0UL
375
376#define thp_get_unmapped_area NULL
377
378static inline bool
379can_split_huge_page(struct page *page, int *pextra_pins)
380{
381 BUILD_BUG();
382 return false;
383}
384static inline int
385split_huge_page_to_list(struct page *page, struct list_head *list)
386{
387 return 0;
388}
389static inline int split_huge_page(struct page *page)
390{
391 return 0;
392}
393static inline void deferred_split_huge_page(struct page *page) {}
394#define split_huge_pmd(__vma, __pmd, __address) \
395 do { } while (0)
396
397static inline void __split_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
398 unsigned long address, bool freeze, struct page *page) {}
399static inline void split_huge_pmd_address(struct vm_area_struct *vma,
400 unsigned long address, bool freeze, struct page *page) {}
401
402#define split_huge_pud(__vma, __pmd, __address) \
403 do { } while (0)
404
405static inline int hugepage_madvise(struct vm_area_struct *vma,
406 unsigned long *vm_flags, int advice)
407{
408 BUG();
409 return 0;
410}
411static inline void vma_adjust_trans_huge(struct vm_area_struct *vma,
412 unsigned long start,
413 unsigned long end,
414 long adjust_next)
415{
416}
417static inline int is_swap_pmd(pmd_t pmd)
418{
419 return 0;
420}
421static inline spinlock_t *pmd_trans_huge_lock(pmd_t *pmd,
422 struct vm_area_struct *vma)
423{
424 return NULL;
425}
426static inline spinlock_t *pud_trans_huge_lock(pud_t *pud,
427 struct vm_area_struct *vma)
428{
429 return NULL;
430}
431
432static inline vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf,
433 pmd_t orig_pmd)
434{
435 return 0;
436}
437
438static inline bool is_huge_zero_page(struct page *page)
439{
440 return false;
441}
442
443static inline bool is_huge_zero_pud(pud_t pud)
444{
445 return false;
446}
447
448static inline void mm_put_huge_zero_page(struct mm_struct *mm)
449{
450 return;
451}
452
453static inline struct page *follow_devmap_pmd(struct vm_area_struct *vma,
454 unsigned long addr, pmd_t *pmd, int flags, struct dev_pagemap **pgmap)
455{
456 return NULL;
457}
458
459static inline struct page *follow_devmap_pud(struct vm_area_struct *vma,
460 unsigned long addr, pud_t *pud, int flags, struct dev_pagemap **pgmap)
461{
462 return NULL;
463}
464
465static inline bool thp_migration_supported(void)
466{
467 return false;
468}
469#endif
470
471
472
473
474
475
476
477static inline unsigned long thp_size(struct page *page)
478{
479 return PAGE_SIZE << thp_order(page);
480}
481
482#endif
483