There are certain types of crashes induced by faulty hardware in which capturing crashing kernel's memory (through kdump) makes no sense (or sometimes dangerous). A case in point, is unrecoverable memory errors (resulting in fatal machine check exceptions) in which reading from the faulty memory location from the kexec'ed kernel will cause double fault and system reset (leaving no information for the user). This patch introduces a framework called 'slimdump' enabled through a new elf-note NT_NOCOREDUMP. Any error whose cause cannot be attributed to a software error and cannot be detected by analysing the kernel memory may decide to add this elf-note to the vmcore and indicate the futility of such an exercise. Tools such as 'kexec', 'makedumpfile' and 'crash' are also modified in tandem to recognise this new elf-note and capture 'slimdump'. The physical address and size of the NT_NOCOREDUMP are made available to the user-space through a "/sys/kernel/nt_nocoredump" sysfs file (just like other kexec related files). Signed-off-by: K.Prasad <prasad(a)linux.vnet.ibm.com&gt; --- arch/x86/kernel/cpu/mcheck/mce.c | 28 ++++++++++++++++++++++++++++ include/linux/elf.h | 18 ++++++++++++++++++ include/linux/kexec.h | 1 + kernel/kexec.c | 11 +++++++++++ kernel/ksysfs.c | 10 ++++++++++ 5 files changed, 68 insertions(+), 0 deletions(-) diff --git a/arch/x86/kernel/cpu/mcheck/mce.c b/arch/x86/kernel/cpu/mcheck/mce.c index 08363b0..483b2fc 100644 --- a/arch/x86/kernel/cpu/mcheck/mce.c +++ b/arch/x86/kernel/cpu/mcheck/mce.c @@ -238,6 +238,34 @@ static atomic_t mce_paniced; static int fake_panic; static atomic_t mce_fake_paniced; +void arch_add_nocoredump_note(u32 *buf) +{ + struct elf_note note; + const char note_name[] = "PANIC_MCE"; + const char desc_msg[] = "Crash induced due to a fatal machine " + "check error"; + + /* + * Prevent coredump from being captured if the panic was triggered due + * to a fatal Machine Check Exception (MCE). + */ + if ((atomic_read(&mce_paniced) == 0) || + (strlen(desc_msg) >= NT_NOCOREDUMP_DESC_BYTES)) + return; + + note.n_namesz = strlen(note_name) + 1; + /* We have no additional description */ + note.n_descsz = strlen(desc_msg) + 1; + note.n_type = NT_NOCOREDUMP; + + memcpy(buf, &note, sizeof(note)); + buf += (sizeof(note) + 3)/4; + memcpy(buf, note_name, note.n_namesz); + buf += (note.n_namesz + 3)/4; + memcpy(buf, desc_msg, note.n_descsz); + buf += (note.n_descsz + 3)/4; +} + /* Panic in progress. Enable interrupts and wait for final IPI */ static void wait_for_panic(void) { diff --git a/include/linux/elf.h b/include/linux/elf.h index 110821c..4be4746 100644 --- a/include/linux/elf.h +++ b/include/linux/elf.h @@ -381,6 +381,11 @@ typedef struct elf64_shdr { #define NT_PRPSINFO 3 #define NT_TASKSTRUCT 4 #define NT_AUXV 6 +/* + * Note to indicate absence of coredump for crashes initiated due to hardware + * errors + */ +#define NT_NOCOREDUMP 21 #define NT_PRXFPREG 0x46e62b7f /* copied from gdb5.1/include/elf/common.h */ #define NT_PPC_VMX 0x100 /* PowerPC Altivec/VMX registers */ #define NT_PPC_SPE 0x101 /* PowerPC SPE/EVR registers */ @@ -435,6 +440,19 @@ extern Elf64_Dyn _DYNAMIC []; #endif +/* NT_NOCOREDUMP related definitions used while creating an elf-note */ +#define NT_NOCOREDUMP_HEAD_BYTES ALIGN(sizeof(struct elf_note), 4) +/* + * The creator of NT_NOCOREDUMP will define the name based on the reason for + * which dump is not captured. for e.g. "PANIC_MCE" + */ +#define NT_NOCOREDUMP_NAME_BYTES 50 +#define NT_NOCOREDUMP_DESC_BYTES (1024) +#define NT_NOCOREDUMP_NOTE_BYTES (NT_NOCOREDUMP_HEAD_BYTES + \ + NT_NOCOREDUMP_NAME_BYTES + \ + NT_NOCOREDUMP_DESC_BYTES) +extern u32 nt_nocoredump_note[(NT_NOCOREDUMP_NOTE_BYTES + 3)/4]; + /* Optional callbacks to write extra ELF notes. */ #ifndef ARCH_HAVE_EXTRA_ELF_NOTES static inline int elf_coredump_extra_notes_size(void) { return 0; } diff --git a/include/linux/kexec.h b/include/linux/kexec.h index c2478a3..84d9b1a 100644 --- a/include/linux/kexec.h +++ b/include/linux/kexec.h @@ -133,6 +133,7 @@ void arch_crash_save_vmcoreinfo(void); void vmcoreinfo_append_str(const char *fmt, ...) __attribute__ ((format (printf, 1, 2))); unsigned long paddr_vmcoreinfo_note(void); +unsigned long paddr_nocoredump_note(void); #define VMCOREINFO_OSRELEASE(value) \ vmcoreinfo_append_str("OSRELEASE=%s\n", value) diff --git a/kernel/kexec.c b/kernel/kexec.c index 296fbc8..d49456e 100644 --- a/kernel/kexec.c +++ b/kernel/kexec.c @@ -50,6 +50,9 @@ u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4]; size_t vmcoreinfo_size; size_t vmcoreinfo_max_size = sizeof(vmcoreinfo_data); +/* NT_NOCOREDUMP related definitions */ +u32 nt_nocoredump_note[(NT_NOCOREDUMP_NOTE_BYTES + 3)/4]; + /* Location of the reserved area for the crash kernel */ struct resource crashk_res = { .name = "Crash kernel", @@ -1065,6 +1068,8 @@ asmlinkage long compat_sys_kexec_load(unsigned long entry, } #endif +__weak void arch_add_nocoredump_note(u32 *buf) {} + void crash_kexec(struct pt_regs *regs) { /* Take the kexec_mutex here to prevent sys_kexec_load @@ -1083,6 +1088,7 @@ void crash_kexec(struct pt_regs *regs) crash_setup_regs(&fixed_regs, regs); crash_save_vmcoreinfo(); + arch_add_nocoredump_note(nt_nocoredump_note); machine_crash_shutdown(&fixed_regs); machine_kexec(kexec_crash_image); } @@ -1428,6 +1434,11 @@ unsigned long __attribute__ ((weak)) paddr_vmcoreinfo_note(void) return __pa((unsigned long)(char *)&vmcoreinfo_note); } +unsigned long __attribute__ ((weak)) paddr_nocoredump_note(void) +{ + return __pa((unsigned long)(char *)&nt_nocoredump_note); +} + static int __init crash_save_vmcoreinfo_init(void) { VMCOREINFO_OSRELEASE(init_uts_ns.name.release); diff --git a/kernel/ksysfs.c b/kernel/ksysfs.c index 3b053c0..ef29ee6 100644 --- a/kernel/ksysfs.c +++ b/kernel/ksysfs.c @@ -130,6 +130,15 @@ static ssize_t vmcoreinfo_show(struct kobject *kobj, } KERNEL_ATTR_RO(vmcoreinfo); +static ssize_t nt_nocoredump_show(struct kobject *kobj, + struct kobj_attribute *attr, char *buf) +{ + return sprintf(buf, "%lx %x\n", + paddr_nocoredump_note(), + (unsigned int)NT_NOCOREDUMP_NOTE_BYTES); +} +KERNEL_ATTR_RO(nt_nocoredump); + #endif /* CONFIG_KEXEC */ /* whether file capabilities are enabled */ @@ -180,6 +189,7 @@ static struct attribute * kernel_attrs[] = { &kexec_crash_loaded_attr.attr, &kexec_crash_size_attr.attr, &vmcoreinfo_attr.attr, + &nt_nocoredump_attr.attr, #endif NULL }; -- 1.7.4.1

On Mon, Oct 03, 2011 at 01:02:03PM +0530, K.Prasad wrote: Even if kernel has to signal to user space the reason for crash, why not add this info to existing vmcoreinfo note. Something like another filed. PANIC_MCE=1. Secondly, the note name NT_NOCOREDUMP itself sounds binding. Kernel can export the reason of panic and then it is up to user space what do they want to do with it. So to me, Again, note_name and desc_msg seem to be only two exports. Frankly desc string seems pretty obivious and we should be able to ignore it. So just exporting PANIC_MCE=true or something like that in case of MCE. Thanks Vivek

The kernel decides to add a new elf-note of type NT_NOCOREDUMP for various hardware error triggered crashes where it makes no sense (or sometimes dangerous) to capture kernel memory into the dump. This patch teaches 'makedumpfile' tool needs to recognise the new elf-note type and act accordingly. Since only a 'slimdump' of a very small size (containing only elf-headers and elf-notes section) will be captured, the coredump will be of ELF type (and not kdump-compressed format). Todo: Make changes to the man pages of makedumpfile to describe these changes. Signed-off-by: K.Prasad <prasad(a)linux.vnet.ibm.com&gt; --- elf_info.c | 36 ++++++++++++++++++++++++++++++++++++ elf_info.h | 8 ++++++++ makedumpfile.c | 13 ++++++++++++- makedumpfile.h | 1 + 4 files changed, 57 insertions(+), 1 deletions(-) diff --git a/elf_info.c b/elf_info.c index 114dd05..de93d9a 100644 --- a/elf_info.c +++ b/elf_info.c @@ -287,6 +287,41 @@ offset_note_desc(void *note) return offset; } +/* + * The kernel generally adds an elf-note of type NT_NOCOREDUMP if the crash is + * due to a hardware error and when it makes no sense to read/store the + * crashing kernel's memory. In such a case, only a 'slimdump' is captured. + * + * This function checks if the elf-header has a note of type NT_NOCOREDUMP. + */ +int +has_nocoredump_note(void) +{ + char note[MAX_SIZE_NHDR]; + off_t offset; + + offset = offset_pt_note_memory; + while (offset < offset_pt_note_memory + size_pt_note_memory) { + if (lseek(fd_memory, offset, SEEK_SET) < 0) { + ERRMSG("Can't seek the dump memory(%s). %s\n", + name_memory, strerror(errno)); + return FALSE; + } + if (read(fd_memory, note, sizeof(note)) != sizeof(note)) { + ERRMSG("Can't read the dump memory(%s). %s\n", + name_memory, strerror(errno)); + return FALSE; + } + if (note_type(note) == NT_NOCOREDUMP) { + DEBUG_MSG("kdump will not be collected. " + "NT_NOCOREDUMP elf-note present.\n"); + return TRUE; + } + offset += offset_next_note(note); + } + return FALSE; +} + static int get_pt_note_info(void) { @@ -630,6 +665,7 @@ get_elf_info(int fd, char *filename) ERRMSG("Can't find PT_NOTE Phdr.\n"); return FALSE; } + has_nocoredump_note(); if (!get_pt_note_info()) { ERRMSG("Can't get PT_NOTE information.\n"); return FALSE; diff --git a/elf_info.h b/elf_info.h index 4dff9c1..10fdc0b 100644 --- a/elf_info.h +++ b/elf_info.h @@ -22,6 +22,12 @@ #define ERASEINFO_NOTE_NAME "ERASEINFO" #define ERASEINFO_NOTE_NAME_BYTES (sizeof(ERASEINFO_NOTE_NAME)) +/* + * Temporary definition of new elf-note type for compilation purposes. + * Not required when run on a new kernel containing this definition. + */ +#define NT_NOCOREDUMP 21 + #define MAX_SIZE_NHDR MAX(sizeof(Elf64_Nhdr), sizeof(Elf32_Nhdr)) @@ -34,6 +40,8 @@ unsigned long long get_max_paddr(void); int get_elf64_ehdr(int fd, char *filename, Elf64_Ehdr *ehdr); int get_elf32_ehdr(int fd, char *filename, Elf32_Ehdr *ehdr); int get_elf_info(int fd, char *filename); +int has_nocoredump_note(void); + void free_elf_info(void); int is_elf64_memory(void); diff --git a/makedumpfile.c b/makedumpfile.c index 7b7c266..a73b4f7 100644 --- a/makedumpfile.c +++ b/makedumpfile.c @@ -4173,7 +4173,11 @@ write_elf_pages(struct cache_data *cd_header, struct cache_data *cd_page) if (!get_phdr_memory(i, &load)) return FALSE; - if (load.p_type != PT_LOAD) + /* + * Do not capture the kernel's memory if flag_nocoredump is + * turned on. This may be dangerous to the system stability. + */ + if ((load.p_type != PT_LOAD) || (info->flag_nocoredump)) continue; off_memory= load.p_offset; @@ -5760,6 +5764,13 @@ create_dumpfile(void) if (!get_elf_info(info->fd_memory, info->name_memory)) return FALSE; } + /* + * If NT_NOCOREDUMP elf-note is present, indicate the same through + * 'flag_nocoredump' flag. The resultant slimdump will always be in ELF + * format, irrespective of the user options. + */ + info->flag_nocoredump = info->flag_elf_dumpfile = has_nocoredump_note(); + if (is_xen_memory()) { if (!initial_xen()) return FALSE; diff --git a/makedumpfile.h b/makedumpfile.h index f0e5da8..faf1c65 100644 --- a/makedumpfile.h +++ b/makedumpfile.h @@ -778,6 +778,7 @@ struct DumpInfo { int flag_exclude_xen_dom;/* exclude Domain-U from xen-kdump */ int flag_dmesg; /* dump the dmesg log out of the vmcore file */ int flag_nospace; /* the flag of "No space on device" error */ + int flag_nocoredump; /* coredump not collected */ unsigned long vaddr_for_vtop; /* virtual address for debugging */ long page_size; /* size of page */ long page_shift; -- 1.7.4.1

----- Original Message ----- At this point, I'll admit I'm not sure I totally understand this patch or what the dumpfile header layout would look like. Your new "myload64" pointer is not pointing to a PT_LOAD, but rather the first PT_NOTE, so its name doesn't even make sense in that respect. And for that matter, I don't see why you didn't just use the currently existing nd->notes64 pointer, which points to the same place? Also, the re-definition of the currently-existing "size" value scares the hell out of me w/respect to backwards-compatibility. And lastly, if I'm not mistaken, when you do the realloc() of tmp_elf_header, it may return a different address -- so wouldn't nd->elf_header be left pointing to the old buffer? And by extension, stale pointer values could be left in nd->elf64, nd->num_pt_load_segments, nd->notes64, nd->load64, etc? I would rather that you is_netdump() is left intact -- except for a call to a new "check_nocoredump()" function, one which does not tinker with the is_netdump() pointers, sizes, buffers, etc... Let that function do its own thing, and if it finds that there's no coredump, then it's not going to return and we're done. But in 99.99% of the time, there will be a coredump, and your function will not have screwed around with any of is_netdump()'s bookkeeping. Anyway, when the feature is accepted upstream in the kernel, and then by makedumpfile, we'll revisit this. Thanks, Dave