mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-05-28 05:34:11 -04:00
Code Issues Projects Releases Packages Wiki Activity

os: refactor/rewrite entire namespace.

Browse source
This commit is contained in:
Michael Scire 2020-04-08 02:21:35 -07:00
parent 6193283f03
commit 065485b971
181 changed files with 5353 additions and 1929 deletions
Download patch file Download diff file Expand all files Collapse all files

17
stratosphere/fatal/source/fatal_config.cpp
View file

@ -30,17 +30,24 @@ namespace ams::fatal::srv {
}
/* Global event. */
os::SystemEvent g_fatal_dirty_event(GetFatalDirtyEventReadableHandle(), true, false);
os::WaitableHolder g_fatal_dirty_waitable_holder(&g_fatal_dirty_event);
os::SystemEventType g_fatal_dirty_event;
os::WaitableHolderType g_fatal_dirty_waitable_holder;
bool g_initialized;
}
os::WaitableHolder *GetFatalDirtyWaitableHolder() {
return &g_fatal_dirty_waitable_holder;
os::WaitableHolderType *GetFatalDirtyWaitableHolder() {
if (AMS_UNLIKELY(!g_initialized)) {
os::AttachReadableHandleToSystemEvent(std::addressof(g_fatal_dirty_event), GetFatalDirtyEventReadableHandle(), true, os::EventClearMode_ManualClear);
os::InitializeWaitableHolder(std::addressof(g_fatal_dirty_waitable_holder), std::addressof(g_fatal_dirty_event));
os::SetWaitableHolderUserData(std::addressof(g_fatal_dirty_waitable_holder), reinterpret_cast<uintptr_t>(std::addressof(g_fatal_dirty_waitable_holder)));
g_initialized = true;
}
return std::addressof(g_fatal_dirty_waitable_holder);
}
void OnFatalDirtyEvent() {
g_fatal_dirty_event.Reset();
os::ClearSystemEvent(std::addressof(g_fatal_dirty_event));
u64 flags_0, flags_1;
if (R_SUCCEEDED(setsysGetFatalDirtyFlags(&flags_0, &flags_1)) && (flags_0 & 1)) {

2
stratosphere/fatal/source/fatal_config.hpp
View file

@ -88,7 +88,7 @@ namespace ams::fatal::srv {
}
};
os::WaitableHolder *GetFatalDirtyWaitableHolder();
os::WaitableHolderType *GetFatalDirtyWaitableHolder();
void OnFatalDirtyEvent();
const FatalConfig &GetFatalConfig();

10
stratosphere/fatal/source/fatal_event_manager.cpp
View file

@ -17,26 +17,26 @@
namespace ams::fatal::srv {
FatalEventManager::FatalEventManager() {
FatalEventManager::FatalEventManager() : lock(false) {
/* Just create all the events. */
for (size_t i = 0; i < FatalEventManager::NumFatalEvents; i++) {
R_ABORT_UNLESS(eventCreate(&this->events[i], true));
R_ABORT_UNLESS(os::CreateSystemEvent(std::addressof(this->events[i]), os::EventClearMode_AutoClear, true));
}
}
Result FatalEventManager::GetEvent(Handle *out) {
Result FatalEventManager::GetEvent(const os::SystemEventType **out) {
std::scoped_lock lk{this->lock};
/* Only allow GetEvent to succeed NumFatalEvents times. */
R_UNLESS(this->num_events_gotten < FatalEventManager::NumFatalEvents, ResultTooManyEvents());
*out = this->events[this->num_events_gotten++].revent;
*out = std::addressof(this->events[this->num_events_gotten++]);
return ResultSuccess();
}
void FatalEventManager::SignalEvents() {
for (size_t i = 0; i < FatalEventManager::NumFatalEvents; i++) {
eventFire(&this->events[i]);
os::SignalSystemEvent(std::addressof(this->events[i]));
}
}

10
stratosphere/fatal/source/fatal_event_manager.hpp
View file

@ -19,15 +19,17 @@
namespace ams::fatal::srv {
class FatalEventManager {
private:
NON_COPYABLE(FatalEventManager);
NON_MOVEABLE(FatalEventManager);
public:
static constexpr size_t NumFatalEvents = 3;
private:
os::Mutex lock;
size_t num_events_gotten = 0;
Event events[NumFatalEvents];
os::SystemEventType events[NumFatalEvents];
public:
FatalEventManager();
Result GetEvent(Handle *out);
Result GetEvent(const os::SystemEventType **out);
void SignalEvents();
};

8
stratosphere/fatal/source/fatal_repair.cpp
View file

@ -44,16 +44,16 @@ namespace ams::fatal::srv {
gpioPadSetDirection(&vol_btn, GpioDirection_Input);
/* Ensure that we're holding the volume button for a full second. */
os::TimeoutHelper timeout_helper(1'000'000'000ul);
while (!timeout_helper.TimedOut()) {
auto start = os::GetSystemTick();
do {
GpioValue val;
if (R_FAILED(gpioPadGetValue(&vol_btn, &val)) || val != GpioValue_Low) {
return true;
}
/* Sleep for 100 ms. */
svcSleepThread(100'000'000ul);
}
os::SleepThread(TimeSpan::FromMilliSeconds(100));
} while (os::ConvertToTimeSpan(os::GetSystemTick() - start) < TimeSpan::FromSeconds(1));
}
return false;

2
stratosphere/fatal/source/fatal_scoped_file.cpp
View file

@ -22,7 +22,7 @@ namespace ams::fatal::srv {
/* Convenience definitions. */
constexpr size_t MaximumLineLength = 0x20;
os::Mutex g_format_lock;
os::Mutex g_format_lock(false);
char g_format_buffer[2 * os::MemoryPageSize];
}

19
stratosphere/fatal/source/fatal_service.cpp
View file

@ -27,6 +27,8 @@ namespace ams::fatal::srv {
/* Service Context. */
class ServiceContext {
private:
os::Event erpt_event;
os::Event battery_event;
ThrowContext context;
FatalEventManager event_manager;
bool has_thrown;
@ -37,14 +39,14 @@ namespace ams::fatal::srv {
return ResultSuccess();
}
public:
ServiceContext() {
this->context.ClearState();
R_ABORT_UNLESS(eventCreate(&this->context.erpt_event, false));
R_ABORT_UNLESS(eventCreate(&this->context.battery_event, false));
this->has_thrown = false;
ServiceContext()
: erpt_event(os::EventClearMode_ManualClear), battery_event(os::EventClearMode_ManualClear),
context(std::addressof(erpt_event), std::addressof(battery_event)), has_thrown(false)
{
/* ... */
}
Result GetEvent(Handle *out) {
Result GetEvent(const os::SystemEventType **out) {
return this->event_manager.GetEvent(out);
}
@ -143,7 +145,10 @@ namespace ams::fatal::srv {
}
Result PrivateService::GetFatalEvent(sf::OutCopyHandle out_h) {
return g_context.GetEvent(out_h.GetHandlePointer());
const os::SystemEventType *event;
R_TRY(g_context.GetEvent(std::addressof(event)));
out_h.SetValue(os::GetReadableHandleOfSystemEvent(event));
return ResultSuccess();
}
}

8
stratosphere/fatal/source/fatal_task.cpp
View file

@ -28,9 +28,9 @@ namespace ams::fatal::srv {
class TaskThread {
NON_COPYABLE(TaskThread);
private:
static constexpr int TaskThreadPriority = 15;
static constexpr s32 TaskThreadPriority = -13;
private:
os::Thread thread;
os::ThreadType thread;
private:
static void RunTaskImpl(void *arg) {
ITask *task = reinterpret_cast<ITask *>(arg);
@ -42,8 +42,8 @@ namespace ams::fatal::srv {
public:
TaskThread() { /* ... */ }
void StartTask(ITask *task) {
R_ABORT_UNLESS(this->thread.Initialize(&RunTaskImpl, task, task->GetStack(), task->GetStackSize(), TaskThreadPriority));
R_ABORT_UNLESS(this->thread.Start());
R_ABORT_UNLESS(os::CreateThread(std::addressof(this->thread), RunTaskImpl, task, task->GetStack(), task->GetStackSize(), TaskThreadPriority, 3));
os::StartThread(std::addressof(this->thread));
}
};

2
stratosphere/fatal/source/fatal_task_error_report.cpp
View file

@ -160,7 +160,7 @@ namespace ams::fatal::srv {
}
/* Signal we're done with our job. */
eventFire(const_cast<Event *>(&this->context->erpt_event));
this->context->erpt_event->Signal();
return ResultSuccess();
}

46
stratosphere/fatal/source/fatal_task_power.cpp
View file

@ -50,6 +50,22 @@ namespace ams::fatal::srv {
}
};
class RebootTimingObserver {
private:
os::Tick start_tick;
bool flag;
s32 interval;
public:
RebootTimingObserver(bool flag, s32 interval) : start_tick(os::GetSystemTick()), flag(flag), interval(interval) {
/* ... */
}
bool IsRebootTiming() const {
auto current_tick = os::GetSystemTick();
return this->flag && (current_tick - this->start_tick).ToTimeSpan().GetSeconds() >= this->interval;
}
};
/* Task globals. */
PowerControlTask g_power_control_task;
PowerButtonObserveTask g_power_button_observe_task;
@ -58,13 +74,16 @@ namespace ams::fatal::srv {
/* Task Implementations. */
bool PowerControlTask::TryShutdown() {
/* Set a timeout of 30 seconds. */
os::TimeoutHelper timeout_helper(30'000'000'000ul);
constexpr s32 MaxShutdownWaitSeconds = 30;
auto start_tick = os::GetSystemTick();
bool perform_shutdown = true;
PsmBatteryVoltageState bv_state = PsmBatteryVoltageState_Normal;
while (true) {
if (timeout_helper.TimedOut()) {
auto cur_tick = os::GetSystemTick();
if ((cur_tick - start_tick).ToTimeSpan().GetSeconds() > MaxShutdownWaitSeconds) {
break;
}
@ -77,8 +96,8 @@ namespace ams::fatal::srv {
break;
}
/* Query voltage state every 5 seconds, for 30 seconds. */
svcSleepThread(5'000'000'000ul);
/* Query voltage state every 1 seconds, for 30 seconds. */
os::SleepThread(TimeSpan::FromSeconds(1));
}
if (perform_shutdown) {
@ -94,13 +113,13 @@ namespace ams::fatal::srv {
/* Check the battery state, and shutdown on low voltage. */
if (R_FAILED(psmGetBatteryVoltageState(&bv_state)) || bv_state == PsmBatteryVoltageState_NeedsShutdown) {
/* Wait a second for the error report task to finish. */
eventWait(const_cast<Event *>(&this->context->erpt_event), os::TimeoutHelper::NsToTick(1'000'000'000ul));
this->context->erpt_event->TimedWait(TimeSpan::FromSeconds(1));
this->TryShutdown();
return;
}
/* Signal we've checked the battery at least once. */
eventFire(const_cast<Event *>(&this->context->battery_event));
this->context->battery_event->Signal();
/* Loop querying voltage state every 5 seconds. */
while (true) {
@ -122,18 +141,18 @@ namespace ams::fatal::srv {
break;
}
svcSleepThread(5'000'000'000ul);
os::SleepThread(TimeSpan::FromSeconds(5));
}
}
void PowerButtonObserveTask::WaitForPowerButton() {
/* Wait up to a second for error report generation to finish. */
eventWait(const_cast<Event *>(&this->context->erpt_event), os::TimeoutHelper::NsToTick(1'000'000'000ul));
this->context->erpt_event->TimedWait(TimeSpan::FromSeconds(1));
/* Force a reboot after some time if kiosk unit. */
const auto &config = GetFatalConfig();
os::TimeoutHelper quest_reboot_helper(config.GetQuestRebootTimeoutInterval());
os::TimeoutHelper fatal_reboot_helper(config.GetFatalRebootTimeoutInterval());
RebootTimingObserver quest_reboot_helper(config.IsQuest(), config.GetQuestRebootTimeoutInterval());
RebootTimingObserver fatal_reboot_helper(config.IsFatalRebootEnabled(), config.GetFatalRebootTimeoutInterval());
bool check_vol_up = true, check_vol_down = true;
GpioPadSession vol_up_btn, vol_down_btn;
@ -159,11 +178,10 @@ namespace ams::fatal::srv {
BpcSleepButtonState state;
GpioValue val;
while (true) {
if ((config.IsFatalRebootEnabled() && fatal_reboot_helper.TimedOut()) ||
if (fatal_reboot_helper.IsRebootTiming() || (quest_reboot_helper.IsRebootTiming()) ||
(check_vol_up && R_SUCCEEDED(gpioPadGetValue(&vol_up_btn, &val)) && val == GpioValue_Low) ||
(check_vol_down && R_SUCCEEDED(gpioPadGetValue(&vol_down_btn, &val)) && val == GpioValue_Low) ||
(R_SUCCEEDED(bpcGetSleepButtonState(&state)) && state == BpcSleepButtonState_Held) ||
(config.IsQuest() && quest_reboot_helper.TimedOut())) {
(R_SUCCEEDED(bpcGetSleepButtonState(&state)) && state == BpcSleepButtonState_Held)) {
/* If any of the above conditions succeeded, we should reboot. */
bpcRebootSystem();
return;
@ -171,7 +189,7 @@ namespace ams::fatal::srv {
/* Wait 100 ms between button checks. */
svcSleepThread(100'000'000ul);
os::SleepThread(TimeSpan::FromMilliSeconds(100));
}
}

2
stratosphere/fatal/source/fatal_task_screen.cpp
View file

@ -418,7 +418,7 @@ namespace ams::fatal::srv {
Result ShowFatalTask::Run() {
/* Don't show the fatal error screen until we've verified the battery is okay. */
eventWait(const_cast<Event *>(&this->context->battery_event), std::numeric_limits<u64>::max());
this->context->battery_event->Wait();
return ShowFatal();
}