1 /* 2 * Copyright (c) 2007 Patrick McHardy <kaber@trash.net> 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License as 6 * published by the Free Software Foundation; either version 2 of 7 * the License, or (at your option) any later version. 8 * 9 * The code this is based on carried the following copyright notice: 10 * --- 11 * (C) Copyright 2001-2006 12 * Alex Zeffertt, Cambridge Broadband Ltd, ajz@cambridgebroadband.com 13 * Re-worked by Ben Greear <greearb@candelatech.com> 14 * --- 15 */ 16 #include <linux/kernel.h> 17 #include <linux/types.h> 18 #include <linux/module.h> 19 #include <linux/init.h> 20 #include <linux/errno.h> 21 #include <linux/slab.h> 22 #include <linux/string.h> 23 #include <linux/rculist.h> 24 #include <linux/notifier.h> 25 #include <linux/netdevice.h> 26 #include <linux/etherdevice.h> 27 #include <linux/ethtool.h> 28 #include <linux/if_arp.h> 29 #include <linux/if_link.h> 30 #include <linux/if_macvlan.h> 31 #include <net/rtnetlink.h> 32 #include <net/xfrm.h> 33 34 #define MACVLAN_HASH_SIZE (1 << BITS_PER_BYTE) 35 36 struct macvlan_port { 37 struct net_device *dev; 38 struct hlist_head vlan_hash[MACVLAN_HASH_SIZE]; 39 struct list_head vlans; 40 struct rcu_head rcu; 41 bool passthru; 42 }; 43 44 #define macvlan_port_get_rcu(dev) \ 45 ((struct macvlan_port *) rcu_dereference(dev->rx_handler_data)) 46 #define macvlan_port_get(dev) ((struct macvlan_port *) dev->rx_handler_data) 47 #define macvlan_port_exists(dev) (dev->priv_flags & IFF_MACVLAN_PORT) 48 49 static struct macvlan_dev *macvlan_hash_lookup(const struct macvlan_port *port, 50 const unsigned char *addr) 51 { 52 struct macvlan_dev *vlan; 53 struct hlist_node *n; 54 55 hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[addr[5]], hlist) { 56 if (!compare_ether_addr_64bits(vlan->dev->dev_addr, addr)) 57 return vlan; 58 } 59 return NULL; 60 } 61 62 static void macvlan_hash_add(struct macvlan_dev *vlan) 63 { 64 struct macvlan_port *port = vlan->port; 65 const unsigned char *addr = vlan->dev->dev_addr; 66 67 hlist_add_head_rcu(&vlan->hlist, &port->vlan_hash[addr[5]]); 68 } 69 70 static void macvlan_hash_del(struct macvlan_dev *vlan) 71 { 72 hlist_del_rcu(&vlan->hlist); 73 synchronize_rcu(); 74 } 75 76 static void macvlan_hash_change_addr(struct macvlan_dev *vlan, 77 const unsigned char *addr) 78 { 79 macvlan_hash_del(vlan); 80 /* Now that we are unhashed it is safe to change the device 81 * address without confusing packet delivery. 82 */ 83 memcpy(vlan->dev->dev_addr, addr, ETH_ALEN); 84 macvlan_hash_add(vlan); 85 } 86 87 static int macvlan_addr_busy(const struct macvlan_port *port, 88 const unsigned char *addr) 89 { 90 /* Test to see if the specified multicast address is 91 * currently in use by the underlying device or 92 * another macvlan. 93 */ 94 if (!compare_ether_addr_64bits(port->dev->dev_addr, addr)) 95 return 1; 96 97 if (macvlan_hash_lookup(port, addr)) 98 return 1; 99 100 return 0; 101 } 102 103 104 static int macvlan_broadcast_one(struct sk_buff *skb, 105 const struct macvlan_dev *vlan, 106 const struct ethhdr *eth, bool local) 107 { 108 struct net_device *dev = vlan->dev; 109 if (!skb) 110 return NET_RX_DROP; 111 112 if (local) 113 return vlan->forward(dev, skb); 114 115 skb->dev = dev; 116 if (!compare_ether_addr_64bits(eth->h_dest, 117 dev->broadcast)) 118 skb->pkt_type = PACKET_BROADCAST; 119 else 120 skb->pkt_type = PACKET_MULTICAST; 121 122 return vlan->receive(skb); 123 } 124 125 static void macvlan_broadcast(struct sk_buff *skb, 126 const struct macvlan_port *port, 127 struct net_device *src, 128 enum macvlan_mode mode) 129 { 130 const struct ethhdr *eth = eth_hdr(skb); 131 const struct macvlan_dev *vlan; 132 struct hlist_node *n; 133 struct sk_buff *nskb; 134 unsigned int i; 135 int err; 136 137 if (skb->protocol == htons(ETH_P_PAUSE)) 138 return; 139 140 for (i = 0; i < MACVLAN_HASH_SIZE; i++) { 141 hlist_for_each_entry_rcu(vlan, n, &port->vlan_hash[i], hlist) { 142 if (vlan->dev == src || !(vlan->mode & mode)) 143 continue; 144 145 nskb = skb_clone(skb, GFP_ATOMIC); 146 err = macvlan_broadcast_one(nskb, vlan, eth, 147 mode == MACVLAN_MODE_BRIDGE); 148 macvlan_count_rx(vlan, skb->len + ETH_HLEN, 149 err == NET_RX_SUCCESS, 1); 150 } 151 } 152 } 153 154 /* called under rcu_read_lock() from netif_receive_skb */ 155 static struct sk_buff *macvlan_handle_frame(struct sk_buff *skb) 156 { 157 struct macvlan_port *port; 158 const struct ethhdr *eth = eth_hdr(skb); 159 const struct macvlan_dev *vlan; 160 const struct macvlan_dev *src; 161 struct net_device *dev; 162 unsigned int len = 0; 163 int ret = NET_RX_DROP; 164 165 port = macvlan_port_get_rcu(skb->dev); 166 if (is_multicast_ether_addr(eth->h_dest)) { 167 src = macvlan_hash_lookup(port, eth->h_source); 168 if (!src) 169 /* frame comes from an external address */ 170 macvlan_broadcast(skb, port, NULL, 171 MACVLAN_MODE_PRIVATE | 172 MACVLAN_MODE_VEPA | 173 MACVLAN_MODE_PASSTHRU| 174 MACVLAN_MODE_BRIDGE); 175 else if (src->mode == MACVLAN_MODE_VEPA) 176 /* flood to everyone except source */ 177 macvlan_broadcast(skb, port, src->dev, 178 MACVLAN_MODE_VEPA | 179 MACVLAN_MODE_BRIDGE); 180 else if (src->mode == MACVLAN_MODE_BRIDGE) 181 /* 182 * flood only to VEPA ports, bridge ports 183 * already saw the frame on the way out. 184 */ 185 macvlan_broadcast(skb, port, src->dev, 186 MACVLAN_MODE_VEPA); 187 return skb; 188 } 189 190 if (port->passthru) 191 vlan = list_first_entry(&port->vlans, struct macvlan_dev, list); 192 else 193 vlan = macvlan_hash_lookup(port, eth->h_dest); 194 if (vlan == NULL) 195 return skb; 196 197 dev = vlan->dev; 198 if (unlikely(!(dev->flags & IFF_UP))) { 199 kfree_skb(skb); 200 return NULL; 201 } 202 len = skb->len + ETH_HLEN; 203 skb = skb_share_check(skb, GFP_ATOMIC); 204 if (!skb) 205 goto out; 206 207 skb->dev = dev; 208 skb->pkt_type = PACKET_HOST; 209 210 ret = vlan->receive(skb); 211 212 out: 213 macvlan_count_rx(vlan, len, ret == NET_RX_SUCCESS, 0); 214 return NULL; 215 } 216 217 static int macvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev) 218 { 219 const struct macvlan_dev *vlan = netdev_priv(dev); 220 const struct macvlan_port *port = vlan->port; 221 const struct macvlan_dev *dest; 222 223 if (vlan->mode == MACVLAN_MODE_BRIDGE) { 224 const struct ethhdr *eth = (void *)skb->data; 225 226 /* send to other bridge ports directly */ 227 if (is_multicast_ether_addr(eth->h_dest)) { 228 macvlan_broadcast(skb, port, dev, MACVLAN_MODE_BRIDGE); 229 goto xmit_world; 230 } 231 232 dest = macvlan_hash_lookup(port, eth->h_dest); 233 if (dest && dest->mode == MACVLAN_MODE_BRIDGE) { 234 unsigned int length = skb->len + ETH_HLEN; 235 int ret = dest->forward(dest->dev, skb); 236 macvlan_count_rx(dest, length, 237 ret == NET_RX_SUCCESS, 0); 238 239 return NET_XMIT_SUCCESS; 240 } 241 } 242 243 xmit_world: 244 skb_set_dev(skb, vlan->lowerdev); 245 return dev_queue_xmit(skb); 246 } 247 248 netdev_tx_t macvlan_start_xmit(struct sk_buff *skb, 249 struct net_device *dev) 250 { 251 unsigned int len = skb->len; 252 int ret; 253 const struct macvlan_dev *vlan = netdev_priv(dev); 254 255 ret = macvlan_queue_xmit(skb, dev); 256 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { 257 struct macvlan_pcpu_stats *pcpu_stats; 258 259 pcpu_stats = this_cpu_ptr(vlan->pcpu_stats); 260 u64_stats_update_begin(&pcpu_stats->syncp); 261 pcpu_stats->tx_packets++; 262 pcpu_stats->tx_bytes += len; 263 u64_stats_update_end(&pcpu_stats->syncp); 264 } else { 265 this_cpu_inc(vlan->pcpu_stats->tx_dropped); 266 } 267 return ret; 268 } 269 EXPORT_SYMBOL_GPL(macvlan_start_xmit); 270 271 static int macvlan_hard_header(struct sk_buff *skb, struct net_device *dev, 272 unsigned short type, const void *daddr, 273 const void *saddr, unsigned len) 274 { 275 const struct macvlan_dev *vlan = netdev_priv(dev); 276 struct net_device *lowerdev = vlan->lowerdev; 277 278 return dev_hard_header(skb, lowerdev, type, daddr, 279 saddr ? : dev->dev_addr, len); 280 } 281 282 static const struct header_ops macvlan_hard_header_ops = { 283 .create = macvlan_hard_header, 284 .rebuild = eth_rebuild_header, 285 .parse = eth_header_parse, 286 .cache = eth_header_cache, 287 .cache_update = eth_header_cache_update, 288 }; 289 290 static int macvlan_open(struct net_device *dev) 291 { 292 struct macvlan_dev *vlan = netdev_priv(dev); 293 struct net_device *lowerdev = vlan->lowerdev; 294 int err; 295 296 if (vlan->port->passthru) { 297 dev_set_promiscuity(lowerdev, 1); 298 goto hash_add; 299 } 300 301 err = -EBUSY; 302 if (macvlan_addr_busy(vlan->port, dev->dev_addr)) 303 goto out; 304 305 err = dev_uc_add(lowerdev, dev->dev_addr); 306 if (err < 0) 307 goto out; 308 if (dev->flags & IFF_ALLMULTI) { 309 err = dev_set_allmulti(lowerdev, 1); 310 if (err < 0) 311 goto del_unicast; 312 } 313 314 hash_add: 315 macvlan_hash_add(vlan); 316 return 0; 317 318 del_unicast: 319 dev_uc_del(lowerdev, dev->dev_addr); 320 out: 321 return err; 322 } 323 324 static int macvlan_stop(struct net_device *dev) 325 { 326 struct macvlan_dev *vlan = netdev_priv(dev); 327 struct net_device *lowerdev = vlan->lowerdev; 328 329 if (vlan->port->passthru) { 330 dev_set_promiscuity(lowerdev, -1); 331 goto hash_del; 332 } 333 334 dev_mc_unsync(lowerdev, dev); 335 if (dev->flags & IFF_ALLMULTI) 336 dev_set_allmulti(lowerdev, -1); 337 338 dev_uc_del(lowerdev, dev->dev_addr); 339 340 hash_del: 341 macvlan_hash_del(vlan); 342 return 0; 343 } 344 345 static int macvlan_set_mac_address(struct net_device *dev, void *p) 346 { 347 struct macvlan_dev *vlan = netdev_priv(dev); 348 struct net_device *lowerdev = vlan->lowerdev; 349 struct sockaddr *addr = p; 350 int err; 351 352 if (!is_valid_ether_addr(addr->sa_data)) 353 return -EADDRNOTAVAIL; 354 355 if (!(dev->flags & IFF_UP)) { 356 /* Just copy in the new address */ 357 memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN); 358 } else { 359 /* Rehash and update the device filters */ 360 if (macvlan_addr_busy(vlan->port, addr->sa_data)) 361 return -EBUSY; 362 363 err = dev_uc_add(lowerdev, addr->sa_data); 364 if (err) 365 return err; 366 367 dev_uc_del(lowerdev, dev->dev_addr); 368 369 macvlan_hash_change_addr(vlan, addr->sa_data); 370 } 371 return 0; 372 } 373 374 static void macvlan_change_rx_flags(struct net_device *dev, int change) 375 { 376 struct macvlan_dev *vlan = netdev_priv(dev); 377 struct net_device *lowerdev = vlan->lowerdev; 378 379 if (change & IFF_ALLMULTI) 380 dev_set_allmulti(lowerdev, dev->flags & IFF_ALLMULTI ? 1 : -1); 381 } 382 383 static void macvlan_set_multicast_list(struct net_device *dev) 384 { 385 struct macvlan_dev *vlan = netdev_priv(dev); 386 387 dev_mc_sync(vlan->lowerdev, dev); 388 } 389 390 static int macvlan_change_mtu(struct net_device *dev, int new_mtu) 391 { 392 struct macvlan_dev *vlan = netdev_priv(dev); 393 394 if (new_mtu < 68 || vlan->lowerdev->mtu < new_mtu) 395 return -EINVAL; 396 dev->mtu = new_mtu; 397 return 0; 398 } 399 400 /* 401 * macvlan network devices have devices nesting below it and are a special 402 * "super class" of normal network devices; split their locks off into a 403 * separate class since they always nest. 404 */ 405 static struct lock_class_key macvlan_netdev_xmit_lock_key; 406 static struct lock_class_key macvlan_netdev_addr_lock_key; 407 408 #define MACVLAN_FEATURES \ 409 (NETIF_F_SG | NETIF_F_ALL_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \ 410 NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_GSO_ROBUST | \ 411 NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO) 412 413 #define MACVLAN_STATE_MASK \ 414 ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT)) 415 416 static void macvlan_set_lockdep_class_one(struct net_device *dev, 417 struct netdev_queue *txq, 418 void *_unused) 419 { 420 lockdep_set_class(&txq->_xmit_lock, 421 &macvlan_netdev_xmit_lock_key); 422 } 423 424 static void macvlan_set_lockdep_class(struct net_device *dev) 425 { 426 lockdep_set_class(&dev->addr_list_lock, 427 &macvlan_netdev_addr_lock_key); 428 netdev_for_each_tx_queue(dev, macvlan_set_lockdep_class_one, NULL); 429 } 430 431 static int macvlan_init(struct net_device *dev) 432 { 433 struct macvlan_dev *vlan = netdev_priv(dev); 434 const struct net_device *lowerdev = vlan->lowerdev; 435 436 dev->state = (dev->state & ~MACVLAN_STATE_MASK) | 437 (lowerdev->state & MACVLAN_STATE_MASK); 438 dev->features = lowerdev->features & MACVLAN_FEATURES; 439 dev->features |= NETIF_F_LLTX; 440 dev->gso_max_size = lowerdev->gso_max_size; 441 dev->iflink = lowerdev->ifindex; 442 dev->hard_header_len = lowerdev->hard_header_len; 443 444 macvlan_set_lockdep_class(dev); 445 446 vlan->pcpu_stats = alloc_percpu(struct macvlan_pcpu_stats); 447 if (!vlan->pcpu_stats) 448 return -ENOMEM; 449 450 return 0; 451 } 452 453 static void macvlan_uninit(struct net_device *dev) 454 { 455 struct macvlan_dev *vlan = netdev_priv(dev); 456 457 free_percpu(vlan->pcpu_stats); 458 } 459 460 static struct rtnl_link_stats64 *macvlan_dev_get_stats64(struct net_device *dev, 461 struct rtnl_link_stats64 *stats) 462 { 463 struct macvlan_dev *vlan = netdev_priv(dev); 464 465 if (vlan->pcpu_stats) { 466 struct macvlan_pcpu_stats *p; 467 u64 rx_packets, rx_bytes, rx_multicast, tx_packets, tx_bytes; 468 u32 rx_errors = 0, tx_dropped = 0; 469 unsigned int start; 470 int i; 471 472 for_each_possible_cpu(i) { 473 p = per_cpu_ptr(vlan->pcpu_stats, i); 474 do { 475 start = u64_stats_fetch_begin_bh(&p->syncp); 476 rx_packets = p->rx_packets; 477 rx_bytes = p->rx_bytes; 478 rx_multicast = p->rx_multicast; 479 tx_packets = p->tx_packets; 480 tx_bytes = p->tx_bytes; 481 } while (u64_stats_fetch_retry_bh(&p->syncp, start)); 482 483 stats->rx_packets += rx_packets; 484 stats->rx_bytes += rx_bytes; 485 stats->multicast += rx_multicast; 486 stats->tx_packets += tx_packets; 487 stats->tx_bytes += tx_bytes; 488 /* rx_errors & tx_dropped are u32, updated 489 * without syncp protection. 490 */ 491 rx_errors += p->rx_errors; 492 tx_dropped += p->tx_dropped; 493 } 494 stats->rx_errors = rx_errors; 495 stats->rx_dropped = rx_errors; 496 stats->tx_dropped = tx_dropped; 497 } 498 return stats; 499 } 500 501 static void macvlan_ethtool_get_drvinfo(struct net_device *dev, 502 struct ethtool_drvinfo *drvinfo) 503 { 504 snprintf(drvinfo->driver, 32, "macvlan"); 505 snprintf(drvinfo->version, 32, "0.1"); 506 } 507 508 static u32 macvlan_ethtool_get_rx_csum(struct net_device *dev) 509 { 510 const struct macvlan_dev *vlan = netdev_priv(dev); 511 return dev_ethtool_get_rx_csum(vlan->lowerdev); 512 } 513 514 static int macvlan_ethtool_get_settings(struct net_device *dev, 515 struct ethtool_cmd *cmd) 516 { 517 const struct macvlan_dev *vlan = netdev_priv(dev); 518 return dev_ethtool_get_settings(vlan->lowerdev, cmd); 519 } 520 521 static u32 macvlan_ethtool_get_flags(struct net_device *dev) 522 { 523 const struct macvlan_dev *vlan = netdev_priv(dev); 524 return dev_ethtool_get_flags(vlan->lowerdev); 525 } 526 527 static const struct ethtool_ops macvlan_ethtool_ops = { 528 .get_link = ethtool_op_get_link, 529 .get_settings = macvlan_ethtool_get_settings, 530 .get_rx_csum = macvlan_ethtool_get_rx_csum, 531 .get_drvinfo = macvlan_ethtool_get_drvinfo, 532 .get_flags = macvlan_ethtool_get_flags, 533 }; 534 535 static const struct net_device_ops macvlan_netdev_ops = { 536 .ndo_init = macvlan_init, 537 .ndo_uninit = macvlan_uninit, 538 .ndo_open = macvlan_open, 539 .ndo_stop = macvlan_stop, 540 .ndo_start_xmit = macvlan_start_xmit, 541 .ndo_change_mtu = macvlan_change_mtu, 542 .ndo_change_rx_flags = macvlan_change_rx_flags, 543 .ndo_set_mac_address = macvlan_set_mac_address, 544 .ndo_set_multicast_list = macvlan_set_multicast_list, 545 .ndo_get_stats64 = macvlan_dev_get_stats64, 546 .ndo_validate_addr = eth_validate_addr, 547 }; 548 549 void macvlan_common_setup(struct net_device *dev) 550 { 551 ether_setup(dev); 552 553 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 554 dev->netdev_ops = &macvlan_netdev_ops; 555 dev->destructor = free_netdev; 556 dev->header_ops = &macvlan_hard_header_ops, 557 dev->ethtool_ops = &macvlan_ethtool_ops; 558 } 559 EXPORT_SYMBOL_GPL(macvlan_common_setup); 560 561 static void macvlan_setup(struct net_device *dev) 562 { 563 macvlan_common_setup(dev); 564 dev->tx_queue_len = 0; 565 } 566 567 static int macvlan_port_create(struct net_device *dev) 568 { 569 struct macvlan_port *port; 570 unsigned int i; 571 int err; 572 573 if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK) 574 return -EINVAL; 575 576 port = kzalloc(sizeof(*port), GFP_KERNEL); 577 if (port == NULL) 578 return -ENOMEM; 579 580 port->passthru = false; 581 port->dev = dev; 582 INIT_LIST_HEAD(&port->vlans); 583 for (i = 0; i < MACVLAN_HASH_SIZE; i++) 584 INIT_HLIST_HEAD(&port->vlan_hash[i]); 585 586 err = netdev_rx_handler_register(dev, macvlan_handle_frame, port); 587 if (err) 588 kfree(port); 589 590 dev->priv_flags |= IFF_MACVLAN_PORT; 591 return err; 592 } 593 594 static void macvlan_port_rcu_free(struct rcu_head *head) 595 { 596 struct macvlan_port *port; 597 598 port = container_of(head, struct macvlan_port, rcu); 599 kfree(port); 600 } 601 602 static void macvlan_port_destroy(struct net_device *dev) 603 { 604 struct macvlan_port *port = macvlan_port_get(dev); 605 606 dev->priv_flags &= ~IFF_MACVLAN_PORT; 607 netdev_rx_handler_unregister(dev); 608 call_rcu(&port->rcu, macvlan_port_rcu_free); 609 } 610 611 static int macvlan_validate(struct nlattr *tb[], struct nlattr *data[]) 612 { 613 if (tb[IFLA_ADDRESS]) { 614 if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) 615 return -EINVAL; 616 if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) 617 return -EADDRNOTAVAIL; 618 } 619 620 if (data && data[IFLA_MACVLAN_MODE]) { 621 switch (nla_get_u32(data[IFLA_MACVLAN_MODE])) { 622 case MACVLAN_MODE_PRIVATE: 623 case MACVLAN_MODE_VEPA: 624 case MACVLAN_MODE_BRIDGE: 625 case MACVLAN_MODE_PASSTHRU: 626 break; 627 default: 628 return -EINVAL; 629 } 630 } 631 return 0; 632 } 633 634 int macvlan_common_newlink(struct net *src_net, struct net_device *dev, 635 struct nlattr *tb[], struct nlattr *data[], 636 int (*receive)(struct sk_buff *skb), 637 int (*forward)(struct net_device *dev, 638 struct sk_buff *skb)) 639 { 640 struct macvlan_dev *vlan = netdev_priv(dev); 641 struct macvlan_port *port; 642 struct net_device *lowerdev; 643 int err; 644 645 if (!tb[IFLA_LINK]) 646 return -EINVAL; 647 648 lowerdev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 649 if (lowerdev == NULL) 650 return -ENODEV; 651 652 /* When creating macvlans on top of other macvlans - use 653 * the real device as the lowerdev. 654 */ 655 if (lowerdev->rtnl_link_ops == dev->rtnl_link_ops) { 656 struct macvlan_dev *lowervlan = netdev_priv(lowerdev); 657 lowerdev = lowervlan->lowerdev; 658 } 659 660 if (!tb[IFLA_MTU]) 661 dev->mtu = lowerdev->mtu; 662 else if (dev->mtu > lowerdev->mtu) 663 return -EINVAL; 664 665 if (!tb[IFLA_ADDRESS]) 666 random_ether_addr(dev->dev_addr); 667 668 if (!macvlan_port_exists(lowerdev)) { 669 err = macvlan_port_create(lowerdev); 670 if (err < 0) 671 return err; 672 } 673 port = macvlan_port_get(lowerdev); 674 675 /* Only 1 macvlan device can be created in passthru mode */ 676 if (port->passthru) 677 return -EINVAL; 678 679 vlan->lowerdev = lowerdev; 680 vlan->dev = dev; 681 vlan->port = port; 682 vlan->receive = receive; 683 vlan->forward = forward; 684 685 vlan->mode = MACVLAN_MODE_VEPA; 686 if (data && data[IFLA_MACVLAN_MODE]) 687 vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]); 688 689 if (vlan->mode == MACVLAN_MODE_PASSTHRU) { 690 if (!list_empty(&port->vlans)) 691 return -EINVAL; 692 port->passthru = true; 693 memcpy(dev->dev_addr, lowerdev->dev_addr, ETH_ALEN); 694 } 695 696 err = register_netdevice(dev); 697 if (err < 0) 698 goto destroy_port; 699 700 list_add_tail(&vlan->list, &port->vlans); 701 netif_stacked_transfer_operstate(lowerdev, dev); 702 703 return 0; 704 705 destroy_port: 706 if (list_empty(&port->vlans)) 707 macvlan_port_destroy(lowerdev); 708 709 return err; 710 } 711 EXPORT_SYMBOL_GPL(macvlan_common_newlink); 712 713 static int macvlan_newlink(struct net *src_net, struct net_device *dev, 714 struct nlattr *tb[], struct nlattr *data[]) 715 { 716 return macvlan_common_newlink(src_net, dev, tb, data, 717 netif_rx, 718 dev_forward_skb); 719 } 720 721 void macvlan_dellink(struct net_device *dev, struct list_head *head) 722 { 723 struct macvlan_dev *vlan = netdev_priv(dev); 724 struct macvlan_port *port = vlan->port; 725 726 list_del(&vlan->list); 727 unregister_netdevice_queue(dev, head); 728 729 if (list_empty(&port->vlans)) 730 macvlan_port_destroy(port->dev); 731 } 732 EXPORT_SYMBOL_GPL(macvlan_dellink); 733 734 static int macvlan_changelink(struct net_device *dev, 735 struct nlattr *tb[], struct nlattr *data[]) 736 { 737 struct macvlan_dev *vlan = netdev_priv(dev); 738 if (data && data[IFLA_MACVLAN_MODE]) 739 vlan->mode = nla_get_u32(data[IFLA_MACVLAN_MODE]); 740 return 0; 741 } 742 743 static size_t macvlan_get_size(const struct net_device *dev) 744 { 745 return nla_total_size(4); 746 } 747 748 static int macvlan_fill_info(struct sk_buff *skb, 749 const struct net_device *dev) 750 { 751 struct macvlan_dev *vlan = netdev_priv(dev); 752 753 NLA_PUT_U32(skb, IFLA_MACVLAN_MODE, vlan->mode); 754 return 0; 755 756 nla_put_failure: 757 return -EMSGSIZE; 758 } 759 760 static const struct nla_policy macvlan_policy[IFLA_MACVLAN_MAX + 1] = { 761 [IFLA_MACVLAN_MODE] = { .type = NLA_U32 }, 762 }; 763 764 int macvlan_link_register(struct rtnl_link_ops *ops) 765 { 766 /* common fields */ 767 ops->priv_size = sizeof(struct macvlan_dev); 768 ops->validate = macvlan_validate; 769 ops->maxtype = IFLA_MACVLAN_MAX; 770 ops->policy = macvlan_policy; 771 ops->changelink = macvlan_changelink; 772 ops->get_size = macvlan_get_size; 773 ops->fill_info = macvlan_fill_info; 774 775 return rtnl_link_register(ops); 776 }; 777 EXPORT_SYMBOL_GPL(macvlan_link_register); 778 779 static struct rtnl_link_ops macvlan_link_ops = { 780 .kind = "macvlan", 781 .setup = macvlan_setup, 782 .newlink = macvlan_newlink, 783 .dellink = macvlan_dellink, 784 }; 785 786 static int macvlan_device_event(struct notifier_block *unused, 787 unsigned long event, void *ptr) 788 { 789 struct net_device *dev = ptr; 790 struct macvlan_dev *vlan, *next; 791 struct macvlan_port *port; 792 793 if (!macvlan_port_exists(dev)) 794 return NOTIFY_DONE; 795 796 port = macvlan_port_get(dev); 797 798 switch (event) { 799 case NETDEV_CHANGE: 800 list_for_each_entry(vlan, &port->vlans, list) 801 netif_stacked_transfer_operstate(vlan->lowerdev, 802 vlan->dev); 803 break; 804 case NETDEV_FEAT_CHANGE: 805 list_for_each_entry(vlan, &port->vlans, list) { 806 vlan->dev->features = dev->features & MACVLAN_FEATURES; 807 vlan->dev->gso_max_size = dev->gso_max_size; 808 netdev_features_change(vlan->dev); 809 } 810 break; 811 case NETDEV_UNREGISTER: 812 /* twiddle thumbs on netns device moves */ 813 if (dev->reg_state != NETREG_UNREGISTERING) 814 break; 815 816 list_for_each_entry_safe(vlan, next, &port->vlans, list) 817 vlan->dev->rtnl_link_ops->dellink(vlan->dev, NULL); 818 break; 819 case NETDEV_PRE_TYPE_CHANGE: 820 /* Forbid underlaying device to change its type. */ 821 return NOTIFY_BAD; 822 } 823 return NOTIFY_DONE; 824 } 825 826 static struct notifier_block macvlan_notifier_block __read_mostly = { 827 .notifier_call = macvlan_device_event, 828 }; 829 830 static int __init macvlan_init_module(void) 831 { 832 int err; 833 834 register_netdevice_notifier(&macvlan_notifier_block); 835 836 err = macvlan_link_register(&macvlan_link_ops); 837 if (err < 0) 838 goto err1; 839 return 0; 840 err1: 841 unregister_netdevice_notifier(&macvlan_notifier_block); 842 return err; 843 } 844 845 static void __exit macvlan_cleanup_module(void) 846 { 847 rtnl_link_unregister(&macvlan_link_ops); 848 unregister_netdevice_notifier(&macvlan_notifier_block); 849 } 850 851 module_init(macvlan_init_module); 852 module_exit(macvlan_cleanup_module); 853 854 MODULE_LICENSE("GPL"); 855 MODULE_AUTHOR("Patrick McHardy <kaber@trash.net>"); 856 MODULE_DESCRIPTION("Driver for MAC address based VLANs"); 857 MODULE_ALIAS_RTNL_LINK("macvlan"); 858