mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2026-05-05 09:57:21 +02:00
Jason Miu
3f2ad90060
Patch series "Make KHO Stateless", v9.
This series transitions KHO from an xarray-based metadata tracking system
with serialization to a radix tree data structure that can be passed
directly to the next kernel.
The key motivations for this change are to:
- Eliminate the need for data serialization before kexec.
- Remove the KHO finalize state.
- Pass preservation metadata more directly to the next kernel via the FDT.
The new approach uses a radix tree to mark preserved pages. A page's
physical address and its order are encoded into a single value. The tree
is composed of multiple levels of page-sized tables, with leaf nodes being
bitmaps where each set bit represents a preserved page. The physical
address of the radix tree's root is passed in the FDT, allowing the next
kernel to reconstruct the preserved memory map.
This series is broken down into the following patches:
1. kho: Adopt radix tree for preserved memory tracking:
Replaces the xarray-based tracker with the new radix tree
implementation and increments the ABI version.
2. kho: Remove finalize state and clients:
Removes the now-obsolete kho_finalize() function and its usage
from client code and debugfs.
This patch (of 2):
Introduce a radix tree implementation for tracking preserved memory pages
and switch the KHO memory tracking mechanism to use it. This lays the
groundwork for a stateless KHO implementation that eliminates the need for
serialization and the associated "finalize" state.
This patch introduces the core radix tree data structures and constants to
the KHO ABI. It adds the radix tree node and leaf structures, along with
documentation for the radix tree key encoding scheme that combines a
page's physical address and order.
To support broader use by other kernel subsystems, such as hugetlb
preservation, the core radix tree manipulation functions are exported as a
public API.
The xarray-based memory tracking is replaced with this new radix tree
implementation. The core KHO preservation and unpreservation functions
are wired up to use the radix tree helpers. On boot, the second kernel
restores the preserved memory map by walking the radix tree whose root
physical address is passed via the FDT.
The ABI `compatible` version is bumped to "kho-v2" to reflect the
structural changes in the preserved memory map and sub-FDT property names.
This includes renaming "fdt" to "preserved-data" to better reflect that
preserved state may use formats other than FDT.
[ran.xiaokai@zte.com.cn: fix child node parsing for debugfs in/sub_fdts]
Link: https://lkml.kernel.org/r/20260309033530.244508-1-ranxiaokai627@163.com
Link: https://lkml.kernel.org/r/20260206021428.3386442-1-jasonmiu@google.com
Link: https://lkml.kernel.org/r/20260206021428.3386442-2-jasonmiu@google.com
Signed-off-by: Jason Miu <jasonmiu@google.com>
Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
Reviewed-by: Pasha Tatashin <pasha.tatashin@soleen.com>
Reviewed-by: Mike Rapoport (Microsoft) <rppt@kernel.org>
Cc: Alexander Graf <graf@amazon.com>
Cc: Baoquan He <bhe@redhat.com>
Cc: Changyuan Lyu <changyuanl@google.com>
Cc: David Matlack <dmatlack@google.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Jason Gunthorpe <jgg@nvidia.com>
Cc: Pratyush Yadav <pratyush@kernel.org>
Cc: Ran Xiaokai <ran.xiaokai@zte.com.cn>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
71 lines
2.1 KiB
C
71 lines
2.1 KiB
C
/* SPDX-License-Identifier: GPL-2.0 */
|
|
|
|
#ifndef _LINUX_KHO_RADIX_TREE_H
|
|
#define _LINUX_KHO_RADIX_TREE_H
|
|
|
|
#include <linux/err.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/mutex_types.h>
|
|
#include <linux/types.h>
|
|
|
|
/**
|
|
* DOC: Kexec Handover Radix Tree
|
|
*
|
|
* This is a radix tree implementation for tracking physical memory pages
|
|
* across kexec transitions. It was developed for the KHO mechanism but is
|
|
* designed for broader use by any subsystem that needs to preserve pages.
|
|
*
|
|
* The radix tree is a multi-level tree where leaf nodes are bitmaps
|
|
* representing individual pages. To allow pages of different sizes (orders)
|
|
* to be stored efficiently in a single tree, it uses a unique key encoding
|
|
* scheme. Each key is an unsigned long that combines a page's physical
|
|
* address and its order.
|
|
*
|
|
* Client code is responsible for allocating the root node of the tree,
|
|
* initializing the mutex lock, and managing its lifecycle. It must use the
|
|
* tree data structures defined in the KHO ABI,
|
|
* `include/linux/kho/abi/kexec_handover.h`.
|
|
*/
|
|
|
|
struct kho_radix_node;
|
|
|
|
struct kho_radix_tree {
|
|
struct kho_radix_node *root;
|
|
struct mutex lock; /* protects the tree's structure and root pointer */
|
|
};
|
|
|
|
typedef int (*kho_radix_tree_walk_callback_t)(phys_addr_t phys,
|
|
unsigned int order);
|
|
|
|
#ifdef CONFIG_KEXEC_HANDOVER
|
|
|
|
int kho_radix_add_page(struct kho_radix_tree *tree, unsigned long pfn,
|
|
unsigned int order);
|
|
|
|
void kho_radix_del_page(struct kho_radix_tree *tree, unsigned long pfn,
|
|
unsigned int order);
|
|
|
|
int kho_radix_walk_tree(struct kho_radix_tree *tree,
|
|
kho_radix_tree_walk_callback_t cb);
|
|
|
|
#else /* #ifdef CONFIG_KEXEC_HANDOVER */
|
|
|
|
static inline int kho_radix_add_page(struct kho_radix_tree *tree, long pfn,
|
|
unsigned int order)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static inline void kho_radix_del_page(struct kho_radix_tree *tree,
|
|
unsigned long pfn, unsigned int order) { }
|
|
|
|
static inline int kho_radix_walk_tree(struct kho_radix_tree *tree,
|
|
kho_radix_tree_walk_callback_t cb)
|
|
{
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
#endif /* #ifdef CONFIG_KEXEC_HANDOVER */
|
|
|
|
#endif /* _LINUX_KHO_RADIX_TREE_H */
|