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