arch/x86/include/asm/cacheflush.h

   1 #ifndef _ASM_X86_CACHEFLUSH_H
   2 #define _ASM_X86_CACHEFLUSH_H
   3
   4 /* Caches aren't brain-dead on the intel. */
   5 #include <asm-generic/cacheflush.h>
   6 #include <asm/special_insns.h>
   7
   8 #ifdef CONFIG_X86_PAT
   9 /*
  10  * X86 PAT uses page flags WC and Uncached together to keep track of
  11  * memory type of pages that have backing page struct. X86 PAT supports 3
  12  * different memory types, _PAGE_CACHE_WB, _PAGE_CACHE_WC and
  13  * _PAGE_CACHE_UC_MINUS and fourth state where page's memory type has not
  14  * been changed from its default (value of -1 used to denote this).
  15  * Note we do not support _PAGE_CACHE_UC here.
  16  */
  17
  18 #define _PGMT_DEFAULT           0
  19 #define _PGMT_WC                (1UL << PG_arch_1)
  20 #define _PGMT_UC_MINUS          (1UL << PG_uncached)
  21 #define _PGMT_WB                (1UL << PG_uncached | 1UL << PG_arch_1)
  22 #define _PGMT_MASK              (1UL << PG_uncached | 1UL << PG_arch_1)
  23 #define _PGMT_CLEAR_MASK        (~_PGMT_MASK)
  24
  25 static inline unsigned long get_page_memtype(struct page *pg)
  26 {
  27         unsigned long pg_flags = pg->flags & _PGMT_MASK;
  28
  29         if (pg_flags == _PGMT_DEFAULT)
  30                 return -1;
  31         else if (pg_flags == _PGMT_WC)
  32                 return _PAGE_CACHE_WC;
  33         else if (pg_flags == _PGMT_UC_MINUS)
  34                 return _PAGE_CACHE_UC_MINUS;
  35         else
  36                 return _PAGE_CACHE_WB;
  37 }
  38
  39 static inline void set_page_memtype(struct page *pg, unsigned long memtype)
  40 {
  41         unsigned long memtype_flags = _PGMT_DEFAULT;
  42         unsigned long old_flags;
  43         unsigned long new_flags;
  44
  45         switch (memtype) {
  46         case _PAGE_CACHE_WC:
  47                 memtype_flags = _PGMT_WC;
  48                 break;
  49         case _PAGE_CACHE_UC_MINUS:
  50                 memtype_flags = _PGMT_UC_MINUS;
  51                 break;
  52         case _PAGE_CACHE_WB:
  53                 memtype_flags = _PGMT_WB;
  54                 break;
  55         }
  56
  57         do {
  58                 old_flags = pg->flags;
  59                 new_flags = (old_flags & _PGMT_CLEAR_MASK) | memtype_flags;
  60         } while (cmpxchg(&pg->flags, old_flags, new_flags) != old_flags);
  61 }
  62 #else
  63 static inline unsigned long get_page_memtype(struct page *pg) { return -1; }
  64 static inline void set_page_memtype(struct page *pg, unsigned long memtype) { }
  65 #endif
  66
  67 /*
  68  * The set_memory_* API can be used to change various attributes of a virtual
  69  * address range. The attributes include:
  70  * Cachability   : UnCached, WriteCombining, WriteBack
  71  * Executability : eXeutable, NoteXecutable
  72  * Read/Write    : ReadOnly, ReadWrite
  73  * Presence      : NotPresent
  74  *
  75  * Within a category, the attributes are mutually exclusive.
  76  *
  77  * The implementation of this API will take care of various aspects that
  78  * are associated with changing such attributes, such as:
  79  * - Flushing TLBs
  80  * - Flushing CPU caches
  81  * - Making sure aliases of the memory behind the mapping don't violate
  82  *   coherency rules as defined by the CPU in the system.
  83  *
  84  * What this API does not do:
  85  * - Provide exclusion between various callers - including callers that
  86  *   operation on other mappings of the same physical page
  87  * - Restore default attributes when a page is freed
  88  * - Guarantee that mappings other than the requested one are
  89  *   in any state, other than that these do not violate rules for
  90  *   the CPU you have. Do not depend on any effects on other mappings,
  91  *   CPUs other than the one you have may have more relaxed rules.
  92  * The caller is required to take care of these.
  93  */
  94
  95 int _set_memory_uc(unsigned long addr, int numpages);
  96 int _set_memory_wc(unsigned long addr, int numpages);
  97 int _set_memory_wb(unsigned long addr, int numpages);
  98 int set_memory_uc(unsigned long addr, int numpages);
  99 int set_memory_wc(unsigned long addr, int numpages);
 100 int set_memory_wb(unsigned long addr, int numpages);
 101 int set_memory_x(unsigned long addr, int numpages);
 102 int set_memory_nx(unsigned long addr, int numpages);
 103 int set_memory_ro(unsigned long addr, int numpages);
 104 int set_memory_rw(unsigned long addr, int numpages);
 105 int set_memory_np(unsigned long addr, int numpages);
 106 int set_memory_4k(unsigned long addr, int numpages);
 107
 108 int set_memory_array_uc(unsigned long *addr, int addrinarray);
 109 int set_memory_array_wc(unsigned long *addr, int addrinarray);
 110 int set_memory_array_wb(unsigned long *addr, int addrinarray);
 111
 112 int set_pages_array_uc(struct page **pages, int addrinarray);
 113 int set_pages_array_wc(struct page **pages, int addrinarray);
 114 int set_pages_array_wb(struct page **pages, int addrinarray);
 115
 116 /*
 117  * For legacy compatibility with the old APIs, a few functions
 118  * are provided that work on a "struct page".
 119  * These functions operate ONLY on the 1:1 kernel mapping of the
 120  * memory that the struct page represents, and internally just
 121  * call the set_memory_* function. See the description of the
 122  * set_memory_* function for more details on conventions.
 123  *
 124  * These APIs should be considered *deprecated* and are likely going to
 125  * be removed in the future.
 126  * The reason for this is the implicit operation on the 1:1 mapping only,
 127  * making this not a generally useful API.
 128  *
 129  * Specifically, many users of the old APIs had a virtual address,
 130  * called virt_to_page() or vmalloc_to_page() on that address to
 131  * get a struct page* that the old API required.
 132  * To convert these cases, use set_memory_*() on the original
 133  * virtual address, do not use these functions.
 134  */
 135
 136 int set_pages_uc(struct page *page, int numpages);
 137 int set_pages_wb(struct page *page, int numpages);
 138 int set_pages_x(struct page *page, int numpages);
 139 int set_pages_nx(struct page *page, int numpages);
 140 int set_pages_ro(struct page *page, int numpages);
 141 int set_pages_rw(struct page *page, int numpages);
 142
 143
 144 void clflush_cache_range(void *addr, unsigned int size);
 145
 146 #ifdef CONFIG_DEBUG_RODATA
 147 void mark_rodata_ro(void);
 148 extern const int rodata_test_data;
 149 extern int kernel_set_to_readonly;
 150 void set_kernel_text_rw(void);
 151 void set_kernel_text_ro(void);
 152 #else
 153 static inline void set_kernel_text_rw(void) { }
 154 static inline void set_kernel_text_ro(void) { }
 155 #endif
 156
 157 #ifdef CONFIG_DEBUG_RODATA_TEST
 158 int rodata_test(void);
 159 #else
 160 static inline int rodata_test(void)
 161 {
 162         return 0;
 163 }
 164 #endif
 165
 166 #endif /* _ASM_X86_CACHEFLUSH_H */