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