Merge branches 'slab/documentation', 'slab/fixes', 'slob/cleanups' and 'slub/fixes...
authorPekka Enberg <penberg@cs.helsinki.fi>
Wed, 17 Jun 2009 05:30:15 +0000 (08:30 +0300)
committerPekka Enberg <penberg@cs.helsinki.fi>
Wed, 17 Jun 2009 05:30:15 +0000 (08:30 +0300)
1  2  3  4  5 
include/linux/page-flags.h
mm/slab.c
mm/slob.c
mm/slub.c
mm/util.c

index d6792f88a1769c0ece3dbf7084fb6c8072a150b4,62214c7d2d939e734352bf888e058001e44ccc30,62214c7d2d939e734352bf888e058001e44ccc30,f036dfbdad546bd022173105cdfd39bea4a86f75,62214c7d2d939e734352bf888e058001e44ccc30..e2e5ce543595df658b883a227fd753f9ab2a92e0
@@@@@@ -95,7 -95,9 -95,9 -95,9 -95,9 +95,7 @@@@@@ enum pageflags 
        PG_reclaim,             /* To be reclaimed asap */
        PG_buddy,               /* Page is free, on buddy lists */
        PG_swapbacked,          /* Page is backed by RAM/swap */
 ----#ifdef CONFIG_UNEVICTABLE_LRU
        PG_unevictable,         /* Page is "unevictable"  */
 ----#endif
     #ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
        PG_mlocked,             /* Page is vma mlocked */
     #endif
        PG_savepinned = PG_dirty,
     
        /* SLOB */
--- -   PG_slob_page = PG_active,
        PG_slob_free = PG_private,
     
        /* SLUB */
@@@@@@ -201,7 -203,7 -203,7 -202,6 -203,7 +200,6 @@@@@@ PAGEFLAG(SavePinned, savepinned);                       /* 
     PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
     PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
     
--- -__PAGEFLAG(SlobPage, slob_page)
     __PAGEFLAG(SlobFree, slob_free)
     
     __PAGEFLAG(SlubFrozen, slub_frozen)
@@@@@@ -246,8 -248,14 -248,14 -246,14 -248,14 +244,8 @@@@@@ PAGEFLAG_FALSE(SwapCache
        SETPAGEFLAG_NOOP(SwapCache) CLEARPAGEFLAG_NOOP(SwapCache)
     #endif
     
 ----#ifdef CONFIG_UNEVICTABLE_LRU
     PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
        TESTCLEARFLAG(Unevictable, unevictable)
 ----#else
 ----PAGEFLAG_FALSE(Unevictable) TESTCLEARFLAG_FALSE(Unevictable)
 ----   SETPAGEFLAG_NOOP(Unevictable) CLEARPAGEFLAG_NOOP(Unevictable)
 ----   __CLEARPAGEFLAG_NOOP(Unevictable)
 ----#endif
     
     #ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
     #define MLOCK_PAGES 1
@@@@@@ -374,6 -382,12 -382,12 -380,12 -382,12 +372,6 @@@@@@ static inline void __ClearPageTail(stru
     
     #endif /* !PAGEFLAGS_EXTENDED */
     
 ----#ifdef CONFIG_UNEVICTABLE_LRU
 ----#define __PG_UNEVICTABLE   (1 << PG_unevictable)
 ----#else
 ----#define __PG_UNEVICTABLE   0
 ----#endif
 ----
     #ifdef CONFIG_HAVE_MLOCKED_PAGE_BIT
     #define __PG_MLOCKED               (1 << PG_mlocked)
     #else
         1 << PG_private | 1 << PG_private_2 | \
         1 << PG_buddy   | 1 << PG_writeback | 1 << PG_reserved | \
         1 << PG_slab    | 1 << PG_swapcache | 1 << PG_active | \
 ----    __PG_UNEVICTABLE | __PG_MLOCKED)
 ++++    1 << PG_unevictable | __PG_MLOCKED)
     
     /*
      * Flags checked when a page is prepped for return by the page allocator.
diff --combined mm/slab.c
index f257d4dd474db5f3ee0ed42016b86dd3d5b02bc4,9a90b00d2f9140e2aaa67ecb949e33d89431e9c5,1a6040d0f41d897bcedf0855ea10175e042a5062,9a90b00d2f9140e2aaa67ecb949e33d89431e9c5,9a90b00d2f9140e2aaa67ecb949e33d89431e9c5..d08692303f6e9f154f0e4b2a0786696db7f9b541
+++ b/mm/slab.c
     #include   <linux/cpu.h>
     #include   <linux/sysctl.h>
     #include   <linux/module.h>
 ----#include   <trace/kmemtrace.h>
 ++++#include   <linux/kmemtrace.h>
     #include   <linux/rcupdate.h>
     #include   <linux/string.h>
     #include   <linux/uaccess.h>
     #include   <linux/nodemask.h>
 ++++#include   <linux/kmemleak.h>
     #include   <linux/mempolicy.h>
     #include   <linux/mutex.h>
     #include   <linux/fault-inject.h>
     #include   <linux/rtmutex.h>
     #include   <linux/reciprocal_div.h>
     #include   <linux/debugobjects.h>
 ++++#include   <linux/kmemcheck.h>
     
     #include   <asm/cacheflush.h>
     #include   <asm/tlbflush.h>
                         SLAB_STORE_USER | \
                         SLAB_RECLAIM_ACCOUNT | SLAB_PANIC | \
                         SLAB_DESTROY_BY_RCU | SLAB_MEM_SPREAD | \
 ----                    SLAB_DEBUG_OBJECTS)
 ++++                    SLAB_DEBUG_OBJECTS | SLAB_NOLEAKTRACE | SLAB_NOTRACK)
     #else
     # define CREATE_MASK       (SLAB_HWCACHE_ALIGN | \
                         SLAB_CACHE_DMA | \
                         SLAB_RECLAIM_ACCOUNT | SLAB_PANIC | \
                         SLAB_DESTROY_BY_RCU | SLAB_MEM_SPREAD | \
 ----                    SLAB_DEBUG_OBJECTS)
 ++++                    SLAB_DEBUG_OBJECTS | SLAB_NOLEAKTRACE | SLAB_NOTRACK)
     #endif
     
     /*
@@@@@@ -304,12 -302,6 -302,6 -302,6 -302,6 +304,12 @@@@@@ struct kmem_list3 
        int free_touched;               /* updated without locking */
     };
     
 ++++/*
 ++++ * The slab allocator is initialized with interrupts disabled. Therefore, make
 ++++ * sure early boot allocations don't accidentally enable interrupts.
 ++++ */
 ++++static gfp_t slab_gfp_mask __read_mostly = SLAB_GFP_BOOT_MASK;
 ++++
     /*
      * Need this for bootstrapping a per node allocator.
      */
@@@@@@ -323,7 -315,7 -315,7 -315,7 -315,7 +323,7 @@@@@@ static int drain_freelist(struct kmem_c
                        struct kmem_list3 *l3, int tofree);
     static void free_block(struct kmem_cache *cachep, void **objpp, int len,
                        int node);
 ----static int enable_cpucache(struct kmem_cache *cachep);
 ++++static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp);
     static void cache_reap(struct work_struct *unused);
     
     /*
@@@@@@ -381,6 -373,87 -373,87 -373,87 -373,87 +381,6 @@@@@@ static void kmem_list3_init(struct kmem
        MAKE_LIST((cachep), (&(ptr)->slabs_free), slabs_free, nodeid);  \
        } while (0)
     
 ----/*
 ---- * struct kmem_cache
 ---- *
 ---- * manages a cache.
 ---- */
 ----
 ----struct kmem_cache {
 ----/* 1) per-cpu data, touched during every alloc/free */
 ----   struct array_cache *array[NR_CPUS];
 ----/* 2) Cache tunables. Protected by cache_chain_mutex */
 ----   unsigned int batchcount;
 ----   unsigned int limit;
 ----   unsigned int shared;
 ----
 ----   unsigned int buffer_size;
 ----   u32 reciprocal_buffer_size;
 ----/* 3) touched by every alloc & free from the backend */
 ----
 ----   unsigned int flags;             /* constant flags */
 ----   unsigned int num;               /* # of objs per slab */
 ----
 ----/* 4) cache_grow/shrink */
 ----   /* order of pgs per slab (2^n) */
 ----   unsigned int gfporder;
 ----
 ----   /* force GFP flags, e.g. GFP_DMA */
 ----   gfp_t gfpflags;
 ----
 ----   size_t colour;                  /* cache colouring range */
 ----   unsigned int colour_off;        /* colour offset */
 ----   struct kmem_cache *slabp_cache;
 ----   unsigned int slab_size;
 ----   unsigned int dflags;            /* dynamic flags */
 ----
 ----   /* constructor func */
 ----   void (*ctor)(void *obj);
 ----
 ----/* 5) cache creation/removal */
 ----   const char *name;
 ----   struct list_head next;
 ----
 ----/* 6) statistics */
 ----#if STATS
 ----   unsigned long num_active;
 ----   unsigned long num_allocations;
 ----   unsigned long high_mark;
 ----   unsigned long grown;
 ----   unsigned long reaped;
 ----   unsigned long errors;
 ----   unsigned long max_freeable;
 ----   unsigned long node_allocs;
 ----   unsigned long node_frees;
 ----   unsigned long node_overflow;
 ----   atomic_t allochit;
 ----   atomic_t allocmiss;
 ----   atomic_t freehit;
 ----   atomic_t freemiss;
 ----#endif
 ----#if DEBUG
 ----   /*
 ----    * If debugging is enabled, then the allocator can add additional
 ----    * fields and/or padding to every object. buffer_size contains the total
 ----    * object size including these internal fields, the following two
 ----    * variables contain the offset to the user object and its size.
 ----    */
 ----   int obj_offset;
 ----   int obj_size;
 ----#endif
 ----   /*
 ----    * We put nodelists[] at the end of kmem_cache, because we want to size
 ----    * this array to nr_node_ids slots instead of MAX_NUMNODES
 ----    * (see kmem_cache_init())
 ----    * We still use [MAX_NUMNODES] and not [1] or [0] because cache_cache
 ----    * is statically defined, so we reserve the max number of nodes.
 ----    */
 ----   struct kmem_list3 *nodelists[MAX_NUMNODES];
 ----   /*
 ----    * Do not add fields after nodelists[]
 ----    */
 ----};
 ----
     #define CFLGS_OFF_SLAB             (0x80000000UL)
     #define    OFF_SLAB(x)     ((x)->flags & CFLGS_OFF_SLAB)
     
@@@@@@ -679,7 -752,6 -752,6 -752,6 -752,6 +679,7 @@@@@@ static enum 
        NONE,
        PARTIAL_AC,
        PARTIAL_L3,
 ++++   EARLY,
        FULL
     } g_cpucache_up;
     
      */
     int slab_is_available(void)
     {
 ----   return g_cpucache_up == FULL;
 ++++   return g_cpucache_up >= EARLY;
     }
     
     static DEFINE_PER_CPU(struct delayed_work, reap_work);
@@@@@@ -818,6 -890,7 -890,7 -890,7 -890,7 +818,6 @@@@@@ static void __slab_error(const char *fu
       */
     
     static int use_alien_caches __read_mostly = 1;
 ----static int numa_platform __read_mostly = 1;
     static int __init noaliencache_setup(char *s)
     {
        use_alien_caches = 0;
@@@@@@ -885,20 -958,12 -958,12 -958,12 -958,12 +885,20 @@@@@@ static void __cpuinit start_cpu_timer(i
     }
     
     static struct array_cache *alloc_arraycache(int node, int entries,
 ----                                       int batchcount)
 ++++                                       int batchcount, gfp_t gfp)
     {
        int memsize = sizeof(void *) * entries + sizeof(struct array_cache);
        struct array_cache *nc = NULL;
     
 ----   nc = kmalloc_node(memsize, GFP_KERNEL, node);
 ++++   nc = kmalloc_node(memsize, gfp, node);
 ++++   /*
 ++++    * The array_cache structures contain pointers to free object.
 ++++    * However, when such objects are allocated or transfered to another
 ++++    * cache the pointers are not cleared and they could be counted as
 ++++    * valid references during a kmemleak scan. Therefore, kmemleak must
 ++++    * not scan such objects.
 ++++    */
 ++++   kmemleak_no_scan(nc);
        if (nc) {
                nc->avail = 0;
                nc->limit = entries;
@@@@@@ -938,7 -1003,7 -1003,7 -1003,7 -1003,7 +938,7 @@@@@@ static int transfer_objects(struct arra
     #define drain_alien_cache(cachep, alien) do { } while (0)
     #define reap_alien(cachep, l3) do { } while (0)
     
 ----static inline struct array_cache **alloc_alien_cache(int node, int limit)
 ++++static inline struct array_cache **alloc_alien_cache(int node, int limit, gfp_t gfp)
     {
        return (struct array_cache **)BAD_ALIEN_MAGIC;
     }
@@@@@@ -969,7 -1034,7 -1034,7 -1034,7 -1034,7 +969,7 @@@@@@ static inline void *____cache_alloc_nod
     static void *____cache_alloc_node(struct kmem_cache *, gfp_t, int);
     static void *alternate_node_alloc(struct kmem_cache *, gfp_t);
     
 ----static struct array_cache **alloc_alien_cache(int node, int limit)
 ++++static struct array_cache **alloc_alien_cache(int node, int limit, gfp_t gfp)
     {
        struct array_cache **ac_ptr;
        int memsize = sizeof(void *) * nr_node_ids;
     
        if (limit > 1)
                limit = 12;
 ----   ac_ptr = kmalloc_node(memsize, GFP_KERNEL, node);
 ++++   ac_ptr = kmalloc_node(memsize, gfp, node);
        if (ac_ptr) {
                for_each_node(i) {
                        if (i == node || !node_online(i)) {
                                ac_ptr[i] = NULL;
                                continue;
                        }
 ----                   ac_ptr[i] = alloc_arraycache(node, limit, 0xbaadf00d);
 ++++                   ac_ptr[i] = alloc_arraycache(node, limit, 0xbaadf00d, gfp);
                        if (!ac_ptr[i]) {
                                for (i--; i >= 0; i--)
                                        kfree(ac_ptr[i]);
@@@@@@ -1217,20 -1282,20 -1282,20 -1282,20 -1282,20 +1217,20 @@@@@@ static int __cpuinit cpuup_prepare(lon
                struct array_cache **alien = NULL;
     
                nc = alloc_arraycache(node, cachep->limit,
 ----                                   cachep->batchcount);
 ++++                                   cachep->batchcount, GFP_KERNEL);
                if (!nc)
                        goto bad;
                if (cachep->shared) {
                        shared = alloc_arraycache(node,
                                cachep->shared * cachep->batchcount,
 ----                           0xbaadf00d);
 ++++                           0xbaadf00d, GFP_KERNEL);
                        if (!shared) {
                                kfree(nc);
                                goto bad;
                        }
                }
                if (use_alien_caches) {
 ----                   alien = alloc_alien_cache(node, cachep->limit);
 ++++                   alien = alloc_alien_cache(node, cachep->limit, GFP_KERNEL);
                        if (!alien) {
                                kfree(shared);
                                kfree(nc);
@@@@@@ -1334,9 -1399,10 -1399,10 -1399,10 -1399,10 +1334,9 @@@@@@ static void init_list(struct kmem_cach
     {
        struct kmem_list3 *ptr;
     
 ----   ptr = kmalloc_node(sizeof(struct kmem_list3), GFP_KERNEL, nodeid);
 ++++   ptr = kmalloc_node(sizeof(struct kmem_list3), GFP_NOWAIT, nodeid);
        BUG_ON(!ptr);
     
 ----   local_irq_disable();
        memcpy(ptr, list, sizeof(struct kmem_list3));
        /*
         * Do not assume that spinlocks can be initialized via memcpy:
     
        MAKE_ALL_LISTS(cachep, ptr, nodeid);
        cachep->nodelists[nodeid] = ptr;
 ----   local_irq_enable();
     }
     
     /*
@@@@@@ -1376,8 -1443,10 -1443,10 -1443,10 -1443,10 +1376,8 @@@@@@ void __init kmem_cache_init(void
        int order;
        int node;
     
 ----   if (num_possible_nodes() == 1) {
 ++++   if (num_possible_nodes() == 1)
                use_alien_caches = 0;
 ----           numa_platform = 0;
 ----   }
     
        for (i = 0; i < NUM_INIT_LISTS; i++) {
                kmem_list3_init(&initkmem_list3[i]);
        {
                struct array_cache *ptr;
     
 ----           ptr = kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
 ++++           ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);
     
 ----           local_irq_disable();
                BUG_ON(cpu_cache_get(&cache_cache) != &initarray_cache.cache);
                memcpy(ptr, cpu_cache_get(&cache_cache),
                       sizeof(struct arraycache_init));
                spin_lock_init(&ptr->lock);
     
                cache_cache.array[smp_processor_id()] = ptr;
 ----           local_irq_enable();
     
 ----           ptr = kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
 ++++           ptr = kmalloc(sizeof(struct arraycache_init), GFP_NOWAIT);
     
 ----           local_irq_disable();
                BUG_ON(cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep)
                       != &initarray_generic.cache);
                memcpy(ptr, cpu_cache_get(malloc_sizes[INDEX_AC].cs_cachep),
     
                malloc_sizes[INDEX_AC].cs_cachep->array[smp_processor_id()] =
                    ptr;
 ----           local_irq_enable();
        }
        /* 5) Replace the bootstrap kmem_list3's */
        {
                }
        }
     
 ----   /* 6) resize the head arrays to their final sizes */
 ----   {
 ----           struct kmem_cache *cachep;
 ----           mutex_lock(&cache_chain_mutex);
 ----           list_for_each_entry(cachep, &cache_chain, next)
 ----                   if (enable_cpucache(cachep))
 ----                           BUG();
 ----           mutex_unlock(&cache_chain_mutex);
 ----   }
 ++++   g_cpucache_up = EARLY;
     
        /* Annotate slab for lockdep -- annotate the malloc caches */
        init_lock_keys();
 ++++}
 ++++
 ++++void __init kmem_cache_init_late(void)
 ++++{
 ++++   struct kmem_cache *cachep;
     
 ++++   /*
 ++++    * Interrupts are enabled now so all GFP allocations are safe.
 ++++    */
 ++++   slab_gfp_mask = __GFP_BITS_MASK;
 ++++
 ++++   /* 6) resize the head arrays to their final sizes */
 ++++   mutex_lock(&cache_chain_mutex);
 ++++   list_for_each_entry(cachep, &cache_chain, next)
 ++++           if (enable_cpucache(cachep, GFP_NOWAIT))
 ++++                   BUG();
 ++++   mutex_unlock(&cache_chain_mutex);
     
        /* Done! */
        g_cpucache_up = FULL;
@@@@@@ -1624,7 -1689,7 -1689,7 -1689,7 -1689,7 +1624,7 @@@@@@ static void *kmem_getpages(struct kmem_
        if (cachep->flags & SLAB_RECLAIM_ACCOUNT)
                flags |= __GFP_RECLAIMABLE;
     
 ----   page = alloc_pages_node(nodeid, flags, cachep->gfporder);
 ++++   page = alloc_pages_exact_node(nodeid, flags | __GFP_NOTRACK, cachep->gfporder);
        if (!page)
                return NULL;
     
                        NR_SLAB_UNRECLAIMABLE, nr_pages);
        for (i = 0; i < nr_pages; i++)
                __SetPageSlab(page + i);
 ++++
 ++++   if (kmemcheck_enabled && !(cachep->flags & SLAB_NOTRACK)) {
 ++++           kmemcheck_alloc_shadow(page, cachep->gfporder, flags, nodeid);
 ++++
 ++++           if (cachep->ctor)
 ++++                   kmemcheck_mark_uninitialized_pages(page, nr_pages);
 ++++           else
 ++++                   kmemcheck_mark_unallocated_pages(page, nr_pages);
 ++++   }
 ++++
        return page_address(page);
     }
     
@@@@@@ -1659,8 -1714,6 -1714,6 -1714,6 -1714,6 +1659,8 @@@@@@ static void kmem_freepages(struct kmem_
        struct page *page = virt_to_page(addr);
        const unsigned long nr_freed = i;
     
 ++++   kmemcheck_free_shadow(page, cachep->gfporder);
 ++++
        if (cachep->flags & SLAB_RECLAIM_ACCOUNT)
                sub_zone_page_state(page_zone(page),
                                NR_SLAB_RECLAIMABLE, nr_freed);
@@@@@@ -2011,10 -2064,10 -2064,10 -2064,10 -2064,10 +2011,10 @@@@@@ static size_t calculate_slab_order(stru
        return left_over;
     }
     
 ----static int __init_refok setup_cpu_cache(struct kmem_cache *cachep)
 ++++static int __init_refok setup_cpu_cache(struct kmem_cache *cachep, gfp_t gfp)
     {
        if (g_cpucache_up == FULL)
 ----           return enable_cpucache(cachep);
 ++++           return enable_cpucache(cachep, gfp);
     
        if (g_cpucache_up == NONE) {
                /*
                        g_cpucache_up = PARTIAL_AC;
        } else {
                cachep->array[smp_processor_id()] =
 ----                   kmalloc(sizeof(struct arraycache_init), GFP_KERNEL);
 ++++                   kmalloc(sizeof(struct arraycache_init), gfp);
     
                if (g_cpucache_up == PARTIAL_AC) {
                        set_up_list3s(cachep, SIZE_L3);
                        for_each_online_node(node) {
                                cachep->nodelists[node] =
                                    kmalloc_node(sizeof(struct kmem_list3),
 ----                                           GFP_KERNEL, node);
 ++++                                           gfp, node);
                                BUG_ON(!cachep->nodelists[node]);
                                kmem_list3_init(cachep->nodelists[node]);
                        }
@@@@@@ -2100,7 -2153,6 -2153,6 -2153,6 -2153,6 +2100,7 @@@@@@ kmem_cache_create (const char *name, si
     {
        size_t left_over, slab_size, ralign;
        struct kmem_cache *cachep = NULL, *pc;
 ++++   gfp_t gfp;
     
        /*
         * Sanity checks... these are all serious usage bugs.
         * We use cache_chain_mutex to ensure a consistent view of
         * cpu_online_mask as well.  Please see cpuup_callback
         */
 ----   get_online_cpus();
 ----   mutex_lock(&cache_chain_mutex);
 ++++   if (slab_is_available()) {
 ++++           get_online_cpus();
 ++++           mutex_lock(&cache_chain_mutex);
 ++++   }
     
        list_for_each_entry(pc, &cache_chain, next) {
                char tmp;
         */
        align = ralign;
     
 ++++   if (slab_is_available())
 ++++           gfp = GFP_KERNEL;
 ++++   else
 ++++           gfp = GFP_NOWAIT;
 ++++
        /* Get cache's description obj. */
 ----   cachep = kmem_cache_zalloc(&cache_cache, GFP_KERNEL);
 ++++   cachep = kmem_cache_zalloc(&cache_cache, gfp);
        if (!cachep)
                goto oops;
     
                /* really off slab. No need for manual alignment */
                slab_size =
                    cachep->num * sizeof(kmem_bufctl_t) + sizeof(struct slab);
++ ++
++ ++#ifdef CONFIG_PAGE_POISONING
++ ++           /* If we're going to use the generic kernel_map_pages()
++ ++            * poisoning, then it's going to smash the contents of
++ ++            * the redzone and userword anyhow, so switch them off.
++ ++            */
++ ++           if (size % PAGE_SIZE == 0 && flags & SLAB_POISON)
++ ++                   flags &= ~(SLAB_RED_ZONE | SLAB_STORE_USER);
++ ++#endif
        }
     
        cachep->colour_off = cache_line_size();
        cachep->ctor = ctor;
        cachep->name = name;
     
 ----   if (setup_cpu_cache(cachep)) {
 ++++   if (setup_cpu_cache(cachep, gfp)) {
                __kmem_cache_destroy(cachep);
                cachep = NULL;
                goto oops;
        if (!cachep && (flags & SLAB_PANIC))
                panic("kmem_cache_create(): failed to create slab `%s'\n",
                      name);
 ----   mutex_unlock(&cache_chain_mutex);
 ----   put_online_cpus();
 ++++   if (slab_is_available()) {
 ++++           mutex_unlock(&cache_chain_mutex);
 ++++           put_online_cpus();
 ++++   }
        return cachep;
     }
     EXPORT_SYMBOL(kmem_cache_create);
@@@@@@ -2578,14 -2621,6 -2630,6 -2621,6 -2621,6 +2587,14 @@@@@@ static struct slab *alloc_slabmgmt(stru
                /* Slab management obj is off-slab. */
                slabp = kmem_cache_alloc_node(cachep->slabp_cache,
                                              local_flags, nodeid);
 ++++           /*
 ++++            * If the first object in the slab is leaked (it's allocated
 ++++            * but no one has a reference to it), we want to make sure
 ++++            * kmemleak does not treat the ->s_mem pointer as a reference
 ++++            * to the object. Otherwise we will not report the leak.
 ++++            */
 ++++           kmemleak_scan_area(slabp, offsetof(struct slab, list),
 ++++                              sizeof(struct list_head), local_flags);
                if (!slabp)
                        return NULL;
        } else {
@@@@@@ -3106,12 -3141,6 -3150,6 -3141,6 -3141,6 +3115,12 @@@@@@ static inline void *____cache_alloc(str
                STATS_INC_ALLOCMISS(cachep);
                objp = cache_alloc_refill(cachep, flags);
        }
 ++++   /*
 ++++    * To avoid a false negative, if an object that is in one of the
 ++++    * per-CPU caches is leaked, we need to make sure kmemleak doesn't
 ++++    * treat the array pointers as a reference to the object.
 ++++    */
 ++++   kmemleak_erase(&ac->entry[ac->avail]);
        return objp;
     }
     
                if (local_flags & __GFP_WAIT)
                        local_irq_enable();
                kmem_flagcheck(cache, flags);
 ----           obj = kmem_getpages(cache, local_flags, -1);
 ++++           obj = kmem_getpages(cache, local_flags, numa_node_id());
                if (local_flags & __GFP_WAIT)
                        local_irq_disable();
                if (obj) {
@@@@@@ -3298,8 -3327,6 -3336,6 -3327,6 -3327,6 +3307,8 @@@@@@ __cache_alloc_node(struct kmem_cache *c
        unsigned long save_flags;
        void *ptr;
     
 ++++   flags &= slab_gfp_mask;
 ++++
        lockdep_trace_alloc(flags);
     
        if (slab_should_failslab(cachep, flags))
       out:
        local_irq_restore(save_flags);
        ptr = cache_alloc_debugcheck_after(cachep, flags, ptr, caller);
 ++++   kmemleak_alloc_recursive(ptr, obj_size(cachep), 1, cachep->flags,
 ++++                            flags);
 ++++
 ++++   if (likely(ptr))
 ++++           kmemcheck_slab_alloc(cachep, flags, ptr, obj_size(cachep));
     
        if (unlikely((flags & __GFP_ZERO) && ptr))
                memset(ptr, 0, obj_size(cachep));
@@@@@@ -3383,8 -3405,6 -3414,6 -3405,6 -3405,6 +3392,8 @@@@@@ __cache_alloc(struct kmem_cache *cachep
        unsigned long save_flags;
        void *objp;
     
 ++++   flags &= slab_gfp_mask;
 ++++
        lockdep_trace_alloc(flags);
     
        if (slab_should_failslab(cachep, flags))
        objp = __do_cache_alloc(cachep, flags);
        local_irq_restore(save_flags);
        objp = cache_alloc_debugcheck_after(cachep, flags, objp, caller);
 ++++   kmemleak_alloc_recursive(objp, obj_size(cachep), 1, cachep->flags,
 ++++                            flags);
        prefetchw(objp);
     
 ++++   if (likely(objp))
 ++++           kmemcheck_slab_alloc(cachep, flags, objp, obj_size(cachep));
 ++++
        if (unlikely((flags & __GFP_ZERO) && objp))
                memset(objp, 0, obj_size(cachep));
     
@@@@@@ -3515,11 -3530,8 -3539,8 -3530,8 -3530,8 +3524,11 @@@@@@ static inline void __cache_free(struct 
        struct array_cache *ac = cpu_cache_get(cachep);
     
        check_irq_off();
 ++++   kmemleak_free_recursive(objp, cachep->flags);
        objp = cache_free_debugcheck(cachep, objp, __builtin_return_address(0));
     
 ++++   kmemcheck_slab_free(cachep, objp, obj_size(cachep));
 ++++
        /*
         * Skip calling cache_free_alien() when the platform is not numa.
         * This will avoid cache misses that happen while accessing slabp (which
         * variable to skip the call, which is mostly likely to be present in
         * the cache.
         */
 ----   if (numa_platform && cache_free_alien(cachep, objp))
 ++++   if (nr_online_nodes > 1 && cache_free_alien(cachep, objp))
                return;
     
        if (likely(ac->avail < ac->limit)) {
@@@@@@ -3790,7 -3802,7 -3811,7 -3802,7 -3802,7 +3799,7 @@@@@@ EXPORT_SYMBOL_GPL(kmem_cache_name)
     /*
      * This initializes kmem_list3 or resizes various caches for all nodes.
      */
 ----static int alloc_kmemlist(struct kmem_cache *cachep)
 ++++static int alloc_kmemlist(struct kmem_cache *cachep, gfp_t gfp)
     {
        int node;
        struct kmem_list3 *l3;
        for_each_online_node(node) {
     
                     if (use_alien_caches) {
 ----                        new_alien = alloc_alien_cache(node, cachep->limit);
 ++++                        new_alien = alloc_alien_cache(node, cachep->limit, gfp);
                             if (!new_alien)
                                     goto fail;
                     }
                if (cachep->shared) {
                        new_shared = alloc_arraycache(node,
                                cachep->shared*cachep->batchcount,
 ----                                   0xbaadf00d);
 ++++                                   0xbaadf00d, gfp);
                        if (!new_shared) {
                                free_alien_cache(new_alien);
                                goto fail;
                        free_alien_cache(new_alien);
                        continue;
                }
 ----           l3 = kmalloc_node(sizeof(struct kmem_list3), GFP_KERNEL, node);
 ++++           l3 = kmalloc_node(sizeof(struct kmem_list3), gfp, node);
                if (!l3) {
                        free_alien_cache(new_alien);
                        kfree(new_shared);
@@@@@@ -3894,18 -3906,18 -3915,18 -3906,18 -3906,18 +3903,18 @@@@@@ static void do_ccupdate_local(void *inf
     
     /* Always called with the cache_chain_mutex held */
     static int do_tune_cpucache(struct kmem_cache *cachep, int limit,
 ----                           int batchcount, int shared)
 ++++                           int batchcount, int shared, gfp_t gfp)
     {
        struct ccupdate_struct *new;
        int i;
     
 ----   new = kzalloc(sizeof(*new), GFP_KERNEL);
 ++++   new = kzalloc(sizeof(*new), gfp);
        if (!new)
                return -ENOMEM;
     
        for_each_online_cpu(i) {
                new->new[i] = alloc_arraycache(cpu_to_node(i), limit,
 ----                                           batchcount);
 ++++                                           batchcount, gfp);
                if (!new->new[i]) {
                        for (i--; i >= 0; i--)
                                kfree(new->new[i]);
                kfree(ccold);
        }
        kfree(new);
 ----   return alloc_kmemlist(cachep);
 ++++   return alloc_kmemlist(cachep, gfp);
     }
     
     /* Called with cache_chain_mutex held always */
 ----static int enable_cpucache(struct kmem_cache *cachep)
 ++++static int enable_cpucache(struct kmem_cache *cachep, gfp_t gfp)
     {
        int err;
        int limit, shared;
        if (limit > 32)
                limit = 32;
     #endif
 ----   err = do_tune_cpucache(cachep, limit, (limit + 1) / 2, shared);
 ++++   err = do_tune_cpucache(cachep, limit, (limit + 1) / 2, shared, gfp);
        if (err)
                printk(KERN_ERR "enable_cpucache failed for %s, error %d.\n",
                       cachep->name, -err);
@@@@@@ -4288,8 -4300,7 -4309,7 -4300,7 -4300,7 +4297,8 @@@@@@ ssize_t slabinfo_write(struct file *fil
                                res = 0;
                        } else {
                                res = do_tune_cpucache(cachep, limit,
 ----                                                  batchcount, shared);
 ++++                                                  batchcount, shared,
 ++++                                                  GFP_KERNEL);
                        }
                        break;
                }
diff --combined mm/slob.c
index 64f6db1943bfd501281c046a04f74023b198d132,f92e66d558bd3608f5c758d7b7c39748cf936f51,a2d4ab32198d85b9773926c27ba7fdd07adfbfe7,aad9dad2e8206716b2a5a58839316ad43da50aaa,f92e66d558bd3608f5c758d7b7c39748cf936f51..c78742defdc6477ef7474ebc1fc8117173aaabfc
+++ b/mm/slob.c
      * NUMA support in SLOB is fairly simplistic, pushing most of the real
      * logic down to the page allocator, and simply doing the node accounting
      * on the upper levels. In the event that a node id is explicitly
 ---- * provided, alloc_pages_node() with the specified node id is used
 ++++ * provided, alloc_pages_exact_node() with the specified node id is used
      * instead. The common case (or when the node id isn't explicitly provided)
      * will default to the current node, as per numa_node_id().
      *
     #include <linux/kernel.h>
     #include <linux/slab.h>
     #include <linux/mm.h>
  ++ #include <linux/swap.h> /* struct reclaim_state */
     #include <linux/cache.h>
     #include <linux/init.h>
     #include <linux/module.h>
     #include <linux/rcupdate.h>
     #include <linux/list.h>
 ----#include <trace/kmemtrace.h>
 ++++#include <linux/kmemtrace.h>
 ++++#include <linux/kmemleak.h>
     #include <asm/atomic.h>
     
     /*
@@@@@@ -133,17 -132,17 -131,17 -131,17 -132,17 +133,17 @@@@@@ static LIST_HEAD(free_slob_large)
      */
     static inline int is_slob_page(struct slob_page *sp)
     {
--- -   return PageSlobPage((struct page *)sp);
+++ +   return PageSlab((struct page *)sp);
     }
     
     static inline void set_slob_page(struct slob_page *sp)
     {
--- -   __SetPageSlobPage((struct page *)sp);
+++ +   __SetPageSlab((struct page *)sp);
     }
     
     static inline void clear_slob_page(struct slob_page *sp)
     {
--- -   __ClearPageSlobPage((struct page *)sp);
+++ +   __ClearPageSlab((struct page *)sp);
     }
     
     static inline struct slob_page *slob_page(const void *addr)
@@@@@@ -244,7 -243,7 -242,7 -242,7 -243,7 +244,7 @@@@@@ static void *slob_new_pages(gfp_t gfp, 
     
     #ifdef CONFIG_NUMA
        if (node != -1)
 ----           page = alloc_pages_node(node, gfp, order);
 ++++           page = alloc_pages_exact_node(node, gfp, order);
        else
     #endif
                page = alloc_pages(gfp, order);
     
     static void slob_free_pages(void *b, int order)
     {
  ++    if (current->reclaim_state)
  ++            current->reclaim_state->reclaimed_slab += 1 << order;
        free_pages((unsigned long)b, order);
     }
     
@@@@@@ -411,7 -410,7 -407,7 -407,7 -410,7 +411,7 @@@@@@ static void slob_free(void *block, int 
                spin_unlock_irqrestore(&slob_lock, flags);
                clear_slob_page(sp);
                free_slob_page(sp);
  --            free_page((unsigned long)b);
  ++            slob_free_pages(b, 0);
                return;
        }
     
@@@@@@ -510,7 -509,6 -506,6 -506,6 -509,6 +510,7 @@@@@@ void *__kmalloc_node(size_t size, gfp_
                                   size, PAGE_SIZE << order, gfp, node);
        }
     
 ++++   kmemleak_alloc(ret, size, 1, gfp);
        return ret;
     }
     EXPORT_SYMBOL(__kmalloc_node);
@@@@@@ -523,7 -521,6 -518,6 -518,6 -521,6 +523,7 @@@@@@ void kfree(const void *block
     
        if (unlikely(ZERO_OR_NULL_PTR(block)))
                return;
 ++++   kmemleak_free(block);
     
        sp = slob_page(block);
        if (is_slob_page(sp)) {
@@@@@@ -587,14 -584,12 -581,12 -581,12 -584,12 +587,14 @@@@@@ struct kmem_cache *kmem_cache_create(co
        } else if (flags & SLAB_PANIC)
                panic("Cannot create slab cache %s\n", name);
     
 ++++   kmemleak_alloc(c, sizeof(struct kmem_cache), 1, GFP_KERNEL);
        return c;
     }
     EXPORT_SYMBOL(kmem_cache_create);
     
     void kmem_cache_destroy(struct kmem_cache *c)
     {
 ++++   kmemleak_free(c);
        slob_free(c, sizeof(struct kmem_cache));
     }
     EXPORT_SYMBOL(kmem_cache_destroy);
@@@@@@ -618,7 -613,6 -610,6 -610,6 -613,6 +618,7 @@@@@@ void *kmem_cache_alloc_node(struct kmem
        if (c->ctor)
                c->ctor(b);
     
 ++++   kmemleak_alloc_recursive(b, c->size, 1, c->flags, flags);
        return b;
     }
     EXPORT_SYMBOL(kmem_cache_alloc_node);
@@@@@@ -641,7 -635,6 -632,6 -632,6 -635,6 +641,7 @@@@@@ static void kmem_rcu_free(struct rcu_he
     
     void kmem_cache_free(struct kmem_cache *c, void *b)
     {
 ++++   kmemleak_free_recursive(b, c->flags);
        if (unlikely(c->flags & SLAB_DESTROY_BY_RCU)) {
                struct slob_rcu *slob_rcu;
                slob_rcu = b + (c->size - sizeof(struct slob_rcu));
diff --combined mm/slub.c
index 2701419b0adcab389434cb07a3f7f9af175afeca,65ffda5934b09b8220e9a00332945dc19ba88de6,7ab54ecbd3f3a5abe50eba2c0a5dc035bf4d5efc,7ab54ecbd3f3a5abe50eba2c0a5dc035bf4d5efc,0996b3be751a8c79b2c71b529e1bfe892417ef96..b2b0c78ae35d04b74c0cea458ac93a78ee859e44
+++ b/mm/slub.c
@@@@@@ -9,7 -9,7 -9,6 -9,6 -9,7 +9,7 @@@@@@
      */
     
     #include <linux/mm.h>
  ++ #include <linux/swap.h> /* struct reclaim_state */
     #include <linux/module.h>
     #include <linux/bit_spinlock.h>
     #include <linux/interrupt.h>
     #include <linux/slab.h>
     #include <linux/proc_fs.h>
     #include <linux/seq_file.h>
 ----#include <trace/kmemtrace.h>
 ++++#include <linux/kmemtrace.h>
 ++++#include <linux/kmemcheck.h>
     #include <linux/cpu.h>
     #include <linux/cpuset.h>
 ++++#include <linux/kmemleak.h>
     #include <linux/mempolicy.h>
     #include <linux/ctype.h>
     #include <linux/debugobjects.h>
      * Set of flags that will prevent slab merging
      */
     #define SLUB_NEVER_MERGE (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER | \
 ----           SLAB_TRACE | SLAB_DESTROY_BY_RCU)
 ++++           SLAB_TRACE | SLAB_DESTROY_BY_RCU | SLAB_NOLEAKTRACE)
     
     #define SLUB_MERGE_SAME (SLAB_DEBUG_FREE | SLAB_RECLAIM_ACCOUNT | \
 ----           SLAB_CACHE_DMA)
 ++++           SLAB_CACHE_DMA | SLAB_NOTRACK)
     
     #ifndef ARCH_KMALLOC_MINALIGN
     #define ARCH_KMALLOC_MINALIGN __alignof__(unsigned long long)
@@@@@@ -179,12 -177,6 -176,6 -176,6 -177,6 +179,12 @@@@@@ static enum 
        SYSFS           /* Sysfs up */
     } slab_state = DOWN;
     
 ++++/*
 ++++ * The slab allocator is initialized with interrupts disabled. Therefore, make
 ++++ * sure early boot allocations don't accidentally enable interrupts.
 ++++ */
 ++++static gfp_t slab_gfp_mask __read_mostly = SLAB_GFP_BOOT_MASK;
 ++++
     /* A list of all slab caches on the system */
     static DECLARE_RWSEM(slub_lock);
     static LIST_HEAD(slab_caches);
@@@@@@ -840,6 -832,6 -831,6 -831,6 -832,11 +840,11 @@@@@@ static inline unsigned long slabs_node(
        return atomic_long_read(&n->nr_slabs);
     }
     
++++ static inline unsigned long node_nr_slabs(struct kmem_cache_node *n)
++++ {
++++    return atomic_long_read(&n->nr_slabs);
++++ }
++++ 
     static inline void inc_slabs_node(struct kmem_cache *s, int node, int objects)
     {
        struct kmem_cache_node *n = get_node(s, node);
@@@@@@ -1058,6 -1050,6 -1049,6 -1049,6 -1055,8 +1063,8 @@@@@@ static inline unsigned long kmem_cache_
     
     static inline unsigned long slabs_node(struct kmem_cache *s, int node)
                                                        { return 0; }
++++ static inline unsigned long node_nr_slabs(struct kmem_cache_node *n)
++++                                                    { return 0; }
     static inline void inc_slabs_node(struct kmem_cache *s, int node,
                                                        int objects) {}
     static inline void dec_slabs_node(struct kmem_cache *s, int node,
@@@@@@ -1072,8 -1064,6 -1063,6 -1063,6 -1071,6 +1079,8 @@@@@@ static inline struct page *alloc_slab_p
     {
        int order = oo_order(oo);
     
 ++++   flags |= __GFP_NOTRACK;
 ++++
        if (node == -1)
                return alloc_pages(flags, order);
        else
@@@@@@ -1101,24 -1091,6 -1090,6 -1090,6 -1098,6 +1108,24 @@@@@@ static struct page *allocate_slab(struc
     
                stat(get_cpu_slab(s, raw_smp_processor_id()), ORDER_FALLBACK);
        }
 ++++
 ++++   if (kmemcheck_enabled
 ++++           && !(s->flags & (SLAB_NOTRACK | DEBUG_DEFAULT_FLAGS)))
 ++++   {
 ++++           int pages = 1 << oo_order(oo);
 ++++
 ++++           kmemcheck_alloc_shadow(page, oo_order(oo), flags, node);
 ++++
 ++++           /*
 ++++            * Objects from caches that have a constructor don't get
 ++++            * cleared when they're allocated, so we need to do it here.
 ++++            */
 ++++           if (s->ctor)
 ++++                   kmemcheck_mark_uninitialized_pages(page, pages);
 ++++           else
 ++++                   kmemcheck_mark_unallocated_pages(page, pages);
 ++++   }
 ++++
        page->objects = oo_objects(oo);
        mod_zone_page_state(page_zone(page),
                (s->flags & SLAB_RECLAIM_ACCOUNT) ?
@@@@@@ -1192,8 -1164,6 -1163,6 -1163,6 -1171,6 +1199,8 @@@@@@ static void __free_slab(struct kmem_cac
                __ClearPageSlubDebug(page);
        }
     
 ++++   kmemcheck_free_shadow(page, compound_order(page));
 ++++
        mod_zone_page_state(page_zone(page),
                (s->flags & SLAB_RECLAIM_ACCOUNT) ?
                NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE,
     
        __ClearPageSlab(page);
        reset_page_mapcount(page);
  ++    if (current->reclaim_state)
  ++            current->reclaim_state->reclaimed_slab += pages;
        __free_pages(page, order);
     }
     
@@@@@@ -1514,6 -1484,6 -1481,6 -1481,6 -1491,65 +1521,65 @@@@@@ static inline int node_match(struct kme
        return 1;
     }
     
++++ static int count_free(struct page *page)
++++ {
++++    return page->objects - page->inuse;
++++ }
++++ 
++++ static unsigned long count_partial(struct kmem_cache_node *n,
++++                                    int (*get_count)(struct page *))
++++ {
++++    unsigned long flags;
++++    unsigned long x = 0;
++++    struct page *page;
++++ 
++++    spin_lock_irqsave(&n->list_lock, flags);
++++    list_for_each_entry(page, &n->partial, lru)
++++            x += get_count(page);
++++    spin_unlock_irqrestore(&n->list_lock, flags);
++++    return x;
++++ }
++++ 
++++ static inline unsigned long node_nr_objs(struct kmem_cache_node *n)
++++ {
++++ #ifdef CONFIG_SLUB_DEBUG
++++    return atomic_long_read(&n->total_objects);
++++ #else
++++    return 0;
++++ #endif
++++ }
++++ 
++++ static noinline void
++++ slab_out_of_memory(struct kmem_cache *s, gfp_t gfpflags, int nid)
++++ {
++++    int node;
++++ 
++++    printk(KERN_WARNING
++++            "SLUB: Unable to allocate memory on node %d (gfp=0x%x)\n",
++++            nid, gfpflags);
++++    printk(KERN_WARNING "  cache: %s, object size: %d, buffer size: %d, "
++++            "default order: %d, min order: %d\n", s->name, s->objsize,
++++            s->size, oo_order(s->oo), oo_order(s->min));
++++ 
++++    for_each_online_node(node) {
++++            struct kmem_cache_node *n = get_node(s, node);
++++            unsigned long nr_slabs;
++++            unsigned long nr_objs;
++++            unsigned long nr_free;
++++ 
++++            if (!n)
++++                    continue;
++++ 
++++            nr_free  = count_partial(n, count_free);
++++            nr_slabs = node_nr_slabs(n);
++++            nr_objs  = node_nr_objs(n);
++++ 
++++            printk(KERN_WARNING
++++                    "  node %d: slabs: %ld, objs: %ld, free: %ld\n",
++++                    node, nr_slabs, nr_objs, nr_free);
++++    }
++++ }
++++ 
     /*
      * Slow path. The lockless freelist is empty or we need to perform
      * debugging duties.
@@@@@@ -1595,6 -1565,6 -1562,6 -1562,6 -1631,8 +1661,8 @@@@@@ new_slab
                c->page = new;
                goto load_freelist;
        }
++++    if (!(gfpflags & __GFP_NOWARN) && printk_ratelimit())
++++            slab_out_of_memory(s, gfpflags, node);
        return NULL;
     debug:
        if (!alloc_debug_processing(s, c->page, object, addr))
@@@@@@ -1624,8 -1594,6 -1591,6 -1591,6 -1662,6 +1692,8 @@@@@@ static __always_inline void *slab_alloc
        unsigned long flags;
        unsigned int objsize;
     
 ++++   gfpflags &= slab_gfp_mask;
 ++++
        lockdep_trace_alloc(gfpflags);
        might_sleep_if(gfpflags & __GFP_WAIT);
     
        if (unlikely((gfpflags & __GFP_ZERO) && object))
                memset(object, 0, objsize);
     
 ++++   kmemcheck_slab_alloc(s, gfpflags, object, c->objsize);
 ++++   kmemleak_alloc_recursive(object, objsize, 1, s->flags, gfpflags);
 ++++
        return object;
     }
     
@@@@@@ -1781,10 -1746,8 -1743,8 -1743,8 -1814,8 +1849,10 @@@@@@ static __always_inline void slab_free(s
        struct kmem_cache_cpu *c;
        unsigned long flags;
     
 ++++   kmemleak_free_recursive(x, s->flags);
        local_irq_save(flags);
        c = get_cpu_slab(s, smp_processor_id());
 ++++   kmemcheck_slab_free(s, object, c->objsize);
        debug_check_no_locks_freed(object, c->objsize);
        if (!(s->flags & SLAB_DEBUG_OBJECTS))
                debug_check_no_obj_freed(object, c->objsize);
@@@@@@ -1949,7 -1912,7 -1909,7 -1909,7 -1980,7 +2017,7 @@@@@@ static inline int calculate_order(int s
         * Doh this slab cannot be placed using slub_max_order.
         */
        order = slab_order(size, 1, MAX_ORDER, 1);
  --    if (order <= MAX_ORDER)
  ++    if (order < MAX_ORDER)
                return order;
        return -ENOSYS;
     }
@@@@@@ -2562,7 -2525,7 -2522,6 -2522,6 -2593,7 +2630,7 @@@@@@ __setup("slub_min_order=", setup_slub_m
     static int __init setup_slub_max_order(char *str)
     {
        get_option(&str, &slub_max_order);
  ++    slub_max_order = min(slub_max_order, MAX_ORDER - 1);
     
        return 1;
     }
@@@@@@ -2594,16 -2557,13 -2553,13 -2553,13 -2625,13 +2662,16 @@@@@@ static struct kmem_cache *create_kmallo
        if (gfp_flags & SLUB_DMA)
                flags = SLAB_CACHE_DMA;
     
 ----   down_write(&slub_lock);
 ++++   /*
 ++++    * This function is called with IRQs disabled during early-boot on
 ++++    * single CPU so there's no need to take slub_lock here.
 ++++    */
        if (!kmem_cache_open(s, gfp_flags, name, size, ARCH_KMALLOC_MINALIGN,
                                                                flags, NULL))
                goto panic;
     
        list_add(&s->list, &slab_caches);
 ----   up_write(&slub_lock);
 ++++
        if (sysfs_slab_add(s))
                goto panic;
        return s;
@@@@@@ -2659,8 -2619,7 -2615,7 -2615,7 -2687,7 +2727,8 @@@@@@ static noinline struct kmem_cache *dma_
     
        if (!s || !text || !kmem_cache_open(s, flags, text,
                        realsize, ARCH_KMALLOC_MINALIGN,
 ----                   SLAB_CACHE_DMA|__SYSFS_ADD_DEFERRED, NULL)) {
 ++++                   SLAB_CACHE_DMA|SLAB_NOTRACK|__SYSFS_ADD_DEFERRED,
 ++++                   NULL)) {
                kfree(s);
                kfree(text);
                goto unlock_out;
@@@@@@ -2754,10 -2713,9 -2709,9 -2709,9 -2781,9 +2822,10 @@@@@@ EXPORT_SYMBOL(__kmalloc)
     
     static void *kmalloc_large_node(size_t size, gfp_t flags, int node)
     {
 ----   struct page *page = alloc_pages_node(node, flags | __GFP_COMP,
 ----                                           get_order(size));
 ++++   struct page *page;
     
 ++++   flags |= __GFP_COMP | __GFP_NOTRACK;
 ++++   page = alloc_pages_node(node, flags, get_order(size));
        if (page)
                return page_address(page);
        else
@@@@@@ -3063,7 -3021,7 -3017,7 -3017,7 -3089,7 +3131,7 @@@@@@ void __init kmem_cache_init(void
         * kmem_cache_open for slab_state == DOWN.
         */
        create_kmalloc_cache(&kmalloc_caches[0], "kmem_cache_node",
 ----           sizeof(struct kmem_cache_node), GFP_KERNEL);
 ++++           sizeof(struct kmem_cache_node), GFP_NOWAIT);
        kmalloc_caches[0].refcount = -1;
        caches++;
     
        /* Caches that are not of the two-to-the-power-of size */
        if (KMALLOC_MIN_SIZE <= 64) {
                create_kmalloc_cache(&kmalloc_caches[1],
 ----                           "kmalloc-96", 96, GFP_KERNEL);
 ++++                           "kmalloc-96", 96, GFP_NOWAIT);
                caches++;
                create_kmalloc_cache(&kmalloc_caches[2],
 ----                           "kmalloc-192", 192, GFP_KERNEL);
 ++++                           "kmalloc-192", 192, GFP_NOWAIT);
                caches++;
        }
     
        for (i = KMALLOC_SHIFT_LOW; i < SLUB_PAGE_SHIFT; i++) {
                create_kmalloc_cache(&kmalloc_caches[i],
 ----                   "kmalloc", 1 << i, GFP_KERNEL);
 ++++                   "kmalloc", 1 << i, GFP_NOWAIT);
                caches++;
        }
     
        /* Provide the correct kmalloc names now that the caches are up */
        for (i = KMALLOC_SHIFT_LOW; i < SLUB_PAGE_SHIFT; i++)
                kmalloc_caches[i]. name =
 ----                   kasprintf(GFP_KERNEL, "kmalloc-%d", 1 << i);
 ++++                   kasprintf(GFP_NOWAIT, "kmalloc-%d", 1 << i);
     
     #ifdef CONFIG_SMP
        register_cpu_notifier(&slab_notifier);
                nr_cpu_ids, nr_node_ids);
     }
     
 ++++void __init kmem_cache_init_late(void)
 ++++{
 ++++   /*
 ++++    * Interrupts are enabled now so all GFP allocations are safe.
 ++++    */
 ++++   slab_gfp_mask = __GFP_BITS_MASK;
 ++++}
 ++++
     /*
      * Find a mergeable slab cache
      */
@@@@@@ -3368,20 -3318,20 -3314,20 -3314,20 -3386,6 +3436,6 @@@@@@ void *__kmalloc_node_track_caller(size_
     }
     
     #ifdef CONFIG_SLUB_DEBUG
---- static unsigned long count_partial(struct kmem_cache_node *n,
----                                    int (*get_count)(struct page *))
---- {
----    unsigned long flags;
----    unsigned long x = 0;
----    struct page *page;
---- 
----    spin_lock_irqsave(&n->list_lock, flags);
----    list_for_each_entry(page, &n->partial, lru)
----            x += get_count(page);
----    spin_unlock_irqrestore(&n->list_lock, flags);
----    return x;
---- }
---- 
     static int count_inuse(struct page *page)
     {
        return page->inuse;
@@@@@@ -3392,11 -3342,11 -3338,11 -3338,11 -3396,6 +3446,6 @@@@@@ static int count_total(struct page *pag
        return page->objects;
     }
     
---- static int count_free(struct page *page)
---- {
----    return page->objects - page->inuse;
---- }
---- 
     static int validate_slab(struct kmem_cache *s, struct page *page,
                                                unsigned long *map)
     {
@@@@@@ -3765,7 -3715,7 -3711,7 -3711,7 -3764,7 +3814,7 @@@@@@ static int list_locations(struct kmem_c
                                                 to_cpumask(l->cpus));
                }
     
 ----           if (num_online_nodes() > 1 && !nodes_empty(l->nodes) &&
 ++++           if (nr_online_nodes > 1 && !nodes_empty(l->nodes) &&
                                len < PAGE_SIZE - 60) {
                        len += sprintf(buf + len, " nodes=");
                        len += nodelist_scnprintf(buf + len, PAGE_SIZE - len - 50,
@@@@@@ -4440,8 -4390,6 -4386,6 -4386,6 -4439,6 +4489,8 @@@@@@ static char *create_unique_id(struct km
                *p++ = 'a';
        if (s->flags & SLAB_DEBUG_FREE)
                *p++ = 'F';
 ++++   if (!(s->flags & SLAB_NOTRACK))
 ++++           *p++ = 't';
        if (p != name + 1)
                *p++ = '-';
        p += sprintf(p, "%07d", s->size);
diff --combined mm/util.c
index d5d2213728c51725fb658b5e20225cb429d93015,e79572b3684ccb9f467d42b4f18420640e706b07,55bef160b9f1484c032220b506f4ebfaeffe9a47,55bef160b9f1484c032220b506f4ebfaeffe9a47,55bef160b9f1484c032220b506f4ebfaeffe9a47..7c35ad95f92756d1473bbc2ae658f5bb27de2ca9
+++ b/mm/util.c
@@@@@@ -4,11 -4,9 -4,9 -4,9 -4,9 +4,11 @@@@@@
     #include <linux/module.h>
     #include <linux/err.h>
     #include <linux/sched.h>
 ----#include <linux/tracepoint.h>
     #include <asm/uaccess.h>
     
 ++++#define CREATE_TRACE_POINTS
 ++++#include <trace/events/kmem.h>
 ++++
     /**
      * kstrdup - allocate space for and copy an existing string
      * @s: the string to duplicate
@@@@@@ -168,6 -166,10 -166,6 -166,6 -166,6 +168,10 @@@@@@ EXPORT_SYMBOL(krealloc)
      *
      * The memory of the object @p points to is zeroed before freed.
      * If @p is %NULL, kzfree() does nothing.
+ +++ *
+ +++ * Note: this function zeroes the whole allocated buffer which can be a good
+ +++ * deal bigger than the requested buffer size passed to kmalloc(). So be
+ +++ * careful when using this function in performance sensitive code.
      */
     void kzfree(const void *p)
     {
@@@@@@ -233,21 -235,13 -231,13 -231,13 -231,13 +237,21 @@@@@@ void arch_pick_mmap_layout(struct mm_st
      * @pages: array that receives pointers to the pages pinned.
      *         Should be at least nr_pages long.
      *
 ---- * Attempt to pin user pages in memory without taking mm->mmap_sem.
 ---- * If not successful, it will fall back to taking the lock and
 ---- * calling get_user_pages().
 ---- *
      * Returns number of pages pinned. This may be fewer than the number
      * requested. If nr_pages is 0 or negative, returns 0. If no pages
      * were pinned, returns -errno.
 ++++ *
 ++++ * get_user_pages_fast provides equivalent functionality to get_user_pages,
 ++++ * operating on current and current->mm, with force=0 and vma=NULL. However
 ++++ * unlike get_user_pages, it must be called without mmap_sem held.
 ++++ *
 ++++ * get_user_pages_fast may take mmap_sem and page table locks, so no
 ++++ * assumptions can be made about lack of locking. get_user_pages_fast is to be
 ++++ * implemented in a way that is advantageous (vs get_user_pages()) when the
 ++++ * user memory area is already faulted in and present in ptes. However if the
 ++++ * pages have to be faulted in, it may turn out to be slightly slower so
 ++++ * callers need to carefully consider what to use. On many architectures,
 ++++ * get_user_pages_fast simply falls back to get_user_pages.
      */
     int __attribute__((weak)) get_user_pages_fast(unsigned long start,
                                int nr_pages, int write, struct page **pages)
     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);