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 "net/tap.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.h" 37 #include "monitor.h" 38 #include "sysemu.h" 39 #include "qemu-char.h" 40 #include "qemu-common.h" 41 #include "qemu-error.h" 42 43 #include "net/tap-linux.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 VLANClientState 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(VLANClientState *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(VLANClientState *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(VLANClientState *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(VLANClientState *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(VLANClientState *nc) 218 { 219 TAPState *s = DO_UPCAST(TAPState, nc, nc); 220 221 assert(nc->info->type == NET_CLIENT_TYPE_TAP); 222 223 return s->has_ufo; 224 } 225 226 int tap_has_vnet_hdr(VLANClientState *nc) 227 { 228 TAPState *s = DO_UPCAST(TAPState, nc, nc); 229 230 assert(nc->info->type == NET_CLIENT_TYPE_TAP); 231 232 return !!s->host_vnet_hdr_len; 233 } 234 235 int tap_has_vnet_hdr_len(VLANClientState *nc, int len) 236 { 237 TAPState *s = DO_UPCAST(TAPState, nc, nc); 238 239 assert(nc->info->type == NET_CLIENT_TYPE_TAP); 240 241 return tap_probe_vnet_hdr_len(s->fd, len); 242 } 243 244 void tap_set_vnet_hdr_len(VLANClientState *nc, int len) 245 { 246 TAPState *s = DO_UPCAST(TAPState, nc, nc); 247 248 assert(nc->info->type == NET_CLIENT_TYPE_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(VLANClientState *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_TYPE_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(VLANClientState *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(VLANClientState *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(VLANClientState *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(VLANClientState *nc) 307 { 308 TAPState *s = DO_UPCAST(TAPState, nc, nc); 309 assert(nc->info->type == NET_CLIENT_TYPE_TAP); 310 return s->fd; 311 } 312 313 /* fd support */ 314 315 static NetClientInfo net_tap_info = { 316 .type = NET_CLIENT_TYPE_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(VLANState *vlan, 326 const char *model, 327 const char *name, 328 int fd, 329 int vnet_hdr) 330 { 331 VLANClientState *nc; 332 TAPState *s; 333 334 nc = qemu_new_net_client(&net_tap_info, vlan, NULL, 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 tap_read_poll(s, 1); 344 s->vhost_net = NULL; 345 return s; 346 } 347 348 static int launch_script(const char *setup_script, const char *ifname, int fd) 349 { 350 int pid, status; 351 char *args[3]; 352 char **parg; 353 354 /* try to launch network script */ 355 pid = fork(); 356 if (pid == 0) { 357 int open_max = sysconf(_SC_OPEN_MAX), i; 358 359 for (i = 0; i < open_max; i++) { 360 if (i != STDIN_FILENO && 361 i != STDOUT_FILENO && 362 i != STDERR_FILENO && 363 i != fd) { 364 close(i); 365 } 366 } 367 parg = args; 368 *parg++ = (char *)setup_script; 369 *parg++ = (char *)ifname; 370 *parg = NULL; 371 execv(setup_script, args); 372 _exit(1); 373 } else if (pid > 0) { 374 while (waitpid(pid, &status, 0) != pid) { 375 /* loop */ 376 } 377 378 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 379 return 0; 380 } 381 } 382 fprintf(stderr, "%s: could not launch network script\n", setup_script); 383 return -1; 384 } 385 386 static int recv_fd(int c) 387 { 388 int fd; 389 uint8_t msgbuf[CMSG_SPACE(sizeof(fd))]; 390 struct msghdr msg = { 391 .msg_control = msgbuf, 392 .msg_controllen = sizeof(msgbuf), 393 }; 394 struct cmsghdr *cmsg; 395 struct iovec iov; 396 uint8_t req[1]; 397 ssize_t len; 398 399 cmsg = CMSG_FIRSTHDR(&msg); 400 cmsg->cmsg_level = SOL_SOCKET; 401 cmsg->cmsg_type = SCM_RIGHTS; 402 cmsg->cmsg_len = CMSG_LEN(sizeof(fd)); 403 msg.msg_controllen = cmsg->cmsg_len; 404 405 iov.iov_base = req; 406 iov.iov_len = sizeof(req); 407 408 msg.msg_iov = &iov; 409 msg.msg_iovlen = 1; 410 411 len = recvmsg(c, &msg, 0); 412 if (len > 0) { 413 memcpy(&fd, CMSG_DATA(cmsg), sizeof(fd)); 414 return fd; 415 } 416 417 return len; 418 } 419 420 static int net_bridge_run_helper(const char *helper, const char *bridge) 421 { 422 sigset_t oldmask, mask; 423 int pid, status; 424 char *args[5]; 425 char **parg; 426 int sv[2]; 427 428 sigemptyset(&mask); 429 sigaddset(&mask, SIGCHLD); 430 sigprocmask(SIG_BLOCK, &mask, &oldmask); 431 432 if (socketpair(PF_UNIX, SOCK_STREAM, 0, sv) == -1) { 433 return -1; 434 } 435 436 /* try to launch bridge helper */ 437 pid = fork(); 438 if (pid == 0) { 439 int open_max = sysconf(_SC_OPEN_MAX), i; 440 char fd_buf[6+10]; 441 char br_buf[6+IFNAMSIZ] = {0}; 442 char helper_cmd[PATH_MAX + sizeof(fd_buf) + sizeof(br_buf) + 15]; 443 444 for (i = 0; i < open_max; i++) { 445 if (i != STDIN_FILENO && 446 i != STDOUT_FILENO && 447 i != STDERR_FILENO && 448 i != sv[1]) { 449 close(i); 450 } 451 } 452 453 snprintf(fd_buf, sizeof(fd_buf), "%s%d", "--fd=", sv[1]); 454 455 if (strrchr(helper, ' ') || strrchr(helper, '\t')) { 456 /* assume helper is a command */ 457 458 if (strstr(helper, "--br=") == NULL) { 459 snprintf(br_buf, sizeof(br_buf), "%s%s", "--br=", bridge); 460 } 461 462 snprintf(helper_cmd, sizeof(helper_cmd), "%s %s %s %s", 463 helper, "--use-vnet", fd_buf, br_buf); 464 465 parg = args; 466 *parg++ = (char *)"sh"; 467 *parg++ = (char *)"-c"; 468 *parg++ = helper_cmd; 469 *parg++ = NULL; 470 471 execv("/bin/sh", args); 472 } else { 473 /* assume helper is just the executable path name */ 474 475 snprintf(br_buf, sizeof(br_buf), "%s%s", "--br=", bridge); 476 477 parg = args; 478 *parg++ = (char *)helper; 479 *parg++ = (char *)"--use-vnet"; 480 *parg++ = fd_buf; 481 *parg++ = br_buf; 482 *parg++ = NULL; 483 484 execv(helper, args); 485 } 486 _exit(1); 487 488 } else if (pid > 0) { 489 int fd; 490 491 close(sv[1]); 492 493 do { 494 fd = recv_fd(sv[0]); 495 } while (fd == -1 && errno == EINTR); 496 497 close(sv[0]); 498 499 while (waitpid(pid, &status, 0) != pid) { 500 /* loop */ 501 } 502 sigprocmask(SIG_SETMASK, &oldmask, NULL); 503 if (fd < 0) { 504 fprintf(stderr, "failed to recv file descriptor\n"); 505 return -1; 506 } 507 508 if (WIFEXITED(status) && WEXITSTATUS(status) == 0) { 509 return fd; 510 } 511 } 512 fprintf(stderr, "failed to launch bridge helper\n"); 513 return -1; 514 } 515 516 int net_init_bridge(QemuOpts *opts, const char *name, VLANState *vlan) 517 { 518 TAPState *s; 519 int fd, vnet_hdr; 520 521 if (!qemu_opt_get(opts, "br")) { 522 qemu_opt_set(opts, "br", DEFAULT_BRIDGE_INTERFACE); 523 } 524 if (!qemu_opt_get(opts, "helper")) { 525 qemu_opt_set(opts, "helper", DEFAULT_BRIDGE_HELPER); 526 } 527 528 fd = net_bridge_run_helper(qemu_opt_get(opts, "helper"), 529 qemu_opt_get(opts, "br")); 530 if (fd == -1) { 531 return -1; 532 } 533 534 fcntl(fd, F_SETFL, O_NONBLOCK); 535 536 vnet_hdr = tap_probe_vnet_hdr(fd); 537 538 s = net_tap_fd_init(vlan, "bridge", name, fd, vnet_hdr); 539 if (!s) { 540 close(fd); 541 return -1; 542 } 543 544 snprintf(s->nc.info_str, sizeof(s->nc.info_str), "helper=%s,br=%s", 545 qemu_opt_get(opts, "helper"), qemu_opt_get(opts, "br")); 546 547 return 0; 548 } 549 550 static int net_tap_init(QemuOpts *opts, int *vnet_hdr) 551 { 552 int fd, vnet_hdr_required; 553 char ifname[128] = {0,}; 554 const char *setup_script; 555 556 if (qemu_opt_get(opts, "ifname")) { 557 pstrcpy(ifname, sizeof(ifname), qemu_opt_get(opts, "ifname")); 558 } 559 560 *vnet_hdr = qemu_opt_get_bool(opts, "vnet_hdr", 1); 561 if (qemu_opt_get(opts, "vnet_hdr")) { 562 vnet_hdr_required = *vnet_hdr; 563 } else { 564 vnet_hdr_required = 0; 565 } 566 567 TFR(fd = tap_open(ifname, sizeof(ifname), vnet_hdr, vnet_hdr_required)); 568 if (fd < 0) { 569 return -1; 570 } 571 572 setup_script = qemu_opt_get(opts, "script"); 573 if (setup_script && 574 setup_script[0] != '\0' && 575 strcmp(setup_script, "no") != 0 && 576 launch_script(setup_script, ifname, fd)) { 577 close(fd); 578 return -1; 579 } 580 581 qemu_opt_set(opts, "ifname", ifname); 582 583 return fd; 584 } 585 586 int net_init_tap(QemuOpts *opts, const char *name, VLANState *vlan) 587 { 588 TAPState *s; 589 int fd, vnet_hdr = 0; 590 const char *model; 591 592 if (qemu_opt_get(opts, "fd")) { 593 if (qemu_opt_get(opts, "ifname") || 594 qemu_opt_get(opts, "script") || 595 qemu_opt_get(opts, "downscript") || 596 qemu_opt_get(opts, "vnet_hdr") || 597 qemu_opt_get(opts, "helper")) { 598 error_report("ifname=, script=, downscript=, vnet_hdr=, " 599 "and helper= are invalid with fd="); 600 return -1; 601 } 602 603 fd = net_handle_fd_param(cur_mon, qemu_opt_get(opts, "fd")); 604 if (fd == -1) { 605 return -1; 606 } 607 608 fcntl(fd, F_SETFL, O_NONBLOCK); 609 610 vnet_hdr = tap_probe_vnet_hdr(fd); 611 612 model = "tap"; 613 614 } else if (qemu_opt_get(opts, "helper")) { 615 if (qemu_opt_get(opts, "ifname") || 616 qemu_opt_get(opts, "script") || 617 qemu_opt_get(opts, "downscript") || 618 qemu_opt_get(opts, "vnet_hdr")) { 619 error_report("ifname=, script=, downscript=, and vnet_hdr= " 620 "are invalid with helper="); 621 return -1; 622 } 623 624 fd = net_bridge_run_helper(qemu_opt_get(opts, "helper"), 625 DEFAULT_BRIDGE_INTERFACE); 626 if (fd == -1) { 627 return -1; 628 } 629 630 fcntl(fd, F_SETFL, O_NONBLOCK); 631 632 vnet_hdr = tap_probe_vnet_hdr(fd); 633 634 model = "bridge"; 635 636 } else { 637 if (!qemu_opt_get(opts, "script")) { 638 qemu_opt_set(opts, "script", DEFAULT_NETWORK_SCRIPT); 639 } 640 641 if (!qemu_opt_get(opts, "downscript")) { 642 qemu_opt_set(opts, "downscript", DEFAULT_NETWORK_DOWN_SCRIPT); 643 } 644 645 fd = net_tap_init(opts, &vnet_hdr); 646 if (fd == -1) { 647 return -1; 648 } 649 650 model = "tap"; 651 } 652 653 s = net_tap_fd_init(vlan, model, name, fd, vnet_hdr); 654 if (!s) { 655 close(fd); 656 return -1; 657 } 658 659 if (tap_set_sndbuf(s->fd, opts) < 0) { 660 return -1; 661 } 662 663 if (qemu_opt_get(opts, "fd")) { 664 snprintf(s->nc.info_str, sizeof(s->nc.info_str), "fd=%d", fd); 665 } else if (qemu_opt_get(opts, "helper")) { 666 snprintf(s->nc.info_str, sizeof(s->nc.info_str), 667 "helper=%s", qemu_opt_get(opts, "helper")); 668 } else { 669 const char *ifname, *script, *downscript; 670 671 ifname = qemu_opt_get(opts, "ifname"); 672 script = qemu_opt_get(opts, "script"); 673 downscript = qemu_opt_get(opts, "downscript"); 674 675 snprintf(s->nc.info_str, sizeof(s->nc.info_str), 676 "ifname=%s,script=%s,downscript=%s", 677 ifname, script, downscript); 678 679 if (strcmp(downscript, "no") != 0) { 680 snprintf(s->down_script, sizeof(s->down_script), "%s", downscript); 681 snprintf(s->down_script_arg, sizeof(s->down_script_arg), "%s", ifname); 682 } 683 } 684 685 if (qemu_opt_get_bool(opts, "vhost", !!qemu_opt_get(opts, "vhostfd") || 686 qemu_opt_get_bool(opts, "vhostforce", false))) { 687 int vhostfd, r; 688 bool force = qemu_opt_get_bool(opts, "vhostforce", false); 689 if (qemu_opt_get(opts, "vhostfd")) { 690 r = net_handle_fd_param(cur_mon, qemu_opt_get(opts, "vhostfd")); 691 if (r == -1) { 692 return -1; 693 } 694 vhostfd = r; 695 } else { 696 vhostfd = -1; 697 } 698 s->vhost_net = vhost_net_init(&s->nc, vhostfd, force); 699 if (!s->vhost_net) { 700 error_report("vhost-net requested but could not be initialized"); 701 return -1; 702 } 703 } else if (qemu_opt_get(opts, "vhostfd")) { 704 error_report("vhostfd= is not valid without vhost"); 705 return -1; 706 } 707 708 return 0; 709 } 710 711 VHostNetState *tap_get_vhost_net(VLANClientState *nc) 712 { 713 TAPState *s = DO_UPCAST(TAPState, nc, nc); 714 assert(nc->info->type == NET_CLIENT_TYPE_TAP); 715 return s->vhost_net; 716 } 717