1 /* SPDX-License-Identifier: GPL-2.0 */
6 #include <linux/kasan-enabled.h>
7 #include <linux/kernel.h>
8 #include <linux/static_key.h>
9 #include <linux/types.h>
19 #include <linux/linkage.h>
20 #include <asm/kasan.h>
22 /* kasan_data struct is used in KUnit tests for KASAN expected failures */
23 struct kunit_kasan_expectation {
29 #if defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)
31 #include <linux/pgtable.h>
33 /* Software KASAN implementations use shadow memory. */
35 #ifdef CONFIG_KASAN_SW_TAGS
36 /* This matches KASAN_TAG_INVALID. */
37 #define KASAN_SHADOW_INIT 0xFE
39 #define KASAN_SHADOW_INIT 0
42 #ifndef PTE_HWTABLE_PTRS
43 #define PTE_HWTABLE_PTRS 0
46 extern unsigned char kasan_early_shadow_page[PAGE_SIZE];
47 extern pte_t kasan_early_shadow_pte[MAX_PTRS_PER_PTE + PTE_HWTABLE_PTRS];
48 extern pmd_t kasan_early_shadow_pmd[MAX_PTRS_PER_PMD];
49 extern pud_t kasan_early_shadow_pud[MAX_PTRS_PER_PUD];
50 extern p4d_t kasan_early_shadow_p4d[MAX_PTRS_PER_P4D];
52 int kasan_populate_early_shadow(const void *shadow_start,
53 const void *shadow_end);
55 static inline void *kasan_mem_to_shadow(const void *addr)
57 return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)
58 + KASAN_SHADOW_OFFSET;
61 int kasan_add_zero_shadow(void *start, unsigned long size);
62 void kasan_remove_zero_shadow(void *start, unsigned long size);
64 /* Enable reporting bugs after kasan_disable_current() */
65 extern void kasan_enable_current(void);
67 /* Disable reporting bugs for current task */
68 extern void kasan_disable_current(void);
70 #else /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
72 static inline int kasan_add_zero_shadow(void *start, unsigned long size)
76 static inline void kasan_remove_zero_shadow(void *start,
80 static inline void kasan_enable_current(void) {}
81 static inline void kasan_disable_current(void) {}
83 #endif /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
85 #ifdef CONFIG_KASAN_HW_TAGS
87 void kasan_alloc_pages(struct page *page, unsigned int order, gfp_t flags);
88 void kasan_free_pages(struct page *page, unsigned int order);
90 #else /* CONFIG_KASAN_HW_TAGS */
92 static __always_inline void kasan_alloc_pages(struct page *page,
93 unsigned int order, gfp_t flags)
95 /* Only available for integrated init. */
99 static __always_inline void kasan_free_pages(struct page *page,
102 /* Only available for integrated init. */
106 #endif /* CONFIG_KASAN_HW_TAGS */
108 static inline bool kasan_has_integrated_init(void)
110 return kasan_hw_tags_enabled();
116 int alloc_meta_offset;
117 int free_meta_offset;
121 slab_flags_t __kasan_never_merge(void);
122 static __always_inline slab_flags_t kasan_never_merge(void)
125 return __kasan_never_merge();
129 void __kasan_unpoison_range(const void *addr, size_t size);
130 static __always_inline void kasan_unpoison_range(const void *addr, size_t size)
133 __kasan_unpoison_range(addr, size);
136 void __kasan_poison_pages(struct page *page, unsigned int order, bool init);
137 static __always_inline void kasan_poison_pages(struct page *page,
138 unsigned int order, bool init)
141 __kasan_poison_pages(page, order, init);
144 void __kasan_unpoison_pages(struct page *page, unsigned int order, bool init);
145 static __always_inline void kasan_unpoison_pages(struct page *page,
146 unsigned int order, bool init)
149 __kasan_unpoison_pages(page, order, init);
152 void __kasan_cache_create(struct kmem_cache *cache, unsigned int *size,
153 slab_flags_t *flags);
154 static __always_inline void kasan_cache_create(struct kmem_cache *cache,
155 unsigned int *size, slab_flags_t *flags)
158 __kasan_cache_create(cache, size, flags);
161 void __kasan_cache_create_kmalloc(struct kmem_cache *cache);
162 static __always_inline void kasan_cache_create_kmalloc(struct kmem_cache *cache)
165 __kasan_cache_create_kmalloc(cache);
168 size_t __kasan_metadata_size(struct kmem_cache *cache);
169 static __always_inline size_t kasan_metadata_size(struct kmem_cache *cache)
172 return __kasan_metadata_size(cache);
176 void __kasan_poison_slab(struct slab *slab);
177 static __always_inline void kasan_poison_slab(struct slab *slab)
180 __kasan_poison_slab(slab);
183 void __kasan_unpoison_object_data(struct kmem_cache *cache, void *object);
184 static __always_inline void kasan_unpoison_object_data(struct kmem_cache *cache,
188 __kasan_unpoison_object_data(cache, object);
191 void __kasan_poison_object_data(struct kmem_cache *cache, void *object);
192 static __always_inline void kasan_poison_object_data(struct kmem_cache *cache,
196 __kasan_poison_object_data(cache, object);
199 void * __must_check __kasan_init_slab_obj(struct kmem_cache *cache,
201 static __always_inline void * __must_check kasan_init_slab_obj(
202 struct kmem_cache *cache, const void *object)
205 return __kasan_init_slab_obj(cache, object);
206 return (void *)object;
209 bool __kasan_slab_free(struct kmem_cache *s, void *object,
210 unsigned long ip, bool init);
211 static __always_inline bool kasan_slab_free(struct kmem_cache *s,
212 void *object, bool init)
215 return __kasan_slab_free(s, object, _RET_IP_, init);
219 void __kasan_kfree_large(void *ptr, unsigned long ip);
220 static __always_inline void kasan_kfree_large(void *ptr)
223 __kasan_kfree_large(ptr, _RET_IP_);
226 void __kasan_slab_free_mempool(void *ptr, unsigned long ip);
227 static __always_inline void kasan_slab_free_mempool(void *ptr)
230 __kasan_slab_free_mempool(ptr, _RET_IP_);
233 void * __must_check __kasan_slab_alloc(struct kmem_cache *s,
234 void *object, gfp_t flags, bool init);
235 static __always_inline void * __must_check kasan_slab_alloc(
236 struct kmem_cache *s, void *object, gfp_t flags, bool init)
239 return __kasan_slab_alloc(s, object, flags, init);
243 void * __must_check __kasan_kmalloc(struct kmem_cache *s, const void *object,
244 size_t size, gfp_t flags);
245 static __always_inline void * __must_check kasan_kmalloc(struct kmem_cache *s,
246 const void *object, size_t size, gfp_t flags)
249 return __kasan_kmalloc(s, object, size, flags);
250 return (void *)object;
253 void * __must_check __kasan_kmalloc_large(const void *ptr,
254 size_t size, gfp_t flags);
255 static __always_inline void * __must_check kasan_kmalloc_large(const void *ptr,
256 size_t size, gfp_t flags)
259 return __kasan_kmalloc_large(ptr, size, flags);
263 void * __must_check __kasan_krealloc(const void *object,
264 size_t new_size, gfp_t flags);
265 static __always_inline void * __must_check kasan_krealloc(const void *object,
266 size_t new_size, gfp_t flags)
269 return __kasan_krealloc(object, new_size, flags);
270 return (void *)object;
274 * Unlike kasan_check_read/write(), kasan_check_byte() is performed even for
275 * the hardware tag-based mode that doesn't rely on compiler instrumentation.
277 bool __kasan_check_byte(const void *addr, unsigned long ip);
278 static __always_inline bool kasan_check_byte(const void *addr)
281 return __kasan_check_byte(addr, _RET_IP_);
286 bool kasan_save_enable_multi_shot(void);
287 void kasan_restore_multi_shot(bool enabled);
289 #else /* CONFIG_KASAN */
291 static inline slab_flags_t kasan_never_merge(void)
295 static inline void kasan_unpoison_range(const void *address, size_t size) {}
296 static inline void kasan_poison_pages(struct page *page, unsigned int order,
298 static inline void kasan_unpoison_pages(struct page *page, unsigned int order,
300 static inline void kasan_cache_create(struct kmem_cache *cache,
302 slab_flags_t *flags) {}
303 static inline void kasan_cache_create_kmalloc(struct kmem_cache *cache) {}
304 static inline size_t kasan_metadata_size(struct kmem_cache *cache) { return 0; }
305 static inline void kasan_poison_slab(struct slab *slab) {}
306 static inline void kasan_unpoison_object_data(struct kmem_cache *cache,
308 static inline void kasan_poison_object_data(struct kmem_cache *cache,
310 static inline void *kasan_init_slab_obj(struct kmem_cache *cache,
313 return (void *)object;
315 static inline bool kasan_slab_free(struct kmem_cache *s, void *object, bool init)
319 static inline void kasan_kfree_large(void *ptr) {}
320 static inline void kasan_slab_free_mempool(void *ptr) {}
321 static inline void *kasan_slab_alloc(struct kmem_cache *s, void *object,
322 gfp_t flags, bool init)
326 static inline void *kasan_kmalloc(struct kmem_cache *s, const void *object,
327 size_t size, gfp_t flags)
329 return (void *)object;
331 static inline void *kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags)
335 static inline void *kasan_krealloc(const void *object, size_t new_size,
338 return (void *)object;
340 static inline bool kasan_check_byte(const void *address)
345 #endif /* CONFIG_KASAN */
347 #if defined(CONFIG_KASAN) && defined(CONFIG_KASAN_STACK)
348 void kasan_unpoison_task_stack(struct task_struct *task);
350 static inline void kasan_unpoison_task_stack(struct task_struct *task) {}
353 #ifdef CONFIG_KASAN_GENERIC
355 void kasan_cache_shrink(struct kmem_cache *cache);
356 void kasan_cache_shutdown(struct kmem_cache *cache);
357 void kasan_record_aux_stack(void *ptr);
358 void kasan_record_aux_stack_noalloc(void *ptr);
360 #else /* CONFIG_KASAN_GENERIC */
362 static inline void kasan_cache_shrink(struct kmem_cache *cache) {}
363 static inline void kasan_cache_shutdown(struct kmem_cache *cache) {}
364 static inline void kasan_record_aux_stack(void *ptr) {}
365 static inline void kasan_record_aux_stack_noalloc(void *ptr) {}
367 #endif /* CONFIG_KASAN_GENERIC */
369 #if defined(CONFIG_KASAN_SW_TAGS) || defined(CONFIG_KASAN_HW_TAGS)
371 static inline void *kasan_reset_tag(const void *addr)
373 return (void *)arch_kasan_reset_tag(addr);
377 * kasan_report - print a report about a bad memory access detected by KASAN
378 * @addr: address of the bad access
379 * @size: size of the bad access
380 * @is_write: whether the bad access is a write or a read
381 * @ip: instruction pointer for the accessibility check or the bad access itself
383 bool kasan_report(unsigned long addr, size_t size,
384 bool is_write, unsigned long ip);
386 #else /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS */
388 static inline void *kasan_reset_tag(const void *addr)
393 #endif /* CONFIG_KASAN_SW_TAGS || CONFIG_KASAN_HW_TAGS*/
395 #ifdef CONFIG_KASAN_HW_TAGS
397 void kasan_report_async(void);
399 #endif /* CONFIG_KASAN_HW_TAGS */
401 #ifdef CONFIG_KASAN_SW_TAGS
402 void __init kasan_init_sw_tags(void);
404 static inline void kasan_init_sw_tags(void) { }
407 #ifdef CONFIG_KASAN_HW_TAGS
408 void kasan_init_hw_tags_cpu(void);
409 void __init kasan_init_hw_tags(void);
411 static inline void kasan_init_hw_tags_cpu(void) { }
412 static inline void kasan_init_hw_tags(void) { }
415 #ifdef CONFIG_KASAN_VMALLOC
417 int kasan_populate_vmalloc(unsigned long addr, unsigned long size);
418 void kasan_poison_vmalloc(const void *start, unsigned long size);
419 void kasan_unpoison_vmalloc(const void *start, unsigned long size);
420 void kasan_release_vmalloc(unsigned long start, unsigned long end,
421 unsigned long free_region_start,
422 unsigned long free_region_end);
424 void kasan_populate_early_vm_area_shadow(void *start, unsigned long size);
426 #else /* CONFIG_KASAN_VMALLOC */
428 static inline int kasan_populate_vmalloc(unsigned long start,
434 static inline void kasan_poison_vmalloc(const void *start, unsigned long size)
436 static inline void kasan_unpoison_vmalloc(const void *start, unsigned long size)
438 static inline void kasan_release_vmalloc(unsigned long start,
440 unsigned long free_region_start,
441 unsigned long free_region_end) {}
443 static inline void kasan_populate_early_vm_area_shadow(void *start,
447 #endif /* CONFIG_KASAN_VMALLOC */
449 #if (defined(CONFIG_KASAN_GENERIC) || defined(CONFIG_KASAN_SW_TAGS)) && \
450 !defined(CONFIG_KASAN_VMALLOC)
453 * These functions provide a special case to support backing module
454 * allocations with real shadow memory. With KASAN vmalloc, the special
455 * case is unnecessary, as the work is handled in the generic case.
457 int kasan_module_alloc(void *addr, size_t size, gfp_t gfp_mask);
458 void kasan_free_shadow(const struct vm_struct *vm);
460 #else /* (CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS) && !CONFIG_KASAN_VMALLOC */
462 static inline int kasan_module_alloc(void *addr, size_t size, gfp_t gfp_mask) { return 0; }
463 static inline void kasan_free_shadow(const struct vm_struct *vm) {}
465 #endif /* (CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS) && !CONFIG_KASAN_VMALLOC */
467 #ifdef CONFIG_KASAN_INLINE
468 void kasan_non_canonical_hook(unsigned long addr);
469 #else /* CONFIG_KASAN_INLINE */
470 static inline void kasan_non_canonical_hook(unsigned long addr) { }
471 #endif /* CONFIG_KASAN_INLINE */
473 #endif /* LINUX_KASAN_H */