Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-only
2 : /*
3 : * linux/kernel/reboot.c
4 : *
5 : * Copyright (C) 2013 Linus Torvalds
6 : */
7 :
8 : #define pr_fmt(fmt) "reboot: " fmt
9 :
10 : #include <linux/atomic.h>
11 : #include <linux/ctype.h>
12 : #include <linux/export.h>
13 : #include <linux/kexec.h>
14 : #include <linux/kmod.h>
15 : #include <linux/kmsg_dump.h>
16 : #include <linux/reboot.h>
17 : #include <linux/suspend.h>
18 : #include <linux/syscalls.h>
19 : #include <linux/syscore_ops.h>
20 : #include <linux/uaccess.h>
21 :
22 : /*
23 : * this indicates whether you can reboot with ctrl-alt-del: the default is yes
24 : */
25 :
26 : static int C_A_D = 1;
27 : struct pid *cad_pid;
28 : EXPORT_SYMBOL(cad_pid);
29 :
30 : #if defined(CONFIG_ARM)
31 : #define DEFAULT_REBOOT_MODE = REBOOT_HARD
32 : #else
33 : #define DEFAULT_REBOOT_MODE
34 : #endif
35 : enum reboot_mode reboot_mode DEFAULT_REBOOT_MODE;
36 : EXPORT_SYMBOL_GPL(reboot_mode);
37 : enum reboot_mode panic_reboot_mode = REBOOT_UNDEFINED;
38 :
39 : /*
40 : * This variable is used privately to keep track of whether or not
41 : * reboot_type is still set to its default value (i.e., reboot= hasn't
42 : * been set on the command line). This is needed so that we can
43 : * suppress DMI scanning for reboot quirks. Without it, it's
44 : * impossible to override a faulty reboot quirk without recompiling.
45 : */
46 : int reboot_default = 1;
47 : int reboot_cpu;
48 : enum reboot_type reboot_type = BOOT_ACPI;
49 : int reboot_force;
50 :
51 : struct sys_off_handler {
52 : struct notifier_block nb;
53 : int (*sys_off_cb)(struct sys_off_data *data);
54 : void *cb_data;
55 : enum sys_off_mode mode;
56 : bool blocking;
57 : void *list;
58 : };
59 :
60 : /*
61 : * Temporary stub that prevents linkage failure while we're in process
62 : * of removing all uses of legacy pm_power_off() around the kernel.
63 : */
64 : void __weak (*pm_power_off)(void);
65 :
66 : /**
67 : * emergency_restart - reboot the system
68 : *
69 : * Without shutting down any hardware or taking any locks
70 : * reboot the system. This is called when we know we are in
71 : * trouble so this is our best effort to reboot. This is
72 : * safe to call in interrupt context.
73 : */
74 0 : void emergency_restart(void)
75 : {
76 0 : kmsg_dump(KMSG_DUMP_EMERG);
77 : machine_emergency_restart();
78 0 : }
79 : EXPORT_SYMBOL_GPL(emergency_restart);
80 :
81 0 : void kernel_restart_prepare(char *cmd)
82 : {
83 0 : blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
84 0 : system_state = SYSTEM_RESTART;
85 : usermodehelper_disable();
86 0 : device_shutdown();
87 0 : }
88 :
89 : /**
90 : * register_reboot_notifier - Register function to be called at reboot time
91 : * @nb: Info about notifier function to be called
92 : *
93 : * Registers a function with the list of functions
94 : * to be called at reboot time.
95 : *
96 : * Currently always returns zero, as blocking_notifier_chain_register()
97 : * always returns zero.
98 : */
99 2 : int register_reboot_notifier(struct notifier_block *nb)
100 : {
101 2 : return blocking_notifier_chain_register(&reboot_notifier_list, nb);
102 : }
103 : EXPORT_SYMBOL(register_reboot_notifier);
104 :
105 : /**
106 : * unregister_reboot_notifier - Unregister previously registered reboot notifier
107 : * @nb: Hook to be unregistered
108 : *
109 : * Unregisters a previously registered reboot
110 : * notifier function.
111 : *
112 : * Returns zero on success, or %-ENOENT on failure.
113 : */
114 0 : int unregister_reboot_notifier(struct notifier_block *nb)
115 : {
116 0 : return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
117 : }
118 : EXPORT_SYMBOL(unregister_reboot_notifier);
119 :
120 0 : static void devm_unregister_reboot_notifier(struct device *dev, void *res)
121 : {
122 0 : WARN_ON(unregister_reboot_notifier(*(struct notifier_block **)res));
123 0 : }
124 :
125 0 : int devm_register_reboot_notifier(struct device *dev, struct notifier_block *nb)
126 : {
127 : struct notifier_block **rcnb;
128 : int ret;
129 :
130 0 : rcnb = devres_alloc(devm_unregister_reboot_notifier,
131 : sizeof(*rcnb), GFP_KERNEL);
132 0 : if (!rcnb)
133 : return -ENOMEM;
134 :
135 0 : ret = register_reboot_notifier(nb);
136 0 : if (!ret) {
137 0 : *rcnb = nb;
138 0 : devres_add(dev, rcnb);
139 : } else {
140 0 : devres_free(rcnb);
141 : }
142 :
143 : return ret;
144 : }
145 : EXPORT_SYMBOL(devm_register_reboot_notifier);
146 :
147 : /*
148 : * Notifier list for kernel code which wants to be called
149 : * to restart the system.
150 : */
151 : static ATOMIC_NOTIFIER_HEAD(restart_handler_list);
152 :
153 : /**
154 : * register_restart_handler - Register function to be called to reset
155 : * the system
156 : * @nb: Info about handler function to be called
157 : * @nb->priority: Handler priority. Handlers should follow the
158 : * following guidelines for setting priorities.
159 : * 0: Restart handler of last resort,
160 : * with limited restart capabilities
161 : * 128: Default restart handler; use if no other
162 : * restart handler is expected to be available,
163 : * and/or if restart functionality is
164 : * sufficient to restart the entire system
165 : * 255: Highest priority restart handler, will
166 : * preempt all other restart handlers
167 : *
168 : * Registers a function with code to be called to restart the
169 : * system.
170 : *
171 : * Registered functions will be called from machine_restart as last
172 : * step of the restart sequence (if the architecture specific
173 : * machine_restart function calls do_kernel_restart - see below
174 : * for details).
175 : * Registered functions are expected to restart the system immediately.
176 : * If more than one function is registered, the restart handler priority
177 : * selects which function will be called first.
178 : *
179 : * Restart handlers are expected to be registered from non-architecture
180 : * code, typically from drivers. A typical use case would be a system
181 : * where restart functionality is provided through a watchdog. Multiple
182 : * restart handlers may exist; for example, one restart handler might
183 : * restart the entire system, while another only restarts the CPU.
184 : * In such cases, the restart handler which only restarts part of the
185 : * hardware is expected to register with low priority to ensure that
186 : * it only runs if no other means to restart the system is available.
187 : *
188 : * Currently always returns zero, as atomic_notifier_chain_register()
189 : * always returns zero.
190 : */
191 0 : int register_restart_handler(struct notifier_block *nb)
192 : {
193 0 : return atomic_notifier_chain_register(&restart_handler_list, nb);
194 : }
195 : EXPORT_SYMBOL(register_restart_handler);
196 :
197 : /**
198 : * unregister_restart_handler - Unregister previously registered
199 : * restart handler
200 : * @nb: Hook to be unregistered
201 : *
202 : * Unregisters a previously registered restart handler function.
203 : *
204 : * Returns zero on success, or %-ENOENT on failure.
205 : */
206 0 : int unregister_restart_handler(struct notifier_block *nb)
207 : {
208 0 : return atomic_notifier_chain_unregister(&restart_handler_list, nb);
209 : }
210 : EXPORT_SYMBOL(unregister_restart_handler);
211 :
212 : /**
213 : * do_kernel_restart - Execute kernel restart handler call chain
214 : *
215 : * Calls functions registered with register_restart_handler.
216 : *
217 : * Expected to be called from machine_restart as last step of the restart
218 : * sequence.
219 : *
220 : * Restarts the system immediately if a restart handler function has been
221 : * registered. Otherwise does nothing.
222 : */
223 0 : void do_kernel_restart(char *cmd)
224 : {
225 0 : atomic_notifier_call_chain(&restart_handler_list, reboot_mode, cmd);
226 0 : }
227 :
228 1 : void migrate_to_reboot_cpu(void)
229 : {
230 : /* The boot cpu is always logical cpu 0 */
231 1 : int cpu = reboot_cpu;
232 :
233 : cpu_hotplug_disable();
234 :
235 : /* Make certain the cpu I'm about to reboot on is online */
236 1 : if (!cpu_online(cpu))
237 0 : cpu = cpumask_first(cpu_online_mask);
238 :
239 : /* Prevent races with other tasks migrating this task */
240 1 : current->flags |= PF_NO_SETAFFINITY;
241 :
242 : /* Make certain I only run on the appropriate processor */
243 4 : set_cpus_allowed_ptr(current, cpumask_of(cpu));
244 1 : }
245 :
246 : /*
247 : * Notifier list for kernel code which wants to be called
248 : * to prepare system for restart.
249 : */
250 : static BLOCKING_NOTIFIER_HEAD(restart_prep_handler_list);
251 :
252 : static void do_kernel_restart_prepare(void)
253 : {
254 0 : blocking_notifier_call_chain(&restart_prep_handler_list, 0, NULL);
255 : }
256 :
257 : /**
258 : * kernel_restart - reboot the system
259 : * @cmd: pointer to buffer containing command to execute for restart
260 : * or %NULL
261 : *
262 : * Shutdown everything and perform a clean reboot.
263 : * This is not safe to call in interrupt context.
264 : */
265 0 : void kernel_restart(char *cmd)
266 : {
267 0 : kernel_restart_prepare(cmd);
268 : do_kernel_restart_prepare();
269 0 : migrate_to_reboot_cpu();
270 0 : syscore_shutdown();
271 0 : if (!cmd)
272 0 : pr_emerg("Restarting system\n");
273 : else
274 0 : pr_emerg("Restarting system with command '%s'\n", cmd);
275 0 : kmsg_dump(KMSG_DUMP_SHUTDOWN);
276 0 : machine_restart(cmd);
277 0 : }
278 : EXPORT_SYMBOL_GPL(kernel_restart);
279 :
280 1 : static void kernel_shutdown_prepare(enum system_states state)
281 : {
282 1 : blocking_notifier_call_chain(&reboot_notifier_list,
283 : (state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL);
284 1 : system_state = state;
285 : usermodehelper_disable();
286 1 : device_shutdown();
287 1 : }
288 : /**
289 : * kernel_halt - halt the system
290 : *
291 : * Shutdown everything and perform a clean system halt.
292 : */
293 1 : void kernel_halt(void)
294 : {
295 1 : kernel_shutdown_prepare(SYSTEM_HALT);
296 1 : migrate_to_reboot_cpu();
297 1 : syscore_shutdown();
298 1 : pr_emerg("System halted\n");
299 1 : kmsg_dump(KMSG_DUMP_SHUTDOWN);
300 1 : machine_halt();
301 0 : }
302 : EXPORT_SYMBOL_GPL(kernel_halt);
303 :
304 : /*
305 : * Notifier list for kernel code which wants to be called
306 : * to prepare system for power off.
307 : */
308 : static BLOCKING_NOTIFIER_HEAD(power_off_prep_handler_list);
309 :
310 : /*
311 : * Notifier list for kernel code which wants to be called
312 : * to power off system.
313 : */
314 : static ATOMIC_NOTIFIER_HEAD(power_off_handler_list);
315 :
316 0 : static int sys_off_notify(struct notifier_block *nb,
317 : unsigned long mode, void *cmd)
318 : {
319 : struct sys_off_handler *handler;
320 0 : struct sys_off_data data = {};
321 :
322 0 : handler = container_of(nb, struct sys_off_handler, nb);
323 0 : data.cb_data = handler->cb_data;
324 0 : data.mode = mode;
325 0 : data.cmd = cmd;
326 :
327 0 : return handler->sys_off_cb(&data);
328 : }
329 :
330 : static struct sys_off_handler platform_sys_off_handler;
331 :
332 0 : static struct sys_off_handler *alloc_sys_off_handler(int priority)
333 : {
334 : struct sys_off_handler *handler;
335 : gfp_t flags;
336 :
337 : /*
338 : * Platforms like m68k can't allocate sys_off handler dynamically
339 : * at the early boot time because memory allocator isn't available yet.
340 : */
341 0 : if (priority == SYS_OFF_PRIO_PLATFORM) {
342 0 : handler = &platform_sys_off_handler;
343 0 : if (handler->cb_data)
344 : return ERR_PTR(-EBUSY);
345 : } else {
346 0 : if (system_state > SYSTEM_RUNNING)
347 : flags = GFP_ATOMIC;
348 : else
349 0 : flags = GFP_KERNEL;
350 :
351 0 : handler = kzalloc(sizeof(*handler), flags);
352 0 : if (!handler)
353 : return ERR_PTR(-ENOMEM);
354 : }
355 :
356 : return handler;
357 : }
358 :
359 0 : static void free_sys_off_handler(struct sys_off_handler *handler)
360 : {
361 0 : if (handler == &platform_sys_off_handler)
362 0 : memset(handler, 0, sizeof(*handler));
363 : else
364 0 : kfree(handler);
365 0 : }
366 :
367 : /**
368 : * register_sys_off_handler - Register sys-off handler
369 : * @mode: Sys-off mode
370 : * @priority: Handler priority
371 : * @callback: Callback function
372 : * @cb_data: Callback argument
373 : *
374 : * Registers system power-off or restart handler that will be invoked
375 : * at the step corresponding to the given sys-off mode. Handler's callback
376 : * should return NOTIFY_DONE to permit execution of the next handler in
377 : * the call chain or NOTIFY_STOP to break the chain (in error case for
378 : * example).
379 : *
380 : * Multiple handlers can be registered at the default priority level.
381 : *
382 : * Only one handler can be registered at the non-default priority level,
383 : * otherwise ERR_PTR(-EBUSY) is returned.
384 : *
385 : * Returns a new instance of struct sys_off_handler on success, or
386 : * an ERR_PTR()-encoded error code otherwise.
387 : */
388 : struct sys_off_handler *
389 0 : register_sys_off_handler(enum sys_off_mode mode,
390 : int priority,
391 : int (*callback)(struct sys_off_data *data),
392 : void *cb_data)
393 : {
394 : struct sys_off_handler *handler;
395 : int err;
396 :
397 0 : handler = alloc_sys_off_handler(priority);
398 0 : if (IS_ERR(handler))
399 : return handler;
400 :
401 0 : switch (mode) {
402 : case SYS_OFF_MODE_POWER_OFF_PREPARE:
403 0 : handler->list = &power_off_prep_handler_list;
404 0 : handler->blocking = true;
405 0 : break;
406 :
407 : case SYS_OFF_MODE_POWER_OFF:
408 0 : handler->list = &power_off_handler_list;
409 0 : break;
410 :
411 : case SYS_OFF_MODE_RESTART_PREPARE:
412 0 : handler->list = &restart_prep_handler_list;
413 0 : handler->blocking = true;
414 0 : break;
415 :
416 : case SYS_OFF_MODE_RESTART:
417 0 : handler->list = &restart_handler_list;
418 0 : break;
419 :
420 : default:
421 0 : free_sys_off_handler(handler);
422 0 : return ERR_PTR(-EINVAL);
423 : }
424 :
425 0 : handler->nb.notifier_call = sys_off_notify;
426 0 : handler->nb.priority = priority;
427 0 : handler->sys_off_cb = callback;
428 0 : handler->cb_data = cb_data;
429 0 : handler->mode = mode;
430 :
431 0 : if (handler->blocking) {
432 0 : if (priority == SYS_OFF_PRIO_DEFAULT)
433 0 : err = blocking_notifier_chain_register(handler->list,
434 : &handler->nb);
435 : else
436 0 : err = blocking_notifier_chain_register_unique_prio(handler->list,
437 : &handler->nb);
438 : } else {
439 0 : if (priority == SYS_OFF_PRIO_DEFAULT)
440 0 : err = atomic_notifier_chain_register(handler->list,
441 : &handler->nb);
442 : else
443 0 : err = atomic_notifier_chain_register_unique_prio(handler->list,
444 : &handler->nb);
445 : }
446 :
447 0 : if (err) {
448 0 : free_sys_off_handler(handler);
449 0 : return ERR_PTR(err);
450 : }
451 :
452 : return handler;
453 : }
454 : EXPORT_SYMBOL_GPL(register_sys_off_handler);
455 :
456 : /**
457 : * unregister_sys_off_handler - Unregister sys-off handler
458 : * @handler: Sys-off handler
459 : *
460 : * Unregisters given sys-off handler.
461 : */
462 0 : void unregister_sys_off_handler(struct sys_off_handler *handler)
463 : {
464 : int err;
465 :
466 0 : if (IS_ERR_OR_NULL(handler))
467 : return;
468 :
469 0 : if (handler->blocking)
470 0 : err = blocking_notifier_chain_unregister(handler->list,
471 : &handler->nb);
472 : else
473 0 : err = atomic_notifier_chain_unregister(handler->list,
474 : &handler->nb);
475 :
476 : /* sanity check, shall never happen */
477 0 : WARN_ON(err);
478 :
479 0 : free_sys_off_handler(handler);
480 : }
481 : EXPORT_SYMBOL_GPL(unregister_sys_off_handler);
482 :
483 0 : static void devm_unregister_sys_off_handler(void *data)
484 : {
485 0 : struct sys_off_handler *handler = data;
486 :
487 0 : unregister_sys_off_handler(handler);
488 0 : }
489 :
490 : /**
491 : * devm_register_sys_off_handler - Register sys-off handler
492 : * @dev: Device that registers handler
493 : * @mode: Sys-off mode
494 : * @priority: Handler priority
495 : * @callback: Callback function
496 : * @cb_data: Callback argument
497 : *
498 : * Registers resource-managed sys-off handler.
499 : *
500 : * Returns zero on success, or error code on failure.
501 : */
502 0 : int devm_register_sys_off_handler(struct device *dev,
503 : enum sys_off_mode mode,
504 : int priority,
505 : int (*callback)(struct sys_off_data *data),
506 : void *cb_data)
507 : {
508 : struct sys_off_handler *handler;
509 :
510 0 : handler = register_sys_off_handler(mode, priority, callback, cb_data);
511 0 : if (IS_ERR(handler))
512 0 : return PTR_ERR(handler);
513 :
514 : return devm_add_action_or_reset(dev, devm_unregister_sys_off_handler,
515 : handler);
516 : }
517 : EXPORT_SYMBOL_GPL(devm_register_sys_off_handler);
518 :
519 : /**
520 : * devm_register_power_off_handler - Register power-off handler
521 : * @dev: Device that registers callback
522 : * @callback: Callback function
523 : * @cb_data: Callback's argument
524 : *
525 : * Registers resource-managed sys-off handler with a default priority
526 : * and using power-off mode.
527 : *
528 : * Returns zero on success, or error code on failure.
529 : */
530 0 : int devm_register_power_off_handler(struct device *dev,
531 : int (*callback)(struct sys_off_data *data),
532 : void *cb_data)
533 : {
534 0 : return devm_register_sys_off_handler(dev,
535 : SYS_OFF_MODE_POWER_OFF,
536 : SYS_OFF_PRIO_DEFAULT,
537 : callback, cb_data);
538 : }
539 : EXPORT_SYMBOL_GPL(devm_register_power_off_handler);
540 :
541 : /**
542 : * devm_register_restart_handler - Register restart handler
543 : * @dev: Device that registers callback
544 : * @callback: Callback function
545 : * @cb_data: Callback's argument
546 : *
547 : * Registers resource-managed sys-off handler with a default priority
548 : * and using restart mode.
549 : *
550 : * Returns zero on success, or error code on failure.
551 : */
552 0 : int devm_register_restart_handler(struct device *dev,
553 : int (*callback)(struct sys_off_data *data),
554 : void *cb_data)
555 : {
556 0 : return devm_register_sys_off_handler(dev,
557 : SYS_OFF_MODE_RESTART,
558 : SYS_OFF_PRIO_DEFAULT,
559 : callback, cb_data);
560 : }
561 : EXPORT_SYMBOL_GPL(devm_register_restart_handler);
562 :
563 : static struct sys_off_handler *platform_power_off_handler;
564 :
565 0 : static int platform_power_off_notify(struct sys_off_data *data)
566 : {
567 0 : void (*platform_power_power_off_cb)(void) = data->cb_data;
568 :
569 0 : platform_power_power_off_cb();
570 :
571 0 : return NOTIFY_DONE;
572 : }
573 :
574 : /**
575 : * register_platform_power_off - Register platform-level power-off callback
576 : * @power_off: Power-off callback
577 : *
578 : * Registers power-off callback that will be called as last step
579 : * of the power-off sequence. This callback is expected to be invoked
580 : * for the last resort. Only one platform power-off callback is allowed
581 : * to be registered at a time.
582 : *
583 : * Returns zero on success, or error code on failure.
584 : */
585 0 : int register_platform_power_off(void (*power_off)(void))
586 : {
587 : struct sys_off_handler *handler;
588 :
589 0 : handler = register_sys_off_handler(SYS_OFF_MODE_POWER_OFF,
590 : SYS_OFF_PRIO_PLATFORM,
591 : platform_power_off_notify,
592 : power_off);
593 0 : if (IS_ERR(handler))
594 0 : return PTR_ERR(handler);
595 :
596 0 : platform_power_off_handler = handler;
597 :
598 0 : return 0;
599 : }
600 : EXPORT_SYMBOL_GPL(register_platform_power_off);
601 :
602 : /**
603 : * unregister_platform_power_off - Unregister platform-level power-off callback
604 : * @power_off: Power-off callback
605 : *
606 : * Unregisters previously registered platform power-off callback.
607 : */
608 0 : void unregister_platform_power_off(void (*power_off)(void))
609 : {
610 0 : if (platform_power_off_handler &&
611 0 : platform_power_off_handler->cb_data == power_off) {
612 0 : unregister_sys_off_handler(platform_power_off_handler);
613 0 : platform_power_off_handler = NULL;
614 : }
615 0 : }
616 : EXPORT_SYMBOL_GPL(unregister_platform_power_off);
617 :
618 0 : static int legacy_pm_power_off(struct sys_off_data *data)
619 : {
620 0 : if (pm_power_off)
621 0 : pm_power_off();
622 :
623 0 : return NOTIFY_DONE;
624 : }
625 :
626 : static void do_kernel_power_off_prepare(void)
627 : {
628 0 : blocking_notifier_call_chain(&power_off_prep_handler_list, 0, NULL);
629 : }
630 :
631 : /**
632 : * do_kernel_power_off - Execute kernel power-off handler call chain
633 : *
634 : * Expected to be called as last step of the power-off sequence.
635 : *
636 : * Powers off the system immediately if a power-off handler function has
637 : * been registered. Otherwise does nothing.
638 : */
639 0 : void do_kernel_power_off(void)
640 : {
641 0 : struct sys_off_handler *sys_off = NULL;
642 :
643 : /*
644 : * Register sys-off handlers for legacy PM callback. This allows
645 : * legacy PM callbacks temporary co-exist with the new sys-off API.
646 : *
647 : * TODO: Remove legacy handlers once all legacy PM users will be
648 : * switched to the sys-off based APIs.
649 : */
650 0 : if (pm_power_off)
651 0 : sys_off = register_sys_off_handler(SYS_OFF_MODE_POWER_OFF,
652 : SYS_OFF_PRIO_DEFAULT,
653 : legacy_pm_power_off, NULL);
654 :
655 0 : atomic_notifier_call_chain(&power_off_handler_list, 0, NULL);
656 :
657 0 : unregister_sys_off_handler(sys_off);
658 0 : }
659 :
660 : /**
661 : * kernel_can_power_off - check whether system can be powered off
662 : *
663 : * Returns true if power-off handler is registered and system can be
664 : * powered off, false otherwise.
665 : */
666 0 : bool kernel_can_power_off(void)
667 : {
668 0 : return !atomic_notifier_call_chain_is_empty(&power_off_handler_list) ||
669 : pm_power_off;
670 : }
671 : EXPORT_SYMBOL_GPL(kernel_can_power_off);
672 :
673 : /**
674 : * kernel_power_off - power_off the system
675 : *
676 : * Shutdown everything and perform a clean system power_off.
677 : */
678 0 : void kernel_power_off(void)
679 : {
680 0 : kernel_shutdown_prepare(SYSTEM_POWER_OFF);
681 : do_kernel_power_off_prepare();
682 0 : migrate_to_reboot_cpu();
683 0 : syscore_shutdown();
684 0 : pr_emerg("Power down\n");
685 0 : kmsg_dump(KMSG_DUMP_SHUTDOWN);
686 0 : machine_power_off();
687 0 : }
688 : EXPORT_SYMBOL_GPL(kernel_power_off);
689 :
690 : DEFINE_MUTEX(system_transition_mutex);
691 :
692 : /*
693 : * Reboot system call: for obvious reasons only root may call it,
694 : * and even root needs to set up some magic numbers in the registers
695 : * so that some mistake won't make this reboot the whole machine.
696 : * You can also set the meaning of the ctrl-alt-del-key here.
697 : *
698 : * reboot doesn't sync: do that yourself before calling this.
699 : */
700 0 : SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
701 : void __user *, arg)
702 : {
703 0 : struct pid_namespace *pid_ns = task_active_pid_ns(current);
704 : char buffer[256];
705 0 : int ret = 0;
706 :
707 : /* We only trust the superuser with rebooting the system. */
708 0 : if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
709 : return -EPERM;
710 :
711 : /* For safety, we require "magic" arguments. */
712 0 : if (magic1 != LINUX_REBOOT_MAGIC1 ||
713 0 : (magic2 != LINUX_REBOOT_MAGIC2 &&
714 0 : magic2 != LINUX_REBOOT_MAGIC2A &&
715 0 : magic2 != LINUX_REBOOT_MAGIC2B &&
716 0 : magic2 != LINUX_REBOOT_MAGIC2C))
717 : return -EINVAL;
718 :
719 : /*
720 : * If pid namespaces are enabled and the current task is in a child
721 : * pid_namespace, the command is handled by reboot_pid_ns() which will
722 : * call do_exit().
723 : */
724 0 : ret = reboot_pid_ns(pid_ns, cmd);
725 0 : if (ret)
726 0 : return ret;
727 :
728 : /* Instead of trying to make the power_off code look like
729 : * halt when pm_power_off is not set do it the easy way.
730 : */
731 0 : if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !kernel_can_power_off())
732 0 : cmd = LINUX_REBOOT_CMD_HALT;
733 :
734 0 : mutex_lock(&system_transition_mutex);
735 0 : switch (cmd) {
736 : case LINUX_REBOOT_CMD_RESTART:
737 0 : kernel_restart(NULL);
738 0 : break;
739 :
740 : case LINUX_REBOOT_CMD_CAD_ON:
741 0 : C_A_D = 1;
742 0 : break;
743 :
744 : case LINUX_REBOOT_CMD_CAD_OFF:
745 0 : C_A_D = 0;
746 0 : break;
747 :
748 : case LINUX_REBOOT_CMD_HALT:
749 0 : kernel_halt();
750 0 : do_exit(0);
751 :
752 : case LINUX_REBOOT_CMD_POWER_OFF:
753 0 : kernel_power_off();
754 0 : do_exit(0);
755 : break;
756 :
757 : case LINUX_REBOOT_CMD_RESTART2:
758 0 : ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1);
759 0 : if (ret < 0) {
760 : ret = -EFAULT;
761 : break;
762 : }
763 0 : buffer[sizeof(buffer) - 1] = '\0';
764 :
765 0 : kernel_restart(buffer);
766 0 : break;
767 :
768 : #ifdef CONFIG_KEXEC_CORE
769 : case LINUX_REBOOT_CMD_KEXEC:
770 : ret = kernel_kexec();
771 : break;
772 : #endif
773 :
774 : #ifdef CONFIG_HIBERNATION
775 : case LINUX_REBOOT_CMD_SW_SUSPEND:
776 : ret = hibernate();
777 : break;
778 : #endif
779 :
780 : default:
781 : ret = -EINVAL;
782 : break;
783 : }
784 0 : mutex_unlock(&system_transition_mutex);
785 0 : return ret;
786 : }
787 :
788 0 : static void deferred_cad(struct work_struct *dummy)
789 : {
790 0 : kernel_restart(NULL);
791 0 : }
792 :
793 : /*
794 : * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
795 : * As it's called within an interrupt, it may NOT sync: the only choice
796 : * is whether to reboot at once, or just ignore the ctrl-alt-del.
797 : */
798 0 : void ctrl_alt_del(void)
799 : {
800 : static DECLARE_WORK(cad_work, deferred_cad);
801 :
802 0 : if (C_A_D)
803 : schedule_work(&cad_work);
804 : else
805 : kill_cad_pid(SIGINT, 1);
806 0 : }
807 :
808 : #define POWEROFF_CMD_PATH_LEN 256
809 : static char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
810 : static const char reboot_cmd[] = "/sbin/reboot";
811 :
812 0 : static int run_cmd(const char *cmd)
813 : {
814 : char **argv;
815 : static char *envp[] = {
816 : "HOME=/",
817 : "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
818 : NULL
819 : };
820 : int ret;
821 0 : argv = argv_split(GFP_KERNEL, cmd, NULL);
822 0 : if (argv) {
823 0 : ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
824 0 : argv_free(argv);
825 : } else {
826 : ret = -ENOMEM;
827 : }
828 :
829 0 : return ret;
830 : }
831 :
832 0 : static int __orderly_reboot(void)
833 : {
834 : int ret;
835 :
836 0 : ret = run_cmd(reboot_cmd);
837 :
838 0 : if (ret) {
839 0 : pr_warn("Failed to start orderly reboot: forcing the issue\n");
840 0 : emergency_sync();
841 0 : kernel_restart(NULL);
842 : }
843 :
844 0 : return ret;
845 : }
846 :
847 0 : static int __orderly_poweroff(bool force)
848 : {
849 : int ret;
850 :
851 0 : ret = run_cmd(poweroff_cmd);
852 :
853 0 : if (ret && force) {
854 0 : pr_warn("Failed to start orderly shutdown: forcing the issue\n");
855 :
856 : /*
857 : * I guess this should try to kick off some daemon to sync and
858 : * poweroff asap. Or not even bother syncing if we're doing an
859 : * emergency shutdown?
860 : */
861 0 : emergency_sync();
862 0 : kernel_power_off();
863 : }
864 :
865 0 : return ret;
866 : }
867 :
868 : static bool poweroff_force;
869 :
870 0 : static void poweroff_work_func(struct work_struct *work)
871 : {
872 0 : __orderly_poweroff(poweroff_force);
873 0 : }
874 :
875 : static DECLARE_WORK(poweroff_work, poweroff_work_func);
876 :
877 : /**
878 : * orderly_poweroff - Trigger an orderly system poweroff
879 : * @force: force poweroff if command execution fails
880 : *
881 : * This may be called from any context to trigger a system shutdown.
882 : * If the orderly shutdown fails, it will force an immediate shutdown.
883 : */
884 0 : void orderly_poweroff(bool force)
885 : {
886 0 : if (force) /* do not override the pending "true" */
887 0 : poweroff_force = true;
888 0 : schedule_work(&poweroff_work);
889 0 : }
890 : EXPORT_SYMBOL_GPL(orderly_poweroff);
891 :
892 0 : static void reboot_work_func(struct work_struct *work)
893 : {
894 0 : __orderly_reboot();
895 0 : }
896 :
897 : static DECLARE_WORK(reboot_work, reboot_work_func);
898 :
899 : /**
900 : * orderly_reboot - Trigger an orderly system reboot
901 : *
902 : * This may be called from any context to trigger a system reboot.
903 : * If the orderly reboot fails, it will force an immediate reboot.
904 : */
905 0 : void orderly_reboot(void)
906 : {
907 0 : schedule_work(&reboot_work);
908 0 : }
909 : EXPORT_SYMBOL_GPL(orderly_reboot);
910 :
911 : /**
912 : * hw_failure_emergency_poweroff_func - emergency poweroff work after a known delay
913 : * @work: work_struct associated with the emergency poweroff function
914 : *
915 : * This function is called in very critical situations to force
916 : * a kernel poweroff after a configurable timeout value.
917 : */
918 0 : static void hw_failure_emergency_poweroff_func(struct work_struct *work)
919 : {
920 : /*
921 : * We have reached here after the emergency shutdown waiting period has
922 : * expired. This means orderly_poweroff has not been able to shut off
923 : * the system for some reason.
924 : *
925 : * Try to shut down the system immediately using kernel_power_off
926 : * if populated
927 : */
928 0 : pr_emerg("Hardware protection timed-out. Trying forced poweroff\n");
929 0 : kernel_power_off();
930 :
931 : /*
932 : * Worst of the worst case trigger emergency restart
933 : */
934 0 : pr_emerg("Hardware protection shutdown failed. Trying emergency restart\n");
935 : emergency_restart();
936 0 : }
937 :
938 : static DECLARE_DELAYED_WORK(hw_failure_emergency_poweroff_work,
939 : hw_failure_emergency_poweroff_func);
940 :
941 : /**
942 : * hw_failure_emergency_poweroff - Trigger an emergency system poweroff
943 : *
944 : * This may be called from any critical situation to trigger a system shutdown
945 : * after a given period of time. If time is negative this is not scheduled.
946 : */
947 0 : static void hw_failure_emergency_poweroff(int poweroff_delay_ms)
948 : {
949 0 : if (poweroff_delay_ms <= 0)
950 : return;
951 0 : schedule_delayed_work(&hw_failure_emergency_poweroff_work,
952 : msecs_to_jiffies(poweroff_delay_ms));
953 : }
954 :
955 : /**
956 : * hw_protection_shutdown - Trigger an emergency system poweroff
957 : *
958 : * @reason: Reason of emergency shutdown to be printed.
959 : * @ms_until_forced: Time to wait for orderly shutdown before tiggering a
960 : * forced shudown. Negative value disables the forced
961 : * shutdown.
962 : *
963 : * Initiate an emergency system shutdown in order to protect hardware from
964 : * further damage. Usage examples include a thermal protection or a voltage or
965 : * current regulator failures.
966 : * NOTE: The request is ignored if protection shutdown is already pending even
967 : * if the previous request has given a large timeout for forced shutdown.
968 : * Can be called from any context.
969 : */
970 0 : void hw_protection_shutdown(const char *reason, int ms_until_forced)
971 : {
972 : static atomic_t allow_proceed = ATOMIC_INIT(1);
973 :
974 0 : pr_emerg("HARDWARE PROTECTION shutdown (%s)\n", reason);
975 :
976 : /* Shutdown should be initiated only once. */
977 0 : if (!atomic_dec_and_test(&allow_proceed))
978 : return;
979 :
980 : /*
981 : * Queue a backup emergency shutdown in the event of
982 : * orderly_poweroff failure
983 : */
984 0 : hw_failure_emergency_poweroff(ms_until_forced);
985 : orderly_poweroff(true);
986 : }
987 : EXPORT_SYMBOL_GPL(hw_protection_shutdown);
988 :
989 0 : static int __init reboot_setup(char *str)
990 : {
991 0 : for (;;) {
992 : enum reboot_mode *mode;
993 :
994 : /*
995 : * Having anything passed on the command line via
996 : * reboot= will cause us to disable DMI checking
997 : * below.
998 : */
999 0 : reboot_default = 0;
1000 :
1001 0 : if (!strncmp(str, "panic_", 6)) {
1002 0 : mode = &panic_reboot_mode;
1003 0 : str += 6;
1004 : } else {
1005 : mode = &reboot_mode;
1006 : }
1007 :
1008 0 : switch (*str) {
1009 : case 'w':
1010 0 : *mode = REBOOT_WARM;
1011 0 : break;
1012 :
1013 : case 'c':
1014 0 : *mode = REBOOT_COLD;
1015 0 : break;
1016 :
1017 : case 'h':
1018 0 : *mode = REBOOT_HARD;
1019 0 : break;
1020 :
1021 : case 's':
1022 : /*
1023 : * reboot_cpu is s[mp]#### with #### being the processor
1024 : * to be used for rebooting. Skip 's' or 'smp' prefix.
1025 : */
1026 0 : str += str[1] == 'm' && str[2] == 'p' ? 3 : 1;
1027 :
1028 0 : if (isdigit(str[0])) {
1029 0 : int cpu = simple_strtoul(str, NULL, 0);
1030 :
1031 0 : if (cpu >= num_possible_cpus()) {
1032 0 : pr_err("Ignoring the CPU number in reboot= option. "
1033 : "CPU %d exceeds possible cpu number %d\n",
1034 : cpu, num_possible_cpus());
1035 0 : break;
1036 : }
1037 0 : reboot_cpu = cpu;
1038 : } else
1039 0 : *mode = REBOOT_SOFT;
1040 : break;
1041 :
1042 : case 'g':
1043 0 : *mode = REBOOT_GPIO;
1044 0 : break;
1045 :
1046 : case 'b':
1047 : case 'a':
1048 : case 'k':
1049 : case 't':
1050 : case 'e':
1051 : case 'p':
1052 0 : reboot_type = *str;
1053 0 : break;
1054 :
1055 : case 'f':
1056 0 : reboot_force = 1;
1057 0 : break;
1058 : }
1059 :
1060 0 : str = strchr(str, ',');
1061 0 : if (str)
1062 0 : str++;
1063 : else
1064 : break;
1065 : }
1066 0 : return 1;
1067 : }
1068 : __setup("reboot=", reboot_setup);
1069 :
1070 : #ifdef CONFIG_SYSFS
1071 :
1072 : #define REBOOT_COLD_STR "cold"
1073 : #define REBOOT_WARM_STR "warm"
1074 : #define REBOOT_HARD_STR "hard"
1075 : #define REBOOT_SOFT_STR "soft"
1076 : #define REBOOT_GPIO_STR "gpio"
1077 : #define REBOOT_UNDEFINED_STR "undefined"
1078 :
1079 : #define BOOT_TRIPLE_STR "triple"
1080 : #define BOOT_KBD_STR "kbd"
1081 : #define BOOT_BIOS_STR "bios"
1082 : #define BOOT_ACPI_STR "acpi"
1083 : #define BOOT_EFI_STR "efi"
1084 : #define BOOT_PCI_STR "pci"
1085 :
1086 0 : static ssize_t mode_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
1087 : {
1088 : const char *val;
1089 :
1090 0 : switch (reboot_mode) {
1091 : case REBOOT_COLD:
1092 : val = REBOOT_COLD_STR;
1093 : break;
1094 : case REBOOT_WARM:
1095 : val = REBOOT_WARM_STR;
1096 : break;
1097 : case REBOOT_HARD:
1098 : val = REBOOT_HARD_STR;
1099 : break;
1100 : case REBOOT_SOFT:
1101 : val = REBOOT_SOFT_STR;
1102 : break;
1103 : case REBOOT_GPIO:
1104 : val = REBOOT_GPIO_STR;
1105 : break;
1106 : default:
1107 : val = REBOOT_UNDEFINED_STR;
1108 : }
1109 :
1110 0 : return sprintf(buf, "%s\n", val);
1111 : }
1112 0 : static ssize_t mode_store(struct kobject *kobj, struct kobj_attribute *attr,
1113 : const char *buf, size_t count)
1114 : {
1115 0 : if (!capable(CAP_SYS_BOOT))
1116 : return -EPERM;
1117 :
1118 0 : if (!strncmp(buf, REBOOT_COLD_STR, strlen(REBOOT_COLD_STR)))
1119 0 : reboot_mode = REBOOT_COLD;
1120 0 : else if (!strncmp(buf, REBOOT_WARM_STR, strlen(REBOOT_WARM_STR)))
1121 0 : reboot_mode = REBOOT_WARM;
1122 0 : else if (!strncmp(buf, REBOOT_HARD_STR, strlen(REBOOT_HARD_STR)))
1123 0 : reboot_mode = REBOOT_HARD;
1124 0 : else if (!strncmp(buf, REBOOT_SOFT_STR, strlen(REBOOT_SOFT_STR)))
1125 0 : reboot_mode = REBOOT_SOFT;
1126 0 : else if (!strncmp(buf, REBOOT_GPIO_STR, strlen(REBOOT_GPIO_STR)))
1127 0 : reboot_mode = REBOOT_GPIO;
1128 : else
1129 : return -EINVAL;
1130 :
1131 0 : reboot_default = 0;
1132 :
1133 0 : return count;
1134 : }
1135 : static struct kobj_attribute reboot_mode_attr = __ATTR_RW(mode);
1136 :
1137 : #ifdef CONFIG_X86
1138 : static ssize_t force_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
1139 : {
1140 : return sprintf(buf, "%d\n", reboot_force);
1141 : }
1142 : static ssize_t force_store(struct kobject *kobj, struct kobj_attribute *attr,
1143 : const char *buf, size_t count)
1144 : {
1145 : bool res;
1146 :
1147 : if (!capable(CAP_SYS_BOOT))
1148 : return -EPERM;
1149 :
1150 : if (kstrtobool(buf, &res))
1151 : return -EINVAL;
1152 :
1153 : reboot_default = 0;
1154 : reboot_force = res;
1155 :
1156 : return count;
1157 : }
1158 : static struct kobj_attribute reboot_force_attr = __ATTR_RW(force);
1159 :
1160 : static ssize_t type_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
1161 : {
1162 : const char *val;
1163 :
1164 : switch (reboot_type) {
1165 : case BOOT_TRIPLE:
1166 : val = BOOT_TRIPLE_STR;
1167 : break;
1168 : case BOOT_KBD:
1169 : val = BOOT_KBD_STR;
1170 : break;
1171 : case BOOT_BIOS:
1172 : val = BOOT_BIOS_STR;
1173 : break;
1174 : case BOOT_ACPI:
1175 : val = BOOT_ACPI_STR;
1176 : break;
1177 : case BOOT_EFI:
1178 : val = BOOT_EFI_STR;
1179 : break;
1180 : case BOOT_CF9_FORCE:
1181 : val = BOOT_PCI_STR;
1182 : break;
1183 : default:
1184 : val = REBOOT_UNDEFINED_STR;
1185 : }
1186 :
1187 : return sprintf(buf, "%s\n", val);
1188 : }
1189 : static ssize_t type_store(struct kobject *kobj, struct kobj_attribute *attr,
1190 : const char *buf, size_t count)
1191 : {
1192 : if (!capable(CAP_SYS_BOOT))
1193 : return -EPERM;
1194 :
1195 : if (!strncmp(buf, BOOT_TRIPLE_STR, strlen(BOOT_TRIPLE_STR)))
1196 : reboot_type = BOOT_TRIPLE;
1197 : else if (!strncmp(buf, BOOT_KBD_STR, strlen(BOOT_KBD_STR)))
1198 : reboot_type = BOOT_KBD;
1199 : else if (!strncmp(buf, BOOT_BIOS_STR, strlen(BOOT_BIOS_STR)))
1200 : reboot_type = BOOT_BIOS;
1201 : else if (!strncmp(buf, BOOT_ACPI_STR, strlen(BOOT_ACPI_STR)))
1202 : reboot_type = BOOT_ACPI;
1203 : else if (!strncmp(buf, BOOT_EFI_STR, strlen(BOOT_EFI_STR)))
1204 : reboot_type = BOOT_EFI;
1205 : else if (!strncmp(buf, BOOT_PCI_STR, strlen(BOOT_PCI_STR)))
1206 : reboot_type = BOOT_CF9_FORCE;
1207 : else
1208 : return -EINVAL;
1209 :
1210 : reboot_default = 0;
1211 :
1212 : return count;
1213 : }
1214 : static struct kobj_attribute reboot_type_attr = __ATTR_RW(type);
1215 : #endif
1216 :
1217 : #ifdef CONFIG_SMP
1218 : static ssize_t cpu_show(struct kobject *kobj, struct kobj_attribute *attr, char *buf)
1219 : {
1220 : return sprintf(buf, "%d\n", reboot_cpu);
1221 : }
1222 : static ssize_t cpu_store(struct kobject *kobj, struct kobj_attribute *attr,
1223 : const char *buf, size_t count)
1224 : {
1225 : unsigned int cpunum;
1226 : int rc;
1227 :
1228 : if (!capable(CAP_SYS_BOOT))
1229 : return -EPERM;
1230 :
1231 : rc = kstrtouint(buf, 0, &cpunum);
1232 :
1233 : if (rc)
1234 : return rc;
1235 :
1236 : if (cpunum >= num_possible_cpus())
1237 : return -ERANGE;
1238 :
1239 : reboot_default = 0;
1240 : reboot_cpu = cpunum;
1241 :
1242 : return count;
1243 : }
1244 : static struct kobj_attribute reboot_cpu_attr = __ATTR_RW(cpu);
1245 : #endif
1246 :
1247 : static struct attribute *reboot_attrs[] = {
1248 : &reboot_mode_attr.attr,
1249 : #ifdef CONFIG_X86
1250 : &reboot_force_attr.attr,
1251 : &reboot_type_attr.attr,
1252 : #endif
1253 : #ifdef CONFIG_SMP
1254 : &reboot_cpu_attr.attr,
1255 : #endif
1256 : NULL,
1257 : };
1258 :
1259 : #ifdef CONFIG_SYSCTL
1260 : static struct ctl_table kern_reboot_table[] = {
1261 : {
1262 : .procname = "poweroff_cmd",
1263 : .data = &poweroff_cmd,
1264 : .maxlen = POWEROFF_CMD_PATH_LEN,
1265 : .mode = 0644,
1266 : .proc_handler = proc_dostring,
1267 : },
1268 : {
1269 : .procname = "ctrl-alt-del",
1270 : .data = &C_A_D,
1271 : .maxlen = sizeof(int),
1272 : .mode = 0644,
1273 : .proc_handler = proc_dointvec,
1274 : },
1275 : { }
1276 : };
1277 :
1278 1 : static void __init kernel_reboot_sysctls_init(void)
1279 : {
1280 1 : register_sysctl_init("kernel", kern_reboot_table);
1281 1 : }
1282 : #else
1283 : #define kernel_reboot_sysctls_init() do { } while (0)
1284 : #endif /* CONFIG_SYSCTL */
1285 :
1286 : static const struct attribute_group reboot_attr_group = {
1287 : .attrs = reboot_attrs,
1288 : };
1289 :
1290 1 : static int __init reboot_ksysfs_init(void)
1291 : {
1292 : struct kobject *reboot_kobj;
1293 : int ret;
1294 :
1295 1 : reboot_kobj = kobject_create_and_add("reboot", kernel_kobj);
1296 1 : if (!reboot_kobj)
1297 : return -ENOMEM;
1298 :
1299 1 : ret = sysfs_create_group(reboot_kobj, &reboot_attr_group);
1300 1 : if (ret) {
1301 0 : kobject_put(reboot_kobj);
1302 0 : return ret;
1303 : }
1304 :
1305 1 : kernel_reboot_sysctls_init();
1306 :
1307 1 : return 0;
1308 : }
1309 : late_initcall(reboot_ksysfs_init);
1310 :
1311 : #endif
|
