1 /* 2 * Machine for remote device 3 * 4 * This machine type is used by the remote device process in multi-process 5 * QEMU. QEMU device models depend on parent busses, interrupt controllers, 6 * memory regions, etc. The remote machine type offers this environment so 7 * that QEMU device models can be used as remote devices. 8 * 9 * Copyright © 2018, 2021 Oracle and/or its affiliates. 10 * 11 * This work is licensed under the terms of the GNU GPL, version 2 or later. 12 * See the COPYING file in the top-level directory. 13 * 14 */ 15 16 #include "qemu/osdep.h" 17 18 #include "hw/remote/machine.h" 19 #include "exec/memory.h" 20 #include "qapi/error.h" 21 #include "hw/pci/pci_host.h" 22 #include "hw/remote/iohub.h" 23 #include "hw/remote/iommu.h" 24 #include "hw/qdev-core.h" 25 #include "hw/remote/vfio-user-obj.h" 26 #include "hw/pci/msi.h" 27 28 static void remote_machine_init(MachineState *machine) 29 { 30 MemoryRegion *system_memory, *system_io, *pci_memory; 31 RemoteMachineState *s = REMOTE_MACHINE(machine); 32 RemotePCIHost *rem_host; 33 PCIHostState *pci_host; 34 35 system_memory = get_system_memory(); 36 system_io = get_system_io(); 37 38 pci_memory = g_new(MemoryRegion, 1); 39 memory_region_init(pci_memory, NULL, "pci", UINT64_MAX); 40 41 rem_host = REMOTE_PCIHOST(qdev_new(TYPE_REMOTE_PCIHOST)); 42 43 rem_host->mr_pci_mem = pci_memory; 44 rem_host->mr_sys_mem = system_memory; 45 rem_host->mr_sys_io = system_io; 46 47 s->host = rem_host; 48 49 object_property_add_child(OBJECT(s), "remote-pcihost", OBJECT(rem_host)); 50 memory_region_add_subregion_overlap(system_memory, 0x0, pci_memory, -1); 51 52 qdev_realize(DEVICE(rem_host), sysbus_get_default(), &error_fatal); 53 54 pci_host = PCI_HOST_BRIDGE(rem_host); 55 56 if (s->vfio_user) { 57 remote_iommu_setup(pci_host->bus); 58 59 msi_nonbroken = true; 60 61 vfu_object_set_bus_irq(pci_host->bus); 62 } else { 63 remote_iohub_init(&s->iohub); 64 65 pci_bus_irqs(pci_host->bus, remote_iohub_set_irq, 66 &s->iohub, REMOTE_IOHUB_NB_PIRQS); 67 pci_bus_map_irqs(pci_host->bus, remote_iohub_map_irq); 68 } 69 70 qbus_set_hotplug_handler(BUS(pci_host->bus), OBJECT(s)); 71 } 72 73 static bool remote_machine_get_vfio_user(Object *obj, Error **errp) 74 { 75 RemoteMachineState *s = REMOTE_MACHINE(obj); 76 77 return s->vfio_user; 78 } 79 80 static void remote_machine_set_vfio_user(Object *obj, bool value, Error **errp) 81 { 82 RemoteMachineState *s = REMOTE_MACHINE(obj); 83 84 if (phase_check(PHASE_MACHINE_CREATED)) { 85 error_setg(errp, "Error enabling vfio-user - machine already created"); 86 return; 87 } 88 89 s->vfio_user = value; 90 } 91 92 static bool remote_machine_get_auto_shutdown(Object *obj, Error **errp) 93 { 94 RemoteMachineState *s = REMOTE_MACHINE(obj); 95 96 return s->auto_shutdown; 97 } 98 99 static void remote_machine_set_auto_shutdown(Object *obj, bool value, 100 Error **errp) 101 { 102 RemoteMachineState *s = REMOTE_MACHINE(obj); 103 104 s->auto_shutdown = value; 105 } 106 107 static void remote_machine_instance_init(Object *obj) 108 { 109 RemoteMachineState *s = REMOTE_MACHINE(obj); 110 111 s->auto_shutdown = true; 112 } 113 114 static void remote_machine_dev_unplug_cb(HotplugHandler *hotplug_dev, 115 DeviceState *dev, Error **errp) 116 { 117 qdev_unrealize(dev); 118 119 if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) { 120 remote_iommu_unplug_dev(PCI_DEVICE(dev)); 121 } 122 } 123 124 static void remote_machine_class_init(ObjectClass *oc, void *data) 125 { 126 MachineClass *mc = MACHINE_CLASS(oc); 127 HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc); 128 129 mc->init = remote_machine_init; 130 mc->desc = "Experimental remote machine"; 131 132 hc->unplug = remote_machine_dev_unplug_cb; 133 134 object_class_property_add_bool(oc, "vfio-user", 135 remote_machine_get_vfio_user, 136 remote_machine_set_vfio_user); 137 138 object_class_property_add_bool(oc, "auto-shutdown", 139 remote_machine_get_auto_shutdown, 140 remote_machine_set_auto_shutdown); 141 } 142 143 static const TypeInfo remote_machine = { 144 .name = TYPE_REMOTE_MACHINE, 145 .parent = TYPE_MACHINE, 146 .instance_size = sizeof(RemoteMachineState), 147 .instance_init = remote_machine_instance_init, 148 .class_init = remote_machine_class_init, 149 .interfaces = (InterfaceInfo[]) { 150 { TYPE_HOTPLUG_HANDLER }, 151 { } 152 } 153 }; 154 155 static void remote_machine_register_types(void) 156 { 157 type_register_static(&remote_machine); 158 } 159 160 type_init(remote_machine_register_types); 161