コード例 #1
0
        /// <inheritdoc/>
        protected override KernelResult Unmap(ulong address, ulong pagesCount)
        {
            KPageList pagesToClose = new KPageList();

            var regions = _cpuMemory.GetPhysicalRegions(address, pagesCount * PageSize);

            foreach (var region in regions)
            {
                ulong pa = GetDramAddressFromHostAddress(region.Address);
                if (pa == ulong.MaxValue)
                {
                    continue;
                }

                pa += DramMemoryMap.DramBase;
                if (DramMemoryMap.IsHeapPhysicalAddress(pa))
                {
                    pagesToClose.AddRange(pa, region.Size / PageSize);
                }
            }

            _cpuMemory.Unmap(address, pagesCount * PageSize);

            pagesToClose.DecrementPagesReferenceCount(Context.MemoryManager);

            return(KernelResult.Success);
        }
コード例 #2
0
        /// <inheritdoc/>
        public override KernelResult MapPages(ulong address, IEnumerable <HostMemoryRange> ranges, KMemoryPermission permission)
        {
            ulong currentVa = address;

            foreach (var range in ranges)
            {
                ulong size = range.Size;

                ulong pa = GetDramAddressFromHostAddress(range.Address);
                if (pa != ulong.MaxValue)
                {
                    pa += DramMemoryMap.DramBase;
                    if (DramMemoryMap.IsHeapPhysicalAddress(pa))
                    {
                        Context.MemoryManager.IncrementPagesReferenceCount(pa, size / PageSize);
                    }
                }

                _cpuMemory.Map(currentVa, range.Address, size);

                currentVa += size;
            }

            return(KernelResult.Success);
        }
コード例 #3
0
        /// <inheritdoc/>
        protected override KernelResult MapPages(ulong dstVa, ulong pagesCount, ulong srcPa, KMemoryPermission permission)
        {
            ulong size = pagesCount * PageSize;

            Context.Memory.Commit(srcPa - DramMemoryMap.DramBase, size);

            _cpuMemory.Map(dstVa, Context.Memory.GetPointer(srcPa - DramMemoryMap.DramBase, size), size);

            if (DramMemoryMap.IsHeapPhysicalAddress(srcPa))
            {
                Context.MemoryManager.IncrementPagesReferenceCount(srcPa, pagesCount);
            }

            return(KernelResult.Success);
        }
コード例 #4
0
        /// <inheritdoc/>
        protected override KernelResult MapPages(ulong dstVa, ulong pagesCount, ulong srcPa, KMemoryPermission permission, bool shouldFillPages, byte fillValue)
        {
            ulong size = pagesCount * PageSize;

            Context.Memory.Commit(srcPa - DramMemoryMap.DramBase, size);

            _cpuMemory.Map(dstVa, srcPa - DramMemoryMap.DramBase, size);

            if (DramMemoryMap.IsHeapPhysicalAddress(srcPa))
            {
                Context.MemoryManager.IncrementPagesReferenceCount(srcPa, pagesCount);
            }

            if (shouldFillPages)
            {
                _cpuMemory.Fill(dstVa, size, fillValue);
            }

            return(KernelResult.Success);
        }