[apple/xnu.git] / san / kasan.h

/*
 * Copyright (c) 2000-2019 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 *
 * Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
 */

#ifndef _KASAN_H_
#define _KASAN_H_

#if KERNEL_PRIVATE

#if KASAN && !__has_feature(address_sanitizer)
# error "KASAN selected, but not enabled in compiler"
#endif

#if !KASAN && __has_feature(address_sanitizer)
# error "ASAN enabled in compiler, but kernel is not configured for KASAN"
#endif

#define KASAN_GLOBAL_SEGNAME  "__DATA"
#define KASAN_GLOBAL_SECTNAME "__asan_globals"

typedef uintptr_t uptr;

#if KASAN

#define KASAN_DEBUG  0
#define KASAN_KALLOC 1
#define KASAN_ZALLOC 1
#define KASAN_DYNAMIC_BLACKLIST 1

#define KASAN_GUARD_SIZE (16)
#define KASAN_GUARD_PAD  (KASAN_GUARD_SIZE * 2)

#define KASAN_HEAP_ZALLOC    0
#define KASAN_HEAP_KALLOC    1
#define KASAN_HEAP_FAKESTACK 2
#define KASAN_HEAP_TYPES     3

/* shadow map byte values */
#define ASAN_VALID          0x00
#define ASAN_PARTIAL1       0x01
#define ASAN_PARTIAL2       0x02
#define ASAN_PARTIAL3       0x03
#define ASAN_PARTIAL4       0x04
#define ASAN_PARTIAL5       0x05
#define ASAN_PARTIAL6       0x06
#define ASAN_PARTIAL7       0x07
#define ASAN_ARRAY_COOKIE   0xac
#define ASAN_STACK_RZ       0xf0
#define ASAN_STACK_LEFT_RZ  0xf1
#define ASAN_STACK_MID_RZ   0xf2
#define ASAN_STACK_RIGHT_RZ 0xf3
#define ASAN_STACK_FREED    0xf5
#define ASAN_STACK_OOSCOPE  0xf8
#define ASAN_GLOBAL_RZ      0xf9
#define ASAN_HEAP_RZ        0xe9
#define ASAN_HEAP_LEFT_RZ   0xfa
#define ASAN_HEAP_RIGHT_RZ  0xfb
#define ASAN_HEAP_FREED     0xfd

/*
 * KASAN internal interface
 */

__BEGIN_DECLS
void kasan_map_shadow(vm_offset_t address, vm_size_t size, bool is_zero);
void kasan_disable(void);
void kasan_reserve_memory(void *);
void kasan_late_init(void);
void kasan_init(void);
void kasan_notify_stolen(vm_offset_t top);

void kasan_load_kext(vm_offset_t base, vm_size_t size, const void *bundleid);
void kasan_unload_kext(vm_offset_t base, vm_size_t size);

void kasan_unpoison(void *base, vm_size_t size);
void kasan_poison_range(vm_offset_t base, vm_size_t sz, uint8_t flags);
void kasan_notify_address(vm_offset_t address, vm_size_t size);
void kasan_notify_address_nopoison(vm_offset_t address, vm_size_t size);
void kasan_unpoison_stack(vm_offset_t stack, vm_size_t size);
void kasan_unpoison_curstack(bool whole_stack);
bool kasan_check_shadow(vm_address_t base, vm_size_t sz, uint8_t shadow);
void kasan_unpoison_cxx_array_cookie(void *ptr);

void kasan_fakestack_drop(thread_t thread); /* mark all fakestack entries for thread as unused */
void kasan_fakestack_gc(thread_t thread);   /* free and poison all unused fakestack objects for thread */
void kasan_fakestack_suspend(void);
void kasan_fakestack_resume(void);

/* check for uninitialized memory */
void kasan_check_uninitialized(vm_address_t base, vm_size_t sz);

struct kasan_test;
void __kasan_runtests(struct kasan_test *, int numtests);


typedef int (*pmap_traverse_callback)(vm_map_offset_t start,
    vm_map_offset_t end,
    void *context);
int kasan_traverse_mappings(pmap_traverse_callback, void *context);

#if XNU_KERNEL_PRIVATE
extern unsigned shadow_pages_total;

#if __arm64__
void kasan_notify_address_zero(vm_offset_t, vm_size_t);
#elif __x86_64__
extern void kasan_map_low_fixed_regions(void);
extern unsigned shadow_stolen_idx;
extern vm_offset_t shadow_pnext, shadow_ptop;
#endif
#endif

/*
 * Allocator hooks
 */

vm_size_t kasan_alloc_resize(vm_size_t size);
vm_size_t kasan_user_size(vm_offset_t addr);

vm_address_t kasan_alloc(vm_offset_t addr, vm_size_t size, vm_size_t req, vm_size_t leftrz);
vm_address_t kasan_dealloc(vm_offset_t addr, vm_size_t *size);

void kasan_check_free(vm_offset_t addr, vm_size_t size, unsigned type);
void kasan_free(void **addr, vm_size_t *size, int type, zone_t *zone, vm_size_t user_size, bool doquarantine);

__END_DECLS

/* thread interface */
struct kasan_thread_data {
	LIST_HEAD(fakestack_header_list, fakestack_header) fakestack_head;
};
struct kasan_thread_data *kasan_get_thread_data(thread_t);
void kasan_init_thread(struct kasan_thread_data *);

#endif /* KASAN */

#if __has_feature(address_sanitizer)
# define NOKASAN __attribute__ ((no_sanitize_address))
#else
# define NOKASAN
#endif

/*
 * ASAN callbacks - inserted by the compiler
 */

extern int __asan_option_detect_stack_use_after_return;
extern const uintptr_t __asan_shadow_memory_dynamic_address;

#define KASAN_DECLARE_FOREACH_WIDTH(ret, func, ...) \
	ret func ## 1(__VA_ARGS__); \
	ret func ## 2(__VA_ARGS__); \
	ret func ## 4(__VA_ARGS__); \
	ret func ## 8(__VA_ARGS__); \
	ret func ## 16(__VA_ARGS__)

__BEGIN_DECLS

    KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_load, uptr);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_store, uptr);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_store, uptr);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_exp_load, uptr, int32_t);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_exp_store, uptr, int32_t);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_exp_load, uptr, int32_t);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_exp_store, uptr, int32_t);
KASAN_DECLARE_FOREACH_WIDTH(void, __asan_load, uptr);

void __asan_report_load_n(uptr p, unsigned long size);
void __asan_report_store_n(uptr p, unsigned long size);
void __asan_handle_no_return(void);
uptr __asan_stack_malloc_0(size_t);
uptr __asan_stack_malloc_1(size_t);
uptr __asan_stack_malloc_2(size_t);
uptr __asan_stack_malloc_3(size_t);
uptr __asan_stack_malloc_4(size_t);
uptr __asan_stack_malloc_5(size_t);
uptr __asan_stack_malloc_6(size_t);
uptr __asan_stack_malloc_7(size_t);
uptr __asan_stack_malloc_8(size_t);
uptr __asan_stack_malloc_9(size_t);
uptr __asan_stack_malloc_10(size_t);
void __asan_stack_free_0(uptr, size_t);
void __asan_stack_free_1(uptr, size_t);
void __asan_stack_free_2(uptr, size_t);
void __asan_stack_free_3(uptr, size_t);
void __asan_stack_free_4(uptr, size_t);
void __asan_stack_free_5(uptr, size_t);
void __asan_stack_free_6(uptr, size_t);
void __asan_stack_free_7(uptr, size_t);
void __asan_stack_free_8(uptr, size_t);
void __asan_stack_free_9(uptr, size_t);
void __asan_stack_free_10(uptr, size_t);
void __asan_poison_cxx_array_cookie(uptr);
uptr __asan_load_cxx_array_cookie(uptr *);
void __asan_poison_stack_memory(uptr addr, size_t size);
void __asan_unpoison_stack_memory(uptr addr, size_t size);
void __asan_alloca_poison(uptr addr, uptr size);
void __asan_allocas_unpoison(uptr top, uptr bottom);
void __asan_loadN(uptr, size_t);
void __asan_storeN(uptr, size_t);
void __sanitizer_ptr_sub(uptr a, uptr b);
void __sanitizer_ptr_cmp(uptr a, uptr b);
void __sanitizer_annotate_contiguous_container(const void *beg, const void *end, const void *old_mid, const void *new_mid);

void __asan_exp_loadN(uptr addr, size_t sz, int32_t e);
void __asan_exp_storeN(uptr addr, size_t sz, int32_t e);
void __asan_report_exp_load_n(uptr addr, unsigned long b, int32_t c);
void __asan_report_exp_store_n(uptr addr, unsigned long b, int32_t c);

void __asan_set_shadow_00(uptr, size_t);
void __asan_set_shadow_f1(uptr, size_t);
void __asan_set_shadow_f2(uptr, size_t);
void __asan_set_shadow_f3(uptr, size_t);
void __asan_set_shadow_f5(uptr, size_t);
void __asan_set_shadow_f8(uptr, size_t);

void __asan_init_v5(void);
void __asan_register_globals(uptr a, uptr b);
void __asan_unregister_globals(uptr a, uptr b);
void __asan_register_elf_globals(uptr a, uptr b, uptr c);
void __asan_unregister_elf_globals(uptr a, uptr b, uptr c);

void __asan_before_dynamic_init(uptr);
void __asan_after_dynamic_init(void);
void __asan_init(void);
void __asan_unregister_image_globals(uptr);
void __asan_register_image_globals(uptr);
__END_DECLS

#endif /* KERNEL_PRIVATE */
#endif /* _KASAN_H_ */
Commit	Line	Data
5ba3f43e	1	/*
cb323159	2	* Copyright (c) 2000-2019 Apple Inc. All rights reserved.
5ba3f43e A	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
	28
	29	#ifndef _KASAN_H_
	30	#define _KASAN_H_
	31
	32	#if KERNEL_PRIVATE
	33
	34	#if KASAN && !__has_feature(address_sanitizer)
	35	# error "KASAN selected, but not enabled in compiler"
	36	#endif
	37
	38	#if !KASAN && __has_feature(address_sanitizer)
	39	# error "ASAN enabled in compiler, but kernel is not configured for KASAN"
	40	#endif
	41
	42	#define KASAN_GLOBAL_SEGNAME "__DATA"
	43	#define KASAN_GLOBAL_SECTNAME "__asan_globals"
	44
	45	typedef uintptr_t uptr;
	46
	47	#if KASAN
	48
d9a64523	49	#define KASAN_DEBUG 0
5ba3f43e A	50	#define KASAN_KALLOC 1
	51	#define KASAN_ZALLOC 1
	52	#define KASAN_DYNAMIC_BLACKLIST 1
	53
	54	#define KASAN_GUARD_SIZE (16)
	55	#define KASAN_GUARD_PAD (KASAN_GUARD_SIZE * 2)
	56
	57	#define KASAN_HEAP_ZALLOC 0
	58	#define KASAN_HEAP_KALLOC 1
	59	#define KASAN_HEAP_FAKESTACK 2
	60	#define KASAN_HEAP_TYPES 3
	61
	62	/* shadow map byte values */
	63	#define ASAN_VALID 0x00
	64	#define ASAN_PARTIAL1 0x01
	65	#define ASAN_PARTIAL2 0x02
	66	#define ASAN_PARTIAL3 0x03
	67	#define ASAN_PARTIAL4 0x04
	68	#define ASAN_PARTIAL5 0x05
	69	#define ASAN_PARTIAL6 0x06
	70	#define ASAN_PARTIAL7 0x07
	71	#define ASAN_ARRAY_COOKIE 0xac
	72	#define ASAN_STACK_RZ 0xf0
	73	#define ASAN_STACK_LEFT_RZ 0xf1
	74	#define ASAN_STACK_MID_RZ 0xf2
	75	#define ASAN_STACK_RIGHT_RZ 0xf3
	76	#define ASAN_STACK_FREED 0xf5
5c9f4661	77	#define ASAN_STACK_OOSCOPE 0xf8
5ba3f43e A	78	#define ASAN_GLOBAL_RZ 0xf9
	79	#define ASAN_HEAP_RZ 0xe9
	80	#define ASAN_HEAP_LEFT_RZ 0xfa
	81	#define ASAN_HEAP_RIGHT_RZ 0xfb
	82	#define ASAN_HEAP_FREED 0xfd
	83
	84	/*
	85	* KASAN internal interface
	86	*/
	87
	88	__BEGIN_DECLS
	89	void kasan_map_shadow(vm_offset_t address, vm_size_t size, bool is_zero);
	90	void kasan_disable(void);
	91	void kasan_reserve_memory(void *);
	92	void kasan_late_init(void);
	93	void kasan_init(void);
	94	void kasan_notify_stolen(vm_offset_t top);
	95
	96	void kasan_load_kext(vm_offset_t base, vm_size_t size, const void *bundleid);
	97	void kasan_unload_kext(vm_offset_t base, vm_size_t size);
	98
a39ff7e2	99	void kasan_unpoison(void *base, vm_size_t size);
5ba3f43e A	100	void kasan_poison_range(vm_offset_t base, vm_size_t sz, uint8_t flags);
	101	void kasan_notify_address(vm_offset_t address, vm_size_t size);
	102	void kasan_notify_address_nopoison(vm_offset_t address, vm_size_t size);
	103	void kasan_unpoison_stack(vm_offset_t stack, vm_size_t size);
a39ff7e2	104	void kasan_unpoison_curstack(bool whole_stack);
d9a64523	105	bool kasan_check_shadow(vm_address_t base, vm_size_t sz, uint8_t shadow);
cb323159	106	void kasan_unpoison_cxx_array_cookie(void *ptr);
5ba3f43e	107
d9a64523 A	108	void kasan_fakestack_drop(thread_t thread); /* mark all fakestack entries for thread as unused */
d9a64523 A	109	void kasan_fakestack_gc(thread_t thread); /* free and poison all unused fakestack objects for thread */
a39ff7e2 A	110	void kasan_fakestack_suspend(void);
	111	void kasan_fakestack_resume(void);
	112
cb323159 A	113	/* check for uninitialized memory */
	114	void kasan_check_uninitialized(vm_address_t base, vm_size_t sz);
	115
5ba3f43e A	116	struct kasan_test;
	117	void __kasan_runtests(struct kasan_test *, int numtests);
	118
a39ff7e2 A	119
a39ff7e2 A	120	typedef int (*pmap_traverse_callback)(vm_map_offset_t start,
0a7de745 A	121	vm_map_offset_t end,
0a7de745 A	122	void *context);
a39ff7e2 A	123	int kasan_traverse_mappings(pmap_traverse_callback, void *context);
a39ff7e2 A	124
5ba3f43e	125	#if XNU_KERNEL_PRIVATE
a39ff7e2	126	extern unsigned shadow_pages_total;
5ba3f43e A	127
	128	#if __arm64__
	129	void kasan_notify_address_zero(vm_offset_t, vm_size_t);
	130	#elif __x86_64__
	131	extern void kasan_map_low_fixed_regions(void);
	132	extern unsigned shadow_stolen_idx;
	133	extern vm_offset_t shadow_pnext, shadow_ptop;
	134	#endif
	135	#endif
d9a64523	136
5ba3f43e A	137	/*
	138	* Allocator hooks
	139	*/
	140
	141	vm_size_t kasan_alloc_resize(vm_size_t size);
	142	vm_size_t kasan_user_size(vm_offset_t addr);
	143
	144	vm_address_t kasan_alloc(vm_offset_t addr, vm_size_t size, vm_size_t req, vm_size_t leftrz);
	145	vm_address_t kasan_dealloc(vm_offset_t addr, vm_size_t *size);
	146
	147	void kasan_check_free(vm_offset_t addr, vm_size_t size, unsigned type);
	148	void kasan_free(void *addr, vm_size_t size, int type, zone_t *zone, vm_size_t user_size, bool doquarantine);
	149
	150	__END_DECLS
	151
	152	/* thread interface */
	153	struct kasan_thread_data {
5ba3f43e A	154	LIST_HEAD(fakestack_header_list, fakestack_header) fakestack_head;
	155	};
	156	struct kasan_thread_data *kasan_get_thread_data(thread_t);
	157	void kasan_init_thread(struct kasan_thread_data *);
	158
	159	#endif /* KASAN */
	160
	161	#if __has_feature(address_sanitizer)
	162	# define NOKASAN __attribute__ ((no_sanitize_address))
	163	#else
	164	# define NOKASAN
	165	#endif
	166
5ba3f43e A	167	/*
	168	* ASAN callbacks - inserted by the compiler
	169	*/
	170
	171	extern int __asan_option_detect_stack_use_after_return;
	172	extern const uintptr_t __asan_shadow_memory_dynamic_address;
	173
a39ff7e2 A	174	#define KASAN_DECLARE_FOREACH_WIDTH(ret, func, ...) \
	175	ret func ## 1(__VA_ARGS__); \
	176	ret func ## 2(__VA_ARGS__); \
	177	ret func ## 4(__VA_ARGS__); \
	178	ret func ## 8(__VA_ARGS__); \
cb323159	179	ret func ## 16(__VA_ARGS__)
a39ff7e2	180
5ba3f43e	181	__BEGIN_DECLS
a39ff7e2	182
0a7de745	183	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_load, uptr);
a39ff7e2 A	184	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_store, uptr);
	185	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_store, uptr);
	186	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_exp_load, uptr, int32_t);
	187	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_report_exp_store, uptr, int32_t);
	188	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_exp_load, uptr, int32_t);
	189	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_exp_store, uptr, int32_t);
	190	KASAN_DECLARE_FOREACH_WIDTH(void, __asan_load, uptr);
	191
5ba3f43e A	192	void __asan_report_load_n(uptr p, unsigned long size);
	193	void __asan_report_store_n(uptr p, unsigned long size);
	194	void __asan_handle_no_return(void);
	195	uptr __asan_stack_malloc_0(size_t);
	196	uptr __asan_stack_malloc_1(size_t);
	197	uptr __asan_stack_malloc_2(size_t);
	198	uptr __asan_stack_malloc_3(size_t);
	199	uptr __asan_stack_malloc_4(size_t);
	200	uptr __asan_stack_malloc_5(size_t);
	201	uptr __asan_stack_malloc_6(size_t);
	202	uptr __asan_stack_malloc_7(size_t);
	203	uptr __asan_stack_malloc_8(size_t);
	204	uptr __asan_stack_malloc_9(size_t);
	205	uptr __asan_stack_malloc_10(size_t);
	206	void __asan_stack_free_0(uptr, size_t);
	207	void __asan_stack_free_1(uptr, size_t);
	208	void __asan_stack_free_2(uptr, size_t);
	209	void __asan_stack_free_3(uptr, size_t);
	210	void __asan_stack_free_4(uptr, size_t);
	211	void __asan_stack_free_5(uptr, size_t);
	212	void __asan_stack_free_6(uptr, size_t);
	213	void __asan_stack_free_7(uptr, size_t);
	214	void __asan_stack_free_8(uptr, size_t);
	215	void __asan_stack_free_9(uptr, size_t);
	216	void __asan_stack_free_10(uptr, size_t);
	217	void __asan_poison_cxx_array_cookie(uptr);
	218	uptr __asan_load_cxx_array_cookie(uptr *);
	219	void __asan_poison_stack_memory(uptr addr, size_t size);
	220	void __asan_unpoison_stack_memory(uptr addr, size_t size);
	221	void __asan_alloca_poison(uptr addr, uptr size);
	222	void __asan_allocas_unpoison(uptr top, uptr bottom);
5ba3f43e	223	void __asan_loadN(uptr, size_t);
5ba3f43e A	224	void __asan_storeN(uptr, size_t);
	225	void __sanitizer_ptr_sub(uptr a, uptr b);
	226	void __sanitizer_ptr_cmp(uptr a, uptr b);
	227	void __sanitizer_annotate_contiguous_container(const void beg, const void end, const void old_mid, const void new_mid);
	228
a39ff7e2 A	229	void __asan_exp_loadN(uptr addr, size_t sz, int32_t e);
	230	void __asan_exp_storeN(uptr addr, size_t sz, int32_t e);
	231	void __asan_report_exp_load_n(uptr addr, unsigned long b, int32_t c);
	232	void __asan_report_exp_store_n(uptr addr, unsigned long b, int32_t c);
	233
5ba3f43e A	234	void __asan_set_shadow_00(uptr, size_t);
	235	void __asan_set_shadow_f1(uptr, size_t);
	236	void __asan_set_shadow_f2(uptr, size_t);
	237	void __asan_set_shadow_f3(uptr, size_t);
	238	void __asan_set_shadow_f5(uptr, size_t);
	239	void __asan_set_shadow_f8(uptr, size_t);
	240
	241	void __asan_init_v5(void);
a39ff7e2 A	242	void __asan_register_globals(uptr a, uptr b);
	243	void __asan_unregister_globals(uptr a, uptr b);
	244	void __asan_register_elf_globals(uptr a, uptr b, uptr c);
	245	void __asan_unregister_elf_globals(uptr a, uptr b, uptr c);
	246
5ba3f43e A	247	void __asan_before_dynamic_init(uptr);
5ba3f43e A	248	void __asan_after_dynamic_init(void);
5ba3f43e A	249	void __asan_init(void);
	250	void __asan_unregister_image_globals(uptr);
	251	void __asan_register_image_globals(uptr);
	252	__END_DECLS
	253
	254	#endif /* KERNEL_PRIVATE */
	255	#endif /* _KASAN_H_ */