bool
elf_loadFile(void *elfFile, bool phys, intptr_t offset)
{
int i;
if (elf_checkFile(elfFile) != 0) {
return false;
}
for(i=0; i < elf_getNumProgramHeaders(elfFile); i++) {
/* Load that section */
uintptr_t dest, src;
size_t len;
if (phys) {
dest = (uintptr_t) elf_getProgramHeaderPaddr(elfFile, i);
} else {
dest = (uintptr_t) elf_getProgramHeaderVaddr(elfFile, i);
}
dest += offset;
len = elf_getProgramHeaderFileSize(elfFile, i);
src = (uintptr_t) elfFile + elf_getProgramHeaderOffset(elfFile, i);
memcpy((void*) dest, (void*) src, len);
dest += len;
memset((void*) dest, 0, elf_getProgramHeaderMemorySize(elfFile, i) - len);
}
return true;
}
void
elf_getProgramHeaderInfo(void *elfFile, uint16_t ph, uint64_t *p_vaddr,
uint64_t *p_paddr, uint64_t *p_filesz, uint64_t *p_offset,
uint64_t *p_memsz)
{
*p_vaddr = elf_getProgramHeaderVaddr(elfFile, ph);
*p_paddr = elf_getProgramHeaderPaddr(elfFile, ph);
*p_filesz = elf_getProgramHeaderFileSize(elfFile, ph);
*p_offset = elf_getProgramHeaderOffset(elfFile, ph);
*p_memsz = elf_getProgramHeaderMemorySize(elfFile, ph);
}
bool reios_loadElf(const string& elf) {
FILE* f = fopen(elf.c_str(), "rb");
if (!f) {
return false;
}
fseek(f, 0, SEEK_END);
size_t size = ftell(f);
if (size > 16 * 1024 * 1024) {
return false;
}
void* elfFile = malloc(size);
memset(elfFile, 0, size);
fseek(f, 0, SEEK_SET);
fread(elfFile, 1, size, f);
fclose(f);
int i;
bool phys = false;
if (elf_checkFile(elfFile) != 0) {
free(elfFile);
return false;
}
for (i = 0; i < elf_getNumProgramHeaders(elfFile); i++) {
/* Load that section */
uint64_t dest, src;
size_t len;
if (phys) {
dest = elf_getProgramHeaderPaddr(elfFile, i);
}
else {
dest = elf_getProgramHeaderVaddr(elfFile, i);
}
len = elf_getProgramHeaderFileSize(elfFile, i);
src = (uint64_t)(uintptr_t)elfFile + elf_getProgramHeaderOffset(elfFile, i);
u8* ptr = GetMemPtr(dest, len);
memcpy((void*)ptr, (void*)(uintptr_t)src, len);
ptr += len;
memset((void*)ptr, 0, elf_getProgramHeaderMemorySize(elfFile, i) - len);
}
return true;
}
int elf_load (addrspace_t dest_as, char *elf_file) {
int num_headers;
int err;
int i;
/* Ensure that the ELF file looks sane. */
if (elf_checkFile(elf_file)){
return seL4_InvalidArgument;
}
num_headers = elf_getNumProgramHeaders(elf_file);
for (i = 0; i < num_headers; i++) {
char *source_addr;
unsigned long flags, file_size, segment_size, vaddr;
/* Skip non-loadable segments (such as debugging data). */
if (elf_getProgramHeaderType(elf_file, i) != PT_LOAD)
continue;
/* Fetch information about this segment. */
source_addr = elf_file + elf_getProgramHeaderOffset(elf_file, i);
file_size = elf_getProgramHeaderFileSize(elf_file, i);
segment_size = elf_getProgramHeaderMemorySize(elf_file, i);
vaddr = elf_getProgramHeaderVaddr(elf_file, i);
flags = elf_getProgramHeaderFlags(elf_file, i);
/* Copy it across into the vspace. */
err = load_segment_directly_into_vspace(dest_as, source_addr,
segment_size, file_size, vaddr,
get_sel4_rights_from_elf(flags) & seL4_AllRights);
if (err != 0) {
return 1;
}
}
return 0;
}
int elf_load(seL4_RISCV_PageDirectory dest_as, char *elf_file) {
int num_headers;
int err;
int i;
/* Ensure that the ELF file looks sane. */
if (elf_checkFile(elf_file)){
return seL4_InvalidArgument;
}
num_headers = elf_getNumProgramHeaders(elf_file);
for (i = 0; i < num_headers; i++) {
char *source_addr;
unsigned long flags, file_size, segment_size, vaddr;
/* Skip non-loadable segments (such as debugging data). */
if (elf_getProgramHeaderType(elf_file, i) != PT_LOAD)
continue;
/* Fetch information about this segment. */
source_addr = elf_file + elf_getProgramHeaderOffset(elf_file, i);
file_size = elf_getProgramHeaderFileSize(elf_file, i);
segment_size = elf_getProgramHeaderMemorySize(elf_file, i);
vaddr = elf_getProgramHeaderVaddr(elf_file, i);
flags = elf_getProgramHeaderFlags(elf_file, i);
/* Copy it across into the vspace. */
dprintf(1, " * Loading segment %08x-->%08x\n", (int)vaddr, (int)(vaddr + segment_size));
err = load_segment_into_vspace(dest_as, source_addr, segment_size, file_size, vaddr,
get_sel4_rights_from_elf(flags) & seL4_AllRights);
conditional_panic(err != 0, "Elf loading failed!\n");
}
return 0;
}
/*
* Unpack an ELF file to the given physical address.
*/
static void unpack_elf_to_paddr(void *elf, paddr_t dest_paddr)
{
uint16_t i;
uint64_t min_vaddr, max_vaddr;
size_t image_size;
word_t phys_virt_offset;
/* Get size of the image. */
elf_getMemoryBounds(elf, 0, &min_vaddr, &max_vaddr);
image_size = (size_t)(max_vaddr - min_vaddr);
phys_virt_offset = dest_paddr - (paddr_t)min_vaddr;
/* Zero out all memory in the region, as the ELF file may be sparse. */
memset((char *)dest_paddr, 0, image_size);
/* Load each segment in the ELF file. */
for (i = 0; i < elf_getNumProgramHeaders(elf); i++) {
vaddr_t dest_vaddr;
size_t data_size, data_offset;
/* Skip segments that are not marked as being loadable. */
if (elf_getProgramHeaderType(elf, i) != PT_LOAD) {
continue;
}
/* Parse size/length headers. */
dest_vaddr = elf_getProgramHeaderVaddr(elf, i);
data_size = elf_getProgramHeaderFileSize(elf, i);
data_offset = elf_getProgramHeaderOffset(elf, i);
/* Load data into memory. */
memcpy((char *)dest_vaddr + phys_virt_offset,
(char *)elf + data_offset, data_size);
}
}
void elf_load(int pid, seL4_CPtr reply_cap, void *_args, int err) {
if (TMP_DEBUG) printf("elf_load\n");
elf_load_args *args = (elf_load_args *) _args;
if (err) {
eprintf("Error caught in elf_load\n");
args->cb(pid, reply_cap, args->cb_args, err);
free(args);
return;
}
char *elf_file = args->elf_file;
int curr_header = args->curr_header;
//addr_space *as = proc_table[pid];
/* Ensure that the ELF file looks sane. */
if (elf_checkFile(elf_file)){
eprintf("Error caught in elf_load\n");
args->cb(pid, reply_cap, args->cb_args, -1);
free(args);
return;
}
int num_headers = elf_getNumProgramHeaders(elf_file);
if (curr_header < num_headers) {
char *source_addr;
unsigned long flags, file_size, segment_size, vaddr;
/* Skip non-loadable segments (such as debugging data). */
if (elf_getProgramHeaderType(elf_file, curr_header) != PT_LOAD) {
args->curr_header++;
elf_load(pid, reply_cap, args, 0);
} else {
/* Fetch information about this segment. */
source_addr = elf_file + elf_getProgramHeaderOffset(elf_file, curr_header);
file_size = elf_getProgramHeaderFileSize(elf_file, curr_header);
segment_size = elf_getProgramHeaderMemorySize(elf_file, curr_header);
vaddr = elf_getProgramHeaderVaddr(elf_file, curr_header);
flags = elf_getProgramHeaderFlags(elf_file, curr_header);
/* Copy it across into the vspace. */
dprintf(1, " * Loading segment %08x-->%08x\n", (int)vaddr, (int)(vaddr + segment_size));
// Set up load segment arguments
args->curr_header++;
load_segment_args *segment_args = malloc(sizeof(load_segment_args));
if (segment_args == NULL) {
eprintf("Error caught in elf_load\n");
args->cb(pid, reply_cap, args->cb_args, -1);
free(args);
return;
}
segment_args->src = source_addr;
segment_args->dst = vaddr;
segment_args->pos = 0;
segment_args->segment_size = segment_size;
segment_args->file_size = file_size;
segment_args->permissions = get_sel4_rights_from_elf(flags) & seL4_AllRights;
segment_args->cb = elf_load;
segment_args->cb_args = args;
load_segment_into_vspace(pid, reply_cap, segment_args, 0);
}
//conditional_panic(err != 0, "Elf loading failed!\n");
} else {
// Do callback
printf("Doing callback with pid :%d\n", pid);
args->cb(pid, reply_cap, args->cb_args, 0);
free(args);
}
if (TMP_DEBUG) printf("elf_load end\n");
}
