1088 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/* Copyright (c) 2014 Mahesh Bandewar <maheshb@google.com>3 */4 5#include <linux/ethtool.h>6 7#include "ipvlan.h"8 9static int ipvlan_set_port_mode(struct ipvl_port *port, u16 nval,10 struct netlink_ext_ack *extack)11{12 struct ipvl_dev *ipvlan;13 unsigned int flags;14 int err;15 16 ASSERT_RTNL();17 if (port->mode != nval) {18 list_for_each_entry(ipvlan, &port->ipvlans, pnode) {19 flags = ipvlan->dev->flags;20 if (nval == IPVLAN_MODE_L3 || nval == IPVLAN_MODE_L3S) {21 err = dev_change_flags(ipvlan->dev,22 flags | IFF_NOARP,23 extack);24 } else {25 err = dev_change_flags(ipvlan->dev,26 flags & ~IFF_NOARP,27 extack);28 }29 if (unlikely(err))30 goto fail;31 }32 if (nval == IPVLAN_MODE_L3S) {33 /* New mode is L3S */34 err = ipvlan_l3s_register(port);35 if (err)36 goto fail;37 } else if (port->mode == IPVLAN_MODE_L3S) {38 /* Old mode was L3S */39 ipvlan_l3s_unregister(port);40 }41 port->mode = nval;42 }43 return 0;44 45fail:46 /* Undo the flags changes that have been done so far. */47 list_for_each_entry_continue_reverse(ipvlan, &port->ipvlans, pnode) {48 flags = ipvlan->dev->flags;49 if (port->mode == IPVLAN_MODE_L3 ||50 port->mode == IPVLAN_MODE_L3S)51 dev_change_flags(ipvlan->dev, flags | IFF_NOARP,52 NULL);53 else54 dev_change_flags(ipvlan->dev, flags & ~IFF_NOARP,55 NULL);56 }57 58 return err;59}60 61static int ipvlan_port_create(struct net_device *dev)62{63 struct ipvl_port *port;64 int err, idx;65 66 port = kzalloc(sizeof(struct ipvl_port), GFP_KERNEL);67 if (!port)68 return -ENOMEM;69 70 write_pnet(&port->pnet, dev_net(dev));71 port->dev = dev;72 port->mode = IPVLAN_MODE_L3;73 INIT_LIST_HEAD(&port->ipvlans);74 for (idx = 0; idx < IPVLAN_HASH_SIZE; idx++)75 INIT_HLIST_HEAD(&port->hlhead[idx]);76 77 skb_queue_head_init(&port->backlog);78 INIT_WORK(&port->wq, ipvlan_process_multicast);79 ida_init(&port->ida);80 port->dev_id_start = 1;81 82 err = netdev_rx_handler_register(dev, ipvlan_handle_frame, port);83 if (err)84 goto err;85 86 netdev_hold(dev, &port->dev_tracker, GFP_KERNEL);87 return 0;88 89err:90 kfree(port);91 return err;92}93 94static void ipvlan_port_destroy(struct net_device *dev)95{96 struct ipvl_port *port = ipvlan_port_get_rtnl(dev);97 struct sk_buff *skb;98 99 netdev_put(dev, &port->dev_tracker);100 if (port->mode == IPVLAN_MODE_L3S)101 ipvlan_l3s_unregister(port);102 netdev_rx_handler_unregister(dev);103 cancel_work_sync(&port->wq);104 while ((skb = __skb_dequeue(&port->backlog)) != NULL) {105 dev_put(skb->dev);106 kfree_skb(skb);107 }108 ida_destroy(&port->ida);109 kfree(port);110}111 112#define IPVLAN_ALWAYS_ON_OFLOADS \113 (NETIF_F_SG | NETIF_F_HW_CSUM | \114 NETIF_F_GSO_ROBUST | NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ENCAP_ALL)115 116#define IPVLAN_ALWAYS_ON \117 (IPVLAN_ALWAYS_ON_OFLOADS | NETIF_F_VLAN_CHALLENGED)118 119#define IPVLAN_FEATURES \120 (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \121 NETIF_F_GSO | NETIF_F_ALL_TSO | NETIF_F_GSO_ROBUST | \122 NETIF_F_GRO | NETIF_F_RXCSUM | \123 NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER)124 125 /* NETIF_F_GSO_ENCAP_ALL NETIF_F_GSO_SOFTWARE Newly added */126 127#define IPVLAN_STATE_MASK \128 ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT))129 130static int ipvlan_init(struct net_device *dev)131{132 struct ipvl_dev *ipvlan = netdev_priv(dev);133 struct net_device *phy_dev = ipvlan->phy_dev;134 struct ipvl_port *port;135 int err;136 137 dev->state = (dev->state & ~IPVLAN_STATE_MASK) |138 (phy_dev->state & IPVLAN_STATE_MASK);139 dev->features = phy_dev->features & IPVLAN_FEATURES;140 dev->features |= IPVLAN_ALWAYS_ON;141 dev->vlan_features = phy_dev->vlan_features & IPVLAN_FEATURES;142 dev->vlan_features |= IPVLAN_ALWAYS_ON_OFLOADS;143 dev->hw_enc_features |= dev->features;144 dev->lltx = true;145 netif_inherit_tso_max(dev, phy_dev);146 dev->hard_header_len = phy_dev->hard_header_len;147 148 netdev_lockdep_set_classes(dev);149 150 ipvlan->pcpu_stats = netdev_alloc_pcpu_stats(struct ipvl_pcpu_stats);151 if (!ipvlan->pcpu_stats)152 return -ENOMEM;153 154 if (!netif_is_ipvlan_port(phy_dev)) {155 err = ipvlan_port_create(phy_dev);156 if (err < 0) {157 free_percpu(ipvlan->pcpu_stats);158 return err;159 }160 }161 port = ipvlan_port_get_rtnl(phy_dev);162 port->count += 1;163 return 0;164}165 166static void ipvlan_uninit(struct net_device *dev)167{168 struct ipvl_dev *ipvlan = netdev_priv(dev);169 struct net_device *phy_dev = ipvlan->phy_dev;170 struct ipvl_port *port;171 172 free_percpu(ipvlan->pcpu_stats);173 174 port = ipvlan_port_get_rtnl(phy_dev);175 port->count -= 1;176 if (!port->count)177 ipvlan_port_destroy(port->dev);178}179 180static int ipvlan_open(struct net_device *dev)181{182 struct ipvl_dev *ipvlan = netdev_priv(dev);183 struct ipvl_addr *addr;184 185 if (ipvlan->port->mode == IPVLAN_MODE_L3 ||186 ipvlan->port->mode == IPVLAN_MODE_L3S)187 dev->flags |= IFF_NOARP;188 else189 dev->flags &= ~IFF_NOARP;190 191 rcu_read_lock();192 list_for_each_entry_rcu(addr, &ipvlan->addrs, anode)193 ipvlan_ht_addr_add(ipvlan, addr);194 rcu_read_unlock();195 196 return 0;197}198 199static int ipvlan_stop(struct net_device *dev)200{201 struct ipvl_dev *ipvlan = netdev_priv(dev);202 struct net_device *phy_dev = ipvlan->phy_dev;203 struct ipvl_addr *addr;204 205 dev_uc_unsync(phy_dev, dev);206 dev_mc_unsync(phy_dev, dev);207 208 rcu_read_lock();209 list_for_each_entry_rcu(addr, &ipvlan->addrs, anode)210 ipvlan_ht_addr_del(addr);211 rcu_read_unlock();212 213 return 0;214}215 216static netdev_tx_t ipvlan_start_xmit(struct sk_buff *skb,217 struct net_device *dev)218{219 const struct ipvl_dev *ipvlan = netdev_priv(dev);220 int skblen = skb->len;221 int ret;222 223 ret = ipvlan_queue_xmit(skb, dev);224 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) {225 struct ipvl_pcpu_stats *pcptr;226 227 pcptr = this_cpu_ptr(ipvlan->pcpu_stats);228 229 u64_stats_update_begin(&pcptr->syncp);230 u64_stats_inc(&pcptr->tx_pkts);231 u64_stats_add(&pcptr->tx_bytes, skblen);232 u64_stats_update_end(&pcptr->syncp);233 } else {234 this_cpu_inc(ipvlan->pcpu_stats->tx_drps);235 }236 return ret;237}238 239static netdev_features_t ipvlan_fix_features(struct net_device *dev,240 netdev_features_t features)241{242 struct ipvl_dev *ipvlan = netdev_priv(dev);243 244 features |= NETIF_F_ALL_FOR_ALL;245 features &= (ipvlan->sfeatures | ~IPVLAN_FEATURES);246 features = netdev_increment_features(ipvlan->phy_dev->features,247 features, features);248 features |= IPVLAN_ALWAYS_ON;249 features &= (IPVLAN_FEATURES | IPVLAN_ALWAYS_ON);250 251 return features;252}253 254static void ipvlan_change_rx_flags(struct net_device *dev, int change)255{256 struct ipvl_dev *ipvlan = netdev_priv(dev);257 struct net_device *phy_dev = ipvlan->phy_dev;258 259 if (change & IFF_ALLMULTI)260 dev_set_allmulti(phy_dev, dev->flags & IFF_ALLMULTI? 1 : -1);261}262 263static void ipvlan_set_multicast_mac_filter(struct net_device *dev)264{265 struct ipvl_dev *ipvlan = netdev_priv(dev);266 267 if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {268 bitmap_fill(ipvlan->mac_filters, IPVLAN_MAC_FILTER_SIZE);269 } else {270 struct netdev_hw_addr *ha;271 DECLARE_BITMAP(mc_filters, IPVLAN_MAC_FILTER_SIZE);272 273 bitmap_zero(mc_filters, IPVLAN_MAC_FILTER_SIZE);274 netdev_for_each_mc_addr(ha, dev)275 __set_bit(ipvlan_mac_hash(ha->addr), mc_filters);276 277 /* Turn-on broadcast bit irrespective of address family,278 * since broadcast is deferred to a work-queue, hence no279 * impact on fast-path processing.280 */281 __set_bit(ipvlan_mac_hash(dev->broadcast), mc_filters);282 283 bitmap_copy(ipvlan->mac_filters, mc_filters,284 IPVLAN_MAC_FILTER_SIZE);285 }286 dev_uc_sync(ipvlan->phy_dev, dev);287 dev_mc_sync(ipvlan->phy_dev, dev);288}289 290static void ipvlan_get_stats64(struct net_device *dev,291 struct rtnl_link_stats64 *s)292{293 struct ipvl_dev *ipvlan = netdev_priv(dev);294 295 if (ipvlan->pcpu_stats) {296 struct ipvl_pcpu_stats *pcptr;297 u64 rx_pkts, rx_bytes, rx_mcast, tx_pkts, tx_bytes;298 u32 rx_errs = 0, tx_drps = 0;299 u32 strt;300 int idx;301 302 for_each_possible_cpu(idx) {303 pcptr = per_cpu_ptr(ipvlan->pcpu_stats, idx);304 do {305 strt = u64_stats_fetch_begin(&pcptr->syncp);306 rx_pkts = u64_stats_read(&pcptr->rx_pkts);307 rx_bytes = u64_stats_read(&pcptr->rx_bytes);308 rx_mcast = u64_stats_read(&pcptr->rx_mcast);309 tx_pkts = u64_stats_read(&pcptr->tx_pkts);310 tx_bytes = u64_stats_read(&pcptr->tx_bytes);311 } while (u64_stats_fetch_retry(&pcptr->syncp,312 strt));313 314 s->rx_packets += rx_pkts;315 s->rx_bytes += rx_bytes;316 s->multicast += rx_mcast;317 s->tx_packets += tx_pkts;318 s->tx_bytes += tx_bytes;319 320 /* u32 values are updated without syncp protection. */321 rx_errs += READ_ONCE(pcptr->rx_errs);322 tx_drps += READ_ONCE(pcptr->tx_drps);323 }324 s->rx_errors = rx_errs;325 s->rx_dropped = rx_errs;326 s->tx_dropped = tx_drps;327 }328 s->tx_errors = DEV_STATS_READ(dev, tx_errors);329}330 331static int ipvlan_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid)332{333 struct ipvl_dev *ipvlan = netdev_priv(dev);334 struct net_device *phy_dev = ipvlan->phy_dev;335 336 return vlan_vid_add(phy_dev, proto, vid);337}338 339static int ipvlan_vlan_rx_kill_vid(struct net_device *dev, __be16 proto,340 u16 vid)341{342 struct ipvl_dev *ipvlan = netdev_priv(dev);343 struct net_device *phy_dev = ipvlan->phy_dev;344 345 vlan_vid_del(phy_dev, proto, vid);346 return 0;347}348 349static int ipvlan_get_iflink(const struct net_device *dev)350{351 struct ipvl_dev *ipvlan = netdev_priv(dev);352 353 return READ_ONCE(ipvlan->phy_dev->ifindex);354}355 356static const struct net_device_ops ipvlan_netdev_ops = {357 .ndo_init = ipvlan_init,358 .ndo_uninit = ipvlan_uninit,359 .ndo_open = ipvlan_open,360 .ndo_stop = ipvlan_stop,361 .ndo_start_xmit = ipvlan_start_xmit,362 .ndo_fix_features = ipvlan_fix_features,363 .ndo_change_rx_flags = ipvlan_change_rx_flags,364 .ndo_set_rx_mode = ipvlan_set_multicast_mac_filter,365 .ndo_get_stats64 = ipvlan_get_stats64,366 .ndo_vlan_rx_add_vid = ipvlan_vlan_rx_add_vid,367 .ndo_vlan_rx_kill_vid = ipvlan_vlan_rx_kill_vid,368 .ndo_get_iflink = ipvlan_get_iflink,369};370 371static int ipvlan_hard_header(struct sk_buff *skb, struct net_device *dev,372 unsigned short type, const void *daddr,373 const void *saddr, unsigned len)374{375 const struct ipvl_dev *ipvlan = netdev_priv(dev);376 struct net_device *phy_dev = ipvlan->phy_dev;377 378 /* TODO Probably use a different field than dev_addr so that the379 * mac-address on the virtual device is portable and can be carried380 * while the packets use the mac-addr on the physical device.381 */382 return dev_hard_header(skb, phy_dev, type, daddr,383 saddr ? : phy_dev->dev_addr, len);384}385 386static const struct header_ops ipvlan_header_ops = {387 .create = ipvlan_hard_header,388 .parse = eth_header_parse,389 .cache = eth_header_cache,390 .cache_update = eth_header_cache_update,391 .parse_protocol = eth_header_parse_protocol,392};393 394static void ipvlan_adjust_mtu(struct ipvl_dev *ipvlan, struct net_device *dev)395{396 ipvlan->dev->mtu = dev->mtu;397}398 399static bool netif_is_ipvlan(const struct net_device *dev)400{401 /* both ipvlan and ipvtap devices use the same netdev_ops */402 return dev->netdev_ops == &ipvlan_netdev_ops;403}404 405static int ipvlan_ethtool_get_link_ksettings(struct net_device *dev,406 struct ethtool_link_ksettings *cmd)407{408 const struct ipvl_dev *ipvlan = netdev_priv(dev);409 410 return __ethtool_get_link_ksettings(ipvlan->phy_dev, cmd);411}412 413static void ipvlan_ethtool_get_drvinfo(struct net_device *dev,414 struct ethtool_drvinfo *drvinfo)415{416 strscpy(drvinfo->driver, IPVLAN_DRV, sizeof(drvinfo->driver));417 strscpy(drvinfo->version, IPV_DRV_VER, sizeof(drvinfo->version));418}419 420static u32 ipvlan_ethtool_get_msglevel(struct net_device *dev)421{422 const struct ipvl_dev *ipvlan = netdev_priv(dev);423 424 return ipvlan->msg_enable;425}426 427static void ipvlan_ethtool_set_msglevel(struct net_device *dev, u32 value)428{429 struct ipvl_dev *ipvlan = netdev_priv(dev);430 431 ipvlan->msg_enable = value;432}433 434static const struct ethtool_ops ipvlan_ethtool_ops = {435 .get_link = ethtool_op_get_link,436 .get_link_ksettings = ipvlan_ethtool_get_link_ksettings,437 .get_drvinfo = ipvlan_ethtool_get_drvinfo,438 .get_msglevel = ipvlan_ethtool_get_msglevel,439 .set_msglevel = ipvlan_ethtool_set_msglevel,440};441 442static int ipvlan_nl_changelink(struct net_device *dev,443 struct nlattr *tb[], struct nlattr *data[],444 struct netlink_ext_ack *extack)445{446 struct ipvl_dev *ipvlan = netdev_priv(dev);447 struct ipvl_port *port = ipvlan_port_get_rtnl(ipvlan->phy_dev);448 int err = 0;449 450 if (!data)451 return 0;452 if (!ns_capable(dev_net(ipvlan->phy_dev)->user_ns, CAP_NET_ADMIN))453 return -EPERM;454 455 if (data[IFLA_IPVLAN_MODE]) {456 u16 nmode = nla_get_u16(data[IFLA_IPVLAN_MODE]);457 458 err = ipvlan_set_port_mode(port, nmode, extack);459 }460 461 if (!err && data[IFLA_IPVLAN_FLAGS]) {462 u16 flags = nla_get_u16(data[IFLA_IPVLAN_FLAGS]);463 464 if (flags & IPVLAN_F_PRIVATE)465 ipvlan_mark_private(port);466 else467 ipvlan_clear_private(port);468 469 if (flags & IPVLAN_F_VEPA)470 ipvlan_mark_vepa(port);471 else472 ipvlan_clear_vepa(port);473 }474 475 return err;476}477 478static size_t ipvlan_nl_getsize(const struct net_device *dev)479{480 return (0481 + nla_total_size(2) /* IFLA_IPVLAN_MODE */482 + nla_total_size(2) /* IFLA_IPVLAN_FLAGS */483 );484}485 486static int ipvlan_nl_validate(struct nlattr *tb[], struct nlattr *data[],487 struct netlink_ext_ack *extack)488{489 if (!data)490 return 0;491 492 if (data[IFLA_IPVLAN_MODE]) {493 u16 mode = nla_get_u16(data[IFLA_IPVLAN_MODE]);494 495 if (mode >= IPVLAN_MODE_MAX)496 return -EINVAL;497 }498 if (data[IFLA_IPVLAN_FLAGS]) {499 u16 flags = nla_get_u16(data[IFLA_IPVLAN_FLAGS]);500 501 /* Only two bits are used at this moment. */502 if (flags & ~(IPVLAN_F_PRIVATE | IPVLAN_F_VEPA))503 return -EINVAL;504 /* Also both flags can't be active at the same time. */505 if ((flags & (IPVLAN_F_PRIVATE | IPVLAN_F_VEPA)) ==506 (IPVLAN_F_PRIVATE | IPVLAN_F_VEPA))507 return -EINVAL;508 }509 510 return 0;511}512 513static int ipvlan_nl_fillinfo(struct sk_buff *skb,514 const struct net_device *dev)515{516 struct ipvl_dev *ipvlan = netdev_priv(dev);517 struct ipvl_port *port = ipvlan_port_get_rtnl(ipvlan->phy_dev);518 int ret = -EINVAL;519 520 if (!port)521 goto err;522 523 ret = -EMSGSIZE;524 if (nla_put_u16(skb, IFLA_IPVLAN_MODE, port->mode))525 goto err;526 if (nla_put_u16(skb, IFLA_IPVLAN_FLAGS, port->flags))527 goto err;528 529 return 0;530 531err:532 return ret;533}534 535int ipvlan_link_new(struct net *src_net, struct net_device *dev,536 struct nlattr *tb[], struct nlattr *data[],537 struct netlink_ext_ack *extack)538{539 struct ipvl_dev *ipvlan = netdev_priv(dev);540 struct ipvl_port *port;541 struct net_device *phy_dev;542 int err;543 u16 mode = IPVLAN_MODE_L3;544 545 if (!tb[IFLA_LINK])546 return -EINVAL;547 548 phy_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));549 if (!phy_dev)550 return -ENODEV;551 552 if (netif_is_ipvlan(phy_dev)) {553 struct ipvl_dev *tmp = netdev_priv(phy_dev);554 555 phy_dev = tmp->phy_dev;556 if (!ns_capable(dev_net(phy_dev)->user_ns, CAP_NET_ADMIN))557 return -EPERM;558 } else if (!netif_is_ipvlan_port(phy_dev)) {559 /* Exit early if the underlying link is invalid or busy */560 if (phy_dev->type != ARPHRD_ETHER ||561 phy_dev->flags & IFF_LOOPBACK) {562 netdev_err(phy_dev,563 "Master is either lo or non-ether device\n");564 return -EINVAL;565 }566 567 if (netdev_is_rx_handler_busy(phy_dev)) {568 netdev_err(phy_dev, "Device is already in use.\n");569 return -EBUSY;570 }571 }572 573 ipvlan->phy_dev = phy_dev;574 ipvlan->dev = dev;575 ipvlan->sfeatures = IPVLAN_FEATURES;576 if (!tb[IFLA_MTU])577 ipvlan_adjust_mtu(ipvlan, phy_dev);578 INIT_LIST_HEAD(&ipvlan->addrs);579 spin_lock_init(&ipvlan->addrs_lock);580 581 /* TODO Probably put random address here to be presented to the582 * world but keep using the physical-dev address for the outgoing583 * packets.584 */585 eth_hw_addr_set(dev, phy_dev->dev_addr);586 587 dev->priv_flags |= IFF_NO_RX_HANDLER;588 589 err = register_netdevice(dev);590 if (err < 0)591 return err;592 593 /* ipvlan_init() would have created the port, if required */594 port = ipvlan_port_get_rtnl(phy_dev);595 ipvlan->port = port;596 597 /* If the port-id base is at the MAX value, then wrap it around and598 * begin from 0x1 again. This may be due to a busy system where lots599 * of slaves are getting created and deleted.600 */601 if (port->dev_id_start == 0xFFFE)602 port->dev_id_start = 0x1;603 604 /* Since L2 address is shared among all IPvlan slaves including605 * master, use unique 16 bit dev-ids to differentiate among them.606 * Assign IDs between 0x1 and 0xFFFE (used by the master) to each607 * slave link [see addrconf_ifid_eui48()].608 */609 err = ida_alloc_range(&port->ida, port->dev_id_start, 0xFFFD,610 GFP_KERNEL);611 if (err < 0)612 err = ida_alloc_range(&port->ida, 0x1, port->dev_id_start - 1,613 GFP_KERNEL);614 if (err < 0)615 goto unregister_netdev;616 dev->dev_id = err;617 618 /* Increment id-base to the next slot for the future assignment */619 port->dev_id_start = err + 1;620 621 err = netdev_upper_dev_link(phy_dev, dev, extack);622 if (err)623 goto remove_ida;624 625 /* Flags are per port and latest update overrides. User has626 * to be consistent in setting it just like the mode attribute.627 */628 if (data && data[IFLA_IPVLAN_FLAGS])629 port->flags = nla_get_u16(data[IFLA_IPVLAN_FLAGS]);630 631 if (data && data[IFLA_IPVLAN_MODE])632 mode = nla_get_u16(data[IFLA_IPVLAN_MODE]);633 634 err = ipvlan_set_port_mode(port, mode, extack);635 if (err)636 goto unlink_netdev;637 638 list_add_tail_rcu(&ipvlan->pnode, &port->ipvlans);639 netif_stacked_transfer_operstate(phy_dev, dev);640 return 0;641 642unlink_netdev:643 netdev_upper_dev_unlink(phy_dev, dev);644remove_ida:645 ida_free(&port->ida, dev->dev_id);646unregister_netdev:647 unregister_netdevice(dev);648 return err;649}650EXPORT_SYMBOL_GPL(ipvlan_link_new);651 652void ipvlan_link_delete(struct net_device *dev, struct list_head *head)653{654 struct ipvl_dev *ipvlan = netdev_priv(dev);655 struct ipvl_addr *addr, *next;656 657 spin_lock_bh(&ipvlan->addrs_lock);658 list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) {659 ipvlan_ht_addr_del(addr);660 list_del_rcu(&addr->anode);661 kfree_rcu(addr, rcu);662 }663 spin_unlock_bh(&ipvlan->addrs_lock);664 665 ida_free(&ipvlan->port->ida, dev->dev_id);666 list_del_rcu(&ipvlan->pnode);667 unregister_netdevice_queue(dev, head);668 netdev_upper_dev_unlink(ipvlan->phy_dev, dev);669}670EXPORT_SYMBOL_GPL(ipvlan_link_delete);671 672void ipvlan_link_setup(struct net_device *dev)673{674 ether_setup(dev);675 676 dev->max_mtu = ETH_MAX_MTU;677 dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING);678 dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE;679 dev->netdev_ops = &ipvlan_netdev_ops;680 dev->needs_free_netdev = true;681 dev->header_ops = &ipvlan_header_ops;682 dev->ethtool_ops = &ipvlan_ethtool_ops;683}684EXPORT_SYMBOL_GPL(ipvlan_link_setup);685 686static const struct nla_policy ipvlan_nl_policy[IFLA_IPVLAN_MAX + 1] =687{688 [IFLA_IPVLAN_MODE] = { .type = NLA_U16 },689 [IFLA_IPVLAN_FLAGS] = { .type = NLA_U16 },690};691 692static struct net *ipvlan_get_link_net(const struct net_device *dev)693{694 struct ipvl_dev *ipvlan = netdev_priv(dev);695 696 return dev_net(ipvlan->phy_dev);697}698 699static struct rtnl_link_ops ipvlan_link_ops = {700 .kind = "ipvlan",701 .priv_size = sizeof(struct ipvl_dev),702 703 .setup = ipvlan_link_setup,704 .newlink = ipvlan_link_new,705 .dellink = ipvlan_link_delete,706 .get_link_net = ipvlan_get_link_net,707};708 709int ipvlan_link_register(struct rtnl_link_ops *ops)710{711 ops->get_size = ipvlan_nl_getsize;712 ops->policy = ipvlan_nl_policy;713 ops->validate = ipvlan_nl_validate;714 ops->fill_info = ipvlan_nl_fillinfo;715 ops->changelink = ipvlan_nl_changelink;716 ops->maxtype = IFLA_IPVLAN_MAX;717 return rtnl_link_register(ops);718}719EXPORT_SYMBOL_GPL(ipvlan_link_register);720 721static int ipvlan_device_event(struct notifier_block *unused,722 unsigned long event, void *ptr)723{724 struct netlink_ext_ack *extack = netdev_notifier_info_to_extack(ptr);725 struct netdev_notifier_pre_changeaddr_info *prechaddr_info;726 struct net_device *dev = netdev_notifier_info_to_dev(ptr);727 struct ipvl_dev *ipvlan, *next;728 struct ipvl_port *port;729 LIST_HEAD(lst_kill);730 int err;731 732 if (!netif_is_ipvlan_port(dev))733 return NOTIFY_DONE;734 735 port = ipvlan_port_get_rtnl(dev);736 737 switch (event) {738 case NETDEV_UP:739 case NETDEV_DOWN:740 case NETDEV_CHANGE:741 list_for_each_entry(ipvlan, &port->ipvlans, pnode)742 netif_stacked_transfer_operstate(ipvlan->phy_dev,743 ipvlan->dev);744 break;745 746 case NETDEV_REGISTER: {747 struct net *oldnet, *newnet = dev_net(dev);748 749 oldnet = read_pnet(&port->pnet);750 if (net_eq(newnet, oldnet))751 break;752 753 write_pnet(&port->pnet, newnet);754 755 if (port->mode == IPVLAN_MODE_L3S)756 ipvlan_migrate_l3s_hook(oldnet, newnet);757 break;758 }759 case NETDEV_UNREGISTER:760 if (dev->reg_state != NETREG_UNREGISTERING)761 break;762 763 list_for_each_entry_safe(ipvlan, next, &port->ipvlans, pnode)764 ipvlan->dev->rtnl_link_ops->dellink(ipvlan->dev,765 &lst_kill);766 unregister_netdevice_many(&lst_kill);767 break;768 769 case NETDEV_FEAT_CHANGE:770 list_for_each_entry(ipvlan, &port->ipvlans, pnode) {771 netif_inherit_tso_max(ipvlan->dev, dev);772 netdev_update_features(ipvlan->dev);773 }774 break;775 776 case NETDEV_CHANGEMTU:777 list_for_each_entry(ipvlan, &port->ipvlans, pnode)778 ipvlan_adjust_mtu(ipvlan, dev);779 break;780 781 case NETDEV_PRE_CHANGEADDR:782 prechaddr_info = ptr;783 list_for_each_entry(ipvlan, &port->ipvlans, pnode) {784 err = dev_pre_changeaddr_notify(ipvlan->dev,785 prechaddr_info->dev_addr,786 extack);787 if (err)788 return notifier_from_errno(err);789 }790 break;791 792 case NETDEV_CHANGEADDR:793 list_for_each_entry(ipvlan, &port->ipvlans, pnode) {794 eth_hw_addr_set(ipvlan->dev, dev->dev_addr);795 call_netdevice_notifiers(NETDEV_CHANGEADDR, ipvlan->dev);796 }797 break;798 799 case NETDEV_PRE_TYPE_CHANGE:800 /* Forbid underlying device to change its type. */801 return NOTIFY_BAD;802 }803 return NOTIFY_DONE;804}805 806/* the caller must held the addrs lock */807static int ipvlan_add_addr(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6)808{809 struct ipvl_addr *addr;810 811 addr = kzalloc(sizeof(struct ipvl_addr), GFP_ATOMIC);812 if (!addr)813 return -ENOMEM;814 815 addr->master = ipvlan;816 if (!is_v6) {817 memcpy(&addr->ip4addr, iaddr, sizeof(struct in_addr));818 addr->atype = IPVL_IPV4;819#if IS_ENABLED(CONFIG_IPV6)820 } else {821 memcpy(&addr->ip6addr, iaddr, sizeof(struct in6_addr));822 addr->atype = IPVL_IPV6;823#endif824 }825 826 list_add_tail_rcu(&addr->anode, &ipvlan->addrs);827 828 /* If the interface is not up, the address will be added to the hash829 * list by ipvlan_open.830 */831 if (netif_running(ipvlan->dev))832 ipvlan_ht_addr_add(ipvlan, addr);833 834 return 0;835}836 837static void ipvlan_del_addr(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6)838{839 struct ipvl_addr *addr;840 841 spin_lock_bh(&ipvlan->addrs_lock);842 addr = ipvlan_find_addr(ipvlan, iaddr, is_v6);843 if (!addr) {844 spin_unlock_bh(&ipvlan->addrs_lock);845 return;846 }847 848 ipvlan_ht_addr_del(addr);849 list_del_rcu(&addr->anode);850 spin_unlock_bh(&ipvlan->addrs_lock);851 kfree_rcu(addr, rcu);852}853 854static bool ipvlan_is_valid_dev(const struct net_device *dev)855{856 struct ipvl_dev *ipvlan = netdev_priv(dev);857 858 if (!netif_is_ipvlan(dev))859 return false;860 861 if (!ipvlan || !ipvlan->port)862 return false;863 864 return true;865}866 867#if IS_ENABLED(CONFIG_IPV6)868static int ipvlan_add_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr)869{870 int ret = -EINVAL;871 872 spin_lock_bh(&ipvlan->addrs_lock);873 if (ipvlan_addr_busy(ipvlan->port, ip6_addr, true))874 netif_err(ipvlan, ifup, ipvlan->dev,875 "Failed to add IPv6=%pI6c addr for %s intf\n",876 ip6_addr, ipvlan->dev->name);877 else878 ret = ipvlan_add_addr(ipvlan, ip6_addr, true);879 spin_unlock_bh(&ipvlan->addrs_lock);880 return ret;881}882 883static void ipvlan_del_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr)884{885 return ipvlan_del_addr(ipvlan, ip6_addr, true);886}887 888static int ipvlan_addr6_event(struct notifier_block *unused,889 unsigned long event, void *ptr)890{891 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *)ptr;892 struct net_device *dev = (struct net_device *)if6->idev->dev;893 struct ipvl_dev *ipvlan = netdev_priv(dev);894 895 if (!ipvlan_is_valid_dev(dev))896 return NOTIFY_DONE;897 898 switch (event) {899 case NETDEV_UP:900 if (ipvlan_add_addr6(ipvlan, &if6->addr))901 return NOTIFY_BAD;902 break;903 904 case NETDEV_DOWN:905 ipvlan_del_addr6(ipvlan, &if6->addr);906 break;907 }908 909 return NOTIFY_OK;910}911 912static int ipvlan_addr6_validator_event(struct notifier_block *unused,913 unsigned long event, void *ptr)914{915 struct in6_validator_info *i6vi = (struct in6_validator_info *)ptr;916 struct net_device *dev = (struct net_device *)i6vi->i6vi_dev->dev;917 struct ipvl_dev *ipvlan = netdev_priv(dev);918 919 if (!ipvlan_is_valid_dev(dev))920 return NOTIFY_DONE;921 922 switch (event) {923 case NETDEV_UP:924 if (ipvlan_addr_busy(ipvlan->port, &i6vi->i6vi_addr, true)) {925 NL_SET_ERR_MSG(i6vi->extack,926 "Address already assigned to an ipvlan device");927 return notifier_from_errno(-EADDRINUSE);928 }929 break;930 }931 932 return NOTIFY_OK;933}934#endif935 936static int ipvlan_add_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr)937{938 int ret = -EINVAL;939 940 spin_lock_bh(&ipvlan->addrs_lock);941 if (ipvlan_addr_busy(ipvlan->port, ip4_addr, false))942 netif_err(ipvlan, ifup, ipvlan->dev,943 "Failed to add IPv4=%pI4 on %s intf.\n",944 ip4_addr, ipvlan->dev->name);945 else946 ret = ipvlan_add_addr(ipvlan, ip4_addr, false);947 spin_unlock_bh(&ipvlan->addrs_lock);948 return ret;949}950 951static void ipvlan_del_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr)952{953 return ipvlan_del_addr(ipvlan, ip4_addr, false);954}955 956static int ipvlan_addr4_event(struct notifier_block *unused,957 unsigned long event, void *ptr)958{959 struct in_ifaddr *if4 = (struct in_ifaddr *)ptr;960 struct net_device *dev = (struct net_device *)if4->ifa_dev->dev;961 struct ipvl_dev *ipvlan = netdev_priv(dev);962 struct in_addr ip4_addr;963 964 if (!ipvlan_is_valid_dev(dev))965 return NOTIFY_DONE;966 967 switch (event) {968 case NETDEV_UP:969 ip4_addr.s_addr = if4->ifa_address;970 if (ipvlan_add_addr4(ipvlan, &ip4_addr))971 return NOTIFY_BAD;972 break;973 974 case NETDEV_DOWN:975 ip4_addr.s_addr = if4->ifa_address;976 ipvlan_del_addr4(ipvlan, &ip4_addr);977 break;978 }979 980 return NOTIFY_OK;981}982 983static int ipvlan_addr4_validator_event(struct notifier_block *unused,984 unsigned long event, void *ptr)985{986 struct in_validator_info *ivi = (struct in_validator_info *)ptr;987 struct net_device *dev = (struct net_device *)ivi->ivi_dev->dev;988 struct ipvl_dev *ipvlan = netdev_priv(dev);989 990 if (!ipvlan_is_valid_dev(dev))991 return NOTIFY_DONE;992 993 switch (event) {994 case NETDEV_UP:995 if (ipvlan_addr_busy(ipvlan->port, &ivi->ivi_addr, false)) {996 NL_SET_ERR_MSG(ivi->extack,997 "Address already assigned to an ipvlan device");998 return notifier_from_errno(-EADDRINUSE);999 }1000 break;1001 }1002 1003 return NOTIFY_OK;1004}1005 1006static struct notifier_block ipvlan_addr4_notifier_block __read_mostly = {1007 .notifier_call = ipvlan_addr4_event,1008};1009 1010static struct notifier_block ipvlan_addr4_vtor_notifier_block __read_mostly = {1011 .notifier_call = ipvlan_addr4_validator_event,1012};1013 1014static struct notifier_block ipvlan_notifier_block __read_mostly = {1015 .notifier_call = ipvlan_device_event,1016};1017 1018#if IS_ENABLED(CONFIG_IPV6)1019static struct notifier_block ipvlan_addr6_notifier_block __read_mostly = {1020 .notifier_call = ipvlan_addr6_event,1021};1022 1023static struct notifier_block ipvlan_addr6_vtor_notifier_block __read_mostly = {1024 .notifier_call = ipvlan_addr6_validator_event,1025};1026#endif1027 1028static int __init ipvlan_init_module(void)1029{1030 int err;1031 1032 ipvlan_init_secret();1033 register_netdevice_notifier(&ipvlan_notifier_block);1034#if IS_ENABLED(CONFIG_IPV6)1035 register_inet6addr_notifier(&ipvlan_addr6_notifier_block);1036 register_inet6addr_validator_notifier(1037 &ipvlan_addr6_vtor_notifier_block);1038#endif1039 register_inetaddr_notifier(&ipvlan_addr4_notifier_block);1040 register_inetaddr_validator_notifier(&ipvlan_addr4_vtor_notifier_block);1041 1042 err = ipvlan_l3s_init();1043 if (err < 0)1044 goto error;1045 1046 err = ipvlan_link_register(&ipvlan_link_ops);1047 if (err < 0) {1048 ipvlan_l3s_cleanup();1049 goto error;1050 }1051 1052 return 0;1053error:1054 unregister_inetaddr_notifier(&ipvlan_addr4_notifier_block);1055 unregister_inetaddr_validator_notifier(1056 &ipvlan_addr4_vtor_notifier_block);1057#if IS_ENABLED(CONFIG_IPV6)1058 unregister_inet6addr_notifier(&ipvlan_addr6_notifier_block);1059 unregister_inet6addr_validator_notifier(1060 &ipvlan_addr6_vtor_notifier_block);1061#endif1062 unregister_netdevice_notifier(&ipvlan_notifier_block);1063 return err;1064}1065 1066static void __exit ipvlan_cleanup_module(void)1067{1068 rtnl_link_unregister(&ipvlan_link_ops);1069 ipvlan_l3s_cleanup();1070 unregister_netdevice_notifier(&ipvlan_notifier_block);1071 unregister_inetaddr_notifier(&ipvlan_addr4_notifier_block);1072 unregister_inetaddr_validator_notifier(1073 &ipvlan_addr4_vtor_notifier_block);1074#if IS_ENABLED(CONFIG_IPV6)1075 unregister_inet6addr_notifier(&ipvlan_addr6_notifier_block);1076 unregister_inet6addr_validator_notifier(1077 &ipvlan_addr6_vtor_notifier_block);1078#endif1079}1080 1081module_init(ipvlan_init_module);1082module_exit(ipvlan_cleanup_module);1083 1084MODULE_LICENSE("GPL");1085MODULE_AUTHOR("Mahesh Bandewar <maheshb@google.com>");1086MODULE_DESCRIPTION("Driver for L3 (IPv6/IPv4) based VLANs");1087MODULE_ALIAS_RTNL_LINK("ipvlan");1088