Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * class.c - basic device class management
4 : : *
5 : : * Copyright (c) 2002-3 Patrick Mochel
6 : : * Copyright (c) 2002-3 Open Source Development Labs
7 : : * Copyright (c) 2003-2004 Greg Kroah-Hartman
8 : : * Copyright (c) 2003-2004 IBM Corp.
9 : : */
10 : :
11 : : #include <linux/device.h>
12 : : #include <linux/module.h>
13 : : #include <linux/init.h>
14 : : #include <linux/string.h>
15 : : #include <linux/kdev_t.h>
16 : : #include <linux/err.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/genhd.h>
19 : : #include <linux/mutex.h>
20 : : #include "base.h"
21 : :
22 : : #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
23 : :
24 : 0 : static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
25 : : char *buf)
26 : : {
27 : : struct class_attribute *class_attr = to_class_attr(attr);
28 : : struct subsys_private *cp = to_subsys_private(kobj);
29 : : ssize_t ret = -EIO;
30 : :
31 : 0 : if (class_attr->show)
32 : 0 : ret = class_attr->show(cp->class, class_attr, buf);
33 : 0 : return ret;
34 : : }
35 : :
36 : 0 : static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
37 : : const char *buf, size_t count)
38 : : {
39 : : struct class_attribute *class_attr = to_class_attr(attr);
40 : : struct subsys_private *cp = to_subsys_private(kobj);
41 : : ssize_t ret = -EIO;
42 : :
43 : 0 : if (class_attr->store)
44 : 0 : ret = class_attr->store(cp->class, class_attr, buf, count);
45 : 0 : return ret;
46 : : }
47 : :
48 : 0 : static void class_release(struct kobject *kobj)
49 : : {
50 : 0 : struct subsys_private *cp = to_subsys_private(kobj);
51 : 0 : struct class *class = cp->class;
52 : :
53 : : pr_debug("class '%s': release.\n", class->name);
54 : :
55 : 0 : if (class->class_release)
56 : 0 : class->class_release(class);
57 : : else
58 : : pr_debug("class '%s' does not have a release() function, "
59 : : "be careful\n", class->name);
60 : :
61 : 0 : kfree(cp);
62 : 0 : }
63 : :
64 : 3 : static const struct kobj_ns_type_operations *class_child_ns_type(struct kobject *kobj)
65 : : {
66 : : struct subsys_private *cp = to_subsys_private(kobj);
67 : 3 : struct class *class = cp->class;
68 : :
69 : 3 : return class->ns_type;
70 : : }
71 : :
72 : : static const struct sysfs_ops class_sysfs_ops = {
73 : : .show = class_attr_show,
74 : : .store = class_attr_store,
75 : : };
76 : :
77 : : static struct kobj_type class_ktype = {
78 : : .sysfs_ops = &class_sysfs_ops,
79 : : .release = class_release,
80 : : .child_ns_type = class_child_ns_type,
81 : : };
82 : :
83 : : /* Hotplug events for classes go to the class subsys */
84 : : static struct kset *class_kset;
85 : :
86 : :
87 : 0 : int class_create_file_ns(struct class *cls, const struct class_attribute *attr,
88 : : const void *ns)
89 : : {
90 : : int error;
91 : :
92 : 0 : if (cls)
93 : 0 : error = sysfs_create_file_ns(&cls->p->subsys.kobj,
94 : : &attr->attr, ns);
95 : : else
96 : : error = -EINVAL;
97 : 0 : return error;
98 : : }
99 : :
100 : 0 : void class_remove_file_ns(struct class *cls, const struct class_attribute *attr,
101 : : const void *ns)
102 : : {
103 : 0 : if (cls)
104 : 0 : sysfs_remove_file_ns(&cls->p->subsys.kobj, &attr->attr, ns);
105 : 0 : }
106 : :
107 : : static struct class *class_get(struct class *cls)
108 : : {
109 : 3 : if (cls)
110 : 3 : kset_get(&cls->p->subsys);
111 : : return cls;
112 : : }
113 : :
114 : : static void class_put(struct class *cls)
115 : : {
116 : 3 : if (cls)
117 : 3 : kset_put(&cls->p->subsys);
118 : : }
119 : :
120 : : static struct device *klist_class_to_dev(struct klist_node *n)
121 : : {
122 : : struct device_private *p = to_device_private_class(n);
123 : 3 : return p->device;
124 : : }
125 : :
126 : 3 : static void klist_class_dev_get(struct klist_node *n)
127 : : {
128 : : struct device *dev = klist_class_to_dev(n);
129 : :
130 : 3 : get_device(dev);
131 : 3 : }
132 : :
133 : 1 : static void klist_class_dev_put(struct klist_node *n)
134 : : {
135 : : struct device *dev = klist_class_to_dev(n);
136 : :
137 : 1 : put_device(dev);
138 : 1 : }
139 : :
140 : : static int class_add_groups(struct class *cls,
141 : : const struct attribute_group **groups)
142 : : {
143 : 3 : return sysfs_create_groups(&cls->p->subsys.kobj, groups);
144 : : }
145 : :
146 : : static void class_remove_groups(struct class *cls,
147 : : const struct attribute_group **groups)
148 : : {
149 : 0 : return sysfs_remove_groups(&cls->p->subsys.kobj, groups);
150 : : }
151 : :
152 : 3 : int __class_register(struct class *cls, struct lock_class_key *key)
153 : : {
154 : : struct subsys_private *cp;
155 : : int error;
156 : :
157 : : pr_debug("device class '%s': registering\n", cls->name);
158 : :
159 : 3 : cp = kzalloc(sizeof(*cp), GFP_KERNEL);
160 : 3 : if (!cp)
161 : : return -ENOMEM;
162 : 3 : klist_init(&cp->klist_devices, klist_class_dev_get, klist_class_dev_put);
163 : 3 : INIT_LIST_HEAD(&cp->interfaces);
164 : 3 : kset_init(&cp->glue_dirs);
165 : 3 : __mutex_init(&cp->mutex, "subsys mutex", key);
166 : 3 : error = kobject_set_name(&cp->subsys.kobj, "%s", cls->name);
167 : 3 : if (error) {
168 : 0 : kfree(cp);
169 : 0 : return error;
170 : : }
171 : :
172 : : /* set the default /sys/dev directory for devices of this class */
173 : 3 : if (!cls->dev_kobj)
174 : 3 : cls->dev_kobj = sysfs_dev_char_kobj;
175 : :
176 : : #if defined(CONFIG_BLOCK)
177 : : /* let the block class directory show up in the root of sysfs */
178 : : if (!sysfs_deprecated || cls != &block_class)
179 : 3 : cp->subsys.kobj.kset = class_kset;
180 : : #else
181 : : cp->subsys.kobj.kset = class_kset;
182 : : #endif
183 : 3 : cp->subsys.kobj.ktype = &class_ktype;
184 : 3 : cp->class = cls;
185 : 3 : cls->p = cp;
186 : :
187 : 3 : error = kset_register(&cp->subsys);
188 : 3 : if (error) {
189 : 0 : kfree(cp);
190 : 0 : return error;
191 : : }
192 : 3 : error = class_add_groups(class_get(cls), cls->class_groups);
193 : : class_put(cls);
194 : 3 : return error;
195 : : }
196 : : EXPORT_SYMBOL_GPL(__class_register);
197 : :
198 : 0 : void class_unregister(struct class *cls)
199 : : {
200 : : pr_debug("device class '%s': unregistering\n", cls->name);
201 : 0 : class_remove_groups(cls, cls->class_groups);
202 : 0 : kset_unregister(&cls->p->subsys);
203 : 0 : }
204 : :
205 : 0 : static void class_create_release(struct class *cls)
206 : : {
207 : : pr_debug("%s called for %s\n", __func__, cls->name);
208 : 0 : kfree(cls);
209 : 0 : }
210 : :
211 : : /**
212 : : * class_create - create a struct class structure
213 : : * @owner: pointer to the module that is to "own" this struct class
214 : : * @name: pointer to a string for the name of this class.
215 : : * @key: the lock_class_key for this class; used by mutex lock debugging
216 : : *
217 : : * This is used to create a struct class pointer that can then be used
218 : : * in calls to device_create().
219 : : *
220 : : * Returns &struct class pointer on success, or ERR_PTR() on error.
221 : : *
222 : : * Note, the pointer created here is to be destroyed when finished by
223 : : * making a call to class_destroy().
224 : : */
225 : 3 : struct class *__class_create(struct module *owner, const char *name,
226 : : struct lock_class_key *key)
227 : : {
228 : : struct class *cls;
229 : : int retval;
230 : :
231 : 3 : cls = kzalloc(sizeof(*cls), GFP_KERNEL);
232 : 3 : if (!cls) {
233 : : retval = -ENOMEM;
234 : : goto error;
235 : : }
236 : :
237 : 3 : cls->name = name;
238 : 3 : cls->owner = owner;
239 : 3 : cls->class_release = class_create_release;
240 : :
241 : 3 : retval = __class_register(cls, key);
242 : 3 : if (retval)
243 : : goto error;
244 : :
245 : : return cls;
246 : :
247 : : error:
248 : 0 : kfree(cls);
249 : 0 : return ERR_PTR(retval);
250 : : }
251 : : EXPORT_SYMBOL_GPL(__class_create);
252 : :
253 : : /**
254 : : * class_destroy - destroys a struct class structure
255 : : * @cls: pointer to the struct class that is to be destroyed
256 : : *
257 : : * Note, the pointer to be destroyed must have been created with a call
258 : : * to class_create().
259 : : */
260 : 0 : void class_destroy(struct class *cls)
261 : : {
262 : 0 : if ((cls == NULL) || (IS_ERR(cls)))
263 : 0 : return;
264 : :
265 : 0 : class_unregister(cls);
266 : : }
267 : :
268 : : /**
269 : : * class_dev_iter_init - initialize class device iterator
270 : : * @iter: class iterator to initialize
271 : : * @class: the class we wanna iterate over
272 : : * @start: the device to start iterating from, if any
273 : : * @type: device_type of the devices to iterate over, NULL for all
274 : : *
275 : : * Initialize class iterator @iter such that it iterates over devices
276 : : * of @class. If @start is set, the list iteration will start there,
277 : : * otherwise if it is NULL, the iteration starts at the beginning of
278 : : * the list.
279 : : */
280 : 3 : void class_dev_iter_init(struct class_dev_iter *iter, struct class *class,
281 : : struct device *start, const struct device_type *type)
282 : : {
283 : : struct klist_node *start_knode = NULL;
284 : :
285 : 3 : if (start)
286 : 0 : start_knode = &start->p->knode_class;
287 : 3 : klist_iter_init_node(&class->p->klist_devices, &iter->ki, start_knode);
288 : 3 : iter->type = type;
289 : 3 : }
290 : : EXPORT_SYMBOL_GPL(class_dev_iter_init);
291 : :
292 : : /**
293 : : * class_dev_iter_next - iterate to the next device
294 : : * @iter: class iterator to proceed
295 : : *
296 : : * Proceed @iter to the next device and return it. Returns NULL if
297 : : * iteration is complete.
298 : : *
299 : : * The returned device is referenced and won't be released till
300 : : * iterator is proceed to the next device or exited. The caller is
301 : : * free to do whatever it wants to do with the device including
302 : : * calling back into class code.
303 : : */
304 : 3 : struct device *class_dev_iter_next(struct class_dev_iter *iter)
305 : : {
306 : : struct klist_node *knode;
307 : : struct device *dev;
308 : :
309 : : while (1) {
310 : 3 : knode = klist_next(&iter->ki);
311 : 3 : if (!knode)
312 : : return NULL;
313 : : dev = klist_class_to_dev(knode);
314 : 3 : if (!iter->type || iter->type == dev->type)
315 : 3 : return dev;
316 : : }
317 : : }
318 : : EXPORT_SYMBOL_GPL(class_dev_iter_next);
319 : :
320 : : /**
321 : : * class_dev_iter_exit - finish iteration
322 : : * @iter: class iterator to finish
323 : : *
324 : : * Finish an iteration. Always call this function after iteration is
325 : : * complete whether the iteration ran till the end or not.
326 : : */
327 : 3 : void class_dev_iter_exit(struct class_dev_iter *iter)
328 : : {
329 : 3 : klist_iter_exit(&iter->ki);
330 : 3 : }
331 : : EXPORT_SYMBOL_GPL(class_dev_iter_exit);
332 : :
333 : : /**
334 : : * class_for_each_device - device iterator
335 : : * @class: the class we're iterating
336 : : * @start: the device to start with in the list, if any.
337 : : * @data: data for the callback
338 : : * @fn: function to be called for each device
339 : : *
340 : : * Iterate over @class's list of devices, and call @fn for each,
341 : : * passing it @data. If @start is set, the list iteration will start
342 : : * there, otherwise if it is NULL, the iteration starts at the
343 : : * beginning of the list.
344 : : *
345 : : * We check the return of @fn each time. If it returns anything
346 : : * other than 0, we break out and return that value.
347 : : *
348 : : * @fn is allowed to do anything including calling back into class
349 : : * code. There's no locking restriction.
350 : : */
351 : 3 : int class_for_each_device(struct class *class, struct device *start,
352 : : void *data, int (*fn)(struct device *, void *))
353 : : {
354 : : struct class_dev_iter iter;
355 : : struct device *dev;
356 : : int error = 0;
357 : :
358 : 3 : if (!class)
359 : : return -EINVAL;
360 : 3 : if (!class->p) {
361 : 0 : WARN(1, "%s called for class '%s' before it was initialized",
362 : : __func__, class->name);
363 : 0 : return -EINVAL;
364 : : }
365 : :
366 : : class_dev_iter_init(&iter, class, start, NULL);
367 : 3 : while ((dev = class_dev_iter_next(&iter))) {
368 : 3 : error = fn(dev, data);
369 : 3 : if (error)
370 : : break;
371 : : }
372 : : class_dev_iter_exit(&iter);
373 : :
374 : 3 : return error;
375 : : }
376 : : EXPORT_SYMBOL_GPL(class_for_each_device);
377 : :
378 : : /**
379 : : * class_find_device - device iterator for locating a particular device
380 : : * @class: the class we're iterating
381 : : * @start: Device to begin with
382 : : * @data: data for the match function
383 : : * @match: function to check device
384 : : *
385 : : * This is similar to the class_for_each_dev() function above, but it
386 : : * returns a reference to a device that is 'found' for later use, as
387 : : * determined by the @match callback.
388 : : *
389 : : * The callback should return 0 if the device doesn't match and non-zero
390 : : * if it does. If the callback returns non-zero, this function will
391 : : * return to the caller and not iterate over any more devices.
392 : : *
393 : : * Note, you will need to drop the reference with put_device() after use.
394 : : *
395 : : * @match is allowed to do anything including calling back into class
396 : : * code. There's no locking restriction.
397 : : */
398 : 3 : struct device *class_find_device(struct class *class, struct device *start,
399 : : const void *data,
400 : : int (*match)(struct device *, const void *))
401 : : {
402 : : struct class_dev_iter iter;
403 : : struct device *dev;
404 : :
405 : 3 : if (!class)
406 : : return NULL;
407 : 3 : if (!class->p) {
408 : 0 : WARN(1, "%s called for class '%s' before it was initialized",
409 : : __func__, class->name);
410 : 0 : return NULL;
411 : : }
412 : :
413 : : class_dev_iter_init(&iter, class, start, NULL);
414 : 3 : while ((dev = class_dev_iter_next(&iter))) {
415 : 3 : if (match(dev, data)) {
416 : 3 : get_device(dev);
417 : 3 : break;
418 : : }
419 : : }
420 : : class_dev_iter_exit(&iter);
421 : :
422 : 3 : return dev;
423 : : }
424 : : EXPORT_SYMBOL_GPL(class_find_device);
425 : :
426 : 3 : int class_interface_register(struct class_interface *class_intf)
427 : : {
428 : : struct class *parent;
429 : : struct class_dev_iter iter;
430 : : struct device *dev;
431 : :
432 : 3 : if (!class_intf || !class_intf->class)
433 : : return -ENODEV;
434 : :
435 : : parent = class_get(class_intf->class);
436 : 3 : if (!parent)
437 : : return -EINVAL;
438 : :
439 : 3 : mutex_lock(&parent->p->mutex);
440 : 3 : list_add_tail(&class_intf->node, &parent->p->interfaces);
441 : 3 : if (class_intf->add_dev) {
442 : : class_dev_iter_init(&iter, parent, NULL, NULL);
443 : 3 : while ((dev = class_dev_iter_next(&iter)))
444 : 0 : class_intf->add_dev(dev, class_intf);
445 : : class_dev_iter_exit(&iter);
446 : : }
447 : 3 : mutex_unlock(&parent->p->mutex);
448 : :
449 : 3 : return 0;
450 : : }
451 : :
452 : 0 : void class_interface_unregister(struct class_interface *class_intf)
453 : : {
454 : 0 : struct class *parent = class_intf->class;
455 : : struct class_dev_iter iter;
456 : : struct device *dev;
457 : :
458 : 0 : if (!parent)
459 : 0 : return;
460 : :
461 : 0 : mutex_lock(&parent->p->mutex);
462 : 0 : list_del_init(&class_intf->node);
463 : 0 : if (class_intf->remove_dev) {
464 : : class_dev_iter_init(&iter, parent, NULL, NULL);
465 : 0 : while ((dev = class_dev_iter_next(&iter)))
466 : 0 : class_intf->remove_dev(dev, class_intf);
467 : : class_dev_iter_exit(&iter);
468 : : }
469 : 0 : mutex_unlock(&parent->p->mutex);
470 : :
471 : : class_put(parent);
472 : : }
473 : :
474 : 0 : ssize_t show_class_attr_string(struct class *class,
475 : : struct class_attribute *attr, char *buf)
476 : : {
477 : : struct class_attribute_string *cs;
478 : :
479 : : cs = container_of(attr, struct class_attribute_string, attr);
480 : 0 : return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);
481 : : }
482 : :
483 : : EXPORT_SYMBOL_GPL(show_class_attr_string);
484 : :
485 : : struct class_compat {
486 : : struct kobject *kobj;
487 : : };
488 : :
489 : : /**
490 : : * class_compat_register - register a compatibility class
491 : : * @name: the name of the class
492 : : *
493 : : * Compatibility class are meant as a temporary user-space compatibility
494 : : * workaround when converting a family of class devices to a bus devices.
495 : : */
496 : 3 : struct class_compat *class_compat_register(const char *name)
497 : : {
498 : : struct class_compat *cls;
499 : :
500 : : cls = kmalloc(sizeof(struct class_compat), GFP_KERNEL);
501 : 3 : if (!cls)
502 : : return NULL;
503 : 3 : cls->kobj = kobject_create_and_add(name, &class_kset->kobj);
504 : 3 : if (!cls->kobj) {
505 : 0 : kfree(cls);
506 : 0 : return NULL;
507 : : }
508 : : return cls;
509 : : }
510 : : EXPORT_SYMBOL_GPL(class_compat_register);
511 : :
512 : : /**
513 : : * class_compat_unregister - unregister a compatibility class
514 : : * @cls: the class to unregister
515 : : */
516 : 0 : void class_compat_unregister(struct class_compat *cls)
517 : : {
518 : 0 : kobject_put(cls->kobj);
519 : 0 : kfree(cls);
520 : 0 : }
521 : : EXPORT_SYMBOL_GPL(class_compat_unregister);
522 : :
523 : : /**
524 : : * class_compat_create_link - create a compatibility class device link to
525 : : * a bus device
526 : : * @cls: the compatibility class
527 : : * @dev: the target bus device
528 : : * @device_link: an optional device to which a "device" link should be created
529 : : */
530 : 0 : int class_compat_create_link(struct class_compat *cls, struct device *dev,
531 : : struct device *device_link)
532 : : {
533 : : int error;
534 : :
535 : 0 : error = sysfs_create_link(cls->kobj, &dev->kobj, dev_name(dev));
536 : 0 : if (error)
537 : : return error;
538 : :
539 : : /*
540 : : * Optionally add a "device" link (typically to the parent), as a
541 : : * class device would have one and we want to provide as much
542 : : * backwards compatibility as possible.
543 : : */
544 : 0 : if (device_link) {
545 : 0 : error = sysfs_create_link(&dev->kobj, &device_link->kobj,
546 : : "device");
547 : 0 : if (error)
548 : 0 : sysfs_remove_link(cls->kobj, dev_name(dev));
549 : : }
550 : :
551 : 0 : return error;
552 : : }
553 : : EXPORT_SYMBOL_GPL(class_compat_create_link);
554 : :
555 : : /**
556 : : * class_compat_remove_link - remove a compatibility class device link to
557 : : * a bus device
558 : : * @cls: the compatibility class
559 : : * @dev: the target bus device
560 : : * @device_link: an optional device to which a "device" link was previously
561 : : * created
562 : : */
563 : 0 : void class_compat_remove_link(struct class_compat *cls, struct device *dev,
564 : : struct device *device_link)
565 : : {
566 : 0 : if (device_link)
567 : 0 : sysfs_remove_link(&dev->kobj, "device");
568 : 0 : sysfs_remove_link(cls->kobj, dev_name(dev));
569 : 0 : }
570 : : EXPORT_SYMBOL_GPL(class_compat_remove_link);
571 : :
572 : 3 : int __init classes_init(void)
573 : : {
574 : 3 : class_kset = kset_create_and_add("class", NULL, NULL);
575 : 3 : if (!class_kset)
576 : : return -ENOMEM;
577 : 3 : return 0;
578 : : }
579 : :
580 : : EXPORT_SYMBOL_GPL(class_create_file_ns);
581 : : EXPORT_SYMBOL_GPL(class_remove_file_ns);
582 : : EXPORT_SYMBOL_GPL(class_unregister);
583 : : EXPORT_SYMBOL_GPL(class_destroy);
584 : :
585 : : EXPORT_SYMBOL_GPL(class_interface_register);
586 : : EXPORT_SYMBOL_GPL(class_interface_unregister);
|
