Move solution and projects to src

13 files changed, 2081 insertions, 0 deletions

diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/FileSystemProxyHelper.cs b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/FileSystemProxyHelper.cs
new file mode 100644
index 00000000..ba924db8
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/FileSystemProxyHelper.cs
@@ -0,0 +1,161 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Common.Keys;
+using LibHac.Fs;
+using LibHac.FsSrv.Impl;
+using LibHac.FsSrv.Sf;
+using LibHac.FsSystem;
+using LibHac.Spl;
+using LibHac.Tools.Es;
+using LibHac.Tools.Fs;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using System;
+using System.IO;
+using System.Runtime.InteropServices;
+using Path = System.IO.Path;
+
+namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
+{
+    static class FileSystemProxyHelper
+    {
+        public static ResultCode OpenNsp(ServiceCtx context, string pfsPath, out IFileSystem openedFileSystem)
+        {
+            openedFileSystem = null;
+
+            try
+            {
+                LocalStorage storage = new LocalStorage(pfsPath, FileAccess.Read, FileMode.Open);
+                using SharedRef<LibHac.Fs.Fsa.IFileSystem> nsp = new(new PartitionFileSystem(storage));
+
+                ImportTitleKeysFromNsp(nsp.Get, context.Device.System.KeySet);
+
+                using SharedRef<LibHac.FsSrv.Sf.IFileSystem> adapter = FileSystemInterfaceAdapter.CreateShared(ref nsp.Ref, true);
+
+                openedFileSystem = new IFileSystem(ref adapter.Ref);
+            }
+            catch (HorizonResultException ex)
+            {
+                return (ResultCode)ex.ResultValue.Value;
+            }
+
+            return ResultCode.Success;
+        }
+
+        public static ResultCode OpenNcaFs(ServiceCtx context, string ncaPath, LibHac.Fs.IStorage ncaStorage, out IFileSystem openedFileSystem)
+        {
+            openedFileSystem = null;
+
+            try
+            {
+                Nca nca = new Nca(context.Device.System.KeySet, ncaStorage);
+
+                if (!nca.SectionExists(NcaSectionType.Data))
+                {
+                    return ResultCode.PartitionNotFound;
+                }
+
+                LibHac.Fs.Fsa.IFileSystem fileSystem = nca.OpenFileSystem(NcaSectionType.Data, context.Device.System.FsIntegrityCheckLevel);
+                using var sharedFs = new SharedRef<LibHac.Fs.Fsa.IFileSystem>(fileSystem);
+
+                using SharedRef<LibHac.FsSrv.Sf.IFileSystem> adapter = FileSystemInterfaceAdapter.CreateShared(ref sharedFs.Ref, true);
+
+                openedFileSystem = new IFileSystem(ref adapter.Ref);
+            }
+            catch (HorizonResultException ex)
+            {
+                return (ResultCode)ex.ResultValue.Value;
+            }
+
+            return ResultCode.Success;
+        }
+
+        public static ResultCode OpenFileSystemFromInternalFile(ServiceCtx context, string fullPath, out IFileSystem openedFileSystem)
+        {
+            openedFileSystem = null;
+
+            DirectoryInfo archivePath = new DirectoryInfo(fullPath).Parent;
+
+            while (string.IsNullOrWhiteSpace(archivePath.Extension))
+            {
+                archivePath = archivePath.Parent;
+            }
+
+            if (archivePath.Extension == ".nsp" && File.Exists(archivePath.FullName))
+            {
+                FileStream pfsFile = new FileStream(
+                    archivePath.FullName.TrimEnd(Path.DirectorySeparatorChar),
+                    FileMode.Open,
+                    FileAccess.Read);
+
+                try
+                {
+                    PartitionFileSystem nsp = new PartitionFileSystem(pfsFile.AsStorage());
+
+                    ImportTitleKeysFromNsp(nsp, context.Device.System.KeySet);
+
+                    string filename = fullPath.Replace(archivePath.FullName, string.Empty).TrimStart('\\');
+
+                    using var ncaFile = new UniqueRef<LibHac.Fs.Fsa.IFile>();
+
+                    Result result = nsp.OpenFile(ref ncaFile.Ref, filename.ToU8Span(), OpenMode.Read);
+                    if (result.IsFailure())
+                    {
+                        return (ResultCode)result.Value;
+                    }
+
+                    return OpenNcaFs(context, fullPath, ncaFile.Release().AsStorage(), out openedFileSystem);
+                }
+                catch (HorizonResultException ex)
+                {
+                    return (ResultCode)ex.ResultValue.Value;
+                }
+            }
+
+            return ResultCode.PathDoesNotExist;
+        }
+
+        public static void ImportTitleKeysFromNsp(LibHac.Fs.Fsa.IFileSystem nsp, KeySet keySet)
+        {
+            foreach (DirectoryEntryEx ticketEntry in nsp.EnumerateEntries("/", "*.tik"))
+            {
+                using var ticketFile = new UniqueRef<LibHac.Fs.Fsa.IFile>();
+
+                Result result = nsp.OpenFile(ref ticketFile.Ref, ticketEntry.FullPath.ToU8Span(), OpenMode.Read);
+
+                if (result.IsSuccess())
+                {
+                    Ticket ticket = new Ticket(ticketFile.Get.AsStream());
+                    var titleKey = ticket.GetTitleKey(keySet);
+
+                    if (titleKey != null)
+                    {
+                        keySet.ExternalKeySet.Add(new RightsId(ticket.RightsId), new AccessKey(titleKey));
+                    }
+                }
+            }
+        }
+
+        public static ref readonly FspPath GetFspPath(ServiceCtx context, int index = 0)
+        {
+            ulong position = context.Request.PtrBuff[index].Position;
+            ulong size = context.Request.PtrBuff[index].Size;
+
+            ReadOnlySpan<byte> buffer = context.Memory.GetSpan(position, (int)size);
+            ReadOnlySpan<FspPath> fspBuffer = MemoryMarshal.Cast<byte, FspPath>(buffer);
+
+            return ref fspBuffer[0];
+        }
+
+        public static ref readonly LibHac.FsSrv.Sf.Path GetSfPath(ServiceCtx context, int index = 0)
+        {
+            ulong position = context.Request.PtrBuff[index].Position;
+            ulong size = context.Request.PtrBuff[index].Size;
+
+            ReadOnlySpan<byte> buffer = context.Memory.GetSpan(position, (int)size);
+            ReadOnlySpan<LibHac.FsSrv.Sf.Path> pathBuffer = MemoryMarshal.Cast<byte, LibHac.FsSrv.Sf.Path>(buffer);
+
+            return ref pathBuffer[0];
+        }
+    }
+}
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IDirectory.cs b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IDirectory.cs
new file mode 100644
index 00000000..b9759449
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IDirectory.cs
@@ -0,0 +1,52 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Sf;
+
+namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
+{
+    class IDirectory : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IDirectory> _baseDirectory;
+
+        public IDirectory(ref SharedRef<LibHac.FsSrv.Sf.IDirectory> directory)
+        {
+            _baseDirectory = SharedRef<LibHac.FsSrv.Sf.IDirectory>.CreateMove(ref directory);
+        }
+
+        [CommandCmif(0)]
+        // Read() -> (u64 count, buffer<nn::fssrv::sf::IDirectoryEntry, 6, 0> entries)
+        public ResultCode Read(ServiceCtx context)
+        {
+            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
+            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
+
+            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
+            {
+                Result result = _baseDirectory.Get.Read(out long entriesRead, new OutBuffer(region.Memory.Span));
+
+                context.ResponseData.Write(entriesRead);
+
+                return (ResultCode)result.Value;
+            }
+        }
+
+        [CommandCmif(1)]
+        // GetEntryCount() -> u64
+        public ResultCode GetEntryCount(ServiceCtx context)
+        {
+            Result result = _baseDirectory.Get.GetEntryCount(out long entryCount);
+
+            context.ResponseData.Write(entryCount);
+
+            return (ResultCode)result.Value;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseDirectory.Destroy();
+            }
+        }
+    }
+}
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFile.cs b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFile.cs
new file mode 100644
index 00000000..4bc58ae5
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFile.cs
@@ -0,0 +1,95 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Sf;
+using Ryujinx.Common;
+
+namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
+{
+    class IFile : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IFile> _baseFile;
+
+        public IFile(ref SharedRef<LibHac.FsSrv.Sf.IFile> baseFile)
+        {
+            _baseFile = SharedRef<LibHac.FsSrv.Sf.IFile>.CreateMove(ref baseFile);
+        }
+
+        [CommandCmif(0)]
+        // Read(u32 readOption, u64 offset, u64 size) -> (u64 out_size, buffer<u8, 0x46, 0> out_buf)
+        public ResultCode Read(ServiceCtx context)
+        {
+            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
+            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
+
+            ReadOption readOption = context.RequestData.ReadStruct<ReadOption>();
+            context.RequestData.BaseStream.Position += 4;
+
+            long offset = context.RequestData.ReadInt64();
+            long size   = context.RequestData.ReadInt64();
+
+            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
+            {
+                Result result = _baseFile.Get.Read(out long bytesRead, offset, new OutBuffer(region.Memory.Span), size, readOption);
+
+                context.ResponseData.Write(bytesRead);
+
+                return (ResultCode)result.Value;
+            }
+        }
+
+        [CommandCmif(1)]
+        // Write(u32 writeOption, u64 offset, u64 size, buffer<u8, 0x45, 0>)
+        public ResultCode Write(ServiceCtx context)
+        {
+            ulong position = context.Request.SendBuff[0].Position;
+
+            WriteOption writeOption = context.RequestData.ReadStruct<WriteOption>();
+            context.RequestData.BaseStream.Position += 4;
+
+            long offset = context.RequestData.ReadInt64();
+            long size   = context.RequestData.ReadInt64();
+
+            byte[] data = new byte[context.Request.SendBuff[0].Size];
+
+            context.Memory.Read(position, data);
+
+            return (ResultCode)_baseFile.Get.Write(offset, new InBuffer(data), size, writeOption).Value;
+        }
+
+        [CommandCmif(2)]
+        // Flush()
+        public ResultCode Flush(ServiceCtx context)
+        {
+            return (ResultCode)_baseFile.Get.Flush().Value;
+        }
+
+        [CommandCmif(3)]
+        // SetSize(u64 size)
+        public ResultCode SetSize(ServiceCtx context)
+        {
+            long size = context.RequestData.ReadInt64();
+
+            return (ResultCode)_baseFile.Get.SetSize(size).Value;
+        }
+
+        [CommandCmif(4)]
+        // GetSize() -> u64 fileSize
+        public ResultCode GetSize(ServiceCtx context)
+        {
+            Result result = _baseFile.Get.GetSize(out long size);
+
+            context.ResponseData.Write(size);
+
+            return (ResultCode)result.Value;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseFile.Destroy();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFileSystem.cs b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFileSystem.cs
new file mode 100644
index 00000000..9effa79d
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IFileSystem.cs
@@ -0,0 +1,213 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Fs;
+using Path = LibHac.FsSrv.Sf.Path;
+
+namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
+{
+    class IFileSystem : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IFileSystem> _fileSystem;
+
+        public IFileSystem(ref SharedRef<LibHac.FsSrv.Sf.IFileSystem> provider)
+        {
+            _fileSystem = SharedRef<LibHac.FsSrv.Sf.IFileSystem>.CreateMove(ref provider);
+        }
+
+        public SharedRef<LibHac.FsSrv.Sf.IFileSystem> GetBaseFileSystem()
+        {
+            return SharedRef<LibHac.FsSrv.Sf.IFileSystem>.CreateCopy(in _fileSystem);
+        }
+
+        [CommandCmif(0)]
+        // CreateFile(u32 createOption, u64 size, buffer<bytes<0x301>, 0x19, 0x301> path)
+        public ResultCode CreateFile(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            int createOption = context.RequestData.ReadInt32();
+            context.RequestData.BaseStream.Position += 4;
+
+            long size = context.RequestData.ReadInt64();
+
+            return (ResultCode)_fileSystem.Get.CreateFile(in name, size, createOption).Value;
+        }
+
+        [CommandCmif(1)]
+        // DeleteFile(buffer<bytes<0x301>, 0x19, 0x301> path)
+        public ResultCode DeleteFile(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            return (ResultCode)_fileSystem.Get.DeleteFile(in name).Value;
+        }
+
+        [CommandCmif(2)]
+        // CreateDirectory(buffer<bytes<0x301>, 0x19, 0x301> path)
+        public ResultCode CreateDirectory(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            return (ResultCode)_fileSystem.Get.CreateDirectory(in name).Value;
+        }
+
+        [CommandCmif(3)]
+        // DeleteDirectory(buffer<bytes<0x301>, 0x19, 0x301> path)
+        public ResultCode DeleteDirectory(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            return (ResultCode)_fileSystem.Get.DeleteDirectory(in name).Value;
+        }
+
+        [CommandCmif(4)]
+        // DeleteDirectoryRecursively(buffer<bytes<0x301>, 0x19, 0x301> path)
+        public ResultCode DeleteDirectoryRecursively(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            return (ResultCode)_fileSystem.Get.DeleteDirectoryRecursively(in name).Value;
+        }
+
+        [CommandCmif(5)]
+        // RenameFile(buffer<bytes<0x301>, 0x19, 0x301> oldPath, buffer<bytes<0x301>, 0x19, 0x301> newPath)
+        public ResultCode RenameFile(ServiceCtx context)
+        {
+            ref readonly Path currentName = ref FileSystemProxyHelper.GetSfPath(context, index: 0);
+            ref readonly Path newName = ref FileSystemProxyHelper.GetSfPath(context, index: 1);
+
+            return (ResultCode)_fileSystem.Get.RenameFile(in currentName, in newName).Value;
+        }
+
+        [CommandCmif(6)]
+        // RenameDirectory(buffer<bytes<0x301>, 0x19, 0x301> oldPath, buffer<bytes<0x301>, 0x19, 0x301> newPath)
+        public ResultCode RenameDirectory(ServiceCtx context)
+        {
+            ref readonly Path currentName = ref FileSystemProxyHelper.GetSfPath(context, index: 0);
+            ref readonly Path newName = ref FileSystemProxyHelper.GetSfPath(context, index: 1);
+
+            return (ResultCode)_fileSystem.Get.RenameDirectory(in currentName, in newName).Value;
+        }
+
+        [CommandCmif(7)]
+        // GetEntryType(buffer<bytes<0x301>, 0x19, 0x301> path) -> nn::fssrv::sf::DirectoryEntryType
+        public ResultCode GetEntryType(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            Result result = _fileSystem.Get.GetEntryType(out uint entryType, in name);
+
+            context.ResponseData.Write((int)entryType);
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(8)]
+        // OpenFile(u32 mode, buffer<bytes<0x301>, 0x19, 0x301> path) -> object<nn::fssrv::sf::IFile> file
+        public ResultCode OpenFile(ServiceCtx context)
+        {
+            uint mode = context.RequestData.ReadUInt32();
+
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+            using var file = new SharedRef<LibHac.FsSrv.Sf.IFile>();
+
+            Result result = _fileSystem.Get.OpenFile(ref file.Ref, in name, mode);
+
+            if (result.IsSuccess())
+            {
+                IFile fileInterface = new IFile(ref file.Ref);
+
+                MakeObject(context, fileInterface);
+            }
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(9)]
+        // OpenDirectory(u32 filter_flags, buffer<bytes<0x301>, 0x19, 0x301> path) -> object<nn::fssrv::sf::IDirectory> directory
+        public ResultCode OpenDirectory(ServiceCtx context)
+        {
+            uint mode = context.RequestData.ReadUInt32();
+
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+            using var dir = new SharedRef<LibHac.FsSrv.Sf.IDirectory>();
+
+            Result result = _fileSystem.Get.OpenDirectory(ref dir.Ref, name, mode);
+
+            if (result.IsSuccess())
+            {
+                IDirectory dirInterface = new IDirectory(ref dir.Ref);
+
+                MakeObject(context, dirInterface);
+            }
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(10)]
+        // Commit()
+        public ResultCode Commit(ServiceCtx context)
+        {
+            return (ResultCode)_fileSystem.Get.Commit().Value;
+        }
+
+        [CommandCmif(11)]
+        // GetFreeSpaceSize(buffer<bytes<0x301>, 0x19, 0x301> path) -> u64 totalFreeSpace
+        public ResultCode GetFreeSpaceSize(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            Result result = _fileSystem.Get.GetFreeSpaceSize(out long size, in name);
+
+            context.ResponseData.Write(size);
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(12)]
+        // GetTotalSpaceSize(buffer<bytes<0x301>, 0x19, 0x301> path) -> u64 totalSize
+        public ResultCode GetTotalSpaceSize(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            Result result = _fileSystem.Get.GetTotalSpaceSize(out long size, in name);
+
+            context.ResponseData.Write(size);
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(13)]
+        // CleanDirectoryRecursively(buffer<bytes<0x301>, 0x19, 0x301> path)
+        public ResultCode CleanDirectoryRecursively(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            return (ResultCode)_fileSystem.Get.CleanDirectoryRecursively(in name).Value;
+        }
+
+        [CommandCmif(14)]
+        // GetFileTimeStampRaw(buffer<bytes<0x301>, 0x19, 0x301> path) -> bytes<0x20> timestamp
+        public ResultCode GetFileTimeStampRaw(ServiceCtx context)
+        {
+            ref readonly Path name = ref FileSystemProxyHelper.GetSfPath(context);
+
+            Result result = _fileSystem.Get.GetFileTimeStampRaw(out FileTimeStampRaw timestamp, in name);
+
+            context.ResponseData.Write(timestamp.Created);
+            context.ResponseData.Write(timestamp.Modified);
+            context.ResponseData.Write(timestamp.Accessed);
+            context.ResponseData.Write(1L); // Is valid?
+
+            return (ResultCode)result.Value;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _fileSystem.Destroy();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IStorage.cs b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IStorage.cs
new file mode 100644
index 00000000..54c7b800
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/FileSystemProxy/IStorage.cs
@@ -0,0 +1,65 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Sf;
+using Ryujinx.HLE.HOS.Ipc;
+
+namespace Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy
+{
+    class IStorage : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IStorage> _baseStorage;
+
+        public IStorage(ref SharedRef<LibHac.FsSrv.Sf.IStorage> baseStorage)
+        {
+            _baseStorage = SharedRef<LibHac.FsSrv.Sf.IStorage>.CreateMove(ref baseStorage);
+        }
+
+        [CommandCmif(0)]
+        // Read(u64 offset, u64 length) -> buffer<u8, 0x46, 0> buffer
+        public ResultCode Read(ServiceCtx context)
+        {
+            ulong offset = context.RequestData.ReadUInt64();
+            ulong size   = context.RequestData.ReadUInt64();
+
+            if (context.Request.ReceiveBuff.Count > 0)
+            {
+                ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
+                ulong bufferLen = context.Request.ReceiveBuff[0].Size;
+
+                // Use smaller length to avoid overflows.
+                if (size > bufferLen)
+                {
+                    size = bufferLen;
+                }
+
+                using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
+                {
+                    Result result = _baseStorage.Get.Read((long)offset, new OutBuffer(region.Memory.Span), (long)size);
+
+                    return (ResultCode)result.Value;
+                }
+            }
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(4)]
+        // GetSize() -> u64 size
+        public ResultCode GetSize(ServiceCtx context)
+        {
+            Result result = _baseStorage.Get.GetSize(out long size);
+
+            context.ResponseData.Write(size);
+
+            return (ResultCode)result.Value;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseStorage.Destroy();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/IDeviceOperator.cs b/src/Ryujinx.HLE/HOS/Services/Fs/IDeviceOperator.cs
new file mode 100644
index 00000000..2a40aea4
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/IDeviceOperator.cs
@@ -0,0 +1,58 @@
+using LibHac;
+using LibHac.Common;
+
+using GameCardHandle = System.UInt32;
+
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    class IDeviceOperator : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IDeviceOperator> _baseOperator;
+
+        public IDeviceOperator(ref SharedRef<LibHac.FsSrv.Sf.IDeviceOperator> baseOperator)
+        {
+            _baseOperator = SharedRef<LibHac.FsSrv.Sf.IDeviceOperator>.CreateMove(ref baseOperator);
+        }
+
+        [CommandCmif(0)]
+        // IsSdCardInserted() -> b8 is_inserted
+        public ResultCode IsSdCardInserted(ServiceCtx context)
+        {
+            Result result = _baseOperator.Get.IsSdCardInserted(out bool isInserted);
+
+            context.ResponseData.Write(isInserted);
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(200)]
+        // IsGameCardInserted() -> b8 is_inserted
+        public ResultCode IsGameCardInserted(ServiceCtx context)
+        {
+            Result result = _baseOperator.Get.IsGameCardInserted(out bool isInserted);
+
+            context.ResponseData.Write(isInserted);
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(202)]
+        // GetGameCardHandle() -> u32 gamecard_handle
+        public ResultCode GetGameCardHandle(ServiceCtx context)
+        {
+            Result result = _baseOperator.Get.GetGameCardHandle(out GameCardHandle handle);
+
+            context.ResponseData.Write(handle);
+
+            return (ResultCode)result.Value;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseOperator.Destroy();
+            }
+        }
+    }
+}
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxy.cs b/src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxy.cs
new file mode 100644
index 00000000..e961e9b1
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxy.cs
@@ -0,0 +1,1308 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Fs;
+using LibHac.Fs.Shim;
+using LibHac.FsSrv.Impl;
+using LibHac.FsSystem;
+using LibHac.Ncm;
+using LibHac.Sf;
+using LibHac.Spl;
+using LibHac.Tools.FsSystem;
+using LibHac.Tools.FsSystem.NcaUtils;
+using Ryujinx.Common;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy;
+using System;
+using System.IO;
+using static Ryujinx.HLE.Utilities.StringUtils;
+using GameCardHandle = System.UInt32;
+using IFileSystem = LibHac.FsSrv.Sf.IFileSystem;
+using IStorage = LibHac.FsSrv.Sf.IStorage;
+using RightsId = LibHac.Fs.RightsId;
+
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    [Service("fsp-srv")]
+    class IFileSystemProxy : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IFileSystemProxy> _baseFileSystemProxy;
+        private ulong _pid;
+
+        public IFileSystemProxy(ServiceCtx context) : base(context.Device.System.FsServer)
+        {
+            var applicationClient = context.Device.System.LibHacHorizonManager.ApplicationClient;
+            _baseFileSystemProxy = applicationClient.Fs.Impl.GetFileSystemProxyServiceObject();
+        }
+
+        [CommandCmif(1)]
+        // SetCurrentProcess(u64, pid)
+        public ResultCode SetCurrentProcess(ServiceCtx context)
+        {
+            _pid = context.Request.HandleDesc.PId;
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(8)]
+        // OpenFileSystemWithId(nn::fssrv::sf::FileSystemType filesystem_type, nn::ApplicationId tid, buffer<bytes<0x301>, 0x19, 0x301> path)
+        // -> object<nn::fssrv::sf::IFileSystem> contentFs
+        public ResultCode OpenFileSystemWithId(ServiceCtx context)
+        {
+            FileSystemType fileSystemType = (FileSystemType)context.RequestData.ReadInt32();
+            ulong titleId = context.RequestData.ReadUInt64();
+            string switchPath = ReadUtf8String(context);
+            string fullPath = context.Device.FileSystem.SwitchPathToSystemPath(switchPath);
+
+            if (!File.Exists(fullPath))
+            {
+                if (fullPath.Contains("."))
+                {
+                    ResultCode result = FileSystemProxyHelper.OpenFileSystemFromInternalFile(context, fullPath, out FileSystemProxy.IFileSystem fileSystem);
+
+                    if (result == ResultCode.Success)
+                    {
+                        MakeObject(context, fileSystem);
+                    }
+
+                    return result;
+                }
+
+                return ResultCode.PathDoesNotExist;
+            }
+
+            FileStream fileStream = new FileStream(fullPath, FileMode.Open, FileAccess.Read);
+            string extension = System.IO.Path.GetExtension(fullPath);
+
+            if (extension == ".nca")
+            {
+                ResultCode result = FileSystemProxyHelper.OpenNcaFs(context, fullPath, fileStream.AsStorage(), out FileSystemProxy.IFileSystem fileSystem);
+
+                if (result == ResultCode.Success)
+                {
+                    MakeObject(context, fileSystem);
+                }
+
+                return result;
+            }
+            else if (extension == ".nsp")
+            {
+                ResultCode result = FileSystemProxyHelper.OpenNsp(context, fullPath, out FileSystemProxy.IFileSystem fileSystem);
+
+                if (result == ResultCode.Success)
+                {
+                    MakeObject(context, fileSystem);
+                }
+
+                return result;
+            }
+
+            return ResultCode.InvalidInput;
+        }
+
+        [CommandCmif(11)]
+        // OpenBisFileSystem(nn::fssrv::sf::Partition partitionID, buffer<bytes<0x301>, 0x19, 0x301>) -> object<nn::fssrv::sf::IFileSystem> Bis
+        public ResultCode OpenBisFileSystem(ServiceCtx context)
+        {
+            BisPartitionId bisPartitionId = (BisPartitionId)context.RequestData.ReadInt32();
+
+            ref readonly var path = ref FileSystemProxyHelper.GetFspPath(context);
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenBisFileSystem(ref fileSystem.Ref, in path, bisPartitionId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(12)]
+        // OpenBisStorage(u32 partitionId) -> object<nn::fssrv::sf::IStorage> bisStorage
+        public ResultCode OpenBisStorage(ServiceCtx context)
+        {
+            BisPartitionId bisPartitionId = (BisPartitionId)context.RequestData.ReadInt32();
+            using var storage = new SharedRef<IStorage>();
+
+            Result result = _baseFileSystemProxy.Get.OpenBisStorage(ref storage.Ref, bisPartitionId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IStorage(ref storage.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(13)]
+        // InvalidateBisCache() -> ()
+        public ResultCode InvalidateBisCache(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.InvalidateBisCache().Value;
+        }
+
+        [CommandCmif(18)]
+        // OpenSdCardFileSystem() -> object<nn::fssrv::sf::IFileSystem>
+        public ResultCode OpenSdCardFileSystem(ServiceCtx context)
+        {
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSdCardFileSystem(ref fileSystem.Ref);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(19)]
+        // FormatSdCardFileSystem() -> ()
+        public ResultCode FormatSdCardFileSystem(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.FormatSdCardFileSystem().Value;
+        }
+
+        [CommandCmif(21)]
+        // DeleteSaveDataFileSystem(u64 saveDataId) -> ()
+        public ResultCode DeleteSaveDataFileSystem(ServiceCtx context)
+        {
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.DeleteSaveDataFileSystem(saveDataId).Value;
+        }
+
+        [CommandCmif(22)]
+        // CreateSaveDataFileSystem(nn::fs::SaveDataAttribute attribute, nn::fs::SaveDataCreationInfo creationInfo, nn::fs::SaveDataMetaInfo metaInfo) -> ()
+        public ResultCode CreateSaveDataFileSystem(ServiceCtx context)
+        {
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            SaveDataCreationInfo creationInfo = context.RequestData.ReadStruct<SaveDataCreationInfo>();
+            SaveDataMetaInfo metaInfo = context.RequestData.ReadStruct<SaveDataMetaInfo>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CreateSaveDataFileSystem(in attribute, in creationInfo, in metaInfo).Value;
+        }
+
+        [CommandCmif(23)]
+        // CreateSaveDataFileSystemBySystemSaveDataId(nn::fs::SaveDataAttribute attribute, nn::fs::SaveDataCreationInfo creationInfo) -> ()
+        public ResultCode CreateSaveDataFileSystemBySystemSaveDataId(ServiceCtx context)
+        {
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            SaveDataCreationInfo creationInfo = context.RequestData.ReadStruct<SaveDataCreationInfo>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CreateSaveDataFileSystemBySystemSaveDataId(in attribute, in creationInfo).Value;
+        }
+
+        [CommandCmif(24)]
+        // RegisterSaveDataFileSystemAtomicDeletion(buffer<u64, 5> saveDataIds) -> ()
+        public ResultCode RegisterSaveDataFileSystemAtomicDeletion(ServiceCtx context)
+        {
+            byte[] saveIdBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, saveIdBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.RegisterSaveDataFileSystemAtomicDeletion(new InBuffer(saveIdBuffer)).Value;
+        }
+
+        [CommandCmif(25)]
+        // DeleteSaveDataFileSystemBySaveDataSpaceId(u8 spaceId, u64 saveDataId) -> ()
+        public ResultCode DeleteSaveDataFileSystemBySaveDataSpaceId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.DeleteSaveDataFileSystemBySaveDataSpaceId(spaceId, saveDataId).Value;
+        }
+
+        [CommandCmif(26)]
+        // FormatSdCardDryRun() -> ()
+        public ResultCode FormatSdCardDryRun(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.FormatSdCardDryRun().Value;
+        }
+
+        [CommandCmif(27)]
+        // IsExFatSupported() -> (u8 isSupported)
+        public ResultCode IsExFatSupported(ServiceCtx context)
+        {
+            Result result = _baseFileSystemProxy.Get.IsExFatSupported(out bool isSupported);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(isSupported);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(28)]
+        // DeleteSaveDataFileSystemBySaveDataAttribute(u8 spaceId, nn::fs::SaveDataAttribute attribute) -> ()
+        public ResultCode DeleteSaveDataFileSystemBySaveDataAttribute(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.DeleteSaveDataFileSystemBySaveDataAttribute(spaceId, in attribute).Value;
+        }
+
+        [CommandCmif(30)]
+        // OpenGameCardStorage(u32 handle, u32 partitionId) -> object<nn::fssrv::sf::IStorage>
+        public ResultCode OpenGameCardStorage(ServiceCtx context)
+        {
+            GameCardHandle handle = context.RequestData.ReadUInt32();
+            GameCardPartitionRaw partitionId = (GameCardPartitionRaw)context.RequestData.ReadInt32();
+            using var storage = new SharedRef<IStorage>();
+
+            Result result = _baseFileSystemProxy.Get.OpenGameCardStorage(ref storage.Ref, handle, partitionId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IStorage(ref storage.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(31)]
+        // OpenGameCardFileSystem(u32 handle, u32 partitionId) -> object<nn::fssrv::sf::IFileSystem>
+        public ResultCode OpenGameCardFileSystem(ServiceCtx context)
+        {
+            GameCardHandle handle = context.RequestData.ReadUInt32();
+            GameCardPartition partitionId = (GameCardPartition)context.RequestData.ReadInt32();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenGameCardFileSystem(ref fileSystem.Ref, handle, partitionId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(32)]
+        // ExtendSaveDataFileSystem(u8 spaceId, u64 saveDataId, s64 dataSize, s64 journalSize) -> ()
+        public ResultCode ExtendSaveDataFileSystem(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+            long dataSize = context.RequestData.ReadInt64();
+            long journalSize = context.RequestData.ReadInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.ExtendSaveDataFileSystem(spaceId, saveDataId, dataSize, journalSize).Value;
+        }
+
+        [CommandCmif(33)]
+        // DeleteCacheStorage(u16 index) -> ()
+        public ResultCode DeleteCacheStorage(ServiceCtx context)
+        {
+            ushort index = context.RequestData.ReadUInt16();
+
+            return (ResultCode)_baseFileSystemProxy.Get.DeleteCacheStorage(index).Value;
+        }
+
+        [CommandCmif(34)]
+        // GetCacheStorageSize(u16 index) -> (s64 dataSize, s64 journalSize)
+        public ResultCode GetCacheStorageSize(ServiceCtx context)
+        {
+            ushort index = context.RequestData.ReadUInt16();
+
+            Result result = _baseFileSystemProxy.Get.GetCacheStorageSize(out long dataSize, out long journalSize, index);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(dataSize);
+            context.ResponseData.Write(journalSize);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(35)]
+        // CreateSaveDataFileSystemWithHashSalt(nn::fs::SaveDataAttribute attribute, nn::fs::SaveDataCreationInfo creationInfo, nn::fs::SaveDataMetaInfo metaInfo nn::fs::HashSalt hashSalt) -> ()
+        public ResultCode CreateSaveDataFileSystemWithHashSalt(ServiceCtx context)
+        {
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            SaveDataCreationInfo creationInfo = context.RequestData.ReadStruct<SaveDataCreationInfo>();
+            SaveDataMetaInfo metaCreateInfo = context.RequestData.ReadStruct<SaveDataMetaInfo>();
+            HashSalt hashSalt = context.RequestData.ReadStruct<HashSalt>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CreateSaveDataFileSystemWithHashSalt(in attribute, in creationInfo, in metaCreateInfo, in hashSalt).Value;
+        }
+
+        [CommandCmif(37)] // 14.0.0+
+        // CreateSaveDataFileSystemWithCreationInfo2(buffer<nn::fs::SaveDataCreationInfo2, 25> creationInfo) -> ()
+        public ResultCode CreateSaveDataFileSystemWithCreationInfo2(ServiceCtx context)
+        {
+            byte[] creationInfoBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, creationInfoBuffer);
+            ref readonly SaveDataCreationInfo2 creationInfo = ref SpanHelpers.AsReadOnlyStruct<SaveDataCreationInfo2>(creationInfoBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.CreateSaveDataFileSystemWithCreationInfo2(in creationInfo).Value;
+        }
+
+        [CommandCmif(51)]
+        // OpenSaveDataFileSystem(u8 spaceId, nn::fs::SaveDataAttribute attribute) -> object<nn::fssrv::sf::IFileSystem> saveDataFs
+        public ResultCode OpenSaveDataFileSystem(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataFileSystem(ref fileSystem.Ref, spaceId, in attribute);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(52)]
+        // OpenSaveDataFileSystemBySystemSaveDataId(u8 spaceId, nn::fs::SaveDataAttribute attribute) -> object<nn::fssrv::sf::IFileSystem> systemSaveDataFs
+        public ResultCode OpenSaveDataFileSystemBySystemSaveDataId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataFileSystemBySystemSaveDataId(ref fileSystem.Ref, spaceId, in attribute);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(53)]
+        // OpenReadOnlySaveDataFileSystem(u8 spaceId, nn::fs::SaveDataAttribute attribute) -> object<nn::fssrv::sf::IFileSystem>
+        public ResultCode OpenReadOnlySaveDataFileSystem(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenReadOnlySaveDataFileSystem(ref fileSystem.Ref, spaceId, in attribute);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(57)]
+        // ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(u8 spaceId, u64 saveDataId) -> (buffer<nn::fs::SaveDataExtraData, 6> extraData)
+        public ResultCode ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            byte[] extraDataBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, extraDataBuffer);
+
+            Result result = _baseFileSystemProxy.Get.ReadSaveDataFileSystemExtraDataBySaveDataSpaceId(new OutBuffer(extraDataBuffer), spaceId, saveDataId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.Memory.Write(context.Request.ReceiveBuff[0].Position, extraDataBuffer);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(58)]
+        // ReadSaveDataFileSystemExtraData(u64 saveDataId) -> (buffer<nn::fs::SaveDataExtraData, 6> extraData)
+        public ResultCode ReadSaveDataFileSystemExtraData(ServiceCtx context)
+        {
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            byte[] extraDataBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, extraDataBuffer);
+
+            Result result = _baseFileSystemProxy.Get.ReadSaveDataFileSystemExtraData(new OutBuffer(extraDataBuffer), saveDataId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.Memory.Write(context.Request.ReceiveBuff[0].Position, extraDataBuffer);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(59)]
+        // WriteSaveDataFileSystemExtraData(u8 spaceId, u64 saveDataId, buffer<nn::fs::SaveDataExtraData, 5> extraData) -> ()
+        public ResultCode WriteSaveDataFileSystemExtraData(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            byte[] extraDataBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, extraDataBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.WriteSaveDataFileSystemExtraData(saveDataId, spaceId, new InBuffer(extraDataBuffer)).Value;
+        }
+
+        [CommandCmif(60)]
+        // OpenSaveDataInfoReader() -> object<nn::fssrv::sf::ISaveDataInfoReader>
+        public ResultCode OpenSaveDataInfoReader(ServiceCtx context)
+        {
+            using var infoReader = new SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataInfoReader(ref infoReader.Ref);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new ISaveDataInfoReader(ref infoReader.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(61)]
+        // OpenSaveDataInfoReaderBySaveDataSpaceId(u8 spaceId) -> object<nn::fssrv::sf::ISaveDataInfoReader>
+        public ResultCode OpenSaveDataInfoReaderBySaveDataSpaceId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadByte();
+            using var infoReader = new SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataInfoReaderBySaveDataSpaceId(ref infoReader.Ref, spaceId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new ISaveDataInfoReader(ref infoReader.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(62)]
+        // OpenSaveDataInfoReaderOnlyCacheStorage() -> object<nn::fssrv::sf::ISaveDataInfoReader>
+        public ResultCode OpenSaveDataInfoReaderOnlyCacheStorage(ServiceCtx context)
+        {
+            using var infoReader = new SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataInfoReaderOnlyCacheStorage(ref infoReader.Ref);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new ISaveDataInfoReader(ref infoReader.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(64)]
+        // OpenSaveDataInternalStorageFileSystem(u8 spaceId, u64 saveDataId) -> object<nn::fssrv::sf::ISaveDataInfoReader>
+        public ResultCode OpenSaveDataInternalStorageFileSystem(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataInternalStorageFileSystem(ref fileSystem.Ref, spaceId, saveDataId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(65)]
+        // UpdateSaveDataMacForDebug(u8 spaceId, u64 saveDataId) -> ()
+        public ResultCode UpdateSaveDataMacForDebug(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.UpdateSaveDataMacForDebug(spaceId, saveDataId).Value;
+        }
+
+        [CommandCmif(66)]
+        public ResultCode WriteSaveDataFileSystemExtraDataWithMask(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            byte[] extraDataBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, extraDataBuffer);
+
+            byte[] maskBuffer = new byte[context.Request.SendBuff[1].Size];
+            context.Memory.Read(context.Request.SendBuff[1].Position, maskBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.WriteSaveDataFileSystemExtraDataWithMask(saveDataId, spaceId, new InBuffer(extraDataBuffer), new InBuffer(maskBuffer)).Value;
+        }
+
+        [CommandCmif(67)]
+        public ResultCode FindSaveDataWithFilter(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataFilter filter = context.RequestData.ReadStruct<SaveDataFilter>();
+
+            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
+            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
+
+            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
+            {
+                Result result = _baseFileSystemProxy.Get.FindSaveDataWithFilter(out long count, new OutBuffer(region.Memory.Span), spaceId, in filter);
+                if (result.IsFailure()) return (ResultCode)result.Value;
+
+                context.ResponseData.Write(count);
+            }
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(68)]
+        public ResultCode OpenSaveDataInfoReaderWithFilter(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataFilter filter = context.RequestData.ReadStruct<SaveDataFilter>();
+            using var infoReader = new SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataInfoReaderWithFilter(ref infoReader.Ref, spaceId, in filter);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new ISaveDataInfoReader(ref infoReader.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(69)]
+        public ResultCode ReadSaveDataFileSystemExtraDataBySaveDataAttribute(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+
+            byte[] outputBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, outputBuffer);
+
+            Result result = _baseFileSystemProxy.Get.ReadSaveDataFileSystemExtraDataBySaveDataAttribute(new OutBuffer(outputBuffer), spaceId, in attribute);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.Memory.Write(context.Request.ReceiveBuff[0].Position, outputBuffer);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(70)]
+        public ResultCode WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+
+            byte[] extraDataBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, extraDataBuffer);
+
+            byte[] maskBuffer = new byte[context.Request.SendBuff[1].Size];
+            context.Memory.Read(context.Request.SendBuff[1].Position, maskBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.WriteSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(in attribute, spaceId, new InBuffer(extraDataBuffer), new InBuffer(maskBuffer)).Value;
+        }
+
+        [CommandCmif(71)]
+        public ResultCode ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+
+            byte[] maskBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, maskBuffer);
+
+            byte[] outputBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, outputBuffer);
+
+            Result result = _baseFileSystemProxy.Get.ReadSaveDataFileSystemExtraDataWithMaskBySaveDataAttribute(new OutBuffer(outputBuffer), spaceId, in attribute, new InBuffer(maskBuffer));
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.Memory.Write(context.Request.ReceiveBuff[0].Position, outputBuffer);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(80)]
+        public ResultCode OpenSaveDataMetaFile(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt32();
+            SaveDataMetaType metaType = (SaveDataMetaType)context.RequestData.ReadInt32();
+            SaveDataAttribute attribute = context.RequestData.ReadStruct<SaveDataAttribute>();
+            using var file = new SharedRef<LibHac.FsSrv.Sf.IFile>();
+
+            Result result = _baseFileSystemProxy.Get.OpenSaveDataMetaFile(ref file.Ref, spaceId, in attribute, metaType);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new IFile(ref file.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(84)]
+        public ResultCode ListAccessibleSaveDataOwnerId(ServiceCtx context)
+        {
+            int startIndex = context.RequestData.ReadInt32();
+            int bufferCount = context.RequestData.ReadInt32();
+            ProgramId programId = context.RequestData.ReadStruct<ProgramId>();
+
+            byte[] outputBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, outputBuffer);
+
+            Result result = _baseFileSystemProxy.Get.ListAccessibleSaveDataOwnerId(out int readCount, new OutBuffer(outputBuffer), programId, startIndex, bufferCount);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(readCount);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(100)]
+        public ResultCode OpenImageDirectoryFileSystem(ServiceCtx context)
+        {
+            ImageDirectoryId directoryId = (ImageDirectoryId)context.RequestData.ReadInt32();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenImageDirectoryFileSystem(ref fileSystem.Ref, directoryId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(101)]
+        public ResultCode OpenBaseFileSystem(ServiceCtx context)
+        {
+            BaseFileSystemId fileSystemId = (BaseFileSystemId)context.RequestData.ReadInt32();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenBaseFileSystem(ref fileSystem.Ref, fileSystemId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(110)]
+        public ResultCode OpenContentStorageFileSystem(ServiceCtx context)
+        {
+            ContentStorageId contentStorageId = (ContentStorageId)context.RequestData.ReadInt32();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenContentStorageFileSystem(ref fileSystem.Ref, contentStorageId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(120)]
+        public ResultCode OpenCloudBackupWorkStorageFileSystem(ServiceCtx context)
+        {
+            CloudBackupWorkStorageId storageId = (CloudBackupWorkStorageId)context.RequestData.ReadInt32();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenCloudBackupWorkStorageFileSystem(ref fileSystem.Ref, storageId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(130)]
+        public ResultCode OpenCustomStorageFileSystem(ServiceCtx context)
+        {
+            CustomStorageId customStorageId = (CustomStorageId)context.RequestData.ReadInt32();
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenCustomStorageFileSystem(ref fileSystem.Ref, customStorageId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(200)]
+        // OpenDataStorageByCurrentProcess() -> object<nn::fssrv::sf::IStorage> dataStorage
+        public ResultCode OpenDataStorageByCurrentProcess(ServiceCtx context)
+        {
+            var storage = context.Device.FileSystem.GetRomFs(_pid).AsStorage(true);
+            using var sharedStorage = new SharedRef<LibHac.Fs.IStorage>(storage);
+            using var sfStorage = new SharedRef<IStorage>(new StorageInterfaceAdapter(ref sharedStorage.Ref));
+
+            MakeObject(context, new FileSystemProxy.IStorage(ref sfStorage.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(202)]
+        // OpenDataStorageByDataId(u8 storageId, nn::ncm::DataId dataId) -> object<nn::fssrv::sf::IStorage> dataStorage
+        public ResultCode OpenDataStorageByDataId(ServiceCtx context)
+        {
+            StorageId storageId = (StorageId)context.RequestData.ReadByte();
+            byte[] padding = context.RequestData.ReadBytes(7);
+            ulong titleId = context.RequestData.ReadUInt64();
+
+            // We do a mitm here to find if the request is for an AOC.
+            // This is because AOC can be distributed over multiple containers in the emulator.
+            if (context.Device.System.ContentManager.GetAocDataStorage(titleId, out LibHac.Fs.IStorage aocStorage, context.Device.Configuration.FsIntegrityCheckLevel))
+            {
+                Logger.Info?.Print(LogClass.Loader, $"Opened AddOnContent Data TitleID={titleId:X16}");
+
+                var storage = context.Device.FileSystem.ModLoader.ApplyRomFsMods(titleId, aocStorage);
+                using var sharedStorage = new SharedRef<LibHac.Fs.IStorage>(storage);
+                using var sfStorage = new SharedRef<IStorage>(new StorageInterfaceAdapter(ref sharedStorage.Ref));
+
+                MakeObject(context, new FileSystemProxy.IStorage(ref sfStorage.Ref));
+
+                return ResultCode.Success;
+            }
+
+            NcaContentType contentType = NcaContentType.Data;
+
+            StorageId installedStorage = context.Device.System.ContentManager.GetInstalledStorage(titleId, contentType, storageId);
+
+            if (installedStorage == StorageId.None)
+            {
+                contentType = NcaContentType.PublicData;
+
+                installedStorage = context.Device.System.ContentManager.GetInstalledStorage(titleId, contentType, storageId);
+            }
+
+            if (installedStorage != StorageId.None)
+            {
+                string contentPath = context.Device.System.ContentManager.GetInstalledContentPath(titleId, storageId, contentType);
+                string installPath = context.Device.FileSystem.SwitchPathToSystemPath(contentPath);
+
+                if (!string.IsNullOrWhiteSpace(installPath))
+                {
+                    string ncaPath = installPath;
+
+                    if (File.Exists(ncaPath))
+                    {
+                        try
+                        {
+                            LibHac.Fs.IStorage ncaStorage = new LocalStorage(ncaPath, FileAccess.Read, FileMode.Open);
+                            Nca nca = new Nca(context.Device.System.KeySet, ncaStorage);
+                            LibHac.Fs.IStorage romfsStorage = nca.OpenStorage(NcaSectionType.Data, context.Device.System.FsIntegrityCheckLevel);
+                            using var sharedStorage = new SharedRef<LibHac.Fs.IStorage>(romfsStorage);
+                            using var sfStorage = new SharedRef<IStorage>(new StorageInterfaceAdapter(ref sharedStorage.Ref));
+
+                            MakeObject(context, new FileSystemProxy.IStorage(ref sfStorage.Ref));
+                        }
+                        catch (HorizonResultException ex)
+                        {
+                            return (ResultCode)ex.ResultValue.Value;
+                        }
+
+                        return ResultCode.Success;
+                    }
+                    else
+                    {
+                        throw new FileNotFoundException($"No Nca found in Path `{ncaPath}`.");
+                    }
+                }
+                else
+                {
+                    throw new DirectoryNotFoundException($"Path for title id {titleId:x16} on Storage {storageId} was not found in Path {installPath}.");
+                }
+            }
+
+            throw new FileNotFoundException($"System archive with titleid {titleId:x16} was not found on Storage {storageId}. Found in {installedStorage}.");
+        }
+
+        [CommandCmif(203)]
+        // OpenPatchDataStorageByCurrentProcess() -> object<nn::fssrv::sf::IStorage>
+        public ResultCode OpenPatchDataStorageByCurrentProcess(ServiceCtx context)
+        {
+            var storage = context.Device.FileSystem.GetRomFs(_pid).AsStorage(true);
+            using var sharedStorage = new SharedRef<LibHac.Fs.IStorage>(storage);
+            using var sfStorage = new SharedRef<IStorage>(new StorageInterfaceAdapter(ref sharedStorage.Ref));
+
+            MakeObject(context, new FileSystemProxy.IStorage(ref sfStorage.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(205)]
+        // OpenDataStorageWithProgramIndex(u8 program_index) -> object<nn::fssrv::sf::IStorage>
+        public ResultCode OpenDataStorageWithProgramIndex(ServiceCtx context)
+        {
+            byte programIndex = context.RequestData.ReadByte();
+
+            if ((context.Device.Processes.ActiveApplication.ProgramId & 0xf) != programIndex)
+            {
+                throw new NotImplementedException($"Accessing storage from other programs is not supported (program index = {programIndex}).");
+            }
+
+            var storage = context.Device.FileSystem.GetRomFs(_pid).AsStorage(true);
+            using var sharedStorage = new SharedRef<LibHac.Fs.IStorage>(storage);
+            using var sfStorage = new SharedRef<IStorage>(new StorageInterfaceAdapter(ref sharedStorage.Ref));
+
+            MakeObject(context, new FileSystemProxy.IStorage(ref sfStorage.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(400)]
+        // OpenDataStorageByCurrentProcess() -> object<nn::fssrv::sf::IStorage> dataStorage
+        public ResultCode OpenDeviceOperator(ServiceCtx context)
+        {
+            using var deviceOperator = new SharedRef<LibHac.FsSrv.Sf.IDeviceOperator>();
+
+            Result result = _baseFileSystemProxy.Get.OpenDeviceOperator(ref deviceOperator.Ref);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new IDeviceOperator(ref deviceOperator.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(601)]
+        public ResultCode QuerySaveDataTotalSize(ServiceCtx context)
+        {
+            long dataSize = context.RequestData.ReadInt64();
+            long journalSize = context.RequestData.ReadInt64();
+
+            Result result = _baseFileSystemProxy.Get.QuerySaveDataTotalSize(out long totalSize, dataSize, journalSize);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(totalSize);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(511)]
+        public ResultCode NotifySystemDataUpdateEvent(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.NotifySystemDataUpdateEvent().Value;
+        }
+
+        [CommandCmif(523)]
+        public ResultCode SimulateDeviceDetectionEvent(ServiceCtx context)
+        {
+            bool signalEvent = context.RequestData.ReadBoolean();
+            context.RequestData.BaseStream.Seek(3, SeekOrigin.Current);
+            SdmmcPort port = context.RequestData.ReadStruct<SdmmcPort>();
+            SimulatingDeviceDetectionMode mode = context.RequestData.ReadStruct<SimulatingDeviceDetectionMode>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.SimulateDeviceDetectionEvent(port, mode, signalEvent).Value;
+        }
+
+        [CommandCmif(602)]
+        public ResultCode VerifySaveDataFileSystem(ServiceCtx context)
+        {
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            byte[] readBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, readBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.VerifySaveDataFileSystem(saveDataId, new OutBuffer(readBuffer)).Value;
+        }
+
+        [CommandCmif(603)]
+        public ResultCode CorruptSaveDataFileSystem(ServiceCtx context)
+        {
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CorruptSaveDataFileSystem(saveDataId).Value;
+        }
+
+        [CommandCmif(604)]
+        public ResultCode CreatePaddingFile(ServiceCtx context)
+        {
+            long size = context.RequestData.ReadInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CreatePaddingFile(size).Value;
+        }
+
+        [CommandCmif(605)]
+        public ResultCode DeleteAllPaddingFiles(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.DeleteAllPaddingFiles().Value;
+        }
+
+        [CommandCmif(606)]
+        public ResultCode GetRightsId(ServiceCtx context)
+        {
+            StorageId storageId = (StorageId)context.RequestData.ReadInt64();
+            ProgramId programId = context.RequestData.ReadStruct<ProgramId>();
+
+            Result result = _baseFileSystemProxy.Get.GetRightsId(out RightsId rightsId, programId, storageId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.WriteStruct(rightsId);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(607)]
+        public ResultCode RegisterExternalKey(ServiceCtx context)
+        {
+            RightsId rightsId = context.RequestData.ReadStruct<RightsId>();
+            AccessKey accessKey = context.RequestData.ReadStruct<AccessKey>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.RegisterExternalKey(in rightsId, in accessKey).Value;
+        }
+
+        [CommandCmif(608)]
+        public ResultCode UnregisterAllExternalKey(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.UnregisterAllExternalKey().Value;
+        }
+
+        [CommandCmif(609)]
+        public ResultCode GetRightsIdByPath(ServiceCtx context)
+        {
+            ref readonly var path = ref FileSystemProxyHelper.GetFspPath(context);
+
+            Result result = _baseFileSystemProxy.Get.GetRightsIdByPath(out RightsId rightsId, in path);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.WriteStruct(rightsId);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(610)]
+        public ResultCode GetRightsIdAndKeyGenerationByPath(ServiceCtx context)
+        {
+            ref readonly var path = ref FileSystemProxyHelper.GetFspPath(context);
+
+            Result result = _baseFileSystemProxy.Get.GetRightsIdAndKeyGenerationByPath(out RightsId rightsId, out byte keyGeneration, in path);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(keyGeneration);
+            context.ResponseData.BaseStream.Seek(7, SeekOrigin.Current);
+            context.ResponseData.WriteStruct(rightsId);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(611)]
+        public ResultCode SetCurrentPosixTimeWithTimeDifference(ServiceCtx context)
+        {
+            int timeDifference = context.RequestData.ReadInt32();
+            context.RequestData.BaseStream.Seek(4, SeekOrigin.Current);
+            long time = context.RequestData.ReadInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.SetCurrentPosixTimeWithTimeDifference(time, timeDifference).Value;
+        }
+
+        [CommandCmif(612)]
+        public ResultCode GetFreeSpaceSizeForSaveData(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = context.RequestData.ReadStruct<SaveDataSpaceId>();
+
+            Result result = _baseFileSystemProxy.Get.GetFreeSpaceSizeForSaveData(out long freeSpaceSize, spaceId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(freeSpaceSize);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(613)]
+        public ResultCode VerifySaveDataFileSystemBySaveDataSpaceId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            byte[] readBuffer = new byte[context.Request.ReceiveBuff[0].Size];
+            context.Memory.Read(context.Request.ReceiveBuff[0].Position, readBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.VerifySaveDataFileSystemBySaveDataSpaceId(spaceId, saveDataId, new OutBuffer(readBuffer)).Value;
+        }
+
+        [CommandCmif(614)]
+        public ResultCode CorruptSaveDataFileSystemBySaveDataSpaceId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CorruptSaveDataFileSystemBySaveDataSpaceId(spaceId, saveDataId).Value;
+        }
+
+        [CommandCmif(615)]
+        public ResultCode QuerySaveDataInternalStorageTotalSize(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            Result result = _baseFileSystemProxy.Get.QuerySaveDataInternalStorageTotalSize(out long size, spaceId, saveDataId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(size);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(616)]
+        public ResultCode GetSaveDataCommitId(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+
+            Result result = _baseFileSystemProxy.Get.GetSaveDataCommitId(out long commitId, spaceId, saveDataId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(commitId);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(617)]
+        public ResultCode UnregisterExternalKey(ServiceCtx context)
+        {
+            RightsId rightsId = context.RequestData.ReadStruct<RightsId>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.UnregisterExternalKey(in rightsId).Value;
+        }
+
+        [CommandCmif(620)]
+        public ResultCode SetSdCardEncryptionSeed(ServiceCtx context)
+        {
+            EncryptionSeed encryptionSeed = context.RequestData.ReadStruct<EncryptionSeed>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.SetSdCardEncryptionSeed(in encryptionSeed).Value;
+        }
+
+        [CommandCmif(630)]
+        // SetSdCardAccessibility(u8 isAccessible)
+        public ResultCode SetSdCardAccessibility(ServiceCtx context)
+        {
+            bool isAccessible = context.RequestData.ReadBoolean();
+
+            return (ResultCode)_baseFileSystemProxy.Get.SetSdCardAccessibility(isAccessible).Value;
+        }
+
+        [CommandCmif(631)]
+        // IsSdCardAccessible() -> u8 isAccessible
+        public ResultCode IsSdCardAccessible(ServiceCtx context)
+        {
+            Result result = _baseFileSystemProxy.Get.IsSdCardAccessible(out bool isAccessible);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(isAccessible);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(702)]
+        public ResultCode IsAccessFailureDetected(ServiceCtx context)
+        {
+            ulong processId = context.RequestData.ReadUInt64();
+
+            Result result = _baseFileSystemProxy.Get.IsAccessFailureDetected(out bool isDetected, processId);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(isDetected);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(710)]
+        public ResultCode ResolveAccessFailure(ServiceCtx context)
+        {
+            ulong processId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.ResolveAccessFailure(processId).Value;
+        }
+
+        [CommandCmif(720)]
+        public ResultCode AbandonAccessFailure(ServiceCtx context)
+        {
+            ulong processId = context.RequestData.ReadUInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.AbandonAccessFailure(processId).Value;
+        }
+
+        [CommandCmif(800)]
+        public ResultCode GetAndClearErrorInfo(ServiceCtx context)
+        {
+            Result result = _baseFileSystemProxy.Get.GetAndClearErrorInfo(out FileSystemProxyErrorInfo errorInfo);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.WriteStruct(errorInfo);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(810)]
+        public ResultCode RegisterProgramIndexMapInfo(ServiceCtx context)
+        {
+            int programCount = context.RequestData.ReadInt32();
+
+            byte[] mapInfoBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, mapInfoBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.RegisterProgramIndexMapInfo(new InBuffer(mapInfoBuffer), programCount).Value;
+        }
+
+        [CommandCmif(1000)]
+        public ResultCode SetBisRootForHost(ServiceCtx context)
+        {
+            BisPartitionId partitionId = (BisPartitionId)context.RequestData.ReadInt32();
+            ref readonly var path = ref FileSystemProxyHelper.GetFspPath(context);
+
+            return (ResultCode)_baseFileSystemProxy.Get.SetBisRootForHost(partitionId, in path).Value;
+        }
+
+        [CommandCmif(1001)]
+        public ResultCode SetSaveDataSize(ServiceCtx context)
+        {
+            long dataSize = context.RequestData.ReadInt64();
+            long journalSize = context.RequestData.ReadInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.SetSaveDataSize(dataSize, journalSize).Value;
+        }
+
+        [CommandCmif(1002)]
+        public ResultCode SetSaveDataRootPath(ServiceCtx context)
+        {
+            ref readonly var path = ref FileSystemProxyHelper.GetFspPath(context);
+
+            return (ResultCode)_baseFileSystemProxy.Get.SetSaveDataRootPath(in path).Value;
+        }
+
+        [CommandCmif(1003)]
+        public ResultCode DisableAutoSaveDataCreation(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.DisableAutoSaveDataCreation().Value;
+        }
+
+        [CommandCmif(1004)]
+        // SetGlobalAccessLogMode(u32 mode)
+        public ResultCode SetGlobalAccessLogMode(ServiceCtx context)
+        {
+            int mode = context.RequestData.ReadInt32();
+
+            context.Device.System.GlobalAccessLogMode = mode;
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1005)]
+        // GetGlobalAccessLogMode() -> u32 logMode
+        public ResultCode GetGlobalAccessLogMode(ServiceCtx context)
+        {
+            int mode = context.Device.System.GlobalAccessLogMode;
+
+            context.ResponseData.Write(mode);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1006)]
+        // OutputAccessLogToSdCard(buffer<bytes, 5> log_text)
+        public ResultCode OutputAccessLogToSdCard(ServiceCtx context)
+        {
+            string message = ReadUtf8StringSend(context);
+
+            // FS ends each line with a newline. Remove it because Ryujinx logging adds its own newline
+            Logger.AccessLog?.PrintMsg(LogClass.ServiceFs, message.TrimEnd('\n'));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1007)]
+        public ResultCode RegisterUpdatePartition(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.RegisterUpdatePartition().Value;
+        }
+
+        [CommandCmif(1008)]
+        public ResultCode OpenRegisteredUpdatePartition(ServiceCtx context)
+        {
+            using var fileSystem = new SharedRef<IFileSystem>();
+
+            Result result = _baseFileSystemProxy.Get.OpenRegisteredUpdatePartition(ref fileSystem.Ref);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new FileSystemProxy.IFileSystem(ref fileSystem.Ref));
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1009)]
+        public ResultCode GetAndClearMemoryReportInfo(ServiceCtx context)
+        {
+            Result result = _baseFileSystemProxy.Get.GetAndClearMemoryReportInfo(out MemoryReportInfo reportInfo);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.WriteStruct(reportInfo);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1011)]
+        public ResultCode GetProgramIndexForAccessLog(ServiceCtx context)
+        {
+            Result result = _baseFileSystemProxy.Get.GetProgramIndexForAccessLog(out int programIndex, out int programCount);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(programIndex);
+            context.ResponseData.Write(programCount);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1012)]
+        public ResultCode GetFsStackUsage(ServiceCtx context)
+        {
+            FsStackUsageThreadType threadType = context.RequestData.ReadStruct<FsStackUsageThreadType>();
+
+            Result result = _baseFileSystemProxy.Get.GetFsStackUsage(out uint usage, threadType);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            context.ResponseData.Write(usage);
+
+            return ResultCode.Success;
+        }
+
+        [CommandCmif(1013)]
+        public ResultCode UnsetSaveDataRootPath(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.UnsetSaveDataRootPath().Value;
+        }
+
+        [CommandCmif(1014)]
+        public ResultCode OutputMultiProgramTagAccessLog(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.OutputMultiProgramTagAccessLog().Value;
+        }
+
+        [CommandCmif(1016)]
+        public ResultCode FlushAccessLogOnSdCard(ServiceCtx context)
+        {
+            return (ResultCode)_baseFileSystemProxy.Get.FlushAccessLogOnSdCard().Value;
+        }
+
+        [CommandCmif(1017)]
+        public ResultCode OutputApplicationInfoAccessLog(ServiceCtx context)
+        {
+            ApplicationInfo info = context.RequestData.ReadStruct<ApplicationInfo>();
+
+            return (ResultCode)_baseFileSystemProxy.Get.OutputApplicationInfoAccessLog(in info).Value;
+        }
+
+        [CommandCmif(1100)]
+        public ResultCode OverrideSaveDataTransferTokenSignVerificationKey(ServiceCtx context)
+        {
+            byte[] keyBuffer = new byte[context.Request.SendBuff[0].Size];
+            context.Memory.Read(context.Request.SendBuff[0].Position, keyBuffer);
+
+            return (ResultCode)_baseFileSystemProxy.Get.OverrideSaveDataTransferTokenSignVerificationKey(new InBuffer(keyBuffer)).Value;
+        }
+
+        [CommandCmif(1110)]
+        public ResultCode CorruptSaveDataFileSystemByOffset(ServiceCtx context)
+        {
+            SaveDataSpaceId spaceId = (SaveDataSpaceId)context.RequestData.ReadInt64();
+            ulong saveDataId = context.RequestData.ReadUInt64();
+            long offset = context.RequestData.ReadInt64();
+
+            return (ResultCode)_baseFileSystemProxy.Get.CorruptSaveDataFileSystemByOffset(spaceId, saveDataId, offset).Value;
+        }
+
+        [CommandCmif(1200)] // 6.0.0+
+        // OpenMultiCommitManager() -> object<nn::fssrv::sf::IMultiCommitManager>
+        public ResultCode OpenMultiCommitManager(ServiceCtx context)
+        {
+            using var commitManager = new SharedRef<LibHac.FsSrv.Sf.IMultiCommitManager>();
+
+            Result result = _baseFileSystemProxy.Get.OpenMultiCommitManager(ref commitManager.Ref);
+            if (result.IsFailure()) return (ResultCode)result.Value;
+
+            MakeObject(context, new IMultiCommitManager(ref commitManager.Ref));
+
+            return ResultCode.Success;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseFileSystemProxy.Destroy();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxyForLoader.cs b/src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxyForLoader.cs
new file mode 100644
index 00000000..a40821b9
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/IFileSystemProxyForLoader.cs
@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    [Service("fsp-ldr")]
+    class IFileSystemProxyForLoader : IpcService
+    {
+        public IFileSystemProxyForLoader(ServiceCtx context) { }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/IMultiCommitManager.cs b/src/Ryujinx.HLE/HOS/Services/Fs/IMultiCommitManager.cs
new file mode 100644
index 00000000..aa04a7e6
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/IMultiCommitManager.cs
@@ -0,0 +1,44 @@
+using LibHac;
+using LibHac.Common;
+using Ryujinx.HLE.HOS.Services.Fs.FileSystemProxy;
+
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    class IMultiCommitManager : DisposableIpcService // 6.0.0+
+    {
+        private SharedRef<LibHac.FsSrv.Sf.IMultiCommitManager> _baseCommitManager;
+
+        public IMultiCommitManager(ref SharedRef<LibHac.FsSrv.Sf.IMultiCommitManager> baseCommitManager)
+        {
+            _baseCommitManager = SharedRef<LibHac.FsSrv.Sf.IMultiCommitManager>.CreateMove(ref baseCommitManager);
+        }
+
+        [CommandCmif(1)] // 6.0.0+
+        // Add(object<nn::fssrv::sf::IFileSystem>)
+        public ResultCode Add(ServiceCtx context)
+        {
+            using SharedRef<LibHac.FsSrv.Sf.IFileSystem> fileSystem = GetObject<IFileSystem>(context, 0).GetBaseFileSystem();
+
+            Result result = _baseCommitManager.Get.Add(ref fileSystem.Ref);
+
+            return (ResultCode)result.Value;
+        }
+
+        [CommandCmif(2)] // 6.0.0+
+        // Commit()
+        public ResultCode Commit(ServiceCtx context)
+        {
+            Result result = _baseCommitManager.Get.Commit();
+
+            return (ResultCode)result.Value;
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseCommitManager.Destroy();
+            }
+        }
+    }
+}
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/IProgramRegistry.cs b/src/Ryujinx.HLE/HOS/Services/Fs/IProgramRegistry.cs
new file mode 100644
index 00000000..e11eadf5
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/IProgramRegistry.cs
@@ -0,0 +1,8 @@
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    [Service("fsp-pr")]
+    class IProgramRegistry : IpcService
+    {
+        public IProgramRegistry(ServiceCtx context) { }
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/ISaveDataInfoReader.cs b/src/Ryujinx.HLE/HOS/Services/Fs/ISaveDataInfoReader.cs
new file mode 100644
index 00000000..0611375b
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/ISaveDataInfoReader.cs
@@ -0,0 +1,41 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Sf;
+
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    class ISaveDataInfoReader : DisposableIpcService
+    {
+        private SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader> _baseReader;
+
+        public ISaveDataInfoReader(ref SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader> baseReader)
+        {
+            _baseReader = SharedRef<LibHac.FsSrv.Sf.ISaveDataInfoReader>.CreateMove(ref baseReader);
+        }
+
+        [CommandCmif(0)]
+        // ReadSaveDataInfo() -> (u64, buffer<unknown, 6>)
+        public ResultCode ReadSaveDataInfo(ServiceCtx context)
+        {
+            ulong bufferAddress = context.Request.ReceiveBuff[0].Position;
+            ulong bufferLen = context.Request.ReceiveBuff[0].Size;
+
+            using (var region = context.Memory.GetWritableRegion(bufferAddress, (int)bufferLen, true))
+            {
+                Result result = _baseReader.Get.Read(out long readCount, new OutBuffer(region.Memory.Span));
+
+                context.ResponseData.Write(readCount);
+
+                return (ResultCode)result.Value;
+            }
+        }
+
+        protected override void Dispose(bool isDisposing)
+        {
+            if (isDisposing)
+            {
+                _baseReader.Destroy();
+            }
+        }
+    }
+}
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/ResultCode.cs b/src/Ryujinx.HLE/HOS/Services/Fs/ResultCode.cs
new file mode 100644
index 00000000..8f87142b
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/ResultCode.cs
@@ -0,0 +1,16 @@
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    enum ResultCode
+    {
+        ModuleId       = 2,
+        ErrorCodeShift = 9,
+
+        Success = 0,
+
+        PathDoesNotExist  = (1    << ErrorCodeShift) | ModuleId,
+        PathAlreadyExists = (2    << ErrorCodeShift) | ModuleId,
+        PathAlreadyInUse  = (7    << ErrorCodeShift) | ModuleId,
+        PartitionNotFound = (1001 << ErrorCodeShift) | ModuleId,
+        InvalidInput      = (6001 << ErrorCodeShift) | ModuleId
+    }
+}
\ No newline at end of file
diff --git a/src/Ryujinx.HLE/HOS/Services/Fs/Types/FileSystemType.cs b/src/Ryujinx.HLE/HOS/Services/Fs/Types/FileSystemType.cs
new file mode 100644
index 00000000..f12c1661
--- /dev/null
+++ b/src/Ryujinx.HLE/HOS/Services/Fs/Types/FileSystemType.cs
@@ -0,0 +1,12 @@
+namespace Ryujinx.HLE.HOS.Services.Fs
+{
+    enum FileSystemType
+    {
+        Logo               = 2,
+        ContentControl     = 3,
+        ContentManual      = 4,
+        ContentMeta        = 5,
+        ContentData        = 6,
+        ApplicationPackage = 7
+    }
+}
\ No newline at end of file