public void Register(ReferenceCountedDisposable <DirectorySaveDataFileSystem> fileSystem) { if (_maxCachedFileSystemCount <= 0) { return; } Assert.SdkRequiresGreaterEqual(_nextCacheIndex, 0); Assert.SdkRequiresGreater(_maxCachedFileSystemCount, _nextCacheIndex); if (fileSystem.Target.GetSaveDataSpaceId() == SaveDataSpaceId.SdSystem) { return; } Result rc = fileSystem.Target.Rollback(); if (rc.IsFailure()) { return; } using ScopedLock <SdkRecursiveMutexType> scopedLock = ScopedLock.Lock(ref _mutex); _cachedFileSystems[_nextCacheIndex].Register(fileSystem.AddReference <IFileSystem>(), fileSystem.Target.GetSaveDataSpaceId(), fileSystem.Target.GetSaveDataId()); _nextCacheIndex = (_nextCacheIndex + 1) % _maxCachedFileSystemCount; }
public static Result CreateSubDirectoryFileSystem(out ReferenceCountedDisposable <IFileSystem> subDirFileSystem, ref ReferenceCountedDisposable <IFileSystem> baseFileSystem, U8Span subPath, bool preserveUnc = false) { UnsafeHelpers.SkipParamInit(out subDirFileSystem); // Check if the directory exists Result rc = baseFileSystem.Target.OpenDirectory(out IDirectory dir, subPath, OpenDirectoryMode.Directory); if (rc.IsFailure()) { return(rc); } dir.Dispose(); var fs = new SubdirectoryFileSystem(ref baseFileSystem, preserveUnc); using (var subDirFs = new ReferenceCountedDisposable <SubdirectoryFileSystem>(fs)) { rc = subDirFs.Target.Initialize(subPath); if (rc.IsFailure()) { return(rc); } subDirFileSystem = subDirFs.AddReference <IFileSystem>(); return(Result.Success); } }
public Result Create(out ReferenceCountedDisposable <IFileSystem> subDirFileSystem, ref ReferenceCountedDisposable <IFileSystem> baseFileSystem, U8Span path, bool preserveUnc) { UnsafeHelpers.SkipParamInit(out subDirFileSystem); // Verify the sub-path exists Result rc = baseFileSystem.Target.OpenDirectory(out IDirectory _, path, OpenDirectoryMode.Directory); if (rc.IsFailure()) { return(rc); } // Initialize the SubdirectoryFileSystem var subDir = new SubdirectoryFileSystem(ref baseFileSystem, preserveUnc); using var subDirShared = new ReferenceCountedDisposable <SubdirectoryFileSystem>(subDir); rc = subDirShared.Target.Initialize(path); if (rc.IsFailure()) { return(rc); } subDirFileSystem = subDirShared.AddReference <IFileSystem>(); return(Result.Success); }
public AesXtsFileSystem(ReferenceCountedDisposable <IFileSystem> fs, byte[] keys, int blockSize) { SharedBaseFileSystem = fs.AddReference(); BaseFileSystem = SharedBaseFileSystem.Target; KekSource = keys.AsSpan(0, 0x10).ToArray(); ValidationKey = keys.AsSpan(0x10, 0x10).ToArray(); BlockSize = blockSize; }
public static ReferenceCountedDisposable <IFileSystem> CreateShared( ReferenceCountedDisposable <IFileSystem> baseFileSystem, ISaveDataFileSystemCacheManager cacheManager) { IFileSystem baseFsTarget = baseFileSystem.Target; switch (baseFsTarget) { case SaveDataFileSystem: { ReferenceCountedDisposable <SaveDataFileSystem> castedFs = baseFileSystem.AddReference <SaveDataFileSystem>(); return(new ReferenceCountedDisposable <IFileSystem>( new SaveDataFileSystemCacheRegisterBase <SaveDataFileSystem>(ref castedFs, cacheManager))); } case ApplicationTemporaryFileSystem: { ReferenceCountedDisposable <ApplicationTemporaryFileSystem> castedFs = baseFileSystem.AddReference <ApplicationTemporaryFileSystem>(); return(new ReferenceCountedDisposable <IFileSystem>( new SaveDataFileSystemCacheRegisterBase <ApplicationTemporaryFileSystem>(ref castedFs, cacheManager))); } case DirectorySaveDataFileSystem: { ReferenceCountedDisposable <DirectorySaveDataFileSystem> castedFs = baseFileSystem.AddReference <DirectorySaveDataFileSystem>(); return(new ReferenceCountedDisposable <IFileSystem>( new SaveDataFileSystemCacheRegisterBase <DirectorySaveDataFileSystem>(ref castedFs, cacheManager))); } default: Assert.SdkAssert(false, "Invalid save data file system type."); return(null); } }
public Result Initialize(ReferenceCountedDisposable <IStorage> baseStorage) { Result rc = Initialize(baseStorage.Target); if (rc.IsFailure()) { return(rc); } BaseStorageShared = baseStorage.AddReference(); return(Result.Success); }
/// <summary> /// Creates a <see cref="SubStorage"/> from a subsection of another <see cref="IStorage"/>. /// Holds a reference to <paramref name="sharedBaseStorage"/> until disposed. /// </summary> /// <param name="sharedBaseStorage">The base IStorage.</param> /// <param name="offset">The offset in the base storage at which to begin the created SubStorage.</param> /// <param name="size">The size of the SubStorage.</param> public SubStorage(ReferenceCountedDisposable <IStorage> sharedBaseStorage, long offset, long size) { SharedBaseStorage = sharedBaseStorage.AddReference(); BaseStorage = SharedBaseStorage.Target; Offset = offset; Size = size; IsResizable = false; Assert.AssertTrue(IsValid()); Assert.AssertTrue(Offset >= 0); Assert.AssertTrue(Size >= 0); }
/// <summary> /// Creates a <see cref="SubStorage"/> from a subsection of another <see cref="IStorage"/>. /// Holds a reference to <paramref name="sharedBaseStorage"/> until disposed. /// </summary> /// <param name="sharedBaseStorage">The base IStorage.</param> /// <param name="offset">The offset in the base storage at which to begin the created SubStorage.</param> /// <param name="size">The size of the SubStorage.</param> public SubStorage(ReferenceCountedDisposable <IStorage> sharedBaseStorage, long offset, long size) { SharedBaseStorage = sharedBaseStorage.AddReference(); BaseStorage = SharedBaseStorage.Target; Offset = offset; Size = size; IsResizable = false; Assert.SdkRequiresNotNull(sharedBaseStorage); Assert.SdkRequiresLessEqual(0, Offset); Assert.SdkRequiresLessEqual(0, Size); }
public static ReferenceCountedDisposable <IFileSystem> CreateShared( ref ReferenceCountedDisposable <IFileSystem> fileSystem, ref ReferenceCountedDisposable <IRomFileSystemAccessFailureManager> accessFailureManager) { ReferenceCountedDisposable <DeepRetryFileSystem> sharedRetryFileSystem = null; try { var retryFileSystem = new DeepRetryFileSystem(ref fileSystem, ref accessFailureManager); sharedRetryFileSystem = new ReferenceCountedDisposable <DeepRetryFileSystem>(retryFileSystem); retryFileSystem.SelfReference = new ReferenceCountedDisposable <DeepRetryFileSystem> .WeakReference(sharedRetryFileSystem); return(sharedRetryFileSystem.AddReference <IFileSystem>()); } finally { sharedRetryFileSystem?.Dispose(); } }
public FileServiceObjectAdapter(ReferenceCountedDisposable <IFileSf> baseFile) { BaseFile = baseFile.AddReference(); }
public Result Create(out ReferenceCountedDisposable <IFileSystem> fileSystem, out ReferenceCountedDisposable <ISaveDataExtraDataAccessor> extraDataAccessor, ISaveDataFileSystemCacheManager cacheManager, ref ReferenceCountedDisposable <IFileSystem> baseFileSystem, SaveDataSpaceId spaceId, ulong saveDataId, bool allowDirectorySaveData, bool useDeviceUniqueMac, bool isJournalingSupported, bool isMultiCommitSupported, bool openReadOnly, bool openShared, ISaveDataCommitTimeStampGetter timeStampGetter) { Span <byte> saveImageName = stackalloc byte[0x12]; UnsafeHelpers.SkipParamInit(out fileSystem, out extraDataAccessor); Assert.SdkRequiresNotNull(cacheManager); var sb = new U8StringBuilder(saveImageName); sb.Append((byte)'/').AppendFormat(saveDataId, 'x', 16); Result rc = baseFileSystem.Target.GetEntryType(out DirectoryEntryType type, new U8Span(saveImageName)); if (rc.IsFailure()) { return(ResultFs.PathNotFound.Includes(rc) ? ResultFs.TargetNotFound.LogConverted(rc) : rc); } if (type == DirectoryEntryType.Directory) { if (!allowDirectorySaveData) { return(ResultFs.InvalidSaveDataEntryType.Log()); } SubdirectoryFileSystem subDirFs = null; ReferenceCountedDisposable <DirectorySaveDataFileSystem> saveFs = null; try { subDirFs = new SubdirectoryFileSystem(ref baseFileSystem); rc = subDirFs.Initialize(new U8Span(saveImageName)); if (rc.IsFailure()) { return(rc); } saveFs = DirectorySaveDataFileSystem.CreateShared(Shared.Move(ref subDirFs), _fsServer.Hos.Fs); rc = saveFs.Target.Initialize(timeStampGetter, _randomGenerator, isJournalingSupported, isMultiCommitSupported, !openReadOnly); if (rc.IsFailure()) { return(rc); } fileSystem = saveFs.AddReference <IFileSystem>(); extraDataAccessor = saveFs.AddReference <ISaveDataExtraDataAccessor>(); return(Result.Success); } finally { subDirFs?.Dispose(); saveFs?.Dispose(); } } ReferenceCountedDisposable <IStorage> fileStorage = null; try { Optional <OpenType> openType = openShared ? new Optional <OpenType>(OpenType.Normal) : new Optional <OpenType>(); rc = _fsServer.OpenSaveDataStorage(out fileStorage, ref baseFileSystem, spaceId, saveDataId, OpenMode.ReadWrite, openType); if (rc.IsFailure()) { return(rc); } if (!isJournalingSupported) { throw new NotImplementedException(); } // Todo: Properly handle shared storage fileSystem = new ReferenceCountedDisposable <IFileSystem>(new SaveDataFileSystem(_keySet, fileStorage.Target, IntegrityCheckLevel.ErrorOnInvalid, false)); // Todo: ISaveDataExtraDataAccessor return(Result.Success); } finally { fileStorage?.Dispose(); } }
public DirectoryServiceObjectAdapter(ReferenceCountedDisposable <IDirectorySf> baseDirectory) { BaseDirectory = baseDirectory.AddReference(); }
/// <summary> /// Initializes a new <see cref="FileSystemInterfaceAdapter"/> by creating /// a new reference to <paramref name="fileSystem"/>. /// </summary> /// <param name="fileSystem">The base file system.</param> /// <param name="isHostFsRoot">Does the base file system come from the root directory of a host file system?</param> private FileSystemInterfaceAdapter(ReferenceCountedDisposable <IFileSystem> fileSystem, bool isHostFsRoot = false) { BaseFileSystem = fileSystem.AddReference(); IsHostFsRoot = isHostFsRoot; }
public StorageServiceObjectAdapter(ReferenceCountedDisposable <IStorageSf> baseStorage) { BaseStorage = baseStorage.AddReference(); }
public FileSystemServiceObjectAdapter(ReferenceCountedDisposable <IFileSystemSf> baseFileSystem) { BaseFs = baseFileSystem.AddReference(); }
public ForwardingFileSystem(ReferenceCountedDisposable <IFileSystem> baseFileSystem) { BaseFileSystem = baseFileSystem.AddReference(); }
public ReferenceCountedDisposable <SaveDataOpenTypeSetFileStorage> GetStorage() { return(_storage.AddReference()); }
public LocationResolver(ReferenceCountedDisposable <ILocationResolver> baseInterface) { _interface = baseInterface.AddReference(); }
// todo: Implement properly public Result Create(out ReferenceCountedDisposable <IFileSystem> fileSystem, ReferenceCountedDisposable <IStorage> romFsStorage) { // Todo: Properly use shared references fileSystem = new ReferenceCountedDisposable <IFileSystem>(new RomFsFileSystem(romFsStorage.AddReference().Target)); return(Result.Success); }
public StorageLayoutTypeSetFileSystem(ReferenceCountedDisposable <IFileSystem> baseFileSystem, StorageType storageFlag) { BaseFileSystem = baseFileSystem.AddReference(); StorageFlag = storageFlag; }