mbr: update for the rewritten loader

Author: pcm720

mbr/include/loader.h

@@ -2,11 +2,28 @@
 #define _LOADER_H_
 #include <stdint.h>
 
-// Loads and executes the ELF boot_elf points to
-// Based on PS2SDK elf-loader
-int LoadEmbeddedELF(int resetIOP, uint8_t *boot_elf, int argc, char *argv[]);
+typedef enum {
+  ShutdownType_All,  // Default
+  ShutdownType_None, // NICHDD
+  ShutdownType_HDD,  // NIC
+} ShutdownType;
 
-// Loads ELF from file specified in argv[0]
-int LoadELFFromFile(int resetIOP, int argc, char *argv[]);
+typedef struct {
+  int argc;    // Argument count for the ELF binary
+  char **argv; // ELF arguments; argv[0] must be the path to the binary even if elfMem is set
+
+  void *elfMem; // Optional: Memory location of the ELF binary when loading ELF from memory
+  int elfSize;  // Optional: Size of the ELF binary in memory
+
+  char *ioprpPath; // Optional: Path to the IOPRP binary. Will be ignored when ioprpMem is set
+  void *ioprpMem;  // Optional: Memory location of the IOPRP binary when loading IOPRP image from memory
+  int ioprpSize;   // Optional: Size of the IOPRP binary in memory
+
+  int resetIOP;                  // Indicates if IOP reset is needed (1 = yes). If used with IOPRP, it will be ignored
+  ShutdownType dev9ShutdownType; // Type of shutdown to perform for DEV9
+} LoadOptions;
+
+// Loads ELF using specified options
+int loadELF(LoadOptions *options);
 
 #endif

mbr/src/disc.c

@@ -125,7 +125,12 @@ void handlePS1Disc(char *titleID, char *titleVersion) {
       free(titleID);
       free(titleVersion);
       char *argv[] = {HOSD_DKWDRV_PATH};
-      LoadELFFromFile(0, 1, argv);
+      LoadOptions opts = {
+          .argc = 1,
+          .argv = argv,
+      };
+      loadELF(&opts);
+      return;
     }
     DPRINTF("DKWDRV was not found, falling back to PS1DRV\n");
   }
@@ -149,7 +154,14 @@ void handlePS1Disc(char *titleID, char *titleVersion) {
   if (settings.flags & FLAG_PS1DRV_USE_VN) {
     DPRINTF("Starting PS1DRV via PS1VModeNeg with title ID %s and version %s\n", argv[0], argv[1]);
     sceSifExitCmd();
-    LoadEmbeddedELF(0, ps1vn_elf, 2, argv);
+    LoadOptions opts = {
+        .elfMem = ps1vn_elf,
+        .elfSize = size_ps1vn_elf,
+        .argc = 2,
+        .argv = argv,
+    };
+    loadELF(&opts);
+    return;
   } else {
     char *argv[] = {titleID, titleVersion};
     DPRINTF("Starting PS1DRV with title ID %s and version %s\n", argv[0], argv[1]);

mbr/src/hdd.c

@@ -79,7 +79,11 @@ void runFsck() {
     return;
 
   umountPFS();
-  LoadELFFromFile(0, 1, arg);
+  LoadOptions opts = {
+      .argc = 1,
+      .argv = arg,
+  };
+  loadELF(&opts);
 }
 
 // Mounts the partition specified in path

mbr/src/hdd_start.c

@@ -106,8 +106,13 @@ int handlePATINFO(int partFd, AttributeAreaFile elf, int argc, char *argv[]) {
   sceSifInitRpc(0);
 
   char *nargv[1] = {argv[2]};
-  LoadEmbeddedELF(0, elfMem, 1, nargv);
-  return 0;
+  LoadOptions opts = {
+      .elfMem = elfMem,
+      .elfSize = elf.size,
+      .argc = 1,
+      .argv = nargv,
+  };
+  return loadELF(&opts);
 }
 
 // Starts HDD application using data from the partition attribute area header
@@ -188,7 +193,11 @@ int startHDDApplication(int argc, char *argv[]) {
   if (!strncmp(bootPath, "pfs", 3)) {
     // Build the full path
     sprintf("%s:%s", bootPath, argv[2], bootPath);
-    return LoadELFFromFile(0, argc, argv);
+    LoadOptions opts = {
+        .argc = argc,
+        .argv = argv,
+    };
+    return loadELF(&opts);
   }
 
   return -1;

mbr/src/loader.c

@@ -1,3 +1,5 @@
+#include "loader.h"
+#include "dprintf.h"
 #include "init.h"
 #include <errno.h>
 #include <iopcontrol.h>
@@ -46,46 +48,101 @@ typedef struct {
 #define ELF_MAGIC 0x464c457f
 #define ELF_PT_LOAD 1
 
-// Loads and executes the ELF boot_elf points to
-// Based on PS2SDK elf-loader
-int LoadEmbeddedELF(int resetIOP, uint8_t *boot_elf, int argc, char *argv[]) {
+// Loads and executes the embedded loader with provided arguments
+int executeLoader(int argc, char *argv[]) {
   elf_header_t *eh;
   elf_pheader_t *eph;
   void *pdata;
   int i;
 
-  eh = (elf_header_t *)boot_elf;
+  DPRINTF("Starting the embedded ELF loader with argc = %d\n", argc);
+  for (i = 0; i < argc; i++)
+    DPRINTF("argv[%d] = %s\n", i, argv[i]);
+
+  eh = (elf_header_t *)loader_elf;
   if (_lw((uint32_t)&eh->ident) != ELF_MAGIC)
     __builtin_trap();
 
-  eph = (elf_pheader_t *)(boot_elf + eh->phoff);
+  eph = (elf_pheader_t *)(loader_elf + eh->phoff);
 
   // Scan through the ELF's program headers and copy them into RAM
   for (i = 0; i < eh->phnum; i++) {
     if (eph[i].type != ELF_PT_LOAD)
       continue;
 
-    pdata = (void *)(boot_elf + eph[i].offset);
+    pdata = (void *)(loader_elf + eph[i].offset);
     memcpy(eph[i].vaddr, pdata, eph[i].filesz);
   }
 
   FlushCache(0);
   FlushCache(2);
 
-  if (resetIOP) {
-    argc++;
-    char **nargv = malloc(argc * sizeof(char *));
-    for (i = 0; i < argc-1; i++)
-      nargv[i] = argv[i];
+  return ExecPS2((void *)eh->entry, NULL, argc, argv);
+}
 
-    nargv[argc-1] = "-iopreset";
+// Loads ELF from file specified in argv[0]
+int loadELF(LoadOptions *options) {
+  int argPos = 4; // Account for "-la="
+  int argc = 0;
+  char loaderArg[9] = "-la=\0\0\0\0\0";
+  char elfMemArg[22] = {0};
+  char ioprpMemArg[22] = {0};
 
-    free(argv);
-    argv = nargv;
+  // Basic arguments
+  if (options->resetIOP) {
+    loaderArg[argPos++] = 'R';
+    argc = 1;
+  }
+  if (options->dev9ShutdownType == ShutdownType_HDD) {
+    loaderArg[argPos++] = 'N';
+    argc = 1;
+  } else if (options->dev9ShutdownType == ShutdownType_None) {
+    loaderArg[argPos++] = 'D';
+    argc = 1;
   }
 
-  return ExecPS2((void *)eh->entry, NULL, argc, argv);
-}
+  // IOPRP
+  if (options->ioprpMem || options->ioprpPath) {
+    loaderArg[argPos++] = 'I';
+    argc = (argc == 0) ? 2 : argc + 1;
 
-// Loads ELF from file specified in argv[0]
-int LoadELFFromFile(int resetIOP, int argc, char *argv[]) { return LoadEmbeddedELF(resetIOP, loader_elf, argc, argv); }
+    if (options->ioprpMem)
+      sprintf(ioprpMemArg, "mem:%08lX:%08lX", (uint32_t)options->ioprpMem, (uint32_t)options->ioprpSize);
+  }
+
+  // In-memory ELF
+  if (options->elfMem) {
+    loaderArg[argPos++] = 'E';
+    argc = (argc == 0) ? 2 : argc + 1;
+
+    sprintf(elfMemArg, "mem:%08lX:%08lX", (uint32_t)options->elfMem, (uint32_t)options->elfSize);
+  }
+
+  char **argv = options->argv;
+  if (argc != 0) {
+    argv = malloc((argc + options->argc) * sizeof(char *));
+    // Copy the original arguments
+    for (int i = 0; i < options->argc; i++)
+      argv[i] = options->argv[i];
+
+    // Add loader arguments (ELF and IOPRP argument order is important)
+    int argvOffset = argc;
+    argc += options->argc;
+
+    // ELF argument
+    if (elfMemArg[0] != '\0')
+      argv[argc - (argvOffset--)] = elfMemArg;
+
+    // IOPRP argument
+    if (ioprpMemArg[0] != '\0')
+      argv[argc - (argvOffset--)] = ioprpMemArg;
+    else if (options->ioprpPath)
+      argv[argc - (argvOffset--)] = options->ioprpPath;
+
+    // Loader arguments
+    argv[argc - argvOffset] = loaderArg;
+  } else
+    argc = options->argc;
+
+  return executeLoader(argc, argv);
+}