[linux-block.git] / net / devlink / core.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Copyright (c) 2016 Mellanox Technologies. All rights reserved.
 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
 */

#include <net/genetlink.h>

#include "devl_internal.h"

DEFINE_XARRAY_FLAGS(devlinks, XA_FLAGS_ALLOC);

void *devlink_priv(struct devlink *devlink)
{
	return &devlink->priv;
}
EXPORT_SYMBOL_GPL(devlink_priv);

struct devlink *priv_to_devlink(void *priv)
{
	return container_of(priv, struct devlink, priv);
}
EXPORT_SYMBOL_GPL(priv_to_devlink);

struct device *devlink_to_dev(const struct devlink *devlink)
{
	return devlink->dev;
}
EXPORT_SYMBOL_GPL(devlink_to_dev);

struct net *devlink_net(const struct devlink *devlink)
{
	return read_pnet(&devlink->_net);
}
EXPORT_SYMBOL_GPL(devlink_net);

void devl_assert_locked(struct devlink *devlink)
{
	lockdep_assert_held(&devlink->lock);
}
EXPORT_SYMBOL_GPL(devl_assert_locked);

#ifdef CONFIG_LOCKDEP
/* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */
bool devl_lock_is_held(struct devlink *devlink)
{
	return lockdep_is_held(&devlink->lock);
}
EXPORT_SYMBOL_GPL(devl_lock_is_held);
#endif

void devl_lock(struct devlink *devlink)
{
	mutex_lock(&devlink->lock);
}
EXPORT_SYMBOL_GPL(devl_lock);

int devl_trylock(struct devlink *devlink)
{
	return mutex_trylock(&devlink->lock);
}
EXPORT_SYMBOL_GPL(devl_trylock);

void devl_unlock(struct devlink *devlink)
{
	mutex_unlock(&devlink->lock);
}
EXPORT_SYMBOL_GPL(devl_unlock);

/**
 * devlink_try_get() - try to obtain a reference on a devlink instance
 * @devlink: instance to reference
 *
 * Obtain a reference on a devlink instance. A reference on a devlink instance
 * only implies that it's safe to take the instance lock. It does not imply
 * that the instance is registered, use devl_is_registered() after taking
 * the instance lock to check registration status.
 */
struct devlink *__must_check devlink_try_get(struct devlink *devlink)
{
	if (refcount_inc_not_zero(&devlink->refcount))
		return devlink;
	return NULL;
}

static void devlink_release(struct work_struct *work)
{
	struct devlink *devlink;

	devlink = container_of(to_rcu_work(work), struct devlink, rwork);

	mutex_destroy(&devlink->lock);
	lockdep_unregister_key(&devlink->lock_key);
	kfree(devlink);
}

void devlink_put(struct devlink *devlink)
{
	if (refcount_dec_and_test(&devlink->refcount))
		queue_rcu_work(system_wq, &devlink->rwork);
}

struct devlink *devlinks_xa_find_get(struct net *net, unsigned long *indexp)
{
	struct devlink *devlink = NULL;

	rcu_read_lock();
retry:
	devlink = xa_find(&devlinks, indexp, ULONG_MAX, DEVLINK_REGISTERED);
	if (!devlink)
		goto unlock;

	if (!devlink_try_get(devlink))
		goto next;
	if (!net_eq(devlink_net(devlink), net)) {
		devlink_put(devlink);
		goto next;
	}
unlock:
	rcu_read_unlock();
	return devlink;

next:
	(*indexp)++;
	goto retry;
}

/**
 * devl_register - Register devlink instance
 * @devlink: devlink
 */
int devl_register(struct devlink *devlink)
{
	ASSERT_DEVLINK_NOT_REGISTERED(devlink);
	devl_assert_locked(devlink);

	xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
	devlink_notify_register(devlink);

	return 0;
}
EXPORT_SYMBOL_GPL(devl_register);

void devlink_register(struct devlink *devlink)
{
	devl_lock(devlink);
	devl_register(devlink);
	devl_unlock(devlink);
}
EXPORT_SYMBOL_GPL(devlink_register);

/**
 * devl_unregister - Unregister devlink instance
 * @devlink: devlink
 */
void devl_unregister(struct devlink *devlink)
{
	ASSERT_DEVLINK_REGISTERED(devlink);
	devl_assert_locked(devlink);

	devlink_notify_unregister(devlink);
	xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
}
EXPORT_SYMBOL_GPL(devl_unregister);

void devlink_unregister(struct devlink *devlink)
{
	devl_lock(devlink);
	devl_unregister(devlink);
	devl_unlock(devlink);
}
EXPORT_SYMBOL_GPL(devlink_unregister);

/**
 *	devlink_alloc_ns - Allocate new devlink instance resources
 *	in specific namespace
 *
 *	@ops: ops
 *	@priv_size: size of user private data
 *	@net: net namespace
 *	@dev: parent device
 *
 *	Allocate new devlink instance resources, including devlink index
 *	and name.
 */
struct devlink *devlink_alloc_ns(const struct devlink_ops *ops,
				 size_t priv_size, struct net *net,
				 struct device *dev)
{
	struct devlink *devlink;
	static u32 last_id;
	int ret;

	WARN_ON(!ops || !dev);
	if (!devlink_reload_actions_valid(ops))
		return NULL;

	devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
	if (!devlink)
		return NULL;

	ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b,
			      &last_id, GFP_KERNEL);
	if (ret < 0)
		goto err_xa_alloc;

	devlink->dev = dev;
	devlink->ops = ops;
	xa_init_flags(&devlink->ports, XA_FLAGS_ALLOC);
	xa_init_flags(&devlink->params, XA_FLAGS_ALLOC);
	xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
	write_pnet(&devlink->_net, net);
	INIT_LIST_HEAD(&devlink->rate_list);
	INIT_LIST_HEAD(&devlink->linecard_list);
	INIT_LIST_HEAD(&devlink->sb_list);
	INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
	INIT_LIST_HEAD(&devlink->resource_list);
	INIT_LIST_HEAD(&devlink->region_list);
	INIT_LIST_HEAD(&devlink->reporter_list);
	INIT_LIST_HEAD(&devlink->trap_list);
	INIT_LIST_HEAD(&devlink->trap_group_list);
	INIT_LIST_HEAD(&devlink->trap_policer_list);
	INIT_RCU_WORK(&devlink->rwork, devlink_release);
	lockdep_register_key(&devlink->lock_key);
	mutex_init(&devlink->lock);
	lockdep_set_class(&devlink->lock, &devlink->lock_key);
	refcount_set(&devlink->refcount, 1);

	return devlink;

err_xa_alloc:
	kfree(devlink);
	return NULL;
}
EXPORT_SYMBOL_GPL(devlink_alloc_ns);

/**
 *	devlink_free - Free devlink instance resources
 *
 *	@devlink: devlink
 */
void devlink_free(struct devlink *devlink)
{
	ASSERT_DEVLINK_NOT_REGISTERED(devlink);

	WARN_ON(!list_empty(&devlink->trap_policer_list));
	WARN_ON(!list_empty(&devlink->trap_group_list));
	WARN_ON(!list_empty(&devlink->trap_list));
	WARN_ON(!list_empty(&devlink->reporter_list));
	WARN_ON(!list_empty(&devlink->region_list));
	WARN_ON(!list_empty(&devlink->resource_list));
	WARN_ON(!list_empty(&devlink->dpipe_table_list));
	WARN_ON(!list_empty(&devlink->sb_list));
	WARN_ON(!list_empty(&devlink->rate_list));
	WARN_ON(!list_empty(&devlink->linecard_list));
	WARN_ON(!xa_empty(&devlink->ports));

	xa_destroy(&devlink->snapshot_ids);
	xa_destroy(&devlink->params);
	xa_destroy(&devlink->ports);

	xa_erase(&devlinks, devlink->index);

	devlink_put(devlink);
}
EXPORT_SYMBOL_GPL(devlink_free);

static void __net_exit devlink_pernet_pre_exit(struct net *net)
{
	struct devlink *devlink;
	u32 actions_performed;
	unsigned long index;
	int err;

	/* In case network namespace is getting destroyed, reload
	 * all devlink instances from this namespace into init_net.
	 */
	devlinks_xa_for_each_registered_get(net, index, devlink) {
		devl_lock(devlink);
		err = 0;
		if (devl_is_registered(devlink))
			err = devlink_reload(devlink, &init_net,
					     DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
					     DEVLINK_RELOAD_LIMIT_UNSPEC,
					     &actions_performed, NULL);
		devl_unlock(devlink);
		devlink_put(devlink);
		if (err && err != -EOPNOTSUPP)
			pr_warn("Failed to reload devlink instance into init_net\n");
	}
}

static struct pernet_operations devlink_pernet_ops __net_initdata = {
	.pre_exit = devlink_pernet_pre_exit,
};

static struct notifier_block devlink_port_netdevice_nb = {
	.notifier_call = devlink_port_netdevice_event,
};

static int __init devlink_init(void)
{
	int err;

	err = genl_register_family(&devlink_nl_family);
	if (err)
		goto out;
	err = register_pernet_subsys(&devlink_pernet_ops);
	if (err)
		goto out;
	err = register_netdevice_notifier(&devlink_port_netdevice_nb);

out:
	WARN_ON(err);
	return err;
}

subsys_initcall(devlink_init);
Commit	Line	Data
687125b5 JK	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/*
	3	* Copyright (c) 2016 Mellanox Technologies. All rights reserved.
	4	* Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
	5	*/
	6
	7	#include <net/genetlink.h>
	8
	9	#include "devl_internal.h"
	10
	11	DEFINE_XARRAY_FLAGS(devlinks, XA_FLAGS_ALLOC);
	12
	13	void devlink_priv(struct devlink devlink)
	14	{
	15	return &devlink->priv;
	16	}
	17	EXPORT_SYMBOL_GPL(devlink_priv);
	18
	19	struct devlink priv_to_devlink(void priv)
	20	{
	21	return container_of(priv, struct devlink, priv);
	22	}
	23	EXPORT_SYMBOL_GPL(priv_to_devlink);
	24
	25	struct device devlink_to_dev(const struct devlink devlink)
	26	{
	27	return devlink->dev;
	28	}
	29	EXPORT_SYMBOL_GPL(devlink_to_dev);
	30
	31	struct net devlink_net(const struct devlink devlink)
	32	{
	33	return read_pnet(&devlink->_net);
	34	}
	35	EXPORT_SYMBOL_GPL(devlink_net);
	36
	37	void devl_assert_locked(struct devlink *devlink)
	38	{
	39	lockdep_assert_held(&devlink->lock);
	40	}
	41	EXPORT_SYMBOL_GPL(devl_assert_locked);
	42
	43	#ifdef CONFIG_LOCKDEP
	44	/* For use in conjunction with LOCKDEP only e.g. rcu_dereference_protected() */
	45	bool devl_lock_is_held(struct devlink *devlink)
	46	{
	47	return lockdep_is_held(&devlink->lock);
	48	}
	49	EXPORT_SYMBOL_GPL(devl_lock_is_held);
	50	#endif
	51
	52	void devl_lock(struct devlink *devlink)
	53	{
	54	mutex_lock(&devlink->lock);
	55	}
	56	EXPORT_SYMBOL_GPL(devl_lock);
	57
	58	int devl_trylock(struct devlink *devlink)
	59	{
	60	return mutex_trylock(&devlink->lock);
	61	}
	62	EXPORT_SYMBOL_GPL(devl_trylock);
	63
	64	void devl_unlock(struct devlink *devlink)
65	{
66	mutex_unlock(&devlink->lock);
67	}
68	EXPORT_SYMBOL_GPL(devl_unlock);
69
ed539ba6 JK	70	/**
	71	* devlink_try_get() - try to obtain a reference on a devlink instance
	72	* @devlink: instance to reference
	73	*
	74	* Obtain a reference on a devlink instance. A reference on a devlink instance
	75	* only implies that it's safe to take the instance lock. It does not imply
	76	* that the instance is registered, use devl_is_registered() after taking
	77	* the instance lock to check registration status.
	78	*/
687125b5 JK	79	struct devlink __must_check devlink_try_get(struct devlink devlink)
	80	{
	81	if (refcount_inc_not_zero(&devlink->refcount))
	82	return devlink;
	83	return NULL;
	84	}
	85
93e71edf JK	86	static void devlink_release(struct work_struct *work)
	87	{
	88	struct devlink *devlink;
	89
	90	devlink = container_of(to_rcu_work(work), struct devlink, rwork);
	91
	92	mutex_destroy(&devlink->lock);
	93	lockdep_unregister_key(&devlink->lock_key);
	94	kfree(devlink);
	95	}
	96
687125b5 JK	97	void devlink_put(struct devlink *devlink)
	98	{
	99	if (refcount_dec_and_test(&devlink->refcount))
93e71edf	100	queue_rcu_work(system_wq, &devlink->rwork);
687125b5 JK	101	}
687125b5 JK	102
d7727819	103	struct devlink devlinks_xa_find_get(struct net net, unsigned long *indexp)
687125b5	104	{
d7727819	105	struct devlink *devlink = NULL;
687125b5 JK	106
	107	rcu_read_lock();
	108	retry:
d7727819	109	devlink = xa_find(&devlinks, indexp, ULONG_MAX, DEVLINK_REGISTERED);
687125b5 JK	110	if (!devlink)
	111	goto unlock;
	112
687125b5	113	if (!devlink_try_get(devlink))
d7727819	114	goto next;
687125b5 JK	115	if (!net_eq(devlink_net(devlink), net)) {
687125b5 JK	116	devlink_put(devlink);
d7727819	117	goto next;
687125b5 JK	118	}
	119	unlock:
	120	rcu_read_unlock();
	121	return devlink;
687125b5	122
d7727819 JK	123	next:
	124	(*indexp)++;
	125	goto retry;
687125b5 JK	126	}
687125b5 JK	127
687125b5	128	/**
9053637e JK	129	* devl_register - Register devlink instance
9053637e JK	130	* @devlink: devlink
687125b5	131	*/
9053637e	132	int devl_register(struct devlink *devlink)
687125b5 JK	133	{
687125b5 JK	134	ASSERT_DEVLINK_NOT_REGISTERED(devlink);
9053637e	135	devl_assert_locked(devlink);
687125b5 JK	136
	137	xa_set_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
	138	devlink_notify_register(devlink);
9053637e JK	139
	140	return 0;
	141	}
	142	EXPORT_SYMBOL_GPL(devl_register);
	143
	144	void devlink_register(struct devlink *devlink)
	145	{
	146	devl_lock(devlink);
	147	devl_register(devlink);
	148	devl_unlock(devlink);
687125b5 JK	149	}
	150	EXPORT_SYMBOL_GPL(devlink_register);
	151
	152	/**
9053637e JK	153	* devl_unregister - Unregister devlink instance
9053637e JK	154	* @devlink: devlink
687125b5	155	*/
9053637e	156	void devl_unregister(struct devlink *devlink)
687125b5 JK	157	{
687125b5 JK	158	ASSERT_DEVLINK_REGISTERED(devlink);
9053637e	159	devl_assert_locked(devlink);
687125b5 JK	160
	161	devlink_notify_unregister(devlink);
	162	xa_clear_mark(&devlinks, devlink->index, DEVLINK_REGISTERED);
9053637e JK	163	}
	164	EXPORT_SYMBOL_GPL(devl_unregister);
	165
	166	void devlink_unregister(struct devlink *devlink)
	167	{
	168	devl_lock(devlink);
	169	devl_unregister(devlink);
	170	devl_unlock(devlink);
687125b5 JK	171	}
	172	EXPORT_SYMBOL_GPL(devlink_unregister);
	173
	174	/**
	175	* devlink_alloc_ns - Allocate new devlink instance resources
	176	* in specific namespace
	177	*
	178	* @ops: ops
	179	* @priv_size: size of user private data
	180	* @net: net namespace
	181	* @dev: parent device
	182	*
	183	* Allocate new devlink instance resources, including devlink index
	184	* and name.
	185	*/
	186	struct devlink devlink_alloc_ns(const struct devlink_ops ops,
	187	size_t priv_size, struct net *net,
	188	struct device *dev)
	189	{
	190	struct devlink *devlink;
	191	static u32 last_id;
	192	int ret;
	193
	194	WARN_ON(!ops \|\| !dev);
	195	if (!devlink_reload_actions_valid(ops))
	196	return NULL;
	197
	198	devlink = kzalloc(sizeof(*devlink) + priv_size, GFP_KERNEL);
	199	if (!devlink)
	200	return NULL;
	201
	202	ret = xa_alloc_cyclic(&devlinks, &devlink->index, devlink, xa_limit_31b,
	203	&last_id, GFP_KERNEL);
	204	if (ret < 0)
	205	goto err_xa_alloc;
	206
687125b5 JK	207	devlink->dev = dev;
	208	devlink->ops = ops;
	209	xa_init_flags(&devlink->ports, XA_FLAGS_ALLOC);
a72e17b4	210	xa_init_flags(&devlink->params, XA_FLAGS_ALLOC);
687125b5 JK	211	xa_init_flags(&devlink->snapshot_ids, XA_FLAGS_ALLOC);
	212	write_pnet(&devlink->_net, net);
	213	INIT_LIST_HEAD(&devlink->rate_list);
	214	INIT_LIST_HEAD(&devlink->linecard_list);
	215	INIT_LIST_HEAD(&devlink->sb_list);
	216	INIT_LIST_HEAD_RCU(&devlink->dpipe_table_list);
	217	INIT_LIST_HEAD(&devlink->resource_list);
687125b5 JK	218	INIT_LIST_HEAD(&devlink->region_list);
	219	INIT_LIST_HEAD(&devlink->reporter_list);
	220	INIT_LIST_HEAD(&devlink->trap_list);
	221	INIT_LIST_HEAD(&devlink->trap_group_list);
	222	INIT_LIST_HEAD(&devlink->trap_policer_list);
93e71edf	223	INIT_RCU_WORK(&devlink->rwork, devlink_release);
687125b5 JK	224	lockdep_register_key(&devlink->lock_key);
	225	mutex_init(&devlink->lock);
	226	lockdep_set_class(&devlink->lock, &devlink->lock_key);
687125b5	227	refcount_set(&devlink->refcount, 1);
687125b5 JK	228
	229	return devlink;
	230
687125b5 JK	231	err_xa_alloc:
	232	kfree(devlink);
	233	return NULL;
	234	}
	235	EXPORT_SYMBOL_GPL(devlink_alloc_ns);
	236
	237	/**
	238	* devlink_free - Free devlink instance resources
	239	*
	240	* @devlink: devlink
	241	*/
	242	void devlink_free(struct devlink *devlink)
	243	{
	244	ASSERT_DEVLINK_NOT_REGISTERED(devlink);
	245
687125b5 JK	246	WARN_ON(!list_empty(&devlink->trap_policer_list));
	247	WARN_ON(!list_empty(&devlink->trap_group_list));
	248	WARN_ON(!list_empty(&devlink->trap_list));
	249	WARN_ON(!list_empty(&devlink->reporter_list));
	250	WARN_ON(!list_empty(&devlink->region_list));
687125b5 JK	251	WARN_ON(!list_empty(&devlink->resource_list));
	252	WARN_ON(!list_empty(&devlink->dpipe_table_list));
	253	WARN_ON(!list_empty(&devlink->sb_list));
	254	WARN_ON(!list_empty(&devlink->rate_list));
	255	WARN_ON(!list_empty(&devlink->linecard_list));
	256	WARN_ON(!xa_empty(&devlink->ports));
	257
	258	xa_destroy(&devlink->snapshot_ids);
a72e17b4	259	xa_destroy(&devlink->params);
687125b5 JK	260	xa_destroy(&devlink->ports);
687125b5 JK	261
687125b5 JK	262	xa_erase(&devlinks, devlink->index);
687125b5 JK	263
9053637e	264	devlink_put(devlink);
687125b5 JK	265	}
	266	EXPORT_SYMBOL_GPL(devlink_free);
	267
	268	static void __net_exit devlink_pernet_pre_exit(struct net *net)
	269	{
	270	struct devlink *devlink;
	271	u32 actions_performed;
	272	unsigned long index;
	273	int err;
	274
	275	/* In case network namespace is getting destroyed, reload
	276	* all devlink instances from this namespace into init_net.
	277	*/
	278	devlinks_xa_for_each_registered_get(net, index, devlink) {
7a54a519	279	devl_lock(devlink);
ed539ba6 JK	280	err = 0;
	281	if (devl_is_registered(devlink))
	282	err = devlink_reload(devlink, &init_net,
	283	DEVLINK_RELOAD_ACTION_DRIVER_REINIT,
	284	DEVLINK_RELOAD_LIMIT_UNSPEC,
	285	&actions_performed, NULL);
7a54a519 JK	286	devl_unlock(devlink);
7a54a519 JK	287	devlink_put(devlink);
687125b5 JK	288	if (err && err != -EOPNOTSUPP)
687125b5 JK	289	pr_warn("Failed to reload devlink instance into init_net\n");
687125b5 JK	290	}
	291	}
	292
	293	static struct pernet_operations devlink_pernet_ops __net_initdata = {
	294	.pre_exit = devlink_pernet_pre_exit,
	295	};
	296
d6352dae	297	static struct notifier_block devlink_port_netdevice_nb = {
e93c9378 JP	298	.notifier_call = devlink_port_netdevice_event,
	299	};
	300
687125b5 JK	301	static int __init devlink_init(void)
	302	{
	303	int err;
	304
	305	err = genl_register_family(&devlink_nl_family);
	306	if (err)
	307	goto out;
	308	err = register_pernet_subsys(&devlink_pernet_ops);
e93c9378 JP	309	if (err)
	310	goto out;
	311	err = register_netdevice_notifier(&devlink_port_netdevice_nb);
687125b5 JK	312
	313	out:
	314	WARN_ON(err);
	315	return err;
	316	}
	317
	318	subsys_initcall(devlink_init);