cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

virtio.h (5835B)


      1/*
      2 * libqos virtio definitions
      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#ifndef LIBQOS_VIRTIO_H
     11#define LIBQOS_VIRTIO_H
     12
     13#include "malloc.h"
     14#include "standard-headers/linux/virtio_ring.h"
     15
     16#define QVIRTIO_F_BAD_FEATURE           0x40000000ull
     17
     18typedef struct QVirtioBus QVirtioBus;
     19
     20typedef struct QVirtioDevice {
     21    const QVirtioBus *bus;
     22    /* Device type */
     23    uint16_t device_type;
     24    uint64_t features;
     25    bool big_endian;
     26    bool features_negotiated;
     27} QVirtioDevice;
     28
     29typedef struct QVirtQueue {
     30    QVirtioDevice *vdev;
     31    uint64_t desc; /* This points to an array of struct vring_desc */
     32    uint64_t avail; /* This points to a struct vring_avail */
     33    uint64_t used; /* This points to a struct vring_used */
     34    uint16_t index;
     35    uint32_t size;
     36    uint32_t free_head;
     37    uint32_t num_free;
     38    uint32_t align;
     39    uint16_t last_used_idx;
     40    bool indirect;
     41    bool event;
     42} QVirtQueue;
     43
     44typedef struct QVRingIndirectDesc {
     45    uint64_t desc; /* This points to an array fo struct vring_desc */
     46    uint16_t index;
     47    uint16_t elem;
     48} QVRingIndirectDesc;
     49
     50struct QVirtioBus {
     51    uint8_t (*config_readb)(QVirtioDevice *d, uint64_t addr);
     52    uint16_t (*config_readw)(QVirtioDevice *d, uint64_t addr);
     53    uint32_t (*config_readl)(QVirtioDevice *d, uint64_t addr);
     54    uint64_t (*config_readq)(QVirtioDevice *d, uint64_t addr);
     55
     56    /* Get features of the device */
     57    uint64_t (*get_features)(QVirtioDevice *d);
     58
     59    /* Set features of the device */
     60    void (*set_features)(QVirtioDevice *d, uint64_t features);
     61
     62    /* Get features of the guest */
     63    uint64_t (*get_guest_features)(QVirtioDevice *d);
     64
     65    /* Get status of the device */
     66    uint8_t (*get_status)(QVirtioDevice *d);
     67
     68    /* Set status of the device  */
     69    void (*set_status)(QVirtioDevice *d, uint8_t status);
     70
     71    /* Get the queue ISR status of the device */
     72    bool (*get_queue_isr_status)(QVirtioDevice *d, QVirtQueue *vq);
     73
     74    /* Wait for the configuration ISR status of the device */
     75    void (*wait_config_isr_status)(QVirtioDevice *d, gint64 timeout_us);
     76
     77    /* Select a queue to work on */
     78    void (*queue_select)(QVirtioDevice *d, uint16_t index);
     79
     80    /* Get the size of the selected queue */
     81    uint16_t (*get_queue_size)(QVirtioDevice *d);
     82
     83    /* Set the address of the selected queue */
     84    void (*set_queue_address)(QVirtioDevice *d, QVirtQueue *vq);
     85
     86    /* Setup the virtqueue specified by index */
     87    QVirtQueue *(*virtqueue_setup)(QVirtioDevice *d, QGuestAllocator *alloc,
     88                                                                uint16_t index);
     89
     90    /* Free virtqueue resources */
     91    void (*virtqueue_cleanup)(QVirtQueue *vq, QGuestAllocator *alloc);
     92
     93    /* Notify changes in virtqueue */
     94    void (*virtqueue_kick)(QVirtioDevice *d, QVirtQueue *vq);
     95};
     96
     97static inline uint32_t qvring_size(uint32_t num, uint32_t align)
     98{
     99    return ((sizeof(struct vring_desc) * num + sizeof(uint16_t) * (3 + num)
    100        + align - 1) & ~(align - 1))
    101        + sizeof(uint16_t) * 3 + sizeof(struct vring_used_elem) * num;
    102}
    103
    104uint8_t qvirtio_config_readb(QVirtioDevice *d, uint64_t addr);
    105uint16_t qvirtio_config_readw(QVirtioDevice *d, uint64_t addr);
    106uint32_t qvirtio_config_readl(QVirtioDevice *d, uint64_t addr);
    107uint64_t qvirtio_config_readq(QVirtioDevice *d, uint64_t addr);
    108uint64_t qvirtio_get_features(QVirtioDevice *d);
    109void qvirtio_set_features(QVirtioDevice *d, uint64_t features);
    110bool qvirtio_is_big_endian(QVirtioDevice *d);
    111
    112void qvirtio_reset(QVirtioDevice *d);
    113void qvirtio_set_acknowledge(QVirtioDevice *d);
    114void qvirtio_set_driver(QVirtioDevice *d);
    115void qvirtio_set_driver_ok(QVirtioDevice *d);
    116
    117void qvirtio_wait_queue_isr(QTestState *qts, QVirtioDevice *d,
    118                            QVirtQueue *vq, gint64 timeout_us);
    119uint8_t qvirtio_wait_status_byte_no_isr(QTestState *qts, QVirtioDevice *d,
    120                                        QVirtQueue *vq,
    121                                        uint64_t addr,
    122                                        gint64 timeout_us);
    123void qvirtio_wait_used_elem(QTestState *qts, QVirtioDevice *d,
    124                            QVirtQueue *vq,
    125                            uint32_t desc_idx,
    126                            uint32_t *len,
    127                            gint64 timeout_us);
    128void qvirtio_wait_config_isr(QVirtioDevice *d, gint64 timeout_us);
    129QVirtQueue *qvirtqueue_setup(QVirtioDevice *d,
    130                             QGuestAllocator *alloc, uint16_t index);
    131void qvirtqueue_cleanup(const QVirtioBus *bus, QVirtQueue *vq,
    132                        QGuestAllocator *alloc);
    133
    134void qvring_init(QTestState *qts, const QGuestAllocator *alloc, QVirtQueue *vq,
    135                 uint64_t addr);
    136QVRingIndirectDesc *qvring_indirect_desc_setup(QTestState *qs, QVirtioDevice *d,
    137                                               QGuestAllocator *alloc,
    138                                               uint16_t elem);
    139void qvring_indirect_desc_add(QVirtioDevice *d, QTestState *qts,
    140                              QVRingIndirectDesc *indirect,
    141                              uint64_t data, uint32_t len, bool write);
    142uint32_t qvirtqueue_add(QTestState *qts, QVirtQueue *vq, uint64_t data,
    143                        uint32_t len, bool write, bool next);
    144uint32_t qvirtqueue_add_indirect(QTestState *qts, QVirtQueue *vq,
    145                                 QVRingIndirectDesc *indirect);
    146void qvirtqueue_kick(QTestState *qts, QVirtioDevice *d, QVirtQueue *vq,
    147                     uint32_t free_head);
    148bool qvirtqueue_get_buf(QTestState *qts, QVirtQueue *vq, uint32_t *desc_idx,
    149                        uint32_t *len);
    150
    151void qvirtqueue_set_used_event(QTestState *qts, QVirtQueue *vq, uint16_t idx);
    152
    153void qvirtio_start_device(QVirtioDevice *vdev);
    154
    155#endif