1
2
3
4
5
6
7#define pr_fmt(fmt) "reboot: " fmt
8
9#include <linux/ctype.h>
10#include <linux/export.h>
11#include <linux/kexec.h>
12#include <linux/kmod.h>
13#include <linux/kmsg_dump.h>
14#include <linux/reboot.h>
15#include <linux/suspend.h>
16#include <linux/syscalls.h>
17#include <linux/syscore_ops.h>
18#include <linux/uaccess.h>
19
20
21
22
23
24int C_A_D = 1;
25struct pid *cad_pid;
26EXPORT_SYMBOL(cad_pid);
27
28#if defined(CONFIG_ARM) || defined(CONFIG_UNICORE32)
29#define DEFAULT_REBOOT_MODE = REBOOT_HARD
30#else
31#define DEFAULT_REBOOT_MODE
32#endif
33enum reboot_mode reboot_mode DEFAULT_REBOOT_MODE;
34
35
36
37
38
39
40
41
42int reboot_default = 1;
43int reboot_cpu;
44enum reboot_type reboot_type = BOOT_ACPI;
45int reboot_force;
46
47
48
49
50
51void (*pm_power_off_prepare)(void);
52
53
54
55
56
57
58
59
60
61void emergency_restart(void)
62{
63 kmsg_dump(KMSG_DUMP_EMERG);
64 machine_emergency_restart();
65}
66EXPORT_SYMBOL_GPL(emergency_restart);
67
68void kernel_restart_prepare(char *cmd)
69{
70 blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
71 system_state = SYSTEM_RESTART;
72 usermodehelper_disable();
73 device_shutdown();
74}
75
76
77
78
79
80
81
82
83
84
85
86int register_reboot_notifier(struct notifier_block *nb)
87{
88 return blocking_notifier_chain_register(&reboot_notifier_list, nb);
89}
90EXPORT_SYMBOL(register_reboot_notifier);
91
92
93
94
95
96
97
98
99
100
101int unregister_reboot_notifier(struct notifier_block *nb)
102{
103 return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
104}
105EXPORT_SYMBOL(unregister_reboot_notifier);
106
107
108
109
110
111static ATOMIC_NOTIFIER_HEAD(restart_handler_list);
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151int register_restart_handler(struct notifier_block *nb)
152{
153 return atomic_notifier_chain_register(&restart_handler_list, nb);
154}
155EXPORT_SYMBOL(register_restart_handler);
156
157
158
159
160
161
162
163
164
165
166int unregister_restart_handler(struct notifier_block *nb)
167{
168 return atomic_notifier_chain_unregister(&restart_handler_list, nb);
169}
170EXPORT_SYMBOL(unregister_restart_handler);
171
172
173
174
175
176
177
178
179
180
181
182
183void do_kernel_restart(char *cmd)
184{
185 atomic_notifier_call_chain(&restart_handler_list, reboot_mode, cmd);
186}
187
188void migrate_to_reboot_cpu(void)
189{
190
191 int cpu = reboot_cpu;
192
193 cpu_hotplug_disable();
194
195
196 if (!cpu_online(cpu))
197 cpu = cpumask_first(cpu_online_mask);
198
199
200 current->flags |= PF_NO_SETAFFINITY;
201
202
203 set_cpus_allowed_ptr(current, cpumask_of(cpu));
204}
205
206
207
208
209
210
211
212
213
214void kernel_restart(char *cmd)
215{
216 kernel_restart_prepare(cmd);
217 migrate_to_reboot_cpu();
218 syscore_shutdown();
219 if (!cmd)
220 pr_emerg("Restarting system\n");
221 else
222 pr_emerg("Restarting system with command '%s'\n", cmd);
223 kmsg_dump(KMSG_DUMP_RESTART);
224 machine_restart(cmd);
225}
226EXPORT_SYMBOL_GPL(kernel_restart);
227
228static void kernel_shutdown_prepare(enum system_states state)
229{
230 blocking_notifier_call_chain(&reboot_notifier_list,
231 (state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL);
232 system_state = state;
233 usermodehelper_disable();
234 device_shutdown();
235}
236
237
238
239
240
241void kernel_halt(void)
242{
243 kernel_shutdown_prepare(SYSTEM_HALT);
244 migrate_to_reboot_cpu();
245 syscore_shutdown();
246 pr_emerg("System halted\n");
247 kmsg_dump(KMSG_DUMP_HALT);
248 machine_halt();
249}
250EXPORT_SYMBOL_GPL(kernel_halt);
251
252
253
254
255
256
257void kernel_power_off(void)
258{
259 kernel_shutdown_prepare(SYSTEM_POWER_OFF);
260 if (pm_power_off_prepare)
261 pm_power_off_prepare();
262 migrate_to_reboot_cpu();
263 syscore_shutdown();
264 pr_emerg("Power down\n");
265 kmsg_dump(KMSG_DUMP_POWEROFF);
266 machine_power_off();
267}
268EXPORT_SYMBOL_GPL(kernel_power_off);
269
270static DEFINE_MUTEX(reboot_mutex);
271
272
273
274
275
276
277
278
279
280SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
281 void __user *, arg)
282{
283 struct pid_namespace *pid_ns = task_active_pid_ns(current);
284 char buffer[256];
285 int ret = 0;
286
287
288 if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
289 return -EPERM;
290
291
292 if (magic1 != LINUX_REBOOT_MAGIC1 ||
293 (magic2 != LINUX_REBOOT_MAGIC2 &&
294 magic2 != LINUX_REBOOT_MAGIC2A &&
295 magic2 != LINUX_REBOOT_MAGIC2B &&
296 magic2 != LINUX_REBOOT_MAGIC2C))
297 return -EINVAL;
298
299
300
301
302
303
304 ret = reboot_pid_ns(pid_ns, cmd);
305 if (ret)
306 return ret;
307
308
309
310
311 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
312 cmd = LINUX_REBOOT_CMD_HALT;
313
314 mutex_lock(&reboot_mutex);
315 switch (cmd) {
316 case LINUX_REBOOT_CMD_RESTART:
317 kernel_restart(NULL);
318 break;
319
320 case LINUX_REBOOT_CMD_CAD_ON:
321 C_A_D = 1;
322 break;
323
324 case LINUX_REBOOT_CMD_CAD_OFF:
325 C_A_D = 0;
326 break;
327
328 case LINUX_REBOOT_CMD_HALT:
329 kernel_halt();
330 do_exit(0);
331 panic("cannot halt");
332
333 case LINUX_REBOOT_CMD_POWER_OFF:
334 kernel_power_off();
335 do_exit(0);
336 break;
337
338 case LINUX_REBOOT_CMD_RESTART2:
339 ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1);
340 if (ret < 0) {
341 ret = -EFAULT;
342 break;
343 }
344 buffer[sizeof(buffer) - 1] = '\0';
345
346 kernel_restart(buffer);
347 break;
348
349#ifdef CONFIG_KEXEC_CORE
350 case LINUX_REBOOT_CMD_KEXEC:
351 ret = kernel_kexec();
352 break;
353#endif
354
355#ifdef CONFIG_HIBERNATION
356 case LINUX_REBOOT_CMD_SW_SUSPEND:
357 ret = hibernate();
358 break;
359#endif
360
361 default:
362 ret = -EINVAL;
363 break;
364 }
365 mutex_unlock(&reboot_mutex);
366 return ret;
367}
368
369static void deferred_cad(struct work_struct *dummy)
370{
371 kernel_restart(NULL);
372}
373
374
375
376
377
378
379void ctrl_alt_del(void)
380{
381 static DECLARE_WORK(cad_work, deferred_cad);
382
383 if (C_A_D)
384 schedule_work(&cad_work);
385 else
386 kill_cad_pid(SIGINT, 1);
387}
388
389char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
390static const char reboot_cmd[] = "/sbin/reboot";
391
392static int run_cmd(const char *cmd)
393{
394 char **argv;
395 static char *envp[] = {
396 "HOME=/",
397 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
398 NULL
399 };
400 int ret;
401 argv = argv_split(GFP_KERNEL, cmd, NULL);
402 if (argv) {
403 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
404 argv_free(argv);
405 } else {
406 ret = -ENOMEM;
407 }
408
409 return ret;
410}
411
412static int __orderly_reboot(void)
413{
414 int ret;
415
416 ret = run_cmd(reboot_cmd);
417
418 if (ret) {
419 pr_warn("Failed to start orderly reboot: forcing the issue\n");
420 emergency_sync();
421 kernel_restart(NULL);
422 }
423
424 return ret;
425}
426
427static int __orderly_poweroff(bool force)
428{
429 int ret;
430
431 ret = run_cmd(poweroff_cmd);
432
433 if (ret && force) {
434 pr_warn("Failed to start orderly shutdown: forcing the issue\n");
435
436
437
438
439
440
441 emergency_sync();
442 kernel_power_off();
443 }
444
445 return ret;
446}
447
448static bool poweroff_force;
449
450static void poweroff_work_func(struct work_struct *work)
451{
452 __orderly_poweroff(poweroff_force);
453}
454
455static DECLARE_WORK(poweroff_work, poweroff_work_func);
456
457
458
459
460
461
462
463
464void orderly_poweroff(bool force)
465{
466 if (force)
467 poweroff_force = true;
468 schedule_work(&poweroff_work);
469}
470EXPORT_SYMBOL_GPL(orderly_poweroff);
471
472static void reboot_work_func(struct work_struct *work)
473{
474 __orderly_reboot();
475}
476
477static DECLARE_WORK(reboot_work, reboot_work_func);
478
479
480
481
482
483
484
485void orderly_reboot(void)
486{
487 schedule_work(&reboot_work);
488}
489EXPORT_SYMBOL_GPL(orderly_reboot);
490
491static int __init reboot_setup(char *str)
492{
493 for (;;) {
494
495
496
497
498
499 reboot_default = 0;
500
501 switch (*str) {
502 case 'w':
503 reboot_mode = REBOOT_WARM;
504 break;
505
506 case 'c':
507 reboot_mode = REBOOT_COLD;
508 break;
509
510 case 'h':
511 reboot_mode = REBOOT_HARD;
512 break;
513
514 case 's':
515 {
516 int rc;
517
518 if (isdigit(*(str+1))) {
519 rc = kstrtoint(str+1, 0, &reboot_cpu);
520 if (rc)
521 return rc;
522 } else if (str[1] == 'm' && str[2] == 'p' &&
523 isdigit(*(str+3))) {
524 rc = kstrtoint(str+3, 0, &reboot_cpu);
525 if (rc)
526 return rc;
527 } else
528 reboot_mode = REBOOT_SOFT;
529 break;
530 }
531 case 'g':
532 reboot_mode = REBOOT_GPIO;
533 break;
534
535 case 'b':
536 case 'a':
537 case 'k':
538 case 't':
539 case 'e':
540 case 'p':
541 reboot_type = *str;
542 break;
543
544 case 'f':
545 reboot_force = 1;
546 break;
547 }
548
549 str = strchr(str, ',');
550 if (str)
551 str++;
552 else
553 break;
554 }
555 return 1;
556}
557__setup("reboot=", reboot_setup);
558