vxlan: generalize forwarding tables (6681712d) · Commits · 戴 / test

drivers/net/vxlan.c

+206 −57

Original line number	Diff line number	Diff line
		@@ -81,13 +81,22 @@ struct vxlan_net {
		struct hlist_head vni_list[VNI_HASH_SIZE];
		};

		struct vxlan_rdst {
		struct rcu_head rcu;
		__be32 remote_ip;
		__be16 remote_port;
		u32 remote_vni;
		u32 remote_ifindex;
		struct vxlan_rdst *remote_next;
		};

		/* Forwarding table entry */
		struct vxlan_fdb {
		struct hlist_node hlist; /* linked list of entries */
		struct rcu_head rcu;
		unsigned long updated; /* jiffies */
		unsigned long used;
		__be32 remote_ip;
		struct vxlan_rdst remote;
		u16 state; /* see ndm_state */
		u8 eth_addr[ETH_ALEN];
		};
		@@ -157,7 +166,8 @@ static struct vxlan_dev vxlan_find_vni(struct net net, u32 id)
		/* Fill in neighbour message in skbuff. */
		static int vxlan_fdb_info(struct sk_buff skb, struct vxlan_dev vxlan,
		const struct vxlan_fdb *fdb,
		u32 portid, u32 seq, int type, unsigned int flags)
		u32 portid, u32 seq, int type, unsigned int flags,
		const struct vxlan_rdst *rdst)
		{
		unsigned long now = jiffies;
		struct nda_cacheinfo ci;
		@@ -176,7 +186,7 @@ static int vxlan_fdb_info(struct sk_buff skb, struct vxlan_dev vxlan,

		if (type == RTM_GETNEIGH) {
		ndm->ndm_family = AF_INET;
		send_ip = fdb->remote_ip != 0;
		send_ip = rdst->remote_ip != htonl(INADDR_ANY);
		send_eth = !is_zero_ether_addr(fdb->eth_addr);
		} else
		ndm->ndm_family = AF_BRIDGE;
		@@ -188,7 +198,17 @@ static int vxlan_fdb_info(struct sk_buff skb, struct vxlan_dev vxlan,
		if (send_eth && nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->eth_addr))
		goto nla_put_failure;

		if (send_ip && nla_put_be32(skb, NDA_DST, fdb->remote_ip))
		if (send_ip && nla_put_be32(skb, NDA_DST, rdst->remote_ip))
		goto nla_put_failure;

		if (rdst->remote_port && rdst->remote_port != vxlan_port &&
		nla_put_be16(skb, NDA_PORT, rdst->remote_port))
		goto nla_put_failure;
		if (rdst->remote_vni != vxlan->vni &&
		nla_put_be32(skb, NDA_VNI, rdst->remote_vni))
		goto nla_put_failure;
		if (rdst->remote_ifindex &&
		nla_put_u32(skb, NDA_IFINDEX, rdst->remote_ifindex))
		goto nla_put_failure;

		ci.ndm_used = jiffies_to_clock_t(now - fdb->used);
		@@ -211,6 +231,9 @@ static inline size_t vxlan_nlmsg_size(void)
		return NLMSG_ALIGN(sizeof(struct ndmsg))
		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */
		+ nla_total_size(sizeof(__be32)) /* NDA_DST */
		+ nla_total_size(sizeof(__be32)) /* NDA_PORT */
		+ nla_total_size(sizeof(__be32)) /* NDA_VNI */
		+ nla_total_size(sizeof(__u32)) /* NDA_IFINDEX */
		+ nla_total_size(sizeof(struct nda_cacheinfo));
		}

		@@ -225,7 +248,7 @@ static void vxlan_fdb_notify(struct vxlan_dev *vxlan,
		if (skb == NULL)
		goto errout;

		err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0);
		err = vxlan_fdb_info(skb, vxlan, fdb, 0, 0, type, 0, &fdb->remote);
		if (err < 0) {
		/* -EMSGSIZE implies BUG in vxlan_nlmsg_size() */
		WARN_ON(err == -EMSGSIZE);
		@@ -247,7 +270,8 @@ static void vxlan_ip_miss(struct net_device *dev, __be32 ipa)

		memset(&f, 0, sizeof f);
		f.state = NUD_STALE;
		f.remote_ip = ipa; /* goes to NDA_DST */
		f.remote.remote_ip = ipa; /* goes to NDA_DST */
		f.remote.remote_vni = VXLAN_N_VID;

		vxlan_fdb_notify(vxlan, &f, RTM_GETNEIGH);
		}
		@@ -300,10 +324,38 @@ static struct vxlan_fdb vxlan_find_mac(struct vxlan_dev vxlan,
		return NULL;
		}

		/* Add/update destinations for multicast */
		static int vxlan_fdb_append(struct vxlan_fdb *f,
		__be32 ip, __u32 port, __u32 vni, __u32 ifindex)
		{
		struct vxlan_rdst rd_prev, rd;

		rd_prev = NULL;
		for (rd = &f->remote; rd; rd = rd->remote_next) {
		if (rd->remote_ip == ip &&
		rd->remote_port == port &&
		rd->remote_vni == vni &&
		rd->remote_ifindex == ifindex)
		return 0;
		rd_prev = rd;
		}
		rd = kmalloc(sizeof(*rd), GFP_ATOMIC);
		if (rd == NULL)
		return -ENOBUFS;
		rd->remote_ip = ip;
		rd->remote_port = port;
		rd->remote_vni = vni;
		rd->remote_ifindex = ifindex;
		rd->remote_next = NULL;
		rd_prev->remote_next = rd;
		return 1;
		}

		/* Add new entry to forwarding table -- assumes lock held */
		static int vxlan_fdb_create(struct vxlan_dev *vxlan,
		const u8 *mac, __be32 ip,
		__u16 state, __u16 flags)
		__u16 state, __u16 flags,
		__u32 port, __u32 vni, __u32 ifindex)
		{
		struct vxlan_fdb *f;
		int notify = 0;
		@@ -320,6 +372,14 @@ static int vxlan_fdb_create(struct vxlan_dev *vxlan,
		f->updated = jiffies;
		notify = 1;
		}
		if ((flags & NLM_F_APPEND) &&
		is_multicast_ether_addr(f->eth_addr)) {
		int rc = vxlan_fdb_append(f, ip, port, vni, ifindex);

		if (rc < 0)
		return rc;
		notify \|= rc;
		}
		} else {
		if (!(flags & NLM_F_CREATE))
		return -ENOENT;
		@@ -333,7 +393,11 @@ static int vxlan_fdb_create(struct vxlan_dev *vxlan,
		return -ENOMEM;

		notify = 1;
		f->remote_ip = ip;
		f->remote.remote_ip = ip;
		f->remote.remote_port = port;
		f->remote.remote_vni = vni;
		f->remote.remote_ifindex = ifindex;
		f->remote.remote_next = NULL;
		f->state = state;
		f->updated = f->used = jiffies;
		memcpy(f->eth_addr, mac, ETH_ALEN);
		@@ -349,6 +413,19 @@ static int vxlan_fdb_create(struct vxlan_dev *vxlan,
		return 0;
		}

		void vxlan_fdb_free(struct rcu_head *head)
		{
		struct vxlan_fdb *f = container_of(head, struct vxlan_fdb, rcu);

		while (f->remote.remote_next) {
		struct vxlan_rdst *rd = f->remote.remote_next;

		f->remote.remote_next = rd->remote_next;
		kfree(rd);
		}
		kfree(f);
		}

		static void vxlan_fdb_destroy(struct vxlan_dev vxlan, struct vxlan_fdb f)
		{
		netdev_dbg(vxlan->dev,
		@@ -358,7 +435,7 @@ static void vxlan_fdb_destroy(struct vxlan_dev vxlan, struct vxlan_fdb f)
		vxlan_fdb_notify(vxlan, f, RTM_DELNEIGH);

		hlist_del_rcu(&f->hlist);
		kfree_rcu(f, rcu);
		call_rcu(&f->rcu, vxlan_fdb_free);
		}

		/* Add static entry (via netlink) */
		@@ -367,7 +444,9 @@ static int vxlan_fdb_add(struct ndmsg ndm, struct nlattr tb[],
		const unsigned char *addr, u16 flags)
		{
		struct vxlan_dev *vxlan = netdev_priv(dev);
		struct net *net = dev_net(vxlan->dev);
		__be32 ip;
		u32 port, vni, ifindex;
		int err;

		if (!(ndm->ndm_state & (NUD_PERMANENT\|NUD_REACHABLE))) {
		@@ -384,8 +463,36 @@ static int vxlan_fdb_add(struct ndmsg ndm, struct nlattr tb[],

		ip = nla_get_be32(tb[NDA_DST]);

		if (tb[NDA_PORT]) {
		if (nla_len(tb[NDA_PORT]) != sizeof(u32))
		return -EINVAL;
		port = nla_get_u32(tb[NDA_PORT]);
		} else
		port = vxlan_port;

		if (tb[NDA_VNI]) {
		if (nla_len(tb[NDA_VNI]) != sizeof(u32))
		return -EINVAL;
		vni = nla_get_u32(tb[NDA_VNI]);
		} else
		vni = vxlan->vni;

		if (tb[NDA_IFINDEX]) {
		struct net_device *dev;

		if (nla_len(tb[NDA_IFINDEX]) != sizeof(u32))
		return -EINVAL;
		ifindex = nla_get_u32(tb[NDA_IFINDEX]);
		dev = dev_get_by_index(net, ifindex);
		if (!dev)
		return -EADDRNOTAVAIL;
		dev_put(dev);
		} else
		ifindex = 0;

		spin_lock_bh(&vxlan->hash_lock);
		err = vxlan_fdb_create(vxlan, addr, ip, ndm->ndm_state, flags);
		err = vxlan_fdb_create(vxlan, addr, ip, ndm->ndm_state, flags, port,
		vni, ifindex);
		spin_unlock_bh(&vxlan->hash_lock);

		return err;
		@@ -423,6 +530,8 @@ static int vxlan_fdb_dump(struct sk_buff skb, struct netlink_callback cb,
		int err;

		hlist_for_each_entry_rcu(f, &vxlan->fdb_head[h], hlist) {
		struct vxlan_rdst *rd;
		for (rd = &f->remote; rd; rd = rd->remote_next) {
		if (idx < cb->args[0])
		goto skip;

		@@ -430,13 +539,14 @@ static int vxlan_fdb_dump(struct sk_buff skb, struct netlink_callback cb,
		NETLINK_CB(cb->skb).portid,
		cb->nlh->nlmsg_seq,
		RTM_NEWNEIGH,
		NLM_F_MULTI);
		NLM_F_MULTI, rd);
		if (err < 0)
		break;
		skip:
		++idx;
		}
		}
		}

		return idx;
		}
		@@ -454,22 +564,23 @@ static void vxlan_snoop(struct net_device *dev,
		f = vxlan_find_mac(vxlan, src_mac);
		if (likely(f)) {
		f->used = jiffies;
		if (likely(f->remote_ip == src_ip))
		if (likely(f->remote.remote_ip == src_ip))
		return;

		if (net_ratelimit())
		netdev_info(dev,
		"%pM migrated from %pI4 to %pI4\n",
		src_mac, &f->remote_ip, &src_ip);
		src_mac, &f->remote.remote_ip, &src_ip);

		f->remote_ip = src_ip;
		f->remote.remote_ip = src_ip;
		f->updated = jiffies;
		} else {
		/* learned new entry */
		spin_lock(&vxlan->hash_lock);
		err = vxlan_fdb_create(vxlan, src_mac, src_ip,
		NUD_REACHABLE,
		NLM_F_EXCL\|NLM_F_CREATE);
		NLM_F_EXCL\|NLM_F_CREATE,
		vxlan_port, vxlan->vni, 0);
		spin_unlock(&vxlan->hash_lock);
		}
		}
		@@ -701,7 +812,7 @@ static int arp_reduce(struct net_device dev, struct sk_buff skb)
		}

		f = vxlan_find_mac(vxlan, n->ha);
		if (f && f->remote_ip == 0) {
		if (f && f->remote.remote_ip == htonl(INADDR_ANY)) {
		/* bridge-local neighbor */
		neigh_release(n);
		goto out;
		@@ -834,47 +945,26 @@ static int handle_offloads(struct sk_buff *skb)
		return 0;
		}

		/* Transmit local packets over Vxlan
		*
		* Outer IP header inherits ECN and DF from inner header.
		* Outer UDP destination is the VXLAN assigned port.
		* source port is based on hash of flow
		*/
		static netdev_tx_t vxlan_xmit(struct sk_buff skb, struct net_device dev)
		static netdev_tx_t vxlan_xmit_one(struct sk_buff skb, struct net_device dev,
		struct vxlan_rdst *rdst, bool did_rsc)
		{
		struct vxlan_dev *vxlan = netdev_priv(dev);
		struct rtable *rt;
		const struct iphdr *old_iph;
		struct ethhdr *eth;
		struct iphdr *iph;
		struct vxlanhdr *vxh;
		struct udphdr *uh;
		struct flowi4 fl4;
		unsigned int pkt_len = skb->len;
		__be32 dst;
		__u16 src_port;
		__u16 src_port, dst_port;
		u32 vni;
		__be16 df = 0;
		__u8 tos, ttl;
		bool did_rsc = false;
		const struct vxlan_fdb *f;

		skb_reset_mac_header(skb);
		eth = eth_hdr(skb);

		if ((vxlan->flags & VXLAN_F_PROXY) && ntohs(eth->h_proto) == ETH_P_ARP)
		return arp_reduce(dev, skb);
		else if ((vxlan->flags&VXLAN_F_RSC) && ntohs(eth->h_proto) == ETH_P_IP)
		did_rsc = route_shortcircuit(dev, skb);

		f = vxlan_find_mac(vxlan, eth->h_dest);
		if (f == NULL) {
		did_rsc = false;
		dst = vxlan->gaddr;
		if (!dst && (vxlan->flags & VXLAN_F_L2MISS) &&
		!is_multicast_ether_addr(eth->h_dest))
		vxlan_fdb_miss(vxlan, eth->h_dest);
		} else
		dst = f->remote_ip;
		dst_port = rdst->remote_port ? rdst->remote_port : vxlan_port;
		vni = rdst->remote_vni;
		dst = rdst->remote_ip;

		if (!dst) {
		if (did_rsc) {
		@@ -922,7 +1012,7 @@ static netdev_tx_t vxlan_xmit(struct sk_buff skb, struct net_device dev)
		src_port = vxlan_src_port(vxlan, skb);

		memset(&fl4, 0, sizeof(fl4));
		fl4.flowi4_oif = vxlan->link;
		fl4.flowi4_oif = rdst->remote_ifindex;
		fl4.flowi4_tos = RT_TOS(tos);
		fl4.daddr = dst;
		fl4.saddr = vxlan->saddr;
		@@ -949,13 +1039,13 @@ static netdev_tx_t vxlan_xmit(struct sk_buff skb, struct net_device dev)

		vxh = (struct vxlanhdr ) __skb_push(skb, sizeof(vxh));
		vxh->vx_flags = htonl(VXLAN_FLAGS);
		vxh->vx_vni = htonl(vxlan->vni << 8);
		vxh->vx_vni = htonl(vni << 8);

		__skb_push(skb, sizeof(*uh));
		skb_reset_transport_header(skb);
		uh = udp_hdr(skb);

		uh->dest = htons(vxlan_port);
		uh->dest = htons(dst_port);
		uh->source = htons(src_port);

		uh->len = htons(skb->len);
		@@ -995,6 +1085,64 @@ tx_free:
		return NETDEV_TX_OK;
		}

		/* Transmit local packets over Vxlan
		*
		* Outer IP header inherits ECN and DF from inner header.
		* Outer UDP destination is the VXLAN assigned port.
		* source port is based on hash of flow
		*/
		static netdev_tx_t vxlan_xmit(struct sk_buff skb, struct net_device dev)
		{
		struct vxlan_dev *vxlan = netdev_priv(dev);
		struct ethhdr *eth;
		bool did_rsc = false;
		struct vxlan_rdst group, rdst0, rdst;
		struct vxlan_fdb *f;
		int rc1, rc;

		skb_reset_mac_header(skb);
		eth = eth_hdr(skb);

		if ((vxlan->flags & VXLAN_F_PROXY) && ntohs(eth->h_proto) == ETH_P_ARP)
		return arp_reduce(dev, skb);
		else if ((vxlan->flags&VXLAN_F_RSC) && ntohs(eth->h_proto) == ETH_P_IP)
		did_rsc = route_shortcircuit(dev, skb);

		f = vxlan_find_mac(vxlan, eth->h_dest);
		if (f == NULL) {
		did_rsc = false;
		group.remote_port = vxlan_port;
		group.remote_vni = vxlan->vni;
		group.remote_ip = vxlan->gaddr;
		group.remote_ifindex = vxlan->link;
		group.remote_next = 0;
		rdst0 = &group;

		if (group.remote_ip == htonl(INADDR_ANY) &&
		(vxlan->flags & VXLAN_F_L2MISS) &&
		!is_multicast_ether_addr(eth->h_dest))
		vxlan_fdb_miss(vxlan, eth->h_dest);
		} else
		rdst0 = &f->remote;

		rc = NETDEV_TX_OK;

		/* if there are multiple destinations, send copies */
		for (rdst = rdst0->remote_next; rdst; rdst = rdst->remote_next) {
		struct sk_buff *skb1;

		skb1 = skb_clone(skb, GFP_ATOMIC);
		rc1 = vxlan_xmit_one(skb1, dev, rdst, did_rsc);
		if (rc == NETDEV_TX_OK)
		rc = rc1;
		}

		rc1 = vxlan_xmit_one(skb, dev, rdst0, did_rsc);
		if (rc == NETDEV_TX_OK)
		rc = rc1;
		return rc;
		}

		/* Walk the forwarding table and purge stale entries */
		static void vxlan_cleanup(unsigned long arg)
		{
		@@ -1558,6 +1706,7 @@ static void __exit vxlan_cleanup_module(void)
		{
		rtnl_link_unregister(&vxlan_link_ops);
		unregister_pernet_device(&vxlan_net_ops);
		rcu_barrier();
		}
		module_exit(vxlan_cleanup_module);

include/uapi/linux/neighbour.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -21,6 +21,9 @@ enum {
		NDA_CACHEINFO,
		NDA_PROBES,
		NDA_VLAN,
		NDA_PORT,
		NDA_VNI,
		NDA_IFINDEX,
		__NDA_MAX
		};

net/core/rtnetlink.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -2112,7 +2112,7 @@ static int rtnl_fdb_add(struct sk_buff skb, struct nlmsghdr nlh, void *arg)
		}

		addr = nla_data(tb[NDA_LLADDR]);
		if (!is_valid_ether_addr(addr)) {
		if (is_zero_ether_addr(addr)) {
		pr_info("PF_BRIDGE: RTM_NEWNEIGH with invalid ether address\n");
		return -EINVAL;
		}

Admin message