[ms2-kexec] / sys.c

/*
 *  linux/kernel/sys.c
 *
 *  Copyright (C) 1991, 1992  Linus Torvalds
 */

#include <linux/module.h>
#include <linux/mm.h>
#include <linux/utsname.h>
#include <linux/mman.h>
#include <linux/smp_lock.h>
#include <linux/notifier.h>
#include <linux/reboot.h>
#include <linux/prctl.h>
#include <linux/highuid.h>
#include <linux/fs.h>
#include <linux/resource.h>
#include <linux/kernel.h>
#include <linux/kexec.h>
#include <linux/workqueue.h>
#include <linux/capability.h>
#include <linux/device.h>
#include <linux/key.h>
#include <linux/times.h>
#include <linux/posix-timers.h>
#include <linux/security.h>
#include <linux/dcookies.h>
#include <linux/suspend.h>
#include <linux/tty.h>
#include <linux/signal.h>
#include <linux/cn_proc.h>
#include <linux/getcpu.h>
#include <linux/task_io_accounting_ops.h>
#include <linux/seccomp.h>
#include <linux/cpu.h>
#include <linux/ptrace.h>

#include <linux/compat.h>
#include <linux/syscalls.h>
#include <linux/kprobes.h>
#include <linux/user_namespace.h>

#include <asm/uaccess.h>
#include <asm/io.h>
#include <asm/unistd.h>

extern asmlinkage long (*original_reboot)(int magic1, int magic2, unsigned int cmd, void __user *arg);

#if 0
static struct notifier_block dummy_notifier_reboot = {
         .notifier_call  = NULL,
         .next           = NULL,
         .priority       = INT_MAX
};

BLOCKING_NOTIFIER_HEAD(notifier_head);
#endif


void kernel_restart_prepare(char *cmd)
{
#warning assuming kernel_restart_prepare is at 0xc00779cc
	void (*original_kernel_restart_prepare)(char *) = (void (*)(char *))0xc00779cc;
	return original_kernel_restart_prepare(cmd);
#if 0
	register_reboot_notifier(&dummy_notifier_reboot);
	notifier_head.head=dummy_notifier_reboot.next;
	unregister_reboot_notifier(&dummy_notifier_reboot);

	blocking_notifier_call_chain(&notifier_head, SYS_RESTART, cmd);
	system_state = SYSTEM_RESTART;
	//device_shutdown();
	//sysdev_shutdown();
#endif
}

/*
 * Reboot system call: for obvious reasons only root may call it,
 * and even root needs to set up some magic numbers in the registers
 * so that some mistake won't make this reboot the whole machine.
 * You can also set the meaning of the ctrl-alt-del-key here.
 *
 * reboot doesn't sync: do that yourself before calling this.
 */
asmlinkage long reboot(int magic1, int magic2, unsigned int cmd, void __user *arg)
{
	int ret;
	if(cmd==LINUX_REBOOT_CMD_KEXEC) {
		/* We only trust the superuser with rebooting the system. */
		if (!capable(CAP_SYS_BOOT))
			return -EPERM;

		/* For safety, we require "magic" arguments. */
		if (magic1 != LINUX_REBOOT_MAGIC1 ||
		    (magic2 != LINUX_REBOOT_MAGIC2 &&
		                magic2 != LINUX_REBOOT_MAGIC2A &&
				magic2 != LINUX_REBOOT_MAGIC2B &&
		                magic2 != LINUX_REBOOT_MAGIC2C))
			return -EINVAL;

		lock_kernel();
		ret = kernel_kexec();
		unlock_kernel();
		return ret;
	} else {
		return original_reboot(magic1, magic2, cmd, arg);
	}
}
Commit	Line	Data
4e93cb00 MG	1	/*
	2	* linux/kernel/sys.c
	3	*
	4	* Copyright (C) 1991, 1992 Linus Torvalds
	5	*/
	6
	7	#include <linux/module.h>
	8	#include <linux/mm.h>
	9	#include <linux/utsname.h>
	10	#include <linux/mman.h>
	11	#include <linux/smp_lock.h>
	12	#include <linux/notifier.h>
	13	#include <linux/reboot.h>
	14	#include <linux/prctl.h>
	15	#include <linux/highuid.h>
	16	#include <linux/fs.h>
	17	#include <linux/resource.h>
	18	#include <linux/kernel.h>
	19	#include <linux/kexec.h>
	20	#include <linux/workqueue.h>
	21	#include <linux/capability.h>
	22	#include <linux/device.h>
	23	#include <linux/key.h>
	24	#include <linux/times.h>
	25	#include <linux/posix-timers.h>
	26	#include <linux/security.h>
	27	#include <linux/dcookies.h>
	28	#include <linux/suspend.h>
	29	#include <linux/tty.h>
	30	#include <linux/signal.h>
	31	#include <linux/cn_proc.h>
	32	#include <linux/getcpu.h>
	33	#include <linux/task_io_accounting_ops.h>
	34	#include <linux/seccomp.h>
	35	#include <linux/cpu.h>
	36	#include <linux/ptrace.h>
	37
	38	#include <linux/compat.h>
	39	#include <linux/syscalls.h>
	40	#include <linux/kprobes.h>
	41	#include <linux/user_namespace.h>
	42
	43	#include <asm/uaccess.h>
	44	#include <asm/io.h>
	45	#include <asm/unistd.h>
	46
	47	extern asmlinkage long (original_reboot)(int magic1, int magic2, unsigned int cmd, void __user arg);
	48
4f5f5319	49	#if 0
a16260b8 MG	50	static struct notifier_block dummy_notifier_reboot = {
	51	.notifier_call = NULL,
	52	.next = NULL,
	53	.priority = INT_MAX
	54	};
	55
	56	BLOCKING_NOTIFIER_HEAD(notifier_head);
4f5f5319	57	#endif
a16260b8 MG	58
a16260b8 MG	59
4e93cb00 MG	60	void kernel_restart_prepare(char *cmd)
4e93cb00 MG	61	{
4f5f5319 MG	62	#warning assuming kernel_restart_prepare is at 0xc00779cc
	63	void (original_kernel_restart_prepare)(char ) = (void ()(char ))0xc00779cc;
	64	return original_kernel_restart_prepare(cmd);
	65	#if 0
a16260b8 MG	66	register_reboot_notifier(&dummy_notifier_reboot);
	67	notifier_head.head=dummy_notifier_reboot.next;
	68	unregister_reboot_notifier(&dummy_notifier_reboot);
	69
	70	blocking_notifier_call_chain(&notifier_head, SYS_RESTART, cmd);
	71	system_state = SYSTEM_RESTART;
1109a23f MG	72	//device_shutdown();
1109a23f MG	73	//sysdev_shutdown();
4f5f5319	74	#endif
4e93cb00 MG	75	}
	76
	77	/*
	78	* Reboot system call: for obvious reasons only root may call it,
	79	* and even root needs to set up some magic numbers in the registers
	80	* so that some mistake won't make this reboot the whole machine.
	81	* You can also set the meaning of the ctrl-alt-del-key here.
	82	*
	83	* reboot doesn't sync: do that yourself before calling this.
	84	*/
	85	asmlinkage long reboot(int magic1, int magic2, unsigned int cmd, void __user *arg)
	86	{
	87	int ret;
	88	if(cmd==LINUX_REBOOT_CMD_KEXEC) {
	89	/* We only trust the superuser with rebooting the system. */
	90	if (!capable(CAP_SYS_BOOT))
	91	return -EPERM;
	92
	93	/* For safety, we require "magic" arguments. */
	94	if (magic1 != LINUX_REBOOT_MAGIC1 \|\|
	95	(magic2 != LINUX_REBOOT_MAGIC2 &&
	96	magic2 != LINUX_REBOOT_MAGIC2A &&
	97	magic2 != LINUX_REBOOT_MAGIC2B &&
	98	magic2 != LINUX_REBOOT_MAGIC2C))
	99	return -EINVAL;
	100
	101	lock_kernel();
	102	ret = kernel_kexec();
	103	unlock_kernel();
	104	return ret;
	105	} else {
	106	return original_reboot(magic1, magic2, cmd, arg);
	107	}
	108	}