Loading...
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
24static 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
36static 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
49static const struct sysfs_ops mdev_type_sysfs_ops = {
50 .show = mdev_type_attr_show,
51 .store = mdev_type_attr_store,
52};
53
54static 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
80MDEV_TYPE_ATTR_WO(create);
81
82static 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
90static struct kobj_type mdev_type_ktype = {
91 .sysfs_ops = &mdev_type_sysfs_ops,
92 .release = mdev_type_release,
93};
94
95struct mdev_type *add_mdev_supported_type(struct mdev_parent *parent,
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
141attrs_failed:
142 kobject_put(type->devices_kobj);
143attr_devices_failed:
144 sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
145attr_create_failed:
146 kobject_del(&type->kobj);
147 kobject_put(&type->kobj);
148 return ERR_PTR(ret);
149}
150
151static 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
161static int add_mdev_supported_type_groups(struct mdev_parent *parent)
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(<ype->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 */
186void parent_remove_sysfs_files(struct mdev_parent *parent)
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
199int parent_create_sysfs_files(struct mdev_parent *parent)
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
223create_err:
224 kset_unregister(parent->mdev_types_kset);
225 return ret;
226}
227
228static 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
249static DEVICE_ATTR_WO(remove);
250
251static const struct attribute *mdev_device_attrs[] = {
252 &dev_attr_remove.attr,
253 NULL,
254};
255
256int 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
274type_link_failed:
275 sysfs_remove_link(type->devices_kobj, dev_name(dev));
276device_link_failed:
277 sysfs_remove_files(&dev->kobj, mdev_device_attrs);
278 return ret;
279}
280
281void 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}
1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * File attributes for Mediated devices
4 *
5 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
6 * Author: Neo Jia <cjia@nvidia.com>
7 * Kirti Wankhede <kwankhede@nvidia.com>
8 */
9
10#include <linux/sysfs.h>
11#include <linux/ctype.h>
12#include <linux/slab.h>
13#include <linux/mdev.h>
14
15#include "mdev_private.h"
16
17struct mdev_type_attribute {
18 struct attribute attr;
19 ssize_t (*show)(struct mdev_type *mtype,
20 struct mdev_type_attribute *attr, char *buf);
21 ssize_t (*store)(struct mdev_type *mtype,
22 struct mdev_type_attribute *attr, const char *buf,
23 size_t count);
24};
25
26#define MDEV_TYPE_ATTR_RO(_name) \
27 struct mdev_type_attribute mdev_type_attr_##_name = __ATTR_RO(_name)
28#define MDEV_TYPE_ATTR_WO(_name) \
29 struct mdev_type_attribute mdev_type_attr_##_name = __ATTR_WO(_name)
30
31static ssize_t mdev_type_attr_show(struct kobject *kobj,
32 struct attribute *__attr, char *buf)
33{
34 struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
35 struct mdev_type *type = to_mdev_type(kobj);
36 ssize_t ret = -EIO;
37
38 if (attr->show)
39 ret = attr->show(type, attr, buf);
40 return ret;
41}
42
43static ssize_t mdev_type_attr_store(struct kobject *kobj,
44 struct attribute *__attr,
45 const char *buf, size_t count)
46{
47 struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
48 struct mdev_type *type = to_mdev_type(kobj);
49 ssize_t ret = -EIO;
50
51 if (attr->store)
52 ret = attr->store(type, attr, buf, count);
53 return ret;
54}
55
56static const struct sysfs_ops mdev_type_sysfs_ops = {
57 .show = mdev_type_attr_show,
58 .store = mdev_type_attr_store,
59};
60
61static ssize_t create_store(struct mdev_type *mtype,
62 struct mdev_type_attribute *attr, const char *buf,
63 size_t count)
64{
65 char *str;
66 guid_t uuid;
67 int ret;
68
69 if ((count < UUID_STRING_LEN) || (count > UUID_STRING_LEN + 1))
70 return -EINVAL;
71
72 str = kstrndup(buf, count, GFP_KERNEL);
73 if (!str)
74 return -ENOMEM;
75
76 ret = guid_parse(str, &uuid);
77 kfree(str);
78 if (ret)
79 return ret;
80
81 ret = mdev_device_create(mtype, &uuid);
82 if (ret)
83 return ret;
84
85 return count;
86}
87static MDEV_TYPE_ATTR_WO(create);
88
89static ssize_t device_api_show(struct mdev_type *mtype,
90 struct mdev_type_attribute *attr, char *buf)
91{
92 return sysfs_emit(buf, "%s\n", mtype->parent->mdev_driver->device_api);
93}
94static MDEV_TYPE_ATTR_RO(device_api);
95
96static ssize_t name_show(struct mdev_type *mtype,
97 struct mdev_type_attribute *attr, char *buf)
98{
99 return sysfs_emit(buf, "%s\n",
100 mtype->pretty_name ? mtype->pretty_name : mtype->sysfs_name);
101}
102
103static MDEV_TYPE_ATTR_RO(name);
104
105static ssize_t available_instances_show(struct mdev_type *mtype,
106 struct mdev_type_attribute *attr,
107 char *buf)
108{
109 struct mdev_driver *drv = mtype->parent->mdev_driver;
110
111 if (drv->get_available)
112 return sysfs_emit(buf, "%u\n", drv->get_available(mtype));
113 return sysfs_emit(buf, "%u\n",
114 atomic_read(&mtype->parent->available_instances));
115}
116static MDEV_TYPE_ATTR_RO(available_instances);
117
118static ssize_t description_show(struct mdev_type *mtype,
119 struct mdev_type_attribute *attr,
120 char *buf)
121{
122 return mtype->parent->mdev_driver->show_description(mtype, buf);
123}
124static MDEV_TYPE_ATTR_RO(description);
125
126static struct attribute *mdev_types_core_attrs[] = {
127 &mdev_type_attr_create.attr,
128 &mdev_type_attr_device_api.attr,
129 &mdev_type_attr_name.attr,
130 &mdev_type_attr_available_instances.attr,
131 &mdev_type_attr_description.attr,
132 NULL,
133};
134
135static umode_t mdev_types_core_is_visible(struct kobject *kobj,
136 struct attribute *attr, int n)
137{
138 if (attr == &mdev_type_attr_description.attr &&
139 !to_mdev_type(kobj)->parent->mdev_driver->show_description)
140 return 0;
141 return attr->mode;
142}
143
144static struct attribute_group mdev_type_core_group = {
145 .attrs = mdev_types_core_attrs,
146 .is_visible = mdev_types_core_is_visible,
147};
148
149static const struct attribute_group *mdev_type_groups[] = {
150 &mdev_type_core_group,
151 NULL,
152};
153
154static void mdev_type_release(struct kobject *kobj)
155{
156 struct mdev_type *type = to_mdev_type(kobj);
157
158 pr_debug("Releasing group %s\n", kobj->name);
159 /* Pairs with the get in add_mdev_supported_type() */
160 put_device(type->parent->dev);
161}
162
163static const struct kobj_type mdev_type_ktype = {
164 .sysfs_ops = &mdev_type_sysfs_ops,
165 .release = mdev_type_release,
166 .default_groups = mdev_type_groups,
167};
168
169static int mdev_type_add(struct mdev_parent *parent, struct mdev_type *type)
170{
171 int ret;
172
173 type->kobj.kset = parent->mdev_types_kset;
174 type->parent = parent;
175 /* Pairs with the put in mdev_type_release() */
176 get_device(parent->dev);
177
178 ret = kobject_init_and_add(&type->kobj, &mdev_type_ktype, NULL,
179 "%s-%s", dev_driver_string(parent->dev),
180 type->sysfs_name);
181 if (ret) {
182 kobject_put(&type->kobj);
183 return ret;
184 }
185
186 type->devices_kobj = kobject_create_and_add("devices", &type->kobj);
187 if (!type->devices_kobj) {
188 ret = -ENOMEM;
189 goto attr_devices_failed;
190 }
191
192 return 0;
193
194attr_devices_failed:
195 kobject_del(&type->kobj);
196 kobject_put(&type->kobj);
197 return ret;
198}
199
200static void mdev_type_remove(struct mdev_type *type)
201{
202 kobject_put(type->devices_kobj);
203 kobject_del(&type->kobj);
204 kobject_put(&type->kobj);
205}
206
207/* mdev sysfs functions */
208void parent_remove_sysfs_files(struct mdev_parent *parent)
209{
210 int i;
211
212 for (i = 0; i < parent->nr_types; i++)
213 mdev_type_remove(parent->types[i]);
214 kset_unregister(parent->mdev_types_kset);
215}
216
217int parent_create_sysfs_files(struct mdev_parent *parent)
218{
219 int ret, i;
220
221 parent->mdev_types_kset = kset_create_and_add("mdev_supported_types",
222 NULL, &parent->dev->kobj);
223 if (!parent->mdev_types_kset)
224 return -ENOMEM;
225
226 for (i = 0; i < parent->nr_types; i++) {
227 ret = mdev_type_add(parent, parent->types[i]);
228 if (ret)
229 goto out_err;
230 }
231 return 0;
232
233out_err:
234 while (--i >= 0)
235 mdev_type_remove(parent->types[i]);
236 kset_unregister(parent->mdev_types_kset);
237 return ret;
238}
239
240static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
241 const char *buf, size_t count)
242{
243 struct mdev_device *mdev = to_mdev_device(dev);
244 unsigned long val;
245
246 if (kstrtoul(buf, 0, &val) < 0)
247 return -EINVAL;
248
249 if (val && device_remove_file_self(dev, attr)) {
250 int ret;
251
252 ret = mdev_device_remove(mdev);
253 if (ret)
254 return ret;
255 }
256
257 return count;
258}
259
260static DEVICE_ATTR_WO(remove);
261
262static struct attribute *mdev_device_attrs[] = {
263 &dev_attr_remove.attr,
264 NULL,
265};
266
267static const struct attribute_group mdev_device_group = {
268 .attrs = mdev_device_attrs,
269};
270
271const struct attribute_group *mdev_device_groups[] = {
272 &mdev_device_group,
273 NULL
274};
275
276int mdev_create_sysfs_files(struct mdev_device *mdev)
277{
278 struct mdev_type *type = mdev->type;
279 struct kobject *kobj = &mdev->dev.kobj;
280 int ret;
281
282 ret = sysfs_create_link(type->devices_kobj, kobj, dev_name(&mdev->dev));
283 if (ret)
284 return ret;
285
286 ret = sysfs_create_link(kobj, &type->kobj, "mdev_type");
287 if (ret)
288 goto type_link_failed;
289 return ret;
290
291type_link_failed:
292 sysfs_remove_link(mdev->type->devices_kobj, dev_name(&mdev->dev));
293 return ret;
294}
295
296void mdev_remove_sysfs_files(struct mdev_device *mdev)
297{
298 struct kobject *kobj = &mdev->dev.kobj;
299
300 sysfs_remove_link(kobj, "mdev_type");
301 sysfs_remove_link(mdev->type->devices_kobj, dev_name(&mdev->dev));
302}