[linux.git] / net / core / failover.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2018, Intel Corporation. */

/* A common module to handle registrations and notifications for paravirtual
 * drivers to enable accelerated datapath and support VF live migration.
 *
 * The notifier and event handling code is based on netvsc driver.
 */

#include <linux/module.h>
#include <linux/etherdevice.h>
#include <uapi/linux/if_arp.h>
#include <linux/rtnetlink.h>
#include <linux/if_vlan.h>
#include <net/failover.h>

static LIST_HEAD(failover_list);
static DEFINE_SPINLOCK(failover_lock);

static struct net_device *failover_get_bymac(u8 *mac, struct failover_ops **ops)
{
	struct net_device *failover_dev;
	struct failover *failover;

	spin_lock(&failover_lock);
	list_for_each_entry(failover, &failover_list, list) {
		failover_dev = rtnl_dereference(failover->failover_dev);
		if (ether_addr_equal(failover_dev->perm_addr, mac)) {
			*ops = rtnl_dereference(failover->ops);
			spin_unlock(&failover_lock);
			return failover_dev;
		}
	}
	spin_unlock(&failover_lock);
	return NULL;
}

/**
 * failover_slave_register - Register a slave netdev
 *
 * @slave_dev: slave netdev that is being registered
 *
 * Registers a slave device to a failover instance. Only ethernet devices
 * are supported.
 */
static int failover_slave_register(struct net_device *slave_dev)
{
	struct netdev_lag_upper_info lag_upper_info;
	struct net_device *failover_dev;
	struct failover_ops *fops;
	int err;

	if (slave_dev->type != ARPHRD_ETHER)
		goto done;

	ASSERT_RTNL();

	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
	if (!failover_dev)
		goto done;

	if (fops && fops->slave_pre_register &&
	    fops->slave_pre_register(slave_dev, failover_dev))
		goto done;

	err = netdev_rx_handler_register(slave_dev, fops->slave_handle_frame,
					 failover_dev);
	if (err) {
		netdev_err(slave_dev, "can not register failover rx handler (err = %d)\n",
			   err);
		goto done;
	}

	lag_upper_info.tx_type = NETDEV_LAG_TX_TYPE_ACTIVEBACKUP;
	err = netdev_master_upper_dev_link(slave_dev, failover_dev, NULL,
					   &lag_upper_info, NULL);
	if (err) {
		netdev_err(slave_dev, "can not set failover device %s (err = %d)\n",
			   failover_dev->name, err);
		goto err_upper_link;
	}

	slave_dev->priv_flags |= IFF_FAILOVER_SLAVE;

	if (fops && fops->slave_register &&
	    !fops->slave_register(slave_dev, failover_dev))
		return NOTIFY_OK;

	netdev_upper_dev_unlink(slave_dev, failover_dev);
	slave_dev->priv_flags &= ~IFF_FAILOVER_SLAVE;
err_upper_link:
	netdev_rx_handler_unregister(slave_dev);
done:
	return NOTIFY_DONE;
}

/**
 * failover_slave_unregister - Unregister a slave netdev
 *
 * @slave_dev: slave netdev that is being unregistered
 *
 * Unregisters a slave device from a failover instance.
 */
int failover_slave_unregister(struct net_device *slave_dev)
{
	struct net_device *failover_dev;
	struct failover_ops *fops;

	if (!netif_is_failover_slave(slave_dev))
		goto done;

	ASSERT_RTNL();

	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
	if (!failover_dev)
		goto done;

	if (fops && fops->slave_pre_unregister &&
	    fops->slave_pre_unregister(slave_dev, failover_dev))
		goto done;

	netdev_rx_handler_unregister(slave_dev);
	netdev_upper_dev_unlink(slave_dev, failover_dev);
	slave_dev->priv_flags &= ~IFF_FAILOVER_SLAVE;

	if (fops && fops->slave_unregister &&
	    !fops->slave_unregister(slave_dev, failover_dev))
		return NOTIFY_OK;

done:
	return NOTIFY_DONE;
}
EXPORT_SYMBOL_GPL(failover_slave_unregister);

static int failover_slave_link_change(struct net_device *slave_dev)
{
	struct net_device *failover_dev;
	struct failover_ops *fops;

	if (!netif_is_failover_slave(slave_dev))
		goto done;

	ASSERT_RTNL();

	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
	if (!failover_dev)
		goto done;

	if (!netif_running(failover_dev))
		goto done;

	if (fops && fops->slave_link_change &&
	    !fops->slave_link_change(slave_dev, failover_dev))
		return NOTIFY_OK;

done:
	return NOTIFY_DONE;
}

static int failover_slave_name_change(struct net_device *slave_dev)
{
	struct net_device *failover_dev;
	struct failover_ops *fops;

	if (!netif_is_failover_slave(slave_dev))
		goto done;

	ASSERT_RTNL();

	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
	if (!failover_dev)
		goto done;

	if (!netif_running(failover_dev))
		goto done;

	if (fops && fops->slave_name_change &&
	    !fops->slave_name_change(slave_dev, failover_dev))
		return NOTIFY_OK;

done:
	return NOTIFY_DONE;
}

static int
failover_event(struct notifier_block *this, unsigned long event, void *ptr)
{
	struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);

	/* Skip parent events */
	if (netif_is_failover(event_dev))
		return NOTIFY_DONE;

	switch (event) {
	case NETDEV_REGISTER:
		return failover_slave_register(event_dev);
	case NETDEV_UNREGISTER:
		return failover_slave_unregister(event_dev);
	case NETDEV_UP:
	case NETDEV_DOWN:
	case NETDEV_CHANGE:
		return failover_slave_link_change(event_dev);
	case NETDEV_CHANGENAME:
		return failover_slave_name_change(event_dev);
	default:
		return NOTIFY_DONE;
	}
}

static struct notifier_block failover_notifier = {
	.notifier_call = failover_event,
};

static void
failover_existing_slave_register(struct net_device *failover_dev)
{
	struct net *net = dev_net(failover_dev);
	struct net_device *dev;

	rtnl_lock();
	for_each_netdev(net, dev) {
		if (netif_is_failover(dev))
			continue;
		if (ether_addr_equal(failover_dev->perm_addr, dev->perm_addr))
			failover_slave_register(dev);
	}
	rtnl_unlock();
}

/**
 * failover_register - Register a failover instance
 *
 * @dev: failover netdev
 * @ops: failover ops
 *
 * Allocate and register a failover instance for a failover netdev. ops
 * provides handlers for slave device register/unregister/link change/
 * name change events.
 *
 * Return: pointer to failover instance
 */
struct failover *failover_register(struct net_device *dev,
				   struct failover_ops *ops)
{
	struct failover *failover;

	if (dev->type != ARPHRD_ETHER)
		return ERR_PTR(-EINVAL);

	failover = kzalloc(sizeof(*failover), GFP_KERNEL);
	if (!failover)
		return ERR_PTR(-ENOMEM);

	rcu_assign_pointer(failover->ops, ops);
	dev_hold(dev);
	dev->priv_flags |= IFF_FAILOVER;
	rcu_assign_pointer(failover->failover_dev, dev);

	spin_lock(&failover_lock);
	list_add_tail(&failover->list, &failover_list);
	spin_unlock(&failover_lock);

	netdev_info(dev, "failover master:%s registered\n", dev->name);

	failover_existing_slave_register(dev);

	return failover;
}
EXPORT_SYMBOL_GPL(failover_register);

/**
 * failover_unregister - Unregister a failover instance
 *
 * @failover: pointer to failover instance
 *
 * Unregisters and frees a failover instance.
 */
void failover_unregister(struct failover *failover)
{
	struct net_device *failover_dev;

	failover_dev = rcu_dereference(failover->failover_dev);

	netdev_info(failover_dev, "failover master:%s unregistered\n",
		    failover_dev->name);

	failover_dev->priv_flags &= ~IFF_FAILOVER;
	dev_put(failover_dev);

	spin_lock(&failover_lock);
	list_del(&failover->list);
	spin_unlock(&failover_lock);

	kfree(failover);
}
EXPORT_SYMBOL_GPL(failover_unregister);

static __init int
failover_init(void)
{
	register_netdevice_notifier(&failover_notifier);

	return 0;
}
module_init(failover_init);

static __exit
void failover_exit(void)
{
	unregister_netdevice_notifier(&failover_notifier);
}
module_exit(failover_exit);

MODULE_DESCRIPTION("Generic failover infrastructure/interface");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
30c8bd5a SS	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (c) 2018, Intel Corporation. */
	3
	4	/* A common module to handle registrations and notifications for paravirtual
	5	* drivers to enable accelerated datapath and support VF live migration.
	6	*
	7	* The notifier and event handling code is based on netvsc driver.
	8	*/
	9
	10	#include <linux/module.h>
	11	#include <linux/etherdevice.h>
	12	#include <uapi/linux/if_arp.h>
	13	#include <linux/rtnetlink.h>
	14	#include <linux/if_vlan.h>
	15	#include <net/failover.h>
	16
	17	static LIST_HEAD(failover_list);
	18	static DEFINE_SPINLOCK(failover_lock);
	19
	20	static struct net_device failover_get_bymac(u8 mac, struct failover_ops **ops)
	21	{
	22	struct net_device *failover_dev;
	23	struct failover *failover;
	24
	25	spin_lock(&failover_lock);
	26	list_for_each_entry(failover, &failover_list, list) {
	27	failover_dev = rtnl_dereference(failover->failover_dev);
	28	if (ether_addr_equal(failover_dev->perm_addr, mac)) {
	29	*ops = rtnl_dereference(failover->ops);
	30	spin_unlock(&failover_lock);
	31	return failover_dev;
	32	}
	33	}
	34	spin_unlock(&failover_lock);
	35	return NULL;
	36	}
	37
	38	/**
	39	* failover_slave_register - Register a slave netdev
	40	*
	41	* @slave_dev: slave netdev that is being registered
	42	*
	43	* Registers a slave device to a failover instance. Only ethernet devices
	44	* are supported.
	45	*/
	46	static int failover_slave_register(struct net_device *slave_dev)
	47	{
	48	struct netdev_lag_upper_info lag_upper_info;
	49	struct net_device *failover_dev;
	50	struct failover_ops *fops;
	51	int err;
	52
	53	if (slave_dev->type != ARPHRD_ETHER)
	54	goto done;
	55
	56	ASSERT_RTNL();
	57
	58	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
	59	if (!failover_dev)
	60	goto done;
	61
	62	if (fops && fops->slave_pre_register &&
	63	fops->slave_pre_register(slave_dev, failover_dev))
	64	goto done;
65
66	err = netdev_rx_handler_register(slave_dev, fops->slave_handle_frame,
67	failover_dev);
68	if (err) {
69	netdev_err(slave_dev, "can not register failover rx handler (err = %d)\n",
70	err);
71	goto done;
72	}
73
74	lag_upper_info.tx_type = NETDEV_LAG_TX_TYPE_ACTIVEBACKUP;
75	err = netdev_master_upper_dev_link(slave_dev, failover_dev, NULL,
76	&lag_upper_info, NULL);
77	if (err) {
78	netdev_err(slave_dev, "can not set failover device %s (err = %d)\n",
79	failover_dev->name, err);
80	goto err_upper_link;
81	}
82
83	slave_dev->priv_flags \|= IFF_FAILOVER_SLAVE;
84
85	if (fops && fops->slave_register &&
86	!fops->slave_register(slave_dev, failover_dev))
87	return NOTIFY_OK;
88
89	netdev_upper_dev_unlink(slave_dev, failover_dev);
90	slave_dev->priv_flags &= ~IFF_FAILOVER_SLAVE;
91	err_upper_link:
92	netdev_rx_handler_unregister(slave_dev);
93	done:
94	return NOTIFY_DONE;
95	}
96
97	/**
98	* failover_slave_unregister - Unregister a slave netdev
99	*
100	* @slave_dev: slave netdev that is being unregistered
101	*
102	* Unregisters a slave device from a failover instance.
103	*/
104	int failover_slave_unregister(struct net_device *slave_dev)
105	{
106	struct net_device *failover_dev;
107	struct failover_ops *fops;
108
109	if (!netif_is_failover_slave(slave_dev))
110	goto done;
111
112	ASSERT_RTNL();
113
114	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
115	if (!failover_dev)
116	goto done;
117
118	if (fops && fops->slave_pre_unregister &&
119	fops->slave_pre_unregister(slave_dev, failover_dev))
120	goto done;
121
122	netdev_rx_handler_unregister(slave_dev);
123	netdev_upper_dev_unlink(slave_dev, failover_dev);
124	slave_dev->priv_flags &= ~IFF_FAILOVER_SLAVE;
125
126	if (fops && fops->slave_unregister &&
127	!fops->slave_unregister(slave_dev, failover_dev))
128	return NOTIFY_OK;
129
130	done:
131	return NOTIFY_DONE;
132	}
133	EXPORT_SYMBOL_GPL(failover_slave_unregister);
134
135	static int failover_slave_link_change(struct net_device *slave_dev)
136	{
137	struct net_device *failover_dev;
138	struct failover_ops *fops;
139
140	if (!netif_is_failover_slave(slave_dev))
141	goto done;
142
143	ASSERT_RTNL();
144
145	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
146	if (!failover_dev)
147	goto done;
148
149	if (!netif_running(failover_dev))
150	goto done;
151
152	if (fops && fops->slave_link_change &&
153	!fops->slave_link_change(slave_dev, failover_dev))
154	return NOTIFY_OK;
155
156	done:
157	return NOTIFY_DONE;
158	}
159
160	static int failover_slave_name_change(struct net_device *slave_dev)
161	{
162	struct net_device *failover_dev;
163	struct failover_ops *fops;
164
165	if (!netif_is_failover_slave(slave_dev))
166	goto done;
167
168	ASSERT_RTNL();
169
170	failover_dev = failover_get_bymac(slave_dev->perm_addr, &fops);
171	if (!failover_dev)
172	goto done;
173
174	if (!netif_running(failover_dev))
175	goto done;
176
177	if (fops && fops->slave_name_change &&
178	!fops->slave_name_change(slave_dev, failover_dev))
179	return NOTIFY_OK;
180
181	done:
182	return NOTIFY_DONE;
183	}
184
185	static int
186	failover_event(struct notifier_block this, unsigned long event, void ptr)
187	{
188	struct net_device *event_dev = netdev_notifier_info_to_dev(ptr);
189
190	/* Skip parent events */
191	if (netif_is_failover(event_dev))
192	return NOTIFY_DONE;
193
194	switch (event) {
195	case NETDEV_REGISTER:
196	return failover_slave_register(event_dev);
197	case NETDEV_UNREGISTER:
198	return failover_slave_unregister(event_dev);
199	case NETDEV_UP:
200	case NETDEV_DOWN:
201	case NETDEV_CHANGE:
202	return failover_slave_link_change(event_dev);
203	case NETDEV_CHANGENAME:
204	return failover_slave_name_change(event_dev);
205	default:
206	return NOTIFY_DONE;
207	}
208	}
209
210	static struct notifier_block failover_notifier = {
211	.notifier_call = failover_event,
212	};
213
214	static void
215	failover_existing_slave_register(struct net_device *failover_dev)
216	{
217	struct net *net = dev_net(failover_dev);
218	struct net_device *dev;
219
220	rtnl_lock();
221	for_each_netdev(net, dev) {
222	if (netif_is_failover(dev))
223	continue;
224	if (ether_addr_equal(failover_dev->perm_addr, dev->perm_addr))
225	failover_slave_register(dev);
226	}
227	rtnl_unlock();
228	}
229
230	/**
231	* failover_register - Register a failover instance
232	*
233	* @dev: failover netdev
234	* @ops: failover ops
235	*
236	* Allocate and register a failover instance for a failover netdev. ops
237	* provides handlers for slave device register/unregister/link change/
238	* name change events.
239	*
240	* Return: pointer to failover instance
241	*/
242	struct failover failover_register(struct net_device dev,
243	struct failover_ops *ops)
244	{
245	struct failover *failover;
246
247	if (dev->type != ARPHRD_ETHER)
248	return ERR_PTR(-EINVAL);
249
250	failover = kzalloc(sizeof(*failover), GFP_KERNEL);
251	if (!failover)
252	return ERR_PTR(-ENOMEM);
253
254	rcu_assign_pointer(failover->ops, ops);
255	dev_hold(dev);
256	dev->priv_flags \|= IFF_FAILOVER;
257	rcu_assign_pointer(failover->failover_dev, dev);
258
259	spin_lock(&failover_lock);
260	list_add_tail(&failover->list, &failover_list);
261	spin_unlock(&failover_lock);
262
263	netdev_info(dev, "failover master:%s registered\n", dev->name);
264
265	failover_existing_slave_register(dev);
266
267	return failover;
268	}
269	EXPORT_SYMBOL_GPL(failover_register);
270
271	/**
272	* failover_unregister - Unregister a failover instance
273	*
274	* @failover: pointer to failover instance
275	*
276	* Unregisters and frees a failover instance.
277	*/
278	void failover_unregister(struct failover *failover)
279	{
280	struct net_device *failover_dev;
281
282	failover_dev = rcu_dereference(failover->failover_dev);
283
284	netdev_info(failover_dev, "failover master:%s unregistered\n",
285	failover_dev->name);
286
287	failover_dev->priv_flags &= ~IFF_FAILOVER;
288	dev_put(failover_dev);
289
290	spin_lock(&failover_lock);
291	list_del(&failover->list);
292	spin_unlock(&failover_lock);
293
294	kfree(failover);
295	}
296	EXPORT_SYMBOL_GPL(failover_unregister);
297
298	static __init int
299	failover_init(void)
300	{
301	register_netdevice_notifier(&failover_notifier);
302
303	return 0;
304	}
305	module_init(failover_init);
306
307	static __exit
308	void failover_exit(void)
309	{
310	unregister_netdevice_notifier(&failover_notifier);
311	}
312	module_exit(failover_exit);
313
314	MODULE_DESCRIPTION("Generic failover infrastructure/interface");
315	MODULE_LICENSE("GPL v2");