1 /* 2 * vhost-net support 3 * 4 * Copyright Red Hat, Inc. 2010 5 * 6 * Authors: 7 * Michael S. Tsirkin <mst@redhat.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2. See 10 * the COPYING file in the top-level directory. 11 * 12 * Contributions after 2012-01-13 are licensed under the terms of the 13 * GNU GPL, version 2 or (at your option) any later version. 14 */ 15 16 #include "qemu/osdep.h" 17 #include "net/net.h" 18 #include "net/tap.h" 19 #include "net/vhost-user.h" 20 21 #include "standard-headers/linux/vhost_types.h" 22 #include "hw/virtio/virtio-net.h" 23 #include "net/vhost_net.h" 24 #include "qemu/error-report.h" 25 #include "qemu/main-loop.h" 26 27 #include <sys/socket.h> 28 #include <net/if.h> 29 #include <netinet/in.h> 30 31 32 #include "standard-headers/linux/virtio_ring.h" 33 #include "hw/virtio/vhost.h" 34 #include "hw/virtio/virtio-bus.h" 35 36 struct vhost_net { 37 struct vhost_dev dev; 38 struct vhost_virtqueue vqs[2]; 39 int backend; 40 NetClientState *nc; 41 }; 42 43 /* Features supported by host kernel. */ 44 static const int kernel_feature_bits[] = { 45 VIRTIO_F_NOTIFY_ON_EMPTY, 46 VIRTIO_RING_F_INDIRECT_DESC, 47 VIRTIO_RING_F_EVENT_IDX, 48 VIRTIO_NET_F_MRG_RXBUF, 49 VIRTIO_F_VERSION_1, 50 VIRTIO_NET_F_MTU, 51 VIRTIO_F_IOMMU_PLATFORM, 52 VIRTIO_F_RING_PACKED, 53 VHOST_INVALID_FEATURE_BIT 54 }; 55 56 /* Features supported by others. */ 57 static const int user_feature_bits[] = { 58 VIRTIO_F_NOTIFY_ON_EMPTY, 59 VIRTIO_RING_F_INDIRECT_DESC, 60 VIRTIO_RING_F_EVENT_IDX, 61 62 VIRTIO_F_ANY_LAYOUT, 63 VIRTIO_F_VERSION_1, 64 VIRTIO_NET_F_CSUM, 65 VIRTIO_NET_F_GUEST_CSUM, 66 VIRTIO_NET_F_GSO, 67 VIRTIO_NET_F_GUEST_TSO4, 68 VIRTIO_NET_F_GUEST_TSO6, 69 VIRTIO_NET_F_GUEST_ECN, 70 VIRTIO_NET_F_GUEST_UFO, 71 VIRTIO_NET_F_HOST_TSO4, 72 VIRTIO_NET_F_HOST_TSO6, 73 VIRTIO_NET_F_HOST_ECN, 74 VIRTIO_NET_F_HOST_UFO, 75 VIRTIO_NET_F_MRG_RXBUF, 76 VIRTIO_NET_F_MTU, 77 VIRTIO_F_IOMMU_PLATFORM, 78 VIRTIO_F_RING_PACKED, 79 80 /* This bit implies RARP isn't sent by QEMU out of band */ 81 VIRTIO_NET_F_GUEST_ANNOUNCE, 82 83 VIRTIO_NET_F_MQ, 84 85 VHOST_INVALID_FEATURE_BIT 86 }; 87 88 static const int *vhost_net_get_feature_bits(struct vhost_net *net) 89 { 90 const int *feature_bits = 0; 91 92 switch (net->nc->info->type) { 93 case NET_CLIENT_DRIVER_TAP: 94 feature_bits = kernel_feature_bits; 95 break; 96 case NET_CLIENT_DRIVER_VHOST_USER: 97 feature_bits = user_feature_bits; 98 break; 99 default: 100 error_report("Feature bits not defined for this type: %d", 101 net->nc->info->type); 102 break; 103 } 104 105 return feature_bits; 106 } 107 108 uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features) 109 { 110 return vhost_get_features(&net->dev, vhost_net_get_feature_bits(net), 111 features); 112 } 113 114 void vhost_net_ack_features(struct vhost_net *net, uint64_t features) 115 { 116 net->dev.acked_features = net->dev.backend_features; 117 vhost_ack_features(&net->dev, vhost_net_get_feature_bits(net), features); 118 } 119 120 uint64_t vhost_net_get_max_queues(VHostNetState *net) 121 { 122 return net->dev.max_queues; 123 } 124 125 uint64_t vhost_net_get_acked_features(VHostNetState *net) 126 { 127 return net->dev.acked_features; 128 } 129 130 static int vhost_net_get_fd(NetClientState *backend) 131 { 132 switch (backend->info->type) { 133 case NET_CLIENT_DRIVER_TAP: 134 return tap_get_fd(backend); 135 default: 136 fprintf(stderr, "vhost-net requires tap backend\n"); 137 return -ENOSYS; 138 } 139 } 140 141 struct vhost_net *vhost_net_init(VhostNetOptions *options) 142 { 143 int r; 144 bool backend_kernel = options->backend_type == VHOST_BACKEND_TYPE_KERNEL; 145 struct vhost_net *net = g_new0(struct vhost_net, 1); 146 uint64_t features = 0; 147 148 if (!options->net_backend) { 149 fprintf(stderr, "vhost-net requires net backend to be setup\n"); 150 goto fail; 151 } 152 net->nc = options->net_backend; 153 154 net->dev.max_queues = 1; 155 net->dev.nvqs = 2; 156 net->dev.vqs = net->vqs; 157 158 if (backend_kernel) { 159 r = vhost_net_get_fd(options->net_backend); 160 if (r < 0) { 161 goto fail; 162 } 163 net->dev.backend_features = qemu_has_vnet_hdr(options->net_backend) 164 ? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR); 165 net->backend = r; 166 net->dev.protocol_features = 0; 167 } else { 168 net->dev.backend_features = 0; 169 net->dev.protocol_features = 0; 170 net->backend = -1; 171 172 /* vhost-user needs vq_index to initiate a specific queue pair */ 173 net->dev.vq_index = net->nc->queue_index * net->dev.nvqs; 174 } 175 176 r = vhost_dev_init(&net->dev, options->opaque, 177 options->backend_type, options->busyloop_timeout); 178 if (r < 0) { 179 goto fail; 180 } 181 if (backend_kernel) { 182 if (!qemu_has_vnet_hdr_len(options->net_backend, 183 sizeof(struct virtio_net_hdr_mrg_rxbuf))) { 184 net->dev.features &= ~(1ULL << VIRTIO_NET_F_MRG_RXBUF); 185 } 186 if (~net->dev.features & net->dev.backend_features) { 187 fprintf(stderr, "vhost lacks feature mask %" PRIu64 188 " for backend\n", 189 (uint64_t)(~net->dev.features & net->dev.backend_features)); 190 goto fail; 191 } 192 } 193 194 /* Set sane init value. Override when guest acks. */ 195 #ifdef CONFIG_VHOST_NET_USER 196 if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) { 197 features = vhost_user_get_acked_features(net->nc); 198 if (~net->dev.features & features) { 199 fprintf(stderr, "vhost lacks feature mask %" PRIu64 200 " for backend\n", 201 (uint64_t)(~net->dev.features & features)); 202 goto fail; 203 } 204 } 205 #endif 206 207 vhost_net_ack_features(net, features); 208 209 return net; 210 211 fail: 212 vhost_dev_cleanup(&net->dev); 213 g_free(net); 214 return NULL; 215 } 216 217 static void vhost_net_set_vq_index(struct vhost_net *net, int vq_index) 218 { 219 net->dev.vq_index = vq_index; 220 } 221 222 static int vhost_net_start_one(struct vhost_net *net, 223 VirtIODevice *dev) 224 { 225 struct vhost_vring_file file = { }; 226 int r; 227 228 net->dev.nvqs = 2; 229 net->dev.vqs = net->vqs; 230 231 r = vhost_dev_enable_notifiers(&net->dev, dev); 232 if (r < 0) { 233 goto fail_notifiers; 234 } 235 236 r = vhost_dev_start(&net->dev, dev); 237 if (r < 0) { 238 goto fail_start; 239 } 240 241 if (net->nc->info->poll) { 242 net->nc->info->poll(net->nc, false); 243 } 244 245 if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) { 246 qemu_set_fd_handler(net->backend, NULL, NULL, NULL); 247 file.fd = net->backend; 248 for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { 249 if (!virtio_queue_enabled(dev, net->dev.vq_index + 250 file.index)) { 251 /* Queue might not be ready for start */ 252 continue; 253 } 254 r = vhost_net_set_backend(&net->dev, &file); 255 if (r < 0) { 256 r = -errno; 257 goto fail; 258 } 259 } 260 } 261 return 0; 262 fail: 263 file.fd = -1; 264 if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) { 265 while (file.index-- > 0) { 266 if (!virtio_queue_enabled(dev, net->dev.vq_index + 267 file.index)) { 268 /* Queue might not be ready for start */ 269 continue; 270 } 271 int r = vhost_net_set_backend(&net->dev, &file); 272 assert(r >= 0); 273 } 274 } 275 if (net->nc->info->poll) { 276 net->nc->info->poll(net->nc, true); 277 } 278 vhost_dev_stop(&net->dev, dev); 279 fail_start: 280 vhost_dev_disable_notifiers(&net->dev, dev); 281 fail_notifiers: 282 return r; 283 } 284 285 static void vhost_net_stop_one(struct vhost_net *net, 286 VirtIODevice *dev) 287 { 288 struct vhost_vring_file file = { .fd = -1 }; 289 290 if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) { 291 for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { 292 int r = vhost_net_set_backend(&net->dev, &file); 293 assert(r >= 0); 294 } 295 } 296 if (net->nc->info->poll) { 297 net->nc->info->poll(net->nc, true); 298 } 299 vhost_dev_stop(&net->dev, dev); 300 vhost_dev_disable_notifiers(&net->dev, dev); 301 } 302 303 int vhost_net_start(VirtIODevice *dev, NetClientState *ncs, 304 int total_queues) 305 { 306 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev))); 307 VirtioBusState *vbus = VIRTIO_BUS(qbus); 308 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus); 309 int r, e, i; 310 311 if (!k->set_guest_notifiers) { 312 error_report("binding does not support guest notifiers"); 313 return -ENOSYS; 314 } 315 316 for (i = 0; i < total_queues; i++) { 317 struct vhost_net *net; 318 319 net = get_vhost_net(ncs[i].peer); 320 vhost_net_set_vq_index(net, i * 2); 321 322 /* Suppress the masking guest notifiers on vhost user 323 * because vhost user doesn't interrupt masking/unmasking 324 * properly. 325 */ 326 if (net->nc->info->type == NET_CLIENT_DRIVER_VHOST_USER) { 327 dev->use_guest_notifier_mask = false; 328 } 329 } 330 331 r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true); 332 if (r < 0) { 333 error_report("Error binding guest notifier: %d", -r); 334 goto err; 335 } 336 337 for (i = 0; i < total_queues; i++) { 338 r = vhost_net_start_one(get_vhost_net(ncs[i].peer), dev); 339 340 if (r < 0) { 341 goto err_start; 342 } 343 344 if (ncs[i].peer->vring_enable) { 345 /* restore vring enable state */ 346 r = vhost_set_vring_enable(ncs[i].peer, ncs[i].peer->vring_enable); 347 348 if (r < 0) { 349 goto err_start; 350 } 351 } 352 } 353 354 return 0; 355 356 err_start: 357 while (--i >= 0) { 358 vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev); 359 } 360 e = k->set_guest_notifiers(qbus->parent, total_queues * 2, false); 361 if (e < 0) { 362 fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", e); 363 fflush(stderr); 364 } 365 err: 366 return r; 367 } 368 369 void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs, 370 int total_queues) 371 { 372 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev))); 373 VirtioBusState *vbus = VIRTIO_BUS(qbus); 374 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus); 375 int i, r; 376 377 for (i = 0; i < total_queues; i++) { 378 vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev); 379 } 380 381 r = k->set_guest_notifiers(qbus->parent, total_queues * 2, false); 382 if (r < 0) { 383 fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r); 384 fflush(stderr); 385 } 386 assert(r >= 0); 387 } 388 389 void vhost_net_cleanup(struct vhost_net *net) 390 { 391 vhost_dev_cleanup(&net->dev); 392 } 393 394 int vhost_net_notify_migration_done(struct vhost_net *net, char* mac_addr) 395 { 396 const VhostOps *vhost_ops = net->dev.vhost_ops; 397 398 assert(vhost_ops->backend_type == VHOST_BACKEND_TYPE_USER); 399 assert(vhost_ops->vhost_migration_done); 400 401 return vhost_ops->vhost_migration_done(&net->dev, mac_addr); 402 } 403 404 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx) 405 { 406 return vhost_virtqueue_pending(&net->dev, idx); 407 } 408 409 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev, 410 int idx, bool mask) 411 { 412 vhost_virtqueue_mask(&net->dev, dev, idx, mask); 413 } 414 415 VHostNetState *get_vhost_net(NetClientState *nc) 416 { 417 VHostNetState *vhost_net = 0; 418 419 if (!nc) { 420 return 0; 421 } 422 423 switch (nc->info->type) { 424 case NET_CLIENT_DRIVER_TAP: 425 vhost_net = tap_get_vhost_net(nc); 426 break; 427 #ifdef CONFIG_VHOST_NET_USER 428 case NET_CLIENT_DRIVER_VHOST_USER: 429 vhost_net = vhost_user_get_vhost_net(nc); 430 assert(vhost_net); 431 break; 432 #endif 433 default: 434 break; 435 } 436 437 return vhost_net; 438 } 439 440 int vhost_set_vring_enable(NetClientState *nc, int enable) 441 { 442 VHostNetState *net = get_vhost_net(nc); 443 const VhostOps *vhost_ops = net->dev.vhost_ops; 444 445 nc->vring_enable = enable; 446 447 if (vhost_ops && vhost_ops->vhost_set_vring_enable) { 448 return vhost_ops->vhost_set_vring_enable(&net->dev, enable); 449 } 450 451 return 0; 452 } 453 454 int vhost_net_set_mtu(struct vhost_net *net, uint16_t mtu) 455 { 456 const VhostOps *vhost_ops = net->dev.vhost_ops; 457 458 if (!vhost_ops->vhost_net_set_mtu) { 459 return 0; 460 } 461 462 return vhost_ops->vhost_net_set_mtu(&net->dev, mtu); 463 } 464