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