InstEmitMemoryEx: Barrier after write on ordered store (#3193)

* InstEmitMemoryEx: Barrier after write on ordered store

* increment ptc version

* 32

ARMeilleure/Instructions/InstEmitMemoryEx.cs

@@ -130,11 +130,6 @@ namespace ARMeilleure.Instructions
             bool ordered   = (accType & AccessType.Ordered)   != 0;
             bool exclusive = (accType & AccessType.Exclusive) != 0;
 
-            if (ordered)
-            {
-                EmitBarrier(context);
-            }
-
             Operand address = context.Copy(GetIntOrSP(context, op.Rn));
 
             Operand t = GetIntOrZR(context, op.Rt);
@@ -163,6 +158,11 @@ namespace ARMeilleure.Instructions
             {
                 EmitStoreExclusive(context, address, t, exclusive, op.Size, op.Rs, a32: false);
             }
+
+            if (ordered)
+            {
+                EmitBarrier(context);
+            }
         }
 
         private static void EmitBarrier(ArmEmitterContext context)

ARMeilleure/Instructions/InstEmitMemoryEx32.cs

@@ -146,13 +146,13 @@ namespace ARMeilleure.Instructions
             var exclusive = (accType & AccessType.Exclusive) != 0;
             var ordered = (accType & AccessType.Ordered) != 0;
 
-            if (ordered)
-            {
-                EmitBarrier(context);
-            }
-
             if ((accType & AccessType.Load) != 0)
             {
+                if (ordered)
+                {
+                    EmitBarrier(context);
+                }
+
                 if (size == DWordSizeLog2)
                 {
                     // Keep loads atomic - make the call to get the whole region and then decompose it into parts
@@ -219,6 +219,11 @@ namespace ARMeilleure.Instructions
                     Operand value = context.ZeroExtend32(OperandType.I64, GetIntA32(context, op.Rt));
                     EmitStoreExclusive(context, address, value, exclusive, size, op.Rd, a32: true);
                 }
+
+                if (ordered)
+                {
+                    EmitBarrier(context);
+                }
             }
         }
 

ARMeilleure/Translation/PTC/Ptc.cs

@@ -27,7 +27,7 @@ namespace ARMeilleure.Translation.PTC
         private const string OuterHeaderMagicString = "PTCohd\0\0";
         private const string InnerHeaderMagicString = "PTCihd\0\0";
 
-        private const uint InternalVersion = 3179; //! To be incremented manually for each change to the ARMeilleure project.
+        private const uint InternalVersion = 3193; //! To be incremented manually for each change to the ARMeilleure project.
 
         private const string ActualDir = "0";
         private const string BackupDir = "1";

Ryujinx.Common/Logging/LogClass.cs

@@ -47,6 +47,7 @@ namespace Ryujinx.Common.Logging
         ServiceNim,
         ServiceNs,
         ServiceNsd,
+        ServiceNtc,
         ServiceNv,
         ServiceOlsc,
         ServicePctl,

Ryujinx.HLE/HOS/Services/Nifm/StaticService/IGeneralService.cs

@@ -14,6 +14,9 @@ namespace Ryujinx.HLE.HOS.Services.Nifm.StaticService
     {
         private GeneralServiceDetail _generalServiceDetail;
 
+        private IPInterfaceProperties _targetPropertiesCache = null;
+        private UnicastIPAddressInformation _targetAddressInfoCache = null;
+
         public IGeneralService()
         {
             _generalServiceDetail = new GeneralServiceDetail
@@ -22,6 +25,8 @@ namespace Ryujinx.HLE.HOS.Services.Nifm.StaticService
                 IsAnyInternetRequestAccepted = true // NOTE: Why not accept any internet request?
             };
 
+            NetworkChange.NetworkAddressChanged += new NetworkAddressChangedEventHandler(LocalInterfaceCacheHandler);
+
             GeneralServiceManager.Add(_generalServiceDetail);
         }
 
@@ -165,6 +170,11 @@ namespace Ryujinx.HLE.HOS.Services.Nifm.StaticService
                 return (null, null);
             }
 
+            if (_targetPropertiesCache != null && _targetAddressInfoCache != null)
+            {
+                return (_targetPropertiesCache, _targetAddressInfoCache);
+            }
+
             IPInterfaceProperties       targetProperties  = null;
             UnicastIPAddressInformation targetAddressInfo = null;
 
@@ -194,13 +204,26 @@ namespace Ryujinx.HLE.HOS.Services.Nifm.StaticService
                 }
             }
 
+            _targetPropertiesCache  = targetProperties;
+            _targetAddressInfoCache = targetAddressInfo;
+
             return (targetProperties, targetAddressInfo);
         }
 
+        private void LocalInterfaceCacheHandler(object sender, EventArgs e)
+        {
+            Logger.Info?.Print(LogClass.ServiceNifm, $"NetworkAddress changed, invalidating cached data.");
+
+            _targetPropertiesCache  = null;
+            _targetAddressInfoCache = null;
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             if (isDisposing)
             {
+                NetworkChange.NetworkAddressChanged -= LocalInterfaceCacheHandler;
+
                 GeneralServiceManager.Remove(_generalServiceDetail.ClientId);
             }
         }

Ryujinx.HLE/HOS/Services/Nim/Ntc/IStaticService.cs

@@ -1,8 +1,24 @@
-namespace Ryujinx.HLE.HOS.Services.Nim.Ntc
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Nim.Ntc.StaticService;
+
+namespace Ryujinx.HLE.HOS.Services.Nim.Ntc
 {
     [Service("ntc")]
     class IStaticService : IpcService
     {
         public IStaticService(ServiceCtx context) { }
+
+        [CommandHipc(0)]
+        // OpenEnsureNetworkClockAvailabilityService(u64) -> object<nn::ntc::detail::service::IEnsureNetworkClockAvailabilityService>
+        public ResultCode CreateAsyncInterface(ServiceCtx context)
+        {
+            ulong unknown = context.RequestData.ReadUInt64();
+
+            MakeObject(context, new IEnsureNetworkClockAvailabilityService(context));
+
+            Logger.Stub?.PrintStub(LogClass.ServiceNtc, new { unknown });
+
+            return ResultCode.Success;
+        }
     }
 }

Ryujinx.HLE/HOS/Services/Nim/Ntc/StaticService/IEnsureNetworkClockAvailabilityService.cs

@@ -0,0 +1,77 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Ipc;
+using Ryujinx.HLE.HOS.Kernel.Common;
+using Ryujinx.HLE.HOS.Kernel.Threading;
+using System;
+
+namespace Ryujinx.HLE.HOS.Services.Nim.Ntc.StaticService
+{
+    class IEnsureNetworkClockAvailabilityService : IpcService 
+    {
+        private KEvent     _finishNotificationEvent;
+        private ResultCode _taskResultCode;
+
+        public IEnsureNetworkClockAvailabilityService(ServiceCtx context)
+        {
+            _finishNotificationEvent = new KEvent(context.Device.System.KernelContext);
+            _taskResultCode          = ResultCode.Success;
+
+            // NOTE: The service starts a thread that polls Nintendo NTP server and syncs the time with it.
+            //       Additionnally it gets and uses some settings too:
+            //       autonomic_correction_interval_seconds, autonomic_correction_failed_retry_interval_seconds,
+            //       autonomic_correction_immediate_try_count_max, autonomic_correction_immediate_try_interval_milliseconds
+        }
+
+        [CommandHipc(0)]
+        // StartTask()
+        public ResultCode StartTask(ServiceCtx context)
+        {
+            if (!context.Device.Configuration.EnableInternetAccess)
+            {
+                return (ResultCode)Time.ResultCode.NetworkTimeNotAvailable;
+            }
+
+            // NOTE: Since we don't support the Nintendo NTP server, we can signal the event now to confirm the update task is done.
+            _finishNotificationEvent.ReadableEvent.Signal();
+
+            Logger.Stub?.PrintStub(LogClass.ServiceNtc);
+
+            return ResultCode.Success;
+        }
+
+        [CommandHipc(1)]
+        // GetFinishNotificationEvent() -> handle<copy>
+        public ResultCode GetFinishNotificationEvent(ServiceCtx context)
+        {
+            if (context.Process.HandleTable.GenerateHandle(_finishNotificationEvent.ReadableEvent, out int finishNotificationEventHandle) != KernelResult.Success)
+            {
+                throw new InvalidOperationException("Out of handles!");
+            }
+
+            context.Response.HandleDesc = IpcHandleDesc.MakeCopy(finishNotificationEventHandle);
+
+            return ResultCode.Success;
+        }
+
+        [CommandHipc(2)]
+        // GetResult()
+        public ResultCode GetResult(ServiceCtx context)
+        {
+            return _taskResultCode;
+        }
+
+        [CommandHipc(3)]
+        // Cancel()
+        public ResultCode Cancel(ServiceCtx context)
+        {
+            // NOTE: The update task should be canceled here.
+            _finishNotificationEvent.ReadableEvent.Signal();
+
+            _taskResultCode = (ResultCode)Time.ResultCode.NetworkTimeTaskCanceled;
+
+            Logger.Stub?.PrintStub(LogClass.ServiceNtc);
+
+            return ResultCode.Success;
+        }
+    }
+}

Ryujinx.HLE/HOS/Services/Time/ResultCode.cs

@@ -7,16 +7,18 @@
 
         Success = 0,
 
-        TimeServiceNotInitialized = (0   << ErrorCodeShift) | ModuleId,
-        PermissionDenied          = (1   << ErrorCodeShift) | ModuleId,
-        TimeMismatch              = (102 << ErrorCodeShift) | ModuleId,
-        UninitializedClock        = (103 << ErrorCodeShift) | ModuleId,
-        TimeNotFound              = (200 << ErrorCodeShift) | ModuleId,
-        Overflow                  = (201 << ErrorCodeShift) | ModuleId,
-        LocationNameTooLong       = (801 << ErrorCodeShift) | ModuleId,
-        OutOfRange                = (902 << ErrorCodeShift) | ModuleId,
-        TimeZoneConversionFailed  = (903 << ErrorCodeShift) | ModuleId,
-        TimeZoneNotFound          = (989 << ErrorCodeShift) | ModuleId,
-        NotImplemented            = (990 << ErrorCodeShift) | ModuleId,
+        TimeServiceNotInitialized = (0    << ErrorCodeShift) | ModuleId,
+        PermissionDenied          = (1    << ErrorCodeShift) | ModuleId,
+        TimeMismatch              = (102  << ErrorCodeShift) | ModuleId,
+        UninitializedClock        = (103  << ErrorCodeShift) | ModuleId,
+        TimeNotFound              = (200  << ErrorCodeShift) | ModuleId,
+        Overflow                  = (201  << ErrorCodeShift) | ModuleId,
+        LocationNameTooLong       = (801  << ErrorCodeShift) | ModuleId,
+        OutOfRange                = (902  << ErrorCodeShift) | ModuleId,
+        TimeZoneConversionFailed  = (903  << ErrorCodeShift) | ModuleId,
+        TimeZoneNotFound          = (989  << ErrorCodeShift) | ModuleId,
+        NotImplemented            = (990  << ErrorCodeShift) | ModuleId,
+        NetworkTimeNotAvailable   = (1000 << ErrorCodeShift) | ModuleId,
+        NetworkTimeTaskCanceled   = (1003 << ErrorCodeShift) | ModuleId,
     }
 }