]>
Commit | Line | Data |
---|---|---|
0b9a2443 DH |
1 | /* |
2 | * Virtio MEM PCI device | |
3 | * | |
4 | * Copyright (C) 2020 Red Hat, Inc. | |
5 | * | |
6 | * Authors: | |
7 | * David Hildenbrand <david@redhat.com> | |
8 | * | |
9 | * This work is licensed under the terms of the GNU GPL, version 2. | |
10 | * See the COPYING file in the top-level directory. | |
11 | */ | |
12 | ||
13 | #include "qemu/osdep.h" | |
14 | #include "virtio-mem-pci.h" | |
15 | #include "hw/mem/memory-device.h" | |
16 | #include "qapi/error.h" | |
b495ec6c | 17 | #include "qapi/qapi-events-machine.h" |
722a3c78 | 18 | #include "qapi/qapi-events-misc.h" |
0b9a2443 DH |
19 | |
20 | static void virtio_mem_pci_realize(VirtIOPCIProxy *vpci_dev, Error **errp) | |
21 | { | |
22 | VirtIOMEMPCI *mem_pci = VIRTIO_MEM_PCI(vpci_dev); | |
23 | DeviceState *vdev = DEVICE(&mem_pci->vdev); | |
24 | ||
c22aba19 DH |
25 | virtio_pci_force_virtio_1(vpci_dev); |
26 | qdev_realize(vdev, BUS(&vpci_dev->bus), errp); | |
0b9a2443 DH |
27 | } |
28 | ||
29 | static void virtio_mem_pci_set_addr(MemoryDeviceState *md, uint64_t addr, | |
30 | Error **errp) | |
31 | { | |
5325cc34 | 32 | object_property_set_uint(OBJECT(md), VIRTIO_MEM_ADDR_PROP, addr, errp); |
0b9a2443 DH |
33 | } |
34 | ||
35 | static uint64_t virtio_mem_pci_get_addr(const MemoryDeviceState *md) | |
36 | { | |
37 | return object_property_get_uint(OBJECT(md), VIRTIO_MEM_ADDR_PROP, | |
38 | &error_abort); | |
39 | } | |
40 | ||
41 | static MemoryRegion *virtio_mem_pci_get_memory_region(MemoryDeviceState *md, | |
42 | Error **errp) | |
43 | { | |
44 | VirtIOMEMPCI *pci_mem = VIRTIO_MEM_PCI(md); | |
7d5b0d68 | 45 | VirtIOMEM *vmem = &pci_mem->vdev; |
0b9a2443 DH |
46 | VirtIOMEMClass *vmc = VIRTIO_MEM_GET_CLASS(vmem); |
47 | ||
48 | return vmc->get_memory_region(vmem, errp); | |
49 | } | |
50 | ||
51 | static uint64_t virtio_mem_pci_get_plugged_size(const MemoryDeviceState *md, | |
52 | Error **errp) | |
53 | { | |
54 | return object_property_get_uint(OBJECT(md), VIRTIO_MEM_SIZE_PROP, | |
55 | errp); | |
56 | } | |
57 | ||
58 | static void virtio_mem_pci_fill_device_info(const MemoryDeviceState *md, | |
59 | MemoryDeviceInfo *info) | |
60 | { | |
61 | VirtioMEMDeviceInfo *vi = g_new0(VirtioMEMDeviceInfo, 1); | |
62 | VirtIOMEMPCI *pci_mem = VIRTIO_MEM_PCI(md); | |
7d5b0d68 | 63 | VirtIOMEM *vmem = &pci_mem->vdev; |
0b9a2443 DH |
64 | VirtIOMEMClass *vpc = VIRTIO_MEM_GET_CLASS(vmem); |
65 | DeviceState *dev = DEVICE(md); | |
66 | ||
67 | if (dev->id) { | |
0b9a2443 DH |
68 | vi->id = g_strdup(dev->id); |
69 | } | |
70 | ||
71 | /* let the real device handle everything else */ | |
72 | vpc->fill_device_info(vmem, vi); | |
73 | ||
74 | info->u.virtio_mem.data = vi; | |
75 | info->type = MEMORY_DEVICE_INFO_KIND_VIRTIO_MEM; | |
76 | } | |
77 | ||
296e88fd DH |
78 | static uint64_t virtio_mem_pci_get_min_alignment(const MemoryDeviceState *md) |
79 | { | |
80 | return object_property_get_uint(OBJECT(md), VIRTIO_MEM_BLOCK_SIZE_PROP, | |
81 | &error_abort); | |
82 | } | |
83 | ||
722a3c78 DH |
84 | static void virtio_mem_pci_size_change_notify(Notifier *notifier, void *data) |
85 | { | |
86 | VirtIOMEMPCI *pci_mem = container_of(notifier, VirtIOMEMPCI, | |
87 | size_change_notifier); | |
88 | DeviceState *dev = DEVICE(pci_mem); | |
d89dd28f | 89 | char *qom_path = object_get_canonical_path(OBJECT(dev)); |
722a3c78 | 90 | const uint64_t * const size_p = data; |
722a3c78 | 91 | |
fe8ac1fa | 92 | qapi_event_send_memory_device_size_change(dev->id, *size_p, qom_path); |
d89dd28f | 93 | g_free(qom_path); |
722a3c78 DH |
94 | } |
95 | ||
339a8bbd DH |
96 | static void virtio_mem_pci_unplug_request_check(VirtIOMDPCI *vmd, Error **errp) |
97 | { | |
98 | VirtIOMEMPCI *pci_mem = VIRTIO_MEM_PCI(vmd); | |
99 | VirtIOMEM *vmem = &pci_mem->vdev; | |
100 | VirtIOMEMClass *vpc = VIRTIO_MEM_GET_CLASS(vmem); | |
101 | ||
102 | vpc->unplug_request_check(vmem, errp); | |
103 | } | |
104 | ||
105 | static void virtio_mem_pci_get_requested_size(Object *obj, Visitor *v, | |
106 | const char *name, void *opaque, | |
107 | Error **errp) | |
108 | { | |
109 | VirtIOMEMPCI *pci_mem = VIRTIO_MEM_PCI(obj); | |
110 | ||
111 | object_property_get(OBJECT(&pci_mem->vdev), name, v, errp); | |
112 | } | |
113 | ||
114 | static void virtio_mem_pci_set_requested_size(Object *obj, Visitor *v, | |
115 | const char *name, void *opaque, | |
116 | Error **errp) | |
117 | { | |
118 | VirtIOMEMPCI *pci_mem = VIRTIO_MEM_PCI(obj); | |
119 | DeviceState *dev = DEVICE(obj); | |
120 | ||
121 | /* | |
122 | * If we passed virtio_mem_pci_unplug_request_check(), making sure that | |
123 | * the requested size is 0, don't allow modifying the requested size | |
124 | * anymore, otherwise the VM might end up hotplugging memory before | |
125 | * handling the unplug request. | |
126 | */ | |
127 | if (dev->pending_deleted_event) { | |
128 | error_setg(errp, "'%s' cannot be changed if the device is in the" | |
129 | " process of unplug", name); | |
130 | return; | |
131 | } | |
132 | ||
133 | object_property_set(OBJECT(&pci_mem->vdev), name, v, errp); | |
134 | } | |
135 | ||
0b9a2443 DH |
136 | static void virtio_mem_pci_class_init(ObjectClass *klass, void *data) |
137 | { | |
138 | DeviceClass *dc = DEVICE_CLASS(klass); | |
139 | VirtioPCIClass *k = VIRTIO_PCI_CLASS(klass); | |
140 | PCIDeviceClass *pcidev_k = PCI_DEVICE_CLASS(klass); | |
141 | MemoryDeviceClass *mdc = MEMORY_DEVICE_CLASS(klass); | |
339a8bbd | 142 | VirtIOMDPCIClass *vmdc = VIRTIO_MD_PCI_CLASS(klass); |
0b9a2443 DH |
143 | |
144 | k->realize = virtio_mem_pci_realize; | |
145 | set_bit(DEVICE_CATEGORY_MISC, dc->categories); | |
0b9a2443 DH |
146 | pcidev_k->revision = VIRTIO_PCI_ABI_VERSION; |
147 | pcidev_k->class_id = PCI_CLASS_OTHERS; | |
148 | ||
149 | mdc->get_addr = virtio_mem_pci_get_addr; | |
150 | mdc->set_addr = virtio_mem_pci_set_addr; | |
151 | mdc->get_plugged_size = virtio_mem_pci_get_plugged_size; | |
152 | mdc->get_memory_region = virtio_mem_pci_get_memory_region; | |
153 | mdc->fill_device_info = virtio_mem_pci_fill_device_info; | |
296e88fd | 154 | mdc->get_min_alignment = virtio_mem_pci_get_min_alignment; |
339a8bbd DH |
155 | |
156 | vmdc->unplug_request_check = virtio_mem_pci_unplug_request_check; | |
0b9a2443 DH |
157 | } |
158 | ||
159 | static void virtio_mem_pci_instance_init(Object *obj) | |
160 | { | |
161 | VirtIOMEMPCI *dev = VIRTIO_MEM_PCI(obj); | |
722a3c78 DH |
162 | VirtIOMEMClass *vmc; |
163 | VirtIOMEM *vmem; | |
0b9a2443 DH |
164 | |
165 | virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev), | |
166 | TYPE_VIRTIO_MEM); | |
722a3c78 DH |
167 | |
168 | dev->size_change_notifier.notify = virtio_mem_pci_size_change_notify; | |
7d5b0d68 | 169 | vmem = &dev->vdev; |
722a3c78 DH |
170 | vmc = VIRTIO_MEM_GET_CLASS(vmem); |
171 | /* | |
172 | * We never remove the notifier again, as we expect both devices to | |
173 | * disappear at the same time. | |
174 | */ | |
175 | vmc->add_size_change_notifier(vmem, &dev->size_change_notifier); | |
176 | ||
0b9a2443 DH |
177 | object_property_add_alias(obj, VIRTIO_MEM_BLOCK_SIZE_PROP, |
178 | OBJECT(&dev->vdev), VIRTIO_MEM_BLOCK_SIZE_PROP); | |
179 | object_property_add_alias(obj, VIRTIO_MEM_SIZE_PROP, OBJECT(&dev->vdev), | |
180 | VIRTIO_MEM_SIZE_PROP); | |
339a8bbd DH |
181 | object_property_add(obj, VIRTIO_MEM_REQUESTED_SIZE_PROP, "size", |
182 | virtio_mem_pci_get_requested_size, | |
183 | virtio_mem_pci_set_requested_size, NULL, NULL); | |
0b9a2443 DH |
184 | } |
185 | ||
186 | static const VirtioPCIDeviceTypeInfo virtio_mem_pci_info = { | |
187 | .base_name = TYPE_VIRTIO_MEM_PCI, | |
18129c15 | 188 | .parent = TYPE_VIRTIO_MD_PCI, |
0b9a2443 DH |
189 | .generic_name = "virtio-mem-pci", |
190 | .instance_size = sizeof(VirtIOMEMPCI), | |
191 | .instance_init = virtio_mem_pci_instance_init, | |
192 | .class_init = virtio_mem_pci_class_init, | |
0b9a2443 DH |
193 | }; |
194 | ||
195 | static void virtio_mem_pci_register_types(void) | |
196 | { | |
197 | virtio_pci_types_register(&virtio_mem_pci_info); | |
198 | } | |
199 | type_init(virtio_mem_pci_register_types) |