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