Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'akpm' (fixes from Andrew Morton)
Merge misc fixes from Andrew Morton:
"15 fixes"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
MAINTAINERS: add IIO include files
kernel/panic.c: update comments for print_tainted
mem-hotplug: reset node present pages when hot-adding a new pgdat
mem-hotplug: reset node managed pages when hot-adding a new pgdat
mm/debug-pagealloc: correct freepage accounting and order resetting
fanotify: fix notification of groups with inode & mount marks
mm, compaction: prevent infinite loop in compact_zone
mm: alloc_contig_range: demote pages busy message from warn to info
mm/slab: fix unalignment problem on Malta with EVA due to slab merge
mm/page_alloc: restrict max order of merging on isolated pageblock
mm/page_alloc: move freepage counting logic to __free_one_page()
mm/page_alloc: add freepage on isolate pageblock to correct buddy list
mm/page_alloc: fix incorrect isolation behavior by rechecking migratetype
mm/compaction: skip the range until proper target pageblock is met
zram: avoid kunmap_atomic() of a NULL pointer
+240
-76
+1
MAINTAINERS
+1
MAINTAINERS
+2
-1
drivers/block/zram/zram_drv.c
+2
-1
drivers/block/zram/zram_drv.c
···
560
560
}
561
561
562
562
if (page_zero_filled(uncmem)) {
563
-
kunmap_atomic(user_mem);
563
+
if (user_mem)
564
+
kunmap_atomic(user_mem);
564
565
/* Free memory associated with this sector now. */
565
566
bit_spin_lock(ZRAM_ACCESS, &meta->table[index].value);
566
567
zram_free_page(zram, index);
+21
-15
fs/notify/fsnotify.c
+21
-15
fs/notify/fsnotify.c
···
229
229
&fsnotify_mark_srcu);
230
230
}
231
231
232
+
/*
233
+
* We need to merge inode & vfsmount mark lists so that inode mark
234
+
* ignore masks are properly reflected for mount mark notifications.
235
+
* That's why this traversal is so complicated...
236
+
*/
232
237
while (inode_node || vfsmount_node) {
233
-
inode_group = vfsmount_group = NULL;
238
+
inode_group = NULL;
239
+
inode_mark = NULL;
240
+
vfsmount_group = NULL;
241
+
vfsmount_mark = NULL;
234
242
235
243
if (inode_node) {
236
244
inode_mark = hlist_entry(srcu_dereference(inode_node, &fsnotify_mark_srcu),
···
252
244
vfsmount_group = vfsmount_mark->group;
253
245
}
254
246
255
-
if (inode_group > vfsmount_group) {
256
-
/* handle inode */
257
-
ret = send_to_group(to_tell, inode_mark, NULL, mask,
258
-
data, data_is, cookie, file_name);
259
-
/* we didn't use the vfsmount_mark */
260
-
vfsmount_group = NULL;
261
-
} else if (vfsmount_group > inode_group) {
262
-
ret = send_to_group(to_tell, NULL, vfsmount_mark, mask,
263
-
data, data_is, cookie, file_name);
264
-
inode_group = NULL;
265
-
} else {
266
-
ret = send_to_group(to_tell, inode_mark, vfsmount_mark,
267
-
mask, data, data_is, cookie,
268
-
file_name);
247
+
if (inode_group && vfsmount_group) {
248
+
int cmp = fsnotify_compare_groups(inode_group,
249
+
vfsmount_group);
250
+
if (cmp > 0) {
251
+
inode_group = NULL;
252
+
inode_mark = NULL;
253
+
} else if (cmp < 0) {
254
+
vfsmount_group = NULL;
255
+
vfsmount_mark = NULL;
256
+
}
269
257
}
258
+
ret = send_to_group(to_tell, inode_mark, vfsmount_mark, mask,
259
+
data, data_is, cookie, file_name);
270
260
271
261
if (ret && (mask & ALL_FSNOTIFY_PERM_EVENTS))
272
262
goto out;
+4
fs/notify/fsnotify.h
+4
fs/notify/fsnotify.h
···
12
12
/* protects reads of inode and vfsmount marks list */
13
13
extern struct srcu_struct fsnotify_mark_srcu;
14
14
15
+
/* compare two groups for sorting of marks lists */
16
+
extern int fsnotify_compare_groups(struct fsnotify_group *a,
17
+
struct fsnotify_group *b);
18
+
15
19
extern void fsnotify_set_inode_mark_mask_locked(struct fsnotify_mark *fsn_mark,
16
20
__u32 mask);
17
21
/* add a mark to an inode */
+3
-5
fs/notify/inode_mark.c
+3
-5
fs/notify/inode_mark.c
···
194
194
{
195
195
struct fsnotify_mark *lmark, *last = NULL;
196
196
int ret = 0;
197
+
int cmp;
197
198
198
199
mark->flags |= FSNOTIFY_MARK_FLAG_INODE;
199
200
···
220
219
goto out;
221
220
}
222
221
223
-
if (mark->group->priority < lmark->group->priority)
224
-
continue;
225
-
226
-
if ((mark->group->priority == lmark->group->priority) &&
227
-
(mark->group < lmark->group))
222
+
cmp = fsnotify_compare_groups(lmark->group, mark->group);
223
+
if (cmp < 0)
228
224
continue;
229
225
230
226
hlist_add_before_rcu(&mark->i.i_list, &lmark->i.i_list);
+36
fs/notify/mark.c
+36
fs/notify/mark.c
···
210
210
}
211
211
212
212
/*
213
+
* Sorting function for lists of fsnotify marks.
214
+
*
215
+
* Fanotify supports different notification classes (reflected as priority of
216
+
* notification group). Events shall be passed to notification groups in
217
+
* decreasing priority order. To achieve this marks in notification lists for
218
+
* inodes and vfsmounts are sorted so that priorities of corresponding groups
219
+
* are descending.
220
+
*
221
+
* Furthermore correct handling of the ignore mask requires processing inode
222
+
* and vfsmount marks of each group together. Using the group address as
223
+
* further sort criterion provides a unique sorting order and thus we can
224
+
* merge inode and vfsmount lists of marks in linear time and find groups
225
+
* present in both lists.
226
+
*
227
+
* A return value of 1 signifies that b has priority over a.
228
+
* A return value of 0 signifies that the two marks have to be handled together.
229
+
* A return value of -1 signifies that a has priority over b.
230
+
*/
231
+
int fsnotify_compare_groups(struct fsnotify_group *a, struct fsnotify_group *b)
232
+
{
233
+
if (a == b)
234
+
return 0;
235
+
if (!a)
236
+
return 1;
237
+
if (!b)
238
+
return -1;
239
+
if (a->priority < b->priority)
240
+
return 1;
241
+
if (a->priority > b->priority)
242
+
return -1;
243
+
if (a < b)
244
+
return 1;
245
+
return -1;
246
+
}
247
+
248
+
/*
213
249
* Attach an initialized mark to a given group and fs object.
214
250
* These marks may be used for the fsnotify backend to determine which
215
251
* event types should be delivered to which group.
+3
-5
fs/notify/vfsmount_mark.c
+3
-5
fs/notify/vfsmount_mark.c
···
153
153
struct mount *m = real_mount(mnt);
154
154
struct fsnotify_mark *lmark, *last = NULL;
155
155
int ret = 0;
156
+
int cmp;
156
157
157
158
mark->flags |= FSNOTIFY_MARK_FLAG_VFSMOUNT;
158
159
···
179
178
goto out;
180
179
}
181
180
182
-
if (mark->group->priority < lmark->group->priority)
183
-
continue;
184
-
185
-
if ((mark->group->priority == lmark->group->priority) &&
186
-
(mark->group < lmark->group))
181
+
cmp = fsnotify_compare_groups(lmark->group, mark->group);
182
+
if (cmp < 0)
187
183
continue;
188
184
189
185
hlist_add_before_rcu(&mark->m.m_list, &lmark->m.m_list);
+1
include/linux/bootmem.h
+1
include/linux/bootmem.h
···
46
46
extern unsigned long init_bootmem(unsigned long addr, unsigned long memend);
47
47
48
48
extern unsigned long free_all_bootmem(void);
49
+
extern void reset_node_managed_pages(pg_data_t *pgdat);
49
50
extern void reset_all_zones_managed_pages(void);
50
51
51
52
extern void free_bootmem_node(pg_data_t *pgdat,
+9
include/linux/mmzone.h
+9
include/linux/mmzone.h
···
431
431
*/
432
432
int nr_migrate_reserve_block;
433
433
434
+
#ifdef CONFIG_MEMORY_ISOLATION
435
+
/*
436
+
* Number of isolated pageblock. It is used to solve incorrect
437
+
* freepage counting problem due to racy retrieving migratetype
438
+
* of pageblock. Protected by zone->lock.
439
+
*/
440
+
unsigned long nr_isolate_pageblock;
441
+
#endif
442
+
434
443
#ifdef CONFIG_MEMORY_HOTPLUG
435
444
/* see spanned/present_pages for more description */
436
445
seqlock_t span_seqlock;
+8
include/linux/page-isolation.h
+8
include/linux/page-isolation.h
···
2
2
#define __LINUX_PAGEISOLATION_H
3
3
4
4
#ifdef CONFIG_MEMORY_ISOLATION
5
+
static inline bool has_isolate_pageblock(struct zone *zone)
6
+
{
7
+
return zone->nr_isolate_pageblock;
8
+
}
5
9
static inline bool is_migrate_isolate_page(struct page *page)
6
10
{
7
11
return get_pageblock_migratetype(page) == MIGRATE_ISOLATE;
···
15
11
return migratetype == MIGRATE_ISOLATE;
16
12
}
17
13
#else
14
+
static inline bool has_isolate_pageblock(struct zone *zone)
15
+
{
16
+
return false;
17
+
}
18
18
static inline bool is_migrate_isolate_page(struct page *page)
19
19
{
20
20
return false;
+1
kernel/panic.c
+1
kernel/panic.c
···
244
244
* 'I' - Working around severe firmware bug.
245
245
* 'O' - Out-of-tree module has been loaded.
246
246
* 'E' - Unsigned module has been loaded.
247
+
* 'L' - A soft lockup has previously occurred.
247
248
*
248
249
* The string is overwritten by the next call to print_tainted().
249
250
*/
+5
-4
mm/bootmem.c
+5
-4
mm/bootmem.c
···
243
243
244
244
static int reset_managed_pages_done __initdata;
245
245
246
-
static inline void __init reset_node_managed_pages(pg_data_t *pgdat)
246
+
void reset_node_managed_pages(pg_data_t *pgdat)
247
247
{
248
248
struct zone *z;
249
-
250
-
if (reset_managed_pages_done)
251
-
return;
252
249
253
250
for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
254
251
z->managed_pages = 0;
···
255
258
{
256
259
struct pglist_data *pgdat;
257
260
261
+
if (reset_managed_pages_done)
262
+
return;
263
+
258
264
for_each_online_pgdat(pgdat)
259
265
reset_node_managed_pages(pgdat);
266
+
260
267
reset_managed_pages_done = 1;
261
268
}
262
269
+16
-2
mm/compaction.c
+16
-2
mm/compaction.c
···
479
479
480
480
block_end_pfn = min(block_end_pfn, end_pfn);
481
481
482
+
/*
483
+
* pfn could pass the block_end_pfn if isolated freepage
484
+
* is more than pageblock order. In this case, we adjust
485
+
* scanning range to right one.
486
+
*/
487
+
if (pfn >= block_end_pfn) {
488
+
block_end_pfn = ALIGN(pfn + 1, pageblock_nr_pages);
489
+
block_end_pfn = min(block_end_pfn, end_pfn);
490
+
}
491
+
482
492
if (!pageblock_pfn_to_page(pfn, block_end_pfn, cc->zone))
483
493
break;
484
494
···
1039
1029
}
1040
1030
1041
1031
acct_isolated(zone, cc);
1042
-
/* Record where migration scanner will be restarted */
1043
-
cc->migrate_pfn = low_pfn;
1032
+
/*
1033
+
* Record where migration scanner will be restarted. If we end up in
1034
+
* the same pageblock as the free scanner, make the scanners fully
1035
+
* meet so that compact_finished() terminates compaction.
1036
+
*/
1037
+
cc->migrate_pfn = (end_pfn <= cc->free_pfn) ? low_pfn : cc->free_pfn;
1044
1038
1045
1039
return cc->nr_migratepages ? ISOLATE_SUCCESS : ISOLATE_NONE;
1046
1040
}
+25
mm/internal.h
+25
mm/internal.h
···
108
108
/*
109
109
* in mm/page_alloc.c
110
110
*/
111
+
112
+
/*
113
+
* Locate the struct page for both the matching buddy in our
114
+
* pair (buddy1) and the combined O(n+1) page they form (page).
115
+
*
116
+
* 1) Any buddy B1 will have an order O twin B2 which satisfies
117
+
* the following equation:
118
+
* B2 = B1 ^ (1 << O)
119
+
* For example, if the starting buddy (buddy2) is #8 its order
120
+
* 1 buddy is #10:
121
+
* B2 = 8 ^ (1 << 1) = 8 ^ 2 = 10
122
+
*
123
+
* 2) Any buddy B will have an order O+1 parent P which
124
+
* satisfies the following equation:
125
+
* P = B & ~(1 << O)
126
+
*
127
+
* Assumption: *_mem_map is contiguous at least up to MAX_ORDER
128
+
*/
129
+
static inline unsigned long
130
+
__find_buddy_index(unsigned long page_idx, unsigned int order)
131
+
{
132
+
return page_idx ^ (1 << order);
133
+
}
134
+
135
+
extern int __isolate_free_page(struct page *page, unsigned int order);
111
136
extern void __free_pages_bootmem(struct page *page, unsigned int order);
112
137
extern void prep_compound_page(struct page *page, unsigned long order);
113
138
#ifdef CONFIG_MEMORY_FAILURE
+26
mm/memory_hotplug.c
+26
mm/memory_hotplug.c
···
31
31
#include <linux/stop_machine.h>
32
32
#include <linux/hugetlb.h>
33
33
#include <linux/memblock.h>
34
+
#include <linux/bootmem.h>
34
35
35
36
#include <asm/tlbflush.h>
36
37
···
1067
1066
}
1068
1067
#endif /* CONFIG_MEMORY_HOTPLUG_SPARSE */
1069
1068
1069
+
static void reset_node_present_pages(pg_data_t *pgdat)
1070
+
{
1071
+
struct zone *z;
1072
+
1073
+
for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
1074
+
z->present_pages = 0;
1075
+
1076
+
pgdat->node_present_pages = 0;
1077
+
}
1078
+
1070
1079
/* we are OK calling __meminit stuff here - we have CONFIG_MEMORY_HOTPLUG */
1071
1080
static pg_data_t __ref *hotadd_new_pgdat(int nid, u64 start)
1072
1081
{
···
1106
1095
mutex_lock(&zonelists_mutex);
1107
1096
build_all_zonelists(pgdat, NULL);
1108
1097
mutex_unlock(&zonelists_mutex);
1098
+
1099
+
/*
1100
+
* zone->managed_pages is set to an approximate value in
1101
+
* free_area_init_core(), which will cause
1102
+
* /sys/device/system/node/nodeX/meminfo has wrong data.
1103
+
* So reset it to 0 before any memory is onlined.
1104
+
*/
1105
+
reset_node_managed_pages(pgdat);
1106
+
1107
+
/*
1108
+
* When memory is hot-added, all the memory is in offline state. So
1109
+
* clear all zones' present_pages because they will be updated in
1110
+
* online_pages() and offline_pages().
1111
+
*/
1112
+
reset_node_present_pages(pgdat);
1109
1113
1110
1114
return pgdat;
1111
1115
}
+5
-3
mm/nobootmem.c
+5
-3
mm/nobootmem.c
···
145
145
146
146
static int reset_managed_pages_done __initdata;
147
147
148
-
static inline void __init reset_node_managed_pages(pg_data_t *pgdat)
148
+
void reset_node_managed_pages(pg_data_t *pgdat)
149
149
{
150
150
struct zone *z;
151
151
152
-
if (reset_managed_pages_done)
153
-
return;
154
152
for (z = pgdat->node_zones; z < pgdat->node_zones + MAX_NR_ZONES; z++)
155
153
z->managed_pages = 0;
156
154
}
···
157
159
{
158
160
struct pglist_data *pgdat;
159
161
162
+
if (reset_managed_pages_done)
163
+
return;
164
+
160
165
for_each_online_pgdat(pgdat)
161
166
reset_node_managed_pages(pgdat);
167
+
162
168
reset_managed_pages_done = 1;
163
169
}
164
170
+29
-39
mm/page_alloc.c
+29
-39
mm/page_alloc.c
···
467
467
}
468
468
469
469
/*
470
-
* Locate the struct page for both the matching buddy in our
471
-
* pair (buddy1) and the combined O(n+1) page they form (page).
472
-
*
473
-
* 1) Any buddy B1 will have an order O twin B2 which satisfies
474
-
* the following equation:
475
-
* B2 = B1 ^ (1 << O)
476
-
* For example, if the starting buddy (buddy2) is #8 its order
477
-
* 1 buddy is #10:
478
-
* B2 = 8 ^ (1 << 1) = 8 ^ 2 = 10
479
-
*
480
-
* 2) Any buddy B will have an order O+1 parent P which
481
-
* satisfies the following equation:
482
-
* P = B & ~(1 << O)
483
-
*
484
-
* Assumption: *_mem_map is contiguous at least up to MAX_ORDER
485
-
*/
486
-
static inline unsigned long
487
-
__find_buddy_index(unsigned long page_idx, unsigned int order)
488
-
{
489
-
return page_idx ^ (1 << order);
490
-
}
491
-
492
-
/*
493
470
* This function checks whether a page is free && is the buddy
494
471
* we can do coalesce a page and its buddy if
495
472
* (a) the buddy is not in a hole &&
···
546
569
unsigned long combined_idx;
547
570
unsigned long uninitialized_var(buddy_idx);
548
571
struct page *buddy;
572
+
int max_order = MAX_ORDER;
549
573
550
574
VM_BUG_ON(!zone_is_initialized(zone));
551
575
···
555
577
return;
556
578
557
579
VM_BUG_ON(migratetype == -1);
580
+
if (is_migrate_isolate(migratetype)) {
581
+
/*
582
+
* We restrict max order of merging to prevent merge
583
+
* between freepages on isolate pageblock and normal
584
+
* pageblock. Without this, pageblock isolation
585
+
* could cause incorrect freepage accounting.
586
+
*/
587
+
max_order = min(MAX_ORDER, pageblock_order + 1);
588
+
} else {
589
+
__mod_zone_freepage_state(zone, 1 << order, migratetype);
590
+
}
558
591
559
-
page_idx = pfn & ((1 << MAX_ORDER) - 1);
592
+
page_idx = pfn & ((1 << max_order) - 1);
560
593
561
594
VM_BUG_ON_PAGE(page_idx & ((1 << order) - 1), page);
562
595
VM_BUG_ON_PAGE(bad_range(zone, page), page);
563
596
564
-
while (order < MAX_ORDER-1) {
597
+
while (order < max_order - 1) {
565
598
buddy_idx = __find_buddy_index(page_idx, order);
566
599
buddy = page + (buddy_idx - page_idx);
567
600
if (!page_is_buddy(page, buddy, order))
···
583
594
*/
584
595
if (page_is_guard(buddy)) {
585
596
clear_page_guard_flag(buddy);
586
-
set_page_private(page, 0);
587
-
__mod_zone_freepage_state(zone, 1 << order,
588
-
migratetype);
597
+
set_page_private(buddy, 0);
598
+
if (!is_migrate_isolate(migratetype)) {
599
+
__mod_zone_freepage_state(zone, 1 << order,
600
+
migratetype);
601
+
}
589
602
} else {
590
603
list_del(&buddy->lru);
591
604
zone->free_area[order].nr_free--;
···
706
715
/* must delete as __free_one_page list manipulates */
707
716
list_del(&page->lru);
708
717
mt = get_freepage_migratetype(page);
718
+
if (unlikely(has_isolate_pageblock(zone)))
719
+
mt = get_pageblock_migratetype(page);
720
+
709
721
/* MIGRATE_MOVABLE list may include MIGRATE_RESERVEs */
710
722
__free_one_page(page, page_to_pfn(page), zone, 0, mt);
711
723
trace_mm_page_pcpu_drain(page, 0, mt);
712
-
if (likely(!is_migrate_isolate_page(page))) {
713
-
__mod_zone_page_state(zone, NR_FREE_PAGES, 1);
714
-
if (is_migrate_cma(mt))
715
-
__mod_zone_page_state(zone, NR_FREE_CMA_PAGES, 1);
716
-
}
717
724
} while (--to_free && --batch_free && !list_empty(list));
718
725
}
719
726
spin_unlock(&zone->lock);
···
728
739
if (nr_scanned)
729
740
__mod_zone_page_state(zone, NR_PAGES_SCANNED, -nr_scanned);
730
741
742
+
if (unlikely(has_isolate_pageblock(zone) ||
743
+
is_migrate_isolate(migratetype))) {
744
+
migratetype = get_pfnblock_migratetype(page, pfn);
745
+
}
731
746
__free_one_page(page, pfn, zone, order, migratetype);
732
-
if (unlikely(!is_migrate_isolate(migratetype)))
733
-
__mod_zone_freepage_state(zone, 1 << order, migratetype);
734
747
spin_unlock(&zone->lock);
735
748
}
736
749
···
1475
1484
}
1476
1485
EXPORT_SYMBOL_GPL(split_page);
1477
1486
1478
-
static int __isolate_free_page(struct page *page, unsigned int order)
1487
+
int __isolate_free_page(struct page *page, unsigned int order)
1479
1488
{
1480
1489
unsigned long watermark;
1481
1490
struct zone *zone;
···
6399
6408
6400
6409
/* Make sure the range is really isolated. */
6401
6410
if (test_pages_isolated(outer_start, end, false)) {
6402
-
pr_warn("alloc_contig_range test_pages_isolated(%lx, %lx) failed\n",
6403
-
outer_start, end);
6411
+
pr_info("%s: [%lx, %lx) PFNs busy\n",
6412
+
__func__, outer_start, end);
6404
6413
ret = -EBUSY;
6405
6414
goto done;
6406
6415
}
6407
-
6408
6416
6409
6417
/* Grab isolated pages from freelists. */
6410
6418
outer_end = isolate_freepages_range(&cc, outer_start, end);
+41
-2
mm/page_isolation.c
+41
-2
mm/page_isolation.c
···
60
60
int migratetype = get_pageblock_migratetype(page);
61
61
62
62
set_pageblock_migratetype(page, MIGRATE_ISOLATE);
63
+
zone->nr_isolate_pageblock++;
63
64
nr_pages = move_freepages_block(zone, page, MIGRATE_ISOLATE);
64
65
65
66
__mod_zone_freepage_state(zone, -nr_pages, migratetype);
···
76
75
{
77
76
struct zone *zone;
78
77
unsigned long flags, nr_pages;
78
+
struct page *isolated_page = NULL;
79
+
unsigned int order;
80
+
unsigned long page_idx, buddy_idx;
81
+
struct page *buddy;
79
82
80
83
zone = page_zone(page);
81
84
spin_lock_irqsave(&zone->lock, flags);
82
85
if (get_pageblock_migratetype(page) != MIGRATE_ISOLATE)
83
86
goto out;
84
-
nr_pages = move_freepages_block(zone, page, migratetype);
85
-
__mod_zone_freepage_state(zone, nr_pages, migratetype);
87
+
88
+
/*
89
+
* Because freepage with more than pageblock_order on isolated
90
+
* pageblock is restricted to merge due to freepage counting problem,
91
+
* it is possible that there is free buddy page.
92
+
* move_freepages_block() doesn't care of merge so we need other
93
+
* approach in order to merge them. Isolation and free will make
94
+
* these pages to be merged.
95
+
*/
96
+
if (PageBuddy(page)) {
97
+
order = page_order(page);
98
+
if (order >= pageblock_order) {
99
+
page_idx = page_to_pfn(page) & ((1 << MAX_ORDER) - 1);
100
+
buddy_idx = __find_buddy_index(page_idx, order);
101
+
buddy = page + (buddy_idx - page_idx);
102
+
103
+
if (!is_migrate_isolate_page(buddy)) {
104
+
__isolate_free_page(page, order);
105
+
set_page_refcounted(page);
106
+
isolated_page = page;
107
+
}
108
+
}
109
+
}
110
+
111
+
/*
112
+
* If we isolate freepage with more than pageblock_order, there
113
+
* should be no freepage in the range, so we could avoid costly
114
+
* pageblock scanning for freepage moving.
115
+
*/
116
+
if (!isolated_page) {
117
+
nr_pages = move_freepages_block(zone, page, migratetype);
118
+
__mod_zone_freepage_state(zone, nr_pages, migratetype);
119
+
}
86
120
set_pageblock_migratetype(page, migratetype);
121
+
zone->nr_isolate_pageblock--;
87
122
out:
88
123
spin_unlock_irqrestore(&zone->lock, flags);
124
+
if (isolated_page)
125
+
__free_pages(isolated_page, order);
89
126
}
90
127
91
128
static inline struct page *