1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26#include "qemu/osdep.h"
27#include "qapi/error.h"
28#include "hw/ide.h"
29#include "hw/pci/pci.h"
30#include "hw/xen/xen_common.h"
31#include "migration/vmstate.h"
32#include "hw/xen/xen-legacy-backend.h"
33#include "trace.h"
34#include "sysemu/xen.h"
35#include "sysemu/block-backend.h"
36#include "qemu/error-report.h"
37#include "qemu/module.h"
38#include "qom/object.h"
39
40
41
42#ifdef DEBUG_PLATFORM
43#define DPRINTF(fmt, ...) do { \
44 fprintf(stderr, "xen_platform: " fmt, ## __VA_ARGS__); \
45} while (0)
46#else
47#define DPRINTF(fmt, ...) do { } while (0)
48#endif
49
50#define PFFLAG_ROM_LOCK 1
51
52struct PCIXenPlatformState {
53
54 PCIDevice parent_obj;
55
56
57 MemoryRegion fixed_io;
58 MemoryRegion bar;
59 MemoryRegion mmio_bar;
60 uint8_t flags;
61 uint16_t driver_product_version;
62
63
64 char log_buffer[4096];
65 int log_buffer_off;
66};
67
68#define TYPE_XEN_PLATFORM "xen-platform"
69OBJECT_DECLARE_SIMPLE_TYPE(PCIXenPlatformState, XEN_PLATFORM)
70
71#define XEN_PLATFORM_IOPORT 0x10
72
73
74static void log_writeb(PCIXenPlatformState *s, char val)
75{
76 if (val == '\n' || s->log_buffer_off == sizeof(s->log_buffer) - 1) {
77
78 s->log_buffer[s->log_buffer_off] = 0;
79 trace_xen_platform_log(s->log_buffer);
80 s->log_buffer_off = 0;
81 } else {
82 s->log_buffer[s->log_buffer_off++] = val;
83 }
84}
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99#define _UNPLUG_IDE_SCSI_DISKS 0
100#define UNPLUG_IDE_SCSI_DISKS (1u << _UNPLUG_IDE_SCSI_DISKS)
101
102#define _UNPLUG_ALL_NICS 1
103#define UNPLUG_ALL_NICS (1u << _UNPLUG_ALL_NICS)
104
105#define _UNPLUG_AUX_IDE_DISKS 2
106#define UNPLUG_AUX_IDE_DISKS (1u << _UNPLUG_AUX_IDE_DISKS)
107
108#define _UNPLUG_NVME_DISKS 3
109#define UNPLUG_NVME_DISKS (1u << _UNPLUG_NVME_DISKS)
110
111static void unplug_nic(PCIBus *b, PCIDevice *d, void *o)
112{
113
114 if (pci_get_word(d->config + PCI_CLASS_DEVICE) ==
115 PCI_CLASS_NETWORK_ETHERNET
116 && strcmp(d->name, "xen-pci-passthrough") != 0) {
117 object_unparent(OBJECT(d));
118 }
119}
120
121
122static void del_nic_peer(NICState *nic, void *opaque)
123{
124 NetClientState *nc;
125
126 nc = qemu_get_queue(nic);
127 if (nc->peer)
128 qemu_del_net_client(nc->peer);
129}
130
131static void pci_unplug_nics(PCIBus *bus)
132{
133 qemu_foreach_nic(del_nic_peer, NULL);
134 pci_for_each_device(bus, 0, unplug_nic, NULL);
135}
136
137static void unplug_disks(PCIBus *b, PCIDevice *d, void *opaque)
138{
139 uint32_t flags = *(uint32_t *)opaque;
140 bool aux = (flags & UNPLUG_AUX_IDE_DISKS) &&
141 !(flags & UNPLUG_IDE_SCSI_DISKS);
142
143
144 if (!strcmp(d->name, "xen-pci-passthrough")) {
145 return;
146 }
147
148 switch (pci_get_word(d->config + PCI_CLASS_DEVICE)) {
149 case PCI_CLASS_STORAGE_IDE:
150 pci_piix3_xen_ide_unplug(DEVICE(d), aux);
151 break;
152
153 case PCI_CLASS_STORAGE_SCSI:
154 if (!aux) {
155 object_unparent(OBJECT(d));
156 }
157 break;
158
159 case PCI_CLASS_STORAGE_EXPRESS:
160 if (flags & UNPLUG_NVME_DISKS) {
161 object_unparent(OBJECT(d));
162 }
163
164 default:
165 break;
166 }
167}
168
169static void pci_unplug_disks(PCIBus *bus, uint32_t flags)
170{
171 pci_for_each_device(bus, 0, unplug_disks, &flags);
172}
173
174static void platform_fixed_ioport_writew(void *opaque, uint32_t addr, uint32_t val)
175{
176 PCIXenPlatformState *s = opaque;
177
178 switch (addr) {
179 case 0: {
180 PCIDevice *pci_dev = PCI_DEVICE(s);
181
182 if (val & (UNPLUG_IDE_SCSI_DISKS | UNPLUG_AUX_IDE_DISKS |
183 UNPLUG_NVME_DISKS)) {
184 DPRINTF("unplug disks\n");
185 pci_unplug_disks(pci_get_bus(pci_dev), val);
186 }
187 if (val & UNPLUG_ALL_NICS) {
188 DPRINTF("unplug nics\n");
189 pci_unplug_nics(pci_get_bus(pci_dev));
190 }
191 break;
192 }
193 case 2:
194 switch (val) {
195 case 1:
196 DPRINTF("Citrix Windows PV drivers loaded in guest\n");
197 break;
198 case 0:
199 DPRINTF("Guest claimed to be running PV product 0?\n");
200 break;
201 default:
202 DPRINTF("Unknown PV product %d loaded in guest\n", val);
203 break;
204 }
205 s->driver_product_version = val;
206 break;
207 }
208}
209
210static void platform_fixed_ioport_writel(void *opaque, uint32_t addr,
211 uint32_t val)
212{
213 switch (addr) {
214 case 0:
215
216 break;
217 }
218}
219
220static void platform_fixed_ioport_writeb(void *opaque, uint32_t addr, uint32_t val)
221{
222 PCIXenPlatformState *s = opaque;
223
224 switch (addr) {
225 case 0: {
226 hvmmem_type_t mem_type = (val & PFFLAG_ROM_LOCK) ?
227 HVMMEM_ram_ro : HVMMEM_ram_rw;
228 if (xen_set_mem_type(xen_domid, mem_type, 0xc0, 0x40)) {
229 DPRINTF("unable to change ro/rw state of ROM memory area!\n");
230 } else {
231 s->flags = val & PFFLAG_ROM_LOCK;
232 DPRINTF("changed ro/rw state of ROM memory area. now is %s state.\n",
233 (mem_type == HVMMEM_ram_ro ? "ro":"rw"));
234 }
235 break;
236 }
237 case 2:
238 log_writeb(s, val);
239 break;
240 }
241}
242
243static uint32_t platform_fixed_ioport_readw(void *opaque, uint32_t addr)
244{
245 switch (addr) {
246 case 0:
247
248 return 0x49d2;
249 default:
250 return 0xffff;
251 }
252}
253
254static uint32_t platform_fixed_ioport_readb(void *opaque, uint32_t addr)
255{
256 PCIXenPlatformState *s = opaque;
257
258 switch (addr) {
259 case 0:
260
261 return s->flags;
262 case 2:
263
264 return 1;
265 default:
266 return 0xff;
267 }
268}
269
270static void platform_fixed_ioport_reset(void *opaque)
271{
272 PCIXenPlatformState *s = opaque;
273
274 platform_fixed_ioport_writeb(s, 0, 0);
275}
276
277static uint64_t platform_fixed_ioport_read(void *opaque,
278 hwaddr addr,
279 unsigned size)
280{
281 switch (size) {
282 case 1:
283 return platform_fixed_ioport_readb(opaque, addr);
284 case 2:
285 return platform_fixed_ioport_readw(opaque, addr);
286 default:
287 return -1;
288 }
289}
290
291static void platform_fixed_ioport_write(void *opaque, hwaddr addr,
292
293 uint64_t val, unsigned size)
294{
295 switch (size) {
296 case 1:
297 platform_fixed_ioport_writeb(opaque, addr, val);
298 break;
299 case 2:
300 platform_fixed_ioport_writew(opaque, addr, val);
301 break;
302 case 4:
303 platform_fixed_ioport_writel(opaque, addr, val);
304 break;
305 }
306}
307
308
309static const MemoryRegionOps platform_fixed_io_ops = {
310 .read = platform_fixed_ioport_read,
311 .write = platform_fixed_ioport_write,
312 .valid = {
313 .unaligned = true,
314 },
315 .impl = {
316 .min_access_size = 1,
317 .max_access_size = 4,
318 .unaligned = true,
319 },
320 .endianness = DEVICE_LITTLE_ENDIAN,
321};
322
323static void platform_fixed_ioport_init(PCIXenPlatformState* s)
324{
325 memory_region_init_io(&s->fixed_io, OBJECT(s), &platform_fixed_io_ops, s,
326 "xen-fixed", 16);
327 memory_region_add_subregion(get_system_io(), XEN_PLATFORM_IOPORT,
328 &s->fixed_io);
329}
330
331
332
333static uint64_t xen_platform_ioport_readb(void *opaque, hwaddr addr,
334 unsigned int size)
335{
336 if (addr == 0) {
337 return platform_fixed_ioport_readb(opaque, 0);
338 } else {
339 return ~0u;
340 }
341}
342
343static void xen_platform_ioport_writeb(void *opaque, hwaddr addr,
344 uint64_t val, unsigned int size)
345{
346 PCIXenPlatformState *s = opaque;
347 PCIDevice *pci_dev = PCI_DEVICE(s);
348
349 switch (addr) {
350 case 0:
351 platform_fixed_ioport_writeb(opaque, 0, (uint32_t)val);
352 break;
353 case 4:
354 if (val == 1) {
355
356
357
358
359
360
361
362
363 pci_unplug_disks(pci_get_bus(pci_dev), UNPLUG_IDE_SCSI_DISKS);
364 pci_unplug_nics(pci_get_bus(pci_dev));
365 }
366 break;
367 case 8:
368 switch (val) {
369 case 1:
370 pci_unplug_disks(pci_get_bus(pci_dev), UNPLUG_IDE_SCSI_DISKS);
371 break;
372 case 2:
373 pci_unplug_nics(pci_get_bus(pci_dev));
374 break;
375 default:
376 log_writeb(s, (uint32_t)val);
377 break;
378 }
379 break;
380 default:
381 break;
382 }
383}
384
385static const MemoryRegionOps xen_pci_io_ops = {
386 .read = xen_platform_ioport_readb,
387 .write = xen_platform_ioport_writeb,
388 .impl.min_access_size = 1,
389 .impl.max_access_size = 1,
390};
391
392static void platform_ioport_bar_setup(PCIXenPlatformState *d)
393{
394 memory_region_init_io(&d->bar, OBJECT(d), &xen_pci_io_ops, d,
395 "xen-pci", 0x100);
396}
397
398static uint64_t platform_mmio_read(void *opaque, hwaddr addr,
399 unsigned size)
400{
401 DPRINTF("Warning: attempted read from physical address "
402 "0x" TARGET_FMT_plx " in xen platform mmio space\n", addr);
403
404 return 0;
405}
406
407static void platform_mmio_write(void *opaque, hwaddr addr,
408 uint64_t val, unsigned size)
409{
410 DPRINTF("Warning: attempted write of 0x%"PRIx64" to physical "
411 "address 0x" TARGET_FMT_plx " in xen platform mmio space\n",
412 val, addr);
413}
414
415static const MemoryRegionOps platform_mmio_handler = {
416 .read = &platform_mmio_read,
417 .write = &platform_mmio_write,
418 .endianness = DEVICE_NATIVE_ENDIAN,
419};
420
421static void platform_mmio_setup(PCIXenPlatformState *d)
422{
423 memory_region_init_io(&d->mmio_bar, OBJECT(d), &platform_mmio_handler, d,
424 "xen-mmio", 0x1000000);
425}
426
427static int xen_platform_post_load(void *opaque, int version_id)
428{
429 PCIXenPlatformState *s = opaque;
430
431 platform_fixed_ioport_writeb(s, 0, s->flags);
432
433 return 0;
434}
435
436static const VMStateDescription vmstate_xen_platform = {
437 .name = "platform",
438 .version_id = 4,
439 .minimum_version_id = 4,
440 .post_load = xen_platform_post_load,
441 .fields = (VMStateField[]) {
442 VMSTATE_PCI_DEVICE(parent_obj, PCIXenPlatformState),
443 VMSTATE_UINT8(flags, PCIXenPlatformState),
444 VMSTATE_END_OF_LIST()
445 }
446};
447
448static void xen_platform_realize(PCIDevice *dev, Error **errp)
449{
450 PCIXenPlatformState *d = XEN_PLATFORM(dev);
451 uint8_t *pci_conf;
452
453
454 if (!xen_enabled()) {
455 error_setg(errp, "xen-platform device requires the Xen accelerator");
456 return;
457 }
458
459 pci_conf = dev->config;
460
461 pci_set_word(pci_conf + PCI_COMMAND, PCI_COMMAND_IO | PCI_COMMAND_MEMORY);
462
463 pci_config_set_prog_interface(pci_conf, 0);
464
465 pci_conf[PCI_INTERRUPT_PIN] = 1;
466
467 platform_ioport_bar_setup(d);
468 pci_register_bar(dev, 0, PCI_BASE_ADDRESS_SPACE_IO, &d->bar);
469
470
471 platform_mmio_setup(d);
472 pci_register_bar(dev, 1, PCI_BASE_ADDRESS_MEM_PREFETCH,
473 &d->mmio_bar);
474
475 platform_fixed_ioport_init(d);
476}
477
478static void platform_reset(DeviceState *dev)
479{
480 PCIXenPlatformState *s = XEN_PLATFORM(dev);
481
482 platform_fixed_ioport_reset(s);
483}
484
485static void xen_platform_class_init(ObjectClass *klass, void *data)
486{
487 DeviceClass *dc = DEVICE_CLASS(klass);
488 PCIDeviceClass *k = PCI_DEVICE_CLASS(klass);
489
490 k->realize = xen_platform_realize;
491 k->vendor_id = PCI_VENDOR_ID_XEN;
492 k->device_id = PCI_DEVICE_ID_XEN_PLATFORM;
493 k->class_id = PCI_CLASS_OTHERS << 8 | 0x80;
494 k->subsystem_vendor_id = PCI_VENDOR_ID_XEN;
495 k->subsystem_id = PCI_DEVICE_ID_XEN_PLATFORM;
496 k->revision = 1;
497 set_bit(DEVICE_CATEGORY_MISC, dc->categories);
498 dc->desc = "XEN platform pci device";
499 dc->reset = platform_reset;
500 dc->vmsd = &vmstate_xen_platform;
501}
502
503static const TypeInfo xen_platform_info = {
504 .name = TYPE_XEN_PLATFORM,
505 .parent = TYPE_PCI_DEVICE,
506 .instance_size = sizeof(PCIXenPlatformState),
507 .class_init = xen_platform_class_init,
508 .interfaces = (InterfaceInfo[]) {
509 { INTERFACE_CONVENTIONAL_PCI_DEVICE },
510 { },
511 },
512};
513
514static void xen_platform_register_types(void)
515{
516 type_register_static(&xen_platform_info);
517}
518
519type_init(xen_platform_register_types)
520