mm, slab: suppress out of memory warning unless debug is enabled

When the slab or slub allocators cannot allocate additional slab pages,
they emit diagnostic information to the kernel log such as current number
of slabs, number of objects, active objects, etc.  This is always coupled
with a page allocation failure warning since it is controlled by
!__GFP_NOWARN.

Suppress this out of memory warning if the allocator is configured without
debug supported.  The page allocation failure warning will indicate it is
a failed slab allocation, the order, and the gfp mask, so this is only
useful to diagnose allocator issues.

Since CONFIG_SLUB_DEBUG is already enabled by default for the slub
allocator, there is no functional change with this patch.  If debug is
disabled, however, the warnings are now suppressed.

Signed-off-by: David Rientjes <rientjes@google.com>
Cc: Pekka Enberg <penberg@kernel.org>
Acked-by: Christoph Lameter <cl@linux.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/slab.c b/mm/slab.c
index 19d92181ce24917f799f5f6bbd46dada145d32d8..5c846d25c17d8d8dff186864b5928419faf6a81e 100644 (file)
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1621,10 +1621,16 @@ __initcall(cpucache_init);
 static noinline void
 slab_out_of_memory(struct kmem_cache *cachep, gfp_t gfpflags, int nodeid)
 {
+#if DEBUG
        struct kmem_cache_node *n;
        struct page *page;
        unsigned long flags;
        int node;
+       static DEFINE_RATELIMIT_STATE(slab_oom_rs, DEFAULT_RATELIMIT_INTERVAL,
+                                     DEFAULT_RATELIMIT_BURST);
+
+       if ((gfpflags & __GFP_NOWARN) || !__ratelimit(&slab_oom_rs))
+               return;
 
        printk(KERN_WARNING
                "SLAB: Unable to allocate memory on node %d (gfp=0x%x)\n",
@@ -1662,6 +1668,7 @@ slab_out_of_memory(struct kmem_cache *cachep, gfp_t gfpflags, int nodeid)
                        node, active_slabs, num_slabs, active_objs, num_objs,
                        free_objects);
        }
+#endif
 }
 
 /*
@@ -1683,8 +1690,7 @@ static struct page *kmem_getpages(struct kmem_cache *cachep, gfp_t flags,
 
        page = alloc_pages_exact_node(nodeid, flags | __GFP_NOTRACK, cachep->gfporder);
        if (!page) {
-               if (!(flags & __GFP_NOWARN) && printk_ratelimit())
-                       slab_out_of_memory(cachep, flags, nodeid);
+               slab_out_of_memory(cachep, flags, nodeid);
                return NULL;
        }
 

diff --git a/mm/slub.c b/mm/slub.c
index de99d500af6cdf6de6881ea8d809669c5994ec34..269d049108e3e7454cacd571428decd6d2a57cd9 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -2150,8 +2150,14 @@ static inline unsigned long node_nr_objs(struct kmem_cache_node *n)
 static noinline void
 slab_out_of_memory(struct kmem_cache *s, gfp_t gfpflags, int nid)
 {
+#ifdef CONFIG_SLUB_DEBUG
+       static DEFINE_RATELIMIT_STATE(slub_oom_rs, DEFAULT_RATELIMIT_INTERVAL,
+                                     DEFAULT_RATELIMIT_BURST);
        int node;
 
+       if ((gfpflags & __GFP_NOWARN) || !__ratelimit(&slub_oom_rs))
+               return;
+
        pr_warn("SLUB: Unable to allocate memory on node %d (gfp=0x%x)\n",
                nid, gfpflags);
        pr_warn("  cache: %s, object size: %d, buffer size: %d, default order: %d, min order: %d\n",
@@ -2178,6 +2184,7 @@ slab_out_of_memory(struct kmem_cache *s, gfp_t gfpflags, int nid)
                pr_warn("  node %d: slabs: %ld, objs: %ld, free: %ld\n",
                        node, nr_slabs, nr_objs, nr_free);
        }
+#endif
 }
 
 static inline void *new_slab_objects(struct kmem_cache *s, gfp_t flags,
@@ -2356,9 +2363,7 @@ new_slab:
        freelist = new_slab_objects(s, gfpflags, node, &c);
 
        if (unlikely(!freelist)) {
-               if (!(gfpflags & __GFP_NOWARN) && printk_ratelimit())
-                       slab_out_of_memory(s, gfpflags, node);
-
+               slab_out_of_memory(s, gfpflags, node);
                local_irq_restore(flags);
                return NULL;
        }