Index: linux-2.6.19-rc6-mm1/include/linux/slab.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/include/linux/slab.h	2006-11-27 17:44:47.000000000 -0800
+++ linux-2.6.19-rc6-mm1/include/linux/slab.h	2006-11-27 18:21:47.000000000 -0800
@@ -15,8 +15,6 @@
 #include	<linux/gfp.h>
 #include	<linux/init.h>
 #include	<linux/types.h>
-#include	<asm/page.h>		/* kmalloc_sizes.h needs PAGE_SIZE */
-#include	<asm/cache.h>		/* kmalloc_sizes.h needs L1_CACHE_BYTES */
 
 /* flags for kmem_cache_alloc() */
 #define	SLAB_NOFS		GFP_NOFS
@@ -53,11 +51,11 @@
 #define SLAB_CTOR_ATOMIC	0x002UL		/* tell constructor it can't sleep */
 #define	SLAB_CTOR_VERIFY	0x004UL		/* tell constructor it's a verify call */
 
-#ifndef CONFIG_SLOB
+#ifdef CONFIG_SLOB
+#include <linux/slob.h>
+#else
 
 /* prototypes */
-extern void __init kmem_cache_init(void);
-
 extern struct kmem_cache *kmem_cache_create(const char *,
 		size_t, size_t, unsigned long,
 		void (*)(void *, struct kmem_cache *, unsigned long),
@@ -69,258 +67,21 @@
 extern void kmem_cache_free(struct kmem_cache *, void *);
 extern unsigned int kmem_cache_size(struct kmem_cache *);
 extern const char *kmem_cache_name(struct kmem_cache *);
-
-/* Size description struct for general caches. */
-struct cache_sizes {
-	size_t		 cs_size;
-	struct kmem_cache *cs_cachep;
-#ifdef CONFIG_ZONE_DMA
-	struct kmem_cache *cs_dmacachep;
-#else
-#define cs_dmacachep cs_cachep
-#endif
-};
-extern struct cache_sizes malloc_sizes[];
-
-extern void *__kmalloc(size_t, gfp_t);
-
-/**
- * kmalloc - allocate memory
- * @size: how many bytes of memory are required.
- * @flags: the type of memory to allocate.
- *
- * kmalloc is the normal method of allocating memory
- * in the kernel.
- *
- * The @flags argument may be one of:
- *
- * %GFP_USER - Allocate memory on behalf of user.  May sleep.
- *
- * %GFP_KERNEL - Allocate normal kernel ram.  May sleep.
- *
- * %GFP_ATOMIC - Allocation will not sleep.
- *   For example, use this inside interrupt handlers.
- *
- * %GFP_HIGHUSER - Allocate pages from high memory.
- *
- * %GFP_NOIO - Do not do any I/O at all while trying to get memory.
- *
- * %GFP_NOFS - Do not make any fs calls while trying to get memory.
- *
- * Also it is possible to set different flags by OR'ing
- * in one or more of the following additional @flags:
- *
- * %__GFP_COLD - Request cache-cold pages instead of
- *   trying to return cache-warm pages.
- *
- * %__GFP_DMA - Request memory from the DMA-capable zone.
- *
- * %__GFP_HIGH - This allocation has high priority and may use emergency pools.
- *
- * %__GFP_HIGHMEM - Allocated memory may be from highmem.
- *
- * %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail
- *   (think twice before using).
- *
- * %__GFP_NORETRY - If memory is not immediately available,
- *   then give up at once.
- *
- * %__GFP_NOWARN - If allocation fails, don't issue any warnings.
- *
- * %__GFP_REPEAT - If allocation fails initially, try once more before failing.
- */
-static inline void *kmalloc(size_t size, gfp_t flags)
-{
-	if (__builtin_constant_p(size)) {
-		int i = 0;
-#define CACHE(x) \
-		if (size <= x) \
-			goto found; \
-		else \
-			i++;
-#include "kmalloc_sizes.h"
-#undef CACHE
-		{
-			extern void __you_cannot_kmalloc_that_much(void);
-			__you_cannot_kmalloc_that_much();
-		}
-found:
-		return kmem_cache_alloc((flags & GFP_DMA) ?
-			malloc_sizes[i].cs_dmacachep :
-			malloc_sizes[i].cs_cachep, flags);
-	}
-	return __kmalloc(size, flags);
-}
-
-/*
- * kmalloc_track_caller is a special version of kmalloc that records the
- * calling function of the routine calling it for slab leak tracking instead
- * of just the calling function (confusing, eh?).
- * It's useful when the call to kmalloc comes from a widely-used standard
- * allocator where we care about the real place the memory allocation
- * request comes from.
- */
-#ifndef CONFIG_DEBUG_SLAB
-#define kmalloc_track_caller(size, flags) \
-	__kmalloc(size, flags)
-#else
-extern void *__kmalloc_track_caller(size_t, gfp_t, void*);
-#define kmalloc_track_caller(size, flags) \
-	__kmalloc_track_caller(size, flags, __builtin_return_address(0))
-#endif
-
-extern void *__kzalloc(size_t, gfp_t);
-
-/**
- * kzalloc - allocate memory. The memory is set to zero.
- * @size: how many bytes of memory are required.
- * @flags: the type of memory to allocate (see kmalloc).
- */
-static inline void *kzalloc(size_t size, gfp_t flags)
-{
-	if (__builtin_constant_p(size)) {
-		int i = 0;
-#define CACHE(x) \
-		if (size <= x) \
-			goto found; \
-		else \
-			i++;
-#include "kmalloc_sizes.h"
-#undef CACHE
-		{
-			extern void __you_cannot_kzalloc_that_much(void);
-			__you_cannot_kzalloc_that_much();
-		}
-found:
-		return kmem_cache_zalloc((flags & GFP_DMA) ?
-			malloc_sizes[i].cs_dmacachep :
-			malloc_sizes[i].cs_cachep, flags);
-	}
-	return __kzalloc(size, flags);
-}
-
-/**
- * kcalloc - allocate memory for an array. The memory is set to zero.
- * @n: number of elements.
- * @size: element size.
- * @flags: the type of memory to allocate.
- */
-static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
-{
-	if (n != 0 && size > ULONG_MAX / n)
-		return NULL;
-	return kzalloc(n * size, flags);
-}
-
-extern void kfree(const void *);
-extern unsigned int ksize(const void *);
-extern int slab_is_available(void);
+extern int kmem_ptr_validate(struct kmem_cache *cachep, void *ptr);
 
 #ifdef CONFIG_NUMA
 extern void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
-extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
-
-static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
-{
-	if (__builtin_constant_p(size)) {
-		int i = 0;
-#define CACHE(x) \
-		if (size <= x) \
-			goto found; \
-		else \
-			i++;
-#include "kmalloc_sizes.h"
-#undef CACHE
-		{
-			extern void __you_cannot_kmalloc_that_much(void);
-			__you_cannot_kmalloc_that_much();
-		}
-found:
-		return kmem_cache_alloc_node((flags & GFP_DMA) ?
-			malloc_sizes[i].cs_dmacachep :
-			malloc_sizes[i].cs_cachep, flags, node);
-	}
-	return __kmalloc_node(size, flags, node);
-}
-
-/*
- * kmalloc_node_track_caller is a special version of kmalloc_node that
- * records the calling function of the routine calling it for slab leak
- * tracking instead of just the calling function (confusing, eh?).
- * It's useful when the call to kmalloc_node comes from a widely-used
- * standard allocator where we care about the real place the memory
- * allocation request comes from.
- */
-#ifndef CONFIG_DEBUG_SLAB
-#define kmalloc_node_track_caller(size, flags, node) \
-	__kmalloc_node(size, flags, node)
-#else
-extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, void *);
-#define kmalloc_node_track_caller(size, flags, node) \
-	__kmalloc_node_track_caller(size, flags, node, \
-			__builtin_return_address(0))
-#endif
 #else /* CONFIG_NUMA */
 static inline void *kmem_cache_alloc_node(struct kmem_cache *cachep,
 					gfp_t flags, int node)
 {
 	return kmem_cache_alloc(cachep, flags);
 }
-static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
-{
-	return kmalloc(size, flags);
-}
-
-#define kmalloc_node_track_caller(size, flags, node) \
-	kmalloc_track_caller(size, flags)
 #endif
 
-extern int FASTCALL(kmem_cache_reap(int));
-extern int FASTCALL(kmem_ptr_validate(struct kmem_cache *cachep, void *ptr));
-
-struct shrinker;
-extern void kmem_set_shrinker(kmem_cache_t *cachep, struct shrinker *shrinker);
-
-#else /* CONFIG_SLOB */
-
-/* SLOB allocator routines */
-
-void kmem_cache_init(void);
-struct kmem_cache *kmem_cache_create(const char *c, size_t, size_t,
-	unsigned long,
-	void (*)(void *, struct kmem_cache *, unsigned long),
-	void (*)(void *, struct kmem_cache *, unsigned long));
-void kmem_cache_destroy(struct kmem_cache *c);
-void *kmem_cache_alloc(struct kmem_cache *c, gfp_t flags);
-void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
-void kmem_cache_free(struct kmem_cache *c, void *b);
-const char *kmem_cache_name(struct kmem_cache *);
-void *kmalloc(size_t size, gfp_t flags);
-void *__kzalloc(size_t size, gfp_t flags);
-void kfree(const void *m);
-unsigned int ksize(const void *m);
-unsigned int kmem_cache_size(struct kmem_cache *c);
-
-static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
-{
-	return __kzalloc(n * size, flags);
-}
-
-#define kmem_cache_shrink(d) (0)
-#define kmem_cache_reap(a)
-#define kmem_ptr_validate(a, b) (0)
-#define kmem_cache_alloc_node(c, f, n) kmem_cache_alloc(c, f)
-#define kmalloc_node(s, f, n) kmalloc(s, f)
-#define kzalloc(s, f) __kzalloc(s, f)
-#define kmalloc_track_caller kmalloc
-
-#define kmalloc_node_track_caller kmalloc_node
-
-struct shrinker;
-static inline void kmem_set_shrinker(kmem_cache_t *cachep,
-				     struct shrinker *shrinker) {}
+#include <linux/kmalloc.h>
 
-#endif /* CONFIG_SLOB */
+#endif /* !CONFIG_SLOB */
 
 #endif	/* __KERNEL__ */
 
Index: linux-2.6.19-rc6-mm1/include/linux/kmalloc.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ linux-2.6.19-rc6-mm1/include/linux/kmalloc.h	2006-11-27 21:56:15.000000000 -0800
@@ -0,0 +1,221 @@
+#ifndef _LINUX_KMALLOC_H
+#define	_LINUX_KMALLOC_H
+
+#include <linux/gfp.h>
+#include <asm/page.h>		/* kmalloc_sizes.h needs PAGE_SIZE */
+#include <asm/cache.h>		/* kmalloc_sizes.h needs L1_CACHE_BYTES */
+
+#ifdef __KERNEL__
+
+/* Size description struct for general caches. */
+struct cache_sizes {
+	size_t		 cs_size;
+	struct kmem_cache *cs_cachep;
+#ifdef CONFIG_ZONE_DMA
+	struct kmem_cache *cs_dmacachep;
+#else
+#define cs_dmacachep cs_cachep
+#endif
+};
+extern struct cache_sizes malloc_sizes[];
+
+extern void *__kmalloc(size_t, gfp_t);
+
+/**
+ * kmalloc - allocate memory
+ * @size: how many bytes of memory are required.
+ * @flags: the type of memory to allocate.
+ *
+ * kmalloc is the normal method of allocating memory
+ * in the kernel.
+ *
+ * The @flags argument may be one of:
+ *
+ * %GFP_USER - Allocate memory on behalf of user.  May sleep.
+ *
+ * %GFP_KERNEL - Allocate normal kernel ram.  May sleep.
+ *
+ * %GFP_ATOMIC - Allocation will not sleep.
+ *   For example, use this inside interrupt handlers.
+ *
+ * %GFP_HIGHUSER - Allocate pages from high memory.
+ *
+ * %GFP_NOIO - Do not do any I/O at all while trying to get memory.
+ *
+ * %GFP_NOFS - Do not make any fs calls while trying to get memory.
+ *
+ * Also it is possible to set different flags by OR'ing
+ * in one or more of the following additional @flags:
+ *
+ * %__GFP_COLD - Request cache-cold pages instead of
+ *   trying to return cache-warm pages.
+ *
+ * %__GFP_DMA - Request memory from the DMA-capable zone.
+ *
+ * %__GFP_HIGH - This allocation has high priority and may use emergency pools.
+ *
+ * %__GFP_HIGHMEM - Allocated memory may be from highmem.
+ *
+ * %__GFP_NOFAIL - Indicate that this allocation is in no way allowed to fail
+ *   (think twice before using).
+ *
+ * %__GFP_NORETRY - If memory is not immediately available,
+ *   then give up at once.
+ *
+ * %__GFP_NOWARN - If allocation fails, don't issue any warnings.
+ *
+ * %__GFP_REPEAT - If allocation fails initially, try once more before failing.
+ */
+static inline void *kmalloc(size_t size, gfp_t flags)
+{
+	extern void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
+
+	if (__builtin_constant_p(size)) {
+		int i = 0;
+#define CACHE(x) \
+		if (size <= x) \
+			goto found; \
+		else \
+			i++;
+#include "kmalloc_sizes.h"
+#undef CACHE
+		{
+			extern void __you_cannot_kmalloc_that_much(void);
+			__you_cannot_kmalloc_that_much();
+		}
+found:
+		return kmem_cache_alloc((flags & GFP_DMA) ?
+			malloc_sizes[i].cs_dmacachep :
+			malloc_sizes[i].cs_cachep, flags);
+	}
+	return __kmalloc(size, flags);
+}
+
+/*
+ * kmalloc_track_caller is a special version of kmalloc that records the
+ * calling function of the routine calling it for slab leak tracking instead
+ * of just the calling function (confusing, eh?).
+ * It's useful when the call to kmalloc comes from a widely-used standard
+ * allocator where we care about the real place the memory allocation
+ * request comes from.
+ */
+#ifndef CONFIG_DEBUG_SLAB
+#define kmalloc_track_caller(size, flags) \
+	__kmalloc(size, flags)
+#else
+extern void *__kmalloc_track_caller(size_t, gfp_t, void*);
+#define kmalloc_track_caller(size, flags) \
+	__kmalloc_track_caller(size, flags, __builtin_return_address(0))
+#endif
+
+extern void *__kzalloc(size_t, gfp_t);
+
+/**
+ * kzalloc - allocate memory. The memory is set to zero.
+ * @size: how many bytes of memory are required.
+ * @flags: the type of memory to allocate (see kmalloc).
+ */
+static inline void *kzalloc(size_t size, gfp_t flags)
+{
+	extern void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
+
+	if (__builtin_constant_p(size)) {
+		int i = 0;
+#define CACHE(x) \
+		if (size <= x) \
+			goto found; \
+		else \
+			i++;
+#include "kmalloc_sizes.h"
+#undef CACHE
+		{
+			extern void __you_cannot_kzalloc_that_much(void);
+			__you_cannot_kzalloc_that_much();
+		}
+found:
+		return kmem_cache_zalloc((flags & GFP_DMA) ?
+			malloc_sizes[i].cs_dmacachep :
+			malloc_sizes[i].cs_cachep, flags);
+	}
+	return __kzalloc(size, flags);
+}
+
+/**
+ * kcalloc - allocate memory for an array. The memory is set to zero.
+ * @n: number of elements.
+ * @size: element size.
+ * @flags: the type of memory to allocate.
+ */
+static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
+{
+	if (n != 0 && size > ULONG_MAX / n)
+		return NULL;
+	return kzalloc(n * size, flags);
+}
+
+extern void kfree(const void *);
+extern unsigned int ksize(const void *);
+
+#ifdef CONFIG_NUMA
+extern void *__kmalloc_node(size_t size, gfp_t flags, int node);
+
+static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+{
+	extern void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags,
+								int node);
+
+	if (__builtin_constant_p(size)) {
+		int i = 0;
+#define CACHE(x) \
+		if (size <= x) \
+			goto found; \
+		else \
+			i++;
+#include "kmalloc_sizes.h"
+#undef CACHE
+		{
+			extern void __you_cannot_kmalloc_that_much(void);
+			__you_cannot_kmalloc_that_much();
+		}
+found:
+		return kmem_cache_alloc_node((flags & GFP_DMA) ?
+			malloc_sizes[i].cs_dmacachep :
+			malloc_sizes[i].cs_cachep, flags, node);
+	}
+	return __kmalloc_node(size, flags, node);
+}
+
+/*
+ * kmalloc_node_track_caller is a special version of kmalloc_node that
+ * records the calling function of the routine calling it for slab leak
+ * tracking instead of just the calling function (confusing, eh?).
+ * It's useful when the call to kmalloc_node comes from a widely-used
+ * standard allocator where we care about the real place the memory
+ * allocation request comes from.
+ */
+#ifndef CONFIG_DEBUG_SLAB
+#define kmalloc_node_track_caller(size, flags, node) \
+	__kmalloc_node(size, flags, node)
+#else
+extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, void *);
+#define kmalloc_node_track_caller(size, flags, node) \
+	__kmalloc_node_track_caller(size, flags, node, \
+				__builtin_return_address(0))
+#endif
+#else
+static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
+{
+	return kmalloc(size, flags);
+}
+
+#define kmalloc_node_track_caller(size, flags, node) \
+	kmalloc_track_caller(size, flags)
+#endif
+
+extern void __init kmem_cache_init(void);
+extern int slab_is_available(void);
+extern int kmem_cache_reap(int);
+
+#endif	/* __KERNEL__ */
+
+#endif	/* _LINUX_KMALLOC_H */
Index: linux-2.6.19-rc6-mm1/include/linux/slob.h
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ linux-2.6.19-rc6-mm1/include/linux/slob.h	2006-11-27 17:58:44.000000000 -0800
@@ -0,0 +1,41 @@
+#ifndef _LINUX_SLOB_H
+#define	_LINUX_SLOB_H
+
+#if	defined(__KERNEL__)
+
+#include <linux/slab.h>
+
+/* SLOB allocator routines */
+
+void kmem_cache_init(void);
+struct kmem_cache *kmem_cache_create(const char *c, size_t, size_t,
+	unsigned long,
+	void (*)(void *, struct kmem_cache *, unsigned long),
+	void (*)(void *, struct kmem_cache *, unsigned long));
+void kmem_cache_destroy(struct kmem_cache *c);
+void *kmem_cache_alloc(struct kmem_cache *c, gfp_t flags);
+void *kmem_cache_zalloc(struct kmem_cache *, gfp_t);
+void kmem_cache_free(struct kmem_cache *c, void *b);
+const char *kmem_cache_name(struct kmem_cache *);
+void *kmalloc(size_t size, gfp_t flags);
+void *__kzalloc(size_t size, gfp_t flags);
+void kfree(const void *m);
+unsigned int ksize(const void *m);
+unsigned int kmem_cache_size(struct kmem_cache *c);
+
+static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
+{
+	return __kzalloc(n * size, flags);
+}
+
+#define kmem_cache_shrink(d) (0)
+#define kmem_cache_reap(a)
+#define kmem_ptr_validate(a, b) (0)
+#define kmem_cache_alloc_node(c, f, n) kmem_cache_alloc(c, f)
+#define kmalloc_node(s, f, n) kmalloc(s, f)
+#define kzalloc(s, f) __kzalloc(s, f)
+#define kmalloc_track_caller kmalloc
+
+#endif	/* __KERNEL__ */
+
+#endif	/* _LINUX_SLOB_H */
Index: linux-2.6.19-rc6-mm1/include/linux/coda_linux.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/include/linux/coda_linux.h	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/include/linux/coda_linux.h	2006-11-27 17:58:44.000000000 -0800
@@ -16,7 +16,7 @@
 #include <linux/param.h>
 #include <linux/mm.h>
 #include <linux/vmalloc.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/wait.h>		
 #include <linux/types.h>
 #include <linux/fs.h>
Index: linux-2.6.19-rc6-mm1/include/linux/mempolicy.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/include/linux/mempolicy.h	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/include/linux/mempolicy.h	2006-11-27 17:58:44.000000000 -0800
@@ -29,7 +29,6 @@
 #ifdef __KERNEL__
 
 #include <linux/mmzone.h>
-#include <linux/slab.h>
 #include <linux/rbtree.h>
 #include <linux/spinlock.h>
 #include <linux/nodemask.h>
Index: linux-2.6.19-rc6-mm1/include/linux/percpu.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/include/linux/percpu.h	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/include/linux/percpu.h	2006-11-27 17:58:44.000000000 -0800
@@ -2,7 +2,7 @@
 #define __LINUX_PERCPU_H
 
 #include <linux/spinlock.h> /* For preempt_disable() */
-#include <linux/slab.h> /* For kmalloc() */
+#include <linux/kmalloc.h>
 #include <linux/smp.h>
 #include <linux/string.h> /* For memset() */
 #include <linux/cpumask.h>
Index: linux-2.6.19-rc6-mm1/include/linux/skbuff.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/include/linux/skbuff.h	2006-11-27 13:02:04.000000000 -0800
+++ linux-2.6.19-rc6-mm1/include/linux/skbuff.h	2006-11-27 17:58:44.000000000 -0800
@@ -327,7 +327,7 @@
 /*
  *	Handling routines are only of interest to the kernel
  */
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 
 #include <asm/system.h>
 
Index: linux-2.6.19-rc6-mm1/mm/nommu.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/nommu.c	2006-11-27 13:02:06.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/nommu.c	2006-11-27 17:58:44.000000000 -0800
@@ -18,7 +18,7 @@
 #include <linux/file.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/vmalloc.h>
 #include <linux/ptrace.h>
 #include <linux/blkdev.h>
Index: linux-2.6.19-rc6-mm1/mm/page-writeback.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/page-writeback.c	2006-11-27 13:02:06.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/page-writeback.c	2006-11-27 21:47:59.000000000 -0800
@@ -16,7 +16,7 @@
 #include <linux/fs.h>
 #include <linux/mm.h>
 #include <linux/swap.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/pagemap.h>
 #include <linux/writeback.h>
 #include <linux/init.h>
Index: linux-2.6.19-rc6-mm1/mm/page_alloc.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/page_alloc.c	2006-11-27 13:02:06.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/page_alloc.c	2006-11-27 17:58:44.000000000 -0800
@@ -26,7 +26,7 @@
 #include <linux/suspend.h>
 #include <linux/pagevec.h>
 #include <linux/blkdev.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/notifier.h>
 #include <linux/topology.h>
 #include <linux/sysctl.h>
Index: linux-2.6.19-rc6-mm1/mm/swapfile.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/swapfile.c	2006-11-27 13:02:06.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/swapfile.c	2006-11-27 17:58:44.000000000 -0800
@@ -8,7 +8,7 @@
 #include <linux/mm.h>
 #include <linux/hugetlb.h>
 #include <linux/mman.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/kernel_stat.h>
 #include <linux/swap.h>
 #include <linux/vmalloc.h>
Index: linux-2.6.19-rc6-mm1/mm/util.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/util.c	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/util.c	2006-11-27 17:58:44.000000000 -0800
@@ -1,4 +1,4 @@
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/string.h>
 #include <linux/module.h>
 #include <linux/err.h>
Index: linux-2.6.19-rc6-mm1/mm/vmalloc.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/vmalloc.c	2006-11-27 13:02:06.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/vmalloc.c	2006-11-27 17:58:44.000000000 -0800
@@ -11,7 +11,7 @@
 #include <linux/mm.h>
 #include <linux/module.h>
 #include <linux/highmem.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/spinlock.h>
 #include <linux/interrupt.h>
 
Index: linux-2.6.19-rc6-mm1/mm/vmscan.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/mm/vmscan.c	2006-11-27 13:02:06.000000000 -0800
+++ linux-2.6.19-rc6-mm1/mm/vmscan.c	2006-11-27 17:58:44.000000000 -0800
@@ -13,7 +13,7 @@
 
 #include <linux/mm.h>
 #include <linux/module.h>
-#include <linux/slab.h>
+#include <linux/kmalloc.h>
 #include <linux/kernel_stat.h>
 #include <linux/swap.h>
 #include <linux/swap-prefetch.h>
Index: linux-2.6.19-rc6-mm1/block/cfq-iosched.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/block/cfq-iosched.c	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/block/cfq-iosched.c	2006-11-27 17:58:44.000000000 -0800
@@ -12,6 +12,7 @@
 #include <linux/hash.h>
 #include <linux/rbtree.h>
 #include <linux/ioprio.h>
+#include <linux/slab.h>
 
 /*
  * tunables
Index: linux-2.6.19-rc6-mm1/fs/fat/cache.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/fs/fat/cache.c	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/fs/fat/cache.c	2006-11-27 17:58:44.000000000 -0800
@@ -11,6 +11,7 @@
 #include <linux/fs.h>
 #include <linux/msdos_fs.h>
 #include <linux/buffer_head.h>
+#include <linux/slab.h>
 
 /* this must be > 0. */
 #define FAT_MAX_CACHE	8
Index: linux-2.6.19-rc6-mm1/fs/sysfs/inode.c
===================================================================
--- linux-2.6.19-rc6-mm1.orig/fs/sysfs/inode.c	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/fs/sysfs/inode.c	2006-11-27 17:58:44.000000000 -0800
@@ -13,6 +13,8 @@
 #include <linux/backing-dev.h>
 #include <linux/capability.h>
 #include <linux/errno.h>
+#include <linux/slab.h>
+
 #include "sysfs.h"
 
 extern struct super_block * sysfs_sb;
Index: linux-2.6.19-rc6-mm1/fs/sysfs/sysfs.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/fs/sysfs/sysfs.h	2006-11-15 20:03:40.000000000 -0800
+++ linux-2.6.19-rc6-mm1/fs/sysfs/sysfs.h	2006-11-27 17:58:44.000000000 -0800
@@ -1,3 +1,4 @@
+#include <linux/slab.h>
 
 extern struct vfsmount * sysfs_mount;
 extern kmem_cache_t *sysfs_dir_cachep;
Index: linux-2.6.19-rc6-mm1/include/linux/jbd.h
===================================================================
--- linux-2.6.19-rc6-mm1.orig/include/linux/jbd.h	2006-11-27 13:02:04.000000000 -0800
+++ linux-2.6.19-rc6-mm1/include/linux/jbd.h	2006-11-27 17:58:44.000000000 -0800
@@ -30,6 +30,7 @@
 #include <linux/bit_spinlock.h>
 #include <linux/mutex.h>
 #include <linux/timer.h>
+#include <linux/slab.h>
 
 #include <asm/semaphore.h>
 #endif