kobject_uevent.c 15.1 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/*
 * kernel userspace event delivery
 *
 * Copyright (C) 2004 Red Hat, Inc.  All rights reserved.
 * Copyright (C) 2004 Novell, Inc.  All rights reserved.
 * Copyright (C) 2004 IBM, Inc. All rights reserved.
 *
 * Authors:
 *	Robert Love		<rml@novell.com>
 *	Kay Sievers		<kay.sievers@vrfy.org>
 *	Arjan van de Ven	<arjanv@redhat.com>
 *	Greg Kroah-Hartman	<greg@kroah.com>
 */

#include <linux/spinlock.h>
17 18
#include <linux/string.h>
#include <linux/kobject.h>
19 20
#include <linux/export.h>
#include <linux/kmod.h>
21
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
22 23 24
#include <linux/socket.h>
#include <linux/skbuff.h>
#include <linux/netlink.h>
25 26
#include <linux/uuid.h>
#include <linux/ctype.h>
Linus Torvalds's avatar
Linus Torvalds committed
27
#include <net/sock.h>
28
#include <net/net_namespace.h>
Linus Torvalds's avatar
Linus Torvalds committed
29 30


31
u64 uevent_seqnum;
32
#ifdef CONFIG_UEVENT_HELPER
33
char uevent_helper[UEVENT_HELPER_PATH_LEN] = CONFIG_UEVENT_HELPER_PATH;
34
#endif
35 36 37 38 39 40
#ifdef CONFIG_NET
struct uevent_sock {
	struct list_head list;
	struct sock *sk;
};
static LIST_HEAD(uevent_sock_list);
41 42
#endif

43 44 45
/* This lock protects uevent_seqnum and uevent_sock_list */
static DEFINE_MUTEX(uevent_sock_mutex);

46 47 48 49 50 51 52 53
/* the strings here must match the enum in include/linux/kobject.h */
static const char *kobject_actions[] = {
	[KOBJ_ADD] =		"add",
	[KOBJ_REMOVE] =		"remove",
	[KOBJ_CHANGE] =		"change",
	[KOBJ_MOVE] =		"move",
	[KOBJ_ONLINE] =		"online",
	[KOBJ_OFFLINE] =	"offline",
54 55
	[KOBJ_BIND] =		"bind",
	[KOBJ_UNBIND] =		"unbind",
56 57
};

58 59 60
static int kobject_action_type(const char *buf, size_t count,
			       enum kobject_action *type,
			       const char **args)
61 62
{
	enum kobject_action action;
63 64
	size_t count_first;
	const char *args_start;
65 66
	int ret = -EINVAL;

67
	if (count && (buf[count-1] == '\n' || buf[count-1] == '\0'))
68 69 70 71 72
		count--;

	if (!count)
		goto out;

73 74 75 76 77 78 79
	args_start = strnchr(buf, count, ' ');
	if (args_start) {
		count_first = args_start - buf;
		args_start = args_start + 1;
	} else
		count_first = count;

80
	for (action = 0; action < ARRAY_SIZE(kobject_actions); action++) {
81
		if (strncmp(kobject_actions[action], buf, count_first) != 0)
82
			continue;
83
		if (kobject_actions[action][count_first] != '\0')
84
			continue;
85 86
		if (args)
			*args = args_start;
87 88 89 90 91 92 93 94
		*type = action;
		ret = 0;
		break;
	}
out:
	return ret;
}

95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
static const char *action_arg_word_end(const char *buf, const char *buf_end,
				       char delim)
{
	const char *next = buf;

	while (next <= buf_end && *next != delim)
		if (!isalnum(*next++))
			return NULL;

	if (next == buf)
		return NULL;

	return next;
}

static int kobject_action_args(const char *buf, size_t count,
			       struct kobj_uevent_env **ret_env)
{
	struct kobj_uevent_env *env = NULL;
	const char *next, *buf_end, *key;
	int key_len;
	int r = -EINVAL;

	if (count && (buf[count - 1] == '\n' || buf[count - 1] == '\0'))
		count--;

	if (!count)
		return -EINVAL;

	env = kzalloc(sizeof(*env), GFP_KERNEL);
	if (!env)
		return -ENOMEM;

	/* first arg is UUID */
	if (count < UUID_STRING_LEN || !uuid_is_valid(buf) ||
	    add_uevent_var(env, "SYNTH_UUID=%.*s", UUID_STRING_LEN, buf))
		goto out;

	/*
	 * the rest are custom environment variables in KEY=VALUE
	 * format with ' ' delimiter between each KEY=VALUE pair
	 */
	next = buf + UUID_STRING_LEN;
	buf_end = buf + count - 1;

	while (next <= buf_end) {
		if (*next != ' ')
			goto out;

		/* skip the ' ', key must follow */
		key = ++next;
		if (key > buf_end)
			goto out;

		buf = next;
		next = action_arg_word_end(buf, buf_end, '=');
		if (!next || next > buf_end || *next != '=')
			goto out;
		key_len = next - buf;

		/* skip the '=', value must follow */
		if (++next > buf_end)
			goto out;

		buf = next;
		next = action_arg_word_end(buf, buf_end, ' ');
		if (!next)
			goto out;

		if (add_uevent_var(env, "SYNTH_ARG_%.*s=%.*s",
				   key_len, key, (int) (next - buf), buf))
			goto out;
	}

	r = 0;
out:
	if (r)
		kfree(env);
	else
		*ret_env = env;
	return r;
}

/**
 * kobject_synth_uevent - send synthetic uevent with arguments
 *
 * @kobj: struct kobject for which synthetic uevent is to be generated
 * @buf: buffer containing action type and action args, newline is ignored
 * @count: length of buffer
 *
 * Returns 0 if kobject_synthetic_uevent() is completed with success or the
 * corresponding error when it fails.
 */
int kobject_synth_uevent(struct kobject *kobj, const char *buf, size_t count)
{
	char *no_uuid_envp[] = { "SYNTH_UUID=0", NULL };
	enum kobject_action action;
	const char *action_args;
	struct kobj_uevent_env *env;
	const char *msg = NULL, *devpath;
	int r;

	r = kobject_action_type(buf, count, &action, &action_args);
	if (r) {
		msg = "unknown uevent action string\n";
		goto out;
	}

	if (!action_args) {
		r = kobject_uevent_env(kobj, action, no_uuid_envp);
		goto out;
	}

	r = kobject_action_args(action_args,
				count - (action_args - buf), &env);
	if (r == -EINVAL) {
		msg = "incorrect uevent action arguments\n";
		goto out;
	}

	if (r)
		goto out;

	r = kobject_uevent_env(kobj, action, env->envp);
	kfree(env);
out:
	if (r) {
		devpath = kobject_get_path(kobj, GFP_KERNEL);
		printk(KERN_WARNING "synth uevent: %s: %s",
		       devpath ?: "unknown device",
		       msg ?: "failed to send uevent");
		kfree(devpath);
	}
	return r;
}

231
#ifdef CONFIG_NET
232 233
static int kobj_bcast_filter(struct sock *dsk, struct sk_buff *skb, void *data)
{
234
	struct kobject *kobj = data, *ksobj;
235 236 237
	const struct kobj_ns_type_operations *ops;

	ops = kobj_ns_ops(kobj);
238 239 240 241 242 243 244
	if (!ops && kobj->kset) {
		ksobj = &kobj->kset->kobj;
		if (ksobj->parent != NULL)
			ops = kobj_ns_ops(ksobj->parent);
	}

	if (ops && ops->netlink_ns && kobj->ktype->namespace) {
245 246 247 248 249 250 251 252
		const void *sock_ns, *ns;
		ns = kobj->ktype->namespace(kobj);
		sock_ns = ops->netlink_ns(dsk);
		return sock_ns != ns;
	}

	return 0;
}
253
#endif
254

255
#ifdef CONFIG_UEVENT_HELPER
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
static int kobj_usermode_filter(struct kobject *kobj)
{
	const struct kobj_ns_type_operations *ops;

	ops = kobj_ns_ops(kobj);
	if (ops) {
		const void *init_ns, *ns;
		ns = kobj->ktype->namespace(kobj);
		init_ns = ops->initial_ns();
		return ns != init_ns;
	}

	return 0;
}

271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293
static int init_uevent_argv(struct kobj_uevent_env *env, const char *subsystem)
{
	int len;

	len = strlcpy(&env->buf[env->buflen], subsystem,
		      sizeof(env->buf) - env->buflen);
	if (len >= (sizeof(env->buf) - env->buflen)) {
		WARN(1, KERN_ERR "init_uevent_argv: buffer size too small\n");
		return -ENOMEM;
	}

	env->argv[0] = uevent_helper;
	env->argv[1] = &env->buf[env->buflen];
	env->argv[2] = NULL;

	env->buflen += len + 1;
	return 0;
}

static void cleanup_uevent_env(struct subprocess_info *info)
{
	kfree(info->data);
}
294
#endif
295

296 297 298 299 300 301 302
static int kobject_uevent_net_broadcast(struct kobject *kobj,
					struct kobj_uevent_env *env,
					const char *action_string,
					const char *devpath)
{
	int retval = 0;
#if defined(CONFIG_NET)
303
	struct sk_buff *skb = NULL;
304 305 306 307 308 309 310 311 312
	struct uevent_sock *ue_sk;

	/* send netlink message */
	list_for_each_entry(ue_sk, &uevent_sock_list, list) {
		struct sock *uevent_sock = ue_sk->sk;

		if (!netlink_has_listeners(uevent_sock, 1))
			continue;

313 314 315
		if (!skb) {
			/* allocate message with the maximum possible size */
			size_t len = strlen(action_string) + strlen(devpath) + 2;
316 317
			char *scratch;

318 319 320 321 322
			retval = -ENOMEM;
			skb = alloc_skb(len + env->buflen, GFP_KERNEL);
			if (!skb)
				continue;

323 324 325 326
			/* add header */
			scratch = skb_put(skb, len);
			sprintf(scratch, "%s@%s", action_string, devpath);

327
			skb_put_data(skb, env->buf, env->buflen);
328 329

			NETLINK_CB(skb).dst_group = 1;
330 331 332 333 334 335 336 337 338
		}

		retval = netlink_broadcast_filtered(uevent_sock, skb_get(skb),
						    0, 1, GFP_KERNEL,
						    kobj_bcast_filter,
						    kobj);
		/* ENOBUFS should be handled in userspace */
		if (retval == -ENOBUFS || retval == -ESRCH)
			retval = 0;
339
	}
340
	consume_skb(skb);
341 342 343 344
#endif
	return retval;
}

345 346 347
static void zap_modalias_env(struct kobj_uevent_env *env)
{
	static const char modalias_prefix[] = "MODALIAS=";
348 349
	size_t len;
	int i, j;
350 351 352 353 354 355 356 357

	for (i = 0; i < env->envp_idx;) {
		if (strncmp(env->envp[i], modalias_prefix,
			    sizeof(modalias_prefix) - 1)) {
			i++;
			continue;
		}

358 359 360 361 362 363 364 365 366
		len = strlen(env->envp[i]) + 1;

		if (i != env->envp_idx - 1) {
			memmove(env->envp[i], env->envp[i + 1],
				env->buflen - len);

			for (j = i; j < env->envp_idx - 1; j++)
				env->envp[j] = env->envp[j + 1] - len;
		}
367 368

		env->envp_idx--;
369
		env->buflen -= len;
370 371 372
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
373
/**
374
 * kobject_uevent_env - send an uevent with environmental data
Linus Torvalds's avatar
Linus Torvalds committed
375 376
 *
 * @kobj: struct kobject that the action is happening to
377
 * @action: action that is happening
378
 * @envp_ext: pointer to environmental data
379
 *
380
 * Returns 0 if kobject_uevent_env() is completed with success or the
381
 * corresponding error when it fails.
Linus Torvalds's avatar
Linus Torvalds committed
382
 */
383
int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
384
		       char *envp_ext[])
Linus Torvalds's avatar
Linus Torvalds committed
385
{
386 387
	struct kobj_uevent_env *env;
	const char *action_string = kobject_actions[action];
388 389 390 391
	const char *devpath = NULL;
	const char *subsystem;
	struct kobject *top_kobj;
	struct kset *kset;
392
	const struct kset_uevent_ops *uevent_ops;
Linus Torvalds's avatar
Linus Torvalds committed
393
	int i = 0;
394
	int retval = 0;
Linus Torvalds's avatar
Linus Torvalds committed
395

396
	pr_debug("kobject: '%s' (%p): %s\n",
397
		 kobject_name(kobj), kobj, __func__);
398 399 400

	/* search the kset we belong to */
	top_kobj = kobj;
401
	while (!top_kobj->kset && top_kobj->parent)
402
		top_kobj = top_kobj->parent;
403

404
	if (!top_kobj->kset) {
405 406
		pr_debug("kobject: '%s' (%p): %s: attempted to send uevent "
			 "without kset!\n", kobject_name(kobj), kobj,
407
			 __func__);
408 409
		return -EINVAL;
	}
Linus Torvalds's avatar
Linus Torvalds committed
410

411
	kset = top_kobj->kset;
412
	uevent_ops = kset->uevent_ops;
Linus Torvalds's avatar
Linus Torvalds committed
413

414 415 416 417 418 419 420
	/* skip the event, if uevent_suppress is set*/
	if (kobj->uevent_suppress) {
		pr_debug("kobject: '%s' (%p): %s: uevent_suppress "
				 "caused the event to drop!\n",
				 kobject_name(kobj), kobj, __func__);
		return 0;
	}
421
	/* skip the event, if the filter returns zero. */
422
	if (uevent_ops && uevent_ops->filter)
423
		if (!uevent_ops->filter(kset, kobj)) {
424 425
			pr_debug("kobject: '%s' (%p): %s: filter function "
				 "caused the event to drop!\n",
426
				 kobject_name(kobj), kobj, __func__);
427 428
			return 0;
		}
Linus Torvalds's avatar
Linus Torvalds committed
429

430 431 432 433 434 435
	/* originating subsystem */
	if (uevent_ops && uevent_ops->name)
		subsystem = uevent_ops->name(kset, kobj);
	else
		subsystem = kobject_name(&kset->kobj);
	if (!subsystem) {
436 437
		pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the "
			 "event to drop!\n", kobject_name(kobj), kobj,
438
			 __func__);
439 440 441
		return 0;
	}

442 443 444
	/* environment buffer */
	env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL);
	if (!env)
445
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
446

447 448
	/* complete object path */
	devpath = kobject_get_path(kobj, GFP_KERNEL);
449 450
	if (!devpath) {
		retval = -ENOENT;
451
		goto exit;
452
	}
Linus Torvalds's avatar
Linus Torvalds committed
453

454
	/* default keys */
455 456 457 458 459 460 461 462 463 464 465 466 467
	retval = add_uevent_var(env, "ACTION=%s", action_string);
	if (retval)
		goto exit;
	retval = add_uevent_var(env, "DEVPATH=%s", devpath);
	if (retval)
		goto exit;
	retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem);
	if (retval)
		goto exit;

	/* keys passed in from the caller */
	if (envp_ext) {
		for (i = 0; envp_ext[i]; i++) {
468
			retval = add_uevent_var(env, "%s", envp_ext[i]);
469 470 471 472
			if (retval)
				goto exit;
		}
	}
Linus Torvalds's avatar
Linus Torvalds committed
473

474
	/* let the kset specific function add its stuff */
475
	if (uevent_ops && uevent_ops->uevent) {
476
		retval = uevent_ops->uevent(kset, kobj, env);
Linus Torvalds's avatar
Linus Torvalds committed
477
		if (retval) {
478 479
			pr_debug("kobject: '%s' (%p): %s: uevent() returned "
				 "%d\n", kobject_name(kobj), kobj,
480
				 __func__, retval);
Linus Torvalds's avatar
Linus Torvalds committed
481 482 483 484
			goto exit;
		}
	}

485 486 487 488 489 490 491 492 493
	switch (action) {
	case KOBJ_ADD:
		/*
		 * Mark "add" event so we can make sure we deliver "remove"
		 * event to userspace during automatic cleanup. If
		 * the object did send an "add" event, "remove" will
		 * automatically generated by the core, if not already done
		 * by the caller.
		 */
494
		kobj->state_add_uevent_sent = 1;
495 496 497
		break;

	case KOBJ_REMOVE:
498
		kobj->state_remove_uevent_sent = 1;
499 500 501 502 503 504 505 506 507
		break;

	case KOBJ_UNBIND:
		zap_modalias_env(env);
		break;

	default:
		break;
	}
508

509
	mutex_lock(&uevent_sock_mutex);
510
	/* we will send an event, so request a new sequence number */
511 512 513
	retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)++uevent_seqnum);
	if (retval) {
		mutex_unlock(&uevent_sock_mutex);
514
		goto exit;
515
	}
516 517
	retval = kobject_uevent_net_broadcast(kobj, env, action_string,
					      devpath);
518
	mutex_unlock(&uevent_sock_mutex);
Linus Torvalds's avatar
Linus Torvalds committed
519

520
#ifdef CONFIG_UEVENT_HELPER
521
	/* call uevent_helper, usually only enabled during early boot */
522
	if (uevent_helper[0] && !kobj_usermode_filter(kobj)) {
523
		struct subprocess_info *info;
Linus Torvalds's avatar
Linus Torvalds committed
524

525 526 527
		retval = add_uevent_var(env, "HOME=/");
		if (retval)
			goto exit;
528 529
		retval = add_uevent_var(env,
					"PATH=/sbin:/bin:/usr/sbin:/usr/bin");
530 531
		if (retval)
			goto exit;
532 533 534
		retval = init_uevent_argv(env, subsystem);
		if (retval)
			goto exit;
535

536 537 538 539 540 541 542 543
		retval = -ENOMEM;
		info = call_usermodehelper_setup(env->argv[0], env->argv,
						 env->envp, GFP_KERNEL,
						 NULL, cleanup_uevent_env, env);
		if (info) {
			retval = call_usermodehelper_exec(info, UMH_NO_WAIT);
			env = NULL;	/* freed by cleanup_uevent_env */
		}
544
	}
545
#endif
Linus Torvalds's avatar
Linus Torvalds committed
546 547

exit:
548
	kfree(devpath);
549
	kfree(env);
550
	return retval;
Linus Torvalds's avatar
Linus Torvalds committed
551
}
552 553 554
EXPORT_SYMBOL_GPL(kobject_uevent_env);

/**
555
 * kobject_uevent - notify userspace by sending an uevent
556 557
 *
 * @kobj: struct kobject that the action is happening to
558
 * @action: action that is happening
559 560 561
 *
 * Returns 0 if kobject_uevent() is completed with success or the
 * corresponding error when it fails.
562
 */
563
int kobject_uevent(struct kobject *kobj, enum kobject_action action)
564
{
565
	return kobject_uevent_env(kobj, action, NULL);
566
}
567
EXPORT_SYMBOL_GPL(kobject_uevent);
Linus Torvalds's avatar
Linus Torvalds committed
568 569

/**
570 571 572
 * add_uevent_var - add key value string to the environment buffer
 * @env: environment buffer structure
 * @format: printf format for the key=value pair
Linus Torvalds's avatar
Linus Torvalds committed
573 574 575 576
 *
 * Returns 0 if environment variable was added successfully or -ENOMEM
 * if no space was available.
 */
577
int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
Linus Torvalds's avatar
Linus Torvalds committed
578 579
{
	va_list args;
580
	int len;
Linus Torvalds's avatar
Linus Torvalds committed
581

582
	if (env->envp_idx >= ARRAY_SIZE(env->envp)) {
Arjan van de Ven's avatar
Arjan van de Ven committed
583
		WARN(1, KERN_ERR "add_uevent_var: too many keys\n");
Linus Torvalds's avatar
Linus Torvalds committed
584
		return -ENOMEM;
585
	}
Linus Torvalds's avatar
Linus Torvalds committed
586 587

	va_start(args, format);
588 589 590
	len = vsnprintf(&env->buf[env->buflen],
			sizeof(env->buf) - env->buflen,
			format, args);
Linus Torvalds's avatar
Linus Torvalds committed
591 592
	va_end(args);

593
	if (len >= (sizeof(env->buf) - env->buflen)) {
Arjan van de Ven's avatar
Arjan van de Ven committed
594
		WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n");
Linus Torvalds's avatar
Linus Torvalds committed
595
		return -ENOMEM;
596
	}
Linus Torvalds's avatar
Linus Torvalds committed
597

598 599
	env->envp[env->envp_idx++] = &env->buf[env->buflen];
	env->buflen += len + 1;
Linus Torvalds's avatar
Linus Torvalds committed
600 601
	return 0;
}
602
EXPORT_SYMBOL_GPL(add_uevent_var);
Linus Torvalds's avatar
Linus Torvalds committed
603

604
#if defined(CONFIG_NET)
605
static int uevent_net_init(struct net *net)
606
{
607
	struct uevent_sock *ue_sk;
608 609
	struct netlink_kernel_cfg cfg = {
		.groups	= 1,
610
		.flags	= NL_CFG_F_NONROOT_RECV,
611
	};
612 613 614 615 616

	ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL);
	if (!ue_sk)
		return -ENOMEM;

617
	ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT, &cfg);
618
	if (!ue_sk->sk) {
619 620
		printk(KERN_ERR
		       "kobject_uevent: unable to create netlink socket!\n");
621
		kfree(ue_sk);
622 623
		return -ENODEV;
	}
624 625 626
	mutex_lock(&uevent_sock_mutex);
	list_add_tail(&ue_sk->list, &uevent_sock_list);
	mutex_unlock(&uevent_sock_mutex);
627 628 629
	return 0;
}

630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660
static void uevent_net_exit(struct net *net)
{
	struct uevent_sock *ue_sk;

	mutex_lock(&uevent_sock_mutex);
	list_for_each_entry(ue_sk, &uevent_sock_list, list) {
		if (sock_net(ue_sk->sk) == net)
			goto found;
	}
	mutex_unlock(&uevent_sock_mutex);
	return;

found:
	list_del(&ue_sk->list);
	mutex_unlock(&uevent_sock_mutex);

	netlink_kernel_release(ue_sk->sk);
	kfree(ue_sk);
}

static struct pernet_operations uevent_net_ops = {
	.init	= uevent_net_init,
	.exit	= uevent_net_exit,
};

static int __init kobject_uevent_init(void)
{
	return register_pernet_subsys(&uevent_net_ops);
}


661
postcore_initcall(kobject_uevent_init);
662
#endif