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