another try

src/core/hle/service/time/clock_types.h

@@ -1,108 +1,108 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/uuid.h"
-#include "core/hle/service/time/errors.h"
-#include "core/hle/service/time/time_zone_types.h"
-
-namespace Service::Time::Clock {
-
-enum class TimeType : u8 {
-    UserSystemClock,
-    NetworkSystemClock,
-    LocalSystemClock,
-};
-
-/// https://switchbrew.org/wiki/Glue_services#SteadyClockTimePoint
-struct SteadyClockTimePoint {
-    s64 time_point;
-    Common::UUID clock_source_id;
-
-    Result GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
-        span = 0;
-
-        if (clock_source_id != other.clock_source_id) {
-            return ERROR_TIME_MISMATCH;
-        }
-
-        span = other.time_point - time_point;
-
-        return ResultSuccess;
-    }
-
-    static SteadyClockTimePoint GetRandom() {
-        return {0, Common::UUID::MakeRandom()};
-    }
-};
-static_assert(sizeof(SteadyClockTimePoint) == 0x18, "SteadyClockTimePoint is incorrect size");
-static_assert(std::is_trivially_copyable_v<SteadyClockTimePoint>,
-              "SteadyClockTimePoint must be trivially copyable");
-
-struct SteadyClockContext {
-    u64 internal_offset;
-    Common::UUID steady_time_point;
-};
-static_assert(sizeof(SteadyClockContext) == 0x18, "SteadyClockContext is incorrect size");
-static_assert(std::is_trivially_copyable_v<SteadyClockContext>,
-              "SteadyClockContext must be trivially copyable");
-
-struct SystemClockContext {
-    s64 offset;
-    SteadyClockTimePoint steady_time_point;
-};
-static_assert(sizeof(SystemClockContext) == 0x20, "SystemClockContext is incorrect size");
-static_assert(std::is_trivially_copyable_v<SystemClockContext>,
-              "SystemClockContext must be trivially copyable");
-
-/// https://switchbrew.org/wiki/Glue_services#TimeSpanType
-struct TimeSpanType {
-    s64 nanoseconds{};
-    static constexpr s64 ns_per_second{1000000000ULL};
-
-    s64 ToSeconds() const {
-        return nanoseconds / ns_per_second;
-    }
-
-    static TimeSpanType FromSeconds(s64 seconds) {
-        return {seconds * ns_per_second};
-    }
-
-    static TimeSpanType FromTicks(u64 ticks, u64 frequency) {
-        return FromSeconds(static_cast<s64>(ticks) / static_cast<s64>(frequency));
-    }
-};
-static_assert(sizeof(TimeSpanType) == 8, "TimeSpanType is incorrect size");
-
-struct ClockSnapshot {
-    SystemClockContext user_context;
-    SystemClockContext network_context;
-    s64 user_time;
-    s64 network_time;
-    TimeZone::CalendarTime user_calendar_time;
-    TimeZone::CalendarTime network_calendar_time;
-    TimeZone::CalendarAdditionalInfo user_calendar_additional_time;
-    TimeZone::CalendarAdditionalInfo network_calendar_additional_time;
-    SteadyClockTimePoint steady_clock_time_point;
-    TimeZone::LocationName location_name;
-    u8 is_automatic_correction_enabled;
-    TimeType type;
-    INSERT_PADDING_BYTES_NOINIT(0x2);
-
-    static Result GetCurrentTime(s64& current_time,
-                                 const SteadyClockTimePoint& steady_clock_time_point,
-                                 const SystemClockContext& context) {
-        if (steady_clock_time_point.clock_source_id != context.steady_time_point.clock_source_id) {
-            current_time = 0;
-            return ERROR_TIME_MISMATCH;
-        }
-        current_time = steady_clock_time_point.time_point + context.offset;
-        return ResultSuccess;
-    }
-};
-static_assert(sizeof(ClockSnapshot) == 0xD0, "ClockSnapshot is incorrect size");
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/uuid.h"
+#include "core/hle/service/time/errors.h"
+#include "core/hle/service/time/time_zone_types.h"
+
+namespace Service::Time::Clock {
+
+enum class TimeType : u8 {
+    UserSystemClock,
+    NetworkSystemClock,
+    LocalSystemClock,
+};
+
+/// https://switchbrew.org/wiki/Glue_services#SteadyClockTimePoint
+struct SteadyClockTimePoint {
+    s64 time_point;
+    Common::UUID clock_source_id;
+
+    Result GetSpanBetween(SteadyClockTimePoint other, s64& span) const {
+        span = 0;
+
+        if (clock_source_id != other.clock_source_id) {
+            return ERROR_TIME_MISMATCH;
+        }
+
+        span = other.time_point - time_point;
+
+        return ResultSuccess;
+    }
+
+    static SteadyClockTimePoint GetRandom() {
+        return {0, Common::UUID::MakeRandom()};
+    }
+};
+static_assert(sizeof(SteadyClockTimePoint) == 0x18, "SteadyClockTimePoint is incorrect size");
+static_assert(std::is_trivially_copyable_v<SteadyClockTimePoint>,
+              "SteadyClockTimePoint must be trivially copyable");
+
+struct SteadyClockContext {
+    u64 internal_offset;
+    Common::UUID steady_time_point;
+};
+static_assert(sizeof(SteadyClockContext) == 0x18, "SteadyClockContext is incorrect size");
+static_assert(std::is_trivially_copyable_v<SteadyClockContext>,
+              "SteadyClockContext must be trivially copyable");
+
+struct SystemClockContext {
+    s64 offset;
+    SteadyClockTimePoint steady_time_point;
+};
+static_assert(sizeof(SystemClockContext) == 0x20, "SystemClockContext is incorrect size");
+static_assert(std::is_trivially_copyable_v<SystemClockContext>,
+              "SystemClockContext must be trivially copyable");
+
+/// https://switchbrew.org/wiki/Glue_services#TimeSpanType
+struct TimeSpanType {
+    s64 nanoseconds{};
+    static constexpr s64 ns_per_second{1000000000ULL};
+
+    s64 ToSeconds() const {
+        return nanoseconds / ns_per_second;
+    }
+
+    static TimeSpanType FromSeconds(s64 seconds) {
+        return {seconds * ns_per_second};
+    }
+
+    static TimeSpanType FromTicks(u64 ticks, u64 frequency) {
+        return FromSeconds(static_cast<s64>(ticks) / static_cast<s64>(frequency));
+    }
+};
+static_assert(sizeof(TimeSpanType) == 8, "TimeSpanType is incorrect size");
+
+struct ClockSnapshot {
+    SystemClockContext user_context;
+    SystemClockContext network_context;
+    s64 user_time;
+    s64 network_time;
+    TimeZone::CalendarTime user_calendar_time;
+    TimeZone::CalendarTime network_calendar_time;
+    TimeZone::CalendarAdditionalInfo user_calendar_additional_time;
+    TimeZone::CalendarAdditionalInfo network_calendar_additional_time;
+    SteadyClockTimePoint steady_clock_time_point;
+    TimeZone::LocationName location_name;
+    u8 is_automatic_correction_enabled;
+    TimeType type;
+    INSERT_PADDING_BYTES_NOINIT(0x2);
+
+    static Result GetCurrentTime(s64& current_time,
+                                 const SteadyClockTimePoint& steady_clock_time_point,
+                                 const SystemClockContext& context) {
+        if (steady_clock_time_point.clock_source_id != context.steady_time_point.clock_source_id) {
+            current_time = 0;
+            return ERROR_TIME_MISMATCH;
+        }
+        current_time = steady_clock_time_point.time_point + context.offset;
+        return ResultSuccess;
+    }
+};
+static_assert(sizeof(ClockSnapshot) == 0xD0, "ClockSnapshot is incorrect size");
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/ephemeral_network_system_clock_context_writer.h

@@ -1,15 +1,15 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/system_clock_context_update_callback.h"
-
-namespace Service::Time::Clock {
-
-class EphemeralNetworkSystemClockContextWriter final : public SystemClockContextUpdateCallback {
-public:
-    EphemeralNetworkSystemClockContextWriter() : SystemClockContextUpdateCallback{} {}
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/system_clock_context_update_callback.h"
+
+namespace Service::Time::Clock {
+
+class EphemeralNetworkSystemClockContextWriter final : public SystemClockContextUpdateCallback {
+public:
+    EphemeralNetworkSystemClockContextWriter() : SystemClockContextUpdateCallback{} {}
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/ephemeral_network_system_clock_core.h

@@ -1,16 +1,16 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/system_clock_core.h"
-
-namespace Service::Time::Clock {
-
-class EphemeralNetworkSystemClockCore final : public SystemClockCore {
-public:
-    explicit EphemeralNetworkSystemClockCore(SteadyClockCore& steady_clock_core_)
-        : SystemClockCore{steady_clock_core_} {}
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/system_clock_core.h"
+
+namespace Service::Time::Clock {
+
+class EphemeralNetworkSystemClockCore final : public SystemClockCore {
+public:
+    explicit EphemeralNetworkSystemClockCore(SteadyClockCore& steady_clock_core_)
+        : SystemClockCore{steady_clock_core_} {}
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/errors.h

@@ -1,21 +1,21 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/result.h"
-
-namespace Service::Time {
-
-constexpr Result ERROR_PERMISSION_DENIED{ErrorModule::Time, 1};
-constexpr Result ERROR_TIME_MISMATCH{ErrorModule::Time, 102};
-constexpr Result ERROR_UNINITIALIZED_CLOCK{ErrorModule::Time, 103};
-constexpr Result ERROR_TIME_NOT_FOUND{ErrorModule::Time, 200};
-constexpr Result ERROR_OVERFLOW{ErrorModule::Time, 201};
-constexpr Result ERROR_LOCATION_NAME_TOO_LONG{ErrorModule::Time, 801};
-constexpr Result ERROR_OUT_OF_RANGE{ErrorModule::Time, 902};
-constexpr Result ERROR_TIME_ZONE_CONVERSION_FAILED{ErrorModule::Time, 903};
-constexpr Result ERROR_TIME_ZONE_NOT_FOUND{ErrorModule::Time, 989};
-constexpr Result ERROR_NOT_IMPLEMENTED{ErrorModule::Time, 990};
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/result.h"
+
+namespace Service::Time {
+
+constexpr Result ERROR_PERMISSION_DENIED{ErrorModule::Time, 1};
+constexpr Result ERROR_TIME_MISMATCH{ErrorModule::Time, 102};
+constexpr Result ERROR_UNINITIALIZED_CLOCK{ErrorModule::Time, 103};
+constexpr Result ERROR_TIME_NOT_FOUND{ErrorModule::Time, 200};
+constexpr Result ERROR_OVERFLOW{ErrorModule::Time, 201};
+constexpr Result ERROR_LOCATION_NAME_TOO_LONG{ErrorModule::Time, 801};
+constexpr Result ERROR_OUT_OF_RANGE{ErrorModule::Time, 902};
+constexpr Result ERROR_TIME_ZONE_CONVERSION_FAILED{ErrorModule::Time, 903};
+constexpr Result ERROR_TIME_ZONE_NOT_FOUND{ErrorModule::Time, 989};
+constexpr Result ERROR_NOT_IMPLEMENTED{ErrorModule::Time, 990};
+
+} // namespace Service::Time

src/core/hle/service/time/local_system_clock_context_writer.h

@@ -1,26 +1,26 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/system_clock_context_update_callback.h"
-#include "core/hle/service/time/time_sharedmemory.h"
-
-namespace Service::Time::Clock {
-
-class LocalSystemClockContextWriter final : public SystemClockContextUpdateCallback {
-public:
-    explicit LocalSystemClockContextWriter(SharedMemory& shared_memory_)
-        : SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
-
-protected:
-    Result Update() override {
-        shared_memory.UpdateLocalSystemClockContext(context);
-        return ResultSuccess;
-    }
-
-private:
-    SharedMemory& shared_memory;
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/system_clock_context_update_callback.h"
+#include "core/hle/service/time/time_sharedmemory.h"
+
+namespace Service::Time::Clock {
+
+class LocalSystemClockContextWriter final : public SystemClockContextUpdateCallback {
+public:
+    explicit LocalSystemClockContextWriter(SharedMemory& shared_memory_)
+        : SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
+
+protected:
+    Result Update() override {
+        shared_memory.UpdateLocalSystemClockContext(context);
+        return ResultSuccess;
+    }
+
+private:
+    SharedMemory& shared_memory;
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/network_system_clock_context_writer.h

@@ -1,27 +1,27 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/errors.h"
-#include "core/hle/service/time/system_clock_context_update_callback.h"
-#include "core/hle/service/time/time_sharedmemory.h"
-
-namespace Service::Time::Clock {
-
-class NetworkSystemClockContextWriter final : public SystemClockContextUpdateCallback {
-public:
-    explicit NetworkSystemClockContextWriter(SharedMemory& shared_memory_)
-        : SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
-
-protected:
-    Result Update() override {
-        shared_memory.UpdateNetworkSystemClockContext(context);
-        return ResultSuccess;
-    }
-
-private:
-    SharedMemory& shared_memory;
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/errors.h"
+#include "core/hle/service/time/system_clock_context_update_callback.h"
+#include "core/hle/service/time/time_sharedmemory.h"
+
+namespace Service::Time::Clock {
+
+class NetworkSystemClockContextWriter final : public SystemClockContextUpdateCallback {
+public:
+    explicit NetworkSystemClockContextWriter(SharedMemory& shared_memory_)
+        : SystemClockContextUpdateCallback{}, shared_memory{shared_memory_} {}
+
+protected:
+    Result Update() override {
+        shared_memory.UpdateNetworkSystemClockContext(context);
+        return ResultSuccess;
+    }
+
+private:
+    SharedMemory& shared_memory;
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/standard_local_system_clock_core.h

@@ -1,16 +1,16 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/system_clock_core.h"
-
-namespace Service::Time::Clock {
-
-class StandardLocalSystemClockCore final : public SystemClockCore {
-public:
-    explicit StandardLocalSystemClockCore(SteadyClockCore& steady_clock_core_)
-        : SystemClockCore{steady_clock_core_} {}
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/system_clock_core.h"
+
+namespace Service::Time::Clock {
+
+class StandardLocalSystemClockCore final : public SystemClockCore {
+public:
+    explicit StandardLocalSystemClockCore(SteadyClockCore& steady_clock_core_)
+        : SystemClockCore{steady_clock_core_} {}
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/standard_network_system_clock_core.h

@@ -1,45 +1,45 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/steady_clock_core.h"
-#include "core/hle/service/time/system_clock_core.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time::Clock {
-
-class StandardNetworkSystemClockCore final : public SystemClockCore {
-public:
-    explicit StandardNetworkSystemClockCore(SteadyClockCore& steady_clock_core_)
-        : SystemClockCore{steady_clock_core_} {}
-
-    void SetStandardNetworkClockSufficientAccuracy(TimeSpanType value) {
-        standard_network_clock_sufficient_accuracy = value;
-    }
-
-    bool IsStandardNetworkSystemClockAccuracySufficient(Core::System& system) const {
-        SystemClockContext clock_ctx{};
-        if (GetClockContext(system, clock_ctx) != ResultSuccess) {
-            return {};
-        }
-
-        s64 span{};
-        if (clock_ctx.steady_time_point.GetSpanBetween(
-                GetSteadyClockCore().GetCurrentTimePoint(system), span) != ResultSuccess) {
-            return {};
-        }
-
-        return TimeSpanType{span}.nanoseconds <
-               standard_network_clock_sufficient_accuracy.nanoseconds;
-    }
-
-private:
-    TimeSpanType standard_network_clock_sufficient_accuracy{};
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/steady_clock_core.h"
+#include "core/hle/service/time/system_clock_core.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time::Clock {
+
+class StandardNetworkSystemClockCore final : public SystemClockCore {
+public:
+    explicit StandardNetworkSystemClockCore(SteadyClockCore& steady_clock_core_)
+        : SystemClockCore{steady_clock_core_} {}
+
+    void SetStandardNetworkClockSufficientAccuracy(TimeSpanType value) {
+        standard_network_clock_sufficient_accuracy = value;
+    }
+
+    bool IsStandardNetworkSystemClockAccuracySufficient(Core::System& system) const {
+        SystemClockContext clock_ctx{};
+        if (GetClockContext(system, clock_ctx) != ResultSuccess) {
+            return {};
+        }
+
+        s64 span{};
+        if (clock_ctx.steady_time_point.GetSpanBetween(
+                GetSteadyClockCore().GetCurrentTimePoint(system), span) != ResultSuccess) {
+            return {};
+        }
+
+        return TimeSpanType{span}.nanoseconds <
+               standard_network_clock_sufficient_accuracy.nanoseconds;
+    }
+
+private:
+    TimeSpanType standard_network_clock_sufficient_accuracy{};
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/standard_steady_clock_core.cpp

@@ -1,24 +1,24 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hardware_properties.h"
-#include "core/hle/service/time/standard_steady_clock_core.h"
-
-namespace Service::Time::Clock {
-
-TimeSpanType StandardSteadyClockCore::GetCurrentRawTimePoint(Core::System& system) {
-    const TimeSpanType ticks_time_span{
-        TimeSpanType::FromTicks(system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
-    TimeSpanType raw_time_point{setup_value.nanoseconds + ticks_time_span.nanoseconds};
-
-    if (raw_time_point.nanoseconds < cached_raw_time_point.nanoseconds) {
-        raw_time_point.nanoseconds = cached_raw_time_point.nanoseconds;
-    }
-
-    cached_raw_time_point = raw_time_point;
-    return raw_time_point;
-}
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hardware_properties.h"
+#include "core/hle/service/time/standard_steady_clock_core.h"
+
+namespace Service::Time::Clock {
+
+TimeSpanType StandardSteadyClockCore::GetCurrentRawTimePoint(Core::System& system) {
+    const TimeSpanType ticks_time_span{
+        TimeSpanType::FromTicks(system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
+    TimeSpanType raw_time_point{setup_value.nanoseconds + ticks_time_span.nanoseconds};
+
+    if (raw_time_point.nanoseconds < cached_raw_time_point.nanoseconds) {
+        raw_time_point.nanoseconds = cached_raw_time_point.nanoseconds;
+    }
+
+    cached_raw_time_point = raw_time_point;
+    return raw_time_point;
+}
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/standard_steady_clock_core.h

@@ -1,41 +1,41 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/steady_clock_core.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time::Clock {
-
-class StandardSteadyClockCore final : public SteadyClockCore {
-public:
-    SteadyClockTimePoint GetTimePoint(Core::System& system) override {
-        return {GetCurrentRawTimePoint(system).ToSeconds(), GetClockSourceId()};
-    }
-
-    TimeSpanType GetInternalOffset() const override {
-        return internal_offset;
-    }
-
-    void SetInternalOffset(TimeSpanType value) override {
-        internal_offset = value;
-    }
-
-    TimeSpanType GetCurrentRawTimePoint(Core::System& system) override;
-
-    void SetSetupValue(TimeSpanType value) {
-        setup_value = value;
-    }
-
-private:
-    TimeSpanType setup_value{};
-    TimeSpanType internal_offset{};
-    TimeSpanType cached_raw_time_point{};
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/steady_clock_core.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time::Clock {
+
+class StandardSteadyClockCore final : public SteadyClockCore {
+public:
+    SteadyClockTimePoint GetTimePoint(Core::System& system) override {
+        return {GetCurrentRawTimePoint(system).ToSeconds(), GetClockSourceId()};
+    }
+
+    TimeSpanType GetInternalOffset() const override {
+        return internal_offset;
+    }
+
+    void SetInternalOffset(TimeSpanType value) override {
+        internal_offset = value;
+    }
+
+    TimeSpanType GetCurrentRawTimePoint(Core::System& system) override;
+
+    void SetSetupValue(TimeSpanType value) {
+        setup_value = value;
+    }
+
+private:
+    TimeSpanType setup_value{};
+    TimeSpanType internal_offset{};
+    TimeSpanType cached_raw_time_point{};
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/standard_user_system_clock_core.cpp

@@ -1,81 +1,81 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/assert.h"
-#include "core/core.h"
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/service/time/standard_local_system_clock_core.h"
-#include "core/hle/service/time/standard_network_system_clock_core.h"
-#include "core/hle/service/time/standard_user_system_clock_core.h"
-
-namespace Service::Time::Clock {
-
-StandardUserSystemClockCore::StandardUserSystemClockCore(
-    StandardLocalSystemClockCore& local_system_clock_core_,
-    StandardNetworkSystemClockCore& network_system_clock_core_, Core::System& system_)
-    : SystemClockCore(local_system_clock_core_.GetSteadyClockCore()),
-      local_system_clock_core{local_system_clock_core_},
-      network_system_clock_core{network_system_clock_core_},
-      auto_correction_time{SteadyClockTimePoint::GetRandom()}, service_context{
-                                                                   system_,
-                                                                   "StandardUserSystemClockCore"} {
-    auto_correction_event =
-        service_context.CreateEvent("StandardUserSystemClockCore:AutoCorrectionEvent");
-}
-
-StandardUserSystemClockCore::~StandardUserSystemClockCore() {
-    service_context.CloseEvent(auto_correction_event);
-}
-
-Result StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::System& system,
-                                                                  bool value) {
-    if (const Result result{ApplyAutomaticCorrection(system, value)}; result != ResultSuccess) {
-        return result;
-    }
-
-    auto_correction_enabled = value;
-
-    return ResultSuccess;
-}
-
-Result StandardUserSystemClockCore::GetClockContext(Core::System& system,
-                                                    SystemClockContext& ctx) const {
-    if (const Result result{ApplyAutomaticCorrection(system, false)}; result != ResultSuccess) {
-        return result;
-    }
-
-    return local_system_clock_core.GetClockContext(system, ctx);
-}
-
-Result StandardUserSystemClockCore::Flush(const SystemClockContext&) {
-    UNIMPLEMENTED();
-    return ERROR_NOT_IMPLEMENTED;
-}
-
-Result StandardUserSystemClockCore::SetClockContext(const SystemClockContext&) {
-    UNIMPLEMENTED();
-    return ERROR_NOT_IMPLEMENTED;
-}
-
-Result StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& system,
-                                                             bool value) const {
-    if (auto_correction_enabled == value) {
-        return ResultSuccess;
-    }
-
-    if (!network_system_clock_core.IsClockSetup(system)) {
-        return ERROR_UNINITIALIZED_CLOCK;
-    }
-
-    SystemClockContext ctx{};
-    if (const Result result{network_system_clock_core.GetClockContext(system, ctx)};
-        result != ResultSuccess) {
-        return result;
-    }
-
-    local_system_clock_core.SetClockContext(ctx);
-
-    return ResultSuccess;
-}
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/assert.h"
+#include "core/core.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/time/standard_local_system_clock_core.h"
+#include "core/hle/service/time/standard_network_system_clock_core.h"
+#include "core/hle/service/time/standard_user_system_clock_core.h"
+
+namespace Service::Time::Clock {
+
+StandardUserSystemClockCore::StandardUserSystemClockCore(
+    StandardLocalSystemClockCore& local_system_clock_core_,
+    StandardNetworkSystemClockCore& network_system_clock_core_, Core::System& system_)
+    : SystemClockCore(local_system_clock_core_.GetSteadyClockCore()),
+      local_system_clock_core{local_system_clock_core_},
+      network_system_clock_core{network_system_clock_core_},
+      auto_correction_time{SteadyClockTimePoint::GetRandom()}, service_context{
+                                                                   system_,
+                                                                   "StandardUserSystemClockCore"} {
+    auto_correction_event =
+        service_context.CreateEvent("StandardUserSystemClockCore:AutoCorrectionEvent");
+}
+
+StandardUserSystemClockCore::~StandardUserSystemClockCore() {
+    service_context.CloseEvent(auto_correction_event);
+}
+
+Result StandardUserSystemClockCore::SetAutomaticCorrectionEnabled(Core::System& system,
+                                                                  bool value) {
+    if (const Result result{ApplyAutomaticCorrection(system, value)}; result != ResultSuccess) {
+        return result;
+    }
+
+    auto_correction_enabled = value;
+
+    return ResultSuccess;
+}
+
+Result StandardUserSystemClockCore::GetClockContext(Core::System& system,
+                                                    SystemClockContext& ctx) const {
+    if (const Result result{ApplyAutomaticCorrection(system, false)}; result != ResultSuccess) {
+        return result;
+    }
+
+    return local_system_clock_core.GetClockContext(system, ctx);
+}
+
+Result StandardUserSystemClockCore::Flush(const SystemClockContext&) {
+    UNIMPLEMENTED();
+    return ERROR_NOT_IMPLEMENTED;
+}
+
+Result StandardUserSystemClockCore::SetClockContext(const SystemClockContext&) {
+    UNIMPLEMENTED();
+    return ERROR_NOT_IMPLEMENTED;
+}
+
+Result StandardUserSystemClockCore::ApplyAutomaticCorrection(Core::System& system,
+                                                             bool value) const {
+    if (auto_correction_enabled == value) {
+        return ResultSuccess;
+    }
+
+    if (!network_system_clock_core.IsClockSetup(system)) {
+        return ERROR_UNINITIALIZED_CLOCK;
+    }
+
+    SystemClockContext ctx{};
+    if (const Result result{network_system_clock_core.GetClockContext(system, ctx)};
+        result != ResultSuccess) {
+        return result;
+    }
+
+    local_system_clock_core.SetClockContext(ctx);
+
+    return ResultSuccess;
+}
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/standard_user_system_clock_core.h

@@ -1,63 +1,63 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/kernel_helpers.h"
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/system_clock_core.h"
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KEvent;
-}
-
-namespace Service::Time::Clock {
-
-class StandardLocalSystemClockCore;
-class StandardNetworkSystemClockCore;
-
-class StandardUserSystemClockCore final : public SystemClockCore {
-public:
-    StandardUserSystemClockCore(StandardLocalSystemClockCore& local_system_clock_core_,
-                                StandardNetworkSystemClockCore& network_system_clock_core_,
-                                Core::System& system_);
-
-    ~StandardUserSystemClockCore() override;
-
-    Result SetAutomaticCorrectionEnabled(Core::System& system, bool value);
-
-    Result GetClockContext(Core::System& system, SystemClockContext& ctx) const override;
-
-    bool IsAutomaticCorrectionEnabled() const {
-        return auto_correction_enabled;
-    }
-
-    void SetAutomaticCorrectionUpdatedTime(SteadyClockTimePoint steady_clock_time_point) {
-        auto_correction_time = steady_clock_time_point;
-    }
-
-protected:
-    Result Flush(const SystemClockContext&) override;
-
-    Result SetClockContext(const SystemClockContext&) override;
-
-    Result ApplyAutomaticCorrection(Core::System& system, bool value) const;
-
-    const SteadyClockTimePoint& GetAutomaticCorrectionUpdatedTime() const {
-        return auto_correction_time;
-    }
-
-private:
-    StandardLocalSystemClockCore& local_system_clock_core;
-    StandardNetworkSystemClockCore& network_system_clock_core;
-    bool auto_correction_enabled{};
-    SteadyClockTimePoint auto_correction_time;
-    KernelHelpers::ServiceContext service_context;
-    Kernel::KEvent* auto_correction_event;
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/system_clock_core.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KEvent;
+}
+
+namespace Service::Time::Clock {
+
+class StandardLocalSystemClockCore;
+class StandardNetworkSystemClockCore;
+
+class StandardUserSystemClockCore final : public SystemClockCore {
+public:
+    StandardUserSystemClockCore(StandardLocalSystemClockCore& local_system_clock_core_,
+                                StandardNetworkSystemClockCore& network_system_clock_core_,
+                                Core::System& system_);
+
+    ~StandardUserSystemClockCore() override;
+
+    Result SetAutomaticCorrectionEnabled(Core::System& system, bool value);
+
+    Result GetClockContext(Core::System& system, SystemClockContext& ctx) const override;
+
+    bool IsAutomaticCorrectionEnabled() const {
+        return auto_correction_enabled;
+    }
+
+    void SetAutomaticCorrectionUpdatedTime(SteadyClockTimePoint steady_clock_time_point) {
+        auto_correction_time = steady_clock_time_point;
+    }
+
+protected:
+    Result Flush(const SystemClockContext&) override;
+
+    Result SetClockContext(const SystemClockContext&) override;
+
+    Result ApplyAutomaticCorrection(Core::System& system, bool value) const;
+
+    const SteadyClockTimePoint& GetAutomaticCorrectionUpdatedTime() const {
+        return auto_correction_time;
+    }
+
+private:
+    StandardLocalSystemClockCore& local_system_clock_core;
+    StandardNetworkSystemClockCore& network_system_clock_core;
+    bool auto_correction_enabled{};
+    SteadyClockTimePoint auto_correction_time;
+    KernelHelpers::ServiceContext service_context;
+    Kernel::KEvent* auto_correction_event;
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/steady_clock_core.h

@@ -1,55 +1,55 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/uuid.h"
-#include "core/hle/service/time/clock_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time::Clock {
-
-class SteadyClockCore {
-public:
-    SteadyClockCore() = default;
-    virtual ~SteadyClockCore() = default;
-
-    const Common::UUID& GetClockSourceId() const {
-        return clock_source_id;
-    }
-
-    void SetClockSourceId(const Common::UUID& value) {
-        clock_source_id = value;
-    }
-
-    virtual TimeSpanType GetInternalOffset() const = 0;
-
-    virtual void SetInternalOffset(TimeSpanType internal_offset) = 0;
-
-    virtual SteadyClockTimePoint GetTimePoint(Core::System& system) = 0;
-
-    virtual TimeSpanType GetCurrentRawTimePoint(Core::System& system) = 0;
-
-    SteadyClockTimePoint GetCurrentTimePoint(Core::System& system) {
-        SteadyClockTimePoint result{GetTimePoint(system)};
-        result.time_point += GetInternalOffset().ToSeconds();
-        return result;
-    }
-
-    bool IsInitialized() const {
-        return is_initialized;
-    }
-
-    void MarkAsInitialized() {
-        is_initialized = true;
-    }
-
-private:
-    Common::UUID clock_source_id{Common::UUID::MakeRandom()};
-    bool is_initialized{};
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/uuid.h"
+#include "core/hle/service/time/clock_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time::Clock {
+
+class SteadyClockCore {
+public:
+    SteadyClockCore() = default;
+    virtual ~SteadyClockCore() = default;
+
+    const Common::UUID& GetClockSourceId() const {
+        return clock_source_id;
+    }
+
+    void SetClockSourceId(const Common::UUID& value) {
+        clock_source_id = value;
+    }
+
+    virtual TimeSpanType GetInternalOffset() const = 0;
+
+    virtual void SetInternalOffset(TimeSpanType internal_offset) = 0;
+
+    virtual SteadyClockTimePoint GetTimePoint(Core::System& system) = 0;
+
+    virtual TimeSpanType GetCurrentRawTimePoint(Core::System& system) = 0;
+
+    SteadyClockTimePoint GetCurrentTimePoint(Core::System& system) {
+        SteadyClockTimePoint result{GetTimePoint(system)};
+        result.time_point += GetInternalOffset().ToSeconds();
+        return result;
+    }
+
+    bool IsInitialized() const {
+        return is_initialized;
+    }
+
+    void MarkAsInitialized() {
+        is_initialized = true;
+    }
+
+private:
+    Common::UUID clock_source_id{Common::UUID::MakeRandom()};
+    bool is_initialized{};
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/system_clock_context_update_callback.cpp

@@ -1,54 +1,54 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/service/time/errors.h"
-#include "core/hle/service/time/system_clock_context_update_callback.h"
-
-namespace Service::Time::Clock {
-
-SystemClockContextUpdateCallback::SystemClockContextUpdateCallback() = default;
-SystemClockContextUpdateCallback::~SystemClockContextUpdateCallback() = default;
-
-bool SystemClockContextUpdateCallback::NeedUpdate(const SystemClockContext& value) const {
-    if (has_context) {
-        return context.offset != value.offset ||
-               context.steady_time_point.clock_source_id != value.steady_time_point.clock_source_id;
-    }
-
-    return true;
-}
-
-void SystemClockContextUpdateCallback::RegisterOperationEvent(
-    std::shared_ptr<Kernel::KEvent>&& event) {
-    operation_event_list.emplace_back(std::move(event));
-}
-
-void SystemClockContextUpdateCallback::BroadcastOperationEvent() {
-    for (const auto& event : operation_event_list) {
-        event->Signal();
-    }
-}
-
-Result SystemClockContextUpdateCallback::Update(const SystemClockContext& value) {
-    Result result{ResultSuccess};
-
-    if (NeedUpdate(value)) {
-        context = value;
-        has_context = true;
-
-        result = Update();
-
-        if (result == ResultSuccess) {
-            BroadcastOperationEvent();
-        }
-    }
-
-    return result;
-}
-
-Result SystemClockContextUpdateCallback::Update() {
-    return ResultSuccess;
-}
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/service/time/errors.h"
+#include "core/hle/service/time/system_clock_context_update_callback.h"
+
+namespace Service::Time::Clock {
+
+SystemClockContextUpdateCallback::SystemClockContextUpdateCallback() = default;
+SystemClockContextUpdateCallback::~SystemClockContextUpdateCallback() = default;
+
+bool SystemClockContextUpdateCallback::NeedUpdate(const SystemClockContext& value) const {
+    if (has_context) {
+        return context.offset != value.offset ||
+               context.steady_time_point.clock_source_id != value.steady_time_point.clock_source_id;
+    }
+
+    return true;
+}
+
+void SystemClockContextUpdateCallback::RegisterOperationEvent(
+    std::shared_ptr<Kernel::KEvent>&& event) {
+    operation_event_list.emplace_back(std::move(event));
+}
+
+void SystemClockContextUpdateCallback::BroadcastOperationEvent() {
+    for (const auto& event : operation_event_list) {
+        event->Signal();
+    }
+}
+
+Result SystemClockContextUpdateCallback::Update(const SystemClockContext& value) {
+    Result result{ResultSuccess};
+
+    if (NeedUpdate(value)) {
+        context = value;
+        has_context = true;
+
+        result = Update();
+
+        if (result == ResultSuccess) {
+            BroadcastOperationEvent();
+        }
+    }
+
+    return result;
+}
+
+Result SystemClockContextUpdateCallback::Update() {
+    return ResultSuccess;
+}
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/system_clock_context_update_callback.h

@@ -1,43 +1,43 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-#include <vector>
-
-#include "core/hle/service/time/clock_types.h"
-
-namespace Kernel {
-class KEvent;
-}
-
-namespace Service::Time::Clock {
-
-// Parts of this implementation were based on Ryujinx (https://github.com/Ryujinx/Ryujinx/pull/783).
-// This code was released under public domain.
-
-class SystemClockContextUpdateCallback {
-public:
-    SystemClockContextUpdateCallback();
-    virtual ~SystemClockContextUpdateCallback();
-
-    bool NeedUpdate(const SystemClockContext& value) const;
-
-    void RegisterOperationEvent(std::shared_ptr<Kernel::KEvent>&& event);
-
-    void BroadcastOperationEvent();
-
-    Result Update(const SystemClockContext& value);
-
-protected:
-    virtual Result Update();
-
-    SystemClockContext context{};
-
-private:
-    bool has_context{};
-    std::vector<std::shared_ptr<Kernel::KEvent>> operation_event_list;
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+#include <vector>
+
+#include "core/hle/service/time/clock_types.h"
+
+namespace Kernel {
+class KEvent;
+}
+
+namespace Service::Time::Clock {
+
+// Parts of this implementation were based on Ryujinx (https://github.com/Ryujinx/Ryujinx/pull/783).
+// This code was released under public domain.
+
+class SystemClockContextUpdateCallback {
+public:
+    SystemClockContextUpdateCallback();
+    virtual ~SystemClockContextUpdateCallback();
+
+    bool NeedUpdate(const SystemClockContext& value) const;
+
+    void RegisterOperationEvent(std::shared_ptr<Kernel::KEvent>&& event);
+
+    void BroadcastOperationEvent();
+
+    Result Update(const SystemClockContext& value);
+
+protected:
+    virtual Result Update();
+
+    SystemClockContext context{};
+
+private:
+    bool has_context{};
+    std::vector<std::shared_ptr<Kernel::KEvent>> operation_event_list;
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/system_clock_core.cpp

@@ -1,71 +1,71 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/time/steady_clock_core.h"
-#include "core/hle/service/time/system_clock_context_update_callback.h"
-#include "core/hle/service/time/system_clock_core.h"
-
-namespace Service::Time::Clock {
-
-SystemClockCore::SystemClockCore(SteadyClockCore& steady_clock_core_)
-    : steady_clock_core{steady_clock_core_} {
-    context.steady_time_point.clock_source_id = steady_clock_core.GetClockSourceId();
-}
-
-SystemClockCore::~SystemClockCore() = default;
-
-Result SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
-    posix_time = 0;
-
-    const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
-
-    SystemClockContext clock_context{};
-    if (const Result result{GetClockContext(system, clock_context)}; result != ResultSuccess) {
-        return result;
-    }
-
-    if (current_time_point.clock_source_id != clock_context.steady_time_point.clock_source_id) {
-        return ERROR_TIME_MISMATCH;
-    }
-
-    posix_time = clock_context.offset + current_time_point.time_point;
-
-    return ResultSuccess;
-}
-
-Result SystemClockCore::SetCurrentTime(Core::System& system, s64 posix_time) {
-    const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
-    const SystemClockContext clock_context{posix_time - current_time_point.time_point,
-                                           current_time_point};
-
-    if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
-        return result;
-    }
-    return Flush(clock_context);
-}
-
-Result SystemClockCore::Flush(const SystemClockContext& clock_context) {
-    if (!system_clock_context_update_callback) {
-        return ResultSuccess;
-    }
-    return system_clock_context_update_callback->Update(clock_context);
-}
-
-Result SystemClockCore::SetSystemClockContext(const SystemClockContext& clock_context) {
-    if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
-        return result;
-    }
-    return Flush(clock_context);
-}
-
-bool SystemClockCore::IsClockSetup(Core::System& system) const {
-    SystemClockContext value{};
-    if (GetClockContext(system, value) == ResultSuccess) {
-        const SteadyClockTimePoint steady_clock_time_point{
-            steady_clock_core.GetCurrentTimePoint(system)};
-        return steady_clock_time_point.clock_source_id == value.steady_time_point.clock_source_id;
-    }
-    return {};
-}
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/time/steady_clock_core.h"
+#include "core/hle/service/time/system_clock_context_update_callback.h"
+#include "core/hle/service/time/system_clock_core.h"
+
+namespace Service::Time::Clock {
+
+SystemClockCore::SystemClockCore(SteadyClockCore& steady_clock_core_)
+    : steady_clock_core{steady_clock_core_} {
+    context.steady_time_point.clock_source_id = steady_clock_core.GetClockSourceId();
+}
+
+SystemClockCore::~SystemClockCore() = default;
+
+Result SystemClockCore::GetCurrentTime(Core::System& system, s64& posix_time) const {
+    posix_time = 0;
+
+    const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
+
+    SystemClockContext clock_context{};
+    if (const Result result{GetClockContext(system, clock_context)}; result != ResultSuccess) {
+        return result;
+    }
+
+    if (current_time_point.clock_source_id != clock_context.steady_time_point.clock_source_id) {
+        return ERROR_TIME_MISMATCH;
+    }
+
+    posix_time = clock_context.offset + current_time_point.time_point;
+
+    return ResultSuccess;
+}
+
+Result SystemClockCore::SetCurrentTime(Core::System& system, s64 posix_time) {
+    const SteadyClockTimePoint current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
+    const SystemClockContext clock_context{posix_time - current_time_point.time_point,
+                                           current_time_point};
+
+    if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
+        return result;
+    }
+    return Flush(clock_context);
+}
+
+Result SystemClockCore::Flush(const SystemClockContext& clock_context) {
+    if (!system_clock_context_update_callback) {
+        return ResultSuccess;
+    }
+    return system_clock_context_update_callback->Update(clock_context);
+}
+
+Result SystemClockCore::SetSystemClockContext(const SystemClockContext& clock_context) {
+    if (const Result result{SetClockContext(clock_context)}; result != ResultSuccess) {
+        return result;
+    }
+    return Flush(clock_context);
+}
+
+bool SystemClockCore::IsClockSetup(Core::System& system) const {
+    SystemClockContext value{};
+    if (GetClockContext(system, value) == ResultSuccess) {
+        const SteadyClockTimePoint steady_clock_time_point{
+            steady_clock_core.GetCurrentTimePoint(system)};
+        return steady_clock_time_point.clock_source_id == value.steady_time_point.clock_source_id;
+    }
+    return {};
+}
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/system_clock_core.h

@@ -1,72 +1,72 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <memory>
-
-#include "common/common_types.h"
-#include "core/hle/service/time/clock_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time::Clock {
-
-class SteadyClockCore;
-class SystemClockContextUpdateCallback;
-
-// Parts of this implementation were based on Ryujinx (https://github.com/Ryujinx/Ryujinx/pull/783).
-// This code was released under public domain.
-
-class SystemClockCore {
-public:
-    explicit SystemClockCore(SteadyClockCore& steady_clock_core_);
-    virtual ~SystemClockCore();
-
-    SteadyClockCore& GetSteadyClockCore() const {
-        return steady_clock_core;
-    }
-
-    Result GetCurrentTime(Core::System& system, s64& posix_time) const;
-
-    Result SetCurrentTime(Core::System& system, s64 posix_time);
-
-    virtual Result GetClockContext([[maybe_unused]] Core::System& system,
-                                   SystemClockContext& value) const {
-        value = context;
-        return ResultSuccess;
-    }
-
-    virtual Result SetClockContext(const SystemClockContext& value) {
-        context = value;
-        return ResultSuccess;
-    }
-
-    virtual Result Flush(const SystemClockContext& clock_context);
-
-    void SetUpdateCallbackInstance(std::shared_ptr<SystemClockContextUpdateCallback> callback) {
-        system_clock_context_update_callback = std::move(callback);
-    }
-
-    Result SetSystemClockContext(const SystemClockContext& context);
-
-    bool IsInitialized() const {
-        return is_initialized;
-    }
-
-    void MarkAsInitialized() {
-        is_initialized = true;
-    }
-
-    bool IsClockSetup(Core::System& system) const;
-
-private:
-    SteadyClockCore& steady_clock_core;
-    SystemClockContext context{};
-    bool is_initialized{};
-    std::shared_ptr<SystemClockContextUpdateCallback> system_clock_context_update_callback;
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <memory>
+
+#include "common/common_types.h"
+#include "core/hle/service/time/clock_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time::Clock {
+
+class SteadyClockCore;
+class SystemClockContextUpdateCallback;
+
+// Parts of this implementation were based on Ryujinx (https://github.com/Ryujinx/Ryujinx/pull/783).
+// This code was released under public domain.
+
+class SystemClockCore {
+public:
+    explicit SystemClockCore(SteadyClockCore& steady_clock_core_);
+    virtual ~SystemClockCore();
+
+    SteadyClockCore& GetSteadyClockCore() const {
+        return steady_clock_core;
+    }
+
+    Result GetCurrentTime(Core::System& system, s64& posix_time) const;
+
+    Result SetCurrentTime(Core::System& system, s64 posix_time);
+
+    virtual Result GetClockContext([[maybe_unused]] Core::System& system,
+                                   SystemClockContext& value) const {
+        value = context;
+        return ResultSuccess;
+    }
+
+    virtual Result SetClockContext(const SystemClockContext& value) {
+        context = value;
+        return ResultSuccess;
+    }
+
+    virtual Result Flush(const SystemClockContext& clock_context);
+
+    void SetUpdateCallbackInstance(std::shared_ptr<SystemClockContextUpdateCallback> callback) {
+        system_clock_context_update_callback = std::move(callback);
+    }
+
+    Result SetSystemClockContext(const SystemClockContext& context);
+
+    bool IsInitialized() const {
+        return is_initialized;
+    }
+
+    void MarkAsInitialized() {
+        is_initialized = true;
+    }
+
+    bool IsClockSetup(Core::System& system) const;
+
+private:
+    SteadyClockCore& steady_clock_core;
+    SystemClockContext context{};
+    bool is_initialized{};
+    std::shared_ptr<SystemClockContextUpdateCallback> system_clock_context_update_callback;
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/tick_based_steady_clock_core.cpp

@@ -1,22 +1,22 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hardware_properties.h"
-#include "core/hle/service/time/tick_based_steady_clock_core.h"
-
-namespace Service::Time::Clock {
-
-SteadyClockTimePoint TickBasedSteadyClockCore::GetTimePoint(Core::System& system) {
-    const TimeSpanType ticks_time_span{
-        TimeSpanType::FromTicks(system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
-
-    return {ticks_time_span.ToSeconds(), GetClockSourceId()};
-}
-
-TimeSpanType TickBasedSteadyClockCore::GetCurrentRawTimePoint(Core::System& system) {
-    return TimeSpanType::FromSeconds(GetTimePoint(system).time_point);
-}
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hardware_properties.h"
+#include "core/hle/service/time/tick_based_steady_clock_core.h"
+
+namespace Service::Time::Clock {
+
+SteadyClockTimePoint TickBasedSteadyClockCore::GetTimePoint(Core::System& system) {
+    const TimeSpanType ticks_time_span{
+        TimeSpanType::FromTicks(system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
+
+    return {ticks_time_span.ToSeconds(), GetClockSourceId()};
+}
+
+TimeSpanType TickBasedSteadyClockCore::GetCurrentRawTimePoint(Core::System& system) {
+    return TimeSpanType::FromSeconds(GetTimePoint(system).time_point);
+}
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/tick_based_steady_clock_core.h

@@ -1,28 +1,28 @@
-// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/steady_clock_core.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time::Clock {
-
-class TickBasedSteadyClockCore final : public SteadyClockCore {
-public:
-    TimeSpanType GetInternalOffset() const override {
-        return {};
-    }
-
-    void SetInternalOffset(TimeSpanType internal_offset) override {}
-
-    SteadyClockTimePoint GetTimePoint(Core::System& system) override;
-
-    TimeSpanType GetCurrentRawTimePoint(Core::System& system) override;
-};
-
-} // namespace Service::Time::Clock
+// SPDX-FileCopyrightText: Copyright 2020 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/steady_clock_core.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time::Clock {
+
+class TickBasedSteadyClockCore final : public SteadyClockCore {
+public:
+    TimeSpanType GetInternalOffset() const override {
+        return {};
+    }
+
+    void SetInternalOffset(TimeSpanType internal_offset) override {}
+
+    SteadyClockTimePoint GetTimePoint(Core::System& system) override;
+
+    TimeSpanType GetCurrentRawTimePoint(Core::System& system) override;
+};
+
+} // namespace Service::Time::Clock

src/core/hle/service/time/time.cpp

@@ -1,407 +1,407 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/logging/log.h"
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hardware_properties.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/service/time/time.h"
-#include "core/hle/service/time/time_interface.h"
-#include "core/hle/service/time/time_manager.h"
-#include "core/hle/service/time/time_sharedmemory.h"
-#include "core/hle/service/time/time_zone_service.h"
-
-namespace Service::Time {
-
-class ISystemClock final : public ServiceFramework<ISystemClock> {
-public:
-    explicit ISystemClock(Clock::SystemClockCore& clock_core_, Core::System& system_)
-        : ServiceFramework{system_, "ISystemClock"}, clock_core{clock_core_} {
-        // clang-format off
-        static const FunctionInfo functions[] = {
-            {0, &ISystemClock::GetCurrentTime, "GetCurrentTime"},
-            {1, nullptr, "SetCurrentTime"},
-            {2,  &ISystemClock::GetSystemClockContext, "GetSystemClockContext"},
-            {3, nullptr, "SetSystemClockContext"},
-            {4, nullptr, "GetOperationEventReadableHandle"},
-        };
-        // clang-format on
-
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetCurrentTime(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Time, "called");
-
-        if (!clock_core.IsInitialized()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_UNINITIALIZED_CLOCK);
-            return;
-        }
-
-        s64 posix_time{};
-        if (const Result result{clock_core.GetCurrentTime(system, posix_time)}; result.IsError()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, 4};
-        rb.Push(ResultSuccess);
-        rb.Push<s64>(posix_time);
-    }
-
-    void GetSystemClockContext(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Time, "called");
-
-        if (!clock_core.IsInitialized()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_UNINITIALIZED_CLOCK);
-            return;
-        }
-
-        Clock::SystemClockContext system_clock_context{};
-        if (const Result result{clock_core.GetClockContext(system, system_clock_context)};
-            result.IsError()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(result);
-            return;
-        }
-
-        IPC::ResponseBuilder rb{ctx, sizeof(Clock::SystemClockContext) / 4 + 2};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(system_clock_context);
-    }
-
-    Clock::SystemClockCore& clock_core;
-};
-
-class ISteadyClock final : public ServiceFramework<ISteadyClock> {
-public:
-    explicit ISteadyClock(Clock::SteadyClockCore& clock_core_, Core::System& system_)
-        : ServiceFramework{system_, "ISteadyClock"}, clock_core{clock_core_} {
-        static const FunctionInfo functions[] = {
-            {0, &ISteadyClock::GetCurrentTimePoint, "GetCurrentTimePoint"},
-            {2, nullptr, "GetTestOffset"},
-            {3, nullptr, "SetTestOffset"},
-            {100, nullptr, "GetRtcValue"},
-            {101, nullptr, "IsRtcResetDetected"},
-            {102, nullptr, "GetSetupResultValue"},
-            {200, nullptr, "GetInternalOffset"},
-            {201, nullptr, "SetInternalOffset"},
-        };
-        RegisterHandlers(functions);
-    }
-
-private:
-    void GetCurrentTimePoint(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_Time, "called");
-
-        if (!clock_core.IsInitialized()) {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_UNINITIALIZED_CLOCK);
-            return;
-        }
-
-        const Clock::SteadyClockTimePoint time_point{clock_core.GetCurrentTimePoint(system)};
-        IPC::ResponseBuilder rb{ctx, (sizeof(Clock::SteadyClockTimePoint) / 4) + 2};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(time_point);
-    }
-
-    Clock::SteadyClockCore& clock_core;
-};
-
-Result Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
-    Kernel::KThread* thread, Clock::SystemClockContext user_context,
-    Clock::SystemClockContext network_context, Clock::TimeType type,
-    Clock::ClockSnapshot& clock_snapshot) {
-
-    auto& time_manager{system.GetTimeManager()};
-
-    clock_snapshot.steady_clock_time_point =
-        time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system);
-    clock_snapshot.is_automatic_correction_enabled =
-        time_manager.GetStandardUserSystemClockCore().IsAutomaticCorrectionEnabled();
-    clock_snapshot.type = type;
-
-    if (const Result result{
-            time_manager.GetTimeZoneContentManager().GetTimeZoneManager().GetDeviceLocationName(
-                clock_snapshot.location_name)};
-        result != ResultSuccess) {
-        return result;
-    }
-
-    clock_snapshot.user_context = user_context;
-
-    if (const Result result{Clock::ClockSnapshot::GetCurrentTime(
-            clock_snapshot.user_time, clock_snapshot.steady_clock_time_point,
-            clock_snapshot.user_context)};
-        result != ResultSuccess) {
-        return result;
-    }
-
-    TimeZone::CalendarInfo userCalendarInfo{};
-    if (const Result result{
-            time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
-                clock_snapshot.user_time, userCalendarInfo)};
-        result != ResultSuccess) {
-        return result;
-    }
-
-    clock_snapshot.user_calendar_time = userCalendarInfo.time;
-    clock_snapshot.user_calendar_additional_time = userCalendarInfo.additional_info;
-
-    clock_snapshot.network_context = network_context;
-
-    if (Clock::ClockSnapshot::GetCurrentTime(clock_snapshot.network_time,
-                                             clock_snapshot.steady_clock_time_point,
-                                             clock_snapshot.network_context) != ResultSuccess) {
-        clock_snapshot.network_time = 0;
-    }
-
-    TimeZone::CalendarInfo networkCalendarInfo{};
-    if (const Result result{
-            time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
-                clock_snapshot.network_time, networkCalendarInfo)};
-        result != ResultSuccess) {
-        return result;
-    }
-
-    clock_snapshot.network_calendar_time = networkCalendarInfo.time;
-    clock_snapshot.network_calendar_additional_time = networkCalendarInfo.additional_info;
-
-    return ResultSuccess;
-}
-
-void Module::Interface::GetStandardUserSystemClock(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardUserSystemClockCore(),
-                                      system);
-}
-
-void Module::Interface::GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardNetworkSystemClockCore(),
-                                      system);
-}
-
-void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISteadyClock>(system.GetTimeManager().GetStandardSteadyClockCore(), system);
-}
-
-void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ITimeZoneService>(system,
-                                          system.GetTimeManager().GetTimeZoneContentManager());
-}
-
-void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
-    rb.Push(ResultSuccess);
-    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardLocalSystemClockCore(),
-                                      system);
-}
-
-void Module::Interface::IsStandardNetworkSystemClockAccuracySufficient(
-    Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    auto& clock_core{system.GetTimeManager().GetStandardNetworkSystemClockCore()};
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.Push<u32>(clock_core.IsStandardNetworkSystemClockAccuracySufficient(system));
-}
-
-void Module::Interface::CalculateMonotonicSystemClockBaseTimePoint(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-
-    auto& steady_clock_core{system.GetTimeManager().GetStandardSteadyClockCore()};
-    if (!steady_clock_core.IsInitialized()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(ERROR_UNINITIALIZED_CLOCK);
-        return;
-    }
-
-    IPC::RequestParser rp{ctx};
-    const auto context{rp.PopRaw<Clock::SystemClockContext>()};
-    const auto current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
-
-    if (current_time_point.clock_source_id == context.steady_time_point.clock_source_id) {
-        const auto ticks{Clock::TimeSpanType::FromTicks(system.CoreTiming().GetClockTicks(),
-                                                        Core::Hardware::CNTFREQ)};
-        const s64 base_time_point{context.offset + current_time_point.time_point -
-                                  ticks.ToSeconds()};
-        IPC::ResponseBuilder rb{ctx, (sizeof(s64) / 4) + 2};
-        rb.Push(ResultSuccess);
-        rb.PushRaw(base_time_point);
-        return;
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ERROR_TIME_MISMATCH);
-}
-
-void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto type{rp.PopEnum<Clock::TimeType>()};
-
-    LOG_DEBUG(Service_Time, "called, type={}", type);
-
-    Clock::SystemClockContext user_context{};
-    if (const Result result{
-            system.GetTimeManager().GetStandardUserSystemClockCore().GetClockContext(system,
-                                                                                     user_context)};
-        result.IsError()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    Clock::SystemClockContext network_context{};
-    if (const Result result{
-            system.GetTimeManager().GetStandardNetworkSystemClockCore().GetClockContext(
-                system, network_context)};
-        result.IsError()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    Clock::ClockSnapshot clock_snapshot{};
-    if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
-            &ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
-        result.IsError()) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    ctx.WriteBuffer(clock_snapshot);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void Module::Interface::GetClockSnapshotFromSystemClockContext(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto type{rp.PopEnum<Clock::TimeType>()};
-
-    rp.Skip(1, false);
-
-    const Clock::SystemClockContext user_context{rp.PopRaw<Clock::SystemClockContext>()};
-    const Clock::SystemClockContext network_context{rp.PopRaw<Clock::SystemClockContext>()};
-
-    LOG_DEBUG(Service_Time, "called, type={}", type);
-
-    Clock::ClockSnapshot clock_snapshot{};
-    if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
-            &ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    ctx.WriteBuffer(clock_snapshot);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void Module::Interface::CalculateStandardUserSystemClockDifferenceByUser(
-    Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-
-    Clock::ClockSnapshot snapshot_a;
-    Clock::ClockSnapshot snapshot_b;
-
-    const auto snapshot_a_data = ctx.ReadBuffer(0);
-    const auto snapshot_b_data = ctx.ReadBuffer(1);
-
-    std::memcpy(&snapshot_a, snapshot_a_data.data(), sizeof(Clock::ClockSnapshot));
-    std::memcpy(&snapshot_b, snapshot_b_data.data(), sizeof(Clock::ClockSnapshot));
-
-    auto time_span_type{Clock::TimeSpanType::FromSeconds(snapshot_b.user_context.offset -
-                                                         snapshot_a.user_context.offset)};
-
-    if ((snapshot_b.user_context.steady_time_point.clock_source_id !=
-         snapshot_a.user_context.steady_time_point.clock_source_id) ||
-        (snapshot_b.is_automatic_correction_enabled &&
-         snapshot_a.is_automatic_correction_enabled)) {
-        time_span_type.nanoseconds = 0;
-    }
-
-    IPC::ResponseBuilder rb{ctx, (sizeof(s64) / 4) + 2};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(time_span_type.nanoseconds);
-}
-
-void Module::Interface::CalculateSpanBetween(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-
-    Clock::ClockSnapshot snapshot_a;
-    Clock::ClockSnapshot snapshot_b;
-
-    const auto snapshot_a_data = ctx.ReadBuffer(0);
-    const auto snapshot_b_data = ctx.ReadBuffer(1);
-
-    std::memcpy(&snapshot_a, snapshot_a_data.data(), sizeof(Clock::ClockSnapshot));
-    std::memcpy(&snapshot_b, snapshot_b_data.data(), sizeof(Clock::ClockSnapshot));
-
-    Clock::TimeSpanType time_span_type{};
-    s64 span{};
-
-    if (const Result result{snapshot_a.steady_clock_time_point.GetSpanBetween(
-            snapshot_b.steady_clock_time_point, span)};
-        result != ResultSuccess) {
-        if (snapshot_a.network_time && snapshot_b.network_time) {
-            time_span_type =
-                Clock::TimeSpanType::FromSeconds(snapshot_b.network_time - snapshot_a.network_time);
-        } else {
-            IPC::ResponseBuilder rb{ctx, 2};
-            rb.Push(ERROR_TIME_NOT_FOUND);
-            return;
-        }
-    } else {
-        time_span_type = Clock::TimeSpanType::FromSeconds(span);
-    }
-
-    IPC::ResponseBuilder rb{ctx, (sizeof(s64) / 4) + 2};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(time_span_type.nanoseconds);
-}
-
-void Module::Interface::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-    IPC::ResponseBuilder rb{ctx, 2, 1};
-    rb.Push(ResultSuccess);
-    rb.PushCopyObjects(&system.Kernel().GetTimeSharedMem());
-}
-
-Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,
-                             const char* name)
-    : ServiceFramework{system_, name}, module{std::move(module_)} {}
-
-Module::Interface::~Interface() = default;
-
-void InstallInterfaces(Core::System& system) {
-    auto module{std::make_shared<Module>()};
-    std::make_shared<Time>(module, system, "time:a")->InstallAsService(system.ServiceManager());
-    std::make_shared<Time>(module, system, "time:s")->InstallAsService(system.ServiceManager());
-    std::make_shared<Time>(module, system, "time:u")->InstallAsService(system.ServiceManager());
-}
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hardware_properties.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/service/time/time.h"
+#include "core/hle/service/time/time_interface.h"
+#include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/time/time_sharedmemory.h"
+#include "core/hle/service/time/time_zone_service.h"
+
+namespace Service::Time {
+
+class ISystemClock final : public ServiceFramework<ISystemClock> {
+public:
+    explicit ISystemClock(Clock::SystemClockCore& clock_core_, Core::System& system_)
+        : ServiceFramework{system_, "ISystemClock"}, clock_core{clock_core_} {
+        // clang-format off
+        static const FunctionInfo functions[] = {
+            {0, &ISystemClock::GetCurrentTime, "GetCurrentTime"},
+            {1, nullptr, "SetCurrentTime"},
+            {2,  &ISystemClock::GetSystemClockContext, "GetSystemClockContext"},
+            {3, nullptr, "SetSystemClockContext"},
+            {4, nullptr, "GetOperationEventReadableHandle"},
+        };
+        // clang-format on
+
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetCurrentTime(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Time, "called");
+
+        if (!clock_core.IsInitialized()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_UNINITIALIZED_CLOCK);
+            return;
+        }
+
+        s64 posix_time{};
+        if (const Result result{clock_core.GetCurrentTime(system, posix_time)}; result.IsError()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, 4};
+        rb.Push(ResultSuccess);
+        rb.Push<s64>(posix_time);
+    }
+
+    void GetSystemClockContext(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Time, "called");
+
+        if (!clock_core.IsInitialized()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_UNINITIALIZED_CLOCK);
+            return;
+        }
+
+        Clock::SystemClockContext system_clock_context{};
+        if (const Result result{clock_core.GetClockContext(system, system_clock_context)};
+            result.IsError()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(result);
+            return;
+        }
+
+        IPC::ResponseBuilder rb{ctx, sizeof(Clock::SystemClockContext) / 4 + 2};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(system_clock_context);
+    }
+
+    Clock::SystemClockCore& clock_core;
+};
+
+class ISteadyClock final : public ServiceFramework<ISteadyClock> {
+public:
+    explicit ISteadyClock(Clock::SteadyClockCore& clock_core_, Core::System& system_)
+        : ServiceFramework{system_, "ISteadyClock"}, clock_core{clock_core_} {
+        static const FunctionInfo functions[] = {
+            {0, &ISteadyClock::GetCurrentTimePoint, "GetCurrentTimePoint"},
+            {2, nullptr, "GetTestOffset"},
+            {3, nullptr, "SetTestOffset"},
+            {100, nullptr, "GetRtcValue"},
+            {101, nullptr, "IsRtcResetDetected"},
+            {102, nullptr, "GetSetupResultValue"},
+            {200, nullptr, "GetInternalOffset"},
+            {201, nullptr, "SetInternalOffset"},
+        };
+        RegisterHandlers(functions);
+    }
+
+private:
+    void GetCurrentTimePoint(Kernel::HLERequestContext& ctx) {
+        LOG_DEBUG(Service_Time, "called");
+
+        if (!clock_core.IsInitialized()) {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_UNINITIALIZED_CLOCK);
+            return;
+        }
+
+        const Clock::SteadyClockTimePoint time_point{clock_core.GetCurrentTimePoint(system)};
+        IPC::ResponseBuilder rb{ctx, (sizeof(Clock::SteadyClockTimePoint) / 4) + 2};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(time_point);
+    }
+
+    Clock::SteadyClockCore& clock_core;
+};
+
+Result Module::Interface::GetClockSnapshotFromSystemClockContextInternal(
+    Kernel::KThread* thread, Clock::SystemClockContext user_context,
+    Clock::SystemClockContext network_context, Clock::TimeType type,
+    Clock::ClockSnapshot& clock_snapshot) {
+
+    auto& time_manager{system.GetTimeManager()};
+
+    clock_snapshot.steady_clock_time_point =
+        time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system);
+    clock_snapshot.is_automatic_correction_enabled =
+        time_manager.GetStandardUserSystemClockCore().IsAutomaticCorrectionEnabled();
+    clock_snapshot.type = type;
+
+    if (const Result result{
+            time_manager.GetTimeZoneContentManager().GetTimeZoneManager().GetDeviceLocationName(
+                clock_snapshot.location_name)};
+        result != ResultSuccess) {
+        return result;
+    }
+
+    clock_snapshot.user_context = user_context;
+
+    if (const Result result{Clock::ClockSnapshot::GetCurrentTime(
+            clock_snapshot.user_time, clock_snapshot.steady_clock_time_point,
+            clock_snapshot.user_context)};
+        result != ResultSuccess) {
+        return result;
+    }
+
+    TimeZone::CalendarInfo userCalendarInfo{};
+    if (const Result result{
+            time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
+                clock_snapshot.user_time, userCalendarInfo)};
+        result != ResultSuccess) {
+        return result;
+    }
+
+    clock_snapshot.user_calendar_time = userCalendarInfo.time;
+    clock_snapshot.user_calendar_additional_time = userCalendarInfo.additional_info;
+
+    clock_snapshot.network_context = network_context;
+
+    if (Clock::ClockSnapshot::GetCurrentTime(clock_snapshot.network_time,
+                                             clock_snapshot.steady_clock_time_point,
+                                             clock_snapshot.network_context) != ResultSuccess) {
+        clock_snapshot.network_time = 0;
+    }
+
+    TimeZone::CalendarInfo networkCalendarInfo{};
+    if (const Result result{
+            time_manager.GetTimeZoneContentManager().GetTimeZoneManager().ToCalendarTimeWithMyRules(
+                clock_snapshot.network_time, networkCalendarInfo)};
+        result != ResultSuccess) {
+        return result;
+    }
+
+    clock_snapshot.network_calendar_time = networkCalendarInfo.time;
+    clock_snapshot.network_calendar_additional_time = networkCalendarInfo.additional_info;
+
+    return ResultSuccess;
+}
+
+void Module::Interface::GetStandardUserSystemClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardUserSystemClockCore(),
+                                      system);
+}
+
+void Module::Interface::GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardNetworkSystemClockCore(),
+                                      system);
+}
+
+void Module::Interface::GetStandardSteadyClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ISteadyClock>(system.GetTimeManager().GetStandardSteadyClockCore(), system);
+}
+
+void Module::Interface::GetTimeZoneService(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ITimeZoneService>(system,
+                                          system.GetTimeManager().GetTimeZoneContentManager());
+}
+
+void Module::Interface::GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 0, 1};
+    rb.Push(ResultSuccess);
+    rb.PushIpcInterface<ISystemClock>(system.GetTimeManager().GetStandardLocalSystemClockCore(),
+                                      system);
+}
+
+void Module::Interface::IsStandardNetworkSystemClockAccuracySufficient(
+    Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    auto& clock_core{system.GetTimeManager().GetStandardNetworkSystemClockCore()};
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.Push<u32>(clock_core.IsStandardNetworkSystemClockAccuracySufficient(system));
+}
+
+void Module::Interface::CalculateMonotonicSystemClockBaseTimePoint(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    auto& steady_clock_core{system.GetTimeManager().GetStandardSteadyClockCore()};
+    if (!steady_clock_core.IsInitialized()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(ERROR_UNINITIALIZED_CLOCK);
+        return;
+    }
+
+    IPC::RequestParser rp{ctx};
+    const auto context{rp.PopRaw<Clock::SystemClockContext>()};
+    const auto current_time_point{steady_clock_core.GetCurrentTimePoint(system)};
+
+    if (current_time_point.clock_source_id == context.steady_time_point.clock_source_id) {
+        const auto ticks{Clock::TimeSpanType::FromTicks(system.CoreTiming().GetClockTicks(),
+                                                        Core::Hardware::CNTFREQ)};
+        const s64 base_time_point{context.offset + current_time_point.time_point -
+                                  ticks.ToSeconds()};
+        IPC::ResponseBuilder rb{ctx, (sizeof(s64) / 4) + 2};
+        rb.Push(ResultSuccess);
+        rb.PushRaw(base_time_point);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ERROR_TIME_MISMATCH);
+}
+
+void Module::Interface::GetClockSnapshot(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto type{rp.PopEnum<Clock::TimeType>()};
+
+    LOG_DEBUG(Service_Time, "called, type={}", type);
+
+    Clock::SystemClockContext user_context{};
+    if (const Result result{
+            system.GetTimeManager().GetStandardUserSystemClockCore().GetClockContext(system,
+                                                                                     user_context)};
+        result.IsError()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    Clock::SystemClockContext network_context{};
+    if (const Result result{
+            system.GetTimeManager().GetStandardNetworkSystemClockCore().GetClockContext(
+                system, network_context)};
+        result.IsError()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    Clock::ClockSnapshot clock_snapshot{};
+    if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
+            &ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
+        result.IsError()) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    ctx.WriteBuffer(clock_snapshot);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void Module::Interface::GetClockSnapshotFromSystemClockContext(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto type{rp.PopEnum<Clock::TimeType>()};
+
+    rp.Skip(1, false);
+
+    const Clock::SystemClockContext user_context{rp.PopRaw<Clock::SystemClockContext>()};
+    const Clock::SystemClockContext network_context{rp.PopRaw<Clock::SystemClockContext>()};
+
+    LOG_DEBUG(Service_Time, "called, type={}", type);
+
+    Clock::ClockSnapshot clock_snapshot{};
+    if (const Result result{GetClockSnapshotFromSystemClockContextInternal(
+            &ctx.GetThread(), user_context, network_context, type, clock_snapshot)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    ctx.WriteBuffer(clock_snapshot);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void Module::Interface::CalculateStandardUserSystemClockDifferenceByUser(
+    Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    Clock::ClockSnapshot snapshot_a;
+    Clock::ClockSnapshot snapshot_b;
+
+    const auto snapshot_a_data = ctx.ReadBuffer(0);
+    const auto snapshot_b_data = ctx.ReadBuffer(1);
+
+    std::memcpy(&snapshot_a, snapshot_a_data.data(), sizeof(Clock::ClockSnapshot));
+    std::memcpy(&snapshot_b, snapshot_b_data.data(), sizeof(Clock::ClockSnapshot));
+
+    auto time_span_type{Clock::TimeSpanType::FromSeconds(snapshot_b.user_context.offset -
+                                                         snapshot_a.user_context.offset)};
+
+    if ((snapshot_b.user_context.steady_time_point.clock_source_id !=
+         snapshot_a.user_context.steady_time_point.clock_source_id) ||
+        (snapshot_b.is_automatic_correction_enabled &&
+         snapshot_a.is_automatic_correction_enabled)) {
+        time_span_type.nanoseconds = 0;
+    }
+
+    IPC::ResponseBuilder rb{ctx, (sizeof(s64) / 4) + 2};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(time_span_type.nanoseconds);
+}
+
+void Module::Interface::CalculateSpanBetween(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    Clock::ClockSnapshot snapshot_a;
+    Clock::ClockSnapshot snapshot_b;
+
+    const auto snapshot_a_data = ctx.ReadBuffer(0);
+    const auto snapshot_b_data = ctx.ReadBuffer(1);
+
+    std::memcpy(&snapshot_a, snapshot_a_data.data(), sizeof(Clock::ClockSnapshot));
+    std::memcpy(&snapshot_b, snapshot_b_data.data(), sizeof(Clock::ClockSnapshot));
+
+    Clock::TimeSpanType time_span_type{};
+    s64 span{};
+
+    if (const Result result{snapshot_a.steady_clock_time_point.GetSpanBetween(
+            snapshot_b.steady_clock_time_point, span)};
+        result != ResultSuccess) {
+        if (snapshot_a.network_time && snapshot_b.network_time) {
+            time_span_type =
+                Clock::TimeSpanType::FromSeconds(snapshot_b.network_time - snapshot_a.network_time);
+        } else {
+            IPC::ResponseBuilder rb{ctx, 2};
+            rb.Push(ERROR_TIME_NOT_FOUND);
+            return;
+        }
+    } else {
+        time_span_type = Clock::TimeSpanType::FromSeconds(span);
+    }
+
+    IPC::ResponseBuilder rb{ctx, (sizeof(s64) / 4) + 2};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(time_span_type.nanoseconds);
+}
+
+void Module::Interface::GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+    IPC::ResponseBuilder rb{ctx, 2, 1};
+    rb.Push(ResultSuccess);
+    rb.PushCopyObjects(&system.Kernel().GetTimeSharedMem());
+}
+
+Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& system_,
+                             const char* name)
+    : ServiceFramework{system_, name}, module{std::move(module_)} {}
+
+Module::Interface::~Interface() = default;
+
+void InstallInterfaces(Core::System& system) {
+    auto module{std::make_shared<Module>()};
+    std::make_shared<Time>(module, system, "time:a")->InstallAsService(system.ServiceManager());
+    std::make_shared<Time>(module, system, "time:s")->InstallAsService(system.ServiceManager());
+    std::make_shared<Time>(module, system, "time:u")->InstallAsService(system.ServiceManager());
+}
+
+} // namespace Service::Time

src/core/hle/service/time/time.h

@@ -1,52 +1,52 @@
-// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-#include "core/hle/service/time/clock_types.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time {
-
-class Module final {
-public:
-    Module() = default;
-
-    class Interface : public ServiceFramework<Interface> {
-    public:
-        explicit Interface(std::shared_ptr<Module> module_, Core::System& system_,
-                           const char* name);
-        ~Interface() override;
-
-        void GetStandardUserSystemClock(Kernel::HLERequestContext& ctx);
-        void GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx);
-        void GetStandardSteadyClock(Kernel::HLERequestContext& ctx);
-        void GetTimeZoneService(Kernel::HLERequestContext& ctx);
-        void GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx);
-        void IsStandardNetworkSystemClockAccuracySufficient(Kernel::HLERequestContext& ctx);
-        void CalculateMonotonicSystemClockBaseTimePoint(Kernel::HLERequestContext& ctx);
-        void GetClockSnapshot(Kernel::HLERequestContext& ctx);
-        void GetClockSnapshotFromSystemClockContext(Kernel::HLERequestContext& ctx);
-        void CalculateStandardUserSystemClockDifferenceByUser(Kernel::HLERequestContext& ctx);
-        void CalculateSpanBetween(Kernel::HLERequestContext& ctx);
-        void GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx);
-
-    private:
-        Result GetClockSnapshotFromSystemClockContextInternal(
-            Kernel::KThread* thread, Clock::SystemClockContext user_context,
-            Clock::SystemClockContext network_context, Clock::TimeType type,
-            Clock::ClockSnapshot& cloc_snapshot);
-
-    protected:
-        std::shared_ptr<Module> module;
-    };
-};
-
-/// Registers all Time services with the specified service manager.
-void InstallInterfaces(Core::System& system);
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/service.h"
+#include "core/hle/service/time/clock_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time {
+
+class Module final {
+public:
+    Module() = default;
+
+    class Interface : public ServiceFramework<Interface> {
+    public:
+        explicit Interface(std::shared_ptr<Module> module_, Core::System& system_,
+                           const char* name);
+        ~Interface() override;
+
+        void GetStandardUserSystemClock(Kernel::HLERequestContext& ctx);
+        void GetStandardNetworkSystemClock(Kernel::HLERequestContext& ctx);
+        void GetStandardSteadyClock(Kernel::HLERequestContext& ctx);
+        void GetTimeZoneService(Kernel::HLERequestContext& ctx);
+        void GetStandardLocalSystemClock(Kernel::HLERequestContext& ctx);
+        void IsStandardNetworkSystemClockAccuracySufficient(Kernel::HLERequestContext& ctx);
+        void CalculateMonotonicSystemClockBaseTimePoint(Kernel::HLERequestContext& ctx);
+        void GetClockSnapshot(Kernel::HLERequestContext& ctx);
+        void GetClockSnapshotFromSystemClockContext(Kernel::HLERequestContext& ctx);
+        void CalculateStandardUserSystemClockDifferenceByUser(Kernel::HLERequestContext& ctx);
+        void CalculateSpanBetween(Kernel::HLERequestContext& ctx);
+        void GetSharedMemoryNativeHandle(Kernel::HLERequestContext& ctx);
+
+    private:
+        Result GetClockSnapshotFromSystemClockContextInternal(
+            Kernel::KThread* thread, Clock::SystemClockContext user_context,
+            Clock::SystemClockContext network_context, Clock::TimeType type,
+            Clock::ClockSnapshot& cloc_snapshot);
+
+    protected:
+        std::shared_ptr<Module> module;
+    };
+};
+
+/// Registers all Time services with the specified service manager.
+void InstallInterfaces(Core::System& system);
+
+} // namespace Service::Time

src/core/hle/service/time/time_interface.cpp

@@ -1,41 +1,41 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/hle/service/time/time_interface.h"
-
-namespace Service::Time {
-
-Time::Time(std::shared_ptr<Module> module_, Core::System& system_, const char* name_)
-    : Interface{std::move(module_), system_, name_} {
-    // clang-format off
-    static const FunctionInfo functions[] = {
-        {0, &Time::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
-        {1, &Time::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
-        {2, &Time::GetStandardSteadyClock, "GetStandardSteadyClock"},
-        {3, &Time::GetTimeZoneService, "GetTimeZoneService"},
-        {4, &Time::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
-        {5, nullptr, "GetEphemeralNetworkSystemClock"},
-        {20, &Time::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"},
-        {30, nullptr, "GetStandardNetworkClockOperationEventReadableHandle"},
-        {31, nullptr, "GetEphemeralNetworkClockOperationEventReadableHandle"},
-        {50, nullptr, "SetStandardSteadyClockInternalOffset"},
-        {51, nullptr, "GetStandardSteadyClockRtcValue"},
-        {100, nullptr, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
-        {101, nullptr, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
-        {102, nullptr, "GetStandardUserSystemClockInitialYear"},
-        {200, &Time::IsStandardNetworkSystemClockAccuracySufficient, "IsStandardNetworkSystemClockAccuracySufficient"},
-        {201, nullptr, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
-        {300, &Time::CalculateMonotonicSystemClockBaseTimePoint, "CalculateMonotonicSystemClockBaseTimePoint"},
-        {400, &Time::GetClockSnapshot, "GetClockSnapshot"},
-        {401, &Time::GetClockSnapshotFromSystemClockContext, "GetClockSnapshotFromSystemClockContext"},
-        {500, &Time::CalculateStandardUserSystemClockDifferenceByUser, "CalculateStandardUserSystemClockDifferenceByUser"},
-        {501, &Time::CalculateSpanBetween, "CalculateSpanBetween"},
-    };
-    // clang-format on
-
-    RegisterHandlers(functions);
-}
-
-Time::~Time() = default;
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/service/time/time_interface.h"
+
+namespace Service::Time {
+
+Time::Time(std::shared_ptr<Module> module_, Core::System& system_, const char* name_)
+    : Interface{std::move(module_), system_, name_} {
+    // clang-format off
+    static const FunctionInfo functions[] = {
+        {0, &Time::GetStandardUserSystemClock, "GetStandardUserSystemClock"},
+        {1, &Time::GetStandardNetworkSystemClock, "GetStandardNetworkSystemClock"},
+        {2, &Time::GetStandardSteadyClock, "GetStandardSteadyClock"},
+        {3, &Time::GetTimeZoneService, "GetTimeZoneService"},
+        {4, &Time::GetStandardLocalSystemClock, "GetStandardLocalSystemClock"},
+        {5, nullptr, "GetEphemeralNetworkSystemClock"},
+        {20, &Time::GetSharedMemoryNativeHandle, "GetSharedMemoryNativeHandle"},
+        {30, nullptr, "GetStandardNetworkClockOperationEventReadableHandle"},
+        {31, nullptr, "GetEphemeralNetworkClockOperationEventReadableHandle"},
+        {50, nullptr, "SetStandardSteadyClockInternalOffset"},
+        {51, nullptr, "GetStandardSteadyClockRtcValue"},
+        {100, nullptr, "IsStandardUserSystemClockAutomaticCorrectionEnabled"},
+        {101, nullptr, "SetStandardUserSystemClockAutomaticCorrectionEnabled"},
+        {102, nullptr, "GetStandardUserSystemClockInitialYear"},
+        {200, &Time::IsStandardNetworkSystemClockAccuracySufficient, "IsStandardNetworkSystemClockAccuracySufficient"},
+        {201, nullptr, "GetStandardUserSystemClockAutomaticCorrectionUpdatedTime"},
+        {300, &Time::CalculateMonotonicSystemClockBaseTimePoint, "CalculateMonotonicSystemClockBaseTimePoint"},
+        {400, &Time::GetClockSnapshot, "GetClockSnapshot"},
+        {401, &Time::GetClockSnapshotFromSystemClockContext, "GetClockSnapshotFromSystemClockContext"},
+        {500, &Time::CalculateStandardUserSystemClockDifferenceByUser, "CalculateStandardUserSystemClockDifferenceByUser"},
+        {501, &Time::CalculateSpanBetween, "CalculateSpanBetween"},
+    };
+    // clang-format on
+
+    RegisterHandlers(functions);
+}
+
+Time::~Time() = default;
+
+} // namespace Service::Time

src/core/hle/service/time/time_interface.h

@@ -1,20 +1,20 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/time/time.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time {
-
-class Time final : public Module::Interface {
-public:
-    explicit Time(std::shared_ptr<Module> time, Core::System& system_, const char* name_);
-    ~Time() override;
-};
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/time/time.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time {
+
+class Time final : public Module::Interface {
+public:
+    explicit Time(std::shared_ptr<Module> time, Core::System& system_, const char* name_);
+    ~Time() override;
+};
+
+} // namespace Service::Time

src/core/hle/service/time/time_manager.cpp

@@ -1,313 +1,313 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <chrono>
-#include <ctime>
-
-#include "common/settings.h"
-#include "common/time_zone.h"
-#include "core/hle/service/time/ephemeral_network_system_clock_context_writer.h"
-#include "core/hle/service/time/ephemeral_network_system_clock_core.h"
-#include "core/hle/service/time/local_system_clock_context_writer.h"
-#include "core/hle/service/time/network_system_clock_context_writer.h"
-#include "core/hle/service/time/tick_based_steady_clock_core.h"
-#include "core/hle/service/time/time_manager.h"
-
-namespace Service::Time {
-namespace {
-constexpr Clock::TimeSpanType standard_network_clock_accuracy{0x0009356907420000ULL};
-
-s64 GetSecondsSinceEpoch() {
-    const auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch();
-    return std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch).count() +
-           Settings::values.custom_rtc_differential;
-}
-
-s64 GetExternalRtcValue() {
-    return GetSecondsSinceEpoch() + TimeManager::GetExternalTimeZoneOffset();
-}
-} // Anonymous namespace
-
-struct TimeManager::Impl final {
-    explicit Impl(Core::System& system)
-        : shared_memory{system}, standard_local_system_clock_core{standard_steady_clock_core},
-          standard_network_system_clock_core{standard_steady_clock_core},
-          standard_user_system_clock_core{standard_local_system_clock_core,
-                                          standard_network_system_clock_core, system},
-          ephemeral_network_system_clock_core{tick_based_steady_clock_core},
-          local_system_clock_context_writer{
-              std::make_shared<Clock::LocalSystemClockContextWriter>(shared_memory)},
-          network_system_clock_context_writer{
-              std::make_shared<Clock::NetworkSystemClockContextWriter>(shared_memory)},
-          ephemeral_network_system_clock_context_writer{
-              std::make_shared<Clock::EphemeralNetworkSystemClockContextWriter>()},
-          time_zone_content_manager{system} {
-
-        const auto system_time{Clock::TimeSpanType::FromSeconds(GetExternalRtcValue())};
-        SetupStandardSteadyClock(system, Common::UUID::MakeRandom(), system_time, {}, {});
-        SetupStandardLocalSystemClock(system, {}, system_time.ToSeconds());
-
-        Clock::SystemClockContext clock_context{};
-        standard_local_system_clock_core.GetClockContext(system, clock_context);
-
-        SetupStandardNetworkSystemClock(clock_context, standard_network_clock_accuracy);
-        SetupStandardUserSystemClock(system, {}, Clock::SteadyClockTimePoint::GetRandom());
-        SetupEphemeralNetworkSystemClock();
-    }
-
-    ~Impl() = default;
-
-    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() {
-        return standard_steady_clock_core;
-    }
-
-    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const {
-        return standard_steady_clock_core;
-    }
-
-    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() {
-        return standard_local_system_clock_core;
-    }
-
-    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const {
-        return standard_local_system_clock_core;
-    }
-
-    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() {
-        return standard_network_system_clock_core;
-    }
-
-    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const {
-        return standard_network_system_clock_core;
-    }
-
-    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() {
-        return standard_user_system_clock_core;
-    }
-
-    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const {
-        return standard_user_system_clock_core;
-    }
-
-    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() {
-        return time_zone_content_manager;
-    }
-
-    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const {
-        return time_zone_content_manager;
-    }
-
-    SharedMemory& GetSharedMemory() {
-        return shared_memory;
-    }
-
-    const SharedMemory& GetSharedMemory() const {
-        return shared_memory;
-    }
-
-    void SetupTimeZoneManager(std::string location_name,
-                              Clock::SteadyClockTimePoint time_zone_updated_time_point,
-                              std::size_t total_location_name_count, u128 time_zone_rule_version,
-                              FileSys::VirtualFile& vfs_file) {
-        if (time_zone_content_manager.GetTimeZoneManager().SetDeviceLocationNameWithTimeZoneRule(
-                location_name, vfs_file) != ResultSuccess) {
-            ASSERT(false);
-            return;
-        }
-
-        time_zone_content_manager.GetTimeZoneManager().SetUpdatedTime(time_zone_updated_time_point);
-        time_zone_content_manager.GetTimeZoneManager().SetTotalLocationNameCount(
-            total_location_name_count);
-        time_zone_content_manager.GetTimeZoneManager().SetTimeZoneRuleVersion(
-            time_zone_rule_version);
-        time_zone_content_manager.GetTimeZoneManager().MarkAsInitialized();
-    }
-
-    static s64 GetExternalTimeZoneOffset() {
-        // With "auto" timezone setting, we use the external system's timezone offset
-        if (Settings::GetTimeZoneString() == "auto") {
-            return Common::TimeZone::GetCurrentOffsetSeconds().count();
-        }
-        return 0;
-    }
-
-    void SetupStandardSteadyClock(Core::System& system_, Common::UUID clock_source_id,
-                                  Clock::TimeSpanType setup_value,
-                                  Clock::TimeSpanType internal_offset, bool is_rtc_reset_detected) {
-        standard_steady_clock_core.SetClockSourceId(clock_source_id);
-        standard_steady_clock_core.SetSetupValue(setup_value);
-        standard_steady_clock_core.SetInternalOffset(internal_offset);
-        standard_steady_clock_core.MarkAsInitialized();
-
-        const auto current_time_point{standard_steady_clock_core.GetCurrentRawTimePoint(system_)};
-        shared_memory.SetupStandardSteadyClock(clock_source_id, current_time_point);
-    }
-
-    void SetupStandardLocalSystemClock(Core::System& system_,
-                                       Clock::SystemClockContext clock_context, s64 posix_time) {
-        standard_local_system_clock_core.SetUpdateCallbackInstance(
-            local_system_clock_context_writer);
-
-        const auto current_time_point{
-            standard_local_system_clock_core.GetSteadyClockCore().GetCurrentTimePoint(system_)};
-        if (current_time_point.clock_source_id == clock_context.steady_time_point.clock_source_id) {
-            standard_local_system_clock_core.SetSystemClockContext(clock_context);
-        } else {
-            if (standard_local_system_clock_core.SetCurrentTime(system_, posix_time) !=
-                ResultSuccess) {
-                ASSERT(false);
-                return;
-            }
-        }
-
-        standard_local_system_clock_core.MarkAsInitialized();
-    }
-
-    void SetupStandardNetworkSystemClock(Clock::SystemClockContext clock_context,
-                                         Clock::TimeSpanType sufficient_accuracy) {
-        standard_network_system_clock_core.SetUpdateCallbackInstance(
-            network_system_clock_context_writer);
-
-        if (standard_network_system_clock_core.SetSystemClockContext(clock_context) !=
-            ResultSuccess) {
-            ASSERT(false);
-            return;
-        }
-
-        standard_network_system_clock_core.SetStandardNetworkClockSufficientAccuracy(
-            sufficient_accuracy);
-        standard_network_system_clock_core.MarkAsInitialized();
-    }
-
-    void SetupStandardUserSystemClock(Core::System& system_, bool is_automatic_correction_enabled,
-                                      Clock::SteadyClockTimePoint steady_clock_time_point) {
-        if (standard_user_system_clock_core.SetAutomaticCorrectionEnabled(
-                system_, is_automatic_correction_enabled) != ResultSuccess) {
-            ASSERT(false);
-            return;
-        }
-
-        standard_user_system_clock_core.SetAutomaticCorrectionUpdatedTime(steady_clock_time_point);
-        standard_user_system_clock_core.MarkAsInitialized();
-        shared_memory.SetAutomaticCorrectionEnabled(is_automatic_correction_enabled);
-    }
-
-    void SetupEphemeralNetworkSystemClock() {
-        ephemeral_network_system_clock_core.SetUpdateCallbackInstance(
-            ephemeral_network_system_clock_context_writer);
-        ephemeral_network_system_clock_core.MarkAsInitialized();
-    }
-
-    void UpdateLocalSystemClockTime(Core::System& system_, s64 posix_time) {
-        const auto timespan{Clock::TimeSpanType::FromSeconds(posix_time)};
-        if (GetStandardLocalSystemClockCore()
-                .SetCurrentTime(system_, timespan.ToSeconds())
-                .IsError()) {
-            ASSERT(false);
-            return;
-        }
-    }
-
-    SharedMemory shared_memory;
-
-    Clock::StandardSteadyClockCore standard_steady_clock_core;
-    Clock::TickBasedSteadyClockCore tick_based_steady_clock_core;
-    Clock::StandardLocalSystemClockCore standard_local_system_clock_core;
-    Clock::StandardNetworkSystemClockCore standard_network_system_clock_core;
-    Clock::StandardUserSystemClockCore standard_user_system_clock_core;
-    Clock::EphemeralNetworkSystemClockCore ephemeral_network_system_clock_core;
-
-    std::shared_ptr<Clock::LocalSystemClockContextWriter> local_system_clock_context_writer;
-    std::shared_ptr<Clock::NetworkSystemClockContextWriter> network_system_clock_context_writer;
-    std::shared_ptr<Clock::EphemeralNetworkSystemClockContextWriter>
-        ephemeral_network_system_clock_context_writer;
-
-    TimeZone::TimeZoneContentManager time_zone_content_manager;
-};
-
-TimeManager::TimeManager(Core::System& system_) : system{system_} {}
-
-TimeManager::~TimeManager() = default;
-
-void TimeManager::Initialize() {
-    impl = std::make_unique<Impl>(system);
-
-    // Time zones can only be initialized after impl is valid
-    impl->time_zone_content_manager.Initialize(*this);
-}
-
-Clock::StandardSteadyClockCore& TimeManager::GetStandardSteadyClockCore() {
-    return impl->standard_steady_clock_core;
-}
-
-const Clock::StandardSteadyClockCore& TimeManager::GetStandardSteadyClockCore() const {
-    return impl->standard_steady_clock_core;
-}
-
-Clock::StandardLocalSystemClockCore& TimeManager::GetStandardLocalSystemClockCore() {
-    return impl->standard_local_system_clock_core;
-}
-
-const Clock::StandardLocalSystemClockCore& TimeManager::GetStandardLocalSystemClockCore() const {
-    return impl->standard_local_system_clock_core;
-}
-
-Clock::StandardNetworkSystemClockCore& TimeManager::GetStandardNetworkSystemClockCore() {
-    return impl->standard_network_system_clock_core;
-}
-
-const Clock::StandardNetworkSystemClockCore& TimeManager::GetStandardNetworkSystemClockCore()
-    const {
-    return impl->standard_network_system_clock_core;
-}
-
-Clock::StandardUserSystemClockCore& TimeManager::GetStandardUserSystemClockCore() {
-    return impl->standard_user_system_clock_core;
-}
-
-const Clock::StandardUserSystemClockCore& TimeManager::GetStandardUserSystemClockCore() const {
-    return impl->standard_user_system_clock_core;
-}
-
-TimeZone::TimeZoneContentManager& TimeManager::GetTimeZoneContentManager() {
-    return impl->time_zone_content_manager;
-}
-
-const TimeZone::TimeZoneContentManager& TimeManager::GetTimeZoneContentManager() const {
-    return impl->time_zone_content_manager;
-}
-
-SharedMemory& TimeManager::GetSharedMemory() {
-    return impl->shared_memory;
-}
-
-const SharedMemory& TimeManager::GetSharedMemory() const {
-    return impl->shared_memory;
-}
-
-void TimeManager::Shutdown() {
-    impl.reset();
-}
-
-void TimeManager::UpdateLocalSystemClockTime(s64 posix_time) {
-    impl->UpdateLocalSystemClockTime(system, posix_time);
-}
-
-void TimeManager::SetupTimeZoneManager(std::string location_name,
-                                       Clock::SteadyClockTimePoint time_zone_updated_time_point,
-                                       std::size_t total_location_name_count,
-                                       u128 time_zone_rule_version,
-                                       FileSys::VirtualFile& vfs_file) {
-    impl->SetupTimeZoneManager(location_name, time_zone_updated_time_point,
-                               total_location_name_count, time_zone_rule_version, vfs_file);
-}
-
-/*static*/ s64 TimeManager::GetExternalTimeZoneOffset() {
-    // With "auto" timezone setting, we use the external system's timezone offset
-    if (Settings::GetTimeZoneString() == "auto") {
-        return Common::TimeZone::GetCurrentOffsetSeconds().count();
-    }
-    return 0;
-}
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <chrono>
+#include <ctime>
+
+#include "common/settings.h"
+#include "common/time_zone.h"
+#include "core/hle/service/time/ephemeral_network_system_clock_context_writer.h"
+#include "core/hle/service/time/ephemeral_network_system_clock_core.h"
+#include "core/hle/service/time/local_system_clock_context_writer.h"
+#include "core/hle/service/time/network_system_clock_context_writer.h"
+#include "core/hle/service/time/tick_based_steady_clock_core.h"
+#include "core/hle/service/time/time_manager.h"
+
+namespace Service::Time {
+namespace {
+constexpr Clock::TimeSpanType standard_network_clock_accuracy{0x0009356907420000ULL};
+
+s64 GetSecondsSinceEpoch() {
+    const auto time_since_epoch = std::chrono::system_clock::now().time_since_epoch();
+    return std::chrono::duration_cast<std::chrono::seconds>(time_since_epoch).count() +
+           Settings::values.custom_rtc_differential;
+}
+
+s64 GetExternalRtcValue() {
+    return GetSecondsSinceEpoch() + TimeManager::GetExternalTimeZoneOffset();
+}
+} // Anonymous namespace
+
+struct TimeManager::Impl final {
+    explicit Impl(Core::System& system)
+        : shared_memory{system}, standard_local_system_clock_core{standard_steady_clock_core},
+          standard_network_system_clock_core{standard_steady_clock_core},
+          standard_user_system_clock_core{standard_local_system_clock_core,
+                                          standard_network_system_clock_core, system},
+          ephemeral_network_system_clock_core{tick_based_steady_clock_core},
+          local_system_clock_context_writer{
+              std::make_shared<Clock::LocalSystemClockContextWriter>(shared_memory)},
+          network_system_clock_context_writer{
+              std::make_shared<Clock::NetworkSystemClockContextWriter>(shared_memory)},
+          ephemeral_network_system_clock_context_writer{
+              std::make_shared<Clock::EphemeralNetworkSystemClockContextWriter>()},
+          time_zone_content_manager{system} {
+
+        const auto system_time{Clock::TimeSpanType::FromSeconds(GetExternalRtcValue())};
+        SetupStandardSteadyClock(system, Common::UUID::MakeRandom(), system_time, {}, {});
+        SetupStandardLocalSystemClock(system, {}, system_time.ToSeconds());
+
+        Clock::SystemClockContext clock_context{};
+        standard_local_system_clock_core.GetClockContext(system, clock_context);
+
+        SetupStandardNetworkSystemClock(clock_context, standard_network_clock_accuracy);
+        SetupStandardUserSystemClock(system, {}, Clock::SteadyClockTimePoint::GetRandom());
+        SetupEphemeralNetworkSystemClock();
+    }
+
+    ~Impl() = default;
+
+    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() {
+        return standard_steady_clock_core;
+    }
+
+    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const {
+        return standard_steady_clock_core;
+    }
+
+    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() {
+        return standard_local_system_clock_core;
+    }
+
+    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const {
+        return standard_local_system_clock_core;
+    }
+
+    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() {
+        return standard_network_system_clock_core;
+    }
+
+    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const {
+        return standard_network_system_clock_core;
+    }
+
+    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() {
+        return standard_user_system_clock_core;
+    }
+
+    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const {
+        return standard_user_system_clock_core;
+    }
+
+    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() {
+        return time_zone_content_manager;
+    }
+
+    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const {
+        return time_zone_content_manager;
+    }
+
+    SharedMemory& GetSharedMemory() {
+        return shared_memory;
+    }
+
+    const SharedMemory& GetSharedMemory() const {
+        return shared_memory;
+    }
+
+    void SetupTimeZoneManager(std::string location_name,
+                              Clock::SteadyClockTimePoint time_zone_updated_time_point,
+                              std::size_t total_location_name_count, u128 time_zone_rule_version,
+                              FileSys::VirtualFile& vfs_file) {
+        if (time_zone_content_manager.GetTimeZoneManager().SetDeviceLocationNameWithTimeZoneRule(
+                location_name, vfs_file) != ResultSuccess) {
+            ASSERT(false);
+            return;
+        }
+
+        time_zone_content_manager.GetTimeZoneManager().SetUpdatedTime(time_zone_updated_time_point);
+        time_zone_content_manager.GetTimeZoneManager().SetTotalLocationNameCount(
+            total_location_name_count);
+        time_zone_content_manager.GetTimeZoneManager().SetTimeZoneRuleVersion(
+            time_zone_rule_version);
+        time_zone_content_manager.GetTimeZoneManager().MarkAsInitialized();
+    }
+
+    static s64 GetExternalTimeZoneOffset() {
+        // With "auto" timezone setting, we use the external system's timezone offset
+        if (Settings::GetTimeZoneString() == "auto") {
+            return Common::TimeZone::GetCurrentOffsetSeconds().count();
+        }
+        return 0;
+    }
+
+    void SetupStandardSteadyClock(Core::System& system_, Common::UUID clock_source_id,
+                                  Clock::TimeSpanType setup_value,
+                                  Clock::TimeSpanType internal_offset, bool is_rtc_reset_detected) {
+        standard_steady_clock_core.SetClockSourceId(clock_source_id);
+        standard_steady_clock_core.SetSetupValue(setup_value);
+        standard_steady_clock_core.SetInternalOffset(internal_offset);
+        standard_steady_clock_core.MarkAsInitialized();
+
+        const auto current_time_point{standard_steady_clock_core.GetCurrentRawTimePoint(system_)};
+        shared_memory.SetupStandardSteadyClock(clock_source_id, current_time_point);
+    }
+
+    void SetupStandardLocalSystemClock(Core::System& system_,
+                                       Clock::SystemClockContext clock_context, s64 posix_time) {
+        standard_local_system_clock_core.SetUpdateCallbackInstance(
+            local_system_clock_context_writer);
+
+        const auto current_time_point{
+            standard_local_system_clock_core.GetSteadyClockCore().GetCurrentTimePoint(system_)};
+        if (current_time_point.clock_source_id == clock_context.steady_time_point.clock_source_id) {
+            standard_local_system_clock_core.SetSystemClockContext(clock_context);
+        } else {
+            if (standard_local_system_clock_core.SetCurrentTime(system_, posix_time) !=
+                ResultSuccess) {
+                ASSERT(false);
+                return;
+            }
+        }
+
+        standard_local_system_clock_core.MarkAsInitialized();
+    }
+
+    void SetupStandardNetworkSystemClock(Clock::SystemClockContext clock_context,
+                                         Clock::TimeSpanType sufficient_accuracy) {
+        standard_network_system_clock_core.SetUpdateCallbackInstance(
+            network_system_clock_context_writer);
+
+        if (standard_network_system_clock_core.SetSystemClockContext(clock_context) !=
+            ResultSuccess) {
+            ASSERT(false);
+            return;
+        }
+
+        standard_network_system_clock_core.SetStandardNetworkClockSufficientAccuracy(
+            sufficient_accuracy);
+        standard_network_system_clock_core.MarkAsInitialized();
+    }
+
+    void SetupStandardUserSystemClock(Core::System& system_, bool is_automatic_correction_enabled,
+                                      Clock::SteadyClockTimePoint steady_clock_time_point) {
+        if (standard_user_system_clock_core.SetAutomaticCorrectionEnabled(
+                system_, is_automatic_correction_enabled) != ResultSuccess) {
+            ASSERT(false);
+            return;
+        }
+
+        standard_user_system_clock_core.SetAutomaticCorrectionUpdatedTime(steady_clock_time_point);
+        standard_user_system_clock_core.MarkAsInitialized();
+        shared_memory.SetAutomaticCorrectionEnabled(is_automatic_correction_enabled);
+    }
+
+    void SetupEphemeralNetworkSystemClock() {
+        ephemeral_network_system_clock_core.SetUpdateCallbackInstance(
+            ephemeral_network_system_clock_context_writer);
+        ephemeral_network_system_clock_core.MarkAsInitialized();
+    }
+
+    void UpdateLocalSystemClockTime(Core::System& system_, s64 posix_time) {
+        const auto timespan{Clock::TimeSpanType::FromSeconds(posix_time)};
+        if (GetStandardLocalSystemClockCore()
+                .SetCurrentTime(system_, timespan.ToSeconds())
+                .IsError()) {
+            ASSERT(false);
+            return;
+        }
+    }
+
+    SharedMemory shared_memory;
+
+    Clock::StandardSteadyClockCore standard_steady_clock_core;
+    Clock::TickBasedSteadyClockCore tick_based_steady_clock_core;
+    Clock::StandardLocalSystemClockCore standard_local_system_clock_core;
+    Clock::StandardNetworkSystemClockCore standard_network_system_clock_core;
+    Clock::StandardUserSystemClockCore standard_user_system_clock_core;
+    Clock::EphemeralNetworkSystemClockCore ephemeral_network_system_clock_core;
+
+    std::shared_ptr<Clock::LocalSystemClockContextWriter> local_system_clock_context_writer;
+    std::shared_ptr<Clock::NetworkSystemClockContextWriter> network_system_clock_context_writer;
+    std::shared_ptr<Clock::EphemeralNetworkSystemClockContextWriter>
+        ephemeral_network_system_clock_context_writer;
+
+    TimeZone::TimeZoneContentManager time_zone_content_manager;
+};
+
+TimeManager::TimeManager(Core::System& system_) : system{system_} {}
+
+TimeManager::~TimeManager() = default;
+
+void TimeManager::Initialize() {
+    impl = std::make_unique<Impl>(system);
+
+    // Time zones can only be initialized after impl is valid
+    impl->time_zone_content_manager.Initialize(*this);
+}
+
+Clock::StandardSteadyClockCore& TimeManager::GetStandardSteadyClockCore() {
+    return impl->standard_steady_clock_core;
+}
+
+const Clock::StandardSteadyClockCore& TimeManager::GetStandardSteadyClockCore() const {
+    return impl->standard_steady_clock_core;
+}
+
+Clock::StandardLocalSystemClockCore& TimeManager::GetStandardLocalSystemClockCore() {
+    return impl->standard_local_system_clock_core;
+}
+
+const Clock::StandardLocalSystemClockCore& TimeManager::GetStandardLocalSystemClockCore() const {
+    return impl->standard_local_system_clock_core;
+}
+
+Clock::StandardNetworkSystemClockCore& TimeManager::GetStandardNetworkSystemClockCore() {
+    return impl->standard_network_system_clock_core;
+}
+
+const Clock::StandardNetworkSystemClockCore& TimeManager::GetStandardNetworkSystemClockCore()
+    const {
+    return impl->standard_network_system_clock_core;
+}
+
+Clock::StandardUserSystemClockCore& TimeManager::GetStandardUserSystemClockCore() {
+    return impl->standard_user_system_clock_core;
+}
+
+const Clock::StandardUserSystemClockCore& TimeManager::GetStandardUserSystemClockCore() const {
+    return impl->standard_user_system_clock_core;
+}
+
+TimeZone::TimeZoneContentManager& TimeManager::GetTimeZoneContentManager() {
+    return impl->time_zone_content_manager;
+}
+
+const TimeZone::TimeZoneContentManager& TimeManager::GetTimeZoneContentManager() const {
+    return impl->time_zone_content_manager;
+}
+
+SharedMemory& TimeManager::GetSharedMemory() {
+    return impl->shared_memory;
+}
+
+const SharedMemory& TimeManager::GetSharedMemory() const {
+    return impl->shared_memory;
+}
+
+void TimeManager::Shutdown() {
+    impl.reset();
+}
+
+void TimeManager::UpdateLocalSystemClockTime(s64 posix_time) {
+    impl->UpdateLocalSystemClockTime(system, posix_time);
+}
+
+void TimeManager::SetupTimeZoneManager(std::string location_name,
+                                       Clock::SteadyClockTimePoint time_zone_updated_time_point,
+                                       std::size_t total_location_name_count,
+                                       u128 time_zone_rule_version,
+                                       FileSys::VirtualFile& vfs_file) {
+    impl->SetupTimeZoneManager(location_name, time_zone_updated_time_point,
+                               total_location_name_count, time_zone_rule_version, vfs_file);
+}
+
+/*static*/ s64 TimeManager::GetExternalTimeZoneOffset() {
+    // With "auto" timezone setting, we use the external system's timezone offset
+    if (Settings::GetTimeZoneString() == "auto") {
+        return Common::TimeZone::GetCurrentOffsetSeconds().count();
+    }
+    return 0;
+}
+
+} // namespace Service::Time

src/core/hle/service/time/time_manager.h

@@ -1,76 +1,76 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/standard_local_system_clock_core.h"
-#include "core/hle/service/time/standard_network_system_clock_core.h"
-#include "core/hle/service/time/standard_steady_clock_core.h"
-#include "core/hle/service/time/standard_user_system_clock_core.h"
-#include "core/hle/service/time/time_sharedmemory.h"
-#include "core/hle/service/time/time_zone_content_manager.h"
-
-namespace Service::Time {
-
-namespace Clock {
-class EphemeralNetworkSystemClockContextWriter;
-class LocalSystemClockContextWriter;
-class NetworkSystemClockContextWriter;
-} // namespace Clock
-
-// Parts of this implementation were based on Ryujinx (https://github.com/Ryujinx/Ryujinx/pull/783).
-// This code was released under public domain.
-
-class TimeManager final {
-public:
-    explicit TimeManager(Core::System& system_);
-    ~TimeManager();
-
-    void Initialize();
-
-    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore();
-
-    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const;
-
-    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore();
-
-    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const;
-
-    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore();
-
-    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const;
-
-    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore();
-
-    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const;
-
-    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager();
-
-    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const;
-
-    void UpdateLocalSystemClockTime(s64 posix_time);
-
-    SharedMemory& GetSharedMemory();
-
-    const SharedMemory& GetSharedMemory() const;
-
-    void Shutdown();
-
-    void SetupTimeZoneManager(std::string location_name,
-                              Clock::SteadyClockTimePoint time_zone_updated_time_point,
-                              std::size_t total_location_name_count, u128 time_zone_rule_version,
-                              FileSys::VirtualFile& vfs_file);
-
-    static s64 GetExternalTimeZoneOffset();
-
-private:
-    Core::System& system;
-
-    struct Impl;
-    std::unique_ptr<Impl> impl;
-};
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include "core/file_sys/vfs_types.h"
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/standard_local_system_clock_core.h"
+#include "core/hle/service/time/standard_network_system_clock_core.h"
+#include "core/hle/service/time/standard_steady_clock_core.h"
+#include "core/hle/service/time/standard_user_system_clock_core.h"
+#include "core/hle/service/time/time_sharedmemory.h"
+#include "core/hle/service/time/time_zone_content_manager.h"
+
+namespace Service::Time {
+
+namespace Clock {
+class EphemeralNetworkSystemClockContextWriter;
+class LocalSystemClockContextWriter;
+class NetworkSystemClockContextWriter;
+} // namespace Clock
+
+// Parts of this implementation were based on Ryujinx (https://github.com/Ryujinx/Ryujinx/pull/783).
+// This code was released under public domain.
+
+class TimeManager final {
+public:
+    explicit TimeManager(Core::System& system_);
+    ~TimeManager();
+
+    void Initialize();
+
+    Clock::StandardSteadyClockCore& GetStandardSteadyClockCore();
+
+    const Clock::StandardSteadyClockCore& GetStandardSteadyClockCore() const;
+
+    Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore();
+
+    const Clock::StandardLocalSystemClockCore& GetStandardLocalSystemClockCore() const;
+
+    Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore();
+
+    const Clock::StandardNetworkSystemClockCore& GetStandardNetworkSystemClockCore() const;
+
+    Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore();
+
+    const Clock::StandardUserSystemClockCore& GetStandardUserSystemClockCore() const;
+
+    TimeZone::TimeZoneContentManager& GetTimeZoneContentManager();
+
+    const TimeZone::TimeZoneContentManager& GetTimeZoneContentManager() const;
+
+    void UpdateLocalSystemClockTime(s64 posix_time);
+
+    SharedMemory& GetSharedMemory();
+
+    const SharedMemory& GetSharedMemory() const;
+
+    void Shutdown();
+
+    void SetupTimeZoneManager(std::string location_name,
+                              Clock::SteadyClockTimePoint time_zone_updated_time_point,
+                              std::size_t total_location_name_count, u128 time_zone_rule_version,
+                              FileSys::VirtualFile& vfs_file);
+
+    static s64 GetExternalTimeZoneOffset();
+
+private:
+    Core::System& system;
+
+    struct Impl;
+    std::unique_ptr<Impl> impl;
+};
+
+} // namespace Service::Time

src/core/hle/service/time/time_sharedmemory.cpp

@@ -1,48 +1,48 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "core/core.h"
-#include "core/core_timing.h"
-#include "core/hardware_properties.h"
-#include "core/hle/kernel/kernel.h"
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/steady_clock_core.h"
-#include "core/hle/service/time/time_sharedmemory.h"
-
-namespace Service::Time {
-
-static constexpr std::size_t SHARED_MEMORY_SIZE{0x1000};
-
-SharedMemory::SharedMemory(Core::System& system_) : system(system_) {
-    std::memset(system.Kernel().GetTimeSharedMem().GetPointer(), 0, SHARED_MEMORY_SIZE);
-}
-
-SharedMemory::~SharedMemory() = default;
-
-void SharedMemory::SetupStandardSteadyClock(const Common::UUID& clock_source_id,
-                                            Clock::TimeSpanType current_time_point) {
-    const Clock::TimeSpanType ticks_time_span{Clock::TimeSpanType::FromTicks(
-        system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
-    const Clock::SteadyClockContext context{
-        static_cast<u64>(current_time_point.nanoseconds - ticks_time_span.nanoseconds),
-        clock_source_id};
-    shared_memory_format.standard_steady_clock_timepoint.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
-}
-
-void SharedMemory::UpdateLocalSystemClockContext(const Clock::SystemClockContext& context) {
-    shared_memory_format.standard_local_system_clock_context.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
-}
-
-void SharedMemory::UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context) {
-    shared_memory_format.standard_network_system_clock_context.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), context);
-}
-
-void SharedMemory::SetAutomaticCorrectionEnabled(bool is_enabled) {
-    shared_memory_format.standard_user_system_clock_automatic_correction.StoreData(
-        system.Kernel().GetTimeSharedMem().GetPointer(), is_enabled);
-}
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hardware_properties.h"
+#include "core/hle/kernel/kernel.h"
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/steady_clock_core.h"
+#include "core/hle/service/time/time_sharedmemory.h"
+
+namespace Service::Time {
+
+static constexpr std::size_t SHARED_MEMORY_SIZE{0x1000};
+
+SharedMemory::SharedMemory(Core::System& system_) : system(system_) {
+    std::memset(system.Kernel().GetTimeSharedMem().GetPointer(), 0, SHARED_MEMORY_SIZE);
+}
+
+SharedMemory::~SharedMemory() = default;
+
+void SharedMemory::SetupStandardSteadyClock(const Common::UUID& clock_source_id,
+                                            Clock::TimeSpanType current_time_point) {
+    const Clock::TimeSpanType ticks_time_span{Clock::TimeSpanType::FromTicks(
+        system.CoreTiming().GetClockTicks(), Core::Hardware::CNTFREQ)};
+    const Clock::SteadyClockContext context{
+        static_cast<u64>(current_time_point.nanoseconds - ticks_time_span.nanoseconds),
+        clock_source_id};
+    shared_memory_format.standard_steady_clock_timepoint.StoreData(
+        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+}
+
+void SharedMemory::UpdateLocalSystemClockContext(const Clock::SystemClockContext& context) {
+    shared_memory_format.standard_local_system_clock_context.StoreData(
+        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+}
+
+void SharedMemory::UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context) {
+    shared_memory_format.standard_network_system_clock_context.StoreData(
+        system.Kernel().GetTimeSharedMem().GetPointer(), context);
+}
+
+void SharedMemory::SetAutomaticCorrectionEnabled(bool is_enabled) {
+    shared_memory_format.standard_user_system_clock_automatic_correction.StoreData(
+        system.Kernel().GetTimeSharedMem().GetPointer(), is_enabled);
+}
+
+} // namespace Service::Time

src/core/hle/service/time/time_sharedmemory.h

@@ -1,65 +1,65 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "common/common_types.h"
-#include "common/uuid.h"
-#include "core/hle/kernel/k_shared_memory.h"
-#include "core/hle/service/time/clock_types.h"
-
-namespace Service::Time {
-
-class SharedMemory final {
-public:
-    explicit SharedMemory(Core::System& system_);
-    ~SharedMemory();
-
-    // TODO(ogniK): We have to properly simulate memory barriers, how are we going to do this?
-    template <typename T, std::size_t Offset>
-    struct MemoryBarrier {
-        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
-        u32_le read_attempt{};
-        std::array<T, 2> data{};
-
-        // These are not actually memory barriers at the moment as we don't have multicore and all
-        // HLE is mutexed. This will need to properly be implemented when we start updating the time
-        // points on threads. As of right now, we'll be updated both values synchronously and just
-        // incrementing the read_attempt to indicate that we waited.
-        void StoreData(u8* shared_memory, T data_to_store) {
-            std::memcpy(this, shared_memory + Offset, sizeof(*this));
-            read_attempt++;
-            data[read_attempt & 1] = data_to_store;
-            std::memcpy(shared_memory + Offset, this, sizeof(*this));
-        }
-
-        // For reading we're just going to read the last stored value. If there was no value stored
-        // it will just end up reading an empty value as intended.
-        T ReadData(u8* shared_memory) {
-            std::memcpy(this, shared_memory + Offset, sizeof(*this));
-            return data[(read_attempt - 1) & 1];
-        }
-    };
-
-    // Shared memory format
-    struct Format {
-        MemoryBarrier<Clock::SteadyClockContext, 0x0> standard_steady_clock_timepoint;
-        MemoryBarrier<Clock::SystemClockContext, 0x38> standard_local_system_clock_context;
-        MemoryBarrier<Clock::SystemClockContext, 0x80> standard_network_system_clock_context;
-        MemoryBarrier<bool, 0xc8> standard_user_system_clock_automatic_correction;
-        u32_le format_version;
-    };
-    static_assert(sizeof(Format) == 0xd8, "Format is an invalid size");
-
-    void SetupStandardSteadyClock(const Common::UUID& clock_source_id,
-                                  Clock::TimeSpanType current_time_point);
-    void UpdateLocalSystemClockContext(const Clock::SystemClockContext& context);
-    void UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context);
-    void SetAutomaticCorrectionEnabled(bool is_enabled);
-
-private:
-    Core::System& system;
-    Format shared_memory_format{};
-};
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+#include "common/uuid.h"
+#include "core/hle/kernel/k_shared_memory.h"
+#include "core/hle/service/time/clock_types.h"
+
+namespace Service::Time {
+
+class SharedMemory final {
+public:
+    explicit SharedMemory(Core::System& system_);
+    ~SharedMemory();
+
+    // TODO(ogniK): We have to properly simulate memory barriers, how are we going to do this?
+    template <typename T, std::size_t Offset>
+    struct MemoryBarrier {
+        static_assert(std::is_trivially_copyable_v<T>, "T must be trivially copyable");
+        u32_le read_attempt{};
+        std::array<T, 2> data{};
+
+        // These are not actually memory barriers at the moment as we don't have multicore and all
+        // HLE is mutexed. This will need to properly be implemented when we start updating the time
+        // points on threads. As of right now, we'll be updated both values synchronously and just
+        // incrementing the read_attempt to indicate that we waited.
+        void StoreData(u8* shared_memory, T data_to_store) {
+            std::memcpy(this, shared_memory + Offset, sizeof(*this));
+            read_attempt++;
+            data[read_attempt & 1] = data_to_store;
+            std::memcpy(shared_memory + Offset, this, sizeof(*this));
+        }
+
+        // For reading we're just going to read the last stored value. If there was no value stored
+        // it will just end up reading an empty value as intended.
+        T ReadData(u8* shared_memory) {
+            std::memcpy(this, shared_memory + Offset, sizeof(*this));
+            return data[(read_attempt - 1) & 1];
+        }
+    };
+
+    // Shared memory format
+    struct Format {
+        MemoryBarrier<Clock::SteadyClockContext, 0x0> standard_steady_clock_timepoint;
+        MemoryBarrier<Clock::SystemClockContext, 0x38> standard_local_system_clock_context;
+        MemoryBarrier<Clock::SystemClockContext, 0x80> standard_network_system_clock_context;
+        MemoryBarrier<bool, 0xc8> standard_user_system_clock_automatic_correction;
+        u32_le format_version;
+    };
+    static_assert(sizeof(Format) == 0xd8, "Format is an invalid size");
+
+    void SetupStandardSteadyClock(const Common::UUID& clock_source_id,
+                                  Clock::TimeSpanType current_time_point);
+    void UpdateLocalSystemClockContext(const Clock::SystemClockContext& context);
+    void UpdateNetworkSystemClockContext(const Clock::SystemClockContext& context);
+    void SetAutomaticCorrectionEnabled(bool is_enabled);
+
+private:
+    Core::System& system;
+    Format shared_memory_format{};
+};
+
+} // namespace Service::Time

src/core/hle/service/time/time_zone_content_manager.cpp

@@ -1,143 +1,143 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include <sstream>
-
-#include "common/logging/log.h"
-#include "common/settings.h"
-#include "common/time_zone.h"
-#include "core/core.h"
-#include "core/file_sys/content_archive.h"
-#include "core/file_sys/nca_metadata.h"
-#include "core/file_sys/registered_cache.h"
-#include "core/file_sys/romfs.h"
-#include "core/file_sys/system_archive/system_archive.h"
-#include "core/hle/service/filesystem/filesystem.h"
-#include "core/hle/service/time/time_manager.h"
-#include "core/hle/service/time/time_zone_content_manager.h"
-
-namespace Service::Time::TimeZone {
-
-constexpr u64 time_zone_binary_titleid{0x010000000000080E};
-
-static FileSys::VirtualDir GetTimeZoneBinary(Core::System& system) {
-    const auto* nand{system.GetFileSystemController().GetSystemNANDContents()};
-    const auto nca{nand->GetEntry(time_zone_binary_titleid, FileSys::ContentRecordType::Data)};
-
-    FileSys::VirtualFile romfs;
-    if (nca) {
-        romfs = nca->GetRomFS();
-    }
-
-    if (!romfs) {
-        romfs = FileSys::SystemArchive::SynthesizeSystemArchive(time_zone_binary_titleid);
-    }
-
-    if (!romfs) {
-        LOG_ERROR(Service_Time, "Failed to find or synthesize {:016X!}", time_zone_binary_titleid);
-        return {};
-    }
-
-    return FileSys::ExtractRomFS(romfs);
-}
-
-static std::vector<std::string> BuildLocationNameCache(Core::System& system) {
-    const FileSys::VirtualDir extracted_romfs{GetTimeZoneBinary(system)};
-    if (!extracted_romfs) {
-        LOG_ERROR(Service_Time, "Failed to extract RomFS for {:016X}!", time_zone_binary_titleid);
-        return {};
-    }
-
-    const FileSys::VirtualFile binary_list{extracted_romfs->GetFile("binaryList.txt")};
-    if (!binary_list) {
-        LOG_ERROR(Service_Time, "{:016X} has no file binaryList.txt!", time_zone_binary_titleid);
-        return {};
-    }
-
-    std::vector<char> raw_data(binary_list->GetSize() + 1);
-    binary_list->ReadBytes<char>(raw_data.data(), binary_list->GetSize());
-
-    std::stringstream data_stream{raw_data.data()};
-    std::string name;
-    std::vector<std::string> location_name_cache;
-    while (std::getline(data_stream, name)) {
-        name.pop_back(); // Remove carriage return
-        location_name_cache.emplace_back(std::move(name));
-    }
-    return location_name_cache;
-}
-
-TimeZoneContentManager::TimeZoneContentManager(Core::System& system_)
-    : system{system_}, location_name_cache{BuildLocationNameCache(system)} {}
-
-void TimeZoneContentManager::Initialize(TimeManager& time_manager) {
-    std::string location_name;
-    const auto timezone_setting = Settings::GetTimeZoneString();
-    if (timezone_setting == "auto" || timezone_setting == "default") {
-        location_name = Common::TimeZone::GetDefaultTimeZone();
-    } else {
-        location_name = timezone_setting;
-    }
-
-    if (FileSys::VirtualFile vfs_file;
-        GetTimeZoneInfoFile(location_name, vfs_file) == ResultSuccess) {
-        const auto time_point{
-            time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system)};
-        time_manager.SetupTimeZoneManager(location_name, time_point, location_name_cache.size(), {},
-                                          vfs_file);
-    } else {
-        time_zone_manager.MarkAsInitialized();
-    }
-}
-
-Result TimeZoneContentManager::LoadTimeZoneRule(TimeZoneRule& rules,
-                                                const std::string& location_name) const {
-    FileSys::VirtualFile vfs_file;
-    if (const Result result{GetTimeZoneInfoFile(location_name, vfs_file)};
-        result != ResultSuccess) {
-        return result;
-    }
-
-    return time_zone_manager.ParseTimeZoneRuleBinary(rules, vfs_file);
-}
-
-bool TimeZoneContentManager::IsLocationNameValid(const std::string& location_name) const {
-    return std::find(location_name_cache.begin(), location_name_cache.end(), location_name) !=
-           location_name_cache.end();
-}
-
-Result TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& location_name,
-                                                   FileSys::VirtualFile& vfs_file) const {
-    if (!IsLocationNameValid(location_name)) {
-        return ERROR_TIME_NOT_FOUND;
-    }
-
-    const FileSys::VirtualDir extracted_romfs{GetTimeZoneBinary(system)};
-    if (!extracted_romfs) {
-        LOG_ERROR(Service_Time, "Failed to extract RomFS for {:016X}!", time_zone_binary_titleid);
-        return ERROR_TIME_NOT_FOUND;
-    }
-
-    const FileSys::VirtualDir zoneinfo_dir{extracted_romfs->GetSubdirectory("zoneinfo")};
-    if (!zoneinfo_dir) {
-        LOG_ERROR(Service_Time, "{:016X} has no directory zoneinfo!", time_zone_binary_titleid);
-        return ERROR_TIME_NOT_FOUND;
-    }
-
-    vfs_file = zoneinfo_dir->GetFileRelative(location_name);
-    if (!vfs_file) {
-        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"! Using default timezone.",
-                  time_zone_binary_titleid, location_name);
-        vfs_file = zoneinfo_dir->GetFile(Common::TimeZone::GetDefaultTimeZone());
-    }
-
-    if (!vfs_file) {
-        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"!", time_zone_binary_titleid,
-                  location_name);
-        return ERROR_TIME_NOT_FOUND;
-    }
-
-    return ResultSuccess;
-}
-
-} // namespace Service::Time::TimeZone
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <sstream>
+
+#include "common/logging/log.h"
+#include "common/settings.h"
+#include "common/time_zone.h"
+#include "core/core.h"
+#include "core/file_sys/content_archive.h"
+#include "core/file_sys/nca_metadata.h"
+#include "core/file_sys/registered_cache.h"
+#include "core/file_sys/romfs.h"
+#include "core/file_sys/system_archive/system_archive.h"
+#include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/time/time_manager.h"
+#include "core/hle/service/time/time_zone_content_manager.h"
+
+namespace Service::Time::TimeZone {
+
+constexpr u64 time_zone_binary_titleid{0x010000000000080E};
+
+static FileSys::VirtualDir GetTimeZoneBinary(Core::System& system) {
+    const auto* nand{system.GetFileSystemController().GetSystemNANDContents()};
+    const auto nca{nand->GetEntry(time_zone_binary_titleid, FileSys::ContentRecordType::Data)};
+
+    FileSys::VirtualFile romfs;
+    if (nca) {
+        romfs = nca->GetRomFS();
+    }
+
+    if (!romfs) {
+        romfs = FileSys::SystemArchive::SynthesizeSystemArchive(time_zone_binary_titleid);
+    }
+
+    if (!romfs) {
+        LOG_ERROR(Service_Time, "Failed to find or synthesize {:016X!}", time_zone_binary_titleid);
+        return {};
+    }
+
+    return FileSys::ExtractRomFS(romfs);
+}
+
+static std::vector<std::string> BuildLocationNameCache(Core::System& system) {
+    const FileSys::VirtualDir extracted_romfs{GetTimeZoneBinary(system)};
+    if (!extracted_romfs) {
+        LOG_ERROR(Service_Time, "Failed to extract RomFS for {:016X}!", time_zone_binary_titleid);
+        return {};
+    }
+
+    const FileSys::VirtualFile binary_list{extracted_romfs->GetFile("binaryList.txt")};
+    if (!binary_list) {
+        LOG_ERROR(Service_Time, "{:016X} has no file binaryList.txt!", time_zone_binary_titleid);
+        return {};
+    }
+
+    std::vector<char> raw_data(binary_list->GetSize() + 1);
+    binary_list->ReadBytes<char>(raw_data.data(), binary_list->GetSize());
+
+    std::stringstream data_stream{raw_data.data()};
+    std::string name;
+    std::vector<std::string> location_name_cache;
+    while (std::getline(data_stream, name)) {
+        name.pop_back(); // Remove carriage return
+        location_name_cache.emplace_back(std::move(name));
+    }
+    return location_name_cache;
+}
+
+TimeZoneContentManager::TimeZoneContentManager(Core::System& system_)
+    : system{system_}, location_name_cache{BuildLocationNameCache(system)} {}
+
+void TimeZoneContentManager::Initialize(TimeManager& time_manager) {
+    std::string location_name;
+    const auto timezone_setting = Settings::GetTimeZoneString();
+    if (timezone_setting == "auto" || timezone_setting == "default") {
+        location_name = Common::TimeZone::GetDefaultTimeZone();
+    } else {
+        location_name = timezone_setting;
+    }
+
+    if (FileSys::VirtualFile vfs_file;
+        GetTimeZoneInfoFile(location_name, vfs_file) == ResultSuccess) {
+        const auto time_point{
+            time_manager.GetStandardSteadyClockCore().GetCurrentTimePoint(system)};
+        time_manager.SetupTimeZoneManager(location_name, time_point, location_name_cache.size(), {},
+                                          vfs_file);
+    } else {
+        time_zone_manager.MarkAsInitialized();
+    }
+}
+
+Result TimeZoneContentManager::LoadTimeZoneRule(TimeZoneRule& rules,
+                                                const std::string& location_name) const {
+    FileSys::VirtualFile vfs_file;
+    if (const Result result{GetTimeZoneInfoFile(location_name, vfs_file)};
+        result != ResultSuccess) {
+        return result;
+    }
+
+    return time_zone_manager.ParseTimeZoneRuleBinary(rules, vfs_file);
+}
+
+bool TimeZoneContentManager::IsLocationNameValid(const std::string& location_name) const {
+    return std::find(location_name_cache.begin(), location_name_cache.end(), location_name) !=
+           location_name_cache.end();
+}
+
+Result TimeZoneContentManager::GetTimeZoneInfoFile(const std::string& location_name,
+                                                   FileSys::VirtualFile& vfs_file) const {
+    if (!IsLocationNameValid(location_name)) {
+        return ERROR_TIME_NOT_FOUND;
+    }
+
+    const FileSys::VirtualDir extracted_romfs{GetTimeZoneBinary(system)};
+    if (!extracted_romfs) {
+        LOG_ERROR(Service_Time, "Failed to extract RomFS for {:016X}!", time_zone_binary_titleid);
+        return ERROR_TIME_NOT_FOUND;
+    }
+
+    const FileSys::VirtualDir zoneinfo_dir{extracted_romfs->GetSubdirectory("zoneinfo")};
+    if (!zoneinfo_dir) {
+        LOG_ERROR(Service_Time, "{:016X} has no directory zoneinfo!", time_zone_binary_titleid);
+        return ERROR_TIME_NOT_FOUND;
+    }
+
+    vfs_file = zoneinfo_dir->GetFileRelative(location_name);
+    if (!vfs_file) {
+        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"! Using default timezone.",
+                  time_zone_binary_titleid, location_name);
+        vfs_file = zoneinfo_dir->GetFile(Common::TimeZone::GetDefaultTimeZone());
+    }
+
+    if (!vfs_file) {
+        LOG_ERROR(Service_Time, "{:016X} has no file \"{}\"!", time_zone_binary_titleid,
+                  location_name);
+        return ERROR_TIME_NOT_FOUND;
+    }
+
+    return ResultSuccess;
+}
+
+} // namespace Service::Time::TimeZone

src/core/hle/service/time/time_zone_content_manager.h

@@ -1,47 +1,47 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "core/hle/service/time/time_zone_manager.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time {
-class TimeManager;
-}
-
-namespace Service::Time::TimeZone {
-
-class TimeZoneContentManager final {
-public:
-    explicit TimeZoneContentManager(Core::System& system_);
-
-    void Initialize(TimeManager& time_manager);
-
-    TimeZoneManager& GetTimeZoneManager() {
-        return time_zone_manager;
-    }
-
-    const TimeZoneManager& GetTimeZoneManager() const {
-        return time_zone_manager;
-    }
-
-    Result LoadTimeZoneRule(TimeZoneRule& rules, const std::string& location_name) const;
-
-private:
-    bool IsLocationNameValid(const std::string& location_name) const;
-    Result GetTimeZoneInfoFile(const std::string& location_name,
-                               FileSys::VirtualFile& vfs_file) const;
-
-    Core::System& system;
-    TimeZoneManager time_zone_manager;
-    const std::vector<std::string> location_name_cache;
-};
-
-} // namespace Service::Time::TimeZone
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "core/hle/service/time/time_zone_manager.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time {
+class TimeManager;
+}
+
+namespace Service::Time::TimeZone {
+
+class TimeZoneContentManager final {
+public:
+    explicit TimeZoneContentManager(Core::System& system_);
+
+    void Initialize(TimeManager& time_manager);
+
+    TimeZoneManager& GetTimeZoneManager() {
+        return time_zone_manager;
+    }
+
+    const TimeZoneManager& GetTimeZoneManager() const {
+        return time_zone_manager;
+    }
+
+    Result LoadTimeZoneRule(TimeZoneRule& rules, const std::string& location_name) const;
+
+private:
+    bool IsLocationNameValid(const std::string& location_name) const;
+    Result GetTimeZoneInfoFile(const std::string& location_name,
+                               FileSys::VirtualFile& vfs_file) const;
+
+    Core::System& system;
+    TimeZoneManager time_zone_manager;
+    const std::vector<std::string> location_name_cache;
+};
+
+} // namespace Service::Time::TimeZone

src/core/hle/service/time/time_zone_manager.h

@@ -1,53 +1,53 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <string>
-
-#include "common/common_types.h"
-#include "core/file_sys/vfs_types.h"
-#include "core/hle/service/time/clock_types.h"
-#include "core/hle/service/time/time_zone_types.h"
-
-namespace Service::Time::TimeZone {
-
-class TimeZoneManager final {
-public:
-    TimeZoneManager();
-    ~TimeZoneManager();
-
-    void SetTotalLocationNameCount(std::size_t value) {
-        total_location_name_count = value;
-    }
-
-    void SetTimeZoneRuleVersion(const u128& value) {
-        time_zone_rule_version = value;
-    }
-
-    void MarkAsInitialized() {
-        is_initialized = true;
-    }
-
-    Result SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
-                                                 FileSys::VirtualFile& vfs_file);
-    Result SetUpdatedTime(const Clock::SteadyClockTimePoint& value);
-    Result GetDeviceLocationName(TimeZone::LocationName& value) const;
-    Result ToCalendarTime(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) const;
-    Result ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const;
-    Result ParseTimeZoneRuleBinary(TimeZoneRule& rules, FileSys::VirtualFile& vfs_file) const;
-    Result ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
-                       s64& posix_time) const;
-    Result ToPosixTimeWithMyRule(const CalendarTime& calendar_time, s64& posix_time) const;
-
-private:
-    bool is_initialized{};
-    TimeZoneRule time_zone_rule{};
-    std::string device_location_name{"GMT"};
-    u128 time_zone_rule_version{};
-    std::size_t total_location_name_count{};
-    Clock::SteadyClockTimePoint time_zone_update_time_point{
-        Clock::SteadyClockTimePoint::GetRandom()};
-};
-
-} // namespace Service::Time::TimeZone
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <string>
+
+#include "common/common_types.h"
+#include "core/file_sys/vfs_types.h"
+#include "core/hle/service/time/clock_types.h"
+#include "core/hle/service/time/time_zone_types.h"
+
+namespace Service::Time::TimeZone {
+
+class TimeZoneManager final {
+public:
+    TimeZoneManager();
+    ~TimeZoneManager();
+
+    void SetTotalLocationNameCount(std::size_t value) {
+        total_location_name_count = value;
+    }
+
+    void SetTimeZoneRuleVersion(const u128& value) {
+        time_zone_rule_version = value;
+    }
+
+    void MarkAsInitialized() {
+        is_initialized = true;
+    }
+
+    Result SetDeviceLocationNameWithTimeZoneRule(const std::string& location_name,
+                                                 FileSys::VirtualFile& vfs_file);
+    Result SetUpdatedTime(const Clock::SteadyClockTimePoint& value);
+    Result GetDeviceLocationName(TimeZone::LocationName& value) const;
+    Result ToCalendarTime(const TimeZoneRule& rules, s64 time, CalendarInfo& calendar) const;
+    Result ToCalendarTimeWithMyRules(s64 time, CalendarInfo& calendar) const;
+    Result ParseTimeZoneRuleBinary(TimeZoneRule& rules, FileSys::VirtualFile& vfs_file) const;
+    Result ToPosixTime(const TimeZoneRule& rules, const CalendarTime& calendar_time,
+                       s64& posix_time) const;
+    Result ToPosixTimeWithMyRule(const CalendarTime& calendar_time, s64& posix_time) const;
+
+private:
+    bool is_initialized{};
+    TimeZoneRule time_zone_rule{};
+    std::string device_location_name{"GMT"};
+    u128 time_zone_rule_version{};
+    std::size_t total_location_name_count{};
+    Clock::SteadyClockTimePoint time_zone_update_time_point{
+        Clock::SteadyClockTimePoint::GetRandom()};
+};
+
+} // namespace Service::Time::TimeZone

src/core/hle/service/time/time_zone_service.cpp

@@ -1,172 +1,172 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#include "common/logging/log.h"
-#include "core/hle/ipc_helpers.h"
-#include "core/hle/service/time/time_zone_content_manager.h"
-#include "core/hle/service/time/time_zone_service.h"
-#include "core/hle/service/time/time_zone_types.h"
-
-namespace Service::Time {
-
-ITimeZoneService::ITimeZoneService(Core::System& system_,
-                                   TimeZone::TimeZoneContentManager& time_zone_manager_)
-    : ServiceFramework{system_, "ITimeZoneService"}, time_zone_content_manager{time_zone_manager_} {
-    static const FunctionInfo functions[] = {
-        {0, &ITimeZoneService::GetDeviceLocationName, "GetDeviceLocationName"},
-        {1, nullptr, "SetDeviceLocationName"},
-        {2, nullptr, "GetTotalLocationNameCount"},
-        {3, nullptr, "LoadLocationNameList"},
-        {4, &ITimeZoneService::LoadTimeZoneRule, "LoadTimeZoneRule"},
-        {5, nullptr, "GetTimeZoneRuleVersion"},
-        {6, nullptr, "GetDeviceLocationNameAndUpdatedTime"},
-        {100, &ITimeZoneService::ToCalendarTime, "ToCalendarTime"},
-        {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
-        {201, &ITimeZoneService::ToPosixTime, "ToPosixTime"},
-        {202, &ITimeZoneService::ToPosixTimeWithMyRule, "ToPosixTimeWithMyRule"},
-    };
-    RegisterHandlers(functions);
-}
-
-void ITimeZoneService::GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-
-    TimeZone::LocationName location_name{};
-    if (const Result result{
-            time_zone_content_manager.GetTimeZoneManager().GetDeviceLocationName(location_name)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    IPC::ResponseBuilder rb{ctx, (sizeof(location_name) / 4) + 2};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(location_name);
-}
-
-void ITimeZoneService::LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto raw_location_name{rp.PopRaw<std::array<u8, 0x24>>()};
-
-    std::string location_name;
-    for (const auto& byte : raw_location_name) {
-        // Strip extra bytes
-        if (byte == '\0') {
-            break;
-        }
-        location_name.push_back(byte);
-    }
-
-    LOG_DEBUG(Service_Time, "called, location_name={}", location_name);
-
-    TimeZone::TimeZoneRule time_zone_rule{};
-    if (const Result result{
-            time_zone_content_manager.LoadTimeZoneRule(time_zone_rule, location_name)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    std::vector<u8> time_zone_rule_outbuffer(sizeof(TimeZone::TimeZoneRule));
-    std::memcpy(time_zone_rule_outbuffer.data(), &time_zone_rule, sizeof(TimeZone::TimeZoneRule));
-    ctx.WriteBuffer(time_zone_rule_outbuffer);
-
-    IPC::ResponseBuilder rb{ctx, 2};
-    rb.Push(ResultSuccess);
-}
-
-void ITimeZoneService::ToCalendarTime(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto posix_time{rp.Pop<s64>()};
-
-    LOG_DEBUG(Service_Time, "called, posix_time=0x{:016X}", posix_time);
-
-    TimeZone::TimeZoneRule time_zone_rule{};
-    const auto buffer{ctx.ReadBuffer()};
-    std::memcpy(&time_zone_rule, buffer.data(), buffer.size());
-
-    TimeZone::CalendarInfo calendar_info{};
-    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToCalendarTime(
-            time_zone_rule, posix_time, calendar_info)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2 + (sizeof(TimeZone::CalendarInfo) / 4)};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(calendar_info);
-}
-
-void ITimeZoneService::ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx) {
-    IPC::RequestParser rp{ctx};
-    const auto posix_time{rp.Pop<s64>()};
-
-    LOG_DEBUG(Service_Time, "called, posix_time=0x{:016X}", posix_time);
-
-    TimeZone::CalendarInfo calendar_info{};
-    if (const Result result{
-            time_zone_content_manager.GetTimeZoneManager().ToCalendarTimeWithMyRules(
-                posix_time, calendar_info)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    IPC::ResponseBuilder rb{ctx, 2 + (sizeof(TimeZone::CalendarInfo) / 4)};
-    rb.Push(ResultSuccess);
-    rb.PushRaw(calendar_info);
-}
-
-void ITimeZoneService::ToPosixTime(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-
-    IPC::RequestParser rp{ctx};
-    const auto calendar_time{rp.PopRaw<TimeZone::CalendarTime>()};
-    TimeZone::TimeZoneRule time_zone_rule{};
-    std::memcpy(&time_zone_rule, ctx.ReadBuffer().data(), sizeof(TimeZone::TimeZoneRule));
-
-    s64 posix_time{};
-    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTime(
-            time_zone_rule, calendar_time, posix_time)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    ctx.WriteBuffer(posix_time);
-
-    // TODO(bunnei): Handle multiple times
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushRaw<u32>(1); // Number of times we're returning
-}
-
-void ITimeZoneService::ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
-    LOG_DEBUG(Service_Time, "called");
-
-    IPC::RequestParser rp{ctx};
-    const auto calendar_time{rp.PopRaw<TimeZone::CalendarTime>()};
-
-    s64 posix_time{};
-    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTimeWithMyRule(
-            calendar_time, posix_time)};
-        result != ResultSuccess) {
-        IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
-        return;
-    }
-
-    ctx.WriteBuffer(posix_time);
-
-    IPC::ResponseBuilder rb{ctx, 3};
-    rb.Push(ResultSuccess);
-    rb.PushRaw<u32>(1); // Number of times we're returning
-}
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "common/logging/log.h"
+#include "core/hle/ipc_helpers.h"
+#include "core/hle/service/time/time_zone_content_manager.h"
+#include "core/hle/service/time/time_zone_service.h"
+#include "core/hle/service/time/time_zone_types.h"
+
+namespace Service::Time {
+
+ITimeZoneService::ITimeZoneService(Core::System& system_,
+                                   TimeZone::TimeZoneContentManager& time_zone_manager_)
+    : ServiceFramework{system_, "ITimeZoneService"}, time_zone_content_manager{time_zone_manager_} {
+    static const FunctionInfo functions[] = {
+        {0, &ITimeZoneService::GetDeviceLocationName, "GetDeviceLocationName"},
+        {1, nullptr, "SetDeviceLocationName"},
+        {2, nullptr, "GetTotalLocationNameCount"},
+        {3, nullptr, "LoadLocationNameList"},
+        {4, &ITimeZoneService::LoadTimeZoneRule, "LoadTimeZoneRule"},
+        {5, nullptr, "GetTimeZoneRuleVersion"},
+        {6, nullptr, "GetDeviceLocationNameAndUpdatedTime"},
+        {100, &ITimeZoneService::ToCalendarTime, "ToCalendarTime"},
+        {101, &ITimeZoneService::ToCalendarTimeWithMyRule, "ToCalendarTimeWithMyRule"},
+        {201, &ITimeZoneService::ToPosixTime, "ToPosixTime"},
+        {202, &ITimeZoneService::ToPosixTimeWithMyRule, "ToPosixTimeWithMyRule"},
+    };
+    RegisterHandlers(functions);
+}
+
+void ITimeZoneService::GetDeviceLocationName(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    TimeZone::LocationName location_name{};
+    if (const Result result{
+            time_zone_content_manager.GetTimeZoneManager().GetDeviceLocationName(location_name)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, (sizeof(location_name) / 4) + 2};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(location_name);
+}
+
+void ITimeZoneService::LoadTimeZoneRule(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto raw_location_name{rp.PopRaw<std::array<u8, 0x24>>()};
+
+    std::string location_name;
+    for (const auto& byte : raw_location_name) {
+        // Strip extra bytes
+        if (byte == '\0') {
+            break;
+        }
+        location_name.push_back(byte);
+    }
+
+    LOG_DEBUG(Service_Time, "called, location_name={}", location_name);
+
+    TimeZone::TimeZoneRule time_zone_rule{};
+    if (const Result result{
+            time_zone_content_manager.LoadTimeZoneRule(time_zone_rule, location_name)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    std::vector<u8> time_zone_rule_outbuffer(sizeof(TimeZone::TimeZoneRule));
+    std::memcpy(time_zone_rule_outbuffer.data(), &time_zone_rule, sizeof(TimeZone::TimeZoneRule));
+    ctx.WriteBuffer(time_zone_rule_outbuffer);
+
+    IPC::ResponseBuilder rb{ctx, 2};
+    rb.Push(ResultSuccess);
+}
+
+void ITimeZoneService::ToCalendarTime(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto posix_time{rp.Pop<s64>()};
+
+    LOG_DEBUG(Service_Time, "called, posix_time=0x{:016X}", posix_time);
+
+    TimeZone::TimeZoneRule time_zone_rule{};
+    const auto buffer{ctx.ReadBuffer()};
+    std::memcpy(&time_zone_rule, buffer.data(), buffer.size());
+
+    TimeZone::CalendarInfo calendar_info{};
+    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToCalendarTime(
+            time_zone_rule, posix_time, calendar_info)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2 + (sizeof(TimeZone::CalendarInfo) / 4)};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(calendar_info);
+}
+
+void ITimeZoneService::ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx) {
+    IPC::RequestParser rp{ctx};
+    const auto posix_time{rp.Pop<s64>()};
+
+    LOG_DEBUG(Service_Time, "called, posix_time=0x{:016X}", posix_time);
+
+    TimeZone::CalendarInfo calendar_info{};
+    if (const Result result{
+            time_zone_content_manager.GetTimeZoneManager().ToCalendarTimeWithMyRules(
+                posix_time, calendar_info)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    IPC::ResponseBuilder rb{ctx, 2 + (sizeof(TimeZone::CalendarInfo) / 4)};
+    rb.Push(ResultSuccess);
+    rb.PushRaw(calendar_info);
+}
+
+void ITimeZoneService::ToPosixTime(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    IPC::RequestParser rp{ctx};
+    const auto calendar_time{rp.PopRaw<TimeZone::CalendarTime>()};
+    TimeZone::TimeZoneRule time_zone_rule{};
+    std::memcpy(&time_zone_rule, ctx.ReadBuffer().data(), sizeof(TimeZone::TimeZoneRule));
+
+    s64 posix_time{};
+    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTime(
+            time_zone_rule, calendar_time, posix_time)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    ctx.WriteBuffer(posix_time);
+
+    // TODO(bunnei): Handle multiple times
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushRaw<u32>(1); // Number of times we're returning
+}
+
+void ITimeZoneService::ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx) {
+    LOG_DEBUG(Service_Time, "called");
+
+    IPC::RequestParser rp{ctx};
+    const auto calendar_time{rp.PopRaw<TimeZone::CalendarTime>()};
+
+    s64 posix_time{};
+    if (const Result result{time_zone_content_manager.GetTimeZoneManager().ToPosixTimeWithMyRule(
+            calendar_time, posix_time)};
+        result != ResultSuccess) {
+        IPC::ResponseBuilder rb{ctx, 2};
+        rb.Push(result);
+        return;
+    }
+
+    ctx.WriteBuffer(posix_time);
+
+    IPC::ResponseBuilder rb{ctx, 3};
+    rb.Push(ResultSuccess);
+    rb.PushRaw<u32>(1); // Number of times we're returning
+}
+
+} // namespace Service::Time

src/core/hle/service/time/time_zone_service.h

@@ -1,35 +1,35 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include "core/hle/service/service.h"
-
-namespace Core {
-class System;
-}
-
-namespace Service::Time {
-
-namespace TimeZone {
-class TimeZoneContentManager;
-}
-
-class ITimeZoneService final : public ServiceFramework<ITimeZoneService> {
-public:
-    explicit ITimeZoneService(Core::System& system_,
-                              TimeZone::TimeZoneContentManager& time_zone_manager_);
-
-private:
-    void GetDeviceLocationName(Kernel::HLERequestContext& ctx);
-    void LoadTimeZoneRule(Kernel::HLERequestContext& ctx);
-    void ToCalendarTime(Kernel::HLERequestContext& ctx);
-    void ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx);
-    void ToPosixTime(Kernel::HLERequestContext& ctx);
-    void ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx);
-
-private:
-    TimeZone::TimeZoneContentManager& time_zone_content_manager;
-};
-
-} // namespace Service::Time
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "core/hle/service/service.h"
+
+namespace Core {
+class System;
+}
+
+namespace Service::Time {
+
+namespace TimeZone {
+class TimeZoneContentManager;
+}
+
+class ITimeZoneService final : public ServiceFramework<ITimeZoneService> {
+public:
+    explicit ITimeZoneService(Core::System& system_,
+                              TimeZone::TimeZoneContentManager& time_zone_manager_);
+
+private:
+    void GetDeviceLocationName(Kernel::HLERequestContext& ctx);
+    void LoadTimeZoneRule(Kernel::HLERequestContext& ctx);
+    void ToCalendarTime(Kernel::HLERequestContext& ctx);
+    void ToCalendarTimeWithMyRule(Kernel::HLERequestContext& ctx);
+    void ToPosixTime(Kernel::HLERequestContext& ctx);
+    void ToPosixTimeWithMyRule(Kernel::HLERequestContext& ctx);
+
+private:
+    TimeZone::TimeZoneContentManager& time_zone_content_manager;
+};
+
+} // namespace Service::Time

src/core/hle/service/time/time_zone_types.h

@@ -1,86 +1,86 @@
-// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
-// SPDX-License-Identifier: GPL-2.0-or-later
-
-#pragma once
-
-#include <array>
-
-#include "common/common_funcs.h"
-#include "common/common_types.h"
-#include "common/swap.h"
-
-namespace Service::Time::TimeZone {
-
-using LocationName = std::array<char, 0x24>;
-
-/// https://switchbrew.org/wiki/Glue_services#ttinfo
-struct TimeTypeInfo {
-    s32 gmt_offset{};
-    u8 is_dst{};
-    INSERT_PADDING_BYTES(3);
-    s32 abbreviation_list_index{};
-    u8 is_standard_time_daylight{};
-    u8 is_gmt{};
-    INSERT_PADDING_BYTES(2);
-};
-static_assert(sizeof(TimeTypeInfo) == 0x10, "TimeTypeInfo is incorrect size");
-
-/// https://switchbrew.org/wiki/Glue_services#TimeZoneRule
-struct TimeZoneRule {
-    s32 time_count{};
-    s32 type_count{};
-    s32 char_count{};
-    u8 go_back{};
-    u8 go_ahead{};
-    INSERT_PADDING_BYTES(2);
-    std::array<s64, 1000> ats{};
-    std::array<s8, 1000> types{};
-    std::array<TimeTypeInfo, 128> ttis{};
-    std::array<char, 512> chars{};
-    s32 default_type{};
-    INSERT_PADDING_BYTES(0x12C4);
-};
-static_assert(sizeof(TimeZoneRule) == 0x4000, "TimeZoneRule is incorrect size");
-
-/// https://switchbrew.org/wiki/Glue_services#CalendarAdditionalInfo
-struct CalendarAdditionalInfo {
-    u32 day_of_week;
-    u32 day_of_year;
-    std::array<char, 8> timezone_name;
-    u32 is_dst;
-    s32 gmt_offset;
-};
-static_assert(sizeof(CalendarAdditionalInfo) == 0x18, "CalendarAdditionalInfo is incorrect size");
-
-/// https://switchbrew.org/wiki/Glue_services#CalendarTime
-struct CalendarTime {
-    s16 year;
-    s8 month;
-    s8 day;
-    s8 hour;
-    s8 minute;
-    s8 second;
-    INSERT_PADDING_BYTES_NOINIT(1);
-};
-static_assert(sizeof(CalendarTime) == 0x8, "CalendarTime is incorrect size");
-
-struct CalendarInfo {
-    CalendarTime time;
-    CalendarAdditionalInfo additional_info;
-};
-static_assert(sizeof(CalendarInfo) == 0x20, "CalendarInfo is incorrect size");
-
-struct TzifHeader {
-    u32_be magic{};
-    u8 version{};
-    INSERT_PADDING_BYTES(15);
-    s32_be ttis_gmt_count{};
-    s32_be ttis_std_count{};
-    s32_be leap_count{};
-    s32_be time_count{};
-    s32_be type_count{};
-    s32_be char_count{};
-};
-static_assert(sizeof(TzifHeader) == 0x2C, "TzifHeader is incorrect size");
-
-} // namespace Service::Time::TimeZone
+// SPDX-FileCopyrightText: Copyright 2019 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+
+#include "common/common_funcs.h"
+#include "common/common_types.h"
+#include "common/swap.h"
+
+namespace Service::Time::TimeZone {
+
+using LocationName = std::array<char, 0x24>;
+
+/// https://switchbrew.org/wiki/Glue_services#ttinfo
+struct TimeTypeInfo {
+    s32 gmt_offset{};
+    u8 is_dst{};
+    INSERT_PADDING_BYTES(3);
+    s32 abbreviation_list_index{};
+    u8 is_standard_time_daylight{};
+    u8 is_gmt{};
+    INSERT_PADDING_BYTES(2);
+};
+static_assert(sizeof(TimeTypeInfo) == 0x10, "TimeTypeInfo is incorrect size");
+
+/// https://switchbrew.org/wiki/Glue_services#TimeZoneRule
+struct TimeZoneRule {
+    s32 time_count{};
+    s32 type_count{};
+    s32 char_count{};
+    u8 go_back{};
+    u8 go_ahead{};
+    INSERT_PADDING_BYTES(2);
+    std::array<s64, 1000> ats{};
+    std::array<s8, 1000> types{};
+    std::array<TimeTypeInfo, 128> ttis{};
+    std::array<char, 512> chars{};
+    s32 default_type{};
+    INSERT_PADDING_BYTES(0x12C4);
+};
+static_assert(sizeof(TimeZoneRule) == 0x4000, "TimeZoneRule is incorrect size");
+
+/// https://switchbrew.org/wiki/Glue_services#CalendarAdditionalInfo
+struct CalendarAdditionalInfo {
+    u32 day_of_week;
+    u32 day_of_year;
+    std::array<char, 8> timezone_name;
+    u32 is_dst;
+    s32 gmt_offset;
+};
+static_assert(sizeof(CalendarAdditionalInfo) == 0x18, "CalendarAdditionalInfo is incorrect size");
+
+/// https://switchbrew.org/wiki/Glue_services#CalendarTime
+struct CalendarTime {
+    s16 year;
+    s8 month;
+    s8 day;
+    s8 hour;
+    s8 minute;
+    s8 second;
+    INSERT_PADDING_BYTES_NOINIT(1);
+};
+static_assert(sizeof(CalendarTime) == 0x8, "CalendarTime is incorrect size");
+
+struct CalendarInfo {
+    CalendarTime time;
+    CalendarAdditionalInfo additional_info;
+};
+static_assert(sizeof(CalendarInfo) == 0x20, "CalendarInfo is incorrect size");
+
+struct TzifHeader {
+    u32_be magic{};
+    u8 version{};
+    INSERT_PADDING_BYTES(15);
+    s32_be ttis_gmt_count{};
+    s32_be ttis_std_count{};
+    s32_be leap_count{};
+    s32_be time_count{};
+    s32_be type_count{};
+    s32_be char_count{};
+};
+static_assert(sizeof(TzifHeader) == 0x2C, "TzifHeader is incorrect size");
+
+} // namespace Service::Time::TimeZone