1 /* 2 * libqos virtio driver 3 * 4 * Copyright (c) 2014 Marc Marí 5 * 6 * This work is licensed under the terms of the GNU GPL, version 2 or later. 7 * See the COPYING file in the top-level directory. 8 */ 9 10 #include "qemu/osdep.h" 11 #include "libqtest.h" 12 #include "libqos/virtio.h" 13 #include "standard-headers/linux/virtio_config.h" 14 #include "standard-headers/linux/virtio_ring.h" 15 16 uint8_t qvirtio_config_readb(QVirtioDevice *d, uint64_t addr) 17 { 18 return d->bus->config_readb(d, addr); 19 } 20 21 uint16_t qvirtio_config_readw(QVirtioDevice *d, uint64_t addr) 22 { 23 return d->bus->config_readw(d, addr); 24 } 25 26 uint32_t qvirtio_config_readl(QVirtioDevice *d, uint64_t addr) 27 { 28 return d->bus->config_readl(d, addr); 29 } 30 31 uint64_t qvirtio_config_readq(QVirtioDevice *d, uint64_t addr) 32 { 33 return d->bus->config_readq(d, addr); 34 } 35 36 uint32_t qvirtio_get_features(QVirtioDevice *d) 37 { 38 return d->bus->get_features(d); 39 } 40 41 void qvirtio_set_features(QVirtioDevice *d, uint32_t features) 42 { 43 d->features = features; 44 d->bus->set_features(d, features); 45 } 46 47 QVirtQueue *qvirtqueue_setup(QVirtioDevice *d, 48 QGuestAllocator *alloc, uint16_t index) 49 { 50 return d->bus->virtqueue_setup(d, alloc, index); 51 } 52 53 void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq, 54 QGuestAllocator *alloc) 55 { 56 return bus->virtqueue_cleanup(vq, alloc); 57 } 58 59 void qvirtio_reset(QVirtioDevice *d) 60 { 61 d->bus->set_status(d, 0); 62 g_assert_cmphex(d->bus->get_status(d), ==, 0); 63 } 64 65 void qvirtio_set_acknowledge(QVirtioDevice *d) 66 { 67 d->bus->set_status(d, d->bus->get_status(d) | VIRTIO_CONFIG_S_ACKNOWLEDGE); 68 g_assert_cmphex(d->bus->get_status(d), ==, VIRTIO_CONFIG_S_ACKNOWLEDGE); 69 } 70 71 void qvirtio_set_driver(QVirtioDevice *d) 72 { 73 d->bus->set_status(d, d->bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER); 74 g_assert_cmphex(d->bus->get_status(d), ==, 75 VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_ACKNOWLEDGE); 76 } 77 78 void qvirtio_set_driver_ok(QVirtioDevice *d) 79 { 80 d->bus->set_status(d, d->bus->get_status(d) | VIRTIO_CONFIG_S_DRIVER_OK); 81 g_assert_cmphex(d->bus->get_status(d), ==, VIRTIO_CONFIG_S_DRIVER_OK | 82 VIRTIO_CONFIG_S_DRIVER | VIRTIO_CONFIG_S_ACKNOWLEDGE); 83 } 84 85 void qvirtio_wait_queue_isr(QVirtioDevice *d, 86 QVirtQueue *vq, gint64 timeout_us) 87 { 88 gint64 start_time = g_get_monotonic_time(); 89 90 for (;;) { 91 clock_step(100); 92 if (d->bus->get_queue_isr_status(d, vq)) { 93 return; 94 } 95 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 96 } 97 } 98 99 /* Wait for the status byte at given guest memory address to be set 100 * 101 * The virtqueue interrupt must not be raised, making this useful for testing 102 * event_index functionality. 103 */ 104 uint8_t qvirtio_wait_status_byte_no_isr(QVirtioDevice *d, 105 QVirtQueue *vq, 106 uint64_t addr, 107 gint64 timeout_us) 108 { 109 gint64 start_time = g_get_monotonic_time(); 110 uint8_t val; 111 112 while ((val = readb(addr)) == 0xff) { 113 clock_step(100); 114 g_assert(!d->bus->get_queue_isr_status(d, vq)); 115 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 116 } 117 return val; 118 } 119 120 /* 121 * qvirtio_wait_used_elem: 122 * @desc_idx: The next expected vq->desc[] index in the used ring 123 * @len: A pointer that is filled with the length written into the buffer, may 124 * be NULL 125 * @timeout_us: How many microseconds to wait before failing 126 * 127 * This function waits for the next completed request on the used ring. 128 */ 129 void qvirtio_wait_used_elem(QVirtioDevice *d, 130 QVirtQueue *vq, 131 uint32_t desc_idx, 132 uint32_t *len, 133 gint64 timeout_us) 134 { 135 gint64 start_time = g_get_monotonic_time(); 136 137 for (;;) { 138 uint32_t got_desc_idx; 139 140 clock_step(100); 141 142 if (d->bus->get_queue_isr_status(d, vq) && 143 qvirtqueue_get_buf(vq, &got_desc_idx, len)) { 144 g_assert_cmpint(got_desc_idx, ==, desc_idx); 145 return; 146 } 147 148 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 149 } 150 } 151 152 void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us) 153 { 154 gint64 start_time = g_get_monotonic_time(); 155 156 for (;;) { 157 clock_step(100); 158 if (d->bus->get_config_isr_status(d)) { 159 return; 160 } 161 g_assert(g_get_monotonic_time() - start_time <= timeout_us); 162 } 163 } 164 165 void qvring_init(const QGuestAllocator *alloc, QVirtQueue *vq, uint64_t addr) 166 { 167 int i; 168 169 vq->desc = addr; 170 vq->avail = vq->desc + vq->size * sizeof(struct vring_desc); 171 vq->used = (uint64_t)((vq->avail + sizeof(uint16_t) * (3 + vq->size) 172 + vq->align - 1) & ~(vq->align - 1)); 173 174 for (i = 0; i < vq->size - 1; i++) { 175 /* vq->desc[i].addr */ 176 writeq(vq->desc + (16 * i), 0); 177 /* vq->desc[i].next */ 178 writew(vq->desc + (16 * i) + 14, i + 1); 179 } 180 181 /* vq->avail->flags */ 182 writew(vq->avail, 0); 183 /* vq->avail->idx */ 184 writew(vq->avail + 2, 0); 185 /* vq->avail->used_event */ 186 writew(vq->avail + 4 + (2 * vq->size), 0); 187 188 /* vq->used->flags */ 189 writew(vq->used, 0); 190 /* vq->used->avail_event */ 191 writew(vq->used + 2 + sizeof(struct vring_used_elem) * vq->size, 0); 192 } 193 194 QVRingIndirectDesc *qvring_indirect_desc_setup(QVirtioDevice *d, 195 QGuestAllocator *alloc, uint16_t elem) 196 { 197 int i; 198 QVRingIndirectDesc *indirect = g_malloc(sizeof(*indirect)); 199 200 indirect->index = 0; 201 indirect->elem = elem; 202 indirect->desc = guest_alloc(alloc, sizeof(struct vring_desc) * elem); 203 204 for (i = 0; i < elem - 1; ++i) { 205 /* indirect->desc[i].addr */ 206 writeq(indirect->desc + (16 * i), 0); 207 /* indirect->desc[i].flags */ 208 writew(indirect->desc + (16 * i) + 12, VRING_DESC_F_NEXT); 209 /* indirect->desc[i].next */ 210 writew(indirect->desc + (16 * i) + 14, i + 1); 211 } 212 213 return indirect; 214 } 215 216 void qvring_indirect_desc_add(QVRingIndirectDesc *indirect, uint64_t data, 217 uint32_t len, bool write) 218 { 219 uint16_t flags; 220 221 g_assert_cmpint(indirect->index, <, indirect->elem); 222 223 flags = readw(indirect->desc + (16 * indirect->index) + 12); 224 225 if (write) { 226 flags |= VRING_DESC_F_WRITE; 227 } 228 229 /* indirect->desc[indirect->index].addr */ 230 writeq(indirect->desc + (16 * indirect->index), data); 231 /* indirect->desc[indirect->index].len */ 232 writel(indirect->desc + (16 * indirect->index) + 8, len); 233 /* indirect->desc[indirect->index].flags */ 234 writew(indirect->desc + (16 * indirect->index) + 12, flags); 235 236 indirect->index++; 237 } 238 239 uint32_t qvirtqueue_add(QVirtQueue *vq, uint64_t data, uint32_t len, bool write, 240 bool next) 241 { 242 uint16_t flags = 0; 243 vq->num_free--; 244 245 if (write) { 246 flags |= VRING_DESC_F_WRITE; 247 } 248 249 if (next) { 250 flags |= VRING_DESC_F_NEXT; 251 } 252 253 /* vq->desc[vq->free_head].addr */ 254 writeq(vq->desc + (16 * vq->free_head), data); 255 /* vq->desc[vq->free_head].len */ 256 writel(vq->desc + (16 * vq->free_head) + 8, len); 257 /* vq->desc[vq->free_head].flags */ 258 writew(vq->desc + (16 * vq->free_head) + 12, flags); 259 260 return vq->free_head++; /* Return and increase, in this order */ 261 } 262 263 uint32_t qvirtqueue_add_indirect(QVirtQueue *vq, QVRingIndirectDesc *indirect) 264 { 265 g_assert(vq->indirect); 266 g_assert_cmpint(vq->size, >=, indirect->elem); 267 g_assert_cmpint(indirect->index, ==, indirect->elem); 268 269 vq->num_free--; 270 271 /* vq->desc[vq->free_head].addr */ 272 writeq(vq->desc + (16 * vq->free_head), indirect->desc); 273 /* vq->desc[vq->free_head].len */ 274 writel(vq->desc + (16 * vq->free_head) + 8, 275 sizeof(struct vring_desc) * indirect->elem); 276 /* vq->desc[vq->free_head].flags */ 277 writew(vq->desc + (16 * vq->free_head) + 12, VRING_DESC_F_INDIRECT); 278 279 return vq->free_head++; /* Return and increase, in this order */ 280 } 281 282 void qvirtqueue_kick(QVirtioDevice *d, QVirtQueue *vq, uint32_t free_head) 283 { 284 /* vq->avail->idx */ 285 uint16_t idx = readw(vq->avail + 2); 286 /* vq->used->flags */ 287 uint16_t flags; 288 /* vq->used->avail_event */ 289 uint16_t avail_event; 290 291 /* vq->avail->ring[idx % vq->size] */ 292 writew(vq->avail + 4 + (2 * (idx % vq->size)), free_head); 293 /* vq->avail->idx */ 294 writew(vq->avail + 2, idx + 1); 295 296 /* Must read after idx is updated */ 297 flags = readw(vq->avail); 298 avail_event = readw(vq->used + 4 + 299 sizeof(struct vring_used_elem) * vq->size); 300 301 /* < 1 because we add elements to avail queue one by one */ 302 if ((flags & VRING_USED_F_NO_NOTIFY) == 0 && 303 (!vq->event || (uint16_t)(idx-avail_event) < 1)) { 304 d->bus->virtqueue_kick(d, vq); 305 } 306 } 307 308 /* 309 * qvirtqueue_get_buf: 310 * @desc_idx: A pointer that is filled with the vq->desc[] index, may be NULL 311 * @len: A pointer that is filled with the length written into the buffer, may 312 * be NULL 313 * 314 * This function gets the next used element if there is one ready. 315 * 316 * Returns: true if an element was ready, false otherwise 317 */ 318 bool qvirtqueue_get_buf(QVirtQueue *vq, uint32_t *desc_idx, uint32_t *len) 319 { 320 uint16_t idx; 321 uint64_t elem_addr; 322 323 idx = readw(vq->used + offsetof(struct vring_used, idx)); 324 if (idx == vq->last_used_idx) { 325 return false; 326 } 327 328 elem_addr = vq->used + 329 offsetof(struct vring_used, ring) + 330 (vq->last_used_idx % vq->size) * 331 sizeof(struct vring_used_elem); 332 333 if (desc_idx) { 334 *desc_idx = readl(elem_addr + offsetof(struct vring_used_elem, id)); 335 } 336 337 if (len) { 338 *len = readw(elem_addr + offsetof(struct vring_used_elem, len)); 339 } 340 341 vq->last_used_idx++; 342 return true; 343 } 344 345 void qvirtqueue_set_used_event(QVirtQueue *vq, uint16_t idx) 346 { 347 g_assert(vq->event); 348 349 /* vq->avail->used_event */ 350 writew(vq->avail + 4 + (2 * vq->size), idx); 351 } 352 353 void qvirtio_start_device(QVirtioDevice *vdev) 354 { 355 qvirtio_reset(vdev); 356 qvirtio_set_acknowledge(vdev); 357 qvirtio_set_driver(vdev); 358 } 359 360 bool qvirtio_is_big_endian(QVirtioDevice *d) 361 { 362 return d->big_endian; 363 } 364