Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit f066a4f6df68f03b565dfe867dde54dfeb26576e

Authored by Rusty Russell
Committed by Linus Torvalds
1 parent 86a7b7ef54
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

param: don't complain about unused module parameters. 

Jon confirms that recent modprobe will look in /proc/cmdline, so these
cmdline options can still be used.

See http://bugzilla.kernel.org/show_bug.cgi?id=14164

Reported-by: Adam Williamson <awilliam@redhat.com>
Cc: stable@kernel.org
Signed-off-by: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 1 changed file with 3 additions and 8 deletions Inline Diff

1 /* 1 /*
2 * linux/init/main.c 2 * linux/init/main.c
3 * 3 *
4 * Copyright (C) 1991, 1992 Linus Torvalds 4 * Copyright (C) 1991, 1992 Linus Torvalds
5 * 5 *
6 * GK 2/5/95 - Changed to support mounting root fs via NFS 6 * GK 2/5/95 - Changed to support mounting root fs via NFS
7 * Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96 7 * Added initrd & change_root: Werner Almesberger & Hans Lermen, Feb '96
8 * Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96 8 * Moan early if gcc is old, avoiding bogus kernels - Paul Gortmaker, May '96
9 * Simplified starting of init: Michael A. Griffith <grif@acm.org> 9 * Simplified starting of init: Michael A. Griffith <grif@acm.org>
10 */ 10 */
11 11
12 #include <linux/types.h> 12 #include <linux/types.h>
13 #include <linux/module.h> 13 #include <linux/module.h>
14 #include <linux/proc_fs.h> 14 #include <linux/proc_fs.h>
15 #include <linux/kernel.h> 15 #include <linux/kernel.h>
16 #include <linux/syscalls.h> 16 #include <linux/syscalls.h>
17 #include <linux/stackprotector.h> 17 #include <linux/stackprotector.h>
18 #include <linux/string.h> 18 #include <linux/string.h>
19 #include <linux/ctype.h> 19 #include <linux/ctype.h>
20 #include <linux/delay.h> 20 #include <linux/delay.h>
21 #include <linux/ioport.h> 21 #include <linux/ioport.h>
22 #include <linux/init.h> 22 #include <linux/init.h>
23 #include <linux/smp_lock.h> 23 #include <linux/smp_lock.h>
24 #include <linux/initrd.h> 24 #include <linux/initrd.h>
25 #include <linux/bootmem.h> 25 #include <linux/bootmem.h>
26 #include <linux/acpi.h> 26 #include <linux/acpi.h>
27 #include <linux/tty.h> 27 #include <linux/tty.h>
28 #include <linux/gfp.h> 28 #include <linux/gfp.h>
29 #include <linux/percpu.h> 29 #include <linux/percpu.h>
30 #include <linux/kmod.h> 30 #include <linux/kmod.h>
31 #include <linux/vmalloc.h> 31 #include <linux/vmalloc.h>
32 #include <linux/kernel_stat.h> 32 #include <linux/kernel_stat.h>
33 #include <linux/start_kernel.h> 33 #include <linux/start_kernel.h>
34 #include <linux/security.h> 34 #include <linux/security.h>
35 #include <linux/smp.h> 35 #include <linux/smp.h>
36 #include <linux/workqueue.h> 36 #include <linux/workqueue.h>
37 #include <linux/profile.h> 37 #include <linux/profile.h>
38 #include <linux/rcupdate.h> 38 #include <linux/rcupdate.h>
39 #include <linux/moduleparam.h> 39 #include <linux/moduleparam.h>
40 #include <linux/kallsyms.h> 40 #include <linux/kallsyms.h>
41 #include <linux/writeback.h> 41 #include <linux/writeback.h>
42 #include <linux/cpu.h> 42 #include <linux/cpu.h>
43 #include <linux/cpuset.h> 43 #include <linux/cpuset.h>
44 #include <linux/cgroup.h> 44 #include <linux/cgroup.h>
45 #include <linux/efi.h> 45 #include <linux/efi.h>
46 #include <linux/tick.h> 46 #include <linux/tick.h>
47 #include <linux/interrupt.h> 47 #include <linux/interrupt.h>
48 #include <linux/taskstats_kern.h> 48 #include <linux/taskstats_kern.h>
49 #include <linux/delayacct.h> 49 #include <linux/delayacct.h>
50 #include <linux/unistd.h> 50 #include <linux/unistd.h>
51 #include <linux/rmap.h> 51 #include <linux/rmap.h>
52 #include <linux/mempolicy.h> 52 #include <linux/mempolicy.h>
53 #include <linux/key.h> 53 #include <linux/key.h>
54 #include <linux/buffer_head.h> 54 #include <linux/buffer_head.h>
55 #include <linux/page_cgroup.h> 55 #include <linux/page_cgroup.h>
56 #include <linux/debug_locks.h> 56 #include <linux/debug_locks.h>
57 #include <linux/debugobjects.h> 57 #include <linux/debugobjects.h>
58 #include <linux/lockdep.h> 58 #include <linux/lockdep.h>
59 #include <linux/kmemleak.h> 59 #include <linux/kmemleak.h>
60 #include <linux/pid_namespace.h> 60 #include <linux/pid_namespace.h>
61 #include <linux/device.h> 61 #include <linux/device.h>
62 #include <linux/kthread.h> 62 #include <linux/kthread.h>
63 #include <linux/sched.h> 63 #include <linux/sched.h>
64 #include <linux/signal.h> 64 #include <linux/signal.h>
65 #include <linux/idr.h> 65 #include <linux/idr.h>
66 #include <linux/ftrace.h> 66 #include <linux/ftrace.h>
67 #include <linux/async.h> 67 #include <linux/async.h>
68 #include <linux/kmemcheck.h> 68 #include <linux/kmemcheck.h>
69 #include <linux/kmemtrace.h> 69 #include <linux/kmemtrace.h>
70 #include <linux/sfi.h> 70 #include <linux/sfi.h>
71 #include <linux/shmem_fs.h> 71 #include <linux/shmem_fs.h>
72 #include <trace/boot.h> 72 #include <trace/boot.h>
73 73
74 #include <asm/io.h> 74 #include <asm/io.h>
75 #include <asm/bugs.h> 75 #include <asm/bugs.h>
76 #include <asm/setup.h> 76 #include <asm/setup.h>
77 #include <asm/sections.h> 77 #include <asm/sections.h>
78 #include <asm/cacheflush.h> 78 #include <asm/cacheflush.h>
79 79
80 #ifdef CONFIG_X86_LOCAL_APIC 80 #ifdef CONFIG_X86_LOCAL_APIC
81 #include <asm/smp.h> 81 #include <asm/smp.h>
82 #endif 82 #endif
83 83
84 static int kernel_init(void *); 84 static int kernel_init(void *);
85 85
86 extern void init_IRQ(void); 86 extern void init_IRQ(void);
87 extern void fork_init(unsigned long); 87 extern void fork_init(unsigned long);
88 extern void mca_init(void); 88 extern void mca_init(void);
89 extern void sbus_init(void); 89 extern void sbus_init(void);
90 extern void prio_tree_init(void); 90 extern void prio_tree_init(void);
91 extern void radix_tree_init(void); 91 extern void radix_tree_init(void);
92 extern void free_initmem(void); 92 extern void free_initmem(void);
93 #ifndef CONFIG_DEBUG_RODATA 93 #ifndef CONFIG_DEBUG_RODATA
94 static inline void mark_rodata_ro(void) { } 94 static inline void mark_rodata_ro(void) { }
95 #endif 95 #endif
96 96
97 #ifdef CONFIG_TC 97 #ifdef CONFIG_TC
98 extern void tc_init(void); 98 extern void tc_init(void);
99 #endif 99 #endif
100 100
101 enum system_states system_state __read_mostly; 101 enum system_states system_state __read_mostly;
102 EXPORT_SYMBOL(system_state); 102 EXPORT_SYMBOL(system_state);
103 103
104 /* 104 /*
105 * Boot command-line arguments 105 * Boot command-line arguments
106 */ 106 */
107 #define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT 107 #define MAX_INIT_ARGS CONFIG_INIT_ENV_ARG_LIMIT
108 #define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT 108 #define MAX_INIT_ENVS CONFIG_INIT_ENV_ARG_LIMIT
109 109
110 extern void time_init(void); 110 extern void time_init(void);
111 /* Default late time init is NULL. archs can override this later. */ 111 /* Default late time init is NULL. archs can override this later. */
112 void (*__initdata late_time_init)(void); 112 void (*__initdata late_time_init)(void);
113 extern void softirq_init(void); 113 extern void softirq_init(void);
114 114
115 /* Untouched command line saved by arch-specific code. */ 115 /* Untouched command line saved by arch-specific code. */
116 char __initdata boot_command_line[COMMAND_LINE_SIZE]; 116 char __initdata boot_command_line[COMMAND_LINE_SIZE];
117 /* Untouched saved command line (eg. for /proc) */ 117 /* Untouched saved command line (eg. for /proc) */
118 char *saved_command_line; 118 char *saved_command_line;
119 /* Command line for parameter parsing */ 119 /* Command line for parameter parsing */
120 static char *static_command_line; 120 static char *static_command_line;
121 121
122 static char *execute_command; 122 static char *execute_command;
123 static char *ramdisk_execute_command; 123 static char *ramdisk_execute_command;
124 124
125 #ifdef CONFIG_SMP 125 #ifdef CONFIG_SMP
126 /* Setup configured maximum number of CPUs to activate */ 126 /* Setup configured maximum number of CPUs to activate */
127 unsigned int __initdata setup_max_cpus = NR_CPUS; 127 unsigned int __initdata setup_max_cpus = NR_CPUS;
128 128
129 /* 129 /*
130 * Setup routine for controlling SMP activation 130 * Setup routine for controlling SMP activation
131 * 131 *
132 * Command-line option of "nosmp" or "maxcpus=0" will disable SMP 132 * Command-line option of "nosmp" or "maxcpus=0" will disable SMP
133 * activation entirely (the MPS table probe still happens, though). 133 * activation entirely (the MPS table probe still happens, though).
134 * 134 *
135 * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer 135 * Command-line option of "maxcpus=<NUM>", where <NUM> is an integer
136 * greater than 0, limits the maximum number of CPUs activated in 136 * greater than 0, limits the maximum number of CPUs activated in
137 * SMP mode to <NUM>. 137 * SMP mode to <NUM>.
138 */ 138 */
139 139
140 void __weak arch_disable_smp_support(void) { } 140 void __weak arch_disable_smp_support(void) { }
141 141
142 static int __init nosmp(char *str) 142 static int __init nosmp(char *str)
143 { 143 {
144 setup_max_cpus = 0; 144 setup_max_cpus = 0;
145 arch_disable_smp_support(); 145 arch_disable_smp_support();
146 146
147 return 0; 147 return 0;
148 } 148 }
149 149
150 early_param("nosmp", nosmp); 150 early_param("nosmp", nosmp);
151 151
152 static int __init maxcpus(char *str) 152 static int __init maxcpus(char *str)
153 { 153 {
154 get_option(&str, &setup_max_cpus); 154 get_option(&str, &setup_max_cpus);
155 if (setup_max_cpus == 0) 155 if (setup_max_cpus == 0)
156 arch_disable_smp_support(); 156 arch_disable_smp_support();
157 157
158 return 0; 158 return 0;
159 } 159 }
160 160
161 early_param("maxcpus", maxcpus); 161 early_param("maxcpus", maxcpus);
162 #else 162 #else
163 const unsigned int setup_max_cpus = NR_CPUS; 163 const unsigned int setup_max_cpus = NR_CPUS;
164 #endif 164 #endif
165 165
166 /* 166 /*
167 * If set, this is an indication to the drivers that reset the underlying 167 * If set, this is an indication to the drivers that reset the underlying
168 * device before going ahead with the initialization otherwise driver might 168 * device before going ahead with the initialization otherwise driver might
169 * rely on the BIOS and skip the reset operation. 169 * rely on the BIOS and skip the reset operation.
170 * 170 *
171 * This is useful if kernel is booting in an unreliable environment. 171 * This is useful if kernel is booting in an unreliable environment.
172 * For ex. kdump situaiton where previous kernel has crashed, BIOS has been 172 * For ex. kdump situaiton where previous kernel has crashed, BIOS has been
173 * skipped and devices will be in unknown state. 173 * skipped and devices will be in unknown state.
174 */ 174 */
175 unsigned int reset_devices; 175 unsigned int reset_devices;
176 EXPORT_SYMBOL(reset_devices); 176 EXPORT_SYMBOL(reset_devices);
177 177
178 static int __init set_reset_devices(char *str) 178 static int __init set_reset_devices(char *str)
179 { 179 {
180 reset_devices = 1; 180 reset_devices = 1;
181 return 1; 181 return 1;
182 } 182 }
183 183
184 __setup("reset_devices", set_reset_devices); 184 __setup("reset_devices", set_reset_devices);
185 185
186 static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, }; 186 static char * argv_init[MAX_INIT_ARGS+2] = { "init", NULL, };
187 char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, }; 187 char * envp_init[MAX_INIT_ENVS+2] = { "HOME=/", "TERM=linux", NULL, };
188 static const char *panic_later, *panic_param; 188 static const char *panic_later, *panic_param;
189 189
190 extern struct obs_kernel_param __setup_start[], __setup_end[]; 190 extern struct obs_kernel_param __setup_start[], __setup_end[];
191 191
192 static int __init obsolete_checksetup(char *line) 192 static int __init obsolete_checksetup(char *line)
193 { 193 {
194 struct obs_kernel_param *p; 194 struct obs_kernel_param *p;
195 int had_early_param = 0; 195 int had_early_param = 0;
196 196
197 p = __setup_start; 197 p = __setup_start;
198 do { 198 do {
199 int n = strlen(p->str); 199 int n = strlen(p->str);
200 if (!strncmp(line, p->str, n)) { 200 if (!strncmp(line, p->str, n)) {
201 if (p->early) { 201 if (p->early) {
202 /* Already done in parse_early_param? 202 /* Already done in parse_early_param?
203 * (Needs exact match on param part). 203 * (Needs exact match on param part).
204 * Keep iterating, as we can have early 204 * Keep iterating, as we can have early
205 * params and __setups of same names 8( */ 205 * params and __setups of same names 8( */
206 if (line[n] == '\0' || line[n] == '=') 206 if (line[n] == '\0' || line[n] == '=')
207 had_early_param = 1; 207 had_early_param = 1;
208 } else if (!p->setup_func) { 208 } else if (!p->setup_func) {
209 printk(KERN_WARNING "Parameter %s is obsolete," 209 printk(KERN_WARNING "Parameter %s is obsolete,"
210 " ignored\n", p->str); 210 " ignored\n", p->str);
211 return 1; 211 return 1;
212 } else if (p->setup_func(line + n)) 212 } else if (p->setup_func(line + n))
213 return 1; 213 return 1;
214 } 214 }
215 p++; 215 p++;
216 } while (p < __setup_end); 216 } while (p < __setup_end);
217 217
218 return had_early_param; 218 return had_early_param;
219 } 219 }
220 220
221 /* 221 /*
222 * This should be approx 2 Bo*oMips to start (note initial shift), and will 222 * This should be approx 2 Bo*oMips to start (note initial shift), and will
223 * still work even if initially too large, it will just take slightly longer 223 * still work even if initially too large, it will just take slightly longer
224 */ 224 */
225 unsigned long loops_per_jiffy = (1<<12); 225 unsigned long loops_per_jiffy = (1<<12);
226 226
227 EXPORT_SYMBOL(loops_per_jiffy); 227 EXPORT_SYMBOL(loops_per_jiffy);
228 228
229 static int __init debug_kernel(char *str) 229 static int __init debug_kernel(char *str)
230 { 230 {
231 console_loglevel = 10; 231 console_loglevel = 10;
232 return 0; 232 return 0;
233 } 233 }
234 234
235 static int __init quiet_kernel(char *str) 235 static int __init quiet_kernel(char *str)
236 { 236 {
237 console_loglevel = 4; 237 console_loglevel = 4;
238 return 0; 238 return 0;
239 } 239 }
240 240
241 early_param("debug", debug_kernel); 241 early_param("debug", debug_kernel);
242 early_param("quiet", quiet_kernel); 242 early_param("quiet", quiet_kernel);
243 243
244 static int __init loglevel(char *str) 244 static int __init loglevel(char *str)
245 { 245 {
246 get_option(&str, &console_loglevel); 246 get_option(&str, &console_loglevel);
247 return 0; 247 return 0;
248 } 248 }
249 249
250 early_param("loglevel", loglevel); 250 early_param("loglevel", loglevel);
251 251
252 /* 252 /*
253 * Unknown boot options get handed to init, unless they look like 253 * Unknown boot options get handed to init, unless they look like
254 * failed parameters 254 * unused parameters (modprobe will find them in /proc/cmdline).
255 */ 255 */
256 static int __init unknown_bootoption(char *param, char *val) 256 static int __init unknown_bootoption(char *param, char *val)
257 { 257 {
258 /* Change NUL term back to "=", to make "param" the whole string. */ 258 /* Change NUL term back to "=", to make "param" the whole string. */
259 if (val) { 259 if (val) {
260 /* param=val or param="val"? */ 260 /* param=val or param="val"? */
261 if (val == param+strlen(param)+1) 261 if (val == param+strlen(param)+1)
262 val[-1] = '='; 262 val[-1] = '=';
263 else if (val == param+strlen(param)+2) { 263 else if (val == param+strlen(param)+2) {
264 val[-2] = '='; 264 val[-2] = '=';
265 memmove(val-1, val, strlen(val)+1); 265 memmove(val-1, val, strlen(val)+1);
266 val--; 266 val--;
267 } else 267 } else
268 BUG(); 268 BUG();
269 } 269 }
270 270
271 /* Handle obsolete-style parameters */ 271 /* Handle obsolete-style parameters */
272 if (obsolete_checksetup(param)) 272 if (obsolete_checksetup(param))
273 return 0; 273 return 0;
274 274
275 /* 275 /* Unused module parameter. */
276 * Preemptive maintenance for "why didn't my misspelled command 276 if (strchr(param, '.') && (!val || strchr(param, '.') < val))
277 * line work?"
278 */
279 if (strchr(param, '.') && (!val || strchr(param, '.') < val)) {
280 printk(KERN_ERR "Unknown boot option `%s': ignoring\n", param);
281 return 0; 277 return 0;
282 }
283 278
284 if (panic_later) 279 if (panic_later)
285 return 0; 280 return 0;
286 281
287 if (val) { 282 if (val) {
288 /* Environment option */ 283 /* Environment option */
289 unsigned int i; 284 unsigned int i;
290 for (i = 0; envp_init[i]; i++) { 285 for (i = 0; envp_init[i]; i++) {
291 if (i == MAX_INIT_ENVS) { 286 if (i == MAX_INIT_ENVS) {
292 panic_later = "Too many boot env vars at `%s'"; 287 panic_later = "Too many boot env vars at `%s'";
293 panic_param = param; 288 panic_param = param;
294 } 289 }
295 if (!strncmp(param, envp_init[i], val - param)) 290 if (!strncmp(param, envp_init[i], val - param))
296 break; 291 break;
297 } 292 }
298 envp_init[i] = param; 293 envp_init[i] = param;
299 } else { 294 } else {
300 /* Command line option */ 295 /* Command line option */
301 unsigned int i; 296 unsigned int i;
302 for (i = 0; argv_init[i]; i++) { 297 for (i = 0; argv_init[i]; i++) {
303 if (i == MAX_INIT_ARGS) { 298 if (i == MAX_INIT_ARGS) {
304 panic_later = "Too many boot init vars at `%s'"; 299 panic_later = "Too many boot init vars at `%s'";
305 panic_param = param; 300 panic_param = param;
306 } 301 }
307 } 302 }
308 argv_init[i] = param; 303 argv_init[i] = param;
309 } 304 }
310 return 0; 305 return 0;
311 } 306 }
312 307
313 #ifdef CONFIG_DEBUG_PAGEALLOC 308 #ifdef CONFIG_DEBUG_PAGEALLOC
314 int __read_mostly debug_pagealloc_enabled = 0; 309 int __read_mostly debug_pagealloc_enabled = 0;
315 #endif 310 #endif
316 311
317 static int __init init_setup(char *str) 312 static int __init init_setup(char *str)
318 { 313 {
319 unsigned int i; 314 unsigned int i;
320 315
321 execute_command = str; 316 execute_command = str;
322 /* 317 /*
323 * In case LILO is going to boot us with default command line, 318 * In case LILO is going to boot us with default command line,
324 * it prepends "auto" before the whole cmdline which makes 319 * it prepends "auto" before the whole cmdline which makes
325 * the shell think it should execute a script with such name. 320 * the shell think it should execute a script with such name.
326 * So we ignore all arguments entered _before_ init=... [MJ] 321 * So we ignore all arguments entered _before_ init=... [MJ]
327 */ 322 */
328 for (i = 1; i < MAX_INIT_ARGS; i++) 323 for (i = 1; i < MAX_INIT_ARGS; i++)
329 argv_init[i] = NULL; 324 argv_init[i] = NULL;
330 return 1; 325 return 1;
331 } 326 }
332 __setup("init=", init_setup); 327 __setup("init=", init_setup);
333 328
334 static int __init rdinit_setup(char *str) 329 static int __init rdinit_setup(char *str)
335 { 330 {
336 unsigned int i; 331 unsigned int i;
337 332
338 ramdisk_execute_command = str; 333 ramdisk_execute_command = str;
339 /* See "auto" comment in init_setup */ 334 /* See "auto" comment in init_setup */
340 for (i = 1; i < MAX_INIT_ARGS; i++) 335 for (i = 1; i < MAX_INIT_ARGS; i++)
341 argv_init[i] = NULL; 336 argv_init[i] = NULL;
342 return 1; 337 return 1;
343 } 338 }
344 __setup("rdinit=", rdinit_setup); 339 __setup("rdinit=", rdinit_setup);
345 340
346 #ifndef CONFIG_SMP 341 #ifndef CONFIG_SMP
347 342
348 #ifdef CONFIG_X86_LOCAL_APIC 343 #ifdef CONFIG_X86_LOCAL_APIC
349 static void __init smp_init(void) 344 static void __init smp_init(void)
350 { 345 {
351 APIC_init_uniprocessor(); 346 APIC_init_uniprocessor();
352 } 347 }
353 #else 348 #else
354 #define smp_init() do { } while (0) 349 #define smp_init() do { } while (0)
355 #endif 350 #endif
356 351
357 static inline void setup_nr_cpu_ids(void) { } 352 static inline void setup_nr_cpu_ids(void) { }
358 static inline void smp_prepare_cpus(unsigned int maxcpus) { } 353 static inline void smp_prepare_cpus(unsigned int maxcpus) { }
359 354
360 #else 355 #else
361 356
362 /* Setup number of possible processor ids */ 357 /* Setup number of possible processor ids */
363 int nr_cpu_ids __read_mostly = NR_CPUS; 358 int nr_cpu_ids __read_mostly = NR_CPUS;
364 EXPORT_SYMBOL(nr_cpu_ids); 359 EXPORT_SYMBOL(nr_cpu_ids);
365 360
366 /* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */ 361 /* An arch may set nr_cpu_ids earlier if needed, so this would be redundant */
367 static void __init setup_nr_cpu_ids(void) 362 static void __init setup_nr_cpu_ids(void)
368 { 363 {
369 nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1; 364 nr_cpu_ids = find_last_bit(cpumask_bits(cpu_possible_mask),NR_CPUS) + 1;
370 } 365 }
371 366
372 /* Called by boot processor to activate the rest. */ 367 /* Called by boot processor to activate the rest. */
373 static void __init smp_init(void) 368 static void __init smp_init(void)
374 { 369 {
375 unsigned int cpu; 370 unsigned int cpu;
376 371
377 /* 372 /*
378 * Set up the current CPU as possible to migrate to. 373 * Set up the current CPU as possible to migrate to.
379 * The other ones will be done by cpu_up/cpu_down() 374 * The other ones will be done by cpu_up/cpu_down()
380 */ 375 */
381 set_cpu_active(smp_processor_id(), true); 376 set_cpu_active(smp_processor_id(), true);
382 377
383 /* FIXME: This should be done in userspace --RR */ 378 /* FIXME: This should be done in userspace --RR */
384 for_each_present_cpu(cpu) { 379 for_each_present_cpu(cpu) {
385 if (num_online_cpus() >= setup_max_cpus) 380 if (num_online_cpus() >= setup_max_cpus)
386 break; 381 break;
387 if (!cpu_online(cpu)) 382 if (!cpu_online(cpu))
388 cpu_up(cpu); 383 cpu_up(cpu);
389 } 384 }
390 385
391 /* Any cleanup work */ 386 /* Any cleanup work */
392 printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus()); 387 printk(KERN_INFO "Brought up %ld CPUs\n", (long)num_online_cpus());
393 smp_cpus_done(setup_max_cpus); 388 smp_cpus_done(setup_max_cpus);
394 } 389 }
395 390
396 #endif 391 #endif
397 392
398 /* 393 /*
399 * We need to store the untouched command line for future reference. 394 * We need to store the untouched command line for future reference.
400 * We also need to store the touched command line since the parameter 395 * We also need to store the touched command line since the parameter
401 * parsing is performed in place, and we should allow a component to 396 * parsing is performed in place, and we should allow a component to
402 * store reference of name/value for future reference. 397 * store reference of name/value for future reference.
403 */ 398 */
404 static void __init setup_command_line(char *command_line) 399 static void __init setup_command_line(char *command_line)
405 { 400 {
406 saved_command_line = alloc_bootmem(strlen (boot_command_line)+1); 401 saved_command_line = alloc_bootmem(strlen (boot_command_line)+1);
407 static_command_line = alloc_bootmem(strlen (command_line)+1); 402 static_command_line = alloc_bootmem(strlen (command_line)+1);
408 strcpy (saved_command_line, boot_command_line); 403 strcpy (saved_command_line, boot_command_line);
409 strcpy (static_command_line, command_line); 404 strcpy (static_command_line, command_line);
410 } 405 }
411 406
412 /* 407 /*
413 * We need to finalize in a non-__init function or else race conditions 408 * We need to finalize in a non-__init function or else race conditions
414 * between the root thread and the init thread may cause start_kernel to 409 * between the root thread and the init thread may cause start_kernel to
415 * be reaped by free_initmem before the root thread has proceeded to 410 * be reaped by free_initmem before the root thread has proceeded to
416 * cpu_idle. 411 * cpu_idle.
417 * 412 *
418 * gcc-3.4 accidentally inlines this function, so use noinline. 413 * gcc-3.4 accidentally inlines this function, so use noinline.
419 */ 414 */
420 415
421 static noinline void __init_refok rest_init(void) 416 static noinline void __init_refok rest_init(void)
422 __releases(kernel_lock) 417 __releases(kernel_lock)
423 { 418 {
424 int pid; 419 int pid;
425 420
426 rcu_scheduler_starting(); 421 rcu_scheduler_starting();
427 kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND); 422 kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);
428 numa_default_policy(); 423 numa_default_policy();
429 pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES); 424 pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);
430 kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns); 425 kthreadd_task = find_task_by_pid_ns(pid, &init_pid_ns);
431 unlock_kernel(); 426 unlock_kernel();
432 427
433 /* 428 /*
434 * The boot idle thread must execute schedule() 429 * The boot idle thread must execute schedule()
435 * at least once to get things moving: 430 * at least once to get things moving:
436 */ 431 */
437 init_idle_bootup_task(current); 432 init_idle_bootup_task(current);
438 preempt_enable_no_resched(); 433 preempt_enable_no_resched();
439 schedule(); 434 schedule();
440 preempt_disable(); 435 preempt_disable();
441 436
442 /* Call into cpu_idle with preempt disabled */ 437 /* Call into cpu_idle with preempt disabled */
443 cpu_idle(); 438 cpu_idle();
444 } 439 }
445 440
446 /* Check for early params. */ 441 /* Check for early params. */
447 static int __init do_early_param(char *param, char *val) 442 static int __init do_early_param(char *param, char *val)
448 { 443 {
449 struct obs_kernel_param *p; 444 struct obs_kernel_param *p;
450 445
451 for (p = __setup_start; p < __setup_end; p++) { 446 for (p = __setup_start; p < __setup_end; p++) {
452 if ((p->early && strcmp(param, p->str) == 0) || 447 if ((p->early && strcmp(param, p->str) == 0) ||
453 (strcmp(param, "console") == 0 && 448 (strcmp(param, "console") == 0 &&
454 strcmp(p->str, "earlycon") == 0) 449 strcmp(p->str, "earlycon") == 0)
455 ) { 450 ) {
456 if (p->setup_func(val) != 0) 451 if (p->setup_func(val) != 0)
457 printk(KERN_WARNING 452 printk(KERN_WARNING
458 "Malformed early option '%s'\n", param); 453 "Malformed early option '%s'\n", param);
459 } 454 }
460 } 455 }
461 /* We accept everything at this stage. */ 456 /* We accept everything at this stage. */
462 return 0; 457 return 0;
463 } 458 }
464 459
465 void __init parse_early_options(char *cmdline) 460 void __init parse_early_options(char *cmdline)
466 { 461 {
467 parse_args("early options", cmdline, NULL, 0, do_early_param); 462 parse_args("early options", cmdline, NULL, 0, do_early_param);
468 } 463 }
469 464
470 /* Arch code calls this early on, or if not, just before other parsing. */ 465 /* Arch code calls this early on, or if not, just before other parsing. */
471 void __init parse_early_param(void) 466 void __init parse_early_param(void)
472 { 467 {
473 static __initdata int done = 0; 468 static __initdata int done = 0;
474 static __initdata char tmp_cmdline[COMMAND_LINE_SIZE]; 469 static __initdata char tmp_cmdline[COMMAND_LINE_SIZE];
475 470
476 if (done) 471 if (done)
477 return; 472 return;
478 473
479 /* All fall through to do_early_param. */ 474 /* All fall through to do_early_param. */
480 strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE); 475 strlcpy(tmp_cmdline, boot_command_line, COMMAND_LINE_SIZE);
481 parse_early_options(tmp_cmdline); 476 parse_early_options(tmp_cmdline);
482 done = 1; 477 done = 1;
483 } 478 }
484 479
485 /* 480 /*
486 * Activate the first processor. 481 * Activate the first processor.
487 */ 482 */
488 483
489 static void __init boot_cpu_init(void) 484 static void __init boot_cpu_init(void)
490 { 485 {
491 int cpu = smp_processor_id(); 486 int cpu = smp_processor_id();
492 /* Mark the boot cpu "present", "online" etc for SMP and UP case */ 487 /* Mark the boot cpu "present", "online" etc for SMP and UP case */
493 set_cpu_online(cpu, true); 488 set_cpu_online(cpu, true);
494 set_cpu_present(cpu, true); 489 set_cpu_present(cpu, true);
495 set_cpu_possible(cpu, true); 490 set_cpu_possible(cpu, true);
496 } 491 }
497 492
498 void __init __weak smp_setup_processor_id(void) 493 void __init __weak smp_setup_processor_id(void)
499 { 494 {
500 } 495 }
501 496
502 void __init __weak thread_info_cache_init(void) 497 void __init __weak thread_info_cache_init(void)
503 { 498 {
504 } 499 }
505 500
506 /* 501 /*
507 * Set up kernel memory allocators 502 * Set up kernel memory allocators
508 */ 503 */
509 static void __init mm_init(void) 504 static void __init mm_init(void)
510 { 505 {
511 /* 506 /*
512 * page_cgroup requires countinous pages as memmap 507 * page_cgroup requires countinous pages as memmap
513 * and it's bigger than MAX_ORDER unless SPARSEMEM. 508 * and it's bigger than MAX_ORDER unless SPARSEMEM.
514 */ 509 */
515 page_cgroup_init_flatmem(); 510 page_cgroup_init_flatmem();
516 mem_init(); 511 mem_init();
517 kmem_cache_init(); 512 kmem_cache_init();
518 pgtable_cache_init(); 513 pgtable_cache_init();
519 vmalloc_init(); 514 vmalloc_init();
520 } 515 }
521 516
522 asmlinkage void __init start_kernel(void) 517 asmlinkage void __init start_kernel(void)
523 { 518 {
524 char * command_line; 519 char * command_line;
525 extern struct kernel_param __start___param[], __stop___param[]; 520 extern struct kernel_param __start___param[], __stop___param[];
526 521
527 smp_setup_processor_id(); 522 smp_setup_processor_id();
528 523
529 /* 524 /*
530 * Need to run as early as possible, to initialize the 525 * Need to run as early as possible, to initialize the
531 * lockdep hash: 526 * lockdep hash:
532 */ 527 */
533 lockdep_init(); 528 lockdep_init();
534 debug_objects_early_init(); 529 debug_objects_early_init();
535 530
536 /* 531 /*
537 * Set up the the initial canary ASAP: 532 * Set up the the initial canary ASAP:
538 */ 533 */
539 boot_init_stack_canary(); 534 boot_init_stack_canary();
540 535
541 cgroup_init_early(); 536 cgroup_init_early();
542 537
543 local_irq_disable(); 538 local_irq_disable();
544 early_boot_irqs_off(); 539 early_boot_irqs_off();
545 early_init_irq_lock_class(); 540 early_init_irq_lock_class();
546 541
547 /* 542 /*
548 * Interrupts are still disabled. Do necessary setups, then 543 * Interrupts are still disabled. Do necessary setups, then
549 * enable them 544 * enable them
550 */ 545 */
551 lock_kernel(); 546 lock_kernel();
552 tick_init(); 547 tick_init();
553 boot_cpu_init(); 548 boot_cpu_init();
554 page_address_init(); 549 page_address_init();
555 printk(KERN_NOTICE "%s", linux_banner); 550 printk(KERN_NOTICE "%s", linux_banner);
556 setup_arch(&command_line); 551 setup_arch(&command_line);
557 mm_init_owner(&init_mm, &init_task); 552 mm_init_owner(&init_mm, &init_task);
558 setup_command_line(command_line); 553 setup_command_line(command_line);
559 setup_nr_cpu_ids(); 554 setup_nr_cpu_ids();
560 setup_per_cpu_areas(); 555 setup_per_cpu_areas();
561 smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */ 556 smp_prepare_boot_cpu(); /* arch-specific boot-cpu hooks */
562 557
563 build_all_zonelists(); 558 build_all_zonelists();
564 page_alloc_init(); 559 page_alloc_init();
565 560
566 printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line); 561 printk(KERN_NOTICE "Kernel command line: %s\n", boot_command_line);
567 parse_early_param(); 562 parse_early_param();
568 parse_args("Booting kernel", static_command_line, __start___param, 563 parse_args("Booting kernel", static_command_line, __start___param,
569 __stop___param - __start___param, 564 __stop___param - __start___param,
570 &unknown_bootoption); 565 &unknown_bootoption);
571 /* 566 /*
572 * These use large bootmem allocations and must precede 567 * These use large bootmem allocations and must precede
573 * kmem_cache_init() 568 * kmem_cache_init()
574 */ 569 */
575 pidhash_init(); 570 pidhash_init();
576 vfs_caches_init_early(); 571 vfs_caches_init_early();
577 sort_main_extable(); 572 sort_main_extable();
578 trap_init(); 573 trap_init();
579 mm_init(); 574 mm_init();
580 /* 575 /*
581 * Set up the scheduler prior starting any interrupts (such as the 576 * Set up the scheduler prior starting any interrupts (such as the
582 * timer interrupt). Full topology setup happens at smp_init() 577 * timer interrupt). Full topology setup happens at smp_init()
583 * time - but meanwhile we still have a functioning scheduler. 578 * time - but meanwhile we still have a functioning scheduler.
584 */ 579 */
585 sched_init(); 580 sched_init();
586 /* 581 /*
587 * Disable preemption - early bootup scheduling is extremely 582 * Disable preemption - early bootup scheduling is extremely
588 * fragile until we cpu_idle() for the first time. 583 * fragile until we cpu_idle() for the first time.
589 */ 584 */
590 preempt_disable(); 585 preempt_disable();
591 if (!irqs_disabled()) { 586 if (!irqs_disabled()) {
592 printk(KERN_WARNING "start_kernel(): bug: interrupts were " 587 printk(KERN_WARNING "start_kernel(): bug: interrupts were "
593 "enabled *very* early, fixing it\n"); 588 "enabled *very* early, fixing it\n");
594 local_irq_disable(); 589 local_irq_disable();
595 } 590 }
596 rcu_init(); 591 rcu_init();
597 /* init some links before init_ISA_irqs() */ 592 /* init some links before init_ISA_irqs() */
598 early_irq_init(); 593 early_irq_init();
599 init_IRQ(); 594 init_IRQ();
600 prio_tree_init(); 595 prio_tree_init();
601 init_timers(); 596 init_timers();
602 hrtimers_init(); 597 hrtimers_init();
603 softirq_init(); 598 softirq_init();
604 timekeeping_init(); 599 timekeeping_init();
605 time_init(); 600 time_init();
606 profile_init(); 601 profile_init();
607 if (!irqs_disabled()) 602 if (!irqs_disabled())
608 printk(KERN_CRIT "start_kernel(): bug: interrupts were " 603 printk(KERN_CRIT "start_kernel(): bug: interrupts were "
609 "enabled early\n"); 604 "enabled early\n");
610 early_boot_irqs_on(); 605 early_boot_irqs_on();
611 local_irq_enable(); 606 local_irq_enable();
612 607
613 /* Interrupts are enabled now so all GFP allocations are safe. */ 608 /* Interrupts are enabled now so all GFP allocations are safe. */
614 set_gfp_allowed_mask(__GFP_BITS_MASK); 609 set_gfp_allowed_mask(__GFP_BITS_MASK);
615 610
616 kmem_cache_init_late(); 611 kmem_cache_init_late();
617 612
618 /* 613 /*
619 * HACK ALERT! This is early. We're enabling the console before 614 * HACK ALERT! This is early. We're enabling the console before
620 * we've done PCI setups etc, and console_init() must be aware of 615 * we've done PCI setups etc, and console_init() must be aware of
621 * this. But we do want output early, in case something goes wrong. 616 * this. But we do want output early, in case something goes wrong.
622 */ 617 */
623 console_init(); 618 console_init();
624 if (panic_later) 619 if (panic_later)
625 panic(panic_later, panic_param); 620 panic(panic_later, panic_param);
626 621
627 lockdep_info(); 622 lockdep_info();
628 623
629 /* 624 /*
630 * Need to run this when irqs are enabled, because it wants 625 * Need to run this when irqs are enabled, because it wants
631 * to self-test [hard/soft]-irqs on/off lock inversion bugs 626 * to self-test [hard/soft]-irqs on/off lock inversion bugs
632 * too: 627 * too:
633 */ 628 */
634 locking_selftest(); 629 locking_selftest();
635 630
636 #ifdef CONFIG_BLK_DEV_INITRD 631 #ifdef CONFIG_BLK_DEV_INITRD
637 if (initrd_start && !initrd_below_start_ok && 632 if (initrd_start && !initrd_below_start_ok &&
638 page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) { 633 page_to_pfn(virt_to_page((void *)initrd_start)) < min_low_pfn) {
639 printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - " 634 printk(KERN_CRIT "initrd overwritten (0x%08lx < 0x%08lx) - "
640 "disabling it.\n", 635 "disabling it.\n",
641 page_to_pfn(virt_to_page((void *)initrd_start)), 636 page_to_pfn(virt_to_page((void *)initrd_start)),
642 min_low_pfn); 637 min_low_pfn);
643 initrd_start = 0; 638 initrd_start = 0;
644 } 639 }
645 #endif 640 #endif
646 page_cgroup_init(); 641 page_cgroup_init();
647 enable_debug_pagealloc(); 642 enable_debug_pagealloc();
648 kmemtrace_init(); 643 kmemtrace_init();
649 kmemleak_init(); 644 kmemleak_init();
650 debug_objects_mem_init(); 645 debug_objects_mem_init();
651 idr_init_cache(); 646 idr_init_cache();
652 setup_per_cpu_pageset(); 647 setup_per_cpu_pageset();
653 numa_policy_init(); 648 numa_policy_init();
654 if (late_time_init) 649 if (late_time_init)
655 late_time_init(); 650 late_time_init();
656 sched_clock_init(); 651 sched_clock_init();
657 calibrate_delay(); 652 calibrate_delay();
658 pidmap_init(); 653 pidmap_init();
659 anon_vma_init(); 654 anon_vma_init();
660 #ifdef CONFIG_X86 655 #ifdef CONFIG_X86
661 if (efi_enabled) 656 if (efi_enabled)
662 efi_enter_virtual_mode(); 657 efi_enter_virtual_mode();
663 #endif 658 #endif
664 thread_info_cache_init(); 659 thread_info_cache_init();
665 cred_init(); 660 cred_init();
666 fork_init(totalram_pages); 661 fork_init(totalram_pages);
667 proc_caches_init(); 662 proc_caches_init();
668 buffer_init(); 663 buffer_init();
669 key_init(); 664 key_init();
670 security_init(); 665 security_init();
671 vfs_caches_init(totalram_pages); 666 vfs_caches_init(totalram_pages);
672 radix_tree_init(); 667 radix_tree_init();
673 signals_init(); 668 signals_init();
674 /* rootfs populating might need page-writeback */ 669 /* rootfs populating might need page-writeback */
675 page_writeback_init(); 670 page_writeback_init();
676 #ifdef CONFIG_PROC_FS 671 #ifdef CONFIG_PROC_FS
677 proc_root_init(); 672 proc_root_init();
678 #endif 673 #endif
679 cgroup_init(); 674 cgroup_init();
680 cpuset_init(); 675 cpuset_init();
681 taskstats_init_early(); 676 taskstats_init_early();
682 delayacct_init(); 677 delayacct_init();
683 678
684 check_bugs(); 679 check_bugs();
685 680
686 acpi_early_init(); /* before LAPIC and SMP init */ 681 acpi_early_init(); /* before LAPIC and SMP init */
687 sfi_init_late(); 682 sfi_init_late();
688 683
689 ftrace_init(); 684 ftrace_init();
690 685
691 /* Do the rest non-__init'ed, we're now alive */ 686 /* Do the rest non-__init'ed, we're now alive */
692 rest_init(); 687 rest_init();
693 } 688 }
694 689
695 /* Call all constructor functions linked into the kernel. */ 690 /* Call all constructor functions linked into the kernel. */
696 static void __init do_ctors(void) 691 static void __init do_ctors(void)
697 { 692 {
698 #ifdef CONFIG_CONSTRUCTORS 693 #ifdef CONFIG_CONSTRUCTORS
699 ctor_fn_t *call = (ctor_fn_t *) __ctors_start; 694 ctor_fn_t *call = (ctor_fn_t *) __ctors_start;
700 695
701 for (; call < (ctor_fn_t *) __ctors_end; call++) 696 for (; call < (ctor_fn_t *) __ctors_end; call++)
702 (*call)(); 697 (*call)();
703 #endif 698 #endif
704 } 699 }
705 700
706 int initcall_debug; 701 int initcall_debug;
707 core_param(initcall_debug, initcall_debug, bool, 0644); 702 core_param(initcall_debug, initcall_debug, bool, 0644);
708 703
709 static char msgbuf[64]; 704 static char msgbuf[64];
710 static struct boot_trace_call call; 705 static struct boot_trace_call call;
711 static struct boot_trace_ret ret; 706 static struct boot_trace_ret ret;
712 707
713 int do_one_initcall(initcall_t fn) 708 int do_one_initcall(initcall_t fn)
714 { 709 {
715 int count = preempt_count(); 710 int count = preempt_count();
716 ktime_t calltime, delta, rettime; 711 ktime_t calltime, delta, rettime;
717 712
718 if (initcall_debug) { 713 if (initcall_debug) {
719 call.caller = task_pid_nr(current); 714 call.caller = task_pid_nr(current);
720 printk("calling %pF @ %i\n", fn, call.caller); 715 printk("calling %pF @ %i\n", fn, call.caller);
721 calltime = ktime_get(); 716 calltime = ktime_get();
722 trace_boot_call(&call, fn); 717 trace_boot_call(&call, fn);
723 enable_boot_trace(); 718 enable_boot_trace();
724 } 719 }
725 720
726 ret.result = fn(); 721 ret.result = fn();
727 722
728 if (initcall_debug) { 723 if (initcall_debug) {
729 disable_boot_trace(); 724 disable_boot_trace();
730 rettime = ktime_get(); 725 rettime = ktime_get();
731 delta = ktime_sub(rettime, calltime); 726 delta = ktime_sub(rettime, calltime);
732 ret.duration = (unsigned long long) ktime_to_ns(delta) >> 10; 727 ret.duration = (unsigned long long) ktime_to_ns(delta) >> 10;
733 trace_boot_ret(&ret, fn); 728 trace_boot_ret(&ret, fn);
734 printk("initcall %pF returned %d after %Ld usecs\n", fn, 729 printk("initcall %pF returned %d after %Ld usecs\n", fn,
735 ret.result, ret.duration); 730 ret.result, ret.duration);
736 } 731 }
737 732
738 msgbuf[0] = 0; 733 msgbuf[0] = 0;
739 734
740 if (ret.result && ret.result != -ENODEV && initcall_debug) 735 if (ret.result && ret.result != -ENODEV && initcall_debug)
741 sprintf(msgbuf, "error code %d ", ret.result); 736 sprintf(msgbuf, "error code %d ", ret.result);
742 737
743 if (preempt_count() != count) { 738 if (preempt_count() != count) {
744 strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf)); 739 strlcat(msgbuf, "preemption imbalance ", sizeof(msgbuf));
745 preempt_count() = count; 740 preempt_count() = count;
746 } 741 }
747 if (irqs_disabled()) { 742 if (irqs_disabled()) {
748 strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf)); 743 strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
749 local_irq_enable(); 744 local_irq_enable();
750 } 745 }
751 if (msgbuf[0]) { 746 if (msgbuf[0]) {
752 printk("initcall %pF returned with %s\n", fn, msgbuf); 747 printk("initcall %pF returned with %s\n", fn, msgbuf);
753 } 748 }
754 749
755 return ret.result; 750 return ret.result;
756 } 751 }
757 752
758 753
759 extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[]; 754 extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
760 755
761 static void __init do_initcalls(void) 756 static void __init do_initcalls(void)
762 { 757 {
763 initcall_t *call; 758 initcall_t *call;
764 759
765 for (call = __early_initcall_end; call < __initcall_end; call++) 760 for (call = __early_initcall_end; call < __initcall_end; call++)
766 do_one_initcall(*call); 761 do_one_initcall(*call);
767 762
768 /* Make sure there is no pending stuff from the initcall sequence */ 763 /* Make sure there is no pending stuff from the initcall sequence */
769 flush_scheduled_work(); 764 flush_scheduled_work();
770 } 765 }
771 766
772 /* 767 /*
773 * Ok, the machine is now initialized. None of the devices 768 * Ok, the machine is now initialized. None of the devices
774 * have been touched yet, but the CPU subsystem is up and 769 * have been touched yet, but the CPU subsystem is up and
775 * running, and memory and process management works. 770 * running, and memory and process management works.
776 * 771 *
777 * Now we can finally start doing some real work.. 772 * Now we can finally start doing some real work..
778 */ 773 */
779 static void __init do_basic_setup(void) 774 static void __init do_basic_setup(void)
780 { 775 {
781 init_workqueues(); 776 init_workqueues();
782 cpuset_init_smp(); 777 cpuset_init_smp();
783 usermodehelper_init(); 778 usermodehelper_init();
784 init_tmpfs(); 779 init_tmpfs();
785 driver_init(); 780 driver_init();
786 init_irq_proc(); 781 init_irq_proc();
787 do_ctors(); 782 do_ctors();
788 do_initcalls(); 783 do_initcalls();
789 } 784 }
790 785
791 static void __init do_pre_smp_initcalls(void) 786 static void __init do_pre_smp_initcalls(void)
792 { 787 {
793 initcall_t *call; 788 initcall_t *call;
794 789
795 for (call = __initcall_start; call < __early_initcall_end; call++) 790 for (call = __initcall_start; call < __early_initcall_end; call++)
796 do_one_initcall(*call); 791 do_one_initcall(*call);
797 } 792 }
798 793
799 static void run_init_process(char *init_filename) 794 static void run_init_process(char *init_filename)
800 { 795 {
801 argv_init[0] = init_filename; 796 argv_init[0] = init_filename;
802 kernel_execve(init_filename, argv_init, envp_init); 797 kernel_execve(init_filename, argv_init, envp_init);
803 } 798 }
804 799
805 /* This is a non __init function. Force it to be noinline otherwise gcc 800 /* This is a non __init function. Force it to be noinline otherwise gcc
806 * makes it inline to init() and it becomes part of init.text section 801 * makes it inline to init() and it becomes part of init.text section
807 */ 802 */
808 static noinline int init_post(void) 803 static noinline int init_post(void)
809 __releases(kernel_lock) 804 __releases(kernel_lock)
810 { 805 {
811 /* need to finish all async __init code before freeing the memory */ 806 /* need to finish all async __init code before freeing the memory */
812 async_synchronize_full(); 807 async_synchronize_full();
813 free_initmem(); 808 free_initmem();
814 unlock_kernel(); 809 unlock_kernel();
815 mark_rodata_ro(); 810 mark_rodata_ro();
816 system_state = SYSTEM_RUNNING; 811 system_state = SYSTEM_RUNNING;
817 numa_default_policy(); 812 numa_default_policy();
818 813
819 if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0) 814 if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)
820 printk(KERN_WARNING "Warning: unable to open an initial console.\n"); 815 printk(KERN_WARNING "Warning: unable to open an initial console.\n");
821 816
822 (void) sys_dup(0); 817 (void) sys_dup(0);
823 (void) sys_dup(0); 818 (void) sys_dup(0);
824 819
825 current->signal->flags |= SIGNAL_UNKILLABLE; 820 current->signal->flags |= SIGNAL_UNKILLABLE;
826 821
827 if (ramdisk_execute_command) { 822 if (ramdisk_execute_command) {
828 run_init_process(ramdisk_execute_command); 823 run_init_process(ramdisk_execute_command);
829 printk(KERN_WARNING "Failed to execute %s\n", 824 printk(KERN_WARNING "Failed to execute %s\n",
830 ramdisk_execute_command); 825 ramdisk_execute_command);
831 } 826 }
832 827
833 /* 828 /*
834 * We try each of these until one succeeds. 829 * We try each of these until one succeeds.
835 * 830 *
836 * The Bourne shell can be used instead of init if we are 831 * The Bourne shell can be used instead of init if we are
837 * trying to recover a really broken machine. 832 * trying to recover a really broken machine.
838 */ 833 */
839 if (execute_command) { 834 if (execute_command) {
840 run_init_process(execute_command); 835 run_init_process(execute_command);
841 printk(KERN_WARNING "Failed to execute %s. Attempting " 836 printk(KERN_WARNING "Failed to execute %s. Attempting "
842 "defaults...\n", execute_command); 837 "defaults...\n", execute_command);
843 } 838 }
844 run_init_process("/sbin/init"); 839 run_init_process("/sbin/init");
845 run_init_process("/etc/init"); 840 run_init_process("/etc/init");
846 run_init_process("/bin/init"); 841 run_init_process("/bin/init");
847 run_init_process("/bin/sh"); 842 run_init_process("/bin/sh");
848 843
849 panic("No init found. Try passing init= option to kernel."); 844 panic("No init found. Try passing init= option to kernel.");
850 } 845 }
851 846
852 static int __init kernel_init(void * unused) 847 static int __init kernel_init(void * unused)
853 { 848 {
854 lock_kernel(); 849 lock_kernel();
855 850
856 /* 851 /*
857 * init can allocate pages on any node 852 * init can allocate pages on any node
858 */ 853 */
859 set_mems_allowed(node_possible_map); 854 set_mems_allowed(node_possible_map);
860 /* 855 /*
861 * init can run on any cpu. 856 * init can run on any cpu.
862 */ 857 */
863 set_cpus_allowed_ptr(current, cpu_all_mask); 858 set_cpus_allowed_ptr(current, cpu_all_mask);
864 /* 859 /*
865 * Tell the world that we're going to be the grim 860 * Tell the world that we're going to be the grim
866 * reaper of innocent orphaned children. 861 * reaper of innocent orphaned children.
867 * 862 *
868 * We don't want people to have to make incorrect 863 * We don't want people to have to make incorrect
869 * assumptions about where in the task array this 864 * assumptions about where in the task array this
870 * can be found. 865 * can be found.
871 */ 866 */
872 init_pid_ns.child_reaper = current; 867 init_pid_ns.child_reaper = current;
873 868
874 cad_pid = task_pid(current); 869 cad_pid = task_pid(current);
875 870
876 smp_prepare_cpus(setup_max_cpus); 871 smp_prepare_cpus(setup_max_cpus);
877 872
878 do_pre_smp_initcalls(); 873 do_pre_smp_initcalls();
879 start_boot_trace(); 874 start_boot_trace();
880 875
881 smp_init(); 876 smp_init();
882 sched_init_smp(); 877 sched_init_smp();
883 878
884 do_basic_setup(); 879 do_basic_setup();
885 880
886 /* 881 /*
887 * check if there is an early userspace init. If yes, let it do all 882 * check if there is an early userspace init. If yes, let it do all
888 * the work 883 * the work
889 */ 884 */
890 885
891 if (!ramdisk_execute_command) 886 if (!ramdisk_execute_command)
892 ramdisk_execute_command = "/init"; 887 ramdisk_execute_command = "/init";
893 888
894 if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) { 889 if (sys_access((const char __user *) ramdisk_execute_command, 0) != 0) {
895 ramdisk_execute_command = NULL; 890 ramdisk_execute_command = NULL;
896 prepare_namespace(); 891 prepare_namespace();
897 } 892 }
898 893
899 /* 894 /*
900 * Ok, we have completed the initial bootup, and 895 * Ok, we have completed the initial bootup, and
901 * we're essentially up and running. Get rid of the 896 * we're essentially up and running. Get rid of the
902 * initmem segments and start the user-mode stuff.. 897 * initmem segments and start the user-mode stuff..
903 */ 898 */
904 899
905 init_post(); 900 init_post();
906 return 0; 901 return 0;
907 } 902 }
908 903