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