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