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:
"13 fixes"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
mm, thp: do not cause memcg oom for thp
mm/vmscan: wake up flushers for legacy cgroups too
Revert "mm: page_alloc: skip over regions of invalid pfns where possible"
mm/shmem: do not wait for lock_page() in shmem_unused_huge_shrink()
mm/thp: do not wait for lock_page() in deferred_split_scan()
mm/khugepaged.c: convert VM_BUG_ON() to collapse fail
x86/mm: implement free pmd/pte page interfaces
mm/vmalloc: add interfaces to free unmapped page table
h8300: remove extraneous __BIG_ENDIAN definition
hugetlbfs: check for pgoff value overflow
lockdep: fix fs_reclaim warning
MAINTAINERS: update Mark Fasheh's e-mail
mm/mempolicy.c: avoid use uninitialized preferred_node
+153
-79
+1
-1
MAINTAINERS
+1
-1
MAINTAINERS
···
10334
10334
F: include/linux/oprofile.h
10335
10335
10336
10336
ORACLE CLUSTER FILESYSTEM 2 (OCFS2)
10337
-
M: Mark Fasheh <mfasheh@versity.com>
10337
+
M: Mark Fasheh <mark@fasheh.com>
10338
10338
M: Joel Becker <jlbec@evilplan.org>
10339
10339
L: ocfs2-devel@oss.oracle.com (moderated for non-subscribers)
10340
10340
W: http://ocfs2.wiki.kernel.org
+10
arch/arm64/mm/mmu.c
+10
arch/arm64/mm/mmu.c
-1
arch/h8300/include/asm/byteorder.h
-1
arch/h8300/include/asm/byteorder.h
+48
arch/x86/mm/pgtable.c
+48
arch/x86/mm/pgtable.c
···
702
702
703
703
return 0;
704
704
}
705
+
706
+
/**
707
+
* pud_free_pmd_page - Clear pud entry and free pmd page.
708
+
* @pud: Pointer to a PUD.
709
+
*
710
+
* Context: The pud range has been unmaped and TLB purged.
711
+
* Return: 1 if clearing the entry succeeded. 0 otherwise.
712
+
*/
713
+
int pud_free_pmd_page(pud_t *pud)
714
+
{
715
+
pmd_t *pmd;
716
+
int i;
717
+
718
+
if (pud_none(*pud))
719
+
return 1;
720
+
721
+
pmd = (pmd_t *)pud_page_vaddr(*pud);
722
+
723
+
for (i = 0; i < PTRS_PER_PMD; i++)
724
+
if (!pmd_free_pte_page(&pmd[i]))
725
+
return 0;
726
+
727
+
pud_clear(pud);
728
+
free_page((unsigned long)pmd);
729
+
730
+
return 1;
731
+
}
732
+
733
+
/**
734
+
* pmd_free_pte_page - Clear pmd entry and free pte page.
735
+
* @pmd: Pointer to a PMD.
736
+
*
737
+
* Context: The pmd range has been unmaped and TLB purged.
738
+
* Return: 1 if clearing the entry succeeded. 0 otherwise.
739
+
*/
740
+
int pmd_free_pte_page(pmd_t *pmd)
741
+
{
742
+
pte_t *pte;
743
+
744
+
if (pmd_none(*pmd))
745
+
return 1;
746
+
747
+
pte = (pte_t *)pmd_page_vaddr(*pmd);
748
+
pmd_clear(pmd);
749
+
free_page((unsigned long)pte);
750
+
751
+
return 1;
752
+
}
705
753
#endif /* CONFIG_HAVE_ARCH_HUGE_VMAP */
+14
-3
fs/hugetlbfs/inode.c
+14
-3
fs/hugetlbfs/inode.c
···
108
108
pagevec_reinit(pvec);
109
109
}
110
110
111
+
/*
112
+
* Mask used when checking the page offset value passed in via system
113
+
* calls. This value will be converted to a loff_t which is signed.
114
+
* Therefore, we want to check the upper PAGE_SHIFT + 1 bits of the
115
+
* value. The extra bit (- 1 in the shift value) is to take the sign
116
+
* bit into account.
117
+
*/
118
+
#define PGOFF_LOFFT_MAX \
119
+
(((1UL << (PAGE_SHIFT + 1)) - 1) << (BITS_PER_LONG - (PAGE_SHIFT + 1)))
120
+
111
121
static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
112
122
{
113
123
struct inode *inode = file_inode(file);
···
137
127
vma->vm_ops = &hugetlb_vm_ops;
138
128
139
129
/*
140
-
* Offset passed to mmap (before page shift) could have been
141
-
* negative when represented as a (l)off_t.
130
+
* page based offset in vm_pgoff could be sufficiently large to
131
+
* overflow a (l)off_t when converted to byte offset.
142
132
*/
143
-
if (((loff_t)vma->vm_pgoff << PAGE_SHIFT) < 0)
133
+
if (vma->vm_pgoff & PGOFF_LOFFT_MAX)
144
134
return -EINVAL;
145
135
136
+
/* must be huge page aligned */
146
137
if (vma->vm_pgoff & (~huge_page_mask(h) >> PAGE_SHIFT))
147
138
return -EINVAL;
148
139
+10
include/asm-generic/pgtable.h
+10
include/asm-generic/pgtable.h
···
983
983
int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot);
984
984
int pud_clear_huge(pud_t *pud);
985
985
int pmd_clear_huge(pmd_t *pmd);
986
+
int pud_free_pmd_page(pud_t *pud);
987
+
int pmd_free_pte_page(pmd_t *pmd);
986
988
#else /* !CONFIG_HAVE_ARCH_HUGE_VMAP */
987
989
static inline int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot)
988
990
{
···
1007
1005
return 0;
1008
1006
}
1009
1007
static inline int pmd_clear_huge(pmd_t *pmd)
1008
+
{
1009
+
return 0;
1010
+
}
1011
+
static inline int pud_free_pmd_page(pud_t *pud)
1012
+
{
1013
+
return 0;
1014
+
}
1015
+
static inline int pmd_free_pte_page(pmd_t *pmd)
1010
1016
{
1011
1017
return 0;
1012
1018
}
-1
include/linux/memblock.h
-1
include/linux/memblock.h
···
187
187
unsigned long *end_pfn);
188
188
void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
189
189
unsigned long *out_end_pfn, int *out_nid);
190
-
unsigned long memblock_next_valid_pfn(unsigned long pfn, unsigned long max_pfn);
191
190
192
191
/**
193
192
* for_each_mem_pfn_range - early memory pfn range iterator
+4
-2
lib/ioremap.c
+4
-2
lib/ioremap.c
···
91
91
92
92
if (ioremap_pmd_enabled() &&
93
93
((next - addr) == PMD_SIZE) &&
94
-
IS_ALIGNED(phys_addr + addr, PMD_SIZE)) {
94
+
IS_ALIGNED(phys_addr + addr, PMD_SIZE) &&
95
+
pmd_free_pte_page(pmd)) {
95
96
if (pmd_set_huge(pmd, phys_addr + addr, prot))
96
97
continue;
97
98
}
···
118
117
119
118
if (ioremap_pud_enabled() &&
120
119
((next - addr) == PUD_SIZE) &&
121
-
IS_ALIGNED(phys_addr + addr, PUD_SIZE)) {
120
+
IS_ALIGNED(phys_addr + addr, PUD_SIZE) &&
121
+
pud_free_pmd_page(pud)) {
122
122
if (pud_set_huge(pud, phys_addr + addr, prot))
123
123
continue;
124
124
}
+6
-3
mm/huge_memory.c
+6
-3
mm/huge_memory.c
···
555
555
556
556
VM_BUG_ON_PAGE(!PageCompound(page), page);
557
557
558
-
if (mem_cgroup_try_charge(page, vma->vm_mm, gfp, &memcg, true)) {
558
+
if (mem_cgroup_try_charge(page, vma->vm_mm, gfp | __GFP_NORETRY, &memcg,
559
+
true)) {
559
560
put_page(page);
560
561
count_vm_event(THP_FAULT_FALLBACK);
561
562
return VM_FAULT_FALLBACK;
···
1317
1316
}
1318
1317
1319
1318
if (unlikely(mem_cgroup_try_charge(new_page, vma->vm_mm,
1320
-
huge_gfp, &memcg, true))) {
1319
+
huge_gfp | __GFP_NORETRY, &memcg, true))) {
1321
1320
put_page(new_page);
1322
1321
split_huge_pmd(vma, vmf->pmd, vmf->address);
1323
1322
if (page)
···
2784
2783
2785
2784
list_for_each_safe(pos, next, &list) {
2786
2785
page = list_entry((void *)pos, struct page, mapping);
2787
-
lock_page(page);
2786
+
if (!trylock_page(page))
2787
+
goto next;
2788
2788
/* split_huge_page() removes page from list on success */
2789
2789
if (!split_huge_page(page))
2790
2790
split++;
2791
2791
unlock_page(page);
2792
+
next:
2792
2793
put_page(page);
2793
2794
}
2794
2795
+7
mm/hugetlb.c
+7
mm/hugetlb.c
···
18
18
#include <linux/bootmem.h>
19
19
#include <linux/sysfs.h>
20
20
#include <linux/slab.h>
21
+
#include <linux/mmdebug.h>
21
22
#include <linux/sched/signal.h>
22
23
#include <linux/rmap.h>
23
24
#include <linux/string_helpers.h>
···
4374
4373
struct hugepage_subpool *spool = subpool_inode(inode);
4375
4374
struct resv_map *resv_map;
4376
4375
long gbl_reserve;
4376
+
4377
+
/* This should never happen */
4378
+
if (from > to) {
4379
+
VM_WARN(1, "%s called with a negative range\n", __func__);
4380
+
return -EINVAL;
4381
+
}
4377
4382
4378
4383
/*
4379
4384
* Only apply hugepage reservation if asked. At fault time, an
+12
-3
mm/khugepaged.c
+12
-3
mm/khugepaged.c
···
530
530
goto out;
531
531
}
532
532
533
-
VM_BUG_ON_PAGE(PageCompound(page), page);
533
+
/* TODO: teach khugepaged to collapse THP mapped with pte */
534
+
if (PageCompound(page)) {
535
+
result = SCAN_PAGE_COMPOUND;
536
+
goto out;
537
+
}
538
+
534
539
VM_BUG_ON_PAGE(!PageAnon(page), page);
535
540
536
541
/*
···
965
960
goto out_nolock;
966
961
}
967
962
968
-
if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp, &memcg, true))) {
963
+
/* Do not oom kill for khugepaged charges */
964
+
if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp | __GFP_NORETRY,
965
+
&memcg, true))) {
969
966
result = SCAN_CGROUP_CHARGE_FAIL;
970
967
goto out_nolock;
971
968
}
···
1326
1319
goto out;
1327
1320
}
1328
1321
1329
-
if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp, &memcg, true))) {
1322
+
/* Do not oom kill for khugepaged charges */
1323
+
if (unlikely(mem_cgroup_try_charge(new_page, mm, gfp | __GFP_NORETRY,
1324
+
&memcg, true))) {
1330
1325
result = SCAN_CGROUP_CHARGE_FAIL;
1331
1326
goto out;
1332
1327
}
-28
mm/memblock.c
-28
mm/memblock.c
···
1101
1101
*out_nid = r->nid;
1102
1102
}
1103
1103
1104
-
unsigned long __init_memblock memblock_next_valid_pfn(unsigned long pfn,
1105
-
unsigned long max_pfn)
1106
-
{
1107
-
struct memblock_type *type = &memblock.memory;
1108
-
unsigned int right = type->cnt;
1109
-
unsigned int mid, left = 0;
1110
-
phys_addr_t addr = PFN_PHYS(++pfn);
1111
-
1112
-
do {
1113
-
mid = (right + left) / 2;
1114
-
1115
-
if (addr < type->regions[mid].base)
1116
-
right = mid;
1117
-
else if (addr >= (type->regions[mid].base +
1118
-
type->regions[mid].size))
1119
-
left = mid + 1;
1120
-
else {
1121
-
/* addr is within the region, so pfn is valid */
1122
-
return pfn;
1123
-
}
1124
-
} while (left < right);
1125
-
1126
-
if (right == type->cnt)
1127
-
return -1UL;
1128
-
else
1129
-
return PHYS_PFN(type->regions[right].base);
1130
-
}
1131
-
1132
1104
/**
1133
1105
* memblock_set_node - set node ID on memblock regions
1134
1106
* @base: base of area to set node ID for
+3
mm/mempolicy.c
+3
mm/mempolicy.c
···
2124
2124
case MPOL_INTERLEAVE:
2125
2125
return !!nodes_equal(a->v.nodes, b->v.nodes);
2126
2126
case MPOL_PREFERRED:
2127
+
/* a's ->flags is the same as b's */
2128
+
if (a->flags & MPOL_F_LOCAL)
2129
+
return true;
2127
2130
return a->v.preferred_node == b->v.preferred_node;
2128
2131
default:
2129
2132
BUG();
+2
-11
mm/page_alloc.c
+2
-11
mm/page_alloc.c
···
3596
3596
return false;
3597
3597
3598
3598
/* this guy won't enter reclaim */
3599
-
if ((current->flags & PF_MEMALLOC) && !(gfp_mask & __GFP_NOMEMALLOC))
3599
+
if (current->flags & PF_MEMALLOC)
3600
3600
return false;
3601
3601
3602
3602
/* We're only interested __GFP_FS allocations for now */
···
5356
5356
if (context != MEMMAP_EARLY)
5357
5357
goto not_early;
5358
5358
5359
-
if (!early_pfn_valid(pfn)) {
5360
-
#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
5361
-
/*
5362
-
* Skip to the pfn preceding the next valid one (or
5363
-
* end_pfn), such that we hit a valid pfn (or end_pfn)
5364
-
* on our next iteration of the loop.
5365
-
*/
5366
-
pfn = memblock_next_valid_pfn(pfn, end_pfn) - 1;
5367
-
#endif
5359
+
if (!early_pfn_valid(pfn))
5368
5360
continue;
5369
-
}
5370
5361
if (!early_pfn_in_nid(pfn, nid))
5371
5362
continue;
5372
5363
if (!update_defer_init(pgdat, pfn, end_pfn, &nr_initialised))
+20
-11
mm/shmem.c
+20
-11
mm/shmem.c
···
493
493
info = list_entry(pos, struct shmem_inode_info, shrinklist);
494
494
inode = &info->vfs_inode;
495
495
496
-
if (nr_to_split && split >= nr_to_split) {
497
-
iput(inode);
498
-
continue;
499
-
}
496
+
if (nr_to_split && split >= nr_to_split)
497
+
goto leave;
500
498
501
-
page = find_lock_page(inode->i_mapping,
499
+
page = find_get_page(inode->i_mapping,
502
500
(inode->i_size & HPAGE_PMD_MASK) >> PAGE_SHIFT);
503
501
if (!page)
504
502
goto drop;
505
503
504
+
/* No huge page at the end of the file: nothing to split */
506
505
if (!PageTransHuge(page)) {
507
-
unlock_page(page);
508
506
put_page(page);
509
507
goto drop;
508
+
}
509
+
510
+
/*
511
+
* Leave the inode on the list if we failed to lock
512
+
* the page at this time.
513
+
*
514
+
* Waiting for the lock may lead to deadlock in the
515
+
* reclaim path.
516
+
*/
517
+
if (!trylock_page(page)) {
518
+
put_page(page);
519
+
goto leave;
510
520
}
511
521
512
522
ret = split_huge_page(page);
513
523
unlock_page(page);
514
524
put_page(page);
515
525
516
-
if (ret) {
517
-
/* split failed: leave it on the list */
518
-
iput(inode);
519
-
continue;
520
-
}
526
+
/* If split failed leave the inode on the list */
527
+
if (ret)
528
+
goto leave;
521
529
522
530
split++;
523
531
drop:
524
532
list_del_init(&info->shrinklist);
525
533
removed++;
534
+
leave:
526
535
iput(inode);
527
536
}
528
537
+16
-15
mm/vmscan.c
+16
-15
mm/vmscan.c
···
1780
1780
set_bit(PGDAT_WRITEBACK, &pgdat->flags);
1781
1781
1782
1782
/*
1783
+
* If dirty pages are scanned that are not queued for IO, it
1784
+
* implies that flushers are not doing their job. This can
1785
+
* happen when memory pressure pushes dirty pages to the end of
1786
+
* the LRU before the dirty limits are breached and the dirty
1787
+
* data has expired. It can also happen when the proportion of
1788
+
* dirty pages grows not through writes but through memory
1789
+
* pressure reclaiming all the clean cache. And in some cases,
1790
+
* the flushers simply cannot keep up with the allocation
1791
+
* rate. Nudge the flusher threads in case they are asleep.
1792
+
*/
1793
+
if (stat.nr_unqueued_dirty == nr_taken)
1794
+
wakeup_flusher_threads(WB_REASON_VMSCAN);
1795
+
1796
+
/*
1783
1797
* Legacy memcg will stall in page writeback so avoid forcibly
1784
1798
* stalling here.
1785
1799
*/
···
1805
1791
if (stat.nr_dirty && stat.nr_dirty == stat.nr_congested)
1806
1792
set_bit(PGDAT_CONGESTED, &pgdat->flags);
1807
1793
1808
-
/*
1809
-
* If dirty pages are scanned that are not queued for IO, it
1810
-
* implies that flushers are not doing their job. This can
1811
-
* happen when memory pressure pushes dirty pages to the end of
1812
-
* the LRU before the dirty limits are breached and the dirty
1813
-
* data has expired. It can also happen when the proportion of
1814
-
* dirty pages grows not through writes but through memory
1815
-
* pressure reclaiming all the clean cache. And in some cases,
1816
-
* the flushers simply cannot keep up with the allocation
1817
-
* rate. Nudge the flusher threads in case they are asleep, but
1818
-
* also allow kswapd to start writing pages during reclaim.
1819
-
*/
1820
-
if (stat.nr_unqueued_dirty == nr_taken) {
1821
-
wakeup_flusher_threads(WB_REASON_VMSCAN);
1794
+
/* Allow kswapd to start writing pages during reclaim. */
1795
+
if (stat.nr_unqueued_dirty == nr_taken)
1822
1796
set_bit(PGDAT_DIRTY, &pgdat->flags);
1823
-
}
1824
1797
1825
1798
/*
1826
1799
* If kswapd scans pages marked marked for immediate