From cee712105850ac3385cd0091a923438167433f9f Mon Sep 17 00:00:00 2001
From: TSR Berry <20988865+TSRBerry@users.noreply.github.com>
Date: Sat, 8 Apr 2023 01:22:00 +0200
Subject: Move solution and projects to src
---
src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs | 615 ++++++++++++++++++++++++
1 file changed, 615 insertions(+)
create mode 100644 src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs
(limited to 'src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs')
diff --git a/src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs b/src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs
new file mode 100644
index 00000000..1b3968ea
--- /dev/null
+++ b/src/Ryujinx.HLE/FileSystem/VirtualFileSystem.cs
@@ -0,0 +1,615 @@
+using LibHac;
+using LibHac.Common;
+using LibHac.Common.Keys;
+using LibHac.Fs;
+using LibHac.Fs.Fsa;
+using LibHac.Fs.Shim;
+using LibHac.FsSrv;
+using LibHac.FsSystem;
+using LibHac.Ncm;
+using LibHac.Spl;
+using LibHac.Tools.Es;
+using LibHac.Tools.Fs;
+using LibHac.Tools.FsSystem;
+using Ryujinx.Common.Configuration;
+using Ryujinx.Common.Logging;
+using Ryujinx.HLE.HOS;
+using System;
+using System.Buffers.Text;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.IO;
+using System.Runtime.CompilerServices;
+using Path = System.IO.Path;
+using RightsId = LibHac.Fs.RightsId;
+
+namespace Ryujinx.HLE.FileSystem
+{
+ public class VirtualFileSystem : IDisposable
+ {
+ public static string SafeNandPath = Path.Combine(AppDataManager.DefaultNandDir, "safe");
+ public static string SystemNandPath = Path.Combine(AppDataManager.DefaultNandDir, "system");
+ public static string UserNandPath = Path.Combine(AppDataManager.DefaultNandDir, "user");
+
+ public KeySet KeySet { get; private set; }
+ public EmulatedGameCard GameCard { get; private set; }
+ public EmulatedSdCard SdCard { get; private set; }
+ public ModLoader ModLoader { get; private set; }
+
+ private readonly ConcurrentDictionary<ulong, Stream> _romFsByPid;
+
+ private static bool _isInitialized = false;
+
+ public static VirtualFileSystem CreateInstance()
+ {
+ if (_isInitialized)
+ {
+ throw new InvalidOperationException("VirtualFileSystem can only be instantiated once!");
+ }
+
+ _isInitialized = true;
+
+ return new VirtualFileSystem();
+ }
+
+ private VirtualFileSystem()
+ {
+ ReloadKeySet();
+ ModLoader = new ModLoader(); // Should only be created once
+ _romFsByPid = new ConcurrentDictionary<ulong, Stream>();
+ }
+
+ public void LoadRomFs(ulong pid, string fileName)
+ {
+ var romfsStream = new FileStream(fileName, FileMode.Open, FileAccess.Read);
+
+ _romFsByPid.AddOrUpdate(pid, romfsStream, (pid, oldStream) =>
+ {
+ oldStream.Close();
+
+ return romfsStream;
+ });
+ }
+
+ public void SetRomFs(ulong pid, Stream romfsStream)
+ {
+ _romFsByPid.AddOrUpdate(pid, romfsStream, (pid, oldStream) =>
+ {
+ oldStream.Close();
+
+ return romfsStream;
+ });
+ }
+
+ public Stream GetRomFs(ulong pid)
+ {
+ return _romFsByPid[pid];
+ }
+
+ public string GetFullPath(string basePath, string fileName)
+ {
+ if (fileName.StartsWith("//"))
+ {
+ fileName = fileName.Substring(2);
+ }
+ else if (fileName.StartsWith('/'))
+ {
+ fileName = fileName.Substring(1);
+ }
+ else
+ {
+ return null;
+ }
+
+ string fullPath = Path.GetFullPath(Path.Combine(basePath, fileName));
+
+ if (!fullPath.StartsWith(AppDataManager.BaseDirPath))
+ {
+ return null;
+ }
+
+ return fullPath;
+ }
+
+ internal string GetSdCardPath() => MakeFullPath(AppDataManager.DefaultSdcardDir);
+ public string GetNandPath() => MakeFullPath(AppDataManager.DefaultNandDir);
+
+ public string SwitchPathToSystemPath(string switchPath)
+ {
+ string[] parts = switchPath.Split(":");
+
+ if (parts.Length != 2)
+ {
+ return null;
+ }
+
+ return GetFullPath(MakeFullPath(parts[0]), parts[1]);
+ }
+
+ public string SystemPathToSwitchPath(string systemPath)
+ {
+ string baseSystemPath = AppDataManager.BaseDirPath + Path.DirectorySeparatorChar;
+
+ if (systemPath.StartsWith(baseSystemPath))
+ {
+ string rawPath = systemPath.Replace(baseSystemPath, "");
+ int firstSeparatorOffset = rawPath.IndexOf(Path.DirectorySeparatorChar);
+
+ if (firstSeparatorOffset == -1)
+ {
+ return $"{rawPath}:/";
+ }
+
+ var basePath = rawPath.AsSpan(0, firstSeparatorOffset);
+ var fileName = rawPath.AsSpan(firstSeparatorOffset + 1);
+
+ return $"{basePath}:/{fileName}";
+ }
+
+ return null;
+ }
+
+ private string MakeFullPath(string path, bool isDirectory = true)
+ {
+ // Handles Common Switch Content Paths
+ switch (path)
+ {
+ case ContentPath.SdCard:
+ path = AppDataManager.DefaultSdcardDir;
+ break;
+ case ContentPath.User:
+ path = UserNandPath;
+ break;
+ case ContentPath.System:
+ path = SystemNandPath;
+ break;
+ case ContentPath.SdCardContent:
+ path = Path.Combine(AppDataManager.DefaultSdcardDir, "Nintendo", "Contents");
+ break;
+ case ContentPath.UserContent:
+ path = Path.Combine(UserNandPath, "Contents");
+ break;
+ case ContentPath.SystemContent:
+ path = Path.Combine(SystemNandPath, "Contents");
+ break;
+ }
+
+ string fullPath = Path.Combine(AppDataManager.BaseDirPath, path);
+
+ if (isDirectory && !Directory.Exists(fullPath))
+ {
+ Directory.CreateDirectory(fullPath);
+ }
+
+ return fullPath;
+ }
+
+ public void InitializeFsServer(LibHac.Horizon horizon, out HorizonClient fsServerClient)
+ {
+ LocalFileSystem serverBaseFs = new LocalFileSystem(AppDataManager.BaseDirPath);
+
+ fsServerClient = horizon.CreatePrivilegedHorizonClient();
+ var fsServer = new FileSystemServer(fsServerClient);
+
+ RandomDataGenerator randomGenerator = Random.Shared.NextBytes;
+
+ DefaultFsServerObjects fsServerObjects = DefaultFsServerObjects.GetDefaultEmulatedCreators(serverBaseFs, KeySet, fsServer, randomGenerator);
+
+ // Use our own encrypted fs creator that doesn't actually do any encryption
+ fsServerObjects.FsCreators.EncryptedFileSystemCreator = new EncryptedFileSystemCreator();
+
+ GameCard = fsServerObjects.GameCard;
+ SdCard = fsServerObjects.SdCard;
+
+ SdCard.SetSdCardInsertionStatus(true);
+
+ var fsServerConfig = new FileSystemServerConfig
+ {
+ DeviceOperator = fsServerObjects.DeviceOperator,
+ ExternalKeySet = KeySet.ExternalKeySet,
+ FsCreators = fsServerObjects.FsCreators,
+ RandomGenerator = randomGenerator
+ };
+
+ FileSystemServerInitializer.InitializeWithConfig(fsServerClient, fsServer, fsServerConfig);
+ }
+
+ public void ReloadKeySet()
+ {
+ KeySet ??= KeySet.CreateDefaultKeySet();
+
+ string keyFile = null;
+ string titleKeyFile = null;
+ string consoleKeyFile = null;
+
+ if (AppDataManager.Mode == AppDataManager.LaunchMode.UserProfile)
+ {
+ LoadSetAtPath(AppDataManager.KeysDirPathUser);
+ }
+
+ LoadSetAtPath(AppDataManager.KeysDirPath);
+
+ void LoadSetAtPath(string basePath)
+ {
+ string localKeyFile = Path.Combine(basePath, "prod.keys");
+ string localTitleKeyFile = Path.Combine(basePath, "title.keys");
+ string localConsoleKeyFile = Path.Combine(basePath, "console.keys");
+
+ if (File.Exists(localKeyFile))
+ {
+ keyFile = localKeyFile;
+ }
+
+ if (File.Exists(localTitleKeyFile))
+ {
+ titleKeyFile = localTitleKeyFile;
+ }
+
+ if (File.Exists(localConsoleKeyFile))
+ {
+ consoleKeyFile = localConsoleKeyFile;
+ }
+ }
+
+ ExternalKeyReader.ReadKeyFile(KeySet, keyFile, titleKeyFile, consoleKeyFile, null);
+ }
+
+ public void ImportTickets(IFileSystem fs)
+ {
+ foreach (DirectoryEntryEx ticketEntry in fs.EnumerateEntries("/", "*.tik"))
+ {
+ using var ticketFile = new UniqueRef<IFile>();
+
+ Result result = fs.OpenFile(ref ticketFile.Ref, ticketEntry.FullPath.ToU8Span(), OpenMode.Read);
+
+ if (result.IsSuccess())
+ {
+ Ticket ticket = new(ticketFile.Get.AsStream());
+ var titleKey = ticket.GetTitleKey(KeySet);
+
+ if (titleKey != null)
+ {
+ KeySet.ExternalKeySet.Add(new RightsId(ticket.RightsId), new AccessKey(titleKey));
+ }
+ }
+ }
+ }
+
+ // Save data created before we supported extra data in directory save data will not work properly if
+ // given empty extra data. Luckily some of that extra data can be created using the data from the
+ // save data indexer, which should be enough to check access permissions for user saves.
+ // Every single save data's extra data will be checked and fixed if needed each time the emulator is opened.
+ // Consider removing this at some point in the future when we don't need to worry about old saves.
+ public static Result FixExtraData(HorizonClient hos)
+ {
+ Result rc = GetSystemSaveList(hos, out List<ulong> systemSaveIds);
+ if (rc.IsFailure()) return rc;
+
+ rc = FixUnindexedSystemSaves(hos, systemSaveIds);
+ if (rc.IsFailure()) return rc;
+
+ rc = FixExtraDataInSpaceId(hos, SaveDataSpaceId.System);
+ if (rc.IsFailure()) return rc;
+
+ rc = FixExtraDataInSpaceId(hos, SaveDataSpaceId.User);
+ if (rc.IsFailure()) return rc;
+
+ return Result.Success;
+ }
+
+ private static Result FixExtraDataInSpaceId(HorizonClient hos, SaveDataSpaceId spaceId)
+ {
+ Span<SaveDataInfo> info = stackalloc SaveDataInfo[8];
+
+ using var iterator = new UniqueRef<SaveDataIterator>();
+
+ Result rc = hos.Fs.OpenSaveDataIterator(ref iterator.Ref, spaceId);
+ if (rc.IsFailure()) return rc;
+
+ while (true)
+ {
+ rc = iterator.Get.ReadSaveDataInfo(out long count, info);
+ if (rc.IsFailure()) return rc;
+
+ if (count == 0)
+ return Result.Success;
+
+ for (int i = 0; i < count; i++)
+ {
+ rc = FixExtraData(out bool wasFixNeeded, hos, in info[i]);
+
+ if (ResultFs.TargetNotFound.Includes(rc))
+ {
+ // If the save wasn't found, try to create the directory for its save data ID
+ rc = CreateSaveDataDirectory(hos, in info[i]);
+
+ if (rc.IsFailure())
+ {
+ Logger.Warning?.Print(LogClass.Application, $"Error {rc.ToStringWithName()} when creating save data 0x{info[i].SaveDataId:x} in the {spaceId} save data space");
+
+ // Don't bother fixing the extra data if we couldn't create the directory
+ continue;
+ }
+
+ Logger.Info?.Print(LogClass.Application, $"Recreated directory for save data 0x{info[i].SaveDataId:x} in the {spaceId} save data space");
+
+ // Try to fix the extra data in the new directory
+ rc = FixExtraData(out wasFixNeeded, hos, in info[i]);
+ }
+
+ if (rc.IsFailure())
+ {
+ Logger.Warning?.Print(LogClass.Application, $"Error {rc.ToStringWithName()} when fixing extra data for save data 0x{info[i].SaveDataId:x} in the {spaceId} save data space");
+ }
+ else if (wasFixNeeded)
+ {
+ Logger.Info?.Print(LogClass.Application, $"Fixed extra data for save data 0x{info[i].SaveDataId:x} in the {spaceId} save data space");
+ }
+ }
+ }
+ }
+
+ private static Result CreateSaveDataDirectory(HorizonClient hos, in SaveDataInfo info)
+ {
+ if (info.SpaceId != SaveDataSpaceId.User && info.SpaceId != SaveDataSpaceId.System)
+ return Result.Success;
+
+ const string mountName = "SaveDir";
+ var mountNameU8 = mountName.ToU8Span();
+
+ BisPartitionId partitionId = info.SpaceId switch
+ {
+ SaveDataSpaceId.System => BisPartitionId.System,
+ SaveDataSpaceId.User => BisPartitionId.User,
+ _ => throw new ArgumentOutOfRangeException()
+ };
+
+ Result rc = hos.Fs.MountBis(mountNameU8, partitionId);
+ if (rc.IsFailure()) return rc;
+ try
+ {
+ var path = $"{mountName}:/save/{info.SaveDataId:x16}".ToU8Span();
+
+ rc = hos.Fs.GetEntryType(out _, path);
+
+ if (ResultFs.PathNotFound.Includes(rc))
+ {
+ rc = hos.Fs.CreateDirectory(path);
+ }
+
+ return rc;
+ }
+ finally
+ {
+ hos.Fs.Unmount(mountNameU8);
+ }
+ }
+
+ // Gets a list of all the save data files or directories in the system partition.
+ private static Result GetSystemSaveList(HorizonClient hos, out List<ulong> list)
+ {
+ list = null;
+
+ var mountName = "system".ToU8Span();
+ DirectoryHandle handle = default;
+ List<ulong> localList = new List<ulong>();
+
+ try
+ {
+ Result rc = hos.Fs.MountBis(mountName, BisPartitionId.System);
+ if (rc.IsFailure()) return rc;
+
+ rc = hos.Fs.OpenDirectory(out handle, "system:/save".ToU8Span(), OpenDirectoryMode.All);
+ if (rc.IsFailure()) return rc;
+
+ DirectoryEntry entry = new DirectoryEntry();
+
+ while (true)
+ {
+ rc = hos.Fs.ReadDirectory(out long readCount, SpanHelpers.AsSpan(ref entry), handle);
+ if (rc.IsFailure()) return rc;
+
+ if (readCount == 0)
+ break;
+
+ if (Utf8Parser.TryParse(entry.Name, out ulong saveDataId, out int bytesRead, 'x') &&
+ bytesRead == 16 && (long)saveDataId < 0)
+ {
+ localList.Add(saveDataId);
+ }
+ }
+
+ list = localList;
+
+ return Result.Success;
+ }
+ finally
+ {
+ if (handle.IsValid)
+ {
+ hos.Fs.CloseDirectory(handle);
+ }
+
+ if (hos.Fs.IsMounted(mountName))
+ {
+ hos.Fs.Unmount(mountName);
+ }
+ }
+ }
+
+ // Adds system save data that isn't in the save data indexer to the indexer and creates extra data for it.
+ // Only save data IDs added to SystemExtraDataFixInfo will be fixed.
+ private static Result FixUnindexedSystemSaves(HorizonClient hos, List<ulong> existingSaveIds)
+ {
+ foreach (var fixInfo in SystemExtraDataFixInfo)
+ {
+ if (!existingSaveIds.Contains(fixInfo.StaticSaveDataId))
+ {
+ continue;
+ }
+
+ Result rc = FixSystemExtraData(out bool wasFixNeeded, hos, in fixInfo);
+
+ if (rc.IsFailure())
+ {
+ Logger.Warning?.Print(LogClass.Application,
+ $"Error {rc.ToStringWithName()} when fixing extra data for system save data 0x{fixInfo.StaticSaveDataId:x}");
+ }
+ else if (wasFixNeeded)
+ {
+ Logger.Info?.Print(LogClass.Application,
+ $"Tried to rebuild extra data for system save data 0x{fixInfo.StaticSaveDataId:x}");
+ }
+ }
+
+ return Result.Success;
+ }
+
+ private static Result FixSystemExtraData(out bool wasFixNeeded, HorizonClient hos, in ExtraDataFixInfo info)
+ {
+ wasFixNeeded = true;
+
+ Result rc = hos.Fs.Impl.ReadSaveDataFileSystemExtraData(out SaveDataExtraData extraData, info.StaticSaveDataId);
+ if (!rc.IsSuccess())
+ {
+ if (!ResultFs.TargetNotFound.Includes(rc))
+ return rc;
+
+ // We'll reach this point only if the save data directory exists but it's not in the save data indexer.
+ // Creating the save will add it to the indexer while leaving its existing contents intact.
+ return hos.Fs.CreateSystemSaveData(info.StaticSaveDataId, UserId.InvalidId, info.OwnerId, info.DataSize,
+ info.JournalSize, info.Flags);
+ }
+
+ if (extraData.Attribute.StaticSaveDataId != 0 && extraData.OwnerId != 0)
+ {
+ wasFixNeeded = false;
+ return Result.Success;
+ }
+
+ extraData = new SaveDataExtraData
+ {
+ Attribute = { StaticSaveDataId = info.StaticSaveDataId },
+ OwnerId = info.OwnerId,
+ Flags = info.Flags,
+ DataSize = info.DataSize,
+ JournalSize = info.JournalSize
+ };
+
+ // Make a mask for writing the entire extra data
+ Unsafe.SkipInit(out SaveDataExtraData extraDataMask);
+ SpanHelpers.AsByteSpan(ref extraDataMask).Fill(0xFF);
+
+ return hos.Fs.Impl.WriteSaveDataFileSystemExtraData(SaveDataSpaceId.System, info.StaticSaveDataId,
+ in extraData, in extraDataMask);
+ }
+
+ private static Result FixExtraData(out bool wasFixNeeded, HorizonClient hos, in SaveDataInfo info)
+ {
+ wasFixNeeded = true;
+
+ Result rc = hos.Fs.Impl.ReadSaveDataFileSystemExtraData(out SaveDataExtraData extraData, info.SpaceId,
+ info.SaveDataId);
+ if (rc.IsFailure()) return rc;
+
+ // The extra data should have program ID or static save data ID set if it's valid.
+ // We only try to fix the extra data if the info from the save data indexer has a program ID or static save data ID.
+ bool canFixByProgramId = extraData.Attribute.ProgramId == ProgramId.InvalidId &&
+ info.ProgramId != ProgramId.InvalidId;
+
+ bool canFixBySaveDataId = extraData.Attribute.StaticSaveDataId == 0 && info.StaticSaveDataId != 0;
+
+ bool hasEmptyOwnerId = extraData.OwnerId == 0 && info.Type != SaveDataType.System;
+
+ if (!canFixByProgramId && !canFixBySaveDataId && !hasEmptyOwnerId)
+ {
+ wasFixNeeded = false;
+ return Result.Success;
+ }
+
+ // The save data attribute struct can be completely created from the save data info.
+ extraData.Attribute.ProgramId = info.ProgramId;
+ extraData.Attribute.UserId = info.UserId;
+ extraData.Attribute.StaticSaveDataId = info.StaticSaveDataId;
+ extraData.Attribute.Type = info.Type;
+ extraData.Attribute.Rank = info.Rank;
+ extraData.Attribute.Index = info.Index;
+
+ // The rest of the extra data can't be created from the save data info.
+ // On user saves the owner ID will almost certainly be the same as the program ID.
+ if (info.Type != SaveDataType.System)
+ {
+ extraData.OwnerId = info.ProgramId.Value;
+ }
+ else
+ {
+ // Try to match the system save with one of the known saves
+ foreach (ExtraDataFixInfo fixInfo in SystemExtraDataFixInfo)
+ {
+ if (extraData.Attribute.StaticSaveDataId == fixInfo.StaticSaveDataId)
+ {
+ extraData.OwnerId = fixInfo.OwnerId;
+ extraData.Flags = fixInfo.Flags;
+ extraData.DataSize = fixInfo.DataSize;
+ extraData.JournalSize = fixInfo.JournalSize;
+
+ break;
+ }
+ }
+ }
+
+ // Make a mask for writing the entire extra data
+ Unsafe.SkipInit(out SaveDataExtraData extraDataMask);
+ SpanHelpers.AsByteSpan(ref extraDataMask).Fill(0xFF);
+
+ return hos.Fs.Impl.WriteSaveDataFileSystemExtraData(info.SpaceId, info.SaveDataId, in extraData, in extraDataMask);
+ }
+
+ struct ExtraDataFixInfo
+ {
+ public ulong StaticSaveDataId;
+ public ulong OwnerId;
+ public SaveDataFlags Flags;
+ public long DataSize;
+ public long JournalSize;
+ }
+
+ private static readonly ExtraDataFixInfo[] SystemExtraDataFixInfo =
+ {
+ new ExtraDataFixInfo()
+ {
+ StaticSaveDataId = 0x8000000000000030,
+ OwnerId = 0x010000000000001F,
+ Flags = SaveDataFlags.KeepAfterResettingSystemSaveDataWithoutUserSaveData,
+ DataSize = 0x10000,
+ JournalSize = 0x10000
+ },
+ new ExtraDataFixInfo()
+ {
+ StaticSaveDataId = 0x8000000000001040,
+ OwnerId = 0x0100000000001009,
+ Flags = SaveDataFlags.None,
+ DataSize = 0xC000,
+ JournalSize = 0xC000
+ }
+ };
+
+ public void Dispose()
+ {
+ Dispose(true);
+ }
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (disposing)
+ {
+ foreach (var stream in _romFsByPid.Values)
+ {
+ stream.Close();
+ }
+
+ _romFsByPid.Clear();
+ }
+ }
+ }
+}
\ No newline at end of file
--
cgit v1.2.3-70-g09d2