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