Linux Audio

Check our new training course

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