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)
Mergr misc fixes from Andrew Morton:
"28 fixes"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (28 commits)
fs/hugetlbfs/inode.c: change put_page/unlock_page order in hugetlbfs_fallocate()
mm/hugetlb: fix NULL-pointer dereference on 5-level paging machine
autofs: revert "autofs: fix AT_NO_AUTOMOUNT not being honored"
autofs: revert "autofs: take more care to not update last_used on path walk"
fs/fat/inode.c: fix sb_rdonly() change
mm, memcg: fix mem_cgroup_swapout() for THPs
mm: migrate: fix an incorrect call of prep_transhuge_page()
kmemleak: add scheduling point to kmemleak_scan()
scripts/bloat-o-meter: don't fail with division by 0
fs/mbcache.c: make count_objects() more robust
Revert "mm/page-writeback.c: print a warning if the vm dirtiness settings are illogical"
mm/madvise.c: fix madvise() infinite loop under special circumstances
exec: avoid RLIMIT_STACK races with prlimit()
IB/core: disable memory registration of filesystem-dax vmas
v4l2: disable filesystem-dax mapping support
mm: fail get_vaddr_frames() for filesystem-dax mappings
mm: introduce get_user_pages_longterm
device-dax: implement ->split() to catch invalid munmap attempts
mm, hugetlbfs: introduce ->split() to vm_operations_struct
scripts/faddr2line: extend usage on generic arch
...
+238
-101
-7
Documentation/sysctl/vm.txt
-7
Documentation/sysctl/vm.txt
···
158
158
value lower than this limit will be ignored and the old configuration will be
159
159
retained.
160
160
161
-
Note: the value of dirty_bytes also must be set greater than
162
-
dirty_background_bytes or the amount of memory corresponding to
163
-
dirty_background_ratio.
164
-
165
161
==============================================================
166
162
167
163
dirty_expire_centisecs
···
176
180
generating disk writes will itself start writing out dirty data.
177
181
178
182
The total available memory is not equal to total system memory.
179
-
180
-
Note: dirty_ratio must be set greater than dirty_background_ratio or
181
-
ratio corresponding to dirty_background_bytes.
182
183
183
184
==============================================================
184
185
-1
arch/arm/include/asm/pgtable-3level.h
-1
arch/arm/include/asm/pgtable-3level.h
-1
arch/arm64/include/asm/pgtable.h
-1
arch/arm64/include/asm/pgtable.h
+1
-1
arch/mips/include/asm/pgtable.h
+1
-1
arch/mips/include/asm/pgtable.h
-1
arch/powerpc/include/asm/book3s/64/pgtable.h
-1
arch/powerpc/include/asm/book3s/64/pgtable.h
+7
-1
arch/s390/include/asm/pgtable.h
+7
-1
arch/s390/include/asm/pgtable.h
···
709
709
return (pmd_val(pmd) & origin_mask) >> PAGE_SHIFT;
710
710
}
711
711
712
-
#define __HAVE_ARCH_PMD_WRITE
712
+
#define pmd_write pmd_write
713
713
static inline int pmd_write(pmd_t pmd)
714
714
{
715
715
return (pmd_val(pmd) & _SEGMENT_ENTRY_WRITE) != 0;
···
1262
1262
return pud;
1263
1263
pud_val(pud) &= ~_REGION_ENTRY_PROTECT;
1264
1264
return pud;
1265
+
}
1266
+
1267
+
#define pud_write pud_write
1268
+
static inline int pud_write(pud_t pud)
1269
+
{
1270
+
return (pud_val(pud) & _REGION3_ENTRY_WRITE) != 0;
1265
1271
}
1266
1272
1267
1273
static inline pud_t pud_mkclean(pud_t pud)
+1
-1
arch/sparc/include/asm/pgtable_64.h
+1
-1
arch/sparc/include/asm/pgtable_64.h
+2
-2
arch/sparc/mm/gup.c
+2
-2
arch/sparc/mm/gup.c
···
75
75
if (!(pmd_val(pmd) & _PAGE_VALID))
76
76
return 0;
77
77
78
-
if (write && !pmd_write(pmd))
78
+
if (!pmd_access_permitted(pmd, write))
79
79
return 0;
80
80
81
81
refs = 0;
···
114
114
if (!(pud_val(pud) & _PAGE_VALID))
115
115
return 0;
116
116
117
-
if (write && !pud_write(pud))
117
+
if (!pud_access_permitted(pud, write))
118
118
return 0;
119
119
120
120
refs = 0;
-1
arch/tile/include/asm/pgtable.h
-1
arch/tile/include/asm/pgtable.h
···
475
475
#define pmd_mkdirty(pmd) pte_pmd(pte_mkdirty(pmd_pte(pmd)))
476
476
#define pmd_huge_page(pmd) pte_huge(pmd_pte(pmd))
477
477
#define pmd_mkhuge(pmd) pte_pmd(pte_mkhuge(pmd_pte(pmd)))
478
-
#define __HAVE_ARCH_PMD_WRITE
479
478
480
479
#define pfn_pmd(pfn, pgprot) pte_pmd(pfn_pte((pfn), (pgprot)))
481
480
#define pmd_pfn(pmd) pte_pfn(pmd_pte(pmd))
+7
-1
arch/x86/include/asm/pgtable.h
+7
-1
arch/x86/include/asm/pgtable.h
···
1061
1061
unsigned long address, pmd_t *pmdp);
1062
1062
1063
1063
1064
-
#define __HAVE_ARCH_PMD_WRITE
1064
+
#define pmd_write pmd_write
1065
1065
static inline int pmd_write(pmd_t pmd)
1066
1066
{
1067
1067
return pmd_flags(pmd) & _PAGE_RW;
···
1086
1086
unsigned long addr, pmd_t *pmdp)
1087
1087
{
1088
1088
clear_bit(_PAGE_BIT_RW, (unsigned long *)pmdp);
1089
+
}
1090
+
1091
+
#define pud_write pud_write
1092
+
static inline int pud_write(pud_t pud)
1093
+
{
1094
+
return pud_flags(pud) & _PAGE_RW;
1089
1095
}
1090
1096
1091
1097
/*
+12
drivers/dax/device.c
+12
drivers/dax/device.c
···
428
428
return dev_dax_huge_fault(vmf, PE_SIZE_PTE);
429
429
}
430
430
431
+
static int dev_dax_split(struct vm_area_struct *vma, unsigned long addr)
432
+
{
433
+
struct file *filp = vma->vm_file;
434
+
struct dev_dax *dev_dax = filp->private_data;
435
+
struct dax_region *dax_region = dev_dax->region;
436
+
437
+
if (!IS_ALIGNED(addr, dax_region->align))
438
+
return -EINVAL;
439
+
return 0;
440
+
}
441
+
431
442
static const struct vm_operations_struct dax_vm_ops = {
432
443
.fault = dev_dax_fault,
433
444
.huge_fault = dev_dax_huge_fault,
445
+
.split = dev_dax_split,
434
446
};
435
447
436
448
static int dax_mmap(struct file *filp, struct vm_area_struct *vma)
+1
-1
drivers/infiniband/core/umem.c
+1
-1
drivers/infiniband/core/umem.c
+3
-2
drivers/media/v4l2-core/videobuf-dma-sg.c
+3
-2
drivers/media/v4l2-core/videobuf-dma-sg.c
···
185
185
dprintk(1, "init user [0x%lx+0x%lx => %d pages]\n",
186
186
data, size, dma->nr_pages);
187
187
188
-
err = get_user_pages(data & PAGE_MASK, dma->nr_pages,
188
+
err = get_user_pages_longterm(data & PAGE_MASK, dma->nr_pages,
189
189
flags, dma->pages, NULL);
190
190
191
191
if (err != dma->nr_pages) {
192
192
dma->nr_pages = (err >= 0) ? err : 0;
193
-
dprintk(1, "get_user_pages: err=%d [%d]\n", err, dma->nr_pages);
193
+
dprintk(1, "get_user_pages_longterm: err=%d [%d]\n", err,
194
+
dma->nr_pages);
194
195
return err < 0 ? err : -EINVAL;
195
196
}
196
197
return 0;
+6
-11
fs/autofs4/root.c
+6
-11
fs/autofs4/root.c
···
281
281
pr_debug("waiting for mount name=%pd\n", path->dentry);
282
282
status = autofs4_wait(sbi, path, NFY_MOUNT);
283
283
pr_debug("mount wait done status=%d\n", status);
284
-
ino->last_used = jiffies;
285
284
}
285
+
ino->last_used = jiffies;
286
286
return status;
287
287
}
288
288
···
321
321
*/
322
322
if (autofs_type_indirect(sbi->type) && d_unhashed(dentry)) {
323
323
struct dentry *parent = dentry->d_parent;
324
+
struct autofs_info *ino;
324
325
struct dentry *new;
325
326
326
327
new = d_lookup(parent, &dentry->d_name);
327
328
if (!new)
328
329
return NULL;
329
-
if (new == dentry)
330
-
dput(new);
331
-
else {
332
-
struct autofs_info *ino;
333
-
334
-
ino = autofs4_dentry_ino(new);
335
-
ino->last_used = jiffies;
336
-
dput(path->dentry);
337
-
path->dentry = new;
338
-
}
330
+
ino = autofs4_dentry_ino(new);
331
+
ino->last_used = jiffies;
332
+
dput(path->dentry);
333
+
path->dentry = new;
339
334
}
340
335
return path->dentry;
341
336
}
+2
-1
fs/dax.c
+2
-1
fs/dax.c
+6
-1
fs/exec.c
+6
-1
fs/exec.c
···
1340
1340
* avoid bad behavior from the prior rlimits. This has to
1341
1341
* happen before arch_pick_mmap_layout(), which examines
1342
1342
* RLIMIT_STACK, but after the point of no return to avoid
1343
-
* needing to clean up the change on failure.
1343
+
* races from other threads changing the limits. This also
1344
+
* must be protected from races with prlimit() calls.
1344
1345
*/
1346
+
task_lock(current->group_leader);
1345
1347
if (current->signal->rlim[RLIMIT_STACK].rlim_cur > _STK_LIM)
1346
1348
current->signal->rlim[RLIMIT_STACK].rlim_cur = _STK_LIM;
1349
+
if (current->signal->rlim[RLIMIT_STACK].rlim_max > _STK_LIM)
1350
+
current->signal->rlim[RLIMIT_STACK].rlim_max = _STK_LIM;
1351
+
task_unlock(current->group_leader);
1347
1352
}
1348
1353
1349
1354
arch_pick_mmap_layout(current->mm);
+1
-1
fs/fat/inode.c
+1
-1
fs/fat/inode.c
+2
-2
fs/hugetlbfs/inode.c
+2
-2
fs/hugetlbfs/inode.c
···
639
639
mutex_unlock(&hugetlb_fault_mutex_table[hash]);
640
640
641
641
/*
642
-
* page_put due to reference from alloc_huge_page()
643
642
* unlock_page because locked by add_to_page_cache()
643
+
* page_put due to reference from alloc_huge_page()
644
644
*/
645
-
put_page(page);
646
645
unlock_page(page);
646
+
put_page(page);
647
647
}
648
648
649
649
if (!(mode & FALLOC_FL_KEEP_SIZE) && offset + len > inode->i_size)
+3
fs/mbcache.c
+3
fs/mbcache.c
+3
-12
fs/namei.c
+3
-12
fs/namei.c
···
1129
1129
* of the daemon to instantiate them before they can be used.
1130
1130
*/
1131
1131
if (!(nd->flags & (LOOKUP_PARENT | LOOKUP_DIRECTORY |
1132
-
LOOKUP_OPEN | LOOKUP_CREATE |
1133
-
LOOKUP_AUTOMOUNT))) {
1134
-
/* Positive dentry that isn't meant to trigger an
1135
-
* automount, EISDIR will allow it to be used,
1136
-
* otherwise there's no mount here "now" so return
1137
-
* ENOENT.
1138
-
*/
1139
-
if (path->dentry->d_inode)
1140
-
return -EISDIR;
1141
-
else
1142
-
return -ENOENT;
1143
-
}
1132
+
LOOKUP_OPEN | LOOKUP_CREATE | LOOKUP_AUTOMOUNT)) &&
1133
+
path->dentry->d_inode)
1134
+
return -EISDIR;
1144
1135
1145
1136
if (path->dentry->d_sb->s_user_ns != &init_user_ns)
1146
1137
return -EACCES;
+10
-2
include/asm-generic/pgtable.h
+10
-2
include/asm-generic/pgtable.h
···
805
805
{
806
806
return 0;
807
807
}
808
-
#ifndef __HAVE_ARCH_PMD_WRITE
808
+
#ifndef pmd_write
809
809
static inline int pmd_write(pmd_t pmd)
810
810
{
811
811
BUG();
812
812
return 0;
813
813
}
814
-
#endif /* __HAVE_ARCH_PMD_WRITE */
814
+
#endif /* pmd_write */
815
815
#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
816
+
817
+
#ifndef pud_write
818
+
static inline int pud_write(pud_t pud)
819
+
{
820
+
BUG();
821
+
return 0;
822
+
}
823
+
#endif /* pud_write */
816
824
817
825
#if !defined(CONFIG_TRANSPARENT_HUGEPAGE) || \
818
826
(defined(CONFIG_TRANSPARENT_HUGEPAGE) && \
+16
-1
include/linux/fs.h
+16
-1
include/linux/fs.h
···
3088
3088
static inline int vfs_fstatat(int dfd, const char __user *filename,
3089
3089
struct kstat *stat, int flags)
3090
3090
{
3091
-
return vfs_statx(dfd, filename, flags, stat, STATX_BASIC_STATS);
3091
+
return vfs_statx(dfd, filename, flags | AT_NO_AUTOMOUNT,
3092
+
stat, STATX_BASIC_STATS);
3092
3093
}
3093
3094
static inline int vfs_fstat(int fd, struct kstat *stat)
3094
3095
{
···
3193
3192
static inline bool vma_is_dax(struct vm_area_struct *vma)
3194
3193
{
3195
3194
return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host);
3195
+
}
3196
+
3197
+
static inline bool vma_is_fsdax(struct vm_area_struct *vma)
3198
+
{
3199
+
struct inode *inode;
3200
+
3201
+
if (!vma->vm_file)
3202
+
return false;
3203
+
if (!vma_is_dax(vma))
3204
+
return false;
3205
+
inode = file_inode(vma->vm_file);
3206
+
if (inode->i_mode == S_IFCHR)
3207
+
return false; /* device-dax */
3208
+
return true;
3196
3209
}
3197
3210
3198
3211
static inline int iocb_flags(struct file *file)
-8
include/linux/hugetlb.h
-8
include/linux/hugetlb.h
+1
-1
include/linux/migrate.h
+1
-1
include/linux/migrate.h
+14
include/linux/mm.h
+14
include/linux/mm.h
···
377
377
struct vm_operations_struct {
378
378
void (*open)(struct vm_area_struct * area);
379
379
void (*close)(struct vm_area_struct * area);
380
+
int (*split)(struct vm_area_struct * area, unsigned long addr);
380
381
int (*mremap)(struct vm_area_struct * area);
381
382
int (*fault)(struct vm_fault *vmf);
382
383
int (*huge_fault)(struct vm_fault *vmf, enum page_entry_size pe_size);
···
1380
1379
unsigned int gup_flags, struct page **pages, int *locked);
1381
1380
long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
1382
1381
struct page **pages, unsigned int gup_flags);
1382
+
#ifdef CONFIG_FS_DAX
1383
+
long get_user_pages_longterm(unsigned long start, unsigned long nr_pages,
1384
+
unsigned int gup_flags, struct page **pages,
1385
+
struct vm_area_struct **vmas);
1386
+
#else
1387
+
static inline long get_user_pages_longterm(unsigned long start,
1388
+
unsigned long nr_pages, unsigned int gup_flags,
1389
+
struct page **pages, struct vm_area_struct **vmas)
1390
+
{
1391
+
return get_user_pages(start, nr_pages, gup_flags, pages, vmas);
1392
+
}
1393
+
#endif /* CONFIG_FS_DAX */
1394
+
1383
1395
int get_user_pages_fast(unsigned long start, int nr_pages, int write,
1384
1396
struct page **pages);
1385
1397
+12
mm/frame_vector.c
+12
mm/frame_vector.c
···
53
53
ret = -EFAULT;
54
54
goto out;
55
55
}
56
+
57
+
/*
58
+
* While get_vaddr_frames() could be used for transient (kernel
59
+
* controlled lifetime) pinning of memory pages all current
60
+
* users establish long term (userspace controlled lifetime)
61
+
* page pinning. Treat get_vaddr_frames() like
62
+
* get_user_pages_longterm() and disallow it for filesystem-dax
63
+
* mappings.
64
+
*/
65
+
if (vma_is_fsdax(vma))
66
+
return -EOPNOTSUPP;
67
+
56
68
if (!(vma->vm_flags & (VM_IO | VM_PFNMAP))) {
57
69
vec->got_ref = true;
58
70
vec->is_pfns = false;
+65
-1
mm/gup.c
+65
-1
mm/gup.c
···
66
66
*/
67
67
static inline bool can_follow_write_pte(pte_t pte, unsigned int flags)
68
68
{
69
-
return pte_write(pte) ||
69
+
return pte_access_permitted(pte, WRITE) ||
70
70
((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte));
71
71
}
72
72
···
1094
1094
gup_flags | FOLL_TOUCH);
1095
1095
}
1096
1096
EXPORT_SYMBOL(get_user_pages);
1097
+
1098
+
#ifdef CONFIG_FS_DAX
1099
+
/*
1100
+
* This is the same as get_user_pages() in that it assumes we are
1101
+
* operating on the current task's mm, but it goes further to validate
1102
+
* that the vmas associated with the address range are suitable for
1103
+
* longterm elevated page reference counts. For example, filesystem-dax
1104
+
* mappings are subject to the lifetime enforced by the filesystem and
1105
+
* we need guarantees that longterm users like RDMA and V4L2 only
1106
+
* establish mappings that have a kernel enforced revocation mechanism.
1107
+
*
1108
+
* "longterm" == userspace controlled elevated page count lifetime.
1109
+
* Contrast this to iov_iter_get_pages() usages which are transient.
1110
+
*/
1111
+
long get_user_pages_longterm(unsigned long start, unsigned long nr_pages,
1112
+
unsigned int gup_flags, struct page **pages,
1113
+
struct vm_area_struct **vmas_arg)
1114
+
{
1115
+
struct vm_area_struct **vmas = vmas_arg;
1116
+
struct vm_area_struct *vma_prev = NULL;
1117
+
long rc, i;
1118
+
1119
+
if (!pages)
1120
+
return -EINVAL;
1121
+
1122
+
if (!vmas) {
1123
+
vmas = kcalloc(nr_pages, sizeof(struct vm_area_struct *),
1124
+
GFP_KERNEL);
1125
+
if (!vmas)
1126
+
return -ENOMEM;
1127
+
}
1128
+
1129
+
rc = get_user_pages(start, nr_pages, gup_flags, pages, vmas);
1130
+
1131
+
for (i = 0; i < rc; i++) {
1132
+
struct vm_area_struct *vma = vmas[i];
1133
+
1134
+
if (vma == vma_prev)
1135
+
continue;
1136
+
1137
+
vma_prev = vma;
1138
+
1139
+
if (vma_is_fsdax(vma))
1140
+
break;
1141
+
}
1142
+
1143
+
/*
1144
+
* Either get_user_pages() failed, or the vma validation
1145
+
* succeeded, in either case we don't need to put_page() before
1146
+
* returning.
1147
+
*/
1148
+
if (i >= rc)
1149
+
goto out;
1150
+
1151
+
for (i = 0; i < rc; i++)
1152
+
put_page(pages[i]);
1153
+
rc = -EOPNOTSUPP;
1154
+
out:
1155
+
if (vmas != vmas_arg)
1156
+
kfree(vmas);
1157
+
return rc;
1158
+
}
1159
+
EXPORT_SYMBOL(get_user_pages_longterm);
1160
+
#endif /* CONFIG_FS_DAX */
1097
1161
1098
1162
/**
1099
1163
* populate_vma_page_range() - populate a range of pages in the vma.
+4
-4
mm/hmm.c
+4
-4
mm/hmm.c
···
391
391
if (pmd_protnone(pmd))
392
392
return hmm_vma_walk_clear(start, end, walk);
393
393
394
-
if (write_fault && !pmd_write(pmd))
394
+
if (!pmd_access_permitted(pmd, write_fault))
395
395
return hmm_vma_walk_clear(start, end, walk);
396
396
397
397
pfn = pmd_pfn(pmd) + pte_index(addr);
398
-
flag |= pmd_write(pmd) ? HMM_PFN_WRITE : 0;
398
+
flag |= pmd_access_permitted(pmd, WRITE) ? HMM_PFN_WRITE : 0;
399
399
for (; addr < end; addr += PAGE_SIZE, i++, pfn++)
400
400
pfns[i] = hmm_pfn_t_from_pfn(pfn) | flag;
401
401
return 0;
···
456
456
continue;
457
457
}
458
458
459
-
if (write_fault && !pte_write(pte))
459
+
if (!pte_access_permitted(pte, write_fault))
460
460
goto fault;
461
461
462
462
pfns[i] = hmm_pfn_t_from_pfn(pte_pfn(pte)) | flag;
463
-
pfns[i] |= pte_write(pte) ? HMM_PFN_WRITE : 0;
463
+
pfns[i] |= pte_access_permitted(pte, WRITE) ? HMM_PFN_WRITE : 0;
464
464
continue;
465
465
466
466
fault:
+3
-3
mm/huge_memory.c
+3
-3
mm/huge_memory.c
···
870
870
*/
871
871
WARN_ONCE(flags & FOLL_COW, "mm: In follow_devmap_pmd with FOLL_COW set");
872
872
873
-
if (flags & FOLL_WRITE && !pmd_write(*pmd))
873
+
if (!pmd_access_permitted(*pmd, flags & FOLL_WRITE))
874
874
return NULL;
875
875
876
876
if (pmd_present(*pmd) && pmd_devmap(*pmd))
···
1012
1012
1013
1013
assert_spin_locked(pud_lockptr(mm, pud));
1014
1014
1015
-
if (flags & FOLL_WRITE && !pud_write(*pud))
1015
+
if (!pud_access_permitted(*pud, flags & FOLL_WRITE))
1016
1016
return NULL;
1017
1017
1018
1018
if (pud_present(*pud) && pud_devmap(*pud))
···
1386
1386
*/
1387
1387
static inline bool can_follow_write_pmd(pmd_t pmd, unsigned int flags)
1388
1388
{
1389
-
return pmd_write(pmd) ||
1389
+
return pmd_access_permitted(pmd, WRITE) ||
1390
1390
((flags & FOLL_FORCE) && (flags & FOLL_COW) && pmd_dirty(pmd));
1391
1391
}
1392
1392
+11
-1
mm/hugetlb.c
+11
-1
mm/hugetlb.c
···
3125
3125
}
3126
3126
}
3127
3127
3128
+
static int hugetlb_vm_op_split(struct vm_area_struct *vma, unsigned long addr)
3129
+
{
3130
+
if (addr & ~(huge_page_mask(hstate_vma(vma))))
3131
+
return -EINVAL;
3132
+
return 0;
3133
+
}
3134
+
3128
3135
/*
3129
3136
* We cannot handle pagefaults against hugetlb pages at all. They cause
3130
3137
* handle_mm_fault() to try to instantiate regular-sized pages in the
···
3148
3141
.fault = hugetlb_vm_op_fault,
3149
3142
.open = hugetlb_vm_op_open,
3150
3143
.close = hugetlb_vm_op_close,
3144
+
.split = hugetlb_vm_op_split,
3151
3145
};
3152
3146
3153
3147
static pte_t make_huge_pte(struct vm_area_struct *vma, struct page *page,
···
4635
4627
pte_t *pte = NULL;
4636
4628
4637
4629
pgd = pgd_offset(mm, addr);
4638
-
p4d = p4d_offset(pgd, addr);
4630
+
p4d = p4d_alloc(mm, pgd, addr);
4631
+
if (!p4d)
4632
+
return NULL;
4639
4633
pud = pud_alloc(mm, p4d, addr);
4640
4634
if (pud) {
4641
4635
if (sz == PUD_SIZE) {
+2
mm/kmemleak.c
+2
mm/kmemleak.c
+1
-3
mm/madvise.c
+1
-3
mm/madvise.c
···
276
276
{
277
277
struct file *file = vma->vm_file;
278
278
279
+
*prev = vma;
279
280
#ifdef CONFIG_SWAP
280
281
if (!file) {
281
-
*prev = vma;
282
282
force_swapin_readahead(vma, start, end);
283
283
return 0;
284
284
}
285
285
286
286
if (shmem_mapping(file->f_mapping)) {
287
-
*prev = vma;
288
287
force_shm_swapin_readahead(vma, start, end,
289
288
file->f_mapping);
290
289
return 0;
···
298
299
return 0;
299
300
}
300
301
301
-
*prev = vma;
302
302
start = ((start - vma->vm_start) >> PAGE_SHIFT) + vma->vm_pgoff;
303
303
if (end > vma->vm_end)
304
304
end = vma->vm_end;
+1
-1
mm/memcontrol.c
+1
-1
mm/memcontrol.c
+4
-4
mm/memory.c
+4
-4
mm/memory.c
···
3948
3948
if (unlikely(!pte_same(*vmf->pte, entry)))
3949
3949
goto unlock;
3950
3950
if (vmf->flags & FAULT_FLAG_WRITE) {
3951
-
if (!pte_write(entry))
3951
+
if (!pte_access_permitted(entry, WRITE))
3952
3952
return do_wp_page(vmf);
3953
3953
entry = pte_mkdirty(entry);
3954
3954
}
···
4013
4013
4014
4014
/* NUMA case for anonymous PUDs would go here */
4015
4015
4016
-
if (dirty && !pud_write(orig_pud)) {
4016
+
if (dirty && !pud_access_permitted(orig_pud, WRITE)) {
4017
4017
ret = wp_huge_pud(&vmf, orig_pud);
4018
4018
if (!(ret & VM_FAULT_FALLBACK))
4019
4019
return ret;
···
4046
4046
if (pmd_protnone(orig_pmd) && vma_is_accessible(vma))
4047
4047
return do_huge_pmd_numa_page(&vmf, orig_pmd);
4048
4048
4049
-
if (dirty && !pmd_write(orig_pmd)) {
4049
+
if (dirty && !pmd_access_permitted(orig_pmd, WRITE)) {
4050
4050
ret = wp_huge_pmd(&vmf, orig_pmd);
4051
4051
if (!(ret & VM_FAULT_FALLBACK))
4052
4052
return ret;
···
4336
4336
goto out;
4337
4337
pte = *ptep;
4338
4338
4339
-
if ((flags & FOLL_WRITE) && !pte_write(pte))
4339
+
if (!pte_access_permitted(pte, flags & FOLL_WRITE))
4340
4340
goto unlock;
4341
4341
4342
4342
*prot = pgprot_val(pte_pgprot(pte));
+5
-3
mm/mmap.c
+5
-3
mm/mmap.c
···
2555
2555
struct vm_area_struct *new;
2556
2556
int err;
2557
2557
2558
-
if (is_vm_hugetlb_page(vma) && (addr &
2559
-
~(huge_page_mask(hstate_vma(vma)))))
2560
-
return -EINVAL;
2558
+
if (vma->vm_ops && vma->vm_ops->split) {
2559
+
err = vma->vm_ops->split(vma, addr);
2560
+
if (err)
2561
+
return err;
2562
+
}
2561
2563
2562
2564
new = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL);
2563
2565
if (!new)
+4
-3
mm/oom_kill.c
+4
-3
mm/oom_kill.c
···
550
550
*/
551
551
set_bit(MMF_UNSTABLE, &mm->flags);
552
552
553
-
tlb_gather_mmu(&tlb, mm, 0, -1);
554
553
for (vma = mm->mmap ; vma; vma = vma->vm_next) {
555
554
if (!can_madv_dontneed_vma(vma))
556
555
continue;
···
564
565
* we do not want to block exit_mmap by keeping mm ref
565
566
* count elevated without a good reason.
566
567
*/
567
-
if (vma_is_anonymous(vma) || !(vma->vm_flags & VM_SHARED))
568
+
if (vma_is_anonymous(vma) || !(vma->vm_flags & VM_SHARED)) {
569
+
tlb_gather_mmu(&tlb, mm, vma->vm_start, vma->vm_end);
568
570
unmap_page_range(&tlb, vma, vma->vm_start, vma->vm_end,
569
571
NULL);
572
+
tlb_finish_mmu(&tlb, vma->vm_start, vma->vm_end);
573
+
}
570
574
}
571
-
tlb_finish_mmu(&tlb, 0, -1);
572
575
pr_info("oom_reaper: reaped process %d (%s), now anon-rss:%lukB, file-rss:%lukB, shmem-rss:%lukB\n",
573
576
task_pid_nr(tsk), tsk->comm,
574
577
K(get_mm_counter(mm, MM_ANONPAGES)),
+1
-4
mm/page-writeback.c
+1
-4
mm/page-writeback.c
···
433
433
else
434
434
bg_thresh = (bg_ratio * available_memory) / PAGE_SIZE;
435
435
436
-
if (unlikely(bg_thresh >= thresh)) {
437
-
pr_warn("vm direct limit must be set greater than background limit.\n");
436
+
if (bg_thresh >= thresh)
438
437
bg_thresh = thresh / 2;
439
-
}
440
-
441
438
tsk = current;
442
439
if (tsk->flags & PF_LESS_THROTTLE || rt_task(tsk)) {
443
440
bg_thresh += bg_thresh / 4 + global_wb_domain.dirty_limit / 32;
+8
-5
mm/page_alloc.c
+8
-5
mm/page_alloc.c
···
2507
2507
if (WARN_ON_ONCE(!mm_percpu_wq))
2508
2508
return;
2509
2509
2510
-
/* Workqueues cannot recurse */
2511
-
if (current->flags & PF_WQ_WORKER)
2512
-
return;
2513
-
2514
2510
/*
2515
2511
* Do not drain if one is already in progress unless it's specific to
2516
2512
* a zone. Such callers are primarily CMA and memory hotplug and need
···
7652
7656
7653
7657
/*
7654
7658
* In case of -EBUSY, we'd like to know which page causes problem.
7655
-
* So, just fall through. We will check it in test_pages_isolated().
7659
+
* So, just fall through. test_pages_isolated() has a tracepoint
7660
+
* which will report the busy page.
7661
+
*
7662
+
* It is possible that busy pages could become available before
7663
+
* the call to test_pages_isolated, and the range will actually be
7664
+
* allocated. So, if we fall through be sure to clear ret so that
7665
+
* -EBUSY is not accidentally used or returned to caller.
7656
7666
*/
7657
7667
ret = __alloc_contig_migrate_range(&cc, start, end);
7658
7668
if (ret && ret != -EBUSY)
7659
7669
goto done;
7670
+
ret =0;
7660
7671
7661
7672
/*
7662
7673
* Pages from [start, end) are within a MAX_ORDER_NR_PAGES
+5
-2
scripts/bloat-o-meter
+5
-2
scripts/bloat-o-meter
···
83
83
for d, n in delta:
84
84
if d: print("%-40s %7s %7s %+7d" % (n, old.get(n,"-"), new.get(n,"-"), d))
85
85
86
-
print("Total: Before=%d, After=%d, chg %+.2f%%" % \
87
-
(otot, ntot, (ntot - otot)*100.0/otot))
86
+
if otot:
87
+
percent = (ntot - otot) * 100.0 / otot
88
+
else:
89
+
percent = 0
90
+
print("Total: Before=%d, After=%d, chg %+.2f%%" % (otot, ntot, percent))
88
91
89
92
if sys.argv[1] == "-c":
90
93
print_result("Function", "tT", 3)
+14
-7
scripts/faddr2line
+14
-7
scripts/faddr2line
···
44
44
set -o errexit
45
45
set -o nounset
46
46
47
+
READELF="${CROSS_COMPILE}readelf"
48
+
ADDR2LINE="${CROSS_COMPILE}addr2line"
49
+
SIZE="${CROSS_COMPILE}size"
50
+
NM="${CROSS_COMPILE}nm"
51
+
47
52
command -v awk >/dev/null 2>&1 || die "awk isn't installed"
48
-
command -v readelf >/dev/null 2>&1 || die "readelf isn't installed"
49
-
command -v addr2line >/dev/null 2>&1 || die "addr2line isn't installed"
53
+
command -v ${READELF} >/dev/null 2>&1 || die "readelf isn't installed"
54
+
command -v ${ADDR2LINE} >/dev/null 2>&1 || die "addr2line isn't installed"
55
+
command -v ${SIZE} >/dev/null 2>&1 || die "size isn't installed"
56
+
command -v ${NM} >/dev/null 2>&1 || die "nm isn't installed"
50
57
51
58
usage() {
52
59
echo "usage: faddr2line <object file> <func+offset> <func+offset>..." >&2
···
76
69
find_dir_prefix() {
77
70
local objfile=$1
78
71
79
-
local start_kernel_addr=$(readelf -sW $objfile | awk '$8 == "start_kernel" {printf "0x%s", $2}')
72
+
local start_kernel_addr=$(${READELF} -sW $objfile | awk '$8 == "start_kernel" {printf "0x%s", $2}')
80
73
[[ -z $start_kernel_addr ]] && return
81
74
82
-
local file_line=$(addr2line -e $objfile $start_kernel_addr)
75
+
local file_line=$(${ADDR2LINE} -e $objfile $start_kernel_addr)
83
76
[[ -z $file_line ]] && return
84
77
85
78
local prefix=${file_line%init/main.c:*}
···
111
104
112
105
# Go through each of the object's symbols which match the func name.
113
106
# In rare cases there might be duplicates.
114
-
file_end=$(size -Ax $objfile | awk '$1 == ".text" {print $2}')
107
+
file_end=$(${SIZE} -Ax $objfile | awk '$1 == ".text" {print $2}')
115
108
while read symbol; do
116
109
local fields=($symbol)
117
110
local sym_base=0x${fields[0]}
···
163
156
164
157
# pass real address to addr2line
165
158
echo "$func+$offset/$sym_size:"
166
-
addr2line -fpie $objfile $addr | sed "s; $dir_prefix\(\./\)*; ;"
159
+
${ADDR2LINE} -fpie $objfile $addr | sed "s; $dir_prefix\(\./\)*; ;"
167
160
DONE=1
168
161
169
-
done < <(nm -n $objfile | awk -v fn=$func -v end=$file_end '$3 == fn { found=1; line=$0; start=$1; next } found == 1 { found=0; print line, "0x"$1 } END {if (found == 1) print line, end; }')
162
+
done < <(${NM} -n $objfile | awk -v fn=$func -v end=$file_end '$3 == fn { found=1; line=$0; start=$1; next } found == 1 { found=0; print line, "0x"$1 } END {if (found == 1) print line, end; }')
170
163
}
171
164
172
165
[[ $# -lt 2 ]] && usage