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
11struct kmem_cache;
12struct page;
13struct slab;
14struct vm_struct;
15struct task_struct;
16
17#ifdef CONFIG_KASAN
18
19#include <linux/linkage.h>
20#include <asm/kasan.h>
21
22#endif
23
24typedef 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
48extern unsigned char kasan_early_shadow_page[PAGE_SIZE];
49extern pte_t kasan_early_shadow_pte[MAX_PTRS_PER_PTE + PTE_HWTABLE_PTRS];
50extern pmd_t kasan_early_shadow_pmd[MAX_PTRS_PER_PMD];
51extern pud_t kasan_early_shadow_pud[MAX_PTRS_PER_PUD];
52extern p4d_t kasan_early_shadow_p4d[MAX_PTRS_PER_P4D];
53
54int kasan_populate_early_shadow(const void *shadow_start,
55 const void *shadow_end);
56
57#ifndef kasan_mem_to_shadow
58static 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
65int kasan_add_zero_shadow(void *start, unsigned long size);
66void kasan_remove_zero_shadow(void *start, unsigned long size);
67
68/* Enable reporting bugs after kasan_disable_current() */
69extern void kasan_enable_current(void);
70
71/* Disable reporting bugs for current task */
72extern void kasan_disable_current(void);
73
74#else /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
75
76static inline int kasan_add_zero_shadow(void *start, unsigned long size)
77{
78 return 0;
79}
80static inline void kasan_remove_zero_shadow(void *start,
81 unsigned long size)
82{}
83
84static inline void kasan_enable_current(void) {}
85static 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
95static inline bool kasan_has_integrated_init(void)
96{
97 return kasan_hw_tags_enabled();
98}
99
100#ifdef CONFIG_KASAN
101void __kasan_unpoison_range(const void *addr, size_t size);
102static __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
108void __kasan_poison_pages(struct page *page, unsigned int order, bool init);
109static __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
116bool __kasan_unpoison_pages(struct page *page, unsigned int order, bool init);
117static __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
125void __kasan_poison_slab(struct slab *slab);
126static __always_inline void kasan_poison_slab(struct slab *slab)
127{
128 if (kasan_enabled())
129 __kasan_poison_slab(slab);
130}
131
132void __kasan_unpoison_object_data(struct kmem_cache *cache, void *object);
133static __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
140void __kasan_poison_object_data(struct kmem_cache *cache, void *object);
141static __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
148void * __must_check __kasan_init_slab_obj(struct kmem_cache *cache,
149 const void *object);
150static __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
158bool __kasan_slab_free(struct kmem_cache *s, void *object,
159 unsigned long ip, bool init);
160static __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
168void __kasan_kfree_large(void *ptr, unsigned long ip);
169static __always_inline void kasan_kfree_large(void *ptr)
170{
171 if (kasan_enabled())
172 __kasan_kfree_large(ptr, _RET_IP_);
173}
174
175void __kasan_slab_free_mempool(void *ptr, unsigned long ip);
176static __always_inline void kasan_slab_free_mempool(void *ptr)
177{
178 if (kasan_enabled())
179 __kasan_slab_free_mempool(ptr, _RET_IP_);
180}
181
182void * __must_check __kasan_slab_alloc(struct kmem_cache *s,
183 void *object, gfp_t flags, bool init);
184static __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
192void * __must_check __kasan_kmalloc(struct kmem_cache *s, const void *object,
193 size_t size, gfp_t flags);
194static __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
202void * __must_check __kasan_kmalloc_large(const void *ptr,
203 size_t size, gfp_t flags);
204static __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
212void * __must_check __kasan_krealloc(const void *object,
213 size_t new_size, gfp_t flags);
214static __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 */
226bool __kasan_check_byte(const void *addr, unsigned long ip);
227static __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
236static inline void kasan_unpoison_range(const void *address, size_t size) {}
237static inline void kasan_poison_pages(struct page *page, unsigned int order,
238 bool init) {}
239static inline bool kasan_unpoison_pages(struct page *page, unsigned int order,
240 bool init)
241{
242 return false;
243}
244static inline void kasan_poison_slab(struct slab *slab) {}
245static inline void kasan_unpoison_object_data(struct kmem_cache *cache,
246 void *object) {}
247static inline void kasan_poison_object_data(struct kmem_cache *cache,
248 void *object) {}
249static inline void *kasan_init_slab_obj(struct kmem_cache *cache,
250 const void *object)
251{
252 return (void *)object;
253}
254static inline bool kasan_slab_free(struct kmem_cache *s, void *object, bool init)
255{
256 return false;
257}
258static inline void kasan_kfree_large(void *ptr) {}
259static inline void kasan_slab_free_mempool(void *ptr) {}
260static inline void *kasan_slab_alloc(struct kmem_cache *s, void *object,
261 gfp_t flags, bool init)
262{
263 return object;
264}
265static inline void *kasan_kmalloc(struct kmem_cache *s, const void *object,
266 size_t size, gfp_t flags)
267{
268 return (void *)object;
269}
270static inline void *kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags)
271{
272 return (void *)ptr;
273}
274static inline void *kasan_krealloc(const void *object, size_t new_size,
275 gfp_t flags)
276{
277 return (void *)object;
278}
279static 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)
287void kasan_unpoison_task_stack(struct task_struct *task);
288asmlinkage void kasan_unpoison_task_stack_below(const void *watermark);
289#else
290static inline void kasan_unpoison_task_stack(struct task_struct *task) {}
291static inline void kasan_unpoison_task_stack_below(const void *watermark) {}
292#endif
293
294#ifdef CONFIG_KASAN_GENERIC
295
296struct kasan_cache {
297 int alloc_meta_offset;
298 int free_meta_offset;
299};
300
301size_t kasan_metadata_size(struct kmem_cache *cache, bool in_object);
302slab_flags_t kasan_never_merge(void);
303void kasan_cache_create(struct kmem_cache *cache, unsigned int *size,
304 slab_flags_t *flags);
305
306void kasan_cache_shrink(struct kmem_cache *cache);
307void kasan_cache_shutdown(struct kmem_cache *cache);
308void kasan_record_aux_stack(void *ptr);
309void 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. */
314static 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. */
320static inline slab_flags_t kasan_never_merge(void)
321{
322 return 0;
323}
324/* And no cache-related metadata initialization is required. */
325static inline void kasan_cache_create(struct kmem_cache *cache,
326 unsigned int *size,
327 slab_flags_t *flags) {}
328
329static inline void kasan_cache_shrink(struct kmem_cache *cache) {}
330static inline void kasan_cache_shutdown(struct kmem_cache *cache) {}
331static inline void kasan_record_aux_stack(void *ptr) {}
332static 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
338static 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 */
350bool 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
355static 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
364void kasan_report_async(void);
365
366#endif /* CONFIG_KASAN_HW_TAGS */
367
368#ifdef CONFIG_KASAN_SW_TAGS
369void __init kasan_init_sw_tags(void);
370#else
371static inline void kasan_init_sw_tags(void) { }
372#endif
373
374#ifdef CONFIG_KASAN_HW_TAGS
375void kasan_init_hw_tags_cpu(void);
376void __init kasan_init_hw_tags(void);
377#else
378static inline void kasan_init_hw_tags_cpu(void) { }
379static 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
386void kasan_populate_early_vm_area_shadow(void *start, unsigned long size);
387int kasan_populate_vmalloc(unsigned long addr, unsigned long size);
388void 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
394static inline void kasan_populate_early_vm_area_shadow(void *start,
395 unsigned long size)
396{ }
397static inline int kasan_populate_vmalloc(unsigned long start,
398 unsigned long size)
399{
400 return 0;
401}
402static 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
409void *__kasan_unpoison_vmalloc(const void *start, unsigned long size,
410 kasan_vmalloc_flags_t flags);
411static __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
420void __kasan_poison_vmalloc(const void *start, unsigned long size);
421static __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
430static inline void kasan_populate_early_vm_area_shadow(void *start,
431 unsigned long size) { }
432static inline int kasan_populate_vmalloc(unsigned long start,
433 unsigned long size)
434{
435 return 0;
436}
437static 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
442static inline void *kasan_unpoison_vmalloc(const void *start,
443 unsigned long size,
444 kasan_vmalloc_flags_t flags)
445{
446 return (void *)start;
447}
448static 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 */
461int kasan_alloc_module_shadow(void *addr, size_t size, gfp_t gfp_mask);
462void kasan_free_module_shadow(const struct vm_struct *vm);
463
464#else /* (CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS) && !CONFIG_KASAN_VMALLOC */
465
466static inline int kasan_alloc_module_shadow(void *addr, size_t size, gfp_t gfp_mask) { return 0; }
467static 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)
472void kasan_non_canonical_hook(unsigned long addr);
473#else /* CONFIG_KASAN_GENERIC || CONFIG_KASAN_SW_TAGS */
474static 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

source code of linux/include/linux/kasan.h