+ internal ServiceTable ServiceTable { get; private set; }

+

+ ServiceTable = new ServiceTable();

+ context.Device.System.ServiceTable.WaitServicesReady();

+

+ Logger.Debug?.Print(LogClass.ServiceSm, $"Register \"{name}\".");

+ if (args.Length == 0)

+ generator.AppendLine($"{{ {commandId}, new CommandHandler({method.Identifier.Text}, Array.Empty<CommandArg>()) }},");

+ }

+ else

+ {

+ int index = 0;

+ foreach (var parameter in method.ParameterList.Parameters)

+ string canonicalTypeName = GetCanonicalTypeNameWithGenericArguments(compilation, parameter.Type);

+ CommandArgType argType = GetCommandArgType(compilation, parameter);

+

+ string arg;

+ if (argType == CommandArgType.Buffer)

+ {

+ string bufferFlags = GetFirstAttributeAgument(compilation, parameter, TypeBufferAttribute, 0);

+ string bufferFixedSize = GetFirstAttributeAgument(compilation, parameter, TypeBufferAttribute, 1);

+

+ if (bufferFixedSize != null)

+ {

+ arg = $"new CommandArg({bufferFlags}, {bufferFixedSize})";

+ }

+ else

+ {

+ arg = $"new CommandArg({bufferFlags})";

+ }

+ }

+ else if (argType == CommandArgType.InArgument || argType == CommandArgType.OutArgument)

+ string alignment = GetTypeAlignmentExpression(compilation, parameter.Type);

+

+ arg = $"new CommandArg(CommandArgType.{argType}, Unsafe.SizeOf<{canonicalTypeName}>(), {alignment})";

+ arg = $"new CommandArg(CommandArgType.{argType})";

+ args[index++] = arg;

+ generator.AppendLine($"{{ {commandId}, new CommandHandler({method.Identifier.Text}, {string.Join(", ", args)}) }},");

+ public ulong Size { get; }

+ Size = size;

+ _freeRanges = new List<Range>();

+ ulong sizeDelta = alignedOffset - range.Offset;

+ ulong usableSize = range.Size - sizeDelta;

+ ulong endOffset = range.Offset + range.Size;

+ public bool IgnoreMissingServices { get; }

+ public bool ThrowOnInvalidCommandIds { get; }

+ IgnoreMissingServices = ignoreMissingServices;

+ ThrowOnInvalidCommandIds = true;

+ public static HorizonOptions Options => _options;

+ public static ISyscallApi Syscall => _syscall;

+ public static IVirtualMemoryManager AddressSpace => _addressSpace;

+ public static IThreadContext ThreadContext => _threadContext;

+ public static int CurrentThreadHandle => _threadHandle;

+ HorizonOptions options,

+ ISyscallApi syscallApi,

+ IThreadContext threadContext,

+ int threadHandle)

+ _options = options;

+ _syscall = syscallApi;

+ _addressSpace = addressSpace;

+ _threadHandle = threadHandle;

+ abstract static void Main(ServiceTable serviceTable);

+namespace Ryujinx.Horizon.LogManager.Ipc

+ partial class LmLogger : ILmLogger

+ private readonly LogService _log;

+ private readonly ulong _pid;

+ public LmLogger(LogService log, ulong pid)

+ _pid = pid;

+ if (!SetProcessId(message, _pid))

+ [CmifCommand(1)] // 3.0.0+

+ SpanReader reader = new(message);

+ LogPacketHeader header = reader.Read<LogPacketHeader>();

+ StringBuilder builder = new();

+ builder.AppendLine($"Guest Log:\n Log level: {header.Severity}");

+ string fieldStr;

+ builder.AppendLine($" {fieldStr}");

+ return builder.ToString();

+ int count = 0;

+} \ No newline at end of file

+namespace Ryujinx.Horizon.LogManager.Ipc

+ partial class LogService : ILogService

+ public Result OpenLogger(out LmLogger logger, [ClientProcessId] ulong pid)

+ // NOTE: Internal name is Logger, but we rename it LmLogger to avoid name clash with Ryujinx.Common.Logging logger.

+ logger = new LmLogger(this, pid);

+} \ No newline at end of file

+using Ryujinx.Horizon.LogManager.Ipc;

+using Ryujinx.Horizon.Sdk.Sf.Hipc;

+ private const int MaxDomains = 31;

+ private const int MaxDomainObjects = 61;

+ private const int MaxPortsCount = 1;

+ private static readonly ManagerOptions _logManagerOptions = new(PointerBufferSize, MaxDomains, MaxDomainObjects, false);

+ private SmApi _sm;

+ HeapAllocator allocator = new();

+ _serverManager.RegisterObjectForServer(new LogService(), ServiceName.Encode("lm"), LogMaxSessionsCount);

+} \ No newline at end of file

+ public static void Main(ServiceTable serviceTable)

+ LmIpcServer ipcServer = new();

+

+ serviceTable.SignalServiceReady();

+

+} \ No newline at end of file

+using MsgPack;

+using MsgPack.Serialization;

+using Ryujinx.Common.Logging;

+using Ryujinx.Common.Utilities;

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.Prepo.Types;

+using Ryujinx.Horizon.Sdk.Account;

+using Ryujinx.Horizon.Sdk.Prepo;

+using Ryujinx.Horizon.Sdk.Sf;

+using Ryujinx.Horizon.Sdk.Sf.Hipc;

+using System;

+using System.Text;

+

+namespace Ryujinx.Horizon.Prepo.Ipc

+{

+ partial class PrepoService : IPrepoService

+ {

+ enum PlayReportKind

+ {

+ Normal,

+ System

+ }

+

+ private readonly PrepoServicePermissionLevel _permissionLevel;

+ private ulong _systemSessionId;

+

+ private bool _immediateTransmissionEnabled = false;

+ private bool _userAgreementCheckEnabled = true;

+

+ public PrepoService(PrepoServicePermissionLevel permissionLevel)

+ {

+ _permissionLevel = permissionLevel;

+ }

+

+ [CmifCommand(10100)] // 1.0.0-5.1.0

+ [CmifCommand(10102)] // 6.0.0-9.2.0

+ [CmifCommand(10104)] // 10.0.0+

+ public Result SaveReport([Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer)] ReadOnlySpan<byte> gameRoomBuffer, [Buffer(HipcBufferFlags.In | HipcBufferFlags.MapAlias)] ReadOnlySpan<byte> reportBuffer, [ClientProcessId] ulong pid)

+ {

+ if ((_permissionLevel & PrepoServicePermissionLevel.User) == 0)

+ {

+ return PrepoResult.PermissionDenied;

+ }

+

+ ProcessPlayReport(PlayReportKind.Normal, pid, gameRoomBuffer, reportBuffer, Uid.Null);

+

+ return Result.Success;

+ }

+

+ [CmifCommand(10101)] // 1.0.0-5.1.0

+ [CmifCommand(10103)] // 6.0.0-9.2.0

+ [CmifCommand(10105)] // 10.0.0+

+ public Result SaveReportWithUser(Uid userId, [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer)] ReadOnlySpan<byte> gameRoomBuffer, [Buffer(HipcBufferFlags.In | HipcBufferFlags.MapAlias)] ReadOnlySpan<byte> reportBuffer, [ClientProcessId] ulong pid)

+ {

+ if ((_permissionLevel & PrepoServicePermissionLevel.User) == 0)

+ {

+ return PrepoResult.PermissionDenied;

+ }

+

+ ProcessPlayReport(PlayReportKind.Normal, pid, gameRoomBuffer, reportBuffer, userId, true);

+

+ return Result.Success;

+ }

+

+ [CmifCommand(10200)]

+ public Result RequestImmediateTransmission()

+ {

+ _immediateTransmissionEnabled = true;

+

+ // It signals an event of nn::prepo::detail::service::core::TransmissionStatusManager that requests the transmission of the report.

+ // Since we don't use reports, it's fine to do nothing.

+

+ return Result.Success;

+ }

+

+ [CmifCommand(10300)]

+ public Result GetTransmissionStatus(out int status)

+ {

+ status = 0;

+

+ if (_immediateTransmissionEnabled && _userAgreementCheckEnabled)

+ {

+ status = 1;

+ }

+

+ return Result.Success;

+ }

+

+ [CmifCommand(10400)] // 9.0.0+

+ public Result GetSystemSessionId(out ulong systemSessionId)

+ {

+ systemSessionId = default;

+

+ if ((_permissionLevel & PrepoServicePermissionLevel.User) == 0)

+ {

+ return PrepoResult.PermissionDenied;

+ }

+

+ if (_systemSessionId == 0)

+ {

+ _systemSessionId = (ulong)Random.Shared.NextInt64();

+ }

+

+ systemSessionId = _systemSessionId;

+

+ return Result.Success;

+ }

+

+ [CmifCommand(20100)]

+ public Result SaveSystemReport([Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer)] ReadOnlySpan<byte> gameRoomBuffer, [Buffer(HipcBufferFlags.In | HipcBufferFlags.MapAlias)] ReadOnlySpan<byte> reportBuffer, [ClientProcessId] ulong pid)

+ {

+ if ((_permissionLevel & PrepoServicePermissionLevel.System) != 0)

+ {

+ return PrepoResult.PermissionDenied;

+ }

+

+ return ProcessPlayReport(PlayReportKind.System, pid, gameRoomBuffer, reportBuffer, Uid.Null);

+ }

+

+ [CmifCommand(20101)]

+ public Result SaveSystemReportWithUser(Uid userId, [Buffer(HipcBufferFlags.In | HipcBufferFlags.Pointer)] ReadOnlySpan<byte> gameRoomBuffer, [Buffer(HipcBufferFlags.In | HipcBufferFlags.MapAlias)] ReadOnlySpan<byte> reportBuffer, [ClientProcessId] ulong pid)

+ {

+ if ((_permissionLevel & PrepoServicePermissionLevel.System) != 0)

+ {

+ return PrepoResult.PermissionDenied;

+ }

+

+ return ProcessPlayReport(PlayReportKind.System, pid, gameRoomBuffer, reportBuffer, userId, true);

+ }

+

+ [CmifCommand(40100)] // 2.0.0+

+ public Result IsUserAgreementCheckEnabled(out bool enabled)

+ {

+ enabled = false;

+

+ if (_permissionLevel == PrepoServicePermissionLevel.User || _permissionLevel == PrepoServicePermissionLevel.System)

+ {

+ enabled = _userAgreementCheckEnabled;

+

+ // If "enabled" is false, it sets some internal fields to 0.

+ // Then, it mounts "prepo-sys:/is_user_agreement_check_enabled.bin" and returns the contained bool.

+ // We can return the private bool instead, we don't care about the agreement since we don't send reports.

+

+ return Result.Success;

+ }

+

+ return PrepoResult.PermissionDenied;

+ }

+

+ [CmifCommand(40101)] // 2.0.0+

+ public Result SetUserAgreementCheckEnabled(bool enabled)

+ {

+ if (_permissionLevel == PrepoServicePermissionLevel.User || _permissionLevel == PrepoServicePermissionLevel.System)

+ {

+ _userAgreementCheckEnabled = enabled;

+

+ // If "enabled" is false, it sets some internal fields to 0.

+ // Then, it mounts "prepo-sys:/is_user_agreement_check_enabled.bin" and stores the "enabled" value.

+ // We can store in the private bool instead, we don't care about the agreement since we don't send reports.

+

+ return Result.Success;

+ }

+

+ return PrepoResult.PermissionDenied;

+ }

+

+ private static Result ProcessPlayReport(PlayReportKind playReportKind, ulong pid, ReadOnlySpan<byte> gameRoomBuffer, ReadOnlySpan<byte> reportBuffer, Uid userId, bool withUserId = false)

+ {

+ if (withUserId)

+ {

+ if (userId.IsNull)

+ {

+ return PrepoResult.InvalidArgument;

+ }

+ }

+

+ if (gameRoomBuffer.Length > 31)

+ {

+ return PrepoResult.InvalidArgument;

+ }

+

+ string gameRoom = Encoding.UTF8.GetString(gameRoomBuffer).TrimEnd();

+

+ if (gameRoom == string.Empty)

+ {

+ return PrepoResult.InvalidState;

+ }

+

+ if (reportBuffer.Length == 0)

+ {

+ return PrepoResult.InvalidBufferSize;

+ }

+

+ // NOTE: The service calls arp:r using the pid to get the application id, if it fails PrepoResult.InvalidPid is returned.

+ // Reports are stored internally and an event is signaled to transmit them.

+

+ StringBuilder builder = new();

+ MessagePackObject deserializedReport = MessagePackSerializer.UnpackMessagePackObject(reportBuffer.ToArray());

+

+ builder.AppendLine();

+ builder.AppendLine("PlayReport log:");

+ builder.AppendLine($" Kind: {playReportKind}");

+ builder.AppendLine($" Pid: {pid}");

+

+ if (!userId.IsNull)

+ {

+ builder.AppendLine($" UserId: {userId}");

+ }

+

+ builder.AppendLine($" Room: {gameRoom}");

+ builder.AppendLine($" Report: {MessagePackObjectFormatter.Format(deserializedReport)}");

+

+ Logger.Info?.Print(LogClass.ServicePrepo, builder.ToString());

+

+ return Result.Success;

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Prepo.Types;

+using Ryujinx.Horizon.Sdk.Sf.Hipc;

+using Ryujinx.Horizon.Sdk.Sm;

+

+namespace Ryujinx.Horizon.Prepo

+{

+ class PrepoIpcServer

+ {

+ private const int PrepoMaxSessionsCount = 12;

+ private const int PrepoTotalMaxSessionsCount = PrepoMaxSessionsCount * 6;

+

+ private const int PointerBufferSize = 0x3800;

+ private const int MaxDomains = 64;

+ private const int MaxDomainObjects = 16;

+ private const int MaxPortsCount = 6;

+

+ private static readonly ManagerOptions _logManagerOptions = new(PointerBufferSize, MaxDomains, MaxDomainObjects, false);

+

+ private SmApi _sm;

+ private PrepoServerManager _serverManager;

+

+ public void Initialize()

+ {

+ HeapAllocator allocator = new();

+

+ _sm = new SmApi();

+ _sm.Initialize().AbortOnFailure();

+

+ _serverManager = new PrepoServerManager(allocator, _sm, MaxPortsCount, _logManagerOptions, PrepoTotalMaxSessionsCount);

+

+ _serverManager.RegisterServer((int)PrepoPortIndex.Admin, ServiceName.Encode("prepo:a"), PrepoMaxSessionsCount); // 1.0.0-5.1.0

+ _serverManager.RegisterServer((int)PrepoPortIndex.Admin2, ServiceName.Encode("prepo:a2"), PrepoMaxSessionsCount); // 6.0.0+

+ _serverManager.RegisterServer((int)PrepoPortIndex.Manager, ServiceName.Encode("prepo:m"), PrepoMaxSessionsCount);

+ _serverManager.RegisterServer((int)PrepoPortIndex.User, ServiceName.Encode("prepo:u"), PrepoMaxSessionsCount);

+ _serverManager.RegisterServer((int)PrepoPortIndex.System, ServiceName.Encode("prepo:s"), PrepoMaxSessionsCount);

+ _serverManager.RegisterServer((int)PrepoPortIndex.Debug, ServiceName.Encode("prepo:d"), PrepoMaxSessionsCount); // 1.0.0

+ }

+

+ public void ServiceRequests()

+ {

+ _serverManager.ServiceRequests();

+ }

+

+ public void Shutdown()

+ {

+ _serverManager.Dispose();

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.Horizon.Prepo

+{

+ class PrepoMain : IService

+ {

+ public static void Main(ServiceTable serviceTable)

+ {

+ PrepoIpcServer ipcServer = new();

+

+ ipcServer.Initialize();

+

+ serviceTable.SignalServiceReady();

+

+ ipcServer.ServiceRequests();

+ ipcServer.Shutdown();

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+

+namespace Ryujinx.Horizon.Prepo

+{

+ static class PrepoResult

+ {

+ private const int ModuleId = 129;

+

+ public static Result InvalidArgument => new(ModuleId, 1);

+ public static Result InvalidState => new(ModuleId, 5);

+ public static Result InvalidBufferSize => new(ModuleId, 9);

+ public static Result PermissionDenied => new(ModuleId, 90);

+ public static Result InvalidPid => new(ModuleId, 101);

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.Prepo.Ipc;

+using Ryujinx.Horizon.Prepo.Types;

+using Ryujinx.Horizon.Sdk.Sf.Hipc;

+using Ryujinx.Horizon.Sdk.Sm;

+using System;

+

+namespace Ryujinx.Horizon.Prepo

+{

+ class PrepoServerManager : ServerManager

+ {

+ public PrepoServerManager(HeapAllocator allocator, SmApi sm, int maxPorts, ManagerOptions options, int maxSessions) : base(allocator, sm, maxPorts, options, maxSessions)

+ {

+ }

+

+ protected override Result OnNeedsToAccept(int portIndex, Server server)

+ {

+ return (PrepoPortIndex)portIndex switch

+ {

+ PrepoPortIndex.Admin => AcceptImpl(server, new PrepoService(PrepoServicePermissionLevel.Admin)),

+ PrepoPortIndex.Admin2 => AcceptImpl(server, new PrepoService(PrepoServicePermissionLevel.Admin)),

+ PrepoPortIndex.Manager => AcceptImpl(server, new PrepoService(PrepoServicePermissionLevel.Manager)),

+ PrepoPortIndex.User => AcceptImpl(server, new PrepoService(PrepoServicePermissionLevel.User)),

+ PrepoPortIndex.System => AcceptImpl(server, new PrepoService(PrepoServicePermissionLevel.System)),

+ PrepoPortIndex.Debug => AcceptImpl(server, new PrepoService(PrepoServicePermissionLevel.Debug)),

+ _ => throw new ArgumentOutOfRangeException(nameof(portIndex)),

+ };

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.Horizon.Prepo.Types

+{

+ enum PrepoPortIndex

+ {

+ Admin,

+ Admin2,

+ Manager,

+ User,

+ System,

+ Debug

+ }

+} \ No newline at end of file

+namespace Ryujinx.Horizon.Prepo.Types

+ Manager = 6,

+ Debug = unchecked((int)0x80000006)

+ <ItemGroup>

+ <PackageReference Include="LibHac" />

+ </ItemGroup>

+

+using System;

+using System.IO;

+using System.Linq;

+using System.Runtime.InteropServices;

+

+namespace Ryujinx.Horizon.Sdk.Account

+{

+ [StructLayout(LayoutKind.Sequential)]

+ public readonly record struct Uid

+ {

+ public readonly long High;

+ public readonly long Low;

+

+ public bool IsNull => (Low | High) == 0;

+

+ public static Uid Null => new(0, 0);

+

+ public Uid(long low, long high)

+ {

+ Low = low;

+ High = high;

+ }

+

+ public Uid(byte[] bytes)

+ {

+ High = BitConverter.ToInt64(bytes, 0);

+ Low = BitConverter.ToInt64(bytes, 8);

+ }

+

+ public Uid(string hex)

+ {

+ if (hex == null || hex.Length != 32 || !hex.All("0123456789abcdefABCDEF".Contains))

+ {

+ throw new ArgumentException("Invalid Hex value!", nameof(hex));

+ }

+

+ Low = Convert.ToInt64(hex[16..], 16);

+ High = Convert.ToInt64(hex[..16], 16);

+ }

+

+ public void Write(BinaryWriter binaryWriter)

+ {

+ binaryWriter.Write(High);

+ binaryWriter.Write(Low);

+ }

+

+ public override string ToString()

+ {

+ return High.ToString("x16") + Low.ToString("x16");

+ }

+

+ public LibHac.Account.Uid ToLibHacUid()

+ {

+ return new LibHac.Account.Uid((ulong)High, (ulong)Low);

+ }

+

+ public UInt128 ToUInt128()

+ {

+ return new UInt128((ulong)High, (ulong)Low);

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.Sdk.Sf;

+using System;

+

+namespace Ryujinx.Horizon.Sdk.Lm

+{

+ interface ILmLogger : IServiceObject

+ {

+ Result Log(Span<byte> message);

+ Result SetDestination(LogDestination destination);

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.LogManager.Ipc;

+using Ryujinx.Horizon.Sdk.Sf;

+

+namespace Ryujinx.Horizon.Sdk.Lm

+{

+ interface ILogService : IServiceObject

+ {

+ Result OpenLogger(out LmLogger logger, ulong pid);

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.Sdk.Account;

+using Ryujinx.Horizon.Sdk.Sf;

+using System;

+

+namespace Ryujinx.Horizon.Sdk.Prepo

+{

+ interface IPrepoService : IServiceObject

+ {

+ Result SaveReport(ReadOnlySpan<byte> gameRoomBuffer, ReadOnlySpan<byte> reportBuffer, ulong pid);

+ Result SaveReportWithUser(Uid userId, ReadOnlySpan<byte> gameRoomBuffer, ReadOnlySpan<byte> reportBuffer, ulong pid);

+ Result RequestImmediateTransmission();

+ Result GetTransmissionStatus(out int status);

+ Result GetSystemSessionId(out ulong systemSessionId);

+ Result SaveSystemReport(ReadOnlySpan<byte> gameRoomBuffer, ReadOnlySpan<byte> reportBuffer, ulong pid);

+ Result SaveSystemReportWithUser(Uid userId, ReadOnlySpan<byte> gameRoomBuffer, ReadOnlySpan<byte> reportBuffer, ulong pid);

+ Result IsUserAgreementCheckEnabled(out bool enabled);

+ Result SetUserAgreementCheckEnabled(bool enabled);

+ }

+} \ No newline at end of file

+ int tlsSize = Api.TlsMessageBufferSize;

+ DataSize = data.Length,

+ SendPid = sendPid

+

+} \ No newline at end of file

+ public byte ObjectsCount;

+ public ushort DataSize;

+ public int ObjectId;

+ public uint Padding;

+ public uint Token;

+ Invalid = 0,

+ Close = 2

+ public const uint CmifInHeaderMagic = 0x49434653; // SFCI

+ totalSize = (totalSize + 1) & ~1;

+

+ int outPointerSizeTableSize = format.OutAutoBuffersCount + format.OutPointersCount;

+

+ int rawDataSizeInWords = (totalSize + sizeof(uint) - 1) / sizeof(uint);

+ CmifRequest request = new()

+ Hipc = HipcMessage.WriteMessage(output, new HipcMetadata()

+ {

+ Type = format.Context != 0 ? (int)CommandType.RequestWithContext : (int)CommandType.Request,

+ SendStaticsCount = format.InAutoBuffersCount + format.InPointersCount,

+ SendBuffersCount = format.InAutoBuffersCount + format.InBuffersCount,

+ ReceiveBuffersCount = format.OutAutoBuffersCount + format.OutBuffersCount,

+ ExchangeBuffersCount = format.InOutBuffersCount,

+ DataWordsCount = rawDataSizeInWords,

+ ReceiveStaticsCount = outPointerSizeTableSize + format.OutFixedPointersCount,

+ SendPid = format.SendPid,

+ CopyHandlesCount = format.HandlesCount,

+ MoveHandlesCount = 0

+ })

+ };

+ Type = CmifDomainRequestType.SendMessage,

+ DataSize = (ushort)payloadSize,

+ ObjectId = format.ObjectId,

+ Padding = 0,

+ Token = format.Context

+ data = data[(Unsafe.SizeOf<CmifDomainInHeader>() / sizeof(uint))..];

+ request.Objects = data[((payloadSize + sizeof(uint) - 1) / sizeof(uint))..];

+ Magic = CmifInHeaderMagic,

+ Version = format.Context != 0 ? 1u : 0u,

+ Token = format.ObjectId != 0 ? 0u : format.Context

+ request.Data = MemoryMarshal.Cast<uint, byte>(data)[Unsafe.SizeOf<CmifInHeader>()..];

+ Span<byte> outPointerTable = MemoryMarshal.Cast<uint, byte>(request.Hipc.DataWords)[(outPointerSizeTableOffset - paddingSizeBefore)..];

+

+ request.OutPointerSizes = MemoryMarshal.Cast<byte, ushort>(outPointerTable);

+ HipcMessage responseMessage = new(input);

+ Span<byte> data = MemoryMarshal.Cast<uint, byte>(responseMessage.Data.DataWords);

+ data = data[Unsafe.SizeOf<CmifDomainOutHeader>()..];

+ objects = MemoryMarshal.Cast<byte, uint>(data[(Unsafe.SizeOf<CmifOutHeader>() + size)..]);

+

+

+ Data = data[Unsafe.SizeOf<CmifOutHeader>()..],

+ Objects = objects,

+} \ No newline at end of file

+ public uint Magic;

+ public uint Version;

+ public uint Token;

+ public Span<byte> Data;

+ public Span<ushort> OutPointerSizes;

+ public Span<uint> Objects;

+ public int ServerPointerSize;

+ public int ObjectId;

+ public int DataSize;

+ public int ServerPointerSize;

+ public int InAutoBuffersCount;

+ public int OutAutoBuffersCount;

+ public int InBuffersCount;

+ public int OutBuffersCount;

+ public int InOutBuffersCount;

+ public int InPointersCount;

+ public int OutPointersCount;

+ public int OutFixedPointersCount;

+ public int ObjectsCount;

+ public int HandlesCount;

+ public ReadOnlySpan<int> CopyHandles;

+ public ReadOnlySpan<int> MoveHandles;

+ Invalid = 0,

+ LegacyRequest = 1,

+ Close = 2,

+ LegacyControl = 3,

+ Request = 4,

+ Control = 5,

+ ReadOnlySpan<byte> inDomainRawData = inRawData[Unsafe.SizeOf<CmifDomainInHeader>()..];

+ ReadOnlySpan<byte> inMessageRawData = inDomainRawData[..inHeader.DataSize];

+ Result result = _domain.ReserveIds(new Span<int>(_reservedObjectIds)[..OutObjectsCount]);

+ outRawData = outRawData[outHeaderSize..];

+ outRawData = outRawData[outHeaderSize..];

+ _domain.UnreserveIds(new Span<int>(_reservedObjectIds)[..OutObjectsCount]);

+ Span<int> outObjectIds = MemoryMarshal.Cast<byte, int>(MemoryMarshal.Cast<uint, byte>(response.DataWords)[_outObjectIdsOffset..]);

+ public static PointerAndSize Empty => new(0UL, 0UL);

+ Size = size;

+ public ushort InDataSize { get; }

+ public ushort OutDataSize { get; }

+ public byte InHeadersSize { get; }

+ public byte OutHeadersSize { get; }

+ public byte InObjectsCount { get; }

+ public byte OutObjectsCount { get; }

+

+ byte inHeadersSize,

+ byte outHeadersSize,

+ byte inObjectsCount,

+ byte outObjectsCount)

+ InDataSize = inDataSize;

+ OutDataSize = outDataSize;

+ InHeadersSize = inHeadersSize;

+ OutHeadersSize = outHeadersSize;

+ InObjectsCount = inObjectsCount;

+} \ No newline at end of file

+ public IServiceObject ServiceObject;

+ public ServerSessionManager Manager;

+ public ServerSession Session;

+ public HandlesToClose HandlesToClose;

+ public PointerAndSize PointerBuffer;

+ public ReadOnlySpan<byte> InMessageBuffer;

+ public Span<byte> OutMessageBuffer;

+ public HipcMessage Request;

+} \ No newline at end of file

+ _entries = entries;

+} \ No newline at end of file

+ PrepareForStubReply(ref context, out Span<byte> outRawData);

+ Logger.Warning?.Print(LogClass.Service, $"Missing service {objectName} (command ID: {commandId}) ignored");

+

+ else if (HorizonStatic.Options.ThrowOnInvalidCommandIds)

+ {

+ throw new NotImplementedException($"{objectName} command ID: {commandId} is not implemented");

+ }

+

+ private static void PrepareForStubReply(scoped ref ServiceDispatchContext context, out Span<byte> outRawData)

+} \ No newline at end of file

+ public CommandArgType Type { get; }

+ public HipcBufferFlags BufferFlags { get; }

+ public ushort BufferFixedSize { get; }

+ public int ArgSize { get; }

+ public int ArgAlignment { get; }

+ Type = type;

+ BufferFlags = default;

+ ArgSize = 0;

+ ArgAlignment = 0;

+ Type = type;

+ BufferFlags = default;

+ ArgSize = argSize;

+ ArgAlignment = argAlignment;

+ Type = CommandArgType.Buffer;

+ BufferFlags = flags;

+ ArgSize = 0;

+ ArgAlignment = 0;

+} \ No newline at end of file

+ public HipcBufferFlags Flags { get; }

+ public ushort FixedSize { get; }

+ Flags = flags | HipcBufferFlags.FixedSize;

+} \ No newline at end of file

+ ref ServiceDispatchContext context,

+ HipcCommandProcessor processor,

+ ReadOnlySpan<byte> inRawData,

+ ref Span<CmifOutHeader> outHeader);

+ private readonly MethodInvoke _invoke;

+ _invoke = invoke;

+ var runtimeMetadata = context.Processor.GetRuntimeMetadata();

+ Result result = context.Processor.PrepareForProcess(ref context, runtimeMetadata);

+ outHeader = MemoryMarshal.Cast<byte, CmifOutHeader>(outRawData)[..1];

+ outRawData = outRawData[Unsafe.SizeOf<CmifOutHeader>()..];

+} \ No newline at end of file

+

+} \ No newline at end of file

+ In = 1 << 0,

+ Out = 1 << 1,

+ MapAlias = 1 << 2,

+ Pointer = 1 << 3,

+ FixedSize = 1 << 4,

+ AutoSelect = 1 << 5,

+ Normal = 0,

+ Invalid = 2,

+ if (_session.ServiceObjectHolder.ServiceObject is not DomainServiceObject domain)

+} \ No newline at end of file

+ public HipcMetadata Meta;

+ public ulong Pid;

+ data = data[Unsafe.SizeOf<Header>()..];

+ int receiveStaticsCount = 0;

+ ulong pid = 0;

+ data = data[Unsafe.SizeOf<SpecialHeader>()..];

+ pid = MemoryMarshal.Cast<byte, ulong>(data)[0];

+ data = data[sizeof(ulong)..];

+ Type = (int)header.Type,

+ SendStaticsCount = header.SendStaticsCount,

+ SendBuffersCount = header.SendBuffersCount,

+ ReceiveBuffersCount = header.ReceiveBuffersCount,

+ DataWordsCount = header.DataWordsCount,

+ ReceiveStaticsCount = receiveStaticsCount,

+ SendPid = specialHeader.SendPid,

+ CopyHandlesCount = specialHeader.CopyHandlesCount,

+ MoveHandlesCount = specialHeader.MoveHandlesCount

+ Pid = pid;

+ int sendStaticCount,

+ int dataWordsCount,

+ int copyHandlesCount,

+ int moveHandlesCount)

+ DataWordsCount = dataWordsCount,

+ int initialLength = destination.Length;

+ Type = (CommandType)meta.Type,

+ SendStaticsCount = meta.SendStaticsCount,

+ SendBuffersCount = meta.SendBuffersCount,

+ ReceiveBuffersCount = meta.ReceiveBuffersCount,

+ DataWordsCount = meta.DataWordsCount,

+ ReceiveStaticMode = meta.ReceiveStaticsCount != 0 ? (meta.ReceiveStaticsCount != AutoReceiveStatic ? meta.ReceiveStaticsCount + 2 : 2) : 0,

+ HasSpecialHeader = hasSpecialHeader

+ destination = destination[Unsafe.SizeOf<Header>()..];

+ SendPid = meta.SendPid,

+ destination = destination[Unsafe.SizeOf<SpecialHeader>()..];

+ destination = destination[sizeof(ulong)..];

+ copyHandles = MemoryMarshal.Cast<byte, int>(data)[..meta.CopyHandlesCount];

+ data = data[(meta.CopyHandlesCount * sizeof(int))..];

+ moveHandles = MemoryMarshal.Cast<byte, int>(data)[..meta.MoveHandlesCount];

+ data = data[(meta.MoveHandlesCount * sizeof(int))..];

+ sendStatics = MemoryMarshal.Cast<byte, HipcStaticDescriptor>(data)[..meta.SendStaticsCount];

+ data = data[(meta.SendStaticsCount * Unsafe.SizeOf<HipcStaticDescriptor>())..];

+ sendBuffers = MemoryMarshal.Cast<byte, HipcBufferDescriptor>(data)[..meta.SendBuffersCount];

+ data = data[(meta.SendBuffersCount * Unsafe.SizeOf<HipcBufferDescriptor>())..];

+ receiveBuffers = MemoryMarshal.Cast<byte, HipcBufferDescriptor>(data)[..meta.ReceiveBuffersCount];

+ data = data[(meta.ReceiveBuffersCount * Unsafe.SizeOf<HipcBufferDescriptor>())..];

+ exchangeBuffers = MemoryMarshal.Cast<byte, HipcBufferDescriptor>(data)[..meta.ExchangeBuffersCount];

+ data = data[(meta.ExchangeBuffersCount * Unsafe.SizeOf<HipcBufferDescriptor>())..];

+ int dataOffset = initialLength - data.Length;

+ int padding = (dataOffsetAligned - dataOffset) / sizeof(uint);

+ dataWords = MemoryMarshal.Cast<byte, uint>(data)[padding..meta.DataWordsCount];

+ data = data[(meta.DataWordsCount * sizeof(uint))..];

+ receiveList = MemoryMarshal.Cast<byte, HipcReceiveListEntry>(data)[..receiveListSize];

+ SendStatics = sendStatics,

+ SendBuffers = sendBuffers,

+ ReceiveBuffers = receiveBuffers,

+ DataWords = dataWords,

+ ReceiveList = receiveList,

+ CopyHandles = copyHandles,

+ MoveHandles = moveHandles

+ public Span<uint> DataWords;

+ public Span<int> CopyHandles;

+ public Span<int> MoveHandles;

+} \ No newline at end of file

+ public int Type;

+ public int SendStaticsCount;

+ public int SendBuffersCount;

+ public int ReceiveBuffersCount;

+ public int ExchangeBuffersCount;

+ public int DataWordsCount;

+ public int ReceiveStaticsCount;

+ public int CopyHandlesCount;

+ public int MoveHandlesCount;

+ _word1 = (ushort)(address >> 32) | (uint)(size << 16);

+ public static Result OutOfSessionMemory => new(ModuleId, 102);

+ public static Result OutOfSessions => new(ModuleId, 131);

+ public static Result PointerBufferTooSmall => new(ModuleId, 141);

+ public static Result OutOfDomains => new(ModuleId, 200);

+ public static Result InvalidRequestSize => new(ModuleId, 402);

+ public static Result UnknownCommandType => new(ModuleId, 403);

+ public static Result InvalidCmifRequest => new(ModuleId, 420);

+ public static Result TargetNotDomain => new(ModuleId, 491);

+ public static Result DomainObjectNotFound => new(ModuleId, 492);

+ public ulong Address => ((((_data >> 2) & 0x70) | ((_data >> 12) & 0xf)) << 32) | (_data >> 32);

+ public ushort Size => (ushort)(_data >> 16);

+ public int ReceiveIndex => (int)(_data & 0xf);

+} \ No newline at end of file

+ public static ManagerOptions Default => new(0, 0, 0, false);

+ public int PointerBufferSize { get; }

+ public int MaxDomains { get; }

+ public int MaxDomainObjects { get; }

+ PointerBufferSize = pointerBufferSize;

+ MaxDomains = maxDomains;

+ MaxDomainObjects = maxDomainObjects;

+} \ No newline at end of file

+ public int PortIndex { get; }

+ public int PortHandle { get; }

+ public ServiceName Name { get; }

+ public bool Managed { get; }

+ int portIndex,

+ int portHandle,

+ ServiceName name,

+ bool managed,

+ Name = name;

+ Managed = managed;

+ HipcManager hipcManager = new(this, session);

+ ServerSession session = new(sessionIndex, sessionHandle, obj);

+ Server server = new(portIndex, portHandle, name, managed, staticHoder);

+ Server = 1,

+ _waitList = new MultiWait();

+ _waitListLock = new object();

+ _notifyEvent = new Event(EventClearMode.ManualClear);

+

+

+

+ protected Result AcceptImpl(Server server, IServiceObject obj)

+ {

+ return AcceptSession(server.PortHandle, new ServiceObjectHolder(obj));

+ }

+

+ session.UserData = UserDataTag.Session;

+

+ return (UserDataTag)holder.UserData switch

+ UserDataTag.Server => ProcessForServer(holder),

+ UserDataTag.Session => ProcessForSession(holder),

+ _ => throw new NotImplementedException(((UserDataTag)holder.UserData).ToString())

+ };

+

+ public PointerAndSize PointerBuffer { get; set; }

+ public PointerAndSize SavedMessage { get; set; }

+ public int SessionIndex { get; }

+ public int SessionHandle { get; }

+ public bool IsClosed { get; set; }

+ public bool HasReceived { get; set; }

+ SessionIndex = index;

+ SessionHandle = handle;

+ session.SavedMessage = GetSessionSavedMessageBuffer(session);

+

+ int portIndex,

+ int portHandle,

+ ServiceName name,

+ bool managed,

+

+

+

+

+ }

+ Type = (int)CommandType.Invalid,

+ ServerSession session,

+ Span<byte> inMessage,

+ Span<byte> outMessage)

+ ServiceObject = objectHolder.ServiceObject,

+ Manager = this,

+ Session = session,

+ HandlesToClose = new HandlesToClose(),

+ PointerBuffer = session.PointerBuffer,

+ InMessageBuffer = inMessage,

+ Request = request

+} \ No newline at end of file

+ int sendMapAliasIndex = 0;

+ int recvMapAliasIndex = 0;

+ int sendPointerIndex = 0;

+ ulong address = descriptor.Address;

+ ulong size = descriptor.Size;

+

+ var data = MemoryMarshal.Cast<uint, byte>(context.Request.Data.DataWords);

+ var recvPointerSizes = MemoryMarshal.Cast<byte, ushort>(data[runtimeMetadata.UnfixedOutPointerSizeOffset..]);

+

+ _bufferRanges[i] = new PointerAndSize(pointerBufferHead, size);

+ requestValid &= meta.SendPid == _hasInProcessIdHolder;

+ requestValid &= meta.SendStaticsCount == _inPointerBuffersCount;

+ requestValid &= meta.SendBuffersCount == _inMapAliasBuffersCount;

+ requestValid &= meta.ReceiveBuffersCount == _outMapAliasBuffersCount;

+ requestValid &= meta.CopyHandlesCount == _inCopyHandlesCount;

+ requestValid &= meta.MoveHandlesCount == _inMoveHandlesCount;

+

+ int index = inObjectIndex++;

+

+

+

+} \ No newline at end of file

+ int[] sizes = new int[argsCount];

+ int[] map = new int[argsCount];

+ sizes[i] = args[i].ArgSize;

+ map[i] = i;

+ (map[j], map[j - 1]) = (map[j - 1], map[j]);

+ offset = BitUtils.AlignUp(offset, aligns[i]);

+ offset += sizes[i];

+} \ No newline at end of file

+ public static Result NotSupported => new(ModuleId, 1);

+ public static Result InvalidHeaderSize => new(ModuleId, 202);

+ public static Result InvalidInHeader => new(ModuleId, 211);

+ public static Result InvalidOutHeader => new(ModuleId, 212);

+ public static Result UnknownCommandId => new(ModuleId, 221);

+ public static Result InvalidOutRawSize => new(ModuleId, 232);

+ public static Result InvalidInObjectsCount => new(ModuleId, 235);

+ public static Result InvalidOutObjectsCount => new(ModuleId, 236);

+ public static Result InvalidInObject => new(ModuleId, 239);

+ public static Result TargetNotFound => new(ModuleId, 261);

+ public static Result OutOfDomainEntries => new(ModuleId, 301);

+ public static Result InvalidatedByUser => new(ModuleId, 802);

+ public static Result RequestDeferredByUser => new(ModuleId, 812);

+ public static bool Invalidated(Result result) => result.InRange(801, 809);

+ public static bool RequestDeferred(Result result) => result.InRange(811, 819);

+} \ No newline at end of file

+using Ryujinx.Horizon.Sdk.Sf;

+

+namespace Ryujinx.Horizon.Sdk.Sm

+{

+ interface IManagerService : IServiceObject

+ {

+ }

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.Sdk.Sf;

+

+namespace Ryujinx.Horizon.Sdk.Sm

+{

+ interface IUserService : IServiceObject

+ {

+ Result Initialize(ulong clientProcessId);

+ Result GetService(out int handle, ServiceName name);

+ Result RegisterService(out int handle, ServiceName name, int maxSessions, bool isLight);

+ Result UnregisterService(ServiceName name);

+ }

+} \ No newline at end of file

+ private const string SmName = "sm:";

+

+ Result result = HorizonStatic.Syscall.ConnectToNamedPort(out int portHandle, SmName);

+ result = HorizonStatic.Syscall.ConnectToNamedPort(out portHandle, SmName);

+ SpanWriter writer = new(data);

+ SpanWriter writer = new(data);

+

+

+ SpanWriter writer = new(data);

+

+

+ SpanWriter writer = new(data);

+ SpanWriter writer = new(data);

+} \ No newline at end of file

+ private readonly Action<ServiceTable> _entrypoint;

+ private readonly ServiceTable _serviceTable;

+ private readonly HorizonOptions _options;

+ internal ServiceEntry(Action<ServiceTable> entrypoint, ServiceTable serviceTable, HorizonOptions options)

+ _entrypoint = entrypoint;

+ _serviceTable = serviceTable;

+ _options = options;

+ _entrypoint(_serviceTable);

+} \ No newline at end of file

+using Ryujinx.Horizon.Prepo;

+using System.Threading;

+ public class ServiceTable

+ private int _readyServices;

+ private int _totalServices;

+

+ private readonly ManualResetEvent _servicesReadyEvent = new(false);

+

+ public IEnumerable<ServiceEntry> GetServices(HorizonOptions options)

+ List<ServiceEntry> entries = new();

+ entries.Add(new ServiceEntry(T.Main, this, options));

+ RegisterService<PrepoMain>();

+

+ _totalServices = entries.Count;

+

+ internal void SignalServiceReady()

+ {

+ if (Interlocked.Increment(ref _readyServices) == _totalServices)

+ {

+ _servicesReadyEvent.Set();

+ }

+ }

+

+ public void WaitServicesReady()

+ {

+ _servicesReadyEvent.WaitOne();

+ }

+

+ protected virtual void Dispose(bool disposing)

+ {

+ if (disposing)

+ {

+ _servicesReadyEvent.Dispose();

+ }

+ }

+

+ public void Dispose()

+ {

+ Dispose(true);

+ }

+} \ No newline at end of file

+ public ulong OwnerProcessId;

+ public int PortHandle;

+ Name = ServiceName.Invalid;

+ PortHandle = 0;

+} \ No newline at end of file

+ freeService.PortHandle = clientPort;

+ freeService.Name = name;

+

+} \ No newline at end of file

+using Ryujinx.Horizon.Sdk.Sm;

+

+namespace Ryujinx.Horizon.Sm.Ipc

+{

+ partial class ManagerService : IManagerService

+ {

+ }

+}

+namespace Ryujinx.Horizon.Sm.Ipc

+ partial class UserService : IUserService

+ private bool _initialized;

+ _initialized = true;

+} \ No newline at end of file

+using Ryujinx.Horizon.Prepo.Types;

+using Ryujinx.Horizon.Prepo;

+using Ryujinx.Horizon.Sdk.Sf.Hipc;

+using Ryujinx.Horizon.Sm.Types;

+ private const int SmMaxSessionsCount = 64;

+ private const int SmmMaxSessionsCount = 1;

+ private const int SmTotalMaxSessionsCount = SmMaxSessionsCount + SmmMaxSessionsCount;

+ private SmServerManager _serverManager;

+

+ private readonly ServiceManager _serviceManager = new();

+ HorizonStatic.Syscall.ManageNamedPort(out int smHandle, "sm:", SmMaxSessionsCount).AbortOnFailure();

+

+ _serverManager = new SmServerManager(_serviceManager, null, null, MaxPortsCount, ManagerOptions.Default, SmTotalMaxSessionsCount);

+ _serverManager.RegisterServer((int)SmPortIndex.User, smHandle);

+ _serviceManager.RegisterServiceForSelf(out int smmHandle, ServiceName.Encode("sm:m"), SmmMaxSessionsCount).AbortOnFailure();

+ _serverManager.RegisterServer((int)SmPortIndex.Manager, smmHandle);

+} \ No newline at end of file

+ public static Result OutOfProcess => new(ModuleId, 1);

+ public static Result InvalidClient => new(ModuleId, 2);

+ public static Result OutOfSessions => new(ModuleId, 3);

+ public static Result AlreadyRegistered => new(ModuleId, 4);

+ public static Result OutOfServices => new(ModuleId, 5);

+ public static Result InvalidServiceName => new(ModuleId, 6);

+ public static Result NotRegistered => new(ModuleId, 7);

+ public static Result NotAllowed => new(ModuleId, 8);

+ public static Result TooLargeAccessControl => new(ModuleId, 9);

+} \ No newline at end of file

+using Ryujinx.Horizon.Common;

+using Ryujinx.Horizon.Sdk.Sf.Hipc;

+using Ryujinx.Horizon.Sdk.Sm;

+using Ryujinx.Horizon.Sm.Impl;

+using Ryujinx.Horizon.Sm.Ipc;

+using Ryujinx.Horizon.Sm.Types;

+using System;

+

+namespace Ryujinx.Horizon.Sm

+{

+ class SmServerManager : ServerManager

+ {

+ private readonly ServiceManager _serviceManager;

+

+ public SmServerManager(ServiceManager serviceManager, HeapAllocator allocator, SmApi sm, int maxPorts, ManagerOptions options, int maxSessions) : base(allocator, sm, maxPorts, options, maxSessions)

+ {

+ _serviceManager = serviceManager;

+ }

+

+ protected override Result OnNeedsToAccept(int portIndex, Server server)

+ {

+ return (SmPortIndex)portIndex switch

+ {

+ SmPortIndex.User => AcceptImpl(server, new UserService(_serviceManager)),

+ SmPortIndex.Manager => AcceptImpl(server, new ManagerService()),

+ _ => throw new ArgumentOutOfRangeException(nameof(portIndex)),

+ };

+ }

+ }

+} \ No newline at end of file

+namespace Ryujinx.Horizon.Sm.Types

+{

+ enum SmPortIndex

+ {

+ User,

+ Manager

+ }

+} \ No newline at end of file