| From c5f3b1a51a591c18c8b33983908e7fdda6ae417e Mon Sep 17 00:00:00 2001 |
| From: Catalin Marinas <catalin.marinas@arm.com> |
| Date: Wed, 24 Jun 2015 16:58:26 -0700 |
| Subject: mm: kmemleak: allow safe memory scanning during kmemleak disabling |
| |
| From: Catalin Marinas <catalin.marinas@arm.com> |
| |
| commit c5f3b1a51a591c18c8b33983908e7fdda6ae417e upstream. |
| |
| The kmemleak scanning thread can run for minutes. Callbacks like |
| kmemleak_free() are allowed during this time, the race being taken care |
| of by the object->lock spinlock. Such lock also prevents a memory block |
| from being freed or unmapped while it is being scanned by blocking the |
| kmemleak_free() -> ... -> __delete_object() function until the lock is |
| released in scan_object(). |
| |
| When a kmemleak error occurs (e.g. it fails to allocate its metadata), |
| kmemleak_enabled is set and __delete_object() is no longer called on |
| freed objects. If kmemleak_scan is running at the same time, |
| kmemleak_free() no longer waits for the object scanning to complete, |
| allowing the corresponding memory block to be freed or unmapped (in the |
| case of vfree()). This leads to kmemleak_scan potentially triggering a |
| page fault. |
| |
| This patch separates the kmemleak_free() enabling/disabling from the |
| overall kmemleak_enabled nob so that we can defer the disabling of the |
| object freeing tracking until the scanning thread completed. The |
| kmemleak_free_part() is deliberately ignored by this patch since this is |
| only called during boot before the scanning thread started. |
| |
| Signed-off-by: Catalin Marinas <catalin.marinas@arm.com> |
| Reported-by: Vignesh Radhakrishnan <vigneshr@codeaurora.org> |
| Tested-by: Vignesh Radhakrishnan <vigneshr@codeaurora.org> |
| Signed-off-by: Andrew Morton <akpm@linux-foundation.org> |
| Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org> |
| Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org> |
| |
| --- |
| mm/kmemleak.c | 19 ++++++++++++++++--- |
| 1 file changed, 16 insertions(+), 3 deletions(-) |
| |
| --- a/mm/kmemleak.c |
| +++ b/mm/kmemleak.c |
| @@ -195,6 +195,8 @@ static struct kmem_cache *scan_area_cach |
| |
| /* set if tracing memory operations is enabled */ |
| static int kmemleak_enabled; |
| +/* same as above but only for the kmemleak_free() callback */ |
| +static int kmemleak_free_enabled; |
| /* set in the late_initcall if there were no errors */ |
| static int kmemleak_initialized; |
| /* enables or disables early logging of the memory operations */ |
| @@ -942,7 +944,7 @@ void __ref kmemleak_free(const void *ptr |
| { |
| pr_debug("%s(0x%p)\n", __func__, ptr); |
| |
| - if (kmemleak_enabled && ptr && !IS_ERR(ptr)) |
| + if (kmemleak_free_enabled && ptr && !IS_ERR(ptr)) |
| delete_object_full((unsigned long)ptr); |
| else if (kmemleak_early_log) |
| log_early(KMEMLEAK_FREE, ptr, 0, 0); |
| @@ -982,7 +984,7 @@ void __ref kmemleak_free_percpu(const vo |
| |
| pr_debug("%s(0x%p)\n", __func__, ptr); |
| |
| - if (kmemleak_enabled && ptr && !IS_ERR(ptr)) |
| + if (kmemleak_free_enabled && ptr && !IS_ERR(ptr)) |
| for_each_possible_cpu(cpu) |
| delete_object_full((unsigned long)per_cpu_ptr(ptr, |
| cpu)); |
| @@ -1750,6 +1752,13 @@ static void kmemleak_do_cleanup(struct w |
| mutex_lock(&scan_mutex); |
| stop_scan_thread(); |
| |
| + /* |
| + * Once the scan thread has stopped, it is safe to no longer track |
| + * object freeing. Ordering of the scan thread stopping and the memory |
| + * accesses below is guaranteed by the kthread_stop() function. |
| + */ |
| + kmemleak_free_enabled = 0; |
| + |
| if (!kmemleak_found_leaks) |
| __kmemleak_do_cleanup(); |
| else |
| @@ -1776,6 +1785,8 @@ static void kmemleak_disable(void) |
| /* check whether it is too early for a kernel thread */ |
| if (kmemleak_initialized) |
| schedule_work(&cleanup_work); |
| + else |
| + kmemleak_free_enabled = 0; |
| |
| pr_info("Kernel memory leak detector disabled\n"); |
| } |
| @@ -1840,8 +1851,10 @@ void __init kmemleak_init(void) |
| if (kmemleak_error) { |
| local_irq_restore(flags); |
| return; |
| - } else |
| + } else { |
| kmemleak_enabled = 1; |
| + kmemleak_free_enabled = 1; |
| + } |
| local_irq_restore(flags); |
| |
| /* |