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