kmemtrace: Core implementation.

kmemtrace provides tracing for slab allocator functions, such as kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected data is then fed to the userspace application in order to analyse allocation hotspots, internal fragmentation and so on, making it possible to see how well an allocator performs, as well as debug and profile kernel code.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

new file mode 100644
index 0000000..11cd8e2

include/linux/kmemtrace.h new file +16 -0

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2008 Eduard - Gabriel Munteanu
+ *
+ * This file is released under GPL version 2.
+ */
+
+#ifndef _LINUX_KMEMTRACE_H
+#define _LINUX_KMEMTRACE_H
+
+#include <linux/types.h>
+
+/* ABI definition starts here. */
+
+#define KMEMTRACE_ABI_VERSION          1
+
+enum kmemtrace_event_id {

Hi Eduard-Gabriel,

Quoted 37 lines · Eduard - Gabriel Munteanu

kmemtrace provides tracing for slab allocator functions, such as kmalloc, kfree, kmem_cache_alloc, kmem_cache_free etc.. Collected data is then fed to the userspace application in order to analyse allocation hotspots, internal fragmentation and so on, making it possible to see how well an allocator performs, as well as debug and profile kernel code.

Signed-off-by: Eduard - Gabriel Munteanu
<[email protected]>

new file mode 100644
index 0000000..11cd8e2

include/linux/kmemtrace.h new file +22 -0

@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2008 Eduard - Gabriel Munteanu
+ *
+ * This file is released under GPL version 2.
+ */
+
+#ifndef _LINUX_KMEMTRACE_H
+#define _LINUX_KMEMTRACE_H
+
+#include <linux/types.h>
+
+/* ABI definition starts here. */
+
+#define KMEMTRACE_ABI_VERSION          1
+
+enum kmemtrace_event_id {
+       KMEMTRACE_EVENT_NULL = 0,       /* Erroneous event. */
+       KMEMTRACE_EVENT_ALLOC,
+       KMEMTRACE_EVENT_FREE,
+};
+
+enum kmemtrace_kind_id {

Quoted 4 lines

include/linux/kmemtrace.h new file +3 -0

+       KMEMTRACE_KIND_KERNEL = 0,      /* kmalloc() / kfree(). */
+       KMEMTRACE_KIND_CACHE,           /* kmem_cache_*(). */
+       KMEMTRACE_KIND_PAGES,           /* __get_free_pages() and

friends. */ +};

Can we do s/kind/type/, please? Also, the names "kernel" and "cache" are confusing. Can we just call them "kmalloc" and "kmem_cache" instead?

Quoted 10 lines

include/linux/kmemtrace.h new file +4 -0

+
+struct kmemtrace_event {
+       __u16           event_id;       /* Allocate or free? */
+       __u16           kind_id;        /* Kind of allocation/free.

*/

include/linux/kmemtrace.h new file +4 -0

+       __s32           node;           /* Target CPU. */
+       __u64           call_site;      /* Caller address. */
+       __u64           ptr;            /* Pointer to allocation. */
+       __u64           bytes_req;      /* Number of bytes

requested. */

Quoted 5 lines

+ __u64 bytes_alloc; /* Number of bytes
allocated. */

include/linux/kmemtrace.h new file +2 -0

+       __u64           gfp_flags;      /* Requested flags. */
+       __s64           timestamp;      /* When the operation

occured in ns. */ +} __attribute__ ((__packed__));

Why do you need to use the __packed__ attribute here? Looks like the struct is already laid out properly.

include/linux/kmemtrace.h

Quoted 2 lines

include/linux/kmemtrace.h new file +2 -0

+
+/* End of ABI definition. */

__GFP_NOTRACE turns off allocator tracing for that particular allocation.

This is used by kmemtrace to correctly classify different kinds of allocations, without recording one event multiple times. Example: SLAB's kmalloc() calls kmem_cache_alloc(), but we want to record this only as a kmalloc.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

This is used by kmemtrace to correctly classify different kinds of allocations, without recording one event multiple times. Example: SLAB's kmalloc() calls kmem_cache_alloc(), but we want to record this only as a kmalloc.

Quoted 4 lines · Eduard - Gabriel Munteanu

This is used by kmemtrace to correctly classify different kinds of allocations, without recording one event multiple times. Example:
SLAB's kmalloc() calls kmem_cache_alloc(), but we want to record this only as a kmalloc.

Well then I guess we need to put the recording logic into kmem_cache_alloc?

This adds hooks for the SLAB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

static inline void *kmalloc(size_t size, gfp_t flags) {

include/linux/slab_def.h +4 -2

+       void *ret;
+
       if (__builtin_constant_p(size)) {
               int i = 0;

@@ -50,10 +53,17 @@ static inline void *kmalloc(size_t size, gfp_t flags)
 found:
 #ifdef CONFIG_ZONE_DMA
               if (flags & GFP_DMA)
-                       return kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
-                                               flags);
+                       ret = kmem_cache_alloc(malloc_sizes[i].cs_dmacachep,
+                                              flags | __GFP_NOTRACE);

This adds hooks for the SLAB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

Hi Eduard-Gabriel,

Quoted 7 lines · Eduard - Gabriel Munteanu

This adds hooks for the SLAB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

include/linux/slab_def.h +0 -0

@@ -28,8 +29,20 @@ extern struct cache_sizes malloc_sizes[];
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 void *__kmalloc(size_t size, gfp_t flags);
 

include/linux/slab_def.h extern struct cache_sizes malloc_sizes[]; · line 38

Quoted 7 lines

include/linux/slab_def.h +7 -0

+#ifdef CONFIG_KMEMTRACE
+extern void *__kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);
+#else
+static inline void *__kmem_cache_alloc(struct kmem_cache *cachep,
+				       gfp_t flags)
+{
+	return __kmem_cache_alloc(cachep, flags);

Looks as if the function calls itself i>>?recursively?

Quoted 2 lines

Looks as if the function calls itself i>>?recursively?

Code not tested? Are you sure you configured for slab?

This adds hooks for the SLAB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

include/linux/slab_def.h +0 -0

@@ -28,8 +29,20 @@ extern struct cache_sizes malloc_sizes[];
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 void *__kmalloc(size_t size, gfp_t flags);
 

Hi Eduard-Gabriel,

Quoted 8 lines · Eduard - Gabriel Munteanu

This adds hooks for the SLAB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

include/linux/slab_def.h +0 -0

@@ -28,8 +29,20 @@ extern struct cache_sizes malloc_sizes[];
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
 void *__kmalloc(size_t size, gfp_t flags);
 

include/linux/slab_def.h extern struct cache_sizes malloc_sizes[]; · line 41

Quoted 10 lines

include/linux/slab_def.h +10 -0

+#ifdef CONFIG_KMEMTRACE
+extern void *__kmem_cache_alloc(struct kmem_cache *cachep, gfp_t flags);
+#else
+static inline void *__kmem_cache_alloc(struct kmem_cache *cachep,
+				       gfp_t flags)
+{
+	return kmem_cache_alloc(cachep, flags);
+}
+#endif
+

I'm okay with this approach but then you need to do s/__kmem_cache_alloc/kmem_cache_alloc_trace/ or similar. In the kernel, it's always the *upper* level function that doesn't have the underscores.

Quoted 4 lines

I'm okay with this approach but then you need to do s/__kmem_cache_alloc/kmem_cache_alloc_trace/ or similar. In the kernel, it's always the *upper* level function that doesn't have the underscores.

Hmm, doesn't really make sense:
1. This should be called kmem_cache_alloc_notrace, not *_trace. __kmem_cache_alloc() _disables_ tracing.

2. __kmem_cache_alloc is not really upper level now, since it's called only in kmalloc. So it's an internal function which is not supposed to be used by other kernel code.

Are you sure I should do this?

This adds hooks for the SLUB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

---
 include/linux/slub_def.h |    9 +++++++-
 mm/slub.c                |   49 +++++++++++++++++++++++++++++++++++++++------
 2 files changed, 50 insertions(+), 8 deletions(-)

include/linux/slub_def.h +8 -1

index d117ea2..d60ab10 100644
@@ -10,6 +10,7 @@
 #include <linux/gfp.h>
 #include <linux/workqueue.h>
 #include <linux/kobject.h>
+#include <linux/kmemtrace.h>
 
 enum stat_item {
       ALLOC_FASTPATH,         /* Allocation from cpu slab */

@@ -205,7 +206,13 @@ void *__kmalloc(size_t size, gfp_t flags);
 
 static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
 {
-       return (void *)__get_free_pages(flags | __GFP_COMP, get_order(size));
+       unsigned int order = get_order(size);
+       void *ret = (void *) __get_free_pages(flags, order);
+
+       kmemtrace_mark_alloc(KMEMTRACE_KIND_KERNEL, _THIS_IP_, ret,
+                            size, PAGE_SIZE << order, flags);
+
+       return ret;
 }
 
 static __always_inline void *kmalloc(size_t size, gfp_t flags)

mm/slub.c +42 -8

index 1a427c0..6841dfa 100644
@@ -23,6 +23,7 @@
 #include <linux/kallsyms.h>
 #include <linux/memory.h>
 #include <linux/math64.h>
+#include <linux/kmemtrace.h>
 
 /*
 * Lock order:

@@ -1650,14 +1651,25 @@ static __always_inline void *slab_alloc(struct kmem_cache *s,
 
 void *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
 {
-       return slab_alloc(s, gfpflags, -1, __builtin_return_address(0));
+       void *ret = slab_alloc(s, gfpflags, -1, __builtin_return_address(0));
+
+       kmemtrace_mark_alloc(KMEMTRACE_KIND_CACHE, _RET_IP_, ret,
+                            s->objsize, s->size, gfpflags);
+
+       return ret;
 }
 EXPORT_SYMBOL(kmem_cache_alloc);
 
 #ifdef CONFIG_NUMA
 void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
 {
-       return slab_alloc(s, gfpflags, node, __builtin_return_address(0));
+       void *ret = slab_alloc(s, gfpflags, node,
+                              __builtin_return_address(0));
+
+       kmemtrace_mark_alloc_node(KMEMTRACE_KIND_CACHE, _RET_IP_, ret,
+                                 s->objsize, s->size, gfpflags, node);
+
+       return ret;
 }
 EXPORT_SYMBOL(kmem_cache_alloc_node);
 #endif

@@ -1769,6 +1781,8 @@ void kmem_cache_free(struct kmem_cache *s, void *x)
       page = virt_to_head_page(x);
 
       slab_free(s, page, x, __builtin_return_address(0));
+
+       kmemtrace_mark_free(KMEMTRACE_KIND_CACHE, _RET_IP_, x);
 }
 EXPORT_SYMBOL(kmem_cache_free);
 

@@ -2674,6 +2688,7 @@ static struct kmem_cache *get_slab(size_t size, gfp_t flags)
 void *__kmalloc(size_t size, gfp_t flags)
 {
       struct kmem_cache *s;
+       void *ret;
 
       if (unlikely(size > PAGE_SIZE))
               return kmalloc_large(size, flags);

@@ -2683,7 +2698,12 @@ void *__kmalloc(size_t size, gfp_t flags)
       if (unlikely(ZERO_OR_NULL_PTR(s)))
               return s;
 
-       return slab_alloc(s, flags, -1, __builtin_return_address(0));
+       ret = slab_alloc(s, flags, -1, __builtin_return_address(0));
+
+       kmemtrace_mark_alloc(KMEMTRACE_KIND_KERNEL, _RET_IP_, ret,
+                            size, (size_t) s->size, (unsigned long) flags);
+
+       return ret;
 }
 EXPORT_SYMBOL(__kmalloc);
 

@@ -2702,16 +2722,29 @@ static void *kmalloc_large_node(size_t size, gfp_t flags, int node)
 void *__kmalloc_node(size_t size, gfp_t flags, int node)
 {
       struct kmem_cache *s;
-
-       if (unlikely(size > PAGE_SIZE))
-               return kmalloc_large_node(size, flags, node);
+       void *ret;
+
+       if (unlikely(size > PAGE_SIZE)) {
+               ret = kmalloc_large_node(size, flags, node);
+
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_KERNEL, _RET_IP_, ret,
+                                         size, PAGE_SIZE << get_order(size),
+                                         (unsigned long) flags, node);
+
+               return ret;
+       }
 
       s = get_slab(size, flags);
 
       if (unlikely(ZERO_OR_NULL_PTR(s)))
               return s;
 
-       return slab_alloc(s, flags, node, __builtin_return_address(0));
+       ret = slab_alloc(s, flags, node, __builtin_return_address(0));
+
+       kmemtrace_mark_alloc_node(KMEMTRACE_KIND_KERNEL, _RET_IP_, ret,
+                                 size, s->size, (unsigned long) flags, node);
+
+       return ret;
 }
 EXPORT_SYMBOL(__kmalloc_node);
 #endif

@@ -2769,6 +2802,8 @@ void kfree(const void *x)
               return;
       }
       slab_free(page->slab, page, object, __builtin_return_address(0));
+
+       kmemtrace_mark_free(KMEMTRACE_KIND_KERNEL, _RET_IP_, x);
 }
 EXPORT_SYMBOL(kfree);
 
--

1.5.6.1

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

Christoph, can you please take a look at this?

Quoted 1 line · Pekka Enberg

Christoph, can you please take a look at this?

Yeah. I saw it. Is there some high level description as to how this is going to be used?

Quoted 1 line · Pekka Enberg

Christoph, can you please take a look at this?

Yeah. I saw it. Is there some high level description as to how this is going to be used?

Quoted 2 lines · On Fri, 11 Jul 2008 09:48:03 -0500 Christoph Lameter <[email protected]>…

Pekka Enberg wrote:

Quoted 4 lines

Quoted 1 line

Christoph, can you please take a look at this?

Yeah. I saw it. Is there some high level description as to how this is going to be used?

Here is the userspace application's git tree:
http://repo.or.cz/w/kmemtrace-user.git

This adds hooks for the SLUB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

Hi Eduard-Gabriel,

Quoted 8 lines · Eduard - Gabriel Munteanu

This adds hooks for the SLUB allocator, to allow tracing with kmemtrace.

Signed-off-by: Eduard - Gabriel Munteanu
<[email protected]>

(quoted diff) +0 -0

@@ -205,7 +206,13 @@ void *__kmalloc(size_t size, gfp_t flags);
 

include/linux/slub_def.h void *__kmalloc(size_t size, gfp_t flags); · line 213

Quoted 9 lines

include/linux/slub_def.h +5 -1

 static __always_inline void *kmalloc_large(size_t size, gfp_t
 flags) {
-       return (void *)__get_free_pages(flags | __GFP_COMP,
 get_order(size));
+       unsigned int order = get_order(size);
+       void *ret = (void *) __get_free_pages(flags, order);
+
+       kmemtrace_mark_alloc(KMEMTRACE_KIND_KERNEL, _THIS_IP_, ret,
+                            size, PAGE_SIZE << order, flags);

Oh, I missed this on the first review. Here we have, like in SLOB, page allocator pass-through, so wouldn't KIND_PAGES be more appropriate?

Quoted 3 lines

Oh, I missed this on the first review. Here we have, like in SLOB, page allocator pass-through, so wouldn't KIND_PAGES be more appropriate?

The rationale was to be able to trace how kmalloc()s perform, no matter what the allocator does behind the scenes. Presumably, the developer would know what kmalloc() really does with an allocation request.

Does this sound okay?

This adds hooks for the SLOB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

---
 mm/slob.c |   37 +++++++++++++++++++++++++++++++------
 1 files changed, 31 insertions(+), 6 deletions(-)

mm/slob.c +9 -2

index a3ad667..44f395a 100644
@@ -65,6 +65,7 @@
 #include <linux/module.h>
 #include <linux/rcupdate.h>
 #include <linux/list.h>
+#include <linux/kmemtrace.h>
 #include <asm/atomic.h>
 
 /*

@@ -463,27 +464,38 @@ void *__kmalloc_node(size_t size, gfp_t gfp, int node)
 {
       unsigned int *m;
       int align = max(ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
+       void *ret;
 
       if (size < PAGE_SIZE - align) {
               if (!size)
                       return ZERO_SIZE_PTR;
 
               m = slob_alloc(size + align, gfp, align, node);
+
               if (!m)
                       return NULL;
               *m = size;
-               return (void *)m + align;
+               ret = (void *)m + align;
+
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_KERNEL,
+                                         _RET_IP_, ret,
+                                         size, size + align, gfp, node);
       } else {
-               void *ret;
+               unsigned int order = get_order(size);
 

mm/slob.c +4 -0

+                                         _RET_IP_, ret,
+                                         size, PAGE_SIZE << order, gfp, node);
       }
+
+       return ret;
 }
 EXPORT_SYMBOL(__kmalloc_node);
 

mm/slob.c +13 -3

 }
 EXPORT_SYMBOL(kfree);
 

@@ -569,10 +583,19 @@ void *kmem_cache_alloc_node(struct kmem_cache *c, gfp_t flags, int node)
 {
       void *b;
 
-       if (c->size < PAGE_SIZE)
+       if (c->size < PAGE_SIZE) {
               b = slob_alloc(c->size, flags, c->align, node);
-       else
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_CACHE,
+                                         _RET_IP_, b, c->size,
+                                         SLOB_UNITS(c->size) * SLOB_UNIT,
+                                         flags, node);
+       } else {
               b = slob_new_page(flags, get_order(c->size), node);
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_CACHE,
+                                         _RET_IP_, b, c->size,
+                                         PAGE_SIZE << get_order(c->size),
+                                         flags, node);
+       }
 
       if (c->ctor)
               c->ctor(c, b);

@@ -608,6 +631,8 @@ void kmem_cache_free(struct kmem_cache *c, void *b)
       } else {
               __kmem_cache_free(b, c->size);
       }
+
+       kmemtrace_mark_free(KMEMTRACE_KIND_CACHE, _RET_IP_, b);
 }
 EXPORT_SYMBOL(kmem_cache_free);
 
--

1.5.6.1

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

Hi,

Matt, can you take a look at this? I know you don't want *debugging* code in SLOB but this is for instrumentation.

Quoted 18 lines · Eduard - Gabriel Munteanu

This adds hooks for the SLOB allocator, to allow tracing with kmemtrace.

Signed-off-by Eduard - Gabriel Munteanu <[email protected]>

---
 mm/slob.c |   37 +++++++++++++++++++++++++++++++------
 1 files changed, 31 insertions(+), 6 deletions(-)

mm/slob.c +1 -0

index a3ad667..44f395a 100644
@@ -65,6 +65,7 @@
 #include <linux/module.h>
 #include <linux/rcupdate.h>
 #include <linux/list.h>
+#include <linux/kmemtrace.h>
 #include <asm/atomic.h>
 

mm/slob.c void *__kmalloc_node(size_t size, gfp_t gfp, int node) · line 467

Quoted 6 lines

mm/slob.c +1 -0

 /*

@@ -463,27 +464,38 @@ void *__kmalloc_node(size_t size, gfp_t gfp, int node)
 {
       unsigned int *m;
       int align = max(ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
+       void *ret;

Quoted 19 lines

mm/slob.c +7 -2

       if (size < PAGE_SIZE - align) {
               if (!size)
                       return ZERO_SIZE_PTR;
 
               m = slob_alloc(size + align, gfp, align, node);
+
               if (!m)
                       return NULL;
               *m = size;
-               return (void *)m + align;
+               ret = (void *)m + align;
+
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_KERNEL,
+                                         _RET_IP_, ret,
+                                         size, size + align, gfp, node);
       } else {
-               void *ret;
+               unsigned int order = get_order(size);
 

mm/slob.c void *__kmalloc_node(size_t size, gfp_t gfp, int node) · line 493

Quoted 10 lines

mm/slob.c +3 -2

-               ret = slob_new_page(gfp | __GFP_COMP, get_order(size), node);
+               ret = slob_new_page(gfp | __GFP_COMP, order, node);
               if (ret) {
                       struct page *page;
                       page = virt_to_page(ret);
                       page->private = size;
               }
-               return ret;
+
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_KERNEL,

The latter case is actually page allocator pass-through so I wonder if we want to use KIND_PAGES here instead?

Quoted 9 lines

mm/slob.c +4 -0

+                                         _RET_IP_, ret,
+                                         size, PAGE_SIZE << order, gfp, node);
       }
+
+       return ret;
 }
 EXPORT_SYMBOL(__kmalloc_node);
 

mm/slob.c void kfree(const void *block) · line 517

Quoted 5 lines

mm/slob.c +2 -0

@@ -501,6 +513,8 @@ void kfree(const void *block)
               slob_free(m, *m + align);
       } else
               put_page(&sp->page);
+
+       kmemtrace_mark_free(KMEMTRACE_KIND_KERNEL, _RET_IP_, block);

Same comment here.

Quoted 43 lines

mm/slob.c +13 -3

 }
 EXPORT_SYMBOL(kfree);
 

@@ -569,10 +583,19 @@ void *kmem_cache_alloc_node(struct kmem_cache *c, gfp_t flags, int node)
 {
       void *b;
 
-       if (c->size < PAGE_SIZE)
+       if (c->size < PAGE_SIZE) {
               b = slob_alloc(c->size, flags, c->align, node);
-       else
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_CACHE,
+                                         _RET_IP_, b, c->size,
+                                         SLOB_UNITS(c->size) * SLOB_UNIT,
+                                         flags, node);
+       } else {
               b = slob_new_page(flags, get_order(c->size), node);
+               kmemtrace_mark_alloc_node(KMEMTRACE_KIND_CACHE,
+                                         _RET_IP_, b, c->size,
+                                         PAGE_SIZE << get_order(c->size),
+                                         flags, node);
+       }
 
       if (c->ctor)
               c->ctor(c, b);

@@ -608,6 +631,8 @@ void kmem_cache_free(struct kmem_cache *c, void *b)
       } else {
               __kmem_cache_free(b, c->size);
       }
+
+       kmemtrace_mark_free(KMEMTRACE_KIND_CACHE, _RET_IP_, b);
 }
 EXPORT_SYMBOL(kmem_cache_free);
 
--

1.5.6.1

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

Quoted 4 lines · Pekka Enberg

Hi,

Matt, can you take a look at this? I know you don't want *debugging* code in SLOB but this is for instrumentation.

I presume this code all disappears in a default SLOB build?

Quoted 21 lines

Quoted 19 lines · Eduard - Gabriel Munteanu

This adds hooks for the SLOB allocator, to allow tracing with kmemtrace.

Signed-off-by: Eduard - Gabriel Munteanu
<[email protected]> ---

 mm/slob.c |   37 +++++++++++++++++++++++++++++++------
 1 files changed, 31 insertions(+), 6 deletions(-)

mm/slob.c +1 -0

index a3ad667..44f395a 100644
@@ -65,6 +65,7 @@
 #include <linux/module.h>
 #include <linux/rcupdate.h>
 #include <linux/list.h>
+#include <linux/kmemtrace.h>
 #include <asm/atomic.h>
 

Quoted 6 lines

mm/slob.c void *__kmalloc_node(size_t size, gfp_t · line 467

Quoted 6 lines

mm/slob.c +1 -0

 /*

@@ -463,27 +464,38 @@ void *__kmalloc_node(size_t size, gfp_t
 gfp, int node) {
       unsigned int *m;
       int align = max(ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
+       void *ret;

There's tons of tab damage in this patch. Or perhaps it's just been mangled by someone's mailer?