mm: kmemleak: allow safe memory scanning during kmemleak disabling (c5f3b1a5) · Commits · 戴 / test

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> Cc: <stable@vger.kernel.org> Signed-off-by:

Andrew Morton <akpm@linux-foundation.org> Signed-off-by:

Linus Torvalds <torvalds@linux-foundation.org>

mm/kmemleak.c

+16 −3

Original line number	Diff line number	Diff line
		@@ -195,6 +195,8 @@ static struct kmem_cache *scan_area_cache;

		/* 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 void __percpu *ptr)

		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 work_struct *work)
		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);

		/*

Admin message