Attachment #53919 for bug #118997

View | Details | Raw Unified | Return to bug 118997
Collapse All | Expand All

Lines 59-64 Link Here

(-)linux-2.6.13/include/linux/reboot.h (+4 lines)
59	* Architecture independent implemenations of sys_reboot commands.	59	* Architecture independent implemenations of sys_reboot commands.
60	*/	60	*/
61		61
		62	extern void kernel_restart_prepare(char *cmd);
		63	extern void kernel_halt_prepare(void);
		64	extern void kernel_power_off_prepare(void);
		65
62	extern void kernel_restart(char *cmd);	66	extern void kernel_restart(char *cmd);
63	extern void kernel_halt(void);	67	extern void kernel_halt(void);
64	extern void kernel_power_off(void);	68	extern void kernel_power_off(void);




	return retval;
}

/**
 * emergency_restart - reboot the system
 *
 * Without shutting down any hardware or taking any locks
 * reboot the system.  This is called when we know we are in
 * trouble so this is our best effort to reboot.  This is
 * safe to call in interrupt context.
 */

void emergency_restart(void)
{
	machine_emergency_restart();
}
EXPORT_SYMBOL_GPL(emergency_restart);

/**
 * kernel_restart - reboot the system
 *
 * Shutdown everything and perform a clean reboot.
 * This is not safe to call in interrupt context.
 */
void kernel_restart_prepare(char *cmd)
{
	notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
	system_state = SYSTEM_RESTART;
	device_shutdown();
}
void kernel_restart(char *cmd)
{
	kernel_restart_prepare(cmd);
	if (!cmd) {
		printk(KERN_EMERG "Restarting system.\n");
	} else {

}
EXPORT_SYMBOL_GPL(kernel_restart);

/**
 * kernel_kexec - reboot the system
 *
 * Move into place and start executing a preloaded standalone
 * executable.  If nothing was preloaded return an error.
 */
void kernel_kexec(void)
{
#ifdef CONFIG_KEXEC

	if (!image) {
		return;
	}
	kernel_restart_prepare(NULL);
	system_state = SYSTEM_RESTART;
	device_shutdown();
	printk(KERN_EMERG "Starting new kernel\n");
	machine_shutdown();
	machine_kexec(image);

}
EXPORT_SYMBOL_GPL(kernel_kexec);

/**
 * kernel_halt - halt the system
 *
 * Shutdown everything and perform a clean system halt.
 */
void kernel_halt_prepare(void)
{
	notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);
	system_state = SYSTEM_HALT;
	device_shutdown();
}
void kernel_halt(void)
{
   kernel_halt_prepare();
	printk(KERN_EMERG "System halted.\n");
	machine_halt();
}
EXPORT_SYMBOL_GPL(kernel_halt);

/**
 * kernel_power_off - power_off the system
 *
 * Shutdown everything and perform a clean system power_off.
 */
void kernel_power_off_prepare(void)
{
	notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);
	system_state = SYSTEM_POWER_OFF;
	device_shutdown();
}
void kernel_power_off(void)
{
	kernel_power_off_prepare();
	printk(KERN_EMERG "Power down.\n");
	machine_power_off();
}




#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/pm.h>

#include "power.h"


extern suspend_disk_method_t pm_disk_mode;
extern struct pm_ops * pm_ops;

extern int swsusp_suspend(void);
extern int swsusp_write(void);


static void power_down(suspend_disk_method_t mode)
{
	unsigned long flags;
	int error = 0;

	local_irq_save(flags);
	switch(mode) {
	case PM_DISK_PLATFORM:
		kernel_power_off_prepare();
		error = pm_ops->enter(PM_SUSPEND_DISK);
		break;
	case PM_DISK_SHUTDOWN:

Return to bug 118997

Lines 361-377 Link Here

(-)linux-2.6.13/kernel/sys.c (-6 / +47 lines)
361	return retval;	361	return retval;
362	}	362	}
363		363
		364	/**
		365	* emergency_restart - reboot the system
		366	*
		367	* Without shutting down any hardware or taking any locks
		368	* reboot the system. This is called when we know we are in
		369	* trouble so this is our best effort to reboot. This is
		370	* safe to call in interrupt context.
		371	*/
		372
364	void emergency_restart(void)	373	void emergency_restart(void)
365	{	374	{
366	machine_emergency_restart();	375	machine_emergency_restart();
367	}	376	}
368	EXPORT_SYMBOL_GPL(emergency_restart);	377	EXPORT_SYMBOL_GPL(emergency_restart);
369		378
370	void kernel_restart(char *cmd)	379	/**
		380	* kernel_restart - reboot the system
		381	*
		382	* Shutdown everything and perform a clean reboot.
		383	* This is not safe to call in interrupt context.
		384	*/
		385	void kernel_restart_prepare(char *cmd)
371	{	386	{
372	notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);	387	notifier_call_chain(&reboot_notifier_list, SYS_RESTART, cmd);
373	system_state = SYSTEM_RESTART;	388	system_state = SYSTEM_RESTART;
374	device_shutdown();	389	device_shutdown();
		390	}
		391	void kernel_restart(char *cmd)
		392	{
		393	kernel_restart_prepare(cmd);
375	if (!cmd) {	394	if (!cmd) {
376	printk(KERN_EMERG "Restarting system.\n");	395	printk(KERN_EMERG "Restarting system.\n");
377	} else {	396	} else {
Lines 382-387 Link Here
382	}	401	}
383	EXPORT_SYMBOL_GPL(kernel_restart);	402	EXPORT_SYMBOL_GPL(kernel_restart);
384		403
		404	/**
		405	* kernel_kexec - reboot the system
		406	*
		407	* Move into place and start executing a preloaded standalone
		408	* executable. If nothing was preloaded return an error.
		409	*/
385	void kernel_kexec(void)	410	void kernel_kexec(void)
386	{	411	{
387	#ifdef CONFIG_KEXEC	412	#ifdef CONFIG_KEXEC
Lines 390-398 Link Here
390	if (!image) {	415	if (!image) {
391	return;	416	return;
392	}	417	}
393	notifier_call_chain(&reboot_notifier_list, SYS_RESTART, NULL);	418	kernel_restart_prepare(NULL);
394	system_state = SYSTEM_RESTART;
395	device_shutdown();
396	printk(KERN_EMERG "Starting new kernel\n");	419	printk(KERN_EMERG "Starting new kernel\n");
397	machine_shutdown();	420	machine_shutdown();
398	machine_kexec(image);	421	machine_kexec(image);
Lines 400-420 Link Here
400	}	423	}
401	EXPORT_SYMBOL_GPL(kernel_kexec);	424	EXPORT_SYMBOL_GPL(kernel_kexec);
402		425
403	void kernel_halt(void)	426	/**
		427	* kernel_halt - halt the system
		428	*
		429	* Shutdown everything and perform a clean system halt.
		430	*/
		431	void kernel_halt_prepare(void)
404	{	432	{
405	notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);	433	notifier_call_chain(&reboot_notifier_list, SYS_HALT, NULL);
406	system_state = SYSTEM_HALT;	434	system_state = SYSTEM_HALT;
407	device_shutdown();	435	device_shutdown();
		436	}
		437	void kernel_halt(void)
		438	{
		439	kernel_halt_prepare();
408	printk(KERN_EMERG "System halted.\n");	440	printk(KERN_EMERG "System halted.\n");
409	machine_halt();	441	machine_halt();
410	}	442	}
411	EXPORT_SYMBOL_GPL(kernel_halt);	443	EXPORT_SYMBOL_GPL(kernel_halt);
412		444
413	void kernel_power_off(void)	445	/**
		446	* kernel_power_off - power_off the system
		447	*
		448	* Shutdown everything and perform a clean system power_off.
		449	*/
		450	void kernel_power_off_prepare(void)
414	{	451	{
415	notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);	452	notifier_call_chain(&reboot_notifier_list, SYS_POWER_OFF, NULL);
416	system_state = SYSTEM_POWER_OFF;	453	system_state = SYSTEM_POWER_OFF;
417	device_shutdown();	454	device_shutdown();
		455	}
		456	void kernel_power_off(void)
		457	{
		458	kernel_power_off_prepare();
418	printk(KERN_EMERG "Power down.\n");	459	printk(KERN_EMERG "Power down.\n");
419	machine_power_off();	460	machine_power_off();
420	}	461	}

Lines 17-28 Link Here

(-)linux-2.6.13/kernel/power/disk.c (-4 / +2 lines)
17	#include <linux/delay.h>	17	#include <linux/delay.h>
18	#include <linux/fs.h>	18	#include <linux/fs.h>
19	#include <linux/mount.h>	19	#include <linux/mount.h>
		20	#include <linux/pm.h>
20		21
21	#include "power.h"	22	#include "power.h"
22		23
23		24
24	extern suspend_disk_method_t pm_disk_mode;	25	extern suspend_disk_method_t pm_disk_mode;
25	extern struct pm_ops * pm_ops;
26		26
27	extern int swsusp_suspend(void);	27	extern int swsusp_suspend(void);
28	extern int swsusp_write(void);	28	extern int swsusp_write(void);
Lines 49-61 Link Here
49		49
50	static void power_down(suspend_disk_method_t mode)	50	static void power_down(suspend_disk_method_t mode)
51	{	51	{
52	unsigned long flags;
53	int error = 0;	52	int error = 0;
54		53
55	local_irq_save(flags);
56	switch(mode) {	54	switch(mode) {
57	case PM_DISK_PLATFORM:	55	case PM_DISK_PLATFORM:
58	device_shutdown();	56	kernel_power_off_prepare();
59	error = pm_ops->enter(PM_SUSPEND_DISK);	57	error = pm_ops->enter(PM_SUSPEND_DISK);
60	break;	58	break;
61	case PM_DISK_SHUTDOWN:	59	case PM_DISK_SHUTDOWN: