Index: linuxx/CREDITS
diff -u linuxx/CREDITS:1.1.1.1.6.2 linuxx/CREDITS:1.1.1.1.10.1.4.2
--- linuxx/CREDITS:1.1.1.1.6.2	Fri Dec  6 08:30:14 2002
+++ linuxx/CREDITS	Thu Dec 12 11:57:37 2002
@@ -499,6 +499,14 @@
 S: Fremont, California 94539
 S: USA
 
+N: Florent Chabaud
+E: florent.chabaud@polytechnique.org
+D: software suspend
+S: SGDN/DCSSI/SDS/LTI
+S: 58, Bd Latour-Maubourg
+S: 75700 Paris 07 SP
+S: France
+
 N: Gordon Chaffee
 E: chaffee@cs.berkeley.edu
 W: http://bmrc.berkeley.edu/people/chaffee/
@@ -990,6 +998,13 @@
 S: San Jose, California 95131
 S: USA
 
+N: Nathan Friess
+E: natmanz@shaw.ca
+D: software suspend
+S: 25 Tararidge Close NE
+S: Calgary, Alberta  T3J 2P4
+S: Canada
+
 N: Fernando Fuganti
 E: fuganti@conectiva.com.br
 E: fuganti@netbank.com.br
@@ -1716,6 +1731,11 @@
 S: D-91080 Uttenreuth
 S: Germany
 
+N: Gabor Kuti
+E: seasons@falcon.sch.bme.hu
+E: seasons@makosteszta.sote.hu
+D: software suspend
+
 N: Jaroslav Kysela
 E: perex@suse.cz
 W: http://www.perex.cz
@@ -1888,7 +1908,8 @@
 E: pavel@ucw.cz
 E: pavel@suse.cz
 D: Softcursor for vga, hypertech cdrom support, vcsa bugfix, nbd
-D: sun4/330 port, capabilities for elf, speedup for rm on ext2, USB
+D: sun4/330 port, capabilities for elf, speedup for rm on ext2, USB,
+D: x86-64 port, software suspend
 S: Volkova 1131
 S: 198 00 Praha 9
 S: Czech Republic
Index: linuxx/MAINTAINERS
diff -u linuxx/MAINTAINERS:1.1.1.1.6.3 linuxx/MAINTAINERS:1.1.1.1.6.1.2.1.4.2
--- linuxx/MAINTAINERS:1.1.1.1.6.3	Fri Dec  6 08:30:14 2002
+++ linuxx/MAINTAINERS	Thu Dec 12 11:57:37 2002
@@ -1481,6 +1481,14 @@
 L:	linux-raid@vger.kernel.org
 S:	Maintained
 
+SOFTWARE SUSPEND:
+P:	Pavel Machek
+M:	pavel@suse.cz
+M:	pavel@ucw.cz
+L:	http://lister.fornax.hu/mailman/listinfo/swsusp
+W:	http://swsusp.sf.net/
+S:	Maintained
+
 SONIC NETWORK DRIVER
 P:	Thomas Bogendoerfer
 M:	tsbogend@alpha.franken.de
Index: linuxx/Documentation/Configure.help
diff -u linuxx/Documentation/Configure.help:1.1.1.1.6.2 linuxx/Documentation/Configure.help:1.1.1.1.6.1.2.1.4.1
--- linuxx/Documentation/Configure.help:1.1.1.1.6.2	Fri Nov 29 13:50:32 2002
+++ linuxx/Documentation/Configure.help	Tue Dec  3 10:36:29 2002
@@ -109,6 +109,31 @@
   like MGA monitors that you are very unlikely to see on today's
   systems.
 
+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.
+  
+  This option is about getting stable. However there is still some
+  absence of features.
+
+  For more information take a look at Documentation/swsusp.txt.
+
 Symmetric Multi-Processing support
 CONFIG_SMP
   This enables support for systems with more than one CPU. If you have
Index: linuxx/Documentation/kernel-parameters.txt
diff -u linuxx/Documentation/kernel-parameters.txt:1.1.1.1.6.1 linuxx/Documentation/kernel-parameters.txt:1.1.1.1.10.1.4.1
--- linuxx/Documentation/kernel-parameters.txt:1.1.1.1.6.1	Fri Nov 29 13:50:34 2002
+++ linuxx/Documentation/kernel-parameters.txt	Tue Dec  3 10:36:30 2002
@@ -46,6 +46,7 @@
 	SERIAL	Serial support is enabled.
 	SMP 	The kernel is an SMP kernel.
 	SOUND	Appropriate sound system support is enabled.
+	SWSUSP  Software suspension is enabled.
 	V4L	Video For Linux support is enabled.
 	VGA 	The VGA console has been enabled.
 	VT	Virtual terminal support is enabled.
@@ -401,6 +402,8 @@
 			initial RAM disk.
 
 	nointroute	[IA-64]
+
+	noresume	[SWSUSP] Disables resume and restore original swap space.
  
 	no-scroll	[VGA]
 
@@ -519,6 +522,8 @@
 	reboot=		[BUGS=IA-32]
 
 	reserve=	[KNL,BUGS] force the kernel to ignore some iomem area.
+
+	resume=		[SWSUSP] specify the partition device for software suspension.
 
 	riscom8=	[HW,SERIAL]
 
Index: linuxx/Documentation/swsusp.txt
diff -u /dev/null linuxx/Documentation/swsusp.txt:1.1.6.1
--- /dev/null	Fri Dec 13 18:22:54 2002
+++ linuxx/Documentation/swsusp.txt	Thu Nov 28 20:22:42 2002
@@ -0,0 +1,191 @@
+From kernel/suspend.c:
+
+ * BIG FAT WARNING *********************************************************
+ *
+ * If you have unsupported (*) devices using DMA...
+ *				...say goodbye to your data.
+ *
+ * If you touch anything on disk between suspend and resume...
+ *				...kiss your data goodbye.
+ *
+ * If your disk driver does not support suspend... (IDE does)
+ *				...you'd better find out how to get along
+ *				   without your data.
+ *
+ * (*) pm interface support is needed to make it safe.
+
+You need to append resume=/dev/your_swap_partition to kernel command
+line. Then you suspend by echo "1 0 0" > /proc/sys/kernel/swsusp.
+
+
+The three integers obtained by cat /proc/sys/kernel/swsusp have the
+following meanings:
+State:
+-----
+Always zero on reading. If set to non zero value, cause the
+machine to software suspend (if possible).
+		   bit 0: off = normal state, on = suspend required
+		   bit 1: reserved for future use
+Action:
+------
+The value is an OR of the following flags:
+		   bit 0: off = halt, on = reboot 
+		   bit 1: off = eatmem, on = freemem
+		   bit 2: reserved for future use
+		   bit 3: reserved for future use
+Debug:
+-----
+If compiled with debug enabled in kernel/suspend.c the value is
+an OR of following flags:
+		   bit 0: debugging messages
+		   bit 1: display progression
+		   bit 2: very verbose mode
+		   bit 3: slow down process
+
+		      
+[Notice. Rest docs is pretty outdated (see date!) It should be safe to
+use swsusp on ext3/reiserfs these days.]
+
+
+Article about goals and implementation of Software Suspend for Linux
+Author: Gábor Kuti
+Last revised: 2002-04-08
+
+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>'. Next way is to
+echo 4 > /proc/acpi/sleep.
+
+Either way it saves the state of the machine into active swaps and then
+reboots. You must explicitly specify the swap partition 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. 
+
+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 ``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.
+
+WARNINGS!
+- It does not like pcmcia cards. And this is logical: pcmcia cards need cardmgr to be
+  initialized. they are not initialized during singleuser boot, but "resumed" kernel does
+  expect them to be initialized. That leads to armagedon. You should eject any pcmcia cards
+  before suspending.
+
+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.
+- 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 as well.
+- 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
+
+- If a real time process is running then don't suspend the machine.
+- 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?
+- 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).
+
+Drivers we support
+- IDE disks are okay
+- vesafb
+
+Drivers that need support
+- pc_keyb -- perhaps we can wait for vojtech's input patches
+- do IDE cdroms need some kind of support?
+- IDE CD-RW -- how to deal with that?
+
+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.
+
Index: linuxx/Documentation/sysctl/kernel.txt
diff -u linuxx/Documentation/sysctl/kernel.txt:1.1.1.1 linuxx/Documentation/sysctl/kernel.txt:1.1.1.1.12.1
--- linuxx/Documentation/sysctl/kernel.txt:1.1.1.1	Thu Nov 28 14:06:38 2002
+++ linuxx/Documentation/sysctl/kernel.txt	Thu Nov 28 20:22:42 2002
@@ -39,6 +39,7 @@
 - rtsig-max
 - sg-big-buff                 [ generic SCSI device (sg) ]
 - shmmax                      [ sysv ipc ]
+- swsusp		      ==> Documentation/swsusp.txt
 - tainted
 - version
 - zero-paged                  [ PPC only ]
@@ -219,6 +220,29 @@
 Shared memory segments up to 1Gb are now supported in the 
 kernel.  This value defaults to SHMMAX.
 
+==============================================================
+
+swsusp:
+Three integers:
+State:
+-----
+If set to non zero value, cause the machine to software
+suspend (if possible).
+Action:
+------
+The value is an OR of the following flags:
+		   1: reboot machine after suspension, instead of
+		      halt it.
+		   2: just try to free memory instead of eating
+		      pages to force them to swap.
+Debug:
+-----
+If compiled with debug enabled in kernel/suspend.c the value is
+an OR of the following flags:
+		   1: debugging messages,
+		   2: adding delays to
+		      slow down suspension and be able to read
+		      all messages.
 ==============================================================
 
 tainted: 
Index: linuxx/Documentation/x86_64/mm.txt
diff -u linuxx/arch/i386/config.in:1.1.1.1.6.2 linuxx/arch/i386/config.in:1.1.1.1.6.1.2.1.4.1
--- linuxx/arch/i386/config.in:1.1.1.1.6.2	Fri Nov 29 13:50:58 2002
+++ linuxx/arch/i386/config.in	Tue Dec  3 10:36:34 2002
@@ -297,6 +297,10 @@
 
 bool 'Power Management support' CONFIG_PM
 
+if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
+   dep_bool 'Software Suspend' CONFIG_SOFTWARE_SUSPEND $CONFIG_PM
+fi
+
 dep_tristate '  Advanced Power Management BIOS support' CONFIG_APM $CONFIG_PM
 if [ "$CONFIG_APM" != "n" ]; then
    bool '    Ignore USER SUSPEND' CONFIG_APM_IGNORE_USER_SUSPEND
Index: linuxx/arch/i386/defconfig
diff -u linuxx/arch/i386/defconfig:1.1.1.1.6.1 linuxx/arch/i386/defconfig:1.1.1.1.10.1.4.1
--- linuxx/arch/i386/defconfig:1.1.1.1.6.1	Fri Nov 29 13:50:58 2002
+++ linuxx/arch/i386/defconfig	Tue Dec  3 10:36:34 2002
@@ -109,6 +109,7 @@
 CONFIG_BINFMT_MISC=y
 CONFIG_PM=y
 # CONFIG_APM is not set
+# CONFIG_SOFTWARE_SUSPEND is not set
 
 #
 # Memory Technology Devices (MTD)
Index: linuxx/arch/i386/vmlinux.lds
diff -u linuxx/arch/i386/vmlinux.lds:1.1.1.1 linuxx/arch/i386/vmlinux.lds:1.1.1.1.12.1
--- linuxx/arch/i386/vmlinux.lds:1.1.1.1	Thu Nov 28 14:06:40 2002
+++ linuxx/arch/i386/vmlinux.lds	Thu Nov 28 20:22:43 2002
@@ -53,6 +53,12 @@
   __init_end = .;
 
   . = ALIGN(4096);
+  __nosave_begin = .;
+  .data_nosave : { *(.data.nosave) }
+  . = ALIGN(4096);
+  __nosave_end = .;
+
+  . = ALIGN(4096);
   .data.page_aligned : { *(.data.idt) }
 
   . = ALIGN(32);
Index: linuxx/arch/i386/kernel/apm.c
diff -u linuxx/arch/i386/kernel/apm.c:1.1.1.1.6.1 linuxx/arch/i386/kernel/apm.c:1.1.1.1.10.1.4.1
--- linuxx/arch/i386/kernel/apm.c:1.1.1.1.6.1	Fri Nov 29 13:50:59 2002
+++ linuxx/arch/i386/kernel/apm.c	Tue Dec  3 10:36:34 2002
@@ -1653,6 +1653,7 @@
 	daemonize();
 
 	strcpy(current->comm, "kapmd");
+	current->flags |= PF_IOTHREAD;
 	sigfillset(&current->blocked);
 
 #ifdef CONFIG_SMP
Index: linuxx/arch/i386/kernel/mtrr.c
diff -u linuxx/arch/i386/kernel/mtrr.c:1.1.1.1 linuxx/arch/i386/kernel/mtrr.c:1.1.1.1.12.1.4.1
--- linuxx/arch/i386/kernel/mtrr.c:1.1.1.1	Thu Nov 28 14:06:40 2002
+++ linuxx/arch/i386/kernel/mtrr.c	Tue Dec  3 20:21:45 2002
@@ -270,6 +270,7 @@
 #include <linux/init.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
+#include <linux/suspend.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -2296,6 +2297,67 @@
     init_table ();
     return 0;
 }   /*  End Function mtrr_init  */
+
+#ifdef SOFTWARE_SUSPEND_MTRR
+struct mtrr_suspend_state
+{
+     mtrr_type ltype;
+     unsigned long lbase, lsize;
+};
+/* We return a pointer ptr on an area of *ptr bytes
+   beginning at ptr+sizeof(int)
+   This buffer has to be saved in some way during suspension */
+int *mtrr_suspend(void)
+{
+     int i, max, len;
+     int *ptr;
+     static struct mtrr_suspend_state *mtrr_suspend_buffer=NULL;
+     
+     max = get_num_var_ranges ();
+     if(!mtrr_suspend_buffer)
+     {
+	  len = max * sizeof (struct mtrr_suspend_state) + sizeof(int);
+	  ptr = kmalloc (len, GFP_KERNEL);
+	  if (ptr == NULL)
+	       return(NULL);
+	  *ptr = len;
+	  ptr++;
+	  mtrr_suspend_buffer = (struct mtrr_suspend_state *)ptr;
+	  ptr--;
+     }
+     for (i = 0; i < max; ++i,mtrr_suspend_buffer++)
+	  (*get_mtrr) (i,
+		       &(mtrr_suspend_buffer->lbase),
+		       &(mtrr_suspend_buffer->lsize),
+		       &(mtrr_suspend_buffer->ltype));
+     return(ptr);
+}
+
+/* We restore mtrrs from buffer ptr */
+int mtrr_resume(int *ptr)
+{
+     int i, max, len;
+     struct mtrr_suspend_state *mtrr_suspend_buffer;
+     
+     max = get_num_var_ranges ();
+     len = max * sizeof (struct mtrr_suspend_state) + sizeof(int);
+     if(*ptr != len)
+     {
+	  printk ("mtrr: Resuming failed due to different number of MTRRs\n");
+	  return (-1);
+     }
+     ptr++;
+     mtrr_suspend_buffer=(struct mtrr_suspend_state *)ptr;
+     for (i = 0; i < max; ++i,mtrr_suspend_buffer++)     
+	  if (mtrr_suspend_buffer->lsize)	  
+	       set_mtrr(i,
+			mtrr_suspend_buffer->lbase,
+			mtrr_suspend_buffer->lsize,
+			mtrr_suspend_buffer->ltype);
+}
+EXPORT_SYMBOL(mtrr_suspend);
+EXPORT_SYMBOL(mtrr_resume);
+#endif
 
 /*
  * Local Variables:
Index: linuxx/arch/i386/kernel/process.c
diff -u linuxx/arch/i386/kernel/process.c:1.1.1.1 linuxx/arch/i386/kernel/process.c:1.1.1.1.12.1
--- linuxx/arch/i386/kernel/process.c:1.1.1.1	Thu Nov 28 14:06:40 2002
+++ linuxx/arch/i386/kernel/process.c	Thu Nov 28 20:22:43 2002
@@ -739,6 +739,36 @@
 	}
 }
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+/**
+ *	swsusp_power_off	-	ask the BIOS to power off
+ *
+ *	Handle the power off sequence. This is the one piece of code we
+ *	will execute even on SMP machines. In order to deal with BIOS
+ *	bugs we support real mode APM BIOS power off calls. We also make
+ *	the SMP call on CPU0 as some systems will only honour this call
+ *	on their first cpu.
+ *
+ *	This piece of code is extracted from apm.c. We want to be able
+ *	to do this even if apm isn't activated.
+ */
+ 
+void swsusp_power_off(void)
+{
+	unsigned char	po_bios_call[] = {
+		0xb8, 0x00, 0x10,	/* movw  $0x1000,ax  */
+		0x8e, 0xd0,		/* movw  ax,ss       */
+		0xbc, 0x00, 0xf0,	/* movw  $0xf000,sp  */
+		0xb8, 0x07, 0x53,	/* movw  $0x5307,ax  */
+		0xbb, 0x01, 0x00,	/* movw  $0x0001,bx  */
+		0xb9, 0x03, 0x00,	/* movw  $0x0003,cx  */
+		0xcd, 0x15		/* int   $0x15       */
+	};
+
+	machine_real_restart(po_bios_call, sizeof(po_bios_call));
+}
+#endif
+
 asmlinkage int sys_fork(struct pt_regs regs)
 {
 	return do_fork(SIGCHLD, regs.esp, &regs, 0);
Index: linuxx/arch/i386/kernel/signal.c
diff -u linuxx/arch/i386/kernel/signal.c:1.1.1.1 linuxx/arch/i386/kernel/signal.c:1.1.1.1.12.1
--- linuxx/arch/i386/kernel/signal.c:1.1.1.1	Thu Nov 28 14:06:40 2002
+++ linuxx/arch/i386/kernel/signal.c	Thu Nov 28 20:22:43 2002
@@ -20,6 +20,7 @@
 #include <linux/stddef.h>
 #include <linux/tty.h>
 #include <linux/personality.h>
+#include <linux/suspend.h>
 #include <asm/ucontext.h>
 #include <asm/uaccess.h>
 #include <asm/i387.h>
@@ -595,6 +596,11 @@
 	if ((regs->xcs & 3) != 3)
 		return 1;
 
+	if (current->flags & PF_FREEZE) {
+		refrigerator(0);
+		goto no_signal;
+	}
+
 	if (!oldset)
 		oldset = &current->blocked;
 
@@ -702,6 +708,7 @@
 		return 1;
 	}
 
+ no_signal:
 	/* Did we come from a system call? */
 	if (regs->orig_eax >= 0) {
 		/* Restart the system call - no handlers present */
Index: linuxx/drivers/acpi/system.c
diff -u linuxx/drivers/acpi/system.c:1.1.2.1 linuxx/drivers/acpi/system.c:1.1.2.1.2.1
--- linuxx/drivers/acpi/system.c:1.1.2.1	Thu Nov 28 18:51:46 2002
+++ linuxx/drivers/acpi/system.c	Thu Nov 28 20:22:48 2002
@@ -45,6 +45,7 @@
 #include <linux/mc146818rtc.h>
 #endif
 #endif
+#include <linux/suspend.h>
 
 
 #define _COMPONENT		ACPI_SYSTEM_COMPONENT
@@ -110,7 +111,11 @@
 	acpi_status status;
 
 	/* only support S1 and S5 on kernel 2.4 */
+#ifdef CONFIG_SOFTWARE_SUSPEND	/* unless you use software suspend ;-) */
+	if (state != ACPI_STATE_S1 && state != ACPI_STATE_S4 && state != ACPI_STATE_S5)
+#else
 	if (state != ACPI_STATE_S1 && state != ACPI_STATE_S5)
+#endif
 		return AE_ERROR;
 
 	acpi_enter_sleep_state_prep(state);
@@ -120,6 +125,12 @@
 	ACPI_FLUSH_CPU_CACHE();
 
 	/* perform OS-specific sleep actions */
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	if(state == ACPI_STATE_S4) {
+		software_suspend_pending(); /* when we return, this is resume */
+		status = AE_OK;
+	} else
+#endif
 	status = acpi_enter_sleep_state(state);
 
 	/* Even if we failed to go to sleep, all of the devices are in an suspended
@@ -1014,6 +1025,9 @@
 	}
 	printk(")\n");
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+       system->states[4] = 1;
+#endif
 #ifdef CONFIG_PM
 	/* Install the soft-off (S5) handler. */
 	if (system->states[ACPI_STATE_S5]) {
Index: linuxx/drivers/block/ll_rw_blk.c
diff -u linuxx/drivers/block/ll_rw_blk.c:1.1.1.1.6.1 linuxx/drivers/block/ll_rw_blk.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/block/ll_rw_blk.c:1.1.1.1.6.1	Fri Nov 29 13:52:28 2002
+++ linuxx/drivers/block/ll_rw_blk.c	Tue Dec  3 10:37:11 2002
@@ -1110,6 +1110,9 @@
  * particular, no other flags, are changed by generic_make_request or
  * any lower level drivers.
  * */
+#if 0
+kdev_t suspend_device;
+#endif
 void generic_make_request (int rw, struct buffer_head * bh)
 {
 	int major = MAJOR(bh->b_rdev);
@@ -1119,6 +1122,10 @@
 	if (!bh->b_end_io)
 		BUG();
 
+#if 0
+	if (suspend_device && (bh->b_rdev != suspend_device))
+		panic("Attempted to corrupt disk.");
+#endif
 	/* Test device size, when known. */
 	if (blk_size[major])
 		minorsize = blk_size[major][MINOR(bh->b_rdev)];
Index: linuxx/drivers/block/loop.c
diff -u linuxx/drivers/block/loop.c:1.1.1.1.6.1 linuxx/drivers/block/loop.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/block/loop.c:1.1.1.1.6.1	Fri Nov 29 13:52:28 2002
+++ linuxx/drivers/block/loop.c	Tue Dec  3 10:37:11 2002
@@ -71,6 +71,7 @@
 #include <linux/smp_lock.h>
 #include <linux/swap.h>
 #include <linux/slab.h>
+#include <linux/suspend.h>
 
 #include <asm/uaccess.h>
 
@@ -579,7 +580,9 @@
 	atomic_inc(&lo->lo_pending);
 	spin_unlock_irq(&lo->lo_lock);
 
-	current->flags |= PF_NOIO;
+	current->flags |= PF_NOIO | PF_IOTHREAD; /* loop can be used in an encrypted device
+						    hence, it mustn't be stopped at all because it could
+						    be indirectly used during suspension */
 
 	/*
 	 * up sem, we are running
Index: linuxx/drivers/char/console.c
diff -u linuxx/drivers/char/console.c:1.1.1.1.6.1 linuxx/drivers/char/console.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/char/console.c:1.1.1.1.6.1	Fri Nov 29 13:52:30 2002
+++ linuxx/drivers/char/console.c	Tue Dec  3 10:37:12 2002
@@ -147,11 +147,11 @@
 static void blank_screen(unsigned long dummy);
 static void gotoxy(int currcons, int new_x, int new_y);
 static void save_cur(int currcons);
-static void reset_terminal(int currcons, int do_clear);
+void reset_terminal(int currcons, int do_clear);
 static void con_flush_chars(struct tty_struct *tty);
 static void set_vesa_blanking(unsigned long arg);
 static void set_cursor(int currcons);
-static void hide_cursor(int currcons);
+void hide_cursor(int currcons);
 static void unblank_screen_t(unsigned long dummy);
 static void console_callback(void *ignored);
 
@@ -522,7 +522,7 @@
 		sw->con_putc(vc_cons[currcons].d, i, y, x);
 }
 
-static void hide_cursor(int currcons)
+void hide_cursor(int currcons)
 {
 	if (currcons == sel_cons)
 		clear_selection();
@@ -1389,7 +1389,7 @@
 	ESpalette };
 
 /* console_sem is held (except via vc_init()) */
-static void reset_terminal(int currcons, int do_clear)
+void reset_terminal(int currcons, int do_clear)
 {
 	top		= 0;
 	bottom		= video_num_lines;
@@ -3020,6 +3020,8 @@
 EXPORT_SYMBOL(vc_resize);
 EXPORT_SYMBOL(fg_console);
 EXPORT_SYMBOL(console_blank_hook);
+EXPORT_SYMBOL(hide_cursor);
+EXPORT_SYMBOL(reset_terminal);
 #ifdef CONFIG_VT
 EXPORT_SYMBOL(vt_cons);
 #endif
Index: linuxx/drivers/char/agp/agpgart_be.c
diff -u linuxx/drivers/char/agp/agpgart_be.c:1.1.1.1.6.1 linuxx/drivers/char/agp/agpgart_be.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/char/agp/agpgart_be.c:1.1.1.1.6.1	Fri Nov 29 13:52:35 2002
+++ linuxx/drivers/char/agp/agpgart_be.c	Tue Dec  3 10:37:15 2002
@@ -623,6 +623,7 @@
 
 static void agp_generic_resume(void)
 {
+  	agp_bridge.configure();
 	return;
 }
 
@@ -1791,11 +1792,6 @@
 	return addr | agp_bridge.masks[0].mask;
 }
 
-static void intel_resume(void)
-{
-	intel_configure();
-}
-
 /* Setup function */
 static gatt_mask intel_generic_masks[] =
 {
@@ -1863,7 +1859,7 @@
 	agp_bridge.agp_alloc_page = agp_generic_alloc_page;
 	agp_bridge.agp_destroy_page = agp_generic_destroy_page;
 	agp_bridge.suspend = agp_generic_suspend;
-	agp_bridge.resume = intel_resume;
+	agp_bridge.resume = agp_generic_resume;
 	agp_bridge.cant_use_aperture = 0;
 
 	return 0;
Index: linuxx/drivers/ide/hd.c
diff -u linuxx/drivers/ide/hd.c:1.1.1.1 linuxx/drivers/ide/hd.c:1.1.1.1.12.1
--- linuxx/drivers/ide/hd.c:1.1.1.1	Thu Nov 28 14:07:05 2002
+++ linuxx/drivers/ide/hd.c	Thu Nov 28 20:22:50 2002
@@ -346,6 +346,13 @@
 		hd_request();
 }
 
+void do_reset_hd(void)
+{
+	DEVICE_INTR = NULL;
+	reset = 1;
+	reset_hd();
+}
+
 /*
  * Ok, don't know what to do with the unexpected interrupts: on some machines
  * doing a reset and a retry seems to result in an eternal loop. Right now I
Index: linuxx/drivers/ide/ide-disk.c
diff -u linuxx/drivers/ide/ide-disk.c:1.1.1.1.6.1 linuxx/drivers/ide/ide-disk.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/ide/ide-disk.c:1.1.1.1.6.1	Fri Nov 29 13:52:40 2002
+++ linuxx/drivers/ide/ide-disk.c	Tue Dec  3 10:37:19 2002
@@ -62,6 +62,8 @@
 #define IS_PDC4030_DRIVE (0)	/* auto-NULLs out pdc4030 code */
 #endif
 
+static int driver_blocked = 0;
+
 #ifdef CONFIG_IDE_TASKFILE_IO
 #  undef __TASKFILE__IO /* define __TASKFILE__IO */
 #else /* CONFIG_IDE_TASKFILE_IO */
@@ -558,6 +560,8 @@
  */
 static ide_startstop_t do_rw_disk (ide_drive_t *drive, struct request *rq, unsigned long block)
 {
+	if (driver_blocked)
+		panic("Request while ide driver is blocked?");
 	if (IDE_CONTROL_REG)
 		OUT_BYTE(drive->ctl,IDE_CONTROL_REG);
 
@@ -1548,6 +1552,66 @@
 	ide_register_module(&idedisk_module);
 	MOD_DEC_USE_COUNT;
 	return 0;
+}
+
+void panic_box(void)
+{
+	panic("Attempted to corrupt something: ide operation was pending accross suspend/resume.\n");
+}
+
+int ide_disks_busy(void)
+{
+	int i;
+	for (i=0; i<MAX_HWIFS; i++)
+		if(ide_hwifs[i].present) { /* when using pcmcia ide-disk hwgroup is non NULL but the
+					      disk can be absent */
+			struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+			if (!hwgroup) continue;
+			if ((hwgroup->handler) && (hwgroup->handler != panic_box)) {
+				printk("ide_disks_busy: %6s: handler not null: %p\n",
+				       ide_hwifs[i].name,hwgroup->handler);
+				return 1;
+			}
+		}
+	return 0;
+}
+
+void ide_disk_suspend(void)
+{
+	int i;
+	while (ide_disks_busy()) {
+		printk("*");
+		schedule();
+	}
+	for (i=0; i<MAX_HWIFS; i++)
+		if(ide_hwifs[i].present) { /* when using pcmcia ide-disk hwgroup is non NULL but the
+					      disk can be absent */		
+			struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+
+			if (!hwgroup) continue;
+			hwgroup->handler = panic_box;
+		}
+	driver_blocked = 1;
+	if (ide_disks_busy())
+		panic("How did you get that request through?!");
+}
+
+void ide_disk_unsuspend(void)
+{
+	int i;
+	for (i=0; i<MAX_HWIFS; i++)
+		if(ide_hwifs[i].present) { /* when using pcmcia ide-disk hwgroup is non NULL but the
+					      disk can be absent */
+
+			struct hwgroup_s *hwgroup = ide_hwifs[i].hwgroup;
+
+			if (!hwgroup) continue;
+			if (hwgroup->handler != panic_box)
+				panic("ide_disk_unsuspend: %6s: Handler was not set to panic? %p",
+				      ide_hwifs[i].name,hwgroup->handler);
+			hwgroup->handler = NULL;
+		}
+	driver_blocked = 0;
 }
 
 module_init(idedisk_init);
Index: linuxx/drivers/md/md.c
diff -u linuxx/drivers/md/md.c:1.1.1.1.6.1 linuxx/drivers/md/md.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/md/md.c:1.1.1.1.6.1	Fri Nov 29 13:52:47 2002
+++ linuxx/drivers/md/md.c	Tue Dec  3 10:37:24 2002
@@ -3352,7 +3352,6 @@
 	struct md_list_head *tmp;
 	unsigned long last_check;
 
-
 	err = down_interruptible(&mddev->resync_sem);
 	if (err)
 		goto out_nolock;
@@ -3515,6 +3514,8 @@
 	mdp_disk_t *spare;
 	struct md_list_head *tmp;
 
+	current->flags |= PF_IOTHREAD;
+
 	printk(KERN_INFO "md: recovery thread got woken up ...\n");
 restart:
 	ITERATE_MDDEV(mddev,tmp) {
@@ -3721,6 +3722,15 @@
 		detected_devices[dev_cnt++] = dev;
 }
 
+void md_autostart_arrays(void)
+{
+  	struct md_list_head *tmp;
+	mddev_t *mddev;
+	
+	autostart_arrays();
+	ITERATE_MDDEV(mddev, tmp)
+  		restart_array(mddev);
+}
 
 static void autostart_arrays(void)
 {
@@ -4051,4 +4061,5 @@
 MD_EXPORT_SYMBOL(mddev_map);
 MD_EXPORT_SYMBOL(md_check_ordering);
 MD_EXPORT_SYMBOL(get_spare);
+MD_EXPORT_SYMBOL(md_autostart_arrays);
 MODULE_LICENSE("GPL");
Index: linuxx/drivers/md/raid1.c
diff -u linuxx/drivers/md/raid1.c:1.1.1.1.6.1 linuxx/drivers/md/raid1.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/md/raid1.c:1.1.1.1.6.1	Fri Nov 29 13:52:47 2002
+++ linuxx/drivers/md/raid1.c	Tue Dec  3 10:37:24 2002
@@ -1161,6 +1161,7 @@
 	mddev_t *mddev = conf->mddev;
 	kdev_t dev;
 
+	current->flags |= PF_IOTHREAD;
 	if (mddev->sb_dirty)
 		md_update_sb(mddev);
 
@@ -1286,6 +1287,8 @@
 {
 	raid1_conf_t *conf = data;
 	mddev_t *mddev = conf->mddev;
+
+	current->flags |= PF_IOTHREAD;
 
 	if (!conf->resync_mirrors)
 		return;
Index: linuxx/drivers/md/raid5.c
diff -u linuxx/drivers/md/raid5.c:1.1.1.1 linuxx/drivers/md/raid5.c:1.1.1.1.12.1
--- linuxx/drivers/md/raid5.c:1.1.1.1	Thu Nov 28 14:07:09 2002
+++ linuxx/drivers/md/raid5.c	Thu Nov 28 20:22:50 2002
@@ -1291,6 +1291,8 @@
 
 	PRINTK("+++ raid5d active\n");
 
+	current->flags |= PF_IOTHREAD;
+
 	handled = 0;
 
 	if (mddev->sb_dirty)
@@ -1339,6 +1341,8 @@
 {
 	raid5_conf_t *conf = data;
 	mddev_t *mddev = conf->mddev;
+
+	current->flags |= PF_IOTHREAD;
 
 	if (!conf->resync_parity)
 		return;
Index: linuxx/drivers/net/8139too.c
diff -u linuxx/drivers/net/8139too.c:1.1.1.1.6.1 linuxx/drivers/net/8139too.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/net/8139too.c:1.1.1.1.6.1	Fri Nov 29 13:52:50 2002
+++ linuxx/drivers/net/8139too.c	Tue Dec  3 10:37:26 2002
@@ -109,6 +109,7 @@
 #include <linux/ethtool.h>
 #include <linux/mii.h>
 #include <linux/completion.h>
+#include <linux/suspend.h>
 #include <linux/crc32.h>
 #include <asm/io.h>
 #include <asm/uaccess.h>
@@ -1596,6 +1597,8 @@
 	while (1) {
 		timeout = next_tick;
 		do {
+			if (current->flags & PF_FREEZE)
+				refrigerator(PF_IOTHREAD);
 			timeout = interruptible_sleep_on_timeout (&tp->thr_wait, timeout);
 		} while (!signal_pending (current) && (timeout > 0));
 
Index: linuxx/drivers/net/pcnet32.c
diff -u linuxx/drivers/net/pcnet32.c:1.1.1.1.6.1 linuxx/drivers/net/pcnet32.c:1.1.1.1.12.1.4.1
--- linuxx/drivers/net/pcnet32.c:1.1.1.1.6.1	Fri Nov 29 13:52:54 2002
+++ linuxx/drivers/net/pcnet32.c	Tue Dec  3 10:37:29 2002
@@ -323,6 +323,9 @@
 	mii:1;				/* mii port available */
     struct net_device	*next;
     struct mii_if_info mii_if;
+#ifdef CONFIG_PM
+    u32 pm_state[16];
+#endif
     struct timer_list	watchdog_timer;
 };
 
@@ -1673,6 +1676,42 @@
     return -EOPNOTSUPP;
 }
 
+#ifdef CONFIG_PM
+static int pcnet32_suspend(struct pci_dev *pdev, u32 state)
+{
+	struct net_device *dev = pci_get_drvdata (pdev);
+	struct pcnet32_private *pc = (struct pcnet32_private *)dev->priv;
+
+	//printk("Suspending pcnet32...\n");
+#if 0
+	pci_save_state(pdev, pc->pm_state);
+	if (!netif_running(dev))
+		return 0;
+	netif_device_detach(dev);
+#endif
+	return 0;
+}
+
+static int pcnet32_resume(struct pci_dev *pdev)
+{
+	struct net_device *dev = pci_get_drvdata (pdev);
+	struct pcnet32_private *pc = (struct pcnet32_private *)dev->priv;
+
+	//printk("Resuming pcnet32...\n");
+#if 0
+	pci_restore_state(pdev, pc->pm_state);
+
+	if (!netif_running(dev))
+		return 0;
+
+	pcnet32_restart(dev,0x0042); /* based upon pcnet32_tx_timeout */
+	netif_device_attach(dev);
+	/*set_rx_mode(dev);  does that come from eepro100 ? */
+#endif
+	return 0;
+}
+#endif
+					    
 static void pcnet32_watchdog(struct net_device *dev)
 {
     struct pcnet32_private *lp = dev->priv;
@@ -1688,6 +1727,10 @@
     name:	DRV_NAME,
     probe:	pcnet32_probe_pci,
     id_table:	pcnet32_pci_tbl,
+#ifdef CONFIG_PM
+    suspend:	pcnet32_suspend,
+    resume:	pcnet32_resume
+#endif
 };
 
 MODULE_PARM(debug, "i");
Index: linuxx/drivers/net/via-rhine.c
diff -u linuxx/drivers/net/via-rhine.c:1.1.1.1.6.1 linuxx/drivers/net/via-rhine.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/net/via-rhine.c:1.1.1.1.6.1	Fri Nov 29 13:52:54 2002
+++ linuxx/drivers/net/via-rhine.c	Tue Dec  3 10:37:30 2002
@@ -1792,12 +1792,40 @@
 	pci_set_drvdata(pdev, NULL);
 }
 
+#ifdef CONFIG_PM
+static int via_rhine_suspend(struct pci_dev *pdev, u32 state)
+{
+	printk("Suspending via_rhine...\n");
+#if 0
+	via_rhine_remove_one(pdev);
+#endif
+	return 0;
+}
+
+static int via_rhine_resume(struct pci_dev *pdev)
+{
+	long ioaddr;
+	
+	printk("Resuming via_rhine...\n");
+#if 1
+	ioaddr = pci_resource_start (pdev, 0);
+	/* Reset the chip. */
+	writew(CmdReset, ioaddr + ChipCmd);
+#endif
+	return 0;
+}
+#endif
+					    
 
 static struct pci_driver via_rhine_driver = {
 	name:		"via-rhine",
 	id_table:	via_rhine_pci_tbl,
 	probe:		via_rhine_init_one,
 	remove:		__devexit_p(via_rhine_remove_one),
+#ifdef CONFIG_PM
+	suspend:	via_rhine_suspend,
+	resume:		via_rhine_resume
+#endif
 };
 
 
Index: linuxx/drivers/usb/hub.c
diff -u linuxx/drivers/usb/hub.c:1.1.1.1.6.1 linuxx/drivers/usb/hub.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/usb/hub.c:1.1.1.1.6.1	Fri Nov 29 13:53:27 2002
+++ linuxx/drivers/usb/hub.c	Tue Dec  3 10:37:51 2002
@@ -16,6 +16,7 @@
 #include <linux/list.h>
 #include <linux/slab.h>
 #include <linux/smp_lock.h>
+#include <linux/suspend.h>
 #ifdef CONFIG_USB_DEBUG
 	#define DEBUG
 #else
@@ -919,6 +920,8 @@
 	/* Send me a signal to get me die (for debugging) */
 	do {
 		usb_hub_events();
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
 		wait_event_interruptible(khubd_wait, !list_empty(&hub_event_list)); 
 	} while (!signal_pending(current));
 
Index: linuxx/drivers/usb/storage/usb.c
diff -u linuxx/drivers/usb/storage/usb.c:1.1.1.1.6.1 linuxx/drivers/usb/storage/usb.c:1.1.1.1.10.1.4.1
--- linuxx/drivers/usb/storage/usb.c:1.1.1.1.6.1	Fri Nov 29 13:53:34 2002
+++ linuxx/drivers/usb/storage/usb.c	Tue Dec  3 10:37:56 2002
@@ -319,6 +319,7 @@
 	 */
 	exit_files(current);
 	current->files = init_task.files;
+	current->flags |= PF_IOTHREAD;
 	atomic_inc(&current->files->count);
 	daemonize();
 	reparent_to_init();
Index: linuxx/fs/buffer.c
diff -u linuxx/fs/buffer.c:1.1.1.1.6.2 linuxx/fs/buffer.c:1.1.1.1.10.1.4.2
--- linuxx/fs/buffer.c:1.1.1.1.6.2	Fri Dec  6 08:30:24 2002
+++ linuxx/fs/buffer.c	Thu Dec 12 11:58:00 2002
@@ -47,6 +47,7 @@
 #include <linux/highmem.h>
 #include <linux/module.h>
 #include <linux/completion.h>
+#include <linux/suspend.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -1336,7 +1337,7 @@
 	 * to release buffers.
 	 */
 	return 0;
-try_to_free:	
+try_to_free:
 	return try_to_free_buffers(page, gfp_mask);
 }
 
@@ -2676,7 +2677,7 @@
 
 	/* And free the page */
 	page->buffers = NULL;
-	page_cache_release(page);
+	page_cache_release(page);	
 	write_unlock(&hash_table_lock);
 	spin_unlock(&lru_list_lock);
 	return 1;
@@ -2959,6 +2960,8 @@
 				break;
 			ndirty -= NRSYNC;
 		}
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
 		if (ndirty > 0 || bdflush_stop())
 			interruptible_sleep_on(&bdflush_wait);
 	}
@@ -2991,6 +2994,8 @@
 	for (;;) {
 		/* update interval */
 		interval = bdf_prm.b_un.interval;
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
 		if (interval) {
 			tsk->state = TASK_INTERRUPTIBLE;
 			schedule_timeout(interval);
Index: linuxx/fs/jbd/journal.c
diff -u linuxx/fs/jbd/journal.c:1.1.1.1.6.1 linuxx/fs/jbd/journal.c:1.1.1.1.10.1.4.1
--- linuxx/fs/jbd/journal.c:1.1.1.1.6.1	Fri Nov 29 13:53:50 2002
+++ linuxx/fs/jbd/journal.c	Tue Dec  3 10:38:05 2002
@@ -34,6 +34,7 @@
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/slab.h>
+#include <linux/suspend.h>
 #include <asm/uaccess.h>
 #include <linux/proc_fs.h>
 
@@ -248,7 +249,15 @@
 		}
 
 		wake_up(&journal->j_wait_done_commit);
-		interruptible_sleep_on(&journal->j_wait_commit);
+		if (current->flags & PF_FREEZE) { /* The simpler the better. Flushing journal isn't a
+						     good idea, because that depends on threads that
+						     may be already stopped. */
+			jbd_debug(1, "Now suspending kjournald\n");
+			refrigerator(PF_IOTHREAD);
+			jbd_debug(1, "Resuming kjournald\n");						
+		} else		/* we assume on resume that commits are already there,
+				   so we don't sleep */
+			interruptible_sleep_on(&journal->j_wait_commit);
 
 		jbd_debug(1, "kjournald wakes\n");
 
Index: linuxx/fs/lockd/svc.c
diff -u linuxx/fs/lockd/svc.c:1.1.1.1 linuxx/fs/lockd/svc.c:1.1.1.1.12.1
--- linuxx/fs/lockd/svc.c:1.1.1.1	Thu Nov 28 14:07:38 2002
+++ linuxx/fs/lockd/svc.c	Thu Nov 28 20:22:54 2002
@@ -26,6 +26,7 @@
 #include <linux/slab.h>
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
+#include <linux/suspend.h>
 
 #include <linux/sunrpc/types.h>
 #include <linux/sunrpc/stats.h>
@@ -126,7 +127,11 @@
 	while ((nlmsvc_users || !signalled()) && nlmsvc_pid == current->pid)
 	{
 		long timeout = MAX_SCHEDULE_TIMEOUT;
-		if (signalled()) {
+		if (current->flags & PF_FREEZE) { 
+			dprintk("Now suspending lockd\n");
+			refrigerator(PF_IOTHREAD);
+			dprintk("Now resuming lockd\n");
+		} else if (signalled()) {
 			spin_lock_irq(&current->sigmask_lock);
 			flush_signals(current);
 			spin_unlock_irq(&current->sigmask_lock);
Index: linuxx/fs/reiserfs/journal.c
diff -u linuxx/fs/reiserfs/journal.c:1.1.1.1.6.1 linuxx/fs/reiserfs/journal.c:1.1.1.1.10.1.4.1
--- linuxx/fs/reiserfs/journal.c:1.1.1.1.6.1	Fri Nov 29 13:54:02 2002
+++ linuxx/fs/reiserfs/journal.c	Tue Dec  3 10:38:10 2002
@@ -58,6 +58,7 @@
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/smp_lock.h>
+#include <linux/suspend.h>
 
 /* the number of mounted filesystems.  This is used to decide when to
 ** start and kill the commit thread
@@ -1884,6 +1885,8 @@
       break ;
     }
     wake_up(&reiserfs_commit_thread_done) ;
+    if (current->flags & PF_FREEZE)
+      refrigerator(PF_IOTHREAD);
     interruptible_sleep_on_timeout(&reiserfs_commit_thread_wait, 5 * HZ) ;
   }
   unlock_kernel() ;
Index: linuxx/include/asm-generic/bitops.h
diff -u linuxx/include/asm-generic/bitops.h:1.1.1.1 linuxx/include/asm-generic/bitops.h:1.1.1.1.12.1
--- linuxx/include/asm-generic/bitops.h:1.1.1.1	Thu Nov 28 14:07:46 2002
+++ linuxx/include/asm-generic/bitops.h	Thu Nov 28 20:22:54 2002
@@ -51,6 +51,12 @@
 	return ((mask & *addr) != 0);
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
Index: linuxx/include/asm-i386/bitops.h
diff -u linuxx/include/asm-i386/bitops.h:1.1.1.1.6.1 linuxx/include/asm-i386/bitops.h:1.1.1.1.10.1.4.1
--- linuxx/include/asm-i386/bitops.h:1.1.1.1.6.1	Fri Nov 29 13:54:13 2002
+++ linuxx/include/asm-i386/bitops.h	Tue Dec  3 10:38:11 2002
@@ -330,6 +330,12 @@
 	return word;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /**
Index: linuxx/include/asm-i386/mtrr.h
diff -u linuxx/include/asm-i386/mtrr.h:1.1.1.1 linuxx/include/asm-i386/mtrr.h:1.1.1.1.12.1
--- linuxx/include/asm-i386/mtrr.h:1.1.1.1	Thu Nov 28 14:07:46 2002
+++ linuxx/include/asm-i386/mtrr.h	Thu Nov 28 20:22:54 2002
@@ -89,6 +89,10 @@
 extern int mtrr_del (int reg, unsigned long base, unsigned long size);
 extern int mtrr_del_page (int reg, unsigned long base, unsigned long size);
 extern void mtrr_centaur_report_mcr(int mcr, u32 lo, u32 hi);
+#  ifdef CONFIG_SOFTWARE_SUSPEND
+extern int *mtrr_suspend(void);
+extern int mtrr_resume(int *ptr);
+#  endif
 #  else
 static __inline__ int mtrr_add (unsigned long base, unsigned long size,
 				unsigned int type, char increment)
Index: linuxx/include/asm-i386/processor.h
diff -u linuxx/include/asm-i386/processor.h:1.1.1.1 linuxx/include/asm-i386/processor.h:1.1.1.1.12.1
--- linuxx/include/asm-i386/processor.h:1.1.1.1	Thu Nov 28 14:07:46 2002
+++ linuxx/include/asm-i386/processor.h	Thu Nov 28 20:22:54 2002
@@ -83,6 +83,7 @@
 
 #define cpu_has_pge	(test_bit(X86_FEATURE_PGE,  boot_cpu_data.x86_capability))
 #define cpu_has_pse	(test_bit(X86_FEATURE_PSE,  boot_cpu_data.x86_capability))
+#define cpu_has_pse36	(test_bit(X86_FEATURE_PSE36,boot_cpu_data.x86_capability))
 #define cpu_has_pae	(test_bit(X86_FEATURE_PAE,  boot_cpu_data.x86_capability))
 #define cpu_has_tsc	(test_bit(X86_FEATURE_TSC,  boot_cpu_data.x86_capability))
 #define cpu_has_de	(test_bit(X86_FEATURE_DE,   boot_cpu_data.x86_capability))
Index: linuxx/include/asm-i386/suspend.h
diff -u /dev/null linuxx/include/asm-i386/suspend.h:1.1.6.1.4.1
--- /dev/null	Fri Dec 13 18:24:09 2002
+++ linuxx/include/asm-i386/suspend.h	Tue Dec  3 20:22:11 2002
@@ -0,0 +1,278 @@
+ /*
+  * Copyright 2001-2002 Pavel Machek <pavel@suse.cz>
+  * Based on code
+  * Copyright 2001 Patrick Mochel <mochel@osdl.org>
+  */
+#include <asm/desc.h>
+#include <asm/i387.h>
+
+/* image of the saved processor state */
+struct saved_context {
+	u32 eax, ebx, ecx, edx;
+	u32 esp, ebp, esi, edi;
+	u16 es, fs, gs, ss;
+	u32 cr0, cr2, cr3, cr4;
+	u16 gdt_pad;
+	u16 gdt_limit;
+	u32 gdt_base;
+	u16 idt_pad;
+	u16 idt_limit;
+	u32 idt_base;
+	u16 ldt;
+	u16 tss;
+	u32 tr;
+	u32 safety;
+	u32 return_address;
+	u32 eflags;
+} __attribute__((packed));
+
+static struct saved_context saved_context;
+
+#define loaddebug(thread,register) \
+               __asm__("movl %0,%%db" #register  \
+                       : /* no output */ \
+                       :"r" ((thread)->debugreg[register]))
+
+ 
+/*
+ * save_processor_context
+ * 
+ * Save the state of the processor before we go to sleep.
+ *
+ * return_stack is the value of the stack pointer (%esp) as the caller sees it.
+ * A good way could not be found to obtain it from here (don't want to make _too_
+ * many assumptions about the layout of the stack this far down.) Also, the 
+ * handy little __builtin_frame_pointer(level) where level > 0, is blatantly 
+ * buggy - it returns the value of the stack at the proper location, not the 
+ * location, like it should (as of gcc 2.91.66)
+ * 
+ * Note that the context and timing of this function is pretty critical.
+ * With a minimal amount of things going on in the caller and in here, gcc
+ * does a good job of being just a dumb compiler.  Watch the assembly output
+ * if anything changes, though, and make sure everything is going in the right
+ * place. 
+ */
+static inline void save_processor_context (void)
+{
+	kernel_fpu_begin();
+
+	/*
+	 * descriptor tables
+	 */
+	asm volatile ("sgdt (%0)" : "=m" (saved_context.gdt_limit));
+	asm volatile ("sidt (%0)" : "=m" (saved_context.idt_limit));
+	asm volatile ("sldt (%0)" : "=m" (saved_context.ldt));
+	asm volatile ("str (%0)"  : "=m" (saved_context.tr));
+
+	/*
+	 * save the general registers.
+	 * note that gcc has constructs to specify output of certain registers,
+	 * but they're not used here, because it assumes that you want to modify
+	 * those registers, so it tries to be smart and save them beforehand.
+	 * It's really not necessary, and kinda fishy (check the assembly output),
+	 * so it's avoided. 
+	 */
+	asm volatile ("movl %%esp, (%0)" : "=m" (saved_context.esp));
+	asm volatile ("movl %%eax, (%0)" : "=m" (saved_context.eax));
+	asm volatile ("movl %%ebx, (%0)" : "=m" (saved_context.ebx));
+	asm volatile ("movl %%ecx, (%0)" : "=m" (saved_context.ecx));
+	asm volatile ("movl %%edx, (%0)" : "=m" (saved_context.edx));
+	asm volatile ("movl %%ebp, (%0)" : "=m" (saved_context.ebp));
+	asm volatile ("movl %%esi, (%0)" : "=m" (saved_context.esi));
+	asm volatile ("movl %%edi, (%0)" : "=m" (saved_context.edi));
+
+	/*
+	 * segment registers
+	 */
+	asm volatile ("movw %%es, %0" : "=r" (saved_context.es));
+	asm volatile ("movw %%fs, %0" : "=r" (saved_context.fs));
+	asm volatile ("movw %%gs, %0" : "=r" (saved_context.gs));
+	asm volatile ("movw %%ss, %0" : "=r" (saved_context.ss));
+
+	/*
+	 * control registers 
+	 */
+	asm volatile ("movl %%cr0, %0" : "=r" (saved_context.cr0));
+	asm volatile ("movl %%cr2, %0" : "=r" (saved_context.cr2));
+	asm volatile ("movl %%cr3, %0" : "=r" (saved_context.cr3));
+	asm volatile ("movl %%cr4, %0" : "=r" (saved_context.cr4));
+
+	/*
+	 * eflags
+	 */
+	asm volatile ("pushfl ; popl (%0)" : "=m" (saved_context.eflags));
+}
+
+void fix_processor_context(void)
+{
+	int nr = smp_processor_id();
+	struct tss_struct * t = &init_tss[nr];
+
+	set_tss_desc(nr,t);	/* This just modifies memory; should not be neccessary. But... This is neccessary, because 386 hardware has concept of busy tsc or some similar stupidity. */
+        gdt_table[__TSS(nr)].b &= 0xfffffdff;
+
+	load_TR(nr);		/* This does ltr */
+
+	load_LDT(current->active_mm);	/* This does lldt */
+
+	/*
+	 * Now maybe reload the debug registers
+	 */
+	if (current->thread.debugreg[7]){
+                loaddebug(&current->thread, 0);
+                loaddebug(&current->thread, 1);
+                loaddebug(&current->thread, 2);
+                loaddebug(&current->thread, 3);
+                /* no 4 and 5 */
+                loaddebug(&current->thread, 6);
+                loaddebug(&current->thread, 7);
+	}
+
+}
+
+void
+do_fpu_end(void)
+{
+        /* restore FPU regs if necessary */
+	/* Do it out of line so that gcc does not move cr0 load to some stupid place */
+        kernel_fpu_end();
+}
+
+/*
+ * restore_processor_context
+ * 
+ * Restore the processor context as it was before we went to sleep
+ * - descriptor tables
+ * - control registers
+ * - segment registers
+ * - flags
+ * 
+ * Note that it is critical that this function is declared inline.  
+ * It was separated out from restore_state to make that function
+ * a little clearer, but it needs to be inlined because we won't have a
+ * stack when we get here (so we can't push a return address).
+ */
+static inline void restore_processor_context (void)
+{
+	/*
+	 * first restore %ds, so we can access our data properly
+	 */
+	asm volatile (".align 4");
+	asm volatile ("movw %0, %%ds" :: "r" ((u16)__KERNEL_DS));
+
+
+	/*
+	 * control registers
+	 */
+	asm volatile ("movl %0, %%cr4" :: "r" (saved_context.cr4));
+	asm volatile ("movl %0, %%cr3" :: "r" (saved_context.cr3));
+	asm volatile ("movl %0, %%cr2" :: "r" (saved_context.cr2));
+	asm volatile ("movl %0, %%cr0" :: "r" (saved_context.cr0));
+	
+	/*
+	 * segment registers
+	 */
+	asm volatile ("movw %0, %%es" :: "r" (saved_context.es));
+	asm volatile ("movw %0, %%fs" :: "r" (saved_context.fs));
+	asm volatile ("movw %0, %%gs" :: "r" (saved_context.gs));
+	asm volatile ("movw %0, %%ss" :: "r" (saved_context.ss));
+
+	/*
+	 * the other general registers
+	 *
+	 * note that even though gcc has constructs to specify memory 
+	 * input into certain registers, it will try to be too smart
+	 * and save them at the beginning of the function.  This is esp.
+	 * bad since we don't have a stack set up when we enter, and we 
+	 * want to preserve the values on exit. So, we set them manually.
+	 */
+	asm volatile ("movl %0, %%esp" :: "m" (saved_context.esp));
+	asm volatile ("movl %0, %%ebp" :: "m" (saved_context.ebp));
+	asm volatile ("movl %0, %%eax" :: "m" (saved_context.eax));
+	asm volatile ("movl %0, %%ebx" :: "m" (saved_context.ebx));
+	asm volatile ("movl %0, %%ecx" :: "m" (saved_context.ecx));
+	asm volatile ("movl %0, %%edx" :: "m" (saved_context.edx));
+	asm volatile ("movl %0, %%esi" :: "m" (saved_context.esi));
+	asm volatile ("movl %0, %%edi" :: "m" (saved_context.edi));
+
+	/*
+	 * now restore the descriptor tables to their proper values
+	 * ltr is done i fix_processor_context().
+	 */
+	asm volatile ("lgdt (%0)" :: "m" (saved_context.gdt_limit));
+	asm volatile ("lidt (%0)" :: "m" (saved_context.idt_limit));
+	asm volatile ("lldt (%0)" :: "m" (saved_context.ldt));
+
+	fix_processor_context();
+
+	/*
+	 * the flags
+	 */
+	asm volatile ("pushl %0 ; popfl" :: "m" (saved_context.eflags));
+
+	do_fpu_end();
+}
+
+#ifdef SUSPEND_C
+/* Local variables for do_magic */
+static int loop __nosavedata = 0;
+static int loop2 __nosavedata = 0;
+
+/*
+ * FIXME: This function should really be written in assembly. Actually
+ * requirement is that it does not touch stack, because %esp will be
+ * wrong during resume before restore_processor_context(). Check
+ * assembly if you modify this.
+ */
+static void do_suspend_lowlevel(int resume)
+{
+	if (!resume) {
+		do_magic_suspend_1();
+		save_processor_context();	/* We need to capture registers and memory at "same time" */
+		do_magic_suspend_2();		/* If everything goes okay, this function does not return */
+		return;
+	}
+
+	/* We want to run from swapper_pg_dir, since swapper_pg_dir is stored in constant
+	 * place in memory 
+	 */
+
+        __asm__( "movl %%ecx,%%cr3\n" ::"c"(__pa(swapper_pg_dir)));
+
+/*
+ * Final function for resuming: after copying the pages to their original
+ * position, it restores the register state.
+ *
+ * What about page tables? Writing data pages may toggle
+ * accessed/dirty bits in our page tables. That should be no problems
+ * with 4MB page tables. That's why we require have_pse.  
+ *
+ * This loops destroys stack from under itself, so it better should
+ * not use any stack space, itself. When this function is entered at
+ * resume time, we move stack to _old_ place.  This is means that this
+ * function must use no stack and no local variables in registers,
+ * until calling restore_processor_context();
+ *
+ * Critical section here: noone should touch saved memory after
+ * do_magic_resume_1; copying works, because nr_copy_pages,
+ * pagedir_nosave, loop and loop2 are nosavedata.
+ */
+	do_magic_resume_1();
+
+	for (loop=0; loop < pageset1_size; loop++) {
+		/* You may not call something (like copy_page) here: see above */
+		for (loop2=0; loop2 < PAGE_SIZE; loop2++) {
+			*(((char *)((pagedir_nosave+loop)->address1))+loop2) =
+				*(((char *)((pagedir_nosave+loop)->address3))+loop2);
+			__flush_tlb();
+		}
+	}
+
+	restore_processor_context();
+
+/* Ahah, we now run with our old stack, and with registers copied from
+   suspend time */
+
+	do_magic_resume_2();
+}
+#endif 
Index: linuxx/include/linux/bitops.h
diff -u linuxx/include/linux/bitops.h:1.1.1.1 linuxx/include/linux/bitops.h:1.1.1.1.12.1
--- linuxx/include/linux/bitops.h:1.1.1.1	Thu Nov 28 14:07:56 2002
+++ linuxx/include/linux/bitops.h	Thu Nov 28 20:22:58 2002
@@ -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
@@ -38,6 +38,47 @@
 }
 
 /*
+ * 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;
+}
+
+extern __inline__ int get_bitmask_order(unsigned int count)
+{
+	int order;
+	
+	order = fls(count);
+	return order;	/* We could be slightly more clever with -1 here... */
+}
+
+/*
  * hweightN: returns the hamming weight (i.e. the number
  * of bits set) of a N-bit word
  */
@@ -65,8 +106,6 @@
         res = (res & 0x33) + ((res >> 2) & 0x33);
         return (res & 0x0F) + ((res >> 4) & 0x0F);
 }
-
-#include <asm/bitops.h>
 
 
 #endif
Index: linuxx/include/linux/ide.h
diff -u linuxx/include/linux/ide.h:1.1.1.1.6.1 linuxx/include/linux/ide.h:1.1.1.1.10.1.4.1
--- linuxx/include/linux/ide.h:1.1.1.1.6.1	Fri Nov 29 13:55:07 2002
+++ linuxx/include/linux/ide.h	Tue Dec  3 10:38:46 2002
@@ -513,7 +513,7 @@
 
 typedef struct hwif_s {
 	struct hwif_s	*next;		/* for linked-list in ide_hwgroup_t */
-	void		*hwgroup;	/* actually (ide_hwgroup_t *) */
+	struct hwgroup_s *hwgroup;	/* actually (ide_hwgroup_t *) */
 	ide_ioreg_t	io_ports[IDE_NR_PORTS];	/* task file registers */
 	hw_regs_t	hw;		/* Hardware info */
 	ide_drive_t	drives[MAX_DRIVES];	/* drive info */
Index: linuxx/include/linux/init.h
diff -u linuxx/include/linux/init.h:1.1.1.1 linuxx/include/linux/init.h:1.1.1.1.12.1
--- linuxx/include/linux/init.h:1.1.1.1	Thu Nov 28 14:07:56 2002
+++ linuxx/include/linux/init.h	Thu Nov 28 20:22:58 2002
@@ -111,6 +111,9 @@
  */
 #define module_exit(x)	__exitcall(x);
 
+/* Data marked not to be saved by software_suspend() */
+#define __nosavedata __attribute__ ((__section__ (".data.nosave")))
+
 #else	/* MODULE */
 
 #define __init
Index: linuxx/include/linux/mm.h
diff -u linuxx/include/linux/mm.h:1.1.1.1 linuxx/include/linux/mm.h:1.1.1.1.12.1
--- linuxx/include/linux/mm.h:1.1.1.1	Thu Nov 28 14:07:56 2002
+++ linuxx/include/linux/mm.h	Thu Nov 28 20:22:58 2002
@@ -297,6 +297,9 @@
 #define PG_arch_1		13
 #define PG_reserved		14
 #define PG_launder		15	/* written out by VM pressure.. */
+#define PG_nosave		16
+/* Don't you dare to use high bits, they seem to be used for something else! */
+
 
 /* Make it prettier to test the above... */
 #define UnlockPage(page)	unlock_page(page)
@@ -406,6 +409,12 @@
 #define SetPageReserved(page)		set_bit(PG_reserved, &(page)->flags)
 #define ClearPageReserved(page)		clear_bit(PG_reserved, &(page)->flags)
 
+#define PageNosave(page)	test_bit(PG_nosave, &(page)->flags)
+#define PageSetNosave(page)	set_bit(PG_nosave, &(page)->flags)
+#define PageTestandSetNosave(page)	test_and_set_bit(PG_nosave, &(page)->flags)
+#define PageClearNosave(page)		clear_bit(PG_nosave, &(page)->flags)
+#define PageTestandClearNosave(page)	test_and_clear_bit(PG_nosave, &(page)->flags)
+
 /*
  * Error return values for the *_nopage functions
  */
@@ -599,6 +608,8 @@
 #define __GFP_IO	0x40	/* Can start low memory physical IO? */
 #define __GFP_HIGHIO	0x80	/* Can start high mem physical IO? */
 #define __GFP_FS	0x100	/* Can call down to low-level FS? */
+#define __GFP_FAST	0x200	/* fast return in reschedule if out
+				   of page (used in swsusp) */
 
 #define GFP_NOHIGHIO	(__GFP_HIGH | __GFP_WAIT | __GFP_IO)
 #define GFP_NOIO	(__GFP_HIGH | __GFP_WAIT)
Index: linuxx/include/linux/reboot.h
diff -u linuxx/include/linux/reboot.h:1.1.1.1 linuxx/include/linux/reboot.h:1.1.1.1.12.1
--- linuxx/include/linux/reboot.h:1.1.1.1	Thu Nov 28 14:07:56 2002
+++ linuxx/include/linux/reboot.h	Thu Nov 28 20:22:58 2002
@@ -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__
@@ -45,6 +47,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_pending(void);
+extern unsigned char software_suspend_enabled;
 
 #endif
 
Index: linuxx/include/linux/sched.h
diff -u linuxx/include/linux/sched.h:1.1.1.1.6.1 linuxx/include/linux/sched.h:1.1.1.1.10.1.4.1
--- linuxx/include/linux/sched.h:1.1.1.1.6.1	Fri Nov 29 13:55:08 2002
+++ linuxx/include/linux/sched.h	Tue Dec  3 10:38:47 2002
@@ -435,6 +435,9 @@
 #define PF_MEMDIE	0x00001000	/* Killed for out-of-memory */
 #define PF_FREE_PAGES	0x00002000	/* per process page freeing */
 #define PF_NOIO		0x00004000	/* avoid generating further I/O */
+#define PF_FROZEN	0x00008000	/* frozen for system suspend */
+#define PF_FREEZE	0x00010000	/* this task should be frozen for suspend */
+#define PF_IOTHREAD	0x00020000	/* this thread is needed for doing I/O to swap */
 
 #define PF_USEDFPU	0x00100000	/* task used FPU this quantum (SMP) */
 
Index: linuxx/include/linux/suspend.h
diff -u /dev/null linuxx/include/linux/suspend.h:1.1.6.1.4.1
--- /dev/null	Fri Dec 13 18:24:19 2002
+++ linuxx/include/linux/suspend.h	Tue Dec  3 20:22:11 2002
@@ -0,0 +1,84 @@
+#ifndef _LINUX_SWSUSP_H
+#define _LINUX_SWSUSP_H
+
+#if defined(SUSPEND_C) || defined(ACPI_C)
+#include <asm/suspend.h>
+#endif
+#include <linux/swap.h>
+#include <linux/notifier.h>
+#include <linux/config.h>
+
+extern unsigned char software_suspend_enabled;
+
+#define NORESUME	 1
+#define RESUME_SPECIFIED 2
+
+#ifdef CONFIG_SOFTWARE_SUSPEND
+extern int swsusp_state[3];
+
+/* page backup entry */
+typedef struct pbe {
+	unsigned long address1;		/* original address of pageset1 entry */
+	unsigned long address2;		/* original address of pageset2 entry */
+	unsigned long address3;		/* copy back address */
+	swp_entry_t swap_address1;
+	swp_entry_t swap_address2;
+	swp_entry_t dummy[3];		/* we need at least one sizeof(long) scratch space at 
+					 * end of page (see link, diskpage) and
+					 * sizeof(struct pbe) must be multiple of 4*sizeof(long)
+					 */
+} suspend_pagedir_t;
+
+#define SWAP_FILENAME_MAXLENGTH	32
+
+struct suspend_header {
+	__u32 version_code;
+	unsigned long num_physpages;
+	char machine[65];
+	char version[65];
+	int num_cpus;
+	int page_size;
+	suspend_pagedir_t *suspend_pagedir;
+	unsigned int pageset1_size;
+	unsigned int pageset2_size;
+	unsigned int pagedir_size;
+	int param0;
+	int param1;
+	int param2;
+	int param3;
+	struct swap_location {
+		char filename[SWAP_FILENAME_MAXLENGTH];
+	} swap_location[MAX_SWAPFILES];
+};
+
+#define SUSPEND_PD_PAGES(x)     (((x)*sizeof(struct pbe))/PAGE_SIZE+1)
+#define PAGEDIR_CAPACITY(x)     (((x)*PAGE_SIZE/sizeof(struct pbe)))
+   
+extern struct tq_struct suspend_tq;
+
+/* mm/vmscan.c */
+extern int shrink_mem(void);
+
+/* kernel/suspend.c */
+extern void software_suspend_pending(void);
+extern void software_resume(void);
+
+extern int register_suspend_notifier(struct notifier_block *);
+extern int unregister_suspend_notifier(struct notifier_block *);
+extern void refrigerator(unsigned long);
+
+#ifdef CONFIG_MTRR
+#define SOFTWARE_SUSPEND_MTRR 1
+#else
+#undef SOFTWARE_SUSPEND_MTRR
+#endif
+
+#else
+#define software_suspend_pending()	do { } while(0)
+#define software_resume()		do { } while(0)
+#define register_suspend_notifier(a)	do { } while(0)
+#define unregister_suspend_notifier(a)	do { } while(0)
+#define refrigerator(a)			do { BUG(); } while(0)
+#endif
+
+#endif /* _LINUX_SWSUSP_H */
Index: linuxx/include/linux/swap.h
diff -u linuxx/include/linux/swap.h:1.1.1.1.6.1 linuxx/include/linux/swap.h:1.1.1.1.10.1.4.1
--- linuxx/include/linux/swap.h:1.1.1.1.6.1	Fri Nov 29 13:55:08 2002
+++ linuxx/include/linux/swap.h	Tue Dec  3 10:38:48 2002
@@ -118,7 +118,9 @@
 
 /* linux/mm/page_io.c */
 extern void rw_swap_page(int, struct page *);
-extern void rw_swap_page_nolock(int, swp_entry_t, char *);
+extern void __rw_swap_page_nolock(int, swp_entry_t, char *, int);
+#define rw_swap_page_nolock(rw, entry, buf) __rw_swap_page_nolock(rw, entry, buf, 1)
+#define rw_swap_page_nolock_norfree(rw, entry, buf) __rw_swap_page_nolock(rw, entry, buf, 0)
 
 /* linux/mm/page_alloc.c */
 
Index: linuxx/include/linux/sysctl.h
diff -u linuxx/include/linux/sysctl.h:1.1.1.1.6.1 linuxx/include/linux/sysctl.h:1.1.1.1.10.1.4.1
--- linuxx/include/linux/sysctl.h:1.1.1.1.6.1	Fri Nov 29 13:55:08 2002
+++ linuxx/include/linux/sysctl.h	Tue Dec  3 10:38:48 2002
@@ -124,6 +124,7 @@
 	KERN_CORE_USES_PID=52,		/* int: use core or core.%pid */
 	KERN_TAINTED=53,	/* int: various kernel tainted flags */
 	KERN_CADPID=54,		/* int: PID of the process to notify on CAD */
+	KERN_SWSUSP=55,		/* struct: interface to activate software suspension */
 };
 
 
Index: linuxx/include/linux/raid/md.h
diff -u linuxx/include/linux/raid/md.h:1.1.1.1 linuxx/include/linux/raid/md.h:1.1.1.1.12.1
--- linuxx/include/linux/raid/md.h:1.1.1.1	Thu Nov 28 14:07:58 2002
+++ linuxx/include/linux/raid/md.h	Thu Nov 28 20:22:58 2002
@@ -85,6 +85,8 @@
 
 extern void md_print_devices (void);
 
+extern void md_autostart_arrays(void);
+
 #define MD_BUG(x...) { printk("md: bug in file %s, line %d\n", __FILE__, __LINE__); md_print_devices(); }
 
 #endif 
Index: linuxx/init/main.c
diff -u linuxx/init/main.c:1.1.1.1.6.1 linuxx/init/main.c:1.1.1.1.6.1.2.1
--- linuxx/init/main.c:1.1.1.1.6.1	Thu Nov 28 18:51:50 2002
+++ linuxx/init/main.c	Thu Nov 28 20:22:58 2002
@@ -27,6 +27,7 @@
 #include <linux/iobuf.h>
 #include <linux/bootmem.h>
 #include <linux/tty.h>
+#include <linux/suspend.h>
 
 #include <asm/io.h>
 #include <asm/bugs.h>
@@ -534,6 +535,10 @@
 
 	start_context_thread();
 	do_initcalls();
+
+	/* This has to be before mounting root, because even readonly mount of reiserfs would replay
+	   log corrupting stuff */
+	software_resume();
 
 #ifdef CONFIG_IRDA
 	irda_proto_init();
Index: linuxx/kernel/Makefile
diff -u linuxx/kernel/Makefile:1.1.1.1 linuxx/kernel/Makefile:1.1.1.1.12.1
--- linuxx/kernel/Makefile:1.1.1.1	Thu Nov 28 14:07:58 2002
+++ linuxx/kernel/Makefile	Thu Nov 28 20:22:58 2002
@@ -9,7 +9,7 @@
 
 O_TARGET := kernel.o
 
-export-objs = signal.o sys.o kmod.o context.o ksyms.o pm.o exec_domain.o printk.o
+export-objs = signal.o sys.o kmod.o context.o ksyms.o pm.o exec_domain.o printk.o suspend.o
 
 obj-y     = sched.o dma.o fork.o exec_domain.o panic.o printk.o \
 	    module.o exit.o itimer.o info.o time.o softirq.o resource.o \
@@ -19,6 +19,7 @@
 obj-$(CONFIG_UID16) += uid16.o
 obj-$(CONFIG_MODULES) += ksyms.o
 obj-$(CONFIG_PM) += pm.o
+obj-$(CONFIG_SOFTWARE_SUSPEND) += suspend.o
 
 ifneq ($(CONFIG_IA64),y)
 # According to Alan Modra <alan@linuxcare.com.au>, the -fno-omit-frame-pointer is
Index: linuxx/kernel/context.c
diff -u linuxx/kernel/context.c:1.1.1.1 linuxx/kernel/context.c:1.1.1.1.12.1
--- linuxx/kernel/context.c:1.1.1.1	Thu Nov 28 14:07:59 2002
+++ linuxx/kernel/context.c	Thu Nov 28 20:22:58 2002
@@ -72,6 +72,7 @@
 
 	daemonize();
 	strcpy(curtask->comm, "keventd");
+	current->flags |= PF_IOTHREAD;
 	keventd_running = 1;
 	keventd_task = curtask;
 
Index: linuxx/kernel/signal.c
diff -u linuxx/kernel/signal.c:1.1.1.1.6.1 linuxx/kernel/signal.c:1.1.1.1.12.1.4.1
--- linuxx/kernel/signal.c:1.1.1.1.6.1	Fri Dec  6 08:30:25 2002
+++ linuxx/kernel/signal.c	Thu Dec 12 11:58:05 2002
@@ -475,7 +475,7 @@
  * No need to set need_resched since signal event passing
  * goes through ->blocked
  */
-static inline void signal_wake_up(struct task_struct *t)
+inline void signal_wake_up(struct task_struct *t)
 {
 	t->sigpending = 1;
 
Index: linuxx/kernel/softirq.c
diff -u linuxx/kernel/softirq.c:1.1.1.1.6.1 linuxx/kernel/softirq.c:1.1.1.1.10.1.4.1
--- linuxx/kernel/softirq.c:1.1.1.1.6.1	Fri Nov 29 13:55:10 2002
+++ linuxx/kernel/softirq.c	Tue Dec  3 10:38:49 2002
@@ -365,6 +365,7 @@
 
 	daemonize();
 	current->nice = 19;
+	current->flags |= PF_IOTHREAD;
 	sigfillset(&current->blocked);
 
 	/* Migrate to the right CPU */
Index: linuxx/kernel/suspend.c
diff -u /dev/null linuxx/kernel/suspend.c:1.1.6.1.4.1
--- /dev/null	Fri Dec 13 18:24:21 2002
+++ linuxx/kernel/suspend.c	Tue Dec  3 20:22:11 2002
@@ -0,0 +1,1702 @@
+/*
+ * linux/kernel/suspend.c
+ *
+ * This file is to realize architecture-independent
+ * machine suspend feature using pretty near only high-level routines
+ *
+ * Copyright (C) 1998-2001 Gabor Kuti <seasons@fornax.hu>
+ * Copyright (C) 1998,2001,2002 Pavel Machek <pavel@suse.cz>
+ * Copyright (C) 2002 Florent Chabaud <fchabaud@free.fr>
+ *
+ * I'd like to thank the following people for their work:
+ * 
+ * Pavel Machek <pavel@ucw.cz>:
+ * Modifications, defectiveness pointing, being with me at the very beginning,
+ * suspend to swap space, stop all tasks. Port to 2.4.18-ac and 2.5.17.
+ *
+ * Steve Doddi <dirk@loth.demon.co.uk>: 
+ * Support the possibility of hardware state restoring.
+ *
+ * Raph <grey.havens@earthling.net>:
+ * Support for preserving states of network devices and virtual console
+ * (including X and svgatextmode)
+ *
+ * Kurt Garloff <garloff@suse.de>:
+ * Straightened the critical function in order to prevent compilers from
+ * playing tricks with local variables.
+ *
+ * Andreas Mohr <a.mohr@mailto.de>
+ *
+ * Alex Badea <vampire@go.ro>:
+ * Fixed runaway init
+ *
+ * Jeff Snyder <je4d@pobox.com>
+ * ACPI patch
+ *
+ * Nathan Friess <natmanz@shaw.ca>
+ * Great number of patches. Nice display.
+ *
+ * More state savers are welcome. Especially for the scsi layer...
+ *
+ * For TODOs,FIXMEs also look in Documentation/swsusp.txt
+ */
+
+#include <linux/module.h>
+#include <linux/mm.h>
+#include <linux/swapctl.h>
+#include <linux/suspend.h>
+#include <linux/proc_fs.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>
+#include <linux/spinlock.h>
+#include <linux/genhd.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/blk.h>
+#include <linux/swap.h>
+#include <linux/pm.h>
+#include <linux/raid/md.h>
+#include <linux/selection.h>
+#include <linux/console_struct.h>
+#include <linux/console.h>
+
+#include <asm/uaccess.h>
+#include <asm/mmu_context.h>
+#include <asm/pgtable.h>
+#include <asm/io.h>
+#include <asm/mtrr.h>
+
+unsigned char software_suspend_enabled = 0;
+/*
+ * Poll the swsusp state every second
+ */
+#define SWSUSP_CHECK_TIMEOUT	(HZ)
+
+#define SUSPEND_CONSOLE	(MAX_NR_CONSOLES-1)
+#if 0 || !defined(CONFIG_VT) || !defined(CONFIG_VT_CONSOLE)
+# undef SUSPEND_CONSOLE
+#endif
+
+#define TIMEOUT	(6 * HZ)			/* Timeout for stopping processes */
+#define ADDRESS(x) ((unsigned long) phys_to_virt(((x) << PAGE_SHIFT)))
+
+extern int C_A_D;
+
+/* References to section boundaries */
+extern char _text, _etext, _edata, __bss_start, _end;
+extern char __nosave_begin, __nosave_end;
+
+extern int console_loglevel;
+extern int is_head_of_free_region(unsigned long page);
+extern void generate_free_page_map(void);
+extern inline void signal_wake_up(struct task_struct *t);
+asmlinkage long sys_sched_yield(void);
+asmlinkage void sys_sync(void);	/* it's really int */
+extern void ide_disk_unsuspend(void);
+extern void ide_disk_suspend(void);
+extern kdev_t name_to_kdev_t(char *line) __init;
+extern void vt_console_print(struct console *co, const char * b, unsigned count);
+extern void reset_terminal(int currcons, int do_clear);
+extern void hide_cursor(int currcons);
+/* Locks */
+spinlock_t suspend_pagedir_lock __nosavedata = SPIN_LOCK_UNLOCKED;
+
+/* Variables to be preserved over suspend */
+static int new_loglevel = 7;
+static int orig_loglevel = 0;
+static int orig_fgconsole;
+static int pagedir_order_check;
+static int pageset1_size_check;
+
+static int resume_status = 0;
+static char resume_file[256] = "";			/* For resume= kernel option */
+static kdev_t resume_device;
+/* Local variables that should not be affected by save */
+static unsigned int pageset1_size __nosavedata = 0;
+
+static int pm_suspend_state = 0;
+
+/* Suspend pagedir is allocated before final copy, therefore it
+   must be freed after resume 
+
+   Warning: this is evil. There are actually two pagedirs at time of
+   resume. One is "pagedir_save", which is empty frame allocated at
+   time of suspend, that must be freed. Second is "pagedir_nosave", 
+   allocated at time of resume, that travels through memory not to
+   collide with anything.
+ */
+static suspend_pagedir_t *pagedir_nosave __nosavedata = NULL;
+static suspend_pagedir_t *pagedir_save;
+static int pagedir_order __nosavedata = 0;
+
+#ifdef SUSPEND_CONSOLE
+static int orig_kmsg;
+static int barwidth = 0, barposn = -1, newbarposn = 0, lastpercentage = 0;
+#define suspend_console (struct console *) NULL	/* Used in some console calls - obsolete parameter */
+#endif
+
+struct link {
+	char dummy[PAGE_SIZE - sizeof(swp_entry_t)];
+	swp_entry_t next;
+};
+
+union diskpage {
+	union swap_header swh;	/* swh.magic is the only member used */
+	struct link link;
+	struct suspend_header sh;
+};
+
+union p_diskpage {
+	union diskpage *pointer;
+	char *ptr;
+        unsigned long address;
+};
+
+/*
+ * 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	512
+
+#define name_suspend "Suspend Machine:  "
+#define name_resume  "Resume Machine:   "
+#define swsusp_version "beta 16"
+#define name_swsusp  "Swsusp " swsusp_version ":   "
+#define console_suspend "S U S P E N D   T O   D I S K (" swsusp_version ")"
+#define console_resume "R E S U M E   F R O M   D I S K (" swsusp_version ")"
+/*
+ * Debug
+ */
+#define	DEBUG_DEFAULT	1	/* activate debugging setting in /proc/sys/kernel/swsusp
+				   Commenting out will save a few cycles */
+/* first status register */
+#define SUSPEND_PENDING (swsusp_state[0] & 0x1)
+#define SUSPEND_ABORTING (swsusp_state[0] & 0x2) /* unused */
+/* second status register */
+#define SUSPEND_REBOOT  (swsusp_state[1] & 0x1)
+#define SUSPEND_FREEMEM (swsusp_state[1] & 0x2)
+#define SUSPEND_FAKE    (swsusp_state[1] & 0x4)	/* unused */
+#define SUSPEND_NOPAGESET2 (swsusp_state[1] & 0x8)	/* unused */
+/* third status register */
+#define SUSPEND_DEBUG   	0x1
+#define SUSPEND_PROGRESS   	0x2
+#define SUSPEND_VERBOSE   	0x4
+#define SUSPEND_SLOW		0x8
+#ifdef DEBUG_DEFAULT
+# define PRINTK(mask, f, a...)	((mask) & swsusp_state[2] ? printk(f, ## a):0)
+# define MDELAY(a) 		if (swsusp_state[2] & SUSPEND_SLOW)  mdelay(a); else
+int swsusp_state[3] = {0,	/* when set to 1 swsusp_mainloop activates software_suspend
+				   bit 0: off = normal state, on = suspend required
+				   bit 1: reserved for future use
+				*/
+		       0,	/* action parameter:
+				   bit 0: off = halt, on = reboot 
+				   bit 1: off = eatmem, on = freemem
+				   bit 2: reserved for future use
+				   bit 3: reserved for future use
+				*/
+		       SUSPEND_PROGRESS};
+				/* debugging parameter is an OR of flags:
+				   bit 0: debugging messages
+				   bit 1: display progression
+				   bit 2: very verbose mode
+				   bit 3: slow down process
+				*/
+#else
+# define PRINTK(f, a...)
+# define MDELAY(a)
+int swsusp_state[3] = {0,0,-1};	/* see above for signification of values */
+#endif
+
+// |= 0x2 is the flag that we are aborting the process.
+#define abort_suspend(f, a...) do { \
+	printk(f, ## a); \
+	swsusp_state[0] |= 0x2; \
+} while(0)
+
+static void prepare_status(char * msg, char * action)
+{
+#if defined(SUSPEND_CONSOLE)
+	char posn[2];
+	unsigned int currcons = fg_console;
+
+	if (swsusp_state[2] & (SUSPEND_DEBUG | SUSPEND_VERBOSE))
+		return;
+	if (!(swsusp_state[2] & SUSPEND_PROGRESS))
+		return;
+	
+	hide_cursor(SUSPEND_CONSOLE);
+
+	barwidth = (video_num_columns - (video_num_columns / 2) - 1);
+	barposn = 0;
+
+	/* Print header */
+	posn[0] = (char) ((video_num_columns - 29) / 2);
+	posn[1] = (char) ((video_num_lines / 3) -4);
+	putconsxy(fg_console, posn);
+	vt_console_print(suspend_console, msg, strlen(msg));
+		
+	/* Print action */
+	posn[0] = (char) (video_num_columns / 4);
+	posn[1] = (char) (video_num_lines / 3);
+	putconsxy(fg_console, posn);
+	
+	/* Blank out previous contents of line - assumes text length <= bar width */
+	for (barposn = 0; barposn < barwidth; barposn++) 
+		vt_console_print(suspend_console, " ", 1);
+	
+	putconsxy(fg_console, posn);
+	vt_console_print(suspend_console, action, strlen(action)); 
+
+	/* Draw left bracket of progress bar. */
+	posn[1]++;
+	putconsxy(fg_console, posn);
+	vt_console_print(suspend_console, "[", 1);
+
+	/* Draw right bracket of progress bar. */
+	posn[0] = (char) (video_num_columns - (video_num_columns / 4));
+	putconsxy(fg_console, posn);
+	vt_console_print(suspend_console, "]", 1);
+
+	/* Position at start of progress */
+	posn[0] = (char) (video_num_columns / 4 + 1);
+	putconsxy(fg_console, posn);
+
+	/* Clear bar */
+	for (barposn = 0; barposn < barwidth; barposn++)
+		vt_console_print(suspend_console, " ", 1);
+	putconsxy(fg_console, posn);
+
+	barposn = 0;
+	lastpercentage = 0;
+	hide_cursor(SUSPEND_CONSOLE);
+	MDELAY(1000);
+#endif
+}
+
+static void update_status(char *msg, int percentage)
+{
+#if defined(SUSPEND_CONSOLE)
+	if (swsusp_state[2] & (SUSPEND_DEBUG | SUSPEND_VERBOSE))
+		return;
+	if (!(swsusp_state[2] & SUSPEND_PROGRESS))
+		return;
+	
+	if (percentage < 0)
+		percentage = 0;
+	if (percentage > 100)
+		percentage = 100;
+
+	newbarposn = (int) (percentage * barwidth / 100);
+	
+	if (newbarposn == barposn)
+		return;       
+
+	lastpercentage = percentage;
+	
+	for (; barposn < newbarposn; barposn++)
+		vt_console_print(suspend_console, "-", 1);
+	barposn = newbarposn;
+	hide_cursor(SUSPEND_CONSOLE);
+#endif
+}
+/*
+ * Refrigerator and related stuff
+ */
+
+#define INTERESTING(p) \
+			/* We don't want to touch kernel_threads..*/ \
+			if (p->flags & PF_IOTHREAD) \
+				continue; \
+			if (p == current) \
+				continue; \
+			if (p->state == TASK_ZOMBIE) \
+				continue;
+
+/* Refrigerator is place where frozen processes are stored :-). */
+void refrigerator(unsigned long flag)
+{
+	/* You need correct to work with real-time processes.
+	   OTOH, this way one process may see (via /proc/) some other
+	   process in stopped state (and thereby discovered we were
+	   suspended. We probably do not care. 
+	 */
+	long save;
+	save = current->state;
+	current->state = TASK_STOPPED;
+	PRINTK(SUSPEND_DEBUG, "=");
+	PRINTK(SUSPEND_VERBOSE, "%s entered refrigerator (%lx)\n", current->comm, flag);
+	current->flags &= ~PF_FREEZE;
+	if (flag)
+		flush_signals(current); /* We have signaled a kernel thread, which isn't normal behaviour
+					   and that may lead to 100%CPU sucking because those threads
+					   just don't manage signals. */
+	current->flags |= PF_FROZEN;
+	while (current->flags & PF_FROZEN)
+		schedule();
+	PRINTK(SUSPEND_VERBOSE, "%s left refrigerator (%lx)\n", current->comm, flag);
+	current->state = save;
+}
+
+/* 0 = success, else # of processes that we failed to stop */
+static int freeze_processes(void)
+{
+	int todo, start_time;
+	struct task_struct *p;
+	
+	PRINTK(SUSPEND_DEBUG, name_suspend "Stopping tasks\n" );
+	prepare_status(console_suspend, "Freezing processes...");
+
+	start_time = jiffies;
+	do {
+		todo = 0;
+		read_lock(&tasklist_lock);
+		for_each_task(p) {
+			unsigned long flags;
+			INTERESTING(p);
+			if (p->flags & PF_FROZEN)
+				continue;
+			if (p->state == TASK_STOPPED) {	/* this task is a stopped but not frozen one */
+				/* FIXME: what if a task is waken between this point and suspension ? */
+				p->flags |= PF_IOTHREAD;
+				PRINTK(SUSPEND_DEBUG,"+");
+				PRINTK(SUSPEND_VERBOSE,"%s is already stopped\n", p->comm);
+				continue;
+			}
+			/* FIXME: smp problem here: we may not access other process' flags
+			   without locking */
+			p->flags |= PF_FREEZE;
+			spin_lock_irqsave(&p->sigmask_lock, flags);
+			signal_wake_up(p);
+			spin_unlock_irqrestore(&p->sigmask_lock, flags);
+			todo++;
+		}
+		read_unlock(&tasklist_lock);
+		sys_sched_yield();
+		schedule();
+		if (time_after(jiffies, start_time + TIMEOUT)) {
+			PRINTK(SUSPEND_DEBUG,"\n");
+			printk(KERN_ERR name_suspend " stopping tasks failed (%d tasks remaining)\n", todo );
+			return todo;
+		}
+	} while(todo);
+	
+	PRINTK(SUSPEND_DEBUG,"|\n");
+	return 0;
+}
+
+static void thaw_processes(void)
+{
+	struct task_struct *p;
+
+	PRINTK(SUSPEND_DEBUG, name_resume "Restarting tasks\n");
+	read_lock(&tasklist_lock);
+	for_each_task(p) {
+		if ((p->flags & PF_IOTHREAD)
+		   && (p->state == TASK_STOPPED)) { /* This is a previously stopped job */
+			p->flags &= ~PF_IOTHREAD; /* we assume here that a kernel thread with PF_IOTHREAD
+						     is *never* stopped */
+			PRINTK(SUSPEND_DEBUG, "+");
+			PRINTK(SUSPEND_VERBOSE, KERN_INFO name_resume " %s was stopped\n", p->comm );
+			continue; /* we don't want to wake up this job */
+		}
+		INTERESTING(p);
+		
+		if (p->flags & PF_FROZEN) {
+	        	p->flags &= ~PF_FROZEN;
+			PRINTK(SUSPEND_DEBUG, "-");
+		} else
+			printk(KERN_INFO " Strange, %s not stopped\n", p->comm );
+		wake_up_process(p);
+	}
+	read_unlock(&tasklist_lock);
+	PRINTK(SUSPEND_DEBUG, "|\n");
+	MDELAY(500);
+}
+
+/*
+ * Saving part...
+ */
+
+static __inline__ int fill_suspend_header(struct suspend_header *sh)
+{
+	memset((char *)sh, 0, sizeof(*sh));
+
+	sh->version_code = LINUX_VERSION_CODE;
+	sh->num_physpages = num_physpages;
+	strncpy(sh->machine, system_utsname.machine, 65);
+	strncpy(sh->version, system_utsname.version, 65);
+	sh->num_cpus = smp_num_cpus;
+	sh->page_size = PAGE_SIZE;
+	sh->suspend_pagedir = pagedir_nosave;
+	if (pagedir_save != pagedir_nosave) {
+		abort_suspend("Pagedir_save != Pagedir_nosave!");
+		return 1;
+	}
+	sh->pageset1_size = pageset1_size;
+	/* TODO: needed? mounted fs' last mounted date comparison
+	 * [so they haven't been mounted since last suspend.
+	 * Maybe it isn't.] [we'd need to do this for _all_ fs-es]
+	 */
+	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)
+{
+	while (1) {
+		run_task_queue(&tq_disk);
+		if (!TQ_ACTIVE(tq_disk))
+			break;
+		printk(KERN_ERR "Hm, tq_disk is not empty after run_task_queue\n");
+	}
+}
+
+/* We memorize in swapfile_used what swap devices are used for suspension */
+#define SWAPFILE_UNUSED    0
+#define SWAPFILE_SUSPEND   1	/* This is the suspending device */
+#define SWAPFILE_IGNORED   2	/* Those are other swap devices ignored for suspension */
+
+static unsigned short swapfile_used[MAX_SWAPFILES];
+static unsigned short root_swap;
+#define MARK_SWAP_SUSPEND 0
+#define MARK_SWAP_RECOVER 1
+#define MARK_SWAP_RESUME 2
+
+static inline int sync_page(struct page *page)
+{
+	struct address_space *mapping = page->mapping;
+
+	if (mapping && mapping->a_ops && mapping->a_ops->sync_page)
+		return mapping->a_ops->sync_page(page);
+	return 0;
+}
+
+static int rw_swap_page_nofree(int rw, swp_entry_t entry, union p_diskpage cur)
+{
+	struct page *page;
+
+	page=virt_to_page(cur.address);
+	lock_page(page);
+	PRINTK(SUSPEND_DEBUG, "rw(page:%p) ",page);
+	rw_swap_page_nolock_norfree(rw, entry, cur.ptr);
+	sync_page(page);
+	if(!Page_Uptodate(page)) {
+		abort_suspend("Page not up-to-date in rw_swap_page_nofree!\n");
+		return 1;
+	}
+	return 0;
+}
+
+static int rw_swap_page_sync(int rw, swp_entry_t entry, union p_diskpage cur)
+{
+	struct page *page;
+	//unsigned long dummy1;
+	//struct inode *dummy2;
+
+	page=virt_to_page(cur.address);	
+	lock_page(page);
+	//get_swaphandle_info(entry, &dummy1, &suspend_device, &dummy2);
+	rw_swap_page_nolock(rw, entry, cur.ptr);
+	sync_page(page);
+	if(!Page_Uptodate(page)) {
+		abort_suspend("Page not up-to-date in rw_swap_page_nofree!\n");
+		return 1;
+	}
+	return 0;
+}
+
+static void mark_swapfiles(swp_entry_t prev, int mode)
+{
+	swp_entry_t entry;
+	union p_diskpage cur;
+	struct page *page;
+
+	page = alloc_page(GFP_ATOMIC);
+	if (!page) {
+		abort_suspend("Out of memory in mark_swapfiles");
+		return;
+	}	
+	cur.pointer = page_address(page);
+	/* XXX: this is dirty hack to get first page of swap file */
+	entry = SWP_ENTRY(root_swap, 0);
+	if (rw_swap_page_sync(READ, entry, cur)) {
+		__free_page(page);
+		return;
+	}
+
+	switch(mode) {
+	case MARK_SWAP_RESUME:
+		if (!memcmp("SUSP1R",cur.pointer->swh.magic.magic,6))
+			memcpy(cur.pointer->swh.magic.magic,"SWAP-SPACE",10);
+		else if (!memcmp("SUSP2R",cur.pointer->swh.magic.magic,6))
+			memcpy(cur.pointer->swh.magic.magic,"SWAPSPACE2",10);
+		else printk(name_resume "Unable to find suspended-data signature (%.10s - misspelled?\n", 
+			    cur.pointer->swh.magic.magic);
+		break;
+	case MARK_SWAP_RECOVER:
+		if (!memcmp("SUSP1R",cur.pointer->swh.magic.magic,6))
+			memcpy(cur.pointer->swh.magic.magic,"SWAP-SPACE",10);
+		else if (!memcmp("SUSP2R",cur.pointer->swh.magic.magic,6))
+			memcpy(cur.pointer->swh.magic.magic,"SWAPSPACE2",10);
+	  	else if ((!memcmp("SWAP-SPACE",cur.pointer->swh.magic.magic,10))
+			 &&(!memcmp("SWAPSPACE2",cur.pointer->swh.magic.magic,10))) {
+			abort_suspend("\nSwapspace is altered (%.10s)\n", cur.pointer->swh.magic.magic);
+			__free_page(page);
+			return;
+		}
+		break;
+	case MARK_SWAP_SUSPEND:
+	  	if ((!memcmp("SWAP-SPACE",cur.pointer->swh.magic.magic,10)))
+		  	memcpy(cur.pointer->swh.magic.magic,"SUSP1R....",10);
+		else if ((!memcmp("SWAPSPACE2",cur.pointer->swh.magic.magic,10)))
+			memcpy(cur.pointer->swh.magic.magic,"SUSP2R....",10);
+		else {
+			abort_suspend("\nSwapspace is not swapspace (%.10s)\n", cur.pointer->swh.magic.magic);
+			__free_page(page);
+			return;
+		}
+		cur.pointer->link.next = prev; /* prev is the first/last swap page of the resume area */
+		/* link.next lies *no more* in last 4 bytes of magic */
+		break;
+	}
+	rw_swap_page_sync(WRITE, entry, cur);
+	
+	__free_page(page);
+}
+
+static void read_swapfiles(void) /* This is called before saving image */
+{
+	int i, len;
+	
+	len=strlen(resume_file);
+	root_swap = 0xFFFF;
+	
+	swap_list_lock();
+	for(i=0; i<MAX_SWAPFILES; i++) {
+		if (swap_info[i].flags == 0) {
+			swapfile_used[i]=SWAPFILE_UNUSED;
+		} else {
+			if (!len) {
+	    			printk("resume= option should be used to set suspend device" );
+				if (root_swap == 0xFFFF) {
+					swapfile_used[i] = SWAPFILE_SUSPEND;
+					root_swap = i;
+				} else
+					swapfile_used[i] = SWAPFILE_IGNORED;				  
+			} else {
+	  			/* we ignore all swap devices that are not the resume_file */
+				if (resume_device == swap_info[i].swap_device) {
+					swapfile_used[i] = SWAPFILE_SUSPEND;
+					root_swap = i;
+				} else {
+					PRINTK(SUSPEND_DEBUG, name_suspend "device %s (%x != %x) ignored\n", swap_info[i].swap_file->d_name.name, swap_info[i].swap_device, resume_device);
+				  	swapfile_used[i] = SWAPFILE_IGNORED;
+				}
+			}
+		}
+	}
+	swap_list_unlock();
+}
+
+static void lock_swapdevices(void) /* This is called after saving image so modification
+				      will be lost after resume... and that's what we want. */
+{
+	int i;
+
+	swap_list_lock();
+	for(i = 0; i< MAX_SWAPFILES; i++)
+		if (swapfile_used[i] == SWAPFILE_IGNORED) {
+			swap_info[i].flags ^= 0xFF; /* we make the device unusable. A new call to
+						       lock_swapdevices can unlock the devices. */
+		}
+	swap_list_unlock();
+}
+
+static int write_suspend_image(void)
+{
+	int i, len, *ptr;
+	swp_entry_t entry, prev = { 0 };
+	int nr_pgdir_pages = SUSPEND_PD_PAGES(pageset1_size);
+	union p_diskpage cur, buffer;
+
+#define abort_and_exit(f, a...) do { \
+			abort_suspend(f, ## a); \
+			return -1; \
+	} while(0)
+
+	buffer.address = get_free_page(GFP_ATOMIC);
+	PRINTK(SUSPEND_DEBUG, name_suspend "Writing data to swap (%d pages)\n", pageset1_size);
+	prepare_status(console_suspend, "Writing suspend image...");
+
+	for (i=0; i<pageset1_size; i++) {
+		if (!(i%100))
+			PRINTK(SUSPEND_DEBUG, ".");
+		update_status(console_suspend, (int) (i * 100 / (pageset1_size+nr_pgdir_pages+2)));
+
+		entry = get_swap_page();
+		if (!entry.val)
+			abort_and_exit("Not enough swapspace when writing data.\n");
+		if (swapfile_used[SWP_TYPE(entry)] != SWAPFILE_SUSPEND)
+			abort_and_exit("Page %d: not enough swapspace on suspend device.\n", i);
+/* CBD: pagedir is a dirty hack. Here we advance by i*sizeof(suspend_pagedir_t) and we fill with adresses */
+		cur.address = (pagedir_nosave+i)->address3;
+		if (rw_swap_page_sync(WRITE, entry, cur))
+			return -1;
+		(pagedir_nosave+i)->swap_address1 = entry;
+	}
+	PRINTK(SUSPEND_DEBUG, "|\n");
+	PRINTK(SUSPEND_DEBUG, name_suspend "Writing pagedir (%d pages)\n", nr_pgdir_pages);
+	for (i=0; i<nr_pgdir_pages; i++) {
+/* CBD: Here we advance by a PAGE_SIZE because (union diskpage).link is of that maximal size */
+		cur.pointer = (union diskpage *)pagedir_nosave + i;
+		if (cur.ptr != (((char *) pagedir_nosave) + i*PAGE_SIZE))
+			abort_and_exit("cur.ptr != Pagedir_nosave + i * PAGESIZE! \n");
+		PRINTK(SUSPEND_DEBUG, ".");
+		update_status(console_suspend, (int) ((i+pageset1_size) * 100 / (pageset1_size+nr_pgdir_pages+2)));
+		entry = get_swap_page();
+		if (!entry.val)
+			abort_and_exit("Not enough swapspace when writing pgdir\n");		
+		if (swapfile_used[SWP_TYPE(entry)] != SWAPFILE_SUSPEND)
+			abort_and_exit("Not enough swapspace for pagedir on suspend device\n");
+		if (sizeof(swp_entry_t) != sizeof(long))
+			abort_and_exit("Size of swp_entry_t != size of long in write_pagedir_and_suspend_header!\n");
+		if (PAGE_SIZE % sizeof(struct pbe))
+			abort_and_exit("Page size (%ld) mod size of struct pbe (%d) is not 0 (%ld) in write_pagedir_and_suspend_header!\n", PAGE_SIZE, sizeof(struct pbe), PAGE_SIZE % sizeof(struct pbe));
+		cur.pointer->link.next = prev;				
+		if (rw_swap_page_nofree(WRITE, entry, cur))
+			return -1;
+		prev = entry;
+	}
+	PRINTK(SUSPEND_DEBUG, "H");
+#ifdef SOFTWARE_SUSPEND_MTRR
+	ptr = mtrr_suspend();
+	if(ptr)
+		len = *ptr;
+	else
+#endif
+	{
+		len = 4;	/* we need to put a zero */
+		ptr = NULL;
+	}
+	if (len + sizeof(struct suspend_header) > PAGE_SIZE-sizeof(swp_entry_t))
+		abort_and_exit("Size of suspend header too big!\n");
+	if (sizeof(union diskpage) != PAGE_SIZE)
+		abort_and_exit("Size of a disk page is not PAGE_SIZE!\n");
+	entry = get_swap_page();
+	if (!entry.val)
+		abort_and_exit("Not enough swapspace when writing header!\n");
+	if (swapfile_used[SWP_TYPE(entry)] != SWAPFILE_SUSPEND)
+		abort_and_exit("Not enough swapspace for header on suspend device!\n" );
+
+	cur = buffer;
+	if (fill_suspend_header(&(cur.pointer->sh)))
+		abort_and_exit("Out of memory while writing header!\n");
+	if(ptr)
+		memcpy(cur.ptr+sizeof(struct suspend_header), ptr, len);
+	else {
+		len = 0;
+		ptr = &len;
+		memcpy(cur.ptr+sizeof(struct suspend_header), ptr, sizeof(int));
+	}	
+	cur.pointer->link.next = prev;
+
+	if (rw_swap_page_nofree(WRITE, entry, cur))
+		return -1;
+	prev = entry;
+
+	PRINTK(SUSPEND_DEBUG, "S");
+	update_status(console_suspend, (int) ((nr_pgdir_pages+pageset1_size+1) * 100 / (pageset1_size+nr_pgdir_pages+2)));
+	mark_swapfiles(prev, MARK_SWAP_SUSPEND);
+	if (SUSPEND_ABORTING)
+		return -1;
+	PRINTK(SUSPEND_DEBUG, "|\n");
+	update_status(console_suspend, 100);
+
+	MDELAY(1000);
+	free_page(buffer.address);
+	return 0;
+}
+
+/* if pagedir_p != NULL it also copies the counted pages */
+static int count_and_copy_data_pages(struct pbe *pagedir_p)
+{
+	int chunk_size;
+	int pageset1_size = 0;
+	int loop;
+	
+	if (pagedir_p)
+		prepare_status(console_suspend, "Copying pages...");
+	else
+		prepare_status(console_suspend, "Counting pages...");
+	generate_free_page_map();
+	if (max_mapnr != num_physpages) {
+		abort_suspend("mapnr is not expected");
+		return 0;
+	}
+	for (loop = 0; loop < max_mapnr; loop++) {
+		update_status(console_suspend, loop * 100 / max_mapnr);
+		if (PageHighMem(mem_map+loop)) {
+			abort_suspend("Swsusp not supported on highmem boxes. Send 1GB of RAM to <pavel@ucw.cz> and try again ;-).");
+			return 0;
+		}
+		if (!PageReserved(mem_map+loop)) {
+			if (PageNosave(mem_map+loop))
+				continue;
+
+			if ((chunk_size=is_head_of_free_region(loop))!=0) {
+				loop += chunk_size - 1;
+				continue;
+			}
+		} else if (PageReserved(mem_map+loop)) {
+			if (PageNosave(mem_map+loop)) {
+				abort_suspend("Reserved page marked nosave!\n");
+				return 0;
+			}
+			/*
+			 * Just copy whole code segment. Hopefully it is not that big.
+			 */
+			if (ADDRESS(loop) >= (unsigned long)
+				&__nosave_begin && ADDRESS(loop) < 
+				(unsigned long)&__nosave_end) {
+				PRINTK(SUSPEND_VERBOSE, name_suspend "[nosave %lx]\n", ADDRESS(loop));
+				continue;
+			}
+			/* Hmm, perhaps copying all reserved pages is not too healthy as they may contain 
+			   critical bios data? */
+		} else BUG();
+
+		pageset1_size++;
+		if (pagedir_p) {
+			pagedir_p->address1 = ADDRESS(loop);
+			copy_page(pagedir_p->address3, pagedir_p->address1);
+			pagedir_p++;
+		}
+	}
+	update_status(console_suspend, 100);
+	return pageset1_size;
+}
+
+static void free_suspend_pagedir(suspend_pagedir_t *pagedir)
+{
+	struct page *page = mem_map;
+	int i;
+	unsigned long this_pagedir, this_pagedir_end;
+
+	this_pagedir = (unsigned long) pagedir;
+	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 pageset1_size)
+{
+	int i;
+	suspend_pagedir_t *pagedir;
+	struct pbe *p;
+	struct page *page;
+
+	pagedir_order = get_bitmask_order(SUSPEND_PD_PAGES(pageset1_size));
+
+	p = pagedir = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+	if (!pagedir)
+		return NULL;
+
+	page = virt_to_page(pagedir);
+	for(i=0; i < 1<<pagedir_order; i++)
+		PageSetNosave(page++);
+		
+	while(pageset1_size--) {
+		p->address3 = get_free_page(GFP_ATOMIC);
+		if(!p->address3) {
+			panic("oom");
+			free_suspend_pagedir(pagedir);
+			return NULL;
+		}
+		PageSetNosave(virt_to_page(p->address3));
+		p->address1 = 0;
+		p++;
+	}
+	return pagedir;
+}
+
+static int prepare_suspend_console(char *msg)
+{
+	orig_loglevel = console_loglevel;
+	console_loglevel = new_loglevel;
+
+#ifdef CONFIG_VT
+	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)) {
+		PRINTK(SUSPEND_DEBUG, "Can't switch virtual consoles.");
+		return 1;
+	}
+	reset_terminal(SUSPEND_CONSOLE, 1);
+	orig_kmsg = kmsg_redirect;
+	kmsg_redirect = SUSPEND_CONSOLE;
+	prepare_status(msg, "");
+# endif
+#endif
+	return 0;
+}
+
+static void restore_console(void)
+{
+	console_loglevel = orig_loglevel;
+#ifdef SUSPEND_CONSOLE
+	kmsg_redirect = orig_kmsg;
+	set_console (orig_fgconsole);
+#endif
+	return;
+}
+
+static int prepare_suspend_processes(void)
+{
+	if (freeze_processes()) {
+		PRINTK(SUSPEND_DEBUG, name_suspend "Not all processes stopped!\n");
+		thaw_processes();
+		return 1;
+	}
+	sys_sync();
+	return 0;
+}
+
+/*
+ *	Free as much memory as possible
+ */
+
+static void **eaten_memory = NULL;
+
+static int eat_memory(void)
+{
+	int i = 0;
+	void **c= eaten_memory, *m;
+
+	PRINTK(SUSPEND_DEBUG, name_suspend "Eating pages\n");
+	prepare_status(console_suspend, "Eating memory...");
+
+	while ((m = (void *) get_free_page(GFP_HIGHUSER | __GFP_FAST))) {
+		memset(m, 0, PAGE_SIZE);
+		eaten_memory = m;
+		if (!(i%100)) {
+			PRINTK(SUSPEND_DEBUG, ".");
+			PRINTK(SUSPEND_VERBOSE, "%d", i);
+		}
+		*eaten_memory = c;
+		c = eaten_memory;
+		update_status(console_suspend, i*100/75000);
+		i++; 
+	}
+	PRINTK(SUSPEND_DEBUG, "(%dK)\n", i*4);
+	update_status(console_suspend, 100);
+	return(i);
+}
+
+static void free_memory(int nb)
+{
+	int i = 0;
+	void **c = eaten_memory, *f;
+	
+	PRINTK(SUSPEND_DEBUG, name_suspend "Freeing pages\n");
+	prepare_status(console_suspend, "Freeing memory...");
+	while (c) {
+		if (!(i%100))
+			PRINTK(SUSPEND_DEBUG, "."); 
+		f = c;
+		c = *c;
+		free_page( (long) f );
+		update_status(console_suspend, i*100/nb);
+		i++;
+	}
+	PRINTK(SUSPEND_DEBUG, "(%dK)\n", i*4);
+	eaten_memory = NULL;
+	update_status(console_suspend, 100);
+}
+
+/*
+ * Try to free as much memory as possible, but do not OOM-kill anyone
+ *
+ * Notice: all userland should be stopped at this point, or livelock is possible.
+ */
+static void free_some_memory(void)
+{
+	int nb;
+	
+	if (SUSPEND_FREEMEM) {
+		PRINTK(SUSPEND_DEBUG, name_suspend "Freeing memory\n");
+		while (try_to_free_pages_zone(&contig_page_data.node_zones[ZONE_HIGHMEM], GFP_KSWAPD))
+			PRINTK(SUSPEND_DEBUG, ".");
+		PRINTK(SUSPEND_DEBUG, "|\n");
+	} else {
+		PRINTK(SUSPEND_DEBUG, name_suspend "Using memeat\n");
+		nb=eat_memory();
+		free_memory(nb);
+	}
+}
+
+/* Make disk drivers accept operations, again */
+static void drivers_unsuspend(void)
+{
+#ifdef CONFIG_BLK_DEV_IDE
+	ide_disk_unsuspend();
+#endif
+}
+
+/* Called from process context */
+static int drivers_suspend(void)
+{
+#ifdef CONFIG_BLK_DEV_MD
+	md_notify_reboot(NULL, SYS_HALT, NULL);
+#endif
+#ifdef CONFIG_BLK_DEV_IDE
+	ide_disk_suspend();
+#endif
+	if (!pm_suspend_state) {
+		if (pm_send_all(PM_SUSPEND,(void *)3)) {
+			printk(name_suspend "Problem while sending suspend event\n");
+			return(1);
+		}
+		pm_suspend_state=1;
+	} else
+		PRINTK(SUSPEND_VERBOSE, name_suspend "PM suspend state already raised\n");
+	  
+	return(0);
+}
+
+#define RESUME_PHASE1 1 /* Called from interrupts disabled */
+#define RESUME_PHASE2 2 /* Called with interrupts enabled */
+#define RESUME_ALL_PHASES (RESUME_PHASE1 | RESUME_PHASE2)
+static void drivers_resume(int flags)
+{
+  	if(flags & RESUME_PHASE2) {
+#ifdef CONFIG_BLK_DEV_HD
+		do_reset_hd();			/* Kill all controller state */
+#endif
+	}
+  	if (flags & RESUME_PHASE1) {
+#ifdef CONFIG_BLK_DEV_IDE
+		ide_disk_unsuspend();
+#endif
+#ifdef CONFIG_BLK_DEV_MD
+		md_autostart_arrays();
+#endif
+	}
+  	if (flags & RESUME_PHASE2) {
+		if (pm_suspend_state) {
+			if (pm_send_all(PM_RESUME,(void *)0))
+				printk(name_resume "Problem while sending resume event\n");
+			pm_suspend_state=0;
+		} else
+			PRINTK(SUSPEND_DEBUG, name_resume "PM suspend state wasn't raised\n");
+
+#ifdef SUSPEND_CONSOLE
+		update_screen(fg_console);	/* Hmm, is this the problem? */
+#endif
+	}
+}
+
+static int save_suspend_image(void)
+{
+	struct sysinfo i;
+	unsigned int nr_needed_pages = 0;
+
+	pagedir_nosave = NULL;
+	PRINTK(SUSPEND_VERBOSE, name_suspend "/critical section: Counting pages to copy");
+	pageset1_size = count_and_copy_data_pages(NULL);
+	nr_needed_pages = pageset1_size + PAGES_FOR_IO;
+	
+	if (SUSPEND_ABORTING)
+		return -1;
+
+	PRINTK(SUSPEND_DEBUG, name_suspend " (pages needed: %d+%d=%d free: %d)\n",pageset1_size,PAGES_FOR_IO,nr_needed_pages,nr_free_pages());
+	if (nr_free_pages() < nr_needed_pages) {
+		printk(KERN_CRIT name_suspend "Couldn't get enough free pages, on %d pages short\n",
+			 nr_needed_pages-nr_free_pages());
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+	si_swapinfo(&i);	/* FIXME: si_swapinfo(&i) returns all swap devices information.
+				   We should only consider resume_device. */
+	if (i.freeswap < nr_needed_pages)  {
+		printk(KERN_CRIT name_suspend "There's not enough swap space available, free: %ld need: %d lacks: %ld\n",
+		       i.freeswap,
+		       nr_needed_pages,
+		       nr_needed_pages-i.freeswap);
+		spin_unlock_irq(&suspend_pagedir_lock);
+		return 1;
+	}
+
+#define abort_and_return(f, a...) do	{ \
+		abort_suspend(f, ## a); \
+		free_suspend_pagedir(pagedir_save); \
+		spin_unlock_irq(&suspend_pagedir_lock); \
+		return 1; \
+	} while(0)
+	
+	PRINTK(SUSPEND_VERBOSE, "Alloc pagedir\n"); 
+	pagedir_nosave = create_suspend_pagedir(pageset1_size);
+	pagedir_save = pagedir_nosave;
+	if (!pagedir_nosave) {
+		/* Shouldn't happen */
+		printk(KERN_CRIT name_suspend "Couldn't allocate enough pages\n");
+		abort_and_return("Really should not happen");
+	}
+	pageset1_size_check = pageset1_size;
+	pagedir_order_check = pagedir_order;
+
+	if (pageset1_size != count_and_copy_data_pages(pagedir_nosave))	/* copy */
+		abort_and_return("Number of pages copied doesn't match previous count!\n");
+
+	/*
+	 * 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.
+	 *
+	 * Following line enforces not writing to disk until we choose.
+	 */
+	drivers_unsuspend();
+	spin_unlock_irq(&suspend_pagedir_lock);
+	PRINTK(SUSPEND_VERBOSE, name_suspend "critical section/: done (%d pages copied)\n", pageset1_size);
+
+	lock_swapdevices();
+	write_suspend_image();
+	lock_swapdevices();	/* This will unlock ignored swap devices since writing is finished */
+	if (SUSPEND_ABORTING)
+		return -1;
+	return 0;
+}
+
+extern void (*pm_power_off)(void);
+extern void swsusp_power_off(void);
+void suspend_power_down(void)
+{
+	C_A_D = 0;
+	PRINTK(SUSPEND_DEBUG, name_suspend "Trying to power down.\n");
+	mdelay(1000);		/* FIXME: we need to flush hw disk cache
+				   in a more certain way */
+#ifdef CONFIG_VT
+	if (SUSPEND_REBOOT)
+		machine_restart(NULL);
+	else
+#endif
+	{
+		if(!pm_power_off) {
+			pm_power_off=swsusp_power_off;
+			PRINTK(SUSPEND_DEBUG, name_suspend "Trying to use an apm bios call (you should enable apm or acpi)\n"); 
+		}
+		machine_power_off();
+	}
+
+	printk(KERN_EMERG name_suspend "Probably not capable for powerdown.\n");
+	machine_halt();
+	printk(KERN_EMERG name_suspend "System is now halted.\n");
+	while (1)
+		cpu_relax();
+	/* NOTREACHED */
+}
+
+/*
+ * Magic happens here
+ */
+
+static void do_magic_resume_1(void)
+{
+	barrier();
+	mb();
+	spin_lock_irq(&suspend_pagedir_lock);	/* Done to disable interrupts */ 
+
+	PRINTK(SUSPEND_DEBUG, name_resume "Waiting for DMAs to settle down...\n");
+	mdelay(1000);	/* We do not want some readahead with DMA to corrupt our memory, right?
+			   Do it with disabled interrupts for best effect. That way, if some
+			   driver scheduled DMA, we have good chance for DMA to finish ;-). */
+}
+
+static void do_magic_resume_2(void)
+{
+	if (pageset1_size_check != pageset1_size) {
+		abort_suspend("pageset1_size_check (%d) != pageset1_size (%d)", pageset1_size_check, pageset1_size);
+		return;
+	}
+	if (pagedir_order_check != pagedir_order) {
+		abort_suspend("pagedir_order_check (%d) != pagedir_order (%d)", pagedir_order_check, pagedir_order);
+		return;
+	}
+	prepare_status(console_resume, "Cleaning up...");
+	update_status(console_resume, 100);
+	PRINTK(SUSPEND_DEBUG, name_resume "Freeing prev allocated pagedir\n");
+	free_suspend_pagedir(pagedir_save);
+	__flush_tlb_global();		/* Even mappings of "global" things (vmalloc) need to be fixed */
+	drivers_resume(RESUME_ALL_PHASES);
+	spin_unlock_irq(&suspend_pagedir_lock);
+
+	PRINTK(SUSPEND_DEBUG, name_resume "Fixing swap signatures... ");
+	mark_swapfiles(((swp_entry_t) {0}), MARK_SWAP_RESUME);
+	PRINTK(SUSPEND_DEBUG, "ok\n");
+
+#ifdef SUSPEND_CONSOLE
+	update_screen(fg_console);	/* Hmm, is this the problem? */
+#endif
+}
+
+static void do_magic_suspend_1(void)
+{
+	mb();
+	barrier();
+	spin_lock_irq(&suspend_pagedir_lock);
+}
+
+static void do_magic_suspend_2(void)
+{
+	read_swapfiles();
+	if (!save_suspend_image())
+		suspend_power_down ();
+	printk(KERN_EMERG name_suspend "Suspend failed, trying to recover...\n");
+	MDELAY(1000); /* So user can wait and report us messages if armageddon comes :-) */
+
+	barrier();
+	mb();
+	drivers_resume(RESUME_PHASE2);
+	spin_lock_irq(&suspend_pagedir_lock);	/* Done to disable interrupts */ 
+	mdelay(1000);
+
+	free_pages((unsigned long) pagedir_nosave, pagedir_order);
+	drivers_resume(RESUME_PHASE1);
+	spin_unlock_irq(&suspend_pagedir_lock);
+	mark_swapfiles(((swp_entry_t) {0}), MARK_SWAP_RECOVER);
+	PRINTK(SUSPEND_DEBUG, name_suspend "Leaving do_magic_suspend_2...\n");	
+}
+
+#define SUSPEND_C
+#include <asm/suspend.h>
+
+/*
+ * 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)
+{
+	if (prepare_suspend_console(console_suspend))
+		printk(name_suspend "Can't allocate a console... proceeding\n");
+	if (!prepare_suspend_processes()) {
+		free_some_memory();
+
+		/* No need to invalidate any vfsmnt list -- they will be valid after resume, anyway.
+		 *
+		 * We sync here -- so you have consistent filesystem state when things go wrong.
+		 * -- so that noone writes to disk after we do atomic copy of data.
+		 */
+		PRINTK(SUSPEND_DEBUG, name_suspend "Syncing disks before copy\n" );
+		do_suspend_sync();
+		if (drivers_suspend()==0)
+			do_suspend_lowlevel(0);			/* This function returns after machine woken up from resume */
+		PRINTK(SUSPEND_DEBUG, name_resume "Restarting processes...\n");
+		thaw_processes();
+	}
+	
+	software_suspend_enabled = 1;
+	MDELAY(1000);
+	restore_console ();
+}
+
+static void software_suspend(void)
+{
+	PRINTK(SUSPEND_DEBUG, name_swsusp "Entering software_suspend\n");
+	if (!software_suspend_enabled) {
+		printk(name_swsusp "software suspend is disabled\n");
+		return;
+	}
+	software_suspend_enabled = 0;
+	if (!(cpu_has_pse||cpu_has_pse36)) {
+		printk(name_swsusp "pse or pse36 is required, disabling software suspend");
+		return;
+	}
+	if (in_interrupt())
+		BUG();
+	do_software_suspend();
+}
+
+/*
+ * This is main interface to the outside world. It needs to be
+ * called from process context. It notifies kswsuspd thread
+ * through SUSPEND_PENDING and wait for resume.
+ */
+void software_suspend_pending(void)
+{
+	swsusp_state[0] = 1;
+	while(SUSPEND_PENDING) {
+	  	schedule();
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
+		set_current_state(TASK_INTERRUPTIBLE); /* wait for resume */
+	}
+}
+
+/* More restore stuff */
+
+/* FIXME: Why not memcpy(to, from, 1<<pagedir_order*PAGE_SIZE)? */
+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_nosave, addr, 0)
+
+/*
+ * Returns true if given address/order collides with any address1 
+ */
+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 < pageset1_size; i++)
+		if ((pagedir+i)->address1 >= addr &&
+			(pagedir+i)->address1 < 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 < pageset1_size; i++) {
+		unsigned long addr;
+
+		do {
+			addr = get_free_page(GFP_ATOMIC);
+			if (!addr)
+				return -ENOMEM;
+		} while (does_collide(addr));
+
+		(pagedir_nosave+i)->address3 = addr;
+	}
+	return 0;
+}
+
+static int relocate_pagedir(void)
+{
+	/*
+	 * We have to avoid recursion (not to overflow kernel stack),
+	 * and that's why code looks pretty cryptic 
+	 */
+	suspend_pagedir_t *new_pagedir, *old_pagedir = pagedir_nosave;
+	void **eaten_memory = NULL;
+	void **c = eaten_memory, *m, *f;
+
+	PRINTK(SUSPEND_DEBUG, name_resume "Relocating pagedir");
+
+	if (!does_collide_order(old_pagedir, (unsigned long)old_pagedir, pagedir_order)) {
+		PRINTK(SUSPEND_DEBUG, " isn't necessary\n");
+		return 0;
+	}
+	PRINTK(SUSPEND_DEBUG, "\nSeeking new pagedir location:    ");
+
+	while ((m = (void *) __get_free_pages(GFP_ATOMIC, pagedir_order))) {
+		memset(m, 0, PAGE_SIZE);
+		if (!does_collide_order(old_pagedir, (unsigned long)m, pagedir_order))
+			break;
+		eaten_memory = m;
+		PRINTK(SUSPEND_DEBUG, "."); 
+		*eaten_memory = c;
+		c = eaten_memory;
+	}
+	PRINTK(SUSPEND_DEBUG, "\n"); 
+
+	if (!m)
+		return -ENOMEM;
+
+	pagedir_nosave = new_pagedir = m;
+	copy_pagedir(new_pagedir, old_pagedir);
+
+	PRINTK(SUSPEND_DEBUG, "Freeing rejected memory locations");
+	c = eaten_memory;
+	while(c) {
+		PRINTK(SUSPEND_DEBUG, ":"); 
+		f = *c;
+		c = *c;
+		if (f)
+			free_pages((unsigned long)f, pagedir_order);
+	}
+	PRINTK(SUSPEND_DEBUG, "|\n");
+	return 0;
+}
+
+/*
+ * 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 int sanity_check_failed(char *reason)
+{
+	printk(KERN_ERR name_resume "%s\n",reason);
+	return -EPERM;
+}
+
+static int sanity_check(struct suspend_header *sh)
+{
+	if (sh->version_code != LINUX_VERSION_CODE)
+		return sanity_check_failed("Incorrect kernel version");
+	if (sh->num_physpages != num_physpages)
+		return sanity_check_failed("Incorrect memory size");
+	if (strncmp(sh->machine, system_utsname.machine, 65))
+		return sanity_check_failed("Incorrect machine type");
+	if (strncmp(sh->version, system_utsname.version, 65))
+		return sanity_check_failed("Incorrect version");
+	if (sh->num_cpus != smp_num_cpus)
+		return sanity_check_failed("Incorrect number of cpus");
+	if (sh->page_size != PAGE_SIZE)
+		return sanity_check_failed("Incorrect PAGE_SIZE");
+	return 0;
+}
+
+static int bdev_read_page(kdev_t dev, long pos, void *buf)
+{
+	struct buffer_head *bh;
+	if (pos%PAGE_SIZE)
+		abort_suspend("pos > pagesize!\n");
+	bh = bread(dev, pos/PAGE_SIZE, PAGE_SIZE);
+	if (!bh || (!bh->b_data)) {
+		return -1;
+	}
+	memcpy(buf, bh->b_data, PAGE_SIZE);
+	if (!buffer_uptodate(bh)) {
+		abort_suspend("buffer_uptodate false in bdev_read_page!\n");
+		brelse(bh);
+		return -1;
+	}
+	brelse(bh);
+	return 0;
+} 
+
+static int swsusp_mainloop(void *unused)
+{
+  	printk(name_swsusp "kswsuspd starting\n"); /* This will print the current version on boot */
+	daemonize();
+
+	strcpy(current->comm, "kswsuspd");
+	sigfillset(&current->blocked);
+	current->flags |= PF_IOTHREAD;
+
+	for(;;) {
+		set_current_state(TASK_INTERRUPTIBLE);
+		for(;!SUSPEND_PENDING;) {	  
+			schedule_timeout(SWSUSP_CHECK_TIMEOUT);
+			set_current_state(TASK_INTERRUPTIBLE);
+		}
+		software_suspend();
+		swsusp_state[0] = 0;
+	}
+	return(0);
+}
+
+static int noresume_fix_signature(union p_diskpage cur)
+{
+	struct buffer_head *bh;
+				/* We don't do a sanity check here: we want to restore the swap
+				   whatever version of kernel made the suspend image */
+	printk(name_resume "%s: Fixing swap signatures...\n", resume_file);
+				/* We need to write swap, but swap is *not* enabled so
+				   we must write the device directly */
+	bh = bread(resume_device, 0, PAGE_SIZE);
+	if (!bh || (!bh->b_data))
+		return -EIO;
+		
+	if (is_read_only(bh->b_dev)) {
+		printk(name_resume "Can't write to read-only device %s\n",
+		       kdevname(bh->b_dev));
+		return -EIO;
+	}
+	
+	memcpy(bh->b_data, cur.ptr, PAGE_SIZE);
+	generic_make_request(WRITE, bh);
+	wait_on_buffer(bh);
+	if (buffer_uptodate(bh)) {
+		brelse(bh);
+		return 0;
+	}
+	printk(name_resume "Warning %s: Fixing swap signatures unsuccessful...\n", resume_file);
+	bforget(bh);
+	return -EINVAL;		/* non fatal error */
+}
+
+static int __read_suspend_image(kdev_t bdev, union p_diskpage cur, int noresume)
+{				/* returned values:
+				   -EINVAL in case of swapspace or if noresume is set and swap signature
+				   wasn't correctly fixed (non fatal error),
+				   0 if suspended image was correctly read or if noresume is set
+				   and swap signature was correctly fixed,
+				   other non zero values are errors. */
+	swp_entry_t next;
+	int i, nr_pgdir_pages, len, *ptr;
+
+#define PREPARENEXT do { \
+		next = cur.pointer->link.next; \
+		next.val = SWP_OFFSET(next) * PAGE_SIZE; \
+        } while(0)
+	if (bdev_read_page(bdev, 0, cur.ptr)) return -EIO;
+
+	if ((!memcmp("SWAP-SPACE",cur.pointer->swh.magic.magic,10)) ||
+	    (!memcmp("SWAPSPACE2",cur.pointer->swh.magic.magic,10))) {
+		printk(KERN_ERR name_resume "This is normal swap space\n" );
+		return -EINVAL;	/* non fatal error */
+	}
+	PREPARENEXT; /* We have to read next position before we overwrite it */
+
+	if (!memcmp("SUSP1R",cur.pointer->swh.magic.magic,6))
+		memcpy(cur.pointer->swh.magic.magic,"SWAP-SPACE",10);
+	else if (!memcmp("SUSP2R",cur.pointer->swh.magic.magic,6))
+		memcpy(cur.pointer->swh.magic.magic,"SWAPSPACE2",10);
+	else {
+		printk("%sUnable to find suspended-data signature (%.10s - misspelled?\n", 
+			name_resume, cur.pointer->swh.magic.magic);
+		return -EINVAL;
+		/* We want to abort_suspend even with noresume -- we certainly don't want to add
+		   our signature into your ext2 filesystem ;-) */
+	}
+	if (noresume)
+		return(noresume_fix_signature(cur));
+	
+	if (prepare_suspend_console(console_resume))
+		printk(name_resume "Can't allocate a console... proceeding\n");
+	PRINTK(SUSPEND_VERBOSE, name_resume "Signature found, resuming\n");
+	MDELAY(1000);
+
+	if (bdev_read_page(bdev, next.val, cur.ptr)) return -EIO;	
+	if (sanity_check(&(cur.pointer->sh))) /* Is this the same machine? */
+		return -EPERM;
+#ifdef SOFTWARE_SUSPEND_MTRR
+	ptr = ((int *)cur.ptr)+sizeof(struct suspend_header);
+	len = *ptr;
+	if(len)
+		mtrr_resume(ptr);
+#endif
+	PREPARENEXT;
+
+	pagedir_save = cur.pointer->sh.suspend_pagedir;
+	pageset1_size = cur.pointer->sh.pageset1_size;
+	nr_pgdir_pages = SUSPEND_PD_PAGES(pageset1_size);
+	pagedir_order = get_bitmask_order(nr_pgdir_pages);
+
+	pagedir_nosave = (suspend_pagedir_t *)__get_free_pages(GFP_ATOMIC, pagedir_order);
+	if (!pagedir_nosave)
+		return -ENOMEM;
+
+	PRINTK(SUSPEND_DEBUG, name_resume "Reading pagedir of %d pages, %lx", pageset1_size, next.val);
+
+	/* We get pages in reverse order of saving! */
+	for (cur.pointer=(union diskpage *)pagedir_nosave + (i=nr_pgdir_pages-1);
+	     i>=0;
+	     i--,
+	     cur.pointer--) {
+		if (!next.val) {
+			abort_suspend("next.val is NULL in __read_suspend_image!\n");
+			return -1;
+		}
+		if (bdev_read_page(bdev, next.val, cur.ptr)) return -EIO;	
+		PREPARENEXT;
+	}
+	if (next.val) {
+		abort_suspend("next.val not NULL in __read_suspend_image!\n");
+		return -1;
+	}
+
+	if (relocate_pagedir())
+		return -ENOMEM;
+	if (check_pagedir())
+		return -ENOMEM;
+
+	PRINTK(SUSPEND_DEBUG, name_resume "reading image data (%d pages)\n", pageset1_size);
+	prepare_status(console_resume, "Reading suspend image...");
+	for(i=0; i < pageset1_size; i++) {
+		swp_entry_t swap_address1 = (pagedir_nosave+i)->swap_address1;
+		if (!(i%100))
+			PRINTK(SUSPEND_DEBUG, ".");
+		update_status(console_resume, (int) (i * 100 / pageset1_size));
+		next.val = SWP_OFFSET (swap_address1) * PAGE_SIZE;
+		/* You do not need to check for overlaps...
+		   ... check_pagedir already did this work */
+		if (bdev_read_page(bdev, next.val, (char *)((pagedir_nosave+i)->address3))) return -EIO;	
+	}
+	PRINTK(SUSPEND_DEBUG, "|\n");
+	update_status(console_resume, 100);
+	return 0;
+}
+
+static int read_suspend_image(char * specialfile, int noresume)
+{
+	union p_diskpage cur;
+	unsigned long scratch_page = 0;
+	int error, blksize = 0;
+
+	resume_device = name_to_kdev_t(specialfile);
+	scratch_page = get_free_page(GFP_ATOMIC);
+	if (scratch_page) {
+		cur.address = scratch_page;
+		PRINTK(SUSPEND_DEBUG, name_resume "Resuming from device %x\n", resume_device);
+
+		if (!blksize_size[MAJOR(resume_device)]) {
+			PRINTK(SUSPEND_DEBUG, name_resume "Blocksize not known?\n");
+		} else blksize = blksize_size[MAJOR(resume_device)][MINOR(resume_device)];
+		if (!blksize) {
+			PRINTK(SUSPEND_DEBUG, name_resume "Blocksize not set?\n");
+			blksize = PAGE_SIZE;
+		}
+		set_blocksize(resume_device, PAGE_SIZE);
+		error = __read_suspend_image(resume_device, cur, noresume);
+		free_page(scratch_page);
+	} else error = -ENOMEM;
+
+	switch (error) {
+		case 0:
+		case -EINVAL:	/* non fatal error */
+			set_blocksize(resume_device, blksize);
+			software_suspend_enabled = 1;
+			MDELAY(1000);
+			return(error);
+			break;
+		case -EIO:
+			printk(KERN_CRIT name_resume "I/O error\n");
+			break;
+		case -ENOENT:
+			printk(KERN_CRIT name_resume "%s: No such file or directory\n", specialfile);
+			break;
+		case -EPERM:
+			printk(KERN_CRIT name_resume "Sanity check error\n");
+			break;
+		default:
+			printk(KERN_CRIT name_resume "Error %d resuming\n", error);
+			break;
+	}
+	abort_suspend("Error %d in read_suspend_image",error);
+	return(error);
+}
+/*
+ * Called from init kernel_thread.
+ * We check if we have an image and if so we try to resume
+ */
+
+void software_resume(void)
+{
+#ifdef CONFIG_SMP
+	printk(name_swsusp "malfunctioning SMP support. Disabled :(\n");
+#else
+	/* We enable the possibility of machine suspend */
+	software_suspend_enabled = 1;
+#endif
+	if (!resume_status)
+		return;
+
+	if (resume_status == NORESUME) {
+		PRINTK(SUSPEND_DEBUG, name_swsusp "resuming disabled\n");
+		software_suspend_enabled = 0;
+		if (resume_file[0])
+			read_suspend_image(resume_file,1); /* non fatal error ignored */
+		kernel_thread(swsusp_mainloop, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD);
+		return;
+	}
+	MDELAY(1000);
+
+	orig_loglevel = console_loglevel;
+	console_loglevel = new_loglevel;
+
+	if (!resume_file[0] && resume_status == RESUME_SPECIFIED) {
+		printk(name_swsusp "suspension device unspecified\n");
+		software_suspend_enabled = 0;
+		return;
+	}
+
+	PRINTK(SUSPEND_DEBUG, name_swsusp "resuming from %s\n", resume_file);
+	if (read_suspend_image(resume_file, 0)) { /* non fatal error (normal swap space) */
+		kernel_thread(swsusp_mainloop, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGHAND | SIGCHLD);
+		console_loglevel = orig_loglevel;
+		return;
+	}		
+
+	prepare_status(console_resume, "Copying pages back (no status - sensitive!)...");
+
+	do_suspend_lowlevel(1);
+	BUG();
+}
+
+static int __init resume_setup(char *str)
+{
+	if (resume_status)
+		return 1;
+	if( (str == NULL) || (strncmp(str, "/dev/h", 6)) ) {
+		printk(name_swsusp "software suspend is currently only compatible with IDE /dev/h?? swap partitions: disabled\n");
+		resume_status = 0;
+		software_suspend_enabled = 0;
+		return 1;
+	}
+
+	strncpy( resume_file, str, 255 );
+	resume_status = RESUME_SPECIFIED;
+
+	return 0;
+}
+
+static int __init software_noresume(char *str)
+{
+	resume_status = NORESUME;
+	if (!resume_status) {
+		printk(name_swsusp "noresume option lacks a resume= option\n");
+		return 1;
+	}
+	return 0;
+}
+
+__setup("resume=", resume_setup);
+__setup("noresume", software_noresume);
+
+EXPORT_SYMBOL(software_suspend_pending);
+EXPORT_SYMBOL(swsusp_state);
+EXPORT_SYMBOL(software_suspend_enabled);
+EXPORT_SYMBOL(refrigerator);
Index: linuxx/kernel/sys.c
diff -u linuxx/kernel/sys.c:1.1.1.1 linuxx/kernel/sys.c:1.1.1.1.12.1
--- linuxx/kernel/sys.c:1.1.1.1	Thu Nov 28 14:07:59 2002
+++ linuxx/kernel/sys.c	Thu Nov 28 20:22:58 2002
@@ -4,6 +4,7 @@
  *  Copyright (C) 1991, 1992  Linus Torvalds
  */
 
+#include <linux/config.h>
 #include <linux/module.h>
 #include <linux/mm.h>
 #include <linux/utsname.h>
@@ -322,6 +323,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_pending();
+		do_exit(0);
+		break;
+#endif
 
 	default:
 		unlock_kernel();
Index: linuxx/kernel/sysctl.c
diff -u linuxx/kernel/sysctl.c:1.1.1.1 linuxx/kernel/sysctl.c:1.1.1.1.12.1
--- linuxx/kernel/sysctl.c:1.1.1.1	Thu Nov 28 14:07:59 2002
+++ linuxx/kernel/sysctl.c	Thu Nov 28 20:22:59 2002
@@ -42,6 +42,9 @@
 /* External variables not in a header file. */
 extern int panic_timeout;
 extern int C_A_D;
+#ifdef CONFIG_SOFTWARE_SUSPEND
+extern int swsusp_state[3];
+#endif
 extern int bdf_prm[], bdflush_min[], bdflush_max[];
 extern int sysctl_overcommit_memory;
 extern int max_threads;
@@ -195,6 +198,10 @@
 #endif
 	{KERN_CTLALTDEL, "ctrl-alt-del", &C_A_D, sizeof(int),
 	 0644, NULL, &proc_dointvec},
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	{KERN_SWSUSP, "swsusp", &swsusp_state, 3*sizeof(int),
+	 0644, NULL, &proc_dointvec},
+#endif
 	{KERN_PRINTK, "printk", &console_loglevel, 4*sizeof(int),
 	 0644, NULL, &proc_dointvec},
 #ifdef CONFIG_KMOD
Index: linuxx/mm/page_alloc.c
diff -u linuxx/mm/page_alloc.c:1.1.1.1.6.1 linuxx/mm/page_alloc.c:1.1.1.1.10.1.4.1
--- linuxx/mm/page_alloc.c:1.1.1.1.6.1	Fri Nov 29 13:55:12 2002
+++ linuxx/mm/page_alloc.c	Tue Dec  3 10:38:49 2002
@@ -20,6 +20,7 @@
 #include <linux/pagemap.h>
 #include <linux/bootmem.h>
 #include <linux/slab.h>
+#include <linux/suspend.h>
 #include <linux/module.h>
 
 int nr_swap_pages;
@@ -98,8 +99,10 @@
 
 	if (page->buffers)
 		BUG();
-	if (page->mapping)
+	if (page->mapping) {
+	  	printk("pagebug: %lx\n",page);
 		BUG();
+	}
 	if (!VALID_PAGE(page))
 		BUG();
 	if (PageLocked(page))
@@ -241,6 +244,73 @@
 	return NULL;
 }
 
+#ifdef CONFIG_SOFTWARE_SUSPEND
+#define FREE_PAGE_MAP_SIZE 4096  /* enough for 512Mb */
+
+static unsigned long free_page_map[FREE_PAGE_MAP_SIZE] __nosavedata;
+
+void generate_free_page_map(void) 
+{
+	int i, loop, numcounted = 0;
+	unsigned long page = 0;
+	pg_data_t *pgdat = pgdat_list;
+	unsigned type;
+	unsigned long flags;
+
+	for(i=0; i < FREE_PAGE_MAP_SIZE; i++)
+		free_page_map[i]=0;
+	
+	for (type=0;type < MAX_NR_ZONES; type++) {
+		zone_t *zone = pgdat->node_zones + type;
+		int order = MAX_ORDER - 1;
+		free_area_t *area;
+		struct list_head *head, *curr;
+		spin_lock_irqsave(&zone->lock, flags);
+		do {
+			int first_entry = 1;
+			area = zone->free_area + order;
+			head = &area->free_list;
+			curr = head;
+
+			for(;;) {
+				if(!curr) {
+//					printk("FIXME: this should not happen but it does!!!");
+					break;
+				}
+				if (first_entry) 
+					first_entry--;
+				else {
+					page = list_entry(curr, struct page, list) - mem_map;
+					for(loop=0; loop < (1 << order); loop++) {
+						if(!(free_page_map[page/32]&(1<<(page%32)))) {
+							free_page_map[page/32]|=(1<<(page%32));
+							numcounted++;
+						}
+						page++;					
+					}
+				}
+
+				curr = curr->next;
+				if (curr == head)
+					break; 				
+			}
+		} while(order--);
+		spin_unlock_irqrestore(&zone->lock, flags);
+	}
+}
+ 
+ 
+int is_head_of_free_region(unsigned long page)
+{
+	unsigned long posn = page;
+
+	while ((posn < max_mapnr) && (free_page_map[posn/32]&(1<<(posn%32)))) 
+		posn++;
+	return (posn - page);
+}
+
+#endif /* CONFIG_SOFTWARE_SUSPEND */
+
 #ifndef CONFIG_DISCONTIGMEM
 struct page *_alloc_pages(unsigned int gfp_mask, unsigned int order)
 {
@@ -330,7 +400,9 @@
 	zone_t **zone, * classzone;
 	struct page * page;
 	int freed;
-
+#if CONFIG_SOFTWARE_SUSPEND
+	static unsigned int loopcount;
+#endif	
 	zone = zonelist->zones;
 	classzone = *zone;
 	if (classzone == NULL)
@@ -374,8 +446,25 @@
 	}
 
 	/* here we're in the low on memory slow path */
-
+#if CONFIG_SOFTWARE_SUSPEND
+	loopcount=0;
+#endif
 rebalance:
+#ifdef CONFIG_SOFTWARE_SUSPEND
+	if(gfp_mask & __GFP_FAST) {
+/* when using memeat, we ask for all pages that are really free.
+   800 calls to reschedule should be sufficient to recall all of them since
+   when a page can be found, it is after only one reschedule.
+   Actually I consider this as a bug of alloc_pages, since allocating a
+   page should not hang in an endless loop when it is clear that no
+   memory is available (cbd) */	  
+		loopcount++;
+		//if(!(loopcount%10))
+		//	printk("_");
+		if(loopcount > 800)
+			return NULL;
+	}
+#endif
 	if (current->flags & (PF_MEMALLOC | PF_MEMDIE)) {
 		zone = zonelist->zones;
 		for (;;) {
Index: linuxx/mm/page_io.c
diff -u linuxx/mm/page_io.c:1.1.1.1.6.1 linuxx/mm/page_io.c:1.1.1.1.10.1.4.1
--- linuxx/mm/page_io.c:1.1.1.1.6.1	Fri Nov 29 13:55:13 2002
+++ linuxx/mm/page_io.c	Tue Dec  3 10:38:49 2002
@@ -82,12 +82,19 @@
  *  - it's marked as being swap-cache
  *  - it's associated with the swap inode
  */
+#if 0
+extern long suspend_device;
+#endif
 void rw_swap_page(int rw, struct page *page)
 {
 	swp_entry_t entry;
 
 	entry.val = page->index;
 
+#if 0
+	if (suspend_device)
+		panic("I refuse to corrupt memory/swap.");
+#endif
 	if (!PageLocked(page))
 		PAGE_BUG(page);
 	if (!PageSwapCache(page))
@@ -101,7 +108,7 @@
  * Therefore we can't use it.  Later when we can remove the need for the
  * lock map and we can reduce the number of functions exported.
  */
-void rw_swap_page_nolock(int rw, swp_entry_t entry, char *buf)
+void __rw_swap_page_nolock(int rw, swp_entry_t entry, char *buf, int free)
 {
 	struct page *page = virt_to_page(buf);
 	
@@ -113,8 +120,10 @@
 	page->mapping = &swapper_space;
 	if (rw_swap_page_base(rw, entry, page))
 		lock_page(page);
-	if (!block_flushpage(page, 0))
-		PAGE_BUG(page);
+	if(free) {
+		if (!block_flushpage(page, 0))
+			PAGE_BUG(page);
+	}
 	page->mapping = NULL;
 	UnlockPage(page);
 }
Index: linuxx/mm/vmscan.c
diff -u linuxx/mm/vmscan.c:1.1.1.1.6.1 linuxx/mm/vmscan.c:1.1.1.1.10.1.4.1
--- linuxx/mm/vmscan.c:1.1.1.1.6.1	Fri Nov 29 13:55:13 2002
+++ linuxx/mm/vmscan.c	Tue Dec  3 10:38:50 2002
@@ -21,6 +21,7 @@
 #include <linux/smp_lock.h>
 #include <linux/pagemap.h>
 #include <linux/init.h>
+#include <linux/suspend.h>
 #include <linux/highmem.h>
 #include <linux/file.h>
 
@@ -744,12 +745,16 @@
 	 * Kswapd main loop.
 	 */
 	for (;;) {
+		if (current->flags & PF_FREEZE)
+			refrigerator(PF_IOTHREAD);
 		__set_current_state(TASK_INTERRUPTIBLE);
 		add_wait_queue(&kswapd_wait, &wait);
 
 		mb();
-		if (kswapd_can_sleep())
+		if (kswapd_can_sleep()) {
 			schedule();
+		}
+		
 
 		__set_current_state(TASK_RUNNING);
 		remove_wait_queue(&kswapd_wait, &wait);
Index: linuxx/net/sunrpc/sched.c
diff -u linuxx/net/sunrpc/sched.c:1.1.1.1.6.1 linuxx/net/sunrpc/sched.c:1.1.1.1.10.1.4.1
--- linuxx/net/sunrpc/sched.c:1.1.1.1.6.1	Fri Nov 29 13:55:19 2002
+++ linuxx/net/sunrpc/sched.c	Tue Dec  3 10:38:56 2002
@@ -19,6 +19,7 @@
 #include <linux/smp.h>
 #include <linux/smp_lock.h>
 #include <linux/spinlock.h>
+#include <linux/suspend.h>
 
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/xprt.h>
@@ -1013,6 +1014,11 @@
 		}
 
 		if (!rpciod_task_pending()) {
+			if (current->flags & PF_FREEZE) { 
+				dprintk("Now suspending rpciod\n");
+				refrigerator(PF_IOTHREAD);
+				dprintk("Now resuming rpciod\n");
+			}
 			dprintk("RPC: rpciod back to sleep\n");
 			wait_event_interruptible(rpciod_idle, rpciod_task_pending());
 			dprintk("RPC: switch to rpciod\n");