src/module/coresyms.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       coresyms.cpp, version 1.0                          *
************************************************************
*                                                          *
*here we see all the core symbols so we can use them for,  *
*eg. call backtracing.                                     *
*                                                          *
*30'05'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/qsort.hpp"
#include "src/mboot.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/module/elf.hpp"
#include "src/module/coresyms.hpp"

namespace Syms {


//caution: this will work only if one symtab exists.
struct Elf32_sym *core_syms=NULL;       //all of the coresyms, sorted by address
uint32 syms_count;              //how many syms
uint32 syms_size;               //a single element's size
char *core_syms_str;            //their names
// int elo_yo(uint32 i);

//init the list of kernel syms
void init()
 {_Pf("Syms::init");
Mboot::mboot_sht *syms;
elf_t elf;
Elf32_ehdr ehdr;
uint32 i;
Elf32_shdr *sect;
size_t symtab_addr;
//get the syms info
        syms= Mboot::mboot_syms();
        if (syms==NULL)
                sysfail("failed to collect symbol info: mboot_sht not availlable");
//create a bookkeeping unit
        create_ehdr(&ehdr, syms->num, (Elf32_shdr*) syms->addr,
                syms->entry_size, syms->shndx, ET_EXEC);
        elf.set_ehdr(&ehdr, mem_ksize);
//find the symbol section
        for (i=0;i<syms->num;i++)
                { sect=elf.section(i); if (sect->sh_type == SHT_SYMTAB) break; }
//check if one was found
        if (sect->sh_type != SHT_SYMTAB)
                sysfail("failed to collect symbol info: no symtab found");
//save the symtab info
        core_syms=(Elf32_sym*)Memory::Heap::heap0.malloc(sect->sh_size, NO_ALIGN, FAC_SYMS|FAC_SYMTAB, NULL);
        if (core_syms == NULL)
                sysfail("failed to collect symbol info: out of memory");
        symtab_addr=sect->sh_addr + mem_kernel_start - mem_physical;//change from phys to virt
        memmove(core_syms, (void*)symtab_addr, sect->sh_size);
        syms_size=sect->sh_entsize;
        syms_count=sect->sh_size / syms_size;
//strtab
        core_syms_str=(char*)elf.sect_addr(sect -> sh_link) + mem_kernel_start-mem_physical;
        if (core_syms_str==NULL)
                sysfail("failed to collect symbol info: no strtab found");

//sort by adresses
        qsort(core_syms, syms_count, syms_size, &symscompar, NULL);

        Preturn();
 }

//compare by addr
int symscompar(const void *a, const void *b)
 { _Pf("Syms::symscompar");
uint32 A, B;
        A= ((Elf32_sym*)a)-> st_value;
        B= ((Elf32_sym*)b)-> st_value;

        if (A>B)
                preturn( 1);
        if (A<B)
                preturn( -1);
        preturn( 0);
 }

//return the most possible guess of the symbol's name at addr
char *sym_name(uint32 addr, int sym_type)
 {
Elf32_sym *sym;
Elf32_sym *guess=NULL;
        if (core_syms == NULL)
                return NULL;
        for (sym=core_syms;sym; sym=(Elf32_sym*)((uint32)sym + syms_size))
         {
                if (sym->st_value > addr)
                        break;
        //check type
                if (ELF32_ST_TYPE(sym->st_info) == sym_type)
        //and bind.. for global/weak
                if (((uint32)ELF32_ST_BIND(sym->st_info) == STB_GLOBAL ) ||
                ((uint32)ELF32_ST_BIND(sym->st_info) == STB_WEAK ))
                        guess=sym;
         }
        if (!guess)
                return NULL;
        return core_syms_str+guess->st_name;
 }

//get the name
char *sym_name(Elf32_sym *sym) {
        return core_syms_str+sym->st_name;
 }



 };     /* namespace Syms */
 
/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---