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