hw/remote/proxy.c

   1 /*
   2  * Copyright © 2018, 2021 Oracle and/or its affiliates.
   3  *
   4  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   5  * See the COPYING file in the top-level directory.
   6  *
   7  */
   8
   9 #include "qemu/osdep.h"
  10
  11 #include "hw/remote/proxy.h"
  12 #include "hw/pci/pci.h"
  13 #include "qapi/error.h"
  14 #include "io/channel-util.h"
  15 #include "hw/qdev-properties.h"
  16 #include "monitor/monitor.h"
  17 #include "migration/blocker.h"
  18 #include "qemu/sockets.h"
  19 #include "hw/remote/mpqemu-link.h"
  20 #include "qemu/error-report.h"
  21 #include "hw/remote/proxy-memory-listener.h"
  22 #include "qom/object.h"
  23 #include "qemu/event_notifier.h"
  24 #include "sysemu/kvm.h"
  25
  26 static void probe_pci_info(PCIDevice *dev, Error **errp);
  27 static void proxy_device_reset(DeviceState *dev);
  28
  29 static void proxy_intx_update(PCIDevice *pci_dev)
  30 {
  31     PCIProxyDev *dev = PCI_PROXY_DEV(pci_dev);
  32     PCIINTxRoute route;
  33     int pin = pci_get_byte(pci_dev->config + PCI_INTERRUPT_PIN) - 1;
  34
  35     if (dev->virq != -1) {
  36         kvm_irqchip_remove_irqfd_notifier_gsi(kvm_state, &dev->intr, dev->virq);
  37         dev->virq = -1;
  38     }
  39
  40     route = pci_device_route_intx_to_irq(pci_dev, pin);
  41
  42     dev->virq = route.irq;
  43
  44     if (dev->virq != -1) {
  45         kvm_irqchip_add_irqfd_notifier_gsi(kvm_state, &dev->intr,
  46                                            &dev->resample, dev->virq);
  47     }
  48 }
  49
  50 static void setup_irqfd(PCIProxyDev *dev)
  51 {
  52     PCIDevice *pci_dev = PCI_DEVICE(dev);
  53     MPQemuMsg msg;
  54     Error *local_err = NULL;
  55
  56     event_notifier_init(&dev->intr, 0);
  57     event_notifier_init(&dev->resample, 0);
  58
  59     memset(&msg, 0, sizeof(MPQemuMsg));
  60     msg.cmd = MPQEMU_CMD_SET_IRQFD;
  61     msg.num_fds = 2;
  62     msg.fds[0] = event_notifier_get_fd(&dev->intr);
  63     msg.fds[1] = event_notifier_get_fd(&dev->resample);
  64     msg.size = 0;
  65
  66     if (!mpqemu_msg_send(&msg, dev->ioc, &local_err)) {
  67         error_report_err(local_err);
  68     }
  69
  70     dev->virq = -1;
  71
  72     proxy_intx_update(pci_dev);
  73
  74     pci_device_set_intx_routing_notifier(pci_dev, proxy_intx_update);
  75 }
  76
  77 static void pci_proxy_dev_realize(PCIDevice *device, Error **errp)
  78 {
  79     ERRP_GUARD();
  80     PCIProxyDev *dev = PCI_PROXY_DEV(device);
  81     uint8_t *pci_conf = device->config;
  82     int fd;
  83
  84     if (!dev->fd) {
  85         error_setg(errp, "fd parameter not specified for %s",
  86                    DEVICE(device)->id);
  87         return;
  88     }
  89
  90     fd = monitor_fd_param(monitor_cur(), dev->fd, errp);
  91     if (fd == -1) {
  92         error_prepend(errp, "proxy: unable to parse fd %s: ", dev->fd);
  93         return;
  94     }
  95
  96     if (!fd_is_socket(fd)) {
  97         error_setg(errp, "proxy: fd %d is not a socket", fd);
  98         close(fd);
  99         return;
 100     }
 101
 102     dev->ioc = qio_channel_new_fd(fd, errp);
 103     if (!dev->ioc) {
 104         close(fd);
 105         return;
 106     }
 107
 108     error_setg(&dev->migration_blocker, "%s does not support migration",
 109                TYPE_PCI_PROXY_DEV);
 110     if (migrate_add_blocker(&dev->migration_blocker, errp) < 0) {
 111         object_unref(dev->ioc);
 112         return;
 113     }
 114
 115     qemu_mutex_init(&dev->io_mutex);
 116     qio_channel_set_blocking(dev->ioc, true, NULL);
 117
 118     pci_conf[PCI_LATENCY_TIMER] = 0xff;
 119     pci_conf[PCI_INTERRUPT_PIN] = 0x01;
 120
 121     proxy_memory_listener_configure(&dev->proxy_listener, dev->ioc);
 122
 123     setup_irqfd(dev);
 124
 125     probe_pci_info(PCI_DEVICE(dev), errp);
 126 }
 127
 128 static void pci_proxy_dev_exit(PCIDevice *pdev)
 129 {
 130     PCIProxyDev *dev = PCI_PROXY_DEV(pdev);
 131
 132     if (dev->ioc) {
 133         qio_channel_close(dev->ioc, NULL);
 134     }
 135
 136     migrate_del_blocker(&dev->migration_blocker);
 137
 138     proxy_memory_listener_deconfigure(&dev->proxy_listener);
 139
 140     event_notifier_cleanup(&dev->intr);
 141     event_notifier_cleanup(&dev->resample);
 142 }
 143
 144 static void config_op_send(PCIProxyDev *pdev, uint32_t addr, uint32_t *val,
 145                            int len, unsigned int op)
 146 {
 147     MPQemuMsg msg = { 0 };
 148     uint64_t ret = -EINVAL;
 149     Error *local_err = NULL;
 150
 151     msg.cmd = op;
 152     msg.data.pci_conf_data.addr = addr;
 153     msg.data.pci_conf_data.val = (op == MPQEMU_CMD_PCI_CFGWRITE) ? *val : 0;
 154     msg.data.pci_conf_data.len = len;
 155     msg.size = sizeof(PciConfDataMsg);
 156
 157     ret = mpqemu_msg_send_and_await_reply(&msg, pdev, &local_err);
 158     if (local_err) {
 159         error_report_err(local_err);
 160     }
 161
 162     if (ret == UINT64_MAX) {
 163         error_report("Failed to perform PCI config %s operation",
 164                      (op == MPQEMU_CMD_PCI_CFGREAD) ? "READ" : "WRITE");
 165     }
 166
 167     if (op == MPQEMU_CMD_PCI_CFGREAD) {
 168         *val = (uint32_t)ret;
 169     }
 170 }
 171
 172 static uint32_t pci_proxy_read_config(PCIDevice *d, uint32_t addr, int len)
 173 {
 174     uint32_t val;
 175
 176     config_op_send(PCI_PROXY_DEV(d), addr, &val, len, MPQEMU_CMD_PCI_CFGREAD);
 177
 178     return val;
 179 }
 180
 181 static void pci_proxy_write_config(PCIDevice *d, uint32_t addr, uint32_t val,
 182                                    int len)
 183 {
 184     /*
 185      * Some of the functions access the copy of remote device's PCI config
 186      * space which is cached in the proxy device. Therefore, maintain
 187      * it updated.
 188      */
 189     pci_default_write_config(d, addr, val, len);
 190
 191     config_op_send(PCI_PROXY_DEV(d), addr, &val, len, MPQEMU_CMD_PCI_CFGWRITE);
 192 }
 193
 194 static Property proxy_properties[] = {
 195     DEFINE_PROP_STRING("fd", PCIProxyDev, fd),
 196     DEFINE_PROP_END_OF_LIST(),
 197 };
 198
 199 static void pci_proxy_dev_class_init(ObjectClass *klass, void *data)
 200 {
 201     DeviceClass *dc = DEVICE_CLASS(klass);
 202     PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
 203
 204     k->realize = pci_proxy_dev_realize;
 205     k->exit = pci_proxy_dev_exit;
 206     k->config_read = pci_proxy_read_config;
 207     k->config_write = pci_proxy_write_config;
 208
 209     device_class_set_legacy_reset(dc, proxy_device_reset);
 210
 211     device_class_set_props(dc, proxy_properties);
 212 }
 213
 214 static const TypeInfo pci_proxy_dev_type_info = {
 215     .name          = TYPE_PCI_PROXY_DEV,
 216     .parent        = TYPE_PCI_DEVICE,
 217     .instance_size = sizeof(PCIProxyDev),
 218     .class_init    = pci_proxy_dev_class_init,
 219     .interfaces = (InterfaceInfo[]) {
 220         { INTERFACE_CONVENTIONAL_PCI_DEVICE },
 221         { },
 222     },
 223 };
 224
 225 static void pci_proxy_dev_register_types(void)
 226 {
 227     type_register_static(&pci_proxy_dev_type_info);
 228 }
 229
 230 type_init(pci_proxy_dev_register_types)
 231
 232 static void send_bar_access_msg(PCIProxyDev *pdev, MemoryRegion *mr,
 233                                 bool write, hwaddr addr, uint64_t *val,
 234                                 unsigned size, bool memory)
 235 {
 236     MPQemuMsg msg = { 0 };
 237     long ret = -EINVAL;
 238     Error *local_err = NULL;
 239
 240     msg.size = sizeof(BarAccessMsg);
 241     msg.data.bar_access.addr = mr->addr + addr;
 242     msg.data.bar_access.size = size;
 243     msg.data.bar_access.memory = memory;
 244
 245     if (write) {
 246         msg.cmd = MPQEMU_CMD_BAR_WRITE;
 247         msg.data.bar_access.val = *val;
 248     } else {
 249         msg.cmd = MPQEMU_CMD_BAR_READ;
 250     }
 251
 252     ret = mpqemu_msg_send_and_await_reply(&msg, pdev, &local_err);
 253     if (local_err) {
 254         error_report_err(local_err);
 255     }
 256
 257     if (!write) {
 258         *val = ret;
 259     }
 260 }
 261
 262 static void proxy_bar_write(void *opaque, hwaddr addr, uint64_t val,
 263                             unsigned size)
 264 {
 265     ProxyMemoryRegion *pmr = opaque;
 266
 267     send_bar_access_msg(pmr->dev, &pmr->mr, true, addr, &val, size,
 268                         pmr->memory);
 269 }
 270
 271 static uint64_t proxy_bar_read(void *opaque, hwaddr addr, unsigned size)
 272 {
 273     ProxyMemoryRegion *pmr = opaque;
 274     uint64_t val;
 275
 276     send_bar_access_msg(pmr->dev, &pmr->mr, false, addr, &val, size,
 277                         pmr->memory);
 278
 279     return val;
 280 }
 281
 282 const MemoryRegionOps proxy_mr_ops = {
 283     .read = proxy_bar_read,
 284     .write = proxy_bar_write,
 285     .endianness = DEVICE_NATIVE_ENDIAN,
 286     .impl = {
 287         .min_access_size = 1,
 288         .max_access_size = 8,
 289     },
 290 };
 291
 292 static void probe_pci_info(PCIDevice *dev, Error **errp)
 293 {
 294     PCIDeviceClass *pc = PCI_DEVICE_GET_CLASS(dev);
 295     uint32_t orig_val, new_val, base_class, val;
 296     PCIProxyDev *pdev = PCI_PROXY_DEV(dev);
 297     DeviceClass *dc = DEVICE_CLASS(pc);
 298     uint8_t type;
 299     int i, size;
 300
 301     config_op_send(pdev, PCI_VENDOR_ID, &val, 2, MPQEMU_CMD_PCI_CFGREAD);
 302     pc->vendor_id = (uint16_t)val;
 303
 304     config_op_send(pdev, PCI_DEVICE_ID, &val, 2, MPQEMU_CMD_PCI_CFGREAD);
 305     pc->device_id = (uint16_t)val;
 306
 307     config_op_send(pdev, PCI_CLASS_DEVICE, &val, 2, MPQEMU_CMD_PCI_CFGREAD);
 308     pc->class_id = (uint16_t)val;
 309
 310     config_op_send(pdev, PCI_SUBSYSTEM_ID, &val, 2, MPQEMU_CMD_PCI_CFGREAD);
 311     pc->subsystem_id = (uint16_t)val;
 312
 313     base_class = pc->class_id >> 4;
 314     switch (base_class) {
 315     case PCI_BASE_CLASS_BRIDGE:
 316         set_bit(DEVICE_CATEGORY_BRIDGE, dc->categories);
 317         break;
 318     case PCI_BASE_CLASS_STORAGE:
 319         set_bit(DEVICE_CATEGORY_STORAGE, dc->categories);
 320         break;
 321     case PCI_BASE_CLASS_NETWORK:
 322     case PCI_BASE_CLASS_WIRELESS:
 323         set_bit(DEVICE_CATEGORY_NETWORK, dc->categories);
 324         break;
 325     case PCI_BASE_CLASS_INPUT:
 326         set_bit(DEVICE_CATEGORY_INPUT, dc->categories);
 327         break;
 328     case PCI_BASE_CLASS_DISPLAY:
 329         set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);
 330         break;
 331     case PCI_BASE_CLASS_PROCESSOR:
 332         set_bit(DEVICE_CATEGORY_CPU, dc->categories);
 333         break;
 334     default:
 335         set_bit(DEVICE_CATEGORY_MISC, dc->categories);
 336         break;
 337     }
 338
 339     for (i = 0; i < PCI_NUM_REGIONS; i++) {
 340         config_op_send(pdev, PCI_BASE_ADDRESS_0 + (4 * i), &orig_val, 4,
 341                        MPQEMU_CMD_PCI_CFGREAD);
 342         new_val = 0xffffffff;
 343         config_op_send(pdev, PCI_BASE_ADDRESS_0 + (4 * i), &new_val, 4,
 344                        MPQEMU_CMD_PCI_CFGWRITE);
 345         config_op_send(pdev, PCI_BASE_ADDRESS_0 + (4 * i), &new_val, 4,
 346                        MPQEMU_CMD_PCI_CFGREAD);
 347         size = (~(new_val & 0xFFFFFFF0)) + 1;
 348         config_op_send(pdev, PCI_BASE_ADDRESS_0 + (4 * i), &orig_val, 4,
 349                        MPQEMU_CMD_PCI_CFGWRITE);
 350         type = (new_val & 0x1) ?
 351                    PCI_BASE_ADDRESS_SPACE_IO : PCI_BASE_ADDRESS_SPACE_MEMORY;
 352
 353         if (size) {
 354             g_autofree char *name = g_strdup_printf("bar-region-%d", i);
 355             pdev->region[i].dev = pdev;
 356             pdev->region[i].present = true;
 357             if (type == PCI_BASE_ADDRESS_SPACE_MEMORY) {
 358                 pdev->region[i].memory = true;
 359             }
 360             memory_region_init_io(&pdev->region[i].mr, OBJECT(pdev),
 361                                   &proxy_mr_ops, &pdev->region[i],
 362                                   name, size);
 363             pci_register_bar(dev, i, type, &pdev->region[i].mr);
 364         }
 365     }
 366 }
 367
 368 static void proxy_device_reset(DeviceState *dev)
 369 {
 370     PCIProxyDev *pdev = PCI_PROXY_DEV(dev);
 371     MPQemuMsg msg = { 0 };
 372     Error *local_err = NULL;
 373
 374     msg.cmd = MPQEMU_CMD_DEVICE_RESET;
 375     msg.size = 0;
 376
 377     mpqemu_msg_send_and_await_reply(&msg, pdev, &local_err);
 378     if (local_err) {
 379         error_report_err(local_err);
 380     }
 381
 382 }