include/asm-generic/pgtable.h

   1 #ifndef _ASM_GENERIC_PGTABLE_H
   2 #define _ASM_GENERIC_PGTABLE_H
   3
   4 #ifndef __HAVE_ARCH_PTEP_ESTABLISH
   5 /*
   6  * Establish a new mapping:
   7  *  - flush the old one
   8  *  - update the page tables
   9  *  - inform the TLB about the new one
  10  *
  11  * We hold the mm semaphore for reading and vma->vm_mm->page_table_lock.
  12  *
  13  * Note: the old pte is known to not be writable, so we don't need to
  14  * worry about dirty bits etc getting lost.
  15  */
  16 #ifndef __HAVE_ARCH_SET_PTE_ATOMIC
  17 #define ptep_establish(__vma, __address, __ptep, __entry)               \
  18 do {                                                                    \
  19         set_pte(__ptep, __entry);                                       \
  20         flush_tlb_page(__vma, __address);                               \
  21 } while (0)
  22 #else /* __HAVE_ARCH_SET_PTE_ATOMIC */
  23 #define ptep_establish(__vma, __address, __ptep, __entry)               \
  24 do {                                                                    \
  25         set_pte_atomic(__ptep, __entry);                                \
  26         flush_tlb_page(__vma, __address);                               \
  27 } while (0)
  28 #endif /* __HAVE_ARCH_SET_PTE_ATOMIC */
  29 #endif
  30
  31 #ifndef __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
  32 /*
  33  * Largely same as above, but only sets the access flags (dirty,
  34  * accessed, and writable). Furthermore, we know it always gets set
  35  * to a "more permissive" setting, which allows most architectures
  36  * to optimize this.
  37  */
  38 #define ptep_set_access_flags(__vma, __address, __ptep, __entry, __dirty) \
  39 do {                                                                      \
  40         set_pte(__ptep, __entry);                                         \
  41         flush_tlb_page(__vma, __address);                                 \
  42 } while (0)
  43 #endif
  44
  45 #ifndef __HAVE_ARCH_PTEP_TEST_AND_CLEAR_YOUNG
  46 static inline int ptep_test_and_clear_young(pte_t *ptep)
  47 {
  48         pte_t pte = *ptep;
  49         if (!pte_young(pte))
  50                 return 0;
  51         set_pte(ptep, pte_mkold(pte));
  52         return 1;
  53 }
  54 #endif
  55
  56 #ifndef __HAVE_ARCH_PTEP_CLEAR_YOUNG_FLUSH
  57 #define ptep_clear_flush_young(__vma, __address, __ptep)                \
  58 ({                                                                      \
  59         int __young = ptep_test_and_clear_young(__ptep);                \
  60         if (__young)                                                    \
  61                 flush_tlb_page(__vma, __address);                       \
  62         __young;                                                        \
  63 })
  64 #endif
  65
  66 #ifndef __HAVE_ARCH_PTEP_TEST_AND_CLEAR_DIRTY
  67 static inline int ptep_test_and_clear_dirty(pte_t *ptep)
  68 {
  69         pte_t pte = *ptep;
  70         if (!pte_dirty(pte))
  71                 return 0;
  72         set_pte(ptep, pte_mkclean(pte));
  73         return 1;
  74 }
  75 #endif
  76
  77 #ifndef __HAVE_ARCH_PTEP_CLEAR_DIRTY_FLUSH
  78 #define ptep_clear_flush_dirty(__vma, __address, __ptep)                \
  79 ({                                                                      \
  80         int __dirty = ptep_test_and_clear_dirty(__ptep);                \
  81         if (__dirty)                                                    \
  82                 flush_tlb_page(__vma, __address);                       \
  83         __dirty;                                                        \
  84 })
  85 #endif
  86
  87 #ifndef __HAVE_ARCH_PTEP_GET_AND_CLEAR
  88 static inline pte_t ptep_get_and_clear(pte_t *ptep)
  89 {
  90         pte_t pte = *ptep;
  91         pte_clear(ptep);
  92         return pte;
  93 }
  94 #endif
  95
  96 #ifndef __HAVE_ARCH_PTEP_CLEAR_FLUSH
  97 #define ptep_clear_flush(__vma, __address, __ptep)                      \
  98 ({                                                                      \
  99         pte_t __pte = ptep_get_and_clear(__ptep);                       \
 100         flush_tlb_page(__vma, __address);                               \
 101         __pte;                                                          \
 102 })
 103 #endif
 104
 105 #ifndef __HAVE_ARCH_PTEP_SET_WRPROTECT
 106 static inline void ptep_set_wrprotect(pte_t *ptep)
 107 {
 108         pte_t old_pte = *ptep;
 109         set_pte(ptep, pte_wrprotect(old_pte));
 110 }
 111 #endif
 112
 113 #ifndef __HAVE_ARCH_PTEP_MKDIRTY
 114 static inline void ptep_mkdirty(pte_t *ptep)
 115 {
 116         pte_t old_pte = *ptep;
 117         set_pte(ptep, pte_mkdirty(old_pte));
 118 }
 119 #endif
 120
 121 #ifndef __HAVE_ARCH_PTE_SAME
 122 #define pte_same(A,B)   (pte_val(A) == pte_val(B))
 123 #endif
 124
 125 #ifndef __HAVE_ARCH_PAGE_TEST_AND_CLEAR_DIRTY
 126 #define page_test_and_clear_dirty(page) (0)
 127 #endif
 128
 129 #ifndef __HAVE_ARCH_PAGE_TEST_AND_CLEAR_YOUNG
 130 #define page_test_and_clear_young(page) (0)
 131 #endif
 132
 133 #ifndef __HAVE_ARCH_PGD_OFFSET_GATE
 134 #define pgd_offset_gate(mm, addr)       pgd_offset(mm, addr)
 135 #endif
 136
 137 #endif /* _ASM_GENERIC_PGTABLE_H */