Merge pull request #60 from NathanNeurotic/codex/locate-and-update-system.loadelf

Fix PopStarter argv0 selector handling

Author: NathanNeurotic

bin/POPSLDR/system.lua

@@ -75,6 +75,7 @@ end
 local APP_DIR_LOCAL = NormalizeDirPath(APP_DIR or BOOT_PATH_RAW)
 LOG("APP_DIR_NORM="..APP_DIR_LOCAL)
 LOG("APP_DIR_POPSTARTER_JOIN="..JoinPath(APP_DIR_LOCAL, "POPSTARTER.ELF"))
+local SELECTOR_MODE = "basename"
 
 local function ResolveAsset(rel)
   return System.resolveAsset(rel) or JoinPath(APP_DIR_LOCAL, rel)
@@ -287,9 +288,9 @@ function PLDR.CheckPOPStarterDEPS(device)
   if device == UI.SCENES.GUSB then
     return doesFileExist("mass:/POPS/POPS_IOX.PAK")
   elseif device == UI.SCENES.GHDD then
-    local a = HDD.MountPartition("hdd0:__common", 1, FIO_MT_RDONLY)
+    local a = HDD.MountPartition("hdd0:__common", 0, FIO_MT_RDONLY)
     if a then
-      return a, doesFileExist("pfs1:/POPS/POPS.ELF"), doesFileExist("pfs1:/POPS/IOPRP252.IMG")
+      return a, doesFileExist("pfs0:/POPS/POPS.ELF"), doesFileExist("pfs0:/POPS/IOPRP252.IMG")
     else
       return a, false, false
     end
@@ -361,17 +362,17 @@ end
 function PLDR.HDD.CheckAvailableHddPopsParts()
   if not PLDR.HDD.HAS_CHECKED then --HDD is checked only once since it cannot be removed/replaced without damaging the console
     LOG("Checking available __.POPS Partitions")
-    if HDD.MountPartition("hdd0:__.POPS", 1, FIO_MT_RDONLY) then
+    if HDD.MountPartition("hdd0:__.POPS", 0, FIO_MT_RDONLY) then
       PLDR.HDD.MAINPART = true
-      HDD.UMountPartition(1)
+      HDD.UMountPartition(0)
     end
     LOG("__.POPS", PLDR.HDD.MAINPART)
     PLDR.HDD.FOUNDANY = PLDR.HDD.MAINPART
     for i=1, 9 do
-      if HDD.MountPartition(("hdd0:__.POPS%d"):format(i), 1, FIO_MT_RDONLY) then
+      if HDD.MountPartition(("hdd0:__.POPS%d"):format(i), 0, FIO_MT_RDONLY) then
         PLDR.HDD.EXTRAPARTS[i] = true
         PLDR.HDD.FOUNDANY = true
-        HDD.UMountPartition(1)
+        HDD.UMountPartition(0)
       end
       LOG("__.POPS"..i, PLDR.HDD.EXTRAPARTS[i])
     end
@@ -385,25 +386,25 @@ function PLDR.HDD.BuildGameList()
   PLDR.HDD.GAMEPARTS = {}
   if not PLDR.HDD.FOUNDANY then return end
   if PLDR.HDD.MAINPART then
-    if HDD.MountPartition("hdd0:__.POPS", 1, FIO_MT_RDONLY) then
+    if HDD.MountPartition("hdd0:__.POPS", 0, FIO_MT_RDONLY) then
       local start_index = #PLDR.GAMES
-      PLDR.GetPS1GameLists("pfs1:/", true)
+      PLDR.GetPS1GameLists("pfs0:/", true)
       for i = start_index + 1, #PLDR.GAMES do
         PLDR.HDD.GAMEPARTS[PLDR.GAMES[i]] = "hdd0:__.POPS"
       end
-      HDD.UMountPartition(1)
+      HDD.UMountPartition(0)
     end
   end
   for i=1, 9 do
     if PLDR.HDD.EXTRAPARTS[i] then
-      if HDD.MountPartition("hdd0:__.POPS"..i, 1, FIO_MT_RDONLY) then
+      if HDD.MountPartition("hdd0:__.POPS"..i, 0, FIO_MT_RDONLY) then
         local start_index = #PLDR.GAMES
         local partition = "hdd0:__.POPS"..i
-        PLDR.GetPS1GameLists("pfs1:/", true)
+        PLDR.GetPS1GameLists("pfs0:/", true)
         for j = start_index + 1, #PLDR.GAMES do
           PLDR.HDD.GAMEPARTS[PLDR.GAMES[j]] = partition
         end
-        HDD.UMountPartition(1)
+        HDD.UMountPartition(0)
       end
     end
   end
@@ -545,6 +546,34 @@ local function BuildPopstarterSelector(prefix, vcd_filename)
   return prefix..vcd_filename..".ELF"
 end
 
+local function SelectPopstarterSelectorPrefix(device_page)
+  if device_page == "USB" or device_page == "MMCE" or device_page == "SMB/MMCE" then
+    return "XX."
+  end
+  if device_page == "HDD" then
+    return ""
+  end
+  return "XX."
+end
+
+local function BuildPopstarterSelectorPath(device_page, game_name)
+  if game_name == nil or game_name == "" then
+    return ""
+  end
+  if device_page == "HDD" then
+    return "hdd0:__.POPS/"..game_name..".ELF"
+  end
+  if device_page == "USB" or device_page == "MMCE" or device_page == "SMB/MMCE" then
+    return "mass:/POPS/XX."..game_name..".ELF"
+  end
+  return game_name..".ELF"
+end
+
+local function DeriveGameNameFromSelection(raw_selection)
+  local vcd_filename = ExtractVcdFilename(raw_selection or "")
+  return SanitizeGameName(StripVcdExtension(vcd_filename))
+end
+
 local function HasBootPrefix(basename, desired_prefix)
   if basename == nil or basename == "" or desired_prefix == nil or desired_prefix == "" then
     return false
@@ -627,7 +656,7 @@ local function EnsureHDDReadyForLaunch(game)
   end
   local partition = PLDR.HDD.GAMEPARTS[game] or "hdd0:__.POPS"
   result.mount_partition = partition
-  result.mount_ok = HDD.MountPartition(partition, 1, FIO_MT_RDONLY)
+  result.mount_ok = HDD.MountPartition(partition, 0, FIO_MT_RDONLY)
   return result
 end
 
@@ -860,6 +889,12 @@ local function LaunchEngine(popstarter, argv, reboot_iop, context)
     context and context.bootparam or "unknown"
   )
   LaunchLog("LAUNCH: stage A argv_count:", exec_args and #exec_args or 0)
+  LaunchLog(
+    "LAUNCH: selector="..tostring(argv0),
+    "popstarter="..tostring(popstarter),
+    "reboot_iop="..tostring(reboot_iop)
+  )
+  LaunchLog("LAUNCH: loadELF argc (caller):", exec_args and #exec_args or 0)
   local rc
   if exec_args ~= nil and #exec_args > 0 and unpack_fn ~= nil then
     rc = System.loadELF(popstarter, reboot_iop, unpack_fn(exec_args))
@@ -984,10 +1019,37 @@ function PLDR.RunPOPStarterGame(gamelocation, game)
   local fallback_exists = false
   local bootparam_basename_used = normalized_basename
   local prefix_used = HasBootPrefix(normalized_basename, prefix) and prefix or ""
-  local vcd_filename = ExtractVcdFilename(game)
-  local game_name = SanitizeGameName(StripVcdExtension(vcd_filename))
-  local selector_prefix = "XX."
-  local argv0_selector = BuildPopstarterSelector(selector_prefix, game_name)
+  local game_name = DeriveGameNameFromSelection(game)
+  if game_name == "" or string.upper(game_name) == "POPSTARTER" then
+    LaunchLog("LAUNCH: GameName derivation failed for selection:", game)
+    BlockLaunchFailure(
+      "GameName derivation failed",
+      popstarter,
+      device_page,
+      nil,
+      game,
+      APP_DIR_LOCAL,
+      nil,
+      nil
+    )
+    return
+  end
+  local selector_prefix = SelectPopstarterSelectorPrefix(device_page)
+  local argv0_selector = BuildPopstarterSelectorPath(device_page, game_name)
+  if selector_prefix == "" and string.upper(game_name) == "POPSTARTER" then
+    LaunchLog("LAUNCH: Internal error: game_base derived as POPSTARTER; refusing to launch.", game)
+    BlockLaunchFailure(
+      "Internal error: game_base derived as POPSTARTER; refusing to launch.",
+      popstarter,
+      device_page,
+      nil,
+      game,
+      APP_DIR_LOCAL,
+      nil,
+      nil
+    )
+    return
+  end
   if boot_source_mode == "mass" and prefix_added and not bootparam_exists then
     fallback_bootparam = EnsureTrailingSlash(pops_root)..game
     fallback_exists = doesFileExist(fallback_bootparam)
@@ -1010,7 +1072,10 @@ function PLDR.RunPOPStarterGame(gamelocation, game)
   LaunchLog("LAUNCH: vcd basename used:", bootparam_basename_used)
   LaunchLog("LAUNCH: bootparam candidate:", bootparam, "exists:", tostring(bootparam_exists))
   LaunchLog("LAUNCH: derived GameName:", game_name)
+  LaunchLog("LAUNCH: selector mode:", SELECTOR_MODE)
+  LaunchLog("LAUNCH: selector prefix:", selector_prefix)
   LaunchLog("LAUNCH: argv0 selector:", argv0_selector)
+  LaunchLog("LAUNCH: loadELF argc (caller):", #argv)
   if fallback_bootparam ~= nil then
     LaunchLog("LAUNCH: bootparam fallback:", fallback_bootparam, "exists:", tostring(fallback_exists))
   end

src/elf_loader/include/elf-loader.h

@@ -22,6 +22,7 @@ extern "C" {
 
 // Before call this method be sure that you have previously called sbv_patch_disable_prefix_check();
 int LoadELFFromFile(const char *filename, int argc, char *argv[]);
+int LoadELFFromFileExecPS2(const char *filename, int argc, char *argv[]);
 
 /** Modify argv[0] when partition info should be kept
  *

src/elf_loader/src/elf.c

@@ -58,6 +58,67 @@ static char *store_arg(const char *src, char *storage, size_t storage_size, size
 	return dest;
 }
 
+static void copy_span(char *dest, size_t dest_size, const char *start, size_t len) {
+	if (!dest || dest_size == 0) {
+		return;
+	}
+	if (!start) {
+		dest[0] = '\0';
+		return;
+	}
+	if (len >= dest_size) {
+		len = dest_size - 1;
+	}
+	memcpy(dest, start, len);
+	dest[len] = '\0';
+}
+
+static void parse_selector_parts(const char *argv0, char *out_prefix, size_t out_prefix_size, char *out_game, size_t out_game_size) {
+	const char *last_dot;
+	const char *prefix = "XX.";
+	size_t prefix_len = strlen(prefix);
+	if (out_prefix_size > 0) {
+		out_prefix[0] = '\0';
+	}
+	if (out_game_size > 0) {
+		out_game[0] = '\0';
+	}
+	if (!argv0) {
+		return;
+	}
+	last_dot = strrchr(argv0, '.');
+	if (!last_dot) {
+		copy_span(out_game, out_game_size, argv0, strlen(argv0));
+		return;
+	}
+	if (strncmp(argv0, prefix, prefix_len) == 0) {
+		copy_span(out_prefix, out_prefix_size, "XX", 2);
+		copy_span(out_game, out_game_size, argv0 + prefix_len, (size_t)(last_dot - (argv0 + prefix_len)));
+		return;
+	}
+	copy_span(out_game, out_game_size, argv0, (size_t)(last_dot - argv0));
+}
+
+static void append_launch_log_line(const char *line) {
+	int fd = open("launch.log", O_WRONLY | O_CREAT, 0666);
+	if (fd < 0) {
+		return;
+	}
+	lseek(fd, 0, SEEK_END);
+	write(fd, line, strlen(line));
+	close(fd);
+}
+
+static void append_launch_log_fmt(const char *label, int index, const char *value) {
+	char buffer[256];
+	if (index >= 0) {
+		snprintf(buffer, sizeof(buffer), "LAUNCH: %s[%d]=%s\n", label, index, value ? value : "(null)");
+	} else {
+		snprintf(buffer, sizeof(buffer), "LAUNCH: %s=%s\n", label, value ? value : "(null)");
+	}
+	append_launch_log_line(buffer);
+}
+
 /* 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 {
@@ -109,9 +170,17 @@ int LoadELFFromFileWithPartition(const char *filename, int argc, char *argv[]) {
 	} else {
 		return fd;
 	}
+	DPRINTF("LAUNCH: argc_in=%d argv_ptr=%s\n", argc, argv ? "set" : "null");
+	{
+		char argc_buf[32];
+		snprintf(argc_buf, sizeof(argc_buf), "%d", argc);
+		append_launch_log_fmt("argc_in", -1, argc_buf);
+	}
+	append_launch_log_fmt("argv_ptr", -1, argv ? "set" : "null");
 	use_default_argv0 = (argc <= 0 || argv == NULL || argv[0] == NULL);
 	new_argc = use_default_argv0 ? 1 : argc;
 	DPRINTF("LAUNCH: argv0 source: %s\n", use_default_argv0 ? "resolved path" : "caller");
+	append_launch_log_fmt("argv0_source", -1, use_default_argv0 ? "resolved path" : "caller");
 	// Preparing filename and partition to be sent in the argv
 	if (new_argc + 1 > kMaxArgc) {
 		return -2;
@@ -134,18 +203,79 @@ int LoadELFFromFileWithPartition(const char *filename, int argc, char *argv[]) {
 	launch_argv[new_argc] = NULL;
 
 	DPRINTF("LAUNCH: Using LoadExecPS2\n");
+	DPRINTF("LAUNCH: exec path=%s\n", resolved_path);
 	DPRINTF("LAUNCH: argc=%d\n", new_argc);
+	DPRINTF("LAUNCH: use_default_argv0=%s argv0=%s\n",
+		use_default_argv0 ? "true" : "false",
+		launch_argv[0] ? launch_argv[0] : "(null)");
+	DPRINTF("LAUNCH: argv0_final=%s\n", use_default_argv0 ? resolved_path : (launch_argv[0] ? launch_argv[0] : "(null)"));
+	DPRINTF("LAUNCH: argv1=%s\n", launch_argv[1] ? launch_argv[1] : "(null)");
+	DPRINTF("LAUNCH: argv2_is_null=%s\n", launch_argv[2] == NULL ? "yes" : "no");
+	{
+		char selector_prefix[32];
+		char selector_game[128];
+		parse_selector_parts(launch_argv[0], selector_prefix, sizeof(selector_prefix), selector_game, sizeof(selector_game));
+		DPRINTF("LAUNCH: selector_prefix=%s selector_game=%s\n",
+			selector_prefix[0] ? selector_prefix : "(none)",
+			selector_game[0] ? selector_game : "(unknown)");
+		DPRINTF("LAUNCH: selector_mode=%s\n", selector_prefix[0] ? "XX" : "NO_PREFIX");
+		append_launch_log_fmt("selector_prefix", -1, selector_prefix[0] ? selector_prefix : "(none)");
+		append_launch_log_fmt("selector_game", -1, selector_game[0] ? selector_game : "(unknown)");
+		append_launch_log_fmt("selector_mode", -1, selector_prefix[0] ? "XX" : "NO_PREFIX");
+	}
+	append_launch_log_fmt("exec path", -1, resolved_path);
+	{
+		char argc_buf[32];
+		snprintf(argc_buf, sizeof(argc_buf), "%d", new_argc);
+		append_launch_log_fmt("argc", -1, argc_buf);
+	}
+	append_launch_log_fmt("use_default_argv0", -1, use_default_argv0 ? "true" : "false");
+	append_launch_log_fmt("argv0", -1, launch_argv[0]);
+	append_launch_log_fmt("argv1", -1, launch_argv[1]);
+	append_launch_log_fmt("argv2_is_null", -1, launch_argv[2] == NULL ? "yes" : "no");
+	append_launch_log_fmt("argv0_final", -1, use_default_argv0 ? resolved_path : launch_argv[0]);
 	for (i = 0; i < new_argc; i++) {
 		DPRINTF("LAUNCH: argv[%d]=%s\n", i, launch_argv[i] ? launch_argv[i] : "(null)");
+		append_launch_log_fmt("argv", i, launch_argv[i]);
 	}
 	DPRINTF("LAUNCH: argv[%d] is NULL: %s\n", new_argc, launch_argv[new_argc] == NULL ? "yes" : "no");
+	append_launch_log_fmt("argv_null", new_argc, launch_argv[new_argc] == NULL ? "yes" : "no");
 	/* LoadExecPS2 should not return on success. */
 	LoadExecPS2(resolved_path, new_argc, launch_argv);
 	DPRINTF("LAUNCH: RETURNED rc=%d\n", -1);
+	append_launch_log_line("LAUNCH: RETURNED rc=-1\n");
 	return -1;
 }
 
 int LoadELFFromFile(const char *filename, int argc, char *argv[])
 {
 	return LoadELFFromFileWithPartition(filename, argc, argv);
 }
+
+int LoadELFFromFileExecPS2(const char *filename, int argc, char *argv[])
+{
+	t_ExecData elfdata;
+	char resolved_path[256];
+	int ret;
+
+	if (argc <= 0 || argv == NULL || argv[0] == NULL) {
+		return -4;
+	}
+	if (resolve_exec_path(filename, resolved_path, sizeof(resolved_path)) < 0) {
+		return -1;
+	}
+	DPRINTF("LAUNCH: Using ExecPS2\n");
+	DPRINTF("POPSTARTER ExecPS2 argv0=%s\n", argv[0]);
+
+	SifInitRpc(0);
+	SifLoadFileInit();
+	ret = SifLoadElf(resolved_path, &elfdata);
+	SifLoadFileExit();
+
+	if (ret != 0 || elfdata.epc == 0) {
+		return -2;
+	}
+
+	ExecPS2((void *)elfdata.epc, (void *)elfdata.gp, argc, argv);
+	return -1;
+}

src/luasystem.cpp

@@ -491,6 +491,7 @@ static int lua_checkexist(lua_State *L){
 }
 extern "C" {
 int LoadELFFromFile(const char *filename, int argc, char *argv[]);
+int LoadELFFromFileExecPS2(const char *filename, int argc, char *argv[]);
 }
 static int lua_loadELF(lua_State *L)
 {
@@ -500,14 +501,21 @@ static int lua_loadELF(lua_State *L)
 	const char *elftoload = luaL_checklstring(L, 1, &size);
 	int rebootIOP = luaL_checkinteger(L, 2);
 	int extra_args = argc - 2;
-	char** p = (char**)malloc((extra_args + 1) * sizeof(const char*));
+	static char selector_buf[256];
+	static char *argv_static[2];
 	printf("# Loading ELF '%s' iop_reboot=%d, extra_args=%d\n", elftoload, rebootIOP, extra_args);
-	for (int x = 3; x <= argc; x++) {
-		p[x-3] = (char*)luaL_checkstring(L, x);
+	if (extra_args > 0) {
+		const char *selector = luaL_checkstring(L, 3);
+		snprintf(selector_buf, sizeof(selector_buf), "%s", selector ? selector : "");
+		argv_static[0] = selector_buf;
+		argv_static[1] = NULL;
+		printf("# Loading ELF argv0='%s' argc=1\n", argv_static[0]);
+		int rc = LoadELFFromFileExecPS2(elftoload, 1, argv_static);
+		lua_pushinteger(L, rc);
+		return 1;
 	}
-	p[extra_args] = NULL;
-	int rc = LoadELFFromFile(elftoload, extra_args, p);
-	free(p);
+	printf("# Loading ELF argv0 default (argc=0)\n");
+	int rc = LoadELFFromFile(elftoload, 0, NULL);
 	lua_pushinteger(L, rc);
 	return 1;
 }