1 /* 2 * QEMU System Emulator 3 * 4 * Copyright (c) 2003-2008 Fabrice Bellard 5 * Copyright (c) 2009 Red Hat, Inc. 6 * 7 * Permission is hereby granted, free of charge, to any person obtaining a copy 8 * of this software and associated documentation files (the "Software"), to deal 9 * in the Software without restriction, including without limitation the rights 10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 11 * copies of the Software, and to permit persons to whom the Software is 12 * furnished to do so, subject to the following conditions: 13 * 14 * The above copyright notice and this permission notice shall be included in 15 * all copies or substantial portions of the Software. 16 * 17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 23 * THE SOFTWARE. 24 */ 25 26 #include "tap_int.h" 27 28 #include "config-host.h" 29 30 #include <sys/ioctl.h> 31 #include <sys/stat.h> 32 #include <sys/wait.h> 33 #include <sys/socket.h> 34 #include <net/if.h> 35 36 #include "net/net.h" 37 #include "clients.h" 38 #include "monitor/monitor.h" 39 #include "sysemu/sysemu.h" 40 #include "qemu-common.h" 41 #include "qemu/error-report.h" 42 43 #include "net/tap.h" 44 45 #include "hw/vhost_net.h" 46 47 /* Maximum GSO packet size (64k) plus plenty of room for 48 * the ethernet and virtio_net headers 49 */ 50 #define TAP_BUFSIZE (4096 + 65536) 51 52 typedef struct TAPState { 53 NetClientState nc; 54 int fd; 55 char down_script[1024]; 56 char down_script_arg[128]; 57 uint8_t buf[TAP_BUFSIZE]; 58 unsigned int read_poll : 1; 59 unsigned int write_poll : 1; 60 unsigned int using_vnet_hdr : 1; 61 unsigned int has_ufo: 1; 62 VHostNetState *vhost_net; 63 unsigned host_vnet_hdr_len; 64 } TAPState; 65 66 static int launch_script(const char *setup_script, const char *ifname, int fd); 67 68 static int tap_can_send(void *opaque); 69 static void tap_send(void *opaque); 70 static void tap_writable(void *opaque); 71 72 static void tap_update_fd_handler(TAPState *s) 73 { 74 qemu_set_fd_handler2(s->fd, 75 s->read_poll ? tap_can_send : NULL, 76 s->read_poll ? tap_send : NULL, 77 s->write_poll ? tap_writable : NULL, 78 s); 79 } 80 81 static void tap_read_poll(TAPState *s, int enable) 82 { 83 s->read_poll = !!enable; 84 tap_update_fd_handler(s); 85 } 86 87 static void tap_write_poll(TAPState *s, int enable) 88 { 89 s->write_poll = !!enable; 90 tap_update_fd_handler(s); 91 } 92 93 static void tap_writable(void *opaque) 94 { 95 TAPState *s = opaque; 96 97 tap_write_poll(s, 0); 98 99 qemu_flush_queued_packets(&s->nc); 100 } 101 102 static ssize_t tap_write_packet(TAPState *s, const struct iovec *iov, int iovcnt) 103 { 104 ssize_t len; 105 106 do { 107 len = writev(s->fd, iov, iovcnt); 108 } while (len == -1 && errno == EINTR); 109 110 if (len == -1 && errno == EAGAIN) { 111 tap_write_poll(s, 1); 112 return 0; 113 } 114 115 return len; 116 } 117 118 static ssize_t tap_receive_iov(NetClientState *nc, const struct iovec *iov, 119 int iovcnt) 120 { 121 TAPState *s = DO_UPCAST(TAPState, nc, nc); 122 const struct iovec *iovp = iov; 123 struct iovec iov_copy[iovcnt + 1]; 124 struct virtio_net_hdr_mrg_rxbuf hdr = { }; 125 126 if (s->host_vnet_hdr_len && !s->using_vnet_hdr) { 127 iov_copy[0].iov_base = &hdr; 128 iov_copy[0].iov_len = s->host_vnet_hdr_len; 129 memcpy(&iov_copy[1], iov, iovcnt * sizeof(*iov)); 130 iovp = iov_copy; 131 iovcnt++; 132 } 133 134 return tap_write_packet(s, iovp, iovcnt); 135 } 136 137 static ssize_t tap_receive_raw(NetClientState *nc, const uint8_t *buf, size_t size) 138 { 139 TAPState *s = DO_UPCAST(TAPState, nc, nc); 140 struct iovec iov[2]; 141 int iovcnt = 0; 142 struct virtio_net_hdr_mrg_rxbuf hdr = { }; 143 144 if (s->host_vnet_hdr_len) { 145 iov[iovcnt].iov_base = &hdr; 146 iov[iovcnt].iov_len = s->host_vnet_hdr_len; 147 iovcnt++; 148 } 149 150 iov[iovcnt].iov_base = (char *)buf; 151 iov[iovcnt].iov_len = size; 152 iovcnt++; 153 154 return tap_write_packet(s, iov, iovcnt); 155 } 156 157 static ssize_t tap_receive(NetClientState *nc, const uint8_t *buf, size_t size) 158 { 159 TAPState *s = DO_UPCAST(TAPState, nc, nc); 160 struct iovec iov[1]; 161 162 if (s->host_vnet_hdr_len && !s->using_vnet_hdr) { 163 return tap_receive_raw(nc, buf, size); 164 } 165 166 iov[0].iov_base = (char *)buf; 167 iov[0].iov_len = size; 168 169 return tap_write_packet(s, iov, 1); 170 } 171 172 static int tap_can_send(void *opaque) 173 { 174 TAPState *s = opaque; 175 176 return qemu_can_send_packet(&s->nc); 177 } 178 179 #ifndef __sun__ 180 ssize_t tap_read_packet(int tapfd, uint8_t *buf, int maxlen) 181 { 182 return read(tapfd, buf, maxlen); 183 } 184 #endif 185 186 static void tap_send_completed(NetClientState *nc, ssize_t len) 187 { 188 TAPState *s = DO_UPCAST(TAPState, nc, nc); 189 tap_read_poll(s, 1); 190 } 191 192 static void tap_send(void *opaque) 193 { 194 TAPState *s = opaque; 195 int size; 196 197 do { 198 uint8_t *buf = s->buf; 199 200 size = tap_read_packet(s->fd, s->buf, sizeof(s->buf)); 201 if (size <= 0) { 202 break; 203 } 204 205 if (s->host_vnet_hdr_len && !s->using_vnet_hdr) { 206 buf += s->host_vnet_hdr_len; 207 size -= s->host_vnet_hdr_len; 208 } 209 210 size = qemu_send_packet_async(&s->nc, buf, size, tap_send_completed); 211 if (size == 0) { 212 tap_read_poll(s, 0); 213 } 214 } while (size > 0 && qemu_can_send_packet(&s->nc)); 215 } 216 217 int tap_has_ufo(NetClientState *nc) 218 { 219 TAPState *s = DO_UPCAST(TAPState, nc, nc); 220 221 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 222 223 return s->has_ufo; 224 } 225 226 int tap_has_vnet_hdr(NetClientState *nc) 227 { 228 TAPState *s = DO_UPCAST(TAPState, nc, nc); 229 230 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 231 232 return !!s->host_vnet_hdr_len; 233 } 234 235 int tap_has_vnet_hdr_len(NetClientState *nc, int len) 236 { 237 TAPState *s = DO_UPCAST(TAPState, nc, nc); 238 239 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 240 241 return tap_probe_vnet_hdr_len(s->fd, len); 242 } 243 244 void tap_set_vnet_hdr_len(NetClientState *nc, int len) 245 { 246 TAPState *s = DO_UPCAST(TAPState, nc, nc); 247 248 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 249 assert(len == sizeof(struct virtio_net_hdr_mrg_rxbuf) || 250 len == sizeof(struct virtio_net_hdr)); 251 252 tap_fd_set_vnet_hdr_len(s->fd, len); 253 s->host_vnet_hdr_len = len; 254 } 255 256 void tap_using_vnet_hdr(NetClientState *nc, int using_vnet_hdr) 257 { 258 TAPState *s = DO_UPCAST(TAPState, nc, nc); 259 260 using_vnet_hdr = using_vnet_hdr != 0; 261 262 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 263 assert(!!s->host_vnet_hdr_len == using_vnet_hdr); 264 265 s->using_vnet_hdr = using_vnet_hdr; 266 } 267 268 void tap_set_offload(NetClientState *nc, int csum, int tso4, 269 int tso6, int ecn, int ufo) 270 { 271 TAPState *s = DO_UPCAST(TAPState, nc, nc); 272 if (s->fd < 0) { 273 return; 274 } 275 276 tap_fd_set_offload(s->fd, csum, tso4, tso6, ecn, ufo); 277 } 278 279 static void tap_cleanup(NetClientState *nc) 280 { 281 TAPState *s = DO_UPCAST(TAPState, nc, nc); 282 283 if (s->vhost_net) { 284 vhost_net_cleanup(s->vhost_net); 285 s->vhost_net = NULL; 286 } 287 288 qemu_purge_queued_packets(nc); 289 290 if (s->down_script[0]) 291 launch_script(s->down_script, s->down_script_arg, s->fd); 292 293 tap_read_poll(s, 0); 294 tap_write_poll(s, 0); 295 close(s->fd); 296 s->fd = -1; 297 } 298 299 static void tap_poll(NetClientState *nc, bool enable) 300 { 301 TAPState *s = DO_UPCAST(TAPState, nc, nc); 302 tap_read_poll(s, enable); 303 tap_write_poll(s, enable); 304 } 305 306 int tap_get_fd(NetClientState *nc) 307 { 308 TAPState *s = DO_UPCAST(TAPState, nc, nc); 309 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 310 return s->fd; 311 } 312 313 /* fd support */ 314 315 static NetClientInfo net_tap_info = { 316 .type = NET_CLIENT_OPTIONS_KIND_TAP, 317 .size = sizeof(TAPState), 318 .receive = tap_receive, 319 .receive_raw = tap_receive_raw, 320 .receive_iov = tap_receive_iov, 321 .poll = tap_poll, 322 .cleanup = tap_cleanup, 323 }; 324 325 static TAPState *net_tap_fd_init(NetClientState *peer, 326 const char *model, 327 const char *name, 328 int fd, 329 int vnet_hdr) 330 { 331 NetClientState *nc; 332 TAPState *s; 333 334 nc = qemu_new_net_client(&net_tap_info, peer, model, name); 335 336 s = DO_UPCAST(TAPState, nc, nc); 337 338 s->fd = fd; 339 s->host_vnet_hdr_len = vnet_hdr ? sizeof(struct virtio_net_hdr) : 0; 340 s->using_vnet_hdr = 0; 341 s->has_ufo = tap_probe_has_ufo(s->fd); 342 tap_set_offload(&s->nc, 0, 0, 0, 0, 0); 343 /* 344 * Make sure host header length is set correctly in tap: 345 * it might have been modified by another instance of qemu. 346 */ 347 if (tap_probe_vnet_hdr_len(s->fd, s->host_vnet_hdr_len)) { 348 tap_fd_set_vnet_hdr_len(s->fd, s->host_vnet_hdr_len); 349 } 350 tap_read_poll(s, 1); 351 s->vhost_net = NULL; 352 return s; 353 } 354 355 static int launch_script(const char *setup_script, const char *ifname, int fd) 356 { 357 int pid, status; 358 char *args[3]; 359 char **parg; 360 361 /* try to launch network script */ 362 pid = fork(); 363 if (pid == 0) { 364 int open_max = sysconf(_SC_OPEN_MAX), i; 365 366 for (i = 0; i < open_max; i++) { 367 if (i != STDIN_FILENO && 368 i != STDOUT_FILENO && 369 i != STDERR_FILENO && 370 i != fd) { 371 close(i); 372 } 373 } 374 parg = args; 375 *parg++ = (char *)setup_script; 376 *parg++ = (char *)ifname; 377 *parg = NULL; 378 execv(setup_script, args); 379 _exit(1); 380 } else if (pid > 0) { 381 while (waitpid(pid, &status, 0) != pid) { 382 /* loop */ 383 } 384 385 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 386 return 0; 387 } 388 } 389 fprintf(stderr, "%s: could not launch network script\n", setup_script); 390 return -1; 391 } 392 393 static int recv_fd(int c) 394 { 395 int fd; 396 uint8_t msgbuf[CMSG_SPACE(sizeof(fd))]; 397 struct msghdr msg = { 398 .msg_control = msgbuf, 399 .msg_controllen = sizeof(msgbuf), 400 }; 401 struct cmsghdr *cmsg; 402 struct iovec iov; 403 uint8_t req[1]; 404 ssize_t len; 405 406 cmsg = CMSG_FIRSTHDR(&msg); 407 cmsg->cmsg_level = SOL_SOCKET; 408 cmsg->cmsg_type = SCM_RIGHTS; 409 cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); 410 msg.msg_controllen = cmsg->cmsg_len; 411 412 iov.iov_base = req; 413 iov.iov_len = sizeof(req); 414 415 msg.msg_iov = &iov; 416 msg.msg_iovlen = 1; 417 418 len = recvmsg(c, &msg, 0); 419 if (len > 0) { 420 memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd)); 421 return fd; 422 } 423 424 return len; 425 } 426 427 static int net_bridge_run_helper(const char *helper, const char *bridge) 428 { 429 sigset_t oldmask, mask; 430 int pid, status; 431 char *args[5]; 432 char **parg; 433 int sv[2]; 434 435 sigemptyset(&mask); 436 sigaddset(&mask, SIGCHLD); 437 sigprocmask(SIG_BLOCK, &mask, &oldmask); 438 439 if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) { 440 return -1; 441 } 442 443 /* try to launch bridge helper */ 444 pid = fork(); 445 if (pid == 0) { 446 int open_max = sysconf(_SC_OPEN_MAX), i; 447 char fd_buf[6+10]; 448 char br_buf[6+IFNAMSIZ] = {0}; 449 char helper_cmd[PATH_MAX + sizeof(fd_buf) + sizeof(br_buf) + 15]; 450 451 for (i = 0; i < open_max; i++) { 452 if (i != STDIN_FILENO && 453 i != STDOUT_FILENO && 454 i != STDERR_FILENO && 455 i != sv[1]) { 456 close(i); 457 } 458 } 459 460 snprintf(fd_buf, sizeof(fd_buf), "%s%d", "--fd=", sv[1]); 461 462 if (strrchr(helper, ' ') || strrchr(helper, '\t')) { 463 /* assume helper is a command */ 464 465 if (strstr(helper, "--br=") == NULL) { 466 snprintf(br_buf, sizeof(br_buf), "%s%s", "--br=", bridge); 467 } 468 469 snprintf(helper_cmd, sizeof(helper_cmd), "%s %s %s %s", 470 helper, "--use-vnet", fd_buf, br_buf); 471 472 parg = args; 473 *parg++ = (char *)"sh"; 474 *parg++ = (char *)"-c"; 475 *parg++ = helper_cmd; 476 *parg++ = NULL; 477 478 execv("/bin/sh", args); 479 } else { 480 /* assume helper is just the executable path name */ 481 482 snprintf(br_buf, sizeof(br_buf), "%s%s", "--br=", bridge); 483 484 parg = args; 485 *parg++ = (char *)helper; 486 *parg++ = (char *)"--use-vnet"; 487 *parg++ = fd_buf; 488 *parg++ = br_buf; 489 *parg++ = NULL; 490 491 execv(helper, args); 492 } 493 _exit(1); 494 495 } else if (pid > 0) { 496 int fd; 497 498 close(sv[1]); 499 500 do { 501 fd = recv_fd(sv[0]); 502 } while (fd == -1 && errno == EINTR); 503 504 close(sv[0]); 505 506 while (waitpid(pid, &status, 0) != pid) { 507 /* loop */ 508 } 509 sigprocmask(SIG_SETMASK, &oldmask, NULL); 510 if (fd < 0) { 511 fprintf(stderr, "failed to recv file descriptor\n"); 512 return -1; 513 } 514 515 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 516 return fd; 517 } 518 } 519 fprintf(stderr, "failed to launch bridge helper\n"); 520 return -1; 521 } 522 523 int net_init_bridge(const NetClientOptions *opts, const char *name, 524 NetClientState *peer) 525 { 526 const NetdevBridgeOptions *bridge; 527 const char *helper, *br; 528 529 TAPState *s; 530 int fd, vnet_hdr; 531 532 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_BRIDGE); 533 bridge = opts->bridge; 534 535 helper = bridge->has_helper ? bridge->helper : DEFAULT_BRIDGE_HELPER; 536 br = bridge->has_br ? bridge->br : DEFAULT_BRIDGE_INTERFACE; 537 538 fd = net_bridge_run_helper(helper, br); 539 if (fd == -1) { 540 return -1; 541 } 542 543 fcntl(fd, F_SETFL, O_NONBLOCK); 544 545 vnet_hdr = tap_probe_vnet_hdr(fd); 546 547 s = net_tap_fd_init(peer, "bridge", name, fd, vnet_hdr); 548 if (!s) { 549 close(fd); 550 return -1; 551 } 552 553 snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s,br=%s", helper, 554 br); 555 556 return 0; 557 } 558 559 static int net_tap_init(const NetdevTapOptions *tap, int *vnet_hdr, 560 const char *setup_script, char *ifname, 561 size_t ifname_sz) 562 { 563 int fd, vnet_hdr_required; 564 565 if (tap->has_ifname) { 566 pstrcpy(ifname, ifname_sz, tap->ifname); 567 } else { 568 assert(ifname_sz > 0); 569 ifname[0] = '\0'; 570 } 571 572 if (tap->has_vnet_hdr) { 573 *vnet_hdr = tap->vnet_hdr; 574 vnet_hdr_required = *vnet_hdr; 575 } else { 576 *vnet_hdr = 1; 577 vnet_hdr_required = 0; 578 } 579 580 TFR(fd = tap_open(ifname, ifname_sz, vnet_hdr, vnet_hdr_required)); 581 if (fd < 0) { 582 return -1; 583 } 584 585 if (setup_script && 586 setup_script[0] != '\0' && 587 strcmp(setup_script, "no") != 0 && 588 launch_script(setup_script, ifname, fd)) { 589 close(fd); 590 return -1; 591 } 592 593 return fd; 594 } 595 596 int net_init_tap(const NetClientOptions *opts, const char *name, 597 NetClientState *peer) 598 { 599 const NetdevTapOptions *tap; 600 601 int fd, vnet_hdr = 0; 602 const char *model; 603 TAPState *s; 604 605 /* for the no-fd, no-helper case */ 606 const char *script = NULL; /* suppress wrong "uninit'd use" gcc warning */ 607 char ifname[128]; 608 609 assert(opts->kind == NET_CLIENT_OPTIONS_KIND_TAP); 610 tap = opts->tap; 611 612 if (tap->has_fd) { 613 if (tap->has_ifname || tap->has_script || tap->has_downscript || 614 tap->has_vnet_hdr || tap->has_helper) { 615 error_report("ifname=, script=, downscript=, vnet_hdr=, " 616 "and helper= are invalid with fd="); 617 return -1; 618 } 619 620 fd = monitor_handle_fd_param(cur_mon, tap->fd); 621 if (fd == -1) { 622 return -1; 623 } 624 625 fcntl(fd, F_SETFL, O_NONBLOCK); 626 627 vnet_hdr = tap_probe_vnet_hdr(fd); 628 629 model = "tap"; 630 631 } else if (tap->has_helper) { 632 if (tap->has_ifname || tap->has_script || tap->has_downscript || 633 tap->has_vnet_hdr) { 634 error_report("ifname=, script=, downscript=, and vnet_hdr= " 635 "are invalid with helper="); 636 return -1; 637 } 638 639 fd = net_bridge_run_helper(tap->helper, DEFAULT_BRIDGE_INTERFACE); 640 if (fd == -1) { 641 return -1; 642 } 643 644 fcntl(fd, F_SETFL, O_NONBLOCK); 645 646 vnet_hdr = tap_probe_vnet_hdr(fd); 647 648 model = "bridge"; 649 650 } else { 651 script = tap->has_script ? tap->script : DEFAULT_NETWORK_SCRIPT; 652 fd = net_tap_init(tap, &vnet_hdr, script, ifname, sizeof ifname); 653 if (fd == -1) { 654 return -1; 655 } 656 657 model = "tap"; 658 } 659 660 s = net_tap_fd_init(peer, model, name, fd, vnet_hdr); 661 if (!s) { 662 close(fd); 663 return -1; 664 } 665 666 if (tap_set_sndbuf(s->fd, tap) < 0) { 667 return -1; 668 } 669 670 if (tap->has_fd) { 671 snprintf(s->nc.info_str, sizeof(s->nc.info_str), "fd=%d", fd); 672 } else if (tap->has_helper) { 673 snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s", 674 tap->helper); 675 } else { 676 const char *downscript; 677 678 downscript = tap->has_downscript ? tap->downscript : 679 DEFAULT_NETWORK_DOWN_SCRIPT; 680 681 snprintf(s->nc.info_str, sizeof(s->nc.info_str), 682 "ifname=%s,script=%s,downscript=%s", ifname, script, 683 downscript); 684 685 if (strcmp(downscript, "no") != 0) { 686 snprintf(s->down_script, sizeof(s->down_script), "%s", downscript); 687 snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname); 688 } 689 } 690 691 if (tap->has_vhost ? tap->vhost : 692 tap->has_vhostfd || (tap->has_vhostforce && tap->vhostforce)) { 693 int vhostfd; 694 695 if (tap->has_vhostfd) { 696 vhostfd = monitor_handle_fd_param(cur_mon, tap->vhostfd); 697 if (vhostfd == -1) { 698 return -1; 699 } 700 } else { 701 vhostfd = -1; 702 } 703 704 s->vhost_net = vhost_net_init(&s->nc, vhostfd, 705 tap->has_vhostforce && tap->vhostforce); 706 if (!s->vhost_net) { 707 error_report("vhost-net requested but could not be initialized"); 708 return -1; 709 } 710 } else if (tap->has_vhostfd) { 711 error_report("vhostfd= is not valid without vhost"); 712 return -1; 713 } 714 715 return 0; 716 } 717 718 VHostNetState *tap_get_vhost_net(NetClientState *nc) 719 { 720 TAPState *s = DO_UPCAST(TAPState, nc, nc); 721 assert(nc->info->type == NET_CLIENT_OPTIONS_KIND_TAP); 722 return s->vhost_net; 723 } 724