[linux-2.6-block.git] / drivers / net / ipvlan / ipvlan_core.c

/* Copyright (c) 2014 Mahesh Bandewar <maheshb@google.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 *
 */

#include "ipvlan.h"

static u32 ipvlan_jhash_secret;

void ipvlan_init_secret(void)
{
	net_get_random_once(&ipvlan_jhash_secret, sizeof(ipvlan_jhash_secret));
}

static void ipvlan_count_rx(const struct ipvl_dev *ipvlan,
			    unsigned int len, bool success, bool mcast)
{
	if (!ipvlan)
		return;

	if (likely(success)) {
		struct ipvl_pcpu_stats *pcptr;

		pcptr = this_cpu_ptr(ipvlan->pcpu_stats);
		u64_stats_update_begin(&pcptr->syncp);
		pcptr->rx_pkts++;
		pcptr->rx_bytes += len;
		if (mcast)
			pcptr->rx_mcast++;
		u64_stats_update_end(&pcptr->syncp);
	} else {
		this_cpu_inc(ipvlan->pcpu_stats->rx_errs);
	}
}

static u8 ipvlan_get_v6_hash(const void *iaddr)
{
	const struct in6_addr *ip6_addr = iaddr;

	return __ipv6_addr_jhash(ip6_addr, ipvlan_jhash_secret) &
	       IPVLAN_HASH_MASK;
}

static u8 ipvlan_get_v4_hash(const void *iaddr)
{
	const struct in_addr *ip4_addr = iaddr;

	return jhash_1word(ip4_addr->s_addr, ipvlan_jhash_secret) &
	       IPVLAN_HASH_MASK;
}

struct ipvl_addr *ipvlan_ht_addr_lookup(const struct ipvl_port *port,
					const void *iaddr, bool is_v6)
{
	struct ipvl_addr *addr;
	u8 hash;

	hash = is_v6 ? ipvlan_get_v6_hash(iaddr) :
	       ipvlan_get_v4_hash(iaddr);
	hlist_for_each_entry_rcu(addr, &port->hlhead[hash], hlnode) {
		if (is_v6 && addr->atype == IPVL_IPV6 &&
		    ipv6_addr_equal(&addr->ip6addr, iaddr))
			return addr;
		else if (!is_v6 && addr->atype == IPVL_IPV4 &&
			 addr->ip4addr.s_addr ==
				((struct in_addr *)iaddr)->s_addr)
			return addr;
	}
	return NULL;
}

void ipvlan_ht_addr_add(struct ipvl_dev *ipvlan, struct ipvl_addr *addr)
{
	struct ipvl_port *port = ipvlan->port;
	u8 hash;

	hash = (addr->atype == IPVL_IPV6) ?
	       ipvlan_get_v6_hash(&addr->ip6addr) :
	       ipvlan_get_v4_hash(&addr->ip4addr);
	hlist_add_head_rcu(&addr->hlnode, &port->hlhead[hash]);
}

void ipvlan_ht_addr_del(struct ipvl_addr *addr, bool sync)
{
	hlist_del_rcu(&addr->hlnode);
	if (sync)
		synchronize_rcu();
}

bool ipvlan_addr_busy(struct ipvl_dev *ipvlan, void *iaddr, bool is_v6)
{
	struct ipvl_port *port = ipvlan->port;
	struct ipvl_addr *addr;

	list_for_each_entry(addr, &ipvlan->addrs, anode) {
		if ((is_v6 && addr->atype == IPVL_IPV6 &&
		    ipv6_addr_equal(&addr->ip6addr, iaddr)) ||
		    (!is_v6 && addr->atype == IPVL_IPV4 &&
		    addr->ip4addr.s_addr == ((struct in_addr *)iaddr)->s_addr))
			return true;
	}

	if (ipvlan_ht_addr_lookup(port, iaddr, is_v6))
		return true;

	return false;
}

static void *ipvlan_get_L3_hdr(struct sk_buff *skb, int *type)
{
	void *lyr3h = NULL;

	switch (skb->protocol) {
	case htons(ETH_P_ARP): {
		struct arphdr *arph;

		if (unlikely(!pskb_may_pull(skb, sizeof(*arph))))
			return NULL;

		arph = arp_hdr(skb);
		*type = IPVL_ARP;
		lyr3h = arph;
		break;
	}
	case htons(ETH_P_IP): {
		u32 pktlen;
		struct iphdr *ip4h;

		if (unlikely(!pskb_may_pull(skb, sizeof(*ip4h))))
			return NULL;

		ip4h = ip_hdr(skb);
		pktlen = ntohs(ip4h->tot_len);
		if (ip4h->ihl < 5 || ip4h->version != 4)
			return NULL;
		if (skb->len < pktlen || pktlen < (ip4h->ihl * 4))
			return NULL;

		*type = IPVL_IPV4;
		lyr3h = ip4h;
		break;
	}
	case htons(ETH_P_IPV6): {
		struct ipv6hdr *ip6h;

		if (unlikely(!pskb_may_pull(skb, sizeof(*ip6h))))
			return NULL;

		ip6h = ipv6_hdr(skb);
		if (ip6h->version != 6)
			return NULL;

		*type = IPVL_IPV6;
		lyr3h = ip6h;
		/* Only Neighbour Solicitation pkts need different treatment */
		if (ipv6_addr_any(&ip6h->saddr) &&
		    ip6h->nexthdr == NEXTHDR_ICMP) {
			*type = IPVL_ICMPV6;
			lyr3h = ip6h + 1;
		}
		break;
	}
	default:
		return NULL;
	}

	return lyr3h;
}

unsigned int ipvlan_mac_hash(const unsigned char *addr)
{
	u32 hash = jhash_1word(__get_unaligned_cpu32(addr+2),
			       ipvlan_jhash_secret);

	return hash & IPVLAN_MAC_FILTER_MASK;
}

static void ipvlan_multicast_frame(struct ipvl_port *port, struct sk_buff *skb,
				   const struct ipvl_dev *in_dev, bool local)
{
	struct ethhdr *eth = eth_hdr(skb);
	struct ipvl_dev *ipvlan;
	struct sk_buff *nskb;
	unsigned int len;
	unsigned int mac_hash;
	int ret;

	if (skb->protocol == htons(ETH_P_PAUSE))
		return;

	list_for_each_entry(ipvlan, &port->ipvlans, pnode) {
		if (local && (ipvlan == in_dev))
			continue;

		mac_hash = ipvlan_mac_hash(eth->h_dest);
		if (!test_bit(mac_hash, ipvlan->mac_filters))
			continue;

		ret = NET_RX_DROP;
		len = skb->len + ETH_HLEN;
		nskb = skb_clone(skb, GFP_ATOMIC);
		if (!nskb)
			goto mcast_acct;

		if (ether_addr_equal(eth->h_dest, ipvlan->phy_dev->broadcast))
			nskb->pkt_type = PACKET_BROADCAST;
		else
			nskb->pkt_type = PACKET_MULTICAST;

		nskb->dev = ipvlan->dev;
		if (local)
			ret = dev_forward_skb(ipvlan->dev, nskb);
		else
			ret = netif_rx(nskb);
mcast_acct:
		ipvlan_count_rx(ipvlan, len, ret == NET_RX_SUCCESS, true);
	}

	/* Locally generated? ...Forward a copy to the main-device as
	 * well. On the RX side we'll ignore it (wont give it to any
	 * of the virtual devices.
	 */
	if (local) {
		nskb = skb_clone(skb, GFP_ATOMIC);
		if (nskb) {
			if (ether_addr_equal(eth->h_dest, port->dev->broadcast))
				nskb->pkt_type = PACKET_BROADCAST;
			else
				nskb->pkt_type = PACKET_MULTICAST;

			dev_forward_skb(port->dev, nskb);
		}
	}
}

static int ipvlan_rcv_frame(struct ipvl_addr *addr, struct sk_buff *skb,
			    bool local)
{
	struct ipvl_dev *ipvlan = addr->master;
	struct net_device *dev = ipvlan->dev;
	unsigned int len;
	rx_handler_result_t ret = RX_HANDLER_CONSUMED;
	bool success = false;

	len = skb->len + ETH_HLEN;
	if (unlikely(!(dev->flags & IFF_UP))) {
		kfree_skb(skb);
		goto out;
	}

	skb = skb_share_check(skb, GFP_ATOMIC);
	if (!skb)
		goto out;

	skb->dev = dev;
	skb->pkt_type = PACKET_HOST;

	if (local) {
		if (dev_forward_skb(ipvlan->dev, skb) == NET_RX_SUCCESS)
			success = true;
	} else {
		ret = RX_HANDLER_ANOTHER;
		success = true;
	}

out:
	ipvlan_count_rx(ipvlan, len, success, false);
	return ret;
}

static struct ipvl_addr *ipvlan_addr_lookup(struct ipvl_port *port,
					    void *lyr3h, int addr_type,
					    bool use_dest)
{
	struct ipvl_addr *addr = NULL;

	if (addr_type == IPVL_IPV6) {
		struct ipv6hdr *ip6h;
		struct in6_addr *i6addr;

		ip6h = (struct ipv6hdr *)lyr3h;
		i6addr = use_dest ? &ip6h->daddr : &ip6h->saddr;
		addr = ipvlan_ht_addr_lookup(port, i6addr, true);
	} else if (addr_type == IPVL_ICMPV6) {
		struct nd_msg *ndmh;
		struct in6_addr *i6addr;

		/* Make sure that the NeighborSolicitation ICMPv6 packets
		 * are handled to avoid DAD issue.
		 */
		ndmh = (struct nd_msg *)lyr3h;
		if (ndmh->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION) {
			i6addr = &ndmh->target;
			addr = ipvlan_ht_addr_lookup(port, i6addr, true);
		}
	} else if (addr_type == IPVL_IPV4) {
		struct iphdr *ip4h;
		__be32 *i4addr;

		ip4h = (struct iphdr *)lyr3h;
		i4addr = use_dest ? &ip4h->daddr : &ip4h->saddr;
		addr = ipvlan_ht_addr_lookup(port, i4addr, false);
	} else if (addr_type == IPVL_ARP) {
		struct arphdr *arph;
		unsigned char *arp_ptr;
		__be32 dip;

		arph = (struct arphdr *)lyr3h;
		arp_ptr = (unsigned char *)(arph + 1);
		if (use_dest)
			arp_ptr += (2 * port->dev->addr_len) + 4;
		else
			arp_ptr += port->dev->addr_len;

		memcpy(&dip, arp_ptr, 4);
		addr = ipvlan_ht_addr_lookup(port, &dip, false);
	}

	return addr;
}

static int ipvlan_process_v4_outbound(struct sk_buff *skb)
{
	const struct iphdr *ip4h = ip_hdr(skb);
	struct net_device *dev = skb->dev;
	struct rtable *rt;
	int err, ret = NET_XMIT_DROP;
	struct flowi4 fl4 = {
		.flowi4_oif = dev->iflink,
		.flowi4_tos = RT_TOS(ip4h->tos),
		.flowi4_flags = FLOWI_FLAG_ANYSRC,
		.daddr = ip4h->daddr,
		.saddr = ip4h->saddr,
	};

	rt = ip_route_output_flow(dev_net(dev), &fl4, NULL);
	if (IS_ERR(rt))
		goto err;

	if (rt->rt_type != RTN_UNICAST && rt->rt_type != RTN_LOCAL) {
		ip_rt_put(rt);
		goto err;
	}
	skb_dst_drop(skb);
	skb_dst_set(skb, &rt->dst);
	err = ip_local_out(skb);
	if (unlikely(net_xmit_eval(err)))
		dev->stats.tx_errors++;
	else
		ret = NET_XMIT_SUCCESS;
	goto out;
err:
	dev->stats.tx_errors++;
	kfree_skb(skb);
out:
	return ret;
}

static int ipvlan_process_v6_outbound(struct sk_buff *skb)
{
	const struct ipv6hdr *ip6h = ipv6_hdr(skb);
	struct net_device *dev = skb->dev;
	struct dst_entry *dst;
	int err, ret = NET_XMIT_DROP;
	struct flowi6 fl6 = {
		.flowi6_iif = skb->dev->ifindex,
		.daddr = ip6h->daddr,
		.saddr = ip6h->saddr,
		.flowi6_flags = FLOWI_FLAG_ANYSRC,
		.flowlabel = ip6_flowinfo(ip6h),
		.flowi6_mark = skb->mark,
		.flowi6_proto = ip6h->nexthdr,
	};

	dst = ip6_route_output(dev_net(dev), NULL, &fl6);
	if (IS_ERR(dst))
		goto err;

	skb_dst_drop(skb);
	skb_dst_set(skb, dst);
	err = ip6_local_out(skb);
	if (unlikely(net_xmit_eval(err)))
		dev->stats.tx_errors++;
	else
		ret = NET_XMIT_SUCCESS;
	goto out;
err:
	dev->stats.tx_errors++;
	kfree_skb(skb);
out:
	return ret;
}

static int ipvlan_process_outbound(struct sk_buff *skb,
				   const struct ipvl_dev *ipvlan)
{
	struct ethhdr *ethh = eth_hdr(skb);
	int ret = NET_XMIT_DROP;

	/* In this mode we dont care about multicast and broadcast traffic */
	if (is_multicast_ether_addr(ethh->h_dest)) {
		pr_warn_ratelimited("Dropped {multi|broad}cast of type= [%x]\n",
				    ntohs(skb->protocol));
		kfree_skb(skb);
		goto out;
	}

	/* The ipvlan is a pseudo-L2 device, so the packets that we receive
	 * will have L2; which need to discarded and processed further
	 * in the net-ns of the main-device.
	 */
	if (skb_mac_header_was_set(skb)) {
		skb_pull(skb, sizeof(*ethh));
		skb->mac_header = (typeof(skb->mac_header))~0U;
		skb_reset_network_header(skb);
	}

	if (skb->protocol == htons(ETH_P_IPV6))
		ret = ipvlan_process_v6_outbound(skb);
	else if (skb->protocol == htons(ETH_P_IP))
		ret = ipvlan_process_v4_outbound(skb);
	else {
		pr_warn_ratelimited("Dropped outbound packet type=%x\n",
				    ntohs(skb->protocol));
		kfree_skb(skb);
	}
out:
	return ret;
}

static int ipvlan_xmit_mode_l3(struct sk_buff *skb, struct net_device *dev)
{
	const struct ipvl_dev *ipvlan = netdev_priv(dev);
	void *lyr3h;
	struct ipvl_addr *addr;
	int addr_type;

	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
	if (!lyr3h)
		goto out;

	addr = ipvlan_addr_lookup(ipvlan->port, lyr3h, addr_type, true);
	if (addr)
		return ipvlan_rcv_frame(addr, skb, true);

out:
	skb->dev = ipvlan->phy_dev;
	return ipvlan_process_outbound(skb, ipvlan);
}

static int ipvlan_xmit_mode_l2(struct sk_buff *skb, struct net_device *dev)
{
	const struct ipvl_dev *ipvlan = netdev_priv(dev);
	struct ethhdr *eth = eth_hdr(skb);
	struct ipvl_addr *addr;
	void *lyr3h;
	int addr_type;

	if (ether_addr_equal(eth->h_dest, eth->h_source)) {
		lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
		if (lyr3h) {
			addr = ipvlan_addr_lookup(ipvlan->port, lyr3h, addr_type, true);
			if (addr)
				return ipvlan_rcv_frame(addr, skb, true);
		}
		skb = skb_share_check(skb, GFP_ATOMIC);
		if (!skb)
			return NET_XMIT_DROP;

		/* Packet definitely does not belong to any of the
		 * virtual devices, but the dest is local. So forward
		 * the skb for the main-dev. At the RX side we just return
		 * RX_PASS for it to be processed further on the stack.
		 */
		return dev_forward_skb(ipvlan->phy_dev, skb);

	} else if (is_multicast_ether_addr(eth->h_dest)) {
		u8 ip_summed = skb->ip_summed;

		skb->ip_summed = CHECKSUM_UNNECESSARY;
		ipvlan_multicast_frame(ipvlan->port, skb, ipvlan, true);
		skb->ip_summed = ip_summed;
	}

	skb->dev = ipvlan->phy_dev;
	return dev_queue_xmit(skb);
}

int ipvlan_queue_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ipvl_dev *ipvlan = netdev_priv(dev);
	struct ipvl_port *port = ipvlan_port_get_rcu(ipvlan->phy_dev);

	if (!port)
		goto out;

	if (unlikely(!pskb_may_pull(skb, sizeof(struct ethhdr))))
		goto out;

	switch(port->mode) {
	case IPVLAN_MODE_L2:
		return ipvlan_xmit_mode_l2(skb, dev);
	case IPVLAN_MODE_L3:
		return ipvlan_xmit_mode_l3(skb, dev);
	}

	/* Should not reach here */
	WARN_ONCE(true, "ipvlan_queue_xmit() called for mode = [%hx]\n",
			  port->mode);
out:
	kfree_skb(skb);
	return NET_XMIT_DROP;
}

static bool ipvlan_external_frame(struct sk_buff *skb, struct ipvl_port *port)
{
	struct ethhdr *eth = eth_hdr(skb);
	struct ipvl_addr *addr;
	void *lyr3h;
	int addr_type;

	if (ether_addr_equal(eth->h_source, skb->dev->dev_addr)) {
		lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
		if (!lyr3h)
			return true;

		addr = ipvlan_addr_lookup(port, lyr3h, addr_type, false);
		if (addr)
			return false;
	}

	return true;
}

static rx_handler_result_t ipvlan_handle_mode_l3(struct sk_buff **pskb,
						 struct ipvl_port *port)
{
	void *lyr3h;
	int addr_type;
	struct ipvl_addr *addr;
	struct sk_buff *skb = *pskb;
	rx_handler_result_t ret = RX_HANDLER_PASS;

	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
	if (!lyr3h)
		goto out;

	addr = ipvlan_addr_lookup(port, lyr3h, addr_type, true);
	if (addr)
		ret = ipvlan_rcv_frame(addr, skb, false);

out:
	return ret;
}

static rx_handler_result_t ipvlan_handle_mode_l2(struct sk_buff **pskb,
						 struct ipvl_port *port)
{
	struct sk_buff *skb = *pskb;
	struct ethhdr *eth = eth_hdr(skb);
	rx_handler_result_t ret = RX_HANDLER_PASS;
	void *lyr3h;
	int addr_type;

	if (is_multicast_ether_addr(eth->h_dest)) {
		if (ipvlan_external_frame(skb, port))
			ipvlan_multicast_frame(port, skb, NULL, false);
	} else {
		struct ipvl_addr *addr;

		lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
		if (!lyr3h)
			return ret;

		addr = ipvlan_addr_lookup(port, lyr3h, addr_type, true);
		if (addr)
			ret = ipvlan_rcv_frame(addr, skb, false);
	}

	return ret;
}

rx_handler_result_t ipvlan_handle_frame(struct sk_buff **pskb)
{
	struct sk_buff *skb = *pskb;
	struct ipvl_port *port = ipvlan_port_get_rcu(skb->dev);

	if (!port)
		return RX_HANDLER_PASS;

	switch (port->mode) {
	case IPVLAN_MODE_L2:
		return ipvlan_handle_mode_l2(pskb, port);
	case IPVLAN_MODE_L3:
		return ipvlan_handle_mode_l3(pskb, port);
	}

	/* Should not reach here */
	WARN_ONCE(true, "ipvlan_handle_frame() called for mode = [%hx]\n",
			  port->mode);
	kfree_skb(skb);
	return NET_RX_DROP;
}
Commit	Line	Data
2ad7bf36 MB	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 u32 ipvlan_jhash_secret;
	13
	14	void ipvlan_init_secret(void)
	15	{
	16	net_get_random_once(&ipvlan_jhash_secret, sizeof(ipvlan_jhash_secret));
	17	}
	18
	19	static void ipvlan_count_rx(const struct ipvl_dev *ipvlan,
	20	unsigned int len, bool success, bool mcast)
	21	{
	22	if (!ipvlan)
	23	return;
	24
	25	if (likely(success)) {
	26	struct ipvl_pcpu_stats *pcptr;
	27
	28	pcptr = this_cpu_ptr(ipvlan->pcpu_stats);
	29	u64_stats_update_begin(&pcptr->syncp);
	30	pcptr->rx_pkts++;
	31	pcptr->rx_bytes += len;
	32	if (mcast)
	33	pcptr->rx_mcast++;
	34	u64_stats_update_end(&pcptr->syncp);
	35	} else {
	36	this_cpu_inc(ipvlan->pcpu_stats->rx_errs);
	37	}
	38	}
	39
	40	static u8 ipvlan_get_v6_hash(const void *iaddr)
	41	{
	42	const struct in6_addr *ip6_addr = iaddr;
	43
	44	return __ipv6_addr_jhash(ip6_addr, ipvlan_jhash_secret) &
	45	IPVLAN_HASH_MASK;
	46	}
	47
	48	static u8 ipvlan_get_v4_hash(const void *iaddr)
	49	{
	50	const struct in_addr *ip4_addr = iaddr;
	51
	52	return jhash_1word(ip4_addr->s_addr, ipvlan_jhash_secret) &
	53	IPVLAN_HASH_MASK;
	54	}
	55
	56	struct ipvl_addr ipvlan_ht_addr_lookup(const struct ipvl_port port,
	57	const void *iaddr, bool is_v6)
	58	{
	59	struct ipvl_addr *addr;
	60	u8 hash;
	61
	62	hash = is_v6 ? ipvlan_get_v6_hash(iaddr) :
	63	ipvlan_get_v4_hash(iaddr);
	64	hlist_for_each_entry_rcu(addr, &port->hlhead[hash], hlnode) {
65	if (is_v6 && addr->atype == IPVL_IPV6 &&
66	ipv6_addr_equal(&addr->ip6addr, iaddr))
67	return addr;
68	else if (!is_v6 && addr->atype == IPVL_IPV4 &&
69	addr->ip4addr.s_addr ==
70	((struct in_addr *)iaddr)->s_addr)
71	return addr;
72	}
73	return NULL;
74	}
75
76	void ipvlan_ht_addr_add(struct ipvl_dev ipvlan, struct ipvl_addr addr)
77	{
78	struct ipvl_port *port = ipvlan->port;
79	u8 hash;
80
81	hash = (addr->atype == IPVL_IPV6) ?
82	ipvlan_get_v6_hash(&addr->ip6addr) :
83	ipvlan_get_v4_hash(&addr->ip4addr);
84	hlist_add_head_rcu(&addr->hlnode, &port->hlhead[hash]);
85	}
86
87	void ipvlan_ht_addr_del(struct ipvl_addr *addr, bool sync)
88	{
89	hlist_del_rcu(&addr->hlnode);
90	if (sync)
91	synchronize_rcu();
92	}
93
94	bool ipvlan_addr_busy(struct ipvl_dev ipvlan, void iaddr, bool is_v6)
95	{
96	struct ipvl_port *port = ipvlan->port;
97	struct ipvl_addr *addr;
98
99	list_for_each_entry(addr, &ipvlan->addrs, anode) {
100	if ((is_v6 && addr->atype == IPVL_IPV6 &&
101	ipv6_addr_equal(&addr->ip6addr, iaddr)) \|\|
102	(!is_v6 && addr->atype == IPVL_IPV4 &&
103	addr->ip4addr.s_addr == ((struct in_addr *)iaddr)->s_addr))
104	return true;
105	}
106
107	if (ipvlan_ht_addr_lookup(port, iaddr, is_v6))
108	return true;
109
110	return false;
111	}
112
113	static void ipvlan_get_L3_hdr(struct sk_buff skb, int *type)
114	{
115	void *lyr3h = NULL;
116
117	switch (skb->protocol) {
118	case htons(ETH_P_ARP): {
119	struct arphdr *arph;
120
121	if (unlikely(!pskb_may_pull(skb, sizeof(*arph))))
122	return NULL;
123
124	arph = arp_hdr(skb);
125	*type = IPVL_ARP;
126	lyr3h = arph;
127	break;
128	}
129	case htons(ETH_P_IP): {
130	u32 pktlen;
131	struct iphdr *ip4h;
132
133	if (unlikely(!pskb_may_pull(skb, sizeof(*ip4h))))
134	return NULL;
135
136	ip4h = ip_hdr(skb);
137	pktlen = ntohs(ip4h->tot_len);
138	if (ip4h->ihl < 5 \|\| ip4h->version != 4)
139	return NULL;
140	if (skb->len < pktlen \|\| pktlen < (ip4h->ihl * 4))
141	return NULL;
142
143	*type = IPVL_IPV4;
144	lyr3h = ip4h;
145	break;
146	}
147	case htons(ETH_P_IPV6): {
148	struct ipv6hdr *ip6h;
149
150	if (unlikely(!pskb_may_pull(skb, sizeof(*ip6h))))
151	return NULL;
152
153	ip6h = ipv6_hdr(skb);
154	if (ip6h->version != 6)
155	return NULL;
156
157	*type = IPVL_IPV6;
158	lyr3h = ip6h;
159	/* Only Neighbour Solicitation pkts need different treatment */
160	if (ipv6_addr_any(&ip6h->saddr) &&
161	ip6h->nexthdr == NEXTHDR_ICMP) {
162	*type = IPVL_ICMPV6;
163	lyr3h = ip6h + 1;
164	}
165	break;
166	}
167	default:
168	return NULL;
169	}
170
171	return lyr3h;
172	}
173
174	unsigned int ipvlan_mac_hash(const unsigned char *addr)
175	{
176	u32 hash = jhash_1word(__get_unaligned_cpu32(addr+2),
177	ipvlan_jhash_secret);
178
179	return hash & IPVLAN_MAC_FILTER_MASK;
180	}
181
182	static void ipvlan_multicast_frame(struct ipvl_port port, struct sk_buff skb,
183	const struct ipvl_dev *in_dev, bool local)
184	{
185	struct ethhdr *eth = eth_hdr(skb);
186	struct ipvl_dev *ipvlan;
187	struct sk_buff *nskb;
188	unsigned int len;
189	unsigned int mac_hash;
190	int ret;
191
192	if (skb->protocol == htons(ETH_P_PAUSE))
193	return;
194
195	list_for_each_entry(ipvlan, &port->ipvlans, pnode) {
196	if (local && (ipvlan == in_dev))
197	continue;
198
199	mac_hash = ipvlan_mac_hash(eth->h_dest);
200	if (!test_bit(mac_hash, ipvlan->mac_filters))
201	continue;
202
203	ret = NET_RX_DROP;
204	len = skb->len + ETH_HLEN;
205	nskb = skb_clone(skb, GFP_ATOMIC);
206	if (!nskb)
207	goto mcast_acct;
208
209	if (ether_addr_equal(eth->h_dest, ipvlan->phy_dev->broadcast))
210	nskb->pkt_type = PACKET_BROADCAST;
211	else
212	nskb->pkt_type = PACKET_MULTICAST;
213
214	nskb->dev = ipvlan->dev;
215	if (local)
216	ret = dev_forward_skb(ipvlan->dev, nskb);
217	else
218	ret = netif_rx(nskb);
219	mcast_acct:
220	ipvlan_count_rx(ipvlan, len, ret == NET_RX_SUCCESS, true);
221	}
222
223	/* Locally generated? ...Forward a copy to the main-device as
224	* well. On the RX side we'll ignore it (wont give it to any
225	* of the virtual devices.
226	*/
227	if (local) {
228	nskb = skb_clone(skb, GFP_ATOMIC);
229	if (nskb) {
230	if (ether_addr_equal(eth->h_dest, port->dev->broadcast))
231	nskb->pkt_type = PACKET_BROADCAST;
232	else
233	nskb->pkt_type = PACKET_MULTICAST;
234
235	dev_forward_skb(port->dev, nskb);
236	}
237	}
238	}
239
240	static int ipvlan_rcv_frame(struct ipvl_addr addr, struct sk_buff skb,
241	bool local)
242	{
243	struct ipvl_dev *ipvlan = addr->master;
244	struct net_device *dev = ipvlan->dev;
245	unsigned int len;
246	rx_handler_result_t ret = RX_HANDLER_CONSUMED;
247	bool success = false;
248
249	len = skb->len + ETH_HLEN;
250	if (unlikely(!(dev->flags & IFF_UP))) {
251	kfree_skb(skb);
252	goto out;
253	}
254
255	skb = skb_share_check(skb, GFP_ATOMIC);
256	if (!skb)
257	goto out;
258
259	skb->dev = dev;
260	skb->pkt_type = PACKET_HOST;
261
262	if (local) {
263	if (dev_forward_skb(ipvlan->dev, skb) == NET_RX_SUCCESS)
264	success = true;
265	} else {
266	ret = RX_HANDLER_ANOTHER;
267	success = true;
268	}
269
270	out:
271	ipvlan_count_rx(ipvlan, len, success, false);
272	return ret;
273	}
274
275	static struct ipvl_addr ipvlan_addr_lookup(struct ipvl_port port,
276	void *lyr3h, int addr_type,
277	bool use_dest)
278	{
279	struct ipvl_addr *addr = NULL;
280
281	if (addr_type == IPVL_IPV6) {
282	struct ipv6hdr *ip6h;
283	struct in6_addr *i6addr;
284
285	ip6h = (struct ipv6hdr *)lyr3h;
286	i6addr = use_dest ? &ip6h->daddr : &ip6h->saddr;
287	addr = ipvlan_ht_addr_lookup(port, i6addr, true);
288	} else if (addr_type == IPVL_ICMPV6) {
289	struct nd_msg *ndmh;
290	struct in6_addr *i6addr;
291
292	/* Make sure that the NeighborSolicitation ICMPv6 packets
293	* are handled to avoid DAD issue.
294	*/
295	ndmh = (struct nd_msg *)lyr3h;
296	if (ndmh->icmph.icmp6_type == NDISC_NEIGHBOUR_SOLICITATION) {
297	i6addr = &ndmh->target;
298	addr = ipvlan_ht_addr_lookup(port, i6addr, true);
299	}
300	} else if (addr_type == IPVL_IPV4) {
301	struct iphdr *ip4h;
302	__be32 *i4addr;
303
304	ip4h = (struct iphdr *)lyr3h;
305	i4addr = use_dest ? &ip4h->daddr : &ip4h->saddr;
306	addr = ipvlan_ht_addr_lookup(port, i4addr, false);
307	} else if (addr_type == IPVL_ARP) {
308	struct arphdr *arph;
309	unsigned char *arp_ptr;
310	__be32 dip;
311
312	arph = (struct arphdr *)lyr3h;
313	arp_ptr = (unsigned char *)(arph + 1);
314	if (use_dest)
315	arp_ptr += (2 * port->dev->addr_len) + 4;
316	else
317	arp_ptr += port->dev->addr_len;
318
319	memcpy(&dip, arp_ptr, 4);
320	addr = ipvlan_ht_addr_lookup(port, &dip, false);
321	}
322
323	return addr;
324	}
325
326	static int ipvlan_process_v4_outbound(struct sk_buff *skb)
327	{
328	const struct iphdr *ip4h = ip_hdr(skb);
329	struct net_device *dev = skb->dev;
330	struct rtable *rt;
331	int err, ret = NET_XMIT_DROP;
332	struct flowi4 fl4 = {
333	.flowi4_oif = dev->iflink,
334	.flowi4_tos = RT_TOS(ip4h->tos),
335	.flowi4_flags = FLOWI_FLAG_ANYSRC,
336	.daddr = ip4h->daddr,
337	.saddr = ip4h->saddr,
338	};
339
340	rt = ip_route_output_flow(dev_net(dev), &fl4, NULL);
341	if (IS_ERR(rt))
342	goto err;
343
344	if (rt->rt_type != RTN_UNICAST && rt->rt_type != RTN_LOCAL) {
345	ip_rt_put(rt);
346	goto err;
347	}
348	skb_dst_drop(skb);
349	skb_dst_set(skb, &rt->dst);
350	err = ip_local_out(skb);
351	if (unlikely(net_xmit_eval(err)))
352	dev->stats.tx_errors++;
353	else
354	ret = NET_XMIT_SUCCESS;
355	goto out;
356	err:
357	dev->stats.tx_errors++;
358	kfree_skb(skb);
359	out:
360	return ret;
361	}
362
363	static int ipvlan_process_v6_outbound(struct sk_buff *skb)
364	{
365	const struct ipv6hdr *ip6h = ipv6_hdr(skb);
366	struct net_device *dev = skb->dev;
367	struct dst_entry *dst;
368	int err, ret = NET_XMIT_DROP;
369	struct flowi6 fl6 = {
370	.flowi6_iif = skb->dev->ifindex,
371	.daddr = ip6h->daddr,
372	.saddr = ip6h->saddr,
373	.flowi6_flags = FLOWI_FLAG_ANYSRC,
374	.flowlabel = ip6_flowinfo(ip6h),
375	.flowi6_mark = skb->mark,
376	.flowi6_proto = ip6h->nexthdr,
377	};
378
379	dst = ip6_route_output(dev_net(dev), NULL, &fl6);
380	if (IS_ERR(dst))
381	goto err;
382
383	skb_dst_drop(skb);
384	skb_dst_set(skb, dst);
385	err = ip6_local_out(skb);
386	if (unlikely(net_xmit_eval(err)))
387	dev->stats.tx_errors++;
388	else
389	ret = NET_XMIT_SUCCESS;
390	goto out;
391	err:
392	dev->stats.tx_errors++;
393	kfree_skb(skb);
394	out:
395	return ret;
396	}
397
398	static int ipvlan_process_outbound(struct sk_buff *skb,
399	const struct ipvl_dev *ipvlan)
400	{
401	struct ethhdr *ethh = eth_hdr(skb);
402	int ret = NET_XMIT_DROP;
403
404	/* In this mode we dont care about multicast and broadcast traffic */
405	if (is_multicast_ether_addr(ethh->h_dest)) {
406	pr_warn_ratelimited("Dropped {multi\|broad}cast of type= [%x]\n",
407	ntohs(skb->protocol));
408	kfree_skb(skb);
409	goto out;
410	}
411
412	/* The ipvlan is a pseudo-L2 device, so the packets that we receive
413	* will have L2; which need to discarded and processed further
414	* in the net-ns of the main-device.
415	*/
416	if (skb_mac_header_was_set(skb)) {
417	skb_pull(skb, sizeof(*ethh));
418	skb->mac_header = (typeof(skb->mac_header))~0U;
419	skb_reset_network_header(skb);
420	}
421
422	if (skb->protocol == htons(ETH_P_IPV6))
423	ret = ipvlan_process_v6_outbound(skb);
424	else if (skb->protocol == htons(ETH_P_IP))
425	ret = ipvlan_process_v4_outbound(skb);
426	else {
427	pr_warn_ratelimited("Dropped outbound packet type=%x\n",
428	ntohs(skb->protocol));
429	kfree_skb(skb);
430	}
431	out:
432	return ret;
433	}
434
435	static int ipvlan_xmit_mode_l3(struct sk_buff skb, struct net_device dev)
436	{
437	const struct ipvl_dev *ipvlan = netdev_priv(dev);
438	void *lyr3h;
439	struct ipvl_addr *addr;
440	int addr_type;
441
442	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
443	if (!lyr3h)
444	goto out;
445
446	addr = ipvlan_addr_lookup(ipvlan->port, lyr3h, addr_type, true);
447	if (addr)
448	return ipvlan_rcv_frame(addr, skb, true);
449
450	out:
451	skb->dev = ipvlan->phy_dev;
452	return ipvlan_process_outbound(skb, ipvlan);
453	}
454
455	static int ipvlan_xmit_mode_l2(struct sk_buff skb, struct net_device dev)
456	{
457	const struct ipvl_dev *ipvlan = netdev_priv(dev);
458	struct ethhdr *eth = eth_hdr(skb);
459	struct ipvl_addr *addr;
460	void *lyr3h;
461	int addr_type;
462
463	if (ether_addr_equal(eth->h_dest, eth->h_source)) {
464	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
465	if (lyr3h) {
466	addr = ipvlan_addr_lookup(ipvlan->port, lyr3h, addr_type, true);
467	if (addr)
468	return ipvlan_rcv_frame(addr, skb, true);
469	}
470	skb = skb_share_check(skb, GFP_ATOMIC);
471	if (!skb)
472	return NET_XMIT_DROP;
473
474	/* Packet definitely does not belong to any of the
475	* virtual devices, but the dest is local. So forward
476	* the skb for the main-dev. At the RX side we just return
477	* RX_PASS for it to be processed further on the stack.
478	*/
479	return dev_forward_skb(ipvlan->phy_dev, skb);
480
481	} else if (is_multicast_ether_addr(eth->h_dest)) {
482	u8 ip_summed = skb->ip_summed;
483
484	skb->ip_summed = CHECKSUM_UNNECESSARY;
485	ipvlan_multicast_frame(ipvlan->port, skb, ipvlan, true);
486	skb->ip_summed = ip_summed;
487	}
488
489	skb->dev = ipvlan->phy_dev;
490	return dev_queue_xmit(skb);
491	}
492
493	int ipvlan_queue_xmit(struct sk_buff skb, struct net_device dev)
494	{
495	struct ipvl_dev *ipvlan = netdev_priv(dev);
496	struct ipvl_port *port = ipvlan_port_get_rcu(ipvlan->phy_dev);
497
498	if (!port)
499	goto out;
500
501	if (unlikely(!pskb_may_pull(skb, sizeof(struct ethhdr))))
502	goto out;
503
504	switch(port->mode) {
505	case IPVLAN_MODE_L2:
506	return ipvlan_xmit_mode_l2(skb, dev);
507	case IPVLAN_MODE_L3:
508	return ipvlan_xmit_mode_l3(skb, dev);
509	}
510
511	/* Should not reach here */
512	WARN_ONCE(true, "ipvlan_queue_xmit() called for mode = [%hx]\n",
513	port->mode);
514	out:
515	kfree_skb(skb);
516	return NET_XMIT_DROP;
517	}
518
519	static bool ipvlan_external_frame(struct sk_buff skb, struct ipvl_port port)
520	{
521	struct ethhdr *eth = eth_hdr(skb);
522	struct ipvl_addr *addr;
523	void *lyr3h;
524	int addr_type;
525
526	if (ether_addr_equal(eth->h_source, skb->dev->dev_addr)) {
527	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
528	if (!lyr3h)
529	return true;
530
531	addr = ipvlan_addr_lookup(port, lyr3h, addr_type, false);
532	if (addr)
533	return false;
534	}
535
536	return true;
537	}
538
539	static rx_handler_result_t ipvlan_handle_mode_l3(struct sk_buff **pskb,
540	struct ipvl_port *port)
541	{
542	void *lyr3h;
543	int addr_type;
544	struct ipvl_addr *addr;
545	struct sk_buff skb = pskb;
546	rx_handler_result_t ret = RX_HANDLER_PASS;
547
548	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
549	if (!lyr3h)
550	goto out;
551
552	addr = ipvlan_addr_lookup(port, lyr3h, addr_type, true);
553	if (addr)
554	ret = ipvlan_rcv_frame(addr, skb, false);
555
556	out:
557	return ret;
558	}
559
560	static rx_handler_result_t ipvlan_handle_mode_l2(struct sk_buff **pskb,
561	struct ipvl_port *port)
562	{
563	struct sk_buff skb = pskb;
564	struct ethhdr *eth = eth_hdr(skb);
565	rx_handler_result_t ret = RX_HANDLER_PASS;
566	void *lyr3h;
567	int addr_type;
568
569	if (is_multicast_ether_addr(eth->h_dest)) {
570	if (ipvlan_external_frame(skb, port))
571	ipvlan_multicast_frame(port, skb, NULL, false);
572	} else {
573	struct ipvl_addr *addr;
574
575	lyr3h = ipvlan_get_L3_hdr(skb, &addr_type);
576	if (!lyr3h)
577	return ret;
578
579	addr = ipvlan_addr_lookup(port, lyr3h, addr_type, true);
580	if (addr)
581	ret = ipvlan_rcv_frame(addr, skb, false);
582	}
583
584	return ret;
585	}
586
587	rx_handler_result_t ipvlan_handle_frame(struct sk_buff **pskb)
588	{
589	struct sk_buff skb = pskb;
590	struct ipvl_port *port = ipvlan_port_get_rcu(skb->dev);
591
592	if (!port)
593	return RX_HANDLER_PASS;
594
595	switch (port->mode) {
596	case IPVLAN_MODE_L2:
597	return ipvlan_handle_mode_l2(pskb, port);
598	case IPVLAN_MODE_L3:
599	return ipvlan_handle_mode_l3(pskb, port);
600	}
601
602	/* Should not reach here */
603	WARN_ONCE(true, "ipvlan_handle_frame() called for mode = [%hx]\n",
604	port->mode);
605	kfree_skb(skb);
606	return NET_RX_DROP;
607	}