src/module/elf.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                             *
************************************************************
*       elf.cpp, version 1.3                               *
************************************************************
*                                                          *
*some support for the executable and linkable format.      *
*                                                          *
*30'05'04- forked from the old 0.o5 branch (1.3)           *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/blist.hpp"
#include "src/tty/teletype.hpp"
#include "src/memory/heap.hpp"
#include "src/memory/memset.hpp"
#include "src/module/elf.hpp"
// #include "LINKER/cpprtl.hpp"
// #include "LINKER/teletype.hpp"
// #include "LINKER/debug.hpp"
// #include "LINKER/MM/memheap.hpp"
// #include "LINKER/linker.hpp"
// #include "LINKER/blist.hpp"
// #include "LINKER/MODS/syms.hpp"
// #include "LINKER/MODS/elf.hpp"


/*=======================================CLASS MANAGEMENT===================================*/
// /*init*/
// elf_t::elf_t()
//  {
// /*there's no image at the moment*/
//      image = (char*) NULL;
//      ehdr = (Elf32_ehdr*) NULL;
//      size = 0;
//      valid = 0;
//  }
// 
// /*init and set ptr to data*/
// elf_t::elf_t(char *ptr, uint32 sze)
//  {
// /*init*/
//      set(ptr, sze);
//  }

/*init and set ptr to data*/
void elf_t::init(char *ptr, uint32 sze)
 {
/*set the info about the image*/
        image = ptr;
        size = sze;
        ehdr = (Elf32_ehdr*) image;

/*check validity*/
        valid = ident();
 }

/*set custom ehdr*/
void elf_t::set_ehdr(Elf32_ehdr *_ehdr, uint32 sze)
 {
/* clear */
        memset(this,0,sizeof(elf_t));
/*just set the ehdr variable*/
        ehdr = _ehdr;
        size = sze;

/*check validity*/
        valid = ident();
 }

// /*done.*/
// elf_t::~elf_t()
//  {
// /*done*/
//      done();
//  }

/*done.*/
void elf_t::done() {
        memset(this,0,sizeof(elf_t));
 }

/*check elf validity*/
char elf_t::ident()
 {
const uint32 NON_VALID = 0;
const uint32 VALID = 1;

/*check for size - if is smaller than a full ehdr, it is nonvalid*/
        if (size < sizeof(Elf32_ehdr)) return NON_VALID;

/*check magic key for 'ELF'*/
        if (ehdr -> e_ident[0] != 0x7F) return NON_VALID;
        if (ehdr -> e_ident[1] != 'E' ) return NON_VALID;
        if (ehdr -> e_ident[2] != 'L' ) return NON_VALID;
        if (ehdr -> e_ident[3] != 'F' ) return NON_VALID;

/*check architecture*/
        if (ehdr -> e_machine != EM_386) return NON_VALID;

/*check class for ELFCLASS32*/
        if (ehdr -> e_ident[EI_CLASS] != ELFCLASS32) return NON_VALID;

/*check endianness for ELFDATA2LSB*/
        if (ehdr -> e_ident[EI_DATA] != ELFDATA2LSB) return NON_VALID;

/*check elf header version*/
        if (ehdr -> e_ident[EI_VERSION] != EV_CURRENT) return NON_VALID;
        if (ehdr -> e_version != EV_CURRENT) return NON_VALID;


/*if the image passed all those tests, the image is a valid
        Executable and Linkable Format module.*/
        return VALID;
 }

/*========================================DATA TYPES=======================================*/

/*returns pointer to a section header, if exists*/
Elf32_shdr *elf_t::section(uint32 n)
 {
/*check validity*/
        if (valid == 0) return (Elf32_shdr*) NULL;

/*check if such a section exists*/
        if (ehdr->e_shnum <= n) return (Elf32_shdr*) NULL;

/*return the pointer*/
        return (Elf32_shdr*)
                                ((uint32) image +       /*the image's start point*/
                                ehdr->e_shoff +         /*the start of the section header table (relocatable)*/
                                ehdr->e_shentsize * n); /*the offset of the section header in the table*/
 }

/*returns pointer to a section, if exists*/
void *elf_t::sect_addr(uint32 n)
 {
Elf32_shdr *s = section(n);
uint32 ret;
/*check validity*/
        if (!s)
                return NULL;
/*check module type*/
        if (ehdr->e_type == ET_REL)
                ret = ((uint32)image+           /*image in memory*/
                                        s->sh_offset);  /*section offset (relocatables)*/
        else
                ret = ((uint32)image+           /*image in memory*/
                                        s->sh_addr);            /*section offset (executables)*/

/*return*/
        return (void*)ret;
 }

/*returns pointer to a program header, if exists*/
Elf32_phdr *elf_t::segment(uint32 n)
 {
/*check validity*/
        if (valid == 0) return NULL;

/*check if such a segment exists*/
        if (ehdr->e_phnum <= n) return NULL;

/*return the pointer*/
        return (Elf32_phdr*)
                                ((uint32) image +       /*the image's start point*/
                                ehdr->e_phoff +         /*the start of the program header table*/
                                ehdr->e_phentsize * n); /*the offset of the program header in the table*/
 }

/*returns pointer to a segment, if exists*/
void *elf_t::segm_addr(uint32 n)
 {
Elf32_phdr *segm = segment(n);
        if (segm == NULL)
                return NULL;

        return (void*) ((uint32) image + segm->p_offset);
 }

/*returns pointer to a symtab entry #n in section sect*/
Elf32_sym *elf_t::symbol(uint32 sect, uint32 n)
 {
Elf32_shdr *sc;
        sc = section(sect);

/*check if such a section exists. image validity tested by section()*/
        if (sc == 0) return 0;

/*check symtab section type*/
        if (sc -> sh_type != SHT_SYMTAB) return 0;

/*check symtab section size*/
        if (n >= sc -> sh_size / sc->sh_entsize) return 0;

/*return a pointer*/
        return (Elf32_sym*) ((uint32) sect_addr(sect) + sc->sh_entsize * n);
//      return (Elf32_sym*)((uint32)image +             /*pointer to image*/
//                                              sc -> sh_offset +       /*offset of symtab in image*/
//                                              sc -> sh_entsize * n);/*offset of symbol in table*/
 }

/*returns a pointer to a strtab entry with offset off in section sect*/
char *elf_t::str(uint32 sect, uint32 off)
 {
Elf32_shdr *sc;
        sc = section(sect);

/*check if such a section exists. image validity tested by section()*/
        if (sc == 0) return 0;

/*check strtab section type*/
        if (sc -> sh_type != SHT_STRTAB) return 0;

/*check symtab section size*/
        if (off >= sc -> sh_size) return 0;

/*return a pointer*/
        return off + (char*) sect_addr(sect);
//      return (char*)((uint32)image +          /*pointer to image*/
//                              sc -> sh_offset +       /*offset of strtab in image*/
//                              off);                           /*offset of string in table*/
 }

/*returns a pointer to a rel/rela section entry #n in section sect*/
Elf32_reloc *elf_t::reloc(uint32 sect, uint32 n)
 {
Elf32_shdr *sc;
        sc = section(sect);

/*check if such a section exists. image validity tested by section()*/
        if (sc == 0) return 0;

/*check rel/rela section type*/
        if (sc -> sh_type != SHT_REL)
                if (sc -> sh_type != SHT_RELA)
                                        return 0;

/*check section size*/
        if (n >= sc -> sh_size / sc -> sh_entsize) return 0;

/*return a pointer*/
        return (Elf32_reloc*)((uint32)image +           /*pointer to image*/
                                                sc -> sh_offset +       /*offset of section in image*/
                                                sc->sh_entsize * n);/*offset of string in table*/
 }
// /*
// uint32 xyz;
// /*===========================================SYMS==========================================*/
// /*saves all defined/undefined (defined == [0;1]) symbols with bind_type == sym_bind from this elf to list*/
// uint32 elf_t::save_syms(blist_t *list, uint32 sym_bind, uint32 defined, mod_t *mod)
//  {
// uint32 i, n, val;
// Elf32_shdr *sect;
// Elf32_sym *sym;
// char *ch;
// xyz++;
// /*find the symbol sections*/
//      for (i=0; i<ehdr->e_shnum; i++)
//       {
//              sect = (Elf32_shdr*)((uint32) ehdr->e_shoff + i * ehdr->e_shentsize + (uint32) image);
//      /*check type*/
//              if (sect -> sh_type != SHT_SYMTAB)
//                              continue;
// 
//      /*get each symbol*/
//              for (n=0; n < sect -> sh_size / (sect -> sh_entsize); n++)
//               {
//              /*every 0x28 symbols put a dot*/
//                      if (n - ((n / 0x28) * 0x28) == 0x28 - 1)
//                              kprintf(".");
//              /*the symtab entry analysed*/
//                      sym = (Elf32_sym*)(n * sect -> sh_entsize + (uint32)image);
// 
//              /*whether relocatable/linkable; either sh_addr or sh_offset*/
//                      if (ehdr->e_type == ET_EXEC)
//                              sym = (Elf32_sym*) ((uint32)sym + sect -> sh_addr);     /*executable*/
//                      else
//                              sym = (Elf32_sym*) ((uint32)sym + sect -> sh_offset);/*relocatable*/
// 
//              /*add only defined global symbols to the kernel_syms table*/
//                      if ((defined) ^ (sym -> st_shndx == SHN_UNDEF))
//                              if ((uint32)(sym -> st_info >> 4) == sym_bind) 
//                                      {
//                                      /*the symbol name*/
//                                              ch = (char*) ((Elf32_shdr*) ((uint32) image + (uint32) ehdr->e_shoff + sect -> sh_link * ehdr->e_shentsize));
//                                              if (ehdr->e_type == ET_EXEC)
//                                                      ch = (char*)(((Elf32_shdr*) ch) -> sh_addr);    /*executable*/
//                                              else
//                                                      ch = (char*)(((Elf32_shdr*) ch) -> sh_offset);  /*relocatable*/
//                                              ch = (char*)((uint32)ch + sym->st_name + (uint32) image);
//                                      /*the symbol value*/
//                                              val = sym -> st_value;
//                              /*the symbol's address may need to be fixed by the section's addr in memory for reloc modules*/
//                                              if (ehdr -> e_type == ET_REL)
//                                                      val+=(uint32)sect_addr(sym->st_shndx);
//                                      /*add to list*/
//                                              add_sym(list, ch, val, mod, sym, sect);
//                                      }
//               }
//       }
// 
// /*return success*/
//      return DEF_SUCCESS;
//  }
// 
// /*perform relocations indicitated by rel/rela sections*/
// void elf_t::relocate()
//  {
// uint32 i, n;
// Elf32_shdr *sect;
// Elf32_reloc *reloc;
// 
// /*check validity*/
//      if (!valid)
//              return;
// 
// /*check each section*/
//      for (i=0; i<ehdr->e_shnum;i++)
//       {
//      /*get section addr*/
//              sect = section(i);
//      /*check if is a reloc section*/
//              if (sect -> sh_type != SHT_REL)
//                      if (sect -> sh_type != SHT_RELA)
//                              continue;
//      /*check each reltab entry*/
//              for (n=0; n<(sect -> sh_size) / (sect -> sh_entsize); n++)
//               {
//              /*relocation entry*/
//                      reloc = (Elf32_reloc*) ((uint32)sect_addr(i) + n * sect -> sh_entsize);
//              /*now, relocate entry*/
//                      do_elf_reloc(reloc, sect);
//               }
//       }
//  }
// 
// /*perform relocations indicitated by rel/rela sections for symtab entry sym*/
// void elf_t::un_reloc(Elf32_sym *sym)
//  {
// uint32 i, n;
// Elf32_shdr *sect;
// Elf32_reloc *reloc;
// Elf32_shdr *symtab;
// Elf32_sym *symb;
// 
// /*check validity*/
//      if (!valid)
//              return;
// 
// /*check each section*/
//      for (i=0; i<ehdr->e_shnum;i++)
//       {
//      /*get section addr*/
//              sect = section(i);
//      /*check if is a reloc section*/
//              if (sect -> sh_type != SHT_REL)
//                      if (sect -> sh_type != SHT_RELA)
//                              continue;
//      /*check each reltab entry*/
//              for (n=0; n<(sect -> sh_size) / (sect -> sh_entsize); n++)
//               {
//              /*relocation entry*/
//                      reloc = (Elf32_reloc*) ((uint32)sect_addr(i) + n * sect -> sh_entsize);
//              /*the symtab connected with the relocation entry*/
//                      symtab = section(sect -> sh_link);
//              /*and the appropriate symtab entry*/
//                      symb = (Elf32_sym*)(
//                                      (uint32) sect_addr(sect->sh_link)+
//                                      symtab -> sh_entsize * reloc -> r_symtabndx);/*entry #(reloc->r_symtabndx) in the table*/
//              /*check if this is the sym*/
//                      if (symb != sym)
//                              continue;
// 
//              /*now, unreloc entry*/
//                      undo_elf_reloc(reloc, sect);
//               }
//       }
//  }
// 
// /*perform relocations indicitated by rel/rela sections for symtab entry sym*/
// void elf_t::relocate(Elf32_sym *sym)
//  {
// uint32 i, n;
// Elf32_shdr *sect;
// Elf32_reloc *reloc;
// Elf32_shdr *symtab;
// Elf32_sym *symb;
// 
// /*check validity*/
//      if (!valid)
//              return;
// 
// /*check each section*/
//      for (i=0; i<ehdr->e_shnum;i++)
//       {
//      /*get section addr*/
//              sect = section(i);
//      /*check if is a reloc section*/
//              if (sect -> sh_type != SHT_REL)
//                      if (sect -> sh_type != SHT_RELA)
//                              continue;
//      /*check each reltab entry*/
//              for (n=0; n<(sect -> sh_size) / (sect -> sh_entsize); n++)
//               {
//              /*relocation entry*/
//                      reloc = (Elf32_reloc*) ((uint32)sect_addr(i) + n * sect -> sh_entsize);
//              /*the symtab connected with the relocation entry*/
//                      symtab = section(sect -> sh_link);
//              /*and the appropriate symtab entry*/
//                      symb = (Elf32_sym*)(
//                                      (uint32) sect_addr(sect->sh_link)+
//                                      symtab -> sh_entsize * reloc -> r_symtabndx);/*entry #(reloc->r_symtabndx) in the table*/
//              /*check if this is the sym*/
//                      if (symb != sym)
//                              continue;
// 
//              /*now, unreloc entry*/
//                      do_elf_reloc(reloc, sect);
//               }
//       }
//  }
// 
// /*perform single relocation*/
// void elf_t::do_elf_reloc(Elf32_reloc *reloc, Elf32_shdr *sect)
//  {
// uint32 *relocated_element;
// uint32 addend;
// Elf32_shdr *symtab;
// Elf32_sym *sym;
// 
// /*the symtab connected with the relocation entry*/
//      symtab = section(sect -> sh_link);
// /*and the appropriate symtab entry*/
//      sym = (Elf32_sym*)(
//                      (uint32) sect_addr(sect->sh_link)+
//                      symtab -> sh_entsize * reloc -> r_symtabndx);/*entry #(reloc->r_symtabndx) in the table*/
// 
// /*create a pointer to the relocated object*/
//      relocated_element = (uint32*) (
//              (uint32) sect_addr(sect->sh_info) +
//              reloc->r_addr);                 /*offset in the section*/
// 
// /*save the addend's value which depends on section type*/
//      if (sect -> sh_type == SHT_REL)
//              addend = *relocated_element;    /*the addend's already there*/
//      else    /*RELA*/
//              addend = reloc -> r_addend;
//  
// /*all freshly bound symbols have SHN_UNDEF st_shndx so we can adjust the symbol value*/
//      if (sym ->st_shndx == SHN_UNDEF)
//       {
//              sym -> st_value -= (uint32) relocated_element - reloc->r_addr;
//      /*we should not fix the value twice, if it was referenced twice*/
//              sym -> st_shndx = sect -> sh_info;
//       }
// 
// /*now relocate the element. check the relocation type*/
//      switch (reloc -> r_type)
//       {
//              /*S + A*/
//              case R_386_32:
//                      *relocated_element =
//                              addend +                        /* +Addend*/
//                              sym -> st_value +       /* +Value*/
//                              (uint32) sect_addr(sect->sh_info);/* +the section's address in memory (aka the rest of the Value)*/
//                      /*check if the symbol's section is the same as the relocated section.
//                      if not, we have to fix the element with the difference*/
//                      *relocated_element-=
//                              (uint32)sect_addr(sect->sh_info) -      /*the relocated section*/
//                              (uint32)sect_addr(sym->st_shndx);       /*the symbol's section*/
//                      break;
//              /*S + A - P*/
//              case R_386_PC32:
//                      *relocated_element = 
//                              addend +                        /* +Addend*/
//                              sym -> st_value -       /* +Value*/
//                              reloc->r_addr;          /* -Position*/
//                      break;
//       };
//  }
// 
// /*delete old relocation*/
// void elf_t::undo_elf_reloc(Elf32_reloc *reloc, Elf32_shdr *sect)
//  {
// uint32 *relocated_element;
// Elf32_shdr *symtab;
// Elf32_sym *sym;
// 
// /*the symtab connected with the relocation entry*/
//      symtab = section(sect -> sh_link);
// /*and the appropriate symtab entry*/
//      sym = (Elf32_sym*)(
//                      (uint32) sect_addr(sect->sh_link)+
//                      symtab -> sh_entsize * reloc -> r_symtabndx);/*entry #(reloc->r_symtabndx) in the table*/
// 
// /*create a pointer to the relocated object*/
//      relocated_element = (uint32*) (
//              (uint32) sect_addr(sect->sh_info) +
//              reloc->r_addr);                 /*offset in the section*/
// 
// /*all freshly bound symbols have SHN_UNDEF st_shndx so we can adjust the symbol value*/
//      if (sym ->st_shndx == SHN_UNDEF)
//       {
//              sym -> st_value -= (uint32) relocated_element - reloc->r_addr;
//      /*we should not fix the value twice, if it was referenced twice*/
//              sym -> st_shndx = sect -> sh_info;
//       }
// 
// /*now un-relocate the element. check the relocation type. after this *relocated_element will be equal to the addend*/
//      switch (reloc -> r_type)
//       {
//              /*S + A*/
//              case R_386_32:
//                      *relocated_element =
//                              *relocated_element - 
//                              sym -> st_value -       /* +Value*/
//                              (uint32) sect_addr(sect->sh_info);/* +the section's address in memory (aka the rest of the Value)*/
//                      /*check if the symbol's section is the same as the relocated section.
//                      if not, we have to fix the element with the difference*/
//                      *relocated_element+=
//                              (uint32)sect_addr(sect->sh_info) -      /*the relocated section*/
//                              (uint32)sect_addr(sym->st_shndx);       /*the symbol's section*/
//                      break;
//              /*S + A - P*/
//              case R_386_PC32:
//                      *relocated_element =
//                              *relocated_element - 
//                              sym -> st_value +       /* +Value*/
//                              reloc->r_addr;          /* -Position*/
//                      break;
//       };
//  }*/

/*===========================================MISC==========================================*/
/*create a header*/
int create_ehdr(Elf32_ehdr *ehdr, uint32 shnum,
        Elf32_shdr *shaddr, uint32 shentsize, uint32 shstrndx, uint32 e_type)
 {
/*put identification data*/
        /*magic*/
        ehdr -> e_ident[0] = 0x7F;
        ehdr -> e_ident[1] = 'E';
        ehdr -> e_ident[2] = 'L';
        ehdr -> e_ident[3] = 'F';
        /*architecture*/
        ehdr -> e_machine = EM_386;
        /*class for ELFCLASS32*/
        ehdr -> e_ident[EI_CLASS] = ELFCLASS32;
        /*endianness for ELFDATA2LSB*/
        ehdr -> e_ident[EI_DATA] = ELFDATA2LSB;
        /*elf header version*/
        ehdr -> e_ident[EI_VERSION] = EV_CURRENT;
        ehdr -> e_version = EV_CURRENT;

/*fill in custom data*/
        ehdr->e_shnum = shnum;  /*section header count*/
        ehdr->e_shoff = (uint32) shaddr;        /*offset of section header*/
        ehdr->e_shentsize = shentsize;  /*shentry size*/
        ehdr->e_shstrndx = shstrndx;    /*strtab for section names*/
        ehdr->e_type = e_type;          /*file type*/

/*return value*/
        return ESUCCESS;
 }

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

---