Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * This file contains common generic and tag-based KASAN code.
4 : : *
5 : : * Copyright (c) 2014 Samsung Electronics Co., Ltd.
6 : : * Author: Andrey Ryabinin <ryabinin.a.a@gmail.com>
7 : : *
8 : : * Some code borrowed from https://github.com/xairy/kasan-prototype by
9 : : * Andrey Konovalov <andreyknvl@gmail.com>
10 : : *
11 : : * This program is free software; you can redistribute it and/or modify
12 : : * it under the terms of the GNU General Public License version 2 as
13 : : * published by the Free Software Foundation.
14 : : *
15 : : */
16 : :
17 : : #include <linux/export.h>
18 : : #include <linux/interrupt.h>
19 : : #include <linux/init.h>
20 : : #include <linux/kasan.h>
21 : : #include <linux/kernel.h>
22 : : #include <linux/kmemleak.h>
23 : : #include <linux/linkage.h>
24 : : #include <linux/memblock.h>
25 : : #include <linux/memory.h>
26 : : #include <linux/mm.h>
27 : : #include <linux/module.h>
28 : : #include <linux/printk.h>
29 : : #include <linux/sched.h>
30 : : #include <linux/sched/task_stack.h>
31 : : #include <linux/slab.h>
32 : : #include <linux/stacktrace.h>
33 : : #include <linux/string.h>
34 : : #include <linux/types.h>
35 : : #include <linux/vmalloc.h>
36 : : #include <linux/bug.h>
37 : : #include <linux/uaccess.h>
38 : :
39 : : #include <asm/cacheflush.h>
40 : : #include <asm/tlbflush.h>
41 : :
42 : : #include "kasan.h"
43 : : #include "../slab.h"
44 : :
45 : : static inline int in_irqentry_text(unsigned long ptr)
46 : : {
47 : : return (ptr >= (unsigned long)&__irqentry_text_start &&
48 : : ptr < (unsigned long)&__irqentry_text_end) ||
49 : : (ptr >= (unsigned long)&__softirqentry_text_start &&
50 : : ptr < (unsigned long)&__softirqentry_text_end);
51 : : }
52 : :
53 : : static inline unsigned int filter_irq_stacks(unsigned long *entries,
54 : : unsigned int nr_entries)
55 : : {
56 : : unsigned int i;
57 : :
58 : : for (i = 0; i < nr_entries; i++) {
59 : : if (in_irqentry_text(entries[i])) {
60 : : /* Include the irqentry function into the stack. */
61 : : return i + 1;
62 : : }
63 : : }
64 : : return nr_entries;
65 : : }
66 : :
67 : 18790570 : static inline depot_stack_handle_t save_stack(gfp_t flags)
68 : : {
69 : 18790570 : unsigned long entries[KASAN_STACK_DEPTH];
70 : 18790570 : unsigned int nr_entries;
71 : :
72 : : //nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
73 : : //nr_entries = filter_irq_stacks(entries, nr_entries);
74 : 18790570 : nr_entries = 1;
75 : 18790570 : entries[0] = -1;
76 : 18790570 : return stack_depot_save(entries, nr_entries, flags);
77 : : }
78 : :
79 : 18788640 : static inline void set_track(struct kasan_track *track, gfp_t flags)
80 : : {
81 : 18788640 : track->pid = current->pid;
82 : 18788640 : track->stack = save_stack(flags);
83 : 10643632 : }
84 : :
85 : 109494 : void kasan_enable_current(void)
86 : : {
87 : 109494 : current->kasan_depth++;
88 : 109494 : }
89 : :
90 : 109494 : void kasan_disable_current(void)
91 : : {
92 : 109494 : current->kasan_depth--;
93 : 109494 : }
94 : :
95 : 177872300 : bool __kasan_check_read(const volatile void *p, unsigned int size)
96 : : {
97 : 177872300 : return check_memory_region((unsigned long)p, size, false, _RET_IP_);
98 : : }
99 : : EXPORT_SYMBOL(__kasan_check_read);
100 : :
101 : 185926200 : bool __kasan_check_write(const volatile void *p, unsigned int size)
102 : : {
103 : 185926200 : return check_memory_region((unsigned long)p, size, true, _RET_IP_);
104 : : }
105 : : EXPORT_SYMBOL(__kasan_check_write);
106 : :
107 : : #undef memset
108 : 3545713 : void *memset(void *addr, int c, size_t len)
109 : : {
110 : 3545713 : check_memory_region((unsigned long)addr, len, true, _RET_IP_);
111 : :
112 : 3545713 : return __memset(addr, c, len);
113 : : }
114 : :
115 : : #ifdef __HAVE_ARCH_MEMMOVE
116 : : #undef memmove
117 : 57816 : void *memmove(void *dest, const void *src, size_t len)
118 : : {
119 : 57816 : check_memory_region((unsigned long)src, len, false, _RET_IP_);
120 : 57816 : check_memory_region((unsigned long)dest, len, true, _RET_IP_);
121 : :
122 : 57816 : return __memmove(dest, src, len);
123 : : }
124 : : #endif
125 : :
126 : : #undef memcpy
127 : 7011647 : void *memcpy(void *dest, const void *src, size_t len)
128 : : {
129 : 7011647 : check_memory_region((unsigned long)src, len, false, _RET_IP_);
130 : 7011647 : check_memory_region((unsigned long)dest, len, true, _RET_IP_);
131 : :
132 : 7011647 : return __memcpy(dest, src, len);
133 : : }
134 : :
135 : : /*
136 : : * Poisons the shadow memory for 'size' bytes starting from 'addr'.
137 : : * Memory addresses should be aligned to KASAN_SHADOW_SCALE_SIZE.
138 : : */
139 : 37467950 : void kasan_poison_shadow(const void *address, size_t size, u8 value)
140 : : {
141 : 37467950 : void *shadow_start, *shadow_end;
142 : :
143 : : /*
144 : : * Perform shadow offset calculation based on untagged address, as
145 : : * some of the callers (e.g. kasan_poison_object_data) pass tagged
146 : : * addresses to this function.
147 : : */
148 : 37467950 : address = reset_tag(address);
149 : :
150 : 3760415 : shadow_start = kasan_mem_to_shadow(address);
151 : 8149385 : shadow_end = kasan_mem_to_shadow(address + size);
152 : :
153 : 37467630 : __memset(shadow_start, value, shadow_end - shadow_start);
154 : 0 : }
155 : :
156 : 14661110 : void kasan_unpoison_shadow(const void *address, size_t size)
157 : : {
158 : 14661110 : u8 tag = get_tag(address);
159 : :
160 : : /*
161 : : * Perform shadow offset calculation based on untagged address, as
162 : : * some of the callers (e.g. kasan_unpoison_object_data) pass tagged
163 : : * addresses to this function.
164 : : */
165 : 14661110 : address = reset_tag(address);
166 : :
167 : 14661110 : kasan_poison_shadow(address, size, tag);
168 : :
169 [ + + ]: 14661110 : if (size & KASAN_SHADOW_MASK) {
170 : 603352 : u8 *shadow = (u8 *)kasan_mem_to_shadow(address + size);
171 : :
172 : 603352 : if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
173 : : *shadow = tag;
174 : : else
175 : 603352 : *shadow = size & KASAN_SHADOW_MASK;
176 : : }
177 : 14661110 : }
178 : :
179 : 11 : static void __kasan_unpoison_stack(struct task_struct *task, const void *sp)
180 : : {
181 : 11 : void *base = task_stack_page(task);
182 : 11 : size_t size = sp - base;
183 : :
184 : 11 : kasan_unpoison_shadow(base, size);
185 : : }
186 : :
187 : : /* Unpoison the entire stack for a task. */
188 : 11 : void kasan_unpoison_task_stack(struct task_struct *task)
189 : : {
190 : 11 : __kasan_unpoison_stack(task, task_stack_page(task) + THREAD_SIZE);
191 : 11 : }
192 : :
193 : : /* Unpoison the stack for the current task beyond a watermark sp value. */
194 : 0 : asmlinkage void kasan_unpoison_task_stack_below(const void *watermark)
195 : : {
196 : : /*
197 : : * Calculate the task stack base address. Avoid using 'current'
198 : : * because this function is called by early resume code which hasn't
199 : : * yet set up the percpu register (%gs).
200 : : */
201 : 0 : void *base = (void *)((unsigned long)watermark & ~(THREAD_SIZE - 1));
202 : :
203 : 0 : kasan_unpoison_shadow(base, watermark - base);
204 : 0 : }
205 : :
206 : : /*
207 : : * Clear all poison for the region between the current SP and a provided
208 : : * watermark value, as is sometimes required prior to hand-crafted asm function
209 : : * returns in the middle of functions.
210 : : */
211 : 0 : void kasan_unpoison_stack_above_sp_to(const void *watermark)
212 : : {
213 : 0 : const void *sp = __builtin_frame_address(0);
214 : 0 : size_t size = watermark - sp;
215 : :
216 [ # # # # ]: 0 : if (WARN_ON(sp > watermark))
217 : : return;
218 : 0 : kasan_unpoison_shadow(sp, size);
219 : : }
220 : :
221 : 1345871 : void kasan_alloc_pages(struct page *page, unsigned int order)
222 : : {
223 : 1345871 : u8 tag;
224 : 1345871 : unsigned long i;
225 : :
226 : 1345871 : if (unlikely(PageHighMem(page)))
227 : : return;
228 : :
229 : 1345871 : tag = random_tag();
230 : 1345871 : for (i = 0; i < (1 << order); i++)
231 : : page_kasan_tag_set(page + i, tag);
232 : 1345871 : kasan_unpoison_shadow(page_address(page), PAGE_SIZE << order);
233 : : }
234 : :
235 : 1091737 : void kasan_free_pages(struct page *page, unsigned int order)
236 : : {
237 : 1091737 : if (likely(!PageHighMem(page)))
238 : 1091737 : kasan_poison_shadow(page_address(page),
239 : : PAGE_SIZE << order,
240 : : KASAN_FREE_PAGE);
241 : 1091737 : }
242 : :
243 : : /*
244 : : * Adaptive redzone policy taken from the userspace AddressSanitizer runtime.
245 : : * For larger allocations larger redzones are used.
246 : : */
247 : 2442 : static inline unsigned int optimal_redzone(unsigned int object_size)
248 : : {
249 : 2442 : if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
250 : : return 0;
251 : :
252 : 2442 : return
253 [ + + + + : 2024 : object_size <= 64 - 16 ? 16 :
+ + - + -
- - - ]
254 : : object_size <= 128 - 32 ? 32 :
255 : : object_size <= 512 - 64 ? 64 :
256 : : object_size <= 4096 - 128 ? 128 :
257 : : object_size <= (1 << 14) - 256 ? 256 :
258 : : object_size <= (1 << 15) - 512 ? 512 :
259 : : object_size <= (1 << 16) - 1024 ? 1024 : 2048;
260 : : }
261 : :
262 : 2442 : void kasan_cache_create(struct kmem_cache *cache, unsigned int *size,
263 : : slab_flags_t *flags)
264 : : {
265 : 2442 : unsigned int orig_size = *size;
266 : 2442 : unsigned int redzone_size;
267 : 2442 : int redzone_adjust;
268 : :
269 : : /* Add alloc meta. */
270 : 2442 : cache->kasan_info.alloc_meta_offset = *size;
271 : 2442 : *size += sizeof(struct kasan_alloc_meta);
272 : :
273 : : /* Add free meta. */
274 : 4565 : if (IS_ENABLED(CONFIG_KASAN_GENERIC) &&
275 [ + + + + ]: 2442 : (cache->flags & SLAB_TYPESAFE_BY_RCU || cache->ctor ||
276 [ - + ]: 2123 : cache->object_size < sizeof(struct kasan_free_meta))) {
277 : 319 : cache->kasan_info.free_meta_offset = *size;
278 : 319 : *size += sizeof(struct kasan_free_meta);
279 : : }
280 : :
281 [ + + ]: 2442 : redzone_size = optimal_redzone(cache->object_size);
282 : 2442 : redzone_adjust = redzone_size - (*size - cache->object_size);
283 [ + + ]: 2442 : if (redzone_adjust > 0)
284 : 2002 : *size += redzone_adjust;
285 : :
286 : 2442 : *size = min_t(unsigned int, KMALLOC_MAX_SIZE,
287 : : max(*size, cache->object_size + redzone_size));
288 : :
289 : : /*
290 : : * If the metadata doesn't fit, don't enable KASAN at all.
291 : : */
292 [ + - ]: 2442 : if (*size <= cache->kasan_info.alloc_meta_offset ||
293 [ - + ]: 2442 : *size <= cache->kasan_info.free_meta_offset) {
294 : 0 : cache->kasan_info.alloc_meta_offset = 0;
295 : 0 : cache->kasan_info.free_meta_offset = 0;
296 : 0 : *size = orig_size;
297 : 0 : return;
298 : : }
299 : :
300 : 2442 : *flags |= SLAB_KASAN;
301 : : }
302 : :
303 : 0 : size_t kasan_metadata_size(struct kmem_cache *cache)
304 : : {
305 : 0 : return (cache->kasan_info.alloc_meta_offset ?
306 [ # # ]: 0 : sizeof(struct kasan_alloc_meta) : 0) +
307 : 0 : (cache->kasan_info.free_meta_offset ?
308 [ # # ]: 0 : sizeof(struct kasan_free_meta) : 0);
309 : : }
310 : :
311 : 24980540 : struct kasan_alloc_meta *get_alloc_info(struct kmem_cache *cache,
312 : : const void *object)
313 : : {
314 : 24980540 : return (void *)object + cache->kasan_info.alloc_meta_offset;
315 : : }
316 : :
317 : 8145018 : struct kasan_free_meta *get_free_info(struct kmem_cache *cache,
318 : : const void *object)
319 : : {
320 : 8145018 : BUILD_BUG_ON(sizeof(struct kasan_free_meta) > 32);
321 : 8145018 : return (void *)object + cache->kasan_info.free_meta_offset;
322 : : }
323 : :
324 : :
325 : 8145018 : static void kasan_set_free_info(struct kmem_cache *cache,
326 : : void *object, u8 tag)
327 : : {
328 : 8145018 : struct kasan_alloc_meta *alloc_meta;
329 : 8145018 : u8 idx = 0;
330 : :
331 : 8145018 : alloc_meta = get_alloc_info(cache, object);
332 : :
333 : : #ifdef CONFIG_KASAN_SW_TAGS_IDENTIFY
334 : : idx = alloc_meta->free_track_idx;
335 : : alloc_meta->free_pointer_tag[idx] = tag;
336 : : alloc_meta->free_track_idx = (idx + 1) % KASAN_NR_FREE_STACKS;
337 : : #endif
338 : :
339 : 8145018 : set_track(&alloc_meta->free_track[idx], GFP_NOWAIT);
340 : : }
341 : :
342 : 291545 : void kasan_poison_slab(struct page *page)
343 : : {
344 : 291545 : unsigned long i;
345 : :
346 [ + + ]: 1525500 : for (i = 0; i < compound_nr(page); i++)
347 : 942410 : page_kasan_tag_reset(page + i);
348 : 291545 : kasan_poison_shadow(page_address(page), page_size(page),
349 : : KASAN_KMALLOC_REDZONE);
350 : 291545 : }
351 : :
352 : 253095 : void kasan_unpoison_object_data(struct kmem_cache *cache, void *object)
353 : : {
354 : 253095 : kasan_unpoison_shadow(object, cache->object_size);
355 : 253095 : }
356 : :
357 : 253095 : void kasan_poison_object_data(struct kmem_cache *cache, void *object)
358 : : {
359 : 253095 : kasan_poison_shadow(object,
360 : 253095 : round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE),
361 : : KASAN_KMALLOC_REDZONE);
362 : 253095 : }
363 : :
364 : : /*
365 : : * This function assigns a tag to an object considering the following:
366 : : * 1. A cache might have a constructor, which might save a pointer to a slab
367 : : * object somewhere (e.g. in the object itself). We preassign a tag for
368 : : * each object in caches with constructors during slab creation and reuse
369 : : * the same tag each time a particular object is allocated.
370 : : * 2. A cache might be SLAB_TYPESAFE_BY_RCU, which means objects can be
371 : : * accessed after being freed. We preassign tags for objects in these
372 : : * caches as well.
373 : : * 3. For SLAB allocator we can't preassign tags randomly since the freelist
374 : : * is stored as an array of indexes instead of a linked list. Assign tags
375 : : * based on objects indexes, so that objects that are next to each other
376 : : * get different tags.
377 : : */
378 : : static u8 assign_tag(struct kmem_cache *cache, const void *object,
379 : : bool init, bool keep_tag)
380 : : {
381 : : /*
382 : : * 1. When an object is kmalloc()'ed, two hooks are called:
383 : : * kasan_slab_alloc() and kasan_kmalloc(). We assign the
384 : : * tag only in the first one.
385 : : * 2. We reuse the same tag for krealloc'ed objects.
386 : : */
387 : : if (keep_tag)
388 : : return get_tag(object);
389 : :
390 : : /*
391 : : * If the cache neither has a constructor nor has SLAB_TYPESAFE_BY_RCU
392 : : * set, assign a tag when the object is being allocated (init == false).
393 : : */
394 : : if (!cache->ctor && !(cache->flags & SLAB_TYPESAFE_BY_RCU))
395 : : return init ? KASAN_TAG_KERNEL : random_tag();
396 : :
397 : : /* For caches that either have a constructor or SLAB_TYPESAFE_BY_RCU: */
398 : : #ifdef CONFIG_SLAB
399 : : /* For SLAB assign tags based on the object index in the freelist. */
400 : : return (u8)obj_to_index(cache, virt_to_page(object), (void *)object);
401 : : #else
402 : : /*
403 : : * For SLUB assign a random tag during slab creation, otherwise reuse
404 : : * the already assigned tag.
405 : : */
406 : : return init ? random_tag() : get_tag(object);
407 : : #endif
408 : : }
409 : :
410 : 6191870 : void * __must_check kasan_init_slab_obj(struct kmem_cache *cache,
411 : : const void *object)
412 : : {
413 : 6191870 : struct kasan_alloc_meta *alloc_info;
414 : :
415 [ + - ]: 6191870 : if (!(cache->flags & SLAB_KASAN))
416 : : return (void *)object;
417 : :
418 : 6191870 : alloc_info = get_alloc_info(cache, object);
419 : 6191870 : __memset(alloc_info, 0, sizeof(*alloc_info));
420 : :
421 : 6191870 : if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
422 : : object = set_tag(object,
423 : : assign_tag(cache, object, true, false));
424 : :
425 : 6191870 : return (void *)object;
426 : : }
427 : :
428 : 8149385 : static inline bool shadow_invalid(u8 tag, s8 shadow_byte)
429 : : {
430 : 8149385 : if (IS_ENABLED(CONFIG_KASAN_GENERIC))
431 : 8149385 : return shadow_byte < 0 ||
432 : : shadow_byte >= KASAN_SHADOW_SCALE_SIZE;
433 : :
434 : : /* else CONFIG_KASAN_SW_TAGS: */
435 : : if ((u8)shadow_byte == KASAN_TAG_INVALID)
436 : : return true;
437 : : if ((tag != KASAN_TAG_KERNEL) && (tag != (u8)shadow_byte))
438 : : return true;
439 : :
440 : : return false;
441 : : }
442 : :
443 : 8418374 : static bool __kasan_slab_free(struct kmem_cache *cache, void *object,
444 : : unsigned long ip, bool quarantine)
445 : : {
446 : 8418374 : s8 shadow_byte;
447 : 8418374 : u8 tag;
448 : 8418374 : void *tagged_object;
449 : 8418374 : unsigned long rounded_up_size;
450 : :
451 : 8418374 : tag = get_tag(object);
452 : 8418374 : tagged_object = object;
453 : 8418374 : object = reset_tag(object);
454 : :
455 [ + - - + ]: 16836760 : if (unlikely(nearest_obj(cache, virt_to_head_page(object), object) !=
456 : : object)) {
457 : 0 : kasan_report_invalid_free(tagged_object, ip);
458 : 0 : return true;
459 : : }
460 : :
461 : : /* RCU slabs could be legally used after free within the RCU period */
462 [ + + ]: 8418374 : if (unlikely(cache->flags & SLAB_TYPESAFE_BY_RCU))
463 : : return false;
464 : :
465 [ - + ]: 8149385 : shadow_byte = READ_ONCE(*(s8 *)kasan_mem_to_shadow(object));
466 [ - + ]: 8149385 : if (shadow_invalid(tag, shadow_byte)) {
467 : 0 : kasan_report_invalid_free(tagged_object, ip);
468 : 0 : return true;
469 : : }
470 : :
471 : 8149385 : rounded_up_size = round_up(cache->object_size, KASAN_SHADOW_SCALE_SIZE);
472 : 8149385 : kasan_poison_shadow(object, rounded_up_size, KASAN_KMALLOC_FREE);
473 : :
474 [ + + ]: 8149385 : if ((IS_ENABLED(CONFIG_KASAN_GENERIC) && !quarantine) ||
475 [ + - ]: 8145018 : unlikely(!(cache->flags & SLAB_KASAN)))
476 : : return false;
477 : :
478 : 8145018 : kasan_set_free_info(cache, object, tag);
479 : :
480 : 8145018 : quarantine_put(get_free_info(cache, object), cache);
481 : :
482 : 8145018 : return IS_ENABLED(CONFIG_KASAN_GENERIC);
483 : : }
484 : :
485 : 8414007 : bool kasan_slab_free(struct kmem_cache *cache, void *object, unsigned long ip)
486 : : {
487 : 8414007 : return __kasan_slab_free(cache, object, ip, true);
488 : : }
489 : :
490 : 10643632 : static void *__kasan_kmalloc(struct kmem_cache *cache, const void *object,
491 : : size_t size, gfp_t flags, bool keep_tag)
492 : : {
493 : 10643632 : unsigned long redzone_start;
494 : 10643632 : unsigned long redzone_end;
495 : 10643632 : u8 tag = 0xff;
496 : :
497 [ + + ]: 10643632 : if (gfpflags_allow_blocking(flags))
498 : 10187967 : quarantine_reduce();
499 : :
500 [ + - ]: 10643632 : if (unlikely(object == NULL))
501 : : return NULL;
502 : :
503 : 10643632 : redzone_start = round_up((unsigned long)(object + size),
504 : : KASAN_SHADOW_SCALE_SIZE);
505 : 10643632 : redzone_end = round_up((unsigned long)object + cache->object_size,
506 : : KASAN_SHADOW_SCALE_SIZE);
507 : :
508 : 10643632 : if (IS_ENABLED(CONFIG_KASAN_SW_TAGS))
509 : : tag = assign_tag(cache, object, false, keep_tag);
510 : :
511 : : /* Tag is ignored in set_tag without CONFIG_KASAN_SW_TAGS */
512 : 10643632 : kasan_unpoison_shadow(set_tag(object, tag), size);
513 : 10643632 : kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start,
514 : : KASAN_KMALLOC_REDZONE);
515 : :
516 [ + - ]: 10643632 : if (cache->flags & SLAB_KASAN)
517 : 10643632 : set_track(&get_alloc_info(cache, object)->alloc_track, flags);
518 : :
519 : : return set_tag(object, tag);
520 : : }
521 : :
522 : 9640123 : void * __must_check kasan_slab_alloc(struct kmem_cache *cache, void *object,
523 : : gfp_t flags)
524 : : {
525 : 9640123 : return __kasan_kmalloc(cache, object, cache->object_size, flags, false);
526 : : }
527 : :
528 : 1000264 : void * __must_check kasan_kmalloc(struct kmem_cache *cache, const void *object,
529 : : size_t size, gfp_t flags)
530 : : {
531 : 1000264 : return __kasan_kmalloc(cache, object, size, flags, true);
532 : : }
533 : : EXPORT_SYMBOL(kasan_kmalloc);
534 : :
535 : 319 : void * __must_check kasan_kmalloc_large(const void *ptr, size_t size,
536 : : gfp_t flags)
537 : : {
538 : 319 : struct page *page;
539 : 319 : unsigned long redzone_start;
540 : 319 : unsigned long redzone_end;
541 : :
542 [ + + ]: 319 : if (gfpflags_allow_blocking(flags))
543 : 308 : quarantine_reduce();
544 : :
545 [ + - ]: 319 : if (unlikely(ptr == NULL))
546 : : return NULL;
547 : :
548 [ + - ]: 319 : page = virt_to_page(ptr);
549 : 319 : redzone_start = round_up((unsigned long)(ptr + size),
550 : : KASAN_SHADOW_SCALE_SIZE);
551 : 319 : redzone_end = (unsigned long)ptr + page_size(page);
552 : :
553 : 319 : kasan_unpoison_shadow(ptr, size);
554 : 319 : kasan_poison_shadow((void *)redzone_start, redzone_end - redzone_start,
555 : : KASAN_PAGE_REDZONE);
556 : :
557 : 319 : return (void *)ptr;
558 : : }
559 : :
560 : 3135 : void * __must_check kasan_krealloc(const void *object, size_t size, gfp_t flags)
561 : : {
562 : 3135 : struct page *page;
563 : :
564 [ + - ]: 3135 : if (unlikely(object == ZERO_SIZE_PTR))
565 : : return (void *)object;
566 : :
567 [ + - ]: 3135 : page = virt_to_head_page(object);
568 : :
569 [ - + - + ]: 3135 : if (unlikely(!PageSlab(page)))
570 : 0 : return kasan_kmalloc_large(object, size, flags);
571 : : else
572 : 3135 : return __kasan_kmalloc(page->slab_cache, object, size,
573 : : flags, true);
574 : : }
575 : :
576 : 4367 : void kasan_poison_kfree(void *ptr, unsigned long ip)
577 : : {
578 : 4367 : struct page *page;
579 : :
580 [ + - ]: 4367 : page = virt_to_head_page(ptr);
581 : :
582 [ - + - + ]: 4367 : if (unlikely(!PageSlab(page))) {
583 [ # # ]: 0 : if (ptr != page_address(page)) {
584 : 0 : kasan_report_invalid_free(ptr, ip);
585 : 0 : return;
586 : : }
587 : 0 : kasan_poison_shadow(ptr, page_size(page), KASAN_FREE_PAGE);
588 : : } else {
589 : 4367 : __kasan_slab_free(page->slab_cache, ptr, ip, false);
590 : : }
591 : : }
592 : :
593 : 165 : void kasan_kfree_large(void *ptr, unsigned long ip)
594 : : {
595 [ + - - + ]: 330 : if (ptr != page_address(virt_to_head_page(ptr)))
596 : 0 : kasan_report_invalid_free(ptr, ip);
597 : : /* The object will be poisoned by page_alloc. */
598 : 165 : }
599 : :
600 : : #ifndef CONFIG_KASAN_VMALLOC
601 : 22 : int kasan_module_alloc(void *addr, size_t size)
602 : : {
603 : 22 : void *ret;
604 : 22 : size_t scaled_size;
605 : 22 : size_t shadow_size;
606 : 22 : unsigned long shadow_start;
607 : :
608 [ - + ]: 22 : shadow_start = (unsigned long)kasan_mem_to_shadow(addr);
609 : 22 : scaled_size = (size + KASAN_SHADOW_MASK) >> KASAN_SHADOW_SCALE_SHIFT;
610 : 22 : shadow_size = round_up(scaled_size, PAGE_SIZE);
611 : :
612 [ - + + - ]: 22 : if (WARN_ON(!PAGE_ALIGNED(shadow_start)))
613 : : return -EINVAL;
614 : :
615 : 44 : ret = __vmalloc_node_range(shadow_size, 1, shadow_start,
616 : : shadow_start + shadow_size,
617 : : GFP_KERNEL,
618 : 22 : PAGE_KERNEL, VM_NO_GUARD, NUMA_NO_NODE,
619 : 22 : __builtin_return_address(0));
620 : :
621 [ + - ]: 22 : if (ret) {
622 : 22 : __memset(ret, KASAN_SHADOW_INIT, shadow_size);
623 : 22 : find_vm_area(addr)->flags |= VM_KASAN;
624 : 22 : kmemleak_ignore(ret);
625 : 22 : return 0;
626 : : }
627 : :
628 : : return -ENOMEM;
629 : : }
630 : :
631 : 133243 : void kasan_free_shadow(const struct vm_struct *vm)
632 : : {
633 [ + + ]: 133243 : if (vm->flags & VM_KASAN)
634 : 11 : vfree(kasan_mem_to_shadow(vm->addr));
635 : 133243 : }
636 : : #endif
637 : :
638 : : extern void __kasan_report(unsigned long addr, size_t size, bool is_write, unsigned long ip);
639 : :
640 : 1545126 : void kasan_report(unsigned long addr, size_t size, bool is_write, unsigned long ip)
641 : : {
642 : 1545126 : unsigned long flags = user_access_save();
643 : 1545126 : __kasan_report(addr, size, is_write, ip);
644 : 1545126 : user_access_restore(flags);
645 : 1545126 : }
646 : :
647 : : #ifdef CONFIG_MEMORY_HOTPLUG
648 : : static bool shadow_mapped(unsigned long addr)
649 : : {
650 : : pgd_t *pgd = pgd_offset_k(addr);
651 : : p4d_t *p4d;
652 : : pud_t *pud;
653 : : pmd_t *pmd;
654 : : pte_t *pte;
655 : :
656 : : if (pgd_none(*pgd))
657 : : return false;
658 : : p4d = p4d_offset(pgd, addr);
659 : : if (p4d_none(*p4d))
660 : : return false;
661 : : pud = pud_offset(p4d, addr);
662 : : if (pud_none(*pud))
663 : : return false;
664 : :
665 : : /*
666 : : * We can't use pud_large() or pud_huge(), the first one is
667 : : * arch-specific, the last one depends on HUGETLB_PAGE. So let's abuse
668 : : * pud_bad(), if pud is bad then it's bad because it's huge.
669 : : */
670 : : if (pud_bad(*pud))
671 : : return true;
672 : : pmd = pmd_offset(pud, addr);
673 : : if (pmd_none(*pmd))
674 : : return false;
675 : :
676 : : if (pmd_bad(*pmd))
677 : : return true;
678 : : pte = pte_offset_kernel(pmd, addr);
679 : : return !pte_none(*pte);
680 : : }
681 : :
682 : : static int __meminit kasan_mem_notifier(struct notifier_block *nb,
683 : : unsigned long action, void *data)
684 : : {
685 : : struct memory_notify *mem_data = data;
686 : : unsigned long nr_shadow_pages, start_kaddr, shadow_start;
687 : : unsigned long shadow_end, shadow_size;
688 : :
689 : : nr_shadow_pages = mem_data->nr_pages >> KASAN_SHADOW_SCALE_SHIFT;
690 : : start_kaddr = (unsigned long)pfn_to_kaddr(mem_data->start_pfn);
691 : : shadow_start = (unsigned long)kasan_mem_to_shadow((void *)start_kaddr);
692 : : shadow_size = nr_shadow_pages << PAGE_SHIFT;
693 : : shadow_end = shadow_start + shadow_size;
694 : :
695 : : if (WARN_ON(mem_data->nr_pages % KASAN_SHADOW_SCALE_SIZE) ||
696 : : WARN_ON(start_kaddr % (KASAN_SHADOW_SCALE_SIZE << PAGE_SHIFT)))
697 : : return NOTIFY_BAD;
698 : :
699 : : switch (action) {
700 : : case MEM_GOING_ONLINE: {
701 : : void *ret;
702 : :
703 : : /*
704 : : * If shadow is mapped already than it must have been mapped
705 : : * during the boot. This could happen if we onlining previously
706 : : * offlined memory.
707 : : */
708 : : if (shadow_mapped(shadow_start))
709 : : return NOTIFY_OK;
710 : :
711 : : ret = __vmalloc_node_range(shadow_size, PAGE_SIZE, shadow_start,
712 : : shadow_end, GFP_KERNEL,
713 : : PAGE_KERNEL, VM_NO_GUARD,
714 : : pfn_to_nid(mem_data->start_pfn),
715 : : __builtin_return_address(0));
716 : : if (!ret)
717 : : return NOTIFY_BAD;
718 : :
719 : : kmemleak_ignore(ret);
720 : : return NOTIFY_OK;
721 : : }
722 : : case MEM_CANCEL_ONLINE:
723 : : case MEM_OFFLINE: {
724 : : struct vm_struct *vm;
725 : :
726 : : /*
727 : : * shadow_start was either mapped during boot by kasan_init()
728 : : * or during memory online by __vmalloc_node_range().
729 : : * In the latter case we can use vfree() to free shadow.
730 : : * Non-NULL result of the find_vm_area() will tell us if
731 : : * that was the second case.
732 : : *
733 : : * Currently it's not possible to free shadow mapped
734 : : * during boot by kasan_init(). It's because the code
735 : : * to do that hasn't been written yet. So we'll just
736 : : * leak the memory.
737 : : */
738 : : vm = find_vm_area((void *)shadow_start);
739 : : if (vm)
740 : : vfree((void *)shadow_start);
741 : : }
742 : : }
743 : :
744 : : return NOTIFY_OK;
745 : : }
746 : :
747 : : static int __init kasan_memhotplug_init(void)
748 : : {
749 : : hotplug_memory_notifier(kasan_mem_notifier, 0);
750 : :
751 : : return 0;
752 : : }
753 : :
754 : : core_initcall(kasan_memhotplug_init);
755 : : #endif
756 : :
757 : : #ifdef CONFIG_KASAN_VMALLOC
758 : : static int kasan_populate_vmalloc_pte(pte_t *ptep, unsigned long addr,
759 : : void *unused)
760 : : {
761 : : unsigned long page;
762 : : pte_t pte;
763 : :
764 : : if (likely(!pte_none(*ptep)))
765 : : return 0;
766 : :
767 : : page = __get_free_page(GFP_KERNEL);
768 : : if (!page)
769 : : return -ENOMEM;
770 : :
771 : : memset((void *)page, KASAN_VMALLOC_INVALID, PAGE_SIZE);
772 : : pte = pfn_pte(PFN_DOWN(__pa(page)), PAGE_KERNEL);
773 : :
774 : : spin_lock(&init_mm.page_table_lock);
775 : : if (likely(pte_none(*ptep))) {
776 : : set_pte_at(&init_mm, addr, ptep, pte);
777 : : page = 0;
778 : : }
779 : : spin_unlock(&init_mm.page_table_lock);
780 : : if (page)
781 : : free_page(page);
782 : : return 0;
783 : : }
784 : :
785 : : int kasan_populate_vmalloc(unsigned long addr, unsigned long size)
786 : : {
787 : : unsigned long shadow_start, shadow_end;
788 : : int ret;
789 : :
790 : : if (!is_vmalloc_or_module_addr((void *)addr))
791 : : return 0;
792 : :
793 : : shadow_start = (unsigned long)kasan_mem_to_shadow((void *)addr);
794 : : shadow_start = ALIGN_DOWN(shadow_start, PAGE_SIZE);
795 : : shadow_end = (unsigned long)kasan_mem_to_shadow((void *)addr + size);
796 : : shadow_end = ALIGN(shadow_end, PAGE_SIZE);
797 : :
798 : : ret = apply_to_page_range(&init_mm, shadow_start,
799 : : shadow_end - shadow_start,
800 : : kasan_populate_vmalloc_pte, NULL);
801 : : if (ret)
802 : : return ret;
803 : :
804 : : flush_cache_vmap(shadow_start, shadow_end);
805 : :
806 : : /*
807 : : * We need to be careful about inter-cpu effects here. Consider:
808 : : *
809 : : * CPU#0 CPU#1
810 : : * WRITE_ONCE(p, vmalloc(100)); while (x = READ_ONCE(p)) ;
811 : : * p[99] = 1;
812 : : *
813 : : * With compiler instrumentation, that ends up looking like this:
814 : : *
815 : : * CPU#0 CPU#1
816 : : * // vmalloc() allocates memory
817 : : * // let a = area->addr
818 : : * // we reach kasan_populate_vmalloc
819 : : * // and call kasan_unpoison_shadow:
820 : : * STORE shadow(a), unpoison_val
821 : : * ...
822 : : * STORE shadow(a+99), unpoison_val x = LOAD p
823 : : * // rest of vmalloc process <data dependency>
824 : : * STORE p, a LOAD shadow(x+99)
825 : : *
826 : : * If there is no barrier between the end of unpoisioning the shadow
827 : : * and the store of the result to p, the stores could be committed
828 : : * in a different order by CPU#0, and CPU#1 could erroneously observe
829 : : * poison in the shadow.
830 : : *
831 : : * We need some sort of barrier between the stores.
832 : : *
833 : : * In the vmalloc() case, this is provided by a smp_wmb() in
834 : : * clear_vm_uninitialized_flag(). In the per-cpu allocator and in
835 : : * get_vm_area() and friends, the caller gets shadow allocated but
836 : : * doesn't have any pages mapped into the virtual address space that
837 : : * has been reserved. Mapping those pages in will involve taking and
838 : : * releasing a page-table lock, which will provide the barrier.
839 : : */
840 : :
841 : : return 0;
842 : : }
843 : :
844 : : /*
845 : : * Poison the shadow for a vmalloc region. Called as part of the
846 : : * freeing process at the time the region is freed.
847 : : */
848 : : void kasan_poison_vmalloc(const void *start, unsigned long size)
849 : : {
850 : : if (!is_vmalloc_or_module_addr(start))
851 : : return;
852 : :
853 : : size = round_up(size, KASAN_SHADOW_SCALE_SIZE);
854 : : kasan_poison_shadow(start, size, KASAN_VMALLOC_INVALID);
855 : : }
856 : :
857 : : void kasan_unpoison_vmalloc(const void *start, unsigned long size)
858 : : {
859 : : if (!is_vmalloc_or_module_addr(start))
860 : : return;
861 : :
862 : : kasan_unpoison_shadow(start, size);
863 : : }
864 : :
865 : : static int kasan_depopulate_vmalloc_pte(pte_t *ptep, unsigned long addr,
866 : : void *unused)
867 : : {
868 : : unsigned long page;
869 : :
870 : : page = (unsigned long)__va(pte_pfn(*ptep) << PAGE_SHIFT);
871 : :
872 : : spin_lock(&init_mm.page_table_lock);
873 : :
874 : : if (likely(!pte_none(*ptep))) {
875 : : pte_clear(&init_mm, addr, ptep);
876 : : free_page(page);
877 : : }
878 : : spin_unlock(&init_mm.page_table_lock);
879 : :
880 : : return 0;
881 : : }
882 : :
883 : : /*
884 : : * Release the backing for the vmalloc region [start, end), which
885 : : * lies within the free region [free_region_start, free_region_end).
886 : : *
887 : : * This can be run lazily, long after the region was freed. It runs
888 : : * under vmap_area_lock, so it's not safe to interact with the vmalloc/vmap
889 : : * infrastructure.
890 : : *
891 : : * How does this work?
892 : : * -------------------
893 : : *
894 : : * We have a region that is page aligned, labelled as A.
895 : : * That might not map onto the shadow in a way that is page-aligned:
896 : : *
897 : : * start end
898 : : * v v
899 : : * |????????|????????|AAAAAAAA|AA....AA|AAAAAAAA|????????| < vmalloc
900 : : * -------- -------- -------- -------- --------
901 : : * | | | | |
902 : : * | | | /-------/ |
903 : : * \-------\|/------/ |/---------------/
904 : : * ||| ||
905 : : * |??AAAAAA|AAAAAAAA|AA??????| < shadow
906 : : * (1) (2) (3)
907 : : *
908 : : * First we align the start upwards and the end downwards, so that the
909 : : * shadow of the region aligns with shadow page boundaries. In the
910 : : * example, this gives us the shadow page (2). This is the shadow entirely
911 : : * covered by this allocation.
912 : : *
913 : : * Then we have the tricky bits. We want to know if we can free the
914 : : * partially covered shadow pages - (1) and (3) in the example. For this,
915 : : * we are given the start and end of the free region that contains this
916 : : * allocation. Extending our previous example, we could have:
917 : : *
918 : : * free_region_start free_region_end
919 : : * | start end |
920 : : * v v v v
921 : : * |FFFFFFFF|FFFFFFFF|AAAAAAAA|AA....AA|AAAAAAAA|FFFFFFFF| < vmalloc
922 : : * -------- -------- -------- -------- --------
923 : : * | | | | |
924 : : * | | | /-------/ |
925 : : * \-------\|/------/ |/---------------/
926 : : * ||| ||
927 : : * |FFAAAAAA|AAAAAAAA|AAF?????| < shadow
928 : : * (1) (2) (3)
929 : : *
930 : : * Once again, we align the start of the free region up, and the end of
931 : : * the free region down so that the shadow is page aligned. So we can free
932 : : * page (1) - we know no allocation currently uses anything in that page,
933 : : * because all of it is in the vmalloc free region. But we cannot free
934 : : * page (3), because we can't be sure that the rest of it is unused.
935 : : *
936 : : * We only consider pages that contain part of the original region for
937 : : * freeing: we don't try to free other pages from the free region or we'd
938 : : * end up trying to free huge chunks of virtual address space.
939 : : *
940 : : * Concurrency
941 : : * -----------
942 : : *
943 : : * How do we know that we're not freeing a page that is simultaneously
944 : : * being used for a fresh allocation in kasan_populate_vmalloc(_pte)?
945 : : *
946 : : * We _can_ have kasan_release_vmalloc and kasan_populate_vmalloc running
947 : : * at the same time. While we run under free_vmap_area_lock, the population
948 : : * code does not.
949 : : *
950 : : * free_vmap_area_lock instead operates to ensure that the larger range
951 : : * [free_region_start, free_region_end) is safe: because __alloc_vmap_area and
952 : : * the per-cpu region-finding algorithm both run under free_vmap_area_lock,
953 : : * no space identified as free will become used while we are running. This
954 : : * means that so long as we are careful with alignment and only free shadow
955 : : * pages entirely covered by the free region, we will not run in to any
956 : : * trouble - any simultaneous allocations will be for disjoint regions.
957 : : */
958 : : void kasan_release_vmalloc(unsigned long start, unsigned long end,
959 : : unsigned long free_region_start,
960 : : unsigned long free_region_end)
961 : : {
962 : : void *shadow_start, *shadow_end;
963 : : unsigned long region_start, region_end;
964 : : unsigned long size;
965 : :
966 : : region_start = ALIGN(start, PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
967 : : region_end = ALIGN_DOWN(end, PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
968 : :
969 : : free_region_start = ALIGN(free_region_start,
970 : : PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
971 : :
972 : : if (start != region_start &&
973 : : free_region_start < region_start)
974 : : region_start -= PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE;
975 : :
976 : : free_region_end = ALIGN_DOWN(free_region_end,
977 : : PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE);
978 : :
979 : : if (end != region_end &&
980 : : free_region_end > region_end)
981 : : region_end += PAGE_SIZE * KASAN_SHADOW_SCALE_SIZE;
982 : :
983 : : shadow_start = kasan_mem_to_shadow((void *)region_start);
984 : : shadow_end = kasan_mem_to_shadow((void *)region_end);
985 : :
986 : : if (shadow_end > shadow_start) {
987 : : size = shadow_end - shadow_start;
988 : : apply_to_existing_page_range(&init_mm,
989 : : (unsigned long)shadow_start,
990 : : size, kasan_depopulate_vmalloc_pte,
991 : : NULL);
992 : : flush_tlb_kernel_range((unsigned long)shadow_start,
993 : : (unsigned long)shadow_end);
994 : : }
995 : : }
996 : : #endif
|
