Index: linux-2.6.19-mm1/mm/slub.c
===================================================================
--- linux-2.6.19-mm1.orig/mm/slub.c	2006-12-14 22:30:33.992470619 -0800
+++ linux-2.6.19-mm1/mm/slub.c	2006-12-14 23:13:28.359457710 -0800
@@ -428,12 +428,16 @@ static struct page *new_slab(struct kmem
 {
 	struct page *page;
 
-	if (flags & __GFP_NO_GROW)
+	if (flags & __GFP_NO_GROW) {
+		BUG();
 		return NULL;
+	}
 
 	page = allocate_slab(s, flags & GFP_LEVEL_MASK, node);
-	if (!page)
+	if (!page) {
+		BUG();
 		return NULL;
+	}
 
 	page->offset = s->offset;
 	atomic_long_inc(&s->nr_slabs);
@@ -589,6 +593,9 @@ static __always_inline void *allocate(st
 	void **object;
 	unsigned long flags;
 
+	printk(KERN_CRIT "allocate(%s,%x,%d)\n", s->name, gfpflags, node);
+	BUG_ON(!s->name);
+
 	local_irq_save(flags);
 	a = ACTIVE_SLAB(s, smp_processor_id());
 	if (unlikely(!a->page))
@@ -615,13 +622,14 @@ new_slab:
 		if (flags & __GFP_WAIT)
 			local_irq_enable();
 
-		page = new_slab(s, flags, node);
+		page = new_slab(s, gfpflags, node);
 
 		if (flags & __GFP_WAIT)
 			local_irq_disable();
 
 		if (!page) {
 			object = NULL;
+			BUG();
 			goto out;
 		}
 
@@ -631,6 +639,7 @@ new_slab:
 		 */
 		if (unlikely(s->objects == 1)) {
 			object = page_address(page);
+			BUG_ON(!object);
 			goto out;
 		}
 
@@ -675,6 +684,8 @@ get_object:
 	}
 #endif
 out:
+	BUG_ON(!s->name);
+	BUG_ON(!object);
 	local_irq_restore(flags);
 	return object;
 }
@@ -725,6 +736,7 @@ void kmem_cache_free(struct kmem_cache *
 	unsigned long flags;
 	struct active_slab *a;
 
+	BUG_ON(!s->name);
 	if (!object)
 		return;
 
@@ -760,6 +772,7 @@ void kmem_cache_free(struct kmem_cache *
 		object[s->offset] = a->freelist;
 		a->freelist = object;
 out:
+		BUG_ON(!s->name);
 		local_irq_restore(flags);
 		return;
 	}
@@ -961,6 +974,9 @@ int kmem_cache_open(struct kmem_cache *s
 {
 	int cpu;
 
+	printk("kmem_cache_open(%p, %s, %ld, %ld, %lx, %p, %p)\n",
+		s, name, (long)size, (long)align, flags, ctor, dtor);
+
 	BUG_ON(flags & SLUB_UNIMPLEMENTED);
 	memset(s, 0, sizeof(struct kmem_cache));
 	atomic_long_set(&s->nr_slabs, 0);
@@ -1347,7 +1363,7 @@ static struct kmem_cache *get_slab(size_
 		return s;
 
 	/* Dynamically create dma cache */
-	s = kmalloc(sizeof(struct kmem_cache), flags & ~(__GFP_DMA));
+	s = kmalloc(sizeof(struct kmem_cache), flags & ~__GFP_DMA);
 
 	if (!s)
 		panic("Unable to allocate memory for dma cache\n");
@@ -1405,7 +1421,6 @@ EXPORT_SYMBOL(kfree);
 void __init kmem_cache_init(void)
 {
 	int i;
-	char *bootname = "kmalloc";
 
 	/*
 	 * NUMA Bootstrap only works if the slab for the active_slab
@@ -1415,6 +1430,7 @@ void __init kmem_cache_init(void)
 
 	kmem_cache_open(ACTIVE_SLAB_SLAB, "active_slab", 1 << ACTIVE_SLAB_NR,
 		 ARCH_KMALLOC_MINALIGN, SLAB_PANIC, NULL, NULL);
+
 	slab_state = PARTIAL;
 
 	/* Power of two sized caches */
@@ -1422,7 +1438,7 @@ void __init kmem_cache_init(void)
 		if (i != ACTIVE_SLAB_NR)
 			kmem_cache_open(
 				&kmalloc_caches[i - KMALLOC_SHIFT_LOW],
-				bootname, 1 << i,
+				"kmalloc", 1 << i,
 		 		ARCH_KMALLOC_MINALIGN, SLAB_PANIC, NULL, NULL);
 
 #ifdef KMALLOC_EXTRA
@@ -1439,9 +1455,14 @@ void __init kmem_cache_init(void)
 	slab_state = UP;
 
 	/* We can provide the correct kmalloc names now that the caches are up */
-	for (i = 0; i < KMALLOC_SHIFT_HIGH - KMALLOC_SHIFT_LOW; i++)
-		kmalloc_caches[i].name = kasprintf(GFP_KERNEL, "kmalloc-%d",
+	for (i = 0; i <= KMALLOC_SHIFT_HIGH - KMALLOC_SHIFT_LOW; i++) {
+		char *name = kasprintf(GFP_KERNEL, "kmalloc-%d",
 			kmalloc_caches[i].size);
+
+		BUG_ON(!name);
+		kmalloc_caches[i].name = name;
+	};
+
 	printk(KERN_INFO "Kmalloc cache initialized: Caches=%d"
 		" Min_order=%d.\n",
 		KMALLOC_SHIFT_HIGH - KMALLOC_SHIFT_LOW + KMALLOC_EXTRAS,
Index: linux-2.6.19-mm1/include/linux/slub_def.h
===================================================================
--- linux-2.6.19-mm1.orig/include/linux/slub_def.h	2006-12-14 19:30:58.333764683 -0800
+++ linux-2.6.19-mm1/include/linux/slub_def.h	2006-12-14 22:30:38.115264254 -0800
@@ -135,9 +135,12 @@ static inline void *kmalloc(size_t size,
 	if (__builtin_constant_p(size) && !(flags & __GFP_DMA)) {
 		struct kmem_cache *s = kmalloc_slab(size);
 
+		printk(KERN_CRIT "kmalloc(%ld, %x) %p\n", size, flags, s);
 		return kmem_cache_alloc(s, flags);
-	} else
+	} else {
+		printk(KERN_CRIT "__kmalloc(%ld, %x)\n", size, flags);
 		return __kmalloc(size, flags);
+	}
 }
 
 static inline void *kzalloc(size_t size, gfp_t flags)