WebSVN - shark - Rev 1618 - /shark/branches/xen/ports/dynalink/elf.c

////////////////////////////////////////////////////////////////////////
// elf.c
//
// DynaLink for S.H.A.R.K
// Dynamic ELF object linker.
//
// Original code written by Luca Abeni.
// Adapted by Lex Nahumury 19-7-2006.
//
// This is free software; see GPL.txt
////////////////////////////////////////////////////////////////////////
#include "kernel/kern.h"
#include <kernel/func.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>

#include <ll/i386/hw-data.h>
#include <ll/i386/mem.h>
#include <ll/i386/hw-instr.h>
#include <ll/i386/cons.h>
#include <ll/i386/error.h>
#include <ll/i386/mem.h>
#include <ll/ctype.h>
#include <ll/i386/x-bios.h>

#include "format.h"
#include "elf.h"

//#define __ELF_DEBUG__

char elf_signature[] = "\177ELF";

DWORD ELF_read_headers( struct file_ops *kf,
struct table_info *tables)
{
//printk("ELF_read_headers\n");
int res;

DWORD entry;
struct elf_header header;
struct elf_section_header h;

kf->file_seek(kf->file_offset + 0, kf->seek_set);
kf->file_read(&header, sizeof(struct elf_header));

if (memcmp(header.e_ident, elf_signature, 4)) {
printk("Not an ELF file\n");
printk("Wrong signature: 0x%lx)!!!\n",
*(DWORD *)header.e_ident);
return 0;
}
//printk("ELF signature OK\n");

tables->flags = 0;
if (header.e_ident[4] != ELFCLASS32) {
printk("Wrong ELF class\n");
printk("Class: 0x%x!!!\n", header.e_ident[4]);
return 0;
}
//printk("ELF Class OK\n");

if (header.e_ident[5] != ELFDATA2LSB) {
printk("Wrong data ordering (not LSB)\n");
printk("Ordering: 0x%x!!!\n", header.e_ident[5]);
return 0;
}
//printk("ELF data ordering OK\n");

#ifdef __ELF_DEBUG__
if(header.e_machine != EM_386)
{
printk("Warning: machine = 0x%x!!!\n", header.e_machine);
}
#endif
//printk("ELF Type: 0x%x\n", header.e_type);

if(header.e_shoff != 0)
{
#ifdef __ELF_DEBUG__
printk("Section headers @ %ld\n", header.e_shoff);
printk("Number of sections: %d\n", header.e_shnum);
printk("Section header size: %d (0x%x)\n",
header.e_shentsize, header.e_shentsize);
#endif
tables->section_header = header.e_shoff;
tables->section_header_size = header.e_shentsize;
tables->num_sections = header.e_shnum;
}

#ifdef __ELF_DEBUG__
if (header.e_phoff != 0) {
printk("Program header table @ %ld\n", header.e_phoff);
printk("Number of segments: %d\n", header.e_phnum);
printk("Segment header size: %d (0x%x)\n",
header.e_phentsize, header.e_phentsize);
}

#ifdef __ELF_DEBUG__
/* Flags... */
/* RELOCATION */
if (header.f_flags & F_RELFLG) {
printk("No relocation info!\n");
}

if (header.f_flags & F_EXEC) {
printk("Executable file (no unresolved symbols)\n");
}

if (header.f_flags & F_LNNO) {
printk("No line numbers!\n");
}

if (header.f_flags & F_LSYMS) {
printk("No local symbols!\n");
}

if (header.f_flags & F_AR32WR) {
printk("32-bit little endian!\n");
} else {
printk("File type?\n");
}
#endif

printk("Section Name String Table is section number %d\n",
header.e_shstrndx);
#endif
if (header.e_shstrndx > tables->num_sections)
{
printk("Error: SNST number > section number...\n");
return 0;
}

res = kf->file_seek( kf->file_offset + tables->section_header +
header.e_shstrndx * tables->section_header_size,
kf->seek_set);
if (res < 0) {
printk("Cannot seek");
return 0;
}
//printk("ELF file seek OK\n");

res = kf->file_read( &h, sizeof(struct elf_section_header));
if (res < 0) {
printk("Cannot read");
return 0;
}
//printk("ELF file read OK\n");

tables->section_names = 0;
if(h.sh_size != 0)
{
//printk("ELF Loading Section Names...\n");

tables->section_names = (void *)malloc(h.sh_size);
if (tables->section_names == NULL)
{
printk("Failed to allocate space for section names...\n");
return 0;
}

res = kf->file_seek( kf->file_offset + h.sh_offset, kf->seek_set);
if (res < 0) {
printk("Cannot seek");
return 0;
}
res = kf->file_read( tables->section_names, h.sh_size);
if (res < 0) {
printk("Cannot read");
return 0;
}
tables->section_names_size = h.sh_size;
}
else
{
printk("0 size?\n");
tables->section_names_size = 0;
}

entry = header.e_entry;
if (entry == 0) {
tables->flags |= NO_ENTRY;
tables->flags |= NEED_LOAD_RELOCATABLE;
tables->flags |= NEED_SECTION_RELOCATION;
}
//printk("ELF Read headers Done!\n");
return entry;
};

int ELF_read_section_headers(struct file_ops *kf,
struct table_info *tables,
struct section_info *scndata)
{

int bss = -1;
int i, j;
struct elf_section_header h;
int header_size;
int stringtable = -1;
struct elf_rel_info r;

header_size = tables->section_header_size;
if(header_size > sizeof(struct elf_section_header))
{
printk("Section header size (%d) > sizeof(struct section_header) (%d)\n",
header_size, (int)(sizeof(struct elf_section_header)) );

header_size = sizeof(struct elf_section_header);
}

for (i = 0; i < tables->num_sections; i++)
{
kf->file_seek( kf->file_offset + tables->section_header +
i * tables->section_header_size, kf->seek_set);
kf->file_read( &h, sizeof(struct elf_section_header));

#ifdef __ELF_DEBUG__
printk("Section %d: ", i);
printk("Flags 0x%x: \n", h.sh_flags);
#endif
/*
Set this stuff to 0...
If size == 0 the section must not be loaded
*/
scndata[i].num_reloc = 0;
scndata[i].base = 0;
scndata[i].size = 0;
scndata[i].fileptr = 0;
scndata[i].filesize = 0;

/* If this is a NULL section, skip it!!! */
if (h.sh_type != SHT_NULL) {
if (tables->section_names != 0) {
#ifdef __ELF_DEBUG__
printk("[%s]", tables->section_names + h.sh_name);
#endif
if (strcmp(tables->section_names + h.sh_name, ".bss") == 0) {
bss = i;
}
}
#ifdef __ELF_DEBUG__
printk(" <0x%lx:0x%lx> (0x%lx)\n",
h.sh_addr,
h.sh_addr + h.sh_size,
h.sh_offset);
#endif

if (h.sh_type == SHT_REL) {
#ifdef __ELF_DEBUG__
printk("\t\tSection %d: relocation info!!!\n", i);
printk("\t\tSymbol table: section number %lu\n", h.sh_link);
printk("\t\tSection to modify: %lu\n", h.sh_info);
printk("\t\tNumber of relocation entries: %lu\n",
h.sh_size / h.sh_entsize);
#endif
if (scndata[h.sh_info].num_reloc != 0) {
printk("Double relocation for section\n");
printk("%lu?\n", h.sh_info);
return 0;
}
/* So, ...let's load it!!! */
scndata[h.sh_info].num_reloc = h.sh_size / h.sh_entsize;
//scndata[h.sh_info].reloc = (void *)kf->mem_alloc((h.sh_size / h.sh_entsize) * sizeof(struct reloc_info));
scndata[h.sh_info].reloc = (void *)malloc((h.sh_size / h.sh_entsize) * sizeof(struct reloc_info));
if (scndata[h.sh_info].reloc == NULL) {
printk("Failed to allocate space for relocation info...\n");
return 0;
}
//printk("ELF Allocate space for relocation info OK!\n");

for (j = 0; j < h.sh_size / h.sh_entsize; j++) {
kf->file_seek( kf->file_offset + h.sh_offset + j * h.sh_entsize,
kf->seek_set);
kf->file_read( &r, sizeof(struct elf_rel_info));
scndata[h.sh_info].reloc[j].offset = r.r_offset;
scndata[h.sh_info].reloc[j].symbol = r.r_info >> 8;
/* HACKME!!! Unify the relocation types... */
scndata[h.sh_info].reloc[j].type = (BYTE)r.r_info;
if ((BYTE)r.r_info == R_386_32){
scndata[h.sh_info].reloc[j].type = REL_TYPE_ELF_ABSOLUTE;
} else if ((BYTE)r.r_info == R_386_PC32) {
scndata[h.sh_info].reloc[j].type = REL_TYPE_RELATIVE;
}
}
} else if (h.sh_type == SHT_RELA) {
printk("Error: unsupported relocation section!!!\n");

return 0;
} else if ((h.sh_type == SHT_SYMTAB) || (h.sh_type == SHT_DYNSYM)) {
#ifdef __ELF_DEBUG__
printk("\t\tSection %d: symbol table!!!\n", i);
printk("\t\tString table: section number %lu\n", h.sh_link);
printk("\t\tLast local Symbol + 1: %lu\n", h.sh_info);
#endif
tables->symbol = h.sh_offset;
tables->num_symbols = h.sh_size / h.sh_entsize;
tables->symbol_size = h.sh_size;
if (stringtable != -1) {
printk("Error: double string table!!!\n");
return 0;
}
stringtable = h.sh_link;
if (stringtable < i) {
printk("Strange... ");
printk("String table (%d) < Symbol Table\n", stringtable);
return 0;
}
} else if (i == stringtable) {
#ifdef __ELF_DEBUG__
printk("\t\t Section %d: string table!!!\n", i);
#endif
tables->string = h.sh_offset;
tables->string_size = h.sh_size;
stringtable = -1;
} else {
scndata[i].base = h.sh_addr;
scndata[i].size = h.sh_size;
scndata[i].fileptr = h.sh_offset;
if (h.sh_type != SHT_NOBITS) {
#ifdef __ELF_DEBUG__
printk("BSS?\n");
#endif
scndata[i].filesize = h.sh_size;
}
}
} else {
#ifdef __ELF_DEBUG__
printk("NULL Section\n");
#endif
}

#if 0
if (h.s_flags & SECT_TEXT) {
printk("Executable section\n");
}
if (h.s_flags & SECT_INIT_DATA) {
printk("Data section\n");
}
if (h.s_flags & SECT_UNINIT_DATA) {
printk("BSS section\n");
scndata[i].filesize = 0;
}
#endif
}
tables->image_base = scndata[0].base;
return bss;
};

int ELF_read_symbols(struct file_ops *kf,
struct table_info *tables,
struct symbol_info *syms)
{
//printk("ELF read_symbols\n");

int i;
int entsize;
struct elf_symbol_info symbol;
char *s;

s = (void *)malloc(tables->string_size);
if(s == NULL)
{
printk("Failed to allocate space for string table...\n");
return 0;
}

tables->string_buffer = (DWORD)s;
kf->file_seek( kf->file_offset + tables->string, kf->seek_set);
kf->file_read( s, tables->string_size);

entsize = tables->symbol_size / tables->num_symbols;

for (i = 0; i < tables->num_symbols; i++)
{
kf->file_seek( kf->file_offset + tables->symbol + i * entsize,
kf->seek_set);
kf->file_read( &symbol, sizeof(struct elf_symbol_info));
syms[i].name = s + symbol.st_name;
syms[i].section = symbol.st_shndx;
syms[i].offset = symbol.st_value;

if (syms[i].section == SHN_UNDEF) {
/* extern symbol */
if (symbol.st_name != 0)
syms[i].section = EXTERN_SYMBOL;
else /* Mark the empty entry, external symbol with no name is not used :-) */
syms[i].section = NULL_SYMBOL;
}
if (syms[i].section == SHN_COMMON) {
/* extern symbol */
syms[i].section = COMMON_SYMBOL;
syms[i].offset = symbol.st_size;
/* calculate the local_bss_size */
tables->local_bss_size += syms[i].offset;
}
}

return 1;
};

int Elf_check(struct file_ops *kf)
{
char signature[4];

kf->file_offset = kf->file_seek( 0, kf->seek_cur);
kf->file_read(signature, 4);
kf->file_seek( kf->file_offset + 0, kf->seek_set);

if(memcmp(signature, elf_signature, 4))
{
return 0;
}

return 1;
};

int ELF_relocate_section(struct file_ops *kf,
DWORD base,
struct table_info *tables,
int n,
struct section_info *s,
int sect,
struct symbol_info *syms,
struct symbol *import)
{

int i, idx;
DWORD address, destination;
int j, done;
DWORD local_bss = tables->local_bss;
struct reloc_info *rel = s[sect].reloc;

/* Setup the common space-uninitialized symbols at the first section relocation
* Pre-calculate the local BSS size (in read_symbols)
* then allocate for each symbol (in load_relocatable)
*/

if(sect == 0)
{
for(i=0; i<tables->num_symbols; i++)
{
if(syms[i].section == COMMON_SYMBOL)
{
j = syms[i].offset;
syms[i].offset = local_bss;
local_bss += j;
}
else if(syms[i].section == EXTERN_SYMBOL)
{
#ifdef __ELF_DEBUG__
printk("Searching for symbol %s\n", syms[i].name);
#endif
/* Pre-set the external symbol at the same time */
for(j=0, done=0; import[j].name != 0; j++)
{
if(strcmp(import[j].name, syms[i].name) == 0)
{
syms[i].offset = import[j].address;
done = 1;
break;
}
}
if(done == 0)
{
printk("Symbol %s not found\n", syms[i].name);
return -1;
}

}
}
}

//printk("[COMMON] s[sect].num_reloc = %d\n", s[sect].num_reloc);

for(i=0; i < s[sect].num_reloc; i++)
{
#ifdef __COFF_DEBUG__
printk("Relocate 0x%lx (index 0x%x): mode %d ",
rel[i].offset, rel[i].symbol, rel[i].type);
#endif
idx = rel[i].symbol;

#ifdef __COFF_DEBUG__
printk("%s --> 0x%lx (section %d)\n", syms[idx].name,
syms[idx].offset, syms[idx].section);
#endif

switch (rel[i].type)
{
case REL_TYPE_ELF_ABSOLUTE:
destination = s[sect].base + rel[i].offset + base;
// Initial address
address = *((DWORD*)destination);
break;
case REL_TYPE_RELATIVE:
destination = s[sect].base + rel[i].offset + base;
address = 0;
break;
default:
// (Non-)external symbols: only REL32 is supported
printk("Unsupported relocation!\n");
printk("Relocation Type: %d\n", rel[i].type);
return -1;
}

if(syms[idx].section == COMMON_SYMBOL || syms[idx].section == EXTERN_SYMBOL)
{
if(rel[i].type == REL_TYPE_ELF_ABSOLUTE)
address += syms[idx].offset;

else if(rel[i].type == REL_TYPE_RELATIVE)
address = syms[idx].offset - destination - 4;
}
else if(syms[idx].section >= n)
{
// Check if the section exists ...
printk("Unsupported relocation section\n");
printk("Section %d > %d\n", syms[idx].section, n);
printk("Value 0x%lx\n", syms[idx].offset);
return -1;
}
else
{
if(rel[i].type == REL_TYPE_ELF_ABSOLUTE)
{
address += base + s[syms[idx].section].base + syms[idx].offset;
}
else if(rel[i].type == REL_TYPE_RELATIVE)
{
address = (s[syms[idx].section].base + syms[idx].offset) - (s[sect].base + rel[i].offset) - 4;
#ifdef __COFF_DEBUG__
printk("Reloc: 0x%lx + 0x%lx - 0x%lx = 0x%lx ",
syms[idx].offset,
s[syms[idx].section].base,
rel[i].offset , address);
#endif
}
}

#ifdef __COFF_DEBUG__
printk("0x%lx <--- 0x%lx\n", destination, address);
#endif
*((DWORD*)destination) = address;
}

return 1;
};

/* Import symbol with suffix `name'
* NOTE: Any symbol with prefix `_' won't be found and be regarded as internal and hidden
*/
DWORD ELF_import_symbol(struct file_ops *kf,
int n,
struct symbol_info *syms,
char *name,
int *sect)
{
//printk("[COMMON] import_symbol...\n");

int i;
int len = strlen(name);

for(i = 0; i < n ; i++)
{
#ifdef __COFF_DEBUG__
printk("Checking symbol %d [%d] --- Sect %d\n", i, n, syms[i].section);
#endif
if ((syms[i].section != EXTERN_SYMBOL) && (syms[i].section != COMMON_SYMBOL) && (syms[i].section != NULL_SYMBOL))
{
#ifdef __COFF_DEBUG__
printk("Compare %s, %s\n", syms[i].name, name);
#endif
if(syms[i].name[0] != '_')
{
int sym_len = strlen(syms[i].name);
if(sym_len >= len && strcmp(syms[i].name+sym_len-len, name) == 0)
{
#ifdef __COFF_DEBUG__
printk("Found: %s --- 0x%x : 0x%lx\n",
syms[i].name, syms[i].section, syms[i].offset);
#endif
break;
}
#ifdef __COFF_DEBUG__
else
{
printk("Cmp failed --- Going to %d\n", i);
}
#endif
}
}
#ifdef __COFF_DEBUG__
else
{
printk("Skipped symbol --- Going to %d\n", i);
}
#endif
}

if(i < n)
{ /* Symbol found */
*sect = syms[i].section;
return syms[i].offset;
}
else
{
*sect = -1;
printk("Symbol not found!!!\n");
return 0;
}
};

DWORD ELF_load_relocatable( struct file_ops *kf,
struct table_info *tables,
int n,
struct section_info *s,
DWORD *size)
{
int i;
DWORD needed_mem = 0;
DWORD local_offset = 0;
BYTE *mem_space, *where_to_place;

// Allocate for the local bss at the mean time
for(i=0; i<n; i++)
{
needed_mem += s[i].size;
}
needed_mem += tables->local_bss_size;
mem_space = (BYTE *)malloc(needed_mem);
if(mem_space == NULL)
{
printk("Unable to allocate memory for the program image\n");
return 0;
}
memset(mem_space, 0, needed_mem);

#ifdef __ELF_DEBUG__
printk("Loading relocatable @%p; size 0x%lx\n", mem_space, needed_mem);
#endif

if(tables->local_bss_size != 0)
tables->local_bss = (DWORD)mem_space + needed_mem - tables->local_bss_size;
else
tables->local_bss = 0;

for(i=0; i<n; i++)
{
#ifdef __ELF_DEBUG__
printk("Section %d\t", i);
#endif
if(s[i].size != 0)
{
#ifdef __ELF_DEBUG__
printk("Loading @ 0x%lx (0x%lx + 0x%lx)...\n",
(DWORD)mem_space + (DWORD)local_offset,
(DWORD)mem_space, local_offset);
#endif

where_to_place = mem_space + local_offset;
s[i].base = local_offset;
local_offset += s[i].size;
kf->file_seek( kf->file_offset + s[i].fileptr, kf->seek_set);
if(s[i].filesize > 0)
{
kf->file_read( where_to_place, s[i].filesize);
}
}
else
{
#ifdef __ELF_DEBUG__
printk("Not to be loaded\n");
#endif
}
}

*size = needed_mem;
return (DWORD)mem_space;
};

void ELF_free_tables(struct file_ops *kf,
struct table_info *tables,
struct symbol_info *syms,
struct section_info *scndata)
{
int i;

for(i = 0; i < tables->num_sections; i++)
if (scndata[i].num_reloc != 0)
free( scndata[i].reloc);

free(scndata);
if (syms != NULL) free(syms);
if (tables->string_size != 0) free((DWORD*)tables->string_buffer);
if (tables->section_names_size != 0) free(tables->section_names);
};

Subversion Repositories shark

(root)/shark/branches/xen/ports/dynalink/elf.c - Rev 1618