1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef _LINUX_KASAN_H |
3 | #define _LINUX_KASAN_H |
4 | |
5 | #include <linux/bug.h> |
6 | #include <linux/kasan-enabled.h> |
7 | #include <linux/kernel.h> |
8 | #include <linux/static_key.h> |
9 | #include <linux/types.h> |
10 | |
11 | struct kmem_cache; |
12 | struct page; |
13 | struct slab; |
14 | struct vm_struct; |
15 | struct task_struct; |
16 | |
17 | #ifdef CONFIG_KASAN |
18 | |
19 | #include <linux/linkage.h> |
20 | #include <asm/kasan.h> |
21 | |
22 | #endif |
23 | |
24 | typedef unsigned int __bitwise kasan_vmalloc_flags_t; |
25 | |
26 | #define KASAN_VMALLOC_NONE ((__force kasan_vmalloc_flags_t)0x00u) |
27 | #define KASAN_VMALLOC_INIT ((__force kasan_vmalloc_flags_t)0x01u) |
28 | #define KASAN_VMALLOC_VM_ALLOC ((__force kasan_vmalloc_flags_t)0x02u) |
29 | #define KASAN_VMALLOC_PROT_NORMAL ((__force kasan_vmalloc_flags_t)0x04u) |
30 | |
31 | #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS) |
32 | |
33 | #include <linux/pgtable.h> |
34 | |
35 | /* Software KASAN implementations use shadow memory. */ |
36 | |
37 | #ifdef CONFIG_KASAN_SW_TAGS |
38 | /* This matches KASAN_TAG_INVALID. */ |
39 | #define KASAN_SHADOW_INIT 0xFE |
40 | #else |
41 | #define KASAN_SHADOW_INIT 0 |
42 | #endif |
43 | |
44 | #ifndef PTE_HWTABLE_PTRS |
45 | #define PTE_HWTABLE_PTRS 0 |
46 | #endif |
47 | |
48 | extern unsigned char kasan_early_shadow_page[PAGE_SIZE]; |
49 | extern pte_t kasan_early_shadow_pte[MAX_PTRS_PER_PTE + PTE_HWTABLE_PTRS]; |
50 | extern pmd_t kasan_early_shadow_pmd[MAX_PTRS_PER_PMD]; |
51 | extern pud_t kasan_early_shadow_pud[MAX_PTRS_PER_PUD]; |
52 | extern p4d_t kasan_early_shadow_p4d[MAX_PTRS_PER_P4D]; |
53 | |
54 | int kasan_populate_early_shadow(const void *shadow_start, |
55 | const void *shadow_end); |
56 | |
57 | #ifndef kasan_mem_to_shadow |
58 | static inline void *kasan_mem_to_shadow(const void *addr) |
59 | { |
60 | return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT) |
61 | + KASAN_SHADOW_OFFSET; |
62 | } |
63 | #endif |
64 | |
65 | int kasan_add_zero_shadow(void *start, unsigned long size); |
66 | void kasan_remove_zero_shadow(void *start, unsigned long size); |
67 | |
68 | /* Enable reporting bugs after kasan_disable_current() */ |
69 | extern void kasan_enable_current(void); |
70 | |
71 | /* Disable reporting bugs for current task */ |
72 | extern void kasan_disable_current(void); |
73 | |
74 | #else /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */ |
75 | |
76 | static inline int kasan_add_zero_shadow(void *start, unsigned long size) |
77 | { |
78 | return 0; |
79 | } |
80 | static inline void kasan_remove_zero_shadow(void *start, |
81 | unsigned long size) |
82 | {} |
83 | |
84 | static inline void kasan_enable_current(void) {} |
85 | static inline void kasan_disable_current(void) {} |
86 | |
87 | #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */ |
88 | |
89 | #ifdef CONFIG_KASAN_HW_TAGS |
90 | |
91 | #else /* CONFIG_KASAN_HW_TAGS */ |
92 | |
93 | #endif /* CONFIG_KASAN_HW_TAGS */ |
94 | |
95 | static inline bool kasan_has_integrated_init(void) |
96 | { |
97 | return kasan_hw_tags_enabled(); |
98 | } |
99 | |
100 | #ifdef CONFIG_KASAN |
101 | void __kasan_unpoison_range(const void *addr, size_t size); |
102 | static __always_inline void kasan_unpoison_range(const void *addr, size_t size) |
103 | { |
104 | if (kasan_enabled()) |
105 | __kasan_unpoison_range(addr, size); |
106 | } |
107 | |
108 | void __kasan_poison_pages(struct page *page, unsigned int order, bool init); |
109 | static __always_inline void kasan_poison_pages(struct page *page, |
110 | unsigned int order, bool init) |
111 | { |
112 | if (kasan_enabled()) |
113 | __kasan_poison_pages(page, order, init); |
114 | } |
115 | |
116 | bool __kasan_unpoison_pages(struct page *page, unsigned int order, bool init); |
117 | static __always_inline bool kasan_unpoison_pages(struct page *page, |
118 | unsigned int order, bool init) |
119 | { |
120 | if (kasan_enabled()) |
121 | return __kasan_unpoison_pages(page, order, init); |
122 | return false; |
123 | } |
124 | |
125 | void __kasan_poison_slab(struct slab *slab); |
126 | static __always_inline void kasan_poison_slab(struct slab *slab) |
127 | { |
128 | if (kasan_enabled()) |
129 | __kasan_poison_slab(slab); |
130 | } |
131 | |
132 | void __kasan_unpoison_object_data(struct kmem_cache *cache, void *object); |
133 | static __always_inline void kasan_unpoison_object_data(struct kmem_cache *cache, |
134 | void *object) |
135 | { |
136 | if (kasan_enabled()) |
137 | __kasan_unpoison_object_data(cache, object); |
138 | } |
139 | |
140 | void __kasan_poison_object_data(struct kmem_cache *cache, void *object); |
141 | static __always_inline void kasan_poison_object_data(struct kmem_cache *cache, |
142 | void *object) |
143 | { |
144 | if (kasan_enabled()) |
145 | __kasan_poison_object_data(cache, object); |
146 | } |
147 | |
148 | void * __must_check __kasan_init_slab_obj(struct kmem_cache *cache, |
149 | const void *object); |
150 | static __always_inline void * __must_check kasan_init_slab_obj( |
151 | struct kmem_cache *cache, const void *object) |
152 | { |
153 | if (kasan_enabled()) |
154 | return __kasan_init_slab_obj(cache, object); |
155 | return (void *)object; |
156 | } |
157 | |
158 | bool __kasan_slab_free(struct kmem_cache *s, void *object, |
159 | unsigned long ip, bool init); |
160 | static __always_inline bool kasan_slab_free(struct kmem_cache *s, |
161 | void *object, bool init) |
162 | { |
163 | if (kasan_enabled()) |
164 | return __kasan_slab_free(s, object, _RET_IP_, init); |
165 | return false; |
166 | } |
167 | |
168 | void __kasan_kfree_large(void *ptr, unsigned long ip); |
169 | static __always_inline void kasan_kfree_large(void *ptr) |
170 | { |
171 | if (kasan_enabled()) |
172 | __kasan_kfree_large(ptr, _RET_IP_); |
173 | } |
174 | |
175 | void __kasan_slab_free_mempool(void *ptr, unsigned long ip); |
176 | static __always_inline void kasan_slab_free_mempool(void *ptr) |
177 | { |
178 | if (kasan_enabled()) |
179 | __kasan_slab_free_mempool(ptr, _RET_IP_); |
180 | } |
181 | |
182 | void * __must_check __kasan_slab_alloc(struct kmem_cache *s, |
183 | void *object, gfp_t flags, bool init); |
184 | static __always_inline void * __must_check kasan_slab_alloc( |
185 | struct kmem_cache *s, void *object, gfp_t flags, bool init) |
186 | { |
187 | if (kasan_enabled()) |
188 | return __kasan_slab_alloc(s, object, flags, init); |
189 | return object; |
190 | } |
191 | |
192 | void * __must_check __kasan_kmalloc(struct kmem_cache *s, const void *object, |
193 | size_t size, gfp_t flags); |
194 | static __always_inline void * __must_check kasan_kmalloc(struct kmem_cache *s, |
195 | const void *object, size_t size, gfp_t flags) |
196 | { |
197 | if (kasan_enabled()) |
198 | return __kasan_kmalloc(s, object, size, flags); |
199 | return (void *)object; |
200 | } |
201 | |
202 | void * __must_check __kasan_kmalloc_large(const void *ptr, |
203 | size_t size, gfp_t flags); |
204 | static __always_inline void * __must_check kasan_kmalloc_large(const void *ptr, |
205 | size_t size, gfp_t flags) |
206 | { |
207 | if (kasan_enabled()) |
208 | return __kasan_kmalloc_large(ptr, size, flags); |
209 | return (void *)ptr; |
210 | } |
211 | |
212 | void * __must_check __kasan_krealloc(const void *object, |
213 | size_t new_size, gfp_t flags); |
214 | static __always_inline void * __must_check kasan_krealloc(const void *object, |
215 | size_t new_size, gfp_t flags) |
216 | { |
217 | if (kasan_enabled()) |
218 | return __kasan_krealloc(object, new_size, flags); |
219 | return (void *)object; |
220 | } |
221 | |
222 | /* |
223 | * Unlike kasan_check_read/write(), kasan_check_byte() is performed even for |
224 | * the hardware tag-based mode that doesn't rely on compiler instrumentation. |
225 | */ |
226 | bool __kasan_check_byte(const void *addr, unsigned long ip); |
227 | static __always_inline bool kasan_check_byte(const void *addr) |
228 | { |
229 | if (kasan_enabled()) |
230 | return __kasan_check_byte(addr, _RET_IP_); |
231 | return true; |
232 | } |
233 | |
234 | #else /* CONFIG_KASAN */ |
235 | |
236 | static inline void kasan_unpoison_range(const void *address, size_t size) {} |
237 | static inline void kasan_poison_pages(struct page *page, unsigned int order, |
238 | bool init) {} |
239 | static inline bool kasan_unpoison_pages(struct page *page, unsigned int order, |
240 | bool init) |
241 | { |
242 | return false; |
243 | } |
244 | static inline void kasan_poison_slab(struct slab *slab) {} |
245 | static inline void kasan_unpoison_object_data(struct kmem_cache *cache, |
246 | void *object) {} |
247 | static inline void kasan_poison_object_data(struct kmem_cache *cache, |
248 | void *object) {} |
249 | static inline void *kasan_init_slab_obj(struct kmem_cache *cache, |
250 | const void *object) |
251 | { |
252 | return (void *)object; |
253 | } |
254 | static inline bool kasan_slab_free(struct kmem_cache *s, void *object, bool init) |
255 | { |
256 | return false; |
257 | } |
258 | static inline void kasan_kfree_large(void *ptr) {} |
259 | static inline void kasan_slab_free_mempool(void *ptr) {} |
260 | static inline void *kasan_slab_alloc(struct kmem_cache *s, void *object, |
261 | gfp_t flags, bool init) |
262 | { |
263 | return object; |
264 | } |
265 | static inline void *kasan_kmalloc(struct kmem_cache *s, const void *object, |
266 | size_t size, gfp_t flags) |
267 | { |
268 | return (void *)object; |
269 | } |
270 | static inline void *kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags) |
271 | { |
272 | return (void *)ptr; |
273 | } |
274 | static inline void *kasan_krealloc(const void *object, size_t new_size, |
275 | gfp_t flags) |
276 | { |
277 | return (void *)object; |
278 | } |
279 | static inline bool kasan_check_byte(const void *address) |
280 | { |
281 | return true; |
282 | } |
283 | |
284 | #endif /* CONFIG_KASAN */ |
285 | |
286 | #if defined(CONFIG_KASAN) && defined(CONFIG_KASAN_STACK) |
287 | void kasan_unpoison_task_stack(struct task_struct *task); |
288 | asmlinkage void kasan_unpoison_task_stack_below(const void *watermark); |
289 | #else |
290 | static inline void kasan_unpoison_task_stack(struct task_struct *task) {} |
291 | static inline void kasan_unpoison_task_stack_below(const void *watermark) {} |
292 | #endif |
293 | |
294 | #ifdef CONFIG_KASAN_GENERIC |
295 | |
296 | struct kasan_cache { |
297 | int alloc_meta_offset; |
298 | int free_meta_offset; |
299 | }; |
300 | |
301 | size_t kasan_metadata_size(struct kmem_cache *cache, bool in_object); |
302 | slab_flags_t kasan_never_merge(void); |
303 | void kasan_cache_create(struct kmem_cache *cache, unsigned int *size, |
304 | slab_flags_t *flags); |
305 | |
306 | void kasan_cache_shrink(struct kmem_cache *cache); |
307 | void kasan_cache_shutdown(struct kmem_cache *cache); |
308 | void kasan_record_aux_stack(void *ptr); |
309 | void kasan_record_aux_stack_noalloc(void *ptr); |
310 | |
311 | #else /* CONFIG_KASAN_GENERIC */ |
312 | |
313 | /* Tag-based KASAN modes do not use per-object metadata. */ |
314 | static inline size_t kasan_metadata_size(struct kmem_cache *cache, |
315 | bool in_object) |
316 | { |
317 | return 0; |
318 | } |
319 | /* And thus nothing prevents cache merging. */ |
320 | static inline slab_flags_t kasan_never_merge(void) |
321 | { |
322 | return 0; |
323 | } |
324 | /* And no cache-related metadata initialization is required. */ |
325 | static inline void kasan_cache_create(struct kmem_cache *cache, |
326 | unsigned int *size, |
327 | slab_flags_t *flags) {} |
328 | |
329 | static inline void kasan_cache_shrink(struct kmem_cache *cache) {} |
330 | static inline void kasan_cache_shutdown(struct kmem_cache *cache) {} |
331 | static inline void kasan_record_aux_stack(void *ptr) {} |
332 | static inline void kasan_record_aux_stack_noalloc(void *ptr) {} |
333 | |
334 | #endif /* CONFIG_KASAN_GENERIC */ |
335 | |
336 | #if defined(CONFIG_KASAN_SW_TAGS) || defined(CONFIG_KASAN_HW_TAGS) |
337 | |
338 | static inline void *kasan_reset_tag(const void *addr) |
339 | { |
340 | return (void *)arch_kasan_reset_tag(addr); |
341 | } |
342 | |
343 | /** |
344 | * kasan_report - print a report about a bad memory access detected by KASAN |
345 | * @addr: address of the bad access |
346 | * @size: size of the bad access |
347 | * @is_write: whether the bad access is a write or a read |
348 | * @ip: instruction pointer for the accessibility check or the bad access itself |
349 | */ |
350 | bool kasan_report(const void *addr, size_t size, |
351 | bool is_write, unsigned long ip); |
352 | |
353 | #else /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */ |
354 | |
355 | static inline void *kasan_reset_tag(const void *addr) |
356 | { |
357 | return (void *)addr; |
358 | } |
359 | |
360 | #endif /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS*/ |
361 | |
362 | #ifdef CONFIG_KASAN_HW_TAGS |
363 | |
364 | void kasan_report_async(void); |
365 | |
366 | #endif /* CONFIG_KASAN_HW_TAGS */ |
367 | |
368 | #ifdef CONFIG_KASAN_SW_TAGS |
369 | void __init kasan_init_sw_tags(void); |
370 | #else |
371 | static inline void kasan_init_sw_tags(void) { } |
372 | #endif |
373 | |
374 | #ifdef CONFIG_KASAN_HW_TAGS |
375 | void kasan_init_hw_tags_cpu(void); |
376 | void __init kasan_init_hw_tags(void); |
377 | #else |
378 | static inline void kasan_init_hw_tags_cpu(void) { } |
379 | static inline void kasan_init_hw_tags(void) { } |
380 | #endif |
381 | |
382 | #ifdef CONFIG_KASAN_VMALLOC |
383 | |
384 | #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS) |
385 | |
386 | void kasan_populate_early_vm_area_shadow(void *start, unsigned long size); |
387 | int kasan_populate_vmalloc(unsigned long addr, unsigned long size); |
388 | void kasan_release_vmalloc(unsigned long start, unsigned long end, |
389 | unsigned long free_region_start, |
390 | unsigned long free_region_end); |
391 | |
392 | #else /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */ |
393 | |
394 | static inline void kasan_populate_early_vm_area_shadow(void *start, |
395 | unsigned long size) |
396 | { } |
397 | static inline int kasan_populate_vmalloc(unsigned long start, |
398 | unsigned long size) |
399 | { |
400 | return 0; |
401 | } |
402 | static inline void kasan_release_vmalloc(unsigned long start, |
403 | unsigned long end, |
404 | unsigned long free_region_start, |
405 | unsigned long free_region_end) { } |
406 | |
407 | #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */ |
408 | |
409 | void *__kasan_unpoison_vmalloc(const void *start, unsigned long size, |
410 | kasan_vmalloc_flags_t flags); |
411 | static __always_inline void *kasan_unpoison_vmalloc(const void *start, |
412 | unsigned long size, |
413 | kasan_vmalloc_flags_t flags) |
414 | { |
415 | if (kasan_enabled()) |
416 | return __kasan_unpoison_vmalloc(start, size, flags); |
417 | return (void *)start; |
418 | } |
419 | |
420 | void __kasan_poison_vmalloc(const void *start, unsigned long size); |
421 | static __always_inline void kasan_poison_vmalloc(const void *start, |
422 | unsigned long size) |
423 | { |
424 | if (kasan_enabled()) |
425 | __kasan_poison_vmalloc(start, size); |
426 | } |
427 | |
428 | #else /* CONFIG_KASAN_VMALLOC */ |
429 | |
430 | static inline void kasan_populate_early_vm_area_shadow(void *start, |
431 | unsigned long size) { } |
432 | static inline int kasan_populate_vmalloc(unsigned long start, |
433 | unsigned long size) |
434 | { |
435 | return 0; |
436 | } |
437 | static inline void kasan_release_vmalloc(unsigned long start, |
438 | unsigned long end, |
439 | unsigned long free_region_start, |
440 | unsigned long free_region_end) { } |
441 | |
442 | static inline void *kasan_unpoison_vmalloc(const void *start, |
443 | unsigned long size, |
444 | kasan_vmalloc_flags_t flags) |
445 | { |
446 | return (void *)start; |
447 | } |
448 | static inline void kasan_poison_vmalloc(const void *start, unsigned long size) |
449 | { } |
450 | |
451 | #endif /* CONFIG_KASAN_VMALLOC */ |
452 | |
453 | #if (defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)) && \ |
454 | !defined(CONFIG_KASAN_VMALLOC) |
455 | |
456 | /* |
457 | * These functions allocate and free shadow memory for kernel modules. |
458 | * They are only required when KASAN_VMALLOC is not supported, as otherwise |
459 | * shadow memory is allocated by the generic vmalloc handlers. |
460 | */ |
461 | int kasan_alloc_module_shadow(void *addr, size_t size, gfp_t gfp_mask); |
462 | void kasan_free_module_shadow(const struct vm_struct *vm); |
463 | |
464 | #else /* (CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS) && !CONFIG_KASAN_VMALLOC */ |
465 | |
466 | static inline int kasan_alloc_module_shadow(void *addr, size_t size, gfp_t gfp_mask) { return 0; } |
467 | static inline void kasan_free_module_shadow(const struct vm_struct *vm) {} |
468 | |
469 | #endif /* (CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS) && !CONFIG_KASAN_VMALLOC */ |
470 | |
471 | #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS) |
472 | void kasan_non_canonical_hook(unsigned long addr); |
473 | #else /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */ |
474 | static inline void kasan_non_canonical_hook(unsigned long addr) { } |
475 | #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */ |
476 | |
477 | #endif /* LINUX_KASAN_H */ |
478 | |