2 kmod, the new module loader (replaces kerneld)
5 Reorganized not to be a daemon by Adam Richter, with guidance
8 Modified to avoid chroot and file sharing problems.
11 Limit the concurrent number of kmod modprobes to catch loops from
12 "modprobe needs a service that is in a module".
13 Keith Owens <kaos@ocs.com.au> December 1999
15 Unblock all signals when we exec a usermode process.
16 Shuu Yamaguchi <shuu@wondernetworkresources.com> December 2000
18 call_usermodehelper wait flag, and remove exec_usermodehelper.
19 Rusty Russell <rusty@rustcorp.com.au> Jan 2003
21 #include <linux/module.h>
22 #include <linux/sched.h>
23 #include <linux/syscalls.h>
24 #include <linux/unistd.h>
25 #include <linux/kmod.h>
26 #include <linux/slab.h>
27 #include <linux/completion.h>
28 #include <linux/cred.h>
29 #include <linux/file.h>
30 #include <linux/fdtable.h>
31 #include <linux/workqueue.h>
32 #include <linux/security.h>
33 #include <linux/mount.h>
34 #include <linux/kernel.h>
35 #include <linux/init.h>
36 #include <linux/resource.h>
37 #include <linux/notifier.h>
38 #include <linux/suspend.h>
39 #include <linux/rwsem.h>
40 #include <asm/uaccess.h>
42 #include <trace/events/module.h>
44 extern int max_threads
;
46 static struct workqueue_struct
*khelper_wq
;
48 #define CAP_BSET (void *)1
49 #define CAP_PI (void *)2
51 static kernel_cap_t usermodehelper_bset
= CAP_FULL_SET
;
52 static kernel_cap_t usermodehelper_inheritable
= CAP_FULL_SET
;
53 static DEFINE_SPINLOCK(umh_sysctl_lock
);
54 static DECLARE_RWSEM(umhelper_sem
);
59 modprobe_path is set via /proc/sys.
61 char modprobe_path
[KMOD_PATH_LEN
] = "/sbin/modprobe";
63 static void free_modprobe_argv(struct subprocess_info
*info
)
65 kfree(info
->argv
[3]); /* check call_modprobe() */
69 static int call_modprobe(char *module_name
, int wait
)
71 static char *envp
[] = {
74 "PATH=/sbin:/usr/sbin:/bin:/usr/bin",
78 char **argv
= kmalloc(sizeof(char *[5]), GFP_KERNEL
);
82 module_name
= kstrdup(module_name
, GFP_KERNEL
);
86 argv
[0] = modprobe_path
;
89 argv
[3] = module_name
; /* check free_modprobe_argv() */
92 return call_usermodehelper_fns(modprobe_path
, argv
, envp
,
93 wait
| UMH_KILLABLE
, NULL
, free_modprobe_argv
, NULL
);
101 * __request_module - try to load a kernel module
102 * @wait: wait (or not) for the operation to complete
103 * @fmt: printf style format string for the name of the module
104 * @...: arguments as specified in the format string
106 * Load a module using the user mode module loader. The function returns
107 * zero on success or a negative errno code on failure. Note that a
108 * successful module load does not mean the module did not then unload
109 * and exit on an error of its own. Callers must check that the service
110 * they requested is now available not blindly invoke it.
112 * If module auto-loading support is disabled then this function
113 * becomes a no-operation.
115 int __request_module(bool wait
, const char *fmt
, ...)
118 char module_name
[MODULE_NAME_LEN
];
119 unsigned int max_modprobes
;
121 static atomic_t kmod_concurrent
= ATOMIC_INIT(0);
122 #define MAX_KMOD_CONCURRENT 50 /* Completely arbitrary value - KAO */
123 static int kmod_loop_msg
;
126 ret
= vsnprintf(module_name
, MODULE_NAME_LEN
, fmt
, args
);
128 if (ret
>= MODULE_NAME_LEN
)
129 return -ENAMETOOLONG
;
131 ret
= security_kernel_module_request(module_name
);
135 /* If modprobe needs a service that is in a module, we get a recursive
136 * loop. Limit the number of running kmod threads to max_threads/2 or
137 * MAX_KMOD_CONCURRENT, whichever is the smaller. A cleaner method
138 * would be to run the parents of this process, counting how many times
139 * kmod was invoked. That would mean accessing the internals of the
140 * process tables to get the command line, proc_pid_cmdline is static
141 * and it is not worth changing the proc code just to handle this case.
144 * "trace the ppid" is simple, but will fail if someone's
145 * parent exits. I think this is as good as it gets. --RR
147 max_modprobes
= min(max_threads
/2, MAX_KMOD_CONCURRENT
);
148 atomic_inc(&kmod_concurrent
);
149 if (atomic_read(&kmod_concurrent
) > max_modprobes
) {
150 /* We may be blaming an innocent here, but unlikely */
151 if (kmod_loop_msg
< 5) {
153 "request_module: runaway loop modprobe %s\n",
157 atomic_dec(&kmod_concurrent
);
161 trace_module_request(module_name
, wait
, _RET_IP_
);
163 ret
= call_modprobe(module_name
, wait
? UMH_WAIT_PROC
: UMH_WAIT_EXEC
);
165 atomic_dec(&kmod_concurrent
);
168 EXPORT_SYMBOL(__request_module
);
169 #endif /* CONFIG_MODULES */
172 * This is the task which runs the usermode application
174 static int ____call_usermodehelper(void *data
)
176 struct subprocess_info
*sub_info
= data
;
180 spin_lock_irq(¤t
->sighand
->siglock
);
181 flush_signal_handlers(current
, 1);
182 spin_unlock_irq(¤t
->sighand
->siglock
);
184 /* We can run anywhere, unlike our parent keventd(). */
185 set_cpus_allowed_ptr(current
, cpu_all_mask
);
188 * Our parent is keventd, which runs with elevated scheduling priority.
189 * Avoid propagating that into the userspace child.
191 set_user_nice(current
, 0);
194 new = prepare_kernel_cred(current
);
198 spin_lock(&umh_sysctl_lock
);
199 new->cap_bset
= cap_intersect(usermodehelper_bset
, new->cap_bset
);
200 new->cap_inheritable
= cap_intersect(usermodehelper_inheritable
,
201 new->cap_inheritable
);
202 spin_unlock(&umh_sysctl_lock
);
204 if (sub_info
->init
) {
205 retval
= sub_info
->init(sub_info
, new);
214 retval
= kernel_execve(sub_info
->path
,
215 (const char *const *)sub_info
->argv
,
216 (const char *const *)sub_info
->envp
);
220 sub_info
->retval
= retval
;
224 static void call_usermodehelper_freeinfo(struct subprocess_info
*info
)
227 (*info
->cleanup
)(info
);
231 static void umh_complete(struct subprocess_info
*sub_info
)
233 struct completion
*comp
= xchg(&sub_info
->complete
, NULL
);
235 * See call_usermodehelper_exec(). If xchg() returns NULL
236 * we own sub_info, the UMH_KILLABLE caller has gone away.
241 call_usermodehelper_freeinfo(sub_info
);
244 /* Keventd can't block, but this (a child) can. */
245 static int wait_for_helper(void *data
)
247 struct subprocess_info
*sub_info
= data
;
250 /* If SIGCLD is ignored sys_wait4 won't populate the status. */
251 spin_lock_irq(¤t
->sighand
->siglock
);
252 current
->sighand
->action
[SIGCHLD
-1].sa
.sa_handler
= SIG_DFL
;
253 spin_unlock_irq(¤t
->sighand
->siglock
);
255 pid
= kernel_thread(____call_usermodehelper
, sub_info
, SIGCHLD
);
257 sub_info
->retval
= pid
;
261 * Normally it is bogus to call wait4() from in-kernel because
262 * wait4() wants to write the exit code to a userspace address.
263 * But wait_for_helper() always runs as keventd, and put_user()
264 * to a kernel address works OK for kernel threads, due to their
265 * having an mm_segment_t which spans the entire address space.
267 * Thus the __user pointer cast is valid here.
269 sys_wait4(pid
, (int __user
*)&ret
, 0, NULL
);
272 * If ret is 0, either ____call_usermodehelper failed and the
273 * real error code is already in sub_info->retval or
274 * sub_info->retval is 0 anyway, so don't mess with it then.
277 sub_info
->retval
= ret
;
280 umh_complete(sub_info
);
284 /* This is run by khelper thread */
285 static void __call_usermodehelper(struct work_struct
*work
)
287 struct subprocess_info
*sub_info
=
288 container_of(work
, struct subprocess_info
, work
);
289 int wait
= sub_info
->wait
& ~UMH_KILLABLE
;
292 /* CLONE_VFORK: wait until the usermode helper has execve'd
293 * successfully We need the data structures to stay around
294 * until that is done. */
295 if (wait
== UMH_WAIT_PROC
)
296 pid
= kernel_thread(wait_for_helper
, sub_info
,
297 CLONE_FS
| CLONE_FILES
| SIGCHLD
);
299 pid
= kernel_thread(____call_usermodehelper
, sub_info
,
300 CLONE_VFORK
| SIGCHLD
);
304 call_usermodehelper_freeinfo(sub_info
);
313 sub_info
->retval
= pid
;
314 umh_complete(sub_info
);
319 * If set, call_usermodehelper_exec() will exit immediately returning -EBUSY
320 * (used for preventing user land processes from being created after the user
321 * land has been frozen during a system-wide hibernation or suspend operation).
322 * Should always be manipulated under umhelper_sem acquired for write.
324 static enum umh_disable_depth usermodehelper_disabled
= UMH_DISABLED
;
326 /* Number of helpers running */
327 static atomic_t running_helpers
= ATOMIC_INIT(0);
330 * Wait queue head used by usermodehelper_disable() to wait for all running
333 static DECLARE_WAIT_QUEUE_HEAD(running_helpers_waitq
);
336 * Used by usermodehelper_read_lock_wait() to wait for usermodehelper_disabled
339 static DECLARE_WAIT_QUEUE_HEAD(usermodehelper_disabled_waitq
);
342 * Time to wait for running_helpers to become zero before the setting of
343 * usermodehelper_disabled in usermodehelper_disable() fails
345 #define RUNNING_HELPERS_TIMEOUT (5 * HZ)
347 int usermodehelper_read_trylock(void)
352 down_read(&umhelper_sem
);
354 prepare_to_wait(&usermodehelper_disabled_waitq
, &wait
,
356 if (!usermodehelper_disabled
)
359 if (usermodehelper_disabled
== UMH_DISABLED
)
362 up_read(&umhelper_sem
);
370 down_read(&umhelper_sem
);
372 finish_wait(&usermodehelper_disabled_waitq
, &wait
);
375 EXPORT_SYMBOL_GPL(usermodehelper_read_trylock
);
377 long usermodehelper_read_lock_wait(long timeout
)
384 down_read(&umhelper_sem
);
386 prepare_to_wait(&usermodehelper_disabled_waitq
, &wait
,
387 TASK_UNINTERRUPTIBLE
);
388 if (!usermodehelper_disabled
)
391 up_read(&umhelper_sem
);
393 timeout
= schedule_timeout(timeout
);
397 down_read(&umhelper_sem
);
399 finish_wait(&usermodehelper_disabled_waitq
, &wait
);
402 EXPORT_SYMBOL_GPL(usermodehelper_read_lock_wait
);
404 void usermodehelper_read_unlock(void)
406 up_read(&umhelper_sem
);
408 EXPORT_SYMBOL_GPL(usermodehelper_read_unlock
);
411 * __usermodehelper_set_disable_depth - Modify usermodehelper_disabled.
412 * depth: New value to assign to usermodehelper_disabled.
414 * Change the value of usermodehelper_disabled (under umhelper_sem locked for
415 * writing) and wakeup tasks waiting for it to change.
417 void __usermodehelper_set_disable_depth(enum umh_disable_depth depth
)
419 down_write(&umhelper_sem
);
420 usermodehelper_disabled
= depth
;
421 wake_up(&usermodehelper_disabled_waitq
);
422 up_write(&umhelper_sem
);
426 * __usermodehelper_disable - Prevent new helpers from being started.
427 * @depth: New value to assign to usermodehelper_disabled.
429 * Set usermodehelper_disabled to @depth and wait for running helpers to exit.
431 int __usermodehelper_disable(enum umh_disable_depth depth
)
438 down_write(&umhelper_sem
);
439 usermodehelper_disabled
= depth
;
440 up_write(&umhelper_sem
);
443 * From now on call_usermodehelper_exec() won't start any new
444 * helpers, so it is sufficient if running_helpers turns out to
445 * be zero at one point (it may be increased later, but that
448 retval
= wait_event_timeout(running_helpers_waitq
,
449 atomic_read(&running_helpers
) == 0,
450 RUNNING_HELPERS_TIMEOUT
);
454 __usermodehelper_set_disable_depth(UMH_ENABLED
);
458 static void helper_lock(void)
460 atomic_inc(&running_helpers
);
461 smp_mb__after_atomic_inc();
464 static void helper_unlock(void)
466 if (atomic_dec_and_test(&running_helpers
))
467 wake_up(&running_helpers_waitq
);
471 * call_usermodehelper_setup - prepare to call a usermode helper
472 * @path: path to usermode executable
473 * @argv: arg vector for process
474 * @envp: environment for process
475 * @gfp_mask: gfp mask for memory allocation
477 * Returns either %NULL on allocation failure, or a subprocess_info
478 * structure. This should be passed to call_usermodehelper_exec to
479 * exec the process and free the structure.
481 struct subprocess_info
*call_usermodehelper_setup(char *path
, char **argv
,
482 char **envp
, gfp_t gfp_mask
)
484 struct subprocess_info
*sub_info
;
485 sub_info
= kzalloc(sizeof(struct subprocess_info
), gfp_mask
);
489 INIT_WORK(&sub_info
->work
, __call_usermodehelper
);
490 sub_info
->path
= path
;
491 sub_info
->argv
= argv
;
492 sub_info
->envp
= envp
;
496 EXPORT_SYMBOL(call_usermodehelper_setup
);
499 * call_usermodehelper_setfns - set a cleanup/init function
500 * @info: a subprocess_info returned by call_usermodehelper_setup
501 * @cleanup: a cleanup function
502 * @init: an init function
503 * @data: arbitrary context sensitive data
505 * The init function is used to customize the helper process prior to
506 * exec. A non-zero return code causes the process to error out, exit,
507 * and return the failure to the calling process
509 * The cleanup function is just before ethe subprocess_info is about to
510 * be freed. This can be used for freeing the argv and envp. The
511 * Function must be runnable in either a process context or the
512 * context in which call_usermodehelper_exec is called.
514 void call_usermodehelper_setfns(struct subprocess_info
*info
,
515 int (*init
)(struct subprocess_info
*info
, struct cred
*new),
516 void (*cleanup
)(struct subprocess_info
*info
),
519 info
->cleanup
= cleanup
;
523 EXPORT_SYMBOL(call_usermodehelper_setfns
);
526 * call_usermodehelper_exec - start a usermode application
527 * @sub_info: information about the subprocessa
528 * @wait: wait for the application to finish and return status.
529 * when -1 don't wait at all, but you get no useful error back when
530 * the program couldn't be exec'ed. This makes it safe to call
531 * from interrupt context.
533 * Runs a user-space application. The application is started
534 * asynchronously if wait is not set, and runs as a child of keventd.
535 * (ie. it runs with full root capabilities).
537 int call_usermodehelper_exec(struct subprocess_info
*sub_info
, int wait
)
539 DECLARE_COMPLETION_ONSTACK(done
);
543 if (sub_info
->path
[0] == '\0')
546 if (!khelper_wq
|| usermodehelper_disabled
) {
551 sub_info
->complete
= &done
;
552 sub_info
->wait
= wait
;
554 queue_work(khelper_wq
, &sub_info
->work
);
555 if (wait
== UMH_NO_WAIT
) /* task has freed sub_info */
558 if (wait
& UMH_KILLABLE
) {
559 retval
= wait_for_completion_killable(&done
);
563 /* umh_complete() will see NULL and free sub_info */
564 if (xchg(&sub_info
->complete
, NULL
))
566 /* fallthrough, umh_complete() was already called */
569 wait_for_completion(&done
);
571 retval
= sub_info
->retval
;
573 call_usermodehelper_freeinfo(sub_info
);
578 EXPORT_SYMBOL(call_usermodehelper_exec
);
580 static int proc_cap_handler(struct ctl_table
*table
, int write
,
581 void __user
*buffer
, size_t *lenp
, loff_t
*ppos
)
584 unsigned long cap_array
[_KERNEL_CAPABILITY_U32S
];
585 kernel_cap_t new_cap
;
588 if (write
&& (!capable(CAP_SETPCAP
) ||
589 !capable(CAP_SYS_MODULE
)))
593 * convert from the global kernel_cap_t to the ulong array to print to
594 * userspace if this is a read.
596 spin_lock(&umh_sysctl_lock
);
597 for (i
= 0; i
< _KERNEL_CAPABILITY_U32S
; i
++) {
598 if (table
->data
== CAP_BSET
)
599 cap_array
[i
] = usermodehelper_bset
.cap
[i
];
600 else if (table
->data
== CAP_PI
)
601 cap_array
[i
] = usermodehelper_inheritable
.cap
[i
];
605 spin_unlock(&umh_sysctl_lock
);
611 * actually read or write and array of ulongs from userspace. Remember
612 * these are least significant 32 bits first
614 err
= proc_doulongvec_minmax(&t
, write
, buffer
, lenp
, ppos
);
619 * convert from the sysctl array of ulongs to the kernel_cap_t
620 * internal representation
622 for (i
= 0; i
< _KERNEL_CAPABILITY_U32S
; i
++)
623 new_cap
.cap
[i
] = cap_array
[i
];
626 * Drop everything not in the new_cap (but don't add things)
628 spin_lock(&umh_sysctl_lock
);
630 if (table
->data
== CAP_BSET
)
631 usermodehelper_bset
= cap_intersect(usermodehelper_bset
, new_cap
);
632 if (table
->data
== CAP_PI
)
633 usermodehelper_inheritable
= cap_intersect(usermodehelper_inheritable
, new_cap
);
635 spin_unlock(&umh_sysctl_lock
);
640 struct ctl_table usermodehelper_table
[] = {
644 .maxlen
= _KERNEL_CAPABILITY_U32S
* sizeof(unsigned long),
646 .proc_handler
= proc_cap_handler
,
649 .procname
= "inheritable",
651 .maxlen
= _KERNEL_CAPABILITY_U32S
* sizeof(unsigned long),
653 .proc_handler
= proc_cap_handler
,
658 void __init
usermodehelper_init(void)
660 khelper_wq
= create_singlethread_workqueue("khelper");