Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
class.c
Go to the documentation of this file.
1 /*
2  * class.c - basic device class management
3  *
4  * Copyright (c) 2002-3 Patrick Mochel
5  * Copyright (c) 2002-3 Open Source Development Labs
6  * Copyright (c) 2003-2004 Greg Kroah-Hartman
7  * Copyright (c) 2003-2004 IBM Corp.
8  *
9  * This file is released under the GPLv2
10  *
11  */
12 
13 #include <linux/device.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/string.h>
17 #include <linux/kdev_t.h>
18 #include <linux/err.h>
19 #include <linux/slab.h>
20 #include <linux/genhd.h>
21 #include <linux/mutex.h>
22 #include "base.h"
23 
24 #define to_class_attr(_attr) container_of(_attr, struct class_attribute, attr)
25 
26 static ssize_t class_attr_show(struct kobject *kobj, struct attribute *attr,
27  char *buf)
28 {
29  struct class_attribute *class_attr = to_class_attr(attr);
30  struct subsys_private *cp = to_subsys_private(kobj);
31  ssize_t ret = -EIO;
32 
33  if (class_attr->show)
34  ret = class_attr->show(cp->class, class_attr, buf);
35  return ret;
36 }
37 
38 static ssize_t class_attr_store(struct kobject *kobj, struct attribute *attr,
39  const char *buf, size_t count)
40 {
41  struct class_attribute *class_attr = to_class_attr(attr);
42  struct subsys_private *cp = to_subsys_private(kobj);
43  ssize_t ret = -EIO;
44 
45  if (class_attr->store)
46  ret = class_attr->store(cp->class, class_attr, buf, count);
47  return ret;
48 }
49 
50 static const void *class_attr_namespace(struct kobject *kobj,
51  const struct attribute *attr)
52 {
53  struct class_attribute *class_attr = to_class_attr(attr);
54  struct subsys_private *cp = to_subsys_private(kobj);
55  const void *ns = NULL;
56 
57  if (class_attr->namespace)
58  ns = class_attr->namespace(cp->class, class_attr);
59  return ns;
60 }
61 
62 static void class_release(struct kobject *kobj)
63 {
64  struct subsys_private *cp = to_subsys_private(kobj);
65  struct class *class = cp->class;
66 
67  pr_debug("class '%s': release.\n", class->name);
68 
69  if (class->class_release)
70  class->class_release(class);
71  else
72  pr_debug("class '%s' does not have a release() function, "
73  "be careful\n", class->name);
74 
75  kfree(cp);
76 }
77 
78 static const struct kobj_ns_type_operations *class_child_ns_type(struct kobject *kobj)
79 {
80  struct subsys_private *cp = to_subsys_private(kobj);
81  struct class *class = cp->class;
82 
83  return class->ns_type;
84 }
85 
86 static const struct sysfs_ops class_sysfs_ops = {
87  .show = class_attr_show,
88  .store = class_attr_store,
89  .namespace = class_attr_namespace,
90 };
91 
92 static struct kobj_type class_ktype = {
93  .sysfs_ops = &class_sysfs_ops,
94  .release = class_release,
95  .child_ns_type = class_child_ns_type,
96 };
97 
98 /* Hotplug events for classes go to the class subsys */
99 static struct kset *class_kset;
100 
101 
102 int class_create_file(struct class *cls, const struct class_attribute *attr)
103 {
104  int error;
105  if (cls)
106  error = sysfs_create_file(&cls->p->subsys.kobj,
107  &attr->attr);
108  else
109  error = -EINVAL;
110  return error;
111 }
112 
113 void class_remove_file(struct class *cls, const struct class_attribute *attr)
114 {
115  if (cls)
116  sysfs_remove_file(&cls->p->subsys.kobj, &attr->attr);
117 }
118 
119 static struct class *class_get(struct class *cls)
120 {
121  if (cls)
122  kset_get(&cls->p->subsys);
123  return cls;
124 }
125 
126 static void class_put(struct class *cls)
127 {
128  if (cls)
129  kset_put(&cls->p->subsys);
130 }
131 
132 static int add_class_attrs(struct class *cls)
133 {
134  int i;
135  int error = 0;
136 
137  if (cls->class_attrs) {
138  for (i = 0; attr_name(cls->class_attrs[i]); i++) {
139  error = class_create_file(cls, &cls->class_attrs[i]);
140  if (error)
141  goto error;
142  }
143  }
144 done:
145  return error;
146 error:
147  while (--i >= 0)
148  class_remove_file(cls, &cls->class_attrs[i]);
149  goto done;
150 }
151 
152 static void remove_class_attrs(struct class *cls)
153 {
154  int i;
155 
156  if (cls->class_attrs) {
157  for (i = 0; attr_name(cls->class_attrs[i]); i++)
158  class_remove_file(cls, &cls->class_attrs[i]);
159  }
160 }
161 
162 static void klist_class_dev_get(struct klist_node *n)
163 {
164  struct device *dev = container_of(n, struct device, knode_class);
165 
166  get_device(dev);
167 }
168 
169 static void klist_class_dev_put(struct klist_node *n)
170 {
171  struct device *dev = container_of(n, struct device, knode_class);
172 
173  put_device(dev);
174 }
175 
176 int __class_register(struct class *cls, struct lock_class_key *key)
177 {
178  struct subsys_private *cp;
179  int error;
180 
181  pr_debug("device class '%s': registering\n", cls->name);
182 
183  cp = kzalloc(sizeof(*cp), GFP_KERNEL);
184  if (!cp)
185  return -ENOMEM;
186  klist_init(&cp->klist_devices, klist_class_dev_get, klist_class_dev_put);
187  INIT_LIST_HEAD(&cp->interfaces);
188  kset_init(&cp->glue_dirs);
189  __mutex_init(&cp->mutex, "subsys mutex", key);
190  error = kobject_set_name(&cp->subsys.kobj, "%s", cls->name);
191  if (error) {
192  kfree(cp);
193  return error;
194  }
195 
196  /* set the default /sys/dev directory for devices of this class */
197  if (!cls->dev_kobj)
198  cls->dev_kobj = sysfs_dev_char_kobj;
199 
200 #if defined(CONFIG_BLOCK)
201  /* let the block class directory show up in the root of sysfs */
202  if (!sysfs_deprecated || cls != &block_class)
203  cp->subsys.kobj.kset = class_kset;
204 #else
205  cp->subsys.kobj.kset = class_kset;
206 #endif
207  cp->subsys.kobj.ktype = &class_ktype;
208  cp->class = cls;
209  cls->p = cp;
210 
211  error = kset_register(&cp->subsys);
212  if (error) {
213  kfree(cp);
214  return error;
215  }
216  error = add_class_attrs(class_get(cls));
217  class_put(cls);
218  return error;
219 }
221 
222 void class_unregister(struct class *cls)
223 {
224  pr_debug("device class '%s': unregistering\n", cls->name);
225  remove_class_attrs(cls);
226  kset_unregister(&cls->p->subsys);
227 }
228 
229 static void class_create_release(struct class *cls)
230 {
231  pr_debug("%s called for %s\n", __func__, cls->name);
232  kfree(cls);
233 }
234 
249 struct class *__class_create(struct module *owner, const char *name,
250  struct lock_class_key *key)
251 {
252  struct class *cls;
253  int retval;
254 
255  cls = kzalloc(sizeof(*cls), GFP_KERNEL);
256  if (!cls) {
257  retval = -ENOMEM;
258  goto error;
259  }
260 
261  cls->name = name;
262  cls->owner = owner;
263  cls->class_release = class_create_release;
264 
265  retval = __class_register(cls, key);
266  if (retval)
267  goto error;
268 
269  return cls;
270 
271 error:
272  kfree(cls);
273  return ERR_PTR(retval);
274 }
276 
284 void class_destroy(struct class *cls)
285 {
286  if ((cls == NULL) || (IS_ERR(cls)))
287  return;
288 
289  class_unregister(cls);
290 }
291 
304 void class_dev_iter_init(struct class_dev_iter *iter, struct class *class,
305  struct device *start, const struct device_type *type)
306 {
307  struct klist_node *start_knode = NULL;
308 
309  if (start)
310  start_knode = &start->knode_class;
311  klist_iter_init_node(&class->p->klist_devices, &iter->ki, start_knode);
312  iter->type = type;
313 }
315 
329 {
330  struct klist_node *knode;
331  struct device *dev;
332 
333  while (1) {
334  knode = klist_next(&iter->ki);
335  if (!knode)
336  return NULL;
337  dev = container_of(knode, struct device, knode_class);
338  if (!iter->type || iter->type == dev->type)
339  return dev;
340  }
341 }
343 
352 {
353  klist_iter_exit(&iter->ki);
354 }
356 
375 int class_for_each_device(struct class *class, struct device *start,
376  void *data, int (*fn)(struct device *, void *))
377 {
378  struct class_dev_iter iter;
379  struct device *dev;
380  int error = 0;
381 
382  if (!class)
383  return -EINVAL;
384  if (!class->p) {
385  WARN(1, "%s called for class '%s' before it was initialized",
386  __func__, class->name);
387  return -EINVAL;
388  }
389 
390  class_dev_iter_init(&iter, class, start, NULL);
391  while ((dev = class_dev_iter_next(&iter))) {
392  error = fn(dev, data);
393  if (error)
394  break;
395  }
396  class_dev_iter_exit(&iter);
397 
398  return error;
399 }
401 
422 struct device *class_find_device(struct class *class, struct device *start,
423  void *data,
424  int (*match)(struct device *, void *))
425 {
426  struct class_dev_iter iter;
427  struct device *dev;
428 
429  if (!class)
430  return NULL;
431  if (!class->p) {
432  WARN(1, "%s called for class '%s' before it was initialized",
433  __func__, class->name);
434  return NULL;
435  }
436 
437  class_dev_iter_init(&iter, class, start, NULL);
438  while ((dev = class_dev_iter_next(&iter))) {
439  if (match(dev, data)) {
440  get_device(dev);
441  break;
442  }
443  }
444  class_dev_iter_exit(&iter);
445 
446  return dev;
447 }
449 
451 {
452  struct class *parent;
453  struct class_dev_iter iter;
454  struct device *dev;
455 
456  if (!class_intf || !class_intf->class)
457  return -ENODEV;
458 
459  parent = class_get(class_intf->class);
460  if (!parent)
461  return -EINVAL;
462 
463  mutex_lock(&parent->p->mutex);
464  list_add_tail(&class_intf->node, &parent->p->interfaces);
465  if (class_intf->add_dev) {
466  class_dev_iter_init(&iter, parent, NULL, NULL);
467  while ((dev = class_dev_iter_next(&iter)))
468  class_intf->add_dev(dev, class_intf);
469  class_dev_iter_exit(&iter);
470  }
471  mutex_unlock(&parent->p->mutex);
472 
473  return 0;
474 }
475 
477 {
478  struct class *parent = class_intf->class;
479  struct class_dev_iter iter;
480  struct device *dev;
481 
482  if (!parent)
483  return;
484 
485  mutex_lock(&parent->p->mutex);
486  list_del_init(&class_intf->node);
487  if (class_intf->remove_dev) {
488  class_dev_iter_init(&iter, parent, NULL, NULL);
489  while ((dev = class_dev_iter_next(&iter)))
490  class_intf->remove_dev(dev, class_intf);
491  class_dev_iter_exit(&iter);
492  }
493  mutex_unlock(&parent->p->mutex);
494 
495  class_put(parent);
496 }
497 
498 ssize_t show_class_attr_string(struct class *class,
499  struct class_attribute *attr, char *buf)
500 {
501  struct class_attribute_string *cs;
502  cs = container_of(attr, struct class_attribute_string, attr);
503  return snprintf(buf, PAGE_SIZE, "%s\n", cs->str);
504 }
505 
507 
508 struct class_compat {
509  struct kobject *kobj;
510 };
511 
520 {
521  struct class_compat *cls;
522 
523  cls = kmalloc(sizeof(struct class_compat), GFP_KERNEL);
524  if (!cls)
525  return NULL;
526  cls->kobj = kobject_create_and_add(name, &class_kset->kobj);
527  if (!cls->kobj) {
528  kfree(cls);
529  return NULL;
530  }
531  return cls;
532 }
534 
540 {
541  kobject_put(cls->kobj);
542  kfree(cls);
543 }
545 
554  struct device *device_link)
555 {
556  int error;
557 
558  error = sysfs_create_link(cls->kobj, &dev->kobj, dev_name(dev));
559  if (error)
560  return error;
561 
562  /*
563  * Optionally add a "device" link (typically to the parent), as a
564  * class device would have one and we want to provide as much
565  * backwards compatibility as possible.
566  */
567  if (device_link) {
568  error = sysfs_create_link(&dev->kobj, &device_link->kobj,
569  "device");
570  if (error)
571  sysfs_remove_link(cls->kobj, dev_name(dev));
572  }
573 
574  return error;
575 }
577 
587  struct device *device_link)
588 {
589  if (device_link)
590  sysfs_remove_link(&dev->kobj, "device");
591  sysfs_remove_link(cls->kobj, dev_name(dev));
592 }
594 
596 {
597  class_kset = kset_create_and_add("class", NULL, NULL);
598  if (!class_kset)
599  return -ENOMEM;
600  return 0;
601 }
602 
607