kasan: rename (un)poison_shadow to (un)poison_range

This is a preparatory commit for the upcoming addition of a new hardware tag-based (MTE-based) KASAN mode. The new mode won't be using shadow memory. Rename external annotation kasan_unpoison_shadow() to kasan_unpoison_range(), and introduce internal functions (un)poison_range() (without kasan_ prefix).

Andrey Konovalov committed 5 years ago

Commit cebd0eb1 parent d5750ed7 files · +47 −42Browse files

Unified · Split

7 files

include/linux/kasan.h +3 −3
kernel/fork.c +2 −2
mm/kasan/common.c +27 −22
mm/kasan/generic.c +11 −12
mm/kasan/kasan.h +2 −1
mm/kasan/tags.c +1 −1
mm/slab_common.c +1 −1

include/linux/kasan.h+3−3

@@ -72,7 +72,7 @@ extern void kasan_enable_current(void); · 71 unmodified lines
72	72	/* Disable reporting bugs for current task */
73	73	extern void kasan_disable_current(void);
74	74
75		−void kasan_unpoison_shadow(const void *address, size_t size);
	75	+void kasan_unpoison_range(const void *address, size_t size);
76	76
77	77	void kasan_unpoison_task_stack(struct task_struct *task);
78	78
@@ -109,7 +109,7 @@ struct kasan_cache { · 30 unmodified lines
109	109	size_t __ksize(const void *);
110	110	static inline void kasan_unpoison_slab(const void *ptr)
111	111	{
112		− kasan_unpoison_shadow(ptr, __ksize(ptr));
	112	+ kasan_unpoison_range(ptr, __ksize(ptr));
113	113	}
114	114	size_t kasan_metadata_size(struct kmem_cache *cache);
115	115
@@ -118,7 +118,7 @@ void kasan_restore_multi_shot(bool enabled); · 2 unmodified lines
118	118
119	119	#else /* CONFIG_KASAN */
120	120
121		−static inline void kasan_unpoison_shadow(const void *address, size_t size) {}
	121	+static inline void kasan_unpoison_range(const void *address, size_t size) {}
122	122
123	123	static inline void kasan_unpoison_task_stack(struct task_struct *task) {}
124	124

kernel/fork.c+2−2

@@ -225,8 +225,8 @@ static unsigned long alloc_thread_stack_node(struct task_struct tsk, int node) · 224 unmodified lines
225	225	if (!s)
226	226	continue;
227	227
228		− /* Clear the KASAN shadow of the stack. */
229		− kasan_unpoison_shadow(s->addr, THREAD_SIZE);
	228	+ /* Mark stack accessible for KASAN. */
	229	+ kasan_unpoison_range(s->addr, THREAD_SIZE);
230	230
231	231	/* Clear stale pointers from reused stack. */
232	232	memset(s->addr, 0, THREAD_SIZE);

mm/kasan/common.c+27−22

@@ -108,7 +108,7 @@ void memcpy(void dest, const void *src, size_t len) · 107 unmodified lines
108	108	* Poisons the shadow memory for 'size' bytes starting from 'addr'.
109	109	* Memory addresses should be aligned to KASAN_SHADOW_SCALE_SIZE.
110	110	*/
111		−void kasan_poison_shadow(const void *address, size_t size, u8 value)
	111	+void poison_range(const void *address, size_t size, u8 value)
112	112	{
113	113	void shadow_start, shadow_end;
114	114
@@ -125,7 +125,7 @@ void kasan_poison_shadow(const void *address, size_t size, u8 value) · 10 unmodified lines
125	125	__memset(shadow_start, value, shadow_end - shadow_start);
126	126	}
127	127
128		−void kasan_unpoison_shadow(const void *address, size_t size)
	128	+void unpoison_range(const void *address, size_t size)
129	129	{
130	130	u8 tag = get_tag(address);
131	131
@@ -136,7 +136,7 @@ void kasan_unpoison_shadow(const void *address, size_t size) · 4 unmodified lines
136	136	*/
137	137	address = reset_tag(address);
138	138
139		− kasan_poison_shadow(address, size, tag);
	139	+ poison_range(address, size, tag);
140	140
141	141	if (size & KASAN_SHADOW_MASK) {
142	142	u8 shadow = (u8 )kasan_mem_to_shadow(address + size);
@@ -148,12 +148,17 @@ void kasan_unpoison_shadow(const void *address, size_t size) · 5 unmodified lines
148	148	}
149	149	}
150	150
	151	+void kasan_unpoison_range(const void *address, size_t size)
	152	+{
	153	+ unpoison_range(address, size);
	154	+}
	155	+
151	156	static void __kasan_unpoison_stack(struct task_struct task, const void sp)
152	157	{
153	158	void *base = task_stack_page(task);
154	159	size_t size = sp - base;
155	160
156		− kasan_unpoison_shadow(base, size);
	161	+ unpoison_range(base, size);
157	162	}
158	163
159	164	/* Unpoison the entire stack for a task. */
@@ -172,7 +177,7 @@ asmlinkage void kasan_unpoison_task_stack_below(const void *watermark) · 12 unmodified lines
172	177	*/
173	178	void base = (void )((unsigned long)watermark & ~(THREAD_SIZE - 1));
174	179
175		− kasan_unpoison_shadow(base, watermark - base);
	180	+ unpoison_range(base, watermark - base);
176	181	}
177	182
178	183	void kasan_alloc_pages(struct page *page, unsigned int order)
@@ -186,13 +191,13 @@ void kasan_alloc_pages(struct page *page, unsigned int order) · 7 unmodified lines
186	191	tag = random_tag();
187	192	for (i = 0; i < (1 << order); i++)
188	193	page_kasan_tag_set(page + i, tag);
189		− kasan_unpoison_shadow(page_address(page), PAGE_SIZE << order);
	194	+ unpoison_range(page_address(page), PAGE_SIZE << order);
190	195	}
191	196
192	197	void kasan_free_pages(struct page *page, unsigned int order)
193	198	{
194	199	if (likely(!PageHighMem(page)))
195		− kasan_poison_shadow(page_address(page),
	200	+ poison_range(page_address(page),
196	201	PAGE_SIZE << order,
197	202	KASAN_FREE_PAGE);
198	203	}
@@ -284,18 +289,18 @@ void kasan_poison_slab(struct page *page) · 85 unmodified lines
284	289
285	290	for (i = 0; i < compound_nr(page); i++)
286	291	page_kasan_tag_reset(page + i);
287		− kasan_poison_shadow(page_address(page), page_size(page),
288		− KASAN_KMALLOC_REDZONE);
	292	+ poison_range(page_address(page), page_size(page),
	293	+ KASAN_KMALLOC_REDZONE);
289	294	}
290	295
291	296	void kasan_unpoison_object_data(struct kmem_cache cache, void object)
292	297	{
293		− kasan_unpoison_shadow(object, cache->object_size);
	298	+ unpoison_range(object, cache->object_size);
294	299	}
295	300
296	301	void kasan_poison_object_data(struct kmem_cache cache, void object)
297	302	{
298		− kasan_poison_shadow(object,
	303	+ poison_range(object,
299	304	round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE),
300	305	KASAN_KMALLOC_REDZONE);
301	306	}
@@ -408,7 +413,7 @@ static bool __kasan_slab_free(struct kmem_cache cache, void object, · 106 unmodified lines
408	413	}
409	414
410	415	rounded_up_size = round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE);
411		− kasan_poison_shadow(object, rounded_up_size, KASAN_KMALLOC_FREE);
	416	+ poison_range(object, rounded_up_size, KASAN_KMALLOC_FREE);
412	417
413	418	if ((IS_ENABLED(CONFIG_KASAN_GENERIC) && !quarantine) \|\|
414	419	unlikely(!(cache->flags & SLAB_KASAN)))
@@ -448,9 +453,9 @@ static void __kasan_kmalloc(struct kmem_cache cache, const void *object, · 33 unmodified lines
448	453	tag = assign_tag(cache, object, false, keep_tag);
449	454
450	455	/* Tag is ignored in set_tag without CONFIG_KASAN_SW_TAGS */
451		− kasan_unpoison_shadow(set_tag(object, tag), size);
452		− kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start,
453		− KASAN_KMALLOC_REDZONE);
	456	+ unpoison_range(set_tag(object, tag), size);
	457	+ poison_range((void *)redzone_start, redzone_end - redzone_start,
	458	+ KASAN_KMALLOC_REDZONE);
454	459
455	460	if (cache->flags & SLAB_KASAN)
456	461	kasan_set_track(&get_alloc_info(cache, object)->alloc_track, flags);
@@ -489,9 +494,9 @@ void * __must_check kasan_kmalloc_large(const void *ptr, size_t size, · 32 unmodified lines
489	494	KASAN_SHADOW_SCALE_SIZE);
490	495	redzone_end = (unsigned long)ptr + page_size(page);
491	496
492		− kasan_unpoison_shadow(ptr, size);
493		− kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start,
494		− KASAN_PAGE_REDZONE);
	497	+ unpoison_range(ptr, size);
	498	+ poison_range((void *)redzone_start, redzone_end - redzone_start,
	499	+ KASAN_PAGE_REDZONE);
495	500
496	501	return (void *)ptr;
497	502	}
@@ -523,7 +528,7 @@ void kasan_poison_kfree(void *ptr, unsigned long ip) · 25 unmodified lines
523	528	kasan_report_invalid_free(ptr, ip);
524	529	return;
525	530	}
526		− kasan_poison_shadow(ptr, page_size(page), KASAN_FREE_PAGE);
	531	+ poison_range(ptr, page_size(page), KASAN_FREE_PAGE);
527	532	} else {
528	533	__kasan_slab_free(page->slab_cache, ptr, ip, false);
529	534	}
@@ -709,7 +714,7 @@ int kasan_populate_vmalloc(unsigned long addr, unsigned long size) · 179 unmodified lines
709	714	* // vmalloc() allocates memory
710	715	* // let a = area->addr
711	716	* // we reach kasan_populate_vmalloc
712		− * // and call kasan_unpoison_shadow:
	717	+ * // and call unpoison_range:
713	718	* STORE shadow(a), unpoison_val
714	719	* ...
715	720	* STORE shadow(a+99), unpoison_val x = LOAD p
@@ -744,7 +749,7 @@ void kasan_poison_vmalloc(const void *start, unsigned long size) · 28 unmodified lines
744	749	return;
745	750
746	751	size = round_up(size, KASAN_SHADOW_SCALE_SIZE);
747		− kasan_poison_shadow(start, size, KASAN_VMALLOC_INVALID);
	752	+ poison_range(start, size, KASAN_VMALLOC_INVALID);
748	753	}
749	754
750	755	void kasan_unpoison_vmalloc(const void *start, unsigned long size)
@@ -752,7 +757,7 @@ void kasan_unpoison_vmalloc(const void *start, unsigned long size) · 1 unmodified line
752	757	if (!is_vmalloc_or_module_addr(start))
753	758	return;
754	759
755		− kasan_unpoison_shadow(start, size);
	760	+ unpoison_range(start, size);
756	761	}
757	762
758	763	static int kasan_depopulate_vmalloc_pte(pte_t *ptep, unsigned long addr,

mm/kasan/generic.c+11−12

@@ -202,11 +202,11 @@ static void register_global(struct kasan_global *global) · 201 unmodified lines
202	202	{
203	203	size_t aligned_size = round_up(global->size, KASAN_SHADOW_SCALE_SIZE);
204	204
205		− kasan_unpoison_shadow(global->beg, global->size);
	205	+ unpoison_range(global->beg, global->size);
206	206
207		− kasan_poison_shadow(global->beg + aligned_size,
208		− global->size_with_redzone - aligned_size,
209		− KASAN_GLOBAL_REDZONE);
	207	+ poison_range(global->beg + aligned_size,
	208	+ global->size_with_redzone - aligned_size,
	209	+ KASAN_GLOBAL_REDZONE);
210	210	}
211	211
212	212	void __asan_register_globals(struct kasan_global *globals, size_t size)
@@ -285,13 +285,12 @@ void __asan_alloca_poison(unsigned long addr, size_t size) · 72 unmodified lines
285	285
286	286	WARN_ON(!IS_ALIGNED(addr, KASAN_ALLOCA_REDZONE_SIZE));
287	287
288		− kasan_unpoison_shadow((const void *)(addr + rounded_down_size),
289		− size - rounded_down_size);
290		− kasan_poison_shadow(left_redzone, KASAN_ALLOCA_REDZONE_SIZE,
291		− KASAN_ALLOCA_LEFT);
292		− kasan_poison_shadow(right_redzone,
293		− padding_size + KASAN_ALLOCA_REDZONE_SIZE,
294		− KASAN_ALLOCA_RIGHT);
	288	+ unpoison_range((const void *)(addr + rounded_down_size),
	289	+ size - rounded_down_size);
	290	+ poison_range(left_redzone, KASAN_ALLOCA_REDZONE_SIZE,
	291	+ KASAN_ALLOCA_LEFT);
	292	+ poison_range(right_redzone, padding_size + KASAN_ALLOCA_REDZONE_SIZE,
	293	+ KASAN_ALLOCA_RIGHT);
295	294	}
296	295	EXPORT_SYMBOL(__asan_alloca_poison);
297	296
@@ -301,7 +300,7 @@ void __asan_allocas_unpoison(const void stack_top, const void stack_bottom) · 3 unmodified lines
301	300	if (unlikely(!stack_top \|\| stack_top > stack_bottom))
302	301	return;
303	302
304		− kasan_unpoison_shadow(stack_top, stack_bottom - stack_top);
	303	+ unpoison_range(stack_top, stack_bottom - stack_top);
305	304	}
306	305	EXPORT_SYMBOL(__asan_allocas_unpoison);
307	306

mm/kasan/kasan.h+2−1

@@ -150,7 +150,8 @@ static inline bool addr_has_shadow(const void *addr) · 149 unmodified lines
150	150	return (addr >= kasan_shadow_to_mem((void *)KASAN_SHADOW_START));
151	151	}
152	152
153		−void kasan_poison_shadow(const void *address, size_t size, u8 value);
	153	+void poison_range(const void *address, size_t size, u8 value);
	154	+void unpoison_range(const void *address, size_t size);
154	155
155	156	/**
156	157	* check_memory_region - Check memory region, and report if invalid access.

mm/kasan/tags.c+1−1

@@ -153,7 +153,7 @@ EXPORT_SYMBOL(__hwasan_storeN_noabort); · 152 unmodified lines
153	153
154	154	void __hwasan_tag_memory(unsigned long addr, u8 tag, unsigned long size)
155	155	{
156		− kasan_poison_shadow((void *)addr, size, tag);
	156	+ poison_range((void *)addr, size, tag);
157	157	}
158	158	EXPORT_SYMBOL(__hwasan_tag_memory);
159	159

mm/slab_common.c+1−1

@@ -1176,7 +1176,7 @@ size_t ksize(const void *objp) · 1175 unmodified lines
1176	1176	* We assume that ksize callers could use whole allocated area,
1177	1177	* so we need to unpoison this area.
1178	1178	*/
1179		− kasan_unpoison_shadow(objp, size);
	1179	+ kasan_unpoison_range(objp, size);
1180	1180	return size;
1181	1181	}
1182	1182	EXPORT_SYMBOL(ksize);

kasan: rename (un)poison_shadow to (un)poison_range

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code