• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
kobject_name(const struct kobject * kobj)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 
to_kset(struct kobject * kobj)135 static inline struct kset * to_kset(struct kobject * kobj)
136 {
137 	return kobj ? container_of(kobj,struct kset,kobj) : NULL;
138 }
139 
kset_get(struct kset * k)140 static inline struct kset * kset_get(struct kset * k)
141 {
142 	return k ? to_kset(kobject_get(&k->kobj)) : NULL;
143 }
144 
kset_put(struct kset * k)145 static inline void kset_put(struct kset * k)
146 {
147 	kobject_put(&k->kobj);
148 }
149 
get_ktype(struct kobject * k)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 /* The global /sys/hypervisor/ subsystem  */
194 extern struct subsystem hypervisor_subsys;
195 
196 /**
197  * Helpers for setting the kset of registered objects.
198  * Often, a registered object belongs to a kset embedded in a
199  * subsystem. These do no magic, just make the resulting code
200  * easier to follow.
201  */
202 
203 /**
204  *	kobj_set_kset_s(obj,subsys) - set kset for embedded kobject.
205  *	@obj:		ptr to some object type.
206  *	@subsys:	a subsystem object (not a ptr).
207  *
208  *	Can be used for any object type with an embedded ->kobj.
209  */
210 
211 #define kobj_set_kset_s(obj,subsys) \
212 	(obj)->kobj.kset = &(subsys).kset
213 
214 /**
215  *	kset_set_kset_s(obj,subsys) - set kset for embedded kset.
216  *	@obj:		ptr to some object type.
217  *	@subsys:	a subsystem object (not a ptr).
218  *
219  *	Can be used for any object type with an embedded ->kset.
220  *	Sets the kset of @obj's  embedded kobject (via its embedded
221  *	kset) to @subsys.kset. This makes @obj a member of that
222  *	kset.
223  */
224 
225 #define kset_set_kset_s(obj,subsys) \
226 	(obj)->kset.kobj.kset = &(subsys).kset
227 
228 /**
229  *	subsys_set_kset(obj,subsys) - set kset for subsystem
230  *	@obj:		ptr to some object type.
231  *	@subsys:	a subsystem object (not a ptr).
232  *
233  *	Can be used for any object type with an embedded ->subsys.
234  *	Sets the kset of @obj's kobject to @subsys.kset. This makes
235  *	the object a member of that kset.
236  */
237 
238 #define subsys_set_kset(obj,_subsys) \
239 	(obj)->subsys.kset.kobj.kset = &(_subsys).kset
240 
241 extern void subsystem_init(struct subsystem *);
242 extern int subsystem_register(struct subsystem *);
243 extern void subsystem_unregister(struct subsystem *);
244 
subsys_get(struct subsystem * s)245 static inline struct subsystem * subsys_get(struct subsystem * s)
246 {
247 	return s ? container_of(kset_get(&s->kset),struct subsystem,kset) : NULL;
248 }
249 
subsys_put(struct subsystem * s)250 static inline void subsys_put(struct subsystem * s)
251 {
252 	kset_put(&s->kset);
253 }
254 
255 struct subsys_attribute {
256 	struct attribute attr;
257 	ssize_t (*show)(struct subsystem *, char *);
258 	ssize_t (*store)(struct subsystem *, const char *, size_t);
259 };
260 
261 extern int subsys_create_file(struct subsystem * , struct subsys_attribute *);
262 
263 #if defined(CONFIG_HOTPLUG)
264 void kobject_uevent(struct kobject *kobj, enum kobject_action action);
265 
266 int add_uevent_var(char **envp, int num_envp, int *cur_index,
267 			char *buffer, int buffer_size, int *cur_len,
268 			const char *format, ...)
269 	__attribute__((format (printf, 7, 8)));
270 #else
kobject_uevent(struct kobject * kobj,enum kobject_action action)271 static inline void kobject_uevent(struct kobject *kobj, enum kobject_action action) { }
272 
add_uevent_var(char ** envp,int num_envp,int * cur_index,char * buffer,int buffer_size,int * cur_len,const char * format,...)273 static inline int add_uevent_var(char **envp, int num_envp, int *cur_index,
274 				      char *buffer, int buffer_size, int *cur_len,
275 				      const char *format, ...)
276 { return 0; }
277 #endif
278 
279 #endif /* __KERNEL__ */
280 #endif /* _KOBJECT_H_ */
281