Kernel memory leak detector 0.11
Subsystems (17)
cover Kernel memory leak detector 0.11
This is a new version (0.11) of the kernel memory leak detector. See the Documentation/kmemleak.txt file for a more detailed description. The patches are downloadable from (the whole patch or the broken-out series):
http://homepage.ntlworld.com/cmarinas/kmemleak/patch-2.6.19-rc1-kmemleak-0.11.bz2
http://homepage.ntlworld.com/cmarinas/kmemleak/broken-out/patches-kmemleak-0.11.tar.bz2
What's new in this version:
- updated to Linux 2.6.19-rc1
- kmemleak now uses the common API for getting stack traces, making it easier to support other architectures
- fixed bug in calculating the page order for the hash allocation
To do:
- testing on a wider range of platforms and configurations
- support for ioremap tracking
- eliminate the task stacks scanning (if possible, by marking the allocated blocks as temporary until the return to user-space - Ingo's suggestion)
- precise type identification (after first assessing the efficiency of the current method as it requires changes to the kernel API)
Signature · 1 line
Catalin
PATCH 1/10 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 | 111 ++++ init/main.c | 3 lib/Kconfig.debug | 96 +++ mm/Makefile | 1 mm/memleak.c | 1470 +++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 1686 insertions(+), 2 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>
@@ -296,9 +297,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 +111 -0
111 lines not on this page · raw message
init/main.c +2 -1
@@ -570,6 +570,8 @@ #endifcpuset_init_early ();mem_init ();kmem_cache_init (); +radix_tree_init (); +memleak_init ();setup_per_cpu_pageset ();numa_policy_init ();if (late_time_init)
@@ -590,7 +592,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 +96 -0
102 lines not on this page · raw message
mm/Makefile +1 -0
@@ -28,3 +28,4 @@ obj-$(CONFIG_MEMORY_HOTPLUG) += memory_h obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_SMP) += allocpercpu.o +obj-$(CONFIG_DEBUG_MEMLEAK) += memleak.o
mm/memleak.c new file +1470 -0
1,470 lines not on this page · raw message
PATCH 2/10 Some documentation for kmemleak
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
---
Documentation/kmemleak.txt | 157 ++++++++++++++++++++++++++++++++++++++++++++ 1 files changed, 157 insertions(+), 0 deletions(-)
Documentation/kmemleak.txt new file +157 -0
@@ -0,0 +1,157 @@ +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. + + +Usage +----- + +CONFIG_DEBUG_MEMLEAK has to be enabled. For additional config options, +look in: + + -> Kernel hacking + -> Kernel debugging + -> Debug slab memory allocations + -> Kernel memory leak detector + +To display the possible memory leaks: + + # mount -t debugfs nodev /sys/kernel/debug/ + # cat /sys/kernel/debug/memleak + +In order to reduce the run-time overhead, memory scanning is only +performed when reading the /sys/kernel/debug/memleak file. + + +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 hash table. The +corresponding freeing function calls are tracked and the pointers +removed from the hash table. + +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 hash + table. 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 type information is stored in the +.init.memleak_offsets section. The memleak_init() function creates a +radix tree with corresponding offsets for every encountered block +type. The memory allocations hook stores the pointer address together +with its aliases based on the type of the allocated block. + +While one level of offsets should be enough for most cases, a second +level, i.e. container_of(container_of(...)), can be enabled via the +configuration options (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. + +Kmemleak currently approximates the type id using the sizeof() +compiler built-in function. This is not accurate and can lead to false +negatives. The aim is to gradually change the kernel and kmemleak to +do more precise type identification. + +Another source of false negatives is the data stored in non-pointer +values. Together with the more precise type identification, kmemleak +could only scan the pointer members in the allocated structures. + +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. + +Page allocations and ioremap are not tracked. Only the ARM and i386 +architectures are currently supported. + + +Kmemleak API +------------ + +See the include/linux/memleak.h header for the functions prototype. + +memleak_init - initialize kmemleak +memleak_alloc - notify of a memory block allocation +memleak_free - notify of a memory block freeing +memleak_padding - mark the boundaries of the data inside the block +memleak_not_leak - mark a pointer as not a leak +memleak_ignore - do not scan or report a pointer as leak +memleak_scan_area - add scan areas inside a memory block +memleak_insert_aliases - add aliases for a given type +memleak_erase - erase an old value in a pointer variable +memleak_typeid_raw - set the typeid for an allocated block +memleak_container - statically declare a pointer alias +memleak_typeid - set the typeid for an allocated block (takes + a type rather than typeid as argument) + + +Dealing with false positives/negatives +-------------------------------------- + +To reduce the false negatives, kmemleak provides the memleak_ignore, +memleak_scan_area and memleak_erase functions. The task stacks also +increase the amount of false negatives and their scanning is not +enabled by default. + +To eliminate the false positives caused by code allocating a different +size from the object one (either for alignment or for extra memory +after the end of the structure), kmemleak provides the memleak_padding +and memleak_typeid functions. + +For pointers known not to be leaks, kmemleak provides the +memleak_not_leak function. The memleak_ignore could also be used if +the memory block is known not to contain other pointers as it will no +longer be scanned.
PATCH 3/10 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/kfree, kmem_cache_(alloc|free), vmalloc/vfree etc.
---
include/linux/slab.h | 6 ++++++ mm/page_alloc.c | 2 ++ mm/slab.c | 19 +++++++++++++++++-- mm/vmalloc.c | 22 ++++++++++++++++++++-- 4 files changed, 45 insertions(+), 4 deletions(-)
include/linux/slab.h +6 -0
@@ -125,6 +125,8 @@ extern void *__kmalloc(size_t, gfp_t);*/ static inline void *kmalloc (size_t size,gfp_t flags) { +#ifndef CONFIG_DEBUG_MEMLEAK +/* this block removes the size information needed by kmemleak */ if (__builtin_constant_p (size)) {int i =0 ;#define CACHE (x) \
@@ -143,6 +145,7 @@ found: malloc_sizes[i].cs_dmacachep : malloc_sizes[i].cs_cachep, flags); } +#endif return __kmalloc (size, flags); }
@@ -172,6 +175,8 @@ extern void *__kzalloc(size_t, gfp_t);*/ static inline void *kzalloc (size_t size,gfp_t flags) { +#ifndef CONFIG_DEBUG_MEMLEAK +/* this block removes the size information needed by kmemleak */ if (__builtin_constant_p (size)) {int i =0 ;#define CACHE (x) \
@@ -190,6 +195,7 @@ found: malloc_sizes[i].cs_dmacachep : malloc_sizes[i].cs_cachep, flags); } +#endif return __kzalloc (size, flags); }
mm/page_alloc.c +2 -0
@@ -3121,6 +3121,8 @@ void *__init alloc_large_system_hash(conif (_hash_mask) *_hash_mask = (1 << log2qty) -1 ; +memleak_alloc (table, size,1 ); +return table; }
mm/slab.c +17 -2
@@ -2545,6 +2545,9 @@ static struct slab *alloc_slabmgmt(struc/* Slab management obj is off-slab. */ slabp =kmem_cache_alloc_node (cachep->slabp_cache, local_flags, nodeid); +/* only scan the list member to avoid false negatives */ +memleak_scan_area (slabp, offsetof(struct slab , list), +sizeof (struct list_head ));if (!slabp)return NULL ; }else {
@@ -3077,6 +3080,8 @@ static inline void *____cache_alloc(struSTATS_INC_ALLOCMISS (cachep); objp =cache_alloc_refill (cachep, flags); } +/* avoid false negatives */ +memleak_erase (&ac->entry[ac->avail]);return objp; }
@@ -3105,6 +3110,7 @@ static __always_inline void *__cache_alllocal_irq_restore (save_flags); objp =cache_alloc_debugcheck_after (cachep, flags, objp, caller); +memleak_alloc (objp,obj_size (cachep),1 );prefetchw (objp);return objp; }
@@ -3328,6 +3334,7 @@ static inline void __cache_free(struct kstruct array_cache *ac =cpu_cache_get (cachep);check_irq_off (); +memleak_free (objp); objp =cache_free_debugcheck (cachep, objp,__builtin_return_address (0 ));if (cache_free_alien (cachep, objp))
@@ -3447,6 +3454,7 @@ void *kmem_cache_alloc_node(struct kmem_ ptr =cache_alloc_debugcheck_after (cachep, flags, ptr,__builtin_return_address (0 )); +memleak_alloc (ptr,obj_size (cachep),1 );return ptr; }
@@ -3455,11 +3463,14 @@ EXPORT_SYMBOL(kmem_cache_alloc_node);void *__kmalloc_node (size_t size,gfp_t flags,int node) {struct kmem_cache *cachep; +void *ptr; cachep =kmem_find_general_cachep (size, flags);if (unlikely (cachep ==NULL ))return NULL ; -return kmem_cache_alloc_node (cachep, flags, node); + ptr =kmem_cache_alloc_node (cachep, flags, node); +memleak_padding (ptr,0 , size); +return ptr; }EXPORT_SYMBOL (__kmalloc_node);#endif
@@ -3474,6 +3485,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_.
@@ -3483,7 +3495,10 @@ 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_padding (ptr,0 , size); + +return ptr; }
mm/vmalloc.c +20 -2
@@ -364,6 +364,9 @@ void __vunmap(void *addr, int deallocatevoid vfree (void *addr) {BUG_ON (in_interrupt ()); + +memleak_free (addr); +__vunmap (addr,1 ); }EXPORT_SYMBOL (vfree);
@@ -461,7 +464,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_alloc (addr, area->size -PAGE_SIZE ,2 ); + +return addr; }/**
@@ -479,6 +489,8 @@ static void *__vmalloc_node(unsigned lon int node) {struct vm_struct *area; +void *addr; +unsigned long real_size = size; size =PAGE_ALIGN (size);if (!size || (size >>PAGE_SHIFT ) > num_physpages)
@@ -488,7 +500,13 @@ static void *__vmalloc_node(unsigned lonif (!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_alloc (addr, real_size,2 ); + +return addr; }void *__vmalloc (unsigned long size,gfp_t gfp_mask,pgprot_t prot)
PATCH 4/10 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 | 41 +++++++++++++++++++++++++++++++++++++++++ 1 files changed, 41 insertions(+), 0 deletions(-)
kernel/module.c +41 -0
@@ -1503,6 +1503,11 @@ static struct module *load_module(void _unsigned int unusedcrcindex;unsigned int unusedgplindex;unsigned int unusedgplcrcindex; +#ifdef CONFIG_DEBUG_MEMLEAK +unsigned int dataindex; +unsigned int bssindex; +unsigned int mloffindex; +#endif struct module *mod;long err =0 ;void *percpu =NULL , *ptr =NULL ;/* Stops spurious gcc warning */
@@ -1599,6 +1604,11 @@ #endif#ifdef ARCH_UNWIND_SECTION_NAME unwindex =find_sec (hdr, sechdrs, secstrings,ARCH_UNWIND_SECTION_NAME );#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 /* Don't keep modinfo section */ sechdrs[infoindex].sh_flags &= ~(unsigned long )SHF_ALLOC ;
@@ -1669,6 +1679,10 @@ #endif/* Do the allocs. */ ptr =module_alloc (mod->core_size); +/* the pointer to this block is stored in the module structure +* which is inside the block. Just mark it as not being a +* leak */ +memleak_not_leak (ptr);if (!ptr) { err = -ENOMEM ; goto free_percpu;
@@ -1677,6 +1691,11 @@ #endif mod->module_core = ptr; ptr =module_alloc (mod->init_size); +/* the pointer to this block is stored in the module structure +* which is inside the block. This block doesn't need to be +* scanned as it contains data and code that will be freed +* after the module is initialized */ +memleak_ignore (ptr);if (!ptr && mod->init_size) { err = -ENOMEM ; goto free_core;
@@ -1708,6 +1727,28 @@ #endif/* Module has been moved. */ mod = (void *)sechdrs[modindex].sh_addr; +#ifdef CONFIG_DEBUG_MEMLEAK +if (mloffindex) +memleak_insert_aliases ((void *)sechdrs[mloffindex].sh_addr, + (void *)sechdrs[mloffindex].sh_addr + + sechdrs[mloffindex].sh_size); + +/* only scan the sections containing data */ +memleak_scan_area (mod->module_core, + (unsigned long )mod - (unsigned long )mod->module_core, +sizeof (struct module )); +if (dataindex) +memleak_scan_area (mod->module_core, + sechdrs[dataindex].sh_addr + - (unsigned long )mod->module_core, + sechdrs[dataindex].sh_size); +if (bssindex) +memleak_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/10 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/thread_info.h | 10 +++++++++- 2 files changed, 13 insertions(+), 1 deletions(-)
arch/i386/kernel/vmlinux.lds.S +4 -0
@@ -51,6 +51,7 @@ SECTIONS __tracedata_end = .; /* writeable */ + _sdata = .; /* Start of data section */ .data : AT(ADDR(.data) - LOAD_OFFSET) { /* Data */ *(.data) CONSTRUCTORS
@@ -162,6 +163,9 @@ #endif __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/thread_info.h +9 -1
@@ -100,12 +100,20 @@ #define alloc_thread_info(tsk) \struct thread_info *ret; \ \ ret =kmalloc (THREAD_SIZE ,GFP_KERNEL ); \ +memleak_ignore (ret); \if (ret) \memset (ret,0 ,THREAD_SIZE ); \ ret; \ })#else -#define alloc_thread_info (tsk) kmalloc(THREAD_SIZE, GFP_KERNEL) +#define alloc_thread_info (tsk) \ + ({ \ + struct thread_info *ret; \ + \ + ret = kmalloc(THREAD_SIZE, GFP_KERNEL); \ + memleak_ignore(ret); \ + ret; \ + })#endif #define free_thread_info (info) kfree(info)
PATCH 6/10 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 +++++++ 1 files changed, 7 insertions(+), 0 deletions(-)
arch/arm/kernel/vmlinux.lds.S +7 -0
@@ -67,6 +67,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)
@@ -115,6 +120,7 @@ #endif .data : AT(__data_loc) { __data_start = .; /* address in memory */ + _sdata = .; /* * first, the init task union, aligned
@@ -165,6 +171,7 @@ #endif __bss_start = .; /* BSS */ *(.bss) *(COMMON) + __bss_stop = .; _end = .; } /* Stabs debugging sections. */
PATCH 7/10 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.
---
drivers/base/platform.c | 3 +++ drivers/char/vt.c | 4 ++++ drivers/hwmon/w83627hf.c | 4 ++++ drivers/scsi/hosts.c | 3 +++ drivers/video/console/fbcon.c | 3 +++ fs/ext3/dir.c | 3 +++ include/linux/percpu.h | 5 +++++ ipc/util.c | 6 ++++++ kernel/params.c | 8 +++++++- net/core/dev.c | 6 ++++++ net/core/skbuff.c | 3 +++ net/ipv4/netfilter/ip_conntrack_core.c | 5 +++++ net/sched/sch_generic.c | 5 +++++ 13 files changed, 57 insertions(+), 1 deletions(-)
drivers/base/platform.c +3 -0
@@ -166,6 +166,9 @@ struct platform_device *platform_device_struct platform_object *pa; pa =kzalloc (sizeof (struct platform_object ) +strlen (name),GFP_KERNEL ); +/* kmemleak cannot guess the object type because the block +* size is different from the object size */ + memleak_typeid(pa, struct platform_object);if (pa) {strcpy (pa->name, name); pa->pdev.name = pa->name;
drivers/char/vt.c +4 -0
@@ -2640,6 +2640,10 @@ static int __init con_init(void)*/ for (currcons =0 ; currcons <MIN_NR_CONSOLES ; currcons++) { vc_cons[currcons].d = vc =alloc_bootmem (sizeof (struct vc_data )); +/* kmemleak does not track the memory allocated via +* alloc_bootmem() but this block contains pointers to +* other blocks allocated via kmalloc */ +memleak_alloc (vc,sizeof (struct vc_data ),1 );visual_init (vc, currcons,1 ); vc->vc_screenbuf = (unsigned short *)alloc_bootmem (vc->vc_screenbuf_size); vc->vc_kmalloced =0 ;
drivers/hwmon/w83627hf.c +4 -0
@@ -1097,6 +1097,10 @@ static int w83627hf_detect(struct i2c_ad err = -ENOMEM ; goto ERROR1; } +/* the pointer to member is stored but the code doesn't use +* container_of for access and the alias need to be +* explicitely declared here */ + memleak_container(struct w83627hf_data, client); new_client = &data->client;i2c_set_clientdata (new_client, data);
drivers/scsi/hosts.c +3 -0
@@ -300,6 +300,9 @@ struct Scsi_Host *scsi_host_alloc(struct shost =kzalloc (sizeof (struct Scsi_Host ) + privsize, gfp_mask);if (!shost)return NULL ; +/* kmemleak cannot guess the object type because the block +* size is different from the object size */ + memleak_typeid(shost, struct Scsi_Host);spin_lock_init (&shost->default_lock);scsi_assign_lock (shost, &shost->default_lock);
drivers/video/console/fbcon.c +3 -0
@@ -2485,6 +2485,9 @@ static int fbcon_set_font(struct vc_data size = h * pitch * charcount; new_data =kmalloc (FONT_EXTRA_WORDS *sizeof (int ) + size,GFP_USER ); +/* the stored pointer is different from the address of the +* allocated block because of padding */ +memleak_padding (new_data,FONT_EXTRA_WORDS *sizeof (int ), size);if (!new_data)return -ENOMEM ;
fs/ext3/dir.c +3 -0
@@ -349,6 +349,9 @@ int ext3_htree_store_dirent(struct file new_fn =kzalloc (len,GFP_KERNEL );if (!new_fn)return -ENOMEM ; +/* kmemleak cannot guess the object type because the block +* size is different from the object size */ + memleak_typeid(new_fn, struct fname); new_fn->hash = hash; new_fn->minor_hash = minor_hash; new_fn->inode =le32_to_cpu (dirent->inode);
include/linux/percpu.h +5 -0
@@ -30,7 +30,12 @@ struct percpu_data {void *ptrs[NR_CPUS ]; }; +/* pointer disguising messes up the kmemleak objects tracking */ +#ifndef CONFIG_DEBUG_MEMLEAK #define __percpu_disguise (pdata) (struct percpu_data *)~(unsigned long)(pdata) +#else +#define __percpu_disguise (pdata) (struct percpu_data *)(pdata) +#endif /* * Use this to get to a cpu's version of the per-cpu object dynamically * allocated. Non-atomic access to the current CPU's version should
ipc/util.c +6 -0
@@ -492,6 +492,9 @@ void* ipc_rcu_alloc(int size)*/ if (rcu_use_vmalloc (size)) { out =vmalloc (HDRLEN_VMALLOC + size); +/* the stored pointer is different from the address of +* the allocated block because of padding */ +memleak_padding (out,HDRLEN_VMALLOC , size);if (out) { out +=HDRLEN_VMALLOC ; container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 1;
@@ -499,6 +502,9 @@ void* ipc_rcu_alloc(int size) } }else { out =kmalloc (HDRLEN_KMALLOC + size,GFP_KERNEL ); +/* the stored pointer is different from the address of +* the allocated block because of padding */ +memleak_padding (out,HDRLEN_KMALLOC , size);if (out) { out +=HDRLEN_KMALLOC ; container_of(out, struct ipc_rcu_hdr, data)->is_vmalloc = 0;
kernel/params.c +7 -1
@@ -548,6 +548,7 @@ static void __init kernel_param_sysfs_se {struct module_kobject *mk;int ret; +struct module_param_attrs *mp; mk =kzalloc (sizeof (struct module_kobject ),GFP_KERNEL );BUG_ON (!mk);
@@ -558,8 +559,13 @@ static void __init kernel_param_sysfs_se ret =kobject_register (&mk->kobj);BUG_ON (ret <0 ); + mp =param_sysfs_setup (mk, kparam, num_params, name_skip); +/* this structure is not freed but the pointer is +* lost. However, there are other pointers to its members and +* the object has to be kept */ +memleak_not_leak (mp);/* 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); }
net/core/dev.c +6 -0
@@ -3210,6 +3210,12 @@ struct net_device *alloc_netdev(int size dev = (struct net_device *) (((long )p +NETDEV_ALIGN_CONST ) & ~NETDEV_ALIGN_CONST ); dev->padded = (char *)dev - (char *)p; +/* kmemleak cannot guess the object type because the block +* size is different from the object size. The stored pointer +* is also different from the address of the allocated block +* because of padding */ +memleak_padding (p, dev->padded, alloc_size - dev->padded); + memleak_typeid(p, struct net_device);if (sizeof_priv) dev->priv =netdev_priv (dev);
net/core/skbuff.c +3 -0
@@ -151,6 +151,9 @@ struct sk_buff *__alloc_skb(unsigned int/* Get the HEAD */ skb =kmem_cache_alloc (cache, gfp_mask & ~__GFP_DMA); +/* the skbuff_fclone_cache contains objects larger than +* "struct sk_buff" and kmemleak cannot guess the type */ + memleak_typeid(skb, struct sk_buff);if (!skb) goto out;
net/ipv4/netfilter/ip_conntrack_core.c +5 -0
@@ -645,6 +645,11 @@ struct ip_conntrack *ip_conntrack_alloc( } conntrack =kmem_cache_alloc (ip_conntrack_cachep,GFP_ATOMIC ); +/* tuplehash_to_ctrack doesn't pass a constant argument to +* container_of and therefore the conntrack->tuplehash[].list +* aliases are ignored */ + memleak_container(struct ip_conntrack, tuplehash[IP_CT_DIR_ORIGINAL]); + memleak_container(struct ip_conntrack, tuplehash[IP_CT_DIR_REPLY]);if (!conntrack) {DEBUGP ("Can't allocate conntrack.\n" );atomic_dec (&ip_conntrack_count);
net/sched/sch_generic.c +5 -0
@@ -434,6 +434,11 @@ struct Qdisc *qdisc_alloc(struct net_dev goto errout; sch = (struct Qdisc *)QDISC_ALIGN ((unsigned long ) p); sch->padded = (char *) sch - (char *) p; +/* kmemleak cannot guess the object type because the block +* size is different from the object size. The stored pointer +* is also different from the address of the allocated block +* because of padding */ +memleak_padding (p, sch->padded,sizeof (struct Qdisc ));INIT_LIST_HEAD (&sch->list);skb_queue_head_init (&sch->q);
PATCH 8/10 Keep the __init functions after initialization
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
This patch adds the CONFIG_DEBUG_KEEP_INIT option which preserves the .init.text section after initialization. Memory leaks happening during this phase can be more easily tracked.
---
include/linux/init.h | 5 +++++ lib/Kconfig.debug | 12 ++++++++++++ 2 files changed, 17 insertions(+), 0 deletions(-)
include/linux/init.h +5 -0
@@ -40,8 +40,13 @@ #include <linux/compiler.h>/* These are for everybody (although not all archs will actually discard it in modules) */ +#ifdef CONFIG_DEBUG_KEEP_INIT +#define __init +#define __initdata +#else #define __init __attribute__ ((__section__ (".init.text")))#define __initdata __attribute__ ((__section__ (".init.data"))) +#endif #define __exitdata __attribute__ ((__section__(".exit.data")))#define __exit_call __attribute_used__ __attribute__ ((__section__ (".exitcall.exit")))
lib/Kconfig.debug +12 -0
@@ -208,6 +208,18 @@ config DEBUG_MEMLEAK_REPORTS_NR reading the /sys/kernel/debug/memleak file could lead to some soft-locks. +config DEBUG_KEEP_INIT + bool "Do not free the __init code/data" + default n + depends on DEBUG_MEMLEAK + help + This option moves the __init code/data out of the + .init.text/.init.data sections. It is useful for identifying + memory leaks happening during the kernel or modules + initialization. + + If unsure, say N. + config DEBUG_PREEMPT bool "Debug preemptible kernel" depends on DEBUG_KERNEL && PREEMPT && TRACE_IRQFLAGS_SUPPORT
PATCH 9/10 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 | 11 +++++++ mm/Makefile | 1 + mm/memleak-test.c | 89 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 101 insertions(+), 0 deletions(-)
lib/Kconfig.debug +11 -0
@@ -220,6 +220,17 @@ config DEBUG_KEEP_INIT If unsure, say N. +config DEBUG_MEMLEAK_TEST + tristate "Test the kernel memory leak detector" + default n + depends on DEBUG_MEMLEAK + help + Say Y or M here to build the test harness for the kernel + memory leak detector. At the moment, this option enables a + module that explicitly leaks memory. + + If unsure, say N. + config DEBUG_PREEMPT bool "Debug preemptible kernel" depends on DEBUG_KERNEL && PREEMPT && TRACE_IRQFLAGS_SUPPORT
mm/Makefile +1 -0
@@ -29,3 +29,4 @@ obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o obj-$(CONFIG_SMP) += allocpercpu.o obj-$(CONFIG_DEBUG_MEMLEAK) += memleak.o +obj-$(CONFIG_DEBUG_MEMLEAK_TEST) += memleak-test.o
mm/memleak-test.c new file +89 -0
89 lines not on this page · raw message
PATCH 10/10 Update the MAINTAINERS file for kmemleak
In reply to Catalin MarinasFrom: Catalin Marinas <[email protected]>
---
MAINTAINERS | 6 ++++++ 1 files changed, 6 insertions(+), 0 deletions(-)
MAINTAINERS +6 -0
@@ -1708,6 +1708,12 @@ L: [email protected] W: http://www.kerneljanitors.org/ S: Maintained +KERNEL MEMORY LEAK DETECTOR +P: Catalin Marinas +M: [email protected] +W: http://www.procode.org/ +S: Maintained + KERNEL NFSD P: Neil Brown M: [email protected]
Hi Catalin,
Quoted 7 lines · Catalin Marinas
This is a new version (0.11) of the kernel memory leak detector. See the
Documentation/kmemleak.txtfile for a more detailed description. The patches are downloadable from (the whole patch or the broken-out series):http://homepage.ntlworld.com/cmarinas/kmemleak/patch-2.6.19-rc1-kmemleak-0.11.bz2
http://homepage.ntlworld.com/cmarinas/kmemleak/broken-out/patches-kmemleak-0.11.tar.bz2
I have a new false positives :)
http://www.stardust.webpages.pl/files/o_bugs/kmemleak-0.11/ml.txt
Quoted 2 lines
--
Catalin
Regards,
Michal
Signature · 3 lines
Michal K. K. Piotrowski LTG - Linux Testers Group (http://www.stardust.webpages.pl/ltg/)
Quoted 8 lines · Michal Piotrowski
Hi Catalin,
Quoted 5 lines · Catalin Marinas
This is a new version (0.11) of the kernel memory leak detector. See the
Documentation/kmemleak.txtfile for a more detailed description. The patches are downloadable from (the whole patch or the broken-out series):
Quoted 5 lines
Quoted 2 lines
http://homepage.ntlworld.com/cmarinas/kmemleak/patch-2.6.19-rc1-kmemleak-0.11.bz2
http://homepage.ntlworld.com/cmarinas/kmemleak/broken-out/patches-kmemleak-0.11.tar.bz2I have a new false positives :)
http://www.stardust.webpages.pl/files/o_bugs/kmemleak-0.11/ml.txt
KML vs. Autotest
http://www.stardust.webpages.pl/files/o_bugs/kmemleak-0.11/kml-vs-autotest.tar.bz2
Quoted 3 lines
Quoted 3 lines
--
Catalin
Regards,
Michal
Signature · 3 lines
Michal K. K. Piotrowski LTG - Linux Testers Group (http://www.stardust.webpages.pl/ltg/)
Hi Michal,
Quoted 2 lines · Michal Piotrowski
I have a new false positives :)
http://www.stardust.webpages.pl/files/o_bugs/kmemleak-0.11/ml.txt
I eventually found some time to look at these reports. See below for comments (I removed the duplicates):
unreferenced object 0xdff2213c (size 398):
[<c0166bc1>] memleak_alloc
[<c0164d15>] __kmalloc_track_caller
[<c01548c1>] __kzalloc
[<c024361b>] platform_device_alloc
[<c03e9076>] add_pcspkr
[<c03e48bd>] do_initcalls
[<c03e496a>] do_basic_setup
[<c0100421>] init
[<c01039ab>] kernel_thread_helper
[<ffffffff>]
Kmemleak is probably right in that this code will never be able to free the platform device (the pointer was only stored on the stack). However, this won't be needed and I'll mark it as not being a leak.
unreferenced object 0xf4f4eb68 (size 8):
[<c0166bc1>] memleak_alloc
[<c0164d15>] __kmalloc_track_caller
[<c01548c1>] __kzalloc
[<c0166479>] __percpu_alloc_mask
[<fd954a1b>] snmp6_mib_init
[<fd926017>] ip6t_hook
[<fd9260f2>] __param_forward
[<c013b5ad>] sys_init_module
[<c0102dd5>] sysenter_past_esp
[<ffffffff>]
This might be a real leak since the previous kmemleak versions were ignoring all the percpu allocations. I'm a bit confused about the calling chain between ip6t_hook and snmp6_mib_init. Maybe the network people could shed some light on this.
unreferenced object 0xf4a17304 (size 1412):
[<c0166bc1>] memleak_alloc
[<c0164c2d>] __kmalloc
[<fd95c587>] addrconf_sysctl_register
[<fd926337>] __param_forward
[<fd92619e>] __param_forward
[<c013b5ad>] sys_init_module
[<c0102dd5>] sysenter_past_esp
[<ffffffff>]
unreferenced object 0xf48f75bc (size 8):
[<c0166bc1>] memleak_alloc
[<c0164d15>] __kmalloc_track_caller
[<c0154915>] kstrdup
[<fd95c5fa>] addrconf_sysctl_register
[<fd926337>] __param_forward
[<fd92619e>] __param_forward
[<c013b5ad>] sys_init_module
[<c0102dd5>] sysenter_past_esp
[<ffffffff>]
I have the same problem with the stack trace here - can't find __param_forward in the code and it also looks strange to have a recursive call into this function.
I suspect you use the skge.c Ethernet driver. Is it possible to link this into the kernel (not as a module) and maybe together with the networking stuff? It might show a clearer stack trace.
unreferenced object 0xf44869e4 (size 160):
[<c0166bc1>] memleak_alloc
[<c0164a30>] kmem_cache_alloc
[<c02a91a0>] __alloc_skb
[<f9882439>] FillRxDescriptor
[<f9882408>] FillRxRing
[<f9881bdf>] SkGeOpen
[<c02adcda>] dev_open
[<c02af332>] dev_change_flags
[<c02e27dd>] devinet_ioctl
[<c02e4372>] inet_ioctl
[<c02a5844>] sock_ioctl
[<ffffffff>]
unreferenced object 0xf45101ec (size 1828):
[<c0166bc1>] memleak_alloc
[<c0164d15>] __kmalloc_track_caller
[<c02a91cb>] __alloc_skb
[<f9882439>] FillRxDescriptor
[<f9882408>] FillRxRing
[<f9881bdf>] SkGeOpen
[<c02adcda>] dev_open
[<c02af332>] dev_change_flags
[<c02e27dd>] devinet_ioctl
[<c02e4372>] inet_ioctl
[<c02a5844>] sock_ioctl
[<ffffffff>]
The above is probably not a leak but it looks more like badly written code. It looks like the pointers to the sk_buff structures are stored in memory allocated by pci_alloc_consistent. Kmemleak doesn't scan this area as it is usually meant for DMA'ing data and not for holding pointers kernel structures. I can mark it as not a leak.
Thanks.
Signature · 1 line
Catalin