Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'akpm' (patches from Andrew)
Merge misc fixes from Andrew Morton:
"9 fixes"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
mm/vmstat: fix overflow in mod_zone_page_state()
ocfs2/dlm: clear migration_pending when migration target goes down
mm/memory_hotplug.c: check for missing sections in test_pages_in_a_zone()
ocfs2: fix flock panic issue
m32r: add io*_rep helpers
m32r: fix build failure
arch/x86/xen/suspend.c: include xen/xen.h
mm: memcontrol: fix possible memcg leak due to interrupted reclaim
ocfs2: fix BUG when calculate new backup super
+102
-39
+1
arch/m32r/include/asm/Kbuild
+1
arch/m32r/include/asm/Kbuild
+9
-1
arch/m32r/include/asm/io.h
+9
-1
arch/m32r/include/asm/io.h
···
168
168
#define writew_relaxed writew
169
169
#define writel_relaxed writel
170
170
171
-
#define ioread8 read
171
+
#define ioread8 readb
172
172
#define ioread16 readw
173
173
#define ioread32 readl
174
174
#define iowrite8 writeb
175
175
#define iowrite16 writew
176
176
#define iowrite32 writel
177
+
178
+
#define ioread8_rep(p, dst, count) insb((unsigned long)(p), (dst), (count))
179
+
#define ioread16_rep(p, dst, count) insw((unsigned long)(p), (dst), (count))
180
+
#define ioread32_rep(p, dst, count) insl((unsigned long)(p), (dst), (count))
181
+
182
+
#define iowrite8_rep(p, src, count) outsb((unsigned long)(p), (src), (count))
183
+
#define iowrite16_rep(p, src, count) outsw((unsigned long)(p), (src), (count))
184
+
#define iowrite32_rep(p, src, count) outsl((unsigned long)(p), (src), (count))
177
185
178
186
#define ioread16be(addr) be16_to_cpu(readw(addr))
179
187
#define ioread32be(addr) be32_to_cpu(readl(addr))
+1
arch/x86/xen/suspend.c
+1
arch/x86/xen/suspend.c
+2
fs/ocfs2/dlm/dlmmaster.c
+2
fs/ocfs2/dlm/dlmmaster.c
+4
-1
fs/ocfs2/locks.c
+4
-1
fs/ocfs2/locks.c
+12
-3
fs/ocfs2/resize.c
+12
-3
fs/ocfs2/resize.c
···
54
54
static u16 ocfs2_calc_new_backup_super(struct inode *inode,
55
55
struct ocfs2_group_desc *gd,
56
56
u16 cl_cpg,
57
+
u16 old_bg_clusters,
57
58
int set)
58
59
{
59
60
int i;
60
61
u16 backups = 0;
61
-
u32 cluster;
62
+
u32 cluster, lgd_cluster;
62
63
u64 blkno, gd_blkno, lgd_blkno = le64_to_cpu(gd->bg_blkno);
63
64
64
65
for (i = 0; i < OCFS2_MAX_BACKUP_SUPERBLOCKS; i++) {
···
71
70
continue;
72
71
else if (gd_blkno > lgd_blkno)
73
72
break;
73
+
74
+
/* check if already done backup super */
75
+
lgd_cluster = ocfs2_blocks_to_clusters(inode->i_sb, lgd_blkno);
76
+
lgd_cluster += old_bg_clusters;
77
+
if (lgd_cluster >= cluster)
78
+
continue;
74
79
75
80
if (set)
76
81
ocfs2_set_bit(cluster % cl_cpg,
···
106
99
u16 chain, num_bits, backups = 0;
107
100
u16 cl_bpc = le16_to_cpu(cl->cl_bpc);
108
101
u16 cl_cpg = le16_to_cpu(cl->cl_cpg);
102
+
u16 old_bg_clusters;
109
103
110
104
trace_ocfs2_update_last_group_and_inode(new_clusters,
111
105
first_new_cluster);
···
120
112
121
113
group = (struct ocfs2_group_desc *)group_bh->b_data;
122
114
115
+
old_bg_clusters = le16_to_cpu(group->bg_bits) / cl_bpc;
123
116
/* update the group first. */
124
117
num_bits = new_clusters * cl_bpc;
125
118
le16_add_cpu(&group->bg_bits, num_bits);
···
134
125
OCFS2_FEATURE_COMPAT_BACKUP_SB)) {
135
126
backups = ocfs2_calc_new_backup_super(bm_inode,
136
127
group,
137
-
cl_cpg, 1);
128
+
cl_cpg, old_bg_clusters, 1);
138
129
le16_add_cpu(&group->bg_free_bits_count, -1 * backups);
139
130
}
140
131
···
172
163
if (ret < 0) {
173
164
ocfs2_calc_new_backup_super(bm_inode,
174
165
group,
175
-
cl_cpg, 0);
166
+
cl_cpg, old_bg_clusters, 0);
176
167
le16_add_cpu(&group->bg_free_bits_count, backups);
177
168
le16_add_cpu(&group->bg_bits, -1 * num_bits);
178
169
le16_add_cpu(&group->bg_free_bits_count, -1 * num_bits);
+3
-3
include/linux/vmstat.h
+3
-3
include/linux/vmstat.h
···
176
176
#define sub_zone_page_state(__z, __i, __d) mod_zone_page_state(__z, __i, -(__d))
177
177
178
178
#ifdef CONFIG_SMP
179
-
void __mod_zone_page_state(struct zone *, enum zone_stat_item item, int);
179
+
void __mod_zone_page_state(struct zone *, enum zone_stat_item item, long);
180
180
void __inc_zone_page_state(struct page *, enum zone_stat_item);
181
181
void __dec_zone_page_state(struct page *, enum zone_stat_item);
182
182
183
-
void mod_zone_page_state(struct zone *, enum zone_stat_item, int);
183
+
void mod_zone_page_state(struct zone *, enum zone_stat_item, long);
184
184
void inc_zone_page_state(struct page *, enum zone_stat_item);
185
185
void dec_zone_page_state(struct page *, enum zone_stat_item);
186
186
···
205
205
* The functions directly modify the zone and global counters.
206
206
*/
207
207
static inline void __mod_zone_page_state(struct zone *zone,
208
-
enum zone_stat_item item, int delta)
208
+
enum zone_stat_item item, long delta)
209
209
{
210
210
zone_page_state_add(delta, zone, item);
211
211
}
+46
-14
mm/memcontrol.c
+46
-14
mm/memcontrol.c
···
903
903
if (prev && reclaim->generation != iter->generation)
904
904
goto out_unlock;
905
905
906
-
do {
906
+
while (1) {
907
907
pos = READ_ONCE(iter->position);
908
+
if (!pos || css_tryget(&pos->css))
909
+
break;
908
910
/*
909
-
* A racing update may change the position and
910
-
* put the last reference, hence css_tryget(),
911
-
* or retry to see the updated position.
911
+
* css reference reached zero, so iter->position will
912
+
* be cleared by ->css_released. However, we should not
913
+
* rely on this happening soon, because ->css_released
914
+
* is called from a work queue, and by busy-waiting we
915
+
* might block it. So we clear iter->position right
916
+
* away.
912
917
*/
913
-
} while (pos && !css_tryget(&pos->css));
918
+
(void)cmpxchg(&iter->position, pos, NULL);
919
+
}
914
920
}
915
921
916
922
if (pos)
···
962
956
}
963
957
964
958
if (reclaim) {
965
-
if (cmpxchg(&iter->position, pos, memcg) == pos) {
966
-
if (memcg)
967
-
css_get(&memcg->css);
968
-
if (pos)
969
-
css_put(&pos->css);
970
-
}
971
-
972
959
/*
973
-
* pairs with css_tryget when dereferencing iter->position
974
-
* above.
960
+
* The position could have already been updated by a competing
961
+
* thread, so check that the value hasn't changed since we read
962
+
* it to avoid reclaiming from the same cgroup twice.
975
963
*/
964
+
(void)cmpxchg(&iter->position, pos, memcg);
965
+
976
966
if (pos)
977
967
css_put(&pos->css);
978
968
···
999
997
root = root_mem_cgroup;
1000
998
if (prev && prev != root)
1001
999
css_put(&prev->css);
1000
+
}
1001
+
1002
+
static void invalidate_reclaim_iterators(struct mem_cgroup *dead_memcg)
1003
+
{
1004
+
struct mem_cgroup *memcg = dead_memcg;
1005
+
struct mem_cgroup_reclaim_iter *iter;
1006
+
struct mem_cgroup_per_zone *mz;
1007
+
int nid, zid;
1008
+
int i;
1009
+
1010
+
while ((memcg = parent_mem_cgroup(memcg))) {
1011
+
for_each_node(nid) {
1012
+
for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1013
+
mz = &memcg->nodeinfo[nid]->zoneinfo[zid];
1014
+
for (i = 0; i <= DEF_PRIORITY; i++) {
1015
+
iter = &mz->iter[i];
1016
+
cmpxchg(&iter->position,
1017
+
dead_memcg, NULL);
1018
+
}
1019
+
}
1020
+
}
1021
+
}
1002
1022
}
1003
1023
1004
1024
/*
···
4348
4324
wb_memcg_offline(memcg);
4349
4325
}
4350
4326
4327
+
static void mem_cgroup_css_released(struct cgroup_subsys_state *css)
4328
+
{
4329
+
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
4330
+
4331
+
invalidate_reclaim_iterators(memcg);
4332
+
}
4333
+
4351
4334
static void mem_cgroup_css_free(struct cgroup_subsys_state *css)
4352
4335
{
4353
4336
struct mem_cgroup *memcg = mem_cgroup_from_css(css);
···
5216
5185
.css_alloc = mem_cgroup_css_alloc,
5217
5186
.css_online = mem_cgroup_css_online,
5218
5187
.css_offline = mem_cgroup_css_offline,
5188
+
.css_released = mem_cgroup_css_released,
5219
5189
.css_free = mem_cgroup_css_free,
5220
5190
.css_reset = mem_cgroup_css_reset,
5221
5191
.can_attach = mem_cgroup_can_attach,
+19
-12
mm/memory_hotplug.c
+19
-12
mm/memory_hotplug.c
···
1375
1375
*/
1376
1376
int test_pages_in_a_zone(unsigned long start_pfn, unsigned long end_pfn)
1377
1377
{
1378
-
unsigned long pfn;
1378
+
unsigned long pfn, sec_end_pfn;
1379
1379
struct zone *zone = NULL;
1380
1380
struct page *page;
1381
1381
int i;
1382
-
for (pfn = start_pfn;
1382
+
for (pfn = start_pfn, sec_end_pfn = SECTION_ALIGN_UP(start_pfn);
1383
1383
pfn < end_pfn;
1384
-
pfn += MAX_ORDER_NR_PAGES) {
1385
-
i = 0;
1386
-
/* This is just a CONFIG_HOLES_IN_ZONE check.*/
1387
-
while ((i < MAX_ORDER_NR_PAGES) && !pfn_valid_within(pfn + i))
1388
-
i++;
1389
-
if (i == MAX_ORDER_NR_PAGES)
1384
+
pfn = sec_end_pfn + 1, sec_end_pfn += PAGES_PER_SECTION) {
1385
+
/* Make sure the memory section is present first */
1386
+
if (!present_section_nr(pfn_to_section_nr(pfn)))
1390
1387
continue;
1391
-
page = pfn_to_page(pfn + i);
1392
-
if (zone && page_zone(page) != zone)
1393
-
return 0;
1394
-
zone = page_zone(page);
1388
+
for (; pfn < sec_end_pfn && pfn < end_pfn;
1389
+
pfn += MAX_ORDER_NR_PAGES) {
1390
+
i = 0;
1391
+
/* This is just a CONFIG_HOLES_IN_ZONE check.*/
1392
+
while ((i < MAX_ORDER_NR_PAGES) &&
1393
+
!pfn_valid_within(pfn + i))
1394
+
i++;
1395
+
if (i == MAX_ORDER_NR_PAGES)
1396
+
continue;
1397
+
page = pfn_to_page(pfn + i);
1398
+
if (zone && page_zone(page) != zone)
1399
+
return 0;
1400
+
zone = page_zone(page);
1401
+
}
1395
1402
}
1396
1403
return 1;
1397
1404
}
+5
-5
mm/vmstat.c
+5
-5
mm/vmstat.c
···
219
219
* particular counter cannot be updated from interrupt context.
220
220
*/
221
221
void __mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
222
-
int delta)
222
+
long delta)
223
223
{
224
224
struct per_cpu_pageset __percpu *pcp = zone->pageset;
225
225
s8 __percpu *p = pcp->vm_stat_diff + item;
···
318
318
* 1 Overstepping half of threshold
319
319
* -1 Overstepping minus half of threshold
320
320
*/
321
-
static inline void mod_state(struct zone *zone,
322
-
enum zone_stat_item item, int delta, int overstep_mode)
321
+
static inline void mod_state(struct zone *zone, enum zone_stat_item item,
322
+
long delta, int overstep_mode)
323
323
{
324
324
struct per_cpu_pageset __percpu *pcp = zone->pageset;
325
325
s8 __percpu *p = pcp->vm_stat_diff + item;
···
357
357
}
358
358
359
359
void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
360
-
int delta)
360
+
long delta)
361
361
{
362
362
mod_state(zone, item, delta, 0);
363
363
}
···
384
384
* Use interrupt disable to serialize counter updates
385
385
*/
386
386
void mod_zone_page_state(struct zone *zone, enum zone_stat_item item,
387
-
int delta)
387
+
long delta)
388
388
{
389
389
unsigned long flags;
390
390