elf.c

/*
# _____     ___ ____     ___ ____
#  ____|   |    ____|   |        | |____|
# |     ___|   |____ ___|    ____| |    \    PS2DEV Open Source Project.
#-----------------------------------------------------------------------
# (c) 2020 Francisco Javier Trujillo Mata <fjtrujy@gmail.com>
# Licenced under Academic Free License version 2.0
# Review ps2sdk README & LICENSE files for further details.
*/
 
#include <string.h>
#include <sifrpc.h>
#include <kernel.h>
#include <sys/stat.h>
#include <stdbool.h>
#include <stdlib.h>
 
#include "elf.h"
 
// Loader ELF variables
extern u8 loader_elf[];
extern int size_loader_elf;
 
// ELF-loading stuff
#define ELF_MAGIC 0x464c457f
#define ELF_PT_LOAD 1
 
static bool file_exists(const char *filename) {
    struct stat   buffer;   
    return (stat (filename, &buffer) == 0);
}
 
/* IMPORTANT: This method wipe memory where the loader is going to be allocated 
* This values come from the linkfile used by the loader.c
MEMORY {
    bios    : ORIGIN = 0x00000000, LENGTH = 528K --- 0x00000000 - 0x00084000: BIOS memory
    bram    : ORIGIN = 0x00084000, LENGTH = 496K --- 0x00084000 - 0x00100000: BIOS unused memory
    gram    : ORIGIN = 0x00100000, LENGTH =  31M --- 0x00100000 - 0x02000000: GAME memory
}
*/
 
static void wipe_bramMem(void) {
    int i;
    for (i = 0x00084000; i < 0x100000; i += 64) {
        asm volatile(
            "\tsq $0, 0(%0) \n"
            "\tsq $0, 16(%0) \n"
            "\tsq $0, 32(%0) \n"
            "\tsq $0, 48(%0) \n" ::"r"(i));
    }
}
 
int LoadELFFromFileWithPartition(const char *filename, const char *partition, int argc, char *argv[]) {
    u8 *boot_elf;
    elf_header_t *eh;
    elf_pheader_t *eph;
    void *pdata;
    int i;
    int new_argc = argc + 2;
    
    // We need to check that the ELF file before continue
    if (!file_exists(filename)) {
        return -1; // ELF file doesn't exists
    }
    // ELF Exists
    wipe_bramMem();
 
    // Preparing filename and partition to be sent in the argv
    char *new_argv[argc + 2];
    new_argv[0] = partition != NULL ? (char *)partition : "";
    new_argv[1] = (char *)filename;
    for (i = 0; i < argc; i++) {
        new_argv[i + 2] = argv[i];
    }
    
    /* NB: LOADER.ELF is embedded  */
    boot_elf = (u8 *)loader_elf;
    eh = (elf_header_t *)boot_elf;
    if (_lw((u32)&eh->ident) != ELF_MAGIC)
        __builtin_trap();
 
    eph = (elf_pheader_t *)(boot_elf + eh->phoff);
 
    /* Scan through the ELF's program headers and copy them into RAM, then zero out any non-loaded regions.  */
    for (i = 0; i < eh->phnum; i++) {
        if (eph[i].type != ELF_PT_LOAD)
            continue;
 
        pdata = (void *)(boot_elf + eph[i].offset);
        memcpy(eph[i].vaddr, pdata, eph[i].filesz);
 
        if (eph[i].memsz > eph[i].filesz)
            memset((void *)((u8 *)(eph[i].vaddr) + eph[i].filesz), 0, eph[i].memsz - eph[i].filesz);
    }
 
    /* Let's go.  */
    SifExitRpc();
    FlushCache(0);
    FlushCache(2);
    
    return ExecPS2((void *)eh->entry, NULL, new_argc, new_argv);
}
 
int LoadELFFromFile(const char *filename, int argc, char *argv[])
{
    return LoadELFFromFileWithPartition(filename, NULL, argc, argv);
}