1 /* -*- linux-c -*- 2 * INET 802.1Q VLAN 3 * Ethernet-type device handling. 4 * 5 * Authors: Ben Greear <greearb@candelatech.com> 6 * Please send support related email to: netdev@vger.kernel.org 7 * VLAN Home Page: http://www.candelatech.com/~greear/vlan.html 8 * 9 * Fixes: Mar 22 2001: Martin Bokaemper <mbokaemper@unispherenetworks.com> 10 * - reset skb->pkt_type on incoming packets when MAC was changed 11 * - see that changed MAC is saddr for outgoing packets 12 * Oct 20, 2001: Ard van Breeman: 13 * - Fix MC-list, finally. 14 * - Flush MC-list on VLAN destroy. 15 * 16 * 17 * This program is free software; you can redistribute it and/or 18 * modify it under the terms of the GNU General Public License 19 * as published by the Free Software Foundation; either version 20 * 2 of the License, or (at your option) any later version. 21 */ 22 23 #include <linux/module.h> 24 #include <linux/slab.h> 25 #include <linux/skbuff.h> 26 #include <linux/netdevice.h> 27 #include <linux/etherdevice.h> 28 #include <linux/ethtool.h> 29 #include <net/arp.h> 30 31 #include "vlan.h" 32 #include "vlanproc.h" 33 #include <linux/if_vlan.h> 34 35 /* 36 * Rebuild the Ethernet MAC header. This is called after an ARP 37 * (or in future other address resolution) has completed on this 38 * sk_buff. We now let ARP fill in the other fields. 39 * 40 * This routine CANNOT use cached dst->neigh! 41 * Really, it is used only when dst->neigh is wrong. 42 * 43 * TODO: This needs a checkup, I'm ignorant here. --BLG 44 */ 45 static int vlan_dev_rebuild_header(struct sk_buff *skb) 46 { 47 struct net_device *dev = skb->dev; 48 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data); 49 50 switch (veth->h_vlan_encapsulated_proto) { 51 #ifdef CONFIG_INET 52 case htons(ETH_P_IP): 53 54 /* TODO: Confirm this will work with VLAN headers... */ 55 return arp_find(veth->h_dest, skb); 56 #endif 57 default: 58 pr_debug("%s: unable to resolve type %X addresses.\n", 59 dev->name, ntohs(veth->h_vlan_encapsulated_proto)); 60 61 memcpy(veth->h_source, dev->dev_addr, ETH_ALEN); 62 break; 63 } 64 65 return 0; 66 } 67 68 static inline struct sk_buff *vlan_check_reorder_header(struct sk_buff *skb) 69 { 70 if (vlan_dev_info(skb->dev)->flags & VLAN_FLAG_REORDER_HDR) { 71 if (skb_cow(skb, skb_headroom(skb)) < 0) 72 skb = NULL; 73 if (skb) { 74 /* Lifted from Gleb's VLAN code... */ 75 memmove(skb->data - ETH_HLEN, 76 skb->data - VLAN_ETH_HLEN, 12); 77 skb->mac_header += VLAN_HLEN; 78 } 79 } 80 81 return skb; 82 } 83 84 static inline void vlan_set_encap_proto(struct sk_buff *skb, 85 struct vlan_hdr *vhdr) 86 { 87 __be16 proto; 88 unsigned char *rawp; 89 90 /* 91 * Was a VLAN packet, grab the encapsulated protocol, which the layer 92 * three protocols care about. 93 */ 94 95 proto = vhdr->h_vlan_encapsulated_proto; 96 if (ntohs(proto) >= 1536) { 97 skb->protocol = proto; 98 return; 99 } 100 101 rawp = skb->data; 102 if (*(unsigned short *)rawp == 0xFFFF) 103 /* 104 * This is a magic hack to spot IPX packets. Older Novell 105 * breaks the protocol design and runs IPX over 802.3 without 106 * an 802.2 LLC layer. We look for FFFF which isn't a used 107 * 802.2 SSAP/DSAP. This won't work for fault tolerant netware 108 * but does for the rest. 109 */ 110 skb->protocol = htons(ETH_P_802_3); 111 else 112 /* 113 * Real 802.2 LLC 114 */ 115 skb->protocol = htons(ETH_P_802_2); 116 } 117 118 /* 119 * Determine the packet's protocol ID. The rule here is that we 120 * assume 802.3 if the type field is short enough to be a length. 121 * This is normal practice and works for any 'now in use' protocol. 122 * 123 * Also, at this point we assume that we ARE dealing exclusively with 124 * VLAN packets, or packets that should be made into VLAN packets based 125 * on a default VLAN ID. 126 * 127 * NOTE: Should be similar to ethernet/eth.c. 128 * 129 * SANITY NOTE: This method is called when a packet is moving up the stack 130 * towards userland. To get here, it would have already passed 131 * through the ethernet/eth.c eth_type_trans() method. 132 * SANITY NOTE 2: We are referencing to the VLAN_HDR frields, which MAY be 133 * stored UNALIGNED in the memory. RISC systems don't like 134 * such cases very much... 135 * SANITY NOTE 2a: According to Dave Miller & Alexey, it will always be 136 * aligned, so there doesn't need to be any of the unaligned 137 * stuff. It has been commented out now... --Ben 138 * 139 */ 140 int vlan_skb_recv(struct sk_buff *skb, struct net_device *dev, 141 struct packet_type *ptype, struct net_device *orig_dev) 142 { 143 struct vlan_hdr *vhdr; 144 struct vlan_rx_stats *rx_stats; 145 u16 vlan_id; 146 u16 vlan_tci; 147 148 skb = skb_share_check(skb, GFP_ATOMIC); 149 if (skb == NULL) 150 goto err_free; 151 152 if (unlikely(!pskb_may_pull(skb, VLAN_HLEN))) 153 goto err_free; 154 155 vhdr = (struct vlan_hdr *)skb->data; 156 vlan_tci = ntohs(vhdr->h_vlan_TCI); 157 vlan_id = vlan_tci & VLAN_VID_MASK; 158 159 rcu_read_lock(); 160 skb->dev = __find_vlan_dev(dev, vlan_id); 161 if (!skb->dev) { 162 pr_debug("%s: ERROR: No net_device for VID: %u on dev: %s\n", 163 __func__, vlan_id, dev->name); 164 goto err_unlock; 165 } 166 167 rx_stats = per_cpu_ptr(vlan_dev_info(skb->dev)->vlan_rx_stats, 168 smp_processor_id()); 169 rx_stats->rx_packets++; 170 rx_stats->rx_bytes += skb->len; 171 172 skb_pull_rcsum(skb, VLAN_HLEN); 173 174 skb->priority = vlan_get_ingress_priority(skb->dev, vlan_tci); 175 176 pr_debug("%s: priority: %u for TCI: %hu\n", 177 __func__, skb->priority, vlan_tci); 178 179 switch (skb->pkt_type) { 180 case PACKET_BROADCAST: /* Yeah, stats collect these together.. */ 181 /* stats->broadcast ++; // no such counter :-( */ 182 break; 183 184 case PACKET_MULTICAST: 185 rx_stats->multicast++; 186 break; 187 188 case PACKET_OTHERHOST: 189 /* Our lower layer thinks this is not local, let's make sure. 190 * This allows the VLAN to have a different MAC than the 191 * underlying device, and still route correctly. 192 */ 193 if (!compare_ether_addr(eth_hdr(skb)->h_dest, 194 skb->dev->dev_addr)) 195 skb->pkt_type = PACKET_HOST; 196 break; 197 default: 198 break; 199 } 200 201 vlan_set_encap_proto(skb, vhdr); 202 203 skb = vlan_check_reorder_header(skb); 204 if (!skb) { 205 rx_stats->rx_errors++; 206 goto err_unlock; 207 } 208 209 netif_rx(skb); 210 rcu_read_unlock(); 211 return NET_RX_SUCCESS; 212 213 err_unlock: 214 rcu_read_unlock(); 215 err_free: 216 kfree_skb(skb); 217 return NET_RX_DROP; 218 } 219 220 static inline u16 221 vlan_dev_get_egress_qos_mask(struct net_device *dev, struct sk_buff *skb) 222 { 223 struct vlan_priority_tci_mapping *mp; 224 225 mp = vlan_dev_info(dev)->egress_priority_map[(skb->priority & 0xF)]; 226 while (mp) { 227 if (mp->priority == skb->priority) { 228 return mp->vlan_qos; /* This should already be shifted 229 * to mask correctly with the 230 * VLAN's TCI */ 231 } 232 mp = mp->next; 233 } 234 return 0; 235 } 236 237 /* 238 * Create the VLAN header for an arbitrary protocol layer 239 * 240 * saddr=NULL means use device source address 241 * daddr=NULL means leave destination address (eg unresolved arp) 242 * 243 * This is called when the SKB is moving down the stack towards the 244 * physical devices. 245 */ 246 static int vlan_dev_hard_header(struct sk_buff *skb, struct net_device *dev, 247 unsigned short type, 248 const void *daddr, const void *saddr, 249 unsigned int len) 250 { 251 struct vlan_hdr *vhdr; 252 unsigned int vhdrlen = 0; 253 u16 vlan_tci = 0; 254 int rc; 255 256 if (WARN_ON(skb_headroom(skb) < dev->hard_header_len)) 257 return -ENOSPC; 258 259 if (!(vlan_dev_info(dev)->flags & VLAN_FLAG_REORDER_HDR)) { 260 vhdr = (struct vlan_hdr *) skb_push(skb, VLAN_HLEN); 261 262 vlan_tci = vlan_dev_info(dev)->vlan_id; 263 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb); 264 vhdr->h_vlan_TCI = htons(vlan_tci); 265 266 /* 267 * Set the protocol type. For a packet of type ETH_P_802_3/2 we 268 * put the length in here instead. 269 */ 270 if (type != ETH_P_802_3 && type != ETH_P_802_2) 271 vhdr->h_vlan_encapsulated_proto = htons(type); 272 else 273 vhdr->h_vlan_encapsulated_proto = htons(len); 274 275 skb->protocol = htons(ETH_P_8021Q); 276 type = ETH_P_8021Q; 277 vhdrlen = VLAN_HLEN; 278 } 279 280 /* Before delegating work to the lower layer, enter our MAC-address */ 281 if (saddr == NULL) 282 saddr = dev->dev_addr; 283 284 /* Now make the underlying real hard header */ 285 dev = vlan_dev_info(dev)->real_dev; 286 rc = dev_hard_header(skb, dev, type, daddr, saddr, len + vhdrlen); 287 if (rc > 0) 288 rc += vhdrlen; 289 return rc; 290 } 291 292 static netdev_tx_t vlan_dev_hard_start_xmit(struct sk_buff *skb, 293 struct net_device *dev) 294 { 295 int i = skb_get_queue_mapping(skb); 296 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 297 struct vlan_ethhdr *veth = (struct vlan_ethhdr *)(skb->data); 298 unsigned int len; 299 int ret; 300 301 /* Handle non-VLAN frames if they are sent to us, for example by DHCP. 302 * 303 * NOTE: THIS ASSUMES DIX ETHERNET, SPECIFICALLY NOT SUPPORTING 304 * OTHER THINGS LIKE FDDI/TokenRing/802.3 SNAPs... 305 */ 306 if (veth->h_vlan_proto != htons(ETH_P_8021Q) || 307 vlan_dev_info(dev)->flags & VLAN_FLAG_REORDER_HDR) { 308 unsigned int orig_headroom = skb_headroom(skb); 309 u16 vlan_tci; 310 311 vlan_dev_info(dev)->cnt_encap_on_xmit++; 312 313 vlan_tci = vlan_dev_info(dev)->vlan_id; 314 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb); 315 skb = __vlan_put_tag(skb, vlan_tci); 316 if (!skb) { 317 txq->tx_dropped++; 318 return NETDEV_TX_OK; 319 } 320 321 if (orig_headroom < VLAN_HLEN) 322 vlan_dev_info(dev)->cnt_inc_headroom_on_tx++; 323 } 324 325 326 skb_set_dev(skb, vlan_dev_info(dev)->real_dev); 327 len = skb->len; 328 ret = dev_queue_xmit(skb); 329 330 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { 331 txq->tx_packets++; 332 txq->tx_bytes += len; 333 } else 334 txq->tx_dropped++; 335 336 return ret; 337 } 338 339 static netdev_tx_t vlan_dev_hwaccel_hard_start_xmit(struct sk_buff *skb, 340 struct net_device *dev) 341 { 342 int i = skb_get_queue_mapping(skb); 343 struct netdev_queue *txq = netdev_get_tx_queue(dev, i); 344 u16 vlan_tci; 345 unsigned int len; 346 int ret; 347 348 vlan_tci = vlan_dev_info(dev)->vlan_id; 349 vlan_tci |= vlan_dev_get_egress_qos_mask(dev, skb); 350 skb = __vlan_hwaccel_put_tag(skb, vlan_tci); 351 352 skb->dev = vlan_dev_info(dev)->real_dev; 353 len = skb->len; 354 ret = dev_queue_xmit(skb); 355 356 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { 357 txq->tx_packets++; 358 txq->tx_bytes += len; 359 } else 360 txq->tx_dropped++; 361 362 return ret; 363 } 364 365 static u16 vlan_dev_select_queue(struct net_device *dev, struct sk_buff *skb) 366 { 367 struct net_device *rdev = vlan_dev_info(dev)->real_dev; 368 const struct net_device_ops *ops = rdev->netdev_ops; 369 370 return ops->ndo_select_queue(rdev, skb); 371 } 372 373 static int vlan_dev_change_mtu(struct net_device *dev, int new_mtu) 374 { 375 /* TODO: gotta make sure the underlying layer can handle it, 376 * maybe an IFF_VLAN_CAPABLE flag for devices? 377 */ 378 if (vlan_dev_info(dev)->real_dev->mtu < new_mtu) 379 return -ERANGE; 380 381 dev->mtu = new_mtu; 382 383 return 0; 384 } 385 386 void vlan_dev_set_ingress_priority(const struct net_device *dev, 387 u32 skb_prio, u16 vlan_prio) 388 { 389 struct vlan_dev_info *vlan = vlan_dev_info(dev); 390 391 if (vlan->ingress_priority_map[vlan_prio & 0x7] && !skb_prio) 392 vlan->nr_ingress_mappings--; 393 else if (!vlan->ingress_priority_map[vlan_prio & 0x7] && skb_prio) 394 vlan->nr_ingress_mappings++; 395 396 vlan->ingress_priority_map[vlan_prio & 0x7] = skb_prio; 397 } 398 399 int vlan_dev_set_egress_priority(const struct net_device *dev, 400 u32 skb_prio, u16 vlan_prio) 401 { 402 struct vlan_dev_info *vlan = vlan_dev_info(dev); 403 struct vlan_priority_tci_mapping *mp = NULL; 404 struct vlan_priority_tci_mapping *np; 405 u32 vlan_qos = (vlan_prio << VLAN_PRIO_SHIFT) & VLAN_PRIO_MASK; 406 407 /* See if a priority mapping exists.. */ 408 mp = vlan->egress_priority_map[skb_prio & 0xF]; 409 while (mp) { 410 if (mp->priority == skb_prio) { 411 if (mp->vlan_qos && !vlan_qos) 412 vlan->nr_egress_mappings--; 413 else if (!mp->vlan_qos && vlan_qos) 414 vlan->nr_egress_mappings++; 415 mp->vlan_qos = vlan_qos; 416 return 0; 417 } 418 mp = mp->next; 419 } 420 421 /* Create a new mapping then. */ 422 mp = vlan->egress_priority_map[skb_prio & 0xF]; 423 np = kmalloc(sizeof(struct vlan_priority_tci_mapping), GFP_KERNEL); 424 if (!np) 425 return -ENOBUFS; 426 427 np->next = mp; 428 np->priority = skb_prio; 429 np->vlan_qos = vlan_qos; 430 vlan->egress_priority_map[skb_prio & 0xF] = np; 431 if (vlan_qos) 432 vlan->nr_egress_mappings++; 433 return 0; 434 } 435 436 /* Flags are defined in the vlan_flags enum in include/linux/if_vlan.h file. */ 437 int vlan_dev_change_flags(const struct net_device *dev, u32 flags, u32 mask) 438 { 439 struct vlan_dev_info *vlan = vlan_dev_info(dev); 440 u32 old_flags = vlan->flags; 441 442 if (mask & ~(VLAN_FLAG_REORDER_HDR | VLAN_FLAG_GVRP | 443 VLAN_FLAG_LOOSE_BINDING)) 444 return -EINVAL; 445 446 vlan->flags = (old_flags & ~mask) | (flags & mask); 447 448 if (netif_running(dev) && (vlan->flags ^ old_flags) & VLAN_FLAG_GVRP) { 449 if (vlan->flags & VLAN_FLAG_GVRP) 450 vlan_gvrp_request_join(dev); 451 else 452 vlan_gvrp_request_leave(dev); 453 } 454 return 0; 455 } 456 457 void vlan_dev_get_realdev_name(const struct net_device *dev, char *result) 458 { 459 strncpy(result, vlan_dev_info(dev)->real_dev->name, 23); 460 } 461 462 static int vlan_dev_open(struct net_device *dev) 463 { 464 struct vlan_dev_info *vlan = vlan_dev_info(dev); 465 struct net_device *real_dev = vlan->real_dev; 466 int err; 467 468 if (!(real_dev->flags & IFF_UP) && 469 !(vlan->flags & VLAN_FLAG_LOOSE_BINDING)) 470 return -ENETDOWN; 471 472 if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr)) { 473 err = dev_uc_add(real_dev, dev->dev_addr); 474 if (err < 0) 475 goto out; 476 } 477 478 if (dev->flags & IFF_ALLMULTI) { 479 err = dev_set_allmulti(real_dev, 1); 480 if (err < 0) 481 goto del_unicast; 482 } 483 if (dev->flags & IFF_PROMISC) { 484 err = dev_set_promiscuity(real_dev, 1); 485 if (err < 0) 486 goto clear_allmulti; 487 } 488 489 memcpy(vlan->real_dev_addr, real_dev->dev_addr, ETH_ALEN); 490 491 if (vlan->flags & VLAN_FLAG_GVRP) 492 vlan_gvrp_request_join(dev); 493 494 netif_carrier_on(dev); 495 return 0; 496 497 clear_allmulti: 498 if (dev->flags & IFF_ALLMULTI) 499 dev_set_allmulti(real_dev, -1); 500 del_unicast: 501 if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr)) 502 dev_uc_del(real_dev, dev->dev_addr); 503 out: 504 netif_carrier_off(dev); 505 return err; 506 } 507 508 static int vlan_dev_stop(struct net_device *dev) 509 { 510 struct vlan_dev_info *vlan = vlan_dev_info(dev); 511 struct net_device *real_dev = vlan->real_dev; 512 513 if (vlan->flags & VLAN_FLAG_GVRP) 514 vlan_gvrp_request_leave(dev); 515 516 dev_mc_unsync(real_dev, dev); 517 dev_uc_unsync(real_dev, dev); 518 if (dev->flags & IFF_ALLMULTI) 519 dev_set_allmulti(real_dev, -1); 520 if (dev->flags & IFF_PROMISC) 521 dev_set_promiscuity(real_dev, -1); 522 523 if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr)) 524 dev_uc_del(real_dev, dev->dev_addr); 525 526 netif_carrier_off(dev); 527 return 0; 528 } 529 530 static int vlan_dev_set_mac_address(struct net_device *dev, void *p) 531 { 532 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 533 struct sockaddr *addr = p; 534 int err; 535 536 if (!is_valid_ether_addr(addr->sa_data)) 537 return -EADDRNOTAVAIL; 538 539 if (!(dev->flags & IFF_UP)) 540 goto out; 541 542 if (compare_ether_addr(addr->sa_data, real_dev->dev_addr)) { 543 err = dev_uc_add(real_dev, addr->sa_data); 544 if (err < 0) 545 return err; 546 } 547 548 if (compare_ether_addr(dev->dev_addr, real_dev->dev_addr)) 549 dev_uc_del(real_dev, dev->dev_addr); 550 551 out: 552 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 553 return 0; 554 } 555 556 static int vlan_dev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd) 557 { 558 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 559 const struct net_device_ops *ops = real_dev->netdev_ops; 560 struct ifreq ifrr; 561 int err = -EOPNOTSUPP; 562 563 strncpy(ifrr.ifr_name, real_dev->name, IFNAMSIZ); 564 ifrr.ifr_ifru = ifr->ifr_ifru; 565 566 switch (cmd) { 567 case SIOCGMIIPHY: 568 case SIOCGMIIREG: 569 case SIOCSMIIREG: 570 if (netif_device_present(real_dev) && ops->ndo_do_ioctl) 571 err = ops->ndo_do_ioctl(real_dev, &ifrr, cmd); 572 break; 573 } 574 575 if (!err) 576 ifr->ifr_ifru = ifrr.ifr_ifru; 577 578 return err; 579 } 580 581 static int vlan_dev_neigh_setup(struct net_device *dev, struct neigh_parms *pa) 582 { 583 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 584 const struct net_device_ops *ops = real_dev->netdev_ops; 585 int err = 0; 586 587 if (netif_device_present(real_dev) && ops->ndo_neigh_setup) 588 err = ops->ndo_neigh_setup(real_dev, pa); 589 590 return err; 591 } 592 593 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 594 static int vlan_dev_fcoe_ddp_setup(struct net_device *dev, u16 xid, 595 struct scatterlist *sgl, unsigned int sgc) 596 { 597 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 598 const struct net_device_ops *ops = real_dev->netdev_ops; 599 int rc = 0; 600 601 if (ops->ndo_fcoe_ddp_setup) 602 rc = ops->ndo_fcoe_ddp_setup(real_dev, xid, sgl, sgc); 603 604 return rc; 605 } 606 607 static int vlan_dev_fcoe_ddp_done(struct net_device *dev, u16 xid) 608 { 609 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 610 const struct net_device_ops *ops = real_dev->netdev_ops; 611 int len = 0; 612 613 if (ops->ndo_fcoe_ddp_done) 614 len = ops->ndo_fcoe_ddp_done(real_dev, xid); 615 616 return len; 617 } 618 619 static int vlan_dev_fcoe_enable(struct net_device *dev) 620 { 621 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 622 const struct net_device_ops *ops = real_dev->netdev_ops; 623 int rc = -EINVAL; 624 625 if (ops->ndo_fcoe_enable) 626 rc = ops->ndo_fcoe_enable(real_dev); 627 return rc; 628 } 629 630 static int vlan_dev_fcoe_disable(struct net_device *dev) 631 { 632 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 633 const struct net_device_ops *ops = real_dev->netdev_ops; 634 int rc = -EINVAL; 635 636 if (ops->ndo_fcoe_disable) 637 rc = ops->ndo_fcoe_disable(real_dev); 638 return rc; 639 } 640 641 static int vlan_dev_fcoe_get_wwn(struct net_device *dev, u64 *wwn, int type) 642 { 643 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 644 const struct net_device_ops *ops = real_dev->netdev_ops; 645 int rc = -EINVAL; 646 647 if (ops->ndo_fcoe_get_wwn) 648 rc = ops->ndo_fcoe_get_wwn(real_dev, wwn, type); 649 return rc; 650 } 651 #endif 652 653 static void vlan_dev_change_rx_flags(struct net_device *dev, int change) 654 { 655 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 656 657 if (change & IFF_ALLMULTI) 658 dev_set_allmulti(real_dev, dev->flags & IFF_ALLMULTI ? 1 : -1); 659 if (change & IFF_PROMISC) 660 dev_set_promiscuity(real_dev, dev->flags & IFF_PROMISC ? 1 : -1); 661 } 662 663 static void vlan_dev_set_rx_mode(struct net_device *vlan_dev) 664 { 665 dev_mc_sync(vlan_dev_info(vlan_dev)->real_dev, vlan_dev); 666 dev_uc_sync(vlan_dev_info(vlan_dev)->real_dev, vlan_dev); 667 } 668 669 /* 670 * vlan network devices have devices nesting below it, and are a special 671 * "super class" of normal network devices; split their locks off into a 672 * separate class since they always nest. 673 */ 674 static struct lock_class_key vlan_netdev_xmit_lock_key; 675 static struct lock_class_key vlan_netdev_addr_lock_key; 676 677 static void vlan_dev_set_lockdep_one(struct net_device *dev, 678 struct netdev_queue *txq, 679 void *_subclass) 680 { 681 lockdep_set_class_and_subclass(&txq->_xmit_lock, 682 &vlan_netdev_xmit_lock_key, 683 *(int *)_subclass); 684 } 685 686 static void vlan_dev_set_lockdep_class(struct net_device *dev, int subclass) 687 { 688 lockdep_set_class_and_subclass(&dev->addr_list_lock, 689 &vlan_netdev_addr_lock_key, 690 subclass); 691 netdev_for_each_tx_queue(dev, vlan_dev_set_lockdep_one, &subclass); 692 } 693 694 static const struct header_ops vlan_header_ops = { 695 .create = vlan_dev_hard_header, 696 .rebuild = vlan_dev_rebuild_header, 697 .parse = eth_header_parse, 698 }; 699 700 static const struct net_device_ops vlan_netdev_ops, vlan_netdev_accel_ops, 701 vlan_netdev_ops_sq, vlan_netdev_accel_ops_sq; 702 703 static int vlan_dev_init(struct net_device *dev) 704 { 705 struct net_device *real_dev = vlan_dev_info(dev)->real_dev; 706 int subclass = 0; 707 708 netif_carrier_off(dev); 709 710 /* IFF_BROADCAST|IFF_MULTICAST; ??? */ 711 dev->flags = real_dev->flags & ~(IFF_UP | IFF_PROMISC | IFF_ALLMULTI | 712 IFF_MASTER | IFF_SLAVE); 713 dev->iflink = real_dev->ifindex; 714 dev->state = (real_dev->state & ((1<<__LINK_STATE_NOCARRIER) | 715 (1<<__LINK_STATE_DORMANT))) | 716 (1<<__LINK_STATE_PRESENT); 717 718 dev->features |= real_dev->features & real_dev->vlan_features; 719 dev->gso_max_size = real_dev->gso_max_size; 720 721 /* ipv6 shared card related stuff */ 722 dev->dev_id = real_dev->dev_id; 723 724 if (is_zero_ether_addr(dev->dev_addr)) 725 memcpy(dev->dev_addr, real_dev->dev_addr, dev->addr_len); 726 if (is_zero_ether_addr(dev->broadcast)) 727 memcpy(dev->broadcast, real_dev->broadcast, dev->addr_len); 728 729 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 730 dev->fcoe_ddp_xid = real_dev->fcoe_ddp_xid; 731 #endif 732 733 if (real_dev->features & NETIF_F_HW_VLAN_TX) { 734 dev->header_ops = real_dev->header_ops; 735 dev->hard_header_len = real_dev->hard_header_len; 736 if (real_dev->netdev_ops->ndo_select_queue) 737 dev->netdev_ops = &vlan_netdev_accel_ops_sq; 738 else 739 dev->netdev_ops = &vlan_netdev_accel_ops; 740 } else { 741 dev->header_ops = &vlan_header_ops; 742 dev->hard_header_len = real_dev->hard_header_len + VLAN_HLEN; 743 if (real_dev->netdev_ops->ndo_select_queue) 744 dev->netdev_ops = &vlan_netdev_ops_sq; 745 else 746 dev->netdev_ops = &vlan_netdev_ops; 747 } 748 749 if (is_vlan_dev(real_dev)) 750 subclass = 1; 751 752 vlan_dev_set_lockdep_class(dev, subclass); 753 754 vlan_dev_info(dev)->vlan_rx_stats = alloc_percpu(struct vlan_rx_stats); 755 if (!vlan_dev_info(dev)->vlan_rx_stats) 756 return -ENOMEM; 757 758 return 0; 759 } 760 761 static void vlan_dev_uninit(struct net_device *dev) 762 { 763 struct vlan_priority_tci_mapping *pm; 764 struct vlan_dev_info *vlan = vlan_dev_info(dev); 765 int i; 766 767 free_percpu(vlan->vlan_rx_stats); 768 vlan->vlan_rx_stats = NULL; 769 for (i = 0; i < ARRAY_SIZE(vlan->egress_priority_map); i++) { 770 while ((pm = vlan->egress_priority_map[i]) != NULL) { 771 vlan->egress_priority_map[i] = pm->next; 772 kfree(pm); 773 } 774 } 775 } 776 777 static int vlan_ethtool_get_settings(struct net_device *dev, 778 struct ethtool_cmd *cmd) 779 { 780 const struct vlan_dev_info *vlan = vlan_dev_info(dev); 781 return dev_ethtool_get_settings(vlan->real_dev, cmd); 782 } 783 784 static void vlan_ethtool_get_drvinfo(struct net_device *dev, 785 struct ethtool_drvinfo *info) 786 { 787 strcpy(info->driver, vlan_fullname); 788 strcpy(info->version, vlan_version); 789 strcpy(info->fw_version, "N/A"); 790 } 791 792 static u32 vlan_ethtool_get_rx_csum(struct net_device *dev) 793 { 794 const struct vlan_dev_info *vlan = vlan_dev_info(dev); 795 return dev_ethtool_get_rx_csum(vlan->real_dev); 796 } 797 798 static u32 vlan_ethtool_get_flags(struct net_device *dev) 799 { 800 const struct vlan_dev_info *vlan = vlan_dev_info(dev); 801 return dev_ethtool_get_flags(vlan->real_dev); 802 } 803 804 static struct net_device_stats *vlan_dev_get_stats(struct net_device *dev) 805 { 806 struct net_device_stats *stats = &dev->stats; 807 808 dev_txq_stats_fold(dev, stats); 809 810 if (vlan_dev_info(dev)->vlan_rx_stats) { 811 struct vlan_rx_stats *p, rx = {0}; 812 int i; 813 814 for_each_possible_cpu(i) { 815 p = per_cpu_ptr(vlan_dev_info(dev)->vlan_rx_stats, i); 816 rx.rx_packets += p->rx_packets; 817 rx.rx_bytes += p->rx_bytes; 818 rx.rx_errors += p->rx_errors; 819 rx.multicast += p->multicast; 820 } 821 stats->rx_packets = rx.rx_packets; 822 stats->rx_bytes = rx.rx_bytes; 823 stats->rx_errors = rx.rx_errors; 824 stats->multicast = rx.multicast; 825 } 826 return stats; 827 } 828 829 static const struct ethtool_ops vlan_ethtool_ops = { 830 .get_settings = vlan_ethtool_get_settings, 831 .get_drvinfo = vlan_ethtool_get_drvinfo, 832 .get_link = ethtool_op_get_link, 833 .get_rx_csum = vlan_ethtool_get_rx_csum, 834 .get_flags = vlan_ethtool_get_flags, 835 }; 836 837 static const struct net_device_ops vlan_netdev_ops = { 838 .ndo_change_mtu = vlan_dev_change_mtu, 839 .ndo_init = vlan_dev_init, 840 .ndo_uninit = vlan_dev_uninit, 841 .ndo_open = vlan_dev_open, 842 .ndo_stop = vlan_dev_stop, 843 .ndo_start_xmit = vlan_dev_hard_start_xmit, 844 .ndo_validate_addr = eth_validate_addr, 845 .ndo_set_mac_address = vlan_dev_set_mac_address, 846 .ndo_set_rx_mode = vlan_dev_set_rx_mode, 847 .ndo_set_multicast_list = vlan_dev_set_rx_mode, 848 .ndo_change_rx_flags = vlan_dev_change_rx_flags, 849 .ndo_do_ioctl = vlan_dev_ioctl, 850 .ndo_neigh_setup = vlan_dev_neigh_setup, 851 .ndo_get_stats = vlan_dev_get_stats, 852 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 853 .ndo_fcoe_ddp_setup = vlan_dev_fcoe_ddp_setup, 854 .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done, 855 .ndo_fcoe_enable = vlan_dev_fcoe_enable, 856 .ndo_fcoe_disable = vlan_dev_fcoe_disable, 857 .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, 858 #endif 859 }; 860 861 static const struct net_device_ops vlan_netdev_accel_ops = { 862 .ndo_change_mtu = vlan_dev_change_mtu, 863 .ndo_init = vlan_dev_init, 864 .ndo_uninit = vlan_dev_uninit, 865 .ndo_open = vlan_dev_open, 866 .ndo_stop = vlan_dev_stop, 867 .ndo_start_xmit = vlan_dev_hwaccel_hard_start_xmit, 868 .ndo_validate_addr = eth_validate_addr, 869 .ndo_set_mac_address = vlan_dev_set_mac_address, 870 .ndo_set_rx_mode = vlan_dev_set_rx_mode, 871 .ndo_set_multicast_list = vlan_dev_set_rx_mode, 872 .ndo_change_rx_flags = vlan_dev_change_rx_flags, 873 .ndo_do_ioctl = vlan_dev_ioctl, 874 .ndo_neigh_setup = vlan_dev_neigh_setup, 875 .ndo_get_stats = vlan_dev_get_stats, 876 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 877 .ndo_fcoe_ddp_setup = vlan_dev_fcoe_ddp_setup, 878 .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done, 879 .ndo_fcoe_enable = vlan_dev_fcoe_enable, 880 .ndo_fcoe_disable = vlan_dev_fcoe_disable, 881 .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, 882 #endif 883 }; 884 885 static const struct net_device_ops vlan_netdev_ops_sq = { 886 .ndo_select_queue = vlan_dev_select_queue, 887 .ndo_change_mtu = vlan_dev_change_mtu, 888 .ndo_init = vlan_dev_init, 889 .ndo_uninit = vlan_dev_uninit, 890 .ndo_open = vlan_dev_open, 891 .ndo_stop = vlan_dev_stop, 892 .ndo_start_xmit = vlan_dev_hard_start_xmit, 893 .ndo_validate_addr = eth_validate_addr, 894 .ndo_set_mac_address = vlan_dev_set_mac_address, 895 .ndo_set_rx_mode = vlan_dev_set_rx_mode, 896 .ndo_set_multicast_list = vlan_dev_set_rx_mode, 897 .ndo_change_rx_flags = vlan_dev_change_rx_flags, 898 .ndo_do_ioctl = vlan_dev_ioctl, 899 .ndo_neigh_setup = vlan_dev_neigh_setup, 900 .ndo_get_stats = vlan_dev_get_stats, 901 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 902 .ndo_fcoe_ddp_setup = vlan_dev_fcoe_ddp_setup, 903 .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done, 904 .ndo_fcoe_enable = vlan_dev_fcoe_enable, 905 .ndo_fcoe_disable = vlan_dev_fcoe_disable, 906 .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, 907 #endif 908 }; 909 910 static const struct net_device_ops vlan_netdev_accel_ops_sq = { 911 .ndo_select_queue = vlan_dev_select_queue, 912 .ndo_change_mtu = vlan_dev_change_mtu, 913 .ndo_init = vlan_dev_init, 914 .ndo_uninit = vlan_dev_uninit, 915 .ndo_open = vlan_dev_open, 916 .ndo_stop = vlan_dev_stop, 917 .ndo_start_xmit = vlan_dev_hwaccel_hard_start_xmit, 918 .ndo_validate_addr = eth_validate_addr, 919 .ndo_set_mac_address = vlan_dev_set_mac_address, 920 .ndo_set_rx_mode = vlan_dev_set_rx_mode, 921 .ndo_set_multicast_list = vlan_dev_set_rx_mode, 922 .ndo_change_rx_flags = vlan_dev_change_rx_flags, 923 .ndo_do_ioctl = vlan_dev_ioctl, 924 .ndo_neigh_setup = vlan_dev_neigh_setup, 925 .ndo_get_stats = vlan_dev_get_stats, 926 #if defined(CONFIG_FCOE) || defined(CONFIG_FCOE_MODULE) 927 .ndo_fcoe_ddp_setup = vlan_dev_fcoe_ddp_setup, 928 .ndo_fcoe_ddp_done = vlan_dev_fcoe_ddp_done, 929 .ndo_fcoe_enable = vlan_dev_fcoe_enable, 930 .ndo_fcoe_disable = vlan_dev_fcoe_disable, 931 .ndo_fcoe_get_wwn = vlan_dev_fcoe_get_wwn, 932 #endif 933 }; 934 935 void vlan_setup(struct net_device *dev) 936 { 937 ether_setup(dev); 938 939 dev->priv_flags |= IFF_802_1Q_VLAN; 940 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 941 dev->tx_queue_len = 0; 942 943 dev->netdev_ops = &vlan_netdev_ops; 944 dev->destructor = free_netdev; 945 dev->ethtool_ops = &vlan_ethtool_ops; 946 947 memset(dev->broadcast, 0, ETH_ALEN); 948 } 949