Kernel memory leak detector 0.5
Subsystems (8)
cover Kernel memory leak detector 0.5
This is a new version (0.5) of the kernel memory leak detector. It is mainly a bug-fix release after testing it with a wider range of kernel modules. See the Documentation/kmemleak.txt file for a more detailed description. The patches are downloadable from (the bundled patch or the series):
http://homepage.ntlworld.com/cmarinas/kmemleak/patch-2.6.17-rc5-kmemleak-0.5.bz2
http://homepage.ntlworld.com/cmarinas/kmemleak/patches-kmemleak-0.5.tar.bz2
What's new in this version:
- fixed panic caused by some secondary offsets in modules
- removed the panic when not all aliases are found for freed pointers as the aliases list can be modified by modules insertion
- following Pavel's suggestion, shortened the function names by removing "_debug"
To do:
- more testing
- test Ingo's suggestion on task stacks scanning
- NUMA support
- (support for ioremap tracking)
Note that gcc4 cannot compile the kernels with this patch because of a bug with __builtin_constant_p (always returning true).
Any bug reports or suggestions are more than welcome as I can only test it with a limited number of kernel configurations.
Thanks.
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 | 1018 +++++++++++++++++++++++++++++++++++++++++++++++ 6 files changed, 1149 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_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 +1018 -0
1,018 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/kfree, 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_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_alloc (table, size,1 ); +return table; }
mm/slab.c +20 -2
@@ -2878,6 +2878,7 @@ #endifSTATS_INC_ALLOCMISS (cachep); objp =cache_alloc_refill (cachep, flags); } +memleak_erase (ac->entry[ac->avail]);return objp; }
@@ -3143,7 +3144,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_alloc (ptr, cachep->obj_size,1 ); + +return ptr; }EXPORT_SYMBOL (kmem_cache_alloc);
@@ -3158,6 +3163,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_alloc (ret, cache->obj_size,1 ); +if (ret)memset (ret,0 ,obj_size (cache));return ret;
@@ -3279,6 +3287,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_.
@@ -3288,7 +3297,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_alloc (ptr, size,1 ); + +return ptr; }
@@ -3372,6 +3385,9 @@ void kmem_cache_free(struct kmem_cache *unsigned long flags;local_irq_save (flags); + +memleak_free (objp); +__cache_free (cachep, objp);local_irq_restore (flags); }
@@ -3395,6 +3411,8 @@ void kfree(const void *objp)return ;local_irq_save (flags);kfree_debugcheck (objp); +memleak_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_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_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_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_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_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_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/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_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_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_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_not_leak (mp); }/*
mm/slab.c +1 -0
@@ -3357,6 +3357,7 @@ void *__alloc_percpu(size_t size)memset (pdata->ptrs[i],0 , size); } +memleak_not_leak (pdata);/* Catch derefs w/o wrappers */ return (void *)(~(unsigned long )pdata);
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
Quoted 9 lines · Catalin Marinas
This is a new version (0.5) of the kernel memory leak detector. It is mainly a bug-fix release after testing it with a wider range of kernel modules. See the
Documentation/kmemleak.txtfile for a more detailed description. The patches are downloadable from (the bundled patch or the series):http://homepage.ntlworld.com/cmarinas/kmemleak/patch-2.6.17-rc5-kmemleak-0.5.bz2
http://homepage.ntlworld.com/cmarinas/kmemleak/patches-kmemleak-0.5.tar.bz2
System hangs while starting udev.
Here is config
http://www.stardust.webpages.pl/files/kml/kml-config
Here is "Kernel Bug : The Movie 2" ;)
http://www.stardust.webpages.pl/files/crap/kbtm2.avi
$ gcc-3.4 --version gcc-3.4 (GCC) 3.4.6
Regards,
Michal
Signature · 3 lines
Michal K. K. Piotrowski LTG - Linux Testers Group (http://www.stardust.webpages.pl/ltg/wiki/)
Quoted 7 lines · Michal Piotrowski
System hangs while starting udev.
Here is config
http://www.stardust.webpages.pl/files/kml/kml-configHere is "Kernel Bug : The Movie 2" ;)
http://www.stardust.webpages.pl/files/crap/kbtm2.avi
Could you put some screenshots instead? I can't play this file (tried totem, realplayer, windows media player).
Thanks.
Signature · 1 line
Catalin
Quoted 11 lines · "Catalin Marinas" (on Tue, 6 Jun 2006 09:25:53 +0100) wrote:
Quoted 7 lines · Michal Piotrowski
System hangs while starting udev.
Here is config
http://www.stardust.webpages.pl/files/kml/kml-configHere is "Kernel Bug : The Movie 2" ;)
http://www.stardust.webpages.pl/files/crap/kbtm2.aviCould you put some screenshots instead? I can't play this file (tried totem, realplayer, windows media player).
[g]mplayer handles it fine. But the screen quality is so bad that you cannot read any numbers.
Quoted 7 lines · Michal Piotrowski
System hangs while starting udev.
Here is config
http://www.stardust.webpages.pl/files/kml/kml-configHere is "Kernel Bug : The Movie 2" ;)
http://www.stardust.webpages.pl/files/crap/kbtm2.avi
I mananged to play it but there isn't anything obvious. Are there any messages from kmemleak (it's pretty hard to read the screen in this movie)?
Could you try with SMP disabled? The locking mechanism in kmemleak should be OK but I might have missed something.
Signature · 1 line
Catalin
Quoted 4 lines · Michal Piotrowski
System hangs while starting udev.
Here is config
http://www.stardust.webpages.pl/files/kml/kml-config
I managed to reproduce the problem - the kernel can deadlock on SMP if the module being loaded contains the .init.memleak_aliases section. I'll fix it and post another patch later today.
Thanks for testing.
Signature · 1 line
Catalin
Hi Catalian,
Quoted 10 lines · Catalin Marinas
Quoted 4 lines · Michal Piotrowski
System hangs while starting udev.
Here is config
http://www.stardust.webpages.pl/files/kml/kml-configI managed to reproduce the problem - the kernel can deadlock on SMP if the module being loaded contains the .init.memleak_aliases section. I'll fix it and post another patch later today.
I have disabled SMP and system still hangs, but now I know when :)
Here is bug http://www.stardust.webpages.pl/files/kml/bug1.jpg
Here is config http://www.stardust.webpages.pl/files/kml/kml-config2
I think that Ingo's "Ignore loglevel on printks" patch is very useful.
Quoted 3 lines
--
Catalin
Regards,
Michal
Signature · 3 lines
Michal K. K. Piotrowski LTG - Linux Testers Group (http://www.stardust.webpages.pl/ltg/wiki/)
Quoted 3 lines · Michal Piotrowski
I have disabled SMP and system still hangs, but now I know when :)
Here is bug http://www.stardust.webpages.pl/files/kml/bug1.jpg
Yes, that's the deadlock I got as well. memleak_insert_aliases holds the spinlock but it also calls kmalloc which calls the memleak_alloc hook which deadlocks.
Hopefully, I fixed it know and tested it on ARM. I'll give it a try a bit later on x86 and post a new patch.
Regards.
Signature · 1 line
Catalin