if_tap.c revision 243615
1/*- 2 * Copyright (C) 1999-2000 by Maksim Yevmenkin <m_evmenkin@yahoo.com> 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 * 26 * BASED ON: 27 * ------------------------------------------------------------------------- 28 * 29 * Copyright (c) 1988, Julian Onions <jpo@cs.nott.ac.uk> 30 * Nottingham University 1987. 31 */ 32 33/* 34 * $FreeBSD: head/sys/net/if_tap.c 243615 2012-11-27 12:23:57Z davidxu $ 35 * $Id: if_tap.c,v 0.21 2000/07/23 21:46:02 max Exp $ 36 */ 37 38#include "opt_compat.h" 39#include "opt_inet.h" 40 41#include <sys/param.h> 42#include <sys/conf.h> 43#include <sys/fcntl.h> 44#include <sys/filio.h> 45#include <sys/jail.h> 46#include <sys/kernel.h> 47#include <sys/malloc.h> 48#include <sys/mbuf.h> 49#include <sys/module.h> 50#include <sys/poll.h> 51#include <sys/priv.h> 52#include <sys/proc.h> 53#include <sys/selinfo.h> 54#include <sys/signalvar.h> 55#include <sys/socket.h> 56#include <sys/sockio.h> 57#include <sys/sysctl.h> 58#include <sys/systm.h> 59#include <sys/ttycom.h> 60#include <sys/uio.h> 61#include <sys/queue.h> 62 63#include <net/bpf.h> 64#include <net/ethernet.h> 65#include <net/if.h> 66#include <net/if_clone.h> 67#include <net/if_dl.h> 68#include <net/if_media.h> 69#include <net/if_types.h> 70#include <net/route.h> 71#include <net/vnet.h> 72 73#include <netinet/in.h> 74 75#include <net/if_tapvar.h> 76#include <net/if_tap.h> 77 78 79#define CDEV_NAME "tap" 80#define TAPDEBUG if (tapdebug) printf 81 82static const char tapname[] = "tap"; 83static const char vmnetname[] = "vmnet"; 84#define TAPMAXUNIT 0x7fff 85#define VMNET_DEV_MASK CLONE_FLAG0 86 87/* module */ 88static int tapmodevent(module_t, int, void *); 89 90/* device */ 91static void tapclone(void *, struct ucred *, char *, int, 92 struct cdev **); 93static void tapcreate(struct cdev *); 94 95/* network interface */ 96static void tapifstart(struct ifnet *); 97static int tapifioctl(struct ifnet *, u_long, caddr_t); 98static void tapifinit(void *); 99 100static int tap_clone_create(struct if_clone *, int, caddr_t); 101static void tap_clone_destroy(struct ifnet *); 102static struct if_clone *tap_cloner; 103static int vmnet_clone_create(struct if_clone *, int, caddr_t); 104static void vmnet_clone_destroy(struct ifnet *); 105static struct if_clone *vmnet_cloner; 106 107/* character device */ 108static d_open_t tapopen; 109static d_close_t tapclose; 110static d_read_t tapread; 111static d_write_t tapwrite; 112static d_ioctl_t tapioctl; 113static d_poll_t tappoll; 114static d_kqfilter_t tapkqfilter; 115 116/* kqueue(2) */ 117static int tapkqread(struct knote *, long); 118static int tapkqwrite(struct knote *, long); 119static void tapkqdetach(struct knote *); 120 121static struct filterops tap_read_filterops = { 122 .f_isfd = 1, 123 .f_attach = NULL, 124 .f_detach = tapkqdetach, 125 .f_event = tapkqread, 126}; 127 128static struct filterops tap_write_filterops = { 129 .f_isfd = 1, 130 .f_attach = NULL, 131 .f_detach = tapkqdetach, 132 .f_event = tapkqwrite, 133}; 134 135static struct cdevsw tap_cdevsw = { 136 .d_version = D_VERSION, 137 .d_flags = D_NEEDMINOR, 138 .d_open = tapopen, 139 .d_close = tapclose, 140 .d_read = tapread, 141 .d_write = tapwrite, 142 .d_ioctl = tapioctl, 143 .d_poll = tappoll, 144 .d_name = CDEV_NAME, 145 .d_kqfilter = tapkqfilter, 146}; 147 148/* 149 * All global variables in if_tap.c are locked with tapmtx, with the 150 * exception of tapdebug, which is accessed unlocked; tapclones is 151 * static at runtime. 152 */ 153static struct mtx tapmtx; 154static int tapdebug = 0; /* debug flag */ 155static int tapuopen = 0; /* allow user open() */ 156static int tapuponopen = 0; /* IFF_UP on open() */ 157static int tapdclone = 1; /* enable devfs cloning */ 158static SLIST_HEAD(, tap_softc) taphead; /* first device */ 159static struct clonedevs *tapclones; 160 161MALLOC_DECLARE(M_TAP); 162MALLOC_DEFINE(M_TAP, CDEV_NAME, "Ethernet tunnel interface"); 163SYSCTL_INT(_debug, OID_AUTO, if_tap_debug, CTLFLAG_RW, &tapdebug, 0, ""); 164 165SYSCTL_DECL(_net_link); 166static SYSCTL_NODE(_net_link, OID_AUTO, tap, CTLFLAG_RW, 0, 167 "Ethernet tunnel software network interface"); 168SYSCTL_INT(_net_link_tap, OID_AUTO, user_open, CTLFLAG_RW, &tapuopen, 0, 169 "Allow user to open /dev/tap (based on node permissions)"); 170SYSCTL_INT(_net_link_tap, OID_AUTO, up_on_open, CTLFLAG_RW, &tapuponopen, 0, 171 "Bring interface up when /dev/tap is opened"); 172SYSCTL_INT(_net_link_tap, OID_AUTO, devfs_cloning, CTLFLAG_RW, &tapdclone, 0, 173 "Enably legacy devfs interface creation"); 174SYSCTL_INT(_net_link_tap, OID_AUTO, debug, CTLFLAG_RW, &tapdebug, 0, ""); 175 176TUNABLE_INT("net.link.tap.devfs_cloning", &tapdclone); 177 178DEV_MODULE(if_tap, tapmodevent, NULL); 179 180static int 181tap_clone_create(struct if_clone *ifc, int unit, caddr_t params) 182{ 183 struct cdev *dev; 184 int i; 185 186 /* Find any existing device, or allocate new unit number. */ 187 i = clone_create(&tapclones, &tap_cdevsw, &unit, &dev, 0); 188 if (i) { 189 dev = make_dev(&tap_cdevsw, unit, UID_ROOT, GID_WHEEL, 0600, 190 "%s%d", tapname, unit); 191 } 192 193 tapcreate(dev); 194 return (0); 195} 196 197/* vmnet devices are tap devices in disguise */ 198static int 199vmnet_clone_create(struct if_clone *ifc, int unit, caddr_t params) 200{ 201 struct cdev *dev; 202 int i; 203 204 /* Find any existing device, or allocate new unit number. */ 205 i = clone_create(&tapclones, &tap_cdevsw, &unit, &dev, VMNET_DEV_MASK); 206 if (i) { 207 dev = make_dev(&tap_cdevsw, unit | VMNET_DEV_MASK, UID_ROOT, 208 GID_WHEEL, 0600, "%s%d", tapname, unit); 209 } 210 211 tapcreate(dev); 212 return (0); 213} 214 215static void 216tap_destroy(struct tap_softc *tp) 217{ 218 struct ifnet *ifp = tp->tap_ifp; 219 220 CURVNET_SET(ifp->if_vnet); 221 destroy_dev(tp->tap_dev); 222 seldrain(&tp->tap_rsel); 223 knlist_destroy(&tp->tap_rsel.si_note); 224 ether_ifdetach(ifp); 225 if_free(ifp); 226 227 mtx_destroy(&tp->tap_mtx); 228 free(tp, M_TAP); 229 CURVNET_RESTORE(); 230} 231 232static void 233tap_clone_destroy(struct ifnet *ifp) 234{ 235 struct tap_softc *tp = ifp->if_softc; 236 237 mtx_lock(&tapmtx); 238 SLIST_REMOVE(&taphead, tp, tap_softc, tap_next); 239 mtx_unlock(&tapmtx); 240 tap_destroy(tp); 241} 242 243/* vmnet devices are tap devices in disguise */ 244static void 245vmnet_clone_destroy(struct ifnet *ifp) 246{ 247 tap_clone_destroy(ifp); 248} 249 250/* 251 * tapmodevent 252 * 253 * module event handler 254 */ 255static int 256tapmodevent(module_t mod, int type, void *data) 257{ 258 static eventhandler_tag eh_tag = NULL; 259 struct tap_softc *tp = NULL; 260 struct ifnet *ifp = NULL; 261 262 switch (type) { 263 case MOD_LOAD: 264 265 /* intitialize device */ 266 267 mtx_init(&tapmtx, "tapmtx", NULL, MTX_DEF); 268 SLIST_INIT(&taphead); 269 270 clone_setup(&tapclones); 271 eh_tag = EVENTHANDLER_REGISTER(dev_clone, tapclone, 0, 1000); 272 if (eh_tag == NULL) { 273 clone_cleanup(&tapclones); 274 mtx_destroy(&tapmtx); 275 return (ENOMEM); 276 } 277 tap_cloner = if_clone_simple(tapname, tap_clone_create, 278 tap_clone_destroy, 0); 279 vmnet_cloner = if_clone_simple(vmnetname, vmnet_clone_create, 280 vmnet_clone_destroy, 0); 281 return (0); 282 283 case MOD_UNLOAD: 284 /* 285 * The EBUSY algorithm here can't quite atomically 286 * guarantee that this is race-free since we have to 287 * release the tap mtx to deregister the clone handler. 288 */ 289 mtx_lock(&tapmtx); 290 SLIST_FOREACH(tp, &taphead, tap_next) { 291 mtx_lock(&tp->tap_mtx); 292 if (tp->tap_flags & TAP_OPEN) { 293 mtx_unlock(&tp->tap_mtx); 294 mtx_unlock(&tapmtx); 295 return (EBUSY); 296 } 297 mtx_unlock(&tp->tap_mtx); 298 } 299 mtx_unlock(&tapmtx); 300 301 EVENTHANDLER_DEREGISTER(dev_clone, eh_tag); 302 if_clone_detach(tap_cloner); 303 if_clone_detach(vmnet_cloner); 304 drain_dev_clone_events(); 305 306 mtx_lock(&tapmtx); 307 while ((tp = SLIST_FIRST(&taphead)) != NULL) { 308 SLIST_REMOVE_HEAD(&taphead, tap_next); 309 mtx_unlock(&tapmtx); 310 311 ifp = tp->tap_ifp; 312 313 TAPDEBUG("detaching %s\n", ifp->if_xname); 314 315 tap_destroy(tp); 316 mtx_lock(&tapmtx); 317 } 318 mtx_unlock(&tapmtx); 319 clone_cleanup(&tapclones); 320 321 mtx_destroy(&tapmtx); 322 323 break; 324 325 default: 326 return (EOPNOTSUPP); 327 } 328 329 return (0); 330} /* tapmodevent */ 331 332 333/* 334 * DEVFS handler 335 * 336 * We need to support two kind of devices - tap and vmnet 337 */ 338static void 339tapclone(void *arg, struct ucred *cred, char *name, int namelen, struct cdev **dev) 340{ 341 char devname[SPECNAMELEN + 1]; 342 int i, unit, append_unit; 343 int extra; 344 345 if (*dev != NULL) 346 return; 347 348 if (!tapdclone || 349 (!tapuopen && priv_check_cred(cred, PRIV_NET_IFCREATE, 0) != 0)) 350 return; 351 352 unit = 0; 353 append_unit = 0; 354 extra = 0; 355 356 /* We're interested in only tap/vmnet devices. */ 357 if (strcmp(name, tapname) == 0) { 358 unit = -1; 359 } else if (strcmp(name, vmnetname) == 0) { 360 unit = -1; 361 extra = VMNET_DEV_MASK; 362 } else if (dev_stdclone(name, NULL, tapname, &unit) != 1) { 363 if (dev_stdclone(name, NULL, vmnetname, &unit) != 1) { 364 return; 365 } else { 366 extra = VMNET_DEV_MASK; 367 } 368 } 369 370 if (unit == -1) 371 append_unit = 1; 372 373 CURVNET_SET(CRED_TO_VNET(cred)); 374 /* find any existing device, or allocate new unit number */ 375 i = clone_create(&tapclones, &tap_cdevsw, &unit, dev, extra); 376 if (i) { 377 if (append_unit) { 378 /* 379 * We were passed 'tun' or 'tap', with no unit specified 380 * so we'll need to append it now. 381 */ 382 namelen = snprintf(devname, sizeof(devname), "%s%d", name, 383 unit); 384 name = devname; 385 } 386 387 *dev = make_dev_credf(MAKEDEV_REF, &tap_cdevsw, unit | extra, 388 cred, UID_ROOT, GID_WHEEL, 0600, "%s", name); 389 } 390 391 if_clone_create(name, namelen, NULL); 392 CURVNET_RESTORE(); 393} /* tapclone */ 394 395 396/* 397 * tapcreate 398 * 399 * to create interface 400 */ 401static void 402tapcreate(struct cdev *dev) 403{ 404 struct ifnet *ifp = NULL; 405 struct tap_softc *tp = NULL; 406 unsigned short macaddr_hi; 407 uint32_t macaddr_mid; 408 int unit; 409 const char *name = NULL; 410 u_char eaddr[6]; 411 412 dev->si_flags &= ~SI_CHEAPCLONE; 413 414 /* allocate driver storage and create device */ 415 tp = malloc(sizeof(*tp), M_TAP, M_WAITOK | M_ZERO); 416 mtx_init(&tp->tap_mtx, "tap_mtx", NULL, MTX_DEF); 417 mtx_lock(&tapmtx); 418 SLIST_INSERT_HEAD(&taphead, tp, tap_next); 419 mtx_unlock(&tapmtx); 420 421 unit = dev2unit(dev); 422 423 /* select device: tap or vmnet */ 424 if (unit & VMNET_DEV_MASK) { 425 name = vmnetname; 426 tp->tap_flags |= TAP_VMNET; 427 } else 428 name = tapname; 429 430 unit &= TAPMAXUNIT; 431 432 TAPDEBUG("tapcreate(%s%d). minor = %#x\n", name, unit, dev2unit(dev)); 433 434 /* generate fake MAC address: 00 bd xx xx xx unit_no */ 435 macaddr_hi = htons(0x00bd); 436 macaddr_mid = (uint32_t) ticks; 437 bcopy(&macaddr_hi, eaddr, sizeof(short)); 438 bcopy(&macaddr_mid, &eaddr[2], sizeof(uint32_t)); 439 eaddr[5] = (u_char)unit; 440 441 /* fill the rest and attach interface */ 442 ifp = tp->tap_ifp = if_alloc(IFT_ETHER); 443 if (ifp == NULL) 444 panic("%s%d: can not if_alloc()", name, unit); 445 ifp->if_softc = tp; 446 if_initname(ifp, name, unit); 447 ifp->if_init = tapifinit; 448 ifp->if_start = tapifstart; 449 ifp->if_ioctl = tapifioctl; 450 ifp->if_mtu = ETHERMTU; 451 ifp->if_flags = (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST); 452 IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen); 453 ifp->if_capabilities |= IFCAP_LINKSTATE; 454 ifp->if_capenable |= IFCAP_LINKSTATE; 455 456 dev->si_drv1 = tp; 457 tp->tap_dev = dev; 458 459 ether_ifattach(ifp, eaddr); 460 461 mtx_lock(&tp->tap_mtx); 462 tp->tap_flags |= TAP_INITED; 463 mtx_unlock(&tp->tap_mtx); 464 465 knlist_init_mtx(&tp->tap_rsel.si_note, &tp->tap_mtx); 466 467 TAPDEBUG("interface %s is created. minor = %#x\n", 468 ifp->if_xname, dev2unit(dev)); 469} /* tapcreate */ 470 471 472/* 473 * tapopen 474 * 475 * to open tunnel. must be superuser 476 */ 477static int 478tapopen(struct cdev *dev, int flag, int mode, struct thread *td) 479{ 480 struct tap_softc *tp = NULL; 481 struct ifnet *ifp = NULL; 482 int error; 483 484 if (tapuopen == 0) { 485 error = priv_check(td, PRIV_NET_TAP); 486 if (error) 487 return (error); 488 } 489 490 if ((dev2unit(dev) & CLONE_UNITMASK) > TAPMAXUNIT) 491 return (ENXIO); 492 493 tp = dev->si_drv1; 494 495 mtx_lock(&tp->tap_mtx); 496 if (tp->tap_flags & TAP_OPEN) { 497 mtx_unlock(&tp->tap_mtx); 498 return (EBUSY); 499 } 500 501 bcopy(IF_LLADDR(tp->tap_ifp), tp->ether_addr, sizeof(tp->ether_addr)); 502 tp->tap_pid = td->td_proc->p_pid; 503 tp->tap_flags |= TAP_OPEN; 504 ifp = tp->tap_ifp; 505 506 ifp->if_drv_flags |= IFF_DRV_RUNNING; 507 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 508 if (tapuponopen) 509 ifp->if_flags |= IFF_UP; 510 if_link_state_change(ifp, LINK_STATE_UP); 511 mtx_unlock(&tp->tap_mtx); 512 513 TAPDEBUG("%s is open. minor = %#x\n", ifp->if_xname, dev2unit(dev)); 514 515 return (0); 516} /* tapopen */ 517 518 519/* 520 * tapclose 521 * 522 * close the device - mark i/f down & delete routing info 523 */ 524static int 525tapclose(struct cdev *dev, int foo, int bar, struct thread *td) 526{ 527 struct ifaddr *ifa; 528 struct tap_softc *tp = dev->si_drv1; 529 struct ifnet *ifp = tp->tap_ifp; 530 531 /* junk all pending output */ 532 mtx_lock(&tp->tap_mtx); 533 CURVNET_SET(ifp->if_vnet); 534 IF_DRAIN(&ifp->if_snd); 535 536 /* 537 * do not bring the interface down, and do not anything with 538 * interface, if we are in VMnet mode. just close the device. 539 */ 540 541 if (((tp->tap_flags & TAP_VMNET) == 0) && (ifp->if_flags & IFF_UP)) { 542 mtx_unlock(&tp->tap_mtx); 543 if_down(ifp); 544 mtx_lock(&tp->tap_mtx); 545 if (ifp->if_drv_flags & IFF_DRV_RUNNING) { 546 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 547 mtx_unlock(&tp->tap_mtx); 548 TAILQ_FOREACH(ifa, &ifp->if_addrhead, ifa_link) { 549 rtinit(ifa, (int)RTM_DELETE, 0); 550 } 551 if_purgeaddrs(ifp); 552 mtx_lock(&tp->tap_mtx); 553 } 554 } 555 556 if_link_state_change(ifp, LINK_STATE_DOWN); 557 CURVNET_RESTORE(); 558 559 funsetown(&tp->tap_sigio); 560 selwakeuppri(&tp->tap_rsel, PZERO+1); 561 KNOTE_LOCKED(&tp->tap_rsel.si_note, 0); 562 563 tp->tap_flags &= ~TAP_OPEN; 564 tp->tap_pid = 0; 565 mtx_unlock(&tp->tap_mtx); 566 567 TAPDEBUG("%s is closed. minor = %#x\n", 568 ifp->if_xname, dev2unit(dev)); 569 570 return (0); 571} /* tapclose */ 572 573 574/* 575 * tapifinit 576 * 577 * network interface initialization function 578 */ 579static void 580tapifinit(void *xtp) 581{ 582 struct tap_softc *tp = (struct tap_softc *)xtp; 583 struct ifnet *ifp = tp->tap_ifp; 584 585 TAPDEBUG("initializing %s\n", ifp->if_xname); 586 587 mtx_lock(&tp->tap_mtx); 588 ifp->if_drv_flags |= IFF_DRV_RUNNING; 589 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 590 mtx_unlock(&tp->tap_mtx); 591 592 /* attempt to start output */ 593 tapifstart(ifp); 594} /* tapifinit */ 595 596 597/* 598 * tapifioctl 599 * 600 * Process an ioctl request on network interface 601 */ 602static int 603tapifioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 604{ 605 struct tap_softc *tp = ifp->if_softc; 606 struct ifreq *ifr = (struct ifreq *)data; 607 struct ifstat *ifs = NULL; 608 struct ifmediareq *ifmr = NULL; 609 int dummy, error = 0; 610 611 switch (cmd) { 612 case SIOCSIFFLAGS: /* XXX -- just like vmnet does */ 613 case SIOCADDMULTI: 614 case SIOCDELMULTI: 615 break; 616 617 case SIOCGIFMEDIA: 618 ifmr = (struct ifmediareq *)data; 619 dummy = ifmr->ifm_count; 620 ifmr->ifm_count = 1; 621 ifmr->ifm_status = IFM_AVALID; 622 ifmr->ifm_active = IFM_ETHER; 623 if (tp->tap_flags & TAP_OPEN) 624 ifmr->ifm_status |= IFM_ACTIVE; 625 ifmr->ifm_current = ifmr->ifm_active; 626 if (dummy >= 1) { 627 int media = IFM_ETHER; 628 error = copyout(&media, ifmr->ifm_ulist, 629 sizeof(int)); 630 } 631 break; 632 633 case SIOCSIFMTU: 634 ifp->if_mtu = ifr->ifr_mtu; 635 break; 636 637 case SIOCGIFSTATUS: 638 ifs = (struct ifstat *)data; 639 dummy = strlen(ifs->ascii); 640 mtx_lock(&tp->tap_mtx); 641 if (tp->tap_pid != 0 && dummy < sizeof(ifs->ascii)) 642 snprintf(ifs->ascii + dummy, 643 sizeof(ifs->ascii) - dummy, 644 "\tOpened by PID %d\n", tp->tap_pid); 645 mtx_unlock(&tp->tap_mtx); 646 break; 647 648 default: 649 error = ether_ioctl(ifp, cmd, data); 650 break; 651 } 652 653 return (error); 654} /* tapifioctl */ 655 656 657/* 658 * tapifstart 659 * 660 * queue packets from higher level ready to put out 661 */ 662static void 663tapifstart(struct ifnet *ifp) 664{ 665 struct tap_softc *tp = ifp->if_softc; 666 667 TAPDEBUG("%s starting\n", ifp->if_xname); 668 669 /* 670 * do not junk pending output if we are in VMnet mode. 671 * XXX: can this do any harm because of queue overflow? 672 */ 673 674 mtx_lock(&tp->tap_mtx); 675 if (((tp->tap_flags & TAP_VMNET) == 0) && 676 ((tp->tap_flags & TAP_READY) != TAP_READY)) { 677 struct mbuf *m; 678 679 /* Unlocked read. */ 680 TAPDEBUG("%s not ready, tap_flags = 0x%x\n", ifp->if_xname, 681 tp->tap_flags); 682 683 for (;;) { 684 IF_DEQUEUE(&ifp->if_snd, m); 685 if (m != NULL) { 686 m_freem(m); 687 ifp->if_oerrors++; 688 } else 689 break; 690 } 691 mtx_unlock(&tp->tap_mtx); 692 693 return; 694 } 695 696 ifp->if_drv_flags |= IFF_DRV_OACTIVE; 697 698 if (!IFQ_IS_EMPTY(&ifp->if_snd)) { 699 if (tp->tap_flags & TAP_RWAIT) { 700 tp->tap_flags &= ~TAP_RWAIT; 701 wakeup(tp); 702 } 703 704 if ((tp->tap_flags & TAP_ASYNC) && (tp->tap_sigio != NULL)) { 705 mtx_unlock(&tp->tap_mtx); 706 pgsigio(&tp->tap_sigio, SIGIO, 0); 707 mtx_lock(&tp->tap_mtx); 708 } 709 710 selwakeuppri(&tp->tap_rsel, PZERO+1); 711 KNOTE_LOCKED(&tp->tap_rsel.si_note, 0); 712 ifp->if_opackets ++; /* obytes are counted in ether_output */ 713 } 714 715 ifp->if_drv_flags &= ~IFF_DRV_OACTIVE; 716 mtx_unlock(&tp->tap_mtx); 717} /* tapifstart */ 718 719 720/* 721 * tapioctl 722 * 723 * the cdevsw interface is now pretty minimal 724 */ 725static int 726tapioctl(struct cdev *dev, u_long cmd, caddr_t data, int flag, struct thread *td) 727{ 728 struct tap_softc *tp = dev->si_drv1; 729 struct ifnet *ifp = tp->tap_ifp; 730 struct tapinfo *tapp = NULL; 731 int f; 732#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 733 defined(COMPAT_FREEBSD4) 734 int ival; 735#endif 736 737 switch (cmd) { 738 case TAPSIFINFO: 739 tapp = (struct tapinfo *)data; 740 mtx_lock(&tp->tap_mtx); 741 ifp->if_mtu = tapp->mtu; 742 ifp->if_type = tapp->type; 743 ifp->if_baudrate = tapp->baudrate; 744 mtx_unlock(&tp->tap_mtx); 745 break; 746 747 case TAPGIFINFO: 748 tapp = (struct tapinfo *)data; 749 mtx_lock(&tp->tap_mtx); 750 tapp->mtu = ifp->if_mtu; 751 tapp->type = ifp->if_type; 752 tapp->baudrate = ifp->if_baudrate; 753 mtx_unlock(&tp->tap_mtx); 754 break; 755 756 case TAPSDEBUG: 757 tapdebug = *(int *)data; 758 break; 759 760 case TAPGDEBUG: 761 *(int *)data = tapdebug; 762 break; 763 764 case TAPGIFNAME: { 765 struct ifreq *ifr = (struct ifreq *) data; 766 767 strlcpy(ifr->ifr_name, ifp->if_xname, IFNAMSIZ); 768 } break; 769 770 case FIONBIO: 771 break; 772 773 case FIOASYNC: 774 mtx_lock(&tp->tap_mtx); 775 if (*(int *)data) 776 tp->tap_flags |= TAP_ASYNC; 777 else 778 tp->tap_flags &= ~TAP_ASYNC; 779 mtx_unlock(&tp->tap_mtx); 780 break; 781 782 case FIONREAD: 783 if (!IFQ_IS_EMPTY(&ifp->if_snd)) { 784 struct mbuf *mb; 785 786 IFQ_LOCK(&ifp->if_snd); 787 IFQ_POLL_NOLOCK(&ifp->if_snd, mb); 788 for (*(int *)data = 0; mb != NULL; 789 mb = mb->m_next) 790 *(int *)data += mb->m_len; 791 IFQ_UNLOCK(&ifp->if_snd); 792 } else 793 *(int *)data = 0; 794 break; 795 796 case FIOSETOWN: 797 return (fsetown(*(int *)data, &tp->tap_sigio)); 798 799 case FIOGETOWN: 800 *(int *)data = fgetown(&tp->tap_sigio); 801 return (0); 802 803 /* this is deprecated, FIOSETOWN should be used instead */ 804 case TIOCSPGRP: 805 return (fsetown(-(*(int *)data), &tp->tap_sigio)); 806 807 /* this is deprecated, FIOGETOWN should be used instead */ 808 case TIOCGPGRP: 809 *(int *)data = -fgetown(&tp->tap_sigio); 810 return (0); 811 812 /* VMware/VMnet port ioctl's */ 813 814#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \ 815 defined(COMPAT_FREEBSD4) 816 case _IO('V', 0): 817 ival = IOCPARM_IVAL(data); 818 data = (caddr_t)&ival; 819 /* FALLTHROUGH */ 820#endif 821 case VMIO_SIOCSIFFLAGS: /* VMware/VMnet SIOCSIFFLAGS */ 822 f = *(int *)data; 823 f &= 0x0fff; 824 f &= ~IFF_CANTCHANGE; 825 f |= IFF_UP; 826 827 mtx_lock(&tp->tap_mtx); 828 ifp->if_flags = f | (ifp->if_flags & IFF_CANTCHANGE); 829 mtx_unlock(&tp->tap_mtx); 830 break; 831 832 case OSIOCGIFADDR: /* get MAC address of the remote side */ 833 case SIOCGIFADDR: 834 mtx_lock(&tp->tap_mtx); 835 bcopy(tp->ether_addr, data, sizeof(tp->ether_addr)); 836 mtx_unlock(&tp->tap_mtx); 837 break; 838 839 case SIOCSIFADDR: /* set MAC address of the remote side */ 840 mtx_lock(&tp->tap_mtx); 841 bcopy(data, tp->ether_addr, sizeof(tp->ether_addr)); 842 mtx_unlock(&tp->tap_mtx); 843 break; 844 845 default: 846 return (ENOTTY); 847 } 848 return (0); 849} /* tapioctl */ 850 851 852/* 853 * tapread 854 * 855 * the cdevsw read interface - reads a packet at a time, or at 856 * least as much of a packet as can be read 857 */ 858static int 859tapread(struct cdev *dev, struct uio *uio, int flag) 860{ 861 struct tap_softc *tp = dev->si_drv1; 862 struct ifnet *ifp = tp->tap_ifp; 863 struct mbuf *m = NULL; 864 int error = 0, len; 865 866 TAPDEBUG("%s reading, minor = %#x\n", ifp->if_xname, dev2unit(dev)); 867 868 mtx_lock(&tp->tap_mtx); 869 if ((tp->tap_flags & TAP_READY) != TAP_READY) { 870 mtx_unlock(&tp->tap_mtx); 871 872 /* Unlocked read. */ 873 TAPDEBUG("%s not ready. minor = %#x, tap_flags = 0x%x\n", 874 ifp->if_xname, dev2unit(dev), tp->tap_flags); 875 876 return (EHOSTDOWN); 877 } 878 879 tp->tap_flags &= ~TAP_RWAIT; 880 881 /* sleep until we get a packet */ 882 do { 883 IF_DEQUEUE(&ifp->if_snd, m); 884 885 if (m == NULL) { 886 if (flag & O_NONBLOCK) { 887 mtx_unlock(&tp->tap_mtx); 888 return (EWOULDBLOCK); 889 } 890 891 tp->tap_flags |= TAP_RWAIT; 892 error = mtx_sleep(tp, &tp->tap_mtx, PCATCH | (PZERO + 1), 893 "taprd", 0); 894 if (error) { 895 mtx_unlock(&tp->tap_mtx); 896 return (error); 897 } 898 } 899 } while (m == NULL); 900 mtx_unlock(&tp->tap_mtx); 901 902 /* feed packet to bpf */ 903 BPF_MTAP(ifp, m); 904 905 /* xfer packet to user space */ 906 while ((m != NULL) && (uio->uio_resid > 0) && (error == 0)) { 907 len = min(uio->uio_resid, m->m_len); 908 if (len == 0) 909 break; 910 911 error = uiomove(mtod(m, void *), len, uio); 912 m = m_free(m); 913 } 914 915 if (m != NULL) { 916 TAPDEBUG("%s dropping mbuf, minor = %#x\n", ifp->if_xname, 917 dev2unit(dev)); 918 m_freem(m); 919 } 920 921 return (error); 922} /* tapread */ 923 924 925/* 926 * tapwrite 927 * 928 * the cdevsw write interface - an atomic write is a packet - or else! 929 */ 930static int 931tapwrite(struct cdev *dev, struct uio *uio, int flag) 932{ 933 struct ether_header *eh; 934 struct tap_softc *tp = dev->si_drv1; 935 struct ifnet *ifp = tp->tap_ifp; 936 struct mbuf *m; 937 938 TAPDEBUG("%s writing, minor = %#x\n", 939 ifp->if_xname, dev2unit(dev)); 940 941 if (uio->uio_resid == 0) 942 return (0); 943 944 if ((uio->uio_resid < 0) || (uio->uio_resid > TAPMRU)) { 945 TAPDEBUG("%s invalid packet len = %zd, minor = %#x\n", 946 ifp->if_xname, uio->uio_resid, dev2unit(dev)); 947 948 return (EIO); 949 } 950 951 if ((m = m_uiotombuf(uio, M_DONTWAIT, 0, ETHER_ALIGN, 952 M_PKTHDR)) == NULL) { 953 ifp->if_ierrors ++; 954 return (ENOBUFS); 955 } 956 957 m->m_pkthdr.rcvif = ifp; 958 959 /* 960 * Only pass a unicast frame to ether_input(), if it would actually 961 * have been received by non-virtual hardware. 962 */ 963 if (m->m_len < sizeof(struct ether_header)) { 964 m_freem(m); 965 return (0); 966 } 967 eh = mtod(m, struct ether_header *); 968 969 if (eh && (ifp->if_flags & IFF_PROMISC) == 0 && 970 !ETHER_IS_MULTICAST(eh->ether_dhost) && 971 bcmp(eh->ether_dhost, IF_LLADDR(ifp), ETHER_ADDR_LEN) != 0) { 972 m_freem(m); 973 return (0); 974 } 975 976 /* Pass packet up to parent. */ 977 CURVNET_SET(ifp->if_vnet); 978 (*ifp->if_input)(ifp, m); 979 CURVNET_RESTORE(); 980 ifp->if_ipackets ++; /* ibytes are counted in parent */ 981 982 return (0); 983} /* tapwrite */ 984 985 986/* 987 * tappoll 988 * 989 * the poll interface, this is only useful on reads 990 * really. the write detect always returns true, write never blocks 991 * anyway, it either accepts the packet or drops it 992 */ 993static int 994tappoll(struct cdev *dev, int events, struct thread *td) 995{ 996 struct tap_softc *tp = dev->si_drv1; 997 struct ifnet *ifp = tp->tap_ifp; 998 int revents = 0; 999 1000 TAPDEBUG("%s polling, minor = %#x\n", 1001 ifp->if_xname, dev2unit(dev)); 1002 1003 if (events & (POLLIN | POLLRDNORM)) { 1004 IFQ_LOCK(&ifp->if_snd); 1005 if (!IFQ_IS_EMPTY(&ifp->if_snd)) { 1006 TAPDEBUG("%s have data in queue. len = %d, " \ 1007 "minor = %#x\n", ifp->if_xname, 1008 ifp->if_snd.ifq_len, dev2unit(dev)); 1009 1010 revents |= (events & (POLLIN | POLLRDNORM)); 1011 } else { 1012 TAPDEBUG("%s waiting for data, minor = %#x\n", 1013 ifp->if_xname, dev2unit(dev)); 1014 1015 selrecord(td, &tp->tap_rsel); 1016 } 1017 IFQ_UNLOCK(&ifp->if_snd); 1018 } 1019 1020 if (events & (POLLOUT | POLLWRNORM)) 1021 revents |= (events & (POLLOUT | POLLWRNORM)); 1022 1023 return (revents); 1024} /* tappoll */ 1025 1026 1027/* 1028 * tap_kqfilter 1029 * 1030 * support for kevent() system call 1031 */ 1032static int 1033tapkqfilter(struct cdev *dev, struct knote *kn) 1034{ 1035 struct tap_softc *tp = dev->si_drv1; 1036 struct ifnet *ifp = tp->tap_ifp; 1037 1038 switch (kn->kn_filter) { 1039 case EVFILT_READ: 1040 TAPDEBUG("%s kqfilter: EVFILT_READ, minor = %#x\n", 1041 ifp->if_xname, dev2unit(dev)); 1042 kn->kn_fop = &tap_read_filterops; 1043 break; 1044 1045 case EVFILT_WRITE: 1046 TAPDEBUG("%s kqfilter: EVFILT_WRITE, minor = %#x\n", 1047 ifp->if_xname, dev2unit(dev)); 1048 kn->kn_fop = &tap_write_filterops; 1049 break; 1050 1051 default: 1052 TAPDEBUG("%s kqfilter: invalid filter, minor = %#x\n", 1053 ifp->if_xname, dev2unit(dev)); 1054 return (EINVAL); 1055 /* NOT REACHED */ 1056 } 1057 1058 kn->kn_hook = tp; 1059 knlist_add(&tp->tap_rsel.si_note, kn, 0); 1060 1061 return (0); 1062} /* tapkqfilter */ 1063 1064 1065/* 1066 * tap_kqread 1067 * 1068 * Return true if there is data in the interface queue 1069 */ 1070static int 1071tapkqread(struct knote *kn, long hint) 1072{ 1073 int ret; 1074 struct tap_softc *tp = kn->kn_hook; 1075 struct cdev *dev = tp->tap_dev; 1076 struct ifnet *ifp = tp->tap_ifp; 1077 1078 if ((kn->kn_data = ifp->if_snd.ifq_len) > 0) { 1079 TAPDEBUG("%s have data in queue. len = %d, minor = %#x\n", 1080 ifp->if_xname, ifp->if_snd.ifq_len, dev2unit(dev)); 1081 ret = 1; 1082 } else { 1083 TAPDEBUG("%s waiting for data, minor = %#x\n", 1084 ifp->if_xname, dev2unit(dev)); 1085 ret = 0; 1086 } 1087 1088 return (ret); 1089} /* tapkqread */ 1090 1091 1092/* 1093 * tap_kqwrite 1094 * 1095 * Always can write. Return the MTU in kn->data 1096 */ 1097static int 1098tapkqwrite(struct knote *kn, long hint) 1099{ 1100 struct tap_softc *tp = kn->kn_hook; 1101 struct ifnet *ifp = tp->tap_ifp; 1102 1103 kn->kn_data = ifp->if_mtu; 1104 1105 return (1); 1106} /* tapkqwrite */ 1107 1108 1109static void 1110tapkqdetach(struct knote *kn) 1111{ 1112 struct tap_softc *tp = kn->kn_hook; 1113 1114 knlist_remove(&tp->tap_rsel.si_note, kn, 0); 1115} /* tapkqdetach */ 1116 1117