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