From: Sasha Levin Date: Sun, 14 Feb 2021 18:31:57 +0000 (-0500) Subject: Fixes for 4.4 X-Git-Tag: v5.4.99~32 X-Git-Url: http://git.ipfire.org/?a=commitdiff_plain;h=91c85fcfb871b53fa2cb57c77b10cfe350ef2fb5;p=thirdparty%2Fkernel%2Fstable-queue.git Fixes for 4.4 Signed-off-by: Sasha Levin --- diff --git a/queue-4.4/memblock-do-not-start-bottom-up-allocations-with-ker.patch b/queue-4.4/memblock-do-not-start-bottom-up-allocations-with-ker.patch new file mode 100644 index 00000000000..e6c7dbcac72 --- /dev/null +++ b/queue-4.4/memblock-do-not-start-bottom-up-allocations-with-ker.patch @@ -0,0 +1,146 @@ +From e851bae8bfddd8146437f131109113436be219ba Mon Sep 17 00:00:00 2001 +From: Sasha Levin +Date: Thu, 4 Feb 2021 18:32:36 -0800 +Subject: memblock: do not start bottom-up allocations with kernel_end + +From: Roman Gushchin + +[ Upstream commit 2dcb3964544177c51853a210b6ad400de78ef17d ] + +With kaslr the kernel image is placed at a random place, so starting the +bottom-up allocation with the kernel_end can result in an allocation +failure and a warning like this one: + + hugetlb_cma: reserve 2048 MiB, up to 2048 MiB per node + ------------[ cut here ]------------ + memblock: bottom-up allocation failed, memory hotremove may be affected + WARNING: CPU: 0 PID: 0 at mm/memblock.c:332 memblock_find_in_range_node+0x178/0x25a + Modules linked in: + CPU: 0 PID: 0 Comm: swapper Not tainted 5.10.0+ #1169 + Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.14.0-1.fc33 04/01/2014 + RIP: 0010:memblock_find_in_range_node+0x178/0x25a + Code: e9 6d ff ff ff 48 85 c0 0f 85 da 00 00 00 80 3d 9b 35 df 00 00 75 15 48 c7 c7 c0 75 59 88 c6 05 8b 35 df 00 01 e8 25 8a fa ff <0f> 0b 48 c7 44 24 20 ff ff ff ff 44 89 e6 44 89 ea 48 c7 c1 70 5c + RSP: 0000:ffffffff88803d18 EFLAGS: 00010086 ORIG_RAX: 0000000000000000 + RAX: 0000000000000000 RBX: 0000000240000000 RCX: 00000000ffffdfff + RDX: 00000000ffffdfff RSI: 00000000ffffffea RDI: 0000000000000046 + RBP: 0000000100000000 R08: ffffffff88922788 R09: 0000000000009ffb + R10: 00000000ffffe000 R11: 3fffffffffffffff R12: 0000000000000000 + R13: 0000000000000000 R14: 0000000080000000 R15: 00000001fb42c000 + FS: 0000000000000000(0000) GS:ffffffff88f71000(0000) knlGS:0000000000000000 + CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 + CR2: ffffa080fb401000 CR3: 00000001fa80a000 CR4: 00000000000406b0 + Call Trace: + memblock_alloc_range_nid+0x8d/0x11e + cma_declare_contiguous_nid+0x2c4/0x38c + hugetlb_cma_reserve+0xdc/0x128 + flush_tlb_one_kernel+0xc/0x20 + native_set_fixmap+0x82/0xd0 + flat_get_apic_id+0x5/0x10 + register_lapic_address+0x8e/0x97 + setup_arch+0x8a5/0xc3f + start_kernel+0x66/0x547 + load_ucode_bsp+0x4c/0xcd + secondary_startup_64_no_verify+0xb0/0xbb + random: get_random_bytes called from __warn+0xab/0x110 with crng_init=0 + ---[ end trace f151227d0b39be70 ]--- + +At the same time, the kernel image is protected with memblock_reserve(), +so we can just start searching at PAGE_SIZE. In this case the bottom-up +allocation has the same chances to success as a top-down allocation, so +there is no reason to fallback in the case of a failure. All together it +simplifies the logic. + +Link: https://lkml.kernel.org/r/20201217201214.3414100-2-guro@fb.com +Fixes: 8fabc623238e ("powerpc: Ensure that swiotlb buffer is allocated from low memory") +Signed-off-by: Roman Gushchin +Reviewed-by: Mike Rapoport +Cc: Joonsoo Kim +Cc: Michal Hocko +Cc: Rik van Riel +Cc: Wonhyuk Yang +Cc: Thiago Jung Bauermann +Signed-off-by: Andrew Morton +Signed-off-by: Linus Torvalds +Signed-off-by: Sasha Levin +--- + mm/memblock.c | 49 ++++++------------------------------------------- + 1 file changed, 6 insertions(+), 43 deletions(-) + +diff --git a/mm/memblock.c b/mm/memblock.c +index f8fab45bfdb75..ff51a37eb86be 100644 +--- a/mm/memblock.c ++++ b/mm/memblock.c +@@ -189,14 +189,6 @@ __memblock_find_range_top_down(phys_addr_t start, phys_addr_t end, + * + * Find @size free area aligned to @align in the specified range and node. + * +- * When allocation direction is bottom-up, the @start should be greater +- * than the end of the kernel image. Otherwise, it will be trimmed. The +- * reason is that we want the bottom-up allocation just near the kernel +- * image so it is highly likely that the allocated memory and the kernel +- * will reside in the same node. +- * +- * If bottom-up allocation failed, will try to allocate memory top-down. +- * + * RETURNS: + * Found address on success, 0 on failure. + */ +@@ -204,8 +196,6 @@ phys_addr_t __init_memblock memblock_find_in_range_node(phys_addr_t size, + phys_addr_t align, phys_addr_t start, + phys_addr_t end, int nid, ulong flags) + { +- phys_addr_t kernel_end, ret; +- + /* pump up @end */ + if (end == MEMBLOCK_ALLOC_ACCESSIBLE) + end = memblock.current_limit; +@@ -213,40 +203,13 @@ phys_addr_t __init_memblock memblock_find_in_range_node(phys_addr_t size, + /* avoid allocating the first page */ + start = max_t(phys_addr_t, start, PAGE_SIZE); + end = max(start, end); +- kernel_end = __pa_symbol(_end); +- +- /* +- * try bottom-up allocation only when bottom-up mode +- * is set and @end is above the kernel image. +- */ +- if (memblock_bottom_up() && end > kernel_end) { +- phys_addr_t bottom_up_start; +- +- /* make sure we will allocate above the kernel */ +- bottom_up_start = max(start, kernel_end); + +- /* ok, try bottom-up allocation first */ +- ret = __memblock_find_range_bottom_up(bottom_up_start, end, +- size, align, nid, flags); +- if (ret) +- return ret; +- +- /* +- * we always limit bottom-up allocation above the kernel, +- * but top-down allocation doesn't have the limit, so +- * retrying top-down allocation may succeed when bottom-up +- * allocation failed. +- * +- * bottom-up allocation is expected to be fail very rarely, +- * so we use WARN_ONCE() here to see the stack trace if +- * fail happens. +- */ +- WARN_ONCE(1, "memblock: bottom-up allocation failed, " +- "memory hotunplug may be affected\n"); +- } +- +- return __memblock_find_range_top_down(start, end, size, align, nid, +- flags); ++ if (memblock_bottom_up()) ++ return __memblock_find_range_bottom_up(start, end, size, align, ++ nid, flags); ++ else ++ return __memblock_find_range_top_down(start, end, size, align, ++ nid, flags); + } + + /** +-- +2.27.0 + diff --git a/queue-4.4/series b/queue-4.4/series index 6f0b2c40a7e..5470862edad 100644 --- a/queue-4.4/series +++ b/queue-4.4/series @@ -11,3 +11,4 @@ memcg-fix-a-crash-in-wb_workfn-when-a-device-disappe.patch squashfs-add-more-sanity-checks-in-id-lookup.patch squashfs-add-more-sanity-checks-in-inode-lookup.patch squashfs-add-more-sanity-checks-in-xattr-id-lookup.patch +memblock-do-not-start-bottom-up-allocations-with-ker.patch