toaruos/kernel/misc/elf.c
Kevin Lange 339b82e10c [massive commit] Userspace terminal.
Completely removes:
* The kernel terminal (both VGA and graphical)
* The kernel ANSI parser (obviously)
* kgets() function
* Dozens of other functions that were made useless

Adds:
* Userspace terminal that should work (relatively) well
* Keyboard device driver (implemented with a "pipe" object)
* Stabalized interrupt interface
* `clear` uses the c library
* All panic screens and kprintf() output goes to the serial line ONLY
* The kernel boots directly into /bin/terminal (no arguments, unless you
  want to add them (such as -f))
2012-01-25 00:19:52 -06:00

161 lines
5.2 KiB
C

/* vim: tabstop=4 shiftwidth=4 noexpandtab
*
* ELF Static Executable Loader
*
* Part of the ToAru OS Kernel
* (C) 2011 Kevin Lange
* Released under the terms of the NCSA License, see the included
* README file for further information.
*/
#include <system.h>
#include <fs.h>
#include <elf.h>
#include <process.h>
/**
* Load and execute a static ELF binary.
*
* We make one assumption on the location the binary expects to be loaded
* at: that it be outside of the kernel memory space.
*
* Arguments are passed to the stack of the user application so that they
* can be read properly.
*
* TODO: Environment variables should be loaded somewhere.
*
* HACK: ELF verification isn't complete.
*
* @param path Path to the executable to attempt to execute.
* @param argc Number of arguments (because I'm not counting for you)
* @param argv Pointer to a string of arguments
*/
int
exec(
char * path, /* Path to the executable to run */
int argc, /* Argument count (ie, /bin/echo hello world = 3) */
char ** argv /* Argument strings (including executable path) */
) {
/* Open the file */
fs_node_t * file = kopen(path,0);
if (!file) {
/* Command not found */
return 0;
}
/* Read in the binary contents */
Elf32_Header * header = (Elf32_Header *)malloc(file->length + 100);
read_fs(file, 0, file->length, (uint8_t *)header);
current_process->name = malloc(strlen(path) + 1);
memcpy(current_process->name, path, strlen(path) + 1);
/* Alright, we've read the binary, time to load the loadable sections */
/* Verify the magic */
if ( header->e_ident[0] != ELFMAG0 ||
header->e_ident[1] != ELFMAG1 ||
header->e_ident[2] != ELFMAG2 ||
header->e_ident[3] != ELFMAG3) {
/* What? This isn't an ELF... */
kprintf("Fatal: Not a valid ELF executable.\n");
free(header);
close_fs(file);
return -1;
}
/* Load the loadable segments from the binary */
for (uintptr_t x = 0; x < header->e_shentsize * header->e_shnum; x += header->e_shentsize) {
/* read a section header */
Elf32_Shdr * shdr = (Elf32_Shdr *)((uintptr_t)header + (header->e_shoff + x));
if (shdr->sh_addr) {
/* If this is a loadable section, load it up. */
if (shdr->sh_addr < current_process->image.entry) {
/* If this is the lowest entry point, store it for memory reasons */
current_process->image.entry = shdr->sh_addr;
}
if (shdr->sh_addr + shdr->sh_size - current_process->image.entry > current_process->image.size) {
/* We also store the total size of the memory region used by the application */
current_process->image.size = shdr->sh_addr + shdr->sh_size - current_process->image.entry;
}
for (uintptr_t i = 0; i < shdr->sh_size + 0x2000; i += 0x1000) {
/* This doesn't care if we already allocated this page */
alloc_frame(get_page(shdr->sh_addr + i, 1, current_directory), 0, 1);
}
if (shdr->sh_type == SHT_NOBITS) {
/* This is the .bss, zero it */
memset((void *)(shdr->sh_addr), 0x0, shdr->sh_size);
} else {
/* Copy the section into memory */
memcpy((void *)(shdr->sh_addr), (void *)((uintptr_t)header + shdr->sh_offset), shdr->sh_size);
}
}
}
/* Store the entry point to the code segment */
uintptr_t entry = (uintptr_t)header->e_entry;
/* Free the space we used for the ELF headers and files */
free(header);
close_fs(file);
for (uintptr_t stack_pointer = 0x10000000; stack_pointer < 0x100F0000; stack_pointer += 0x1000) {
alloc_frame(get_page(stack_pointer, 1, current_directory), 0, 1);
}
uintptr_t heap = current_process->image.entry + current_process->image.size;
alloc_frame(get_page(heap, 1, current_directory), 0, 1);
char ** argv_ = (char **)heap;
heap += sizeof(char *) * argc;
for (int i = 0; i < argc; ++i) {
alloc_frame(get_page(heap, 1, current_directory), 0, 1);
argv_[i] = (char *)heap;
memcpy((void *)heap, argv[i], strlen(argv[i]) * sizeof(char) + 1);
heap += strlen(argv[i]) + 1;
}
current_process->image.heap = heap; /* heap end */
current_process->image.heap_actual = heap + (0x1000 - heap % 0x1000);
current_process->image.user_stack = 0x100EFFFF;
while (current_process->fds.length < 3) {
process_append_fd((process_t *)current_process, NULL);
}
/* Go go go */
enter_user_jmp(entry, argc, argv_, 0x100EFFFF);
/* We should never reach this code */
return -1;
}
int
system(
char * path, /* Path to the executable to run */
int argc, /* Argument count (ie, /bin/echo hello world = 3) */
char ** argv /* Argument strings (including executable path) */
) {
int child = fork();
if (child == 0) {
exec(path,argc,argv);
kexit(-1);
return -1;
} else {
/* We are system(), so we need to wait for the child
* application to exit before we can continue. */
/* Get the child task. */
process_t * volatile child_task = process_from_pid(child);
/* If the child task doesn't exist, bail */
if (!child_task) return -1;
/* Wait until it finishes (this is stupidly memory intensive,
* but we haven't actually implemented wait() yet, so there's
* not all that much we can do right now. */
while (child_task->finished == 0) {
if (child_task->finished != 0) break;
}
/* Grab the child's return value */
int ret = child_task->status;
delete_process(child_task);
return ret;
}
}