Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0 */
       2                 :            : #ifndef _ASM_GENERIC_HUGETLB_H
       3                 :            : #define _ASM_GENERIC_HUGETLB_H
       4                 :            : 
       5                 :          0 : static inline pte_t mk_huge_pte(struct page *page, pgprot_t pgprot)
       6                 :            : {
       7         [ #  # ]:          0 :         return mk_pte(page, pgprot);
       8                 :            : }
       9                 :            : 
      10                 :          0 : static inline unsigned long huge_pte_write(pte_t pte)
      11                 :            : {
      12   [ #  #  #  # ]:          0 :         return pte_write(pte);
      13                 :            : }
      14                 :            : 
      15                 :          0 : static inline unsigned long huge_pte_dirty(pte_t pte)
      16                 :            : {
      17         [ #  # ]:          0 :         return pte_dirty(pte);
      18                 :            : }
      19                 :            : 
      20                 :          0 : static inline pte_t huge_pte_mkwrite(pte_t pte)
      21                 :            : {
      22                 :          0 :         return pte_mkwrite(pte);
      23                 :            : }
      24                 :            : 
      25                 :          0 : static inline pte_t huge_pte_mkdirty(pte_t pte)
      26                 :            : {
      27                 :          0 :         return pte_mkdirty(pte);
      28                 :            : }
      29                 :            : 
      30                 :          0 : static inline pte_t huge_pte_modify(pte_t pte, pgprot_t newprot)
      31                 :            : {
      32                 :          0 :         return pte_modify(pte, newprot);
      33                 :            : }
      34                 :            : 
      35                 :            : #ifndef __HAVE_ARCH_HUGE_PTE_CLEAR
      36                 :          0 : static inline void huge_pte_clear(struct mm_struct *mm, unsigned long addr,
      37                 :            :                     pte_t *ptep, unsigned long sz)
      38                 :            : {
      39                 :          0 :         pte_clear(mm, addr, ptep);
      40                 :            : }
      41                 :            : #endif
      42                 :            : 
      43                 :            : #ifndef __HAVE_ARCH_HUGETLB_FREE_PGD_RANGE
      44                 :          0 : static inline void hugetlb_free_pgd_range(struct mmu_gather *tlb,
      45                 :            :                 unsigned long addr, unsigned long end,
      46                 :            :                 unsigned long floor, unsigned long ceiling)
      47                 :            : {
      48                 :          0 :         free_pgd_range(tlb, addr, end, floor, ceiling);
      49                 :          0 : }
      50                 :            : #endif
      51                 :            : 
      52                 :            : #ifndef __HAVE_ARCH_HUGE_SET_HUGE_PTE_AT
      53                 :          0 : static inline void set_huge_pte_at(struct mm_struct *mm, unsigned long addr,
      54                 :            :                 pte_t *ptep, pte_t pte)
      55                 :            : {
      56         [ #  # ]:          0 :         set_pte_at(mm, addr, ptep, pte);
      57                 :            : }
      58                 :            : #endif
      59                 :            : 
      60                 :            : #ifndef __HAVE_ARCH_HUGE_PTEP_GET_AND_CLEAR
      61                 :          0 : static inline pte_t huge_ptep_get_and_clear(struct mm_struct *mm,
      62                 :            :                 unsigned long addr, pte_t *ptep)
      63                 :            : {
      64                 :          0 :         return ptep_get_and_clear(mm, addr, ptep);
      65                 :            : }
      66                 :            : #endif
      67                 :            : 
      68                 :            : #ifndef __HAVE_ARCH_HUGE_PTEP_CLEAR_FLUSH
      69                 :          0 : static inline void huge_ptep_clear_flush(struct vm_area_struct *vma,
      70                 :            :                 unsigned long addr, pte_t *ptep)
      71                 :            : {
      72                 :          0 :         ptep_clear_flush(vma, addr, ptep);
      73                 :            : }
      74                 :            : #endif
      75                 :            : 
      76                 :            : #ifndef __HAVE_ARCH_HUGE_PTE_NONE
      77                 :          0 : static inline int huge_pte_none(pte_t pte)
      78                 :            : {
      79   [ #  #  #  #  :          0 :         return pte_none(pte);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                      # ]
      80                 :            : }
      81                 :            : #endif
      82                 :            : 
      83                 :            : #ifndef __HAVE_ARCH_HUGE_PTE_WRPROTECT
      84                 :            : static inline pte_t huge_pte_wrprotect(pte_t pte)
      85                 :            : {
      86                 :            :         return pte_wrprotect(pte);
      87                 :            : }
      88                 :            : #endif
      89                 :            : 
      90                 :            : #ifndef __HAVE_ARCH_PREPARE_HUGEPAGE_RANGE
      91                 :          0 : static inline int prepare_hugepage_range(struct file *file,
      92                 :            :                 unsigned long addr, unsigned long len)
      93                 :            : {
      94         [ #  # ]:          0 :         struct hstate *h = hstate_file(file);
      95                 :            : 
      96         [ #  # ]:          0 :         if (len & ~huge_page_mask(h))
      97                 :            :                 return -EINVAL;
      98         [ #  # ]:          0 :         if (addr & ~huge_page_mask(h))
      99                 :            :                 return -EINVAL;
     100                 :            : 
     101                 :            :         return 0;
     102                 :            : }
     103                 :            : #endif
     104                 :            : 
     105                 :            : #ifndef __HAVE_ARCH_HUGE_PTEP_SET_WRPROTECT
     106                 :          0 : static inline void huge_ptep_set_wrprotect(struct mm_struct *mm,
     107                 :            :                 unsigned long addr, pte_t *ptep)
     108                 :            : {
     109                 :          0 :         ptep_set_wrprotect(mm, addr, ptep);
     110                 :          0 : }
     111                 :            : #endif
     112                 :            : 
     113                 :            : #ifndef __HAVE_ARCH_HUGE_PTEP_SET_ACCESS_FLAGS
     114                 :          0 : static inline int huge_ptep_set_access_flags(struct vm_area_struct *vma,
     115                 :            :                 unsigned long addr, pte_t *ptep,
     116                 :            :                 pte_t pte, int dirty)
     117                 :            : {
     118                 :          0 :         return ptep_set_access_flags(vma, addr, ptep, pte, dirty);
     119                 :            : }
     120                 :            : #endif
     121                 :            : 
     122                 :            : #ifndef __HAVE_ARCH_HUGE_PTEP_GET
     123                 :          0 : static inline pte_t huge_ptep_get(pte_t *ptep)
     124                 :            : {
     125   [ #  #  #  #  :          0 :         return *ptep;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     126                 :            : }
     127                 :            : #endif
     128                 :            : 
     129                 :            : #ifndef __HAVE_ARCH_GIGANTIC_PAGE_RUNTIME_SUPPORTED
     130                 :            : static inline bool gigantic_page_runtime_supported(void)
     131                 :            : {
     132                 :            :         return IS_ENABLED(CONFIG_ARCH_HAS_GIGANTIC_PAGE);
     133                 :            : }
     134                 :            : #endif /* __HAVE_ARCH_GIGANTIC_PAGE_RUNTIME_SUPPORTED */
     135                 :            : 
     136                 :            : #endif /* _ASM_GENERIC_HUGETLB_H */