diff -wurN -X dontdiff linux-2.2.18/CREDITS linux-2.2.18-swsusp/CREDITS
--- linux-2.2.18/CREDITS	Mon Dec 11 00:49:40 2000
+++ linux-2.2.18-swsusp/CREDITS	Fri Jan 26 04:10:30 2001
@@ -1229,6 +1229,11 @@
 S: D-91080 Uttenreuth
 S: Germany
 
+N: Gabor Kuti
+E: seasons@falcon.sch.bme.hu
+E: (seasons@makosteszta.sote.hu)
+D: Author and Maintainer for Software Suspend
+
 N: Jaroslav Kysela
 E: perex@jcu.cz
 W: http://www.pf.jcu.cz/~perex
diff -wurN -X dontdiff linux-2.2.18/Documentation/Configure.help linux-2.2.18-swsusp/Documentation/Configure.help
--- linux-2.2.18/Documentation/Configure.help	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/Documentation/Configure.help	Fri Jan 26 04:11:14 2001
@@ -10298,6 +10298,58 @@
   a work-around for a number of buggy BIOSes. Switch this option on if
   your computer crashes instead of powering off properly.
 
+Software Suspend
+CONFIG_SOFTWARE_SUSPEND
+  Enable the possibilty of suspendig machine. It doesn't need APM.
+  You may suspend your machine by either pressing Sysrq-d or with
+  'swsusp' or 'shutdown -z <time>' (patch for sysvinit needed). It
+  creates an image which is saved in your active swaps. By the next
+  booting the kernel detects the saved image, restores the memory from
+  it and then it continues to run as before you've suspended.
+  If you don't want the previous state to continue use the 'noresume'
+  kernel option. However note that your partitions will be fsck'd and
+  you must re-mkswap your swap partitions/files.
+
+  Right now you may boot without resuming and then later resume but
+  in meantime you cannot use those swap partitions/files which were
+  involved in suspending. Also in this case there is a risk that buffers
+  on disk won't match with saved ones.
+
+  SMP is supported ``as-is''. There's a code for it but doesn't work.
+  There have been problems reported relating SCSI.
+  
+  Also, this had a _maybe_ fixed bug where by resuming kflushd oopses
+  when kernel has been compiled with egcs. Reports about this are
+  welcome.
+
+  Users: Without the problems listed in swsusp.tex this problem should
+  work without any problem.
+  Hackers: patches are welcome.
+
+  This option is about getting stable. However there are still some
+  absence of features.
+
+  For more information take a look at Documentation/swsusp.tex.
+
+Support hardware state restore
+CONFIG_HWSTATE_RESTORE
+  If you say Y here then the suspend will attempt to restore the state
+  of your hardware devices. Although it needs more improvement since it
+  supports only the restoring of serial ports, RTC, screen and network
+  devices. It also wakes up init what calls 'resume' entries from
+  `/etc/inittab'. This way you may specify userland programs what can
+  restore hardware states the kernel cannot (for example svgatextmode
+  and hdparm).
+
+  Also, if you have APM support enabled, a resume event will be sent
+  to all APM-registered processes (for example, apmd)
+
+Override APM suspend events
+CONFIG_SWSUSP_OVERRIDE_APM
+  If you say Y here whenever the APM driver tries to suspend, the
+  software suspend function will be used instead. This is useful if
+  your APM bios is broken.
+
 Watchdog Timer Support 
 CONFIG_WATCHDOG
   If you say Y here (and to one of the following options) and create a
diff -wurN -X dontdiff linux-2.2.18/Documentation/swsusp.tex linux-2.2.18-swsusp/Documentation/swsusp.tex
--- linux-2.2.18/Documentation/swsusp.tex	Thu Jan  1 01:00:00 1970
+++ linux-2.2.18-swsusp/Documentation/swsusp.tex	Fri Dec 29 03:49:17 2000
@@ -0,0 +1,150 @@
+\documentclass[a4paper,12pt]{article}
+\newcommand{\config}{{\tt}}
+\newcommand{\url}{\it}
+\rm
+\begin{document}
+\title{Article about goals and implementation of Software Suspend for Linux}
+\author{Author: G\'abor Kuti}
+\date{Last revised: Jan 23rd, 2000}
+\maketitle
+
+\section{Idea and goals to achieve}
+Nowadays it is common in several laptops that they have a suspend button. It
+saves the state of the machine to a filesystem or to a partition and switches
+to standby mode. Later resuming the machine the saved state is loaded back to
+ram and the machine can continue its work. It has two real benefits. First we
+save ourselves the time machine goes down and later boots up, energy costs
+real high when running from batteries. The other gain is that we don't have to
+interrupt our programs so processes that are calculating something for a long
+time shouldn't need to be written interruptible.
+
+On desk machines the power saving function isn't as important as it is in
+laptops but we really may benefit from the second one. Nowadays the number of
+desk machines supporting suspend function in their APM is going up but there
+are (and there will still be for a long time) machines that don't even support
+APM of any kind. On the other hand it is reported that using APM's suspend
+some irqs (e.g. ATA disk irq) is lost and it is annoying for the user until
+the Linux kernel resets the device.
+
+So I started thinking about implementing Software Suspend which doesn't need
+any APM support and - since it uses pretty near only high-level routines - is
+supposed to be architecture independent code.
+
+\section{Using the code}
+The code is experimental right now - testers, extra eyes are welcome. To
+compile this support into the kernel, you need \config{CONFIG\_EXPERIMENTAL}, 
+and then \config{CONFIG\_SOFTWARE\_SUSPEND} in menu {\bf General Setup} to be 
+enabled. It cannot be used as a module and I don't think it will ever be 
+needed.
+
+You have two ways to use this code. The first one is if you've compiled in
+sysrq support then you may press Sysrq-D to request suspend. The other way
+is with a patched SysVinit (my patch is against 2.76 and available at my
+home page). You might call 'swsusp' or 'shutdown -z <time>'.
+
+Either way it saves the state of the machine into active swaps and then
+reboots. By the next booting the kernel's resuming function is either
+triggered by swapon -a (which is ought to be in the very early stage of
+booting) or you may explicitly specify the swap partition/file to resume
+from with ``resume='' kernel option. If signature is found it loads and
+restores saved state. If the option ``noresume'' is specified as a boot
+parameter, it skips the resuming. {\bf Warning!} Look at section
+``Things to implement'' to see what {\it isn't} yet implemented.
+Also I strongly suggest you to list all active swaps in /etc/fstab. Firstly
+because you don't have to specify anything to resume and secondly if you
+have more than one swap area you can't decide which one has the 'root'
+signature. Also, it doesn't yet support ``embedded'' swapfiles, e.g. you have
+a dos partition mounted on /dos and also have a /dos/swapfile named swapfile..
+I plan to add support to mount all necessary filesystems readonly.
+
+In the meantime while the system is suspended you should not touch any of the
+hardware!
+
+\section{About the code}
+\subsection{Goals reached}
+The code can be downloaded from
+{\url http://falcon.sch.bme.hu/~seasons/linux\/}. It mainly works but there
+are still some of XXXs, TODOs, FIXMEs in the code which seem not to be too
+important. It should work all right except for the problems listed in ``Things
+to implement''. Notes about the code are really welcome.
+
+\subsubsection{How the code works}
+When suspending is triggered it immediately wakes up process bdflush. Bdflush
+checks whether we have anything in our run queue {\it tq\_bdflush}. Since we
+queued up function {\it do\_software\_suspend}, it is called. Here we shrink
+everything including dcache, inodes, buffers and memory (here mainly processes
+are swapped out). We count how many pages we need to duplicate (we have to be
+atomical!) then we create an appropiate sized page directory. It will point to
+the original and the new (copied) address of the page. We get the free
+pages by {\it \_\_get\_free\_pages()} but since it changes state we have
+to be able to track it later so it also flips in a bit in page's flags (a new
+Nosave flag). We duplicate pages and then mark them as used (so atomicity is
+ensured). After this we write out the image to swaps, do another sync and the
+machine may reboot. We also save registers to stack.
+
+By resuming an ``inverse'' method is executed. The image if exists is loaded,
+loadling is either triggered by ``swapon -a'' or ``resume='' kernel option.
+We change our task to bdflush (it is needed because if we don't do this {\it
+init} does an oops when it is waken up later) and then pages are copied back
+to their original location. We restore registers, free previously allocated
+memory, activate memory context and task information. Here we should restore
+hardware state but even without this the machine is restored and processes are
+continued to work. I think hardware state should be restored by some list
+(using notify\_chain) and probably by some userland program (run-parts?) for
+users' pleasure. Check out my patch at the same location for the sysvinit
+patch.
+
+\subsection{Things to implement}
+\noindent
+\begin{itemize}
+\item SMP support. I've done an SMP support but since I don't have access
+to a kind of this one I cannot test it. Please SMP people test it.
+.. Tested it, doesn't work. Had no time to figure out why. There is some
+mess with interrupts AFAIK..
+\item We should only make a copy of data related to kernel segment, since
+any process data won't be changed.
+\item Should \#define ADDRESS go into linux/mm.h?
+\item By copying pages back to their original position, {\it copy\_page}
+caused General Protection Fault. Why?
+\item Hardware state restoring.  Now there's support for notifying via the
+notify chain, event handlers are welcome. Some devices may have microcodes
+loaded into them. We should have event handlers for them aswell.
+\item We should support other architectures (There are really only some
+arch related functions..)
+\item We should also restore original state of swaps if the ``noresume''
+kernel option is specified.. Or do we need such a feature to save state for
+some other time? Do we need some kind of ``several saved states''?
+(Linux-HA people?). There's been some discussion about checkpointing on
+linux-future.
+\item Should make more sanity checks. Or are these enough?
+\end{itemize}
+
+\subsection{Not so important ideas for implementing}
+\noindent
+\begin{itemize}
+\item Should SIGSTOP\_SUSPEND called SIGFREEZE? Or is it some kind of stealing
+for Solaris?
+\item If a real time process is running then don't suspend the machine.
+\item Is there any sense in compressing the outwritten pages?
+\item Support for power.conf file as in Solaris, autoshutdown, special
+devicetypes support, maybe in sysctl.
+\item Introduce timeout for SMP locking. But first locking ought to work :O
+\item Pre-detect if we don't have enough swap space or free it instead of
+calling panic.
+\item Support for adding/removing hardware while suspended?
+\item I'm afraid that if you had more than one swaps than there's some problem
+with the code.
+\item We should not free pages at the beginning so aggressively, most of them
+go there anyway..
+\item If X is active while suspending then by resuming calling svgatextmode
+corrupts the virtual console of X.. (Maybe this has been fixed AFAIK). 
+\end{itemize}
+
+Any other idea you might have tell me!
+
+\section{Contacting the author}
+If you have any question or any patch that solves the above or detected
+problems please contact me at {\it seasons@falcon.sch.bme.hu} or {\it
+ksx@sch.bme.hu}. I might delay answering, sorry about that.
+
+\end{document}
diff -wurN -X dontdiff linux-2.2.18/Documentation/swsusp.txt linux-2.2.18-swsusp/Documentation/swsusp.txt
--- linux-2.2.18/Documentation/swsusp.txt	Thu Jan  1 01:00:00 1970
+++ linux-2.2.18-swsusp/Documentation/swsusp.txt	Fri Dec 29 03:49:17 2000
@@ -0,0 +1,138 @@
+Article about goals and implementation of Software Suspend for Linux
+Author: Gábor Kuti
+Last revised: Jan 23rd, 2000
+
+Idea and goals to achieve
+
+Nowadays it is common in several laptops that they have a suspend button. It
+saves the state of the machine to a filesystem or to a partition and switches
+to standby mode. Later resuming the machine the saved state is loaded back to
+ram and the machine can continue its work. It has two real benefits. First we
+save ourselves the time machine goes down and later boots up, energy costs
+real high when running from batteries. The other gain is that we don't have to
+interrupt our programs so processes that are calculating something for a long
+time shouldn't need to be written interruptible.
+
+On desk machines the power saving function isn't as important as it is in
+laptops but we really may benefit from the second one. Nowadays the number of
+desk machines supporting suspend function in their APM is going up but there
+are (and there will still be for a long time) machines that don't even support
+APM of any kind. On the other hand it is reported that using APM's suspend
+some irqs (e.g. ATA disk irq) is lost and it is annoying for the user until
+the Linux kernel resets the device.
+
+So I started thinking about implementing Software Suspend which doesn't need
+any APM support and - since it uses pretty near only high-level routines - is
+supposed to be architecture independent code.
+
+Using the code
+
+The code is experimental right now - testers, extra eyes are welcome. To
+compile this support into the kernel, you need CONFIG_EXPERIMENTAL, 
+and then CONFIG_SOFTWARE_SUSPEND in menu General Setup to be  enabled. It
+cannot be used as a module and I don't think it will ever be needed.
+
+You have two ways to use this code. The first one is if you've compiled in
+sysrq support then you may press Sysrq-D to request suspend. The other way
+is with a patched SysVinit (my patch is against 2.76 and available at my
+home page). You might call 'swsusp' or 'shutdown -z <time>'.
+
+Either way it saves the state of the machine into active swaps and then
+reboots. By the next booting the kernel's resuming function is either triggered
+by swapon -a (which is ought to be in the very early stage of booting) or you
+may explicitly specify the swap partition/file to resume from with ``resume=''
+kernel option. If signature is found it loads and restores saved state. If the
+option ``noresume'' is specified as a boot parameter, it skips the resuming.
+Warning! Look at section ``Things to implement'' to see what isn't yet
+implemented.  Also I strongly suggest you to list all active swaps in
+/etc/fstab. Firstly because you don't have to specify anything to resume and
+secondly if you have more than one swap area you can't decide which one has the
+'root' signature. Also, it doesn't yet support ``embedded'' swapfiles, e.g. you
+have a dos partition mounted on /dos and also have a /dos/swapfile named
+swapfile..  I plan to add support to mount all necessary filesystems readonly.
+
+In the meantime while the system is suspended you should not touch any of the
+hardware!
+
+About the code
+Goals reached
+
+The code can be downloaded from
+http://falcon.sch.bme.hu/~seasons/linux/. It mainly works but there are still
+some of XXXs, TODOs, FIXMEs in the code which seem not to be too important. It
+should work all right except for the problems listed in ``Things to
+implement''. Notes about the code are really welcome.
+
+How the code works
+
+When suspending is triggered it immediately wakes up process bdflush. Bdflush
+checks whether we have anything in our run queue tq_bdflush. Since we queued up
+function do_software_suspend, it is called. Here we shrink everything including
+dcache, inodes, buffers and memory (here mainly processes are swapped out). We
+count how many pages we need to duplicate (we have to be atomical!) then we
+create an appropiate sized page directory. It will point to the original and
+the new (copied) address of the page. We get the free pages by
+__get_free_pages() but since it changes state we have to be able to track it
+later so it also flips in a bit in page's flags (a new Nosave flag). We
+duplicate pages and then mark them as used (so atomicity is ensured). After
+this we write out the image to swaps, do another sync and the machine may
+reboot. We also save registers to stack.
+
+By resuming an ``inverse'' method is executed. The image if exists is loaded,
+loadling is either triggered by ``swapon -a'' or ``resume='' kernel option.  We
+change our task to bdflush (it is needed because if we don't do this init does
+an oops when it is waken up later) and then pages are copied back to their
+original location. We restore registers, free previously allocated memory,
+activate memory context and task information. Here we should restore hardware
+state but even without this the machine is restored and processes are continued
+to work. I think hardware state should be restored by some list (using
+notify_chain) and probably by some userland program (run-parts?) for users'
+pleasure. Check out my patch at the same location for the sysvinit patch.
+
+Things to implement
+- SMP support. I've done an SMP support but since I don't have access to a kind
+  of this one I cannot test it. Please SMP people test it.  .. Tested it,
+  doesn't work. Had no time to figure out why. There is some mess with
+  interrupts AFAIK..
+- We should only make a copy of data related to kernel segment, since any
+  process data won't be changed.
+- Should \#define ADDRESS go into linux/mm.h?
+- By copying pages back to their original position, copy_page caused General
+  Protection Fault. Why?
+- Hardware state restoring.  Now there's support for notifying via the notify
+  chain, event handlers are welcome. Some devices may have microcodes loaded
+  into them. We should have event handlers for them aswell.
+- We should support other architectures (There are really only some arch
+  related functions..)
+- We should also restore original state of swaps if the ``noresume'' kernel
+  option is specified.. Or do we need such a feature to save state for some
+  other time? Do we need some kind of ``several saved states''?  (Linux-HA
+  people?). There's been some discussion about checkpointing on linux-future.
+- Should make more sanity checks. Or are these enough?
+
+Not so important ideas for implementing
+
+- Should SIGSTOP_SUSPEND called SIGFREEZE? Or is it some kind of stealing
+  for Solaris?
+- If a real time process is running then don't suspend the machine.
+- Is there any sense in compressing the outwritten pages?
+- Support for power.conf file as in Solaris, autoshutdown, special
+  devicetypes support, maybe in sysctl.
+- Introduce timeout for SMP locking. But first locking ought to work :O
+- Pre-detect if we don't have enough swap space or free it instead of
+  calling panic.
+- Support for adding/removing hardware while suspended?
+- I'm afraid that if you had more than one swaps than there's some problem
+  with the code.
+- We should not free pages at the beginning so aggressively, most of them
+  go there anyway..
+- If X is active while suspending then by resuming calling svgatextmode
+  corrupts the virtual console of X.. (Maybe this has been fixed AFAIK).
+
+Any other idea you might have tell me!
+
+Contacting the author
+If you have any question or any patch that solves the above or detected
+problems please contact me at seasons@falcon.sch.bme.hu. I might delay
+answering, sorry about that.
+
diff -wurN -X dontdiff linux-2.2.18/MAINTAINERS linux-2.2.18-swsusp/MAINTAINERS
--- linux-2.2.18/MAINTAINERS	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/MAINTAINERS	Fri Jan 26 04:11:59 2001
@@ -872,6 +872,14 @@
 L:	linux-smp@vger.kernel.org
 S:	Maintained
 
+SOFTWARE SUSPEND:
+P:	Gabor Kuti
+M:	seasons@falcon.sch.bme.hu
+M:	(seasons@makosteszta.sote.hu)
+L:	swsusp@listserv.elte.hu
+W:	http://falcon.sch.bme.hu/~seasons/linux
+S:	Maintained
+
 SONIC NETWORK DRIVER
 P:	Thomas Bogendoerfer
 M:	tsbogend@alpha.franken.de
diff -wurN -X dontdiff linux-2.2.18/arch/i386/Makefile linux-2.2.18-swsusp/arch/i386/Makefile
--- linux-2.2.18/arch/i386/Makefile	Thu May  4 01:16:30 2000
+++ linux-2.2.18-swsusp/arch/i386/Makefile	Fri Dec 29 08:50:00 2000
@@ -32,11 +32,11 @@
 endif
 
 ifdef CONFIG_M586
-CFLAGS := $(CFLAGS) -m486 -malign-loops=2 -malign-jumps=2 -malign-functions=2 -DCPU=586
+CFLAGS := $(CFLAGS) -march=pentium -malign-loops=2 -malign-jumps=2 -malign-functions=2 -DCPU=586
 endif
 
 ifdef CONFIG_M586TSC
-CFLAGS := $(CFLAGS) -m486 -malign-loops=2 -malign-jumps=2 -malign-functions=2 -DCPU=586
+CFLAGS := $(CFLAGS) -march=pentium -malign-loops=2 -malign-jumps=2 -malign-functions=2 -DCPU=586
 endif
 
 ifdef CONFIG_M686
diff -wurN -X dontdiff linux-2.2.18/arch/i386/config.in linux-2.2.18-swsusp/arch/i386/config.in
--- linux-2.2.18/arch/i386/config.in	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/arch/i386/config.in	Fri Jan 26 04:13:18 2001
@@ -119,6 +119,19 @@
 fi
 tristate 'Toshiba Laptop support' CONFIG_TOSHIBA
 
+if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+  bool 'Software Suspend' CONFIG_SOFTWARE_SUSPEND
+  if [ "$CONFIG_SOFTWARE_SUSPEND" = "y" ]; then
+    bool '   Support hardware state restore' CONFIG_HWSTATE_RESTORE
+    if [ "$CONFIG_HWSTATE_RESTORE" = "y" ]; then
+      bool '    RTC stores time in GMT' CONFIG_APM_RTC_IS_GMT
+    fi      
+    if [ "$CONFIG_APM" = "y" ]; then
+      bool '   Override APM suspend events' CONFIG_SWSUSP_OVERRIDE_APM
+    fi
+  fi
+fi
+
 endmenu
 
 source drivers/pnp/Config.in
diff -wurN -X dontdiff linux-2.2.18/arch/i386/defconfig linux-2.2.18-swsusp/arch/i386/defconfig
--- linux-2.2.18/arch/i386/defconfig	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/arch/i386/defconfig	Fri Jan 26 04:13:45 2001
@@ -58,6 +58,8 @@
 # CONFIG_PARPORT is not set
 # CONFIG_APM is not set
 # CONFIG_TOSHIBA is not set
+# CONFIG_SOFTWARE_SUSPEND is not set
+# CONFIG_HWSTATE_RESTORE is not set
 
 #
 # Plug and Play support
diff -wurN -X dontdiff linux-2.2.18/arch/i386/kernel/apm.c linux-2.2.18-swsusp/arch/i386/kernel/apm.c
--- linux-2.2.18/arch/i386/kernel/apm.c	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/arch/i386/kernel/apm.c	Fri Dec 29 03:49:18 2000
@@ -166,6 +166,10 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 
+#ifdef CONFIG_SWSUSP_OVERRIDE_APM
+# include <linux/swsusp.h>
+#endif
+
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/desc.h>
@@ -270,6 +274,10 @@
 #define savesegment(seg, where) \
 		__asm__ __volatile__("movl %%" #seg ",%0" : "=m" (where))
 
+/* Moved set_time related functions into time.c for software suspend */
+extern void	apm_set_time(void);
+extern void	get_time_diff(void);
+
 /*
  * Maximum number of events stored
  */
@@ -312,13 +320,6 @@
 static int			standbys_pending = 0;
 static int			waiting_for_resume = 0;
 
-#ifdef CONFIG_APM_RTC_IS_GMT
-#	define	clock_cmos_diff	0
-#	define	got_clock_diff	1
-#else
-static long			clock_cmos_diff;
-static int			got_clock_diff = 0;
-#endif
 static int			debug = 0;
 static int			apm_disabled = 0;
 #ifdef CONFIG_SMP
@@ -824,35 +825,6 @@
 	wake_up_interruptible(&apm_waitqueue);
 }
 
-static void set_time(void)
-{
-	unsigned long	flags;
-
-	if (got_clock_diff) {	/* Must know time zone in order to set clock */
-		save_flags(flags);
-		cli();
-		CURRENT_TIME = get_cmos_time() + clock_cmos_diff;
-		restore_flags(flags);
-	}
-}
-
-static void get_time_diff(void)
-{
-#ifndef CONFIG_APM_RTC_IS_GMT
-	unsigned long	flags;
-
-	/*
-	 * Estimate time zone so that set_time can update the clock
-	 */
-	save_flags(flags);
-	clock_cmos_diff = -get_cmos_time();
-	cli();
-	clock_cmos_diff += CURRENT_TIME;
-	got_clock_diff = 1;
-	restore_flags(flags);
-#endif
-}
-
 static void reinit_timer(void)
 {
 #ifdef INIT_TIMER_AFTER_SUSPEND
@@ -873,13 +845,19 @@
 
 static int suspend(void)
 {
+#ifdef CONFIG_SWSUSP_OVERRIDE_APM
+	/* If swsusp isn't enabled for some reason, may as well
+	   fall back to standard APM method */
+	if (!software_suspend_enabled) {
+#endif
+
 	int		err;
 	struct apm_user	*as;
 
 	get_time_diff();
 	err = apm_set_power_state(APM_STATE_SUSPEND);
 	reinit_timer();
-	set_time();
+	apm_set_time();
 	if (err == APM_NO_ERROR)
 		err = APM_SUCCESS;
 	if (err != APM_SUCCESS)
@@ -890,6 +868,16 @@
 	}
 	wake_up_interruptible(&apm_suspend_waitqueue);
 	return err;
+
+#ifdef CONFIG_SWSUSP_OVERRIDE_APM
+	} else {
+		/* XXX Is this safe? What if it's due to a user-suspend?
+		   XXX Well it seems to work for me -- jsh */
+		if (apm_bios_info.version > 0x100)
+			apm_set_power_state(APM_STATE_REJECT);
+		software_suspend ();
+	}
+#endif
 }
 
 static void standby(void)
@@ -921,7 +909,7 @@
 	return 0;
 }
 
-static int send_event(apm_event_t event, apm_event_t undo,
+int apm_send_event(apm_event_t event, apm_event_t undo,
 		       struct apm_user *sender)
 {
 	callback_list_t *	call;
@@ -966,7 +954,7 @@
 		switch (event) {
 		case APM_SYS_STANDBY:
 		case APM_USER_STANDBY:
-			if (send_event(event, APM_STANDBY_RESUME, NULL)) {
+			if (apm_send_event(event, APM_STANDBY_RESUME, NULL)) {
 				if (standbys_pending <= 0)
 					standby();
 			}
@@ -993,7 +981,7 @@
 			 */
 			if (waiting_for_resume)
 				return;
-			if (send_event(event, APM_NORMAL_RESUME, NULL)) {
+			if (apm_send_event(event, APM_NORMAL_RESUME, NULL)) {
 				waiting_for_resume = 1;
 				if (suspends_pending <= 0)
 					(void) suspend();
@@ -1008,18 +996,18 @@
 			last_resume = jiffies;
 			ignore_bounce = 1;
 #endif
-			set_time();
-			send_event(event, 0, NULL);
+			apm_set_time();
+			apm_send_event(event, 0, NULL);
 			break;
 
 		case APM_CAPABILITY_CHANGE:
 		case APM_LOW_BATTERY:
 		case APM_POWER_STATUS_CHANGE:
-			send_event(event, 0, NULL);
+			apm_send_event(event, 0, NULL);
 			break;
 
 		case APM_UPDATE_TIME:
-			set_time();
+			apm_set_time();
 			break;
 
 		case APM_CRITICAL_SUSPEND:
@@ -1144,7 +1132,7 @@
 			as->standbys_read--;
 			as->standbys_pending--;
 			standbys_pending--;
-		} else if (!send_event(APM_USER_STANDBY, APM_STANDBY_RESUME, as))
+		} else if (!apm_send_event(APM_USER_STANDBY, APM_STANDBY_RESUME, as))
 			return -EAGAIN;
 		if (standbys_pending <= 0)
 			standby();
@@ -1154,7 +1142,7 @@
 			as->suspends_read--;
 			as->suspends_pending--;
 			suspends_pending--;
-		} else if (!send_event(APM_USER_SUSPEND, APM_NORMAL_RESUME, as))
+		} else if (!apm_send_event(APM_USER_SUSPEND, APM_NORMAL_RESUME, as))
 			return -EAGAIN;
 		if (suspends_pending <= 0) {
 			if (suspend() != APM_SUCCESS)
diff -wurN -X dontdiff linux-2.2.18/arch/i386/kernel/process.c linux-2.2.18-swsusp/arch/i386/kernel/process.c
--- linux-2.2.18/arch/i386/kernel/process.c	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/arch/i386/kernel/process.c	Fri Dec 29 03:49:18 2000
@@ -496,6 +496,7 @@
 int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
 {
 	long retval, d0;
+	if (!fn) return (-1);
 
 	__asm__ __volatile__(
 		"movl %%esp,%%esi\n\t"
@@ -760,6 +761,23 @@
 		loaddebug(next,7);
 	}
 }
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+/*
+ * We reload there TR, LDT, page tables only. Other processor registers
+ * including segment ones are restored before calling this function
+ */
+void activate_task(struct task_struct *tsk)
+{
+	/* Reload TR */
+	gdt_table[tsk->tss.tr >> 3].b &= 0xfffffdff;
+	asm volatile("ltr %0": :"g" (*(unsigned short *)&tsk->tss.tr));
+	/* Re-load LDT */
+	asm volatile("lldt %0": :"g" (*(unsigned short *)&tsk->tss.ldt));
+	/* Re-load page tables */
+	asm volatile("movl %0,%%cr3": :"r" (tsk->tss.cr3));
+}
+#endif
 
 asmlinkage int sys_fork(struct pt_regs regs)
 {
diff -wurN -X dontdiff linux-2.2.18/arch/i386/kernel/time.c linux-2.2.18-swsusp/arch/i386/kernel/time.c
--- linux-2.2.18/arch/i386/kernel/time.c	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/arch/i386/kernel/time.c	Fri Dec 29 03:49:18 2000
@@ -52,6 +52,9 @@
 #include <linux/mc146818rtc.h>
 #include <linux/timex.h>
 #include <linux/config.h>
+#ifdef CONFIG_HWSTATE_RESTORE
+#include <linux/swsusp.h>
+#endif /* CONFIG_HWSTATE_RESTORE */
 
 #include <asm/fixmap.h>
 #include <asm/cobalt.h>
@@ -513,8 +516,7 @@
 	  )*60 + sec; /* finally seconds */
 }
 
-/* not static: needed by APM */
-unsigned long get_cmos_time(void)
+static unsigned long get_cmos_time(void)
 {
 	unsigned int year, mon, day, hour, min, sec;
 	int i;
@@ -634,6 +636,69 @@
 
 extern int x86_udelay_tsc;
 
+#if defined(CONFIG_HWSTATE_RESTORE) || defined(CONFIG_APM)
+
+#ifdef CONFIG_APM_RTC_IS_GMT
+#       define  clock_cmos_diff 0
+#       define  got_clock_diff  1
+#else
+static long                     clock_cmos_diff;
+static int                      got_clock_diff = 0;
+#endif
+
+/*
+ * Estimate time zone so that apm_set_time() can update the clock
+ */
+void get_time_diff(void)
+{
+#ifndef CONFIG_APM_RTC_IS_GMT
+	unsigned long flags;
+	
+	save_flags(flags);
+	clock_cmos_diff = -get_cmos_time();
+	cli();
+	clock_cmos_diff += CURRENT_TIME;
+	got_clock_diff = 1;
+	restore_flags(flags);
+#endif
+}
+
+void apm_set_time(void)
+{
+	unsigned long	flags;
+
+	if (got_clock_diff) {	/* Must know time zone in order to set clock */
+		save_flags(flags);
+		cli();
+		CURRENT_TIME = get_cmos_time() + clock_cmos_diff;
+		restore_flags(flags);
+	}
+}
+
+#endif
+
+#ifdef CONFIG_HWSTATE_RESTORE
+static int i386rtc_event(struct notifier_block *this, unsigned long event, void *ptr)
+{
+	switch (event) {
+	case SYS_SUSPEND:
+		get_time_diff();
+		break;
+	case SYS_RESUME:
+		apm_set_time();
+		break;
+	}
+
+	return NOTIFY_DONE;
+}
+		
+static struct notifier_block i386rtc_suspend_notifier = {
+	i386rtc_event,
+	NULL,
+	0
+};
+#endif /* CONFIG_HWSTATE_RESTORE */
+
 __initfunc(void time_init(void))
 {
 	xtime.tv_sec = get_cmos_time();
@@ -712,4 +777,7 @@
 #else
 	setup_x86_irq(0, &irq0);
 #endif
+#ifdef CONFIG_HWSTATE_RESTORE
+	register_suspend_notifier(&i386rtc_suspend_notifier);
+#endif /* CONFIG_HWSTATE_RESTORE */
 }
diff -wurN -X dontdiff linux-2.2.18/arch/i386/vmlinux.lds.S linux-2.2.18-swsusp/arch/i386/vmlinux.lds.S
--- linux-2.2.18/arch/i386/vmlinux.lds.S	Mon Dec 11 00:49:41 2000
+++ linux-2.2.18-swsusp/arch/i386/vmlinux.lds.S	Fri Dec 29 03:49:18 2000
@@ -13,6 +13,8 @@
 	*(.fixup)
 	*(.gnu.warning)
 	} = 0x9090
+  _etext = .;                  /* End of text section */
+
   .text.lock : { *(.text.lock) }	/* out-of-line lock text */
   .rodata : { *(.rodata) }
   .kstrtab : { *(.kstrtab) }
@@ -26,8 +28,6 @@
   __ksymtab : { *(__ksymtab) }
   __stop___ksymtab = .;
 
-  _etext = .;			/* End of text section */
-
   .data : {			/* Data */
 	*(.data)
 	CONSTRUCTORS
@@ -51,6 +51,12 @@
   __initcall_end = .;
   . = ALIGN(4096);
   __init_end = .;
+
+  . = ALIGN(4096);             /* nosave data for software suspend */
+  __nosave_begin = .;
+  .data.nosave : { *(.data.nosave) }
+  . = ALIGN(4096);
+  __nosave_end = .;
 
 
   . = ALIGN(32);
diff -wurN -X dontdiff linux-2.2.18/drivers/char/serial.c linux-2.2.18-swsusp/drivers/char/serial.c
--- linux-2.2.18/drivers/char/serial.c	Wed Jun  7 22:26:42 2000
+++ linux-2.2.18-swsusp/drivers/char/serial.c	Fri Dec 29 03:49:18 2000
@@ -139,6 +139,9 @@
 #include <linux/malloc.h>
 #include <linux/init.h>
 #include <linux/delay.h>
+#ifdef CONFIG_HWSTATE_RESTORE
+#include <linux/swsusp.h>
+#endif
 #ifdef CONFIG_SERIAL_CONSOLE
 #include <linux/console.h>
 #endif
@@ -911,7 +914,7 @@
 	IRQ_timeout[irq] = timeout ? timeout : 1;
 }
 
-static int startup(struct async_struct * info)
+static int startup(struct async_struct * info, int restart)
 {
 	unsigned long flags;
 	int	retval=0;
@@ -928,7 +931,8 @@
 
 	save_flags(flags); cli();
 
-	if (info->flags & ASYNC_INITIALIZED) {
+	if (info->flags & ASYNC_INITIALIZED &&
+		!restart) {
 		free_page(page);
 		goto errout;
 	}
@@ -988,7 +992,8 @@
 	 * Allocate the IRQ if necessary
 	 */
 	if (state->irq && (!IRQ_ports[state->irq] ||
-			  !IRQ_ports[state->irq]->next_port)) {
+			  !IRQ_ports[state->irq]->next_port) &&
+			  !restart) {
 		if (IRQ_ports[state->irq]) {
 #ifdef CONFIG_SERIAL_SHARE_IRQ
 			free_irq(state->irq, NULL);
@@ -1021,12 +1026,14 @@
 	/*
 	 * Insert serial port into IRQ chain.
 	 */
+	if(!restart) {
 	info->prev_port = 0;
 	info->next_port = IRQ_ports[state->irq];
 	if (info->next_port)
 		info->next_port->prev_port = info;
 	IRQ_ports[state->irq] = info;
 	figure_IRQ_timeout(state->irq);
+	}
 
 	/*
 	 * Clear the interrupt registers.
@@ -1765,7 +1772,7 @@
 			change_speed(info, 0);
 		}
 	} else
-		retval = startup(info);
+		retval = startup(info,0);
 	return retval;
 }
 
@@ -1893,7 +1900,7 @@
 	    (info->state->type != PORT_UNKNOWN))
 		info->state->irq = detect_uart_irq(info->state);
 
-	retval = startup(info);
+	retval = startup(info,0);
 	if (retval)
 		return retval;
 	return 0;
@@ -2663,7 +2670,7 @@
 	/*
 	 * Start up serial port
 	 */
-	retval = startup(info);
+	retval = startup(info,0);
 	if (retval) {
 		/* MOD_DEC_USE_COUNT; "info->tty" will cause this? */
 		return retval;
@@ -3080,6 +3087,16 @@
 EXPORT_SYMBOL(register_serial);
 EXPORT_SYMBOL(unregister_serial);
 
+#ifdef CONFIG_HWSTATE_RESTORE
+static int serial_event(struct notifier_block *, unsigned long, void *);
+
+struct notifier_block serial_suspend_notifier = {
+	serial_event,
+	NULL,
+	0
+};
+#endif
+
 /*
  * The serial driver boot-time initialization code!
  */
@@ -3216,9 +3233,47 @@
 		       state->port, state->irq,
 		       uart_config[state->type].name);
 	}
+#if CONFIG_HWSTATE_RESTORE
+	/* The notifier_block stuff doesn't enforce any critical sections.
+	   So I hope interrupts are off here. Maybe I'll check one day.	*/
+	register_suspend_notifier(&serial_suspend_notifier);
+#endif
 	return 0;
 }
 
+#if CONFIG_HWSTATE_RESTORE
+/*
+ * Make the hardware state match what we think it should be.
+ */
+static void restore_hardware_state(void)
+{
+	int line;
+	struct serial_state *sstate;
+
+	/* find open ports / lines, and reinitialise them */
+	for( line = 0; line < NR_PORTS; line++ ) {
+		sstate = &rs_table[line];
+		if( sstate->count ) {
+			startup(sstate->info,1);
+		}
+	}
+}
+
+/*
+ * called when the machine is suspended to swap or resumed.
+ */
+int serial_event(struct notifier_block *this, unsigned long event, void *ptr)
+{
+	switch( event ) {
+	case SYS_RESUME:
+		restore_hardware_state();
+		break;
+	}
+
+	return NOTIFY_DONE;
+}
+#endif /* CONFIG_HWSTATE_RESTORE */
+		
 /*
  * register_serial and unregister_serial allows for serial ports to be
  * configured at run-time, to support PCMCIA modems.
@@ -3313,6 +3368,9 @@
 	if ((e2 = tty_unregister_driver(&callout_driver)))
 		printk("SERIAL: failed to unregister callout driver (%d)\n", 
 		       e2);
+#ifdef CONFIG_HWSTATE_RESTORE
+	unregister_suspend_notifier(&serial_suspend_notifier);
+#endif
 	restore_flags(flags);
 
 	for (i = 0; i < NR_PORTS; i++) {
diff -wurN -X dontdiff linux-2.2.18/drivers/char/sysrq.c linux-2.2.18-swsusp/drivers/char/sysrq.c
--- linux-2.2.18/drivers/char/sysrq.c	Thu May  4 01:16:39 2000
+++ linux-2.2.18-swsusp/drivers/char/sysrq.c	Fri Dec 29 03:49:18 2000
@@ -28,6 +28,10 @@
 int sysrq_enabled = 1;
 #endif
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+#include <linux/swsusp.h>
+#endif
+
 extern void wakeup_bdflush(int);
 extern void reset_vc(unsigned int);
 extern int console_loglevel;
@@ -65,6 +69,10 @@
 		return;
 
 	console_loglevel = 7;
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	if(key != 'd')
+#endif
 	printk(KERN_INFO "SysRq: ");
 	switch (key) {
 	case 'r':					    /* R -- Reset raw mode */
@@ -91,6 +99,15 @@
 			sysrq_power_off();
 		}
 		break;
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	case 'd':
+		if(!software_suspend_enabled) {
+			printk("Software Suspend is not possible now\n");
+			break;
+		}
+		software_suspend();
+		break;
+#endif
 	case 's':					    /* S -- emergency sync */
 		printk("Emergency Sync\n");
 		emergency_sync_scheduled = EMERG_SYNC;
@@ -143,6 +160,9 @@
 		printk("Boot ");
 		if (sysrq_power_off)
 			printk("Off ");
+#ifdef CONFIG_SOFTWARE_SUSPEND
+			printk("suspenD ");
+#endif
 		printk("Sync Unmount showPc showTasks showMem loglevel0-8 tErm kIll killalL\n");
 		/* Don't use 'A' as it's handled specially on the Sparc */
 	}
diff -wurN -X dontdiff linux-2.2.18/fs/buffer.c linux-2.2.18-swsusp/fs/buffer.c
--- linux-2.2.18/fs/buffer.c	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/fs/buffer.c	Fri Jan 26 04:25:00 2001
@@ -126,6 +126,8 @@
 
 void wakeup_bdflush(int);
 
+DECLARE_TASK_QUEUE(tq_bdflush);
+
 /*
  * Rewrote the wait-routines to use the "new" wait-queue functionality,
  * and getting rid of the cli-sti pairs. The wait-queue routines still
@@ -1931,6 +1933,11 @@
 			continue;
 		}
 		run_task_queue(&tq_disk);
+#ifdef CONFIG_SOFTWARE_SUSPEND
+		//printk("bdflush: run tq_bdflush ...\n");
+		run_task_queue(&tq_bdflush);
+		//printk("bdflush: return from tq_bdflush ...\n");
+#endif
 		wake_up(&bdflush_done);
 		
 		/* If there are still a lot of dirty buffers around, skip the sleep
diff -wurN -X dontdiff linux-2.2.18/include/asm-alpha/bitops.h linux-2.2.18-swsusp/include/asm-alpha/bitops.h
--- linux-2.2.18/include/asm-alpha/bitops.h	Mon Sep  4 18:39:28 2000
+++ linux-2.2.18-swsusp/include/asm-alpha/bitops.h	Fri Dec 29 03:49:18 2000
@@ -195,6 +195,12 @@
 #endif
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-arm/bitops.h linux-2.2.18-swsusp/include/asm-arm/bitops.h
--- linux-2.2.18/include/asm-arm/bitops.h	Tue Jul 21 01:23:32 1998
+++ linux-2.2.18-swsusp/include/asm-arm/bitops.h	Fri Dec 29 03:49:18 2000
@@ -53,6 +53,12 @@
         return k;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-generic/bitops.h linux-2.2.18-swsusp/include/asm-generic/bitops.h
--- linux-2.2.18/include/asm-generic/bitops.h	Tue Jul 21 01:23:32 1998
+++ linux-2.2.18-swsusp/include/asm-generic/bitops.h	Fri Dec 29 03:49:18 2000
@@ -51,6 +51,12 @@
 	return ((mask & *addr) != 0);
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-i386/bitops.h linux-2.2.18-swsusp/include/asm-i386/bitops.h
--- linux-2.2.18/include/asm-i386/bitops.h	Tue May 11 18:35:42 1999
+++ linux-2.2.18-swsusp/include/asm-i386/bitops.h	Fri Dec 29 07:34:08 2000
@@ -187,6 +187,12 @@
 	return word;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-i386/init.h linux-2.2.18-swsusp/include/asm-i386/init.h
--- linux-2.2.18/include/asm-i386/init.h	Mon Dec 28 06:45:13 1998
+++ linux-2.2.18-swsusp/include/asm-i386/init.h	Fri Dec 29 03:49:18 2000
@@ -6,6 +6,10 @@
 #define __initfunc(__arginit) \
 	__arginit __init; \
 	__arginit
+
+/* Data marked not to be saved by software_suspend() */
+#define __nosavedata __attribute__ ((__section__ (".data.nosave")))
+
 /* For assembly routines */
 #define __INIT		.section	".text.init",#alloc,#execinstr
 #define __FINIT	.previous
diff -wurN -X dontdiff linux-2.2.18/include/asm-i386/swsusp.h linux-2.2.18-swsusp/include/asm-i386/swsusp.h
--- linux-2.2.18/include/asm-i386/swsusp.h	Thu Jan  1 01:00:00 1970
+++ linux-2.2.18-swsusp/include/asm-i386/swsusp.h	Fri Dec 29 03:49:18 2000
@@ -0,0 +1,35 @@
+#ifndef __ASM_I386_SWSUSP_H
+#define __ASM_I386_SWSUSP_H
+
+struct suspend_stack {
+	unsigned long ss;
+	unsigned long esp;
+};
+
+#define SAVE_REGISTERS(suspend_stack)	\
+	__asm__ __volatile__ ( \
+	"pushl %%fs\n\t" \
+	"pushl %%gs\n\t" \
+	"pushfl\n\t" \
+	"movl %%ss, %0\n\t" \
+	"movl %%esp, %1\n\t" \
+	: "=m" (suspend_stack.ss), \
+	  "=m" (suspend_stack.esp) \
+	: /* No input */ \
+	: "memory"); \
+	mb();
+
+#define RESTORE_REGISTERS(suspend_stack)	\
+	mb(); \
+	__asm__ __volatile__ ( \
+	"movl %1, %%esp\n\t" \
+	"movl %0, %%ss\n\t" \
+	"popfl\n\t" \
+	"popl %%gs\n\t" \
+	"popl %%fs\n\t" \
+	: /* No output */ \
+	: "m" (suspend_stack.ss), \
+	  "m" (suspend_stack.esp) \
+	: "memory","cc");
+
+#endif /* __ASM_I386_SWSUSP_H */
diff -wurN -X dontdiff linux-2.2.18/include/asm-m68k/bitops.h linux-2.2.18-swsusp/include/asm-m68k/bitops.h
--- linux-2.2.18/include/asm-m68k/bitops.h	Wed Sep  2 17:39:18 1998
+++ linux-2.2.18-swsusp/include/asm-m68k/bitops.h	Fri Dec 29 03:49:18 2000
@@ -210,6 +210,12 @@
 	return res ^ 31;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-mips/bitops.h linux-2.2.18-swsusp/include/asm-mips/bitops.h
--- linux-2.2.18/include/asm-mips/bitops.h	Tue Jul 21 01:23:32 1998
+++ linux-2.2.18-swsusp/include/asm-mips/bitops.h	Fri Dec 29 03:49:18 2000
@@ -372,6 +372,12 @@
 	return __res;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-ppc/bitops.h linux-2.2.18-swsusp/include/asm-ppc/bitops.h
--- linux-2.2.18/include/asm-ppc/bitops.h	Mon Sep  4 18:39:28 2000
+++ linux-2.2.18-swsusp/include/asm-ppc/bitops.h	Fri Dec 29 03:49:18 2000
@@ -44,6 +44,12 @@
 	return 31 - n;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-sparc/bitops.h linux-2.2.18-swsusp/include/asm-sparc/bitops.h
--- linux-2.2.18/include/asm-sparc/bitops.h	Mon Sep  4 18:39:28 2000
+++ linux-2.2.18-swsusp/include/asm-sparc/bitops.h	Fri Dec 29 03:49:18 2000
@@ -182,6 +182,12 @@
 	return result;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/asm-sparc64/bitops.h linux-2.2.18-swsusp/include/asm-sparc64/bitops.h
--- linux-2.2.18/include/asm-sparc64/bitops.h	Mon Sep  4 18:39:28 2000
+++ linux-2.2.18-swsusp/include/asm-sparc64/bitops.h	Fri Dec 29 03:49:18 2000
@@ -186,6 +186,12 @@
 	return result;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -wurN -X dontdiff linux-2.2.18/include/linux/bitops.h linux-2.2.18-swsusp/include/linux/bitops.h
--- linux-2.2.18/include/linux/bitops.h	Mon Apr 26 20:19:02 1999
+++ linux-2.2.18-swsusp/include/linux/bitops.h	Fri Jan 26 01:21:57 2001
@@ -1,6 +1,6 @@
 #ifndef _LINUX_BITOPS_H
 #define _LINUX_BITOPS_H
-
+#include <asm/bitops.h>
 
 /*
  * ffs: find first bit set. This is defined the same way as
@@ -33,6 +33,39 @@
 	if (!(x & 1)) {
 		x >>= 1;
 		r += 1;
+	}
+	return r;
+}
+
+/*
+ * fls: find last bit set.
+ */
+
+extern __inline__ int generic_fls(int x)
+{
+	int r = 32;
+
+	if (!x)
+		return 0;
+	if (!(x & 0xffff0000)) {
+		x <<= 16;
+		r -= 16;
+	}
+	if (!(x & 0xff000000)) {
+		x <<= 8;
+		r -= 8;
+	}
+	if (!(x & 0xf0000000)) {
+		x <<= 4;
+		r -= 4;
+	}
+	if (!(x & 0xc0000000)) {
+		x <<= 2;
+		r -= 2;
+	}
+	if (!(x & 0x80000000)) {
+		x <<= 1;
+		r -= 1;
 	}
 	return r;
 }
diff -wurN -X dontdiff linux-2.2.18/include/linux/mm.h linux-2.2.18-swsusp/include/linux/mm.h
--- linux-2.2.18/include/linux/mm.h	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/include/linux/mm.h	Sat Jan 20 05:41:04 2001
@@ -144,6 +144,7 @@
 #define PG_Slab			 9
 #define PG_swap_cache		10
 #define PG_skip			11
+#define PG_nosave		13
 #define PG_reserved		31
 
 /* Make it prettier to test the above... */
@@ -158,23 +159,31 @@
 #define PageDMA(page)		(test_bit(PG_DMA, &(page)->flags))
 #define PageSlab(page)		(test_bit(PG_Slab, &(page)->flags))
 #define PageSwapCache(page)	(test_bit(PG_swap_cache, &(page)->flags))
+#define PageNosave(page)	(test_bit(PG_nosave, &(page)->flags))
 #define PageReserved(page)	(test_bit(PG_reserved, &(page)->flags))
 
 #define PageSetSlab(page)	(set_bit(PG_Slab, &(page)->flags))
 #define PageSetSwapCache(page)	(set_bit(PG_swap_cache, &(page)->flags))
+#define PageSetNosave(page)	(set_bit(PG_nosave, &(page)->flags))
 
 #define PageTestandSetDirty(page)	\
 			(test_and_set_bit(PG_dirty, &(page)->flags))
 #define PageTestandSetSwapCache(page)	\
 			(test_and_set_bit(PG_swap_cache, &(page)->flags))
+#define PageTestandSetNosave(page)	\
+ 			(test_and_set_bit(PG_nosave, &(page)->flags))
 
 #define PageClearSlab(page)	(clear_bit(PG_Slab, &(page)->flags))
 #define PageClearSwapCache(page)(clear_bit(PG_swap_cache, &(page)->flags))
+#define PageClearNosave(page)	(clear_bit(PG_nosave, &(page)->flags))
 
 #define PageTestandClearDirty(page) \
 			(test_and_clear_bit(PG_dirty, &(page)->flags))
 #define PageTestandClearSwapCache(page)	\
 			(test_and_clear_bit(PG_swap_cache, &(page)->flags))
+#define PageTestandClearNosave(page)	\
+			(test_and_clear_bit(PG_nosave, &(page)->flags))
+
 
 /*
  * Various page->flags bits:
diff -wurN -X dontdiff linux-2.2.18/include/linux/notifier.h linux-2.2.18-swsusp/include/linux/notifier.h
--- linux-2.2.18/include/linux/notifier.h	Fri Aug 28 03:33:08 1998
+++ linux-2.2.18-swsusp/include/linux/notifier.h	Fri Dec 29 07:34:00 2000
@@ -104,6 +104,8 @@
 #define SYS_RESTART	SYS_DOWN
 #define SYS_HALT	0x0002	/* Notify of system halt */
 #define SYS_POWER_OFF	0x0003	/* Notify of system power off */
+#define SYS_SUSPEND	0x0004	/* System is about to suspend - save h/w state */
+#define SYS_RESUME	0x0005	/* system has resumed - restore h/w state */
 
 /*
  *	Publically visible notifier objects
diff -wurN -X dontdiff linux-2.2.18/include/linux/reboot.h linux-2.2.18-swsusp/include/linux/reboot.h
--- linux-2.2.18/include/linux/reboot.h	Fri Aug 28 03:37:33 1998
+++ linux-2.2.18-swsusp/include/linux/reboot.h	Fri Dec 29 08:48:19 2000
@@ -20,6 +20,7 @@
  * CAD_OFF     Ctrl-Alt-Del sequence sends SIGINT to init task.
  * POWER_OFF   Stop OS and remove all power from system, if possible.
  * RESTART2    Restart system using given command string.
+ * SW_SUSPEND  Suspend system using Software Suspend if compiled in
  */
 
 #define	LINUX_REBOOT_CMD_RESTART	0x01234567
@@ -28,6 +29,7 @@
 #define	LINUX_REBOOT_CMD_CAD_OFF	0x00000000
 #define	LINUX_REBOOT_CMD_POWER_OFF	0x4321FEDC
 #define	LINUX_REBOOT_CMD_RESTART2	0xA1B2C3D4
+#define	LINUX_REBOOT_CMD_SW_SUSPEND	0xD000FCE2
 
 
 #ifdef __KERNEL__
@@ -46,6 +48,13 @@
 extern void machine_restart(char *cmd);
 extern void machine_halt(void);
 extern void machine_power_off(void);
+
+/*
+ * Architecture-independent suspend facility
+ */
+
+extern void software_suspend(void);
+extern unsigned char software_suspend_enabled;
 
 #endif
 
diff -wurN -X dontdiff linux-2.2.18/include/linux/swsusp.h linux-2.2.18-swsusp/include/linux/swsusp.h
--- linux-2.2.18/include/linux/swsusp.h	Thu Jan  1 01:00:00 1970
+++ linux-2.2.18-swsusp/include/linux/swsusp.h	Fri Dec 29 08:48:06 2000
@@ -0,0 +1,61 @@
+#ifndef _LINUX_SWSUSP_H
+#define _LINUX_SWSUSP_H
+
+#include <asm/swsusp.h>
+#include <linux/swap.h>
+#include <linux/notifier.h>
+
+extern unsigned char software_suspend_enabled;
+
+#define NORESUME	 1
+#define RESUME_SPECIFIED 2
+
+/* page backup entry */
+typedef struct pbe {
+	unsigned long address;		/* address of the copy */
+	unsigned long orig_address;	/* original address of page */
+	unsigned long swap_address;	
+	unsigned long dummy;		/* we need scratch space at 
+					 * end of page (see link, diskpage)
+					 */
+} suspend_pagedir_t;
+
+#define SWAP_FILENAME_MAXLENGTH	32
+
+struct suspend_header {
+	__u32 version_code;
+	unsigned long num_physpages;
+	char machine[8];
+	char version[20];
+	int num_cpus;
+	int page_size;
+	unsigned long suspend_pagedir;
+	unsigned int num_pbes;
+	struct swap_location {
+		char filename[SWAP_FILENAME_MAXLENGTH];
+	} swap_location[MAX_SWAPFILES];
+};
+
+#define SUSPEND_PD_PAGES(x)     (((x)*sizeof(struct pbe)-1)/PAGE_SIZE+1)
+   
+extern struct tq_struct suspend_tq;
+
+/* kernel/swsusp.c */
+extern void software_suspend(void);
+extern void software_resume(void);
+extern void software_noresume(char *, int *);
+extern void resume_setup(char *line, int *num);
+
+extern int register_suspend_notifier(struct notifier_block *);
+extern int unregister_suspend_notifier(struct notifier_block *);
+
+/* mm/vmscan.c */
+extern void shrink_mem(void);
+
+/* fs/inode.c */
+extern void shrink_free_inodes(void);
+
+/* arch/<arch>/kernel/process.c */
+extern void activate_task(struct task_struct *tsk);
+
+#endif /* _LINUX_SWSUSP_H */
diff -wurN -X dontdiff linux-2.2.18/include/linux/tqueue.h linux-2.2.18-swsusp/include/linux/tqueue.h
--- linux-2.2.18/include/linux/tqueue.h	Tue May 11 18:35:44 1999
+++ linux-2.2.18-swsusp/include/linux/tqueue.h	Fri Dec 29 07:34:08 2000
@@ -51,7 +51,7 @@
 
 #define DECLARE_TASK_QUEUE(q)  task_queue q = NULL
 
-extern task_queue tq_timer, tq_immediate, tq_scheduler, tq_disk;
+extern task_queue tq_timer, tq_immediate, tq_scheduler, tq_disk, tq_bdflush;
 
 /*
  * To implement your own list of active bottom halfs, use the following
diff -wurN -X dontdiff linux-2.2.18/init/main.c linux-2.2.18-swsusp/init/main.c
--- linux-2.2.18/init/main.c	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/init/main.c	Fri Jan 26 04:34:58 2001
@@ -61,6 +61,10 @@
 
 extern int irda_device_init(void);
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+#include <linux/swsusp.h>
+#endif
+
 /*
  * Versions of gcc older than that listed below may actually compile
  * and link okay, but the end product can have subtle run time bugs.
@@ -749,6 +753,9 @@
         { "iucv=", iucv_setup } ,
 #endif
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	{ "noresume", software_noresume },
+#endif
 #ifdef CONFIG_FB
 	{ "video=", video_setup },
 #endif
@@ -1071,6 +1078,9 @@
 
 static struct kernel_param raw_params[] __initdata = {
 	{ "root=", root_dev_setup },
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	{ "resume=", resume_setup },
+#endif
 #ifdef CONFIG_ROOT_NFS
 	{ "nfsroot=", nfs_root_setup },
 	{ "nfsaddrs=", ip_auto_config_setup },
@@ -1623,6 +1633,10 @@
 	/* Mount the root filesystem.. */
 	mount_root();
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	software_resume();
+#endif
+
 #ifdef CONFIG_BLK_DEV_INITRD
 	root_mountflags = real_root_mountflags;
 	if (mount_initrd && ROOT_DEV != real_root_dev
@@ -1663,6 +1677,16 @@
 	(void) dup(0);
 	(void) dup(0);
 	
+#ifdef CONFIG_SOFTWARE_SUSPEND
+#ifdef CONFIG_SMP
+	printk(KERN_WARNING
+	"Software Suspend has a malfunctioning SMP support. Disabled :(\n");
+#else
+	/* We enable the possibility of machine suspend */
+	software_suspend_enabled = 1;
+#endif
+#endif
+
 	/*
 	 * We try each of these until one succeeds.
 	 *
diff -wurN -X dontdiff linux-2.2.18/kernel/Makefile linux-2.2.18-swsusp/kernel/Makefile
--- linux-2.2.18/kernel/Makefile	Wed May  6 19:01:46 1998
+++ linux-2.2.18-swsusp/kernel/Makefile	Fri Jan 26 02:49:54 2001
@@ -25,6 +25,12 @@
 OX_OBJS  += ksyms.o
 endif
 
+ifeq ($(CONFIG_SOFTWARE_SUSPEND),y)
+ O_OBJS += swsusp.o
+ CFLAGS_swsusp.o := -fno-omit-frame-pointer
+ # No gcc-2.95, please!! CC_swsusp.o = /usr/bin/cc
+endif
+
 CFLAGS_sched.o := $(PROFILING) -fno-omit-frame-pointer
 
 include $(TOPDIR)/Rules.make
diff -wurN -X dontdiff linux-2.2.18/kernel/ksyms.c linux-2.2.18-swsusp/kernel/ksyms.c
--- linux-2.2.18/kernel/ksyms.c	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/kernel/ksyms.c	Fri Jan 26 04:36:23 2001
@@ -44,6 +44,9 @@
 #ifdef CONFIG_KMOD
 #include <linux/kmod.h>
 #endif
+#ifdef CONFIG_HWSTATE_RESTORE
+#include <linux/swsusp.h>
+#endif
 
 extern char *get_options(char *str, int *ints);
 extern void set_device_ro(kdev_t dev,int flag);
@@ -438,6 +441,12 @@
 
 /* init task, for moving kthread roots - ought to export a function ?? */
 EXPORT_SYMBOL(init_task_union);
+
+#ifdef CONFIG_HWSTATE_RESTORE
+/* software suspend to swap + restore hardware state */
+EXPORT_SYMBOL(register_suspend_notifier);
+EXPORT_SYMBOL(unregister_suspend_notifier);
+#endif
 
 /* Support for external backtracer */ 
 extern char _stext, _etext;
diff -wurN -X dontdiff linux-2.2.18/kernel/swsusp.c linux-2.2.18-swsusp/kernel/swsusp.c
--- linux-2.2.18/kernel/swsusp.c	Thu Jan  1 01:00:00 1970
+++ linux-2.2.18-swsusp/kernel/swsusp.c	Fri Jan 26 02:42:17 2001
@@ -0,0 +1,1446 @@
+/*
+ * linux/kernel/swsusp.c
+ *
+ * This file is to realize architecture-independent
+ * machine suspend feature using pretty near only high-level routines
+ *
+ * Copyright (C) 1998, 1999 Gabor Kuti <seasons@falcon.sch.bme.hu>
+ * 
+ * Modifications, defectiveness pointing by Pavel Machek <pavel@ucw.cz>:
+ * suspend to swap space (in order not to corrupt filesystem), stop all tasks
+ * so that they can not hold any locks, and so that we no longer need rt
+ * priority, and so that we may sleep when we want to.
+ *
+ * Support the possibility of hardware state restoring by Steve Dodd.
+ *
+ * Support for preserving states of network devices and virtual console
+ * (including X and svgatextmode) by Raph <grey.havens@earthling.net>
+ *
+ * Modifications for 2.2.13 by 1999 Kurt Garloff <garloff@suse.de>, 99-11-16
+ * Also straightened the critical function in order to prevent compilers
+ * from playing tricks with local variables.
+ *
+ * More state savers are welcome. Especially for the scsi layer...
+ *
+ * For TODOs,FIXMEs also look in Documentation/swsusp.tex
+ */
+
+#include <linux/mm.h>
+#include <linux/swapctl.h>
+#include <linux/swsusp.h>
+#include <linux/smp_lock.h>
+#include <linux/file.h>
+#include <linux/utsname.h>
+#include <linux/version.h>
+#include <linux/compile.h>
+#include <linux/delay.h>
+#include <linux/reboot.h>
+#include <linux/init.h>
+#include <linux/locks.h>
+#include <linux/vt_kern.h>
+#include <linux/bitops.h>
+#include <linux/interrupt.h>
+#include <linux/kbd_kern.h>
+#include <linux/keyboard.h>
+
+#if defined (CONFIG_HWSTATE_RESTORE) && defined (CONFIG_APM)
+# include <linux/apm_bios.h>
+extern int              apm_send_event(apm_event_t event, apm_event_t undo,
+                                       void *sender);
+ 
+#endif
+
+#include <asm/spinlock.h>
+#include <asm/uaccess.h>
+#include <asm/mmu_context.h>
+#include <asm/pgtable.h>
+
+/* JMP - 32 is used by pthreads lib.
+#define	SIGSTOP_SUSPEND	SIGSTOP
+ */
+#define SIGRESUME	SIGXCPU
+
+
+unsigned char software_suspend_enabled = 0;
+
+/* TODO: do all include files need to be in the header of this code? */
+
+#define SUSPEND_PARANOIA	1
+#define SUSPEND_CONSOLE	(MAX_NR_CONSOLES-1)
+
+/* XXX: Should this be in include/linux/mm.h?? */
+#define ADDRESS(x) (PAGE_OFFSET + ((x) << PAGE_SHIFT))
+
+/* Timeout for stopping processes */
+#define TIMEOUT	(6 * HZ)
+
+extern void wakeup_bdflush(int);
+
+extern asmlinkage ssize_t sys_read(unsigned int, char *, size_t);
+extern asmlinkage ssize_t sys_write(unsigned int, char *, size_t);
+extern asmlinkage off_t sys_lseek(unsigned int, off_t, unsigned int);
+extern asmlinkage int sys_unlink(const char *);
+extern asmlinkage int sys_sched_yield(void);
+
+extern struct vfsmount *vfsmntlist;
+extern int C_A_D;
+
+/* References to section boundaries */
+extern char _text, _etext, _edata, __bss_start, _end;
+extern char __nosave_begin, __nosave_end;
+
+/* Locks */
+spinlock_t suspend_lock __nosavedata = SPIN_LOCK_UNLOCKED;
+spinlock_t suspend_pagedir_lock __nosavedata = SPIN_LOCK_UNLOCKED;
+
+extern int console_loglevel;
+
+/* Local variables */
+static int new_loglevel = 7;
+static int orig_loglevel = 0;
+
+static int orig_fgconsole;
+
+static int was_in_interrupt;
+
+#ifdef CONFIG_SMP
+static atomic_t num_captured_cpus = ATOMIC_INIT(0);
+static atomic_t smp_recommenced = ATOMIC_INIT(0);
+#endif
+
+#ifdef CONFIG_HWSTATE_RESTORE
+/* maybe move this stuff to a different file one day? */
+static struct notifier_block *suspend_chain = NULL;
+#endif /* CONFIG_HWSTATE_RESTORE */
+
+/* Local variables that should not be affected by save */
+static int resume_status __nosavedata = 0;
+static unsigned int nr_needed_pages __nosavedata = 0;
+static unsigned int nr_copy_pages __nosavedata = 0;
+static suspend_pagedir_t *pagedir __nosavedata = NULL;
+static unsigned long suspend_pagedir;
+static int pagedir_order __nosavedata = 0;
+static struct suspend_stack s_stack;
+
+static struct pbe *pagedir_p = NULL;
+static int loop __nosavedata = 0;
+static int loop2 __nosavedata = 0;
+
+struct link {
+	char dummy[PAGE_SIZE - sizeof(unsigned long)];
+	unsigned long next;
+};
+
+union diskpage {
+	union swap_header swh;
+	struct link link;
+	struct suspend_header sh;
+};
+
+/*
+ * Saving part...
+ */
+
+/*
+ * XXX: We try to keep some more pages free so that I/O operations succeed
+ * without paging. Might this be more?
+ */
+#define PAGES_FOR_IO	32
+
+static const char *name_suspend = "Suspend Machine: ";
+static const char *name_resume = "Resume Machine: ";
+#ifdef CONFIG_HWSTATE_RESTORE
+static const char *fat_warning = "Warning: system is in an undefined state. Watch out.";
+#endif
+
+/*
+ * Debug
+ */
+#define DEBUG_DEFAULT	1
+#define DEBUG_PROCESS	2
+#define DEBUG DEBUG_DEFAULT
+/* | DEBUG_PROCESS */
+#undef DEBUG_SLOW
+
+#if DEBUG & DEBUG_DEFAULT
+#define PRINTD(func, f, a...)	\
+	do { \
+		printk("%s", func); \
+		printk(f, ## a); \
+	} while(0)
+#define PRINTS(f, a...)	PRINTD(name_suspend, f, ## a)
+#define PRINTR(f, a...)	PRINTD(name_resume, f, ## a)
+#define PRINTK(f, a...)	printk(f, ## a)
+#else
+#define PRINTD(func, f, a...)
+#define PRINTS(f, a...)
+#define PRINTR(f, a...)
+#define PRINTK(f, a...)
+#endif
+
+extern int is_head_of_free_region(struct page *);
+static char resume_file[256] = "";
+
+static int ignore_uninterruptible = 0;
+static int stopping_failed = 0;
+
+#define INTERESTING(p) \
+			/* We don't want to touch init & kernel_threads..*/ \
+			if ( p->p_opptr->pid==0 || p->mm==&init_mm ) \
+				continue; \
+			if (p == current) \
+				continue; \
+			if (p->state == TASK_ZOMBIE) \
+				continue; \
+			if (p->state == TASK_UNINTERRUPTIBLE && \
+				ignore_uninterruptible) \
+				continue;
+
+#define	init_flags()	do { \
+				ignore_uninterruptible = 0; \
+				stopping_failed = 0; \
+			} while(0)
+
+/* XXX JMP: could we use get_order() from page.h? */
+static __inline__ int get_bit_order(unsigned int count)
+{
+	int order;
+	
+	order = fls(count);
+	return (order && 1<<(order-1) == count)?order-1:order;
+}
+
+static void do_ignore_uninterruptible(unsigned long unused)
+{
+	ignore_uninterruptible = 1;
+}
+
+static void do_stopping_failed(unsigned long unused)
+{
+	stopping_failed = 1;
+}
+
+/* 0 = success, else # of processes that we failed to stop */
+static int stop_processes(void)
+{
+	int todo;
+	struct task_struct *p;
+	struct timer_list timer_ignore, timer_failed;
+	
+	PRINTS( "Waiting for tasks to stop... " );
+	init_flags();
+	
+	init_timer(&timer_ignore);
+	timer_ignore.expires = TIMEOUT + jiffies;
+	timer_ignore.data = 0;
+	timer_ignore.function = do_ignore_uninterruptible;
+
+	init_timer(&timer_failed);
+	timer_failed.expires = TIMEOUT * 2 + jiffies;
+	timer_failed.data = 0;
+	timer_failed.function = do_stopping_failed;
+
+	add_timer(&timer_ignore);
+	add_timer(&timer_failed);
+	
+	do {
+		todo = 0;
+		read_lock(&tasklist_lock);
+		for_each_task(p) {
+#if DEBUG & DEBUG_PROCESS
+			printk( " %i", p->pid );
+#endif
+			INTERESTING(p);
+#if DEBUG & DEBUG_PROCESS
+			printk( ":" );
+#endif
+
+/* FIXME: JMP - We should mark processes stopped by us, e.g. by using a
+   TASK_STOPPED_SUSPEND flag... if (p->state == TASK_STOPPED_SUSPEND)
+*/
+			if (p->state == TASK_STOPPED)
+				continue;
+#if DEBUG & DEBUG_PROCESS
+			printk( "Y" );
+#endif
+			/* forcing it to be sure */
+			force_sig_info(SIGSTOP, NULL, p);
+			todo++;
+		}
+		read_unlock(&tasklist_lock);
+		sys_sched_yield();
+		schedule();
+		if (stopping_failed) {
+			PRINTK( "\n" );
+			printk(KERN_ERR " stopping tasks failed (%d tasks remaining)\n", todo );
+			return todo; /* Hackayda hack */
+		}
+	} while(todo);
+	
+	del_timer(&timer_ignore);
+	del_timer(&timer_failed);
+	PRINTK( " ook\n" );
+	return 0;
+}
+
+static void continue_processes(void)
+{
+	struct task_struct *p;
+
+	ignore_uninterruptible = 1;
+	PRINTR( "Restarting tasks... " );
+	read_lock(&tasklist_lock);
+	for_each_task(p) {
+#if DEBUG & DEBUG_PROCESS
+		printk( " %i", p->pid );
+#endif
+		INTERESTING(p);
+#if DEBUG & DEBUG_PROCESS
+		printk( ":");
+#endif
+		
+		/*  JMP		if (p->state == TASK_STOPPED_SUSPEND) { */
+		if (p->state == TASK_STOPPED) {
+#if DEBUG & DEBUG_PROCESS
+			printk( "Y" );
+#endif
+			send_sig_info(SIGCONT, NULL, p);
+		}
+		else
+			printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
+	}
+	read_unlock(&tasklist_lock);
+	PRINTK( " done\n" );
+}
+
+static __inline__ int fill_suspend_header(struct suspend_header *sh,
+						unsigned short *swapfile_used)
+{
+	memset((char *)sh, 0, sizeof(*sh));
+
+	sh->version_code = LINUX_VERSION_CODE;
+	sh->num_physpages = num_physpages;
+	strncpy(sh->machine, system_utsname.machine, 8);
+	strncpy(sh->version, system_utsname.version, 20);
+	sh->num_cpus = smp_num_cpus;
+	sh->page_size = PAGE_SIZE;
+	sh->suspend_pagedir = (unsigned long)pagedir;
+	sh->num_pbes = nr_copy_pages;
+	/* TODO: needed? mounted fs' last mounted date comparison
+	 * [so they haven't been mounted since last suspend.
+	 * Maybe it isn't.]
+	 */
+
+	{
+		int i, len;
+		struct swap_info_struct *p = swap_info;
+		char * path, * page = (char *) __get_free_page(GFP_ATOMIC);
+
+		if(!page)
+			return -ENOMEM;
+
+		for(i=0; i < MAX_SWAPFILES; i++, p++) {
+			if(!swapfile_used[i])
+				continue;
+
+			path = d_path(p->swap_file, page, PAGE_SIZE);
+			len = page + PAGE_SIZE - path;
+
+			if(len > SWAP_FILENAME_MAXLENGTH)
+				panic("\nFilename for %s swapfile is too long",path);
+
+			strcpy(sh->swap_location[i].filename,path);
+		}
+
+		free_page((unsigned long) page);
+	}
+	return 0;
+}
+
+/*
+ * This is our sync function. With this solution we probably won't sleep
+ * but that should not be a problem since tasks are stopped..
+ */
+
+static void do_suspend_sync(void)
+{
+	sync_dev(0);
+#ifdef SUSPEND_PARANOIA
+do_suspend_sync:
+	run_task_queue(&tq_disk);
+	if(tq_disk != NULL) {
+		printk(KERN_ERR "Hm, tq_disk is not empty after run_task_queue\n");
+			goto do_suspend_sync;
+	}
+#else
+	run_task_queue(&tq_disk);
+	/*
+	 * XXX: Probably needed because of loop device.. or maybe not..
+	 * (look into sync_old_buffers() in fs/buffer.c)
+	 */
+	run_task_queue(&tq_disk);
+#endif
+}
+
+static void write_suspend_image(void)
+{
+	union diskpage *cur;
+	int i;
+	long entry, prev = 0;
+	int nr_pgdir_pages = SUSPEND_PD_PAGES(nr_copy_pages);
+	union diskpage *buffer = (union diskpage *)get_free_page(GFP_ATOMIC);
+	unsigned short swapfile_used[MAX_SWAPFILES];
+
+	memset((char *)swapfile_used, 0, sizeof(swapfile_used));
+
+	PRINTS( "Writing data to swap (%d pages): ", nr_copy_pages );
+	for (i=0; i<nr_copy_pages; i++) {
+		if (!(i%100))
+			PRINTK( "." );
+		if (!(entry = get_swap_page()))
+			panic("\nNot enough swapspace when writing data" );
+		swapfile_used[SWP_TYPE(entry)] = 1;
+		rw_swap_page_nocache(WRITE, entry, (char *) ((pagedir+i)->address));
+		(pagedir+i)->swap_address = entry;
+	}
+	PRINTK(" done\n");
+	PRINTS( "Writing pagedir (%d pages): ", nr_pgdir_pages);
+	for (i=0; i<nr_pgdir_pages; i++) {
+		cur = (union diskpage *)((char *) pagedir)+i;
+		PRINTK( "." );
+		if (!(entry = get_swap_page()))
+			panic("\nNot enough swapspace when writing pgdir" );
+		swapfile_used[SWP_TYPE(entry)] = 1;
+		cur->link.next = prev;
+		rw_swap_page_nocache(WRITE, entry, (char *) cur );
+		prev = entry;
+	}
+	PRINTK(", header");
+#ifdef SUSPEND_PARANOIA
+	if(sizeof(struct suspend_header) > PAGE_SIZE-sizeof(unsigned long))
+		panic("sizeof(struct suspend_header) too big: %d",
+				sizeof(struct suspend_header));
+#endif
+	if (!(entry = get_swap_page()))
+		panic( "\nNot enough swapspace when writing header" );
+	swapfile_used[SWP_TYPE(entry)] = 1;
+
+	cur = (void *) buffer;
+	if(fill_suspend_header(&cur->sh, swapfile_used))
+		panic("\nOut of memory while writing header");
+		
+	cur->link.next = prev;
+	
+	rw_swap_page_nocache(WRITE, entry, (char *) cur );
+	prev = entry;
+	/*
+	 * If we have more than one swapfiles the one that contains
+	 * the very first block for resuming is marked as SUSP[12]R
+	 * while the other ones are marked as SUSP[12]P. We test it in
+	 * sys_swapon().
+	 */
+	PRINTK( ", signature" );
+	{
+		struct swap_info_struct *p;
+		unsigned long tmp_lock_map;
+		void *save;
+		int i, root_swap;
+		
+		cur = (void *) buffer;
+		root_swap = SWP_TYPE(entry);
+
+		for(i=0,p=swap_info; i < MAX_SWAPFILES; i++,p++) {
+			if(!swapfile_used[i])
+				continue;
+			
+		/* XXX: this is dirty hack to get first page of swap file */
+			entry = SWP_ENTRY(i, 0);
+			save = p->swap_lockmap; 
+			tmp_lock_map = 0;
+			p->swap_lockmap = (void *) &tmp_lock_map;
+		
+			rw_swap_page_nocache(READ, entry, (char *) cur);
+		
+			if ((!memcmp("SWAP-SPACE",cur->swh.magic.magic,10)))
+				strcpy(cur->swh.magic.magic,"SUSP1P....");
+			else if ((!memcmp("SWAPSPACE2",cur->swh.magic.magic,10)))
+				strcpy(cur->swh.magic.magic,"SUSP2P....");
+			else {
+				panic("\nSwapspace is not swapspace (%.10s)\n", 
+				      cur->swh.magic.magic);
+			}
+			if(root_swap != i)
+				goto non_root_swap;
+
+			cur->swh.magic.magic[5]='R'; /* marked as 'root' */
+			cur->link.next = prev;
+non_root_swap:
+
+			tmp_lock_map = 0;
+			rw_swap_page_nocache(WRITE, entry, (char *)buffer);
+			p->swap_lockmap = save;
+		}
+		PRINTK( ", done\n" );
+	}
+#ifdef DEBUG_SLOW
+mdelay(1000);
+#endif
+}
+
+/* if pagedir != NULL it also copies the counted pages */
+/* FIXME: We should only make a copy of data related to kernel segment,
+ * since any process data won't be changed */
+static void count_and_copy_data_pages(void)
+{
+	int chunk_size;
+	nr_copy_pages = 0;
+	
+	pagedir_p = pagedir;
+
+	for(loop = 0; loop < num_physpages; loop++) {
+		if(!PageReserved(mem_map+loop)) {
+			if(PageNosave(mem_map+loop))
+				continue;
+
+			if((chunk_size=is_head_of_free_region(mem_map+loop))!=0) {
+				loop += chunk_size - 1;
+				continue;
+			}
+		} else if(PageReserved(mem_map+loop)) {
+			/*
+			 * This is an ugly workaround for swapper_pg_dir that
+			 * resides in code segment. I hope no other variable
+			 * sits there..
+			 */
+			if (ADDRESS(loop) != (unsigned long)swapper_pg_dir &&
+				(ADDRESS(loop) >= (unsigned long) &_text &&
+				 ADDRESS(loop) < (unsigned long) &_etext)) {
+					continue; /* we don't need codepages */
+			} else if (ADDRESS(loop) >= (unsigned long)
+				&__nosave_begin && ADDRESS(loop) < 
+				(unsigned long)&__nosave_end) {
+					continue;
+			}
+		}
+
+		nr_copy_pages++;
+		if(pagedir_p) {
+			pagedir_p->orig_address = ADDRESS(loop);
+			copy_page(pagedir_p->address, pagedir_p->orig_address);
+			pagedir_p++;
+		}
+	}
+}
+
+static __inline__ void invalidate_one(kdev_t dev)
+{
+	struct super_block *sb = get_super(dev);
+
+	shrink_dcache_sb(sb);
+	invalidate_inodes(sb);
+	invalidate_buffers(dev);
+}
+
+static void invalidate_everything(void)
+{
+	struct vfsmount *mnt;
+
+	for (mnt = vfsmntlist; mnt; mnt = mnt->mnt_next)
+		invalidate_one(mnt->mnt_dev);
+
+}
+
+static void free_suspend_pagedir(unsigned long this_pagedir)
+{
+	struct page *page = mem_map;
+	int i;
+	unsigned long this_pagedir_end = this_pagedir +
+		(PAGE_SIZE << pagedir_order);
+
+	for(i=0; i < num_physpages; i++, page++) {
+		if(!PageTestandClearNosave(page))
+			continue;
+
+		if(ADDRESS(i) >= this_pagedir && ADDRESS(i) < this_pagedir_end)
+			continue; /* old pagedir gets freed in one */
+		
+		free_page(ADDRESS(i));
+	}
+	free_pages(this_pagedir, pagedir_order);
+}
+
+static suspend_pagedir_t *create_suspend_pagedir(int nr_copy_pages)
+{
+	int i;
+	suspend_pagedir_t *pagedir;
+	struct pbe *p;
+	struct page *page;
+
+	pagedir_order = get_bit_order(SUSPEND_PD_PAGES(nr_copy_pages));
+
+	p = pagedir = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+	if(!pagedir)
+		/*
+		 * Whoops, really big problem but however should never occur
+		 */
+		goto no_order;
+
+	page = mem_map + MAP_NR(pagedir);
+	for(i=0; i < 1<<pagedir_order; i++)
+		PageSetNosave(page++);
+		
+	while(nr_copy_pages--) {
+		p->address = __get_free_page(GFP_ATOMIC);
+		if(!p->address)
+			goto pagedir_cleanup;
+		PageSetNosave(mem_map + MAP_NR(p->address));
+		p->orig_address = 0;
+		p++;
+	}
+no_order:
+	return pagedir;
+
+pagedir_cleanup:
+	free_suspend_pagedir((unsigned long) pagedir);
+	pagedir = 0;
+	return 0;
+}
+
+#ifdef CONFIG_HWSTATE_RESTORE
+/* 
+ * FIXME: Maybe this would be better using another signal but table in
+ * asm/signal.h seems to be full for userland .. so use SIGXCPU. I don't know
+ * if pipeing would be safe from here. Tried but I got redefined defines
+ * (because of sys/param.h) (look in asm/signal.h). Can SIGXCPU be used at
+ * all?
+ * .. Ugh, looking at this FIXME I don't remember why the FIFO method
+ * didn't work. That way we didn't need to use any SIGNAL.
+ */
+void __inline__ notify_init(void)
+{
+#if 1
+	struct task_struct *tsk;
+	
+	tsk = find_task_by_pid(1);
+	send_sig_info(SIGRESUME, NULL, tsk);
+
+	/* Waiting for the operation to be done */
+	while(signal_pending(tsk) ||
+	      init_task.next_run != init_task.prev_run )
+		schedule();
+#else
+	struct init_request request;
+	int fd;
+
+	memset(&request, 0, sizeof(&request));
+	request.magic = INIT_MAGIC;
+	request.cmd = INIT_CMD_RESUME;
+	/* FIXME: If we must fall back to this fifo method we should trigger
+	 * an alarm here not to hang in opening INIT_FIFO..
+	 */
+	if((fd=sys_open(INIT_FIFO, O_WRONLY)) >=0 &&
+		write(fd, &request, sizeof(request)) == sizeof(request)) {
+		sys_close(fd);
+	} else
+		PRINTR( "Could not open INIT_FIFO\n" );
+#endif
+}
+#endif
+
+static int prepare_suspend_console(void)
+{
+	orig_loglevel = console_loglevel;
+	console_loglevel = new_loglevel;
+
+	orig_fgconsole = fg_console;
+#ifdef SUSPEND_CONSOLE
+	if(vc_allocate(SUSPEND_CONSOLE))
+	  /* we can't have a free VC for now. Too bad,
+	   * we don't want to mess the screen for now. */
+		return 1;
+
+	set_console (SUSPEND_CONSOLE);
+	if(vt_waitactive(SUSPEND_CONSOLE)) {
+#ifdef SUSPEND_PARANOIA
+		PRINTS("Bummer. Can't switch VCs.");
+		return 1;
+#endif
+	}
+#endif
+#ifdef DEBUG
+	if(was_in_interrupt)
+		printk(KERN_INFO "SysRq: Software Suspend\n");
+#endif
+	return 0;
+}
+
+static void restore_console(void)
+{
+	console_loglevel = orig_loglevel;
+	set_console (orig_fgconsole);
+	return;
+}
+
+#ifdef CONFIG_SMP
+static void prepare_suspend_smp(void)
+{
+	/* Waiting for all other cpus to be captured */
+	while(atomic_read(&num_captured_cpus) != smp_num_cpus - 1)
+		/* nothing */ ;
+}
+#endif
+
+static int prepare_suspend_processes(void)
+{
+	PRINTS( "Stopping processes\n" );
+	if (stop_processes()) {
+		PRINTS( "Not all processes stopped!\n" );
+		continue_processes();
+		return 1;
+	}
+	do_suspend_sync();
+	return 0;
+}
+
+static int prepare_suspend_shrink(void) 
+{
+	PRINTS( "Shrinking memory\n" );
+	shrink_mem();
+	invalidate_everything();
+
+	/* We should sync here so things written to swap are written now */
+	PRINTS( "Syncing disks before copy\n" );
+	do_suspend_sync();
+	count_and_copy_data_pages ();
+#ifdef DEBUG_SLOW
+	mdelay(1000);
+#endif
+	if (nr_copy_pages + PAGES_FOR_IO + freepages.high > nr_free_pages) {
+		PRINTS( "Only %d free pages!\n", nr_free_pages );
+		return 1;
+	}
+	return 0;
+}
+   
+#ifdef CONFIG_HWSTATE_RESTORE
+static int suspend_hardware(void)
+{
+	/* Save the hardware state at the last possible moment */
+	PRINTS( "Saving hardware state\n" );
+	if(notifier_call_chain(&suspend_chain, SYS_SUSPEND, NULL) !=
+			NOTIFY_DONE) {
+#ifdef SUSPEND_PARANOIA
+		PRINTS("Bummer. Someone doesn't want us to suspend.\n" );
+		/*
+		 * FIXME: we should now call the chain with SYS_RESUME, but
+		 * at this point we don't know where it stopped.
+		 * Possible fix: re-implement notifier_call_chain() or something
+                 * similar.
+		 */
+		printk(KERN_ALERT "%s%s\n",name_suspend,fat_warning);
+		return 1;
+#endif
+	}
+	return 0;
+}
+
+static int restore_hardware(void)
+{
+	/* Restore the state of the hardware before the processes wake up */
+	PRINTR( "Restoring hardware state\n" );
+	if(notifier_call_chain(&suspend_chain, SYS_RESUME, NULL) !=
+			NOTIFY_DONE) {
+#ifdef SUSPEND_PARANOIA
+		PRINTR("Bummer. Someone doesn't want us to resume. \n");
+		/*
+		 * FIXME: for the moment, this problem only arises when a
+		 * network device doesn't want to go up again after it went
+		 * down on suspend. We should just bring the interface
+		 * completely down (see net/core/dev.c)
+		 */
+		printk(KERN_ALERT "%s%s\n", name_resume, fat_warning);
+		/* but for the moment, we just (almost) ignore the error */
+#endif
+	}
+	return 0;
+}
+#endif
+
+#define RESUME_MAGIC 0x13579bdf
+static int resume_magic;
+
+/*
+ * Critical section begins here:
+ * 	from now nothing should change in memory.
+ */
+static int suspend_save_image(void)
+{
+	spin_lock_irq(&suspend_pagedir_lock);
+	pagedir = NULL;
+	resume_magic = 0;
+	PRINTS( "/critical section: Counting pages to copy" );
+	count_and_copy_data_pages();	/* just counts */
+	nr_needed_pages = nr_copy_pages + PAGES_FOR_IO + freepages.high;
+	
+	PRINTK(" (pages needed: %d+%d+%d=%d free: %d)\n",nr_copy_pages,PAGES_FOR_IO,freepages.high,nr_needed_pages,nr_free_pages);
+	if(nr_free_pages < nr_needed_pages) {
+		printk(KERN_CRIT "%sCouldn't get enough free pages, on %d pages short\n",name_suspend, nr_needed_pages-nr_free_pages);
+	/* 
+	 * XXX: (Later we might open here a proper sized swapfile to save
+	 * some more pages if possible and to be sure there will be enough
+	 * space for image as well (with pre-occupied swap pages)
+	 */
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+
+	PRINTK( "Alloc pagedir\n" ); 
+	pagedir = create_suspend_pagedir(nr_copy_pages);
+	if(!pagedir) {
+		/* Shouldn't happen */
+		printk(KERN_CRIT "%sCouldn't allocate enough pages\n",name_suspend);
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+	count_and_copy_data_pages();	/* copy */
+	/* As we saved the stack here, we may return from copy_back_pages !!! */
+#if 0
+	if (resume_magic == RESUME_MAGIC) return 0;
+#endif
+
+	spin_unlock_irq(&suspend_pagedir_lock);
+	PRINTS( "/critical section: done (%d pages copied)\n", nr_copy_pages );
+	/*
+	 * End of critical section. From now on, we can write to memory,
+	 * but we should not touch disk. This specially means we must _not_
+	 * touch swap space! Except we must write out our image of course.
+	 */
+
+	write_suspend_image();
+
+	/* Image is saved, call sync & restart machine */
+	PRINTS( "Syncing disks\n" );
+	/* It is important _NOT_ to umount filesystems at this point. We want
+	 * them synced (in case something goes wrong) but we DO not want to mark
+	 * filesystem clean: it is not. (And it does not matter, if we resume
+	 * correctly, we'll mark system clean, anyway.)
+	 */
+	do_suspend_sync();
+	return 0;
+}
+
+void suspend_power_down(void)
+{
+	C_A_D = 0;
+	printk(KERN_EMERG "%sTrying to power down.\n", name_suspend);
+	mdelay(1000);
+	machine_power_off();
+	printk(KERN_EMERG "%sProbably not capable for powerdown. System halted.\n", name_suspend);
+	machine_halt();
+	while (1);
+	/* NOTREACHED */
+}
+
+void suspend_restart(void)
+{
+	C_A_D = 0;
+	printk(KERN_EMERG "%sTrying to reboot.\n", name_suspend);
+	printk(KERN_EMERG "shift_state: %04x\n", shift_state);
+	mdelay(1000);
+	machine_restart(NULL);
+	printk(KERN_EMERG "%sRestart not possible. System halted.\n", name_suspend);
+	machine_halt();
+	while (1);
+	/* NOTREACHED */
+}
+
+#if 0
+void copy_back_pages (void)
+{
+	register int page; register int off;
+	for (page=0; page < nr_copy_pages; page++) {
+		/* FIXME?!: copy_page caused GPF */
+		for (off = 0; off < PAGE_SIZE/sizeof(long); off++)
+			*(((long *)((pagedir+page)->orig_address))+off) =
+				*(((long *)((pagedir+page)->address))+off);
+	}
+	resume_magic = RESUME_MAGIC;
+}
+#endif
+
+static void restore_task(void)
+{
+#ifdef DEBUG_SLOW
+	mdelay(1000);
+#endif
+	PRINTR( "Activating task\n" );
+	activate_context(current);
+	activate_task(current);
+}
+
+/* forward decl */
+static void do_software_suspend(void);
+
+/*
+ * (KG): Since we affect stack here, we make this function as flat and easy
+ * as possible in order to not provoke gcc to use local variables on the stack.
+ * Note that on resume, all (expect nosave) variables will have the state from
+ * the time of writing (suspend_save_image) and the registers (including the
+ * stack pointer, but excluding the instruction pointer) will be loaded with 
+ * the values saved at SAVE_REGISTERS time.
+ */
+static void do_sw_susp_resume(int resume)
+{
+#if DEBUG & DEBUG_PROCESS
+	long local_var;
+	local_var = (long)current->mm;
+#endif
+	if (resume) goto sw_resume; else goto sw_susp;
+sw_susp:
+	mdelay(500); /* time to press the CTRL key */
+	if (prepare_suspend_console() ) goto end;
+#ifdef SMP
+	prepare_suspend_smp ();
+#endif
+	spin_lock(&suspend_lock);
+#if DEBUG & DEBUG_PROCESS
+	PRINTS( "Test local var: %08lx\n", local_var);
+#endif
+	SAVE_REGISTERS(s_stack)
+	pagedir = NULL;
+	if (prepare_suspend_processes() ) goto sw_susp_fail_processes;
+	if (prepare_suspend_shrink() ) goto sw_susp_fail_shrink;
+#ifdef CONFIG_HWSTATE_RESTORE
+	if (suspend_hardware() ) goto sw_susp_fail_shrink;
+#endif
+	if (suspend_save_image() ) goto sw_susp_fail_write;
+#if 0
+	if (resume_magic == RESUME_MAGIC) goto continue_resume;
+#endif
+	if (shift_state & (1 << KG_CTRL))
+		suspend_restart();
+	else
+		suspend_power_down();
+sw_susp_fail_write:
+	printk(KERN_ALERT "%sNoone ever tried this, await armageddon\n", name_suspend);
+	restore_hardware ();
+	mdelay(3000); /* So user can wait and report us messages if armagedon comes :-) */
+sw_susp_fail_shrink:
+	continue_processes ();
+sw_susp_fail_processes:
+	RESTORE_REGISTERS(s_stack)
+	printk(KERN_NOTICE "%sContinuing normal operation\n",name_suspend);
+	goto end;
+
+/*
+ * Final function for resuming: after copying the pages to their original
+ * position, it restores the register state. This is done in process kflushd
+ * otherwise nasty OOPS happens by C-A-D.
+ */
+sw_resume:
+	spin_lock(&suspend_lock);
+	/* Critical section here: noone should touch memory from now */
+	spin_lock_irq(&suspend_pagedir_lock);
+
+	/* This works, because loop and loop2 are nosavedata */
+	for (loop=0; loop < nr_copy_pages; loop++) {
+		/* FIXME?!: copy_page causes GPF */
+		for (loop2=0; loop2 < PAGE_SIZE/sizeof(long); loop2++)
+			*(((long *)((pagedir+loop)->orig_address))+loop2) =
+				*(((long *)((pagedir+loop)->address))+loop2);
+	}
+#if 0
+continue_resume:
+#endif
+	RESTORE_REGISTERS(s_stack)
+#if DEBUG & DEBUG_PROCESS
+	PRINTR( "Test local var: %08lx\n", local_var);
+#endif
+
+	PRINTR( "Freeing prev allocated pagedir\n" );
+	free_suspend_pagedir(suspend_pagedir);
+
+	restore_task ();
+#ifdef CONFIG_HWSTATE_RESTORE
+	restore_hardware();
+	PRINTR( "Restoring with userland programs\n" );
+	notify_init();
+#ifdef CONFIG_APM
+	/* this should make apmd call the apmd_proxy shell script --jsh */
+	apm_send_event (APM_NORMAL_RESUME, 0, NULL);
+#endif
+#endif /* CONFIG_HWSTATE_RESTORE */
+
+	update_screen(fg_console);
+	PRINTR( "Restarting processes\n" );
+	continue_processes();
+
+	suspend_tq.routine = (void *)do_software_suspend;
+	spin_unlock_irq(&suspend_pagedir_lock);
+   
+	goto end;
+
+end:	
+	software_suspend_enabled = 1;
+	PRINTR( "Done\n" );
+#ifdef CONFIG_SMP
+	atomic_set(&smp_recommenced, 1);
+	/* FIXME (KG): The capture CPU threads should be killed */
+#endif
+	restore_console ();
+	spin_unlock(&suspend_lock);
+	return;
+}
+
+/*
+ * This function is triggered using process bdflush. We try to swap out as
+ * much as we can then make a copy of the occupied pages in memory so we can
+ * make a copy of kernel state atomically, the I/O needed by saving won't
+ * bother us anymore.
+ */
+static void do_software_suspend(void)
+{
+	do_sw_susp_resume(0);
+}
+
+static void suspend_restore_data(void)
+{
+	do_sw_susp_resume(1);
+}
+
+#ifdef CONFIG_SMP
+static int capture_cpu(void *unused)
+{
+	/* XXX: this might not be a must..? */
+/*	if(smp_processor_id() == boot_cpu_id) {
+		current->need_resched = 1;
+		schedule();
+	}*/
+
+	atomic_inc(&num_captured_cpus);
+	while (!atomic_read(&smp_recommenced))
+		/* nothing */ ;
+
+	atomic_dec(&num_captured_cpus);
+	return 0;
+}
+
+/*
+ * All processes will be stopped but not kernel threads. So kswapd might
+ * be running (and writing)...This functions forks a thread for all processors
+ * so they're surely idle
+ */
+static void fork_kernel_threads(void)
+{
+	atomic_set(&smp_recommenced, 0);
+	for(loop = smp_num_cpus - 1; loop; loop--)
+		/* XXX: what CLONE is needed here? maybe nothing? */
+		/* XXX: might kernel_thread be called from interrupt? */
+		kernel_thread(capture_cpu, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND);
+}
+#endif
+
+struct tq_struct suspend_tq =
+	{ 0, 0, (void *)(void *)do_software_suspend, 0 };
+
+/*
+ * This is the trigger function, we must queue ourself since we
+ * can be called from interrupt && bdflush context is needed
+ */
+void software_suspend(void)
+{
+	if(!software_suspend_enabled)
+		return;
+
+	was_in_interrupt = in_interrupt();
+	software_suspend_enabled = 0;
+#ifdef CONFIG_SMP
+	fork_kernel_threads();
+#endif
+
+	queue_task(&suspend_tq, &tq_bdflush);
+	wakeup_bdflush(0);
+}
+
+/* More restore stuff */
+
+static void copy_pagedir(suspend_pagedir_t *to, suspend_pagedir_t *from)
+{
+	int i;
+	char *topointer=(char *)to, *frompointer=(char *)from;
+
+	for(i=0; i < 1 << pagedir_order; i++) {
+		copy_page(topointer, frompointer);
+		topointer += PAGE_SIZE;
+		frompointer += PAGE_SIZE;
+	}
+}
+
+#define does_collide(addr)	\
+		does_collide_order(pagedir, addr, 0)
+
+static int does_collide_order(suspend_pagedir_t *pagedir, unsigned long addr,
+		int order)
+{
+	int i;
+	unsigned long addre = addr + (PAGE_SIZE<<order);
+	
+	for(i=0; i < nr_copy_pages; i++)
+		if((pagedir+i)->orig_address >= addr &&
+			(pagedir+i)->orig_address < addre)
+			return 1;
+
+	return 0;
+}
+
+/*
+ * We check here that pagedir & pages it points to won't collide with pages
+ * where we're going to restore from the loaded pages later
+ */
+
+static int check_pagedir(void)
+{
+	int i;
+
+	for(i=0; i < nr_copy_pages; i++) {
+		unsigned long addr;
+do_retry:
+		addr = __get_free_page(GFP_ATOMIC);
+		if(!addr)
+			return -ENOMEM;
+
+		if(does_collide(addr))
+			goto do_retry;
+
+		(pagedir+i)->address = addr;
+	}
+	return 0;
+}
+
+static int relocate_pagedir(suspend_pagedir_t *old_pagedir)
+{
+	int error = 0;
+
+	if(does_collide_order(old_pagedir, (unsigned long)old_pagedir, pagedir_order)) {
+		suspend_pagedir_t *new_pagedir;
+		error = -ENOMEM;
+		
+		new_pagedir = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+		if(!new_pagedir)
+			return error;
+		copy_pagedir(new_pagedir, old_pagedir);
+		error = relocate_pagedir(new_pagedir);
+		free_pages((unsigned long)old_pagedir, pagedir_order);
+	} else
+		pagedir = old_pagedir;
+
+	return error;	
+}
+
+/*
+ * Sanity check if this image makes sense with this kernel/swap context
+ * I really don't think that it's foolproof but more than nothing..
+ */
+
+static void sanity_check_failed(char *reason)
+{
+	printk(KERN_ERR "%s%s\n",name_resume,reason);
+}
+
+static int sanity_check(struct suspend_header *sh)
+{
+	int error = -EPERM;
+	
+	if(sh->version_code != LINUX_VERSION_CODE) {
+		sanity_check_failed("Incorrect kernel version");
+		goto out_check_failed;
+	}
+	if(sh->num_physpages != num_physpages) {
+		sanity_check_failed("Incorrect memory size");
+		goto out_check_failed;
+	}
+	if(strncmp(sh->machine, system_utsname.machine, 8)) {
+		sanity_check_failed("Incorrect machine type");
+		goto out_check_failed;
+	}
+	if(strncmp(sh->version, system_utsname.version, 20)) {
+		sanity_check_failed("Incorrect version");
+		goto out_check_failed;
+	}
+	if(sh->num_cpus != smp_num_cpus) {
+		sanity_check_failed("Incorrect number of cpus");
+		goto out_check_failed;
+	}
+	if(sh->page_size != PAGE_SIZE) {
+		sanity_check_failed("Incorrect PAGE_SIZE");
+		goto out_check_failed;
+	}
+	/* TODO: hardware list check. "Easy"(?): PCI listing checks. */	
+	error = 0;
+	
+out_check_failed:
+	return error;
+}		
+
+int resume_try_to_read(const char * specialfile)
+{
+	unsigned int handles[MAX_SWAPFILES], saved_handle, fixlater[MAX_SWAPFILES];
+	unsigned int n_handle=0; /* the next file to read from */
+	union diskpage *cur;
+	unsigned long next;
+	int i, nr_pgdir_pages, error;
+	mm_segment_t orig_fs;
+	struct suspend_header *sh;
+	
+	cur = (void *) get_free_page(GFP_ATOMIC);
+	if (!cur) {
+		printk( "%sNot enough memory?\n", name_resume );
+		error = -EINVAL;
+		goto resume_read_error;
+	}
+
+	memset((char *)handles, 0, sizeof(handles));
+	memset((char *)fixlater, 0, sizeof(fixlater));
+
+#define OPEN_SWAP(handle, specialfile)	\
+	handle = error = sys_open( specialfile, O_RDWR, 0 ); \
+	if (error == -EROFS)    /* In case of swapfile */ \
+		handle = error = sys_open( specialfile, O_RDONLY, 0 ); \
+	if (handle < 0) \
+		goto resume_read_error;
+#define SEEK \
+	if (next != sys_lseek(handles[n_handle], next, 0)) /* 0 == SEEK_SET */ \
+		goto resume_read_error;
+#define READNEXT \
+	if (PAGE_SIZE != sys_read(handles[n_handle], (char *)cur, PAGE_SIZE)) \
+		goto resume_read_error;		
+#define PREPARENEXT \
+	{	next = cur->link.next; \
+		n_handle = SWP_TYPE(next); \
+                next = SWP_OFFSET(next) * PAGE_SIZE; \
+        }
+
+	orig_fs = get_fs();
+	set_fs(KERNEL_DS);
+	OPEN_SWAP(handles[0], specialfile);
+	
+	error = -EIO;
+	READNEXT;
+
+	if ((!memcmp("SWAP-SPACE",cur->swh.magic.magic,10)) ||
+	    (!memcmp("SWAPSPACE2",cur->swh.magic.magic,10))) {
+		printk(KERN_ERR "%sThis is normal swap space\n", name_resume );
+		error = -EINVAL;
+		goto resume_read_error;
+	}
+
+	next = 0;
+	SEEK;
+	PREPARENEXT; /* We have to read next position before we overwrite it */
+	n_handle = 0;
+
+	if (!memcmp("SUSP1R",cur->swh.magic.magic,6))
+		strcpy(cur->swh.magic.magic,"SWAP-SPACE");
+	else if (!memcmp("SUSP2R",cur->swh.magic.magic,6))
+		strcpy(cur->swh.magic.magic,"SWAPSPACE2");
+	else {
+		panic("%sUnable to find suspended-data signature (%.10s) - misspelled?\n", 
+		      name_resume, cur->swh.magic.magic);
+	}
+	printk( "%sSignature found, resuming\n", name_resume );
+	/* FIXME: we should do this later.. when we have a rw fs
+	 * again after resuming..and for non-root swaps as well
+	 */
+	if (PAGE_SIZE != sys_write(handles[0], (char *)cur, PAGE_SIZE))
+		printk( KERN_WARNING "%sUnable to overwrite signature back\n", name_resume );
+
+	do_suspend_sync();
+#ifdef DEBUG_SLOW
+	mdelay(1000);
+#endif
+
+	SEEK;
+	READNEXT;
+
+	error = -EPERM;
+	sh = &cur->sh;
+	if(sanity_check(sh))
+		goto resume_read_error;
+
+	saved_handle = handles[0];
+	handles[0] = 0;
+	for(i=0; i < MAX_SWAPFILES; i++) {
+		if(!sh->swap_location[i].filename[0])
+			continue;
+		
+		if(!strcmp(sh->swap_location[i].filename, specialfile)) {
+			handles[i] = saved_handle;
+			continue;
+		}
+		OPEN_SWAP(handles[i], sh->swap_location[i].filename);
+	}
+	
+	PREPARENEXT;
+
+	/* FIXME: later also have to take care about 'embedded' swapfiles
+	 * e.g. /dev/hdaX is mounted on /dos and we have a /dos/swapfile
+	 * named swapfile...
+	 */
+	/* Probably this is the same machine */
+	suspend_pagedir = cur->sh.suspend_pagedir;
+	nr_copy_pages = cur->sh.num_pbes;
+	nr_pgdir_pages = SUSPEND_PD_PAGES(nr_copy_pages);
+	pagedir_order = get_bit_order(nr_pgdir_pages);
+
+	error = -ENOMEM;
+	pagedir = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+	if(!pagedir)
+		goto resume_read_error;
+
+	PRINTR( "%sReading pagedir, ", name_resume );
+
+	/* We get pages in reverse order of saving! */
+	error=-EIO;
+	for (i=nr_pgdir_pages-1; i>=0; i--) {
+		if (!next)
+			panic( "Preliminary end of suspended data?" );
+		cur = (union diskpage *)((char *) pagedir)+i;
+		SEEK;
+		READNEXT;
+		PREPARENEXT;
+	}
+	if (next)
+		panic( "Suspended data too long?" );
+
+	if((error=relocate_pagedir(pagedir))!=0)
+		goto resume_read_error;
+	if((error=check_pagedir())!=0)
+		goto resume_read_error;
+
+	PRINTK( "image data (%d pages): ", nr_copy_pages );
+	error = -EIO;
+	for(i=0; i < nr_copy_pages; i++) {
+		unsigned long swap_address = (pagedir+i)->swap_address;
+		
+		if (!(i%100))
+			PRINTK( "." );
+		n_handle = SWP_TYPE (swap_address);
+		next = SWP_OFFSET (swap_address) * PAGE_SIZE;
+		SEEK;
+		if (sys_read(handles[n_handle], (char *)((pagedir+i)->address),PAGE_SIZE)!=PAGE_SIZE)
+			goto resume_read_error;
+	}
+	PRINTK( " done\n" );
+	error = 0;
+
+resume_read_error:
+	for(i=0; i < MAX_SWAPFILES; i++)
+		if(!handles[i])
+			sys_close(handles[i]);
+
+	switch (error) {
+		case 0:
+			printk( "Reading resume file successful\n");
+			break;
+		case -EINVAL:
+			break;
+		case -EIO:
+			printk( "%sI/O error\n", name_resume);
+			break;
+		case -ENOENT:
+			printk( "%s%s: No such file or directory\n",
+				name_resume, specialfile);
+			break;
+		default:
+			printk( "%sError %d resuming\n", name_resume, error );
+	}
+	set_fs(orig_fs);
+	return error;
+}
+
+/*
+ * Called from init kernel_thread.
+ * We check if we have an image and if so we try to recover.
+ */
+
+void software_resume(void)
+{
+	if(!resume_status)
+		return;
+
+	printk( "%s", name_resume );
+	if(resume_status == NORESUME) {
+		printk( "disabled\n" );
+		return;
+	}
+
+	spin_lock(&suspend_lock);
+
+	orig_loglevel = console_loglevel;
+	console_loglevel = new_loglevel;
+
+	if(!resume_file[0] && resume_status == RESUME_SPECIFIED) {
+		printk( "nowhere to resume from\n" );
+		return;
+	}
+
+#ifdef CONFIG_SMP
+	fork_kernel_threads();
+
+	/* Waiting for all other cpus to be captured */
+	while(atomic_read(&num_captured_cpus) < smp_num_cpus - 1)
+		/* nothing */ ;
+#endif
+
+	printk( "resuming from %s\n", resume_file);
+	if(resume_try_to_read(resume_file))
+		goto read_failure;
+
+	suspend_tq.routine = (void *)suspend_restore_data;
+	queue_task(&suspend_tq, &tq_bdflush);
+	wakeup_bdflush(0);
+	schedule();
+	/* NOTREACHED */
+#ifdef SUSPEND_PARANOIA
+	printk(KERN_CRIT "Returned from schedule() -- impossible..\n");
+	while(1);
+#endif
+
+read_failure:
+	console_loglevel = orig_loglevel;
+#ifdef CONFIG_SMP
+	atomic_set(&smp_recommenced, 1);
+#endif
+	spin_unlock(&suspend_lock);
+	return;
+}
+
+
+void resume_setup(char *line, int *num)
+{
+	if(resume_status)
+		return;
+
+	strncpy( resume_file, line, 255 );
+	resume_status = RESUME_SPECIFIED;
+}
+
+void __init software_noresume(char *str, int *ints)
+{
+	if(resume_status)
+		return;
+	
+	resume_status = NORESUME;
+}
+
+#ifdef CONFIG_HWSTATE_RESTORE
+int register_suspend_notifier(struct notifier_block *nb)
+{
+	return notifier_chain_register(&suspend_chain, nb);
+}
+
+int unregister_suspend_notifier(struct notifier_block *nb)
+{
+	return notifier_chain_unregister(&suspend_chain, nb);
+}
+#endif /* CONFIG_HWSTATE_RESTORE */
diff -wurN -X dontdiff linux-2.2.18/kernel/sys.c linux-2.2.18-swsusp/kernel/sys.c
--- linux-2.2.18/kernel/sys.c	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/kernel/sys.c	Fri Dec 29 03:49:19 2000
@@ -4,6 +4,7 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
+#include <linux/config.h>
 #include <linux/mm.h>
 #include <linux/utsname.h>
 #include <linux/mman.h>
@@ -208,6 +209,16 @@
 		printk(KERN_EMERG "Restarting system with command '%s'.\n", buffer);
 		machine_restart(buffer);
 		break;
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	case LINUX_REBOOT_CMD_SW_SUSPEND:
+		if(!software_suspend_enabled)
+			return -EAGAIN;
+		
+		software_suspend();
+		do_exit(0);
+		break;
+#endif
 
 	default:
 		unlock_kernel();
diff -wurN -X dontdiff linux-2.2.18/mm/page_alloc.c linux-2.2.18-swsusp/mm/page_alloc.c
--- linux-2.2.18/mm/page_alloc.c	Mon Sep  4 18:39:28 2000
+++ linux-2.2.18-swsusp/mm/page_alloc.c	Fri Dec 29 03:49:19 2000
@@ -13,6 +13,9 @@
 #include <linux/interrupt.h>
 #include <linux/init.h>
 #include <linux/pagemap.h>
+#ifdef CONFIG_SOFTWARE_SUSPEND
+#include <linux/swsusp.h>
+#endif
 
 #include <asm/dma.h>
 #include <asm/uaccess.h> /* for copy_to/from_user */
@@ -254,6 +257,32 @@
 nopage:
 	return 0;
 }
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+int is_head_of_free_region(struct page *p)
+{
+    /* Added type loop, 11/99 KG */
+    unsigned type;
+    for (type = 0; type < NR_MEM_TYPES; type++) {
+	int order = NR_MEM_LISTS - 1;
+
+	do { 
+	   	struct free_area_struct *area = &(free_area[type][order]);
+		struct page *prev = memory_head(area), *ret = prev->next;
+
+		while (memory_head(area) != ret) { \
+			if (p != ret) {
+				prev = ret;
+				ret = ret->next;
+				continue;
+			}
+			return 1 << order;
+		}
+	} while (order--);
+    }
+    return 0;
+}
+#endif /* CONFIG_SOFTWARE_SUSPEND */
 
 /*
  * Show free area list (used inside shift_scroll-lock stuff)
diff -wurN -X dontdiff linux-2.2.18/mm/swapfile.c linux-2.2.18-swsusp/mm/swapfile.c
--- linux-2.2.18/mm/swapfile.c	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/mm/swapfile.c	Fri Dec 29 03:49:19 2000
@@ -14,6 +14,9 @@
 #include <linux/vmalloc.h>
 #include <linux/pagemap.h>
 #include <linux/shm.h>
+#ifdef CONFIG_SOFTWARE_SUSPEND
+#include <linux/swsusp.h>
+#endif
 
 #include <asm/pgtable.h>
 
@@ -586,6 +589,14 @@
 		swap_header_version = 1;
 	else if (!memcmp("SWAPSPACE2",swap_header->magic.magic,10))
 		swap_header_version = 2;
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	else if(!memcmp("SUSP1R",swap_header->magic.magic,6)||
+		!memcmp("SUSP2R",swap_header->magic.magic,6)) {
+		resume_setup((char *)specialfile, NULL);
+		software_resume();
+		goto bad_swap; /* in case sg goes wrong */
+	}
+#endif
 	else {
 		printk("Unable to find swap-space signature\n");
 		error = -EINVAL;
diff -wurN -X dontdiff linux-2.2.18/mm/vmscan.c linux-2.2.18-swsusp/mm/vmscan.c
--- linux-2.2.18/mm/vmscan.c	Mon Sep  4 18:39:28 2000
+++ linux-2.2.18-swsusp/mm/vmscan.c	Fri Dec 29 03:49:19 2000
@@ -511,3 +511,17 @@
 		}
 	}
 }
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+/*
+ * This tries to free as many pages as it could.
+ * Called by do_software_suspend() in kernel/swsusp.c.
+ */
+void shrink_mem(void)
+{
+	unsigned int gfp_mask = __GFP_WAIT | __GFP_IO;
+
+	while(try_to_free_pages(gfp_mask));
+	return;
+}
+#endif
diff -wurN -X dontdiff linux-2.2.18/net/core/dev.c linux-2.2.18-swsusp/net/core/dev.c
--- linux-2.2.18/net/core/dev.c	Mon Dec 11 00:49:44 2000
+++ linux-2.2.18-swsusp/net/core/dev.c	Fri Dec 29 03:49:19 2000
@@ -94,6 +94,10 @@
 #ifdef CONFIG_NET_RADIO
 #include <linux/wireless.h>
 #endif	/* CONFIG_NET_RADIO */
+#ifdef CONFIG_HWSTATE_RESTORE
+#include <linux/swsusp.h>
+#include <linux/if_arp.h>
+#endif
 #ifdef CONFIG_PLIP
 extern int plip_init(void);
 #endif
@@ -259,6 +263,75 @@
 
 ******************************************************************************************/
 
+#ifdef CONFIG_HWSTATE_RESTORE
+static int dev_event(struct notifier_block *this, 
+		     unsigned long event, void *ptr)
+{
+	struct device *dev;
+	for(dev = dev_base; dev != NULL; dev = dev->next)
+	if (dev->flags & IFF_UP) {
+		int dt = dev->type;
+		switch(event) {
+		case SYS_SUSPEND: 
+			/* we must shut it down. */
+			/* FIXME: I made this after I realized that
+			 * "ifconfig <if> down; ifconfig <if> up" keeps
+			 * all interface params. That is, I assumed that
+			 * hardware-level dev_close() and dev_open()
+			 * keep high-level device parameters UNTOUCHED.
+			 */
+			/* Of course, there are several hardware types
+			 * that cannot shut down properly from here,
+			 * either because they rely on user-space
+			 * programs (ethertap, PPP, SLIP) or because
+			 * hardware state suspending/restoring isn't
+			 * relevant for them (loopback, PPP, shaper).
+			 * FIXME: I don't really know which hardware
+			 * types really need hwstate suspend/restore.
+			 * Add/remove as needed.
+			 */
+			if(dev->stop && (
+			   dt == ARPHRD_ETHER || dt == ARPHRD_EETHER ||
+			   dt == ARPHRD_AX25 || dt == ARPHRD_ARCNET ||
+			   dt == ARPHRD_APPLETLK || dt == ARPHRD_DLCI ||
+			   dt == ARPHRD_IRDA || dt == ARPHRD_LOCALTLK)
+				)
+			{
+				dev->stop(dev);
+				/* XXX: if(dev->start) then ???????? */
+				dev->start = 0; /* for resuming below */
+				/* FIXME: are there any devices there that
+				   reset dev->flags to ~IFF_UP on close ? */
+				   
+			};
+			break;
+		case SYS_RESUME: 
+			if(/* XXX: */ dev->stop && (
+			   dt == ARPHRD_ETHER || dt == ARPHRD_EETHER ||
+	     		   dt == ARPHRD_AX25 || dt == ARPHRD_ARCNET ||
+			   dt == ARPHRD_APPLETLK || dt == ARPHRD_DLCI ||
+			   dt == ARPHRD_IRDA || dt == ARPHRD_LOCALTLK)
+					&&
+			   dev->open && dev->start == 0 ) 
+				if(dev->open(dev))
+					return NOTIFY_BAD;
+			/* note on the previous "XXX": should an
+			 * interface with no dev->close be
+			 * dev->open'ed on resume ?
+			 */
+			break;
+		};
+	};
+	return NOTIFY_DONE;
+};
+
+static struct notifier_block dev_suspend_notifier = {
+	&dev_event,
+	NULL,
+	0
+};
+#endif
+
 /* 
  *	Find an interface by name.
  */
@@ -2113,5 +2186,12 @@
 	ip_auto_config();
 #endif
 
+#ifdef CONFIG_HWSTATE_RESTORE
+	/* FIXME: I really don't know where to put this within the function.
+	 * Perhaps it would be better to put it at the beginning. Or in the
+	 * middle. Please people find out and "fix" this. */
+	register_suspend_notifier(&dev_suspend_notifier);
+#endif
+	
 	return 0;
 }