Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 9ace4223 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'geneve-next' 



Jesse Gross says:

====================
Geneve Cleanups

Much of the basis for the Geneve code comes from VXLAN. However,
Geneve is quite a bit simpler than VXLAN and so this cleans up a
lot of the infrastruction - particularly around locking - where the
extra complexity is not necessary.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 7beceebf 46b1e4f9

include/net/geneve.h

+2 −3
Original line number Diff line number Diff line
@@ -68,13 +68,12 @@ struct geneve_sock; 
typedef void (geneve_rcv_t)(struct geneve_sock *gs, struct sk_buff *skb);



struct geneve_sock {

	struct hlist_node	hlist;

	struct list_head	list;

	geneve_rcv_t		*rcv;

	void			*rcv_data;

	struct work_struct	del_work;

	struct socket		*sock;

	struct rcu_head		rcu;

	atomic_t		refcnt;

	int			refcnt;

	struct udp_offload	udp_offloads;

};

net/ipv4/geneve.c

+33 −68
Original line number Diff line number Diff line
@@ -17,7 +17,7 @@ 
#include <linux/errno.h>

#include <linux/slab.h>

#include <linux/skbuff.h>

#include <linux/rculist.h>

#include <linux/list.h>

#include <linux/netdevice.h>

#include <linux/in.h>

#include <linux/ip.h>
@@ -26,8 +26,8 @@ 
#include <linux/etherdevice.h>

#include <linux/if_ether.h>

#include <linux/if_vlan.h>

#include <linux/hash.h>

#include <linux/ethtool.h>

#include <linux/mutex.h>

#include <net/arp.h>

#include <net/ndisc.h>

#include <net/ip.h>
@@ -50,38 +50,30 @@ 
#include <net/ip6_checksum.h>

#endif



#define PORT_HASH_BITS 8

#define PORT_HASH_SIZE (1<<PORT_HASH_BITS)

/* Protects sock_list and refcounts. */

static DEFINE_MUTEX(geneve_mutex);



/* per-network namespace private data for this module */

struct geneve_net {

	struct hlist_head	sock_list[PORT_HASH_SIZE];

	spinlock_t		sock_lock;   /* Protects sock_list */

	struct list_head	sock_list;

};



static int geneve_net_id;



static struct workqueue_struct *geneve_wq;



static inline struct genevehdr *geneve_hdr(const struct sk_buff *skb)

{

	return (struct genevehdr *)(udp_hdr(skb) + 1);

}



static struct hlist_head *gs_head(struct net *net, __be16 port)

static struct geneve_sock *geneve_find_sock(struct net *net,

					    sa_family_t family, __be16 port)

{

	struct geneve_net *gn = net_generic(net, geneve_net_id);



	return &gn->sock_list[hash_32(ntohs(port), PORT_HASH_BITS)];

}



/* Find geneve socket based on network namespace and UDP port */

static struct geneve_sock *geneve_find_sock(struct net *net, __be16 port)

{

	struct geneve_sock *gs;



	hlist_for_each_entry_rcu(gs, gs_head(net, port), hlist) {

		if (inet_sk(gs->sock->sk)->inet_sport == port)

	list_for_each_entry(gs, &gn->sock_list, list) {

		if (inet_sk(gs->sock->sk)->inet_sport == port &&

		    inet_sk(gs->sock->sk)->sk.sk_family == family)

			return gs;

	}
@@ -307,15 +299,6 @@ static int geneve_udp_encap_recv(struct sock *sk, struct sk_buff *skb) 
	return 1;

}



static void geneve_del_work(struct work_struct *work)

{

	struct geneve_sock *gs = container_of(work, struct geneve_sock,

					      del_work);



	udp_tunnel_sock_release(gs->sock);

	kfree_rcu(gs, rcu);

}



static struct socket *geneve_create_sock(struct net *net, bool ipv6,

					 __be16 port)

{
@@ -356,8 +339,6 @@ static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port, 
	if (!gs)

		return ERR_PTR(-ENOMEM);



	INIT_WORK(&gs->del_work, geneve_del_work);



	sock = geneve_create_sock(net, ipv6, port);

	if (IS_ERR(sock)) {

		kfree(gs);
@@ -365,7 +346,7 @@ static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port, 
	}



	gs->sock = sock;

	atomic_set(&gs->refcnt, 1);

	gs->refcnt = 1;

	gs->rcv = rcv;

	gs->rcv_data = data;
@@ -373,11 +354,7 @@ static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port, 
	gs->udp_offloads.port = port;

	gs->udp_offloads.callbacks.gro_receive  = geneve_gro_receive;

	gs->udp_offloads.callbacks.gro_complete = geneve_gro_complete;



	spin_lock(&gn->sock_lock);

	hlist_add_head_rcu(&gs->hlist, gs_head(net, port));

	geneve_notify_add_rx_port(gs);

	spin_unlock(&gn->sock_lock);



	/* Mark socket as an encapsulation socket */

	tunnel_cfg.sk_user_data = gs;
@@ -386,6 +363,8 @@ static struct geneve_sock *geneve_socket_create(struct net *net, __be16 port, 
	tunnel_cfg.encap_destroy = NULL;

	setup_udp_tunnel_sock(net, sock, &tunnel_cfg);



	list_add(&gs->list, &gn->sock_list);



	return gs;

}
@@ -393,25 +372,21 @@ struct geneve_sock *geneve_sock_add(struct net *net, __be16 port, 
				    geneve_rcv_t *rcv, void *data,

				    bool no_share, bool ipv6)

{

	struct geneve_net *gn = net_generic(net, geneve_net_id);

	struct geneve_sock *gs;



	gs = geneve_socket_create(net, port, rcv, data, ipv6);

	if (!IS_ERR(gs))

		return gs;



	if (no_share)	/* Return error if sharing is not allowed. */

		return ERR_PTR(-EINVAL);

	mutex_lock(&geneve_mutex);



	spin_lock(&gn->sock_lock);

	gs = geneve_find_sock(net, port);

	if (gs && ((gs->rcv != rcv) ||

		   !atomic_add_unless(&gs->refcnt, 1, 0)))

	gs = geneve_find_sock(net, ipv6 ? AF_INET6 : AF_INET, port);

	if (gs) {

		if (!no_share && gs->rcv == rcv)

			gs->refcnt++;

		else

			gs = ERR_PTR(-EBUSY);

	spin_unlock(&gn->sock_lock);

	} else {

		gs = geneve_socket_create(net, port, rcv, data, ipv6);

	}



	if (!gs)

		gs = ERR_PTR(-EINVAL);

	mutex_unlock(&geneve_mutex);



	return gs;

}
@@ -419,37 +394,32 @@ EXPORT_SYMBOL_GPL(geneve_sock_add); 


void geneve_sock_release(struct geneve_sock *gs)

{

	struct net *net = sock_net(gs->sock->sk);

	struct geneve_net *gn = net_generic(net, geneve_net_id);

	mutex_lock(&geneve_mutex);



	if (!atomic_dec_and_test(&gs->refcnt))

		return;

	if (--gs->refcnt)

		goto unlock;



	spin_lock(&gn->sock_lock);

	hlist_del_rcu(&gs->hlist);

	list_del(&gs->list);

	geneve_notify_del_rx_port(gs);

	spin_unlock(&gn->sock_lock);

	udp_tunnel_sock_release(gs->sock);

	kfree_rcu(gs, rcu);



	queue_work(geneve_wq, &gs->del_work);

unlock:

	mutex_unlock(&geneve_mutex);

}

EXPORT_SYMBOL_GPL(geneve_sock_release);



static __net_init int geneve_init_net(struct net *net)

{

	struct geneve_net *gn = net_generic(net, geneve_net_id);

	unsigned int h;



	spin_lock_init(&gn->sock_lock);



	for (h = 0; h < PORT_HASH_SIZE; ++h)

		INIT_HLIST_HEAD(&gn->sock_list[h]);

	INIT_LIST_HEAD(&gn->sock_list);



	return 0;

}



static struct pernet_operations geneve_net_ops = {

	.init = geneve_init_net,

	.exit = NULL,

	.id   = &geneve_net_id,

	.size = sizeof(struct geneve_net),

};
@@ -458,10 +428,6 @@ static int __init geneve_init_module(void) 
{

	int rc;



	geneve_wq = alloc_workqueue("geneve", 0, 0);

	if (!geneve_wq)

		return -ENOMEM;



	rc = register_pernet_subsys(&geneve_net_ops);

	if (rc)

		return rc;
@@ -470,11 +436,10 @@ static int __init geneve_init_module(void) 


	return 0;

}

late_initcall(geneve_init_module);

module_init(geneve_init_module);



static void __exit geneve_cleanup_module(void)

{

	destroy_workqueue(geneve_wq);

	unregister_pernet_subsys(&geneve_net_ops);

}

module_exit(geneve_cleanup_module);