Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
FreeBSD/Linux Kernel Cross Reference
sys/net/if_ethersubr.c
Version:
- FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
SearchContext: - none - 3 - 10
1 /*- 2 * SPDX-License-Identifier: BSD-3-Clause 3 * 4 * Copyright (c) 1982, 1989, 1993 5 * The Regents of the University of California. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. Neither the name of the University nor the names of its contributors 16 * may be used to endorse or promote products derived from this software 17 * without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 * @(#)if_ethersubr.c 8.1 (Berkeley) 6/10/93 32 * $FreeBSD: releng/12.0/sys/net/if_ethersubr.c 338324 2018-08-26 12:51:46Z markm $ 33 */ 34 35 #include "opt_inet.h" 36 #include "opt_inet6.h" 37 #include "opt_netgraph.h" 38 #include "opt_mbuf_profiling.h" 39 #include "opt_rss.h" 40 41 #include <sys/param.h> 42 #include <sys/systm.h> 43 #include <sys/bus.h> 44 #include <sys/eventhandler.h> 45 #include <sys/kernel.h> 46 #include <sys/lock.h> 47 #include <sys/malloc.h> 48 #include <sys/module.h> 49 #include <sys/mbuf.h> 50 #include <sys/priv.h> 51 #include <sys/random.h> 52 #include <sys/socket.h> 53 #include <sys/sockio.h> 54 #include <sys/sysctl.h> 55 #include <sys/uuid.h> 56 57 #include <net/if.h> 58 #include <net/if_var.h> 59 #include <net/if_arp.h> 60 #include <net/netisr.h> 61 #include <net/route.h> 62 #include <net/if_llc.h> 63 #include <net/if_dl.h> 64 #include <net/if_types.h> 65 #include <net/bpf.h> 66 #include <net/ethernet.h> 67 #include <net/if_bridgevar.h> 68 #include <net/if_vlan_var.h> 69 #include <net/if_llatbl.h> 70 #include <net/pfil.h> 71 #include <net/rss_config.h> 72 #include <net/vnet.h> 73 74 #include <netpfil/pf/pf_mtag.h> 75 76 #if defined(INET) || defined(INET6) 77 #include <netinet/in.h> 78 #include <netinet/in_var.h> 79 #include <netinet/if_ether.h> 80 #include <netinet/ip_carp.h> 81 #include <netinet/ip_var.h> 82 #endif 83 #ifdef INET6 84 #include <netinet6/nd6.h> 85 #endif 86 #include <security/mac/mac_framework.h> 87 88 #ifdef CTASSERT 89 CTASSERT(sizeof (struct ether_header) == ETHER_ADDR_LEN * 2 + 2); 90 CTASSERT(sizeof (struct ether_addr) == ETHER_ADDR_LEN); 91 #endif 92 93 VNET_DEFINE(struct pfil_head, link_pfil_hook); /* Packet filter hooks */ 94 95 /* netgraph node hooks for ng_ether(4) */ 96 void (*ng_ether_input_p)(struct ifnet *ifp, struct mbuf **mp); 97 void (*ng_ether_input_orphan_p)(struct ifnet *ifp, struct mbuf *m); 98 int (*ng_ether_output_p)(struct ifnet *ifp, struct mbuf **mp); 99 void (*ng_ether_attach_p)(struct ifnet *ifp); 100 void (*ng_ether_detach_p)(struct ifnet *ifp); 101 102 void (*vlan_input_p)(struct ifnet *, struct mbuf *); 103 104 /* if_bridge(4) support */ 105 void (*bridge_dn_p)(struct mbuf *, struct ifnet *); 106 107 /* if_lagg(4) support */ 108 struct mbuf *(*lagg_input_p)(struct ifnet *, struct mbuf *); 109 110 static const u_char etherbroadcastaddr[ETHER_ADDR_LEN] = 111 { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 112 113 static int ether_resolvemulti(struct ifnet *, struct sockaddr **, 114 struct sockaddr *); 115 #ifdef VIMAGE 116 static void ether_reassign(struct ifnet *, struct vnet *, char *); 117 #endif 118 static int ether_requestencap(struct ifnet *, struct if_encap_req *); 119 120 121 #define senderr(e) do { error = (e); goto bad;} while (0) 122 123 static void 124 update_mbuf_csumflags(struct mbuf *src, struct mbuf *dst) 125 { 126 int csum_flags = 0; 127 128 if (src->m_pkthdr.csum_flags & CSUM_IP) 129 csum_flags |= (CSUM_IP_CHECKED|CSUM_IP_VALID); 130 if (src->m_pkthdr.csum_flags & CSUM_DELAY_DATA) 131 csum_flags |= (CSUM_DATA_VALID|CSUM_PSEUDO_HDR); 132 if (src->m_pkthdr.csum_flags & CSUM_SCTP) 133 csum_flags |= CSUM_SCTP_VALID; 134 dst->m_pkthdr.csum_flags |= csum_flags; 135 if (csum_flags & CSUM_DATA_VALID) 136 dst->m_pkthdr.csum_data = 0xffff; 137 } 138 139 /* 140 * Handle link-layer encapsulation requests. 141 */ 142 static int 143 ether_requestencap(struct ifnet *ifp, struct if_encap_req *req) 144 { 145 struct ether_header *eh; 146 struct arphdr *ah; 147 uint16_t etype; 148 const u_char *lladdr; 149 150 if (req->rtype != IFENCAP_LL) 151 return (EOPNOTSUPP); 152 153 if (req->bufsize < ETHER_HDR_LEN) 154 return (ENOMEM); 155 156 eh = (struct ether_header *)req->buf; 157 lladdr = req->lladdr; 158 req->lladdr_off = 0; 159 160 switch (req->family) { 161 case AF_INET: 162 etype = htons(ETHERTYPE_IP); 163 break; 164 case AF_INET6: 165 etype = htons(ETHERTYPE_IPV6); 166 break; 167 case AF_ARP: 168 ah = (struct arphdr *)req->hdata; 169 ah->ar_hrd = htons(ARPHRD_ETHER); 170 171 switch(ntohs(ah->ar_op)) { 172 case ARPOP_REVREQUEST: 173 case ARPOP_REVREPLY: 174 etype = htons(ETHERTYPE_REVARP); 175 break; 176 case ARPOP_REQUEST: 177 case ARPOP_REPLY: 178 default: 179 etype = htons(ETHERTYPE_ARP); 180 break; 181 } 182 183 if (req->flags & IFENCAP_FLAG_BROADCAST) 184 lladdr = ifp->if_broadcastaddr; 185 break; 186 default: 187 return (EAFNOSUPPORT); 188 } 189 190 memcpy(&eh->ether_type, &etype, sizeof(eh->ether_type)); 191 memcpy(eh->ether_dhost, lladdr, ETHER_ADDR_LEN); 192 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 193 req->bufsize = sizeof(struct ether_header); 194 195 return (0); 196 } 197 198 199 static int 200 ether_resolve_addr(struct ifnet *ifp, struct mbuf *m, 201 const struct sockaddr *dst, struct route *ro, u_char *phdr, 202 uint32_t *pflags, struct llentry **plle) 203 { 204 struct ether_header *eh; 205 uint32_t lleflags = 0; 206 int error = 0; 207 #if defined(INET) || defined(INET6) 208 uint16_t etype; 209 #endif 210 211 if (plle) 212 *plle = NULL; 213 eh = (struct ether_header *)phdr; 214 215 switch (dst->sa_family) { 216 #ifdef INET 217 case AF_INET: 218 if ((m->m_flags & (M_BCAST | M_MCAST)) == 0) 219 error = arpresolve(ifp, 0, m, dst, phdr, &lleflags, 220 plle); 221 else { 222 if (m->m_flags & M_BCAST) 223 memcpy(eh->ether_dhost, ifp->if_broadcastaddr, 224 ETHER_ADDR_LEN); 225 else { 226 const struct in_addr *a; 227 a = &(((const struct sockaddr_in *)dst)->sin_addr); 228 ETHER_MAP_IP_MULTICAST(a, eh->ether_dhost); 229 } 230 etype = htons(ETHERTYPE_IP); 231 memcpy(&eh->ether_type, &etype, sizeof(etype)); 232 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 233 } 234 break; 235 #endif 236 #ifdef INET6 237 case AF_INET6: 238 if ((m->m_flags & M_MCAST) == 0) 239 error = nd6_resolve(ifp, 0, m, dst, phdr, &lleflags, 240 plle); 241 else { 242 const struct in6_addr *a6; 243 a6 = &(((const struct sockaddr_in6 *)dst)->sin6_addr); 244 ETHER_MAP_IPV6_MULTICAST(a6, eh->ether_dhost); 245 etype = htons(ETHERTYPE_IPV6); 246 memcpy(&eh->ether_type, &etype, sizeof(etype)); 247 memcpy(eh->ether_shost, IF_LLADDR(ifp), ETHER_ADDR_LEN); 248 } 249 break; 250 #endif 251 default: 252 if_printf(ifp, "can't handle af%d\n", dst->sa_family); 253 if (m != NULL) 254 m_freem(m); 255 return (EAFNOSUPPORT); 256 } 257 258 if (error == EHOSTDOWN) { 259 if (ro != NULL && (ro->ro_flags & RT_HAS_GW) != 0) 260 error = EHOSTUNREACH; 261 } 262 263 if (error != 0) 264 return (error); 265 266 *pflags = RT_MAY_LOOP; 267 if (lleflags & LLE_IFADDR) 268 *pflags |= RT_L2_ME; 269 270 return (0); 271 } 272 273 /* 274 * Ethernet output routine. 275 * Encapsulate a packet of type family for the local net. 276 * Use trailer local net encapsulation if enough data in first 277 * packet leaves a multiple of 512 bytes of data in remainder. 278 */ 279 int 280 ether_output(struct ifnet *ifp, struct mbuf *m, 281 const struct sockaddr *dst, struct route *ro) 282 { 283 int error = 0; 284 char linkhdr[ETHER_HDR_LEN], *phdr; 285 struct ether_header *eh; 286 struct pf_mtag *t; 287 int loop_copy = 1; 288 int hlen; /* link layer header length */ 289 uint32_t pflags; 290 struct llentry *lle = NULL; 291 int addref = 0; 292 293 phdr = NULL; 294 pflags = 0; 295 if (ro != NULL) { 296 /* XXX BPF uses ro_prepend */ 297 if (ro->ro_prepend != NULL) { 298 phdr = ro->ro_prepend; 299 hlen = ro->ro_plen; 300 } else if (!(m->m_flags & (M_BCAST | M_MCAST))) { 301 if ((ro->ro_flags & RT_LLE_CACHE) != 0) { 302 lle = ro->ro_lle; 303 if (lle != NULL && 304 (lle->la_flags & LLE_VALID) == 0) { 305 LLE_FREE(lle); 306 lle = NULL; /* redundant */ 307 ro->ro_lle = NULL; 308 } 309 if (lle == NULL) { 310 /* if we lookup, keep cache */ 311 addref = 1; 312 } else 313 /* 314 * Notify LLE code that 315 * the entry was used 316 * by datapath. 317 */ 318 llentry_mark_used(lle); 319 } 320 if (lle != NULL) { 321 phdr = lle->r_linkdata; 322 hlen = lle->r_hdrlen; 323 pflags = lle->r_flags; 324 } 325 } 326 } 327 328 #ifdef MAC 329 error = mac_ifnet_check_transmit(ifp, m); 330 if (error) 331 senderr(error); 332 #endif 333 334 M_PROFILE(m); 335 if (ifp->if_flags & IFF_MONITOR) 336 senderr(ENETDOWN); 337 if (!((ifp->if_flags & IFF_UP) && 338 (ifp->if_drv_flags & IFF_DRV_RUNNING))) 339 senderr(ENETDOWN); 340 341 if (phdr == NULL) { 342 /* No prepend data supplied. Try to calculate ourselves. */ 343 phdr = linkhdr; 344 hlen = ETHER_HDR_LEN; 345 error = ether_resolve_addr(ifp, m, dst, ro, phdr, &pflags, 346 addref ? &lle : NULL); 347 if (addref && lle != NULL) 348 ro->ro_lle = lle; 349 if (error != 0) 350 return (error == EWOULDBLOCK ? 0 : error); 351 } 352 353 if ((pflags & RT_L2_ME) != 0) { 354 update_mbuf_csumflags(m, m); 355 return (if_simloop(ifp, m, dst->sa_family, 0)); 356 } 357 loop_copy = pflags & RT_MAY_LOOP; 358 359 /* 360 * Add local net header. If no space in first mbuf, 361 * allocate another. 362 * 363 * Note that we do prepend regardless of RT_HAS_HEADER flag. 364 * This is done because BPF code shifts m_data pointer 365 * to the end of ethernet header prior to calling if_output(). 366 */ 367 M_PREPEND(m, hlen, M_NOWAIT); 368 if (m == NULL) 369 senderr(ENOBUFS); 370 if ((pflags & RT_HAS_HEADER) == 0) { 371 eh = mtod(m, struct ether_header *); 372 memcpy(eh, phdr, hlen); 373 } 374 375 /* 376 * If a simplex interface, and the packet is being sent to our 377 * Ethernet address or a broadcast address, loopback a copy. 378 * XXX To make a simplex device behave exactly like a duplex 379 * device, we should copy in the case of sending to our own 380 * ethernet address (thus letting the original actually appear 381 * on the wire). However, we don't do that here for security 382 * reasons and compatibility with the original behavior. 383 */ 384 if ((m->m_flags & M_BCAST) && loop_copy && (ifp->if_flags & IFF_SIMPLEX) && 385 ((t = pf_find_mtag(m)) == NULL || !t->routed)) { 386 struct mbuf *n; 387 388 /* 389 * Because if_simloop() modifies the packet, we need a 390 * writable copy through m_dup() instead of a readonly 391 * one as m_copy[m] would give us. The alternative would 392 * be to modify if_simloop() to handle the readonly mbuf, 393 * but performancewise it is mostly equivalent (trading 394 * extra data copying vs. extra locking). 395 * 396 * XXX This is a local workaround. A number of less 397 * often used kernel parts suffer from the same bug. 398 * See PR kern/105943 for a proposed general solution. 399 */ 400 if ((n = m_dup(m, M_NOWAIT)) != NULL) { 401 update_mbuf_csumflags(m, n); 402 (void)if_simloop(ifp, n, dst->sa_family, hlen); 403 } else 404 if_inc_counter(ifp, IFCOUNTER_IQDROPS, 1); 405 } 406 407 /* 408 * Bridges require special output handling. 409 */ 410 if (ifp->if_bridge) { 411 BRIDGE_OUTPUT(ifp, m, error); 412 return (error); 413 } 414 415 #if defined(INET) || defined(INET6) 416 if (ifp->if_carp && 417 (error = (*carp_output_p)(ifp, m, dst))) 418 goto bad; 419 #endif 420 421 /* Handle ng_ether(4) processing, if any */ 422 if (ifp->if_l2com != NULL) { 423 KASSERT(ng_ether_output_p != NULL, 424 ("ng_ether_output_p is NULL")); 425 if ((error = (*ng_ether_output_p)(ifp, &m)) != 0) { 426 bad: if (m != NULL) 427 m_freem(m); 428 return (error); 429 } 430 if (m == NULL) 431 return (0); 432 } 433 434 /* Continue with link-layer output */ 435 return ether_output_frame(ifp, m); 436 } 437 438 static bool 439 ether_set_pcp(struct mbuf **mp, struct ifnet *ifp, uint8_t pcp) 440 { 441 struct ether_header *eh; 442 443 eh = mtod(*mp, struct ether_header *); 444 if (ntohs(eh->ether_type) == ETHERTYPE_VLAN || 445 ether_8021q_frame(mp, ifp, ifp, 0, pcp)) 446 return (true); 447 if_inc_counter(ifp, IFCOUNTER_OERRORS, 1); 448 return (false); 449 } 450 451 /* 452 * Ethernet link layer output routine to send a raw frame to the device. 453 * 454 * This assumes that the 14 byte Ethernet header is present and contiguous 455 * in the first mbuf (if BRIDGE'ing). 456 */ 457 int 458 ether_output_frame(struct ifnet *ifp, struct mbuf *m) 459 { 460 int error; 461 uint8_t pcp; 462 463 pcp = ifp->if_pcp; 464 if (pcp != IFNET_PCP_NONE && ifp->if_type != IFT_L2VLAN && 465 !ether_set_pcp(&m, ifp, pcp)) 466 return (0); 467 468 if (PFIL_HOOKED(&V_link_pfil_hook)) { 469 error = pfil_run_hooks(&V_link_pfil_hook, &m, ifp, 470 PFIL_OUT, 0, NULL); 471 if (error != 0) 472 return (EACCES); 473 474 if (m == NULL) 475 return (0); 476 } 477 478 /* 479 * Queue message on interface, update output statistics if 480 * successful, and start output if interface not yet active. 481 */ 482 return ((ifp->if_transmit)(ifp, m)); 483 } 484 485 /* 486 * Process a received Ethernet packet; the packet is in the 487 * mbuf chain m with the ethernet header at the front. 488 */ 489 static void 490 ether_input_internal(struct ifnet *ifp, struct mbuf *m) 491 { 492 struct ether_header *eh; 493 u_short etype; 494 495 if ((ifp->if_flags & IFF_UP) == 0) { 496 m_freem(m); 497 return; 498 } 499 #ifdef DIAGNOSTIC 500 if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0) { 501 if_printf(ifp, "discard frame at !IFF_DRV_RUNNING\n"); 502 m_freem(m); 503 return; 504 } 505 #endif 506 if (m->m_len < ETHER_HDR_LEN) { 507 /* XXX maybe should pullup? */ 508 if_printf(ifp, "discard frame w/o leading ethernet " 509 "header (len %u pkt len %u)\n", 510 m->m_len, m->m_pkthdr.len); 511 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 512 m_freem(m); 513 return; 514 } 515 eh = mtod(m, struct ether_header *); 516 etype = ntohs(eh->ether_type); 517 random_harvest_queue_ether(m, sizeof(*m)); 518 519 CURVNET_SET_QUIET(ifp->if_vnet); 520 521 if (ETHER_IS_MULTICAST(eh->ether_dhost)) { 522 if (ETHER_IS_BROADCAST(eh->ether_dhost)) 523 m->m_flags |= M_BCAST; 524 else 525 m->m_flags |= M_MCAST; 526 if_inc_counter(ifp, IFCOUNTER_IMCASTS, 1); 527 } 528 529 #ifdef MAC 530 /* 531 * Tag the mbuf with an appropriate MAC label before any other 532 * consumers can get to it. 533 */ 534 mac_ifnet_create_mbuf(ifp, m); 535 #endif 536 537 /* 538 * Give bpf a chance at the packet. 539 */ 540 ETHER_BPF_MTAP(ifp, m); 541 542 /* 543 * If the CRC is still on the packet, trim it off. We do this once 544 * and once only in case we are re-entered. Nothing else on the 545 * Ethernet receive path expects to see the FCS. 546 */ 547 if (m->m_flags & M_HASFCS) { 548 m_adj(m, -ETHER_CRC_LEN); 549 m->m_flags &= ~M_HASFCS; 550 } 551 552 if (!(ifp->if_capenable & IFCAP_HWSTATS)) 553 if_inc_counter(ifp, IFCOUNTER_IBYTES, m->m_pkthdr.len); 554 555 /* Allow monitor mode to claim this frame, after stats are updated. */ 556 if (ifp->if_flags & IFF_MONITOR) { 557 m_freem(m); 558 CURVNET_RESTORE(); 559 return; 560 } 561 562 /* Handle input from a lagg(4) port */ 563 if (ifp->if_type == IFT_IEEE8023ADLAG) { 564 KASSERT(lagg_input_p != NULL, 565 ("%s: if_lagg not loaded!", __func__)); 566 m = (*lagg_input_p)(ifp, m); 567 if (m != NULL) 568 ifp = m->m_pkthdr.rcvif; 569 else { 570 CURVNET_RESTORE(); 571 return; 572 } 573 } 574 575 /* 576 * If the hardware did not process an 802.1Q tag, do this now, 577 * to allow 802.1P priority frames to be passed to the main input 578 * path correctly. 579 * TODO: Deal with Q-in-Q frames, but not arbitrary nesting levels. 580 */ 581 if ((m->m_flags & M_VLANTAG) == 0 && etype == ETHERTYPE_VLAN) { 582 struct ether_vlan_header *evl; 583 584 if (m->m_len < sizeof(*evl) && 585 (m = m_pullup(m, sizeof(*evl))) == NULL) { 586 #ifdef DIAGNOSTIC 587 if_printf(ifp, "cannot pullup VLAN header\n"); 588 #endif 589 if_inc_counter(ifp, IFCOUNTER_IERRORS, 1); 590 CURVNET_RESTORE(); 591 return; 592 } 593 594 evl = mtod(m, struct ether_vlan_header *); 595 m->m_pkthdr.ether_vtag = ntohs(evl->evl_tag); 596 m->m_flags |= M_VLANTAG; 597 598 bcopy((char *)evl, (char *)evl + ETHER_VLAN_ENCAP_LEN, 599 ETHER_HDR_LEN - ETHER_TYPE_LEN); 600 m_adj(m, ETHER_VLAN_ENCAP_LEN); 601 eh = mtod(m, struct ether_header *); 602 } 603 604 M_SETFIB(m, ifp->if_fib); 605 606 /* Allow ng_ether(4) to claim this frame. */ 607 if (ifp->if_l2com != NULL) { 608 KASSERT(ng_ether_input_p != NULL, 609 ("%s: ng_ether_input_p is NULL", __func__)); 610 m->m_flags &= ~M_PROMISC; 611 (*ng_ether_input_p)(ifp, &m); 612 if (m == NULL) { 613 CURVNET_RESTORE(); 614 return; 615 } 616 eh = mtod(m, struct ether_header *); 617 } 618 619 /* 620 * Allow if_bridge(4) to claim this frame. 621 * The BRIDGE_INPUT() macro will update ifp if the bridge changed it 622 * and the frame should be delivered locally. 623 */ 624 if (ifp->if_bridge != NULL) { 625 m->m_flags &= ~M_PROMISC; 626 BRIDGE_INPUT(ifp, m); 627 if (m == NULL) { 628 CURVNET_RESTORE(); 629 return; 630 } 631 eh = mtod(m, struct ether_header *); 632 } 633 634 #if defined(INET) || defined(INET6) 635 /* 636 * Clear M_PROMISC on frame so that carp(4) will see it when the 637 * mbuf flows up to Layer 3. 638 * FreeBSD's implementation of carp(4) uses the inprotosw 639 * to dispatch IPPROTO_CARP. carp(4) also allocates its own 640 * Ethernet addresses of the form 00:00:5e:00:01:xx, which 641 * is outside the scope of the M_PROMISC test below. 642 * TODO: Maintain a hash table of ethernet addresses other than 643 * ether_dhost which may be active on this ifp. 644 */ 645 if (ifp->if_carp && (*carp_forus_p)(ifp, eh->ether_dhost)) { 646 m->m_flags &= ~M_PROMISC; 647 } else 648 #endif 649 { 650 /* 651 * If the frame received was not for our MAC address, set the 652 * M_PROMISC flag on the mbuf chain. The frame may need to 653 * be seen by the rest of the Ethernet input path in case of 654 * re-entry (e.g. bridge, vlan, netgraph) but should not be 655 * seen by upper protocol layers. 656 */ 657 if (!ETHER_IS_MULTICAST(eh->ether_dhost) && 658 bcmp(IF_LLADDR(ifp), eh->ether_dhost, ETHER_ADDR_LEN) != 0) 659 m->m_flags |= M_PROMISC; 660 } 661 662 ether_demux(ifp, m); 663 CURVNET_RESTORE(); 664 } 665 666 /* 667 * Ethernet input dispatch; by default, direct dispatch here regardless of 668 * global configuration. However, if RSS is enabled, hook up RSS affinity 669 * so that when deferred or hybrid dispatch is enabled, we can redistribute 670 * load based on RSS. 671 * 672 * XXXRW: Would be nice if the ifnet passed up a flag indicating whether or 673 * not it had already done work distribution via multi-queue. Then we could 674 * direct dispatch in the event load balancing was already complete and 675 * handle the case of interfaces with different capabilities better. 676 * 677 * XXXRW: Sort of want an M_DISTRIBUTED flag to avoid multiple distributions 678 * at multiple layers? 679 * 680 * XXXRW: For now, enable all this only if RSS is compiled in, although it 681 * works fine without RSS. Need to characterise the performance overhead 682 * of the detour through the netisr code in the event the result is always 683 * direct dispatch. 684 */ 685 static void 686 ether_nh_input(struct mbuf *m) 687 { 688 689 M_ASSERTPKTHDR(m); 690 KASSERT(m->m_pkthdr.rcvif != NULL, 691 ("%s: NULL interface pointer", __func__)); 692 ether_input_internal(m->m_pkthdr.rcvif, m); 693 } 694 695 static struct netisr_handler ether_nh = { 696 .nh_name = "ether", 697 .nh_handler = ether_nh_input, 698 .nh_proto = NETISR_ETHER, 699 #ifdef RSS 700 .nh_policy = NETISR_POLICY_CPU, 701 .nh_dispatch = NETISR_DISPATCH_DIRECT, 702 .nh_m2cpuid = rss_m2cpuid, 703 #else 704 .nh_policy = NETISR_POLICY_SOURCE, 705 .nh_dispatch = NETISR_DISPATCH_DIRECT, 706 #endif 707 }; 708 709 static void 710 ether_init(__unused void *arg) 711 { 712 713 netisr_register(ðer_nh); 714 } 715 SYSINIT(ether, SI_SUB_INIT_IF, SI_ORDER_ANY, ether_init, NULL); 716 717 static void 718 vnet_ether_init(__unused void *arg) 719 { 720 int i; 721 722 /* Initialize packet filter hooks. */ 723 V_link_pfil_hook.ph_type = PFIL_TYPE_AF; 724 V_link_pfil_hook.ph_af = AF_LINK; 725 if ((i = pfil_head_register(&V_link_pfil_hook)) != 0) 726 printf("%s: WARNING: unable to register pfil link hook, " 727 "error %d\n", __func__, i); 728 #ifdef VIMAGE 729 netisr_register_vnet(ðer_nh); 730 #endif 731 } 732 VNET_SYSINIT(vnet_ether_init, SI_SUB_PROTO_IF, SI_ORDER_ANY, 733 vnet_ether_init, NULL); 734 735 #ifdef VIMAGE 736 static void 737 vnet_ether_pfil_destroy(__unused void *arg) 738 { 739 int i; 740 741 if ((i = pfil_head_unregister(&V_link_pfil_hook)) != 0) 742 printf("%s: WARNING: unable to unregister pfil link hook, " 743 "error %d\n", __func__, i); 744 } 745 VNET_SYSUNINIT(vnet_ether_pfil_uninit, SI_SUB_PROTO_PFIL, SI_ORDER_ANY, 746 vnet_ether_pfil_destroy, NULL); 747 748 static void 749 vnet_ether_destroy(__unused void *arg) 750 { 751 752 netisr_unregister_vnet(ðer_nh); 753 } 754 VNET_SYSUNINIT(vnet_ether_uninit, SI_SUB_PROTO_IF, SI_ORDER_ANY, 755 vnet_ether_destroy, NULL); 756 #endif 757 758 759 760 static void 761 ether_input(struct ifnet *ifp, struct mbuf *m) 762 { 763 764 struct mbuf *mn; 765 766 /* 767 * The drivers are allowed to pass in a chain of packets linked with 768 * m_nextpkt. We split them up into separate packets here and pass 769 * them up. This allows the drivers to amortize the receive lock. 770 */ 771 while (m) { 772 mn = m->m_nextpkt; 773 m->m_nextpkt = NULL; 774 775 /* 776 * We will rely on rcvif being set properly in the deferred context, 777 * so assert it is correct here. 778 */ 779 KASSERT(m->m_pkthdr.rcvif == ifp, ("%s: ifnet mismatch m %p " 780 "rcvif %p ifp %p", __func__, m, m->m_pkthdr.rcvif, ifp)); 781 CURVNET_SET_QUIET(ifp->if_vnet); 782 netisr_dispatch(NETISR_ETHER, m); 783 CURVNET_RESTORE(); 784 m = mn; 785 } 786 } 787 788 /* 789 * Upper layer processing for a received Ethernet packet. 790 */ 791 void 792 ether_demux(struct ifnet *ifp, struct mbuf *m) 793 { 794 struct ether_header *eh; 795 int i, isr; 796 u_short ether_type; 797 798 KASSERT(ifp != NULL, ("%s: NULL interface pointer", __func__)); 799 800 /* Do not grab PROMISC frames in case we are re-entered. */ 801 if (PFIL_HOOKED(&V_link_pfil_hook) && !(m->m_flags & M_PROMISC)) { 802 i = pfil_run_hooks(&V_link_pfil_hook, &m, ifp, PFIL_IN, 0, 803 NULL); 804 805 if (i != 0 || m == NULL) 806 return; 807 } 808 809 eh = mtod(m, struct ether_header *); 810 ether_type = ntohs(eh->ether_type); 811 812 /* 813 * If this frame has a VLAN tag other than 0, call vlan_input() 814 * if its module is loaded. Otherwise, drop. 815 */ 816 if ((m->m_flags & M_VLANTAG) && 817 EVL_VLANOFTAG(m->m_pkthdr.ether_vtag) != 0) { 818 if (ifp->if_vlantrunk == NULL) { 819 if_inc_counter(ifp, IFCOUNTER_NOPROTO, 1); 820 m_freem(m); 821 return; 822 } 823 KASSERT(vlan_input_p != NULL,("%s: VLAN not loaded!", 824 __func__)); 825 /* Clear before possibly re-entering ether_input(). */ 826 m->m_flags &= ~M_PROMISC; 827 (*vlan_input_p)(ifp, m); 828 return; 829 } 830 831 /* 832 * Pass promiscuously received frames to the upper layer if the user 833 * requested this by setting IFF_PPROMISC. Otherwise, drop them. 834 */ 835 if ((ifp->if_flags & IFF_PPROMISC) == 0 && (m->m_flags & M_PROMISC)) { 836 m_freem(m); 837 return; 838 } 839 840 /* 841 * Reset layer specific mbuf flags to avoid confusing upper layers. 842 * Strip off Ethernet header. 843 */ 844 m->m_flags &= ~M_VLANTAG; 845 m_clrprotoflags(m); 846 m_adj(m, ETHER_HDR_LEN); 847 848 /* 849 * Dispatch frame to upper layer. 850 */ 851 switch (ether_type) { 852 #ifdef INET 853 case ETHERTYPE_IP: 854 isr = NETISR_IP; 855 break; 856 857 case ETHERTYPE_ARP: 858 if (ifp->if_flags & IFF_NOARP) { 859 /* Discard packet if ARP is disabled on interface */ 860 m_freem(m); 861 return; 862 } 863 isr = NETISR_ARP; 864 break; 865 #endif 866 #ifdef INET6 867 case ETHERTYPE_IPV6: 868 isr = NETISR_IPV6; 869 break; 870 #endif 871 default: 872 goto discard; 873 } 874 netisr_dispatch(isr, m); 875 return; 876 877 discard: 878 /* 879 * Packet is to be discarded. If netgraph is present, 880 * hand the packet to it for last chance processing; 881 * otherwise dispose of it. 882 */ 883 if (ifp->if_l2com != NULL) { 884 KASSERT(ng_ether_input_orphan_p != NULL, 885 ("ng_ether_input_orphan_p is NULL")); 886 /* 887 * Put back the ethernet header so netgraph has a 888 * consistent view of inbound packets. 889 */ 890 M_PREPEND(m, ETHER_HDR_LEN, M_NOWAIT); 891 (*ng_ether_input_orphan_p)(ifp, m); 892 return; 893 } 894 m_freem(m); 895 } 896 897 /* 898 * Convert Ethernet address to printable (loggable) representation. 899 * This routine is for compatibility; it's better to just use 900 * 901 * printf("%6D", <pointer to address>, ":"); 902 * 903 * since there's no static buffer involved. 904 */ 905 char * 906 ether_sprintf(const u_char *ap) 907 { 908 static char etherbuf[18]; 909 snprintf(etherbuf, sizeof (etherbuf), "%6D", ap, ":"); 910 return (etherbuf); 911 } 912 913 /* 914 * Perform common duties while attaching to interface list 915 */ 916 void 917 ether_ifattach(struct ifnet *ifp, const u_int8_t *lla) 918 { 919 int i; 920 struct ifaddr *ifa; 921 struct sockaddr_dl *sdl; 922 923 ifp->if_addrlen = ETHER_ADDR_LEN; 924 ifp->if_hdrlen = ETHER_HDR_LEN; 925 if_attach(ifp); 926 ifp->if_mtu = ETHERMTU; 927 ifp->if_output = ether_output; 928 ifp->if_input = ether_input; 929 ifp->if_resolvemulti = ether_resolvemulti; 930 ifp->if_requestencap = ether_requestencap; 931 #ifdef VIMAGE 932 ifp->if_reassign = ether_reassign; 933 #endif 934 if (ifp->if_baudrate == 0) 935 ifp->if_baudrate = IF_Mbps(10); /* just a default */ 936 ifp->if_broadcastaddr = etherbroadcastaddr; 937 938 ifa = ifp->if_addr; 939 KASSERT(ifa != NULL, ("%s: no lladdr!\n", __func__)); 940 sdl = (struct sockaddr_dl *)ifa->ifa_addr; 941 sdl->sdl_type = IFT_ETHER; 942 sdl->sdl_alen = ifp->if_addrlen; 943 bcopy(lla, LLADDR(sdl), ifp->if_addrlen); 944 945 if (ifp->if_hw_addr != NULL) 946 bcopy(lla, ifp->if_hw_addr, ifp->if_addrlen); 947 948 bpfattach(ifp, DLT_EN10MB, ETHER_HDR_LEN); 949 if (ng_ether_attach_p != NULL) 950 (*ng_ether_attach_p)(ifp); 951 952 /* Announce Ethernet MAC address if non-zero. */ 953 for (i = 0; i < ifp->if_addrlen; i++) 954 if (lla[i] != 0) 955 break; 956 if (i != ifp->if_addrlen) 957 if_printf(ifp, "Ethernet address: %6D\n", lla, ":"); 958 959 uuid_ether_add(LLADDR(sdl)); 960 961 /* Add necessary bits are setup; announce it now. */ 962 EVENTHANDLER_INVOKE(ether_ifattach_event, ifp); 963 if (IS_DEFAULT_VNET(curvnet)) 964 devctl_notify("ETHERNET", ifp->if_xname, "IFATTACH", NULL); 965 } 966 967 /* 968 * Perform common duties while detaching an Ethernet interface 969 */ 970 void 971 ether_ifdetach(struct ifnet *ifp) 972 { 973 struct sockaddr_dl *sdl; 974 975 sdl = (struct sockaddr_dl *)(ifp->if_addr->ifa_addr); 976 uuid_ether_del(LLADDR(sdl)); 977 978 if (ifp->if_l2com != NULL) { 979 KASSERT(ng_ether_detach_p != NULL, 980 ("ng_ether_detach_p is NULL")); 981 (*ng_ether_detach_p)(ifp); 982 } 983 984 bpfdetach(ifp); 985 if_detach(ifp); 986 } 987 988 #ifdef VIMAGE 989 void 990 ether_reassign(struct ifnet *ifp, struct vnet *new_vnet, char *unused __unused) 991 { 992 993 if (ifp->if_l2com != NULL) { 994 KASSERT(ng_ether_detach_p != NULL, 995 ("ng_ether_detach_p is NULL")); 996 (*ng_ether_detach_p)(ifp); 997 } 998 999 if (ng_ether_attach_p != NULL) { 1000 CURVNET_SET_QUIET(new_vnet); 1001 (*ng_ether_attach_p)(ifp); 1002 CURVNET_RESTORE(); 1003 } 1004 } 1005 #endif 1006 1007 SYSCTL_DECL(_net_link); 1008 SYSCTL_NODE(_net_link, IFT_ETHER, ether, CTLFLAG_RW, 0, "Ethernet"); 1009 1010 #if 0 1011 /* 1012 * This is for reference. We have a table-driven version 1013 * of the little-endian crc32 generator, which is faster 1014 * than the double-loop. 1015 */ 1016 uint32_t 1017 ether_crc32_le(const uint8_t *buf, size_t len) 1018 { 1019 size_t i; 1020 uint32_t crc; 1021 int bit; 1022 uint8_t data; 1023 1024 crc = 0xffffffff; /* initial value */ 1025 1026 for (i = 0; i < len; i++) { 1027 for (data = *buf++, bit = 0; bit < 8; bit++, data >>= 1) { 1028 carry = (crc ^ data) & 1; 1029 crc >>= 1; 1030 if (carry) 1031 crc = (crc ^ ETHER_CRC_POLY_LE); 1032 } 1033 } 1034 1035 return (crc); 1036 } 1037 #else 1038 uint32_t 1039 ether_crc32_le(const uint8_t *buf, size_t len) 1040 { 1041 static const uint32_t crctab[] = { 1042 0x00000000, 0x1db71064, 0x3b6e20c8, 0x26d930ac, 1043 0x76dc4190, 0x6b6b51f4, 0x4db26158, 0x5005713c, 1044 0xedb88320, 0xf00f9344, 0xd6d6a3e8, 0xcb61b38c, 1045 0x9b64c2b0, 0x86d3d2d4, 0xa00ae278, 0xbdbdf21c 1046 }; 1047 size_t i; 1048 uint32_t crc; 1049 1050 crc = 0xffffffff; /* initial value */ 1051 1052 for (i = 0; i < len; i++) { 1053 crc ^= buf[i]; 1054 crc = (crc >> 4) ^ crctab[crc & 0xf]; 1055 crc = (crc >> 4) ^ crctab[crc & 0xf]; 1056 } 1057 1058 return (crc); 1059 } 1060 #endif 1061 1062 uint32_t 1063 ether_crc32_be(const uint8_t *buf, size_t len) 1064 { 1065 size_t i; 1066 uint32_t crc, carry; 1067 int bit; 1068 uint8_t data; 1069 1070 crc = 0xffffffff; /* initial value */ 1071 1072 for (i = 0; i < len; i++) { 1073 for (data = *buf++, bit = 0; bit < 8; bit++, data >>= 1) { 1074 carry = ((crc & 0x80000000) ? 1 : 0) ^ (data & 0x01); 1075 crc <<= 1; 1076 if (carry) 1077 crc = (crc ^ ETHER_CRC_POLY_BE) | carry; 1078 } 1079 } 1080 1081 return (crc); 1082 } 1083 1084 int 1085 ether_ioctl(struct ifnet *ifp, u_long command, caddr_t data) 1086 { 1087 struct ifaddr *ifa = (struct ifaddr *) data; 1088 struct ifreq *ifr = (struct ifreq *) data; 1089 int error = 0; 1090 1091 switch (command) { 1092 case SIOCSIFADDR: 1093 ifp->if_flags |= IFF_UP; 1094 1095 switch (ifa->ifa_addr->sa_family) { 1096 #ifdef INET 1097 case AF_INET: 1098 ifp->if_init(ifp->if_softc); /* before arpwhohas */ 1099 arp_ifinit(ifp, ifa); 1100 break; 1101 #endif 1102 default: 1103 ifp->if_init(ifp->if_softc); 1104 break; 1105 } 1106 break; 1107 1108 case SIOCGIFADDR: 1109 bcopy(IF_LLADDR(ifp), &ifr->ifr_addr.sa_data[0], 1110 ETHER_ADDR_LEN); 1111 break; 1112 1113 case SIOCSIFMTU: 1114 /* 1115 * Set the interface MTU. 1116 */ 1117 if (ifr->ifr_mtu > ETHERMTU) { 1118 error = EINVAL; 1119 } else { 1120 ifp->if_mtu = ifr->ifr_mtu; 1121 } 1122 break; 1123 1124 case SIOCSLANPCP: 1125 error = priv_check(curthread, PRIV_NET_SETLANPCP); 1126 if (error != 0) 1127 break; 1128 if (ifr->ifr_lan_pcp > 7 && 1129 ifr->ifr_lan_pcp != IFNET_PCP_NONE) { 1130 error = EINVAL; 1131 } else { 1132 ifp->if_pcp = ifr->ifr_lan_pcp; 1133 /* broadcast event about PCP change */ 1134 EVENTHANDLER_INVOKE(ifnet_event, ifp, IFNET_EVENT_PCP); 1135 } 1136 break; 1137 1138 case SIOCGLANPCP: 1139 ifr->ifr_lan_pcp = ifp->if_pcp; 1140 break; 1141 1142 default: 1143 error = EINVAL; /* XXX netbsd has ENOTTY??? */ 1144 break; 1145 } 1146 return (error); 1147 } 1148 1149 static int 1150 ether_resolvemulti(struct ifnet *ifp, struct sockaddr **llsa, 1151 struct sockaddr *sa) 1152 { 1153 struct sockaddr_dl *sdl; 1154 #ifdef INET 1155 struct sockaddr_in *sin; 1156 #endif 1157 #ifdef INET6 1158 struct sockaddr_in6 *sin6; 1159 #endif 1160 u_char *e_addr; 1161 1162 switch(sa->sa_family) { 1163 case AF_LINK: 1164 /* 1165 * No mapping needed. Just check that it's a valid MC address. 1166 */ 1167 sdl = (struct sockaddr_dl *)sa; 1168 e_addr = LLADDR(sdl); 1169 if (!ETHER_IS_MULTICAST(e_addr)) 1170 return EADDRNOTAVAIL; 1171 *llsa = NULL; 1172 return 0; 1173 1174 #ifdef INET 1175 case AF_INET: 1176 sin = (struct sockaddr_in *)sa; 1177 if (!IN_MULTICAST(ntohl(sin->sin_addr.s_addr))) 1178 return EADDRNOTAVAIL; 1179 sdl = link_init_sdl(ifp, *llsa, IFT_ETHER); 1180 sdl->sdl_alen = ETHER_ADDR_LEN; 1181 e_addr = LLADDR(sdl); 1182 ETHER_MAP_IP_MULTICAST(&sin->sin_addr, e_addr); 1183 *llsa = (struct sockaddr *)sdl; 1184 return 0; 1185 #endif 1186 #ifdef INET6 1187 case AF_INET6: 1188 sin6 = (struct sockaddr_in6 *)sa; 1189 if (IN6_IS_ADDR_UNSPECIFIED(&sin6->sin6_addr)) { 1190 /* 1191 * An IP6 address of 0 means listen to all 1192 * of the Ethernet multicast address used for IP6. 1193 * (This is used for multicast routers.) 1194 */ 1195 ifp->if_flags |= IFF_ALLMULTI; 1196 *llsa = NULL; 1197 return 0; 1198 } 1199 if (!IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr)) 1200 return EADDRNOTAVAIL; 1201 sdl = link_init_sdl(ifp, *llsa, IFT_ETHER); 1202 sdl->sdl_alen = ETHER_ADDR_LEN; 1203 e_addr = LLADDR(sdl); 1204 ETHER_MAP_IPV6_MULTICAST(&sin6->sin6_addr, e_addr); 1205 *llsa = (struct sockaddr *)sdl; 1206 return 0; 1207 #endif 1208 1209 default: 1210 /* 1211 * Well, the text isn't quite right, but it's the name 1212 * that counts... 1213 */ 1214 return EAFNOSUPPORT; 1215 } 1216 } 1217 1218 static moduledata_t ether_mod = { 1219 .name = "ether", 1220 }; 1221 1222 void 1223 ether_vlan_mtap(struct bpf_if *bp, struct mbuf *m, void *data, u_int dlen) 1224 { 1225 struct ether_vlan_header vlan; 1226 struct mbuf mv, mb; 1227 1228 KASSERT((m->m_flags & M_VLANTAG) != 0, 1229 ("%s: vlan information not present", __func__)); 1230 KASSERT(m->m_len >= sizeof(struct ether_header), 1231 ("%s: mbuf not large enough for header", __func__)); 1232 bcopy(mtod(m, char *), &vlan, sizeof(struct ether_header)); 1233 vlan.evl_proto = vlan.evl_encap_proto; 1234 vlan.evl_encap_proto = htons(ETHERTYPE_VLAN); 1235 vlan.evl_tag = htons(m->m_pkthdr.ether_vtag); 1236 m->m_len -= sizeof(struct ether_header); 1237 m->m_data += sizeof(struct ether_header); 1238 /* 1239 * If a data link has been supplied by the caller, then we will need to 1240 * re-create a stack allocated mbuf chain with the following structure: 1241 * 1242 * (1) mbuf #1 will contain the supplied data link 1243 * (2) mbuf #2 will contain the vlan header 1244 * (3) mbuf #3 will contain the original mbuf's packet data 1245 * 1246 * Otherwise, submit the packet and vlan header via bpf_mtap2(). 1247 */ 1248 if (data != NULL) { 1249 mv.m_next = m; 1250 mv.m_data = (caddr_t)&vlan; 1251 mv.m_len = sizeof(vlan); 1252 mb.m_next = &mv; 1253 mb.m_data = data; 1254 mb.m_len = dlen; 1255 bpf_mtap(bp, &mb); 1256 } else 1257 bpf_mtap2(bp, &vlan, sizeof(vlan), m); 1258 m->m_len += sizeof(struct ether_header); 1259 m->m_data -= sizeof(struct ether_header); 1260 } 1261 1262 struct mbuf * 1263 ether_vlanencap(struct mbuf *m, uint16_t tag) 1264 { 1265 struct ether_vlan_header *evl; 1266 1267 M_PREPEND(m, ETHER_VLAN_ENCAP_LEN, M_NOWAIT); 1268 if (m == NULL) 1269 return (NULL); 1270 /* M_PREPEND takes care of m_len, m_pkthdr.len for us */ 1271 1272 if (m->m_len < sizeof(*evl)) { 1273 m = m_pullup(m, sizeof(*evl)); 1274 if (m == NULL) 1275 return (NULL); 1276 } 1277 1278 /* 1279 * Transform the Ethernet header into an Ethernet header 1280 * with 802.1Q encapsulation. 1281 */ 1282 evl = mtod(m, struct ether_vlan_header *); 1283 bcopy((char *)evl + ETHER_VLAN_ENCAP_LEN, 1284 (char *)evl, ETHER_HDR_LEN - ETHER_TYPE_LEN); 1285 evl->evl_encap_proto = htons(ETHERTYPE_VLAN); 1286 evl->evl_tag = htons(tag); 1287 return (m); 1288 } 1289 1290 static SYSCTL_NODE(_net_link, IFT_L2VLAN, vlan, CTLFLAG_RW, 0, 1291 "IEEE 802.1Q VLAN"); 1292 static SYSCTL_NODE(_net_link_vlan, PF_LINK, link, CTLFLAG_RW, 0, 1293 "for consistency"); 1294 1295 VNET_DEFINE_STATIC(int, soft_pad); 1296 #define V_soft_pad VNET(soft_pad) 1297 SYSCTL_INT(_net_link_vlan, OID_AUTO, soft_pad, CTLFLAG_RW | CTLFLAG_VNET, 1298 &VNET_NAME(soft_pad), 0, 1299 "pad short frames before tagging"); 1300 1301 /* 1302 * For now, make preserving PCP via an mbuf tag optional, as it increases 1303 * per-packet memory allocations and frees. In the future, it would be 1304 * preferable to reuse ether_vtag for this, or similar. 1305 */ 1306 int vlan_mtag_pcp = 0; 1307 SYSCTL_INT(_net_link_vlan, OID_AUTO, mtag_pcp, CTLFLAG_RW, 1308 &vlan_mtag_pcp, 0, 1309 "Retain VLAN PCP information as packets are passed up the stack"); 1310 1311 bool 1312 ether_8021q_frame(struct mbuf **mp, struct ifnet *ife, struct ifnet *p, 1313 uint16_t vid, uint8_t pcp) 1314 { 1315 struct m_tag *mtag; 1316 int n; 1317 uint16_t tag; 1318 static const char pad[8]; /* just zeros */ 1319 1320 /* 1321 * Pad the frame to the minimum size allowed if told to. 1322 * This option is in accord with IEEE Std 802.1Q, 2003 Ed., 1323 * paragraph C.4.4.3.b. It can help to work around buggy 1324 * bridges that violate paragraph C.4.4.3.a from the same 1325 * document, i.e., fail to pad short frames after untagging. 1326 * E.g., a tagged frame 66 bytes long (incl. FCS) is OK, but 1327 * untagging it will produce a 62-byte frame, which is a runt 1328 * and requires padding. There are VLAN-enabled network 1329 * devices that just discard such runts instead or mishandle 1330 * them somehow. 1331 */ 1332 if (V_soft_pad && p->if_type == IFT_ETHER) { 1333 for (n = ETHERMIN + ETHER_HDR_LEN - (*mp)->m_pkthdr.len; 1334 n > 0; n -= sizeof(pad)) { 1335 if (!m_append(*mp, min(n, sizeof(pad)), pad)) 1336 break; 1337 } 1338 if (n > 0) { 1339 m_freem(*mp); 1340 *mp = NULL; 1341 if_printf(ife, "cannot pad short frame"); 1342 return (false); 1343 } 1344 } 1345 1346 /* 1347 * If underlying interface can do VLAN tag insertion itself, 1348 * just pass the packet along. However, we need some way to 1349 * tell the interface where the packet came from so that it 1350 * knows how to find the VLAN tag to use, so we attach a 1351 * packet tag that holds it. 1352 */ 1353 if (vlan_mtag_pcp && (mtag = m_tag_locate(*mp, MTAG_8021Q, 1354 MTAG_8021Q_PCP_OUT, NULL)) != NULL) 1355 tag = EVL_MAKETAG(vid, *(uint8_t *)(mtag + 1), 0); 1356 else 1357 tag = EVL_MAKETAG(vid, pcp, 0); 1358 if (p->if_capenable & IFCAP_VLAN_HWTAGGING) { 1359 (*mp)->m_pkthdr.ether_vtag = tag; 1360 (*mp)->m_flags |= M_VLANTAG; 1361 } else { 1362 *mp = ether_vlanencap(*mp, tag); 1363 if (*mp == NULL) { 1364 if_printf(ife, "unable to prepend 802.1Q header"); 1365 return (false); 1366 } 1367 } 1368 return (true); 1369 } 1370 1371 DECLARE_MODULE(ether, ether_mod, SI_SUB_INIT_IF, SI_ORDER_ANY); 1372 MODULE_VERSION(ether, 1);
Cache object: 95282c2e236c82ef3ed00aedbb06fc87
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]