diff --git a/.cproject b/.cproject index bb8f40f..697a696 100644 --- a/.cproject +++ b/.cproject @@ -24,9 +24,15 @@ + + @@ -38,14 +44,6 @@ - - - - - - diff --git a/.settings/language.settings.xml b/.settings/language.settings.xml index 207fcc1..bfaac99 100644 --- a/.settings/language.settings.xml +++ b/.settings/language.settings.xml @@ -5,7 +5,7 @@ - + diff --git a/sys/i386/i386_exec.c b/sys/i386/i386_exec.c index dbeb76e..6f27c6d 100644 --- a/sys/i386/i386_exec.c +++ b/sys/i386/i386_exec.c @@ -24,6 +24,7 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ +#include #include #include #include @@ -34,9 +35,12 @@ #include #include #include +#include #include #include +#define ENOEXEC -1 + #define AT_NULL 0 /* Terminates the vector. */ #define AT_IGNORE 1 /* Ignored entry. */ #define AT_EXECFD 2 /* File descriptor of program to load. */ @@ -50,6 +54,47 @@ #define AUXARGS_ENTRY(pos, id, val) {*pos = id;pos++; *pos = val;pos++;} +typedef struct elf_file { + int preloaded; /* Was file pre-loaded */ + caddr_t address; /* Relocation address */ + Elf32_Dyn *dynamic; /* Symbol table etc. */ + Elf32_Hashelt nbuckets; /* DT_HASH info */ + Elf32_Hashelt nchains; + const Elf32_Hashelt *buckets; + const Elf32_Hashelt *chains; + caddr_t hash; + caddr_t strtab; /* DT_STRTAB */ + int strsz; /* DT_STRSZ */ + const Elf32_Sym *symtab; /* DT_SYMTAB */ + Elf32_Addr *got; /* DT_PLTGOT */ + const Elf32_Rel *pltrel; /* DT_JMPREL */ + int pltrelsize; /* DT_PLTRELSZ */ + const Elf32_Rela *pltrela; /* DT_JMPREL */ + int pltrelasize; /* DT_PLTRELSZ */ + const Elf32_Rel *rel; /* DT_REL */ + int relsize; /* DT_RELSZ */ + const Elf32_Rela *rela; /* DT_RELA */ + int relasize; /* DT_RELASZ */ + caddr_t modptr; + const Elf32_Sym *ddbsymtab; /* The symbol table we are using */ + long ddbsymcnt; /* Number of symbols */ + caddr_t ddbstrtab; /* String table */ + long ddbstrcnt; /* number of bytes in string table */ + caddr_t symbase; /* malloc'ed symbold base */ + caddr_t strbase; /* malloc'ed string base */ + caddr_t ctftab; /* CTF table */ + long ctfcnt; /* number of bytes in CTF table */ + caddr_t ctfoff; /* CTF offset table */ + caddr_t typoff; /* Type offset table */ + long typlen; /* Number of type entries. */ + Elf32_Addr pcpu_start; /* Pre-relocation pcpu set start. */ + Elf32_Addr pcpu_stop; /* Pre-relocation pcpu set stop. */ + Elf32_Addr pcpu_base; /* Relocated pcpu set address. */ + Elf32_Addr ld_addr; // Entry Point Of Linker (Load It Too) +}*elf_file_t; + +static int elf_parse_dynamic(elf_file_t ef); + /***************************************************************************************** Function: execThread(void (*)(void),int,char *); @@ -61,14 +106,14 @@ so do not use out side of kernel space *****************************************************************************************/ -uInt32 execThread( void (*tproc)( void ), uint32_t stack, char *arg ) { +uInt32 execThread(void (*tproc)(void), uint32_t stack, char *arg) { kTask_t * newProcess = 0x0; /* Find A New Thread */ newProcess = schedNewTask(); - assert( newProcess ); - if ( stack < 0x100000 ) - kpanic( "exec: stack not in valid area: [0x%X]\n", stack ); + assert(newProcess); + if (stack < 0x100000) + kpanic("exec: stack not in valid area: [0x%X]\n", stack); /* Set All The Correct Thread Attributes */ newProcess->tss.back_link = 0x0; @@ -128,7 +173,7 @@ ); /* Put new thread into the READY state */ - sched_setStatus( newProcess->id, READY ); + sched_setStatus(newProcess->id, READY); /* Return with the new process ID */ return ((uInt32) newProcess); @@ -150,7 +195,7 @@ The Freshly Allocated Pages With The Correct Permissions *****************************************************************************************/ -void execFile( char *file, int argc, char **argv, int console ) { +void execFile(char *file, int argc, char **argv, int console) { int i = 0x0; int x = 0x0; @@ -162,21 +207,21 @@ /* Get A New Task For This Proccess */ _current = schedNewTask(); - assert (_current); + assert(_current); _current->gid = 0x0; _current->uid = 0x0; - _current->term = tty_find( console ); + _current->term = tty_find(console); - if ( _current->term == 0x0 ) - kprintf( "Error: invalid console\n" ); + if (_current->term == 0x0) + kprintf("Error: invalid console\n"); /* Set tty ownership */ _current->term->owner = _current->id; /* Now We Must Create A Virtual Space For This Proccess To Run In */ - _current->tss.cr3 = (uInt32) vmm_createVirtualSpace( _current->id ); - kprintf( "_current->tss.cr3: 0x%X", _current->tss.cr3 ); + _current->tss.cr3 = (uInt32) vmm_createVirtualSpace(_current->id); + kprintf("_current->tss.cr3: 0x%X", _current->tss.cr3); /* To Better Load This Application We Will Switch Over To Its VM Space */ asm volatile( "movl %0,%%eax \n" @@ -184,81 +229,79 @@ : : "d" ((uInt32 *)(_current->tss.cr3)) ); /* Lets Find The File */ - tmpFd = fopen( file, "r" ); + tmpFd = fopen(file, "r"); /* If We Dont Find the File Return */ - if ( tmpFd == 0x0 ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - fclose( tmpFd ); + if (tmpFd == 0x0) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + fclose(tmpFd); return; } - if ( tmpFd->perms == 0x0 ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - fclose( tmpFd ); + if (tmpFd->perms == 0x0) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + fclose(tmpFd); return; } /* Load ELF Header */ - binaryHeader = (Elf32_Ehdr *) kmalloc( sizeof(Elf32_Ehdr) ); + binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr)); //kprintf(">a:%i:0x%X:0x%X<",sizeof(Elf32_Ehdr),binaryHeader,tmpFd); - fread( binaryHeader, sizeof(Elf32_Ehdr), 1, tmpFd ); + fread(binaryHeader, sizeof(Elf32_Ehdr), 1, tmpFd); /* Check If App Is A Real Application */ - if ( (binaryHeader->e_ident[1] != 'E') && (binaryHeader->e_ident[2] != 'L') && (binaryHeader->e_ident[3] != 'F') ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - kfree( binaryHeader ); - fclose( tmpFd ); + if ((binaryHeader->e_ident[1] != 'E') && (binaryHeader->e_ident[2] != 'L') && (binaryHeader->e_ident[3] != 'F')) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + kfree(binaryHeader); + fclose(tmpFd); return; - } - else if ( binaryHeader->e_type != 2 ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - kfree( binaryHeader ); - fclose( tmpFd ); + } else if (binaryHeader->e_type != 2) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + kfree(binaryHeader); + fclose(tmpFd); return; - } - else if ( binaryHeader->e_entry == 0x300000 ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - kfree( binaryHeader ); - fclose( tmpFd ); + } else if (binaryHeader->e_entry == 0x300000) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + kfree(binaryHeader); + fclose(tmpFd); return; } _current->td.abi = binaryHeader->e_ident[EI_OSABI]; /* Load The Program Header(s) */ - programHeader = (elfProgramHeader *) kmalloc( sizeof(elfProgramHeader) * binaryHeader->e_phnum ); - fseek( tmpFd, binaryHeader->e_phoff, 0 ); + programHeader = (elfProgramHeader *) kmalloc(sizeof(elfProgramHeader) * binaryHeader->e_phnum); + fseek(tmpFd, binaryHeader->e_phoff, 0); //kprintf(">c:%i:0x%X:0x%X<",sizeof(elfProgramHeader)*binaryHeader->e_phnum,programHeader,tmpFd); - fread( programHeader, (sizeof(elfProgramHeader) * binaryHeader->e_phnum), 1, tmpFd ); + fread(programHeader, (sizeof(elfProgramHeader) * binaryHeader->e_phnum), 1, tmpFd); //kprintf(">d<"); /* Loop Through The Header And Load Sections Which Need To Be Loaded */ - for ( i = 0; i < binaryHeader->e_phnum; i++ ) { - if ( programHeader[i].phType == 1 ) { + for (i = 0; i < binaryHeader->e_phnum; i++) { + if (programHeader[i].phType == 1) { /* Allocate Memory Im Going To Have To Make This Load Memory With Correct Settings so it helps us in the future */ - for ( x = 0x0; x < (programHeader[i].phMemsz); x += 0x1000 ) { + for (x = 0x0; x < (programHeader[i].phMemsz); x += 0x1000) { /* Make readonly and read/write !!! */ - if ( vmm_remapPage( vmm_findFreePage( _current->id ), ((programHeader[i].phVaddr & 0xFFFFF000) + x), PAGE_DEFAULT ) == 0x0 ) - K_PANIC( "Remap Page Failed" ); + if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].phVaddr & 0xFFFFF000) + x), PAGE_DEFAULT) == 0x0) + K_PANIC("Remap Page Failed"); - memset( (void *) ((programHeader[i].phVaddr & 0xFFFFF000) + x), 0x0, 0x1000 ); + memset((void *) ((programHeader[i].phVaddr & 0xFFFFF000) + x), 0x0, 0x1000); } _current->oInfo.vmStart = 0x80000000; _current->td.vm_daddr = (u_long) (programHeader[i].phVaddr & 0xFFFFF000); /* Now Load Section To Memory */ - fseek( tmpFd, programHeader[i].phOffset, 0 ); - fread( (void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, tmpFd ); - if ( (programHeader[i].phFlags & 0x2) != 0x2 ) { - kprintf( "pH: [0x%X]\n", programHeader[i].phMemsz ); - for ( x = 0x0; x < (programHeader[i].phMemsz); x += 0x1000 ) { - if ( (vmm_setPageAttributes( (programHeader[i].phVaddr & 0xFFFFF000) + x, PAGE_PRESENT | PAGE_USER )) != 0x0 ) - kpanic( "Error: vmm_setPageAttributes failed, File: %s, Line: %i\n", __FILE__, __LINE__ ); + fseek(tmpFd, programHeader[i].phOffset, 0); + fread((void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, tmpFd); + if ((programHeader[i].phFlags & 0x2) != 0x2) { + kprintf("pH: [0x%X]\n", programHeader[i].phMemsz); + for (x = 0x0; x < (programHeader[i].phMemsz); x += 0x1000) { + if ((vmm_setPageAttributes((programHeader[i].phVaddr & 0xFFFFF000) + x, PAGE_PRESENT | PAGE_USER)) != 0x0) + kpanic("Error: vmm_setPageAttributes failed, File: %s, Line: %i\n", __FILE__, __LINE__); } } } @@ -270,13 +313,13 @@ /* Set Up Stack Space */ //MrOlsen (2016-01-14) FIX: is the stack start supposed to be addressable xhcnage x= 1 to x=0 - for ( x = 0; x < 100; x++ ) { - vmm_remapPage( vmm_findFreePage( _current->id ), STACK_ADDR - (x * 0x1000), PAGE_DEFAULT | PAGE_STACK ); + for (x = 0; x < 100; x++) { + vmm_remapPage(vmm_findFreePage(_current->id), STACK_ADDR - (x * 0x1000), PAGE_DEFAULT | PAGE_STACK); } /* Kernel Stack 0x2000 bytes long */ - vmm_remapPage( vmm_findFreePage( _current->id ), 0x5BC000, KERNEL_PAGE_DEFAULT | PAGE_STACK ); - vmm_remapPage( vmm_findFreePage( _current->id ), 0x5BB000, KERNEL_PAGE_DEFAULT | PAGE_STACK ); + vmm_remapPage(vmm_findFreePage(_current->id), 0x5BC000, KERNEL_PAGE_DEFAULT | PAGE_STACK); + vmm_remapPage(vmm_findFreePage(_current->id), 0x5BB000, KERNEL_PAGE_DEFAULT | PAGE_STACK); /* Set All The Proper Information For The Task */ _current->tss.back_link = 0x0; @@ -305,11 +348,11 @@ _current->tss.trace_bitmap = 0x0000; _current->tss.io_map = 0x8000; - sched_setStatus( _current->id, READY ); + sched_setStatus(_current->id, READY); - kfree( binaryHeader ); - kfree( programHeader ); - fclose( tmpFd ); + kfree(binaryHeader); + kfree(programHeader); + fclose(tmpFd); tmp = (uInt32 *) _current->tss.esp0 - 5; tmp[0] = binaryHeader->e_entry; @@ -317,7 +360,7 @@ tmp = (uint32_t *) _current->tss.esp; - kprintf( "argv: [0x%X]\n", argv ); + kprintf("argv: [0x%X]\n", argv); //*tmp++ = 0x0; // Stack EIP Return Addr //*tmp++ = tmp + 1; // Pointer To AP *tmp++ = 0x1; // ARGC @@ -338,7 +381,7 @@ : : "d" ((uInt32 *)(kernelPageDirectory)) ); - kprintf( "execFile Return: %i\n", _current->id ); + kprintf("execFile Return: %i\n", _current->id); /* Finally Return */ return; } @@ -356,7 +399,7 @@ *****************************************************************************************/ -int sys_exec( struct thread *td, char *file, char **argv, char **envp ) { +int sys_exec(struct thread *td, char *file, char **argv, char **envp) { int i = 0x0; int x = 0x0; int argc = 0x0; @@ -377,31 +420,33 @@ fileDescriptor *fd = 0x0; Elf32_Ehdr *binaryHeader = 0x0; - elfProgramHeader *programHeader = 0x0; - elfSectionHeader *sectionHeader = 0x0; - elfDynamic *elfDynamicS = 0x0; - elfDynamic *dynp = 0x0; + Elf32_Phdr *programHeader = 0x0; + Elf32_Shdr *sectionHeader = 0x0; + + Elf32_Dyn *elfDynamicS = 0x0; + Elf32_Dyn *dynp = 0x0; + + elf_file_t ef = 0x0; u_long text_addr = 0, text_size = 0; u_long data_addr = 0, data_size = 0; struct i386_frame *iFrame = 0x0; - //struct i386_frame *iFrameNew = 0x0; //Elf_Auxargs *auxargs = 0x0; asm("movl %%cr3, %0;" : "=r" (cr3)); - fd = fopen( file, "r" ); + fd = fopen(file, "r"); /* If the file doesn't exist fail */ - if ( fd == 0x0 ) + if (fd == 0x0) return (-1); /* Test If Executable */ - if ( fd->perms == 0 ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - fclose( fd ); + if (fd->perms == 0) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + fclose(fd); return (-1); } @@ -411,32 +456,30 @@ //! Clean the virtual of COW pages left over from the fork //vmm_cleanVirtualSpace( (uint32_t) _current->td.vm_daddr + (_current->td.vm_dsize << PAGE_SHIFT) ); //MrOlsen 2017-12-15 - FIX! - This should be done before it was causing a lot of problems why did I free space after loading binary???? - vmm_cleanVirtualSpace( (uint32_t) 0x8048000 ); + vmm_cleanVirtualSpace((uint32_t) 0x8048000); /* Load ELF Header */ - if ( (binaryHeader = (Elf32_Ehdr *) kmalloc( sizeof(Elf32_Ehdr) )) == 0x0 ) - K_PANIC( "MALLOC FAILED" ); + if ((binaryHeader = (Elf32_Ehdr *) kmalloc(sizeof(Elf32_Ehdr))) == 0x0) + K_PANIC("MALLOC FAILED"); - fread( binaryHeader, sizeof(Elf32_Ehdr), 1, fd ); + fread(binaryHeader, sizeof(Elf32_Ehdr), 1, fd); /* Done Loading ELF Header */ /* Check If App Is A Real Application */ - if ( (binaryHeader->e_ident[1] != 'E') && (binaryHeader->e_ident[2] != 'L') && (binaryHeader->e_ident[3] != 'F') ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - kfree( binaryHeader ); - fclose( fd ); + if ((binaryHeader->e_ident[1] != 'E') && (binaryHeader->e_ident[2] != 'L') && (binaryHeader->e_ident[3] != 'F')) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + kfree(binaryHeader); + fclose(fd); return (-1); - } - else if ( binaryHeader->e_type != ET_EXEC ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - kfree( binaryHeader ); - fclose( fd ); + } else if (binaryHeader->e_type != ET_EXEC) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + kfree(binaryHeader); + fclose(fd); return (-1); - } - else if ( binaryHeader->e_entry == 0x300000 ) { - kprintf( "Exec Format Error: Binary File Not Executable.\n" ); - kfree( binaryHeader ); - fclose( fd ); + } else if (binaryHeader->e_entry == 0x300000) { + kprintf("Exec Format Error: Binary File Not Executable.\n"); + kfree(binaryHeader); + fclose(fd); return (-1); } @@ -444,69 +487,70 @@ td->abi = binaryHeader->e_ident[EI_OSABI]; /* Load The Program Header(s) */ - if ( (programHeader = (elfProgramHeader *) kmalloc( sizeof(elfProgramHeader) * binaryHeader->e_phnum )) == 0x0 ) - K_PANIC( "MALLOC FAILED" ); + if ((programHeader = (elfProgramHeader *) kmalloc(sizeof(elfProgramHeader) * binaryHeader->e_phnum)) == 0x0) + K_PANIC("MALLOC FAILED"); - assert( programHeader ); + assert(programHeader); - fseek( fd, binaryHeader->e_phoff, 0 ); - fread( programHeader, (sizeof(elfProgramHeader) * binaryHeader->e_phnum), 1, fd ); + fseek(fd, binaryHeader->e_phoff, 0); + fread(programHeader, (sizeof(elfProgramHeader) * binaryHeader->e_phnum), 1, fd); /* Done Loading Program Header(s) */ /* Load The Section Header(s) */ - if ( (sectionHeader = (elfSectionHeader *) kmalloc( sizeof(elfSectionHeader) * binaryHeader->e_shnum )) == 0x0 ) - K_PANIC( "MALLOC FAILED" ); + if ((sectionHeader = (elfSectionHeader *) kmalloc(sizeof(elfSectionHeader) * binaryHeader->e_shnum)) == 0x0) + K_PANIC("MALLOC FAILED"); - assert( sectionHeader ); - fseek( fd, binaryHeader->e_shoff, 0 ); - fread( sectionHeader, sizeof(elfSectionHeader) * binaryHeader->e_shnum, 1, fd ); + assert(sectionHeader); + fseek(fd, binaryHeader->e_shoff, 0); + fread(sectionHeader, sizeof(elfSectionHeader) * binaryHeader->e_shnum, 1, fd); /* Done Loading Section Header(s) */ + ef = kmalloc(sizeof(struct elf_file)); + /* Loop Through The Header And Load Sections Which Need To Be Loaded */ - for ( i = 0; i < binaryHeader->e_phnum; i++ ) { - switch ( programHeader[i].phType ) { + for (i = 0; i < binaryHeader->e_phnum; i++) { + switch (programHeader[i].p_type) { case PT_LOAD: - if ( programHeader[i].phMemsz == 0x0 ) + if (programHeader[i].p_memsz == 0x0) break; - seg_addr = trunc_page( programHeader[i].phVaddr ); - seg_size = round_page( programHeader[i].phMemsz + programHeader[i].phVaddr - seg_addr ); + seg_addr = trunc_page(programHeader[i].p_vaddr); + seg_size = round_page(programHeader[i].p_memsz + programHeader[i].p_vaddr - seg_addr); /* Allocate Memory Im Going To Have To Make This Load Memory With Correct Settings so it helps us in the future */ - for ( x = 0x0; x < (round_page( programHeader[i].phMemsz )); x += 0x1000 ) { + for (x = 0x0; x < (round_page(programHeader[i].p_memsz)); x += 0x1000) { /* Make readonly and read/write !!! */ - if ( vmm_remapPage( vmm_findFreePage( _current->id ), ((programHeader[i].phVaddr & 0xFFFFF000) + x), PAGE_DEFAULT ) == 0x0 ) { - K_PANIC( "Error: Remap Page Failed" ); + if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x), PAGE_DEFAULT) == 0x0) { + K_PANIC("Error: Remap Page Failed"); } /* - else { - kprintf("rP[0x%X]", (programHeader[i].phVaddr & 0xFFFFF000) + x); - } */ + else { + kprintf("rP[0x%X]", (programHeader[i].phVaddr & 0xFFFFF000) + x); + } */ - memset( (void *) ((programHeader[i].phVaddr & 0xFFFFF000) + x), 0x0, 0x1000 ); + memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x), 0x0, 0x1000); } /* Now Load Section To Memory */ - fseek( fd, programHeader[i].phOffset, 0 ); - fread( (void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, fd ); + fseek(fd, programHeader[i].p_offset, 0); + fread((void *) programHeader[i].p_vaddr, programHeader[i].p_filesz, 1, fd); - if ( (programHeader[i].phFlags & 0x2) != 0x2 ) { - for ( x = 0x0; x < (round_page( programHeader[i].phMemsz )); x += 0x1000 ) { - if ( (vmm_setPageAttributes( (programHeader[i].phVaddr & 0xFFFFF000) + x, PAGE_PRESENT | PAGE_USER )) != 0x0 ) - kpanic( "Error: vmm_setPageAttributes failed, File: %s,Line: %i\n", __FILE__, __LINE__ ); + if ((programHeader[i].p_flags & 0x2) != 0x2) { + for (x = 0x0; x < (round_page(programHeader[i].p_memsz)); x += 0x1000) { + if ((vmm_setPageAttributes((programHeader[i].p_vaddr & 0xFFFFF000) + x, PAGE_PRESENT | PAGE_USER)) != 0x0) + kpanic("Error: vmm_setPageAttributes failed, File: %s,Line: %i\n", __FILE__, __LINE__); } } - if ((programHeader[i].phFlags & PF_X) && text_size < seg_size) { - kprintf( "setting text: 0x%X - 0x%X\n", seg_addr, seg_size ); + if ((programHeader[i].p_flags & PF_X) && text_size < seg_size) { + kprintf("setting text: 0x%X - 0x%X\n", seg_addr, seg_size); text_size = seg_size; text_addr = seg_addr; - } - else { - kprintf( "setting data: 0x%X - 0x%X\n", seg_addr, seg_size ); + } else { + kprintf("setting data: 0x%X - 0x%X\n", seg_addr, seg_size); data_size = seg_size; data_addr = seg_addr; /* @@ -520,21 +564,23 @@ * MrOlsen (2016-01-19) NOTE: Note Sure, I should Do This Later * Thjis is for stack space */ - _current->oInfo.vmStart = ((programHeader[i].phVaddr & 0xFFFFF000) + 0xA900000); + _current->oInfo.vmStart = ((programHeader[i].p_vaddr & 0xFFFFF000) + 0xA900000); break; case PT_DYNAMIC: //newLoc = (char *)programHeader[i].phVaddr; - elfDynamicS = (elfDynamic *) programHeader[i].phVaddr; - fseek( fd, programHeader[i].phOffset, 0 ); - fread( (void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, fd ); + //elfDynamicS = (elfDynamic *) programHeader[i].p_vaddr; + ef->dynamic = (Elf32_Dyn *) programHeader[i].p_vaddr; + //fseek( fd, programHeader[i].phOffset, 0 ); + //fread( (void *) programHeader[i].phVaddr, programHeader[i].phFilesz, 1, fd ); break; case PT_INTERP: - kprintf( "Malloc: %i\n", programHeader[i].phFilesz ); - interp = (char *) kmalloc( programHeader[i].phFilesz ); - fseek( fd, programHeader[i].phOffset, 0 ); - fread( (void *) interp, programHeader[i].phFilesz, 1, fd ); - kprintf( "Interp: [%s]\n", interp ); - ldAddr = ldEnable(); + kprintf("Malloc: %i\n", programHeader[i].p_filesz); + interp = (char *) kmalloc(programHeader[i].p_filesz); + fseek(fd, programHeader[i].p_offset, 0); + fread((void *) interp, programHeader[i].p_filesz, 1, fd); + kprintf("Interp: [%s]\n", interp); + //ldAddr = ldEnable(); + ef->ld_addr = ldEnable(); break; case PT_GNU_STACK: break; @@ -548,58 +594,10 @@ _current->td.vm_dsize = data_size >> PAGE_SHIFT; _current->td.vm_daddr = data_addr; - kprintf( "Done Looping\n" ); + kprintf("Done Looping\n"); - /* What is this doing? 11/23/06 */ - if ( elfDynamicS != 0x0 ) { - for ( dynp = elfDynamicS ; dynp->d_tag != 0x0; dynp++) { - switch (dynp->d_tag) { - case DT_NEEDED: - break; - case DT_INIT: - break; - case DT_FINI: - break; - case DT_HASH: - kprintf("COM BACK TO THIS"); - break; - case DT_STRTAB: - break; - case DT_SYMTAB: - break; - case DT_STRSZ: - break; - case DT_SYMENT: - break; - case DT_DEBUG: - break; - case DT_PLTREL: - break; - case DT_JMPREL: - break; - case DT_REL: - break; - case DT_RELSZ: - break; - case DT_RELENT: - if (dynp->d_un.d_val != sizeof(Elf32_Rel)) - kpanic("NOEXEC"); - break; - case DT_PLTGOT: - tmp = (void *) dynp->d_un.d_ptr;//elfDynamicS[i].dynPtr; - if ( tmp == 0x0 ) - kpanic( "tmp: NULL\n" ); - else - kprintf("[0x%X]", tmp); - tmp[2] = (uInt32) ldAddr; - tmp[1] = (uInt32) fd; - break; - default: - kprintf("t_tag: 0x%X>", dynp->d_tag); - break; - } - } - } + elf_parse_dynamic(ef); + /* _current->td.vm_dsize = seg_size >> PAGE_SHIFT; _current->td.vm_daddr = (char *) seg_addr; @@ -607,26 +605,25 @@ //argv = ≈ //if (argv[1] != 0x0) { - if ( argv != 0x0 ) { + if (argv != 0x0) { //MrOlsen (2016-01-12) FIX: Not sure why argv[0] == 0 argc = ((int) argv[0] > 0) ? (int) argv[0] : 1; - kprintf( "argc: %i", argc ); - args = (char *) vmm_getFreeVirtualPage( _current->id, 1, VM_TASK ); - kprintf( "argc: %i, args 0x%X", argc, args ); - memset( args, 0x0, 0x1000 ); + kprintf("argc: %i", argc); + args = (char *) vmm_getFreeVirtualPage(_current->id, 1, VM_TASK); + kprintf("argc: %i, args 0x%X", argc, args); + memset(args, 0x0, 0x1000); x = 0x0; - argvNew = (char **) kmalloc( sizeof(char *) * argc ); - for ( i = 0x0; i < argc; i++ ) { - strcpy( args + x, argv[i + 1] ); + argvNew = (char **) kmalloc(sizeof(char *) * argc); + for (i = 0x0; i < argc; i++) { + strcpy(args + x, argv[i + 1]); argvNew[i] = args + x; - x += strlen( argv[i + 1] ) + 1; + x += strlen(argv[i + 1]) + 1; //args[x] = '\0'; //x++; } argv = argvNew; - } - else { + } else { argc = 1; } @@ -639,37 +636,35 @@ //! Adjust iframe // iFrame = (struct i386_frame *) (_current->tss.esp0 - sizeof(struct i386_frame)); - //kprintf( "EBP-1(%i): EBP: [0x%X], EIP: [0x%X], ESP: [0x%X]\n", _current->id, iFrame->ebp, iFrame->eip, iFrame->user_esp ); - argc = 1; - iFrame->ebp = 0x0;//STACK_ADDR; + iFrame->ebp = 0x0; //STACK_ADDR; iFrame->eip = binaryHeader->e_entry; //iFrame->user_ebp = 0x0; iFrame->edx = 0x0; //iFrame->user_esp = ((uint32_t) STACK_ADDR) - ((sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2)); - iFrame->user_esp = ((uint32_t) STACK_ADDR) - (128);//(sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2)); + iFrame->user_esp = ((uint32_t) STACK_ADDR) - (128); //(sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2)); tmp = (void *) iFrame->user_esp; //MrOlsen 2017-11-14 iFrame->user_ebp; - kprintf("[0x%X][0x%X]", iFrame->user_esp,tmp); + kprintf("[0x%X][0x%X]", iFrame->user_esp, tmp); //memset(tmp,0x0,((sizeof(uint32_t) * (argc + 8 + 1)) + (sizeof(Elf32_Auxinfo) * 2))); - memset((char *)(STACK_ADDR - 128),0x0,128); + memset((char *) (STACK_ADDR - 128), 0x0, 128); tmp[0] = argc; // ARGC /* - if ( argc == 1 ) { - *tmp++ = 0x0; //ARGV Pointers - } - else { - for ( i = 0; i < argc; i++ ) { - *tmp++ = (u_int) argv[i]; - } - } - */ + if ( argc == 1 ) { + *tmp++ = 0x0; //ARGV Pointers + } + else { + for ( i = 0; i < argc; i++ ) { + *tmp++ = (u_int) argv[i]; + } + } + */ tmp[1] = 0x0; // ARGV tmp[2] = 0x0; // ARGV Terminator @@ -684,13 +679,13 @@ tmp[9] = 0xDEADBEEF; // End Marker - kfree( argvNew ); + kfree(argvNew); /* Now That We Relocated The Binary We Can Unmap And Free Header Info */ - kfree( binaryHeader ); - kfree( programHeader ); + kfree(binaryHeader); + kfree(programHeader); -/* + /* _current->tss.es = 0x30 + 3; _current->tss.cs = 0x28 + 3; _current->tss.ss = 0x30 + 3; @@ -701,7 +696,7 @@ _current->tss.ldt = 0x18; _current->tss.trace_bitmap = 0x0000; _current->tss.io_map = 0x8000; -*/ + */ /* kfree (iFrameNew); @@ -720,3 +715,95 @@ return (0x0); } + +static int elf_parse_dynamic(elf_file_t ef) { + Elf32_Dyn *dynp; + int plttype = DT_REL; + uint32_t *tmp; + + for (dynp = ef->dynamic; dynp->d_tag != 0x0; dynp++) { + switch (dynp->d_tag) { + case DT_NEEDED: + break; + case DT_INIT: + break; + case DT_FINI: + break; + case DT_HASH: + /* From src/libexec/rtld-elf/rtld.c */ + const Elf32_Hashelt *hashtab = (const Elf32_Hashelt *) (ef->address + dynp->d_un.d_ptr); + ef->nbuckets = hashtab[0]; + ef->nchains = hashtab[1]; + ef->buckets = hashtab + 2; + ef->chains = ef->buckets + ef->nbuckets; + break; + case DT_STRTAB: + ef->strtab = (caddr_t) (ef->address + dynp->d_un.d_ptr); + break; + case DT_STRSZ: + ef->strsz = dynp->d_un.d_val; + break; + case DT_SYMTAB: + ef->symtab = (Elf32_Sym *) (ef->address + dynp->d_un.d_ptr); + break; + case DT_SYMENT: + if (dynp->d_un.d_val != sizeof(Elf32_Sym)) + return (ENOEXEC); + break; + case DT_REL: + ef->rel = (const Elf32_Rel *) (ef->address + dynp->d_un.d_ptr); + break; + case DT_RELSZ: + ef->relsize = dynp->d_un.d_val; + break; + case DT_RELENT: + if (dynp->d_un.d_val != sizeof(Elf32_Rel)) + return (ENOEXEC); + break; + case DT_JMPREL: + ef->pltrel = (const Elf32_Rel *) (ef->address + dynp->d_un.d_ptr); + break; + case DT_PLTRELSZ: + ef->pltrelsize = dynp->d_un.d_val; + break; + case DT_RELA: + ef->rela = (const Elf32_Rela *) (ef->address + dynp->d_un.d_ptr); + break; + case DT_RELASZ: + ef->relasize = dynp->d_un.d_val; + break; + case DT_RELAENT: + if (dynp->d_un.d_val != sizeof(Elf32_Rela)) + return (ENOEXEC); + break; + case DT_PLTREL: + plttype = dynp->d_un.d_val; + if (plttype != DT_REL && plttype != DT_RELA) + return (ENOEXEC); + break; + case DT_PLTGOT: + ef->got = (Elf32_Addr *) (ef->address + dynp->d_un.d_ptr); + tmp = (void *) dynp->d_un.d_ptr; //elfDynamicS[i].dynPtr; + if (tmp == 0x0) + kpanic("tmp: NULL\n"); + else + kprintf("[0x%X]", tmp); + tmp[2] = (uInt32) ef->ld_addr; + tmp[1] = (uInt32) ef; + break; + default: + kprintf("t_tag: 0x%X>", dynp->d_tag); + break; + } + } + ef->pltrela = (const Elf32_Rela *) ef->pltrel; + ef->pltrel = NULL; + ef->pltrelasize = ef->pltrelsize; + ef->pltrelsize = 0; + + ef->ddbsymtab = ef->symtab; + ef->ddbsymcnt = ef->nchains; + ef->ddbstrtab = ef->strtab; + ef->ddbstrcnt = ef->strsz; + return (0); +} diff --git a/sys/include/sys/_types.h b/sys/include/sys/_types.h index 6cfd882..73bd3d7 100644 --- a/sys/include/sys/_types.h +++ b/sys/include/sys/_types.h @@ -24,8 +24,8 @@ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ -#ifndef __TYPES_H -#define __TYPES_H +#ifndef _SYS__TYPES_H_ +#define _SYS__TYPES_H_ typedef char __int8_t; typedef unsigned char __uint8_t; @@ -73,5 +73,4 @@ typedef __uint_least32_t __char32_t; #endif - #endif diff --git a/sys/include/sys/types.h b/sys/include/sys/types.h index fd73945..77f3cdf 100644 --- a/sys/include/sys/types.h +++ b/sys/include/sys/types.h @@ -27,15 +27,19 @@ *****************************************************************************************/ -#ifndef _SYS_TYPES_H -#define _SYS_TYPES_H +#ifndef _SYS_TYPES_H_ +#define _SYS_TYPES_H_ #include +#define NULL 0x0 + #ifndef NULL #define NULL 0x0 #endif +typedef char *caddr_t; + /* unsigned integrals */ typedef __uint8_t uint8_t; typedef __uint16_t uint16_t; diff --git a/sys/include/vfs/file.h b/sys/include/vfs/file.h index f2718ae..4d4df02 100644 --- a/sys/include/vfs/file.h +++ b/sys/include/vfs/file.h @@ -21,8 +21,8 @@ **************************************************************************************/ -#ifndef _FILE_H -#define _FILE_H +#ifndef _VFS_FILE_H_ +#define _VFS_FILE_H_ 1 #include #include diff --git a/sys/kernel/elf.c b/sys/kernel/elf.c index c7ec1e7..ea95ddf 100644 --- a/sys/kernel/elf.c +++ b/sys/kernel/elf.c @@ -28,6 +28,7 @@ *****************************************************************************************/ #include +#include #include #include #include @@ -39,12 +40,14 @@ } *elf_file_type; int elf_load_file(kTask_t *p, const char *file, uint32_t *addr, uint32_t *entry) { + int i = 0x0; int x = 0x0; int numsegs = 0x0; - uint32_t base = 0x0; + //uint32_t base = 0x0; uint32_t base_addr = 0x0; + uint32_t real_base_addr = 0x0; Elf32_Ehdr *binaryHeader = 0x0; Elf32_Phdr *programHeader = 0x0; @@ -71,9 +74,9 @@ } if (binaryHeader->e_type == ET_DYN) - base = *addr; + real_base_addr = *addr; else if (binaryHeader->e_type == ET_EXEC) - base = 0x0; + real_base_addr = 0x0; else return (-1); @@ -85,7 +88,7 @@ fread(programHeader, (sizeof(Elf32_Phdr) * binaryHeader->e_phnum), 1, exec_fd); - for (i = 0x0; i < binaryHeader->e_phnum; i++) { + for (numsegs = 0x0, i = 0x0; i < binaryHeader->e_phnum; i++) { switch (programHeader[i].p_type) { case PT_LOAD: /* @@ -95,33 +98,35 @@ for (x = 0x0; x < (programHeader[i].p_memsz + 0xFFF); x += 0x1000) { /* Make readonly and read/write */ - if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x + base), PAGE_DEFAULT) == 0x0) + if (vmm_remapPage(vmm_findFreePage(_current->id), ((programHeader[i].p_vaddr & 0xFFFFF000) + x + real_base_addr), PAGE_DEFAULT) == 0x0) K_PANIC("Error: Remap Page Failed"); - memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x + base), 0x0, 0x1000); + memset((void *) ((programHeader[i].p_vaddr & 0xFFFFF000) + x + real_base_addr), 0x0, 0x1000); } /* Now Load Section To Memory */ fseek(exec_fd, programHeader[i].p_offset, 0); - fread((void *) programHeader[i].p_vaddr + base, programHeader[i].p_filesz, 1, exec_fd); + fread((void *) programHeader[i].p_vaddr + real_base_addr, programHeader[i].p_filesz, 1, exec_fd); if ((programHeader[i].p_flags & 0x2) != 0x2) { for (x = 0x0; x < (programHeader[i].p_memsz); x += 0x1000) { - if ((vmm_setPageAttributes((programHeader[i].p_vaddr & 0xFFFFF000) + x + base, PAGE_PRESENT | PAGE_USER)) != 0x0) + if ((vmm_setPageAttributes((programHeader[i].p_vaddr & 0xFFFFF000) + x + real_base_addr, PAGE_PRESENT | PAGE_USER)) != 0x0) K_PANIC("vmm_setPageAttributes failed"); } } if (numsegs == 0x0) - base_addr = (programHeader[i].p_vaddr & 0xFFFFF000) + base; + base_addr = (programHeader[i].p_vaddr & 0xFFFFF000) + real_base_addr; numsegs++; break; } } *addr = base_addr; - kprintf("entry: [0x%X]\n", *entry); - *entry = binaryHeader->e_entry + base; - kprintf("entry: [0x%X]\n", *entry); + + *entry = binaryHeader->e_entry + real_base_addr; + + free(binaryHeader); + free(programHeader); return (0x0); }