Contents of /alx-src/tags/kernel26-2.6.12-alx-r9/kernel/kmod.c
Parent Directory | Revision Log
Revision 630 -
(show annotations)
(download)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 7386 byte(s)
Wed Mar 4 11:03:09 2009 UTC (15 years, 6 months ago) by niro
File MIME type: text/plain
File size: 7386 byte(s)
Tag kernel26-2.6.12-alx-r9
1 | /* |
2 | kmod, the new module loader (replaces kerneld) |
3 | Kirk Petersen |
4 | |
5 | Reorganized not to be a daemon by Adam Richter, with guidance |
6 | from Greg Zornetzer. |
7 | |
8 | Modified to avoid chroot and file sharing problems. |
9 | Mikael Pettersson |
10 | |
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 |
14 | |
15 | Unblock all signals when we exec a usermode process. |
16 | Shuu Yamaguchi <shuu@wondernetworkresources.com> December 2000 |
17 | |
18 | call_usermodehelper wait flag, and remove exec_usermodehelper. |
19 | Rusty Russell <rusty@rustcorp.com.au> Jan 2003 |
20 | */ |
21 | #define __KERNEL_SYSCALLS__ |
22 | |
23 | #include <linux/config.h> |
24 | #include <linux/module.h> |
25 | #include <linux/sched.h> |
26 | #include <linux/syscalls.h> |
27 | #include <linux/unistd.h> |
28 | #include <linux/kmod.h> |
29 | #include <linux/smp_lock.h> |
30 | #include <linux/slab.h> |
31 | #include <linux/namespace.h> |
32 | #include <linux/completion.h> |
33 | #include <linux/file.h> |
34 | #include <linux/workqueue.h> |
35 | #include <linux/security.h> |
36 | #include <linux/mount.h> |
37 | #include <linux/kernel.h> |
38 | #include <linux/init.h> |
39 | #include <asm/uaccess.h> |
40 | |
41 | extern int max_threads; |
42 | |
43 | static struct workqueue_struct *khelper_wq; |
44 | |
45 | #ifdef CONFIG_KMOD |
46 | |
47 | /* |
48 | modprobe_path is set via /proc/sys. |
49 | */ |
50 | char modprobe_path[KMOD_PATH_LEN] = "/sbin/modprobe"; |
51 | |
52 | /** |
53 | * request_module - try to load a kernel module |
54 | * @fmt: printf style format string for the name of the module |
55 | * @varargs: arguements as specified in the format string |
56 | * |
57 | * Load a module using the user mode module loader. The function returns |
58 | * zero on success or a negative errno code on failure. Note that a |
59 | * successful module load does not mean the module did not then unload |
60 | * and exit on an error of its own. Callers must check that the service |
61 | * they requested is now available not blindly invoke it. |
62 | * |
63 | * If module auto-loading support is disabled then this function |
64 | * becomes a no-operation. |
65 | */ |
66 | int request_module(const char *fmt, ...) |
67 | { |
68 | va_list args; |
69 | char module_name[MODULE_NAME_LEN]; |
70 | unsigned int max_modprobes; |
71 | int ret; |
72 | char *argv[] = { modprobe_path, "-q", "--", module_name, NULL }; |
73 | static char *envp[] = { "HOME=/", |
74 | "TERM=linux", |
75 | "PATH=/sbin:/usr/sbin:/bin:/usr/bin", |
76 | NULL }; |
77 | static atomic_t kmod_concurrent = ATOMIC_INIT(0); |
78 | #define MAX_KMOD_CONCURRENT 50 /* Completely arbitrary value - KAO */ |
79 | static int kmod_loop_msg; |
80 | |
81 | va_start(args, fmt); |
82 | ret = vsnprintf(module_name, MODULE_NAME_LEN, fmt, args); |
83 | va_end(args); |
84 | if (ret >= MODULE_NAME_LEN) |
85 | return -ENAMETOOLONG; |
86 | |
87 | /* If modprobe needs a service that is in a module, we get a recursive |
88 | * loop. Limit the number of running kmod threads to max_threads/2 or |
89 | * MAX_KMOD_CONCURRENT, whichever is the smaller. A cleaner method |
90 | * would be to run the parents of this process, counting how many times |
91 | * kmod was invoked. That would mean accessing the internals of the |
92 | * process tables to get the command line, proc_pid_cmdline is static |
93 | * and it is not worth changing the proc code just to handle this case. |
94 | * KAO. |
95 | * |
96 | * "trace the ppid" is simple, but will fail if someone's |
97 | * parent exits. I think this is as good as it gets. --RR |
98 | */ |
99 | max_modprobes = min(max_threads/2, MAX_KMOD_CONCURRENT); |
100 | atomic_inc(&kmod_concurrent); |
101 | if (atomic_read(&kmod_concurrent) > max_modprobes) { |
102 | /* We may be blaming an innocent here, but unlikely */ |
103 | if (kmod_loop_msg++ < 5) |
104 | printk(KERN_ERR |
105 | "request_module: runaway loop modprobe %s\n", |
106 | module_name); |
107 | atomic_dec(&kmod_concurrent); |
108 | return -ENOMEM; |
109 | } |
110 | |
111 | ret = call_usermodehelper(modprobe_path, argv, envp, 1); |
112 | atomic_dec(&kmod_concurrent); |
113 | return ret; |
114 | } |
115 | EXPORT_SYMBOL(request_module); |
116 | #endif /* CONFIG_KMOD */ |
117 | |
118 | struct subprocess_info { |
119 | struct completion *complete; |
120 | char *path; |
121 | char **argv; |
122 | char **envp; |
123 | int wait; |
124 | int retval; |
125 | }; |
126 | |
127 | /* |
128 | * This is the task which runs the usermode application |
129 | */ |
130 | static int ____call_usermodehelper(void *data) |
131 | { |
132 | struct subprocess_info *sub_info = data; |
133 | int retval; |
134 | |
135 | /* Unblock all signals. */ |
136 | flush_signals(current); |
137 | spin_lock_irq(¤t->sighand->siglock); |
138 | flush_signal_handlers(current, 1); |
139 | sigemptyset(¤t->blocked); |
140 | recalc_sigpending(); |
141 | spin_unlock_irq(¤t->sighand->siglock); |
142 | |
143 | /* We can run anywhere, unlike our parent keventd(). */ |
144 | set_cpus_allowed(current, CPU_MASK_ALL); |
145 | |
146 | retval = -EPERM; |
147 | if (current->fs->root) |
148 | retval = execve(sub_info->path, sub_info->argv,sub_info->envp); |
149 | |
150 | /* Exec failed? */ |
151 | sub_info->retval = retval; |
152 | do_exit(0); |
153 | } |
154 | |
155 | /* Keventd can't block, but this (a child) can. */ |
156 | static int wait_for_helper(void *data) |
157 | { |
158 | struct subprocess_info *sub_info = data; |
159 | pid_t pid; |
160 | struct k_sigaction sa; |
161 | |
162 | /* Install a handler: if SIGCLD isn't handled sys_wait4 won't |
163 | * populate the status, but will return -ECHILD. */ |
164 | sa.sa.sa_handler = SIG_IGN; |
165 | sa.sa.sa_flags = 0; |
166 | siginitset(&sa.sa.sa_mask, sigmask(SIGCHLD)); |
167 | do_sigaction(SIGCHLD, &sa, (struct k_sigaction *)0); |
168 | allow_signal(SIGCHLD); |
169 | |
170 | pid = kernel_thread(____call_usermodehelper, sub_info, SIGCHLD); |
171 | if (pid < 0) { |
172 | sub_info->retval = pid; |
173 | } else { |
174 | /* |
175 | * Normally it is bogus to call wait4() from in-kernel because |
176 | * wait4() wants to write the exit code to a userspace address. |
177 | * But wait_for_helper() always runs as keventd, and put_user() |
178 | * to a kernel address works OK for kernel threads, due to their |
179 | * having an mm_segment_t which spans the entire address space. |
180 | * |
181 | * Thus the __user pointer cast is valid here. |
182 | */ |
183 | sys_wait4(pid, (int __user *) &sub_info->retval, 0, NULL); |
184 | } |
185 | |
186 | complete(sub_info->complete); |
187 | return 0; |
188 | } |
189 | |
190 | /* This is run by khelper thread */ |
191 | static void __call_usermodehelper(void *data) |
192 | { |
193 | struct subprocess_info *sub_info = data; |
194 | pid_t pid; |
195 | |
196 | /* CLONE_VFORK: wait until the usermode helper has execve'd |
197 | * successfully We need the data structures to stay around |
198 | * until that is done. */ |
199 | if (sub_info->wait) |
200 | pid = kernel_thread(wait_for_helper, sub_info, |
201 | CLONE_FS | CLONE_FILES | SIGCHLD); |
202 | else |
203 | pid = kernel_thread(____call_usermodehelper, sub_info, |
204 | CLONE_VFORK | SIGCHLD); |
205 | |
206 | if (pid < 0) { |
207 | sub_info->retval = pid; |
208 | complete(sub_info->complete); |
209 | } else if (!sub_info->wait) |
210 | complete(sub_info->complete); |
211 | } |
212 | |
213 | /** |
214 | * call_usermodehelper - start a usermode application |
215 | * @path: pathname for the application |
216 | * @argv: null-terminated argument list |
217 | * @envp: null-terminated environment list |
218 | * @wait: wait for the application to finish and return status. |
219 | * |
220 | * Runs a user-space application. The application is started |
221 | * asynchronously if wait is not set, and runs as a child of keventd. |
222 | * (ie. it runs with full root capabilities). |
223 | * |
224 | * Must be called from process context. Returns a negative error code |
225 | * if program was not execed successfully, or 0. |
226 | */ |
227 | int call_usermodehelper(char *path, char **argv, char **envp, int wait) |
228 | { |
229 | DECLARE_COMPLETION(done); |
230 | struct subprocess_info sub_info = { |
231 | .complete = &done, |
232 | .path = path, |
233 | .argv = argv, |
234 | .envp = envp, |
235 | .wait = wait, |
236 | .retval = 0, |
237 | }; |
238 | DECLARE_WORK(work, __call_usermodehelper, &sub_info); |
239 | |
240 | if (!khelper_wq) |
241 | return -EBUSY; |
242 | |
243 | if (path[0] == '\0') |
244 | return 0; |
245 | |
246 | queue_work(khelper_wq, &work); |
247 | wait_for_completion(&done); |
248 | return sub_info.retval; |
249 | } |
250 | EXPORT_SYMBOL(call_usermodehelper); |
251 | |
252 | void __init usermodehelper_init(void) |
253 | { |
254 | khelper_wq = create_singlethread_workqueue("khelper"); |
255 | BUG_ON(!khelper_wq); |
256 | } |