add mpatrol package

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.