kexec: Allow preservation of ftrace buffers
Subsystems (14)
Alexander Graf
reviewerv2 cover kexec: Allow preservation of ftrace buffers
Kexec today considers itself purely a boot loader: When we enter the new kernel, any state the previous kernel left behind is irrelevant and the new kernel reinitializes the system.
However, there are use cases where this mode of operation is not what we actually want. In virtualization hosts for example, we want to use kexec to update the host kernel while virtual machine memory stays untouched. When we add device assignment to the mix, we also need to ensure that IOMMU and VFIO states are untouched. If we add PCIe peer to peer DMA, we need to do the same for the PCI subsystem. If we want to kexec while an SEV-SNP enabled virtual machine is running, we need to preserve the VM context pages and physical memory. See James' and my Linux Plumbers Conference 2023 presentation for details:
https://lpc.events/event/17/contributions/1485/
To start us on the journey to support all the use cases above, this patch implements basic infrastructure to allow hand over of kernel state across kexec (Kexec HandOver, aka KHO). As example target, we use ftrace:
With this patch set applied, you can read ftrace records from the pre-kexec environment in your post-kexec one. This creates a very powerful debugging and performance analysis tool for kexec. It's also slightly easier to reason about than full blown VFIO state preservation.
== Alternatives ==
There are alternative approaches to (parts of) the problems above:
* Memory Pools [1] - preallocated persistent memory region + allocator
* PRMEM [2] - resizable persistent memory regions with fixed metadata pointer on the kernel command line + allocator
* Pkernfs [3] - preallocated file system for in-kernel data with fixed address location on the kernel command line
* PKRAM [4] - handover of user space pages using a fixed metadata page specified via command line
All of the approaches above fundamentally have the same problem: They require the administrator to explicitly carve out a physical memory location because they have no mechanism outside of the kernel command line to pass data (including memory reservations) between kexec'ing kernels.
KHO provides that base foundation. We will determine later whether we still need any of the approaches above for fast bulk memory handover of for example IOMMU page tables. But IMHO they would all be users of KHO, with KHO providing the foundational primitive to pass metadata and bulk memory reservations as well as provide easy versioning for data.
== Documentation ==
If people are happy with the approach in this patch set, I will write up conclusive documentation including schemas for the metadata as part of its next iteration. For now, here's a rudimentary overview:
We introduce a metadata file that the kernels pass between each other. How they pass it is architecture specific. The file's format is a Flattened Device Tree (fdt) which has a generator and parser already included in Linux. When the root user enables KHO through /sys/kernel/kho/active, the kernel invokes callbacks to every driver that supports KHO to serialize its state. When the actual kexec happens, the fdt is part of the image set that we boot into. In addition, we keep a "scratch region" available for kexec: A physically contiguous memory region that is guaranteed to not have any memory that KHO would preserve. The new kernel bootstraps itself using the scratch region and sets all handed over memory as in use. When drivers initialize that support KHO, they introspect the fdt and recover their state from it. This includes memory reservations, where the driver can either discard or claim reservations.
== Limitations ==
I currently only implemented file based kexec. The kernel interfaces in the patch set are already in place to support user space kexec as well, but I have not implemented it yet.
== How to Use ==
To use the code, please boot the kernel with the "kho_scratch=" command line parameter set: "kho_scratch=512M". KHO requires a scratch region.
Make sure to fill ftrace with contents that you want to observe after kexec. Then, before you invoke file based "kexec -l", activate KHO:
# echo 1 > /sys/kernel/kho/active # kexec -l Image --initrd=initrd -s # kexec -e
The new kernel will boot up and contain the previous kernel's trace buffers in /sys/kernel/debug/tracing/trace.
== Changelog ==
v1 -> v2:
- Removed: tracing: Introduce names for ring buffers
- Removed: tracing: Introduce names for events
- New: kexec: Add config option for KHO
- New: kexec: Add documentation for KHO
- New: tracing: Initialize fields before registering
- New: devicetree: Add bindings for ftrace KHO
- test bot warning fixes
- Change kconfig option to ARCH_SUPPORTS_KEXEC_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- s/kho_reserve/kho_reserve_scratch/g
- Remove / reduce ifdefs
- Select crc32
- Leave anything that requires a name in trace.c to keep buffers unnamed entities
- Put events as array into a property, use fingerprint instead of names to identify them
- Reduce footprint without CONFIG_FTRACE_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- make kho_get_fdt() const
- Add stubs for return_mem and claim_mem
- make kho_get_fdt() const
- Get events as array from a property, use fingerprint instead of names to identify events
- Change kconfig option to ARCH_SUPPORTS_KEXEC_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- s/kho_reserve/kho_reserve_scratch/g
- Leave the node generation code that needs to know the name in trace.c so that ring buffers can stay anonymous
- s/kho_reserve/kho_reserve_scratch/g
- Move kho enums out of ifdef
- Move from names to fdt offsets. That way, trace.c can find the trace array offset and then the ring buffer code only needs to read out its per-CPU data. That way it can stay oblivient to its name.
- Make kho_get_fdt() const
Alex
[1] https://lore.kernel.org/all/169645773092.11424.7258549771090599226.stgit@skinsburskii./
[2] https://lore.kernel.org/all/[email protected]/
[3] https://lpc.events/event/17/contributions/1485/attachments/1296/2650/jgowans-preserving-across-kexec.pdf
[4] https://lore.kernel.org/kexec/[email protected]/
Alexander Graf (17):
mm,memblock: Add support for scratch memory
memblock: Declare scratch memory as CMA
kexec: Add Kexec HandOver (KHO) generation helpers
kexec: Add KHO parsing support
kexec: Add KHO support to kexec file loads
kexec: Add config option for KHO
kexec: Add documentation for KHO
arm64: Add KHO support
x86: Add KHO support
tracing: Initialize fields before registering
tracing: Introduce kho serialization
tracing: Add kho serialization of trace buffers
tracing: Recover trace buffers from kexec handover
tracing: Add kho serialization of trace events
tracing: Recover trace events from kexec handover
tracing: Add config option for kexec handover
devicetree: Add bindings for ftrace KHO
Documentation/ABI/testing/sysfs-firmware-kho | 9 + Documentation/ABI/testing/sysfs-kernel-kho | 53 ++ .../admin-guide/kernel-parameters.txt | 10 + .../bindings/kho/ftrace/ftrace-array.yaml | 46 ++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 ++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++ Documentation/kho/concepts.rst | 88 +++ Documentation/kho/index.rst | 19 + Documentation/kho/usage.rst | 57 ++ Documentation/subsystem-apis.rst | 1 + MAINTAINERS | 2 + arch/arm64/Kconfig | 3 + arch/arm64/kernel/setup.c | 2 + arch/arm64/mm/init.c | 8 + arch/x86/Kconfig | 3 + arch/x86/boot/compressed/kaslr.c | 55 ++ arch/x86/include/uapi/asm/bootparam.h | 15 +- arch/x86/kernel/e820.c | 9 + arch/x86/kernel/kexec-bzimage64.c | 39 ++ arch/x86/kernel/setup.c | 46 ++ arch/x86/mm/init_32.c | 7 + arch/x86/mm/init_64.c | 7 + drivers/of/fdt.c | 39 ++ drivers/of/kexec.c | 54 ++ include/linux/kexec.h | 58 ++ include/linux/memblock.h | 19 + include/linux/ring_buffer.h | 17 +- include/linux/trace_events.h | 1 + include/uapi/linux/kexec.h | 6 + kernel/Kconfig.kexec | 13 + kernel/Makefile | 2 + kernel/kexec_file.c | 41 ++ kernel/kexec_kho_in.c | 298 ++++++++++ kernel/kexec_kho_out.c | 526 ++++++++++++++++++ kernel/trace/Kconfig | 14 + kernel/trace/ring_buffer.c | 243 +++++++- kernel/trace/trace.c | 96 +++- kernel/trace/trace_events.c | 14 +- kernel/trace/trace_events_synth.c | 14 +- kernel/trace/trace_events_user.c | 4 + kernel/trace/trace_output.c | 246 +++++++- kernel/trace/trace_output.h | 5 + kernel/trace/trace_probe.c | 4 + mm/Kconfig | 4 + mm/memblock.c | 83 ++- 45 files changed, 2360 insertions(+), 24 deletions(-) create mode 100644 Documentation/ABI/testing/sysfs-firmware-kho create mode 100644 Documentation/ABI/testing/sysfs-kernel-kho create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml create mode 100644 Documentation/kho/concepts.rst create mode 100644 Documentation/kho/index.rst create mode 100644 Documentation/kho/usage.rst create mode 100644 kernel/kexec_kho_in.c create mode 100644 kernel/kexec_kho_out.c
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 1/17 mm,memblock: Add support for scratch memory
With KHO (Kexec HandOver), we need a way to ensure that the new kernel does not allocate memory on top of any memory regions that the previous kernel was handing over. But to know where those are, we need to include them in the reserved memblocks array which may not be big enough to hold all allocations. To resize the array, we need to allocate memory. That brings us into a catch 22 situation.
The solution to that is the scratch region: a safe region to operate in. KHO provides a "scratch region" as part of its metadata. This scratch region is a single, contiguous memory block that we know does not contain any KHO allocations. We can exclusively allocate from there until we finish kernel initialization to a point where it knows about all the KHO memory reservations. We introduce a new memblock_set_scratch_only() function that allows KHO to indicate that any memblock allocation must happen from the scratch region.
Later, we may want to perform another KHO kexec. For that, we reuse the same scratch region. To ensure that no eventually handed over data gets allocated inside that scratch region, we flip the semantics of the scratch region with memblock_clear_scratch_only(): After that call, no allocations may happen from scratch memblock regions. We will lift that restriction in the next patch.
--- include/linux/memblock.h | 19 +++++++++++++ mm/Kconfig | 4 +++ mm/memblock.c | 61 +++++++++++++++++++++++++++++++++++++++- 3 files changed, 83 insertions(+), 1 deletion(-)
include/linux/memblock.h +19 -0
@@ -42,6 +42,10 @@ extern unsigned long long max_possible_pfn;* kernel resource tree. * @MEMBLOCK_RSRV_NOINIT: memory region for which struct pages are * not initialized (only for reserved regions). +* @MEMBLOCK_SCRATCH: memory region that kexec can pass to the next kernel in +* handover mode. During early boot, we do not know about all memory reservations +* yet, so we get scratch memory from the previous kernel that we know is good +* to use. It is the only memory that allocations may happen from in this phase. */ enum memblock_flags {MEMBLOCK_NONE =0x0 ,/* No special request */
@@ -50,6 +54,7 @@ enum memblock_flags {MEMBLOCK_NOMAP =0x4 ,/* don't add to kernel direct mapping */ MEMBLOCK_DRIVER_MANAGED =0x8 ,/* always detected via a driver */ MEMBLOCK_RSRV_NOINIT =0x10 ,/* don't initialize struct pages */ + MEMBLOCK_SCRATCH = 0x20, /* scratch memory for kexec handover */ };/**
@@ -129,6 +134,8 @@ int memblock_mark_mirror(phys_addr_t base, phys_addr_t size);int memblock_mark_nomap (phys_addr_t base,phys_addr_t size);int memblock_clear_nomap (phys_addr_t base,phys_addr_t size);int memblock_reserved_mark_noinit (phys_addr_t base,phys_addr_t size); +int memblock_mark_scratch (phys_addr_t base,phys_addr_t size); +int memblock_clear_scratch (phys_addr_t base,phys_addr_t size);void memblock_free_all (void );void memblock_free (void *ptr,size_t size);
@@ -273,6 +280,11 @@ static inline bool memblock_is_driver_managed(struct memblock_region *m)return m->flags &MEMBLOCK_DRIVER_MANAGED ; } +static inline bool memblock_is_scratch (struct memblock_region *m) +{ +return m->flags &MEMBLOCK_SCRATCH ; +} +int memblock_search_pfn_nid (unsigned long pfn,unsigned long *start_pfn,unsigned long *end_pfn); void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
@@ -610,5 +622,12 @@ static inline void early_memtest(phys_addr_t start, phys_addr_t end) { }static inline void memtest_report_meminfo (struct seq_file *m) { }#endif +#ifdef CONFIG_MEMBLOCK_SCRATCH +void memblock_set_scratch_only (void ); +void memblock_clear_scratch_only (void ); +#else +static inline void memblock_set_scratch_only (void ) { } +static inline void memblock_clear_scratch_only (void ) { } +#endif #endif /* _LINUX_MEMBLOCK_H */
mm/Kconfig +4 -0
@@ -513,6 +513,10 @@ config ARCH_WANT_OPTIMIZE_HUGETLB_VMEMMAP config HAVE_MEMBLOCK_PHYS_MAP bool +# Enable memblock support for scratch memory which is needed for KHO +config MEMBLOCK_SCRATCH + bool + config HAVE_FAST_GUP depends on MMU bool
mm/memblock.c +60 -1
103 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 2/17 memblock: Declare scratch memory as CMA
In reply to Alexander GrafWhen we finish populating our memory, we don't want to lose the scratch region as memory we can use for useful data. Do do that, we mark it as CMA memory. That means that any allocation within it only happens with movable memory which we can then happily discard for the next kexec.
That way we don't lose the scratch region's memory anymore for allocations after boot.
---
v1 -> v2:
- test bot warning fix
--- mm/memblock.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-)
mm/memblock.c +26 -4
@@ -16,6 +16,7 @@#include <linux/kmemleak.h> #include <linux/seq_file.h> #include <linux/memblock.h> +#include <linux/page-isolation.h> #include <asm/sections.h> #include <linux/io.h>
@@ -1100,10 +1101,6 @@ static bool should_skip_region(struct memblock_type *type,if ((flags &MEMBLOCK_SCRATCH ) && !memblock_is_scratch (m))return true; -/* Leave scratch memory alone after scratch-only phase */ -if (!(flags &MEMBLOCK_SCRATCH ) &&memblock_is_scratch (m)) -return true; -return false; }
@@ -2153,6 +2150,20 @@ static void __init __free_pages_memory(unsigned long start, unsigned long end) } } +#ifdef CONFIG_MEMBLOCK_SCRATCH +static void reserve_scratch_mem (phys_addr_t start,phys_addr_t end) +{ +ulong start_pfn =pageblock_start_pfn (PFN_DOWN (start)); +ulong end_pfn =pageblock_align (PFN_UP (end)); +ulong pfn; + +for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) { +/* Mark as CMA to prevent kernel allocations in it */ +set_pageblock_migratetype (pfn_to_page (pfn),MIGRATE_CMA ); + } +} +#endif +static unsigned long __init __free_memory_core (phys_addr_t start,phys_addr_t end) {
@@ -2214,6 +2225,17 @@ static unsigned long __init free_low_memory_core_early(void)memmap_init_reserved_pages (); +#ifdef CONFIG_MEMBLOCK_SCRATCH +/* +* Mark scratch mem as CMA before we return it. That way we ensure that +* no kernel allocations happen on it. That means we can reuse it as +* scratch memory again later. +*/ +__for_each_mem_range (i, &memblock.memory,NULL ,NUMA_NO_NODE , +MEMBLOCK_SCRATCH , &start, &end,NULL ) +reserve_scratch_mem (start, end); +#endif +/* * We need to use NUMA_NO_NODE instead of NODE_DATA(0)->node_id * because in some case like Node0 doesn't have RAM installed
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 3/17 kexec: Add Kexec HandOver (KHO) generation helpers
In reply to Alexander GrafThis patch adds the core infrastructure to generate Kexec HandOver metadata. Kexec HandOver is a mechanism that allows Linux to preserve state - arbitrary properties as well as memory locations - across kexec.
It does so using 3 concepts:
1) Device Tree - Every KHO kexec carries a KHO specific flattened device tree blob that describes the state of the system. Device drivers can register to KHO to serialize their state before kexec.
2) Mem cache - A memblocks like structure that contains full page ranges of reservations. These can not be part of the architectural reservations, because they differ on every kexec.
3) Scratch Region - A CMA region that we allocate in the first kernel. CMA gives us the guarantee that no handover pages land in that region, because handover pages must be at a static physical memory location. We use this region as the place to load future kexec images into which then won't collide with any handover data.
---
v1 -> v2:
- s/kho_reserve/kho_reserve_scratch/g
- Move kho enums out of ifdef
--- Documentation/ABI/testing/sysfs-kernel-kho | 53 +++ .../admin-guide/kernel-parameters.txt | 10 + MAINTAINERS | 1 + include/linux/kexec.h | 24 ++ include/uapi/linux/kexec.h | 6 + kernel/Makefile | 1 + kernel/kexec_kho_out.c | 316 ++++++++++++++++++ 7 files changed, 411 insertions(+) create mode 100644 Documentation/ABI/testing/sysfs-kernel-kho create mode 100644 kernel/kexec_kho_out.c
Documentation/ABI/testing/sysfs-kernel-kho new file +53 -0
@@ -0,0 +1,53 @@ +What: /sys/kernel/kho/active +Date: December 2023 +Contact: Alexander Graf <[email protected]> +Description: + Kexec HandOver (KHO) allows Linux to transition the state of + compatible drivers into the next kexec'ed kernel. To do so, + device drivers will serialize their current state into a DT. + While the state is serialized, they are unable to perform + any modifications to state that was serialized, such as + handed over memory allocations. + + When this file contains "1", the system is in the transition + state. When contains "0", it is not. To switch between the + two states, echo the respective number into this file. + +What: /sys/kernel/kho/dt_max +Date: December 2023 +Contact: Alexander Graf <[email protected]> +Description: + KHO needs to allocate a buffer for the DT that gets + generated before it knows the final size. By default, it + will allocate 10 MiB for it. You can write to this file + to modify the size of that allocation. + +What: /sys/kernel/kho/scratch_len +Date: December 2023 +Contact: Alexander Graf <[email protected]> +Description: + To support continuous KHO kexecs, we need to reserve a + physically contiguous memory region that will always stay + available for future kexec allocations. This file describes + the length of that memory region. Kexec user space tooling + can use this to determine where it should place its payload + images. + +What: /sys/kernel/kho/scratch_phys +Date: December 2023 +Contact: Alexander Graf <[email protected]> +Description: + To support continuous KHO kexecs, we need to reserve a + physically contiguous memory region that will always stay + available for future kexec allocations. This file describes + the physical location of that memory region. Kexec user space + tooling can use this to determine where it should place its + payload images. + +What: /sys/kernel/kho/dt +Date: December 2023 +Contact: Alexander Graf <[email protected]> +Description: + When KHO is active, the kernel exposes the generated DT that + carries its current KHO state in this file. Kexec user space + tooling can use this as input file for the KHO payload image.
Documentation/admin-guide/kernel-parameters.txt +10 -0
@@ -2504,6 +2504,16 @@ kgdbwait [KGDB] Stop kernel execution and enter the kernel debugger at the earliest opportunity. + kho_scratch=n[KMG] [KEXEC] Sets the size of the KHO scratch + region. The KHO scratch region is a physically + memory range that can only be used for non-kernel + allocations. That way, even when memory is heavily + fragmented with handed over memory, kexec will always + be able to find contiguous memory to place the next + kernel for kexec into. + + The default is 0. + kmac= [MIPS] Korina ethernet MAC address. Configure the RouterBoard 532 series on-chip Ethernet adapter MAC address.
MAINTAINERS +1 -0
@@ -11713,6 +11713,7 @@ M: Eric Biederman <[email protected]> L: [email protected] S: Maintained W: http://kernel.org/pub/linux/utils/kernel/kexec/ +F: Documentation/ABI/testing/sysfs-kernel-kho F: include/linux/kexec.h F: include/uapi/linux/kexec.h F: kernel/kexec*
include/linux/kexec.h +24 -0
@@ -21,6 +21,8 @@#include <uapi/linux/kexec.h> #include <linux/verification.h> +#include <linux/libfdt.h> +#include <linux/notifier.h> extern note_buf_t __percpu *crash_notes;
@@ -516,6 +518,28 @@ void set_kexec_sig_enforced(void);static inline void set_kexec_sig_enforced (void ) {}#endif +/* Notifier index */ +enum kho_event { +KEXEC_KHO_DUMP =0 , +KEXEC_KHO_ABORT =1 , +}; + +#ifdef CONFIG_KEXEC_KHO +extern phys_addr_t kho_scratch_phys; +extern phys_addr_t kho_scratch_len; + +/* egest handover metadata */ +void kho_reserve_scratch (void ); +int register_kho_notifier (struct notifier_block *nb); +int unregister_kho_notifier (struct notifier_block *nb); +bool kho_is_active (void ); +#else +static inline void kho_reserve_scratch (void ) {} +static inline int register_kho_notifier (struct notifier_block *nb) {return -EINVAL ; } +static inline int unregister_kho_notifier (struct notifier_block *nb) {return -EINVAL ; } +static inline bool kho_is_active (void ) {return false; } +#endif +#endif /* !defined(__ASSEBMLY__) */ #endif /* LINUX_KEXEC_H */
include/uapi/linux/kexec.h +6 -0
@@ -49,6 +49,12 @@/* The artificial cap on the number of segments passed to kexec_load. */ #define KEXEC_SEGMENT_MAX 16 +/* KHO passes an array of kho_mem as "mem cache" to the new kernel */ +struct kho_mem { +__u64 addr; +__u64 len; +}; +#ifndef __KERNEL__/* * This structure is used to hold the arguments that are used when
kernel/Makefile +1 -0
@@ -73,6 +73,7 @@ obj-$(CONFIG_KEXEC_CORE) += kexec_core.o obj-$(CONFIG_KEXEC) += kexec.o obj-$(CONFIG_KEXEC_FILE) += kexec_file.o obj-$(CONFIG_KEXEC_ELF) += kexec_elf.o +obj-$(CONFIG_KEXEC_KHO) += kexec_kho_out.o obj-$(CONFIG_BACKTRACE_SELF_TEST) += backtracetest.o obj-$(CONFIG_COMPAT) += compat.o obj-$(CONFIG_CGROUPS) += cgroup/
kernel/kexec_kho_out.c new file +316 -0
316 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 4/17 kexec: Add KHO parsing support
In reply to Alexander GrafWhen we have a KHO kexec, we get a device tree, mem cache and scratch region to populate the state of the system. Provide helper functions that allow architecture code to easily handle memory reservations based on them and give device drivers visibility into the KHO DT and memory reservations so they can recover their own state.
---
v1 -> v2:
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- make kho_get_fdt() const
- Add stubs for return_mem and claim_mem
--- Documentation/ABI/testing/sysfs-firmware-kho | 9 + MAINTAINERS | 1 + include/linux/kexec.h | 27 +- kernel/Makefile | 1 + kernel/kexec_kho_in.c | 298 +++++++++++++++++++ 5 files changed, 335 insertions(+), 1 deletion(-) create mode 100644 Documentation/ABI/testing/sysfs-firmware-kho create mode 100644 kernel/kexec_kho_in.c
Documentation/ABI/testing/sysfs-firmware-kho new file +9 -0
@@ -0,0 +1,9 @@ +What: /sys/firmware/kho/dt +Date: December 2023 +Contact: Alexander Graf <[email protected]> +Description: + When the kernel was booted with Kexec HandOver (KHO), + the device tree that carries metadata about the previous + kernel's state is in this file. This file may disappear + when all consumers of it finished to interpret their + metadata.
MAINTAINERS +1 -0
@@ -11713,6 +11713,7 @@ M: Eric Biederman <[email protected]> L: [email protected] S: Maintained W: http://kernel.org/pub/linux/utils/kernel/kexec/ +F: Documentation/ABI/testing/sysfs-firmware-kho F: Documentation/ABI/testing/sysfs-kernel-kho F: include/linux/kexec.h F: include/uapi/linux/kexec.h
include/linux/kexec.h +26 -1
@@ -528,13 +528,38 @@ enum kho_event {extern phys_addr_t kho_scratch_phys;extern phys_addr_t kho_scratch_len; +/* ingest handover metadata */ +void kho_reserve_previous_mem (void ); +void kho_populate (phys_addr_t dt_phys,phys_addr_t scratch_phys,u64 scratch_len, +phys_addr_t mem_phys,u64 mem_len); +void kho_populate_refcount (void ); +const void *kho_get_fdt (void ); +void kho_return_mem (const struct kho_mem *mem); +void *kho_claim_mem (const struct kho_mem *mem); +static inline bool is_kho_boot (void ) +{ +return !!kho_scratch_phys; +} +/* egest handover metadata */ void kho_reserve_scratch (void );int register_kho_notifier (struct notifier_block *nb);int unregister_kho_notifier (struct notifier_block *nb);bool kho_is_active (void );#else -static inline void kho_reserve_scratch (void ) {} +/* ingest handover metadata */ +static inline void kho_reserve_previous_mem (void ) { } +static inline void kho_populate (phys_addr_t dt_phys,phys_addr_t scratch_phys, +u64 scratch_len,phys_addr_t mem_phys, +u64 mem_len) { } +static inline void kho_populate_refcount (void ) { } +static inline void *kho_get_fdt (void ) {return NULL ; } +static inline void kho_return_mem (const struct kho_mem *mem) { } +static inline void *kho_claim_mem (const struct kho_mem *mem) {return NULL ; } +static inline bool is_kho_boot (void ) {return false; } + +/* egest handover metadata */ +static inline void kho_reserve_scratch (void ) { }static inline int register_kho_notifier (struct notifier_block *nb) {return -EINVAL ; }static inline int unregister_kho_notifier (struct notifier_block *nb) {return -EINVAL ; }static inline bool kho_is_active (void ) {return false; }
kernel/Makefile +1 -0
@@ -73,6 +73,7 @@ obj-$(CONFIG_KEXEC_CORE) += kexec_core.o obj-$(CONFIG_KEXEC) += kexec.o obj-$(CONFIG_KEXEC_FILE) += kexec_file.o obj-$(CONFIG_KEXEC_ELF) += kexec_elf.o +obj-$(CONFIG_KEXEC_KHO) += kexec_kho_in.o obj-$(CONFIG_KEXEC_KHO) += kexec_kho_out.o obj-$(CONFIG_BACKTRACE_SELF_TEST) += backtracetest.o obj-$(CONFIG_COMPAT) += compat.o
kernel/kexec_kho_in.c new file +298 -0
298 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 5/17 kexec: Add KHO support to kexec file loads
In reply to Alexander GrafKexec has 2 modes: A user space driven mode and a kernel driven mode. For the kernel driven mode, kernel code determines the physical addresses of all target buffers that the payload gets copied into.
With KHO, we can only safely copy payloads into the "scratch area". Teach the kexec file loader about it, so it only allocates for that area. In addition, enlighten it with support to ask the KHO subsystem for its respective payloads to copy into target memory. Also teach the KHO subsystem how to fill the images for file loads.
--- include/linux/kexec.h | 9 ++ kernel/kexec_file.c | 41 ++++++++ kernel/kexec_kho_out.c | 210 +++++++++++++++++++++++++++++++++++++++++ 3 files changed, 260 insertions(+)
include/linux/kexec.h +9 -0
@@ -362,6 +362,13 @@ struct kimage {size_t ima_buffer_size;#endif +#ifdef CONFIG_KEXEC_KHO +struct { +struct kexec_buf dt; +struct kexec_buf mem_cache; + } kho; +#endif +/* Core ELF header buffer */ void *elf_headers;unsigned long elf_headers_sz;
@@ -543,6 +550,7 @@ static inline bool is_kho_boot(void)/* egest handover metadata */ void kho_reserve_scratch (void ); +int kho_fill_kimage (struct kimage *image);int register_kho_notifier (struct notifier_block *nb);int unregister_kho_notifier (struct notifier_block *nb);bool kho_is_active (void );
@@ -560,6 +568,7 @@ static inline bool is_kho_boot(void) { return false; }/* egest handover metadata */ static inline void kho_reserve_scratch (void ) { } +static inline int kho_fill_kimage (struct kimage *image) {return 0 ; }static inline int register_kho_notifier (struct notifier_block *nb) {return -EINVAL ; }static inline int unregister_kho_notifier (struct notifier_block *nb) {return -EINVAL ; }static inline bool kho_is_active (void ) {return false; }
kernel/kexec_file.c +41 -0
65 lines not on this page · raw message
kernel/kexec_kho_out.c +210 -0
216 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 6/17 kexec: Add config option for KHO
In reply to Alexander GrafWe have all generic code in place now to support Kexec with KHO. This patch adds a config option that depends on architecture support to enable KHO support.
--- kernel/Kconfig.kexec | 13 +++++++++++++ 1 file changed, 13 insertions(+)
kernel/Kconfig.kexec +13 -0
@@ -91,6 +91,19 @@ config KEXEC_JUMP Jump between original kernel and kexeced kernel and invoke code in physical address mode via KEXEC +config KEXEC_KHO + bool "kexec handover" + depends on ARCH_SUPPORTS_KEXEC_KHO + depends on KEXEC + select MEMBLOCK_SCRATCH + select LIBFDT + select CMA + help + Allow kexec to hand over state across kernels by generating and + passing additional metadata to the target kernel. This is useful + to keep data or state alive across the kexec. For this to work, + both source and target kernels need to have this option enabled. + config CRASH_DUMP bool "kernel crash dumps" depends on ARCH_SUPPORTS_CRASH_DUMP
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 7/17 kexec: Add documentation for KHO
In reply to Alexander GrafWith KHO in place, let's add documentation that describes what it is and how to use it.
--- Documentation/kho/concepts.rst | 88 ++++++++++++++++++++++++++++++++ Documentation/kho/index.rst | 19 +++++++ Documentation/kho/usage.rst | 57 +++++++++++++++++++++ Documentation/subsystem-apis.rst | 1 + 4 files changed, 165 insertions(+) create mode 100644 Documentation/kho/concepts.rst create mode 100644 Documentation/kho/index.rst create mode 100644 Documentation/kho/usage.rst
Documentation/kho/concepts.rst new file +88 -0
@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec. + +It introduces multiple concepts: + +KHO Device Tree +--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to +serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state. + +KHO only uses the fdt container format and libfdt library, but does not +adhere to the same property semantics that normal device trees do: Properties +are passed in native endianness and standardized properties like ``regs`` and +``ranges`` do not exist, hence there are no ``#...-cells`` properties. + +KHO introduces a new concept to its device tree: ``mem`` properties. A +``mem`` property can inside any subnode in the device tree. When present, +it contains an array of physical memory ranges that the new kernel must mark +as reserved on boot. It is recommended, but not required, to make these ranges +as physically contiguous as possible to reduce the number of array elements :: + + struct kho_mem { + __u64 addr; + __u64 len; + }; + +After boot, drivers can call the kho subsystem to transfer ownership of memory +that was reserved via a ``mem`` property to themselves to continue using memory +from the previous execution. + +The KHO device tree follows the in-Linux schema requirements. Any element in +the device tree is documented via device tree schema yamls that explain what +data gets transferred. + +Mem cache +--------- + +The new kernel needs to know about all memory reservations, but is unable to +parse the device tree yet in early bootup code because of memory limitations. +To simplify the initial memory reservation flow, the old kernel passes a +preprocessed array of physically contiguous reserved ranges to the new kernel. + +These reservations have to be separate from architectural memory maps and +reservations because they differ on every kexec, while the architectural ones +get passed directly between invocations. + +The less entries this cache contains, the faster the new kernel will boot. + +Scratch Region +-------------- + +To boot into kexec, we need to have a physically contiguous memory range that +contains no handed over memory. Kexec then places the target kernel and initrd +into that region. The new kernel exclusively uses this region for memory +allocations before it ingests the mem cache. + +We guarantee that we always have such a region through the scratch region: On +first boot, you can pass the ``kho_scratch`` kernel command line option. When +it is set, Linux allocates a CMA region of the given size. CMA gives us the +guarantee that no handover pages land in that region, because handover +pages must be at a static physical memory location and CMA enforces that +only movable pages can be located inside. + +After KHO kexec, we ignore the ``kho_scratch`` kernel command line option and +instead reuse the exact same region that was originally allocated. This allows +us to recursively execute any amount of KHO kexecs. Because we used this region +for boot memory allocations and as target memory for kexec blobs, some parts +of that memory region may be reserved. These reservations are irrenevant for +the next KHO, because kexec can overwrite even the original kernel. + +KHO active phase +---------------- + +To enable user space based kexec file loader, the kernel needs to be able to +provide the device tree that describes the previous kernel's state before +performing the actual kexec. The process of generating that device tree is +called serialization. When the device tree is generated, some properties +of the system may become immutable because they are already written down +in the device tree. That state is called the KHO active phase.
Documentation/kho/index.rst new file +19 -0
@@ -0,0 +1,19 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================== +Kexec Handover Subsystem +======================== + +.. toctree:: + :maxdepth: 1 + + concepts + usage + +.. only:: subproject and html + + + Indices + ======= + + * :ref:`genindex`
Documentation/kho/usage.rst new file +57 -0
57 lines not on this page · raw message
Documentation/subsystem-apis.rst +1 -0
@@ -86,3 +86,4 @@ Storage interfaces misc-devices/index peci/index wmi/index + kho/index
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 8/17 arm64: Add KHO support
In reply to Alexander GrafWe now have all bits in place to support KHO kexecs. This patch adds awareness of KHO in the kexec file as well as boot path for arm64 and adds the respective kconfig option to the architecture so that it can use KHO successfully.
---
v1 -> v2:
- test bot warning fix
- Change kconfig option to ARCH_SUPPORTS_KEXEC_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- s/kho_reserve/kho_reserve_scratch/g
- Remove / reduce ifdefs for kho fdt code
--- arch/arm64/Kconfig | 3 +++ arch/arm64/kernel/setup.c | 2 ++ arch/arm64/mm/init.c | 8 ++++++ drivers/of/fdt.c | 39 ++++++++++++++++++++++++++++ drivers/of/kexec.c | 54 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 106 insertions(+)
arch/arm64/Kconfig +3 -0
@@ -1495,6 +1495,9 @@ config ARCH_SUPPORTS_KEXEC_IMAGE_VERIFY_SIG config ARCH_DEFAULT_KEXEC_IMAGE_VERIFY_SIG def_bool y +config ARCH_SUPPORTS_KEXEC_KHO + def_bool y + config ARCH_SUPPORTS_CRASH_DUMP def_bool y
arch/arm64/kernel/setup.c +2 -0
@@ -346,6 +346,8 @@ void __init __no_sanitize_address setup_arch(char **cmdline_p)paging_init (); +kho_reserve_previous_mem (); +acpi_table_upgrade ();/* Parse the ACPI tables for possible boot-time configuration */
arch/arm64/mm/init.c +8 -0
@@ -358,6 +358,8 @@ void __init bootmem_init(void)*/ arch_reserve_crashkernel (); +kho_reserve_scratch (); +memblock_dump_all (); }
@@ -386,6 +388,12 @@ void __init mem_init(void)/* this will put all unused low memory onto the freelists */ memblock_free_all (); +/* +* Now that all KHO pages are marked as reserved, let's flip them back +* to normal pages with accurate refcount. +*/ +kho_populate_refcount (); +/* * Check boundaries twice: Some fundamental inconsistencies can be * detected at build time already.
drivers/of/fdt.c +39 -0
@@ -1006,6 +1006,42 @@ void __init early_init_dt_check_for_usable_mem_range(void)memblock_add (rgn[i].base, rgn[i].size); } +/** +* early_init_dt_check_kho - Decode info required for kexec handover from DT +*/ +static void __init early_init_dt_check_kho (void ) +{ +unsigned long node = chosen_node_offset; +u64 kho_start, scratch_start, scratch_size, mem_start, mem_size; +const __be32 *p; +int l; + +if (!IS_ENABLED (CONFIG_KEXEC_KHO ) || (long )node <0 ) +return ; + + p =of_get_flat_dt_prop (node,"linux,kho-dt" , &l); +if (l != (dt_root_addr_cells + dt_root_size_cells) *sizeof (__be32)) +return ; + + kho_start =dt_mem_next_cell (dt_root_addr_cells, &p); + + p =of_get_flat_dt_prop (node,"linux,kho-scratch" , &l); +if (l != (dt_root_addr_cells + dt_root_size_cells) *sizeof (__be32)) +return ; + + scratch_start =dt_mem_next_cell (dt_root_addr_cells, &p); + scratch_size =dt_mem_next_cell (dt_root_addr_cells, &p); + + p =of_get_flat_dt_prop (node,"linux,kho-mem" , &l); +if (l != (dt_root_addr_cells + dt_root_size_cells) *sizeof (__be32)) +return ; + + mem_start =dt_mem_next_cell (dt_root_addr_cells, &p); + mem_size =dt_mem_next_cell (dt_root_addr_cells, &p); + +kho_populate (kho_start, scratch_start, scratch_size, mem_start, mem_size); +} +#ifdef CONFIG_SERIAL_EARLYCON int __init early_init_dt_scan_chosen_stdout (void )
@@ -1304,6 +1340,9 @@ void __init early_init_dt_scan_nodes(void)/* Handle linux,usable-memory-range property */ early_init_dt_check_for_usable_mem_range (); + +/* Handle kexec handover */ +early_init_dt_check_kho (); }bool __init early_init_dt_scan (void *params)
drivers/of/kexec.c +54 -0
66 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 9/17 x86: Add KHO support
In reply to Alexander GrafWe now have all bits in place to support KHO kexecs. This patch adds awareness of KHO in the kexec file as well as boot path for x86 and adds the respective kconfig option to the architecture so that it can use KHO successfully.
In addition, it enlightens it decompression code with KHO so that its KASLR location finder only considers memory regions that are not already occupied by KHO memory.
---
v1 -> v2:
- Change kconfig option to ARCH_SUPPORTS_KEXEC_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- s/kho_reserve/kho_reserve_scratch/g
--- arch/x86/Kconfig | 3 ++ arch/x86/boot/compressed/kaslr.c | 55 +++++++++++++++++++++++++++ arch/x86/include/uapi/asm/bootparam.h | 15 +++++++- arch/x86/kernel/e820.c | 9 +++++ arch/x86/kernel/kexec-bzimage64.c | 39 +++++++++++++++++++ arch/x86/kernel/setup.c | 46 ++++++++++++++++++++++ arch/x86/mm/init_32.c | 7 ++++ arch/x86/mm/init_64.c | 7 ++++ 8 files changed, 180 insertions(+), 1 deletion(-)
arch/x86/Kconfig +3 -0
@@ -2094,6 +2094,9 @@ config ARCH_SUPPORTS_KEXEC_BZIMAGE_VERIFY_SIG config ARCH_SUPPORTS_KEXEC_JUMP def_bool y +config ARCH_SUPPORTS_KEXEC_KHO + def_bool y + config ARCH_SUPPORTS_CRASH_DUMP def_bool X86_64 || (X86_32 && HIGHMEM)
arch/x86/boot/compressed/kaslr.c +55 -0
67 lines not on this page · raw message
arch/x86/include/uapi/asm/bootparam.h +14 -1
@@ -13,7 +13,8 @@#define SETUP_CC_BLOB 7#define SETUP_IMA 8#define SETUP_RNG_SEED 9 -#define SETUP_ENUM_MAX SETUP_RNG_SEED +#define SETUP_KEXEC_KHO 10 +#define SETUP_ENUM_MAX SETUP_KEXEC_KHO#define SETUP_INDIRECT (1<<31)#define SETUP_TYPE_MAX (SETUP_ENUM_MAX | SETUP_INDIRECT)
@@ -181,6 +182,18 @@ struct ima_setup_data {__u64 size; } __attribute__((packed)); +/* +* Locations of kexec handover metadata +*/ +struct kho_data { +__u64 dt_addr; +__u64 dt_size; +__u64 scratch_addr; +__u64 scratch_size; +__u64 mem_cache_addr; +__u64 mem_cache_size; +} __attribute__((packed)); +/* The so-called "zeropage" */ struct boot_params {struct screen_info screen_info;/* 0x000 */
arch/x86/kernel/e820.c +9 -0
@@ -1341,6 +1341,15 @@ void __init e820__memblock_setup(void)continue ;memblock_add (entry->addr, entry->size); + +/* +* At this point with KHO we only allocate from scratch memory +* and only from memory below ISA_END_ADDRESS. Make sure that +* when we add memory for the eligible range, we add it as +* scratch memory so that we can resize the memblocks array. +*/ +if (is_kho_boot () && (end <=ISA_END_ADDRESS )) +memblock_mark_scratch (entry->addr, end); }/* Throw away partial pages: */
arch/x86/kernel/kexec-bzimage64.c +39 -0
@@ -15,6 +15,7 @@#include <linux/slab.h> #include <linux/kexec.h> #include <linux/kernel.h> +#include <linux/libfdt.h> #include <linux/mm.h> #include <linux/efi.h> #include <linux/random.h>
@@ -233,6 +234,33 @@ setup_ima_state(const struct kimage *image, struct boot_params *params,#endif /* CONFIG_IMA_KEXEC */ } +static void setup_kho (const struct kimage *image,struct boot_params *params, +unsigned long params_load_addr, +unsigned int setup_data_offset) +{ +#ifdef CONFIG_KEXEC_KHO +struct setup_data *sd = (void *)params + setup_data_offset; +struct kho_data *kho = (void *)sd +sizeof (*sd); + + sd->type =SETUP_KEXEC_KHO ; + sd->len =sizeof (struct kho_data ); + +/* Only add if we have all KHO images in place */ +if (!image->kho.dt.buffer || !image->kho.mem_cache.buffer) +return ; + +/* Add setup data */ + kho->dt_addr = image->kho.dt.mem; + kho->dt_size = image->kho.dt.bufsz; + kho->scratch_addr = kho_scratch_phys; + kho->scratch_size = kho_scratch_len; + kho->mem_cache_addr = image->kho.mem_cache.mem; + kho->mem_cache_size = image->kho.mem_cache.bufsz; + sd->next = params->hdr.setup_data; + params->hdr.setup_data = params_load_addr + setup_data_offset; +#endif /* CONFIG_KEXEC_KHO */ +} + static int setup_boot_parameters(struct kimage *image, struct boot_params *params, unsigned long params_load_addr,
@@ -305,6 +333,13 @@ setup_boot_parameters(struct kimage *image, struct boot_params *params,sizeof (struct ima_setup_data ); } +if (IS_ENABLED (CONFIG_KEXEC_KHO )) { +/* Setup space to store preservation metadata */ +setup_kho (image, params, params_load_addr, setup_data_offset); + setup_data_offset +=sizeof (struct setup_data ) + +sizeof (struct kho_data ); + } +/* Setup RNG seed */ setup_rng_seed (params, params_load_addr, setup_data_offset);
@@ -470,6 +505,10 @@ static void *bzImage64_load(struct kimage *image, char *kernel, kbuf.bufsz +=sizeof (struct setup_data ) +sizeof (struct ima_setup_data ); +if (IS_ENABLED (CONFIG_KEXEC_KHO )) + kbuf.bufsz +=sizeof (struct setup_data ) + +sizeof (struct kho_data ); + params =kzalloc (kbuf.bufsz,GFP_KERNEL );if (!params)return ERR_PTR (-ENOMEM );
arch/x86/kernel/setup.c +46 -0
72 lines not on this page · raw message
arch/x86/mm/init_32.c +7 -0
@@ -20,6 +20,7 @@#include <linux/smp.h> #include <linux/init.h> #include <linux/highmem.h> +#include <linux/kexec.h> #include <linux/pagemap.h> #include <linux/pci.h> #include <linux/pfn.h>
@@ -738,6 +739,12 @@ void __init mem_init(void) after_bootmem =1 ; x86_init.hyper.init_after_bootmem (); +/* +* Now that all KHO pages are marked as reserved, let's flip them back +* to normal pages with accurate refcount. +*/ +kho_populate_refcount (); +/* * Check boundaries twice: Some fundamental inconsistencies can * be detected at build time already.
arch/x86/mm/init_64.c +7 -0
@@ -20,6 +20,7 @@#include <linux/smp.h> #include <linux/init.h> #include <linux/initrd.h> +#include <linux/kexec.h> #include <linux/pagemap.h> #include <linux/memblock.h> #include <linux/proc_fs.h>
@@ -1339,6 +1340,12 @@ void __init mem_init(void) after_bootmem =1 ; x86_init.hyper.init_after_bootmem (); +/* +* Now that all KHO pages are marked as reserved, let's flip them back +* to normal pages with accurate refcount. +*/ +kho_populate_refcount (); +/* * Must be done after boot memory is put on freelist, because here we * might set fields in deferred struct pages that have not yet been
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 10/17 tracing: Initialize fields before registering
In reply to Alexander GrafWith KHO, we need to know all event fields before we allocate an event type for a trace event so that we can recover it based on a previous execution context.
Before this patch, fields were only initialized after we allocated a type id. After this patch, we try to allocate it early as well.
This patch leaves the old late initialization logic in place. The field init code already validates whether there are any fields present, which means it's legal to call it multiple times. This way we're sure we don't miss any call sites.
--- include/linux/trace_events.h | 1 + kernel/trace/trace_events.c | 14 +++++++++----- kernel/trace/trace_events_synth.c | 14 +++++++++----- kernel/trace/trace_events_user.c | 4 ++++ kernel/trace/trace_probe.c | 4 ++++ 5 files changed, 27 insertions(+), 10 deletions(-)
include/linux/trace_events.h +1 -0
@@ -842,6 +842,7 @@ extern int trace_define_field(struct trace_event_call *call, const char *type,extern int trace_add_event_call (struct trace_event_call *call);extern int trace_remove_event_call (struct trace_event_call *call);extern int trace_event_get_offsets (struct trace_event_call *call); +extern int trace_event_define_fields (struct trace_event_call *call);int ftrace_set_clr_event (struct trace_array *tr,char *buf,int set);int trace_set_clr_event (const char *system,const char *event,int set);
kernel/trace/trace_events.c +9 -5
@@ -462,6 +462,11 @@ static void test_event_printk(struct trace_event_call *call)int trace_event_raw_init (struct trace_event_call *call) {int id; +int ret; + + ret =trace_event_define_fields (call); +if (ret) +return ret; id =register_trace_event (&call->event);if (!id)
@@ -2402,8 +2407,7 @@ event_subsystem_dir(struct trace_array *tr, const char *name,return NULL ; } -static int -event_define_fields (struct trace_event_call *call) +int trace_event_define_fields (struct trace_event_call *call) {struct list_head *head;int ret =0 ;
@@ -2592,7 +2596,7 @@ event_create_dir(struct eventfs_inode *parent, struct trace_event_file *file) file->ei = ei; - ret =event_define_fields (call); + ret =trace_event_define_fields (call);if (ret <0 ) {pr_warn ("Could not initialize trace point events/%s\n" , name);return ret;
@@ -2978,7 +2982,7 @@ __trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)if (eventdir_initialized)return event_create_dir (tr->event_dir, file);else -return event_define_fields (call); +return trace_event_define_fields (call); }static void trace_early_triggers (struct trace_event_file *file,const char *name)
@@ -3015,7 +3019,7 @@ __trace_early_add_new_event(struct trace_event_call *call,if (!file)return -ENOMEM ; - ret =event_define_fields (call); + ret =trace_event_define_fields (call);if (ret)return ret;
kernel/trace/trace_events_synth.c +9 -5
@@ -880,17 +880,21 @@ static int register_synth_event(struct synth_event *event)INIT_LIST_HEAD (&call->class->fields); call->event.funcs = &synth_event_funcs; call->class->fields_array = synth_event_fields_array; + call->flags =TRACE_EVENT_FL_TRACEPOINT ; + call->class->reg = trace_event_reg; + call->class->probe = trace_event_raw_event_synth; + call->data = event; + call->tp = event->tp; + + ret =trace_event_define_fields (call); +if (ret) + goto out; ret =register_trace_event (&call->event);if (!ret) { ret = -ENODEV ; goto out; } - call->flags =TRACE_EVENT_FL_TRACEPOINT ; - call->class->reg = trace_event_reg; - call->class->probe = trace_event_raw_event_synth; - call->data = event; - call->tp = event->tp; ret =trace_add_event_call (call);if (ret) {
kernel/trace/trace_events_user.c +4 -0
@@ -1900,6 +1900,10 @@ static int user_event_trace_register(struct user_event *user) {int ret; + ret =trace_event_define_fields (&user->call); +if (ret) +return ret; + ret =register_trace_event (&user->call.event);if (!ret)
kernel/trace/trace_probe.c +4 -0
@@ -1835,6 +1835,10 @@ int trace_probe_register_event_call(struct trace_probe *tp) trace_probe_name(tp)))return -EEXIST ; + ret =trace_event_define_fields (call); +if (ret) +return ret; + ret =register_trace_event (&call->event);if (!ret)return -ENODEV ;
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 11/17 tracing: Introduce kho serialization
In reply to Alexander GrafWe want to be able to transfer ftrace state from one kernel to the next. To start off with, let's establish all the boiler plate to get a write hook when KHO wants to serialize and fill out basic data.
Follow-up patches will fill in serialization of ring buffers and events.
---
v1 -> v2:
- Remove ifdefs
--- kernel/trace/trace.c | 47 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)
kernel/trace/trace.c +47 -0
@@ -32,6 +32,7 @@#include <linux/percpu.h> #include <linux/splice.h> #include <linux/kdebug.h> +#include <linux/kexec.h> #include <linux/string.h> #include <linux/mount.h> #include <linux/rwsem.h>
@@ -866,6 +867,8 @@ static struct tracer *trace_types __read_mostly;*/ DEFINE_MUTEX (trace_types_lock); +static bool trace_in_kho; +/* * serialize the access of the ring buffer *
@@ -10560,12 +10563,56 @@ void __init early_trace_init(void)init_events (); } +static int trace_kho_notifier (struct notifier_block *self, +unsigned long cmd, +void *v) +{ +const char compatible[] ="ftrace-v1" ; +void *fdt = v; +int err =0 ; + +switch (cmd) { +case KEXEC_KHO_ABORT : +if (trace_in_kho) +mutex_unlock (&trace_types_lock); + trace_in_kho = false; +return NOTIFY_DONE ; +case KEXEC_KHO_DUMP : +/* Handled below */ +break ; +default : +return NOTIFY_BAD ; + } + +if (unlikely (tracing_disabled)) +return NOTIFY_DONE ; + + err |=fdt_begin_node (fdt,"ftrace" ); + err |=fdt_property (fdt,"compatible" , compatible,sizeof (compatible)); + err |=fdt_end_node (fdt); + +if (!err) { +/* Hold all future allocations */ +mutex_lock (&trace_types_lock); + trace_in_kho = true; + } + +return err ?NOTIFY_BAD :NOTIFY_DONE ; +} + +static struct notifier_block trace_kho_nb = { + .notifier_call = trace_kho_notifier, +}; +void __init trace_init (void ) {trace_event_init ();if (boot_instance_index)enable_instances (); + +if (IS_ENABLED (CONFIG_FTRACE_KHO )) +register_kho_notifier (&trace_kho_nb); }__init static void clear_boot_tracer (void )
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 6/17 kexec: Add config option for KHO
In reply to Alexander GrafWe have all generic code in place now to support Kexec with KHO. This patch adds a config option that depends on architecture support to enable KHO support.
--- kernel/Kconfig.kexec | 13 +++++++++++++ 1 file changed, 13 insertions(+)
kernel/Kconfig.kexec +13 -0
@@ -91,6 +91,19 @@ config KEXEC_JUMP Jump between original kernel and kexeced kernel and invoke code in physical address mode via KEXEC +config KEXEC_KHO + bool "kexec handover" + depends on ARCH_SUPPORTS_KEXEC_KHO + depends on KEXEC + select MEMBLOCK_SCRATCH + select LIBFDT + select CMA + help + Allow kexec to hand over state across kernels by generating and + passing additional metadata to the target kernel. This is useful + to keep data or state alive across the kexec. For this to work, + both source and target kernels need to have this option enabled. + config CRASH_DUMP bool "kernel crash dumps" depends on ARCH_SUPPORTS_CRASH_DUMP
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 7/17 kexec: Add documentation for KHO
With KHO in place, let's add documentation that describes what it is and how to use it.
--- Documentation/kho/concepts.rst | 88 ++++++++++++++++++++++++++++++++ Documentation/kho/index.rst | 19 +++++++ Documentation/kho/usage.rst | 57 +++++++++++++++++++++ Documentation/subsystem-apis.rst | 1 + 4 files changed, 165 insertions(+) create mode 100644 Documentation/kho/concepts.rst create mode 100644 Documentation/kho/index.rst create mode 100644 Documentation/kho/usage.rst
Documentation/kho/concepts.rst new file +88 -0
@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec. + +It introduces multiple concepts: + +KHO Device Tree +--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to +serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state. + +KHO only uses the fdt container format and libfdt library, but does not +adhere to the same property semantics that normal device trees do: Properties +are passed in native endianness and standardized properties like ``regs`` and +``ranges`` do not exist, hence there are no ``#...-cells`` properties. + +KHO introduces a new concept to its device tree: ``mem`` properties. A +``mem`` property can inside any subnode in the device tree. When present, +it contains an array of physical memory ranges that the new kernel must mark +as reserved on boot. It is recommended, but not required, to make these ranges +as physically contiguous as possible to reduce the number of array elements :: + + struct kho_mem { + __u64 addr; + __u64 len; + }; + +After boot, drivers can call the kho subsystem to transfer ownership of memory +that was reserved via a ``mem`` property to themselves to continue using memory +from the previous execution. + +The KHO device tree follows the in-Linux schema requirements. Any element in +the device tree is documented via device tree schema yamls that explain what +data gets transferred. + +Mem cache +--------- + +The new kernel needs to know about all memory reservations, but is unable to +parse the device tree yet in early bootup code because of memory limitations. +To simplify the initial memory reservation flow, the old kernel passes a +preprocessed array of physically contiguous reserved ranges to the new kernel. + +These reservations have to be separate from architectural memory maps and +reservations because they differ on every kexec, while the architectural ones +get passed directly between invocations. + +The less entries this cache contains, the faster the new kernel will boot. + +Scratch Region +-------------- + +To boot into kexec, we need to have a physically contiguous memory range that +contains no handed over memory. Kexec then places the target kernel and initrd +into that region. The new kernel exclusively uses this region for memory +allocations before it ingests the mem cache. + +We guarantee that we always have such a region through the scratch region: On +first boot, you can pass the ``kho_scratch`` kernel command line option. When +it is set, Linux allocates a CMA region of the given size. CMA gives us the +guarantee that no handover pages land in that region, because handover +pages must be at a static physical memory location and CMA enforces that +only movable pages can be located inside. + +After KHO kexec, we ignore the ``kho_scratch`` kernel command line option and +instead reuse the exact same region that was originally allocated. This allows +us to recursively execute any amount of KHO kexecs. Because we used this region +for boot memory allocations and as target memory for kexec blobs, some parts +of that memory region may be reserved. These reservations are irrenevant for +the next KHO, because kexec can overwrite even the original kernel. + +KHO active phase +---------------- + +To enable user space based kexec file loader, the kernel needs to be able to +provide the device tree that describes the previous kernel's state before +performing the actual kexec. The process of generating that device tree is +called serialization. When the device tree is generated, some properties +of the system may become immutable because they are already written down +in the device tree. That state is called the KHO active phase.
Documentation/kho/index.rst new file +19 -0
@@ -0,0 +1,19 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================== +Kexec Handover Subsystem +======================== + +.. toctree:: + :maxdepth: 1 + + concepts + usage + +.. only:: subproject and html + + + Indices + ======= + + * :ref:`genindex`
Documentation/kho/usage.rst new file +57 -0
57 lines not on this page · raw message
Documentation/subsystem-apis.rst +1 -0
@@ -86,3 +86,4 @@ Storage interfaces misc-devices/index peci/index wmi/index + kho/index
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 8/17 arm64: Add KHO support
In reply to Alexander GrafWe now have all bits in place to support KHO kexecs. This patch adds awareness of KHO in the kexec file as well as boot path for arm64 and adds the respective kconfig option to the architecture so that it can use KHO successfully.
---
v1 -> v2:
- test bot warning fix
- Change kconfig option to ARCH_SUPPORTS_KEXEC_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- s/kho_reserve/kho_reserve_scratch/g
- Remove / reduce ifdefs for kho fdt code
--- arch/arm64/Kconfig | 3 +++ arch/arm64/kernel/setup.c | 2 ++ arch/arm64/mm/init.c | 8 ++++++ drivers/of/fdt.c | 39 ++++++++++++++++++++++++++++ drivers/of/kexec.c | 54 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 106 insertions(+)
arch/arm64/Kconfig +3 -0
@@ -1495,6 +1495,9 @@ config ARCH_SUPPORTS_KEXEC_IMAGE_VERIFY_SIG config ARCH_DEFAULT_KEXEC_IMAGE_VERIFY_SIG def_bool y +config ARCH_SUPPORTS_KEXEC_KHO + def_bool y + config ARCH_SUPPORTS_CRASH_DUMP def_bool y
arch/arm64/kernel/setup.c +2 -0
@@ -346,6 +346,8 @@ void __init __no_sanitize_address setup_arch(char **cmdline_p)paging_init (); +kho_reserve_previous_mem (); +acpi_table_upgrade ();/* Parse the ACPI tables for possible boot-time configuration */
arch/arm64/mm/init.c +8 -0
@@ -358,6 +358,8 @@ void __init bootmem_init(void)*/ arch_reserve_crashkernel (); +kho_reserve_scratch (); +memblock_dump_all (); }
@@ -386,6 +388,12 @@ void __init mem_init(void)/* this will put all unused low memory onto the freelists */ memblock_free_all (); +/* +* Now that all KHO pages are marked as reserved, let's flip them back +* to normal pages with accurate refcount. +*/ +kho_populate_refcount (); +/* * Check boundaries twice: Some fundamental inconsistencies can be * detected at build time already.
drivers/of/fdt.c +39 -0
@@ -1006,6 +1006,42 @@ void __init early_init_dt_check_for_usable_mem_range(void)memblock_add (rgn[i].base, rgn[i].size); } +/** +* early_init_dt_check_kho - Decode info required for kexec handover from DT +*/ +static void __init early_init_dt_check_kho (void ) +{ +unsigned long node = chosen_node_offset; +u64 kho_start, scratch_start, scratch_size, mem_start, mem_size; +const __be32 *p; +int l; + +if (!IS_ENABLED (CONFIG_KEXEC_KHO ) || (long )node <0 ) +return ; + + p =of_get_flat_dt_prop (node,"linux,kho-dt" , &l); +if (l != (dt_root_addr_cells + dt_root_size_cells) *sizeof (__be32)) +return ; + + kho_start =dt_mem_next_cell (dt_root_addr_cells, &p); + + p =of_get_flat_dt_prop (node,"linux,kho-scratch" , &l); +if (l != (dt_root_addr_cells + dt_root_size_cells) *sizeof (__be32)) +return ; + + scratch_start =dt_mem_next_cell (dt_root_addr_cells, &p); + scratch_size =dt_mem_next_cell (dt_root_addr_cells, &p); + + p =of_get_flat_dt_prop (node,"linux,kho-mem" , &l); +if (l != (dt_root_addr_cells + dt_root_size_cells) *sizeof (__be32)) +return ; + + mem_start =dt_mem_next_cell (dt_root_addr_cells, &p); + mem_size =dt_mem_next_cell (dt_root_addr_cells, &p); + +kho_populate (kho_start, scratch_start, scratch_size, mem_start, mem_size); +} +#ifdef CONFIG_SERIAL_EARLYCON int __init early_init_dt_scan_chosen_stdout (void )
@@ -1304,6 +1340,9 @@ void __init early_init_dt_scan_nodes(void)/* Handle linux,usable-memory-range property */ early_init_dt_check_for_usable_mem_range (); + +/* Handle kexec handover */ +early_init_dt_check_kho (); }bool __init early_init_dt_scan (void *params)
drivers/of/kexec.c +54 -0
66 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 10/17 tracing: Initialize fields before registering
In reply to Alexander GrafWith KHO, we need to know all event fields before we allocate an event type for a trace event so that we can recover it based on a previous execution context.
Before this patch, fields were only initialized after we allocated a type id. After this patch, we try to allocate it early as well.
This patch leaves the old late initialization logic in place. The field init code already validates whether there are any fields present, which means it's legal to call it multiple times. This way we're sure we don't miss any call sites.
--- include/linux/trace_events.h | 1 + kernel/trace/trace_events.c | 14 +++++++++----- kernel/trace/trace_events_synth.c | 14 +++++++++----- kernel/trace/trace_events_user.c | 4 ++++ kernel/trace/trace_probe.c | 4 ++++ 5 files changed, 27 insertions(+), 10 deletions(-)
include/linux/trace_events.h +1 -0
@@ -842,6 +842,7 @@ extern int trace_define_field(struct trace_event_call *call, const char *type,extern int trace_add_event_call (struct trace_event_call *call);extern int trace_remove_event_call (struct trace_event_call *call);extern int trace_event_get_offsets (struct trace_event_call *call); +extern int trace_event_define_fields (struct trace_event_call *call);int ftrace_set_clr_event (struct trace_array *tr,char *buf,int set);int trace_set_clr_event (const char *system,const char *event,int set);
kernel/trace/trace_events.c +9 -5
@@ -462,6 +462,11 @@ static void test_event_printk(struct trace_event_call *call)int trace_event_raw_init (struct trace_event_call *call) {int id; +int ret; + + ret =trace_event_define_fields (call); +if (ret) +return ret; id =register_trace_event (&call->event);if (!id)
@@ -2402,8 +2407,7 @@ event_subsystem_dir(struct trace_array *tr, const char *name,return NULL ; } -static int -event_define_fields (struct trace_event_call *call) +int trace_event_define_fields (struct trace_event_call *call) {struct list_head *head;int ret =0 ;
@@ -2592,7 +2596,7 @@ event_create_dir(struct eventfs_inode *parent, struct trace_event_file *file) file->ei = ei; - ret =event_define_fields (call); + ret =trace_event_define_fields (call);if (ret <0 ) {pr_warn ("Could not initialize trace point events/%s\n" , name);return ret;
@@ -2978,7 +2982,7 @@ __trace_add_new_event(struct trace_event_call *call, struct trace_array *tr)if (eventdir_initialized)return event_create_dir (tr->event_dir, file);else -return event_define_fields (call); +return trace_event_define_fields (call); }static void trace_early_triggers (struct trace_event_file *file,const char *name)
@@ -3015,7 +3019,7 @@ __trace_early_add_new_event(struct trace_event_call *call,if (!file)return -ENOMEM ; - ret =event_define_fields (call); + ret =trace_event_define_fields (call);if (ret)return ret;
kernel/trace/trace_events_synth.c +9 -5
@@ -880,17 +880,21 @@ static int register_synth_event(struct synth_event *event)INIT_LIST_HEAD (&call->class->fields); call->event.funcs = &synth_event_funcs; call->class->fields_array = synth_event_fields_array; + call->flags =TRACE_EVENT_FL_TRACEPOINT ; + call->class->reg = trace_event_reg; + call->class->probe = trace_event_raw_event_synth; + call->data = event; + call->tp = event->tp; + + ret =trace_event_define_fields (call); +if (ret) + goto out; ret =register_trace_event (&call->event);if (!ret) { ret = -ENODEV ; goto out; } - call->flags =TRACE_EVENT_FL_TRACEPOINT ; - call->class->reg = trace_event_reg; - call->class->probe = trace_event_raw_event_synth; - call->data = event; - call->tp = event->tp; ret =trace_add_event_call (call);if (ret) {
kernel/trace/trace_events_user.c +4 -0
@@ -1900,6 +1900,10 @@ static int user_event_trace_register(struct user_event *user) {int ret; + ret =trace_event_define_fields (&user->call); +if (ret) +return ret; + ret =register_trace_event (&user->call.event);if (!ret)
kernel/trace/trace_probe.c +4 -0
@@ -1835,6 +1835,10 @@ int trace_probe_register_event_call(struct trace_probe *tp) trace_probe_name(tp)))return -EEXIST ; + ret =trace_event_define_fields (call); +if (ret) +return ret; + ret =register_trace_event (&call->event);if (!ret)return -ENODEV ;
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 9/17 x86: Add KHO support
In reply to Alexander GrafWe now have all bits in place to support KHO kexecs. This patch adds awareness of KHO in the kexec file as well as boot path for x86 and adds the respective kconfig option to the architecture so that it can use KHO successfully.
In addition, it enlightens it decompression code with KHO so that its KASLR location finder only considers memory regions that are not already occupied by KHO memory.
---
v1 -> v2:
- Change kconfig option to ARCH_SUPPORTS_KEXEC_KHO
- s/kho_reserve_mem/kho_reserve_previous_mem/g
- s/kho_reserve/kho_reserve_scratch/g
--- arch/x86/Kconfig | 3 ++ arch/x86/boot/compressed/kaslr.c | 55 +++++++++++++++++++++++++++ arch/x86/include/uapi/asm/bootparam.h | 15 +++++++- arch/x86/kernel/e820.c | 9 +++++ arch/x86/kernel/kexec-bzimage64.c | 39 +++++++++++++++++++ arch/x86/kernel/setup.c | 46 ++++++++++++++++++++++ arch/x86/mm/init_32.c | 7 ++++ arch/x86/mm/init_64.c | 7 ++++ 8 files changed, 180 insertions(+), 1 deletion(-)
arch/x86/Kconfig +3 -0
@@ -2094,6 +2094,9 @@ config ARCH_SUPPORTS_KEXEC_BZIMAGE_VERIFY_SIG config ARCH_SUPPORTS_KEXEC_JUMP def_bool y +config ARCH_SUPPORTS_KEXEC_KHO + def_bool y + config ARCH_SUPPORTS_CRASH_DUMP def_bool X86_64 || (X86_32 && HIGHMEM)
arch/x86/boot/compressed/kaslr.c +55 -0
67 lines not on this page · raw message
arch/x86/include/uapi/asm/bootparam.h +14 -1
@@ -13,7 +13,8 @@#define SETUP_CC_BLOB 7#define SETUP_IMA 8#define SETUP_RNG_SEED 9 -#define SETUP_ENUM_MAX SETUP_RNG_SEED +#define SETUP_KEXEC_KHO 10 +#define SETUP_ENUM_MAX SETUP_KEXEC_KHO#define SETUP_INDIRECT (1<<31)#define SETUP_TYPE_MAX (SETUP_ENUM_MAX | SETUP_INDIRECT)
@@ -181,6 +182,18 @@ struct ima_setup_data {__u64 size; } __attribute__((packed)); +/* +* Locations of kexec handover metadata +*/ +struct kho_data { +__u64 dt_addr; +__u64 dt_size; +__u64 scratch_addr; +__u64 scratch_size; +__u64 mem_cache_addr; +__u64 mem_cache_size; +} __attribute__((packed)); +/* The so-called "zeropage" */ struct boot_params {struct screen_info screen_info;/* 0x000 */
arch/x86/kernel/e820.c +9 -0
@@ -1341,6 +1341,15 @@ void __init e820__memblock_setup(void)continue ;memblock_add (entry->addr, entry->size); + +/* +* At this point with KHO we only allocate from scratch memory +* and only from memory below ISA_END_ADDRESS. Make sure that +* when we add memory for the eligible range, we add it as +* scratch memory so that we can resize the memblocks array. +*/ +if (is_kho_boot () && (end <=ISA_END_ADDRESS )) +memblock_mark_scratch (entry->addr, end); }/* Throw away partial pages: */
arch/x86/kernel/kexec-bzimage64.c +39 -0
@@ -15,6 +15,7 @@#include <linux/slab.h> #include <linux/kexec.h> #include <linux/kernel.h> +#include <linux/libfdt.h> #include <linux/mm.h> #include <linux/efi.h> #include <linux/random.h>
@@ -233,6 +234,33 @@ setup_ima_state(const struct kimage *image, struct boot_params *params,#endif /* CONFIG_IMA_KEXEC */ } +static void setup_kho (const struct kimage *image,struct boot_params *params, +unsigned long params_load_addr, +unsigned int setup_data_offset) +{ +#ifdef CONFIG_KEXEC_KHO +struct setup_data *sd = (void *)params + setup_data_offset; +struct kho_data *kho = (void *)sd +sizeof (*sd); + + sd->type =SETUP_KEXEC_KHO ; + sd->len =sizeof (struct kho_data ); + +/* Only add if we have all KHO images in place */ +if (!image->kho.dt.buffer || !image->kho.mem_cache.buffer) +return ; + +/* Add setup data */ + kho->dt_addr = image->kho.dt.mem; + kho->dt_size = image->kho.dt.bufsz; + kho->scratch_addr = kho_scratch_phys; + kho->scratch_size = kho_scratch_len; + kho->mem_cache_addr = image->kho.mem_cache.mem; + kho->mem_cache_size = image->kho.mem_cache.bufsz; + sd->next = params->hdr.setup_data; + params->hdr.setup_data = params_load_addr + setup_data_offset; +#endif /* CONFIG_KEXEC_KHO */ +} + static int setup_boot_parameters(struct kimage *image, struct boot_params *params, unsigned long params_load_addr,
@@ -305,6 +333,13 @@ setup_boot_parameters(struct kimage *image, struct boot_params *params,sizeof (struct ima_setup_data ); } +if (IS_ENABLED (CONFIG_KEXEC_KHO )) { +/* Setup space to store preservation metadata */ +setup_kho (image, params, params_load_addr, setup_data_offset); + setup_data_offset +=sizeof (struct setup_data ) + +sizeof (struct kho_data ); + } +/* Setup RNG seed */ setup_rng_seed (params, params_load_addr, setup_data_offset);
@@ -470,6 +505,10 @@ static void *bzImage64_load(struct kimage *image, char *kernel, kbuf.bufsz +=sizeof (struct setup_data ) +sizeof (struct ima_setup_data ); +if (IS_ENABLED (CONFIG_KEXEC_KHO )) + kbuf.bufsz +=sizeof (struct setup_data ) + +sizeof (struct kho_data ); + params =kzalloc (kbuf.bufsz,GFP_KERNEL );if (!params)return ERR_PTR (-ENOMEM );
arch/x86/kernel/setup.c +46 -0
72 lines not on this page · raw message
arch/x86/mm/init_32.c +7 -0
@@ -20,6 +20,7 @@#include <linux/smp.h> #include <linux/init.h> #include <linux/highmem.h> +#include <linux/kexec.h> #include <linux/pagemap.h> #include <linux/pci.h> #include <linux/pfn.h>
@@ -738,6 +739,12 @@ void __init mem_init(void) after_bootmem =1 ; x86_init.hyper.init_after_bootmem (); +/* +* Now that all KHO pages are marked as reserved, let's flip them back +* to normal pages with accurate refcount. +*/ +kho_populate_refcount (); +/* * Check boundaries twice: Some fundamental inconsistencies can * be detected at build time already.
arch/x86/mm/init_64.c +7 -0
@@ -20,6 +20,7 @@#include <linux/smp.h> #include <linux/init.h> #include <linux/initrd.h> +#include <linux/kexec.h> #include <linux/pagemap.h> #include <linux/memblock.h> #include <linux/proc_fs.h>
@@ -1339,6 +1340,12 @@ void __init mem_init(void) after_bootmem =1 ; x86_init.hyper.init_after_bootmem (); +/* +* Now that all KHO pages are marked as reserved, let's flip them back +* to normal pages with accurate refcount. +*/ +kho_populate_refcount (); +/* * Must be done after boot memory is put on freelist, because here we * might set fields in deferred struct pages that have not yet been
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 11/17 tracing: Introduce kho serialization
In reply to Alexander GrafWe want to be able to transfer ftrace state from one kernel to the next. To start off with, let's establish all the boiler plate to get a write hook when KHO wants to serialize and fill out basic data.
Follow-up patches will fill in serialization of ring buffers and events.
---
v1 -> v2:
- Remove ifdefs
--- kernel/trace/trace.c | 47 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+)
kernel/trace/trace.c +47 -0
@@ -32,6 +32,7 @@#include <linux/percpu.h> #include <linux/splice.h> #include <linux/kdebug.h> +#include <linux/kexec.h> #include <linux/string.h> #include <linux/mount.h> #include <linux/rwsem.h>
@@ -866,6 +867,8 @@ static struct tracer *trace_types __read_mostly;*/ DEFINE_MUTEX (trace_types_lock); +static bool trace_in_kho; +/* * serialize the access of the ring buffer *
@@ -10560,12 +10563,56 @@ void __init early_trace_init(void)init_events (); } +static int trace_kho_notifier (struct notifier_block *self, +unsigned long cmd, +void *v) +{ +const char compatible[] ="ftrace-v1" ; +void *fdt = v; +int err =0 ; + +switch (cmd) { +case KEXEC_KHO_ABORT : +if (trace_in_kho) +mutex_unlock (&trace_types_lock); + trace_in_kho = false; +return NOTIFY_DONE ; +case KEXEC_KHO_DUMP : +/* Handled below */ +break ; +default : +return NOTIFY_BAD ; + } + +if (unlikely (tracing_disabled)) +return NOTIFY_DONE ; + + err |=fdt_begin_node (fdt,"ftrace" ); + err |=fdt_property (fdt,"compatible" , compatible,sizeof (compatible)); + err |=fdt_end_node (fdt); + +if (!err) { +/* Hold all future allocations */ +mutex_lock (&trace_types_lock); + trace_in_kho = true; + } + +return err ?NOTIFY_BAD :NOTIFY_DONE ; +} + +static struct notifier_block trace_kho_nb = { + .notifier_call = trace_kho_notifier, +}; +void __init trace_init (void ) {trace_event_init ();if (boot_instance_index)enable_instances (); + +if (IS_ENABLED (CONFIG_FTRACE_KHO )) +register_kho_notifier (&trace_kho_nb); }__init static void clear_boot_tracer (void )
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 12/17 tracing: Add kho serialization of trace buffers
In reply to Alexander GrafWhen we do a kexec handover, we want to preserve previous ftrace data into the new kernel. At the point when we write out the handover data, ftrace may still be running and recording new events and we want to capture all of those too.
To allow the new kernel to revive all trace data up to reboot, we store all locations of trace buffers as well as their linked list metadata. We can then later reuse the linked list to reconstruct the head pointer.
This patch implements the write-out logic for trace buffers.
---
v1 -> v2:
- Leave the node generation code that needs to know the name in trace.c so that ring buffers can stay anonymous
--- include/linux/ring_buffer.h | 2 + kernel/trace/ring_buffer.c | 76 +++++++++++++++++++++++++++++++++++++ kernel/trace/trace.c | 16 ++++++++ 3 files changed, 94 insertions(+)
include/linux/ring_buffer.h +2 -0
@@ -211,4 +211,6 @@ int trace_rb_cpu_prepare(unsigned int cpu, struct hlist_node *node);#define trace_rb_cpu_prepare NULL#endif +int ring_buffer_kho_write (void *fdt,struct trace_buffer *buffer); +#endif /* _LINUX_RING_BUFFER_H */
kernel/trace/ring_buffer.c +76 -0
88 lines not on this page · raw message
kernel/trace/trace.c +16 -0
@@ -10563,6 +10563,21 @@ void __init early_trace_init(void)init_events (); } +static int trace_kho_write_trace_array (void *fdt,struct trace_array *tr) +{ +const char *name = tr->name ? tr->name :"global_trace" ; +const char compatible[] ="ftrace,array-v1" ; +int err =0 ; + + err |=fdt_begin_node (fdt, name); + err |=fdt_property (fdt,"compatible" , compatible,sizeof (compatible)); + err |=fdt_property (fdt,"trace_flags" , &tr->trace_flags,sizeof (tr->trace_flags)); + err |=ring_buffer_kho_write (fdt, tr->array_buffer.buffer); + err |=fdt_end_node (fdt); + +return err; +} +static int trace_kho_notifier (struct notifier_block *self,unsigned long cmd,void *v)
@@ -10589,6 +10604,7 @@ static int trace_kho_notifier(struct notifier_block *self, err |=fdt_begin_node (fdt,"ftrace" ); err |=fdt_property (fdt,"compatible" , compatible,sizeof (compatible)); + err |=trace_kho_write_trace_array (fdt, &global_trace); err |=fdt_end_node (fdt);if (!err) {
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 13/17 tracing: Recover trace buffers from kexec handover
In reply to Alexander GrafWhen kexec handover is in place, we now know the location of all previous buffers for ftrace rings. With this patch applied, ftrace reassembles any new trace buffer that carries the same name as a previous one with the same data pages that the previous buffer had.
That way, a buffer that we had in place before kexec becomes readable after kexec again as soon as it gets initialized with the same name.
---
v1 -> v2:
- Move from names to fdt offsets. That way, trace.c can find the trace array offset and then the ring buffer code only needs to read out its per-CPU data. That way it can stay oblivient to its name.
- Make kho_get_fdt() const
- Remove ifdefs
--- include/linux/ring_buffer.h | 15 ++-- kernel/trace/ring_buffer.c | 171 ++++++++++++++++++++++++++++++++++-- kernel/trace/trace.c | 32 ++++++- 3 files changed, 206 insertions(+), 12 deletions(-)
include/linux/ring_buffer.h +9 -6
@@ -84,20 +84,23 @@ void ring_buffer_discard_commit(struct trace_buffer *buffer,/* * size is in bytes for each per CPU buffer. */ -struct trace_buffer * -__ring_buffer_alloc (unsigned long size,unsigned flags,struct lock_class_key *key); +struct trace_buffer *__ring_buffer_alloc (unsigned long size,unsigned flags, +struct lock_class_key *key, +int tr_off);/* * Because the ring buffer is generic, if other users of the ring buffer get * traced by ftrace, it can produce lockdep warnings. We need to keep each * ring buffer's lock class separate. */ -#define ring_buffer_alloc (size, flags) \ -({ \ - static struct lock_class_key __key; \ - __ring_buffer_alloc((size), (flags), &__key); \ +#define ring_buffer_alloc_kho (size, flags, tr_off) \ +({ \ + static struct lock_class_key __key; \ + __ring_buffer_alloc((size), (flags), &__key, tr_off); \ }) +#define ring_buffer_alloc (size, flags) ring_buffer_alloc_kho(size, flags, 0) +int ring_buffer_wait (struct trace_buffer *buffer,int cpu,int full);__poll_t ring_buffer_poll_wait (struct trace_buffer *buffer,int cpu,struct file *filp,poll_table *poll_table,int full);
kernel/trace/ring_buffer.c +166 -5
243 lines not on this page · raw message
kernel/trace/trace.c +31 -1
@@ -9348,16 +9348,46 @@ static struct dentry *trace_instance_dir;static void init_tracer_tracefs (struct trace_array *tr,struct dentry *d_tracer); +static int trace_kho_off_tr (struct trace_array *tr) +{ +const char *name = tr->name ? tr->name :"global_trace" ; +const void *fdt =kho_get_fdt (); +char *path; +int off; + +if (!IS_ENABLED (CONFIG_FTRACE_KHO )) +return 0 ; + +if (!fdt) +return 0 ; + + path =kasprintf (GFP_KERNEL ,"/ftrace/%s" , name); +if (!path) +return -ENOMEM ; + +pr_debug ("Trying to revive trace buffer '%s'" , path); + + off =fdt_path_offset (fdt, path); +if (off <0 ) { +pr_debug ("Could not find '%s' in DT" , path); + off =0 ; + } + +kfree (path); +return off; +} +static int allocate_trace_buffer (struct trace_array *tr,struct array_buffer *buf,int size) { +int tr_off =trace_kho_off_tr (tr);enum ring_buffer_flags rb_flags; rb_flags = tr->trace_flags &TRACE_ITER_OVERWRITE ?RB_FL_OVERWRITE :0 ; buf->tr = tr; - buf->buffer =ring_buffer_alloc (size, rb_flags); + buf->buffer =ring_buffer_alloc_kho (size, rb_flags, tr_off);if (!buf->buffer)return -ENOMEM ;
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 14/17 tracing: Add kho serialization of trace events
In reply to Alexander GrafEvents and thus their parsing handle in ftrace have dynamic IDs that get assigned whenever the event is added to the system. If we want to parse trace events after kexec, we need to link event IDs back to the original trace event that existed before we kexec'ed.
There are broadly 2 paths we could take for that:
1) Save full event description across KHO, restore after kexec, merge identical trace events into a single identifier.
2) Recover the ID of post-kexec added events so they get the same ID after kexec that they had before kexec
This patch implements the second option. It's simpler and thus less intrusive. However, it means we can not fully parse affected events when the kernel removes or modifies trace events across a kho kexec.
---
v1 -> v2:
- Leave anything that requires a name in trace.c to keep buffers unnamed entities
- Put events as array into a property, use fingerprint instead of names to identify them
- Reduce footprint without CONFIG_FTRACE_KHO
--- kernel/trace/trace.c | 1 + kernel/trace/trace_output.c | 89 +++++++++++++++++++++++++++++++++++++ kernel/trace/trace_output.h | 5 +++ 3 files changed, 95 insertions(+)
kernel/trace/trace.c +1 -0
@@ -10634,6 +10634,7 @@ static int trace_kho_notifier(struct notifier_block *self, err |=fdt_begin_node (fdt,"ftrace" ); err |=fdt_property (fdt,"compatible" , compatible,sizeof (compatible)); + err |=trace_kho_write_events (fdt); err |=trace_kho_write_trace_array (fdt, &global_trace); err |=fdt_end_node (fdt);
kernel/trace/trace_output.c +89 -0
101 lines not on this page · raw message
kernel/trace/trace_output.h +5 -0
@@ -25,6 +25,11 @@ extern enum print_line_t print_event_fields(struct trace_iterator *iter,extern void trace_event_read_lock (void );extern void trace_event_read_unlock (void );extern struct trace_event *ftrace_find_event (int type); +#ifdef CONFIG_FTRACE_KHO +extern int trace_kho_write_events (void *fdt); +#else +static inline int trace_kho_write_events (void *fdt) {return -EINVAL ; } +#endif extern enum print_line_t trace_nop_print (struct trace_iterator *iter,int flags,struct trace_event *event);
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 15/17 tracing: Recover trace events from kexec handover
In reply to Alexander GrafThis patch implements all logic necessary to match a new trace event that we add against preserved trace events from kho. If we find a match, we give the new trace event the old event's identifier. That way, trace read-outs are able to make sense of buffer contents again because the parsing code for events looks at the same identifiers.
---
v1 -> v2:
- make kho_get_fdt() const
- Get events as array from a property, use fingerprint instead of names to identify events
- Remove ifdefs
--- kernel/trace/trace_output.c | 158 +++++++++++++++++++++++++++++++++++- 1 file changed, 156 insertions(+), 2 deletions(-)
kernel/trace/trace_output.c +156 -2
@@ -24,6 +24,8 @@ DECLARE_RWSEM(trace_event_sem);static struct hlist_head event_hash[EVENT_HASHSIZE ]__read_mostly ; +static bool trace_is_kho_event (int type); +enum print_line_t trace_print_bputs_msg_only (struct trace_iterator *iter) {struct trace_seq *s = &iter->seq;
@@ -784,7 +786,7 @@ static DEFINE_IDA(trace_event_ida);static void free_trace_event_type (int type) { -if (type >= __TRACE_LAST_TYPE) +if (type >= __TRACE_LAST_TYPE && !trace_is_kho_event (type))ida_free (&trace_event_ida, type); }
@@ -810,6 +812,156 @@ void trace_event_read_unlock(void)up_read (&trace_event_sem); } + +/** +* trace_kho_get_map - Return the KHO event map +* @pmap: Pointer to a trace map array. Will be filled on success. +* @plen: Pointer to the length of the map. Will be filled on success. +* @unallocated: True if the event does not have an ID yet +* +* Event types are semi-dynamically generated. To ensure that +* their identifiers match before and after kexec with KHO, +* we store an event map in the KHO DT. Whenever we need the +* map, this function provides it. +* +* The first time we request a map, it also walks through it and +* reserves all identifiers so later event registration has find their +* identifier already reserved. +*/ +static int trace_kho_get_map (const struct trace_event_map **pmap,int *plen, +bool unallocated) +{ +static const struct trace_event_map *event_map; +static int event_map_len; +static bool event_map_reserved; +const struct trace_event_map *map =NULL ; +const void *fdt =kho_get_fdt (); +const char *path ="/ftrace" ; +int off, err, len =0 ; +int i; + +if (!IS_ENABLED (CONFIG_FTRACE_KHO ) || !fdt) +return -EINVAL ; + +if (event_map) { + map = event_map; + len = event_map_len; + } + +if (!map) { + off =fdt_path_offset (fdt, path); + +if (off <0 ) { +pr_debug ("Could not find '%s' in DT" , path); +return -EINVAL ; + } + + err =fdt_node_check_compatible (fdt, off,"ftrace-v1" ); +if (err) { +pr_warn ("Node '%s' has invalid compatible" , path); +return -EINVAL ; + } + + map =fdt_getprop (fdt, off,"events" , &len); +if (!map) +return -EINVAL ; + + event_map = map; + event_map_len = len; + } + +if (unallocated && !event_map_reserved) { +/* +* Reserve all IDs in our IDA. We only have a working IDA later +* in boot, so restrict it to when we allocate a dynamic type id +* for an event. +*/ +for (i =0 ; i < len; i +=sizeof (*map)) { +const struct trace_event_map *imap = (void *)map + i; + +if (imap->type < __TRACE_LAST_TYPE) +continue ; +if (ida_alloc_range (&trace_event_ida, imap->type, imap->type, +GFP_KERNEL ) != imap->type) { +pr_warn ("Unable to reserve id %d" , imap->type); +return -EINVAL ; + } + } + + event_map_reserved = true; + } + + *pmap = map; + *plen = len; + +return 0 ; +} + +/** +* trace_is_kho_event - returns true if the event type is KHO reserved +* @event: the event type to enumerate +* +* With KHO, we reserve all previous kernel's trace event types in the +* KHO DT. Then, when we allocate a type, we just reuse the previous +* kernel's value. However, that means we have to keep these type identifiers +* reserved across the lifetime of the system, because we may get a new event +* that matches the old kernel's event fingerprint. This function is a small +* helper that allows us to check whether a type ID is in use by KHO. +*/ +static bool trace_is_kho_event (int type) +{ +const struct trace_event_map *map =NULL ; +int len, i; + +if (trace_kho_get_map (&map, &len, false)) +return false; + +if (!map) +return false; + +for (i =0 ; i < len; i +=sizeof (*map), map++) +if (map->type == type) +return true; + +return false; +} + +/** +* trace_kho_fill_event_type - restore event type info from KHO +* @event: the event to enumerate +* +* Event types are semi-dynamically generated. To ensure that +* their identifiers match before and after kexec with KHO, +* let's match up unique fingerprint - either their predetermined +* type or their crc32 value - and fill in the respective type +* information if we booted with KHO. +*/ +static bool trace_kho_fill_event_type (struct trace_event *event) +{ +const struct trace_event_map *map =NULL ; +int len =0 , i; +u32 crc32; + +if (trace_kho_get_map (&map, &len, !event->type)) +return false; + + crc32 =event2fp (event); + +for (i =0 ; i < len; i +=sizeof (*map), map++) { +if (map->crc32 == crc32) { +if (!map->type) +return false; + + event->type = map->type; +return true; + } + } + +pr_debug ("Could not find event" ); + +return false; +} +/** * register_trace_event - register output for an event type * @event: the event type to register
@@ -838,7 +990,9 @@ int register_trace_event(struct trace_event *event)if (WARN_ON (!event->funcs)) goto out; -if (!event->type) { +if (trace_kho_fill_event_type (event)) { +pr_debug ("Recovered id=%d" , event->type); + }else if (!event->type) { event->type =alloc_trace_event_type ();if (!event->type) goto out;
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 16/17 tracing: Add config option for kexec handover
In reply to Alexander GrafNow that all bits are in place to allow ftrace to pass its trace data into the next kernel on kexec, let's give users a kconfig option to enable the functionality.
---
v1 -> v2:
- Select crc32
--- kernel/trace/Kconfig | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
kernel/trace/Kconfig +14 -0
@@ -1169,6 +1169,20 @@ config HIST_TRIGGERS_DEBUG If unsure, say N. +config FTRACE_KHO + bool "Ftrace Kexec handover support" + depends on KEXEC_KHO + select CRC32 + help + Enable support for ftrace to pass metadata across kexec so the new + kernel continues to use the previous kernel's trace buffers. + + This can be useful when debugging kexec performance or correctness + issues: The new kernel can dump the old kernel's trace buffer which + contains all events until reboot. + + If unsure, say N. + source "kernel/trace/rv/Kconfig" endif # FTRACE
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Alexander Graf
reviewerPATCH v2 17/17 devicetree: Add bindings for ftrace KHO
In reply to Alexander GrafWith ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
--- .../bindings/kho/ftrace/ftrace-array.yaml | 46 +++++++++++++++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 +++++++++++++++++++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +46 -0
@@ -0,0 +1,46 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace-array.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace trace array + +maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,array-v1 + + trace_flags: + $ref: /schemas/types.yaml#/definitions/uint32 + description: + Bitmap of all the trace flags that were enabled in the trace array at the + point of serialization. + +# Subnodes will be of type "ftrace,cpu-v1", one each per CPU +additionalProperties: true + +required: + - compatible + - trace_flags + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + };
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +56 -0
56 lines not on this page · raw message
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +48 -0
48 lines not on this page · raw message
Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Rob Herring
maintainerRe: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
Quoted 7 lines · Alexander Graf
With ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
Signed-off-by Alexander Graf <[email protected]>
Quoted 9 lines
--- .../bindings/kho/ftrace/ftrace-array.yaml | 46 +++++++++++++++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 +++++++++++++++++++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml
My bot found errors running 'make DT_CHECKER_FLAGS=-m dt_binding_check' on your patch (DT_CHECKER_FLAGS is new in v5.13):
yamllint warnings/errors:./Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml:43:111: [warning] line too long (117 > 110 characters) (line-length) ./Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml:53:111: [warning] line too long (117 > 110 characters) (line-length) ./Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml:45:111: [warning] line too long (117 > 110 characters) (line-length)
dtschema/dtc warnings/errors:
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-array.example.dts:29.25-39: Value 0x0000000101000000 truncated to 0x01000000
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-array.example.dts:29.48-62: Value 0x0000000101000100 truncated to 0x01000100
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-array.example.dts:29.73-87: Value 0x0000000101000038 truncated to 0x01000038
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-array.example.dts:29.96-110: Value 0x0000000101002000 truncated to 0x01002000
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.example.dts:29.25-39: Value 0x0000000101000000 truncated to 0x01000000
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.example.dts:29.48-62: Value 0x0000000101000100 truncated to 0x01000100
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.example.dts:29.73-87: Value 0x0000000101000038 truncated to 0x01000038
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.example.dts:29.96-110: Value 0x0000000101002000 truncated to 0x01002000
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace.example.dts:29.25-39: Value 0x0000000101000000 truncated to 0x01000000
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace.example.dts:29.48-62: Value 0x0000000101000100 truncated to 0x01000100
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace.example.dts:29.73-87: Value 0x0000000101000038 truncated to 0x01000038
WARNING: Documentation/devicetree/bindings/kho/ftrace/ftrace.example.dts:29.96-110: Value 0x0000000101002000 truncated to 0x01002000
doc reference errors (make refcheckdocs):
See https://patchwork.ozlabs.org/project/devicetree-bindings/patch/[email protected]
The base for the series is generally the latest rc1. A different dependency should be noted in *this* patch.
If you already ran 'make dt_binding_check' and didn't see the above error(s), then make sure 'yamllint' is installed and dt-schema is up to date:
pip3 install dtschema --upgrade
Please check and re-submit after running the above command yourself. Note that DT_SCHEMA_FILES can be set to your schema file to speed up checking your schema. However, it must be unset to test all examples with your schema.
Re: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
In reply to Alexander GrafQuoted 5 lines · Alexander Graf
With ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
Please use scripts/get_maintainers.pl to get a list of necessary people and lists to CC (and consider --no-git-fallback argument). It might happen, that command when run on an older kernel, gives you outdated entries. Therefore please be sure you base your patches on recent Linux kernel.
Please use subject prefixes matching the subsystem. You can get them for example with git log --oneline -- DIRECTORY_OR_FILE on the directory your patch is touching.
A nit, subject: drop second/last, redundant "bindings". The "dt-bindings" prefix is already stating that these are bindings.
Quoted 17 lines
Signed-off-by Alexander Graf <[email protected]>--- .../bindings/kho/ftrace/ftrace-array.yaml | 46 +++++++++++++++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 +++++++++++++++++++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace.yamlDocumentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +0
-0
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 8
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +8
-0@@ -0,0 +1,46 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace-array.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace trace array +
Missing description. Commit msg also does not tell me much. This must stand on its own and must describe the hardware. Whatever you have in cover letter, does not matter, especially that you did not Cc us on it.
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 17
Quoted 9 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +9
-0+maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,array-v1 + + trace_flags:
Underscores are not allowed. Does not look like generic property.
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 24
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +7
-0+ $ref: /schemas/types.yaml#/definitions/uint32 + description: + Bitmap of all the trace flags that were enabled in the trace array at the + point of serialization. + +# Subnodes will be of type "ftrace,cpu-v1", one each per CPU +additionalProperties: true
No, this must be false. And it goes after required:
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 36
Quoted 12 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +12
-0+ +required: + - compatible + - trace_flags + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace {
Again, no underscores.
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 42
Quoted 6 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +6
-0+ compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >;
Drop redundant spaces.
Quoted 1 line
+ mem = <
0x101000000ULL0x38ULL0x101000100ULL0x1000ULL0x101000038ULL0x38ULL0x101002000ULL0x1000ULL>;
? Do you see any of such syntax in DTS?
Best regards,
Krzysztof
Alexander Graf
reviewerRe: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
Hi Krzysztof!
Thanks a lot for the fast review!
Quoted 11 lines · Krzysztof Kozlowski
Quoted 5 lines · Alexander Graf
With ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
Please use
scripts/get_maintainers.plto get a list of necessary people and lists to CC (and consider --no-git-fallback argument). It might happen, that command when run on an older kernel, gives you outdated entries. Therefore please be sure you base your patches on recent Linux kernel.
Ah, this is about directly CC'ing maintainers? I was slightly picky on CCs since the CC list is already a bit long for this patch set, so I limited the CC list to mailing lists and people that I know were directly interested. Happy to CC you next time.
Quoted 7 lines
Please use subject prefixes matching the subsystem. You can get them for example with
git log --oneline -- DIRECTORY_OR_FILEon the directory your patch is touching.A nit, subject: drop second/last, redundant "bindings". The "dt-bindings" prefix is already stating that these are bindings.
Happy to fix up for v3 :)
Quoted 20 lines
Quoted 20 lines
Signed-off-by Alexander Graf <[email protected]>--- .../bindings/kho/ftrace/ftrace-array.yaml | 46 +++++++++++++++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 +++++++++++++++++++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++++++++++++++++ 3 files changed, 150 insertions(+)create mode 100644
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yamlcreate mode 100644Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yamlcreate mode 100644Documentation/devicetree/bindings/kho/ftrace/ftrace.yamlDocumentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +3
-0@@ -0,0 +1,46 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +---
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 8
Quoted 5 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +5
-0+$id: http://devicetree.org/schemas/kho/ftrace/ftrace-array.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace trace array +Missing description. Commit msg also does not tell me much. This must stand on its own and must describe the hardware. Whatever you have in cover letter, does not matter, especially that you did not Cc us on it.
Alrighty, I'll add descriptions and make the commit message stand on its own.
For quick reference: KHO is a new mechanism this patch set introduces which allows Linux to pass arbitrary memory and metadata between kernels on kexec. I'm reusing FDTs to implement the hand over protocol, as Linux-to-Linux boot communication holds very similar properties to firmware-to-Linux boot communication. So this binding is not about hardware; it's about preserving Linux subsystem state across kexec.
For more details, please refer to the KHO documentation which is part of patch 7 of this patch set: https://lore.kernel.org/lkml/[email protected]/
Quoted 11 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 17
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +9
-0+maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,array-v1 + + trace_flags:Underscores are not allowed. Does not look like generic property.
Let me make it "trace-flags" to not have underscores. Could you please elaborate on what you mean by generic property?
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 24
Quoted 9 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +7
-0+ $ref: /schemas/types.yaml#/definitions/uint32 + description: + Bitmap of all the trace flags that were enabled in the trace array at the + point of serialization. + +# Subnodes will be of type "ftrace,cpu-v1", one each per CPU +additionalProperties: trueNo, this must be false. And it goes after required:
Ok, making it false and adding pattern matches instead for subnodes.
Quoted 15 lines
Quoted 4 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +2
-0+ +required:Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 36
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +10
-0+ - compatible + - trace_flags + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace {Again, no underscores.
Ok :)
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 42
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +6
-0+ compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >;Drop redundant spaces.
I don't understand what you're referring to as redundant spaces? Double checking, I believe indentation is off for every line below "ftrace {". Is that what you're referring to? Fixing :)
Quoted 3 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 43
Quoted 2 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +1
-0+ mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>;? Do you see any of such syntax in DTS?
I was trying to make it easy to reason to readers about 64bit numbers - and then potentially extend dtc to consume that new syntax. KHO DTs are native/little endian, so dtc already has some difficulties interpreting it which I'll need to fix up with patches to it eventually :). I'll change it to something that looks more 32bit'y for now.
Alex
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
Re: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
Quoted 21 lines · Alexander Graf
Quoted 8 lines
Quoted 8 lines
new file mode 100644
index 000000000000..9960fefc292dDocumentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +3
-0@@ -0,0 +1,46 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +---Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 8
Quoted 5 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +5
-0+$id: http://devicetree.org/schemas/kho/ftrace/ftrace-array.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace trace array +Missing description. Commit msg also does not tell me much. This must stand on its own and must describe the hardware. Whatever you have in cover letter, does not matter, especially that you did not Cc us on it.
Alrighty, I'll add descriptions and make the commit message stand on its own.
Quoted 6 lines
For quick reference: KHO is a new mechanism this patch set introduces which allows Linux to pass arbitrary memory and metadata between kernels on kexec. I'm reusing FDTs to implement the hand over protocol, as Linux-to-Linux boot communication holds very similar properties to firmware-to-Linux boot communication. So this binding is not about hardware; it's about preserving Linux subsystem state across kexec.
Devicetree is for non-discoverable systems and their hardware, not for passing arbitrary data between kernels. For me this does not suit DT at all, please use other ways.
Quoted 19 lines
For more details, please refer to the KHO documentation which is part of patch 7 of this patch set:
https://lore.kernel.org/lkml/[email protected]/Quoted 11 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 17
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +9
-0+maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,array-v1 + + trace_flags:Underscores are not allowed. Does not look like generic property.
Quoted 2 lines
Let me make it "trace-flags" to not have underscores. Could you please elaborate on what you mean by generic property?
Generic property, so one without vendor prefix, is shared and common to a group of devices.
Quoted 44 lines
Quoted 4 lines
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 24
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +7
-0+ $ref: /schemas/types.yaml#/definitions/uint32 + description: + Bitmap of all the trace flags that were enabled in the trace array at the + point of serialization. + +# Subnodes will be of type "ftrace,cpu-v1", one each per CPU +additionalProperties: trueNo, this must be false. And it goes after required:
Ok, making it false and adding pattern matches instead for subnodes.
Quoted 15 lines
Quoted 4 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +2
-0+ +required:Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 36
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +10
-0+ - compatible + - trace_flags + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace {Again, no underscores.
Ok :)
Quoted 7 lines
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +6
-0+ compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >;
Quoted 6 lines
Quoted 1 line
Drop redundant spaces.
I don't understand what you're referring to as redundant spaces? Double checking, I believe indentation is off for every line below "ftrace {". Is that what you're referring to? Fixing :)
Open DTS, some recent, arm64 like Qualcomm. Do you see spaces around <>? Or open the coding style document... Please do not introduce different coding style.
Quoted 8 lines
Quoted 5 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 43
Quoted 4 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +1
-0+ mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>;? Do you see any of such syntax in DTS?
I was trying to make it easy to reason to readers about 64bit numbers -
64bit numbers are not a problem for DTS reading. Above syntax is.
Quoted 5 lines
and then potentially extend dtc to consume that new syntax. KHO DTs are native/little endian, so dtc already has some difficulties interpreting it which I'll need to fix up with patches to it eventually :). I'll change it to something that looks more 32bit'y for now.
Best regards,
Krzysztof
Rob Herring
maintainerRe: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
In reply to Alexander GrafQuoted 16 lines · Alexander Graf
Hi Krzysztof!
Thanks a lot for the fast review!
Quoted 11 lines · Krzysztof Kozlowski
Quoted 5 lines · Alexander Graf
With ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
Please use
scripts/get_maintainers.plto get a list of necessary people and lists to CC (and consider --no-git-fallback argument). It might happen, that command when run on an older kernel, gives you outdated entries. Therefore please be sure you base your patches on recent Linux kernel.
[...]
Quoted 10 lines
Quoted 3 lines
Quoted 2 lines
+ mem = <
0x101000000ULL0x38ULL0x101000100ULL0x1000ULL0x101000038ULL0x38ULL0x101002000ULL0x1000ULL>;? Do you see any of such syntax in DTS?
I was trying to make it easy to reason to readers about 64bit numbers - and then potentially extend dtc to consume that new syntax. KHO DTs are native/little endian, so dtc already has some difficulties interpreting it which I'll need to fix up with patches to it eventually :). I'll change it to something that looks more 32bit'y for now.
"/bits/ 64 <0x0 ...>" is what you are looking for.
Rob
Rob Herring
maintainerRe: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
In reply to Alexander GrafQuoted 5 lines · Alexander Graf
With ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
Why so much data in DT rather than putting all this information into memory in your own data structure and DT just has a single property pointing to that? That's what is done with every other blob of data passed by kexec.
Quoted 30 lines
Signed-off-by Alexander Graf <[email protected]>--- .../bindings/kho/ftrace/ftrace-array.yaml | 46 +++++++++++++++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 +++++++++++++++++++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++++++++++++++++ 3 files changed, 150 insertions(+) create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml create mode 100644 Documentation/devicetree/bindings/kho/ftrace/ftrace.yamlDocumentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +13
-0@@ -0,0 +1,46 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace-array.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace trace array + +maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible:
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 23
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +10
-0+ enum: + - ftrace,array-v1 + + trace_flags: + $ref: /schemas/types.yaml#/definitions/uint32 + description: + Bitmap of all the trace flags that were enabled in the trace array at the + point of serialization. + +# Subnodes will be of type "ftrace,cpu-v1", one each per CPU
This can be expressed as a schema.
Quoted 37 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +23
-0+additionalProperties: true + +required: + - compatible + - trace_flags + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + };Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +8
-0@@ -0,0 +1,56 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace-cpu.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace per-CPU ring buffer contents +
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml line 18
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +10
-0+maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,cpu-v1 + + cpu: + $ref: /schemas/types.yaml#/definitions/uint32
'cpu' is already a defined property of type 'phandle'. While we can have multiple types for a given property name, best practice is to avoid that. The normal way to refer to a CPU would be a phandle to the CPU node, but I can see that might not make sense here.
"CPU numbers" on arm64 are 64-bit values as well as they are the CPU's MPIDR value.
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml line 23
Quoted 5 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +5
-0+ description: + CPU number of the CPU that this ring buffer belonged to when it was + serialized. + + mem:
Too vague. Make the property name indicate what's in the memory.
Quoted 46 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +33
-0+ $ref: /schemas/types.yaml#/definitions/uint32-array + description: + Array of { u64 phys_addr, u64 len } elements that describe a list of ring + buffer pages. Each page consists of two elements. The first element + describes the location of the struct buffer_page that contains metadata + for a given ring buffer page, such as the ring's head indicator. The + second element points to the ring buffer data page which contains the raw + trace data. + +additionalProperties: false + +required: + - compatible + - cpu + - mem + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + };Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +7
-0@@ -0,0 +1,48 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace core data
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml line 17
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +10
-0+ +maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace-v1 + + events:
Again, too vague.
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +7
-0+ $ref: /schemas/types.yaml#/definitions/uint32-array + description: + Array of { u32 crc, u32 type } elements. Each element contains a unique + identifier for an event, followed by the identifier that this event had + in the previous kernel's trace buffers. + +# Other child nodes will be of type "ftrace,array-v1". Each of which describe
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml line 34
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +10
-0+# a trace buffer +additionalProperties: true + +required: + - compatible + - events + +examples: + - | + ftrace {
This should go under /chosen. Show that here. Start the example with '/{' to do that and not add the usual boilerplate we add when extracting the examples.
Also, we don't need 3 examples. Just do 1 complete example here.
Quoted 30 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +14
-0+ compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + };Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Re: [PATCH v2 02/17] memblock: Declare scratch memory as CMA
In reply to Alexander GrafQuoted 43 lines · Alexander Graf
When we finish populating our memory, we don't want to lose the scratch region as memory we can use for useful data. Do do that, we mark it as CMA memory. That means that any allocation within it only happens with movable memory which we can then happily discard for the next kexec.
That way we don't lose the scratch region's memory anymore for allocations after boot.
Signed-off-by Alexander Graf <[email protected]>---
v1 -> v2:
- test bot warning fix
--- mm/memblock.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-)mm/memblock.c +1
-4@@ -16,6 +16,7 @@#include <linux/kmemleak.h> #include <linux/seq_file.h> #include <linux/memblock.h> +#include <linux/page-isolation.h> #include <asm/sections.h> #include <linux/io.h> @@ -1100,10 +1101,6 @@ static bool should_skip_region(struct memblock_type *type,if ((flags &MEMBLOCK_SCRATCH ) && !memblock_is_scratch (m))return true; -/* Leave scratch memory alone after scratch-only phase */ -if (!(flags &MEMBLOCK_SCRATCH ) &&memblock_is_scratch (m)) -return true; -return false; }
mm/memblock.c static void __init __free_pages_memory(unsigned long start, unsigned long end) · line 2154
Quoted 5 lines
mm/memblock.c +2
-0@@ -2153,6 +2150,20 @@ static void __init __free_pages_memory(unsigned long start, unsigned long end) } } +#ifdef CONFIG_MEMBLOCK_SCRATCH +static void reserve_scratch_mem (phys_addr_t start,phys_addr_t end)
nit: the function name doesn't look reasonable as it has nothing limiting it to neither reservation nor scratch mem. Perhaps something like "set_mem_cma_type" would be a better fit.
mm/memblock.c static void __init __free_pages_memory(unsigned long start, unsigned long end) · line 2161
Quoted 7 lines
mm/memblock.c +7
-0+{ +ulong start_pfn =pageblock_start_pfn (PFN_DOWN (start)); +ulong end_pfn =pageblock_align (PFN_UP (end)); +ulong pfn; + +for (pfn = start_pfn; pfn < end_pfn; pfn += pageblock_nr_pages) { +/* Mark as CMA to prevent kernel allocations in it */
nit: the comment above looks irrelevant/redundant.
Quoted 41 lines
mm/memblock.c +16
-0+ set_pageblock_migratetype(pfn_to_page(pfn), MIGRATE_CMA); + } +} +#endif +static unsigned long __init __free_memory_core (phys_addr_t start,phys_addr_t end) {@@ -2214,6 +2225,17 @@ static unsigned long __init free_low_memory_core_early(void)memmap_init_reserved_pages (); +#ifdef CONFIG_MEMBLOCK_SCRATCH +/* +* Mark scratch mem as CMA before we return it. That way we ensure that +* no kernel allocations happen on it. That means we can reuse it as +* scratch memory again later. +*/ +__for_each_mem_range (i, &memblock.memory,NULL ,NUMA_NO_NODE , +MEMBLOCK_SCRATCH , &start, &end,NULL ) +reserve_scratch_mem (start, end); +#endif +/* * We need to use NUMA_NO_NODE instead of NODE_DATA(0)->node_id * because in some case like Node0 doesn't have RAM installed Signature · 12 lines
2.40.1 Amazon Development Center Germany GmbH Krausenstr. 38 10117 Berlin Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B Sitz: Berlin Ust-ID: DE 289 237 879
Re: [PATCH v2 04/17] kexec: Add KHO parsing support
In reply to Alexander GrafQuoted 19 lines · Alexander Graf
kernel/kexec_kho_in.c new file +19
-0+/** +* kho_reserve_previous_mem - Adds all memory reservations into memblocks +* and moves us out of the scratch only phase. Must be called after page tables +* are initialized and memblock_allow_resize(). +*/ +void __init kho_reserve_previous_mem (void ) +{ +void *mem_virt =__va (mem_phys); +int off, err; + +if (!handover_phys || !mem_phys) +return ; + +/* +* We reached here because we are running inside a working linear map +* that allows us to resize memblocks dynamically. Use the chance and +* populate the global fdt pointer +*/ + fdt =__va (handover_phys);
kernel/kexec_kho_in.c line 179
Quoted 10 lines
kernel/kexec_kho_in.c new file +10
-0+ + off =fdt_path_offset (fdt,"/" ); +if (off <0 ) { + fdt =NULL ; +return ; + } + + err =fdt_node_check_compatible (fdt, off,"kho-v1" ); +if (err) { +pr_warn ("KHO has invalid compatible, disabling." );
It looks like KHO preserved regions won't be reserved in this case. Should KHO DT state be destroyed here to prevent KHO memory regions reuse upon rollback?
Quoted 29 lines
kernel/kexec_kho_in.c new file +29
-0+ +void __init kho_populate (phys_addr_t handover_dt_phys,phys_addr_t scratch_phys, +u64 scratch_len,phys_addr_t mem_cache_phys, +u64 mem_cache_len) +{ +void *handover_dt; + +/* Determine the real size of the DT */ + handover_dt =early_memremap (handover_dt_phys,sizeof (struct fdt_header )); +if (!handover_dt) { +pr_warn ("setup: failed to memremap kexec FDT (0x%llx)\n" , handover_dt_phys); +return ; + } + +if (fdt_check_header (handover_dt)) { +pr_warn ("setup: kexec handover FDT is invalid (0x%llx)\n" , handover_dt_phys); +early_memunmap (handover_dt,PAGE_SIZE ); +return ; + } + + handover_len =fdt_totalsize (handover_dt); + handover_phys = handover_dt_phys; + +/* Reserve the DT so we can still access it in late boot */ +memblock_reserve (handover_phys, handover_len); + +/* Reserve the mem cache so we can still access it later */ +memblock_reserve (mem_cache_phys, mem_cache_len); +
kernel/kexec_kho_in.c line 274
Quoted 10 lines
kernel/kexec_kho_in.c new file +10
-0+/* +* We pass a safe contiguous block of memory to use for early boot purporses from +* the previous kernel so that we can resize the memblock array as needed. +*/ +memblock_add (scratch_phys, scratch_len); + +if (WARN_ON (memblock_mark_scratch (scratch_phys, scratch_len))) { +pr_err ("Kexec failed to mark the scratch region. Disabling KHO." ); + handover_len =0 ; + handover_phys =0 ;
Same question here: doesn't all the KHO state gets invalid in case of any restoration error?
Re: [PATCH v2 07/17] kexec: Add documentation for KHO
In reply to Alexander GrafQuoted 22 lines · Alexander Graf
Documentation/kho/concepts.rst new file +16
-0@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec. + +It introduces multiple concepts: + +KHO Device Tree +--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to
Documentation/kho/concepts.rst line 26
Quoted 10 lines
Documentation/kho/concepts.rst new file +10
-0+serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state. + +KHO only uses the fdt container format and libfdt library, but does not +adhere to the same property semantics that normal device trees do: Properties +are passed in native endianness and standardized properties like ``regs`` and +``ranges`` do not exist, hence there are no ``#...-cells`` properties. + +KHO introduces a new concept to its device tree: ``mem`` properties. A +``mem`` property can inside any subnode in the device tree. When present,
Should it be "property can be" ?
...
Quoted 14 lines
Documentation/kho/usage.rst new file +8
-0@@ -0,0 +1,57 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +==================== +Kexec Handover Usage +==================== + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec.
Documentation/kho/usage.rst line 18
Quoted 10 lines
Documentation/kho/usage.rst new file +10
-0+ +This document expects that you are familiar with the base KHO +:ref:`Documentation/kho/concepts.rst <concepts>`. If you have not read +them yet, please do so now. + +Prerequisites +------------- + +KHO is available when the ``CONFIG_KEXEC_KHO`` config option is set to y +at compile team. Every KHO producer has its own config option that you
Should it be "at compile time."?
Re: [PATCH v2 07/17] kexec: Add documentation for KHO
In reply to Alexander GrafQuoted 29 lines · Alexander Graf
With KHO in place, let's add documentation that describes what it is and how to use it.
Signed-off-by Alexander Graf <[email protected]>--- Documentation/kho/concepts.rst | 88 ++++++++++++++++++++++++++++++++ Documentation/kho/index.rst | 19 +++++++ Documentation/kho/usage.rst | 57 +++++++++++++++++++++ Documentation/subsystem-apis.rst | 1 + 4 files changed, 165 insertions(+) create mode 100644 Documentation/kho/concepts.rst create mode 100644 Documentation/kho/index.rst create mode 100644 Documentation/kho/usage.rstDocumentation/kho/concepts.rst new file +8
-0@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec.
Documentation/kho/concepts.rst line 18
Quoted 10 lines
Documentation/kho/concepts.rst new file +10
-0+ +It introduces multiple concepts: + +KHO Device Tree +--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to +serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state.
How does this work with kexec when there is also the FDT for the h/w? The h/w FDT has a /chosen property pointing to this FDT blob?
Documentation/kho/concepts.rst line 23
Quoted 5 lines
Documentation/kho/concepts.rst new file +5
-0+ +KHO only uses the fdt container format and libfdt library, but does not +adhere to the same property semantics that normal device trees do: Properties +are passed in native endianness and standardized properties like ``regs`` and +``ranges`` do not exist, hence there are no ``#...-cells`` properties.
I think native endianness is asking for trouble. libfdt would need different swap functions here than elsewhere in the kernel for example which wouldn't even work. So you are just crossing your fingers that you aren't using any libfdt functions that swap. And when I sync dtc/libfdt and that changes, I might break you.
Also, if you want to dump the FDT and do a dtc DTB->DTS pass, it is not going to be too readable given that outputs swapped 32-bit values for anything that's a 4 byte multiple.
Quoted 9 lines
Documentation/kho/concepts.rst new file +9
-0+ +KHO introduces a new concept to its device tree: ``mem`` properties. A +``mem`` property can inside any subnode in the device tree. When present, +it contains an array of physical memory ranges that the new kernel must mark +as reserved on boot. It is recommended, but not required, to make these ranges +as physically contiguous as possible to reduce the number of array elements :: + + struct kho_mem { + __u64 addr;
Documentation/kho/concepts.rst line 42
Quoted 10 lines
Documentation/kho/concepts.rst new file +10
-0+ __u64 len; + }; + +After boot, drivers can call the kho subsystem to transfer ownership of memory +that was reserved via a ``mem`` property to themselves to continue using memory +from the previous execution. + +The KHO device tree follows the in-Linux schema requirements. Any element in +the device tree is documented via device tree schema yamls that explain what +data gets transferred.
If this is all separate, then I think the schemas should be too. And then from my (DT maintainer) perspective, you can do whatever you want here (like FIT images). The dtschema tools are pretty much only geared for "normal" DTs. A couple of problems come to mind. You can't exclude or change standard properties. The decoding of the DTB to run validation assumes big endian. We could probably split things up a bit, but you may be better off just using jsonschema directly. I'm not even sure running validation here would that valuable. You have 1 source of code generating the DT and 1 consumer. Yes, there's different kernel versions to deal with, but it's not 100s of people creating 1000s of DTs with 100s of nodes.
You might look at the netlink stuff which is using its own yaml syntax to generate code and jsonschema is used to validate the yaml.
Rob
Alexander Graf
reviewerRe: [PATCH v2 04/17] kexec: Add KHO parsing support
In reply to Stanislav KinsburskiiQuoted 25 lines · Stanislav Kinsburskii
Quoted 24 lines · Alexander Graf
kernel/kexec_kho_in.c new file +24
-0+/** +* kho_reserve_previous_mem - Adds all memory reservations into memblocks +* and moves us out of the scratch only phase. Must be called after page tables +* are initialized and memblock_allow_resize(). +*/ +void __init kho_reserve_previous_mem (void ) +{ +void *mem_virt =__va (mem_phys); +int off, err; + +if (!handover_phys || !mem_phys) +return ; + +/* +* We reached here because we are running inside a working linear map +* that allows us to resize memblocks dynamically. Use the chance and +* populate the global fdt pointer +*/ + fdt =__va (handover_phys); + + off =fdt_path_offset (fdt,"/" ); +if (off <0 ) { + fdt =NULL ; +return ;
Quoted 8 lines
kernel/kexec_kho_in.c line 179
Quoted 5 lines
kernel/kexec_kho_in.c new file +5
-0+ } + + err =fdt_node_check_compatible (fdt, off,"kho-v1" ); +if (err) { +pr_warn ("KHO has invalid compatible, disabling." );It looks like KHO preserved regions won't be reserved in this case. Should KHO DT state be destroyed here to prevent KHO memory regions reuse upon rollback?
Good catch. I'll set fdt to NULL in that case in v3.
Quoted 34 lines
Quoted 34 lines
kernel/kexec_kho_in.c new file +33
-0+ +void __init kho_populate (phys_addr_t handover_dt_phys,phys_addr_t scratch_phys, +u64 scratch_len,phys_addr_t mem_cache_phys, +u64 mem_cache_len) +{ +void *handover_dt; + +/* Determine the real size of the DT */ + handover_dt =early_memremap (handover_dt_phys,sizeof (struct fdt_header )); +if (!handover_dt) { +pr_warn ("setup: failed to memremap kexec FDT (0x%llx)\n" , handover_dt_phys); +return ; + } + +if (fdt_check_header (handover_dt)) { +pr_warn ("setup: kexec handover FDT is invalid (0x%llx)\n" , handover_dt_phys); +early_memunmap (handover_dt,PAGE_SIZE ); +return ; + } + + handover_len =fdt_totalsize (handover_dt); + handover_phys = handover_dt_phys; + +/* Reserve the DT so we can still access it in late boot */ +memblock_reserve (handover_phys, handover_len); + +/* Reserve the mem cache so we can still access it later */ +memblock_reserve (mem_cache_phys, mem_cache_len); + +/* +* We pass a safe contiguous block of memory to use for early boot purporses from +* the previous kernel so that we can resize the memblock array as needed. +*/
Quoted 8 lines
kernel/kexec_kho_in.c line 274
Quoted 6 lines
kernel/kexec_kho_in.c new file +6
-0+memblock_add (scratch_phys, scratch_len); + +if (WARN_ON (memblock_mark_scratch (scratch_phys, scratch_len))) { +pr_err ("Kexec failed to mark the scratch region. Disabling KHO." ); + handover_len =0 ; + handover_phys =0 ;Same question here: doesn't all the KHO state gets invalid in case of any restoration error?
It does, which is what the error case here does, no? Or are you referring to the fact that we're not unrolling the memblock reservations? If we can't mark the scratch region, I'd rather leave everything else alone. It means the scratch region is in a hole, which should never happen.
Alex
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
Alexander Graf
reviewerRe: [PATCH v2 17/17] devicetree: Add bindings for ftrace KHO
In reply to Rob HerringHey Rob,
Thanks a lot for taking the time to review!
Quoted 10 lines · Rob Herring
Quoted 5 lines · Alexander Graf
With ftrace in KHO, we are creating an ABI between old kernel and new kernel about the state that they transfer. To ensure that we document that state and catch any breaking change, let's add its schema to the common devicetree bindings. This way, we can quickly reason about the state that gets passed.
Why so much data in DT rather than putting all this information into memory in your own data structure and DT just has a single property pointing to that? That's what is done with every other blob of data passed by kexec.
This is our own data structure for KHO that just happens to again contain a DT structure. The reason is simple: I want a unified, versioned, introspectable data format that is cross platform so you don't need to touch every architecture specific boot passing logic every time you want to add a tiny piece of data.
Quoted 33 lines
Quoted 33 lines
Signed-off-by Alexander Graf <[email protected]>--- .../bindings/kho/ftrace/ftrace-array.yaml | 46 +++++++++++++++ .../bindings/kho/ftrace/ftrace-cpu.yaml | 56 +++++++++++++++++++ .../bindings/kho/ftrace/ftrace.yaml | 48 ++++++++++++++++ 3 files changed, 150 insertions(+)create mode 100644
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yamlcreate mode 100644Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yamlcreate mode 100644Documentation/devicetree/bindings/kho/ftrace/ftrace.yamlDocumentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +16
-0@@ -0,0 +1,46 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace-array.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace trace array + +maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,array-v1 +
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml line 23
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +7
-0+ trace_flags: + $ref: /schemas/types.yaml#/definitions/uint32 + description: + Bitmap of all the trace flags that were enabled in the trace array at the + point of serialization. + +# Subnodes will be of type "ftrace,cpu-v1", one each per CPUThis can be expressed as a schema.
Could you please give me a few more hints here? I'm not sure I understand how :)
Quoted 53 lines
Quoted 38 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-array.yaml new file +23
-0+additionalProperties: true + +required: + - compatible + - trace_flags + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + };Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +8
-0@@ -0,0 +1,56 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace-cpu.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace per-CPU ring buffer contents +Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml line 18
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +10
-0+maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace,cpu-v1 + + cpu: + $ref: /schemas/types.yaml#/definitions/uint32'cpu' is already a defined property of type 'phandle'. While we can have multiple types for a given property name, best practice is to avoid that. The normal way to refer to a CPU would be a phandle to the CPU node, but I can see that might not make sense here.
Quoted 2 lines
"CPU numbers" on arm64 are 64-bit values as well as they are the CPU's MPIDR value.
Here we're looking at the Linux internal CPU numbering which I believe does not have to use the MIDR value?
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml line 23
Quoted 6 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +5
-0+ description: + CPU number of the CPU that this ring buffer belonged to when it was + serialized. + + mem:Too vague. Make the property name indicate what's in the memory.
"mem" is a generic property for every node in the KHO DT that contains a <u64 phys_start, u64 size> array that describes memory to pass over. I use it in generic code so that we don't need to do memory reservations individually per node. That means I can't change the name here.
Quoted 69 lines
Quoted 47 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace-cpu.yaml new file +33
-0+ $ref: /schemas/types.yaml#/definitions/uint32-array + description: + Array of { u64 phys_addr, u64 len } elements that describe a list of ring + buffer pages. Each page consists of two elements. The first element + describes the location of the struct buffer_page that contains metadata + for a given ring buffer page, such as the ring's head indicator. The + second element points to the ring buffer data page which contains the raw + trace data. + +additionalProperties: false + +required: + - compatible + - cpu + - mem + +examples: + - | + ftrace { + compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1"; + cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + };Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +7
-0@@ -0,0 +1,48 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/kho/ftrace/ftrace.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Ftrace core dataDocumentation/devicetree/bindings/kho/ftrace/ftrace.yaml line 17
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +10
-0+ +maintainers: + - Alexander Graf <[email protected]> + +properties: + compatible: + enum: + - ftrace-v1 + + events:Again, too vague.
Quoted 10 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +10
-0+ $ref: /schemas/types.yaml#/definitions/uint32-array + description: + Array of { u32 crc, u32 type } elements. Each element contains a unique + identifier for an event, followed by the identifier that this event had + in the previous kernel's trace buffers. + +# Other child nodes will be of type "ftrace,array-v1". Each of which describe +# a trace buffer +additionalProperties: true +
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml line 34
Quoted 7 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +7
-0+required: + - compatible + - events + +examples: + - | + ftrace {This should go under /chosen. Show that here. Start the example with
It can't go under /chosen because x86 doesn't have /chosen :). This is not a device DT, it's a KHO DT.
Quoted 2 lines
'/{' to do that and not add the usual boilerplate we add when extracting the examples.
What exact difference does /{ and ftrace { make?
Quoted 2 lines
Also, we don't need 3 examples. Just do 1 complete example here.
Great idea :)
Quoted 11 lines
Quoted 11 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +9
-0+ compatible = "ftrace-v1"; + events = <1 1 2 2 3 3>; + + global_trace { + compatible = "ftrace,array-v1"; + trace_flags = < 0x3354601 >; + + cpu0 { + compatible = "ftrace,cpu-v1";
Quoted 8 lines
Quoted 8 lines
Documentation/devicetree/bindings/kho/ftrace/ftrace.yaml new file +5
-1+ cpu = < 0x00 >; + mem = < 0x101000000ULL 0x38ULL 0x101000100ULL 0x1000ULL 0x101000038ULL 0x38ULL 0x101002000ULL 0x1000ULL>; + }; + }; + }; --2.40.1
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
Alexander Graf
reviewerRe: [PATCH v2 07/17] kexec: Add documentation for KHO
In reply to Rob HerringQuoted 34 lines · Rob Herring
Quoted 32 lines · Alexander Graf
With KHO in place, let's add documentation that describes what it is and how to use it.
Signed-off-by Alexander Graf <[email protected]>--- Documentation/kho/concepts.rst | 88 ++++++++++++++++++++++++++++++++ Documentation/kho/index.rst | 19 +++++++ Documentation/kho/usage.rst | 57 +++++++++++++++++++++ Documentation/subsystem-apis.rst | 1 + 4 files changed, 165 insertions(+)create mode 100644
Documentation/kho/concepts.rstcreate mode 100644Documentation/kho/index.rstcreate mode 100644Documentation/kho/usage.rstDocumentation/kho/concepts.rst new file +12
-0@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec. + +It introduces multiple concepts: + +KHO Device Tree
Quoted 8 lines
Documentation/kho/concepts.rst line 18
Quoted 6 lines
Documentation/kho/concepts.rst new file +6
-0+--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to +serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state.How does this work with kexec when there is also the FDT for the h/w? The h/w FDT has a /chosen property pointing to this FDT blob?
Yep, exactly.
Quoted 12 lines
Documentation/kho/concepts.rst line 23
Quoted 6 lines
Documentation/kho/concepts.rst new file +5
-0+ +KHO only uses the fdt container format and libfdt library, but does not +adhere to the same property semantics that normal device trees do: Properties +are passed in native endianness and standardized properties like ``regs`` and +``ranges`` do not exist, hence there are no ``#...-cells`` properties.I think native endianness is asking for trouble. libfdt would need different swap functions here than elsewhere in the kernel for example which wouldn't even work. So you are just crossing your fingers that you aren't using any libfdt functions that swap. And when I sync dtc/libfdt and that changes, I might break you.
Quoted 3 lines
Also, if you want to dump the FDT and do a dtc
DTB->DTSpass, it is not going to be too readable given that outputs swapped 32-bit values for anything that's a 4 byte multiple.
Yeah, but big endian these days is just a complete waste of brain and cpu cycles :). And yes, I don't really want to use any libfdt helper functions to read data. I use it only to give me the raw data and take it from there.
Quoted 32 lines
Quoted 10 lines
Documentation/kho/concepts.rst new file +9
-0+ +KHO introduces a new concept to its device tree: ``mem`` properties. A +``mem`` property can inside any subnode in the device tree. When present, +it contains an array of physical memory ranges that the new kernel must mark +as reserved on boot. It is recommended, but not required, to make these ranges +as physically contiguous as possible to reduce the number of array elements :: + + struct kho_mem { + __u64 addr;Documentation/kho/concepts.rst line 42
Quoted 10 lines
Documentation/kho/concepts.rst new file +10
-0+ __u64 len; + }; + +After boot, drivers can call the kho subsystem to transfer ownership of memory +that was reserved via a ``mem`` property to themselves to continue using memory +from the previous execution. + +The KHO device tree follows the in-Linux schema requirements. Any element in +the device tree is documented via device tree schema yamls that explain what +data gets transferred.If this is all separate, then I think the schemas should be too. And then from my (DT maintainer) perspective, you can do whatever you want here (like FIT images). The dtschema tools are pretty much only geared for "normal" DTs. A couple of problems come to mind. You can't exclude or change standard properties. The decoding of the DTB to run validation assumes big endian. We could probably split things up a bit, but you may be better off just using jsonschema directly. I'm not even sure running validation here would that valuable. You have 1 source of code generating the DT and 1 consumer. Yes, there's different kernel versions to deal with, but it's not 100s of people creating 1000s of DTs with 100s of nodes.
Quoted 2 lines
You might look at the netlink stuff which is using its own yaml syntax to generate code and jsonschema is used to validate the yaml.
I'm currently a lot more interested in the documentation aspect than in the validation, yeah. So I think for v3, I'll just throw the schemas into the Documentation/kho directory without any validation. We can worry about that later :)
Thanks a lot again for the review!
Alex
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
Re: [PATCH v2 07/17] kexec: Add documentation for KHO
Quoted 35 lines · Alexander Graf
Quoted 32 lines · Rob Herring
Quoted 30 lines · Alexander Graf
With KHO in place, let's add documentation that describes what it is and how to use it.
Signed-off-by Alexander Graf <[email protected]>--- Documentation/kho/concepts.rst | 88 ++++++++++++++++++++++++++++++++ Documentation/kho/index.rst | 19 +++++++ Documentation/kho/usage.rst | 57 +++++++++++++++++++++ Documentation/subsystem-apis.rst | 1 + 4 files changed, 165 insertions(+)create mode 100644
Documentation/kho/concepts.rstcreate mode 100644Documentation/kho/index.rstcreate mode 100644Documentation/kho/usage.rstDocumentation/kho/concepts.rst new file +10
-0@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec. + +It introduces multiple concepts:
Quoted 8 lines
Quoted 8 lines
Documentation/kho/concepts.rst line 18
Quoted 8 lines
Documentation/kho/concepts.rst new file +8
-0+ +KHO Device Tree +--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to +serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state.
Can you avoid calling anything "device tree" as much as possible. We can't avoid the format is FDT/DTB, but otherwise none of this is Devicetree as most folks know it. Sure, there can be trees of devices which are not Devicetree, but this is neither. You could have used BSON or any hierarchical key-value pair serialization format just as easily (if we already had a parser in the kernel).
Quoted 5 lines
Quoted 2 lines
How does this work with kexec when there is also the FDT for the h/w? The h/w FDT has a /chosen property pointing to this FDT blob?
Yep, exactly.
Those properties need to be documented here[1].
[...]
Quoted 30 lines
Quoted 30 lines
Quoted 8 lines
Documentation/kho/concepts.rst new file +8
-0+KHO introduces a new concept to its device tree: ``mem`` properties. A +``mem`` property can inside any subnode in the device tree. When present, +it contains an array of physical memory ranges that the new kernel must mark +as reserved on boot. It is recommended, but not required, to make these ranges +as physically contiguous as possible to reduce the number of array elements :: + + struct kho_mem { + __u64 addr;Documentation/kho/concepts.rst line 42
Quoted 10 lines
Documentation/kho/concepts.rst new file +10
-0+ __u64 len; + }; + +After boot, drivers can call the kho subsystem to transfer ownership of memory +that was reserved via a ``mem`` property to themselves to continue using memory +from the previous execution. + +The KHO device tree follows the in-Linux schema requirements. Any element in +the device tree is documented via device tree schema yamls that explain what +data gets transferred.If this is all separate, then I think the schemas should be too. And then from my (DT maintainer) perspective, you can do whatever you want here (like FIT images). The dtschema tools are pretty much only geared for "normal" DTs. A couple of problems come to mind. You can't exclude or change standard properties. The decoding of the DTB to run validation assumes big endian. We could probably split things up a bit, but you may be better off just using jsonschema directly. I'm not even sure running validation here would that valuable. You have 1 source of code generating the DT and 1 consumer. Yes, there's different kernel versions to deal with, but it's not 100s of people creating 1000s of DTs with 100s of nodes.
Quoted 8 lines
Quoted 2 lines
You might look at the netlink stuff which is using its own yaml syntax to generate code and jsonschema is used to validate the yaml.
I'm currently a lot more interested in the documentation aspect than in the validation, yeah. So I think for v3, I'll just throw the schemas into the
Documentation/khodirectory without any validation. We can worry about that later :)
I'll regret that when I get patches fixing them, but okay.
Rob
[1] https://github.com/devicetree-org/dt-schema/blob/main/dtschema/schemas/chosen.yaml
Alexander Graf
reviewerRe: [PATCH v2 07/17] kexec: Add documentation for KHO
Quoted 40 lines · Rob Herring
Quoted 39 lines · Alexander Graf
Quoted 37 lines · Rob Herring
Quoted 36 lines · Alexander Graf
With KHO in place, let's add documentation that describes what it is and how to use it.
Signed-off-by Alexander Graf <[email protected]>--- Documentation/kho/concepts.rst | 88 ++++++++++++++++++++++++++++++++ Documentation/kho/index.rst | 19 +++++++ Documentation/kho/usage.rst | 57 +++++++++++++++++++++ Documentation/subsystem-apis.rst | 1 + 4 files changed, 165 insertions(+)create mode 100644
Documentation/kho/concepts.rstcreate mode 100644Documentation/kho/index.rstcreate mode 100644Documentation/kho/usage.rstDocumentation/kho/concepts.rst new file +16
-0@@ -0,0 +1,88 @@ +.. SPDX-License-Identifier: GPL-2.0-or-later + +======================= +Kexec Handover Concepts +======================= + +Kexec HandOver (KHO) is a mechanism that allows Linux to preserve state - +arbitrary properties as well as memory locations - across kexec. + +It introduces multiple concepts: + +KHO Device Tree +--------------- + +Every KHO kexec carries a KHO specific flattened device tree blob that +describes the state of the system. Device drivers can register to KHO to
Quoted 8 lines
Quoted 2 lines
Quoted 2 lines
Documentation/kho/concepts.rst line 18
Quoted 2 lines
Documentation/kho/concepts.rst new file +2
-0+serialize their state before kexec. After KHO, device drivers can read +the device tree and extract previous state.Can you avoid calling anything "device tree" as much as possible. We can't avoid the format is FDT/DTB, but otherwise none of this is Devicetree as most folks know it. Sure, there can be trees of devices which are not Devicetree, but this is neither. You could have used BSON or any hierarchical key-value pair serialization format just as easily (if we already had a parser in the kernel).
I understand and agree - it's been confusing to pretty much everyone who was looking at KHO so far. Unfortunately I'm terrible at naming. Do you happen to have a good suggestion? :)
Quoted 6 lines
Quoted 5 lines
Quoted 3 lines
How does this work with kexec when there is also the FDT for the h/w? The h/w FDT has a /chosen property pointing to this FDT blob?
Yep, exactly.
Those properties need to be documented here[1].
Oooh, thanks a lot for the pointer! I'll add them :)
Alex
Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879