ryujinx-final/Ryujinx.HLE/HOS/Kernel/Ipc/KBufferDescriptorTable.cs

using Ryujinx.Common;
using Ryujinx.HLE.HOS.Kernel.Common;
using Ryujinx.HLE.HOS.Kernel.Memory;
using System.Collections.Generic;

namespace Ryujinx.HLE.HOS.Kernel.Ipc
{
    class KBufferDescriptorTable
    {
        private const int MaxInternalBuffersCount = 8;

        private List<KBufferDescriptor> _sendBufferDescriptors;
        private List<KBufferDescriptor> _receiveBufferDescriptors;
        private List<KBufferDescriptor> _exchangeBufferDescriptors;

        public KBufferDescriptorTable()
        {
            _sendBufferDescriptors     = new List<KBufferDescriptor>(MaxInternalBuffersCount);
            _receiveBufferDescriptors  = new List<KBufferDescriptor>(MaxInternalBuffersCount);
            _exchangeBufferDescriptors = new List<KBufferDescriptor>(MaxInternalBuffersCount);
        }

        public KernelResult AddSendBuffer(ulong src, ulong dst, ulong size, MemoryState state)
        {
            return Add(_sendBufferDescriptors, src, dst, size, state);
        }

        public KernelResult AddReceiveBuffer(ulong src, ulong dst, ulong size, MemoryState state)
        {
            return Add(_receiveBufferDescriptors, src, dst, size, state);
        }

        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 CopyBuffersToClient(KPageTableBase memoryManager)
        {
            KernelResult result = CopyToClient(memoryManager, _receiveBufferDescriptors);

            if (result != KernelResult.Success)
            {
                return result;
            }

            return CopyToClient(memoryManager, _exchangeBufferDescriptors);
        }

        private KernelResult CopyToClient(KPageTableBase memoryManager, List<KBufferDescriptor> list)
        {
            foreach (KBufferDescriptor desc in list)
            {
                MemoryState stateMask;

                switch (desc.State)
                {
                    case MemoryState.IpcBuffer0: stateMask = MemoryState.IpcSendAllowedType0; break;
                    case MemoryState.IpcBuffer1: stateMask = MemoryState.IpcSendAllowedType1; break;
                    case MemoryState.IpcBuffer3: stateMask = MemoryState.IpcSendAllowedType3; break;

                    default: return KernelResult.InvalidCombination;
                }

                MemoryAttribute attributeMask = MemoryAttribute.Borrowed | MemoryAttribute.Uncached;

                if (desc.State == MemoryState.IpcBuffer0)
                {
                    attributeMask |= MemoryAttribute.DeviceMapped;
                }

                ulong clientAddrTruncated = BitUtils.AlignDown<ulong>(desc.ClientAddress, KPageTableBase.PageSize);
                ulong clientAddrRounded   = BitUtils.AlignUp<ulong>(desc.ClientAddress, KPageTableBase.PageSize);

                // Check if address is not aligned, in this case we need to perform 2 copies.
                if (clientAddrTruncated != clientAddrRounded)
                {
                    ulong copySize = clientAddrRounded - desc.ClientAddress;

                    if (copySize > desc.Size)
                    {
                        copySize = desc.Size;
                    }

                    KernelResult result = memoryManager.CopyDataFromCurrentProcess(
                        desc.ClientAddress,
                        copySize,
                        stateMask,
                        stateMask,
                        KMemoryPermission.ReadAndWrite,
                        attributeMask,
                        MemoryAttribute.None,
                        desc.ServerAddress);

                    if (result != KernelResult.Success)
                    {
                        return result;
                    }
                }

                ulong clientEndAddr = desc.ClientAddress + desc.Size;
                ulong serverEndAddr = desc.ServerAddress + desc.Size;

                ulong clientEndAddrTruncated = BitUtils.AlignDown<ulong>(clientEndAddr, (ulong)KPageTableBase.PageSize);
                ulong clientEndAddrRounded   = BitUtils.AlignUp<ulong>(clientEndAddr, KPageTableBase.PageSize);
                ulong serverEndAddrTruncated = BitUtils.AlignDown<ulong>(serverEndAddr, (ulong)KPageTableBase.PageSize);

                if (clientEndAddrTruncated < clientEndAddrRounded &&
                    (clientAddrTruncated == clientAddrRounded || clientAddrTruncated < clientEndAddrTruncated))
                {
                    KernelResult result = memoryManager.CopyDataFromCurrentProcess(
                        clientEndAddrTruncated,
                        clientEndAddr - clientEndAddrTruncated,
                        stateMask,
                        stateMask,
                        KMemoryPermission.ReadAndWrite,
                        attributeMask,
                        MemoryAttribute.None,
                        serverEndAddrTruncated);

                    if (result != KernelResult.Success)
                    {
                        return result;
                    }
                }
            }

            return KernelResult.Success;
        }

        public KernelResult UnmapServerBuffers(KPageTableBase memoryManager)
        {
            KernelResult result = UnmapServer(memoryManager, _sendBufferDescriptors);

            if (result != KernelResult.Success)
            {
                return result;
            }

            result = UnmapServer(memoryManager, _receiveBufferDescriptors);

            if (result != KernelResult.Success)
            {
                return result;
            }

            return UnmapServer(memoryManager, _exchangeBufferDescriptors);
        }

        private KernelResult UnmapServer(KPageTableBase memoryManager, List<KBufferDescriptor> list)
        {
            foreach (KBufferDescriptor descriptor in list)
            {
                KernelResult result = memoryManager.UnmapNoAttributeIfStateEquals(
                    descriptor.ServerAddress,
                    descriptor.Size,
                    descriptor.State);

                if (result != KernelResult.Success)
                {
                    return result;
                }
            }

            return KernelResult.Success;
        }

        public KernelResult RestoreClientBuffers(KPageTableBase memoryManager)
        {
            KernelResult result = RestoreClient(memoryManager, _sendBufferDescriptors);

            if (result != KernelResult.Success)
            {
                return result;
            }

            result = RestoreClient(memoryManager, _receiveBufferDescriptors);

            if (result != KernelResult.Success)
            {
                return result;
            }

            return RestoreClient(memoryManager, _exchangeBufferDescriptors);
        }

        private KernelResult RestoreClient(KPageTableBase memoryManager, List<KBufferDescriptor> list)
        {
            foreach (KBufferDescriptor descriptor in list)
            {
                KernelResult result = memoryManager.UnmapIpcRestorePermission(
                    descriptor.ClientAddress,
                    descriptor.Size,
                    descriptor.State);

                if (result != KernelResult.Success)
                {
                    return result;
                }
            }

            return KernelResult.Success;
        }
    }
}