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