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