mm/hugetlb: move default definition of hugepd_t earlier in the header
[muen/linux.git] / include / linux / hugetlb.h
1 #ifndef _LINUX_HUGETLB_H
2 #define _LINUX_HUGETLB_H
3
4 #include <linux/mm_types.h>
5 #include <linux/mmdebug.h>
6 #include <linux/fs.h>
7 #include <linux/hugetlb_inline.h>
8 #include <linux/cgroup.h>
9 #include <linux/list.h>
10 #include <linux/kref.h>
11 #include <asm/pgtable.h>
12
13 struct ctl_table;
14 struct user_struct;
15 struct mmu_gather;
16
17 #ifndef is_hugepd
18 /*
19  * Some architectures requires a hugepage directory format that is
20  * required to support multiple hugepage sizes. For example
21  * a4fe3ce76 "powerpc/mm: Allow more flexible layouts for hugepage pagetables"
22  * introduced the same on powerpc. This allows for a more flexible hugepage
23  * pagetable layout.
24  */
25 typedef struct { unsigned long pd; } hugepd_t;
26 #define is_hugepd(hugepd) (0)
27 #define __hugepd(x) ((hugepd_t) { (x) })
28 static inline int gup_huge_pd(hugepd_t hugepd, unsigned long addr,
29                               unsigned pdshift, unsigned long end,
30                               int write, struct page **pages, int *nr)
31 {
32         return 0;
33 }
34 #else
35 extern int gup_huge_pd(hugepd_t hugepd, unsigned long addr,
36                        unsigned pdshift, unsigned long end,
37                        int write, struct page **pages, int *nr);
38 #endif
39
40
41 #ifdef CONFIG_HUGETLB_PAGE
42
43 #include <linux/mempolicy.h>
44 #include <linux/shm.h>
45 #include <asm/tlbflush.h>
46
47 struct hugepage_subpool {
48         spinlock_t lock;
49         long count;
50         long max_hpages;        /* Maximum huge pages or -1 if no maximum. */
51         long used_hpages;       /* Used count against maximum, includes */
52                                 /* both alloced and reserved pages. */
53         struct hstate *hstate;
54         long min_hpages;        /* Minimum huge pages or -1 if no minimum. */
55         long rsv_hpages;        /* Pages reserved against global pool to */
56                                 /* sasitfy minimum size. */
57 };
58
59 struct resv_map {
60         struct kref refs;
61         spinlock_t lock;
62         struct list_head regions;
63         long adds_in_progress;
64         struct list_head region_cache;
65         long region_cache_count;
66 };
67 extern struct resv_map *resv_map_alloc(void);
68 void resv_map_release(struct kref *ref);
69
70 extern spinlock_t hugetlb_lock;
71 extern int hugetlb_max_hstate __read_mostly;
72 #define for_each_hstate(h) \
73         for ((h) = hstates; (h) < &hstates[hugetlb_max_hstate]; (h)++)
74
75 struct hugepage_subpool *hugepage_new_subpool(struct hstate *h, long max_hpages,
76                                                 long min_hpages);
77 void hugepage_put_subpool(struct hugepage_subpool *spool);
78
79 void reset_vma_resv_huge_pages(struct vm_area_struct *vma);
80 int hugetlb_sysctl_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *);
81 int hugetlb_overcommit_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *);
82 int hugetlb_treat_movable_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *);
83
84 #ifdef CONFIG_NUMA
85 int hugetlb_mempolicy_sysctl_handler(struct ctl_table *, int,
86                                         void __user *, size_t *, loff_t *);
87 #endif
88
89 int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
90 long follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *,
91                          struct page **, struct vm_area_struct **,
92                          unsigned long *, unsigned long *, long, unsigned int,
93                          int *);
94 void unmap_hugepage_range(struct vm_area_struct *,
95                           unsigned long, unsigned long, struct page *);
96 void __unmap_hugepage_range_final(struct mmu_gather *tlb,
97                           struct vm_area_struct *vma,
98                           unsigned long start, unsigned long end,
99                           struct page *ref_page);
100 void __unmap_hugepage_range(struct mmu_gather *tlb, struct vm_area_struct *vma,
101                                 unsigned long start, unsigned long end,
102                                 struct page *ref_page);
103 void hugetlb_report_meminfo(struct seq_file *);
104 int hugetlb_report_node_meminfo(int, char *);
105 void hugetlb_show_meminfo(void);
106 unsigned long hugetlb_total_pages(void);
107 int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
108                         unsigned long address, unsigned int flags);
109 int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm, pte_t *dst_pte,
110                                 struct vm_area_struct *dst_vma,
111                                 unsigned long dst_addr,
112                                 unsigned long src_addr,
113                                 struct page **pagep);
114 int hugetlb_reserve_pages(struct inode *inode, long from, long to,
115                                                 struct vm_area_struct *vma,
116                                                 vm_flags_t vm_flags);
117 long hugetlb_unreserve_pages(struct inode *inode, long start, long end,
118                                                 long freed);
119 int dequeue_hwpoisoned_huge_page(struct page *page);
120 bool isolate_huge_page(struct page *page, struct list_head *list);
121 void putback_active_hugepage(struct page *page);
122 void free_huge_page(struct page *page);
123 void hugetlb_fix_reserve_counts(struct inode *inode);
124 extern struct mutex *hugetlb_fault_mutex_table;
125 u32 hugetlb_fault_mutex_hash(struct hstate *h, struct mm_struct *mm,
126                                 struct vm_area_struct *vma,
127                                 struct address_space *mapping,
128                                 pgoff_t idx, unsigned long address);
129
130 pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud);
131
132 extern int hugepages_treat_as_movable;
133 extern int sysctl_hugetlb_shm_group;
134 extern struct list_head huge_boot_pages;
135
136 /* arch callbacks */
137
138 pte_t *huge_pte_alloc(struct mm_struct *mm,
139                         unsigned long addr, unsigned long sz);
140 pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr);
141 int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep);
142 struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
143                               int write);
144 struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
145                                 pmd_t *pmd, int flags);
146 struct page *follow_huge_pud(struct mm_struct *mm, unsigned long address,
147                                 pud_t *pud, int flags);
148 struct page *follow_huge_pgd(struct mm_struct *mm, unsigned long address,
149                              pgd_t *pgd, int flags);
150
151 int pmd_huge(pmd_t pmd);
152 int pud_huge(pud_t pud);
153 unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
154                 unsigned long address, unsigned long end, pgprot_t newprot);
155
156 bool is_hugetlb_entry_migration(pte_t pte);
157 #else /* !CONFIG_HUGETLB_PAGE */
158
159 static inline void reset_vma_resv_huge_pages(struct vm_area_struct *vma)
160 {
161 }
162
163 static inline unsigned long hugetlb_total_pages(void)
164 {
165         return 0;
166 }
167
168 #define follow_hugetlb_page(m,v,p,vs,a,b,i,w,n) ({ BUG(); 0; })
169 #define follow_huge_addr(mm, addr, write)       ERR_PTR(-EINVAL)
170 #define copy_hugetlb_page_range(src, dst, vma)  ({ BUG(); 0; })
171 static inline void hugetlb_report_meminfo(struct seq_file *m)
172 {
173 }
174 #define hugetlb_report_node_meminfo(n, buf)     0
175 static inline void hugetlb_show_meminfo(void)
176 {
177 }
178 #define follow_huge_pmd(mm, addr, pmd, flags)   NULL
179 #define follow_huge_pud(mm, addr, pud, flags)   NULL
180 #define follow_huge_pgd(mm, addr, pgd, flags)   NULL
181 #define prepare_hugepage_range(file, addr, len) (-EINVAL)
182 #define pmd_huge(x)     0
183 #define pud_huge(x)     0
184 #define is_hugepage_only_range(mm, addr, len)   0
185 #define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; })
186 #define hugetlb_fault(mm, vma, addr, flags)     ({ BUG(); 0; })
187 #define hugetlb_mcopy_atomic_pte(dst_mm, dst_pte, dst_vma, dst_addr, \
188                                 src_addr, pagep)        ({ BUG(); 0; })
189 #define huge_pte_offset(mm, address)    0
190 static inline int dequeue_hwpoisoned_huge_page(struct page *page)
191 {
192         return 0;
193 }
194
195 static inline bool isolate_huge_page(struct page *page, struct list_head *list)
196 {
197         return false;
198 }
199 #define putback_active_hugepage(p)      do {} while (0)
200
201 static inline unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
202                 unsigned long address, unsigned long end, pgprot_t newprot)
203 {
204         return 0;
205 }
206
207 static inline void __unmap_hugepage_range_final(struct mmu_gather *tlb,
208                         struct vm_area_struct *vma, unsigned long start,
209                         unsigned long end, struct page *ref_page)
210 {
211         BUG();
212 }
213
214 static inline void __unmap_hugepage_range(struct mmu_gather *tlb,
215                         struct vm_area_struct *vma, unsigned long start,
216                         unsigned long end, struct page *ref_page)
217 {
218         BUG();
219 }
220
221 #endif /* !CONFIG_HUGETLB_PAGE */
222 /*
223  * hugepages at page global directory. If arch support
224  * hugepages at pgd level, they need to define this.
225  */
226 #ifndef pgd_huge
227 #define pgd_huge(x)     0
228 #endif
229 #ifndef p4d_huge
230 #define p4d_huge(x)     0
231 #endif
232
233 #ifndef pgd_write
234 static inline int pgd_write(pgd_t pgd)
235 {
236         BUG();
237         return 0;
238 }
239 #endif
240
241 #ifndef pud_write
242 static inline int pud_write(pud_t pud)
243 {
244         BUG();
245         return 0;
246 }
247 #endif
248
249 #define HUGETLB_ANON_FILE "anon_hugepage"
250
251 enum {
252         /*
253          * The file will be used as an shm file so shmfs accounting rules
254          * apply
255          */
256         HUGETLB_SHMFS_INODE     = 1,
257         /*
258          * The file is being created on the internal vfs mount and shmfs
259          * accounting rules do not apply
260          */
261         HUGETLB_ANONHUGE_INODE  = 2,
262 };
263
264 #ifdef CONFIG_HUGETLBFS
265 struct hugetlbfs_sb_info {
266         long    max_inodes;   /* inodes allowed */
267         long    free_inodes;  /* inodes free */
268         spinlock_t      stat_lock;
269         struct hstate *hstate;
270         struct hugepage_subpool *spool;
271 };
272
273 static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
274 {
275         return sb->s_fs_info;
276 }
277
278 extern const struct file_operations hugetlbfs_file_operations;
279 extern const struct vm_operations_struct hugetlb_vm_ops;
280 struct file *hugetlb_file_setup(const char *name, size_t size, vm_flags_t acct,
281                                 struct user_struct **user, int creat_flags,
282                                 int page_size_log);
283
284 static inline bool is_file_hugepages(struct file *file)
285 {
286         if (file->f_op == &hugetlbfs_file_operations)
287                 return true;
288
289         return is_file_shm_hugepages(file);
290 }
291
292
293 #else /* !CONFIG_HUGETLBFS */
294
295 #define is_file_hugepages(file)                 false
296 static inline struct file *
297 hugetlb_file_setup(const char *name, size_t size, vm_flags_t acctflag,
298                 struct user_struct **user, int creat_flags,
299                 int page_size_log)
300 {
301         return ERR_PTR(-ENOSYS);
302 }
303
304 #endif /* !CONFIG_HUGETLBFS */
305
306 #ifdef HAVE_ARCH_HUGETLB_UNMAPPED_AREA
307 unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
308                                         unsigned long len, unsigned long pgoff,
309                                         unsigned long flags);
310 #endif /* HAVE_ARCH_HUGETLB_UNMAPPED_AREA */
311
312 #ifdef CONFIG_HUGETLB_PAGE
313
314 #define HSTATE_NAME_LEN 32
315 /* Defines one hugetlb page size */
316 struct hstate {
317         int next_nid_to_alloc;
318         int next_nid_to_free;
319         unsigned int order;
320         unsigned long mask;
321         unsigned long max_huge_pages;
322         unsigned long nr_huge_pages;
323         unsigned long free_huge_pages;
324         unsigned long resv_huge_pages;
325         unsigned long surplus_huge_pages;
326         unsigned long nr_overcommit_huge_pages;
327         struct list_head hugepage_activelist;
328         struct list_head hugepage_freelists[MAX_NUMNODES];
329         unsigned int nr_huge_pages_node[MAX_NUMNODES];
330         unsigned int free_huge_pages_node[MAX_NUMNODES];
331         unsigned int surplus_huge_pages_node[MAX_NUMNODES];
332 #ifdef CONFIG_CGROUP_HUGETLB
333         /* cgroup control files */
334         struct cftype cgroup_files[5];
335 #endif
336         char name[HSTATE_NAME_LEN];
337 };
338
339 struct huge_bootmem_page {
340         struct list_head list;
341         struct hstate *hstate;
342 #ifdef CONFIG_HIGHMEM
343         phys_addr_t phys;
344 #endif
345 };
346
347 struct page *alloc_huge_page(struct vm_area_struct *vma,
348                                 unsigned long addr, int avoid_reserve);
349 struct page *alloc_huge_page_node(struct hstate *h, int nid);
350 struct page *alloc_huge_page_noerr(struct vm_area_struct *vma,
351                                 unsigned long addr, int avoid_reserve);
352 int huge_add_to_page_cache(struct page *page, struct address_space *mapping,
353                         pgoff_t idx);
354
355 /* arch callback */
356 int __init alloc_bootmem_huge_page(struct hstate *h);
357
358 void __init hugetlb_bad_size(void);
359 void __init hugetlb_add_hstate(unsigned order);
360 struct hstate *size_to_hstate(unsigned long size);
361
362 #ifndef HUGE_MAX_HSTATE
363 #define HUGE_MAX_HSTATE 1
364 #endif
365
366 extern struct hstate hstates[HUGE_MAX_HSTATE];
367 extern unsigned int default_hstate_idx;
368
369 #define default_hstate (hstates[default_hstate_idx])
370
371 static inline struct hstate *hstate_inode(struct inode *i)
372 {
373         return HUGETLBFS_SB(i->i_sb)->hstate;
374 }
375
376 static inline struct hstate *hstate_file(struct file *f)
377 {
378         return hstate_inode(file_inode(f));
379 }
380
381 static inline struct hstate *hstate_sizelog(int page_size_log)
382 {
383         if (!page_size_log)
384                 return &default_hstate;
385
386         return size_to_hstate(1UL << page_size_log);
387 }
388
389 static inline struct hstate *hstate_vma(struct vm_area_struct *vma)
390 {
391         return hstate_file(vma->vm_file);
392 }
393
394 static inline unsigned long huge_page_size(struct hstate *h)
395 {
396         return (unsigned long)PAGE_SIZE << h->order;
397 }
398
399 extern unsigned long vma_kernel_pagesize(struct vm_area_struct *vma);
400
401 extern unsigned long vma_mmu_pagesize(struct vm_area_struct *vma);
402
403 static inline unsigned long huge_page_mask(struct hstate *h)
404 {
405         return h->mask;
406 }
407
408 static inline unsigned int huge_page_order(struct hstate *h)
409 {
410         return h->order;
411 }
412
413 static inline unsigned huge_page_shift(struct hstate *h)
414 {
415         return h->order + PAGE_SHIFT;
416 }
417
418 static inline bool hstate_is_gigantic(struct hstate *h)
419 {
420         return huge_page_order(h) >= MAX_ORDER;
421 }
422
423 static inline unsigned int pages_per_huge_page(struct hstate *h)
424 {
425         return 1 << h->order;
426 }
427
428 static inline unsigned int blocks_per_huge_page(struct hstate *h)
429 {
430         return huge_page_size(h) / 512;
431 }
432
433 #include <asm/hugetlb.h>
434
435 #ifndef arch_make_huge_pte
436 static inline pte_t arch_make_huge_pte(pte_t entry, struct vm_area_struct *vma,
437                                        struct page *page, int writable)
438 {
439         return entry;
440 }
441 #endif
442
443 static inline struct hstate *page_hstate(struct page *page)
444 {
445         VM_BUG_ON_PAGE(!PageHuge(page), page);
446         return size_to_hstate(PAGE_SIZE << compound_order(page));
447 }
448
449 static inline unsigned hstate_index_to_shift(unsigned index)
450 {
451         return hstates[index].order + PAGE_SHIFT;
452 }
453
454 static inline int hstate_index(struct hstate *h)
455 {
456         return h - hstates;
457 }
458
459 pgoff_t __basepage_index(struct page *page);
460
461 /* Return page->index in PAGE_SIZE units */
462 static inline pgoff_t basepage_index(struct page *page)
463 {
464         if (!PageCompound(page))
465                 return page->index;
466
467         return __basepage_index(page);
468 }
469
470 extern int dissolve_free_huge_pages(unsigned long start_pfn,
471                                     unsigned long end_pfn);
472 static inline bool hugepage_migration_supported(struct hstate *h)
473 {
474 #ifdef CONFIG_ARCH_ENABLE_HUGEPAGE_MIGRATION
475         if ((huge_page_shift(h) == PMD_SHIFT) ||
476                 (huge_page_shift(h) == PGDIR_SHIFT))
477                 return true;
478         else
479                 return false;
480 #else
481         return false;
482 #endif
483 }
484
485 static inline spinlock_t *huge_pte_lockptr(struct hstate *h,
486                                            struct mm_struct *mm, pte_t *pte)
487 {
488         if (huge_page_size(h) == PMD_SIZE)
489                 return pmd_lockptr(mm, (pmd_t *) pte);
490         VM_BUG_ON(huge_page_size(h) == PAGE_SIZE);
491         return &mm->page_table_lock;
492 }
493
494 #ifndef hugepages_supported
495 /*
496  * Some platform decide whether they support huge pages at boot
497  * time. Some of them, such as powerpc, set HPAGE_SHIFT to 0
498  * when there is no such support
499  */
500 #define hugepages_supported() (HPAGE_SHIFT != 0)
501 #endif
502
503 void hugetlb_report_usage(struct seq_file *m, struct mm_struct *mm);
504
505 static inline void hugetlb_count_add(long l, struct mm_struct *mm)
506 {
507         atomic_long_add(l, &mm->hugetlb_usage);
508 }
509
510 static inline void hugetlb_count_sub(long l, struct mm_struct *mm)
511 {
512         atomic_long_sub(l, &mm->hugetlb_usage);
513 }
514 #else   /* CONFIG_HUGETLB_PAGE */
515 struct hstate {};
516 #define alloc_huge_page(v, a, r) NULL
517 #define alloc_huge_page_node(h, nid) NULL
518 #define alloc_huge_page_noerr(v, a, r) NULL
519 #define alloc_bootmem_huge_page(h) NULL
520 #define hstate_file(f) NULL
521 #define hstate_sizelog(s) NULL
522 #define hstate_vma(v) NULL
523 #define hstate_inode(i) NULL
524 #define page_hstate(page) NULL
525 #define huge_page_size(h) PAGE_SIZE
526 #define huge_page_mask(h) PAGE_MASK
527 #define vma_kernel_pagesize(v) PAGE_SIZE
528 #define vma_mmu_pagesize(v) PAGE_SIZE
529 #define huge_page_order(h) 0
530 #define huge_page_shift(h) PAGE_SHIFT
531 static inline bool hstate_is_gigantic(struct hstate *h)
532 {
533         return false;
534 }
535
536 static inline unsigned int pages_per_huge_page(struct hstate *h)
537 {
538         return 1;
539 }
540 #define hstate_index_to_shift(index) 0
541 #define hstate_index(h) 0
542
543 static inline pgoff_t basepage_index(struct page *page)
544 {
545         return page->index;
546 }
547 #define dissolve_free_huge_pages(s, e)  0
548 #define hugepage_migration_supported(h) false
549
550 static inline spinlock_t *huge_pte_lockptr(struct hstate *h,
551                                            struct mm_struct *mm, pte_t *pte)
552 {
553         return &mm->page_table_lock;
554 }
555
556 static inline void hugetlb_report_usage(struct seq_file *f, struct mm_struct *m)
557 {
558 }
559
560 static inline void hugetlb_count_sub(long l, struct mm_struct *mm)
561 {
562 }
563 #endif  /* CONFIG_HUGETLB_PAGE */
564
565 static inline spinlock_t *huge_pte_lock(struct hstate *h,
566                                         struct mm_struct *mm, pte_t *pte)
567 {
568         spinlock_t *ptl;
569
570         ptl = huge_pte_lockptr(h, mm, pte);
571         spin_lock(ptl);
572         return ptl;
573 }
574
575 #endif /* _LINUX_HUGETLB_H */