Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * kernel userspace event delivery
4 : *
5 : * Copyright (C) 2004 Red Hat, Inc. All rights reserved.
6 : * Copyright (C) 2004 Novell, Inc. All rights reserved.
7 : * Copyright (C) 2004 IBM, Inc. All rights reserved.
8 : *
9 : * Authors:
10 : * Robert Love <rml@novell.com>
11 : * Kay Sievers <kay.sievers@vrfy.org>
12 : * Arjan van de Ven <arjanv@redhat.com>
13 : * Greg Kroah-Hartman <greg@kroah.com>
14 : */
15 :
16 : #include <linux/spinlock.h>
17 : #include <linux/string.h>
18 : #include <linux/kobject.h>
19 : #include <linux/export.h>
20 : #include <linux/kmod.h>
21 : #include <linux/slab.h>
22 : #include <linux/socket.h>
23 : #include <linux/skbuff.h>
24 : #include <linux/netlink.h>
25 : #include <linux/uidgid.h>
26 : #include <linux/uuid.h>
27 : #include <linux/ctype.h>
28 : #include <net/sock.h>
29 : #include <net/netlink.h>
30 : #include <net/net_namespace.h>
31 :
32 :
33 : u64 uevent_seqnum;
34 : #ifdef CONFIG_UEVENT_HELPER
35 : char uevent_helper[UEVENT_HELPER_PATH_LEN] = CONFIG_UEVENT_HELPER_PATH;
36 : #endif
37 :
38 : struct uevent_sock {
39 : struct list_head list;
40 : struct sock *sk;
41 : };
42 :
43 : #ifdef CONFIG_NET
44 : static LIST_HEAD(uevent_sock_list);
45 : #endif
46 :
47 : /* This lock protects uevent_seqnum and uevent_sock_list */
48 : static DEFINE_MUTEX(uevent_sock_mutex);
49 :
50 : /* the strings here must match the enum in include/linux/kobject.h */
51 : static const char *kobject_actions[] = {
52 : [KOBJ_ADD] = "add",
53 : [KOBJ_REMOVE] = "remove",
54 : [KOBJ_CHANGE] = "change",
55 : [KOBJ_MOVE] = "move",
56 : [KOBJ_ONLINE] = "online",
57 : [KOBJ_OFFLINE] = "offline",
58 : [KOBJ_BIND] = "bind",
59 : [KOBJ_UNBIND] = "unbind",
60 : };
61 :
62 171 : static int kobject_action_type(const char *buf, size_t count,
63 : enum kobject_action *type,
64 : const char **args)
65 : {
66 171 : enum kobject_action action;
67 171 : size_t count_first;
68 171 : const char *args_start;
69 171 : int ret = -EINVAL;
70 :
71 171 : if (count && (buf[count-1] == '\n' || buf[count-1] == '\0'))
72 171 : count--;
73 :
74 171 : if (!count)
75 0 : goto out;
76 :
77 171 : args_start = strnchr(buf, count, ' ');
78 171 : if (args_start) {
79 0 : count_first = args_start - buf;
80 0 : args_start = args_start + 1;
81 : } else
82 : count_first = count;
83 :
84 171 : for (action = 0; action < ARRAY_SIZE(kobject_actions); action++) {
85 171 : if (strncmp(kobject_actions[action], buf, count_first) != 0)
86 0 : continue;
87 171 : if (kobject_actions[action][count_first] != '\0')
88 0 : continue;
89 171 : if (args)
90 171 : *args = args_start;
91 171 : *type = action;
92 171 : ret = 0;
93 171 : break;
94 : }
95 0 : out:
96 171 : return ret;
97 : }
98 :
99 0 : static const char *action_arg_word_end(const char *buf, const char *buf_end,
100 : char delim)
101 : {
102 0 : const char *next = buf;
103 :
104 0 : while (next <= buf_end && *next != delim)
105 0 : if (!isalnum(*next++))
106 : return NULL;
107 :
108 0 : if (next == buf)
109 0 : return NULL;
110 :
111 : return next;
112 : }
113 :
114 0 : static int kobject_action_args(const char *buf, size_t count,
115 : struct kobj_uevent_env **ret_env)
116 : {
117 0 : struct kobj_uevent_env *env = NULL;
118 0 : const char *next, *buf_end, *key;
119 0 : int key_len;
120 0 : int r = -EINVAL;
121 :
122 0 : if (count && (buf[count - 1] == '\n' || buf[count - 1] == '\0'))
123 0 : count--;
124 :
125 0 : if (!count)
126 : return -EINVAL;
127 :
128 0 : env = kzalloc(sizeof(*env), GFP_KERNEL);
129 0 : if (!env)
130 : return -ENOMEM;
131 :
132 : /* first arg is UUID */
133 0 : if (count < UUID_STRING_LEN || !uuid_is_valid(buf) ||
134 0 : add_uevent_var(env, "SYNTH_UUID=%.*s", UUID_STRING_LEN, buf))
135 0 : goto out;
136 :
137 : /*
138 : * the rest are custom environment variables in KEY=VALUE
139 : * format with ' ' delimiter between each KEY=VALUE pair
140 : */
141 0 : next = buf + UUID_STRING_LEN;
142 0 : buf_end = buf + count - 1;
143 :
144 0 : while (next <= buf_end) {
145 0 : if (*next != ' ')
146 0 : goto out;
147 :
148 : /* skip the ' ', key must follow */
149 0 : key = ++next;
150 0 : if (key > buf_end)
151 0 : goto out;
152 :
153 0 : buf = next;
154 0 : next = action_arg_word_end(buf, buf_end, '=');
155 0 : if (!next || next > buf_end || *next != '=')
156 0 : goto out;
157 0 : key_len = next - buf;
158 :
159 : /* skip the '=', value must follow */
160 0 : if (++next > buf_end)
161 0 : goto out;
162 :
163 0 : buf = next;
164 0 : next = action_arg_word_end(buf, buf_end, ' ');
165 0 : if (!next)
166 0 : goto out;
167 :
168 0 : if (add_uevent_var(env, "SYNTH_ARG_%.*s=%.*s",
169 0 : key_len, key, (int) (next - buf), buf))
170 0 : goto out;
171 : }
172 :
173 : r = 0;
174 0 : out:
175 0 : if (r)
176 0 : kfree(env);
177 : else
178 0 : *ret_env = env;
179 : return r;
180 : }
181 :
182 : /**
183 : * kobject_synth_uevent - send synthetic uevent with arguments
184 : *
185 : * @kobj: struct kobject for which synthetic uevent is to be generated
186 : * @buf: buffer containing action type and action args, newline is ignored
187 : * @count: length of buffer
188 : *
189 : * Returns 0 if kobject_synthetic_uevent() is completed with success or the
190 : * corresponding error when it fails.
191 : */
192 171 : int kobject_synth_uevent(struct kobject *kobj, const char *buf, size_t count)
193 : {
194 171 : char *no_uuid_envp[] = { "SYNTH_UUID=0", NULL };
195 171 : enum kobject_action action;
196 171 : const char *action_args;
197 171 : struct kobj_uevent_env *env;
198 171 : const char *msg = NULL, *devpath;
199 171 : int r;
200 :
201 171 : r = kobject_action_type(buf, count, &action, &action_args);
202 171 : if (r) {
203 0 : msg = "unknown uevent action string";
204 0 : goto out;
205 : }
206 :
207 171 : if (!action_args) {
208 171 : r = kobject_uevent_env(kobj, action, no_uuid_envp);
209 171 : goto out;
210 : }
211 :
212 0 : r = kobject_action_args(action_args,
213 0 : count - (action_args - buf), &env);
214 0 : if (r == -EINVAL) {
215 0 : msg = "incorrect uevent action arguments";
216 0 : goto out;
217 : }
218 :
219 0 : if (r)
220 0 : goto out;
221 :
222 0 : r = kobject_uevent_env(kobj, action, env->envp);
223 0 : kfree(env);
224 171 : out:
225 171 : if (r) {
226 0 : devpath = kobject_get_path(kobj, GFP_KERNEL);
227 0 : pr_warn("synth uevent: %s: %s\n",
228 : devpath ?: "unknown device",
229 : msg ?: "failed to send uevent");
230 0 : kfree(devpath);
231 : }
232 171 : return r;
233 : }
234 :
235 : #ifdef CONFIG_UEVENT_HELPER
236 0 : static int kobj_usermode_filter(struct kobject *kobj)
237 : {
238 0 : const struct kobj_ns_type_operations *ops;
239 :
240 0 : ops = kobj_ns_ops(kobj);
241 0 : if (ops) {
242 0 : const void *init_ns, *ns;
243 :
244 0 : ns = kobj->ktype->namespace(kobj);
245 0 : init_ns = ops->initial_ns();
246 0 : return ns != init_ns;
247 : }
248 :
249 : return 0;
250 : }
251 :
252 0 : static int init_uevent_argv(struct kobj_uevent_env *env, const char *subsystem)
253 : {
254 0 : int len;
255 :
256 0 : len = strlcpy(&env->buf[env->buflen], subsystem,
257 0 : sizeof(env->buf) - env->buflen);
258 0 : if (len >= (sizeof(env->buf) - env->buflen)) {
259 0 : WARN(1, KERN_ERR "init_uevent_argv: buffer size too small\n");
260 0 : return -ENOMEM;
261 : }
262 :
263 0 : env->argv[0] = uevent_helper;
264 0 : env->argv[1] = &env->buf[env->buflen];
265 0 : env->argv[2] = NULL;
266 :
267 0 : env->buflen += len + 1;
268 0 : return 0;
269 : }
270 :
271 0 : static void cleanup_uevent_env(struct subprocess_info *info)
272 : {
273 0 : kfree(info->data);
274 0 : }
275 : #endif
276 :
277 : #ifdef CONFIG_NET
278 192 : static struct sk_buff *alloc_uevent_skb(struct kobj_uevent_env *env,
279 : const char *action_string,
280 : const char *devpath)
281 : {
282 192 : struct netlink_skb_parms *parms;
283 192 : struct sk_buff *skb = NULL;
284 192 : char *scratch;
285 192 : size_t len;
286 :
287 : /* allocate message with maximum possible size */
288 192 : len = strlen(action_string) + strlen(devpath) + 2;
289 192 : skb = alloc_skb(len + env->buflen, GFP_KERNEL);
290 192 : if (!skb)
291 : return NULL;
292 :
293 : /* add header */
294 192 : scratch = skb_put(skb, len);
295 192 : sprintf(scratch, "%s@%s", action_string, devpath);
296 :
297 192 : skb_put_data(skb, env->buf, env->buflen);
298 :
299 192 : parms = &NETLINK_CB(skb);
300 192 : parms->creds.uid = GLOBAL_ROOT_UID;
301 192 : parms->creds.gid = GLOBAL_ROOT_GID;
302 192 : parms->dst_group = 1;
303 192 : parms->portid = 0;
304 :
305 192 : return skb;
306 : }
307 :
308 471 : static int uevent_net_broadcast_untagged(struct kobj_uevent_env *env,
309 : const char *action_string,
310 : const char *devpath)
311 : {
312 471 : struct sk_buff *skb = NULL;
313 471 : struct uevent_sock *ue_sk;
314 471 : int retval = 0;
315 :
316 : /* send netlink message */
317 931 : list_for_each_entry(ue_sk, &uevent_sock_list, list) {
318 460 : struct sock *uevent_sock = ue_sk->sk;
319 :
320 460 : if (!netlink_has_listeners(uevent_sock, 1))
321 276 : continue;
322 :
323 184 : if (!skb) {
324 184 : retval = -ENOMEM;
325 184 : skb = alloc_uevent_skb(env, action_string, devpath);
326 184 : if (!skb)
327 0 : continue;
328 : }
329 :
330 184 : retval = netlink_broadcast(uevent_sock, skb_get(skb), 0, 1,
331 : GFP_KERNEL);
332 : /* ENOBUFS should be handled in userspace */
333 184 : if (retval == -ENOBUFS || retval == -ESRCH)
334 0 : retval = 0;
335 : }
336 471 : consume_skb(skb);
337 :
338 471 : return retval;
339 : }
340 :
341 8 : static int uevent_net_broadcast_tagged(struct sock *usk,
342 : struct kobj_uevent_env *env,
343 : const char *action_string,
344 : const char *devpath)
345 : {
346 8 : struct user_namespace *owning_user_ns = sock_net(usk)->user_ns;
347 8 : struct sk_buff *skb = NULL;
348 8 : int ret = 0;
349 :
350 8 : skb = alloc_uevent_skb(env, action_string, devpath);
351 8 : if (!skb)
352 : return -ENOMEM;
353 :
354 : /* fix credentials */
355 8 : if (owning_user_ns != &init_user_ns) {
356 0 : struct netlink_skb_parms *parms = &NETLINK_CB(skb);
357 0 : kuid_t root_uid;
358 0 : kgid_t root_gid;
359 :
360 : /* fix uid */
361 0 : root_uid = make_kuid(owning_user_ns, 0);
362 0 : if (uid_valid(root_uid))
363 0 : parms->creds.uid = root_uid;
364 :
365 : /* fix gid */
366 0 : root_gid = make_kgid(owning_user_ns, 0);
367 0 : if (gid_valid(root_gid))
368 0 : parms->creds.gid = root_gid;
369 : }
370 :
371 8 : ret = netlink_broadcast(usk, skb, 0, 1, GFP_KERNEL);
372 : /* ENOBUFS should be handled in userspace */
373 8 : if (ret == -ENOBUFS || ret == -ESRCH)
374 6 : ret = 0;
375 :
376 : return ret;
377 : }
378 : #endif
379 :
380 479 : static int kobject_uevent_net_broadcast(struct kobject *kobj,
381 : struct kobj_uevent_env *env,
382 : const char *action_string,
383 : const char *devpath)
384 : {
385 479 : int ret = 0;
386 :
387 : #ifdef CONFIG_NET
388 479 : const struct kobj_ns_type_operations *ops;
389 479 : const struct net *net = NULL;
390 :
391 479 : ops = kobj_ns_ops(kobj);
392 479 : if (!ops && kobj->kset) {
393 475 : struct kobject *ksobj = &kobj->kset->kobj;
394 :
395 475 : if (ksobj->parent != NULL)
396 34 : ops = kobj_ns_ops(ksobj->parent);
397 : }
398 :
399 : /* kobjects currently only carry network namespace tags and they
400 : * are the only tag relevant here since we want to decide which
401 : * network namespaces to broadcast the uevent into.
402 : */
403 479 : if (ops && ops->netlink_ns && kobj->ktype->namespace)
404 8 : if (ops->type == KOBJ_NS_TYPE_NET)
405 8 : net = kobj->ktype->namespace(kobj);
406 :
407 8 : if (!net)
408 471 : ret = uevent_net_broadcast_untagged(env, action_string,
409 : devpath);
410 : else
411 8 : ret = uevent_net_broadcast_tagged(net->uevent_sock->sk, env,
412 : action_string, devpath);
413 : #endif
414 :
415 479 : return ret;
416 : }
417 :
418 0 : static void zap_modalias_env(struct kobj_uevent_env *env)
419 : {
420 0 : static const char modalias_prefix[] = "MODALIAS=";
421 0 : size_t len;
422 0 : int i, j;
423 :
424 0 : for (i = 0; i < env->envp_idx;) {
425 0 : if (strncmp(env->envp[i], modalias_prefix,
426 : sizeof(modalias_prefix) - 1)) {
427 0 : i++;
428 0 : continue;
429 : }
430 :
431 0 : len = strlen(env->envp[i]) + 1;
432 :
433 0 : if (i != env->envp_idx - 1) {
434 0 : memmove(env->envp[i], env->envp[i + 1],
435 0 : env->buflen - len);
436 :
437 0 : for (j = i; j < env->envp_idx - 1; j++)
438 0 : env->envp[j] = env->envp[j + 1] - len;
439 : }
440 :
441 0 : env->envp_idx--;
442 0 : env->buflen -= len;
443 : }
444 0 : }
445 :
446 : /**
447 : * kobject_uevent_env - send an uevent with environmental data
448 : *
449 : * @kobj: struct kobject that the action is happening to
450 : * @action: action that is happening
451 : * @envp_ext: pointer to environmental data
452 : *
453 : * Returns 0 if kobject_uevent_env() is completed with success or the
454 : * corresponding error when it fails.
455 : */
456 633 : int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
457 : char *envp_ext[])
458 : {
459 633 : struct kobj_uevent_env *env;
460 633 : const char *action_string = kobject_actions[action];
461 633 : const char *devpath = NULL;
462 633 : const char *subsystem;
463 633 : struct kobject *top_kobj;
464 633 : struct kset *kset;
465 633 : const struct kset_uevent_ops *uevent_ops;
466 633 : int i = 0;
467 633 : int retval = 0;
468 :
469 : /*
470 : * Mark "remove" event done regardless of result, for some subsystems
471 : * do not want to re-trigger "remove" event via automatic cleanup.
472 : */
473 633 : if (action == KOBJ_REMOVE)
474 1 : kobj->state_remove_uevent_sent = 1;
475 :
476 633 : pr_debug("kobject: '%s' (%p): %s\n",
477 : kobject_name(kobj), kobj, __func__);
478 :
479 : /* search the kset we belong to */
480 633 : top_kobj = kobj;
481 676 : while (!top_kobj->kset && top_kobj->parent)
482 : top_kobj = top_kobj->parent;
483 :
484 633 : if (!top_kobj->kset) {
485 : pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "
486 : "without kset!\n", kobject_name(kobj), kobj,
487 : __func__);
488 : return -EINVAL;
489 : }
490 :
491 626 : kset = top_kobj->kset;
492 626 : uevent_ops = kset->uevent_ops;
493 :
494 : /* skip the event, if uevent_suppress is set*/
495 626 : if (kobj->uevent_suppress) {
496 : pr_debug("kobject: '%s' (%p): %s: uevent_suppress "
497 : "caused the event to drop!\n",
498 : kobject_name(kobj), kobj, __func__);
499 : return 0;
500 : }
501 : /* skip the event, if the filter returns zero. */
502 547 : if (uevent_ops && uevent_ops->filter)
503 498 : if (!uevent_ops->filter(kset, kobj)) {
504 : pr_debug("kobject: '%s' (%p): %s: filter function "
505 : "caused the event to drop!\n",
506 : kobject_name(kobj), kobj, __func__);
507 : return 0;
508 : }
509 :
510 : /* originating subsystem */
511 479 : if (uevent_ops && uevent_ops->name)
512 299 : subsystem = uevent_ops->name(kset, kobj);
513 : else
514 180 : subsystem = kobject_name(&kset->kobj);
515 479 : if (!subsystem) {
516 : pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "
517 : "event to drop!\n", kobject_name(kobj), kobj,
518 : __func__);
519 : return 0;
520 : }
521 :
522 : /* environment buffer */
523 479 : env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
524 479 : if (!env)
525 : return -ENOMEM;
526 :
527 : /* complete object path */
528 479 : devpath = kobject_get_path(kobj, GFP_KERNEL);
529 479 : if (!devpath) {
530 0 : retval = -ENOENT;
531 0 : goto exit;
532 : }
533 :
534 : /* default keys */
535 479 : retval = add_uevent_var(env, "ACTION=%s", action_string);
536 479 : if (retval)
537 0 : goto exit;
538 479 : retval = add_uevent_var(env, "DEVPATH=%s", devpath);
539 479 : if (retval)
540 0 : goto exit;
541 479 : retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
542 479 : if (retval)
543 0 : goto exit;
544 :
545 : /* keys passed in from the caller */
546 479 : if (envp_ext) {
547 342 : for (i = 0; envp_ext[i]; i++) {
548 171 : retval = add_uevent_var(env, "%s", envp_ext[i]);
549 171 : if (retval)
550 0 : goto exit;
551 : }
552 : }
553 :
554 : /* let the kset specific function add its stuff */
555 479 : if (uevent_ops && uevent_ops->uevent) {
556 299 : retval = uevent_ops->uevent(kset, kobj, env);
557 299 : if (retval) {
558 0 : pr_debug("kobject: '%s' (%p): %s: uevent() returned "
559 : "%d\n", kobject_name(kobj), kobj,
560 : __func__, retval);
561 0 : goto exit;
562 : }
563 : }
564 :
565 479 : switch (action) {
566 473 : case KOBJ_ADD:
567 : /*
568 : * Mark "add" event so we can make sure we deliver "remove"
569 : * event to userspace during automatic cleanup. If
570 : * the object did send an "add" event, "remove" will
571 : * automatically generated by the core, if not already done
572 : * by the caller.
573 : */
574 473 : kobj->state_add_uevent_sent = 1;
575 473 : break;
576 :
577 0 : case KOBJ_UNBIND:
578 0 : zap_modalias_env(env);
579 0 : break;
580 :
581 : default:
582 : break;
583 : }
584 :
585 479 : mutex_lock(&uevent_sock_mutex);
586 : /* we will send an event, so request a new sequence number */
587 479 : retval = add_uevent_var(env, "SEQNUM=%llu", ++uevent_seqnum);
588 479 : if (retval) {
589 0 : mutex_unlock(&uevent_sock_mutex);
590 0 : goto exit;
591 : }
592 479 : retval = kobject_uevent_net_broadcast(kobj, env, action_string,
593 : devpath);
594 479 : mutex_unlock(&uevent_sock_mutex);
595 :
596 : #ifdef CONFIG_UEVENT_HELPER
597 : /* call uevent_helper, usually only enabled during early boot */
598 479 : if (uevent_helper[0] && !kobj_usermode_filter(kobj)) {
599 0 : struct subprocess_info *info;
600 :
601 0 : retval = add_uevent_var(env, "HOME=/");
602 0 : if (retval)
603 0 : goto exit;
604 0 : retval = add_uevent_var(env,
605 : "PATH=/sbin:/bin:/usr/sbin:/usr/bin");
606 0 : if (retval)
607 0 : goto exit;
608 0 : retval = init_uevent_argv(env, subsystem);
609 0 : if (retval)
610 0 : goto exit;
611 :
612 0 : retval = -ENOMEM;
613 0 : info = call_usermodehelper_setup(env->argv[0], env->argv,
614 0 : env->envp, GFP_KERNEL,
615 : NULL, cleanup_uevent_env, env);
616 0 : if (info) {
617 0 : retval = call_usermodehelper_exec(info, UMH_NO_WAIT);
618 0 : env = NULL; /* freed by cleanup_uevent_env */
619 : }
620 : }
621 : #endif
622 :
623 479 : exit:
624 479 : kfree(devpath);
625 479 : kfree(env);
626 479 : return retval;
627 : }
628 : EXPORT_SYMBOL_GPL(kobject_uevent_env);
629 :
630 : /**
631 : * kobject_uevent - notify userspace by sending an uevent
632 : *
633 : * @kobj: struct kobject that the action is happening to
634 : * @action: action that is happening
635 : *
636 : * Returns 0 if kobject_uevent() is completed with success or the
637 : * corresponding error when it fails.
638 : */
639 462 : int kobject_uevent(struct kobject *kobj, enum kobject_action action)
640 : {
641 462 : return kobject_uevent_env(kobj, action, NULL);
642 : }
643 : EXPORT_SYMBOL_GPL(kobject_uevent);
644 :
645 : /**
646 : * add_uevent_var - add key value string to the environment buffer
647 : * @env: environment buffer structure
648 : * @format: printf format for the key=value pair
649 : *
650 : * Returns 0 if environment variable was added successfully or -ENOMEM
651 : * if no space was available.
652 : */
653 4348 : int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
654 : {
655 4348 : va_list args;
656 4348 : int len;
657 :
658 4348 : if (env->envp_idx >= ARRAY_SIZE(env->envp)) {
659 0 : WARN(1, KERN_ERR "add_uevent_var: too many keys\n");
660 0 : return -ENOMEM;
661 : }
662 :
663 4348 : va_start(args, format);
664 4348 : len = vsnprintf(&env->buf[env->buflen],
665 4348 : sizeof(env->buf) - env->buflen,
666 : format, args);
667 4348 : va_end(args);
668 :
669 4348 : if (len >= (sizeof(env->buf) - env->buflen)) {
670 0 : WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n");
671 0 : return -ENOMEM;
672 : }
673 :
674 4348 : env->envp[env->envp_idx++] = &env->buf[env->buflen];
675 4348 : env->buflen += len + 1;
676 4348 : return 0;
677 : }
678 : EXPORT_SYMBOL_GPL(add_uevent_var);
679 :
680 : #if defined(CONFIG_NET)
681 0 : static int uevent_net_broadcast(struct sock *usk, struct sk_buff *skb,
682 : struct netlink_ext_ack *extack)
683 : {
684 : /* u64 to chars: 2^64 - 1 = 21 chars */
685 0 : char buf[sizeof("SEQNUM=") + 21];
686 0 : struct sk_buff *skbc;
687 0 : int ret;
688 :
689 : /* bump and prepare sequence number */
690 0 : ret = snprintf(buf, sizeof(buf), "SEQNUM=%llu", ++uevent_seqnum);
691 0 : if (ret < 0 || (size_t)ret >= sizeof(buf))
692 : return -ENOMEM;
693 0 : ret++;
694 :
695 : /* verify message does not overflow */
696 0 : if ((skb->len + ret) > UEVENT_BUFFER_SIZE) {
697 0 : NL_SET_ERR_MSG(extack, "uevent message too big");
698 0 : return -EINVAL;
699 : }
700 :
701 : /* copy skb and extend to accommodate sequence number */
702 0 : skbc = skb_copy_expand(skb, 0, ret, GFP_KERNEL);
703 0 : if (!skbc)
704 : return -ENOMEM;
705 :
706 : /* append sequence number */
707 0 : skb_put_data(skbc, buf, ret);
708 :
709 : /* remove msg header */
710 0 : skb_pull(skbc, NLMSG_HDRLEN);
711 :
712 : /* set portid 0 to inform userspace message comes from kernel */
713 0 : NETLINK_CB(skbc).portid = 0;
714 0 : NETLINK_CB(skbc).dst_group = 1;
715 :
716 0 : ret = netlink_broadcast(usk, skbc, 0, 1, GFP_KERNEL);
717 : /* ENOBUFS should be handled in userspace */
718 0 : if (ret == -ENOBUFS || ret == -ESRCH)
719 0 : ret = 0;
720 :
721 : return ret;
722 : }
723 :
724 0 : static int uevent_net_rcv_skb(struct sk_buff *skb, struct nlmsghdr *nlh,
725 : struct netlink_ext_ack *extack)
726 : {
727 0 : struct net *net;
728 0 : int ret;
729 :
730 0 : if (!nlmsg_data(nlh))
731 : return -EINVAL;
732 :
733 : /*
734 : * Verify that we are allowed to send messages to the target
735 : * network namespace. The caller must have CAP_SYS_ADMIN in the
736 : * owning user namespace of the target network namespace.
737 : */
738 0 : net = sock_net(NETLINK_CB(skb).sk);
739 0 : if (!netlink_ns_capable(skb, net->user_ns, CAP_SYS_ADMIN)) {
740 0 : NL_SET_ERR_MSG(extack, "missing CAP_SYS_ADMIN capability");
741 0 : return -EPERM;
742 : }
743 :
744 0 : mutex_lock(&uevent_sock_mutex);
745 0 : ret = uevent_net_broadcast(net->uevent_sock->sk, skb, extack);
746 0 : mutex_unlock(&uevent_sock_mutex);
747 :
748 0 : return ret;
749 : }
750 :
751 186 : static void uevent_net_rcv(struct sk_buff *skb)
752 : {
753 186 : netlink_rcv_skb(skb, &uevent_net_rcv_skb);
754 186 : }
755 :
756 1 : static int uevent_net_init(struct net *net)
757 : {
758 1 : struct uevent_sock *ue_sk;
759 1 : struct netlink_kernel_cfg cfg = {
760 : .groups = 1,
761 : .input = uevent_net_rcv,
762 : .flags = NL_CFG_F_NONROOT_RECV
763 : };
764 :
765 1 : ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);
766 1 : if (!ue_sk)
767 : return -ENOMEM;
768 :
769 1 : ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT, &cfg);
770 1 : if (!ue_sk->sk) {
771 0 : pr_err("kobject_uevent: unable to create netlink socket!\n");
772 0 : kfree(ue_sk);
773 0 : return -ENODEV;
774 : }
775 :
776 1 : net->uevent_sock = ue_sk;
777 :
778 : /* Restrict uevents to initial user namespace. */
779 1 : if (sock_net(ue_sk->sk)->user_ns == &init_user_ns) {
780 1 : mutex_lock(&uevent_sock_mutex);
781 1 : list_add_tail(&ue_sk->list, &uevent_sock_list);
782 1 : mutex_unlock(&uevent_sock_mutex);
783 : }
784 :
785 : return 0;
786 : }
787 :
788 0 : static void uevent_net_exit(struct net *net)
789 : {
790 0 : struct uevent_sock *ue_sk = net->uevent_sock;
791 :
792 0 : if (sock_net(ue_sk->sk)->user_ns == &init_user_ns) {
793 0 : mutex_lock(&uevent_sock_mutex);
794 0 : list_del(&ue_sk->list);
795 0 : mutex_unlock(&uevent_sock_mutex);
796 : }
797 :
798 0 : netlink_kernel_release(ue_sk->sk);
799 0 : kfree(ue_sk);
800 0 : }
801 :
802 : static struct pernet_operations uevent_net_ops = {
803 : .init = uevent_net_init,
804 : .exit = uevent_net_exit,
805 : };
806 :
807 1 : static int __init kobject_uevent_init(void)
808 : {
809 1 : return register_pernet_subsys(&uevent_net_ops);
810 : }
811 :
812 :
813 : postcore_initcall(kobject_uevent_init);
814 : #endif
|
