/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "VirtioGpuStream.h"

#include <cros_gralloc_handle.h>
#include <drm/virtgpu_drm.h>
#include <xf86drm.h>

#include <sys/types.h>
#include <sys/mman.h>

#include <errno.h>
#include <unistd.h>

#ifndef PAGE_SIZE
#define PAGE_SIZE 0x1000
#endif

// In a virtual machine, there should only be one GPU
#define RENDERNODE_MINOR 128

// Maximum size of readback / response buffer in bytes
#define MAX_CMDRESPBUF_SIZE (10*PAGE_SIZE)

// Attributes use to allocate our response buffer
// Similar to virgl's fence objects
#define PIPE_BUFFER             0
#define VIRGL_FORMAT_R8_UNORM   64
#define VIRGL_BIND_CUSTOM       (1 << 17)

// Conservative; see virgl_winsys.h
#define VIRGL_MAX_CMDBUF_DWORDS (16*1024)
#define VIRGL_MAX_CMDBUF_SIZE   (4*VIRGL_MAX_CMDBUF_DWORDS)

struct VirtioGpuCmd {
    uint32_t op;
    uint32_t cmdSize;
    unsigned char buf[0];
} __attribute__((packed));

bool VirtioGpuProcessPipe::processPipeInit(HostConnectionType, renderControl_encoder_context_t *rcEnc)
{
  union {
      uint64_t proto;
      struct {
          int pid;
          int tid;
      } id;
  } puid = {
      .id.pid = getpid(),
      .id.tid = gettid(),
  };
  rcEnc->rcSetPuid(rcEnc, puid.proto);
  return true;
}

VirtioGpuStream::VirtioGpuStream(size_t bufSize) :
    IOStream(0U),
    m_fd(-1),
    m_bufSize(bufSize),
    m_buf(nullptr),
    m_cmdResp_rh(0U),
    m_cmdResp_bo(0U),
    m_cmdResp(nullptr),
    m_cmdRespPos(0U),
    m_cmdPos(0U),
    m_flushPos(0U),
    m_allocSize(0U),
    m_allocFlushSize(0U)
{
}

VirtioGpuStream::~VirtioGpuStream()
{
    if (m_cmdResp) {
        munmap(m_cmdResp, MAX_CMDRESPBUF_SIZE);
    }

    if (m_cmdResp_bo > 0U) {
        drm_gem_close gem_close = {
            .handle = m_cmdResp_bo,
        };
        drmIoctl(m_fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
    }

    if (m_fd >= 0) {
        close(m_fd);
    }

    free(m_buf);
}

int VirtioGpuStream::connect()
{
    if (m_fd < 0) {
        m_fd = drmOpenRender(RENDERNODE_MINOR);
        if (m_fd < 0) {
            ERR("%s: failed with fd %d (%s)", __func__, m_fd, strerror(errno));
            return -1;
        }
    }

    if (!m_cmdResp_bo) {
        drm_virtgpu_resource_create create = {
            .target     = PIPE_BUFFER,
            .format     = VIRGL_FORMAT_R8_UNORM,
            .bind       = VIRGL_BIND_CUSTOM,
            .width      = MAX_CMDRESPBUF_SIZE,
            .height     = 1U,
            .depth      = 1U,
            .array_size = 0U,
            .size       = MAX_CMDRESPBUF_SIZE,
            .stride     = MAX_CMDRESPBUF_SIZE,
        };
        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
        if (ret) {
            ERR("%s: failed with %d allocating command response buffer (%s)",
                __func__, ret, strerror(errno));
            return -1;
        }
        m_cmdResp_bo = create.bo_handle;
        if (!m_cmdResp_bo) {
            ERR("%s: no handle when allocating command response buffer",
                __func__);
            return -1;
        }
        m_cmdResp_rh = create.res_handle;
        if (create.size != MAX_CMDRESPBUF_SIZE) {
	    ERR("%s: command response buffer wrongly sized, create.size=%zu "
		"!= %zu", __func__,
		static_cast<size_t>(create.size),
		static_cast<size_t>(MAX_CMDRESPBUF_SIZE));
	    abort();
	}
    }

    if (!m_cmdResp) {
        drm_virtgpu_map map = {
            .handle = m_cmdResp_bo,
        };
        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_MAP, &map);
        if (ret) {
            ERR("%s: failed with %d mapping command response buffer (%s)",
                __func__, ret, strerror(errno));
            return -1;
        }
        m_cmdResp = static_cast<VirtioGpuCmd *>(mmap64(nullptr,
                                                       MAX_CMDRESPBUF_SIZE,
                                                       PROT_READ, MAP_SHARED,
                                                       m_fd, map.offset));
        if (m_cmdResp == MAP_FAILED) {
            ERR("%s: failed with %d mmap'ing command response buffer (%s)",
                __func__, ret, strerror(errno));
            return -1;
        }
    }

    return 0;
}

int VirtioGpuStream::flush()
{
    int ret = commitBuffer(m_allocSize - m_allocFlushSize);
    if (ret)
        return ret;
    m_allocFlushSize = m_allocSize;
    return 0;
}

void *VirtioGpuStream::allocBuffer(size_t minSize)
{
    if (m_buf) {
        // Try to model the alloc() calls being made by the user. They should be
        // obeying the protocol and using alloc() for anything they don't write
        // with writeFully(), so we can know if this alloc() is for part of a
        // command, or not. If it is not for part of a command, we are starting
        // a new command, and should increment m_cmdPos.
        VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
        if (m_allocSize + minSize > cmd->cmdSize) {
            m_allocFlushSize = 0U;
            m_allocSize = 0U;
            // This might also be a convenient point to flush commands
            if (m_cmdPos + cmd->cmdSize + minSize > m_bufSize) {
                if (commitAll() < 0) {
                    ERR("%s: command flush failed", __func__);
                    m_flushPos = 0U;
                    m_bufSize = 0U;
                    m_cmdPos = 0U;
                    free(m_buf);
                    m_buf = nullptr;
                    return nullptr;
                }
            } else {
                m_cmdPos += cmd->cmdSize;
                m_flushPos = m_cmdPos;
            }
        }
    }

    // Update m_allocSize here, before minSize is tampered with below
    m_allocSize += minSize;

    // Make sure anything we already have written to the buffer is retained
    minSize += m_flushPos;

    size_t allocSize = (m_bufSize < minSize ? minSize : m_bufSize);
    if (!m_buf) {
        m_buf = static_cast<unsigned char *>(malloc(allocSize));
    } else if (m_bufSize < allocSize) {
        unsigned char *p = static_cast<unsigned char *>(realloc(m_buf, allocSize));
        if (!p) {
            free(m_buf);
        }
        m_buf = p;
    }
    if (!m_buf) {
        ERR("%s: alloc (%zu) failed\n", __func__, allocSize);
        m_allocFlushSize = 0U;
        m_allocSize = 0U;
        m_flushPos = 0U;
        m_bufSize = 0U;
        m_cmdPos = 0U;
    } else {
        m_bufSize = allocSize;
    }
    if (m_flushPos == 0 && m_cmdPos == 0) {
      // During initialization, HostConnection will send an empty command
      // packet to check the connection is good, but it doesn't obey the usual
      // line protocol. This is a 4 byte write to [0], which is our 'op' field,
      // and we don't have an op=0 so it's OK. We fake up a valid length, and
      // overload this workaround by putting the res_handle for the readback
      // buffer in the command payload, patched in just before we submit.
      VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);
      cmd->op = 0U;
      cmd->cmdSize = sizeof(*cmd) + sizeof(__u32);
    }
    return m_buf + m_cmdPos;
}

// For us, writeFully() means to write a command without any header, directly
// into the buffer stream. We can use the packet frame written directly to the
// stream to verify this write is within bounds, then update the counter.

int VirtioGpuStream::writeFully(const void *buf, size_t len)
{
    if (!valid())
        return -1;

    if (!buf) {
        if (len > 0) {
            // If len is non-zero, buf must not be NULL. Otherwise the pipe would
            // be in a corrupted state, which is lethal for the emulator.
            ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting",
                __func__, len);
            abort();
        }
        return 0;
    }

    VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[m_cmdPos]);

    if (m_flushPos < sizeof(*cmd)) {
        ERR("%s: writeFully len %zu would overwrite command header, "
            "cmd_pos=%zu, flush_pos=%zu, lethal error, exiting", __func__,
            len, m_cmdPos, m_flushPos);
        abort();
    }

    if (m_flushPos + len > cmd->cmdSize) {
        ERR("%s: writeFully len %zu would overflow the command bounds, "
            "cmd_pos=%zu, flush_pos=%zu, cmdsize=%zu, lethal error, exiting",
            __func__, len, m_cmdPos, m_flushPos, cmd->cmdSize);
        abort();
    }

    if (len > VIRGL_MAX_CMDBUF_SIZE) {
        ERR("%s: Large command (%zu bytes) exceeds virgl limits",
            __func__, len);
        /* Fall through */
    }

    memcpy(&m_buf[m_flushPos], buf, len);
    commitBuffer(len);
    m_allocSize += len;
    return 0;
}

const unsigned char *VirtioGpuStream::readFully(void *buf, size_t len)
{
    if (!valid())
        return nullptr;

    if (!buf) {
        if (len > 0) {
            // If len is non-zero, buf must not be NULL. Otherwise the pipe would
            // be in a corrupted state, which is lethal for the emulator.
            ERR("%s: failed, buf=NULL, len %zu, lethal error, exiting.",
                __func__, len);
            abort();
        }
        return nullptr;
    }

    // Read is too big for current architecture
    if (len > MAX_CMDRESPBUF_SIZE - sizeof(*m_cmdResp)) {
        ERR("%s: failed, read too large, len %zu, lethal error, exiting.",
            __func__, len);
        abort();
    }

    // Commit all outstanding write commands (if any)
    if (commitAll() < 0) {
        ERR("%s: command flush failed", __func__);
        return nullptr;
    }

    if (len > 0U && m_cmdRespPos == 0U) {
        // When we are about to read for the first time, wait for the virtqueue
        // to drain to this command, otherwise the data could be stale
        drm_virtgpu_3d_wait wait = {
            .handle = m_cmdResp_bo,
        };
        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_WAIT, &wait);
        if (ret) {
            ERR("%s: failed with %d waiting for response buffer (%s)",
                __func__, ret, strerror(errno));
            // Fall through, hope for the best
        }
    }

    // Most likely a protocol implementation error
    if (m_cmdResp->cmdSize - sizeof(*m_cmdResp) < m_cmdRespPos + len) {
        ERR("%s: failed, op %zu, len %zu, cmdSize %zu, pos %zu, lethal "
            "error, exiting.", __func__, m_cmdResp->op, len,
            m_cmdResp->cmdSize, m_cmdRespPos);
        abort();
    }

    memcpy(buf, &m_cmdResp->buf[m_cmdRespPos], len);

    if (m_cmdRespPos + len == m_cmdResp->cmdSize - sizeof(*m_cmdResp)) {
        m_cmdRespPos = 0U;
    } else {
        m_cmdRespPos += len;
    }

    return reinterpret_cast<const unsigned char *>(buf);
}

int VirtioGpuStream::commitBuffer(size_t size)
{
    if (m_flushPos + size > m_bufSize) {
        ERR("%s: illegal commit size %zu, flushPos %zu, bufSize %zu",
            __func__, size, m_flushPos, m_bufSize);
        return -1;
    }
    m_flushPos += size;
    return 0;
}

int VirtioGpuStream::commitAll()
{
    size_t pos = 0U, numFlushed = 0U;
    while (pos < m_flushPos) {
        VirtioGpuCmd *cmd = reinterpret_cast<VirtioGpuCmd *>(&m_buf[pos]);

        // Should never happen
        if (pos + cmd->cmdSize > m_bufSize) {
            ERR("%s: failed, pos %zu, cmdSize %zu, bufSize %zu, lethal "
                "error, exiting.", __func__, pos, cmd->cmdSize, m_bufSize);
            abort();
        }

        // Saw dummy command; patch it with res handle
        if (cmd->op == 0) {
            *(uint32_t *)cmd->buf = m_cmdResp_rh;
        }

        // Flush a single command
        drm_virtgpu_execbuffer execbuffer = {
            .size           = cmd->cmdSize,
            .command        = reinterpret_cast<__u64>(cmd),
            .bo_handles     = reinterpret_cast<__u64>(&m_cmdResp_bo),
            .num_bo_handles = 1U,
        };
        int ret = drmIoctl(m_fd, DRM_IOCTL_VIRTGPU_EXECBUFFER, &execbuffer);
        if (ret) {
            ERR("%s: failed with %d executing command buffer (%s)",  __func__,
                ret, strerror(errno));
            return -1;
        }

        pos += cmd->cmdSize;
        numFlushed++;
    }

    if (pos > m_flushPos) {
        ERR("%s: aliasing, flushPos %zu, pos %zu, probably ok", __func__,
            m_flushPos, pos);
        /* Fall through */
    }

    m_flushPos = 0U;
    m_cmdPos = 0U;
    return 0;
}