License cleanup: add SPDX GPL-2.0 license identifier to files with no license
Many source files in the tree are missing licensing information, which
makes it harder for compliance tools to determine the correct license.
By default all files without license information are under the default
license of the kernel, which is GPL version 2.
Update the files which contain no license information with the 'GPL-2.0'
SPDX license identifier. The SPDX identifier is a legally binding
shorthand, which can be used instead of the full boiler plate text.
This patch is based on work done by Thomas Gleixner and Kate Stewart and
Philippe Ombredanne.
How this work was done:
Patches were generated and checked against linux-4.14-rc6 for a subset of
the use cases:
- file had no licensing information it it.
- file was a */uapi/* one with no licensing information in it,
- file was a */uapi/* one with existing licensing information,
Further patches will be generated in subsequent months to fix up cases
where non-standard license headers were used, and references to license
had to be inferred by heuristics based on keywords.
The analysis to determine which SPDX License Identifier to be applied to
a file was done in a spreadsheet of side by side results from of the
output of two independent scanners (ScanCode & Windriver) producing SPDX
tag:value files created by Philippe Ombredanne. Philippe prepared the
base worksheet, and did an initial spot review of a few 1000 files.
The 4.13 kernel was the starting point of the analysis with 60,537 files
assessed. Kate Stewart did a file by file comparison of the scanner
results in the spreadsheet to determine which SPDX license identifier(s)
to be applied to the file. She confirmed any determination that was not
immediately clear with lawyers working with the Linux Foundation.
Criteria used to select files for SPDX license identifier tagging was:
- Files considered eligible had to be source code files.
- Make and config files were included as candidates if they contained >5
lines of source
- File already had some variant of a license header in it (even if <5
lines).
All documentation files were explicitly excluded.
The following heuristics were used to determine which SPDX license
identifiers to apply.
- when both scanners couldn't find any license traces, file was
considered to have no license information in it, and the top level
COPYING file license applied.
For non */uapi/* files that summary was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 11139
and resulted in the first patch in this series.
If that file was a */uapi/* path one, it was "GPL-2.0 WITH
Linux-syscall-note" otherwise it was "GPL-2.0". Results of that was:
SPDX license identifier # files
---------------------------------------------------|-------
GPL-2.0 WITH Linux-syscall-note 930
and resulted in the second patch in this series.
- if a file had some form of licensing information in it, and was one
of the */uapi/* ones, it was denoted with the Linux-syscall-note if
any GPL family license was found in the file or had no licensing in
it (per prior point). Results summary:
SPDX license identifier # files
---------------------------------------------------|------
GPL-2.0 WITH Linux-syscall-note 270
GPL-2.0+ WITH Linux-syscall-note 169
((GPL-2.0 WITH Linux-syscall-note) OR BSD-2-Clause) 21
((GPL-2.0 WITH Linux-syscall-note) OR BSD-3-Clause) 17
LGPL-2.1+ WITH Linux-syscall-note 15
GPL-1.0+ WITH Linux-syscall-note 14
((GPL-2.0+ WITH Linux-syscall-note) OR BSD-3-Clause) 5
LGPL-2.0+ WITH Linux-syscall-note 4
LGPL-2.1 WITH Linux-syscall-note 3
((GPL-2.0 WITH Linux-syscall-note) OR MIT) 3
((GPL-2.0 WITH Linux-syscall-note) AND MIT) 1
and that resulted in the third patch in this series.
- when the two scanners agreed on the detected license(s), that became
the concluded license(s).
- when there was disagreement between the two scanners (one detected a
license but the other didn't, or they both detected different
licenses) a manual inspection of the file occurred.
- In most cases a manual inspection of the information in the file
resulted in a clear resolution of the license that should apply (and
which scanner probably needed to revisit its heuristics).
- When it was not immediately clear, the license identifier was
confirmed with lawyers working with the Linux Foundation.
- If there was any question as to the appropriate license identifier,
the file was flagged for further research and to be revisited later
in time.
In total, over 70 hours of logged manual review was done on the
spreadsheet to determine the SPDX license identifiers to apply to the
source files by Kate, Philippe, Thomas and, in some cases, confirmation
by lawyers working with the Linux Foundation.
Kate also obtained a third independent scan of the 4.13 code base from
FOSSology, and compared selected files where the other two scanners
disagreed against that SPDX file, to see if there was new insights. The
Windriver scanner is based on an older version of FOSSology in part, so
they are related.
Thomas did random spot checks in about 500 files from the spreadsheets
for the uapi headers and agreed with SPDX license identifier in the
files he inspected. For the non-uapi files Thomas did random spot checks
in about 15000 files.
In initial set of patches against 4.14-rc6, 3 files were found to have
copy/paste license identifier errors, and have been fixed to reflect the
correct identifier.
Additionally Philippe spent 10 hours this week doing a detailed manual
inspection and review of the 12,461 patched files from the initial patch
version early this week with:
- a full scancode scan run, collecting the matched texts, detected
license ids and scores
- reviewing anything where there was a license detected (about 500+
files) to ensure that the applied SPDX license was correct
- reviewing anything where there was no detection but the patch license
was not GPL-2.0 WITH Linux-syscall-note to ensure that the applied
SPDX license was correct
This produced a worksheet with 20 files needing minor correction. This
worksheet was then exported into 3 different .csv files for the
different types of files to be modified.
These .csv files were then reviewed by Greg. Thomas wrote a script to
parse the csv files and add the proper SPDX tag to the file, in the
format that the file expected. This script was further refined by Greg
based on the output to detect more types of files automatically and to
distinguish between header and source .c files (which need different
comment types.) Finally Greg ran the script using the .csv files to
generate the patches.
Reviewed-by: Kate Stewart <kstewart@linuxfoundation.org>
Reviewed-by: Philippe Ombredanne <pombredanne@nexb.com>
Reviewed-by: Thomas Gleixner <tglx@linutronix.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2017-11-01 07:07:57 -07:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0 */
|
2005-11-02 21:35:45 -07:00
|
|
|
#ifndef _ASM_POWERPC_KEXEC_H
|
|
|
|
|
#define _ASM_POWERPC_KEXEC_H
|
2005-12-16 14:43:46 -07:00
|
|
|
#ifdef __KERNEL__
|
2005-11-02 21:35:45 -07:00
|
|
|
|
2022-09-19 10:01:31 -07:00
|
|
|
#if defined(CONFIG_PPC_85xx) || defined(CONFIG_44x)
|
2010-04-04 13:19:03 -07:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* On FSL-BookE we setup a 1:1 mapping which covers the first 2GiB of memory
|
|
|
|
|
* and therefore we can only deal with memory within this range
|
|
|
|
|
*/
|
2010-07-22 11:30:44 -07:00
|
|
|
#define KEXEC_SOURCE_MEMORY_LIMIT (2 * 1024 * 1024 * 1024UL - 1)
|
|
|
|
|
#define KEXEC_DESTINATION_MEMORY_LIMIT (2 * 1024 * 1024 * 1024UL - 1)
|
|
|
|
|
#define KEXEC_CONTROL_MEMORY_LIMIT (2 * 1024 * 1024 * 1024UL - 1)
|
2010-04-04 13:19:03 -07:00
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
2005-11-02 21:35:45 -07:00
|
|
|
/*
|
|
|
|
|
* Maximum page that is mapped directly into kernel memory.
|
|
|
|
|
* XXX: Since we copy virt we can use any page we allocate
|
|
|
|
|
*/
|
|
|
|
|
#define KEXEC_SOURCE_MEMORY_LIMIT (-1UL)
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Maximum address we can reach in physical address mode.
|
|
|
|
|
* XXX: I want to allow initrd in highmem. Otherwise set to rmo on LPAR.
|
|
|
|
|
*/
|
|
|
|
|
#define KEXEC_DESTINATION_MEMORY_LIMIT (-1UL)
|
|
|
|
|
|
|
|
|
|
/* Maximum address we can use for the control code buffer */
|
|
|
|
|
#ifdef __powerpc64__
|
|
|
|
|
#define KEXEC_CONTROL_MEMORY_LIMIT (-1UL)
|
|
|
|
|
#else
|
|
|
|
|
/* TASK_SIZE, probably left over from use_mm ?? */
|
|
|
|
|
#define KEXEC_CONTROL_MEMORY_LIMIT TASK_SIZE
|
|
|
|
|
#endif
|
2010-04-04 13:19:03 -07:00
|
|
|
#endif
|
2005-11-02 21:35:45 -07:00
|
|
|
|
2008-08-15 00:40:22 -07:00
|
|
|
#define KEXEC_CONTROL_PAGE_SIZE 4096
|
2005-11-02 21:35:45 -07:00
|
|
|
|
|
|
|
|
/* The native architecture */
|
|
|
|
|
#ifdef __powerpc64__
|
|
|
|
|
#define KEXEC_ARCH KEXEC_ARCH_PPC64
|
|
|
|
|
#else
|
|
|
|
|
#define KEXEC_ARCH KEXEC_ARCH_PPC
|
|
|
|
|
#endif
|
|
|
|
|
|
2010-05-13 12:40:11 -07:00
|
|
|
#define KEXEC_STATE_NONE 0
|
|
|
|
|
#define KEXEC_STATE_IRQS_OFF 1
|
|
|
|
|
#define KEXEC_STATE_REAL_MODE 2
|
|
|
|
|
|
2006-05-17 01:00:46 -07:00
|
|
|
#ifndef __ASSEMBLY__
|
2008-12-17 03:09:01 -07:00
|
|
|
#include <asm/reg.h>
|
2006-05-17 01:00:46 -07:00
|
|
|
|
2008-06-12 02:14:34 -07:00
|
|
|
typedef void (*crash_shutdown_t)(void);
|
|
|
|
|
|
2016-11-29 05:45:50 -07:00
|
|
|
#ifdef CONFIG_KEXEC_CORE
|
2024-02-26 03:30:10 -07:00
|
|
|
struct kimage;
|
|
|
|
|
struct pt_regs;
|
2006-01-13 20:15:36 -07:00
|
|
|
|
2005-11-02 21:35:45 -07:00
|
|
|
extern void kexec_smp_wait(void); /* get and clear naca physid, wait for
|
|
|
|
|
master to copy new code to 0 */
|
[PATCH] powerpc: Merge kexec
This patch merges, to some extent, the PPC32 and PPC64 kexec implementations.
We adopt the PPC32 approach of having ppc_md callbacks for the kexec functions.
The current PPC64 implementation becomes the "default" implementation for PPC64
which platforms can select if they need no special treatment.
I've added these default callbacks to pseries/maple/cell/powermac, this means
iSeries no longer supports kexec - but it never worked anyway.
I've renamed PPC32's machine_kexec_simple to default_machine_kexec, inline with
PPC64. Judging by the comments it might be better named machine_kexec_non_of,
or something, but at the moment it's the only implementation for PPC32 so it's
the "default".
Kexec requires machine_shutdown(), which is in machine_kexec.c on PPC32, but we
already have in setup-common.c on powerpc. All this does is call
ppc_md.nvram_sync, which only powermac implements, so instead make
machine_shutdown a ppc_md member and have it call core99_nvram_sync directly
on powermac.
I've also stuck relocate_kernel.S into misc_32.S for powerpc.
Built for ARCH=ppc, and 32 & 64 bit ARCH=powerpc, with KEXEC=y/n. Booted on
P5 LPAR and successfully kexec'ed.
Should apply on top of 493f25ef4087395891c99fcfe2c72e62e293e89f.
Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Signed-off-by: Paul Mackerras <paulus@samba.org>
2005-11-14 05:35:00 -07:00
|
|
|
extern void default_machine_kexec(struct kimage *image);
|
2010-09-16 15:58:23 -07:00
|
|
|
extern void machine_kexec_mask_interrupts(void);
|
2006-05-17 01:00:46 -07:00
|
|
|
|
powerpc: Fix kexec failure on book3s/32
In the old days, _PAGE_EXEC didn't exist on 6xx aka book3s/32.
Therefore, allthough __mapin_ram_chunk() was already mapping kernel
text with PAGE_KERNEL_TEXT and the rest with PAGE_KERNEL, the entire
memory was executable. Part of the memory (first 512kbytes) was
mapped with BATs instead of page table, but it was also entirely
mapped as executable.
In commit 385e89d5b20f ("powerpc/mm: add exec protection on
powerpc 603"), we started adding exec protection to some 6xx, namely
the 603, for pages mapped via pagetables.
Then, in commit 63b2bc619565 ("powerpc/mm/32s: Use BATs for
STRICT_KERNEL_RWX"), the exec protection was extended to BAT mapped
memory, so that really only the kernel text could be executed.
The problem here is that kexec is based on copying some code into
upper part of memory then executing it from there in order to install
a fresh new kernel at its definitive location.
However, the code is position independant and first part of it is
just there to deactivate the MMU and jump to the second part. So it
is possible to run this first part inplace instead of running the
copy. Once the MMU is off, there is no protection anymore and the
second part of the code will just run as before.
Reported-by: Aaro Koskinen <aaro.koskinen@iki.fi>
Fixes: 63b2bc619565 ("powerpc/mm/32s: Use BATs for STRICT_KERNEL_RWX")
Cc: stable@vger.kernel.org # v5.1+
Signed-off-by: Christophe Leroy <christophe.leroy@c-s.fr>
Tested-by: Aaro Koskinen <aaro.koskinen@iki.fi>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
2019-06-03 01:20:28 -07:00
|
|
|
void relocate_new_kernel(unsigned long indirection_page, unsigned long reboot_code_buffer,
|
|
|
|
|
unsigned long start_address) __noreturn;
|
2022-03-04 10:04:05 -07:00
|
|
|
void kexec_copy_flush(struct kimage *image);
|
|
|
|
|
|
2016-11-29 05:45:51 -07:00
|
|
|
#ifdef CONFIG_KEXEC_FILE
|
2018-04-13 15:35:49 -07:00
|
|
|
extern const struct kexec_file_ops kexec_elf64_ops;
|
2016-11-29 05:45:51 -07:00
|
|
|
|
2016-12-19 17:22:45 -07:00
|
|
|
#define ARCH_HAS_KIMAGE_ARCH
|
|
|
|
|
|
|
|
|
|
struct kimage_arch {
|
2020-07-29 04:40:16 -07:00
|
|
|
struct crash_mem *exclude_ranges;
|
|
|
|
|
|
2020-07-29 04:42:58 -07:00
|
|
|
unsigned long backup_start;
|
|
|
|
|
void *backup_buf;
|
2021-02-21 10:49:24 -07:00
|
|
|
void *fdt;
|
2020-07-29 04:40:16 -07:00
|
|
|
};
|
2016-12-19 17:22:45 -07:00
|
|
|
|
2020-07-29 04:43:14 -07:00
|
|
|
char *setup_kdump_cmdline(struct kimage *image, char *cmdline,
|
|
|
|
|
unsigned long cmdline_len);
|
2016-11-29 05:45:51 -07:00
|
|
|
int setup_purgatory(struct kimage *image, const void *slave_code,
|
|
|
|
|
const void *fdt, unsigned long kernel_load_addr,
|
|
|
|
|
unsigned long fdt_load_addr);
|
2020-07-29 04:39:41 -07:00
|
|
|
|
|
|
|
|
#ifdef CONFIG_PPC64
|
2020-07-29 04:42:58 -07:00
|
|
|
struct kexec_buf;
|
|
|
|
|
|
2022-07-01 00:34:04 -07:00
|
|
|
int arch_kexec_kernel_image_probe(struct kimage *image, void *buf, unsigned long buf_len);
|
|
|
|
|
#define arch_kexec_kernel_image_probe arch_kexec_kernel_image_probe
|
|
|
|
|
|
|
|
|
|
int arch_kimage_file_post_load_cleanup(struct kimage *image);
|
|
|
|
|
#define arch_kimage_file_post_load_cleanup arch_kimage_file_post_load_cleanup
|
|
|
|
|
|
|
|
|
|
int arch_kexec_locate_mem_hole(struct kexec_buf *kbuf);
|
|
|
|
|
#define arch_kexec_locate_mem_hole arch_kexec_locate_mem_hole
|
|
|
|
|
|
2020-07-29 04:42:58 -07:00
|
|
|
int load_crashdump_segments_ppc64(struct kimage *image,
|
|
|
|
|
struct kexec_buf *kbuf);
|
2020-07-29 04:39:41 -07:00
|
|
|
int setup_purgatory_ppc64(struct kimage *image, const void *slave_code,
|
|
|
|
|
const void *fdt, unsigned long kernel_load_addr,
|
|
|
|
|
unsigned long fdt_load_addr);
|
2024-05-10 03:22:34 -07:00
|
|
|
unsigned int kexec_extra_fdt_size_ppc64(struct kimage *image, struct crash_mem *rmem);
|
|
|
|
|
int setup_new_fdt_ppc64(const struct kimage *image, void *fdt, struct crash_mem *rmem);
|
2020-07-29 04:39:41 -07:00
|
|
|
#endif /* CONFIG_PPC64 */
|
2020-07-29 04:40:16 -07:00
|
|
|
|
2016-11-29 05:45:51 -07:00
|
|
|
#endif /* CONFIG_KEXEC_FILE */
|
|
|
|
|
|
2024-02-26 03:30:10 -07:00
|
|
|
#endif /* CONFIG_KEXEC_CORE */
|
|
|
|
|
|
|
|
|
|
#ifdef CONFIG_CRASH_RESERVE
|
|
|
|
|
int __init overlaps_crashkernel(unsigned long start, unsigned long size);
|
|
|
|
|
extern void reserve_crashkernel(void);
|
|
|
|
|
#else
|
|
|
|
|
static inline void reserve_crashkernel(void) {}
|
|
|
|
|
static inline int overlaps_crashkernel(unsigned long start, unsigned long size) { return 0; }
|
|
|
|
|
#endif
|
2006-05-17 01:00:46 -07:00
|
|
|
|
2024-02-26 03:30:10 -07:00
|
|
|
#if defined(CONFIG_CRASH_DUMP)
|
|
|
|
|
/*
|
|
|
|
|
* This function is responsible for capturing register states if coming
|
|
|
|
|
* via panic or invoking dump using sysrq-trigger.
|
|
|
|
|
*/
|
|
|
|
|
static inline void crash_setup_regs(struct pt_regs *newregs,
|
|
|
|
|
struct pt_regs *oldregs)
|
2006-05-17 01:00:46 -07:00
|
|
|
{
|
2024-02-26 03:30:10 -07:00
|
|
|
if (oldregs)
|
|
|
|
|
memcpy(newregs, oldregs, sizeof(*newregs));
|
|
|
|
|
else
|
|
|
|
|
ppc_save_regs(newregs);
|
|
|
|
|
}
|
|
|
|
|
|
powerpc/crash: add crash CPU hotplug support
Due to CPU/Memory hotplug or online/offline events, the elfcorehdr
(which describes the CPUs and memory of the crashed kernel) and FDT
(Flattened Device Tree) of kdump image becomes outdated. Consequently,
attempting dump collection with an outdated elfcorehdr or FDT can lead
to failed or inaccurate dump collection.
Going forward, CPU hotplug or online/offline events are referred as
CPU/Memory add/remove events.
The current solution to address the above issue involves monitoring the
CPU/Memory add/remove events in userspace using udev rules and whenever
there are changes in CPU and memory resources, the entire kdump image
is loaded again. The kdump image includes kernel, initrd, elfcorehdr,
FDT, purgatory. Given that only elfcorehdr and FDT get outdated due to
CPU/Memory add/remove events, reloading the entire kdump image is
inefficient. More importantly, kdump remains inactive for a substantial
amount of time until the kdump reload completes.
To address the aforementioned issue, commit 247262756121 ("crash: add
generic infrastructure for crash hotplug support") added a generic
infrastructure that allows architectures to selectively update the kdump
image component during CPU or memory add/remove events within the kernel
itself.
In the event of a CPU or memory add/remove events, the generic crash
hotplug event handler, `crash_handle_hotplug_event()`, is triggered. It
then acquires the necessary locks to update the kdump image and invokes
the architecture-specific crash hotplug handler,
`arch_crash_handle_hotplug_event()`, to update the required kdump image
components.
This patch adds crash hotplug handler for PowerPC and enable support to
update the kdump image on CPU add/remove events. Support for memory
add/remove events is added in a subsequent patch with the title
"powerpc: add crash memory hotplug support"
As mentioned earlier, only the elfcorehdr and FDT kdump image components
need to be updated in the event of CPU or memory add/remove events.
However, on PowerPC architecture crash hotplug handler only updates the
FDT to enable crash hotplug support for CPU add/remove events. Here's
why.
The elfcorehdr on PowerPC is built with possible CPUs, and thus, it does
not need an update on CPU add/remove events. On the other hand, the FDT
needs to be updated on CPU add events to include the newly added CPU. If
the FDT is not updated and the kernel crashes on a newly added CPU, the
kdump kernel will fail to boot due to the unavailability of the crashing
CPU in the FDT. During the early boot, it is expected that the boot CPU
must be a part of the FDT; otherwise, the kernel will raise a BUG and
fail to boot. For more information, refer to commit 36ae37e3436b0
("powerpc: Make boot_cpuid common between 32 and 64-bit"). Since it is
okay to have an offline CPU in the kdump FDT, no action is taken in case
of CPU removal.
There are two system calls, `kexec_file_load` and `kexec_load`, used to
load the kdump image. Few changes have been made to ensure kernel can
safely update the FDT of kdump image loaded using both system calls.
For kexec_file_load syscall the kdump image is prepared in kernel. So to
support an increasing number of CPUs, the FDT is constructed with extra
buffer space to ensure it can accommodate a possible number of CPU
nodes. Additionally, a call to fdt_pack (which trims the unused space
once the FDT is prepared) is avoided if this feature is enabled.
For the kexec_load syscall, the FDT is updated only if the
KEXEC_CRASH_HOTPLUG_SUPPORT kexec flag is passed to the kernel by
userspace (kexec tools). When userspace passes this flag to the kernel,
it indicates that the FDT is built to accommodate possible CPUs, and the
FDT segment is excluded from SHA calculation, making it safe to update.
The changes related to this feature are kept under the CRASH_HOTPLUG
config, and it is enabled by default.
Signed-off-by: Sourabh Jain <sourabhjain@linux.ibm.com>
Acked-by: Hari Bathini <hbathini@linux.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://msgid.link/20240326055413.186534-6-sourabhjain@linux.ibm.com
2024-03-25 22:54:12 -07:00
|
|
|
#ifdef CONFIG_CRASH_HOTPLUG
|
|
|
|
|
void arch_crash_handle_hotplug_event(struct kimage *image, void *arg);
|
|
|
|
|
#define arch_crash_handle_hotplug_event arch_crash_handle_hotplug_event
|
|
|
|
|
|
|
|
|
|
int arch_crash_hotplug_support(struct kimage *image, unsigned long kexec_flags);
|
|
|
|
|
#define arch_crash_hotplug_support arch_crash_hotplug_support
|
powerpc/crash: add crash memory hotplug support
Extend the arch crash hotplug handler, as introduced by the patch title
("powerpc: add crash CPU hotplug support"), to also support memory
add/remove events.
Elfcorehdr describes the memory of the crash kernel to capture the
kernel; hence, it needs to be updated if memory resources change due to
memory add/remove events. Therefore, arch_crash_handle_hotplug_event()
is updated to recreate the elfcorehdr and replace it with the previous
one on memory add/remove events.
The memblock list is used to prepare the elfcorehdr. In the case of
memory hot remove, the memblock list is updated after the arch crash
hotplug handler is triggered, as depicted in Figure 1. Thus, the
hot-removed memory is explicitly removed from the crash memory ranges
to ensure that the memory ranges added to elfcorehdr do not include the
hot-removed memory.
Memory remove
|
v
Offline pages
|
v
Initiate memory notify call <----> crash hotplug handler
chain for MEM_OFFLINE event
|
v
Update memblock list
Figure 1
There are two system calls, `kexec_file_load` and `kexec_load`, used to
load the kdump image. A few changes have been made to ensure that the
kernel can safely update the elfcorehdr component of the kdump image for
both system calls.
For the kexec_file_load syscall, kdump image is prepared in the kernel.
To support an increasing number of memory regions, the elfcorehdr is
built with extra buffer space to ensure that it can accommodate
additional memory ranges in future.
For the kexec_load syscall, the elfcorehdr is updated only if the
KEXEC_CRASH_HOTPLUG_SUPPORT kexec flag is passed to the kernel by the
kexec tool. Passing this flag to the kernel indicates that the
elfcorehdr is built to accommodate additional memory ranges and the
elfcorehdr segment is not considered for SHA calculation, making it safe
to update.
The changes related to this feature are kept under the CRASH_HOTPLUG
config, and it is enabled by default.
Signed-off-by: Sourabh Jain <sourabhjain@linux.ibm.com>
Acked-by: Hari Bathini <hbathini@linux.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://msgid.link/20240326055413.186534-7-sourabhjain@linux.ibm.com
2024-03-25 22:54:13 -07:00
|
|
|
|
|
|
|
|
unsigned int arch_crash_get_elfcorehdr_size(void);
|
|
|
|
|
#define crash_get_elfcorehdr_size arch_crash_get_elfcorehdr_size
|
powerpc/crash: add crash CPU hotplug support
Due to CPU/Memory hotplug or online/offline events, the elfcorehdr
(which describes the CPUs and memory of the crashed kernel) and FDT
(Flattened Device Tree) of kdump image becomes outdated. Consequently,
attempting dump collection with an outdated elfcorehdr or FDT can lead
to failed or inaccurate dump collection.
Going forward, CPU hotplug or online/offline events are referred as
CPU/Memory add/remove events.
The current solution to address the above issue involves monitoring the
CPU/Memory add/remove events in userspace using udev rules and whenever
there are changes in CPU and memory resources, the entire kdump image
is loaded again. The kdump image includes kernel, initrd, elfcorehdr,
FDT, purgatory. Given that only elfcorehdr and FDT get outdated due to
CPU/Memory add/remove events, reloading the entire kdump image is
inefficient. More importantly, kdump remains inactive for a substantial
amount of time until the kdump reload completes.
To address the aforementioned issue, commit 247262756121 ("crash: add
generic infrastructure for crash hotplug support") added a generic
infrastructure that allows architectures to selectively update the kdump
image component during CPU or memory add/remove events within the kernel
itself.
In the event of a CPU or memory add/remove events, the generic crash
hotplug event handler, `crash_handle_hotplug_event()`, is triggered. It
then acquires the necessary locks to update the kdump image and invokes
the architecture-specific crash hotplug handler,
`arch_crash_handle_hotplug_event()`, to update the required kdump image
components.
This patch adds crash hotplug handler for PowerPC and enable support to
update the kdump image on CPU add/remove events. Support for memory
add/remove events is added in a subsequent patch with the title
"powerpc: add crash memory hotplug support"
As mentioned earlier, only the elfcorehdr and FDT kdump image components
need to be updated in the event of CPU or memory add/remove events.
However, on PowerPC architecture crash hotplug handler only updates the
FDT to enable crash hotplug support for CPU add/remove events. Here's
why.
The elfcorehdr on PowerPC is built with possible CPUs, and thus, it does
not need an update on CPU add/remove events. On the other hand, the FDT
needs to be updated on CPU add events to include the newly added CPU. If
the FDT is not updated and the kernel crashes on a newly added CPU, the
kdump kernel will fail to boot due to the unavailability of the crashing
CPU in the FDT. During the early boot, it is expected that the boot CPU
must be a part of the FDT; otherwise, the kernel will raise a BUG and
fail to boot. For more information, refer to commit 36ae37e3436b0
("powerpc: Make boot_cpuid common between 32 and 64-bit"). Since it is
okay to have an offline CPU in the kdump FDT, no action is taken in case
of CPU removal.
There are two system calls, `kexec_file_load` and `kexec_load`, used to
load the kdump image. Few changes have been made to ensure kernel can
safely update the FDT of kdump image loaded using both system calls.
For kexec_file_load syscall the kdump image is prepared in kernel. So to
support an increasing number of CPUs, the FDT is constructed with extra
buffer space to ensure it can accommodate a possible number of CPU
nodes. Additionally, a call to fdt_pack (which trims the unused space
once the FDT is prepared) is avoided if this feature is enabled.
For the kexec_load syscall, the FDT is updated only if the
KEXEC_CRASH_HOTPLUG_SUPPORT kexec flag is passed to the kernel by
userspace (kexec tools). When userspace passes this flag to the kernel,
it indicates that the FDT is built to accommodate possible CPUs, and the
FDT segment is excluded from SHA calculation, making it safe to update.
The changes related to this feature are kept under the CRASH_HOTPLUG
config, and it is enabled by default.
Signed-off-by: Sourabh Jain <sourabhjain@linux.ibm.com>
Acked-by: Hari Bathini <hbathini@linux.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://msgid.link/20240326055413.186534-6-sourabhjain@linux.ibm.com
2024-03-25 22:54:12 -07:00
|
|
|
#endif /* CONFIG_CRASH_HOTPLUG */
|
|
|
|
|
|
2024-02-26 03:30:10 -07:00
|
|
|
extern int crashing_cpu;
|
|
|
|
|
extern void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *));
|
|
|
|
|
extern void crash_ipi_callback(struct pt_regs *regs);
|
|
|
|
|
extern int crash_wake_offline;
|
|
|
|
|
|
|
|
|
|
extern int crash_shutdown_register(crash_shutdown_t handler);
|
|
|
|
|
extern int crash_shutdown_unregister(crash_shutdown_t handler);
|
|
|
|
|
extern void default_machine_crash_shutdown(struct pt_regs *regs);
|
|
|
|
|
|
|
|
|
|
extern void crash_kexec_prepare(void);
|
|
|
|
|
extern void crash_kexec_secondary(struct pt_regs *regs);
|
|
|
|
|
|
|
|
|
|
static inline bool kdump_in_progress(void)
|
|
|
|
|
{
|
|
|
|
|
return crashing_cpu >= 0;
|
2006-05-17 01:00:46 -07:00
|
|
|
}
|
2006-02-01 04:05:57 -07:00
|
|
|
|
2024-02-26 03:30:10 -07:00
|
|
|
bool is_kdump_kernel(void);
|
|
|
|
|
#define is_kdump_kernel is_kdump_kernel
|
|
|
|
|
#if defined(CONFIG_PPC_RTAS)
|
|
|
|
|
void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
|
|
|
|
|
#define crash_free_reserved_phys_range crash_free_reserved_phys_range
|
|
|
|
|
#endif /* CONFIG_PPC_RTAS */
|
|
|
|
|
|
|
|
|
|
#else /* !CONFIG_CRASH_DUMP */
|
|
|
|
|
static inline void crash_kexec_secondary(struct pt_regs *regs) { }
|
2006-05-17 18:16:11 -07:00
|
|
|
|
2008-06-12 02:14:34 -07:00
|
|
|
static inline int crash_shutdown_register(crash_shutdown_t handler)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline int crash_shutdown_unregister(crash_shutdown_t handler)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-18 11:06:55 -07:00
|
|
|
static inline bool kdump_in_progress(void)
|
|
|
|
|
{
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-12 15:34:07 -07:00
|
|
|
static inline void crash_ipi_callback(struct pt_regs *regs) { }
|
|
|
|
|
|
|
|
|
|
static inline void crash_send_ipi(void (*crash_ipi_callback)(struct pt_regs *))
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
|
2024-02-26 03:30:10 -07:00
|
|
|
#endif /* CONFIG_CRASH_DUMP */
|
2020-07-08 20:29:41 -07:00
|
|
|
|
2024-03-25 22:54:11 -07:00
|
|
|
#if defined(CONFIG_KEXEC_FILE) || defined(CONFIG_CRASH_DUMP)
|
|
|
|
|
int update_cpus_node(void *fdt);
|
|
|
|
|
#endif
|
|
|
|
|
|
2020-07-08 20:29:41 -07:00
|
|
|
#ifdef CONFIG_PPC_BOOK3S_64
|
|
|
|
|
#include <asm/book3s/64/kexec.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef reset_sprs
|
|
|
|
|
#define reset_sprs reset_sprs
|
|
|
|
|
static inline void reset_sprs(void)
|
|
|
|
|
{
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2006-05-17 01:00:46 -07:00
|
|
|
#endif /* ! __ASSEMBLY__ */
|
2005-12-16 14:43:46 -07:00
|
|
|
#endif /* __KERNEL__ */
|
2005-11-02 21:35:45 -07:00
|
|
|
#endif /* _ASM_POWERPC_KEXEC_H */
|