blob: 2615074d3de5c63e63da31995adc4a1f07f7e9fd [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Denis V. Lunev2d38f9a2008-03-27 14:26:30 -070018#include <linux/string.h>
19#include <linux/kobject.h>
Paul Gortmaker8bc3bcc2011-11-16 21:29:17 -050020#include <linux/export.h>
21#include <linux/kmod.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/socket.h>
24#include <linux/skbuff.h>
25#include <linux/netlink.h>
Peter Rajnohaf36776f2017-05-09 15:22:30 +020026#include <linux/uuid.h>
27#include <linux/ctype.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <net/sock.h>
Eric W. Biederman07e98962010-05-04 17:36:44 -070029#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030
Linus Torvalds1da177e2005-04-16 15:20:36 -070031
Cornelia Huckcd030c42007-07-20 13:58:13 +020032u64 uevent_seqnum;
Michael Marineau86d56132014-04-10 14:09:31 -070033#ifdef CONFIG_UEVENT_HELPER
Kay Sievers6a8d8ab2007-08-15 15:38:28 +020034char uevent_helper[UEVENT_HELPER_PATH_LEN] = CONFIG_UEVENT_HELPER_PATH;
Michael Marineau86d56132014-04-10 14:09:31 -070035#endif
Eric W. Biederman07e98962010-05-04 17:36:44 -070036#ifdef CONFIG_NET
37struct uevent_sock {
38 struct list_head list;
39 struct sock *sk;
40};
41static LIST_HEAD(uevent_sock_list);
Cornelia Huckcd030c42007-07-20 13:58:13 +020042#endif
43
Andrew Vagin7b60a182012-03-07 14:49:56 +040044/* This lock protects uevent_seqnum and uevent_sock_list */
45static DEFINE_MUTEX(uevent_sock_mutex);
46
Kay Sievers5c5daf62007-08-12 20:43:55 +020047/* the strings here must match the enum in include/linux/kobject.h */
48static const char *kobject_actions[] = {
49 [KOBJ_ADD] = "add",
50 [KOBJ_REMOVE] = "remove",
51 [KOBJ_CHANGE] = "change",
52 [KOBJ_MOVE] = "move",
53 [KOBJ_ONLINE] = "online",
54 [KOBJ_OFFLINE] = "offline",
Dmitry Torokhov1455cf82017-07-19 17:24:30 -070055 [KOBJ_BIND] = "bind",
56 [KOBJ_UNBIND] = "unbind",
Kay Sievers5c5daf62007-08-12 20:43:55 +020057};
58
Peter Rajnohaf36776f2017-05-09 15:22:30 +020059static int kobject_action_type(const char *buf, size_t count,
60 enum kobject_action *type,
61 const char **args)
Kay Sievers5c5daf62007-08-12 20:43:55 +020062{
63 enum kobject_action action;
Peter Rajnohaf36776f2017-05-09 15:22:30 +020064 size_t count_first;
65 const char *args_start;
Kay Sievers5c5daf62007-08-12 20:43:55 +020066 int ret = -EINVAL;
67
Mark Lorda9edadb2008-03-28 19:05:25 -040068 if (count && (buf[count-1] == '\n' || buf[count-1] == '\0'))
Kay Sievers5c5daf62007-08-12 20:43:55 +020069 count--;
70
71 if (!count)
72 goto out;
73
Peter Rajnohaf36776f2017-05-09 15:22:30 +020074 args_start = strnchr(buf, count, ' ');
75 if (args_start) {
76 count_first = args_start - buf;
77 args_start = args_start + 1;
78 } else
79 count_first = count;
80
Kay Sievers5c5daf62007-08-12 20:43:55 +020081 for (action = 0; action < ARRAY_SIZE(kobject_actions); action++) {
Peter Rajnohaf36776f2017-05-09 15:22:30 +020082 if (strncmp(kobject_actions[action], buf, count_first) != 0)
Kay Sievers5c5daf62007-08-12 20:43:55 +020083 continue;
Peter Rajnohaf36776f2017-05-09 15:22:30 +020084 if (kobject_actions[action][count_first] != '\0')
Kay Sievers5c5daf62007-08-12 20:43:55 +020085 continue;
Peter Rajnohaf36776f2017-05-09 15:22:30 +020086 if (args)
87 *args = args_start;
Kay Sievers5c5daf62007-08-12 20:43:55 +020088 *type = action;
89 ret = 0;
90 break;
91 }
92out:
93 return ret;
94}
95
Peter Rajnohaf36776f2017-05-09 15:22:30 +020096static const char *action_arg_word_end(const char *buf, const char *buf_end,
97 char delim)
98{
99 const char *next = buf;
100
101 while (next <= buf_end && *next != delim)
102 if (!isalnum(*next++))
103 return NULL;
104
105 if (next == buf)
106 return NULL;
107
108 return next;
109}
110
111static int kobject_action_args(const char *buf, size_t count,
112 struct kobj_uevent_env **ret_env)
113{
114 struct kobj_uevent_env *env = NULL;
115 const char *next, *buf_end, *key;
116 int key_len;
117 int r = -EINVAL;
118
119 if (count && (buf[count - 1] == '\n' || buf[count - 1] == '\0'))
120 count--;
121
122 if (!count)
123 return -EINVAL;
124
125 env = kzalloc(sizeof(*env), GFP_KERNEL);
126 if (!env)
127 return -ENOMEM;
128
129 /* first arg is UUID */
130 if (count < UUID_STRING_LEN || !uuid_is_valid(buf) ||
131 add_uevent_var(env, "SYNTH_UUID=%.*s", UUID_STRING_LEN, buf))
132 goto out;
133
134 /*
135 * the rest are custom environment variables in KEY=VALUE
136 * format with ' ' delimiter between each KEY=VALUE pair
137 */
138 next = buf + UUID_STRING_LEN;
139 buf_end = buf + count - 1;
140
141 while (next <= buf_end) {
142 if (*next != ' ')
143 goto out;
144
145 /* skip the ' ', key must follow */
146 key = ++next;
147 if (key > buf_end)
148 goto out;
149
150 buf = next;
151 next = action_arg_word_end(buf, buf_end, '=');
152 if (!next || next > buf_end || *next != '=')
153 goto out;
154 key_len = next - buf;
155
156 /* skip the '=', value must follow */
157 if (++next > buf_end)
158 goto out;
159
160 buf = next;
161 next = action_arg_word_end(buf, buf_end, ' ');
162 if (!next)
163 goto out;
164
165 if (add_uevent_var(env, "SYNTH_ARG_%.*s=%.*s",
166 key_len, key, (int) (next - buf), buf))
167 goto out;
168 }
169
170 r = 0;
171out:
172 if (r)
173 kfree(env);
174 else
175 *ret_env = env;
176 return r;
177}
178
179/**
180 * kobject_synth_uevent - send synthetic uevent with arguments
181 *
182 * @kobj: struct kobject for which synthetic uevent is to be generated
183 * @buf: buffer containing action type and action args, newline is ignored
184 * @count: length of buffer
185 *
186 * Returns 0 if kobject_synthetic_uevent() is completed with success or the
187 * corresponding error when it fails.
188 */
189int kobject_synth_uevent(struct kobject *kobj, const char *buf, size_t count)
190{
191 char *no_uuid_envp[] = { "SYNTH_UUID=0", NULL };
192 enum kobject_action action;
193 const char *action_args;
194 struct kobj_uevent_env *env;
195 const char *msg = NULL, *devpath;
196 int r;
197
198 r = kobject_action_type(buf, count, &action, &action_args);
199 if (r) {
200 msg = "unknown uevent action string\n";
201 goto out;
202 }
203
204 if (!action_args) {
205 r = kobject_uevent_env(kobj, action, no_uuid_envp);
206 goto out;
207 }
208
209 r = kobject_action_args(action_args,
210 count - (action_args - buf), &env);
211 if (r == -EINVAL) {
212 msg = "incorrect uevent action arguments\n";
213 goto out;
214 }
215
216 if (r)
217 goto out;
218
219 r = kobject_uevent_env(kobj, action, env->envp);
220 kfree(env);
221out:
222 if (r) {
223 devpath = kobject_get_path(kobj, GFP_KERNEL);
224 printk(KERN_WARNING "synth uevent: %s: %s",
225 devpath ?: "unknown device",
226 msg ?: "failed to send uevent");
227 kfree(devpath);
228 }
229 return r;
230}
231
Andrew Mortonc8421282010-05-21 15:05:21 -0700232#ifdef CONFIG_NET
Eric W. Biederman5f71a292010-05-04 17:36:47 -0700233static int kobj_bcast_filter(struct sock *dsk, struct sk_buff *skb, void *data)
234{
Weilong Chen82ef3d52014-01-16 17:24:31 +0800235 struct kobject *kobj = data, *ksobj;
Eric W. Biederman5f71a292010-05-04 17:36:47 -0700236 const struct kobj_ns_type_operations *ops;
237
238 ops = kobj_ns_ops(kobj);
Weilong Chen82ef3d52014-01-16 17:24:31 +0800239 if (!ops && kobj->kset) {
240 ksobj = &kobj->kset->kobj;
241 if (ksobj->parent != NULL)
242 ops = kobj_ns_ops(ksobj->parent);
243 }
244
245 if (ops && ops->netlink_ns && kobj->ktype->namespace) {
Eric W. Biederman5f71a292010-05-04 17:36:47 -0700246 const void *sock_ns, *ns;
247 ns = kobj->ktype->namespace(kobj);
248 sock_ns = ops->netlink_ns(dsk);
249 return sock_ns != ns;
250 }
251
252 return 0;
253}
Andrew Mortonc8421282010-05-21 15:05:21 -0700254#endif
Eric W. Biederman5f71a292010-05-04 17:36:47 -0700255
Michael Marineau86d56132014-04-10 14:09:31 -0700256#ifdef CONFIG_UEVENT_HELPER
Eric W. Biederman417daa12010-05-04 17:36:48 -0700257static int kobj_usermode_filter(struct kobject *kobj)
258{
259 const struct kobj_ns_type_operations *ops;
260
261 ops = kobj_ns_ops(kobj);
262 if (ops) {
263 const void *init_ns, *ns;
264 ns = kobj->ktype->namespace(kobj);
265 init_ns = ops->initial_ns();
266 return ns != init_ns;
267 }
268
269 return 0;
270}
271
Vladimir Davydovbcccff92014-04-03 14:48:21 -0700272static int init_uevent_argv(struct kobj_uevent_env *env, const char *subsystem)
273{
274 int len;
275
276 len = strlcpy(&env->buf[env->buflen], subsystem,
277 sizeof(env->buf) - env->buflen);
278 if (len >= (sizeof(env->buf) - env->buflen)) {
279 WARN(1, KERN_ERR "init_uevent_argv: buffer size too small\n");
280 return -ENOMEM;
281 }
282
283 env->argv[0] = uevent_helper;
284 env->argv[1] = &env->buf[env->buflen];
285 env->argv[2] = NULL;
286
287 env->buflen += len + 1;
288 return 0;
289}
290
291static void cleanup_uevent_env(struct subprocess_info *info)
292{
293 kfree(info->data);
294}
Michael Marineau86d56132014-04-10 14:09:31 -0700295#endif
Vladimir Davydovbcccff92014-04-03 14:48:21 -0700296
Eric Dumazet16dff332017-09-19 16:27:03 -0700297static int kobject_uevent_net_broadcast(struct kobject *kobj,
298 struct kobj_uevent_env *env,
299 const char *action_string,
300 const char *devpath)
301{
302 int retval = 0;
303#if defined(CONFIG_NET)
Eric Dumazetd464e842017-09-19 16:27:05 -0700304 struct sk_buff *skb = NULL;
Eric Dumazet16dff332017-09-19 16:27:03 -0700305 struct uevent_sock *ue_sk;
306
307 /* send netlink message */
308 list_for_each_entry(ue_sk, &uevent_sock_list, list) {
309 struct sock *uevent_sock = ue_sk->sk;
Eric Dumazet16dff332017-09-19 16:27:03 -0700310
311 if (!netlink_has_listeners(uevent_sock, 1))
312 continue;
313
Eric Dumazetd464e842017-09-19 16:27:05 -0700314 if (!skb) {
315 /* allocate message with the maximum possible size */
316 size_t len = strlen(action_string) + strlen(devpath) + 2;
Eric Dumazet16dff332017-09-19 16:27:03 -0700317 char *scratch;
Eric Dumazet16dff332017-09-19 16:27:03 -0700318
Eric Dumazetd464e842017-09-19 16:27:05 -0700319 retval = -ENOMEM;
320 skb = alloc_skb(len + env->buflen, GFP_KERNEL);
321 if (!skb)
322 continue;
323
Eric Dumazet16dff332017-09-19 16:27:03 -0700324 /* add header */
325 scratch = skb_put(skb, len);
326 sprintf(scratch, "%s@%s", action_string, devpath);
327
Eric Dumazet4a336a22017-09-19 16:27:04 -0700328 skb_put_data(skb, env->buf, env->buflen);
Eric Dumazet16dff332017-09-19 16:27:03 -0700329
330 NETLINK_CB(skb).dst_group = 1;
Eric Dumazetd464e842017-09-19 16:27:05 -0700331 }
332
333 retval = netlink_broadcast_filtered(uevent_sock, skb_get(skb),
334 0, 1, GFP_KERNEL,
335 kobj_bcast_filter,
336 kobj);
337 /* ENOBUFS should be handled in userspace */
338 if (retval == -ENOBUFS || retval == -ESRCH)
339 retval = 0;
Eric Dumazet16dff332017-09-19 16:27:03 -0700340 }
Eric Dumazetd464e842017-09-19 16:27:05 -0700341 consume_skb(skb);
Eric Dumazet16dff332017-09-19 16:27:03 -0700342#endif
343 return retval;
344}
345
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700346static void zap_modalias_env(struct kobj_uevent_env *env)
347{
348 static const char modalias_prefix[] = "MODALIAS=";
Dmitry Torokhov9b3fa472017-12-13 15:21:22 -0800349 size_t len;
350 int i, j;
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700351
352 for (i = 0; i < env->envp_idx;) {
353 if (strncmp(env->envp[i], modalias_prefix,
354 sizeof(modalias_prefix) - 1)) {
355 i++;
356 continue;
357 }
358
Dmitry Torokhov9b3fa472017-12-13 15:21:22 -0800359 len = strlen(env->envp[i]) + 1;
360
361 if (i != env->envp_idx - 1) {
362 memmove(env->envp[i], env->envp[i + 1],
363 env->buflen - len);
364
365 for (j = i; j < env->envp_idx - 1; j++)
366 env->envp[j] = env->envp[j + 1] - len;
367 }
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700368
369 env->envp_idx--;
Dmitry Torokhov9b3fa472017-12-13 15:21:22 -0800370 env->buflen -= len;
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700371 }
372}
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374/**
Cornelia Huck8a824722006-11-20 17:07:51 +0100375 * kobject_uevent_env - send an uevent with environmental data
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 * @kobj: struct kobject that the action is happening to
Julia Lawalledbbf992016-10-01 21:46:28 +0200378 * @action: action that is happening
Cornelia Huck8a824722006-11-20 17:07:51 +0100379 * @envp_ext: pointer to environmental data
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800380 *
Xiaotian Fengf6e6e772010-08-13 18:58:10 +0800381 * Returns 0 if kobject_uevent_env() is completed with success or the
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800382 * corresponding error when it fails.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 */
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800384int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
Kay Sievers7eff2e72007-08-14 15:15:12 +0200385 char *envp_ext[])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386{
Kay Sievers7eff2e72007-08-14 15:15:12 +0200387 struct kobj_uevent_env *env;
388 const char *action_string = kobject_actions[action];
Kay Sievers5f123fb2005-11-11 14:43:07 +0100389 const char *devpath = NULL;
390 const char *subsystem;
391 struct kobject *top_kobj;
392 struct kset *kset;
Emese Revfy9cd43612009-12-31 14:52:51 +0100393 const struct kset_uevent_ops *uevent_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394 int i = 0;
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800395 int retval = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
Greg Kroah-Hartman9f66fa22007-11-28 23:49:41 -0800397 pr_debug("kobject: '%s' (%p): %s\n",
Harvey Harrison810304d2008-04-30 00:55:08 -0700398 kobject_name(kobj), kobj, __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
Kay Sievers5f123fb2005-11-11 14:43:07 +0100400 /* search the kset we belong to */
401 top_kobj = kobj;
Kay Sieversccd490a2007-08-12 20:43:55 +0200402 while (!top_kobj->kset && top_kobj->parent)
John Anthony Kazos Jr14193fb2007-04-04 07:39:17 -0400403 top_kobj = top_kobj->parent;
Kay Sieversccd490a2007-08-12 20:43:55 +0200404
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800405 if (!top_kobj->kset) {
Greg Kroah-Hartman9f66fa22007-11-28 23:49:41 -0800406 pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "
407 "without kset!\n", kobject_name(kobj), kobj,
Harvey Harrison810304d2008-04-30 00:55:08 -0700408 __func__);
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800409 return -EINVAL;
410 }
Kay Sievers5f123fb2005-11-11 14:43:07 +0100411
412 kset = top_kobj->kset;
Kay Sievers312c0042005-11-16 09:00:00 +0100413 uevent_ops = kset->uevent_ops;
Kay Sievers5f123fb2005-11-11 14:43:07 +0100414
Ming Leif67f1292009-03-01 21:10:49 +0800415 /* skip the event, if uevent_suppress is set*/
416 if (kobj->uevent_suppress) {
417 pr_debug("kobject: '%s' (%p): %s: uevent_suppress "
418 "caused the event to drop!\n",
419 kobject_name(kobj), kobj, __func__);
420 return 0;
421 }
Kay Sievers7eff2e72007-08-14 15:15:12 +0200422 /* skip the event, if the filter returns zero. */
Kay Sievers312c0042005-11-16 09:00:00 +0100423 if (uevent_ops && uevent_ops->filter)
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800424 if (!uevent_ops->filter(kset, kobj)) {
Greg Kroah-Hartman9f66fa22007-11-28 23:49:41 -0800425 pr_debug("kobject: '%s' (%p): %s: filter function "
426 "caused the event to drop!\n",
Harvey Harrison810304d2008-04-30 00:55:08 -0700427 kobject_name(kobj), kobj, __func__);
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800428 return 0;
429 }
Kay Sievers5f123fb2005-11-11 14:43:07 +0100430
Kay Sievers86406242007-03-14 03:25:56 +0100431 /* originating subsystem */
432 if (uevent_ops && uevent_ops->name)
433 subsystem = uevent_ops->name(kset, kobj);
434 else
435 subsystem = kobject_name(&kset->kobj);
436 if (!subsystem) {
Greg Kroah-Hartman9f66fa22007-11-28 23:49:41 -0800437 pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "
438 "event to drop!\n", kobject_name(kobj), kobj,
Harvey Harrison810304d2008-04-30 00:55:08 -0700439 __func__);
Kay Sievers86406242007-03-14 03:25:56 +0100440 return 0;
441 }
442
Kay Sievers7eff2e72007-08-14 15:15:12 +0200443 /* environment buffer */
444 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
445 if (!env)
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800446 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Kay Sievers5f123fb2005-11-11 14:43:07 +0100448 /* complete object path */
449 devpath = kobject_get_path(kobj, GFP_KERNEL);
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800450 if (!devpath) {
451 retval = -ENOENT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 goto exit;
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800453 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
Kay Sievers5f123fb2005-11-11 14:43:07 +0100455 /* default keys */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200456 retval = add_uevent_var(env, "ACTION=%s", action_string);
457 if (retval)
458 goto exit;
459 retval = add_uevent_var(env, "DEVPATH=%s", devpath);
460 if (retval)
461 goto exit;
462 retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
463 if (retval)
464 goto exit;
465
466 /* keys passed in from the caller */
467 if (envp_ext) {
468 for (i = 0; envp_ext[i]; i++) {
Tejun Heoc65b9142008-11-13 13:20:00 +0900469 retval = add_uevent_var(env, "%s", envp_ext[i]);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200470 if (retval)
471 goto exit;
472 }
473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
Kay Sievers5f123fb2005-11-11 14:43:07 +0100475 /* let the kset specific function add its stuff */
Kay Sievers312c0042005-11-16 09:00:00 +0100476 if (uevent_ops && uevent_ops->uevent) {
Kay Sievers7eff2e72007-08-14 15:15:12 +0200477 retval = uevent_ops->uevent(kset, kobj, env);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 if (retval) {
Greg Kroah-Hartman9f66fa22007-11-28 23:49:41 -0800479 pr_debug("kobject: '%s' (%p): %s: uevent() returned "
480 "%d\n", kobject_name(kobj), kobj,
Harvey Harrison810304d2008-04-30 00:55:08 -0700481 __func__, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 goto exit;
483 }
484 }
485
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700486 switch (action) {
487 case KOBJ_ADD:
488 /*
489 * Mark "add" event so we can make sure we deliver "remove"
490 * event to userspace during automatic cleanup. If
491 * the object did send an "add" event, "remove" will
492 * automatically generated by the core, if not already done
493 * by the caller.
494 */
Kay Sievers0f4dafc2007-12-19 01:40:42 +0100495 kobj->state_add_uevent_sent = 1;
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700496 break;
497
498 case KOBJ_REMOVE:
Kay Sievers0f4dafc2007-12-19 01:40:42 +0100499 kobj->state_remove_uevent_sent = 1;
Dmitry Torokhov6878e7d2017-09-13 16:29:48 -0700500 break;
501
502 case KOBJ_UNBIND:
503 zap_modalias_env(env);
504 break;
505
506 default:
507 break;
508 }
Kay Sievers0f4dafc2007-12-19 01:40:42 +0100509
Andrew Vagin7b60a182012-03-07 14:49:56 +0400510 mutex_lock(&uevent_sock_mutex);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200511 /* we will send an event, so request a new sequence number */
Andrew Vagin7b60a182012-03-07 14:49:56 +0400512 retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)++uevent_seqnum);
513 if (retval) {
514 mutex_unlock(&uevent_sock_mutex);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200515 goto exit;
Andrew Vagin7b60a182012-03-07 14:49:56 +0400516 }
Eric Dumazet16dff332017-09-19 16:27:03 -0700517 retval = kobject_uevent_net_broadcast(kobj, env, action_string,
518 devpath);
Andrew Vagin7b60a182012-03-07 14:49:56 +0400519 mutex_unlock(&uevent_sock_mutex);
Kay Sievers5f123fb2005-11-11 14:43:07 +0100520
Michael Marineau86d56132014-04-10 14:09:31 -0700521#ifdef CONFIG_UEVENT_HELPER
Kay Sievers5f123fb2005-11-11 14:43:07 +0100522 /* call uevent_helper, usually only enabled during early boot */
Eric W. Biederman417daa12010-05-04 17:36:48 -0700523 if (uevent_helper[0] && !kobj_usermode_filter(kobj)) {
Vladimir Davydovbcccff92014-04-03 14:48:21 -0700524 struct subprocess_info *info;
Kay Sievers5f123fb2005-11-11 14:43:07 +0100525
Kay Sievers7eff2e72007-08-14 15:15:12 +0200526 retval = add_uevent_var(env, "HOME=/");
527 if (retval)
528 goto exit;
Greg Kroah-Hartmane374a2b2008-01-24 21:59:04 -0800529 retval = add_uevent_var(env,
530 "PATH=/sbin:/bin:/usr/sbin:/usr/bin");
Kay Sievers7eff2e72007-08-14 15:15:12 +0200531 if (retval)
532 goto exit;
Vladimir Davydovbcccff92014-04-03 14:48:21 -0700533 retval = init_uevent_argv(env, subsystem);
534 if (retval)
535 goto exit;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200536
Vladimir Davydovbcccff92014-04-03 14:48:21 -0700537 retval = -ENOMEM;
538 info = call_usermodehelper_setup(env->argv[0], env->argv,
539 env->envp, GFP_KERNEL,
540 NULL, cleanup_uevent_env, env);
541 if (info) {
542 retval = call_usermodehelper_exec(info, UMH_NO_WAIT);
543 env = NULL; /* freed by cleanup_uevent_env */
544 }
Kay Sievers5f123fb2005-11-11 14:43:07 +0100545 }
Michael Marineau86d56132014-04-10 14:09:31 -0700546#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
548exit:
Kay Sievers5f123fb2005-11-11 14:43:07 +0100549 kfree(devpath);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200550 kfree(env);
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800551 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552}
Cornelia Huck8a824722006-11-20 17:07:51 +0100553EXPORT_SYMBOL_GPL(kobject_uevent_env);
554
555/**
Xiaotian Fengf6e6e772010-08-13 18:58:10 +0800556 * kobject_uevent - notify userspace by sending an uevent
Cornelia Huck8a824722006-11-20 17:07:51 +0100557 *
Cornelia Huck8a824722006-11-20 17:07:51 +0100558 * @kobj: struct kobject that the action is happening to
Julia Lawalledbbf992016-10-01 21:46:28 +0200559 * @action: action that is happening
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800560 *
561 * Returns 0 if kobject_uevent() is completed with success or the
562 * corresponding error when it fails.
Cornelia Huck8a824722006-11-20 17:07:51 +0100563 */
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800564int kobject_uevent(struct kobject *kobj, enum kobject_action action)
Cornelia Huck8a824722006-11-20 17:07:51 +0100565{
Aneesh Kumar K.V542cfce2006-12-19 13:01:27 -0800566 return kobject_uevent_env(kobj, action, NULL);
Cornelia Huck8a824722006-11-20 17:07:51 +0100567}
Kay Sievers312c0042005-11-16 09:00:00 +0100568EXPORT_SYMBOL_GPL(kobject_uevent);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569
570/**
Kay Sievers7eff2e72007-08-14 15:15:12 +0200571 * add_uevent_var - add key value string to the environment buffer
572 * @env: environment buffer structure
573 * @format: printf format for the key=value pair
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 *
575 * Returns 0 if environment variable was added successfully or -ENOMEM
576 * if no space was available.
577 */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200578int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
580 va_list args;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200581 int len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582
Kay Sievers7eff2e72007-08-14 15:15:12 +0200583 if (env->envp_idx >= ARRAY_SIZE(env->envp)) {
Arjan van de Ven5cd2b452008-07-25 19:45:39 -0700584 WARN(1, KERN_ERR "add_uevent_var: too many keys\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 return -ENOMEM;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200586 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587
588 va_start(args, format);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200589 len = vsnprintf(&env->buf[env->buflen],
590 sizeof(env->buf) - env->buflen,
591 format, args);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 va_end(args);
593
Kay Sievers7eff2e72007-08-14 15:15:12 +0200594 if (len >= (sizeof(env->buf) - env->buflen)) {
Arjan van de Ven5cd2b452008-07-25 19:45:39 -0700595 WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 return -ENOMEM;
Kay Sievers7eff2e72007-08-14 15:15:12 +0200597 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
Kay Sievers7eff2e72007-08-14 15:15:12 +0200599 env->envp[env->envp_idx++] = &env->buf[env->buflen];
600 env->buflen += len + 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601 return 0;
602}
Kay Sievers312c0042005-11-16 09:00:00 +0100603EXPORT_SYMBOL_GPL(add_uevent_var);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604
Kay Sievers4d17ffd2006-04-25 15:37:26 +0200605#if defined(CONFIG_NET)
Eric W. Biederman07e98962010-05-04 17:36:44 -0700606static int uevent_net_init(struct net *net)
Kay Sievers5f123fb2005-11-11 14:43:07 +0100607{
Eric W. Biederman07e98962010-05-04 17:36:44 -0700608 struct uevent_sock *ue_sk;
Pablo Neira Ayusoa31f2d12012-06-29 06:15:21 +0000609 struct netlink_kernel_cfg cfg = {
610 .groups = 1,
Pablo Neira Ayuso9785e102012-09-08 02:53:53 +0000611 .flags = NL_CFG_F_NONROOT_RECV,
Pablo Neira Ayusoa31f2d12012-06-29 06:15:21 +0000612 };
Eric W. Biederman07e98962010-05-04 17:36:44 -0700613
614 ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);
615 if (!ue_sk)
616 return -ENOMEM;
617
Pablo Neira Ayuso9f00d972012-09-08 02:53:54 +0000618 ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT, &cfg);
Eric W. Biederman07e98962010-05-04 17:36:44 -0700619 if (!ue_sk->sk) {
Kay Sievers5f123fb2005-11-11 14:43:07 +0100620 printk(KERN_ERR
621 "kobject_uevent: unable to create netlink socket!\n");
Dan Carpenter743db2d2010-05-25 11:51:10 +0200622 kfree(ue_sk);
Kay Sievers5f123fb2005-11-11 14:43:07 +0100623 return -ENODEV;
624 }
Eric W. Biederman07e98962010-05-04 17:36:44 -0700625 mutex_lock(&uevent_sock_mutex);
626 list_add_tail(&ue_sk->list, &uevent_sock_list);
627 mutex_unlock(&uevent_sock_mutex);
Kay Sievers5f123fb2005-11-11 14:43:07 +0100628 return 0;
629}
630
Eric W. Biederman07e98962010-05-04 17:36:44 -0700631static void uevent_net_exit(struct net *net)
632{
633 struct uevent_sock *ue_sk;
634
635 mutex_lock(&uevent_sock_mutex);
636 list_for_each_entry(ue_sk, &uevent_sock_list, list) {
637 if (sock_net(ue_sk->sk) == net)
638 goto found;
639 }
640 mutex_unlock(&uevent_sock_mutex);
641 return;
642
643found:
644 list_del(&ue_sk->list);
645 mutex_unlock(&uevent_sock_mutex);
646
647 netlink_kernel_release(ue_sk->sk);
648 kfree(ue_sk);
649}
650
651static struct pernet_operations uevent_net_ops = {
652 .init = uevent_net_init,
653 .exit = uevent_net_exit,
654};
655
656static int __init kobject_uevent_init(void)
657{
Eric W. Biederman07e98962010-05-04 17:36:44 -0700658 return register_pernet_subsys(&uevent_net_ops);
659}
660
661
Kay Sievers5f123fb2005-11-11 14:43:07 +0100662postcore_initcall(kobject_uevent_init);
Kay Sievers4d17ffd2006-04-25 15:37:26 +0200663#endif