blob: a38418a95d33fa425791e0fcee465778833b4cce [file] [log] [blame]
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001/*
2 * mm/kmemleak.c
3 *
4 * Copyright (C) 2008 ARM Limited
5 * Written by Catalin Marinas <catalin.marinas@arm.com>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 *
21 * For more information on the algorithm and kmemleak usage, please see
22 * Documentation/kmemleak.txt.
23 *
24 * Notes on locking
25 * ----------------
26 *
27 * The following locks and mutexes are used by kmemleak:
28 *
29 * - kmemleak_lock (rwlock): protects the object_list modifications and
30 * accesses to the object_tree_root. The object_list is the main list
31 * holding the metadata (struct kmemleak_object) for the allocated memory
32 * blocks. The object_tree_root is a priority search tree used to look-up
33 * metadata based on a pointer to the corresponding memory block. The
34 * kmemleak_object structures are added to the object_list and
35 * object_tree_root in the create_object() function called from the
36 * kmemleak_alloc() callback and removed in delete_object() called from the
37 * kmemleak_free() callback
38 * - kmemleak_object.lock (spinlock): protects a kmemleak_object. Accesses to
39 * the metadata (e.g. count) are protected by this lock. Note that some
40 * members of this structure may be protected by other means (atomic or
41 * kmemleak_lock). This lock is also held when scanning the corresponding
42 * memory block to avoid the kernel freeing it via the kmemleak_free()
43 * callback. This is less heavyweight than holding a global lock like
44 * kmemleak_lock during scanning
45 * - scan_mutex (mutex): ensures that only one thread may scan the memory for
46 * unreferenced objects at a time. The gray_list contains the objects which
47 * are already referenced or marked as false positives and need to be
48 * scanned. This list is only modified during a scanning episode when the
49 * scan_mutex is held. At the end of a scan, the gray_list is always empty.
50 * Note that the kmemleak_object.use_count is incremented when an object is
51 * added to the gray_list and therefore cannot be freed
52 * - kmemleak_mutex (mutex): prevents multiple users of the "kmemleak" debugfs
53 * file together with modifications to the memory scanning parameters
54 * including the scan_thread pointer
55 *
56 * The kmemleak_object structures have a use_count incremented or decremented
57 * using the get_object()/put_object() functions. When the use_count becomes
58 * 0, this count can no longer be incremented and put_object() schedules the
59 * kmemleak_object freeing via an RCU callback. All calls to the get_object()
60 * function must be protected by rcu_read_lock() to avoid accessing a freed
61 * structure.
62 */
63
Joe Perchesae281062009-06-23 14:40:26 +010064#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
65
Catalin Marinas3c7b4e62009-06-11 13:22:39 +010066#include <linux/init.h>
67#include <linux/kernel.h>
68#include <linux/list.h>
69#include <linux/sched.h>
70#include <linux/jiffies.h>
71#include <linux/delay.h>
72#include <linux/module.h>
73#include <linux/kthread.h>
74#include <linux/prio_tree.h>
75#include <linux/gfp.h>
76#include <linux/fs.h>
77#include <linux/debugfs.h>
78#include <linux/seq_file.h>
79#include <linux/cpumask.h>
80#include <linux/spinlock.h>
81#include <linux/mutex.h>
82#include <linux/rcupdate.h>
83#include <linux/stacktrace.h>
84#include <linux/cache.h>
85#include <linux/percpu.h>
86#include <linux/hardirq.h>
87#include <linux/mmzone.h>
88#include <linux/slab.h>
89#include <linux/thread_info.h>
90#include <linux/err.h>
91#include <linux/uaccess.h>
92#include <linux/string.h>
93#include <linux/nodemask.h>
94#include <linux/mm.h>
95
96#include <asm/sections.h>
97#include <asm/processor.h>
98#include <asm/atomic.h>
99
100#include <linux/kmemleak.h>
101
102/*
103 * Kmemleak configuration and common defines.
104 */
105#define MAX_TRACE 16 /* stack trace length */
106#define REPORTS_NR 50 /* maximum number of reported leaks */
107#define MSECS_MIN_AGE 5000 /* minimum object age for reporting */
108#define MSECS_SCAN_YIELD 10 /* CPU yielding period */
109#define SECS_FIRST_SCAN 60 /* delay before the first scan */
110#define SECS_SCAN_WAIT 600 /* subsequent auto scanning delay */
111
112#define BYTES_PER_POINTER sizeof(void *)
113
Catalin Marinas216c04b2009-06-17 18:29:02 +0100114/* GFP bitmask for kmemleak internal allocations */
115#define GFP_KMEMLEAK_MASK (GFP_KERNEL | GFP_ATOMIC)
116
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100117/* scanning area inside a memory block */
118struct kmemleak_scan_area {
119 struct hlist_node node;
120 unsigned long offset;
121 size_t length;
122};
123
124/*
125 * Structure holding the metadata for each allocated memory block.
126 * Modifications to such objects should be made while holding the
127 * object->lock. Insertions or deletions from object_list, gray_list or
128 * tree_node are already protected by the corresponding locks or mutex (see
129 * the notes on locking above). These objects are reference-counted
130 * (use_count) and freed using the RCU mechanism.
131 */
132struct kmemleak_object {
133 spinlock_t lock;
134 unsigned long flags; /* object status flags */
135 struct list_head object_list;
136 struct list_head gray_list;
137 struct prio_tree_node tree_node;
138 struct rcu_head rcu; /* object_list lockless traversal */
139 /* object usage count; object freed when use_count == 0 */
140 atomic_t use_count;
141 unsigned long pointer;
142 size_t size;
143 /* minimum number of a pointers found before it is considered leak */
144 int min_count;
145 /* the total number of pointers found pointing to this object */
146 int count;
147 /* memory ranges to be scanned inside an object (empty for all) */
148 struct hlist_head area_list;
149 unsigned long trace[MAX_TRACE];
150 unsigned int trace_len;
151 unsigned long jiffies; /* creation timestamp */
152 pid_t pid; /* pid of the current task */
153 char comm[TASK_COMM_LEN]; /* executable name */
154};
155
156/* flag representing the memory block allocation status */
157#define OBJECT_ALLOCATED (1 << 0)
158/* flag set after the first reporting of an unreference object */
159#define OBJECT_REPORTED (1 << 1)
160/* flag set to not scan the object */
161#define OBJECT_NO_SCAN (1 << 2)
162
163/* the list of all allocated objects */
164static LIST_HEAD(object_list);
165/* the list of gray-colored objects (see color_gray comment below) */
166static LIST_HEAD(gray_list);
167/* prio search tree for object boundaries */
168static struct prio_tree_root object_tree_root;
169/* rw_lock protecting the access to object_list and prio_tree_root */
170static DEFINE_RWLOCK(kmemleak_lock);
171
172/* allocation caches for kmemleak internal data */
173static struct kmem_cache *object_cache;
174static struct kmem_cache *scan_area_cache;
175
176/* set if tracing memory operations is enabled */
177static atomic_t kmemleak_enabled = ATOMIC_INIT(0);
178/* set in the late_initcall if there were no errors */
179static atomic_t kmemleak_initialized = ATOMIC_INIT(0);
180/* enables or disables early logging of the memory operations */
181static atomic_t kmemleak_early_log = ATOMIC_INIT(1);
182/* set if a fata kmemleak error has occurred */
183static atomic_t kmemleak_error = ATOMIC_INIT(0);
184
185/* minimum and maximum address that may be valid pointers */
186static unsigned long min_addr = ULONG_MAX;
187static unsigned long max_addr;
188
189/* used for yielding the CPU to other tasks during scanning */
190static unsigned long next_scan_yield;
191static struct task_struct *scan_thread;
192static unsigned long jiffies_scan_yield;
193static unsigned long jiffies_min_age;
194/* delay between automatic memory scannings */
195static signed long jiffies_scan_wait;
196/* enables or disables the task stacks scanning */
Catalin Marinase0a2a162009-06-26 17:38:25 +0100197static int kmemleak_stack_scan = 1;
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100198/* mutex protecting the memory scanning */
199static DEFINE_MUTEX(scan_mutex);
200/* mutex protecting the access to the /sys/kernel/debug/kmemleak file */
201static DEFINE_MUTEX(kmemleak_mutex);
202
203/* number of leaks reported (for limitation purposes) */
204static int reported_leaks;
205
206/*
Catalin Marinas20301172009-06-17 18:29:04 +0100207 * Early object allocation/freeing logging. Kmemleak is initialized after the
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100208 * kernel allocator. However, both the kernel allocator and kmemleak may
Catalin Marinas20301172009-06-17 18:29:04 +0100209 * allocate memory blocks which need to be tracked. Kmemleak defines an
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100210 * arbitrary buffer to hold the allocation/freeing information before it is
211 * fully initialized.
212 */
213
214/* kmemleak operation type for early logging */
215enum {
216 KMEMLEAK_ALLOC,
217 KMEMLEAK_FREE,
218 KMEMLEAK_NOT_LEAK,
219 KMEMLEAK_IGNORE,
220 KMEMLEAK_SCAN_AREA,
221 KMEMLEAK_NO_SCAN
222};
223
224/*
225 * Structure holding the information passed to kmemleak callbacks during the
226 * early logging.
227 */
228struct early_log {
229 int op_type; /* kmemleak operation type */
230 const void *ptr; /* allocated/freed memory block */
231 size_t size; /* memory block size */
232 int min_count; /* minimum reference count */
233 unsigned long offset; /* scan area offset */
234 size_t length; /* scan area length */
235};
236
237/* early logging buffer and current position */
Catalin Marinasa9d90582009-06-25 10:16:11 +0100238static struct early_log early_log[CONFIG_DEBUG_KMEMLEAK_EARLY_LOG_SIZE];
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100239static int crt_early_log;
240
241static void kmemleak_disable(void);
242
243/*
244 * Print a warning and dump the stack trace.
245 */
246#define kmemleak_warn(x...) do { \
247 pr_warning(x); \
248 dump_stack(); \
249} while (0)
250
251/*
252 * Macro invoked when a serious kmemleak condition occured and cannot be
Catalin Marinas20301172009-06-17 18:29:04 +0100253 * recovered from. Kmemleak will be disabled and further allocation/freeing
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100254 * tracing no longer available.
255 */
Catalin Marinas000814f2009-06-17 18:29:03 +0100256#define kmemleak_stop(x...) do { \
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100257 kmemleak_warn(x); \
258 kmemleak_disable(); \
259} while (0)
260
261/*
262 * Object colors, encoded with count and min_count:
263 * - white - orphan object, not enough references to it (count < min_count)
264 * - gray - not orphan, not marked as false positive (min_count == 0) or
265 * sufficient references to it (count >= min_count)
266 * - black - ignore, it doesn't contain references (e.g. text section)
267 * (min_count == -1). No function defined for this color.
268 * Newly created objects don't have any color assigned (object->count == -1)
269 * before the next memory scan when they become white.
270 */
271static int color_white(const struct kmemleak_object *object)
272{
273 return object->count != -1 && object->count < object->min_count;
274}
275
276static int color_gray(const struct kmemleak_object *object)
277{
278 return object->min_count != -1 && object->count >= object->min_count;
279}
280
281/*
282 * Objects are considered referenced if their color is gray and they have not
283 * been deleted.
284 */
285static int referenced_object(struct kmemleak_object *object)
286{
287 return (object->flags & OBJECT_ALLOCATED) && color_gray(object);
288}
289
290/*
291 * Objects are considered unreferenced only if their color is white, they have
292 * not be deleted and have a minimum age to avoid false positives caused by
293 * pointers temporarily stored in CPU registers.
294 */
295static int unreferenced_object(struct kmemleak_object *object)
296{
297 return (object->flags & OBJECT_ALLOCATED) && color_white(object) &&
298 time_is_before_eq_jiffies(object->jiffies + jiffies_min_age);
299}
300
301/*
302 * Printing of the (un)referenced objects information, either to the seq file
303 * or to the kernel log. The print_referenced/print_unreferenced functions
304 * must be called with the object->lock held.
305 */
306#define print_helper(seq, x...) do { \
307 struct seq_file *s = (seq); \
308 if (s) \
309 seq_printf(s, x); \
310 else \
311 pr_info(x); \
312} while (0)
313
314static void print_referenced(struct kmemleak_object *object)
315{
Joe Perchesae281062009-06-23 14:40:26 +0100316 pr_info("referenced object 0x%08lx (size %zu)\n",
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100317 object->pointer, object->size);
318}
319
320static void print_unreferenced(struct seq_file *seq,
321 struct kmemleak_object *object)
322{
323 int i;
324
Joe Perchesae281062009-06-23 14:40:26 +0100325 print_helper(seq, "unreferenced object 0x%08lx (size %zu):\n",
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100326 object->pointer, object->size);
327 print_helper(seq, " comm \"%s\", pid %d, jiffies %lu\n",
328 object->comm, object->pid, object->jiffies);
329 print_helper(seq, " backtrace:\n");
330
331 for (i = 0; i < object->trace_len; i++) {
332 void *ptr = (void *)object->trace[i];
333 print_helper(seq, " [<%p>] %pS\n", ptr, ptr);
334 }
335}
336
337/*
338 * Print the kmemleak_object information. This function is used mainly for
339 * debugging special cases when kmemleak operations. It must be called with
340 * the object->lock held.
341 */
342static void dump_object_info(struct kmemleak_object *object)
343{
344 struct stack_trace trace;
345
346 trace.nr_entries = object->trace_len;
347 trace.entries = object->trace;
348
Joe Perchesae281062009-06-23 14:40:26 +0100349 pr_notice("Object 0x%08lx (size %zu):\n",
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100350 object->tree_node.start, object->size);
351 pr_notice(" comm \"%s\", pid %d, jiffies %lu\n",
352 object->comm, object->pid, object->jiffies);
353 pr_notice(" min_count = %d\n", object->min_count);
354 pr_notice(" count = %d\n", object->count);
355 pr_notice(" backtrace:\n");
356 print_stack_trace(&trace, 4);
357}
358
359/*
360 * Look-up a memory block metadata (kmemleak_object) in the priority search
361 * tree based on a pointer value. If alias is 0, only values pointing to the
362 * beginning of the memory block are allowed. The kmemleak_lock must be held
363 * when calling this function.
364 */
365static struct kmemleak_object *lookup_object(unsigned long ptr, int alias)
366{
367 struct prio_tree_node *node;
368 struct prio_tree_iter iter;
369 struct kmemleak_object *object;
370
371 prio_tree_iter_init(&iter, &object_tree_root, ptr, ptr);
372 node = prio_tree_next(&iter);
373 if (node) {
374 object = prio_tree_entry(node, struct kmemleak_object,
375 tree_node);
376 if (!alias && object->pointer != ptr) {
Joe Perchesae281062009-06-23 14:40:26 +0100377 kmemleak_warn("Found object by alias");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100378 object = NULL;
379 }
380 } else
381 object = NULL;
382
383 return object;
384}
385
386/*
387 * Increment the object use_count. Return 1 if successful or 0 otherwise. Note
388 * that once an object's use_count reached 0, the RCU freeing was already
389 * registered and the object should no longer be used. This function must be
390 * called under the protection of rcu_read_lock().
391 */
392static int get_object(struct kmemleak_object *object)
393{
394 return atomic_inc_not_zero(&object->use_count);
395}
396
397/*
398 * RCU callback to free a kmemleak_object.
399 */
400static void free_object_rcu(struct rcu_head *rcu)
401{
402 struct hlist_node *elem, *tmp;
403 struct kmemleak_scan_area *area;
404 struct kmemleak_object *object =
405 container_of(rcu, struct kmemleak_object, rcu);
406
407 /*
408 * Once use_count is 0 (guaranteed by put_object), there is no other
409 * code accessing this object, hence no need for locking.
410 */
411 hlist_for_each_entry_safe(area, elem, tmp, &object->area_list, node) {
412 hlist_del(elem);
413 kmem_cache_free(scan_area_cache, area);
414 }
415 kmem_cache_free(object_cache, object);
416}
417
418/*
419 * Decrement the object use_count. Once the count is 0, free the object using
420 * an RCU callback. Since put_object() may be called via the kmemleak_free() ->
421 * delete_object() path, the delayed RCU freeing ensures that there is no
422 * recursive call to the kernel allocator. Lock-less RCU object_list traversal
423 * is also possible.
424 */
425static void put_object(struct kmemleak_object *object)
426{
427 if (!atomic_dec_and_test(&object->use_count))
428 return;
429
430 /* should only get here after delete_object was called */
431 WARN_ON(object->flags & OBJECT_ALLOCATED);
432
433 call_rcu(&object->rcu, free_object_rcu);
434}
435
436/*
437 * Look up an object in the prio search tree and increase its use_count.
438 */
439static struct kmemleak_object *find_and_get_object(unsigned long ptr, int alias)
440{
441 unsigned long flags;
442 struct kmemleak_object *object = NULL;
443
444 rcu_read_lock();
445 read_lock_irqsave(&kmemleak_lock, flags);
446 if (ptr >= min_addr && ptr < max_addr)
447 object = lookup_object(ptr, alias);
448 read_unlock_irqrestore(&kmemleak_lock, flags);
449
450 /* check whether the object is still available */
451 if (object && !get_object(object))
452 object = NULL;
453 rcu_read_unlock();
454
455 return object;
456}
457
458/*
459 * Create the metadata (struct kmemleak_object) corresponding to an allocated
460 * memory block and add it to the object_list and object_tree_root.
461 */
462static void create_object(unsigned long ptr, size_t size, int min_count,
463 gfp_t gfp)
464{
465 unsigned long flags;
466 struct kmemleak_object *object;
467 struct prio_tree_node *node;
468 struct stack_trace trace;
469
Catalin Marinas216c04b2009-06-17 18:29:02 +0100470 object = kmem_cache_alloc(object_cache, gfp & GFP_KMEMLEAK_MASK);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100471 if (!object) {
Joe Perchesae281062009-06-23 14:40:26 +0100472 kmemleak_stop("Cannot allocate a kmemleak_object structure\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100473 return;
474 }
475
476 INIT_LIST_HEAD(&object->object_list);
477 INIT_LIST_HEAD(&object->gray_list);
478 INIT_HLIST_HEAD(&object->area_list);
479 spin_lock_init(&object->lock);
480 atomic_set(&object->use_count, 1);
481 object->flags = OBJECT_ALLOCATED;
482 object->pointer = ptr;
483 object->size = size;
484 object->min_count = min_count;
485 object->count = -1; /* no color initially */
486 object->jiffies = jiffies;
487
488 /* task information */
489 if (in_irq()) {
490 object->pid = 0;
491 strncpy(object->comm, "hardirq", sizeof(object->comm));
492 } else if (in_softirq()) {
493 object->pid = 0;
494 strncpy(object->comm, "softirq", sizeof(object->comm));
495 } else {
496 object->pid = current->pid;
497 /*
498 * There is a small chance of a race with set_task_comm(),
499 * however using get_task_comm() here may cause locking
500 * dependency issues with current->alloc_lock. In the worst
501 * case, the command line is not correct.
502 */
503 strncpy(object->comm, current->comm, sizeof(object->comm));
504 }
505
506 /* kernel backtrace */
507 trace.max_entries = MAX_TRACE;
508 trace.nr_entries = 0;
509 trace.entries = object->trace;
510 trace.skip = 1;
511 save_stack_trace(&trace);
512 object->trace_len = trace.nr_entries;
513
514 INIT_PRIO_TREE_NODE(&object->tree_node);
515 object->tree_node.start = ptr;
516 object->tree_node.last = ptr + size - 1;
517
518 write_lock_irqsave(&kmemleak_lock, flags);
519 min_addr = min(min_addr, ptr);
520 max_addr = max(max_addr, ptr + size);
521 node = prio_tree_insert(&object_tree_root, &object->tree_node);
522 /*
523 * The code calling the kernel does not yet have the pointer to the
524 * memory block to be able to free it. However, we still hold the
525 * kmemleak_lock here in case parts of the kernel started freeing
526 * random memory blocks.
527 */
528 if (node != &object->tree_node) {
529 unsigned long flags;
530
Joe Perchesae281062009-06-23 14:40:26 +0100531 kmemleak_stop("Cannot insert 0x%lx into the object search tree "
532 "(already existing)\n", ptr);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100533 object = lookup_object(ptr, 1);
534 spin_lock_irqsave(&object->lock, flags);
535 dump_object_info(object);
536 spin_unlock_irqrestore(&object->lock, flags);
537
538 goto out;
539 }
540 list_add_tail_rcu(&object->object_list, &object_list);
541out:
542 write_unlock_irqrestore(&kmemleak_lock, flags);
543}
544
545/*
546 * Remove the metadata (struct kmemleak_object) for a memory block from the
547 * object_list and object_tree_root and decrement its use_count.
548 */
549static void delete_object(unsigned long ptr)
550{
551 unsigned long flags;
552 struct kmemleak_object *object;
553
554 write_lock_irqsave(&kmemleak_lock, flags);
555 object = lookup_object(ptr, 0);
556 if (!object) {
Joe Perchesae281062009-06-23 14:40:26 +0100557 kmemleak_warn("Freeing unknown object at 0x%08lx\n",
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100558 ptr);
559 write_unlock_irqrestore(&kmemleak_lock, flags);
560 return;
561 }
562 prio_tree_remove(&object_tree_root, &object->tree_node);
563 list_del_rcu(&object->object_list);
564 write_unlock_irqrestore(&kmemleak_lock, flags);
565
566 WARN_ON(!(object->flags & OBJECT_ALLOCATED));
567 WARN_ON(atomic_read(&object->use_count) < 1);
568
569 /*
570 * Locking here also ensures that the corresponding memory block
571 * cannot be freed when it is being scanned.
572 */
573 spin_lock_irqsave(&object->lock, flags);
574 if (object->flags & OBJECT_REPORTED)
575 print_referenced(object);
576 object->flags &= ~OBJECT_ALLOCATED;
577 spin_unlock_irqrestore(&object->lock, flags);
578 put_object(object);
579}
580
581/*
582 * Make a object permanently as gray-colored so that it can no longer be
583 * reported as a leak. This is used in general to mark a false positive.
584 */
585static void make_gray_object(unsigned long ptr)
586{
587 unsigned long flags;
588 struct kmemleak_object *object;
589
590 object = find_and_get_object(ptr, 0);
591 if (!object) {
Joe Perchesae281062009-06-23 14:40:26 +0100592 kmemleak_warn("Graying unknown object at 0x%08lx\n", ptr);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100593 return;
594 }
595
596 spin_lock_irqsave(&object->lock, flags);
597 object->min_count = 0;
598 spin_unlock_irqrestore(&object->lock, flags);
599 put_object(object);
600}
601
602/*
603 * Mark the object as black-colored so that it is ignored from scans and
604 * reporting.
605 */
606static void make_black_object(unsigned long ptr)
607{
608 unsigned long flags;
609 struct kmemleak_object *object;
610
611 object = find_and_get_object(ptr, 0);
612 if (!object) {
Joe Perchesae281062009-06-23 14:40:26 +0100613 kmemleak_warn("Blacking unknown object at 0x%08lx\n", ptr);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100614 return;
615 }
616
617 spin_lock_irqsave(&object->lock, flags);
618 object->min_count = -1;
619 spin_unlock_irqrestore(&object->lock, flags);
620 put_object(object);
621}
622
623/*
624 * Add a scanning area to the object. If at least one such area is added,
625 * kmemleak will only scan these ranges rather than the whole memory block.
626 */
627static void add_scan_area(unsigned long ptr, unsigned long offset,
628 size_t length, gfp_t gfp)
629{
630 unsigned long flags;
631 struct kmemleak_object *object;
632 struct kmemleak_scan_area *area;
633
634 object = find_and_get_object(ptr, 0);
635 if (!object) {
Joe Perchesae281062009-06-23 14:40:26 +0100636 kmemleak_warn("Adding scan area to unknown object at 0x%08lx\n",
637 ptr);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100638 return;
639 }
640
Catalin Marinas216c04b2009-06-17 18:29:02 +0100641 area = kmem_cache_alloc(scan_area_cache, gfp & GFP_KMEMLEAK_MASK);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100642 if (!area) {
Joe Perchesae281062009-06-23 14:40:26 +0100643 kmemleak_warn("Cannot allocate a scan area\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100644 goto out;
645 }
646
647 spin_lock_irqsave(&object->lock, flags);
648 if (offset + length > object->size) {
Joe Perchesae281062009-06-23 14:40:26 +0100649 kmemleak_warn("Scan area larger than object 0x%08lx\n", ptr);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100650 dump_object_info(object);
651 kmem_cache_free(scan_area_cache, area);
652 goto out_unlock;
653 }
654
655 INIT_HLIST_NODE(&area->node);
656 area->offset = offset;
657 area->length = length;
658
659 hlist_add_head(&area->node, &object->area_list);
660out_unlock:
661 spin_unlock_irqrestore(&object->lock, flags);
662out:
663 put_object(object);
664}
665
666/*
667 * Set the OBJECT_NO_SCAN flag for the object corresponding to the give
668 * pointer. Such object will not be scanned by kmemleak but references to it
669 * are searched.
670 */
671static void object_no_scan(unsigned long ptr)
672{
673 unsigned long flags;
674 struct kmemleak_object *object;
675
676 object = find_and_get_object(ptr, 0);
677 if (!object) {
Joe Perchesae281062009-06-23 14:40:26 +0100678 kmemleak_warn("Not scanning unknown object at 0x%08lx\n", ptr);
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100679 return;
680 }
681
682 spin_lock_irqsave(&object->lock, flags);
683 object->flags |= OBJECT_NO_SCAN;
684 spin_unlock_irqrestore(&object->lock, flags);
685 put_object(object);
686}
687
688/*
689 * Log an early kmemleak_* call to the early_log buffer. These calls will be
690 * processed later once kmemleak is fully initialized.
691 */
692static void log_early(int op_type, const void *ptr, size_t size,
693 int min_count, unsigned long offset, size_t length)
694{
695 unsigned long flags;
696 struct early_log *log;
697
698 if (crt_early_log >= ARRAY_SIZE(early_log)) {
Catalin Marinasa9d90582009-06-25 10:16:11 +0100699 pr_warning("Early log buffer exceeded\n");
700 kmemleak_disable();
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100701 return;
702 }
703
704 /*
705 * There is no need for locking since the kernel is still in UP mode
706 * at this stage. Disabling the IRQs is enough.
707 */
708 local_irq_save(flags);
709 log = &early_log[crt_early_log];
710 log->op_type = op_type;
711 log->ptr = ptr;
712 log->size = size;
713 log->min_count = min_count;
714 log->offset = offset;
715 log->length = length;
716 crt_early_log++;
717 local_irq_restore(flags);
718}
719
720/*
721 * Memory allocation function callback. This function is called from the
722 * kernel allocators when a new block is allocated (kmem_cache_alloc, kmalloc,
723 * vmalloc etc.).
724 */
725void kmemleak_alloc(const void *ptr, size_t size, int min_count, gfp_t gfp)
726{
727 pr_debug("%s(0x%p, %zu, %d)\n", __func__, ptr, size, min_count);
728
729 if (atomic_read(&kmemleak_enabled) && ptr && !IS_ERR(ptr))
730 create_object((unsigned long)ptr, size, min_count, gfp);
731 else if (atomic_read(&kmemleak_early_log))
732 log_early(KMEMLEAK_ALLOC, ptr, size, min_count, 0, 0);
733}
734EXPORT_SYMBOL_GPL(kmemleak_alloc);
735
736/*
737 * Memory freeing function callback. This function is called from the kernel
738 * allocators when a block is freed (kmem_cache_free, kfree, vfree etc.).
739 */
740void kmemleak_free(const void *ptr)
741{
742 pr_debug("%s(0x%p)\n", __func__, ptr);
743
744 if (atomic_read(&kmemleak_enabled) && ptr && !IS_ERR(ptr))
745 delete_object((unsigned long)ptr);
746 else if (atomic_read(&kmemleak_early_log))
747 log_early(KMEMLEAK_FREE, ptr, 0, 0, 0, 0);
748}
749EXPORT_SYMBOL_GPL(kmemleak_free);
750
751/*
752 * Mark an already allocated memory block as a false positive. This will cause
753 * the block to no longer be reported as leak and always be scanned.
754 */
755void kmemleak_not_leak(const void *ptr)
756{
757 pr_debug("%s(0x%p)\n", __func__, ptr);
758
759 if (atomic_read(&kmemleak_enabled) && ptr && !IS_ERR(ptr))
760 make_gray_object((unsigned long)ptr);
761 else if (atomic_read(&kmemleak_early_log))
762 log_early(KMEMLEAK_NOT_LEAK, ptr, 0, 0, 0, 0);
763}
764EXPORT_SYMBOL(kmemleak_not_leak);
765
766/*
767 * Ignore a memory block. This is usually done when it is known that the
768 * corresponding block is not a leak and does not contain any references to
769 * other allocated memory blocks.
770 */
771void kmemleak_ignore(const void *ptr)
772{
773 pr_debug("%s(0x%p)\n", __func__, ptr);
774
775 if (atomic_read(&kmemleak_enabled) && ptr && !IS_ERR(ptr))
776 make_black_object((unsigned long)ptr);
777 else if (atomic_read(&kmemleak_early_log))
778 log_early(KMEMLEAK_IGNORE, ptr, 0, 0, 0, 0);
779}
780EXPORT_SYMBOL(kmemleak_ignore);
781
782/*
783 * Limit the range to be scanned in an allocated memory block.
784 */
785void kmemleak_scan_area(const void *ptr, unsigned long offset, size_t length,
786 gfp_t gfp)
787{
788 pr_debug("%s(0x%p)\n", __func__, ptr);
789
790 if (atomic_read(&kmemleak_enabled) && ptr && !IS_ERR(ptr))
791 add_scan_area((unsigned long)ptr, offset, length, gfp);
792 else if (atomic_read(&kmemleak_early_log))
793 log_early(KMEMLEAK_SCAN_AREA, ptr, 0, 0, offset, length);
794}
795EXPORT_SYMBOL(kmemleak_scan_area);
796
797/*
798 * Inform kmemleak not to scan the given memory block.
799 */
800void kmemleak_no_scan(const void *ptr)
801{
802 pr_debug("%s(0x%p)\n", __func__, ptr);
803
804 if (atomic_read(&kmemleak_enabled) && ptr && !IS_ERR(ptr))
805 object_no_scan((unsigned long)ptr);
806 else if (atomic_read(&kmemleak_early_log))
807 log_early(KMEMLEAK_NO_SCAN, ptr, 0, 0, 0, 0);
808}
809EXPORT_SYMBOL(kmemleak_no_scan);
810
811/*
812 * Yield the CPU so that other tasks get a chance to run. The yielding is
813 * rate-limited to avoid excessive number of calls to the schedule() function
814 * during memory scanning.
815 */
816static void scan_yield(void)
817{
818 might_sleep();
819
820 if (time_is_before_eq_jiffies(next_scan_yield)) {
821 schedule();
822 next_scan_yield = jiffies + jiffies_scan_yield;
823 }
824}
825
826/*
827 * Memory scanning is a long process and it needs to be interruptable. This
828 * function checks whether such interrupt condition occured.
829 */
830static int scan_should_stop(void)
831{
832 if (!atomic_read(&kmemleak_enabled))
833 return 1;
834
835 /*
836 * This function may be called from either process or kthread context,
837 * hence the need to check for both stop conditions.
838 */
839 if (current->mm)
840 return signal_pending(current);
841 else
842 return kthread_should_stop();
843
844 return 0;
845}
846
847/*
848 * Scan a memory block (exclusive range) for valid pointers and add those
849 * found to the gray list.
850 */
851static void scan_block(void *_start, void *_end,
852 struct kmemleak_object *scanned)
853{
854 unsigned long *ptr;
855 unsigned long *start = PTR_ALIGN(_start, BYTES_PER_POINTER);
856 unsigned long *end = _end - (BYTES_PER_POINTER - 1);
857
858 for (ptr = start; ptr < end; ptr++) {
859 unsigned long flags;
860 unsigned long pointer = *ptr;
861 struct kmemleak_object *object;
862
863 if (scan_should_stop())
864 break;
865
866 /*
867 * When scanning a memory block with a corresponding
868 * kmemleak_object, the CPU yielding is handled in the calling
869 * code since it holds the object->lock to avoid the block
870 * freeing.
871 */
872 if (!scanned)
873 scan_yield();
874
875 object = find_and_get_object(pointer, 1);
876 if (!object)
877 continue;
878 if (object == scanned) {
879 /* self referenced, ignore */
880 put_object(object);
881 continue;
882 }
883
884 /*
885 * Avoid the lockdep recursive warning on object->lock being
886 * previously acquired in scan_object(). These locks are
887 * enclosed by scan_mutex.
888 */
889 spin_lock_irqsave_nested(&object->lock, flags,
890 SINGLE_DEPTH_NESTING);
891 if (!color_white(object)) {
892 /* non-orphan, ignored or new */
893 spin_unlock_irqrestore(&object->lock, flags);
894 put_object(object);
895 continue;
896 }
897
898 /*
899 * Increase the object's reference count (number of pointers
900 * to the memory block). If this count reaches the required
901 * minimum, the object's color will become gray and it will be
902 * added to the gray_list.
903 */
904 object->count++;
905 if (color_gray(object))
906 list_add_tail(&object->gray_list, &gray_list);
907 else
908 put_object(object);
909 spin_unlock_irqrestore(&object->lock, flags);
910 }
911}
912
913/*
914 * Scan a memory block corresponding to a kmemleak_object. A condition is
915 * that object->use_count >= 1.
916 */
917static void scan_object(struct kmemleak_object *object)
918{
919 struct kmemleak_scan_area *area;
920 struct hlist_node *elem;
921 unsigned long flags;
922
923 /*
924 * Once the object->lock is aquired, the corresponding memory block
925 * cannot be freed (the same lock is aquired in delete_object).
926 */
927 spin_lock_irqsave(&object->lock, flags);
928 if (object->flags & OBJECT_NO_SCAN)
929 goto out;
930 if (!(object->flags & OBJECT_ALLOCATED))
931 /* already freed object */
932 goto out;
933 if (hlist_empty(&object->area_list))
934 scan_block((void *)object->pointer,
935 (void *)(object->pointer + object->size), object);
936 else
937 hlist_for_each_entry(area, elem, &object->area_list, node)
938 scan_block((void *)(object->pointer + area->offset),
939 (void *)(object->pointer + area->offset
940 + area->length), object);
941out:
942 spin_unlock_irqrestore(&object->lock, flags);
943}
944
945/*
946 * Scan data sections and all the referenced memory blocks allocated via the
947 * kernel's standard allocators. This function must be called with the
948 * scan_mutex held.
949 */
950static void kmemleak_scan(void)
951{
952 unsigned long flags;
953 struct kmemleak_object *object, *tmp;
954 struct task_struct *task;
955 int i;
956
957 /* prepare the kmemleak_object's */
958 rcu_read_lock();
959 list_for_each_entry_rcu(object, &object_list, object_list) {
960 spin_lock_irqsave(&object->lock, flags);
961#ifdef DEBUG
962 /*
963 * With a few exceptions there should be a maximum of
964 * 1 reference to any object at this point.
965 */
966 if (atomic_read(&object->use_count) > 1) {
Joe Perchesae281062009-06-23 14:40:26 +0100967 pr_debug("object->use_count = %d\n",
Catalin Marinas3c7b4e62009-06-11 13:22:39 +0100968 atomic_read(&object->use_count));
969 dump_object_info(object);
970 }
971#endif
972 /* reset the reference count (whiten the object) */
973 object->count = 0;
974 if (color_gray(object) && get_object(object))
975 list_add_tail(&object->gray_list, &gray_list);
976
977 spin_unlock_irqrestore(&object->lock, flags);
978 }
979 rcu_read_unlock();
980
981 /* data/bss scanning */
982 scan_block(_sdata, _edata, NULL);
983 scan_block(__bss_start, __bss_stop, NULL);
984
985#ifdef CONFIG_SMP
986 /* per-cpu sections scanning */
987 for_each_possible_cpu(i)
988 scan_block(__per_cpu_start + per_cpu_offset(i),
989 __per_cpu_end + per_cpu_offset(i), NULL);
990#endif
991
992 /*
993 * Struct page scanning for each node. The code below is not yet safe
994 * with MEMORY_HOTPLUG.
995 */
996 for_each_online_node(i) {
997 pg_data_t *pgdat = NODE_DATA(i);
998 unsigned long start_pfn = pgdat->node_start_pfn;
999 unsigned long end_pfn = start_pfn + pgdat->node_spanned_pages;
1000 unsigned long pfn;
1001
1002 for (pfn = start_pfn; pfn < end_pfn; pfn++) {
1003 struct page *page;
1004
1005 if (!pfn_valid(pfn))
1006 continue;
1007 page = pfn_to_page(pfn);
1008 /* only scan if page is in use */
1009 if (page_count(page) == 0)
1010 continue;
1011 scan_block(page, page + 1, NULL);
1012 }
1013 }
1014
1015 /*
1016 * Scanning the task stacks may introduce false negatives and it is
1017 * not enabled by default.
1018 */
1019 if (kmemleak_stack_scan) {
1020 read_lock(&tasklist_lock);
1021 for_each_process(task)
1022 scan_block(task_stack_page(task),
1023 task_stack_page(task) + THREAD_SIZE, NULL);
1024 read_unlock(&tasklist_lock);
1025 }
1026
1027 /*
1028 * Scan the objects already referenced from the sections scanned
1029 * above. More objects will be referenced and, if there are no memory
1030 * leaks, all the objects will be scanned. The list traversal is safe
1031 * for both tail additions and removals from inside the loop. The
1032 * kmemleak objects cannot be freed from outside the loop because their
1033 * use_count was increased.
1034 */
1035 object = list_entry(gray_list.next, typeof(*object), gray_list);
1036 while (&object->gray_list != &gray_list) {
1037 scan_yield();
1038
1039 /* may add new objects to the list */
1040 if (!scan_should_stop())
1041 scan_object(object);
1042
1043 tmp = list_entry(object->gray_list.next, typeof(*object),
1044 gray_list);
1045
1046 /* remove the object from the list and release it */
1047 list_del(&object->gray_list);
1048 put_object(object);
1049
1050 object = tmp;
1051 }
1052 WARN_ON(!list_empty(&gray_list));
1053}
1054
1055/*
1056 * Thread function performing automatic memory scanning. Unreferenced objects
1057 * at the end of a memory scan are reported but only the first time.
1058 */
1059static int kmemleak_scan_thread(void *arg)
1060{
1061 static int first_run = 1;
1062
Joe Perchesae281062009-06-23 14:40:26 +01001063 pr_info("Automatic memory scanning thread started\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001064
1065 /*
1066 * Wait before the first scan to allow the system to fully initialize.
1067 */
1068 if (first_run) {
1069 first_run = 0;
1070 ssleep(SECS_FIRST_SCAN);
1071 }
1072
1073 while (!kthread_should_stop()) {
1074 struct kmemleak_object *object;
1075 signed long timeout = jiffies_scan_wait;
1076
1077 mutex_lock(&scan_mutex);
1078
1079 kmemleak_scan();
1080 reported_leaks = 0;
1081
1082 rcu_read_lock();
1083 list_for_each_entry_rcu(object, &object_list, object_list) {
1084 unsigned long flags;
1085
1086 if (reported_leaks >= REPORTS_NR)
1087 break;
1088 spin_lock_irqsave(&object->lock, flags);
1089 if (!(object->flags & OBJECT_REPORTED) &&
1090 unreferenced_object(object)) {
1091 print_unreferenced(NULL, object);
1092 object->flags |= OBJECT_REPORTED;
1093 reported_leaks++;
1094 } else if ((object->flags & OBJECT_REPORTED) &&
1095 referenced_object(object)) {
1096 print_referenced(object);
1097 object->flags &= ~OBJECT_REPORTED;
1098 }
1099 spin_unlock_irqrestore(&object->lock, flags);
1100 }
1101 rcu_read_unlock();
1102
1103 mutex_unlock(&scan_mutex);
1104 /* wait before the next scan */
1105 while (timeout && !kthread_should_stop())
1106 timeout = schedule_timeout_interruptible(timeout);
1107 }
1108
Joe Perchesae281062009-06-23 14:40:26 +01001109 pr_info("Automatic memory scanning thread ended\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001110
1111 return 0;
1112}
1113
1114/*
1115 * Start the automatic memory scanning thread. This function must be called
1116 * with the kmemleak_mutex held.
1117 */
1118void start_scan_thread(void)
1119{
1120 if (scan_thread)
1121 return;
1122 scan_thread = kthread_run(kmemleak_scan_thread, NULL, "kmemleak");
1123 if (IS_ERR(scan_thread)) {
Joe Perchesae281062009-06-23 14:40:26 +01001124 pr_warning("Failed to create the scan thread\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001125 scan_thread = NULL;
1126 }
1127}
1128
1129/*
1130 * Stop the automatic memory scanning thread. This function must be called
1131 * with the kmemleak_mutex held.
1132 */
1133void stop_scan_thread(void)
1134{
1135 if (scan_thread) {
1136 kthread_stop(scan_thread);
1137 scan_thread = NULL;
1138 }
1139}
1140
1141/*
1142 * Iterate over the object_list and return the first valid object at or after
1143 * the required position with its use_count incremented. The function triggers
1144 * a memory scanning when the pos argument points to the first position.
1145 */
1146static void *kmemleak_seq_start(struct seq_file *seq, loff_t *pos)
1147{
1148 struct kmemleak_object *object;
1149 loff_t n = *pos;
1150
1151 if (!n) {
1152 kmemleak_scan();
1153 reported_leaks = 0;
1154 }
1155 if (reported_leaks >= REPORTS_NR)
1156 return NULL;
1157
1158 rcu_read_lock();
1159 list_for_each_entry_rcu(object, &object_list, object_list) {
1160 if (n-- > 0)
1161 continue;
1162 if (get_object(object))
1163 goto out;
1164 }
1165 object = NULL;
1166out:
1167 rcu_read_unlock();
1168 return object;
1169}
1170
1171/*
1172 * Return the next object in the object_list. The function decrements the
1173 * use_count of the previous object and increases that of the next one.
1174 */
1175static void *kmemleak_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1176{
1177 struct kmemleak_object *prev_obj = v;
1178 struct kmemleak_object *next_obj = NULL;
1179 struct list_head *n = &prev_obj->object_list;
1180
1181 ++(*pos);
1182 if (reported_leaks >= REPORTS_NR)
1183 goto out;
1184
1185 rcu_read_lock();
1186 list_for_each_continue_rcu(n, &object_list) {
1187 next_obj = list_entry(n, struct kmemleak_object, object_list);
1188 if (get_object(next_obj))
1189 break;
1190 }
1191 rcu_read_unlock();
1192out:
1193 put_object(prev_obj);
1194 return next_obj;
1195}
1196
1197/*
1198 * Decrement the use_count of the last object required, if any.
1199 */
1200static void kmemleak_seq_stop(struct seq_file *seq, void *v)
1201{
1202 if (v)
1203 put_object(v);
1204}
1205
1206/*
1207 * Print the information for an unreferenced object to the seq file.
1208 */
1209static int kmemleak_seq_show(struct seq_file *seq, void *v)
1210{
1211 struct kmemleak_object *object = v;
1212 unsigned long flags;
1213
1214 spin_lock_irqsave(&object->lock, flags);
1215 if (!unreferenced_object(object))
1216 goto out;
1217 print_unreferenced(seq, object);
1218 reported_leaks++;
1219out:
1220 spin_unlock_irqrestore(&object->lock, flags);
1221 return 0;
1222}
1223
1224static const struct seq_operations kmemleak_seq_ops = {
1225 .start = kmemleak_seq_start,
1226 .next = kmemleak_seq_next,
1227 .stop = kmemleak_seq_stop,
1228 .show = kmemleak_seq_show,
1229};
1230
1231static int kmemleak_open(struct inode *inode, struct file *file)
1232{
1233 int ret = 0;
1234
1235 if (!atomic_read(&kmemleak_enabled))
1236 return -EBUSY;
1237
1238 ret = mutex_lock_interruptible(&kmemleak_mutex);
1239 if (ret < 0)
1240 goto out;
1241 if (file->f_mode & FMODE_READ) {
1242 ret = mutex_lock_interruptible(&scan_mutex);
1243 if (ret < 0)
1244 goto kmemleak_unlock;
1245 ret = seq_open(file, &kmemleak_seq_ops);
1246 if (ret < 0)
1247 goto scan_unlock;
1248 }
1249 return ret;
1250
1251scan_unlock:
1252 mutex_unlock(&scan_mutex);
1253kmemleak_unlock:
1254 mutex_unlock(&kmemleak_mutex);
1255out:
1256 return ret;
1257}
1258
1259static int kmemleak_release(struct inode *inode, struct file *file)
1260{
1261 int ret = 0;
1262
1263 if (file->f_mode & FMODE_READ) {
1264 seq_release(inode, file);
1265 mutex_unlock(&scan_mutex);
1266 }
1267 mutex_unlock(&kmemleak_mutex);
1268
1269 return ret;
1270}
1271
1272/*
1273 * File write operation to configure kmemleak at run-time. The following
1274 * commands can be written to the /sys/kernel/debug/kmemleak file:
1275 * off - disable kmemleak (irreversible)
1276 * stack=on - enable the task stacks scanning
1277 * stack=off - disable the tasks stacks scanning
1278 * scan=on - start the automatic memory scanning thread
1279 * scan=off - stop the automatic memory scanning thread
1280 * scan=... - set the automatic memory scanning period in seconds (0 to
1281 * disable it)
1282 */
1283static ssize_t kmemleak_write(struct file *file, const char __user *user_buf,
1284 size_t size, loff_t *ppos)
1285{
1286 char buf[64];
1287 int buf_size;
1288
1289 if (!atomic_read(&kmemleak_enabled))
1290 return -EBUSY;
1291
1292 buf_size = min(size, (sizeof(buf) - 1));
1293 if (strncpy_from_user(buf, user_buf, buf_size) < 0)
1294 return -EFAULT;
1295 buf[buf_size] = 0;
1296
1297 if (strncmp(buf, "off", 3) == 0)
1298 kmemleak_disable();
1299 else if (strncmp(buf, "stack=on", 8) == 0)
1300 kmemleak_stack_scan = 1;
1301 else if (strncmp(buf, "stack=off", 9) == 0)
1302 kmemleak_stack_scan = 0;
1303 else if (strncmp(buf, "scan=on", 7) == 0)
1304 start_scan_thread();
1305 else if (strncmp(buf, "scan=off", 8) == 0)
1306 stop_scan_thread();
1307 else if (strncmp(buf, "scan=", 5) == 0) {
1308 unsigned long secs;
1309 int err;
1310
1311 err = strict_strtoul(buf + 5, 0, &secs);
1312 if (err < 0)
1313 return err;
1314 stop_scan_thread();
1315 if (secs) {
1316 jiffies_scan_wait = msecs_to_jiffies(secs * 1000);
1317 start_scan_thread();
1318 }
1319 } else
1320 return -EINVAL;
1321
1322 /* ignore the rest of the buffer, only one command at a time */
1323 *ppos += size;
1324 return size;
1325}
1326
1327static const struct file_operations kmemleak_fops = {
1328 .owner = THIS_MODULE,
1329 .open = kmemleak_open,
1330 .read = seq_read,
1331 .write = kmemleak_write,
1332 .llseek = seq_lseek,
1333 .release = kmemleak_release,
1334};
1335
1336/*
1337 * Perform the freeing of the kmemleak internal objects after waiting for any
1338 * current memory scan to complete.
1339 */
1340static int kmemleak_cleanup_thread(void *arg)
1341{
1342 struct kmemleak_object *object;
1343
1344 mutex_lock(&kmemleak_mutex);
1345 stop_scan_thread();
1346 mutex_unlock(&kmemleak_mutex);
1347
1348 mutex_lock(&scan_mutex);
1349 rcu_read_lock();
1350 list_for_each_entry_rcu(object, &object_list, object_list)
1351 delete_object(object->pointer);
1352 rcu_read_unlock();
1353 mutex_unlock(&scan_mutex);
1354
1355 return 0;
1356}
1357
1358/*
1359 * Start the clean-up thread.
1360 */
1361static void kmemleak_cleanup(void)
1362{
1363 struct task_struct *cleanup_thread;
1364
1365 cleanup_thread = kthread_run(kmemleak_cleanup_thread, NULL,
1366 "kmemleak-clean");
1367 if (IS_ERR(cleanup_thread))
Joe Perchesae281062009-06-23 14:40:26 +01001368 pr_warning("Failed to create the clean-up thread\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001369}
1370
1371/*
1372 * Disable kmemleak. No memory allocation/freeing will be traced once this
1373 * function is called. Disabling kmemleak is an irreversible operation.
1374 */
1375static void kmemleak_disable(void)
1376{
1377 /* atomically check whether it was already invoked */
1378 if (atomic_cmpxchg(&kmemleak_error, 0, 1))
1379 return;
1380
1381 /* stop any memory operation tracing */
1382 atomic_set(&kmemleak_early_log, 0);
1383 atomic_set(&kmemleak_enabled, 0);
1384
1385 /* check whether it is too early for a kernel thread */
1386 if (atomic_read(&kmemleak_initialized))
1387 kmemleak_cleanup();
1388
1389 pr_info("Kernel memory leak detector disabled\n");
1390}
1391
1392/*
1393 * Allow boot-time kmemleak disabling (enabled by default).
1394 */
1395static int kmemleak_boot_config(char *str)
1396{
1397 if (!str)
1398 return -EINVAL;
1399 if (strcmp(str, "off") == 0)
1400 kmemleak_disable();
1401 else if (strcmp(str, "on") != 0)
1402 return -EINVAL;
1403 return 0;
1404}
1405early_param("kmemleak", kmemleak_boot_config);
1406
1407/*
Catalin Marinas20301172009-06-17 18:29:04 +01001408 * Kmemleak initialization.
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001409 */
1410void __init kmemleak_init(void)
1411{
1412 int i;
1413 unsigned long flags;
1414
1415 jiffies_scan_yield = msecs_to_jiffies(MSECS_SCAN_YIELD);
1416 jiffies_min_age = msecs_to_jiffies(MSECS_MIN_AGE);
1417 jiffies_scan_wait = msecs_to_jiffies(SECS_SCAN_WAIT * 1000);
1418
1419 object_cache = KMEM_CACHE(kmemleak_object, SLAB_NOLEAKTRACE);
1420 scan_area_cache = KMEM_CACHE(kmemleak_scan_area, SLAB_NOLEAKTRACE);
1421 INIT_PRIO_TREE_ROOT(&object_tree_root);
1422
1423 /* the kernel is still in UP mode, so disabling the IRQs is enough */
1424 local_irq_save(flags);
1425 if (!atomic_read(&kmemleak_error)) {
1426 atomic_set(&kmemleak_enabled, 1);
1427 atomic_set(&kmemleak_early_log, 0);
1428 }
1429 local_irq_restore(flags);
1430
1431 /*
1432 * This is the point where tracking allocations is safe. Automatic
1433 * scanning is started during the late initcall. Add the early logged
1434 * callbacks to the kmemleak infrastructure.
1435 */
1436 for (i = 0; i < crt_early_log; i++) {
1437 struct early_log *log = &early_log[i];
1438
1439 switch (log->op_type) {
1440 case KMEMLEAK_ALLOC:
1441 kmemleak_alloc(log->ptr, log->size, log->min_count,
1442 GFP_KERNEL);
1443 break;
1444 case KMEMLEAK_FREE:
1445 kmemleak_free(log->ptr);
1446 break;
1447 case KMEMLEAK_NOT_LEAK:
1448 kmemleak_not_leak(log->ptr);
1449 break;
1450 case KMEMLEAK_IGNORE:
1451 kmemleak_ignore(log->ptr);
1452 break;
1453 case KMEMLEAK_SCAN_AREA:
1454 kmemleak_scan_area(log->ptr, log->offset, log->length,
1455 GFP_KERNEL);
1456 break;
1457 case KMEMLEAK_NO_SCAN:
1458 kmemleak_no_scan(log->ptr);
1459 break;
1460 default:
1461 WARN_ON(1);
1462 }
1463 }
1464}
1465
1466/*
1467 * Late initialization function.
1468 */
1469static int __init kmemleak_late_init(void)
1470{
1471 struct dentry *dentry;
1472
1473 atomic_set(&kmemleak_initialized, 1);
1474
1475 if (atomic_read(&kmemleak_error)) {
1476 /*
1477 * Some error occured and kmemleak was disabled. There is a
1478 * small chance that kmemleak_disable() was called immediately
1479 * after setting kmemleak_initialized and we may end up with
1480 * two clean-up threads but serialized by scan_mutex.
1481 */
1482 kmemleak_cleanup();
1483 return -ENOMEM;
1484 }
1485
1486 dentry = debugfs_create_file("kmemleak", S_IRUGO, NULL, NULL,
1487 &kmemleak_fops);
1488 if (!dentry)
Joe Perchesae281062009-06-23 14:40:26 +01001489 pr_warning("Failed to create the debugfs kmemleak file\n");
Catalin Marinas3c7b4e62009-06-11 13:22:39 +01001490 mutex_lock(&kmemleak_mutex);
1491 start_scan_thread();
1492 mutex_unlock(&kmemleak_mutex);
1493
1494 pr_info("Kernel memory leak detector initialized\n");
1495
1496 return 0;
1497}
1498late_initcall(kmemleak_late_init);