Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-22 20:22:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

powerpc: make fadump resilient with memory add/remove events

Browse Source 
Due to changes in memory resources caused by either memory hotplug or
online/offline events, the elfcorehdr, which describes the CPUs and
memory of the crashed kernel to the kernel that collects the dump (known
as second/fadump kernel), becomes outdated. Consequently, attempting
dump collection with an outdated elfcorehdr can lead to failed or
inaccurate dump collection.

Memory hotplug or online/offline events is referred as memory add/remove
events in reset of the commit message.

The current solution to address the aforementioned issue is as follows:
Monitor memory add/remove events in userspace using udev rules, and
re-register fadump whenever there are changes in memory resources. This
leads to the creation of a new elfcorehdr with updated system memory
information.

There are several notable issues associated with re-registering fadump
for every memory add/remove events.

1. Bulk memory add/remove events with udev-based fadump re-registration
   can lead to race conditions and, more importantly, it creates a wide
   window during which fadump is inactive until all memory add/remove
   events are settled.
2. Re-registering fadump for every memory add/remove event is
   inefficient.
3. The memory for elfcorehdr is allocated based on the memblock regions
   available during early boot and remains fixed thereafter. However, if
   elfcorehdr is later recreated with additional memblock regions, its
   size will increase, potentially leading to memory corruption.

Address the aforementioned challenges by shifting the creation of
elfcorehdr from the first kernel (also referred as the crashed kernel),
where it was created and frequently recreated for every memory
add/remove event, to the fadump kernel. As a result, the elfcorehdr only
needs to be created once, thus eliminating the necessity to re-register
fadump during memory add/remove events.

At present, the first kernel prepares fadump header and stores it in the
fadump reserved area. The fadump header includes the start address of
the elfcorehdr, crashing CPU details, and other relevant information. In
the event of a crash in the first kernel, the second/fadump boots and
accesses the fadump header prepared by the first kernel. It then
performs the following steps in a platform-specific function
[rtas|opal]_fadump_process:

1. Sanity check for fadump header
2. Update CPU notes in elfcorehdr

Along with the above, update the setup_fadump()/fadump.c to create
elfcorehdr and set its address to the global variable elfcorehdr_addr
for the vmcore module to process it in the second/fadump kernel.

Section below outlines the information required to create the elfcorehdr
and the changes made to make it available to the fadump kernel if it's
not already.

To create elfcorehdr, the following crashed kernel information is
required: CPU notes, vmcoreinfo, and memory ranges.

At present, the CPU notes are already prepared in the fadump kernel, so
no changes are needed in that regard. The fadump kernel has access to
all crashed kernel memory regions, including boot memory regions that
are relocated by firmware to fadump reserved areas, so no changes for
that either. However, it is necessary to add new members to the fadump
header, i.e., the 'fadump_crash_info_header' structure, in order to pass
the crashed kernel's vmcoreinfo address and its size to fadump kernel.

In addition to the vmcoreinfo address and size, there are a few other
attributes also added to the fadump_crash_info_header structure.

1. version:
   It stores the fadump header version, which is currently set to 1.
   This provides flexibility to update the fadump crash info header in
   the future without changing the magic number. For each change in the
   fadump header, the version will be increased. This will help the
   updated kernel determine how to handle kernel dumps from older
   kernels. The magic number remains relevant for checking fadump header
   corruption.

2. pt_regs_sz/cpu_mask_sz:
   Store size of pt_regs and cpu_mask structure of first kernel. These
   attributes are used to prevent dump processing if the sizes of
   pt_regs or cpu_mask structure differ between the first and fadump
   kernels.

Note: if either first/crashed kernel or second/fadump kernel do not have
the changes introduced here then kernel fail to collect the dump and
prints relevant error message on the console.

Signed-off-by: Sourabh Jain <sourabhjain@linux.ibm.com>
Signed-off-by: Michael Ellerman <mpe@ellerman.id.au>
Link: https://msgid.link/20240422195932.1583833-2-sourabhjain@linux.ibm.com
This commit is contained in:
Sourabh Jain 2024-04-23 01:29:30 +05:30 committed by Michael Ellerman
parent 6d43416385
commit c6c5b14dac
4 changed files with 242 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
arch/powerpc/include/asm/fadump-internal.h
View File

@ -42,13 +42,38 @@ static inline u64 fadump_str_to_u64(const char *str)
#define FADUMP_CPU_UNKNOWN (~((u32)0))
#define FADUMP_CRASH_INFO_MAGIC fadump_str_to_u64("FADMPINF")
/*
* The introduction of new fields in the fadump crash info header has
* led to a change in the magic key from `FADMPINF` to `FADMPSIG` for
* identifying a kernel crash from an old kernel.
*
* To prevent the need for further changes to the magic number in the
* event of future modifications to the fadump crash info header, a
* version field has been introduced to track the fadump crash info
* header version.
*
* Consider a few points before adding new members to the fadump crash info
* header structure:
*
* - Append new members; avoid adding them in between.
* - Non-primitive members should have a size member as well.
* - For every change in the fadump header, increment the
* fadump header version. This helps the updated kernel decide how to
* handle kernel dumps from older kernels.
*/
#define FADUMP_CRASH_INFO_MAGIC_OLD fadump_str_to_u64("FADMPINF")
#define FADUMP_CRASH_INFO_MAGIC fadump_str_to_u64("FADMPSIG")
#define FADUMP_HEADER_VERSION 1
/* fadump crash info structure */
struct fadump_crash_info_header {
u64 magic_number;
u64 elfcorehdr_addr;
u32 version;
u32 crashing_cpu;
u64 vmcoreinfo_raddr;
u64 vmcoreinfo_size;
u32 pt_regs_sz;
u32 cpu_mask_sz;
struct pt_regs regs;
struct cpumask cpu_mask;
};
@ -94,6 +119,8 @@ struct fw_dump {
u64 boot_mem_regs_cnt;
unsigned long fadumphdr_addr;
u64 elfcorehdr_addr;
u64 elfcorehdr_size;
unsigned long cpu_notes_buf_vaddr;
unsigned long cpu_notes_buf_size;

361
arch/powerpc/kernel/fadump.c
View File

@ -53,8 +53,6 @@ static struct kobject *fadump_kobj;
static atomic_t cpus_in_fadump;
static DEFINE_MUTEX(fadump_mutex);
static struct fadump_mrange_info crash_mrange_info = { "crash", NULL, 0, 0, 0, false };
#define RESERVED_RNGS_SZ 16384 /* 16K - 128 entries */
#define RESERVED_RNGS_CNT (RESERVED_RNGS_SZ / \
sizeof(struct fadump_memory_range))
@ -373,12 +371,6 @@ static unsigned long __init get_fadump_area_size(void)
size = PAGE_ALIGN(size);
size += fw_dump.boot_memory_size;
size += sizeof(struct fadump_crash_info_header);
size += sizeof(struct elfhdr); /* ELF core header.*/
size += sizeof(struct elf_phdr); /* place holder for cpu notes */
/* Program headers for crash memory regions. */
size += sizeof(struct elf_phdr) * (memblock_num_regions(memory) + 2);
size = PAGE_ALIGN(size);
/* This is to hold kernel metadata on platforms that support it */
size += (fw_dump.ops->fadump_get_metadata_size ?
@ -915,36 +907,6 @@ static inline int fadump_add_mem_range(struct fadump_mrange_info *mrange_info,
return 0;
}
static int fadump_exclude_reserved_area(u64 start, u64 end)
{
u64 ra_start, ra_end;
int ret = 0;
ra_start = fw_dump.reserve_dump_area_start;
ra_end = ra_start + fw_dump.reserve_dump_area_size;
if ((ra_start < end) && (ra_end > start)) {
if ((start < ra_start) && (end > ra_end)) {
ret = fadump_add_mem_range(&crash_mrange_info,
start, ra_start);
if (ret)
return ret;
ret = fadump_add_mem_range(&crash_mrange_info,
ra_end, end);
} else if (start < ra_start) {
ret = fadump_add_mem_range(&crash_mrange_info,
start, ra_start);
} else if (ra_end < end) {
ret = fadump_add_mem_range(&crash_mrange_info,
ra_end, end);
}
} else
ret = fadump_add_mem_range(&crash_mrange_info, start, end);
return ret;
}
static int fadump_init_elfcore_header(char *bufp)
{
struct elfhdr *elf;
@ -981,52 +943,6 @@ static int fadump_init_elfcore_header(char *bufp)
return 0;
}
/*
* Traverse through memblock structure and setup crash memory ranges. These
* ranges will be used create PT_LOAD program headers in elfcore header.
*/
static int fadump_setup_crash_memory_ranges(void)
{
u64 i, start, end;
int ret;
pr_debug("Setup crash memory ranges.\n");
crash_mrange_info.mem_range_cnt = 0;
/*
* Boot memory region(s) registered with firmware are moved to
* different location at the time of crash. Create separate program
* header(s) for this memory chunk(s) with the correct offset.
*/
for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
start = fw_dump.boot_mem_addr[i];
end = start + fw_dump.boot_mem_sz[i];
ret = fadump_add_mem_range(&crash_mrange_info, start, end);
if (ret)
return ret;
}
for_each_mem_range(i, &start, &end) {
/*
* skip the memory chunk that is already added
* (0 through boot_memory_top).
*/
if (start < fw_dump.boot_mem_top) {
if (end > fw_dump.boot_mem_top)
start = fw_dump.boot_mem_top;
else
continue;
}
/* add this range excluding the reserved dump area. */
ret = fadump_exclude_reserved_area(start, end);
if (ret)
return ret;
}
return 0;
}
/*
* If the given physical address falls within the boot memory region then
* return the relocated address that points to the dump region reserved
@ -1057,36 +973,50 @@ static inline unsigned long fadump_relocate(unsigned long paddr)
return raddr;
}
static int fadump_create_elfcore_headers(char *bufp)
static void __init populate_elf_pt_load(struct elf_phdr *phdr, u64 start,
u64 size, unsigned long long offset)
{
unsigned long long raddr, offset;
struct elf_phdr *phdr;
struct elfhdr *elf;
int i, j;
phdr->p_align = 0;
phdr->p_memsz = size;
phdr->p_filesz = size;
phdr->p_paddr = start;
phdr->p_offset = offset;
phdr->p_type = PT_LOAD;
phdr->p_flags = PF_R|PF_W|PF_X;
phdr->p_vaddr = (unsigned long)__va(start);
}
static void __init fadump_populate_elfcorehdr(struct fadump_crash_info_header *fdh)
{
char *bufp;
struct elfhdr *elf;
struct elf_phdr *phdr;
u64 boot_mem_dest_offset;
unsigned long long i, ra_start, ra_end, ra_size, mstart, mend;
bufp = (char *) fw_dump.elfcorehdr_addr;
fadump_init_elfcore_header(bufp);
elf = (struct elfhdr *)bufp;
bufp += sizeof(struct elfhdr);
/*
* setup ELF PT_NOTE, place holder for cpu notes info. The notes info
* will be populated during second kernel boot after crash. Hence
* this PT_NOTE will always be the first elf note.
* Set up ELF PT_NOTE, a placeholder for CPU notes information.
* The notes info will be populated later by platform-specific code.
* Hence, this PT_NOTE will always be the first ELF note.
*
* NOTE: Any new ELF note addition should be placed after this note.
*/
phdr = (struct elf_phdr *)bufp;
bufp += sizeof(struct elf_phdr);
phdr->p_type = PT_NOTE;
phdr->p_flags = 0;
phdr->p_vaddr = 0;
phdr->p_align = 0;
phdr->p_offset = 0;
phdr->p_paddr = 0;
phdr->p_filesz = 0;
phdr->p_memsz = 0;
phdr->p_flags = 0;
phdr->p_vaddr = 0;
phdr->p_align = 0;
phdr->p_offset = 0;
phdr->p_paddr = 0;
phdr->p_filesz = 0;
phdr->p_memsz = 0;
/* Increment number of program headers. */
(elf->e_phnum)++;
/* setup ELF PT_NOTE for vmcoreinfo */
@ -1096,55 +1026,66 @@ static int fadump_create_elfcore_headers(char *bufp)
phdr->p_flags = 0;
phdr->p_vaddr = 0;
phdr->p_align = 0;
phdr->p_paddr = fadump_relocate(paddr_vmcoreinfo_note());
phdr->p_offset = phdr->p_paddr;
phdr->p_memsz = phdr->p_filesz = VMCOREINFO_NOTE_SIZE;
phdr->p_paddr = phdr->p_offset = fdh->vmcoreinfo_raddr;
phdr->p_memsz = phdr->p_filesz = fdh->vmcoreinfo_size;
/* Increment number of program headers. */
(elf->e_phnum)++;
/* setup PT_LOAD sections. */
j = 0;
offset = 0;
raddr = fw_dump.boot_mem_addr[0];
for (i = 0; i < crash_mrange_info.mem_range_cnt; i++) {
u64 mbase, msize;
mbase = crash_mrange_info.mem_ranges[i].base;
msize = crash_mrange_info.mem_ranges[i].size;
if (!msize)
continue;
/*
* Setup PT_LOAD sections. first include boot memory regions
* and then add rest of the memory regions.
*/
boot_mem_dest_offset = fw_dump.boot_mem_dest_addr;
for (i = 0; i < fw_dump.boot_mem_regs_cnt; i++) {
phdr = (struct elf_phdr *)bufp;
bufp += sizeof(struct elf_phdr);
phdr->p_type = PT_LOAD;
phdr->p_flags = PF_R|PF_W|PF_X;
phdr->p_offset = mbase;
populate_elf_pt_load(phdr, fw_dump.boot_mem_addr[i],
fw_dump.boot_mem_sz[i],
boot_mem_dest_offset);
/* Increment number of program headers. */
(elf->e_phnum)++;
boot_mem_dest_offset += fw_dump.boot_mem_sz[i];
}
if (mbase == raddr) {
/*
* The entire real memory region will be moved by
* firmware to the specified destination_address.
* Hence set the correct offset.
*/
phdr->p_offset = fw_dump.boot_mem_dest_addr + offset;
if (j < (fw_dump.boot_mem_regs_cnt - 1)) {
offset += fw_dump.boot_mem_sz[j];
raddr = fw_dump.boot_mem_addr[++j];
}
/* Memory reserved for fadump in first kernel */
ra_start = fw_dump.reserve_dump_area_start;
ra_size = get_fadump_area_size();
ra_end = ra_start + ra_size;
phdr = (struct elf_phdr *)bufp;
for_each_mem_range(i, &mstart, &mend) {
/* Boot memory regions already added, skip them now */
if (mstart < fw_dump.boot_mem_top) {
if (mend > fw_dump.boot_mem_top)
mstart = fw_dump.boot_mem_top;
else
continue;
}
phdr->p_paddr = mbase;
phdr->p_vaddr = (unsigned long)__va(mbase);
phdr->p_filesz = msize;
phdr->p_memsz = msize;
phdr->p_align = 0;
/* Handle memblock regions overlaps with fadump reserved area */
if ((ra_start < mend) && (ra_end > mstart)) {
if ((mstart < ra_start) && (mend > ra_end)) {
populate_elf_pt_load(phdr, mstart, ra_start - mstart, mstart);
/* Increment number of program headers. */
(elf->e_phnum)++;
bufp += sizeof(struct elf_phdr);
phdr = (struct elf_phdr *)bufp;
populate_elf_pt_load(phdr, ra_end, mend - ra_end, ra_end);
} else if (mstart < ra_start) {
populate_elf_pt_load(phdr, mstart, ra_start - mstart, mstart);
} else if (ra_end < mend) {
populate_elf_pt_load(phdr, ra_end, mend - ra_end, ra_end);
}
} else {
/* No overlap with fadump reserved memory region */
populate_elf_pt_load(phdr, mstart, mend - mstart, mstart);
}
/* Increment number of program headers. */
(elf->e_phnum)++;
bufp += sizeof(struct elf_phdr);
phdr = (struct elf_phdr *) bufp;
}
return 0;
}
static unsigned long init_fadump_header(unsigned long addr)
@ -1159,14 +1100,25 @@ static unsigned long init_fadump_header(unsigned long addr)
memset(fdh, 0, sizeof(struct fadump_crash_info_header));
fdh->magic_number = FADUMP_CRASH_INFO_MAGIC;
fdh->elfcorehdr_addr = addr;
fdh->version = FADUMP_HEADER_VERSION;
/* We will set the crashing cpu id in crash_fadump() during crash. */
fdh->crashing_cpu = FADUMP_CPU_UNKNOWN;
/*
* The physical address and size of vmcoreinfo are required in the
* second kernel to prepare elfcorehdr.
*/
fdh->vmcoreinfo_raddr = fadump_relocate(paddr_vmcoreinfo_note());
fdh->vmcoreinfo_size = VMCOREINFO_NOTE_SIZE;
fdh->pt_regs_sz = sizeof(struct pt_regs);
/*
* When LPAR is terminated by PYHP, ensure all possible CPUs'
* register data is processed while exporting the vmcore.
*/
fdh->cpu_mask = *cpu_possible_mask;
fdh->cpu_mask_sz = sizeof(struct cpumask);
return addr;
}
@ -1174,8 +1126,6 @@ static unsigned long init_fadump_header(unsigned long addr)
static int register_fadump(void)
{
unsigned long addr;
void *vaddr;
int ret;
/*
* If no memory is reserved then we can not register for firmware-
@ -1184,18 +1134,10 @@ static int register_fadump(void)
if (!fw_dump.reserve_dump_area_size)
return -ENODEV;
ret = fadump_setup_crash_memory_ranges();
if (ret)
return ret;
addr = fw_dump.fadumphdr_addr;
/* Initialize fadump crash info header. */
addr = init_fadump_header(addr);
vaddr = __va(addr);
pr_debug("Creating ELF core headers at %#016lx\n", addr);
fadump_create_elfcore_headers(vaddr);
/* register the future kernel dump with firmware. */
pr_debug("Registering for firmware-assisted kernel dump...\n");
@ -1214,7 +1156,6 @@ void fadump_cleanup(void)
} else if (fw_dump.dump_registered) {
/* Un-register Firmware-assisted dump if it was registered. */
fw_dump.ops->fadump_unregister(&fw_dump);
fadump_free_mem_ranges(&crash_mrange_info);
}
if (fw_dump.ops->fadump_cleanup)
@ -1400,6 +1341,22 @@ static void fadump_release_memory(u64 begin, u64 end)
fadump_release_reserved_area(tstart, end);
}
static void fadump_free_elfcorehdr_buf(void)
{
if (fw_dump.elfcorehdr_addr == 0 || fw_dump.elfcorehdr_size == 0)
return;
/*
* Before freeing the memory of `elfcorehdr`, reset the global
* `elfcorehdr_addr` to prevent modules like `vmcore` from accessing
* invalid memory.
*/
elfcorehdr_addr = ELFCORE_ADDR_ERR;
fadump_free_buffer(fw_dump.elfcorehdr_addr, fw_dump.elfcorehdr_size);
fw_dump.elfcorehdr_addr = 0;
fw_dump.elfcorehdr_size = 0;
}
static void fadump_invalidate_release_mem(void)
{
mutex_lock(&fadump_mutex);
@ -1411,6 +1368,7 @@ static void fadump_invalidate_release_mem(void)
fadump_cleanup();
mutex_unlock(&fadump_mutex);
fadump_free_elfcorehdr_buf();
fadump_release_memory(fw_dump.boot_mem_top, memblock_end_of_DRAM());
fadump_free_cpu_notes_buf();
@ -1616,6 +1574,102 @@ static void __init fadump_init_files(void)
return;
}
static int __init fadump_setup_elfcorehdr_buf(void)
{
int elf_phdr_cnt;
unsigned long elfcorehdr_size;
/*
* Program header for CPU notes comes first, followed by one for
* vmcoreinfo, and the remaining program headers correspond to
* memory regions.
*/
elf_phdr_cnt = 2 + fw_dump.boot_mem_regs_cnt + memblock_num_regions(memory);
elfcorehdr_size = sizeof(struct elfhdr) + (elf_phdr_cnt * sizeof(struct elf_phdr));
elfcorehdr_size = PAGE_ALIGN(elfcorehdr_size);
fw_dump.elfcorehdr_addr = (u64)fadump_alloc_buffer(elfcorehdr_size);
if (!fw_dump.elfcorehdr_addr) {
pr_err("Failed to allocate %lu bytes for elfcorehdr\n",
elfcorehdr_size);
return -ENOMEM;
}
fw_dump.elfcorehdr_size = elfcorehdr_size;
return 0;
}
/*
* Check if the fadump header of crashed kernel is compatible with fadump kernel.
*
* It checks the magic number, endianness, and size of non-primitive type
* members of fadump header to ensure safe dump collection.
*/
static bool __init is_fadump_header_compatible(struct fadump_crash_info_header *fdh)
{
if (fdh->magic_number == FADUMP_CRASH_INFO_MAGIC_OLD) {
pr_err("Old magic number, can't process the dump.\n");
return false;
}
if (fdh->magic_number != FADUMP_CRASH_INFO_MAGIC) {
if (fdh->magic_number == swab64(FADUMP_CRASH_INFO_MAGIC))
pr_err("Endianness mismatch between the crashed and fadump kernels.\n");
else
pr_err("Fadump header is corrupted.\n");
return false;
}
/*
* Dump collection is not safe if the size of non-primitive type members
* of the fadump header do not match between crashed and fadump kernel.
*/
if (fdh->pt_regs_sz != sizeof(struct pt_regs) ||
fdh->cpu_mask_sz != sizeof(struct cpumask)) {
pr_err("Fadump header size mismatch.\n");
return false;
}
return true;
}
static void __init fadump_process(void)
{
struct fadump_crash_info_header *fdh;
fdh = (struct fadump_crash_info_header *) __va(fw_dump.fadumphdr_addr);
if (!fdh) {
pr_err("Crash info header is empty.\n");
goto err_out;
}
/* Avoid processing the dump if fadump header isn't compatible */
if (!is_fadump_header_compatible(fdh))
goto err_out;
/* Allocate buffer for elfcorehdr */
if (fadump_setup_elfcorehdr_buf())
goto err_out;
fadump_populate_elfcorehdr(fdh);
/* Let platform update the CPU notes in elfcorehdr */
if (fw_dump.ops->fadump_process(&fw_dump) < 0)
goto err_out;
/*
* elfcorehdr is now ready to be exported.
*
* set elfcorehdr_addr so that vmcore module will export the
* elfcorehdr through '/proc/vmcore'.
*/
elfcorehdr_addr = virt_to_phys((void *)fw_dump.elfcorehdr_addr);
return;
err_out:
fadump_invalidate_release_mem();
}
/*
* Prepare for firmware-assisted dump.
*/
@ -1635,12 +1689,7 @@ int __init setup_fadump(void)
* saving it to the disk.
*/
if (fw_dump.dump_active) {
/*
* if dump process fails then invalidate the registration
* and release memory before proceeding for re-registration.
*/
if (fw_dump.ops->fadump_process(&fw_dump) < 0)
fadump_invalidate_release_mem();
fadump_process();
}
/* Initialize the kernel dump memory structure and register with f/w */
else if (fw_dump.reserve_dump_area_size) {

22
arch/powerpc/platforms/powernv/opal-fadump.c
View File

@ -513,8 +513,8 @@ out:
final_note(note_buf);
pr_debug("Updating elfcore header (%llx) with cpu notes\n",
fdh->elfcorehdr_addr);
fadump_update_elfcore_header(__va(fdh->elfcorehdr_addr));
fadump_conf->elfcorehdr_addr);
fadump_update_elfcore_header((char *)fadump_conf->elfcorehdr_addr);
return 0;
}
@ -526,12 +526,7 @@ static int __init opal_fadump_process(struct fw_dump *fadump_conf)
if (!opal_fdm_active || !fadump_conf->fadumphdr_addr)
return rc;
/* Validate the fadump crash info header */
fdh = __va(fadump_conf->fadumphdr_addr);
if (fdh->magic_number != FADUMP_CRASH_INFO_MAGIC) {
pr_err("Crash info header is not valid.\n");
return rc;
}
#ifdef CONFIG_OPAL_CORE
/*
@ -545,18 +540,7 @@ static int __init opal_fadump_process(struct fw_dump *fadump_conf)
kernel_initiated = true;
#endif
rc = opal_fadump_build_cpu_notes(fadump_conf, fdh);
if (rc)
return rc;
/*
* We are done validating dump info and elfcore header is now ready
* to be exported. set elfcorehdr_addr so that vmcore module will
* export the elfcore header through '/proc/vmcore'.
*/
elfcorehdr_addr = fdh->elfcorehdr_addr;
return rc;
return opal_fadump_build_cpu_notes(fadump_conf, fdh);
}
static void opal_fadump_region_show(struct fw_dump *fadump_conf,

34
arch/powerpc/platforms/pseries/rtas-fadump.c
View File

@ -375,11 +375,8 @@ static int __init rtas_fadump_build_cpu_notes(struct fw_dump *fadump_conf)
}
final_note(note_buf);
if (fdh) {
pr_debug("Updating elfcore header (%llx) with cpu notes\n",
fdh->elfcorehdr_addr);
fadump_update_elfcore_header(__va(fdh->elfcorehdr_addr));
}
pr_debug("Updating elfcore header (%llx) with cpu notes\n", fadump_conf->elfcorehdr_addr);
fadump_update_elfcore_header((char *)fadump_conf->elfcorehdr_addr);
return 0;
error_out:
@ -389,14 +386,11 @@ error_out:
}
/*
* Validate and process the dump data stored by firmware before exporting
* it through '/proc/vmcore'.
* Validate and process the dump data stored by the firmware, and update
* the CPU notes of elfcorehdr.
*/
static int __init rtas_fadump_process(struct fw_dump *fadump_conf)
{
struct fadump_crash_info_header *fdh;
int rc = 0;
if (!fdm_active || !fadump_conf->fadumphdr_addr)
return -EINVAL;
@ -415,25 +409,7 @@ static int __init rtas_fadump_process(struct fw_dump *fadump_conf)
return -EINVAL;
}
/* Validate the fadump crash info header */
fdh = __va(fadump_conf->fadumphdr_addr);
if (fdh->magic_number != FADUMP_CRASH_INFO_MAGIC) {
pr_err("Crash info header is not valid.\n");
return -EINVAL;
}
rc = rtas_fadump_build_cpu_notes(fadump_conf);
if (rc)
return rc;
/*
* We are done validating dump info and elfcore header is now ready
* to be exported. set elfcorehdr_addr so that vmcore module will
* export the elfcore header through '/proc/vmcore'.
*/
elfcorehdr_addr = fdh->elfcorehdr_addr;
return 0;
return rtas_fadump_build_cpu_notes(fadump_conf);
}
static void rtas_fadump_region_show(struct fw_dump *fadump_conf,