| /* Copyright (c) 2005-2008, Google Inc. |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| * |
| * --- |
| * Author: Markus Gutschke, Carl Crous |
| */ |
| |
| #ifndef _ELFCORE_H |
| #define _ELFCORE_H |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| /* We currently only support x86-32, x86-64, ARM, and MIPS on Linux. |
| * Porting to other related platforms should not be difficult. |
| */ |
| #if (defined(__i386__) || defined(__x86_64__) || defined(__ARM_ARCH_3__) || \ |
| defined(__mips__)) && defined(__linux) |
| |
| #include <stdarg.h> |
| #include <stdint.h> |
| #include <sys/types.h> |
| #include <config.h> |
| |
| |
| /* Define the DUMPER symbol to make sure that there is exactly one |
| * core dumper built into the library. |
| */ |
| #define DUMPER "ELF" |
| |
| /* By the time that we get a chance to read CPU registers in the |
| * calling thread, they are already in a not particularly useful |
| * state. Besides, there will be multiple frames on the stack that are |
| * just making the core file confusing. To fix this problem, we take a |
| * snapshot of the frame pointer, stack pointer, and instruction |
| * pointer at an earlier time, and then insert these values into the |
| * core file. |
| */ |
| |
| #if defined(__i386__) || defined(__x86_64__) |
| typedef struct i386_regs { /* Normal (non-FPU) CPU registers */ |
| #ifdef __x86_64__ |
| #define BP rbp |
| #define SP rsp |
| #define IP rip |
| uint64_t r15,r14,r13,r12,rbp,rbx,r11,r10; |
| uint64_t r9,r8,rax,rcx,rdx,rsi,rdi,orig_rax; |
| uint64_t rip,cs,eflags; |
| uint64_t rsp,ss; |
| uint64_t fs_base, gs_base; |
| uint64_t ds,es,fs,gs; |
| #else |
| #define BP ebp |
| #define SP esp |
| #define IP eip |
| uint32_t ebx, ecx, edx, esi, edi, ebp, eax; |
| uint16_t ds, __ds, es, __es; |
| uint16_t fs, __fs, gs, __gs; |
| uint32_t orig_eax, eip; |
| uint16_t cs, __cs; |
| uint32_t eflags, esp; |
| uint16_t ss, __ss; |
| #endif |
| } i386_regs; |
| #elif defined(__ARM_ARCH_3__) |
| typedef struct arm_regs { /* General purpose registers */ |
| #define BP uregs[11] /* Frame pointer */ |
| #define SP uregs[13] /* Stack pointer */ |
| #define IP uregs[15] /* Program counter */ |
| #define LR uregs[14] /* Link register */ |
| long uregs[18]; |
| } arm_regs; |
| #elif defined(__mips__) |
| typedef struct mips_regs { |
| unsigned long pad[6]; /* Unused padding to match kernel structures */ |
| unsigned long uregs[32]; /* General purpose registers. */ |
| unsigned long hi; /* Used for multiplication and division. */ |
| unsigned long lo; |
| unsigned long cp0_epc; /* Program counter. */ |
| unsigned long cp0_badvaddr; |
| unsigned long cp0_status; |
| unsigned long cp0_cause; |
| unsigned long unused; |
| } mips_regs; |
| #endif |
| |
| #if defined(__i386__) && defined(__GNUC__) |
| /* On x86 we provide an optimized version of the FRAME() macro, if the |
| * compiler supports a GCC-style asm() directive. This results in somewhat |
| * more accurate values for CPU registers. |
| */ |
| typedef struct Frame { |
| struct i386_regs uregs; |
| int errno_; |
| pid_t tid; |
| } Frame; |
| #define FRAME(f) Frame f; \ |
| do { \ |
| f.errno_ = errno; \ |
| f.tid = sys_gettid(); \ |
| __asm__ volatile ( \ |
| "push %%ebp\n" \ |
| "push %%ebx\n" \ |
| "mov %%ebx,0(%%eax)\n" \ |
| "mov %%ecx,4(%%eax)\n" \ |
| "mov %%edx,8(%%eax)\n" \ |
| "mov %%esi,12(%%eax)\n" \ |
| "mov %%edi,16(%%eax)\n" \ |
| "mov %%ebp,20(%%eax)\n" \ |
| "mov %%eax,24(%%eax)\n" \ |
| "mov %%ds,%%ebx\n" \ |
| "mov %%ebx,28(%%eax)\n" \ |
| "mov %%es,%%ebx\n" \ |
| "mov %%ebx,32(%%eax)\n" \ |
| "mov %%fs,%%ebx\n" \ |
| "mov %%ebx,36(%%eax)\n" \ |
| "mov %%gs,%%ebx\n" \ |
| "mov %%ebx, 40(%%eax)\n" \ |
| "call 0f\n" \ |
| "0:pop %%ebx\n" \ |
| "add $1f-0b,%%ebx\n" \ |
| "mov %%ebx,48(%%eax)\n" \ |
| "mov %%cs,%%ebx\n" \ |
| "mov %%ebx,52(%%eax)\n" \ |
| "pushf\n" \ |
| "pop %%ebx\n" \ |
| "mov %%ebx,56(%%eax)\n" \ |
| "mov %%esp,%%ebx\n" \ |
| "add $8,%%ebx\n" \ |
| "mov %%ebx,60(%%eax)\n" \ |
| "mov %%ss,%%ebx\n" \ |
| "mov %%ebx,64(%%eax)\n" \ |
| "pop %%ebx\n" \ |
| "pop %%ebp\n" \ |
| "1:" \ |
| : : "a" (&f) : "memory"); \ |
| } while (0) |
| #define SET_FRAME(f,r) \ |
| do { \ |
| errno = (f).errno_; \ |
| (r) = (f).uregs; \ |
| } while (0) |
| #elif defined(__x86_64__) && defined(__GNUC__) |
| /* The FRAME and SET_FRAME macros for x86_64. */ |
| typedef struct Frame { |
| struct i386_regs uregs; |
| int errno_; |
| pid_t tid; |
| } Frame; |
| #define FRAME(f) Frame f; \ |
| do { \ |
| f.errno_ = errno; \ |
| f.tid = sys_gettid(); \ |
| __asm__ volatile ( \ |
| "push %%rbp\n" \ |
| "push %%rbx\n" \ |
| "mov %%r15,0(%%rax)\n" \ |
| "mov %%r14,8(%%rax)\n" \ |
| "mov %%r13,16(%%rax)\n" \ |
| "mov %%r12,24(%%rax)\n" \ |
| "mov %%rbp,32(%%rax)\n" \ |
| "mov %%rbx,40(%%rax)\n" \ |
| "mov %%r11,48(%%rax)\n" \ |
| "mov %%r10,56(%%rax)\n" \ |
| "mov %%r9,64(%%rax)\n" \ |
| "mov %%r8,72(%%rax)\n" \ |
| "mov %%rax,80(%%rax)\n" \ |
| "mov %%rcx,88(%%rax)\n" \ |
| "mov %%rdx,96(%%rax)\n" \ |
| "mov %%rsi,104(%%rax)\n" \ |
| "mov %%rdi,112(%%rax)\n" \ |
| "mov %%ds,%%rbx\n" \ |
| "mov %%rbx,184(%%rax)\n" \ |
| "mov %%es,%%rbx\n" \ |
| "mov %%rbx,192(%%rax)\n" \ |
| "mov %%fs,%%rbx\n" \ |
| "mov %%rbx,200(%%rax)\n" \ |
| "mov %%gs,%%rbx\n" \ |
| "mov %%rbx,208(%%rax)\n" \ |
| "call 0f\n" \ |
| "0:pop %%rbx\n" \ |
| "add $1f-0b,%%rbx\n" \ |
| "mov %%rbx,128(%%rax)\n" \ |
| "mov %%cs,%%rbx\n" \ |
| "mov %%rbx,136(%%rax)\n" \ |
| "pushf\n" \ |
| "pop %%rbx\n" \ |
| "mov %%rbx,144(%%rax)\n" \ |
| "mov %%rsp,%%rbx\n" \ |
| "add $16,%%ebx\n" \ |
| "mov %%rbx,152(%%rax)\n" \ |
| "mov %%ss,%%rbx\n" \ |
| "mov %%rbx,160(%%rax)\n" \ |
| "pop %%rbx\n" \ |
| "pop %%rbp\n" \ |
| "1:" \ |
| : : "a" (&f) : "memory"); \ |
| } while (0) |
| #define SET_FRAME(f,r) \ |
| do { \ |
| errno = (f).errno_; \ |
| (f).uregs.fs_base = (r).fs_base; \ |
| (f).uregs.gs_base = (r).gs_base; \ |
| (r) = (f).uregs; \ |
| } while (0) |
| #elif defined(__ARM_ARCH_3__) && defined(__GNUC__) |
| /* ARM calling conventions are a little more tricky. A little assembly |
| * helps in obtaining an accurate snapshot of all registers. |
| */ |
| typedef struct Frame { |
| struct arm_regs arm; |
| int errno_; |
| pid_t tid; |
| } Frame; |
| #define FRAME(f) Frame f; \ |
| do { \ |
| long cpsr; \ |
| f.errno_ = errno; \ |
| f.tid = sys_gettid(); \ |
| __asm__ volatile( \ |
| "stmia %0, {r0-r15}\n" /* All integer regs */\ |
| : : "r"(&f.arm) : "memory"); \ |
| f.arm.uregs[16] = 0; \ |
| __asm__ volatile( \ |
| "mrs %0, cpsr\n" /* Condition code reg */\ |
| : "=r"(cpsr)); \ |
| f.arm.uregs[17] = cpsr; \ |
| } while (0) |
| #define SET_FRAME(f,r) \ |
| do { \ |
| /* Don't override the FPU status register. */\ |
| /* Use the value obtained from ptrace(). This*/\ |
| /* works, because our code does not perform */\ |
| /* any FPU operations, itself. */\ |
| long fps = (f).arm.uregs[16]; \ |
| errno = (f).errno_; \ |
| (r) = (f).arm; \ |
| (r).uregs[16] = fps; \ |
| } while (0) |
| #elif defined(__mips__) && defined(__GNUC__) |
| typedef struct Frame { |
| struct mips_regs mips_regs; |
| int errno_; |
| pid_t tid; |
| } Frame; |
| #define MIPSREG(n) ({ register unsigned long r __asm__("$"#n); r; }) |
| #define FRAME(f) Frame f = { 0 }; \ |
| do { \ |
| unsigned long hi, lo; \ |
| register unsigned long pc __asm__("$31"); \ |
| f.mips_regs.uregs[ 0] = MIPSREG( 0); \ |
| f.mips_regs.uregs[ 1] = MIPSREG( 1); \ |
| f.mips_regs.uregs[ 2] = MIPSREG( 2); \ |
| f.mips_regs.uregs[ 3] = MIPSREG( 3); \ |
| f.mips_regs.uregs[ 4] = MIPSREG( 4); \ |
| f.mips_regs.uregs[ 5] = MIPSREG( 5); \ |
| f.mips_regs.uregs[ 6] = MIPSREG( 6); \ |
| f.mips_regs.uregs[ 7] = MIPSREG( 7); \ |
| f.mips_regs.uregs[ 8] = MIPSREG( 8); \ |
| f.mips_regs.uregs[ 9] = MIPSREG( 9); \ |
| f.mips_regs.uregs[10] = MIPSREG(10); \ |
| f.mips_regs.uregs[11] = MIPSREG(11); \ |
| f.mips_regs.uregs[12] = MIPSREG(12); \ |
| f.mips_regs.uregs[13] = MIPSREG(13); \ |
| f.mips_regs.uregs[14] = MIPSREG(14); \ |
| f.mips_regs.uregs[15] = MIPSREG(15); \ |
| f.mips_regs.uregs[16] = MIPSREG(16); \ |
| f.mips_regs.uregs[17] = MIPSREG(17); \ |
| f.mips_regs.uregs[18] = MIPSREG(18); \ |
| f.mips_regs.uregs[19] = MIPSREG(19); \ |
| f.mips_regs.uregs[20] = MIPSREG(20); \ |
| f.mips_regs.uregs[21] = MIPSREG(21); \ |
| f.mips_regs.uregs[22] = MIPSREG(22); \ |
| f.mips_regs.uregs[23] = MIPSREG(23); \ |
| f.mips_regs.uregs[24] = MIPSREG(24); \ |
| f.mips_regs.uregs[25] = MIPSREG(25); \ |
| f.mips_regs.uregs[26] = MIPSREG(26); \ |
| f.mips_regs.uregs[27] = MIPSREG(27); \ |
| f.mips_regs.uregs[28] = MIPSREG(28); \ |
| f.mips_regs.uregs[29] = MIPSREG(29); \ |
| f.mips_regs.uregs[30] = MIPSREG(30); \ |
| f.mips_regs.uregs[31] = MIPSREG(31); \ |
| __asm__ volatile ("mfhi %0" : "=r"(hi)); \ |
| __asm__ volatile ("mflo %0" : "=r"(lo)); \ |
| __asm__ volatile ("jal 1f; 1:nop" : "=r"(pc)); \ |
| f.mips_regs.hi = hi; \ |
| f.mips_regs.lo = lo; \ |
| f.mips_regs.cp0_epc = pc; \ |
| f.errno_ = errno; \ |
| f.tid = sys_gettid(); \ |
| } while (0) |
| #define SET_FRAME(f,r) \ |
| do { \ |
| errno = (f).errno_; \ |
| memcpy((r).uregs, (f).mips_regs.uregs, \ |
| 32*sizeof(unsigned long)); \ |
| (r).hi = (f).mips_regs.hi; \ |
| (r).lo = (f).mips_regs.lo; \ |
| (r).cp0_epc = (f).mips_regs.cp0_epc; \ |
| } while (0) |
| #else |
| /* If we do not have a hand-optimized assembly version of the FRAME() |
| * macro, we cannot reliably unroll the stack. So, we show a few additional |
| * stack frames for the coredumper. |
| */ |
| typedef struct Frame { |
| pid_t tid; |
| } Frame; |
| #define FRAME(f) Frame f; do { f.tid = sys_gettid(); } while (0) |
| #define SET_FRAME(f,r) do { } while (0) |
| #endif |
| |
| |
| /* Internal function for generating a core file. This API can change without |
| * notice and is only supposed to be used internally by the core dumper. |
| * |
| * This function works for both single- and multi-threaded core |
| * dumps. If called as |
| * |
| * FRAME(frame); |
| * InternalGetCoreDump(&frame, 0, NULL, ap); |
| * |
| * it creates a core file that only contains information about the |
| * calling thread. |
| * |
| * Optionally, the caller can provide information about other threads |
| * by passing their process ids in "thread_pids". The process id of |
| * the caller should not be included in this array. All of the threads |
| * must have been attached to with ptrace(), prior to calling this |
| * function. They will be detached when "InternalGetCoreDump()" returns. |
| * |
| * This function either returns a file handle that can be read for obtaining |
| * a core dump, or "-1" in case of an error. In the latter case, "errno" |
| * will be set appropriately. |
| * |
| * While "InternalGetCoreDump()" is not technically async signal safe, you |
| * might be tempted to invoke it from a signal handler. The code goes to |
| * great lengths to make a best effort that this will actually work. But in |
| * any case, you must make sure that you preserve the value of "errno" |
| * yourself. It is guaranteed to be clobbered otherwise. |
| * |
| * Also, "InternalGetCoreDump" is not strictly speaking re-entrant. Again, |
| * it makes a best effort to behave reasonably when called in a multi- |
| * threaded environment, but it is ultimately the caller's responsibility |
| * to provide locking. |
| */ |
| int InternalGetCoreDump(void *frame, int num_threads, pid_t *thread_pids, |
| va_list ap |
| /* const struct CoreDumpParameters *params, |
| const char *file_name, |
| const char *PATH |
| */); |
| |
| #endif |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif /* _ELFCORE_H */ |
