xref: /illumos-kvm-cmd/hw/virtio-pci.c (revision 68396ea9)
1 /*
2  * Virtio PCI Bindings
3  *
4  * Copyright IBM, Corp. 2007
5  * Copyright (c) 2009 CodeSourcery
6  *
7  * Authors:
8  *  Anthony Liguori   <aliguori@us.ibm.com>
9  *  Paul Brook        <paul@codesourcery.com>
10  *
11  * This work is licensed under the terms of the GNU GPL, version 2.  See
12  * the COPYING file in the top-level directory.
13  *
14  */
15 
16 #include <inttypes.h>
17 
18 #include "virtio.h"
19 #include "virtio-blk.h"
20 #include "virtio-net.h"
21 #include "pci.h"
22 #include "qemu-error.h"
23 #include "msix.h"
24 #include "net.h"
25 #include "loader.h"
26 #include "kvm.h"
27 #include "blockdev.h"
28 
29 /* from Linux's linux/virtio_pci.h */
30 
31 /* A 32-bit r/o bitmask of the features supported by the host */
32 #define VIRTIO_PCI_HOST_FEATURES        0
33 
34 /* A 32-bit r/w bitmask of features activated by the guest */
35 #define VIRTIO_PCI_GUEST_FEATURES       4
36 
37 /* A 32-bit r/w PFN for the currently selected queue */
38 #define VIRTIO_PCI_QUEUE_PFN            8
39 
40 /* A 16-bit r/o queue size for the currently selected queue */
41 #define VIRTIO_PCI_QUEUE_NUM            12
42 
43 /* A 16-bit r/w queue selector */
44 #define VIRTIO_PCI_QUEUE_SEL            14
45 
46 /* A 16-bit r/w queue notifier */
47 #define VIRTIO_PCI_QUEUE_NOTIFY         16
48 
49 /* An 8-bit device status register.  */
50 #define VIRTIO_PCI_STATUS               18
51 
52 /* An 8-bit r/o interrupt status register.  Reading the value will return the
53  * current contents of the ISR and will also clear it.  This is effectively
54  * a read-and-acknowledge. */
55 #define VIRTIO_PCI_ISR                  19
56 
57 /* MSI-X registers: only enabled if MSI-X is enabled. */
58 /* A 16-bit vector for configuration changes. */
59 #define VIRTIO_MSI_CONFIG_VECTOR        20
60 /* A 16-bit vector for selected queue notifications. */
61 #define VIRTIO_MSI_QUEUE_VECTOR         22
62 
63 /* Config space size */
64 #define VIRTIO_PCI_CONFIG_NOMSI         20
65 #define VIRTIO_PCI_CONFIG_MSI           24
66 #define VIRTIO_PCI_REGION_SIZE(dev)     (msix_present(dev) ? \
67                                          VIRTIO_PCI_CONFIG_MSI : \
68                                          VIRTIO_PCI_CONFIG_NOMSI)
69 
70 /* The remaining space is defined by each driver as the per-driver
71  * configuration space */
72 #define VIRTIO_PCI_CONFIG(dev)          (msix_enabled(dev) ? \
73                                          VIRTIO_PCI_CONFIG_MSI : \
74                                          VIRTIO_PCI_CONFIG_NOMSI)
75 
76 /* Virtio ABI version, if we increment this, we break the guest driver. */
77 #define VIRTIO_PCI_ABI_VERSION          0
78 
79 /* How many bits to shift physical queue address written to QUEUE_PFN.
80  * 12 is historical, and due to x86 page size. */
81 #define VIRTIO_PCI_QUEUE_ADDR_SHIFT    12
82 
83 /* Flags track per-device state like workarounds for quirks in older guests. */
84 #define VIRTIO_PCI_FLAG_BUS_MASTER_BUG  (1 << 0)
85 
86 /* Performance improves when virtqueue kick processing is decoupled from the
87  * vcpu thread using ioeventfd for some devices. */
88 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT 1
89 #define VIRTIO_PCI_FLAG_USE_IOEVENTFD   (1 << VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT)
90 
91 /* QEMU doesn't strictly need write barriers since everything runs in
92  * lock-step.  We'll leave the calls to wmb() in though to make it obvious for
93  * KVM or if kqemu gets SMP support.
94  */
95 #define wmb() do { } while (0)
96 
97 /* PCI bindings.  */
98 
99 typedef struct {
100     PCIDevice pci_dev;
101     VirtIODevice *vdev;
102     uint32_t flags;
103     uint32_t addr;
104     uint32_t class_code;
105     uint32_t nvectors;
106     BlockConf block;
107     NICConf nic;
108     uint32_t host_features;
109 #ifdef CONFIG_LINUX
110     V9fsConf fsconf;
111 #endif
112     /* Max. number of ports we can have for a the virtio-serial device */
113     uint32_t max_virtserial_ports;
114     virtio_net_conf net;
115     bool ioeventfd_disabled;
116     bool ioeventfd_started;
117 } VirtIOPCIProxy;
118 
119 /* virtio device */
120 
virtio_pci_notify(void * opaque,uint16_t vector)121 static void virtio_pci_notify(void *opaque, uint16_t vector)
122 {
123     VirtIOPCIProxy *proxy = opaque;
124     if (msix_enabled(&proxy->pci_dev))
125         msix_notify(&proxy->pci_dev, vector);
126     else
127         qemu_set_irq(proxy->pci_dev.irq[0], proxy->vdev->isr & 1);
128 }
129 
virtio_pci_save_config(void * opaque,QEMUFile * f)130 static void virtio_pci_save_config(void * opaque, QEMUFile *f)
131 {
132     VirtIOPCIProxy *proxy = opaque;
133     pci_device_save(&proxy->pci_dev, f);
134     msix_save(&proxy->pci_dev, f);
135     if (msix_present(&proxy->pci_dev))
136         qemu_put_be16(f, proxy->vdev->config_vector);
137 }
138 
virtio_pci_save_queue(void * opaque,int n,QEMUFile * f)139 static void virtio_pci_save_queue(void * opaque, int n, QEMUFile *f)
140 {
141     VirtIOPCIProxy *proxy = opaque;
142     if (msix_present(&proxy->pci_dev))
143         qemu_put_be16(f, virtio_queue_vector(proxy->vdev, n));
144 }
145 
virtio_pci_load_config(void * opaque,QEMUFile * f)146 static int virtio_pci_load_config(void * opaque, QEMUFile *f)
147 {
148     VirtIOPCIProxy *proxy = opaque;
149     int ret;
150     ret = pci_device_load(&proxy->pci_dev, f);
151     if (ret) {
152         return ret;
153     }
154     msix_load(&proxy->pci_dev, f);
155     if (msix_present(&proxy->pci_dev)) {
156         qemu_get_be16s(f, &proxy->vdev->config_vector);
157     } else {
158         proxy->vdev->config_vector = VIRTIO_NO_VECTOR;
159     }
160     if (proxy->vdev->config_vector != VIRTIO_NO_VECTOR) {
161         return msix_vector_use(&proxy->pci_dev, proxy->vdev->config_vector);
162     }
163     return 0;
164 }
165 
virtio_pci_load_queue(void * opaque,int n,QEMUFile * f)166 static int virtio_pci_load_queue(void * opaque, int n, QEMUFile *f)
167 {
168     VirtIOPCIProxy *proxy = opaque;
169     uint16_t vector;
170     if (msix_present(&proxy->pci_dev)) {
171         qemu_get_be16s(f, &vector);
172     } else {
173         vector = VIRTIO_NO_VECTOR;
174     }
175     virtio_queue_set_vector(proxy->vdev, n, vector);
176     if (vector != VIRTIO_NO_VECTOR) {
177         return msix_vector_use(&proxy->pci_dev, vector);
178     }
179     return 0;
180 }
181 
virtio_pci_set_host_notifier_internal(VirtIOPCIProxy * proxy,int n,bool assign)182 static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
183                                                  int n, bool assign)
184 {
185     VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
186     EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
187     int r;
188     if (assign) {
189         r = event_notifier_init(notifier, 1);
190         if (r < 0) {
191             error_report("%s: unable to init event notifier: %d",
192                          __func__, r);
193             return r;
194         }
195         r = kvm_set_ioeventfd_pio_word(event_notifier_get_fd(notifier),
196                                        proxy->addr + VIRTIO_PCI_QUEUE_NOTIFY,
197                                        n, assign);
198         if (r < 0) {
199             error_report("%s: unable to map ioeventfd: %d",
200                          __func__, r);
201             event_notifier_cleanup(notifier);
202         }
203     } else {
204         r = kvm_set_ioeventfd_pio_word(event_notifier_get_fd(notifier),
205                                        proxy->addr + VIRTIO_PCI_QUEUE_NOTIFY,
206                                        n, assign);
207         if (r < 0) {
208             error_report("%s: unable to unmap ioeventfd: %d",
209                          __func__, r);
210             return r;
211         }
212 
213         /* Handle the race condition where the guest kicked and we deassigned
214          * before we got around to handling the kick.
215          */
216         if (event_notifier_test_and_clear(notifier)) {
217             virtio_queue_notify_vq(vq);
218         }
219 
220         event_notifier_cleanup(notifier);
221     }
222     return r;
223 }
224 
virtio_pci_host_notifier_read(void * opaque)225 static void virtio_pci_host_notifier_read(void *opaque)
226 {
227     VirtQueue *vq = opaque;
228     EventNotifier *n = virtio_queue_get_host_notifier(vq);
229     if (event_notifier_test_and_clear(n)) {
230         virtio_queue_notify_vq(vq);
231     }
232 }
233 
virtio_pci_set_host_notifier_fd_handler(VirtIOPCIProxy * proxy,int n,bool assign)234 static void virtio_pci_set_host_notifier_fd_handler(VirtIOPCIProxy *proxy,
235                                                     int n, bool assign)
236 {
237     VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
238     EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
239     if (assign) {
240         qemu_set_fd_handler(event_notifier_get_fd(notifier),
241                             virtio_pci_host_notifier_read, NULL, vq);
242     } else {
243         qemu_set_fd_handler(event_notifier_get_fd(notifier),
244                             NULL, NULL, NULL);
245     }
246 }
247 
virtio_pci_start_ioeventfd(VirtIOPCIProxy * proxy)248 static void virtio_pci_start_ioeventfd(VirtIOPCIProxy *proxy)
249 {
250     int n, r;
251 
252     if (!(proxy->flags & VIRTIO_PCI_FLAG_USE_IOEVENTFD) ||
253         proxy->ioeventfd_disabled ||
254         proxy->ioeventfd_started) {
255         return;
256     }
257 
258     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
259         if (!virtio_queue_get_num(proxy->vdev, n)) {
260             continue;
261         }
262 
263         r = virtio_pci_set_host_notifier_internal(proxy, n, true);
264         if (r < 0) {
265             goto assign_error;
266         }
267 
268         virtio_pci_set_host_notifier_fd_handler(proxy, n, true);
269     }
270     proxy->ioeventfd_started = true;
271     return;
272 
273 assign_error:
274     while (--n >= 0) {
275         if (!virtio_queue_get_num(proxy->vdev, n)) {
276             continue;
277         }
278 
279         virtio_pci_set_host_notifier_fd_handler(proxy, n, false);
280         r = virtio_pci_set_host_notifier_internal(proxy, n, false);
281         assert(r >= 0);
282     }
283     proxy->ioeventfd_started = false;
284     error_report("%s: failed. Fallback to a userspace (slower).", __func__);
285 }
286 
virtio_pci_stop_ioeventfd(VirtIOPCIProxy * proxy)287 static void virtio_pci_stop_ioeventfd(VirtIOPCIProxy *proxy)
288 {
289     int r;
290     int n;
291 
292     if (!proxy->ioeventfd_started) {
293         return;
294     }
295 
296     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
297         if (!virtio_queue_get_num(proxy->vdev, n)) {
298             continue;
299         }
300 
301         virtio_pci_set_host_notifier_fd_handler(proxy, n, false);
302         r = virtio_pci_set_host_notifier_internal(proxy, n, false);
303         assert(r >= 0);
304     }
305     proxy->ioeventfd_started = false;
306 }
307 
virtio_pci_reset(DeviceState * d)308 static void virtio_pci_reset(DeviceState *d)
309 {
310     VirtIOPCIProxy *proxy = container_of(d, VirtIOPCIProxy, pci_dev.qdev);
311     virtio_pci_stop_ioeventfd(proxy);
312     virtio_reset(proxy->vdev);
313     msix_reset(&proxy->pci_dev);
314     proxy->flags &= ~VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
315 }
316 
virtio_ioport_write(void * opaque,uint32_t addr,uint32_t val)317 static void virtio_ioport_write(void *opaque, uint32_t addr, uint32_t val)
318 {
319     VirtIOPCIProxy *proxy = opaque;
320     VirtIODevice *vdev = proxy->vdev;
321     target_phys_addr_t pa;
322 
323     switch (addr) {
324     case VIRTIO_PCI_GUEST_FEATURES:
325 	/* Guest does not negotiate properly?  We have to assume nothing. */
326 	if (val & (1 << VIRTIO_F_BAD_FEATURE)) {
327 	    if (vdev->bad_features)
328 		val = proxy->host_features & vdev->bad_features(vdev);
329 	    else
330 		val = 0;
331 	}
332         if (vdev->set_features)
333             vdev->set_features(vdev, val);
334         vdev->guest_features = val;
335         break;
336     case VIRTIO_PCI_QUEUE_PFN:
337         pa = (target_phys_addr_t)val << VIRTIO_PCI_QUEUE_ADDR_SHIFT;
338         if (pa == 0) {
339             virtio_pci_stop_ioeventfd(proxy);
340             virtio_reset(proxy->vdev);
341             msix_unuse_all_vectors(&proxy->pci_dev);
342         }
343         else
344             virtio_queue_set_addr(vdev, vdev->queue_sel, pa);
345         break;
346     case VIRTIO_PCI_QUEUE_SEL:
347         if (val < VIRTIO_PCI_QUEUE_MAX)
348             vdev->queue_sel = val;
349         break;
350     case VIRTIO_PCI_QUEUE_NOTIFY:
351         virtio_queue_notify(vdev, val);
352         break;
353     case VIRTIO_PCI_STATUS:
354         if (!(val & VIRTIO_CONFIG_S_DRIVER_OK)) {
355             virtio_pci_stop_ioeventfd(proxy);
356         }
357 
358         virtio_set_status(vdev, val & 0xFF);
359 
360         if (val & VIRTIO_CONFIG_S_DRIVER_OK) {
361             virtio_pci_start_ioeventfd(proxy);
362         }
363 
364         if (vdev->status == 0) {
365             virtio_reset(proxy->vdev);
366             msix_unuse_all_vectors(&proxy->pci_dev);
367         }
368 
369         /* Linux before 2.6.34 sets the device as OK without enabling
370            the PCI device bus master bit. In this case we need to disable
371            some safety checks. */
372         if ((val & VIRTIO_CONFIG_S_DRIVER_OK) &&
373             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
374             proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
375         }
376         break;
377     case VIRTIO_MSI_CONFIG_VECTOR:
378         msix_vector_unuse(&proxy->pci_dev, vdev->config_vector);
379         /* Make it possible for guest to discover an error took place. */
380         if (msix_vector_use(&proxy->pci_dev, val) < 0)
381             val = VIRTIO_NO_VECTOR;
382         vdev->config_vector = val;
383         break;
384     case VIRTIO_MSI_QUEUE_VECTOR:
385         msix_vector_unuse(&proxy->pci_dev,
386                           virtio_queue_vector(vdev, vdev->queue_sel));
387         /* Make it possible for guest to discover an error took place. */
388         if (msix_vector_use(&proxy->pci_dev, val) < 0)
389             val = VIRTIO_NO_VECTOR;
390         virtio_queue_set_vector(vdev, vdev->queue_sel, val);
391         break;
392     default:
393         error_report("%s: unexpected address 0x%x value 0x%x",
394                      __func__, addr, val);
395         break;
396     }
397 }
398 
virtio_ioport_read(VirtIOPCIProxy * proxy,uint32_t addr)399 static uint32_t virtio_ioport_read(VirtIOPCIProxy *proxy, uint32_t addr)
400 {
401     VirtIODevice *vdev = proxy->vdev;
402     uint32_t ret = 0xFFFFFFFF;
403 
404     switch (addr) {
405     case VIRTIO_PCI_HOST_FEATURES:
406         ret = proxy->host_features;
407         break;
408     case VIRTIO_PCI_GUEST_FEATURES:
409         ret = vdev->guest_features;
410         break;
411     case VIRTIO_PCI_QUEUE_PFN:
412         ret = virtio_queue_get_addr(vdev, vdev->queue_sel)
413               >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
414         break;
415     case VIRTIO_PCI_QUEUE_NUM:
416         ret = virtio_queue_get_num(vdev, vdev->queue_sel);
417         break;
418     case VIRTIO_PCI_QUEUE_SEL:
419         ret = vdev->queue_sel;
420         break;
421     case VIRTIO_PCI_STATUS:
422         ret = vdev->status;
423         break;
424     case VIRTIO_PCI_ISR:
425         /* reading from the ISR also clears it. */
426         ret = vdev->isr;
427         vdev->isr = 0;
428         qemu_set_irq(proxy->pci_dev.irq[0], 0);
429         break;
430     case VIRTIO_MSI_CONFIG_VECTOR:
431         ret = vdev->config_vector;
432         break;
433     case VIRTIO_MSI_QUEUE_VECTOR:
434         ret = virtio_queue_vector(vdev, vdev->queue_sel);
435         break;
436     default:
437         break;
438     }
439 
440     return ret;
441 }
442 
virtio_pci_config_readb(void * opaque,uint32_t addr)443 static uint32_t virtio_pci_config_readb(void *opaque, uint32_t addr)
444 {
445     VirtIOPCIProxy *proxy = opaque;
446     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
447     addr -= proxy->addr;
448     if (addr < config)
449         return virtio_ioport_read(proxy, addr);
450     addr -= config;
451     return virtio_config_readb(proxy->vdev, addr);
452 }
453 
virtio_pci_config_readw(void * opaque,uint32_t addr)454 static uint32_t virtio_pci_config_readw(void *opaque, uint32_t addr)
455 {
456     VirtIOPCIProxy *proxy = opaque;
457     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
458     addr -= proxy->addr;
459     if (addr < config)
460         return virtio_ioport_read(proxy, addr);
461     addr -= config;
462     return virtio_config_readw(proxy->vdev, addr);
463 }
464 
virtio_pci_config_readl(void * opaque,uint32_t addr)465 static uint32_t virtio_pci_config_readl(void *opaque, uint32_t addr)
466 {
467     VirtIOPCIProxy *proxy = opaque;
468     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
469     addr -= proxy->addr;
470     if (addr < config)
471         return virtio_ioport_read(proxy, addr);
472     addr -= config;
473     return virtio_config_readl(proxy->vdev, addr);
474 }
475 
virtio_pci_config_writeb(void * opaque,uint32_t addr,uint32_t val)476 static void virtio_pci_config_writeb(void *opaque, uint32_t addr, uint32_t val)
477 {
478     VirtIOPCIProxy *proxy = opaque;
479     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
480     addr -= proxy->addr;
481     if (addr < config) {
482         virtio_ioport_write(proxy, addr, val);
483         return;
484     }
485     addr -= config;
486     virtio_config_writeb(proxy->vdev, addr, val);
487 }
488 
virtio_pci_config_writew(void * opaque,uint32_t addr,uint32_t val)489 static void virtio_pci_config_writew(void *opaque, uint32_t addr, uint32_t val)
490 {
491     VirtIOPCIProxy *proxy = opaque;
492     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
493     addr -= proxy->addr;
494     if (addr < config) {
495         virtio_ioport_write(proxy, addr, val);
496         return;
497     }
498     addr -= config;
499     virtio_config_writew(proxy->vdev, addr, val);
500 }
501 
virtio_pci_config_writel(void * opaque,uint32_t addr,uint32_t val)502 static void virtio_pci_config_writel(void *opaque, uint32_t addr, uint32_t val)
503 {
504     VirtIOPCIProxy *proxy = opaque;
505     uint32_t config = VIRTIO_PCI_CONFIG(&proxy->pci_dev);
506     addr -= proxy->addr;
507     if (addr < config) {
508         virtio_ioport_write(proxy, addr, val);
509         return;
510     }
511     addr -= config;
512     virtio_config_writel(proxy->vdev, addr, val);
513 }
514 
virtio_map(PCIDevice * pci_dev,int region_num,pcibus_t addr,pcibus_t size,int type)515 static void virtio_map(PCIDevice *pci_dev, int region_num,
516                        pcibus_t addr, pcibus_t size, int type)
517 {
518     VirtIOPCIProxy *proxy = container_of(pci_dev, VirtIOPCIProxy, pci_dev);
519     VirtIODevice *vdev = proxy->vdev;
520     unsigned config_len = VIRTIO_PCI_REGION_SIZE(pci_dev) + vdev->config_len;
521 
522     proxy->addr = addr;
523 
524     register_ioport_write(addr, config_len, 1, virtio_pci_config_writeb, proxy);
525     register_ioport_write(addr, config_len, 2, virtio_pci_config_writew, proxy);
526     register_ioport_write(addr, config_len, 4, virtio_pci_config_writel, proxy);
527     register_ioport_read(addr, config_len, 1, virtio_pci_config_readb, proxy);
528     register_ioport_read(addr, config_len, 2, virtio_pci_config_readw, proxy);
529     register_ioport_read(addr, config_len, 4, virtio_pci_config_readl, proxy);
530 
531     if (vdev->config_len)
532         vdev->get_config(vdev, vdev->config);
533 }
534 
virtio_write_config(PCIDevice * pci_dev,uint32_t address,uint32_t val,int len)535 static void virtio_write_config(PCIDevice *pci_dev, uint32_t address,
536                                 uint32_t val, int len)
537 {
538     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
539 
540     if (PCI_COMMAND == address) {
541         if (!(val & PCI_COMMAND_MASTER)) {
542             if (!(proxy->flags & VIRTIO_PCI_FLAG_BUS_MASTER_BUG)) {
543                 virtio_pci_stop_ioeventfd(proxy);
544                 virtio_set_status(proxy->vdev,
545                                   proxy->vdev->status & ~VIRTIO_CONFIG_S_DRIVER_OK);
546             }
547         }
548     }
549 
550     pci_default_write_config(pci_dev, address, val, len);
551     msix_write_config(pci_dev, address, val, len);
552 }
553 
virtio_pci_get_features(void * opaque)554 static unsigned virtio_pci_get_features(void *opaque)
555 {
556     VirtIOPCIProxy *proxy = opaque;
557     return proxy->host_features;
558 }
559 
virtio_pci_guest_notifier_read(void * opaque)560 static void virtio_pci_guest_notifier_read(void *opaque)
561 {
562     VirtQueue *vq = opaque;
563     EventNotifier *n = virtio_queue_get_guest_notifier(vq);
564     if (event_notifier_test_and_clear(n)) {
565         virtio_irq(vq);
566     }
567 }
568 
virtio_pci_mask_vq(PCIDevice * dev,unsigned vector,VirtQueue * vq,int masked)569 static int virtio_pci_mask_vq(PCIDevice *dev, unsigned vector,
570                               VirtQueue *vq, int masked)
571 {
572 #ifdef CONFIG_KVM
573     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
574     int r = kvm_set_irqfd(dev->msix_irq_entries[vector].gsi,
575                           event_notifier_get_fd(notifier),
576                           !masked);
577     if (r < 0) {
578         return (r == -ENOSYS) ? 0 : r;
579     }
580     if (masked) {
581         qemu_set_fd_handler(event_notifier_get_fd(notifier),
582                             virtio_pci_guest_notifier_read, NULL, vq);
583     } else {
584         qemu_set_fd_handler(event_notifier_get_fd(notifier),
585                             NULL, NULL, NULL);
586     }
587     return 0;
588 #else
589     return -ENOSYS;
590 #endif
591 }
592 
virtio_pci_mask_notifier(PCIDevice * dev,unsigned vector,int masked)593 static int virtio_pci_mask_notifier(PCIDevice *dev, unsigned vector,
594                                     int masked)
595 {
596     VirtIOPCIProxy *proxy = container_of(dev, VirtIOPCIProxy, pci_dev);
597     VirtIODevice *vdev = proxy->vdev;
598     int r, n;
599 
600     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
601         if (!virtio_queue_get_num(vdev, n)) {
602             break;
603         }
604         if (virtio_queue_vector(vdev, n) != vector) {
605             continue;
606         }
607         r = virtio_pci_mask_vq(dev, vector, virtio_get_queue(vdev, n), masked);
608         if (r < 0) {
609             goto undo;
610         }
611     }
612     return 0;
613 undo:
614     while (--n >= 0) {
615         if (virtio_queue_vector(vdev, n) != vector) {
616             continue;
617         }
618         virtio_pci_mask_vq(dev, vector, virtio_get_queue(vdev, n), !masked);
619     }
620     return r;
621 }
622 
623 
virtio_pci_set_guest_notifier(void * opaque,int n,bool assign)624 static int virtio_pci_set_guest_notifier(void *opaque, int n, bool assign)
625 {
626     VirtIOPCIProxy *proxy = opaque;
627     VirtQueue *vq = virtio_get_queue(proxy->vdev, n);
628     EventNotifier *notifier = virtio_queue_get_guest_notifier(vq);
629 
630     if (assign) {
631         int r = event_notifier_init(notifier, 0);
632         if (r < 0) {
633             return r;
634         }
635         qemu_set_fd_handler(event_notifier_get_fd(notifier),
636                             virtio_pci_guest_notifier_read, NULL, vq);
637     } else {
638         qemu_set_fd_handler(event_notifier_get_fd(notifier),
639                             NULL, NULL, NULL);
640         /* Test and clear notifier before closing it,
641          * in case poll callback didn't have time to run. */
642         virtio_pci_guest_notifier_read(vq);
643         event_notifier_cleanup(notifier);
644     }
645 
646     return 0;
647 }
648 
virtio_pci_query_guest_notifiers(void * opaque)649 static bool virtio_pci_query_guest_notifiers(void *opaque)
650 {
651     VirtIOPCIProxy *proxy = opaque;
652     return msix_enabled(&proxy->pci_dev);
653 }
654 
virtio_pci_set_guest_notifiers(void * opaque,bool assign)655 static int virtio_pci_set_guest_notifiers(void *opaque, bool assign)
656 {
657     VirtIOPCIProxy *proxy = opaque;
658     VirtIODevice *vdev = proxy->vdev;
659     int r, n;
660 
661     /* Must unset mask notifier while guest notifier
662      * is still assigned */
663     if (!assign) {
664 	    r = msix_unset_mask_notifier(&proxy->pci_dev);
665             assert(r >= 0);
666     }
667 
668     for (n = 0; n < VIRTIO_PCI_QUEUE_MAX; n++) {
669         if (!virtio_queue_get_num(vdev, n)) {
670             break;
671         }
672 
673         r = virtio_pci_set_guest_notifier(opaque, n, assign);
674         if (r < 0) {
675             goto assign_error;
676         }
677     }
678 
679     /* Must set mask notifier after guest notifier
680      * has been assigned */
681     if (assign) {
682         r = msix_set_mask_notifier(&proxy->pci_dev,
683                                    virtio_pci_mask_notifier);
684         if (r < 0) {
685             goto assign_error;
686         }
687     }
688 
689     return 0;
690 
691 assign_error:
692     /* We get here on assignment failure. Recover by undoing for VQs 0 .. n. */
693     if (assign) {
694         msix_unset_mask_notifier(&proxy->pci_dev);
695     }
696 
697     while (--n >= 0) {
698         virtio_pci_set_guest_notifier(opaque, n, !assign);
699     }
700 
701     if (!assign) {
702         msix_set_mask_notifier(&proxy->pci_dev,
703                                virtio_pci_mask_notifier);
704     }
705     return r;
706 }
707 
virtio_pci_set_host_notifier(void * opaque,int n,bool assign)708 static int virtio_pci_set_host_notifier(void *opaque, int n, bool assign)
709 {
710     VirtIOPCIProxy *proxy = opaque;
711 
712     /* Stop using ioeventfd for virtqueue kick if the device starts using host
713      * notifiers.  This makes it easy to avoid stepping on each others' toes.
714      */
715     proxy->ioeventfd_disabled = assign;
716     if (assign) {
717         virtio_pci_stop_ioeventfd(proxy);
718     }
719     /* We don't need to start here: it's not needed because backend
720      * currently only stops on status change away from ok,
721      * reset, vmstop and such. If we do add code to start here,
722      * need to check vmstate, device state etc. */
723     return virtio_pci_set_host_notifier_internal(proxy, n, assign);
724 }
725 
virtio_pci_vmstate_change(void * opaque,bool running)726 static void virtio_pci_vmstate_change(void *opaque, bool running)
727 {
728     VirtIOPCIProxy *proxy = opaque;
729 
730     if (running) {
731         /* Try to find out if the guest has bus master disabled, but is
732            in ready state. Then we have a buggy guest OS. */
733         if ((proxy->vdev->status & VIRTIO_CONFIG_S_DRIVER_OK) &&
734             !(proxy->pci_dev.config[PCI_COMMAND] & PCI_COMMAND_MASTER)) {
735             proxy->flags |= VIRTIO_PCI_FLAG_BUS_MASTER_BUG;
736         }
737         virtio_pci_start_ioeventfd(proxy);
738     } else {
739         virtio_pci_stop_ioeventfd(proxy);
740     }
741 }
742 
743 static const VirtIOBindings virtio_pci_bindings = {
744     .notify = virtio_pci_notify,
745     .save_config = virtio_pci_save_config,
746     .load_config = virtio_pci_load_config,
747     .save_queue = virtio_pci_save_queue,
748     .load_queue = virtio_pci_load_queue,
749     .get_features = virtio_pci_get_features,
750     .query_guest_notifiers = virtio_pci_query_guest_notifiers,
751     .set_host_notifier = virtio_pci_set_host_notifier,
752     .set_guest_notifiers = virtio_pci_set_guest_notifiers,
753     .vmstate_change = virtio_pci_vmstate_change,
754 };
755 
virtio_init_pci(VirtIOPCIProxy * proxy,VirtIODevice * vdev,uint16_t vendor,uint16_t device,uint16_t class_code,uint8_t pif)756 static void virtio_init_pci(VirtIOPCIProxy *proxy, VirtIODevice *vdev,
757                             uint16_t vendor, uint16_t device,
758                             uint16_t class_code, uint8_t pif)
759 {
760     uint8_t *config;
761     uint32_t size;
762 
763     proxy->vdev = vdev;
764 
765     config = proxy->pci_dev.config;
766     pci_config_set_vendor_id(config, vendor);
767     pci_config_set_device_id(config, device);
768 
769     config[0x08] = VIRTIO_PCI_ABI_VERSION;
770 
771     config[0x09] = pif;
772     pci_config_set_class(config, class_code);
773 
774     config[0x2c] = vendor & 0xFF;
775     config[0x2d] = (vendor >> 8) & 0xFF;
776     config[0x2e] = vdev->device_id & 0xFF;
777     config[0x2f] = (vdev->device_id >> 8) & 0xFF;
778 
779     config[0x3d] = 1;
780 
781     if (vdev->nvectors && !msix_init(&proxy->pci_dev, vdev->nvectors, 1, 0)) {
782         pci_register_bar(&proxy->pci_dev, 1,
783                          msix_bar_size(&proxy->pci_dev),
784                          PCI_BASE_ADDRESS_SPACE_MEMORY,
785                          msix_mmio_map);
786     } else
787         vdev->nvectors = 0;
788 
789     proxy->pci_dev.config_write = virtio_write_config;
790 
791     size = VIRTIO_PCI_REGION_SIZE(&proxy->pci_dev) + vdev->config_len;
792     if (size & (size-1))
793         size = 1 << qemu_fls(size);
794 
795     pci_register_bar(&proxy->pci_dev, 0, size, PCI_BASE_ADDRESS_SPACE_IO,
796                            virtio_map);
797 
798     if (!kvm_has_many_ioeventfds()) {
799         proxy->flags &= ~VIRTIO_PCI_FLAG_USE_IOEVENTFD;
800     }
801 
802     virtio_bind_device(vdev, &virtio_pci_bindings, proxy);
803     proxy->host_features |= 0x1 << VIRTIO_F_NOTIFY_ON_EMPTY;
804     proxy->host_features |= 0x1 << VIRTIO_F_BAD_FEATURE;
805     proxy->host_features = vdev->get_features(vdev, proxy->host_features);
806 }
807 
virtio_blk_init_pci(PCIDevice * pci_dev)808 static int virtio_blk_init_pci(PCIDevice *pci_dev)
809 {
810     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
811     VirtIODevice *vdev;
812 
813     if (proxy->class_code != PCI_CLASS_STORAGE_SCSI &&
814         proxy->class_code != PCI_CLASS_STORAGE_OTHER)
815         proxy->class_code = PCI_CLASS_STORAGE_SCSI;
816 
817     vdev = virtio_blk_init(&pci_dev->qdev, &proxy->block);
818     if (!vdev) {
819         return -1;
820     }
821     vdev->nvectors = proxy->nvectors;
822     virtio_init_pci(proxy, vdev,
823                     PCI_VENDOR_ID_REDHAT_QUMRANET,
824                     PCI_DEVICE_ID_VIRTIO_BLOCK,
825                     proxy->class_code, 0x00);
826     /* make the actual value visible */
827     proxy->nvectors = vdev->nvectors;
828     return 0;
829 }
830 
virtio_exit_pci(PCIDevice * pci_dev)831 static int virtio_exit_pci(PCIDevice *pci_dev)
832 {
833     return msix_uninit(pci_dev);
834 }
835 
virtio_blk_exit_pci(PCIDevice * pci_dev)836 static int virtio_blk_exit_pci(PCIDevice *pci_dev)
837 {
838     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
839 
840     virtio_pci_stop_ioeventfd(proxy);
841     virtio_blk_exit(proxy->vdev);
842     blockdev_mark_auto_del(proxy->block.bs);
843     return virtio_exit_pci(pci_dev);
844 }
845 
virtio_serial_init_pci(PCIDevice * pci_dev)846 static int virtio_serial_init_pci(PCIDevice *pci_dev)
847 {
848     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
849     VirtIODevice *vdev;
850 
851     if (proxy->class_code != PCI_CLASS_COMMUNICATION_OTHER &&
852         proxy->class_code != PCI_CLASS_DISPLAY_OTHER && /* qemu 0.10 */
853         proxy->class_code != PCI_CLASS_OTHERS)          /* qemu-kvm  */
854         proxy->class_code = PCI_CLASS_COMMUNICATION_OTHER;
855 
856     vdev = virtio_serial_init(&pci_dev->qdev, proxy->max_virtserial_ports);
857     if (!vdev) {
858         return -1;
859     }
860     vdev->nvectors = proxy->nvectors == DEV_NVECTORS_UNSPECIFIED
861                                         ? proxy->max_virtserial_ports + 1
862                                         : proxy->nvectors;
863     virtio_init_pci(proxy, vdev,
864                     PCI_VENDOR_ID_REDHAT_QUMRANET,
865                     PCI_DEVICE_ID_VIRTIO_CONSOLE,
866                     proxy->class_code, 0x00);
867     proxy->nvectors = vdev->nvectors;
868     return 0;
869 }
870 
virtio_serial_exit_pci(PCIDevice * pci_dev)871 static int virtio_serial_exit_pci(PCIDevice *pci_dev)
872 {
873     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
874 
875     virtio_serial_exit(proxy->vdev);
876     return virtio_exit_pci(pci_dev);
877 }
878 
virtio_net_init_pci(PCIDevice * pci_dev)879 static int virtio_net_init_pci(PCIDevice *pci_dev)
880 {
881     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
882     VirtIODevice *vdev;
883 
884     vdev = virtio_net_init(&pci_dev->qdev, &proxy->nic, &proxy->net);
885 
886     vdev->nvectors = proxy->nvectors;
887     virtio_init_pci(proxy, vdev,
888                     PCI_VENDOR_ID_REDHAT_QUMRANET,
889                     PCI_DEVICE_ID_VIRTIO_NET,
890                     PCI_CLASS_NETWORK_ETHERNET,
891                     0x00);
892 
893     /* make the actual value visible */
894     proxy->nvectors = vdev->nvectors;
895     return 0;
896 }
897 
virtio_net_exit_pci(PCIDevice * pci_dev)898 static int virtio_net_exit_pci(PCIDevice *pci_dev)
899 {
900     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
901 
902     virtio_pci_stop_ioeventfd(proxy);
903     virtio_net_exit(proxy->vdev);
904     return virtio_exit_pci(pci_dev);
905 }
906 
virtio_balloon_init_pci(PCIDevice * pci_dev)907 static int virtio_balloon_init_pci(PCIDevice *pci_dev)
908 {
909     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
910     VirtIODevice *vdev;
911 
912     vdev = virtio_balloon_init(&pci_dev->qdev);
913     virtio_init_pci(proxy, vdev,
914                     PCI_VENDOR_ID_REDHAT_QUMRANET,
915                     PCI_DEVICE_ID_VIRTIO_BALLOON,
916                     PCI_CLASS_MEMORY_RAM,
917                     0x00);
918     return 0;
919 }
920 
921 #ifdef CONFIG_VIRTFS
virtio_9p_init_pci(PCIDevice * pci_dev)922 static int virtio_9p_init_pci(PCIDevice *pci_dev)
923 {
924     VirtIOPCIProxy *proxy = DO_UPCAST(VirtIOPCIProxy, pci_dev, pci_dev);
925     VirtIODevice *vdev;
926 
927     vdev = virtio_9p_init(&pci_dev->qdev, &proxy->fsconf);
928     vdev->nvectors = proxy->nvectors;
929     virtio_init_pci(proxy, vdev,
930                     PCI_VENDOR_ID_REDHAT_QUMRANET,
931                     0x1009,
932                     0x2,
933                     0x00);
934     /* make the actual value visible */
935     proxy->nvectors = vdev->nvectors;
936     return 0;
937 }
938 #endif
939 
940 static PCIDeviceInfo virtio_info[] = {
941     {
942         .qdev.name = "virtio-blk-pci",
943         .qdev.alias = "virtio-blk",
944         .qdev.size = sizeof(VirtIOPCIProxy),
945         .init      = virtio_blk_init_pci,
946         .exit      = virtio_blk_exit_pci,
947         .qdev.props = (Property[]) {
948             DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
949             DEFINE_BLOCK_PROPERTIES(VirtIOPCIProxy, block),
950             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
951                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, true),
952             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
953             DEFINE_VIRTIO_BLK_FEATURES(VirtIOPCIProxy, host_features),
954             DEFINE_PROP_END_OF_LIST(),
955         },
956         .qdev.reset = virtio_pci_reset,
957     },{
958         .qdev.name  = "virtio-net-pci",
959         .qdev.size  = sizeof(VirtIOPCIProxy),
960         .init       = virtio_net_init_pci,
961         .exit       = virtio_net_exit_pci,
962         .romfile    = "pxe-virtio.bin",
963         .qdev.props = (Property[]) {
964             DEFINE_PROP_BIT("ioeventfd", VirtIOPCIProxy, flags,
965                             VIRTIO_PCI_FLAG_USE_IOEVENTFD_BIT, false),
966             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 3),
967             DEFINE_VIRTIO_NET_FEATURES(VirtIOPCIProxy, host_features),
968             DEFINE_NIC_PROPERTIES(VirtIOPCIProxy, nic),
969             DEFINE_PROP_UINT32("x-txtimer", VirtIOPCIProxy,
970                                net.txtimer, TX_TIMER_INTERVAL),
971             DEFINE_PROP_INT32("x-txburst", VirtIOPCIProxy,
972                               net.txburst, TX_BURST),
973             DEFINE_PROP_STRING("tx", VirtIOPCIProxy, net.tx),
974             DEFINE_PROP_END_OF_LIST(),
975         },
976         .qdev.reset = virtio_pci_reset,
977     },{
978         .qdev.name = "virtio-serial-pci",
979         .qdev.alias = "virtio-serial",
980         .qdev.size = sizeof(VirtIOPCIProxy),
981         .init      = virtio_serial_init_pci,
982         .exit      = virtio_serial_exit_pci,
983         .qdev.props = (Property[]) {
984             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors,
985                                DEV_NVECTORS_UNSPECIFIED),
986             DEFINE_PROP_HEX32("class", VirtIOPCIProxy, class_code, 0),
987             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
988             DEFINE_PROP_UINT32("max_ports", VirtIOPCIProxy, max_virtserial_ports,
989                                31),
990             DEFINE_PROP_END_OF_LIST(),
991         },
992         .qdev.reset = virtio_pci_reset,
993     },{
994         .qdev.name = "virtio-balloon-pci",
995         .qdev.size = sizeof(VirtIOPCIProxy),
996         .init      = virtio_balloon_init_pci,
997         .exit      = virtio_exit_pci,
998         .qdev.props = (Property[]) {
999             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
1000             DEFINE_PROP_END_OF_LIST(),
1001         },
1002         .qdev.reset = virtio_pci_reset,
1003     },{
1004 #ifdef CONFIG_VIRTFS
1005         .qdev.name = "virtio-9p-pci",
1006         .qdev.size = sizeof(VirtIOPCIProxy),
1007         .init      = virtio_9p_init_pci,
1008         .qdev.props = (Property[]) {
1009             DEFINE_PROP_UINT32("vectors", VirtIOPCIProxy, nvectors, 2),
1010             DEFINE_VIRTIO_COMMON_FEATURES(VirtIOPCIProxy, host_features),
1011             DEFINE_PROP_STRING("mount_tag", VirtIOPCIProxy, fsconf.tag),
1012             DEFINE_PROP_STRING("fsdev", VirtIOPCIProxy, fsconf.fsdev_id),
1013             DEFINE_PROP_END_OF_LIST(),
1014         },
1015     }, {
1016 #endif
1017         /* end of list */
1018     }
1019 };
1020 
virtio_pci_register_devices(void)1021 static void virtio_pci_register_devices(void)
1022 {
1023     pci_qdev_register_many(virtio_info);
1024 }
1025 
1026 device_init(virtio_pci_register_devices)
1027