~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/mm/balloon_compaction.c

Version: ~ [ linux-5.11-rc3 ] ~ [ linux-5.10.7 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.89 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.167 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.215 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.251 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.251 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp