[PATCH] stack2core: show stack message and convert it to core file when kernel die

[PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

Hello,

For, when the kernel die, the user will get some message like:
PC is at kernel_init+0xd4/0x104
LR is at _atomic_dec_and_lock+0x48/0x6c
pc : [<c0008470>]    lr : [<c01911f8>]    psr: 60000013
sp : c7823fd8  ip : c7823f48  fp : c7823ff4
Stack: (0xc7823fd8 to 0xc7824000)
3fc0:                                                       00000000 00000001
Backtrace:
[<c000839c>] (kernel_init+0x0/0x104) from [<c0042660>] (do_exit+0x0/0x880)
This backtrace have some wrong message sometime and cannot get any
val. Of course, kdump can get more message.  But it need do some a lot
of other config.

The stack2core function, can let kernel show stack message when kernel
die.  This stack message can be convert to core file by program s2c
(tools/s2c).  Then gdb can show the message in this core file.
For example:
When kernel die, show some message:
S2C:elf_class=1
S2C:elf_data=1
S2C:elf_arch=40
S2C:elf_osabi=0
S2C:r0=0x00000000;
S2C:r1=0xc7822000;
S2C:r2=0xc7823f48;
S2C:r3=0x00000003;
S2C:r4=0x00000000;
S2C:r5=0x00000000;
S2C:r6=0x00000000;
S2C:r7=0x00000000;
S2C:r8=0x00000000;
S2C:r9=0x00000000;
S2C:r10=0x00000000;
S2C:fp=0xc7823ff4;
S2C:ip=0xc7823f48;
S2C:sp=0xc7823fd8;
S2C:lr=0xc01911f8;
S2C:pc=0xc0008470;
S2C:cpsr=0x60000013;
S2C:ORIG_r0=0xffffffff;

S2C:stack=0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
S2C:stack=0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
S2C:stack=0x00, 0x00, 0x00, 0x00, 0xf8, 0x3f, 0x82, 0xc7,
S2C:stack=0x60, 0x26, 0x04, 0xc0, 0xa8, 0x83, 0x00, 0xc0,
S2C:stack=0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
S2C:commandline=console=ttyAMA0,115200 ip=dhcp root=/dev/nfs
nfsroot=10.0.2.2:/home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/export/dist,nfsvers=2,mountprog=21111,nfsprog=11111,udp
rw highres=off UMA=1

Save it to file t.txt.  This is the reg message and stack message.

Get the s2c program.
cd linux-2.6/tools/s2c
sudo make install

Get the core file.
s2c < t.txt >core

Use core file.
gdb ./vmlinux core
Core was generated by `console=ttyAMA0,115200 ip=dhcp root=/dev/nfs
nfsroot=10.0.2.2:/home/teawater/ke'.
[New process 0]
#0  0xc0008470 in kernel_init (unused=<value optimized out>)
    at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/init/main.c:916
916		buf[0] = 3;
(gdb) bt
#0  0xc0008470 in kernel_init (unused=<value optimized out>)
    at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/init/main.c:916
#1  0xc0042660 in sys_waitid (which=<value optimized out>, upid=<value
optimized out>, infop=0x0, options=0, ru=0x14)
    at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/kernel/exit.c:1798
Backtrace stopped: previous frame inner to this frame (corrupt stack?)
(gdb) frame 1
#1  0xc0042660 in sys_waitid (which=<value optimized out>, upid=<value
optimized out>, infop=0x0, options=0, ru=0x14)
    at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/kernel/exit.c:1798
1798			pid = find_get_pid(upid);
(gdb) p pid
$1 = (struct pid *) 0x0

It can support lkm:
The stack message will include:
S2C:add-symbol-file e.ko 0xffffffffa0000000
In gdb, use command "add-symbol-file e.ko 0xffffffffa0000000" let gdb
load the symbol of this lkm.


Now, stack2core support x86, x8664, arm, mips.

Thanks,
Hui

---
 arch/arm/kernel/traps.c        |   27 +
 arch/mips/kernel/traps.c       |   20
 arch/x86/kernel/dumpstack_32.c |   27 +
 arch/x86/kernel/dumpstack_64.c |   31 +
 include/linux/module.h         |    4
 include/linux/stack2core.h     |   49 +
 kernel/module.c                |   13
 lib/Kconfig.debug              |    9
 tools/s2c/Makefile             |   15
 tools/s2c/s2c.c                | 1009 +++++++++++++++++++++++++++++++++++++++++
 10 files changed, 1204 insertions(+)

--- a/arch/arm/kernel/traps.c
+++ b/arch/arm/kernel/traps.c
@@ -28,6 +28,7 @@
 #include <asm/unistd.h>
 #include <asm/traps.h>
 #include <asm/unwind.h>
+#include <linux/stack2core.h>

 #include "ptrace.h"
 #include "signal.h"
@@ -242,6 +243,32 @@ static void __die(const char *str, int e
 			 THREAD_SIZE + (unsigned long)task_stack_page(tsk));
 		dump_backtrace(regs, tsk);
 		dump_instr(KERN_EMERG, regs);
+
+#ifdef CONFIG_STACK2CORE
+		stack2core_header();
+
+		/* Show the registers */
+		printk(S2CMARK"r0=0x%08x;\n", (unsigned int)regs->ARM_r0);
+		printk(S2CMARK"r1=0x%08x;\n", (unsigned int)regs->ARM_r1);
+		printk(S2CMARK"r2=0x%08x;\n", (unsigned int)regs->ARM_r2);
+		printk(S2CMARK"r3=0x%08x;\n", (unsigned int)regs->ARM_r3);
+		printk(S2CMARK"r4=0x%08x;\n", (unsigned int)regs->ARM_r4);
+		printk(S2CMARK"r5=0x%08x;\n", (unsigned int)regs->ARM_r5);
+		printk(S2CMARK"r6=0x%08x;\n", (unsigned int)regs->ARM_r6);
+		printk(S2CMARK"r7=0x%08x;\n", (unsigned int)regs->ARM_r7);
+		printk(S2CMARK"r8=0x%08x;\n", (unsigned int)regs->ARM_r8);
+		printk(S2CMARK"r9=0x%08x;\n", (unsigned int)regs->ARM_r9);
+		printk(S2CMARK"r10=0x%08x;\n", (unsigned int)regs->ARM_r10);
+		printk(S2CMARK"fp=0x%08x;\n", (unsigned int)regs->ARM_fp);
+		printk(S2CMARK"ip=0x%08x;\n", (unsigned int)regs->ARM_ip);
+		printk(S2CMARK"sp=0x%08x;\n", (unsigned int)regs->ARM_sp);
+		printk(S2CMARK"lr=0x%08x;\n", (unsigned int)regs->ARM_lr);
+		printk(S2CMARK"pc=0x%08x;\n", (unsigned int)regs->ARM_pc);
+		printk(S2CMARK"cpsr=0x%08x;\n", (unsigned int)regs->ARM_cpsr);
+		printk(S2CMARK"ORIG_r0=0x%08x;\n", (unsigned int)regs->ARM_ORIG_r0);
+
+		stack2core_tail((uint8_t *)(regs->ARM_sp));
+#endif	/* CONFIG_STACK2CORE */
 	}
 }

--- a/arch/mips/kernel/traps.c
+++ b/arch/mips/kernel/traps.c
@@ -347,6 +347,26 @@ void show_registers(const struct pt_regs
 	show_stacktrace(current, regs);
 	show_code((unsigned int __user *) regs->cp0_epc);
 	printk("\n");
+#ifdef CONFIG_STACK2CORE
+	stack2core_header();
+
+	/* Show the registers */
+	{
+		int	i;
+
+		for (i = 0; i < 32; i++)
+			printk(S2CMARK"r%d=0x%lx;\n", i, regs->regs[i]);
+
+		printk(S2CMARK"cp0_status=0x%lx;\n", regs->cp0_status);
+		printk(S2CMARK"hi=0x%lx;\n", regs->hi);
+		printk(S2CMARK"lo=0x%lx;\n", regs->lo);
+		printk(S2CMARK"cp0_badvaddr=0x%lx;\n", regs->cp0_badvaddr);
+		printk(S2CMARK"cp0_cause=0x%lx;\n", regs->cp0_cause);
+		printk(S2CMARK"cp0_epc=0x%lx;\n", regs->cp0_epc);
+	}
+
+	stack2core_tail((uint8_t *)(regs->regs[29]));
+#endif	/* CONFIG_STACK2CORE */
 }

 static DEFINE_SPINLOCK(die_lock);
--- a/arch/x86/kernel/dumpstack_32.c
+++ b/arch/x86/kernel/dumpstack_32.c
@@ -13,6 +13,7 @@
 #include <linux/sysfs.h>
 #include <linux/bug.h>
 #include <linux/nmi.h>
+#include <linux/stack2core.h>

 #include <asm/stacktrace.h>

@@ -141,6 +142,32 @@ void show_registers(struct pt_regs *regs
 			else
 				printk("%02x ", c);
 		}
+
+#ifdef CONFIG_STACK2CORE
+		printk("\n");
+		stack2core_header();
+
+		/* Show the registers */
+		printk(S2CMARK"bx=0x%08x;\n", (unsigned int)regs->bx);
+		printk(S2CMARK"cx=0x%08x;\n", (unsigned int)regs->cx);
+		printk(S2CMARK"dx=0x%08x;\n", (unsigned int)regs->dx);
+		printk(S2CMARK"si=0x%08x;\n", (unsigned int)regs->si);
+		printk(S2CMARK"di=0x%08x;\n", (unsigned int)regs->di);
+		printk(S2CMARK"bp=0x%08x;\n", (unsigned int)regs->bp);
+		printk(S2CMARK"ax=0x%08x;\n", (unsigned int)regs->ax);
+		printk(S2CMARK"ds=0x%08x;\n", (unsigned int)regs->ds);
+		printk(S2CMARK"es=0x%08x;\n", (unsigned int)regs->es);
+		printk(S2CMARK"fs=0x%08x;\n", (unsigned int)regs->fs);
+		printk(S2CMARK"gs=0x%08x;\n", (unsigned int)regs->gs);
+		printk(S2CMARK"orig_ax=0x%08x;\n", (unsigned int)regs->orig_ax);
+		printk(S2CMARK"ip=0x%08x;\n", (unsigned int)regs->ip);
+		printk(S2CMARK"cs=0x%08x;\n", (unsigned int)regs->cs);
+		printk(S2CMARK"flags=0x%08x;\n", (unsigned int)regs->flags);
+		printk(S2CMARK"sp=0x%08x;\n", (unsigned int)&regs->sp);
+		printk(S2CMARK"ss=0x%08x;\n", (unsigned int)regs->ss);
+
+		stack2core_tail((uint8_t *)(&regs->sp));
+#endif	/* CONFIG_STACK2CORE */
 	}
 	printk("\n");
 }
--- a/arch/x86/kernel/dumpstack_64.c
+++ b/arch/x86/kernel/dumpstack_64.c
@@ -13,6 +13,7 @@
 #include <linux/sysfs.h>
 #include <linux/bug.h>
 #include <linux/nmi.h>
+#include <linux/stack2core.h>

 #include <asm/stacktrace.h>

@@ -328,6 +329,36 @@ void show_registers(struct pt_regs *regs
 			else
 				printk("%02x ", c);
 		}
+
+#ifdef CONFIG_STACK2CORE
+		printk("\n");
+		stack2core_header();
+
+		/* Show the registers */
+		printk(S2CMARK"r15=0x%016x;\n", (unsigned long)regs->r15);
+		printk(S2CMARK"r14=0x%016x;\n", (unsigned long)regs->r14);
+		printk(S2CMARK"r13=0x%016x;\n", (unsigned long)regs->r13);
+		printk(S2CMARK"r12=0x%016x;\n", (unsigned long)regs->r12);
+		printk(S2CMARK"bp=0x%016x;\n", (unsigned long)regs->bp);
+		printk(S2CMARK"bx=0x%016x;\n", (unsigned long)regs->bx);
+		printk(S2CMARK"r11=0x%016x;\n", (unsigned long)regs->r11);
+		printk(S2CMARK"r10=0x%016x;\n", (unsigned long)regs->r10);
+		printk(S2CMARK"r9=0x%016x;\n", (unsigned long)regs->r9);
+ 		printk(S2CMARK"r8=0x%016x;\n", (unsigned long)regs->r8);
+		printk(S2CMARK"ax=0x%016x;\n", (unsigned long)regs->ax);
+		printk(S2CMARK"cx=0x%016x;\n", (unsigned long)regs->cx);
+		printk(S2CMARK"dx=0x%016x;\n", (unsigned long)regs->dx);
+		printk(S2CMARK"si=0x%016x;\n", (unsigned long)regs->si);
+		printk(S2CMARK"di=0x%016x;\n", (unsigned long)regs->di);
+		printk(S2CMARK"orig_ax=0x%016x;\n", (unsigned long)regs->orig_ax);
+		printk(S2CMARK"ip=0x%016x;\n", (unsigned long)regs->ip);
+		printk(S2CMARK"cs=0x%016x;\n", (unsigned long)regs->cs);
+		printk(S2CMARK"flags=0x%016x;\n", (unsigned long)regs->flags);
+		printk(S2CMARK"sp=0x%016x;\n", (unsigned long)regs->sp);
+		printk(S2CMARK"ss=0x%016x;\n", (unsigned long)regs->ss);
+
+		stack2core_tail((uint8_t *)(regs->sp));
+#endif	/* CONFIG_STACK2CORE */
 	}
 	printk("\n");
 }
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -726,4 +726,8 @@ static inline int  module_bug_finalize(c
 static inline void module_bug_cleanup(struct module *mod) {}
 #endif	/* CONFIG_GENERIC_BUG */

+#ifdef CONFIG_STACK2CORE
+extern void module_print_address_for_s2c (void);
+#endif	/* CONFIG_STACK2CORE */
+
 #endif /* _LINUX_MODULE_H */
--- /dev/null
+++ b/include/linux/stack2core.h
@@ -0,0 +1,49 @@
+/*
+ *  Copyright (C) 2009, 2010, Hui Zhu
+ */
+#ifndef _STACK2CORE_H_
+#define _STACK2CORE_H_
+
+#ifdef CONFIG_STACK2CORE
+
+#define S2CMARK	KERN_EMERG "S2C:"
+
+static inline void
+stack2core_header(void)
+{
+	printk(S2CMARK"elf_class=%d\n", ELF_CLASS);
+	printk(S2CMARK"elf_data=%d\n", ELF_DATA);
+	printk(S2CMARK"elf_arch=%d\n", ELF_ARCH);
+	printk(S2CMARK"elf_osabi=%d\n", ELF_OSABI);
+}
+
+static inline void
+stack2core_tail(uint8_t *stack)
+{
+	int	i = 7;
+	uint8_t	*stack_end = (uint8_t *)(((unsigned long)stack &
(~(THREAD_SIZE - 1))) + THREAD_SIZE);
+
+	/* Show stack.  */
+	for (; stack < stack_end; stack++) {
+		if (i > 6) {
+			printk("\n");
+			printk(S2CMARK"stack=0x%02x,", stack[0]);
+			i = 0;
+		}
+		else {
+			printk(" 0x%02x,", stack[0]);
+			i ++;
+		}
+	}
+	printk("\n");
+
+	/* Show the modules.  */
+	module_print_address_for_s2c ();
+
+	/* Show command line.  */
+	printk(S2CMARK"commandline=%s\n", saved_command_line);
+}
+
+#endif	/* CONFIG_STACK2CORE */
+
+#endif /* _STACK2CORE_H_ */
--- a/kernel/module.c
+++ b/kernel/module.c
@@ -55,6 +55,7 @@
 #include <linux/async.h>
 #include <linux/percpu.h>
 #include <linux/kmemleak.h>
+#include <linux/stack2core.h>

 #define CREATE_TRACE_POINTS
 #include <trace/events/module.h>
@@ -3014,3 +3015,15 @@ int module_get_iter_tracepoints(struct t
 	return found;
 }
 #endif
+
+#ifdef CONFIG_STACK2CORE
+void
+module_print_address_for_s2c (void)
+{
+	struct module *mod;
+
+	list_for_each_entry(mod, &modules, list)
+		printk(S2CMARK"add-symbol-file %s.ko 0x%p\n",
+			mod->name, mod->module_core);
+}
+#endif	/* CONFIG_STACK2CORE */
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -322,6 +322,15 @@ config DEBUG_SLAB
 	  allocation as well as poisoning memory on free to catch use of freed
 	  memory. This can make kmalloc/kfree-intensive workloads much slower.

+config STACK2CORE
+	bool "Output stack data when kernel die."
+	depends on DEBUG_KERNEL && (X86 || MIPS || ARM)
+	default y
+	help
+	  If say Y here, kernel will output stack data when it die.  This data
+	  can be convert to core file through program stack2core.  Then GDB can
+	  do clear backtrace with this core file.
+
 config DEBUG_SLAB_LEAK
 	bool "Memory leak debugging"
 	depends on DEBUG_SLAB
--- /dev/null
+++ b/tools/s2c/Makefile
@@ -0,0 +1,15 @@
+TARGET = s2c
+CC = gcc
+CFLAGS = -g
+
+
+all: $(TARGET)
+
+$(TARGET): $(TARGET).c
+	$(CC) $(CFLAGS) $(TARGET).c -o $(TARGET)
+
+clean:
+	rm -rf $(TARGET)
+
+install: $(TARGET)
+	cp $(TARGET) /bin/
--- /dev/null
+++ b/tools/s2c/s2c.c
@@ -0,0 +1,1009 @@
+/*
+ *  Copyright (C) 2009, 2010, Hui Zhu
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdint.h>
+#include <ctype.h>
+#include <byteswap.h>
+
+#define S2CMARK		"S2C:"
+
+#define S2C_ELFCLASS32	1
+#define S2C_ELFCLASS64	2
+
+#define S2C_ELFDATA2LSB	1	/* little endian */
+#define S2C_ELFDATA2MSB	2	/* big endian */
+
+#define S2C_EM_386	3
+#define S2C_EM_X86_64	62
+#define S2C_EM_ARM	40
+#define S2C_EM_MIPS	8
+
+#define NEEDSWAP	((BYTE_ORDER == LITTLE_ENDIAN \
+                          && elf_data == S2C_ELFDATA2MSB) \
+		         || (BYTE_ORDER == BIG_ENDIAN \
+                             && elf_data == S2C_ELFDATA2LSB))
+#define SWAP16(a)	(NEEDSWAP ? bswap_16 (a) : a)
+#define SWAP32(a)	(NEEDSWAP ? bswap_32 (a) : a)
+#define SWAP64(a)	(NEEDSWAP ? bswap_64 (a) : a)
+
+#define GETU32(ul, str) \
+	if (strncmp (line, str, strlen (str)) == 0) { \
+		ul = strtoul (line + strlen (str), NULL, 0); \
+		return 0; \
+	}
+
+#define GETU64(ul, str) \
+	if (strncmp (line, str, strlen (str)) == 0) { \
+		ul = strtoull (line + strlen (str), NULL, 0); \
+		return 0; \
+	}
+
+/* Parse and save the input.  */
+
+uint8_t	elf_class = 0;
+uint8_t	elf_data = 0;
+uint8_t	elf_arch = 0;
+uint8_t	elf_osabi = 0;
+
+#define S2C_ELF_PRARGSZ	(80)
+uint8_t	commandline[S2C_ELF_PRARGSZ];
+
+#define S2C_THREAD_SIZE	8192
+uint8_t	stack[S2C_THREAD_SIZE];
+int stack_len = 0;
+
+uint32_t	sp_32 = 0;
+uint64_t	sp_64 = 0;
+
+/* I386 */
+
+uint32_t	i386_bx = 0;
+uint32_t	i386_cx = 0;
+uint32_t	i386_dx = 0;
+uint32_t	i386_si = 0;
+uint32_t	i386_di = 0;
+uint32_t	i386_bp = 0;
+uint32_t	i386_ax = 0;
+uint32_t	i386_ds = 0;
+uint32_t	i386_es = 0;
+uint32_t	i386_fs = 0;
+uint32_t	i386_gs = 0;
+uint32_t	i386_orig_ax = 0;
+uint32_t	i386_ip = 0;
+uint32_t	i386_cs = 0;
+uint32_t	i386_flags = 0;
+uint32_t	i386_sp = 0;
+uint32_t	i386_ss = 0;
+
+int
+parse_line_i386 (char *line)
+{
+	GETU32 (i386_bx, "bx=");
+	GETU32 (i386_cx, "cx=");
+	GETU32 (i386_dx, "dx=");
+	GETU32 (i386_si, "si=");
+	GETU32 (i386_di, "di=");
+	GETU32 (i386_bp, "bp=");
+	GETU32 (i386_ax, "ax=");
+	GETU32 (i386_ds, "ds=");
+	GETU32 (i386_es, "es=");
+	GETU32 (i386_fs, "fs=");
+	GETU32 (i386_gs, "gs=");
+	GETU32 (i386_orig_ax, "orig_ax=");
+	GETU32 (i386_ip, "ip=");
+	GETU32 (i386_cs, "cs=");
+	GETU32 (i386_flags, "flags=");
+	GETU32 (i386_sp, "sp=");
+	GETU32 (i386_ss, "ss=");
+
+	return 0;
+}
+
+/* x86_64 */
+
+uint64_t	x86_64_r15 = 0;
+uint64_t	x86_64_r14 = 0;
+uint64_t	x86_64_r13 = 0;
+uint64_t	x86_64_r12 = 0;
+uint64_t	x86_64_bp = 0;
+uint64_t	x86_64_bx = 0;
+uint64_t	x86_64_r11 = 0;
+uint64_t	x86_64_r10 = 0;
+uint64_t	x86_64_r9 = 0;
+uint64_t	x86_64_r8 = 0;
+uint64_t	x86_64_ax = 0;
+uint64_t	x86_64_cx = 0;
+uint64_t	x86_64_dx = 0;
+uint64_t	x86_64_si = 0;
+uint64_t	x86_64_di = 0;
+uint64_t	x86_64_orig_ax = 0;
+uint64_t	x86_64_ip = 0;
+uint64_t	x86_64_cs = 0;
+uint64_t	x86_64_flags = 0;
+uint64_t	x86_64_sp = 0;
+uint64_t	x86_64_ss = 0;
+
+int
+parse_line_x86_64 (char *line)
+{
+	GETU64 (x86_64_r15, "r15=");
+	GETU64 (x86_64_r14, "r14=");
+	GETU64 (x86_64_r13, "r13=");
+	GETU64 (x86_64_r12, "r12=");
+	GETU64 (x86_64_bp, "bp=");
+	GETU64 (x86_64_bx, "bx=");
+	GETU64 (x86_64_r11, "r11=");
+	GETU64 (x86_64_r10, "r10=");
+	GETU64 (x86_64_r9, "r9=");
+	GETU64 (x86_64_r8, "r8=");
+	GETU64 (x86_64_ax, "ax=");
+	GETU64 (x86_64_cx, "cx=");
+	GETU64 (x86_64_dx, "dx=");
+	GETU64 (x86_64_si, "si=");
+	GETU64 (x86_64_di, "di=");
+	GETU64 (x86_64_orig_ax, "orig_ax=");
+	GETU64 (x86_64_ip, "ip=");
+	GETU64 (x86_64_cs, "cs=");
+	GETU64 (x86_64_flags, "flags=");
+	GETU64 (x86_64_sp, "sp=");
+	GETU64 (x86_64_ss, "ss=");
+
+	return 0;
+}
+
+/* arm */
+
+uint32_t	arm_r0 = 0;
+uint32_t	arm_r1 = 0;
+uint32_t	arm_r2 = 0;
+uint32_t	arm_r3 = 0;
+uint32_t	arm_r4 = 0;
+uint32_t	arm_r5 = 0;
+uint32_t	arm_r6 = 0;
+uint32_t	arm_r7 = 0;
+uint32_t	arm_r8 = 0;
+uint32_t	arm_r9 = 0;
+uint32_t	arm_r10 = 0;
+uint32_t	arm_fp = 0;
+uint32_t	arm_ip = 0;
+uint32_t	arm_sp = 0;
+uint32_t	arm_lr = 0;
+uint32_t	arm_pc = 0;
+uint32_t	arm_cpsr = 0;
+uint32_t	arm_ORIG_r0 = 0;
+
+int
+parse_line_arm (char *line)
+{
+	GETU32 (arm_r0, "r0=");
+	GETU32 (arm_r1, "r1=");
+	GETU32 (arm_r2, "r2=");
+	GETU32 (arm_r3, "r3=");
+	GETU32 (arm_r4, "r4=");
+	GETU32 (arm_r5, "r5=");
+	GETU32 (arm_r6, "r6=");
+	GETU32 (arm_r7, "r7=");
+	GETU32 (arm_r8, "r8=");
+	GETU32 (arm_r9, "r9=");
+	GETU32 (arm_r10, "r10=");
+	GETU32 (arm_fp, "fp=");
+	GETU32 (arm_ip, "ip=");
+	GETU32 (arm_sp, "sp=");
+	GETU32 (arm_lr, "lr=");
+	GETU32 (arm_pc, "pc=");
+	GETU32 (arm_cpsr, "cpsr=");
+	GETU32 (arm_ORIG_r0, "ORIG_r0=");
+
+	return 0;
+}
+
+/* mips */
+
+uint32_t	mips32_r[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0};
+uint32_t	mips32_hi = 0;
+uint32_t	mips32_lo = 0;
+uint32_t	mips32_cp0_epc = 0;
+uint32_t	mips32_cp0_badvaddr = 0;
+uint32_t	mips32_cp0_status = 0;
+uint32_t	mips32_cp0_cause = 0;
+
+
+uint64_t	mips64_r[32] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+				0, 0};
+uint64_t	mips64_hi = 0;
+uint64_t	mips64_lo = 0;
+uint64_t	mips64_cp0_epc = 0;
+uint64_t	mips64_cp0_badvaddr = 0;
+uint64_t	mips64_cp0_status = 0;
+uint64_t	mips64_cp0_cause = 0;
+
+int
+parse_line_mips (char *line)
+{
+	int	i;
+	char	str[10];
+
+	if (elf_class == S2C_ELFCLASS32) {
+		for (i = 0; i < 32; i++) {
+			snprintf (str, 10, "r%d=", i);
+			GETU32 (mips32_r[i], str);
+		}
+		GETU32 (mips32_cp0_status, "cp0_status=");
+		GETU32 (mips32_hi, "hi=");
+		GETU32 (mips32_lo, "lo=");
+		GETU32 (mips32_cp0_badvaddr, "cp0_badvaddr=");
+		GETU32 (mips32_cp0_cause, "cp0_cause=");
+		GETU32 (mips32_cp0_epc, "cp0_epc=");
+	}
+	else {
+		for (i = 0; i < 32; i++) {
+			snprintf (str, 10, "r%d=", i);
+			GETU64 (mips64_r[i], str);
+		}
+		GETU64 (mips64_cp0_status, "cp0_status=");
+		GETU64 (mips64_hi, "hi=");
+		GETU64 (mips64_lo, "lo=");
+		GETU64 (mips64_cp0_badvaddr, "cp0_badvaddr=");
+		GETU64 (mips64_cp0_cause, "cp0_cause=");
+		GETU64 (mips64_cp0_epc, "cp0_epc=");
+	}
+
+	return 0;
+}
+
+int
+parse_line (char *line)
+{
+	GETU32 (elf_class, "elf_class=");
+	GETU32 (elf_data, "elf_data=");
+	GETU32 (elf_arch, "elf_arch=");
+	GETU32 (elf_osabi, "elf_osabi=");
+
+	if (strncmp (line, "stack=", sizeof ("stack=") - 1) == 0) {
+		line += sizeof ("stack=") - 1;
+
+		while (stack_len < S2C_THREAD_SIZE && line[0]) {
+			if (isdigit (line[0]))
+				stack[stack_len++] = strtoul (line, &line, 0);
+			else
+				line++;
+		}
+		return 0;
+	}
+
+	if (strncmp (line, "commandline=", sizeof ("commandline=") - 1) == 0) {
+		snprintf ((char *)commandline, S2C_ELF_PRARGSZ, "%s",
+			  line + sizeof ("commandline=") - 1);
+		return 0;
+	}
+
+	switch (elf_arch) {
+		case S2C_EM_386:
+			return parse_line_i386 (line);
+			break;
+		case S2C_EM_X86_64:
+			return parse_line_x86_64 (line);
+			break;
+		case S2C_EM_ARM:
+			return parse_line_arm (line);
+			break;
+		case S2C_EM_MIPS:
+			return parse_line_mips (line);
+			break;
+	}
+
+	return 0;
+}
+
+void
+iterate_over_lines (FILE *fp)
+{
+	char	line[256], *linep;
+
+	if (!fp) {
+		fprintf(stderr, "Parse input error.\n");
+		exit (-1);
+	}
+
+	while(fgets(line, 256, fp) != NULL) {
+		linep = line;
+                linep = strstr (linep, S2CMARK);
+		if (linep) {
+			linep += sizeof (S2CMARK) - 1;
+			if (parse_line (linep)) {
+				fprintf(stderr, "Failied with parse line %s\n", line);
+				exit (-1);
+			}
+		}
+	}
+	if (ferror (fp)) {
+		fprintf(stderr, "Parse input error.\n");
+		exit (-1);
+	}
+}
+
+/* Convert and save to core_buf.  */
+
+uint8_t	core_buf[81920];
+int	core_buf_size = 0;
+
+#define S2C_EI_NIDENT	16
+
+typedef struct s2c_elf32_hdr_s {
+	uint8_t		e_ident[S2C_EI_NIDENT];
+	uint16_t	e_type;
+	uint16_t	e_machine;
+	uint32_t	e_version;
+	uint32_t	e_entry;
+	uint32_t	e_phoff;
+	uint32_t	e_shoff;
+	uint32_t	e_flags;
+	uint16_t	e_ehsize;
+	uint16_t	e_phentsize;
+	uint16_t	e_phnum;
+	uint16_t	e_shentsize;
+	uint16_t	e_shnum;
+	uint16_t	e_shstrndx;
+} s2c_elf32_hdr_t;
+
+typedef struct s2c_elf64_hdr_s {
+	uint8_t		e_ident[S2C_EI_NIDENT];
+	uint16_t	e_type;
+	uint16_t	e_machine;
+	uint32_t	e_version;
+	uint64_t	e_entry;
+	uint64_t	e_phoff;
+	uint64_t	e_shoff;
+	uint32_t	e_flags;
+	uint16_t	e_ehsize;
+	uint16_t	e_phentsize;
+	uint16_t	e_phnum;
+	uint16_t	e_shentsize;
+	uint16_t	e_shnum;
+	uint16_t	e_shstrndx;
+} s2c_elf64_hdr_t;
+
+#define	S2C_ELFMAG	"\177ELF"
+#define S2C_SELFMAG	4
+#define S2C_EI_CLASS	4
+#define S2C_EI_DATA	5
+#define	S2C_EI_VERSION	6
+#define S2C_EV_CURRENT	1
+#define	S2C_EI_OSABI	7
+#define S2C_ET_CORE	4
+
+typedef struct s2c_elf32_phdr_s {
+	uint32_t	p_type;
+	uint32_t	p_offset;
+	uint32_t	p_vaddr;
+	uint32_t	p_paddr;
+	uint32_t	p_filesz;
+	uint32_t	p_memsz;
+	uint32_t	p_flags;
+	uint32_t	p_align;
+} s2c_elf32_phdr_t;
+
+typedef struct s2c_elf64_phdr_s {
+	uint32_t	p_type;
+	uint32_t	p_flags;
+	uint64_t	p_offset;
+	uint64_t	p_vaddr;
+	uint64_t	p_paddr;
+	uint64_t	p_filesz;
+	uint64_t	p_memsz;
+	uint64_t	p_align;
+} s2c_elf64_phdr_t;
+
+#define S2C_PT_NOTE	4
+#define S2C_PT_LOAD	1
+#define S2C_PF_R		0x4
+
+uint8_t	*nhdr;
+uint8_t	*phdr;
+
+void
+elfhdr_32 (void)
+{
+	s2c_elf32_hdr_t	*elf;
+	s2c_elf32_phdr_t	*nhdrp;
+	s2c_elf32_phdr_t	*phdrp;
+
+	elf = (s2c_elf32_hdr_t *)(core_buf + core_buf_size);
+	core_buf_size += sizeof (s2c_elf32_hdr_t);
+	memset(elf, 0, sizeof(*elf));
+	memcpy(elf->e_ident, S2C_ELFMAG, S2C_SELFMAG);
+	elf->e_ident[S2C_EI_CLASS] = elf_class;
+	elf->e_ident[S2C_EI_DATA] = elf_data;
+	elf->e_ident[S2C_EI_VERSION] = S2C_EV_CURRENT;
+	elf->e_ident[S2C_EI_OSABI] = elf_osabi;
+	elf->e_type = SWAP16 (S2C_ET_CORE);
+	elf->e_machine = SWAP16 (elf_arch);
+	elf->e_version = SWAP32 (S2C_EV_CURRENT);
+	elf->e_phoff = SWAP32 (sizeof (s2c_elf32_hdr_t));
+	elf->e_flags = 0;
+	elf->e_ehsize = SWAP16 (sizeof (s2c_elf32_hdr_t));
+	elf->e_phentsize = SWAP16 (sizeof (s2c_elf32_phdr_t));
+	/* segs including notes section (vma + 1) */
+	elf->e_phnum = SWAP16 (1 + 1);
+
+	nhdr = core_buf + core_buf_size;
+	core_buf_size += sizeof (s2c_elf32_phdr_t);
+	nhdrp = (s2c_elf32_phdr_t *) nhdr;
+	nhdrp->p_type = SWAP32 (S2C_PT_NOTE);
+	nhdrp->p_offset = sizeof(s2c_elf32_hdr_t) + sizeof(s2c_elf32_phdr_t) * 2;
+	nhdrp->p_vaddr = 0;
+	nhdrp->p_paddr = 0;
+	nhdrp->p_filesz = 0;
+	nhdrp->p_memsz = 0;
+	nhdrp->p_flags = 0;
+	nhdrp->p_align = 0;
+
+	phdr = core_buf + core_buf_size;
+	core_buf_size += sizeof (s2c_elf32_phdr_t);
+	phdrp = (s2c_elf32_phdr_t *) phdr;
+	phdrp->p_type = SWAP32 (S2C_PT_LOAD);
+	phdrp->p_flags = SWAP32 (S2C_PF_R);
+	phdrp->p_offset = nhdrp->p_offset;
+	phdrp->p_vaddr = sp_32 & ~63;
+	phdrp->p_paddr = 0;
+	phdrp->p_filesz = phdrp->p_memsz = stack_len + (sp_32 - phdrp->p_vaddr);
+	phdrp->p_align = SWAP32 (1);
+}
+
+void
+elfhdr_64 (void)
+{
+	s2c_elf64_hdr_t	*elf;
+	s2c_elf64_phdr_t	*nhdrp;
+	s2c_elf64_phdr_t	*phdrp;
+
+	elf = (s2c_elf64_hdr_t *)(core_buf + core_buf_size);
+	core_buf_size += sizeof (s2c_elf64_hdr_t);
+	memset(elf, 0, sizeof(*elf));
+	memcpy(elf->e_ident, S2C_ELFMAG, S2C_SELFMAG);
+	elf->e_ident[S2C_EI_CLASS] = elf_class;
+	elf->e_ident[S2C_EI_DATA] = elf_data;
+	elf->e_ident[S2C_EI_VERSION] = S2C_EV_CURRENT;
+	elf->e_ident[S2C_EI_OSABI] = elf_osabi;
+	elf->e_type = SWAP16 (S2C_ET_CORE);
+	elf->e_machine = SWAP16 (elf_arch);
+	elf->e_version = SWAP32 (S2C_EV_CURRENT);
+	elf->e_phoff = SWAP64 (sizeof (s2c_elf64_hdr_t));
+	elf->e_flags = 0;
+	elf->e_ehsize = SWAP16 (sizeof (s2c_elf64_hdr_t));
+	elf->e_phentsize = SWAP16 (sizeof (s2c_elf64_phdr_t));
+	/* segs including notes section (vma + 1) */
+	elf->e_phnum = SWAP16 (1 + 1);
+
+	nhdr = core_buf + core_buf_size;
+	core_buf_size += sizeof (s2c_elf64_phdr_t);
+	nhdrp = (s2c_elf64_phdr_t *) nhdr;
+	nhdrp->p_type = SWAP32 (S2C_PT_NOTE);
+	nhdrp->p_offset = sizeof(s2c_elf64_hdr_t) + sizeof(s2c_elf64_phdr_t) * 2;
+	nhdrp->p_vaddr = 0;
+	nhdrp->p_paddr = 0;
+	nhdrp->p_filesz = 0;
+	nhdrp->p_memsz = 0;
+	nhdrp->p_flags = 0;
+	nhdrp->p_align = 0;
+
+	phdr = core_buf + core_buf_size;
+	core_buf_size += sizeof (s2c_elf64_phdr_t);
+	phdrp = (s2c_elf64_phdr_t *) phdr;
+	phdrp->p_type = SWAP32 (S2C_PT_LOAD);
+	phdrp->p_flags = SWAP32 (S2C_PF_R);
+	phdrp->p_offset = nhdrp->p_offset;
+	phdrp->p_vaddr = sp_64 & ~63;
+	phdrp->p_paddr = 0;
+	phdrp->p_filesz = phdrp->p_memsz = stack_len + (sp_64 - phdrp->p_vaddr);
+	phdrp->p_align = 1;
+}
+
+typedef struct elf_note_s {
+	uint32_t	n_namesz;
+	uint32_t	n_descsz;
+	uint32_t	n_type;
+} elf_note_t;
+
+#define roundup(x, y) ((((x) + ((y) - 1)) / (y)) * (y))
+
+int
+fill_elf_note (uint8_t *p, const char *name,
+		int type, void **data, int data_len)
+{
+	int		ret = 0;
+	elf_note_t	*en = (elf_note_t *) p;
+
+	p += sizeof(elf_note_t);
+	ret += sizeof(elf_note_t);
+	en->n_namesz = strlen(name) + 1;
+	en->n_type = SWAP32 (type);
+	en->n_descsz = SWAP32 (data_len);
+
+	memcpy (p, name, en->n_namesz);
+	p += en->n_namesz;
+	p = (uint8_t *) roundup((unsigned long) p, 4);
+	ret += roundup((en->n_namesz), 4);
+
+	*data = p;
+	p += data_len;
+	p = (uint8_t *) roundup((unsigned long) p, 4);
+	ret += roundup(data_len, 4);
+
+	en->n_namesz = SWAP32 (en->n_namesz);
+
+	return ret;
+}
+
+#define S2C_NT_PRSTATUS	1
+
+struct s2c_elf_siginfo
+{
+	uint32_t	si_signo;
+	uint32_t	si_code;
+	uint32_t	si_errno;
+};
+
+struct s2c_timeval_32 {
+	uint32_t	tv_sec;
+	uint32_t	tv_usec;
+};
+
+struct s2c_timeval_64 {
+	uint64_t	tv_sec;
+	uint64_t	tv_usec;
+};
+
+/* i386 */
+
+struct i386_elf_prstatus
+{
+	struct s2c_elf_siginfo	pr_info;
+	uint16_t		pr_cursig;
+	uint32_t		pr_sigpend;
+	uint32_t		pr_sighold;
+	uint32_t		pr_pid;
+	uint32_t		pr_ppid;
+	uint32_t		pr_pgrp;
+	uint32_t		pr_sid;
+	struct s2c_timeval_32	pr_utime;
+	struct s2c_timeval_32	pr_stime;
+	struct s2c_timeval_32	pr_cutime;
+	struct s2c_timeval_32	pr_cstime;
+
+	uint32_t		pr_reg[17];
+
+	uint32_t		pr_fpvalid;
+} __attribute__ ((aligned(4)));
+
+void
+i386_elf_prstatus (void)
+{
+	int				offset;
+	struct i386_elf_prstatus	*pstat;
+
+	offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+				S2C_NT_PRSTATUS,
+				((void **)&pstat),
+				sizeof(struct i386_elf_prstatus));
+	core_buf_size += offset;
+	((s2c_elf32_phdr_t *) nhdr)->p_filesz += offset;
+	memset (pstat, 0, sizeof(struct i386_elf_prstatus));
+	pstat->pr_reg[0] = SWAP32 (i386_bx);
+	pstat->pr_reg[1] = SWAP32 (i386_cx);
+	pstat->pr_reg[2] = SWAP32 (i386_dx);
+	pstat->pr_reg[3] = SWAP32 (i386_si);
+	pstat->pr_reg[4] = SWAP32 (i386_di);
+	pstat->pr_reg[5] = SWAP32 (i386_bp);
+	pstat->pr_reg[6] = SWAP32 (i386_ax);
+	pstat->pr_reg[7] = SWAP32 (i386_ds);
+	pstat->pr_reg[8] = SWAP32 (i386_es);
+	pstat->pr_reg[9] = SWAP32 (i386_fs);
+	pstat->pr_reg[10] = SWAP32 (i386_gs);
+	pstat->pr_reg[11] = SWAP32 (i386_orig_ax);
+	pstat->pr_reg[12] = SWAP32 (i386_ip);
+	pstat->pr_reg[13] = SWAP32 (i386_cs);
+	pstat->pr_reg[14] = SWAP32 (i386_flags);
+	pstat->pr_reg[15] = SWAP32 (i386_sp);
+	pstat->pr_reg[16] = SWAP32 (i386_ss);
+}
+
+/* x86_64 */
+
+struct x86_64_elf_prstatus
+{
+	struct s2c_elf_siginfo	pr_info;
+	uint16_t		pr_cursig;
+	uint64_t		pr_sigpend;
+	uint64_t		pr_sighold;
+	uint32_t		pr_pid;
+	uint32_t		pr_ppid;
+	uint32_t		pr_pgrp;
+	uint32_t		pr_sid;
+	struct s2c_timeval_64	pr_utime;
+	struct s2c_timeval_64	pr_stime;
+	struct s2c_timeval_64	pr_cutime;
+	struct s2c_timeval_64	pr_cstime;
+
+	uint64_t		pr_reg[27];
+
+	uint32_t		pr_fpvalid;
+} __attribute__ ((aligned(8)));
+
+void
+x86_64_elf_prstatus (void)
+{
+	int				offset;
+	struct x86_64_elf_prstatus	*pstat;
+
+	offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+				S2C_NT_PRSTATUS,
+				((void **)&pstat),
+				sizeof(struct x86_64_elf_prstatus));
+	core_buf_size += offset;
+	((s2c_elf64_phdr_t *) nhdr)->p_filesz += offset;
+	memset (pstat, 0, sizeof(struct x86_64_elf_prstatus));
+	pstat->pr_reg[0] = SWAP64 (x86_64_r15);
+	pstat->pr_reg[1] = SWAP64 (x86_64_r14);
+	pstat->pr_reg[2] = SWAP64 (x86_64_r13);
+	pstat->pr_reg[3] = SWAP64 (x86_64_r12);
+	pstat->pr_reg[4] = SWAP64 (x86_64_bp);
+	pstat->pr_reg[5] = SWAP64 (x86_64_bx);
+	pstat->pr_reg[6] = SWAP64 (x86_64_r11);
+	pstat->pr_reg[7] = SWAP64 (x86_64_r10);
+	pstat->pr_reg[8] = SWAP64 (x86_64_r9);
+	pstat->pr_reg[9] = SWAP64 (x86_64_r8);
+	pstat->pr_reg[10] = SWAP64 (x86_64_ax);
+	pstat->pr_reg[11] = SWAP64 (x86_64_cx);
+	pstat->pr_reg[12] = SWAP64 (x86_64_dx);
+	pstat->pr_reg[13] = SWAP64 (x86_64_si);
+	pstat->pr_reg[14] = SWAP64 (x86_64_di);
+	pstat->pr_reg[15] = SWAP64 (x86_64_orig_ax);
+	pstat->pr_reg[16] = SWAP64 (x86_64_ip);
+	pstat->pr_reg[17] = SWAP64 (x86_64_cs);
+	pstat->pr_reg[18] = SWAP64 (x86_64_flags);
+	pstat->pr_reg[19] = SWAP64 (x86_64_sp);
+ 	pstat->pr_reg[20] = SWAP64 (x86_64_ss);
+}
+
+/* arm */
+
+struct arm_elf_prstatus
+{
+	struct s2c_elf_siginfo	pr_info;
+	uint16_t		pr_cursig;
+	uint32_t		pr_sigpend;
+	uint32_t		pr_sighold;
+	uint32_t		pr_pid;
+	uint32_t		pr_ppid;
+	uint32_t		pr_pgrp;
+	uint32_t		pr_sid;
+	struct s2c_timeval_32	pr_utime;
+	struct s2c_timeval_32	pr_stime;
+	struct s2c_timeval_32	pr_cutime;
+	struct s2c_timeval_32	pr_cstime;
+
+	uint32_t		pr_reg[18];
+
+	uint32_t		pr_fpvalid;
+} __attribute__ ((aligned(4)));
+
+void
+arm_elf_prstatus (void)
+{
+	int				offset;
+	struct arm_elf_prstatus		*pstat;
+
+	offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+				S2C_NT_PRSTATUS,
+				((void **)&pstat),
+				sizeof(struct arm_elf_prstatus));
+	core_buf_size += offset;
+	((s2c_elf32_phdr_t *) nhdr)->p_filesz += offset;
+	memset (pstat, 0, sizeof(struct arm_elf_prstatus));
+	pstat->pr_reg[0] = SWAP32 (arm_r0);
+	pstat->pr_reg[1] = SWAP32 (arm_r1);
+	pstat->pr_reg[2] = SWAP32 (arm_r2);
+	pstat->pr_reg[3] = SWAP32 (arm_r3);
+	pstat->pr_reg[4] = SWAP32 (arm_r4);
+	pstat->pr_reg[5] = SWAP32 (arm_r5);
+	pstat->pr_reg[6] = SWAP32 (arm_r6);
+	pstat->pr_reg[7] = SWAP32 (arm_r7);
+	pstat->pr_reg[8] = SWAP32 (arm_r8);
+	pstat->pr_reg[9] = SWAP32 (arm_r9);
+	pstat->pr_reg[10] = SWAP32 (arm_r10);
+	pstat->pr_reg[11] = SWAP32 (arm_fp);
+	pstat->pr_reg[12] = SWAP32 (arm_ip);
+	pstat->pr_reg[13] = SWAP32 (arm_sp);
+	pstat->pr_reg[14] = SWAP32 (arm_lr);
+	pstat->pr_reg[15] = SWAP32 (arm_pc);
+	pstat->pr_reg[16] = SWAP32 (arm_cpsr);
+	pstat->pr_reg[17] = SWAP32 (arm_ORIG_r0);
+}
+
+/* mips */
+
+struct mips32_elf_prstatus
+{
+	struct s2c_elf_siginfo	pr_info;
+	uint16_t		pr_cursig;
+	uint32_t		pr_sigpend;
+	uint32_t		pr_sighold;
+	uint32_t		pr_pid;
+	uint32_t		pr_ppid;
+	uint32_t		pr_pgrp;
+	uint32_t		pr_sid;
+	struct s2c_timeval_32	pr_utime;
+	struct s2c_timeval_32	pr_stime;
+	struct s2c_timeval_32	pr_cutime;
+	struct s2c_timeval_32	pr_cstime;
+
+	uint32_t		pr_reg[45];
+
+	uint32_t		pr_fpvalid;
+} __attribute__ ((aligned(4)));
+
+struct mips64_elf_prstatus
+{
+	struct s2c_elf_siginfo	pr_info;
+	uint16_t		pr_cursig;
+	uint64_t		pr_sigpend;
+	uint64_t		pr_sighold;
+	uint32_t		pr_pid;
+	uint32_t		pr_ppid;
+	uint32_t		pr_pgrp;
+	uint32_t		pr_sid;
+	struct s2c_timeval_64	pr_utime;
+	struct s2c_timeval_64	pr_stime;
+	struct s2c_timeval_64	pr_cutime;
+	struct s2c_timeval_64	pr_cstime;
+
+	uint64_t		pr_reg[45];
+
+	uint32_t		pr_fpvalid;
+} __attribute__ ((aligned(8)));
+
+#define MIPS32_EF_R0		6
+#define MIPS32_EF_LO		38
+#define MIPS32_EF_HI		39
+#define MIPS32_EF_CP0_EPC	40
+#define MIPS32_EF_CP0_BADVADDR	41
+#define MIPS32_EF_CP0_STATUS	42
+#define MIPS32_EF_CP0_CAUSE	43
+
+#define MIPS64_EF_R0		0
+#define MIPS64_EF_LO		32
+#define MIPS64_EF_HI		33
+#define MIPS64_EF_CP0_EPC	34
+#define MIPS64_EF_CP0_BADVADDR	35
+#define MIPS64_EF_CP0_STATUS	36
+#define MIPS64_EF_CP0_CAUSE	37
+
+void
+mips_elf_prstatus (void)
+{
+	int	offset;
+
+	if (elf_class == S2C_ELFCLASS32) {
+		struct mips32_elf_prstatus	*pstat;
+
+		offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+					S2C_NT_PRSTATUS,
+					((void **)&pstat),
+					sizeof(struct mips32_elf_prstatus));
+		core_buf_size += offset;
+		((s2c_elf32_phdr_t *) nhdr)->p_filesz += offset;
+		memset (pstat, 0, sizeof(struct mips32_elf_prstatus));
+
+		for (offset = 0; offset < 32; offset ++)
+			pstat->pr_reg[MIPS32_EF_R0 + offset] = SWAP32 (mips32_r[offset]);
+		pstat->pr_reg[MIPS32_EF_LO] = SWAP32 (mips32_lo);
+		pstat->pr_reg[MIPS32_EF_HI] = SWAP32 (mips32_hi);
+		pstat->pr_reg[MIPS32_EF_CP0_EPC] = SWAP32 (mips32_cp0_epc);
+		pstat->pr_reg[MIPS32_EF_CP0_BADVADDR] = SWAP32 (mips32_cp0_badvaddr);
+		pstat->pr_reg[MIPS32_EF_CP0_STATUS] = SWAP32 (mips32_cp0_status);
+		pstat->pr_reg[MIPS32_EF_CP0_CAUSE] = SWAP32 (mips32_cp0_cause);
+
+	}
+	else {
+		struct mips64_elf_prstatus	*pstat;
+
+		offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+					S2C_NT_PRSTATUS,
+					((void **)&pstat),
+					sizeof(struct mips64_elf_prstatus));
+		core_buf_size += offset;
+		((s2c_elf64_phdr_t *) nhdr)->p_filesz += offset;
+		memset (pstat, 0, sizeof(struct mips64_elf_prstatus));
+
+		for (offset = 0; offset < 32; offset ++)
+			pstat->pr_reg[MIPS64_EF_R0 + offset] = SWAP64 (mips64_r[offset]);
+		pstat->pr_reg[MIPS64_EF_LO] = SWAP64 (mips64_lo);
+		pstat->pr_reg[MIPS64_EF_HI] = SWAP64 (mips64_hi);
+		pstat->pr_reg[MIPS64_EF_CP0_EPC] = SWAP64 (mips64_cp0_epc);
+		pstat->pr_reg[MIPS64_EF_CP0_BADVADDR] = SWAP64 (mips64_cp0_badvaddr);
+		pstat->pr_reg[MIPS64_EF_CP0_STATUS] = SWAP64 (mips64_cp0_status);
+		pstat->pr_reg[MIPS64_EF_CP0_CAUSE] = SWAP64 (mips64_cp0_cause);
+	}
+}
+
+struct s2c_elf_prpsinfo_32
+{
+	uint8_t		pr_state;
+	uint8_t		pr_sname;
+	uint8_t		pr_zomb;
+	uint8_t		pr_nice;
+	uint32_t	pr_flag;
+	uint16_t	pr_uid;
+	uint16_t	pr_gid;
+	uint32_t	pr_pid, pr_ppid, pr_pgrp, pr_sid;
+	uint8_t		pr_fname[16];
+	uint8_t		pr_psargs[S2C_ELF_PRARGSZ];
+};
+
+struct s2c_elf_prpsinfo_64
+{
+	uint8_t		pr_state;
+	uint8_t		pr_sname;
+	uint8_t		pr_zomb;
+	uint8_t		pr_nice;
+	uint64_t	pr_flag;
+	uint32_t	pr_uid;
+	uint32_t	pr_gid;
+	uint32_t	pr_pid, pr_ppid, pr_pgrp, pr_sid;
+	uint8_t		pr_fname[16];
+	uint8_t		pr_psargs[S2C_ELF_PRARGSZ];
+};
+
+#define S2C_NT_PRPSINFO	3
+
+void
+save_pinfo_32 (void)
+{
+	int				offset;
+	struct s2c_elf_prpsinfo_32	*pinfo;
+
+	offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+				S2C_NT_PRPSINFO,
+				((void **)&pinfo),
+				sizeof(struct s2c_elf_prpsinfo_32));
+	core_buf_size += offset;
+	memset (pinfo, 0, sizeof(struct s2c_elf_prpsinfo_32));
+	pinfo->pr_state = 0;
+	pinfo->pr_sname = 'R';
+	pinfo->pr_zomb = 0;
+	strcpy((char *)pinfo->pr_fname, "vmlinux");
+	snprintf((char *)pinfo->pr_psargs, S2C_ELF_PRARGSZ, "%s", commandline);
+	((s2c_elf32_phdr_t *) nhdr)->p_filesz += offset;
+}
+
+void
+save_pinfo_64 (void)
+{
+	int				offset;
+	struct s2c_elf_prpsinfo_64	*pinfo;
+
+	offset = fill_elf_note (core_buf + core_buf_size, "CORE",
+				S2C_NT_PRPSINFO,
+				((void **)&pinfo),
+				sizeof(struct s2c_elf_prpsinfo_64));
+	core_buf_size += offset;
+	memset (pinfo, 0, sizeof(struct s2c_elf_prpsinfo_64));
+	pinfo->pr_state = 0;
+	pinfo->pr_sname = 'R';
+	pinfo->pr_zomb = 0;
+	strcpy((char *)pinfo->pr_fname, "vmlinux");
+	snprintf((char *)pinfo->pr_psargs, S2C_ELF_PRARGSZ, "%s", commandline);
+	((s2c_elf64_phdr_t *) nhdr)->p_filesz += offset;
+}
+
+void
+stack_32 (void)
+{
+	((s2c_elf32_phdr_t *) phdr)->p_offset += ((s2c_elf32_phdr_t *)
nhdr)->p_filesz;
+	memset (core_buf + core_buf_size, 0, (sp_32 - ((s2c_elf32_phdr_t *)
phdr)->p_vaddr));
+	core_buf_size += sp_32 - ((s2c_elf32_phdr_t *) phdr)->p_vaddr;
+	memcpy (core_buf + core_buf_size, stack, stack_len);
+	core_buf_size += stack_len;
+
+	if (NEEDSWAP) {
+		((s2c_elf32_phdr_t *) nhdr)->p_offset = bswap_32(((s2c_elf32_phdr_t
*) nhdr)->p_offset);
+		((s2c_elf32_phdr_t *) nhdr)->p_filesz = bswap_32(((s2c_elf32_phdr_t
*) nhdr)->p_filesz);
+		((s2c_elf32_phdr_t *) phdr)->p_offset = bswap_32(((s2c_elf32_phdr_t
*) phdr)->p_offset);
+		((s2c_elf32_phdr_t *) phdr)->p_vaddr = bswap_32(((s2c_elf32_phdr_t
*) phdr)->p_vaddr);
+		((s2c_elf32_phdr_t *) phdr)->p_filesz = bswap_32(((s2c_elf32_phdr_t
*) phdr)->p_filesz);
+		((s2c_elf32_phdr_t *) phdr)->p_memsz = bswap_32(((s2c_elf32_phdr_t
*) phdr)->p_memsz);
+	}
+}
+
+void
+stack_64 (void)
+{
+	((s2c_elf64_phdr_t *) phdr)->p_offset += ((s2c_elf64_phdr_t *)
nhdr)->p_filesz;
+	memset (core_buf + core_buf_size, 0, (sp_64 - ((s2c_elf64_phdr_t *)
phdr)->p_vaddr));
+	core_buf_size += sp_64 - ((s2c_elf64_phdr_t *) phdr)->p_vaddr;
+	memcpy (core_buf + core_buf_size, stack, stack_len);
+	core_buf_size += stack_len;
+
+	if (NEEDSWAP) {
+		((s2c_elf64_phdr_t *) nhdr)->p_offset = bswap_64(((s2c_elf64_phdr_t
*) nhdr)->p_offset);
+		((s2c_elf64_phdr_t *) nhdr)->p_filesz = bswap_64(((s2c_elf64_phdr_t
*) nhdr)->p_filesz);
+		((s2c_elf64_phdr_t *) phdr)->p_offset = bswap_64(((s2c_elf64_phdr_t
*) phdr)->p_offset);
+		((s2c_elf64_phdr_t *) phdr)->p_vaddr = bswap_64(((s2c_elf64_phdr_t
*) phdr)->p_vaddr);
+		((s2c_elf64_phdr_t *) phdr)->p_filesz = bswap_64(((s2c_elf64_phdr_t
*) phdr)->p_filesz);
+		((s2c_elf64_phdr_t *) phdr)->p_memsz = bswap_64(((s2c_elf64_phdr_t
*) phdr)->p_memsz);
+	}
+}
+
+int
+main(int argc,char *argv[],char *envp[])
+{
+	/* Parse and save the input.  */
+	iterate_over_lines (stdin);
+	/* Set sp.  */
+	switch (elf_arch) {
+		case S2C_EM_386:
+			sp_32 = i386_sp;
+			break;
+		case S2C_EM_X86_64:
+			sp_64 = x86_64_sp;
+			break;
+		case S2C_EM_ARM:
+			sp_32 = arm_sp;
+			break;
+		case S2C_EM_MIPS:
+			if (elf_class == S2C_ELFCLASS32)
+				sp_32 = mips32_r[29];
+			else
+				sp_64 = mips64_r[29];
+			break;
+	}
+
+	/* Convert and save to core_buf.  */
+	/* Elf header */
+	if (elf_class == S2C_ELFCLASS32)
+		elfhdr_32 ();
+	else
+		elfhdr_64 ();
+	/* note0 pstat */
+	switch (elf_arch) {
+		case S2C_EM_386:
+			i386_elf_prstatus ();
+			break;
+		case S2C_EM_X86_64:
+			x86_64_elf_prstatus ();
+			break;
+		case S2C_EM_ARM:
+			arm_elf_prstatus ();
+			break;
+		case S2C_EM_MIPS:
+			mips_elf_prstatus ();
+			break;
+	}
+	/* note1 pinfo */
+	if (elf_class == S2C_ELFCLASS32)
+		save_pinfo_32 ();
+	else
+		save_pinfo_64 ();
+
+	/* stack */
+	if (elf_class == S2C_ELFCLASS32)
+		stack_32 ();
+	else
+		stack_64 ();
+
+	if (write (STDOUT_FILENO, core_buf, core_buf_size) != core_buf_size) {
+		fprintf(stderr, "Output core error.\n");
+		exit (-1);
+	}
+
+	return 0;
+}

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Russell King - ARM Linux]

On Sun, Jan 03, 2010 at 11:05:05PM +0800, Hui Zhu wrote:
> Hello,
> 
> For, when the kernel die, the user will get some message like:
> PC is at kernel_init+0xd4/0x104
> LR is at _atomic_dec_and_lock+0x48/0x6c
> pc : [<c0008470>]    lr : [<c01911f8>]    psr: 60000013
> sp : c7823fd8  ip : c7823f48  fp : c7823ff4
> Stack: (0xc7823fd8 to 0xc7824000)
> 3fc0:                                                       00000000 00000001
> Backtrace:
> [<c000839c>] (kernel_init+0x0/0x104) from [<c0042660>] (do_exit+0x0/0x880)
> This backtrace have some wrong message sometime and cannot get any
> val. Of course, kdump can get more message.  But it need do some a lot
> of other config.

If you have frame pointers enabled, the backtrace is _never_ wrong.
It only goes wrong if you disable frame pointers, at which point the
unwind tables have to be used.

> When kernel die, show some message:
> S2C:elf_class=1
> S2C:elf_data=1
> S2C:elf_arch=40
> S2C:elf_osabi=0
> S2C:r0=0x00000000;
> S2C:r1=0xc7822000;
> S2C:r2=0xc7823f48;
> S2C:r3=0x00000003;
> S2C:r4=0x00000000;
> S2C:r5=0x00000000;
> S2C:r6=0x00000000;
> S2C:r7=0x00000000;
> S2C:r8=0x00000000;
> S2C:r9=0x00000000;
> S2C:r10=0x00000000;
> S2C:fp=0xc7823ff4;
> S2C:ip=0xc7823f48;
> S2C:sp=0xc7823fd8;
> S2C:lr=0xc01911f8;
> S2C:pc=0xc0008470;
> S2C:cpsr=0x60000013;
> S2C:ORIG_r0=0xffffffff;
> 
> S2C:stack=0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
> S2C:stack=0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
> S2C:stack=0x00, 0x00, 0x00, 0x00, 0xf8, 0x3f, 0x82, 0xc7,
> S2C:stack=0x60, 0x26, 0x04, 0xc0, 0xa8, 0x83, 0x00, 0xc0,
> S2C:stack=0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

Please don't invent yet another way of dumping stuff out of the kernel.
What we already have is sufficient for your needs - there's no reason
what so ever to change it to achieve your goals.  We already dump the
registers and the stack, which seems to be all that you require.

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

Thanks Russell,

This S2C: message just for program s2c.
s2c can convert it to a core file.  Then gdb can do a clear analyse
with this file.
Then you can get more message than current we can get.

For example:
(gdb) bt
#0  0xc0008470 in kernel_init (unused=<value optimized out>)
   at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/init/main.c:916
#1  0xc0042660 in sys_waitid (which=<value optimized out>, upid=<value
optimized out>, infop=0x0, options=0, ru=0x14)
   at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/kernel/exit.c:1798
Backtrace stopped: previous frame inner to this frame (corrupt stack?)

a more clear backtrace.

(gdb) frame 1
#1  0xc0042660 in sys_waitid (which=<value optimized out>, upid=<value
optimized out>, infop=0x0, options=0, ru=0x14)
   at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/kernel/exit.c:1798
1798                    pid = find_get_pid(upid);
(gdb) p pid
$1 = (struct pid *) 0x0

A value of a val in stack in the frame.


I think it will more helpful for user to deal with the kernel die.

Best regards,
Hui

On Mon, Jan 4, 2010 at 00:03, Russell King - ARM Linux
<linux@arm.linux.org.uk> wrote:
> On Sun, Jan 03, 2010 at 11:05:05PM +0800, Hui Zhu wrote:
>> Hello,
>>
>> For, when the kernel die, the user will get some message like:
>> PC is at kernel_init+0xd4/0x104
>> LR is at _atomic_dec_and_lock+0x48/0x6c
>> pc : [<c0008470>]    lr : [<c01911f8>]    psr: 60000013
>> sp : c7823fd8  ip : c7823f48  fp : c7823ff4
>> Stack: (0xc7823fd8 to 0xc7824000)
>> 3fc0:                                                       00000000 00000001
>> Backtrace:
>> [<c000839c>] (kernel_init+0x0/0x104) from [<c0042660>] (do_exit+0x0/0x880)
>> This backtrace have some wrong message sometime and cannot get any
>> val. Of course, kdump can get more message.  But it need do some a lot
>> of other config.
>
> If you have frame pointers enabled, the backtrace is _never_ wrong.
> It only goes wrong if you disable frame pointers, at which point the
> unwind tables have to be used.
>
>> When kernel die, show some message:
>> S2C:elf_class=1
>> S2C:elf_data=1
>> S2C:elf_arch=40
>> S2C:elf_osabi=0
>> S2C:r0=0x00000000;
>> S2C:r1=0xc7822000;
>> S2C:r2=0xc7823f48;
>> S2C:r3=0x00000003;
>> S2C:r4=0x00000000;
>> S2C:r5=0x00000000;
>> S2C:r6=0x00000000;
>> S2C:r7=0x00000000;
>> S2C:r8=0x00000000;
>> S2C:r9=0x00000000;
>> S2C:r10=0x00000000;
>> S2C:fp=0xc7823ff4;
>> S2C:ip=0xc7823f48;
>> S2C:sp=0xc7823fd8;
>> S2C:lr=0xc01911f8;
>> S2C:pc=0xc0008470;
>> S2C:cpsr=0x60000013;
>> S2C:ORIG_r0=0xffffffff;
>>
>> S2C:stack=0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
>> S2C:stack=0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>> S2C:stack=0x00, 0x00, 0x00, 0x00, 0xf8, 0x3f, 0x82, 0xc7,
>> S2C:stack=0x60, 0x26, 0x04, 0xc0, 0xa8, 0x83, 0x00, 0xc0,
>> S2C:stack=0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
>
> Please don't invent yet another way of dumping stuff out of the kernel.
> What we already have is sufficient for your needs - there's no reason
> what so ever to change it to achieve your goals.  We already dump the
> registers and the stack, which seems to be all that you require.
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Russell King - ARM Linux]

On Mon, Jan 04, 2010 at 12:30:20AM +0800, Hui Zhu wrote:
> This S2C: message just for program s2c.
> s2c can convert it to a core file.  Then gdb can do a clear analyse
> with this file.
> Then you can get more message than current we can get.

I understand that.  What I'm saying is that all the additional noise
you're causing the kernel to create is just a pure duplication of
what we already dump.

Oops dumps are already noisy enough - especially if they cause a panic
at the end (where you end up with two backtraces.)  We do not need even
more noise caused by needless duplication.

You can get everything you need already from the kernel.  On ARM, we
already dump out all the registers and the _full_ stack.  There is no
need for you to implement your own register dumping code and full stack
dump on top of that again.

So, I'm not going to accept your patch for the ARM kernel.  Please use
what's already provided - it's more than adequate.  By doing so, you
don't penalise those of us who want to read the raw oopses.

Talking about noisy oopses, I'm getting one with 2.6.33-rc2 on 'poweroff'
shutdown.  No idea what it is because most of it's scrolled off the top of
the screen and I can't scroll back.  Not bothered about it at the moment.
What it does illustrate though is why making things too noisy when problems
occur makes it _more_ difficult to find out what went wrong.

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

I didn't give the user raw oopses.
I give him core file. When the kernel die, do we can get a core file now?


(gdb) bt
#0  0xc0008470 in kernel_init (unused=<value optimized out>)
  at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/init/main.c:916
#1  0xc0042660 in sys_waitid (which=<value optimized out>, upid=<value
optimized out>, infop=0x0, options=0, ru=0x14)
  at /home/teawater/kernel/arm_versatile_926ejs.glibc_std.standard/build/linux/kernel/exit.c:1798
Backtrace stopped: previous frame inner to this frame (corrupt stack?)

It show which line make kernel die.

Hui




On Mon, Jan 4, 2010 at 00:44, Russell King - ARM Linux
<linux@arm.linux.org.uk> wrote:
> On Mon, Jan 04, 2010 at 12:30:20AM +0800, Hui Zhu wrote:
>> This S2C: message just for program s2c.
>> s2c can convert it to a core file.  Then gdb can do a clear analyse
>> with this file.
>> Then you can get more message than current we can get.
>
> I understand that.  What I'm saying is that all the additional noise
> you're causing the kernel to create is just a pure duplication of
> what we already dump.
>
> Oops dumps are already noisy enough - especially if they cause a panic
> at the end (where you end up with two backtraces.)  We do not need even
> more noise caused by needless duplication.
>
> You can get everything you need already from the kernel.  On ARM, we
> already dump out all the registers and the _full_ stack.  There is no
> need for you to implement your own register dumping code and full stack
> dump on top of that again.
>
> So, I'm not going to accept your patch for the ARM kernel.  Please use
> what's already provided - it's more than adequate.  By doing so, you
> don't penalise those of us who want to read the raw oopses.
>
> Talking about noisy oopses, I'm getting one with 2.6.33-rc2 on 'poweroff'
> shutdown.  No idea what it is because most of it's scrolled off the top of
> the screen and I can't scroll back.  Not bothered about it at the moment.
> What it does illustrate though is why making things too noisy when problems
> occur makes it _more_ difficult to find out what went wrong.
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Russell King - ARM Linux]

On Mon, Jan 04, 2010 at 12:55:04AM +0800, Hui Zhu wrote:
> I didn't give the user raw oopses.
> I give him core file. When the kernel die, do we can get a core file now?

I think there's a communication issue here... clearly you're not
understanding what I've been trying to tell you.

I don't think I can help you any further.

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

Sorry I make a mistake, I sent the mail before I complete it.  Maybe
some hotkey or something.

The s2c can get the message from the current panic message is better.
I am not get them for now, maybe it need open some options or
something.

Thanks,
Hui

On Mon, Jan 4, 2010 at 01:10, Russell King - ARM Linux
<linux@arm.linux.org.uk> wrote:
> On Mon, Jan 04, 2010 at 12:55:04AM +0800, Hui Zhu wrote:
>> I didn't give the user raw oopses.
>> I give him core file. When the kernel die, do we can get a core file now?
>
> I think there's a communication issue here... clearly you're not
> understanding what I've been trying to tell you.
>
> I don't think I can help you any further.
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

And gdb need a message that seems panic doesn't show:
LKM address message. like:
S2C:add-symbol-file e.ko 0xffffffffa0000000

Thanks,
Hui

On Mon, Jan 4, 2010 at 01:18, Hui Zhu <teawater@gmail.com> wrote:
> Sorry I make a mistake, I sent the mail before I complete it.  Maybe
> some hotkey or something.
>
> The s2c can get the message from the current panic message is better.
> I am not get them for now, maybe it need open some options or
> something.
>
> Thanks,
> Hui
>
> On Mon, Jan 4, 2010 at 01:10, Russell King - ARM Linux
> <linux@arm.linux.org.uk> wrote:
>> On Mon, Jan 04, 2010 at 12:55:04AM +0800, Hui Zhu wrote:
>>> I didn't give the user raw oopses.
>>> I give him core file. When the kernel die, do we can get a core file now?
>>
>> I think there's a communication issue here... clearly you're not
>> understanding what I've been trying to tell you.
>>
>> I don't think I can help you any further.
>>
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Arjan van de Ven]

On Mon, 4 Jan 2010 00:55:04 +0800
Hui Zhu <teawater@gmail.com> wrote:
> 
> It show which line make kernel die.
> 

similar to scripts/markup_oops.pl already does ?


-- 
Arjan van de Ven 	Intel Open Source Technology Centre
For development, discussion and tips for power savings, 
visit http://www.lesswatts.org

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

scripts/markup_oops.pl just support x86?
s2c support x86, x8664, arm, mips, mips64.

Thanks,
Hui

On Mon, Jan 4, 2010 at 01:26, Arjan van de Ven <arjan@infradead.org> wrote:
> On Mon, 4 Jan 2010 00:55:04 +0800
> Hui Zhu <teawater@gmail.com> wrote:
>>
>> It show which line make kernel die.
>>
>
> similar to scripts/markup_oops.pl already does ?
>
>
> --
> Arjan van de Ven        Intel Open Source Technology Centre
> For development, discussion and tips for power savings,
> visit http://www.lesswatts.org
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Russell King - ARM Linux]

On Mon, Jan 04, 2010 at 01:39:44AM +0800, Hui Zhu wrote:
> scripts/markup_oops.pl just support x86?
> s2c support x86, x8664, arm, mips, mips64.

I'm sure there's patches around to make it work on ARM, or if not,
there soon will be.  There's certainly patches around at the moment
to make scripts/decodecode work on ARM.

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Marek Vasut]

Dne Ne 3. ledna 2010 18:47:37 Russell King - ARM Linux napsal(a):
> On Mon, Jan 04, 2010 at 01:39:44AM +0800, Hui Zhu wrote:
> > scripts/markup_oops.pl just support x86?
> > s2c support x86, x8664, arm, mips, mips64.
> 
> I'm sure there's patches around to make it work on ARM, or if not,
> there soon will be.

And if there are not, that's the place you should focus yourself on rather than 
duplicating work ...

> There's certainly patches around at the moment
> to make scripts/decodecode work on ARM.
> 
> _______________________________________________
> linux-arm-kernel mailing list
> linux-arm-kernel@lists.infradead.org
> http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
> 

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Tejun Heo]

On 01/04/2010 12:05 AM, Hui Zhu wrote:
> Hello,
> 
> For, when the kernel die, the user will get some message like:
> PC is at kernel_init+0xd4/0x104
> LR is at _atomic_dec_and_lock+0x48/0x6c
> pc : [<c0008470>]    lr : [<c01911f8>]    psr: 60000013
> sp : c7823fd8  ip : c7823f48  fp : c7823ff4
> Stack: (0xc7823fd8 to 0xc7824000)
> 3fc0:                                                       00000000 00000001
> Backtrace:
> [<c000839c>] (kernel_init+0x0/0x104) from [<c0042660>] (do_exit+0x0/0x880)
> This backtrace have some wrong message sometime and cannot get any
> val. Of course, kdump can get more message.  But it need do some a lot
> of other config.
> 
> The stack2core function, can let kernel show stack message when kernel
> die.  This stack message can be convert to core file by program s2c
> (tools/s2c).  Then gdb can show the message in this core file.

FWIW, I love it.  I used to have to match the assembly to the source
code manually to find out which register and stack space meant what.
This will be very helpful in decoding oops message, but I think that
it would be far more useful if it uses the existing oops messages
instead of adding extra messages.  The new messages don't add any new
information and the oops message is already quite long and scrolls off
the screen on certain configurations.  Adding new configuration option
and making oops message longer will make acquiring the information
quite more difficult.

If implementing parsing of oops message in C is too awkward
(unsurprising at all), maybe implementing a converter in perl or
python is the easiest way so that it takes the oops message and puts
out well formatted input for the s2c program?

thanks.

-- 
tejun

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Arjan van de Ven]

On Mon, 04 Jan 2010 07:49:56 +0900
Tejun Heo <tj@kernel.org> wrote:
> 
> If implementing parsing of oops message in C is too awkward
> (unsurprising at all), maybe implementing a converter in perl or
> python is the easiest way so that it takes the oops message and puts
> out well formatted input for the s2c program?

you mean like scripts/markup_oops.pl ?



-- 
Arjan van de Ven 	Intel Open Source Technology Centre
For development, discussion and tips for power savings, 
visit http://www.lesswatts.org

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Tejun Heo]

On 01/04/2010 08:01 AM, Arjan van de Ven wrote:
> On Mon, 04 Jan 2010 07:49:56 +0900
> Tejun Heo <tj@kernel.org> wrote:
>>
>> If implementing parsing of oops message in C is too awkward
>> (unsurprising at all), maybe implementing a converter in perl or
>> python is the easiest way so that it takes the oops message and puts
>> out well formatted input for the s2c program?
> 
> you mean like scripts/markup_oops.pl ?

Whichever one works but s2c wouldn't require symbol decoding.  Maybe
we can simply add an option to tell it to just parse the oops and
output it in machine friendly format.  Oh, also, the patch does add
new information the module load addresses.  We should be able to add
those to the oops message in a compact form.

Thanks.

-- 
tejun

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Arjan van de Ven]

On Mon, 04 Jan 2010 08:07:45 +0900
Tejun Heo <tj@kernel.org> wrote:

> On 01/04/2010 08:01 AM, Arjan van de Ven wrote:
> > On Mon, 04 Jan 2010 07:49:56 +0900
> > Tejun Heo <tj@kernel.org> wrote:
> >>
> >> If implementing parsing of oops message in C is too awkward
> >> (unsurprising at all), maybe implementing a converter in perl or
> >> python is the easiest way so that it takes the oops message and
> >> puts out well formatted input for the s2c program?
> > 
> > you mean like scripts/markup_oops.pl ?
> 
> Whichever one works but s2c wouldn't require symbol decoding.  Maybe
> we can simply add an option to tell it to just parse the oops and
> output it in machine friendly format.  Oh, also, the patch does add
> new information the module load addresses.  We should be able to add
> those to the oops message in a compact form.

actually one does not need those; you know the start address of the
function already from the current oops output, and since you know the
address of the function within the module as well, you know the start
address of the module.


-- 
Arjan van de Ven 	Intel Open Source Technology Centre
For development, discussion and tips for power savings, 
visit http://www.lesswatts.org

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Tejun Heo]

On 01/04/2010 08:14 AM, Arjan van de Ven wrote:
>> Whichever one works but s2c wouldn't require symbol decoding.  Maybe
>> we can simply add an option to tell it to just parse the oops and
>> output it in machine friendly format.  Oh, also, the patch does add
>> new information the module load addresses.  We should be able to add
>> those to the oops message in a compact form.
> 
> actually one does not need those; you know the start address of the
> function already from the current oops output, and since you know the
> address of the function within the module as well, you know the start
> address of the module.

Right.  Thanks for the explanation.

-- 
tejun

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

Thanks for your mail.

I am not sure s2c is not a duplicating work with with others or not.

The main work of it is give user a coredump when kernel die like a
user level program die.
The user can very easy use it with gdb.
Now, it support x86/x8664/mips/arm.  It's very easy to extend.  To
support a new arch is not a very hard work. (I use half a day make it
support mips and mips64 include the test work.)

And the s2c convert program can run on every environment.  I try it in
x86, x8664, mipsn32 . It didn't depend on any special lib.  User can
compile it with "gcc s2c.c" to get it.  And run it in a small board
that didn't have some script support.

markup_oops.pl sames still not support cross compile environment.  It
get module message with modinfo,right?  And use some objdump and so
on.
So even if it support cross compile environment, user use it will need
set which objdump he want use.  Which mod dir  he want use.  Right?

For the s2c, user just "s2c < message >core" It did everything with itself.
After that, gdb vmlinux core.

Best regards,
Hui

On Mon, Jan 4, 2010 at 07:14, Arjan van de Ven <arjan@infradead.org> wrote:
> On Mon, 04 Jan 2010 08:07:45 +0900
> Tejun Heo <tj@kernel.org> wrote:
>
>> On 01/04/2010 08:01 AM, Arjan van de Ven wrote:
>> > On Mon, 04 Jan 2010 07:49:56 +0900
>> > Tejun Heo <tj@kernel.org> wrote:
>> >>
>> >> If implementing parsing of oops message in C is too awkward
>> >> (unsurprising at all), maybe implementing a converter in perl or
>> >> python is the easiest way so that it takes the oops message and
>> >> puts out well formatted input for the s2c program?
>> >
>> > you mean like scripts/markup_oops.pl ?
>>
>> Whichever one works but s2c wouldn't require symbol decoding.  Maybe
>> we can simply add an option to tell it to just parse the oops and
>> output it in machine friendly format.  Oh, also, the patch does add
>> new information the module load addresses.  We should be able to add
>> those to the oops message in a compact form.
>
> actually one does not need those; you know the start address of the
> function already from the current oops output, and since you know the
> address of the function within the module as well, you know the start
> address of the module.
>
>
> --
> Arjan van de Ven        Intel Open Source Technology Centre
> For development, discussion and tips for power savings,
> visit http://www.lesswatts.org
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Tejun Heo]

Hello,

On 01/05/2010 01:22 AM, Hui Zhu wrote:
> For the s2c, user just "s2c < message >core" It did everything with itself.
> After that, gdb vmlinux core.

It is true that by making the kernel oops message more verbose, s2c
can be made way simpler.  However, dependence on standard object tools
or perl is already assumed and avoiding it doesn't really buy
anything.  I really like the idea but unfortunately I'm doubtful that
it will be able to go upstream in the current form.  The suggested
solution (extending markup_oops.pl) won't be too much work, most of
functionality will remain the same and will have much higher chance of
getting included.

Thanks.

-- 
tejun

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

Hi,

I agree with read the current stack message is better.

About the extending, I have some question with it:
1.  markup_oops.pl have itself idea, it try use dmesg| markup_oops.pl
show what happen to usr.  This is different with s2c.
I am not sure people like it have other function with it.  Too much
part of this file need to be change.  It need rewrite, just the oops
message parse part can be keep.

2.  I use perl to work in a long time before, I know it good at parse
the text, but I am not sure it good at handle struct like:
struct mips64_elf_prstatus
{
	struct s2c_elf_siginfo	pr_info;
	uint16_t		pr_cursig;
	uint64_t		pr_sigpend;
	uint64_t		pr_sighold;
	uint32_t		pr_pid;
	uint32_t		pr_ppid;
	uint32_t		pr_pgrp;
	uint32_t		pr_sid;
	struct s2c_timeval_64	pr_utime;
	struct s2c_timeval_64	pr_stime;
	struct s2c_timeval_64	pr_cutime;
	struct s2c_timeval_64	pr_cstime;

	uint64_t		pr_reg[45];

	uint32_t		pr_fpvalid;
} __attribute__ ((aligned(8)));
Even if what happen, I will keep a c s2c with myself.  :)

Best regards,
Hui

On Tue, Jan 5, 2010 at 07:03, Tejun Heo <tj@kernel.org> wrote:
> Hello,
>
> On 01/05/2010 01:22 AM, Hui Zhu wrote:
>> For the s2c, user just "s2c < message >core" It did everything with itself.
>> After that, gdb vmlinux core.
>
> It is true that by making the kernel oops message more verbose, s2c
> can be made way simpler.  However, dependence on standard object tools
> or perl is already assumed and avoiding it doesn't really buy
> anything.  I really like the idea but unfortunately I'm doubtful that
> it will be able to go upstream in the current form.  The suggested
> solution (extending markup_oops.pl) won't be too much work, most of
> functionality will remain the same and will have much higher chance of
> getting included.
>
> Thanks.
>
> --
> tejun
>

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Tejun Heo]

Hello,

On 01/05/2010 06:04 PM, Hui Zhu wrote:
> I agree with read the current stack message is better.
> 
> About the extending, I have some question with it:
> 1.  markup_oops.pl have itself idea, it try use dmesg| markup_oops.pl
> show what happen to usr.  This is different with s2c.
> I am not sure people like it have other function with it.  Too much
> part of this file need to be change.  It need rewrite, just the oops
> message parse part can be keep.

Yeah, I think you'll need to refactor it and share only the parsing
frontend.  Just adding a switch (-m or whatever) which puts it into
machine-friendly translator mode should do the trick.

> 2.  I use perl to work in a long time before, I know it good at parse
> the text, but I am not sure it good at handle struct like:

You don't need to handle the data structure at all.  Just make it
parse the dmesg and output machine-friendly formatted output which can
be processed by s2c.  ie. just make it do the reformatting.

> Even if what happen, I will keep a c s2c with myself.  :)

That will be sad.  I really want it too.  :-)

Thanks.

-- 
tejun

Re: [PATCH] stack2core: show stack message and convert it to core file when kernel die

[Hui Zhu]

Hi,

On Tue, Jan 5, 2010 at 17:20, Tejun Heo <tj@kernel.org> wrote:
> Hello,
>
> On 01/05/2010 06:04 PM, Hui Zhu wrote:
>> I agree with read the current stack message is better.
>>
>> About the extending, I have some question with it:
>> 1.  markup_oops.pl have itself idea, it try use dmesg| markup_oops.pl
>> show what happen to usr.  This is different with s2c.
>> I am not sure people like it have other function with it.  Too much
>> part of this file need to be change.  It need rewrite, just the oops
>> message parse part can be keep.
>
> Yeah, I think you'll need to refactor it and share only the parsing
> frontend.  Just adding a switch (-m or whatever) which puts it into
> machine-friendly translator mode should do the trick.
>
>> 2.  I use perl to work in a long time before, I know it good at parse
>> the text, but I am not sure it good at handle struct like:
>
> You don't need to handle the data structure at all.  Just make it
> parse the dmesg and output machine-friendly formatted output which can
> be processed by s2c.  ie. just make it do the reformatting.

This idea is very cool.  I will do it.  Thanks for help.  :)

Best regards,
Hui