Question

我想到了两种可能的机制：

IPC就像现有的QMP和QAPI
QEMU加载包含模型

所需的功能（当然所有可能通过C API，但不一定是IPC API）：

注入中断
注册用于注册访问的回调
修改主内存

为什么我要这样：

使用QEMU作为子模块并保持其源不受影响
仅适用于IPC方法的其他优点：
- 用我想要的任何语言编写模型
- 为我的设备使用非GPL许可

我知道in-tree设备，如How to add a new device in QEMU source code?所述，这是传统的做事方式。

到目前为止我发现了什么：

中断：只能使用nmi监视命令
IO端口：使用i和o监控命令可以进行IO，所以我很好
主要记忆：
- 理想的解决方案是直接将内存映射到主机，但这似乎很难：
- 可通过x和xp监视器命令
- 找不到如何使用monitor命令写入内存。但我认为GDB API支持，因此实现起来应该不会太难。

我能找到的最接近的代码片段是：https://github.com/texane/vpcie，它将双方的PCI序列化，然后通过QEMU的TCP API发送。但这种效率更低，更具侵入性，因为它需要在访客和主机上进行额外设置。

Answer 1

这创建了树形PCI设备，它只是在lspci中显示设备.. 它将简化更快的PCI驱动程序实现，因为它将充当模块，我们可以扩展它以具有与QEMU的edu-pci类似的功能。？

https://github.com/alokprasad/pci-hacking/blob/master/ksrc/virtual_pcinet/virtual_pci.c

/*
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/sysfs.h>
#include <linux/fs.h>
#include <linux/kobject.h>
#include <linux/device.h>
#include <linux/proc_fs.h>
#include <linux/types.h>
#include <linux/pci.h>
#include <linux/version.h>
#include<linux/kernel.h>


#define PCI_VENDOR_ID_XTREME        0x15b3
#define PCI_DEVICE_ID_XTREME_VNIC   0x1450

static struct pci_bus *vbus;
static struct pci_sysdata *sysdata;

static DEFINE_PCI_DEVICE_TABLE( vpci_dev_table) = {
    {PCI_DEVICE(PCI_VENDOR_ID_XTREME, PCI_DEVICE_ID_XTREME_VNIC)},
    {0}
};

MODULE_DEVICE_TABLE(pci,  vpci_dev_table);

int  vpci_read(struct pci_bus *bus, unsigned int devfn, int where,
         int size, u32 *val)
{
    switch (where) {
    case PCI_VENDOR_ID:
        *val = PCI_VENDOR_ID_XTREME | PCI_DEVICE_ID_XTREME_VNIC << 16;
        /* our id */
        break;
    case PCI_COMMAND:
        *val = 0;
        break;
    case PCI_HEADER_TYPE:
        *val = PCI_HEADER_TYPE_NORMAL;
        break;
    case PCI_STATUS:
        *val = 0;
        break;
    case PCI_CLASS_REVISION:
        *val = (4 << 24) | (0 << 16) | 1;
        /* network class, ethernet controller, revision 1 */ /*2 or 4*/
        break;
    case PCI_INTERRUPT_PIN:
        *val = 0;
        break;
    case PCI_SUBSYSTEM_VENDOR_ID:
        *val = 0;
        break;
    case PCI_SUBSYSTEM_ID:
        *val = 0;
        break;
    default:
        *val = 0;
        /* sensible default */
    }
    return 0;
}

int  vpci_write(struct pci_bus *bus, unsigned int devfn, int where,
          int size, u32 val)
{
    switch (where) {
    case PCI_BASE_ADDRESS_0:
    case PCI_BASE_ADDRESS_1:
    case PCI_BASE_ADDRESS_2:
    case PCI_BASE_ADDRESS_3:
    case PCI_BASE_ADDRESS_4:
    case PCI_BASE_ADDRESS_5:
        break;
    }
    return 0;
}

struct pci_ops  vpci_ops = {
    .read =  vpci_read,
    .write =  vpci_write
};


void  vpci_remove_vnic()
{
    struct pci_dev *pcidev = NULL;
    if (vbus == NULL)
        return;
    pci_remove_bus_device(pcidev);
    pci_dev_put(pcidev);
}
EXPORT_SYMBOL( vpci_remove_vnic);

void  vpci_vdev_remove(struct pci_dev *dev)
{
}

static struct pci_driver  vpci_vdev_driver = {
    .name = "Xtreme-Virtual-NIC1",
    .id_table =  vpci_dev_table,
    .remove =  vpci_vdev_remove
};

int  vpci_bus_init(void)
{
    struct pci_dev *pcidev = NULL;
    sysdata = kzalloc(sizeof(void *), GFP_KERNEL);
        vbus = pci_scan_bus_parented(NULL, 2, & vpci_ops, sysdata);
        //vbus = pci_create_root_bus(NULL,i,& vpci_ops, sysdata,NULL);
        //if (vbus != NULL)
            //break;
        memset(sysdata, 0, sizeof(void *));
    if (vbus == NULL) {
        kfree(sysdata);
        return -EINVAL;
    }
    if (pci_register_driver(& vpci_vdev_driver) < 0) {
        pci_remove_bus(vbus);
        vbus = NULL;
        return -EINVAL;
    }
    pcidev = pci_scan_single_device(vbus, 0);

        if (pcidev == NULL)
                return 0;
        else
                pci_dev_get(pcidev);

    pci_bus_add_devices(vbus);

    return 0;
}

void  vpci_bus_remove(void)
{
    if (vbus) {
        pci_unregister_driver(&vpci_vdev_driver);
        device_unregister(vbus->bridge);
        pci_remove_bus(vbus);
        kfree(sysdata);
        vbus = NULL;
    }
}


static int __init pci_init(void)
{
    printk( "module loaded");
     vpci_bus_init();
    return 0;
}

static void __exit pci_exit(void)
{
        printk(KERN_ALERT "unregister PCI Device\n");
        pci_unregister_driver(&vpci_vdev_driver);
}


module_init(pci_init);
module_exit(pci_exit);
MODULE_LICENSE("GPL");

Answer 2

我知道至少有一个QEMU分支，它为QEMU提供了共享库插件...但这是QEMU 4.0的分支。

https://github.com/cromulencellc/qemu-shoggoth

尽管未记录，但可以使用此fork构建出树形插件。

Answer 3

2019年11月11日，QEMU的主要贡献者Peter Maydell commented on another Stack Overflow question：

设备插件特别不在菜单之列，因为上游用户不想为人们提供一种很好的简单机制来使用树外非GPL /封闭源设备。

因此，QEMU开发人员似乎在那个时候反对这一想法。值得学习QEMU插件系统，尽管在任何情况下它都可能对相关应用程序有用：How to count the number of guest instructions QEMU executed from the beginning to the end of a run?

这太可惜了。想象一下，如果Linux内核没有内核模块接口！我建议QEMU公开此接口，但不要使其保持稳定，这样就不会给开发人员造成负担，这给合并人员带来的麻烦是，它没有麻烦的基础。

如何创建树外QEMU设备？

3 个答案: