[mirror_ubuntu-bionic-kernel.git] / drivers / vfio / mdev / mdev_sysfs.c

/*
 * File attributes for Mediated devices
 *
 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
 *     Author: Neo Jia <cjia@nvidia.com>
 *             Kirti Wankhede <kwankhede@nvidia.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/sysfs.h>
#include <linux/ctype.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include <linux/mdev.h>

#include "mdev_private.h"

/* Static functions */

static ssize_t mdev_type_attr_show(struct kobject *kobj,
				     struct attribute *__attr, char *buf)
{
	struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
	struct mdev_type *type = to_mdev_type(kobj);
	ssize_t ret = -EIO;

	if (attr->show)
		ret = attr->show(kobj, type->parent->dev, buf);
	return ret;
}

static ssize_t mdev_type_attr_store(struct kobject *kobj,
				      struct attribute *__attr,
				      const char *buf, size_t count)
{
	struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
	struct mdev_type *type = to_mdev_type(kobj);
	ssize_t ret = -EIO;

	if (attr->store)
		ret = attr->store(&type->kobj, type->parent->dev, buf, count);
	return ret;
}

static const struct sysfs_ops mdev_type_sysfs_ops = {
	.show = mdev_type_attr_show,
	.store = mdev_type_attr_store,
};

static ssize_t create_store(struct kobject *kobj, struct device *dev,
			    const char *buf, size_t count)
{
	char *str;
	uuid_le uuid;
	int ret;

	if ((count < UUID_STRING_LEN) || (count > UUID_STRING_LEN + 1))
		return -EINVAL;

	str = kstrndup(buf, count, GFP_KERNEL);
	if (!str)
		return -ENOMEM;

	ret = uuid_le_to_bin(str, &uuid);
	kfree(str);
	if (ret)
		return ret;

	ret = mdev_device_create(kobj, dev, uuid);
	if (ret)
		return ret;

	return count;
}

MDEV_TYPE_ATTR_WO(create);

static void mdev_type_release(struct kobject *kobj)
{
	struct mdev_type *type = to_mdev_type(kobj);

	pr_debug("Releasing group %s\n", kobj->name);
	kfree(type);
}

static struct kobj_type mdev_type_ktype = {
	.sysfs_ops = &mdev_type_sysfs_ops,
	.release = mdev_type_release,
};

struct mdev_type *add_mdev_supported_type(struct mdev_parent *parent,
					  struct attribute_group *group)
{
	struct mdev_type *type;
	int ret;

	if (!group->name) {
		pr_err("%s: Type name empty!\n", __func__);
		return ERR_PTR(-EINVAL);
	}

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

	type->kobj.kset = parent->mdev_types_kset;

	ret = kobject_init_and_add(&type->kobj, &mdev_type_ktype, NULL,
				   "%s-%s", dev_driver_string(parent->dev),
				   group->name);
	if (ret) {
		kfree(type);
		return ERR_PTR(ret);
	}

	ret = sysfs_create_file(&type->kobj, &mdev_type_attr_create.attr);
	if (ret)
		goto attr_create_failed;

	type->devices_kobj = kobject_create_and_add("devices", &type->kobj);
	if (!type->devices_kobj) {
		ret = -ENOMEM;
		goto attr_devices_failed;
	}

	ret = sysfs_create_files(&type->kobj,
				 (const struct attribute **)group->attrs);
	if (ret) {
		ret = -ENOMEM;
		goto attrs_failed;
	}

	type->group = group;
	type->parent = parent;
	return type;

attrs_failed:
	kobject_put(type->devices_kobj);
attr_devices_failed:
	sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
attr_create_failed:
	kobject_del(&type->kobj);
	kobject_put(&type->kobj);
	return ERR_PTR(ret);
}

static void remove_mdev_supported_type(struct mdev_type *type)
{
	sysfs_remove_files(&type->kobj,
			   (const struct attribute **)type->group->attrs);
	kobject_put(type->devices_kobj);
	sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
	kobject_del(&type->kobj);
	kobject_put(&type->kobj);
}

static int add_mdev_supported_type_groups(struct mdev_parent *parent)
{
	int i;

	for (i = 0; parent->ops->supported_type_groups[i]; i++) {
		struct mdev_type *type;

		type = add_mdev_supported_type(parent,
					parent->ops->supported_type_groups[i]);
		if (IS_ERR(type)) {
			struct mdev_type *ltype, *tmp;

			list_for_each_entry_safe(ltype, tmp, &parent->type_list,
						  next) {
				list_del(&ltype->next);
				remove_mdev_supported_type(ltype);
			}
			return PTR_ERR(type);
		}
		list_add(&type->next, &parent->type_list);
	}
	return 0;
}

/* mdev sysfs functions */
void parent_remove_sysfs_files(struct mdev_parent *parent)
{
	struct mdev_type *type, *tmp;

	list_for_each_entry_safe(type, tmp, &parent->type_list, next) {
		list_del(&type->next);
		remove_mdev_supported_type(type);
	}

	sysfs_remove_groups(&parent->dev->kobj, parent->ops->dev_attr_groups);
	kset_unregister(parent->mdev_types_kset);
}

int parent_create_sysfs_files(struct mdev_parent *parent)
{
	int ret;

	parent->mdev_types_kset = kset_create_and_add("mdev_supported_types",
					       NULL, &parent->dev->kobj);

	if (!parent->mdev_types_kset)
		return -ENOMEM;

	INIT_LIST_HEAD(&parent->type_list);

	ret = sysfs_create_groups(&parent->dev->kobj,
				  parent->ops->dev_attr_groups);
	if (ret)
		goto create_err;

	ret = add_mdev_supported_type_groups(parent);
	if (ret)
		sysfs_remove_groups(&parent->dev->kobj,
				    parent->ops->dev_attr_groups);
	else
		return ret;

create_err:
	kset_unregister(parent->mdev_types_kset);
	return ret;
}

static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	unsigned long val;

	if (kstrtoul(buf, 0, &val) < 0)
		return -EINVAL;

	if (val && device_remove_file_self(dev, attr)) {
		int ret;

		ret = mdev_device_remove(dev, false);
		if (ret) {
			device_create_file(dev, attr);
			return ret;
		}
	}

	return count;
}

static DEVICE_ATTR_WO(remove);

static const struct attribute *mdev_device_attrs[] = {
	&dev_attr_remove.attr,
	NULL,
};

int  mdev_create_sysfs_files(struct device *dev, struct mdev_type *type)
{
	int ret;

	ret = sysfs_create_files(&dev->kobj, mdev_device_attrs);
	if (ret)
		return ret;

	ret = sysfs_create_link(type->devices_kobj, &dev->kobj, dev_name(dev));
	if (ret)
		goto device_link_failed;

	ret = sysfs_create_link(&dev->kobj, &type->kobj, "mdev_type");
	if (ret)
		goto type_link_failed;

	return ret;

type_link_failed:
	sysfs_remove_link(type->devices_kobj, dev_name(dev));
device_link_failed:
	sysfs_remove_files(&dev->kobj, mdev_device_attrs);
	return ret;
}

void mdev_remove_sysfs_files(struct device *dev, struct mdev_type *type)
{
	sysfs_remove_link(&dev->kobj, "mdev_type");
	sysfs_remove_link(type->devices_kobj, dev_name(dev));
	sysfs_remove_files(&dev->kobj, mdev_device_attrs);
}
Commit	Line	Data
7b96953b KW	1	/*
	2	* File attributes for Mediated devices
	3	*
	4	* Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
	5	* Author: Neo Jia <cjia@nvidia.com>
	6	* Kirti Wankhede <kwankhede@nvidia.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License version 2 as
	10	* published by the Free Software Foundation.
	11	*/
	12
	13	#include <linux/sysfs.h>
	14	#include <linux/ctype.h>
	15	#include <linux/device.h>
	16	#include <linux/slab.h>
	17	#include <linux/uuid.h>
	18	#include <linux/mdev.h>
	19
	20	#include "mdev_private.h"
	21
	22	/* Static functions */
	23
	24	static ssize_t mdev_type_attr_show(struct kobject *kobj,
	25	struct attribute __attr, char buf)
	26	{
	27	struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
	28	struct mdev_type *type = to_mdev_type(kobj);
	29	ssize_t ret = -EIO;
	30
	31	if (attr->show)
	32	ret = attr->show(kobj, type->parent->dev, buf);
	33	return ret;
	34	}
	35
	36	static ssize_t mdev_type_attr_store(struct kobject *kobj,
	37	struct attribute *__attr,
	38	const char *buf, size_t count)
	39	{
	40	struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
	41	struct mdev_type *type = to_mdev_type(kobj);
	42	ssize_t ret = -EIO;
	43
	44	if (attr->store)
	45	ret = attr->store(&type->kobj, type->parent->dev, buf, count);
	46	return ret;
	47	}
	48
	49	static const struct sysfs_ops mdev_type_sysfs_ops = {
	50	.show = mdev_type_attr_show,
	51	.store = mdev_type_attr_store,
	52	};
	53
	54	static ssize_t create_store(struct kobject kobj, struct device dev,
	55	const char *buf, size_t count)
	56	{
	57	char *str;
	58	uuid_le uuid;
	59	int ret;
	60
	61	if ((count < UUID_STRING_LEN) \|\| (count > UUID_STRING_LEN + 1))
	62	return -EINVAL;
	63
	64	str = kstrndup(buf, count, GFP_KERNEL);
65	if (!str)
66	return -ENOMEM;
67
68	ret = uuid_le_to_bin(str, &uuid);
69	kfree(str);
70	if (ret)
71	return ret;
72
73	ret = mdev_device_create(kobj, dev, uuid);
74	if (ret)
75	return ret;
76
77	return count;
78	}
79
80	MDEV_TYPE_ATTR_WO(create);
81
82	static void mdev_type_release(struct kobject *kobj)
83	{
84	struct mdev_type *type = to_mdev_type(kobj);
85
86	pr_debug("Releasing group %s\n", kobj->name);
87	kfree(type);
88	}
89
90	static struct kobj_type mdev_type_ktype = {
91	.sysfs_ops = &mdev_type_sysfs_ops,
92	.release = mdev_type_release,
93	};
94
42930553	95	struct mdev_type add_mdev_supported_type(struct mdev_parent parent,
7b96953b KW	96	struct attribute_group *group)
	97	{
	98	struct mdev_type *type;
	99	int ret;
	100
	101	if (!group->name) {
	102	pr_err("%s: Type name empty!\n", __func__);
	103	return ERR_PTR(-EINVAL);
	104	}
	105
	106	type = kzalloc(sizeof(*type), GFP_KERNEL);
	107	if (!type)
	108	return ERR_PTR(-ENOMEM);
	109
	110	type->kobj.kset = parent->mdev_types_kset;
	111
	112	ret = kobject_init_and_add(&type->kobj, &mdev_type_ktype, NULL,
	113	"%s-%s", dev_driver_string(parent->dev),
	114	group->name);
	115	if (ret) {
	116	kfree(type);
	117	return ERR_PTR(ret);
	118	}
	119
	120	ret = sysfs_create_file(&type->kobj, &mdev_type_attr_create.attr);
	121	if (ret)
	122	goto attr_create_failed;
	123
	124	type->devices_kobj = kobject_create_and_add("devices", &type->kobj);
	125	if (!type->devices_kobj) {
	126	ret = -ENOMEM;
	127	goto attr_devices_failed;
	128	}
	129
	130	ret = sysfs_create_files(&type->kobj,
	131	(const struct attribute **)group->attrs);
	132	if (ret) {
	133	ret = -ENOMEM;
	134	goto attrs_failed;
	135	}
	136
	137	type->group = group;
	138	type->parent = parent;
	139	return type;
	140
	141	attrs_failed:
	142	kobject_put(type->devices_kobj);
	143	attr_devices_failed:
	144	sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
	145	attr_create_failed:
	146	kobject_del(&type->kobj);
	147	kobject_put(&type->kobj);
	148	return ERR_PTR(ret);
	149	}
	150
	151	static void remove_mdev_supported_type(struct mdev_type *type)
	152	{
	153	sysfs_remove_files(&type->kobj,
	154	(const struct attribute **)type->group->attrs);
	155	kobject_put(type->devices_kobj);
	156	sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
	157	kobject_del(&type->kobj);
	158	kobject_put(&type->kobj);
	159	}
160
42930553	161	static int add_mdev_supported_type_groups(struct mdev_parent *parent)
7b96953b KW	162	{
	163	int i;
	164
	165	for (i = 0; parent->ops->supported_type_groups[i]; i++) {
	166	struct mdev_type *type;
	167
	168	type = add_mdev_supported_type(parent,
	169	parent->ops->supported_type_groups[i]);
	170	if (IS_ERR(type)) {
	171	struct mdev_type ltype, tmp;
	172
	173	list_for_each_entry_safe(ltype, tmp, &parent->type_list,
	174	next) {
	175	list_del(&ltype->next);
	176	remove_mdev_supported_type(ltype);
	177	}
	178	return PTR_ERR(type);
	179	}
	180	list_add(&type->next, &parent->type_list);
	181	}
	182	return 0;
	183	}
	184
	185	/* mdev sysfs functions */
42930553	186	void parent_remove_sysfs_files(struct mdev_parent *parent)
7b96953b KW	187	{
	188	struct mdev_type type, tmp;
	189
	190	list_for_each_entry_safe(type, tmp, &parent->type_list, next) {
	191	list_del(&type->next);
	192	remove_mdev_supported_type(type);
	193	}
	194
	195	sysfs_remove_groups(&parent->dev->kobj, parent->ops->dev_attr_groups);
	196	kset_unregister(parent->mdev_types_kset);
	197	}
	198
42930553	199	int parent_create_sysfs_files(struct mdev_parent *parent)
7b96953b KW	200	{
	201	int ret;
	202
	203	parent->mdev_types_kset = kset_create_and_add("mdev_supported_types",
	204	NULL, &parent->dev->kobj);
	205
	206	if (!parent->mdev_types_kset)
	207	return -ENOMEM;
	208
	209	INIT_LIST_HEAD(&parent->type_list);
	210
	211	ret = sysfs_create_groups(&parent->dev->kobj,
	212	parent->ops->dev_attr_groups);
	213	if (ret)
	214	goto create_err;
	215
	216	ret = add_mdev_supported_type_groups(parent);
	217	if (ret)
	218	sysfs_remove_groups(&parent->dev->kobj,
	219	parent->ops->dev_attr_groups);
	220	else
	221	return ret;
	222
	223	create_err:
	224	kset_unregister(parent->mdev_types_kset);
	225	return ret;
	226	}
	227
	228	static ssize_t remove_store(struct device dev, struct device_attribute attr,
	229	const char *buf, size_t count)
	230	{
	231	unsigned long val;
	232
	233	if (kstrtoul(buf, 0, &val) < 0)
	234	return -EINVAL;
	235
	236	if (val && device_remove_file_self(dev, attr)) {
	237	int ret;
	238
	239	ret = mdev_device_remove(dev, false);
	240	if (ret) {
	241	device_create_file(dev, attr);
	242	return ret;
	243	}
	244	}
	245
	246	return count;
	247	}
	248
	249	static DEVICE_ATTR_WO(remove);
	250
	251	static const struct attribute *mdev_device_attrs[] = {
	252	&dev_attr_remove.attr,
	253	NULL,
	254	};
	255
	256	int mdev_create_sysfs_files(struct device dev, struct mdev_type type)
	257	{
	258	int ret;
	259
	260	ret = sysfs_create_files(&dev->kobj, mdev_device_attrs);
	261	if (ret)
	262	return ret;
	263
264	ret = sysfs_create_link(type->devices_kobj, &dev->kobj, dev_name(dev));
265	if (ret)
266	goto device_link_failed;
267
268	ret = sysfs_create_link(&dev->kobj, &type->kobj, "mdev_type");
269	if (ret)
270	goto type_link_failed;
271
272	return ret;
273
274	type_link_failed:
275	sysfs_remove_link(type->devices_kobj, dev_name(dev));
276	device_link_failed:
277	sysfs_remove_files(&dev->kobj, mdev_device_attrs);
278	return ret;
279	}
280
281	void mdev_remove_sysfs_files(struct device dev, struct mdev_type type)
282	{
283	sysfs_remove_link(&dev->kobj, "mdev_type");
284	sysfs_remove_link(type->devices_kobj, dev_name(dev));
285	sysfs_remove_files(&dev->kobj, mdev_device_attrs);
286	}