memcg: charge swapcache to proper memcg
[linux-2.6.git] / mm / memory_hotplug.c
index 0fb05b2..c083cf5 100644 (file)
 #include <linux/highmem.h>
 #include <linux/vmalloc.h>
 #include <linux/ioport.h>
-#include <linux/cpuset.h>
 #include <linux/delay.h>
 #include <linux/migrate.h>
 #include <linux/page-isolation.h>
+#include <linux/pfn.h>
 
 #include <asm/tlbflush.h>
 
@@ -189,7 +189,7 @@ static void grow_pgdat_span(struct pglist_data *pgdat, unsigned long start_pfn,
                                        pgdat->node_start_pfn;
 }
 
-static int __add_zone(struct zone *zone, unsigned long phys_start_pfn)
+static int __meminit __add_zone(struct zone *zone, unsigned long phys_start_pfn)
 {
        struct pglist_data *pgdat = zone->zone_pgdat;
        int nr_pages = PAGES_PER_SECTION;
@@ -216,7 +216,8 @@ static int __add_zone(struct zone *zone, unsigned long phys_start_pfn)
        return 0;
 }
 
-static int __add_section(struct zone *zone, unsigned long phys_start_pfn)
+static int __meminit __add_section(int nid, struct zone *zone,
+                                       unsigned long phys_start_pfn)
 {
        int nr_pages = PAGES_PER_SECTION;
        int ret;
@@ -234,7 +235,7 @@ static int __add_section(struct zone *zone, unsigned long phys_start_pfn)
        if (ret < 0)
                return ret;
 
-       return register_new_memory(__pfn_to_section(phys_start_pfn));
+       return register_new_memory(nid, __pfn_to_section(phys_start_pfn));
 }
 
 #ifdef CONFIG_SPARSEMEM_VMEMMAP
@@ -273,8 +274,8 @@ static int __remove_section(struct zone *zone, struct mem_section *ms)
  * call this function after deciding the zone to which to
  * add the new pages.
  */
-int __add_pages(struct zone *zone, unsigned long phys_start_pfn,
-                unsigned long nr_pages)
+int __ref __add_pages(int nid, struct zone *zone, unsigned long phys_start_pfn,
+                       unsigned long nr_pages)
 {
        unsigned long i;
        int err = 0;
@@ -284,7 +285,7 @@ int __add_pages(struct zone *zone, unsigned long phys_start_pfn,
        end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1);
 
        for (i = start_sec; i <= end_sec; i++) {
-               err = __add_section(zone, i << PFN_SECTION_SHIFT);
+               err = __add_section(nid, zone, i << PFN_SECTION_SHIFT);
 
                /*
                 * EEXIST is finally dealt with by ioresource collision
@@ -323,11 +324,11 @@ int __remove_pages(struct zone *zone, unsigned long phys_start_pfn,
        BUG_ON(phys_start_pfn & ~PAGE_SECTION_MASK);
        BUG_ON(nr_pages % PAGES_PER_SECTION);
 
-       release_mem_region(phys_start_pfn << PAGE_SHIFT, nr_pages * PAGE_SIZE);
-
        sections_to_remove = nr_pages / PAGES_PER_SECTION;
        for (i = 0; i < sections_to_remove; i++) {
                unsigned long pfn = phys_start_pfn + i*PAGES_PER_SECTION;
+               release_mem_region(pfn << PAGE_SHIFT,
+                                  PAGES_PER_SECTION << PAGE_SHIFT);
                ret = __remove_section(zone, __pfn_to_section(pfn));
                if (ret)
                        break;
@@ -429,7 +430,9 @@ int online_pages(unsigned long pfn, unsigned long nr_pages)
 
        if (need_zonelists_rebuild)
                build_all_zonelists();
-       vm_total_pages = nr_free_pagecache_pages();
+       else
+               vm_total_pages = nr_free_pagecache_pages();
+
        writeback_set_ratelimit();
 
        if (onlined_pages)
@@ -468,7 +471,8 @@ static void rollback_node_hotadd(int nid, pg_data_t *pgdat)
 }
 
 
-int add_memory(int nid, u64 start, u64 size)
+/* we are OK calling __meminit stuff here - we have CONFIG_MEMORY_HOTPLUG */
+int __ref add_memory(int nid, u64 start, u64 size)
 {
        pg_data_t *pgdat = NULL;
        int new_pgdat = 0;
@@ -495,8 +499,6 @@ int add_memory(int nid, u64 start, u64 size)
        /* we online node here. we can't roll back from here. */
        node_set_online(nid);
 
-       cpuset_track_online_nodes();
-
        if (new_pgdat) {
                ret = register_one_node(nid);
                /*
@@ -521,6 +523,66 @@ EXPORT_SYMBOL_GPL(add_memory);
 
 #ifdef CONFIG_MEMORY_HOTREMOVE
 /*
+ * A free page on the buddy free lists (not the per-cpu lists) has PageBuddy
+ * set and the size of the free page is given by page_order(). Using this,
+ * the function determines if the pageblock contains only free pages.
+ * Due to buddy contraints, a free page at least the size of a pageblock will
+ * be located at the start of the pageblock
+ */
+static inline int pageblock_free(struct page *page)
+{
+       return PageBuddy(page) && page_order(page) >= pageblock_order;
+}
+
+/* Return the start of the next active pageblock after a given page */
+static struct page *next_active_pageblock(struct page *page)
+{
+       int pageblocks_stride;
+
+       /* Ensure the starting page is pageblock-aligned */
+       BUG_ON(page_to_pfn(page) & (pageblock_nr_pages - 1));
+
+       /* Move forward by at least 1 * pageblock_nr_pages */
+       pageblocks_stride = 1;
+
+       /* If the entire pageblock is free, move to the end of free page */
+       if (pageblock_free(page))
+               pageblocks_stride += page_order(page) - pageblock_order;
+
+       return page + (pageblocks_stride * pageblock_nr_pages);
+}
+
+/* Checks if this range of memory is likely to be hot-removable. */
+int is_mem_section_removable(unsigned long start_pfn, unsigned long nr_pages)
+{
+       int type;
+       struct page *page = pfn_to_page(start_pfn);
+       struct page *end_page = page + nr_pages;
+
+       /* Check the starting page of each pageblock within the range */
+       for (; page < end_page; page = next_active_pageblock(page)) {
+               type = get_pageblock_migratetype(page);
+
+               /*
+                * A pageblock containing MOVABLE or free pages is considered
+                * removable
+                */
+               if (type != MIGRATE_MOVABLE && !pageblock_free(page))
+                       return 0;
+
+               /*
+                * A pageblock starting with a PageReserved page is not
+                * considered removable.
+                */
+               if (PageReserved(page))
+                       return 0;
+       }
+
+       /* All pageblocks in the memory block are likely to be hot-removable */
+       return 1;
+}
+
+/*
  * Confirm all pages in a range [start, end) is belongs to the same zone.
  */
 static int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn)
@@ -565,15 +627,12 @@ int scan_lru_pages(unsigned long start, unsigned long end)
 }
 
 static struct page *
-hotremove_migrate_alloc(struct page *page,
-                       unsigned long private,
-                       int **x)
+hotremove_migrate_alloc(struct page *page, unsigned long private, int **x)
 {
-       /* This should be improoooooved!! */
-       return alloc_page(GFP_HIGHUSER_PAGECACHE);
+       /* This should be improooooved!! */
+       return alloc_page(GFP_HIGHUSER_MOVABLE);
 }
 
-
 #define NR_OFFLINE_AT_ONCE_PAGES       (256)
 static int
 do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
@@ -595,8 +654,9 @@ do_migrate_range(unsigned long start_pfn, unsigned long end_pfn)
                 * We can skip free pages. And we can only deal with pages on
                 * LRU.
                 */
-               ret = isolate_lru_page(page, &source);
+               ret = isolate_lru_page(page);
                if (!ret) { /* Success */
+                       list_add_tail(&page->lru, &source);
                        move_pages--;
                } else {
                        /* Becasue we don't have big zone->lock. we should
@@ -787,10 +847,19 @@ failed_removal:
 
        return ret;
 }
+
+int remove_memory(u64 start, u64 size)
+{
+       unsigned long start_pfn, end_pfn;
+
+       start_pfn = PFN_DOWN(start);
+       end_pfn = start_pfn + PFN_DOWN(size);
+       return offline_pages(start_pfn, end_pfn, 120 * HZ);
+}
 #else
 int remove_memory(u64 start, u64 size)
 {
        return -EINVAL;
 }
-EXPORT_SYMBOL_GPL(remove_memory);
 #endif /* CONFIG_MEMORY_HOTREMOVE */
+EXPORT_SYMBOL_GPL(remove_memory);