internal NeuralTuringMachine(NeuralTuringMachine oldMachine) { _controller = oldMachine._controller.Clone(); _memory = oldMachine._memory; _newMemoryState = oldMachine._newMemoryState; _oldMemoryState = oldMachine._oldMemoryState; }
public KBufferDescriptor(ulong src, ulong dst, ulong size, MemoryState state) { ClientAddress = src; ServerAddress = dst; Size = size; State = state; }
public void SetState(KMemoryPermission permission, MemoryState state, MemoryAttribute attribute) { Permission = permission; State = state; Attribute &= MemoryAttribute.IpcAndDeviceMapped; Attribute |= attribute; }
public KernelResult UnmapFromProcess( KPageTableBase memoryManager, ulong address, ulong size, KProcess process) { if (_storage == null) { throw new NotImplementedException(); } ulong pagesCountRounded = BitUtils.DivRoundUp(size, KPageTableBase.PageSize); var pageList = _storage.GetPageList(); ulong pagesCount = pageList.GetPagesCount(); if (pagesCount != pagesCountRounded) { return(KernelResult.InvalidSize); } var ranges = _storage.GetRanges(); MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory; KernelResult result = memoryManager.UnmapPages(address, pagesCount, ranges, state); if (result == KernelResult.Success) { _isMapped = false; } return(result); }
public KernelResult MapIntoProcess( KPageTableBase memoryManager, ulong address, ulong size, KProcess process, KMemoryPermission permission) { if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize)) { return(KernelResult.InvalidSize); } if (permission != Permission || _isMapped) { return(KernelResult.InvalidState); } MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory; KernelResult result = memoryManager.MapPages(address, _pageList, state, KMemoryPermission.ReadAndWrite); if (result == KernelResult.Success) { _isMapped = true; } return(result); }
public void Process(double[] input) { _lastInput = input; _oldMemoryState = _newMemoryState; _controller.Process(input, _oldMemoryState.ReadData); _newMemoryState = _oldMemoryState.Process(GetHeads()); }
public NativeMemoryInfo(ulong baseAddress, ulong allocationBase, MemoryProtection allocationProtect, ulong regionSize, MemoryState state, MemoryProtection protect, MemoryType type) { BaseAddress = baseAddress; AllocationBase = allocationBase; AllocationProtect = allocationProtect; RegionSize = regionSize; State = state; Protect = protect; Type = type; }
public void InsertBlock( ulong baseAddress, ulong pagesCount, MemoryState state, KMemoryPermission permission = KMemoryPermission.None, MemoryAttribute attribute = MemoryAttribute.None) { // Inserts new block at the list, replacing and splitting // existing blocks as needed. int oldCount = _blocks.Count; ulong endAddr = baseAddress + pagesCount * PageSize; LinkedListNode <KMemoryBlock> node = _blocks.First; while (node != null) { LinkedListNode <KMemoryBlock> newNode = node; KMemoryBlock currBlock = node.Value; ulong currBaseAddr = currBlock.BaseAddress; ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr; if (baseAddress < currEndAddr && currBaseAddr < endAddr) { if (baseAddress > currBaseAddr) { _blocks.AddBefore(node, currBlock.SplitRightAtAddress(baseAddress)); } if (endAddr < currEndAddr) { newNode = _blocks.AddBefore(node, currBlock.SplitRightAtAddress(endAddr)); } newNode.Value.SetState(permission, state, attribute); newNode = MergeEqualStateNeighbors(newNode); } if (currEndAddr - 1 >= endAddr - 1) { break; } node = newNode.Next; } _slabManager.Count += _blocks.Count - oldCount; ValidateInternalState(); }
public void InsertBlock( ulong baseAddress, ulong pagesCount, MemoryState state, KMemoryPermission permission = KMemoryPermission.None, MemoryAttribute attribute = MemoryAttribute.None) { // Inserts new block at the list, replacing and splitting // existing blocks as needed. int oldCount = _blockTree.Count; ulong endAddr = baseAddress + pagesCount * PageSize; KMemoryBlock currBlock = FindBlock(baseAddress); while (currBlock != null) { ulong currBaseAddr = currBlock.BaseAddress; ulong currEndAddr = currBlock.PagesCount * PageSize + currBaseAddr; if (baseAddress < currEndAddr && currBaseAddr < endAddr) { if (baseAddress > currBaseAddr) { KMemoryBlock newBlock = currBlock.SplitRightAtAddress(baseAddress); _blockTree.Add(newBlock); } if (endAddr < currEndAddr) { KMemoryBlock newBlock = currBlock.SplitRightAtAddress(endAddr); _blockTree.Add(newBlock); currBlock = newBlock; } currBlock.SetState(permission, state, attribute); currBlock = MergeEqualStateNeighbors(currBlock); } if (currEndAddr - 1 >= endAddr - 1) { break; } currBlock = currBlock.Successor; } _slabManager.Count += _blockTree.Count - oldCount; ValidateInternalState(); }
public KMemoryBlock( ulong baseAddress, ulong pagesCount, MemoryState state, MemoryPermission permission, MemoryAttribute attribute) { BaseAddress = baseAddress; PagesCount = pagesCount; State = state; Attribute = attribute; Permission = permission; }
public KMemoryBlock( long BasePosition, long PagesCount, MemoryState State, MemoryPermission Permission, MemoryAttribute Attribute) { this.BasePosition = BasePosition; this.PagesCount = PagesCount; this.State = State; this.Attribute = Attribute; this.Permission = Permission; }
public KMemoryBlock( ulong BaseAddress, ulong PagesCount, MemoryState State, MemoryPermission Permission, MemoryAttribute Attribute) { this.BaseAddress = BaseAddress; this.PagesCount = PagesCount; this.State = State; this.Attribute = Attribute; this.Permission = Permission; }
public void HleMapCustom(long Position, long Size, MemoryState State, MemoryPermission Permission) { long PagesCount = Size / PageSize; if (!Allocator.TryAllocate(Size, out long PA)) { throw new InvalidOperationException(); } lock (Blocks) { InsertBlock(Position, PagesCount, State, Permission); CpuMemory.Map(Position, PA, Size); } }
public KMemoryInfo( long Position, long Size, MemoryState State, MemoryPermission Permission, MemoryAttribute Attribute, int IpcRefCount, int DeviceRefCount) { this.Position = Position; this.Size = Size; this.State = State; this.Attribute = Attribute; this.Permission = Permission; this.IpcRefCount = IpcRefCount; this.DeviceRefCount = DeviceRefCount; }
public KMemoryInfo( ulong address, ulong size, MemoryState state, MemoryPermission permission, MemoryAttribute attribute, int ipcRefCount, int deviceRefCount) { Address = address; Size = size; State = state; Attribute = attribute; Permission = permission; IpcRefCount = ipcRefCount; DeviceRefCount = deviceRefCount; }
public KMemoryInfo( ulong Address, ulong Size, MemoryState State, MemoryPermission Permission, MemoryAttribute Attribute, int IpcRefCount, int DeviceRefCount) { this.Address = Address; this.Size = Size; this.State = State; this.Attribute = Attribute; this.Permission = Permission; this.IpcRefCount = IpcRefCount; this.DeviceRefCount = DeviceRefCount; }
public KMemoryBlock( ulong baseAddress, ulong pagesCount, MemoryState state, KMemoryPermission permission, MemoryAttribute attribute, int ipcRefCount = 0, int deviceRefCount = 0) { BaseAddress = baseAddress; PagesCount = pagesCount; State = state; Attribute = attribute; Permission = permission; IpcRefCount = ipcRefCount; DeviceRefCount = deviceRefCount; }
private bool AnalyzePointerFromStack(out PointerInfo info, ulong address, KThread thread) { info = default; ulong sp = thread.Context.GetX(31); var memoryInfo = _owner.MemoryManager.QueryMemory(address); MemoryState memoryState = memoryInfo.State; if (!memoryState.HasFlag(MemoryState.Stack)) // Is this pointer within the stack? { return(false); } info.SubOffset = address - sp; return(true); }
/// <summary> /// Gets the bookmark for a particular cycle type. /// </summary> private BookmarkEntry GetBookmarkEntry(int book, MemoryState state) { // // Index into the "bookmark" table: // bits value // 7:4 bookmark (cycle type) // 3:2 current state // 1:0 current Tstate // int lookup = (((int)book & 0x0f) << 4) | ((int)state << 2) | Tstate; #if TRACING_ENABLED if (Trace.TraceOn) { Trace.Log(LogType.MemoryState, "{0} Bookmark[{1:x3}]: {2}", _name, lookup, _bkmTable[lookup]); } #endif return(_bkmTable[lookup]); }
public KernelResult MapIntoProcess( KPageTableBase memoryManager, ulong address, ulong size, KProcess process, KMemoryPermission permission) { if (_storage == null) { throw new NotImplementedException(); } ulong pagesCountRounded = BitUtils.DivRoundUp(size, KPageTableBase.PageSize); var pageList = _storage.GetPageList(); if (pageList.GetPagesCount() != pagesCountRounded) { return(KernelResult.InvalidSize); } if (permission != Permission || _isMapped) { return(KernelResult.InvalidState); } MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory; KernelResult result = memoryManager.MapPages(address, pageList, state, KMemoryPermission.ReadAndWrite); if (result == KernelResult.Success) { _isMapped = true; if (!memoryManager.SupportsMemoryAliasing) { _storage.Borrow(process, address); } } return(result); }
private string GetStateStr(MemoryState state) { switch (state) { case MemoryState.Commit: return("Commit"); case MemoryState.Free: return("Free"); case MemoryState.Reserve: return("Reserve"); case MemoryState.Reset: return("Reset"); default: return("Unknown"); } }
public KernelResult UnmapFromProcess( KPageTableBase memoryManager, ulong address, ulong size, KProcess process) { if (_pageList.GetPagesCount() != BitUtils.DivRoundUp(size, KPageTableBase.PageSize)) { return(KernelResult.InvalidSize); } MemoryState state = Permission == KMemoryPermission.None ? MemoryState.TransferMemoryIsolated : MemoryState.TransferMemory; KernelResult result = memoryManager.UnmapPages(address, _pageList, state); if (result == KernelResult.Success) { _isMapped = false; } return(result); }
private bool CheckRange( long Position, long Size, MemoryState StateMask, MemoryState StateExpected, MemoryPermission PermissionMask, MemoryPermission PermissionExpected, MemoryAttribute AttributeMask, MemoryAttribute AttributeExpected, MemoryAttribute AttributeIgnoreMask, out MemoryState OutState, out MemoryPermission OutPermission, out MemoryAttribute OutAttribute) { KMemoryInfo BlkInfo = FindBlock(Position).GetInfo(); ulong Start = (ulong)Position; ulong End = (ulong)Size + Start; if (End <= (ulong)(BlkInfo.Position + BlkInfo.Size)) { if ((BlkInfo.Attribute & AttributeMask) == AttributeExpected && (BlkInfo.State & StateMask) == StateExpected && (BlkInfo.Permission & PermissionMask) == PermissionExpected) { OutState = BlkInfo.State; OutPermission = BlkInfo.Permission; OutAttribute = BlkInfo.Attribute & ~AttributeIgnoreMask; return(true); } } OutState = MemoryState.Unmapped; OutPermission = MemoryPermission.None; OutAttribute = MemoryAttribute.None; return(false); }
private string GetStateStr(MemoryState state) { if (state == MemoryState.Commit) { return("Commit"); } else if (state == MemoryState.Free) { return("Free"); } else if (state == MemoryState.Reserve) { return("Reserve"); } else if (state == MemoryState.Reset) { return("Reset"); } else { return("Unknown"); } }
public KernelResult AddReceiveBuffer(ulong src, ulong dst, ulong size, MemoryState state) { return(Add(_receiveBufferDescriptors, src, dst, size, state)); }
private string GetStateStr(MemoryState state) { if (state == MemoryState.Commit) return "Commit"; else if (state == MemoryState.Free) return "Free"; else if (state == MemoryState.Reserve) return "Reserve"; else if (state == MemoryState.Reset) return "Reset"; else return "Unknown"; }
private string GetStateStr(MemoryState state) { switch (state) { case MemoryState.Commit: return "Commit"; case MemoryState.Free: return "Free"; case MemoryState.Reserve: return "Reserve"; case MemoryState.Reset: return "Reset"; default: return "Unknown"; } }
private void InsertBlock( long BasePosition, long PagesCount, MemoryState OldState, MemoryPermission OldPermission, MemoryAttribute OldAttribute, MemoryState NewState, MemoryPermission NewPermission, MemoryAttribute NewAttribute) { //Insert new block on the list only on areas where the state //of the block matches the state specified on the Old* state //arguments, otherwise leave it as is. OldAttribute |= MemoryAttribute.IpcAndDeviceMapped; ulong Start = (ulong)BasePosition; ulong End = (ulong)PagesCount * PageSize + Start; LinkedListNode <KMemoryBlock> Node = Blocks.First; while (Node != null) { LinkedListNode <KMemoryBlock> NewNode = Node; LinkedListNode <KMemoryBlock> NextNode = Node.Next; KMemoryBlock CurrBlock = Node.Value; ulong CurrStart = (ulong)CurrBlock.BasePosition; ulong CurrEnd = (ulong)CurrBlock.PagesCount * PageSize + CurrStart; if (Start < CurrEnd && CurrStart < End) { MemoryAttribute CurrBlockAttr = CurrBlock.Attribute | MemoryAttribute.IpcAndDeviceMapped; if (CurrBlock.State != OldState || CurrBlock.Permission != OldPermission || CurrBlockAttr != OldAttribute) { Node = NextNode; continue; } if (CurrStart >= Start && CurrEnd <= End) { CurrBlock.State = NewState; CurrBlock.Permission = NewPermission; CurrBlock.Attribute &= ~MemoryAttribute.IpcAndDeviceMapped; CurrBlock.Attribute |= NewAttribute; } else if (CurrStart >= Start) { CurrBlock.BasePosition = (long)End; CurrBlock.PagesCount = (long)((CurrEnd - End) / PageSize); long NewPagesCount = (long)((End - CurrStart) / PageSize); NewNode = Blocks.AddBefore(Node, new KMemoryBlock( (long)CurrStart, NewPagesCount, NewState, NewPermission, NewAttribute)); } else if (CurrEnd <= End) { CurrBlock.PagesCount = (long)((Start - CurrStart) / PageSize); long NewPagesCount = (long)((CurrEnd - Start) / PageSize); NewNode = Blocks.AddAfter(Node, new KMemoryBlock( BasePosition, NewPagesCount, NewState, NewPermission, NewAttribute)); } else { CurrBlock.PagesCount = (long)((Start - CurrStart) / PageSize); long NextPagesCount = (long)((CurrEnd - End) / PageSize); NewNode = Blocks.AddAfter(Node, new KMemoryBlock( BasePosition, PagesCount, NewState, NewPermission, NewAttribute)); Blocks.AddAfter(NewNode, new KMemoryBlock( (long)End, NextPagesCount, CurrBlock.State, CurrBlock.Permission, CurrBlock.Attribute)); NextNode = null; } MergeEqualStateNeighbours(NewNode); } Node = NextNode; } }
internal void InitializeMemoryState() { _newMemoryState = new MemoryState(_memory); _newMemoryState.DoInitialReading(); _oldMemoryState = null; }
public KernelResult AddExchangeBuffer(ulong src, ulong dst, ulong size, MemoryState state) { return Add(_exchangeBufferDescriptors, src, dst, size, state); }
private KernelResult Add(List<KBufferDescriptor> list, ulong src, ulong dst, ulong size, MemoryState state) { if (list.Count < MaxInternalBuffersCount) { list.Add(new KBufferDescriptor(src, dst, size, state)); return KernelResult.Success; } return KernelResult.OutOfMemory; }
public KernelResult Receive(ulong customCmdBuffAddr = 0, ulong customCmdBuffSize = 0) { KThread serverThread = KernelContext.Scheduler.GetCurrentThread(); KProcess serverProcess = serverThread.Owner; KernelContext.CriticalSection.Enter(); if (_parent.ClientSession.State != ChannelState.Open) { KernelContext.CriticalSection.Leave(); return(KernelResult.PortRemoteClosed); } if (_activeRequest != null || !DequeueRequest(out KSessionRequest request)) { KernelContext.CriticalSection.Leave(); return(KernelResult.NotFound); } if (request.ClientThread == null) { KernelContext.CriticalSection.Leave(); return(KernelResult.PortRemoteClosed); } KThread clientThread = request.ClientThread; KProcess clientProcess = clientThread.Owner; KernelContext.CriticalSection.Leave(); _activeRequest = request; request.ServerProcess = serverProcess; Message clientMsg = new Message(request); Message serverMsg = new Message(serverThread, customCmdBuffAddr, customCmdBuffSize); MessageHeader clientHeader = GetClientMessageHeader(clientMsg); MessageHeader serverHeader = GetServerMessageHeader(serverMsg); KernelResult serverResult = KernelResult.NotFound; KernelResult clientResult = KernelResult.Success; void CleanUpForError() { if (request.BufferDescriptorTable.UnmapServerBuffers(serverProcess.MemoryManager) == KernelResult.Success) { request.BufferDescriptorTable.RestoreClientBuffers(clientProcess.MemoryManager); } CloseAllHandles(serverMsg, clientHeader, serverProcess); KernelContext.CriticalSection.Enter(); _activeRequest = null; if (_requests.Count != 0) { Signal(); } KernelContext.CriticalSection.Leave(); WakeClientThread(request, clientResult); } if (clientHeader.ReceiveListType < 2 && clientHeader.ReceiveListOffset > clientMsg.Size) { CleanUpForError(); return(KernelResult.InvalidCombination); } else if (clientHeader.ReceiveListType == 2 && clientHeader.ReceiveListOffset + 8 > clientMsg.Size) { CleanUpForError(); return(KernelResult.InvalidCombination); } else if (clientHeader.ReceiveListType > 2 && clientHeader.ReceiveListType * 8 - 0x10 + clientHeader.ReceiveListOffset > clientMsg.Size) { CleanUpForError(); return(KernelResult.InvalidCombination); } if (clientHeader.ReceiveListOffsetInWords < clientHeader.MessageSizeInWords) { CleanUpForError(); return(KernelResult.InvalidCombination); } if (clientHeader.MessageSizeInWords * 4 > clientMsg.Size) { CleanUpForError(); return(KernelResult.CmdBufferTooSmall); } ulong[] receiveList = GetReceiveList( serverMsg, serverHeader.ReceiveListType, serverHeader.ReceiveListOffset); serverProcess.CpuMemory.Write(serverMsg.Address + 0, clientHeader.Word0); serverProcess.CpuMemory.Write(serverMsg.Address + 4, clientHeader.Word1); uint offset; // Copy handles. if (clientHeader.HasHandles) { if (clientHeader.MoveHandlesCount != 0) { CleanUpForError(); return(KernelResult.InvalidCombination); } serverProcess.CpuMemory.Write(serverMsg.Address + 8, clientHeader.Word2); offset = 3; if (clientHeader.HasPid) { serverProcess.CpuMemory.Write(serverMsg.Address + offset * 4, clientProcess.Pid); offset += 2; } for (int index = 0; index < clientHeader.CopyHandlesCount; index++) { int newHandle = 0; int handle = KernelContext.Memory.Read <int>(clientMsg.DramAddress + offset * 4); if (clientResult == KernelResult.Success && handle != 0) { clientResult = GetCopyObjectHandle(clientThread, serverProcess, handle, out newHandle); } serverProcess.CpuMemory.Write(serverMsg.Address + offset * 4, newHandle); offset++; } for (int index = 0; index < clientHeader.MoveHandlesCount; index++) { int newHandle = 0; int handle = KernelContext.Memory.Read <int>(clientMsg.DramAddress + offset * 4); if (handle != 0) { if (clientResult == KernelResult.Success) { clientResult = GetMoveObjectHandle(clientProcess, serverProcess, handle, out newHandle); } else { clientProcess.HandleTable.CloseHandle(handle); } } serverProcess.CpuMemory.Write(serverMsg.Address + offset * 4, newHandle); offset++; } if (clientResult != KernelResult.Success) { CleanUpForError(); return(serverResult); } } else { offset = 2; } // Copy pointer/receive list buffers. uint recvListDstOffset = 0; for (int index = 0; index < clientHeader.PointerBuffersCount; index++) { ulong pointerDesc = KernelContext.Memory.Read <ulong>(clientMsg.DramAddress + offset * 4); PointerBufferDesc descriptor = new PointerBufferDesc(pointerDesc); if (descriptor.BufferSize != 0) { clientResult = GetReceiveListAddress( descriptor, serverMsg, serverHeader.ReceiveListType, clientHeader.MessageSizeInWords, receiveList, ref recvListDstOffset, out ulong recvListBufferAddress); if (clientResult != KernelResult.Success) { CleanUpForError(); return(serverResult); } clientResult = clientProcess.MemoryManager.CopyDataToCurrentProcess( recvListBufferAddress, descriptor.BufferSize, descriptor.BufferAddress, MemoryState.IsPoolAllocated, MemoryState.IsPoolAllocated, MemoryPermission.Read, MemoryAttribute.Uncached, MemoryAttribute.None); if (clientResult != KernelResult.Success) { CleanUpForError(); return(serverResult); } descriptor.BufferAddress = recvListBufferAddress; } else { descriptor.BufferAddress = 0; } serverProcess.CpuMemory.Write(serverMsg.Address + offset * 4, descriptor.Pack()); offset += 2; } // Copy send, receive and exchange buffers. uint totalBuffersCount = clientHeader.SendBuffersCount + clientHeader.ReceiveBuffersCount + clientHeader.ExchangeBuffersCount; for (int index = 0; index < totalBuffersCount; index++) { ulong clientDescAddress = clientMsg.DramAddress + offset * 4; uint descWord0 = KernelContext.Memory.Read <uint>(clientDescAddress + 0); uint descWord1 = KernelContext.Memory.Read <uint>(clientDescAddress + 4); uint descWord2 = KernelContext.Memory.Read <uint>(clientDescAddress + 8); bool isSendDesc = index < clientHeader.SendBuffersCount; bool isExchangeDesc = index >= clientHeader.SendBuffersCount + clientHeader.ReceiveBuffersCount; bool notReceiveDesc = isSendDesc || isExchangeDesc; bool isReceiveDesc = !notReceiveDesc; MemoryPermission permission = index >= clientHeader.SendBuffersCount ? MemoryPermission.ReadAndWrite : MemoryPermission.Read; uint sizeHigh4 = (descWord2 >> 24) & 0xf; ulong bufferSize = descWord0 | (ulong)sizeHigh4 << 32; ulong dstAddress = 0; if (bufferSize != 0) { ulong bufferAddress; bufferAddress = descWord2 >> 28; bufferAddress |= ((descWord2 >> 2) & 7) << 4; bufferAddress = (bufferAddress << 32) | descWord1; MemoryState state = IpcMemoryStates[(descWord2 + 1) & 3]; clientResult = serverProcess.MemoryManager.MapBufferFromClientProcess( bufferSize, bufferAddress, clientProcess.MemoryManager, permission, state, notReceiveDesc, out dstAddress); if (clientResult != KernelResult.Success) { CleanUpForError(); return(serverResult); } if (isSendDesc) { clientResult = request.BufferDescriptorTable.AddSendBuffer(bufferAddress, dstAddress, bufferSize, state); } else if (isReceiveDesc) { clientResult = request.BufferDescriptorTable.AddReceiveBuffer(bufferAddress, dstAddress, bufferSize, state); } else /* if (isExchangeDesc) */ { clientResult = request.BufferDescriptorTable.AddExchangeBuffer(bufferAddress, dstAddress, bufferSize, state); } if (clientResult != KernelResult.Success) { CleanUpForError(); return(serverResult); } } descWord1 = (uint)dstAddress; descWord2 &= 3; descWord2 |= sizeHigh4 << 24; descWord2 |= (uint)(dstAddress >> 34) & 0x3ffffffc; descWord2 |= (uint)(dstAddress >> 4) & 0xf0000000; ulong serverDescAddress = serverMsg.Address + offset * 4; serverProcess.CpuMemory.Write(serverDescAddress + 0, descWord0); serverProcess.CpuMemory.Write(serverDescAddress + 4, descWord1); serverProcess.CpuMemory.Write(serverDescAddress + 8, descWord2); offset += 3; } // Copy raw data. if (clientHeader.RawDataSizeInWords != 0) { ulong copySrc = clientMsg.Address + offset * 4; ulong copyDst = serverMsg.Address + offset * 4; ulong copySize = clientHeader.RawDataSizeInWords * 4; if (serverMsg.IsCustom || clientMsg.IsCustom) { MemoryPermission permission = clientMsg.IsCustom ? MemoryPermission.None : MemoryPermission.Read; clientResult = clientProcess.MemoryManager.CopyDataToCurrentProcess( copyDst, copySize, copySrc, MemoryState.IsPoolAllocated, MemoryState.IsPoolAllocated, permission, MemoryAttribute.Uncached, MemoryAttribute.None); } else { copySrc = clientProcess.MemoryManager.GetDramAddressFromVa(copySrc); copyDst = serverProcess.MemoryManager.GetDramAddressFromVa(copyDst); KernelContext.Memory.Copy(copyDst, copySrc, copySize); } if (clientResult != KernelResult.Success) { CleanUpForError(); return(serverResult); } } return(KernelResult.Success); }