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 Morton)
Merge fixes from Andrew Morton:
"10 fixes"
* emailed patches from Andrew Morton <akpm@linux-foundation.org>:
Josh has moved
kexec: export free_huge_page to VMCOREINFO
mm: fix filemap.c pagecache_get_page() kernel-doc warnings
mm: debugfs: move rounddown_pow_of_two() out from do_fault path
memcg: oom_notify use-after-free fix
hwpoison: call action_result() in failure path of hwpoison_user_mappings()
hwpoison: fix hugetlbfs/thp precheck in hwpoison_user_mappings()
rapidio/tsi721_dma: fix failure to obtain transaction descriptor
mm, thp: do not allow thp faults to avoid cpuset restrictions
mm/page-writeback.c: fix divide by zero in bdi_dirty_limits()
+69
-36
+5
.mailmap
+5
.mailmap
···
62
62
Jens Axboe <axboe@suse.de>
63
63
Jens Osterkamp <Jens.Osterkamp@de.ibm.com>
64
64
John Stultz <johnstul@us.ibm.com>
65
+
<josh@joshtriplett.org> <josh@freedesktop.org>
66
+
<josh@joshtriplett.org> <josh@kernel.org>
67
+
<josh@joshtriplett.org> <josht@linux.vnet.ibm.com>
68
+
<josh@joshtriplett.org> <josht@us.ibm.com>
69
+
<josh@joshtriplett.org> <josht@vnet.ibm.com>
65
70
Juha Yrjola <at solidboot.com>
66
71
Juha Yrjola <juha.yrjola@nokia.com>
67
72
Juha Yrjola <juha.yrjola@solidboot.com>
+4
-3
CREDITS
+4
-3
CREDITS
···
3511
3511
S: Australia
3512
3512
3513
3513
N: Josh Triplett
3514
-
E: josh@freedesktop.org
3515
-
P: 1024D/D0FE7AFB B24A 65C9 1D71 2AC2 DE87 CA26 189B 9946 D0FE 7AFB
3516
-
D: rcutorture maintainer
3514
+
E: josh@joshtriplett.org
3515
+
P: 4096R/8AFF873D 758E 5042 E397 4BA3 3A9C 1E67 0ED9 A3DF 8AFF 873D
3516
+
D: RCU and rcutorture
3517
3517
D: lock annotations, finding and fixing lock bugs
3518
+
D: kernel tinification
3518
3519
3519
3520
N: Winfried Trümper
3520
3521
E: winni@xpilot.org
+1
-1
MAINTAINERS
+1
-1
MAINTAINERS
···
7424
7424
F: drivers/net/wireless/ray*
7425
7425
7426
7426
RCUTORTURE MODULE
7427
-
M: Josh Triplett <josh@freedesktop.org>
7427
+
M: Josh Triplett <josh@joshtriplett.org>
7428
7428
M: "Paul E. McKenney" <paulmck@linux.vnet.ibm.com>
7429
7429
L: linux-kernel@vger.kernel.org
7430
7430
S: Supported
+7
-1
drivers/rapidio/devices/tsi721_dma.c
+7
-1
drivers/rapidio/devices/tsi721_dma.c
···
287
287
"desc %p not ACKed\n", tx_desc);
288
288
}
289
289
290
+
if (ret == NULL) {
291
+
dev_dbg(bdma_chan->dchan.device->dev,
292
+
"%s: unable to obtain tx descriptor\n", __func__);
293
+
goto err_out;
294
+
}
295
+
290
296
i = bdma_chan->wr_count_next % bdma_chan->bd_num;
291
297
if (i == bdma_chan->bd_num - 1) {
292
298
i = 0;
···
303
297
tx_desc->txd.phys = bdma_chan->bd_phys +
304
298
i * sizeof(struct tsi721_dma_desc);
305
299
tx_desc->hw_desc = &((struct tsi721_dma_desc *)bdma_chan->bd_base)[i];
306
-
300
+
err_out:
307
301
spin_unlock_bh(&bdma_chan->lock);
308
302
309
303
return ret;
+1
include/linux/hugetlb.h
+1
include/linux/hugetlb.h
···
80
80
bool isolate_huge_page(struct page *page, struct list_head *list);
81
81
void putback_active_hugepage(struct page *page);
82
82
bool is_hugepage_active(struct page *page);
83
+
void free_huge_page(struct page *page);
83
84
84
85
#ifdef CONFIG_ARCH_WANT_HUGE_PMD_SHARE
85
86
pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud);
+2
kernel/kexec.c
+2
kernel/kexec.c
···
33
33
#include <linux/swap.h>
34
34
#include <linux/syscore_ops.h>
35
35
#include <linux/compiler.h>
36
+
#include <linux/hugetlb.h>
36
37
37
38
#include <asm/page.h>
38
39
#include <asm/uaccess.h>
···
1620
1619
#endif
1621
1620
VMCOREINFO_NUMBER(PG_head_mask);
1622
1621
VMCOREINFO_NUMBER(PAGE_BUDDY_MAPCOUNT_VALUE);
1622
+
VMCOREINFO_SYMBOL(free_huge_page);
1623
1623
1624
1624
arch_crash_save_vmcoreinfo();
1625
1625
update_vmcoreinfo_note();
+2
-2
kernel/rcu/rcutorture.c
+2
-2
kernel/rcu/rcutorture.c
···
18
18
* Copyright (C) IBM Corporation, 2005, 2006
19
19
*
20
20
* Authors: Paul E. McKenney <paulmck@us.ibm.com>
21
-
* Josh Triplett <josh@freedesktop.org>
21
+
* Josh Triplett <josh@joshtriplett.org>
22
22
*
23
23
* See also: Documentation/RCU/torture.txt
24
24
*/
···
51
51
#include <linux/torture.h>
52
52
53
53
MODULE_LICENSE("GPL");
54
-
MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com> and Josh Triplett <josh@freedesktop.org>");
54
+
MODULE_AUTHOR("Paul E. McKenney <paulmck@us.ibm.com> and Josh Triplett <josh@joshtriplett.org>");
55
55
56
56
57
57
torture_param(int, fqs_duration, 0,
+8
-5
mm/filemap.c
+8
-5
mm/filemap.c
···
1031
1031
* @mapping: the address_space to search
1032
1032
* @offset: the page index
1033
1033
* @fgp_flags: PCG flags
1034
-
* @gfp_mask: gfp mask to use if a page is to be allocated
1034
+
* @cache_gfp_mask: gfp mask to use for the page cache data page allocation
1035
+
* @radix_gfp_mask: gfp mask to use for radix tree node allocation
1035
1036
*
1036
1037
* Looks up the page cache slot at @mapping & @offset.
1037
1038
*
1038
-
* PCG flags modify how the page is returned
1039
+
* PCG flags modify how the page is returned.
1039
1040
*
1040
1041
* FGP_ACCESSED: the page will be marked accessed
1041
1042
* FGP_LOCK: Page is return locked
1042
1043
* FGP_CREAT: If page is not present then a new page is allocated using
1043
-
* @gfp_mask and added to the page cache and the VM's LRU
1044
-
* list. The page is returned locked and with an increased
1045
-
* refcount. Otherwise, %NULL is returned.
1044
+
* @cache_gfp_mask and added to the page cache and the VM's LRU
1045
+
* list. If radix tree nodes are allocated during page cache
1046
+
* insertion then @radix_gfp_mask is used. The page is returned
1047
+
* locked and with an increased refcount. Otherwise, %NULL is
1048
+
* returned.
1046
1049
*
1047
1050
* If FGP_LOCK or FGP_CREAT are specified then the function may sleep even
1048
1051
* if the GFP flags specified for FGP_CREAT are atomic.
+1
-1
mm/hugetlb.c
+1
-1
mm/hugetlb.c
+4
mm/memcontrol.c
+4
mm/memcontrol.c
···
5415
5415
{
5416
5416
struct mem_cgroup_eventfd_list *ev;
5417
5417
5418
+
spin_lock(&memcg_oom_lock);
5419
+
5418
5420
list_for_each_entry(ev, &memcg->oom_notify, list)
5419
5421
eventfd_signal(ev->eventfd, 1);
5422
+
5423
+
spin_unlock(&memcg_oom_lock);
5420
5424
return 0;
5421
5425
}
5422
5426
+11
-3
mm/memory-failure.c
+11
-3
mm/memory-failure.c
···
895
895
struct page *hpage = *hpagep;
896
896
struct page *ppage;
897
897
898
-
if (PageReserved(p) || PageSlab(p) || !PageLRU(p))
898
+
/*
899
+
* Here we are interested only in user-mapped pages, so skip any
900
+
* other types of pages.
901
+
*/
902
+
if (PageReserved(p) || PageSlab(p))
903
+
return SWAP_SUCCESS;
904
+
if (!(PageLRU(hpage) || PageHuge(p)))
899
905
return SWAP_SUCCESS;
900
906
901
907
/*
···
911
905
if (!page_mapped(hpage))
912
906
return SWAP_SUCCESS;
913
907
914
-
if (PageKsm(p))
908
+
if (PageKsm(p)) {
909
+
pr_err("MCE %#lx: can't handle KSM pages.\n", pfn);
915
910
return SWAP_FAIL;
911
+
}
916
912
917
913
if (PageSwapCache(p)) {
918
914
printk(KERN_ERR
···
1237
1229
*/
1238
1230
if (hwpoison_user_mappings(p, pfn, trapno, flags, &hpage)
1239
1231
!= SWAP_SUCCESS) {
1240
-
printk(KERN_ERR "MCE %#lx: cannot unmap page, give up\n", pfn);
1232
+
action_result(pfn, "unmapping failed", IGNORED);
1241
1233
res = -EBUSY;
1242
1234
goto out;
1243
1235
}
+12
-9
mm/memory.c
+12
-9
mm/memory.c
···
2758
2758
update_mmu_cache(vma, address, pte);
2759
2759
}
2760
2760
2761
-
static unsigned long fault_around_bytes = 65536;
2761
+
static unsigned long fault_around_bytes = rounddown_pow_of_two(65536);
2762
2762
2763
-
/*
2764
-
* fault_around_pages() and fault_around_mask() round down fault_around_bytes
2765
-
* to nearest page order. It's what do_fault_around() expects to see.
2766
-
*/
2767
2763
static inline unsigned long fault_around_pages(void)
2768
2764
{
2769
-
return rounddown_pow_of_two(fault_around_bytes) / PAGE_SIZE;
2765
+
return fault_around_bytes >> PAGE_SHIFT;
2770
2766
}
2771
2767
2772
2768
static inline unsigned long fault_around_mask(void)
2773
2769
{
2774
-
return ~(rounddown_pow_of_two(fault_around_bytes) - 1) & PAGE_MASK;
2770
+
return ~(fault_around_bytes - 1) & PAGE_MASK;
2775
2771
}
2776
-
2777
2772
2778
2773
#ifdef CONFIG_DEBUG_FS
2779
2774
static int fault_around_bytes_get(void *data, u64 *val)
···
2777
2782
return 0;
2778
2783
}
2779
2784
2785
+
/*
2786
+
* fault_around_pages() and fault_around_mask() expects fault_around_bytes
2787
+
* rounded down to nearest page order. It's what do_fault_around() expects to
2788
+
* see.
2789
+
*/
2780
2790
static int fault_around_bytes_set(void *data, u64 val)
2781
2791
{
2782
2792
if (val / PAGE_SIZE > PTRS_PER_PTE)
2783
2793
return -EINVAL;
2784
-
fault_around_bytes = val;
2794
+
if (val > PAGE_SIZE)
2795
+
fault_around_bytes = rounddown_pow_of_two(val);
2796
+
else
2797
+
fault_around_bytes = PAGE_SIZE; /* rounddown_pow_of_two(0) is undefined */
2785
2798
return 0;
2786
2799
}
2787
2800
DEFINE_SIMPLE_ATTRIBUTE(fault_around_bytes_fops,
+3
-3
mm/page-writeback.c
+3
-3
mm/page-writeback.c
···
1306
1306
*bdi_thresh = bdi_dirty_limit(bdi, dirty_thresh);
1307
1307
1308
1308
if (bdi_bg_thresh)
1309
-
*bdi_bg_thresh = div_u64((u64)*bdi_thresh *
1310
-
background_thresh,
1311
-
dirty_thresh);
1309
+
*bdi_bg_thresh = dirty_thresh ? div_u64((u64)*bdi_thresh *
1310
+
background_thresh,
1311
+
dirty_thresh) : 0;
1312
1312
1313
1313
/*
1314
1314
* In order to avoid the stacked BDI deadlock we need
+8
-8
mm/page_alloc.c
+8
-8
mm/page_alloc.c
···
2447
2447
gfp_to_alloc_flags(gfp_t gfp_mask)
2448
2448
{
2449
2449
int alloc_flags = ALLOC_WMARK_MIN | ALLOC_CPUSET;
2450
-
const gfp_t wait = gfp_mask & __GFP_WAIT;
2450
+
const bool atomic = !(gfp_mask & (__GFP_WAIT | __GFP_NO_KSWAPD));
2451
2451
2452
2452
/* __GFP_HIGH is assumed to be the same as ALLOC_HIGH to save a branch. */
2453
2453
BUILD_BUG_ON(__GFP_HIGH != (__force gfp_t) ALLOC_HIGH);
···
2456
2456
* The caller may dip into page reserves a bit more if the caller
2457
2457
* cannot run direct reclaim, or if the caller has realtime scheduling
2458
2458
* policy or is asking for __GFP_HIGH memory. GFP_ATOMIC requests will
2459
-
* set both ALLOC_HARDER (!wait) and ALLOC_HIGH (__GFP_HIGH).
2459
+
* set both ALLOC_HARDER (atomic == true) and ALLOC_HIGH (__GFP_HIGH).
2460
2460
*/
2461
2461
alloc_flags |= (__force int) (gfp_mask & __GFP_HIGH);
2462
2462
2463
-
if (!wait) {
2463
+
if (atomic) {
2464
2464
/*
2465
-
* Not worth trying to allocate harder for
2466
-
* __GFP_NOMEMALLOC even if it can't schedule.
2465
+
* Not worth trying to allocate harder for __GFP_NOMEMALLOC even
2466
+
* if it can't schedule.
2467
2467
*/
2468
-
if (!(gfp_mask & __GFP_NOMEMALLOC))
2468
+
if (!(gfp_mask & __GFP_NOMEMALLOC))
2469
2469
alloc_flags |= ALLOC_HARDER;
2470
2470
/*
2471
-
* Ignore cpuset if GFP_ATOMIC (!wait) rather than fail alloc.
2472
-
* See also cpuset_zone_allowed() comment in kernel/cpuset.c.
2471
+
* Ignore cpuset mems for GFP_ATOMIC rather than fail, see the
2472
+
* comment for __cpuset_node_allowed_softwall().
2473
2473
*/
2474
2474
alloc_flags &= ~ALLOC_CPUSET;
2475
2475
} else if (unlikely(rt_task(current)) && !in_interrupt())