Kernel memory leak detector 0.4
Subsystems (8)
cover Kernel memory leak detector 0.4
This is a new version (0.4) of the kernel memory leak detector. See the Documentation/kmemleak.txt file for a more detailed description. The patches are downloadable from (the bundled patch or the full series):
http://homepage.ntlworld.com/cmarinas/kmemleak/patch-2.6.17-rc5-kmemleak-0.4.bz2
http://homepage.ntlworld.com/cmarinas/kmemleak/patches-kmemleak-0.4.tar.bz2
What's new in this version:
- full kernel modules support
- kmemleak now depends on DEBUG_SLAB. The detection is improved by the objects poisoning caused by this configuration option
- freeing orphan pointers is no longer reported since these can be false positives
- replaced some _rcu list traversal loops with their normal or _safe form
To do:
- better testing
- test Ingo's suggestion on task stacks scanning
- NUMA support
- (support for ioremap)
Signature · 1 line
Catalin
PATCH 1/8 Base support for kmemleak
From: Catalin Marinas <[email protected]>
This patch adds the base support for the kernel memory leak detector. It traces the memory allocation/freeing in a way similar to the Boehm's conservative garbage collector, the difference being that the orphan pointers are not freed but only shown in /proc/memleak. Enabling this feature would introduce an overhead to memory allocations.
---
include/linux/kernel.h | 7 include/linux/memleak.h | 79 ++++ init/main.c | 3 lib/Kconfig.debug | 43 ++ mm/Makefile | 2 mm/memleak.c | 1036 +++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 1167 insertions(+), 3 deletions(-)
include/linux/kernel.h +6 -1
@@ -13,6 +13,7 @@ #include <linux/stddef.h>#include <linux/types.h> #include <linux/compiler.h> #include <linux/bitops.h> +#include <linux/memleak.h> #include <asm/byteorder.h> #include <asm/bug.h>
@@ -284,9 +285,13 @@ #define max_t(type,x,y) \* @member: the name of the member within the struct. * */ -#define container_of (ptr, type, member) ({ \ +#define __container_of (ptr, type, member) ({ \ const typeof( ((type *)0)->member ) *__mptr = (ptr); \ (type *)( (char *)__mptr - offsetof(type,member) );}) +#define container_of (ptr, type, member) ({ \ + DECLARE_MEMLEAK_OFFSET(container_of, type, member); \ + __container_of(ptr, type, member); \ +})/* * Check at compile time that something is of a particular type.
include/linux/memleak.h new file +79 -0
79 lines not on this page · raw message
init/main.c +2 -1
@@ -513,6 +513,8 @@ #endifcpuset_init_early ();mem_init ();kmem_cache_init (); +radix_tree_init (); +memleak_debug_init ();setup_per_cpu_pageset ();numa_policy_init ();if (late_time_init)
@@ -533,7 +535,6 @@ #endifkey_init ();security_init ();vfs_caches_init (num_physpages); -radix_tree_init ();signals_init ();/* rootfs populating might need page-writeback */ page_writeback_init ();
lib/Kconfig.debug +43 -0
49 lines not on this page · raw message
mm/Makefile +1 -1
@@ -23,4 +23,4 @@ obj-$(CONFIG_SLAB) += slab.o obj-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o - +obj-$(CONFIG_DEBUG_MEMLEAK) += memleak.o
mm/memleak.c new file +1036 -0
1,036 lines not on this page · raw message
PATCH 2/8 Some documentation for kmemleak
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
---
Documentation/kmemleak.txt | 92 ++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 92 insertions(+), 0 deletions(-)
Documentation/kmemleak.txt new file +92 -0
@@ -0,0 +1,92 @@ +Kernel Memory Leak Detector +=========================== + + +Introduction +------------ + +Kmemleak provides a way of detecting possible kernel memory leaks in a +way similar to a tracing garbage collector +(http://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29#Tracing_garbage_collectors), +with the difference that the orphan pointers are not freed but only +reported via /sys/kernel/debug/memleak. A similar method is used by +the Valgrind tool (memcheck --leak-check) to detect the memory leaks +in user-space applications. + + +Basic Algorithm +--------------- + +The memory allocations via kmalloc, vmalloc, kmem_cache_alloc and +friends are tracked and the pointers, together with additional +information like size and stack trace, are stored in a radix tree. The +corresponding freeing function calls are tracked and the pointers +removed from the radix tree. + +An allocated block of memory is considered orphan if a pointer to its +start address or to an alias (pointer aliases are explained later) +cannot be found by scanning the memory (including saved +registers). This means that there might be no way for the kernel to +pass the address of the allocated block to a freeing function and +therefore the block is considered a leak. + +The scanning algorithm steps: + + 1. mark all pointers as white (remaining white pointers will later + be considered orphan) + 2. scan the memory starting with the data section and stacks, + checking the values against the addresses stored in the radix + tree. If a white pointer is found, it is added to the grey list + 3. scan the grey pointers for matching addresses (some white + pointers can become grey and added at the end of the grey list) + until the grey set is finished + 4. the remaining white pointers are considered orphan and reported + via /sys/kernel/debug/memleak + + +Improvements +------------ + +Because the Linux kernel calculates many pointers at run-time via the +container_of macro (see the lists implementation), a lot of false +positives would be reported. This tool re-writes the container_of +macro so that the offset and size information is stored in the +.init.memleak_offsets section. The memleak_init() function creates a +radix tree with corresponding offsets for every encountered block +size. The memory allocations hook stores the pointer address together +with its aliases based on the size of the allocated block. + +While one level of offsets should be enough for most cases, two levels +are considered, i.e. container_of(container_of(...)) (one false +positive is the "struct socket_alloc" allocation in the +sock_alloc_inode() function). + +Some allocated memory blocks have pointers stored in the kernel's +internal data structures and they cannot be detected as orphans. To +avoid this, kmemleak can also store the number of values equal to the +pointer (or aliases) that need to be found so that the block is not +considered a leak. One example is __vmalloc(). + + +Limitations and Drawbacks +------------------------- + +The biggest drawback is the reduced performance of memory allocation +and freeing. To avoid other penalties, the memory scanning is only +performed when the /sys/kernel/debug/memleak file is read. Anyway, +this tool is intended for debugging purposes where the performance +might not be the most important requirement. + +The tool can report false positives. These are cases where an +allocated block doesn't need to be freed (some cases in the init_call +functions), the pointer is calculated by other methods than the +container_of macro or the pointer is stored in a location not scanned +by kmemleak. If the "member" argument in the offsetof(type, member) +call is not constant, kmemleak considers the offset as zero since it +cannot be determined at compilation time (as a side node, it seems +that gcc-4.0 doesn't compile these offsetof constructs either). + +Page allocations and ioremap are not tracked. NUMA architectures are +not supported yet. + +Only the ARM and i386 architectures are currently supported.
PATCH 3/8 Add the memory allocation/freeing hooks for kmemleak
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
This patch adds the callbacks to memleak_(alloc|free) functions from kmalloc/kree, kmem_cache_(alloc|free), vmalloc/vfree etc.
---
drivers/base/platform.c | 1 + include/linux/slab.h | 4 ++++ mm/page_alloc.c | 2 ++ mm/slab.c | 22 ++++++++++++++++++++-- mm/vmalloc.c | 24 ++++++++++++++++++++++-- 5 files changed, 49 insertions(+), 4 deletions(-)
drivers/base/platform.c +1 -0
@@ -166,6 +166,7 @@ struct platform_device *platform_device_struct platform_object *pa; pa =kzalloc (sizeof (struct platform_object ) +strlen (name),GFP_KERNEL ); +memleak_debug_resize (pa,sizeof (struct platform_object ));if (pa) {strcpy (pa->name, name); pa->pdev.name = pa->name;
include/linux/slab.h +4 -0
@@ -89,6 +89,7 @@ #endifstatic inline void *kmalloc (size_t size,gfp_t flags) { +#ifndef CONFIG_DEBUG_MEMLEAK if (__builtin_constant_p (size)) {int i =0 ;#define CACHE (x) \
@@ -107,6 +108,7 @@ found: malloc_sizes[i].cs_dmacachep : malloc_sizes[i].cs_cachep, flags); } +#endif return __kmalloc (size, flags); }
@@ -114,6 +116,7 @@ extern void *__kzalloc(size_t, gfp_t);static inline void *kzalloc (size_t size,gfp_t flags) { +#ifndef CONFIG_DEBUG_MEMLEAK if (__builtin_constant_p (size)) {int i =0 ;#define CACHE (x) \
@@ -132,6 +135,7 @@ found: malloc_sizes[i].cs_dmacachep : malloc_sizes[i].cs_cachep, flags); } +#endif return __kzalloc (size, flags); }
mm/page_alloc.c +2 -0
@@ -2800,6 +2800,8 @@ void *__init alloc_large_system_hash(conif (_hash_mask) *_hash_mask = (1 << log2qty) -1 ; +memleak_debug_alloc (table, size,1 ); +return table; }
mm/slab.c +20 -2
@@ -2879,6 +2879,7 @@ #endifSTATS_INC_ALLOCMISS (cachep); objp =cache_alloc_refill (cachep, flags); } +memleak_debug_erase (ac->entry[ac->avail]);return objp; }
@@ -3144,7 +3145,11 @@ #endif*/ void *kmem_cache_alloc (struct kmem_cache *cachep,gfp_t flags) { -return __cache_alloc (cachep, flags,__builtin_return_address (0 )); +void *ptr =__cache_alloc (cachep, flags,__builtin_return_address (0 )); + +memleak_debug_alloc (ptr, cachep->obj_size,1 ); + +return ptr; }EXPORT_SYMBOL (kmem_cache_alloc);
@@ -3159,6 +3164,9 @@ EXPORT_SYMBOL(kmem_cache_alloc);void *kmem_cache_zalloc (struct kmem_cache *cache,gfp_t flags) {void *ret =__cache_alloc (cache, flags,__builtin_return_address (0 )); + +memleak_debug_alloc (ret, cache->obj_size,1 ); +if (ret)memset (ret,0 ,obj_size (cache));return ret;
@@ -3280,6 +3288,7 @@ static __always_inline void *__do_kmallo void *caller) {struct kmem_cache *cachep; +void *ptr;/* If you want to save a few bytes .text space: replace * __ with kmem_.
@@ -3289,7 +3298,11 @@ static __always_inline void *__do_kmallo cachep =__find_general_cachep (size, flags);if (unlikely (cachep ==NULL ))return NULL ; -return __cache_alloc (cachep, flags, caller); + ptr =__cache_alloc (cachep, flags, caller); + +memleak_debug_alloc (ptr, size,1 ); + +return ptr; }
@@ -3373,6 +3386,9 @@ void kmem_cache_free(struct kmem_cache *unsigned long flags;local_irq_save (flags); + +memleak_debug_free (objp); +__cache_free (cachep, objp);local_irq_restore (flags); }
@@ -3396,6 +3412,8 @@ void kfree(const void *objp)return ;local_irq_save (flags);kfree_debugcheck (objp); +memleak_debug_free (objp); + c =virt_to_cache (objp);mutex_debug_check_no_locks_freed (objp,obj_size (c));__cache_free (c, (void *)objp);
mm/vmalloc.c +22 -2
@@ -349,6 +349,9 @@ void __vunmap(void *addr, int deallocatevoid vfree (void *addr) {BUG_ON (in_interrupt ()); + +memleak_debug_free (addr); +__vunmap (addr,1 ); }EXPORT_SYMBOL (vfree);
@@ -447,7 +450,14 @@ fail:void *__vmalloc_area (struct vm_struct *area,gfp_t gfp_mask,pgprot_t prot) { -return __vmalloc_area_node (area, gfp_mask, prot,-1 ); +void *addr =__vmalloc_area_node (area, gfp_mask, prot,-1 ); + +/* this needs ref_count = 2 since vm_struct also contains a +pointer to this address. The guard page is also subtracted +from the size */ +memleak_debug_alloc (addr, area->size -PAGE_SIZE ,2 ); + +return addr; }/**
@@ -466,6 +476,10 @@ void *__vmalloc_node(unsigned long size, int node) {struct vm_struct *area; +void *addr; +#ifdef CONFIG_DEBUG_MEMLEAK +unsigned long real_size = size; +#endif size =PAGE_ALIGN (size);if (!size || (size >>PAGE_SHIFT ) > num_physpages)
@@ -475,7 +489,13 @@ void *__vmalloc_node(unsigned long size,if (!area)return NULL ; -return __vmalloc_area_node (area, gfp_mask, prot, node); + addr =__vmalloc_area_node (area, gfp_mask, prot, node); + +/* this needs ref_count = 2 since the vm_struct also contains +a pointer to this address */ +memleak_debug_alloc (addr, real_size,2 ); + +return addr; }EXPORT_SYMBOL (__vmalloc_node);
PATCH 4/8 Modules support for kmemleak
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
This patch handles the kmemleak operations needed for modules loading so that memory allocations from inside a module are properly tracked.
---
kernel/module.c | 32 ++++++++++++++++++++++++++++++++ 1 files changed, 32 insertions(+), 0 deletions(-)
kernel/module.c +32 -0
@@ -1413,6 +1413,9 @@ static struct module *load_module(void _ exportindex, modindex, obsparmindex, infoindex, gplindex, crcindex, gplcrcindex, versindex, pcpuindex, gplfutureindex, gplfuturecrcindex; +#ifdef CONFIG_DEBUG_MEMLEAK +unsigned int dataindex, bssindex, mloffindex; +#endif struct module *mod;long err =0 ;void *percpu =NULL , *ptr =NULL ;/* Stops spurious gcc warning */
@@ -1510,6 +1513,11 @@ #ifdef CONFIG_KALLSYMS sechdrs[symindex].sh_flags |=SHF_ALLOC ; sechdrs[strindex].sh_flags |=SHF_ALLOC ;#endif +#ifdef CONFIG_DEBUG_MEMLEAK + dataindex =find_sec (hdr, sechdrs, secstrings,".data" ); + bssindex =find_sec (hdr, sechdrs, secstrings,".bss" ); + mloffindex =find_sec (hdr, sechdrs, secstrings,".init.memleak_offsets" ); +#endif /* Check module struct version now, before we try to use module. */ if (!check_modstruct_version (sechdrs, versindex, mod)) {
@@ -1569,6 +1577,7 @@ #endif/* Do the allocs. */ ptr =module_alloc (mod->core_size); +memleak_debug_not_leak (ptr);if (!ptr) { err = -ENOMEM ; goto free_percpu;
@@ -1577,6 +1586,7 @@ #endif mod->module_core = ptr; ptr =module_alloc (mod->init_size); +memleak_debug_ignore (ptr);if (!ptr && mod->init_size) { err = -ENOMEM ; goto free_core;
@@ -1608,6 +1618,28 @@ #endif/* Module has been moved. */ mod = (void *)sechdrs[modindex].sh_addr; +#ifdef CONFIG_DEBUG_MEMLEAK +if (mloffindex) +memleak_debug_insert_aliases ((void *)sechdrs[mloffindex].sh_addr, + (void *)sechdrs[mloffindex].sh_addr + + sechdrs[mloffindex].sh_size); + +/* only scan the sections containing data */ +memleak_debug_scan_area (mod->module_core, + (unsigned long )mod - (unsigned long )mod->module_core, +sizeof (struct module )); +if (dataindex) +memleak_debug_scan_area (mod->module_core, + sechdrs[dataindex].sh_addr + - (unsigned long )mod->module_core, + sechdrs[dataindex].sh_size); +if (bssindex) +memleak_debug_scan_area (mod->module_core, + sechdrs[bssindex].sh_addr + - (unsigned long )mod->module_core, + sechdrs[bssindex].sh_size); +#endif +/* Now we've moved module, initialize linked lists, etc. */ module_unload_init (mod);
PATCH 5/8 Add kmemleak support for i386
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
This patch modifies the vmlinux.lds.S script and adds the backtrace support for i386 to be used with kmemleak.
---
arch/i386/kernel/vmlinux.lds.S | 4 ++++ include/asm-i386/processor.h | 12 ++++++++++++ 2 files changed, 16 insertions(+), 0 deletions(-)
arch/i386/kernel/vmlinux.lds.S +4 -0
@@ -38,6 +38,7 @@ SECTIONS RODATA /* writeable */ + _sdata = .; /* Start of data section */ .data : AT(ADDR(.data) - LOAD_OFFSET) { /* Data */ *(.data) CONSTRUCTORS
@@ -140,6 +141,9 @@ SECTIONS __per_cpu_start = .; .data.percpu : AT(ADDR(.data.percpu) - LOAD_OFFSET) { *(.data.percpu) } __per_cpu_end = .; + __memleak_offsets_start = .; + .init.memleak_offsets : AT(ADDR(.init.memleak_offsets) - LOAD_OFFSET) { *(.init.memleak_offsets) } + __memleak_offsets_end = .; . = ALIGN(4096); __init_end = .; /* freed after init ends here */
include/asm-i386/processor.h +12 -0
@@ -743,4 +743,16 @@ #else#define mcheck_init (c) do {} while(0)#endif +#ifdef CONFIG_FRAME_POINTER +static inline unsigned long arch_call_address (void *frame) +{ +return *(unsigned long *) (frame +4 ); +} + +static inline void *arch_prev_frame (void *frame) +{ +return *(void **) frame; +} +#endif +#endif /* __ASM_I386_PROCESSOR_H */
PATCH 6/8 Add kmemleak support for ARM
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
This patch modifies the vmlinux.lds.S script and adds the backtrace support for ARM to be used with kmemleak.
---
arch/arm/kernel/vmlinux.lds.S | 7 +++++++ include/asm-arm/processor.h | 12 ++++++++++++ 2 files changed, 19 insertions(+), 0 deletions(-)
arch/arm/kernel/vmlinux.lds.S +7 -0
@@ -68,6 +68,11 @@ #endif __per_cpu_start = .; *(.data.percpu) __per_cpu_end = .; +#ifdef CONFIG_DEBUG_MEMLEAK + __memleak_offsets_start = .; + *(.init.memleak_offsets) + __memleak_offsets_end = .; +#endif #ifndef CONFIG_XIP_KERNEL __init_begin = _stext; *(.init.data)
@@ -110,6 +115,7 @@ #endif .data : AT(__data_loc) { __data_start = .; /* address in memory */ + _sdata = .; /* * first, the init task union, aligned
@@ -158,6 +164,7 @@ #endif __bss_start = .; /* BSS */ *(.bss) *(COMMON) + __bss_stop = .; _end = .; } /* Stabs debugging sections. */
include/asm-arm/processor.h +12 -0
@@ -121,6 +121,18 @@ #define spin_lock_prefetch(x) do { } whi#endif +#ifdef CONFIG_FRAME_POINTER +static inline unsigned long arch_call_address (void *frame) +{ +return *(unsigned long *) (frame -4 ) -4 ; +} + +static inline void *arch_prev_frame (void *frame) +{ +return *(void **) (frame -12 ); +} +#endif +#endif #endif /* __ASM_ARM_PROCESSOR_H */
PATCH 7/8 Remove some of the kmemleak false positives
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
There are allocations for which the main pointer cannot be found but they are not memory leaks. This patch fixes some of them.
---
arch/i386/kernel/setup.c | 1 + ipc/util.c | 2 ++ kernel/params.c | 7 +++++-- mm/slab.c | 1 + 4 files changed, 9 insertions(+), 2 deletions(-)
arch/i386/kernel/setup.c +1 -0
@@ -1323,6 +1323,7 @@ legacy_init_iomem_resources(struct resouif (e820.map[i].addr + e820.map[i].size >0x100000000ULL )continue ; res =kzalloc (sizeof (struct resource ),GFP_ATOMIC ); +memleak_debug_not_leak (res);switch (e820.map[i].type) {case E820_RAM : res->name ="System RAM" ;break ;case E820_ACPI : res->name ="ACPI Tables" ;break ;
ipc/util.c +2 -0
@@ -389,6 +389,7 @@ void* ipc_rcu_alloc(int size)*/ if (rcu_use_vmalloc (size)) { out =vmalloc (HDRLEN_VMALLOC + size); +memleak_debug_not_leak (out);if (out) { out +=HDRLEN_VMALLOC ; container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
@@ -396,6 +397,7 @@ void* ipc_rcu_alloc(int size) } }else { out =kmalloc (HDRLEN_KMALLOC + size,GFP_KERNEL ); +memleak_debug_not_leak (out);if (out) { out +=HDRLEN_KMALLOC ; container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
kernel/params.c +5 -2
@@ -548,6 +548,7 @@ static void __init kernel_param_sysfs_se unsigned int name_skip) {struct module_kobject *mk; +struct module_param_attrs *mp; mk =kzalloc (sizeof (struct module_kobject ),GFP_KERNEL );BUG_ON (!mk);
@@ -557,11 +558,13 @@ static void __init kernel_param_sysfs_sekobject_set_name (&mk->kobj, name);kobject_register (&mk->kobj); + mp =param_sysfs_setup (mk, kparam, num_params, name_skip);/* no need to keep the kobject if no parameter is exported */ -if (!param_sysfs_setup (mk, kparam, num_params, name_skip)) { +if (!mp) {kobject_unregister (&mk->kobj);kfree (mk); - } + }else +memleak_debug_not_leak (mp); }/*
mm/slab.c +1 -0
@@ -3358,6 +3358,7 @@ void *__alloc_percpu(size_t size)memset (pdata->ptrs[i],0 , size); } +memleak_debug_not_leak (pdata);/* Catch derefs w/o wrappers */ return (void *)(~(unsigned long )pdata);
Re: [PATCH 2.6.17-rc5 7/8] Remove some of the kmemleak false positives
Hi!
arch/i386/kernel/setup.c legacy_init_iomem_resources(struct resou · line 1326
Quoted 10 lines
From: Catalin Marinas <[email protected]>
There are allocations for which the main pointer cannot be found but they are not memory leaks. This patch fixes some of them.
arch/i386/kernel/setup.c +1
-0@@ -1323,6 +1323,7 @@ legacy_init_iomem_resources(struct resouif (e820.map[i].addr + e820.map[i].size >0x100000000ULL )continue ; res =kzalloc (sizeof (struct resource ),GFP_ATOMIC ); +memleak_debug_not_leak (res);
I'd suggest some shorter/more generic name.
not_freed(res); ? alloc_forever(res); ?
Signature · 1 line
Thanks for all the (sleeping) penguins.
Re: [PATCH 2.6.17-rc5 7/8] Remove some of the kmemleak false positives
Quoted 8 lines · Pavel Machek
arch/i386/kernel/setup.c legacy_init_iomem_resources(struct resou · line 1326
Quoted 2 lines
From: Catalin Marinas <[email protected]>
arch/i386/kernel/setup.c +1
-0+memleak_debug_not_leak (res);I'd suggest some shorter/more generic name.
not_freed(res); ? alloc_forever(res); ?
It's true that the names are a bit long ("debug" is even superfluous). I would, however, keep the memleak_ prefix as I think it makes the code clearer (i.e. the function belongs to a certain part of the kernel).
Catalin
Re: [PATCH 2.6.17-rc5 7/8] Remove some of the kmemleak false positives
Hi!
Quoted 5 lines
Quoted 5 lines
arch/i386/kernel/setup.c legacy_init_iomem_resources(struct resou · line 1326
Quoted 2 lines
From: Catalin Marinas <[email protected]>
arch/i386/kernel/setup.c +1
-0+memleak_debug_not_leak (res);I'd suggest some shorter/more generic name.
Quoted 7 lines
Quoted 3 lines
not_freed(res); ? alloc_forever(res); ?It's true that the names are a bit long ("debug" is even superfluous). I would, however, keep the
memleak_prefix as I think it makes the code clearer (i.e. the function belongs to a certain part of the kernel).
Well, in future some other leak detector may want to use these hooks.
Anyway memleak_not_leak() is already quite good.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
PATCH 8/8 Simple testing for kmemleak
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
This patch only contains some very simple testing at the moment. Proper testing will be needed.
---
lib/Kconfig.debug | 9 ++++++ mm/Makefile | 1 + mm/memleak-test.c | 83 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 93 insertions(+), 0 deletions(-)
lib/Kconfig.debug +9 -0
@@ -132,6 +132,15 @@ config DEBUG_MEMLEAK_SECONDARY_ALIASES false negatives but it can slightly increase the number of false positives. +config DEBUG_MEMLEAK_TEST + tristate "Test the kernel memory leak detector" + default n + depends on DEBUG_MEMLEAK + help + Say Y here to build the test harness for the kernel memory + leak detector. At the moment, this option enables a module + that explicitly leaks memory. + config DEBUG_PREEMPT bool "Debug preemptible kernel" depends on DEBUG_KERNEL && PREEMPT
mm/Makefile +1 -0
@@ -24,3 +24,4 @@ obj-$(CONFIG_MEMORY_HOTPLUG) += memory_h obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_DEBUG_MEMLEAK) += memleak.o +obj-$(CONFIG_DEBUG_MEMLEAK_TEST) += memleak-test.o
mm/memleak-test.c new file +83 -0
83 lines not on this page · raw message