Merge branch 'akpm' (fixes from Andrew Morton)

Merge patch-bomb from Andrew Morton:
 - part of OCFS2 (review is laggy again)
 - procfs
 - slab
 - all of MM
 - zram, zbud
 - various other random things: arch, filesystems.

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (164 commits)
  nosave: consolidate __nosave_{begin,end} in <asm/sections.h>
  include/linux/screen_info.h: remove unused ORIG_* macros
  kernel/sys.c: compat sysinfo syscall: fix undefined behavior
  kernel/sys.c: whitespace fixes
  acct: eliminate compile warning
  kernel/async.c: switch to pr_foo()
  include/linux/blkdev.h: use NULL instead of zero
  include/linux/kernel.h: deduplicate code implementing clamp* macros
  include/linux/kernel.h: rewrite min3, max3 and clamp using min and max
  alpha: use Kbuild logic to include <asm-generic/sections.h>
  frv: remove deprecated IRQF_DISABLED
  frv: remove unused cpuinfo_frv and friends to fix future build error
  zbud: avoid accessing last unused freelist
  zsmalloc: simplify init_zspage free obj linking
  mm/zsmalloc.c: correct comment for fullness group computation
  zram: use notify_free to account all free notifications
  zram: report maximum used memory
  zram: zram memory size limitation
  zsmalloc: change return value unit of zs_get_total_size_bytes
  zsmalloc: move pages_allocated to zs_pool
  ...

4 files changed, 117 insertions, 3 deletions

diff --git a/drivers/base/Kconfig b/drivers/base/Kconfig
index 134f763d90fd..61a33f4ba608 100644
--- a/drivers/base/Kconfig
+++ b/drivers/base/Kconfig
@@ -252,6 +252,9 @@ config DMA_CMA
           to allocate big physically-contiguous blocks of memory for use with
           hardware components that do not support I/O map nor scatter-gather.
 
+          You can disable CMA by specifying "cma=0" on the kernel's command
+          line.
+
           For more information see <include/linux/dma-contiguous.h>.
           If unsure, say "n".
 
diff --git a/drivers/base/dma-mapping.c b/drivers/base/dma-mapping.c
index 6cd08e145bfa..9e8bbdd470ca 100644
--- a/drivers/base/dma-mapping.c
+++ b/drivers/base/dma-mapping.c
@@ -10,6 +10,8 @@
 #include <linux/dma-mapping.h>
 #include <linux/export.h>
 #include <linux/gfp.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
 #include <asm-generic/dma-coherent.h>
 
 /*
@@ -267,3 +269,73 @@ int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
         return ret;
 }
 EXPORT_SYMBOL(dma_common_mmap);
+
+#ifdef CONFIG_MMU
+/*
+ * remaps an array of PAGE_SIZE pages into another vm_area
+ * Cannot be used in non-sleeping contexts
+ */
+void *dma_common_pages_remap(struct page **pages, size_t size,
+                        unsigned long vm_flags, pgprot_t prot,
+                        const void *caller)
+{
+        struct vm_struct *area;
+
+        area = get_vm_area_caller(size, vm_flags, caller);
+        if (!area)
+                return NULL;
+
+        area->pages = pages;
+
+        if (map_vm_area(area, prot, pages)) {
+                vunmap(area->addr);
+                return NULL;
+        }
+
+        return area->addr;
+}
+
+/*
+ * remaps an allocated contiguous region into another vm_area.
+ * Cannot be used in non-sleeping contexts
+ */
+
+void *dma_common_contiguous_remap(struct page *page, size_t size,
+                        unsigned long vm_flags,
+                        pgprot_t prot, const void *caller)
+{
+        int i;
+        struct page **pages;
+        void *ptr;
+        unsigned long pfn;
+
+        pages = kmalloc(sizeof(struct page *) << get_order(size), GFP_KERNEL);
+        if (!pages)
+                return NULL;
+
+        for (i = 0, pfn = page_to_pfn(page); i < (size >> PAGE_SHIFT); i++)
+                pages[i] = pfn_to_page(pfn + i);
+
+        ptr = dma_common_pages_remap(pages, size, vm_flags, prot, caller);
+
+        kfree(pages);
+
+        return ptr;
+}
+
+/*
+ * unmaps a range previously mapped by dma_common_*_remap
+ */
+void dma_common_free_remap(void *cpu_addr, size_t size, unsigned long vm_flags)
+{
+        struct vm_struct *area = find_vm_area(cpu_addr);
+
+        if (!area || (area->flags & vm_flags) != vm_flags) {
+                WARN(1, "trying to free invalid coherent area: %p\n", cpu_addr);
+                return;
+        }
+
+        unmap_kernel_range((unsigned long)cpu_addr, size);
+        vunmap(cpu_addr);
+}
+#endif
diff --git a/drivers/base/memory.c b/drivers/base/memory.c
index a2e13e250bba..7c5d87191b28 100644
--- a/drivers/base/memory.c
+++ b/drivers/base/memory.c
@@ -373,6 +373,45 @@ static ssize_t show_phys_device(struct device *dev,
         return sprintf(buf, "%d\n", mem->phys_device);
 }
 
+#ifdef CONFIG_MEMORY_HOTREMOVE
+static ssize_t show_valid_zones(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        struct memory_block *mem = to_memory_block(dev);
+        unsigned long start_pfn, end_pfn;
+        unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
+        struct page *first_page;
+        struct zone *zone;
+
+        start_pfn = section_nr_to_pfn(mem->start_section_nr);
+        end_pfn = start_pfn + nr_pages;
+        first_page = pfn_to_page(start_pfn);
+
+        /* The block contains more than one zone can not be offlined. */
+        if (!test_pages_in_a_zone(start_pfn, end_pfn))
+                return sprintf(buf, "none\n");
+
+        zone = page_zone(first_page);
+
+        if (zone_idx(zone) == ZONE_MOVABLE - 1) {
+                /*The mem block is the last memoryblock of this zone.*/
+                if (end_pfn == zone_end_pfn(zone))
+                        return sprintf(buf, "%s %s\n",
+                                        zone->name, (zone + 1)->name);
+        }
+
+        if (zone_idx(zone) == ZONE_MOVABLE) {
+                /*The mem block is the first memoryblock of ZONE_MOVABLE.*/
+                if (start_pfn == zone->zone_start_pfn)
+                        return sprintf(buf, "%s %s\n",
+                                        zone->name, (zone - 1)->name);
+        }
+
+        return sprintf(buf, "%s\n", zone->name);
+}
+static DEVICE_ATTR(valid_zones, 0444, show_valid_zones, NULL);
+#endif
+
 static DEVICE_ATTR(phys_index, 0444, show_mem_start_phys_index, NULL);
 static DEVICE_ATTR(state, 0644, show_mem_state, store_mem_state);
 static DEVICE_ATTR(phys_device, 0444, show_phys_device, NULL);
@@ -523,6 +562,9 @@ static struct attribute *memory_memblk_attrs[] = {
         &dev_attr_state.attr,
         &dev_attr_phys_device.attr,
         &dev_attr_removable.attr,
+#ifdef CONFIG_MEMORY_HOTREMOVE
+        &dev_attr_valid_zones.attr,
+#endif
         NULL
 };
 
diff --git a/drivers/base/node.c b/drivers/base/node.c
index d51c49c9bafa..472168cd0c97 100644
--- a/drivers/base/node.c
+++ b/drivers/base/node.c
@@ -289,8 +289,6 @@ static int register_node(struct node *node, int num, struct node *parent)
                 device_create_file(&node->dev, &dev_attr_distance);
                 device_create_file(&node->dev, &dev_attr_vmstat);
 
-                scan_unevictable_register_node(node);
-
                 hugetlb_register_node(node);
 
                 compaction_register_node(node);
@@ -314,7 +312,6 @@ void unregister_node(struct node *node)
         device_remove_file(&node->dev, &dev_attr_distance);
         device_remove_file(&node->dev, &dev_attr_vmstat);
 
-        scan_unevictable_unregister_node(node);
         hugetlb_unregister_node(node);          /* no-op, if memoryless node */
 
         device_unregister(&node->dev);