Merge branch 'kmemtrace-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip

* 'kmemtrace-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/linux-2.6-tip:
  kmemtrace: trace kfree() calls with NULL or zero-length objects
  kmemtrace: small cleanups
  kmemtrace: restore original tracing data binary format, improve ABI
  kmemtrace: kmemtrace_alloc() must fill type_id
  kmemtrace: use tracepoints
  kmemtrace, rcu: don't include unnecessary headers, allow kmemtrace w/ tracepoints
  kmemtrace, rcu: fix rcupreempt.c data structure dependencies
  kmemtrace, rcu: fix rcu_tree_trace.c data structure dependencies
  kmemtrace, rcu: fix linux/rcutree.h and linux/rcuclassic.h dependencies
  kmemtrace, mm: fix slab.h dependency problem in mm/failslab.c
  kmemtrace, kbuild: fix slab.h dependency problem in lib/decompress_unlzma.c
  kmemtrace, kbuild: fix slab.h dependency problem in lib/decompress_bunzip2.c
  kmemtrace, kbuild: fix slab.h dependency problem in lib/decompress_inflate.c
  kmemtrace, squashfs: fix slab.h dependency problem in squasfs
  kmemtrace, befs: fix slab.h dependency problem
  kmemtrace, security: fix linux/key.h header file dependencies
  kmemtrace, fs: fix linux/fdtable.h header file dependencies
  kmemtrace, fs: uninline simple_transaction_set()
  kmemtrace, fs, security: move alloc_secdata() and free_secdata() to linux/security.h

7 files changed, 325 insertions, 103 deletions

diff --git a/kernel/rcuclassic.c b/kernel/rcuclassic.c
index 654c640a6b9c..0f2b0b311304 100644
--- a/kernel/rcuclassic.c
+++ b/kernel/rcuclassic.c
@@ -65,6 +65,7 @@ static struct rcu_ctrlblk rcu_ctrlblk = {
         .lock = __SPIN_LOCK_UNLOCKED(&rcu_ctrlblk.lock),
         .cpumask = CPU_BITS_NONE,
 };
+
 static struct rcu_ctrlblk rcu_bh_ctrlblk = {
         .cur = -300,
         .completed = -300,
@@ -73,8 +74,26 @@ static struct rcu_ctrlblk rcu_bh_ctrlblk = {
         .cpumask = CPU_BITS_NONE,
 };
 
-DEFINE_PER_CPU(struct rcu_data, rcu_data) = { 0L };
-DEFINE_PER_CPU(struct rcu_data, rcu_bh_data) = { 0L };
+static DEFINE_PER_CPU(struct rcu_data, rcu_data);
+static DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
+
+/*
+ * Increment the quiescent state counter.
+ * The counter is a bit degenerated: We do not need to know
+ * how many quiescent states passed, just if there was at least
+ * one since the start of the grace period. Thus just a flag.
+ */
+void rcu_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+        rdp->passed_quiesc = 1;
+}
+
+void rcu_bh_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+        rdp->passed_quiesc = 1;
+}
 
 static int blimit = 10;
 static int qhimark = 10000;
diff --git a/kernel/rcupreempt.c b/kernel/rcupreempt.c
index 5d59e850fb71..ce97a4df64d3 100644
--- a/kernel/rcupreempt.c
+++ b/kernel/rcupreempt.c
@@ -147,7 +147,51 @@ struct rcu_ctrlblk {
         wait_queue_head_t sched_wq;     /* Place for rcu_sched to sleep. */
 };
 
+struct rcu_dyntick_sched {
+        int dynticks;
+        int dynticks_snap;
+        int sched_qs;
+        int sched_qs_snap;
+        int sched_dynticks_snap;
+};
+
+static DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_dyntick_sched, rcu_dyntick_sched) = {
+        .dynticks = 1,
+};
+
+void rcu_qsctr_inc(int cpu)
+{
+        struct rcu_dyntick_sched *rdssp = &per_cpu(rcu_dyntick_sched, cpu);
+
+        rdssp->sched_qs++;
+}
+
+#ifdef CONFIG_NO_HZ
+
+void rcu_enter_nohz(void)
+{
+        static DEFINE_RATELIMIT_STATE(rs, 10 * HZ, 1);
+
+        smp_mb(); /* CPUs seeing ++ must see prior RCU read-side crit sects */
+        __get_cpu_var(rcu_dyntick_sched).dynticks++;
+        WARN_ON_RATELIMIT(__get_cpu_var(rcu_dyntick_sched).dynticks & 0x1, &rs);
+}
+
+void rcu_exit_nohz(void)
+{
+        static DEFINE_RATELIMIT_STATE(rs, 10 * HZ, 1);
+
+        __get_cpu_var(rcu_dyntick_sched).dynticks++;
+        smp_mb(); /* CPUs seeing ++ must see later RCU read-side crit sects */
+        WARN_ON_RATELIMIT(!(__get_cpu_var(rcu_dyntick_sched).dynticks & 0x1),
+                                &rs);
+}
+
+#endif /* CONFIG_NO_HZ */
+
+
 static DEFINE_PER_CPU(struct rcu_data, rcu_data);
+
 static struct rcu_ctrlblk rcu_ctrlblk = {
         .fliplock = __SPIN_LOCK_UNLOCKED(rcu_ctrlblk.fliplock),
         .completed = 0,
@@ -427,10 +471,6 @@ static void __rcu_advance_callbacks(struct rcu_data *rdp)
         }
 }
 
-DEFINE_PER_CPU_SHARED_ALIGNED(struct rcu_dyntick_sched, rcu_dyntick_sched) = {
-        .dynticks = 1,
-};
-
 #ifdef CONFIG_NO_HZ
 static DEFINE_PER_CPU(int, rcu_update_flag);
 
diff --git a/kernel/rcutree.c b/kernel/rcutree.c
index 97ce31579ec0..7f3266922572 100644
--- a/kernel/rcutree.c
+++ b/kernel/rcutree.c
@@ -78,6 +78,26 @@ DEFINE_PER_CPU(struct rcu_data, rcu_data);
 struct rcu_state rcu_bh_state = RCU_STATE_INITIALIZER(rcu_bh_state);
 DEFINE_PER_CPU(struct rcu_data, rcu_bh_data);
 
+/*
+ * Increment the quiescent state counter.
+ * The counter is a bit degenerated: We do not need to know
+ * how many quiescent states passed, just if there was at least
+ * one since the start of the grace period. Thus just a flag.
+ */
+void rcu_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_data, cpu);
+        rdp->passed_quiesc = 1;
+        rdp->passed_quiesc_completed = rdp->completed;
+}
+
+void rcu_bh_qsctr_inc(int cpu)
+{
+        struct rcu_data *rdp = &per_cpu(rcu_bh_data, cpu);
+        rdp->passed_quiesc = 1;
+        rdp->passed_quiesc_completed = rdp->completed;
+}
+
 #ifdef CONFIG_NO_HZ
 DEFINE_PER_CPU(struct rcu_dynticks, rcu_dynticks) = {
         .dynticks_nesting = 1,
diff --git a/kernel/rcutree.h b/kernel/rcutree.h
new file mode 100644
index 000000000000..5e872bbf07f5
--- /dev/null
+++ b/kernel/rcutree.h
@@ -0,0 +1,10 @@
+
+/*
+ * RCU implementation internal declarations:
+ */
+extern struct rcu_state rcu_state;
+DECLARE_PER_CPU(struct rcu_data, rcu_data);
+
+extern struct rcu_state rcu_bh_state;
+DECLARE_PER_CPU(struct rcu_data, rcu_bh_data);
+
diff --git a/kernel/rcutree_trace.c b/kernel/rcutree_trace.c
index d6db3e837826..4ee954f6a8d5 100644
--- a/kernel/rcutree_trace.c
+++ b/kernel/rcutree_trace.c
@@ -43,6 +43,8 @@
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
 
+#include "rcutree.h"
+
 static void print_one_rcu_data(struct seq_file *m, struct rcu_data *rdp)
 {
         if (!rdp->beenonline)
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,
-        .opts = kmem_opts
+        .val                    = 0,
+        .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,
- * or something close to....perhaps they need some missing things
+ * The following functions give the original output from kmemtrace,
+ * 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,
-                                struct kmemtrace_alloc_entry *entry)
+kmemtrace_print_alloc_user(struct trace_iterator *iter,
+                           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 */
-        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu "
-          "bytes_req %lu bytes_alloc %lu gfp_flags %lu node %d\n",
-           entry->type_id, entry->call_site, (unsigned long) entry->ptr,
-           (unsigned long) entry->bytes_req, (unsigned long) entry->bytes_alloc,
-           (unsigned long) entry->gfp_flags, entry->node);
+        ev->event_id            = KMEMTRACE_USER_ALLOC;
+        ev->type_id             = entry->type_id;
+        ev->event_size          = sizeof(*ev) + sizeof(*ev_alloc);
+        ev->cpu                 = iter->cpu;
+        ev->timestamp           = iter->ts;
+        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,
-                                struct kmemtrace_free_entry *entry)
+kmemtrace_print_free_user(struct trace_iterator *iter,
+                          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 */
-        ret = trace_seq_printf(s, "type_id %d call_site %lu ptr %lu\n",
-           entry->type_id, entry->call_site, (unsigned long) entry->ptr);
-
-        if (!ret)
+        ev = trace_seq_reserve(s, sizeof(*ev));
+        if (!ev)
                 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",
-        .init           = kmem_trace_init,
-        .reset          = kmem_trace_reset,
-        .print_line     = kmemtrace_print_line,
-        .print_header = kmemtrace_headers,
-        .flags          = &kmem_tracer_flags
+        .name                   = "kmemtrace",
+        .init                   = kmem_trace_init,
+        .reset                  = kmem_trace_reset,
+        .print_line             = kmemtrace_print_line,
+        .print_header           = kmemtrace_headers,
+        .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/trace.h b/kernel/trace/trace.h
index cb0ce3fc36d3..cbc168f1e43d 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -182,6 +182,12 @@ struct trace_power {
         struct power_trace      state_data;
 };
 
+enum kmemtrace_type_id {
+        KMEMTRACE_TYPE_KMALLOC = 0,     /* kmalloc() or kfree(). */
+        KMEMTRACE_TYPE_CACHE,           /* kmem_cache_*(). */
+        KMEMTRACE_TYPE_PAGES,           /* __get_free_pages() and friends. */
+};
+
 struct kmemtrace_alloc_entry {
         struct trace_entry      ent;
         enum kmemtrace_type_id type_id;