2018-09-07 17:00:13 +02:00
|
|
|
/*
|
2019-04-08 04:00:49 +02:00
|
|
|
* Copyright (c) 2018-2019 Atmosphère-NX
|
2018-09-07 17:00:13 +02:00
|
|
|
*
|
|
|
|
* 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/>.
|
|
|
|
*/
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-05-03 06:18:05 +02:00
|
|
|
#include <cstdlib>
|
|
|
|
#include <cstdint>
|
|
|
|
#include <cstring>
|
|
|
|
#include <malloc.h>
|
|
|
|
|
|
|
|
#include <switch.h>
|
2018-11-08 10:24:40 +01:00
|
|
|
#include <atmosphere.h>
|
2018-05-03 06:18:05 +02:00
|
|
|
#include <stratosphere.hpp>
|
|
|
|
|
2018-05-03 12:10:05 +02:00
|
|
|
#include "pm_boot_mode.hpp"
|
2018-05-05 04:16:40 +02:00
|
|
|
#include "pm_info.hpp"
|
|
|
|
#include "pm_shell.hpp"
|
2018-05-03 12:10:05 +02:00
|
|
|
#include "pm_process_track.hpp"
|
2018-05-04 07:58:25 +02:00
|
|
|
#include "pm_registration.hpp"
|
2018-05-07 12:45:44 +02:00
|
|
|
#include "pm_debug_monitor.hpp"
|
2018-05-03 12:10:05 +02:00
|
|
|
|
2018-05-03 06:18:05 +02:00
|
|
|
extern "C" {
|
|
|
|
extern u32 __start__;
|
|
|
|
|
|
|
|
u32 __nx_applet_type = AppletType_None;
|
|
|
|
|
2019-03-27 01:47:29 +01:00
|
|
|
#define INNER_HEAP_SIZE 0x30000
|
2018-05-03 06:18:05 +02:00
|
|
|
size_t nx_inner_heap_size = INNER_HEAP_SIZE;
|
|
|
|
char nx_inner_heap[INNER_HEAP_SIZE];
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-05-03 06:18:05 +02:00
|
|
|
void __libnx_initheap(void);
|
|
|
|
void __appInit(void);
|
|
|
|
void __appExit(void);
|
2019-04-13 00:28:46 +02:00
|
|
|
|
|
|
|
/* Exception handling. */
|
|
|
|
alignas(16) u8 __nx_exception_stack[0x1000];
|
|
|
|
u64 __nx_exception_stack_size = sizeof(__nx_exception_stack);
|
|
|
|
void __libnx_exception_handler(ThreadExceptionDump *ctx);
|
|
|
|
u64 __stratosphere_title_id = TitleId_Pm;
|
|
|
|
void __libstratosphere_exception_handler(AtmosphereFatalErrorContext *ctx);
|
|
|
|
}
|
|
|
|
|
|
|
|
void __libnx_exception_handler(ThreadExceptionDump *ctx) {
|
|
|
|
StratosphereCrashHandler(ctx);
|
2018-05-03 06:18:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void __libnx_initheap(void) {
|
2018-09-09 08:47:15 +02:00
|
|
|
void* addr = nx_inner_heap;
|
|
|
|
size_t size = nx_inner_heap_size;
|
2018-05-03 06:18:05 +02:00
|
|
|
|
2018-09-09 08:47:15 +02:00
|
|
|
/* Newlib */
|
|
|
|
extern char* fake_heap_start;
|
|
|
|
extern char* fake_heap_end;
|
2018-05-03 06:18:05 +02:00
|
|
|
|
2018-09-09 08:47:15 +02:00
|
|
|
fake_heap_start = (char*)addr;
|
|
|
|
fake_heap_end = (char*)addr + size;
|
2018-05-03 06:18:05 +02:00
|
|
|
}
|
|
|
|
|
2018-10-18 01:26:36 +02:00
|
|
|
void RegisterPrivilegedProcessesWithFs() {
|
|
|
|
/* Ensures that all privileged processes are registered with full FS permissions. */
|
|
|
|
constexpr u64 PRIVILEGED_PROCESS_MIN = 0;
|
|
|
|
constexpr u64 PRIVILEGED_PROCESS_MAX = 0x4F;
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-10-18 01:26:36 +02:00
|
|
|
const u32 PRIVILEGED_FAH[0x1C/sizeof(u32)] = {0x00000001, 0x00000000, 0x80000000, 0x0000001C, 0x00000000, 0x0000001C, 0x00000000};
|
|
|
|
const u32 PRIVILEGED_FAC[0x2C/sizeof(u32)] = {0x00000001, 0x00000000, 0x80000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF};
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-11-08 14:28:52 +01:00
|
|
|
u32 num_pids;
|
|
|
|
u64 pids[PRIVILEGED_PROCESS_MAX+1];
|
|
|
|
if (R_SUCCEEDED(svcGetProcessList(&num_pids, pids, sizeof(pids)/sizeof(pids[0])))) {
|
|
|
|
for (u32 i = 0; i < num_pids; i++) {
|
|
|
|
const u64 pid = pids[i];
|
|
|
|
if (PRIVILEGED_PROCESS_MIN <= pid && pid <= PRIVILEGED_PROCESS_MAX) {
|
|
|
|
fsprUnregisterProgram(pid);
|
|
|
|
fsprRegisterProgram(pid, pid, FsStorageId_NandSystem, PRIVILEGED_FAH, sizeof(PRIVILEGED_FAH), PRIVILEGED_FAC, sizeof(PRIVILEGED_FAC));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (u64 pid = PRIVILEGED_PROCESS_MIN; pid <= PRIVILEGED_PROCESS_MAX; pid++) {
|
|
|
|
fsprUnregisterProgram(pid);
|
|
|
|
fsprRegisterProgram(pid, pid, FsStorageId_NandSystem, PRIVILEGED_FAH, sizeof(PRIVILEGED_FAH), PRIVILEGED_FAC, sizeof(PRIVILEGED_FAC));
|
|
|
|
}
|
2018-10-18 01:26:36 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-05-03 06:18:05 +02:00
|
|
|
void __appInit(void) {
|
|
|
|
Result rc;
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2019-02-20 23:17:51 +01:00
|
|
|
SetFirmwareVersionForLibnx();
|
2018-05-03 06:18:05 +02:00
|
|
|
|
2019-04-22 21:40:53 +02:00
|
|
|
DoWithSmSession([&]() {
|
|
|
|
rc = fsprInitialize();
|
|
|
|
if (R_FAILED(rc)) {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
/* This works around a bug with process permissions on < 4.0.0. */
|
|
|
|
RegisterPrivilegedProcessesWithFs();
|
|
|
|
|
|
|
|
rc = smManagerAmsInitialize();
|
|
|
|
if (R_SUCCEEDED(rc)) {
|
|
|
|
smManagerAmsEndInitialDefers();
|
|
|
|
smManagerAmsExit();
|
|
|
|
} else {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = smManagerInitialize();
|
|
|
|
if (R_FAILED(rc)) {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = lrInitialize();
|
|
|
|
if (R_FAILED(rc)) {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = ldrPmInitialize();
|
|
|
|
if (R_FAILED(rc)) {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = splInitialize();
|
|
|
|
if (R_FAILED(rc)) {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = fsInitialize();
|
|
|
|
if (R_FAILED(rc)) {
|
|
|
|
std::abort();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2018-11-08 10:24:40 +01:00
|
|
|
CheckAtmosphereVersion(CURRENT_ATMOSPHERE_VERSION);
|
2018-05-03 06:18:05 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void __appExit(void) {
|
|
|
|
/* Cleanup services. */
|
|
|
|
fsdevUnmountAll();
|
2018-05-03 10:58:11 +02:00
|
|
|
splExit();
|
2018-05-04 07:58:25 +02:00
|
|
|
smManagerExit();
|
|
|
|
ldrPmExit();
|
2018-05-03 06:18:05 +02:00
|
|
|
fsprExit();
|
|
|
|
lrExit();
|
|
|
|
fsExit();
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
2019-01-21 07:21:49 +01:00
|
|
|
HosThread process_track_thread;
|
2018-05-03 06:18:05 +02:00
|
|
|
consoleDebugInit(debugDevice_SVC);
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-05-03 12:10:05 +02:00
|
|
|
/* Initialize and spawn the Process Tracking thread. */
|
2018-05-04 07:58:25 +02:00
|
|
|
Registration::InitializeSystemResources();
|
2019-01-21 07:21:49 +01:00
|
|
|
if (R_FAILED(process_track_thread.Initialize(&ProcessTracking::MainLoop, NULL, 0x4000, 0x15))) {
|
2019-04-22 22:07:11 +02:00
|
|
|
std::abort();
|
2018-05-04 00:15:00 +02:00
|
|
|
}
|
2019-01-21 07:21:49 +01:00
|
|
|
if (R_FAILED(process_track_thread.Start())) {
|
2019-04-22 22:07:11 +02:00
|
|
|
std::abort();
|
2018-05-04 00:15:00 +02:00
|
|
|
}
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2019-04-22 22:07:11 +02:00
|
|
|
/* Create Server Manager. */
|
|
|
|
static auto s_server_manager = WaitableManager(1);
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-05-03 06:18:05 +02:00
|
|
|
/* TODO: Create services. */
|
2019-04-22 22:07:11 +02:00
|
|
|
s_server_manager.AddWaitable(new ServiceServer<ShellService>("pm:shell", 3));
|
2019-05-22 21:11:40 +02:00
|
|
|
s_server_manager.AddWaitable(new ServiceServer<DebugMonitorService>("pm:dmnt", 3));
|
2019-04-22 22:07:11 +02:00
|
|
|
s_server_manager.AddWaitable(new ServiceServer<BootModeService>("pm:bm", 6));
|
2019-05-22 21:11:40 +02:00
|
|
|
s_server_manager.AddWaitable(new ServiceServer<InformationService>("pm:info", 3));
|
2018-05-03 06:18:05 +02:00
|
|
|
|
|
|
|
/* Loop forever, servicing our services. */
|
2019-04-22 22:10:29 +02:00
|
|
|
s_server_manager.Process();
|
2019-04-22 21:40:53 +02:00
|
|
|
|
2018-09-09 08:47:15 +02:00
|
|
|
return 0;
|
2018-05-03 06:18:05 +02:00
|
|
|
}
|
|
|
|
|