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: src/sys/net/if_tap.c,v 1.3.2.3 2002/04/14 21:41:48 luigi Exp $ 35 * $Id: if_tap.c,v 0.21 2000/07/23 21:46:02 max Exp $ 36 */ 37 38 #include "opt_inet.h" 39 #include "use_tap.h" 40 41 #include <sys/param.h> 42 #include <sys/conf.h> 43 #include <sys/device.h> 44 #include <sys/filedesc.h> 45 #include <sys/filio.h> 46 #include <sys/kernel.h> 47 #include <sys/malloc.h> 48 #include <sys/mbuf.h> 49 #include <sys/proc.h> 50 #include <sys/priv.h> 51 #include <sys/signalvar.h> 52 #include <sys/socket.h> 53 #include <sys/sockio.h> 54 #include <sys/sysctl.h> 55 #include <sys/systm.h> 56 #include <sys/ttycom.h> 57 #include <sys/uio.h> 58 #include <sys/vnode.h> 59 #include <sys/serialize.h> 60 61 #include <sys/thread2.h> 62 #include <sys/mplock2.h> 63 64 #include <net/bpf.h> 65 #include <net/ethernet.h> 66 #include <net/if.h> 67 #include <net/ifq_var.h> 68 #include <net/if_arp.h> 69 #include <net/if_clone.h> 70 #include <net/if_media.h> 71 #include <net/route.h> 72 #include <sys/devfs.h> 73 74 #include <netinet/in.h> 75 76 #include "if_tapvar.h" 77 #include "if_tap.h" 78 79 #define TAP_IFFLAGS (IFF_BROADCAST|IFF_SIMPLEX|IFF_MULTICAST) 80 81 #if NTAP <= 1 82 #define TAP_PREALLOCATED_UNITS 4 83 #else 84 #define TAP_PREALLOCATED_UNITS NTAP 85 #endif 86 87 #define CDEV_NAME "tap" 88 #define TAPDEBUG if (tapdebug) if_printf 89 90 #define TAP "tap" 91 #define VMNET "vmnet" 92 #define VMNET_DEV_MASK 0x00010000 93 94 DEVFS_DECLARE_CLONE_BITMAP(tap); 95 96 /* module */ 97 static int tapmodevent (module_t, int, void *); 98 99 /* device */ 100 static struct tap_softc *tapcreate(int, cdev_t); 101 static void tapdestroy(struct tap_softc *); 102 103 /* clone */ 104 static int tap_clone_create(struct if_clone *, int, caddr_t); 105 static int tap_clone_destroy(struct ifnet *); 106 107 108 /* network interface */ 109 static void tapifstart (struct ifnet *, 110 struct ifaltq_subque *); 111 static int tapifioctl (struct ifnet *, u_long, caddr_t, 112 struct ucred *); 113 static void tapifinit (void *); 114 static void tapifstop(struct tap_softc *, int); 115 static void tapifflags(struct tap_softc *); 116 117 118 /* character device */ 119 static d_open_t tapopen; 120 static d_clone_t tapclone; 121 static d_close_t tapclose; 122 static d_read_t tapread; 123 static d_write_t tapwrite; 124 static d_ioctl_t tapioctl; 125 static d_kqfilter_t tapkqfilter; 126 127 static struct dev_ops tap_ops = { 128 { CDEV_NAME, 0, 0 }, 129 .d_open = tapopen, 130 .d_close = tapclose, 131 .d_read = tapread, 132 .d_write = tapwrite, 133 .d_ioctl = tapioctl, 134 .d_kqfilter = tapkqfilter 135 }; 136 137 static int taprefcnt = 0; /* module ref. counter */ 138 static int taplastunit = -1; /* max. open unit number */ 139 static int tapdebug = 0; /* debug flag */ 140 static int tapuopen = 0; /* all user open() */ 141 static int tapuponopen = 0; /* IFF_UP */ 142 143 MALLOC_DECLARE(M_TAP); 144 MALLOC_DEFINE(M_TAP, CDEV_NAME, "Ethernet tunnel interface"); 145 struct if_clone tap_cloner = IF_CLONE_INITIALIZER("tap", 146 tap_clone_create, tap_clone_destroy, 147 0, IF_MAXUNIT); 148 static SLIST_HEAD(,tap_softc) tap_listhead = 149 SLIST_HEAD_INITIALIZER(&tap_listhead); 150 151 SYSCTL_INT(_debug, OID_AUTO, if_tap_debug, CTLFLAG_RW, &tapdebug, 0, ""); 152 SYSCTL_DECL(_net_link); 153 SYSCTL_NODE(_net_link, OID_AUTO, tap, CTLFLAG_RW, 0, 154 "Ethernet tunnel software network interface"); 155 SYSCTL_INT(_net_link_tap, OID_AUTO, user_open, CTLFLAG_RW, &tapuopen, 0, 156 "Allow user to open /dev/tap (based on node permissions)"); 157 SYSCTL_INT(_net_link_tap, OID_AUTO, up_on_open, CTLFLAG_RW, &tapuponopen, 0, 158 "Bring interface up when /dev/tap is opened"); 159 SYSCTL_INT(_net_link_tap, OID_AUTO, debug, CTLFLAG_RW, &tapdebug, 0, ""); 160 161 DEV_MODULE(if_tap, tapmodevent, NULL); 162 163 /* 164 * tapmodevent 165 * 166 * module event handler 167 */ 168 static int 169 tapmodevent(module_t mod, int type, void *data) 170 { 171 static int attached = 0; 172 struct tap_softc *tp, *ntp; 173 int i; 174 175 switch (type) { 176 case MOD_LOAD: 177 if (attached) 178 return (EEXIST); 179 180 make_autoclone_dev(&tap_ops, &DEVFS_CLONE_BITMAP(tap), tapclone, 181 UID_ROOT, GID_WHEEL, 0600, "tap"); 182 SLIST_INIT(&tap_listhead); 183 if_clone_attach(&tap_cloner); 184 185 for (i = 0; i < TAP_PREALLOCATED_UNITS; ++i) { 186 make_dev(&tap_ops, i, UID_ROOT, GID_WHEEL, 187 0600, "tap%d", i); 188 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(tap), i); 189 } 190 191 attached = 1; 192 break; 193 194 case MOD_UNLOAD: 195 if (taprefcnt > 0) 196 return (EBUSY); 197 198 if_clone_detach(&tap_cloner); 199 200 /* Maintain tap ifs in a local list */ 201 SLIST_FOREACH_MUTABLE(tp, &tap_listhead, tap_link, ntp) 202 tapdestroy(tp); 203 204 attached = 0; 205 206 devfs_clone_handler_del("tap"); 207 dev_ops_remove_all(&tap_ops); 208 devfs_clone_bitmap_uninit(&DEVFS_CLONE_BITMAP(tap)); 209 break; 210 211 default: 212 return (EOPNOTSUPP); 213 } 214 215 return (0); 216 } /* tapmodevent */ 217 218 219 /* 220 * tapcreate - create or clone an interface 221 */ 222 static struct tap_softc * 223 tapcreate(int unit, cdev_t dev) 224 { 225 const char *name = TAP; 226 struct ifnet *ifp; 227 struct tap_softc *tp; 228 uint8_t ether_addr[ETHER_ADDR_LEN]; 229 230 tp = kmalloc(sizeof(*tp), M_TAP, M_WAITOK | M_ZERO); 231 dev->si_drv1 = tp; 232 tp->tap_dev = dev; 233 tp->tap_unit = unit; 234 235 reference_dev(dev); /* tp association */ 236 237 /* generate fake MAC address: 00 bd xx xx xx unit_no */ 238 ether_addr[0] = 0x00; 239 ether_addr[1] = 0xbd; 240 bcopy(&ticks, ðer_addr[2], 3); 241 ether_addr[5] = (u_char)unit; 242 243 /* fill the rest and attach interface */ 244 ifp = &tp->tap_if; 245 ifp->if_softc = tp; 246 247 if_initname(ifp, name, unit); 248 if (unit > taplastunit) 249 taplastunit = unit; 250 251 ifp->if_init = tapifinit; 252 ifp->if_start = tapifstart; 253 ifp->if_ioctl = tapifioctl; 254 ifp->if_mtu = ETHERMTU; 255 ifp->if_flags = TAP_IFFLAGS; 256 ifq_set_maxlen(&ifp->if_snd, ifqmaxlen); 257 ifq_set_ready(&ifp->if_snd); 258 259 ether_ifattach(ifp, ether_addr, NULL); 260 261 tp->tap_flags |= TAP_INITED; 262 tp->tap_devq.ifq_maxlen = ifqmaxlen; 263 264 SLIST_INSERT_HEAD(&tap_listhead, tp, tap_link); 265 266 TAPDEBUG(ifp, "created. minor = %#x\n", minor(dev)); 267 return (tp); 268 } 269 270 static 271 struct tap_softc * 272 tapfind(int unit) 273 { 274 struct tap_softc *tp; 275 276 SLIST_FOREACH(tp, &tap_listhead, tap_link) { 277 if (tp->tap_unit == unit) 278 return(tp); 279 } 280 return (NULL); 281 } 282 283 /* 284 * tap_clone_create: 285 * 286 * Create a new tap instance via ifconfig. 287 */ 288 static int 289 tap_clone_create(struct if_clone *ifc __unused, int unit, 290 caddr_t param __unused) 291 { 292 struct tap_softc *tp; 293 cdev_t dev; 294 295 tp = tapfind(unit); 296 if (tp == NULL) { 297 if (!devfs_clone_bitmap_chk(&DEVFS_CLONE_BITMAP(tap), unit)) { 298 devfs_clone_bitmap_set(&DEVFS_CLONE_BITMAP(tap), unit); 299 dev = make_dev(&tap_ops, unit, UID_ROOT, GID_WHEEL, 300 0600, "%s%d", TAP, unit); 301 } else { 302 dev = devfs_find_device_by_name("%s%d", TAP, unit); 303 } 304 305 KKASSERT(dev != NULL); 306 tp = tapcreate(unit, dev); 307 } 308 tp->tap_flags |= TAP_CLONE; 309 TAPDEBUG(&tp->tap_if, "clone created. minor = %#x tap_flags = 0x%x\n", 310 minor(tp->tap_dev), tp->tap_flags); 311 312 return (0); 313 } 314 315 /* 316 * tapopen 317 * 318 * to open tunnel. must be superuser 319 */ 320 static int 321 tapopen(struct dev_open_args *ap) 322 { 323 cdev_t dev = NULL; 324 struct tap_softc *tp = NULL; 325 struct ifnet *ifp = NULL; 326 int error; 327 328 if (tapuopen == 0 && 329 (error = priv_check_cred(ap->a_cred, PRIV_ROOT, 0)) != 0) 330 return (error); 331 332 get_mplock(); 333 dev = ap->a_head.a_dev; 334 tp = dev->si_drv1; 335 if (tp == NULL) 336 tp = tapcreate(minor(dev), dev); 337 if (tp->tap_flags & TAP_OPEN) { 338 rel_mplock(); 339 return (EBUSY); 340 } 341 ifp = &tp->arpcom.ac_if; 342 343 if ((tp->tap_flags & TAP_CLONE) == 0) { 344 EVENTHANDLER_INVOKE(ifnet_attach_event, ifp); 345 346 /* Announce the return of the interface. */ 347 rt_ifannouncemsg(ifp, IFAN_ARRIVAL); 348 } 349 350 bcopy(tp->arpcom.ac_enaddr, tp->ether_addr, sizeof(tp->ether_addr)); 351 352 if (curthread->td_proc) 353 fsetown(curthread->td_proc->p_pid, &tp->tap_sigtd); 354 tp->tap_flags |= TAP_OPEN; 355 taprefcnt ++; 356 357 if (tapuponopen && (ifp->if_flags & IFF_UP) == 0) { 358 crit_enter(); 359 if_up(ifp); 360 crit_exit(); 361 362 ifnet_serialize_all(ifp); 363 tapifflags(tp); 364 ifnet_deserialize_all(ifp); 365 366 tp->tap_flags |= TAP_CLOSEDOWN; 367 } 368 369 TAPDEBUG(ifp, "opened. minor = %#x, refcnt = %d, taplastunit = %d\n", 370 minor(tp->tap_dev), taprefcnt, taplastunit); 371 372 rel_mplock(); 373 return (0); 374 } 375 376 static int 377 tapclone(struct dev_clone_args *ap) 378 { 379 int unit; 380 381 unit = devfs_clone_bitmap_get(&DEVFS_CLONE_BITMAP(tap), 0); 382 ap->a_dev = make_only_dev(&tap_ops, unit, UID_ROOT, GID_WHEEL, 383 0600, "%s%d", TAP, unit); 384 tapcreate(unit, ap->a_dev); 385 return (0); 386 } 387 388 /* 389 * tapclose 390 * 391 * close the device - mark i/f down & delete routing info 392 */ 393 static int 394 tapclose(struct dev_close_args *ap) 395 { 396 cdev_t dev = ap->a_head.a_dev; 397 struct tap_softc *tp = dev->si_drv1; 398 struct ifnet *ifp = &tp->tap_if; 399 int clear_flags = 0; 400 401 get_mplock(); 402 403 /* Junk all pending output */ 404 ifq_purge_all(&ifp->if_snd); 405 406 /* 407 * Do not bring the interface down, and do not anything with 408 * interface, if we are in VMnet mode. just close the device. 409 * 410 * If the interface is not cloned, we always bring it down. 411 * 412 * If the interface is cloned, then we bring it down during 413 * closing only if it was brought up during opening. 414 */ 415 if ((tp->tap_flags & TAP_VMNET) == 0 && 416 ((tp->tap_flags & TAP_CLONE) == 0 || 417 (tp->tap_flags & TAP_CLOSEDOWN))) { 418 if (ifp->if_flags & IFF_UP) 419 if_down(ifp); 420 clear_flags = 1; 421 } 422 ifnet_serialize_all(ifp); 423 tapifstop(tp, clear_flags); 424 ifnet_deserialize_all(ifp); 425 426 if ((tp->tap_flags & TAP_CLONE) == 0) { 427 if_purgeaddrs_nolink(ifp); 428 429 EVENTHANDLER_INVOKE(ifnet_detach_event, ifp); 430 431 /* Announce the departure of the interface. */ 432 rt_ifannouncemsg(ifp, IFAN_DEPARTURE); 433 } 434 435 funsetown(&tp->tap_sigio); 436 tp->tap_sigio = NULL; 437 KNOTE(&tp->tap_rkq.ki_note, 0); 438 439 tp->tap_flags &= ~TAP_OPEN; 440 funsetown(&tp->tap_sigtd); 441 tp->tap_sigtd = NULL; 442 443 taprefcnt --; 444 if (taprefcnt < 0) { 445 taprefcnt = 0; 446 if_printf(ifp, "minor = %#x, refcnt = %d is out of sync. " 447 "set refcnt to 0\n", minor(tp->tap_dev), taprefcnt); 448 } 449 450 TAPDEBUG(ifp, "closed. minor = %#x, refcnt = %d, taplastunit = %d\n", 451 minor(tp->tap_dev), taprefcnt, taplastunit); 452 453 if (tp->tap_unit >= TAP_PREALLOCATED_UNITS) 454 tapdestroy(tp); 455 456 rel_mplock(); 457 return (0); 458 } 459 460 /* 461 * tapdestroy: 462 * 463 * Destroy a tap instance. 464 */ 465 static void 466 tapdestroy(struct tap_softc *tp) 467 { 468 struct ifnet *ifp = &tp->arpcom.ac_if; 469 cdev_t dev; 470 471 TAPDEBUG(ifp, "destroyed. minor = %#x, refcnt = %d, taplastunit = %d\n", 472 minor(tp->tap_dev), taprefcnt, taplastunit); 473 474 ifnet_serialize_all(ifp); 475 tapifstop(tp, 1); 476 ifnet_deserialize_all(ifp); 477 478 ether_ifdetach(ifp); 479 SLIST_REMOVE(&tap_listhead, tp, tap_softc, tap_link); 480 481 dev = tp->tap_dev; 482 tp->tap_dev = NULL; 483 dev->si_drv1 = NULL; 484 485 release_dev(dev); /* tp association */ 486 487 /* 488 * Also destroy the cloned device 489 */ 490 if (tp->tap_unit >= TAP_PREALLOCATED_UNITS) { 491 destroy_dev(dev); 492 devfs_clone_bitmap_put(&DEVFS_CLONE_BITMAP(tap), tp->tap_unit); 493 } 494 495 kfree(tp, M_TAP); 496 497 taplastunit--; 498 } 499 500 /* 501 * tap_clone_destroy: 502 * 503 * Destroy a tap instance. 504 */ 505 static int 506 tap_clone_destroy(struct ifnet *ifp) 507 { 508 struct tap_softc *tp = ifp->if_softc; 509 510 if ((tp->tap_flags & TAP_CLONE) == 0) 511 return ENXIO; 512 513 TAPDEBUG(&tp->tap_if, "clone destroyed. minor = %#x tap_flags = 0x%x\n", 514 minor(tp->tap_dev), tp->tap_flags); 515 tapdestroy(tp); 516 517 return 0; 518 } 519 520 /* 521 * tapifinit 522 * 523 * Network interface initialization function (called with if serializer held) 524 * 525 * MPSAFE 526 */ 527 static void 528 tapifinit(void *xtp) 529 { 530 struct tap_softc *tp = xtp; 531 struct ifnet *ifp = &tp->tap_if; 532 struct ifaltq_subque *ifsq = ifq_get_subq_default(&ifp->if_snd); 533 534 TAPDEBUG(ifp, "initializing, minor = %#x tap_flags = 0x%x\n", 535 minor(tp->tap_dev), tp->tap_flags); 536 537 ASSERT_IFNET_SERIALIZED_ALL(ifp); 538 539 tapifstop(tp, 1); 540 541 ifp->if_flags |= IFF_RUNNING; 542 ifsq_clr_oactive(ifsq); 543 544 /* attempt to start output */ 545 tapifstart(ifp, ifsq); 546 } 547 548 549 /* 550 * tapifioctl 551 * 552 * Process an ioctl request on network interface (called with if serializer 553 * held). 554 * 555 * MPSAFE 556 */ 557 static int 558 tapifioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr) 559 { 560 struct tap_softc *tp = (struct tap_softc *)(ifp->if_softc); 561 struct ifstat *ifs = NULL; 562 struct ifmediareq *ifmr = NULL; 563 int error = 0; 564 int dummy; 565 566 switch (cmd) { 567 case SIOCSIFADDR: 568 case SIOCGIFADDR: 569 case SIOCSIFMTU: 570 error = ether_ioctl(ifp, cmd, data); 571 break; 572 573 case SIOCSIFFLAGS: 574 tapifflags(tp); 575 break; 576 577 case SIOCADDMULTI: /* XXX -- just like vmnet does */ 578 case SIOCDELMULTI: 579 break; 580 581 case SIOCGIFMEDIA: 582 /* 583 * The bridge code needs this when running the 584 * spanning tree protocol. 585 */ 586 ifmr = (struct ifmediareq *)data; 587 dummy = ifmr->ifm_count; 588 ifmr->ifm_count = 1; 589 ifmr->ifm_status = IFM_AVALID; 590 ifmr->ifm_active = IFM_ETHER; 591 if (tp->tap_flags & TAP_OPEN) 592 ifmr->ifm_status |= IFM_ACTIVE; 593 ifmr->ifm_current = ifmr->ifm_active; 594 if (dummy >= 1) { 595 int media = IFM_ETHER; 596 error = copyout(&media, 597 ifmr->ifm_ulist, 598 sizeof(int)); 599 } 600 break; 601 602 case SIOCGIFSTATUS: 603 ifs = (struct ifstat *)data; 604 dummy = strlen(ifs->ascii); 605 if ((tp->tap_flags & TAP_OPEN) && 606 dummy < sizeof(ifs->ascii)) { 607 if (tp->tap_sigtd && tp->tap_sigtd->sio_proc) { 608 ksnprintf(ifs->ascii + dummy, 609 sizeof(ifs->ascii) - dummy, 610 "\tOpened by pid %d\n", 611 (int)tp->tap_sigtd->sio_proc->p_pid); 612 } else { 613 ksnprintf(ifs->ascii + dummy, 614 sizeof(ifs->ascii) - dummy, 615 "\tOpened by <unknown>\n"); 616 } 617 } 618 break; 619 620 default: 621 error = EINVAL; 622 break; 623 } 624 625 return (error); 626 } 627 628 629 /* 630 * tapifstart 631 * 632 * Queue packets from higher level ready to put out (called with if serializer 633 * held) 634 * 635 * MPSAFE 636 */ 637 static void 638 tapifstart(struct ifnet *ifp, struct ifaltq_subque *ifsq) 639 { 640 struct tap_softc *tp = ifp->if_softc; 641 struct ifqueue *ifq; 642 struct mbuf *m; 643 int has_data = 0; 644 645 ASSERT_ALTQ_SQ_DEFAULT(ifp, ifsq); 646 TAPDEBUG(ifp, "starting, minor = %#x\n", minor(tp->tap_dev)); 647 648 /* 649 * do not junk pending output if we are in VMnet mode. 650 * XXX: can this do any harm because of queue overflow? 651 */ 652 653 if (((tp->tap_flags & TAP_VMNET) == 0) && 654 ((tp->tap_flags & TAP_READY) != TAP_READY)) { 655 TAPDEBUG(ifp, "not ready. minor = %#x, tap_flags = 0x%x\n", 656 minor(tp->tap_dev), tp->tap_flags); 657 ifsq_purge(ifsq); 658 return; 659 } 660 661 ifsq_set_oactive(ifsq); 662 663 ifq = &tp->tap_devq; 664 while ((m = ifsq_dequeue(ifsq, NULL)) != NULL) { 665 if (IF_QFULL(ifq)) { 666 IF_DROP(ifq); 667 ifp->if_oerrors++; 668 m_freem(m); 669 } else { 670 IF_ENQUEUE(ifq, m); 671 ifp->if_opackets++; 672 has_data = 1; 673 } 674 } 675 676 if (has_data) { 677 if (tp->tap_flags & TAP_RWAIT) { 678 tp->tap_flags &= ~TAP_RWAIT; 679 wakeup((caddr_t)tp); 680 } 681 682 KNOTE(&tp->tap_rkq.ki_note, 0); 683 684 if ((tp->tap_flags & TAP_ASYNC) && (tp->tap_sigio != NULL)) { 685 get_mplock(); 686 pgsigio(tp->tap_sigio, SIGIO, 0); 687 rel_mplock(); 688 } 689 } 690 691 ifsq_clr_oactive(ifsq); 692 } 693 694 695 /* 696 * tapioctl 697 * 698 * The ops interface is now pretty minimal. Called via fileops with nothing 699 * held. 700 * 701 * MPSAFE 702 */ 703 static int 704 tapioctl(struct dev_ioctl_args *ap) 705 { 706 cdev_t dev = ap->a_head.a_dev; 707 caddr_t data = ap->a_data; 708 struct tap_softc *tp = dev->si_drv1; 709 struct ifnet *ifp = &tp->tap_if; 710 struct tapinfo *tapp = NULL; 711 struct mbuf *mb; 712 short f; 713 int error; 714 715 ifnet_serialize_all(ifp); 716 error = 0; 717 718 switch (ap->a_cmd) { 719 case TAPSIFINFO: 720 tapp = (struct tapinfo *)data; 721 ifp->if_mtu = tapp->mtu; 722 ifp->if_type = tapp->type; 723 ifp->if_baudrate = tapp->baudrate; 724 break; 725 726 case TAPGIFINFO: 727 tapp = (struct tapinfo *)data; 728 tapp->mtu = ifp->if_mtu; 729 tapp->type = ifp->if_type; 730 tapp->baudrate = ifp->if_baudrate; 731 break; 732 733 case TAPSDEBUG: 734 tapdebug = *(int *)data; 735 break; 736 737 case TAPGDEBUG: 738 *(int *)data = tapdebug; 739 break; 740 741 case FIOASYNC: 742 if (*(int *)data) 743 tp->tap_flags |= TAP_ASYNC; 744 else 745 tp->tap_flags &= ~TAP_ASYNC; 746 break; 747 748 case FIONREAD: 749 *(int *)data = 0; 750 751 /* Take a look at devq first */ 752 IF_POLL(&tp->tap_devq, mb); 753 if (mb == NULL) 754 mb = ifsq_poll(ifq_get_subq_default(&ifp->if_snd)); 755 756 if (mb != NULL) { 757 for(; mb != NULL; mb = mb->m_next) 758 *(int *)data += mb->m_len; 759 } 760 break; 761 762 case FIOSETOWN: 763 error = fsetown(*(int *)data, &tp->tap_sigio); 764 break; 765 766 case FIOGETOWN: 767 *(int *)data = fgetown(&tp->tap_sigio); 768 break; 769 770 /* this is deprecated, FIOSETOWN should be used instead */ 771 case TIOCSPGRP: 772 error = fsetown(-(*(int *)data), &tp->tap_sigio); 773 break; 774 775 /* this is deprecated, FIOGETOWN should be used instead */ 776 case TIOCGPGRP: 777 *(int *)data = -fgetown(&tp->tap_sigio); 778 break; 779 780 /* VMware/VMnet port ioctl's */ 781 782 case SIOCGIFFLAGS: /* get ifnet flags */ 783 bcopy(&ifp->if_flags, data, sizeof(ifp->if_flags)); 784 break; 785 786 case VMIO_SIOCSIFFLAGS: /* VMware/VMnet SIOCSIFFLAGS */ 787 f = *(short *)data; 788 f &= 0x0fff; 789 f &= ~IFF_CANTCHANGE; 790 f |= IFF_UP; 791 ifp->if_flags = f | (ifp->if_flags & IFF_CANTCHANGE); 792 break; 793 794 case OSIOCGIFADDR: /* get MAC address of the remote side */ 795 case SIOCGIFADDR: 796 bcopy(tp->ether_addr, data, sizeof(tp->ether_addr)); 797 break; 798 799 case SIOCSIFADDR: /* set MAC address of the remote side */ 800 bcopy(data, tp->ether_addr, sizeof(tp->ether_addr)); 801 break; 802 803 default: 804 error = ENOTTY; 805 break; 806 } 807 ifnet_deserialize_all(ifp); 808 return (error); 809 } 810 811 812 /* 813 * tapread 814 * 815 * The ops read interface - reads a packet at a time, or at 816 * least as much of a packet as can be read. 817 * 818 * Called from the fileops interface with nothing held. 819 * 820 * MPSAFE 821 */ 822 static int 823 tapread(struct dev_read_args *ap) 824 { 825 cdev_t dev = ap->a_head.a_dev; 826 struct uio *uio = ap->a_uio; 827 struct tap_softc *tp = dev->si_drv1; 828 struct ifnet *ifp = &tp->tap_if; 829 struct mbuf *m0 = NULL; 830 int error = 0, len; 831 832 TAPDEBUG(ifp, "reading, minor = %#x\n", minor(tp->tap_dev)); 833 834 if ((tp->tap_flags & TAP_READY) != TAP_READY) { 835 TAPDEBUG(ifp, "not ready. minor = %#x, tap_flags = 0x%x\n", 836 minor(tp->tap_dev), tp->tap_flags); 837 838 return (EHOSTDOWN); 839 } 840 841 tp->tap_flags &= ~TAP_RWAIT; 842 843 /* sleep until we get a packet */ 844 do { 845 ifnet_serialize_all(ifp); 846 IF_DEQUEUE(&tp->tap_devq, m0); 847 if (m0 == NULL) { 848 if (ap->a_ioflag & IO_NDELAY) { 849 ifnet_deserialize_all(ifp); 850 return (EWOULDBLOCK); 851 } 852 tp->tap_flags |= TAP_RWAIT; 853 tsleep_interlock(tp, PCATCH); 854 ifnet_deserialize_all(ifp); 855 error = tsleep(tp, PCATCH | PINTERLOCKED, "taprd", 0); 856 if (error) 857 return (error); 858 } else { 859 ifnet_deserialize_all(ifp); 860 } 861 } while (m0 == NULL); 862 863 BPF_MTAP(ifp, m0); 864 865 /* xfer packet to user space */ 866 while ((m0 != NULL) && (uio->uio_resid > 0) && (error == 0)) { 867 len = (int)szmin(uio->uio_resid, m0->m_len); 868 if (len == 0) 869 break; 870 871 error = uiomove(mtod(m0, caddr_t), (size_t)len, uio); 872 m0 = m_free(m0); 873 } 874 875 if (m0 != NULL) { 876 TAPDEBUG(ifp, "dropping mbuf, minor = %#x\n", 877 minor(tp->tap_dev)); 878 m_freem(m0); 879 } 880 881 return (error); 882 } 883 884 /* 885 * tapwrite 886 * 887 * The ops write interface - an atomic write is a packet - or else! 888 * 889 * Called from the fileops interface with nothing held. 890 * 891 * MPSAFE 892 */ 893 static int 894 tapwrite(struct dev_write_args *ap) 895 { 896 cdev_t dev = ap->a_head.a_dev; 897 struct uio *uio = ap->a_uio; 898 struct tap_softc *tp = dev->si_drv1; 899 struct ifnet *ifp = &tp->tap_if; 900 struct mbuf *top = NULL, **mp = NULL, *m = NULL; 901 int error; 902 size_t tlen, mlen; 903 904 TAPDEBUG(ifp, "writing, minor = %#x\n", minor(tp->tap_dev)); 905 906 if ((tp->tap_flags & TAP_READY) != TAP_READY) { 907 TAPDEBUG(ifp, "not ready. minor = %#x, tap_flags = 0x%x\n", 908 minor(tp->tap_dev), tp->tap_flags); 909 return (EHOSTDOWN); 910 } 911 912 if (uio->uio_resid == 0) 913 return (0); 914 915 if (uio->uio_resid > TAPMRU) { 916 TAPDEBUG(ifp, "invalid packet len = %zu, minor = %#x\n", 917 uio->uio_resid, minor(tp->tap_dev)); 918 919 return (EIO); 920 } 921 tlen = uio->uio_resid; 922 923 /* get a header mbuf */ 924 MGETHDR(m, MB_WAIT, MT_DATA); 925 if (m == NULL) 926 return (ENOBUFS); 927 mlen = MHLEN; 928 929 top = NULL; 930 mp = ⊤ 931 error = 0; 932 933 while (error == 0 && uio->uio_resid > 0) { 934 m->m_len = (int)szmin(mlen, uio->uio_resid); 935 error = uiomove(mtod(m, caddr_t), (size_t)m->m_len, uio); 936 *mp = m; 937 mp = &m->m_next; 938 if (uio->uio_resid > 0) { 939 MGET(m, MB_WAIT, MT_DATA); 940 if (m == NULL) { 941 error = ENOBUFS; 942 break; 943 } 944 mlen = MLEN; 945 } 946 } 947 if (error) { 948 ifp->if_ierrors ++; 949 if (top) 950 m_freem(top); 951 return (error); 952 } 953 954 top->m_pkthdr.len = (int)tlen; 955 top->m_pkthdr.rcvif = ifp; 956 957 /* 958 * Ethernet bridge and bpf are handled in ether_input 959 * 960 * adjust mbuf and give packet to the ether_input 961 */ 962 ifnet_serialize_all(ifp); 963 ifp->if_input(ifp, top); 964 ifp->if_ipackets ++; /* ibytes are counted in ether_input */ 965 ifnet_deserialize_all(ifp); 966 967 return (0); 968 } 969 970 /* 971 * tapkqfilter - called from the fileops interface with nothing held 972 * 973 * MPSAFE 974 */ 975 static int filt_tapread(struct knote *kn, long hint); 976 static int filt_tapwrite(struct knote *kn, long hint); 977 static void filt_tapdetach(struct knote *kn); 978 static struct filterops tapread_filtops = 979 { FILTEROP_ISFD, NULL, filt_tapdetach, filt_tapread }; 980 static struct filterops tapwrite_filtops = 981 { FILTEROP_ISFD, NULL, filt_tapdetach, filt_tapwrite }; 982 983 static int 984 tapkqfilter(struct dev_kqfilter_args *ap) 985 { 986 cdev_t dev = ap->a_head.a_dev; 987 struct knote *kn = ap->a_kn; 988 struct tap_softc *tp; 989 struct klist *list; 990 991 tp = dev->si_drv1; 992 list = &tp->tap_rkq.ki_note; 993 ap->a_result =0; 994 995 switch(kn->kn_filter) { 996 case EVFILT_READ: 997 kn->kn_fop = &tapread_filtops; 998 kn->kn_hook = (void *)tp; 999 break; 1000 case EVFILT_WRITE: 1001 kn->kn_fop = &tapwrite_filtops; 1002 kn->kn_hook = (void *)tp; 1003 break; 1004 default: 1005 ap->a_result = EOPNOTSUPP; 1006 return(0); 1007 } 1008 1009 knote_insert(list, kn); 1010 return(0); 1011 } 1012 1013 static int 1014 filt_tapread(struct knote *kn, long hint) 1015 { 1016 struct tap_softc *tp = (void *)kn->kn_hook; 1017 1018 if (IF_QEMPTY(&tp->tap_devq) == 0) /* XXX serializer */ 1019 return(1); 1020 else 1021 return(0); 1022 } 1023 1024 static int 1025 filt_tapwrite(struct knote *kn, long hint) 1026 { 1027 /* Always ready for a write */ 1028 return (1); 1029 } 1030 1031 static void 1032 filt_tapdetach(struct knote *kn) 1033 { 1034 struct tap_softc *tp = (void *)kn->kn_hook; 1035 1036 knote_remove(&tp->tap_rkq.ki_note, kn); 1037 } 1038 1039 static void 1040 tapifstop(struct tap_softc *tp, int clear_flags) 1041 { 1042 struct ifnet *ifp = &tp->tap_if; 1043 1044 ASSERT_IFNET_SERIALIZED_ALL(ifp); 1045 IF_DRAIN(&tp->tap_devq); 1046 tp->tap_flags &= ~TAP_CLOSEDOWN; 1047 if (clear_flags) { 1048 ifp->if_flags &= ~IFF_RUNNING; 1049 ifsq_clr_oactive(ifq_get_subq_default(&ifp->if_snd)); 1050 } 1051 } 1052 1053 static void 1054 tapifflags(struct tap_softc *tp) 1055 { 1056 struct ifnet *ifp = &tp->arpcom.ac_if; 1057 1058 ASSERT_IFNET_SERIALIZED_ALL(ifp); 1059 if ((tp->tap_flags & TAP_VMNET) == 0) { 1060 /* 1061 * Only for non-vmnet tap(4) 1062 */ 1063 if (ifp->if_flags & IFF_UP) { 1064 if ((ifp->if_flags & IFF_RUNNING) == 0) 1065 tapifinit(tp); 1066 } else { 1067 tapifstop(tp, 1); 1068 } 1069 } else { 1070 /* XXX */ 1071 } 1072 } 1073