Branch data 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 : 3 : 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 : : int ret = -EINVAL;
70 : :
71 : 3 : if (count && (buf[count-1] == '\n' || buf[count-1] == '\0'))
72 : : count--;
73 : :
74 : 3 : if (!count)
75 : : goto out;
76 : :
77 : 3 : args_start = strnchr(buf, count, ' ');
78 : 3 : 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 : 3 : for (action = 0; action < ARRAY_SIZE(kobject_actions); action++) {
85 : 3 : if (strncmp(kobject_actions[action], buf, count_first) != 0)
86 : 3 : continue;
87 : 3 : if (kobject_actions[action][count_first] != '\0')
88 : 0 : continue;
89 : 3 : if (args)
90 : 3 : *args = args_start;
91 : 3 : *type = action;
92 : : ret = 0;
93 : 3 : break;
94 : : }
95 : : out:
96 : 3 : 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 : 0 : 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 : : struct kobj_uevent_env *env = NULL;
118 : : const char *next, *buf_end, *key;
119 : : int key_len;
120 : : int r = -EINVAL;
121 : :
122 : 0 : if (count && (buf[count - 1] == '\n' || buf[count - 1] == '\0'))
123 : : 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 : : 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 : : 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 : : 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 : 0 : 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 : 3 : int kobject_synth_uevent(struct kobject *kobj, const char *buf, size_t count)
193 : : {
194 : 3 : 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 : : const char *msg = NULL, *devpath;
199 : : int r;
200 : :
201 : 3 : r = kobject_action_type(buf, count, &action, &action_args);
202 : 3 : if (r) {
203 : : msg = "unknown uevent action string";
204 : : goto out;
205 : : }
206 : :
207 : 3 : if (!action_args) {
208 : 3 : r = kobject_uevent_env(kobj, action, no_uuid_envp);
209 : 3 : 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 : 3 : 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 : 3 : return r;
233 : : }
234 : :
235 : : #ifdef CONFIG_UEVENT_HELPER
236 : 0 : static int kobj_usermode_filter(struct kobject *kobj)
237 : : {
238 : : const struct kobj_ns_type_operations *ops;
239 : :
240 : 0 : ops = kobj_ns_ops(kobj);
241 : 0 : if (ops) {
242 : : 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 : : int len;
255 : :
256 : 0 : len = strlcpy(&env->buf[env->buflen], subsystem,
257 : : 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 : 3 : static struct sk_buff *alloc_uevent_skb(struct kobj_uevent_env *env,
279 : : const char *action_string,
280 : : const char *devpath)
281 : : {
282 : : struct netlink_skb_parms *parms;
283 : : struct sk_buff *skb = NULL;
284 : : char *scratch;
285 : : size_t len;
286 : :
287 : : /* allocate message with maximum possible size */
288 : 3 : len = strlen(action_string) + strlen(devpath) + 2;
289 : 3 : skb = alloc_skb(len + env->buflen, GFP_KERNEL);
290 : 3 : if (!skb)
291 : : return NULL;
292 : :
293 : : /* add header */
294 : 3 : scratch = skb_put(skb, len);
295 : 3 : sprintf(scratch, "%s@%s", action_string, devpath);
296 : :
297 : 3 : skb_put_data(skb, env->buf, env->buflen);
298 : :
299 : : parms = &NETLINK_CB(skb);
300 : 3 : parms->creds.uid = GLOBAL_ROOT_UID;
301 : 3 : parms->creds.gid = GLOBAL_ROOT_GID;
302 : 3 : parms->dst_group = 1;
303 : 3 : parms->portid = 0;
304 : :
305 : 3 : return skb;
306 : : }
307 : :
308 : 3 : static int uevent_net_broadcast_untagged(struct kobj_uevent_env *env,
309 : : const char *action_string,
310 : : const char *devpath)
311 : : {
312 : : struct sk_buff *skb = NULL;
313 : : struct uevent_sock *ue_sk;
314 : : int retval = 0;
315 : :
316 : : /* send netlink message */
317 : 3 : list_for_each_entry(ue_sk, &uevent_sock_list, list) {
318 : 3 : struct sock *uevent_sock = ue_sk->sk;
319 : :
320 : 3 : if (!netlink_has_listeners(uevent_sock, 1))
321 : 3 : continue;
322 : :
323 : 3 : if (!skb) {
324 : : retval = -ENOMEM;
325 : 3 : skb = alloc_uevent_skb(env, action_string, devpath);
326 : 3 : if (!skb)
327 : 0 : continue;
328 : : }
329 : :
330 : 3 : retval = netlink_broadcast(uevent_sock, skb_get(skb), 0, 1,
331 : : GFP_KERNEL);
332 : : /* ENOBUFS should be handled in userspace */
333 : 3 : if (retval == -ENOBUFS || retval == -ESRCH)
334 : : retval = 0;
335 : : }
336 : 3 : consume_skb(skb);
337 : :
338 : 3 : return retval;
339 : : }
340 : :
341 : 3 : 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 : 3 : struct user_namespace *owning_user_ns = sock_net(usk)->user_ns;
347 : : struct sk_buff *skb = NULL;
348 : : int ret = 0;
349 : :
350 : 3 : skb = alloc_uevent_skb(env, action_string, devpath);
351 : 3 : if (!skb)
352 : : return -ENOMEM;
353 : :
354 : : /* fix credentials */
355 : 3 : if (owning_user_ns != &init_user_ns) {
356 : : struct netlink_skb_parms *parms = &NETLINK_CB(skb);
357 : : kuid_t root_uid;
358 : : kgid_t root_gid;
359 : :
360 : : /* fix uid */
361 : 1 : root_uid = make_kuid(owning_user_ns, 0);
362 : 1 : if (uid_valid(root_uid))
363 : 0 : parms->creds.uid = root_uid;
364 : :
365 : : /* fix gid */
366 : 1 : root_gid = make_kgid(owning_user_ns, 0);
367 : 1 : if (gid_valid(root_gid))
368 : 0 : parms->creds.gid = root_gid;
369 : : }
370 : :
371 : 3 : ret = netlink_broadcast(usk, skb, 0, 1, GFP_KERNEL);
372 : : /* ENOBUFS should be handled in userspace */
373 : 3 : if (ret == -ENOBUFS || ret == -ESRCH)
374 : : ret = 0;
375 : :
376 : 3 : return ret;
377 : : }
378 : : #endif
379 : :
380 : 3 : 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 : : int ret = 0;
386 : :
387 : : #ifdef CONFIG_NET
388 : : const struct kobj_ns_type_operations *ops;
389 : : const struct net *net = NULL;
390 : :
391 : 3 : ops = kobj_ns_ops(kobj);
392 : 3 : if (!ops && kobj->kset) {
393 : : struct kobject *ksobj = &kobj->kset->kobj;
394 : :
395 : 3 : if (ksobj->parent != NULL)
396 : 3 : 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 : 3 : if (ops && ops->netlink_ns && kobj->ktype->namespace)
404 : 3 : if (ops->type == KOBJ_NS_TYPE_NET)
405 : 3 : net = kobj->ktype->namespace(kobj);
406 : :
407 : 3 : if (!net)
408 : 3 : ret = uevent_net_broadcast_untagged(env, action_string,
409 : : devpath);
410 : : else
411 : 3 : ret = uevent_net_broadcast_tagged(net->uevent_sock->sk, env,
412 : : action_string, devpath);
413 : : #endif
414 : :
415 : 3 : return ret;
416 : : }
417 : :
418 : 0 : static void zap_modalias_env(struct kobj_uevent_env *env)
419 : : {
420 : : static const char modalias_prefix[] = "MODALIAS=";
421 : : size_t len;
422 : : 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 : 3 : int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
457 : : char *envp_ext[])
458 : : {
459 : : struct kobj_uevent_env *env;
460 : 3 : const char *action_string = kobject_actions[action];
461 : : const char *devpath = NULL;
462 : : const char *subsystem;
463 : : struct kobject *top_kobj;
464 : : struct kset *kset;
465 : : const struct kset_uevent_ops *uevent_ops;
466 : : int i = 0;
467 : : 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 : 3 : if (action == KOBJ_REMOVE)
474 : 3 : kobj->state_remove_uevent_sent = 1;
475 : :
476 : : pr_debug("kobject: '%s' (%p): %s\n",
477 : : kobject_name(kobj), kobj, __func__);
478 : :
479 : : /* search the kset we belong to */
480 : : top_kobj = kobj;
481 : 3 : while (!top_kobj->kset && top_kobj->parent)
482 : : top_kobj = top_kobj->parent;
483 : :
484 : 3 : 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 : 3 : kset = top_kobj->kset;
492 : 3 : uevent_ops = kset->uevent_ops;
493 : :
494 : : /* skip the event, if uevent_suppress is set*/
495 : 3 : 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 : 3 : if (uevent_ops && uevent_ops->filter)
503 : 3 : 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 : 3 : if (uevent_ops && uevent_ops->name)
512 : 3 : subsystem = uevent_ops->name(kset, kobj);
513 : : else
514 : : subsystem = kobject_name(&kset->kobj);
515 : 3 : 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 : 3 : env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
524 : 3 : if (!env)
525 : : return -ENOMEM;
526 : :
527 : : /* complete object path */
528 : 3 : devpath = kobject_get_path(kobj, GFP_KERNEL);
529 : 3 : if (!devpath) {
530 : : retval = -ENOENT;
531 : : goto exit;
532 : : }
533 : :
534 : : /* default keys */
535 : 3 : retval = add_uevent_var(env, "ACTION=%s", action_string);
536 : 3 : if (retval)
537 : : goto exit;
538 : 3 : retval = add_uevent_var(env, "DEVPATH=%s", devpath);
539 : 3 : if (retval)
540 : : goto exit;
541 : 3 : retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
542 : 3 : if (retval)
543 : : goto exit;
544 : :
545 : : /* keys passed in from the caller */
546 : 3 : if (envp_ext) {
547 : 3 : for (i = 0; envp_ext[i]; i++) {
548 : 3 : retval = add_uevent_var(env, "%s", envp_ext[i]);
549 : 3 : if (retval)
550 : : goto exit;
551 : : }
552 : : }
553 : :
554 : : /* let the kset specific function add its stuff */
555 : 3 : if (uevent_ops && uevent_ops->uevent) {
556 : 3 : retval = uevent_ops->uevent(kset, kobj, env);
557 : 3 : if (retval) {
558 : : pr_debug("kobject: '%s' (%p): %s: uevent() returned "
559 : : "%d\n", kobject_name(kobj), kobj,
560 : : __func__, retval);
561 : : goto exit;
562 : : }
563 : : }
564 : :
565 : 3 : switch (action) {
566 : : 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 : 3 : kobj->state_add_uevent_sent = 1;
575 : 3 : break;
576 : :
577 : : case KOBJ_UNBIND:
578 : 0 : zap_modalias_env(env);
579 : 0 : break;
580 : :
581 : : default:
582 : : break;
583 : : }
584 : :
585 : 3 : mutex_lock(&uevent_sock_mutex);
586 : : /* we will send an event, so request a new sequence number */
587 : 3 : retval = add_uevent_var(env, "SEQNUM=%llu", ++uevent_seqnum);
588 : 3 : if (retval) {
589 : 0 : mutex_unlock(&uevent_sock_mutex);
590 : 0 : goto exit;
591 : : }
592 : 3 : retval = kobject_uevent_net_broadcast(kobj, env, action_string,
593 : : devpath);
594 : 3 : mutex_unlock(&uevent_sock_mutex);
595 : :
596 : : #ifdef CONFIG_UEVENT_HELPER
597 : : /* call uevent_helper, usually only enabled during early boot */
598 : 3 : if (uevent_helper[0] && !kobj_usermode_filter(kobj)) {
599 : : struct subprocess_info *info;
600 : :
601 : 0 : retval = add_uevent_var(env, "HOME=/");
602 : 0 : if (retval)
603 : : goto exit;
604 : 0 : retval = add_uevent_var(env,
605 : : "PATH=/sbin:/bin:/usr/sbin:/usr/bin");
606 : 0 : if (retval)
607 : : goto exit;
608 : 0 : retval = init_uevent_argv(env, subsystem);
609 : 0 : if (retval)
610 : : goto exit;
611 : :
612 : : 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 : : env = NULL; /* freed by cleanup_uevent_env */
619 : : }
620 : : }
621 : : #endif
622 : :
623 : : exit:
624 : 3 : kfree(devpath);
625 : 3 : kfree(env);
626 : 3 : 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 : 3 : int kobject_uevent(struct kobject *kobj, enum kobject_action action)
640 : : {
641 : 3 : 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 : 3 : int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
654 : : {
655 : : va_list args;
656 : : int len;
657 : :
658 : 3 : 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 : 3 : va_start(args, format);
664 : 3 : len = vsnprintf(&env->buf[env->buflen],
665 : : sizeof(env->buf) - env->buflen,
666 : : format, args);
667 : 3 : va_end(args);
668 : :
669 : 3 : 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 : 3 : env->envp[env->envp_idx++] = &env->buf[env->buflen];
675 : 3 : env->buflen += len + 1;
676 : 3 : 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 : : char buf[sizeof("SEQNUM=") + 21];
686 : : struct sk_buff *skbc;
687 : : 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 : : 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 : : ret = 0;
720 : :
721 : 0 : 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 : : struct net *net;
728 : : 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 : : 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 : 3 : static void uevent_net_rcv(struct sk_buff *skb)
752 : : {
753 : 3 : netlink_rcv_skb(skb, &uevent_net_rcv_skb);
754 : 3 : }
755 : :
756 : 3 : static int uevent_net_init(struct net *net)
757 : : {
758 : : struct uevent_sock *ue_sk;
759 : 3 : struct netlink_kernel_cfg cfg = {
760 : : .groups = 1,
761 : : .input = uevent_net_rcv,
762 : : .flags = NL_CFG_F_NONROOT_RECV
763 : : };
764 : :
765 : 3 : ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);
766 : 3 : if (!ue_sk)
767 : : return -ENOMEM;
768 : :
769 : 3 : ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT, &cfg);
770 : 3 : 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 : 3 : net->uevent_sock = ue_sk;
777 : :
778 : : /* Restrict uevents to initial user namespace. */
779 : 3 : if (sock_net(ue_sk->sk)->user_ns == &init_user_ns) {
780 : 3 : mutex_lock(&uevent_sock_mutex);
781 : 3 : list_add_tail(&ue_sk->list, &uevent_sock_list);
782 : 3 : mutex_unlock(&uevent_sock_mutex);
783 : : }
784 : :
785 : : return 0;
786 : : }
787 : :
788 : 1 : static void uevent_net_exit(struct net *net)
789 : : {
790 : 1 : struct uevent_sock *ue_sk = net->uevent_sock;
791 : :
792 : 1 : if (sock_net(ue_sk->sk)->user_ns == &init_user_ns) {
793 : 0 : mutex_lock(&uevent_sock_mutex);
794 : : list_del(&ue_sk->list);
795 : 0 : mutex_unlock(&uevent_sock_mutex);
796 : : }
797 : :
798 : 1 : netlink_kernel_release(ue_sk->sk);
799 : 1 : kfree(ue_sk);
800 : 1 : }
801 : :
802 : : static struct pernet_operations uevent_net_ops = {
803 : : .init = uevent_net_init,
804 : : .exit = uevent_net_exit,
805 : : };
806 : :
807 : 3 : static int __init kobject_uevent_init(void)
808 : : {
809 : 3 : return register_pernet_subsys(&uevent_net_ops);
810 : : }
811 : :
812 : :
813 : : postcore_initcall(kobject_uevent_init);
814 : : #endif
|
