mm: SLAB Out-of-memory diagnostics

Following the example at mm/slub.c, add out-of-memory diagnostics to the
SLAB allocator to help on debugging certain OOM conditions.

An example print out looks like this:

  <snip page allocator out-of-memory message>
  SLAB: Unable to allocate memory on node 0 (gfp=0x11200)
    cache: bio-0, object size: 192, order: 0
    node 0: slabs: 3/3, objs: 60/60, free: 0

Signed-off-by: Rafael Aquini <aquini@redhat.com>
Acked-by: Rik van Riel <riel@redhat.com>
Acked-by: David Rientjes <rientjes@google.com>
Signed-off-by: Pekka Enberg <penberg@kernel.org>

1 files changed, 50 insertions, 1 deletions

diff --git a/mm/slab.c b/mm/slab.c
index 806a754fad8..67e0e058926 100644
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1731,6 +1731,52 @@ static int __init cpucache_init(void)
 }
 __initcall(cpucache_init);
 
+static noinline void
+slab_out_of_memory(struct kmem_cache *cachep, gfp_t gfpflags, int nodeid)
+{
+        struct kmem_list3 *l3;
+        struct slab *slabp;
+        unsigned long flags;
+        int node;
+
+        printk(KERN_WARNING
+                "SLAB: Unable to allocate memory on node %d (gfp=0x%x)\n",
+                nodeid, gfpflags);
+        printk(KERN_WARNING "  cache: %s, object size: %d, order: %d\n",
+                cachep->name, cachep->buffer_size, cachep->gfporder);
+
+        for_each_online_node(node) {
+                unsigned long active_objs = 0, num_objs = 0, free_objects = 0;
+                unsigned long active_slabs = 0, num_slabs = 0;
+
+                l3 = cachep->nodelists[node];
+                if (!l3)
+                        continue;
+
+                spin_lock_irqsave(&l3->list_lock, flags);
+                list_for_each_entry(slabp, &l3->slabs_full, list) {
+                        active_objs += cachep->num;
+                        active_slabs++;
+                }
+                list_for_each_entry(slabp, &l3->slabs_partial, list) {
+                        active_objs += slabp->inuse;
+                        active_slabs++;
+                }
+                list_for_each_entry(slabp, &l3->slabs_free, list)
+                        num_slabs++;
+
+                free_objects += l3->free_objects;
+                spin_unlock_irqrestore(&l3->list_lock, flags);
+
+                num_slabs += active_slabs;
+                num_objs = num_slabs * cachep->num;
+                printk(KERN_WARNING
+                        "  node %d: slabs: %ld/%ld, objs: %ld/%ld, free: %ld\n",
+                        node, active_slabs, num_slabs, active_objs, num_objs,
+                        free_objects);
+        }
+}
+
 /*
  * Interface to system's page allocator. No need to hold the cache-lock.
  *
@@ -1757,8 +1803,11 @@ static void *kmem_getpages(struct kmem_cache *cachep, gfp_t flags, int nodeid)
                 flags |= __GFP_RECLAIMABLE;
 
         page = alloc_pages_exact_node(nodeid, flags | __GFP_NOTRACK, cachep->gfporder);
-        if (!page)
+        if (!page) {
+                if (!(flags & __GFP_NOWARN) && printk_ratelimit())
+                        slab_out_of_memory(cachep, flags, nodeid);
                 return NULL;
+        }
 
         nr_pages = (1 << cachep->gfporder);
         if (cachep->flags & SLAB_RECLAIM_ACCOUNT)