]>
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 | ||
25 | #define BUFFER_SIZE 1024 /* buffer for the hotplug env */ | |
26 | #define NUM_ENVP 32 /* number of env pointers */ | |
27 | ||
0296b228 KS |
28 | #if defined(CONFIG_HOTPLUG) |
29 | char hotplug_path[HOTPLUG_PATH_LEN] = "/sbin/hotplug"; | |
30 | u64 hotplug_seqnum; | |
31 | static DEFINE_SPINLOCK(sequence_lock); | |
5f123fbd | 32 | static struct sock *uevent_sock; |
0296b228 | 33 | |
1da177e4 LT |
34 | static char *action_to_string(enum kobject_action action) |
35 | { | |
36 | switch (action) { | |
37 | case KOBJ_ADD: | |
38 | return "add"; | |
39 | case KOBJ_REMOVE: | |
40 | return "remove"; | |
41 | case KOBJ_CHANGE: | |
42 | return "change"; | |
1da177e4 LT |
43 | case KOBJ_OFFLINE: |
44 | return "offline"; | |
45 | case KOBJ_ONLINE: | |
46 | return "online"; | |
47 | default: | |
48 | return NULL; | |
49 | } | |
50 | } | |
1da177e4 | 51 | |
1da177e4 LT |
52 | /** |
53 | * kobject_hotplug - notify userspace by executing /sbin/hotplug | |
54 | * | |
55 | * @action: action that is happening (usually "ADD" or "REMOVE") | |
56 | * @kobj: struct kobject that the action is happening to | |
57 | */ | |
58 | void kobject_hotplug(struct kobject *kobj, enum kobject_action action) | |
59 | { | |
5f123fbd KS |
60 | char **envp; |
61 | char *buffer; | |
1da177e4 | 62 | char *scratch; |
5f123fbd KS |
63 | const char *action_string; |
64 | const char *devpath = NULL; | |
65 | const char *subsystem; | |
66 | struct kobject *top_kobj; | |
67 | struct kset *kset; | |
68 | struct kset_hotplug_ops *hotplug_ops; | |
69 | u64 seq; | |
70 | char *seq_buff; | |
1da177e4 LT |
71 | int i = 0; |
72 | int retval; | |
1da177e4 | 73 | |
5f123fbd KS |
74 | pr_debug("%s\n", __FUNCTION__); |
75 | ||
76 | action_string = action_to_string(action); | |
77 | if (!action_string) | |
78 | return; | |
79 | ||
80 | /* search the kset we belong to */ | |
81 | top_kobj = kobj; | |
1da177e4 LT |
82 | if (!top_kobj->kset && top_kobj->parent) { |
83 | do { | |
84 | top_kobj = top_kobj->parent; | |
85 | } while (!top_kobj->kset && top_kobj->parent); | |
86 | } | |
5f123fbd | 87 | if (!top_kobj->kset) |
1da177e4 LT |
88 | return; |
89 | ||
5f123fbd KS |
90 | kset = top_kobj->kset; |
91 | hotplug_ops = kset->hotplug_ops; | |
1da177e4 | 92 | |
5f123fbd KS |
93 | /* skip the event, if the filter returns zero. */ |
94 | if (hotplug_ops && hotplug_ops->filter) | |
1da177e4 LT |
95 | if (!hotplug_ops->filter(kset, kobj)) |
96 | return; | |
1da177e4 | 97 | |
5f123fbd KS |
98 | /* environment index */ |
99 | envp = kzalloc(NUM_ENVP * sizeof (char *), GFP_KERNEL); | |
1da177e4 LT |
100 | if (!envp) |
101 | return; | |
1da177e4 | 102 | |
5f123fbd | 103 | /* environment values */ |
1da177e4 LT |
104 | buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL); |
105 | if (!buffer) | |
106 | goto exit; | |
107 | ||
5f123fbd KS |
108 | /* complete object path */ |
109 | devpath = kobject_get_path(kobj, GFP_KERNEL); | |
110 | if (!devpath) | |
111 | goto exit; | |
1da177e4 | 112 | |
5f123fbd KS |
113 | /* originating subsystem */ |
114 | if (hotplug_ops && hotplug_ops->name) | |
115 | subsystem = hotplug_ops->name(kset, kobj); | |
116 | else | |
117 | subsystem = kobject_name(&kset->kobj); | |
1da177e4 | 118 | |
5f123fbd KS |
119 | /* event environemnt for helper process only */ |
120 | envp[i++] = "HOME=/"; | |
121 | envp[i++] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin"; | |
1da177e4 | 122 | |
5f123fbd | 123 | /* default keys */ |
1da177e4 | 124 | scratch = buffer; |
1da177e4 LT |
125 | envp [i++] = scratch; |
126 | scratch += sprintf(scratch, "ACTION=%s", action_string) + 1; | |
1da177e4 | 127 | envp [i++] = scratch; |
5f123fbd | 128 | scratch += sprintf (scratch, "DEVPATH=%s", devpath) + 1; |
1da177e4 | 129 | envp [i++] = scratch; |
5f123fbd | 130 | scratch += sprintf(scratch, "SUBSYSTEM=%s", subsystem) + 1; |
1da177e4 | 131 | |
5f123fbd | 132 | /* just reserve the space, overwrite it after kset call has returned */ |
1da177e4 LT |
133 | envp[i++] = seq_buff = scratch; |
134 | scratch += strlen("SEQNUM=18446744073709551616") + 1; | |
135 | ||
5f123fbd KS |
136 | /* let the kset specific function add its stuff */ |
137 | if (hotplug_ops && hotplug_ops->hotplug) { | |
1da177e4 LT |
138 | retval = hotplug_ops->hotplug (kset, kobj, |
139 | &envp[i], NUM_ENVP - i, scratch, | |
140 | BUFFER_SIZE - (scratch - buffer)); | |
141 | if (retval) { | |
142 | pr_debug ("%s - hotplug() returned %d\n", | |
143 | __FUNCTION__, retval); | |
144 | goto exit; | |
145 | } | |
146 | } | |
147 | ||
5f123fbd | 148 | /* we will send an event, request a new sequence number */ |
1da177e4 LT |
149 | spin_lock(&sequence_lock); |
150 | seq = ++hotplug_seqnum; | |
151 | spin_unlock(&sequence_lock); | |
152 | sprintf(seq_buff, "SEQNUM=%llu", (unsigned long long)seq); | |
153 | ||
5f123fbd KS |
154 | /* send netlink message */ |
155 | if (uevent_sock) { | |
156 | struct sk_buff *skb; | |
157 | size_t len; | |
158 | ||
159 | /* allocate message with the maximum possible size */ | |
160 | len = strlen(action_string) + strlen(devpath) + 2; | |
161 | skb = alloc_skb(len + BUFFER_SIZE, GFP_KERNEL); | |
162 | if (skb) { | |
163 | /* add header */ | |
164 | scratch = skb_put(skb, len); | |
165 | sprintf(scratch, "%s@%s", action_string, devpath); | |
166 | ||
167 | /* copy keys to our continuous event payload buffer */ | |
168 | for (i = 2; envp[i]; i++) { | |
169 | len = strlen(envp[i]) + 1; | |
170 | scratch = skb_put(skb, len); | |
171 | strcpy(scratch, envp[i]); | |
172 | } | |
173 | ||
174 | NETLINK_CB(skb).dst_group = 1; | |
175 | netlink_broadcast(uevent_sock, skb, 0, 1, GFP_KERNEL); | |
176 | } | |
177 | } | |
1da177e4 | 178 | |
5f123fbd KS |
179 | /* call uevent_helper, usually only enabled during early boot */ |
180 | if (hotplug_path[0]) { | |
181 | char *argv [3]; | |
1da177e4 | 182 | |
5f123fbd KS |
183 | argv [0] = hotplug_path; |
184 | argv [1] = (char *)subsystem; | |
185 | argv [2] = NULL; | |
186 | call_usermodehelper (argv[0], argv, envp, 0); | |
187 | } | |
1da177e4 LT |
188 | |
189 | exit: | |
5f123fbd | 190 | kfree(devpath); |
1da177e4 LT |
191 | kfree(buffer); |
192 | kfree(envp); | |
193 | return; | |
194 | } | |
195 | EXPORT_SYMBOL(kobject_hotplug); | |
196 | ||
197 | /** | |
198 | * add_hotplug_env_var - helper for creating hotplug environment variables | |
199 | * @envp: Pointer to table of environment variables, as passed into | |
200 | * hotplug() method. | |
201 | * @num_envp: Number of environment variable slots available, as | |
202 | * passed into hotplug() method. | |
203 | * @cur_index: Pointer to current index into @envp. It should be | |
204 | * initialized to 0 before the first call to add_hotplug_env_var(), | |
205 | * and will be incremented on success. | |
206 | * @buffer: Pointer to buffer for environment variables, as passed | |
207 | * into hotplug() method. | |
208 | * @buffer_size: Length of @buffer, as passed into hotplug() method. | |
209 | * @cur_len: Pointer to current length of space used in @buffer. | |
210 | * Should be initialized to 0 before the first call to | |
211 | * add_hotplug_env_var(), and will be incremented on success. | |
212 | * @format: Format for creating environment variable (of the form | |
213 | * "XXX=%x") for snprintf(). | |
214 | * | |
215 | * Returns 0 if environment variable was added successfully or -ENOMEM | |
216 | * if no space was available. | |
217 | */ | |
218 | int add_hotplug_env_var(char **envp, int num_envp, int *cur_index, | |
219 | char *buffer, int buffer_size, int *cur_len, | |
220 | const char *format, ...) | |
221 | { | |
222 | va_list args; | |
223 | ||
224 | /* | |
225 | * We check against num_envp - 1 to make sure there is at | |
226 | * least one slot left after we return, since the hotplug | |
227 | * method needs to set the last slot to NULL. | |
228 | */ | |
229 | if (*cur_index >= num_envp - 1) | |
230 | return -ENOMEM; | |
231 | ||
232 | envp[*cur_index] = buffer + *cur_len; | |
233 | ||
234 | va_start(args, format); | |
235 | *cur_len += vsnprintf(envp[*cur_index], | |
236 | max(buffer_size - *cur_len, 0), | |
237 | format, args) + 1; | |
238 | va_end(args); | |
239 | ||
240 | if (*cur_len > buffer_size) | |
241 | return -ENOMEM; | |
242 | ||
243 | (*cur_index)++; | |
244 | return 0; | |
245 | } | |
246 | EXPORT_SYMBOL(add_hotplug_env_var); | |
247 | ||
5f123fbd KS |
248 | static int __init kobject_uevent_init(void) |
249 | { | |
250 | uevent_sock = netlink_kernel_create(NETLINK_KOBJECT_UEVENT, 1, NULL, | |
251 | THIS_MODULE); | |
252 | ||
253 | if (!uevent_sock) { | |
254 | printk(KERN_ERR | |
255 | "kobject_uevent: unable to create netlink socket!\n"); | |
256 | return -ENODEV; | |
257 | } | |
258 | ||
259 | return 0; | |
260 | } | |
261 | ||
262 | postcore_initcall(kobject_uevent_init); | |
263 | ||
1da177e4 | 264 | #endif /* CONFIG_HOTPLUG */ |