arch/ppc-chrp/efika/kernel/debug.c

   1 /*
   2  * debug.c
   3  *
   4  *  Created on: Aug 25, 2008
   5  *      Author: misc
   6  */
   7
   8 #define PCIC0_IO 0
   9
  10 #include <asm/io.h>
  11 #include <aros/libcall.h>
  12 #include <stdarg.h>
  13 #include <string.h>
  14 #include <proto/exec.h>
  15 #include <exec/lists.h>
  16 #include <exec/nodes.h>
  17 #include <exec/memory.h>
  18 #include "kernel_intern.h"
  19
  20 void __putc(uint8_t chr)
  21 {
  22         if (chr == '\n')
  23                 __putc('\r');
  24
  25         while (!(inw(0xf0002004) & 0x400));
  26         outb(chr, 0xf0002080);
  27         while (!(inw(0xf0002004) & 0x400));
  28 }
  29
  30
  31 AROS_LH2(int, KrnBug,
  32          AROS_LHA(const char *, format, A0),
  33          AROS_LHA(va_list, args, A1),
  34          struct KernelBase *, KernelBase, 11, Kernel)
  35 {
  36     AROS_LIBFUNC_INIT
  37
  38 #if 1
  39     int result;
  40
  41     result = __vcformat(NULL, __putc, format, args);
  42
  43     return result;
  44 #endif
  45
  46     AROS_LIBFUNC_EXIT
  47 }
  48
  49
  50
  51
  52
  53
  54
  55 #define SHT_PROGBITS    1
  56 #define SHT_SYMTAB      2
  57 #define SHT_STRTAB      3
  58 #define SHT_RELA        4
  59 #define SHT_NOBITS      8
  60 #define SHT_REL         9
  61 #define SHT_SYMTAB_SHNDX 18
  62
  63 #define ET_REL          1
  64
  65 #define EM_386          3
  66 #define EM_68K          4
  67 #define EM_PPC         20
  68 #define EM_ARM         40
  69 #define EM_X86_64       62      /* AMD x86-64 */
  70
  71 #define R_386_NONE      0
  72 #define R_386_32        1
  73 #define R_386_PC32      2
  74
  75 /* AMD x86-64 relocations.  */
  76 #define R_X86_64_NONE   0       /* No reloc */
  77 #define R_X86_64_64     1       /* Direct 64 bit  */
  78 #define R_X86_64_PC32   2       /* PC relative 32 bit signed */
  79
  80 #define R_68k_NONE      0
  81 #define R_68K_32        1
  82 #define R_68K_PC32      4
  83
  84 #define R_PPC_NONE      0
  85 #define R_PPC_ADDR32    1
  86 #define R_PPC_ADDR16_LO 4
  87 #define R_PPC_ADDR16_HA 6
  88 #define R_PPC_REL24     10
  89 #define R_PPC_REL32     26
  90 #define R_PPC_REL16_LO  250
  91 #define R_PPC_REL16_HA  252
  92
  93 #define R_ARM_NONE      0
  94 #define R_ARM_PC24      1
  95 #define R_ARM_ABS32     2
  96
  97 #define STT_OBJECT      1
  98 #define STT_FUNC        2
  99
 100 #define SHN_UNDEF       0
 101 #define SHN_LORESERVE   0xff00
 102 #define SHN_ABS         0xfff1
 103 #define SHN_COMMON      0xfff2
 104 #define SHN_XINDEX      0xffff
 105 #define SHN_HIRESERVE   0xffff
 106
 107 #define SHF_ALLOC            (1 << 1)
 108 #define SHF_EXECINSTR        (1 << 2)
 109
 110 #define ELF32_ST_TYPE(i)    ((i) & 0x0F)
 111
 112 #define EI_VERSION      6
 113 #define EV_CURRENT      1
 114
 115 #define EI_DATA         5
 116 #define ELFDATA2LSB     1
 117 #define ELFDATA2MSB     2
 118
 119 #define EI_CLASS        4
 120 #define ELFCLASS32      1
 121 #define ELFCLASS64      2               /* 64-bit objects */
 122
 123 #define ELF32_R_SYM(val)        ((val) >> 8)
 124 #define ELF32_R_TYPE(val)       ((val) & 0xff)
 125 #define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff))
 126
 127
 128 struct elfheader
 129 {
 130     UBYTE ident[16];
 131     UWORD type;
 132     UWORD machine;
 133     ULONG version;
 134     APTR  entry;
 135     ULONG phoff;
 136     ULONG shoff;
 137     ULONG flags;
 138     UWORD ehsize;
 139     UWORD phentsize;
 140     UWORD phnum;
 141     UWORD shentsize;
 142     UWORD shnum;
 143     UWORD shstrndx;
 144
 145     /* these are internal, and not part of the header proper. they are wider
 146      * versions of shnum and shstrndx for when they don't fit in the header
 147      * and we need to get them from the first section header. see
 148      * load_header() for details
 149      */
 150     ULONG int_shnum;
 151     ULONG int_shstrndx;
 152 };
 153
 154 struct sheader
 155 {
 156     ULONG name;
 157     ULONG type;
 158     ULONG flags;
 159     APTR  addr;
 160     ULONG offset;
 161     ULONG size;
 162     ULONG link;
 163     ULONG info;
 164     ULONG addralign;
 165     ULONG entsize;
 166 };
 167
 168 struct symbol
 169 {
 170     ULONG name;     /* Offset of the name string in the string table */
 171     ULONG value;    /* Varies; eg. the offset of the symbol in its hunk */
 172     ULONG size;     /* How much memory does the symbol occupy */
 173     UBYTE info;     /* What kind of symbol is this ? (global, variable, etc) */
 174     UBYTE other;    /* undefined */
 175     UWORD shindex;  /* In which section is the symbol defined ? */
 176 };
 177
 178 struct relo
 179 {
 180     ULONG offset;   /* Address of the relocation relative to the section it refers to */
 181     ULONG info;     /* Type of the relocation */
 182 #if defined(__mc68000__) || defined (__x86_64__) || defined (__ppc__) || defined (__powerpc__) || defined(__arm__)
 183     LONG  addend;   /* Constant addend used to compute value */
 184 #endif
 185 };
 186
 187 struct hunk
 188 {
 189     ULONG size;
 190     BPTR  next;
 191     char  data[0];
 192 } __attribute__((packed));
 193
 194 #define BPTR2HUNK(bptr) ((struct hunk *)((char *)BADDR(bptr) - offsetof(struct hunk, next)))
 195 #define HUNK2BPTR(hunk) MKBADDR(&hunk->next)
 196
 197 /* convert section header number to array index */
 198 #define SHINDEX(n) \
 199     ((n) < SHN_LORESERVE ? (n) : ((n) <= SHN_HIRESERVE ? 0 : (n) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
 200
 201 /* convert section header array index to section number */
 202 #define SHNUM(i) \
 203     ((i) < SHN_LORESERVE ? (i) : (i) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
 204
 205 AROS_LH3(void, KrnRegisterModule,
 206                 AROS_LHA(const char *,          name, A0),
 207                 AROS_LHA(struct sheader *,      sections, A1),
 208                 AROS_LHA(struct elfheader *,eh, A2),
 209                 struct KernelBase *, KernelBase, 11, Kernel)
 210 {
 211         AROS_LIBFUNC_INIT
 212
 213         struct ExecBase *SysBase = getSysBase();
 214
 215         if (name && sections && eh)
 216         {
 217                 module_t *mod = AllocVec(sizeof(module_t), MEMF_PUBLIC | MEMF_CLEAR);
 218
 219                 if (mod)
 220                 {
 221                         int i;
 222
 223 //                      D(bug("[KRN] KrnRegisterModule('%s', %08x, %d)\n", name, sections, eh->int_shnum));
 224
 225                         mod->m_name = AllocVec(strlen(name)+1, MEMF_PUBLIC | MEMF_CLEAR);
 226                         strcpy(mod->m_name, name);
 227
 228                         NEWLIST(&mod->m_symbols);
 229
 230                         mod->m_lowest = 0xffffffff;
 231                         mod->m_highest = 0;
 232
 233                         for (i=0; i < eh->int_shnum; i++)
 234                         {
 235                                 /* If we have string table, copy it */
 236                                 if (sections[i].type == SHT_STRTAB && i != SHINDEX(eh->int_shstrndx))
 237                                 {
 238 //                                      D(bug("[KRN]  symbol table of length %d in section %d\n", sections[i].size, i));
 239
 240                                         if (!mod->m_str)
 241                                         {
 242                                                 mod->m_str = AllocVec(sections[i].size, MEMF_PUBLIC | MEMF_CLEAR);
 243                                                 CopyMem(sections[i].addr, mod->m_str, sections[i].size);
 244                                         }
 245                                 }
 246
 247                                 if ((sections[i].flags & (SHF_ALLOC | SHF_EXECINSTR)) == (SHF_ALLOC | SHF_EXECINSTR))
 248                                 {
 249                                         if (sections[i].addr)
 250                                         {
 251                                                 if (sections[i].addr < mod->m_lowest)
 252                                                         mod->m_lowest = sections[i].addr;
 253                                                 if (sections[i].addr + sections[i].size > mod->m_highest)
 254                                                         mod->m_highest = sections[i].addr + sections[i].size;
 255                                         }
 256                                 }
 257                         }
 258
 259                         for (i=0; i < eh->int_shnum; i++)
 260                         {
 261                                 if (sections[i].addr && sections[i].type == SHT_SYMTAB)
 262                                 {
 263                                         int j;
 264                                         struct symbol *st = (struct symbol *)sections[i].addr;
 265
 266                                         for (j=0; j < (sections[i].size / sizeof(struct symbol)); j++)
 267                                         {
 268                                                 if (st[j].shindex != SHN_XINDEX)
 269                                                 {
 270                                                         if (sections[st[j].shindex].addr && (sections[st[j].shindex].flags & (SHF_ALLOC | SHF_EXECINSTR)) == (SHF_ALLOC | SHF_EXECINSTR))
 271                                                         {
 272                                                                 symbol_t *sym = AllocVec(sizeof(symbol_t), MEMF_PUBLIC | MEMF_CLEAR);
 273                                                                 sym->s_name = &mod->m_str[st[j].name];
 274                                                                 sym->s_lowest = sections[st[j].shindex].addr + st[j].value;
 275                                                                 sym->s_highest = sym->s_lowest + st[j].size;
 276
 277                                         //                      D(bug("[KRN]  Adding symbol '%s' %08x-%08x\n", sym->s_name, sym->s_lowest, sym->s_highest-1));
 278
 279                                                                 AddHead(&mod->m_symbols, sym);
 280                                                         }
 281                                                 }
 282                                         }
 283
 284                                         break;
 285                                 }
 286                         }
 287
 288 //                      D(bug("[KRN]  address range %08x - %08x\n", mod->m_lowest, mod->m_highest-1));
 289
 290
 291
 292                         AddHead(&KernelBase->kb_Modules, mod);
 293                 }
 294         }
 295
 296         AROS_LIBFUNC_EXIT
 297 }
 298
 299 AROS_LH1(void, KrnUnregisterModule,
 300                 AROS_LHA(void *,                address, A0),
 301                 struct KernelBase *, KernelBase, 11, Kernel)
 302 {
 303         AROS_LIBFUNC_INIT
 304
 305         struct ExecBase *SysBase = getSysBase();
 306         module_t *mod;
 307         intptr_t addr = (intptr_t)address;
 308
 309         ForeachNode(&KernelBase->kb_Modules, mod)
 310         {
 311                 if (mod->m_lowest <= addr && mod->m_highest > addr)
 312                 {
 313                         symbol_t *sym;
 314
 315                         Remove(mod);
 316
 317                         if (mod->m_str)
 318                                 FreeVec(mod->m_str);
 319                         if (mod->m_name)
 320                                 FreeVec(mod->m_name);
 321
 322                         while(sym = RemHead(&mod->m_symbols))
 323                         {
 324                                 FreeVec(sym);
 325                         }
 326
 327                         FreeVec(mod);
 328
 329                         break;
 330                 }
 331         }
 332
 333         AROS_LIBFUNC_EXIT
 334 }
 335
 336 extern module_t *modlist;
 337 extern uint32_t modlength;
 338
 339 uint32_t findNames(intptr_t addr, char **module, char **function)
 340 {
 341         struct KernelBase *KernelBase = getKernelBase();
 342         module_t *mod;
 343         symbol_t *sym;
 344         uint32_t offset = 0;
 345
 346         *module = NULL;
 347         *function = NULL;
 348
 349         ForeachNode(&KernelBase->kb_Modules, mod)
 350         {
 351                 /* if address suits the module bounds, you got it */
 352                 if (mod->m_lowest <= addr && mod->m_highest > addr)
 353                 {
 354                         *module = mod->m_name;
 355                         offset = addr - mod->m_lowest;
 356
 357                         ForeachNode(&mod->m_symbols, sym)
 358                         {
 359                                 if (sym->s_lowest <= addr && sym->s_highest > addr)
 360                                 {
 361                                         offset = addr - sym->s_lowest;
 362                                         *function = sym->s_name;
 363                                         break;
 364                                 }
 365                         }
 366
 367                         break;
 368                 }
 369         }
 370
 371         /* module unset? then look through the kernel list */
 372         if (*module == NULL)
 373         {
 374                 int i;
 375                 for (i=0; i < modlength; i++)
 376                 {
 377                         if (modlist[i].m_lowest <= addr && modlist[i].m_highest > addr)
 378                         {
 379                                 *module = modlist[i].m_name;
 380                                 offset = addr - modlist[i].m_lowest;
 381
 382                                 ForeachNode(&modlist[i].m_symbols, sym)
 383                                 {
 384                                         if (sym->s_lowest <= addr && sym->s_highest > addr)
 385                                         {
 386                                                 offset = addr - sym->s_lowest;
 387                                                 *function = sym->s_name;
 388                                                 break;
 389                                         }
 390                                 }
 391
 392                                 break;
 393                         }
 394                 }
 395         }
 396
 397         return offset;
 398 }