nold/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere synced 2024-09-19 22:59:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

stratosphere: prefer static waitable managers

Browse source
This commit is contained in:
Michael Scire 2019-06-20 13:15:39 -07:00
parent d3d6c552b7
commit 1671c04e24
10 changed files with 39 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
stratosphere/ams_mitm/source/bpc_mitm/bpcmitm_main.cpp
View file

@ -38,23 +38,20 @@ void BpcMitmMain(void *arg) {
BpcRebootManager::Initialize();
/* Create server manager */
auto server_manager = new WaitableManager(2);
static auto s_server_manager = WaitableManager(2);
/* Create bpc mitm. */
const char *service_name = "bpc";
if (GetRuntimeFirmwareVersion() < FirmwareVersion_200) {
service_name = "bpc:c";
}
AddMitmServerToManager<BpcMitmService>(server_manager, service_name, 13);
AddMitmServerToManager<BpcMitmService>(&s_server_manager, service_name, 13);
/* Extension: Allow for reboot-to-error. */
/* Must be managed port in order for sm to be able to access. */
server_manager->AddWaitable(new ManagedPortServer<BpcAtmosphereService>("bpc:ams", 1));
s_server_manager.AddWaitable(new ManagedPortServer<BpcAtmosphereService>("bpc:ams", 1));
/* Loop forever, servicing our services. */
server_manager->Process();
delete server_manager;
s_server_manager.Process();
}

8
stratosphere/ams_mitm/source/fs_mitm/fsmitm_main.cpp
View file

@ -37,14 +37,12 @@ using FsMitmManager = WaitableManager<FsMitmManagerOptions>;
void FsMitmMain(void *arg) {
/* Create server manager. */
auto server_manager = new FsMitmManager(5);
static auto s_server_manager = FsMitmManager(5);
/* Create fsp-srv mitm. */
AddMitmServerToManager<FsMitmService>(server_manager, "fsp-srv", 61);
AddMitmServerToManager<FsMitmService>(&s_server_manager, "fsp-srv", 61);
/* Loop forever, servicing our services. */
server_manager->Process();
delete server_manager;
s_server_manager.Process();
}

11
stratosphere/ams_mitm/source/ns_mitm/nsmitm_main.cpp
View file

@ -41,19 +41,16 @@ void NsMitmMain(void *arg) {
nsExit();
/* Create server manager */
auto server_manager = new WaitableManager(1);
static auto s_server_manager = WaitableManager(1);
/* Create ns mitm. */
if (GetRuntimeFirmwareVersion() < FirmwareVersion_300) {
AddMitmServerToManager<NsAmMitmService>(server_manager, "ns:am", 5);
AddMitmServerToManager<NsAmMitmService>(&s_server_manager, "ns:am", 5);
} else {
AddMitmServerToManager<NsWebMitmService>(server_manager, "ns:web", 5);
AddMitmServerToManager<NsWebMitmService>(&s_server_manager, "ns:web", 5);
}
/* Loop forever, servicing our services. */
server_manager->Process();
delete server_manager;
s_server_manager.Process();
}

11
stratosphere/ams_mitm/source/set_mitm/setmitm_main.cpp
View file

@ -48,18 +48,15 @@ void SetMitmMain(void *arg) {
VersionManager::Initialize();
/* Create server manager */
auto server_manager = new SetMitmManager(4);
static auto s_server_manager = SetMitmManager(4);
/* Create set:sys mitm. */
AddMitmServerToManager<SetSysMitmService>(server_manager, "set:sys", 60);
AddMitmServerToManager<SetSysMitmService>(&s_server_manager, "set:sys", 60);
/* Create set mitm. */
AddMitmServerToManager<SetMitmService>(server_manager, "set", 60);
AddMitmServerToManager<SetMitmService>(&s_server_manager, "set", 60);
/* Loop forever, servicing our services. */
server_manager->Process();
delete server_manager;
s_server_manager.Process();
}

21
stratosphere/dmnt/source/dmnt_cheat_manager.cpp
View file

@ -987,8 +987,8 @@ void DmntCheatManager::OnNewApplicationLaunch() {
}
void DmntCheatManager::DetectThread(void *arg) {
auto waiter = new WaitableManager(1);
waiter->AddWaitable(LoadReadOnlySystemEvent(PrepareDebugNextApplication(), [](u64 timeout) {
static auto s_waiter = WaitableManager(1);
s_waiter.AddWaitable(LoadReadOnlySystemEvent(PrepareDebugNextApplication(), [](u64 timeout) {
/* Process stuff for new application. */
DmntCheatManager::OnNewApplicationLaunch();
@ -998,8 +998,7 @@ void DmntCheatManager::DetectThread(void *arg) {
return ResultSuccess;
}, true));
waiter->Process();
delete waiter;
s_waiter.Process();
}
void DmntCheatManager::VmThread(void *arg) {
@ -1092,16 +1091,10 @@ void DmntCheatManager::InitializeCheatManager() {
DmntCheatDebugEventsManager::Initialize();
/* Spawn application detection thread, spawn cheat vm thread. */
if (R_FAILED(g_detect_thread.Initialize(&DmntCheatManager::DetectThread, nullptr, 0x4000, 39))) {
std::abort();
}
if (R_FAILED(g_vm_thread.Initialize(&DmntCheatManager::VmThread, nullptr, 0x4000, 48))) {
std::abort();
}
R_ASSERT(g_detect_thread.Initialize(&DmntCheatManager::DetectThread, nullptr, 0x4000, 39));
R_ASSERT(g_vm_thread.Initialize(&DmntCheatManager::VmThread, nullptr, 0x4000, 48));
/* Start threads. */
if (R_FAILED(g_detect_thread.Start()) || R_FAILED(g_vm_thread.Start())) {
std::abort();
}
R_ASSERT(g_detect_thread.Start());
R_ASSERT(g_vm_thread.Start());
}

8
stratosphere/dmnt/source/dmnt_main.cpp
View file

@ -106,7 +106,7 @@ int main(int argc, char **argv)
DmntCheatManager::InitializeCheatManager();
/* Nintendo uses four threads. Add a fifth for our cheat service. */
auto server_manager = new WaitableManager(5);
static auto s_server_manager = WaitableManager(5);
/* Create services. */
@ -114,12 +114,10 @@ int main(int argc, char **argv)
/* server_manager->AddWaitable(new ServiceServer<DebugMonitorService>("dmnt:-", 4)); */
server_manager->AddWaitable(new ServiceServer<DmntCheatService>("dmnt:cht", 1));
s_server_manager.AddWaitable(new ServiceServer<DmntCheatService>("dmnt:cht", 1));
/* Loop forever, servicing our services. */
server_manager->Process();
delete server_manager;
s_server_manager.Process();
return 0;
}

12
stratosphere/fatal/source/fatal_main.cpp
View file

@ -135,17 +135,15 @@ int main(int argc, char **argv)
CheckRepairStatus();
/* TODO: What's a good timeout value to use here? */
auto server_manager = new WaitableManager(1);
static auto s_server_manager = WaitableManager(1);
/* Create services. */
server_manager->AddWaitable(new ServiceServer<PrivateService>("fatal:p", 4));
server_manager->AddWaitable(new ServiceServer<UserService>("fatal:u", 4));
server_manager->AddWaitable(GetFatalSettingsEvent());
s_server_manager.AddWaitable(new ServiceServer<PrivateService>("fatal:p", 4));
s_server_manager.AddWaitable(new ServiceServer<UserService>("fatal:u", 4));
s_server_manager.AddWaitable(GetFatalSettingsEvent());
/* Loop forever, servicing our services. */
server_manager->Process();
delete server_manager;
s_server_manager.Process();
return 0;
}

2
stratosphere/libstratosphere

@ -1 +1 @@
Subproject commit 59b49c0e0c64f896ce36180bb7d00f54f70300e9
Subproject commit 4ccee4257763373c8e8dd5453246a592482f9a86

8
stratosphere/pm/source/pm_process_track.cpp
View file

@ -21,11 +21,9 @@
void ProcessTracking::MainLoop(void *arg) {
/* Make a new waitable manager. */
auto process_waiter = new WaitableManager(1);
process_waiter->AddWaitable(Registration::GetProcessLaunchStartEvent());
static auto s_process_waiter = WaitableManager(1);
s_process_waiter.AddWaitable(Registration::GetProcessLaunchStartEvent());
/* Service processes. */
process_waiter->Process();
delete process_waiter;
s_process_waiter.Process();
}

11
stratosphere/sm/source/sm_main.cpp
View file

@ -83,30 +83,29 @@ int main(int argc, char **argv)
consoleDebugInit(debugDevice_SVC);
/* TODO: What's a good timeout value to use here? */
auto server_manager = new WaitableManager(1);
static auto s_server_manager = WaitableManager(1);
/* Create sm:, (and thus allow things to register to it). */
server_manager->AddWaitable(new ManagedPortServer<UserService>("sm:", 0x40));
s_server_manager.AddWaitable(new ManagedPortServer<UserService>("sm:", 0x40));
/* Create sm:m manually. */
Handle smm_h;
R_ASSERT(Registration::RegisterServiceForSelf(smEncodeName("sm:m"), 1, false, &smm_h));
server_manager->AddWaitable(new ExistingPortServer<ManagerService>(smm_h, 1));
s_server_manager.AddWaitable(new ExistingPortServer<ManagerService>(smm_h, 1));
/*===== ATMOSPHERE EXTENSION =====*/
/* Create sm:dmnt manually. */
Handle smdmnt_h;
R_ASSERT(Registration::RegisterServiceForSelf(smEncodeName("sm:dmnt"), 1, false, &smdmnt_h));
server_manager->AddWaitable(new ExistingPortServer<DmntService>(smm_h, 1));;
s_server_manager.AddWaitable(new ExistingPortServer<DmntService>(smm_h, 1));;
/*================================*/
/* Loop forever, servicing our services. */
server_manager->Process();
s_server_manager.Process();
/* Cleanup. */
delete server_manager;
return 0;
}