[linux-2.6-block.git] / drivers / net / netdevsim / bus.c

// SPDX-License-Identifier: GPL-2.0
/* Copyright (C) 2017 Netronome Systems, Inc.
 * Copyright (C) 2019 Mellanox Technologies. All rights reserved
 */

#include <linux/device.h>
#include <linux/idr.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/rtnetlink.h>
#include <linux/slab.h>
#include <linux/sysfs.h>

#include "netdevsim.h"

static DEFINE_IDA(nsim_bus_dev_ids);
static LIST_HEAD(nsim_bus_dev_list);
static DEFINE_MUTEX(nsim_bus_dev_list_lock);
static bool nsim_bus_enable;

static struct nsim_bus_dev *to_nsim_bus_dev(struct device *dev)
{
	return container_of(dev, struct nsim_bus_dev, dev);
}

static int nsim_bus_dev_vfs_enable(struct nsim_bus_dev *nsim_bus_dev,
				   unsigned int num_vfs)
{
	nsim_bus_dev->vfconfigs = kcalloc(num_vfs,
					  sizeof(struct nsim_vf_config),
					  GFP_KERNEL | __GFP_NOWARN);
	if (!nsim_bus_dev->vfconfigs)
		return -ENOMEM;
	nsim_bus_dev->num_vfs = num_vfs;

	return 0;
}

static void nsim_bus_dev_vfs_disable(struct nsim_bus_dev *nsim_bus_dev)
{
	kfree(nsim_bus_dev->vfconfigs);
	nsim_bus_dev->vfconfigs = NULL;
	nsim_bus_dev->num_vfs = 0;
}

static ssize_t
nsim_bus_dev_numvfs_store(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	unsigned int num_vfs;
	int ret;

	ret = kstrtouint(buf, 0, &num_vfs);
	if (ret)
		return ret;

	rtnl_lock();
	if (nsim_bus_dev->num_vfs == num_vfs)
		goto exit_good;
	if (nsim_bus_dev->num_vfs && num_vfs) {
		ret = -EBUSY;
		goto exit_unlock;
	}

	if (num_vfs) {
		ret = nsim_bus_dev_vfs_enable(nsim_bus_dev, num_vfs);
		if (ret)
			goto exit_unlock;
	} else {
		nsim_bus_dev_vfs_disable(nsim_bus_dev);
	}
exit_good:
	ret = count;
exit_unlock:
	rtnl_unlock();

	return ret;
}

static ssize_t
nsim_bus_dev_numvfs_show(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);

	return sprintf(buf, "%u\n", nsim_bus_dev->num_vfs);
}

static struct device_attribute nsim_bus_dev_numvfs_attr =
	__ATTR(sriov_numvfs, 0664, nsim_bus_dev_numvfs_show,
	       nsim_bus_dev_numvfs_store);

static ssize_t
new_port_store(struct device *dev, struct device_attribute *attr,
	       const char *buf, size_t count)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	struct nsim_dev *nsim_dev = dev_get_drvdata(dev);
	struct devlink *devlink;
	unsigned int port_index;
	int ret;

	/* Prevent to use nsim_bus_dev before initialization. */
	if (!smp_load_acquire(&nsim_bus_dev->init))
		return -EBUSY;
	ret = kstrtouint(buf, 0, &port_index);
	if (ret)
		return ret;

	devlink = priv_to_devlink(nsim_dev);

	mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock);
	devlink_reload_disable(devlink);
	ret = nsim_dev_port_add(nsim_bus_dev, port_index);
	devlink_reload_enable(devlink);
	mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
	return ret ? ret : count;
}

static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port);

static ssize_t
del_port_store(struct device *dev, struct device_attribute *attr,
	       const char *buf, size_t count)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	struct nsim_dev *nsim_dev = dev_get_drvdata(dev);
	struct devlink *devlink;
	unsigned int port_index;
	int ret;

	/* Prevent to use nsim_bus_dev before initialization. */
	if (!smp_load_acquire(&nsim_bus_dev->init))
		return -EBUSY;
	ret = kstrtouint(buf, 0, &port_index);
	if (ret)
		return ret;

	devlink = priv_to_devlink(nsim_dev);

	mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock);
	devlink_reload_disable(devlink);
	ret = nsim_dev_port_del(nsim_bus_dev, port_index);
	devlink_reload_enable(devlink);
	mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
	return ret ? ret : count;
}

static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port);

static struct attribute *nsim_bus_dev_attrs[] = {
	&nsim_bus_dev_numvfs_attr.attr,
	&nsim_bus_dev_new_port_attr.attr,
	&nsim_bus_dev_del_port_attr.attr,
	NULL,
};

static const struct attribute_group nsim_bus_dev_attr_group = {
	.attrs = nsim_bus_dev_attrs,
};

static const struct attribute_group *nsim_bus_dev_attr_groups[] = {
	&nsim_bus_dev_attr_group,
	NULL,
};

static void nsim_bus_dev_release(struct device *dev)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);

	nsim_bus_dev_vfs_disable(nsim_bus_dev);
}

static struct device_type nsim_bus_dev_type = {
	.groups = nsim_bus_dev_attr_groups,
	.release = nsim_bus_dev_release,
};

static struct nsim_bus_dev *
nsim_bus_dev_new(unsigned int id, unsigned int port_count);

static ssize_t
new_device_store(struct bus_type *bus, const char *buf, size_t count)
{
	struct nsim_bus_dev *nsim_bus_dev;
	unsigned int port_count;
	unsigned int id;
	int err;

	err = sscanf(buf, "%u %u", &id, &port_count);
	switch (err) {
	case 1:
		port_count = 1;
		fallthrough;
	case 2:
		if (id > INT_MAX) {
			pr_err("Value of \"id\" is too big.\n");
			return -EINVAL;
		}
		break;
	default:
		pr_err("Format for adding new device is \"id port_count\" (uint uint).\n");
		return -EINVAL;
	}

	mutex_lock(&nsim_bus_dev_list_lock);
	/* Prevent to use resource before initialization. */
	if (!smp_load_acquire(&nsim_bus_enable)) {
		err = -EBUSY;
		goto err;
	}

	nsim_bus_dev = nsim_bus_dev_new(id, port_count);
	if (IS_ERR(nsim_bus_dev)) {
		err = PTR_ERR(nsim_bus_dev);
		goto err;
	}

	/* Allow using nsim_bus_dev */
	smp_store_release(&nsim_bus_dev->init, true);

	list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list);
	mutex_unlock(&nsim_bus_dev_list_lock);

	return count;
err:
	mutex_unlock(&nsim_bus_dev_list_lock);
	return err;
}
static BUS_ATTR_WO(new_device);

static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev);

static ssize_t
del_device_store(struct bus_type *bus, const char *buf, size_t count)
{
	struct nsim_bus_dev *nsim_bus_dev, *tmp;
	unsigned int id;
	int err;

	err = sscanf(buf, "%u", &id);
	switch (err) {
	case 1:
		if (id > INT_MAX) {
			pr_err("Value of \"id\" is too big.\n");
			return -EINVAL;
		}
		break;
	default:
		pr_err("Format for deleting device is \"id\" (uint).\n");
		return -EINVAL;
	}

	err = -ENOENT;
	mutex_lock(&nsim_bus_dev_list_lock);
	/* Prevent to use resource before initialization. */
	if (!smp_load_acquire(&nsim_bus_enable)) {
		mutex_unlock(&nsim_bus_dev_list_lock);
		return -EBUSY;
	}
	list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
		if (nsim_bus_dev->dev.id != id)
			continue;
		list_del(&nsim_bus_dev->list);
		nsim_bus_dev_del(nsim_bus_dev);
		err = 0;
		break;
	}
	mutex_unlock(&nsim_bus_dev_list_lock);
	return !err ? count : err;
}
static BUS_ATTR_WO(del_device);

static struct attribute *nsim_bus_attrs[] = {
	&bus_attr_new_device.attr,
	&bus_attr_del_device.attr,
	NULL
};
ATTRIBUTE_GROUPS(nsim_bus);

static int nsim_bus_probe(struct device *dev)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);

	return nsim_dev_probe(nsim_bus_dev);
}

static int nsim_bus_remove(struct device *dev)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);

	nsim_dev_remove(nsim_bus_dev);
	return 0;
}

static int nsim_num_vf(struct device *dev)
{
	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);

	return nsim_bus_dev->num_vfs;
}

static struct bus_type nsim_bus = {
	.name		= DRV_NAME,
	.dev_name	= DRV_NAME,
	.bus_groups	= nsim_bus_groups,
	.probe		= nsim_bus_probe,
	.remove		= nsim_bus_remove,
	.num_vf		= nsim_num_vf,
};

static struct nsim_bus_dev *
nsim_bus_dev_new(unsigned int id, unsigned int port_count)
{
	struct nsim_bus_dev *nsim_bus_dev;
	int err;

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

	err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL);
	if (err < 0)
		goto err_nsim_bus_dev_free;
	nsim_bus_dev->dev.id = err;
	nsim_bus_dev->dev.bus = &nsim_bus;
	nsim_bus_dev->dev.type = &nsim_bus_dev_type;
	nsim_bus_dev->port_count = port_count;
	nsim_bus_dev->initial_net = current->nsproxy->net_ns;
	mutex_init(&nsim_bus_dev->nsim_bus_reload_lock);
	/* Disallow using nsim_bus_dev */
	smp_store_release(&nsim_bus_dev->init, false);

	err = device_register(&nsim_bus_dev->dev);
	if (err)
		goto err_nsim_bus_dev_id_free;
	return nsim_bus_dev;

err_nsim_bus_dev_id_free:
	ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
err_nsim_bus_dev_free:
	kfree(nsim_bus_dev);
	return ERR_PTR(err);
}

static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev)
{
	/* Disallow using nsim_bus_dev */
	smp_store_release(&nsim_bus_dev->init, false);
	device_unregister(&nsim_bus_dev->dev);
	ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
	kfree(nsim_bus_dev);
}

static struct device_driver nsim_driver = {
	.name		= DRV_NAME,
	.bus		= &nsim_bus,
	.owner		= THIS_MODULE,
};

int nsim_bus_init(void)
{
	int err;

	err = bus_register(&nsim_bus);
	if (err)
		return err;
	err = driver_register(&nsim_driver);
	if (err)
		goto err_bus_unregister;
	/* Allow using resources */
	smp_store_release(&nsim_bus_enable, true);
	return 0;

err_bus_unregister:
	bus_unregister(&nsim_bus);
	return err;
}

void nsim_bus_exit(void)
{
	struct nsim_bus_dev *nsim_bus_dev, *tmp;

	/* Disallow using resources */
	smp_store_release(&nsim_bus_enable, false);

	mutex_lock(&nsim_bus_dev_list_lock);
	list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
		list_del(&nsim_bus_dev->list);
		nsim_bus_dev_del(nsim_bus_dev);
	}
	mutex_unlock(&nsim_bus_dev_list_lock);

	driver_unregister(&nsim_driver);
	bus_unregister(&nsim_bus);
}
Commit	Line	Data
925f5afe JP	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (C) 2017 Netronome Systems, Inc.
	3	* Copyright (C) 2019 Mellanox Technologies. All rights reserved
	4	*/
	5
	6	#include <linux/device.h>
57ce9774	7	#include <linux/idr.h>
40e4fe4c	8	#include <linux/kernel.h>
f9d9db47 JP	9	#include <linux/list.h>
f9d9db47 JP	10	#include <linux/mutex.h>
40e4fe4c JP	11	#include <linux/rtnetlink.h>
	12	#include <linux/slab.h>
	13	#include <linux/sysfs.h>
925f5afe JP	14
	15	#include "netdevsim.h"
	16
57ce9774	17	static DEFINE_IDA(nsim_bus_dev_ids);
f9d9db47 JP	18	static LIST_HEAD(nsim_bus_dev_list);
f9d9db47 JP	19	static DEFINE_MUTEX(nsim_bus_dev_list_lock);
f5cd2160	20	static bool nsim_bus_enable;
40e4fe4c JP	21
	22	static struct nsim_bus_dev to_nsim_bus_dev(struct device dev)
	23	{
	24	return container_of(dev, struct nsim_bus_dev, dev);
	25	}
	26
	27	static int nsim_bus_dev_vfs_enable(struct nsim_bus_dev *nsim_bus_dev,
	28	unsigned int num_vfs)
	29	{
	30	nsim_bus_dev->vfconfigs = kcalloc(num_vfs,
	31	sizeof(struct nsim_vf_config),
83cf4213	32	GFP_KERNEL \| __GFP_NOWARN);
40e4fe4c JP	33	if (!nsim_bus_dev->vfconfigs)
	34	return -ENOMEM;
	35	nsim_bus_dev->num_vfs = num_vfs;
	36
	37	return 0;
	38	}
	39
	40	static void nsim_bus_dev_vfs_disable(struct nsim_bus_dev *nsim_bus_dev)
	41	{
	42	kfree(nsim_bus_dev->vfconfigs);
	43	nsim_bus_dev->vfconfigs = NULL;
	44	nsim_bus_dev->num_vfs = 0;
	45	}
	46
	47	static ssize_t
	48	nsim_bus_dev_numvfs_store(struct device dev, struct device_attribute attr,
	49	const char *buf, size_t count)
	50	{
	51	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	52	unsigned int num_vfs;
	53	int ret;
	54
	55	ret = kstrtouint(buf, 0, &num_vfs);
	56	if (ret)
	57	return ret;
	58
	59	rtnl_lock();
	60	if (nsim_bus_dev->num_vfs == num_vfs)
	61	goto exit_good;
	62	if (nsim_bus_dev->num_vfs && num_vfs) {
	63	ret = -EBUSY;
	64	goto exit_unlock;
	65	}
	66
	67	if (num_vfs) {
	68	ret = nsim_bus_dev_vfs_enable(nsim_bus_dev, num_vfs);
	69	if (ret)
	70	goto exit_unlock;
	71	} else {
	72	nsim_bus_dev_vfs_disable(nsim_bus_dev);
	73	}
	74	exit_good:
	75	ret = count;
	76	exit_unlock:
	77	rtnl_unlock();
	78
	79	return ret;
	80	}
	81
	82	static ssize_t
	83	nsim_bus_dev_numvfs_show(struct device *dev,
	84	struct device_attribute attr, char buf)
	85	{
	86	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	87
	88	return sprintf(buf, "%u\n", nsim_bus_dev->num_vfs);
	89	}
	90
	91	static struct device_attribute nsim_bus_dev_numvfs_attr =
	92	__ATTR(sriov_numvfs, 0664, nsim_bus_dev_numvfs_show,
	93	nsim_bus_dev_numvfs_store);
	94
794b2c05 JP	95	static ssize_t
	96	new_port_store(struct device dev, struct device_attribute attr,
	97	const char *buf, size_t count)
	98	{
	99	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
6ab63366 TY	100	struct nsim_dev *nsim_dev = dev_get_drvdata(dev);
6ab63366 TY	101	struct devlink *devlink;
794b2c05 JP	102	unsigned int port_index;
	103	int ret;
	104
f5cd2160 TY	105	/* Prevent to use nsim_bus_dev before initialization. */
	106	if (!smp_load_acquire(&nsim_bus_dev->init))
	107	return -EBUSY;
794b2c05 JP	108	ret = kstrtouint(buf, 0, &port_index);
	109	if (ret)
	110	return ret;
6ab63366 TY	111
	112	devlink = priv_to_devlink(nsim_dev);
	113
	114	mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock);
	115	devlink_reload_disable(devlink);
794b2c05	116	ret = nsim_dev_port_add(nsim_bus_dev, port_index);
6ab63366 TY	117	devlink_reload_enable(devlink);
6ab63366 TY	118	mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
794b2c05 JP	119	return ret ? ret : count;
	120	}
	121
	122	static struct device_attribute nsim_bus_dev_new_port_attr = __ATTR_WO(new_port);
	123
	124	static ssize_t
	125	del_port_store(struct device dev, struct device_attribute attr,
	126	const char *buf, size_t count)
	127	{
	128	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
6ab63366 TY	129	struct nsim_dev *nsim_dev = dev_get_drvdata(dev);
6ab63366 TY	130	struct devlink *devlink;
794b2c05 JP	131	unsigned int port_index;
	132	int ret;
	133
f5cd2160 TY	134	/* Prevent to use nsim_bus_dev before initialization. */
	135	if (!smp_load_acquire(&nsim_bus_dev->init))
	136	return -EBUSY;
794b2c05 JP	137	ret = kstrtouint(buf, 0, &port_index);
	138	if (ret)
	139	return ret;
6ab63366 TY	140
	141	devlink = priv_to_devlink(nsim_dev);
	142
	143	mutex_lock(&nsim_bus_dev->nsim_bus_reload_lock);
	144	devlink_reload_disable(devlink);
794b2c05	145	ret = nsim_dev_port_del(nsim_bus_dev, port_index);
6ab63366 TY	146	devlink_reload_enable(devlink);
6ab63366 TY	147	mutex_unlock(&nsim_bus_dev->nsim_bus_reload_lock);
794b2c05 JP	148	return ret ? ret : count;
	149	}
	150
	151	static struct device_attribute nsim_bus_dev_del_port_attr = __ATTR_WO(del_port);
	152
40e4fe4c JP	153	static struct attribute *nsim_bus_dev_attrs[] = {
40e4fe4c JP	154	&nsim_bus_dev_numvfs_attr.attr,
794b2c05 JP	155	&nsim_bus_dev_new_port_attr.attr,
794b2c05 JP	156	&nsim_bus_dev_del_port_attr.attr,
40e4fe4c JP	157	NULL,
	158	};
	159
	160	static const struct attribute_group nsim_bus_dev_attr_group = {
	161	.attrs = nsim_bus_dev_attrs,
	162	};
	163
	164	static const struct attribute_group *nsim_bus_dev_attr_groups[] = {
	165	&nsim_bus_dev_attr_group,
	166	NULL,
	167	};
	168
	169	static void nsim_bus_dev_release(struct device *dev)
	170	{
	171	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	172
	173	nsim_bus_dev_vfs_disable(nsim_bus_dev);
	174	}
	175
	176	static struct device_type nsim_bus_dev_type = {
	177	.groups = nsim_bus_dev_attr_groups,
	178	.release = nsim_bus_dev_release,
	179	};
	180
e05b2d14 JP	181	static struct nsim_bus_dev *
	182	nsim_bus_dev_new(unsigned int id, unsigned int port_count);
	183
f9d9db47 JP	184	static ssize_t
	185	new_device_store(struct bus_type bus, const char buf, size_t count)
	186	{
	187	struct nsim_bus_dev *nsim_bus_dev;
	188	unsigned int port_count;
	189	unsigned int id;
	190	int err;
	191
	192	err = sscanf(buf, "%u %u", &id, &port_count);
	193	switch (err) {
	194	case 1:
	195	port_count = 1;
df561f66	196	fallthrough;
f9d9db47 JP	197	case 2:
	198	if (id > INT_MAX) {
	199	pr_err("Value of \"id\" is too big.\n");
	200	return -EINVAL;
	201	}
	202	break;
	203	default:
	204	pr_err("Format for adding new device is \"id port_count\" (uint uint).\n");
	205	return -EINVAL;
	206	}
f9d9db47 JP	207
f9d9db47 JP	208	mutex_lock(&nsim_bus_dev_list_lock);
f5cd2160 TY	209	/* Prevent to use resource before initialization. */
	210	if (!smp_load_acquire(&nsim_bus_enable)) {
	211	err = -EBUSY;
	212	goto err;
	213	}
	214
	215	nsim_bus_dev = nsim_bus_dev_new(id, port_count);
	216	if (IS_ERR(nsim_bus_dev)) {
	217	err = PTR_ERR(nsim_bus_dev);
	218	goto err;
	219	}
	220
	221	/* Allow using nsim_bus_dev */
	222	smp_store_release(&nsim_bus_dev->init, true);
	223
f9d9db47 JP	224	list_add_tail(&nsim_bus_dev->list, &nsim_bus_dev_list);
	225	mutex_unlock(&nsim_bus_dev_list_lock);
	226
	227	return count;
f5cd2160 TY	228	err:
	229	mutex_unlock(&nsim_bus_dev_list_lock);
	230	return err;
f9d9db47 JP	231	}
	232	static BUS_ATTR_WO(new_device);
	233
e05b2d14 JP	234	static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev);
e05b2d14 JP	235
f9d9db47 JP	236	static ssize_t
	237	del_device_store(struct bus_type bus, const char buf, size_t count)
	238	{
	239	struct nsim_bus_dev nsim_bus_dev, tmp;
	240	unsigned int id;
	241	int err;
	242
	243	err = sscanf(buf, "%u", &id);
	244	switch (err) {
	245	case 1:
	246	if (id > INT_MAX) {
	247	pr_err("Value of \"id\" is too big.\n");
	248	return -EINVAL;
	249	}
	250	break;
	251	default:
	252	pr_err("Format for deleting device is \"id\" (uint).\n");
	253	return -EINVAL;
	254	}
	255
	256	err = -ENOENT;
	257	mutex_lock(&nsim_bus_dev_list_lock);
f5cd2160 TY	258	/* Prevent to use resource before initialization. */
	259	if (!smp_load_acquire(&nsim_bus_enable)) {
	260	mutex_unlock(&nsim_bus_dev_list_lock);
	261	return -EBUSY;
	262	}
f9d9db47 JP	263	list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
	264	if (nsim_bus_dev->dev.id != id)
	265	continue;
	266	list_del(&nsim_bus_dev->list);
	267	nsim_bus_dev_del(nsim_bus_dev);
	268	err = 0;
	269	break;
	270	}
	271	mutex_unlock(&nsim_bus_dev_list_lock);
	272	return !err ? count : err;
	273	}
	274	static BUS_ATTR_WO(del_device);
	275
	276	static struct attribute *nsim_bus_attrs[] = {
	277	&bus_attr_new_device.attr,
	278	&bus_attr_del_device.attr,
	279	NULL
	280	};
	281	ATTRIBUTE_GROUPS(nsim_bus);
	282
8320d145 JP	283	static int nsim_bus_probe(struct device *dev)
	284	{
	285	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	286
	287	return nsim_dev_probe(nsim_bus_dev);
	288	}
	289
	290	static int nsim_bus_remove(struct device *dev)
	291	{
	292	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	293
	294	nsim_dev_remove(nsim_bus_dev);
	295	return 0;
	296	}
	297
69bbbdc5	298	static int nsim_num_vf(struct device *dev)
40e4fe4c JP	299	{
	300	struct nsim_bus_dev *nsim_bus_dev = to_nsim_bus_dev(dev);
	301
	302	return nsim_bus_dev->num_vfs;
	303	}
	304
	305	static struct bus_type nsim_bus = {
925f5afe JP	306	.name = DRV_NAME,
925f5afe JP	307	.dev_name = DRV_NAME,
f9d9db47	308	.bus_groups = nsim_bus_groups,
8320d145 JP	309	.probe = nsim_bus_probe,
8320d145 JP	310	.remove = nsim_bus_remove,
925f5afe JP	311	.num_vf = nsim_num_vf,
	312	};
	313
e05b2d14 JP	314	static struct nsim_bus_dev *
e05b2d14 JP	315	nsim_bus_dev_new(unsigned int id, unsigned int port_count)
40e4fe4c JP	316	{
	317	struct nsim_bus_dev *nsim_bus_dev;
	318	int err;
	319
	320	nsim_bus_dev = kzalloc(sizeof(*nsim_bus_dev), GFP_KERNEL);
	321	if (!nsim_bus_dev)
	322	return ERR_PTR(-ENOMEM);
	323
e05b2d14	324	err = ida_alloc_range(&nsim_bus_dev_ids, id, id, GFP_KERNEL);
57ce9774 JP	325	if (err < 0)
	326	goto err_nsim_bus_dev_free;
	327	nsim_bus_dev->dev.id = err;
40e4fe4c JP	328	nsim_bus_dev->dev.bus = &nsim_bus;
40e4fe4c JP	329	nsim_bus_dev->dev.type = &nsim_bus_dev_type;
f9d9db47	330	nsim_bus_dev->port_count = port_count;
7b60027b	331	nsim_bus_dev->initial_net = current->nsproxy->net_ns;
6ab63366	332	mutex_init(&nsim_bus_dev->nsim_bus_reload_lock);
f5cd2160 TY	333	/* Disallow using nsim_bus_dev */
f5cd2160 TY	334	smp_store_release(&nsim_bus_dev->init, false);
f9d9db47	335
40e4fe4c JP	336	err = device_register(&nsim_bus_dev->dev);
40e4fe4c JP	337	if (err)
57ce9774	338	goto err_nsim_bus_dev_id_free;
40e4fe4c JP	339	return nsim_bus_dev;
40e4fe4c JP	340
57ce9774 JP	341	err_nsim_bus_dev_id_free:
57ce9774 JP	342	ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
40e4fe4c JP	343	err_nsim_bus_dev_free:
	344	kfree(nsim_bus_dev);
	345	return ERR_PTR(err);
	346	}
	347
e05b2d14	348	static void nsim_bus_dev_del(struct nsim_bus_dev *nsim_bus_dev)
40e4fe4c	349	{
f5cd2160 TY	350	/* Disallow using nsim_bus_dev */
f5cd2160 TY	351	smp_store_release(&nsim_bus_dev->init, false);
40e4fe4c	352	device_unregister(&nsim_bus_dev->dev);
57ce9774	353	ida_free(&nsim_bus_dev_ids, nsim_bus_dev->dev.id);
40e4fe4c JP	354	kfree(nsim_bus_dev);
	355	}
	356
23d415da JP	357	static struct device_driver nsim_driver = {
	358	.name = DRV_NAME,
	359	.bus = &nsim_bus,
	360	.owner = THIS_MODULE,
	361	};
	362
925f5afe JP	363	int nsim_bus_init(void)
925f5afe JP	364	{
23d415da JP	365	int err;
	366
	367	err = bus_register(&nsim_bus);
	368	if (err)
	369	return err;
	370	err = driver_register(&nsim_driver);
	371	if (err)
	372	goto err_bus_unregister;
f5cd2160 TY	373	/* Allow using resources */
f5cd2160 TY	374	smp_store_release(&nsim_bus_enable, true);
23d415da JP	375	return 0;
	376
	377	err_bus_unregister:
	378	bus_unregister(&nsim_bus);
	379	return err;
925f5afe JP	380	}
	381
	382	void nsim_bus_exit(void)
	383	{
f9d9db47 JP	384	struct nsim_bus_dev nsim_bus_dev, tmp;
f9d9db47 JP	385
f5cd2160 TY	386	/* Disallow using resources */
	387	smp_store_release(&nsim_bus_enable, false);
	388
f9d9db47 JP	389	mutex_lock(&nsim_bus_dev_list_lock);
	390	list_for_each_entry_safe(nsim_bus_dev, tmp, &nsim_bus_dev_list, list) {
	391	list_del(&nsim_bus_dev->list);
	392	nsim_bus_dev_del(nsim_bus_dev);
	393	}
	394	mutex_unlock(&nsim_bus_dev_list_lock);
f5cd2160	395
23d415da	396	driver_unregister(&nsim_driver);
925f5afe JP	397	bus_unregister(&nsim_bus);
925f5afe JP	398	}