| #ifndef _LINUX_VIRTIO_RING_H |
| #define _LINUX_VIRTIO_RING_H |
| /* An interface for efficient virtio implementation, currently for use by KVM |
| * and lguest, but hopefully others soon. Do NOT change this since it will |
| * break existing servers and clients. |
| * |
| * This header is BSD licensed so anyone can use the definitions to implement |
| * compatible drivers/servers. |
| * |
| * Copyright Rusty Russell IBM Corporation 2007. */ |
| #include <linux/types.h> |
| |
| /* This marks a buffer as continuing via the next field. */ |
| #define VRING_DESC_F_NEXT 1 |
| /* This marks a buffer as write-only (otherwise read-only). */ |
| #define VRING_DESC_F_WRITE 2 |
| /* This means the buffer contains a list of buffer descriptors. */ |
| #define VRING_DESC_F_INDIRECT 4 |
| |
| /* The Host uses this in used->flags to advise the Guest: don't kick me when |
| * you add a buffer. It's unreliable, so it's simply an optimization. Guest |
| * will still kick if it's out of buffers. */ |
| #define VRING_USED_F_NO_NOTIFY 1 |
| /* The Guest uses this in avail->flags to advise the Host: 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 |
| |
| /* We support indirect buffer descriptors */ |
| #define VIRTIO_RING_F_INDIRECT_DESC 28 |
| |
| /* Virtio ring descriptors: 16 bytes. These can chain together via "next". */ |
| struct vring_desc { |
| /* Address (guest-physical). */ |
| __u64 addr; |
| /* Length. */ |
| __u32 len; |
| /* The flags as indicated above. */ |
| __u16 flags; |
| /* We chain unused descriptors via this, too */ |
| __u16 next; |
| }; |
| |
| struct vring_avail { |
| __u16 flags; |
| __u16 idx; |
| __u16 ring[]; |
| }; |
| |
| /* u32 is used here for ids for padding reasons. */ |
| struct vring_used_elem { |
| /* Index of start of used descriptor chain. */ |
| __u32 id; |
| /* Total length of the descriptor chain which was used (written to) */ |
| __u32 len; |
| }; |
| |
| struct vring_used { |
| __u16 flags; |
| __u16 idx; |
| struct vring_used_elem ring[]; |
| }; |
| |
| struct vring { |
| unsigned int num; |
| |
| struct vring_desc *desc; |
| |
| struct vring_avail *avail; |
| |
| struct vring_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. |
| * __u16 avail_flags; |
| * __u16 avail_idx; |
| * __u16 available[num]; |
| * |
| * // Padding to the next align boundary. |
| * char pad[]; |
| * |
| * // A ring of used descriptor heads with free-running index. |
| * __u16 used_flags; |
| * __u16 used_idx; |
| * struct vring_used_elem used[num]; |
| * }; |
| */ |
| 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] + align-1) |
| & ~(align - 1)); |
| } |
| |
| static __inline__ unsigned vring_size(unsigned int num, unsigned long align) |
| { |
| return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num) |
| + align - 1) & ~(align - 1)) |
| + sizeof(__u16) * 2 + sizeof(struct vring_used_elem) * num; |
| } |
| |
| #endif /* _LINUX_VIRTIO_RING_H */ |