xref: /kvmtool/virtio/core.c (revision b7af514c7ca3d87b2e2a2da9129b2bc4c86f78de)
1 #include <linux/virtio_ring.h>
2 #include <linux/types.h>
3 #include <sys/uio.h>
4 #include <stdlib.h>
5 
6 #include "kvm/guest_compat.h"
7 #include "kvm/barrier.h"
8 #include "kvm/virtio.h"
9 #include "kvm/virtio-pci.h"
10 #include "kvm/virtio-mmio.h"
11 #include "kvm/util.h"
12 #include "kvm/kvm.h"
13 
14 
15 const char* virtio_trans_name(enum virtio_trans trans)
16 {
17 	if (trans == VIRTIO_PCI)
18 		return "pci";
19 	else if (trans == VIRTIO_MMIO)
20 		return "mmio";
21 	return "unknown";
22 }
23 
24 void virt_queue__used_idx_advance(struct virt_queue *queue, u16 jump)
25 {
26 	u16 idx = virtio_guest_to_host_u16(queue, queue->vring.used->idx);
27 
28 	/*
29 	 * Use wmb to assure that used elem was updated with head and len.
30 	 * We need a wmb here since we can't advance idx unless we're ready
31 	 * to pass the used element to the guest.
32 	 */
33 	wmb();
34 	idx += jump;
35 	queue->vring.used->idx = virtio_host_to_guest_u16(queue, idx);
36 
37 	/*
38 	 * Use wmb to assure used idx has been increased before we signal the guest.
39 	 * Without a wmb here the guest may ignore the queue since it won't see
40 	 * an updated idx.
41 	 */
42 	wmb();
43 }
44 
45 struct vring_used_elem *
46 virt_queue__set_used_elem_no_update(struct virt_queue *queue, u32 head,
47 				    u32 len, u16 offset)
48 {
49 	struct vring_used_elem *used_elem;
50 	u16 idx = virtio_guest_to_host_u16(queue, queue->vring.used->idx);
51 
52 	idx += offset;
53 	used_elem	= &queue->vring.used->ring[idx % queue->vring.num];
54 	used_elem->id	= virtio_host_to_guest_u32(queue, head);
55 	used_elem->len	= virtio_host_to_guest_u32(queue, len);
56 
57 	return used_elem;
58 }
59 
60 struct vring_used_elem *virt_queue__set_used_elem(struct virt_queue *queue, u32 head, u32 len)
61 {
62 	struct vring_used_elem *used_elem;
63 
64 	used_elem = virt_queue__set_used_elem_no_update(queue, head, len, 0);
65 	virt_queue__used_idx_advance(queue, 1);
66 
67 	return used_elem;
68 }
69 
70 static inline bool virt_desc__test_flag(struct virt_queue *vq,
71 					struct vring_desc *desc, u16 flag)
72 {
73 	return !!(virtio_guest_to_host_u16(vq, desc->flags) & flag);
74 }
75 
76 /*
77  * Each buffer in the virtqueues is actually a chain of descriptors.  This
78  * function returns the next descriptor in the chain, or vq->vring.num if we're
79  * at the end.
80  */
81 static unsigned next_desc(struct virt_queue *vq, struct vring_desc *desc,
82 			  unsigned int i, unsigned int max)
83 {
84 	unsigned int next;
85 
86 	/* If this descriptor says it doesn't chain, we're done. */
87 	if (!virt_desc__test_flag(vq, &desc[i], VRING_DESC_F_NEXT))
88 		return max;
89 
90 	/* Check they're not leading us off end of descriptors. */
91 	next = virtio_guest_to_host_u16(vq, desc[i].next);
92 	/* Make sure compiler knows to grab that: we don't want it changing! */
93 	wmb();
94 
95 	return next;
96 }
97 
98 u16 virt_queue__get_head_iov(struct virt_queue *vq, struct iovec iov[], u16 *out, u16 *in, u16 head, struct kvm *kvm)
99 {
100 	struct vring_desc *desc;
101 	u16 idx;
102 	u16 max;
103 
104 	idx = head;
105 	*out = *in = 0;
106 	max = vq->vring.num;
107 	desc = vq->vring.desc;
108 
109 	if (virt_desc__test_flag(vq, &desc[idx], VRING_DESC_F_INDIRECT)) {
110 		max = virtio_guest_to_host_u32(vq, desc[idx].len) / sizeof(struct vring_desc);
111 		desc = guest_flat_to_host(kvm, virtio_guest_to_host_u64(vq, desc[idx].addr));
112 		idx = 0;
113 	}
114 
115 	do {
116 		/* Grab the first descriptor, and check it's OK. */
117 		iov[*out + *in].iov_len = virtio_guest_to_host_u32(vq, desc[idx].len);
118 		iov[*out + *in].iov_base = guest_flat_to_host(kvm,
119 							      virtio_guest_to_host_u64(vq, desc[idx].addr));
120 		/* If this is an input descriptor, increment that count. */
121 		if (virt_desc__test_flag(vq, &desc[idx], VRING_DESC_F_WRITE))
122 			(*in)++;
123 		else
124 			(*out)++;
125 	} while ((idx = next_desc(vq, desc, idx, max)) != max);
126 
127 	return head;
128 }
129 
130 u16 virt_queue__get_iov(struct virt_queue *vq, struct iovec iov[], u16 *out, u16 *in, struct kvm *kvm)
131 {
132 	u16 head;
133 
134 	head = virt_queue__pop(vq);
135 
136 	return virt_queue__get_head_iov(vq, iov, out, in, head, kvm);
137 }
138 
139 /* in and out are relative to guest */
140 u16 virt_queue__get_inout_iov(struct kvm *kvm, struct virt_queue *queue,
141 			      struct iovec in_iov[], struct iovec out_iov[],
142 			      u16 *in, u16 *out)
143 {
144 	struct vring_desc *desc;
145 	u16 head, idx;
146 
147 	idx = head = virt_queue__pop(queue);
148 	*out = *in = 0;
149 	do {
150 		u64 addr;
151 		desc = virt_queue__get_desc(queue, idx);
152 		addr = virtio_guest_to_host_u64(queue, desc->addr);
153 		if (virt_desc__test_flag(queue, desc, VRING_DESC_F_WRITE)) {
154 			in_iov[*in].iov_base = guest_flat_to_host(kvm, addr);
155 			in_iov[*in].iov_len = virtio_guest_to_host_u32(queue, desc->len);
156 			(*in)++;
157 		} else {
158 			out_iov[*out].iov_base = guest_flat_to_host(kvm, addr);
159 			out_iov[*out].iov_len = virtio_guest_to_host_u32(queue, desc->len);
160 			(*out)++;
161 		}
162 		if (virt_desc__test_flag(queue, desc, VRING_DESC_F_NEXT))
163 			idx = virtio_guest_to_host_u16(queue, desc->next);
164 		else
165 			break;
166 	} while (1);
167 
168 	return head;
169 }
170 
171 int virtio__get_dev_specific_field(int offset, bool msix, u32 *config_off)
172 {
173 	if (msix) {
174 		if (offset < 4)
175 			return VIRTIO_PCI_O_MSIX;
176 		else
177 			offset -= 4;
178 	}
179 
180 	*config_off = offset;
181 
182 	return VIRTIO_PCI_O_CONFIG;
183 }
184 
185 bool virtio_queue__should_signal(struct virt_queue *vq)
186 {
187 	u16 old_idx, new_idx, event_idx;
188 
189 	if (!vq->use_event_idx) {
190 		/*
191 		 * When VIRTIO_RING_F_EVENT_IDX isn't negotiated, interrupt the
192 		 * guest if it didn't explicitly request to be left alone.
193 		 */
194 		return !(virtio_guest_to_host_u16(vq, vq->vring.avail->flags) &
195 			 VRING_AVAIL_F_NO_INTERRUPT);
196 	}
197 
198 	old_idx		= vq->last_used_signalled;
199 	new_idx		= virtio_guest_to_host_u16(vq, vq->vring.used->idx);
200 	event_idx	= virtio_guest_to_host_u16(vq, vring_used_event(&vq->vring));
201 
202 	if (vring_need_event(event_idx, new_idx, old_idx)) {
203 		vq->last_used_signalled = new_idx;
204 		return true;
205 	}
206 
207 	return false;
208 }
209 
210 void virtio_set_guest_features(struct kvm *kvm, struct virtio_device *vdev,
211 			       void *dev, u32 features)
212 {
213 	/* TODO: fail negotiation if features & ~host_features */
214 
215 	vdev->features = features;
216 	vdev->ops->set_guest_features(kvm, dev, features);
217 }
218 
219 int virtio_init(struct kvm *kvm, void *dev, struct virtio_device *vdev,
220 		struct virtio_ops *ops, enum virtio_trans trans,
221 		int device_id, int subsys_id, int class)
222 {
223 	void *virtio;
224 
225 	switch (trans) {
226 	case VIRTIO_PCI:
227 		virtio = calloc(sizeof(struct virtio_pci), 1);
228 		if (!virtio)
229 			return -ENOMEM;
230 		vdev->virtio			= virtio;
231 		vdev->ops			= ops;
232 		vdev->ops->signal_vq		= virtio_pci__signal_vq;
233 		vdev->ops->signal_config	= virtio_pci__signal_config;
234 		vdev->ops->init			= virtio_pci__init;
235 		vdev->ops->exit			= virtio_pci__exit;
236 		vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class);
237 		break;
238 	case VIRTIO_MMIO:
239 		virtio = calloc(sizeof(struct virtio_mmio), 1);
240 		if (!virtio)
241 			return -ENOMEM;
242 		vdev->virtio			= virtio;
243 		vdev->ops			= ops;
244 		vdev->ops->signal_vq		= virtio_mmio_signal_vq;
245 		vdev->ops->signal_config	= virtio_mmio_signal_config;
246 		vdev->ops->init			= virtio_mmio_init;
247 		vdev->ops->exit			= virtio_mmio_exit;
248 		vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class);
249 		break;
250 	default:
251 		return -1;
252 	};
253 
254 	return 0;
255 }
256 
257 int virtio_compat_add_message(const char *device, const char *config)
258 {
259 	int len = 1024;
260 	int compat_id;
261 	char *title;
262 	char *desc;
263 
264 	title = malloc(len);
265 	if (!title)
266 		return -ENOMEM;
267 
268 	desc = malloc(len);
269 	if (!desc) {
270 		free(title);
271 		return -ENOMEM;
272 	}
273 
274 	snprintf(title, len, "%s device was not detected.", device);
275 	snprintf(desc,  len, "While you have requested a %s device, "
276 			     "the guest kernel did not initialize it.\n"
277 			     "\tPlease make sure that the guest kernel was "
278 			     "compiled with %s=y enabled in .config.",
279 			     device, config);
280 
281 	compat_id = compat__add_message(title, desc);
282 
283 	free(desc);
284 	free(title);
285 
286 	return compat_id;
287 }
288