hugetlb.h 5.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192
  1. #ifndef _LINUX_HUGETLB_H
  2. #define _LINUX_HUGETLB_H
  3. #ifdef CONFIG_HUGETLB_PAGE
  4. #include <linux/mempolicy.h>
  5. #include <linux/shm.h>
  6. #include <asm/tlbflush.h>
  7. struct ctl_table;
  8. static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
  9. {
  10. return vma->vm_flags & VM_HUGETLB;
  11. }
  12. int hugetlb_sysctl_handler(struct ctl_table *, int, struct file *, void __user *, size_t *, loff_t *);
  13. int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
  14. int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *, struct page **, struct vm_area_struct **, unsigned long *, int *, int);
  15. void unmap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
  16. void __unmap_hugepage_range(struct vm_area_struct *, unsigned long, unsigned long);
  17. int hugetlb_prefault(struct address_space *, struct vm_area_struct *);
  18. int hugetlb_report_meminfo(char *);
  19. int hugetlb_report_node_meminfo(int, char *);
  20. unsigned long hugetlb_total_pages(void);
  21. int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
  22. unsigned long address, int write_access);
  23. int hugetlb_reserve_pages(struct inode *inode, long from, long to);
  24. void hugetlb_unreserve_pages(struct inode *inode, long offset, long freed);
  25. extern unsigned long max_huge_pages;
  26. extern const unsigned long hugetlb_zero, hugetlb_infinity;
  27. extern int sysctl_hugetlb_shm_group;
  28. /* arch callbacks */
  29. pte_t *huge_pte_alloc(struct mm_struct *mm, unsigned long addr);
  30. pte_t *huge_pte_offset(struct mm_struct *mm, unsigned long addr);
  31. int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep);
  32. struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
  33. int write);
  34. struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
  35. pmd_t *pmd, int write);
  36. int pmd_huge(pmd_t pmd);
  37. void hugetlb_change_protection(struct vm_area_struct *vma,
  38. unsigned long address, unsigned long end, pgprot_t newprot);
  39. #ifndef ARCH_HAS_HUGEPAGE_ONLY_RANGE
  40. #define is_hugepage_only_range(mm, addr, len) 0
  41. #endif
  42. #ifndef ARCH_HAS_HUGETLB_FREE_PGD_RANGE
  43. #define hugetlb_free_pgd_range free_pgd_range
  44. #else
  45. void hugetlb_free_pgd_range(struct mmu_gather **tlb, unsigned long addr,
  46. unsigned long end, unsigned long floor,
  47. unsigned long ceiling);
  48. #endif
  49. #ifndef ARCH_HAS_PREPARE_HUGEPAGE_RANGE
  50. /*
  51. * If the arch doesn't supply something else, assume that hugepage
  52. * size aligned regions are ok without further preparation.
  53. */
  54. static inline int prepare_hugepage_range(unsigned long addr, unsigned long len,
  55. pgoff_t pgoff)
  56. {
  57. if (pgoff & (~HPAGE_MASK >> PAGE_SHIFT))
  58. return -EINVAL;
  59. if (len & ~HPAGE_MASK)
  60. return -EINVAL;
  61. if (addr & ~HPAGE_MASK)
  62. return -EINVAL;
  63. return 0;
  64. }
  65. #else
  66. int prepare_hugepage_range(unsigned long addr, unsigned long len,
  67. pgoff_t pgoff);
  68. #endif
  69. #ifndef ARCH_HAS_SETCLEAR_HUGE_PTE
  70. #define set_huge_pte_at(mm, addr, ptep, pte) set_pte_at(mm, addr, ptep, pte)
  71. #define huge_ptep_get_and_clear(mm, addr, ptep) ptep_get_and_clear(mm, addr, ptep)
  72. #else
  73. void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
  74. pte_t *ptep, pte_t pte);
  75. pte_t huge_ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
  76. pte_t *ptep);
  77. #endif
  78. #ifndef ARCH_HAS_HUGETLB_PREFAULT_HOOK
  79. #define hugetlb_prefault_arch_hook(mm) do { } while (0)
  80. #else
  81. void hugetlb_prefault_arch_hook(struct mm_struct *mm);
  82. #endif
  83. #else /* !CONFIG_HUGETLB_PAGE */
  84. static inline int is_vm_hugetlb_page(struct vm_area_struct *vma)
  85. {
  86. return 0;
  87. }
  88. static inline unsigned long hugetlb_total_pages(void)
  89. {
  90. return 0;
  91. }
  92. #define follow_hugetlb_page(m,v,p,vs,a,b,i) ({ BUG(); 0; })
  93. #define follow_huge_addr(mm, addr, write) ERR_PTR(-EINVAL)
  94. #define copy_hugetlb_page_range(src, dst, vma) ({ BUG(); 0; })
  95. #define hugetlb_prefault(mapping, vma) ({ BUG(); 0; })
  96. #define unmap_hugepage_range(vma, start, end) BUG()
  97. #define hugetlb_report_meminfo(buf) 0
  98. #define hugetlb_report_node_meminfo(n, buf) 0
  99. #define follow_huge_pmd(mm, addr, pmd, write) NULL
  100. #define prepare_hugepage_range(addr,len,pgoff) (-EINVAL)
  101. #define pmd_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, write) ({ BUG(); 0; })
  105. #define hugetlb_change_protection(vma, address, end, newprot)
  106. #ifndef HPAGE_MASK
  107. #define HPAGE_MASK PAGE_MASK /* Keep the compiler happy */
  108. #define HPAGE_SIZE PAGE_SIZE
  109. #endif
  110. #endif /* !CONFIG_HUGETLB_PAGE */
  111. #ifdef CONFIG_HUGETLBFS
  112. struct hugetlbfs_config {
  113. uid_t uid;
  114. gid_t gid;
  115. umode_t mode;
  116. long nr_blocks;
  117. long nr_inodes;
  118. };
  119. struct hugetlbfs_sb_info {
  120. long max_blocks; /* blocks allowed */
  121. long free_blocks; /* blocks free */
  122. long max_inodes; /* inodes allowed */
  123. long free_inodes; /* inodes free */
  124. spinlock_t stat_lock;
  125. };
  126. struct hugetlbfs_inode_info {
  127. struct shared_policy policy;
  128. struct inode vfs_inode;
  129. };
  130. static inline struct hugetlbfs_inode_info *HUGETLBFS_I(struct inode *inode)
  131. {
  132. return container_of(inode, struct hugetlbfs_inode_info, vfs_inode);
  133. }
  134. static inline struct hugetlbfs_sb_info *HUGETLBFS_SB(struct super_block *sb)
  135. {
  136. return sb->s_fs_info;
  137. }
  138. extern const struct file_operations hugetlbfs_file_operations;
  139. extern struct vm_operations_struct hugetlb_vm_ops;
  140. struct file *hugetlb_zero_setup(size_t);
  141. int hugetlb_get_quota(struct address_space *mapping);
  142. void hugetlb_put_quota(struct address_space *mapping);
  143. static inline int is_file_hugepages(struct file *file)
  144. {
  145. if (file->f_op == &hugetlbfs_file_operations)
  146. return 1;
  147. if (is_file_shm_hugepages(file))
  148. return 1;
  149. return 0;
  150. }
  151. static inline void set_file_hugepages(struct file *file)
  152. {
  153. file->f_op = &hugetlbfs_file_operations;
  154. }
  155. #else /* !CONFIG_HUGETLBFS */
  156. #define is_file_hugepages(file) 0
  157. #define set_file_hugepages(file) BUG()
  158. #define hugetlb_zero_setup(size) ERR_PTR(-ENOSYS)
  159. #endif /* !CONFIG_HUGETLBFS */
  160. #endif /* _LINUX_HUGETLB_H */