← Back to branch summary

~ubuntu-branches/ubuntu/trusty/virtualbox-ose/trusty

« back to all changes in this revision

Viewing changes to src/VBox/Devices/VirtIO/Virtio.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-12-18 16:44:29 UTC
  • mfrom: (0.3.3 upstream) (0.4.6 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091218164429-jd34ccexpv5na11a
Tags: 3.1.2-dfsg-1ubuntu1
https://launchpad.net/bugs/498219
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/474625
https://launchpad.net/bugs/495935
https://launchpad.net/bugs/473334
* Merge from Debian unstable (LP: #498219), remaining changes:
  - Disable update action
    - debian/patches/u01-disable-update-action.dpatch
  - VirtualBox should go in Accessories, not in System tools (LP: #288590)
    - debian/virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add Apport hook
    - debian/virtualbox-ose.files/source_virtualbox-ose.py
    - debian/virtualbox-ose.install
  - Add Launchpad integration
    - debian/control
    - debian/lpi-bug.xpm
    - debian/patches/u02-lp-integration.dpatch
* Fixes the following bugs:
  - Kernel module fails to build with Linux >= 2.6.32 (LP: #474625)
  - X.Org drivers need to be rebuilt against X-Server 1.7 (LP: #495935)
  - The *-source packages try to build the kernel modules even though the
    kernel headers aren't available (LP: #473334)
* Replace *-source packages with transitional packages for *-dkms.
* Adapt u01-disable-update-action.dpatch and u02-lp-integration.dpatch for
  new upstream version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Devices/VirtIO/Virtio.h
 
1
/* $Id: Virtio.h $ */
 
2
/** @file
 
3
 * Virtio.h - Virtio Declarations
 
4
 *
 
5
 */
 
6
 
 
7
/*
 
8
 * Copyright (C) 2009 Sun Microsystems, Inc.
 
9
 *
 
10
 * This file is part of VirtualBox Open Source Edition (OSE), as
 
11
 * available from http://www.virtualbox.org. This file is free software;
 
12
 * you can redistribute it and/or modify it under the terms of the GNU
 
13
 * General Public License (GPL) as published by the Free Software
 
14
 * Foundation, in version 2 as it comes in the "COPYING" file of the
 
15
 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
 
16
 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
 
17
 *
 
18
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
 
19
 * Clara, CA 95054 USA or visit http://www.sun.com if you need
 
20
 * additional information or have any questions.
 
21
 */
 
22
 
 
23
#ifndef ___VBox_Virtio_h
 
24
#define ___VBox_Virtio_h
 
25
 
 
26
#include <iprt/ctype.h>
 
27
 
 
28
#define VIRTIO_RELOCATE(p, o) *(RTHCUINTPTR *)&p += o
 
29
 
 
30
/*
 
31
 * The saved state version is changed if either common or any of specific
 
32
 * parts are changed. That is, it is perfectly possible that the version
 
33
 * of saved vnet state will increase as a result of change in vblk structure
 
34
 * for example.
 
35
 */
 
36
#define VIRTIO_SAVEDSTATE_VERSION_3_1_BETA1 1
 
37
#define VIRTIO_SAVEDSTATE_VERSION           2
 
38
 
 
39
#define DEVICE_PCI_VENDOR_ID                0x1AF4
 
40
#define DEVICE_PCI_DEVICE_ID                0x1000
 
41
#define DEVICE_PCI_SUBSYSTEM_VENDOR_ID      0x1AF4
 
42
 
 
43
#define VIRTIO_MAX_NQUEUES                  3
 
44
 
 
45
#define VPCI_HOST_FEATURES                  0x0
 
46
#define VPCI_GUEST_FEATURES                 0x4
 
47
#define VPCI_QUEUE_PFN                      0x8
 
48
#define VPCI_QUEUE_NUM                      0xC
 
49
#define VPCI_QUEUE_SEL                      0xE
 
50
#define VPCI_QUEUE_NOTIFY                   0x10
 
51
#define VPCI_STATUS                         0x12
 
52
#define VPCI_ISR                            0x13
 
53
#define VPCI_CONFIG                         0x14
 
54
 
 
55
#define VPCI_ISR_QUEUE                      0x1
 
56
#define VPCI_ISR_CONFIG                     0x3
 
57
 
 
58
#define VPCI_STATUS_ACK                     0x01
 
59
#define VPCI_STATUS_DRV                     0x02
 
60
#define VPCI_STATUS_DRV_OK                  0x04
 
61
#define VPCI_STATUS_FAILED                  0x80
 
62
 
 
63
#define VPCI_F_NOTIFY_ON_EMPTY              0x01000000
 
64
#define VPCI_F_BAD_FEATURE                  0x40000000
 
65
 
 
66
#define VRINGDESC_MAX_SIZE                  (2 * 1024 * 1024)
 
67
#define VRINGDESC_F_NEXT                    0x01
 
68
#define VRINGDESC_F_WRITE                   0x02
 
69
 
 
70
struct VRingDesc
 
71
{
 
72
    uint64_t u64Addr;
 
73
    uint32_t uLen;
 
74
    uint16_t u16Flags;
 
75
    uint16_t u16Next;
 
76
};
 
77
typedef struct VRingDesc VRINGDESC;
 
78
typedef VRINGDESC *PVRINGDESC;
 
79
 
 
80
#define VRINGAVAIL_F_NO_INTERRUPT 0x01
 
81
 
 
82
struct VRingAvail
 
83
{
 
84
    uint16_t uFlags;
 
85
    uint16_t uNextFreeIndex;
 
86
    uint16_t auRing[1];
 
87
};
 
88
typedef struct VRingAvail VRINGAVAIL;
 
89
 
 
90
struct VRingUsedElem
 
91
{
 
92
    uint32_t uId;
 
93
    uint32_t uLen;
 
94
};
 
95
typedef struct VRingUsedElem VRINGUSEDELEM;
 
96
 
 
97
#define VRINGUSED_F_NO_NOTIFY 0x01
 
98
 
 
99
struct VRingUsed
 
100
{
 
101
    uint16_t      uFlags;
 
102
    uint16_t      uIndex;
 
103
    VRINGUSEDELEM aRing[1];
 
104
};
 
105
typedef struct VRingUsed VRINGUSED;
 
106
typedef VRINGUSED *PVRINGUSED;
 
107
 
 
108
#define VRING_MAX_SIZE 1024
 
109
 
 
110
struct VRing
 
111
{
 
112
    uint16_t   uSize;
 
113
    uint16_t   padding[3];
 
114
    RTGCPHYS   addrDescriptors;
 
115
    RTGCPHYS   addrAvail;
 
116
    RTGCPHYS   addrUsed;
 
117
};
 
118
typedef struct VRing VRING;
 
119
typedef VRING *PVRING;
 
120
 
 
121
struct VQueue
 
122
{
 
123
    VRING    VRing;
 
124
    uint16_t uNextAvailIndex;
 
125
    uint16_t uNextUsedIndex;
 
126
    uint32_t uPageNumber;
 
127
#ifdef IN_RING3
 
128
    void   (*pfnCallback)(void *pvState, struct VQueue *pQueue);
 
129
#else
 
130
    RTR3UINTPTR pfnCallback;
 
131
#endif
 
132
    R3PTRTYPE(const char *) pcszName;
 
133
};
 
134
typedef struct VQueue VQUEUE;
 
135
typedef VQUEUE *PVQUEUE;
 
136
 
 
137
struct VQueueElemSeg
 
138
{
 
139
    RTGCPHYS addr;
 
140
    void    *pv;
 
141
    uint32_t cb;
 
142
};
 
143
typedef struct VQueueElemSeg VQUEUESEG;
 
144
 
 
145
struct VQueueElem
 
146
{
 
147
    uint32_t  uIndex;
 
148
    uint32_t  nIn;
 
149
    uint32_t  nOut;
 
150
    VQUEUESEG aSegsIn[VRING_MAX_SIZE];
 
151
    VQUEUESEG aSegsOut[VRING_MAX_SIZE];
 
152
};
 
153
typedef struct VQueueElem VQUEUEELEM;
 
154
typedef VQUEUEELEM *PVQUEUEELEM;
 
155
 
 
156
 
 
157
enum VirtioDeviceType
 
158
{
 
159
    VIRTIO_NET_ID = 0,
 
160
    VIRTIO_BLK_ID = 1,
 
161
    VIRTIO_32BIT_HACK = 0x7fffffff
 
162
};
 
163
 
 
164
struct VPCIState_st
 
165
{
 
166
    PDMCRITSECT            cs;      /**< Critical section - what is it protecting? */
 
167
    /* Read-only part, never changes after initialization. */
 
168
    char                   szInstance[8];         /**< Instance name, e.g. VNet#1. */
 
169
 
 
170
#if HC_ARCH_BITS != 64
 
171
    uint32_t               padding1;
 
172
#endif
 
173
 
 
174
    PDMIBASE               IBase;
 
175
    PDMILEDPORTS           ILeds;                               /**< LED interface */
 
176
    R3PTRTYPE(PPDMILEDCONNECTORS) pLedsConnector;
 
177
 
 
178
    PPDMDEVINSR3           pDevInsR3;                   /**< Device instance - R3. */
 
179
    PPDMDEVINSR0           pDevInsR0;                   /**< Device instance - R0. */
 
180
    PPDMDEVINSRC           pDevInsRC;                   /**< Device instance - RC. */
 
181
 
 
182
#if HC_ARCH_BITS == 64
 
183
    uint32_t               padding2;
 
184
#endif
 
185
 
 
186
    /** TODO */
 
187
    PCIDEVICE              pciDevice;
 
188
    /** Base port of I/O space region. */
 
189
    RTIOPORT               addrIOPort;
 
190
 
 
191
    /* Read/write part, protected with critical section. */
 
192
    /** Status LED. */
 
193
    PDMLED                 led;
 
194
 
 
195
    uint32_t               uGuestFeatures;
 
196
    uint16_t               uQueueSelector;         /**< An index in aQueues array. */
 
197
    uint8_t                uStatus; /**< Device Status (bits are device-specific). */
 
198
    uint8_t                uISR;                   /**< Interrupt Status Register. */
 
199
 
 
200
#if HC_ARCH_BITS != 64
 
201
    uint32_t               padding3;
 
202
#endif
 
203
 
 
204
    uint32_t               nQueues;       /**< Actual number of queues used. */
 
205
    VQUEUE                 Queues[VIRTIO_MAX_NQUEUES];
 
206
 
 
207
#if defined(VBOX_WITH_STATISTICS)
 
208
    STAMPROFILEADV         StatIOReadGC;
 
209
    STAMPROFILEADV         StatIOReadHC;
 
210
    STAMPROFILEADV         StatIOWriteGC;
 
211
    STAMPROFILEADV         StatIOWriteHC;
 
212
    STAMCOUNTER            StatIntsRaised;
 
213
    STAMCOUNTER            StatIntsSkipped;
 
214
    STAMPROFILE            StatCsGC;
 
215
    STAMPROFILE            StatCsHC;
 
216
#endif /* VBOX_WITH_STATISTICS */
 
217
};
 
218
typedef struct VPCIState_st VPCISTATE;
 
219
typedef VPCISTATE *PVPCISTATE;
 
220
 
 
221
/* Callbacks *****************************************************************/
 
222
typedef uint32_t (*PFNGETHOSTFEATURES)(void *pState);
 
223
typedef uint32_t (*PFNGETHOSTMINIMALFEATURES)(void *pState);
 
224
typedef void     (*PFNSETHOSTFEATURES)(void *pState, uint32_t uFeatures);
 
225
typedef int      (*PFNGETCONFIG)(void *pState, uint32_t port, uint32_t cb, void *data);
 
226
typedef int      (*PFNSETCONFIG)(void *pState, uint32_t port, uint32_t cb, void *data);
 
227
typedef void     (*PFNRESET)(void *pState);
 
228
typedef void     (*PFNREADY)(void *pState);
 
229
/*****************************************************************************/
 
230
 
 
231
int vpciRaiseInterrupt(VPCISTATE *pState, int rcBusy, uint8_t u8IntCause);
 
232
int vpciIOPortIn(PPDMDEVINS         pDevIns,
 
233
                 void              *pvUser,
 
234
                 RTIOPORT           port,
 
235
                 uint32_t          *pu32,
 
236
                 unsigned           cb,
 
237
                 PFNGETHOSTFEATURES pfnGetHostFeatures,
 
238
                 PFNGETCONFIG       pfnGetConfig);
 
239
 
 
240
int vpciIOPortOut(PPDMDEVINS                pDevIns,
 
241
                  void                     *pvUser,
 
242
                  RTIOPORT                  port,
 
243
                  uint32_t                  u32,
 
244
                  unsigned                  cb,
 
245
                  PFNGETHOSTMINIMALFEATURES pfnGetHostMinimalFeatures,
 
246
                  PFNGETHOSTFEATURES        pfnGetHostFeatures,
 
247
                  PFNSETHOSTFEATURES        pfnSetHostFeatures,
 
248
                  PFNRESET                  pfnReset,
 
249
                  PFNREADY                  pfnReady,
 
250
                  PFNSETCONFIG              pfnSetConfig);
 
251
 
 
252
void  vpciSetWriteLed(PVPCISTATE pState, bool fOn);
 
253
void  vpciSetReadLed(PVPCISTATE pState, bool fOn);
 
254
int   vpciSaveExec(PVPCISTATE pState, PSSMHANDLE pSSM);
 
255
int   vpciLoadExec(PVPCISTATE pState, PSSMHANDLE pSSM,
 
256
                   uint32_t uVersion, uint32_t uPass,
 
257
                   uint32_t nQueues);
 
258
int   vpciConstruct(PPDMDEVINS pDevIns, VPCISTATE *pState,
 
259
                    int iInstance, const char *pcszNameFmt,
 
260
                    uint16_t uSubsystemId, uint16_t uClass,
 
261
                    uint32_t nQueues);
 
262
int   vpciDestruct(VPCISTATE* pState);
 
263
void  vpciRelocate(PPDMDEVINS pDevIns, RTGCINTPTR offDelta);
 
264
void  vpciReset(PVPCISTATE pState);
 
265
void *vpciQueryInterface(struct PDMIBASE *pInterface,
 
266
                         PDMINTERFACE enmInterface);
 
267
PVQUEUE vpciAddQueue(VPCISTATE* pState, unsigned uSize,
 
268
                     void (*pfnCallback)(void *pvState, PVQUEUE pQueue),
 
269
                     const char *pcszName);
 
270
 
 
271
#define VPCI_CS
 
272
DECLINLINE(int) vpciCsEnter(VPCISTATE *pState, int iBusyRc)
 
273
{
 
274
#ifdef VPCI_CS
 
275
    STAM_PROFILE_START(&pState->CTXSUFF(StatCs), a);
 
276
    int rc = PDMCritSectEnter(&pState->cs, iBusyRc);
 
277
    STAM_PROFILE_STOP(&pState->CTXSUFF(StatCs), a);
 
278
    return rc;
 
279
#else
 
280
    return VINF_SUCCESS;
 
281
#endif
 
282
}
 
283
 
 
284
DECLINLINE(void) vpciCsLeave(VPCISTATE *pState)
 
285
{
 
286
#ifdef VPCI_CS
 
287
    PDMCritSectLeave(&pState->cs);
 
288
#endif
 
289
}
 
290
 
 
291
void vringSetNotification(PVPCISTATE pState, PVRING pVRing, bool fEnabled);
 
292
 
 
293
DECLINLINE(uint16_t) vringReadAvailIndex(PVPCISTATE pState, PVRING pVRing)
 
294
{
 
295
    uint16_t tmp;
 
296
 
 
297
    PDMDevHlpPhysRead(pState->CTX_SUFF(pDevIns),
 
298
                      pVRing->addrAvail + RT_OFFSETOF(VRINGAVAIL, uNextFreeIndex),
 
299
                      &tmp, sizeof(tmp));
 
300
    return tmp;
 
301
}
 
302
 
 
303
bool vqueueGet(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem);
 
304
void vqueuePut(PVPCISTATE pState, PVQUEUE pQueue, PVQUEUEELEM pElem, uint32_t uLen);
 
305
void vqueueNotify(PVPCISTATE pState, PVQUEUE pQueue);
 
306
void vqueueSync(PVPCISTATE pState, PVQUEUE pQueue);
 
307
 
 
308
 
 
309
DECLINLINE(bool) vqueueIsReady(PVPCISTATE pState, PVQUEUE pQueue)
 
310
{
 
311
    return !!pQueue->VRing.addrAvail;
 
312
}
 
313
 
 
314
DECLINLINE(bool) vqueueIsEmpty(PVPCISTATE pState, PVQUEUE pQueue)
 
315
{
 
316
    return (vringReadAvailIndex(pState, &pQueue->VRing) == pQueue->uNextAvailIndex);
 
317
}
 
318
 
 
319
#endif /* ___VBox_Virtio_h */