1 files changed, 222 insertions, 97 deletions
diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c
index ae201b3eda89..5011f4d91e37 100644
--- a/kernel/trace/kmemtrace.c
+++ b/kernel/trace/kmemtrace.c
@@ -6,14 +6,16 @@
 * Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
 */
-#include <linux/dcache.h>
+#include <linux/tracepoint.h>
+#include <linux/seq_file.h>
 #include <linux/debugfs.h>
+#include <linux/dcache.h>
 #include <linux/fs.h>
-#include <linux/seq_file.h>
 #include <trace/kmemtrace.h>
-#include "trace.h"
 #include "trace_output.h"
+#include "trace.h"
 /* Select an alternative, minimalistic output than the original one */
 #define TRACE_KMEM_OPT_MINIMAL  0x1
@@ -25,14 +27,156 @@ static struct tracer_opt kmem_opts[] = {
 };
 static struct tracer_flags kmem_tracer_flags = {
-        .val = 0,
+        .val                    = 0,
-        .opts = kmem_opts
+        .opts                   = kmem_opts
 };
-static bool kmem_tracing_enabled __read_mostly;
 static struct trace_array *kmemtrace_array;
+/* Trace allocations */
+static inline void kmemtrace_alloc(enum kmemtrace_type_id type_id,
+                                   unsigned long call_site,
+                                   const void *ptr,
+                                   size_t bytes_req,
+                                   size_t bytes_alloc,
+                                   gfp_t gfp_flags,
+                                   int node)
+{
+        struct trace_array *tr = kmemtrace_array;
+        struct kmemtrace_alloc_entry *entry;
+        struct ring_buffer_event *event;
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
+        if (!event)
+                return;
+        entry = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type         = TRACE_KMEM_ALLOC;
+        entry->type_id          = type_id;
+        entry->call_site        = call_site;
+        entry->ptr              = ptr;
+        entry->bytes_req        = bytes_req;
+        entry->bytes_alloc      = bytes_alloc;
+        entry->gfp_flags        = gfp_flags;
+        entry->node             = node;
+        ring_buffer_unlock_commit(tr->buffer, event);
+        trace_wake_up();
+}
+static inline void kmemtrace_free(enum kmemtrace_type_id type_id,
+                                  unsigned long call_site,
+                                  const void *ptr)
+{
+        struct trace_array *tr = kmemtrace_array;
+        struct kmemtrace_free_entry *entry;
+        struct ring_buffer_event *event;
+        event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
+        if (!event)
+                return;
+        entry   = ring_buffer_event_data(event);
+        tracing_generic_entry_update(&entry->ent, 0, 0);
+        entry->ent.type         = TRACE_KMEM_FREE;
+        entry->type_id          = type_id;
+        entry->call_site        = call_site;
+        entry->ptr              = ptr;
+        ring_buffer_unlock_commit(tr->buffer, event);
+        trace_wake_up();
+}
+static void kmemtrace_kmalloc(unsigned long call_site,
+                              const void *ptr,
+                              size_t bytes_req,
+                              size_t bytes_alloc,
+                              gfp_t gfp_flags)
+{
+        kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
+                        bytes_req, bytes_alloc, gfp_flags, -1);
+}
+static void kmemtrace_kmem_cache_alloc(unsigned long call_site,
+                                       const void *ptr,
+                                       size_t bytes_req,
+                                       size_t bytes_alloc,
+                                       gfp_t gfp_flags)
+{
+        kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
+                        bytes_req, bytes_alloc, gfp_flags, -1);
+}
+static void kmemtrace_kmalloc_node(unsigned long call_site,
+                                   const void *ptr,
+                                   size_t bytes_req,
+                                   size_t bytes_alloc,
+                                   gfp_t gfp_flags,
+                                   int node)
+{
+        kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
+                        bytes_req, bytes_alloc, gfp_flags, node);
+}
+static void kmemtrace_kmem_cache_alloc_node(unsigned long call_site,
+                                            const void *ptr,
+                                            size_t bytes_req,
+                                            size_t bytes_alloc,
+                                            gfp_t gfp_flags,
+                                            int node)
+{
+        kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
+                        bytes_req, bytes_alloc, gfp_flags, node);
+}
+static void kmemtrace_kfree(unsigned long call_site, const void *ptr)
+{
+        kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr);
+}
+static void kmemtrace_kmem_cache_free(unsigned long call_site, const void *ptr)
+{
+        kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr);
+}
+static int kmemtrace_start_probes(void)
+{
+        int err;
+        err = register_trace_kmalloc(kmemtrace_kmalloc);
+        if (err)
+                return err;
+        err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
+        if (err)
+                return err;
+        err = register_trace_kmalloc_node(kmemtrace_kmalloc_node);
+        if (err)
+                return err;
+        err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
+        if (err)
+                return err;
+        err = register_trace_kfree(kmemtrace_kfree);
+        if (err)
+                return err;
+        err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
+        return err;
+}
+static void kmemtrace_stop_probes(void)
+{
+        unregister_trace_kmalloc(kmemtrace_kmalloc);
+        unregister_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
+        unregister_trace_kmalloc_node(kmemtrace_kmalloc_node);
+        unregister_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
+        unregister_trace_kfree(kmemtrace_kfree);
+        unregister_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
+}
 static int kmem_trace_init(struct trace_array *tr)
 {
        int cpu;
@@ -41,14 +185,14 @@ static int kmem_trace_init(struct trace_array *tr)
        for_each_cpu_mask(cpu, cpu_possible_map)
                tracing_reset(tr, cpu);
-        kmem_tracing_enabled = true;
+        kmemtrace_start_probes();
        return 0;
 }
 static void kmem_trace_reset(struct trace_array *tr)
 {
-        kmem_tracing_enabled = false;
+        kmemtrace_stop_probes();
 }
 static void kmemtrace_headers(struct seq_file *s)
@@ -66,47 +210,84 @@ static void kmemtrace_headers(struct seq_file *s)
 }
 /*
- * The two following functions give the original output from kmemtrace,
+ * The following functions give the original output from kmemtrace,
- * or something close to....perhaps they need some missing things
+ * plus the origin CPU, since reordering occurs in-kernel now.
 */
+#define KMEMTRACE_USER_ALLOC    0
+#define KMEMTRACE_USER_FREE     1
+struct kmemtrace_user_event {
+        u8                      event_id;
+        u8                      type_id;
+        u16                     event_size;
+        u32                     cpu;
+        u64                     timestamp;
+        unsigned long           call_site;
+        unsigned long           ptr;
+};
+struct kmemtrace_user_event_alloc {
+        size_t                  bytes_req;
+        size_t                  bytes_alloc;
+        unsigned                gfp_flags;
+        int                     node;
+};
 static enum print_line_t
-kmemtrace_print_alloc_original(struct trace_iterator *iter,
+kmemtrace_print_alloc_user(struct trace_iterator *iter,
-                                struct kmemtrace_alloc_entry *entry)
+                           struct kmemtrace_alloc_entry *entry)
 {
+        struct kmemtrace_user_event_alloc *ev_alloc;
        struct trace_seq *s = &iter->seq;
-        int ret;
+        struct kmemtrace_user_event *ev;
+        ev = trace_seq_reserve(s, sizeof(*ev));
+        if (!ev)
+                return TRACE_TYPE_PARTIAL_LINE;
-        /* Taken from the old linux/kmemtrace.h */
+        ev->event_id            = KMEMTRACE_USER_ALLOC;
-        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
+        ev->type_id             = entry->type_id;
-          "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
+        ev->event_size          = sizeof(*ev) + sizeof(*ev_alloc);
-           entry->type_id, entry->call_site, (unsigned long) entry->ptr,
+        ev->cpu                 = iter->cpu;
-           (unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
+        ev->timestamp           = iter->ts;
-           (unsigned long) entry->gfp_flags, entry->node);
+        ev->call_site           = entry->call_site;
+        ev->ptr                 = (unsigned long)entry->ptr;
-        if (!ret)
+        ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc));
+        if (!ev_alloc)
                return TRACE_TYPE_PARTIAL_LINE;
+        ev_alloc->bytes_req     = entry->bytes_req;
+        ev_alloc->bytes_alloc   = entry->bytes_alloc;
+        ev_alloc->gfp_flags     = entry->gfp_flags;
+        ev_alloc->node          = entry->node;
        return TRACE_TYPE_HANDLED;
 }
 static enum print_line_t
-kmemtrace_print_free_original(struct trace_iterator *iter,
+kmemtrace_print_free_user(struct trace_iterator *iter,
-                                struct kmemtrace_free_entry *entry)
+                          struct kmemtrace_free_entry *entry)
 {
        struct trace_seq *s = &iter->seq;
-        int ret;
+        struct kmemtrace_user_event *ev;
-        /* Taken from the old linux/kmemtrace.h */
+        ev = trace_seq_reserve(s, sizeof(*ev));
-        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
+        if (!ev)
-           entry->type_id, entry->call_site, (unsigned long) entry->ptr);
-        if (!ret)
                return TRACE_TYPE_PARTIAL_LINE;
+        ev->event_id            = KMEMTRACE_USER_FREE;
+        ev->type_id             = entry->type_id;
+        ev->event_size          = sizeof(*ev);
+        ev->cpu                 = iter->cpu;
+        ev->timestamp           = iter->ts;
+        ev->call_site           = entry->call_site;
+        ev->ptr                 = (unsigned long)entry->ptr;
        return TRACE_TYPE_HANDLED;
 }
 /* The two other following provide a more minimalistic output */
 static enum print_line_t
 kmemtrace_print_alloc_compress(struct trace_iterator *iter,
@@ -178,7 +359,7 @@ kmemtrace_print_alloc_compress(struct trace_iterator *iter,
 static enum print_line_t
 kmemtrace_print_free_compress(struct trace_iterator *iter,
-                                struct kmemtrace_free_entry *entry)
+                              struct kmemtrace_free_entry *entry)
 {
        struct trace_seq *s = &iter->seq;
        int ret;
@@ -239,20 +420,22 @@ static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
        switch (entry->type) {
        case TRACE_KMEM_ALLOC: {
                struct kmemtrace_alloc_entry *field;
                trace_assign_type(field, entry);
                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
                        return kmemtrace_print_alloc_compress(iter, field);
                else
-                        return kmemtrace_print_alloc_original(iter, field);
+                        return kmemtrace_print_alloc_user(iter, field);
        }
        case TRACE_KMEM_FREE: {
                struct kmemtrace_free_entry *field;
                trace_assign_type(field, entry);
                if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
                        return kmemtrace_print_free_compress(iter, field);
                else
-                        return kmemtrace_print_free_original(iter, field);
+                        return kmemtrace_print_free_user(iter, field);
        }
        default:
@@ -260,70 +443,13 @@ static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
        }
 }
-/* Trace allocations */
-void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
-                             unsigned long call_site,
-                             const void *ptr,
-                             size_t bytes_req,
-                             size_t bytes_alloc,
-                             gfp_t gfp_flags,
-                             int node)
-{
-        struct ring_buffer_event *event;
-        struct kmemtrace_alloc_entry *entry;
-        struct trace_array *tr = kmemtrace_array;
-        if (!kmem_tracing_enabled)
-                return;
-        event = trace_buffer_lock_reserve(tr, TRACE_KMEM_ALLOC,
-                                          sizeof(*entry), 0, 0);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->call_site = call_site;
-        entry->ptr = ptr;
-        entry->bytes_req = bytes_req;
-        entry->bytes_alloc = bytes_alloc;
-        entry->gfp_flags = gfp_flags;
-        entry->node     =       node;
-        trace_buffer_unlock_commit(tr, event, 0, 0);
-}
-EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
-void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
-                       unsigned long call_site,
-                       const void *ptr)
-{
-        struct ring_buffer_event *event;
-        struct kmemtrace_free_entry *entry;
-        struct trace_array *tr = kmemtrace_array;
-        if (!kmem_tracing_enabled)
-                return;
-        event = trace_buffer_lock_reserve(tr, TRACE_KMEM_FREE,
-                                          sizeof(*entry), 0, 0);
-        if (!event)
-                return;
-        entry   = ring_buffer_event_data(event);
-        entry->type_id  = type_id;
-        entry->call_site = call_site;
-        entry->ptr = ptr;
-        trace_buffer_unlock_commit(tr, event, 0, 0);
-}
-EXPORT_SYMBOL(kmemtrace_mark_free);
 static struct tracer kmem_tracer __read_mostly = {
-        .name           = "kmemtrace",
+        .name                   = "kmemtrace",
-        .init           = kmem_trace_init,
+        .init                   = kmem_trace_init,
-        .reset          = kmem_trace_reset,
+        .reset                  = kmem_trace_reset,
-        .print_line     = kmemtrace_print_line,
+        .print_line             = kmemtrace_print_line,
-        .print_header = kmemtrace_headers,
+        .print_header           = kmemtrace_headers,
-        .flags          = &kmem_tracer_flags
+        .flags                  = &kmem_tracer_flags
 };
 void kmemtrace_init(void)
@@ -335,5 +461,4 @@ static int __init init_kmem_tracer(void)
 {
        return register_tracer(&kmem_tracer);
 }
 device_initcall(init_kmem_tracer);

diff --git a/kernel/trace/kmemtrace.c b/kernel/trace/kmemtrace.c index ae201b3eda89..5011f4d91e37 100644 --- a/kernel/trace/kmemtrace.c +++ b/kernel/trace/kmemtrace.c
@@ -6,14 +6,16 @@
6	* Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>	6	* Copyright (C) 2008 Frederic Weisbecker <fweisbec@gmail.com>
7	*/	7	*/
8		8
9	#include <linux/dcache.h>	9	#include <linux/tracepoint.h>
		10	#include <linux/seq_file.h>
10	#include <linux/debugfs.h>	11	#include <linux/debugfs.h>
		12	#include <linux/dcache.h>
11	#include <linux/fs.h>	13	#include <linux/fs.h>
12	#include <linux/seq_file.h>	14
13	#include <trace/kmemtrace.h>	15	#include <trace/kmemtrace.h>
14		16
15	#include "trace.h"
16	#include "trace_output.h"	17	#include "trace_output.h"
		18	#include "trace.h"
17		19
18	/* Select an alternative, minimalistic output than the original one */	20	/* Select an alternative, minimalistic output than the original one */
19	#define TRACE_KMEM_OPT_MINIMAL 0x1	21	#define TRACE_KMEM_OPT_MINIMAL 0x1
@@ -25,14 +27,156 @@ static struct tracer_opt kmem_opts[] = {
25	};	27	};
26		28
27	static struct tracer_flags kmem_tracer_flags = {	29	static struct tracer_flags kmem_tracer_flags = {
28	.val = 0,	30	.val = 0,
29	.opts = kmem_opts	31	.opts = kmem_opts
30	};	32	};
31		33
32
33	static bool kmem_tracing_enabled __read_mostly;
34	static struct trace_array *kmemtrace_array;	34	static struct trace_array *kmemtrace_array;
35		35
		36	/* Trace allocations */
		37	static inline void kmemtrace_alloc(enum kmemtrace_type_id type_id,
		38	unsigned long call_site,
		39	const void *ptr,
		40	size_t bytes_req,
		41	size_t bytes_alloc,
		42	gfp_t gfp_flags,
		43	int node)
		44	{
		45	struct trace_array *tr = kmemtrace_array;
		46	struct kmemtrace_alloc_entry *entry;
		47	struct ring_buffer_event *event;
		48
		49	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
		50	if (!event)
		51	return;
		52
		53	entry = ring_buffer_event_data(event);
		54	tracing_generic_entry_update(&entry->ent, 0, 0);
		55
		56	entry->ent.type = TRACE_KMEM_ALLOC;
		57	entry->type_id = type_id;
		58	entry->call_site = call_site;
		59	entry->ptr = ptr;
		60	entry->bytes_req = bytes_req;
		61	entry->bytes_alloc = bytes_alloc;
		62	entry->gfp_flags = gfp_flags;
		63	entry->node = node;
		64
		65	ring_buffer_unlock_commit(tr->buffer, event);
		66
		67	trace_wake_up();
		68	}
		69
		70	static inline void kmemtrace_free(enum kmemtrace_type_id type_id,
		71	unsigned long call_site,
		72	const void *ptr)
		73	{
		74	struct trace_array *tr = kmemtrace_array;
		75	struct kmemtrace_free_entry *entry;
		76	struct ring_buffer_event *event;
		77
		78	event = ring_buffer_lock_reserve(tr->buffer, sizeof(*entry));
		79	if (!event)
		80	return;
		81	entry = ring_buffer_event_data(event);
		82	tracing_generic_entry_update(&entry->ent, 0, 0);
		83
		84	entry->ent.type = TRACE_KMEM_FREE;
		85	entry->type_id = type_id;
		86	entry->call_site = call_site;
		87	entry->ptr = ptr;
		88
		89	ring_buffer_unlock_commit(tr->buffer, event);
		90
		91	trace_wake_up();
		92	}
		93
		94	static void kmemtrace_kmalloc(unsigned long call_site,
		95	const void *ptr,
		96	size_t bytes_req,
		97	size_t bytes_alloc,
		98	gfp_t gfp_flags)
		99	{
		100	kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
		101	bytes_req, bytes_alloc, gfp_flags, -1);
		102	}
		103
		104	static void kmemtrace_kmem_cache_alloc(unsigned long call_site,
		105	const void *ptr,
		106	size_t bytes_req,
		107	size_t bytes_alloc,
		108	gfp_t gfp_flags)
		109	{
		110	kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
		111	bytes_req, bytes_alloc, gfp_flags, -1);
		112	}
		113
		114	static void kmemtrace_kmalloc_node(unsigned long call_site,
		115	const void *ptr,
		116	size_t bytes_req,
		117	size_t bytes_alloc,
		118	gfp_t gfp_flags,
		119	int node)
		120	{
		121	kmemtrace_alloc(KMEMTRACE_TYPE_KMALLOC, call_site, ptr,
		122	bytes_req, bytes_alloc, gfp_flags, node);
		123	}
		124
		125	static void kmemtrace_kmem_cache_alloc_node(unsigned long call_site,
		126	const void *ptr,
		127	size_t bytes_req,
		128	size_t bytes_alloc,
		129	gfp_t gfp_flags,
		130	int node)
		131	{
		132	kmemtrace_alloc(KMEMTRACE_TYPE_CACHE, call_site, ptr,
		133	bytes_req, bytes_alloc, gfp_flags, node);
		134	}
		135
		136	static void kmemtrace_kfree(unsigned long call_site, const void *ptr)
		137	{
		138	kmemtrace_free(KMEMTRACE_TYPE_KMALLOC, call_site, ptr);
		139	}
		140
		141	static void kmemtrace_kmem_cache_free(unsigned long call_site, const void *ptr)
		142	{
		143	kmemtrace_free(KMEMTRACE_TYPE_CACHE, call_site, ptr);
		144	}
		145
		146	static int kmemtrace_start_probes(void)
		147	{
		148	int err;
		149
		150	err = register_trace_kmalloc(kmemtrace_kmalloc);
		151	if (err)
		152	return err;
		153	err = register_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
		154	if (err)
		155	return err;
		156	err = register_trace_kmalloc_node(kmemtrace_kmalloc_node);
		157	if (err)
		158	return err;
		159	err = register_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
		160	if (err)
		161	return err;
		162	err = register_trace_kfree(kmemtrace_kfree);
		163	if (err)
		164	return err;
		165	err = register_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
		166
		167	return err;
		168	}
		169
		170	static void kmemtrace_stop_probes(void)
		171	{
		172	unregister_trace_kmalloc(kmemtrace_kmalloc);
		173	unregister_trace_kmem_cache_alloc(kmemtrace_kmem_cache_alloc);
		174	unregister_trace_kmalloc_node(kmemtrace_kmalloc_node);
		175	unregister_trace_kmem_cache_alloc_node(kmemtrace_kmem_cache_alloc_node);
		176	unregister_trace_kfree(kmemtrace_kfree);
		177	unregister_trace_kmem_cache_free(kmemtrace_kmem_cache_free);
		178	}
		179
36	static int kmem_trace_init(struct trace_array *tr)	180	static int kmem_trace_init(struct trace_array *tr)
37	{	181	{
38	int cpu;	182	int cpu;
@@ -41,14 +185,14 @@ static int kmem_trace_init(struct trace_array *tr)
41	for_each_cpu_mask(cpu, cpu_possible_map)	185	for_each_cpu_mask(cpu, cpu_possible_map)
42	tracing_reset(tr, cpu);	186	tracing_reset(tr, cpu);
43		187
44	kmem_tracing_enabled = true;	188	kmemtrace_start_probes();
45		189
46	return 0;	190	return 0;
47	}	191	}
48		192
49	static void kmem_trace_reset(struct trace_array *tr)	193	static void kmem_trace_reset(struct trace_array *tr)
50	{	194	{
51	kmem_tracing_enabled = false;	195	kmemtrace_stop_probes();
52	}	196	}
53		197
54	static void kmemtrace_headers(struct seq_file *s)	198	static void kmemtrace_headers(struct seq_file *s)
@@ -66,47 +210,84 @@ static void kmemtrace_headers(struct seq_file *s)
66	}	210	}
67		211
68	/*	212	/*
69	* The two following functions give the original output from kmemtrace,	213	* The following functions give the original output from kmemtrace,
70	* or something close to....perhaps they need some missing things	214	* plus the origin CPU, since reordering occurs in-kernel now.
71	*/	215	*/
		216
		217	#define KMEMTRACE_USER_ALLOC 0
		218	#define KMEMTRACE_USER_FREE 1
		219
		220	struct kmemtrace_user_event {
		221	u8 event_id;
		222	u8 type_id;
		223	u16 event_size;
		224	u32 cpu;
		225	u64 timestamp;
		226	unsigned long call_site;
		227	unsigned long ptr;
		228	};
		229
		230	struct kmemtrace_user_event_alloc {
		231	size_t bytes_req;
		232	size_t bytes_alloc;
		233	unsigned gfp_flags;
		234	int node;
		235	};
		236
72	static enum print_line_t	237	static enum print_line_t
73	kmemtrace_print_alloc_original(struct trace_iterator *iter,	238	kmemtrace_print_alloc_user(struct trace_iterator *iter,
74	struct kmemtrace_alloc_entry *entry)	239	struct kmemtrace_alloc_entry *entry)
75	{	240	{
		241	struct kmemtrace_user_event_alloc *ev_alloc;
76	struct trace_seq *s = &iter->seq;	242	struct trace_seq *s = &iter->seq;
77	int ret;	243	struct kmemtrace_user_event *ev;
		244
		245	ev = trace_seq_reserve(s, sizeof(*ev));
		246	if (!ev)
		247	return TRACE_TYPE_PARTIAL_LINE;
78		248
79	/* Taken from the old linux/kmemtrace.h */	249	ev->event_id = KMEMTRACE_USER_ALLOC;
80	ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "	250	ev->type_id = entry->type_id;
81	"bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",	251	ev->event_size = sizeof(ev) + sizeof(ev_alloc);
82	entry->type_id, entry->call_site, (unsigned long) entry->ptr,	252	ev->cpu = iter->cpu;
83	(unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,	253	ev->timestamp = iter->ts;
84	(unsigned long) entry->gfp_flags, entry->node);	254	ev->call_site = entry->call_site;
		255	ev->ptr = (unsigned long)entry->ptr;
85		256
86	if (!ret)	257	ev_alloc = trace_seq_reserve(s, sizeof(*ev_alloc));
		258	if (!ev_alloc)
87	return TRACE_TYPE_PARTIAL_LINE;	259	return TRACE_TYPE_PARTIAL_LINE;
88		260
		261	ev_alloc->bytes_req = entry->bytes_req;
		262	ev_alloc->bytes_alloc = entry->bytes_alloc;
		263	ev_alloc->gfp_flags = entry->gfp_flags;
		264	ev_alloc->node = entry->node;
		265
89	return TRACE_TYPE_HANDLED;	266	return TRACE_TYPE_HANDLED;
90	}	267	}
91		268
92	static enum print_line_t	269	static enum print_line_t
93	kmemtrace_print_free_original(struct trace_iterator *iter,	270	kmemtrace_print_free_user(struct trace_iterator *iter,
94	struct kmemtrace_free_entry *entry)	271	struct kmemtrace_free_entry *entry)
95	{	272	{
96	struct trace_seq *s = &iter->seq;	273	struct trace_seq *s = &iter->seq;
97	int ret;	274	struct kmemtrace_user_event *ev;
98		275
99	/* Taken from the old linux/kmemtrace.h */	276	ev = trace_seq_reserve(s, sizeof(*ev));
100	ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",	277	if (!ev)
101	entry->type_id, entry->call_site, (unsigned long) entry->ptr);
102
103	if (!ret)
104	return TRACE_TYPE_PARTIAL_LINE;	278	return TRACE_TYPE_PARTIAL_LINE;
105		279
		280	ev->event_id = KMEMTRACE_USER_FREE;
		281	ev->type_id = entry->type_id;
		282	ev->event_size = sizeof(*ev);
		283	ev->cpu = iter->cpu;
		284	ev->timestamp = iter->ts;
		285	ev->call_site = entry->call_site;
		286	ev->ptr = (unsigned long)entry->ptr;
		287
106	return TRACE_TYPE_HANDLED;	288	return TRACE_TYPE_HANDLED;
107	}	289	}
108		290
109
110	/* The two other following provide a more minimalistic output */	291	/* The two other following provide a more minimalistic output */
111	static enum print_line_t	292	static enum print_line_t
112	kmemtrace_print_alloc_compress(struct trace_iterator *iter,	293	kmemtrace_print_alloc_compress(struct trace_iterator *iter,
@@ -178,7 +359,7 @@ kmemtrace_print_alloc_compress(struct trace_iterator *iter,
178		359
179	static enum print_line_t	360	static enum print_line_t
180	kmemtrace_print_free_compress(struct trace_iterator *iter,	361	kmemtrace_print_free_compress(struct trace_iterator *iter,
181	struct kmemtrace_free_entry *entry)	362	struct kmemtrace_free_entry *entry)
182	{	363	{
183	struct trace_seq *s = &iter->seq;	364	struct trace_seq *s = &iter->seq;
184	int ret;	365	int ret;
@@ -239,20 +420,22 @@ static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
239	switch (entry->type) {	420	switch (entry->type) {
240	case TRACE_KMEM_ALLOC: {	421	case TRACE_KMEM_ALLOC: {
241	struct kmemtrace_alloc_entry *field;	422	struct kmemtrace_alloc_entry *field;
		423
242	trace_assign_type(field, entry);	424	trace_assign_type(field, entry);
243	if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)	425	if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
244	return kmemtrace_print_alloc_compress(iter, field);	426	return kmemtrace_print_alloc_compress(iter, field);
245	else	427	else
246	return kmemtrace_print_alloc_original(iter, field);	428	return kmemtrace_print_alloc_user(iter, field);
247	}	429	}
248		430
249	case TRACE_KMEM_FREE: {	431	case TRACE_KMEM_FREE: {
250	struct kmemtrace_free_entry *field;	432	struct kmemtrace_free_entry *field;
		433
251	trace_assign_type(field, entry);	434	trace_assign_type(field, entry);
252	if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)	435	if (kmem_tracer_flags.val & TRACE_KMEM_OPT_MINIMAL)
253	return kmemtrace_print_free_compress(iter, field);	436	return kmemtrace_print_free_compress(iter, field);
254	else	437	else
255	return kmemtrace_print_free_original(iter, field);	438	return kmemtrace_print_free_user(iter, field);
256	}	439	}
257		440
258	default:	441	default:
@@ -260,70 +443,13 @@ static enum print_line_t kmemtrace_print_line(struct trace_iterator *iter)
260	}	443	}
261	}	444	}
262		445
263	/* Trace allocations */
264	void kmemtrace_mark_alloc_node(enum kmemtrace_type_id type_id,
265	unsigned long call_site,
266	const void *ptr,
267	size_t bytes_req,
268	size_t bytes_alloc,
269	gfp_t gfp_flags,
270	int node)
271	{
272	struct ring_buffer_event *event;
273	struct kmemtrace_alloc_entry *entry;
274	struct trace_array *tr = kmemtrace_array;
275
276	if (!kmem_tracing_enabled)
277	return;
278
279	event = trace_buffer_lock_reserve(tr, TRACE_KMEM_ALLOC,
280	sizeof(*entry), 0, 0);
281	if (!event)
282	return;
283	entry = ring_buffer_event_data(event);
284
285	entry->call_site = call_site;
286	entry->ptr = ptr;
287	entry->bytes_req = bytes_req;
288	entry->bytes_alloc = bytes_alloc;
289	entry->gfp_flags = gfp_flags;
290	entry->node = node;
291
292	trace_buffer_unlock_commit(tr, event, 0, 0);
293	}
294	EXPORT_SYMBOL(kmemtrace_mark_alloc_node);
295
296	void kmemtrace_mark_free(enum kmemtrace_type_id type_id,
297	unsigned long call_site,
298	const void *ptr)
299	{
300	struct ring_buffer_event *event;
301	struct kmemtrace_free_entry *entry;
302	struct trace_array *tr = kmemtrace_array;
303
304	if (!kmem_tracing_enabled)
305	return;
306
307	event = trace_buffer_lock_reserve(tr, TRACE_KMEM_FREE,
308	sizeof(*entry), 0, 0);
309	if (!event)
310	return;
311	entry = ring_buffer_event_data(event);
312	entry->type_id = type_id;
313	entry->call_site = call_site;
314	entry->ptr = ptr;
315
316	trace_buffer_unlock_commit(tr, event, 0, 0);
317	}
318	EXPORT_SYMBOL(kmemtrace_mark_free);
319
320	static struct tracer kmem_tracer __read_mostly = {	446	static struct tracer kmem_tracer __read_mostly = {
321	.name = "kmemtrace",	447	.name = "kmemtrace",
322	.init = kmem_trace_init,	448	.init = kmem_trace_init,
323	.reset = kmem_trace_reset,	449	.reset = kmem_trace_reset,
324	.print_line = kmemtrace_print_line,	450	.print_line = kmemtrace_print_line,
325	.print_header = kmemtrace_headers,	451	.print_header = kmemtrace_headers,
326	.flags = &kmem_tracer_flags	452	.flags = &kmem_tracer_flags
327	};	453	};
328		454
329	void kmemtrace_init(void)	455	void kmemtrace_init(void)
@@ -335,5 +461,4 @@ static int __init init_kmem_tracer(void)
335	{	461	{
336	return register_tracer(&kmem_tracer);	462	return register_tracer(&kmem_tracer);
337	}	463	}
338
339	device_initcall(init_kmem_tracer);	464	device_initcall(init_kmem_tracer);