mm/balloon_compaction.c

   1 /*
   2  * mm/balloon_compaction.c
   3  *
   4  * Common interface for making balloon pages movable by compaction.
   5  *
   6  * Copyright (C) 2012, Red Hat, Inc.  Rafael Aquini <aquini@redhat.com>
   7  */
   8 #include <linux/mm.h>
   9 #include <linux/slab.h>
  10 #include <linux/export.h>
  11 #include <linux/balloon_compaction.h>
  12
  13 /*
  14  * balloon_page_enqueue - allocates a new page and inserts it into the balloon
  15  *                        page list.
  16  * @b_dev_info: balloon device descriptor where we will insert a new page to
  17  *
  18  * Driver must call it to properly allocate a new enlisted balloon page
  19  * before definitively removing it from the guest system.
  20  * This function returns the page address for the recently enqueued page or
  21  * NULL in the case we fail to allocate a new page this turn.
  22  */
  23 struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info)
  24 {
  25         unsigned long flags;
  26         struct page *page = alloc_page(balloon_mapping_gfp_mask() |
  27                                         __GFP_NOMEMALLOC | __GFP_NORETRY);
  28         if (!page)
  29                 return NULL;
  30
  31         /*
  32          * Block others from accessing the 'page' when we get around to
  33          * establishing additional references. We should be the only one
  34          * holding a reference to the 'page' at this point.
  35          */
  36         BUG_ON(!trylock_page(page));
  37         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
  38         balloon_page_insert(b_dev_info, page);
  39         __count_vm_event(BALLOON_INFLATE);
  40         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
  41         unlock_page(page);
  42         return page;
  43 }
  44 EXPORT_SYMBOL_GPL(balloon_page_enqueue);
  45
  46 /*
  47  * balloon_page_dequeue - removes a page from balloon's page list and returns
  48  *                        the its address to allow the driver release the page.
  49  * @b_dev_info: balloon device decriptor where we will grab a page from.
  50  *
  51  * Driver must call it to properly de-allocate a previous enlisted balloon page
  52  * before definetively releasing it back to the guest system.
  53  * This function returns the page address for the recently dequeued page or
  54  * NULL in the case we find balloon's page list temporarily empty due to
  55  * compaction isolated pages.
  56  */
  57 struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info)
  58 {
  59         struct page *page, *tmp;
  60         unsigned long flags;
  61         bool dequeued_page;
  62
  63         dequeued_page = false;
  64         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
  65         list_for_each_entry_safe(page, tmp, &b_dev_info->pages, lru) {
  66                 /*
  67                  * Block others from accessing the 'page' while we get around
  68                  * establishing additional references and preparing the 'page'
  69                  * to be released by the balloon driver.
  70                  */
  71                 if (trylock_page(page)) {
  72 #ifdef CONFIG_BALLOON_COMPACTION
  73                         if (PageIsolated(page)) {
  74                                 /* raced with isolation */
  75                                 unlock_page(page);
  76                                 continue;
  77                         }
  78 #endif
  79                         balloon_page_delete(page);
  80                         __count_vm_event(BALLOON_DEFLATE);
  81                         unlock_page(page);
  82                         dequeued_page = true;
  83                         break;
  84                 }
  85         }
  86         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
  87
  88         if (!dequeued_page) {
  89                 /*
  90                  * If we are unable to dequeue a balloon page because the page
  91                  * list is empty and there is no isolated pages, then something
  92                  * went out of track and some balloon pages are lost.
  93                  * BUG() here, otherwise the balloon driver may get stuck into
  94                  * an infinite loop while attempting to release all its pages.
  95                  */
  96                 spin_lock_irqsave(&b_dev_info->pages_lock, flags);
  97                 if (unlikely(list_empty(&b_dev_info->pages) &&
  98                              !b_dev_info->isolated_pages))
  99                         BUG();
 100                 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 101                 page = NULL;
 102         }
 103         return page;
 104 }
 105 EXPORT_SYMBOL_GPL(balloon_page_dequeue);
 106
 107 #ifdef CONFIG_BALLOON_COMPACTION
 108
 109 bool balloon_page_isolate(struct page *page, isolate_mode_t mode)
 110
 111 {
 112         struct balloon_dev_info *b_dev_info = balloon_page_device(page);
 113         unsigned long flags;
 114
 115         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
 116         list_del(&page->lru);
 117         b_dev_info->isolated_pages++;
 118         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 119
 120         return true;
 121 }
 122
 123 void balloon_page_putback(struct page *page)
 124 {
 125         struct balloon_dev_info *b_dev_info = balloon_page_device(page);
 126         unsigned long flags;
 127
 128         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
 129         list_add(&page->lru, &b_dev_info->pages);
 130         b_dev_info->isolated_pages--;
 131         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 132 }
 133
 134
 135 /* move_to_new_page() counterpart for a ballooned page */
 136 int balloon_page_migrate(struct address_space *mapping,
 137                 struct page *newpage, struct page *page,
 138                 enum migrate_mode mode)
 139 {
 140         struct balloon_dev_info *balloon = balloon_page_device(page);
 141
 142         VM_BUG_ON_PAGE(!PageLocked(page), page);
 143         VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
 144
 145         return balloon->migratepage(balloon, newpage, page, mode);
 146 }
 147
 148 const struct address_space_operations balloon_aops = {
 149         .migratepage = balloon_page_migrate,
 150         .isolate_page = balloon_page_isolate,
 151         .putback_page = balloon_page_putback,
 152 };
 153 EXPORT_SYMBOL_GPL(balloon_aops);
 154
 155 #endif /* CONFIG_BALLOON_COMPACTION */