litmus_migrate_pages

4 files changed, 130 insertions, 1 deletions

diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h
index 089743ade734..1dbef0b18d21 100644
--- a/include/linux/balloon_compaction.h
+++ b/include/linux/balloon_compaction.h
@@ -93,6 +93,20 @@ static inline void balloon_page_free(struct page *page)
         __free_page(page);
 }
 
+static inline void litmus_balloon_page_free(struct page *page)
+{
+        /*
+         * Balloon pages always get an extra refcount before being isolated
+         * and before being dequeued to help on sorting out fortuite colisions
+         * between a thread attempting to isolate and another thread attempting
+         * to release the very same balloon page.
+         *
+         * Before we handle the page back to Buddy, lets drop its extra refcnt.
+         */
+        put_page(page);
+        __free_page(page);
+}
+
 #ifdef CONFIG_BALLOON_COMPACTION
 extern bool balloon_page_isolate(struct page *page);
 extern void balloon_page_putback(struct page *page);
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index a405d3dc0f61..a2a7e25ec716 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -41,6 +41,8 @@ extern int migrate_page(struct address_space *,
                         struct page *, struct page *, enum migrate_mode);
 extern int migrate_pages(struct list_head *l, new_page_t x,
                 unsigned long private, enum migrate_mode mode, int reason);
+extern int litmus_migrate_pages(struct list_head *l, new_page_t x,
+                unsigned long private, enum migrate_mode mode, int reason);
 extern int migrate_huge_page(struct page *, new_page_t x,
                 unsigned long private, enum migrate_mode mode);
 
diff --git a/litmus/litmus.c b/litmus/litmus.c
index 04c5017aa0dd..c8ed597f212e 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -499,7 +499,7 @@ asmlinkage long sys_set_page_color(int cpu)
 
         //node= 0;
         if (!list_empty(&pagelist)) {
-                ret = migrate_pages(&pagelist, new_alloc_page, node, MIGRATE_ASYNC, MR_SYSCALL);
+                ret = litmus_migrate_pages(&pagelist, new_alloc_page, node, MIGRATE_ASYNC, MR_SYSCALL);
                 TRACE_TASK(current, "%ld pages not migrated.\n", ret);
                 if (ret) {
                         putback_lru_pages(&pagelist);
diff --git a/mm/migrate.c b/mm/migrate.c
index a88c12f2235d..eab459afebf0 100644
--- a/mm/migrate.c
+++ b/mm/migrate.c
@@ -918,6 +918,65 @@ out:
         return rc;
 }
 
+static int litmus_unmap_and_move(new_page_t get_new_page, unsigned long private,
+                        struct page *page, int force, enum migrate_mode mode)
+{
+        int rc = 0;
+        int *result = NULL;
+        struct page *newpage = get_new_page(page, private, &result);
+
+        if (!newpage)
+                return -ENOMEM;
+
+        if (page_count(page) == 1) {
+                /* page was freed from under us. So we are done. */
+                goto out;
+        }
+
+        if (unlikely(PageTransHuge(page)))
+                if (unlikely(split_huge_page(page)))
+                        goto out;
+
+        rc = __unmap_and_move(page, newpage, force, mode);
+
+        if (unlikely(rc == MIGRATEPAGE_BALLOON_SUCCESS)) {
+                /*
+                 * A ballooned page has been migrated already.
+                 * Now, it's the time to wrap-up counters,
+                 * handle the page back to Buddy and return.
+                 */
+                dec_zone_page_state(page, NR_ISOLATED_ANON +
+                                    page_is_file_cache(page));
+                litmus_balloon_page_free(page);
+                return MIGRATEPAGE_SUCCESS;
+        }
+out:
+        if (rc != -EAGAIN) {
+                /*
+                 * A page that has been migrated has all references
+                 * removed and will be freed. A page that has not been
+                 * migrated will have kepts its references and be
+                 * restored.
+                 */
+                list_del(&page->lru);
+                dec_zone_page_state(page, NR_ISOLATED_ANON +
+                                page_is_file_cache(page));
+                putback_lru_page(page);
+        }
+        /*
+         * Move the new page to the LRU. If migration was not successful
+         * then this will free the page.
+         */
+        putback_lru_page(newpage);
+        if (result) {
+                if (rc)
+                        *result = rc;
+                else
+                        *result = page_to_nid(newpage);
+        }
+        return rc;
+}
+
 /*
  * Counterpart of unmap_and_move_page() for hugepage migration.
  *
@@ -1058,6 +1117,60 @@ out:
         return rc;
 }
 
+int litmus_migrate_pages(struct list_head *from, new_page_t get_new_page,
+                unsigned long private, enum migrate_mode mode, int reason)
+{
+        int retry = 1;
+        int nr_failed = 0;
+        int nr_succeeded = 0;
+        int pass = 0;
+        struct page *page;
+        struct page *page2;
+        int swapwrite = current->flags & PF_SWAPWRITE;
+        int rc;
+
+        if (!swapwrite)
+                current->flags |= PF_SWAPWRITE;
+
+        for(pass = 0; pass < 10 && retry; pass++) {
+                retry = 0;
+
+                list_for_each_entry_safe(page, page2, from, lru) {
+                        cond_resched();
+
+                        rc = litmus_unmap_and_move(get_new_page, private,
+                                                page, pass > 2, mode);
+
+                        switch(rc) {
+                        case -ENOMEM:
+                                goto out;
+                        case -EAGAIN:
+                                retry++;
+                                break;
+                        case MIGRATEPAGE_SUCCESS:
+                                nr_succeeded++;
+                                break;
+                        default:
+                                /* Permanent failure */
+                                nr_failed++;
+                                break;
+                        }
+                }
+        }
+        rc = nr_failed + retry;
+out:
+        if (nr_succeeded)
+                count_vm_events(PGMIGRATE_SUCCESS, nr_succeeded);
+        if (nr_failed)
+                count_vm_events(PGMIGRATE_FAIL, nr_failed);
+        trace_mm_migrate_pages(nr_succeeded, nr_failed, mode, reason);
+
+        if (!swapwrite)
+                current->flags &= ~PF_SWAPWRITE;
+
+        return rc;
+}
+
 int migrate_huge_page(struct page *hpage, new_page_t get_new_page,
                       unsigned long private, enum migrate_mode mode)
 {