~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/include/linux/hugetlb.h

Version: ~ [ linux-5.3-rc5 ] ~ [ linux-5.2.9 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.67 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.139 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.189 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.189 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.72 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp