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

5 files changed, 55 insertions, 50 deletions

diff --git a/mm/failslab.c b/mm/failslab.c
index 7c6ea6493f80..9339de5f0a91 100644
--- a/mm/failslab.c
+++ b/mm/failslab.c
@@ -1,4 +1,5 @@
 #include <linux/fault-inject.h>
+#include <linux/gfp.h>
 
 static struct {
         struct fault_attr attr;
diff --git a/mm/slab.c b/mm/slab.c
index 4fc1761c6dc8..9a90b00d2f91 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -3565,8 +3565,8 @@ void *kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags)
 {
         void *ret = __cache_alloc(cachep, flags, __builtin_return_address(0));
 
-        kmemtrace_mark_alloc(KMEMTRACE_TYPE_CACHE, _RET_IP_, ret,
-                             obj_size(cachep), cachep->buffer_size, flags);
+        trace_kmem_cache_alloc(_RET_IP_, ret,
+                               obj_size(cachep), cachep->buffer_size, flags);
 
         return ret;
 }
@@ -3627,9 +3627,9 @@ void *kmem_cache_alloc_node(struct kmem_cache *cachep, gfp_t flags, int nodeid)
         void *ret = __cache_alloc_node(cachep, flags, nodeid,
                                        __builtin_return_address(0));
 
-        kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_CACHE, _RET_IP_, ret,
-                                  obj_size(cachep), cachep->buffer_size,
-                                  flags, nodeid);
+        trace_kmem_cache_alloc_node(_RET_IP_, ret,
+                                    obj_size(cachep), cachep->buffer_size,
+                                    flags, nodeid);
 
         return ret;
 }
@@ -3657,9 +3657,8 @@ __do_kmalloc_node(size_t size, gfp_t flags, int node, void *caller)
                 return cachep;
         ret = kmem_cache_alloc_node_notrace(cachep, flags, node);
 
-        kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC,
-                                  (unsigned long) caller, ret,
-                                  size, cachep->buffer_size, flags, node);
+        trace_kmalloc_node((unsigned long) caller, ret,
+                           size, cachep->buffer_size, flags, node);
 
         return ret;
 }
@@ -3709,9 +3708,8 @@ static __always_inline void *__do_kmalloc(size_t size, gfp_t flags,
                 return cachep;
         ret = __cache_alloc(cachep, flags, caller);
 
-        kmemtrace_mark_alloc(KMEMTRACE_TYPE_KMALLOC,
-                             (unsigned long) caller, ret,
-                             size, cachep->buffer_size, flags);
+        trace_kmalloc((unsigned long) caller, ret,
+                      size, cachep->buffer_size, flags);
 
         return ret;
 }
@@ -3757,7 +3755,7 @@ void kmem_cache_free(struct kmem_cache *cachep, void *objp)
         __cache_free(cachep, objp);
         local_irq_restore(flags);
 
-        kmemtrace_mark_free(KMEMTRACE_TYPE_CACHE, _RET_IP_, objp);
+        trace_kmem_cache_free(_RET_IP_, objp);
 }
 EXPORT_SYMBOL(kmem_cache_free);
 
@@ -3775,6 +3773,8 @@ void kfree(const void *objp)
         struct kmem_cache *c;
         unsigned long flags;
 
+        trace_kfree(_RET_IP_, objp);
+
         if (unlikely(ZERO_OR_NULL_PTR(objp)))
                 return;
         local_irq_save(flags);
@@ -3784,8 +3784,6 @@ void kfree(const void *objp)
         debug_check_no_obj_freed(objp, obj_size(c));
         __cache_free(c, (void *)objp);
         local_irq_restore(flags);
-
-        kmemtrace_mark_free(KMEMTRACE_TYPE_KMALLOC, _RET_IP_, objp);
 }
 EXPORT_SYMBOL(kfree);
 
diff --git a/mm/slob.c b/mm/slob.c
index 4dd6516447f2..a2d4ab32198d 100644
--- a/mm/slob.c
+++ b/mm/slob.c
@@ -490,9 +490,8 @@ void *__kmalloc_node(size_t size, gfp_t gfp, int node)
                 *m = size;
                 ret = (void *)m + align;
 
-                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC,
-                                          _RET_IP_, ret,
-                                          size, size + align, gfp, node);
+                trace_kmalloc_node(_RET_IP_, ret,
+                                   size, size + align, gfp, node);
         } else {
                 unsigned int order = get_order(size);
 
@@ -503,9 +502,8 @@ void *__kmalloc_node(size_t size, gfp_t gfp, int node)
                         page->private = size;
                 }
 
-                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC,
-                                          _RET_IP_, ret,
-                                          size, PAGE_SIZE << order, gfp, node);
+                trace_kmalloc_node(_RET_IP_, ret,
+                                   size, PAGE_SIZE << order, gfp, node);
         }
 
         return ret;
@@ -516,6 +514,8 @@ void kfree(const void *block)
 {
         struct slob_page *sp;
 
+        trace_kfree(_RET_IP_, block);
+
         if (unlikely(ZERO_OR_NULL_PTR(block)))
                 return;
 
@@ -526,8 +526,6 @@ void kfree(const void *block)
                 slob_free(m, *m + align);
         } else
                 put_page(&sp->page);
-
-        kmemtrace_mark_free(KMEMTRACE_TYPE_KMALLOC, _RET_IP_, block);
 }
 EXPORT_SYMBOL(kfree);
 
@@ -599,16 +597,14 @@ void *kmem_cache_alloc_node(struct kmem_cache *c, gfp_t flags, int node)
 
         if (c->size < PAGE_SIZE) {
                 b = slob_alloc(c->size, flags, c->align, node);
-                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_CACHE,
-                                          _RET_IP_, b, c->size,
-                                          SLOB_UNITS(c->size) * SLOB_UNIT,
-                                          flags, node);
+                trace_kmem_cache_alloc_node(_RET_IP_, b, c->size,
+                                            SLOB_UNITS(c->size) * SLOB_UNIT,
+                                            flags, node);
         } else {
                 b = slob_new_pages(flags, get_order(c->size), node);
-                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_CACHE,
-                                          _RET_IP_, b, c->size,
-                                          PAGE_SIZE << get_order(c->size),
-                                          flags, node);
+                trace_kmem_cache_alloc_node(_RET_IP_, b, c->size,
+                                            PAGE_SIZE << get_order(c->size),
+                                            flags, node);
         }
 
         if (c->ctor)
@@ -646,7 +642,7 @@ void kmem_cache_free(struct kmem_cache *c, void *b)
                 __kmem_cache_free(b, c->size);
         }
 
-        kmemtrace_mark_free(KMEMTRACE_TYPE_CACHE, _RET_IP_, b);
+        trace_kmem_cache_free(_RET_IP_, b);
 }
 EXPORT_SYMBOL(kmem_cache_free);
 
diff --git a/mm/slub.c b/mm/slub.c
index 7aaa121d0ea9..7ab54ecbd3f3 100644
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -1621,8 +1621,7 @@ void *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
 {
         void *ret = slab_alloc(s, gfpflags, -1, _RET_IP_);
 
-        kmemtrace_mark_alloc(KMEMTRACE_TYPE_CACHE, _RET_IP_, ret,
-                             s->objsize, s->size, gfpflags);
+        trace_kmem_cache_alloc(_RET_IP_, ret, s->objsize, s->size, gfpflags);
 
         return ret;
 }
@@ -1641,8 +1640,8 @@ void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
 {
         void *ret = slab_alloc(s, gfpflags, node, _RET_IP_);
 
-        kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_CACHE, _RET_IP_, ret,
-                                  s->objsize, s->size, gfpflags, node);
+        trace_kmem_cache_alloc_node(_RET_IP_, ret,
+                                    s->objsize, s->size, gfpflags, node);
 
         return ret;
 }
@@ -1767,7 +1766,7 @@ void kmem_cache_free(struct kmem_cache *s, void *x)
 
         slab_free(s, page, x, _RET_IP_);
 
-        kmemtrace_mark_free(KMEMTRACE_TYPE_CACHE, _RET_IP_, x);
+        trace_kmem_cache_free(_RET_IP_, x);
 }
 EXPORT_SYMBOL(kmem_cache_free);
 
@@ -2702,8 +2701,7 @@ void *__kmalloc(size_t size, gfp_t flags)
 
         ret = slab_alloc(s, flags, -1, _RET_IP_);
 
-        kmemtrace_mark_alloc(KMEMTRACE_TYPE_KMALLOC, _RET_IP_, ret,
-                             size, s->size, flags);
+        trace_kmalloc(_RET_IP_, ret, size, s->size, flags);
 
         return ret;
 }
@@ -2729,10 +2727,9 @@ void *__kmalloc_node(size_t size, gfp_t flags, int node)
         if (unlikely(size > SLUB_MAX_SIZE)) {
                 ret = kmalloc_large_node(size, flags, node);
 
-                kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC,
-                                          _RET_IP_, ret,
-                                          size, PAGE_SIZE << get_order(size),
-                                          flags, node);
+                trace_kmalloc_node(_RET_IP_, ret,
+                                   size, PAGE_SIZE << get_order(size),
+                                   flags, node);
 
                 return ret;
         }
@@ -2744,8 +2741,7 @@ void *__kmalloc_node(size_t size, gfp_t flags, int node)
 
         ret = slab_alloc(s, flags, node, _RET_IP_);
 
-        kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC, _RET_IP_, ret,
-                                  size, s->size, flags, node);
+        trace_kmalloc_node(_RET_IP_, ret, size, s->size, flags, node);
 
         return ret;
 }
@@ -2796,6 +2792,8 @@ void kfree(const void *x)
         struct page *page;
         void *object = (void *)x;
 
+        trace_kfree(_RET_IP_, x);
+
         if (unlikely(ZERO_OR_NULL_PTR(x)))
                 return;
 
@@ -2806,8 +2804,6 @@ void kfree(const void *x)
                 return;
         }
         slab_free(page->slab, page, object, _RET_IP_);
-
-        kmemtrace_mark_free(KMEMTRACE_TYPE_KMALLOC, _RET_IP_, x);
 }
 EXPORT_SYMBOL(kfree);
 
@@ -3290,8 +3286,7 @@ void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, unsigned long caller)
         ret = slab_alloc(s, gfpflags, -1, caller);
 
         /* Honor the call site pointer we recieved. */
-        kmemtrace_mark_alloc(KMEMTRACE_TYPE_KMALLOC, caller, ret, size,
-                             s->size, gfpflags);
+        trace_kmalloc(caller, ret, size, s->size, gfpflags);
 
         return ret;
 }
@@ -3313,8 +3308,7 @@ void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
         ret = slab_alloc(s, gfpflags, node, caller);
 
         /* Honor the call site pointer we recieved. */
-        kmemtrace_mark_alloc_node(KMEMTRACE_TYPE_KMALLOC, caller, ret,
-                                  size, s->size, gfpflags, node);
+        trace_kmalloc_node(caller, ret, size, s->size, gfpflags, node);
 
         return ret;
 }
diff --git a/mm/util.c b/mm/util.c
index 7c122e49f769..2599e83eea17 100644
--- a/mm/util.c
+++ b/mm/util.c
@@ -4,6 +4,7 @@
 #include <linux/module.h>
 #include <linux/err.h>
 #include <linux/sched.h>
+#include <linux/tracepoint.h>
 #include <asm/uaccess.h>
 
 /**
@@ -236,3 +237,18 @@ int __attribute__((weak)) get_user_pages_fast(unsigned long start,
         return ret;
 }
 EXPORT_SYMBOL_GPL(get_user_pages_fast);
+
+/* Tracepoints definitions. */
+DEFINE_TRACE(kmalloc);
+DEFINE_TRACE(kmem_cache_alloc);
+DEFINE_TRACE(kmalloc_node);
+DEFINE_TRACE(kmem_cache_alloc_node);
+DEFINE_TRACE(kfree);
+DEFINE_TRACE(kmem_cache_free);
+
+EXPORT_TRACEPOINT_SYMBOL(kmalloc);
+EXPORT_TRACEPOINT_SYMBOL(kmem_cache_alloc);
+EXPORT_TRACEPOINT_SYMBOL(kmalloc_node);
+EXPORT_TRACEPOINT_SYMBOL(kmem_cache_alloc_node);
+EXPORT_TRACEPOINT_SYMBOL(kfree);
+EXPORT_TRACEPOINT_SYMBOL(kmem_cache_free);