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