1 files changed, 84 insertions, 56 deletions

diff --git a/mm/page_cgroup.c b/mm/page_cgroup.c
index 5bffada7cde1..99055010cece 100644
--- a/mm/page_cgroup.c
+++ b/mm/page_cgroup.c
@@ -11,12 +11,11 @@
 #include <linux/swapops.h>
 #include <linux/kmemleak.h>
 
-static void __meminit
-__init_page_cgroup(struct page_cgroup *pc, unsigned long pfn)
+static void __meminit init_page_cgroup(struct page_cgroup *pc, unsigned long id)
 {
         pc->flags = 0;
+        set_page_cgroup_array_id(pc, id);
         pc->mem_cgroup = NULL;
-        pc->page = pfn_to_page(pfn);
         INIT_LIST_HEAD(&pc->lru);
 }
 static unsigned long total_usage;
@@ -43,6 +42,19 @@ struct page_cgroup *lookup_page_cgroup(struct page *page)
         return base + offset;
 }
 
+struct page *lookup_cgroup_page(struct page_cgroup *pc)
+{
+        unsigned long pfn;
+        struct page *page;
+        pg_data_t *pgdat;
+
+        pgdat = NODE_DATA(page_cgroup_array_id(pc));
+        pfn = pc - pgdat->node_page_cgroup + pgdat->node_start_pfn;
+        page = pfn_to_page(pfn);
+        VM_BUG_ON(pc != lookup_page_cgroup(page));
+        return page;
+}
+
 static int __init alloc_node_page_cgroup(int nid)
 {
         struct page_cgroup *base, *pc;
@@ -63,7 +75,7 @@ static int __init alloc_node_page_cgroup(int nid)
                 return -ENOMEM;
         for (index = 0; index < nr_pages; index++) {
                 pc = base + index;
-                __init_page_cgroup(pc, start_pfn + index);
+                init_page_cgroup(pc, nid);
         }
         NODE_DATA(nid)->node_page_cgroup = base;
         total_usage += table_size;
@@ -105,46 +117,75 @@ struct page_cgroup *lookup_page_cgroup(struct page *page)
         return section->page_cgroup + pfn;
 }
 
-/* __alloc_bootmem...() is protected by !slab_available() */
+struct page *lookup_cgroup_page(struct page_cgroup *pc)
+{
+        struct mem_section *section;
+        struct page *page;
+        unsigned long nr;
+
+        nr = page_cgroup_array_id(pc);
+        section = __nr_to_section(nr);
+        page = pfn_to_page(pc - section->page_cgroup);
+        VM_BUG_ON(pc != lookup_page_cgroup(page));
+        return page;
+}
+
+static void *__init_refok alloc_page_cgroup(size_t size, int nid)
+{
+        void *addr = NULL;
+
+        addr = alloc_pages_exact(size, GFP_KERNEL | __GFP_NOWARN);
+        if (addr)
+                return addr;
+
+        if (node_state(nid, N_HIGH_MEMORY))
+                addr = vmalloc_node(size, nid);
+        else
+                addr = vmalloc(size);
+
+        return addr;
+}
+
+#ifdef CONFIG_MEMORY_HOTPLUG
+static void free_page_cgroup(void *addr)
+{
+        if (is_vmalloc_addr(addr)) {
+                vfree(addr);
+        } else {
+                struct page *page = virt_to_page(addr);
+                size_t table_size =
+                        sizeof(struct page_cgroup) * PAGES_PER_SECTION;
+
+                BUG_ON(PageReserved(page));
+                free_pages_exact(addr, table_size);
+        }
+}
+#endif
+
 static int __init_refok init_section_page_cgroup(unsigned long pfn)
 {
-        struct mem_section *section = __pfn_to_section(pfn);
         struct page_cgroup *base, *pc;
+        struct mem_section *section;
         unsigned long table_size;
+        unsigned long nr;
         int nid, index;
 
-        if (!section->page_cgroup) {
-                nid = page_to_nid(pfn_to_page(pfn));
-                table_size = sizeof(struct page_cgroup) * PAGES_PER_SECTION;
-                VM_BUG_ON(!slab_is_available());
-                if (node_state(nid, N_HIGH_MEMORY)) {
-                        base = kmalloc_node(table_size,
-                                GFP_KERNEL | __GFP_NOWARN, nid);
-                        if (!base)
-                                base = vmalloc_node(table_size, nid);
-                } else {
-                        base = kmalloc(table_size, GFP_KERNEL | __GFP_NOWARN);
-                        if (!base)
-                                base = vmalloc(table_size);
-                }
-                /*
-                 * The value stored in section->page_cgroup is (base - pfn)
-                 * and it does not point to the memory block allocated above,
-                 * causing kmemleak false positives.
-                 */
-                kmemleak_not_leak(base);
-        } else {
-                /*
-                 * We don't have to allocate page_cgroup again, but
-                 * address of memmap may be changed. So, we have to initialize
-                 * again.
-                 */
-                base = section->page_cgroup + pfn;
-                table_size = 0;
-                /* check address of memmap is changed or not. */
-                if (base->page == pfn_to_page(pfn))
-                        return 0;
-        }
+        nr = pfn_to_section_nr(pfn);
+        section = __nr_to_section(nr);
+
+        if (section->page_cgroup)
+                return 0;
+
+        nid = page_to_nid(pfn_to_page(pfn));
+        table_size = sizeof(struct page_cgroup) * PAGES_PER_SECTION;
+        base = alloc_page_cgroup(table_size, nid);
+
+        /*
+         * The value stored in section->page_cgroup is (base - pfn)
+         * and it does not point to the memory block allocated above,
+         * causing kmemleak false positives.
+         */
+        kmemleak_not_leak(base);
 
         if (!base) {
                 printk(KERN_ERR "page cgroup allocation failure\n");
@@ -153,7 +194,7 @@ static int __init_refok init_section_page_cgroup(unsigned long pfn)
 
         for (index = 0; index < PAGES_PER_SECTION; index++) {
                 pc = base + index;
-                __init_page_cgroup(pc, pfn + index);
+                init_page_cgroup(pc, nr);
         }
 
         section->page_cgroup = base - pfn;
@@ -170,16 +211,8 @@ void __free_page_cgroup(unsigned long pfn)
         if (!ms || !ms->page_cgroup)
                 return;
         base = ms->page_cgroup + pfn;
-        if (is_vmalloc_addr(base)) {
-                vfree(base);
-                ms->page_cgroup = NULL;
-        } else {
-                struct page *page = virt_to_page(base);
-                if (!PageReserved(page)) { /* Is bootmem ? */
-                        kfree(base);
-                        ms->page_cgroup = NULL;
-                }
-        }
+        free_page_cgroup(base);
+        ms->page_cgroup = NULL;
 }
 
 int __meminit online_page_cgroup(unsigned long start_pfn,
@@ -243,12 +276,7 @@ static int __meminit page_cgroup_callback(struct notifier_block *self,
                 break;
         }
 
-        if (ret)
-                ret = notifier_from_errno(ret);
-        else
-                ret = NOTIFY_OK;
-
-        return ret;
+        return notifier_from_errno(ret);
 }
 
 #endif
@@ -349,7 +377,7 @@ not_enough_page:
  * @new: new id
  *
  * Returns old id at success, 0 at failure.
- * (There is no mem_cgroup useing 0 as its id)
+ * (There is no mem_cgroup using 0 as its id)
  */
 unsigned short swap_cgroup_cmpxchg(swp_entry_t ent,
                                         unsigned short old, unsigned short new)