git subrepo clone https://github.com/Atmosphere-NX/Atmosphere-libs libraries

subrepo:
  subdir:   "libraries"
  merged:   "07af583b"
upstream:
  origin:   "https://github.com/Atmosphere-NX/Atmosphere-libs"
  branch:   "master"
  commit:   "07af583b"
git-subrepo:
  version:  "0.4.0"
  origin:   "https://github.com/ingydotnet/git-subrepo"
  commit:   "5d6aba9"

libraries/libstratosphere/source/ams/ams_bpc.c

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/>.
+ */
+#define NX_SERVICE_ASSUME_NON_DOMAIN
+#include "../service_guard.h"
+#include "ams_bpc.h"
+
+static Service g_amsBpcSrv;
+
+NX_GENERATE_SERVICE_GUARD(amsBpc);
+
+Result _amsBpcInitialize(void) {
+    Handle h;
+    Result rc = svcConnectToNamedPort(&h, "bpc:ams"); /* TODO: ams:bpc */
+    if (R_SUCCEEDED(rc)) serviceCreate(&g_amsBpcSrv, h);
+    return rc;
+}
+
+void _amsBpcCleanup(void) {
+    serviceClose(&g_amsBpcSrv);
+}
+
+Service *amsBpcGetServiceSession(void) {
+    return &g_amsBpcSrv;
+}
+
+Result amsBpcRebootToFatalError(void *ctx) {
+    /* Note: this takes in an sts::ams::FatalErrorContext. */
+    /* static_assert(sizeof() == 0x350) is done at type definition. */
+    return serviceDispatch(&g_amsBpcSrv, 65000,
+        .buffer_attrs = { SfBufferAttr_Out | SfBufferAttr_HipcMapAlias | SfBufferAttr_FixedSize },
+        .buffers = { { ctx, 0x350 } },
+    );
+}

libraries/libstratosphere/source/ams/ams_bpc.h

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/>.
+ */
+
+#pragma once
+#include <switch/types.h>
+#include <switch/kernel/event.h>
+#include <switch/services/sm.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+Result amsBpcInitialize(void);
+void amsBpcExit(void);
+Service *amsBpcGetServiceSession(void);
+
+Result amsBpcRebootToFatalError(void *ctx);
+
+#ifdef __cplusplus
+}
+#endif

libraries/libstratosphere/source/ams/ams_emummc_api.cpp

@@ -0,0 +1,137 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/>.
+ */
+
+#include <stratosphere.hpp>
+
+namespace ams::emummc {
+
+    namespace {
+
+        /* Convenience Definitions. */
+        constexpr u32 StorageMagic = 0x30534645; /* EFS0 */
+        constexpr size_t MaxDirLen = 0x7F;
+
+        /* Types. */
+        struct BaseConfig {
+            u32 magic;
+            u32 type;
+            u32 id;
+            u32 fs_version;
+        };
+
+        struct PartitionConfig {
+            u64 start_sector;
+        };
+
+        struct FileConfig {
+            char path[MaxDirLen + 1];
+        };
+
+        struct ExosphereConfig {
+            BaseConfig base_cfg;
+            union {
+                PartitionConfig partition_cfg;
+                FileConfig file_cfg;
+            };
+            char emu_dir_path[MaxDirLen + 1];
+        };
+
+        enum Storage : u32 {
+            Storage_Emmc,
+            Storage_Sd,
+            Storage_SdFile,
+
+            Storage_Count,
+        };
+
+        /* Globals. */
+        os::Mutex g_lock;
+        ExosphereConfig g_exo_config;
+        bool g_is_emummc;
+        bool g_has_cached;
+
+        /* Helpers. */
+        void CacheValues() {
+            std::scoped_lock lk(g_lock);
+
+            if (g_has_cached) {
+                return;
+            }
+
+            /* Retrieve and cache values. */
+            {
+
+                typename std::aligned_storage<2 * (MaxDirLen + 1), os::MemoryPageSize>::type path_storage;
+
+                struct {
+                    char file_path[MaxDirLen + 1];
+                    char nintendo_path[MaxDirLen + 1];
+                } *paths = reinterpret_cast<decltype(paths)>(&path_storage);
+
+                /* Retrieve paths from secure monitor. */
+                AMS_ASSERT(spl::smc::AtmosphereGetEmummcConfig(&g_exo_config, paths, 0) == spl::smc::Result::Success);
+
+                const Storage storage = static_cast<Storage>(g_exo_config.base_cfg.type);
+                g_is_emummc = g_exo_config.base_cfg.magic == StorageMagic && storage != Storage_Emmc;
+
+                /* Format paths. Ignore string format warnings. */
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wformat-truncation"
+                {
+                    if (storage == Storage_SdFile) {
+                        std::snprintf(g_exo_config.file_cfg.path, sizeof(g_exo_config.file_cfg.path), "/%s", paths->file_path);
+                    }
+
+                    std::snprintf(g_exo_config.emu_dir_path, sizeof(g_exo_config.emu_dir_path), "/%s", paths->nintendo_path);
+
+                    /* If we're emummc, implement default nintendo redirection path. */
+                    if (g_is_emummc && std::strcmp(g_exo_config.emu_dir_path, "/") == 0) {
+                        std::snprintf(g_exo_config.emu_dir_path, sizeof(g_exo_config.emu_dir_path), "/emummc/Nintendo_%04x", g_exo_config.base_cfg.id);
+                    }
+                }
+                #pragma GCC diagnostic pop
+            }
+
+            g_has_cached = true;
+        }
+
+    }
+
+    /* Get whether emummc is active. */
+    bool IsActive() {
+        CacheValues();
+        return g_is_emummc;
+    }
+
+    /* Get Nintendo redirection path. */
+    const char *GetNintendoDirPath() {
+        CacheValues();
+        if (!g_is_emummc) {
+            return nullptr;
+        }
+        return g_exo_config.emu_dir_path;
+    }
+
+    /* Get Emummc folderpath, NULL if not file-based. */
+    const char *GetFilePath() {
+        CacheValues();
+        if (!g_is_emummc || g_exo_config.base_cfg.type != Storage_SdFile) {
+            return nullptr;
+        }
+        return g_exo_config.file_cfg.path;
+    }
+
+}

libraries/libstratosphere/source/ams/ams_environment.cpp

@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/>.
+ */
+
+#include <stratosphere.hpp>
+#include "ams_bpc.h"
+
+namespace ams {
+
+    namespace {
+
+        inline u64 GetPc() {
+            u64 pc;
+            __asm__ __volatile__ ("adr %[pc], ." : [pc]"=&r"(pc) :: );
+            return pc;
+        }
+
+        struct StackFrame {
+            u64 fp;
+            u64 lr;
+        };
+
+    }
+
+    extern ncm::ProgramId CurrentProgramId;
+
+    void WEAK ExceptionHandler(FatalErrorContext *ctx) {
+        R_ASSERT(amsBpcInitialize());
+        R_ASSERT(amsBpcRebootToFatalError(ctx));
+        while (1) { /* ... */ }
+    }
+
+    void CrashHandler(ThreadExceptionDump *ctx) {
+        FatalErrorContext ams_ctx;
+
+        /* Convert thread dump to atmosphere dump. */
+        {
+            ams_ctx.magic = FatalErrorContext::Magic;
+            ams_ctx.error_desc = ctx->error_desc;
+            ams_ctx.program_id = static_cast<u64>(CurrentProgramId);
+            for (size_t i = 0; i < FatalErrorContext::NumGprs; i++) {
+                ams_ctx.gprs[i] = ctx->cpu_gprs[i].x;
+            }
+            if (ams_ctx.error_desc == FatalErrorContext::DataAbortErrorDesc &&
+                ams_ctx.gprs[27] == FatalErrorContext::StdAbortMagicAddress &&
+                ams_ctx.gprs[28] == FatalErrorContext::StdAbortMagicValue)
+            {
+                /* Detect std::abort(). */
+                ams_ctx.error_desc = FatalErrorContext::StdAbortErrorDesc;
+            }
+
+            ams_ctx.fp = ctx->fp.x;
+            ams_ctx.lr = ctx->lr.x;
+            ams_ctx.sp = ctx->sp.x;
+            ams_ctx.pc = ctx->pc.x;
+            ams_ctx.pstate = ctx->pstate;
+            ams_ctx.afsr0 = ctx->afsr0;
+            ams_ctx.afsr1 = ctx->afsr1;
+            ams_ctx.far = ctx->far.x;
+            ams_ctx.report_identifier = armGetSystemTick();
+            /* Grab module base. */
+            {
+                MemoryInfo mem_info;
+                u32 page_info;
+                if (R_SUCCEEDED(svcQueryMemory(&mem_info, &page_info, GetPc()))) {
+                    ams_ctx.module_base = mem_info.addr;
+                } else {
+                    ams_ctx.module_base = 0;
+                }
+            }
+            ams_ctx.stack_trace_size = 0;
+            u64 cur_fp = ams_ctx.fp;
+            for (size_t i = 0; i < FatalErrorContext::MaxStackTrace; i++) {
+                /* Validate current frame. */
+                if (cur_fp == 0 || (cur_fp & 0xF)) {
+                    break;
+                }
+
+                /* Read a new frame. */
+                StackFrame cur_frame;
+                MemoryInfo mem_info;
+                u32 page_info;
+                if (R_SUCCEEDED(svcQueryMemory(&mem_info, &page_info, cur_fp)) && (mem_info.perm & Perm_R) == Perm_R) {
+                    std::memcpy(&cur_frame, reinterpret_cast<void *>(cur_fp), sizeof(cur_frame));
+                } else {
+                    break;
+                }
+
+                /* Advance to the next frame. */
+                ams_ctx.stack_trace[ams_ctx.stack_trace_size++] = cur_frame.lr;
+                cur_fp = cur_frame.fp;
+            }
+            /* Clear unused parts of stack trace. */
+            for (size_t i = ams_ctx.stack_trace_size; i < FatalErrorContext::MaxStackTrace; i++) {
+                ams_ctx.stack_trace[i] = 0;
+            }
+
+            /* Grab up to 0x100 of stack. */
+            {
+                MemoryInfo mem_info;
+                u32 page_info;
+                if (R_SUCCEEDED(svcQueryMemory(&mem_info, &page_info, ams_ctx.sp)) && (mem_info.perm & Perm_R) == Perm_R) {
+                    size_t copy_size = std::min(FatalErrorContext::MaxStackDumpSize, static_cast<size_t>(mem_info.addr + mem_info.size - ams_ctx.sp));
+                    ams_ctx.stack_dump_size = copy_size;
+                    std::memcpy(ams_ctx.stack_dump, reinterpret_cast<void *>(ams_ctx.sp), copy_size);
+                } else {
+                    ams_ctx.stack_dump_size = 0;
+                }
+            }
+        }
+
+        /* Just call the user exception handler. */
+        ::ams::ExceptionHandler(&ams_ctx);
+    }
+
+    inline NORETURN void AbortImpl() {
+        /* Just perform a data abort. */
+        register u64 addr __asm__("x27") = FatalErrorContext::StdAbortMagicAddress;
+        register u64 val __asm__("x28")  = FatalErrorContext::StdAbortMagicValue;
+        while (true) {
+            __asm__ __volatile__ (
+                "str %[val], [%[addr]]"
+                :
+                : [val]"r"(val), [addr]"r"(addr)
+            );
+        }
+        __builtin_unreachable();
+    }
+
+}
+
+extern "C" {
+
+    /* Redefine abort to trigger these handlers. */
+    void abort();
+
+    /* Redefine C++ exception handlers. Requires wrap linker flag. */
+    #define WRAP_ABORT_FUNC(func) void NORETURN __wrap_##func(void) { abort(); __builtin_unreachable(); }
+    WRAP_ABORT_FUNC(__cxa_pure_virtual)
+    WRAP_ABORT_FUNC(__cxa_throw)
+    WRAP_ABORT_FUNC(__cxa_rethrow)
+    WRAP_ABORT_FUNC(__cxa_allocate_exception)
+    WRAP_ABORT_FUNC(__cxa_free_exception)
+    WRAP_ABORT_FUNC(__cxa_begin_catch)
+    WRAP_ABORT_FUNC(__cxa_end_catch)
+    WRAP_ABORT_FUNC(__cxa_call_unexpected)
+    WRAP_ABORT_FUNC(__cxa_call_terminate)
+    WRAP_ABORT_FUNC(__gxx_personality_v0)
+    WRAP_ABORT_FUNC(_ZSt19__throw_logic_errorPKc)
+    WRAP_ABORT_FUNC(_ZSt20__throw_length_errorPKc)
+    WRAP_ABORT_FUNC(_ZNSt11logic_errorC2EPKc)
+
+    /* TODO: We may wish to consider intentionally not defining an _Unwind_Resume wrapper. */
+    /* This would mean that a failure to wrap all exception functions is a linker error. */
+    WRAP_ABORT_FUNC(_Unwind_Resume)
+    #undef WRAP_ABORT_FUNC
+
+}
+
+/* Custom abort handler, so that std::abort will trigger these. */
+void abort() {
+    ams::AbortImpl();
+    __builtin_unreachable();
+}

libraries/libstratosphere/source/ams/ams_exosphere_api.cpp

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2018-2019 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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/>.
+ */
+
+#include <stratosphere.hpp>
+#include <stratosphere/spl.hpp>
+#include <stratosphere/spl/smc/spl_smc.hpp>
+
+namespace ams::exosphere {
+
+    ApiInfo GetApiInfo() {
+        u64 exosphere_cfg;
+        if (spl::smc::GetConfig(&exosphere_cfg, 1, SplConfigItem_ExosphereApiVersion) != spl::smc::Result::Success) {
+            R_ASSERT(ResultNotPresent());
+        }
+
+        return ApiInfo{
+            .major_version = static_cast<u32>((exosphere_cfg >> 0x20) & 0xFF),
+            .minor_version = static_cast<u32>((exosphere_cfg >> 0x18) & 0xFF),
+            .micro_version = static_cast<u32>((exosphere_cfg >> 0x10) & 0xFF),
+            .target_firmware = static_cast<TargetFirmware>((exosphere_cfg >> 0x08) & 0xFF),
+            .master_key_revision = static_cast<u32>((exosphere_cfg >> 0x00) & 0xFF),
+        };
+    }
+
+    void ForceRebootToRcm() {
+        R_ASSERT(spl::smc::ConvertResult(spl::smc::SetConfig(SplConfigItem_ExosphereNeedsReboot, 1)));
+    }
+
+    void ForceRebootToIramPayload() {
+        R_ASSERT(spl::smc::ConvertResult(spl::smc::SetConfig(SplConfigItem_ExosphereNeedsReboot, 2)));
+    }
+
+    void ForceShutdown() {
+        R_ASSERT(spl::smc::ConvertResult(spl::smc::SetConfig(SplConfigItem_ExosphereNeedsShutdown, 1)));
+    }
+
+    void CopyToIram(uintptr_t iram_dst, const void *dram_src, size_t size) {
+        spl::smc::AtmosphereCopyToIram(iram_dst, dram_src, size);
+    }
+
+    void CopyFromIram(void *dram_dst, uintptr_t iram_src, size_t size) {
+        spl::smc::AtmosphereCopyFromIram(dram_dst, iram_src, size);
+    }
+
+    namespace {
+
+        inline Result GetRcmBugPatched(bool *out) {
+            u64 tmp = 0;
+            R_TRY(spl::smc::ConvertResult(spl::smc::GetConfig(&tmp, 1, SplConfigItem_ExosphereHasRcmBugPatch)));
+            *out = (tmp != 0);
+            return ResultSuccess();
+        }
+
+    }
+
+    bool IsRcmBugPatched() {
+        bool rcm_bug_patched;
+        R_ASSERT(GetRcmBugPatched(&rcm_bug_patched));
+        return rcm_bug_patched;
+    }
+
+}