Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * kernel userspace event delivery | |
3 | * | |
4 | * Copyright (C) 2004 Red Hat, Inc. All rights reserved. | |
5 | * Copyright (C) 2004 Novell, Inc. All rights reserved. | |
6 | * Copyright (C) 2004 IBM, Inc. All rights reserved. | |
7 | * | |
8 | * Licensed under the GNU GPL v2. | |
9 | * | |
10 | * Authors: | |
11 | * Robert Love <rml@novell.com> | |
12 | * Kay Sievers <kay.sievers@vrfy.org> | |
13 | * Arjan van de Ven <arjanv@redhat.com> | |
14 | * Greg Kroah-Hartman <greg@kroah.com> | |
15 | */ | |
16 | ||
17 | #include <linux/spinlock.h> | |
18 | #include <linux/socket.h> | |
19 | #include <linux/skbuff.h> | |
20 | #include <linux/netlink.h> | |
21 | #include <linux/string.h> | |
1da177e4 LT |
22 | #include <linux/kobject.h> |
23 | #include <net/sock.h> | |
24 | ||
d87499ed | 25 | #define BUFFER_SIZE 2048 /* buffer for the variables */ |
1da177e4 LT |
26 | #define NUM_ENVP 32 /* number of env pointers */ |
27 | ||
4d17ffda | 28 | #if defined(CONFIG_HOTPLUG) |
51107301 JN |
29 | u64 uevent_seqnum; |
30 | char uevent_helper[UEVENT_HELPER_PATH_LEN] = "/sbin/hotplug"; | |
0296b228 | 31 | static DEFINE_SPINLOCK(sequence_lock); |
4d17ffda | 32 | #if defined(CONFIG_NET) |
5f123fbd | 33 | static struct sock *uevent_sock; |
4d17ffda | 34 | #endif |
0296b228 | 35 | |
1da177e4 LT |
36 | static char *action_to_string(enum kobject_action action) |
37 | { | |
38 | switch (action) { | |
39 | case KOBJ_ADD: | |
40 | return "add"; | |
41 | case KOBJ_REMOVE: | |
42 | return "remove"; | |
43 | case KOBJ_CHANGE: | |
44 | return "change"; | |
1da177e4 LT |
45 | case KOBJ_OFFLINE: |
46 | return "offline"; | |
47 | case KOBJ_ONLINE: | |
48 | return "online"; | |
8a82472f CH |
49 | case KOBJ_MOVE: |
50 | return "move"; | |
1da177e4 LT |
51 | default: |
52 | return NULL; | |
53 | } | |
54 | } | |
1da177e4 | 55 | |
1da177e4 | 56 | /** |
8a82472f | 57 | * kobject_uevent_env - send an uevent with environmental data |
1da177e4 | 58 | * |
8a82472f | 59 | * @action: action that is happening (usually KOBJ_MOVE) |
1da177e4 | 60 | * @kobj: struct kobject that the action is happening to |
8a82472f | 61 | * @envp_ext: pointer to environmental data |
542cfce6 AK |
62 | * |
63 | * Returns 0 if kobject_uevent() is completed with success or the | |
64 | * corresponding error when it fails. | |
1da177e4 | 65 | */ |
542cfce6 | 66 | int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, |
8a82472f | 67 | char *envp_ext[]) |
1da177e4 | 68 | { |
5f123fbd KS |
69 | char **envp; |
70 | char *buffer; | |
1da177e4 | 71 | char *scratch; |
5f123fbd KS |
72 | const char *action_string; |
73 | const char *devpath = NULL; | |
74 | const char *subsystem; | |
75 | struct kobject *top_kobj; | |
76 | struct kset *kset; | |
312c004d | 77 | struct kset_uevent_ops *uevent_ops; |
5f123fbd KS |
78 | u64 seq; |
79 | char *seq_buff; | |
1da177e4 | 80 | int i = 0; |
542cfce6 | 81 | int retval = 0; |
8a82472f | 82 | int j; |
1da177e4 | 83 | |
5f123fbd KS |
84 | pr_debug("%s\n", __FUNCTION__); |
85 | ||
86 | action_string = action_to_string(action); | |
542cfce6 AK |
87 | if (!action_string) { |
88 | pr_debug("kobject attempted to send uevent without action_string!\n"); | |
89 | return -EINVAL; | |
90 | } | |
5f123fbd KS |
91 | |
92 | /* search the kset we belong to */ | |
93 | top_kobj = kobj; | |
14193fb9 JAKJ |
94 | while (!top_kobj->kset && top_kobj->parent) { |
95 | top_kobj = top_kobj->parent; | |
1da177e4 | 96 | } |
542cfce6 AK |
97 | if (!top_kobj->kset) { |
98 | pr_debug("kobject attempted to send uevent without kset!\n"); | |
99 | return -EINVAL; | |
100 | } | |
1da177e4 | 101 | |
5f123fbd | 102 | kset = top_kobj->kset; |
312c004d | 103 | uevent_ops = kset->uevent_ops; |
1da177e4 | 104 | |
5f123fbd | 105 | /* skip the event, if the filter returns zero. */ |
312c004d | 106 | if (uevent_ops && uevent_ops->filter) |
542cfce6 AK |
107 | if (!uevent_ops->filter(kset, kobj)) { |
108 | pr_debug("kobject filter function caused the event to drop!\n"); | |
109 | return 0; | |
110 | } | |
1da177e4 | 111 | |
86406245 KS |
112 | /* originating subsystem */ |
113 | if (uevent_ops && uevent_ops->name) | |
114 | subsystem = uevent_ops->name(kset, kobj); | |
115 | else | |
116 | subsystem = kobject_name(&kset->kobj); | |
117 | if (!subsystem) { | |
118 | pr_debug("unset subsytem caused the event to drop!\n"); | |
119 | return 0; | |
120 | } | |
121 | ||
5f123fbd KS |
122 | /* environment index */ |
123 | envp = kzalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL); | |
1da177e4 | 124 | if (!envp) |
542cfce6 | 125 | return -ENOMEM; |
1da177e4 | 126 | |
5f123fbd | 127 | /* environment values */ |
1da177e4 | 128 | buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); |
542cfce6 AK |
129 | if (!buffer) { |
130 | retval = -ENOMEM; | |
1da177e4 | 131 | goto exit; |
542cfce6 | 132 | } |
1da177e4 | 133 | |
5f123fbd KS |
134 | /* complete object path */ |
135 | devpath = kobject_get_path(kobj, GFP_KERNEL); | |
542cfce6 AK |
136 | if (!devpath) { |
137 | retval = -ENOENT; | |
5f123fbd | 138 | goto exit; |
542cfce6 | 139 | } |
1da177e4 | 140 | |
5f123fbd KS |
141 | /* event environemnt for helper process only */ |
142 | envp[i++] = "HOME=/"; | |
143 | envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; | |
1da177e4 | 144 | |
5f123fbd | 145 | /* default keys */ |
1da177e4 | 146 | scratch = buffer; |
1da177e4 LT |
147 | envp [i++] = scratch; |
148 | scratch += sprintf(scratch, "ACTION=%s", action_string) + 1; | |
1da177e4 | 149 | envp [i++] = scratch; |
5f123fbd | 150 | scratch += sprintf (scratch, "DEVPATH=%s", devpath) + 1; |
1da177e4 | 151 | envp [i++] = scratch; |
5f123fbd | 152 | scratch += sprintf(scratch, "SUBSYSTEM=%s", subsystem) + 1; |
8a82472f CH |
153 | for (j = 0; envp_ext && envp_ext[j]; j++) |
154 | envp[i++] = envp_ext[j]; | |
5f123fbd | 155 | /* just reserve the space, overwrite it after kset call has returned */ |
1da177e4 LT |
156 | envp[i++] = seq_buff = scratch; |
157 | scratch += strlen("SEQNUM=18446744073709551616") + 1; | |
158 | ||
5f123fbd | 159 | /* let the kset specific function add its stuff */ |
312c004d KS |
160 | if (uevent_ops && uevent_ops->uevent) { |
161 | retval = uevent_ops->uevent(kset, kobj, | |
1da177e4 LT |
162 | &envp[i], NUM_ENVP - i, scratch, |
163 | BUFFER_SIZE - (scratch - buffer)); | |
164 | if (retval) { | |
312c004d | 165 | pr_debug ("%s - uevent() returned %d\n", |
1da177e4 LT |
166 | __FUNCTION__, retval); |
167 | goto exit; | |
168 | } | |
169 | } | |
170 | ||
5f123fbd | 171 | /* we will send an event, request a new sequence number */ |
1da177e4 | 172 | spin_lock(&sequence_lock); |
312c004d | 173 | seq = ++uevent_seqnum; |
1da177e4 LT |
174 | spin_unlock(&sequence_lock); |
175 | sprintf(seq_buff, "SEQNUM=%llu", (unsigned long long)seq); | |
176 | ||
4d17ffda | 177 | #if defined(CONFIG_NET) |
5f123fbd KS |
178 | /* send netlink message */ |
179 | if (uevent_sock) { | |
180 | struct sk_buff *skb; | |
181 | size_t len; | |
182 | ||
183 | /* allocate message with the maximum possible size */ | |
184 | len = strlen(action_string) + strlen(devpath) + 2; | |
185 | skb = alloc_skb(len + BUFFER_SIZE, GFP_KERNEL); | |
186 | if (skb) { | |
187 | /* add header */ | |
188 | scratch = skb_put(skb, len); | |
189 | sprintf(scratch, "%s@%s", action_string, devpath); | |
190 | ||
191 | /* copy keys to our continuous event payload buffer */ | |
192 | for (i = 2; envp[i]; i++) { | |
193 | len = strlen(envp[i]) + 1; | |
194 | scratch = skb_put(skb, len); | |
195 | strcpy(scratch, envp[i]); | |
196 | } | |
197 | ||
198 | NETLINK_CB(skb).dst_group = 1; | |
199 | netlink_broadcast(uevent_sock, skb, 0, 1, GFP_KERNEL); | |
200 | } | |
201 | } | |
4d17ffda | 202 | #endif |
1da177e4 | 203 | |
5f123fbd | 204 | /* call uevent_helper, usually only enabled during early boot */ |
312c004d | 205 | if (uevent_helper[0]) { |
5f123fbd | 206 | char *argv [3]; |
1da177e4 | 207 | |
312c004d | 208 | argv [0] = uevent_helper; |
5f123fbd KS |
209 | argv [1] = (char *)subsystem; |
210 | argv [2] = NULL; | |
211 | call_usermodehelper (argv[0], argv, envp, 0); | |
212 | } | |
1da177e4 LT |
213 | |
214 | exit: | |
5f123fbd | 215 | kfree(devpath); |
1da177e4 LT |
216 | kfree(buffer); |
217 | kfree(envp); | |
542cfce6 | 218 | return retval; |
1da177e4 | 219 | } |
8a82472f CH |
220 | |
221 | EXPORT_SYMBOL_GPL(kobject_uevent_env); | |
222 | ||
223 | /** | |
224 | * kobject_uevent - notify userspace by ending an uevent | |
225 | * | |
226 | * @action: action that is happening (usually KOBJ_ADD and KOBJ_REMOVE) | |
227 | * @kobj: struct kobject that the action is happening to | |
542cfce6 AK |
228 | * |
229 | * Returns 0 if kobject_uevent() is completed with success or the | |
230 | * corresponding error when it fails. | |
8a82472f | 231 | */ |
542cfce6 | 232 | int kobject_uevent(struct kobject *kobj, enum kobject_action action) |
8a82472f | 233 | { |
542cfce6 | 234 | return kobject_uevent_env(kobj, action, NULL); |
8a82472f CH |
235 | } |
236 | ||
312c004d | 237 | EXPORT_SYMBOL_GPL(kobject_uevent); |
1da177e4 LT |
238 | |
239 | /** | |
312c004d | 240 | * add_uevent_var - helper for creating event variables |
1da177e4 | 241 | * @envp: Pointer to table of environment variables, as passed into |
312c004d | 242 | * uevent() method. |
1da177e4 | 243 | * @num_envp: Number of environment variable slots available, as |
312c004d | 244 | * passed into uevent() method. |
1da177e4 | 245 | * @cur_index: Pointer to current index into @envp. It should be |
312c004d | 246 | * initialized to 0 before the first call to add_uevent_var(), |
1da177e4 LT |
247 | * and will be incremented on success. |
248 | * @buffer: Pointer to buffer for environment variables, as passed | |
312c004d KS |
249 | * into uevent() method. |
250 | * @buffer_size: Length of @buffer, as passed into uevent() method. | |
1da177e4 LT |
251 | * @cur_len: Pointer to current length of space used in @buffer. |
252 | * Should be initialized to 0 before the first call to | |
312c004d | 253 | * add_uevent_var(), and will be incremented on success. |
1da177e4 LT |
254 | * @format: Format for creating environment variable (of the form |
255 | * "XXX=%x") for snprintf(). | |
256 | * | |
257 | * Returns 0 if environment variable was added successfully or -ENOMEM | |
258 | * if no space was available. | |
259 | */ | |
312c004d KS |
260 | int add_uevent_var(char **envp, int num_envp, int *cur_index, |
261 | char *buffer, int buffer_size, int *cur_len, | |
262 | const char *format, ...) | |
1da177e4 LT |
263 | { |
264 | va_list args; | |
265 | ||
266 | /* | |
267 | * We check against num_envp - 1 to make sure there is at | |
312c004d KS |
268 | * least one slot left after we return, since kobject_uevent() |
269 | * needs to set the last slot to NULL. | |
1da177e4 LT |
270 | */ |
271 | if (*cur_index >= num_envp - 1) | |
272 | return -ENOMEM; | |
273 | ||
274 | envp[*cur_index] = buffer + *cur_len; | |
275 | ||
276 | va_start(args, format); | |
277 | *cur_len += vsnprintf(envp[*cur_index], | |
278 | max(buffer_size - *cur_len, 0), | |
279 | format, args) + 1; | |
280 | va_end(args); | |
281 | ||
282 | if (*cur_len > buffer_size) | |
283 | return -ENOMEM; | |
284 | ||
285 | (*cur_index)++; | |
286 | return 0; | |
287 | } | |
312c004d | 288 | EXPORT_SYMBOL_GPL(add_uevent_var); |
1da177e4 | 289 | |
4d17ffda | 290 | #if defined(CONFIG_NET) |
5f123fbd KS |
291 | static int __init kobject_uevent_init(void) |
292 | { | |
293 | uevent_sock = netlink_kernel_create(NETLINK_KOBJECT_UEVENT, 1, NULL, | |
af65bdfc | 294 | NULL, THIS_MODULE); |
5f123fbd KS |
295 | |
296 | if (!uevent_sock) { | |
297 | printk(KERN_ERR | |
298 | "kobject_uevent: unable to create netlink socket!\n"); | |
299 | return -ENODEV; | |
300 | } | |
301 | ||
302 | return 0; | |
303 | } | |
304 | ||
305 | postcore_initcall(kobject_uevent_init); | |
4d17ffda | 306 | #endif |
5f123fbd | 307 | |
1da177e4 | 308 | #endif /* CONFIG_HOTPLUG */ |