Merge tag 'dlm-3.9' of git://git.kernel.org/pub/scm/linux/kernel/git/teigland/linux-dlm
[platform/adaptation/renesas_rcar/renesas_kernel.git] / mm / page_isolation.c
1 /*
2  * linux/mm/page_isolation.c
3  */
4
5 #include <linux/mm.h>
6 #include <linux/page-isolation.h>
7 #include <linux/pageblock-flags.h>
8 #include <linux/memory.h>
9 #include "internal.h"
10
11 int set_migratetype_isolate(struct page *page, bool skip_hwpoisoned_pages)
12 {
13         struct zone *zone;
14         unsigned long flags, pfn;
15         struct memory_isolate_notify arg;
16         int notifier_ret;
17         int ret = -EBUSY;
18
19         zone = page_zone(page);
20
21         spin_lock_irqsave(&zone->lock, flags);
22
23         pfn = page_to_pfn(page);
24         arg.start_pfn = pfn;
25         arg.nr_pages = pageblock_nr_pages;
26         arg.pages_found = 0;
27
28         /*
29          * It may be possible to isolate a pageblock even if the
30          * migratetype is not MIGRATE_MOVABLE. The memory isolation
31          * notifier chain is used by balloon drivers to return the
32          * number of pages in a range that are held by the balloon
33          * driver to shrink memory. If all the pages are accounted for
34          * by balloons, are free, or on the LRU, isolation can continue.
35          * Later, for example, when memory hotplug notifier runs, these
36          * pages reported as "can be isolated" should be isolated(freed)
37          * by the balloon driver through the memory notifier chain.
38          */
39         notifier_ret = memory_isolate_notify(MEM_ISOLATE_COUNT, &arg);
40         notifier_ret = notifier_to_errno(notifier_ret);
41         if (notifier_ret)
42                 goto out;
43         /*
44          * FIXME: Now, memory hotplug doesn't call shrink_slab() by itself.
45          * We just check MOVABLE pages.
46          */
47         if (!has_unmovable_pages(zone, page, arg.pages_found,
48                                  skip_hwpoisoned_pages))
49                 ret = 0;
50
51         /*
52          * immobile means "not-on-lru" paes. If immobile is larger than
53          * removable-by-driver pages reported by notifier, we'll fail.
54          */
55
56 out:
57         if (!ret) {
58                 unsigned long nr_pages;
59                 int migratetype = get_pageblock_migratetype(page);
60
61                 set_pageblock_migratetype(page, MIGRATE_ISOLATE);
62                 nr_pages = move_freepages_block(zone, page, MIGRATE_ISOLATE);
63
64                 __mod_zone_freepage_state(zone, -nr_pages, migratetype);
65         }
66
67         spin_unlock_irqrestore(&zone->lock, flags);
68         if (!ret)
69                 drain_all_pages();
70         return ret;
71 }
72
73 void unset_migratetype_isolate(struct page *page, unsigned migratetype)
74 {
75         struct zone *zone;
76         unsigned long flags, nr_pages;
77
78         zone = page_zone(page);
79         spin_lock_irqsave(&zone->lock, flags);
80         if (get_pageblock_migratetype(page) != MIGRATE_ISOLATE)
81                 goto out;
82         nr_pages = move_freepages_block(zone, page, migratetype);
83         __mod_zone_freepage_state(zone, nr_pages, migratetype);
84         set_pageblock_migratetype(page, migratetype);
85 out:
86         spin_unlock_irqrestore(&zone->lock, flags);
87 }
88
89 static inline struct page *
90 __first_valid_page(unsigned long pfn, unsigned long nr_pages)
91 {
92         int i;
93         for (i = 0; i < nr_pages; i++)
94                 if (pfn_valid_within(pfn + i))
95                         break;
96         if (unlikely(i == nr_pages))
97                 return NULL;
98         return pfn_to_page(pfn + i);
99 }
100
101 /*
102  * start_isolate_page_range() -- make page-allocation-type of range of pages
103  * to be MIGRATE_ISOLATE.
104  * @start_pfn: The lower PFN of the range to be isolated.
105  * @end_pfn: The upper PFN of the range to be isolated.
106  * @migratetype: migrate type to set in error recovery.
107  *
108  * Making page-allocation-type to be MIGRATE_ISOLATE means free pages in
109  * the range will never be allocated. Any free pages and pages freed in the
110  * future will not be allocated again.
111  *
112  * start_pfn/end_pfn must be aligned to pageblock_order.
113  * Returns 0 on success and -EBUSY if any part of range cannot be isolated.
114  */
115 int start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
116                              unsigned migratetype, bool skip_hwpoisoned_pages)
117 {
118         unsigned long pfn;
119         unsigned long undo_pfn;
120         struct page *page;
121
122         BUG_ON((start_pfn) & (pageblock_nr_pages - 1));
123         BUG_ON((end_pfn) & (pageblock_nr_pages - 1));
124
125         for (pfn = start_pfn;
126              pfn < end_pfn;
127              pfn += pageblock_nr_pages) {
128                 page = __first_valid_page(pfn, pageblock_nr_pages);
129                 if (page &&
130                     set_migratetype_isolate(page, skip_hwpoisoned_pages)) {
131                         undo_pfn = pfn;
132                         goto undo;
133                 }
134         }
135         return 0;
136 undo:
137         for (pfn = start_pfn;
138              pfn < undo_pfn;
139              pfn += pageblock_nr_pages)
140                 unset_migratetype_isolate(pfn_to_page(pfn), migratetype);
141
142         return -EBUSY;
143 }
144
145 /*
146  * Make isolated pages available again.
147  */
148 int undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
149                             unsigned migratetype)
150 {
151         unsigned long pfn;
152         struct page *page;
153         BUG_ON((start_pfn) & (pageblock_nr_pages - 1));
154         BUG_ON((end_pfn) & (pageblock_nr_pages - 1));
155         for (pfn = start_pfn;
156              pfn < end_pfn;
157              pfn += pageblock_nr_pages) {
158                 page = __first_valid_page(pfn, pageblock_nr_pages);
159                 if (!page || get_pageblock_migratetype(page) != MIGRATE_ISOLATE)
160                         continue;
161                 unset_migratetype_isolate(page, migratetype);
162         }
163         return 0;
164 }
165 /*
166  * Test all pages in the range is free(means isolated) or not.
167  * all pages in [start_pfn...end_pfn) must be in the same zone.
168  * zone->lock must be held before call this.
169  *
170  * Returns 1 if all pages in the range are isolated.
171  */
172 static int
173 __test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn,
174                                   bool skip_hwpoisoned_pages)
175 {
176         struct page *page;
177
178         while (pfn < end_pfn) {
179                 if (!pfn_valid_within(pfn)) {
180                         pfn++;
181                         continue;
182                 }
183                 page = pfn_to_page(pfn);
184                 if (PageBuddy(page)) {
185                         /*
186                          * If race between isolatation and allocation happens,
187                          * some free pages could be in MIGRATE_MOVABLE list
188                          * although pageblock's migratation type of the page
189                          * is MIGRATE_ISOLATE. Catch it and move the page into
190                          * MIGRATE_ISOLATE list.
191                          */
192                         if (get_freepage_migratetype(page) != MIGRATE_ISOLATE) {
193                                 struct page *end_page;
194
195                                 end_page = page + (1 << page_order(page)) - 1;
196                                 move_freepages(page_zone(page), page, end_page,
197                                                 MIGRATE_ISOLATE);
198                         }
199                         pfn += 1 << page_order(page);
200                 }
201                 else if (page_count(page) == 0 &&
202                         get_freepage_migratetype(page) == MIGRATE_ISOLATE)
203                         pfn += 1;
204                 else if (skip_hwpoisoned_pages && PageHWPoison(page)) {
205                         /*
206                          * The HWPoisoned page may be not in buddy
207                          * system, and page_count() is not 0.
208                          */
209                         pfn++;
210                         continue;
211                 }
212                 else
213                         break;
214         }
215         if (pfn < end_pfn)
216                 return 0;
217         return 1;
218 }
219
220 int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
221                         bool skip_hwpoisoned_pages)
222 {
223         unsigned long pfn, flags;
224         struct page *page;
225         struct zone *zone;
226         int ret;
227
228         /*
229          * Note: pageblock_nr_page != MAX_ORDER. Then, chunks of free page
230          * is not aligned to pageblock_nr_pages.
231          * Then we just check pagetype fist.
232          */
233         for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) {
234                 page = __first_valid_page(pfn, pageblock_nr_pages);
235                 if (page && get_pageblock_migratetype(page) != MIGRATE_ISOLATE)
236                         break;
237         }
238         page = __first_valid_page(start_pfn, end_pfn - start_pfn);
239         if ((pfn < end_pfn) || !page)
240                 return -EBUSY;
241         /* Check all pages are free or Marked as ISOLATED */
242         zone = page_zone(page);
243         spin_lock_irqsave(&zone->lock, flags);
244         ret = __test_page_isolated_in_pageblock(start_pfn, end_pfn,
245                                                 skip_hwpoisoned_pages);
246         spin_unlock_irqrestore(&zone->lock, flags);
247         return ret ? 0 : -EBUSY;
248 }
249
250 struct page *alloc_migrate_target(struct page *page, unsigned long private,
251                                   int **resultp)
252 {
253         gfp_t gfp_mask = GFP_USER | __GFP_MOVABLE;
254
255         if (PageHighMem(page))
256                 gfp_mask |= __GFP_HIGHMEM;
257
258         return alloc_page(gfp_mask);
259 }