← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to hw/virtio.h

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/virtio.h
 
1
/*
 
2
 * Virtio Support
 
3
 *
 
4
 * Copyright IBM, Corp. 2007
 
5
 *
 
6
 * Authors:
 
7
 *  Anthony Liguori   <aliguori@us.ibm.com>
 
8
 *
 
9
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 
10
 * the COPYING file in the top-level directory.
 
11
 *
 
12
 */
 
13
 
 
14
#ifndef _QEMU_VIRTIO_H
 
15
#define _QEMU_VIRTIO_H
 
16
 
 
17
#include "hw.h"
 
18
#include "net.h"
 
19
#include "qdev.h"
 
20
#include "sysemu.h"
 
21
#include "block_int.h"
 
22
#include "event_notifier.h"
 
23
#ifdef CONFIG_LINUX
 
24
#include "9p.h"
 
25
#endif
 
26
 
 
27
/* from Linux's linux/virtio_config.h */
 
28
 
 
29
/* Status byte for guest to report progress, and synchronize features. */
 
30
/* We have seen device and processed generic fields (VIRTIO_CONFIG_F_VIRTIO) */
 
31
#define VIRTIO_CONFIG_S_ACKNOWLEDGE     1
 
32
/* We have found a driver for the device. */
 
33
#define VIRTIO_CONFIG_S_DRIVER          2
 
34
/* Driver has used its parts of the config, and is happy */
 
35
#define VIRTIO_CONFIG_S_DRIVER_OK       4
 
36
/* We've given up on this device. */
 
37
#define VIRTIO_CONFIG_S_FAILED          0x80
 
38
 
 
39
/* Some virtio feature bits (currently bits 28 through 31) are reserved for the
 
40
 * transport being used (eg. virtio_ring), the rest are per-device feature bits. */
 
41
#define VIRTIO_TRANSPORT_F_START        28
 
42
#define VIRTIO_TRANSPORT_F_END          32
 
43
 
 
44
/* We notify when the ring is completely used, even if the guest is suppressing
 
45
 * callbacks */
 
46
#define VIRTIO_F_NOTIFY_ON_EMPTY        24
 
47
/* We support indirect buffer descriptors */
 
48
#define VIRTIO_RING_F_INDIRECT_DESC     28
 
49
/* The Guest publishes the used index for which it expects an interrupt
 
50
 * at the end of the avail ring. Host should ignore the avail->flags field. */
 
51
/* The Host publishes the avail index for which it expects a kick
 
52
 * at the end of the used ring. Guest should ignore the used->flags field. */
 
53
#define VIRTIO_RING_F_EVENT_IDX         29
 
54
/* A guest should never accept this.  It implies negotiation is broken. */
 
55
#define VIRTIO_F_BAD_FEATURE            30
 
56
 
 
57
/* from Linux's linux/virtio_ring.h */
 
58
 
 
59
/* This marks a buffer as continuing via the next field. */
 
60
#define VRING_DESC_F_NEXT       1
 
61
/* This marks a buffer as write-only (otherwise read-only). */
 
62
#define VRING_DESC_F_WRITE      2
 
63
/* This means the buffer contains a list of buffer descriptors. */
 
64
#define VRING_DESC_F_INDIRECT  4
 
65
 
 
66
/* This means don't notify other side when buffer added. */
 
67
#define VRING_USED_F_NO_NOTIFY  1
 
68
/* This means don't interrupt guest when buffer consumed. */
 
69
#define VRING_AVAIL_F_NO_INTERRUPT      1
 
70
 
 
71
struct VirtQueue;
 
72
 
 
73
static inline target_phys_addr_t vring_align(target_phys_addr_t addr,
 
74
                                             unsigned long align)
 
75
{
 
76
    return (addr + align - 1) & ~(align - 1);
 
77
}
 
78
 
 
79
typedef struct VirtQueue VirtQueue;
 
80
 
 
81
#define VIRTQUEUE_MAX_SIZE 1024
 
82
 
 
83
typedef struct VirtQueueElement
 
84
{
 
85
    unsigned int index;
 
86
    unsigned int out_num;
 
87
    unsigned int in_num;
 
88
    target_phys_addr_t in_addr[VIRTQUEUE_MAX_SIZE];
 
89
    target_phys_addr_t out_addr[VIRTQUEUE_MAX_SIZE];
 
90
    struct iovec in_sg[VIRTQUEUE_MAX_SIZE];
 
91
    struct iovec out_sg[VIRTQUEUE_MAX_SIZE];
 
92
} VirtQueueElement;
 
93
 
 
94
typedef struct {
 
95
    void (*notify)(void * opaque, uint16_t vector);
 
96
    void (*save_config)(void * opaque, QEMUFile *f);
 
97
    void (*save_queue)(void * opaque, int n, QEMUFile *f);
 
98
    int (*load_config)(void * opaque, QEMUFile *f);
 
99
    int (*load_queue)(void * opaque, int n, QEMUFile *f);
 
100
    int (*load_done)(void * opaque, QEMUFile *f);
 
101
    unsigned (*get_features)(void * opaque);
 
102
    bool (*query_guest_notifiers)(void * opaque);
 
103
    int (*set_guest_notifiers)(void * opaque, bool assigned);
 
104
    int (*set_host_notifier)(void * opaque, int n, bool assigned);
 
105
    void (*vmstate_change)(void * opaque, bool running);
 
106
} VirtIOBindings;
 
107
 
 
108
#define VIRTIO_PCI_QUEUE_MAX 64
 
109
 
 
110
#define VIRTIO_NO_VECTOR 0xffff
 
111
 
 
112
struct VirtIODevice
 
113
{
 
114
    const char *name;
 
115
    uint8_t status;
 
116
    uint8_t isr;
 
117
    uint16_t queue_sel;
 
118
    uint32_t guest_features;
 
119
    size_t config_len;
 
120
    void *config;
 
121
    uint16_t config_vector;
 
122
    int nvectors;
 
123
    uint32_t (*get_features)(VirtIODevice *vdev, uint32_t requested_features);
 
124
    uint32_t (*bad_features)(VirtIODevice *vdev);
 
125
    void (*set_features)(VirtIODevice *vdev, uint32_t val);
 
126
    void (*get_config)(VirtIODevice *vdev, uint8_t *config);
 
127
    void (*set_config)(VirtIODevice *vdev, const uint8_t *config);
 
128
    void (*reset)(VirtIODevice *vdev);
 
129
    void (*set_status)(VirtIODevice *vdev, uint8_t val);
 
130
    VirtQueue *vq;
 
131
    const VirtIOBindings *binding;
 
132
    void *binding_opaque;
 
133
    uint16_t device_id;
 
134
    bool vm_running;
 
135
    VMChangeStateEntry *vmstate;
 
136
};
 
137
 
 
138
static inline void virtio_set_status(VirtIODevice *vdev, uint8_t val)
 
139
{
 
140
    if (vdev->set_status) {
 
141
        vdev->set_status(vdev, val);
 
142
    }
 
143
    vdev->status = val;
 
144
}
 
145
 
 
146
VirtQueue *virtio_add_queue(VirtIODevice *vdev, int queue_size,
 
147
                            void (*handle_output)(VirtIODevice *,
 
148
                                                  VirtQueue *));
 
149
 
 
150
void virtqueue_push(VirtQueue *vq, const VirtQueueElement *elem,
 
151
                    unsigned int len);
 
152
void virtqueue_flush(VirtQueue *vq, unsigned int count);
 
153
void virtqueue_fill(VirtQueue *vq, const VirtQueueElement *elem,
 
154
                    unsigned int len, unsigned int idx);
 
155
 
 
156
void virtqueue_map_sg(struct iovec *sg, target_phys_addr_t *addr,
 
157
    size_t num_sg, int is_write);
 
158
int virtqueue_pop(VirtQueue *vq, VirtQueueElement *elem);
 
159
int virtqueue_avail_bytes(VirtQueue *vq, int in_bytes, int out_bytes);
 
160
 
 
161
void virtio_notify(VirtIODevice *vdev, VirtQueue *vq);
 
162
 
 
163
void virtio_save(VirtIODevice *vdev, QEMUFile *f);
 
164
 
 
165
int virtio_load(VirtIODevice *vdev, QEMUFile *f);
 
166
 
 
167
void virtio_cleanup(VirtIODevice *vdev);
 
168
 
 
169
void virtio_notify_config(VirtIODevice *vdev);
 
170
 
 
171
void virtio_queue_set_notification(VirtQueue *vq, int enable);
 
172
 
 
173
int virtio_queue_ready(VirtQueue *vq);
 
174
 
 
175
int virtio_queue_empty(VirtQueue *vq);
 
176
 
 
177
/* Host binding interface.  */
 
178
 
 
179
VirtIODevice *virtio_common_init(const char *name, uint16_t device_id,
 
180
                                 size_t config_size, size_t struct_size);
 
181
uint32_t virtio_config_readb(VirtIODevice *vdev, uint32_t addr);
 
182
uint32_t virtio_config_readw(VirtIODevice *vdev, uint32_t addr);
 
183
uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr);
 
184
void virtio_config_writeb(VirtIODevice *vdev, uint32_t addr, uint32_t data);
 
185
void virtio_config_writew(VirtIODevice *vdev, uint32_t addr, uint32_t data);
 
186
void virtio_config_writel(VirtIODevice *vdev, uint32_t addr, uint32_t data);
 
187
void virtio_queue_set_addr(VirtIODevice *vdev, int n, target_phys_addr_t addr);
 
188
target_phys_addr_t virtio_queue_get_addr(VirtIODevice *vdev, int n);
 
189
int virtio_queue_get_num(VirtIODevice *vdev, int n);
 
190
void virtio_queue_notify(VirtIODevice *vdev, int n);
 
191
uint16_t virtio_queue_vector(VirtIODevice *vdev, int n);
 
192
void virtio_queue_set_vector(VirtIODevice *vdev, int n, uint16_t vector);
 
193
void virtio_reset(void *opaque);
 
194
void virtio_update_irq(VirtIODevice *vdev);
 
195
 
 
196
void virtio_bind_device(VirtIODevice *vdev, const VirtIOBindings *binding,
 
197
                        void *opaque);
 
198
 
 
199
/* Base devices.  */
 
200
VirtIODevice *virtio_blk_init(DeviceState *dev, BlockConf *conf,
 
201
                              char **serial);
 
202
struct virtio_net_conf;
 
203
VirtIODevice *virtio_net_init(DeviceState *dev, NICConf *conf,
 
204
                              struct virtio_net_conf *net);
 
205
typedef struct virtio_serial_conf virtio_serial_conf;
 
206
VirtIODevice *virtio_serial_init(DeviceState *dev, virtio_serial_conf *serial);
 
207
VirtIODevice *virtio_balloon_init(DeviceState *dev);
 
208
#ifdef CONFIG_LINUX
 
209
VirtIODevice *virtio_9p_init(DeviceState *dev, V9fsConf *conf);
 
210
#endif
 
211
 
 
212
 
 
213
void virtio_net_exit(VirtIODevice *vdev);
 
214
void virtio_blk_exit(VirtIODevice *vdev);
 
215
void virtio_serial_exit(VirtIODevice *vdev);
 
216
void virtio_balloon_exit(VirtIODevice *vdev);
 
217
 
 
218
#define DEFINE_VIRTIO_COMMON_FEATURES(_state, _field) \
 
219
        DEFINE_PROP_BIT("indirect_desc", _state, _field, \
 
220
                        VIRTIO_RING_F_INDIRECT_DESC, true), \
 
221
        DEFINE_PROP_BIT("event_idx", _state, _field, \
 
222
                        VIRTIO_RING_F_EVENT_IDX, true)
 
223
 
 
224
target_phys_addr_t virtio_queue_get_desc_addr(VirtIODevice *vdev, int n);
 
225
target_phys_addr_t virtio_queue_get_avail_addr(VirtIODevice *vdev, int n);
 
226
target_phys_addr_t virtio_queue_get_used_addr(VirtIODevice *vdev, int n);
 
227
target_phys_addr_t virtio_queue_get_ring_addr(VirtIODevice *vdev, int n);
 
228
target_phys_addr_t virtio_queue_get_desc_size(VirtIODevice *vdev, int n);
 
229
target_phys_addr_t virtio_queue_get_avail_size(VirtIODevice *vdev, int n);
 
230
target_phys_addr_t virtio_queue_get_used_size(VirtIODevice *vdev, int n);
 
231
target_phys_addr_t virtio_queue_get_ring_size(VirtIODevice *vdev, int n);
 
232
uint16_t virtio_queue_get_last_avail_idx(VirtIODevice *vdev, int n);
 
233
void virtio_queue_set_last_avail_idx(VirtIODevice *vdev, int n, uint16_t idx);
 
234
VirtQueue *virtio_get_queue(VirtIODevice *vdev, int n);
 
235
EventNotifier *virtio_queue_get_guest_notifier(VirtQueue *vq);
 
236
EventNotifier *virtio_queue_get_host_notifier(VirtQueue *vq);
 
237
void virtio_queue_notify_vq(VirtQueue *vq);
 
238
void virtio_irq(VirtQueue *vq);
 
239
#endif