kexec: Enable CMA based contiguous allocation
Subsystems (4)
Alexander Graf
reviewerPATCH v2 1/1 kexec: Enable CMA based contiguous allocation
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.
---
v1 -> v2:
- Clarify patch description
- Move cma pointer out of kexec_segment. That is a sneaky UAPI struct we can not modify. Fixes non kexec_file path
- Coding style
- Move memset(0) to only clear remainder
- Move kexec_alloc_contig() into kexec_locate_mem_hole(). Makes the code flow easier to read.
- Sanitize return values
--- arch/riscv/kernel/elf_kexec.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/elf_kexec.c +1 -0
@@ -109,6 +109,7 @@ static int elf_find_pbase(struct kimage *image, unsigned long kernel_len, kbuf.mem =KEXEC_BUF_MEM_UNKNOWN ; kbuf.memsz =ALIGN (kernel_len,PAGE_SIZE ); kbuf.top_down = false; + kbuf.cma =NULL ; ret =arch_kexec_locate_mem_hole (&kbuf);if (!ret) { *old_pbase = lowest_paddr;
include/linux/kexec.h +10 -0
@@ -75,6 +75,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
@@ -169,6 +175,7 @@ int kexec_image_post_load_cleanup_default(struct kimage *image);* @buf_min: The buffer can't be placed below this address. * @buf_max: The buffer can't be placed above this address. * @top_down: Allocate from top of memory. +* @cma: CMA page if the buffer is backed by CMA. */ struct kexec_buf {struct kimage *image;
@@ -180,6 +187,7 @@ struct kexec_buf {unsigned long buf_min;unsigned long buf_max;bool top_down; +struct page *cma; };int kexec_load_purgatory (struct kimage *image,struct kexec_buf *kbuf);
@@ -310,6 +318,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;
@@ -331,6 +340,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 +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 +1 -1
@@ -152,7 +152,7 @@ static int do_kexec_load(unsigned long entry, unsigned long nr_segments, 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 +92 -8
156 lines not on this page · raw message
kernel/kexec_file.c +50 -1
93 lines not on this page · raw message
kernel/kexec_internal.h +1 -1
@@ -10,7 +10,7 @@ struct kimage *do_kimage_alloc_init(void);int 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);
Signature · 12 lines
2.34.1 Amazon Web Services Development Center Germany GmbH Tamara-Danz-Str. 13 10243 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 257764 B Sitz: Berlin Ust-ID: DE 365 538 597