Loader services refactor

sysmodules/loader/source/hbldr.c

@@ -0,0 +1,84 @@
+#include <3ds.h>
+#include <string.h>
+#include "hbldr.h"
+
+static u32 hbldrRefcount = 0;
+static Handle hbldrHandle = 0;
+
+Result hbldrInit(void)
+{
+    Result res;
+    if (AtomicPostIncrement(&hbldrRefcount)) return 0;
+
+    for(res = 0xD88007FA; res == (Result)0xD88007FA; svcSleepThread(500 * 1000LL)) {
+        res = svcConnectToPort(&hbldrHandle, "hb:ldr");
+        if(R_FAILED(res) && res != (Result)0xD88007FA) {
+            AtomicDecrement(&hbldrRefcount);
+            return res;
+        }
+    }
+
+    return 0;
+}
+
+void hbldrExit(void)
+{
+    if (AtomicDecrement(&hbldrRefcount)) return;
+    svcCloseHandle(hbldrHandle);
+}
+
+Result HBLDR_LoadProcess(Handle *outCodeSet, u32 textAddr, u32 kernelFlags, u64 titleId, const char *name)
+{
+    u32* cmdbuf = getThreadCommandBuffer(); // 0x11800
+    cmdbuf[0] = IPC_MakeHeader(1, 6, 0);
+    cmdbuf[1] = textAddr;
+    cmdbuf[2] = kernelFlags & 0xF00;
+    memcpy(&cmdbuf[3], &titleId, 8);
+    strncpy((char *)&cmdbuf[5], name, 8);
+    Result rc = svcSendSyncRequest(hbldrHandle);
+    if (R_SUCCEEDED(rc)) rc = cmdbuf[1];
+
+    *outCodeSet = R_SUCCEEDED(rc) ? cmdbuf[3] : 0;
+    return rc;
+}
+
+Result HBLDR_SetTarget(const char* path)
+{
+    u32 pathLen = strlen(path) + 1;
+    u32* cmdbuf = getThreadCommandBuffer();
+
+    cmdbuf[0] = IPC_MakeHeader(2, 0, 2); // 0x20002
+    cmdbuf[1] = IPC_Desc_StaticBuffer(pathLen, 0);
+    cmdbuf[2] = (u32)path;
+
+    Result rc = svcSendSyncRequest(hbldrHandle);
+    if (R_SUCCEEDED(rc)) rc = cmdbuf[1];
+    return rc;
+}
+
+Result HBLDR_SetArgv(const void* buffer, size_t size)
+{
+    u32* cmdbuf = getThreadCommandBuffer();
+
+    cmdbuf[0] = IPC_MakeHeader(3, 0, 2); // 0x30002
+    cmdbuf[1] = IPC_Desc_StaticBuffer(size, 1);
+    cmdbuf[2] = (u32)buffer;
+
+    Result rc = svcSendSyncRequest(hbldrHandle);
+    if (R_SUCCEEDED(rc)) rc = cmdbuf[1];
+    return rc;
+}
+
+Result HBLDR_PatchExHeaderInfo(ExHeader_Info *exheaderInfo)
+{
+    u32* cmdbuf = getThreadCommandBuffer();
+
+    cmdbuf[0] = IPC_MakeHeader(4, 0, 2); // 0x40002
+    cmdbuf[1] = IPC_Desc_Buffer(sizeof(*exheaderInfo), IPC_BUFFER_RW);
+    cmdbuf[2] = (u32)exheaderInfo;
+
+    Result rc = svcSendSyncRequest(hbldrHandle);
+    if (R_SUCCEEDED(rc)) rc = cmdbuf[1];
+
+    return rc;
+}

sysmodules/loader/source/hbldr.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <3ds/exheader.h>
+
+#define HBLDR_3DSX_TID  (*(vu64 *)0x1FF81100)
+
+Result hbldrInit(void);
+void hbldrExit(void);
+
+Result HBLDR_LoadProcess(Handle *outCodeSet, u32 textAddr, u32 kernelFlags, u64 titleId, const char *name);
+Result HBLDR_SetTarget(const char* path);
+Result HBLDR_SetArgv(const void* buffer, size_t size);
+Result HBLDR_PatchExHeaderInfo(ExHeader_Info *exheaderInfo);

sysmodules/loader/source/loader.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <3ds/types.h>
+
+void loaderHandleCommands(void *ctx);

sysmodules/loader/source/main.c

@@ -0,0 +1,126 @@
+#include <3ds.h>
+#include "memory.h"
+#include "patcher.h"
+#include "ifile.h"
+#include "util.h"
+#include "loader.h"
+#include "service_manager.h"
+
+u32 config, multiConfig, bootConfig;
+bool isN3DS, needToInitSd, isSdMode;
+
+// MAKE SURE fsreg has been init before calling this
+static Result fsldrPatchPermissions(void)
+{
+    u32 pid;
+    Result res = 0;
+    FS_ProgramInfo info;
+    ExHeader_Arm11StorageInfo storageInfo = {
+        .fs_access_info = FSACCESS_NANDRW | FSACCESS_NANDRO_RO | FSACCESS_SDMC_RW,
+    };
+
+    info.programId = 0x0004013000001302LL; // loader PID
+    info.mediaType = MEDIATYPE_NAND;
+    TRY(svcGetProcessId(&pid, CUR_PROCESS_HANDLE));
+    return FSREG_Register(pid, 0xFFFF000000000000LL, &info, &storageInfo);
+}
+
+static inline void loadCFWInfo(void)
+{
+    s64 out;
+
+    assertSuccess(svcGetSystemInfo(&out, 0x10000, 3));
+    config = (u32)out;
+    assertSuccess(svcGetSystemInfo(&out, 0x10000, 4));
+    multiConfig = (u32)out;
+    assertSuccess(svcGetSystemInfo(&out, 0x10000, 5));
+    bootConfig = (u32)out;
+
+    assertSuccess(svcGetSystemInfo(&out, 0x10000, 0x201));
+    isN3DS = (bool)out;
+    assertSuccess(svcGetSystemInfo(&out, 0x10000, 0x202));
+    needToInitSd = (bool)out;
+    assertSuccess(svcGetSystemInfo(&out, 0x10000, 0x203));
+    isSdMode = (bool)out;
+
+    IFile file;
+    if(needToInitSd) fileOpen(&file, ARCHIVE_SDMC, "/", FS_OPEN_READ); //Init SD card if SAFE_MODE is being booted
+}
+
+// this is called before main
+void __appInit()
+{
+    loadCFWInfo();
+
+    Result res;
+    for(res = 0xD88007FA; res == (Result)0xD88007FA; svcSleepThread(500 * 1000LL))
+    {
+        res = srvInit();
+        if(R_FAILED(res) && res != (Result)0xD88007FA)
+            panic(res);
+    }
+
+    assertSuccess(fsRegInit());
+    assertSuccess(fsldrPatchPermissions());
+
+    //fsldrInit();
+    assertSuccess(srvGetServiceHandle(fsGetSessionHandle(), "fs:LDR"));
+
+    // Hackjob
+    assertSuccess(FSUSER_InitializeWithSdkVersion(*fsGetSessionHandle(), 0x70200C8));
+    assertSuccess(FSUSER_SetPriority(0));
+
+    assertSuccess(pxiPmInit());
+}
+
+// this is called after main exits
+void __appExit()
+{
+    pxiPmExit();
+    //fsldrExit();
+    svcCloseHandle(*fsGetSessionHandle());
+    fsRegExit();
+    srvExit();
+}
+
+// stubs for non-needed pre-main functions
+void __sync_init();
+void __sync_fini();
+void __system_initSyscalls();
+
+void __ctru_exit()
+{
+    void __libc_fini_array(void);
+
+    __libc_fini_array();
+    __appExit();
+    __sync_fini();
+    svcExitProcess();
+}
+
+void initSystem()
+{
+    void __libc_init_array(void);
+
+    __sync_init();
+    __system_initSyscalls();
+    __appInit();
+
+    __libc_init_array();
+}
+
+static const ServiceManagerServiceEntry services[] = {
+    { "Loader", 1, loaderHandleCommands, false },
+    { NULL },
+};
+
+static const ServiceManagerNotificationEntry notifications[] = {
+    { 0x000, NULL },
+};
+
+int main(void)
+{
+    loadCFWInfo();
+    assertSuccess(ServiceManager_Run(services, notifications, NULL));
+    return 0;
+}

sysmodules/loader/source/patcher.c

@@ -355,10 +355,10 @@ error:
     while(true);
 }
 
-bool loadTitleExheader(u64 progId, ExHeader_Info *exheader)
+bool loadTitleExheaderInfo(u64 progId, ExHeader_Info *exheaderInfo)
 {
     /* Here we look for "/luma/titles/[u64 titleID in hex, uppercase]/exheader.bin"
-       If it exists it should be a decrypted exheader */
+       If it exists it should be a decrypted exheader / exheader info */
 
     char path[] = "/luma/titles/0000000000000000/exheader.bin";
     progIdToStr(path + 28, progId);
@@ -374,7 +374,7 @@ bool loadTitleExheader(u64 progId, ExHeader_Info *exheader)
     {
         u64 total;
 
-        if(R_FAILED(IFile_Read(&file, &total, exheader, sizeof(ExHeader_Info))) || total != sizeof(ExHeader_Info)) goto error;
+        if(R_FAILED(IFile_Read(&file, &total, exheaderInfo, sizeof(ExHeader_Info))) || total != sizeof(ExHeader_Info)) goto error;
     }
 
     IFile_Close(&file);

sysmodules/loader/source/patcher.h

@@ -44,4 +44,4 @@ extern bool isN3DS, needToInitSd, isSdMode;
 void patchCode(u64 progId, u16 progVer, u8 *code, u32 size, u32 textSize, u32 roSize, u32 dataSize, u32 roAddress, u32 dataAddress);
 Result fileOpen(IFile *file, FS_ArchiveID archiveId, const char *path, int flags);
 bool loadTitleCodeSection(u64 progId, u8 *code, u32 size);
-bool loadTitleExheader(u64 progId, ExHeader_Info *exheader);
+bool loadTitleExheaderInfo(u64 progId, ExHeader_Info *exheaderInfo);

sysmodules/loader/source/service_manager.c

@@ -0,0 +1,182 @@
+/*
+*   This file is part of Luma3DS
+*   Copyright (C) 2016-2019 Aurora Wright, TuxSH
+*
+*   This program is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   This program is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*
+*   Additional Terms 7.b and 7.c of GPLv3 apply to this file:
+*       * Requiring preservation of specified reasonable legal notices or
+*         author attributions in that material or in the Appropriate Legal
+*         Notices displayed by works containing it.
+*       * Prohibiting misrepresentation of the origin of that material,
+*         or requiring that modified versions of such material be marked in
+*         reasonable ways as different from the original version.
+*/
+
+#include <3ds.h>
+#include "service_manager.h"
+
+#define TRY(expr) if(R_FAILED(res = (expr))) goto cleanup;
+
+Result ServiceManager_Run(const ServiceManagerServiceEntry *services, const ServiceManagerNotificationEntry *notifications, const ServiceManagerContextAllocator *allocator)
+{
+    Result res = 0;
+
+    u32 numServices = 0;
+    u32 maxSessionsTotal = 0;
+    u32 numActiveSessions = 0;
+    bool terminationRequested = false;
+
+    for (u32 i = 0; services[i].name != NULL; i++) {
+        numServices++;
+        maxSessionsTotal += services[i].maxSessions;
+    }
+
+    Handle waitHandles[1 + numServices + maxSessionsTotal];
+    void *ctxs[maxSessionsTotal];
+    u8 handlerIds[maxSessionsTotal];
+
+    Handle replyTarget = 0;
+    s32 id = -1;
+    u32 *cmdbuf = getThreadCommandBuffer();
+
+    TRY(srvEnableNotification(&waitHandles[0]));
+
+    // Subscribe to notifications if needed.
+    for (u32 i = 0; notifications[i].handler != NULL; i++) {
+        // Termination & ready for reboot events send by PM using PublishToProcess don't require subscription.
+        if (notifications[i].id != 0x100 && notifications[i].id != 0x179) {
+            TRY(srvSubscribe(notifications[i].id));
+        }
+    }
+
+    for (u32 i = 0; i < numServices; i++) {
+        if (!services[i].isGlobalPort) {
+            TRY(srvRegisterService(&waitHandles[1 + i], services[i].name, (s32)services[i].maxSessions));
+        } else {
+            Handle clientPort;
+            TRY(svcCreatePort(&waitHandles[1 + i], &clientPort, services[i].name, (s32)services[i].maxSessions));
+            svcCloseHandle(clientPort);
+        }
+    }
+
+    while (!terminationRequested) {
+        if (replyTarget == 0) {
+            cmdbuf[0] = 0xFFFF0000;
+        }
+
+        id = -1;
+        res = svcReplyAndReceive(&id, waitHandles, 1 + numServices + numActiveSessions, replyTarget);
+
+        if (res == (Result)0xC920181A) {
+            // Session has been closed
+            u32 off;
+            if (id == -1) {
+                for (off = 0; off < numActiveSessions && waitHandles[1 + numServices + off] != replyTarget; off++);
+                if (off >= numActiveSessions) {
+                    return res;
+                }
+
+                id = 1 + numServices + off;
+            } else if ((u32)id < 1 + numServices) {
+                return res;
+            }
+
+            off = id - 1 - numServices;
+
+            Handle h = waitHandles[id];
+            void *ctx = ctxs[off];
+            waitHandles[id] = waitHandles[1 + numServices + --numActiveSessions];
+            handlerIds[off] = handlerIds[numActiveSessions];
+            ctxs[off] = ctxs[numActiveSessions];
+
+            svcCloseHandle(h);
+            if (allocator != NULL) {
+                allocator->freeSessionContext(ctx);
+            }
+
+            replyTarget = 0;
+            res = 0;
+        } else if (R_FAILED(res)) {
+            return res;
+        }
+
+        else {
+            // Ok, no session closed and no error
+            replyTarget = 0;
+            if (id == 0) {
+                // Notification
+                u32 notificationId = 0;
+                TRY(srvReceiveNotification(&notificationId));
+                terminationRequested = notificationId == 0x100;
+
+                for (u32 i = 0; notifications[i].handler != NULL; i++) {
+                    if (notifications[i].id == notificationId) {
+                        notifications[i].handler(notificationId);
+                        break;
+                    }
+                }
+            } else if ((u32)id < 1 + numServices) {
+                // New session
+                Handle session;
+                void *ctx = NULL;
+                TRY(svcAcceptSession(&session, waitHandles[id]));
+
+                if (allocator) {
+                    ctx = allocator->newSessionContext((u8)(id - 1));
+                    if (ctx == NULL) {
+                        svcCloseHandle(session);
+                        return 0xDEAD0000;
+                    }
+                }
+
+                waitHandles[1 + numServices + numActiveSessions] = session;
+                handlerIds[numActiveSessions] = (u8)(id - 1);
+                ctxs[numActiveSessions++] = ctx;
+            } else {
+                // Service command
+                u32 off = id - 1 - numServices;
+                services[handlerIds[off]].handler(ctxs[off]);
+                replyTarget = waitHandles[id];
+            }
+        }
+    }
+
+cleanup:
+    for (u32 i = 0; i < 1 + numServices + numActiveSessions; i++) {
+        svcCloseHandle(waitHandles[i]);
+    }
+
+    // Subscribe to notifications if needed.
+    for (u32 i = 0; notifications[i].handler != NULL; i++) {
+        // Termination & ready for reboot events send by PM using PublishToProcess don't require subscription.
+        if (notifications[i].id != 0x100 && notifications[i].id != 0x179) {
+            TRY(srvUnsubscribe(notifications[i].id));
+        }
+    }
+
+    for (u32 i = 0; i < numServices; i++) {
+        if (!services[i].isGlobalPort) {
+            srvUnregisterService(services[i].name);
+        }
+    }
+
+    if (allocator) {
+        for (u32 i = 0; i < numActiveSessions; i++) {
+            allocator->freeSessionContext(ctxs[i]);
+        }
+    }
+
+    return res;
+}

sysmodules/loader/source/service_manager.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <3ds/types.h>
+
+typedef struct ServiceManagerServiceEntry {
+    const char *name;
+    u32 maxSessions;
+    void (*handler)(void *ctx);
+    bool isGlobalPort;
+} ServiceManagerServiceEntry;
+
+typedef struct ServiceManagerNotificationEntry {
+    u32 id;
+    void (*handler)(u32 id);
+} ServiceManagerNotificationEntry;
+
+typedef struct ServiceManagerContextAllocator {
+    void* (*newSessionContext)(u8 serviceId);
+    void  (*freeSessionContext)(void *ctx);
+} ServiceManagerContextAllocator;
+
+Result ServiceManager_Run(const ServiceManagerServiceEntry *services, const ServiceManagerNotificationEntry *notifications, const ServiceManagerContextAllocator *allocator);

sysmodules/loader/source/util.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <3ds/types.h>
+#include <3ds/result.h>
+#include <3ds/os.h>
+#include <3ds/srv.h>
+
+
+#define REG32(reg)              (*(vu32 *)reg)
+#define REG64(reg)              (*(vu64 *)reg)
+
+#define TRY(expr)               if(R_FAILED(res = (expr))) return res;
+#define TRYG(expr, label)       if(R_FAILED(res = (expr))) goto label;
+
+#ifdef XDS
+static void hexItoa(u64 number, char *out, u32 digits, bool uppercase)
+{
+    const char hexDigits[] = "0123456789ABCDEF";
+    const char hexDigitsLowercase[] = "0123456789abcdef";
+    u32 i = 0;
+
+    while(number > 0)
+    {
+        out[digits - 1 - i++] = uppercase ? hexDigits[number & 0xF] : hexDigitsLowercase[number & 0xF];
+        number >>= 4;
+    }
+
+    while(i < digits) out[digits - 1 - i++] = '0';
+}
+#endif
+
+static void __attribute__((noinline)) panic(Result res)
+{
+#ifndef XDS
+    (void)res;
+    __builtin_trap();
+#else
+    char buf[32] = {0};
+    hexItoa(res, buf, 8, false);
+    svcOutputDebugString(buf, 8);
+    svcBreak(USERBREAK_PANIC);
+#endif
+}
+
+static inline Result assertSuccess(Result res)
+{
+    if(R_FAILED(res)) {
+        panic(res);
+    }
+
+    return res;
+}

sysmodules/pm/source/util.h

@@ -3,6 +3,7 @@
 #include <3ds/types.h>
 #include <3ds/result.h>
 #include <3ds/os.h>
+#include <3ds/srv.h>
 
 #define REG32(reg)              (*(vu32 *)reg)
 #define REG64(reg)              (*(vu64 *)reg)
@@ -20,7 +21,6 @@
 #define TRY(expr)               if(R_FAILED(res = (expr))) return res;
 #define TRYG(expr, label)       if(R_FAILED(res = (expr))) goto label;
 
-#define XDS
 #ifdef XDS
 static void hexItoa(u64 number, char *out, u32 digits, bool uppercase)
 {

sysmodules/rosalina/source/hbloader.c

@@ -149,7 +149,7 @@ void HBLDR_HandleCommands(void *ctx)
     u32 *cmdbuf = getThreadCommandBuffer();
     switch (cmdbuf[0] >> 16)
     {
-        case 1:
+        case 1: // LoadProcess
         {
             if (cmdbuf[0] != IPC_MakeHeader(1, 6, 0))
             {
@@ -212,7 +212,7 @@ void HBLDR_HandleCommands(void *ctx)
             cmdbuf[3] = hCodeset;
             break;
         }
-        case 2:
+        case 2: // SetTarget
         {
             if (cmdbuf[0] != IPC_MakeHeader(2, 0, 2) || (cmdbuf[1] & 0x3FFF) != 0x0002)
             {
@@ -232,7 +232,7 @@ void HBLDR_HandleCommands(void *ctx)
             cmdbuf[1] = 0;
             break;
         }
-        case 3:
+        case 3: // SetArgv
         {
             if (cmdbuf[0] != IPC_MakeHeader(3, 0, 2) || (cmdbuf[1] & 0x3FFF) != (0x2 | (1<<10)))
             {
@@ -244,7 +244,7 @@ void HBLDR_HandleCommands(void *ctx)
             cmdbuf[1] = 0;
             break;
         }
-        case 4:
+        case 4: // PatchExHeaderInfo
         {
             if (cmdbuf[0] != IPC_MakeHeader(4, 0, 2) || cmdbuf[1] != IPC_Desc_Buffer(sizeof(ExHeader_Info), IPC_BUFFER_RW))
             {
@@ -253,14 +253,14 @@ void HBLDR_HandleCommands(void *ctx)
             }
 
             // Perform ExHeader patches
-            ExHeader_Info* exh = (ExHeader_Info*)cmdbuf[2];
+            ExHeader_Info* exhi = (ExHeader_Info*)cmdbuf[2];
             u32 stacksize = 4096; // 3dsx/libctru don't require anymore than this
-            memcpy(exh->sci.codeset_info.name, "3dsx_app", 8);
+            memcpy(exhi->sci.codeset_info.name, "3dsx_app", 8);
-            memcpy(&exh->sci.codeset_info.stack_size, &stacksize, 4);
+            memcpy(&exhi->sci.codeset_info.stack_size, &stacksize, 4);
-            memset(&exh->sci.dependencies, 0, sizeof(exh->sci.dependencies));
+            memset(&exhi->sci.dependencies, 0, sizeof(exhi->sci.dependencies));
-            memcpy(exh->sci.dependencies, dependencyList, sizeof(dependencyList));
+            memcpy(exhi->sci.dependencies, dependencyList, sizeof(dependencyList));
 
-            ExHeader_Arm11SystemLocalCapabilities* localcaps0 = &exh->aci.local_caps;
+            ExHeader_Arm11SystemLocalCapabilities* localcaps0 = &exhi->aci.local_caps;
 
             localcaps0->core_info.core_version = 2;
             localcaps0->core_info.use_cpu_clockrate_804MHz = false;
@@ -285,20 +285,20 @@ void HBLDR_HandleCommands(void *ctx)
 
             localcaps0->reslimit_category = RESLIMIT_CATEGORY_APPLICATION;
 
-            ExHeader_Arm11KernelCapabilities* kcaps0 = &exh->aci.kernel_caps;
+            ExHeader_Arm11KernelCapabilities* kcaps0 = &exhi->aci.kernel_caps;
             memset(kcaps0->descriptors, 0xFF, sizeof(kcaps0->descriptors));
             memcpy(kcaps0->descriptors, kernelCaps, sizeof(kernelCaps));
 
             u64 lastdep = sizeof(dependencyList)/8;
             if (osGetFirmVersion() >= SYSTEM_VERSION(2,50,0)) // 9.6+ FIRM
             {
-                exh->sci.dependencies[lastdep++] = 0x0004013000004002ULL; // nfc
+                exhi->sci.dependencies[lastdep++] = 0x0004013000004002ULL; // nfc
                 strncpy((char*)&localcaps0->service_access[0x20], "nfc:u", 8);
                 s64 dummy = 0;
                 bool isN3DS = svcGetSystemInfo(&dummy, 0x10001, 0) == 0;
                 if (isN3DS)
                 {
-                    exh->sci.dependencies[lastdep++] = 0x0004013020004102ULL; // mvd
+                    exhi->sci.dependencies[lastdep++] = 0x0004013020004102ULL; // mvd
                     strncpy((char*)&localcaps0->service_access[0x21], "mvd:STD", 8);
                 }
             }
@@ -306,7 +306,7 @@ void HBLDR_HandleCommands(void *ctx)
             cmdbuf[0] = IPC_MakeHeader(4, 1, 2);
             cmdbuf[1] = 0;
             cmdbuf[2] = IPC_Desc_Buffer(sizeof(ExHeader_Info), IPC_BUFFER_RW);
-            cmdbuf[3] = (u32)exh;
+            cmdbuf[3] = (u32)exhi;
             break;
         }
         default: