diff options
Diffstat (limited to 'package/mpatrol/mpatrol-uclibc.patch')
| -rw-r--r-- | package/mpatrol/mpatrol-uclibc.patch | 552 |
1 files changed, 552 insertions, 0 deletions
diff --git a/package/mpatrol/mpatrol-uclibc.patch b/package/mpatrol/mpatrol-uclibc.patch new file mode 100644 index 000000000..aab70a876 --- /dev/null +++ b/package/mpatrol/mpatrol-uclibc.patch @@ -0,0 +1,552 @@ +Patches for mpatrol to support uClibc and MIPS full call stack tracing +by Dan Howell <dahowell@directv.com> + +diff -urN mpatrol/src/config.h mpatrol-uclibc/src/config.h +--- mpatrol/src/config.h 2006-04-27 15:58:21.000000000 -0700 ++++ mpatrol-uclibc/src/config.h 2006-05-05 20:32:58.000000000 -0700 +@@ -795,6 +795,10 @@ + */ + + #ifndef MP_INIT_SUPPORT ++/* Note that machine.c currently only implements MP_INIT_SUPPORT for ++ * x86, 68k, 88k, and Sparc architechtures. */ ++#if ARCH == ARCH_IX86 || ARCH == ARCH_M68K || \ ++ ARCH == ARCH_M88K || ARCH == ARCH_SPARC + #if SYSTEM == SYSTEM_DGUX || SYSTEM == SYSTEM_DRSNX || \ + SYSTEM == SYSTEM_DYNIX || SYSTEM == SYSTEM_LINUX || \ + SYSTEM == SYSTEM_SOLARIS || SYSTEM == SYSTEM_UNIXWARE +@@ -809,6 +813,9 @@ + #else /* SYSTEM */ + #define MP_INIT_SUPPORT 0 + #endif /* SYSTEM */ ++#else /* ARCH */ ++#define MP_INIT_SUPPORT 0 ++#endif + #endif /* MP_INIT_SUPPORT */ + + +diff -urN mpatrol/src/inter.c mpatrol-uclibc/src/inter.c +--- mpatrol/src/inter.c 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/inter.c 2006-05-17 18:02:04.000000000 -0700 +@@ -79,12 +79,24 @@ + + #if TARGET == TARGET_UNIX + #if SYSTEM == SYSTEM_LINUX ++#ifndef __UCLIBC__ + /* This contains a pointer to the environment variables for a process. If + * it is not set up yet then we must use sbrk() to allocate all memory since + * we can't initialise mpatrol until the environment variable can be read. + */ + + extern char **__environ; ++#else /* __UCLIBC__ */ ++/* In uClibc, the dynamic loader calls malloc() and related functions, ++ * and sets __environ before these calls, so we can't use it to determine ++ * if we can initialize mpatrol. Instead, we use __progname, which is set ++ * in __uClibc_main just before before uClibc transfers control to the ++ * application's main() function (and static constructors, if any). Before ++ * this, we must use sbrk() to allocate memory. ++ */ ++ ++extern const char *__progname; ++#endif /* __UCLIBC__ */ + #elif SYSTEM == SYSTEM_TRU64 + /* The exception support library on Tru64 always allocates some memory from + * the heap in order to initialise the code address range tables. We need +@@ -118,7 +130,11 @@ + + #if TARGET == TARGET_UNIX + #if SYSTEM == SYSTEM_LINUX ++#ifndef __UCLIBC__ + #define crt_initialised() (__environ) ++#else /* __UCLIBC__ */ ++#define crt_initialised() (__progname) ++#endif /* __UCLIBC__ */ + #elif SYSTEM == SYSTEM_TRU64 + #define crt_initialised() (__exc_crd_list_head && init_flag) + #else /* SYSTEM */ +@@ -306,7 +322,7 @@ + alloctype t; + int c; + +- if (memhead.fini || (memhead.astack.size == 0)) ++ if (memhead.fini || (memhead.astack.size == 0) || memhead.recur != 1) + return; + #if MP_FULLSTACK + /* Create the address nodes for the current call. This is not necessarily +@@ -1307,7 +1323,7 @@ + loginfo v; + int j; + +- if (!memhead.init || memhead.fini) ++ if (!memhead.init || memhead.fini || memhead.recur != 0) + { + __mp_memset(p, c, l); + return p; +@@ -1371,7 +1387,7 @@ + loginfo v; + int j; + +- if (!memhead.init || memhead.fini) ++ if (!memhead.init || memhead.fini || memhead.recur != 0) + if (f == AT_MEMCCPY) + { + if (r = __mp_memfind(p, l, &c, 1)) +diff -ur mpatrol/src/machine.c mpatrol-uclibc/src/machine.c +--- mpatrol/src/machine.c 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/machine.c 2006-06-07 15:11:20.000000000 -0700 +@@ -217,6 +217,19 @@ + .end __mp_stackpointer + + ++/* Obtain the frame pointer (s8) for the current function. ++ */ ++ ++ .text ++ .globl __mp_framepointer ++ .ent __mp_framepointer ++__mp_framepointer: ++ .frame $29,0,$31 ++ move $2,$30 ++ j $31 ++ .end __mp_framepointer ++ ++ + /* Obtain the return address for the current function. + */ + +diff -urN mpatrol/src/memory.c mpatrol-uclibc/src/memory.c +--- mpatrol/src/memory.c 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/memory.c 2006-05-12 18:12:39.000000000 -0700 +@@ -47,7 +47,7 @@ + #endif /* SYSTEM */ + #include <setjmp.h> + #include <signal.h> +-#if MP_SIGINFO_SUPPORT ++#if MP_SIGINFO_SUPPORT && SYSTEM != SYSTEM_LINUX + #include <siginfo.h> + #endif /* MP_SIGINFO_SUPPORT */ + #include <fcntl.h> +diff -urN mpatrol/src/signals.c mpatrol-uclibc/src/signals.c +--- mpatrol/src/signals.c 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/signals.c 2006-05-12 18:12:19.000000000 -0700 +@@ -36,7 +36,7 @@ + #include <stdlib.h> + #include <signal.h> + #if TARGET == TARGET_UNIX +-#if MP_SIGINFO_SUPPORT ++#if MP_SIGINFO_SUPPORT && SYSTEM != SYSTEM_LINUX + #include <siginfo.h> + #endif /* MP_SIGINFO_SUPPORT */ + #elif TARGET == TARGET_WINDOWS +diff -urN mpatrol/src/stack.c mpatrol-uclibc/src/stack.c +--- mpatrol/src/stack.c 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/stack.c 2006-06-22 15:39:04.000000000 -0700 +@@ -48,7 +48,7 @@ + #else /* MP_LIBRARYSTACK_SUPPORT */ + #if TARGET == TARGET_UNIX + #include <setjmp.h> +-#if MP_SIGINFO_SUPPORT ++#if MP_SIGINFO_SUPPORT && SYSTEM != SYSTEM_LINUX + #include <siginfo.h> + #endif /* MP_SIGINFO_SUPPORT */ + #if SYSTEM == SYSTEM_DRSNX || SYSTEM == SYSTEM_SOLARIS +@@ -58,6 +58,17 @@ + #define R_SP REG_SP + #endif /* R_SP */ + #endif /* ARCH */ ++#elif SYSTEM == SYSTEM_LINUX ++#if ARCH == ARCH_MIPS ++#include <linux/unistd.h> ++/* We need the ucontext defined in asm/ucontext.h, but sys/ucontext.h ++ * has a conflicting definition of ucontext. So we'll trick the ++ * preprocessor into letting the include file define a non-conflicting ++ * name. */ ++#define ucontext asm_ucontext ++#include <asm/ucontext.h> ++#undef ucontext ++#endif /* ARCH */ + #endif /* SYSTEM */ + #endif /* TARGET */ + #endif /* MP_LIBRARYSTACK_SUPPORT */ +@@ -122,6 +133,15 @@ + #define SP_OFFSET 2 /* stack pointer offset has been set */ + #define SP_LOWER 4 /* lower part of stack pointer offset has been set */ + #define SP_UPPER 8 /* upper part of stack pointer offset has been set */ ++#define BR_UNCOND 16 /* unconditional branch needs to be taken */ ++#define BR_COND 32 /* conditional branch encountered */ ++#define RA_NOFRAME 64 /* no frame - return address is in ra register */ ++#define SP_IN_FP 128 /* stack pointer stored in frame pointer (s8) register */ ++ ++#if SYSTEM == SYSTEM_LINUX ++#define RA_SIGTRAMP 1 /* return address is a signal trampoline */ ++#define RA_SIGRETURN 2 /* return address is in the signalled function */ ++#endif /* SYSTEM */ + #endif /* TARGET && ARCH */ + #endif /* MP_BUILTINSTACK_SUPPORT && MP_LIBRARYSTACK_SUPPORT */ + +@@ -152,6 +172,13 @@ + #endif /* SYSTEM */ + #endif /* SYSTEM */ + #else /* MP_LIBRARYSTACK_SUPPORT */ ++/* On some systems, such as those using uClibc, the signal() function may ++ * call memcpy() or other memory related functions, so we need to guard ++ * against recursion. ++ */ ++ ++static unsigned char recursive; ++ + static jmp_buf environment; + #if MP_SIGINFO_SUPPORT + static struct sigaction bushandler; +@@ -261,23 +288,41 @@ + int + unwind(frameinfo *f) + { +- long p, s; +- unsigned long a, i, q; ++ long p, m, s; ++ unsigned long a, i, q, t, b, r; + unsigned short l, u; + + s = -1; +- p = 0; ++ p = m = 0; + q = 0xFFFFFFFF; + l = u = 0; + a = 0; ++ t = b = 0; + /* Determine the current stack pointer and return address if we are + * initiating call stack traversal. + */ + if (f->ra == 0) + { + f->sp = __mp_stackpointer(); ++ f->fp = __mp_framepointer(); + f->ra = __mp_returnaddress(); + } ++#if SYSTEM == SYSTEM_LINUX ++ /* Handle signal frames. ++ */ ++ if (f->ra & RA_SIGRETURN) ++ { ++ /* in case of frameless function, get ra and sp from sigcontext */ ++ p = ((struct sigcontext *) f->sp)->sc_regs[31]; ++ f->fp = ((struct sigcontext *) f->sp)->sc_regs[30]; ++ f->sp = ((struct sigcontext *) f->sp)->sc_regs[29]; ++ a |= RA_NOFRAME; ++ } ++ f->ra &= ~3; ++#endif ++ /* Save initial code-reading starting point. ++ */ ++ r = f->ra; + /* Search for the return address offset in the stack frame. + */ + while (!((a & RA_OFFSET) && (a & SP_OFFSET)) && (f->ra < q)) +@@ -294,6 +339,67 @@ + s = 0; + a |= SP_OFFSET; + } ++ else if (i == 0x03C0E821) ++ { ++ /* move sp,s8 */ ++ a |= SP_IN_FP; ++ } ++ else if ((i >> 28 == 0x1) || (i >> 26 == 0x01)) ++ { ++ /* branch */ ++ t = f->ra + ((signed short)(i & 0xFFFF) * 4) + 4; ++ if ((i >> 16 == 0x1000) && !(a & BR_COND)) ++ { ++ /* unconditional branch, if no conditional branch could ++ branch past this code */ ++ b = t; ++ a |= BR_UNCOND; ++ } ++ else ++ { ++ /* conditional branch, ignore if previous conditional branch ++ is further forwards */ ++ if ((t > b) && (t > f->ra)) ++ { ++ b = t; ++ a |= BR_COND; ++ /* can branch past an unconditional branch */ ++ if (b > q) ++ q = 0xFFFFFFFF; ++ } ++ else if (t < r) ++ { ++ /* but if branching backwards, set reverse branch target to ++ lowest address target encountered so far */ ++ r = t; ++ /* ensure a loop back */ ++ q = 0xFFFFFFFF; ++ } ++ } ++ } ++#if SYSTEM == SYSTEM_LINUX ++ else if (i == 0x0000000c) ++ { ++ /* syscall - check for signal handler trampolines */ ++ if (*((unsigned long *) (f->ra - 4)) == 0x24020000 + __NR_sigreturn) ++ { ++ /* li v0,__NR_sigreturn */ ++ /* get pointer to sigcontext */ ++ f->sp = f->ra + 4; ++ f->ra = ((struct sigcontext *) f->sp)->sc_pc | RA_SIGRETURN; ++ return 1; ++ } ++ else if (*((unsigned long *) (f->ra - 4)) == 0x24020000 + __NR_rt_sigreturn) ++ { ++ /* li v0,__NR_rt_sigreturn */ ++ /* get pointer to sigcontext */ ++ f->sp = f->ra + 4 + ++ sizeof(struct siginfo) + offsetof(struct asm_ucontext, uc_mcontext); ++ f->ra = ((struct sigcontext *) f->sp)->sc_pc | RA_SIGRETURN; ++ return 1; ++ } ++ } ++#endif + else + switch (i >> 16) + { +@@ -319,6 +425,10 @@ + u = i & 0xFFFF; + a |= SP_UPPER; + break; ++ case 0x8FBE: ++ /* lw s8,##(sp) */ ++ m = i & 0xFFFF; ++ break; + case 0x8FBF: + /* lw ra,##(sp) */ + p = i & 0xFFFF; +@@ -326,9 +436,52 @@ + break; + } + f->ra += 4; ++ /* Process branch instructions. ++ */ ++ if (a & BR_COND) ++ { ++ if (f->ra >= b) ++ { ++ /* reached target of previous conditional branch */ ++ a &= ~BR_COND; ++ b = 0; ++ } ++ } ++ else if (a & BR_UNCOND) ++ /* clear branch flag and process instruction in delay slot */ ++ a &= ~BR_UNCOND; ++ else if (b != 0) ++ { ++ /* now follow the unconditional branch */ ++ if (b < f->ra) ++ { ++ /* avoid infinite loops */ ++ q = f->ra - 8; ++ /* go back as far as possible */ ++ if (r < b) ++ b = r; ++ } ++ f->ra = b; ++ b = 0; ++ } + } + if ((s == 0) && ((a & SP_LOWER) || (a & SP_UPPER))) + s = (u << 16) | l; ++#if SYSTEM == SYSTEM_LINUX ++ if ((a & RA_NOFRAME) && !(a & RA_OFFSET) && ++ ((*((unsigned long *) (p - 8)) == 0x0320F809) || ++ (*((unsigned long *) (p - 8)) >> 16 == 0x0C10))) ++ { ++ /* jalr ra,t9 or jal ## */ ++ /* f->sp already set */ ++ f->ra = p; ++ return 1; ++ } ++#endif ++ if (a & SP_IN_FP) ++ f->sp = f->fp; ++ if (m > 0) ++ f->fp = ((unsigned long *) f->sp)[m >> 2]; + if ((s > 0) && (i = ((unsigned long *) f->sp)[p >> 2]) && + ((*((unsigned long *) (i - 8)) == 0x0320F809) || + (*((unsigned long *) (i - 8)) >> 16 == 0x0C10))) +@@ -338,6 +491,19 @@ + f->ra = i; + return 1; + } ++#if SYSTEM == SYSTEM_LINUX ++ else if ((s > 0) && (i != 0) && ++ (*((unsigned long *) (i + 4)) == 0x0000000c) && ++ ((*((unsigned long *) i) == 0x24020000 + __NR_sigreturn) || ++ (*((unsigned long *) i) == 0x24020000 + __NR_rt_sigreturn))) ++ { ++ /* li v0,__NR_sigreturn or __NR_rt_sigreturn ; syscall */ ++ /* signal trampoline */ ++ f->sp += s; ++ f->ra = i | RA_SIGTRAMP; ++ return 1; ++ } ++#endif + f->sp = f->ra = 0; + return 0; + } +@@ -573,16 +739,14 @@ + } + #endif /* TARGET */ + #else /* MP_BUILTINSTACK_SUPPORT && MP_LIBRARYSTACK_SUPPORT */ +-#if (TARGET == TARGET_UNIX && (ARCH == ARCH_IX86 || ARCH == ARCH_M68K || \ +- ARCH == ARCH_M88K || ARCH == ARCH_POWER || ARCH == ARCH_POWERPC || \ +- ARCH == ARCH_SPARC)) || ((TARGET == TARGET_WINDOWS || \ +- TARGET == TARGET_NETWARE) && ARCH == ARCH_IX86) +- /* This section is not complete in any way for the OS / processor +- * combinations it supports, as it is intended to be as portable as possible +- * without writing in assembler. In particular, optimised code is likely +- * to cause major problems for stack traversal on some platforms. +- */ + #if TARGET == TARGET_UNIX ++ /* On some systems, such as those using uClibc, the signal() function may ++ * call memcpy() or other memory related functions, so we need to guard ++ * against recursion here. ++ */ ++ if (!recursive) ++ { ++ recursive = 1; + #if MP_SIGINFO_SUPPORT + i.sa_flags = 0; + (void *) i.sa_handler = (void *) stackhandler; +@@ -597,6 +761,15 @@ + __mp_newframe(p, p->first); + else + #endif /* TARGET */ ++#if (TARGET == TARGET_UNIX && (ARCH == ARCH_IX86 || ARCH == ARCH_M68K || \ ++ ARCH == ARCH_M88K || ARCH == ARCH_POWER || ARCH == ARCH_POWERPC || \ ++ ARCH == ARCH_SPARC)) || ((TARGET == TARGET_WINDOWS || \ ++ TARGET == TARGET_NETWARE) && ARCH == ARCH_IX86) ++ /* This section is not complete in any way for the OS / processor ++ * combinations it supports, as it is intended to be as portable as possible ++ * without writing in assembler. In particular, optimised code is likely ++ * to cause major problems for stack traversal on some platforms. ++ */ + { + if (p->frame == NULL) + if (p->first == NULL) +@@ -640,32 +813,10 @@ + r = 1; + } + } +-#if TARGET == TARGET_UNIX +-#if MP_SIGINFO_SUPPORT +- sigaction(SIGBUS, &bushandler, NULL); +- sigaction(SIGSEGV, &segvhandler, NULL); +-#else /* MP_SIGINFO_SUPPORT */ +- signal(SIGBUS, bushandler); +- signal(SIGSEGV, segvhandler); +-#endif /* MP_SIGINFO_SUPPORT */ +-#endif /* TARGET */ + #elif TARGET == TARGET_UNIX && ARCH == ARCH_MIPS + /* For the MIPS architecture we perform code reading to determine the + * frame pointers and the return addresses. + */ +-#if MP_SIGINFO_SUPPORT +- i.sa_flags = 0; +- (void *) i.sa_handler = (void *) stackhandler; +- sigfillset(&i.sa_mask); +- sigaction(SIGBUS, &i, &bushandler); +- sigaction(SIGSEGV, &i, &segvhandler); +-#else /* MP_SIGINFO_SUPPORT */ +- bushandler = signal(SIGBUS, stackhandler); +- segvhandler = signal(SIGSEGV, stackhandler); +-#endif /* MP_SIGINFO_SUPPORT */ +- if (setjmp(environment)) +- __mp_newframe(p, p->first); +- else + { + if (p->frame == NULL) + unwind(&p->next); +@@ -673,6 +824,10 @@ + { + p->frame = (void *) p->next.sp; + p->addr = (void *) (p->next.ra - 8); ++#if SYSTEM == SYSTEM_LINUX ++ if (p->next.ra & (RA_SIGTRAMP|RA_SIGRETURN)) ++ p->addr = (void *) (p->next.ra & ~3); ++#endif /* SYSTEM */ + r = 1; + } + else +@@ -681,6 +836,8 @@ + p->addr = NULL; + } + } ++#endif /* TARGET && ARCH */ ++#if TARGET == TARGET_UNIX + #if MP_SIGINFO_SUPPORT + sigaction(SIGBUS, &bushandler, NULL); + sigaction(SIGSEGV, &segvhandler, NULL); +@@ -688,7 +845,9 @@ + signal(SIGBUS, bushandler); + signal(SIGSEGV, segvhandler); + #endif /* MP_SIGINFO_SUPPORT */ +-#endif /* TARGET && ARCH */ ++ recursive = 0; ++ } /* if (!bushandler) */ ++#endif /* TARGET */ + #endif /* MP_BUILTINSTACK_SUPPORT && MP_LIBRARYSTACK_SUPPORT */ + return r; + } +diff -ur mpatrol/src/stack.h mpatrol-uclibc/src/stack.h +--- mpatrol/src/stack.h 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/stack.h 2006-06-07 15:12:58.000000000 -0700 +@@ -75,6 +75,7 @@ + typedef struct frameinfo + { + unsigned int sp; /* stack pointer */ ++ unsigned int fp; /* frame pointer (s8) */ + unsigned int ra; /* return address */ + } + frameinfo; +diff -urN mpatrol/src/symbol.c mpatrol-uclibc/src/symbol.c +--- mpatrol/src/symbol.c 2002-01-08 12:13:59.000000000 -0800 ++++ mpatrol-uclibc/src/symbol.c 2006-05-24 15:43:04.000000000 -0700 +@@ -1157,7 +1157,7 @@ + __mp_error(ET_MAX, AT_MAX, NULL, 0, "%s: %s\n", f, m); + return 0; + } +- if (n == 0) ++ if (n <= sizeof(asymbol *)) + { + /* If we couldn't find the symbol table then it is likely that the file + * has been stripped. However, if the file was dynamically linked then +@@ -1172,7 +1172,7 @@ + __mp_error(ET_MAX, AT_MAX, NULL, 0, "%s: %s\n", f, m); + return 0; + } +- if (n == 0) ++ if (n <= sizeof(asymbol *)) + { + m = "missing symbol table"; + if (a != NULL) +@@ -1893,6 +1893,17 @@ + l = (dynamiclink *) *((unsigned long *) d->d_un.d_ptr + 1); + break; + } ++#if ARCH == ARCH_MIPS ++ else if (d->d_tag == DT_MIPS_RLD_MAP) ++ { ++ /* MIPS elf has DT_MIPS_RLD_MAP instead of DT_DEBUG. */ ++ if (!d->d_un.d_ptr || !(*(unsigned long **) d->d_un.d_ptr)) ++ l = NULL; ++ else ++ l = (dynamiclink *) *((*(unsigned long **) d->d_un.d_ptr) + 1); ++ break; ++ } ++#endif /* ARCH */ + /* We skip past the first item on the list since it represents the + * executable file, but we may wish to record the name of the file + * if we haven't already determined it. |