Kmemleak patches for 2.6.32
Subsystems (7)
Catalin Marinas
maintainercover Kmemleak patches for 2.6.32
Hi,
These are kmemleak related patches I plan to submit for mainline inclusion during the upcoming merging window. I'll push them to the linux-next tree once any comments received are implemented.
Thanks.
Catalin Marinas (7):
kmemleak: Dump object information on request
kmemleak: Allow rescheduling during an object scanning
kmemleak: Mark the early log buffer as __initdata
kmemleak: Save the stack trace for early allocations
kmemleak: Do not report alloc_bootmem blocks as leaks
kmemleak: Inform kmemleak about kernel stack allocation
kmemleak: Always scan the task stacks
Sergey Senozhatsky (1):
kmemleak: Printing of the objects hex dump
Documentation/kmemleak.txt | 12 +- arch/x86/include/asm/thread_info.h | 7 + arch/x86/kernel/process.c | 1 include/linux/kmemleak.h | 18 ++- kernel/fork.c | 7 + mm/bootmem.c | 6 + mm/kmemleak.c | 195 +++++++++++++++++++++++++++--------- 7 files changed, 178 insertions(+), 68 deletions(-)
Signature · 1 line
Catalin
Catalin Marinas
maintainerPATCH 1/8 kmemleak: Dump object information on request
By writing dump=<addr> to the kmemleak file, kmemleak will look up an object with that address and dump the information it has about it to syslog. This is useful in debugging memory leaks.
--- Documentation/kmemleak.txt | 1 + mm/kmemleak.c | 25 +++++++++++++++++++++++++ 2 files changed, 26 insertions(+), 0 deletions(-)
Documentation/kmemleak.txt +1 -0
@@ -42,6 +42,7 @@ Memory scanning parameters can be modified at run-time by writing to the scan=<secs> - set the automatic memory scanning period in seconds (default 600, 0 to stop the automatic scanning) scan - trigger a memory scan + dump=<addr> - dump information about the object found at <addr> Kmemleak can also be disabled at boot-time by passing "kmemleak=off" on the kernel command line.
mm/kmemleak.c +25 -0
@@ -330,6 +330,7 @@ static void dump_object_info(struct kmemleak_object *object) object->comm, object->pid, object->jiffies);pr_notice (" min_count = %d\n" , object->min_count);pr_notice (" count = %d\n" , object->count); +pr_notice (" flags = 0x%lx\n" , object->flags);pr_notice (" backtrace:\n" );print_stack_trace (&trace,4 ); }
@@ -1294,6 +1295,27 @@ static int kmemleak_release(struct inode *inode, struct file *file)return seq_release (inode, file); } +static int dump_str_object_info (const char *str) +{ +unsigned long flags; +struct kmemleak_object *object; +unsigned long addr; + + addr=simple_strtoul (str,NULL ,0 ); + object =find_and_get_object (addr,0 ); +if (!object) { +pr_info ("Unknown object at 0x%08lx\n" , addr); +return -EINVAL ; + } + +spin_lock_irqsave (&object->lock, flags); +dump_object_info (object); +spin_unlock_irqrestore (&object->lock, flags); + +put_object (object); +return 0 ; +} +/* * File write operation to configure kmemleak at run-time. The following * commands can be written to the /sys/kernel/debug/kmemleak file:
@@ -1305,6 +1327,7 @@ static int kmemleak_release(struct inode *inode, struct file *file)* scan=... - set the automatic memory scanning period in seconds (0 to * disable it) * scan - trigger a memory scan +* dump=... - dump information about the object found at the given address */ static ssize_t kmemleak_write (struct file *file,const char __user *user_buf,size_t size,loff_t *ppos)
@@ -1345,6 +1368,8 @@ static ssize_t kmemleak_write(struct file *file, const char __user *user_buf, } }else if (strncmp (buf,"scan" ,4 ) ==0 )kmemleak_scan (); +else if (strncmp (buf,"dump=" ,5 ) ==0 ) + ret =dump_str_object_info (buf +5 );else ret = -EINVAL ;
Catalin Marinas
maintainerPATCH 2/8 kmemleak: Allow rescheduling during an object scanning
In reply to Catalin MarinasIf the object size is bigger than a predefined value (4K in this case), release the object lock during scanning and call cond_resched(). Re-acquire the lock after rescheduling and test whether the object is still valid.
--- mm/kmemleak.c | 19 +++++++++++++++---- 1 files changed, 15 insertions(+), 4 deletions(-)
mm/kmemleak.c +15 -4
@@ -107,6 +107,7 @@#define SECS_FIRST_SCAN 60/* delay before the first scan */ #define SECS_SCAN_WAIT 600/* subsequent auto scanning delay */ #define GRAY_LIST_PASSES 25/* maximum number of gray list scans */ +#define MAX_SCAN_SIZE 4096/* maximum size of a scanned block */ #define BYTES_PER_POINTER sizeof(void *)
@@ -950,10 +951,20 @@ static void scan_object(struct kmemleak_object *object)if (!(object->flags &OBJECT_ALLOCATED ))/* already freed object */ goto out; -if (hlist_empty (&object->area_list)) -scan_block ((void *)object->pointer, - (void *)(object->pointer + object->size), object,0 ); -else +if (hlist_empty (&object->area_list)) { +void *start = (void *)object->pointer; +void *end = (void *)(object->pointer + object->size); + +while (start < end && (object->flags &OBJECT_ALLOCATED )) { +scan_block (start,min (start +MAX_SCAN_SIZE , end), + object,0 ); + start +=MAX_SCAN_SIZE ; + +spin_unlock_irqrestore (&object->lock, flags); +cond_resched (); +spin_lock_irqsave (&object->lock, flags); + } + }else hlist_for_each_entry (area, elem, &object->area_list, node) scan_block((void *)(object->pointer + area->offset), (void *)(object->pointer + area->offset
Catalin Marinas
maintainerPATCH 3/8 kmemleak: Mark the early log buffer as __initdata
In reply to Catalin MarinasThis buffer isn't needed after kmemleak was initialised so it can be freed together with the .init.data section. This patch also marks functions conditionally accessing the early log variables with __ref.
--- include/linux/kmemleak.h | 18 +++++++++--------- mm/kmemleak.c | 26 ++++++++++++++------------ 2 files changed, 23 insertions(+), 21 deletions(-)
include/linux/kmemleak.h +9 -9
@@ -23,18 +23,18 @@#ifdef CONFIG_DEBUG_KMEMLEAK -extern void kmemleak_init (void ); +extern void kmemleak_init (void )__ref ;extern void kmemleak_alloc (const void *ptr,size_t size,int min_count, -gfp_t gfp); -extern void kmemleak_free (const void *ptr); -extern void kmemleak_free_part (const void *ptr,size_t size); +gfp_t gfp)__ref ; +extern void kmemleak_free (const void *ptr)__ref ; +extern void kmemleak_free_part (const void *ptr,size_t size)__ref ;extern void kmemleak_padding (const void *ptr,unsigned long offset, -size_t size); -extern void kmemleak_not_leak (const void *ptr); -extern void kmemleak_ignore (const void *ptr); +size_t size)__ref ; +extern void kmemleak_not_leak (const void *ptr)__ref ; +extern void kmemleak_ignore (const void *ptr)__ref ;extern void kmemleak_scan_area (const void *ptr,unsigned long offset, -size_t length,gfp_t gfp); -extern void kmemleak_no_scan (const void *ptr); +size_t length,gfp_t gfp)__ref ; +extern void kmemleak_no_scan (const void *ptr)__ref ; static inline void kmemleak_alloc_recursive(const void *ptr, size_t size, int min_count, unsigned long flags,
mm/kmemleak.c +14 -12
@@ -232,8 +232,9 @@ struct early_log { };/* early logging buffer and current position */ -static struct early_log early_log[CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE ]; -static int crt_early_log; +static struct early_log + early_log[CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE ]__initdata ; +static int crt_early_log__initdata ;static void kmemleak_disable (void );
@@ -717,8 +718,8 @@ static void object_no_scan(unsigned long ptr)* Log an early kmemleak_* call to the early_log buffer. These calls will be * processed later once kmemleak is fully initialized. */ -static void log_early (int op_type,const void *ptr,size_t size, -int min_count,unsigned long offset,size_t length) +static void __init log_early (int op_type,const void *ptr,size_t size, +int min_count,unsigned long offset,size_t length) {unsigned long flags;struct early_log *log;
@@ -750,7 +751,8 @@ static void log_early(int op_type, const void *ptr, size_t size,* kernel allocators when a new block is allocated (kmem_cache_alloc, kmalloc, * vmalloc etc.). */ -void kmemleak_alloc (const void *ptr,size_t size,int min_count,gfp_t gfp) +void __ref kmemleak_alloc (const void *ptr,size_t size,int min_count, +gfp_t gfp) {pr_debug ("%s(0x%p, %zu, %d)\n" , __func__, ptr, size, min_count);
@@ -765,7 +767,7 @@ EXPORT_SYMBOL_GPL(kmemleak_alloc);* Memory freeing function callback. This function is called from the kernel * allocators when a block is freed (kmem_cache_free, kfree, vfree etc.). */ -void kmemleak_free (const void *ptr) +void __ref kmemleak_free (const void *ptr) {pr_debug ("%s(0x%p)\n" , __func__, ptr);
@@ -780,7 +782,7 @@ EXPORT_SYMBOL_GPL(kmemleak_free);* Partial memory freeing function callback. This function is usually called * from bootmem allocator when (part of) a memory block is freed. */ -void kmemleak_free_part (const void *ptr,size_t size) +void __ref kmemleak_free_part (const void *ptr,size_t size) {pr_debug ("%s(0x%p)\n" , __func__, ptr);
@@ -795,7 +797,7 @@ EXPORT_SYMBOL_GPL(kmemleak_free_part);* Mark an already allocated memory block as a false positive. This will cause * the block to no longer be reported as leak and always be scanned. */ -void kmemleak_not_leak (const void *ptr) +void __ref kmemleak_not_leak (const void *ptr) {pr_debug ("%s(0x%p)\n" , __func__, ptr);
@@ -811,7 +813,7 @@ EXPORT_SYMBOL(kmemleak_not_leak);* corresponding block is not a leak and does not contain any references to * other allocated memory blocks. */ -void kmemleak_ignore (const void *ptr) +void __ref kmemleak_ignore (const void *ptr) {pr_debug ("%s(0x%p)\n" , __func__, ptr);
@@ -825,8 +827,8 @@ EXPORT_SYMBOL(kmemleak_ignore);/* * Limit the range to be scanned in an allocated memory block. */ -void kmemleak_scan_area (const void *ptr,unsigned long offset,size_t length, -gfp_t gfp) +void __ref kmemleak_scan_area (const void *ptr,unsigned long offset, +size_t length,gfp_t gfp) {pr_debug ("%s(0x%p)\n" , __func__, ptr);
@@ -840,7 +842,7 @@ EXPORT_SYMBOL(kmemleak_scan_area);/* * Inform kmemleak not to scan the given memory block. */ -void kmemleak_no_scan (const void *ptr) +void __ref kmemleak_no_scan (const void *ptr) {pr_debug ("%s(0x%p)\n" , __func__, ptr);
Catalin Marinas
maintainerPATCH 4/8 kmemleak: Save the stack trace for early allocations
In reply to Catalin MarinasBefore slab is initialised, kmemleak save the allocations in an early log buffer. They are later recorded as normal memory allocations. This patch adds the stack trace saving to the early log buffer, otherwise the information shown for such objects only refers to the kmemleak_init() function.
--- mm/kmemleak.c | 64 ++++++++++++++++++++++++++++++++++++++++++++++----------- 1 files changed, 52 insertions(+), 12 deletions(-)
mm/kmemleak.c +52 -12
@@ -229,6 +229,8 @@ struct early_log {int min_count;/* minimum reference count */ unsigned long offset;/* scan area offset */ size_t length;/* scan area length */ +unsigned long trace[MAX_TRACE ];/* stack trace */ +unsigned int trace_len;/* stack trace length */ };/* early logging buffer and current position */
@@ -437,21 +439,36 @@ static struct kmemleak_object *find_and_get_object(unsigned long ptr, int alias) }/* +* Save stack trace to the given array of MAX_TRACE size. +*/ +static int __save_stack_trace (unsigned long *trace) +{ +struct stack_trace stack_trace; + + stack_trace.max_entries =MAX_TRACE ; + stack_trace.nr_entries =0 ; + stack_trace.entries = trace; + stack_trace.skip =2 ; +save_stack_trace (&stack_trace); + +return stack_trace.nr_entries; +} + +/* * Create the metadata (struct kmemleak_object) corresponding to an allocated * memory block and add it to the object_list and object_tree_root. */ -static void create_object (unsigned long ptr,size_t size,int min_count, -gfp_t gfp) +static struct kmemleak_object *create_object (unsigned long ptr,size_t size, +int min_count,gfp_t gfp) {unsigned long flags;struct kmemleak_object *object;struct prio_tree_node *node; -struct stack_trace trace; object =kmem_cache_alloc (object_cache, gfp &GFP_KMEMLEAK_MASK );if (!object) {kmemleak_stop ("Cannot allocate a kmemleak_object structure\n" ); -return ; +return NULL ; }INIT_LIST_HEAD (&object->object_list);
@@ -485,12 +502,7 @@ static void create_object(unsigned long ptr, size_t size, int min_count, }/* kernel backtrace */ - trace.max_entries =MAX_TRACE ; - trace.nr_entries =0 ; - trace.entries = object->trace; - trace.skip =1 ; -save_stack_trace (&trace); - object->trace_len = trace.nr_entries; + object->trace_len =__save_stack_trace (object->trace);INIT_PRIO_TREE_NODE (&object->tree_node); object->tree_node.start = ptr;
@@ -521,6 +533,7 @@ static void create_object(unsigned long ptr, size_t size, int min_count,list_add_tail_rcu (&object->object_list, &object_list); out:write_unlock_irqrestore (&kmemleak_lock, flags); +return object; }/*
@@ -742,11 +755,39 @@ static void __init log_early(int op_type, const void *ptr, size_t size, log->min_count = min_count; log->offset = offset; log->length = length; +if (op_type ==KMEMLEAK_ALLOC ) + log->trace_len =__save_stack_trace (log->trace); crt_early_log++;local_irq_restore (flags); }/* +* Log an early allocated block and populate the stack trace. +*/ +static void early_alloc (struct early_log *log) +{ +struct kmemleak_object *object; +unsigned long flags; +int i; + +if (!atomic_read (&kmemleak_enabled) || !log->ptr ||IS_ERR (log->ptr)) +return ; + +/* +* RCU locking needed to ensure object is not freed via put_object(). +*/ +rcu_read_lock (); + object =create_object ((unsigned long )log->ptr, log->size, + log->min_count,GFP_KERNEL ); +spin_lock_irqsave (&object->lock, flags); +for (i =0 ; i < log->trace_len; i++) + object->trace[i] = log->trace[i]; + object->trace_len = log->trace_len; +spin_unlock_irqrestore (&object->lock, flags); +rcu_read_unlock (); +} + +/* * Memory allocation function callback. This function is called from the * kernel allocators when a new block is allocated (kmem_cache_alloc, kmalloc, * vmalloc etc.).
@@ -1507,8 +1548,7 @@ void __init kmemleak_init(void)switch (log->op_type) {case KMEMLEAK_ALLOC : -kmemleak_alloc (log->ptr, log->size, log->min_count, -GFP_KERNEL ); +early_alloc (log);break ;case KMEMLEAK_FREE :kmemleak_free (log->ptr);
Catalin Marinas
maintainerPATCH 5/8 kmemleak: Do not report alloc_bootmem blocks as leaks
In reply to Catalin MarinasThis patch sets the min_count for alloc_bootmem objects to 0 so that they are never reported as leaks. This is because many of these blocks are only referred via the physical address which is not looked up by kmemleak.
--- mm/bootmem.c | 6 +++++- 1 files changed, 5 insertions(+), 1 deletions(-)
mm/bootmem.c +5 -1
@@ -521,7 +521,11 @@ find_block: region =phys_to_virt (PFN_PHYS (bdata->node_min_pfn) + start_off);memset (region,0 , size); -kmemleak_alloc (region, size,1 ,0 ); +/* +* The min_count is set to 0 so that bootmem allocated blocks +* are never reported as leaks. +*/ +kmemleak_alloc (region, size,0 ,0 );return region; }
Catalin Marinas
maintainerPATCH 6/8 kmemleak: Printing of the objects hex dump
In reply to Catalin MarinasFrom: Sergey Senozhatsky <[email protected]>
Introducing printing of the objects hex dump to the seq file. The number of lines to be printed is limited to HEX_MAX_LINES to prevent seq file spamming. The actual number of printed bytes is less than or equal to (HEX_MAX_LINES * HEX_ROW_SIZE).
(slight adjustments by Catalin Marinas)
--- mm/kmemleak.c | 39 +++++++++++++++++++++++++++++++++++++++ 1 files changed, 39 insertions(+), 0 deletions(-)
mm/kmemleak.c +39 -0
@@ -162,6 +162,15 @@ struct kmemleak_object {/* flag set on newly allocated objects */ #define OBJECT_NEW (1 << 3) +/* number of bytes to print per line; must be 16 or 32 */ +#define HEX_ROW_SIZE 16 +/* number of bytes to print at a time (1, 2, 4, 8) */ +#define HEX_GROUP_SIZE 1 +/* include ASCII after the hex output */ +#define HEX_ASCII 1 +/* max number of lines to be printed */ +#define HEX_MAX_LINES 2 +/* the list of all allocated objects */ static LIST_HEAD (object_list);/* the list of gray-colored objects (see color_gray comment below) */
@@ -259,6 +268,35 @@ static void kmemleak_disable(void); }while (0 )/* +* Printing of the objects hex dump to the seq file. The number of lines to be +* printed is limited to HEX_MAX_LINES to prevent seq file spamming. The +* actual number of printed bytes depends on HEX_ROW_SIZE. It must be called +* with the object->lock held. +*/ +static void hex_dump_object(struct seq_file *seq, +struct kmemleak_object *object) +{ +const u8 *ptr = (const u8 *)object->pointer; +int i, len, remaining; +unsigned char linebuf[HEX_ROW_SIZE *5 ]; + +/* limit the number of lines to HEX_MAX_LINES */ + remaining = len = +min (object->size, (size_t )(HEX_MAX_LINES *HEX_ROW_SIZE )); + +seq_printf (seq," hex dump (first %d bytes):\n" , len); +for (i =0 ; i < len; i +=HEX_ROW_SIZE ) { +int linelen =min (remaining,HEX_ROW_SIZE ); + + remaining -=HEX_ROW_SIZE ; +hex_dump_to_buffer (ptr + i, linelen,HEX_ROW_SIZE , +HEX_GROUP_SIZE , linebuf,sizeof (linebuf), +HEX_ASCII ); +seq_printf (seq," %s\n" , linebuf); + } +} + +/* * Object colors, encoded with count and min_count: * - white - orphan object, not enough references to it (count < min_count) * - gray - not orphan, not marked as false positive (min_count == 0) or
@@ -308,6 +346,7 @@ static void print_unreferenced(struct seq_file *seq, object->pointer, object->size);seq_printf (seq," comm \"%s\", pid %d, jiffies %lu\n" , object->comm, object->pid, object->jiffies); +hex_dump_object (seq, object);seq_printf (seq," backtrace:\n" );for (i =0 ; i < object->trace_len; i++) {
Catalin Marinas
maintainerPATCH 7/8 kmemleak: Inform kmemleak about kernel stack allocation
In reply to Catalin MarinasTraversing all the tasks in the system for scanning the kernel stacks requires locking which increases the kernel latency considerably. This patch informs kmemleak about newly allocated or freed stacks so that they are treated as any other allocated object. Subsequent patch will remove the explicit stack scanning from mm/kmemleak.c.
--- arch/x86/include/asm/thread_info.h | 7 ++++++- arch/x86/kernel/process.c | 1 + kernel/fork.c | 7 ++++++- 3 files changed, 13 insertions(+), 2 deletions(-)
arch/x86/include/asm/thread_info.h +6 -1
@@ -162,7 +162,12 @@ struct thread_info {#define __HAVE_ARCH_THREAD_INFO_ALLOCATOR#define alloc_thread_info (tsk) \ - ((struct thread_info *)__get_free_pages(THREAD_FLAGS, THREAD_ORDER)) +({ \ + struct thread_info *ti = (struct thread_info *) \ + __get_free_pages(THREAD_FLAGS, THREAD_ORDER); \ + kmemleak_alloc(ti, THREAD_SIZE, 1, THREAD_FLAGS); \ + ti; \ +})#ifdef CONFIG_X86_32
arch/x86/kernel/process.c +1 -0
@@ -55,6 +55,7 @@ void free_thread_xstate(struct task_struct *tsk)void free_thread_info (struct thread_info *ti) {free_thread_xstate (ti->task); +kmemleak_free (ti);free_pages ((unsigned long )ti,get_order (THREAD_SIZE )); }
kernel/fork.c +6 -1
@@ -62,6 +62,7 @@#include <linux/fs_struct.h> #include <linux/magic.h> #include <linux/perf_counter.h> +#include <linux/kmemleak.h> #include <asm/pgtable.h> #include <asm/pgalloc.h>
@@ -104,16 +105,20 @@ static struct kmem_cache *task_struct_cachep;#ifndef __HAVE_ARCH_THREAD_INFO_ALLOCATORstatic inline struct thread_info *alloc_thread_info (struct task_struct *tsk) { +struct thread_info *ti;#ifdef CONFIG_DEBUG_STACK_USAGE gfp_t mask =GFP_KERNEL | __GFP_ZERO;#else gfp_t mask =GFP_KERNEL ;#endif -return (struct thread_info *)__get_free_pages (mask,THREAD_SIZE_ORDER ); + ti = (struct thread_info *)__get_free_pages (mask,THREAD_SIZE_ORDER ); +kmemleak_alloc (ti,THREAD_SIZE ,1 , mask); +return ti; }static inline void free_thread_info (struct thread_info *ti) { +kmemleak_free (ti);free_pages ((unsigned long )ti,THREAD_SIZE_ORDER ); }#endif
Catalin Marinas
maintainerPATCH 8/8 kmemleak: Always scan the task stacks
In reply to Catalin MarinasThis patch removes the stack scanning on/off run-time configuration. The thread stacks are now automatically scanned as any other allocated object (and avoid many false positives).
--- Documentation/kmemleak.txt | 11 +++++------ mm/kmemleak.c | 22 ---------------------- 2 files changed, 5 insertions(+), 28 deletions(-)
Documentation/kmemleak.txt +5 -6
@@ -35,8 +35,6 @@ Memory scanning parameters can be modified at run-time by writing to the /sys/kernel/debug/kmemleak file. The following parameters are supported: off - disable kmemleak (irreversible) - stack=on - enable the task stacks scanning (default) - stack=off - disable the tasks stacks scanning scan=on - start the automatic memory scanning thread (default) scan=off - stop the automatic memory scanning thread scan=<secs> - set the automatic memory scanning period in seconds
@@ -111,7 +109,8 @@ reported by kmemleak because values found during the memory scanning point to such objects. To reduce the number of false negatives, kmemleak provides the kmemleak_ignore, kmemleak_scan_area, kmemleak_no_scan and kmemleak_erase functions (see above). The task stacks also increase the -amount of false negatives and their scanning is not enabled by default. +amount of false negatives (enabling CONFIG_DEBUG_STACK_USAGE would help +by zeroing newly allocated stacks). The false positives are objects wrongly reported as being memory leaks (orphan). For objects known not to be leaks, kmemleak provides the
@@ -120,9 +119,9 @@ the memory block is known not to contain other pointers and it will no longer be scanned. Some of the reported leaks are only transient, especially on SMP -systems, because of pointers temporarily stored in CPU registers or -stacks. Kmemleak defines MSECS_MIN_AGE (defaulting to 1000) representing -the minimum age of an object to be reported as a memory leak. +systems, because of pointers temporarily stored in CPU registers. +Kmemleak defines MSECS_MIN_AGE (defaulting to 5000) representing the +minimum age of an object to be reported as a memory leak. Limitations and Drawbacks -------------------------
mm/kmemleak.c +0 -22
@@ -203,8 +203,6 @@ static unsigned long jiffies_min_age;static unsigned long jiffies_last_scan;/* delay between automatic memory scannings */ static signed long jiffies_scan_wait; -/* enables or disables the task stacks scanning */ -static int kmemleak_stack_scan =1 ;/* protects the memory scanning, parameters and debug/kmemleak file access */ static DEFINE_MUTEX (scan_mutex);
@@ -1064,7 +1062,6 @@ static void kmemleak_scan(void) {unsigned long flags;struct kmemleak_object *object, *tmp; -struct task_struct *task;int i;int new_leaks =0 ;int gray_list_pass =0 ;
@@ -1131,19 +1128,6 @@ static void kmemleak_scan(void) }/* -* Scanning the task stacks may introduce false negatives and it is -* not enabled by default. -*/ -if (kmemleak_stack_scan) { -read_lock (&tasklist_lock); -for_each_process (task) -scan_block (task_stack_page (task), -task_stack_page (task) +THREAD_SIZE , -NULL ,0 ); -read_unlock (&tasklist_lock); - } - -/* * Scan the objects already referenced from the sections scanned * above. More objects will be referenced and, if there are no memory * leaks, all the objects will be scanned. The list traversal is safe
@@ -1413,8 +1397,6 @@ static int dump_str_object_info(const char *str)* File write operation to configure kmemleak at run-time. The following * commands can be written to the /sys/kernel/debug/kmemleak file: * off - disable kmemleak (irreversible) -* stack=on - enable the task stacks scanning -* stack=off - disable the tasks stacks scanning * scan=on - start the automatic memory scanning thread * scan=off - stop the automatic memory scanning thread * scan=... - set the automatic memory scanning period in seconds (0 to
@@ -1440,10 +1422,6 @@ static ssize_t kmemleak_write(struct file *file, const char __user *user_buf,if (strncmp (buf,"off" ,3 ) ==0 )kmemleak_disable (); -else if (strncmp (buf,"stack=on" ,8 ) ==0 ) - kmemleak_stack_scan =1 ; -else if (strncmp (buf,"stack=off" ,9 ) ==0 ) - kmemleak_stack_scan =0 ;else if (strncmp (buf,"scan=on" ,7 ) ==0 )start_scan_thread ();else if (strncmp (buf,"scan=off" ,8 ) ==0 )