Force all exclusive memory accesses to be ordered on AppleHv (#5898)

* Implement reprotect method on virtual memory manager (currently stubbed)

* Force all exclusive memory accesses to be ordered on AppleHv

* Format whitespace

* Fix test build

* Fix comment copy/paste

* Fix wrong bit for isLoad

* Update src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs

Co-authored-by: riperiperi <rhy3756547@hotmail.com>

---------

Co-authored-by: riperiperi <rhy3756547@hotmail.com>

Directory.Packages.props

@@ -18,12 +18,13 @@
     <PackageVersion Include="GtkSharp.Dependencies" Version="1.1.1" />
     <PackageVersion Include="GtkSharp.Dependencies.osx" Version="0.0.5" />
     <PackageVersion Include="jp2masa.Avalonia.Flexbox" Version="0.3.0-beta.4" />
-    <PackageVersion Include="LibHac" Version="0.18.0" />
+    <PackageVersion Include="LibHac" Version="0.19.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.3.4" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.7.0" />
     <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
     <PackageVersion Include="Microsoft.IO.RecyclableMemoryStream" Version="2.3.2" />
     <PackageVersion Include="MsgPack.Cli" Version="1.0.1" />
+    <PackageVersion Include="NetCoreServer" Version="7.0.0" />
     <PackageVersion Include="NUnit" Version="3.13.3" />
     <PackageVersion Include="NUnit3TestAdapter" Version="4.1.0" />
     <PackageVersion Include="OpenTK.Core" Version="4.7.7" />

README.md

@@ -141,4 +141,5 @@ See [LICENSE.txt](LICENSE.txt) and [THIRDPARTY.md](distribution/legal/THIRDPARTY
 
 - [LibHac](https://github.com/Thealexbarney/LibHac) is used for our file-system.
 - [AmiiboAPI](https://www.amiiboapi.com) is used in our Amiibo emulation.
+- [ldn_mitm](https://github.com/spacemeowx2/ldn_mitm) is used for one of our available multiplayer modes.
 - [ShellLink](https://github.com/securifybv/ShellLink) is used for Windows shortcut generation.

distribution/legal/THIRDPARTY.md

@@ -710,4 +710,4 @@
   OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   SOFTWARE.
   ```
-</details>
+</details>

src/ARMeilleure/Decoders/Decoder.cs

@@ -38,7 +38,9 @@ namespace ARMeilleure.Decoders
                 {
                     block = new Block(blkAddress);
 
-                    if ((dMode != DecoderMode.MultipleBlocks && visited.Count >= 1) || opsCount > instructionLimit || !memory.IsMapped(blkAddress))
+                    if ((dMode != DecoderMode.MultipleBlocks && visited.Count >= 1) ||
+                        opsCount > instructionLimit ||
+                        (visited.Count > 0 && !memory.IsMapped(blkAddress)))
                     {
                         block.Exit = true;
                         block.EndAddress = blkAddress;

src/Ryujinx.Ava/AppHost.cs

@@ -190,6 +190,7 @@ namespace Ryujinx.Ava
             ConfigurationState.Instance.Graphics.ScalingFilterLevel.Event += UpdateScalingFilterLevel;
             ConfigurationState.Instance.Graphics.EnableColorSpacePassthrough.Event += UpdateColorSpacePassthrough;
 
+            ConfigurationState.Instance.System.EnableInternetAccess.Event += UpdateEnableInternetAccessState;
             ConfigurationState.Instance.Multiplayer.LanInterfaceId.Event += UpdateLanInterfaceIdState;
             ConfigurationState.Instance.Multiplayer.Mode.Event += UpdateMultiplayerModeState;
 
@@ -408,6 +409,11 @@ namespace Ryujinx.Ava
             });
         }
 
+        private void UpdateEnableInternetAccessState(object sender, ReactiveEventArgs<bool> e)
+        {
+            Device.Configuration.EnableInternetAccess = e.NewValue;
+        }
+
         private void UpdateLanInterfaceIdState(object sender, ReactiveEventArgs<string> e)
         {
             Device.Configuration.MultiplayerLanInterfaceId = e.NewValue;
@@ -710,7 +716,7 @@ namespace Ryujinx.Ava
 
             ApplicationLibrary.LoadAndSaveMetaData(Device.Processes.ActiveApplication.ProgramIdText, appMetadata =>
             {
-                appMetadata.LastPlayed = DateTime.UtcNow;
+                appMetadata.UpdatePreGame();
             });
 
             return true;

src/Ryujinx.Ava/Assets/Locales/en_US.json

@@ -650,7 +650,7 @@
   "UserEditorTitle": "Edit User",
   "UserEditorTitleCreate": "Create User",
   "SettingsTabNetworkInterface": "Network Interface:",
-  "NetworkInterfaceTooltip": "The network interface used for LAN features",
+  "NetworkInterfaceTooltip": "The network interface used for LAN/LDN features",
   "NetworkInterfaceDefault": "Default",
   "PackagingShaders": "Packaging Shaders",
   "AboutChangelogButton": "View Changelog on GitHub",

src/Ryujinx.Ava/Common/ApplicationHelper.cs

@@ -173,7 +173,7 @@ namespace Ryujinx.Ava.Common
                 string extension = Path.GetExtension(titleFilePath).ToLower();
                 if (extension == ".nsp" || extension == ".pfs0" || extension == ".xci")
                 {
-                    PartitionFileSystem pfs;
+                    IFileSystem pfs;
 
                     if (extension == ".xci")
                     {
@@ -181,7 +181,9 @@ namespace Ryujinx.Ava.Common
                     }
                     else
                     {
-                        pfs = new PartitionFileSystem(file.AsStorage());
+                        var pfsTemp = new PartitionFileSystem();
+                        pfsTemp.Initialize(file.AsStorage()).ThrowIfFailure();
+                        pfs = pfsTemp;
                     }
 
                     foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))

src/Ryujinx.Ava/Program.cs

@@ -6,13 +6,13 @@ using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
-using Ryujinx.Common.SystemInfo;
 using Ryujinx.Common.SystemInterop;
 using Ryujinx.Modules;
 using Ryujinx.SDL2.Common;
 using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
 using Ryujinx.Ui.Common.Helper;
+using Ryujinx.Ui.Common.SystemInfo;
 using System;
 using System.IO;
 using System.Runtime.InteropServices;

src/Ryujinx.Ava/UI/Controls/ApplicationListView.axaml

@@ -126,17 +126,17 @@
                                     Spacing="5">
                                     <TextBlock
                                         HorizontalAlignment="Stretch"
-                                        Text="{Binding TimePlayed}"
+                                        Text="{Binding TimePlayedString}"
                                         TextAlignment="Right"
                                         TextWrapping="Wrap" />
                                     <TextBlock
                                         HorizontalAlignment="Stretch"
-                                        Text="{Binding LastPlayed, Converter={helpers:NullableDateTimeConverter}}"
+                                        Text="{Binding LastPlayedString, Converter={helpers:LocalizedNeverConverter}}"
                                         TextAlignment="Right"
                                         TextWrapping="Wrap" />
                                     <TextBlock
                                         HorizontalAlignment="Stretch"
-                                        Text="{Binding FileSize}"
+                                        Text="{Binding FileSizeString}"
                                         TextAlignment="Right"
                                         TextWrapping="Wrap" />
                                 </StackPanel>

src/Ryujinx.Ava/UI/Helpers/LocalizedNeverConverter.cs

@@ -0,0 +1,43 @@
+using Avalonia.Data.Converters;
+using Avalonia.Markup.Xaml;
+using Ryujinx.Ava.Common.Locale;
+using Ryujinx.Ui.Common.Helper;
+using System;
+using System.Globalization;
+
+namespace Ryujinx.Ava.UI.Helpers
+{
+    /// <summary>
+    /// This <see cref="IValueConverter"/> makes sure that the string "Never" that's returned by <see cref="ValueFormatUtils.FormatDateTime"/> is properly localized in the Avalonia UI.
+    /// After the Avalonia UI has been made the default and the GTK UI is removed, <see cref="ValueFormatUtils"/> should be updated to directly return a localized string.
+    /// </summary>
+    internal class LocalizedNeverConverter : MarkupExtension, IValueConverter
+    {
+        private static readonly LocalizedNeverConverter _instance = new();
+
+        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            if (value is not string valStr)
+            {
+                return "";
+            }
+
+            if (valStr == "Never")
+            {
+                return LocaleManager.Instance[LocaleKeys.Never];
+            }
+
+            return valStr;
+        }
+
+        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override object ProvideValue(IServiceProvider serviceProvider)
+        {
+            return _instance;
+        }
+    }
+}

src/Ryujinx.Ava/UI/Helpers/NullableDateTimeConverter.cs

@@ -1,38 +0,0 @@
-using Avalonia.Data.Converters;
-using Avalonia.Markup.Xaml;
-using Ryujinx.Ava.Common.Locale;
-using System;
-using System.Globalization;
-
-namespace Ryujinx.Ava.UI.Helpers
-{
-    internal class NullableDateTimeConverter : MarkupExtension, IValueConverter
-    {
-        private static readonly NullableDateTimeConverter _instance = new();
-
-        public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
-        {
-            if (value == null)
-            {
-                return LocaleManager.Instance[LocaleKeys.Never];
-            }
-
-            if (value is DateTime dateTime)
-            {
-                return dateTime.ToLocalTime().ToString(culture);
-            }
-
-            throw new NotSupportedException();
-        }
-
-        public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture)
-        {
-            throw new NotSupportedException();
-        }
-
-        public override object ProvideValue(IServiceProvider serviceProvider)
-        {
-            return _instance;
-        }
-    }
-}

src/Ryujinx.Ava/UI/Models/Generic/LastPlayedSortComparer.cs

@@ -13,20 +13,19 @@ namespace Ryujinx.Ava.UI.Models.Generic
 
         public int Compare(ApplicationData x, ApplicationData y)
         {
-            var aValue = x.LastPlayed;
-            var bValue = y.LastPlayed;
+            DateTime aValue = DateTime.UnixEpoch, bValue = DateTime.UnixEpoch;
 
-            if (!aValue.HasValue)
+            if (x?.LastPlayed != null)
             {
-                aValue = DateTime.UnixEpoch;
+                aValue = x.LastPlayed.Value;
             }
 
-            if (!bValue.HasValue)
+            if (y?.LastPlayed != null)
             {
-                bValue = DateTime.UnixEpoch;
+                bValue = y.LastPlayed.Value;
             }
 
-            return (IsAscending ? 1 : -1) * DateTime.Compare(bValue.Value, aValue.Value);
+            return (IsAscending ? 1 : -1) * DateTime.Compare(aValue, bValue);
         }
     }
 }

src/Ryujinx.Ava/UI/Models/Generic/TimePlayedSortComparer.cs

@@ -0,0 +1,31 @@
+using Ryujinx.Ui.App.Common;
+using System;
+using System.Collections.Generic;
+
+namespace Ryujinx.Ava.UI.Models.Generic
+{
+    internal class TimePlayedSortComparer : IComparer<ApplicationData>
+    {
+        public TimePlayedSortComparer() { }
+        public TimePlayedSortComparer(bool isAscending) { IsAscending = isAscending; }
+
+        public bool IsAscending { get; }
+
+        public int Compare(ApplicationData x, ApplicationData y)
+        {
+            TimeSpan aValue = TimeSpan.Zero, bValue = TimeSpan.Zero;
+
+            if (x?.TimePlayed != null)
+            {
+                aValue = x.TimePlayed;
+            }
+
+            if (y?.TimePlayed != null)
+            {
+                bValue = y.TimePlayed;
+            }
+
+            return (IsAscending ? 1 : -1) * TimeSpan.Compare(aValue, bValue);
+        }
+    }
+}

src/Ryujinx.Ava/UI/Models/SaveModel.cs

@@ -4,7 +4,7 @@ using Ryujinx.Ava.UI.ViewModels;
 using Ryujinx.Ava.UI.Windows;
 using Ryujinx.HLE.FileSystem;
 using Ryujinx.Ui.App.Common;
-using System;
+using Ryujinx.Ui.Common.Helper;
 using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
@@ -38,26 +38,7 @@ namespace Ryujinx.Ava.UI.Models
 
         public bool SizeAvailable { get; set; }
 
-        public string SizeString => GetSizeString();
-
-        private string GetSizeString()
-        {
-            const int Scale = 1024;
-            string[] orders = { "GiB", "MiB", "KiB" };
-            long max = (long)Math.Pow(Scale, orders.Length);
-
-            foreach (string order in orders)
-            {
-                if (Size > max)
-                {
-                    return $"{decimal.Divide(Size, max):##.##} {order}";
-                }
-
-                max /= Scale;
-            }
-
-            return "0 KiB";
-        }
+        public string SizeString => ValueFormatUtils.FormatFileSize(Size);
 
         public SaveModel(SaveDataInfo info)
         {

src/Ryujinx.Ava/UI/ViewModels/DownloadableContentManagerViewModel.cs

@@ -126,7 +126,8 @@ namespace Ryujinx.Ava.UI.ViewModels
                 {
                     using FileStream containerFile = File.OpenRead(downloadableContentContainer.ContainerPath);
 
-                    PartitionFileSystem partitionFileSystem = new(containerFile.AsStorage());
+                    PartitionFileSystem partitionFileSystem = new();
+                    partitionFileSystem.Initialize(containerFile.AsStorage()).ThrowIfFailure();
 
                     _virtualFileSystem.ImportTickets(partitionFileSystem);
 
@@ -232,7 +233,8 @@ namespace Ryujinx.Ava.UI.ViewModels
 
             using FileStream containerFile = File.OpenRead(path);
 
-            PartitionFileSystem partitionFileSystem = new(containerFile.AsStorage());
+            PartitionFileSystem partitionFileSystem = new();
+            partitionFileSystem.Initialize(containerFile.AsStorage()).ThrowIfFailure();
             bool containsDownloadableContent = false;
 
             _virtualFileSystem.ImportTickets(partitionFileSystem);

src/Ryujinx.Ava/UI/ViewModels/MainWindowViewModel.cs

@@ -930,21 +930,20 @@ namespace Ryujinx.Ava.UI.ViewModels
             return SortMode switch
             {
 #pragma warning disable IDE0055 // Disable formatting
+                ApplicationSort.Title           => IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.TitleName)
+                                                               : SortExpressionComparer<ApplicationData>.Descending(app => app.TitleName),
+                ApplicationSort.Developer       => IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.Developer)
+                                                               : SortExpressionComparer<ApplicationData>.Descending(app => app.Developer),
                 ApplicationSort.LastPlayed      => new LastPlayedSortComparer(IsAscending),
-                ApplicationSort.FileSize        => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app => app.FileSizeBytes)
-                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.FileSizeBytes),
-                ApplicationSort.TotalTimePlayed => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app => app.TimePlayedNum)
-                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.TimePlayedNum),
-                ApplicationSort.Title           => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app => app.TitleName)
-                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.TitleName),
+                ApplicationSort.TotalTimePlayed => new TimePlayedSortComparer(IsAscending),
+                ApplicationSort.FileType        => IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.FileExtension)
+                                                               : SortExpressionComparer<ApplicationData>.Descending(app => app.FileExtension),
+                ApplicationSort.FileSize        => IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.FileSize)
+                                                               : SortExpressionComparer<ApplicationData>.Descending(app => app.FileSize),
+                ApplicationSort.Path            => IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.Path)
+                                                               : SortExpressionComparer<ApplicationData>.Descending(app => app.Path),
                 ApplicationSort.Favorite        => !IsAscending ? SortExpressionComparer<ApplicationData>.Ascending(app => app.Favorite)
                                                                 : SortExpressionComparer<ApplicationData>.Descending(app => app.Favorite),
-                ApplicationSort.Developer       => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app => app.Developer)
-                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.Developer),
-                ApplicationSort.FileType        => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app => app.FileExtension)
-                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.FileExtension),
-                ApplicationSort.Path            => IsAscending  ? SortExpressionComparer<ApplicationData>.Ascending(app => app.Path)
-                                                                : SortExpressionComparer<ApplicationData>.Descending(app => app.Path),
                 _ => null,
 #pragma warning restore IDE0055
             };
@@ -1549,13 +1548,7 @@ namespace Ryujinx.Ava.UI.ViewModels
         {
             ApplicationLibrary.LoadAndSaveMetaData(titleId, appMetadata =>
             {
-                if (appMetadata.LastPlayed.HasValue)
-                {
-                    double sessionTimePlayed = DateTime.UtcNow.Subtract(appMetadata.LastPlayed.Value).TotalSeconds;
-                    appMetadata.TimePlayed += Math.Round(sessionTimePlayed, MidpointRounding.AwayFromZero);
-                }
-
-                appMetadata.LastPlayed = DateTime.UtcNow;
+                appMetadata.UpdatePostGame();
             });
         }
 

src/Ryujinx.Ava/UI/ViewModels/TitleUpdateViewModel.cs

@@ -170,7 +170,9 @@ namespace Ryujinx.Ava.UI.ViewModels
 
                 try
                 {
-                    (Nca patchNca, Nca controlNca) = ApplicationLibrary.GetGameUpdateDataFromPartition(VirtualFileSystem, new PartitionFileSystem(file.AsStorage()), TitleId.ToString("x16"), 0);
+                    var pfs = new PartitionFileSystem();
+                    pfs.Initialize(file.AsStorage()).ThrowIfFailure();
+                    (Nca patchNca, Nca controlNca) = ApplicationLibrary.GetGameUpdateDataFromPartition(VirtualFileSystem, pfs, TitleId.ToString("x16"), 0);
 
                     if (controlNca != null && patchNca != null)
                     {

src/Ryujinx.Common/Configuration/Multiplayer/MultiplayerMode.cs

@@ -3,5 +3,6 @@
     public enum MultiplayerMode
     {
         Disabled,
+        LdnMitm,
     }
 }

src/Ryujinx.Common/Utilities/NetworkHelpers.cs

@@ -74,5 +74,10 @@ namespace Ryujinx.Common.Utilities
         {
             return ConvertIpv4Address(IPAddress.Parse(ipAddress));
         }
+
+        public static IPAddress ConvertUint(uint ipAddress)
+        {
+            return new IPAddress(new byte[] { (byte)((ipAddress >> 24) & 0xFF), (byte)((ipAddress >> 16) & 0xFF), (byte)((ipAddress >> 8) & 0xFF), (byte)(ipAddress & 0xFF) });
+        }
     }
 }

src/Ryujinx.Cpu/AppleHv/HvCodePatcher.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+
+namespace Ryujinx.Cpu.AppleHv
+{
+    static class HvCodePatcher
+    {
+        private const uint XMask = 0x3f808000u;
+        private const uint XValue = 0x8000000u;
+
+        private const uint ZrIndex = 31u;
+
+        public static void RewriteUnorderedExclusiveInstructions(Span<byte> code)
+        {
+            Span<uint> codeUint = MemoryMarshal.Cast<byte, uint>(code);
+            Span<Vector128<uint>> codeVector = MemoryMarshal.Cast<byte, Vector128<uint>>(code);
+
+            Vector128<uint> mask = Vector128.Create(XMask);
+            Vector128<uint> value = Vector128.Create(XValue);
+
+            for (int index = 0; index < codeVector.Length; index++)
+            {
+                Vector128<uint> v = codeVector[index];
+
+                if (Vector128.EqualsAny(Vector128.BitwiseAnd(v, mask), value))
+                {
+                    int baseIndex = index * 4;
+
+                    for (int instIndex = baseIndex; instIndex < baseIndex + 4; instIndex++)
+                    {
+                        ref uint inst = ref codeUint[instIndex];
+
+                        if ((inst & XMask) != XValue)
+                        {
+                            continue;
+                        }
+
+                        bool isPair = (inst & (1u << 21)) != 0;
+                        bool isLoad = (inst & (1u << 22)) != 0;
+
+                        uint rt2 = (inst >> 10) & 0x1fu;
+                        uint rs = (inst >> 16) & 0x1fu;
+
+                        if (isLoad && rs != ZrIndex)
+                        {
+                            continue;
+                        }
+
+                        if (!isPair && rt2 != ZrIndex)
+                        {
+                            continue;
+                        }
+
+                        // Set the ordered flag.
+                        inst |= 1u << 15;
+                    }
+                }
+            }
+        }
+    }
+}

src/Ryujinx.Cpu/AppleHv/HvMemoryManager.cs

@@ -128,21 +128,6 @@ namespace Ryujinx.Cpu.AppleHv
             }
         }
 
-#pragma warning disable IDE0051 // Remove unused private member
-        /// <summary>
-        /// Ensures the combination of virtual address and size is part of the addressable space and fully mapped.
-        /// </summary>
-        /// <param name="va">Virtual address of the range</param>
-        /// <param name="size">Size of the range in bytes</param>
-        private void AssertMapped(ulong va, ulong size)
-        {
-            if (!ValidateAddressAndSize(va, size) || !IsRangeMappedImpl(va, size))
-            {
-                throw new InvalidMemoryRegionException($"Not mapped: va=0x{va:X16}, size=0x{size:X16}");
-            }
-        }
-#pragma warning restore IDE0051
-
         /// <inheritdoc/>
         public void Map(ulong va, ulong pa, ulong size, MemoryMapFlags flags)
         {
@@ -736,6 +721,24 @@ namespace Ryujinx.Cpu.AppleHv
             return (int)(vaSpan / PageSize);
         }
 
+        /// <inheritdoc/>
+        public void Reprotect(ulong va, ulong size, MemoryPermission protection)
+        {
+            if (protection.HasFlag(MemoryPermission.Execute))
+            {
+                // Some applications use unordered exclusive memory access instructions
+                // where it is not valid to do so, leading to memory re-ordering that
+                // makes the code behave incorrectly on some CPUs.
+                // To work around this, we force all such accesses to be ordered.
+
+                using WritableRegion writableRegion = GetWritableRegion(va, (int)size);
+
+                HvCodePatcher.RewriteUnorderedExclusiveInstructions(writableRegion.Memory.Span);
+            }
+
+            // TODO
+        }
+
         /// <inheritdoc/>
         public void TrackingReprotect(ulong va, ulong size, MemoryPermission protection)
         {

src/Ryujinx.Cpu/Jit/MemoryManager.cs

@@ -575,24 +575,17 @@ namespace Ryujinx.Cpu.Jit
             }
         }
 
-#pragma warning disable IDE0051 // Remove unused private member
-        private ulong GetPhysicalAddress(ulong va)
-        {
-            // We return -1L if the virtual address is invalid or unmapped.
-            if (!ValidateAddress(va) || !IsMapped(va))
-            {
-                return ulong.MaxValue;
-            }
-
-            return GetPhysicalAddressInternal(va);
-        }
-#pragma warning restore IDE0051
-
         private ulong GetPhysicalAddressInternal(ulong va)
         {
             return PteToPa(_pageTable.Read<ulong>((va / PageSize) * PteSize) & ~(0xffffUL << 48)) + (va & PageMask);
         }
 
+        /// <inheritdoc/>
+        public void Reprotect(ulong va, ulong size, MemoryPermission protection)
+        {
+            // TODO
+        }
+
         /// <inheritdoc/>
         public void TrackingReprotect(ulong va, ulong size, MemoryPermission protection)
         {
@@ -698,9 +691,5 @@ namespace Ryujinx.Cpu.Jit
         /// Disposes of resources used by the memory manager.
         /// </summary>
         protected override void Destroy() => _pageTable.Dispose();
-
-#pragma warning disable IDE0051 // Remove unused private member
-        private static void ThrowInvalidMemoryRegionException(string message) => throw new InvalidMemoryRegionException(message);
-#pragma warning restore IDE0051
     }
 }

src/Ryujinx.Cpu/Jit/MemoryManagerHostMapped.cs

@@ -615,6 +615,12 @@ namespace Ryujinx.Cpu.Jit
             return (int)(vaSpan / PageSize);
         }
 
+        /// <inheritdoc/>
+        public void Reprotect(ulong va, ulong size, MemoryPermission protection)
+        {
+            // TODO
+        }
+
         /// <inheritdoc/>
         public void TrackingReprotect(ulong va, ulong size, MemoryPermission protection)
         {

src/Ryujinx.Graphics.Gpu/Image/Texture.cs

@@ -101,6 +101,11 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public bool AlwaysFlushOnOverlap { get; private set; }
 
+        /// <summary>
+        /// Indicates that the texture was fully unmapped since the modified flag was set, and flushes should be ignored until it is modified again.
+        /// </summary>
+        public bool FlushStale { get; private set; }
+
         /// <summary>
         /// Increments when the host texture is swapped, or when the texture is removed from all pools.
         /// </summary>
@@ -149,6 +154,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public bool HadPoolOwner { get; private set; }
 
+        /// <summary>
         /// Physical memory ranges where the texture data is located.
         /// </summary>
         public MultiRange Range { get; private set; }
@@ -1411,6 +1417,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// </summary>
         public void SignalModified()
         {
+            FlushStale = false;
             _scaledSetScore = Math.Max(0, _scaledSetScore - 1);
 
             if (_modifiedStale || Group.HasCopyDependencies)
@@ -1431,6 +1438,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             if (bound)
             {
+                FlushStale = false;
                 _scaledSetScore = Math.Max(0, _scaledSetScore - 1);
             }
 
@@ -1695,12 +1703,17 @@ namespace Ryujinx.Graphics.Gpu.Image
         /// <param name="unmapRange">The range of memory being unmapped</param>
         public void Unmapped(MultiRange unmapRange)
         {
+            if (unmapRange.Contains(Range))
+            {
+                // If this is a full unmap, prevent flushes until the texture is mapped again.
+                FlushStale = true;
+            }
+
             ChangedMapping = true;
 
             if (Group.Storage == this)
             {
                 Group.Unmapped();
-
                 Group.ClearModified(unmapRange);
             }
         }

src/Ryujinx.Graphics.Gpu/Image/TextureCache.cs

@@ -107,8 +107,6 @@ namespace Ryujinx.Graphics.Gpu.Image
                             // Any texture that has been unmapped at any point or is partially unmapped
                             // should update their pool references after the remap completes.
 
-                            MultiRange unmapped = ((MemoryManager)sender).GetPhysicalRegions(e.Address, e.Size);
-
                             foreach (var texture in _partiallyMappedTextures)
                             {
                                 texture.UpdatePoolMappings();
@@ -735,9 +733,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     if (overlap.IsView)
                     {
-                        overlapCompatibility = overlapCompatibility == TextureViewCompatibility.FormatAlias ?
-                            TextureViewCompatibility.Incompatible :
-                            TextureViewCompatibility.CopyOnly;
+                        overlapCompatibility = TextureViewCompatibility.CopyOnly;
                     }
                     else
                     {
@@ -815,7 +811,7 @@ namespace Ryujinx.Graphics.Gpu.Image
                     Texture overlap = _textureOverlaps[index];
                     OverlapInfo oInfo = _overlapInfo[index];
 
-                    if (oInfo.Compatibility <= TextureViewCompatibility.LayoutIncompatible || oInfo.Compatibility == TextureViewCompatibility.FormatAlias)
+                    if (oInfo.Compatibility <= TextureViewCompatibility.LayoutIncompatible)
                     {
                         if (!overlap.IsView && texture.DataOverlaps(overlap, oInfo.Compatibility))
                         {

src/Ryujinx.Graphics.Gpu/Image/TextureCompatibility.cs

@@ -226,7 +226,7 @@ namespace Ryujinx.Graphics.Gpu.Image
         {
             // D32F and R32F texture have the same representation internally,
             // however the R32F format is used to sample from depth textures.
-            if (lhs.FormatInfo.Format == Format.D32Float && rhs.FormatInfo.Format == Format.R32Float && (forSampler || depthAlias))
+            if (IsValidDepthAsColorAlias(lhs.FormatInfo.Format, rhs.FormatInfo.Format) && (forSampler || depthAlias))
             {
                 return TextureMatchQuality.FormatAlias;
             }
@@ -239,14 +239,8 @@ namespace Ryujinx.Graphics.Gpu.Image
                 {
                     return TextureMatchQuality.FormatAlias;
                 }
-
-                if (lhs.FormatInfo.Format == Format.D16Unorm && rhs.FormatInfo.Format == Format.R16Unorm)
-                {
-                    return TextureMatchQuality.FormatAlias;
-                }
-
-                if ((lhs.FormatInfo.Format == Format.D24UnormS8Uint ||
-                     lhs.FormatInfo.Format == Format.S8UintD24Unorm) && rhs.FormatInfo.Format == Format.B8G8R8A8Unorm)
+                else if ((lhs.FormatInfo.Format == Format.D24UnormS8Uint ||
+                          lhs.FormatInfo.Format == Format.S8UintD24Unorm) && rhs.FormatInfo.Format == Format.B8G8R8A8Unorm)
                 {
                     return TextureMatchQuality.FormatAlias;
                 }
@@ -632,12 +626,27 @@ namespace Ryujinx.Graphics.Gpu.Image
 
             if (lhsFormat.Format.IsDepthOrStencil() || rhsFormat.Format.IsDepthOrStencil())
             {
-                return FormatMatches(lhs, rhs, flags.HasFlag(TextureSearchFlags.ForSampler), flags.HasFlag(TextureSearchFlags.DepthAlias)) switch
+                bool forSampler = flags.HasFlag(TextureSearchFlags.ForSampler);
+                bool depthAlias = flags.HasFlag(TextureSearchFlags.DepthAlias);
+
+                TextureMatchQuality matchQuality = FormatMatches(lhs, rhs, forSampler, depthAlias);
+
+                if (matchQuality == TextureMatchQuality.Perfect)
                 {
-                    TextureMatchQuality.Perfect => TextureViewCompatibility.Full,
-                    TextureMatchQuality.FormatAlias => TextureViewCompatibility.FormatAlias,
-                    _ => TextureViewCompatibility.Incompatible,
-                };
+                    return TextureViewCompatibility.Full;
+                }
+                else if (matchQuality == TextureMatchQuality.FormatAlias)
+                {
+                    return TextureViewCompatibility.FormatAlias;
+                }
+                else if (IsValidColorAsDepthAlias(lhsFormat.Format, rhsFormat.Format) || IsValidDepthAsColorAlias(lhsFormat.Format, rhsFormat.Format))
+                {
+                    return TextureViewCompatibility.CopyOnly;
+                }
+                else
+                {
+                    return TextureViewCompatibility.Incompatible;
+                }
             }
 
             if (IsFormatHostIncompatible(lhs, caps) || IsFormatHostIncompatible(rhs, caps))
@@ -666,6 +675,30 @@ namespace Ryujinx.Graphics.Gpu.Image
             return TextureViewCompatibility.Incompatible;
         }
 
+        /// <summary>
+        /// Checks if it's valid to alias a color format as a depth format.
+        /// </summary>
+        /// <param name="lhsFormat">Source format to be checked</param>
+        /// <param name="rhsFormat">Target format to be checked</param>
+        /// <returns>True if it's valid to alias the formats</returns>
+        private static bool IsValidColorAsDepthAlias(Format lhsFormat, Format rhsFormat)
+        {
+            return (lhsFormat == Format.R32Float && rhsFormat == Format.D32Float) ||
+                   (lhsFormat == Format.R16Unorm && rhsFormat == Format.D16Unorm);
+        }
+
+        /// <summary>
+        /// Checks if it's valid to alias a depth format as a color format.
+        /// </summary>
+        /// <param name="lhsFormat">Source format to be checked</param>
+        /// <param name="rhsFormat">Target format to be checked</param>
+        /// <returns>True if it's valid to alias the formats</returns>
+        private static bool IsValidDepthAsColorAlias(Format lhsFormat, Format rhsFormat)
+        {
+            return (lhsFormat == Format.D32Float && rhsFormat == Format.R32Float) ||
+                   (lhsFormat == Format.D16Unorm && rhsFormat == Format.R16Unorm);
+        }
+
         /// <summary>
         /// Checks if aliasing of two formats that would normally be considered incompatible be allowed,
         /// using copy dependencies.

src/Ryujinx.Graphics.Gpu/Image/TextureGroup.cs

@@ -1659,6 +1659,14 @@ namespace Ryujinx.Graphics.Gpu.Image
                 return;
             }
 
+            // If size is zero, we have nothing to flush.
+            // If the flush is stale, we should ignore it because the texture was unmapped since the modified
+            // flag was set, and flushing it is not safe anymore as the GPU might no longer own the memory.
+            if (size == 0 || Storage.FlushStale)
+            {
+                return;
+            }
+
             // There is a small gap here where the action is removed but _actionRegistered is still 1.
             // In this case it will skip registering the action, but here we are already handling it,
             // so there shouldn't be any issue as it's the same handler for all actions.

src/Ryujinx.Graphics.OpenGL/Image/TextureCopy.cs

@@ -367,7 +367,7 @@ namespace Ryujinx.Graphics.OpenGL.Image
             return to;
         }
 
-        private TextureView PboCopy(TextureView from, TextureView to, int srcLayer, int dstLayer, int srcLevel, int dstLevel, int width, int height)
+        public void PboCopy(TextureView from, TextureView to, int srcLayer, int dstLayer, int srcLevel, int dstLevel, int width, int height)
         {
             int dstWidth = width;
             int dstHeight = height;
@@ -445,8 +445,6 @@ namespace Ryujinx.Graphics.OpenGL.Image
             }
 
             GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);
-
-            return to;
         }
 
         private void EnsurePbo(TextureView view)

src/Ryujinx.Graphics.OpenGL/Image/TextureView.cs

@@ -140,6 +140,28 @@ namespace Ryujinx.Graphics.OpenGL.Image
                 int levels = Math.Min(Info.Levels, destinationView.Info.Levels - firstLevel);
                 _renderer.TextureCopyIncompatible.CopyIncompatibleFormats(this, destinationView, 0, firstLayer, 0, firstLevel, layers, levels);
             }
+            else if (destinationView.Format.IsDepthOrStencil() != Format.IsDepthOrStencil())
+            {
+                int layers = Math.Min(Info.GetLayers(), destinationView.Info.GetLayers() - firstLayer);
+                int levels = Math.Min(Info.Levels, destinationView.Info.Levels - firstLevel);
+
+                for (int level = 0; level < levels; level++)
+                {
+                    int srcWidth = Math.Max(1, Width >> level);
+                    int srcHeight = Math.Max(1, Height >> level);
+
+                    int dstWidth = Math.Max(1, destinationView.Width >> (firstLevel + level));
+                    int dstHeight = Math.Max(1, destinationView.Height >> (firstLevel + level));
+
+                    int minWidth = Math.Min(srcWidth, dstWidth);
+                    int minHeight = Math.Min(srcHeight, dstHeight);
+
+                    for (int layer = 0; layer < layers; layer++)
+                    {
+                        _renderer.TextureCopy.PboCopy(this, destinationView, 0, firstLayer + layer, 0, firstLevel + level, minWidth, minHeight);
+                    }
+                }
+            }
             else
             {
                 _renderer.TextureCopy.CopyUnscaled(this, destinationView, 0, firstLayer, 0, firstLevel);
@@ -169,6 +191,13 @@ namespace Ryujinx.Graphics.OpenGL.Image
             {
                 _renderer.TextureCopyIncompatible.CopyIncompatibleFormats(this, destinationView, srcLayer, dstLayer, srcLevel, dstLevel, 1, 1);
             }
+            else if (destinationView.Format.IsDepthOrStencil() != Format.IsDepthOrStencil())
+            {
+                int minWidth = Math.Min(Width, destinationView.Width);
+                int minHeight = Math.Min(Height, destinationView.Height);
+
+                _renderer.TextureCopy.PboCopy(this, destinationView, srcLayer, dstLayer, srcLevel, dstLevel, minWidth, minHeight);
+            }
             else
             {
                 _renderer.TextureCopy.CopyUnscaled(this, destinationView, srcLayer, dstLayer, srcLevel, dstLevel, 1, 1);

src/Ryujinx.Graphics.Shader/Instructions/InstEmitTexture.cs

@@ -766,7 +766,10 @@ namespace Ryujinx.Graphics.Shader.Instructions
                 flags |= offset == TexOffset.Ptp ? TextureFlags.Offsets : TextureFlags.Offset;
             }
 
-            sourcesList.Add(Const((int)component));
+            if (!hasDepthCompare)
+            {
+                sourcesList.Add(Const((int)component));
+            }
 
             Operand[] sources = sourcesList.ToArray();
             Operand[] dests = new Operand[BitOperations.PopCount((uint)componentMask)];

src/Ryujinx.Graphics.Vulkan/TextureView.cs

@@ -211,6 +211,13 @@ namespace Ryujinx.Graphics.Vulkan
                 int levels = Math.Min(Info.Levels, dst.Info.Levels - firstLevel);
                 _gd.HelperShader.CopyIncompatibleFormats(_gd, cbs, src, dst, 0, firstLayer, 0, firstLevel, layers, levels);
             }
+            else if (src.Info.Format.IsDepthOrStencil() != dst.Info.Format.IsDepthOrStencil())
+            {
+                int layers = Math.Min(Info.GetLayers(), dst.Info.GetLayers() - firstLayer);
+                int levels = Math.Min(Info.Levels, dst.Info.Levels - firstLevel);
+
+                _gd.HelperShader.CopyColor(_gd, cbs, src, dst, 0, firstLayer, 0, FirstLevel, layers, levels);
+            }
             else
             {
                 TextureCopy.Copy(
@@ -260,6 +267,10 @@ namespace Ryujinx.Graphics.Vulkan
             {
                 _gd.HelperShader.CopyIncompatibleFormats(_gd, cbs, src, dst, srcLayer, dstLayer, srcLevel, dstLevel, 1, 1);
             }
+            else if (src.Info.Format.IsDepthOrStencil() != dst.Info.Format.IsDepthOrStencil())
+            {
+                _gd.HelperShader.CopyColor(_gd, cbs, src, dst, srcLayer, dstLayer, srcLevel, dstLevel, 1, 1);
+            }
             else
             {
                 TextureCopy.Copy(

src/Ryujinx.HLE/FileSystem/ContentManager.cs

@@ -198,7 +198,7 @@ namespace Ryujinx.HLE.FileSystem
             {
                 using var ncaFile = new UniqueRef<IFile>();
 
-                fs.OpenFile(ref ncaFile.Ref, ncaPath.FullPath.ToU8Span(), OpenMode.Read);
+                fs.OpenFile(ref ncaFile.Ref, ncaPath.FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
                 var nca = new Nca(_virtualFileSystem.KeySet, ncaFile.Get.AsStorage());
                 if (nca.Header.ContentType != NcaContentType.Meta)
                 {
@@ -210,7 +210,7 @@ namespace Ryujinx.HLE.FileSystem
                 using var pfs0 = nca.OpenFileSystem(0, integrityCheckLevel);
                 using var cnmtFile = new UniqueRef<IFile>();
 
-                pfs0.OpenFile(ref cnmtFile.Ref, pfs0.EnumerateEntries().Single().FullPath.ToU8Span(), OpenMode.Read);
+                pfs0.OpenFile(ref cnmtFile.Ref, pfs0.EnumerateEntries().Single().FullPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
 
                 var cnmt = new Cnmt(cnmtFile.Get.AsStream());
                 if (cnmt.Type != ContentMetaType.AddOnContent || (cnmt.TitleId & 0xFFFFFFFFFFFFE000) != aocBaseId)
@@ -220,7 +220,7 @@ namespace Ryujinx.HLE.FileSystem
 
                 string ncaId = Convert.ToHexString(cnmt.ContentEntries[0].NcaId).ToLower();
 
-                AddAocItem(cnmt.TitleId, containerPath, $"{ncaId}.nca", true);
+                AddAocItem(cnmt.TitleId, containerPath, $"/{ncaId}.nca", true);
             }
         }
 
@@ -238,7 +238,8 @@ namespace Ryujinx.HLE.FileSystem
                 if (!mergedToContainer)
                 {
                     using FileStream fileStream = File.OpenRead(containerPath);
-                    using PartitionFileSystem partitionFileSystem = new(fileStream.AsStorage());
+                    using PartitionFileSystem partitionFileSystem = new();
+                    partitionFileSystem.Initialize(fileStream.AsStorage()).ThrowIfFailure();
 
                     _virtualFileSystem.ImportTickets(partitionFileSystem);
                 }
@@ -259,17 +260,17 @@ namespace Ryujinx.HLE.FileSystem
             {
                 var file = new FileStream(aoc.ContainerPath, FileMode.Open, FileAccess.Read);
                 using var ncaFile = new UniqueRef<IFile>();
-                PartitionFileSystem pfs;
 
                 switch (Path.GetExtension(aoc.ContainerPath))
                 {
                     case ".xci":
-                        pfs = new Xci(_virtualFileSystem.KeySet, file.AsStorage()).OpenPartition(XciPartitionType.Secure);
-                        pfs.OpenFile(ref ncaFile.Ref, aoc.NcaPath.ToU8Span(), OpenMode.Read);
+                        var xci = new Xci(_virtualFileSystem.KeySet, file.AsStorage()).OpenPartition(XciPartitionType.Secure);
+                        xci.OpenFile(ref ncaFile.Ref, aoc.NcaPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
                         break;
                     case ".nsp":
-                        pfs = new PartitionFileSystem(file.AsStorage());
-                        pfs.OpenFile(ref ncaFile.Ref, aoc.NcaPath.ToU8Span(), OpenMode.Read);
+                        var pfs = new PartitionFileSystem();
+                        pfs.Initialize(file.AsStorage());
+                        pfs.OpenFile(ref ncaFile.Ref, aoc.NcaPath.ToU8Span(), OpenMode.Read).ThrowIfFailure();
                         break;
                     default:
                         return false; // Print error?
@@ -606,11 +607,11 @@ namespace Ryujinx.HLE.FileSystem
 
             if (filesystem.FileExists($"{path}/00"))
             {
-                filesystem.OpenFile(ref file.Ref, $"{path}/00".ToU8Span(), mode);
+                filesystem.OpenFile(ref file.Ref, $"{path}/00".ToU8Span(), mode).ThrowIfFailure();
             }
             else
             {
-                filesystem.OpenFile(ref file.Ref, path.ToU8Span(), mode);
+                filesystem.OpenFile(ref file.Ref, path.ToU8Span(), mode).ThrowIfFailure();
             }
 
             return file.Release();

src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs

@@ -7,6 +7,7 @@ using LibHac.Fs.Shim;
 using LibHac.FsSrv;
 using LibHac.FsSystem;
 using LibHac.Ncm;
+using LibHac.Sdmmc;
 using LibHac.Spl;
 using LibHac.Tools.Es;
 using LibHac.Tools.Fs;
@@ -32,7 +33,7 @@ namespace Ryujinx.HLE.FileSystem
 
         public KeySet KeySet { get; private set; }
         public EmulatedGameCard GameCard { get; private set; }
-        public EmulatedSdCard SdCard { get; private set; }
+        public SdmmcApi SdCard { get; private set; }
         public ModLoader ModLoader { get; private set; }
 
         private readonly ConcurrentDictionary<ulong, Stream> _romFsByPid;
@@ -198,15 +199,15 @@ namespace Ryujinx.HLE.FileSystem
             fsServerObjects.FsCreators.EncryptedFileSystemCreator = new EncryptedFileSystemCreator();
 
             GameCard = fsServerObjects.GameCard;
-            SdCard = fsServerObjects.SdCard;
+            SdCard = fsServerObjects.Sdmmc;
 
-            SdCard.SetSdCardInsertionStatus(true);
+            SdCard.SetSdCardInserted(true);
 
             var fsServerConfig = new FileSystemServerConfig
             {
-                DeviceOperator = fsServerObjects.DeviceOperator,
                 ExternalKeySet = KeySet.ExternalKeySet,
                 FsCreators = fsServerObjects.FsCreators,
+                StorageDeviceManagerFactory = fsServerObjects.StorageDeviceManagerFactory,
                 RandomGenerator = randomGenerator,
             };
 
@@ -263,7 +264,16 @@ namespace Ryujinx.HLE.FileSystem
 
                 if (result.IsSuccess())
                 {
-                    Ticket ticket = new(ticketFile.Get.AsStream());
+                    // When reading a file from a Sha256PartitionFileSystem, you can't start a read in the middle
+                    // of the hashed portion (usually the first 0x200 bytes) of the file and end the read after
+                    // the end of the hashed portion, so we read the ticket file using a single read.
+                    byte[] ticketData = new byte[0x2C0];
+                    result = ticketFile.Get.Read(out long bytesRead, 0, ticketData);
+
+                    if (result.IsFailure() || bytesRead != ticketData.Length)
+                        continue;
+
+                    Ticket ticket = new(new MemoryStream(ticketData));
                     var titleKey = ticket.GetTitleKey(KeySet);
 
                     if (titleKey != null)

src/Ryujinx.HLE/HLEConfiguration.cs

@@ -101,7 +101,7 @@ namespace Ryujinx.HLE
         /// <summary>
         /// Control if the guest application should be told that there is a Internet connection available.
         /// </summary>
-        internal readonly bool EnableInternetAccess;
+        public bool EnableInternetAccess { internal get; set; }
 
         /// <summary>
         /// Control LibHac's integrity check level.

src/Ryujinx.HLE/HOS/Kernel/Memory/KMemoryPermission.cs

@@ -0,0 +1,46 @@
+using Ryujinx.Memory;
+using System;
+
+namespace Ryujinx.HLE.HOS.Kernel.Memory
+{
+    [Flags]
+    enum KMemoryPermission : uint
+    {
+        None = 0,
+        UserMask = Read | Write | Execute,
+        Mask = uint.MaxValue,
+
+        Read = 1 << 0,
+        Write = 1 << 1,
+        Execute = 1 << 2,
+        DontCare = 1 << 28,
+
+        ReadAndWrite = Read | Write,
+        ReadAndExecute = Read | Execute,
+    }
+
+    static class KMemoryPermissionExtensions
+    {
+        public static MemoryPermission Convert(this KMemoryPermission permission)
+        {
+            MemoryPermission output = MemoryPermission.None;
+
+            if (permission.HasFlag(KMemoryPermission.Read))
+            {
+                output = MemoryPermission.Read;
+            }
+
+            if (permission.HasFlag(KMemoryPermission.Write))
+            {
+                output |= MemoryPermission.Write;
+            }
+
+            if (permission.HasFlag(KMemoryPermission.Execute))
+            {
+                output |= MemoryPermission.Execute;
+            }
+
+            return output;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Kernel/Memory/KPageTable.cs

@@ -203,15 +203,17 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
         /// <inheritdoc/>
         protected override Result Reprotect(ulong address, ulong pagesCount, KMemoryPermission permission)
         {
-            // TODO.
+            _cpuMemory.Reprotect(address, pagesCount * PageSize, permission.Convert());
+
             return Result.Success;
         }
 
         /// <inheritdoc/>
-        protected override Result ReprotectWithAttributes(ulong address, ulong pagesCount, KMemoryPermission permission)
+        protected override Result ReprotectAndFlush(ulong address, ulong pagesCount, KMemoryPermission permission)
         {
-            // TODO.
-            return Result.Success;
+            // TODO: Flush JIT cache.
+
+            return Reprotect(address, pagesCount, permission);
         }
 
         /// <inheritdoc/>

src/Ryujinx.HLE/HOS/Kernel/Memory/KPageTableBase.cs

@@ -1255,7 +1255,7 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
 
                         if ((oldPermission & KMemoryPermission.Execute) != 0)
                         {
-                            result = ReprotectWithAttributes(address, pagesCount, permission);
+                            result = ReprotectAndFlush(address, pagesCount, permission);
                         }
                         else
                         {
@@ -3036,13 +3036,13 @@ namespace Ryujinx.HLE.HOS.Kernel.Memory
         protected abstract Result Reprotect(ulong address, ulong pagesCount, KMemoryPermission permission);
 
         /// <summary>
-        /// Changes the permissions of a given virtual memory region.
+        /// Changes the permissions of a given virtual memory region, while also flushing the cache.
         /// </summary>
         /// <param name="address">Virtual address of the region to have the permission changes</param>
         /// <param name="pagesCount">Number of pages to have their permissions changed</param>
         /// <param name="permission">New permission</param>
         /// <returns>Result of the permission change operation</returns>
-        protected abstract Result ReprotectWithAttributes(ulong address, ulong pagesCount, KMemoryPermission permission);
+        protected abstract Result ReprotectAndFlush(ulong address, ulong pagesCount, KMemoryPermission permission);
 
         /// <summary>
         /// Alerts the memory tracking that a given region has been read from or written to.

src/Ryujinx.HLE/HOS/Kernel/Memory/MemoryPermission.cs

@@ -1,20 +0,0 @@
-using System;
-
-namespace Ryujinx.HLE.HOS.Kernel.Memory
-{
-    [Flags]
-    enum KMemoryPermission : uint
-    {
-        None = 0,
-        UserMask = Read | Write | Execute,
-        Mask = uint.MaxValue,
-
-        Read = 1 << 0,
-        Write = 1 << 1,
-        Execute = 1 << 2,
-        DontCare = 1 << 28,
-
-        ReadAndWrite = Read | Write,
-        ReadAndExecute = Read | Execute,
-    }
-}

src/Ryujinx.HLE/HOS/ModLoader.cs

@@ -533,7 +533,9 @@ namespace Ryujinx.HLE.HOS
 
             Logger.Info?.Print(LogClass.ModLoader, "Using replacement ExeFS partition");
 
-            exefs = new PartitionFileSystem(mods.ExefsContainers[0].Path.OpenRead().AsStorage());
+            var pfs = new PartitionFileSystem();
+            pfs.Initialize(mods.ExefsContainers[0].Path.OpenRead().AsStorage()).ThrowIfFailure();
+            exefs = pfs;
 
             return true;
         }

src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/FileSystemProxyHelper.cs

@@ -26,7 +26,9 @@ namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
             try
             {
                 LocalStorage storage = new(pfsPath, FileAccess.Read, FileMode.Open);
-                using SharedRef<LibHac.Fs.Fsa.IFileSystem> nsp = new(new PartitionFileSystem(storage));
+                var pfs = new PartitionFileSystem();
+                using SharedRef<LibHac.Fs.Fsa.IFileSystem> nsp = new(pfs);
+                pfs.Initialize(storage).ThrowIfFailure();
 
                 ImportTitleKeysFromNsp(nsp.Get, context.Device.System.KeySet);
 
@@ -90,7 +92,8 @@ namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
 
                 try
                 {
-                    PartitionFileSystem nsp = new(pfsFile.AsStorage());
+                    PartitionFileSystem nsp = new();
+                    nsp.Initialize(pfsFile.AsStorage()).ThrowIfFailure();
 
                     ImportTitleKeysFromNsp(nsp, context.Device.System.KeySet);
 

src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFileSystem.cs

@@ -1,6 +1,7 @@
 using LibHac;
 using LibHac.Common;
 using LibHac.Fs;
+using LibHac.Fs.Fsa;
 using Path = LibHac.FsSrv.Sf.Path;
 
 namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
@@ -202,6 +203,16 @@ namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
             return (ResultCode)result.Value;
         }
 
+        [CommandCmif(16)]
+        public ResultCode GetFileSystemAttribute(ServiceCtx context)
+        {
+            Result result = _fileSystem.Get.GetFileSystemAttribute(out FileSystemAttribute attribute);
+
+            context.ResponseData.Write(SpanHelpers.AsReadOnlyByteSpan(in attribute));
+
+            return (ResultCode)result.Value;
+        }
+
         protected override void Dispose(bool isDisposing)
         {
             if (isDisposing)

src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxy.cs

@@ -1380,7 +1380,10 @@ namespace Ryujinx.HLE.HOS.Services.Fs
         [CommandCmif(1016)]
         public ResultCode FlushAccessLogOnSdCard(ServiceCtx context)
         {
-            return (ResultCode)_baseFileSystemProxy.Get.FlushAccessLogOnSdCard().Value;
+            // Logging the access log to the SD card isn't implemented, meaning this function will be a no-op since
+            // there's nothing to flush. Return success until it's implemented.
+            // return (ResultCode)_baseFileSystemProxy.Get.FlushAccessLogOnSdCard().Value;
+            return ResultCode.Success;
         }
 
         [CommandCmif(1017)]

src/Ryujinx.HLE/HOS/Services/Ldn/LdnConst.cs

@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.HOS.Services.Ldn
+{
+    static class LdnConst
+    {
+        public const int SsidLengthMax = 0x20;
+        public const int AdvertiseDataSizeMax = 0x180;
+        public const int UserNameBytesMax = 0x20;
+        public const int NodeCountMax = 8;
+        public const int StationCountMax = NodeCountMax - 1;
+        public const int PassphraseLengthMax = 0x40;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/Types/LdnNetworkInfo.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types

src/Ryujinx.HLE/HOS/Services/Ldn/Types/NodeInfo.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types

src/Ryujinx.HLE/HOS/Services/Ldn/Types/NodeLatestUpdate.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types
@@ -48,7 +48,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.Types
                 {
                     result[i].Reserved = new Array7<byte>();
 
-                    if (i < 8)
+                    if (i < LdnConst.NodeCountMax)
                     {
                         result[i].State = array[i].State;
                         array[i].State = NodeLatestUpdateFlags.None;

src/Ryujinx.HLE/HOS/Services/Ldn/Types/SecurityConfig.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types

src/Ryujinx.HLE/HOS/Services/Ldn/Types/Ssid.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types

src/Ryujinx.HLE/HOS/Services/Ldn/Types/UserConfig.cs

@@ -1,4 +1,4 @@
-using Ryujinx.Common.Memory;
+using Ryujinx.Common.Memory;
 using System.Runtime.InteropServices;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.Types

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/AccessPoint.cs

@@ -1,7 +1,6 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Network.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
 using System;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
@@ -30,7 +29,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             _parent.NetworkClient.NetworkChange -= NetworkChanged;
         }
 
-        private void NetworkChanged(object sender, RyuLdn.NetworkChangeEventArgs e)
+        private void NetworkChanged(object sender, NetworkChangeEventArgs e)
         {
             LatestUpdates.CalculateLatestUpdate(NetworkInfo.Ldn.Nodes, e.Info.Ldn.Nodes);
 

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/INetworkClient.cs

@@ -1,12 +1,13 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Network.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
 using System;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
     interface INetworkClient : IDisposable
     {
+        bool NeedsRealId { get; }
+
         event EventHandler<NetworkChangeEventArgs> NetworkChange;
 
         void DisconnectNetwork();

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/IUserLocalCommunicationService.cs

@@ -8,7 +8,7 @@ using Ryujinx.Cpu;
 using Ryujinx.HLE.HOS.Ipc;
 using Ryujinx.HLE.HOS.Kernel.Threading;
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm;
 using Ryujinx.Horizon.Common;
 using Ryujinx.Memory;
 using System;
@@ -395,7 +395,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
                             }
                             else
                             {
-                                if (scanFilter.NetworkId.IntentId.LocalCommunicationId == -1)
+                                if (scanFilter.NetworkId.IntentId.LocalCommunicationId == -1 && NetworkClient.NeedsRealId)
                                 {
                                     // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
                                     ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
@@ -546,7 +546,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             context.RequestData.BaseStream.Seek(4, SeekOrigin.Current); // Alignment?
             NetworkConfig networkConfig = context.RequestData.ReadStruct<NetworkConfig>();
 
-            if (networkConfig.IntentId.LocalCommunicationId == -1)
+            if (networkConfig.IntentId.LocalCommunicationId == -1 && NetworkClient.NeedsRealId)
             {
                 // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
                 ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
@@ -555,7 +555,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             }
 
             bool isLocalCommunicationIdValid = CheckLocalCommunicationIdPermission(context, (ulong)networkConfig.IntentId.LocalCommunicationId);
-            if (!isLocalCommunicationIdValid)
+            if (!isLocalCommunicationIdValid && NetworkClient.NeedsRealId)
             {
                 return ResultCode.InvalidObject;
             }
@@ -568,13 +568,13 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             networkConfig.Channel = CheckDevelopmentChannel(networkConfig.Channel);
             securityConfig.SecurityMode = CheckDevelopmentSecurityMode(securityConfig.SecurityMode);
 
-            if (networkConfig.NodeCountMax <= 8)
+            if (networkConfig.NodeCountMax <= LdnConst.NodeCountMax)
             {
                 if ((((ulong)networkConfig.LocalCommunicationVersion) & 0x80000000) == 0)
                 {
                     if (securityConfig.SecurityMode <= SecurityMode.Retail)
                     {
-                        if (securityConfig.Passphrase.Length <= 0x40)
+                        if (securityConfig.Passphrase.Length <= LdnConst.PassphraseLengthMax)
                         {
                             if (_state == NetworkState.AccessPoint)
                             {
@@ -678,7 +678,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
                 return _nifmResultCode;
             }
 
-            if (bufferSize == 0 || bufferSize > 0x180)
+            if (bufferSize == 0 || bufferSize > LdnConst.AdvertiseDataSizeMax)
             {
                 return ResultCode.InvalidArgument;
             }
@@ -848,10 +848,10 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 
                 context.Memory.Read(bufferPosition, networkInfoBytes);
 
-                networkInfo = MemoryMarshal.Cast<byte, NetworkInfo>(networkInfoBytes)[0];
+                networkInfo = MemoryMarshal.Read<NetworkInfo>(networkInfoBytes);
             }
 
-            if (networkInfo.NetworkId.IntentId.LocalCommunicationId == -1)
+            if (networkInfo.NetworkId.IntentId.LocalCommunicationId == -1 && NetworkClient.NeedsRealId)
             {
                 // TODO: Call nn::arp::GetApplicationControlProperty here when implemented.
                 ApplicationControlProperty controlProperty = context.Device.Processes.ActiveApplication.ApplicationControlProperties;
@@ -860,7 +860,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             }
 
             bool isLocalCommunicationIdValid = CheckLocalCommunicationIdPermission(context, (ulong)networkInfo.NetworkId.IntentId.LocalCommunicationId);
-            if (!isLocalCommunicationIdValid)
+            if (!isLocalCommunicationIdValid && NetworkClient.NeedsRealId)
             {
                 return ResultCode.InvalidObject;
             }
@@ -1061,10 +1061,16 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
                     if (System.Net.NetworkInformation.NetworkInterface.GetIsNetworkAvailable())
                     {
                         MultiplayerMode mode = context.Device.Configuration.MultiplayerMode;
+
+                        Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Initializing with multiplayer mode: {mode}");
+
                         switch (mode)
                         {
+                            case MultiplayerMode.LdnMitm:
+                                NetworkClient = new LdnMitmClient(context.Device.Configuration);
+                                break;
                             case MultiplayerMode.Disabled:
-                                NetworkClient = new DisabledLdnClient();
+                                NetworkClient = new LdnDisabledClient();
                                 break;
                         }
 

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnDisabledClient.cs

@@ -1,12 +1,13 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Network.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
 using System;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
-    class DisabledLdnClient : INetworkClient
+    class LdnDisabledClient : INetworkClient
     {
+        public bool NeedsRealId => true;
+
         public event EventHandler<NetworkChangeEventArgs> NetworkChange;
 
         public NetworkError Connect(ConnectRequest request)

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/LanDiscovery.cs

@@ -0,0 +1,611 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
+{
+    internal class LanDiscovery : IDisposable
+    {
+        private const int DefaultPort = 11452;
+        private const ushort CommonChannel = 6;
+        private const byte CommonLinkLevel = 3;
+        private const byte CommonNetworkType = 2;
+
+        private const int FailureTimeout = 4000;
+
+        private readonly LdnMitmClient _parent;
+        private readonly LanProtocol _protocol;
+        private bool _initialized;
+        private readonly Ssid _fakeSsid;
+        private ILdnTcpSocket _tcp;
+        private LdnProxyUdpServer _udp, _udp2;
+        private readonly List<LdnProxyTcpSession> _stations = new();
+        private readonly object _lock = new();
+
+        private readonly AutoResetEvent _apConnected = new(false);
+
+        internal readonly IPAddress LocalAddr;
+        internal readonly IPAddress LocalBroadcastAddr;
+        internal NetworkInfo NetworkInfo;
+
+        public bool IsHost => _tcp is LdnProxyTcpServer;
+
+        private readonly Random _random = new();
+
+        // NOTE: Credit to https://stackoverflow.com/a/39338188
+        private static IPAddress GetBroadcastAddress(IPAddress address, IPAddress mask)
+        {
+            uint ipAddress = BitConverter.ToUInt32(address.GetAddressBytes(), 0);
+            uint ipMaskV4 = BitConverter.ToUInt32(mask.GetAddressBytes(), 0);
+            uint broadCastIpAddress = ipAddress | ~ipMaskV4;
+
+            return new IPAddress(BitConverter.GetBytes(broadCastIpAddress));
+        }
+
+        private static NetworkInfo GetEmptyNetworkInfo()
+        {
+            NetworkInfo networkInfo = new()
+            {
+                NetworkId = new NetworkId
+                {
+                    SessionId = new Array16<byte>(),
+                },
+                Common = new CommonNetworkInfo
+                {
+                    MacAddress = new Array6<byte>(),
+                    Ssid = new Ssid
+                    {
+                        Name = new Array33<byte>(),
+                    },
+                },
+                Ldn = new LdnNetworkInfo
+                {
+                    NodeCountMax = LdnConst.NodeCountMax,
+                    SecurityParameter = new Array16<byte>(),
+                    Nodes = new Array8<NodeInfo>(),
+                    AdvertiseData = new Array384<byte>(),
+                    Reserved4 = new Array140<byte>(),
+                },
+            };
+
+            for (int i = 0; i < LdnConst.NodeCountMax; i++)
+            {
+                networkInfo.Ldn.Nodes[i] = new NodeInfo
+                {
+                    MacAddress = new Array6<byte>(),
+                    UserName = new Array33<byte>(),
+                    Reserved2 = new Array16<byte>(),
+                };
+            }
+
+            return networkInfo;
+        }
+
+        public LanDiscovery(LdnMitmClient parent, IPAddress ipAddress, IPAddress ipv4Mask)
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Initialize LanDiscovery using IP: {ipAddress}");
+
+            _parent = parent;
+            LocalAddr = ipAddress;
+            LocalBroadcastAddr = GetBroadcastAddress(ipAddress, ipv4Mask);
+
+            _fakeSsid = new Ssid
+            {
+                Length = LdnConst.SsidLengthMax,
+            };
+            _random.NextBytes(_fakeSsid.Name.AsSpan()[..32]);
+
+            _protocol = new LanProtocol(this);
+            _protocol.Accept += OnConnect;
+            _protocol.SyncNetwork += OnSyncNetwork;
+            _protocol.DisconnectStation += DisconnectStation;
+
+            NetworkInfo = GetEmptyNetworkInfo();
+
+            ResetStations();
+
+            if (!InitUdp())
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, "LanDiscovery Initialize: InitUdp failed.");
+
+                return;
+            }
+
+            _initialized = true;
+        }
+
+        protected void OnSyncNetwork(NetworkInfo info)
+        {
+            bool updated = false;
+
+            lock (_lock)
+            {
+                if (!NetworkInfo.Equals(info))
+                {
+                    NetworkInfo = info;
+                    updated = true;
+
+                    Logger.Debug?.PrintMsg(LogClass.ServiceLdn, $"Host IP: {NetworkHelpers.ConvertUint(info.Ldn.Nodes[0].Ipv4Address)}");
+                }
+            }
+
+            if (updated)
+            {
+                _parent.InvokeNetworkChange(info, true);
+            }
+
+            _apConnected.Set();
+        }
+
+        protected void OnConnect(LdnProxyTcpSession station)
+        {
+            lock (_lock)
+            {
+                station.NodeId = LocateEmptyNode();
+
+                if (_stations.Count > LdnConst.StationCountMax || station.NodeId == -1)
+                {
+                    station.Disconnect();
+                    station.Dispose();
+
+                    return;
+                }
+
+                _stations.Add(station);
+
+                UpdateNodes();
+            }
+        }
+
+        public void DisconnectStation(LdnProxyTcpSession station)
+        {
+            if (!station.IsDisposed)
+            {
+                if (station.IsConnected)
+                {
+                    station.Disconnect();
+                }
+
+                station.Dispose();
+            }
+
+            lock (_lock)
+            {
+                if (_stations.Remove(station))
+                {
+                    NetworkInfo.Ldn.Nodes[station.NodeId] = new NodeInfo()
+                    {
+                        MacAddress = new Array6<byte>(),
+                        UserName = new Array33<byte>(),
+                        Reserved2 = new Array16<byte>(),
+                    };
+
+                    UpdateNodes();
+                }
+            }
+        }
+
+        public bool SetAdvertiseData(byte[] data)
+        {
+            if (data.Length > LdnConst.AdvertiseDataSizeMax)
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, "AdvertiseData exceeds size limit.");
+
+                return false;
+            }
+
+            data.CopyTo(NetworkInfo.Ldn.AdvertiseData.AsSpan());
+            NetworkInfo.Ldn.AdvertiseDataSize = (ushort)data.Length;
+
+            // NOTE: Otherwise this results in SessionKeepFailed or MasterDisconnected
+            lock (_lock)
+            {
+                if (NetworkInfo.Ldn.Nodes[0].IsConnected == 1)
+                {
+                    UpdateNodes(true);
+                }
+            }
+
+            return true;
+        }
+
+        public void InitNetworkInfo()
+        {
+            lock (_lock)
+            {
+                NetworkInfo.Common.MacAddress = GetFakeMac();
+                NetworkInfo.Common.Channel = CommonChannel;
+                NetworkInfo.Common.LinkLevel = CommonLinkLevel;
+                NetworkInfo.Common.NetworkType = CommonNetworkType;
+                NetworkInfo.Common.Ssid = _fakeSsid;
+
+                NetworkInfo.Ldn.Nodes = new Array8<NodeInfo>();
+
+                for (int i = 0; i < LdnConst.NodeCountMax; i++)
+                {
+                    NetworkInfo.Ldn.Nodes[i].NodeId = (byte)i;
+                    NetworkInfo.Ldn.Nodes[i].IsConnected = 0;
+                }
+            }
+        }
+
+        protected Array6<byte> GetFakeMac(IPAddress address = null)
+        {
+            address ??= LocalAddr;
+
+            byte[] ip = address.GetAddressBytes();
+
+            var macAddress = new Array6<byte>();
+            new byte[] { 0x02, 0x00, ip[0], ip[1], ip[2], ip[3] }.CopyTo(macAddress.AsSpan());
+
+            return macAddress;
+        }
+
+        public bool InitTcp(bool listening, IPAddress address = null, int port = DefaultPort)
+        {
+            Logger.Debug?.PrintMsg(LogClass.ServiceLdn, $"LanDiscovery InitTcp: IP: {address}, listening: {listening}");
+
+            if (_tcp != null)
+            {
+                _tcp.DisconnectAndStop();
+                _tcp.Dispose();
+                _tcp = null;
+            }
+
+            ILdnTcpSocket tcpSocket;
+
+            if (listening)
+            {
+                try
+                {
+                    address ??= LocalAddr;
+
+                    tcpSocket = new LdnProxyTcpServer(_protocol, address, port);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Failed to create LdnProxyTcpServer: {ex}");
+
+                    return false;
+                }
+
+                if (!tcpSocket.Start())
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                if (address == null)
+                {
+                    return false;
+                }
+
+                try
+                {
+                    tcpSocket = new LdnProxyTcpClient(_protocol, address, port);
+                }
+                catch (Exception ex)
+                {
+                    Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Failed to create LdnProxyTcpClient: {ex}");
+
+                    return false;
+                }
+            }
+
+            _tcp = tcpSocket;
+
+            return true;
+        }
+
+        public bool InitUdp()
+        {
+            _udp?.Stop();
+            _udp2?.Stop();
+
+            try
+            {
+                // NOTE: Linux won't receive any broadcast packets if the socket is not bound to the broadcast address.
+                //       Windows only works if bound to localhost or the local address.
+                //       See this discussion: https://stackoverflow.com/questions/13666789/receiving-udp-broadcast-packets-on-linux
+                if (OperatingSystem.IsLinux() || OperatingSystem.IsMacOS())
+                {
+                    _udp2 = new LdnProxyUdpServer(_protocol, LocalBroadcastAddr, DefaultPort);
+                }
+
+                _udp = new LdnProxyUdpServer(_protocol, LocalAddr, DefaultPort);
+            }
+            catch (Exception ex)
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Failed to create LdnProxyUdpServer: {ex}");
+
+                return false;
+            }
+
+            return true;
+        }
+
+        public NetworkInfo[] Scan(ushort channel, ScanFilter filter)
+        {
+            _udp.ClearScanResults();
+
+            if (_protocol.SendBroadcast(_udp, LanPacketType.Scan, DefaultPort) < 0)
+            {
+                return Array.Empty<NetworkInfo>();
+            }
+
+            List<NetworkInfo> outNetworkInfo = new();
+
+            foreach (KeyValuePair<ulong, NetworkInfo> item in _udp.GetScanResults())
+            {
+                bool copy = true;
+
+                if (filter.Flag.HasFlag(ScanFilterFlag.LocalCommunicationId))
+                {
+                    copy &= filter.NetworkId.IntentId.LocalCommunicationId == item.Value.NetworkId.IntentId.LocalCommunicationId;
+                }
+
+                if (filter.Flag.HasFlag(ScanFilterFlag.SessionId))
+                {
+                    copy &= filter.NetworkId.SessionId.AsSpan().SequenceEqual(item.Value.NetworkId.SessionId.AsSpan());
+                }
+
+                if (filter.Flag.HasFlag(ScanFilterFlag.NetworkType))
+                {
+                    copy &= filter.NetworkType == (NetworkType)item.Value.Common.NetworkType;
+                }
+
+                if (filter.Flag.HasFlag(ScanFilterFlag.Ssid))
+                {
+                    Span<byte> gameSsid = item.Value.Common.Ssid.Name.AsSpan()[item.Value.Common.Ssid.Length..];
+                    Span<byte> scanSsid = filter.Ssid.Name.AsSpan()[filter.Ssid.Length..];
+                    copy &= gameSsid.SequenceEqual(scanSsid);
+                }
+
+                if (filter.Flag.HasFlag(ScanFilterFlag.SceneId))
+                {
+                    copy &= filter.NetworkId.IntentId.SceneId == item.Value.NetworkId.IntentId.SceneId;
+                }
+
+                if (copy)
+                {
+                    if (item.Value.Ldn.Nodes[0].UserName[0] != 0)
+                    {
+                        outNetworkInfo.Add(item.Value);
+                    }
+                    else
+                    {
+                        Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "LanDiscovery Scan: Got empty Username. There might be a timing issue somewhere...");
+                    }
+                }
+            }
+
+            return outNetworkInfo.ToArray();
+        }
+
+        protected void ResetStations()
+        {
+            lock (_lock)
+            {
+                foreach (LdnProxyTcpSession station in _stations)
+                {
+                    station.Disconnect();
+                    station.Dispose();
+                }
+
+                _stations.Clear();
+            }
+        }
+
+        private int LocateEmptyNode()
+        {
+            Array8<NodeInfo> nodes = NetworkInfo.Ldn.Nodes;
+
+            for (int i = 1; i < nodes.Length; i++)
+            {
+                if (nodes[i].IsConnected == 0)
+                {
+                    return i;
+                }
+            }
+
+            return -1;
+        }
+
+        protected void UpdateNodes(bool forceUpdate = false)
+        {
+            int countConnected = 1;
+
+            foreach (LdnProxyTcpSession station in _stations.Where(station => station.IsConnected))
+            {
+                countConnected++;
+
+                station.OverrideInfo();
+
+                // NOTE: This is not part of the original implementation.
+                NetworkInfo.Ldn.Nodes[station.NodeId] = station.NodeInfo;
+            }
+
+            byte nodeCount = (byte)countConnected;
+
+            bool networkInfoChanged = forceUpdate || NetworkInfo.Ldn.NodeCount != nodeCount;
+
+            NetworkInfo.Ldn.NodeCount = nodeCount;
+
+            foreach (LdnProxyTcpSession station in _stations)
+            {
+                if (station.IsConnected)
+                {
+                    if (_protocol.SendPacket(station, LanPacketType.SyncNetwork, SpanHelpers.AsSpan<NetworkInfo, byte>(ref NetworkInfo).ToArray()) < 0)
+                    {
+                        Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Failed to send {LanPacketType.SyncNetwork} to station {station.NodeId}");
+                    }
+                }
+            }
+
+            if (networkInfoChanged)
+            {
+                _parent.InvokeNetworkChange(NetworkInfo, true);
+            }
+        }
+
+        protected NodeInfo GetNodeInfo(NodeInfo node, UserConfig userConfig, ushort localCommunicationVersion)
+        {
+            uint ipAddress = NetworkHelpers.ConvertIpv4Address(LocalAddr);
+
+            node.MacAddress = GetFakeMac();
+            node.IsConnected = 1;
+            node.UserName = userConfig.UserName;
+            node.LocalCommunicationVersion = localCommunicationVersion;
+            node.Ipv4Address = ipAddress;
+
+            return node;
+        }
+
+        public bool CreateNetwork(SecurityConfig securityConfig, UserConfig userConfig, NetworkConfig networkConfig)
+        {
+            if (!InitTcp(true))
+            {
+                return false;
+            }
+
+            InitNetworkInfo();
+
+            NetworkInfo.Ldn.NodeCountMax = networkConfig.NodeCountMax;
+            NetworkInfo.Ldn.SecurityMode = (ushort)securityConfig.SecurityMode;
+
+            NetworkInfo.Common.Channel = networkConfig.Channel == 0 ? (ushort)6 : networkConfig.Channel;
+
+            NetworkInfo.NetworkId.SessionId = new Array16<byte>();
+            _random.NextBytes(NetworkInfo.NetworkId.SessionId.AsSpan());
+            NetworkInfo.NetworkId.IntentId = networkConfig.IntentId;
+
+            NetworkInfo.Ldn.Nodes[0] = GetNodeInfo(NetworkInfo.Ldn.Nodes[0], userConfig, networkConfig.LocalCommunicationVersion);
+            NetworkInfo.Ldn.Nodes[0].IsConnected = 1;
+            NetworkInfo.Ldn.NodeCount++;
+
+            _parent.InvokeNetworkChange(NetworkInfo, true);
+
+            return true;
+        }
+
+        public void DestroyNetwork()
+        {
+            if (_tcp != null)
+            {
+                try
+                {
+                    _tcp.DisconnectAndStop();
+                }
+                finally
+                {
+                    _tcp.Dispose();
+                    _tcp = null;
+                }
+            }
+
+            ResetStations();
+        }
+
+        public NetworkError Connect(NetworkInfo networkInfo, UserConfig userConfig, uint localCommunicationVersion)
+        {
+            _apConnected.Reset();
+
+            if (networkInfo.Ldn.NodeCount == 0)
+            {
+                return NetworkError.Unknown;
+            }
+
+            IPAddress address = NetworkHelpers.ConvertUint(networkInfo.Ldn.Nodes[0].Ipv4Address);
+
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"Connecting to host: {address}");
+
+            if (!InitTcp(false, address))
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, "Could not initialize TCPClient");
+
+                return NetworkError.ConnectNotFound;
+            }
+
+            if (!_tcp.Connect())
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, "Failed to connect.");
+
+                return NetworkError.ConnectFailure;
+            }
+
+            NodeInfo myNode = GetNodeInfo(new NodeInfo(), userConfig, (ushort)localCommunicationVersion);
+            if (_protocol.SendPacket(_tcp, LanPacketType.Connect, SpanHelpers.AsSpan<NodeInfo, byte>(ref myNode).ToArray()) < 0)
+            {
+                return NetworkError.Unknown;
+            }
+
+            return _apConnected.WaitOne(FailureTimeout) ? NetworkError.None : NetworkError.ConnectTimeout;
+        }
+
+        public void Dispose()
+        {
+            if (_initialized)
+            {
+                DisconnectAndStop();
+                ResetStations();
+                _initialized = false;
+            }
+
+            _protocol.Accept -= OnConnect;
+            _protocol.SyncNetwork -= OnSyncNetwork;
+            _protocol.DisconnectStation -= DisconnectStation;
+        }
+
+        public void DisconnectAndStop()
+        {
+            if (_udp != null)
+            {
+                try
+                {
+                    _udp.Stop();
+                }
+                finally
+                {
+                    _udp.Dispose();
+                    _udp = null;
+                }
+            }
+
+            if (_udp2 != null)
+            {
+                try
+                {
+                    _udp2.Stop();
+                }
+                finally
+                {
+                    _udp2.Dispose();
+                    _udp2 = null;
+                }
+            }
+
+            if (_tcp != null)
+            {
+                try
+                {
+                    _tcp.DisconnectAndStop();
+                }
+                finally
+                {
+                    _tcp.Dispose();
+                    _tcp = null;
+                }
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/LanProtocol.cs

@@ -0,0 +1,314 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Memory;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Types;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
+{
+    internal class LanProtocol
+    {
+        private const uint LanMagic = 0x11451400;
+
+        public const int BufferSize = 2048;
+        public const int TcpTxBufferSize = 0x800;
+        public const int TcpRxBufferSize = 0x1000;
+        public const int TxBufferSizeMax = 0x2000;
+        public const int RxBufferSizeMax = 0x2000;
+
+        private readonly int _headerSize = Marshal.SizeOf<LanPacketHeader>();
+
+        private readonly LanDiscovery _discovery;
+
+        public event Action<LdnProxyTcpSession> Accept;
+        public event Action<EndPoint, LanPacketType, byte[]> Scan;
+        public event Action<NetworkInfo> ScanResponse;
+        public event Action<NetworkInfo> SyncNetwork;
+        public event Action<NodeInfo, EndPoint> Connect;
+        public event Action<LdnProxyTcpSession> DisconnectStation;
+
+        public LanProtocol(LanDiscovery parent)
+        {
+            _discovery = parent;
+        }
+
+        public void InvokeAccept(LdnProxyTcpSession session)
+        {
+            Accept?.Invoke(session);
+        }
+
+        public void InvokeDisconnectStation(LdnProxyTcpSession session)
+        {
+            DisconnectStation?.Invoke(session);
+        }
+
+        private void DecodeAndHandle(LanPacketHeader header, byte[] data, EndPoint endPoint = null)
+        {
+            switch (header.Type)
+            {
+                case LanPacketType.Scan:
+                    // UDP
+                    if (_discovery.IsHost)
+                    {
+                        Scan?.Invoke(endPoint, LanPacketType.ScanResponse, SpanHelpers.AsSpan<NetworkInfo, byte>(ref _discovery.NetworkInfo).ToArray());
+                    }
+                    break;
+                case LanPacketType.ScanResponse:
+                    // UDP
+                    ScanResponse?.Invoke(MemoryMarshal.Cast<byte, NetworkInfo>(data)[0]);
+                    break;
+                case LanPacketType.SyncNetwork:
+                    // TCP
+                    SyncNetwork?.Invoke(MemoryMarshal.Cast<byte, NetworkInfo>(data)[0]);
+                    break;
+                case LanPacketType.Connect:
+                    // TCP Session / Station
+                    Connect?.Invoke(MemoryMarshal.Cast<byte, NodeInfo>(data)[0], endPoint);
+                    break;
+                default:
+                    Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Decode error: Unhandled type {header.Type}");
+                    break;
+            }
+        }
+
+        public void Read(scoped ref byte[] buffer, scoped ref int bufferEnd, byte[] data, int offset, int size, EndPoint endPoint = null)
+        {
+            if (endPoint != null && _discovery.LocalAddr.Equals(((IPEndPoint)endPoint).Address))
+            {
+                return;
+            }
+
+            int index = 0;
+            while (index < size)
+            {
+                if (bufferEnd < _headerSize)
+                {
+                    int copyable2 = Math.Min(size - index, Math.Min(size, _headerSize - bufferEnd));
+
+                    Array.Copy(data, index + offset, buffer, bufferEnd, copyable2);
+
+                    index += copyable2;
+                    bufferEnd += copyable2;
+                }
+
+                if (bufferEnd >= _headerSize)
+                {
+                    LanPacketHeader header = MemoryMarshal.Cast<byte, LanPacketHeader>(buffer)[0];
+                    if (header.Magic != LanMagic)
+                    {
+                        bufferEnd = 0;
+
+                        Logger.Warning?.PrintMsg(LogClass.ServiceLdn, $"Invalid magic number in received packet. [magic: {header.Magic}] [EP: {endPoint}]");
+
+                        return;
+                    }
+
+                    int totalSize = _headerSize + header.Length;
+                    if (totalSize > BufferSize)
+                    {
+                        bufferEnd = 0;
+
+                        Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Max packet size {BufferSize} exceeded.");
+
+                        return;
+                    }
+
+                    int copyable = Math.Min(size - index, Math.Min(size, totalSize - bufferEnd));
+
+                    Array.Copy(data, index + offset, buffer, bufferEnd, copyable);
+
+                    index += copyable;
+                    bufferEnd += copyable;
+
+                    if (totalSize == bufferEnd)
+                    {
+                        byte[] ldnData = new byte[totalSize - _headerSize];
+                        Array.Copy(buffer, _headerSize, ldnData, 0, ldnData.Length);
+
+                        if (header.Compressed == 1)
+                        {
+                            if (Decompress(ldnData, out byte[] decompressedLdnData) != 0)
+                            {
+                                Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Decompress error:\n {header}, {_headerSize}\n {ldnData}, {ldnData.Length}");
+
+                                return;
+                            }
+
+                            if (decompressedLdnData.Length != header.DecompressLength)
+                            {
+                                Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Decompress error: length does not match. ({decompressedLdnData.Length} != {header.DecompressLength})");
+                                Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"Decompress error data: '{string.Join("", decompressedLdnData.Select(x => (int)x).ToArray())}'");
+
+                                return;
+                            }
+
+                            ldnData = decompressedLdnData;
+                        }
+
+                        DecodeAndHandle(header, ldnData, endPoint);
+
+                        bufferEnd = 0;
+                    }
+                }
+            }
+        }
+
+        public int SendBroadcast(ILdnSocket s, LanPacketType type, int port)
+        {
+            return SendPacket(s, type, Array.Empty<byte>(), new IPEndPoint(_discovery.LocalBroadcastAddr, port));
+        }
+
+        public int SendPacket(ILdnSocket s, LanPacketType type, byte[] data, EndPoint endPoint = null)
+        {
+            byte[] buf = PreparePacket(type, data);
+
+            return s.SendPacketAsync(endPoint, buf) ? 0 : -1;
+        }
+
+        public int SendPacket(LdnProxyTcpSession s, LanPacketType type, byte[] data)
+        {
+            byte[] buf = PreparePacket(type, data);
+
+            return s.SendAsync(buf) ? 0 : -1;
+        }
+
+        private LanPacketHeader PrepareHeader(LanPacketHeader header, LanPacketType type)
+        {
+            header.Magic = LanMagic;
+            header.Type = type;
+            header.Compressed = 0;
+            header.Length = 0;
+            header.DecompressLength = 0;
+            header.Reserved = new Array2<byte>();
+
+            return header;
+        }
+
+        private byte[] PreparePacket(LanPacketType type, byte[] data)
+        {
+            LanPacketHeader header = PrepareHeader(new LanPacketHeader(), type);
+            header.Length = (ushort)data.Length;
+
+            byte[] buf;
+            if (data.Length > 0)
+            {
+                if (Compress(data, out byte[] compressed) == 0)
+                {
+                    header.DecompressLength = header.Length;
+                    header.Length = (ushort)compressed.Length;
+                    header.Compressed = 1;
+
+                    buf = new byte[compressed.Length + _headerSize];
+
+                    SpanHelpers.AsSpan<LanPacketHeader, byte>(ref header).ToArray().CopyTo(buf, 0);
+                    compressed.CopyTo(buf, _headerSize);
+                }
+                else
+                {
+                    buf = new byte[data.Length + _headerSize];
+
+                    Logger.Error?.PrintMsg(LogClass.ServiceLdn, "Compressing packet data failed.");
+
+                    SpanHelpers.AsSpan<LanPacketHeader, byte>(ref header).ToArray().CopyTo(buf, 0);
+                    data.CopyTo(buf, _headerSize);
+                }
+            }
+            else
+            {
+                buf = new byte[_headerSize];
+                SpanHelpers.AsSpan<LanPacketHeader, byte>(ref header).ToArray().CopyTo(buf, 0);
+            }
+
+            return buf;
+        }
+
+        private int Compress(byte[] input, out byte[] output)
+        {
+            List<byte> outputList = new();
+            int i = 0;
+            int maxCount = 0xFF;
+
+            while (i < input.Length)
+            {
+                byte inputByte = input[i++];
+                int count = 0;
+
+                if (inputByte == 0)
+                {
+                    while (i < input.Length && input[i] == 0 && count < maxCount)
+                    {
+                        count += 1;
+                        i++;
+                    }
+                }
+
+                if (inputByte == 0)
+                {
+                    outputList.Add(0);
+
+                    if (outputList.Count == BufferSize)
+                    {
+                        output = null;
+
+                        return -1;
+                    }
+
+                    outputList.Add((byte)count);
+                }
+                else
+                {
+                    outputList.Add(inputByte);
+                }
+            }
+
+            output = outputList.ToArray();
+
+            return i == input.Length ? 0 : -1;
+        }
+
+        private int Decompress(byte[] input, out byte[] output)
+        {
+            List<byte> outputList = new();
+            int i = 0;
+
+            while (i < input.Length && outputList.Count < BufferSize)
+            {
+                byte inputByte = input[i++];
+
+                outputList.Add(inputByte);
+
+                if (inputByte == 0)
+                {
+                    if (i == input.Length)
+                    {
+                        output = null;
+
+                        return -1;
+                    }
+
+                    int count = input[i++];
+
+                    for (int j = 0; j < count; j++)
+                    {
+                        if (outputList.Count == BufferSize)
+                        {
+                            break;
+                        }
+
+                        outputList.Add(inputByte);
+                    }
+                }
+            }
+
+            output = outputList.ToArray();
+
+            return i == input.Length ? 0 : -1;
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/LdnMitmClient.cs

@@ -0,0 +1,104 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.Common.Utilities;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
+using System;
+using System.Net.NetworkInformation;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm
+{
+    /// <summary>
+    /// Client implementation for <a href="https://github.com/spacemeowx2/ldn_mitm">ldn_mitm</a>
+    /// </summary>
+    internal class LdnMitmClient : INetworkClient
+    {
+        public bool NeedsRealId => false;
+
+        public event EventHandler<NetworkChangeEventArgs> NetworkChange;
+
+        private readonly LanDiscovery _lanDiscovery;
+
+        public LdnMitmClient(HLEConfiguration config)
+        {
+            UnicastIPAddressInformation localIpInterface = NetworkHelpers.GetLocalInterface(config.MultiplayerLanInterfaceId).Item2;
+
+            _lanDiscovery = new LanDiscovery(this, localIpInterface.Address, localIpInterface.IPv4Mask);
+        }
+
+        internal void InvokeNetworkChange(NetworkInfo info, bool connected, DisconnectReason reason = DisconnectReason.None)
+        {
+            NetworkChange?.Invoke(this, new NetworkChangeEventArgs(info, connected: connected, disconnectReason: reason));
+        }
+
+        public NetworkError Connect(ConnectRequest request)
+        {
+            return _lanDiscovery.Connect(request.NetworkInfo, request.UserConfig, request.LocalCommunicationVersion);
+        }
+
+        public NetworkError ConnectPrivate(ConnectPrivateRequest request)
+        {
+            // NOTE: This method is not implemented in ldn_mitm
+            Logger.Stub?.PrintMsg(LogClass.ServiceLdn, "LdnMitmClient ConnectPrivate");
+
+            return NetworkError.None;
+        }
+
+        public bool CreateNetwork(CreateAccessPointRequest request, byte[] advertiseData)
+        {
+            return _lanDiscovery.CreateNetwork(request.SecurityConfig, request.UserConfig, request.NetworkConfig);
+        }
+
+        public bool CreateNetworkPrivate(CreateAccessPointPrivateRequest request, byte[] advertiseData)
+        {
+            // NOTE: This method is not implemented in ldn_mitm
+            Logger.Stub?.PrintMsg(LogClass.ServiceLdn, "LdnMitmClient CreateNetworkPrivate");
+
+            return true;
+        }
+
+        public void DisconnectAndStop()
+        {
+            _lanDiscovery.DisconnectAndStop();
+        }
+
+        public void DisconnectNetwork()
+        {
+            _lanDiscovery.DestroyNetwork();
+        }
+
+        public ResultCode Reject(DisconnectReason disconnectReason, uint nodeId)
+        {
+            // NOTE: This method is not implemented in ldn_mitm
+            Logger.Stub?.PrintMsg(LogClass.ServiceLdn, "LdnMitmClient Reject");
+
+            return ResultCode.Success;
+        }
+
+        public NetworkInfo[] Scan(ushort channel, ScanFilter scanFilter)
+        {
+            return _lanDiscovery.Scan(channel, scanFilter);
+        }
+
+        public void SetAdvertiseData(byte[] data)
+        {
+            _lanDiscovery.SetAdvertiseData(data);
+        }
+
+        public void SetGameVersion(byte[] versionString)
+        {
+            // NOTE: This method is not implemented in ldn_mitm
+            Logger.Stub?.PrintMsg(LogClass.ServiceLdn, "LdnMitmClient SetGameVersion");
+        }
+
+        public void SetStationAcceptPolicy(AcceptPolicy acceptPolicy)
+        {
+            // NOTE: This method is not implemented in ldn_mitm
+            Logger.Stub?.PrintMsg(LogClass.ServiceLdn, "LdnMitmClient SetStationAcceptPolicy");
+        }
+
+        public void Dispose()
+        {
+            _lanDiscovery.Dispose();
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Proxy/ILdnSocket.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Net;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy
+{
+    internal interface ILdnSocket : IDisposable
+    {
+        bool SendPacketAsync(EndPoint endpoint, byte[] buffer);
+        bool Start();
+        bool Stop();
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Proxy/ILdnTcpSocket.cs

@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy
+{
+    internal interface ILdnTcpSocket : ILdnSocket
+    {
+        bool Connect();
+        void DisconnectAndStop();
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Proxy/LdnProxyTcpClient.cs

@@ -0,0 +1,99 @@
+using Ryujinx.Common.Logging;
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy
+{
+    internal class LdnProxyTcpClient : NetCoreServer.TcpClient, ILdnTcpSocket
+    {
+        private readonly LanProtocol _protocol;
+        private byte[] _buffer;
+        private int _bufferEnd;
+
+        public LdnProxyTcpClient(LanProtocol protocol, IPAddress address, int port) : base(address, port)
+        {
+            _protocol = protocol;
+            _buffer = new byte[LanProtocol.BufferSize];
+            OptionSendBufferSize = LanProtocol.TcpTxBufferSize;
+            OptionReceiveBufferSize = LanProtocol.TcpRxBufferSize;
+            OptionSendBufferLimit = LanProtocol.TxBufferSizeMax;
+            OptionReceiveBufferLimit = LanProtocol.RxBufferSizeMax;
+        }
+
+        protected override void OnConnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyTCPClient connected!");
+        }
+
+        protected override void OnReceived(byte[] buffer, long offset, long size)
+        {
+            _protocol.Read(ref _buffer, ref _bufferEnd, buffer, (int)offset, (int)size);
+        }
+
+        public void DisconnectAndStop()
+        {
+            DisconnectAsync();
+
+            while (IsConnected)
+            {
+                Thread.Yield();
+            }
+        }
+
+        public bool SendPacketAsync(EndPoint endPoint, byte[] data)
+        {
+            if (endPoint != null)
+            {
+                Logger.Warning?.PrintMsg(LogClass.ServiceLdn, "LdnProxyTcpClient is sending a packet but endpoint is not null.");
+            }
+
+            if (IsConnecting && !IsConnected)
+            {
+                Logger.Info?.PrintMsg(LogClass.ServiceLdn, "LdnProxyTCPClient needs to connect before sending packets. Waiting...");
+
+                while (IsConnecting && !IsConnected)
+                {
+                    Thread.Yield();
+                }
+            }
+
+            return SendAsync(data);
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyTCPClient caught an error with code {error}");
+        }
+
+        protected override void Dispose(bool disposingManagedResources)
+        {
+            DisconnectAndStop();
+            base.Dispose(disposingManagedResources);
+        }
+
+        public override bool Connect()
+        {
+            // TODO: NetCoreServer has a Connect() method, but it currently leads to weird issues.
+            base.ConnectAsync();
+
+            while (IsConnecting)
+            {
+                Thread.Sleep(1);
+            }
+
+            return IsConnected;
+        }
+
+        public bool Start()
+        {
+            throw new InvalidOperationException("Start was called.");
+        }
+
+        public bool Stop()
+        {
+            throw new InvalidOperationException("Stop was called.");
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Proxy/LdnProxyTcpServer.cs

@@ -0,0 +1,54 @@
+using NetCoreServer;
+using Ryujinx.Common.Logging;
+using System;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy
+{
+    internal class LdnProxyTcpServer : TcpServer, ILdnTcpSocket
+    {
+        private readonly LanProtocol _protocol;
+
+        public LdnProxyTcpServer(LanProtocol protocol, IPAddress address, int port) : base(address, port)
+        {
+            _protocol = protocol;
+            OptionReuseAddress = true;
+            OptionSendBufferSize = LanProtocol.TcpTxBufferSize;
+            OptionReceiveBufferSize = LanProtocol.TcpRxBufferSize;
+
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyTCPServer created a server for this address: {address}:{port}");
+        }
+
+        protected override TcpSession CreateSession()
+        {
+            return new LdnProxyTcpSession(this, _protocol);
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyTCPServer caught an error with code {error}");
+        }
+
+        protected override void Dispose(bool disposingManagedResources)
+        {
+            Stop();
+            base.Dispose(disposingManagedResources);
+        }
+
+        public bool Connect()
+        {
+            throw new InvalidOperationException("Connect was called.");
+        }
+
+        public void DisconnectAndStop()
+        {
+            Stop();
+        }
+
+        public bool SendPacketAsync(EndPoint endpoint, byte[] buffer)
+        {
+            throw new InvalidOperationException("SendPacketAsync was called.");
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Proxy/LdnProxyTcpSession.cs

@@ -0,0 +1,83 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using System.Net;
+using System.Net.Sockets;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy
+{
+    internal class LdnProxyTcpSession : NetCoreServer.TcpSession
+    {
+        private readonly LanProtocol _protocol;
+
+        internal int NodeId;
+        internal NodeInfo NodeInfo;
+
+        private byte[] _buffer;
+        private int _bufferEnd;
+
+        public LdnProxyTcpSession(LdnProxyTcpServer server, LanProtocol protocol) : base(server)
+        {
+            _protocol = protocol;
+            _protocol.Connect += OnConnect;
+            _buffer = new byte[LanProtocol.BufferSize];
+            OptionSendBufferSize = LanProtocol.TcpTxBufferSize;
+            OptionReceiveBufferSize = LanProtocol.TcpRxBufferSize;
+            OptionSendBufferLimit = LanProtocol.TxBufferSizeMax;
+            OptionReceiveBufferLimit = LanProtocol.RxBufferSizeMax;
+        }
+
+        public void OverrideInfo()
+        {
+            NodeInfo.NodeId = (byte)NodeId;
+            NodeInfo.IsConnected = (byte)(IsConnected ? 1 : 0);
+        }
+
+        protected override void OnConnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, "LdnProxyTCPSession connected!");
+        }
+
+        protected override void OnDisconnected()
+        {
+            Logger.Info?.PrintMsg(LogClass.ServiceLdn, "LdnProxyTCPSession disconnected!");
+
+            _protocol.InvokeDisconnectStation(this);
+        }
+
+        protected override void OnReceived(byte[] buffer, long offset, long size)
+        {
+            _protocol.Read(ref _buffer, ref _bufferEnd, buffer, (int)offset, (int)size, this.Socket.RemoteEndPoint);
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyTCPSession caught an error with code {error}");
+
+            Dispose();
+        }
+
+        protected override void Dispose(bool disposingManagedResources)
+        {
+            _protocol.Connect -= OnConnect;
+            base.Dispose(disposingManagedResources);
+        }
+
+        private void OnConnect(NodeInfo info, EndPoint endPoint)
+        {
+            try
+            {
+                if (endPoint.Equals(this.Socket.RemoteEndPoint))
+                {
+                    NodeInfo = info;
+                    _protocol.InvokeAccept(this);
+                }
+            }
+            catch (System.ObjectDisposedException)
+            {
+                Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyTCPSession was disposed. [IP: {NodeInfo.Ipv4Address}]");
+
+                _protocol.InvokeDisconnectStation(this);
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Proxy/LdnProxyUdpServer.cs

@@ -0,0 +1,157 @@
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Ldn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Types;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Net;
+using System.Net.Sockets;
+using System.Threading;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Proxy
+{
+    internal class LdnProxyUdpServer : NetCoreServer.UdpServer, ILdnSocket
+    {
+        private const long ScanFrequency = 1000;
+
+        private readonly LanProtocol _protocol;
+        private byte[] _buffer;
+        private int _bufferEnd;
+
+        private readonly object _scanLock = new();
+
+        private Dictionary<ulong, NetworkInfo> _scanResultsLast = new();
+        private Dictionary<ulong, NetworkInfo> _scanResults = new();
+        private readonly AutoResetEvent _scanResponse = new(false);
+        private long _lastScanTime;
+
+        public LdnProxyUdpServer(LanProtocol protocol, IPAddress address, int port) : base(address, port)
+        {
+            _protocol = protocol;
+            _protocol.Scan += HandleScan;
+            _protocol.ScanResponse += HandleScanResponse;
+            _buffer = new byte[LanProtocol.BufferSize];
+            OptionReuseAddress = true;
+            OptionReceiveBufferSize = LanProtocol.RxBufferSizeMax;
+            OptionSendBufferSize = LanProtocol.TxBufferSizeMax;
+
+            Start();
+        }
+
+        protected override Socket CreateSocket()
+        {
+            return new Socket(Endpoint.AddressFamily, SocketType.Dgram, ProtocolType.Udp)
+            {
+                EnableBroadcast = true,
+            };
+        }
+
+        protected override void OnStarted()
+        {
+            ReceiveAsync();
+        }
+
+        protected override void OnReceived(EndPoint endpoint, byte[] buffer, long offset, long size)
+        {
+            _protocol.Read(ref _buffer, ref _bufferEnd, buffer, (int)offset, (int)size, endpoint);
+            ReceiveAsync();
+        }
+
+        protected override void OnError(SocketError error)
+        {
+            Logger.Error?.PrintMsg(LogClass.ServiceLdn, $"LdnProxyUdpServer caught an error with code {error}");
+        }
+
+        protected override void Dispose(bool disposingManagedResources)
+        {
+            _protocol.Scan -= HandleScan;
+            _protocol.ScanResponse -= HandleScanResponse;
+
+            _scanResponse.Dispose();
+
+            base.Dispose(disposingManagedResources);
+        }
+
+        public bool SendPacketAsync(EndPoint endpoint, byte[] data)
+        {
+            return SendAsync(endpoint, data);
+        }
+
+        private void HandleScan(EndPoint endpoint, LanPacketType type, byte[] data)
+        {
+            _protocol.SendPacket(this, type, data, endpoint);
+        }
+
+        private void HandleScanResponse(NetworkInfo info)
+        {
+            Span<byte> mac = stackalloc byte[8];
+
+            info.Common.MacAddress.AsSpan().CopyTo(mac);
+
+            lock (_scanLock)
+            {
+                _scanResults[BitConverter.ToUInt64(mac)] = info;
+
+                _scanResponse.Set();
+            }
+        }
+
+        public void ClearScanResults()
+        {
+            // Rate limit scans.
+
+            long timeMs = Stopwatch.GetTimestamp() / (Stopwatch.Frequency / 1000);
+            long delay = ScanFrequency - (timeMs - _lastScanTime);
+
+            if (delay > 0)
+            {
+                Thread.Sleep((int)delay);
+            }
+
+            _lastScanTime = timeMs;
+
+            lock (_scanLock)
+            {
+                var newResults = _scanResultsLast;
+                newResults.Clear();
+
+                _scanResultsLast = _scanResults;
+                _scanResults = newResults;
+
+                _scanResponse.Reset();
+            }
+        }
+
+        public Dictionary<ulong, NetworkInfo> GetScanResults()
+        {
+            // NOTE: Try to minimize waiting time for scan results.
+            // After we receive the first response, wait a short time for follow-ups and return.
+            // Responses that were too late to catch will appear in the next scan.
+
+            // ldn_mitm does not do this, but this improves latency for games that expect it to be low (it is on console).
+
+            if (_scanResponse.WaitOne(1000))
+            {
+                // Wait a short while longer in case there are some other responses.
+                Thread.Sleep(33);
+            }
+
+            lock (_scanLock)
+            {
+                var results = new Dictionary<ulong, NetworkInfo>();
+
+                foreach (KeyValuePair<ulong, NetworkInfo> last in _scanResultsLast)
+                {
+                    results[last.Key] = last.Value;
+                }
+
+                foreach (KeyValuePair<ulong, NetworkInfo> scan in _scanResults)
+                {
+                    results[scan.Key] = scan.Value;
+                }
+
+                return results;
+            }
+        }
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Types/LanPacketHeader.cs

@@ -0,0 +1,16 @@
+using Ryujinx.Common.Memory;
+using System.Runtime.InteropServices;
+
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Types
+{
+    [StructLayout(LayoutKind.Sequential, Size = 12)]
+    internal struct LanPacketHeader
+    {
+        public uint Magic;
+        public LanPacketType Type;
+        public byte Compressed;
+        public ushort Length;
+        public ushort DecompressLength;
+        public Array2<byte> Reserved;
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/LdnMitm/Types/LanPacketType.cs

@@ -0,0 +1,10 @@
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.LdnMitm.Types
+{
+    internal enum LanPacketType : byte
+    {
+        Scan,
+        ScanResponse,
+        Connect,
+        SyncNetwork,
+    }
+}

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/NetworkChangeEventArgs.cs

@@ -1,7 +1,7 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
 using System;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
 {
     class NetworkChangeEventArgs : EventArgs
     {

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Station.cs

@@ -1,7 +1,6 @@
 using Ryujinx.Common.Memory;
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Network.Types;
-using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types;
+using Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types;
 using System;
 
 namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
@@ -22,7 +21,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator
             _parent.NetworkClient.NetworkChange += NetworkChanged;
         }
 
-        private void NetworkChanged(object sender, RyuLdn.NetworkChangeEventArgs e)
+        private void NetworkChanged(object sender, NetworkChangeEventArgs e)
         {
             LatestUpdates.CalculateLatestUpdate(NetworkInfo.Ldn.Nodes, e.Info.Ldn.Nodes);
 

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/ConnectPrivateRequest.cs

@@ -1,7 +1,7 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
 {
     [StructLayout(LayoutKind.Sequential, Size = 0xBC)]
     struct ConnectPrivateRequest

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/ConnectRequest.cs

@@ -1,7 +1,7 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Network.Types
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
 {
     [StructLayout(LayoutKind.Sequential, Size = 0x4FC)]
     struct ConnectRequest

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/CreateAccessPointPrivateRequest.cs

@@ -1,7 +1,7 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
 {
     /// <remarks>
     /// Advertise data is appended separately (remaining data in the buffer).

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/CreateAccessPointRequest.cs

@@ -1,7 +1,7 @@
 using Ryujinx.HLE.HOS.Services.Ldn.Types;
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Network.Types
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
 {
     /// <remarks>
     /// Advertise data is appended separately (remaining data in the buffer).

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/NetworkError.cs

@@ -1,4 +1,4 @@
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
 {
     enum NetworkError : int
     {

src/Ryujinx.HLE/HOS/Services/Ldn/UserServiceCreator/Types/NetworkErrorMessage.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.RyuLdn.Types
+namespace Ryujinx.HLE.HOS.Services.Ldn.UserServiceCreator.Types
 {
     [StructLayout(LayoutKind.Sequential, Size = 0x4)]
     struct NetworkErrorMessage

src/Ryujinx.HLE/HOS/Services/ServerBase.cs

@@ -39,6 +39,8 @@ namespace Ryujinx.HLE.HOS.Services
         private readonly KernelContext _context;
         private KProcess _selfProcess;
         private KThread _selfThread;
+        private KEvent _wakeEvent;
+        private int _wakeHandle = 0;
 
         private readonly ReaderWriterLockSlim _handleLock = new();
         private readonly Dictionary<int, IpcService> _sessions = new();
@@ -125,6 +127,8 @@ namespace Ryujinx.HLE.HOS.Services
                     _handleLock.ExitWriteLock();
                 }
             }
+
+            _wakeEvent.WritableEvent.Signal();
         }
 
         private IpcService GetSessionObj(int serverSessionHandle)
@@ -187,6 +191,9 @@ namespace Ryujinx.HLE.HOS.Services
                 AddPort(serverPortHandle, SmObjectFactory);
             }
 
+            _wakeEvent = new KEvent(_context);
+            Result result = _selfProcess.HandleTable.GenerateHandle(_wakeEvent.ReadableEvent, out _wakeHandle);
+
             InitDone.Set();
 
             ulong messagePtr = _selfThread.TlsAddress;
@@ -195,7 +202,6 @@ namespace Ryujinx.HLE.HOS.Services
             _selfProcess.CpuMemory.Write(messagePtr + 0x0, 0);
             _selfProcess.CpuMemory.Write(messagePtr + 0x4, 2 << 10);
             _selfProcess.CpuMemory.Write(messagePtr + 0x8, heapAddr | ((ulong)PointerBufferSize << 48));
-
             int replyTargetHandle = 0;
 
             while (true)
@@ -211,13 +217,15 @@ namespace Ryujinx.HLE.HOS.Services
 
                     portHandleCount = _ports.Count;
 
-                    handleCount = portHandleCount + _sessions.Count;
+                    handleCount = portHandleCount + _sessions.Count + 1;
 
                     handles = ArrayPool<int>.Shared.Rent(handleCount);
 
-                    _ports.Keys.CopyTo(handles, 0);
+                    handles[0] = _wakeHandle;
 
-                    _sessions.Keys.CopyTo(handles, portHandleCount);
+                    _ports.Keys.CopyTo(handles, 1);
+
+                    _sessions.Keys.CopyTo(handles, portHandleCount + 1);
                 }
                 finally
                 {
@@ -227,8 +235,7 @@ namespace Ryujinx.HLE.HOS.Services
                     }
                 }
 
-                // We still need a timeout here to allow the service to pick up and listen new sessions...
-                var rc = _context.Syscall.ReplyAndReceive(out int signaledIndex, handles.AsSpan(0, handleCount), replyTargetHandle, 1000000L);
+                var rc = _context.Syscall.ReplyAndReceive(out int signaledIndex, handles.AsSpan(0, handleCount), replyTargetHandle, -1);
 
                 _selfThread.HandlePostSyscall();
 
@@ -239,7 +246,7 @@ namespace Ryujinx.HLE.HOS.Services
 
                 replyTargetHandle = 0;
 
-                if (rc == Result.Success && signaledIndex >= portHandleCount)
+                if (rc == Result.Success && signaledIndex >= portHandleCount + 1)
                 {
                     // We got a IPC request, process it, pass to the appropriate service if needed.
                     int signaledHandle = handles[signaledIndex];
@@ -253,24 +260,32 @@ namespace Ryujinx.HLE.HOS.Services
                 {
                     if (rc == Result.Success)
                     {
-                        // We got a new connection, accept the session to allow servicing future requests.
-                        if (_context.Syscall.AcceptSession(out int serverSessionHandle, handles[signaledIndex]) == Result.Success)
+                        if (signaledIndex > 0)
                         {
-                            bool handleWriteLockTaken = false;
-                            try
+                            // We got a new connection, accept the session to allow servicing future requests.
+                            if (_context.Syscall.AcceptSession(out int serverSessionHandle, handles[signaledIndex]) == Result.Success)
                             {
-                                handleWriteLockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
-                                IpcService obj = _ports[handles[signaledIndex]].Invoke();
-                                _sessions.Add(serverSessionHandle, obj);
-                            }
-                            finally
-                            {
-                                if (handleWriteLockTaken)
+                                bool handleWriteLockTaken = false;
+                                try
                                 {
-                                    _handleLock.ExitWriteLock();
+                                    handleWriteLockTaken = _handleLock.TryEnterWriteLock(Timeout.Infinite);
+                                    IpcService obj = _ports[handles[signaledIndex]].Invoke();
+                                    _sessions.Add(serverSessionHandle, obj);
+                                }
+                                finally
+                                {
+                                    if (handleWriteLockTaken)
+                                    {
+                                        _handleLock.ExitWriteLock();
+                                    }
                                 }
                             }
                         }
+                        else
+                        {
+                            // The _wakeEvent signalled, which means we have a new session.
+                            _wakeEvent.WritableEvent.Clear();
+                        }
                     }
 
                     _selfProcess.CpuMemory.Write(messagePtr + 0x0, 0);
@@ -499,6 +514,8 @@ namespace Ryujinx.HLE.HOS.Services
 
                 if (Interlocked.Exchange(ref _isDisposed, 1) == 0)
                 {
+                    _selfProcess.HandleTable.CloseHandle(_wakeHandle);
+
                     foreach (IpcService service in _sessions.Values)
                     {
                         (service as IDisposable)?.Dispose();

src/Ryujinx.HLE/Loaders/Processes/Extensions/PartitionFileSystemExtensions.cs

@@ -20,7 +20,11 @@ namespace Ryujinx.HLE.Loaders.Processes.Extensions
         private static readonly DownloadableContentJsonSerializerContext _contentSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
         private static readonly TitleUpdateMetadataJsonSerializerContext _titleSerializerContext = new(JsonHelper.GetDefaultSerializerOptions());
 
-        internal static (bool, ProcessResult) TryLoad(this PartitionFileSystem partitionFileSystem, Switch device, string path, out string errorMessage)
+        internal static (bool, ProcessResult) TryLoad<TMetaData, TFormat, THeader, TEntry>(this PartitionFileSystemCore<TMetaData, TFormat, THeader, TEntry> partitionFileSystem, Switch device, string path, out string errorMessage)
+            where TMetaData : PartitionFileSystemMetaCore<TFormat, THeader, TEntry>, new()
+            where TFormat : IPartitionFileSystemFormat
+            where THeader : unmanaged, IPartitionFileSystemHeader
+            where TEntry : unmanaged, IPartitionFileSystemEntry
         {
             errorMessage = null;
 
@@ -91,7 +95,8 @@ namespace Ryujinx.HLE.Loaders.Processes.Extensions
                         string updatePath = JsonHelper.DeserializeFromFile(titleUpdateMetadataPath, _titleSerializerContext.TitleUpdateMetadata).Selected;
                         if (File.Exists(updatePath))
                         {
-                            PartitionFileSystem updatePartitionFileSystem = new(new FileStream(updatePath, FileMode.Open, FileAccess.Read).AsStorage());
+                            PartitionFileSystem updatePartitionFileSystem = new();
+                            updatePartitionFileSystem.Initialize(new FileStream(updatePath, FileMode.Open, FileAccess.Read).AsStorage()).ThrowIfFailure();
 
                             device.Configuration.VirtualFileSystem.ImportTickets(updatePartitionFileSystem);
 

src/Ryujinx.HLE/Loaders/Processes/ProcessLoader.cs

@@ -69,7 +69,8 @@ namespace Ryujinx.HLE.Loaders.Processes
         public bool LoadNsp(string path)
         {
             FileStream file = new(path, FileMode.Open, FileAccess.Read);
-            PartitionFileSystem partitionFileSystem = new(file.AsStorage());
+            PartitionFileSystem partitionFileSystem = new();
+            partitionFileSystem.Initialize(file.AsStorage()).ThrowIfFailure();
 
             (bool success, ProcessResult processResult) = partitionFileSystem.TryLoad(_device, path, out string errorMessage);
 

src/Ryujinx.HLE/Loaders/Processes/ProcessLoaderHelper.cs

@@ -1,8 +1,8 @@
 using LibHac.Account;
 using LibHac.Common;
 using LibHac.Fs;
+using LibHac.Fs.Fsa;
 using LibHac.Fs.Shim;
-using LibHac.FsSystem;
 using LibHac.Loader;
 using LibHac.Ncm;
 using LibHac.Ns;
@@ -33,7 +33,7 @@ namespace Ryujinx.HLE.Loaders.Processes
         // TODO: Remove this workaround when ASLR is implemented.
         private const ulong CodeStartOffset = 0x500000UL;
 
-        public static LibHac.Result RegisterProgramMapInfo(Switch device, PartitionFileSystem partitionFileSystem)
+        public static LibHac.Result RegisterProgramMapInfo(Switch device, IFileSystem partitionFileSystem)
         {
             ulong applicationId = 0;
             int programCount = 0;

src/Ryujinx.HLE/Ryujinx.HLE.csproj

@@ -27,6 +27,7 @@
     <PackageReference Include="SixLabors.ImageSharp" />
     <PackageReference Include="SixLabors.ImageSharp.Drawing" />
     <PackageReference Include="System.IdentityModel.Tokens.Jwt" />
+    <PackageReference Include="NetCoreServer" />
   </ItemGroup>
 
   <!-- Due to Concentus. -->

src/Ryujinx.Memory/AddressSpaceManager.cs

@@ -455,6 +455,11 @@ namespace Ryujinx.Memory
             return _pageTable.Read(va) + (nuint)(va & PageMask);
         }
 
+        /// <inheritdoc/>
+        public void Reprotect(ulong va, ulong size, MemoryPermission protection)
+        {
+        }
+
         /// <inheritdoc/>
         public void TrackingReprotect(ulong va, ulong size, MemoryPermission protection)
         {

src/Ryujinx.Memory/IVirtualMemoryManager.cs

@@ -104,6 +104,12 @@ namespace Ryujinx.Memory
         /// <returns>True if the data was changed, false otherwise</returns>
         bool WriteWithRedundancyCheck(ulong va, ReadOnlySpan<byte> data);
 
+        /// <summary>
+        /// Fills the specified memory region with the value specified in <paramref name="value"/>.
+        /// </summary>
+        /// <param name="va">Virtual address to fill the value into</param>
+        /// <param name="size">Size of the memory region to fill</param>
+        /// <param name="value">Value to fill with</param>
         void Fill(ulong va, ulong size, byte value)
         {
             const int MaxChunkSize = 1 << 24;
@@ -194,6 +200,14 @@ namespace Ryujinx.Memory
         /// <param name="exemptId">Optional ID of the handles that should not be signalled</param>
         void SignalMemoryTracking(ulong va, ulong size, bool write, bool precise = false, int? exemptId = null);
 
+        /// <summary>
+        /// Reprotect a region of virtual memory for guest access.
+        /// </summary>
+        /// <param name="va">Virtual address base</param>
+        /// <param name="size">Size of the region to protect</param>
+        /// <param name="protection">Memory protection to set</param>
+        void Reprotect(ulong va, ulong size, MemoryPermission protection);
+
         /// <summary>
         /// Reprotect a region of virtual memory for tracking.
         /// </summary>

src/Ryujinx.Tests.Memory/MockVirtualMemoryManager.cs

@@ -102,6 +102,11 @@ namespace Ryujinx.Tests.Memory
             throw new NotImplementedException();
         }
 
+        public void Reprotect(ulong va, ulong size, MemoryPermission protection)
+        {
+            throw new NotImplementedException();
+        }
+
         public void TrackingReprotect(ulong va, ulong size, MemoryPermission protection)
         {
             OnProtect?.Invoke(va, size, protection);

src/Ryujinx.Ui.Common/App/ApplicationData.cs

@@ -9,10 +9,9 @@ using LibHac.Tools.FsSystem;
 using LibHac.Tools.FsSystem.NcaUtils;
 using Ryujinx.Common.Logging;
 using Ryujinx.HLE.FileSystem;
+using Ryujinx.Ui.Common.Helper;
 using System;
-using System.Globalization;
 using System.IO;
-using System.Text.Json.Serialization;
 
 namespace Ryujinx.Ui.App.Common
 {
@@ -24,29 +23,18 @@ namespace Ryujinx.Ui.App.Common
         public string TitleId { get; set; }
         public string Developer { get; set; }
         public string Version { get; set; }
-        public string TimePlayed { get; set; }
-        public double TimePlayedNum { get; set; }
+        public TimeSpan TimePlayed { get; set; }
         public DateTime? LastPlayed { get; set; }
         public string FileExtension { get; set; }
-        public string FileSize { get; set; }
-        public double FileSizeBytes { get; set; }
+        public long FileSize { get; set; }
         public string Path { get; set; }
         public BlitStruct<ApplicationControlProperty> ControlHolder { get; set; }
 
-        [JsonIgnore]
-        public string LastPlayedString
-        {
-            get
-            {
-                if (!LastPlayed.HasValue)
-                {
-                    // TODO: maybe put localized string here instead of just "Never"
-                    return "Never";
-                }
+        public string TimePlayedString => ValueFormatUtils.FormatTimeSpan(TimePlayed);
 
-                return LastPlayed.Value.ToLocalTime().ToString(CultureInfo.CurrentCulture);
-            }
-        }
+        public string LastPlayedString => ValueFormatUtils.FormatDateTime(LastPlayed);
+
+        public string FileSizeString => ValueFormatUtils.FormatFileSize(FileSize);
 
         public static string GetApplicationBuildId(VirtualFileSystem virtualFileSystem, string titleFilePath)
         {
@@ -65,7 +53,7 @@ namespace Ryujinx.Ui.App.Common
 
             if (extension is ".nsp" or ".xci")
             {
-                PartitionFileSystem pfs;
+                IFileSystem pfs;
 
                 if (extension == ".xci")
                 {
@@ -75,7 +63,9 @@ namespace Ryujinx.Ui.App.Common
                 }
                 else
                 {
-                    pfs = new PartitionFileSystem(file.AsStorage());
+                    var pfsTemp = new PartitionFileSystem();
+                    pfsTemp.Initialize(file.AsStorage()).ThrowIfFailure();
+                    pfs = pfsTemp;
                 }
 
                 foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))

src/Ryujinx.Ui.Common/App/ApplicationLibrary.cs

@@ -155,7 +155,7 @@ namespace Ryujinx.Ui.App.Common
                         return;
                     }
 
-                    double fileSize = new FileInfo(applicationPath).Length * 0.000000000931;
+                    long fileSize = new FileInfo(applicationPath).Length;
                     string titleName = "Unknown";
                     string titleId = "0000000000000000";
                     string developer = "Unknown";
@@ -174,7 +174,7 @@ namespace Ryujinx.Ui.App.Common
                         {
                             try
                             {
-                                PartitionFileSystem pfs;
+                                IFileSystem pfs;
 
                                 bool isExeFs = false;
 
@@ -186,7 +186,9 @@ namespace Ryujinx.Ui.App.Common
                                 }
                                 else
                                 {
-                                    pfs = new PartitionFileSystem(file.AsStorage());
+                                    var pfsTemp = new PartitionFileSystem();
+                                    pfsTemp.Initialize(file.AsStorage()).ThrowIfFailure();
+                                    pfs = pfsTemp;
 
                                     // If the NSP doesn't have a main NCA, decrement the number of applications found and then continue to the next application.
                                     bool hasMainNca = false;
@@ -423,25 +425,25 @@ namespace Ryujinx.Ui.App.Common
                     {
                         appMetadata.Title = titleName;
 
-                        if (appMetadata.LastPlayedOld == default || appMetadata.LastPlayed.HasValue)
+                        // Only do the migration if time_played has a value and timespan_played hasn't been updated yet.
+                        if (appMetadata.TimePlayedOld != default && appMetadata.TimePlayed == TimeSpan.Zero)
                         {
-                            // Don't do the migration if last_played doesn't exist or last_played_utc already has a value.
-                            return;
+                            appMetadata.TimePlayed = TimeSpan.FromSeconds(appMetadata.TimePlayedOld);
+                            appMetadata.TimePlayedOld = default;
                         }
 
-                        // Migrate from string-based last_played to DateTime-based last_played_utc.
-                        if (DateTime.TryParse(appMetadata.LastPlayedOld, out DateTime lastPlayedOldParsed))
+                        // Only do the migration if last_played has a value and last_played_utc doesn't exist yet.
+                        if (appMetadata.LastPlayedOld != default && !appMetadata.LastPlayed.HasValue)
                         {
-                            Logger.Info?.Print(LogClass.Application, $"last_played found: \"{appMetadata.LastPlayedOld}\", migrating to last_played_utc");
-                            appMetadata.LastPlayed = lastPlayedOldParsed;
+                            // Migrate from string-based last_played to DateTime-based last_played_utc.
+                            if (DateTime.TryParse(appMetadata.LastPlayedOld, out DateTime lastPlayedOldParsed))
+                            {
+                                appMetadata.LastPlayed = lastPlayedOldParsed;
+
+                                // Migration successful: deleting last_played from the metadata file.
+                                appMetadata.LastPlayedOld = default;
+                            }
 
-                            // Migration successful: deleting last_played from the metadata file.
-                            appMetadata.LastPlayedOld = default;
-                        }
-                        else
-                        {
-                            // Migration failed: emitting warning but leaving the unparsable value in the metadata file so the user can fix it.
-                            Logger.Warning?.Print(LogClass.Application, $"Last played string \"{appMetadata.LastPlayedOld}\" is invalid for current system culture, skipping (did current culture change?)");
                         }
                     });
 
@@ -453,12 +455,10 @@ namespace Ryujinx.Ui.App.Common
                         TitleId = titleId,
                         Developer = developer,
                         Version = version,
-                        TimePlayed = ConvertSecondsToFormattedString(appMetadata.TimePlayed),
-                        TimePlayedNum = appMetadata.TimePlayed,
+                        TimePlayed = appMetadata.TimePlayed,
                         LastPlayed = appMetadata.LastPlayed,
-                        FileExtension = Path.GetExtension(applicationPath).ToUpper().Remove(0, 1),
-                        FileSize = (fileSize < 1) ? (fileSize * 1024).ToString("0.##") + " MiB" : fileSize.ToString("0.##") + " GiB",
-                        FileSizeBytes = fileSize,
+                        FileExtension = Path.GetExtension(applicationPath).TrimStart('.').ToUpper(),
+                        FileSize = fileSize,
                         Path = applicationPath,
                         ControlHolder = controlHolder,
                     };
@@ -500,7 +500,7 @@ namespace Ryujinx.Ui.App.Common
             ApplicationCountUpdated?.Invoke(null, e);
         }
 
-        private void GetControlFsAndTitleId(PartitionFileSystem pfs, out IFileSystem controlFs, out string titleId)
+        private void GetControlFsAndTitleId(IFileSystem pfs, out IFileSystem controlFs, out string titleId)
         {
             (_, _, Nca controlNca) = GetGameData(_virtualFileSystem, pfs, 0);
 
@@ -563,7 +563,7 @@ namespace Ryujinx.Ui.App.Common
                     {
                         try
                         {
-                            PartitionFileSystem pfs;
+                            IFileSystem pfs;
 
                             bool isExeFs = false;
 
@@ -575,7 +575,9 @@ namespace Ryujinx.Ui.App.Common
                             }
                             else
                             {
-                                pfs = new PartitionFileSystem(file.AsStorage());
+                                var pfsTemp = new PartitionFileSystem();
+                                pfsTemp.Initialize(file.AsStorage()).ThrowIfFailure();
+                                pfs = pfsTemp;
 
                                 foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*"))
                                 {
@@ -712,31 +714,6 @@ namespace Ryujinx.Ui.App.Common
             return applicationIcon ?? _ncaIcon;
         }
 
-        private static string ConvertSecondsToFormattedString(double seconds)
-        {
-            TimeSpan time = TimeSpan.FromSeconds(seconds);
-
-            string timeString;
-            if (time.Days != 0)
-            {
-                timeString = $"{time.Days}d {time.Hours:D2}h {time.Minutes:D2}m";
-            }
-            else if (time.Hours != 0)
-            {
-                timeString = $"{time.Hours:D2}h {time.Minutes:D2}m";
-            }
-            else if (time.Minutes != 0)
-            {
-                timeString = $"{time.Minutes:D2}m";
-            }
-            else
-            {
-                timeString = "Never";
-            }
-
-            return timeString;
-        }
-
         private void GetGameInformation(ref ApplicationControlProperty controlData, out string titleName, out string titleId, out string publisher, out string version)
         {
             _ = Enum.TryParse(_desiredTitleLanguage.ToString(), out TitleLanguage desiredTitleLanguage);
@@ -827,7 +804,7 @@ namespace Ryujinx.Ui.App.Common
             return false;
         }
 
-        public static (Nca main, Nca patch, Nca control) GetGameData(VirtualFileSystem fileSystem, PartitionFileSystem pfs, int programIndex)
+        public static (Nca main, Nca patch, Nca control) GetGameData(VirtualFileSystem fileSystem, IFileSystem pfs, int programIndex)
         {
             Nca mainNca = null;
             Nca patchNca = null;
@@ -931,7 +908,8 @@ namespace Ryujinx.Ui.App.Common
                     if (File.Exists(updatePath))
                     {
                         FileStream file = new(updatePath, FileMode.Open, FileAccess.Read);
-                        PartitionFileSystem nsp = new(file.AsStorage());
+                        PartitionFileSystem nsp = new();
+                        nsp.Initialize(file.AsStorage()).ThrowIfFailure();
 
                         return GetGameUpdateDataFromPartition(fileSystem, nsp, titleIdBase.ToString("x16"), programIndex);
                     }

src/Ryujinx.Ui.Common/App/ApplicationMetadata.cs

@@ -7,13 +7,45 @@ namespace Ryujinx.Ui.App.Common
     {
         public string Title { get; set; }
         public bool Favorite { get; set; }
-        public double TimePlayed { get; set; }
+
+        [JsonPropertyName("timespan_played")]
+        public TimeSpan TimePlayed { get; set; } = TimeSpan.Zero;
 
         [JsonPropertyName("last_played_utc")]
         public DateTime? LastPlayed { get; set; } = null;
 
+        [JsonPropertyName("time_played")]
+        [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
+        public double TimePlayedOld { get; set; }
+
         [JsonPropertyName("last_played")]
         [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingDefault)]
         public string LastPlayedOld { get; set; }
+
+        /// <summary>
+        /// Updates <see cref="LastPlayed"/>. Call this before launching a game.
+        /// </summary>
+        public void UpdatePreGame()
+        {
+            LastPlayed = DateTime.UtcNow;
+        }
+
+        /// <summary>
+        /// Updates <see cref="LastPlayed"/> and <see cref="TimePlayed"/>. Call this after a game ends.
+        /// </summary>
+        public void UpdatePostGame()
+        {
+            DateTime? prevLastPlayed = LastPlayed;
+            UpdatePreGame();
+
+            if (!prevLastPlayed.HasValue)
+            {
+                return;
+            }
+
+            TimeSpan diff = DateTime.UtcNow - prevLastPlayed.Value;
+            double newTotalSeconds = TimePlayed.Add(diff).TotalSeconds;
+            TimePlayed = TimeSpan.FromSeconds(Math.Round(newTotalSeconds, MidpointRounding.AwayFromZero));
+        }
     }
 }

src/Ryujinx.Ui.Common/Configuration/ConfigurationState.cs

@@ -571,6 +571,7 @@ namespace Ryujinx.Ui.Common.Configuration
             {
                 LanInterfaceId = new ReactiveObject<string>();
                 Mode = new ReactiveObject<MultiplayerMode>();
+                Mode.Event += static (_, e) => LogValueChange(e, nameof(MultiplayerMode));
             }
         }
 

src/Ryujinx.Ui.Common/Helper/ValueFormatUtils.cs

@@ -0,0 +1,219 @@
+using System;
+using System.Globalization;
+using System.Linq;
+
+namespace Ryujinx.Ui.Common.Helper
+{
+    public static class ValueFormatUtils
+    {
+        private static readonly string[] _fileSizeUnitStrings =
+        {
+            "B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB",  // Base 10 units, used for formatting and parsing
+            "KB", "MB", "GB", "TB", "PB", "EB",             // Base 2 units, used for parsing legacy values
+        };
+
+        /// <summary>
+        /// Used by <see cref="FormatFileSize"/>.
+        /// </summary>
+        public enum FileSizeUnits
+        {
+            Auto = -1,
+            Bytes = 0,
+            Kibibytes = 1,
+            Mebibytes = 2,
+            Gibibytes = 3,
+            Tebibytes = 4,
+            Pebibytes = 5,
+            Exbibytes = 6,
+            Kilobytes = 7,
+            Megabytes = 8,
+            Gigabytes = 9,
+            Terabytes = 10,
+            Petabytes = 11,
+            Exabytes = 12,
+        }
+
+        private const double SizeBase10 = 1000;
+        private const double SizeBase2 = 1024;
+        private const int UnitEBIndex = 6;
+
+        #region Value formatters
+
+        /// <summary>
+        /// Creates a human-readable string from a <see cref="TimeSpan"/>.
+        /// </summary>
+        /// <param name="timeSpan">The <see cref="TimeSpan"/> to be formatted.</param>
+        /// <returns>A formatted string that can be displayed in the UI.</returns>
+        public static string FormatTimeSpan(TimeSpan? timeSpan)
+        {
+            if (!timeSpan.HasValue || timeSpan.Value.TotalSeconds < 1)
+            {
+                // Game was never played
+                return TimeSpan.Zero.ToString("c", CultureInfo.InvariantCulture);
+            }
+
+            if (timeSpan.Value.TotalDays < 1)
+            {
+                // Game was played for less than a day
+                return timeSpan.Value.ToString("c", CultureInfo.InvariantCulture);
+            }
+
+            // Game was played for more than a day
+            TimeSpan onlyTime = timeSpan.Value.Subtract(TimeSpan.FromDays(timeSpan.Value.Days));
+            string onlyTimeString = onlyTime.ToString("c", CultureInfo.InvariantCulture);
+
+            return $"{timeSpan.Value.Days}d, {onlyTimeString}";
+        }
+
+        /// <summary>
+        /// Creates a human-readable string from a <see cref="DateTime"/>.
+        /// </summary>
+        /// <param name="utcDateTime">The <see cref="DateTime"/> to be formatted. This is expected to be UTC-based.</param>
+        /// <param name="culture">The <see cref="CultureInfo"/> that's used in formatting. Defaults to <see cref="CultureInfo.CurrentCulture"/>.</param>
+        /// <returns>A formatted string that can be displayed in the UI.</returns>
+        public static string FormatDateTime(DateTime? utcDateTime, CultureInfo culture = null)
+        {
+            culture ??= CultureInfo.CurrentCulture;
+
+            if (!utcDateTime.HasValue)
+            {
+                // In the Avalonia UI, this is turned into a localized version of "Never" by LocalizedNeverConverter.
+                return "Never";
+            }
+
+            return utcDateTime.Value.ToLocalTime().ToString(culture);
+        }
+
+        /// <summary>
+        /// Creates a human-readable file size string.
+        /// </summary>
+        /// <param name="size">The file size in bytes.</param>
+        /// <param name="forceUnit">Formats the passed size value as this unit, bypassing the automatic unit choice.</param>
+        /// <returns>A human-readable file size string.</returns>
+        public static string FormatFileSize(long size, FileSizeUnits forceUnit = FileSizeUnits.Auto)
+        {
+            if (size <= 0)
+            {
+                return $"0 {_fileSizeUnitStrings[0]}";
+            }
+
+            int unitIndex = (int)forceUnit;
+            if (forceUnit == FileSizeUnits.Auto)
+            {
+                unitIndex = Convert.ToInt32(Math.Floor(Math.Log(size, SizeBase10)));
+
+                // Apply an upper bound so that exabytes are the biggest unit used when formatting.
+                if (unitIndex > UnitEBIndex)
+                {
+                    unitIndex = UnitEBIndex;
+                }
+            }
+
+            double sizeRounded;
+
+            if (unitIndex > UnitEBIndex)
+            {
+                sizeRounded = Math.Round(size / Math.Pow(SizeBase10, unitIndex - UnitEBIndex), 1);
+            }
+            else
+            {
+                sizeRounded = Math.Round(size / Math.Pow(SizeBase2, unitIndex), 1);
+            }
+
+            string sizeFormatted = sizeRounded.ToString(CultureInfo.InvariantCulture);
+
+            return $"{sizeFormatted} {_fileSizeUnitStrings[unitIndex]}";
+        }
+
+        #endregion
+
+        #region Value parsers
+
+        /// <summary>
+        /// Parses a string generated by <see cref="FormatTimeSpan"/> and returns the original <see cref="TimeSpan"/>.
+        /// </summary>
+        /// <param name="timeSpanString">A string representing a <see cref="TimeSpan"/>.</param>
+        /// <returns>A <see cref="TimeSpan"/> object. If the input string couldn't been parsed, <see cref="TimeSpan.Zero"/> is returned.</returns>
+        public static TimeSpan ParseTimeSpan(string timeSpanString)
+        {
+            TimeSpan returnTimeSpan = TimeSpan.Zero;
+
+            // An input string can either look like "01:23:45" or "1d, 01:23:45" if the timespan represents a duration of more than a day.
+            // Here, we split the input string to check if it's the former or the latter.
+            var valueSplit = timeSpanString.Split(", ");
+            if (valueSplit.Length > 1)
+            {
+                var dayPart = valueSplit[0].Split("d")[0];
+                if (int.TryParse(dayPart, out int days))
+                {
+                    returnTimeSpan = returnTimeSpan.Add(TimeSpan.FromDays(days));
+                }
+            }
+
+            if (TimeSpan.TryParse(valueSplit.Last(), out TimeSpan parsedTimeSpan))
+            {
+                returnTimeSpan = returnTimeSpan.Add(parsedTimeSpan);
+            }
+
+            return returnTimeSpan;
+        }
+
+        /// <summary>
+        /// Parses a string generated by <see cref="FormatDateTime"/> and returns the original <see cref="DateTime"/>.
+        /// </summary>
+        /// <param name="dateTimeString">The string representing a <see cref="DateTime"/>.</param>
+        /// <returns>A <see cref="DateTime"/> object. If the input string couldn't be parsed, <see cref="DateTime.UnixEpoch"/> is returned.</returns>
+        public static DateTime ParseDateTime(string dateTimeString)
+        {
+            if (!DateTime.TryParse(dateTimeString, CultureInfo.CurrentCulture, out DateTime parsedDateTime))
+            {
+                // Games that were never played are supposed to appear before the oldest played games in the list,
+                // so returning DateTime.UnixEpoch here makes sense.
+                return DateTime.UnixEpoch;
+            }
+
+            return parsedDateTime;
+        }
+
+        /// <summary>
+        /// Parses a string generated by <see cref="FormatFileSize"/> and returns a <see cref="long"/> representing a number of bytes.
+        /// </summary>
+        /// <param name="sizeString">A string representing a file size formatted with <see cref="FormatFileSize"/>.</param>
+        /// <returns>A <see cref="long"/> representing a number of bytes.</returns>
+        public static long ParseFileSize(string sizeString)
+        {
+            // Enumerating over the units backwards because otherwise, sizeString.EndsWith("B") would exit the loop in the first iteration.
+            for (int i = _fileSizeUnitStrings.Length - 1; i >= 0; i--)
+            {
+                string unit = _fileSizeUnitStrings[i];
+                if (!sizeString.EndsWith(unit))
+                {
+                    continue;
+                }
+
+                string numberString = sizeString.Split(" ")[0];
+                if (!double.TryParse(numberString, CultureInfo.InvariantCulture, out double number))
+                {
+                    break;
+                }
+
+                double sizeBase = SizeBase2;
+
+                // If the unit index is one that points to a base 10 unit in the FileSizeUnitStrings array, subtract 6 to arrive at a usable power value.
+                if (i > UnitEBIndex)
+                {
+                    i -= UnitEBIndex;
+                    sizeBase = SizeBase10;
+                }
+
+                number *= Math.Pow(sizeBase, i);
+
+                return Convert.ToInt64(number);
+            }
+
+            return 0;
+        }
+
+        #endregion
+    }
+}

src/Ryujinx.Ui.Common/SystemInfo/LinuxSystemInfo.cs

@@ -5,7 +5,7 @@ using System.Globalization;
 using System.IO;
 using System.Runtime.Versioning;
 
-namespace Ryujinx.Common.SystemInfo
+namespace Ryujinx.Ui.Common.SystemInfo
 {
     [SupportedOSPlatform("linux")]
     class LinuxSystemInfo : SystemInfo

src/Ryujinx.Ui.Common/SystemInfo/MacOSSystemInfo.cs

@@ -5,13 +5,20 @@ using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 using System.Text;
 
-namespace Ryujinx.Common.SystemInfo
+namespace Ryujinx.Ui.Common.SystemInfo
 {
     [SupportedOSPlatform("macos")]
     partial class MacOSSystemInfo : SystemInfo
     {
         internal MacOSSystemInfo()
         {
+            if (SysctlByName("kern.osversion", out string buildRevision) != 0)
+            {
+                buildRevision = "Unknown Build";
+            }
+
+            OsDescription = $"macOS {Environment.OSVersion.Version} ({buildRevision}) ({RuntimeInformation.OSArchitecture})";
+
             string cpuName = GetCpuidCpuName();
 
             if (cpuName == null && SysctlByName("machdep.cpu.brand_string", out cpuName) != 0)

src/Ryujinx.Ui.Common/SystemInfo/SystemInfo.cs

@@ -1,10 +1,11 @@
 using Ryujinx.Common.Logging;
+using Ryujinx.Ui.Common.Helper;
 using System;
 using System.Runtime.InteropServices;
 using System.Runtime.Intrinsics.X86;
 using System.Text;
 
-namespace Ryujinx.Common.SystemInfo
+namespace Ryujinx.Ui.Common.SystemInfo
 {
     public class SystemInfo
     {
@@ -20,13 +21,13 @@ namespace Ryujinx.Common.SystemInfo
             CpuName = "Unknown";
         }
 
-        private static string ToMiBString(ulong bytesValue) => (bytesValue == 0) ? "Unknown" : $"{bytesValue / 1024 / 1024} MiB";
+        private static string ToGBString(ulong bytesValue) => (bytesValue == 0) ? "Unknown" : ValueFormatUtils.FormatFileSize((long)bytesValue, ValueFormatUtils.FileSizeUnits.Gibibytes);
 
         public void Print()
         {
             Logger.Notice.Print(LogClass.Application, $"Operating System: {OsDescription}");
             Logger.Notice.Print(LogClass.Application, $"CPU: {CpuName}");
-            Logger.Notice.Print(LogClass.Application, $"RAM: Total {ToMiBString(RamTotal)} ; Available {ToMiBString(RamAvailable)}");
+            Logger.Notice.Print(LogClass.Application, $"RAM: Total {ToGBString(RamTotal)} ; Available {ToGBString(RamAvailable)}");
         }
 
         public static SystemInfo Gather()

src/Ryujinx.Ui.Common/SystemInfo/WindowsSystemInfo.cs

@@ -4,7 +4,7 @@ using System.Management;
 using System.Runtime.InteropServices;
 using System.Runtime.Versioning;
 
-namespace Ryujinx.Common.SystemInfo
+namespace Ryujinx.Ui.Common.SystemInfo
 {
     [SupportedOSPlatform("windows")]
     partial class WindowsSystemInfo : SystemInfo

src/Ryujinx/Program.cs

@@ -3,7 +3,6 @@ using Ryujinx.Common;
 using Ryujinx.Common.Configuration;
 using Ryujinx.Common.GraphicsDriver;
 using Ryujinx.Common.Logging;
-using Ryujinx.Common.SystemInfo;
 using Ryujinx.Common.SystemInterop;
 using Ryujinx.Modules;
 using Ryujinx.SDL2.Common;
@@ -11,6 +10,7 @@ using Ryujinx.Ui;
 using Ryujinx.Ui.Common;
 using Ryujinx.Ui.Common.Configuration;
 using Ryujinx.Ui.Common.Helper;
+using Ryujinx.Ui.Common.SystemInfo;
 using Ryujinx.Ui.Widgets;
 using SixLabors.ImageSharp.Formats.Jpeg;
 using System;

src/Ryujinx/Ui/Helper/SortHelper.cs

@@ -1,4 +1,5 @@
 using Gtk;
+using Ryujinx.Ui.Common.Helper;
 using System;
 
 namespace Ryujinx.Ui.Helper
@@ -7,88 +8,26 @@ namespace Ryujinx.Ui.Helper
     {
         public static int TimePlayedSort(ITreeModel model, TreeIter a, TreeIter b)
         {
-            static string ReverseFormat(string time)
-            {
-                if (time == "Never")
-                {
-                    return "00";
-                }
+            TimeSpan aTimeSpan = ValueFormatUtils.ParseTimeSpan(model.GetValue(a, 5).ToString());
+            TimeSpan bTimeSpan = ValueFormatUtils.ParseTimeSpan(model.GetValue(b, 5).ToString());
 
-                var numbers = time.Split(new char[] { 'd', 'h', 'm' });
-
-                time = time.Replace(" ", "").Replace("d", ".").Replace("h", ":").Replace("m", "");
-
-                if (numbers.Length == 2)
-                {
-                    return $"00.00:{time}";
-                }
-                else if (numbers.Length == 3)
-                {
-                    return $"00.{time}";
-                }
-
-                return time;
-            }
-
-            string aValue = ReverseFormat(model.GetValue(a, 5).ToString());
-            string bValue = ReverseFormat(model.GetValue(b, 5).ToString());
-
-            return TimeSpan.Compare(TimeSpan.Parse(aValue), TimeSpan.Parse(bValue));
+            return TimeSpan.Compare(aTimeSpan, bTimeSpan);
         }
 
         public static int LastPlayedSort(ITreeModel model, TreeIter a, TreeIter b)
         {
-            string aValue = model.GetValue(a, 6).ToString();
-            string bValue = model.GetValue(b, 6).ToString();
+            DateTime aDateTime = ValueFormatUtils.ParseDateTime(model.GetValue(a, 6).ToString());
+            DateTime bDateTime = ValueFormatUtils.ParseDateTime(model.GetValue(b, 6).ToString());
 
-            if (aValue == "Never")
-            {
-                aValue = DateTime.UnixEpoch.ToString();
-            }
-
-            if (bValue == "Never")
-            {
-                bValue = DateTime.UnixEpoch.ToString();
-            }
-
-            return DateTime.Compare(DateTime.Parse(bValue), DateTime.Parse(aValue));
+            return DateTime.Compare(aDateTime, bDateTime);
         }
 
         public static int FileSizeSort(ITreeModel model, TreeIter a, TreeIter b)
         {
-            string aValue = model.GetValue(a, 8).ToString();
-            string bValue = model.GetValue(b, 8).ToString();
+            long aSize = ValueFormatUtils.ParseFileSize(model.GetValue(a, 8).ToString());
+            long bSize = ValueFormatUtils.ParseFileSize(model.GetValue(b, 8).ToString());
 
-            if (aValue[^3..] == "GiB")
-            {
-                aValue = (float.Parse(aValue[0..^3]) * 1024).ToString();
-            }
-            else
-            {
-                aValue = aValue[0..^3];
-            }
-
-            if (bValue[^3..] == "GiB")
-            {
-                bValue = (float.Parse(bValue[0..^3]) * 1024).ToString();
-            }
-            else
-            {
-                bValue = bValue[0..^3];
-            }
-
-            if (float.Parse(aValue) > float.Parse(bValue))
-            {
-                return -1;
-            }
-            else if (float.Parse(bValue) > float.Parse(aValue))
-            {
-                return 1;
-            }
-            else
-            {
-                return 0;
-            }
+            return aSize.CompareTo(bSize);
         }
     }
 }

src/Ryujinx/Ui/MainWindow.cs

@@ -954,7 +954,7 @@ namespace Ryujinx.Ui
 
                 ApplicationLibrary.LoadAndSaveMetaData(_emulationContext.Processes.ActiveApplication.ProgramIdText, appMetadata =>
                 {
-                    appMetadata.LastPlayed = DateTime.UtcNow;
+                    appMetadata.UpdatePreGame();
                 });
             }
         }
@@ -1097,13 +1097,7 @@ namespace Ryujinx.Ui
             {
                 ApplicationLibrary.LoadAndSaveMetaData(titleId, appMetadata =>
                 {
-                    if (appMetadata.LastPlayed.HasValue)
-                    {
-                        double sessionTimePlayed = DateTime.UtcNow.Subtract(appMetadata.LastPlayed.Value).TotalSeconds;
-                        appMetadata.TimePlayed += Math.Round(sessionTimePlayed, MidpointRounding.AwayFromZero);
-                    }
-
-                    appMetadata.LastPlayed = DateTime.UtcNow;
+                    appMetadata.UpdatePostGame();
                 });
             }
         }
@@ -1121,6 +1115,14 @@ namespace Ryujinx.Ui
             Graphics.Gpu.GraphicsConfig.EnableMacroHLE = ConfigurationState.Instance.Graphics.EnableMacroHLE;
         }
 
+        public void UpdateInternetAccess()
+        {
+            if (_gameLoaded)
+            {
+                _emulationContext.Configuration.EnableInternetAccess = ConfigurationState.Instance.System.EnableInternetAccess.Value;
+            }
+        }
+
         public static void SaveConfig()
         {
             ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);
@@ -1169,10 +1171,10 @@ namespace Ryujinx.Ui
                     $"{args.AppData.TitleName}\n{args.AppData.TitleId.ToUpper()}",
                     args.AppData.Developer,
                     args.AppData.Version,
-                    args.AppData.TimePlayed,
+                    args.AppData.TimePlayedString,
                     args.AppData.LastPlayedString,
                     args.AppData.FileExtension,
-                    args.AppData.FileSize,
+                    args.AppData.FileSizeString,
                     args.AppData.Path,
                     args.AppData.ControlHolder);
             });

src/Ryujinx/Ui/Widgets/GameTableContextMenu.cs

@@ -211,7 +211,7 @@ namespace Ryujinx.Ui.Widgets
                         (System.IO.Path.GetExtension(_titleFilePath).ToLower() == ".pfs0") ||
                         (System.IO.Path.GetExtension(_titleFilePath).ToLower() == ".xci"))
                     {
-                        PartitionFileSystem pfs;
+                        IFileSystem pfs;
 
                         if (System.IO.Path.GetExtension(_titleFilePath) == ".xci")
                         {
@@ -221,7 +221,9 @@ namespace Ryujinx.Ui.Widgets
                         }
                         else
                         {
-                            pfs = new PartitionFileSystem(file.AsStorage());
+                            var pfsTemp = new PartitionFileSystem();
+                            pfsTemp.Initialize(file.AsStorage()).ThrowIfFailure();
+                            pfs = pfsTemp;
                         }
 
                         foreach (DirectoryEntryEx fileEntry in pfs.EnumerateEntries("/", "*.nca"))

src/Ryujinx/Ui/Windows/DlcWindow.cs

@@ -88,7 +88,8 @@ namespace Ryujinx.Ui.Windows
 
                     using FileStream containerFile = File.OpenRead(dlcContainer.ContainerPath);
 
-                    PartitionFileSystem pfs = new(containerFile.AsStorage());
+                    PartitionFileSystem pfs = new();
+                    pfs.Initialize(containerFile.AsStorage()).ThrowIfFailure();
 
                     _virtualFileSystem.ImportTickets(pfs);
 
@@ -153,7 +154,8 @@ namespace Ryujinx.Ui.Windows
 
                     using FileStream containerFile = File.OpenRead(containerPath);
 
-                    PartitionFileSystem pfs = new(containerFile.AsStorage());
+                    PartitionFileSystem pfs = new();
+                    pfs.Initialize(containerFile.AsStorage()).ThrowIfFailure();
                     bool containsDlc = false;
 
                     _virtualFileSystem.ImportTickets(pfs);

src/Ryujinx/Ui/Windows/SettingsWindow.cs

@@ -671,6 +671,8 @@ namespace Ryujinx.Ui.Windows
             }
 
             ConfigurationState.Instance.ToFileFormat().SaveConfig(Program.ConfigurationPath);
+
+            _parent.UpdateInternetAccess();
             MainWindow.UpdateGraphicsConfig();
             ThemeHelper.ApplyTheme();
         }

src/Ryujinx/Ui/Windows/SettingsWindow.glade

@@ -2993,6 +2993,7 @@
                                         <property name="active-id">Disabled</property>
                                         <items>
                                           <item id="Disabled" translatable="yes">Disabled</item>
+                                          <item id="LdnMitm" translatable="yes">ldn_mitm</item>
                                         </items>
                                       </object>
                                       <packing>
@@ -3064,7 +3065,7 @@
                                       <object class="GtkLabel">
                                         <property name="visible">True</property>
                                         <property name="can-focus">False</property>
-                                        <property name="tooltip-text" translatable="yes">The network interface used for LAN features</property>
+                                        <property name="tooltip-text" translatable="yes">The network interface used for LAN/LDN features</property>
                                         <property name="halign">end</property>
                                         <property name="label" translatable="yes">Network Interface:</property>
                                       </object>
@@ -3079,7 +3080,7 @@
                                       <object class="GtkComboBoxText" id="_multiLanSelect">
                                         <property name="visible">True</property>
                                         <property name="can-focus">False</property>
-                                        <property name="tooltip-text" translatable="yes">The network interface used for LAN features</property>
+                                        <property name="tooltip-text" translatable="yes">The network interface used for LAN/LDN features</property>
                                         <property name="active-id">0</property>
                                         <items>
                                           <item id="0" translatable="yes">Default</item>

src/Ryujinx/Ui/Windows/TitleUpdateWindow.cs

@@ -90,7 +90,8 @@ namespace Ryujinx.Ui.Windows
             {
                 using FileStream file = new(path, FileMode.Open, FileAccess.Read);
 
-                PartitionFileSystem nsp = new(file.AsStorage());
+                PartitionFileSystem nsp = new();
+                nsp.Initialize(file.AsStorage()).ThrowIfFailure();
 
                 try
                 {