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_devinfo_alloc - allocates a balloon device information descriptor. 15 * @balloon_dev_descriptor: pointer to reference the balloon device which 16 * this struct balloon_dev_info will be servicing. 17 * 18 * Driver must call it to properly allocate and initialize an instance of 19 * struct balloon_dev_info which will be used to reference a balloon device 20 * as well as to keep track of the balloon device page list. 21 */ 22 struct balloon_dev_info *balloon_devinfo_alloc(void *balloon_dev_descriptor) 23 { 24 struct balloon_dev_info *b_dev_info; 25 b_dev_info = kmalloc(sizeof(*b_dev_info), GFP_KERNEL); 26 if (!b_dev_info) 27 return ERR_PTR(-ENOMEM); 28 29 b_dev_info->balloon_device = balloon_dev_descriptor; 30 b_dev_info->mapping = NULL; 31 b_dev_info->isolated_pages = 0; 32 spin_lock_init(&b_dev_info->pages_lock); 33 INIT_LIST_HEAD(&b_dev_info->pages); 34 35 return b_dev_info; 36 } 37 EXPORT_SYMBOL_GPL(balloon_devinfo_alloc); 38 39 /* 40 * balloon_page_enqueue - allocates a new page and inserts it into the balloon 41 * page list. 42 * @b_dev_info: balloon device decriptor where we will insert a new page to 43 * 44 * Driver must call it to properly allocate a new enlisted balloon page 45 * before definetively removing it from the guest system. 46 * This function returns the page address for the recently enqueued page or 47 * NULL in the case we fail to allocate a new page this turn. 48 */ 49 struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info) 50 { 51 unsigned long flags; 52 struct page *page = alloc_page(balloon_mapping_gfp_mask() | 53 __GFP_NOMEMALLOC | __GFP_NORETRY); 54 if (!page) 55 return NULL; 56 57 /* 58 * Block others from accessing the 'page' when we get around to 59 * establishing additional references. We should be the only one 60 * holding a reference to the 'page' at this point. 61 */ 62 BUG_ON(!trylock_page(page)); 63 spin_lock_irqsave(&b_dev_info->pages_lock, flags); 64 balloon_page_insert(page, b_dev_info->mapping, &b_dev_info->pages); 65 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); 66 unlock_page(page); 67 return page; 68 } 69 EXPORT_SYMBOL_GPL(balloon_page_enqueue); 70 71 /* 72 * balloon_page_dequeue - removes a page from balloon's page list and returns 73 * the its address to allow the driver release the page. 74 * @b_dev_info: balloon device decriptor where we will grab a page from. 75 * 76 * Driver must call it to properly de-allocate a previous enlisted balloon page 77 * before definetively releasing it back to the guest system. 78 * This function returns the page address for the recently dequeued page or 79 * NULL in the case we find balloon's page list temporarily empty due to 80 * compaction isolated pages. 81 */ 82 struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info) 83 { 84 struct page *page, *tmp; 85 unsigned long flags; 86 bool dequeued_page; 87 88 dequeued_page = false; 89 list_for_each_entry_safe(page, tmp, &b_dev_info->pages, lru) { 90 /* 91 * Block others from accessing the 'page' while we get around 92 * establishing additional references and preparing the 'page' 93 * to be released by the balloon driver. 94 */ 95 if (trylock_page(page)) { 96 spin_lock_irqsave(&b_dev_info->pages_lock, flags); 97 /* 98 * Raise the page refcount here to prevent any wrong 99 * attempt to isolate this page, in case of coliding 100 * with balloon_page_isolate() just after we release 101 * the page lock. 102 * 103 * balloon_page_free() will take care of dropping 104 * this extra refcount later. 105 */ 106 get_page(page); 107 balloon_page_delete(page); 108 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); 109 unlock_page(page); 110 dequeued_page = true; 111 break; 112 } 113 } 114 115 if (!dequeued_page) { 116 /* 117 * If we are unable to dequeue a balloon page because the page 118 * list is empty and there is no isolated pages, then something 119 * went out of track and some balloon pages are lost. 120 * BUG() here, otherwise the balloon driver may get stuck into 121 * an infinite loop while attempting to release all its pages. 122 */ 123 spin_lock_irqsave(&b_dev_info->pages_lock, flags); 124 if (unlikely(list_empty(&b_dev_info->pages) && 125 !b_dev_info->isolated_pages)) 126 BUG(); 127 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); 128 page = NULL; 129 } 130 return page; 131 } 132 EXPORT_SYMBOL_GPL(balloon_page_dequeue); 133 134 #ifdef CONFIG_BALLOON_COMPACTION 135 /* 136 * balloon_mapping_alloc - allocates a special ->mapping for ballooned pages. 137 * @b_dev_info: holds the balloon device information descriptor. 138 * @a_ops: balloon_mapping address_space_operations descriptor. 139 * 140 * Driver must call it to properly allocate and initialize an instance of 141 * struct address_space which will be used as the special page->mapping for 142 * balloon device enlisted page instances. 143 */ 144 struct address_space *balloon_mapping_alloc(struct balloon_dev_info *b_dev_info, 145 const struct address_space_operations *a_ops) 146 { 147 struct address_space *mapping; 148 149 mapping = kmalloc(sizeof(*mapping), GFP_KERNEL); 150 if (!mapping) 151 return ERR_PTR(-ENOMEM); 152 153 /* 154 * Give a clean 'zeroed' status to all elements of this special 155 * balloon page->mapping struct address_space instance. 156 */ 157 address_space_init_once(mapping); 158 159 /* 160 * Set mapping->flags appropriately, to allow balloon pages 161 * ->mapping identification. 162 */ 163 mapping_set_balloon(mapping); 164 mapping_set_gfp_mask(mapping, balloon_mapping_gfp_mask()); 165 166 /* balloon's page->mapping->a_ops callback descriptor */ 167 mapping->a_ops = a_ops; 168 169 /* 170 * Establish a pointer reference back to the balloon device descriptor 171 * this particular page->mapping will be servicing. 172 * This is used by compaction / migration procedures to identify and 173 * access the balloon device pageset while isolating / migrating pages. 174 * 175 * As some balloon drivers can register multiple balloon devices 176 * for a single guest, this also helps compaction / migration to 177 * properly deal with multiple balloon pagesets, when required. 178 */ 179 mapping->private_data = b_dev_info; 180 b_dev_info->mapping = mapping; 181 182 return mapping; 183 } 184 EXPORT_SYMBOL_GPL(balloon_mapping_alloc); 185 186 static inline void __isolate_balloon_page(struct page *page) 187 { 188 struct balloon_dev_info *b_dev_info = page->mapping->private_data; 189 unsigned long flags; 190 spin_lock_irqsave(&b_dev_info->pages_lock, flags); 191 list_del(&page->lru); 192 b_dev_info->isolated_pages++; 193 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); 194 } 195 196 static inline void __putback_balloon_page(struct page *page) 197 { 198 struct balloon_dev_info *b_dev_info = page->mapping->private_data; 199 unsigned long flags; 200 spin_lock_irqsave(&b_dev_info->pages_lock, flags); 201 list_add(&page->lru, &b_dev_info->pages); 202 b_dev_info->isolated_pages--; 203 spin_unlock_irqrestore(&b_dev_info->pages_lock, flags); 204 } 205 206 static inline int __migrate_balloon_page(struct address_space *mapping, 207 struct page *newpage, struct page *page, enum migrate_mode mode) 208 { 209 return page->mapping->a_ops->migratepage(mapping, newpage, page, mode); 210 } 211 212 /* __isolate_lru_page() counterpart for a ballooned page */ 213 bool balloon_page_isolate(struct page *page) 214 { 215 /* 216 * Avoid burning cycles with pages that are yet under __free_pages(), 217 * or just got freed under us. 218 * 219 * In case we 'win' a race for a balloon page being freed under us and 220 * raise its refcount preventing __free_pages() from doing its job 221 * the put_page() at the end of this block will take care of 222 * release this page, thus avoiding a nasty leakage. 223 */ 224 if (likely(get_page_unless_zero(page))) { 225 /* 226 * As balloon pages are not isolated from LRU lists, concurrent 227 * compaction threads can race against page migration functions 228 * as well as race against the balloon driver releasing a page. 229 * 230 * In order to avoid having an already isolated balloon page 231 * being (wrongly) re-isolated while it is under migration, 232 * or to avoid attempting to isolate pages being released by 233 * the balloon driver, lets be sure we have the page lock 234 * before proceeding with the balloon page isolation steps. 235 */ 236 if (likely(trylock_page(page))) { 237 /* 238 * A ballooned page, by default, has just one refcount. 239 * Prevent concurrent compaction threads from isolating 240 * an already isolated balloon page by refcount check. 241 */ 242 if (__is_movable_balloon_page(page) && 243 page_count(page) == 2) { 244 __isolate_balloon_page(page); 245 unlock_page(page); 246 return true; 247 } 248 unlock_page(page); 249 } 250 put_page(page); 251 } 252 return false; 253 } 254 255 /* putback_lru_page() counterpart for a ballooned page */ 256 void balloon_page_putback(struct page *page) 257 { 258 /* 259 * 'lock_page()' stabilizes the page and prevents races against 260 * concurrent isolation threads attempting to re-isolate it. 261 */ 262 lock_page(page); 263 264 if (__is_movable_balloon_page(page)) { 265 __putback_balloon_page(page); 266 /* drop the extra ref count taken for page isolation */ 267 put_page(page); 268 } else { 269 WARN_ON(1); 270 dump_page(page); 271 } 272 unlock_page(page); 273 } 274 275 /* move_to_new_page() counterpart for a ballooned page */ 276 int balloon_page_migrate(struct page *newpage, 277 struct page *page, enum migrate_mode mode) 278 { 279 struct address_space *mapping; 280 int rc = -EAGAIN; 281 282 /* 283 * Block others from accessing the 'newpage' when we get around to 284 * establishing additional references. We should be the only one 285 * holding a reference to the 'newpage' at this point. 286 */ 287 BUG_ON(!trylock_page(newpage)); 288 289 if (WARN_ON(!__is_movable_balloon_page(page))) { 290 dump_page(page); 291 unlock_page(newpage); 292 return rc; 293 } 294 295 mapping = page->mapping; 296 if (mapping) 297 rc = __migrate_balloon_page(mapping, newpage, page, mode); 298 299 unlock_page(newpage); 300 return rc; 301 } 302 #endif /* CONFIG_BALLOON_COMPACTION */ 303