1 #include "kvm/virtio-pci.h"
2
3 #include "kvm/ioport.h"
4 #include "kvm/kvm.h"
5 #include "kvm/kvm-cpu.h"
6 #include "kvm/virtio-pci-dev.h"
7 #include "kvm/irq.h"
8 #include "kvm/virtio.h"
9 #include "kvm/ioeventfd.h"
10 #include "kvm/util.h"
11
12 #include <sys/ioctl.h>
13 #include <linux/virtio_pci.h>
14 #include <assert.h>
15 #include <string.h>
16
17 /* The bit of the ISR which indicates a queue change. */
18 #define VIRTIO_PCI_ISR_QUEUE 0x1
19
virtio_pci__add_msix_route(struct virtio_pci * vpci,u32 vec)20 int virtio_pci__add_msix_route(struct virtio_pci *vpci, u32 vec)
21 {
22 int gsi;
23 struct msi_msg *msg;
24
25 if (vec == VIRTIO_MSI_NO_VECTOR)
26 return -EINVAL;
27
28 msg = &vpci->msix_table[vec].msg;
29 gsi = irq__add_msix_route(vpci->kvm, msg, vpci->dev_hdr.dev_num << 3);
30 /*
31 * We don't need IRQ routing if we can use
32 * MSI injection via the KVM_SIGNAL_MSI ioctl.
33 */
34 if (gsi == -ENXIO && vpci->signal_msi)
35 return gsi;
36
37 if (gsi < 0)
38 die("failed to configure MSIs");
39
40 return gsi;
41 }
42
virtio_pci__del_msix_route(struct virtio_pci * vpci,u32 gsi)43 static void virtio_pci__del_msix_route(struct virtio_pci *vpci, u32 gsi)
44 {
45 struct msi_msg msg = { 0 };
46
47 irq__update_msix_route(vpci->kvm, gsi, &msg);
48 }
49
virtio_pci__ioevent_callback(struct kvm * kvm,void * param)50 static void virtio_pci__ioevent_callback(struct kvm *kvm, void *param)
51 {
52 struct virtio_pci_ioevent_param *ioeventfd = param;
53 struct virtio_pci *vpci = ioeventfd->vdev->virtio;
54
55 ioeventfd->vdev->ops->notify_vq(kvm, vpci->dev, ioeventfd->vq);
56 }
57
virtio_pci__init_ioeventfd(struct kvm * kvm,struct virtio_device * vdev,u32 vq)58 int virtio_pci__init_ioeventfd(struct kvm *kvm, struct virtio_device *vdev,
59 u32 vq)
60 {
61 struct ioevent ioevent;
62 struct virtio_pci *vpci = vdev->virtio;
63 u32 mmio_addr = virtio_pci__mmio_addr(vpci);
64 u16 port_addr = virtio_pci__port_addr(vpci);
65 off_t offset = vpci->doorbell_offset;
66 int r, flags = 0;
67 int pio_fd, mmio_fd;
68
69 vpci->ioeventfds[vq] = (struct virtio_pci_ioevent_param) {
70 .vdev = vdev,
71 .vq = vq,
72 };
73
74 ioevent = (struct ioevent) {
75 .fn = virtio_pci__ioevent_callback,
76 .fn_ptr = &vpci->ioeventfds[vq],
77 .datamatch = vq,
78 .fn_kvm = kvm,
79 };
80
81 /*
82 * Vhost will poll the eventfd in host kernel side, otherwise we
83 * need to poll in userspace.
84 */
85 if (!vdev->use_vhost)
86 flags |= IOEVENTFD_FLAG_USER_POLL;
87
88 /* ioport */
89 ioevent.io_addr = port_addr + offset;
90 ioevent.io_len = sizeof(u16);
91 ioevent.fd = pio_fd = eventfd(0, 0);
92 r = ioeventfd__add_event(&ioevent, flags | IOEVENTFD_FLAG_PIO);
93 if (r)
94 return r;
95
96 /* mmio */
97 ioevent.io_addr = mmio_addr + offset;
98 ioevent.io_len = sizeof(u16);
99 ioevent.fd = mmio_fd = eventfd(0, 0);
100 r = ioeventfd__add_event(&ioevent, flags);
101 if (r)
102 goto free_ioport_evt;
103
104 if (vdev->ops->notify_vq_eventfd)
105 vdev->ops->notify_vq_eventfd(kvm, vpci->dev, vq,
106 vdev->legacy ? pio_fd : mmio_fd);
107 return 0;
108
109 free_ioport_evt:
110 ioeventfd__del_event(port_addr + offset, vq);
111 return r;
112 }
113
virtio_pci_init_vq(struct kvm * kvm,struct virtio_device * vdev,int vq)114 int virtio_pci_init_vq(struct kvm *kvm, struct virtio_device *vdev, int vq)
115 {
116 int ret;
117 struct virtio_pci *vpci = vdev->virtio;
118
119 ret = virtio_pci__init_ioeventfd(kvm, vdev, vq);
120 if (ret) {
121 pr_err("couldn't add ioeventfd for vq %d: %d", vq, ret);
122 return ret;
123 }
124 return vdev->ops->init_vq(kvm, vpci->dev, vq);
125 }
126
virtio_pci_exit_vq(struct kvm * kvm,struct virtio_device * vdev,int vq)127 void virtio_pci_exit_vq(struct kvm *kvm, struct virtio_device *vdev, int vq)
128 {
129 struct virtio_pci *vpci = vdev->virtio;
130 u32 mmio_addr = virtio_pci__mmio_addr(vpci);
131 u16 port_addr = virtio_pci__port_addr(vpci);
132 off_t offset = vpci->doorbell_offset;
133
134 virtio_pci__del_msix_route(vpci, vpci->gsis[vq]);
135 vpci->gsis[vq] = 0;
136 vpci->vq_vector[vq] = VIRTIO_MSI_NO_VECTOR;
137 ioeventfd__del_event(mmio_addr + offset, vq);
138 ioeventfd__del_event(port_addr + offset, vq);
139 virtio_exit_vq(kvm, vdev, vpci->dev, vq);
140 }
141
update_msix_map(struct virtio_pci * vpci,struct msix_table * msix_entry,u32 vecnum)142 static void update_msix_map(struct virtio_pci *vpci,
143 struct msix_table *msix_entry, u32 vecnum)
144 {
145 u32 gsi, i;
146
147 /* Find the GSI number used for that vector */
148 if (vecnum == vpci->config_vector) {
149 gsi = vpci->config_gsi;
150 } else {
151 for (i = 0; i < VIRTIO_PCI_MAX_VQ; i++)
152 if (vpci->vq_vector[i] == vecnum)
153 break;
154 if (i == VIRTIO_PCI_MAX_VQ)
155 return;
156 gsi = vpci->gsis[i];
157 }
158
159 if (gsi == 0)
160 return;
161
162 msix_entry = &msix_entry[vecnum];
163 irq__update_msix_route(vpci->kvm, gsi, &msix_entry->msg);
164 }
165
virtio_pci__msix_mmio_callback(struct kvm_cpu * vcpu,u64 addr,u8 * data,u32 len,u8 is_write,void * ptr)166 static void virtio_pci__msix_mmio_callback(struct kvm_cpu *vcpu,
167 u64 addr, u8 *data, u32 len,
168 u8 is_write, void *ptr)
169 {
170 struct virtio_device *vdev = ptr;
171 struct virtio_pci *vpci = vdev->virtio;
172 struct msix_table *table;
173 u32 msix_io_addr = virtio_pci__msix_io_addr(vpci);
174 u32 pba_offset;
175 int vecnum;
176 size_t offset;
177
178 BUILD_BUG_ON(VIRTIO_NR_MSIX > (sizeof(vpci->msix_pba) * 8));
179
180 pba_offset = vpci->pci_hdr.msix.pba_offset & ~PCI_MSIX_TABLE_BIR;
181 if (addr >= msix_io_addr + pba_offset) {
182 /* Read access to PBA */
183 if (is_write)
184 return;
185 offset = addr - (msix_io_addr + pba_offset);
186 if ((offset + len) > sizeof (vpci->msix_pba))
187 return;
188 memcpy(data, (void *)&vpci->msix_pba + offset, len);
189 return;
190 }
191
192 table = vpci->msix_table;
193 offset = addr - msix_io_addr;
194
195 vecnum = offset / sizeof(struct msix_table);
196 offset = offset % sizeof(struct msix_table);
197
198 if (!is_write) {
199 memcpy(data, (void *)&table[vecnum] + offset, len);
200 return;
201 }
202
203 memcpy((void *)&table[vecnum] + offset, data, len);
204
205 /* Did we just update the address or payload? */
206 if (offset < offsetof(struct msix_table, ctrl))
207 update_msix_map(vpci, table, vecnum);
208 }
209
virtio_pci__signal_msi(struct kvm * kvm,struct virtio_pci * vpci,int vec)210 static void virtio_pci__signal_msi(struct kvm *kvm, struct virtio_pci *vpci,
211 int vec)
212 {
213 struct kvm_msi msi = {
214 .address_lo = vpci->msix_table[vec].msg.address_lo,
215 .address_hi = vpci->msix_table[vec].msg.address_hi,
216 .data = vpci->msix_table[vec].msg.data,
217 };
218
219 if (kvm->msix_needs_devid) {
220 msi.flags = KVM_MSI_VALID_DEVID;
221 msi.devid = vpci->dev_hdr.dev_num << 3;
222 }
223
224 irq__signal_msi(kvm, &msi);
225 }
226
virtio_pci__signal_vq(struct kvm * kvm,struct virtio_device * vdev,u32 vq)227 int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_device *vdev, u32 vq)
228 {
229 struct virtio_pci *vpci = vdev->virtio;
230 int tbl = vpci->vq_vector[vq];
231
232 if (virtio_pci__msix_enabled(vpci) && tbl != VIRTIO_MSI_NO_VECTOR) {
233 if (vpci->pci_hdr.msix.ctrl & cpu_to_le16(PCI_MSIX_FLAGS_MASKALL) ||
234 vpci->msix_table[tbl].ctrl & cpu_to_le16(PCI_MSIX_ENTRY_CTRL_MASKBIT)) {
235
236 vpci->msix_pba |= 1 << tbl;
237 return 0;
238 }
239
240 if (vpci->signal_msi)
241 virtio_pci__signal_msi(kvm, vpci, vpci->vq_vector[vq]);
242 else
243 kvm__irq_trigger(kvm, vpci->gsis[vq]);
244 } else {
245 vpci->isr |= VIRTIO_PCI_ISR_QUEUE;
246 kvm__irq_line(kvm, vpci->legacy_irq_line, VIRTIO_IRQ_HIGH);
247 }
248 return 0;
249 }
250
virtio_pci__signal_config(struct kvm * kvm,struct virtio_device * vdev)251 int virtio_pci__signal_config(struct kvm *kvm, struct virtio_device *vdev)
252 {
253 struct virtio_pci *vpci = vdev->virtio;
254 int tbl = vpci->config_vector;
255
256 if (virtio_pci__msix_enabled(vpci) && tbl != VIRTIO_MSI_NO_VECTOR) {
257 if (vpci->pci_hdr.msix.ctrl & cpu_to_le16(PCI_MSIX_FLAGS_MASKALL) ||
258 vpci->msix_table[tbl].ctrl & cpu_to_le16(PCI_MSIX_ENTRY_CTRL_MASKBIT)) {
259
260 vpci->msix_pba |= 1 << tbl;
261 return 0;
262 }
263
264 if (vpci->signal_msi)
265 virtio_pci__signal_msi(kvm, vpci, tbl);
266 else
267 kvm__irq_trigger(kvm, vpci->config_gsi);
268 } else {
269 vpci->isr |= VIRTIO_PCI_ISR_CONFIG;
270 kvm__irq_line(kvm, vpci->legacy_irq_line, VIRTIO_IRQ_HIGH);
271 }
272
273 return 0;
274 }
275
virtio_pci__bar_activate(struct kvm * kvm,struct pci_device_header * pci_hdr,int bar_num,void * data)276 static int virtio_pci__bar_activate(struct kvm *kvm,
277 struct pci_device_header *pci_hdr,
278 int bar_num, void *data)
279 {
280 struct virtio_device *vdev = data;
281 mmio_handler_fn mmio_fn;
282 u32 bar_addr, bar_size;
283 int r = -EINVAL;
284
285 if (vdev->legacy)
286 mmio_fn = &virtio_pci_legacy__io_mmio_callback;
287 else
288 mmio_fn = &virtio_pci_modern__io_mmio_callback;
289
290 assert(bar_num <= 2);
291
292 bar_addr = pci__bar_address(pci_hdr, bar_num);
293 bar_size = pci__bar_size(pci_hdr, bar_num);
294
295 switch (bar_num) {
296 case 0:
297 r = kvm__register_pio(kvm, bar_addr, bar_size, mmio_fn, vdev);
298 break;
299 case 1:
300 r = kvm__register_mmio(kvm, bar_addr, bar_size, false, mmio_fn,
301 vdev);
302 break;
303 case 2:
304 r = kvm__register_mmio(kvm, bar_addr, bar_size, false,
305 virtio_pci__msix_mmio_callback, vdev);
306 break;
307 }
308
309 return r;
310 }
311
virtio_pci__bar_deactivate(struct kvm * kvm,struct pci_device_header * pci_hdr,int bar_num,void * data)312 static int virtio_pci__bar_deactivate(struct kvm *kvm,
313 struct pci_device_header *pci_hdr,
314 int bar_num, void *data)
315 {
316 u32 bar_addr;
317 bool success;
318 int r = -EINVAL;
319
320 assert(bar_num <= 2);
321
322 bar_addr = pci__bar_address(pci_hdr, bar_num);
323
324 switch (bar_num) {
325 case 0:
326 r = kvm__deregister_pio(kvm, bar_addr);
327 break;
328 case 1:
329 case 2:
330 success = kvm__deregister_mmio(kvm, bar_addr);
331 /* kvm__deregister_mmio fails when the region is not found. */
332 r = (success ? 0 : -ENOENT);
333 break;
334 }
335
336 return r;
337 }
338
virtio_pci__init(struct kvm * kvm,void * dev,struct virtio_device * vdev,int device_id,int subsys_id,int class)339 int virtio_pci__init(struct kvm *kvm, void *dev, struct virtio_device *vdev,
340 int device_id, int subsys_id, int class)
341 {
342 struct virtio_pci *vpci = vdev->virtio;
343 u32 mmio_addr, msix_io_block;
344 u16 port_addr;
345 int r;
346
347 vpci->kvm = kvm;
348 vpci->dev = dev;
349
350 BUILD_BUG_ON(!is_power_of_two(PCI_IO_SIZE));
351
352 port_addr = pci_get_io_port_block(PCI_IO_SIZE);
353 mmio_addr = pci_get_mmio_block(PCI_IO_SIZE);
354 msix_io_block = pci_get_mmio_block(VIRTIO_MSIX_BAR_SIZE);
355
356 vpci->pci_hdr = (struct pci_device_header) {
357 .vendor_id = cpu_to_le16(PCI_VENDOR_ID_REDHAT_QUMRANET),
358 .device_id = cpu_to_le16(device_id),
359 .command = PCI_COMMAND_IO | PCI_COMMAND_MEMORY,
360 .header_type = PCI_HEADER_TYPE_NORMAL,
361 .revision_id = vdev->legacy ? 0 : 1,
362 .class[0] = class & 0xff,
363 .class[1] = (class >> 8) & 0xff,
364 .class[2] = (class >> 16) & 0xff,
365 .subsys_vendor_id = cpu_to_le16(PCI_SUBSYSTEM_VENDOR_ID_REDHAT_QUMRANET),
366 .subsys_id = cpu_to_le16(subsys_id),
367 .bar[0] = cpu_to_le32(port_addr
368 | PCI_BASE_ADDRESS_SPACE_IO),
369 .bar[1] = cpu_to_le32(mmio_addr
370 | PCI_BASE_ADDRESS_SPACE_MEMORY),
371 .bar[2] = cpu_to_le32(msix_io_block
372 | PCI_BASE_ADDRESS_SPACE_MEMORY),
373 .status = cpu_to_le16(PCI_STATUS_CAP_LIST),
374 .capabilities = PCI_CAP_OFF(&vpci->pci_hdr, msix),
375 .bar_size[0] = cpu_to_le32(PCI_IO_SIZE),
376 .bar_size[1] = cpu_to_le32(PCI_IO_SIZE),
377 .bar_size[2] = cpu_to_le32(VIRTIO_MSIX_BAR_SIZE),
378 };
379
380 r = pci__register_bar_regions(kvm, &vpci->pci_hdr,
381 virtio_pci__bar_activate,
382 virtio_pci__bar_deactivate, vdev);
383 if (r < 0)
384 return r;
385
386 vpci->dev_hdr = (struct device_header) {
387 .bus_type = DEVICE_BUS_PCI,
388 .data = &vpci->pci_hdr,
389 };
390
391 vpci->pci_hdr.msix.cap = PCI_CAP_ID_MSIX;
392 vpci->pci_hdr.msix.next = 0;
393 /*
394 * We at most have VIRTIO_NR_MSIX entries (VIRTIO_PCI_MAX_VQ
395 * entries for virt queue, VIRTIO_PCI_MAX_CONFIG entries for
396 * config).
397 *
398 * To quote the PCI spec:
399 *
400 * System software reads this field to determine the
401 * MSI-X Table Size N, which is encoded as N-1.
402 * For example, a returned value of "00000000011"
403 * indicates a table size of 4.
404 */
405 vpci->pci_hdr.msix.ctrl = cpu_to_le16(VIRTIO_NR_MSIX - 1);
406
407 /* Both table and PBA are mapped to the same BAR (2) */
408 vpci->pci_hdr.msix.table_offset = cpu_to_le32(2);
409 vpci->pci_hdr.msix.pba_offset = cpu_to_le32(2 | VIRTIO_MSIX_TABLE_SIZE);
410 vpci->config_vector = VIRTIO_MSI_NO_VECTOR;
411 /* Initialize all vq vectors to NO_VECTOR */
412 memset(vpci->vq_vector, 0xff, sizeof(vpci->vq_vector));
413
414 if (irq__can_signal_msi(kvm))
415 vpci->signal_msi = true;
416
417 vpci->legacy_irq_line = pci__assign_irq(&vpci->pci_hdr);
418
419 r = device__register(&vpci->dev_hdr);
420 if (r < 0)
421 return r;
422
423 if (vdev->legacy)
424 vpci->doorbell_offset = VIRTIO_PCI_QUEUE_NOTIFY;
425 else
426 return virtio_pci_modern_init(vdev);
427
428 return 0;
429 }
430
virtio_pci__reset(struct kvm * kvm,struct virtio_device * vdev)431 int virtio_pci__reset(struct kvm *kvm, struct virtio_device *vdev)
432 {
433 unsigned int vq;
434 struct virtio_pci *vpci = vdev->virtio;
435
436 virtio_pci__del_msix_route(vpci, vpci->config_gsi);
437 vpci->config_gsi = 0;
438 vpci->config_vector = VIRTIO_MSI_NO_VECTOR;
439
440 for (vq = 0; vq < vdev->ops->get_vq_count(kvm, vpci->dev); vq++)
441 virtio_pci_exit_vq(kvm, vdev, vq);
442
443 return 0;
444 }
445
virtio_pci__exit(struct kvm * kvm,struct virtio_device * vdev)446 int virtio_pci__exit(struct kvm *kvm, struct virtio_device *vdev)
447 {
448 struct virtio_pci *vpci = vdev->virtio;
449
450 virtio_pci__reset(kvm, vdev);
451 kvm__deregister_mmio(kvm, virtio_pci__mmio_addr(vpci));
452 kvm__deregister_mmio(kvm, virtio_pci__msix_io_addr(vpci));
453 kvm__deregister_pio(kvm, virtio_pci__port_addr(vpci));
454
455 return 0;
456 }
457