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 void migrate_to_reboot_cpu(void) 108 { 109 /* The boot cpu is always logical cpu 0 */ 110 int cpu = reboot_cpu; 111 112 cpu_hotplug_disable(); 113 114 /* Make certain the cpu I'm about to reboot on is online */ 115 if (!cpu_online(cpu)) 116 cpu = cpumask_first(cpu_online_mask); 117 118 /* Prevent races with other tasks migrating this task */ 119 current->flags |= PF_NO_SETAFFINITY; 120 121 /* Make certain I only run on the appropriate processor */ 122 set_cpus_allowed_ptr(current, cpumask_of(cpu)); 123 } 124 125 /** 126 * kernel_restart - reboot the system 127 * @cmd: pointer to buffer containing command to execute for restart 128 * or %NULL 129 * 130 * Shutdown everything and perform a clean reboot. 131 * This is not safe to call in interrupt context. 132 */ 133 void kernel_restart(char *cmd) 134 { 135 kernel_restart_prepare(cmd); 136 migrate_to_reboot_cpu(); 137 syscore_shutdown(); 138 if (!cmd) 139 pr_emerg("Restarting system\n"); 140 else 141 pr_emerg("Restarting system with command '%s'\n", cmd); 142 kmsg_dump(KMSG_DUMP_RESTART); 143 machine_restart(cmd); 144 } 145 EXPORT_SYMBOL_GPL(kernel_restart); 146 147 static void kernel_shutdown_prepare(enum system_states state) 148 { 149 blocking_notifier_call_chain(&reboot_notifier_list, 150 (state == SYSTEM_HALT) ? SYS_HALT : SYS_POWER_OFF, NULL); 151 system_state = state; 152 usermodehelper_disable(); 153 device_shutdown(); 154 } 155 /** 156 * kernel_halt - halt the system 157 * 158 * Shutdown everything and perform a clean system halt. 159 */ 160 void kernel_halt(void) 161 { 162 kernel_shutdown_prepare(SYSTEM_HALT); 163 migrate_to_reboot_cpu(); 164 syscore_shutdown(); 165 pr_emerg("System halted\n"); 166 kmsg_dump(KMSG_DUMP_HALT); 167 machine_halt(); 168 } 169 EXPORT_SYMBOL_GPL(kernel_halt); 170 171 /** 172 * kernel_power_off - power_off the system 173 * 174 * Shutdown everything and perform a clean system power_off. 175 */ 176 void kernel_power_off(void) 177 { 178 kernel_shutdown_prepare(SYSTEM_POWER_OFF); 179 if (pm_power_off_prepare) 180 pm_power_off_prepare(); 181 migrate_to_reboot_cpu(); 182 syscore_shutdown(); 183 pr_emerg("Power down\n"); 184 kmsg_dump(KMSG_DUMP_POWEROFF); 185 machine_power_off(); 186 } 187 EXPORT_SYMBOL_GPL(kernel_power_off); 188 189 static DEFINE_MUTEX(reboot_mutex); 190 191 /* 192 * Reboot system call: for obvious reasons only root may call it, 193 * and even root needs to set up some magic numbers in the registers 194 * so that some mistake won't make this reboot the whole machine. 195 * You can also set the meaning of the ctrl-alt-del-key here. 196 * 197 * reboot doesn't sync: do that yourself before calling this. 198 */ 199 SYSCALL_DEFINE4(reboot, int, magic1, int, magic2, unsigned int, cmd, 200 void __user *, arg) 201 { 202 struct pid_namespace *pid_ns = task_active_pid_ns(current); 203 char buffer[256]; 204 int ret = 0; 205 206 /* We only trust the superuser with rebooting the system. */ 207 if (!ns_capable(pid_ns->user_ns, CAP_SYS_BOOT)) 208 return -EPERM; 209 210 /* For safety, we require "magic" arguments. */ 211 if (magic1 != LINUX_REBOOT_MAGIC1 || 212 (magic2 != LINUX_REBOOT_MAGIC2 && 213 magic2 != LINUX_REBOOT_MAGIC2A && 214 magic2 != LINUX_REBOOT_MAGIC2B && 215 magic2 != LINUX_REBOOT_MAGIC2C)) 216 return -EINVAL; 217 218 /* 219 * If pid namespaces are enabled and the current task is in a child 220 * pid_namespace, the command is handled by reboot_pid_ns() which will 221 * call do_exit(). 222 */ 223 ret = reboot_pid_ns(pid_ns, cmd); 224 if (ret) 225 return ret; 226 227 /* Instead of trying to make the power_off code look like 228 * halt when pm_power_off is not set do it the easy way. 229 */ 230 if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off) 231 cmd = LINUX_REBOOT_CMD_HALT; 232 233 mutex_lock(&reboot_mutex); 234 switch (cmd) { 235 case LINUX_REBOOT_CMD_RESTART: 236 kernel_restart(NULL); 237 break; 238 239 case LINUX_REBOOT_CMD_CAD_ON: 240 C_A_D = 1; 241 break; 242 243 case LINUX_REBOOT_CMD_CAD_OFF: 244 C_A_D = 0; 245 break; 246 247 case LINUX_REBOOT_CMD_HALT: 248 kernel_halt(); 249 do_exit(0); 250 panic("cannot halt"); 251 252 case LINUX_REBOOT_CMD_POWER_OFF: 253 kernel_power_off(); 254 do_exit(0); 255 break; 256 257 case LINUX_REBOOT_CMD_RESTART2: 258 ret = strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1); 259 if (ret < 0) { 260 ret = -EFAULT; 261 break; 262 } 263 buffer[sizeof(buffer) - 1] = '\0'; 264 265 kernel_restart(buffer); 266 break; 267 268 #ifdef CONFIG_KEXEC 269 case LINUX_REBOOT_CMD_KEXEC: 270 ret = kernel_kexec(); 271 break; 272 #endif 273 274 #ifdef CONFIG_HIBERNATION 275 case LINUX_REBOOT_CMD_SW_SUSPEND: 276 ret = hibernate(); 277 break; 278 #endif 279 280 default: 281 ret = -EINVAL; 282 break; 283 } 284 mutex_unlock(&reboot_mutex); 285 return ret; 286 } 287 288 static void deferred_cad(struct work_struct *dummy) 289 { 290 kernel_restart(NULL); 291 } 292 293 /* 294 * This function gets called by ctrl-alt-del - ie the keyboard interrupt. 295 * As it's called within an interrupt, it may NOT sync: the only choice 296 * is whether to reboot at once, or just ignore the ctrl-alt-del. 297 */ 298 void ctrl_alt_del(void) 299 { 300 static DECLARE_WORK(cad_work, deferred_cad); 301 302 if (C_A_D) 303 schedule_work(&cad_work); 304 else 305 kill_cad_pid(SIGINT, 1); 306 } 307 308 char poweroff_cmd[POWEROFF_CMD_PATH_LEN] = "/sbin/poweroff"; 309 310 static int __orderly_poweroff(bool force) 311 { 312 char **argv; 313 static char *envp[] = { 314 "HOME=/", 315 "PATH=/sbin:/bin:/usr/sbin:/usr/bin", 316 NULL 317 }; 318 int ret; 319 320 argv = argv_split(GFP_KERNEL, poweroff_cmd, NULL); 321 if (argv) { 322 ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_EXEC); 323 argv_free(argv); 324 } else { 325 ret = -ENOMEM; 326 } 327 328 if (ret && force) { 329 pr_warn("Failed to start orderly shutdown: forcing the issue\n"); 330 /* 331 * I guess this should try to kick off some daemon to sync and 332 * poweroff asap. Or not even bother syncing if we're doing an 333 * emergency shutdown? 334 */ 335 emergency_sync(); 336 kernel_power_off(); 337 } 338 339 return ret; 340 } 341 342 static bool poweroff_force; 343 344 static void poweroff_work_func(struct work_struct *work) 345 { 346 __orderly_poweroff(poweroff_force); 347 } 348 349 static DECLARE_WORK(poweroff_work, poweroff_work_func); 350 351 /** 352 * orderly_poweroff - Trigger an orderly system poweroff 353 * @force: force poweroff if command execution fails 354 * 355 * This may be called from any context to trigger a system shutdown. 356 * If the orderly shutdown fails, it will force an immediate shutdown. 357 */ 358 int orderly_poweroff(bool force) 359 { 360 if (force) /* do not override the pending "true" */ 361 poweroff_force = true; 362 schedule_work(&poweroff_work); 363 return 0; 364 } 365 EXPORT_SYMBOL_GPL(orderly_poweroff); 366 367 static int __init reboot_setup(char *str) 368 { 369 for (;;) { 370 /* 371 * Having anything passed on the command line via 372 * reboot= will cause us to disable DMI checking 373 * below. 374 */ 375 reboot_default = 0; 376 377 switch (*str) { 378 case 'w': 379 reboot_mode = REBOOT_WARM; 380 break; 381 382 case 'c': 383 reboot_mode = REBOOT_COLD; 384 break; 385 386 case 'h': 387 reboot_mode = REBOOT_HARD; 388 break; 389 390 case 's': 391 { 392 int rc; 393 394 if (isdigit(*(str+1))) { 395 rc = kstrtoint(str+1, 0, &reboot_cpu); 396 if (rc) 397 return rc; 398 } else if (str[1] == 'm' && str[2] == 'p' && 399 isdigit(*(str+3))) { 400 rc = kstrtoint(str+3, 0, &reboot_cpu); 401 if (rc) 402 return rc; 403 } else 404 reboot_mode = REBOOT_SOFT; 405 break; 406 } 407 case 'g': 408 reboot_mode = REBOOT_GPIO; 409 break; 410 411 case 'b': 412 case 'a': 413 case 'k': 414 case 't': 415 case 'e': 416 case 'p': 417 reboot_type = *str; 418 break; 419 420 case 'f': 421 reboot_force = 1; 422 break; 423 } 424 425 str = strchr(str, ','); 426 if (str) 427 str++; 428 else 429 break; 430 } 431 return 1; 432 } 433 __setup("reboot=", reboot_setup); 434