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;
}
