// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (C) 2025 Ant Group
 * Author: Tiwei Bie <tiwei.btw@antgroup.com>
 */
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <sys/eventfd.h>
#include <linux/limits.h>
#include <linux/vfio.h>
#include <linux/pci_regs.h>
#include <as-layout.h>
#include <um_malloc.h>

#include "vfio_user.h"

int uml_vfio_user_open_container(void)
{
        int r, fd;

        fd = open("/dev/vfio/vfio", O_RDWR);
        if (fd < 0)
                return -errno;

        r = ioctl(fd, VFIO_GET_API_VERSION);
        if (r != VFIO_API_VERSION) {
                r = r < 0 ? -errno : -EINVAL;
                goto error;
        }

        r = ioctl(fd, VFIO_CHECK_EXTENSION, VFIO_TYPE1_IOMMU);
        if (r <= 0) {
                r = r < 0 ? -errno : -EINVAL;
                goto error;
        }

        return fd;

error:
        close(fd);
        return r;
}

int uml_vfio_user_setup_iommu(int container)
{
        /*
         * This is a bit tricky. See the big comment in
         * vhost_user_set_mem_table() in virtio_uml.c.
         */
        unsigned long reserved = uml_reserved - uml_physmem;
        struct vfio_iommu_type1_dma_map dma_map = {
                .argsz = sizeof(dma_map),
                .flags = VFIO_DMA_MAP_FLAG_READ | VFIO_DMA_MAP_FLAG_WRITE,
                .vaddr = uml_reserved,
                .iova = reserved,
                .size = physmem_size - reserved,
        };

        if (ioctl(container, VFIO_SET_IOMMU, VFIO_TYPE1_IOMMU) < 0)
                return -errno;

        if (ioctl(container, VFIO_IOMMU_MAP_DMA, &dma_map) < 0)
                return -errno;

        return 0;
}

int uml_vfio_user_get_group_id(const char *device)
{
        char *path, *buf, *end;
        const char *name;
        int r;

        path = uml_kmalloc(PATH_MAX, UM_GFP_KERNEL);
        if (!path)
                return -ENOMEM;

        sprintf(path, "/sys/bus/pci/devices/%s/iommu_group", device);

        buf = uml_kmalloc(PATH_MAX + 1, UM_GFP_KERNEL);
        if (!buf) {
                r = -ENOMEM;
                goto free_path;
        }

        r = readlink(path, buf, PATH_MAX);
        if (r < 0) {
                r = -errno;
                goto free_buf;
        }
        buf[r] = '\0';

        name = basename(buf);

        r = strtoul(name, &end, 10);
        if (*end != '\0' || end == name) {
                r = -EINVAL;
                goto free_buf;
        }

free_buf:
        kfree(buf);
free_path:
        kfree(path);
        return r;
}

int uml_vfio_user_open_group(int group_id)
{
        char *path;
        int fd;

        path = uml_kmalloc(PATH_MAX, UM_GFP_KERNEL);
        if (!path)
                return -ENOMEM;

        sprintf(path, "/dev/vfio/%d", group_id);

        fd = open(path, O_RDWR);
        if (fd < 0) {
                fd = -errno;
                goto out;
        }

out:
        kfree(path);
        return fd;
}

int uml_vfio_user_set_container(int container, int group)
{
        if (ioctl(group, VFIO_GROUP_SET_CONTAINER, &container) < 0)
                return -errno;
        return 0;
}

int uml_vfio_user_unset_container(int container, int group)
{
        if (ioctl(group, VFIO_GROUP_UNSET_CONTAINER, &container) < 0)
                return -errno;
        return 0;
}

static int vfio_set_irqs(int device, int start, int count, int *irqfd)
{
        struct vfio_irq_set *irq_set;
        int argsz = sizeof(*irq_set) + sizeof(*irqfd) * count;
        int err = 0;

        irq_set = uml_kmalloc(argsz, UM_GFP_KERNEL);
        if (!irq_set)
                return -ENOMEM;

        irq_set->argsz = argsz;
        irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER;
        irq_set->index = VFIO_PCI_MSIX_IRQ_INDEX;
        irq_set->start = start;
        irq_set->count = count;
        memcpy(irq_set->data, irqfd, sizeof(*irqfd) * count);

        if (ioctl(device, VFIO_DEVICE_SET_IRQS, irq_set) < 0) {
                err = -errno;
                goto out;
        }

out:
        kfree(irq_set);
        return err;
}

int uml_vfio_user_setup_device(struct uml_vfio_user_device *dev,
                               int group, const char *device)
{
        struct vfio_device_info device_info = { .argsz = sizeof(device_info) };
        struct vfio_irq_info irq_info = { .argsz = sizeof(irq_info) };
        int err, i;

        dev->device = ioctl(group, VFIO_GROUP_GET_DEVICE_FD, device);
        if (dev->device < 0)
                return -errno;

        if (ioctl(dev->device, VFIO_DEVICE_GET_INFO, &device_info) < 0) {
                err = -errno;
                goto close_device;
        }

        dev->num_regions = device_info.num_regions;
        if (dev->num_regions > VFIO_PCI_CONFIG_REGION_INDEX + 1)
                dev->num_regions = VFIO_PCI_CONFIG_REGION_INDEX + 1;

        dev->region = uml_kmalloc(sizeof(*dev->region) * dev->num_regions,
                                  UM_GFP_KERNEL);
        if (!dev->region) {
                err = -ENOMEM;
                goto close_device;
        }

        for (i = 0; i < dev->num_regions; i++) {
                struct vfio_region_info region = {
                        .argsz = sizeof(region),
                        .index = i,
                };
                if (ioctl(dev->device, VFIO_DEVICE_GET_REGION_INFO, &region) < 0) {
                        err = -errno;
                        goto free_region;
                }
                dev->region[i].size = region.size;
                dev->region[i].offset = region.offset;
        }

        /* Only MSI-X is supported currently. */
        irq_info.index = VFIO_PCI_MSIX_IRQ_INDEX;
        if (ioctl(dev->device, VFIO_DEVICE_GET_IRQ_INFO, &irq_info) < 0) {
                err = -errno;
                goto free_region;
        }

        dev->irq_count = irq_info.count;

        dev->irqfd = uml_kmalloc(sizeof(int) * dev->irq_count, UM_GFP_KERNEL);
        if (!dev->irqfd) {
                err = -ENOMEM;
                goto free_region;
        }

        memset(dev->irqfd, -1, sizeof(int) * dev->irq_count);

        err = vfio_set_irqs(dev->device, 0, dev->irq_count, dev->irqfd);
        if (err)
                goto free_irqfd;

        return 0;

free_irqfd:
        kfree(dev->irqfd);
free_region:
        kfree(dev->region);
close_device:
        close(dev->device);
        return err;
}

void uml_vfio_user_teardown_device(struct uml_vfio_user_device *dev)
{
        kfree(dev->irqfd);
        kfree(dev->region);
        close(dev->device);
}

int uml_vfio_user_activate_irq(struct uml_vfio_user_device *dev, int index)
{
        int irqfd;

        irqfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
        if (irqfd < 0)
                return -errno;

        dev->irqfd[index] = irqfd;
        return irqfd;
}

void uml_vfio_user_deactivate_irq(struct uml_vfio_user_device *dev, int index)
{
        close(dev->irqfd[index]);
        dev->irqfd[index] = -1;
}

int uml_vfio_user_update_irqs(struct uml_vfio_user_device *dev)
{
        return vfio_set_irqs(dev->device, 0, dev->irq_count, dev->irqfd);
}

static int vfio_region_read(struct uml_vfio_user_device *dev, unsigned int index,
                            uint64_t offset, void *buf, uint64_t size)
{
        if (index >= dev->num_regions || offset + size > dev->region[index].size)
                return -EINVAL;

        if (pread(dev->device, buf, size, dev->region[index].offset + offset) < 0)
                return -errno;

        return 0;
}

static int vfio_region_write(struct uml_vfio_user_device *dev, unsigned int index,
                             uint64_t offset, const void *buf, uint64_t size)
{
        if (index >= dev->num_regions || offset + size > dev->region[index].size)
                return -EINVAL;

        if (pwrite(dev->device, buf, size, dev->region[index].offset + offset) < 0)
                return -errno;

        return 0;
}

int uml_vfio_user_cfgspace_read(struct uml_vfio_user_device *dev,
                                unsigned int offset, void *buf, int size)
{
        return vfio_region_read(dev, VFIO_PCI_CONFIG_REGION_INDEX,
                                offset, buf, size);
}

int uml_vfio_user_cfgspace_write(struct uml_vfio_user_device *dev,
                                 unsigned int offset, const void *buf, int size)
{
        return vfio_region_write(dev, VFIO_PCI_CONFIG_REGION_INDEX,
                                 offset, buf, size);
}

int uml_vfio_user_bar_read(struct uml_vfio_user_device *dev, int bar,
                           unsigned int offset, void *buf, int size)
{
        return vfio_region_read(dev, bar, offset, buf, size);
}

int uml_vfio_user_bar_write(struct uml_vfio_user_device *dev, int bar,
                            unsigned int offset, const void *buf, int size)
{
        return vfio_region_write(dev, bar, offset, buf, size);
}