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:
"Two weeks worth of fixes here"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (41 commits)
init/main.c: fix initcall_blacklisted on ia64, ppc64 and parisc64
autofs: don't get stuck in a loop if vfs_write() returns an error
mm/page_owner: avoid null pointer dereference
tools/vm/slabinfo: fix spelling mistake: "Ocurrences" -> "Occurrences"
fs/nilfs2: fix potential underflow in call to crc32_le
oom, suspend: fix oom_reaper vs. oom_killer_disable race
ocfs2: disable BUG assertions in reading blocks
mm, compaction: abort free scanner if split fails
mm: prevent KASAN false positives in kmemleak
mm/hugetlb: clear compound_mapcount when freeing gigantic pages
mm/swap.c: flush lru pvecs on compound page arrival
memcg: css_alloc should return an ERR_PTR value on error
memcg: mem_cgroup_migrate() may be called with irq disabled
hugetlb: fix nr_pmds accounting with shared page tables
Revert "mm: disable fault around on emulated access bit architecture"
Revert "mm: make faultaround produce old ptes"
mailmap: add Boris Brezillon's email
mailmap: add Antoine Tenart's email
mm, sl[au]b: add __GFP_ATOMIC to the GFP reclaim mask
mm: mempool: kasan: don't poot mempool objects in quarantine
...
+178
-207
+4
.mailmap
+4
.mailmap
···
21
21
Andrew Morton <akpm@linux-foundation.org>
22
22
Andrew Vasquez <andrew.vasquez@qlogic.com>
23
23
Andy Adamson <andros@citi.umich.edu>
24
+
Antoine Tenart <antoine.tenart@free-electrons.com>
24
25
Antonio Ospite <ao2@ao2.it> <ao2@amarulasolutions.com>
25
26
Archit Taneja <archit@ti.com>
26
27
Arnaud Patard <arnaud.patard@rtp-net.org>
···
31
30
Ben Gardner <bgardner@wabtec.com>
32
31
Ben M Cahill <ben.m.cahill@intel.com>
33
32
Björn Steinbrink <B.Steinbrink@gmx.de>
33
+
Boris Brezillon <boris.brezillon@free-electrons.com>
34
+
Boris Brezillon <boris.brezillon@free-electrons.com> <b.brezillon.dev@gmail.com>
35
+
Boris Brezillon <boris.brezillon@free-electrons.com> <b.brezillon@overkiz.com>
34
36
Brian Avery <b.avery@hp.com>
35
37
Brian King <brking@us.ibm.com>
36
38
Christoph Hellwig <hch@lst.de>
+3
-3
MAINTAINERS
+3
-3
MAINTAINERS
···
2776
2776
F: net/caif/
2777
2777
2778
2778
CALGARY x86-64 IOMMU
2779
-
M: Muli Ben-Yehuda <muli@il.ibm.com>
2780
-
M: "Jon D. Mason" <jdmason@kudzu.us>
2781
-
L: discuss@x86-64.org
2779
+
M: Muli Ben-Yehuda <mulix@mulix.org>
2780
+
M: Jon Mason <jdmason@kudzu.us>
2781
+
L: iommu@lists.linux-foundation.org
2782
2782
S: Maintained
2783
2783
F: arch/x86/kernel/pci-calgary_64.c
2784
2784
F: arch/x86/kernel/tce_64.c
+2
-2
arch/alpha/include/asm/pgalloc.h
+2
-2
arch/alpha/include/asm/pgalloc.h
···
40
40
static inline pmd_t *
41
41
pmd_alloc_one(struct mm_struct *mm, unsigned long address)
42
42
{
43
-
pmd_t *ret = (pmd_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
43
+
pmd_t *ret = (pmd_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
44
44
return ret;
45
45
}
46
46
···
53
53
static inline pte_t *
54
54
pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
55
55
{
56
-
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
56
+
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
57
57
return pte;
58
58
}
59
59
+2
-2
arch/arc/include/asm/pgalloc.h
+2
-2
arch/arc/include/asm/pgalloc.h
···
95
95
{
96
96
pte_t *pte;
97
97
98
-
pte = (pte_t *) __get_free_pages(GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO,
98
+
pte = (pte_t *) __get_free_pages(GFP_KERNEL | __GFP_ZERO,
99
99
__get_order_pte());
100
100
101
101
return pte;
···
107
107
pgtable_t pte_pg;
108
108
struct page *page;
109
109
110
-
pte_pg = (pgtable_t)__get_free_pages(GFP_KERNEL | __GFP_REPEAT, __get_order_pte());
110
+
pte_pg = (pgtable_t)__get_free_pages(GFP_KERNEL, __get_order_pte());
111
111
if (!pte_pg)
112
112
return 0;
113
113
memzero((void *)pte_pg, PTRS_PER_PTE * sizeof(pte_t));
+1
-1
arch/arm/include/asm/pgalloc.h
+1
-1
arch/arm/include/asm/pgalloc.h
+1
-1
arch/arm64/include/asm/pgalloc.h
+1
-1
arch/arm64/include/asm/pgalloc.h
···
26
26
27
27
#define check_pgt_cache() do { } while (0)
28
28
29
-
#define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO)
29
+
#define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO)
30
30
#define PGD_SIZE (PTRS_PER_PGD * sizeof(pgd_t))
31
31
32
32
#if CONFIG_PGTABLE_LEVELS > 2
+3
-3
arch/avr32/include/asm/pgalloc.h
+3
-3
arch/avr32/include/asm/pgalloc.h
···
43
43
*/
44
44
static inline pgd_t *pgd_alloc(struct mm_struct *mm)
45
45
{
46
-
return quicklist_alloc(QUICK_PGD, GFP_KERNEL | __GFP_REPEAT, pgd_ctor);
46
+
return quicklist_alloc(QUICK_PGD, GFP_KERNEL, pgd_ctor);
47
47
}
48
48
49
49
static inline void pgd_free(struct mm_struct *mm, pgd_t *pgd)
···
54
54
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
55
55
unsigned long address)
56
56
{
57
-
return quicklist_alloc(QUICK_PT, GFP_KERNEL | __GFP_REPEAT, NULL);
57
+
return quicklist_alloc(QUICK_PT, GFP_KERNEL, NULL);
58
58
}
59
59
60
60
static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
···
63
63
struct page *page;
64
64
void *pg;
65
65
66
-
pg = quicklist_alloc(QUICK_PT, GFP_KERNEL | __GFP_REPEAT, NULL);
66
+
pg = quicklist_alloc(QUICK_PT, GFP_KERNEL, NULL);
67
67
if (!pg)
68
68
return NULL;
69
69
+2
-2
arch/cris/include/asm/pgalloc.h
+2
-2
arch/cris/include/asm/pgalloc.h
···
24
24
25
25
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
26
26
{
27
-
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
27
+
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
28
28
return pte;
29
29
}
30
30
31
31
static inline pgtable_t pte_alloc_one(struct mm_struct *mm, unsigned long address)
32
32
{
33
33
struct page *pte;
34
-
pte = alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
34
+
pte = alloc_pages(GFP_KERNEL|__GFP_ZERO, 0);
35
35
if (!pte)
36
36
return NULL;
37
37
if (!pgtable_page_ctor(pte)) {
+3
-3
arch/frv/mm/pgalloc.c
+3
-3
arch/frv/mm/pgalloc.c
···
22
22
23
23
pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
24
24
{
25
-
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT);
25
+
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL);
26
26
if (pte)
27
27
clear_page(pte);
28
28
return pte;
···
33
33
struct page *page;
34
34
35
35
#ifdef CONFIG_HIGHPTE
36
-
page = alloc_pages(GFP_KERNEL|__GFP_HIGHMEM|__GFP_REPEAT, 0);
36
+
page = alloc_pages(GFP_KERNEL|__GFP_HIGHMEM, 0);
37
37
#else
38
-
page = alloc_pages(GFP_KERNEL|__GFP_REPEAT, 0);
38
+
page = alloc_pages(GFP_KERNEL, 0);
39
39
#endif
40
40
if (!page)
41
41
return NULL;
+2
-2
arch/hexagon/include/asm/pgalloc.h
+2
-2
arch/hexagon/include/asm/pgalloc.h
···
64
64
{
65
65
struct page *pte;
66
66
67
-
pte = alloc_page(GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO);
67
+
pte = alloc_page(GFP_KERNEL | __GFP_ZERO);
68
68
if (!pte)
69
69
return NULL;
70
70
if (!pgtable_page_ctor(pte)) {
···
78
78
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
79
79
unsigned long address)
80
80
{
81
-
gfp_t flags = GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO;
81
+
gfp_t flags = GFP_KERNEL | __GFP_ZERO;
82
82
return (pte_t *) __get_free_page(flags);
83
83
}
84
84
+2
-2
arch/m68k/include/asm/mcf_pgalloc.h
+2
-2
arch/m68k/include/asm/mcf_pgalloc.h
···
14
14
extern inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
15
15
unsigned long address)
16
16
{
17
-
unsigned long page = __get_free_page(GFP_DMA|__GFP_REPEAT);
17
+
unsigned long page = __get_free_page(GFP_DMA);
18
18
19
19
if (!page)
20
20
return NULL;
···
51
51
static inline struct page *pte_alloc_one(struct mm_struct *mm,
52
52
unsigned long address)
53
53
{
54
-
struct page *page = alloc_pages(GFP_DMA|__GFP_REPEAT, 0);
54
+
struct page *page = alloc_pages(GFP_DMA, 0);
55
55
pte_t *pte;
56
56
57
57
if (!page)
+2
-2
arch/m68k/include/asm/motorola_pgalloc.h
+2
-2
arch/m68k/include/asm/motorola_pgalloc.h
···
11
11
{
12
12
pte_t *pte;
13
13
14
-
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
14
+
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
15
15
if (pte) {
16
16
__flush_page_to_ram(pte);
17
17
flush_tlb_kernel_page(pte);
···
32
32
struct page *page;
33
33
pte_t *pte;
34
34
35
-
page = alloc_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, 0);
35
+
page = alloc_pages(GFP_KERNEL|__GFP_ZERO, 0);
36
36
if(!page)
37
37
return NULL;
38
38
if (!pgtable_page_ctor(page)) {
+2
-2
arch/m68k/include/asm/sun3_pgalloc.h
+2
-2
arch/m68k/include/asm/sun3_pgalloc.h
···
37
37
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
38
38
unsigned long address)
39
39
{
40
-
unsigned long page = __get_free_page(GFP_KERNEL|__GFP_REPEAT);
40
+
unsigned long page = __get_free_page(GFP_KERNEL);
41
41
42
42
if (!page)
43
43
return NULL;
···
49
49
static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
50
50
unsigned long address)
51
51
{
52
-
struct page *page = alloc_pages(GFP_KERNEL|__GFP_REPEAT, 0);
52
+
struct page *page = alloc_pages(GFP_KERNEL, 0);
53
53
54
54
if (page == NULL)
55
55
return NULL;
+2
-3
arch/metag/include/asm/pgalloc.h
+2
-3
arch/metag/include/asm/pgalloc.h
···
42
42
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
43
43
unsigned long address)
44
44
{
45
-
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL | __GFP_REPEAT |
46
-
__GFP_ZERO);
45
+
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
47
46
return pte;
48
47
}
49
48
···
50
51
unsigned long address)
51
52
{
52
53
struct page *pte;
53
-
pte = alloc_pages(GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO, 0);
54
+
pte = alloc_pages(GFP_KERNEL | __GFP_ZERO, 0);
54
55
if (!pte)
55
56
return NULL;
56
57
if (!pgtable_page_ctor(pte)) {
+2
-2
arch/microblaze/include/asm/pgalloc.h
+2
-2
arch/microblaze/include/asm/pgalloc.h
···
116
116
struct page *ptepage;
117
117
118
118
#ifdef CONFIG_HIGHPTE
119
-
int flags = GFP_KERNEL | __GFP_HIGHMEM | __GFP_REPEAT;
119
+
int flags = GFP_KERNEL | __GFP_HIGHMEM;
120
120
#else
121
-
int flags = GFP_KERNEL | __GFP_REPEAT;
121
+
int flags = GFP_KERNEL;
122
122
#endif
123
123
124
124
ptepage = alloc_pages(flags, 0);
+1
-2
arch/microblaze/mm/pgtable.c
+1
-2
arch/microblaze/mm/pgtable.c
+3
-3
arch/mips/include/asm/pgalloc.h
+3
-3
arch/mips/include/asm/pgalloc.h
···
69
69
{
70
70
pte_t *pte;
71
71
72
-
pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO, PTE_ORDER);
72
+
pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_ZERO, PTE_ORDER);
73
73
74
74
return pte;
75
75
}
···
79
79
{
80
80
struct page *pte;
81
81
82
-
pte = alloc_pages(GFP_KERNEL | __GFP_REPEAT, PTE_ORDER);
82
+
pte = alloc_pages(GFP_KERNEL, PTE_ORDER);
83
83
if (!pte)
84
84
return NULL;
85
85
clear_highpage(pte);
···
113
113
{
114
114
pmd_t *pmd;
115
115
116
-
pmd = (pmd_t *) __get_free_pages(GFP_KERNEL|__GFP_REPEAT, PMD_ORDER);
116
+
pmd = (pmd_t *) __get_free_pages(GFP_KERNEL, PMD_ORDER);
117
117
if (pmd)
118
118
pmd_init((unsigned long)pmd, (unsigned long)invalid_pte_table);
119
119
return pmd;
+3
-3
arch/mn10300/mm/pgtable.c
+3
-3
arch/mn10300/mm/pgtable.c
···
63
63
64
64
pte_t *pte_alloc_one_kernel(struct mm_struct *mm, unsigned long address)
65
65
{
66
-
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT);
66
+
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL);
67
67
if (pte)
68
68
clear_page(pte);
69
69
return pte;
···
74
74
struct page *pte;
75
75
76
76
#ifdef CONFIG_HIGHPTE
77
-
pte = alloc_pages(GFP_KERNEL|__GFP_HIGHMEM|__GFP_REPEAT, 0);
77
+
pte = alloc_pages(GFP_KERNEL|__GFP_HIGHMEM, 0);
78
78
#else
79
-
pte = alloc_pages(GFP_KERNEL|__GFP_REPEAT, 0);
79
+
pte = alloc_pages(GFP_KERNEL, 0);
80
80
#endif
81
81
if (!pte)
82
82
return NULL;
+2
-3
arch/nios2/include/asm/pgalloc.h
+2
-3
arch/nios2/include/asm/pgalloc.h
···
42
42
{
43
43
pte_t *pte;
44
44
45
-
pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO,
46
-
PTE_ORDER);
45
+
pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_ZERO, PTE_ORDER);
47
46
48
47
return pte;
49
48
}
···
52
53
{
53
54
struct page *pte;
54
55
55
-
pte = alloc_pages(GFP_KERNEL | __GFP_REPEAT, PTE_ORDER);
56
+
pte = alloc_pages(GFP_KERNEL, PTE_ORDER);
56
57
if (pte) {
57
58
if (!pgtable_page_ctor(pte)) {
58
59
__free_page(pte);
+1
-1
arch/openrisc/include/asm/pgalloc.h
+1
-1
arch/openrisc/include/asm/pgalloc.h
+1
-1
arch/openrisc/mm/ioremap.c
+1
-1
arch/openrisc/mm/ioremap.c
+3
-4
arch/parisc/include/asm/pgalloc.h
+3
-4
arch/parisc/include/asm/pgalloc.h
···
63
63
64
64
static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long address)
65
65
{
66
-
pmd_t *pmd = (pmd_t *)__get_free_pages(GFP_KERNEL|__GFP_REPEAT,
67
-
PMD_ORDER);
66
+
pmd_t *pmd = (pmd_t *)__get_free_pages(GFP_KERNEL, PMD_ORDER);
68
67
if (pmd)
69
68
memset(pmd, 0, PAGE_SIZE<<PMD_ORDER);
70
69
return pmd;
···
123
124
static inline pgtable_t
124
125
pte_alloc_one(struct mm_struct *mm, unsigned long address)
125
126
{
126
-
struct page *page = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
127
+
struct page *page = alloc_page(GFP_KERNEL|__GFP_ZERO);
127
128
if (!page)
128
129
return NULL;
129
130
if (!pgtable_page_ctor(page)) {
···
136
137
static inline pte_t *
137
138
pte_alloc_one_kernel(struct mm_struct *mm, unsigned long addr)
138
139
{
139
-
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
140
+
pte_t *pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
140
141
return pte;
141
142
}
142
143
+5
-7
arch/powerpc/include/asm/book3s/64/pgalloc.h
+5
-7
arch/powerpc/include/asm/book3s/64/pgalloc.h
···
41
41
pgtable_cache[(shift) - 1]; \
42
42
})
43
43
44
-
#define PGALLOC_GFP GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO
44
+
#define PGALLOC_GFP GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO
45
45
46
46
extern pte_t *pte_fragment_alloc(struct mm_struct *, unsigned long, int);
47
47
extern void pte_fragment_free(unsigned long *, int);
···
56
56
return (pgd_t *)__get_free_page(PGALLOC_GFP);
57
57
#else
58
58
struct page *page;
59
-
page = alloc_pages(PGALLOC_GFP, 4);
59
+
page = alloc_pages(PGALLOC_GFP | __GFP_REPEAT, 4);
60
60
if (!page)
61
61
return NULL;
62
62
return (pgd_t *) page_address(page);
···
93
93
94
94
static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long addr)
95
95
{
96
-
return kmem_cache_alloc(PGT_CACHE(PUD_INDEX_SIZE),
97
-
GFP_KERNEL|__GFP_REPEAT);
96
+
return kmem_cache_alloc(PGT_CACHE(PUD_INDEX_SIZE), GFP_KERNEL);
98
97
}
99
98
100
99
static inline void pud_free(struct mm_struct *mm, pud_t *pud)
···
114
115
115
116
static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long addr)
116
117
{
117
-
return kmem_cache_alloc(PGT_CACHE(PMD_CACHE_INDEX),
118
-
GFP_KERNEL|__GFP_REPEAT);
118
+
return kmem_cache_alloc(PGT_CACHE(PMD_CACHE_INDEX), GFP_KERNEL);
119
119
}
120
120
121
121
static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
···
149
151
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
150
152
unsigned long address)
151
153
{
152
-
return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO);
154
+
return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
153
155
}
154
156
155
157
static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
+3
-5
arch/powerpc/include/asm/nohash/64/pgalloc.h
+3
-5
arch/powerpc/include/asm/nohash/64/pgalloc.h
···
57
57
58
58
static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long addr)
59
59
{
60
-
return kmem_cache_alloc(PGT_CACHE(PUD_INDEX_SIZE),
61
-
GFP_KERNEL|__GFP_REPEAT);
60
+
return kmem_cache_alloc(PGT_CACHE(PUD_INDEX_SIZE), GFP_KERNEL);
62
61
}
63
62
64
63
static inline void pud_free(struct mm_struct *mm, pud_t *pud)
···
87
88
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
88
89
unsigned long address)
89
90
{
90
-
return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO);
91
+
return (pte_t *)__get_free_page(GFP_KERNEL | __GFP_ZERO);
91
92
}
92
93
93
94
static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
···
189
190
190
191
static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long addr)
191
192
{
192
-
return kmem_cache_alloc(PGT_CACHE(PMD_CACHE_INDEX),
193
-
GFP_KERNEL|__GFP_REPEAT);
193
+
return kmem_cache_alloc(PGT_CACHE(PMD_CACHE_INDEX), GFP_KERNEL);
194
194
}
195
195
196
196
static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
+1
-1
arch/powerpc/mm/hugetlbpage.c
+1
-1
arch/powerpc/mm/hugetlbpage.c
+2
-2
arch/powerpc/mm/pgtable_32.c
+2
-2
arch/powerpc/mm/pgtable_32.c
···
84
84
pte_t *pte;
85
85
86
86
if (slab_is_available()) {
87
-
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
87
+
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
88
88
} else {
89
89
pte = __va(memblock_alloc(PAGE_SIZE, PAGE_SIZE));
90
90
if (pte)
···
97
97
{
98
98
struct page *ptepage;
99
99
100
-
gfp_t flags = GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO;
100
+
gfp_t flags = GFP_KERNEL | __GFP_ZERO;
101
101
102
102
ptepage = alloc_pages(flags, 0);
103
103
if (!ptepage)
+1
-2
arch/powerpc/mm/pgtable_64.c
+1
-2
arch/powerpc/mm/pgtable_64.c
···
350
350
static pte_t *__alloc_for_cache(struct mm_struct *mm, int kernel)
351
351
{
352
352
void *ret = NULL;
353
-
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK |
354
-
__GFP_REPEAT | __GFP_ZERO);
353
+
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO);
355
354
if (!page)
356
355
return NULL;
357
356
if (!kernel && !pgtable_page_ctor(page)) {
+1
-1
arch/s390/mm/pgalloc.c
+1
-1
arch/s390/mm/pgalloc.c
+2
-3
arch/score/include/asm/pgalloc.h
+2
-3
arch/score/include/asm/pgalloc.h
···
42
42
{
43
43
pte_t *pte;
44
44
45
-
pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO,
46
-
PTE_ORDER);
45
+
pte = (pte_t *) __get_free_pages(GFP_KERNEL|__GFP_ZERO, PTE_ORDER);
47
46
48
47
return pte;
49
48
}
···
52
53
{
53
54
struct page *pte;
54
55
55
-
pte = alloc_pages(GFP_KERNEL | __GFP_REPEAT, PTE_ORDER);
56
+
pte = alloc_pages(GFP_KERNEL, PTE_ORDER);
56
57
if (!pte)
57
58
return NULL;
58
59
clear_highpage(pte);
+2
-2
arch/sh/include/asm/pgalloc.h
+2
-2
arch/sh/include/asm/pgalloc.h
···
34
34
static inline pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
35
35
unsigned long address)
36
36
{
37
-
return quicklist_alloc(QUICK_PT, GFP_KERNEL | __GFP_REPEAT, NULL);
37
+
return quicklist_alloc(QUICK_PT, GFP_KERNEL, NULL);
38
38
}
39
39
40
40
static inline pgtable_t pte_alloc_one(struct mm_struct *mm,
···
43
43
struct page *page;
44
44
void *pg;
45
45
46
-
pg = quicklist_alloc(QUICK_PT, GFP_KERNEL | __GFP_REPEAT, NULL);
46
+
pg = quicklist_alloc(QUICK_PT, GFP_KERNEL, NULL);
47
47
if (!pg)
48
48
return NULL;
49
49
page = virt_to_page(pg);
+1
-1
arch/sh/mm/pgtable.c
+1
-1
arch/sh/mm/pgtable.c
+2
-4
arch/sparc/include/asm/pgalloc_64.h
+2
-4
arch/sparc/include/asm/pgalloc_64.h
···
41
41
42
42
static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long addr)
43
43
{
44
-
return kmem_cache_alloc(pgtable_cache,
45
-
GFP_KERNEL|__GFP_REPEAT);
44
+
return kmem_cache_alloc(pgtable_cache, GFP_KERNEL);
46
45
}
47
46
48
47
static inline void pud_free(struct mm_struct *mm, pud_t *pud)
···
51
52
52
53
static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long addr)
53
54
{
54
-
return kmem_cache_alloc(pgtable_cache,
55
-
GFP_KERNEL|__GFP_REPEAT);
55
+
return kmem_cache_alloc(pgtable_cache, GFP_KERNEL);
56
56
}
57
57
58
58
static inline void pmd_free(struct mm_struct *mm, pmd_t *pmd)
+2
-4
arch/sparc/mm/init_64.c
+2
-4
arch/sparc/mm/init_64.c
···
2704
2704
pte_t *pte_alloc_one_kernel(struct mm_struct *mm,
2705
2705
unsigned long address)
2706
2706
{
2707
-
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK |
2708
-
__GFP_REPEAT | __GFP_ZERO);
2707
+
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO);
2709
2708
pte_t *pte = NULL;
2710
2709
2711
2710
if (page)
···
2716
2717
pgtable_t pte_alloc_one(struct mm_struct *mm,
2717
2718
unsigned long address)
2718
2719
{
2719
-
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK |
2720
-
__GFP_REPEAT | __GFP_ZERO);
2720
+
struct page *page = alloc_page(GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO);
2721
2721
if (!page)
2722
2722
return NULL;
2723
2723
if (!pgtable_page_ctor(page)) {
+1
-1
arch/tile/mm/pgtable.c
+1
-1
arch/tile/mm/pgtable.c
+2
-2
arch/um/kernel/mem.c
+2
-2
arch/um/kernel/mem.c
···
204
204
{
205
205
pte_t *pte;
206
206
207
-
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
207
+
pte = (pte_t *)__get_free_page(GFP_KERNEL|__GFP_ZERO);
208
208
return pte;
209
209
}
210
210
···
212
212
{
213
213
struct page *pte;
214
214
215
-
pte = alloc_page(GFP_KERNEL|__GFP_REPEAT|__GFP_ZERO);
215
+
pte = alloc_page(GFP_KERNEL|__GFP_ZERO);
216
216
if (!pte)
217
217
return NULL;
218
218
if (!pgtable_page_ctor(pte)) {
+1
-1
arch/unicore32/include/asm/pgalloc.h
+1
-1
arch/unicore32/include/asm/pgalloc.h
···
28
28
#define pgd_alloc(mm) get_pgd_slow(mm)
29
29
#define pgd_free(mm, pgd) free_pgd_slow(mm, pgd)
30
30
31
-
#define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO)
31
+
#define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO)
32
32
33
33
/*
34
34
* Allocate one PTE table.
+2
-2
arch/x86/include/asm/pgalloc.h
+2
-2
arch/x86/include/asm/pgalloc.h
···
81
81
static inline pmd_t *pmd_alloc_one(struct mm_struct *mm, unsigned long addr)
82
82
{
83
83
struct page *page;
84
-
page = alloc_pages(GFP_KERNEL | __GFP_REPEAT | __GFP_ZERO, 0);
84
+
page = alloc_pages(GFP_KERNEL | __GFP_ZERO, 0);
85
85
if (!page)
86
86
return NULL;
87
87
if (!pgtable_pmd_page_ctor(page)) {
···
125
125
126
126
static inline pud_t *pud_alloc_one(struct mm_struct *mm, unsigned long addr)
127
127
{
128
-
return (pud_t *)get_zeroed_page(GFP_KERNEL|__GFP_REPEAT);
128
+
return (pud_t *)get_zeroed_page(GFP_KERNEL);
129
129
}
130
130
131
131
static inline void pud_free(struct mm_struct *mm, pud_t *pud)
+1
-1
arch/x86/kernel/espfix_64.c
+1
-1
arch/x86/kernel/espfix_64.c
···
57
57
# error "Need more than one PGD for the ESPFIX hack"
58
58
#endif
59
59
60
-
#define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO)
60
+
#define PGALLOC_GFP (GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO)
61
61
62
62
/* This contains the *bottom* address of the espfix stack */
63
63
DEFINE_PER_CPU_READ_MOSTLY(unsigned long, espfix_stack);
+1
-1
arch/x86/mm/pgtable.c
+1
-1
arch/x86/mm/pgtable.c
+1
-1
arch/x86/platform/efi/efi_64.c
+1
-1
arch/x86/platform/efi/efi_64.c
···
139
139
if (efi_enabled(EFI_OLD_MEMMAP))
140
140
return 0;
141
141
142
-
gfp_mask = GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO;
142
+
gfp_mask = GFP_KERNEL | __GFP_NOTRACK | __GFP_ZERO;
143
143
efi_pgd = (pgd_t *)__get_free_page(gfp_mask);
144
144
if (!efi_pgd)
145
145
return -ENOMEM;
+1
-1
arch/x86/xen/p2m.c
+1
-1
arch/x86/xen/p2m.c
+1
-1
arch/xtensa/include/asm/pgalloc.h
+1
-1
arch/xtensa/include/asm/pgalloc.h
+1
-1
drivers/block/aoe/aoecmd.c
+1
-1
drivers/block/aoe/aoecmd.c
+4
-3
fs/autofs4/waitq.c
+4
-3
fs/autofs4/waitq.c
···
66
66
set_fs(KERNEL_DS);
67
67
68
68
mutex_lock(&sbi->pipe_mutex);
69
-
wr = __vfs_write(file, data, bytes, &file->f_pos);
70
-
while (bytes && wr) {
69
+
while (bytes) {
70
+
wr = __vfs_write(file, data, bytes, &file->f_pos);
71
+
if (wr <= 0)
72
+
break;
71
73
data += wr;
72
74
bytes -= wr;
73
-
wr = __vfs_write(file, data, bytes, &file->f_pos);
74
75
}
75
76
mutex_unlock(&sbi->pipe_mutex);
76
77
+7
-25
fs/jbd2/journal.c
+7
-25
fs/jbd2/journal.c
···
2329
2329
2330
2330
BUG_ON(size & (size-1)); /* Must be a power of 2 */
2331
2331
2332
-
flags |= __GFP_REPEAT;
2333
-
if (size == PAGE_SIZE)
2334
-
ptr = (void *)__get_free_pages(flags, 0);
2335
-
else if (size > PAGE_SIZE) {
2336
-
int order = get_order(size);
2337
-
2338
-
if (order < 3)
2339
-
ptr = (void *)__get_free_pages(flags, order);
2340
-
else
2341
-
ptr = vmalloc(size);
2342
-
} else
2332
+
if (size < PAGE_SIZE)
2343
2333
ptr = kmem_cache_alloc(get_slab(size), flags);
2334
+
else
2335
+
ptr = (void *)__get_free_pages(flags, get_order(size));
2344
2336
2345
2337
/* Check alignment; SLUB has gotten this wrong in the past,
2346
2338
* and this can lead to user data corruption! */
···
2343
2351
2344
2352
void jbd2_free(void *ptr, size_t size)
2345
2353
{
2346
-
if (size == PAGE_SIZE) {
2347
-
free_pages((unsigned long)ptr, 0);
2348
-
return;
2349
-
}
2350
-
if (size > PAGE_SIZE) {
2351
-
int order = get_order(size);
2352
-
2353
-
if (order < 3)
2354
-
free_pages((unsigned long)ptr, order);
2355
-
else
2356
-
vfree(ptr);
2357
-
return;
2358
-
}
2359
-
kmem_cache_free(get_slab(size), ptr);
2354
+
if (size < PAGE_SIZE)
2355
+
kmem_cache_free(get_slab(size), ptr);
2356
+
else
2357
+
free_pages((unsigned long)ptr, get_order(size));
2360
2358
};
2361
2359
2362
2360
/*
+1
-1
fs/nilfs2/the_nilfs.c
+1
-1
fs/nilfs2/the_nilfs.c
···
439
439
if (!sbp || le16_to_cpu(sbp->s_magic) != NILFS_SUPER_MAGIC)
440
440
return 0;
441
441
bytes = le16_to_cpu(sbp->s_bytes);
442
-
if (bytes > BLOCK_SIZE)
442
+
if (bytes < sumoff + 4 || bytes > BLOCK_SIZE)
443
443
return 0;
444
444
crc = crc32_le(le32_to_cpu(sbp->s_crc_seed), (unsigned char *)sbp,
445
445
sumoff);
-2
fs/ocfs2/Makefile
-2
fs/ocfs2/Makefile
+5
fs/ocfs2/buffer_head_io.c
+5
fs/ocfs2/buffer_head_io.c
···
139
139
140
140
lock_buffer(bh);
141
141
if (buffer_jbd(bh)) {
142
+
#ifdef CATCH_BH_JBD_RACES
142
143
mlog(ML_ERROR,
143
144
"block %llu had the JBD bit set "
144
145
"while I was in lock_buffer!",
145
146
(unsigned long long)bh->b_blocknr);
146
147
BUG();
148
+
#else
149
+
unlock_buffer(bh);
150
+
continue;
151
+
#endif
147
152
}
148
153
149
154
clear_buffer_uptodate(bh);
+7
-4
include/linux/kasan.h
+7
-4
include/linux/kasan.h
···
59
59
60
60
void kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags);
61
61
void kasan_kfree_large(const void *ptr);
62
-
void kasan_kfree(void *ptr);
62
+
void kasan_poison_kfree(void *ptr);
63
63
void kasan_kmalloc(struct kmem_cache *s, const void *object, size_t size,
64
64
gfp_t flags);
65
65
void kasan_krealloc(const void *object, size_t new_size, gfp_t flags);
66
66
67
67
void kasan_slab_alloc(struct kmem_cache *s, void *object, gfp_t flags);
68
68
bool kasan_slab_free(struct kmem_cache *s, void *object);
69
-
void kasan_poison_slab_free(struct kmem_cache *s, void *object);
70
69
71
70
struct kasan_cache {
72
71
int alloc_meta_offset;
···
74
75
75
76
int kasan_module_alloc(void *addr, size_t size);
76
77
void kasan_free_shadow(const struct vm_struct *vm);
78
+
79
+
size_t ksize(const void *);
80
+
static inline void kasan_unpoison_slab(const void *ptr) { ksize(ptr); }
77
81
78
82
#else /* CONFIG_KASAN */
79
83
···
104
102
105
103
static inline void kasan_kmalloc_large(void *ptr, size_t size, gfp_t flags) {}
106
104
static inline void kasan_kfree_large(const void *ptr) {}
107
-
static inline void kasan_kfree(void *ptr) {}
105
+
static inline void kasan_poison_kfree(void *ptr) {}
108
106
static inline void kasan_kmalloc(struct kmem_cache *s, const void *object,
109
107
size_t size, gfp_t flags) {}
110
108
static inline void kasan_krealloc(const void *object, size_t new_size,
···
116
114
{
117
115
return false;
118
116
}
119
-
static inline void kasan_poison_slab_free(struct kmem_cache *s, void *object) {}
120
117
121
118
static inline int kasan_module_alloc(void *addr, size_t size) { return 0; }
122
119
static inline void kasan_free_shadow(const struct vm_struct *vm) {}
120
+
121
+
static inline void kasan_unpoison_slab(const void *ptr) { }
123
122
124
123
#endif /* CONFIG_KASAN */
125
124
+1
-1
include/linux/mm.h
+1
-1
include/linux/mm.h
+3
-1
init/main.c
+3
-1
init/main.c
···
708
708
{
709
709
struct blacklist_entry *entry;
710
710
char fn_name[KSYM_SYMBOL_LEN];
711
+
unsigned long addr;
711
712
712
713
if (list_empty(&blacklisted_initcalls))
713
714
return false;
714
715
715
-
sprint_symbol_no_offset(fn_name, (unsigned long)fn);
716
+
addr = (unsigned long) dereference_function_descriptor(fn);
717
+
sprint_symbol_no_offset(fn_name, addr);
716
718
717
719
list_for_each_entry(entry, &blacklisted_initcalls, next) {
718
720
if (!strcmp(fn_name, entry->buf)) {
+12
kernel/power/process.c
+12
kernel/power/process.c
···
146
146
if (!error && !oom_killer_disable())
147
147
error = -EBUSY;
148
148
149
+
/*
150
+
* There is a hard to fix race between oom_reaper kernel thread
151
+
* and oom_killer_disable. oom_reaper calls exit_oom_victim
152
+
* before the victim reaches exit_mm so try to freeze all the tasks
153
+
* again and catch such a left over task.
154
+
*/
155
+
if (!error) {
156
+
pr_info("Double checking all user space processes after OOM killer disable... ");
157
+
error = try_to_freeze_tasks(true);
158
+
pr_cont("\n");
159
+
}
160
+
149
161
if (error)
150
162
thaw_processes();
151
163
return error;
+21
-18
mm/compaction.c
+21
-18
mm/compaction.c
···
441
441
442
442
/* Found a free page, break it into order-0 pages */
443
443
isolated = split_free_page(page);
444
+
if (!isolated)
445
+
break;
446
+
444
447
total_isolated += isolated;
448
+
cc->nr_freepages += isolated;
445
449
for (i = 0; i < isolated; i++) {
446
450
list_add(&page->lru, freelist);
447
451
page++;
448
452
}
449
-
450
-
/* If a page was split, advance to the end of it */
451
-
if (isolated) {
452
-
cc->nr_freepages += isolated;
453
-
if (!strict &&
454
-
cc->nr_migratepages <= cc->nr_freepages) {
455
-
blockpfn += isolated;
456
-
break;
457
-
}
458
-
459
-
blockpfn += isolated - 1;
460
-
cursor += isolated - 1;
461
-
continue;
453
+
if (!strict && cc->nr_migratepages <= cc->nr_freepages) {
454
+
blockpfn += isolated;
455
+
break;
462
456
}
457
+
/* Advance to the end of split page */
458
+
blockpfn += isolated - 1;
459
+
cursor += isolated - 1;
460
+
continue;
463
461
464
462
isolate_fail:
465
463
if (strict)
···
466
468
continue;
467
469
468
470
}
471
+
472
+
if (locked)
473
+
spin_unlock_irqrestore(&cc->zone->lock, flags);
469
474
470
475
/*
471
476
* There is a tiny chance that we have read bogus compound_order(),
···
490
489
*/
491
490
if (strict && blockpfn < end_pfn)
492
491
total_isolated = 0;
493
-
494
-
if (locked)
495
-
spin_unlock_irqrestore(&cc->zone->lock, flags);
496
492
497
493
/* Update the pageblock-skip if the whole pageblock was scanned */
498
494
if (blockpfn == end_pfn)
···
1009
1011
block_end_pfn = block_start_pfn,
1010
1012
block_start_pfn -= pageblock_nr_pages,
1011
1013
isolate_start_pfn = block_start_pfn) {
1014
+
unsigned long isolated;
1012
1015
1013
1016
/*
1014
1017
* This can iterate a massively long zone without finding any
···
1034
1035
continue;
1035
1036
1036
1037
/* Found a block suitable for isolating free pages from. */
1037
-
isolate_freepages_block(cc, &isolate_start_pfn,
1038
-
block_end_pfn, freelist, false);
1038
+
isolated = isolate_freepages_block(cc, &isolate_start_pfn,
1039
+
block_end_pfn, freelist, false);
1040
+
/* If isolation failed early, do not continue needlessly */
1041
+
if (!isolated && isolate_start_pfn < block_end_pfn &&
1042
+
cc->nr_migratepages > cc->nr_freepages)
1043
+
break;
1039
1044
1040
1045
/*
1041
1046
* If we isolated enough freepages, or aborted due to async
+1
-1
mm/filemap.c
+1
-1
mm/filemap.c
···
2186
2186
if (file->f_ra.mmap_miss > 0)
2187
2187
file->f_ra.mmap_miss--;
2188
2188
addr = address + (page->index - vmf->pgoff) * PAGE_SIZE;
2189
-
do_set_pte(vma, addr, page, pte, false, false, true);
2189
+
do_set_pte(vma, addr, page, pte, false, false);
2190
2190
unlock_page(page);
2191
2191
goto next;
2192
2192
unlock:
+2
-2
mm/hugetlb.c
+2
-2
mm/hugetlb.c
···
1030
1030
int nr_pages = 1 << order;
1031
1031
struct page *p = page + 1;
1032
1032
1033
+
atomic_set(compound_mapcount_ptr(page), 0);
1033
1034
for (i = 1; i < nr_pages; i++, p = mem_map_next(p, page, i)) {
1034
1035
clear_compound_head(p);
1035
1036
set_page_refcounted(p);
···
4229
4228
if (saddr) {
4230
4229
spte = huge_pte_offset(svma->vm_mm, saddr);
4231
4230
if (spte) {
4232
-
mm_inc_nr_pmds(mm);
4233
4231
get_page(virt_to_page(spte));
4234
4232
break;
4235
4233
}
···
4243
4243
if (pud_none(*pud)) {
4244
4244
pud_populate(mm, pud,
4245
4245
(pmd_t *)((unsigned long)spte & PAGE_MASK));
4246
+
mm_inc_nr_pmds(mm);
4246
4247
} else {
4247
4248
put_page(virt_to_page(spte));
4248
-
mm_inc_nr_pmds(mm);
4249
4249
}
4250
4250
spin_unlock(ptl);
4251
4251
out:
+2
-1
mm/internal.h
+2
-1
mm/internal.h
···
24
24
*/
25
25
#define GFP_RECLAIM_MASK (__GFP_RECLAIM|__GFP_HIGH|__GFP_IO|__GFP_FS|\
26
26
__GFP_NOWARN|__GFP_REPEAT|__GFP_NOFAIL|\
27
-
__GFP_NORETRY|__GFP_MEMALLOC|__GFP_NOMEMALLOC)
27
+
__GFP_NORETRY|__GFP_MEMALLOC|__GFP_NOMEMALLOC|\
28
+
__GFP_ATOMIC)
28
29
29
30
/* The GFP flags allowed during early boot */
30
31
#define GFP_BOOT_MASK (__GFP_BITS_MASK & ~(__GFP_RECLAIM|__GFP_IO|__GFP_FS))
+3
-3
mm/kasan/kasan.c
+3
-3
mm/kasan/kasan.c
···
508
508
kasan_kmalloc(cache, object, cache->object_size, flags);
509
509
}
510
510
511
-
void kasan_poison_slab_free(struct kmem_cache *cache, void *object)
511
+
static void kasan_poison_slab_free(struct kmem_cache *cache, void *object)
512
512
{
513
513
unsigned long size = cache->object_size;
514
514
unsigned long rounded_up_size = round_up(size, KASAN_SHADOW_SCALE_SIZE);
···
626
626
kasan_kmalloc(page->slab_cache, object, size, flags);
627
627
}
628
628
629
-
void kasan_kfree(void *ptr)
629
+
void kasan_poison_kfree(void *ptr)
630
630
{
631
631
struct page *page;
632
632
···
636
636
kasan_poison_shadow(ptr, PAGE_SIZE << compound_order(page),
637
637
KASAN_FREE_PAGE);
638
638
else
639
-
kasan_slab_free(page->slab_cache, ptr);
639
+
kasan_poison_slab_free(page->slab_cache, ptr);
640
640
}
641
641
642
642
void kasan_kfree_large(const void *ptr)
+2
mm/kmemleak.c
+2
mm/kmemleak.c
···
307
307
len = min_t(size_t, object->size, HEX_MAX_LINES * HEX_ROW_SIZE);
308
308
309
309
seq_printf(seq, " hex dump (first %zu bytes):\n", len);
310
+
kasan_disable_current();
310
311
seq_hex_dump(seq, " ", DUMP_PREFIX_NONE, HEX_ROW_SIZE,
311
312
HEX_GROUP_SIZE, ptr, len, HEX_ASCII);
313
+
kasan_enable_current();
312
314
}
313
315
314
316
/*
+4
-3
mm/memcontrol.c
+4
-3
mm/memcontrol.c
···
4203
4203
return &memcg->css;
4204
4204
fail:
4205
4205
mem_cgroup_free(memcg);
4206
-
return NULL;
4206
+
return ERR_PTR(-ENOMEM);
4207
4207
}
4208
4208
4209
4209
static int
···
5544
5544
struct mem_cgroup *memcg;
5545
5545
unsigned int nr_pages;
5546
5546
bool compound;
5547
+
unsigned long flags;
5547
5548
5548
5549
VM_BUG_ON_PAGE(!PageLocked(oldpage), oldpage);
5549
5550
VM_BUG_ON_PAGE(!PageLocked(newpage), newpage);
···
5575
5574
5576
5575
commit_charge(newpage, memcg, false);
5577
5576
5578
-
local_irq_disable();
5577
+
local_irq_save(flags);
5579
5578
mem_cgroup_charge_statistics(memcg, newpage, compound, nr_pages);
5580
5579
memcg_check_events(memcg, newpage);
5581
-
local_irq_enable();
5580
+
local_irq_restore(flags);
5582
5581
}
5583
5582
5584
5583
DEFINE_STATIC_KEY_FALSE(memcg_sockets_enabled_key);
+5
-26
mm/memory.c
+5
-26
mm/memory.c
···
2877
2877
* vm_ops->map_pages.
2878
2878
*/
2879
2879
void do_set_pte(struct vm_area_struct *vma, unsigned long address,
2880
-
struct page *page, pte_t *pte, bool write, bool anon, bool old)
2880
+
struct page *page, pte_t *pte, bool write, bool anon)
2881
2881
{
2882
2882
pte_t entry;
2883
2883
···
2885
2885
entry = mk_pte(page, vma->vm_page_prot);
2886
2886
if (write)
2887
2887
entry = maybe_mkwrite(pte_mkdirty(entry), vma);
2888
-
if (old)
2889
-
entry = pte_mkold(entry);
2890
2888
if (anon) {
2891
2889
inc_mm_counter_fast(vma->vm_mm, MM_ANONPAGES);
2892
2890
page_add_new_anon_rmap(page, vma, address, false);
···
2898
2900
update_mmu_cache(vma, address, pte);
2899
2901
}
2900
2902
2901
-
/*
2902
-
* If architecture emulates "accessed" or "young" bit without HW support,
2903
-
* there is no much gain with fault_around.
2904
-
*/
2905
2903
static unsigned long fault_around_bytes __read_mostly =
2906
-
#ifndef __HAVE_ARCH_PTEP_SET_ACCESS_FLAGS
2907
-
PAGE_SIZE;
2908
-
#else
2909
2904
rounddown_pow_of_two(65536);
2910
-
#endif
2911
2905
2912
2906
#ifdef CONFIG_DEBUG_FS
2913
2907
static int fault_around_bytes_get(void *data, u64 *val)
···
3022
3032
*/
3023
3033
if (vma->vm_ops->map_pages && fault_around_bytes >> PAGE_SHIFT > 1) {
3024
3034
pte = pte_offset_map_lock(mm, pmd, address, &ptl);
3035
+
do_fault_around(vma, address, pte, pgoff, flags);
3025
3036
if (!pte_same(*pte, orig_pte))
3026
3037
goto unlock_out;
3027
-
do_fault_around(vma, address, pte, pgoff, flags);
3028
-
/* Check if the fault is handled by faultaround */
3029
-
if (!pte_same(*pte, orig_pte)) {
3030
-
/*
3031
-
* Faultaround produce old pte, but the pte we've
3032
-
* handler fault for should be young.
3033
-
*/
3034
-
pte_t entry = pte_mkyoung(*pte);
3035
-
if (ptep_set_access_flags(vma, address, pte, entry, 0))
3036
-
update_mmu_cache(vma, address, pte);
3037
-
goto unlock_out;
3038
-
}
3039
3038
pte_unmap_unlock(pte, ptl);
3040
3039
}
3041
3040
···
3039
3060
put_page(fault_page);
3040
3061
return ret;
3041
3062
}
3042
-
do_set_pte(vma, address, fault_page, pte, false, false, false);
3063
+
do_set_pte(vma, address, fault_page, pte, false, false);
3043
3064
unlock_page(fault_page);
3044
3065
unlock_out:
3045
3066
pte_unmap_unlock(pte, ptl);
···
3090
3111
}
3091
3112
goto uncharge_out;
3092
3113
}
3093
-
do_set_pte(vma, address, new_page, pte, true, true, false);
3114
+
do_set_pte(vma, address, new_page, pte, true, true);
3094
3115
mem_cgroup_commit_charge(new_page, memcg, false, false);
3095
3116
lru_cache_add_active_or_unevictable(new_page, vma);
3096
3117
pte_unmap_unlock(pte, ptl);
···
3143
3164
put_page(fault_page);
3144
3165
return ret;
3145
3166
}
3146
-
do_set_pte(vma, address, fault_page, pte, true, false, false);
3167
+
do_set_pte(vma, address, fault_page, pte, true, false);
3147
3168
pte_unmap_unlock(pte, ptl);
3148
3169
3149
3170
if (set_page_dirty(fault_page))
+4
-8
mm/mempool.c
+4
-8
mm/mempool.c
···
104
104
105
105
static void kasan_poison_element(mempool_t *pool, void *element)
106
106
{
107
-
if (pool->alloc == mempool_alloc_slab)
108
-
kasan_poison_slab_free(pool->pool_data, element);
109
-
if (pool->alloc == mempool_kmalloc)
110
-
kasan_kfree(element);
107
+
if (pool->alloc == mempool_alloc_slab || pool->alloc == mempool_kmalloc)
108
+
kasan_poison_kfree(element);
111
109
if (pool->alloc == mempool_alloc_pages)
112
110
kasan_free_pages(element, (unsigned long)pool->pool_data);
113
111
}
114
112
115
113
static void kasan_unpoison_element(mempool_t *pool, void *element, gfp_t flags)
116
114
{
117
-
if (pool->alloc == mempool_alloc_slab)
118
-
kasan_slab_alloc(pool->pool_data, element, flags);
119
-
if (pool->alloc == mempool_kmalloc)
120
-
kasan_krealloc(element, (size_t)pool->pool_data, flags);
115
+
if (pool->alloc == mempool_alloc_slab || pool->alloc == mempool_kmalloc)
116
+
kasan_unpoison_slab(element);
121
117
if (pool->alloc == mempool_alloc_pages)
122
118
kasan_alloc_pages(element, (unsigned long)pool->pool_data);
123
119
}
+1
-6
mm/oom_kill.c
+1
-6
mm/oom_kill.c
···
474
474
p = find_lock_task_mm(tsk);
475
475
if (!p)
476
476
goto unlock_oom;
477
-
478
477
mm = p->mm;
479
-
if (!atomic_inc_not_zero(&mm->mm_users)) {
480
-
task_unlock(p);
481
-
goto unlock_oom;
482
-
}
483
-
478
+
atomic_inc(&mm->mm_users);
484
479
task_unlock(p);
485
480
486
481
if (!down_read_trylock(&mm->mmap_sem)) {
+4
-2
mm/page_owner.c
+4
-2
mm/page_owner.c
···
207
207
.nr_entries = page_ext->nr_entries,
208
208
.entries = &page_ext->trace_entries[0],
209
209
};
210
-
gfp_t gfp_mask = page_ext->gfp_mask;
211
-
int mt = gfpflags_to_migratetype(gfp_mask);
210
+
gfp_t gfp_mask;
211
+
int mt;
212
212
213
213
if (unlikely(!page_ext)) {
214
214
pr_alert("There is not page extension available.\n");
215
215
return;
216
216
}
217
+
gfp_mask = page_ext->gfp_mask;
218
+
mt = gfpflags_to_migratetype(gfp_mask);
217
219
218
220
if (!test_bit(PAGE_EXT_OWNER, &page_ext->flags)) {
219
221
pr_alert("page_owner info is not active (free page?)\n");
+1
-1
mm/shmem.c
+1
-1
mm/shmem.c
+5
-6
mm/swap.c
+5
-6
mm/swap.c
···
242
242
get_page(page);
243
243
local_irq_save(flags);
244
244
pvec = this_cpu_ptr(&lru_rotate_pvecs);
245
-
if (!pagevec_add(pvec, page))
245
+
if (!pagevec_add(pvec, page) || PageCompound(page))
246
246
pagevec_move_tail(pvec);
247
247
local_irq_restore(flags);
248
248
}
···
296
296
struct pagevec *pvec = &get_cpu_var(activate_page_pvecs);
297
297
298
298
get_page(page);
299
-
if (!pagevec_add(pvec, page))
299
+
if (!pagevec_add(pvec, page) || PageCompound(page))
300
300
pagevec_lru_move_fn(pvec, __activate_page, NULL);
301
301
put_cpu_var(activate_page_pvecs);
302
302
}
···
391
391
struct pagevec *pvec = &get_cpu_var(lru_add_pvec);
392
392
393
393
get_page(page);
394
-
if (!pagevec_space(pvec))
394
+
if (!pagevec_add(pvec, page) || PageCompound(page))
395
395
__pagevec_lru_add(pvec);
396
-
pagevec_add(pvec, page);
397
396
put_cpu_var(lru_add_pvec);
398
397
}
399
398
···
627
628
if (likely(get_page_unless_zero(page))) {
628
629
struct pagevec *pvec = &get_cpu_var(lru_deactivate_file_pvecs);
629
630
630
-
if (!pagevec_add(pvec, page))
631
+
if (!pagevec_add(pvec, page) || PageCompound(page))
631
632
pagevec_lru_move_fn(pvec, lru_deactivate_file_fn, NULL);
632
633
put_cpu_var(lru_deactivate_file_pvecs);
633
634
}
···
647
648
struct pagevec *pvec = &get_cpu_var(lru_deactivate_pvecs);
648
649
649
650
get_page(page);
650
-
if (!pagevec_add(pvec, page))
651
+
if (!pagevec_add(pvec, page) || PageCompound(page))
651
652
pagevec_lru_move_fn(pvec, lru_deactivate_fn, NULL);
652
653
put_cpu_var(lru_deactivate_pvecs);
653
654
}
+1
-1
tools/testing/selftests/vm/compaction_test.c
+1
-1
tools/testing/selftests/vm/compaction_test.c
···
136
136
printf("No of huge pages allocated = %d\n",
137
137
(atoi(nr_hugepages)));
138
138
139
-
if (write(fd, initial_nr_hugepages, sizeof(initial_nr_hugepages))
139
+
if (write(fd, initial_nr_hugepages, strlen(initial_nr_hugepages))
140
140
!= strlen(initial_nr_hugepages)) {
141
141
perror("Failed to write to /proc/sys/vm/nr_hugepages\n");
142
142
goto close_fd;
+1
-1
tools/vm/slabinfo.c
+1
-1
tools/vm/slabinfo.c
···
492
492
s->deactivate_to_head + s->deactivate_to_tail + s->deactivate_bypass;
493
493
494
494
if (total) {
495
-
printf("\nSlab Deactivation Ocurrences %%\n");
495
+
printf("\nSlab Deactivation Occurrences %%\n");
496
496
printf("-------------------------------------------------\n");
497
497
printf("Slab full %7lu %3lu%%\n",
498
498
s->deactivate_full, (s->deactivate_full * 100) / total);