include/linux/kasan.h

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