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 max if we're at the 79 * 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 next = virtio_guest_to_host_u16(vq, desc[i].next); 91 92 /* Ensure they're not leading us off end of descriptors. */ 93 return min(next, max); 94 } 95 96 u16 virt_queue__get_head_iov(struct virt_queue *vq, struct iovec iov[], u16 *out, u16 *in, u16 head, struct kvm *kvm) 97 { 98 struct vring_desc *desc; 99 u16 idx; 100 u16 max; 101 102 idx = head; 103 *out = *in = 0; 104 max = vq->vring.num; 105 desc = vq->vring.desc; 106 107 if (virt_desc__test_flag(vq, &desc[idx], VRING_DESC_F_INDIRECT)) { 108 max = virtio_guest_to_host_u32(vq, desc[idx].len) / sizeof(struct vring_desc); 109 desc = guest_flat_to_host(kvm, virtio_guest_to_host_u64(vq, desc[idx].addr)); 110 idx = 0; 111 } 112 113 do { 114 /* Grab the first descriptor, and check it's OK. */ 115 iov[*out + *in].iov_len = virtio_guest_to_host_u32(vq, desc[idx].len); 116 iov[*out + *in].iov_base = guest_flat_to_host(kvm, 117 virtio_guest_to_host_u64(vq, desc[idx].addr)); 118 /* If this is an input descriptor, increment that count. */ 119 if (virt_desc__test_flag(vq, &desc[idx], VRING_DESC_F_WRITE)) 120 (*in)++; 121 else 122 (*out)++; 123 } while ((idx = next_desc(vq, desc, idx, max)) != max); 124 125 return head; 126 } 127 128 u16 virt_queue__get_iov(struct virt_queue *vq, struct iovec iov[], u16 *out, u16 *in, struct kvm *kvm) 129 { 130 u16 head; 131 132 head = virt_queue__pop(vq); 133 134 return virt_queue__get_head_iov(vq, iov, out, in, head, kvm); 135 } 136 137 /* in and out are relative to guest */ 138 u16 virt_queue__get_inout_iov(struct kvm *kvm, struct virt_queue *queue, 139 struct iovec in_iov[], struct iovec out_iov[], 140 u16 *in, u16 *out) 141 { 142 struct vring_desc *desc; 143 u16 head, idx; 144 145 idx = head = virt_queue__pop(queue); 146 *out = *in = 0; 147 do { 148 u64 addr; 149 desc = virt_queue__get_desc(queue, idx); 150 addr = virtio_guest_to_host_u64(queue, desc->addr); 151 if (virt_desc__test_flag(queue, desc, VRING_DESC_F_WRITE)) { 152 in_iov[*in].iov_base = guest_flat_to_host(kvm, addr); 153 in_iov[*in].iov_len = virtio_guest_to_host_u32(queue, desc->len); 154 (*in)++; 155 } else { 156 out_iov[*out].iov_base = guest_flat_to_host(kvm, addr); 157 out_iov[*out].iov_len = virtio_guest_to_host_u32(queue, desc->len); 158 (*out)++; 159 } 160 if (virt_desc__test_flag(queue, desc, VRING_DESC_F_NEXT)) 161 idx = virtio_guest_to_host_u16(queue, desc->next); 162 else 163 break; 164 } while (1); 165 166 return head; 167 } 168 169 int virtio__get_dev_specific_field(int offset, bool msix, u32 *config_off) 170 { 171 if (msix) { 172 if (offset < 4) 173 return VIRTIO_PCI_O_MSIX; 174 else 175 offset -= 4; 176 } 177 178 *config_off = offset; 179 180 return VIRTIO_PCI_O_CONFIG; 181 } 182 183 bool virtio_queue__should_signal(struct virt_queue *vq) 184 { 185 u16 old_idx, new_idx, event_idx; 186 187 if (!vq->use_event_idx) { 188 /* 189 * When VIRTIO_RING_F_EVENT_IDX isn't negotiated, interrupt the 190 * guest if it didn't explicitly request to be left alone. 191 */ 192 return !(virtio_guest_to_host_u16(vq, vq->vring.avail->flags) & 193 VRING_AVAIL_F_NO_INTERRUPT); 194 } 195 196 old_idx = vq->last_used_signalled; 197 new_idx = virtio_guest_to_host_u16(vq, vq->vring.used->idx); 198 event_idx = virtio_guest_to_host_u16(vq, vring_used_event(&vq->vring)); 199 200 if (vring_need_event(event_idx, new_idx, old_idx)) { 201 vq->last_used_signalled = new_idx; 202 return true; 203 } 204 205 return false; 206 } 207 208 void virtio_set_guest_features(struct kvm *kvm, struct virtio_device *vdev, 209 void *dev, u32 features) 210 { 211 /* TODO: fail negotiation if features & ~host_features */ 212 213 vdev->features = features; 214 vdev->ops->set_guest_features(kvm, dev, features); 215 } 216 217 void virtio_notify_status(struct kvm *kvm, struct virtio_device *vdev, 218 void *dev, u8 status) 219 { 220 u32 ext_status = status; 221 222 vdev->status &= ~VIRTIO_CONFIG_S_MASK; 223 vdev->status |= status; 224 225 /* Add a few hints to help devices */ 226 if ((status & VIRTIO_CONFIG_S_DRIVER_OK) && 227 !(vdev->status & VIRTIO__STATUS_START)) { 228 vdev->status |= VIRTIO__STATUS_START; 229 ext_status |= VIRTIO__STATUS_START; 230 231 } else if (!status && (vdev->status & VIRTIO__STATUS_START)) { 232 vdev->status &= ~VIRTIO__STATUS_START; 233 ext_status |= VIRTIO__STATUS_STOP; 234 } 235 236 if (vdev->ops->notify_status) 237 vdev->ops->notify_status(kvm, dev, ext_status); 238 } 239 240 int virtio_init(struct kvm *kvm, void *dev, struct virtio_device *vdev, 241 struct virtio_ops *ops, enum virtio_trans trans, 242 int device_id, int subsys_id, int class) 243 { 244 void *virtio; 245 246 switch (trans) { 247 case VIRTIO_PCI: 248 virtio = calloc(sizeof(struct virtio_pci), 1); 249 if (!virtio) 250 return -ENOMEM; 251 vdev->virtio = virtio; 252 vdev->ops = ops; 253 vdev->ops->signal_vq = virtio_pci__signal_vq; 254 vdev->ops->signal_config = virtio_pci__signal_config; 255 vdev->ops->init = virtio_pci__init; 256 vdev->ops->exit = virtio_pci__exit; 257 vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class); 258 break; 259 case VIRTIO_MMIO: 260 virtio = calloc(sizeof(struct virtio_mmio), 1); 261 if (!virtio) 262 return -ENOMEM; 263 vdev->virtio = virtio; 264 vdev->ops = ops; 265 vdev->ops->signal_vq = virtio_mmio_signal_vq; 266 vdev->ops->signal_config = virtio_mmio_signal_config; 267 vdev->ops->init = virtio_mmio_init; 268 vdev->ops->exit = virtio_mmio_exit; 269 vdev->ops->init(kvm, dev, vdev, device_id, subsys_id, class); 270 break; 271 default: 272 return -1; 273 }; 274 275 return 0; 276 } 277 278 int virtio_compat_add_message(const char *device, const char *config) 279 { 280 int len = 1024; 281 int compat_id; 282 char *title; 283 char *desc; 284 285 title = malloc(len); 286 if (!title) 287 return -ENOMEM; 288 289 desc = malloc(len); 290 if (!desc) { 291 free(title); 292 return -ENOMEM; 293 } 294 295 snprintf(title, len, "%s device was not detected.", device); 296 snprintf(desc, len, "While you have requested a %s device, " 297 "the guest kernel did not initialize it.\n" 298 "\tPlease make sure that the guest kernel was " 299 "compiled with %s=y enabled in .config.", 300 device, config); 301 302 compat_id = compat__add_message(title, desc); 303 304 free(desc); 305 free(title); 306 307 return compat_id; 308 } 309