kexec-enable-cma-based-contiguous-allocation.patch removed from -mm tree
The quilt patch titled
Subject: kexec: enable CMA based contiguous allocation
has been removed from the -mm tree. Its filename was
kexec-enable-cma-based-contiguous-allocation.patch
This patch was dropped because it was merged into the mm-nonmm-stable branch of git://git.kernel.org/pub/scm/linux/kernel/git/akpm/mm
------------------------------------------------------
From: Alexander Graf <[email protected]>
Subject: kexec: enable CMA based contiguous allocation
Date: Tue, 10 Jun 2025 08:53:27 +0000
When booting a new kernel with kexec_file, the kernel picks a target location that the kernel should live at, then allocates random pages, checks whether any of those patches magically happens to coincide with a target address range and if so, uses them for that range.
For every page allocated this way, it then creates a page list that the relocation code - code that executes while all CPUs are off and we are just about to jump into the new kernel - copies to their final memory location. We can not put them there before, because chances are pretty good that at least some page in the target range is already in use by the currently running Linux environment. Copying is happening from a single CPU at RAM rate, which takes around 4-50 ms per 100 MiB.
All of this is inefficient and error prone.
To successfully kexec, we need to quiesce all devices of the outgoing kernel so they don't scribble over the new kernel's memory. We have seen cases where that does not happen properly (*cough* GIC *cough*) and hence the new kernel was corrupted. This started a month long journey to root cause failing kexecs to eventually see memory corruption, because the new kernel was corrupted severely enough that it could not emit output to tell us about the fact that it was corrupted. By allocating memory for the next kernel from a memory range that is guaranteed scribbling free, we can boot the next kernel up to a point where it is at least able to detect corruption and maybe even stop it before it becomes severe. This increases the chance for successful kexecs.
Since kexec got introduced, Linux has gained the CMA framework which can perform physically contiguous memory mappings, while keeping that memory available for movable memory when it is not needed for contiguous allocations. The default CMA allocator is for DMA allocations.
This patch adds logic to the kexec file loader to attempt to place the target payload at a location allocated from CMA. If successful, it uses that memory range directly instead of creating copy instructions during the hot phase. To ensure that there is a safety net in case anything goes wrong with the CMA allocation, it also adds a flag for user space to force disable CMA allocations.
Using CMA allocations has two advantages:
1) Faster by 4-50 ms per 100 MiB. There is no more need to copy in the hot phase.
2) More robust. Even if by accident some page is still in use for DMA, the new kernel image will be safe from that access because it resides in a memory region that is considered allocated in the old kernel and has a chance to reinitialize that component.
---
arch/riscv/kernel/kexec_elf.c | 1 include/linux/kexec.h | 10 +++ include/uapi/linux/kexec.h | 1 kernel/kexec.c | 2 kernel/kexec_core.c | 100 +++++++++++++++++++++++++++++--- kernel/kexec_file.c | 51 ++++++++++++++++ kernel/kexec_internal.h | 2 7 files changed, 156 insertions(+), 11 deletions(-)
arch/riscv/kernel/kexec_elf.c renamed from arch/riscv/kernel/kexec_elf.c~kexec-enable-cma-based-contiguous-allocation +1 -0
@@ -95,6 +95,7 @@ static int elf_find_pbase(struct kimage kbuf.buf_align =PMD_SIZE ; kbuf.mem =KEXEC_BUF_MEM_UNKNOWN ; kbuf.memsz =ALIGN (kernel_len,PAGE_SIZE ); + kbuf.cma =NULL ; kbuf.top_down = false; ret =arch_kexec_locate_mem_hole (&kbuf);if (!ret) {
include/linux/kexec.h renamed from include/linux/kexec.h~kexec-enable-cma-based-contiguous-allocation +10 -0
@@ -79,6 +79,12 @@ extern note_buf_t __percpu *crash_notes;typedef unsigned long kimage_entry_t ; +/* +* This is a copy of the UAPI struct kexec_segment and must be identical +* to it because it gets copied straight from user space into kernel +* memory. Do not modify this structure unless you change the way segments +* get ingested from user space. +*/ struct kexec_segment {/* * This pointer can point to user memory if kexec_load() system
@@ -172,6 +178,7 @@ int kexec_image_post_load_cleanup_defaul* @buf_align: Minimum alignment needed. * @buf_min: The buffer can't be placed below this address. * @buf_max: The buffer can't be placed above this address. +* @cma: CMA page if the buffer is backed by CMA. * @top_down: Allocate from top of memory. * @random: Place the buffer at a random position. */
@@ -184,6 +191,7 @@ struct kexec_buf {unsigned long buf_align;unsigned long buf_min;unsigned long buf_max; +struct page *cma;bool top_down;#ifdef CONFIG_CRASH_DUMP bool random;
@@ -340,6 +348,7 @@ struct kimage {unsigned long nr_segments;struct kexec_segment segment[KEXEC_SEGMENT_MAX ]; +struct page *segment_cma[KEXEC_SEGMENT_MAX ];struct list_head control_pages;struct list_head dest_pages;
@@ -361,6 +370,7 @@ struct kimage {*/ unsigned int hotplug_support:1;#endif + unsigned int no_cma:1;#ifdef ARCH_HAS_KIMAGE_ARCH struct kimage_arch arch;
include/uapi/linux/kexec.h renamed from include/uapi/linux/kexec.h~kexec-enable-cma-based-contiguous-allocation +1 -0
@@ -27,6 +27,7 @@#define KEXEC_FILE_ON_CRASH 0x00000002#define KEXEC_FILE_NO_INITRAMFS 0x00000004#define KEXEC_FILE_DEBUG 0x00000008 +#define KEXEC_FILE_NO_CMA 0x00000010/* These values match the ELF architecture values. * Unless there is a good reason that should continue to be the case.
kernel/kexec.c renamed from kernel/kexec.c~kexec-enable-cma-based-contiguous-allocation +1 -1
@@ -152,7 +152,7 @@ static int do_kexec_load(unsigned long e goto out;for (i =0 ; i < nr_segments; i++) { - ret =kimage_load_segment (image, &image->segment[i]); + ret =kimage_load_segment (image, i);if (ret) goto out; }
kernel/kexec_core.c renamed from kernel/kexec_core.c~kexec-enable-cma-based-contiguous-allocation +92 -8
156 lines not on this page · raw message
kernel/kexec_file.c renamed from kernel/kexec_file.c~kexec-enable-cma-based-contiguous-allocation +50 -1
93 lines not on this page · raw message
kernel/kexec_internal.h renamed from kernel/kexec_internal.h~kexec-enable-cma-based-contiguous-allocation +1 -1
@@ -10,7 +10,7 @@ struct kimage *do_kimage_alloc_init(voidint sanity_check_segment_list (struct kimage *image);void kimage_free_page_list (struct list_head *list);void kimage_free (struct kimage *image); -int kimage_load_segment (struct kimage *image,struct kexec_segment *segment); +int kimage_load_segment (struct kimage *image,int idx);void kimage_terminate (struct kimage *image);int kimage_is_destination_range (struct kimage *image,unsigned long start,unsigned long end);
_
Patches currently in -mm which might be from [email protected] are