1 /* Copyright (c) 2014 Mahesh Bandewar <maheshb@google.com> 2 * 3 * This program is free software; you can redistribute it and/or 4 * modify it under the terms of the GNU General Public License as 5 * published by the Free Software Foundation; either version 2 of 6 * the License, or (at your option) any later version. 7 * 8 */ 9 10 #include "ipvlan.h" 11 12 static void ipvlan_adjust_mtu(struct ipvl_dev *ipvlan, struct net_device *dev) 13 { 14 ipvlan->dev->mtu = dev->mtu - ipvlan->mtu_adj; 15 } 16 17 static void ipvlan_set_port_mode(struct ipvl_port *port, u16 nval) 18 { 19 struct ipvl_dev *ipvlan; 20 21 if (port->mode != nval) { 22 list_for_each_entry(ipvlan, &port->ipvlans, pnode) { 23 if (nval == IPVLAN_MODE_L3) 24 ipvlan->dev->flags |= IFF_NOARP; 25 else 26 ipvlan->dev->flags &= ~IFF_NOARP; 27 } 28 port->mode = nval; 29 } 30 } 31 32 static int ipvlan_port_create(struct net_device *dev) 33 { 34 struct ipvl_port *port; 35 int err, idx; 36 37 if (dev->type != ARPHRD_ETHER || dev->flags & IFF_LOOPBACK) { 38 netdev_err(dev, "Master is either lo or non-ether device\n"); 39 return -EINVAL; 40 } 41 42 if (netif_is_macvlan_port(dev)) { 43 netdev_err(dev, "Master is a macvlan port.\n"); 44 return -EBUSY; 45 } 46 47 port = kzalloc(sizeof(struct ipvl_port), GFP_KERNEL); 48 if (!port) 49 return -ENOMEM; 50 51 port->dev = dev; 52 port->mode = IPVLAN_MODE_L3; 53 INIT_LIST_HEAD(&port->ipvlans); 54 for (idx = 0; idx < IPVLAN_HASH_SIZE; idx++) 55 INIT_HLIST_HEAD(&port->hlhead[idx]); 56 57 skb_queue_head_init(&port->backlog); 58 INIT_WORK(&port->wq, ipvlan_process_multicast); 59 60 err = netdev_rx_handler_register(dev, ipvlan_handle_frame, port); 61 if (err) 62 goto err; 63 64 dev->priv_flags |= IFF_IPVLAN_MASTER; 65 return 0; 66 67 err: 68 kfree_rcu(port, rcu); 69 return err; 70 } 71 72 static void ipvlan_port_destroy(struct net_device *dev) 73 { 74 struct ipvl_port *port = ipvlan_port_get_rtnl(dev); 75 76 dev->priv_flags &= ~IFF_IPVLAN_MASTER; 77 netdev_rx_handler_unregister(dev); 78 cancel_work_sync(&port->wq); 79 __skb_queue_purge(&port->backlog); 80 kfree_rcu(port, rcu); 81 } 82 83 /* ipvlan network devices have devices nesting below it and are a special 84 * "super class" of normal network devices; split their locks off into a 85 * separate class since they always nest. 86 */ 87 static struct lock_class_key ipvlan_netdev_xmit_lock_key; 88 static struct lock_class_key ipvlan_netdev_addr_lock_key; 89 90 #define IPVLAN_FEATURES \ 91 (NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_HIGHDMA | NETIF_F_FRAGLIST | \ 92 NETIF_F_GSO | NETIF_F_TSO | NETIF_F_UFO | NETIF_F_GSO_ROBUST | \ 93 NETIF_F_TSO_ECN | NETIF_F_TSO6 | NETIF_F_GRO | NETIF_F_RXCSUM | \ 94 NETIF_F_HW_VLAN_CTAG_FILTER | NETIF_F_HW_VLAN_STAG_FILTER) 95 96 #define IPVLAN_STATE_MASK \ 97 ((1<<__LINK_STATE_NOCARRIER) | (1<<__LINK_STATE_DORMANT)) 98 99 static void ipvlan_set_lockdep_class_one(struct net_device *dev, 100 struct netdev_queue *txq, 101 void *_unused) 102 { 103 lockdep_set_class(&txq->_xmit_lock, &ipvlan_netdev_xmit_lock_key); 104 } 105 106 static void ipvlan_set_lockdep_class(struct net_device *dev) 107 { 108 lockdep_set_class(&dev->addr_list_lock, &ipvlan_netdev_addr_lock_key); 109 netdev_for_each_tx_queue(dev, ipvlan_set_lockdep_class_one, NULL); 110 } 111 112 static int ipvlan_init(struct net_device *dev) 113 { 114 struct ipvl_dev *ipvlan = netdev_priv(dev); 115 const struct net_device *phy_dev = ipvlan->phy_dev; 116 117 dev->state = (dev->state & ~IPVLAN_STATE_MASK) | 118 (phy_dev->state & IPVLAN_STATE_MASK); 119 dev->features = phy_dev->features & IPVLAN_FEATURES; 120 dev->features |= NETIF_F_LLTX; 121 dev->gso_max_size = phy_dev->gso_max_size; 122 dev->gso_max_segs = phy_dev->gso_max_segs; 123 dev->hard_header_len = phy_dev->hard_header_len; 124 125 ipvlan_set_lockdep_class(dev); 126 127 ipvlan->pcpu_stats = alloc_percpu(struct ipvl_pcpu_stats); 128 if (!ipvlan->pcpu_stats) 129 return -ENOMEM; 130 131 return 0; 132 } 133 134 static void ipvlan_uninit(struct net_device *dev) 135 { 136 struct ipvl_dev *ipvlan = netdev_priv(dev); 137 struct ipvl_port *port = ipvlan->port; 138 139 free_percpu(ipvlan->pcpu_stats); 140 141 port->count -= 1; 142 if (!port->count) 143 ipvlan_port_destroy(port->dev); 144 } 145 146 static int ipvlan_open(struct net_device *dev) 147 { 148 struct ipvl_dev *ipvlan = netdev_priv(dev); 149 struct net_device *phy_dev = ipvlan->phy_dev; 150 struct ipvl_addr *addr; 151 152 if (ipvlan->port->mode == IPVLAN_MODE_L3) 153 dev->flags |= IFF_NOARP; 154 else 155 dev->flags &= ~IFF_NOARP; 156 157 list_for_each_entry(addr, &ipvlan->addrs, anode) 158 ipvlan_ht_addr_add(ipvlan, addr); 159 160 return dev_uc_add(phy_dev, phy_dev->dev_addr); 161 } 162 163 static int ipvlan_stop(struct net_device *dev) 164 { 165 struct ipvl_dev *ipvlan = netdev_priv(dev); 166 struct net_device *phy_dev = ipvlan->phy_dev; 167 struct ipvl_addr *addr; 168 169 dev_uc_unsync(phy_dev, dev); 170 dev_mc_unsync(phy_dev, dev); 171 172 dev_uc_del(phy_dev, phy_dev->dev_addr); 173 174 list_for_each_entry(addr, &ipvlan->addrs, anode) 175 ipvlan_ht_addr_del(addr); 176 177 return 0; 178 } 179 180 static netdev_tx_t ipvlan_start_xmit(struct sk_buff *skb, 181 struct net_device *dev) 182 { 183 const struct ipvl_dev *ipvlan = netdev_priv(dev); 184 int skblen = skb->len; 185 int ret; 186 187 ret = ipvlan_queue_xmit(skb, dev); 188 if (likely(ret == NET_XMIT_SUCCESS || ret == NET_XMIT_CN)) { 189 struct ipvl_pcpu_stats *pcptr; 190 191 pcptr = this_cpu_ptr(ipvlan->pcpu_stats); 192 193 u64_stats_update_begin(&pcptr->syncp); 194 pcptr->tx_pkts++; 195 pcptr->tx_bytes += skblen; 196 u64_stats_update_end(&pcptr->syncp); 197 } else { 198 this_cpu_inc(ipvlan->pcpu_stats->tx_drps); 199 } 200 return ret; 201 } 202 203 static netdev_features_t ipvlan_fix_features(struct net_device *dev, 204 netdev_features_t features) 205 { 206 struct ipvl_dev *ipvlan = netdev_priv(dev); 207 208 return features & (ipvlan->sfeatures | ~IPVLAN_FEATURES); 209 } 210 211 static void ipvlan_change_rx_flags(struct net_device *dev, int change) 212 { 213 struct ipvl_dev *ipvlan = netdev_priv(dev); 214 struct net_device *phy_dev = ipvlan->phy_dev; 215 216 if (change & IFF_ALLMULTI) 217 dev_set_allmulti(phy_dev, dev->flags & IFF_ALLMULTI? 1 : -1); 218 } 219 220 static void ipvlan_set_multicast_mac_filter(struct net_device *dev) 221 { 222 struct ipvl_dev *ipvlan = netdev_priv(dev); 223 224 if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) { 225 bitmap_fill(ipvlan->mac_filters, IPVLAN_MAC_FILTER_SIZE); 226 } else { 227 struct netdev_hw_addr *ha; 228 DECLARE_BITMAP(mc_filters, IPVLAN_MAC_FILTER_SIZE); 229 230 bitmap_zero(mc_filters, IPVLAN_MAC_FILTER_SIZE); 231 netdev_for_each_mc_addr(ha, dev) 232 __set_bit(ipvlan_mac_hash(ha->addr), mc_filters); 233 234 /* Turn-on broadcast bit irrespective of address family, 235 * since broadcast is deferred to a work-queue, hence no 236 * impact on fast-path processing. 237 */ 238 __set_bit(ipvlan_mac_hash(dev->broadcast), mc_filters); 239 240 bitmap_copy(ipvlan->mac_filters, mc_filters, 241 IPVLAN_MAC_FILTER_SIZE); 242 } 243 dev_uc_sync(ipvlan->phy_dev, dev); 244 dev_mc_sync(ipvlan->phy_dev, dev); 245 } 246 247 static struct rtnl_link_stats64 *ipvlan_get_stats64(struct net_device *dev, 248 struct rtnl_link_stats64 *s) 249 { 250 struct ipvl_dev *ipvlan = netdev_priv(dev); 251 252 if (ipvlan->pcpu_stats) { 253 struct ipvl_pcpu_stats *pcptr; 254 u64 rx_pkts, rx_bytes, rx_mcast, tx_pkts, tx_bytes; 255 u32 rx_errs = 0, tx_drps = 0; 256 u32 strt; 257 int idx; 258 259 for_each_possible_cpu(idx) { 260 pcptr = per_cpu_ptr(ipvlan->pcpu_stats, idx); 261 do { 262 strt= u64_stats_fetch_begin_irq(&pcptr->syncp); 263 rx_pkts = pcptr->rx_pkts; 264 rx_bytes = pcptr->rx_bytes; 265 rx_mcast = pcptr->rx_mcast; 266 tx_pkts = pcptr->tx_pkts; 267 tx_bytes = pcptr->tx_bytes; 268 } while (u64_stats_fetch_retry_irq(&pcptr->syncp, 269 strt)); 270 271 s->rx_packets += rx_pkts; 272 s->rx_bytes += rx_bytes; 273 s->multicast += rx_mcast; 274 s->tx_packets += tx_pkts; 275 s->tx_bytes += tx_bytes; 276 277 /* u32 values are updated without syncp protection. */ 278 rx_errs += pcptr->rx_errs; 279 tx_drps += pcptr->tx_drps; 280 } 281 s->rx_errors = rx_errs; 282 s->rx_dropped = rx_errs; 283 s->tx_dropped = tx_drps; 284 } 285 return s; 286 } 287 288 static int ipvlan_vlan_rx_add_vid(struct net_device *dev, __be16 proto, u16 vid) 289 { 290 struct ipvl_dev *ipvlan = netdev_priv(dev); 291 struct net_device *phy_dev = ipvlan->phy_dev; 292 293 return vlan_vid_add(phy_dev, proto, vid); 294 } 295 296 static int ipvlan_vlan_rx_kill_vid(struct net_device *dev, __be16 proto, 297 u16 vid) 298 { 299 struct ipvl_dev *ipvlan = netdev_priv(dev); 300 struct net_device *phy_dev = ipvlan->phy_dev; 301 302 vlan_vid_del(phy_dev, proto, vid); 303 return 0; 304 } 305 306 static int ipvlan_get_iflink(const struct net_device *dev) 307 { 308 struct ipvl_dev *ipvlan = netdev_priv(dev); 309 310 return ipvlan->phy_dev->ifindex; 311 } 312 313 static const struct net_device_ops ipvlan_netdev_ops = { 314 .ndo_init = ipvlan_init, 315 .ndo_uninit = ipvlan_uninit, 316 .ndo_open = ipvlan_open, 317 .ndo_stop = ipvlan_stop, 318 .ndo_start_xmit = ipvlan_start_xmit, 319 .ndo_fix_features = ipvlan_fix_features, 320 .ndo_change_rx_flags = ipvlan_change_rx_flags, 321 .ndo_set_rx_mode = ipvlan_set_multicast_mac_filter, 322 .ndo_get_stats64 = ipvlan_get_stats64, 323 .ndo_vlan_rx_add_vid = ipvlan_vlan_rx_add_vid, 324 .ndo_vlan_rx_kill_vid = ipvlan_vlan_rx_kill_vid, 325 .ndo_get_iflink = ipvlan_get_iflink, 326 }; 327 328 static int ipvlan_hard_header(struct sk_buff *skb, struct net_device *dev, 329 unsigned short type, const void *daddr, 330 const void *saddr, unsigned len) 331 { 332 const struct ipvl_dev *ipvlan = netdev_priv(dev); 333 struct net_device *phy_dev = ipvlan->phy_dev; 334 335 /* TODO Probably use a different field than dev_addr so that the 336 * mac-address on the virtual device is portable and can be carried 337 * while the packets use the mac-addr on the physical device. 338 */ 339 return dev_hard_header(skb, phy_dev, type, daddr, 340 saddr ? : dev->dev_addr, len); 341 } 342 343 static const struct header_ops ipvlan_header_ops = { 344 .create = ipvlan_hard_header, 345 .parse = eth_header_parse, 346 .cache = eth_header_cache, 347 .cache_update = eth_header_cache_update, 348 }; 349 350 static int ipvlan_ethtool_get_link_ksettings(struct net_device *dev, 351 struct ethtool_link_ksettings *cmd) 352 { 353 const struct ipvl_dev *ipvlan = netdev_priv(dev); 354 355 return __ethtool_get_link_ksettings(ipvlan->phy_dev, cmd); 356 } 357 358 static void ipvlan_ethtool_get_drvinfo(struct net_device *dev, 359 struct ethtool_drvinfo *drvinfo) 360 { 361 strlcpy(drvinfo->driver, IPVLAN_DRV, sizeof(drvinfo->driver)); 362 strlcpy(drvinfo->version, IPV_DRV_VER, sizeof(drvinfo->version)); 363 } 364 365 static u32 ipvlan_ethtool_get_msglevel(struct net_device *dev) 366 { 367 const struct ipvl_dev *ipvlan = netdev_priv(dev); 368 369 return ipvlan->msg_enable; 370 } 371 372 static void ipvlan_ethtool_set_msglevel(struct net_device *dev, u32 value) 373 { 374 struct ipvl_dev *ipvlan = netdev_priv(dev); 375 376 ipvlan->msg_enable = value; 377 } 378 379 static const struct ethtool_ops ipvlan_ethtool_ops = { 380 .get_link = ethtool_op_get_link, 381 .get_link_ksettings = ipvlan_ethtool_get_link_ksettings, 382 .get_drvinfo = ipvlan_ethtool_get_drvinfo, 383 .get_msglevel = ipvlan_ethtool_get_msglevel, 384 .set_msglevel = ipvlan_ethtool_set_msglevel, 385 }; 386 387 static int ipvlan_nl_changelink(struct net_device *dev, 388 struct nlattr *tb[], struct nlattr *data[]) 389 { 390 struct ipvl_dev *ipvlan = netdev_priv(dev); 391 struct ipvl_port *port = ipvlan_port_get_rtnl(ipvlan->phy_dev); 392 393 if (data && data[IFLA_IPVLAN_MODE]) { 394 u16 nmode = nla_get_u16(data[IFLA_IPVLAN_MODE]); 395 396 ipvlan_set_port_mode(port, nmode); 397 } 398 return 0; 399 } 400 401 static size_t ipvlan_nl_getsize(const struct net_device *dev) 402 { 403 return (0 404 + nla_total_size(2) /* IFLA_IPVLAN_MODE */ 405 ); 406 } 407 408 static int ipvlan_nl_validate(struct nlattr *tb[], struct nlattr *data[]) 409 { 410 if (data && data[IFLA_IPVLAN_MODE]) { 411 u16 mode = nla_get_u16(data[IFLA_IPVLAN_MODE]); 412 413 if (mode < IPVLAN_MODE_L2 || mode >= IPVLAN_MODE_MAX) 414 return -EINVAL; 415 } 416 return 0; 417 } 418 419 static int ipvlan_nl_fillinfo(struct sk_buff *skb, 420 const struct net_device *dev) 421 { 422 struct ipvl_dev *ipvlan = netdev_priv(dev); 423 struct ipvl_port *port = ipvlan_port_get_rtnl(ipvlan->phy_dev); 424 int ret = -EINVAL; 425 426 if (!port) 427 goto err; 428 429 ret = -EMSGSIZE; 430 if (nla_put_u16(skb, IFLA_IPVLAN_MODE, port->mode)) 431 goto err; 432 433 return 0; 434 435 err: 436 return ret; 437 } 438 439 static int ipvlan_link_new(struct net *src_net, struct net_device *dev, 440 struct nlattr *tb[], struct nlattr *data[]) 441 { 442 struct ipvl_dev *ipvlan = netdev_priv(dev); 443 struct ipvl_port *port; 444 struct net_device *phy_dev; 445 int err; 446 u16 mode = IPVLAN_MODE_L3; 447 448 if (!tb[IFLA_LINK]) 449 return -EINVAL; 450 451 phy_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 452 if (!phy_dev) 453 return -ENODEV; 454 455 if (netif_is_ipvlan(phy_dev)) { 456 struct ipvl_dev *tmp = netdev_priv(phy_dev); 457 458 phy_dev = tmp->phy_dev; 459 } else if (!netif_is_ipvlan_port(phy_dev)) { 460 err = ipvlan_port_create(phy_dev); 461 if (err < 0) 462 return err; 463 } 464 465 if (data && data[IFLA_IPVLAN_MODE]) 466 mode = nla_get_u16(data[IFLA_IPVLAN_MODE]); 467 468 port = ipvlan_port_get_rtnl(phy_dev); 469 ipvlan->phy_dev = phy_dev; 470 ipvlan->dev = dev; 471 ipvlan->port = port; 472 ipvlan->sfeatures = IPVLAN_FEATURES; 473 ipvlan_adjust_mtu(ipvlan, phy_dev); 474 INIT_LIST_HEAD(&ipvlan->addrs); 475 476 /* TODO Probably put random address here to be presented to the 477 * world but keep using the physical-dev address for the outgoing 478 * packets. 479 */ 480 memcpy(dev->dev_addr, phy_dev->dev_addr, ETH_ALEN); 481 482 dev->priv_flags |= IFF_IPVLAN_SLAVE; 483 484 port->count += 1; 485 err = register_netdevice(dev); 486 if (err < 0) 487 goto ipvlan_destroy_port; 488 489 err = netdev_upper_dev_link(phy_dev, dev); 490 if (err) 491 goto ipvlan_destroy_port; 492 493 list_add_tail_rcu(&ipvlan->pnode, &port->ipvlans); 494 ipvlan_set_port_mode(port, mode); 495 496 netif_stacked_transfer_operstate(phy_dev, dev); 497 return 0; 498 499 ipvlan_destroy_port: 500 port->count -= 1; 501 if (!port->count) 502 ipvlan_port_destroy(phy_dev); 503 504 return err; 505 } 506 507 static void ipvlan_link_delete(struct net_device *dev, struct list_head *head) 508 { 509 struct ipvl_dev *ipvlan = netdev_priv(dev); 510 struct ipvl_addr *addr, *next; 511 512 list_for_each_entry_safe(addr, next, &ipvlan->addrs, anode) { 513 ipvlan_ht_addr_del(addr); 514 list_del(&addr->anode); 515 kfree_rcu(addr, rcu); 516 } 517 518 list_del_rcu(&ipvlan->pnode); 519 unregister_netdevice_queue(dev, head); 520 netdev_upper_dev_unlink(ipvlan->phy_dev, dev); 521 } 522 523 static void ipvlan_link_setup(struct net_device *dev) 524 { 525 ether_setup(dev); 526 527 dev->priv_flags &= ~(IFF_XMIT_DST_RELEASE | IFF_TX_SKB_SHARING); 528 dev->priv_flags |= IFF_UNICAST_FLT | IFF_NO_QUEUE; 529 dev->netdev_ops = &ipvlan_netdev_ops; 530 dev->destructor = free_netdev; 531 dev->header_ops = &ipvlan_header_ops; 532 dev->ethtool_ops = &ipvlan_ethtool_ops; 533 } 534 535 static const struct nla_policy ipvlan_nl_policy[IFLA_IPVLAN_MAX + 1] = 536 { 537 [IFLA_IPVLAN_MODE] = { .type = NLA_U16 }, 538 }; 539 540 static struct rtnl_link_ops ipvlan_link_ops = { 541 .kind = "ipvlan", 542 .priv_size = sizeof(struct ipvl_dev), 543 544 .get_size = ipvlan_nl_getsize, 545 .policy = ipvlan_nl_policy, 546 .validate = ipvlan_nl_validate, 547 .fill_info = ipvlan_nl_fillinfo, 548 .changelink = ipvlan_nl_changelink, 549 .maxtype = IFLA_IPVLAN_MAX, 550 551 .setup = ipvlan_link_setup, 552 .newlink = ipvlan_link_new, 553 .dellink = ipvlan_link_delete, 554 }; 555 556 static int ipvlan_link_register(struct rtnl_link_ops *ops) 557 { 558 return rtnl_link_register(ops); 559 } 560 561 static int ipvlan_device_event(struct notifier_block *unused, 562 unsigned long event, void *ptr) 563 { 564 struct net_device *dev = netdev_notifier_info_to_dev(ptr); 565 struct ipvl_dev *ipvlan, *next; 566 struct ipvl_port *port; 567 LIST_HEAD(lst_kill); 568 569 if (!netif_is_ipvlan_port(dev)) 570 return NOTIFY_DONE; 571 572 port = ipvlan_port_get_rtnl(dev); 573 574 switch (event) { 575 case NETDEV_CHANGE: 576 list_for_each_entry(ipvlan, &port->ipvlans, pnode) 577 netif_stacked_transfer_operstate(ipvlan->phy_dev, 578 ipvlan->dev); 579 break; 580 581 case NETDEV_UNREGISTER: 582 if (dev->reg_state != NETREG_UNREGISTERING) 583 break; 584 585 list_for_each_entry_safe(ipvlan, next, &port->ipvlans, 586 pnode) 587 ipvlan->dev->rtnl_link_ops->dellink(ipvlan->dev, 588 &lst_kill); 589 unregister_netdevice_many(&lst_kill); 590 break; 591 592 case NETDEV_FEAT_CHANGE: 593 list_for_each_entry(ipvlan, &port->ipvlans, pnode) { 594 ipvlan->dev->features = dev->features & IPVLAN_FEATURES; 595 ipvlan->dev->gso_max_size = dev->gso_max_size; 596 ipvlan->dev->gso_max_segs = dev->gso_max_segs; 597 netdev_features_change(ipvlan->dev); 598 } 599 break; 600 601 case NETDEV_CHANGEMTU: 602 list_for_each_entry(ipvlan, &port->ipvlans, pnode) 603 ipvlan_adjust_mtu(ipvlan, dev); 604 break; 605 606 case NETDEV_PRE_TYPE_CHANGE: 607 /* Forbid underlying device to change its type. */ 608 return NOTIFY_BAD; 609 } 610 return NOTIFY_DONE; 611 } 612 613 static int ipvlan_add_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr) 614 { 615 struct ipvl_addr *addr; 616 617 if (ipvlan_addr_busy(ipvlan->port, ip6_addr, true)) { 618 netif_err(ipvlan, ifup, ipvlan->dev, 619 "Failed to add IPv6=%pI6c addr for %s intf\n", 620 ip6_addr, ipvlan->dev->name); 621 return -EINVAL; 622 } 623 addr = kzalloc(sizeof(struct ipvl_addr), GFP_ATOMIC); 624 if (!addr) 625 return -ENOMEM; 626 627 addr->master = ipvlan; 628 memcpy(&addr->ip6addr, ip6_addr, sizeof(struct in6_addr)); 629 addr->atype = IPVL_IPV6; 630 list_add_tail(&addr->anode, &ipvlan->addrs); 631 632 /* If the interface is not up, the address will be added to the hash 633 * list by ipvlan_open. 634 */ 635 if (netif_running(ipvlan->dev)) 636 ipvlan_ht_addr_add(ipvlan, addr); 637 638 return 0; 639 } 640 641 static void ipvlan_del_addr6(struct ipvl_dev *ipvlan, struct in6_addr *ip6_addr) 642 { 643 struct ipvl_addr *addr; 644 645 addr = ipvlan_find_addr(ipvlan, ip6_addr, true); 646 if (!addr) 647 return; 648 649 ipvlan_ht_addr_del(addr); 650 list_del(&addr->anode); 651 kfree_rcu(addr, rcu); 652 653 return; 654 } 655 656 static int ipvlan_addr6_event(struct notifier_block *unused, 657 unsigned long event, void *ptr) 658 { 659 struct inet6_ifaddr *if6 = (struct inet6_ifaddr *)ptr; 660 struct net_device *dev = (struct net_device *)if6->idev->dev; 661 struct ipvl_dev *ipvlan = netdev_priv(dev); 662 663 /* FIXME IPv6 autoconf calls us from bh without RTNL */ 664 if (in_softirq()) 665 return NOTIFY_DONE; 666 667 if (!netif_is_ipvlan(dev)) 668 return NOTIFY_DONE; 669 670 if (!ipvlan || !ipvlan->port) 671 return NOTIFY_DONE; 672 673 switch (event) { 674 case NETDEV_UP: 675 if (ipvlan_add_addr6(ipvlan, &if6->addr)) 676 return NOTIFY_BAD; 677 break; 678 679 case NETDEV_DOWN: 680 ipvlan_del_addr6(ipvlan, &if6->addr); 681 break; 682 } 683 684 return NOTIFY_OK; 685 } 686 687 static int ipvlan_add_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr) 688 { 689 struct ipvl_addr *addr; 690 691 if (ipvlan_addr_busy(ipvlan->port, ip4_addr, false)) { 692 netif_err(ipvlan, ifup, ipvlan->dev, 693 "Failed to add IPv4=%pI4 on %s intf.\n", 694 ip4_addr, ipvlan->dev->name); 695 return -EINVAL; 696 } 697 addr = kzalloc(sizeof(struct ipvl_addr), GFP_KERNEL); 698 if (!addr) 699 return -ENOMEM; 700 701 addr->master = ipvlan; 702 memcpy(&addr->ip4addr, ip4_addr, sizeof(struct in_addr)); 703 addr->atype = IPVL_IPV4; 704 list_add_tail(&addr->anode, &ipvlan->addrs); 705 706 /* If the interface is not up, the address will be added to the hash 707 * list by ipvlan_open. 708 */ 709 if (netif_running(ipvlan->dev)) 710 ipvlan_ht_addr_add(ipvlan, addr); 711 712 return 0; 713 } 714 715 static void ipvlan_del_addr4(struct ipvl_dev *ipvlan, struct in_addr *ip4_addr) 716 { 717 struct ipvl_addr *addr; 718 719 addr = ipvlan_find_addr(ipvlan, ip4_addr, false); 720 if (!addr) 721 return; 722 723 ipvlan_ht_addr_del(addr); 724 list_del(&addr->anode); 725 kfree_rcu(addr, rcu); 726 727 return; 728 } 729 730 static int ipvlan_addr4_event(struct notifier_block *unused, 731 unsigned long event, void *ptr) 732 { 733 struct in_ifaddr *if4 = (struct in_ifaddr *)ptr; 734 struct net_device *dev = (struct net_device *)if4->ifa_dev->dev; 735 struct ipvl_dev *ipvlan = netdev_priv(dev); 736 struct in_addr ip4_addr; 737 738 if (!netif_is_ipvlan(dev)) 739 return NOTIFY_DONE; 740 741 if (!ipvlan || !ipvlan->port) 742 return NOTIFY_DONE; 743 744 switch (event) { 745 case NETDEV_UP: 746 ip4_addr.s_addr = if4->ifa_address; 747 if (ipvlan_add_addr4(ipvlan, &ip4_addr)) 748 return NOTIFY_BAD; 749 break; 750 751 case NETDEV_DOWN: 752 ip4_addr.s_addr = if4->ifa_address; 753 ipvlan_del_addr4(ipvlan, &ip4_addr); 754 break; 755 } 756 757 return NOTIFY_OK; 758 } 759 760 static struct notifier_block ipvlan_addr4_notifier_block __read_mostly = { 761 .notifier_call = ipvlan_addr4_event, 762 }; 763 764 static struct notifier_block ipvlan_notifier_block __read_mostly = { 765 .notifier_call = ipvlan_device_event, 766 }; 767 768 static struct notifier_block ipvlan_addr6_notifier_block __read_mostly = { 769 .notifier_call = ipvlan_addr6_event, 770 }; 771 772 static int __init ipvlan_init_module(void) 773 { 774 int err; 775 776 ipvlan_init_secret(); 777 register_netdevice_notifier(&ipvlan_notifier_block); 778 register_inet6addr_notifier(&ipvlan_addr6_notifier_block); 779 register_inetaddr_notifier(&ipvlan_addr4_notifier_block); 780 781 err = ipvlan_link_register(&ipvlan_link_ops); 782 if (err < 0) 783 goto error; 784 785 return 0; 786 error: 787 unregister_inetaddr_notifier(&ipvlan_addr4_notifier_block); 788 unregister_inet6addr_notifier(&ipvlan_addr6_notifier_block); 789 unregister_netdevice_notifier(&ipvlan_notifier_block); 790 return err; 791 } 792 793 static void __exit ipvlan_cleanup_module(void) 794 { 795 rtnl_link_unregister(&ipvlan_link_ops); 796 unregister_netdevice_notifier(&ipvlan_notifier_block); 797 unregister_inetaddr_notifier(&ipvlan_addr4_notifier_block); 798 unregister_inet6addr_notifier(&ipvlan_addr6_notifier_block); 799 } 800 801 module_init(ipvlan_init_module); 802 module_exit(ipvlan_cleanup_module); 803 804 MODULE_LICENSE("GPL"); 805 MODULE_AUTHOR("Mahesh Bandewar <maheshb@google.com>"); 806 MODULE_DESCRIPTION("Driver for L3 (IPv6/IPv4) based VLANs"); 807 MODULE_ALIAS_RTNL_LINK("ipvlan"); 808