diff options
| -rw-r--r-- | conformance.tex | 2 | ||||
| -rw-r--r-- | content.tex | 121 | ||||
| -rw-r--r-- | introduction.tex | 4 | ||||
| -rw-r--r-- | virtio-ring.h | 100 |
4 files changed, 102 insertions, 125 deletions
diff --git a/conformance.tex b/conformance.tex index 4896729..942afac 100644 --- a/conformance.tex +++ b/conformance.tex @@ -252,7 +252,7 @@ REQUIRED level requirements for the legacy interface for the transitional devices and drivers. The requirements for the legacy interface for transitional implementations -are located in sections named "Legacy Interface" listed below: +are located in sections named ``Legacy Interface'' listed below: \begin{itemize} \item Section \ref{sec:Basic Facilities of a Virtio Device / Feature Bits / Legacy Interface: A Note on Feature Bits} diff --git a/content.tex b/content.tex index 9775c44..58c3ebc 100644 --- a/content.tex +++ b/content.tex @@ -290,10 +290,10 @@ according to the following formula: \begin{lstlisting} #define ALIGN(x) (((x) + PAGE_SIZE) & ~PAGE_SIZE) -static inline unsigned vring_size(unsigned int qsz) +static inline unsigned virtq_size(unsigned int qsz) { - return ALIGN(sizeof(struct vring_desc)*qsz + sizeof(u16)*(3 + qsz)) - + ALIGN(sizeof(u16)*3 + sizeof(struct vring_used_elem)*qsz); + return ALIGN(sizeof(struct virtq_desc)*qsz + sizeof(u16)*(3 + qsz)) + + ALIGN(sizeof(u16)*3 + sizeof(struct virtq_used_elem)*qsz); } \end{lstlisting} @@ -303,18 +303,18 @@ devices and drivers MUST use the following virtqueue layout structure to locate elements of the virtqueue: \begin{lstlisting} -struct vring { +struct virtq { // The actual descriptors (16 bytes each) - struct vring_desc desc[ Queue Size ]; + struct virtq_desc desc[ Queue Size ]; // A ring of available descriptor heads with free-running index. - struct vring_avail avail; + struct virtq_avail avail; // Padding to the next PAGE_SIZE boundary. u8 pad[ Padding ]; // A ring of used descriptor heads with free-running index. - struct vring_used used; + struct virtq_used used; }; \end{lstlisting} @@ -384,18 +384,18 @@ device type. Most common is to begin the data with a header it with a status tailer for the device to write. \begin{lstlisting} -struct vring_desc { +struct virtq_desc { /* Address (guest-physical). */ le64 addr; /* Length. */ le32 len; /* This marks a buffer as continuing via the next field. */ -#define VRING_DESC_F_NEXT 1 +#define VIRTQ_DESC_F_NEXT 1 /* This marks a buffer as device write-only (otherwise device read-only). */ -#define VRING_DESC_F_WRITE 2 +#define VIRTQ_DESC_F_WRITE 2 /* This means the buffer contains a list of buffer descriptors. */ -#define VRING_DESC_F_INDIRECT 4 +#define VIRTQ_DESC_F_INDIRECT 4 /* The flags as indicated above. */ le16 flags; /* Next field if flags & NEXT */ @@ -406,6 +406,12 @@ struct vring_desc { The number of descriptors in the table is defined by the queue size for this virtqueue. +\begin{note} +The legacy \hyperref[intro:Virtio PCI Draft]{[Virtio PCI Draft]} +referred to this structure as vring_desc, and the constants as +VRING_DESC_F_NEXT, etc, but the layout and values were identical. +\end{note} + \devicenormative{\subsubsection}{The Virtqueue Descriptor Table}{Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Descriptor Table} A device MUST NOT write to a device-readable buffer, and a device SHOULD NOT read a device-writable buffer (it MAY do so for debugging or diagnostic @@ -418,10 +424,10 @@ this implies that loops in the descriptor chain are forbidden! \subsubsection{Indirect Descriptors}\label{sec:Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Descriptor Table / Indirect Descriptors} Some devices benefit by concurrently dispatching a large number -of large requests. The VIRTIO_RING_F_INDIRECT_DESC feature allows this (see \ref{sec:virtio-ring.h}~\nameref{sec:virtio-ring.h}). To increase +of large requests. The VIRTIO_F_INDIRECT_DESC feature allows this (see \ref{sec:virtio-ring.h}~\nameref{sec:virtio-ring.h}). To increase ring capacity the driver can store a table of indirect descriptors anywhere in memory, and insert a descriptor in main -virtqueue (with \field{flags}\&VRING_DESC_F_INDIRECT on) that refers to memory buffer +virtqueue (with \field{flags}\&VIRTQ_DESC_F_INDIRECT on) that refers to memory buffer containing this indirect descriptor table; \field{addr} and \field{len} refer to the indirect table address and length in bytes, respectively. @@ -433,35 +439,35 @@ which is a variable, so this code won't compile): \begin{lstlisting} struct indirect_descriptor_table { /* The actual descriptors (16 bytes each) */ - struct vring_desc desc[len / 16]; + struct virtq_desc desc[len / 16]; }; \end{lstlisting} The first indirect descriptor is located at start of the indirect descriptor table (index 0), additional indirect descriptors are chained by \field{next}. An indirect descriptor without a valid \field{next} -(with \field{flags}\&VRING_DESC_F_NEXT off) signals the end of the descriptor. +(with \field{flags}\&VIRTQ_DESC_F_NEXT off) signals the end of the descriptor. A single indirect descriptor table can include both device-readable and device-writable descriptors. \drivernormative{\paragraph}{Indirect Descriptors}{Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Descriptor Table / Indirect Descriptors} -The driver MUST NOT set the VRING_DESC_F_INDIRECT flag unless the -VIRTIO_RING_F_INDIRECT_DESC feature was negotiated. The driver MUST NOT -set the VRING_DESC_F_INDIRECT flag within an indirect descriptor (ie. only +The driver MUST NOT set the VIRTQ_DESC_F_INDIRECT flag unless the +VIRTIO_F_INDIRECT_DESC feature was negotiated. The driver MUST NOT +set the VIRTQ_DESC_F_INDIRECT flag within an indirect descriptor (ie. only one table per descriptor). \devicenormative{\paragraph}{Indirect Descriptors}{Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Descriptor Table / Indirect Descriptors} -The device MUST ignore the write-only flag (\field{flags}\&VRING_DESC_F_WRITE) in the descriptor that refers to an indirect table. +The device MUST ignore the write-only flag (\field{flags}\&VIRTQ_DESC_F_WRITE) in the descriptor that refers to an indirect table. \subsection{The Virtqueue Available Ring}\label{sec:Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Available Ring} \begin{lstlisting} -struct vring_avail { -#define VRING_AVAIL_F_NO_INTERRUPT 1 +struct virtq_avail { +#define VIRTQ_AVAIL_F_NO_INTERRUPT 1 le16 flags; le16 idx; le16 ring[ /* Queue Size */ ]; - le16 used_event; /* Only if VIRTIO_RING_F_EVENT_IDX */ + le16 used_event; /* Only if VIRTIO_F_EVENT_IDX */ }; \end{lstlisting} @@ -472,9 +478,15 @@ written by the driver and read by the device. \field{idx} field indicates where the driver would put the next descriptor entry in the ring (modulo the queue size). This starts at 0, and increases. +\begin{note} +The legacy \hyperref[intro:Virtio PCI Draft]{[Virtio PCI Draft]} +referred to this structure as vring_avail, and the constant as +VRING_AVAIL_F_NO_INTERRUPT, but the layout and value were identical. +\end{note} + \subsection{Virtqueue Interrupt Suppression}\label{sec:Basic Facilities of a Virtio Device / Virtqueues / Virtqueue Interrupt Suppression} -If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated, +If the VIRTIO_F_EVENT_IDX feature bit is not negotiated, the \field{flags} field in the available ring offers a crude mechanism for the driver to inform the device that it doesn't want interrupts when buffers are used. Otherwise \field{used_event} is a more performant alterative where the driver @@ -485,14 +497,14 @@ are not synchronized with the device, but they serve as useful optimizations. \drivernormative{\subsubsection}{Virtqueue Interrupt Suppression}{Basic Facilities of a Virtio Device / Virtqueues / Virtqueue Interrupt Suppression} -If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated: +If the VIRTIO_F_EVENT_IDX feature bit is not negotiated: \begin{itemize} \item The driver MUST set \field{flags} to 0 or 1. \item The driver MAY set \field{flags} to 1 to advise the device that interrupts are not needed. \end{itemize} -Otherwise, if the VIRTIO_RING_F_EVENT_IDX feature bit is negotiated: +Otherwise, if the VIRTIO_F_EVENT_IDX feature bit is negotiated: \begin{itemize} \item The driver MUST set \field{flags} to 0. \item The driver MAY use \field{used_event} to advise the device that interrupts are unnecessary until the device writes entry with an index specified by \field{used_event} into the used ring (equivalently, until \field{idx} in the @@ -503,7 +515,7 @@ The driver MUST handle spurious interrupts from the device. \devicenormative{\subsubsection}{Virtqueue Interrupt Suppression}{Basic Facilities of a Virtio Device / Virtqueues / Virtqueue Interrupt Suppression} -If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated: +If the VIRTIO_F_EVENT_IDX feature bit is not negotiated: \begin{itemize} \item The device MUST ignore the \field{used_event} value. \item After the device writes a descriptor index into the used ring: @@ -513,7 +525,7 @@ If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated: \end{itemize} \end{itemize} -Otherwise, if the VIRTIO_RING_F_EVENT_IDX feature bit is negotiated: +Otherwise, if the VIRTIO_F_EVENT_IDX feature bit is negotiated: \begin{itemize} \item The device MUST ignore the lower bit of \field{flags}. \item After the device writes a descriptor index into the used ring: @@ -527,23 +539,23 @@ Otherwise, if the VIRTIO_RING_F_EVENT_IDX feature bit is negotiated: \begin{note} For example, if \field{used_event} is 0, then a device using - VIRTIO_RING_F_EVENT_IDX would interrupt after the first buffer is + VIRTIO_F_EVENT_IDX would interrupt after the first buffer is used (and again after the 65536th buffer, etc). \end{note} \subsection{The Virtqueue Used Ring}\label{sec:Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Used Ring} \begin{lstlisting} -struct vring_used { -#define VRING_USED_F_NO_NOTIFY 1 +struct virtq_used { +#define VIRTQ_USED_F_NO_NOTIFY 1 le16 flags; le16 idx; - struct vring_used_elem ring[ /* Queue Size */]; - le16 avail_event; /* Only if VIRTIO_RING_F_EVENT_IDX */ + struct virtq_used_elem ring[ /* Queue Size */]; + le16 avail_event; /* Only if VIRTIO_F_EVENT_IDX */ }; /* le32 is used here for ids for padding reasons. */ -struct vring_used_elem { +struct virtq_used_elem { /* Index of start of used descriptor chain. */ le32 id; /* Total length of the descriptor chain which was used (written to) */ @@ -562,6 +574,13 @@ for drivers using untrusted buffers: if you do not know exactly how much has been written by the device, you usually have to zero the buffer to ensure no data leakage occurs. +\begin{note} +The legacy \hyperref[intro:Virtio PCI Draft]{[Virtio PCI Draft]} +referred to these structures as vring_used and vring_used_elem, and +the constant as VRING_USED_F_NO_NOTIFY, but the layout and value were +identical. +\end{note} + \subsection{Virtqueue Notification Suppression}\label{sec:Basic Facilities of a Virtio Device / Virtqueues / Virtqueue Notification Suppression} The device can suppress notifications in a manner analogous to the way @@ -574,7 +593,7 @@ same way the driver manipulates \field{flags} or \field{used_event} in the avail The driver MUST initialize \field{flags} in the used ring to 0 when allocating the used ring. -If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated: +If the VIRTIO_F_EVENT_IDX feature bit is not negotiated: \begin{itemize} \item The driver MUST ignore the \field{avail_event} value. \item After the driver writes a descriptor index into the available ring: @@ -584,7 +603,7 @@ If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated: \end{itemize} \end{itemize} -Otherwise, if the VIRTIO_RING_F_EVENT_IDX feature bit is negotiated: +Otherwise, if the VIRTIO_F_EVENT_IDX feature bit is negotiated: \begin{itemize} \item The driver MUST ignore the lower bit of \field{flags}. \item After the driver writes a descriptor index into the available ring: @@ -597,14 +616,14 @@ Otherwise, if the VIRTIO_RING_F_EVENT_IDX feature bit is negotiated: \end{itemize} \devicenormative{\subsubsection}{Virtqueue Notification Suppression}{Basic Facilities of a Virtio Device / Virtqueues / Virtqueue Notification Suppression} -If the VIRTIO_RING_F_EVENT_IDX feature bit is not negotiated: +If the VIRTIO_F_EVENT_IDX feature bit is not negotiated: \begin{itemize} \item The device MUST set \field{flags} to 0 or 1. \item The device MAY set \field{flags} to 1 to advise the driver that notifications are not needed. \end{itemize} -Otherwise, if the VIRTIO_RING_F_EVENT_IDX feature bit is negotiated: +Otherwise, if the VIRTIO_F_EVENT_IDX feature bit is negotiated: \begin{itemize} \item The device MUST set \field{flags} to 0. \item The device MAY use \field{avail_event} to advise the driver that notifications are unnecessary until the driver writes entry with an index specified by \field{avail_event} into the available ring (equivalently, until \field{idx} in the @@ -778,13 +797,13 @@ for each buffer element, b: \item Get the next free descriptor table entry, d \item Set \field{d.addr} to the physical address of the start of b \item Set \field{d.len} to the length of b. -\item If b is device-writable, set \field{d.flags} to VRING_DESC_F_WRITE, +\item If b is device-writable, set \field{d.flags} to VIRTQ_DESC_F_WRITE, otherwise 0. \item If there is a buffer element after this: \begin{enumerate} \item Set \field{d.next} to the index of the next free descriptor element. - \item Set the VRING_DESC_F_NEXT bit in \field{d.flags}. + \item Set the VIRTQ_DESC_F_NEXT bit in \field{d.flags}. \end{enumerate} \end{enumerate} @@ -855,20 +874,20 @@ emptying the ring and reenabling interrupts. This is usually handled by re-checking for more used buffers after interrups are re-enabled: \begin{lstlisting} -vring_disable_interrupts(vq); +virtq_disable_interrupts(vq); for (;;) { - if (vq->last_seen_used != le16_to_cpu(vring->used.idx)) { - vring_enable_interrupts(vq); + if (vq->last_seen_used != le16_to_cpu(virtq->used.idx)) { + virtq_enable_interrupts(vq); mb(); - if (vq->last_seen_used != le16_to_cpu(vring->used.idx)) + if (vq->last_seen_used != le16_to_cpu(virtq->used.idx)) break; - vring_disable_interrupts(vq); + virtq_disable_interrupts(vq); } - struct vring_used_elem *e = vring.used->ring[vq->last_seen_used%vsz]; + struct virtq_used_elem *e = virtq.used->ring[vq->last_seen_used%vsz]; process_buffer(e); vq->last_seen_used++; } @@ -2487,11 +2506,11 @@ The calculation for total size is as follows: \begin{lstlisting} #define ALIGN(x) (((x) + align) & ~align) -static inline unsigned vring_size(unsigned int num) +static inline unsigned virtq_size(unsigned int num) { - return ALIGN(sizeof(struct vring_desc)*num + return ALIGN(sizeof(struct virtq_desc)*num + sizeof(u16)*(3 + num)) - + ALIGN(sizeof(u16)*3 + sizeof(struct vring_used_elem)*num); + + ALIGN(sizeof(u16)*3 + sizeof(struct virtq_used_elem)*num); } \end{lstlisting} @@ -3135,7 +3154,7 @@ which case it MUST set the VIRTIO_NET_HDR_GSO_ECN bit in \field{gso_type}. \paragraph{Packet Transmission Interrupt}\label{sec:Device Types / Network Device / Device Operation / Packet Transmission / Packet Transmission Interrupt} Often a driver will suppress transmission interrupts using the -VRING_AVAIL_F_NO_INTERRUPT flag +VIRTQ_AVAIL_F_NO_INTERRUPT flag (see \ref{sec:General Initialization And Device Operation / Device Operation / Receiving Used Buffers From The Device}~\nameref{sec:General Initialization And Device Operation / Device Operation / Receiving Used Buffers From The Device}) and check for used packets in the transmit path of following packets. @@ -4948,7 +4967,7 @@ Currently there are three device-independent feature bits defined: \begin{description} \item[VIRTIO_F_RING_INDIRECT_DESC (28)] Negotiating this feature indicates - that the driver can use descriptors with the VRING_DESC_F_INDIRECT + that the driver can use descriptors with the VIRTQ_DESC_F_INDIRECT flag set, as described in \ref{sec:Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Descriptor Table / Indirect Descriptors}~\nameref{sec:Basic Facilities of a Virtio Device / Virtqueues / The Virtqueue Descriptor Table / Indirect Descriptors}. \item[VIRTIO_F_RING_EVENT_IDX(29)] This feature enables the \field{used_event} @@ -4976,7 +4995,7 @@ Transitional devices MAY offer the following: has been negotiated by driver, the device MUST issue an interrupt if the device runs out of available descriptors on a virtqueue, even though - interrupts are suppressed using the VRING_AVAIL_F_NO_INTERRUPT + interrupts are suppressed using the VIRTQ_AVAIL_F_NO_INTERRUPT flag or the \field{used_event} field. \begin{note} An example of a driver using this feature is the legacy diff --git a/introduction.tex b/introduction.tex index f8ea424..ac7eefa 100644 --- a/introduction.tex +++ b/introduction.tex @@ -38,8 +38,8 @@ between different transports. \begin{longtable}{l p{5in}} \phantomsection\label{intro:rfc2119}\textbf{[RFC2119]} & -Bradner S., "Key words for use in RFCs to Indicate Requirement -Levels", BCP 14, RFC 2119, March 1997. \newline\url{http://www.ietf.org/rfc/rfc2119.txt}\\ +Bradner S., ``Key words for use in RFCs to Indicate Requirement +Levels'', BCP 14, RFC 2119, March 1997. \newline\url{http://www.ietf.org/rfc/rfc2119.txt}\\ \phantomsection\label{intro:S390 PoP}\textbf{[S390 PoP]} & z/Architecture Principles of Operation, IBM Publication SA22-7832, \newline\url{http://publibfi.boulder.ibm.com/epubs/pdf/dz9zr009.pdf}, and any future revisions\\ \phantomsection\label{intro:S390 Common I/O}\textbf{[S390 Common I/O]} & ESA/390 Common I/O-Device and Self-Description, IBM Publication SA22-7204, \newline\url{http://publibfp.dhe.ibm.com/cgi-bin/bookmgr/BOOKS/dz9ar501/CCONTENTS}, and any future revisions\\ \phantomsection\label{intro:PCI}\textbf{[PCI]} & diff --git a/virtio-ring.h b/virtio-ring.h index 6d1e2dd..aa01d92 100644 --- a/virtio-ring.h +++ b/virtio-ring.h @@ -1,5 +1,5 @@ -#ifndef VIRTIO_RING_H -#define VIRTIO_RING_H +#ifndef VIRTQUEUE_H +#define VIRTQUEUE_H /* An interface for efficient virtio implementation. * * This header is BSD licensed so anyone can use the definitions @@ -35,33 +35,33 @@ #include <stdint.h> /* This marks a buffer as continuing via the next field. */ -#define VRING_DESC_F_NEXT 1 +#define VIRTQ_DESC_F_NEXT 1 /* This marks a buffer as write-only (otherwise read-only). */ -#define VRING_DESC_F_WRITE 2 +#define VIRTQ_DESC_F_WRITE 2 /* This means the buffer contains a list of buffer descriptors. */ -#define VRING_DESC_F_INDIRECT 4 +#define VIRTQ_DESC_F_INDIRECT 4 /* The device uses this in used->flags to advise the driver: don't kick me * when you add a buffer. It's unreliable, so it's simply an * optimization. */ -#define VRING_USED_F_NO_NOTIFY 1 +#define VIRTQ_USED_F_NO_NOTIFY 1 /* The driver uses this in avail->flags to advise the device: don't * interrupt me when you consume a buffer. It's unreliable, so it's * simply an optimization. */ -#define VRING_AVAIL_F_NO_INTERRUPT 1 +#define VIRTQ_AVAIL_F_NO_INTERRUPT 1 /* Support for indirect descriptors */ -#define VIRTIO_RING_F_INDIRECT_DESC 28 +#define VIRTIO_F_INDIRECT_DESC 28 /* Support for avail_idx and used_idx fields */ -#define VIRTIO_RING_F_EVENT_IDX 29 +#define VIRTIO_F_EVENT_IDX 29 /* Arbitrary descriptor layouts. */ -#define VIRTIO_F_ANY_LAYOUT 27 +#define VIRTIO_F_ANY_LAYOUT 27 -/* Virtio ring descriptors: 16 bytes. +/* Virtqueue descriptors: 16 bytes. * These can chain together via "next". */ -struct vring_desc { +struct virtq_desc { /* Address (guest-physical). */ le64 addr; /* Length. */ @@ -72,93 +72,51 @@ struct vring_desc { le16 next; }; -struct vring_avail { +struct virtq_avail { le16 flags; le16 idx; le16 ring[]; - /* Only if VIRTIO_RING_F_EVENT_IDX: le16 used_event; */ + /* Only if VIRTIO_F_EVENT_IDX: le16 used_event; */ }; /* le32 is used here for ids for padding reasons. */ -struct vring_used_elem { +struct virtq_used_elem { /* Index of start of used descriptor chain. */ le32 id; /* Total length of the descriptor chain which was written to. */ le32 len; }; -struct vring_used { +struct virtq_used { le16 flags; le16 idx; - struct vring_used_elem ring[]; - /* Only if VIRTIO_RING_F_EVENT_IDX: le16 avail_event; */ + struct virtq_used_elem ring[]; + /* Only if VIRTIO_F_EVENT_IDX: le16 avail_event; */ }; -struct vring { +struct virtq { unsigned int num; - struct vring_desc *desc; - struct vring_avail *avail; - struct vring_used *used; + struct virtq_desc *desc; + struct virtq_avail *avail; + struct virtq_used *used; }; -/* The standard layout for the ring is a continuous chunk of memory which - * looks like this. We assume num is a power of 2. - * - * struct vring { - * // The actual descriptors (16 bytes each) - * struct vring_desc desc[num]; - * - * // A ring of available descriptor heads with free-running index. - * le16 avail_flags; - * le16 avail_idx; - * le16 available[num]; - * le16 used_event_idx; // Only if VIRTIO_RING_F_EVENT_IDX - * - * // Padding to the next align boundary. - * char pad[]; - * - * // A ring of used descriptor heads with free-running index. - * le16 used_flags; - * le16 used_idx; - * struct vring_used_elem used[num]; - * le16 avail_event_idx; // Only if VIRTIO_RING_F_EVENT_IDX - * }; - * Note: for virtio PCI, align is 4096. - */ -static inline void vring_init(struct vring *vr, unsigned int num, void *p, - unsigned long align) -{ - vr->num = num; - vr->desc = p; - vr->avail = p + num*sizeof(struct vring_desc); - vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(le16) - + align-1) - & ~(align - 1)); -} - -static inline unsigned vring_size(unsigned int num, unsigned long align) -{ - return ((sizeof(struct vring_desc)*num + sizeof(le16)*(3+num) - + align - 1) & ~(align - 1)) - + sizeof(le16)*3 + sizeof(struct vring_used_elem)*num; -} - -static inline int vring_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old_idx) +static inline int virtq_need_event(uint16_t event_idx, uint16_t new_idx, uint16_t old_idx) { return (uint16_t)(new_idx - event_idx - 1) < (uint16_t)(new_idx - old_idx); } -/* Get location of event indices (only with VIRTIO_RING_F_EVENT_IDX) */ -static inline le16 *vring_used_event(struct vring *vr) +/* Get location of event indices (only with VIRTIO_F_EVENT_IDX) */ +static inline le16 *virtq_used_event(struct virtq *vq) { /* For backwards compat, used event index is at *end* of avail ring. */ - return &vr->avail->ring[vr->num]; + return &vq->avail->ring[vq->num]; } -static inline le16 *vring_avail_event(struct vring *vr) +static inline le16 *virtq_avail_event(struct virtq *vq) { /* For backwards compat, avail event index is at *end* of used ring. */ - return (le16 *)&vr->used->ring[vr->num]; + return (le16 *)&vq->used->ring[vq->num]; } -#endif /* VIRTIO_RING_H */ +#endif /* VIRTQUEUE_H */ |