From 1aba033ba7868d29f5f840c99ee11dd29d689972 Mon Sep 17 00:00:00 2001 From: Thomas Guillemard Date: Tue, 8 Oct 2019 05:48:49 +0200 Subject: Update time implementation to 9.0.0 (#783) * Fix 9.0.0 related services bindings This was wrong because of a mistake on switchbrew. * Fix wronog cmdid for ISteadyClock::GetTestOffset/SetTestOffset * Update ClockCore logics to 9.0.0 Also apply 9.0.0 permissions and comment time:u, and time:a (as those are going to be moved) * Move every clocks instances + timezone to a global manager * Start implementing time:m Also prepare the skeleton of the shared memory * Implement SystemClockContextUpdateCallback and co * Update StaticService to 9.0.0 * Update ISystemClock to 9.0.0 * Rename IStaticService and add glue's IStaticService * Implement psc's ITimeZoneService * Integrate psc layer into glue for TimeZoneService * Rename TimeZoneManagerForPsc => TimeZoneManager * Use correct TimeZoneService interface for both StaticService implementations * Accurately implement time shared memory operations * Fix two critical flaws in TimeZone logic The first one was the month range being different fron Nintendo one (0-11 instead of 1-12) The other flaw was a bad incrementation order during days & months computation. * Follow Nintendo's abort logic for TimeManager * Avoid crashing when timezone sysarchive isn't present * Update Readme * Address comments * Correctly align fields in ISystemClock * Fix code style and some typos * Improve timezone system archive warning/error messages * Rearrange using definitions in Horizon.cs * Address comments --- Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs | 126 ++++++++++++++++++++++ 1 file changed, 126 insertions(+) create mode 100644 Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs (limited to 'Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs') diff --git a/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs b/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs new file mode 100644 index 00000000..f714c662 --- /dev/null +++ b/Ryujinx.HLE/HOS/Services/Time/TimeSharedMemory.cs @@ -0,0 +1,126 @@ +using System; +using System.Runtime.InteropServices; +using System.Threading; +using Ryujinx.HLE.HOS.Kernel.Memory; +using Ryujinx.HLE.HOS.Kernel.Threading; +using Ryujinx.HLE.HOS.Services.Time.Clock; +using Ryujinx.HLE.HOS.Services.Time.Types; +using Ryujinx.HLE.Utilities; + +namespace Ryujinx.HLE.HOS.Services.Time +{ + class TimeSharedMemory + { + private Switch _device; + private KSharedMemory _sharedMemory; + private long _timeSharedMemoryAddress; + private int _timeSharedMemorySize; + + private const uint SteadyClockContextOffset = 0x00; + private const uint LocalSystemClockContextOffset = 0x38; + private const uint NetworkSystemClockContextOffset = 0x80; + private const uint AutomaticCorrectionEnabledOffset = 0xC8; + + public void Initialize(Switch device, KSharedMemory sharedMemory, long timeSharedMemoryAddress, int timeSharedMemorySize) + { + _device = device; + _sharedMemory = sharedMemory; + _timeSharedMemoryAddress = timeSharedMemoryAddress; + _timeSharedMemorySize = timeSharedMemorySize; + + // Clean the shared memory + _device.Memory.FillWithZeros(_timeSharedMemoryAddress, _timeSharedMemorySize); + } + + public KSharedMemory GetSharedMemory() + { + return _sharedMemory; + } + + public void SetupStandardSteadyClock(KThread thread, UInt128 clockSourceId, TimeSpanType currentTimePoint) + { + TimeSpanType ticksTimeSpan; + + // As this may be called before the guest code, we support passing a null thread to make this api usable. + if (thread == null) + { + ticksTimeSpan = TimeSpanType.FromSeconds(0); + } + else + { + ticksTimeSpan = TimeSpanType.FromTicks(thread.Context.CntpctEl0, thread.Context.CntfrqEl0); + } + + SteadyClockContext context = new SteadyClockContext + { + InternalOffset = (ulong)(currentTimePoint.NanoSeconds - ticksTimeSpan.NanoSeconds), + ClockSourceId = clockSourceId + }; + + WriteObjectToSharedMemory(SteadyClockContextOffset, 4, context); + } + + public void SetAutomaticCorrectionEnabled(bool isAutomaticCorrectionEnabled) + { + // We convert the bool to byte here as a bool in C# takes 4 bytes... + WriteObjectToSharedMemory(AutomaticCorrectionEnabledOffset, 0, Convert.ToByte(isAutomaticCorrectionEnabled)); + } + + public void SetSteadyClockRawTimePoint(KThread thread, TimeSpanType currentTimePoint) + { + SteadyClockContext context = ReadObjectFromSharedMemory(SteadyClockContextOffset, 4); + TimeSpanType ticksTimeSpan = TimeSpanType.FromTicks(thread.Context.CntpctEl0, thread.Context.CntfrqEl0); + + context.InternalOffset = (ulong)(currentTimePoint.NanoSeconds - ticksTimeSpan.NanoSeconds); + + WriteObjectToSharedMemory(SteadyClockContextOffset, 4, context); + } + + public void UpdateLocalSystemClockContext(SystemClockContext context) + { + WriteObjectToSharedMemory(LocalSystemClockContextOffset, 4, context); + } + + public void UpdateNetworkSystemClockContext(SystemClockContext context) + { + WriteObjectToSharedMemory(NetworkSystemClockContextOffset, 4, context); + } + + private T ReadObjectFromSharedMemory(long offset, long padding) + { + long indexOffset = _timeSharedMemoryAddress + offset; + + T result; + uint index; + uint possiblyNewIndex; + + do + { + index = _device.Memory.ReadUInt32(indexOffset); + + long objectOffset = indexOffset + 4 + padding + (index & 1) * Marshal.SizeOf(); + + result = _device.Memory.ReadStruct(objectOffset); + + Thread.MemoryBarrier(); + + possiblyNewIndex = _device.Memory.ReadUInt32(indexOffset); + } while (index != possiblyNewIndex); + + return result; + } + + private void WriteObjectToSharedMemory(long offset, long padding, T value) + { + long indexOffset = _timeSharedMemoryAddress + offset; + uint newIndex = _device.Memory.ReadUInt32(indexOffset) + 1; + long objectOffset = indexOffset + 4 + padding + (newIndex & 1) * Marshal.SizeOf(); + + _device.Memory.WriteStruct(objectOffset, value); + + Thread.MemoryBarrier(); + + _device.Memory.WriteUInt32(indexOffset, newIndex); + } + } +} -- cgit v1.2.3