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 "net/net.h" 17 #include "net/tap.h" 18 #include "net/vhost-user.h" 19 20 #include "hw/virtio/virtio-net.h" 21 #include "net/vhost_net.h" 22 #include "qemu/error-report.h" 23 24 #include "config.h" 25 26 #ifdef CONFIG_VHOST_NET 27 #include <linux/vhost.h> 28 #include <sys/socket.h> 29 #include <linux/kvm.h> 30 #include <fcntl.h> 31 #include <netpacket/packet.h> 32 #include <net/ethernet.h> 33 #include <net/if.h> 34 #include <netinet/in.h> 35 36 #include <stdio.h> 37 38 #include "standard-headers/linux/virtio_ring.h" 39 #include "hw/virtio/vhost.h" 40 #include "hw/virtio/virtio-bus.h" 41 #include "hw/virtio/virtio-access.h" 42 43 struct vhost_net { 44 struct vhost_dev dev; 45 struct vhost_virtqueue vqs[2]; 46 int backend; 47 NetClientState *nc; 48 }; 49 50 /* Features supported by host kernel. */ 51 static const int kernel_feature_bits[] = { 52 VIRTIO_F_NOTIFY_ON_EMPTY, 53 VIRTIO_RING_F_INDIRECT_DESC, 54 VIRTIO_RING_F_EVENT_IDX, 55 VIRTIO_NET_F_MRG_RXBUF, 56 VIRTIO_F_VERSION_1, 57 VHOST_INVALID_FEATURE_BIT 58 }; 59 60 /* Features supported by others. */ 61 static const int user_feature_bits[] = { 62 VIRTIO_F_NOTIFY_ON_EMPTY, 63 VIRTIO_RING_F_INDIRECT_DESC, 64 VIRTIO_RING_F_EVENT_IDX, 65 66 VIRTIO_F_ANY_LAYOUT, 67 VIRTIO_F_VERSION_1, 68 VIRTIO_NET_F_CSUM, 69 VIRTIO_NET_F_GUEST_CSUM, 70 VIRTIO_NET_F_GSO, 71 VIRTIO_NET_F_GUEST_TSO4, 72 VIRTIO_NET_F_GUEST_TSO6, 73 VIRTIO_NET_F_GUEST_ECN, 74 VIRTIO_NET_F_GUEST_UFO, 75 VIRTIO_NET_F_HOST_TSO4, 76 VIRTIO_NET_F_HOST_TSO6, 77 VIRTIO_NET_F_HOST_ECN, 78 VIRTIO_NET_F_HOST_UFO, 79 VIRTIO_NET_F_MRG_RXBUF, 80 VIRTIO_NET_F_STATUS, 81 VIRTIO_NET_F_CTRL_VQ, 82 VIRTIO_NET_F_CTRL_RX, 83 VIRTIO_NET_F_CTRL_VLAN, 84 VIRTIO_NET_F_CTRL_RX_EXTRA, 85 VIRTIO_NET_F_CTRL_MAC_ADDR, 86 VIRTIO_NET_F_CTRL_GUEST_OFFLOADS, 87 88 VIRTIO_NET_F_MQ, 89 90 VHOST_INVALID_FEATURE_BIT 91 }; 92 93 static const int *vhost_net_get_feature_bits(struct vhost_net *net) 94 { 95 const int *feature_bits = 0; 96 97 switch (net->nc->info->type) { 98 case NET_CLIENT_OPTIONS_KIND_TAP: 99 feature_bits = kernel_feature_bits; 100 break; 101 case NET_CLIENT_OPTIONS_KIND_VHOST_USER: 102 feature_bits = user_feature_bits; 103 break; 104 default: 105 error_report("Feature bits not defined for this type: %d", 106 net->nc->info->type); 107 break; 108 } 109 110 return feature_bits; 111 } 112 113 uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features) 114 { 115 return vhost_get_features(&net->dev, vhost_net_get_feature_bits(net), 116 features); 117 } 118 119 void vhost_net_ack_features(struct vhost_net *net, uint64_t features) 120 { 121 net->dev.acked_features = net->dev.backend_features; 122 vhost_ack_features(&net->dev, vhost_net_get_feature_bits(net), features); 123 } 124 125 uint64_t vhost_net_get_max_queues(VHostNetState *net) 126 { 127 return net->dev.max_queues; 128 } 129 130 static int vhost_net_get_fd(NetClientState *backend) 131 { 132 switch (backend->info->type) { 133 case NET_CLIENT_OPTIONS_KIND_TAP: 134 return tap_get_fd(backend); 135 default: 136 fprintf(stderr, "vhost-net requires tap backend\n"); 137 return -EBADFD; 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_malloc(sizeof *net); 146 147 if (!options->net_backend) { 148 fprintf(stderr, "vhost-net requires net backend to be setup\n"); 149 goto fail; 150 } 151 net->nc = options->net_backend; 152 153 net->dev.max_queues = 1; 154 net->dev.nvqs = 2; 155 net->dev.vqs = net->vqs; 156 157 if (backend_kernel) { 158 r = vhost_net_get_fd(options->net_backend); 159 if (r < 0) { 160 goto fail; 161 } 162 net->dev.backend_features = qemu_has_vnet_hdr(options->net_backend) 163 ? 0 : (1ULL << VHOST_NET_F_VIRTIO_NET_HDR); 164 net->backend = r; 165 net->dev.protocol_features = 0; 166 } else { 167 net->dev.backend_features = 0; 168 net->dev.protocol_features = 0; 169 net->backend = -1; 170 171 /* vhost-user needs vq_index to initiate a specific queue pair */ 172 net->dev.vq_index = net->nc->queue_index * net->dev.nvqs; 173 } 174 175 r = vhost_dev_init(&net->dev, options->opaque, 176 options->backend_type); 177 if (r < 0) { 178 goto fail; 179 } 180 if (backend_kernel) { 181 if (!qemu_has_vnet_hdr_len(options->net_backend, 182 sizeof(struct virtio_net_hdr_mrg_rxbuf))) { 183 net->dev.features &= ~(1ULL << VIRTIO_NET_F_MRG_RXBUF); 184 } 185 if (~net->dev.features & net->dev.backend_features) { 186 fprintf(stderr, "vhost lacks feature mask %" PRIu64 187 " for backend\n", 188 (uint64_t)(~net->dev.features & net->dev.backend_features)); 189 vhost_dev_cleanup(&net->dev); 190 goto fail; 191 } 192 } 193 /* Set sane init value. Override when guest acks. */ 194 vhost_net_ack_features(net, 0); 195 return net; 196 fail: 197 g_free(net); 198 return NULL; 199 } 200 201 static void vhost_net_set_vq_index(struct vhost_net *net, int vq_index) 202 { 203 net->dev.vq_index = vq_index; 204 } 205 206 static int vhost_net_set_vnet_endian(VirtIODevice *dev, NetClientState *peer, 207 bool set) 208 { 209 int r = 0; 210 211 if (virtio_vdev_has_feature(dev, VIRTIO_F_VERSION_1) || 212 (virtio_legacy_is_cross_endian(dev) && !virtio_is_big_endian(dev))) { 213 r = qemu_set_vnet_le(peer, set); 214 if (r) { 215 error_report("backend does not support LE vnet headers"); 216 } 217 } else if (virtio_legacy_is_cross_endian(dev)) { 218 r = qemu_set_vnet_be(peer, set); 219 if (r) { 220 error_report("backend does not support BE vnet headers"); 221 } 222 } 223 224 return r; 225 } 226 227 static int vhost_net_start_one(struct vhost_net *net, 228 VirtIODevice *dev) 229 { 230 struct vhost_vring_file file = { }; 231 int r; 232 233 net->dev.nvqs = 2; 234 net->dev.vqs = net->vqs; 235 236 r = vhost_dev_enable_notifiers(&net->dev, dev); 237 if (r < 0) { 238 goto fail_notifiers; 239 } 240 241 r = vhost_dev_start(&net->dev, dev); 242 if (r < 0) { 243 goto fail_start; 244 } 245 246 if (net->nc->info->poll) { 247 net->nc->info->poll(net->nc, false); 248 } 249 250 if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) { 251 qemu_set_fd_handler(net->backend, NULL, NULL, NULL); 252 file.fd = net->backend; 253 for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { 254 const VhostOps *vhost_ops = net->dev.vhost_ops; 255 r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND, 256 &file); 257 if (r < 0) { 258 r = -errno; 259 goto fail; 260 } 261 } 262 } 263 return 0; 264 fail: 265 file.fd = -1; 266 if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) { 267 while (file.index-- > 0) { 268 const VhostOps *vhost_ops = net->dev.vhost_ops; 269 int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND, 270 &file); 271 assert(r >= 0); 272 } 273 } 274 if (net->nc->info->poll) { 275 net->nc->info->poll(net->nc, true); 276 } 277 vhost_dev_stop(&net->dev, dev); 278 fail_start: 279 vhost_dev_disable_notifiers(&net->dev, dev); 280 fail_notifiers: 281 return r; 282 } 283 284 static void vhost_net_stop_one(struct vhost_net *net, 285 VirtIODevice *dev) 286 { 287 struct vhost_vring_file file = { .fd = -1 }; 288 289 if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP) { 290 for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { 291 const VhostOps *vhost_ops = net->dev.vhost_ops; 292 int r = vhost_ops->vhost_call(&net->dev, VHOST_NET_SET_BACKEND, 293 &file); 294 assert(r >= 0); 295 } 296 } else if (net->nc->info->type == NET_CLIENT_OPTIONS_KIND_VHOST_USER) { 297 for (file.index = 0; file.index < net->dev.nvqs; ++file.index) { 298 const VhostOps *vhost_ops = net->dev.vhost_ops; 299 int r = vhost_ops->vhost_call(&net->dev, VHOST_RESET_DEVICE, 300 NULL); 301 assert(r >= 0); 302 } 303 } 304 if (net->nc->info->poll) { 305 net->nc->info->poll(net->nc, true); 306 } 307 vhost_dev_stop(&net->dev, dev); 308 vhost_dev_disable_notifiers(&net->dev, dev); 309 } 310 311 int vhost_net_start(VirtIODevice *dev, NetClientState *ncs, 312 int total_queues) 313 { 314 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev))); 315 VirtioBusState *vbus = VIRTIO_BUS(qbus); 316 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus); 317 int r, e, i; 318 319 if (!k->set_guest_notifiers) { 320 error_report("binding does not support guest notifiers"); 321 r = -ENOSYS; 322 goto err; 323 } 324 325 r = vhost_net_set_vnet_endian(dev, ncs[0].peer, true); 326 if (r < 0) { 327 goto err; 328 } 329 330 for (i = 0; i < total_queues; i++) { 331 vhost_net_set_vq_index(get_vhost_net(ncs[i].peer), i * 2); 332 } 333 334 r = k->set_guest_notifiers(qbus->parent, total_queues * 2, true); 335 if (r < 0) { 336 error_report("Error binding guest notifier: %d", -r); 337 goto err_endian; 338 } 339 340 for (i = 0; i < total_queues; i++) { 341 r = vhost_net_start_one(get_vhost_net(ncs[i].peer), dev); 342 343 if (r < 0) { 344 goto err_start; 345 } 346 } 347 348 return 0; 349 350 err_start: 351 while (--i >= 0) { 352 vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev); 353 } 354 e = k->set_guest_notifiers(qbus->parent, total_queues * 2, false); 355 if (e < 0) { 356 fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", e); 357 fflush(stderr); 358 } 359 err_endian: 360 vhost_net_set_vnet_endian(dev, ncs[0].peer, false); 361 err: 362 return r; 363 } 364 365 void vhost_net_stop(VirtIODevice *dev, NetClientState *ncs, 366 int total_queues) 367 { 368 BusState *qbus = BUS(qdev_get_parent_bus(DEVICE(dev))); 369 VirtioBusState *vbus = VIRTIO_BUS(qbus); 370 VirtioBusClass *k = VIRTIO_BUS_GET_CLASS(vbus); 371 int i, r; 372 373 for (i = 0; i < total_queues; i++) { 374 vhost_net_stop_one(get_vhost_net(ncs[i].peer), dev); 375 } 376 377 r = k->set_guest_notifiers(qbus->parent, total_queues * 2, false); 378 if (r < 0) { 379 fprintf(stderr, "vhost guest notifier cleanup failed: %d\n", r); 380 fflush(stderr); 381 } 382 assert(r >= 0); 383 384 assert(vhost_net_set_vnet_endian(dev, ncs[0].peer, false) >= 0); 385 } 386 387 void vhost_net_cleanup(struct vhost_net *net) 388 { 389 vhost_dev_cleanup(&net->dev); 390 g_free(net); 391 } 392 393 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx) 394 { 395 return vhost_virtqueue_pending(&net->dev, idx); 396 } 397 398 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev, 399 int idx, bool mask) 400 { 401 vhost_virtqueue_mask(&net->dev, dev, idx, mask); 402 } 403 404 VHostNetState *get_vhost_net(NetClientState *nc) 405 { 406 VHostNetState *vhost_net = 0; 407 408 if (!nc) { 409 return 0; 410 } 411 412 switch (nc->info->type) { 413 case NET_CLIENT_OPTIONS_KIND_TAP: 414 vhost_net = tap_get_vhost_net(nc); 415 break; 416 case NET_CLIENT_OPTIONS_KIND_VHOST_USER: 417 vhost_net = vhost_user_get_vhost_net(nc); 418 break; 419 default: 420 break; 421 } 422 423 return vhost_net; 424 } 425 426 int vhost_set_vring_enable(NetClientState *nc, int enable) 427 { 428 VHostNetState *net = get_vhost_net(nc); 429 const VhostOps *vhost_ops = net->dev.vhost_ops; 430 431 if (vhost_ops->vhost_backend_set_vring_enable) { 432 return vhost_ops->vhost_backend_set_vring_enable(&net->dev, enable); 433 } 434 435 return 0; 436 } 437 438 #else 439 uint64_t vhost_net_get_max_queues(VHostNetState *net) 440 { 441 return 1; 442 } 443 444 struct vhost_net *vhost_net_init(VhostNetOptions *options) 445 { 446 error_report("vhost-net support is not compiled in"); 447 return NULL; 448 } 449 450 int vhost_net_start(VirtIODevice *dev, 451 NetClientState *ncs, 452 int total_queues) 453 { 454 return -ENOSYS; 455 } 456 void vhost_net_stop(VirtIODevice *dev, 457 NetClientState *ncs, 458 int total_queues) 459 { 460 } 461 462 void vhost_net_cleanup(struct vhost_net *net) 463 { 464 } 465 466 uint64_t vhost_net_get_features(struct vhost_net *net, uint64_t features) 467 { 468 return features; 469 } 470 void vhost_net_ack_features(struct vhost_net *net, uint64_t features) 471 { 472 } 473 474 bool vhost_net_virtqueue_pending(VHostNetState *net, int idx) 475 { 476 return false; 477 } 478 479 void vhost_net_virtqueue_mask(VHostNetState *net, VirtIODevice *dev, 480 int idx, bool mask) 481 { 482 } 483 484 VHostNetState *get_vhost_net(NetClientState *nc) 485 { 486 return 0; 487 } 488 489 int vhost_set_vring_enable(NetClientState *nc, int enable) 490 { 491 return 0; 492 } 493 #endif 494