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 static Result GetAndClearPatrolReadAllocateBufferCount(this StorageService service,
out long successCount, out long failureCount)
{
UnsafeHelpers.SkipParamInit(out successCount, out failureCount);
ReferenceCountedDisposable <IStorageDeviceOperator> mmcOperator = null;
try
{
Result rc = service.GetMmcManagerOperator(out mmcOperator);
if (rc.IsFailure())
{
return(rc);
}
int operationId = MakeOperationId(MmcManagerOperationIdValue.GetAndClearPatrolReadAllocateBufferCount);
OutBuffer successCountBuffer = OutBuffer.FromStruct(ref successCount);
OutBuffer failureCountBuffer = OutBuffer.FromStruct(ref failureCount);
return(mmcOperator.Target.OperateOut2(out _, successCountBuffer, out _, failureCountBuffer,
operationId));
}
finally
{
mmcOperator?.Dispose();
}
}
public MemoryMappedInfo(ReferenceCountedDisposable <MemoryMappedFile> memoryMappedFile, string name, long offset, long size)
{
_memoryMappedFile = memoryMappedFile;
Name = name;
Offset = offset;
Size = size;
}
public Result OpenAccessFailureDetectionEventNotifier(out ReferenceCountedDisposable <IEventNotifier> notifier,
ulong processId, bool notifyOnDeepRetry)
{
UnsafeHelpers.SkipParamInit(out notifier);
Result rc = GetProgramInfo(out ProgramInfo programInfo);
if (rc.IsFailure())
{
return(rc);
}
if (!programInfo.AccessControl.CanCall(OperationType.OpenAccessFailureDetectionEventNotifier))
{
return(ResultFs.PermissionDenied.Log());
}
rc = _serviceImpl.CreateNotifier(out IEventNotifier tempNotifier, processId, notifyOnDeepRetry);
if (rc.IsFailure())
{
return(rc);
}
notifier = new ReferenceCountedDisposable <IEventNotifier>(tempNotifier);
return(Result.Success);
}
public FileInterfaceAdapter(IFile baseFile,
ref ReferenceCountedDisposable <FileSystemInterfaceAdapter> parentFileSystem)
{
BaseFile = baseFile;
ParentFs = parentFileSystem;
parentFileSystem = null;
}
/// <summary>
/// Initializes a new <see cref="FileSystemInterfaceAdapter"/> cast to an <see cref="IFileSystemSf"/>
/// by moving the input file system object. Avoids allocations from incrementing and then decrementing the ref-count.
/// </summary>
/// <param name="baseFileSystem">The base file system. Will be null upon returning.</param>
/// <param name="isHostFsRoot">Does the base file system come from the root directory of a host file system?</param>
public static ReferenceCountedDisposable <IFileSystemSf> CreateShared(
ref ReferenceCountedDisposable <IFileSystem> baseFileSystem, bool isHostFsRoot = false)
{
var adapter = new FileSystemInterfaceAdapter(ref baseFileSystem, isHostFsRoot);
return(ReferenceCountedDisposable <IFileSystemSf> .Create(adapter, out adapter._selfReference));
}
public MultiCommitManager(
ref ReferenceCountedDisposable <ISaveDataMultiCommitCoreInterface> multiCommitInterface,
HorizonClient client)
{
Hos = client;
MultiCommitInterface = Shared.Move(ref multiCommitInterface);
}
public static Result GetRightsId(this FileSystemClient fs, out FsRightsId rightsId, ProgramId programId,
StorageId storageId)
{
using ReferenceCountedDisposable <IFileSystemProxy> fsProxy = fs.Impl.GetFileSystemProxyServiceObject();
return(fsProxy.Target.GetRightsId(out rightsId, programId, storageId));
}
public UniqueLockWithPin(ref UniqueLockSemaphore semaphore, ref ReferenceCountedDisposable <T> pinnedObject)
{
Shared.Move(out _semaphore, ref semaphore);
Shared.Move(out _pinnedObject, ref pinnedObject);
Assert.True(_semaphore.IsLocked);
}
public Result OpenBaseFileSystem(out ReferenceCountedDisposable <IFileSystemSf> fileSystem,
BaseFileSystemId fileSystemId)
{
UnsafeHelpers.SkipParamInit(out fileSystem);
Result rc = CheckCapabilityById(fileSystemId, _processId);
if (rc.IsFailure())
{
return(rc);
}
ReferenceCountedDisposable <IFileSystem> fs = null;
try
{
// Open the file system
rc = _serviceImpl.OpenBaseFileSystem(out fs, fileSystemId);
if (rc.IsFailure())
{
return(rc);
}
// Create an SF adapter for the file system
fileSystem = FileSystemInterfaceAdapter.CreateShared(ref fs);
return(Result.Success);
}
finally
{
fs?.Dispose();
}
}
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);
}
static Result Mount(FileSystemClientImpl fs, U8Span mountName, BisPartitionId partitionId)
{
Result rc = fs.CheckMountNameAcceptingReservedMountName(mountName);
if (rc.IsFailure())
{
return(rc);
}
using ReferenceCountedDisposable <IFileSystemProxy> fsProxy = fs.GetFileSystemProxyServiceObject();
// Nintendo doesn't use the provided rootPath
FspPath.CreateEmpty(out FspPath sfPath);
ReferenceCountedDisposable <IFileSystemSf> fileSystem = null;
try
{
rc = fsProxy.Target.OpenBisFileSystem(out fileSystem, in sfPath, partitionId);
if (rc.IsFailure())
{
return(rc);
}
var nameGenerator = new BisCommonMountNameGenerator(partitionId);
var fileSystemAdapter = new FileSystemServiceObjectAdapter(fileSystem);
return(fs.Fs.Register(mountName, fileSystemAdapter, nameGenerator));
}
finally
{
fileSystem?.Dispose();
}
}
private void LocationServiceStorageLocationChanging(object sender, PersistentStorageLocationChangingEventArgs e)
{
ReferenceCountedDisposable <IPersistentStorage> storage = null;
lock (_lock)
{
if (e.SolutionId != _currentPersistentStorageSolutionId)
{
return;
}
// We will transfer ownership in a thread-safe way out so we can dispose outside the lock
storage = _currentPersistentStorage;
_currentPersistentStorage = null;
_currentPersistentStorageSolutionId = null;
}
if (storage != null)
{
if (e.MustUseNewStorageLocationImmediately)
{
// Dispose storage outside of the lock. Note this only removes our reference count; clients who are still
// using this will still be holding a reference count.
storage.Dispose();
}
else
{
// make it to shutdown asynchronously
Task.Run(() => storage.Dispose());
}
}
}
public static Result WrapSubDirectory(out ReferenceCountedDisposable <IFileSystem> fileSystem,
ref ReferenceCountedDisposable <IFileSystem> baseFileSystem, U8Span path, bool createIfMissing)
{
UnsafeHelpers.SkipParamInit(out fileSystem);
// The path must already exist if we're not automatically creating it
if (!createIfMissing)
{
Result result = baseFileSystem.Target.GetEntryType(out _, path);
if (result.IsFailure())
{
return(result);
}
}
// Ensure the path exists or check if it's a directory
Result rc = EnsureDirectory(baseFileSystem.Target, path);
if (rc.IsFailure())
{
return(rc);
}
return(CreateSubDirectoryFileSystem(out fileSystem, ref baseFileSystem, path));
}
public void TestWeakReferenceLifetime()
{
var target = new DisposableObject();
var reference = new ReferenceCountedDisposable <DisposableObject>(target);
var weakReference = new ReferenceCountedDisposable <DisposableObject> .WeakReference(reference);
var reference2 = reference.TryAddReference();
Assert.NotNull(reference2);
reference.Dispose();
// TryAddReference fails after dispose for a counted reference
Assert.Null(reference.TryAddReference());
Assert.NotNull(reference2.Target);
Assert.False(target.IsDisposed);
// However, a WeakReference created from the disposed reference can still add a reference
var reference3 = weakReference.TryAddReference();
Assert.NotNull(reference3);
reference2.Dispose();
Assert.False(target.IsDisposed);
reference3.Dispose();
Assert.True(target.IsDisposed);
}
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;
}
/// <summary>
/// Initializes a new <see cref="FileSystemInterfaceAdapter"/> by moving the file system object.
/// Avoids allocations from incrementing and then decrementing the ref-count.
/// </summary>
/// <param name="fileSystem">The base file system. Will be null upon returning.</param>
/// <param name="isHostFsRoot">Does the base file system come from the root directory of a host file system?</param>
private FileSystemInterfaceAdapter(ref ReferenceCountedDisposable <IFileSystem> fileSystem,
bool isHostFsRoot = false)
{
BaseFileSystem = fileSystem;
fileSystem = null;
IsHostFsRoot = isHostFsRoot;
}
static Result Mount(FileSystemClient fs, U8Span mountName, GameCardHandle handle,
GameCardPartition partitionId)
{
Result rc = fs.Impl.CheckMountNameAcceptingReservedMountName(mountName);
if (rc.IsFailure())
{
return(rc);
}
using ReferenceCountedDisposable <IFileSystemProxy> fsProxy = fs.Impl.GetFileSystemProxyServiceObject();
ReferenceCountedDisposable <IFileSystemSf> fileSystem = null;
try
{
rc = fsProxy.Target.OpenGameCardFileSystem(out fileSystem, handle, partitionId);
if (rc.IsFailure())
{
return(rc);
}
var fileSystemAdapter = new FileSystemServiceObjectAdapter(fileSystem);
var mountNameGenerator = new GameCardCommonMountNameGenerator(handle, partitionId);
return(fs.Register(mountName, fileSystemAdapter, mountNameGenerator));
}
finally
{
fileSystem?.Dispose();
}
}
/// <summary>
/// Commits all added file systems.
/// </summary>
/// <returns>The <see cref="Result"/> of the operation.</returns>
public Result Commit()
{
lock (Locker)
{
Result rc = EnsureSaveDataForContext();
if (rc.IsFailure())
{
return(rc);
}
ReferenceCountedDisposable <IFileSystem> contextFs = null;
try
{
rc = MultiCommitInterface.Target.OpenMultiCommitContext(out contextFs);
if (rc.IsFailure())
{
return(rc);
}
return(Commit(contextFs.Target));
}
finally
{
contextFs?.Dispose();
}
}
}
public static Result GetGameCardHandle(this FileSystemClient fs, out GameCardHandle handle)
{
UnsafeHelpers.SkipParamInit(out handle);
using ReferenceCountedDisposable <IFileSystemProxy> fsProxy = fs.Impl.GetFileSystemProxyServiceObject();
ReferenceCountedDisposable <IDeviceOperator> deviceOperator = null;
try
{
Result rc = fsProxy.Target.OpenDeviceOperator(out deviceOperator);
fs.Impl.AbortIfNeeded(rc);
if (rc.IsFailure())
{
return(rc);
}
rc = deviceOperator.Target.GetGameCardHandle(out handle);
fs.Impl.AbortIfNeeded(rc);
return(rc);
}
finally
{
deviceOperator?.Dispose();
}
}
protected override void Dispose(bool disposing)
{
if (_baseFileSystem is null)
{
return;
}
if (disposing)
{
if (typeof(T) == typeof(SaveDataFileSystem))
{
_cacheManager.Register(
(ReferenceCountedDisposable <SaveDataFileSystem>)(object) _baseFileSystem);
}
else if (typeof(T) == typeof(ApplicationTemporaryFileSystem))
{
_cacheManager.Register(
(ReferenceCountedDisposable <ApplicationTemporaryFileSystem>)(object) _baseFileSystem);
}
else if (typeof(T) == typeof(DirectorySaveDataFileSystem))
{
_cacheManager.Register(
(ReferenceCountedDisposable <DirectorySaveDataFileSystem>)(object) _baseFileSystem);
}
_baseFileSystem.Dispose();
_baseFileSystem = null;
}
base.Dispose(disposing);
}
public static ReferenceCountedDisposable <IFileSystem> CreateShared(
ref ReferenceCountedDisposable <IFileSystem> baseFileSystem)
{
var resultConvertFileSystem = new SaveDataResultConvertFileSystem(ref baseFileSystem);
return(new ReferenceCountedDisposable <IFileSystem>(resultConvertFileSystem));
}
/// <summary>
/// Caller is responsible for disposing the returned stream.
/// multiple call of this will not increase VM.
/// </summary>
public Stream CreateReadableStream()
{
// Note: TryAddReference behaves according to its documentation even if the target object has been
// disposed. If it returns non-null, then the object will not be disposed before the returned
// reference is disposed (see comments on _memoryMappedFile and TryAddReference).
var streamAccessor = _weakReadAccessor.TryAddReference();
if (streamAccessor == null)
{
var rawAccessor = RunWithCompactingGCFallback(
info =>
info._memoryMappedFile.Target.CreateViewAccessor(
info.Offset,
info.Size,
MemoryMappedFileAccess.Read
),
this
);
streamAccessor = new ReferenceCountedDisposable <MemoryMappedViewAccessor>(
rawAccessor
);
_weakReadAccessor =
new ReferenceCountedDisposable <MemoryMappedViewAccessor> .WeakReference(
streamAccessor
);
}
Debug.Assert(streamAccessor.Target.CanRead);
return(new SharedReadableStream(streamAccessor, Size));
}
public static ReferenceCountedDisposable <ISaveDataExtraDataAccessor> CreateShared(
ref ReferenceCountedDisposable <ISaveDataExtraDataAccessor> accessor)
{
var resultConvertAccessor = new SaveDataExtraDataResultConvertAccessor(ref accessor);
return(new ReferenceCountedDisposable <ISaveDataExtraDataAccessor>(resultConvertAccessor));
}
public static Result GetAndClearMmcErrorInfo(this StorageService service, out StorageErrorInfo errorInfo,
out long logSize, Span <byte> logBuffer)
{
UnsafeHelpers.SkipParamInit(out errorInfo, out logSize);
ReferenceCountedDisposable <IStorageDeviceOperator> mmcOperator = null;
try
{
Result rc = service.GetMmcManagerOperator(out mmcOperator);
if (rc.IsFailure())
{
return(rc);
}
int operationId = MakeOperationId(MmcManagerOperationIdValue.GetAndClearErrorInfo);
var logOutBuffer = new OutBuffer(logBuffer);
OutBuffer errorInfoOutBuffer = OutBuffer.FromStruct(ref errorInfo);
return(mmcOperator.Target.OperateOut2(out _, errorInfoOutBuffer, out logSize, logOutBuffer,
operationId));
}
finally
{
mmcOperator?.Dispose();
}
}
public static ReferenceCountedDisposable <IStorageSf> CreateShared(
ref ReferenceCountedDisposable <IStorage> baseStorage)
{
var adapter = new StorageInterfaceAdapter(ref baseStorage);
return(new ReferenceCountedDisposable <IStorageSf>(adapter));
}
protected OpenCountFileSystem(ref ReferenceCountedDisposable <IFileSystem> baseFileSystem,
ref ReferenceCountedDisposable <IEntryOpenCountSemaphoreManager> entryCountSemaphore,
ref IUniqueLock mountCountSemaphore) : base(ref baseFileSystem)
{
Shared.Move(out _entryCountSemaphore, ref entryCountSemaphore);
Shared.Move(out _mountCountSemaphore, ref mountCountSemaphore);
}
public IReferenceCountedDisposable <IRuleSetFile> GetOrCreateRuleSet(string ruleSetFileFullPath)
{
ReferenceCountedDisposable <RuleSetFile> disposable = null;
lock (_gate)
{
// If we already have one in the map to hand out, great
if (_ruleSetFileMap.TryGetValue(ruleSetFileFullPath, out var weakReference))
{
disposable = weakReference.TryAddReference();
}
if (disposable == null)
{
// We didn't easily get a disposable, so one of two things is the case:
//
// 1. We have no entry in _ruleSetFileMap at all for this.
// 2. We had an entry, but it was disposed and is no longer valid.
// In either case, we'll create a new rule set file and add it to the map.
disposable = new ReferenceCountedDisposable <RuleSetFile>(new RuleSetFile(ruleSetFileFullPath, this));
_ruleSetFileMap[ruleSetFileFullPath] = new ReferenceCountedDisposable <RuleSetFile> .WeakReference(disposable);
}
}
// Call InitializeFileTracking outside the lock, so we don't have requests for other files blocking behind the initialization of this one.
// RuleSetFile itself will ensure InitializeFileTracking is locked as appropriate.
disposable.Target.InitializeFileTracking(_fileChangeWatcher);
return(disposable);
}
private async IAsyncEnumerable <SuggestedActionSet> GetCodeFixesAndRefactoringsAsync(
ReferenceCountedDisposable <State> state,
ISuggestedActionCategorySet requestedActionCategories,
Document document,
SnapshotSpan range,
TextSpan?selection,
Func <string, IDisposable?> addOperationScope,
CodeActionRequestPriority priority,
int currentActionCount,
[EnumeratorCancellation] CancellationToken cancellationToken)
{
var workspace = document.Project.Solution.Workspace;
var supportsFeatureService = workspace.Services.GetRequiredService <ITextBufferSupportsFeatureService>();
var fixesTask = GetCodeFixesAsync(
state, supportsFeatureService, requestedActionCategories, workspace, document, range,
addOperationScope, priority, isBlocking: false, cancellationToken);
var refactoringsTask = GetRefactoringsAsync(
state, supportsFeatureService, requestedActionCategories, GlobalOptions, workspace, document, selection,
addOperationScope, priority, isBlocking: false, cancellationToken);
await Task.WhenAll(fixesTask, refactoringsTask).ConfigureAwait(false);
var fixes = await fixesTask.ConfigureAwait(false);
var refactorings = await refactoringsTask.ConfigureAwait(false);
foreach (var set in ConvertToSuggestedActionSets(state, selection, fixes, refactorings, currentActionCount))
{
yield return(set);
}
}
static Result OpenFileSystem(FileSystemClient fs, ReferenceCountedDisposable <IFileSystemProxy> fsProxy,
out ReferenceCountedDisposable <IFileSystemSf> fileSystem)
{
UnsafeHelpers.SkipParamInit(out fileSystem);
// Retry a few times if the storage device isn't ready yet
const int maxRetries = 10;
const int retryInterval = 1000;
for (int i = 0; i < maxRetries; i++)
{
Result rc = fsProxy.Target.OpenSdCardFileSystem(out fileSystem);
if (rc.IsSuccess())
{
break;
}
if (!ResultFs.StorageDeviceNotReady.Includes(rc))
{
return(rc);
}
if (i == maxRetries - 1)
{
return(rc);
}
fs.Hos.Os.SleepThread(TimeSpan.FromMilliSeconds(retryInterval));
}
return(Result.Success);
}
