mm/balloon_compaction.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * mm/balloon_compaction.c
   4  *
   5  * Common interface for making balloon pages movable by compaction.
   6  *
   7  * Copyright (C) 2012, Red Hat, Inc.  Rafael Aquini <aquini@redhat.com>
   8  */
   9 #include <linux/mm.h>
  10 #include <linux/slab.h>
  11 #include <linux/export.h>
  12 #include <linux/balloon_compaction.h>
  13
  14 static void balloon_page_enqueue_one(struct balloon_dev_info *b_dev_info,
  15                                      struct page *page)
  16 {
  17         /*
  18          * Block others from accessing the 'page' when we get around to
  19          * establishing additional references. We should be the only one
  20          * holding a reference to the 'page' at this point. If we are not, then
  21          * memory corruption is possible and we should stop execution.
  22          */
  23         BUG_ON(!trylock_page(page));
  24         balloon_page_insert(b_dev_info, page);
  25         unlock_page(page);
  26         __count_vm_event(BALLOON_INFLATE);
  27 }
  28
  29 /**
  30  * balloon_page_list_enqueue() - inserts a list of pages into the balloon page
  31  *                               list.
  32  * @b_dev_info: balloon device descriptor where we will insert a new page to
  33  * @pages: pages to enqueue - allocated using balloon_page_alloc.
  34  *
  35  * Driver must call this function to properly enqueue balloon pages before
  36  * definitively removing them from the guest system.
  37  *
  38  * Return: number of pages that were enqueued.
  39  */
  40 size_t balloon_page_list_enqueue(struct balloon_dev_info *b_dev_info,
  41                                  struct list_head *pages)
  42 {
  43         struct page *page, *tmp;
  44         unsigned long flags;
  45         size_t n_pages = 0;
  46
  47         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
  48         list_for_each_entry_safe(page, tmp, pages, lru) {
  49                 list_del(&page->lru);
  50                 balloon_page_enqueue_one(b_dev_info, page);
  51                 n_pages++;
  52         }
  53         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
  54         return n_pages;
  55 }
  56 EXPORT_SYMBOL_GPL(balloon_page_list_enqueue);
  57
  58 /**
  59  * balloon_page_list_dequeue() - removes pages from balloon's page list and
  60  *                               returns a list of the pages.
  61  * @b_dev_info: balloon device decriptor where we will grab a page from.
  62  * @pages: pointer to the list of pages that would be returned to the caller.
  63  * @n_req_pages: number of requested pages.
  64  *
  65  * Driver must call this function to properly de-allocate a previous enlisted
  66  * balloon pages before definitively releasing it back to the guest system.
  67  * This function tries to remove @n_req_pages from the ballooned pages and
  68  * return them to the caller in the @pages list.
  69  *
  70  * Note that this function may fail to dequeue some pages even if the balloon
  71  * isn't empty - since the page list can be temporarily empty due to compaction
  72  * of isolated pages.
  73  *
  74  * Return: number of pages that were added to the @pages list.
  75  */
  76 size_t balloon_page_list_dequeue(struct balloon_dev_info *b_dev_info,
  77                                  struct list_head *pages, size_t n_req_pages)
  78 {
  79         struct page *page, *tmp;
  80         unsigned long flags;
  81         size_t n_pages = 0;
  82
  83         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
  84         list_for_each_entry_safe(page, tmp, &b_dev_info->pages, lru) {
  85                 if (n_pages == n_req_pages)
  86                         break;
  87
  88                 /*
  89                  * Block others from accessing the 'page' while we get around to
  90                  * establishing additional references and preparing the 'page'
  91                  * to be released by the balloon driver.
  92                  */
  93                 if (!trylock_page(page))
  94                         continue;
  95
  96                 if (IS_ENABLED(CONFIG_BALLOON_COMPACTION) &&
  97                     PageIsolated(page)) {
  98                         /* raced with isolation */
  99                         unlock_page(page);
 100                         continue;
 101                 }
 102                 balloon_page_delete(page);
 103                 __count_vm_event(BALLOON_DEFLATE);
 104                 list_add(&page->lru, pages);
 105                 unlock_page(page);
 106                 n_pages++;
 107         }
 108         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 109
 110         return n_pages;
 111 }
 112 EXPORT_SYMBOL_GPL(balloon_page_list_dequeue);
 113
 114 /*
 115  * balloon_page_alloc - allocates a new page for insertion into the balloon
 116  *                      page list.
 117  *
 118  * Driver must call this function to properly allocate a new balloon page.
 119  * Driver must call balloon_page_enqueue before definitively removing the page
 120  * from the guest system.
 121  *
 122  * Return: struct page for the allocated page or NULL on allocation failure.
 123  */
 124 struct page *balloon_page_alloc(void)
 125 {
 126         struct page *page = alloc_page(balloon_mapping_gfp_mask() |
 127                                        __GFP_NOMEMALLOC | __GFP_NORETRY);
 128         return page;
 129 }
 130 EXPORT_SYMBOL_GPL(balloon_page_alloc);
 131
 132 /*
 133  * balloon_page_enqueue - inserts a new page into the balloon page list.
 134  *
 135  * @b_dev_info: balloon device descriptor where we will insert a new page
 136  * @page: new page to enqueue - allocated using balloon_page_alloc.
 137  *
 138  * Drivers must call this function to properly enqueue a new allocated balloon
 139  * page before definitively removing the page from the guest system.
 140  *
 141  * Drivers must not call balloon_page_enqueue on pages that have been pushed to
 142  * a list with balloon_page_push before removing them with balloon_page_pop. To
 143  * enqueue a list of pages, use balloon_page_list_enqueue instead.
 144  */
 145 void balloon_page_enqueue(struct balloon_dev_info *b_dev_info,
 146                           struct page *page)
 147 {
 148         unsigned long flags;
 149
 150         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
 151         balloon_page_enqueue_one(b_dev_info, page);
 152         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 153 }
 154 EXPORT_SYMBOL_GPL(balloon_page_enqueue);
 155
 156 /*
 157  * balloon_page_dequeue - removes a page from balloon's page list and returns
 158  *                        its address to allow the driver to release the page.
 159  * @b_dev_info: balloon device decriptor where we will grab a page from.
 160  *
 161  * Driver must call this function to properly dequeue a previously enqueued page
 162  * before definitively releasing it back to the guest system.
 163  *
 164  * Caller must perform its own accounting to ensure that this
 165  * function is called only if some pages are actually enqueued.
 166  *
 167  * Note that this function may fail to dequeue some pages even if there are
 168  * some enqueued pages - since the page list can be temporarily empty due to
 169  * the compaction of isolated pages.
 170  *
 171  * TODO: remove the caller accounting requirements, and allow caller to wait
 172  * until all pages can be dequeued.
 173  *
 174  * Return: struct page for the dequeued page, or NULL if no page was dequeued.
 175  */
 176 struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info)
 177 {
 178         unsigned long flags;
 179         LIST_HEAD(pages);
 180         int n_pages;
 181
 182         n_pages = balloon_page_list_dequeue(b_dev_info, &pages, 1);
 183
 184         if (n_pages != 1) {
 185                 /*
 186                  * If we are unable to dequeue a balloon page because the page
 187                  * list is empty and there are no isolated pages, then something
 188                  * went out of track and some balloon pages are lost.
 189                  * BUG() here, otherwise the balloon driver may get stuck in
 190                  * an infinite loop while attempting to release all its pages.
 191                  */
 192                 spin_lock_irqsave(&b_dev_info->pages_lock, flags);
 193                 if (unlikely(list_empty(&b_dev_info->pages) &&
 194                              !b_dev_info->isolated_pages))
 195                         BUG();
 196                 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 197                 return NULL;
 198         }
 199         return list_first_entry(&pages, struct page, lru);
 200 }
 201 EXPORT_SYMBOL_GPL(balloon_page_dequeue);
 202
 203 #ifdef CONFIG_BALLOON_COMPACTION
 204
 205 bool balloon_page_isolate(struct page *page, isolate_mode_t mode)
 206
 207 {
 208         struct balloon_dev_info *b_dev_info = balloon_page_device(page);
 209         unsigned long flags;
 210
 211         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
 212         list_del(&page->lru);
 213         b_dev_info->isolated_pages++;
 214         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 215
 216         return true;
 217 }
 218
 219 void balloon_page_putback(struct page *page)
 220 {
 221         struct balloon_dev_info *b_dev_info = balloon_page_device(page);
 222         unsigned long flags;
 223
 224         spin_lock_irqsave(&b_dev_info->pages_lock, flags);
 225         list_add(&page->lru, &b_dev_info->pages);
 226         b_dev_info->isolated_pages--;
 227         spin_unlock_irqrestore(&b_dev_info->pages_lock, flags);
 228 }
 229
 230
 231 /* move_to_new_page() counterpart for a ballooned page */
 232 int balloon_page_migrate(struct address_space *mapping,
 233                 struct page *newpage, struct page *page,
 234                 enum migrate_mode mode)
 235 {
 236         struct balloon_dev_info *balloon = balloon_page_device(page);
 237
 238         /*
 239          * We can not easily support the no copy case here so ignore it as it
 240          * is unlikely to be used with balloon pages. See include/linux/hmm.h
 241          * for a user of the MIGRATE_SYNC_NO_COPY mode.
 242          */
 243         if (mode == MIGRATE_SYNC_NO_COPY)
 244                 return -EINVAL;
 245
 246         VM_BUG_ON_PAGE(!PageLocked(page), page);
 247         VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
 248
 249         return balloon->migratepage(balloon, newpage, page, mode);
 250 }
 251
 252 const struct address_space_operations balloon_aops = {
 253         .migratepage = balloon_page_migrate,
 254         .isolate_page = balloon_page_isolate,
 255         .putback_page = balloon_page_putback,
 256 };
 257 EXPORT_SYMBOL_GPL(balloon_aops);
 258
 259 #endif /* CONFIG_BALLOON_COMPACTION */