kobject.h 8.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295
  1. /*
  2. * kobject.h - generic kernel object infrastructure.
  3. *
  4. * Copyright (c) 2002-2003 Patrick Mochel
  5. * Copyright (c) 2002-2003 Open Source Development Labs
  6. *
  7. * This file is released under the GPLv2.
  8. *
  9. *
  10. * Please read Documentation/kobject.txt before using the kobject
  11. * interface, ESPECIALLY the parts about reference counts and object
  12. * destructors.
  13. */
  14. #ifndef _KOBJECT_H_
  15. #define _KOBJECT_H_
  16. #ifdef __KERNEL__
  17. #include <linux/types.h>
  18. #include <linux/list.h>
  19. #include <linux/sysfs.h>
  20. #include <linux/compiler.h>
  21. #include <linux/spinlock.h>
  22. #include <linux/rwsem.h>
  23. #include <linux/kref.h>
  24. #include <linux/kernel.h>
  25. #include <linux/wait.h>
  26. #include <asm/atomic.h>
  27. #define KOBJ_NAME_LEN 20
  28. #define UEVENT_HELPER_PATH_LEN 256
  29. /* path to the userspace helper executed on an event */
  30. extern char uevent_helper[];
  31. /* counter to tag the uevent, read only except for the kobject core */
  32. extern u64 uevent_seqnum;
  33. /* the actions here must match the proper string in lib/kobject_uevent.c */
  34. typedef int __bitwise kobject_action_t;
  35. enum kobject_action {
  36. KOBJ_ADD = (__force kobject_action_t) 0x01, /* exclusive to core */
  37. KOBJ_REMOVE = (__force kobject_action_t) 0x02, /* exclusive to core */
  38. KOBJ_CHANGE = (__force kobject_action_t) 0x03, /* device state change */
  39. KOBJ_MOUNT = (__force kobject_action_t) 0x04, /* mount event for block devices (broken) */
  40. KOBJ_UMOUNT = (__force kobject_action_t) 0x05, /* umount event for block devices (broken) */
  41. KOBJ_OFFLINE = (__force kobject_action_t) 0x06, /* device offline */
  42. KOBJ_ONLINE = (__force kobject_action_t) 0x07, /* device online */
  43. KOBJ_MOVE = (__force kobject_action_t) 0x08, /* device move */
  44. };
  45. struct kobject {
  46. const char * k_name;
  47. char name[KOBJ_NAME_LEN];
  48. struct kref kref;
  49. struct list_head entry;
  50. struct kobject * parent;
  51. struct kset * kset;
  52. struct kobj_type * ktype;
  53. struct dentry * dentry;
  54. wait_queue_head_t poll;
  55. };
  56. extern int kobject_set_name(struct kobject *, const char *, ...)
  57. __attribute__((format(printf,2,3)));
  58. static inline const char * kobject_name(const struct kobject * kobj)
  59. {
  60. return kobj->k_name;
  61. }
  62. extern void kobject_init(struct kobject *);
  63. extern void kobject_cleanup(struct kobject *);
  64. extern int __must_check kobject_add(struct kobject *);
  65. extern int __must_check kobject_shadow_add(struct kobject *, struct dentry *);
  66. extern void kobject_del(struct kobject *);
  67. extern int __must_check kobject_rename(struct kobject *, const char *new_name);
  68. extern int __must_check kobject_shadow_rename(struct kobject *kobj,
  69. struct dentry *new_parent,
  70. const char *new_name);
  71. extern int __must_check kobject_move(struct kobject *, struct kobject *);
  72. extern int __must_check kobject_register(struct kobject *);
  73. extern void kobject_unregister(struct kobject *);
  74. extern struct kobject * kobject_get(struct kobject *);
  75. extern void kobject_put(struct kobject *);
  76. extern struct kobject *kobject_add_dir(struct kobject *, const char *);
  77. extern char * kobject_get_path(struct kobject *, gfp_t);
  78. struct kobj_type {
  79. void (*release)(struct kobject *);
  80. struct sysfs_ops * sysfs_ops;
  81. struct attribute ** default_attrs;
  82. };
  83. /**
  84. * kset - a set of kobjects of a specific type, belonging
  85. * to a specific subsystem.
  86. *
  87. * All kobjects of a kset should be embedded in an identical
  88. * type. This type may have a descriptor, which the kset points
  89. * to. This allows there to exist sets of objects of the same
  90. * type in different subsystems.
  91. *
  92. * A subsystem does not have to be a list of only one type
  93. * of object; multiple ksets can belong to one subsystem. All
  94. * ksets of a subsystem share the subsystem's lock.
  95. *
  96. * Each kset can support specific event variables; it can
  97. * supress the event generation or add subsystem specific
  98. * variables carried with the event.
  99. */
  100. struct kset_uevent_ops {
  101. int (*filter)(struct kset *kset, struct kobject *kobj);
  102. const char *(*name)(struct kset *kset, struct kobject *kobj);
  103. int (*uevent)(struct kset *kset, struct kobject *kobj, char **envp,
  104. int num_envp, char *buffer, int buffer_size);
  105. };
  106. struct kset {
  107. struct subsystem * subsys;
  108. struct kobj_type * ktype;
  109. struct list_head list;
  110. spinlock_t list_lock;
  111. struct kobject kobj;
  112. struct kset_uevent_ops * uevent_ops;
  113. };
  114. extern void kset_init(struct kset * k);
  115. extern int __must_check kset_add(struct kset * k);
  116. extern int __must_check kset_register(struct kset * k);
  117. extern void kset_unregister(struct kset * k);
  118. static inline struct kset * to_kset(struct kobject * kobj)
  119. {
  120. return kobj ? container_of(kobj,struct kset,kobj) : NULL;
  121. }
  122. static inline struct kset * kset_get(struct kset * k)
  123. {
  124. return k ? to_kset(kobject_get(&k->kobj)) : NULL;
  125. }
  126. static inline void kset_put(struct kset * k)
  127. {
  128. kobject_put(&k->kobj);
  129. }
  130. static inline struct kobj_type * get_ktype(struct kobject * k)
  131. {
  132. if (k->kset && k->kset->ktype)
  133. return k->kset->ktype;
  134. else
  135. return k->ktype;
  136. }
  137. extern struct kobject * kset_find_obj(struct kset *, const char *);
  138. /**
  139. * Use this when initializing an embedded kset with no other
  140. * fields to initialize.
  141. */
  142. #define set_kset_name(str) .kset = { .kobj = { .name = str } }
  143. struct subsystem {
  144. struct kset kset;
  145. struct rw_semaphore rwsem;
  146. };
  147. #define decl_subsys(_name,_type,_uevent_ops) \
  148. struct subsystem _name##_subsys = { \
  149. .kset = { \
  150. .kobj = { .name = __stringify(_name) }, \
  151. .ktype = _type, \
  152. .uevent_ops =_uevent_ops, \
  153. } \
  154. }
  155. #define decl_subsys_name(_varname,_name,_type,_uevent_ops) \
  156. struct subsystem _varname##_subsys = { \
  157. .kset = { \
  158. .kobj = { .name = __stringify(_name) }, \
  159. .ktype = _type, \
  160. .uevent_ops =_uevent_ops, \
  161. } \
  162. }
  163. /* The global /sys/kernel/ subsystem for people to chain off of */
  164. extern struct subsystem kernel_subsys;
  165. /* The global /sys/hypervisor/ subsystem */
  166. extern struct subsystem hypervisor_subsys;
  167. /**
  168. * Helpers for setting the kset of registered objects.
  169. * Often, a registered object belongs to a kset embedded in a
  170. * subsystem. These do no magic, just make the resulting code
  171. * easier to follow.
  172. */
  173. /**
  174. * kobj_set_kset_s(obj,subsys) - set kset for embedded kobject.
  175. * @obj: ptr to some object type.
  176. * @subsys: a subsystem object (not a ptr).
  177. *
  178. * Can be used for any object type with an embedded ->kobj.
  179. */
  180. #define kobj_set_kset_s(obj,subsys) \
  181. (obj)->kobj.kset = &(subsys).kset
  182. /**
  183. * kset_set_kset_s(obj,subsys) - set kset for embedded kset.
  184. * @obj: ptr to some object type.
  185. * @subsys: a subsystem object (not a ptr).
  186. *
  187. * Can be used for any object type with an embedded ->kset.
  188. * Sets the kset of @obj's embedded kobject (via its embedded
  189. * kset) to @subsys.kset. This makes @obj a member of that
  190. * kset.
  191. */
  192. #define kset_set_kset_s(obj,subsys) \
  193. (obj)->kset.kobj.kset = &(subsys).kset
  194. /**
  195. * subsys_set_kset(obj,subsys) - set kset for subsystem
  196. * @obj: ptr to some object type.
  197. * @subsys: a subsystem object (not a ptr).
  198. *
  199. * Can be used for any object type with an embedded ->subsys.
  200. * Sets the kset of @obj's kobject to @subsys.kset. This makes
  201. * the object a member of that kset.
  202. */
  203. #define subsys_set_kset(obj,_subsys) \
  204. (obj)->subsys.kset.kobj.kset = &(_subsys).kset
  205. extern void subsystem_init(struct subsystem *);
  206. extern int __must_check subsystem_register(struct subsystem *);
  207. extern void subsystem_unregister(struct subsystem *);
  208. static inline struct subsystem * subsys_get(struct subsystem * s)
  209. {
  210. return s ? container_of(kset_get(&s->kset),struct subsystem,kset) : NULL;
  211. }
  212. static inline void subsys_put(struct subsystem * s)
  213. {
  214. kset_put(&s->kset);
  215. }
  216. struct subsys_attribute {
  217. struct attribute attr;
  218. ssize_t (*show)(struct subsystem *, char *);
  219. ssize_t (*store)(struct subsystem *, const char *, size_t);
  220. };
  221. extern int __must_check subsys_create_file(struct subsystem * ,
  222. struct subsys_attribute *);
  223. #if defined(CONFIG_HOTPLUG)
  224. int kobject_uevent(struct kobject *kobj, enum kobject_action action);
  225. int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
  226. char *envp[]);
  227. int add_uevent_var(char **envp, int num_envp, int *cur_index,
  228. char *buffer, int buffer_size, int *cur_len,
  229. const char *format, ...)
  230. __attribute__((format (printf, 7, 8)));
  231. #else
  232. static inline int kobject_uevent(struct kobject *kobj, enum kobject_action action)
  233. { return 0; }
  234. static inline int kobject_uevent_env(struct kobject *kobj,
  235. enum kobject_action action,
  236. char *envp[])
  237. { return 0; }
  238. static inline int add_uevent_var(char **envp, int num_envp, int *cur_index,
  239. char *buffer, int buffer_size, int *cur_len,
  240. const char *format, ...)
  241. { return 0; }
  242. #endif
  243. #endif /* __KERNEL__ */
  244. #endif /* _KOBJECT_H_ */