32 files changed, 371 insertions, 322 deletions
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 7ad634501e48..e1c8d080c427 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -88,32 +88,32 @@
 * lib/bitmap.c provides these functions:
 */
-extern int __bitmap_empty(const unsigned long *bitmap, int bits);
+extern int __bitmap_empty(const unsigned long *bitmap, unsigned int nbits);
-extern int __bitmap_full(const unsigned long *bitmap, int bits);
+extern int __bitmap_full(const unsigned long *bitmap, unsigned int nbits);
 extern int __bitmap_equal(const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                          const unsigned long *bitmap2, unsigned int nbits);
 extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
-                        int bits);
+                        unsigned int nbits);
 extern void __bitmap_shift_right(unsigned long *dst,
                        const unsigned long *src, int shift, int bits);
 extern void __bitmap_shift_left(unsigned long *dst,
                        const unsigned long *src, int shift, int bits);
 extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                        const unsigned long *bitmap2, unsigned int nbits);
 extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                        const unsigned long *bitmap2, unsigned int nbits);
 extern void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                        const unsigned long *bitmap2, unsigned int nbits);
 extern int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                        const unsigned long *bitmap2, unsigned int nbits);
 extern int __bitmap_intersects(const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                        const unsigned long *bitmap2, unsigned int nbits);
 extern int __bitmap_subset(const unsigned long *bitmap1,
-                        const unsigned long *bitmap2, int bits);
+                        const unsigned long *bitmap2, unsigned int nbits);
-extern int __bitmap_weight(const unsigned long *bitmap, int bits);
+extern int __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);
-extern void bitmap_set(unsigned long *map, int i, int len);
+extern void bitmap_set(unsigned long *map, unsigned int start, int len);
-extern void bitmap_clear(unsigned long *map, int start, int nr);
+extern void bitmap_clear(unsigned long *map, unsigned int start, int len);
 extern unsigned long bitmap_find_next_zero_area(unsigned long *map,
                                         unsigned long size,
                                         unsigned long start,
@@ -140,9 +140,9 @@ extern void bitmap_onto(unsigned long *dst, const unsigned long *orig,
                const unsigned long *relmap, int bits);
 extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
                int sz, int bits);
-extern int bitmap_find_free_region(unsigned long *bitmap, int bits, int order);
+extern int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
-extern void bitmap_release_region(unsigned long *bitmap, int pos, int order);
+extern void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
-extern int bitmap_allocate_region(unsigned long *bitmap, int pos, int order);
+extern int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
 extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
 extern int bitmap_ord_to_pos(const unsigned long *bitmap, int n, int bits);
@@ -188,15 +188,15 @@ static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
 }
 static inline int bitmap_and(unsigned long *dst, const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
-                return (*dst = *src1 & *src2) != 0;
+                return (*dst = *src1 & *src2 & BITMAP_LAST_WORD_MASK(nbits)) != 0;
        return __bitmap_and(dst, src1, src2, nbits);
 }
 static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                *dst = *src1 | *src2;
@@ -205,7 +205,7 @@ static inline void bitmap_or(unsigned long *dst, const unsigned long *src1,
 }
 static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                *dst = *src1 ^ *src2;
@@ -214,24 +214,24 @@ static inline void bitmap_xor(unsigned long *dst, const unsigned long *src1,
 }
 static inline int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
-                return (*dst = *src1 & ~(*src2)) != 0;
+                return (*dst = *src1 & ~(*src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
        return __bitmap_andnot(dst, src1, src2, nbits);
 }
 static inline void bitmap_complement(unsigned long *dst, const unsigned long *src,
-                        int nbits)
+                        unsigned int nbits)
 {
        if (small_const_nbits(nbits))
-                *dst = ~(*src) & BITMAP_LAST_WORD_MASK(nbits);
+                *dst = ~(*src);
        else
                __bitmap_complement(dst, src, nbits);
 }
 static inline int bitmap_equal(const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                return ! ((*src1 ^ *src2) & BITMAP_LAST_WORD_MASK(nbits));
@@ -240,7 +240,7 @@ static inline int bitmap_equal(const unsigned long *src1,
 }
 static inline int bitmap_intersects(const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                return ((*src1 & *src2) & BITMAP_LAST_WORD_MASK(nbits)) != 0;
@@ -249,7 +249,7 @@ static inline int bitmap_intersects(const unsigned long *src1,
 }
 static inline int bitmap_subset(const unsigned long *src1,
-                        const unsigned long *src2, int nbits)
+                        const unsigned long *src2, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                return ! ((*src1 & ~(*src2)) & BITMAP_LAST_WORD_MASK(nbits));
@@ -257,7 +257,7 @@ static inline int bitmap_subset(const unsigned long *src1,
                return __bitmap_subset(src1, src2, nbits);
 }
-static inline int bitmap_empty(const unsigned long *src, int nbits)
+static inline int bitmap_empty(const unsigned long *src, unsigned nbits)
 {
        if (small_const_nbits(nbits))
                return ! (*src & BITMAP_LAST_WORD_MASK(nbits));
@@ -265,7 +265,7 @@ static inline int bitmap_empty(const unsigned long *src, int nbits)
                return __bitmap_empty(src, nbits);
 }
-static inline int bitmap_full(const unsigned long *src, int nbits)
+static inline int bitmap_full(const unsigned long *src, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                return ! (~(*src) & BITMAP_LAST_WORD_MASK(nbits));
@@ -273,7 +273,7 @@ static inline int bitmap_full(const unsigned long *src, int nbits)
                return __bitmap_full(src, nbits);
 }
-static inline int bitmap_weight(const unsigned long *src, int nbits)
+static inline int bitmap_weight(const unsigned long *src, unsigned int nbits)
 {
        if (small_const_nbits(nbits))
                return hweight_long(*src & BITMAP_LAST_WORD_MASK(nbits));
@@ -284,7 +284,7 @@ static inline void bitmap_shift_right(unsigned long *dst,
                        const unsigned long *src, int n, int nbits)
 {
        if (small_const_nbits(nbits))
-                *dst = *src >> n;
+                *dst = (*src & BITMAP_LAST_WORD_MASK(nbits)) >> n;
        else
                __bitmap_shift_right(dst, src, n, nbits);
 }
diff --git a/include/linux/byteorder/generic.h b/include/linux/byteorder/generic.h
index 0846e6b931ce..89f67c1c3160 100644
--- a/include/linux/byteorder/generic.h
+++ b/include/linux/byteorder/generic.h
@@ -2,7 +2,7 @@
 #define _LINUX_BYTEORDER_GENERIC_H
 /*
- * linux/byteorder_generic.h
+ * linux/byteorder/generic.h
 * Generic Byte-reordering support
 *
 * The "... p" macros, like le64_to_cpup, can be used with pointers
diff --git a/include/linux/cma.h b/include/linux/cma.h
new file mode 100644
index 000000000000..371b93042520
--- /dev/null
+++ b/include/linux/cma.h
@@ -0,0 +1,27 @@
+#ifndef __CMA_H__
+#define __CMA_H__
+/*
+ * There is always at least global CMA area and a few optional
+ * areas configured in kernel .config.
+ */
+#ifdef CONFIG_CMA_AREAS
+#define MAX_CMA_AREAS   (1 + CONFIG_CMA_AREAS)
+#else
+#define MAX_CMA_AREAS   (0)
+#endif
+struct cma;
+extern phys_addr_t cma_get_base(struct cma *cma);
+extern unsigned long cma_get_size(struct cma *cma);
+extern int __init cma_declare_contiguous(phys_addr_t size,
+                        phys_addr_t base, phys_addr_t limit,
+                        phys_addr_t alignment, unsigned int order_per_bit,
+                        bool fixed, struct cma **res_cma);
+extern struct page *cma_alloc(struct cma *cma, int count, unsigned int align);
+extern bool cma_release(struct cma *cma, struct page *pages, int count);
+#endif
diff --git a/include/linux/dma-contiguous.h b/include/linux/dma-contiguous.h
index 772eab5d524a..569bbd039896 100644
--- a/include/linux/dma-contiguous.h
+++ b/include/linux/dma-contiguous.h
@@ -53,18 +53,13 @@
 #ifdef __KERNEL__
+#include <linux/device.h>
 struct cma;
 struct page;
-struct device;
 #ifdef CONFIG_DMA_CMA
-/*
- * There is always at least global CMA area and a few optional device
- * private areas configured in kernel .config.
- */
-#define MAX_CMA_AREAS   (1 + CONFIG_CMA_AREAS)
 extern struct cma *dma_contiguous_default_area;
 static inline struct cma *dev_get_cma_area(struct device *dev)
@@ -123,8 +118,6 @@ bool dma_release_from_contiguous(struct device *dev, struct page *pages,
 #else
-#define MAX_CMA_AREAS   (0)
 static inline struct cma *dev_get_cma_area(struct device *dev)
 {
        return NULL;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 2daccaf4b547..1ab6c6913040 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2688,7 +2688,7 @@ static const struct file_operations __fops = {				\
        .read    = simple_attr_read,                                    \
        .write   = simple_attr_write,                                   \
        .llseek  = generic_file_llseek,                                 \
-};
+}
 static inline __printf(1, 2)
 void __simple_attr_check_format(const char *fmt, ...)
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index fc7718c6bd3e..ca060d7c4fa6 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -322,16 +322,18 @@ extern int fsnotify_fasync(int fd, struct file *file, int on);
 extern void fsnotify_destroy_event(struct fsnotify_group *group,
                                   struct fsnotify_event *event);
 /* attach the event to the group notification queue */
-extern int fsnotify_add_notify_event(struct fsnotify_group *group,
+extern int fsnotify_add_event(struct fsnotify_group *group,
-                                     struct fsnotify_event *event,
+                              struct fsnotify_event *event,
-                                     int (*merge)(struct list_head *,
+                              int (*merge)(struct list_head *,
-                                                  struct fsnotify_event *));
+                                           struct fsnotify_event *));
+/* Remove passed event from groups notification queue */
+extern void fsnotify_remove_event(struct fsnotify_group *group, struct fsnotify_event *event);
 /* true if the group notification queue is empty */
 extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
 /* return, but do not dequeue the first event on the notification queue */
-extern struct fsnotify_event *fsnotify_peek_notify_event(struct fsnotify_group *group);
+extern struct fsnotify_event *fsnotify_peek_first_event(struct fsnotify_group *group);
 /* return AND dequeue the first event on the notification queue */
-extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group *group);
+extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group *group);
 /* functions used to manipulate the marks attached to inodes */
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 6eb1fb37de9a..5e7219dc0fae 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -360,7 +360,7 @@ extern unsigned long get_zeroed_page(gfp_t gfp_mask);
 void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
 void free_pages_exact(void *virt, size_t size);
 /* This is different from alloc_pages_exact_node !!! */
-void *alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask);
+void * __meminit alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask);
 #define __get_free_page(gfp_mask) \
                __get_free_pages((gfp_mask), 0)
diff --git a/include/linux/glob.h b/include/linux/glob.h
new file mode 100644
index 000000000000..861d8347d08e
--- /dev/null
+++ b/include/linux/glob.h
@@ -0,0 +1,9 @@
+#ifndef _LINUX_GLOB_H
+#define _LINUX_GLOB_H
+#include <linux/types.h>        /* For bool */
+#include <linux/compiler.h>     /* For __pure */
+bool __pure glob_match(char const *pat, char const *str);
+#endif  /* _LINUX_GLOB_H */
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index 7fb31da45d03..9286a46b7d69 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -93,7 +93,7 @@ static inline int kmap_atomic_idx_push(void)
 #ifdef CONFIG_DEBUG_HIGHMEM
        WARN_ON_ONCE(in_irq() && !irqs_disabled());
-        BUG_ON(idx > KM_TYPE_NR);
+        BUG_ON(idx >= KM_TYPE_NR);
 #endif
        return idx;
 }
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index b826239bdce0..63579cb8d3dc 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -93,10 +93,6 @@ extern bool is_vma_temporary_stack(struct vm_area_struct *vma);
 #endif /* CONFIG_DEBUG_VM */
 extern unsigned long transparent_hugepage_flags;
-extern int copy_pte_range(struct mm_struct *dst_mm, struct mm_struct *src_mm,
-                          pmd_t *dst_pmd, pmd_t *src_pmd,
-                          struct vm_area_struct *vma,
-                          unsigned long addr, unsigned long end);
 extern int split_huge_page_to_list(struct page *page, struct list_head *list);
 static inline int split_huge_page(struct page *page)
 {
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index a23c096b3080..6e6d338641fe 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -87,7 +87,6 @@ pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud);
 #endif
 extern unsigned long hugepages_treat_as_movable;
-extern const unsigned long hugetlb_zero, hugetlb_infinity;
 extern int sysctl_hugetlb_shm_group;
 extern struct list_head huge_boot_pages;
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index a9e2268ecccb..3dc22abbc68a 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -493,11 +493,6 @@ static inline char *hex_byte_pack_upper(char *buf, u8 byte)
        return buf;
 }
-static inline char * __deprecated pack_hex_byte(char *buf, u8 byte)
-{
-        return hex_byte_pack(buf, byte);
-}
 extern int hex_to_bin(char ch);
 extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
diff --git a/include/linux/klist.h b/include/linux/klist.h
index a370ce57cf1d..61e5b723ae73 100644
--- a/include/linux/klist.h
+++ b/include/linux/klist.h
@@ -44,7 +44,7 @@ struct klist_node {
 extern void klist_add_tail(struct klist_node *n, struct klist *k);
 extern void klist_add_head(struct klist_node *n, struct klist *k);
-extern void klist_add_after(struct klist_node *n, struct klist_node *pos);
+extern void klist_add_behind(struct klist_node *n, struct klist_node *pos);
 extern void klist_add_before(struct klist_node *n, struct klist_node *pos);
 extern void klist_del(struct klist_node *n);
diff --git a/include/linux/list.h b/include/linux/list.h
index ef9594171062..cbbb96fcead9 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -654,15 +654,15 @@ static inline void hlist_add_before(struct hlist_node *n,
        *(n->pprev) = n;
 }
-static inline void hlist_add_after(struct hlist_node *n,
+static inline void hlist_add_behind(struct hlist_node *n,
-                                        struct hlist_node *next)
+                                    struct hlist_node *prev)
 {
-        next->next = n->next;
+        n->next = prev->next;
-        n->next = next;
+        prev->next = n;
-        next->pprev = &n->next;
+        n->pprev = &prev->next;
-        if(next->next)
+        if (n->next)
-                next->next->pprev  = &next->next;
+                n->next->pprev  = &n->next;
 }
 /* after that we'll appear to be on some hlist and hlist_del will work */
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index b660e05b63d4..e8cc45307f8f 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -249,7 +249,7 @@ phys_addr_t memblock_alloc(phys_addr_t size, phys_addr_t align);
 /*
 * Set the allocation direction to bottom-up or top-down.
 */
-static inline void memblock_set_bottom_up(bool enable)
+static inline void __init memblock_set_bottom_up(bool enable)
 {
        memblock.bottom_up = enable;
 }
@@ -264,7 +264,7 @@ static inline bool memblock_bottom_up(void)
        return memblock.bottom_up;
 }
 #else
-static inline void memblock_set_bottom_up(bool enable) {}
+static inline void __init memblock_set_bottom_up(bool enable) {}
 static inline bool memblock_bottom_up(void) { return false; }
 #endif
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 010d125bffbf..d9524c49d767 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -26,11 +26,12 @@ enum {
        MEMORY_HOTPLUG_MAX_BOOTMEM_TYPE = NODE_INFO,
 };
-/* Types for control the zone type of onlined memory */
+/* Types for control the zone type of onlined and offlined memory */
 enum {
-        ONLINE_KEEP,
+        MMOP_OFFLINE = -1,
-        ONLINE_KERNEL,
+        MMOP_ONLINE_KEEP,
-        ONLINE_MOVABLE,
+        MMOP_ONLINE_KERNEL,
+        MMOP_ONLINE_MOVABLE,
 };
 /*
@@ -258,6 +259,7 @@ static inline void remove_memory(int nid, u64 start, u64 size) {}
 extern int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn,
                void *arg, int (*func)(struct memory_block *, void *));
 extern int add_memory(int nid, u64 start, u64 size);
+extern int zone_for_memory(int nid, u64 start, u64 size, int zone_default);
 extern int arch_add_memory(int nid, u64 start, u64 size);
 extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
 extern bool is_memblock_offlined(struct memory_block *mem);
diff --git a/include/linux/mmdebug.h b/include/linux/mmdebug.h
index edd82a105220..2f348d02f640 100644
--- a/include/linux/mmdebug.h
+++ b/include/linux/mmdebug.h
@@ -20,11 +20,13 @@ extern void dump_page_badflags(struct page *page, const char *reason,
        } while (0)
 #define VM_WARN_ON(cond) WARN_ON(cond)
 #define VM_WARN_ON_ONCE(cond) WARN_ON_ONCE(cond)
+#define VM_WARN_ONCE(cond, format...) WARN_ONCE(cond, format)
 #else
 #define VM_BUG_ON(cond) BUILD_BUG_ON_INVALID(cond)
 #define VM_BUG_ON_PAGE(cond, page) VM_BUG_ON(cond)
 #define VM_WARN_ON(cond) BUILD_BUG_ON_INVALID(cond)
 #define VM_WARN_ON_ONCE(cond) BUILD_BUG_ON_INVALID(cond)
+#define VM_WARN_ONCE(cond, format...) BUILD_BUG_ON_INVALID(cond)
 #endif
 #ifdef CONFIG_DEBUG_VIRTUAL
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index deca87452528..27288692241e 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -170,6 +170,8 @@ extern int __mmu_notifier_register(struct mmu_notifier *mn,
                                   struct mm_struct *mm);
 extern void mmu_notifier_unregister(struct mmu_notifier *mn,
                                    struct mm_struct *mm);
+extern void mmu_notifier_unregister_no_release(struct mmu_notifier *mn,
+                                               struct mm_struct *mm);
 extern void __mmu_notifier_mm_destroy(struct mm_struct *mm);
 extern void __mmu_notifier_release(struct mm_struct *mm);
 extern int __mmu_notifier_clear_flush_young(struct mm_struct *mm,
@@ -288,6 +290,10 @@ static inline void mmu_notifier_mm_destroy(struct mm_struct *mm)
        set_pte_at(___mm, ___address, __ptep, ___pte);                  \
 })
+extern void mmu_notifier_call_srcu(struct rcu_head *rcu,
+                                   void (*func)(struct rcu_head *rcu));
+extern void mmu_notifier_synchronize(void);
 #else /* CONFIG_MMU_NOTIFIER */
 static inline void mmu_notifier_release(struct mm_struct *mm)
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 6cbd1b6c3d20..318df7051850 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -143,6 +143,7 @@ enum zone_stat_item {
        NR_SHMEM,               /* shmem pages (included tmpfs/GEM pages) */
        NR_DIRTIED,             /* page dirtyings since bootup */
        NR_WRITTEN,             /* page writings since bootup */
+        NR_PAGES_SCANNED,       /* pages scanned since last reclaim */
 #ifdef CONFIG_NUMA
        NUMA_HIT,               /* allocated in intended node */
        NUMA_MISS,              /* allocated in non intended node */
@@ -324,19 +325,12 @@ enum zone_type {
 #ifndef __GENERATING_BOUNDS_H
 struct zone {
-        /* Fields commonly accessed by the page allocator */
+        /* Read-mostly fields */
        /* zone watermarks, access with *_wmark_pages(zone) macros */
        unsigned long watermark[NR_WMARK];
        /*
-         * When free pages are below this point, additional steps are taken
-         * when reading the number of free pages to avoid per-cpu counter
-         * drift allowing watermarks to be breached
-         */
-        unsigned long percpu_drift_mark;
-        /*
         * We don't know if the memory that we're going to allocate will be freeable
         * or/and it will be released eventually, so to avoid totally wasting several
         * GB of ram we must reserve some of the lower zone memory (otherwise we risk
@@ -344,41 +338,26 @@ struct zone {
         * on the higher zones). This array is recalculated at runtime if the
         * sysctl_lowmem_reserve_ratio sysctl changes.
         */
-        unsigned long           lowmem_reserve[MAX_NR_ZONES];
+        long lowmem_reserve[MAX_NR_ZONES];
-        /*
-         * This is a per-zone reserve of pages that should not be
-         * considered dirtyable memory.
-         */
-        unsigned long           dirty_balance_reserve;
 #ifdef CONFIG_NUMA
        int node;
+#endif
        /*
-         * zone reclaim becomes active if more unmapped pages exist.
+         * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on
+         * this zone's LRU.  Maintained by the pageout code.
         */
-        unsigned long           min_unmapped_pages;
+        unsigned int inactive_ratio;
-        unsigned long           min_slab_pages;
-#endif
+        struct pglist_data      *zone_pgdat;
        struct per_cpu_pageset __percpu *pageset;
        /*
-         * free areas of different sizes
+         * This is a per-zone reserve of pages that should not be
+         * considered dirtyable memory.
         */
-        spinlock_t              lock;
+        unsigned long           dirty_balance_reserve;
-#if defined CONFIG_COMPACTION || defined CONFIG_CMA
-        /* Set to true when the PG_migrate_skip bits should be cleared */
-        bool                    compact_blockskip_flush;
-        /* pfn where compaction free scanner should start */
-        unsigned long           compact_cached_free_pfn;
-        /* pfn where async and sync compaction migration scanner should start */
-        unsigned long           compact_cached_migrate_pfn[2];
-#endif
-#ifdef CONFIG_MEMORY_HOTPLUG
-        /* see spanned/present_pages for more description */
-        seqlock_t               span_seqlock;
-#endif
-        struct free_area        free_area[MAX_ORDER];
 #ifndef CONFIG_SPARSEMEM
        /*
@@ -388,74 +367,14 @@ struct zone {
        unsigned long           *pageblock_flags;
 #endif /* CONFIG_SPARSEMEM */
-#ifdef CONFIG_COMPACTION
+#ifdef CONFIG_NUMA
-        /*
-         * On compaction failure, 1<<compact_defer_shift compactions
-         * are skipped before trying again. The number attempted since
-         * last failure is tracked with compact_considered.
-         */
-        unsigned int            compact_considered;
-        unsigned int            compact_defer_shift;
-        int                     compact_order_failed;
-#endif
-        ZONE_PADDING(_pad1_)
-        /* Fields commonly accessed by the page reclaim scanner */
-        spinlock_t              lru_lock;
-        struct lruvec           lruvec;
-        /* Evictions & activations on the inactive file list */
-        atomic_long_t           inactive_age;
-        unsigned long           pages_scanned;     /* since last reclaim */
-        unsigned long           flags;             /* zone flags, see below */
-        /* Zone statistics */
-        atomic_long_t           vm_stat[NR_VM_ZONE_STAT_ITEMS];
-        /*
-         * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on
-         * this zone's LRU.  Maintained by the pageout code.
-         */
-        unsigned int inactive_ratio;
-        ZONE_PADDING(_pad2_)
-        /* Rarely used or read-mostly fields */
        /*
-         * wait_table           -- the array holding the hash table
+         * zone reclaim becomes active if more unmapped pages exist.
-         * wait_table_hash_nr_entries   -- the size of the hash table array
-         * wait_table_bits      -- wait_table_size == (1 << wait_table_bits)
-         *
-         * The purpose of all these is to keep track of the people
-         * waiting for a page to become available and make them
-         * runnable again when possible. The trouble is that this
-         * consumes a lot of space, especially when so few things
-         * wait on pages at a given time. So instead of using
-         * per-page waitqueues, we use a waitqueue hash table.
-         *
-         * The bucket discipline is to sleep on the same queue when
-         * colliding and wake all in that wait queue when removing.
-         * When something wakes, it must check to be sure its page is
-         * truly available, a la thundering herd. The cost of a
-         * collision is great, but given the expected load of the
-         * table, they should be so rare as to be outweighed by the
-         * benefits from the saved space.
-         *
-         * __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
-         * primary users of these fields, and in mm/page_alloc.c
-         * free_area_init_core() performs the initialization of them.
         */
-        wait_queue_head_t       * wait_table;
+        unsigned long           min_unmapped_pages;
-        unsigned long           wait_table_hash_nr_entries;
+        unsigned long           min_slab_pages;
-        unsigned long           wait_table_bits;
+#endif /* CONFIG_NUMA */
-        /*
-         * Discontig memory support fields.
-         */
-        struct pglist_data      *zone_pgdat;
        /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
        unsigned long           zone_start_pfn;
@@ -500,9 +419,11 @@ struct zone {
         * adjust_managed_page_count() should be used instead of directly
         * touching zone->managed_pages and totalram_pages.
         */
+        unsigned long           managed_pages;
        unsigned long           spanned_pages;
        unsigned long           present_pages;
-        unsigned long           managed_pages;
+        const char              *name;
        /*
         * Number of MIGRATE_RESEVE page block. To maintain for just
@@ -510,10 +431,94 @@ struct zone {
         */
        int                     nr_migrate_reserve_block;
+#ifdef CONFIG_MEMORY_HOTPLUG
+        /* see spanned/present_pages for more description */
+        seqlock_t               span_seqlock;
+#endif
        /*
-         * rarely used fields:
+         * wait_table           -- the array holding the hash table
+         * wait_table_hash_nr_entries   -- the size of the hash table array
+         * wait_table_bits      -- wait_table_size == (1 << wait_table_bits)
+         *
+         * The purpose of all these is to keep track of the people
+         * waiting for a page to become available and make them
+         * runnable again when possible. The trouble is that this
+         * consumes a lot of space, especially when so few things
+         * wait on pages at a given time. So instead of using
+         * per-page waitqueues, we use a waitqueue hash table.
+         *
+         * The bucket discipline is to sleep on the same queue when
+         * colliding and wake all in that wait queue when removing.
+         * When something wakes, it must check to be sure its page is
+         * truly available, a la thundering herd. The cost of a
+         * collision is great, but given the expected load of the
+         * table, they should be so rare as to be outweighed by the
+         * benefits from the saved space.
+         *
+         * __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
+         * primary users of these fields, and in mm/page_alloc.c
+         * free_area_init_core() performs the initialization of them.
         */
-        const char              *name;
+        wait_queue_head_t       *wait_table;
+        unsigned long           wait_table_hash_nr_entries;
+        unsigned long           wait_table_bits;
+        ZONE_PADDING(_pad1_)
+        /* Write-intensive fields used from the page allocator */
+        spinlock_t              lock;
+        /* free areas of different sizes */
+        struct free_area        free_area[MAX_ORDER];
+        /* zone flags, see below */
+        unsigned long           flags;
+        ZONE_PADDING(_pad2_)
+        /* Write-intensive fields used by page reclaim */
+        /* Fields commonly accessed by the page reclaim scanner */
+        spinlock_t              lru_lock;
+        struct lruvec           lruvec;
+        /* Evictions & activations on the inactive file list */
+        atomic_long_t           inactive_age;
+        /*
+         * When free pages are below this point, additional steps are taken
+         * when reading the number of free pages to avoid per-cpu counter
+         * drift allowing watermarks to be breached
+         */
+        unsigned long percpu_drift_mark;
+#if defined CONFIG_COMPACTION || defined CONFIG_CMA
+        /* pfn where compaction free scanner should start */
+        unsigned long           compact_cached_free_pfn;
+        /* pfn where async and sync compaction migration scanner should start */
+        unsigned long           compact_cached_migrate_pfn[2];
+#endif
+#ifdef CONFIG_COMPACTION
+        /*
+         * On compaction failure, 1<<compact_defer_shift compactions
+         * are skipped before trying again. The number attempted since
+         * last failure is tracked with compact_considered.
+         */
+        unsigned int            compact_considered;
+        unsigned int            compact_defer_shift;
+        int                     compact_order_failed;
+#endif
+#if defined CONFIG_COMPACTION || defined CONFIG_CMA
+        /* Set to true when the PG_migrate_skip bits should be cleared */
+        bool                    compact_blockskip_flush;
+#endif
+        ZONE_PADDING(_pad3_)
+        /* Zone statistics */
+        atomic_long_t           vm_stat[NR_VM_ZONE_STAT_ITEMS];
 } ____cacheline_internodealigned_in_smp;
 typedef enum {
@@ -529,6 +534,7 @@ typedef enum {
        ZONE_WRITEBACK,                 /* reclaim scanning has recently found
                                         * many pages under writeback
                                         */
+        ZONE_FAIR_DEPLETED,             /* fair zone policy batch depleted */
 } zone_flags_t;
 static inline void zone_set_flag(struct zone *zone, zone_flags_t flag)
@@ -566,6 +572,11 @@ static inline int zone_is_reclaim_locked(const struct zone *zone)
        return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
 }
+static inline int zone_is_fair_depleted(const struct zone *zone)
+{
+        return test_bit(ZONE_FAIR_DEPLETED, &zone->flags);
+}
 static inline int zone_is_oom_locked(const struct zone *zone)
 {
        return test_bit(ZONE_OOM_LOCKED, &zone->flags);
@@ -872,6 +883,8 @@ static inline int zone_movable_is_highmem(void)
 {
 #if defined(CONFIG_HIGHMEM) && defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
        return movable_zone == ZONE_HIGHMEM;
+#elif defined(CONFIG_HIGHMEM)
+        return (ZONE_MOVABLE - 1) == ZONE_HIGHMEM;
 #else
        return 0;
 #endif
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index 58b9a02c38d2..83a6aeda899d 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -430,7 +430,15 @@ static inline int num_node_state(enum node_states state)
        for_each_node_mask((__node), node_states[__state])
 #define first_online_node       first_node(node_states[N_ONLINE])
-#define next_online_node(nid)   next_node((nid), node_states[N_ONLINE])
+#define first_memory_node       first_node(node_states[N_MEMORY])
+static inline int next_online_node(int nid)
+{
+        return next_node(nid, node_states[N_ONLINE]);
+}
+static inline int next_memory_node(int nid)
+{
+        return next_node(nid, node_states[N_MEMORY]);
+}
 extern int nr_node_ids;
 extern int nr_online_nodes;
@@ -471,6 +479,7 @@ static inline int num_node_state(enum node_states state)
        for ( (node) = 0; (node) == 0; (node) = 1)
 #define first_online_node       0
+#define first_memory_node       0
 #define next_online_node(nid)   (MAX_NUMNODES)
 #define nr_node_ids             1
 #define nr_online_nodes         1
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 4cd62677feb9..647395a1a550 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -55,8 +55,8 @@ extern void oom_kill_process(struct task_struct *p, gfp_t gfp_mask, int order,
                             struct mem_cgroup *memcg, nodemask_t *nodemask,
                             const char *message);
-extern int try_set_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
+extern bool oom_zonelist_trylock(struct zonelist *zonelist, gfp_t gfp_flags);
-extern void clear_zonelist_oom(struct zonelist *zonelist, gfp_t gfp_flags);
+extern void oom_zonelist_unlock(struct zonelist *zonelist, gfp_t gfp_flags);
 extern void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
                               int order, const nodemask_t *nodemask);
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 8304959ad336..e1f5fcd79792 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -171,13 +171,12 @@ static inline int __TestClearPage##uname(struct page *page)		\
 #define __PAGEFLAG(uname, lname) TESTPAGEFLAG(uname, lname)             \
        __SETPAGEFLAG(uname, lname)  __CLEARPAGEFLAG(uname, lname)
-#define PAGEFLAG_FALSE(uname)                                           \
-static inline int Page##uname(const struct page *page)                  \
-                        { return 0; }
 #define TESTSCFLAG(uname, lname)                                        \
        TESTSETFLAG(uname, lname) TESTCLEARFLAG(uname, lname)
+#define TESTPAGEFLAG_FALSE(uname)                                       \
+static inline int Page##uname(const struct page *page) { return 0; }
 #define SETPAGEFLAG_NOOP(uname)                                         \
 static inline void SetPage##uname(struct page *page) {  }
@@ -187,12 +186,21 @@ static inline void ClearPage##uname(struct page *page) {  }
 #define __CLEARPAGEFLAG_NOOP(uname)                                     \
 static inline void __ClearPage##uname(struct page *page) {  }
+#define TESTSETFLAG_FALSE(uname)                                        \
+static inline int TestSetPage##uname(struct page *page) { return 0; }
 #define TESTCLEARFLAG_FALSE(uname)                                      \
 static inline int TestClearPage##uname(struct page *page) { return 0; }
 #define __TESTCLEARFLAG_FALSE(uname)                                    \
 static inline int __TestClearPage##uname(struct page *page) { return 0; }
+#define PAGEFLAG_FALSE(uname) TESTPAGEFLAG_FALSE(uname)                 \
+        SETPAGEFLAG_NOOP(uname) CLEARPAGEFLAG_NOOP(uname)
+#define TESTSCFLAG_FALSE(uname)                                         \
+        TESTSETFLAG_FALSE(uname) TESTCLEARFLAG_FALSE(uname)
 struct page;    /* forward declaration */
 TESTPAGEFLAG(Locked, locked)
@@ -248,7 +256,6 @@ PAGEFLAG_FALSE(HighMem)
 PAGEFLAG(SwapCache, swapcache)
 #else
 PAGEFLAG_FALSE(SwapCache)
-        SETPAGEFLAG_NOOP(SwapCache) CLEARPAGEFLAG_NOOP(SwapCache)
 #endif
 PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
@@ -258,8 +265,8 @@ PAGEFLAG(Unevictable, unevictable) __CLEARPAGEFLAG(Unevictable, unevictable)
 PAGEFLAG(Mlocked, mlocked) __CLEARPAGEFLAG(Mlocked, mlocked)
        TESTSCFLAG(Mlocked, mlocked) __TESTCLEARFLAG(Mlocked, mlocked)
 #else
-PAGEFLAG_FALSE(Mlocked) SETPAGEFLAG_NOOP(Mlocked)
+PAGEFLAG_FALSE(Mlocked) __CLEARPAGEFLAG_NOOP(Mlocked)
-        TESTCLEARFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
+        TESTSCFLAG_FALSE(Mlocked) __TESTCLEARFLAG_FALSE(Mlocked)
 #endif
 #ifdef CONFIG_ARCH_USES_PG_UNCACHED
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index e1474ae18c88..3df8c7db7a4e 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -484,6 +484,9 @@ static inline int lock_page_killable(struct page *page)
 /*
 * lock_page_or_retry - Lock the page, unless this would block and the
 * caller indicated that it can handle a retry.
+ *
+ * Return value and mmap_sem implications depend on flags; see
+ * __lock_page_or_retry().
 */
 static inline int lock_page_or_retry(struct page *page, struct mm_struct *mm,
                                     unsigned int flags)
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 319ff7e53efb..0990997a5304 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -31,7 +31,7 @@ static inline const char *printk_skip_level(const char *buffer)
 }
 /* printk's without a loglevel use this.. */
-#define DEFAULT_MESSAGE_LOGLEVEL CONFIG_DEFAULT_MESSAGE_LOGLEVEL
+#define MESSAGE_LOGLEVEL_DEFAULT CONFIG_MESSAGE_LOGLEVEL_DEFAULT
 /* We show everything that is MORE important than this.. */
 #define CONSOLE_LOGLEVEL_SILENT  0 /* Mum's the word */
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 8183b46fbaa2..372ad5e0dcb8 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -432,9 +432,9 @@ static inline void hlist_add_before_rcu(struct hlist_node *n,
 }
 /**
- * hlist_add_after_rcu
+ * hlist_add_behind_rcu
- * @prev: the existing element to add the new element after.
 * @n: the new element to add to the hash list.
+ * @prev: the existing element to add the new element after.
 *
 * Description:
 * Adds the specified element to the specified hlist
@@ -449,8 +449,8 @@ static inline void hlist_add_before_rcu(struct hlist_node *n,
 * hlist_for_each_entry_rcu(), used to prevent memory-consistency
 * problems on Alpha CPUs.
 */
-static inline void hlist_add_after_rcu(struct hlist_node *prev,
+static inline void hlist_add_behind_rcu(struct hlist_node *n,
-                                       struct hlist_node *n)
+                                        struct hlist_node *prev)
 {
        n->next = prev->next;
        n->pprev = &prev->next;
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 4bdbee80eede..1eb64043c076 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -311,7 +311,6 @@ extern void lru_add_page_tail(struct page *page, struct page *page_tail,
                         struct lruvec *lruvec, struct list_head *head);
 extern void activate_page(struct page *);
 extern void mark_page_accessed(struct page *);
-extern void init_page_accessed(struct page *page);
 extern void lru_add_drain(void);
 extern void lru_add_drain_cpu(int cpu);
 extern void lru_add_drain_all(void);
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index 4b8a89189a29..b87696fdf06a 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -113,7 +113,7 @@ extern struct vm_struct *remove_vm_area(const void *addr);
 extern struct vm_struct *find_vm_area(const void *addr);
 extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
-                        struct page ***pages);
+                        struct page **pages);
 #ifdef CONFIG_MMU
 extern int map_kernel_range_noflush(unsigned long start, unsigned long size,
                                    pgprot_t prot, struct page **pages);
diff --git a/include/linux/zbud.h b/include/linux/zbud.h
index 13af0d450bf6..f9d41a6e361f 100644
--- a/include/linux/zbud.h
+++ b/include/linux/zbud.h
@@ -11,7 +11,7 @@ struct zbud_ops {
 struct zbud_pool *zbud_create_pool(gfp_t gfp, struct zbud_ops *ops);
 void zbud_destroy_pool(struct zbud_pool *pool);
-int zbud_alloc(struct zbud_pool *pool, unsigned int size, gfp_t gfp,
+int zbud_alloc(struct zbud_pool *pool, size_t size, gfp_t gfp,
        unsigned long *handle);
 void zbud_free(struct zbud_pool *pool, unsigned long handle);
 int zbud_reclaim_page(struct zbud_pool *pool, unsigned int retries);
diff --git a/include/linux/zlib.h b/include/linux/zlib.h
index 9c5a6b4de0a3..197abb2a54c5 100644
--- a/include/linux/zlib.h
+++ b/include/linux/zlib.h
@@ -493,64 +493,6 @@ extern int deflateInit2 (z_streamp strm,
   method). msg is set to null if there is no error message.  deflateInit2 does
   not perform any compression: this will be done by deflate().
 */
-                            
-#if 0
-extern int zlib_deflateSetDictionary (z_streamp strm,
-                                                     const Byte *dictionary,
-                                                     uInt  dictLength);
-#endif
-/*
-     Initializes the compression dictionary from the given byte sequence
-   without producing any compressed output. This function must be called
-   immediately after deflateInit, deflateInit2 or deflateReset, before any
-   call of deflate. The compressor and decompressor must use exactly the same
-   dictionary (see inflateSetDictionary).
-     The dictionary should consist of strings (byte sequences) that are likely
-   to be encountered later in the data to be compressed, with the most commonly
-   used strings preferably put towards the end of the dictionary. Using a
-   dictionary is most useful when the data to be compressed is short and can be
-   predicted with good accuracy; the data can then be compressed better than
-   with the default empty dictionary.
-     Depending on the size of the compression data structures selected by
-   deflateInit or deflateInit2, a part of the dictionary may in effect be
-   discarded, for example if the dictionary is larger than the window size in
-   deflate or deflate2. Thus the strings most likely to be useful should be
-   put at the end of the dictionary, not at the front.
-     Upon return of this function, strm->adler is set to the Adler32 value
-   of the dictionary; the decompressor may later use this value to determine
-   which dictionary has been used by the compressor. (The Adler32 value
-   applies to the whole dictionary even if only a subset of the dictionary is
-   actually used by the compressor.)
-     deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
-   parameter is invalid (such as NULL dictionary) or the stream state is
-   inconsistent (for example if deflate has already been called for this stream
-   or if the compression method is bsort). deflateSetDictionary does not
-   perform any compression: this will be done by deflate().
-*/
-#if 0
-extern int zlib_deflateCopy (z_streamp dest, z_streamp source);
-#endif
-/*
-     Sets the destination stream as a complete copy of the source stream.
-     This function can be useful when several compression strategies will be
-   tried, for example when there are several ways of pre-processing the input
-   data with a filter. The streams that will be discarded should then be freed
-   by calling deflateEnd.  Note that deflateCopy duplicates the internal
-   compression state which can be quite large, so this strategy is slow and
-   can consume lots of memory.
-     deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
-   enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
-   (such as zalloc being NULL). msg is left unchanged in both source and
-   destination.
-*/
 extern int zlib_deflateReset (z_streamp strm);
 /*
@@ -568,27 +510,6 @@ static inline unsigned long deflateBound(unsigned long s)
        return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
 }
-#if 0
-extern int zlib_deflateParams (z_streamp strm, int level, int strategy);
-#endif
-/*
-     Dynamically update the compression level and compression strategy.  The
-   interpretation of level and strategy is as in deflateInit2.  This can be
-   used to switch between compression and straight copy of the input data, or
-   to switch to a different kind of input data requiring a different
-   strategy. If the compression level is changed, the input available so far
-   is compressed with the old level (and may be flushed); the new level will
-   take effect only at the next call of deflate().
-     Before the call of deflateParams, the stream state must be set as for
-   a call of deflate(), since the currently available input may have to
-   be compressed and flushed. In particular, strm->avail_out must be non-zero.
-     deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source
-   stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR
-   if strm->avail_out was zero.
-*/
 /*   
 extern int inflateInit2 (z_streamp strm, int  windowBits);
@@ -631,45 +552,6 @@ extern int inflateInit2 (z_streamp strm, int  windowBits);
   and avail_out are unchanged.)
 */
-extern int zlib_inflateSetDictionary (z_streamp strm,
-                                                     const Byte *dictionary,
-                                                     uInt  dictLength);
-/*
-     Initializes the decompression dictionary from the given uncompressed byte
-   sequence. This function must be called immediately after a call of inflate,
-   if that call returned Z_NEED_DICT. The dictionary chosen by the compressor
-   can be determined from the adler32 value returned by that call of inflate.
-   The compressor and decompressor must use exactly the same dictionary (see
-   deflateSetDictionary).  For raw inflate, this function can be called
-   immediately after inflateInit2() or inflateReset() and before any call of
-   inflate() to set the dictionary.  The application must insure that the
-   dictionary that was used for compression is provided.
-     inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
-   parameter is invalid (such as NULL dictionary) or the stream state is
-   inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
-   expected one (incorrect adler32 value). inflateSetDictionary does not
-   perform any decompression: this will be done by subsequent calls of
-   inflate().
-*/
-#if 0
-extern int zlib_inflateSync (z_streamp strm);
-#endif
-/* 
-    Skips invalid compressed data until a full flush point (see above the
-  description of deflate with Z_FULL_FLUSH) can be found, or until all
-  available input is skipped. No output is provided.
-    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR
-  if no more input was provided, Z_DATA_ERROR if no flush point has been found,
-  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success
-  case, the application may save the current current value of total_in which
-  indicates where valid compressed data was found. In the error case, the
-  application may repeatedly call inflateSync, providing more input each time,
-  until success or end of the input data.
-*/
 extern int zlib_inflateReset (z_streamp strm);
 /*
     This function is equivalent to inflateEnd followed by inflateInit,
diff --git a/include/linux/zpool.h b/include/linux/zpool.h
new file mode 100644
index 000000000000..f14bd75f08b3
--- /dev/null
+++ b/include/linux/zpool.h
@@ -0,0 +1,106 @@
+/*
+ * zpool memory storage api
+ *
+ * Copyright (C) 2014 Dan Streetman
+ *
+ * This is a common frontend for the zbud and zsmalloc memory
+ * storage pool implementations.  Typically, this is used to
+ * store compressed memory.
+ */
+#ifndef _ZPOOL_H_
+#define _ZPOOL_H_
+struct zpool;
+struct zpool_ops {
+        int (*evict)(struct zpool *pool, unsigned long handle);
+};
+/*
+ * Control how a handle is mapped.  It will be ignored if the
+ * implementation does not support it.  Its use is optional.
+ * Note that this does not refer to memory protection, it
+ * refers to how the memory will be copied in/out if copying
+ * is necessary during mapping; read-write is the safest as
+ * it copies the existing memory in on map, and copies the
+ * changed memory back out on unmap.  Write-only does not copy
+ * in the memory and should only be used for initialization.
+ * If in doubt, use ZPOOL_MM_DEFAULT which is read-write.
+ */
+enum zpool_mapmode {
+        ZPOOL_MM_RW, /* normal read-write mapping */
+        ZPOOL_MM_RO, /* read-only (no copy-out at unmap time) */
+        ZPOOL_MM_WO, /* write-only (no copy-in at map time) */
+        ZPOOL_MM_DEFAULT = ZPOOL_MM_RW
+};
+struct zpool *zpool_create_pool(char *type, gfp_t gfp, struct zpool_ops *ops);
+char *zpool_get_type(struct zpool *pool);
+void zpool_destroy_pool(struct zpool *pool);
+int zpool_malloc(struct zpool *pool, size_t size, gfp_t gfp,
+                        unsigned long *handle);
+void zpool_free(struct zpool *pool, unsigned long handle);
+int zpool_shrink(struct zpool *pool, unsigned int pages,
+                        unsigned int *reclaimed);
+void *zpool_map_handle(struct zpool *pool, unsigned long handle,
+                        enum zpool_mapmode mm);
+void zpool_unmap_handle(struct zpool *pool, unsigned long handle);
+u64 zpool_get_total_size(struct zpool *pool);
+/**
+ * struct zpool_driver - driver implementation for zpool
+ * @type:       name of the driver.
+ * @list:       entry in the list of zpool drivers.
+ * @create:     create a new pool.
+ * @destroy:    destroy a pool.
+ * @malloc:     allocate mem from a pool.
+ * @free:       free mem from a pool.
+ * @shrink:     shrink the pool.
+ * @map:        map a handle.
+ * @unmap:      unmap a handle.
+ * @total_size: get total size of a pool.
+ *
+ * This is created by a zpool implementation and registered
+ * with zpool.
+ */
+struct zpool_driver {
+        char *type;
+        struct module *owner;
+        atomic_t refcount;
+        struct list_head list;
+        void *(*create)(gfp_t gfp, struct zpool_ops *ops);
+        void (*destroy)(void *pool);
+        int (*malloc)(void *pool, size_t size, gfp_t gfp,
+                                unsigned long *handle);
+        void (*free)(void *pool, unsigned long handle);
+        int (*shrink)(void *pool, unsigned int pages,
+                                unsigned int *reclaimed);
+        void *(*map)(void *pool, unsigned long handle,
+                                enum zpool_mapmode mm);
+        void (*unmap)(void *pool, unsigned long handle);
+        u64 (*total_size)(void *pool);
+};
+void zpool_register_driver(struct zpool_driver *driver);
+int zpool_unregister_driver(struct zpool_driver *driver);
+int zpool_evict(void *pool, unsigned long handle);
+#endif
diff --git a/include/trace/events/migrate.h b/include/trace/events/migrate.h
index 4e4f2f8b1ac2..dd2b5467d905 100644
--- a/include/trace/events/migrate.h
+++ b/include/trace/events/migrate.h
@@ -17,6 +17,7 @@
        {MR_MEMORY_HOTPLUG,     "memory_hotplug"},              \
        {MR_SYSCALL,            "syscall_or_cpuset"},           \
        {MR_MEMPOLICY_MBIND,    "mempolicy_mbind"},             \
+        {MR_NUMA_MISPLACED,     "numa_misplaced"},              \
        {MR_CMA,                "cma"}
 TRACE_EVENT(mm_migrate_pages,
diff --git a/include/trace/events/pagemap.h b/include/trace/events/pagemap.h
index 1c9fabde69e4..ce0803b8d05f 100644
--- a/include/trace/events/pagemap.h
+++ b/include/trace/events/pagemap.h
@@ -28,12 +28,10 @@ TRACE_EVENT(mm_lru_insertion,
        TP_PROTO(
                struct page *page,
-                unsigned long pfn,
+                int lru
-                int lru,
-                unsigned long flags
        ),
-        TP_ARGS(page, pfn, lru, flags),
+        TP_ARGS(page, lru),
        TP_STRUCT__entry(
                __field(struct page *,  page    )
@@ -44,9 +42,9 @@ TRACE_EVENT(mm_lru_insertion,
        TP_fast_assign(
                __entry->page   = page;
-                __entry->pfn    = pfn;
+                __entry->pfn    = page_to_pfn(page);
                __entry->lru    = lru;
-                __entry->flags  = flags;
+                __entry->flags  = trace_pagemap_flags(page);
        ),
        /* Flag format is based on page-types.c formatting for pagemap */
@@ -64,9 +62,9 @@ TRACE_EVENT(mm_lru_insertion,
 TRACE_EVENT(mm_lru_activate,
-        TP_PROTO(struct page *page, unsigned long pfn),
+        TP_PROTO(struct page *page),
-        TP_ARGS(page, pfn),
+        TP_ARGS(page),
        TP_STRUCT__entry(
                __field(struct page *,  page    )
@@ -75,7 +73,7 @@ TRACE_EVENT(mm_lru_activate,
        TP_fast_assign(
                __entry->page   = page;
-                __entry->pfn    = pfn;
+                __entry->pfn    = page_to_pfn(page);
        ),
        /* Flag format is based on page-types.c formatting for pagemap */