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 | |
17 | struct 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 | |
31 | static 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 | |
43 | static 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 | |
56 | static const struct sysfs_ops mdev_type_sysfs_ops = { |
57 | .show = mdev_type_attr_show, |
58 | .store = mdev_type_attr_store, |
59 | }; |
60 | |
61 | static 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(s: buf, len: count, GFP_KERNEL); |
73 | if (!str) |
74 | return -ENOMEM; |
75 | |
76 | ret = guid_parse(uuid: str, u: &uuid); |
77 | kfree(objp: str); |
78 | if (ret) |
79 | return ret; |
80 | |
81 | ret = mdev_device_create(kobj: mtype, uuid: &uuid); |
82 | if (ret) |
83 | return ret; |
84 | |
85 | return count; |
86 | } |
87 | static MDEV_TYPE_ATTR_WO(create); |
88 | |
89 | static ssize_t device_api_show(struct mdev_type *mtype, |
90 | struct mdev_type_attribute *attr, char *buf) |
91 | { |
92 | return sysfs_emit(buf, fmt: "%s\n" , mtype->parent->mdev_driver->device_api); |
93 | } |
94 | static MDEV_TYPE_ATTR_RO(device_api); |
95 | |
96 | static ssize_t name_show(struct mdev_type *mtype, |
97 | struct mdev_type_attribute *attr, char *buf) |
98 | { |
99 | return sysfs_emit(buf, fmt: "%s\n" , |
100 | mtype->pretty_name ? mtype->pretty_name : mtype->sysfs_name); |
101 | } |
102 | |
103 | static MDEV_TYPE_ATTR_RO(name); |
104 | |
105 | static 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, fmt: "%u\n" , drv->get_available(mtype)); |
113 | return sysfs_emit(buf, fmt: "%u\n" , |
114 | atomic_read(v: &mtype->parent->available_instances)); |
115 | } |
116 | static MDEV_TYPE_ATTR_RO(available_instances); |
117 | |
118 | static 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 | } |
124 | static MDEV_TYPE_ATTR_RO(description); |
125 | |
126 | static 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 | |
135 | static 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 | |
144 | static struct attribute_group mdev_type_core_group = { |
145 | .attrs = mdev_types_core_attrs, |
146 | .is_visible = mdev_types_core_is_visible, |
147 | }; |
148 | |
149 | static const struct attribute_group *mdev_type_groups[] = { |
150 | &mdev_type_core_group, |
151 | NULL, |
152 | }; |
153 | |
154 | static 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(dev: type->parent->dev); |
161 | } |
162 | |
163 | static 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 | |
169 | static 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(dev: parent->dev); |
177 | |
178 | ret = kobject_init_and_add(kobj: &type->kobj, ktype: &mdev_type_ktype, NULL, |
179 | fmt: "%s-%s" , dev_driver_string(dev: parent->dev), |
180 | type->sysfs_name); |
181 | if (ret) { |
182 | kobject_put(kobj: &type->kobj); |
183 | return ret; |
184 | } |
185 | |
186 | type->devices_kobj = kobject_create_and_add(name: "devices" , parent: &type->kobj); |
187 | if (!type->devices_kobj) { |
188 | ret = -ENOMEM; |
189 | goto attr_devices_failed; |
190 | } |
191 | |
192 | return 0; |
193 | |
194 | attr_devices_failed: |
195 | kobject_del(kobj: &type->kobj); |
196 | kobject_put(kobj: &type->kobj); |
197 | return ret; |
198 | } |
199 | |
200 | static void mdev_type_remove(struct mdev_type *type) |
201 | { |
202 | kobject_put(kobj: type->devices_kobj); |
203 | kobject_del(kobj: &type->kobj); |
204 | kobject_put(kobj: &type->kobj); |
205 | } |
206 | |
207 | /* mdev sysfs functions */ |
208 | void 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(type: parent->types[i]); |
214 | kset_unregister(kset: parent->mdev_types_kset); |
215 | } |
216 | |
217 | int parent_create_sysfs_files(struct mdev_parent *parent) |
218 | { |
219 | int ret, i; |
220 | |
221 | parent->mdev_types_kset = kset_create_and_add(name: "mdev_supported_types" , |
222 | NULL, parent_kobj: &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, type: parent->types[i]); |
228 | if (ret) |
229 | goto out_err; |
230 | } |
231 | return 0; |
232 | |
233 | out_err: |
234 | while (--i >= 0) |
235 | mdev_type_remove(type: parent->types[i]); |
236 | kset_unregister(kset: parent->mdev_types_kset); |
237 | return ret; |
238 | } |
239 | |
240 | static 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(s: buf, base: 0, res: &val) < 0) |
247 | return -EINVAL; |
248 | |
249 | if (val && device_remove_file_self(dev, attr)) { |
250 | int ret; |
251 | |
252 | ret = mdev_device_remove(dev: mdev); |
253 | if (ret) |
254 | return ret; |
255 | } |
256 | |
257 | return count; |
258 | } |
259 | |
260 | static DEVICE_ATTR_WO(remove); |
261 | |
262 | static struct attribute *mdev_device_attrs[] = { |
263 | &dev_attr_remove.attr, |
264 | NULL, |
265 | }; |
266 | |
267 | static const struct attribute_group mdev_device_group = { |
268 | .attrs = mdev_device_attrs, |
269 | }; |
270 | |
271 | const struct attribute_group *mdev_device_groups[] = { |
272 | &mdev_device_group, |
273 | NULL |
274 | }; |
275 | |
276 | int 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(kobj: type->devices_kobj, target: kobj, name: dev_name(dev: &mdev->dev)); |
283 | if (ret) |
284 | return ret; |
285 | |
286 | ret = sysfs_create_link(kobj, target: &type->kobj, name: "mdev_type" ); |
287 | if (ret) |
288 | goto type_link_failed; |
289 | return ret; |
290 | |
291 | type_link_failed: |
292 | sysfs_remove_link(kobj: mdev->type->devices_kobj, name: dev_name(dev: &mdev->dev)); |
293 | return ret; |
294 | } |
295 | |
296 | void mdev_remove_sysfs_files(struct mdev_device *mdev) |
297 | { |
298 | struct kobject *kobj = &mdev->dev.kobj; |
299 | |
300 | sysfs_remove_link(kobj, name: "mdev_type" ); |
301 | sysfs_remove_link(kobj: mdev->type->devices_kobj, name: dev_name(dev: &mdev->dev)); |
302 | } |
303 | |