1/* 2 * Copyright (c) 2003-2014 Apple Inc. All rights reserved. 3 * 4 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ 5 * 6 * This file contains Original Code and/or Modifications of Original Code 7 * as defined in and that are subject to the Apple Public Source License 8 * Version 2.0 (the 'License'). You may not use this file except in 9 * compliance with the License. The rights granted to you under the License 10 * may not be used to create, or enable the creation or redistribution of, 11 * unlawful or unlicensed copies of an Apple operating system, or to 12 * circumvent, violate, or enable the circumvention or violation of, any 13 * terms of an Apple operating system software license agreement. 14 * 15 * Please obtain a copy of the License at 16 * http://www.opensource.apple.com/apsl/ and read it before using this file. 17 * 18 * The Original Code and all software distributed under the License are 19 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 20 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 21 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 22 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 23 * Please see the License for the specific language governing rights and 24 * limitations under the License. 25 * 26 * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ 27 */ 28/* 29 * Copyright 1998 Massachusetts Institute of Technology 30 * 31 * Permission to use, copy, modify, and distribute this software and 32 * its documentation for any purpose and without fee is hereby 33 * granted, provided that both the above copyright notice and this 34 * permission notice appear in all copies, that both the above 35 * copyright notice and this permission notice appear in all 36 * supporting documentation, and that the name of M.I.T. not be used 37 * in advertising or publicity pertaining to distribution of the 38 * software without specific, written prior permission. M.I.T. makes 39 * no representations about the suitability of this software for any 40 * purpose. It is provided "as is" without express or implied 41 * warranty. 42 * 43 * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS 44 * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE, 45 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 46 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 47 * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 50 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 51 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 52 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 53 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 54 * SUCH DAMAGE. 55 * 56 * $FreeBSD: src/sys/net/if_vlan.c,v 1.54 2003/10/31 18:32:08 brooks Exp $ 57 */ 58 59/* 60 * if_vlan.c - pseudo-device driver for IEEE 802.1Q virtual LANs. 61 * Might be extended some day to also handle IEEE 802.1p priority 62 * tagging. This is sort of sneaky in the implementation, since 63 * we need to pretend to be enough of an Ethernet implementation 64 * to make arp work. The way we do this is by telling everyone 65 * that we are an Ethernet, and then catch the packets that 66 * ether_output() left on our output queue when it calls 67 * if_start(), rewrite them for use by the real outgoing interface, 68 * and ask it to send them. 69 */ 70 71 72#include <sys/param.h> 73#include <sys/kernel.h> 74#include <sys/malloc.h> 75#include <sys/mbuf.h> 76#include <sys/queue.h> 77#include <sys/socket.h> 78#include <sys/sockio.h> 79#include <sys/sysctl.h> 80#include <sys/systm.h> 81#include <sys/kern_event.h> 82#include <sys/mcache.h> 83 84#include <net/bpf.h> 85#include <net/ethernet.h> 86#include <net/if.h> 87#include <net/if_arp.h> 88#include <net/if_dl.h> 89#include <net/if_ether.h> 90#include <net/if_types.h> 91#include <net/if_vlan_var.h> 92#include <libkern/OSAtomic.h> 93 94#include <net/dlil.h> 95 96#include <net/kpi_interface.h> 97#include <net/kpi_protocol.h> 98 99#include <kern/locks.h> 100 101#ifdef INET 102#include <netinet/in.h> 103#include <netinet/if_ether.h> 104#endif 105 106#include <net/if_media.h> 107#include <net/multicast_list.h> 108#include <net/ether_if_module.h> 109 110#define VLANNAME "vlan" 111 112typedef int (bpf_callback_func)(struct ifnet *, struct mbuf *); 113typedef int (if_set_bpf_tap_func)(struct ifnet *ifp, int mode, bpf_callback_func * func); 114 115/** 116 ** vlan locks 117 **/ 118static __inline__ lck_grp_t * 119my_lck_grp_alloc_init(const char * grp_name) 120{ 121 lck_grp_t * grp; 122 lck_grp_attr_t * grp_attrs; 123 124 grp_attrs = lck_grp_attr_alloc_init(); 125 grp = lck_grp_alloc_init(grp_name, grp_attrs); 126 lck_grp_attr_free(grp_attrs); 127 return (grp); 128} 129 130static __inline__ lck_mtx_t * 131my_lck_mtx_alloc_init(lck_grp_t * lck_grp) 132{ 133 lck_attr_t * lck_attrs; 134 lck_mtx_t * lck_mtx; 135 136 lck_attrs = lck_attr_alloc_init(); 137 lck_mtx = lck_mtx_alloc_init(lck_grp, lck_attrs); 138 lck_attr_free(lck_attrs); 139 return (lck_mtx); 140} 141 142static lck_mtx_t * vlan_lck_mtx; 143 144static __inline__ void 145vlan_lock_init(void) 146{ 147 lck_grp_t * vlan_lck_grp; 148 149 vlan_lck_grp = my_lck_grp_alloc_init("if_vlan"); 150 vlan_lck_mtx = my_lck_mtx_alloc_init(vlan_lck_grp); 151} 152 153static __inline__ void 154vlan_assert_lock_held(void) 155{ 156 lck_mtx_assert(vlan_lck_mtx, LCK_MTX_ASSERT_OWNED); 157 return; 158} 159 160static __inline__ void 161vlan_assert_lock_not_held(void) 162{ 163 lck_mtx_assert(vlan_lck_mtx, LCK_MTX_ASSERT_NOTOWNED); 164 return; 165} 166 167static __inline__ void 168vlan_lock(void) 169{ 170 lck_mtx_lock(vlan_lck_mtx); 171 return; 172} 173 174static __inline__ void 175vlan_unlock(void) 176{ 177 lck_mtx_unlock(vlan_lck_mtx); 178 return; 179} 180 181/** 182 ** vlan structures, types 183 **/ 184struct vlan_parent; 185LIST_HEAD(vlan_parent_list, vlan_parent); 186struct ifvlan; 187LIST_HEAD(ifvlan_list, ifvlan); 188 189typedef LIST_ENTRY(vlan_parent) 190vlan_parent_entry; 191typedef LIST_ENTRY(ifvlan) 192ifvlan_entry; 193 194#define VLP_SIGNATURE 0xfaceface 195typedef struct vlan_parent { 196 vlan_parent_entry vlp_parent_list;/* list of parents */ 197 struct ifnet * vlp_ifp; /* interface */ 198 struct ifvlan_list vlp_vlan_list; /* list of VLAN's */ 199#define VLPF_SUPPORTS_VLAN_MTU 0x00000001 200#define VLPF_CHANGE_IN_PROGRESS 0x00000002 201#define VLPF_DETACHING 0x00000004 202#define VLPF_LINK_EVENT_REQUIRED 0x00000008 203 u_int32_t vlp_flags; 204 u_int32_t vlp_event_code; 205 struct ifdevmtu vlp_devmtu; 206 int32_t vlp_retain_count; 207 u_int32_t vlp_signature; /* VLP_SIGNATURE */ 208} vlan_parent, * vlan_parent_ref; 209 210#define IFV_SIGNATURE 0xbeefbeef 211struct ifvlan { 212 ifvlan_entry ifv_vlan_list; 213 char ifv_name[IFNAMSIZ]; /* our unique id */ 214 struct ifnet * ifv_ifp; /* our interface */ 215 vlan_parent_ref ifv_vlp; /* parent information */ 216 struct ifv_linkmib { 217 u_int16_t ifvm_encaplen;/* encapsulation length */ 218 u_int16_t ifvm_mtufudge;/* MTU fudged by this much */ 219 u_int16_t ifvm_proto; /* encapsulation ethertype */ 220 u_int16_t ifvm_tag; /* tag to apply on packets leaving if */ 221 } ifv_mib; 222 struct multicast_list ifv_multicast; 223#define IFVF_PROMISC 0x1 /* promiscuous mode enabled */ 224#define IFVF_DETACHING 0x2 /* interface is detaching */ 225#define IFVF_READY 0x4 /* interface is ready */ 226 u_int32_t ifv_flags; 227 bpf_packet_func ifv_bpf_input; 228 bpf_packet_func ifv_bpf_output; 229 int32_t ifv_retain_count; 230 u_int32_t ifv_signature; /* IFV_SIGNATURE */ 231}; 232 233typedef struct ifvlan * ifvlan_ref; 234 235typedef struct vlan_globals_s { 236 struct vlan_parent_list parent_list; 237 int verbose; 238} * vlan_globals_ref; 239 240static vlan_globals_ref g_vlan; 241 242#define ifv_tag ifv_mib.ifvm_tag 243#define ifv_encaplen ifv_mib.ifvm_encaplen 244#define ifv_mtufudge ifv_mib.ifvm_mtufudge 245 246static void 247vlan_parent_retain(vlan_parent_ref vlp); 248 249static void 250vlan_parent_release(vlan_parent_ref vlp); 251 252/** 253 ** vlan_parent_ref vlp_flags in-lines 254 **/ 255static __inline__ int 256vlan_parent_flags_supports_vlan_mtu(vlan_parent_ref vlp) 257{ 258 return ((vlp->vlp_flags & VLPF_SUPPORTS_VLAN_MTU) != 0); 259} 260 261static __inline__ void 262vlan_parent_flags_set_supports_vlan_mtu(vlan_parent_ref vlp) 263{ 264 vlp->vlp_flags |= VLPF_SUPPORTS_VLAN_MTU; 265 return; 266} 267 268static __inline__ int 269vlan_parent_flags_change_in_progress(vlan_parent_ref vlp) 270{ 271 return ((vlp->vlp_flags & VLPF_CHANGE_IN_PROGRESS) != 0); 272} 273 274static __inline__ void 275vlan_parent_flags_set_change_in_progress(vlan_parent_ref vlp) 276{ 277 vlp->vlp_flags |= VLPF_CHANGE_IN_PROGRESS; 278 return; 279} 280 281static __inline__ void 282vlan_parent_flags_clear_change_in_progress(vlan_parent_ref vlp) 283{ 284 vlp->vlp_flags &= ~VLPF_CHANGE_IN_PROGRESS; 285 return; 286} 287 288static __inline__ int 289vlan_parent_flags_detaching(struct vlan_parent * vlp) 290{ 291 return ((vlp->vlp_flags & VLPF_DETACHING) != 0); 292} 293 294static __inline__ void 295vlan_parent_flags_set_detaching(struct vlan_parent * vlp) 296{ 297 vlp->vlp_flags |= VLPF_DETACHING; 298 return; 299} 300 301static __inline__ int 302vlan_parent_flags_link_event_required(vlan_parent_ref vlp) 303{ 304 return ((vlp->vlp_flags & VLPF_LINK_EVENT_REQUIRED) != 0); 305} 306 307static __inline__ void 308vlan_parent_flags_set_link_event_required(vlan_parent_ref vlp) 309{ 310 vlp->vlp_flags |= VLPF_LINK_EVENT_REQUIRED; 311 return; 312} 313 314static __inline__ void 315vlan_parent_flags_clear_link_event_required(vlan_parent_ref vlp) 316{ 317 vlp->vlp_flags &= ~VLPF_LINK_EVENT_REQUIRED; 318 return; 319} 320 321 322/** 323 ** ifvlan_flags in-lines routines 324 **/ 325static __inline__ int 326ifvlan_flags_promisc(ifvlan_ref ifv) 327{ 328 return ((ifv->ifv_flags & IFVF_PROMISC) != 0); 329} 330 331static __inline__ void 332ifvlan_flags_set_promisc(ifvlan_ref ifv) 333{ 334 ifv->ifv_flags |= IFVF_PROMISC; 335 return; 336} 337 338static __inline__ void 339ifvlan_flags_clear_promisc(ifvlan_ref ifv) 340{ 341 ifv->ifv_flags &= ~IFVF_PROMISC; 342 return; 343} 344 345static __inline__ int 346ifvlan_flags_ready(ifvlan_ref ifv) 347{ 348 return ((ifv->ifv_flags & IFVF_READY) != 0); 349} 350 351static __inline__ void 352ifvlan_flags_set_ready(ifvlan_ref ifv) 353{ 354 ifv->ifv_flags |= IFVF_READY; 355 return; 356} 357 358static __inline__ int 359ifvlan_flags_detaching(ifvlan_ref ifv) 360{ 361 return ((ifv->ifv_flags & IFVF_DETACHING) != 0); 362} 363 364static __inline__ void 365ifvlan_flags_set_detaching(ifvlan_ref ifv) 366{ 367 ifv->ifv_flags |= IFVF_DETACHING; 368 return; 369} 370 371#if 0 372SYSCTL_DECL(_net_link); 373SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "IEEE 802.1Q VLAN"); 374SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW|CTLFLAG_LOCKED, 0, "for consistency"); 375#endif 376 377#define M_VLAN M_DEVBUF 378 379static int vlan_clone_create(struct if_clone *, u_int32_t, void *); 380static int vlan_clone_destroy(struct ifnet *); 381static int vlan_input(ifnet_t ifp, protocol_family_t protocol, 382 mbuf_t m, char *frame_header); 383static int vlan_output(struct ifnet *ifp, struct mbuf *m); 384static int vlan_ioctl(ifnet_t ifp, u_long cmd, void * addr); 385static int vlan_set_bpf_tap(ifnet_t ifp, bpf_tap_mode mode, 386 bpf_packet_func func); 387static int vlan_attach_protocol(struct ifnet *ifp); 388static int vlan_detach_protocol(struct ifnet *ifp); 389static int vlan_setmulti(struct ifnet *ifp); 390static int vlan_unconfig(ifvlan_ref ifv, int need_to_wait); 391static int vlan_config(struct ifnet * ifp, struct ifnet * p, int tag); 392static void vlan_if_free(struct ifnet * ifp); 393static int vlan_remove(ifvlan_ref ifv, int need_to_wait); 394 395static struct if_clone vlan_cloner = IF_CLONE_INITIALIZER(VLANNAME, 396 vlan_clone_create, 397 vlan_clone_destroy, 398 0, 399 IF_MAXUNIT); 400static void interface_link_event(struct ifnet * ifp, u_int32_t event_code); 401static void vlan_parent_link_event(struct ifnet * p, 402 u_int32_t event_code); 403 404static int ifvlan_new_mtu(ifvlan_ref ifv, int mtu); 405 406/** 407 ** ifvlan_ref routines 408 **/ 409static void 410ifvlan_retain(ifvlan_ref ifv) 411{ 412 if (ifv->ifv_signature != IFV_SIGNATURE) { 413 panic("ifvlan_retain: bad signature\n"); 414 } 415 if (ifv->ifv_retain_count == 0) { 416 panic("ifvlan_retain: retain count is 0\n"); 417 } 418 OSIncrementAtomic(&ifv->ifv_retain_count); 419} 420 421static void 422ifvlan_release(ifvlan_ref ifv) 423{ 424 u_int32_t old_retain_count; 425 426 if (ifv->ifv_signature != IFV_SIGNATURE) { 427 panic("ifvlan_release: bad signature\n"); 428 } 429 old_retain_count = OSDecrementAtomic(&ifv->ifv_retain_count); 430 switch (old_retain_count) { 431 case 0: 432 panic("ifvlan_release: retain count is 0\n"); 433 break; 434 case 1: 435 if (g_vlan->verbose) { 436 printf("ifvlan_release(%s)\n", ifv->ifv_name); 437 } 438 ifv->ifv_signature = 0; 439 FREE(ifv, M_VLAN); 440 break; 441 default: 442 break; 443 } 444 return; 445} 446 447static vlan_parent_ref 448ifvlan_get_vlan_parent_retained(ifvlan_ref ifv) 449{ 450 vlan_parent_ref vlp = ifv->ifv_vlp; 451 452 if (vlp == NULL || vlan_parent_flags_detaching(vlp)) { 453 return (NULL); 454 } 455 vlan_parent_retain(vlp); 456 return (vlp); 457} 458 459/** 460 ** ifnet_* routines 461 **/ 462 463static ifvlan_ref 464ifnet_get_ifvlan(struct ifnet * ifp) 465{ 466 ifvlan_ref ifv; 467 468 ifv = (ifvlan_ref)ifnet_softc(ifp); 469 return (ifv); 470} 471 472static ifvlan_ref 473ifnet_get_ifvlan_retained(struct ifnet * ifp) 474{ 475 ifvlan_ref ifv; 476 477 ifv = ifnet_get_ifvlan(ifp); 478 if (ifv == NULL) { 479 return (NULL); 480 } 481 if (ifvlan_flags_detaching(ifv)) { 482 return (NULL); 483 } 484 ifvlan_retain(ifv); 485 return (ifv); 486} 487 488static int 489ifnet_ifvlan_vlan_parent_ok(struct ifnet * ifp, ifvlan_ref ifv, 490 vlan_parent_ref vlp) 491{ 492 ifvlan_ref check_ifv; 493 494 check_ifv = ifnet_get_ifvlan(ifp); 495 if (check_ifv != ifv || ifvlan_flags_detaching(ifv)) { 496 /* ifvlan_ref no longer valid */ 497 return (FALSE); 498 } 499 if (ifv->ifv_vlp != vlp) { 500 /* vlan_parent no longer valid */ 501 return (FALSE); 502 } 503 if (vlan_parent_flags_detaching(vlp)) { 504 /* parent is detaching */ 505 return (FALSE); 506 } 507 return (TRUE); 508} 509 510/** 511 ** vlan, etc. routines 512 **/ 513 514static int 515vlan_globals_init(void) 516{ 517 vlan_globals_ref v; 518 519 vlan_assert_lock_not_held(); 520 521 if (g_vlan != NULL) { 522 return (0); 523 } 524 v = _MALLOC(sizeof(*v), M_VLAN, M_WAITOK); 525 if (v != NULL) { 526 LIST_INIT(&v->parent_list); 527 v->verbose = 0; 528 } 529 vlan_lock(); 530 if (g_vlan != NULL) { 531 vlan_unlock(); 532 if (v != NULL) { 533 _FREE(v, M_VLAN); 534 } 535 return (0); 536 } 537 g_vlan = v; 538 vlan_unlock(); 539 if (v == NULL) { 540 return (ENOMEM); 541 } 542 return (0); 543} 544 545static int 546siocgifdevmtu(struct ifnet * ifp, struct ifdevmtu * ifdm_p) 547{ 548 struct ifreq ifr; 549 int error; 550 551 bzero(&ifr, sizeof(ifr)); 552 error = ifnet_ioctl(ifp, 0,SIOCGIFDEVMTU, &ifr); 553 if (error == 0) { 554 *ifdm_p = ifr.ifr_devmtu; 555 } 556 return (error); 557} 558 559static int 560siocsifaltmtu(struct ifnet * ifp, int mtu) 561{ 562 struct ifreq ifr; 563 564 bzero(&ifr, sizeof(ifr)); 565 ifr.ifr_mtu = mtu; 566 return (ifnet_ioctl(ifp, 0, SIOCSIFALTMTU, &ifr)); 567} 568 569static __inline__ void 570vlan_bpf_output(struct ifnet * ifp, struct mbuf * m, 571 bpf_packet_func func) 572{ 573 if (func != NULL) { 574 (*func)(ifp, m); 575 } 576 return; 577} 578 579static __inline__ void 580vlan_bpf_input(struct ifnet * ifp, struct mbuf * m, 581 bpf_packet_func func, char * frame_header, 582 int frame_header_len, int encap_len) 583{ 584 if (func != NULL) { 585 if (encap_len > 0) { 586 /* present the right header to bpf */ 587 bcopy(frame_header, frame_header + encap_len, frame_header_len); 588 } 589 m->m_data -= frame_header_len; 590 m->m_len += frame_header_len; 591 (*func)(ifp, m); 592 m->m_data += frame_header_len; 593 m->m_len -= frame_header_len; 594 if (encap_len > 0) { 595 /* restore the header */ 596 bcopy(frame_header + encap_len, frame_header, frame_header_len); 597 } 598 } 599 return; 600} 601 602/** 603 ** vlan_parent synchronization routines 604 **/ 605static void 606vlan_parent_retain(vlan_parent_ref vlp) 607{ 608 if (vlp->vlp_signature != VLP_SIGNATURE) { 609 panic("vlan_parent_retain: signature is bad\n"); 610 } 611 if (vlp->vlp_retain_count == 0) { 612 panic("vlan_parent_retain: retain count is 0\n"); 613 } 614 OSIncrementAtomic(&vlp->vlp_retain_count); 615} 616 617static void 618vlan_parent_release(vlan_parent_ref vlp) 619{ 620 u_int32_t old_retain_count; 621 622 if (vlp->vlp_signature != VLP_SIGNATURE) { 623 panic("vlan_parent_release: signature is bad\n"); 624 } 625 old_retain_count = OSDecrementAtomic(&vlp->vlp_retain_count); 626 switch (old_retain_count) { 627 case 0: 628 panic("vlan_parent_release: retain count is 0\n"); 629 break; 630 case 1: 631 if (g_vlan->verbose) { 632 struct ifnet * ifp = vlp->vlp_ifp; 633 printf("vlan_parent_release(%s%d)\n", ifnet_name(ifp), 634 ifnet_unit(ifp)); 635 } 636 vlp->vlp_signature = 0; 637 FREE(vlp, M_VLAN); 638 break; 639 default: 640 break; 641 } 642 return; 643} 644 645/* 646 * Function: vlan_parent_wait 647 * Purpose: 648 * Allows a single thread to gain exclusive access to the vlan_parent 649 * data structure. Some operations take a long time to complete, 650 * and some have side-effects that we can't predict. Holding the 651 * vlan_lock() across such operations is not possible. 652 * 653 * Notes: 654 * Before calling, you must be holding the vlan_lock and have taken 655 * a reference on the vlan_parent_ref. 656 */ 657static void 658vlan_parent_wait(vlan_parent_ref vlp, const char * msg) 659{ 660 int waited = 0; 661 662 /* other add/remove/multicast-change in progress */ 663 while (vlan_parent_flags_change_in_progress(vlp)) { 664 if (g_vlan->verbose) { 665 struct ifnet * ifp = vlp->vlp_ifp; 666 667 printf("%s%d: %s msleep\n", ifnet_name(ifp), ifnet_unit(ifp), msg); 668 } 669 waited = 1; 670 (void)msleep(vlp, vlan_lck_mtx, PZERO, msg, 0); 671 } 672 /* prevent other vlan parent remove/add from taking place */ 673 vlan_parent_flags_set_change_in_progress(vlp); 674 if (g_vlan->verbose && waited) { 675 struct ifnet * ifp = vlp->vlp_ifp; 676 677 printf("%s%d: %s woke up\n", ifnet_name(ifp), ifnet_unit(ifp), msg); 678 } 679 return; 680} 681 682/* 683 * Function: vlan_parent_signal 684 * Purpose: 685 * Allows the thread that previously invoked vlan_parent_wait() to 686 * give up exclusive access to the vlan_parent data structure, and wake up 687 * any other threads waiting to access 688 * Notes: 689 * Before calling, you must be holding the vlan_lock and have taken 690 * a reference on the vlan_parent_ref. 691 */ 692static void 693vlan_parent_signal(vlan_parent_ref vlp, const char * msg) 694{ 695 struct ifnet * vlp_ifp = vlp->vlp_ifp; 696 697 if (vlan_parent_flags_link_event_required(vlp)) { 698 vlan_parent_flags_clear_link_event_required(vlp); 699 if (!vlan_parent_flags_detaching(vlp)) { 700 u_int32_t event_code = vlp->vlp_event_code; 701 ifvlan_ref ifv; 702 703 vlan_unlock(); 704 705 /* we can safely walk the list unlocked */ 706 LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) { 707 struct ifnet * ifp = ifv->ifv_ifp; 708 709 interface_link_event(ifp, event_code); 710 } 711 if (g_vlan->verbose) { 712 printf("%s%d: propagated link event to vlans\n", 713 ifnet_name(vlp_ifp), ifnet_unit(vlp_ifp)); 714 } 715 vlan_lock(); 716 } 717 } 718 vlan_parent_flags_clear_change_in_progress(vlp); 719 wakeup((caddr_t)vlp); 720 if (g_vlan->verbose) { 721 printf("%s%d: %s wakeup\n", 722 ifnet_name(vlp_ifp), ifnet_unit(vlp_ifp), msg); 723 } 724 return; 725} 726 727/* 728 * Program our multicast filter. What we're actually doing is 729 * programming the multicast filter of the parent. This has the 730 * side effect of causing the parent interface to receive multicast 731 * traffic that it doesn't really want, which ends up being discarded 732 * later by the upper protocol layers. Unfortunately, there's no way 733 * to avoid this: there really is only one physical interface. 734 */ 735static int 736vlan_setmulti(struct ifnet * ifp) 737{ 738 int error = 0; 739 ifvlan_ref ifv; 740 struct ifnet * p; 741 vlan_parent_ref vlp = NULL; 742 743 vlan_lock(); 744 ifv = ifnet_get_ifvlan_retained(ifp); 745 if (ifv == NULL) { 746 goto unlock_done; 747 } 748 vlp = ifvlan_get_vlan_parent_retained(ifv); 749 if (vlp == NULL) { 750 /* no parent, no need to program the multicast filter */ 751 goto unlock_done; 752 } 753 vlan_parent_wait(vlp, "vlan_setmulti"); 754 755 /* check again, things could have changed */ 756 if (ifnet_ifvlan_vlan_parent_ok(ifp, ifv, vlp) == FALSE) { 757 goto signal_done; 758 } 759 p = vlp->vlp_ifp; 760 vlan_unlock(); 761 762 /* update parent interface with our multicast addresses */ 763 error = multicast_list_program(&ifv->ifv_multicast, ifp, p); 764 765 vlan_lock(); 766 767 signal_done: 768 vlan_parent_signal(vlp, "vlan_setmulti"); 769 770 unlock_done: 771 vlan_unlock(); 772 if (ifv != NULL) { 773 ifvlan_release(ifv); 774 } 775 if (vlp != NULL) { 776 vlan_parent_release(vlp); 777 } 778 return (error); 779} 780 781/** 782 ** vlan_parent list manipulation/lookup routines 783 **/ 784static vlan_parent_ref 785parent_list_lookup(struct ifnet * p) 786{ 787 vlan_parent_ref vlp; 788 789 LIST_FOREACH(vlp, &g_vlan->parent_list, vlp_parent_list) { 790 if (vlp->vlp_ifp == p) { 791 return (vlp); 792 } 793 } 794 return (NULL); 795} 796 797static ifvlan_ref 798vlan_parent_lookup_tag(vlan_parent_ref vlp, int tag) 799{ 800 ifvlan_ref ifv; 801 802 LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) { 803 if (tag == ifv->ifv_tag) { 804 return (ifv); 805 } 806 } 807 return (NULL); 808} 809 810static ifvlan_ref 811vlan_lookup_parent_and_tag(struct ifnet * p, int tag) 812{ 813 vlan_parent_ref vlp; 814 815 vlp = parent_list_lookup(p); 816 if (vlp != NULL) { 817 return (vlan_parent_lookup_tag(vlp, tag)); 818 } 819 return (NULL); 820} 821 822static int 823vlan_parent_find_max_mtu(vlan_parent_ref vlp, ifvlan_ref exclude_ifv) 824{ 825 int max_mtu = 0; 826 ifvlan_ref ifv; 827 828 LIST_FOREACH(ifv, &vlp->vlp_vlan_list, ifv_vlan_list) { 829 int req_mtu; 830 831 if (exclude_ifv == ifv) { 832 continue; 833 } 834 req_mtu = ifnet_mtu(ifv->ifv_ifp) + ifv->ifv_mtufudge; 835 if (req_mtu > max_mtu) { 836 max_mtu = req_mtu; 837 } 838 } 839 return (max_mtu); 840} 841 842/* 843 * Function: vlan_parent_create 844 * Purpose: 845 * Create a vlan_parent structure to hold the VLAN's for the given 846 * interface. Add it to the list of VLAN parents. 847 */ 848static int 849vlan_parent_create(struct ifnet * p, vlan_parent_ref * ret_vlp) 850{ 851 int error; 852 vlan_parent_ref vlp; 853 854 *ret_vlp = NULL; 855 vlp = _MALLOC(sizeof(*vlp), M_VLAN, M_WAITOK); 856 if (vlp == NULL) { 857 return (ENOMEM); 858 } 859 bzero(vlp, sizeof(*vlp)); 860 error = siocgifdevmtu(p, &vlp->vlp_devmtu); 861 if (error != 0) { 862 printf("vlan_parent_create (%s%d): siocgifdevmtu failed, %d\n", 863 ifnet_name(p), ifnet_unit(p), error); 864 FREE(vlp, M_VLAN); 865 return (error); 866 } 867 LIST_INIT(&vlp->vlp_vlan_list); 868 vlp->vlp_ifp = p; 869 vlp->vlp_retain_count = 1; 870 vlp->vlp_signature = VLP_SIGNATURE; 871 if (ifnet_offload(p) 872 & (IF_HWASSIST_VLAN_MTU | IF_HWASSIST_VLAN_TAGGING)) { 873 vlan_parent_flags_set_supports_vlan_mtu(vlp); 874 } 875 *ret_vlp = vlp; 876 return (0); 877} 878 879static void 880vlan_parent_remove_all_vlans(struct ifnet * p) 881{ 882 ifvlan_ref ifv; 883 int need_vlp_release = 0; 884 ifvlan_ref next; 885 vlan_parent_ref vlp; 886 887 vlan_lock(); 888 vlp = parent_list_lookup(p); 889 if (vlp == NULL || vlan_parent_flags_detaching(vlp)) { 890 /* no VLAN's */ 891 vlan_unlock(); 892 return; 893 } 894 vlan_parent_flags_set_detaching(vlp); 895 vlan_parent_retain(vlp); 896 vlan_parent_wait(vlp, "vlan_parent_remove_all_vlans"); 897 need_vlp_release++; 898 vlp = parent_list_lookup(p); 899 /* check again */ 900 if (vlp == NULL) { 901 goto signal_done; 902 } 903 904 for (ifv = LIST_FIRST(&vlp->vlp_vlan_list); ifv != NULL; ifv = next) { 905 struct ifnet * ifp = ifv->ifv_ifp; 906 int removed; 907 908 next = LIST_NEXT(ifv, ifv_vlan_list); 909 removed = vlan_remove(ifv, FALSE); 910 if (removed) { 911 vlan_unlock(); 912 ifnet_detach(ifp); 913 vlan_lock(); 914 } 915 } 916 917 /* the vlan parent has no more VLAN's */ 918 ifnet_set_eflags(p, 0, IFEF_VLAN); /* clear IFEF_VLAN */ 919 920 LIST_REMOVE(vlp, vlp_parent_list); 921 need_vlp_release++; /* one for being in the list */ 922 need_vlp_release++; /* final reference */ 923 924 signal_done: 925 vlan_parent_signal(vlp, "vlan_parent_remove_all_vlans"); 926 vlan_unlock(); 927 928 while (need_vlp_release--) { 929 vlan_parent_release(vlp); 930 } 931 return; 932} 933 934static __inline__ int 935vlan_parent_no_vlans(vlan_parent_ref vlp) 936{ 937 return (LIST_EMPTY(&vlp->vlp_vlan_list)); 938} 939 940static void 941vlan_parent_add_vlan(vlan_parent_ref vlp, ifvlan_ref ifv, int tag) 942{ 943 LIST_INSERT_HEAD(&vlp->vlp_vlan_list, ifv, ifv_vlan_list); 944 ifv->ifv_vlp = vlp; 945 ifv->ifv_tag = tag; 946 return; 947} 948 949static void 950vlan_parent_remove_vlan(__unused vlan_parent_ref vlp, ifvlan_ref ifv) 951{ 952 ifv->ifv_vlp = NULL; 953 LIST_REMOVE(ifv, ifv_vlan_list); 954 return; 955} 956 957static int 958vlan_clone_attach(void) 959{ 960 int error; 961 962 error = if_clone_attach(&vlan_cloner); 963 if (error != 0) 964 return error; 965 vlan_lock_init(); 966 return 0; 967} 968 969static int 970vlan_clone_create(struct if_clone *ifc, u_int32_t unit, __unused void *params) 971{ 972 int error; 973 ifvlan_ref ifv; 974 ifnet_t ifp; 975 struct ifnet_init_eparams vlan_init; 976 977 error = vlan_globals_init(); 978 if (error != 0) { 979 return (error); 980 } 981 ifv = _MALLOC(sizeof(struct ifvlan), M_VLAN, M_WAITOK); 982 if (ifv == NULL) 983 return ENOBUFS; 984 bzero(ifv, sizeof(struct ifvlan)); 985 ifv->ifv_retain_count = 1; 986 ifv->ifv_signature = IFV_SIGNATURE; 987 multicast_list_init(&ifv->ifv_multicast); 988 989 /* use the interface name as the unique id for ifp recycle */ 990 if ((unsigned int) 991 snprintf(ifv->ifv_name, sizeof(ifv->ifv_name), "%s%d", 992 ifc->ifc_name, unit) >= sizeof(ifv->ifv_name)) { 993 ifvlan_release(ifv); 994 return (EINVAL); 995 } 996 997 bzero(&vlan_init, sizeof(vlan_init)); 998 vlan_init.ver = IFNET_INIT_CURRENT_VERSION; 999 vlan_init.len = sizeof (vlan_init); 1000 vlan_init.flags = IFNET_INIT_LEGACY; 1001 vlan_init.uniqueid = ifv->ifv_name; 1002 vlan_init.uniqueid_len = strlen(ifv->ifv_name); 1003 vlan_init.name = ifc->ifc_name; 1004 vlan_init.unit = unit; 1005 vlan_init.family = IFNET_FAMILY_VLAN; 1006 vlan_init.type = IFT_L2VLAN; 1007 vlan_init.output = vlan_output; 1008 vlan_init.demux = ether_demux; 1009 vlan_init.add_proto = ether_add_proto; 1010 vlan_init.del_proto = ether_del_proto; 1011 vlan_init.check_multi = ether_check_multi; 1012 vlan_init.framer_extended = ether_frameout_extended; 1013 vlan_init.softc = ifv; 1014 vlan_init.ioctl = vlan_ioctl; 1015 vlan_init.set_bpf_tap = vlan_set_bpf_tap; 1016 vlan_init.detach = vlan_if_free; 1017 vlan_init.broadcast_addr = etherbroadcastaddr; 1018 vlan_init.broadcast_len = ETHER_ADDR_LEN; 1019 error = ifnet_allocate_extended(&vlan_init, &ifp); 1020 1021 if (error) { 1022 ifvlan_release(ifv); 1023 return (error); 1024 } 1025 1026 ifnet_set_offload(ifp, 0); 1027 ifnet_set_addrlen(ifp, ETHER_ADDR_LEN); /* XXX ethernet specific */ 1028 ifnet_set_baudrate(ifp, 0); 1029 ifnet_set_hdrlen(ifp, ETHER_VLAN_ENCAP_LEN); 1030 1031 error = ifnet_attach(ifp, NULL); 1032 if (error) { 1033 ifnet_release(ifp); 1034 ifvlan_release(ifv); 1035 return (error); 1036 } 1037 ifv->ifv_ifp = ifp; 1038 1039 /* attach as ethernet */ 1040 bpfattach(ifp, DLT_EN10MB, sizeof(struct ether_header)); 1041 return (0); 1042} 1043 1044static int 1045vlan_remove(ifvlan_ref ifv, int need_to_wait) 1046{ 1047 vlan_assert_lock_held(); 1048 if (ifvlan_flags_detaching(ifv)) { 1049 return (0); 1050 } 1051 ifvlan_flags_set_detaching(ifv); 1052 vlan_unconfig(ifv, need_to_wait); 1053 return (1); 1054} 1055 1056 1057static int 1058vlan_clone_destroy(struct ifnet *ifp) 1059{ 1060 ifvlan_ref ifv; 1061 1062 vlan_lock(); 1063 ifv = ifnet_get_ifvlan_retained(ifp); 1064 if (ifv == NULL) { 1065 vlan_unlock(); 1066 return 0; 1067 } 1068 if (vlan_remove(ifv, TRUE) == 0) { 1069 vlan_unlock(); 1070 ifvlan_release(ifv); 1071 return 0; 1072 } 1073 vlan_unlock(); 1074 ifvlan_release(ifv); 1075 ifnet_detach(ifp); 1076 1077 return 0; 1078} 1079 1080static int 1081vlan_set_bpf_tap(ifnet_t ifp, bpf_tap_mode mode, bpf_packet_func func) 1082{ 1083 ifvlan_ref ifv; 1084 1085 vlan_lock(); 1086 ifv = ifnet_get_ifvlan_retained(ifp); 1087 if (ifv == NULL) { 1088 vlan_unlock(); 1089 return (ENODEV); 1090 } 1091 switch (mode) { 1092 case BPF_TAP_DISABLE: 1093 ifv->ifv_bpf_input = ifv->ifv_bpf_output = NULL; 1094 break; 1095 1096 case BPF_TAP_INPUT: 1097 ifv->ifv_bpf_input = func; 1098 break; 1099 1100 case BPF_TAP_OUTPUT: 1101 ifv->ifv_bpf_output = func; 1102 break; 1103 1104 case BPF_TAP_INPUT_OUTPUT: 1105 ifv->ifv_bpf_input = ifv->ifv_bpf_output = func; 1106 break; 1107 default: 1108 break; 1109 } 1110 vlan_unlock(); 1111 ifvlan_release(ifv); 1112 return 0; 1113} 1114 1115static int 1116vlan_output(struct ifnet * ifp, struct mbuf * m) 1117{ 1118 bpf_packet_func bpf_func; 1119 struct ether_vlan_header * evl; 1120 int encaplen; 1121 ifvlan_ref ifv; 1122 struct ifnet * p; 1123 int soft_vlan; 1124 u_short tag; 1125 vlan_parent_ref vlp = NULL; 1126 int err; 1127 struct flowadv adv = { FADV_SUCCESS }; 1128 1129 if (m == 0) { 1130 return (0); 1131 } 1132 if ((m->m_flags & M_PKTHDR) == 0) { 1133 m_freem_list(m); 1134 return (0); 1135 } 1136 vlan_lock(); 1137 ifv = ifnet_get_ifvlan_retained(ifp); 1138 if (ifv == NULL || ifvlan_flags_ready(ifv) == 0) { 1139 goto unlock_done; 1140 } 1141 vlp = ifvlan_get_vlan_parent_retained(ifv); 1142 if (vlp == NULL) { 1143 goto unlock_done; 1144 } 1145 p = vlp->vlp_ifp; 1146 (void)ifnet_stat_increment_out(ifp, 1, m->m_pkthdr.len, 0); 1147 soft_vlan = (ifnet_offload(p) & IF_HWASSIST_VLAN_TAGGING) == 0; 1148 bpf_func = ifv->ifv_bpf_output; 1149 tag = ifv->ifv_tag; 1150 encaplen = ifv->ifv_encaplen; 1151 vlan_unlock(); 1152 1153 ifvlan_release(ifv); 1154 vlan_parent_release(vlp); 1155 1156 vlan_bpf_output(ifp, m, bpf_func); 1157 1158 /* do not run parent's if_output() if the parent is not up */ 1159 if ((ifnet_flags(p) & (IFF_UP | IFF_RUNNING)) != (IFF_UP | IFF_RUNNING)) { 1160 m_freem(m); 1161 atomic_add_64(&ifp->if_collisions, 1); 1162 return (0); 1163 } 1164 /* 1165 * If underlying interface can do VLAN tag insertion itself, 1166 * just pass the packet along. However, we need some way to 1167 * tell the interface where the packet came from so that it 1168 * knows how to find the VLAN tag to use. We use a field in 1169 * the mbuf header to store the VLAN tag, and a bit in the 1170 * csum_flags field to mark the field as valid. 1171 */ 1172 if (soft_vlan == 0) { 1173 m->m_pkthdr.csum_flags |= CSUM_VLAN_TAG_VALID; 1174 m->m_pkthdr.vlan_tag = tag; 1175 } else { 1176 M_PREPEND(m, encaplen, M_DONTWAIT); 1177 if (m == NULL) { 1178 printf("%s%d: unable to prepend VLAN header\n", ifnet_name(ifp), 1179 ifnet_unit(ifp)); 1180 atomic_add_64(&ifp->if_oerrors, 1); 1181 return (0); 1182 } 1183 /* M_PREPEND takes care of m_len, m_pkthdr.len for us */ 1184 if (m->m_len < (int)sizeof(*evl)) { 1185 m = m_pullup(m, sizeof(*evl)); 1186 if (m == NULL) { 1187 printf("%s%d: unable to pullup VLAN header\n", ifnet_name(ifp), 1188 ifnet_unit(ifp)); 1189 atomic_add_64(&ifp->if_oerrors, 1); 1190 return (0); 1191 } 1192 } 1193 1194 /* 1195 * Transform the Ethernet header into an Ethernet header 1196 * with 802.1Q encapsulation. 1197 */ 1198 bcopy(mtod(m, char *) + encaplen, 1199 mtod(m, char *), ETHER_HDR_LEN); 1200 evl = mtod(m, struct ether_vlan_header *); 1201 evl->evl_proto = evl->evl_encap_proto; 1202 evl->evl_encap_proto = htons(ETHERTYPE_VLAN); 1203 evl->evl_tag = htons(tag); 1204 } 1205 1206 err = dlil_output(p, PF_VLAN, m, NULL, NULL, 1, &adv); 1207 1208 if (err == 0) { 1209 if (adv.code == FADV_FLOW_CONTROLLED) { 1210 err = EQFULL; 1211 } else if (adv.code == FADV_SUSPENDED) { 1212 err = EQSUSPENDED; 1213 } 1214 } 1215 1216 return (err); 1217 1218 unlock_done: 1219 vlan_unlock(); 1220 if (ifv != NULL) { 1221 ifvlan_release(ifv); 1222 } 1223 if (vlp != NULL) { 1224 vlan_parent_release(vlp); 1225 } 1226 m_freem_list(m); 1227 return (0); 1228 1229} 1230 1231static int 1232vlan_input(ifnet_t p, __unused protocol_family_t protocol, 1233 mbuf_t m, char *frame_header) 1234{ 1235 bpf_packet_func bpf_func = NULL; 1236 struct ether_vlan_header * evl; 1237 struct ifnet * ifp = NULL; 1238 int soft_vlan = 0; 1239 u_int tag = 0; 1240 1241 if (m->m_pkthdr.csum_flags & CSUM_VLAN_TAG_VALID) { 1242 /* 1243 * Packet is tagged, m contains a normal 1244 * Ethernet frame; the tag is stored out-of-band. 1245 */ 1246 m->m_pkthdr.csum_flags &= ~CSUM_VLAN_TAG_VALID; 1247 tag = EVL_VLANOFTAG(m->m_pkthdr.vlan_tag); 1248 m->m_pkthdr.vlan_tag = 0; 1249 } else { 1250 soft_vlan = 1; 1251 switch (ifnet_type(p)) { 1252 case IFT_ETHER: 1253 if (m->m_len < ETHER_VLAN_ENCAP_LEN) { 1254 m_freem(m); 1255 return 0; 1256 } 1257 evl = (struct ether_vlan_header *)(void *)frame_header; 1258 if (ntohs(evl->evl_proto) == ETHERTYPE_VLAN) { 1259 /* don't allow VLAN within VLAN */ 1260 m_freem(m); 1261 return (0); 1262 } 1263 tag = EVL_VLANOFTAG(ntohs(evl->evl_tag)); 1264 1265 /* 1266 * Restore the original ethertype. We'll remove 1267 * the encapsulation after we've found the vlan 1268 * interface corresponding to the tag. 1269 */ 1270 evl->evl_encap_proto = evl->evl_proto; 1271 break; 1272 default: 1273 printf("vlan_demux: unsupported if type %u", 1274 ifnet_type(p)); 1275 m_freem(m); 1276 return 0; 1277 break; 1278 } 1279 } 1280 if (tag != 0) { 1281 ifvlan_ref ifv; 1282 1283 if ((ifnet_eflags(p) & IFEF_VLAN) == 0) { 1284 /* don't bother looking through the VLAN list */ 1285 m_freem(m); 1286 return 0; 1287 } 1288 vlan_lock(); 1289 ifv = vlan_lookup_parent_and_tag(p, tag); 1290 if (ifv != NULL) { 1291 ifp = ifv->ifv_ifp; 1292 } 1293 if (ifv == NULL 1294 || ifvlan_flags_ready(ifv) == 0 1295 || (ifnet_flags(ifp) & IFF_UP) == 0) { 1296 vlan_unlock(); 1297 m_freem(m); 1298 return 0; 1299 } 1300 bpf_func = ifv->ifv_bpf_input; 1301 vlan_unlock(); 1302 } 1303 if (soft_vlan) { 1304 /* 1305 * Packet had an in-line encapsulation header; 1306 * remove it. The original header has already 1307 * been fixed up above. 1308 */ 1309 m->m_len -= ETHER_VLAN_ENCAP_LEN; 1310 m->m_data += ETHER_VLAN_ENCAP_LEN; 1311 m->m_pkthdr.len -= ETHER_VLAN_ENCAP_LEN; 1312 m->m_pkthdr.csum_flags = 0; /* can't trust hardware checksum */ 1313 } 1314 if (tag != 0) { 1315 m->m_pkthdr.rcvif = ifp; 1316 m->m_pkthdr.pkt_hdr = frame_header; 1317 (void)ifnet_stat_increment_in(ifp, 1, 1318 m->m_pkthdr.len + ETHER_HDR_LEN, 0); 1319 vlan_bpf_input(ifp, m, bpf_func, frame_header, ETHER_HDR_LEN, 1320 soft_vlan ? ETHER_VLAN_ENCAP_LEN : 0); 1321 /* We found a vlan interface, inject on that interface. */ 1322 dlil_input_packet_list(ifp, m); 1323 } else { 1324 m->m_pkthdr.pkt_hdr = frame_header; 1325 /* Send priority-tagged packet up through the parent */ 1326 dlil_input_packet_list(p, m); 1327 } 1328 return 0; 1329} 1330 1331static int 1332vlan_config(struct ifnet * ifp, struct ifnet * p, int tag) 1333{ 1334 int error; 1335 int first_vlan = FALSE; 1336 ifvlan_ref ifv = NULL; 1337 int ifv_added = FALSE; 1338 int need_vlp_release = 0; 1339 vlan_parent_ref new_vlp = NULL; 1340 ifnet_offload_t offload; 1341 u_int16_t parent_flags; 1342 vlan_parent_ref vlp = NULL; 1343 1344 /* pre-allocate space for vlan_parent, in case we're first */ 1345 error = vlan_parent_create(p, &new_vlp); 1346 if (error != 0) { 1347 return (error); 1348 } 1349 1350 vlan_lock(); 1351 ifv = ifnet_get_ifvlan_retained(ifp); 1352 if (ifv == NULL || ifv->ifv_vlp != NULL) { 1353 vlan_unlock(); 1354 if (ifv != NULL) { 1355 ifvlan_release(ifv); 1356 } 1357 vlan_parent_release(new_vlp); 1358 return (EBUSY); 1359 } 1360 vlp = parent_list_lookup(p); 1361 if (vlp != NULL) { 1362 vlan_parent_retain(vlp); 1363 need_vlp_release++; 1364 if (vlan_parent_lookup_tag(vlp, tag) != NULL) { 1365 /* already a VLAN with that tag on this interface */ 1366 error = EADDRINUSE; 1367 goto unlock_done; 1368 } 1369 } 1370 else { 1371 /* one for being in the list */ 1372 vlan_parent_retain(new_vlp); 1373 1374 /* we're the first VLAN on this interface */ 1375 LIST_INSERT_HEAD(&g_vlan->parent_list, new_vlp, vlp_parent_list); 1376 vlp = new_vlp; 1377 1378 vlan_parent_retain(vlp); 1379 need_vlp_release++; 1380 } 1381 1382 /* need to wait to ensure no one else is trying to add/remove */ 1383 vlan_parent_wait(vlp, "vlan_config"); 1384 1385 if (ifnet_get_ifvlan(ifp) != ifv) { 1386 error = EINVAL; 1387 goto signal_done; 1388 } 1389 1390 /* check again because someone might have gotten in */ 1391 if (parent_list_lookup(p) != vlp) { 1392 error = EBUSY; 1393 goto signal_done; 1394 } 1395 1396 if (vlan_parent_flags_detaching(vlp) 1397 || ifvlan_flags_detaching(ifv) || ifv->ifv_vlp != NULL) { 1398 error = EBUSY; 1399 goto signal_done; 1400 } 1401 1402 /* check again because someone might have gotten the tag */ 1403 if (vlan_parent_lookup_tag(vlp, tag) != NULL) { 1404 /* already a VLAN with that tag on this interface */ 1405 error = EADDRINUSE; 1406 goto signal_done; 1407 } 1408 1409 if (vlan_parent_no_vlans(vlp)) { 1410 first_vlan = TRUE; 1411 } 1412 vlan_parent_add_vlan(vlp, ifv, tag); 1413 ifvlan_retain(ifv); /* parent references ifv */ 1414 ifv_added = TRUE; 1415 1416 /* check whether bond interface is using parent interface */ 1417 ifnet_lock_exclusive(p); 1418 if ((ifnet_eflags(p) & IFEF_BOND) != 0) { 1419 ifnet_lock_done(p); 1420 /* don't allow VLAN over interface that's already part of a bond */ 1421 error = EBUSY; 1422 goto signal_done; 1423 } 1424 /* prevent BOND interface from using it */ 1425 /* Can't use ifnet_set_eflags because that would take the lock */ 1426 p->if_eflags |= IFEF_VLAN; 1427 ifnet_lock_done(p); 1428 vlan_unlock(); 1429 1430 if (first_vlan) { 1431 /* attach our VLAN "protocol" to the interface */ 1432 error = vlan_attach_protocol(p); 1433 if (error) { 1434 vlan_lock(); 1435 goto signal_done; 1436 } 1437 } 1438 1439 /* configure parent to receive our multicast addresses */ 1440 error = multicast_list_program(&ifv->ifv_multicast, ifp, p); 1441 if (error != 0) { 1442 if (first_vlan) { 1443 (void)vlan_detach_protocol(p); 1444 } 1445 vlan_lock(); 1446 goto signal_done; 1447 } 1448 1449 /* set our ethernet address to that of the parent */ 1450 ifnet_set_lladdr_and_type(ifp, IF_LLADDR(p), ETHER_ADDR_LEN, IFT_ETHER); 1451 1452 /* no failures past this point */ 1453 vlan_lock(); 1454 1455 ifv->ifv_encaplen = ETHER_VLAN_ENCAP_LEN; 1456 ifv->ifv_flags = 0; 1457 if (vlan_parent_flags_supports_vlan_mtu(vlp)) { 1458 ifv->ifv_mtufudge = 0; 1459 } else { 1460 /* 1461 * Fudge the MTU by the encapsulation size. This 1462 * makes us incompatible with strictly compliant 1463 * 802.1Q implementations, but allows us to use 1464 * the feature with other NetBSD implementations, 1465 * which might still be useful. 1466 */ 1467 ifv->ifv_mtufudge = ifv->ifv_encaplen; 1468 } 1469 ifnet_set_mtu(ifp, ETHERMTU - ifv->ifv_mtufudge); 1470 1471 /* 1472 * Copy only a selected subset of flags from the parent. 1473 * Other flags are none of our business. 1474 */ 1475 parent_flags = ifnet_flags(p) 1476 & (IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX); 1477 ifnet_set_flags(ifp, parent_flags, 1478 IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX); 1479 1480 /* use hwassist bits from parent interface, but exclude VLAN bits */ 1481 offload = ifnet_offload(p) & ~(IFNET_VLAN_TAGGING | IFNET_VLAN_MTU); 1482 ifnet_set_offload(ifp, offload); 1483 1484 ifnet_set_flags(ifp, IFF_RUNNING, IFF_RUNNING); 1485 ifvlan_flags_set_ready(ifv); 1486 vlan_parent_signal(vlp, "vlan_config"); 1487 vlan_unlock(); 1488 if (new_vlp != vlp) { 1489 /* throw it away, it wasn't needed */ 1490 vlan_parent_release(new_vlp); 1491 } 1492 if (ifv != NULL) { 1493 ifvlan_release(ifv); 1494 } 1495 if (first_vlan) { 1496 /* mark the parent interface up */ 1497 ifnet_set_flags(p, IFF_UP, IFF_UP); 1498 (void)ifnet_ioctl(p, 0, SIOCSIFFLAGS, (caddr_t)NULL); 1499 } 1500 return 0; 1501 1502 signal_done: 1503 vlan_assert_lock_held(); 1504 1505 if (ifv_added) { 1506 vlan_parent_remove_vlan(vlp, ifv); 1507 if (!vlan_parent_flags_detaching(vlp) && vlan_parent_no_vlans(vlp)) { 1508 /* the vlan parent has no more VLAN's */ 1509 ifnet_set_eflags(p, 0, IFEF_VLAN); 1510 LIST_REMOVE(vlp, vlp_parent_list); 1511 /* release outside of the lock below */ 1512 need_vlp_release++; 1513 1514 /* one for being in the list */ 1515 need_vlp_release++; 1516 } 1517 } 1518 vlan_parent_signal(vlp, "vlan_config"); 1519 1520 unlock_done: 1521 vlan_unlock(); 1522 1523 while (need_vlp_release--) { 1524 vlan_parent_release(vlp); 1525 } 1526 if (new_vlp != vlp) { 1527 vlan_parent_release(new_vlp); 1528 } 1529 if (ifv != NULL) { 1530 if (ifv_added) { 1531 ifvlan_release(ifv); 1532 } 1533 ifvlan_release(ifv); 1534 } 1535 return (error); 1536} 1537 1538static void 1539vlan_link_event(struct ifnet * ifp, struct ifnet * p) 1540{ 1541 struct ifmediareq ifmr; 1542 1543 /* generate a link event based on the state of the underlying interface */ 1544 bzero(&ifmr, sizeof(ifmr)); 1545 snprintf(ifmr.ifm_name, sizeof(ifmr.ifm_name), 1546 "%s%d", ifnet_name(p), ifnet_unit(p)); 1547 if (ifnet_ioctl(p, 0, SIOCGIFMEDIA, &ifmr) == 0 1548 && ifmr.ifm_count > 0 && ifmr.ifm_status & IFM_AVALID) { 1549 u_int32_t event; 1550 1551 event = (ifmr.ifm_status & IFM_ACTIVE) 1552 ? KEV_DL_LINK_ON : KEV_DL_LINK_OFF; 1553 interface_link_event(ifp, event); 1554 } 1555 return; 1556} 1557 1558static int 1559vlan_unconfig(ifvlan_ref ifv, int need_to_wait) 1560{ 1561 struct ifnet * ifp = ifv->ifv_ifp; 1562 int last_vlan = FALSE; 1563 int need_ifv_release = 0; 1564 int need_vlp_release = 0; 1565 struct ifnet * p; 1566 vlan_parent_ref vlp; 1567 1568 vlan_assert_lock_held(); 1569 vlp = ifv->ifv_vlp; 1570 if (vlp == NULL) { 1571 return (0); 1572 } 1573 if (need_to_wait) { 1574 need_vlp_release++; 1575 vlan_parent_retain(vlp); 1576 vlan_parent_wait(vlp, "vlan_unconfig"); 1577 1578 /* check again because another thread could be in vlan_unconfig */ 1579 if (ifv != ifnet_get_ifvlan(ifp)) { 1580 goto signal_done; 1581 } 1582 if (ifv->ifv_vlp != vlp) { 1583 /* vlan parent changed */ 1584 goto signal_done; 1585 } 1586 } 1587 1588 /* ifv has a reference on vlp, need to remove it */ 1589 need_vlp_release++; 1590 p = vlp->vlp_ifp; 1591 1592 /* remember whether we're the last VLAN on the parent */ 1593 if (LIST_NEXT(LIST_FIRST(&vlp->vlp_vlan_list), ifv_vlan_list) == NULL) { 1594 if (g_vlan->verbose) { 1595 printf("vlan_unconfig: last vlan on %s%d\n", 1596 ifnet_name(p), ifnet_unit(p)); 1597 } 1598 last_vlan = TRUE; 1599 } 1600 1601 /* back-out any effect our mtu might have had on the parent */ 1602 (void)ifvlan_new_mtu(ifv, ETHERMTU - ifv->ifv_mtufudge); 1603 1604 vlan_unlock(); 1605 1606 /* un-join multicast on parent interface */ 1607 (void)multicast_list_remove(&ifv->ifv_multicast); 1608 1609 /* Clear our MAC address. */ 1610 ifnet_set_lladdr_and_type(ifp, NULL, 0, IFT_L2VLAN); 1611 1612 /* detach VLAN "protocol" */ 1613 if (last_vlan) { 1614 (void)vlan_detach_protocol(p); 1615 } 1616 1617 vlan_lock(); 1618 1619 /* return to the state we were in before SIFVLAN */ 1620 ifnet_set_mtu(ifp, 0); 1621 ifnet_set_flags(ifp, 0, 1622 IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX | IFF_RUNNING); 1623 ifnet_set_offload(ifp, 0); 1624 ifv->ifv_mtufudge = 0; 1625 1626 /* Disconnect from parent. */ 1627 vlan_parent_remove_vlan(vlp, ifv); 1628 ifv->ifv_flags = 0; 1629 1630 /* vlan_parent has reference to ifv, remove it */ 1631 need_ifv_release++; 1632 1633 /* from this point on, no more referencing ifv */ 1634 if (last_vlan && !vlan_parent_flags_detaching(vlp)) { 1635 /* the vlan parent has no more VLAN's */ 1636 ifnet_set_eflags(p, 0, IFEF_VLAN); 1637 LIST_REMOVE(vlp, vlp_parent_list); 1638 1639 /* one for being in the list */ 1640 need_vlp_release++; 1641 1642 /* release outside of the lock below */ 1643 need_vlp_release++; 1644 } 1645 1646 signal_done: 1647 if (need_to_wait) { 1648 vlan_parent_signal(vlp, "vlan_unconfig"); 1649 } 1650 vlan_unlock(); 1651 while (need_ifv_release--) { 1652 ifvlan_release(ifv); 1653 } 1654 while (need_vlp_release--) { /* references to vlp */ 1655 vlan_parent_release(vlp); 1656 } 1657 vlan_lock(); 1658 return (0); 1659} 1660 1661static int 1662vlan_set_promisc(struct ifnet * ifp) 1663{ 1664 int error = 0; 1665 ifvlan_ref ifv; 1666 vlan_parent_ref vlp; 1667 1668 vlan_lock(); 1669 ifv = ifnet_get_ifvlan_retained(ifp); 1670 if (ifv == NULL) { 1671 error = EBUSY; 1672 goto done; 1673 } 1674 1675 vlp = ifv->ifv_vlp; 1676 if (vlp == NULL) { 1677 goto done; 1678 } 1679 if ((ifnet_flags(ifp) & IFF_PROMISC) != 0) { 1680 if (!ifvlan_flags_promisc(ifv)) { 1681 error = ifnet_set_promiscuous(vlp->vlp_ifp, 1); 1682 if (error == 0) { 1683 ifvlan_flags_set_promisc(ifv); 1684 } 1685 } 1686 } else { 1687 if (ifvlan_flags_promisc(ifv)) { 1688 error = ifnet_set_promiscuous(vlp->vlp_ifp, 0); 1689 if (error == 0) { 1690 ifvlan_flags_clear_promisc(ifv); 1691 } 1692 } 1693 } 1694 done: 1695 vlan_unlock(); 1696 if (ifv != NULL) { 1697 ifvlan_release(ifv); 1698 } 1699 return (error); 1700} 1701 1702static int 1703ifvlan_new_mtu(ifvlan_ref ifv, int mtu) 1704{ 1705 struct ifdevmtu * devmtu_p; 1706 int error = 0; 1707 struct ifnet * ifp = ifv->ifv_ifp; 1708 int max_mtu; 1709 int new_mtu = 0; 1710 int req_mtu; 1711 vlan_parent_ref vlp; 1712 1713 vlan_assert_lock_held(); 1714 vlp = ifv->ifv_vlp; 1715 devmtu_p = &vlp->vlp_devmtu; 1716 req_mtu = mtu + ifv->ifv_mtufudge; 1717 if (req_mtu > devmtu_p->ifdm_max || req_mtu < devmtu_p->ifdm_min) { 1718 return (EINVAL); 1719 } 1720 max_mtu = vlan_parent_find_max_mtu(vlp, ifv); 1721 if (req_mtu > max_mtu) { 1722 new_mtu = req_mtu; 1723 } 1724 else if (max_mtu < devmtu_p->ifdm_current) { 1725 new_mtu = max_mtu; 1726 } 1727 if (new_mtu != 0) { 1728 struct ifnet * p = vlp->vlp_ifp; 1729 vlan_unlock(); 1730 error = siocsifaltmtu(p, new_mtu); 1731 vlan_lock(); 1732 } 1733 if (error == 0) { 1734 if (new_mtu != 0) { 1735 devmtu_p->ifdm_current = new_mtu; 1736 } 1737 ifnet_set_mtu(ifp, mtu); 1738 } 1739 return (error); 1740} 1741 1742static int 1743vlan_set_mtu(struct ifnet * ifp, int mtu) 1744{ 1745 int error = 0; 1746 ifvlan_ref ifv; 1747 vlan_parent_ref vlp; 1748 1749 if (mtu < IF_MINMTU) { 1750 return (EINVAL); 1751 } 1752 vlan_lock(); 1753 ifv = ifnet_get_ifvlan_retained(ifp); 1754 if (ifv == NULL) { 1755 vlan_unlock(); 1756 return (EBUSY); 1757 } 1758 vlp = ifvlan_get_vlan_parent_retained(ifv); 1759 if (vlp == NULL) { 1760 vlan_unlock(); 1761 ifvlan_release(ifv); 1762 if (mtu != 0) { 1763 return (EINVAL); 1764 } 1765 return (0); 1766 } 1767 vlan_parent_wait(vlp, "vlan_set_mtu"); 1768 1769 /* check again, something might have changed */ 1770 if (ifnet_get_ifvlan(ifp) != ifv 1771 || ifvlan_flags_detaching(ifv)) { 1772 error = EBUSY; 1773 goto signal_done; 1774 } 1775 if (ifv->ifv_vlp != vlp) { 1776 /* vlan parent changed */ 1777 goto signal_done; 1778 } 1779 if (vlan_parent_flags_detaching(vlp)) { 1780 if (mtu != 0) { 1781 error = EINVAL; 1782 } 1783 goto signal_done; 1784 } 1785 error = ifvlan_new_mtu(ifv, mtu); 1786 1787 signal_done: 1788 vlan_parent_signal(vlp, "vlan_set_mtu"); 1789 vlan_unlock(); 1790 vlan_parent_release(vlp); 1791 ifvlan_release(ifv); 1792 1793 return (error); 1794} 1795 1796static int 1797vlan_ioctl(ifnet_t ifp, u_long cmd, void * data) 1798{ 1799 struct ifdevmtu * devmtu_p; 1800 int error = 0; 1801 struct ifaddr * ifa; 1802 struct ifmediareq *ifmr; 1803 struct ifreq * ifr; 1804 ifvlan_ref ifv; 1805 struct ifnet * p; 1806 u_short tag; 1807 user_addr_t user_addr; 1808 vlan_parent_ref vlp; 1809 struct vlanreq vlr; 1810 1811 if (ifnet_type(ifp) != IFT_L2VLAN) { 1812 return (EOPNOTSUPP); 1813 } 1814 ifr = (struct ifreq *)data; 1815 ifa = (struct ifaddr *)data; 1816 1817 switch (cmd) { 1818 case SIOCSIFADDR: 1819 ifnet_set_flags(ifp, IFF_UP, IFF_UP); 1820 break; 1821 1822 case SIOCGIFMEDIA32: 1823 case SIOCGIFMEDIA64: 1824 vlan_lock(); 1825 ifv = (ifvlan_ref)ifnet_softc(ifp); 1826 if (ifv == NULL || ifvlan_flags_detaching(ifv)) { 1827 vlan_unlock(); 1828 return (ifv == NULL ? EOPNOTSUPP : EBUSY); 1829 } 1830 p = (ifv->ifv_vlp == NULL) ? NULL : ifv->ifv_vlp->vlp_ifp; 1831 vlan_unlock(); 1832 ifmr = (struct ifmediareq *)data; 1833 user_addr = (cmd == SIOCGIFMEDIA64) ? 1834 ((struct ifmediareq64 *)ifmr)->ifmu_ulist : 1835 CAST_USER_ADDR_T(((struct ifmediareq32 *)ifmr)->ifmu_ulist); 1836 if (p != NULL) { 1837 struct ifmediareq p_ifmr; 1838 1839 bzero(&p_ifmr, sizeof(p_ifmr)); 1840 error = ifnet_ioctl(p, 0, SIOCGIFMEDIA, &p_ifmr); 1841 if (error == 0) { 1842 ifmr->ifm_active = p_ifmr.ifm_active; 1843 ifmr->ifm_current = p_ifmr.ifm_current; 1844 ifmr->ifm_mask = p_ifmr.ifm_mask; 1845 ifmr->ifm_status = p_ifmr.ifm_status; 1846 ifmr->ifm_count = p_ifmr.ifm_count; 1847 /* Limit the result to the parent's current config. */ 1848 if (ifmr->ifm_count >= 1 && user_addr != USER_ADDR_NULL) { 1849 ifmr->ifm_count = 1; 1850 error = copyout(&ifmr->ifm_current, user_addr, 1851 sizeof(int)); 1852 } 1853 } 1854 } else { 1855 ifmr->ifm_active = ifmr->ifm_current = IFM_NONE; 1856 ifmr->ifm_mask = 0; 1857 ifmr->ifm_status = IFM_AVALID; 1858 ifmr->ifm_count = 1; 1859 if (user_addr != USER_ADDR_NULL) { 1860 error = copyout(&ifmr->ifm_current, user_addr, sizeof(int)); 1861 } 1862 } 1863 break; 1864 1865 case SIOCSIFMEDIA: 1866 error = EOPNOTSUPP; 1867 break; 1868 1869 case SIOCGIFDEVMTU: 1870 vlan_lock(); 1871 ifv = (ifvlan_ref)ifnet_softc(ifp); 1872 if (ifv == NULL || ifvlan_flags_detaching(ifv)) { 1873 vlan_unlock(); 1874 return (ifv == NULL ? EOPNOTSUPP : EBUSY); 1875 } 1876 vlp = ifv->ifv_vlp; 1877 if (vlp != NULL) { 1878 int min_mtu = vlp->vlp_devmtu.ifdm_min - ifv->ifv_mtufudge; 1879 devmtu_p = &ifr->ifr_devmtu; 1880 devmtu_p->ifdm_current = ifnet_mtu(ifp); 1881 devmtu_p->ifdm_min = max(min_mtu, IF_MINMTU); 1882 devmtu_p->ifdm_max = vlp->vlp_devmtu.ifdm_max - ifv->ifv_mtufudge; 1883 } 1884 else { 1885 devmtu_p = &ifr->ifr_devmtu; 1886 devmtu_p->ifdm_current = 0; 1887 devmtu_p->ifdm_min = 0; 1888 devmtu_p->ifdm_max = 0; 1889 } 1890 vlan_unlock(); 1891 break; 1892 1893 case SIOCSIFMTU: 1894 error = vlan_set_mtu(ifp, ifr->ifr_mtu); 1895 break; 1896 1897 case SIOCSIFVLAN: 1898 user_addr = proc_is64bit(current_proc()) 1899 ? ifr->ifr_data64 : CAST_USER_ADDR_T(ifr->ifr_data); 1900 error = copyin(user_addr, &vlr, sizeof(vlr)); 1901 if (error) { 1902 break; 1903 } 1904 p = NULL; 1905 if (vlr.vlr_parent[0] != '\0') { 1906 if (vlr.vlr_tag & ~EVL_VLID_MASK) { 1907 /* 1908 * Don't let the caller set up a VLAN tag with 1909 * anything except VLID bits. 1910 */ 1911 error = EINVAL; 1912 break; 1913 } 1914 p = ifunit(vlr.vlr_parent); 1915 if (p == NULL) { 1916 error = ENXIO; 1917 break; 1918 } 1919 /* can't do VLAN over anything but ethernet or ethernet aggregate */ 1920 if (ifnet_type(p) != IFT_ETHER 1921 && ifnet_type(p) != IFT_IEEE8023ADLAG) { 1922 error = EPROTONOSUPPORT; 1923 break; 1924 } 1925 error = vlan_config(ifp, p, vlr.vlr_tag); 1926 if (error) { 1927 break; 1928 } 1929 1930 /* Update promiscuous mode, if necessary. */ 1931 (void)vlan_set_promisc(ifp); 1932 1933 /* generate a link event based on the state of the parent */ 1934 vlan_link_event(ifp, p); 1935 } 1936 else { 1937 int need_link_event = FALSE; 1938 1939 vlan_lock(); 1940 ifv = (ifvlan_ref)ifnet_softc(ifp); 1941 if (ifv == NULL || ifvlan_flags_detaching(ifv)) { 1942 vlan_unlock(); 1943 error = (ifv == NULL ? EOPNOTSUPP : EBUSY); 1944 break; 1945 } 1946 need_link_event = vlan_remove(ifv, TRUE); 1947 vlan_unlock(); 1948 if (need_link_event) { 1949 interface_link_event(ifp, KEV_DL_LINK_OFF); 1950 } 1951 } 1952 break; 1953 1954 case SIOCGIFVLAN: 1955 bzero(&vlr, sizeof vlr); 1956 vlan_lock(); 1957 ifv = (ifvlan_ref)ifnet_softc(ifp); 1958 if (ifv == NULL || ifvlan_flags_detaching(ifv)) { 1959 vlan_unlock(); 1960 return (ifv == NULL ? EOPNOTSUPP : EBUSY); 1961 } 1962 p = (ifv->ifv_vlp == NULL) ? NULL : ifv->ifv_vlp->vlp_ifp; 1963 tag = ifv->ifv_tag; 1964 vlan_unlock(); 1965 if (p != NULL) { 1966 snprintf(vlr.vlr_parent, sizeof(vlr.vlr_parent), 1967 "%s%d", ifnet_name(p), ifnet_unit(p)); 1968 vlr.vlr_tag = tag; 1969 } 1970 user_addr = proc_is64bit(current_proc()) 1971 ? ifr->ifr_data64 : CAST_USER_ADDR_T(ifr->ifr_data); 1972 error = copyout(&vlr, user_addr, sizeof(vlr)); 1973 break; 1974 1975 case SIOCSIFFLAGS: 1976 /* 1977 * For promiscuous mode, we enable promiscuous mode on 1978 * the parent if we need promiscuous on the VLAN interface. 1979 */ 1980 error = vlan_set_promisc(ifp); 1981 break; 1982 1983 case SIOCADDMULTI: 1984 case SIOCDELMULTI: 1985 error = vlan_setmulti(ifp); 1986 break; 1987 default: 1988 error = EOPNOTSUPP; 1989 } 1990 return error; 1991} 1992 1993static void 1994vlan_if_free(struct ifnet * ifp) 1995{ 1996 ifvlan_ref ifv; 1997 1998 if (ifp == NULL) { 1999 return; 2000 } 2001 ifv = (ifvlan_ref)ifnet_softc(ifp); 2002 if (ifv == NULL) { 2003 return; 2004 } 2005 ifvlan_release(ifv); 2006 ifnet_release(ifp); 2007 return; 2008} 2009 2010static void 2011vlan_event(struct ifnet * p, __unused protocol_family_t protocol, 2012 const struct kev_msg * event) 2013{ 2014 int event_code; 2015 2016 /* Check if the interface we are attached to is being detached */ 2017 if (event->vendor_code != KEV_VENDOR_APPLE 2018 || event->kev_class != KEV_NETWORK_CLASS 2019 || event->kev_subclass != KEV_DL_SUBCLASS) { 2020 return; 2021 } 2022 event_code = event->event_code; 2023 switch (event_code) { 2024 case KEV_DL_LINK_OFF: 2025 case KEV_DL_LINK_ON: 2026 vlan_parent_link_event(p, event_code); 2027 break; 2028 default: 2029 return; 2030 } 2031 return; 2032} 2033 2034static errno_t 2035vlan_detached(ifnet_t p, __unused protocol_family_t protocol) 2036{ 2037 if (ifnet_is_attached(p, 0) == 0) { 2038 /* if the parent isn't attached, remove all VLANs */ 2039 vlan_parent_remove_all_vlans(p); 2040 } 2041 return (0); 2042} 2043 2044static void 2045interface_link_event(struct ifnet * ifp, u_int32_t event_code) 2046{ 2047 struct { 2048 struct kern_event_msg header; 2049 u_int32_t unit; 2050 char if_name[IFNAMSIZ]; 2051 } event; 2052 2053 bzero(&event, sizeof(event)); 2054 event.header.total_size = sizeof(event); 2055 event.header.vendor_code = KEV_VENDOR_APPLE; 2056 event.header.kev_class = KEV_NETWORK_CLASS; 2057 event.header.kev_subclass = KEV_DL_SUBCLASS; 2058 event.header.event_code = event_code; 2059 event.header.event_data[0] = ifnet_family(ifp); 2060 event.unit = (u_int32_t) ifnet_unit(ifp); 2061 strlcpy(event.if_name, ifnet_name(ifp), IFNAMSIZ); 2062 ifnet_event(ifp, &event.header); 2063 return; 2064} 2065 2066static void 2067vlan_parent_link_event(struct ifnet * p, u_int32_t event_code) 2068{ 2069 vlan_parent_ref vlp; 2070 2071 vlan_lock(); 2072 if ((ifnet_eflags(p) & IFEF_VLAN) == 0) { 2073 vlan_unlock(); 2074 /* no VLAN's */ 2075 return; 2076 } 2077 vlp = parent_list_lookup(p); 2078 if (vlp == NULL) { 2079 /* no VLAN's */ 2080 vlan_unlock(); 2081 return; 2082 } 2083 vlan_parent_flags_set_link_event_required(vlp); 2084 vlp->vlp_event_code = event_code; 2085 if (vlan_parent_flags_change_in_progress(vlp)) { 2086 /* don't block waiting to generate an event */ 2087 vlan_unlock(); 2088 return; 2089 } 2090 vlan_parent_retain(vlp); 2091 vlan_parent_wait(vlp, "vlan_parent_link_event"); 2092 vlan_parent_signal(vlp, "vlan_parent_link_event"); 2093 vlan_unlock(); 2094 vlan_parent_release(vlp); 2095 return; 2096 2097} 2098 2099/* 2100 * Function: vlan_attach_protocol 2101 * Purpose: 2102 * Attach a DLIL protocol to the interface, using the ETHERTYPE_VLAN 2103 * demux ether type. 2104 * 2105 * The ethernet demux actually special cases VLAN to support hardware. 2106 * The demux here isn't used. The demux will return PF_VLAN for the 2107 * appropriate packets and our vlan_input function will be called. 2108 */ 2109static int 2110vlan_attach_protocol(struct ifnet *ifp) 2111{ 2112 int error; 2113 struct ifnet_attach_proto_param reg; 2114 2115 bzero(®, sizeof(reg)); 2116 reg.input = vlan_input; 2117 reg.event = vlan_event; 2118 reg.detached = vlan_detached; 2119 error = ifnet_attach_protocol(ifp, PF_VLAN, ®); 2120 if (error) { 2121 printf("vlan_proto_attach(%s%d) ifnet_attach_protocol failed, %d\n", 2122 ifnet_name(ifp), ifnet_unit(ifp), error); 2123 } 2124 return (error); 2125} 2126 2127/* 2128 * Function: vlan_detach_protocol 2129 * Purpose: 2130 * Detach our DLIL protocol from an interface 2131 */ 2132static int 2133vlan_detach_protocol(struct ifnet *ifp) 2134{ 2135 int error; 2136 2137 error = ifnet_detach_protocol(ifp, PF_VLAN); 2138 if (error) { 2139 printf("vlan_proto_detach(%s%d) ifnet_detach_protocol failed, %d\n", 2140 ifnet_name(ifp), ifnet_unit(ifp), error); 2141 } 2142 2143 return (error); 2144} 2145 2146/* 2147 * DLIL interface family functions 2148 * We use the ethernet plumb functions, since that's all we support. 2149 * If we wanted to handle multiple LAN types (tokenring, etc.), we'd 2150 * call the appropriate routines for that LAN type instead of hard-coding 2151 * ethernet. 2152 */ 2153static errno_t 2154vlan_attach_inet(struct ifnet *ifp, protocol_family_t protocol_family) 2155{ 2156 return (ether_attach_inet(ifp, protocol_family)); 2157} 2158 2159static void 2160vlan_detach_inet(struct ifnet *ifp, protocol_family_t protocol_family) 2161{ 2162 ether_detach_inet(ifp, protocol_family); 2163} 2164 2165#if INET6 2166static errno_t 2167vlan_attach_inet6(struct ifnet *ifp, protocol_family_t protocol_family) 2168{ 2169 return (ether_attach_inet6(ifp, protocol_family)); 2170} 2171 2172static void 2173vlan_detach_inet6(struct ifnet *ifp, protocol_family_t protocol_family) 2174{ 2175 ether_detach_inet6(ifp, protocol_family); 2176} 2177#endif /* INET6 */ 2178 2179__private_extern__ int 2180vlan_family_init(void) 2181{ 2182 int error=0; 2183 2184 error = proto_register_plumber(PF_INET, IFNET_FAMILY_VLAN, 2185 vlan_attach_inet, vlan_detach_inet); 2186 if (error != 0) { 2187 printf("proto_register_plumber failed for AF_INET error=%d\n", 2188 error); 2189 goto done; 2190 } 2191#if INET6 2192 error = proto_register_plumber(PF_INET6, IFNET_FAMILY_VLAN, 2193 vlan_attach_inet6, vlan_detach_inet6); 2194 if (error != 0) { 2195 printf("proto_register_plumber failed for AF_INET6 error=%d\n", 2196 error); 2197 goto done; 2198 } 2199#endif 2200 error = vlan_clone_attach(); 2201 if (error != 0) { 2202 printf("proto_register_plumber failed vlan_clone_attach error=%d\n", 2203 error); 2204 goto done; 2205 } 2206 2207 2208 done: 2209 return (error); 2210} 2211