1#ifndef _LINUX_HUGETLB_H
2#define _LINUX_HUGETLB_H
3
4#include <linux/fs.h>
5
6struct ctl_table;
7struct user_struct;
8
9#ifdef CONFIG_HUGETLB_PAGE
10
11#include <linux/mempolicy.h>
12#include <linux/shm.h>
13#include <asm/tlbflush.h>
14
15int PageHuge(struct page *page);
16
17static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
18{
19 return vma->vm_flags & VM_HUGETLB;
20}
21
22void reset_vma_resv_huge_pages(struct vm_area_struct *vma);
23int hugetlb_sysctl_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *);
24int hugetlb_overcommit_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *);
25int hugetlb_treat_movable_handler(struct ctl_table *, int, void __user *, size_t *, loff_t *);
26int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
27int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *,
28 struct page **, struct vm_area_struct **,
29 unsigned long *, int *, int, unsigned int flags);
30void unmap_hugepage_range(struct vm_area_struct *,
31 unsigned long, unsigned long, struct page *);
32void __unmap_hugepage_range(struct vm_area_struct *,
33 unsigned long, unsigned long, struct page *);
34int hugetlb_prefault(struct address_space *, struct vm_area_struct *);
35void hugetlb_report_meminfo(struct seq_file *);
36int hugetlb_report_node_meminfo(int, char *);
37unsigned long hugetlb_total_pages(void);
38int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
39 unsigned long address, unsigned int flags);
40int hugetlb_reserve_pages(struct inode *inode, long from, long to,
41 struct vm_area_struct *vma,
42 int acctflags);
43void hugetlb_unreserve_pages(struct inode *inode, long offset, long freed);
44
45extern unsigned long hugepages_treat_as_movable;
46extern const unsigned long hugetlb_zero, hugetlb_infinity;
47extern int sysctl_hugetlb_shm_group;
48extern struct list_head huge_boot_pages;
49
50
51
52pte_t *huge_pte_alloc(struct mm_struct *mm,
53 unsigned long addr, unsigned long sz);
54pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr);
55int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep);
56struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
57 int write);
58struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
59 pmd_t *pmd, int write);
60struct page *follow_huge_pud(struct mm_struct *mm, unsigned long address,
61 pud_t *pud, int write);
62int pmd_huge(pmd_t pmd);
63int pud_huge(pud_t pmd);
64void hugetlb_change_protection(struct vm_area_struct *vma,
65 unsigned long address, unsigned long end, pgprot_t newprot);
66
67#else
68
69static inline int PageHuge(struct page *page)
70{
71 return 0;
72}
73
74static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
75{
76 return 0;
77}
78
79static inline void reset_vma_resv_huge_pages(struct vm_area_struct *vma)
80{
81}
82
83static inline unsigned long hugetlb_total_pages(void)
84{
85 return 0;
86}
87
88#define follow_hugetlb_page(m,v,p,vs,a,b,i,w) ({ BUG(); 0; })
89#define follow_huge_addr(mm, addr, write) ERR_PTR(-EINVAL)
90#define copy_hugetlb_page_range(src, dst, vma) ({ BUG(); 0; })
91#define hugetlb_prefault(mapping, vma) ({ BUG(); 0; })
92#define unmap_hugepage_range(vma, start, end, page) BUG()
93static inline void hugetlb_report_meminfo(struct seq_file *m)
94{
95}
96#define hugetlb_report_node_meminfo(n, buf) 0
97#define follow_huge_pmd(mm, addr, pmd, write) NULL
98#define follow_huge_pud(mm, addr, pud, write) NULL
99#define prepare_hugepage_range(file, addr, len) (-EINVAL)
100#define pmd_huge(x) 0
101#define pud_huge(x) 0
102#define is_hugepage_only_range(mm, addr, len) 0
103#define hugetlb_free_pgd_range(tlb, addr, end, floor, ceiling) ({BUG(); 0; })
104#define hugetlb_fault(mm, vma, addr, flags) ({ BUG(); 0; })
105
106#define hugetlb_change_protection(vma, address, end, newprot)
107
108#ifndef HPAGE_MASK
109#define HPAGE_MASK PAGE_MASK
110#define HPAGE_SIZE PAGE_SIZE
111#endif
112
113#endif
114
115#define HUGETLB_ANON_FILE "anon_hugepage"
116
117enum {
118
119
120
121
122 HUGETLB_SHMFS_INODE = 1,
123
124
125
126
127 HUGETLB_ANONHUGE_INODE = 2,
128};
129
130#ifdef CONFIG_HUGETLBFS
131struct hugetlbfs_config {
132 uid_t uid;
133 gid_t gid;
134 umode_t mode;
135 long nr_blocks;
136 long nr_inodes;
137 struct hstate *hstate;
138};
139
140struct hugetlbfs_sb_info {
141 long max_blocks;
142 long free_blocks;
143 long max_inodes;
144 long free_inodes;
145 spinlock_t stat_lock;
146 struct hstate *hstate;
147};
148
149
150struct hugetlbfs_inode_info {
151 struct shared_policy policy;
152 struct inode vfs_inode;
153};
154
155static inline struct hugetlbfs_inode_info *HUGETLBFS_I(struct inode *inode)
156{
157 return container_of(inode, struct hugetlbfs_inode_info, vfs_inode);
158}
159
160static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
161{
162 return sb->s_fs_info;
163}
164
165extern const struct file_operations hugetlbfs_file_operations;
166extern const struct vm_operations_struct hugetlb_vm_ops;
167struct file *hugetlb_file_setup(const char *name, size_t size, int acct,
168 struct user_struct **user, int creat_flags);
169int hugetlb_get_quota(struct address_space *mapping, long delta);
170void hugetlb_put_quota(struct address_space *mapping, long delta);
171
172static inline int is_file_hugepages(struct file *file)
173{
174 if (file->f_op == &hugetlbfs_file_operations)
175 return 1;
176 if (is_file_shm_hugepages(file))
177 return 1;
178
179 return 0;
180}
181
182static inline void set_file_hugepages(struct file *file)
183{
184 file->f_op = &hugetlbfs_file_operations;
185}
186#else
187
188#define is_file_hugepages(file) 0
189#define set_file_hugepages(file) BUG()
190static inline struct file *hugetlb_file_setup(const char *name, size_t size,
191 int acctflag, struct user_struct **user, int creat_flags)
192{
193 return ERR_PTR(-ENOSYS);
194}
195
196#endif
197
198#ifdef HAVE_ARCH_HUGETLB_UNMAPPED_AREA
199unsigned long hugetlb_get_unmapped_area(struct file *file, unsigned long addr,
200 unsigned long len, unsigned long pgoff,
201 unsigned long flags);
202#endif
203
204#ifdef CONFIG_HUGETLB_PAGE
205
206#define HSTATE_NAME_LEN 32
207
208struct hstate {
209 int next_nid_to_alloc;
210 int next_nid_to_free;
211 unsigned int order;
212 unsigned long mask;
213 unsigned long max_huge_pages;
214 unsigned long nr_huge_pages;
215 unsigned long free_huge_pages;
216 unsigned long resv_huge_pages;
217 unsigned long surplus_huge_pages;
218 unsigned long nr_overcommit_huge_pages;
219 struct list_head hugepage_freelists[MAX_NUMNODES];
220 unsigned int nr_huge_pages_node[MAX_NUMNODES];
221 unsigned int free_huge_pages_node[MAX_NUMNODES];
222 unsigned int surplus_huge_pages_node[MAX_NUMNODES];
223 char name[HSTATE_NAME_LEN];
224};
225
226struct huge_bootmem_page {
227 struct list_head list;
228 struct hstate *hstate;
229};
230
231
232int __init alloc_bootmem_huge_page(struct hstate *h);
233
234void __init hugetlb_add_hstate(unsigned order);
235struct hstate *size_to_hstate(unsigned long size);
236
237#ifndef HUGE_MAX_HSTATE
238#define HUGE_MAX_HSTATE 1
239#endif
240
241extern struct hstate hstates[HUGE_MAX_HSTATE];
242extern unsigned int default_hstate_idx;
243
244#define default_hstate (hstates[default_hstate_idx])
245
246static inline struct hstate *hstate_inode(struct inode *i)
247{
248 struct hugetlbfs_sb_info *hsb;
249 hsb = HUGETLBFS_SB(i->i_sb);
250 return hsb->hstate;
251}
252
253static inline struct hstate *hstate_file(struct file *f)
254{
255 return hstate_inode(f->f_dentry->d_inode);
256}
257
258static inline struct hstate *hstate_vma(struct vm_area_struct *vma)
259{
260 return hstate_file(vma->vm_file);
261}
262
263static inline unsigned long huge_page_size(struct hstate *h)
264{
265 return (unsigned long)PAGE_SIZE << h->order;
266}
267
268extern unsigned long vma_kernel_pagesize(struct vm_area_struct *vma);
269
270extern unsigned long vma_mmu_pagesize(struct vm_area_struct *vma);
271
272static inline unsigned long huge_page_mask(struct hstate *h)
273{
274 return h->mask;
275}
276
277static inline unsigned int huge_page_order(struct hstate *h)
278{
279 return h->order;
280}
281
282static inline unsigned huge_page_shift(struct hstate *h)
283{
284 return h->order + PAGE_SHIFT;
285}
286
287static inline unsigned int pages_per_huge_page(struct hstate *h)
288{
289 return 1 << h->order;
290}
291
292static inline unsigned int blocks_per_huge_page(struct hstate *h)
293{
294 return huge_page_size(h) / 512;
295}
296
297#include <asm/hugetlb.h>
298
299static inline struct hstate *page_hstate(struct page *page)
300{
301 return size_to_hstate(PAGE_SIZE << compound_order(page));
302}
303
304#else
305struct hstate {};
306#define alloc_bootmem_huge_page(h) NULL
307#define hstate_file(f) NULL
308#define hstate_vma(v) NULL
309#define hstate_inode(i) NULL
310#define huge_page_size(h) PAGE_SIZE
311#define huge_page_mask(h) PAGE_MASK
312#define vma_kernel_pagesize(v) PAGE_SIZE
313#define vma_mmu_pagesize(v) PAGE_SIZE
314#define huge_page_order(h) 0
315#define huge_page_shift(h) PAGE_SHIFT
316static inline unsigned int pages_per_huge_page(struct hstate *h)
317{
318 return 1;
319}
320#endif
321
322#endif
323