示例#1
0
        private void SvcQueryMemory(AThreadState ThreadState)
        {
            long InfoPtr  = (long)ThreadState.X0;
            long Position = (long)ThreadState.X2;

            KMemoryInfo BlkInfo = Process.MemoryManager.QueryMemory(Position);

            Memory.WriteInt64(InfoPtr + 0x00, BlkInfo.Position);
            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);

            ThreadState.X0 = 0;
            ThreadState.X1 = 0;
        }
示例#2
0
        private void ScanMemoryForTextSegments()
        {
            ulong oldAddress = 0;
            ulong address    = 0;

            while (address >= oldAddress)
            {
                KMemoryInfo info = _owner.MemoryManager.QueryMemory(address);

                if (info.State == MemoryState.Reserved)
                {
                    break;
                }

                if (info.State == MemoryState.CodeStatic && info.Permission == KMemoryPermission.ReadAndExecute)
                {
                    LoadMod0Symbols(_owner.CpuMemory, info.Address);
                }

                oldAddress = address;

                address = info.Address + info.Size;
            }
        }
示例#3
0
        private long MapNro(ServiceCtx context, NroInfo info, out ulong nroMappedAddress)
        {
            nroMappedAddress = 0;

            KMemoryManager memMgr = context.Process.MemoryManager;

            ulong targetAddress = memMgr.GetAddrSpaceBaseAddr();

            while (true)
            {
                if (targetAddress + info.TotalSize >= memMgr.AddrSpaceEnd)
                {
                    return(MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState));
                }

                KMemoryInfo memInfo = memMgr.QueryMemory(targetAddress);

                if (memInfo.State == MemoryState.Unmapped && memInfo.Size >= info.TotalSize)
                {
                    if (!memMgr.InsideHeapRegion(targetAddress, info.TotalSize) &&
                        !memMgr.InsideAliasRegion(targetAddress, info.TotalSize))
                    {
                        break;
                    }
                }

                targetAddress += memInfo.Size;
            }

            KernelResult result = memMgr.MapProcessCodeMemory(targetAddress, info.NroAddress, info.NroSize);

            if (result != KernelResult.Success)
            {
                return(MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState));
            }

            ulong bssTargetAddress = targetAddress + info.NroSize;

            if (info.BssSize != 0)
            {
                result = memMgr.MapProcessCodeMemory(bssTargetAddress, info.BssAddress, info.BssSize);

                if (result != KernelResult.Success)
                {
                    memMgr.UnmapProcessCodeMemory(targetAddress, info.NroAddress, info.NroSize);

                    return(MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState));
                }
            }

            result = LoadNroIntoMemory(context.Process, info.Executable, targetAddress);

            if (result != KernelResult.Success)
            {
                memMgr.UnmapProcessCodeMemory(targetAddress, info.NroAddress, info.NroSize);

                if (info.BssSize != 0)
                {
                    memMgr.UnmapProcessCodeMemory(bssTargetAddress, info.BssAddress, info.BssSize);
                }

                return(0);
            }

            info.NroMappedAddress = targetAddress;
            nroMappedAddress      = targetAddress;

            return(0);
        }
示例#4
0
        private long MapNro(ServiceCtx Context, NroInfo Info, out ulong NroMappedAddress)
        {
            NroMappedAddress = 0;

            KMemoryManager MemMgr = Context.Process.MemoryManager;

            ulong TargetAddress = MemMgr.GetAddrSpaceBaseAddr();

            while (true)
            {
                if (TargetAddress + Info.TotalSize >= MemMgr.AddrSpaceEnd)
                {
                    return(MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState));
                }

                KMemoryInfo MemInfo = MemMgr.QueryMemory(TargetAddress);

                if (MemInfo.State == MemoryState.Unmapped && MemInfo.Size >= Info.TotalSize)
                {
                    if (!MemMgr.InsideHeapRegion(TargetAddress, Info.TotalSize) &&
                        !MemMgr.InsideAliasRegion(TargetAddress, Info.TotalSize))
                    {
                        break;
                    }
                }

                TargetAddress += MemInfo.Size;
            }

            KernelResult Result = MemMgr.MapProcessCodeMemory(TargetAddress, Info.NroAddress, Info.NroSize);

            if (Result != KernelResult.Success)
            {
                return(MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState));
            }

            ulong BssTargetAddress = TargetAddress + Info.NroSize;

            if (Info.BssSize != 0)
            {
                Result = MemMgr.MapProcessCodeMemory(BssTargetAddress, Info.BssAddress, Info.BssSize);

                if (Result != KernelResult.Success)
                {
                    MemMgr.UnmapProcessCodeMemory(TargetAddress, Info.NroAddress, Info.NroSize);

                    return(MakeError(ErrorModule.Loader, LoaderErr.InvalidMemoryState));
                }
            }

            Result = LoadNroIntoMemory(Context.Process, Info.Executable, TargetAddress);

            if (Result != KernelResult.Success)
            {
                MemMgr.UnmapProcessCodeMemory(TargetAddress, Info.NroAddress, Info.NroSize);

                if (Info.BssSize != 0)
                {
                    MemMgr.UnmapProcessCodeMemory(BssTargetAddress, Info.BssAddress, Info.BssSize);
                }

                return(0);
            }

            Info.NroMappedAddress = TargetAddress;
            NroMappedAddress      = TargetAddress;

            return(0);
        }