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 old_idx = vq->last_used_signalled; 190 new_idx = virtio_guest_to_host_u16(vq, vq->vring.used->idx); 191 event_idx = virtio_guest_to_host_u16(vq, vring_used_event(&vq->vring)); 192 193 if (vring_need_event(event_idx, new_idx, old_idx)) { 194 vq->last_used_signalled = new_idx; 195 return true; 196 } 197 198 return false; 199 } 200 201 int virtio_init(struct kvm *kvm, void *dev, struct virtio_device *vdev, 202 struct virtio_ops *ops, enum virtio_trans trans, 203 int device_id, int subsys_id, int class) 204 { 205 void *virtio; 206 207 switch (trans) { 208 case VIRTIO_PCI: 209 virtio = calloc(sizeof(struct virtio_pci), 1); 210 if (!virtio) 211 return -ENOMEM; 212 vdev->virtio = virtio; 213 vdev->ops = ops; 214 vdev->ops->signal_vq = virtio_pci__signal_vq; 215 vdev->ops->signal_config = virtio_pci__signal_config; 216 vdev->ops->init = virtio_pci__init; 217 vdev->ops->exit = virtio_pci__exit; 218 vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class); 219 break; 220 case VIRTIO_MMIO: 221 virtio = calloc(sizeof(struct virtio_mmio), 1); 222 if (!virtio) 223 return -ENOMEM; 224 vdev->virtio = virtio; 225 vdev->ops = ops; 226 vdev->ops->signal_vq = virtio_mmio_signal_vq; 227 vdev->ops->signal_config = virtio_mmio_signal_config; 228 vdev->ops->init = virtio_mmio_init; 229 vdev->ops->exit = virtio_mmio_exit; 230 vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class); 231 break; 232 default: 233 return -1; 234 }; 235 236 return 0; 237 } 238 239 int virtio_compat_add_message(const char *device, const char *config) 240 { 241 int len = 1024; 242 int compat_id; 243 char *title; 244 char *desc; 245 246 title = malloc(len); 247 if (!title) 248 return -ENOMEM; 249 250 desc = malloc(len); 251 if (!desc) { 252 free(title); 253 return -ENOMEM; 254 } 255 256 snprintf(title, len, "%s device was not detected.", device); 257 snprintf(desc, len, "While you have requested a %s device, " 258 "the guest kernel did not initialize it.\n" 259 "\tPlease make sure that the guest kernel was " 260 "compiled with %s=y enabled in .config.", 261 device, config); 262 263 compat_id = compat__add_message(title, desc); 264 265 free(desc); 266 free(title); 267 268 return compat_id; 269 } 270