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