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