1 #ifndef _LINUX_HIGHMEM_H 2 #define _LINUX_HIGHMEM_H 3 4 #include <linux/fs.h> 5 #include <linux/kernel.h> 6 #include <linux/mm.h> 7 #include <linux/uaccess.h> 8 #include <linux/hardirq.h> 9 10 #include <asm/cacheflush.h> 11 12 #ifndef ARCH_HAS_FLUSH_ANON_PAGE 13 static inline void flush_anon_page(struct vm_area_struct *vma, struct page *page, unsigned long vmaddr) 14 { 15 } 16 #endif 17 18 #ifndef ARCH_HAS_FLUSH_KERNEL_DCACHE_PAGE 19 static inline void flush_kernel_dcache_page(struct page *page) 20 { 21 } 22 static inline void flush_kernel_vmap_range(void *vaddr, int size) 23 { 24 } 25 static inline void invalidate_kernel_vmap_range(void *vaddr, int size) 26 { 27 } 28 #endif 29 30 #include <asm/kmap_types.h> 31 32 #ifdef CONFIG_HIGHMEM 33 #include <asm/highmem.h> 34 35 /* declarations for linux/mm/highmem.c */ 36 unsigned int nr_free_highpages(void); 37 extern unsigned long totalhigh_pages; 38 39 void kmap_flush_unused(void); 40 41 #else /* CONFIG_HIGHMEM */ 42 43 static inline unsigned int nr_free_highpages(void) { return 0; } 44 45 #define totalhigh_pages 0UL 46 47 #ifndef ARCH_HAS_KMAP 48 static inline void *kmap(struct page *page) 49 { 50 might_sleep(); 51 return page_address(page); 52 } 53 54 static inline void kunmap(struct page *page) 55 { 56 } 57 58 static inline void *kmap_atomic(struct page *page) 59 { 60 pagefault_disable(); 61 return page_address(page); 62 } 63 #define kmap_atomic_prot(page, prot) kmap_atomic(page) 64 65 static inline void __kunmap_atomic(void *addr) 66 { 67 pagefault_enable(); 68 } 69 70 #define kmap_atomic_pfn(pfn) kmap_atomic(pfn_to_page(pfn)) 71 #define kmap_atomic_to_page(ptr) virt_to_page(ptr) 72 73 #define kmap_flush_unused() do {} while(0) 74 #endif 75 76 #endif /* CONFIG_HIGHMEM */ 77 78 #if defined(CONFIG_HIGHMEM) || defined(CONFIG_X86_32) 79 80 DECLARE_PER_CPU(int, __kmap_atomic_idx); 81 82 static inline int kmap_atomic_idx_push(void) 83 { 84 int idx = __this_cpu_inc_return(__kmap_atomic_idx) - 1; 85 86 #ifdef CONFIG_DEBUG_HIGHMEM 87 WARN_ON_ONCE(in_irq() && !irqs_disabled()); 88 BUG_ON(idx > KM_TYPE_NR); 89 #endif 90 return idx; 91 } 92 93 static inline int kmap_atomic_idx(void) 94 { 95 return __this_cpu_read(__kmap_atomic_idx) - 1; 96 } 97 98 static inline void kmap_atomic_idx_pop(void) 99 { 100 #ifdef CONFIG_DEBUG_HIGHMEM 101 int idx = __this_cpu_dec_return(__kmap_atomic_idx); 102 103 BUG_ON(idx < 0); 104 #else 105 __this_cpu_dec(__kmap_atomic_idx); 106 #endif 107 } 108 109 #endif 110 111 /* 112 * NOTE: 113 * kmap_atomic() and kunmap_atomic() with two arguments are deprecated. 114 * We only keep them for backward compatibility, any usage of them 115 * are now warned. 116 */ 117 118 #define PASTE(a, b) a ## b 119 #define PASTE2(a, b) PASTE(a, b) 120 121 #define NARG_(_2, _1, n, ...) n 122 #define NARG(...) NARG_(__VA_ARGS__, 2, 1, :) 123 124 static inline void __deprecated *kmap_atomic_deprecated(struct page *page, 125 enum km_type km) 126 { 127 return kmap_atomic(page); 128 } 129 130 #define kmap_atomic1(...) kmap_atomic(__VA_ARGS__) 131 #define kmap_atomic2(...) kmap_atomic_deprecated(__VA_ARGS__) 132 #define kmap_atomic(...) PASTE2(kmap_atomic, NARG(__VA_ARGS__)(__VA_ARGS__)) 133 134 static inline void __deprecated __kunmap_atomic_deprecated(void *addr, 135 enum km_type km) 136 { 137 __kunmap_atomic(addr); 138 } 139 140 /* 141 * Prevent people trying to call kunmap_atomic() as if it were kunmap() 142 * kunmap_atomic() should get the return value of kmap_atomic, not the page. 143 */ 144 #define kunmap_atomic_deprecated(addr, km) \ 145 do { \ 146 BUILD_BUG_ON(__same_type((addr), struct page *)); \ 147 __kunmap_atomic_deprecated(addr, km); \ 148 } while (0) 149 150 #define kunmap_atomic_withcheck(addr) \ 151 do { \ 152 BUILD_BUG_ON(__same_type((addr), struct page *)); \ 153 __kunmap_atomic(addr); \ 154 } while (0) 155 156 #define kunmap_atomic1(...) kunmap_atomic_withcheck(__VA_ARGS__) 157 #define kunmap_atomic2(...) kunmap_atomic_deprecated(__VA_ARGS__) 158 #define kunmap_atomic(...) PASTE2(kunmap_atomic, NARG(__VA_ARGS__)(__VA_ARGS__)) 159 /**** End of C pre-processor tricks for deprecated macros ****/ 160 161 /* when CONFIG_HIGHMEM is not set these will be plain clear/copy_page */ 162 #ifndef clear_user_highpage 163 static inline void clear_user_highpage(struct page *page, unsigned long vaddr) 164 { 165 void *addr = kmap_atomic(page); 166 clear_user_page(addr, vaddr, page); 167 kunmap_atomic(addr); 168 } 169 #endif 170 171 #ifndef __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE 172 /** 173 * __alloc_zeroed_user_highpage - Allocate a zeroed HIGHMEM page for a VMA with caller-specified movable GFP flags 174 * @movableflags: The GFP flags related to the pages future ability to move like __GFP_MOVABLE 175 * @vma: The VMA the page is to be allocated for 176 * @vaddr: The virtual address the page will be inserted into 177 * 178 * This function will allocate a page for a VMA but the caller is expected 179 * to specify via movableflags whether the page will be movable in the 180 * future or not 181 * 182 * An architecture may override this function by defining 183 * __HAVE_ARCH_ALLOC_ZEROED_USER_HIGHPAGE and providing their own 184 * implementation. 185 */ 186 static inline struct page * 187 __alloc_zeroed_user_highpage(gfp_t movableflags, 188 struct vm_area_struct *vma, 189 unsigned long vaddr) 190 { 191 struct page *page = alloc_page_vma(GFP_HIGHUSER | movableflags, 192 vma, vaddr); 193 194 if (page) 195 clear_user_highpage(page, vaddr); 196 197 return page; 198 } 199 #endif 200 201 /** 202 * alloc_zeroed_user_highpage_movable - Allocate a zeroed HIGHMEM page for a VMA that the caller knows can move 203 * @vma: The VMA the page is to be allocated for 204 * @vaddr: The virtual address the page will be inserted into 205 * 206 * This function will allocate a page for a VMA that the caller knows will 207 * be able to migrate in the future using move_pages() or reclaimed 208 */ 209 static inline struct page * 210 alloc_zeroed_user_highpage_movable(struct vm_area_struct *vma, 211 unsigned long vaddr) 212 { 213 return __alloc_zeroed_user_highpage(__GFP_MOVABLE, vma, vaddr); 214 } 215 216 static inline void clear_highpage(struct page *page) 217 { 218 void *kaddr = kmap_atomic(page); 219 clear_page(kaddr); 220 kunmap_atomic(kaddr); 221 } 222 223 static inline void zero_user_segments(struct page *page, 224 unsigned start1, unsigned end1, 225 unsigned start2, unsigned end2) 226 { 227 void *kaddr = kmap_atomic(page); 228 229 BUG_ON(end1 > PAGE_SIZE || end2 > PAGE_SIZE); 230 231 if (end1 > start1) 232 memset(kaddr + start1, 0, end1 - start1); 233 234 if (end2 > start2) 235 memset(kaddr + start2, 0, end2 - start2); 236 237 kunmap_atomic(kaddr); 238 flush_dcache_page(page); 239 } 240 241 static inline void zero_user_segment(struct page *page, 242 unsigned start, unsigned end) 243 { 244 zero_user_segments(page, start, end, 0, 0); 245 } 246 247 static inline void zero_user(struct page *page, 248 unsigned start, unsigned size) 249 { 250 zero_user_segments(page, start, start + size, 0, 0); 251 } 252 253 static inline void __deprecated memclear_highpage_flush(struct page *page, 254 unsigned int offset, unsigned int size) 255 { 256 zero_user(page, offset, size); 257 } 258 259 #ifndef __HAVE_ARCH_COPY_USER_HIGHPAGE 260 261 static inline void copy_user_highpage(struct page *to, struct page *from, 262 unsigned long vaddr, struct vm_area_struct *vma) 263 { 264 char *vfrom, *vto; 265 266 vfrom = kmap_atomic(from); 267 vto = kmap_atomic(to); 268 copy_user_page(vto, vfrom, vaddr, to); 269 kunmap_atomic(vto); 270 kunmap_atomic(vfrom); 271 } 272 273 #endif 274 275 static inline void copy_highpage(struct page *to, struct page *from) 276 { 277 char *vfrom, *vto; 278 279 vfrom = kmap_atomic(from); 280 vto = kmap_atomic(to); 281 copy_page(vto, vfrom); 282 kunmap_atomic(vto); 283 kunmap_atomic(vfrom); 284 } 285 286 #endif /* _LINUX_HIGHMEM_H */ 287