166c519689dea8da43ad119dbf5bc010a6121311
[linux-2.6.git] / include / linux / virtio_ring.h
1 #ifndef _LINUX_VIRTIO_RING_H
2 #define _LINUX_VIRTIO_RING_H
3 /* An interface for efficient virtio implementation, currently for use by KVM
4  * and lguest, but hopefully others soon.  Do NOT change this since it will
5  * break existing servers and clients.
6  *
7  * This header is BSD licensed so anyone can use the definitions to implement
8  * compatible drivers/servers.
9  *
10  * Copyright Rusty Russell IBM Corporation 2007. */
11 #include <linux/types.h>
12
13 /* This marks a buffer as continuing via the next field. */
14 #define VRING_DESC_F_NEXT       1
15 /* This marks a buffer as write-only (otherwise read-only). */
16 #define VRING_DESC_F_WRITE      2
17
18 /* The Host uses this in used->flags to advise the Guest: don't kick me when
19  * you add a buffer.  It's unreliable, so it's simply an optimization.  Guest
20  * will still kick if it's out of buffers. */
21 #define VRING_USED_F_NO_NOTIFY  1
22 /* The Guest uses this in avail->flags to advise the Host: don't interrupt me
23  * when you consume a buffer.  It's unreliable, so it's simply an
24  * optimization.  */
25 #define VRING_AVAIL_F_NO_INTERRUPT      1
26
27 /* Virtio ring descriptors: 16 bytes.  These can chain together via "next". */
28 struct vring_desc
29 {
30         /* Address (guest-physical). */
31         __u64 addr;
32         /* Length. */
33         __u32 len;
34         /* The flags as indicated above. */
35         __u16 flags;
36         /* We chain unused descriptors via this, too */
37         __u16 next;
38 };
39
40 struct vring_avail
41 {
42         __u16 flags;
43         __u16 idx;
44         __u16 ring[];
45 };
46
47 /* u32 is used here for ids for padding reasons. */
48 struct vring_used_elem
49 {
50         /* Index of start of used descriptor chain. */
51         __u32 id;
52         /* Total length of the descriptor chain which was used (written to) */
53         __u32 len;
54 };
55
56 struct vring_used
57 {
58         __u16 flags;
59         __u16 idx;
60         struct vring_used_elem ring[];
61 };
62
63 struct vring {
64         unsigned int num;
65
66         struct vring_desc *desc;
67
68         struct vring_avail *avail;
69
70         struct vring_used *used;
71 };
72
73 /* The standard layout for the ring is a continuous chunk of memory which looks
74  * like this.  We assume num is a power of 2.
75  *
76  * struct vring
77  * {
78  *      // The actual descriptors (16 bytes each)
79  *      struct vring_desc desc[num];
80  *
81  *      // A ring of available descriptor heads with free-running index.
82  *      __u16 avail_flags;
83  *      __u16 avail_idx;
84  *      __u16 available[num];
85  *
86  *      // Padding to the next align boundary.
87  *      char pad[];
88  *
89  *      // A ring of used descriptor heads with free-running index.
90  *      __u16 used_flags;
91  *      __u16 used_idx;
92  *      struct vring_used_elem used[num];
93  * };
94  */
95 static inline void vring_init(struct vring *vr, unsigned int num, void *p,
96                               unsigned long align)
97 {
98         vr->num = num;
99         vr->desc = p;
100         vr->avail = p + num*sizeof(struct vring_desc);
101         vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + align-1)
102                             & ~(align - 1));
103 }
104
105 static inline unsigned vring_size(unsigned int num, unsigned long align)
106 {
107         return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num)
108                  + align - 1) & ~(align - 1))
109                 + sizeof(__u16) * 2 + sizeof(struct vring_used_elem) * num;
110 }
111
112 #ifdef __KERNEL__
113 #include <linux/irqreturn.h>
114 struct virtio_device;
115 struct virtqueue;
116
117 struct virtqueue *vring_new_virtqueue(unsigned int num,
118                                       unsigned int vring_align,
119                                       struct virtio_device *vdev,
120                                       void *pages,
121                                       void (*notify)(struct virtqueue *vq),
122                                       void (*callback)(struct virtqueue *vq),
123                                       const char *name);
124 void vring_del_virtqueue(struct virtqueue *vq);
125 /* Filter out transport-specific feature bits. */
126 void vring_transport_features(struct virtio_device *vdev);
127
128 irqreturn_t vring_interrupt(int irq, void *_vq);
129 #endif /* __KERNEL__ */
130 #endif /* _LINUX_VIRTIO_RING_H */