kernel/reboot.c

   1 /*
   2  *  linux/kernel/reboot.c
   3  *
   4  *  Copyright (C) 2013  Linus Torvalds
   5  */
   6
   7 #define pr_fmt(fmt)     "reboot: " fmt
   8
   9 #include <linux/ctype.h>
  10 #include <linux/export.h>
  11 #include <linux/kexec.h>
  12 #include <linux/kmod.h>
  13 #include <linux/kmsg_dump.h>
  14 #include <linux/reboot.h>
  15 #include <linux/suspend.h>
  16 #include <linux/syscalls.h>
  17 #include <linux/syscore_ops.h>
  18 #include <linux/uaccess.h>
  19
  20 /*
  21  * this indicates whether you can reboot with ctrl-alt-del: the default is yes
  22  */
  23
  24 int C_A_D = 1;
  25 struct pid *cad_pid;
  26 EXPORT_SYMBOL(cad_pid);
  27
  28 #if defined(CONFIG_ARM) || defined(CONFIG_UNICORE32)
  29 #define DEFAULT_REBOOT_MODE             = REBOOT_HARD
  30 #else
  31 #define DEFAULT_REBOOT_MODE
  32 #endif
  33 enum reboot_mode reboot_mode DEFAULT_REBOOT_MODE;
  34
  35 /*
  36  * This variable is used privately to keep track of whether or not
  37  * reboot_type is still set to its default value (i.e., reboot= hasn't
  38  * been set on the command line).  This is needed so that we can
  39  * suppress DMI scanning for reboot quirks.  Without it, it's
  40  * impossible to override a faulty reboot quirk without recompiling.
  41  */
  42 int reboot_default = 1;
  43 int reboot_cpu;
  44 enum reboot_type reboot_type = BOOT_ACPI;
  45 int reboot_force;
  46
  47 /*
  48  * If set, this is used for preparing the system to power off.
  49  */
  50
  51 void (*pm_power_off_prepare)(void);
  52
  53 /**
  54  *      emergency_restart - reboot the system
  55  *
  56  *      Without shutting down any hardware or taking any locks
  57  *      reboot the system.  This is called when we know we are in
  58  *      trouble so this is our best effort to reboot.  This is
  59  *      safe to call in interrupt context.
  60  */
  61 void emergency_restart(void)
  62 {
  63         kmsg_dump(KMSG_DUMP_EMERG);
  64         machine_emergency_restart();
  65 }
  66 EXPORT_SYMBOL_GPL(emergency_restart);
  67
  68 void kernel_restart_prepare(char *cmd)
  69 {
  70         blocking_notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
  71         system_state = SYSTEM_RESTART;
  72         usermodehelper_disable();
  73         device_shutdown();
  74 }
  75
  76 /**
  77  *      register_reboot_notifier - Register function to be called at reboot time
  78  *      @nb: Info about notifier function to be called
  79  *
  80  *      Registers a function with the list of functions
  81  *      to be called at reboot time.
  82  *
  83  *      Currently always returns zero, as blocking_notifier_chain_register()
  84  *      always returns zero.
  85  */
  86 int register_reboot_notifier(struct notifier_block *nb)
  87 {
  88         return blocking_notifier_chain_register(&reboot_notifier_list, nb);
  89 }
  90 EXPORT_SYMBOL(register_reboot_notifier);
  91
  92 /**
  93  *      unregister_reboot_notifier - Unregister previously registered reboot notifier
  94  *      @nb: Hook to be unregistered
  95  *
  96  *      Unregisters a previously registered reboot
  97  *      notifier function.
  98  *
  99  *      Returns zero on success, or %-ENOENT on failure.
 100  */
 101 int unregister_reboot_notifier(struct notifier_block *nb)
 102 {
 103         return blocking_notifier_chain_unregister(&reboot_notifier_list, nb);
 104 }
 105 EXPORT_SYMBOL(unregister_reboot_notifier);
 106
 107 static void devm_unregister_reboot_notifier(struct device *dev, void *res)
 108 {
 109         WARN_ON(unregister_reboot_notifier(*(struct notifier_block **)res));
 110 }
 111
 112 int devm_register_reboot_notifier(struct device *dev, struct notifier_block *nb)
 113 {
 114         struct notifier_block **rcnb;
 115         int ret;
 116
 117         rcnb = devres_alloc(devm_unregister_reboot_notifier,
 118                             sizeof(*rcnb), GFP_KERNEL);
 119         if (!rcnb)
 120                 return -ENOMEM;
 121
 122         ret = register_reboot_notifier(nb);
 123         if (!ret) {
 124                 *rcnb = nb;
 125                 devres_add(dev, rcnb);
 126         } else {
 127                 devres_free(rcnb);
 128         }
 129
 130         return ret;
 131 }
 132 EXPORT_SYMBOL(devm_register_reboot_notifier);
 133
 134 /*
 135  *      Notifier list for kernel code which wants to be called
 136  *      to restart the system.
 137  */
 138 static ATOMIC_NOTIFIER_HEAD(restart_handler_list);
 139
 140 /**
 141  *      register_restart_handler - Register function to be called to reset
 142  *                                 the system
 143  *      @nb: Info about handler function to be called
 144  *      @nb->priority:  Handler priority. Handlers should follow the
 145  *                      following guidelines for setting priorities.
 146  *                      0:      Restart handler of last resort,
 147  *                              with limited restart capabilities
 148  *                      128:    Default restart handler; use if no other
 149  *                              restart handler is expected to be available,
 150  *                              and/or if restart functionality is
 151  *                              sufficient to restart the entire system
 152  *                      255:    Highest priority restart handler, will
 153  *                              preempt all other restart handlers
 154  *
 155  *      Registers a function with code to be called to restart the
 156  *      system.
 157  *
 158  *      Registered functions will be called from machine_restart as last
 159  *      step of the restart sequence (if the architecture specific
 160  *      machine_restart function calls do_kernel_restart - see below
 161  *      for details).
 162  *      Registered functions are expected to restart the system immediately.
 163  *      If more than one function is registered, the restart handler priority
 164  *      selects which function will be called first.
 165  *
 166  *      Restart handlers are expected to be registered from non-architecture
 167  *      code, typically from drivers. A typical use case would be a system
 168  *      where restart functionality is provided through a watchdog. Multiple
 169  *      restart handlers may exist; for example, one restart handler might
 170  *      restart the entire system, while another only restarts the CPU.
 171  *      In such cases, the restart handler which only restarts part of the
 172  *      hardware is expected to register with low priority to ensure that
 173  *      it only runs if no other means to restart the system is available.
 174  *
 175  *      Currently always returns zero, as atomic_notifier_chain_register()
 176  *      always returns zero.
 177  */
 178 int register_restart_handler(struct notifier_block *nb)
 179 {
 180         return atomic_notifier_chain_register(&restart_handler_list, nb);
 181 }
 182 EXPORT_SYMBOL(register_restart_handler);
 183
 184 /**
 185  *      unregister_restart_handler - Unregister previously registered
 186  *                                   restart handler
 187  *      @nb: Hook to be unregistered
 188  *
 189  *      Unregisters a previously registered restart handler function.
 190  *
 191  *      Returns zero on success, or %-ENOENT on failure.
 192  */
 193 int unregister_restart_handler(struct notifier_block *nb)
 194 {
 195         return atomic_notifier_chain_unregister(&restart_handler_list, nb);
 196 }
 197 EXPORT_SYMBOL(unregister_restart_handler);
 198
 199 /**
 200  *      do_kernel_restart - Execute kernel restart handler call chain
 201  *
 202  *      Calls functions registered with register_restart_handler.
 203  *
 204  *      Expected to be called from machine_restart as last step of the restart
 205  *      sequence.
 206  *
 207  *      Restarts the system immediately if a restart handler function has been
 208  *      registered. Otherwise does nothing.
 209  */
 210 void do_kernel_restart(char *cmd)
 211 {
 212         atomic_notifier_call_chain(&restart_handler_list, reboot_mode, cmd);
 213 }
 214
 215 void migrate_to_reboot_cpu(void)
 216 {
 217         /* The boot cpu is always logical cpu 0 */
 218         int cpu = reboot_cpu;
 219
 220         cpu_hotplug_disable();
 221
 222         /* Make certain the cpu I'm about to reboot on is online */
 223         if (!cpu_online(cpu))
 224                 cpu = cpumask_first(cpu_online_mask);
 225
 226         /* Prevent races with other tasks migrating this task */
 227         current->flags |= PF_NO_SETAFFINITY;
 228
 229         /* Make certain I only run on the appropriate processor */
 230         set_cpus_allowed_ptr(current, cpumask_of(cpu));
 231 }
 232
 233 /**
 234  *      kernel_restart - reboot the system
 235  *      @cmd: pointer to buffer containing command to execute for restart
 236  *              or %NULL
 237  *
 238  *      Shutdown everything and perform a clean reboot.
 239  *      This is not safe to call in interrupt context.
 240  */
 241 void kernel_restart(char *cmd)
 242 {
 243         kernel_restart_prepare(cmd);
 244         migrate_to_reboot_cpu();
 245         syscore_shutdown();
 246         if (!cmd)
 247                 pr_emerg("Restarting system\n");
 248         else
 249                 pr_emerg("Restarting system with command '%s'\n", cmd);
 250         kmsg_dump(KMSG_DUMP_RESTART);
 251         machine_restart(cmd);
 252 }
 253 EXPORT_SYMBOL_GPL(kernel_restart);
 254
 255 static void kernel_shutdown_prepare(enum system_states state)
 256 {
 257         blocking_notifier_call_chain(&reboot_notifier_list,
 258                 (state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL);
 259         system_state = state;
 260         usermodehelper_disable();
 261         device_shutdown();
 262 }
 263 /**
 264  *      kernel_halt - halt the system
 265  *
 266  *      Shutdown everything and perform a clean system halt.
 267  */
 268 void kernel_halt(void)
 269 {
 270         kernel_shutdown_prepare(SYSTEM_HALT);
 271         migrate_to_reboot_cpu();
 272         syscore_shutdown();
 273         pr_emerg("System halted\n");
 274         kmsg_dump(KMSG_DUMP_HALT);
 275         machine_halt();
 276 }
 277 EXPORT_SYMBOL_GPL(kernel_halt);
 278
 279 /**
 280  *      kernel_power_off - power_off the system
 281  *
 282  *      Shutdown everything and perform a clean system power_off.
 283  */
 284 void kernel_power_off(void)
 285 {
 286         kernel_shutdown_prepare(SYSTEM_POWER_OFF);
 287         if (pm_power_off_prepare)
 288                 pm_power_off_prepare();
 289         migrate_to_reboot_cpu();
 290         syscore_shutdown();
 291         pr_emerg("Power down\n");
 292         kmsg_dump(KMSG_DUMP_POWEROFF);
 293         machine_power_off();
 294 }
 295 EXPORT_SYMBOL_GPL(kernel_power_off);
 296
 297 DEFINE_MUTEX(system_transition_mutex);
 298
 299 /*
 300  * Reboot system call: for obvious reasons only root may call it,
 301  * and even root needs to set up some magic numbers in the registers
 302  * so that some mistake won't make this reboot the whole machine.
 303  * You can also set the meaning of the ctrl-alt-del-key here.
 304  *
 305  * reboot doesn't sync: do that yourself before calling this.
 306  */
 307 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd,
 308                 void __user *, arg)
 309 {
 310         struct pid_namespace *pid_ns = task_active_pid_ns(current);
 311         char buffer[256];
 312         int ret = 0;
 313
 314         /* We only trust the superuser with rebooting the system. */
 315         if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT))
 316                 return -EPERM;
 317
 318         /* For safety, we require "magic" arguments. */
 319         if (magic1 != LINUX_REBOOT_MAGIC1 ||
 320                         (magic2 != LINUX_REBOOT_MAGIC2 &&
 321                         magic2 != LINUX_REBOOT_MAGIC2A &&
 322                         magic2 != LINUX_REBOOT_MAGIC2B &&
 323                         magic2 != LINUX_REBOOT_MAGIC2C))
 324                 return -EINVAL;
 325
 326         /*
 327          * If pid namespaces are enabled and the current task is in a child
 328          * pid_namespace, the command is handled by reboot_pid_ns() which will
 329          * call do_exit().
 330          */
 331         ret = reboot_pid_ns(pid_ns, cmd);
 332         if (ret)
 333                 return ret;
 334
 335         /* Instead of trying to make the power_off code look like
 336          * halt when pm_power_off is not set do it the easy way.
 337          */
 338         if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)
 339                 cmd = LINUX_REBOOT_CMD_HALT;
 340
 341         mutex_lock(&system_transition_mutex);
 342         switch (cmd) {
 343         case LINUX_REBOOT_CMD_RESTART:
 344                 kernel_restart(NULL);
 345                 break;
 346
 347         case LINUX_REBOOT_CMD_CAD_ON:
 348                 C_A_D = 1;
 349                 break;
 350
 351         case LINUX_REBOOT_CMD_CAD_OFF:
 352                 C_A_D = 0;
 353                 break;
 354
 355         case LINUX_REBOOT_CMD_HALT:
 356                 kernel_halt();
 357                 do_exit(0);
 358                 panic("cannot halt");
 359
 360         case LINUX_REBOOT_CMD_POWER_OFF:
 361                 kernel_power_off();
 362                 do_exit(0);
 363                 break;
 364
 365         case LINUX_REBOOT_CMD_RESTART2:
 366                 ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1);
 367                 if (ret < 0) {
 368                         ret = -EFAULT;
 369                         break;
 370                 }
 371                 buffer[sizeof(buffer) - 1] = '\0';
 372
 373                 kernel_restart(buffer);
 374                 break;
 375
 376 #ifdef CONFIG_KEXEC_CORE
 377         case LINUX_REBOOT_CMD_KEXEC:
 378                 ret = kernel_kexec();
 379                 break;
 380 #endif
 381
 382 #ifdef CONFIG_HIBERNATION
 383         case LINUX_REBOOT_CMD_SW_SUSPEND:
 384                 ret = hibernate();
 385                 break;
 386 #endif
 387
 388         default:
 389                 ret = -EINVAL;
 390                 break;
 391         }
 392         mutex_unlock(&system_transition_mutex);
 393         return ret;
 394 }
 395
 396 static void deferred_cad(struct work_struct *dummy)
 397 {
 398         kernel_restart(NULL);
 399 }
 400
 401 /*
 402  * This function gets called by ctrl-alt-del - ie the keyboard interrupt.
 403  * As it's called within an interrupt, it may NOT sync: the only choice
 404  * is whether to reboot at once, or just ignore the ctrl-alt-del.
 405  */
 406 void ctrl_alt_del(void)
 407 {
 408         static DECLARE_WORK(cad_work, deferred_cad);
 409
 410         if (C_A_D)
 411                 schedule_work(&cad_work);
 412         else
 413                 kill_cad_pid(SIGINT, 1);
 414 }
 415
 416 char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff";
 417 static const char reboot_cmd[] = "/sbin/reboot";
 418
 419 static int run_cmd(const char *cmd)
 420 {
 421         char **argv;
 422         static char *envp[] = {
 423                 "HOME=/",
 424                 "PATH=/sbin:/bin:/usr/sbin:/usr/bin",
 425                 NULL
 426         };
 427         int ret;
 428         argv = argv_split(GFP_KERNEL, cmd, NULL);
 429         if (argv) {
 430                 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC);
 431                 argv_free(argv);
 432         } else {
 433                 ret = -ENOMEM;
 434         }
 435
 436         return ret;
 437 }
 438
 439 static int __orderly_reboot(void)
 440 {
 441         int ret;
 442
 443         ret = run_cmd(reboot_cmd);
 444
 445         if (ret) {
 446                 pr_warn("Failed to start orderly reboot: forcing the issue\n");
 447                 emergency_sync();
 448                 kernel_restart(NULL);
 449         }
 450
 451         return ret;
 452 }
 453
 454 static int __orderly_poweroff(bool force)
 455 {
 456         int ret;
 457
 458         ret = run_cmd(poweroff_cmd);
 459
 460         if (ret && force) {
 461                 pr_warn("Failed to start orderly shutdown: forcing the issue\n");
 462
 463                 /*
 464                  * I guess this should try to kick off some daemon to sync and
 465                  * poweroff asap.  Or not even bother syncing if we're doing an
 466                  * emergency shutdown?
 467                  */
 468                 emergency_sync();
 469                 kernel_power_off();
 470         }
 471
 472         return ret;
 473 }
 474
 475 static bool poweroff_force;
 476
 477 static void poweroff_work_func(struct work_struct *work)
 478 {
 479         __orderly_poweroff(poweroff_force);
 480 }
 481
 482 static DECLARE_WORK(poweroff_work, poweroff_work_func);
 483
 484 /**
 485  * orderly_poweroff - Trigger an orderly system poweroff
 486  * @force: force poweroff if command execution fails
 487  *
 488  * This may be called from any context to trigger a system shutdown.
 489  * If the orderly shutdown fails, it will force an immediate shutdown.
 490  */
 491 void orderly_poweroff(bool force)
 492 {
 493         if (force) /* do not override the pending "true" */
 494                 poweroff_force = true;
 495         schedule_work(&poweroff_work);
 496 }
 497 EXPORT_SYMBOL_GPL(orderly_poweroff);
 498
 499 static void reboot_work_func(struct work_struct *work)
 500 {
 501         __orderly_reboot();
 502 }
 503
 504 static DECLARE_WORK(reboot_work, reboot_work_func);
 505
 506 /**
 507  * orderly_reboot - Trigger an orderly system reboot
 508  *
 509  * This may be called from any context to trigger a system reboot.
 510  * If the orderly reboot fails, it will force an immediate reboot.
 511  */
 512 void orderly_reboot(void)
 513 {
 514         schedule_work(&reboot_work);
 515 }
 516 EXPORT_SYMBOL_GPL(orderly_reboot);
 517
 518 static int __init reboot_setup(char *str)
 519 {
 520         for (;;) {
 521                 /*
 522                  * Having anything passed on the command line via
 523                  * reboot= will cause us to disable DMI checking
 524                  * below.
 525                  */
 526                 reboot_default = 0;
 527
 528                 switch (*str) {
 529                 case 'w':
 530                         reboot_mode = REBOOT_WARM;
 531                         break;
 532
 533                 case 'c':
 534                         reboot_mode = REBOOT_COLD;
 535                         break;
 536
 537                 case 'h':
 538                         reboot_mode = REBOOT_HARD;
 539                         break;
 540
 541                 case 's':
 542                 {
 543                         int rc;
 544
 545                         if (isdigit(*(str+1))) {
 546                                 rc = kstrtoint(str+1, 0, &reboot_cpu);
 547                                 if (rc)
 548                                         return rc;
 549                         } else if (str[1] == 'm' && str[2] == 'p' &&
 550                                    isdigit(*(str+3))) {
 551                                 rc = kstrtoint(str+3, 0, &reboot_cpu);
 552                                 if (rc)
 553                                         return rc;
 554                         } else
 555                                 reboot_mode = REBOOT_SOFT;
 556                         break;
 557                 }
 558                 case 'g':
 559                         reboot_mode = REBOOT_GPIO;
 560                         break;
 561
 562                 case 'b':
 563                 case 'a':
 564                 case 'k':
 565                 case 't':
 566                 case 'e':
 567                 case 'p':
 568                         reboot_type = *str;
 569                         break;
 570
 571                 case 'f':
 572                         reboot_force = 1;
 573                         break;
 574                 }
 575
 576                 str = strchr(str, ',');
 577                 if (str)
 578                         str++;
 579                 else
 580                         break;
 581         }
 582         return 1;
 583 }
 584 __setup("reboot=", reboot_setup);