if_vlan.c revision 167704
1/*- 2 * Copyright 1998 Massachusetts Institute of Technology 3 * 4 * Permission to use, copy, modify, and distribute this software and 5 * its documentation for any purpose and without fee is hereby 6 * granted, provided that both the above copyright notice and this 7 * permission notice appear in all copies, that both the above 8 * copyright notice and this permission notice appear in all 9 * supporting documentation, and that the name of M.I.T. not be used 10 * in advertising or publicity pertaining to distribution of the 11 * software without specific, written prior permission. M.I.T. makes 12 * no representations about the suitability of this software for any 13 * purpose. It is provided "as is" without express or implied 14 * warranty. 15 * 16 * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''. M.I.T. DISCLAIMS 17 * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE, 18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT 20 * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF 23 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 24 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 25 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 26 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD: head/sys/net/if_vlan.c 167704 2007-03-19 16:31:28Z yar $ 30 */ 31 32/* 33 * if_vlan.c - pseudo-device driver for IEEE 802.1Q virtual LANs. 34 * Might be extended some day to also handle IEEE 802.1p priority 35 * tagging. This is sort of sneaky in the implementation, since 36 * we need to pretend to be enough of an Ethernet implementation 37 * to make arp work. The way we do this is by telling everyone 38 * that we are an Ethernet, and then catch the packets that 39 * ether_output() left on our output queue when it calls 40 * if_start(), rewrite them for use by the real outgoing interface, 41 * and ask it to send them. 42 */ 43 44#include "opt_vlan.h" 45 46#include <sys/param.h> 47#include <sys/kernel.h> 48#include <sys/lock.h> 49#include <sys/malloc.h> 50#include <sys/mbuf.h> 51#include <sys/module.h> 52#include <sys/rwlock.h> 53#include <sys/queue.h> 54#include <sys/socket.h> 55#include <sys/sockio.h> 56#include <sys/sysctl.h> 57#include <sys/systm.h> 58 59#include <net/bpf.h> 60#include <net/ethernet.h> 61#include <net/if.h> 62#include <net/if_clone.h> 63#include <net/if_arp.h> 64#include <net/if_dl.h> 65#include <net/if_types.h> 66#include <net/if_vlan_var.h> 67 68#define VLANNAME "vlan" 69#define VLAN_DEF_HWIDTH 4 70#define VLAN_IFFLAGS (IFF_BROADCAST | IFF_MULTICAST) 71 72#define UP_AND_RUNNING(ifp) \ 73 ((ifp)->if_flags & IFF_UP && (ifp)->if_drv_flags & IFF_DRV_RUNNING) 74 75LIST_HEAD(ifvlanhead, ifvlan); 76 77struct ifvlantrunk { 78 struct ifnet *parent; /* parent interface of this trunk */ 79 struct rwlock rw; 80#ifdef VLAN_ARRAY 81#define VLAN_ARRAY_SIZE (EVL_VLID_MASK + 1) 82 struct ifvlan *vlans[VLAN_ARRAY_SIZE]; /* static table */ 83#else 84 struct ifvlanhead *hash; /* dynamic hash-list table */ 85 uint16_t hmask; 86 uint16_t hwidth; 87#endif 88 int refcnt; 89}; 90 91struct vlan_mc_entry { 92 struct ether_addr mc_addr; 93 SLIST_ENTRY(vlan_mc_entry) mc_entries; 94}; 95 96struct ifvlan { 97 struct ifvlantrunk *ifv_trunk; 98 struct ifnet *ifv_ifp; 99#define TRUNK(ifv) ((ifv)->ifv_trunk) 100#define PARENT(ifv) ((ifv)->ifv_trunk->parent) 101 int ifv_pflags; /* special flags we have set on parent */ 102 struct ifv_linkmib { 103 int ifvm_encaplen; /* encapsulation length */ 104 int ifvm_mtufudge; /* MTU fudged by this much */ 105 int ifvm_mintu; /* min transmission unit */ 106 uint16_t ifvm_proto; /* encapsulation ethertype */ 107 uint16_t ifvm_tag; /* tag to apply on packets leaving if */ 108 } ifv_mib; 109 SLIST_HEAD(, vlan_mc_entry) vlan_mc_listhead; 110#ifndef VLAN_ARRAY 111 LIST_ENTRY(ifvlan) ifv_list; 112#endif 113}; 114#define ifv_proto ifv_mib.ifvm_proto 115#define ifv_tag ifv_mib.ifvm_tag 116#define ifv_encaplen ifv_mib.ifvm_encaplen 117#define ifv_mtufudge ifv_mib.ifvm_mtufudge 118#define ifv_mintu ifv_mib.ifvm_mintu 119 120/* Special flags we should propagate to parent. */ 121static struct { 122 int flag; 123 int (*func)(struct ifnet *, int); 124} vlan_pflags[] = { 125 {IFF_PROMISC, ifpromisc}, 126 {IFF_ALLMULTI, if_allmulti}, 127 {0, NULL} 128}; 129 130SYSCTL_DECL(_net_link); 131SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW, 0, "IEEE 802.1Q VLAN"); 132SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0, "for consistency"); 133 134static int soft_pad = 0; 135SYSCTL_INT(_net_link_vlan, OID_AUTO, soft_pad, CTLFLAG_RW, &soft_pad, 0, 136 "pad short frames before tagging"); 137 138static MALLOC_DEFINE(M_VLAN, VLANNAME, "802.1Q Virtual LAN Interface"); 139 140static eventhandler_tag ifdetach_tag; 141 142/* 143 * We have a global mutex, that is used to serialize configuration 144 * changes and isn't used in normal packet delivery. 145 * 146 * We also have a per-trunk rwlock, that is locked shared on packet 147 * processing and exclusive when configuration is changed. 148 * 149 * The VLAN_ARRAY substitutes the dynamic hash with a static array 150 * with 4096 entries. In theory this can give a boost in processing, 151 * however on practice it does not. Probably this is because array 152 * is too big to fit into CPU cache. 153 */ 154static struct mtx ifv_mtx; 155#define VLAN_LOCK_INIT() mtx_init(&ifv_mtx, "vlan_global", NULL, MTX_DEF) 156#define VLAN_LOCK_DESTROY() mtx_destroy(&ifv_mtx) 157#define VLAN_LOCK_ASSERT() mtx_assert(&ifv_mtx, MA_OWNED) 158#define VLAN_LOCK() mtx_lock(&ifv_mtx) 159#define VLAN_UNLOCK() mtx_unlock(&ifv_mtx) 160#define TRUNK_LOCK_INIT(trunk) rw_init(&(trunk)->rw, VLANNAME) 161#define TRUNK_LOCK_DESTROY(trunk) rw_destroy(&(trunk)->rw) 162#define TRUNK_LOCK(trunk) rw_wlock(&(trunk)->rw) 163#define TRUNK_UNLOCK(trunk) rw_wunlock(&(trunk)->rw) 164#define TRUNK_LOCK_ASSERT(trunk) rw_assert(&(trunk)->rw, RA_WLOCKED) 165#define TRUNK_RLOCK(trunk) rw_rlock(&(trunk)->rw) 166#define TRUNK_RUNLOCK(trunk) rw_runlock(&(trunk)->rw) 167#define TRUNK_LOCK_RASSERT(trunk) rw_assert(&(trunk)->rw, RA_RLOCKED) 168 169#ifndef VLAN_ARRAY 170static void vlan_inithash(struct ifvlantrunk *trunk); 171static void vlan_freehash(struct ifvlantrunk *trunk); 172static int vlan_inshash(struct ifvlantrunk *trunk, struct ifvlan *ifv); 173static int vlan_remhash(struct ifvlantrunk *trunk, struct ifvlan *ifv); 174static void vlan_growhash(struct ifvlantrunk *trunk, int howmuch); 175static __inline struct ifvlan * vlan_gethash(struct ifvlantrunk *trunk, 176 uint16_t tag); 177#endif 178static void trunk_destroy(struct ifvlantrunk *trunk); 179 180static void vlan_start(struct ifnet *ifp); 181static void vlan_init(void *foo); 182static void vlan_input(struct ifnet *ifp, struct mbuf *m); 183static int vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t addr); 184static int vlan_setflag(struct ifnet *ifp, int flag, int status, 185 int (*func)(struct ifnet *, int)); 186static int vlan_setflags(struct ifnet *ifp, int status); 187static int vlan_setmulti(struct ifnet *ifp); 188static int vlan_unconfig(struct ifnet *ifp); 189static int vlan_unconfig_locked(struct ifnet *ifp); 190static int vlan_config(struct ifvlan *ifv, struct ifnet *p, uint16_t tag); 191static void vlan_link_state(struct ifnet *ifp, int link); 192static void vlan_capabilities(struct ifvlan *ifv); 193static void vlan_trunk_capabilities(struct ifnet *ifp); 194 195static struct ifnet *vlan_clone_match_ethertag(struct if_clone *, 196 const char *, int *); 197static int vlan_clone_match(struct if_clone *, const char *); 198static int vlan_clone_create(struct if_clone *, char *, size_t, caddr_t); 199static int vlan_clone_destroy(struct if_clone *, struct ifnet *); 200 201static void vlan_ifdetach(void *arg, struct ifnet *ifp); 202 203static struct if_clone vlan_cloner = IFC_CLONE_INITIALIZER(VLANNAME, NULL, 204 IF_MAXUNIT, NULL, vlan_clone_match, vlan_clone_create, vlan_clone_destroy); 205 206#ifndef VLAN_ARRAY 207#define HASH(n, m) ((((n) >> 8) ^ ((n) >> 4) ^ (n)) & (m)) 208 209static void 210vlan_inithash(struct ifvlantrunk *trunk) 211{ 212 int i, n; 213 214 /* 215 * The trunk must not be locked here since we call malloc(M_WAITOK). 216 * It is OK in case this function is called before the trunk struct 217 * gets hooked up and becomes visible from other threads. 218 */ 219 220 KASSERT(trunk->hwidth == 0 && trunk->hash == NULL, 221 ("%s: hash already initialized", __func__)); 222 223 trunk->hwidth = VLAN_DEF_HWIDTH; 224 n = 1 << trunk->hwidth; 225 trunk->hmask = n - 1; 226 trunk->hash = malloc(sizeof(struct ifvlanhead) * n, M_VLAN, M_WAITOK); 227 for (i = 0; i < n; i++) 228 LIST_INIT(&trunk->hash[i]); 229} 230 231static void 232vlan_freehash(struct ifvlantrunk *trunk) 233{ 234#ifdef INVARIANTS 235 int i; 236 237 KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__)); 238 for (i = 0; i < (1 << trunk->hwidth); i++) 239 KASSERT(LIST_EMPTY(&trunk->hash[i]), 240 ("%s: hash table not empty", __func__)); 241#endif 242 free(trunk->hash, M_VLAN); 243 trunk->hash = NULL; 244 trunk->hwidth = trunk->hmask = 0; 245} 246 247static int 248vlan_inshash(struct ifvlantrunk *trunk, struct ifvlan *ifv) 249{ 250 int i, b; 251 struct ifvlan *ifv2; 252 253 TRUNK_LOCK_ASSERT(trunk); 254 KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__)); 255 256 b = 1 << trunk->hwidth; 257 i = HASH(ifv->ifv_tag, trunk->hmask); 258 LIST_FOREACH(ifv2, &trunk->hash[i], ifv_list) 259 if (ifv->ifv_tag == ifv2->ifv_tag) 260 return (EEXIST); 261 262 /* 263 * Grow the hash when the number of vlans exceeds half of the number of 264 * hash buckets squared. This will make the average linked-list length 265 * buckets/2. 266 */ 267 if (trunk->refcnt > (b * b) / 2) { 268 vlan_growhash(trunk, 1); 269 i = HASH(ifv->ifv_tag, trunk->hmask); 270 } 271 LIST_INSERT_HEAD(&trunk->hash[i], ifv, ifv_list); 272 trunk->refcnt++; 273 274 return (0); 275} 276 277static int 278vlan_remhash(struct ifvlantrunk *trunk, struct ifvlan *ifv) 279{ 280 int i, b; 281 struct ifvlan *ifv2; 282 283 TRUNK_LOCK_ASSERT(trunk); 284 KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__)); 285 286 b = 1 << trunk->hwidth; 287 i = HASH(ifv->ifv_tag, trunk->hmask); 288 LIST_FOREACH(ifv2, &trunk->hash[i], ifv_list) 289 if (ifv2 == ifv) { 290 trunk->refcnt--; 291 LIST_REMOVE(ifv2, ifv_list); 292 if (trunk->refcnt < (b * b) / 2) 293 vlan_growhash(trunk, -1); 294 return (0); 295 } 296 297 panic("%s: vlan not found\n", __func__); 298 return (ENOENT); /*NOTREACHED*/ 299} 300 301/* 302 * Grow the hash larger or smaller if memory permits. 303 */ 304static void 305vlan_growhash(struct ifvlantrunk *trunk, int howmuch) 306{ 307 struct ifvlan *ifv; 308 struct ifvlanhead *hash2; 309 int hwidth2, i, j, n, n2; 310 311 TRUNK_LOCK_ASSERT(trunk); 312 KASSERT(trunk->hwidth > 0, ("%s: hwidth not positive", __func__)); 313 314 if (howmuch == 0) { 315 /* Harmless yet obvious coding error */ 316 printf("%s: howmuch is 0\n", __func__); 317 return; 318 } 319 320 hwidth2 = trunk->hwidth + howmuch; 321 n = 1 << trunk->hwidth; 322 n2 = 1 << hwidth2; 323 /* Do not shrink the table below the default */ 324 if (hwidth2 < VLAN_DEF_HWIDTH) 325 return; 326 327 /* M_NOWAIT because we're called with trunk mutex held */ 328 hash2 = malloc(sizeof(struct ifvlanhead) * n2, M_VLAN, M_NOWAIT); 329 if (hash2 == NULL) { 330 printf("%s: out of memory -- hash size not changed\n", 331 __func__); 332 return; /* We can live with the old hash table */ 333 } 334 for (j = 0; j < n2; j++) 335 LIST_INIT(&hash2[j]); 336 for (i = 0; i < n; i++) 337 while ((ifv = LIST_FIRST(&trunk->hash[i])) != NULL) { 338 LIST_REMOVE(ifv, ifv_list); 339 j = HASH(ifv->ifv_tag, n2 - 1); 340 LIST_INSERT_HEAD(&hash2[j], ifv, ifv_list); 341 } 342 free(trunk->hash, M_VLAN); 343 trunk->hash = hash2; 344 trunk->hwidth = hwidth2; 345 trunk->hmask = n2 - 1; 346 347 if (bootverbose) 348 if_printf(trunk->parent, 349 "VLAN hash table resized from %d to %d buckets\n", n, n2); 350} 351 352static __inline struct ifvlan * 353vlan_gethash(struct ifvlantrunk *trunk, uint16_t tag) 354{ 355 struct ifvlan *ifv; 356 357 TRUNK_LOCK_RASSERT(trunk); 358 359 LIST_FOREACH(ifv, &trunk->hash[HASH(tag, trunk->hmask)], ifv_list) 360 if (ifv->ifv_tag == tag) 361 return (ifv); 362 return (NULL); 363} 364 365#if 0 366/* Debugging code to view the hashtables. */ 367static void 368vlan_dumphash(struct ifvlantrunk *trunk) 369{ 370 int i; 371 struct ifvlan *ifv; 372 373 for (i = 0; i < (1 << trunk->hwidth); i++) { 374 printf("%d: ", i); 375 LIST_FOREACH(ifv, &trunk->hash[i], ifv_list) 376 printf("%s ", ifv->ifv_ifp->if_xname); 377 printf("\n"); 378 } 379} 380#endif /* 0 */ 381#endif /* !VLAN_ARRAY */ 382 383static void 384trunk_destroy(struct ifvlantrunk *trunk) 385{ 386 VLAN_LOCK_ASSERT(); 387 388 TRUNK_LOCK(trunk); 389#ifndef VLAN_ARRAY 390 vlan_freehash(trunk); 391#endif 392 trunk->parent->if_vlantrunk = NULL; 393 TRUNK_UNLOCK(trunk); 394 TRUNK_LOCK_DESTROY(trunk); 395 free(trunk, M_VLAN); 396} 397 398/* 399 * Program our multicast filter. What we're actually doing is 400 * programming the multicast filter of the parent. This has the 401 * side effect of causing the parent interface to receive multicast 402 * traffic that it doesn't really want, which ends up being discarded 403 * later by the upper protocol layers. Unfortunately, there's no way 404 * to avoid this: there really is only one physical interface. 405 * 406 * XXX: There is a possible race here if more than one thread is 407 * modifying the multicast state of the vlan interface at the same time. 408 */ 409static int 410vlan_setmulti(struct ifnet *ifp) 411{ 412 struct ifnet *ifp_p; 413 struct ifmultiaddr *ifma, *rifma = NULL; 414 struct ifvlan *sc; 415 struct vlan_mc_entry *mc; 416 struct sockaddr_dl sdl; 417 int error; 418 419 /*VLAN_LOCK_ASSERT();*/ 420 421 /* Find the parent. */ 422 sc = ifp->if_softc; 423 ifp_p = PARENT(sc); 424 425 bzero((char *)&sdl, sizeof(sdl)); 426 sdl.sdl_len = sizeof(sdl); 427 sdl.sdl_family = AF_LINK; 428 sdl.sdl_index = ifp_p->if_index; 429 sdl.sdl_type = IFT_ETHER; 430 sdl.sdl_alen = ETHER_ADDR_LEN; 431 432 /* First, remove any existing filter entries. */ 433 while ((mc = SLIST_FIRST(&sc->vlan_mc_listhead)) != NULL) { 434 bcopy((char *)&mc->mc_addr, LLADDR(&sdl), ETHER_ADDR_LEN); 435 error = if_delmulti(ifp_p, (struct sockaddr *)&sdl); 436 if (error) 437 return (error); 438 SLIST_REMOVE_HEAD(&sc->vlan_mc_listhead, mc_entries); 439 free(mc, M_VLAN); 440 } 441 442 /* Now program new ones. */ 443 TAILQ_FOREACH(ifma, &ifp->if_multiaddrs, ifma_link) { 444 if (ifma->ifma_addr->sa_family != AF_LINK) 445 continue; 446 mc = malloc(sizeof(struct vlan_mc_entry), M_VLAN, M_NOWAIT); 447 if (mc == NULL) 448 return (ENOMEM); 449 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 450 (char *)&mc->mc_addr, ETHER_ADDR_LEN); 451 SLIST_INSERT_HEAD(&sc->vlan_mc_listhead, mc, mc_entries); 452 bcopy(LLADDR((struct sockaddr_dl *)ifma->ifma_addr), 453 LLADDR(&sdl), ETHER_ADDR_LEN); 454 error = if_addmulti(ifp_p, (struct sockaddr *)&sdl, &rifma); 455 if (error) 456 return (error); 457 } 458 459 return (0); 460} 461 462/* 463 * A handler for network interface departure events. 464 * Track departure of trunks here so that we don't access invalid 465 * pointers or whatever if a trunk is ripped from under us, e.g., 466 * by ejecting its hot-plug card. 467 */ 468static void 469vlan_ifdetach(void *arg __unused, struct ifnet *ifp) 470{ 471 struct ifvlan *ifv; 472 int i; 473 474 /* 475 * Check if it's a trunk interface first of all 476 * to avoid needless locking. 477 */ 478 if (ifp->if_vlantrunk == NULL) 479 return; 480 481 VLAN_LOCK(); 482 /* 483 * OK, it's a trunk. Loop over and detach all vlan's on it. 484 * Check trunk pointer after each vlan_unconfig() as it will 485 * free it and set to NULL after the last vlan was detached. 486 */ 487#ifdef VLAN_ARRAY 488 for (i = 0; i < VLAN_ARRAY_SIZE; i++) 489 if ((ifv = ifp->if_vlantrunk->vlans[i])) { 490 vlan_unconfig_locked(ifv->ifv_ifp); 491 if (ifp->if_vlantrunk == NULL) 492 break; 493 } 494#else /* VLAN_ARRAY */ 495restart: 496 for (i = 0; i < (1 << ifp->if_vlantrunk->hwidth); i++) 497 if ((ifv = LIST_FIRST(&ifp->if_vlantrunk->hash[i]))) { 498 vlan_unconfig_locked(ifv->ifv_ifp); 499 if (ifp->if_vlantrunk) 500 goto restart; /* trunk->hwidth can change */ 501 else 502 break; 503 } 504#endif /* VLAN_ARRAY */ 505 /* Trunk should have been destroyed in vlan_unconfig(). */ 506 KASSERT(ifp->if_vlantrunk == NULL, ("%s: purge failed", __func__)); 507 VLAN_UNLOCK(); 508} 509 510/* 511 * VLAN support can be loaded as a module. The only place in the 512 * system that's intimately aware of this is ether_input. We hook 513 * into this code through vlan_input_p which is defined there and 514 * set here. Noone else in the system should be aware of this so 515 * we use an explicit reference here. 516 */ 517extern void (*vlan_input_p)(struct ifnet *, struct mbuf *); 518 519/* For if_link_state_change() eyes only... */ 520extern void (*vlan_link_state_p)(struct ifnet *, int); 521 522static int 523vlan_modevent(module_t mod, int type, void *data) 524{ 525 526 switch (type) { 527 case MOD_LOAD: 528 ifdetach_tag = EVENTHANDLER_REGISTER(ifnet_departure_event, 529 vlan_ifdetach, NULL, EVENTHANDLER_PRI_ANY); 530 if (ifdetach_tag == NULL) 531 return (ENOMEM); 532 VLAN_LOCK_INIT(); 533 vlan_input_p = vlan_input; 534 vlan_link_state_p = vlan_link_state; 535 vlan_trunk_cap_p = vlan_trunk_capabilities; 536 if_clone_attach(&vlan_cloner); 537 if (bootverbose) 538 printf("vlan: initialized, using " 539#ifdef VLAN_ARRAY 540 "full-size arrays" 541#else 542 "hash tables with chaining" 543#endif 544 545 "\n"); 546 break; 547 case MOD_UNLOAD: 548 if_clone_detach(&vlan_cloner); 549 EVENTHANDLER_DEREGISTER(ifnet_departure_event, ifdetach_tag); 550 vlan_input_p = NULL; 551 vlan_link_state_p = NULL; 552 vlan_trunk_cap_p = NULL; 553 VLAN_LOCK_DESTROY(); 554 if (bootverbose) 555 printf("vlan: unloaded\n"); 556 break; 557 default: 558 return (EOPNOTSUPP); 559 } 560 return (0); 561} 562 563static moduledata_t vlan_mod = { 564 "if_vlan", 565 vlan_modevent, 566 0 567}; 568 569DECLARE_MODULE(if_vlan, vlan_mod, SI_SUB_PSEUDO, SI_ORDER_ANY); 570MODULE_VERSION(if_vlan, 3); 571MODULE_DEPEND(if_vlan, miibus, 1, 1, 1); 572 573static struct ifnet * 574vlan_clone_match_ethertag(struct if_clone *ifc, const char *name, int *tag) 575{ 576 const char *cp; 577 struct ifnet *ifp; 578 int t = 0; 579 580 /* Check for <etherif>.<vlan> style interface names. */ 581 IFNET_RLOCK(); 582 TAILQ_FOREACH(ifp, &ifnet, if_link) { 583 if (ifp->if_type != IFT_ETHER) 584 continue; 585 if (strncmp(ifp->if_xname, name, strlen(ifp->if_xname)) != 0) 586 continue; 587 cp = name + strlen(ifp->if_xname); 588 if (*cp != '.') 589 continue; 590 for(; *cp != '\0'; cp++) { 591 if (*cp < '0' || *cp > '9') 592 continue; 593 t = (t * 10) + (*cp - '0'); 594 } 595 if (tag != NULL) 596 *tag = t; 597 break; 598 } 599 IFNET_RUNLOCK(); 600 601 return (ifp); 602} 603 604static int 605vlan_clone_match(struct if_clone *ifc, const char *name) 606{ 607 const char *cp; 608 609 if (vlan_clone_match_ethertag(ifc, name, NULL) != NULL) 610 return (1); 611 612 if (strncmp(VLANNAME, name, strlen(VLANNAME)) != 0) 613 return (0); 614 for (cp = name + 4; *cp != '\0'; cp++) { 615 if (*cp < '0' || *cp > '9') 616 return (0); 617 } 618 619 return (1); 620} 621 622static int 623vlan_clone_create(struct if_clone *ifc, char *name, size_t len, caddr_t params) 624{ 625 char *dp; 626 int wildcard; 627 int unit; 628 int error; 629 int tag; 630 int ethertag; 631 struct ifvlan *ifv; 632 struct ifnet *ifp; 633 struct ifnet *p; 634 struct vlanreq vlr; 635 static const u_char eaddr[6]; /* 00:00:00:00:00:00 */ 636 637 /* 638 * There are 3 (ugh) ways to specify the cloned device: 639 * o pass a parameter block with the clone request. 640 * o specify parameters in the text of the clone device name 641 * o specify no parameters and get an unattached device that 642 * must be configured separately. 643 * The first technique is preferred; the latter two are 644 * supported for backwards compatibilty. 645 */ 646 if (params) { 647 error = copyin(params, &vlr, sizeof(vlr)); 648 if (error) 649 return error; 650 p = ifunit(vlr.vlr_parent); 651 if (p == NULL) 652 return ENXIO; 653 /* 654 * Don't let the caller set up a VLAN tag with 655 * anything except VLID bits. 656 */ 657 if (vlr.vlr_tag & ~EVL_VLID_MASK) 658 return (EINVAL); 659 error = ifc_name2unit(name, &unit); 660 if (error != 0) 661 return (error); 662 663 ethertag = 1; 664 tag = vlr.vlr_tag; 665 wildcard = (unit < 0); 666 } else if ((p = vlan_clone_match_ethertag(ifc, name, &tag)) != NULL) { 667 ethertag = 1; 668 unit = -1; 669 wildcard = 0; 670 671 /* 672 * Don't let the caller set up a VLAN tag with 673 * anything except VLID bits. 674 */ 675 if (tag & ~EVL_VLID_MASK) 676 return (EINVAL); 677 } else { 678 ethertag = 0; 679 680 error = ifc_name2unit(name, &unit); 681 if (error != 0) 682 return (error); 683 684 wildcard = (unit < 0); 685 } 686 687 error = ifc_alloc_unit(ifc, &unit); 688 if (error != 0) 689 return (error); 690 691 /* In the wildcard case, we need to update the name. */ 692 if (wildcard) { 693 for (dp = name; *dp != '\0'; dp++); 694 if (snprintf(dp, len - (dp-name), "%d", unit) > 695 len - (dp-name) - 1) { 696 panic("%s: interface name too long", __func__); 697 } 698 } 699 700 ifv = malloc(sizeof(struct ifvlan), M_VLAN, M_WAITOK | M_ZERO); 701 ifp = ifv->ifv_ifp = if_alloc(IFT_ETHER); 702 if (ifp == NULL) { 703 ifc_free_unit(ifc, unit); 704 free(ifv, M_VLAN); 705 return (ENOSPC); 706 } 707 SLIST_INIT(&ifv->vlan_mc_listhead); 708 709 ifp->if_softc = ifv; 710 /* 711 * Set the name manually rather than using if_initname because 712 * we don't conform to the default naming convention for interfaces. 713 */ 714 strlcpy(ifp->if_xname, name, IFNAMSIZ); 715 ifp->if_dname = ifc->ifc_name; 716 ifp->if_dunit = unit; 717 /* NB: flags are not set here */ 718 ifp->if_linkmib = &ifv->ifv_mib; 719 ifp->if_linkmiblen = sizeof(ifv->ifv_mib); 720 /* NB: mtu is not set here */ 721 722 ifp->if_init = vlan_init; 723 ifp->if_start = vlan_start; 724 ifp->if_ioctl = vlan_ioctl; 725 ifp->if_snd.ifq_maxlen = ifqmaxlen; 726 ifp->if_flags = VLAN_IFFLAGS; 727 ether_ifattach(ifp, eaddr); 728 /* Now undo some of the damage... */ 729 ifp->if_baudrate = 0; 730 ifp->if_type = IFT_L2VLAN; 731 ifp->if_hdrlen = ETHER_VLAN_ENCAP_LEN; 732 733 if (ethertag) { 734 error = vlan_config(ifv, p, tag); 735 if (error != 0) { 736 /* 737 * Since we've partialy failed, we need to back 738 * out all the way, otherwise userland could get 739 * confused. Thus, we destroy the interface. 740 */ 741 ether_ifdetach(ifp); 742 vlan_unconfig(ifp); 743 if_free_type(ifp, IFT_ETHER); 744 free(ifv, M_VLAN); 745 746 return (error); 747 } 748 749 /* Update flags on the parent, if necessary. */ 750 vlan_setflags(ifp, 1); 751 } 752 753 return (0); 754} 755 756static int 757vlan_clone_destroy(struct if_clone *ifc, struct ifnet *ifp) 758{ 759 struct ifvlan *ifv = ifp->if_softc; 760 int unit = ifp->if_dunit; 761 762 ether_ifdetach(ifp); /* first, remove it from system-wide lists */ 763 vlan_unconfig(ifp); /* now it can be unconfigured and freed */ 764 if_free_type(ifp, IFT_ETHER); 765 free(ifv, M_VLAN); 766 ifc_free_unit(ifc, unit); 767 768 return (0); 769} 770 771/* 772 * The ifp->if_init entry point for vlan(4) is a no-op. 773 */ 774static void 775vlan_init(void *foo __unused) 776{ 777} 778 779/* 780 * The if_start method for vlan(4) interface. It doesn't 781 * raises the IFF_DRV_OACTIVE flag, since it is called 782 * only from IFQ_HANDOFF() macro in ether_output_frame(). 783 * If the interface queue is full, and vlan_start() is 784 * not called, the queue would never get emptied and 785 * interface would stall forever. 786 */ 787static void 788vlan_start(struct ifnet *ifp) 789{ 790 struct ifvlan *ifv; 791 struct ifnet *p; 792 struct mbuf *m; 793 int error; 794 795 ifv = ifp->if_softc; 796 p = PARENT(ifv); 797 798 for (;;) { 799 IF_DEQUEUE(&ifp->if_snd, m); 800 if (m == NULL) 801 break; 802 BPF_MTAP(ifp, m); 803 804 /* 805 * Do not run parent's if_start() if the parent is not up, 806 * or parent's driver will cause a system crash. 807 */ 808 if (!UP_AND_RUNNING(p)) { 809 m_freem(m); 810 ifp->if_collisions++; 811 continue; 812 } 813 814 /* 815 * Pad the frame to the minimum size allowed if told to. 816 * This option is in accord with IEEE Std 802.1Q, 2003 Ed., 817 * paragraph C.4.4.3.b. It can help to work around buggy 818 * bridges that violate paragraph C.4.4.3.a from the same 819 * document, i.e., fail to pad short frames after untagging. 820 * E.g., a tagged frame 66 bytes long (incl. FCS) is OK, but 821 * untagging it will produce a 62-byte frame, which is a runt 822 * and requires padding. There are VLAN-enabled network 823 * devices that just discard such runts instead or mishandle 824 * them somehow. 825 */ 826 if (soft_pad) { 827 static char pad[8]; /* just zeros */ 828 int n; 829 830 for (n = ETHERMIN + ETHER_HDR_LEN - m->m_pkthdr.len; 831 n > 0; n -= sizeof(pad)) 832 if (!m_append(m, min(n, sizeof(pad)), pad)) 833 break; 834 835 if (n > 0) { 836 if_printf(ifp, "cannot pad short frame\n"); 837 ifp->if_oerrors++; 838 m_freem(m); 839 continue; 840 } 841 } 842 843 /* 844 * If underlying interface can do VLAN tag insertion itself, 845 * just pass the packet along. However, we need some way to 846 * tell the interface where the packet came from so that it 847 * knows how to find the VLAN tag to use, so we attach a 848 * packet tag that holds it. 849 */ 850 if (p->if_capenable & IFCAP_VLAN_HWTAGGING) { 851 m->m_pkthdr.ether_vtag = ifv->ifv_tag; 852 m->m_flags |= M_VLANTAG; 853 } else { 854 struct ether_vlan_header *evl; 855 856 M_PREPEND(m, ifv->ifv_encaplen, M_DONTWAIT); 857 if (m == NULL) { 858 if_printf(ifp, 859 "unable to prepend VLAN header\n"); 860 ifp->if_oerrors++; 861 continue; 862 } 863 /* M_PREPEND takes care of m_len, m_pkthdr.len for us */ 864 865 if (m->m_len < sizeof(*evl)) { 866 m = m_pullup(m, sizeof(*evl)); 867 if (m == NULL) { 868 if_printf(ifp, 869 "cannot pullup VLAN header\n"); 870 ifp->if_oerrors++; 871 continue; 872 } 873 } 874 875 /* 876 * Transform the Ethernet header into an Ethernet header 877 * with 802.1Q encapsulation. 878 */ 879 evl = mtod(m, struct ether_vlan_header *); 880 bcopy((char *)evl + ifv->ifv_encaplen, 881 (char *)evl, ETHER_HDR_LEN - ETHER_TYPE_LEN); 882 evl->evl_encap_proto = htons(ifv->ifv_proto); 883 evl->evl_tag = htons(ifv->ifv_tag); 884#ifdef DEBUG 885 printf("%s: %*D\n", __func__, (int)sizeof(*evl), 886 (unsigned char *)evl, ":"); 887#endif 888 } 889 890 /* 891 * Send it, precisely as ether_output() would have. 892 * We are already running at splimp. 893 */ 894 IFQ_HANDOFF(p, m, error); 895 if (!error) 896 ifp->if_opackets++; 897 else 898 ifp->if_oerrors++; 899 } 900} 901 902static void 903vlan_input(struct ifnet *ifp, struct mbuf *m) 904{ 905 struct ifvlantrunk *trunk = ifp->if_vlantrunk; 906 struct ifvlan *ifv; 907 uint16_t tag; 908 909 KASSERT(trunk != NULL, ("%s: no trunk", __func__)); 910 911 if (m->m_flags & M_VLANTAG) { 912 /* 913 * Packet is tagged, but m contains a normal 914 * Ethernet frame; the tag is stored out-of-band. 915 */ 916 tag = EVL_VLANOFTAG(m->m_pkthdr.ether_vtag); 917 m->m_flags &= ~M_VLANTAG; 918 } else { 919 struct ether_vlan_header *evl; 920 921 /* 922 * Packet is tagged in-band as specified by 802.1q. 923 */ 924 switch (ifp->if_type) { 925 case IFT_ETHER: 926 if (m->m_len < sizeof(*evl) && 927 (m = m_pullup(m, sizeof(*evl))) == NULL) { 928 if_printf(ifp, "cannot pullup VLAN header\n"); 929 return; 930 } 931 evl = mtod(m, struct ether_vlan_header *); 932 tag = EVL_VLANOFTAG(ntohs(evl->evl_tag)); 933 934 /* 935 * Remove the 802.1q header by copying the Ethernet 936 * addresses over it and adjusting the beginning of 937 * the data in the mbuf. The encapsulated Ethernet 938 * type field is already in place. 939 */ 940 bcopy((char *)evl, (char *)evl + ETHER_VLAN_ENCAP_LEN, 941 ETHER_HDR_LEN - ETHER_TYPE_LEN); 942 m_adj(m, ETHER_VLAN_ENCAP_LEN); 943 break; 944 945 default: 946#ifdef INVARIANTS 947 panic("%s: %s has unsupported if_type %u", 948 __func__, ifp->if_xname, ifp->if_type); 949#endif 950 m_freem(m); 951 ifp->if_noproto++; 952 return; 953 } 954 } 955 956 TRUNK_RLOCK(trunk); 957#ifdef VLAN_ARRAY 958 ifv = trunk->vlans[tag]; 959#else 960 ifv = vlan_gethash(trunk, tag); 961#endif 962 if (ifv == NULL || !UP_AND_RUNNING(ifv->ifv_ifp)) { 963 TRUNK_RUNLOCK(trunk); 964 m_freem(m); 965 ifp->if_noproto++; 966 return; 967 } 968 TRUNK_RUNLOCK(trunk); 969 970 m->m_pkthdr.rcvif = ifv->ifv_ifp; 971 ifv->ifv_ifp->if_ipackets++; 972 973 /* Pass it back through the parent's input routine. */ 974 (*ifp->if_input)(ifv->ifv_ifp, m); 975} 976 977static int 978vlan_config(struct ifvlan *ifv, struct ifnet *p, uint16_t tag) 979{ 980 struct ifvlantrunk *trunk; 981 struct ifnet *ifp; 982 int error = 0; 983 984 /* VID numbers 0x0 and 0xFFF are reserved */ 985 if (tag == 0 || tag == 0xFFF) 986 return (EINVAL); 987 if (p->if_type != IFT_ETHER) 988 return (EPROTONOSUPPORT); 989 if ((p->if_flags & VLAN_IFFLAGS) != VLAN_IFFLAGS) 990 return (EPROTONOSUPPORT); 991 if (ifv->ifv_trunk) 992 return (EBUSY); 993 994 if (p->if_vlantrunk == NULL) { 995 trunk = malloc(sizeof(struct ifvlantrunk), 996 M_VLAN, M_WAITOK | M_ZERO); 997#ifndef VLAN_ARRAY 998 vlan_inithash(trunk); 999#endif 1000 VLAN_LOCK(); 1001 if (p->if_vlantrunk != NULL) { 1002 /* A race that that is very unlikely to be hit. */ 1003#ifndef VLAN_ARRAY 1004 vlan_freehash(trunk); 1005#endif 1006 free(trunk, M_VLAN); 1007 goto exists; 1008 } 1009 TRUNK_LOCK_INIT(trunk); 1010 TRUNK_LOCK(trunk); 1011 p->if_vlantrunk = trunk; 1012 trunk->parent = p; 1013 } else { 1014 VLAN_LOCK(); 1015exists: 1016 trunk = p->if_vlantrunk; 1017 TRUNK_LOCK(trunk); 1018 } 1019 1020 ifv->ifv_tag = tag; /* must set this before vlan_inshash() */ 1021#ifdef VLAN_ARRAY 1022 if (trunk->vlans[tag] != NULL) { 1023 error = EEXIST; 1024 goto done; 1025 } 1026 trunk->vlans[tag] = ifv; 1027 trunk->refcnt++; 1028#else 1029 error = vlan_inshash(trunk, ifv); 1030 if (error) 1031 goto done; 1032#endif 1033 ifv->ifv_proto = ETHERTYPE_VLAN; 1034 ifv->ifv_encaplen = ETHER_VLAN_ENCAP_LEN; 1035 ifv->ifv_mintu = ETHERMIN; 1036 ifv->ifv_pflags = 0; 1037 1038 /* 1039 * If the parent supports the VLAN_MTU capability, 1040 * i.e. can Tx/Rx larger than ETHER_MAX_LEN frames, 1041 * use it. 1042 */ 1043 if (p->if_capenable & IFCAP_VLAN_MTU) { 1044 /* 1045 * No need to fudge the MTU since the parent can 1046 * handle extended frames. 1047 */ 1048 ifv->ifv_mtufudge = 0; 1049 } else { 1050 /* 1051 * Fudge the MTU by the encapsulation size. This 1052 * makes us incompatible with strictly compliant 1053 * 802.1Q implementations, but allows us to use 1054 * the feature with other NetBSD implementations, 1055 * which might still be useful. 1056 */ 1057 ifv->ifv_mtufudge = ifv->ifv_encaplen; 1058 } 1059 1060 ifv->ifv_trunk = trunk; 1061 ifp = ifv->ifv_ifp; 1062 ifp->if_mtu = p->if_mtu - ifv->ifv_mtufudge; 1063 ifp->if_baudrate = p->if_baudrate; 1064 /* 1065 * Copy only a selected subset of flags from the parent. 1066 * Other flags are none of our business. 1067 */ 1068#define VLAN_COPY_FLAGS (IFF_SIMPLEX) 1069 ifp->if_flags &= ~VLAN_COPY_FLAGS; 1070 ifp->if_flags |= p->if_flags & VLAN_COPY_FLAGS; 1071#undef VLAN_COPY_FLAGS 1072 1073 ifp->if_link_state = p->if_link_state; 1074 1075 vlan_capabilities(ifv); 1076 1077 /* 1078 * Set up our ``Ethernet address'' to reflect the underlying 1079 * physical interface's. 1080 */ 1081 bcopy(IF_LLADDR(p), IF_LLADDR(ifp), ETHER_ADDR_LEN); 1082 1083 /* 1084 * Configure multicast addresses that may already be 1085 * joined on the vlan device. 1086 */ 1087 (void)vlan_setmulti(ifp); /* XXX: VLAN lock held */ 1088 1089 /* We are ready for operation now. */ 1090 ifp->if_drv_flags |= IFF_DRV_RUNNING; 1091done: 1092 TRUNK_UNLOCK(trunk); 1093 VLAN_UNLOCK(); 1094 1095 return (error); 1096} 1097 1098static int 1099vlan_unconfig(struct ifnet *ifp) 1100{ 1101 int ret; 1102 1103 VLAN_LOCK(); 1104 ret = vlan_unconfig_locked(ifp); 1105 VLAN_UNLOCK(); 1106 return (ret); 1107} 1108 1109static int 1110vlan_unconfig_locked(struct ifnet *ifp) 1111{ 1112 struct ifvlantrunk *trunk; 1113 struct vlan_mc_entry *mc; 1114 struct ifvlan *ifv; 1115 int error; 1116 1117 VLAN_LOCK_ASSERT(); 1118 1119 ifv = ifp->if_softc; 1120 trunk = ifv->ifv_trunk; 1121 1122 if (trunk) { 1123 struct sockaddr_dl sdl; 1124 struct ifnet *p = trunk->parent; 1125 1126 TRUNK_LOCK(trunk); 1127 1128 /* 1129 * Since the interface is being unconfigured, we need to 1130 * empty the list of multicast groups that we may have joined 1131 * while we were alive from the parent's list. 1132 */ 1133 bzero((char *)&sdl, sizeof(sdl)); 1134 sdl.sdl_len = sizeof(sdl); 1135 sdl.sdl_family = AF_LINK; 1136 sdl.sdl_index = p->if_index; 1137 sdl.sdl_type = IFT_ETHER; 1138 sdl.sdl_alen = ETHER_ADDR_LEN; 1139 1140 while ((mc = SLIST_FIRST(&ifv->vlan_mc_listhead)) != NULL) { 1141 bcopy((char *)&mc->mc_addr, LLADDR(&sdl), 1142 ETHER_ADDR_LEN); 1143 error = if_delmulti(p, (struct sockaddr *)&sdl); 1144 if (error) 1145 return (error); 1146 SLIST_REMOVE_HEAD(&ifv->vlan_mc_listhead, mc_entries); 1147 free(mc, M_VLAN); 1148 } 1149 1150 vlan_setflags(ifp, 0); /* clear special flags on parent */ 1151#ifdef VLAN_ARRAY 1152 trunk->vlans[ifv->ifv_tag] = NULL; 1153 trunk->refcnt--; 1154#else 1155 vlan_remhash(trunk, ifv); 1156#endif 1157 ifv->ifv_trunk = NULL; 1158 1159 /* 1160 * Check if we were the last. 1161 */ 1162 if (trunk->refcnt == 0) { 1163 trunk->parent->if_vlantrunk = NULL; 1164 /* 1165 * XXXGL: If some ithread has already entered 1166 * vlan_input() and is now blocked on the trunk 1167 * lock, then it should preempt us right after 1168 * unlock and finish its work. Then we will acquire 1169 * lock again in trunk_destroy(). 1170 */ 1171 TRUNK_UNLOCK(trunk); 1172 trunk_destroy(trunk); 1173 } else 1174 TRUNK_UNLOCK(trunk); 1175 } 1176 1177 /* Disconnect from parent. */ 1178 if (ifv->ifv_pflags) 1179 if_printf(ifp, "%s: ifv_pflags unclean\n", __func__); 1180 ifp->if_mtu = ETHERMTU; 1181 ifp->if_link_state = LINK_STATE_UNKNOWN; 1182 ifp->if_drv_flags &= ~IFF_DRV_RUNNING; 1183 1184 return (0); 1185} 1186 1187/* Handle a reference counted flag that should be set on the parent as well */ 1188static int 1189vlan_setflag(struct ifnet *ifp, int flag, int status, 1190 int (*func)(struct ifnet *, int)) 1191{ 1192 struct ifvlan *ifv; 1193 int error; 1194 1195 /* XXX VLAN_LOCK_ASSERT(); */ 1196 1197 ifv = ifp->if_softc; 1198 status = status ? (ifp->if_flags & flag) : 0; 1199 /* Now "status" contains the flag value or 0 */ 1200 1201 /* 1202 * See if recorded parent's status is different from what 1203 * we want it to be. If it is, flip it. We record parent's 1204 * status in ifv_pflags so that we won't clear parent's flag 1205 * we haven't set. In fact, we don't clear or set parent's 1206 * flags directly, but get or release references to them. 1207 * That's why we can be sure that recorded flags still are 1208 * in accord with actual parent's flags. 1209 */ 1210 if (status != (ifv->ifv_pflags & flag)) { 1211 error = (*func)(PARENT(ifv), status); 1212 if (error) 1213 return (error); 1214 ifv->ifv_pflags &= ~flag; 1215 ifv->ifv_pflags |= status; 1216 } 1217 return (0); 1218} 1219 1220/* 1221 * Handle IFF_* flags that require certain changes on the parent: 1222 * if "status" is true, update parent's flags respective to our if_flags; 1223 * if "status" is false, forcedly clear the flags set on parent. 1224 */ 1225static int 1226vlan_setflags(struct ifnet *ifp, int status) 1227{ 1228 int error, i; 1229 1230 for (i = 0; vlan_pflags[i].flag; i++) { 1231 error = vlan_setflag(ifp, vlan_pflags[i].flag, 1232 status, vlan_pflags[i].func); 1233 if (error) 1234 return (error); 1235 } 1236 return (0); 1237} 1238 1239/* Inform all vlans that their parent has changed link state */ 1240static void 1241vlan_link_state(struct ifnet *ifp, int link) 1242{ 1243 struct ifvlantrunk *trunk = ifp->if_vlantrunk; 1244 struct ifvlan *ifv; 1245 int i; 1246 1247 TRUNK_LOCK(trunk); 1248#ifdef VLAN_ARRAY 1249 for (i = 0; i < VLAN_ARRAY_SIZE; i++) 1250 if (trunk->vlans[i] != NULL) { 1251 ifv = trunk->vlans[i]; 1252#else 1253 for (i = 0; i < (1 << trunk->hwidth); i++) 1254 LIST_FOREACH(ifv, &trunk->hash[i], ifv_list) { 1255#endif 1256 ifv->ifv_ifp->if_baudrate = trunk->parent->if_baudrate; 1257 if_link_state_change(ifv->ifv_ifp, 1258 trunk->parent->if_link_state); 1259 } 1260 TRUNK_UNLOCK(trunk); 1261} 1262 1263static void 1264vlan_capabilities(struct ifvlan *ifv) 1265{ 1266 struct ifnet *p = PARENT(ifv); 1267 struct ifnet *ifp = ifv->ifv_ifp; 1268 1269 TRUNK_LOCK_ASSERT(TRUNK(ifv)); 1270 1271 /* 1272 * If the parent interface can do checksum offloading 1273 * on VLANs, then propagate its hardware-assisted 1274 * checksumming flags. Also assert that checksum 1275 * offloading requires hardware VLAN tagging. 1276 */ 1277 if (p->if_capabilities & IFCAP_VLAN_HWCSUM) 1278 ifp->if_capabilities = p->if_capabilities & IFCAP_HWCSUM; 1279 1280 if (p->if_capenable & IFCAP_VLAN_HWCSUM && 1281 p->if_capenable & IFCAP_VLAN_HWTAGGING) { 1282 ifp->if_capenable = p->if_capenable & IFCAP_HWCSUM; 1283 ifp->if_hwassist = p->if_hwassist; 1284 } else { 1285 ifp->if_capenable = 0; 1286 ifp->if_hwassist = 0; 1287 } 1288} 1289 1290static void 1291vlan_trunk_capabilities(struct ifnet *ifp) 1292{ 1293 struct ifvlantrunk *trunk = ifp->if_vlantrunk; 1294 struct ifvlan *ifv; 1295 int i; 1296 1297 TRUNK_LOCK(trunk); 1298#ifdef VLAN_ARRAY 1299 for (i = 0; i < VLAN_ARRAY_SIZE; i++) 1300 if (trunk->vlans[i] != NULL) { 1301 ifv = trunk->vlans[i]; 1302#else 1303 for (i = 0; i < (1 << trunk->hwidth); i++) { 1304 LIST_FOREACH(ifv, &trunk->hash[i], ifv_list) 1305#endif 1306 vlan_capabilities(ifv); 1307 } 1308 TRUNK_UNLOCK(trunk); 1309} 1310 1311static int 1312vlan_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data) 1313{ 1314 struct ifaddr *ifa; 1315 struct ifnet *p; 1316 struct ifreq *ifr; 1317 struct ifvlan *ifv; 1318 struct vlanreq vlr; 1319 int error = 0; 1320 1321 ifr = (struct ifreq *)data; 1322 ifa = (struct ifaddr *)data; 1323 ifv = ifp->if_softc; 1324 1325 switch (cmd) { 1326 case SIOCGIFMEDIA: 1327 VLAN_LOCK(); 1328 if (TRUNK(ifv) != NULL) { 1329 error = (*PARENT(ifv)->if_ioctl)(PARENT(ifv), 1330 SIOCGIFMEDIA, data); 1331 VLAN_UNLOCK(); 1332 /* Limit the result to the parent's current config. */ 1333 if (error == 0) { 1334 struct ifmediareq *ifmr; 1335 1336 ifmr = (struct ifmediareq *)data; 1337 if (ifmr->ifm_count >= 1 && ifmr->ifm_ulist) { 1338 ifmr->ifm_count = 1; 1339 error = copyout(&ifmr->ifm_current, 1340 ifmr->ifm_ulist, 1341 sizeof(int)); 1342 } 1343 } 1344 } else { 1345 VLAN_UNLOCK(); 1346 error = EINVAL; 1347 } 1348 break; 1349 1350 case SIOCSIFMEDIA: 1351 error = EINVAL; 1352 break; 1353 1354 case SIOCSIFMTU: 1355 /* 1356 * Set the interface MTU. 1357 */ 1358 VLAN_LOCK(); 1359 if (TRUNK(ifv) != NULL) { 1360 if (ifr->ifr_mtu > 1361 (PARENT(ifv)->if_mtu - ifv->ifv_mtufudge) || 1362 ifr->ifr_mtu < 1363 (ifv->ifv_mintu - ifv->ifv_mtufudge)) 1364 error = EINVAL; 1365 else 1366 ifp->if_mtu = ifr->ifr_mtu; 1367 } else 1368 error = EINVAL; 1369 VLAN_UNLOCK(); 1370 break; 1371 1372 case SIOCSETVLAN: 1373 error = copyin(ifr->ifr_data, &vlr, sizeof(vlr)); 1374 if (error) 1375 break; 1376 if (vlr.vlr_parent[0] == '\0') { 1377 vlan_unconfig(ifp); 1378 break; 1379 } 1380 p = ifunit(vlr.vlr_parent); 1381 if (p == 0) { 1382 error = ENOENT; 1383 break; 1384 } 1385 /* 1386 * Don't let the caller set up a VLAN tag with 1387 * anything except VLID bits. 1388 */ 1389 if (vlr.vlr_tag & ~EVL_VLID_MASK) { 1390 error = EINVAL; 1391 break; 1392 } 1393 error = vlan_config(ifv, p, vlr.vlr_tag); 1394 if (error) 1395 break; 1396 1397 /* Update flags on the parent, if necessary. */ 1398 vlan_setflags(ifp, 1); 1399 break; 1400 1401 case SIOCGETVLAN: 1402 bzero(&vlr, sizeof(vlr)); 1403 VLAN_LOCK(); 1404 if (TRUNK(ifv) != NULL) { 1405 strlcpy(vlr.vlr_parent, PARENT(ifv)->if_xname, 1406 sizeof(vlr.vlr_parent)); 1407 vlr.vlr_tag = ifv->ifv_tag; 1408 } 1409 VLAN_UNLOCK(); 1410 error = copyout(&vlr, ifr->ifr_data, sizeof(vlr)); 1411 break; 1412 1413 case SIOCSIFFLAGS: 1414 /* 1415 * We should propagate selected flags to the parent, 1416 * e.g., promiscuous mode. 1417 */ 1418 if (TRUNK(ifv) != NULL) 1419 error = vlan_setflags(ifp, 1); 1420 break; 1421 1422 case SIOCADDMULTI: 1423 case SIOCDELMULTI: 1424 /* 1425 * If we don't have a parent, just remember the membership for 1426 * when we do. 1427 */ 1428 if (TRUNK(ifv) != NULL) 1429 error = vlan_setmulti(ifp); 1430 break; 1431 1432 default: 1433 error = ether_ioctl(ifp, cmd, data); 1434 } 1435 1436 return (error); 1437} 1438