diff --git a/Ryujinx.Common/BitUtils.cs b/Ryujinx.Common/BitUtils.cs index fa49082bb8..5c858029bd 100644 --- a/Ryujinx.Common/BitUtils.cs +++ b/Ryujinx.Common/BitUtils.cs @@ -7,6 +7,11 @@ namespace Ryujinx.Common return (Value + (Size - 1)) & -Size; } + public static ulong AlignUp(ulong Value, int Size) + { + return (ulong)AlignUp((long)Value, Size); + } + public static long AlignUp(long Value, int Size) { return (Value + (Size - 1)) & -(long)Size; @@ -17,11 +22,21 @@ namespace Ryujinx.Common return Value & -Size; } + public static ulong AlignDown(ulong Value, int Size) + { + return (ulong)AlignDown((long)Value, Size); + } + public static long AlignDown(long Value, int Size) { return Value & -(long)Size; } + public static ulong DivRoundUp(ulong Value, uint Dividend) + { + return (Value + Dividend - 1) / Dividend; + } + public static long DivRoundUp(long Value, int Dividend) { return (Value + Dividend - 1) / Dividend; diff --git a/Ryujinx.HLE/HOS/Horizon.cs b/Ryujinx.HLE/HOS/Horizon.cs index 800ac2e823..ea0850cce8 100644 --- a/Ryujinx.HLE/HOS/Horizon.cs +++ b/Ryujinx.HLE/HOS/Horizon.cs @@ -25,9 +25,9 @@ namespace Ryujinx.HLE.HOS internal const int HidSize = 0x40000; internal const int FontSize = 0x1100000; - private const long UserSlabHeapBase = DramMemoryMap.SlabHeapBase; - private const long UserSlabHeapItemSize = KMemoryManager.PageSize; - private const long UserSlabHeapSize = 0x3de000; + private const ulong UserSlabHeapBase = DramMemoryMap.SlabHeapBase; + private const ulong UserSlabHeapItemSize = KMemoryManager.PageSize; + private const ulong UserSlabHeapSize = 0x3de000; internal Switch Device { get; private set; } @@ -114,10 +114,10 @@ namespace Ryujinx.HLE.HOS KMemoryRegionManager Region = MemoryRegions[(int)MemoryRegion.Service]; - long HidPa = Region.Address; - long FontPa = Region.Address + HidSize; + ulong HidPa = Region.Address; + ulong FontPa = Region.Address + HidSize; - HidBaseAddress = HidPa - DramMemoryMap.DramBase; + HidBaseAddress = (long)(HidPa - DramMemoryMap.DramBase); KPageList HidPageList = new KPageList(); KPageList FontPageList = new KPageList(); @@ -132,7 +132,7 @@ namespace Ryujinx.HLE.HOS AppletState.SetFocus(true); - Font = new SharedFontManager(Device, FontPa - DramMemoryMap.DramBase); + Font = new SharedFontManager(Device, (long)(FontPa - DramMemoryMap.DramBase)); VsyncEvent = new KEvent(this); diff --git a/Ryujinx.HLE/HOS/Kernel/DramMemoryMap.cs b/Ryujinx.HLE/HOS/Kernel/DramMemoryMap.cs index 50b33be2df..b20a83e2a9 100644 --- a/Ryujinx.HLE/HOS/Kernel/DramMemoryMap.cs +++ b/Ryujinx.HLE/HOS/Kernel/DramMemoryMap.cs @@ -2,14 +2,14 @@ namespace Ryujinx.HLE.HOS.Kernel { static class DramMemoryMap { - public const long DramBase = 0x80000000; - public const long DramSize = 0x100000000; - public const long DramEnd = DramBase + DramSize; + public const ulong DramBase = 0x80000000; + public const ulong DramSize = 0x100000000; + public const ulong DramEnd = DramBase + DramSize; - public const long KernelReserveBase = DramBase + 0x60000; + public const ulong KernelReserveBase = DramBase + 0x60000; - public const long SlabHeapBase = KernelReserveBase + 0x85000; - public const long SlapHeapSize = 0xa21000; - public const long SlabHeapEnd = SlabHeapBase + SlapHeapSize; + public const ulong SlabHeapBase = KernelReserveBase + 0x85000; + public const ulong SlapHeapSize = 0xa21000; + public const ulong SlabHeapEnd = SlabHeapBase + SlapHeapSize; } } \ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs b/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs index 11360b617f..89339fc316 100644 --- a/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs +++ b/Ryujinx.HLE/HOS/Kernel/HleProcessDebugger.cs @@ -196,10 +196,10 @@ namespace Ryujinx.HLE.HOS.Kernel private void ScanMemoryForTextSegments() { - long OldAddress = 0; - long Address = 0; + ulong OldAddress = 0; + ulong Address = 0; - while ((ulong)Address >= (ulong)OldAddress) + while (Address >= OldAddress) { KMemoryInfo Info = Owner.MemoryManager.QueryMemory(Address); @@ -210,7 +210,7 @@ namespace Ryujinx.HLE.HOS.Kernel if (Info.State == MemoryState.CodeStatic && Info.Permission == MemoryPermission.ReadAndExecute) { - LoadMod0Symbols(Owner.CpuMemory, Info.Address); + LoadMod0Symbols(Owner.CpuMemory, (long)Info.Address); } OldAddress = Address; diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs index 4e8853ce76..7d66e2913b 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryArrangeRegion.cs @@ -2,12 +2,12 @@ namespace Ryujinx.HLE.HOS.Kernel { struct KMemoryArrangeRegion { - public long Address { get; private set; } - public long Size { get; private set; } + public ulong Address { get; private set; } + public ulong Size { get; private set; } - public long EndAddr => Address + Size; + public ulong EndAddr => Address + Size; - public KMemoryArrangeRegion(long Address, long Size) + public KMemoryArrangeRegion(ulong Address, ulong Size) { this.Address = Address; this.Size = Size; diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs index 48fb7a723d..08190236e3 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryBlock.cs @@ -2,8 +2,8 @@ namespace Ryujinx.HLE.HOS.Kernel { class KMemoryBlock { - public long BaseAddress { get; set; } - public long PagesCount { get; set; } + public ulong BaseAddress { get; set; } + public ulong PagesCount { get; set; } public MemoryState State { get; set; } public MemoryPermission Permission { get; set; } @@ -13,8 +13,8 @@ namespace Ryujinx.HLE.HOS.Kernel public int DeviceRefCount { get; set; } public KMemoryBlock( - long BaseAddress, - long PagesCount, + ulong BaseAddress, + ulong PagesCount, MemoryState State, MemoryPermission Permission, MemoryAttribute Attribute) @@ -28,7 +28,7 @@ namespace Ryujinx.HLE.HOS.Kernel public KMemoryInfo GetInfo() { - long Size = PagesCount * KMemoryManager.PageSize; + ulong Size = PagesCount * KMemoryManager.PageSize; return new KMemoryInfo( BaseAddress, diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs index 7a557bb866..09ba88f2c1 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryInfo.cs @@ -2,8 +2,8 @@ namespace Ryujinx.HLE.HOS.Kernel { class KMemoryInfo { - public long Address { get; private set; } - public long Size { get; private set; } + public ulong Address { get; private set; } + public ulong Size { get; private set; } public MemoryState State { get; private set; } public MemoryPermission Permission { get; private set; } @@ -13,8 +13,8 @@ namespace Ryujinx.HLE.HOS.Kernel public int DeviceRefCount { get; private set; } public KMemoryInfo( - long Address, - long Size, + ulong Address, + ulong Size, MemoryState State, MemoryPermission Permission, MemoryAttribute Attribute, diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs index 9cb03eefea..b11c3679fb 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryManager.cs @@ -19,29 +19,29 @@ namespace Ryujinx.HLE.HOS.Kernel private Horizon System; - public long AddrSpaceStart { get; private set; } - public long AddrSpaceEnd { get; private set; } + public ulong AddrSpaceStart { get; private set; } + public ulong AddrSpaceEnd { get; private set; } - public long CodeRegionStart { get; private set; } - public long CodeRegionEnd { get; private set; } + public ulong CodeRegionStart { get; private set; } + public ulong CodeRegionEnd { get; private set; } - public long HeapRegionStart { get; private set; } - public long HeapRegionEnd { get; private set; } + public ulong HeapRegionStart { get; private set; } + public ulong HeapRegionEnd { get; private set; } - private long CurrentHeapAddr; + private ulong CurrentHeapAddr; - public long AliasRegionStart { get; private set; } - public long AliasRegionEnd { get; private set; } + public ulong AliasRegionStart { get; private set; } + public ulong AliasRegionEnd { get; private set; } - public long StackRegionStart { get; private set; } - public long StackRegionEnd { get; private set; } + public ulong StackRegionStart { get; private set; } + public ulong StackRegionEnd { get; private set; } - public long TlsIoRegionStart { get; private set; } - public long TlsIoRegionEnd { get; private set; } + public ulong TlsIoRegionStart { get; private set; } + public ulong TlsIoRegionEnd { get; private set; } - private long HeapCapacity; + private ulong HeapCapacity; - public long PersonalMmHeapUsage { get; private set; } + public ulong PersonalMmHeapUsage { get; private set; } private MemoryRegion MemRegion; @@ -71,8 +71,8 @@ namespace Ryujinx.HLE.HOS.Kernel bool AslrEnabled, bool AslrDisabled, MemoryRegion MemRegion, - long Address, - long Size) + ulong Address, + ulong Size) { if ((uint)AddrSpaceType > (uint)AddressSpaceType.Addr39Bits) { @@ -81,8 +81,8 @@ namespace Ryujinx.HLE.HOS.Kernel ContextId = System.ContextIdManager.GetId(); - long AddrSpaceBase = 0; - long AddrSpaceSize = 1L << AddrSpaceSizes[(int)AddrSpaceType]; + ulong AddrSpaceBase = 0; + ulong AddrSpaceSize = 1UL << AddrSpaceSizes[(int)AddrSpaceType]; KernelResult Result = CreateUserAddressSpace( AddrSpaceType, @@ -104,33 +104,33 @@ namespace Ryujinx.HLE.HOS.Kernel private class Region { - public long Start; - public long End; - public long Size; - public long AslrOffset; + public ulong Start; + public ulong End; + public ulong Size; + public ulong AslrOffset; } private KernelResult CreateUserAddressSpace( AddressSpaceType AddrSpaceType, bool AslrEnabled, bool AslrDisabled, - long AddrSpaceStart, - long AddrSpaceEnd, + ulong AddrSpaceStart, + ulong AddrSpaceEnd, MemoryRegion MemRegion, - long Address, - long Size) + ulong Address, + ulong Size) { - long EndAddr = Address + Size; + ulong EndAddr = Address + Size; Region AliasRegion = new Region(); Region HeapRegion = new Region(); Region StackRegion = new Region(); Region TlsIoRegion = new Region(); - long CodeRegionSize; - long StackAndTlsIoStart; - long StackAndTlsIoEnd; - long BaseAddress; + ulong CodeRegionSize; + ulong StackAndTlsIoStart; + ulong StackAndTlsIoEnd; + ulong BaseAddress; switch (AddrSpaceType) { @@ -191,8 +191,8 @@ namespace Ryujinx.HLE.HOS.Kernel CodeRegionEnd = CodeRegionStart + CodeRegionSize; - long MapBaseAddress; - long MapAvailableSize; + ulong MapBaseAddress; + ulong MapAvailableSize; if (CodeRegionStart - BaseAddress >= AddrSpaceEnd - CodeRegionEnd) { @@ -207,9 +207,9 @@ namespace Ryujinx.HLE.HOS.Kernel MapAvailableSize = AddrSpaceEnd - CodeRegionEnd; } - long MapTotalSize = AliasRegion.Size + HeapRegion.Size + StackRegion.Size + TlsIoRegion.Size; + ulong MapTotalSize = AliasRegion.Size + HeapRegion.Size + StackRegion.Size + TlsIoRegion.Size; - long AslrMaxOffset = MapAvailableSize - MapTotalSize; + ulong AslrMaxOffset = MapAvailableSize - MapTotalSize; this.AddrSpaceStart = AddrSpaceStart; this.AddrSpaceEnd = AddrSpaceEnd; @@ -284,6 +284,11 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } + private ulong GetRandomValue(ulong Min, ulong Max) + { + return (ulong)GetRandomValue((long)Min, (long)Max); + } + private long GetRandomValue(long Min, long Max) { if (RandomNumberGenerator == null) @@ -308,22 +313,22 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private void InitializeBlocks(long AddrSpaceStart, long AddrSpaceEnd) + private void InitializeBlocks(ulong AddrSpaceStart, ulong AddrSpaceEnd) { - long AddrSpacePagesCount = (long)((ulong)(AddrSpaceEnd - AddrSpaceStart) / PageSize); + ulong AddrSpacePagesCount = (AddrSpaceEnd - AddrSpaceStart) / PageSize; InsertBlock(AddrSpaceStart, AddrSpacePagesCount, MemoryState.Unmapped); } public KernelResult MapPages( - long Address, + ulong Address, KPageList PageList, MemoryState State, MemoryPermission Permission) { - long PagesCount = PageList.GetPagesCount(); + ulong PagesCount = PageList.GetPagesCount(); - long Size = PagesCount * PageSize; + ulong Size = PagesCount * PageSize; if (!ValidateRegionForState(Address, Size, State)) { @@ -348,27 +353,27 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult UnmapPages(long Address, KPageList PageList, MemoryState StateExpected) + public KernelResult UnmapPages(ulong Address, KPageList PageList, MemoryState StateExpected) { - long PagesCount = PageList.GetPagesCount(); + ulong PagesCount = PageList.GetPagesCount(); - long Size = PagesCount * PageSize; + ulong Size = PagesCount * PageSize; - long EndAddr = Address + Size; + ulong EndAddr = Address + Size; - long AddrSpacePagesCount = (long)((ulong)(AddrSpaceEnd - AddrSpaceStart) / PageSize); + ulong AddrSpacePagesCount = (AddrSpaceEnd - AddrSpaceStart) / PageSize; - if ((ulong)AddrSpaceStart > (ulong)Address) + if (AddrSpaceStart > Address) { return KernelResult.InvalidMemState; } - if ((ulong)AddrSpacePagesCount < (ulong)PagesCount) + if (AddrSpacePagesCount < PagesCount) { return KernelResult.InvalidMemState; } - if ((ulong)(EndAddr - 1) > (ulong)(AddrSpaceEnd - 1)) + if (EndAddr - 1 > AddrSpaceEnd - 1) { return KernelResult.InvalidMemState; } @@ -427,49 +432,49 @@ namespace Ryujinx.HLE.HOS.Kernel } public KernelResult AllocateOrMapPa( - long NeededPagesCount, + ulong NeededPagesCount, int Alignment, - long SrcPa, + ulong SrcPa, bool Map, - long RegionStart, - long RegionPagesCount, + ulong RegionStart, + ulong RegionPagesCount, MemoryState State, MemoryPermission Permission, - out long Address) + out ulong Address) { Address = 0; - long RegionSize = RegionPagesCount * PageSize; + ulong RegionSize = RegionPagesCount * PageSize; - long RegionEndAddr = RegionStart + RegionSize; + ulong RegionEndAddr = RegionStart + RegionSize; if (!ValidateRegionForState(RegionStart, RegionSize, State)) { return KernelResult.InvalidMemState; } - if ((ulong)RegionPagesCount <= (ulong)NeededPagesCount) + if (RegionPagesCount <= NeededPagesCount) { return KernelResult.OutOfMemory; } - long ReservedPagesCount = IsKernel ? 1 : 4; + ulong ReservedPagesCount = IsKernel ? 1UL : 4UL; lock (Blocks) { if (AslrEnabled) { - long TotalNeededSize = (ReservedPagesCount + NeededPagesCount) * PageSize; + ulong TotalNeededSize = (ReservedPagesCount + NeededPagesCount) * PageSize; - long RemainingPages = RegionPagesCount - NeededPagesCount; + ulong RemainingPages = RegionPagesCount - NeededPagesCount; - long AslrMaxOffset = (long)((ulong)((RemainingPages + ReservedPagesCount) * PageSize) / (ulong)Alignment); + ulong AslrMaxOffset = ((RemainingPages + ReservedPagesCount) * PageSize) / (ulong)Alignment; for (int Attempt = 0; Attempt < 8; Attempt++) { - Address = BitUtils.AlignDown(RegionStart + GetRandomValue(0, AslrMaxOffset) * Alignment, Alignment); + Address = BitUtils.AlignDown(RegionStart + GetRandomValue(0, AslrMaxOffset) * (ulong)Alignment, Alignment); - long EndAddr = Address + TotalNeededSize; + ulong EndAddr = Address + TotalNeededSize; KMemoryInfo Info = FindBlock(Address).GetInfo(); @@ -478,13 +483,13 @@ namespace Ryujinx.HLE.HOS.Kernel continue; } - long CurrBaseAddr = Info.Address + ReservedPagesCount * PageSize; - long CurrEndAddr = Info.Address + Info.Size; + ulong CurrBaseAddr = Info.Address + ReservedPagesCount * PageSize; + ulong CurrEndAddr = Info.Address + Info.Size; - if ((ulong)Address >= (ulong)RegionStart && - (ulong)Address >= (ulong)CurrBaseAddr && - (ulong)EndAddr - 1 <= (ulong)RegionEndAddr - 1 && - (ulong)EndAddr - 1 <= (ulong)CurrEndAddr - 1) + if (Address >= RegionStart && + Address >= CurrBaseAddr && + EndAddr - 1 <= RegionEndAddr - 1 && + EndAddr - 1 <= CurrEndAddr - 1) { break; } @@ -492,7 +497,7 @@ namespace Ryujinx.HLE.HOS.Kernel if (Address == 0) { - long AslrPage = GetRandomValue(0, AslrMaxOffset); + ulong AslrPage = GetRandomValue(0, AslrMaxOffset); Address = FindFirstFit( RegionStart + AslrPage * PageSize, @@ -544,12 +549,12 @@ namespace Ryujinx.HLE.HOS.Kernel } public KernelResult MapNewProcessCode( - long Address, - long PagesCount, + ulong Address, + ulong PagesCount, MemoryState State, MemoryPermission Permission) { - long Size = PagesCount * PageSize; + ulong Size = PagesCount * PageSize; if (!ValidateRegionForState(Address, Size, State)) { @@ -580,9 +585,9 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult UnmapProcessCodeMemory(long Dst, long Src, long Size) + public KernelResult UnmapProcessCodeMemory(ulong Dst, ulong Src, ulong Size) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; lock (Blocks) { @@ -635,25 +640,25 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult SetHeapSize(long Size, out long Address) + public KernelResult SetHeapSize(ulong Size, out ulong Address) { Address = 0; - if ((ulong)Size > (ulong)(HeapRegionEnd - HeapRegionStart)) + if (Size > HeapRegionEnd - HeapRegionStart) { return KernelResult.OutOfMemory; } - long CurrentHeapSize = GetHeapSize(); + ulong CurrentHeapSize = GetHeapSize(); - if ((ulong)CurrentHeapSize <= (ulong)Size) + if (CurrentHeapSize <= Size) { //Expand. - long DiffSize = Size - CurrentHeapSize; + ulong DiffSize = Size - CurrentHeapSize; lock (Blocks) { - long PagesCount = (long)((ulong)DiffSize / PageSize); + ulong PagesCount = DiffSize / PageSize; KMemoryRegionManager Region = GetMemoryRegionManager(); @@ -687,8 +692,8 @@ namespace Ryujinx.HLE.HOS.Kernel else { //Shrink. - long FreeAddr = HeapRegionStart + Size; - long DiffSize = CurrentHeapSize - Size; + ulong FreeAddr = HeapRegionStart + Size; + ulong DiffSize = CurrentHeapSize - Size; lock (Blocks) { @@ -709,7 +714,7 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.InvalidMemState; } - long PagesCount = (long)((ulong)DiffSize / PageSize); + ulong PagesCount = DiffSize / PageSize; KernelResult Result = MmuUnmap(FreeAddr, PagesCount); @@ -729,7 +734,7 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public long GetTotalHeapSize() + public ulong GetTotalHeapSize() { lock (Blocks) { @@ -737,12 +742,12 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private long GetHeapSize() + private ulong GetHeapSize() { return CurrentHeapAddr - HeapRegionStart; } - public KernelResult SetHeapCapacity(long Capacity) + public KernelResult SetHeapCapacity(ulong Capacity) { lock (Blocks) { @@ -753,8 +758,8 @@ namespace Ryujinx.HLE.HOS.Kernel } public long SetMemoryAttribute( - long Address, - long Size, + ulong Address, + ulong Size, MemoryAttribute AttributeMask, MemoryAttribute AttributeValue) { @@ -774,7 +779,7 @@ namespace Ryujinx.HLE.HOS.Kernel out MemoryPermission Permission, out MemoryAttribute Attribute)) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; Attribute &= ~AttributeMask; Attribute |= AttributeMask & AttributeValue; @@ -788,10 +793,10 @@ namespace Ryujinx.HLE.HOS.Kernel return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - public KMemoryInfo QueryMemory(long Address) + public KMemoryInfo QueryMemory(ulong Address) { - if ((ulong)Address >= (ulong)AddrSpaceStart && - (ulong)Address < (ulong)AddrSpaceEnd) + if (Address >= AddrSpaceStart && + Address < AddrSpaceEnd) { lock (Blocks) { @@ -802,7 +807,7 @@ namespace Ryujinx.HLE.HOS.Kernel { return new KMemoryInfo( AddrSpaceEnd, - -AddrSpaceEnd, + ~AddrSpaceEnd + 1, MemoryState.Reserved, MemoryPermission.None, MemoryAttribute.None, @@ -811,7 +816,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult Map(long Dst, long Src, long Size) + public KernelResult Map(ulong Dst, ulong Src, ulong Size) { bool Success; @@ -835,7 +840,7 @@ namespace Ryujinx.HLE.HOS.Kernel if (Success) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; KPageList PageList = new KPageList(); @@ -872,9 +877,9 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult UnmapForKernel(long Address, long PagesCount, MemoryState StateExpected) + public KernelResult UnmapForKernel(ulong Address, ulong PagesCount, MemoryState StateExpected) { - long Size = PagesCount * PageSize; + ulong Size = PagesCount * PageSize; lock (Blocks) { @@ -908,7 +913,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult Unmap(long Dst, long Src, long Size) + public KernelResult Unmap(ulong Dst, ulong Src, ulong Size) { bool Success; @@ -944,7 +949,7 @@ namespace Ryujinx.HLE.HOS.Kernel if (Success) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; KPageList SrcPageList = new KPageList(); KPageList DstPageList = new KPageList(); @@ -985,7 +990,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public long ReserveTransferMemory(long Address, long Size, MemoryPermission Permission) + public long ReserveTransferMemory(ulong Address, ulong Size, MemoryPermission Permission) { lock (Blocks) { @@ -1003,7 +1008,7 @@ namespace Ryujinx.HLE.HOS.Kernel out _, out MemoryAttribute Attribute)) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; Attribute |= MemoryAttribute.Borrowed; @@ -1016,7 +1021,7 @@ namespace Ryujinx.HLE.HOS.Kernel return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - public long ResetTransferMemory(long Address, long Size) + public long ResetTransferMemory(ulong Address, ulong Size) { lock (Blocks) { @@ -1034,7 +1039,7 @@ namespace Ryujinx.HLE.HOS.Kernel out _, out _)) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; InsertBlock(Address, PagesCount, State, MemoryPermission.ReadAndWrite); @@ -1045,7 +1050,7 @@ namespace Ryujinx.HLE.HOS.Kernel return MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); } - public KernelResult SetProcessMemoryPermission(long Address, long Size, MemoryPermission Permission) + public KernelResult SetProcessMemoryPermission(ulong Address, ulong Size, MemoryPermission Permission) { lock (Blocks) { @@ -1085,7 +1090,7 @@ namespace Ryujinx.HLE.HOS.Kernel if (NewState != OldState || Permission != OldPermission) { - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; MemoryOperation Operation = (Permission & MemoryPermission.Execute) != 0 ? MemoryOperation.ChangePermsAndAttributes @@ -1110,13 +1115,13 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult MapPhysicalMemory(long Address, long Size) + public KernelResult MapPhysicalMemory(ulong Address, ulong Size) { - long EndAddr = Address + Size; + ulong EndAddr = Address + Size; lock (Blocks) { - long MappedSize = 0; + ulong MappedSize = 0; KMemoryInfo Info; @@ -1133,16 +1138,16 @@ namespace Ryujinx.HLE.HOS.Kernel Node = Node.Next; } - while ((ulong)(Info.Address + Info.Size) < (ulong)EndAddr && Node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); if (MappedSize == Size) { return KernelResult.Success; } - long RemainingSize = Size - MappedSize; + ulong RemainingSize = Size - MappedSize; - long RemainingPages = (long)((ulong)RemainingSize / PageSize); + ulong RemainingPages = RemainingSize / PageSize; KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); @@ -1167,7 +1172,7 @@ namespace Ryujinx.HLE.HOS.Kernel PersonalMmHeapUsage += RemainingSize; - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; InsertBlock( Address, @@ -1183,15 +1188,15 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public KernelResult UnmapPhysicalMemory(long Address, long Size) + public KernelResult UnmapPhysicalMemory(ulong Address, ulong Size) { - long EndAddr = Address + Size; + ulong EndAddr = Address + Size; lock (Blocks) { //Scan, ensure that the region can be unmapped (all blocks are heap or //already unmapped), fill pages list for freeing memory. - long HeapMappedSize = 0; + ulong HeapMappedSize = 0; KPageList PageList = new KPageList(); @@ -1212,8 +1217,8 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.InvalidMemState; } - long BlockSize = GetSizeInRange(Info, Address, EndAddr); - long BlockAddress = GetAddrInRange(Info, Address); + ulong BlockSize = GetSizeInRange(Info, Address, EndAddr); + ulong BlockAddress = GetAddrInRange(Info, Address); AddVaRangeToPageList(PageList, BlockAddress, BlockAddress + BlockSize); @@ -1226,7 +1231,7 @@ namespace Ryujinx.HLE.HOS.Kernel Node = Node.Next; } - while ((ulong)(Info.Address + Info.Size) < (ulong)EndAddr && Node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); if (HeapMappedSize == 0) { @@ -1244,10 +1249,10 @@ namespace Ryujinx.HLE.HOS.Kernel if (Info.State == MemoryState.Heap) { - long BlockSize = GetSizeInRange(Info, Address, EndAddr); - long BlockAddress = GetAddrInRange(Info, Address); + ulong BlockSize = GetSizeInRange(Info, Address, EndAddr); + ulong BlockAddress = GetAddrInRange(Info, Address); - long BlockPagesCount = (long)((ulong)BlockSize / PageSize); + ulong BlockPagesCount = BlockSize / PageSize; Result = MmuUnmap(BlockAddress, BlockPagesCount); @@ -1262,7 +1267,7 @@ namespace Ryujinx.HLE.HOS.Kernel Node = Node.Next; } - while ((ulong)(Info.Address + Info.Size) < (ulong)EndAddr && Node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); if (Result == KernelResult.Success) { @@ -1274,7 +1279,7 @@ namespace Ryujinx.HLE.HOS.Kernel CurrentProcess.ResourceLimit?.Release(LimitableResource.Memory, HeapMappedSize); - long PagesCount = (long)((ulong)Size / PageSize); + ulong PagesCount = Size / PageSize; InsertBlock(Address, PagesCount, MemoryState.Unmapped); } @@ -1283,7 +1288,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private void MapPhysicalMemory(KPageList PageList, long Address, long EndAddr) + private void MapPhysicalMemory(KPageList PageList, ulong Address, ulong EndAddr) { KMemoryInfo Info; @@ -1293,8 +1298,8 @@ namespace Ryujinx.HLE.HOS.Kernel KPageNode PageNode = PageListNode.Value; - long SrcPa = PageNode.Address; - long SrcPaPages = PageNode.PagesCount; + ulong SrcPa = PageNode.Address; + ulong SrcPaPages = PageNode.PagesCount; do { @@ -1302,11 +1307,11 @@ namespace Ryujinx.HLE.HOS.Kernel if (Info.State == MemoryState.Unmapped) { - long BlockSize = GetSizeInRange(Info, Address, EndAddr); + ulong BlockSize = GetSizeInRange(Info, Address, EndAddr); - long DstVaPages = (long)((ulong)BlockSize / PageSize); + ulong DstVaPages = BlockSize / PageSize; - long DstVa = GetAddrInRange(Info, Address); + ulong DstVa = GetAddrInRange(Info, Address); while (DstVaPages > 0) { @@ -1320,7 +1325,7 @@ namespace Ryujinx.HLE.HOS.Kernel SrcPaPages = PageNode.PagesCount; } - long PagesCount = PageNode.PagesCount; + ulong PagesCount = PageNode.PagesCount; if (PagesCount > DstVaPages) { @@ -1344,20 +1349,20 @@ namespace Ryujinx.HLE.HOS.Kernel Node = Node.Next; } - while ((ulong)(Info.Address + Info.Size) < (ulong)EndAddr && Node != null); + while (Info.Address + Info.Size < EndAddr && Node != null); } - private static long GetSizeInRange(KMemoryInfo Info, long Start, long End) + private static ulong GetSizeInRange(KMemoryInfo Info, ulong Start, ulong End) { - long EndAddr = Info.Size + Info.Address; - long Size = Info.Size; + ulong EndAddr = Info.Size + Info.Address; + ulong Size = Info.Size; - if ((ulong)Info.Address < (ulong)Start) + if (Info.Address < Start) { Size -= Start - Info.Address; } - if ((ulong)EndAddr > (ulong)End) + if (EndAddr > End) { Size -= EndAddr - End; } @@ -1365,9 +1370,9 @@ namespace Ryujinx.HLE.HOS.Kernel return Size; } - private static long GetAddrInRange(KMemoryInfo Info, long Start) + private static ulong GetAddrInRange(KMemoryInfo Info, ulong Start) { - if ((ulong)Info.Address < (ulong)Start) + if (Info.Address < Start) { return Start; } @@ -1375,13 +1380,11 @@ namespace Ryujinx.HLE.HOS.Kernel return Info.Address; } - private void AddVaRangeToPageList(KPageList PageList, long Start, long End) + private void AddVaRangeToPageList(KPageList PageList, ulong Start, ulong End) { - long Address = Start; - - while ((ulong)Address < (ulong)End) + while (Start < End) { - KernelResult Result = ConvertVaToPa(Address, out long Pa); + KernelResult Result = ConvertVaToPa(Start, out ulong Pa); if (Result != KernelResult.Success) { @@ -1390,11 +1393,11 @@ namespace Ryujinx.HLE.HOS.Kernel PageList.AddRange(Pa, 1); - Address += PageSize; + Start += PageSize; } } - public bool HleIsUnmapped(long Address, long Size) + public bool HleIsUnmapped(ulong Address, ulong Size) { bool Result = false; @@ -1406,7 +1409,7 @@ namespace Ryujinx.HLE.HOS.Kernel return Result; } - private bool IsUnmapped(long Address, long Size) + private bool IsUnmapped(ulong Address, ulong Size) { return CheckRange( Address, @@ -1424,8 +1427,8 @@ namespace Ryujinx.HLE.HOS.Kernel } private bool CheckRange( - long Address, - long Size, + ulong Address, + ulong Size, MemoryState StateMask, MemoryState StateExpected, MemoryPermission PermissionMask, @@ -1437,7 +1440,7 @@ namespace Ryujinx.HLE.HOS.Kernel out MemoryPermission OutPermission, out MemoryAttribute OutAttribute) { - long EndAddr = Address + Size - 1; + ulong EndAddr = Address + Size - 1; LinkedListNode Node = FindBlockNode(Address); @@ -1463,7 +1466,7 @@ namespace Ryujinx.HLE.HOS.Kernel } //Check if this is the last block on the range, if so return success. - if ((ulong)EndAddr <= (ulong)(Info.Address + Info.Size - 1)) + if (EndAddr <= Info.Address + Info.Size - 1) { OutState = FirstState; OutPermission = FirstPermission; @@ -1484,8 +1487,8 @@ namespace Ryujinx.HLE.HOS.Kernel } private void InsertBlock( - long BaseAddress, - long PagesCount, + ulong BaseAddress, + ulong PagesCount, MemoryState OldState, MemoryPermission OldPermission, MemoryAttribute OldAttribute, @@ -1498,8 +1501,7 @@ namespace Ryujinx.HLE.HOS.Kernel //arguments, otherwise leave it as is. OldAttribute |= MemoryAttribute.IpcAndDeviceMapped; - ulong BaseAddr = (ulong)BaseAddress; - ulong EndAddr = (ulong)PagesCount * PageSize + BaseAddr; + ulong EndAddr = PagesCount * PageSize + BaseAddress; LinkedListNode Node = Blocks.First; @@ -1510,10 +1512,10 @@ namespace Ryujinx.HLE.HOS.Kernel KMemoryBlock CurrBlock = Node.Value; - ulong CurrBaseAddr = (ulong)CurrBlock.BaseAddress; - ulong CurrEndAddr = (ulong)CurrBlock.PagesCount * PageSize + CurrBaseAddr; + ulong CurrBaseAddr = CurrBlock.BaseAddress; + ulong CurrEndAddr = CurrBlock.PagesCount * PageSize + CurrBaseAddr; - if (BaseAddr < CurrEndAddr && CurrBaseAddr < EndAddr) + if (BaseAddress < CurrEndAddr && CurrBaseAddr < EndAddr) { MemoryAttribute CurrBlockAttr = CurrBlock.Attribute | MemoryAttribute.IpcAndDeviceMapped; @@ -1526,23 +1528,23 @@ namespace Ryujinx.HLE.HOS.Kernel continue; } - if (CurrBaseAddr >= BaseAddr && CurrEndAddr <= EndAddr) + if (CurrBaseAddr >= BaseAddress && CurrEndAddr <= EndAddr) { CurrBlock.State = NewState; CurrBlock.Permission = NewPermission; CurrBlock.Attribute &= ~MemoryAttribute.IpcAndDeviceMapped; CurrBlock.Attribute |= NewAttribute; } - else if (CurrBaseAddr >= BaseAddr) + else if (CurrBaseAddr >= BaseAddress) { - CurrBlock.BaseAddress = (long)EndAddr; + CurrBlock.BaseAddress = EndAddr; - CurrBlock.PagesCount = (long)((CurrEndAddr - EndAddr) / PageSize); + CurrBlock.PagesCount = (CurrEndAddr - EndAddr) / PageSize; - long NewPagesCount = (long)((EndAddr - CurrBaseAddr) / PageSize); + ulong NewPagesCount = (EndAddr - CurrBaseAddr) / PageSize; NewNode = Blocks.AddBefore(Node, new KMemoryBlock( - (long)CurrBaseAddr, + CurrBaseAddr, NewPagesCount, NewState, NewPermission, @@ -1550,9 +1552,9 @@ namespace Ryujinx.HLE.HOS.Kernel } else if (CurrEndAddr <= EndAddr) { - CurrBlock.PagesCount = (long)((BaseAddr - CurrBaseAddr) / PageSize); + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - long NewPagesCount = (long)((CurrEndAddr - BaseAddr) / PageSize); + ulong NewPagesCount = (CurrEndAddr - BaseAddress) / PageSize; NewNode = Blocks.AddAfter(Node, new KMemoryBlock( BaseAddress, @@ -1563,9 +1565,9 @@ namespace Ryujinx.HLE.HOS.Kernel } else { - CurrBlock.PagesCount = (long)((BaseAddr - CurrBaseAddr) / PageSize); + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - long NextPagesCount = (long)((CurrEndAddr - EndAddr) / PageSize); + ulong NextPagesCount = (CurrEndAddr - EndAddr) / PageSize; NewNode = Blocks.AddAfter(Node, new KMemoryBlock( BaseAddress, @@ -1575,7 +1577,7 @@ namespace Ryujinx.HLE.HOS.Kernel NewAttribute)); Blocks.AddAfter(NewNode, new KMemoryBlock( - (long)EndAddr, + EndAddr, NextPagesCount, CurrBlock.State, CurrBlock.Permission, @@ -1592,8 +1594,8 @@ namespace Ryujinx.HLE.HOS.Kernel } private void InsertBlock( - long BaseAddress, - long PagesCount, + ulong BaseAddress, + ulong PagesCount, MemoryState State, MemoryPermission Permission = MemoryPermission.None, MemoryAttribute Attribute = MemoryAttribute.None) @@ -1602,8 +1604,7 @@ namespace Ryujinx.HLE.HOS.Kernel //existing blocks as needed. KMemoryBlock Block = new KMemoryBlock(BaseAddress, PagesCount, State, Permission, Attribute); - ulong BaseAddr = (ulong)BaseAddress; - ulong EndAddr = (ulong)PagesCount * PageSize + BaseAddr; + ulong EndAddr = PagesCount * PageSize + BaseAddress; LinkedListNode NewNode = null; @@ -1615,26 +1616,26 @@ namespace Ryujinx.HLE.HOS.Kernel LinkedListNode NextNode = Node.Next; - ulong CurrBaseAddr = (ulong)CurrBlock.BaseAddress; - ulong CurrEndAddr = (ulong)CurrBlock.PagesCount * PageSize + CurrBaseAddr; + ulong CurrBaseAddr = CurrBlock.BaseAddress; + ulong CurrEndAddr = CurrBlock.PagesCount * PageSize + CurrBaseAddr; - if (BaseAddr < CurrEndAddr && CurrBaseAddr < EndAddr) + if (BaseAddress < CurrEndAddr && CurrBaseAddr < EndAddr) { - if (BaseAddr >= CurrBaseAddr && EndAddr <= CurrEndAddr) + if (BaseAddress >= CurrBaseAddr && EndAddr <= CurrEndAddr) { Block.Attribute |= CurrBlock.Attribute & MemoryAttribute.IpcAndDeviceMapped; } - if (BaseAddr > CurrBaseAddr && EndAddr < CurrEndAddr) + if (BaseAddress > CurrBaseAddr && EndAddr < CurrEndAddr) { - CurrBlock.PagesCount = (long)((BaseAddr - CurrBaseAddr) / PageSize); + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; - long NextPagesCount = (long)((CurrEndAddr - EndAddr) / PageSize); + ulong NextPagesCount = (CurrEndAddr - EndAddr) / PageSize; NewNode = Blocks.AddAfter(Node, Block); Blocks.AddAfter(NewNode, new KMemoryBlock( - (long)EndAddr, + EndAddr, NextPagesCount, CurrBlock.State, CurrBlock.Permission, @@ -1642,20 +1643,20 @@ namespace Ryujinx.HLE.HOS.Kernel break; } - else if (BaseAddr <= CurrBaseAddr && EndAddr < CurrEndAddr) + else if (BaseAddress <= CurrBaseAddr && EndAddr < CurrEndAddr) { - CurrBlock.BaseAddress = (long)EndAddr; + CurrBlock.BaseAddress = EndAddr; - CurrBlock.PagesCount = (long)((CurrEndAddr - EndAddr) / PageSize); + CurrBlock.PagesCount = (CurrEndAddr - EndAddr) / PageSize; if (NewNode == null) { NewNode = Blocks.AddBefore(Node, Block); } } - else if (BaseAddr > CurrBaseAddr && EndAddr >= CurrEndAddr) + else if (BaseAddress > CurrBaseAddr && EndAddr >= CurrEndAddr) { - CurrBlock.PagesCount = (long)((BaseAddr - CurrBaseAddr) / PageSize); + CurrBlock.PagesCount = (BaseAddress - CurrBaseAddr) / PageSize; if (NewNode == null) { @@ -1688,8 +1689,7 @@ namespace Ryujinx.HLE.HOS.Kernel { KMemoryBlock Block = Node.Value; - ulong BaseAddr = (ulong)Block.BaseAddress; - ulong EndAddr = (ulong)Block.PagesCount * PageSize + BaseAddr; + ulong EndAddr = Block.PagesCount * PageSize + Block.BaseAddress; if (Node.Previous != null) { @@ -1700,8 +1700,6 @@ namespace Ryujinx.HLE.HOS.Kernel Blocks.Remove(Node.Previous); Block.BaseAddress = Previous.BaseAddress; - - BaseAddr = (ulong)Block.BaseAddress; } } @@ -1713,11 +1711,11 @@ namespace Ryujinx.HLE.HOS.Kernel { Blocks.Remove(Node.Next); - EndAddr = (ulong)(Next.BaseAddress + Next.PagesCount * PageSize); + EndAddr = Next.BaseAddress + Next.PagesCount * PageSize; } } - Block.PagesCount = (long)((EndAddr - BaseAddr) / PageSize); + Block.PagesCount = (EndAddr - Block.BaseAddress) / PageSize; } private static bool BlockStateEquals(KMemoryBlock Lhs, KMemoryBlock Rhs) @@ -1729,43 +1727,43 @@ namespace Ryujinx.HLE.HOS.Kernel Lhs.IpcRefCount == Rhs.IpcRefCount; } - private long FindFirstFit( - long RegionStart, - long RegionPagesCount, - long NeededPagesCount, - int Alignment, - long ReservedStart, - long ReservedPagesCount) + private ulong FindFirstFit( + ulong RegionStart, + ulong RegionPagesCount, + ulong NeededPagesCount, + int Alignment, + ulong ReservedStart, + ulong ReservedPagesCount) { - long ReservedSize = ReservedPagesCount * PageSize; + ulong ReservedSize = ReservedPagesCount * PageSize; - long TotalNeededSize = ReservedSize + NeededPagesCount * PageSize; + ulong TotalNeededSize = ReservedSize + NeededPagesCount * PageSize; - long RegionEndAddr = RegionStart + RegionPagesCount * PageSize; + ulong RegionEndAddr = RegionStart + RegionPagesCount * PageSize; LinkedListNode Node = FindBlockNode(RegionStart); KMemoryInfo Info = Node.Value.GetInfo(); - while ((ulong)RegionEndAddr >= (ulong)Info.Address) + while (RegionEndAddr >= Info.Address) { if (Info.State == MemoryState.Unmapped) { - long CurrBaseAddr = Info.Address + ReservedSize; - long CurrEndAddr = Info.Address + Info.Size - 1; + ulong CurrBaseAddr = Info.Address + ReservedSize; + ulong CurrEndAddr = Info.Address + Info.Size - 1; - long Address = BitUtils.AlignDown(CurrBaseAddr, Alignment) + ReservedStart; + ulong Address = BitUtils.AlignDown(CurrBaseAddr, Alignment) + ReservedStart; - if ((ulong)CurrBaseAddr > (ulong)Address) + if (CurrBaseAddr > Address) { - Address += Alignment; + Address += (ulong)Alignment; } - long AllocationEndAddr = Address + TotalNeededSize - 1; + ulong AllocationEndAddr = Address + TotalNeededSize - 1; - if ((ulong)AllocationEndAddr <= (ulong)RegionEndAddr && - (ulong)AllocationEndAddr <= (ulong)CurrEndAddr && - (ulong)Address < (ulong)AllocationEndAddr) + if (AllocationEndAddr <= RegionEndAddr && + AllocationEndAddr <= CurrEndAddr && + Address < AllocationEndAddr) { return Address; } @@ -1784,12 +1782,12 @@ namespace Ryujinx.HLE.HOS.Kernel return 0; } - private KMemoryBlock FindBlock(long Address) + private KMemoryBlock FindBlock(ulong Address) { return FindBlockNode(Address)?.Value; } - private LinkedListNode FindBlockNode(long Address) + private LinkedListNode FindBlockNode(ulong Address) { lock (Blocks) { @@ -1799,10 +1797,9 @@ namespace Ryujinx.HLE.HOS.Kernel { KMemoryBlock Block = Node.Value; - ulong CurrBaseAddr = (ulong)Block.BaseAddress; - ulong CurrEndAddr = (ulong)Block.PagesCount * PageSize + CurrBaseAddr; + ulong CurrEndAddr = Block.PagesCount * PageSize + Block.BaseAddress; - if (CurrBaseAddr <= (ulong)Address && CurrEndAddr - 1 >= (ulong)Address) + if (Block.BaseAddress <= Address && CurrEndAddr - 1 >= Address) { return Node; } @@ -1814,31 +1811,31 @@ namespace Ryujinx.HLE.HOS.Kernel return null; } - private bool ValidateRegionForState(long Address, long Size, MemoryState State) + private bool ValidateRegionForState(ulong Address, ulong Size, MemoryState State) { - long EndAddr = Address + Size; + ulong EndAddr = Address + Size; - long RegionBaseAddr = GetBaseAddrForState(State); + ulong RegionBaseAddr = GetBaseAddrForState(State); - long RegionEndAddr = RegionBaseAddr + GetSizeForState(State); + ulong RegionEndAddr = RegionBaseAddr + GetSizeForState(State); bool InsideRegion() { - return (ulong)RegionBaseAddr <= (ulong)Address && - (ulong)EndAddr > (ulong)Address && - (ulong)EndAddr - 1 <= (ulong)RegionEndAddr - 1; + return RegionBaseAddr <= Address && + EndAddr > Address && + EndAddr - 1 <= RegionEndAddr - 1; } bool OutsideHeapRegion() { - return (ulong)EndAddr <= (ulong)HeapRegionStart || - (ulong)Address >= (ulong)HeapRegionEnd; + return EndAddr <= HeapRegionStart || + Address >= HeapRegionEnd; } bool OutsideMapRegion() { - return (ulong)EndAddr <= (ulong)AliasRegionStart || - (ulong)Address >= (ulong)AliasRegionEnd; + return EndAddr <= AliasRegionStart || + Address >= AliasRegionEnd; } switch (State) @@ -1874,7 +1871,7 @@ namespace Ryujinx.HLE.HOS.Kernel throw new ArgumentException($"Invalid state value \"{State}\"."); } - private long GetBaseAddrForState(MemoryState State) + private ulong GetBaseAddrForState(MemoryState State) { switch (State) { @@ -1913,7 +1910,7 @@ namespace Ryujinx.HLE.HOS.Kernel throw new ArgumentException($"Invalid state value \"{State}\"."); } - private long GetSizeForState(MemoryState State) + private ulong GetSizeForState(MemoryState State) { switch (State) { @@ -1952,7 +1949,7 @@ namespace Ryujinx.HLE.HOS.Kernel throw new ArgumentException($"Invalid state value \"{State}\"."); } - public long GetAddrSpaceBaseAddr() + public ulong GetAddrSpaceBaseAddr() { if (AddrSpaceWidth == 36 || AddrSpaceWidth == 39) { @@ -1968,7 +1965,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public long GetAddrSpaceSize() + public ulong GetAddrSpaceSize() { if (AddrSpaceWidth == 36) { @@ -1988,9 +1985,9 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private KernelResult MapPages(long Address, KPageList PageList, MemoryPermission Permission) + private KernelResult MapPages(ulong Address, KPageList PageList, MemoryPermission Permission) { - long CurrAddr = Address; + ulong CurrAddr = Address; KernelResult Result = KernelResult.Success; @@ -2008,7 +2005,7 @@ namespace Ryujinx.HLE.HOS.Kernel { KMemoryInfo Info = FindBlock(CurrAddr).GetInfo(); - long PagesCount = (long)((ulong)(Address - CurrAddr) / PageSize); + ulong PagesCount = (Address - CurrAddr) / PageSize; Result = MmuUnmap(Address, PagesCount); @@ -2021,7 +2018,7 @@ namespace Ryujinx.HLE.HOS.Kernel return Result; } - private KernelResult MmuUnmap(long Address, long PagesCount) + private KernelResult MmuUnmap(ulong Address, ulong PagesCount) { return DoMmuOperation( Address, @@ -2032,7 +2029,7 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryOperation.Unmap); } - private KernelResult MmuChangePermission(long Address, long PagesCount, MemoryPermission Permission) + private KernelResult MmuChangePermission(ulong Address, ulong PagesCount, MemoryPermission Permission) { return DoMmuOperation( Address, @@ -2044,9 +2041,9 @@ namespace Ryujinx.HLE.HOS.Kernel } private KernelResult DoMmuOperation( - long DstVa, - long PagesCount, - long SrcPa, + ulong DstVa, + ulong PagesCount, + ulong SrcPa, bool Map, MemoryPermission Permission, MemoryOperation Operation) @@ -2062,9 +2059,9 @@ namespace Ryujinx.HLE.HOS.Kernel { case MemoryOperation.MapPa: { - long Size = PagesCount * PageSize; + ulong Size = PagesCount * PageSize; - CpuMemory.Map(DstVa, SrcPa - DramMemoryMap.DramBase, Size); + CpuMemory.Map((long)DstVa, (long)(SrcPa - DramMemoryMap.DramBase), (long)Size); Result = KernelResult.Success; @@ -2087,9 +2084,9 @@ namespace Ryujinx.HLE.HOS.Kernel case MemoryOperation.Unmap: { - long Size = PagesCount * PageSize; + ulong Size = PagesCount * PageSize; - CpuMemory.Unmap(DstVa, Size); + CpuMemory.Unmap((long)DstVa, (long)Size); Result = KernelResult.Success; @@ -2106,8 +2103,8 @@ namespace Ryujinx.HLE.HOS.Kernel } private KernelResult DoMmuOperation( - long Address, - long PagesCount, + ulong Address, + ulong PagesCount, KPageList PageList, MemoryPermission Permission, MemoryOperation Operation) @@ -2125,13 +2122,13 @@ namespace Ryujinx.HLE.HOS.Kernel return System.MemoryRegions[(int)MemRegion]; } - private KernelResult MmuMapPages(long Address, KPageList PageList) + private KernelResult MmuMapPages(ulong Address, KPageList PageList) { foreach (KPageNode PageNode in PageList) { - long Size = PageNode.PagesCount * PageSize; + ulong Size = PageNode.PagesCount * PageSize; - CpuMemory.Map(Address, PageNode.Address - DramMemoryMap.DramBase, Size); + CpuMemory.Map((long)Address, (long)(PageNode.Address - DramMemoryMap.DramBase), (long)Size); Address += Size; } @@ -2139,9 +2136,9 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public KernelResult ConvertVaToPa(long Va, out long Pa) + public KernelResult ConvertVaToPa(ulong Va, out ulong Pa) { - Pa = DramMemoryMap.DramBase + CpuMemory.GetPhysicalAddress(Va); + Pa = DramMemoryMap.DramBase + (ulong)CpuMemory.GetPhysicalAddress((long)Va); return KernelResult.Success; } @@ -2159,40 +2156,39 @@ namespace Ryujinx.HLE.HOS.Kernel return Blocks.Count * KMemoryBlockSize; } - public bool InsideAddrSpace(long Address, long Size) + public bool IsInvalidRegion(ulong Address, ulong Size) { - ulong Start = (ulong)Address; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)AddrSpaceStart && - End < (ulong)AddrSpaceEnd; + return Address + Size - 1 > GetAddrSpaceBaseAddr() + GetAddrSpaceSize() - 1; } - public bool InsideMapRegion(long Address, long Size) + public bool InsideAddrSpace(ulong Address, ulong Size) { - ulong Start = (ulong)Address; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)AliasRegionStart && - End < (ulong)AliasRegionEnd; + return AddrSpaceStart <= Address && Address + Size - 1 <= AddrSpaceEnd - 1; } - public bool InsideHeapRegion(long Address, long Size) + public bool InsideAliasRegion(ulong Address, ulong Size) { - ulong Start = (ulong)Address; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)HeapRegionStart && - End < (ulong)HeapRegionEnd; + return Address + Size > AliasRegionStart && AliasRegionEnd > Address; } - public bool InsideNewMapRegion(long Address, long Size) + public bool InsideHeapRegion(ulong Address, ulong Size) { - ulong Start = (ulong)Address; - ulong End = (ulong)Size + Start; + return Address + Size > HeapRegionStart && HeapRegionEnd > Address; + } - return Start >= (ulong)StackRegionStart && - End < (ulong)StackRegionEnd; + public bool InsideStackRegion(ulong Address, ulong Size) + { + return Address + Size > StackRegionStart && StackRegionEnd > Address; + } + + public bool OutsideAliasRegion(ulong Address, ulong Size) + { + return AliasRegionStart > Address || Address + Size - 1 > AliasRegionEnd - 1; + } + + public bool OutsideStackRegion(ulong Address, ulong Size) + { + return StackRegionStart > Address || Address + Size - 1 > StackRegionEnd - 1; } } } \ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs index b5bd73c3d6..1f334e655e 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionBlock.cs @@ -4,13 +4,13 @@ namespace Ryujinx.HLE.HOS.Kernel { public long[][] Masks; - public long FreeCount; - public int MaxLevel; - public long StartAligned; - public long SizeInBlocksTruncated; - public long SizeInBlocksRounded; - public int Order; - public int NextOrder; + public ulong FreeCount; + public int MaxLevel; + public ulong StartAligned; + public ulong SizeInBlocksTruncated; + public ulong SizeInBlocksRounded; + public int Order; + public int NextOrder; public bool TryCoalesce(int Index, int Size) { @@ -35,7 +35,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - FreeCount -= Size; + FreeCount -= (ulong)Size; return true; } diff --git a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs index 95ad302565..5c0517ea0e 100644 --- a/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs +++ b/Ryujinx.HLE/HOS/Kernel/KMemoryRegionManager.cs @@ -6,15 +6,15 @@ namespace Ryujinx.HLE.HOS.Kernel { private static readonly int[] BlockOrders = new int[] { 12, 16, 21, 22, 25, 29, 30 }; - public long Address { get; private set; } - public long EndAddr { get; private set; } - public long Size { get; private set; } + public ulong Address { get; private set; } + public ulong EndAddr { get; private set; } + public ulong Size { get; private set; } private int BlockOrdersCount; private KMemoryRegionBlock[] Blocks; - public KMemoryRegionManager(long Address, long Size, long EndAddr) + public KMemoryRegionManager(ulong Address, ulong Size, ulong EndAddr) { Blocks = new KMemoryRegionBlock[BlockOrders.Length]; @@ -42,18 +42,18 @@ namespace Ryujinx.HLE.HOS.Kernel NextBlockSize = 1 << NextOrder; } - long StartAligned = BitUtils.AlignDown(Address, NextBlockSize); - long EndAddrAligned = BitUtils.AlignDown(EndAddr, CurrBlockSize); + ulong StartAligned = BitUtils.AlignDown(Address, NextBlockSize); + ulong EndAddrAligned = BitUtils.AlignDown(EndAddr, CurrBlockSize); - ulong SizeInBlocksTruncated = (ulong)(EndAddrAligned - StartAligned) >> BlockOrders[BlockIndex]; + ulong SizeInBlocksTruncated = (EndAddrAligned - StartAligned) >> BlockOrders[BlockIndex]; - long EndAddrRounded = BitUtils.AlignUp(Address + Size, NextBlockSize); + ulong EndAddrRounded = BitUtils.AlignUp(Address + Size, NextBlockSize); - ulong SizeInBlocksRounded = (ulong)(EndAddrRounded - StartAligned) >> BlockOrders[BlockIndex]; + ulong SizeInBlocksRounded = (EndAddrRounded - StartAligned) >> BlockOrders[BlockIndex]; Blocks[BlockIndex].StartAligned = StartAligned; - Blocks[BlockIndex].SizeInBlocksTruncated = (long)SizeInBlocksTruncated; - Blocks[BlockIndex].SizeInBlocksRounded = (long)SizeInBlocksRounded; + Blocks[BlockIndex].SizeInBlocksTruncated = SizeInBlocksTruncated; + Blocks[BlockIndex].SizeInBlocksRounded = SizeInBlocksRounded; ulong CurrSizeInBlocks = SizeInBlocksRounded; @@ -85,7 +85,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public KernelResult AllocatePages(long PagesCount, bool Backwards, out KPageList PageList) + public KernelResult AllocatePages(ulong PagesCount, bool Backwards, out KPageList PageList) { lock (Blocks) { @@ -93,7 +93,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private KernelResult AllocatePagesImpl(long PagesCount, bool Backwards, out KPageList PageList) + private KernelResult AllocatePagesImpl(ulong PagesCount, bool Backwards, out KPageList PageList) { Backwards = false; @@ -109,10 +109,10 @@ namespace Ryujinx.HLE.HOS.Kernel ulong BlockPagesCount = (1UL << Block.Order) / KMemoryManager.PageSize; - AvailablePages += BlockPagesCount * (ulong)Block.FreeCount; + AvailablePages += BlockPagesCount * Block.FreeCount; } - if (AvailablePages < (ulong)PagesCount) + if (AvailablePages < PagesCount) { return KernelResult.OutOfMemory; } @@ -126,15 +126,15 @@ namespace Ryujinx.HLE.HOS.Kernel { KMemoryRegionBlock Block = Blocks[BlockIndex]; - int BestFitBlockSize = 1 << Block.Order; + ulong BestFitBlockSize = 1UL << Block.Order; - int BlockPagesCount = BestFitBlockSize / KMemoryManager.PageSize; + ulong BlockPagesCount = BestFitBlockSize / KMemoryManager.PageSize; //Check if this is the best fit for this page size. //If so, try allocating as much requested pages as possible. - while ((ulong)BlockPagesCount <= (ulong)PagesCount) + while (BlockPagesCount <= PagesCount) { - long Address = 0; + ulong Address = 0; for (int CurrBlockIndex = BlockIndex; CurrBlockIndex < BlockOrdersCount && Address == 0; @@ -167,7 +167,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - if ((ulong)Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask) + if (Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask) { continue; } @@ -186,7 +186,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - Address = Block.StartAligned + ((long)Index << Block.Order); + Address = Block.StartAligned + ((ulong)Index << Block.Order); } for (int CurrBlockIndex = BlockIndex; @@ -220,7 +220,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - if ((ulong)Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask) + if (Block.SizeInBlocksTruncated <= (ulong)Index || ZeroMask) { continue; } @@ -239,7 +239,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - Address = Block.StartAligned + ((long)Index << Block.Order); + Address = Block.StartAligned + ((ulong)Index << Block.Order); } //The address being zero means that no free space was found on that order, @@ -251,7 +251,7 @@ namespace Ryujinx.HLE.HOS.Kernel //If we are using a larger order than best fit, then we should //split it into smaller blocks. - int FirstFreeBlockSize = 1 << Block.Order; + ulong FirstFreeBlockSize = 1UL << Block.Order; if (FirstFreeBlockSize > BestFitBlockSize) { @@ -304,32 +304,31 @@ namespace Ryujinx.HLE.HOS.Kernel } } - private void FreePages(long Address, long PagesCount) + private void FreePages(ulong Address, ulong PagesCount) { - long EndAddr = Address + PagesCount * KMemoryManager.PageSize; + ulong EndAddr = Address + PagesCount * KMemoryManager.PageSize; int BlockIndex = BlockOrdersCount - 1; - long AddressRounded = 0; - long EndAddrTruncated = 0; + ulong AddressRounded = 0; + ulong EndAddrTruncated = 0; for (; BlockIndex >= 0; BlockIndex--) { KMemoryRegionBlock AllocInfo = Blocks[BlockIndex]; - long BlockSize = 1L << AllocInfo.Order; + int BlockSize = 1 << AllocInfo.Order; - AddressRounded = (Address + BlockSize - 1) & -BlockSize; + AddressRounded = BitUtils.AlignUp (Address, BlockSize); + EndAddrTruncated = BitUtils.AlignDown(EndAddr, BlockSize); - EndAddrTruncated = EndAddr & -BlockSize; - - if ((ulong)AddressRounded < (ulong)EndAddrTruncated) + if (AddressRounded < EndAddrTruncated) { break; } } - void FreeRegion(long CurrAddress) + void FreeRegion(ulong CurrAddress) { for (int CurrBlockIndex = BlockIndex; CurrBlockIndex < BlockOrdersCount && CurrAddress != 0; @@ -339,7 +338,7 @@ namespace Ryujinx.HLE.HOS.Kernel Block.FreeCount++; - ulong FreedBlocks = (ulong)(CurrAddress - Block.StartAligned) >> Block.Order; + ulong FreedBlocks = (CurrAddress - Block.StartAligned) >> Block.Order; int Index = (int)FreedBlocks; @@ -357,23 +356,23 @@ namespace Ryujinx.HLE.HOS.Kernel int BlockSizeDelta = 1 << (Block.NextOrder - Block.Order); - int FreedBlocksTruncated = (int)FreedBlocks & -BlockSizeDelta; + int FreedBlocksTruncated = BitUtils.AlignDown((int)FreedBlocks, BlockSizeDelta); if (!Block.TryCoalesce(FreedBlocksTruncated, BlockSizeDelta)) { break; } - CurrAddress = Block.StartAligned + ((long)FreedBlocksTruncated << Block.Order); + CurrAddress = Block.StartAligned + ((ulong)FreedBlocksTruncated << Block.Order); } } //Free inside aligned region. - long BaseAddress = AddressRounded; + ulong BaseAddress = AddressRounded; - while ((ulong)BaseAddress < (ulong)EndAddrTruncated) + while (BaseAddress < EndAddrTruncated) { - long BlockSize = 1L << Blocks[BlockIndex].Order; + ulong BlockSize = 1UL << Blocks[BlockIndex].Order; FreeRegion(BaseAddress); @@ -387,9 +386,9 @@ namespace Ryujinx.HLE.HOS.Kernel for (BlockIndex = NextBlockIndex; BlockIndex >= 0; BlockIndex--) { - long BlockSize = 1L << Blocks[BlockIndex].Order; + ulong BlockSize = 1UL << Blocks[BlockIndex].Order; - while ((ulong)(BaseAddress - BlockSize) >= (ulong)Address) + while (BaseAddress - BlockSize >= Address) { BaseAddress -= BlockSize; @@ -402,9 +401,9 @@ namespace Ryujinx.HLE.HOS.Kernel for (BlockIndex = NextBlockIndex; BlockIndex >= 0; BlockIndex--) { - long BlockSize = 1L << Blocks[BlockIndex].Order; + ulong BlockSize = 1UL << Blocks[BlockIndex].Order; - while ((ulong)(BaseAddress + BlockSize) <= (ulong)EndAddr) + while (BaseAddress + BlockSize <= EndAddr) { FreeRegion(BaseAddress); diff --git a/Ryujinx.HLE/HOS/Kernel/KPageList.cs b/Ryujinx.HLE/HOS/Kernel/KPageList.cs index b750f33fe2..05162323fa 100644 --- a/Ryujinx.HLE/HOS/Kernel/KPageList.cs +++ b/Ryujinx.HLE/HOS/Kernel/KPageList.cs @@ -12,7 +12,7 @@ namespace Ryujinx.HLE.HOS.Kernel Nodes = new LinkedList(); } - public KernelResult AddRange(long Address, long PagesCount) + public KernelResult AddRange(ulong Address, ulong PagesCount) { if (PagesCount != 0) { @@ -35,9 +35,9 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public long GetPagesCount() + public ulong GetPagesCount() { - long Sum = 0; + ulong Sum = 0; foreach (KPageNode Node in Nodes) { diff --git a/Ryujinx.HLE/HOS/Kernel/KPageNode.cs b/Ryujinx.HLE/HOS/Kernel/KPageNode.cs index cc11e53129..6cecab2e7f 100644 --- a/Ryujinx.HLE/HOS/Kernel/KPageNode.cs +++ b/Ryujinx.HLE/HOS/Kernel/KPageNode.cs @@ -2,10 +2,10 @@ namespace Ryujinx.HLE.HOS.Kernel { struct KPageNode { - public long Address; - public long PagesCount; + public ulong Address; + public ulong PagesCount; - public KPageNode(long Address, long PagesCount) + public KPageNode(ulong Address, ulong PagesCount) { this.Address = Address; this.PagesCount = PagesCount; diff --git a/Ryujinx.HLE/HOS/Kernel/KProcess.cs b/Ryujinx.HLE/HOS/Kernel/KProcess.cs index 0044cd8d35..ea29372ec8 100644 --- a/Ryujinx.HLE/HOS/Kernel/KProcess.cs +++ b/Ryujinx.HLE/HOS/Kernel/KProcess.cs @@ -21,10 +21,8 @@ namespace Ryujinx.HLE.HOS.Kernel public KMemoryManager MemoryManager { get; private set; } - private long TotalMemoryUsage; - - private SortedDictionary FullTlsPages; - private SortedDictionary FreeTlsPages; + private SortedDictionary FullTlsPages; + private SortedDictionary FreeTlsPages; public int DefaultCpuCore { get; private set; } @@ -32,7 +30,7 @@ namespace Ryujinx.HLE.HOS.Kernel public KResourceLimit ResourceLimit { get; private set; } - public long PersonalMmHeapPagesCount { get; private set; } + public ulong PersonalMmHeapPagesCount { get; private set; } private ProcessState State; @@ -59,16 +57,16 @@ namespace Ryujinx.HLE.HOS.Kernel public long TitleId { get; private set; } public long Pid { get; private set; } - private long CreationTimestamp; - private long Entrypoint; - private long ImageSize; - private long MainThreadStackSize; - private long MemoryUsageCapacity; - private int Category; + private long CreationTimestamp; + private ulong Entrypoint; + private ulong ImageSize; + private ulong MainThreadStackSize; + private ulong MemoryUsageCapacity; + private int Category; public KHandleTable HandleTable { get; private set; } - public long UserExceptionContextAddress { get; private set; } + public ulong UserExceptionContextAddress { get; private set; } private LinkedList Threads; @@ -93,8 +91,8 @@ namespace Ryujinx.HLE.HOS.Kernel MemoryManager = new KMemoryManager(System, CpuMemory); - FullTlsPages = new SortedDictionary(); - FreeTlsPages = new SortedDictionary(); + FullTlsPages = new SortedDictionary(); + FreeTlsPages = new SortedDictionary(); Capabilities = new KProcessCapabilities(); @@ -122,9 +120,9 @@ namespace Ryujinx.HLE.HOS.Kernel bool AslrEnabled = ((CreationInfo.MmuFlags >> 5) & 1) != 0; - long CodeAddress = CreationInfo.CodeAddress; + ulong CodeAddress = CreationInfo.CodeAddress; - long CodeSize = (long)(uint)CreationInfo.CodePagesCount * KMemoryManager.PageSize; + ulong CodeSize = (ulong)CreationInfo.CodePagesCount * KMemoryManager.PageSize; KernelResult Result = MemoryManager.InitializeForProcess( AddrSpaceType, @@ -183,11 +181,11 @@ namespace Ryujinx.HLE.HOS.Kernel this.ResourceLimit = ResourceLimit; this.MemRegion = MemRegion; - long PersonalMmHeapSize = GetPersonalMmHeapSize(CreationInfo.PersonalMmHeapPagesCount, MemRegion); + ulong PersonalMmHeapSize = GetPersonalMmHeapSize((ulong)CreationInfo.PersonalMmHeapPagesCount, MemRegion); - long CodePagesCount = (long)(uint)CreationInfo.CodePagesCount; + ulong CodePagesCount = (ulong)CreationInfo.CodePagesCount; - long NeededSizeForProcess = PersonalMmHeapSize + CodePagesCount * KMemoryManager.PageSize; + ulong NeededSizeForProcess = PersonalMmHeapSize + CodePagesCount * KMemoryManager.PageSize; if (NeededSizeForProcess != 0 && ResourceLimit != null) { @@ -205,7 +203,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - PersonalMmHeapPagesCount = CreationInfo.PersonalMmHeapPagesCount; + PersonalMmHeapPagesCount = (ulong)CreationInfo.PersonalMmHeapPagesCount; if (PersonalMmHeapPagesCount != 0) { @@ -216,9 +214,9 @@ namespace Ryujinx.HLE.HOS.Kernel bool AslrEnabled = ((CreationInfo.MmuFlags >> 5) & 1) != 0; - long CodeAddress = CreationInfo.CodeAddress; + ulong CodeAddress = CreationInfo.CodeAddress; - long CodeSize = CodePagesCount * KMemoryManager.PageSize; + ulong CodeSize = CodePagesCount * KMemoryManager.PageSize; KernelResult Result = MemoryManager.InitializeForProcess( AddrSpaceType, @@ -281,10 +279,10 @@ namespace Ryujinx.HLE.HOS.Kernel return Result; } - private bool ValidateCodeAddressAndSize(long Address, long Size) + private bool ValidateCodeAddressAndSize(ulong Address, ulong Size) { - long CodeRegionStart; - long CodeRegionSize; + ulong CodeRegionStart; + ulong CodeRegionSize; switch (MemoryManager.AddrSpaceWidth) { @@ -306,18 +304,18 @@ namespace Ryujinx.HLE.HOS.Kernel default: throw new InvalidOperationException("Invalid address space width on memory manager."); } - long EndAddr = Address + Size; + ulong EndAddr = Address + Size; - long CodeRegionEnd = CodeRegionStart + CodeRegionSize; + ulong CodeRegionEnd = CodeRegionStart + CodeRegionSize; - if ((ulong)EndAddr <= (ulong)Address || - (ulong)EndAddr - 1 > (ulong)CodeRegionEnd - 1) + if (EndAddr <= Address || + EndAddr - 1 > CodeRegionEnd - 1) { return false; } if (MemoryManager.InsideHeapRegion(Address, Size) || - MemoryManager.InsideMapRegion (Address, Size)) + MemoryManager.InsideAliasRegion (Address, Size)) { return false; } @@ -346,7 +344,7 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.InvalidCombination; } - KernelResult Result = AllocateThreadLocalStorage(out long UserExceptionContextAddress); + KernelResult Result = AllocateThreadLocalStorage(out ulong UserExceptionContextAddress); if (Result != KernelResult.Success) { @@ -355,7 +353,7 @@ namespace Ryujinx.HLE.HOS.Kernel this.UserExceptionContextAddress = UserExceptionContextAddress; - MemoryHelper.FillWithZeros(CpuMemory, UserExceptionContextAddress, KTlsPageInfo.TlsEntrySize); + MemoryHelper.FillWithZeros(CpuMemory, (long)UserExceptionContextAddress, KTlsPageInfo.TlsEntrySize); Name = CreationInfo.Name; @@ -367,7 +365,7 @@ namespace Ryujinx.HLE.HOS.Kernel Category = CreationInfo.Category; TitleId = CreationInfo.TitleId; Entrypoint = CreationInfo.CodeAddress; - ImageSize = CreationInfo.CodePagesCount * KMemoryManager.PageSize; + ImageSize = (ulong)CreationInfo.CodePagesCount * KMemoryManager.PageSize; UseSystemMemBlocks = ((MmuFlags >> 6) & 1) != 0; @@ -395,7 +393,7 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.Success; } - public KernelResult AllocateThreadLocalStorage(out long Address) + public KernelResult AllocateThreadLocalStorage(out ulong Address) { System.CriticalSection.Enter(); @@ -449,15 +447,15 @@ namespace Ryujinx.HLE.HOS.Kernel { PageInfo = default(KTlsPageInfo); - if (!System.UserSlabHeapPages.TryGetItem(out long TlsPagePa)) + if (!System.UserSlabHeapPages.TryGetItem(out ulong TlsPagePa)) { return KernelResult.OutOfMemory; } - long RegionStart = MemoryManager.TlsIoRegionStart; - long RegionSize = MemoryManager.TlsIoRegionEnd - RegionStart; + ulong RegionStart = MemoryManager.TlsIoRegionStart; + ulong RegionSize = MemoryManager.TlsIoRegionEnd - RegionStart; - long RegionPagesCount = (long)((ulong)RegionSize / KMemoryManager.PageSize); + ulong RegionPagesCount = RegionSize / KMemoryManager.PageSize; KernelResult Result = MemoryManager.AllocateOrMapPa( 1, @@ -468,7 +466,7 @@ namespace Ryujinx.HLE.HOS.Kernel RegionPagesCount, MemoryState.ThreadLocal, MemoryPermission.ReadAndWrite, - out long TlsPageVa); + out ulong TlsPageVa); if (Result != KernelResult.Success) { @@ -478,15 +476,15 @@ namespace Ryujinx.HLE.HOS.Kernel { PageInfo = new KTlsPageInfo(TlsPageVa); - MemoryHelper.FillWithZeros(CpuMemory, TlsPageVa, KMemoryManager.PageSize); + MemoryHelper.FillWithZeros(CpuMemory, (long)TlsPageVa, KMemoryManager.PageSize); } return Result; } - public KernelResult FreeThreadLocalStorage(long TlsSlotAddr) + public KernelResult FreeThreadLocalStorage(ulong TlsSlotAddr) { - long TlsPageAddr = BitUtils.AlignDown(TlsSlotAddr, KMemoryManager.PageSize); + ulong TlsPageAddr = BitUtils.AlignDown(TlsSlotAddr, KMemoryManager.PageSize); System.CriticalSection.Enter(); @@ -531,7 +529,7 @@ namespace Ryujinx.HLE.HOS.Kernel private KernelResult FreeTlsPage(KTlsPageInfo PageInfo) { - KernelResult Result = MemoryManager.ConvertVaToPa(PageInfo.PageAddr, out long TlsPagePa); + KernelResult Result = MemoryManager.ConvertVaToPa(PageInfo.PageAddr, out ulong TlsPagePa); if (Result != KernelResult.Success) { @@ -553,7 +551,7 @@ namespace Ryujinx.HLE.HOS.Kernel //TODO. } - public KernelResult Start(int MainThreadPriority, long StackSize) + public KernelResult Start(int MainThreadPriority, ulong StackSize) { lock (ProcessLock) { @@ -575,15 +573,15 @@ namespace Ryujinx.HLE.HOS.Kernel throw new InvalidOperationException("Trying to start a process with a invalid state!"); } - long StackSizeRounded = BitUtils.AlignUp(StackSize, KMemoryManager.PageSize); + ulong StackSizeRounded = BitUtils.AlignUp(StackSize, KMemoryManager.PageSize); - long NeededSize = StackSizeRounded + ImageSize; + ulong NeededSize = StackSizeRounded + ImageSize; //Check if the needed size for the code and the stack will fit on the //memory usage capacity of this Process. Also check for possible overflow //on the above addition. - if ((ulong)NeededSize > (ulong)MemoryUsageCapacity || - (ulong)NeededSize < (ulong)StackSizeRounded) + if (NeededSize > MemoryUsageCapacity || + NeededSize < StackSizeRounded) { ThreadResourceLimit?.Release(LimitableResource.Thread, 1); @@ -606,7 +604,7 @@ namespace Ryujinx.HLE.HOS.Kernel KThread MainThread = null; - long StackTop = 0; + ulong StackTop = 0; void CleanUpForError() { @@ -615,9 +613,9 @@ namespace Ryujinx.HLE.HOS.Kernel if (MainThreadStackSize != 0) { - long StackBottom = StackTop - MainThreadStackSize; + ulong StackBottom = StackTop - MainThreadStackSize; - long StackPagesCount = (long)((ulong)MainThreadStackSize / KMemoryManager.PageSize); + ulong StackPagesCount = MainThreadStackSize / KMemoryManager.PageSize; MemoryManager.UnmapForKernel(StackBottom, StackPagesCount, MemoryState.Stack); } @@ -628,12 +626,12 @@ namespace Ryujinx.HLE.HOS.Kernel if (StackSizeRounded != 0) { - long StackPagesCount = (long)((ulong)StackSizeRounded / KMemoryManager.PageSize); + ulong StackPagesCount = StackSizeRounded / KMemoryManager.PageSize; - long RegionStart = MemoryManager.StackRegionStart; - long RegionSize = MemoryManager.StackRegionEnd - RegionStart; + ulong RegionStart = MemoryManager.StackRegionStart; + ulong RegionSize = MemoryManager.StackRegionEnd - RegionStart; - long RegionPagesCount = (long)((ulong)RegionSize / KMemoryManager.PageSize); + ulong RegionPagesCount = RegionSize / KMemoryManager.PageSize; Result = MemoryManager.AllocateOrMapPa( StackPagesCount, @@ -644,7 +642,7 @@ namespace Ryujinx.HLE.HOS.Kernel RegionPagesCount, MemoryState.Stack, MemoryPermission.ReadAndWrite, - out long StackBottom); + out ulong StackBottom); if (Result != KernelResult.Success) { @@ -658,7 +656,7 @@ namespace Ryujinx.HLE.HOS.Kernel StackTop = StackBottom + StackSizeRounded; } - long HeapCapacity = MemoryUsageCapacity - MainThreadStackSize - ImageSize; + ulong HeapCapacity = MemoryUsageCapacity - MainThreadStackSize - ImageSize; Result = MemoryManager.SetHeapCapacity(HeapCapacity); @@ -747,9 +745,9 @@ namespace Ryujinx.HLE.HOS.Kernel public KernelResult InitializeThread( KThread Thread, - long Entrypoint, - long ArgsPtr, - long StackTop, + ulong Entrypoint, + ulong ArgsPtr, + ulong StackTop, int Priority, int CpuCore) { @@ -783,9 +781,9 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public long GetMemoryCapacity() + public ulong GetMemoryCapacity() { - long TotalCapacity = ResourceLimit.GetRemainingValue(LimitableResource.Memory); + ulong TotalCapacity = (ulong)ResourceLimit.GetRemainingValue(LimitableResource.Memory); TotalCapacity += MemoryManager.GetTotalHeapSize(); @@ -793,7 +791,7 @@ namespace Ryujinx.HLE.HOS.Kernel TotalCapacity += ImageSize + MainThreadStackSize; - if ((ulong)TotalCapacity <= (ulong)MemoryUsageCapacity) + if (TotalCapacity <= MemoryUsageCapacity) { return TotalCapacity; } @@ -801,28 +799,28 @@ namespace Ryujinx.HLE.HOS.Kernel return MemoryUsageCapacity; } - public long GetMemoryUsage() + public ulong GetMemoryUsage() { //TODO: Personal Mm Heap. return ImageSize + MainThreadStackSize + MemoryManager.GetTotalHeapSize(); } - public long GetMemoryCapacityWithoutPersonalMmHeap() + public ulong GetMemoryCapacityWithoutPersonalMmHeap() { return GetMemoryCapacity() - GetPersonalMmHeapSize(); } - public long GetMemoryUsageWithoutPersonalMmHeap() + public ulong GetMemoryUsageWithoutPersonalMmHeap() { return GetMemoryUsage() - GetPersonalMmHeapSize(); } - private long GetPersonalMmHeapSize() + private ulong GetPersonalMmHeapSize() { return GetPersonalMmHeapSize(PersonalMmHeapPagesCount, MemRegion); } - private static long GetPersonalMmHeapSize(long PersonalMmHeapPagesCount, MemoryRegion MemRegion) + private static ulong GetPersonalMmHeapSize(ulong PersonalMmHeapPagesCount, MemoryRegion MemRegion) { if (MemRegion == MemoryRegion.Applet) { diff --git a/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs b/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs index 0a8fd88dd5..6fd70d0cad 100644 --- a/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs +++ b/Ryujinx.HLE/HOS/Kernel/KResourceLimit.cs @@ -5,6 +5,8 @@ namespace Ryujinx.HLE.HOS.Kernel { class KResourceLimit { + private const int Time10SecondsMs = 10000; + private long[] Current; private long[] Limit; private long[] Available; @@ -30,10 +32,14 @@ namespace Ryujinx.HLE.HOS.Kernel this.System = System; } + public bool Reserve(LimitableResource Resource, ulong Amount) + { + return Reserve(Resource, (long)Amount); + } + public bool Reserve(LimitableResource Resource, long Amount) { - //Wait 10 seconds for the resource if no timeout is specified. - return Reserve(Resource, Amount, KTimeManager.ConvertMillisecondsToNanoseconds(10000)); + return Reserve(Resource, Amount, KTimeManager.ConvertMillisecondsToNanoseconds(Time10SecondsMs)); } public bool Reserve(LimitableResource Resource, long Amount, long Timeout) @@ -77,6 +83,11 @@ namespace Ryujinx.HLE.HOS.Kernel return Success; } + public void Release(LimitableResource Resource, ulong Amount) + { + Release(Resource, (long)Amount); + } + public void Release(LimitableResource Resource, long Amount) { Release(Resource, Amount, Amount); diff --git a/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs b/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs index 5691e74a09..a440438b9e 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSharedMemory.cs @@ -25,12 +25,12 @@ namespace Ryujinx.HLE.HOS.Kernel public KernelResult MapIntoProcess( KMemoryManager MemoryManager, - long Address, - long Size, + ulong Address, + ulong Size, KProcess Process, MemoryPermission Permission) { - long PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize); + ulong PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize); if (PageList.GetPagesCount() != PagesCountRounded) { @@ -51,11 +51,11 @@ namespace Ryujinx.HLE.HOS.Kernel public KernelResult UnmapFromProcess( KMemoryManager MemoryManager, - long Address, - long Size, + ulong Address, + ulong Size, KProcess Process) { - long PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize); + ulong PagesCountRounded = BitUtils.DivRoundUp(Size, KMemoryManager.PageSize); if (PageList.GetPagesCount() != PagesCountRounded) { diff --git a/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs b/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs index a728542960..2d6b3ca0f7 100644 --- a/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs +++ b/Ryujinx.HLE/HOS/Kernel/KSlabHeap.cs @@ -4,11 +4,11 @@ namespace Ryujinx.HLE.HOS.Kernel { class KSlabHeap { - private LinkedList Items; + private LinkedList Items; - public KSlabHeap(long Pa, long ItemSize, long Size) + public KSlabHeap(ulong Pa, ulong ItemSize, ulong Size) { - Items = new LinkedList(); + Items = new LinkedList(); int ItemsCount = (int)(Size / ItemSize); @@ -20,7 +20,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public bool TryGetItem(out long Pa) + public bool TryGetItem(out ulong Pa) { lock (Items) { @@ -39,7 +39,7 @@ namespace Ryujinx.HLE.HOS.Kernel return false; } - public void Free(long Pa) + public void Free(ulong Pa) { lock (Items) { diff --git a/Ryujinx.HLE/HOS/Kernel/KThread.cs b/Ryujinx.HLE/HOS/Kernel/KThread.cs index 6b908f2b20..88f144c81c 100644 --- a/Ryujinx.HLE/HOS/Kernel/KThread.cs +++ b/Ryujinx.HLE/HOS/Kernel/KThread.cs @@ -22,13 +22,13 @@ namespace Ryujinx.HLE.HOS.Kernel public long CondVarAddress { get; set; } - private long Entrypoint; + private ulong Entrypoint; public long MutexAddress { get; set; } public KProcess Owner { get; private set; } - private long TlsAddress; + private ulong TlsAddress; public long LastScheduledTime { get; set; } @@ -87,9 +87,9 @@ namespace Ryujinx.HLE.HOS.Kernel } public KernelResult Initialize( - long Entrypoint, - long ArgsPtr, - long StackTop, + ulong Entrypoint, + ulong ArgsPtr, + ulong StackTop, int Priority, int DefaultCpuCore, KProcess Owner, @@ -124,7 +124,7 @@ namespace Ryujinx.HLE.HOS.Kernel return KernelResult.OutOfMemory; } - MemoryHelper.FillWithZeros(Owner.CpuMemory, TlsAddress, KTlsPageInfo.TlsEntrySize); + MemoryHelper.FillWithZeros(Owner.CpuMemory, (long)TlsAddress, KTlsPageInfo.TlsEntrySize); } bool Is64Bits; @@ -142,13 +142,13 @@ namespace Ryujinx.HLE.HOS.Kernel Is64Bits = true; } - Context = new CpuThread(Owner.Translator, Owner.CpuMemory, Entrypoint); + Context = new CpuThread(Owner.Translator, Owner.CpuMemory, (long)Entrypoint); - Context.ThreadState.X0 = (ulong)ArgsPtr; - Context.ThreadState.X31 = (ulong)StackTop; + Context.ThreadState.X0 = ArgsPtr; + Context.ThreadState.X31 = StackTop; Context.ThreadState.CntfrqEl0 = 19200000; - Context.ThreadState.Tpidr = TlsAddress; + Context.ThreadState.Tpidr = (long)TlsAddress; Owner.SubscribeThreadEventHandlers(Context); diff --git a/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs b/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs index 7f88c757c7..18dc2decf4 100644 --- a/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs +++ b/Ryujinx.HLE/HOS/Kernel/KTlsPageInfo.cs @@ -4,11 +4,11 @@ namespace Ryujinx.HLE.HOS.Kernel { public const int TlsEntrySize = 0x200; - public long PageAddr { get; private set; } + public ulong PageAddr { get; private set; } private bool[] IsSlotFree; - public KTlsPageInfo(long PageAddress) + public KTlsPageInfo(ulong PageAddress) { this.PageAddr = PageAddress; @@ -20,7 +20,7 @@ namespace Ryujinx.HLE.HOS.Kernel } } - public bool TryGetFreePage(out long Address) + public bool TryGetFreePage(out ulong Address) { Address = PageAddr; @@ -65,7 +65,7 @@ namespace Ryujinx.HLE.HOS.Kernel return AllFree; } - public void FreeTlsSlot(long Address) + public void FreeTlsSlot(ulong Address) { IsSlotFree[(Address - PageAddr) / TlsEntrySize] = true; } diff --git a/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs b/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs index 6ebffa7e49..5598f78d28 100644 --- a/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs +++ b/Ryujinx.HLE/HOS/Kernel/KTransferMemory.cs @@ -2,13 +2,13 @@ namespace Ryujinx.HLE.HOS.Kernel { class KTransferMemory { - public long Position { get; private set; } - public long Size { get; private set; } + public ulong Address { get; private set; } + public ulong Size { get; private set; } - public KTransferMemory(long Position, long Size) + public KTransferMemory(ulong Address, ulong Size) { - this.Position = Position; - this.Size = Size; + this.Address = Address; + this.Size = Size; } } } \ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/KernelInit.cs b/Ryujinx.HLE/HOS/Kernel/KernelInit.cs index 912b4b4904..efb514c120 100644 --- a/Ryujinx.HLE/HOS/Kernel/KernelInit.cs +++ b/Ryujinx.HLE/HOS/Kernel/KernelInit.cs @@ -59,23 +59,23 @@ namespace Ryujinx.HLE.HOS.Kernel ulong RamSize = (ulong)GetRamSize(KernelMemoryCfg); - long RamPart0; - long RamPart1; + ulong RamPart0; + ulong RamPart1; if (RamSize * 2 > EmemApertureSize) { - RamPart0 = (long)(EmemApertureSize / 2); - RamPart1 = (long)(EmemApertureSize / 2); + RamPart0 = EmemApertureSize / 2; + RamPart1 = EmemApertureSize / 2; } else { - RamPart0 = (long)EmemApertureSize; + RamPart0 = EmemApertureSize; RamPart1 = 0; } int MemoryArrange = 1; - long ApplicationRgSize; + ulong ApplicationRgSize; switch (MemoryArrange) { @@ -85,7 +85,7 @@ namespace Ryujinx.HLE.HOS.Kernel default: ApplicationRgSize = 0xcd500000; break; } - long AppletRgSize; + ulong AppletRgSize; switch (MemoryArrange) { @@ -102,13 +102,13 @@ namespace Ryujinx.HLE.HOS.Kernel KMemoryArrangeRegion AppletRg; KMemoryArrangeRegion ApplicationRg; - const long NvServicesRgSize = 0x29ba000; + const ulong NvServicesRgSize = 0x29ba000; - long ApplicationRgEnd = DramMemoryMap.DramEnd; //- RamPart0; + ulong ApplicationRgEnd = DramMemoryMap.DramEnd; //- RamPart0; ApplicationRg = new KMemoryArrangeRegion(ApplicationRgEnd - ApplicationRgSize, ApplicationRgSize); - long NvServicesRgEnd = ApplicationRg.Address - AppletRgSize; + ulong NvServicesRgEnd = ApplicationRg.Address - AppletRgSize; NvServicesRg = new KMemoryArrangeRegion(NvServicesRgEnd - NvServicesRgSize, NvServicesRgSize); AppletRg = new KMemoryArrangeRegion(NvServicesRgEnd, AppletRgSize); @@ -116,7 +116,7 @@ namespace Ryujinx.HLE.HOS.Kernel //Note: There is an extra region used by the kernel, however //since we are doing HLE we are not going to use that memory, so give all //the remaining memory space to services. - long ServiceRgSize = NvServicesRg.Address - DramMemoryMap.SlabHeapEnd; + ulong ServiceRgSize = NvServicesRg.Address - DramMemoryMap.SlabHeapEnd; ServiceRg = new KMemoryArrangeRegion(DramMemoryMap.SlabHeapEnd, ServiceRgSize); diff --git a/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs b/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs index d3511b8202..dae1345aef 100644 --- a/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs +++ b/Ryujinx.HLE/HOS/Kernel/ProcessCreationInfo.cs @@ -7,8 +7,8 @@ namespace Ryujinx.HLE.HOS.Kernel public int Category { get; private set; } public long TitleId { get; private set; } - public long CodeAddress { get; private set; } - public int CodePagesCount { get; private set; } + public ulong CodeAddress { get; private set; } + public int CodePagesCount { get; private set; } public int MmuFlags { get; private set; } public int ResourceLimitHandle { get; private set; } @@ -18,7 +18,7 @@ namespace Ryujinx.HLE.HOS.Kernel string Name, int Category, long TitleId, - long CodeAddress, + ulong CodeAddress, int CodePagesCount, int MmuFlags, int ResourceLimitHandle, diff --git a/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs b/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs index 949f77b33c..4927d1b0fc 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcMemory.cs @@ -20,13 +20,13 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - KernelResult Result = Process.MemoryManager.SetHeapSize((long)Size, out long Position); + KernelResult Result = Process.MemoryManager.SetHeapSize(Size, out ulong Position); ThreadState.X0 = (ulong)Result; if (Result == KernelResult.Success) { - ThreadState.X1 = (ulong)Position; + ThreadState.X1 = Position; } else { @@ -36,8 +36,8 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcSetMemoryAttribute(CpuThreadState ThreadState) { - long Position = (long)ThreadState.X0; - long Size = (long)ThreadState.X1; + ulong Position = ThreadState.X0; + ulong Size = ThreadState.X1; if (!PageAligned(Position)) { @@ -84,7 +84,7 @@ namespace Ryujinx.HLE.HOS.Kernel } else { - Memory.StopObservingRegion(Position, Size); + Memory.StopObservingRegion((long)Position, (long)Size); } ThreadState.X0 = (ulong)Result; @@ -92,9 +92,9 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcMapMemory(CpuThreadState ThreadState) { - long Dst = (long)ThreadState.X0; - long Src = (long)ThreadState.X1; - long Size = (long)ThreadState.X2; + ulong Dst = ThreadState.X0; + ulong Src = ThreadState.X1; + ulong Size = ThreadState.X2; if (!PageAligned(Src | Dst)) { @@ -114,7 +114,7 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if ((ulong)(Src + Size) <= (ulong)Src || (ulong)(Dst + Size) <= (ulong)Dst) + if (Src + Size <= Src || Dst + Size <= Dst) { Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!"); @@ -123,7 +123,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if (!InsideAddrSpace(Src, Size)) + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); + + if (!CurrentProcess.MemoryManager.InsideAddrSpace(Src, Size)) { Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{Src:x16} out of range!"); @@ -132,7 +134,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if (!InsideNewMapRegion(Dst, Size)) + if (CurrentProcess.MemoryManager.OutsideStackRegion(Dst, Size) || + CurrentProcess.MemoryManager.InsideHeapRegion (Dst, Size) || + CurrentProcess.MemoryManager.InsideAliasRegion (Dst, Size)) { Logger.PrintWarning(LogClass.KernelSvc, $"Dst address 0x{Dst:x16} out of range!"); @@ -153,9 +157,9 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcUnmapMemory(CpuThreadState ThreadState) { - long Dst = (long)ThreadState.X0; - long Src = (long)ThreadState.X1; - long Size = (long)ThreadState.X2; + ulong Dst = ThreadState.X0; + ulong Src = ThreadState.X1; + ulong Size = ThreadState.X2; if (!PageAligned(Src | Dst)) { @@ -175,7 +179,7 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if ((ulong)(Src + Size) <= (ulong)Src || (ulong)(Dst + Size) <= (ulong)Dst) + if (Src + Size <= Src || Dst + Size <= Dst) { Logger.PrintWarning(LogClass.KernelSvc, "Addresses outside of range!"); @@ -184,7 +188,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if (!InsideAddrSpace(Src, Size)) + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); + + if (!CurrentProcess.MemoryManager.InsideAddrSpace(Src, Size)) { Logger.PrintWarning(LogClass.KernelSvc, $"Src address 0x{Src:x16} out of range!"); @@ -193,7 +199,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if (!InsideNewMapRegion(Dst, Size)) + if (CurrentProcess.MemoryManager.OutsideStackRegion(Dst, Size) || + CurrentProcess.MemoryManager.InsideHeapRegion (Dst, Size) || + CurrentProcess.MemoryManager.InsideAliasRegion (Dst, Size)) { Logger.PrintWarning(LogClass.KernelSvc, $"Dst address 0x{Dst:x16} out of range!"); @@ -214,19 +222,19 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcQueryMemory(CpuThreadState ThreadState) { - long InfoPtr = (long)ThreadState.X0; - long Position = (long)ThreadState.X2; + long InfoPtr = (long)ThreadState.X0; + ulong Position = ThreadState.X2; KMemoryInfo BlkInfo = Process.MemoryManager.QueryMemory(Position); - Memory.WriteInt64(InfoPtr + 0x00, BlkInfo.Address); - Memory.WriteInt64(InfoPtr + 0x08, BlkInfo.Size); - Memory.WriteInt32(InfoPtr + 0x10, (int)BlkInfo.State & 0xff); - Memory.WriteInt32(InfoPtr + 0x14, (int)BlkInfo.Attribute); - Memory.WriteInt32(InfoPtr + 0x18, (int)BlkInfo.Permission); - Memory.WriteInt32(InfoPtr + 0x1c, BlkInfo.IpcRefCount); - Memory.WriteInt32(InfoPtr + 0x20, BlkInfo.DeviceRefCount); - Memory.WriteInt32(InfoPtr + 0x24, 0); + Memory.WriteUInt64(InfoPtr + 0x00, BlkInfo.Address); + Memory.WriteUInt64(InfoPtr + 0x08, BlkInfo.Size); + Memory.WriteInt32 (InfoPtr + 0x10, (int)BlkInfo.State & 0xff); + Memory.WriteInt32 (InfoPtr + 0x14, (int)BlkInfo.Attribute); + Memory.WriteInt32 (InfoPtr + 0x18, (int)BlkInfo.Permission); + Memory.WriteInt32 (InfoPtr + 0x1c, BlkInfo.IpcRefCount); + Memory.WriteInt32 (InfoPtr + 0x20, BlkInfo.DeviceRefCount); + Memory.WriteInt32 (InfoPtr + 0x24, 0); ThreadState.X0 = 0; ThreadState.X1 = 0; @@ -234,9 +242,9 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcMapSharedMemory(CpuThreadState ThreadState) { - int Handle = (int)ThreadState.X0; - long Address = (long)ThreadState.X1; - long Size = (long)ThreadState.X2; + int Handle = (int)ThreadState.X0; + ulong Address = ThreadState.X1; + ulong Size = ThreadState.X2; if (!PageAligned(Address)) { @@ -289,7 +297,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if (!InsideAddrSpace(Address, Size) || InsideMapRegion(Address, Size) || InsideHeapRegion(Address, Size)) + if (CurrentProcess.MemoryManager.IsInvalidRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideHeapRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideAliasRegion(Address, Size)) { Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} out of range!"); @@ -315,13 +325,13 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcUnmapSharedMemory(CpuThreadState ThreadState) { - int Handle = (int)ThreadState.X0; - long Position = (long)ThreadState.X1; - long Size = (long)ThreadState.X2; + int Handle = (int)ThreadState.X0; + ulong Address = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(Position)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); @@ -337,9 +347,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if ((ulong)(Position + Size) <= (ulong)Position) + if ((ulong)(Address + Size) <= (ulong)Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); @@ -359,9 +369,11 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if (!InsideAddrSpace(Position, Size) || InsideMapRegion(Position, Size) || InsideHeapRegion(Position, Size)) + if (CurrentProcess.MemoryManager.IsInvalidRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideHeapRegion (Address, Size) || + CurrentProcess.MemoryManager.InsideAliasRegion(Address, Size)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} out of range!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} out of range!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); @@ -370,7 +382,7 @@ namespace Ryujinx.HLE.HOS.Kernel KernelResult Result = SharedMemory.UnmapFromProcess( CurrentProcess.MemoryManager, - Position, + Address, Size, CurrentProcess); @@ -384,12 +396,12 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcCreateTransferMemory(CpuThreadState ThreadState) { - long Position = (long)ThreadState.X1; - long Size = (long)ThreadState.X2; + ulong Address = ThreadState.X1; + ulong Size = ThreadState.X2; - if (!PageAligned(Position)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); @@ -405,9 +417,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if ((ulong)(Position + Size) <= (ulong)Position) + if ((ulong)(Address + Size) <= (ulong)Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); @@ -425,9 +437,9 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - Process.MemoryManager.ReserveTransferMemory(Position, Size, Permission); + Process.MemoryManager.ReserveTransferMemory(Address, Size, Permission); - KTransferMemory TransferMemory = new KTransferMemory(Position, Size); + KTransferMemory TransferMemory = new KTransferMemory(Address, Size); KernelResult Result = Process.HandleTable.GenerateHandle(TransferMemory, out int Handle); @@ -437,12 +449,12 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcMapPhysicalMemory(CpuThreadState ThreadState) { - long Position = (long)ThreadState.X0; - long Size = (long)ThreadState.X1; + ulong Address = ThreadState.X0; + ulong Size = ThreadState.X1; - if (!PageAligned(Position)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); @@ -458,25 +470,37 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if ((ulong)(Position + Size) <= (ulong)Position) + if (Address + Size <= Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (!InsideAddrSpace(Position, Size)) + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); + + if ((CurrentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Position:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"System resource size is zero."); + + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); + + return; + } + + if (!CurrentProcess.MemoryManager.InsideAddrSpace (Address, Size) || + CurrentProcess.MemoryManager.OutsideAliasRegion(Address, Size)) + { + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Address:x16}."); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KernelResult Result = Process.MemoryManager.MapPhysicalMemory(Position, Size); + KernelResult Result = Process.MemoryManager.MapPhysicalMemory(Address, Size); if (Result != KernelResult.Success) { @@ -488,12 +512,12 @@ namespace Ryujinx.HLE.HOS.Kernel private void SvcUnmapPhysicalMemory(CpuThreadState ThreadState) { - long Position = (long)ThreadState.X0; - long Size = (long)ThreadState.X1; + ulong Address = ThreadState.X0; + ulong Size = ThreadState.X1; - if (!PageAligned(Position)) + if (!PageAligned(Address)) { - Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Position:x16} is not page aligned!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Address 0x{Address:x16} is not page aligned!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidAddress); @@ -509,25 +533,37 @@ namespace Ryujinx.HLE.HOS.Kernel return; } - if ((ulong)(Position + Size) <= (ulong)Position) + if ((ulong)(Address + Size) <= (ulong)Address) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Position:x16} / size 0x{Size:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid region address 0x{Address:x16} / size 0x{Size:x16}!"); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - if (!InsideAddrSpace(Position, Size)) + KProcess CurrentProcess = System.Scheduler.GetCurrentProcess(); + + if ((CurrentProcess.PersonalMmHeapPagesCount & 0xfffffffffffff) == 0) { - Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Position:x16}!"); + Logger.PrintWarning(LogClass.KernelSvc, $"System resource size is zero."); + + ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.InvalidState); + + return; + } + + if (!CurrentProcess.MemoryManager.InsideAddrSpace (Address, Size) || + CurrentProcess.MemoryManager.OutsideAliasRegion(Address, Size)) + { + Logger.PrintWarning(LogClass.KernelSvc, $"Invalid address {Address:x16}."); ThreadState.X0 = MakeError(ErrorModule.Kernel, KernelErr.NoAccessPerm); return; } - KernelResult Result = Process.MemoryManager.UnmapPhysicalMemory(Position, Size); + KernelResult Result = Process.MemoryManager.UnmapPhysicalMemory(Address, Size); if (Result != KernelResult.Success) { @@ -537,45 +573,9 @@ namespace Ryujinx.HLE.HOS.Kernel ThreadState.X0 = (ulong)Result; } - private static bool PageAligned(long Position) + private static bool PageAligned(ulong Position) { return (Position & (KMemoryManager.PageSize - 1)) == 0; } - - private bool InsideAddrSpace(long Position, long Size) - { - ulong Start = (ulong)Position; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)Process.MemoryManager.AddrSpaceStart && - End < (ulong)Process.MemoryManager.AddrSpaceEnd; - } - - private bool InsideMapRegion(long Position, long Size) - { - ulong Start = (ulong)Position; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)Process.MemoryManager.AliasRegionStart && - End < (ulong)Process.MemoryManager.AliasRegionEnd; - } - - private bool InsideHeapRegion(long Position, long Size) - { - ulong Start = (ulong)Position; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)Process.MemoryManager.HeapRegionStart && - End < (ulong)Process.MemoryManager.HeapRegionEnd; - } - - private bool InsideNewMapRegion(long Position, long Size) - { - ulong Start = (ulong)Position; - ulong End = (ulong)Size + Start; - - return Start >= (ulong)Process.MemoryManager.StackRegionStart && - End < (ulong)Process.MemoryManager.StackRegionEnd; - } } } \ No newline at end of file diff --git a/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs b/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs index e79fe0f55b..d6bf5b03a0 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcSystem.cs @@ -107,7 +107,7 @@ namespace Ryujinx.HLE.HOS.Kernel else if (Obj is KTransferMemory TransferMemory) { Process.MemoryManager.ResetTransferMemory( - TransferMemory.Position, + TransferMemory.Address, TransferMemory.Size); } @@ -339,27 +339,27 @@ namespace Ryujinx.HLE.HOS.Kernel case 0: Value = Process.Capabilities.AllowedCpuCoresMask; break; case 1: Value = Process.Capabilities.AllowedThreadPriosMask; break; - case 2: Value = Process.MemoryManager.AliasRegionStart; break; - case 3: Value = Process.MemoryManager.AliasRegionEnd - - Process.MemoryManager.AliasRegionStart; break; + case 2: Value = (long)Process.MemoryManager.AliasRegionStart; break; + case 3: Value = (long)(Process.MemoryManager.AliasRegionEnd - + Process.MemoryManager.AliasRegionStart); break; - case 4: Value = Process.MemoryManager.HeapRegionStart; break; - case 5: Value = Process.MemoryManager.HeapRegionEnd - - Process.MemoryManager.HeapRegionStart; break; + case 4: Value = (long)Process.MemoryManager.HeapRegionStart; break; + case 5: Value = (long)(Process.MemoryManager.HeapRegionEnd - + Process.MemoryManager.HeapRegionStart); break; - case 6: Value = Process.GetMemoryCapacity(); break; + case 6: Value = (long)Process.GetMemoryCapacity(); break; - case 7: Value = Process.GetMemoryUsage(); break; + case 7: Value = (long)Process.GetMemoryUsage(); break; - case 12: Value = Process.MemoryManager.GetAddrSpaceBaseAddr(); break; + case 12: Value = (long)Process.MemoryManager.GetAddrSpaceBaseAddr(); break; - case 13: Value = Process.MemoryManager.GetAddrSpaceSize(); break; + case 13: Value = (long)Process.MemoryManager.GetAddrSpaceSize(); break; - case 14: Value = Process.MemoryManager.StackRegionStart; break; - case 15: Value = Process.MemoryManager.StackRegionEnd - - Process.MemoryManager.StackRegionStart; break; + case 14: Value = (long)Process.MemoryManager.StackRegionStart; break; + case 15: Value = (long)(Process.MemoryManager.StackRegionEnd - + Process.MemoryManager.StackRegionStart); break; - case 16: Value = Process.PersonalMmHeapPagesCount * KMemoryManager.PageSize; break; + case 16: Value = (long)Process.PersonalMmHeapPagesCount * KMemoryManager.PageSize; break; case 17: if (Process.PersonalMmHeapPagesCount != 0) @@ -371,11 +371,11 @@ namespace Ryujinx.HLE.HOS.Kernel case 18: Value = Process.TitleId; break; - case 20: Value = Process.UserExceptionContextAddress; break; + case 20: Value = (long)Process.UserExceptionContextAddress; break; - case 21: Value = Process.GetMemoryCapacityWithoutPersonalMmHeap(); break; + case 21: Value = (long)Process.GetMemoryCapacityWithoutPersonalMmHeap(); break; - case 22: Value = Process.GetMemoryUsageWithoutPersonalMmHeap(); break; + case 22: Value = (long)Process.GetMemoryUsageWithoutPersonalMmHeap(); break; } break; diff --git a/Ryujinx.HLE/HOS/Kernel/SvcThread.cs b/Ryujinx.HLE/HOS/Kernel/SvcThread.cs index ac0cf86a7a..ded8f8dc9e 100644 --- a/Ryujinx.HLE/HOS/Kernel/SvcThread.cs +++ b/Ryujinx.HLE/HOS/Kernel/SvcThread.cs @@ -9,11 +9,11 @@ namespace Ryujinx.HLE.HOS.Kernel { private void CreateThread64(CpuThreadState ThreadState) { - long Entrypoint = (long)ThreadState.X1; - long ArgsPtr = (long)ThreadState.X2; - long StackTop = (long)ThreadState.X3; - int Priority = (int)ThreadState.X4; - int CpuCore = (int)ThreadState.X5; + ulong Entrypoint = ThreadState.X1; + ulong ArgsPtr = ThreadState.X2; + ulong StackTop = ThreadState.X3; + int Priority = (int)ThreadState.X4; + int CpuCore = (int)ThreadState.X5; KernelResult Result = CreateThread(Entrypoint, ArgsPtr, StackTop, Priority, CpuCore, out int Handle); @@ -22,9 +22,9 @@ namespace Ryujinx.HLE.HOS.Kernel } private KernelResult CreateThread( - long Entrypoint, - long ArgsPtr, - long StackTop, + ulong Entrypoint, + ulong ArgsPtr, + ulong StackTop, int Priority, int CpuCore, out int Handle) diff --git a/Ryujinx.HLE/HOS/ProgramLoader.cs b/Ryujinx.HLE/HOS/ProgramLoader.cs index 15e50438c8..735255c87d 100644 --- a/Ryujinx.HLE/HOS/ProgramLoader.cs +++ b/Ryujinx.HLE/HOS/ProgramLoader.cs @@ -19,12 +19,12 @@ namespace Ryujinx.HLE.HOS IExecutable[] StaticObjects, byte[] Arguments = null) { - long ArgsStart = 0; - int ArgsSize = 0; - long CodeStart = 0x8000000; - int CodeSize = 0; + ulong ArgsStart = 0; + int ArgsSize = 0; + ulong CodeStart = 0x8000000; + int CodeSize = 0; - long[] NsoBase = new long[StaticObjects.Length]; + ulong[] NsoBase = new ulong[StaticObjects.Length]; for (int Index = 0; Index < StaticObjects.Length; Index++) { @@ -48,13 +48,13 @@ namespace Ryujinx.HLE.HOS NsoSize = BitUtils.AlignUp(NsoSize, KMemoryManager.PageSize); - NsoBase[Index] = CodeStart + CodeSize; + NsoBase[Index] = CodeStart + (ulong)CodeSize; CodeSize += NsoSize; if (Arguments != null && ArgsSize == 0) { - ArgsStart = CodeSize; + ArgsStart = (ulong)CodeSize; ArgsSize = BitUtils.AlignDown(Arguments.Length * 2 + ArgsTotalSize - 1, KMemoryManager.PageSize); @@ -82,7 +82,7 @@ namespace Ryujinx.HLE.HOS KResourceLimit ResourceLimit = new KResourceLimit(System); - long ApplicationRgSize = System.MemoryRegions[(int)MemoryRegion.Application].Size; + long ApplicationRgSize = (long)System.MemoryRegions[(int)MemoryRegion.Application].Size; Result = ResourceLimit.SetLimitValue(LimitableResource.Memory, ApplicationRgSize); Result |= ResourceLimit.SetLimitValue(LimitableResource.Thread, 608); @@ -114,26 +114,26 @@ namespace Ryujinx.HLE.HOS { IExecutable StaticObject = StaticObjects[Index]; - long TextStart = NsoBase[Index] + StaticObject.TextOffset; - long ROStart = NsoBase[Index] + StaticObject.ROOffset; - long DataStart = NsoBase[Index] + StaticObject.DataOffset; + ulong TextStart = NsoBase[Index] + (ulong)StaticObject.TextOffset; + ulong ROStart = NsoBase[Index] + (ulong)StaticObject.ROOffset; + ulong DataStart = NsoBase[Index] + (ulong)StaticObject.DataOffset; - long BssStart = DataStart + StaticObject.Data.Length; + ulong BssStart = DataStart + (ulong)StaticObject.Data.Length; - long BssEnd = BitUtils.AlignUp(BssStart + StaticObject.BssSize, KMemoryManager.PageSize); + ulong BssEnd = BitUtils.AlignUp(BssStart + (ulong)StaticObject.BssSize, KMemoryManager.PageSize); - Process.CpuMemory.WriteBytes(TextStart, StaticObject.Text); - Process.CpuMemory.WriteBytes(ROStart, StaticObject.RO); - Process.CpuMemory.WriteBytes(DataStart, StaticObject.Data); + Process.CpuMemory.WriteBytes((long)TextStart, StaticObject.Text); + Process.CpuMemory.WriteBytes((long)ROStart, StaticObject.RO); + Process.CpuMemory.WriteBytes((long)DataStart, StaticObject.Data); - MemoryHelper.FillWithZeros(Process.CpuMemory, BssStart, (int)(BssEnd - BssStart)); + MemoryHelper.FillWithZeros(Process.CpuMemory, (long)BssStart, (int)(BssEnd - BssStart)); Process.MemoryManager.SetProcessMemoryPermission(TextStart, ROStart - TextStart, MemoryPermission.ReadAndExecute); Process.MemoryManager.SetProcessMemoryPermission(ROStart, DataStart - ROStart, MemoryPermission.Read); Process.MemoryManager.SetProcessMemoryPermission(DataStart, BssEnd - DataStart, MemoryPermission.ReadAndWrite); } - Result = Process.Start(MetaData.MainThreadPriority, MetaData.MainThreadStackSize); + Result = Process.Start(MetaData.MainThreadPriority, (ulong)MetaData.MainThreadStackSize); if (Result != KernelResult.Success) { diff --git a/Ryujinx.HLE/HOS/Services/Ldr/IRoInterface.cs b/Ryujinx.HLE/HOS/Services/Ldr/IRoInterface.cs index 442f01bfd7..df16fe2a34 100644 --- a/Ryujinx.HLE/HOS/Services/Ldr/IRoInterface.cs +++ b/Ryujinx.HLE/HOS/Services/Ldr/IRoInterface.cs @@ -65,15 +65,15 @@ namespace Ryujinx.HLE.HOS.Services.Ldr { public NxRelocatableObject Executable { get; private set; } public byte[] Hash { get; private set; } - public long NroAddress { get; private set; } - public long TotalSize { get; private set; } - public long NroMappedAddress { get; set; } + public ulong NroAddress { get; private set; } + public ulong TotalSize { get; private set; } + public ulong NroMappedAddress { get; set; } - public NroInfo(NxRelocatableObject Executable, byte[] Hash, long TotalSize) + public NroInfo(NxRelocatableObject Executable, byte[] Hash, ulong TotalSize) { this.Executable = Executable; this.Hash = Hash; - this.TotalSize = TotalSize; + this.TotalSize = TotalSize; } } @@ -175,7 +175,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldr return false; } - public long ParseNro(out NroInfo Res, ServiceCtx Context, long NroHeapAddress, long NroSize, long BssHeapAddress, long BssSize) + public long ParseNro(out NroInfo Res, ServiceCtx Context, ulong NroHeapAddress, ulong NroSize, ulong BssHeapAddress, ulong BssSize) { Res = null; @@ -196,15 +196,15 @@ namespace Ryujinx.HLE.HOS.Services.Ldr return MakeError(ErrorModule.Loader, LoaderErr.UnalignedAddress); } - uint Magic = Context.Memory.ReadUInt32(NroHeapAddress + 0x10); - uint NroFileSize = Context.Memory.ReadUInt32(NroHeapAddress + 0x18); + uint Magic = Context.Memory.ReadUInt32((long)NroHeapAddress + 0x10); + uint NroFileSize = Context.Memory.ReadUInt32((long)NroHeapAddress + 0x18); if (Magic != NroMagic || NroSize != NroFileSize) { return MakeError(ErrorModule.Loader, LoaderErr.InvalidNro); } - byte[] NroData = Context.Memory.ReadBytes(NroHeapAddress, NroSize); + byte[] NroData = Context.Memory.ReadBytes((long)NroHeapAddress, (long)NroSize); byte[] NroHash = null; MemoryStream Stream = new MemoryStream(NroData); @@ -244,26 +244,29 @@ namespace Ryujinx.HLE.HOS.Services.Ldr } // finally check the bss size match. - if (Executable.BssSize != BssSize) + if ((ulong)Executable.BssSize != BssSize) { return MakeError(ErrorModule.Loader, LoaderErr.InvalidNro); } - Res = new NroInfo(Executable, NroHash, Executable.Text.Length + Executable.RO.Length + Executable.Data.Length + Executable.BssSize); + int TotalSize = Executable.Text.Length + Executable.RO.Length + Executable.Data.Length + Executable.BssSize; + + Res = new NroInfo(Executable, NroHash, (ulong)TotalSize); return 0; } - private long MapNro(ServiceCtx Context, NroInfo Info, out long NroMappedAddress) + private long MapNro(ServiceCtx Context, NroInfo Info, out ulong NroMappedAddress) { NroMappedAddress = 0; - long TargetAddress = Context.Process.MemoryManager.AddrSpaceStart; - long HeapRegionStart = Context.Process.MemoryManager.HeapRegionStart; - long HeapRegionEnd = Context.Process.MemoryManager.HeapRegionEnd; + ulong TargetAddress = Context.Process.MemoryManager.AddrSpaceStart; - long MapRegionStart = Context.Process.MemoryManager.AliasRegionStart; - long MapRegionEnd = Context.Process.MemoryManager.AliasRegionEnd; + ulong HeapRegionStart = Context.Process.MemoryManager.HeapRegionStart; + ulong HeapRegionEnd = Context.Process.MemoryManager.HeapRegionEnd; + + ulong MapRegionStart = Context.Process.MemoryManager.AliasRegionStart; + ulong MapRegionEnd = Context.Process.MemoryManager.AliasRegionEnd; while (true) { @@ -309,7 +312,7 @@ namespace Ryujinx.HLE.HOS.Services.Ldr return MakeError(ErrorModule.Loader, LoaderErr.BadNrrAddress); } - private long RemoveNroInfo(ServiceCtx Context, long NroMappedAddress, long NroHeapAddress) + private long RemoveNroInfo(ServiceCtx Context, ulong NroMappedAddress, ulong NroHeapAddress) { foreach (NroInfo Info in NroInfos) { @@ -319,11 +322,17 @@ namespace Ryujinx.HLE.HOS.Services.Ldr //Context.Process.RemoveProgram(Info.NroMappedAddress); - KernelResult Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(Info.NroMappedAddress, Info.Executable.SourceAddress, Info.TotalSize - Info.Executable.BssSize); + KernelResult Result = Context.Process.MemoryManager.UnmapProcessCodeMemory( + Info.NroMappedAddress, + Info.Executable.SourceAddress, + Info.TotalSize - (ulong)Info.Executable.BssSize); if (Result == KernelResult.Success && Info.Executable.BssSize != 0) { - Result = Context.Process.MemoryManager.UnmapProcessCodeMemory(Info.NroMappedAddress + Info.TotalSize - Info.Executable.BssSize, Info.Executable.BssAddress, Info.Executable.BssSize); + Result = Context.Process.MemoryManager.UnmapProcessCodeMemory( + Info.NroMappedAddress + Info.TotalSize - (ulong)Info.Executable.BssSize, + Info.Executable.BssAddress, + (ulong)Info.Executable.BssSize); } return (long)Result; @@ -341,12 +350,12 @@ namespace Ryujinx.HLE.HOS.Services.Ldr // Zero Context.RequestData.ReadUInt64(); - long NroHeapAddress = Context.RequestData.ReadInt64(); - long NroSize = Context.RequestData.ReadInt64(); - long BssHeapAddress = Context.RequestData.ReadInt64(); - long BssSize = Context.RequestData.ReadInt64(); + ulong NroHeapAddress = Context.RequestData.ReadUInt64(); + ulong NroSize = Context.RequestData.ReadUInt64(); + ulong BssHeapAddress = Context.RequestData.ReadUInt64(); + ulong BssSize = Context.RequestData.ReadUInt64(); - long NroMappedAddress = 0; + ulong NroMappedAddress = 0; if (IsInitialized) { @@ -375,8 +384,8 @@ namespace Ryujinx.HLE.HOS.Services.Ldr { long Result = MakeError(ErrorModule.Loader, LoaderErr.BadInitialization); - long NroMappedAddress = Context.RequestData.ReadInt64(); - long NroHeapAddress = Context.RequestData.ReadInt64(); + ulong NroMappedAddress = Context.RequestData.ReadUInt64(); + ulong NroHeapAddress = Context.RequestData.ReadUInt64(); if (IsInitialized) { diff --git a/Ryujinx.HLE/Loaders/Executables/NxRelocatableObject.cs b/Ryujinx.HLE/Loaders/Executables/NxRelocatableObject.cs index 8feb7e6684..a8e5f93b20 100644 --- a/Ryujinx.HLE/Loaders/Executables/NxRelocatableObject.cs +++ b/Ryujinx.HLE/Loaders/Executables/NxRelocatableObject.cs @@ -14,10 +14,10 @@ namespace Ryujinx.HLE.Loaders.Executables public int DataOffset { get; private set; } public int BssSize { get; private set; } - public long SourceAddress { get; private set; } - public long BssAddress { get; private set; } + public ulong SourceAddress { get; private set; } + public ulong BssAddress { get; private set; } - public NxRelocatableObject(Stream Input, long SourceAddress = 0, long BssAddress = 0) + public NxRelocatableObject(Stream Input, ulong SourceAddress = 0, ulong BssAddress = 0) { this.SourceAddress = SourceAddress; this.BssAddress = BssAddress;