Atmosphere/fusee/fusee-secondary/src/loader.c

164 lines
5 KiB
C
Raw Normal View History

2018-04-07 21:43:54 +00:00
#include "utils.h"
#include <stdint.h>
2018-04-07 21:43:54 +00:00
#include "loader.h"
#include "sd_utils.h"
#include "stage2.h"
#include "lib/printk.h"
#include "lib/vsprintf.h"
#include "lib/ini.h"
const char *g_bct0 = NULL;
loader_ctx_t g_loader_ctx = {0};
loader_ctx_t *get_loader_ctx(void) {
return &g_loader_ctx;
}
static int loadlist_entry_ini_handler(void *user, const char *section, const char *name, const char *value) {
load_file_t *load_file_ctx = (load_file_t *)user;
uintptr_t x = 0;
const char *ext = NULL;
if (strcmp(section, "stage2") == 0) {
if (strstr(name, load_file_ctx->key) == name) {
ext = name + strlen(load_file_ctx->key);
if (strcmp(ext, "_path") == 0) {
/* Copy in the path. */
strncpy(load_file_ctx->path, value, sizeof(load_file_ctx->path));
} else if (strcmp(ext, "_addr") == 0) {
/* Read in load address as a hex string. */
sscanf(value, "%x", &x);
load_file_ctx->load_address = x;
} else {
return 0;
}
} else {
return 0;
}
} else {
return 0;
}
return 1;
}
bool validate_load_address(uintptr_t load_addr) {
/* TODO: Actually validate addresses. */
(void)(load_addr);
return true;
}
void load_list_entry(const char *key) {
load_file_t load_file_ctx = {0};
load_file_ctx.key = key;
printk("Loading %s\n", key);
if (ini_parse_string(get_loader_ctx()->bct0, loadlist_entry_ini_handler, &load_file_ctx) < 0) {
printk("Error: Failed to parse BCT.ini!\n");
generic_panic();
}
if (load_file_ctx.load_address == 0 || load_file_ctx.path[0] == '\x00') {
printk("Error: Failed to determine where to load %s!\n", key);
generic_panic();
}
printk("Loading %s from %s to 0x%08x\n", key, load_file_ctx.path, load_file_ctx.load_address);
if (!validate_load_address(load_file_ctx.load_address)) {
printk("Error: Load address 0x%08x is invalid!\n");
generic_panic();
}
/* Read file off of SD. */
load_file_ctx.load_size = read_sd_file((void *)load_file_ctx.load_address, LOADER_FILESIZE_MAX, load_file_ctx.path);
if (load_file_ctx.load_size == 0) {
printk("Error: Failed to read %s!\n", load_file_ctx.path);
generic_panic();
}
/* Check for special keys. */
if (strcmp(key, LOADER_PACKAGE2_KEY) == 0) {
get_loader_ctx()->package2_loadfile = load_file_ctx;
} else if (strcmp(key, LOADER_EXOSPHERE_KEY) == 0) {
get_loader_ctx()->exosphere_loadfile = load_file_ctx;
} else if (strcmp(key, LOADER_TSECFW_KEY) == 0) {
get_loader_ctx()->tsecfw_loadfile = load_file_ctx;
} else if (strcmp(key, LOADER_WARMBOOT_KEY) == 0) {
get_loader_ctx()->warmboot_loadfile = load_file_ctx;
}
}
void parse_loadlist(const char *ll) {
printk("Parsing load list: %s\n", ll);
char load_list[0x200] = {0};
strncpy(load_list, ll, 0x200);
char *entry, *p;
/* entry will point to the start of the current entry. p will point to the current location in the list. */
entry = load_list;
p = load_list;
while (*p) {
if (*p == ' ' || *p == '\t') {
/* We're at the end of an entry. */
*p = '\x00';
/* Load the entry. */
load_list_entry(entry);
/* Skip to the next delimiter. */
for (; *p == ' ' || *p == '\t' || *p == '\x00'; p++) { }
if (*p != '|') {
printk("Error: Load list is malformed!\n");
generic_panic();
} else {
/* Skip to the next entry. */
for (; *p == ' ' || *p == '\t' || *p == '|'; p++) { }
entry = p;
}
}
p++;
if (*p == '\x00') {
/* We're at the end of the line, load the last entry */
load_list_entry(entry);
}
}
}
static int loadlist_ini_handler(void *user, const char *section, const char *name, const char *value) {
loader_ctx_t *loader_ctx = (loader_ctx_t *)user;
uintptr_t x = 0;
if (strcmp(section, "stage2") == 0) {
if (strcmp(name, LOADER_LOADLIST_KEY) == 0) {
parse_loadlist(value);
} else if (strcmp(name, LOADER_ENTRYPOINT_KEY) == 0) {
/* Read in entrypoint as a hex string. */
sscanf(value, "%x", &x);
loader_ctx->chainload_entrypoint = (entrypoint_t)x;
} else if (strcmp(name, LOADER_CUSTOMSPLASH_KEY) == 0) {
strncpy(loader_ctx->custom_splash_path, value, sizeof(loader_ctx->custom_splash_path));
} else {
return 0;
}
} else {
return 0;
}
return 1;
}
2018-04-07 21:43:54 +00:00
void load_payload(const char *bct0) {
loader_ctx_t *ctx = get_loader_ctx();
/* Set BCT0 global. */
ctx->bct0 = bct0;
if (ini_parse_string(ctx->bct0, loadlist_ini_handler, ctx) < 0) {
printk("Error: Failed to parse BCT.ini!\n");
generic_panic();
}
2018-04-07 21:43:54 +00:00
}