[PATCH] remove CONFIG_KOBJECT_UEVENT option
[linux-2.6.git] / include / linux / kobject.h
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 <asm/atomic.h>
28
29 #define KOBJ_NAME_LEN   20
30
31 #define HOTPLUG_PATH_LEN        256
32
33 /* path to the userspace helper executed on an event */
34 extern char hotplug_path[];
35
36 /* counter to tag the hotplug event, read only except for the kobject core */
37 extern u64 hotplug_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,      /* add event, for hotplug */
43         KOBJ_REMOVE     = (__force kobject_action_t) 0x02,      /* remove event, for hotplug */
44         KOBJ_CHANGE     = (__force kobject_action_t) 0x03,      /* a sysfs attribute file has changed */
45         KOBJ_MOUNT      = (__force kobject_action_t) 0x04,      /* mount event for block devices */
46         KOBJ_UMOUNT     = (__force kobject_action_t) 0x05,      /* umount event for block devices */
47         KOBJ_OFFLINE    = (__force kobject_action_t) 0x06,      /* offline event for hotplug devices */
48         KOBJ_ONLINE     = (__force kobject_action_t) 0x07,      /* online event for hotplug devices */
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 };
61
62 extern int kobject_set_name(struct kobject *, const char *, ...)
63         __attribute__((format(printf,2,3)));
64
65 static inline const char * kobject_name(const struct kobject * kobj)
66 {
67         return kobj->k_name;
68 }
69
70 extern void kobject_init(struct kobject *);
71 extern void kobject_cleanup(struct kobject *);
72
73 extern int kobject_add(struct kobject *);
74 extern void kobject_del(struct kobject *);
75
76 extern int kobject_rename(struct kobject *, const char *new_name);
77
78 extern int kobject_register(struct kobject *);
79 extern void kobject_unregister(struct kobject *);
80
81 extern struct kobject * kobject_get(struct kobject *);
82 extern void kobject_put(struct kobject *);
83
84 extern char * kobject_get_path(struct kobject *, gfp_t);
85
86 struct kobj_type {
87         void (*release)(struct kobject *);
88         struct sysfs_ops        * sysfs_ops;
89         struct attribute        ** default_attrs;
90 };
91
92
93 /**
94  *      kset - a set of kobjects of a specific type, belonging
95  *      to a specific subsystem.
96  *
97  *      All kobjects of a kset should be embedded in an identical 
98  *      type. This type may have a descriptor, which the kset points
99  *      to. This allows there to exist sets of objects of the same
100  *      type in different subsystems.
101  *
102  *      A subsystem does not have to be a list of only one type 
103  *      of object; multiple ksets can belong to one subsystem. All 
104  *      ksets of a subsystem share the subsystem's lock.
105  *
106  *      Each kset can support hotplugging; if it does, it will be given
107  *      the opportunity to filter out specific kobjects from being
108  *      reported, as well as to add its own "data" elements to the
109  *      environment being passed to the hotplug helper.
110  */
111 struct kset_hotplug_ops {
112         int (*filter)(struct kset *kset, struct kobject *kobj);
113         const char *(*name)(struct kset *kset, struct kobject *kobj);
114         int (*hotplug)(struct kset *kset, struct kobject *kobj, char **envp,
115                         int num_envp, char *buffer, int buffer_size);
116 };
117
118 struct kset {
119         struct subsystem        * subsys;
120         struct kobj_type        * ktype;
121         struct list_head        list;
122         spinlock_t              list_lock;
123         struct kobject          kobj;
124         struct kset_hotplug_ops * hotplug_ops;
125 };
126
127
128 extern void kset_init(struct kset * k);
129 extern int kset_add(struct kset * k);
130 extern int kset_register(struct kset * k);
131 extern void kset_unregister(struct kset * k);
132
133 static inline struct kset * to_kset(struct kobject * kobj)
134 {
135         return kobj ? container_of(kobj,struct kset,kobj) : NULL;
136 }
137
138 static inline struct kset * kset_get(struct kset * k)
139 {
140         return k ? to_kset(kobject_get(&k->kobj)) : NULL;
141 }
142
143 static inline void kset_put(struct kset * k)
144 {
145         kobject_put(&k->kobj);
146 }
147
148 static inline struct kobj_type * get_ktype(struct kobject * k)
149 {
150         if (k->kset && k->kset->ktype)
151                 return k->kset->ktype;
152         else 
153                 return k->ktype;
154 }
155
156 extern struct kobject * kset_find_obj(struct kset *, const char *);
157
158
159 /**
160  * Use this when initializing an embedded kset with no other 
161  * fields to initialize.
162  */
163 #define set_kset_name(str)      .kset = { .kobj = { .name = str } }
164
165
166
167 struct subsystem {
168         struct kset             kset;
169         struct rw_semaphore     rwsem;
170 };
171
172 #define decl_subsys(_name,_type,_hotplug_ops) \
173 struct subsystem _name##_subsys = { \
174         .kset = { \
175                 .kobj = { .name = __stringify(_name) }, \
176                 .ktype = _type, \
177                 .hotplug_ops =_hotplug_ops, \
178         } \
179 }
180 #define decl_subsys_name(_varname,_name,_type,_hotplug_ops) \
181 struct subsystem _varname##_subsys = { \
182         .kset = { \
183                 .kobj = { .name = __stringify(_name) }, \
184                 .ktype = _type, \
185                 .hotplug_ops =_hotplug_ops, \
186         } \
187 }
188
189 /* The global /sys/kernel/ subsystem for people to chain off of */
190 extern struct subsystem kernel_subsys;
191
192 /**
193  * Helpers for setting the kset of registered objects.
194  * Often, a registered object belongs to a kset embedded in a 
195  * subsystem. These do no magic, just make the resulting code
196  * easier to follow. 
197  */
198
199 /**
200  *      kobj_set_kset_s(obj,subsys) - set kset for embedded kobject.
201  *      @obj:           ptr to some object type.
202  *      @subsys:        a subsystem object (not a ptr).
203  *
204  *      Can be used for any object type with an embedded ->kobj.
205  */
206
207 #define kobj_set_kset_s(obj,subsys) \
208         (obj)->kobj.kset = &(subsys).kset
209
210 /**
211  *      kset_set_kset_s(obj,subsys) - set kset for embedded kset.
212  *      @obj:           ptr to some object type.
213  *      @subsys:        a subsystem object (not a ptr).
214  *
215  *      Can be used for any object type with an embedded ->kset.
216  *      Sets the kset of @obj's  embedded kobject (via its embedded
217  *      kset) to @subsys.kset. This makes @obj a member of that 
218  *      kset.
219  */
220
221 #define kset_set_kset_s(obj,subsys) \
222         (obj)->kset.kobj.kset = &(subsys).kset
223
224 /**
225  *      subsys_set_kset(obj,subsys) - set kset for subsystem
226  *      @obj:           ptr to some object type.
227  *      @subsys:        a subsystem object (not a ptr).
228  *
229  *      Can be used for any object type with an embedded ->subsys.
230  *      Sets the kset of @obj's kobject to @subsys.kset. This makes
231  *      the object a member of that kset.
232  */
233
234 #define subsys_set_kset(obj,_subsys) \
235         (obj)->subsys.kset.kobj.kset = &(_subsys).kset
236
237 extern void subsystem_init(struct subsystem *);
238 extern int subsystem_register(struct subsystem *);
239 extern void subsystem_unregister(struct subsystem *);
240
241 static inline struct subsystem * subsys_get(struct subsystem * s)
242 {
243         return s ? container_of(kset_get(&s->kset),struct subsystem,kset) : NULL;
244 }
245
246 static inline void subsys_put(struct subsystem * s)
247 {
248         kset_put(&s->kset);
249 }
250
251 struct subsys_attribute {
252         struct attribute attr;
253         ssize_t (*show)(struct subsystem *, char *);
254         ssize_t (*store)(struct subsystem *, const char *, size_t); 
255 };
256
257 extern int subsys_create_file(struct subsystem * , struct subsys_attribute *);
258 extern void subsys_remove_file(struct subsystem * , struct subsys_attribute *);
259
260 #ifdef CONFIG_HOTPLUG
261 void kobject_hotplug(struct kobject *kobj, enum kobject_action action);
262
263 int add_hotplug_env_var(char **envp, int num_envp, int *cur_index,
264                         char *buffer, int buffer_size, int *cur_len,
265                         const char *format, ...)
266         __attribute__((format (printf, 7, 8)));
267
268 int kobject_uevent(struct kobject *kobj,
269                    enum kobject_action action,
270                    struct attribute *attr);
271 int kobject_uevent_atomic(struct kobject *kobj,
272                           enum kobject_action action,
273                           struct attribute *attr);
274
275 #else
276 static inline void kobject_hotplug(struct kobject *kobj, enum kobject_action action) { }
277 static inline int add_hotplug_env_var(char **envp, int num_envp, int *cur_index, 
278                                       char *buffer, int buffer_size, int *cur_len, 
279                                       const char *format, ...)
280 { return 0; }
281 int kobject_uevent(struct kobject *kobj,
282                    enum kobject_action action,
283                    struct attribute *attr)
284 { return 0; }
285 int kobject_uevent_atomic(struct kobject *kobj,
286                           enum kobject_action action,
287                           struct attribute *attr)
288 { return 0; }
289 #endif
290
291 #endif /* __KERNEL__ */
292 #endif /* _KOBJECT_H_ */