1 /* 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> 18 #include <linux/string.h> 19 #include <linux/kobject.h> 20 #include <linux/export.h> 21 #include <linux/kmod.h> 22 #include <linux/slab.h> 23 #include <linux/user_namespace.h> 24 #include <linux/socket.h> 25 #include <linux/skbuff.h> 26 #include <linux/netlink.h> 27 #include <net/sock.h> 28 #include <net/net_namespace.h> 29 30 31 u64 uevent_seqnum; 32 char uevent_helper[UEVENT_HELPER_PATH_LEN] = CONFIG_UEVENT_HELPER_PATH; 33 #ifdef CONFIG_NET 34 struct uevent_sock { 35 struct list_head list; 36 struct sock *sk; 37 }; 38 static LIST_HEAD(uevent_sock_list); 39 #endif 40 41 /* This lock protects uevent_seqnum and uevent_sock_list */ 42 static DEFINE_MUTEX(uevent_sock_mutex); 43 44 /* the strings here must match the enum in include/linux/kobject.h */ 45 static const char *kobject_actions[] = { 46 [KOBJ_ADD] = "add", 47 [KOBJ_REMOVE] = "remove", 48 [KOBJ_CHANGE] = "change", 49 [KOBJ_MOVE] = "move", 50 [KOBJ_ONLINE] = "online", 51 [KOBJ_OFFLINE] = "offline", 52 }; 53 54 /** 55 * kobject_action_type - translate action string to numeric type 56 * 57 * @buf: buffer containing the action string, newline is ignored 58 * @len: length of buffer 59 * @type: pointer to the location to store the action type 60 * 61 * Returns 0 if the action string was recognized. 62 */ 63 int kobject_action_type(const char *buf, size_t count, 64 enum kobject_action *type) 65 { 66 enum kobject_action action; 67 int ret = -EINVAL; 68 69 if (count && (buf[count-1] == '\n' || buf[count-1] == '\0')) 70 count--; 71 72 if (!count) 73 goto out; 74 75 for (action = 0; action < ARRAY_SIZE(kobject_actions); action++) { 76 if (strncmp(kobject_actions[action], buf, count) != 0) 77 continue; 78 if (kobject_actions[action][count] != '\0') 79 continue; 80 *type = action; 81 ret = 0; 82 break; 83 } 84 out: 85 return ret; 86 } 87 88 #ifdef CONFIG_NET 89 static int kobj_bcast_filter(struct sock *dsk, struct sk_buff *skb, void *data) 90 { 91 struct kobject *kobj = data, *ksobj; 92 const struct kobj_ns_type_operations *ops; 93 94 ops = kobj_ns_ops(kobj); 95 if (!ops && kobj->kset) { 96 ksobj = &kobj->kset->kobj; 97 if (ksobj->parent != NULL) 98 ops = kobj_ns_ops(ksobj->parent); 99 } 100 101 if (ops && ops->netlink_ns && kobj->ktype->namespace) { 102 const void *sock_ns, *ns; 103 ns = kobj->ktype->namespace(kobj); 104 sock_ns = ops->netlink_ns(dsk); 105 return sock_ns != ns; 106 } 107 108 return 0; 109 } 110 #endif 111 112 static int kobj_usermode_filter(struct kobject *kobj) 113 { 114 const struct kobj_ns_type_operations *ops; 115 116 ops = kobj_ns_ops(kobj); 117 if (ops) { 118 const void *init_ns, *ns; 119 ns = kobj->ktype->namespace(kobj); 120 init_ns = ops->initial_ns(); 121 return ns != init_ns; 122 } 123 124 return 0; 125 } 126 127 /** 128 * kobject_uevent_env - send an uevent with environmental data 129 * 130 * @action: action that is happening 131 * @kobj: struct kobject that the action is happening to 132 * @envp_ext: pointer to environmental data 133 * 134 * Returns 0 if kobject_uevent_env() is completed with success or the 135 * corresponding error when it fails. 136 */ 137 int kobject_uevent_env(struct kobject *kobj, enum kobject_action action, 138 char *envp_ext[]) 139 { 140 struct kobj_uevent_env *env; 141 const char *action_string = kobject_actions[action]; 142 const char *devpath = NULL; 143 const char *subsystem; 144 struct kobject *top_kobj; 145 struct kset *kset; 146 const struct kset_uevent_ops *uevent_ops; 147 int i = 0; 148 int retval = 0; 149 #ifdef CONFIG_NET 150 struct uevent_sock *ue_sk; 151 #endif 152 153 pr_debug("kobject: '%s' (%p): %s\n", 154 kobject_name(kobj), kobj, __func__); 155 156 /* search the kset we belong to */ 157 top_kobj = kobj; 158 while (!top_kobj->kset && top_kobj->parent) 159 top_kobj = top_kobj->parent; 160 161 if (!top_kobj->kset) { 162 pr_debug("kobject: '%s' (%p): %s: attempted to send uevent " 163 "without kset!\n", kobject_name(kobj), kobj, 164 __func__); 165 return -EINVAL; 166 } 167 168 kset = top_kobj->kset; 169 uevent_ops = kset->uevent_ops; 170 171 /* skip the event, if uevent_suppress is set*/ 172 if (kobj->uevent_suppress) { 173 pr_debug("kobject: '%s' (%p): %s: uevent_suppress " 174 "caused the event to drop!\n", 175 kobject_name(kobj), kobj, __func__); 176 return 0; 177 } 178 /* skip the event, if the filter returns zero. */ 179 if (uevent_ops && uevent_ops->filter) 180 if (!uevent_ops->filter(kset, kobj)) { 181 pr_debug("kobject: '%s' (%p): %s: filter function " 182 "caused the event to drop!\n", 183 kobject_name(kobj), kobj, __func__); 184 return 0; 185 } 186 187 /* originating subsystem */ 188 if (uevent_ops && uevent_ops->name) 189 subsystem = uevent_ops->name(kset, kobj); 190 else 191 subsystem = kobject_name(&kset->kobj); 192 if (!subsystem) { 193 pr_debug("kobject: '%s' (%p): %s: unset subsystem caused the " 194 "event to drop!\n", kobject_name(kobj), kobj, 195 __func__); 196 return 0; 197 } 198 199 /* environment buffer */ 200 env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); 201 if (!env) 202 return -ENOMEM; 203 204 /* complete object path */ 205 devpath = kobject_get_path(kobj, GFP_KERNEL); 206 if (!devpath) { 207 retval = -ENOENT; 208 goto exit; 209 } 210 211 /* default keys */ 212 retval = add_uevent_var(env, "ACTION=%s", action_string); 213 if (retval) 214 goto exit; 215 retval = add_uevent_var(env, "DEVPATH=%s", devpath); 216 if (retval) 217 goto exit; 218 retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem); 219 if (retval) 220 goto exit; 221 222 /* keys passed in from the caller */ 223 if (envp_ext) { 224 for (i = 0; envp_ext[i]; i++) { 225 retval = add_uevent_var(env, "%s", envp_ext[i]); 226 if (retval) 227 goto exit; 228 } 229 } 230 231 /* let the kset specific function add its stuff */ 232 if (uevent_ops && uevent_ops->uevent) { 233 retval = uevent_ops->uevent(kset, kobj, env); 234 if (retval) { 235 pr_debug("kobject: '%s' (%p): %s: uevent() returned " 236 "%d\n", kobject_name(kobj), kobj, 237 __func__, retval); 238 goto exit; 239 } 240 } 241 242 /* 243 * Mark "add" and "remove" events in the object to ensure proper 244 * events to userspace during automatic cleanup. If the object did 245 * send an "add" event, "remove" will automatically generated by 246 * the core, if not already done by the caller. 247 */ 248 if (action == KOBJ_ADD) 249 kobj->state_add_uevent_sent = 1; 250 else if (action == KOBJ_REMOVE) 251 kobj->state_remove_uevent_sent = 1; 252 253 mutex_lock(&uevent_sock_mutex); 254 /* we will send an event, so request a new sequence number */ 255 retval = add_uevent_var(env, "SEQNUM=%llu", (unsigned long long)++uevent_seqnum); 256 if (retval) { 257 mutex_unlock(&uevent_sock_mutex); 258 goto exit; 259 } 260 261 #if defined(CONFIG_NET) 262 /* send netlink message */ 263 list_for_each_entry(ue_sk, &uevent_sock_list, list) { 264 struct sock *uevent_sock = ue_sk->sk; 265 struct sk_buff *skb; 266 size_t len; 267 268 if (!netlink_has_listeners(uevent_sock, 1)) 269 continue; 270 271 /* allocate message with the maximum possible size */ 272 len = strlen(action_string) + strlen(devpath) + 2; 273 skb = alloc_skb(len + env->buflen, GFP_KERNEL); 274 if (skb) { 275 char *scratch; 276 277 /* add header */ 278 scratch = skb_put(skb, len); 279 sprintf(scratch, "%s@%s", action_string, devpath); 280 281 /* copy keys to our continuous event payload buffer */ 282 for (i = 0; i < env->envp_idx; i++) { 283 len = strlen(env->envp[i]) + 1; 284 scratch = skb_put(skb, len); 285 strcpy(scratch, env->envp[i]); 286 } 287 288 NETLINK_CB(skb).dst_group = 1; 289 retval = netlink_broadcast_filtered(uevent_sock, skb, 290 0, 1, GFP_KERNEL, 291 kobj_bcast_filter, 292 kobj); 293 /* ENOBUFS should be handled in userspace */ 294 if (retval == -ENOBUFS || retval == -ESRCH) 295 retval = 0; 296 } else 297 retval = -ENOMEM; 298 } 299 #endif 300 mutex_unlock(&uevent_sock_mutex); 301 302 /* call uevent_helper, usually only enabled during early boot */ 303 if (uevent_helper[0] && !kobj_usermode_filter(kobj)) { 304 char *argv [3]; 305 306 argv [0] = uevent_helper; 307 argv [1] = (char *)subsystem; 308 argv [2] = NULL; 309 retval = add_uevent_var(env, "HOME=/"); 310 if (retval) 311 goto exit; 312 retval = add_uevent_var(env, 313 "PATH=/sbin:/bin:/usr/sbin:/usr/bin"); 314 if (retval) 315 goto exit; 316 317 retval = call_usermodehelper(argv[0], argv, 318 env->envp, UMH_WAIT_EXEC); 319 } 320 321 exit: 322 kfree(devpath); 323 kfree(env); 324 return retval; 325 } 326 EXPORT_SYMBOL_GPL(kobject_uevent_env); 327 328 /** 329 * kobject_uevent - notify userspace by sending an uevent 330 * 331 * @action: action that is happening 332 * @kobj: struct kobject that the action is happening to 333 * 334 * Returns 0 if kobject_uevent() is completed with success or the 335 * corresponding error when it fails. 336 */ 337 int kobject_uevent(struct kobject *kobj, enum kobject_action action) 338 { 339 return kobject_uevent_env(kobj, action, NULL); 340 } 341 EXPORT_SYMBOL_GPL(kobject_uevent); 342 343 /** 344 * add_uevent_var - add key value string to the environment buffer 345 * @env: environment buffer structure 346 * @format: printf format for the key=value pair 347 * 348 * Returns 0 if environment variable was added successfully or -ENOMEM 349 * if no space was available. 350 */ 351 int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...) 352 { 353 va_list args; 354 int len; 355 356 if (env->envp_idx >= ARRAY_SIZE(env->envp)) { 357 WARN(1, KERN_ERR "add_uevent_var: too many keys\n"); 358 return -ENOMEM; 359 } 360 361 va_start(args, format); 362 len = vsnprintf(&env->buf[env->buflen], 363 sizeof(env->buf) - env->buflen, 364 format, args); 365 va_end(args); 366 367 if (len >= (sizeof(env->buf) - env->buflen)) { 368 WARN(1, KERN_ERR "add_uevent_var: buffer size too small\n"); 369 return -ENOMEM; 370 } 371 372 env->envp[env->envp_idx++] = &env->buf[env->buflen]; 373 env->buflen += len + 1; 374 return 0; 375 } 376 EXPORT_SYMBOL_GPL(add_uevent_var); 377 378 #if defined(CONFIG_NET) 379 static int uevent_net_init(struct net *net) 380 { 381 struct uevent_sock *ue_sk; 382 struct netlink_kernel_cfg cfg = { 383 .groups = 1, 384 .flags = NL_CFG_F_NONROOT_RECV, 385 }; 386 387 ue_sk = kzalloc(sizeof(*ue_sk), GFP_KERNEL); 388 if (!ue_sk) 389 return -ENOMEM; 390 391 ue_sk->sk = netlink_kernel_create(net, NETLINK_KOBJECT_UEVENT, &cfg); 392 if (!ue_sk->sk) { 393 printk(KERN_ERR 394 "kobject_uevent: unable to create netlink socket!\n"); 395 kfree(ue_sk); 396 return -ENODEV; 397 } 398 mutex_lock(&uevent_sock_mutex); 399 list_add_tail(&ue_sk->list, &uevent_sock_list); 400 mutex_unlock(&uevent_sock_mutex); 401 return 0; 402 } 403 404 static void uevent_net_exit(struct net *net) 405 { 406 struct uevent_sock *ue_sk; 407 408 mutex_lock(&uevent_sock_mutex); 409 list_for_each_entry(ue_sk, &uevent_sock_list, list) { 410 if (sock_net(ue_sk->sk) == net) 411 goto found; 412 } 413 mutex_unlock(&uevent_sock_mutex); 414 return; 415 416 found: 417 list_del(&ue_sk->list); 418 mutex_unlock(&uevent_sock_mutex); 419 420 netlink_kernel_release(ue_sk->sk); 421 kfree(ue_sk); 422 } 423 424 static struct pernet_operations uevent_net_ops = { 425 .init = uevent_net_init, 426 .exit = uevent_net_exit, 427 }; 428 429 static int __init kobject_uevent_init(void) 430 { 431 return register_pernet_subsys(&uevent_net_ops); 432 } 433 434 435 postcore_initcall(kobject_uevent_init); 436 #endif 437