Commit b6b61455 authored by Jakub Kicinski's avatar Jakub Kicinski
Browse files

Merge branch 'net-more-factorization-in-cleanup_net-paths' 

Eric Dumazet says:

====================
net: more factorization in cleanup_net() paths

This series is inspired by recent syzbot reports hinting to RTNL and
workqueue abuses.

rtnl_lock() is unfair to (single threaded) cleanup_net(), because
many threads can cause contention on it.

This series adds a new (struct pernet_operations) method,
so that cleanup_net() can hold RTNL longer once it finally
acquires it.

It also factorizes unregister_netdevice_many(), to further
reduce stalls in cleanup_net().

Link: https://lore.kernel.org/netdev/CANn89iLJrrJs+6Vc==Un4rVKcpV0Eof4F_4w1_wQGxUCE2FWAg@mail.gmail.com/T/#u
https://lore.kernel.org/netdev/170688415193.5216.10499830272732622816@kwain/
====================

Link: https://lore.kernel.org/r/20240206144313.2050392-1-edumazet@google.com


Signed-off-by: default avatarJakub Kicinski <kuba@kernel.org>
parents a1e55f51 8962dacc

drivers/net/bareudp.c

+4 −9
Original line number Diff line number Diff line
@@ -760,23 +760,18 @@ static void bareudp_destroy_tunnels(struct net *net, struct list_head *head) 
		unregister_netdevice_queue(bareudp->dev, head);

}



static void __net_exit bareudp_exit_batch_net(struct list_head *net_list)

static void __net_exit bareudp_exit_batch_rtnl(struct list_head *net_list,

					       struct list_head *dev_kill_list)

{

	struct net *net;

	LIST_HEAD(list);



	rtnl_lock();

	list_for_each_entry(net, net_list, exit_list)

		bareudp_destroy_tunnels(net, &list);



	/* unregister the devices gathered above */

	unregister_netdevice_many(&list);

	rtnl_unlock();

		bareudp_destroy_tunnels(net, dev_kill_list);

}



static struct pernet_operations bareudp_net_ops = {

	.init = bareudp_init_net,

	.exit_batch = bareudp_exit_batch_net,

	.exit_batch_rtnl = bareudp_exit_batch_rtnl,

	.id   = &bareudp_net_id,

	.size = sizeof(struct bareudp_net),

};

drivers/net/bonding/bond_main.c

+26 −11
Original line number Diff line number Diff line
@@ -6416,28 +6416,41 @@ static int __net_init bond_net_init(struct net *net) 
	return 0;

}



static void __net_exit bond_net_exit_batch(struct list_head *net_list)

/* According to commit 69b0216ac255 ("bonding: fix bonding_masters

 * race condition in bond unloading") we need to remove sysfs files

 * before we remove our devices (done later in bond_net_exit_batch_rtnl())

 */

static void __net_exit bond_net_pre_exit(struct net *net)

{

	struct bond_net *bn;

	struct net *net;

	LIST_HEAD(list);

	struct bond_net *bn = net_generic(net, bond_net_id);



	list_for_each_entry(net, net_list, exit_list) {

		bn = net_generic(net, bond_net_id);

	bond_destroy_sysfs(bn);

}



static void __net_exit bond_net_exit_batch_rtnl(struct list_head *net_list,

						struct list_head *dev_kill_list)

{

	struct bond_net *bn;

	struct net *net;



	/* Kill off any bonds created after unregistering bond rtnl ops */

	rtnl_lock();

	list_for_each_entry(net, net_list, exit_list) {

		struct bonding *bond, *tmp_bond;



		bn = net_generic(net, bond_net_id);

		list_for_each_entry_safe(bond, tmp_bond, &bn->dev_list, bond_list)

			unregister_netdevice_queue(bond->dev, &list);

			unregister_netdevice_queue(bond->dev, dev_kill_list);

	}

	unregister_netdevice_many(&list);

	rtnl_unlock();

}



/* According to commit 23fa5c2caae0 ("bonding: destroy proc directory

 * only after all bonds are gone") bond_destroy_proc_dir() is called

 * after bond_net_exit_batch_rtnl() has completed.

 */

static void __net_exit bond_net_exit_batch(struct list_head *net_list)

{

	struct bond_net *bn;

	struct net *net;



	list_for_each_entry(net, net_list, exit_list) {

		bn = net_generic(net, bond_net_id);
@@ -6447,6 +6460,8 @@ static void __net_exit bond_net_exit_batch(struct list_head *net_list) 


static struct pernet_operations bond_net_ops = {

	.init = bond_net_init,

	.pre_exit = bond_net_pre_exit,

	.exit_batch_rtnl = bond_net_exit_batch_rtnl,

	.exit_batch = bond_net_exit_batch,

	.id   = &bond_net_id,

	.size = sizeof(struct bond_net),

drivers/net/geneve.c

+10 −13
Original line number Diff line number Diff line
@@ -1900,29 +1900,26 @@ static void geneve_destroy_tunnels(struct net *net, struct list_head *head) 
	}

}



static void __net_exit geneve_exit_batch_net(struct list_head *net_list)

static void __net_exit geneve_exit_batch_rtnl(struct list_head *net_list,

					      struct list_head *dev_to_kill)

{

	struct net *net;

	LIST_HEAD(list);



	rtnl_lock();

	list_for_each_entry(net, net_list, exit_list)

		geneve_destroy_tunnels(net, &list);



	/* unregister the devices gathered above */

	unregister_netdevice_many(&list);

	rtnl_unlock();

		geneve_destroy_tunnels(net, dev_to_kill);

}



	list_for_each_entry(net, net_list, exit_list) {

static void __net_exit geneve_exit_net(struct net *net)

{

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



	WARN_ON_ONCE(!list_empty(&gn->sock_list));

}

}



static struct pernet_operations geneve_net_ops = {

	.init = geneve_init_net,

	.exit_batch = geneve_exit_batch_net,

	.exit_batch_rtnl = geneve_exit_batch_rtnl,

	.exit = geneve_exit_net,

	.id   = &geneve_net_id,

	.size = sizeof(struct geneve_net),

};

drivers/net/gtp.c

+10 −10
Original line number Diff line number Diff line
@@ -1876,23 +1876,23 @@ static int __net_init gtp_net_init(struct net *net) 
	return 0;

}



static void __net_exit gtp_net_exit(struct net *net)

static void __net_exit gtp_net_exit_batch_rtnl(struct list_head *net_list,

					       struct list_head *dev_to_kill)

{

	struct net *net;



	list_for_each_entry(net, net_list, exit_list) {

		struct gtp_net *gn = net_generic(net, gtp_net_id);

		struct gtp_dev *gtp;

	LIST_HEAD(list);



	rtnl_lock();

		list_for_each_entry(gtp, &gn->gtp_dev_list, list)

		gtp_dellink(gtp->dev, &list);



	unregister_netdevice_many(&list);

	rtnl_unlock();

			gtp_dellink(gtp->dev, dev_to_kill);

	}

}



static struct pernet_operations gtp_net_ops = {

	.init	= gtp_net_init,

	.exit	= gtp_net_exit,

	.exit_batch_rtnl = gtp_net_exit_batch_rtnl,

	.id	= &gtp_net_id,

	.size	= sizeof(struct gtp_net),

};

drivers/net/vxlan/vxlan_core.c

+19 −31
Original line number Diff line number Diff line
@@ -4826,55 +4826,43 @@ static __net_init int vxlan_init_net(struct net *net) 
					 NULL);

}



static void vxlan_destroy_tunnels(struct net *net, struct list_head *head)

static void __net_exit vxlan_destroy_tunnels(struct vxlan_net *vn,

					     struct list_head *dev_to_kill)

{

	struct vxlan_net *vn = net_generic(net, vxlan_net_id);

	struct vxlan_dev *vxlan, *next;

	struct net_device *dev, *aux;



	for_each_netdev_safe(net, dev, aux)

		if (dev->rtnl_link_ops == &vxlan_link_ops)

			unregister_netdevice_queue(dev, head);



	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next) {

		/* If vxlan->dev is in the same netns, it has already been added

		 * to the list by the previous loop.

		 */

		if (!net_eq(dev_net(vxlan->dev), net))

			unregister_netdevice_queue(vxlan->dev, head);

	}



	list_for_each_entry_safe(vxlan, next, &vn->vxlan_list, next)

		vxlan_dellink(vxlan->dev, dev_to_kill);

}



static void __net_exit vxlan_exit_batch_net(struct list_head *net_list)

static void __net_exit vxlan_exit_batch_rtnl(struct list_head *net_list,

					     struct list_head *dev_to_kill)

{

	struct net *net;

	LIST_HEAD(list);

	unsigned int h;



	ASSERT_RTNL();

	list_for_each_entry(net, net_list, exit_list) {

		struct vxlan_net *vn = net_generic(net, vxlan_net_id);



		unregister_nexthop_notifier(net, &vn->nexthop_notifier_block);

	}

	rtnl_lock();

	list_for_each_entry(net, net_list, exit_list)

		vxlan_destroy_tunnels(net, &list);

		__unregister_nexthop_notifier(net, &vn->nexthop_notifier_block);



	unregister_netdevice_many(&list);

	rtnl_unlock();

		vxlan_destroy_tunnels(vn, dev_to_kill);

	}

}



	list_for_each_entry(net, net_list, exit_list) {

static void __net_exit vxlan_exit_net(struct net *net)

{

	struct vxlan_net *vn = net_generic(net, vxlan_net_id);

	unsigned int h;



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

		WARN_ON_ONCE(!hlist_empty(&vn->sock_list[h]));

}

}



static struct pernet_operations vxlan_net_ops = {

	.init = vxlan_init_net,

	.exit_batch = vxlan_exit_batch_net,

	.exit_batch_rtnl = vxlan_exit_batch_rtnl,

	.exit = vxlan_exit_net,

	.id   = &vxlan_net_id,

	.size = sizeof(struct vxlan_net),

};