nfs swap patch
authorMike Baker <mbm@openwrt.org>
Mon, 31 May 2004 06:43:24 +0000 (06:43 +0000)
committerMike Baker <mbm@openwrt.org>
Mon, 31 May 2004 06:43:24 +0000 (06:43 +0000)
SVN-Revision: 45

obsolete-buildroot/sources/openwrt-wrt54g-nfsswap.patch [new file with mode: 0644]

diff --git a/obsolete-buildroot/sources/openwrt-wrt54g-nfsswap.patch b/obsolete-buildroot/sources/openwrt-wrt54g-nfsswap.patch
new file mode 100644 (file)
index 0000000..bf848c1
--- /dev/null
@@ -0,0 +1,2362 @@
+diff -Nurb src/linux/linux.orig/Documentation/netswap.txt src/linux/linux/Documentation/netswap.txt
+--- src/linux/linux.orig/Documentation/netswap.txt     1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/Documentation/netswap.txt  2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,51 @@
++                     Swapping over network
++
++Support for this is enabled via the CONFIG_NETSWAP option, which is
++automatically enabled when enabling swap files located on NFS volumes
++(CONFIG_SWAP_VIA_NFS).
++
++When swapping to files located on a network file system like NFS or
++CODA or others or to nbd (network block device, see `nbd.txt')
++partitions there is the problem that this requires additional memory,
++besides the page which is currently swapped in or out, probably at
++least two more pages for each page in question.
++
++This means that not only there needs to be free space left in the swap
++file or the swap partition, but in addition there must be enough free
++memory left in the system to perform the swap out of pages.
++
++This is particularly painful as receiving data over the network itself
++consumes memory, and this memory is allocated from an interrupt
++context (i.e. in the interrupt handler of the network card). That
++means that on a congested network there are chances that the machine
++runs out of memory, simply because the network device's interrupt
++routines allocate memory faster that it is freed by swapping via
++network.
++
++To cope with this problem, there is a new socket option `SO_SWAPPING'
++which has to be set on the `SOL_SOCKET' level with setsockopt() (see
++setsockopt(2)). When this option is set on any network socket, then
++the system will start to drop network packets it receives on any other
++socket when the number of free pages falls below a certain threshold.
++
++This threshold initially is 4 pages less than `freepages.min' (see
++`Documentation/sysctl/vm.txt') but can be tuned using the sysctl
++interface by writing to the file `/proc/sys/net/swapping/threshold'
++
++There are two other files:
++
++`/proc/sys/net/swapping/dropped':
++    how many network packets have been dropped so far. This file is
++    writable, writing to it simply sets the counter to the given value
++    (useful for resetting the counter).
++
++`/proc/sys/net/swapping/sock_count':
++    How many network sockets have the `SO_SWAPPING' option set (read
++    only, of course).
++
++When using swap-files on NFS volumes, then the `SO_SWAPPING' option is
++set or cleared by swapon/swapoff system calls, so the user need not
++care about it.
++
++Swapping over the network is insecure unless the data would be
++encrypted, which is not the case with NFS. It is also very slow.
+diff -Nurb src/linux/linux.orig/Documentation/nfsswap.txt src/linux/linux/Documentation/nfsswap.txt
+--- src/linux/linux.orig/Documentation/nfsswap.txt     1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/Documentation/nfsswap.txt  2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,41 @@
++                   Swapping to files on NFS volumes
++
++To  do  this you have to  say  `Y' or  `M'  to the CONFIG_SWAP_VIA_NFS
++configuration  option. When compling support  for this as a module you
++should  read  `Documentation/modules.txt'.  For  auto-loading  of  the
++module during the `swapon' system call you have to place a line like
++
++alias swapfile-mod nfsswap
++
++in   `/etc/modules.conf'  (or `/etc/conf.modules',  depending  on your
++setup). NFS volumes  holding swapfile should  be mounted  with `rsize'
++and `wsize' set to something  less than the size  of a page, otherwise
++deadlocks  caused by memory fragmentation can  happen,  i.e. mount the
++volume which is to hold the swapfiles with
++
++mount -t nfs -o rsize=2048,wsize=2048 NFS_SERVER_IP:/server_volume /mount_point
++
++or set the option in `/etc/fstab'. Read `Documentation/nfsroot.txt' to
++learn how to set mount options for the root file  system, if your swap
++files are to be located on the root file system.
++
++Setting the  `rsize' and `wsize' to  anything less than PAGE_SIZE is a
++performance hit, so  you probably want to  have  at least two  volumes
++mounted, one for the swapfiles, one for the rest.
++
++You may want to read `Documentation/netswap.txt' as well.
++
++Swapfiles on NFS volumes can be treated like any other swapfile,
++i.e.
++
++dd if=/dev/zero of=/swapfiles/SWAPFILE bs=1k count=20480
++mkswap /swapfiles/SWAPFILE
++swapon /swapfiles/SWAPFILE
++
++will  create a 20M swapfile and  tell the system  to use it. Actually,
++one could use lseek(2) to create  an empty swapfile. This is different
++from swapfiles located on local harddisk.
++
++Swapping  over  the network is   insecure   unless the data  would  be
++encrypted, which is not the case with NFS. It is also very slow.
++
+diff -Nurb src/linux/linux.orig/drivers/block/blkpg.c src/linux/linux/drivers/block/blkpg.c
+--- src/linux/linux.orig/drivers/block/blkpg.c 2003-07-04 04:11:31.000000000 -0400
++++ src/linux/linux/drivers/block/blkpg.c      2004-05-31 02:18:03.000000000 -0400
+@@ -34,7 +34,7 @@
+ #include <linux/blk.h>                        /* for set_device_ro() */
+ #include <linux/blkpg.h>
+ #include <linux/genhd.h>
+-#include <linux/swap.h>                       /* for is_swap_partition() */
++#include <linux/swap.h>                       /* for swap_run_test() */
+ #include <linux/module.h>               /* for EXPORT_SYMBOL */
+ #include <asm/uaccess.h>
+@@ -114,6 +114,29 @@
+       return 0;
+ }
++/* swap_run_test() applies this hook to all swapfiles until it returns
++ * "1".  If it never returns "1", the result of swap_run_test() is "0",
++ * otherwise "1".
++ */
++static int is_swap_partition_hook(unsigned int flags, struct file *swap_file,
++                                void *testdata)
++{
++      kdev_t swap_dev = S_ISBLK(swap_file->f_dentry->d_inode->i_mode)
++              ? swap_file->f_dentry->d_inode->i_rdev : 0;
++      kdev_t dev = *((kdev_t *)testdata);
++      
++      if (flags & SWP_USED && dev == swap_dev) {
++              return 1;
++      } else {
++              return 0;
++      }
++}
++
++static inline int is_swap_partition(kdev_t dev)
++{
++      return swap_run_test(is_swap_partition_hook, &dev);
++}
++
+ /*
+  * Delete a partition given by partition number
+  *
+diff -Nurb src/linux/linux.orig/fs/Config.in src/linux/linux/fs/Config.in
+--- src/linux/linux.orig/fs/Config.in  2004-05-31 02:02:43.000000000 -0400
++++ src/linux/linux/fs/Config.in       2004-05-31 02:18:03.000000000 -0400
+@@ -4,6 +4,12 @@
+ mainmenu_option next_comment
+ comment 'File systems'
++if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
++   tristate 'Swapping to block devices' CONFIG_BLKDEV_SWAP
++else
++   define_bool CONFIG_BLKDEV_SWAP y
++fi
++
+ bool 'Quota support' CONFIG_QUOTA
+ tristate 'Kernel automounter support' CONFIG_AUTOFS_FS
+ tristate 'Kernel automounter version 4 support (also supports v3)' CONFIG_AUTOFS4_FS
+@@ -110,6 +116,12 @@
+    dep_tristate 'NFS file system support' CONFIG_NFS_FS $CONFIG_INET
+    dep_mbool '  Provide NFSv3 client support' CONFIG_NFS_V3 $CONFIG_NFS_FS
+    dep_bool '  Root file system on NFS' CONFIG_ROOT_NFS $CONFIG_NFS_FS $CONFIG_IP_PNP
++   if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
++      dep_tristate '  Swapping via NFS (EXPERIMENTAL)' CONFIG_SWAP_VIA_NFS $CONFIG_NFS_FS
++      if [ "$CONFIG_SWAP_VIA_NFS" = "y" -o "$CONFIG_SWAP_VIA_NFS" = "m" ]; then
++         define_bool CONFIG_NETSWAP  y
++      fi
++   fi
+    dep_tristate 'NFS server support' CONFIG_NFSD $CONFIG_INET
+    dep_mbool '  Provide NFSv3 server support' CONFIG_NFSD_V3 $CONFIG_NFSD
+diff -Nurb src/linux/linux.orig/fs/Makefile src/linux/linux/fs/Makefile
+--- src/linux/linux.orig/fs/Makefile   2004-05-31 02:02:42.000000000 -0400
++++ src/linux/linux/fs/Makefile        2004-05-31 02:18:03.000000000 -0400
+@@ -8,7 +8,7 @@
+ O_TARGET := fs.o
+ export-objs :=        filesystems.o open.o dcache.o buffer.o
+-mod-subdirs :=        nls
++mod-subdirs :=        nls nfs
+ obj-y :=      open.o read_write.o devices.o file_table.o buffer.o \
+               super.o block_dev.o char_dev.o stat.o exec.o pipe.o namei.o \
+@@ -70,6 +70,7 @@
+ subdir-$(CONFIG_JFS_FS)               += jfs
+ subdir-$(CONFIG_SQUASHFS)     += squashfs
++obj-$(CONFIG_BLKDEV_SWAP)       += blkdev_swap.o
+ obj-$(CONFIG_BINFMT_AOUT)     += binfmt_aout.o
+ obj-$(CONFIG_BINFMT_EM86)     += binfmt_em86.o
+diff -Nurb src/linux/linux.orig/fs/blkdev_swap.c src/linux/linux/fs/blkdev_swap.c
+--- src/linux/linux.orig/fs/blkdev_swap.c      1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/fs/blkdev_swap.c   2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,309 @@
++/*
++ * Swapping to partitions or files located on partitions.
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/slab.h>
++#include <linux/locks.h>
++#include <linux/blkdev.h>
++#include <linux/pagemap.h>
++#include <linux/swap.h>
++#include <linux/fs.h>
++
++#ifdef DEBUG_BLKDEV_SWAP
++# define dprintk(fmt...) printk(##fmt)
++#else
++# define dprintk(fmt...) do { /* */ } while (0)
++#endif
++
++#define BLKDEV_SWAP_ID      "blkdev"
++#define BLKDEV_FILE_SWAP_ID "blkdev file"
++
++/*
++ * Helper function, copied here from buffer.c
++ */
++
++/*
++ * Start I/O on a page.
++ * This function expects the page to be locked and may return
++ * before I/O is complete. You then have to check page->locked
++ * and page->uptodate.
++ *
++ * brw_page() is SMP-safe, although it's being called with the
++ * kernel lock held - but the code is ready.
++ *
++ * FIXME: we need a swapper_inode->get_block function to remove
++ *        some of the bmap kludges and interface ugliness here.
++ */
++int brw_page(int rw, struct page *page, kdev_t dev, int b[], int size)
++{
++      struct buffer_head *head, *bh;
++
++      if (!PageLocked(page))
++              panic("brw_page: page not locked for I/O");
++
++      if (!page->buffers)
++              create_empty_buffers(page, dev, size);
++      head = bh = page->buffers;
++
++      /* Stage 1: lock all the buffers */
++      do {
++              lock_buffer(bh);
++              bh->b_blocknr = *(b++);
++              set_bit(BH_Mapped, &bh->b_state);
++              set_buffer_async_io(bh);
++              bh = bh->b_this_page;
++      } while (bh != head);
++
++      /* Stage 2: start the IO */
++      do {
++              struct buffer_head *next = bh->b_this_page;
++              submit_bh(rw, bh);
++              bh = next;
++      } while (bh != head);
++      return 0;
++}
++
++/*
++ * We implement to methods: swapping to partitions, and swapping to files
++ * located on partitions.
++ */
++
++struct blkdev_swap_data {
++      kdev_t dev;
++};
++
++struct test_data {
++      struct file * filp;
++      kdev_t dev;
++};
++
++static int is_blkdev_swapping(unsigned int flags,
++                            struct file * swapf,
++                            void *data)
++{
++      struct test_data *testdata = (struct test_data *) data;
++      struct file * filp = testdata->filp;
++      kdev_t dev = testdata->dev;
++
++      /* Only check filp's that don't match the one already opened
++       * for us by sys_swapon(). Otherwise, we will always flag a
++       * busy swap file.
++       */
++
++      if (swapf != filp) {
++              if (dev == swapf->f_dentry->d_inode->i_rdev)
++                      return 1;
++      }
++      return 0;
++}
++
++static int blkdev_swap_open(struct file * filp, void **dptr)
++{
++      int swapfilesize;
++      kdev_t dev;
++      struct blkdev_swap_data *data;
++      int error;
++      struct test_data testdata;
++
++      MOD_INC_USE_COUNT;
++
++      if (!S_ISBLK(filp->f_dentry->d_inode->i_mode)) {
++              dprintk(__FUNCTION__": can't handle this swap file: %s\n",
++                     swapf->d_name.name);
++              error = 0; /* not for us */
++              goto bad_swap;
++      }
++      
++      dev = filp->f_dentry->d_inode->i_rdev;
++      set_blocksize(dev, PAGE_SIZE);
++      error = -ENODEV;
++      if (!dev ||
++          (blk_size[MAJOR(dev)] && !blk_size[MAJOR(dev)][MINOR(dev)])) {
++              printk("blkdev_swap_open: blkdev weirdness for %s\n",
++                     filp->f_dentry->d_name.name);
++              goto bad_swap;
++      }
++              
++      /* Check to make sure that we aren't already swapping. */
++      error = -EBUSY;
++      testdata.filp = filp;
++      testdata.dev = dev;
++      if (swap_run_test(is_blkdev_swapping, &testdata)) {
++              printk("blkdev_swap_open: already swapping to %s\n",
++                     filp->f_dentry->d_name.name);
++              goto bad_swap;
++      }
++
++      swapfilesize = 0;
++      if (blk_size[MAJOR(dev)])
++              swapfilesize = blk_size[MAJOR(dev)][MINOR(dev)]
++                      >> (PAGE_SHIFT - 10);
++
++      if ((data = kmalloc(sizeof(*data), GFP_KERNEL)) == NULL) {
++              printk("blkdev_swap_open: can't allocate data for %s\n",
++                     filp->f_dentry->d_name.name);
++              error = -ENOMEM;
++              goto bad_swap;
++      }
++      data->dev = dev;
++      *dptr = data;
++
++      dprintk("blkdev_swap_open: returning %d\n", swapfilesize);
++      return swapfilesize;
++
++ bad_swap:
++      MOD_DEC_USE_COUNT;
++      return error; /* this swap thing is not for us */       
++}
++
++static int blkdev_swap_release(struct file * filp, void *data)
++{
++      dprintk("blkdev_swap_release: releasing swap device %s\n",
++              filp->f_dentry->d_name.name);
++      kfree(data);
++      MOD_DEC_USE_COUNT;
++      return 0;
++}
++
++static int blkdev_rw_page(int rw, struct page *page, unsigned long offset,
++                        void *ptr)
++{
++      struct blkdev_swap_data *data = (struct blkdev_swap_data *)ptr;
++      brw_page(rw, page, data->dev, (int *)&offset, PAGE_SIZE);
++      return 1;
++}
++
++static struct swap_ops blkdev_swap_ops = {
++      blkdev_swap_open,
++      blkdev_swap_release,
++      blkdev_rw_page
++};
++
++struct blkdevfile_swap_data {
++      struct inode *swapf;
++};
++
++static int is_blkdevfile_swapping(unsigned int flags,
++                                struct file * swapf,
++                                void * data)
++{
++      struct file * filp = (struct file *) data;
++
++      /* Only check filp's that don't match the one already opened
++       * for us by sys_swapon(). Otherwise, we will always flag a
++       * busy swap file.
++       */
++
++      if (swapf != filp) {
++              if (filp->f_dentry->d_inode == swapf->f_dentry->d_inode)
++                      return 1;
++      }
++      return 0;
++}
++
++static int blkdevfile_swap_open(struct file *swapf, void **dptr)
++{
++      int error = 0;
++      int swapfilesize;
++      struct blkdevfile_swap_data *data;
++
++      MOD_INC_USE_COUNT;
++
++      /* first check whether this is a regular file located on a local 
++       * hard disk
++       */
++      if (!S_ISREG(swapf->f_dentry->d_inode->i_mode)) {
++              dprintk("blkdevfile_swap_open: "
++                      "can't handle this swap file: %s\n",
++                      swapf->d_name.name);
++              error = 0; /* not for us */
++              goto bad_swap;
++      }
++      if (!swapf->f_dentry->d_inode->i_mapping->a_ops->bmap) {
++              dprintk("blkdevfile_swap_open: no bmap for file: %s\n",
++                      swapf->d_name.name);
++              error = 0; /* not for us */
++              goto bad_swap;
++      }
++
++      if (swap_run_test(is_blkdevfile_swapping, swapf)) {
++              dprintk("blkdevfile_swap_open: already swapping to %s\n",
++                      swapf->d_name.name);
++              error = -EBUSY;
++              goto bad_swap;
++      }
++      swapfilesize = swapf->f_dentry->d_inode->i_size >> PAGE_SHIFT;
++      if ((data = kmalloc(sizeof(*data), GFP_KERNEL)) == NULL) {
++              error = -ENOMEM;
++              goto bad_swap;
++      }
++      data->swapf = swapf->f_dentry->d_inode;
++      *dptr = data;
++      return swapfilesize;
++
++ bad_swap:
++      MOD_DEC_USE_COUNT;
++      return error;
++}
++
++static int blkdevfile_swap_release(struct file *swapf, void *data)
++{
++      kfree(data);
++      MOD_DEC_USE_COUNT;
++      return 0;
++}
++
++static int blkdevfile_rw_page(int rw, struct page *page, unsigned long offset,
++                            void *ptr)
++{
++      struct blkdevfile_swap_data *data = (struct blkdevfile_swap_data *)ptr;
++      struct inode * swapf = data->swapf;
++      int i, j;
++      unsigned int block = offset
++              << (PAGE_SHIFT - swapf->i_sb->s_blocksize_bits);
++      kdev_t dev = swapf->i_dev;
++      int block_size;
++      int zones[PAGE_SIZE/512];
++      int zones_used;
++
++      block_size = swapf->i_sb->s_blocksize;
++      for (i=0, j=0; j< PAGE_SIZE ; i++, j += block_size)
++              if (!(zones[i] = bmap(swapf,block++))) {
++                      printk("blkdevfile_rw_page: bad swap file\n");
++                      return 0;
++                      }
++      zones_used = i;
++      
++      /* block_size == PAGE_SIZE/zones_used */
++      brw_page(rw, page, dev, zones, block_size);
++      return 1;
++}
++
++static struct swap_ops blkdevfile_swap_ops = {
++      blkdevfile_swap_open,
++      blkdevfile_swap_release,
++      blkdevfile_rw_page
++ };
++
++int __init blkdev_swap_init(void)
++{
++      (void)register_swap_method(BLKDEV_SWAP_ID, &blkdev_swap_ops);
++      (void)register_swap_method(BLKDEV_FILE_SWAP_ID, &blkdevfile_swap_ops);
++      return 0;
++}
++
++void __exit blkdev_swap_exit(void)
++{
++      unregister_swap_method(BLKDEV_SWAP_ID);
++      unregister_swap_method(BLKDEV_FILE_SWAP_ID);
++}
++
++module_init(blkdev_swap_init)
++module_exit(blkdev_swap_exit)
++
++MODULE_LICENSE("GPL");
++MODULE_AUTHOR("Many. Stuffed into a module by cH (Claus-Justus Heine)");
++MODULE_DESCRIPTION("Swapping to partitions and files on local hard-disks");
+diff -Nurb src/linux/linux.orig/fs/buffer.c src/linux/linux/fs/buffer.c
+--- src/linux/linux.orig/fs/buffer.c   2003-07-04 04:12:05.000000000 -0400
++++ src/linux/linux/fs/buffer.c        2004-05-31 02:21:05.000000000 -0400
+@@ -743,7 +743,7 @@
+       bh->b_private = private;
+ }
+-static void end_buffer_io_async(struct buffer_head * bh, int uptodate)
++void end_buffer_io_async(struct buffer_head * bh, int uptodate)
+ {
+       static spinlock_t page_uptodate_lock = SPIN_LOCK_UNLOCKED;
+       unsigned long flags;
+@@ -2344,35 +2344,6 @@
+       return err;
+ }
+-int brw_page(int rw, struct page *page, kdev_t dev, int b[], int size)
+-{
+-      struct buffer_head *head, *bh;
+-
+-      if (!PageLocked(page))
+-              panic("brw_page: page not locked for I/O");
+-
+-      if (!page->buffers)
+-              create_empty_buffers(page, dev, size);
+-      head = bh = page->buffers;
+-
+-      /* Stage 1: lock all the buffers */
+-      do {
+-              lock_buffer(bh);
+-              bh->b_blocknr = *(b++);
+-              set_bit(BH_Mapped, &bh->b_state);
+-              set_buffer_async_io(bh);
+-              bh = bh->b_this_page;
+-      } while (bh != head);
+-
+-      /* Stage 2: start the IO */
+-      do {
+-              struct buffer_head *next = bh->b_this_page;
+-              submit_bh(rw, bh);
+-              bh = next;
+-      } while (bh != head);
+-      return 0;
+-}
+-
+ int block_symlink(struct inode *inode, const char *symname, int len)
+ {
+       struct address_space *mapping = inode->i_mapping;
+diff -Nurb src/linux/linux.orig/fs/nfs/Makefile src/linux/linux/fs/nfs/Makefile
+--- src/linux/linux.orig/fs/nfs/Makefile       2003-07-04 04:12:07.000000000 -0400
++++ src/linux/linux/fs/nfs/Makefile    2004-05-31 02:18:03.000000000 -0400
+@@ -15,6 +15,14 @@
+ obj-$(CONFIG_ROOT_NFS) += nfsroot.o mount_clnt.o      
+ obj-$(CONFIG_NFS_V3) += nfs3proc.o nfs3xdr.o
+-obj-m   := $(O_TARGET)
++obj-$(CONFIG_SWAP_VIA_NFS) += nfsswap.o
++ifeq ($(CONFIG_SWAP_VIA_NFS),m)
++export-objs := nfs_syms.o
++obj-y += nfs_syms.o
++endif
++
++ifeq ($(CONFIG_NFS_FS),m)
++obj-m   += $(O_TARGET)
++endif
+ include $(TOPDIR)/Rules.make
+diff -Nurb src/linux/linux.orig/fs/nfs/file.c src/linux/linux/fs/nfs/file.c
+--- src/linux/linux.orig/fs/nfs/file.c 2003-07-04 04:12:07.000000000 -0400
++++ src/linux/linux/fs/nfs/file.c      2004-05-31 02:18:03.000000000 -0400
+@@ -58,11 +58,6 @@
+       setattr:        nfs_notify_change,
+ };
+-/* Hack for future NFS swap support */
+-#ifndef IS_SWAPFILE
+-# define IS_SWAPFILE(inode)   (0)
+-#endif
+-
+ /*
+  * Flush all dirty pages, and check for write errors.
+  *
+@@ -217,8 +212,6 @@
+               inode->i_ino, (unsigned long) count, (unsigned long) *ppos);
+       result = -EBUSY;
+-      if (IS_SWAPFILE(inode))
+-              goto out_swapfile;
+       result = nfs_revalidate_inode(NFS_SERVER(inode), inode);
+       if (result)
+               goto out;
+@@ -230,10 +223,6 @@
+       result = generic_file_write(file, buf, count, ppos);
+ out:
+       return result;
+-
+-out_swapfile:
+-      printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
+-      goto out;
+ }
+ /*
+diff -Nurb src/linux/linux.orig/fs/nfs/nfs_syms.c src/linux/linux/fs/nfs/nfs_syms.c
+--- src/linux/linux.orig/fs/nfs/nfs_syms.c     1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/fs/nfs/nfs_syms.c  2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,10 @@
++#include <linux/config.h>
++#define __NO_VERSION__
++#include <linux/module.h>
++#include <linux/types.h>
++#include <linux/sunrpc/clnt.h>
++#include <linux/nfs_fs.h>
++
++EXPORT_SYMBOL(__nfs_refresh_inode);
++EXPORT_SYMBOL(nfs_write_attributes);
++
+diff -Nurb src/linux/linux.orig/fs/nfs/nfsswap.c src/linux/linux/fs/nfs/nfsswap.c
+--- src/linux/linux.orig/fs/nfs/nfsswap.c      1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/fs/nfs/nfsswap.c   2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,350 @@
++/*
++ * Swapping to files located on NFS mounted volumes
++ * Copyright (c) 2000 Claus-Justus Heine
++ *
++ */
++
++#include <linux/config.h>
++#include <linux/module.h>
++#include <linux/init.h>
++#include <linux/types.h>
++#include <linux/slab.h>
++#include <linux/swap.h>
++#include <linux/pagemap.h>
++#include <linux/file.h>
++#include <linux/fs.h>
++#include <linux/socket.h>
++#include <linux/smp_lock.h>
++#include <net/netswapping.h>
++#include <net/sock.h>
++
++#include <linux/sunrpc/clnt.h>
++#include <linux/nfs_fs.h>
++#include <linux/nfs_fs_sb.h>
++#include <asm/uaccess.h>
++
++#define NFSDBG_FACILITY               NFSDBG_SWAP
++
++#define NFS_SWAP_ID "nfs file"
++
++/* we cache some values here. In principle, we only need the file.
++ */
++struct nfs_swap_data {
++      struct file       *file;
++      struct inode      *inode;
++      struct nfs_server *server;
++      struct socket     *socket;
++};
++
++/* Nearly a clone of nfs_readpage_sync() in read.c, but "struct page" does not
++ * contain information about the file offset when swapping. So.
++ */
++static int nfs_read_swap_page(struct page *page,
++                            struct nfs_server *server,
++                            struct inode *inode,
++                            struct file  *file)
++{
++      unsigned int     rsize   = server->rsize;
++      unsigned int     count   = PAGE_SIZE;
++      unsigned int     offset  = 0; /* always at start of page */
++      int              result, eof;
++      struct rpc_cred  *cred;
++      struct nfs_fattr fattr;
++
++      cred = nfs_file_cred(file);
++
++      do {
++              if (count < rsize)
++                      rsize = count;
++
++              lock_kernel();
++              result = NFS_PROTO(inode)->read(inode, cred,
++                                              &fattr,
++                                              NFS_RPC_SWAPFLAGS,
++                                              offset, rsize, page, &eof);
++              nfs_refresh_inode(inode, &fattr);
++              unlock_kernel();
++
++              /*
++               * Even if we had a partial success we can't mark the page
++               * cache valid.
++               */
++              if (result < 0) {
++                      if (result == -EISDIR)
++                              result = -EINVAL;
++                      goto io_error;
++              }
++              count  -= result;
++              offset += result;
++              if (result < rsize)     /* NFSv2ism */
++                      break;
++      } while (count);
++
++      if (count) {
++              char *kaddr = kmap(page);
++              memset(kaddr + offset, 0, count);
++              kunmap(page);
++      }
++      flush_dcache_page(page);
++      result = 0;
++
++io_error:
++      return result;
++}
++
++/* Like nfs_writepage_sync(), but when swapping page->index does not encode
++ * the offset in the swap file alone.
++ *
++ */
++static int nfs_write_swap_page(struct page *page,
++                             struct nfs_server *server,
++                             struct inode *inode,
++                             struct file *file)
++{
++      struct rpc_cred  *cred;
++      unsigned int     wsize   = server->wsize;
++      unsigned int     count   = PAGE_SIZE;
++      unsigned int     offset  = 0;
++      int              result;
++      struct nfs_writeverf verf;
++      struct nfs_fattr fattr;
++
++      cred = nfs_file_cred(file);
++
++      do {
++              if (count < wsize)
++                      wsize = count;
++              
++              lock_kernel();
++              result = NFS_PROTO(inode)->write(inode, cred, &fattr,
++                                               NFS_RW_SWAP|NFS_RW_SYNC, 
++                                               offset, wsize, page, &verf);
++              nfs_write_attributes(inode, &fattr);
++              unlock_kernel();
++
++              if (result < 0) {
++                      goto io_error;
++              }
++              if (result != wsize)
++                      printk("NFS: short write, wsize=%u, result=%d\n",
++                      wsize, result);
++              offset  += wsize;
++              count   -= wsize;
++              /*
++               * If we've extended the file, update the inode
++               * now so we don't invalidate the cache.
++               */
++              if (offset > inode->i_size)
++                      inode->i_size = offset;
++      } while (count);
++
++      result = 0;
++
++io_error:
++
++      return result;
++}
++
++/* Unluckily (for us) form 2.4.19 -> 2.4.20 the nfs-proc's where
++ * changed and expect now a proper file-mapping page, where index
++ * encodes the offset alone.
++ * 
++ * What we do: we save the original value of page->index, initialize
++ * page->index to what the NFS/sun-rpc subsystem expects and restore
++ * the index later.
++ */
++static int nfs_rw_swap_page(int rw, struct page *page,
++                          unsigned long offset, void *dptr)
++{
++      int error;
++      struct nfs_swap_data *data = dptr;
++      unsigned long alloc_flag = current->flags & PF_MEMALLOC;
++      unsigned long page_index;
++
++      if (!PageLocked(page))
++              panic("nfs_rw_swap_page: page not locked for I/O");
++
++      /* prevent memory deadlocks */
++      if (!(current->flags & PF_MEMALLOC)) {
++              dprintk("nfs_rw_swap_page: Setting PF_MEMALLOC\n");
++      }
++      current->flags |= PF_MEMALLOC;
++
++      /* now tweak the page->index field ... */
++      page_index  = page->index;
++      page->index = ((loff_t)offset*(loff_t)PAGE_SIZE) >> PAGE_CACHE_SHIFT;
++
++      if (rw == WRITE) {
++              error = nfs_write_swap_page(page,
++                                          data->server,
++                                          data->inode,
++                                          data->file);
++      } else {
++              error = nfs_read_swap_page(page,
++                                         data->server,
++                                         data->inode,
++                                         data->file);
++      }
++      
++      if (!alloc_flag) {
++              current->flags &= ~PF_MEMALLOC;
++      }
++
++      /* now restore the page->index field ... */
++      page->index = page_index;
++
++      if (error) {
++              /* Must mark the page invalid after I/O error */
++              SetPageError(page);
++              ClearPageUptodate(page);
++      } else {
++              ClearPageError(page);
++              SetPageUptodate(page);
++      }
++
++      if (!error) { /* in case of an error rw_swap_page() likes to unlock
++                     * itself.
++                     */
++              UnlockPage(page);
++      }
++
++      return error < 0 ? 0 : 1;
++}
++
++static int is_nfsfile_swapping(unsigned int flags,
++                             struct file * swapf,
++                             void * data)
++{
++      struct file * filp = (struct file *) data;
++
++      /* Only check filp's that don't match the one already opened
++       * for us by sys_swapon(). Otherwise, we will always flag a
++       * busy swap file.
++       */
++
++      if (swapf != filp) {
++              if (filp->f_dentry->d_inode == swapf->f_dentry->d_inode)
++                      return 1;
++      }
++      return 0;
++}
++
++static int nfs_swap_open(struct file *swapf, void **dptr)
++{
++      int error = 0;
++      int swapfilesize;
++      struct nfs_swap_data *data;
++      int on = 1;
++      mm_segment_t fs;
++      struct inode *inode = swapf->f_dentry->d_inode;
++
++      MOD_INC_USE_COUNT;
++
++      if (!S_ISREG(inode->i_mode)) {
++              dprintk("nfs_swap_open: can't handle this swap file: %s\n",
++                      swapf->f_dentry->d_name.name);
++              error = 0; /* not for us */
++              goto bad_swap;
++      }
++      /* determine whether this file really is located on an NFS mounted
++       * volume
++       */
++      if (!inode->i_sb || inode->i_sb->s_magic != NFS_SUPER_MAGIC) {
++              dprintk("nfs_swap_open: %s is not an NFS file.\n",
++                      swapf->f_dentry->d_name.name);
++              error = 0; /* not for us */
++              goto bad_swap;
++      }
++
++      if (swap_run_test(is_nfsfile_swapping, swapf)) {
++              dprintk("nfs_swap_open: already swapping to %s\n",
++                      swapf->f_dentry->d_name.name);
++              error = -EBUSY;
++              goto bad_swap;
++      }
++      swapfilesize = inode->i_size >> PAGE_SHIFT;
++      if ((data = kmalloc(sizeof(*data), GFP_KERNEL)) == NULL) {
++              error = -ENOMEM;
++              goto bad_swap;
++      }
++      data->file   = swapf;
++      data->inode  = inode;
++      data->server = NFS_SERVER(inode);
++      data->socket = data->server->client->cl_xprt->sock;
++      
++      /* set socket option SO_SWAPPING */
++      fs = get_fs();
++      set_fs(KERNEL_DS);
++      error = sock_setsockopt(data->socket, SOL_SOCKET, SO_SWAPPING,
++                              (char *)&on, sizeof(on));
++      set_fs(fs);
++      if (error) {
++              dprintk("nfs_swap_open: error setting SO_SWAPPING\n");
++              goto bad_swap_2;
++      }
++
++      *dptr = data;
++      return swapfilesize;
++
++ bad_swap_2:
++      kfree(data);
++ bad_swap:
++      MOD_DEC_USE_COUNT;
++      return error;
++}
++
++static int nfs_swap_release(struct file *swapf, void *dptr)
++{
++      struct nfs_swap_data *data = (struct nfs_swap_data *)dptr;
++      int off = 0;
++      mm_segment_t fs;
++      int error;
++
++#if 1
++      if (swapf != data->file ||
++          swapf->f_dentry->d_inode != data->inode ||
++          !swapf->f_dentry->d_inode->i_sb ||
++          swapf->f_dentry->d_inode->i_sb->s_magic != NFS_SUPER_MAGIC ||
++          NFS_SERVER(swapf->f_dentry->d_inode) != data->server ||
++          data->socket != data->server->client->cl_xprt->sock) {
++              panic("nfs_swap_release: nfs swap data messed up");
++      }
++#endif
++
++      /* remove socket option SO_SWAPPING */
++      fs = get_fs();
++      set_fs(KERNEL_DS);
++      error = sock_setsockopt(data->socket, SOL_SOCKET, SO_SWAPPING,
++                              (char *)&off, sizeof(off));
++      set_fs(fs);
++      if (error) {
++              dprintk("nfs_swap_open: error clearing SO_SWAPPING\n");
++      }
++      kfree(data);
++      MOD_DEC_USE_COUNT;
++      return error;
++}
++
++static struct swap_ops nfs_swap_ops = {
++      open: nfs_swap_open,
++      release: nfs_swap_release,
++      rw_page: nfs_rw_swap_page
++};
++
++int __init nfs_swap_init(void)
++{
++      (void)register_swap_method(NFS_SWAP_ID, &nfs_swap_ops);
++      return 0;
++}
++
++void __exit nfs_swap_exit(void)
++{
++      unregister_swap_method(NFS_SWAP_ID);
++}
++
++module_init(nfs_swap_init)
++module_exit(nfs_swap_exit)
++
++MODULE_LICENSE("GPL");
++MODULE_AUTHOR("(c) 1996-2002 cH (Claus-Justus Heine)");
++MODULE_DESCRIPTION("Swapping to files located on volumes mounted via NFS");
+diff -Nurb src/linux/linux.orig/fs/nfs/read.c src/linux/linux/fs/nfs/read.c
+--- src/linux/linux.orig/fs/nfs/read.c 2003-07-04 04:12:08.000000000 -0400
++++ src/linux/linux/fs/nfs/read.c      2004-05-31 02:18:03.000000000 -0400
+@@ -50,11 +50,6 @@
+  */
+ static void   nfs_readpage_result(struct rpc_task *task);
+-/* Hack for future NFS swap support */
+-#ifndef IS_SWAPFILE
+-# define IS_SWAPFILE(inode)   (0)
+-#endif
+-
+ static kmem_cache_t *nfs_rdata_cachep;
+ static __inline__ struct nfs_read_data *nfs_readdata_alloc(void)
+@@ -92,7 +87,6 @@
+       int             rsize = NFS_SERVER(inode)->rsize;
+       int             result;
+       int             count = PAGE_CACHE_SIZE;
+-      int             flags = IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0;
+       int             eof;
+       dprintk("NFS: nfs_readpage_sync(%p)\n", page);
+@@ -114,7 +108,7 @@
+                       offset, rsize, page);
+               lock_kernel();
+-              result = NFS_PROTO(inode)->read(inode, cred, &fattr, flags,
++              result = NFS_PROTO(inode)->read(inode, cred, &fattr, 0,
+                                               offset, rsize, page, &eof);
+               nfs_refresh_inode(inode, &fattr);
+               unlock_kernel();
+@@ -246,7 +240,7 @@
+       task = &data->task;
+       /* N.B. Do we need to test? Never called for swapfile inode */
+-      flags = RPC_TASK_ASYNC | (IS_SWAPFILE(inode)? NFS_RPC_SWAPFLAGS : 0);
++      flags = RPC_TASK_ASYNC;
+       nfs_read_rpcsetup(head, data);
+@@ -476,8 +470,6 @@
+       }
+       error = nfs_readpage_sync(file, inode, page);
+-      if (error < 0 && IS_SWAPFILE(inode))
+-              printk("Aiee.. nfs swap-in of page failed!\n");
+ out:
+       return error;
+diff -Nurb src/linux/linux.orig/fs/nfs/write.c src/linux/linux/fs/nfs/write.c
+--- src/linux/linux.orig/fs/nfs/write.c        2003-07-04 04:12:08.000000000 -0400
++++ src/linux/linux/fs/nfs/write.c     2004-05-31 02:20:47.000000000 -0400
+@@ -3,7 +3,6 @@
+ #include <linux/config.h>
+ #include <linux/types.h>
+ #include <linux/slab.h>
+-#include <linux/swap.h>
+ #include <linux/pagemap.h>
+ #include <linux/file.h>
+@@ -46,11 +45,6 @@
+ static void   nfs_commit_done(struct rpc_task *);
+ #endif
+-/* Hack for future NFS swap support */
+-#ifndef IS_SWAPFILE
+-# define IS_SWAPFILE(inode)   (0)
+-#endif
+-
+ static kmem_cache_t *nfs_wdata_cachep;
+ static __inline__ struct nfs_write_data *nfs_writedata_alloc(void)
+@@ -82,7 +76,7 @@
+  * For the moment, we just call nfs_refresh_inode().
+  */
+ static __inline__ int
+-nfs_write_attributes(struct inode *inode, struct nfs_fattr *fattr)
++__nfs_write_attributes(struct inode *inode, struct nfs_fattr *fattr)
+ {
+       if ((fattr->valid & NFS_ATTR_FATTR) && !(fattr->valid & NFS_ATTR_WCC)) {
+               fattr->pre_size  = NFS_CACHE_ISIZE(inode);
+@@ -93,6 +87,11 @@
+       return nfs_refresh_inode(inode, fattr);
+ }
++int nfs_write_attributes(struct inode *inode, struct nfs_fattr *fattr)
++{
++      return __nfs_write_attributes(inode, fattr);
++}
++
+ /*
+  * Write a page synchronously.
+  * Offset is the data offset within the page.
+@@ -104,8 +103,7 @@
+       struct rpc_cred *cred = NULL;
+       loff_t          base;
+       unsigned int    wsize = NFS_SERVER(inode)->wsize;
+-      int             result, refresh = 0, written = 0, flags;
+-      u8              *buffer;
++      int             result, refresh = 0, written = 0;
+       struct nfs_fattr fattr;
+       struct nfs_writeverf verf;
+@@ -121,15 +119,14 @@
+       base = page_offset(page) + offset;
+-      flags = ((IS_SWAPFILE(inode)) ? NFS_RW_SWAP : 0) | NFS_RW_SYNC;
+-
+       do {
+-              if (count < wsize && !IS_SWAPFILE(inode))
++              if (count < wsize)
+                       wsize = count;
+-              result = NFS_PROTO(inode)->write(inode, cred, &fattr, flags,
++              result = NFS_PROTO(inode)->write(inode, cred, &fattr,
++                                               NFS_RW_SYNC,
+                                                offset, wsize, page, &verf);
+-              nfs_write_attributes(inode, &fattr);
++              __nfs_write_attributes(inode, &fattr);
+               if (result < 0) {
+                       /* Must mark the page invalid after I/O error */
+@@ -140,7 +137,6 @@
+                       printk("NFS: short write, wsize=%u, result=%d\n",
+                       wsize, result);
+               refresh = 1;
+-              buffer  += wsize;
+               base    += wsize;
+               offset  += wsize;
+               written += wsize;
+@@ -979,7 +975,7 @@
+       }
+ #endif
+-      nfs_write_attributes(inode, resp->fattr);
++      __nfs_write_attributes(inode, resp->fattr);
+       while (!list_empty(&data->pages)) {
+               req = nfs_list_entry(data->pages.next);
+               nfs_list_remove_request(req);
+@@ -1133,7 +1129,7 @@
+       if (nfs_async_handle_jukebox(task))
+               return;
+-      nfs_write_attributes(inode, resp->fattr);
++      __nfs_write_attributes(inode, resp->fattr);
+       while (!list_empty(&data->pages)) {
+               req = nfs_list_entry(data->pages.next);
+               nfs_list_remove_request(req);
+diff -Nurb src/linux/linux.orig/include/linux/fs.h src/linux/linux/include/linux/fs.h
+--- src/linux/linux.orig/include/linux/fs.h    2004-05-31 02:06:19.000000000 -0400
++++ src/linux/linux/include/linux/fs.h 2004-05-31 02:18:03.000000000 -0400
+@@ -1500,6 +1500,10 @@
+ extern int inode_change_ok(struct inode *, struct iattr *);
+ extern int inode_setattr(struct inode *, struct iattr *);
++/* for swapping to block devices */
++void create_empty_buffers(struct page *page, kdev_t dev, unsigned long blocksize);
++void end_buffer_io_async(struct buffer_head * bh, int uptodate);
++
+ /*
+  * Common dentry functions for inclusion in the VFS
+  * or in other stackable file systems.  Some of these
+diff -Nurb src/linux/linux.orig/include/linux/nfs_fs.h src/linux/linux/include/linux/nfs_fs.h
+--- src/linux/linux.orig/include/linux/nfs_fs.h        2004-05-31 02:06:28.000000000 -0400
++++ src/linux/linux/include/linux/nfs_fs.h     2004-05-31 02:18:03.000000000 -0400
+@@ -40,8 +40,8 @@
+  */
+ #define NFS_MAX_DIRCACHE              16
+-#define NFS_MAX_FILE_IO_BUFFER_SIZE   32768
+-#define NFS_DEF_FILE_IO_BUFFER_SIZE   4096
++#define NFS_MAX_FILE_IO_BUFFER_SIZE   (8*PAGE_SIZE)
++#define NFS_DEF_FILE_IO_BUFFER_SIZE   PAGE_SIZE
+ /*
+  * The upper limit on timeouts for the exponential backoff algorithm.
+@@ -205,6 +205,8 @@
+ extern int  nfs_writepage(struct page *);
+ extern int  nfs_flush_incompatible(struct file *file, struct page *page);
+ extern int  nfs_updatepage(struct file *, struct page *, unsigned int, unsigned int);
++extern int nfs_write_attributes(struct inode *inode, struct nfs_fattr *fattr);
++
+ /*
+  * Try to write back everything synchronously (but check the
+  * return value!)
+@@ -375,6 +377,7 @@
+ #define NFSDBG_XDR            0x0020
+ #define NFSDBG_FILE           0x0040
+ #define NFSDBG_ROOT           0x0080
++#define NFSDBG_SWAP             0x0100
+ #define NFSDBG_ALL            0xFFFF
+ #ifdef __KERNEL__
+diff -Nurb src/linux/linux.orig/include/linux/slab.h src/linux/linux/include/linux/slab.h
+--- src/linux/linux.orig/include/linux/slab.h  2004-05-31 02:06:19.000000000 -0400
++++ src/linux/linux/include/linux/slab.h       2004-05-31 02:18:03.000000000 -0400
+@@ -39,6 +39,7 @@
+ #define       SLAB_HWCACHE_ALIGN      0x00002000UL    /* align objs on a h/w cache lines */
+ #define SLAB_CACHE_DMA                0x00004000UL    /* use GFP_DMA memory */
+ #define SLAB_MUST_HWCACHE_ALIGN       0x00008000UL    /* force alignment */
++#define SLAB_LOW_GFP_ORDER    0x00010000UL    /* use as low a gfp order as possible */
+ /* flags passed to a constructor func */
+ #define       SLAB_CTOR_CONSTRUCTOR   0x001UL         /* if not set, then deconstructor */
+diff -Nurb src/linux/linux.orig/include/linux/swap.h src/linux/linux/include/linux/swap.h
+--- src/linux/linux.orig/include/linux/swap.h  2004-05-31 02:06:19.000000000 -0400
++++ src/linux/linux/include/linux/swap.h       2004-05-31 02:18:03.000000000 -0400
+@@ -58,15 +58,29 @@
+ #define SWAP_MAP_MAX  0x7fff
+ #define SWAP_MAP_BAD  0x8000
++struct swap_ops {
++      int (*open)(struct file *swapf, void **data);
++      int (*release)(struct file *swapf, void *data);
++      int (*rw_page)(int rw,
++                     struct page *page, unsigned long offset, void *data);
++};
++
++struct swap_method {
++      struct swap_method *next;
++      char * name;
++      struct swap_ops *ops;
++      int use_count;
++};
++
+ /*
+  * The in-memory structure used to track swap areas.
+  */
+ struct swap_info_struct {
+       unsigned int flags;
+-      kdev_t swap_device;
++      struct file *swap_file;
++      struct swap_method *method;
++      void *data;
+       spinlock_t sdev_lock;
+-      struct dentry * swap_file;
+-      struct vfsmount *swap_vfsmnt;
+       unsigned short * swap_map;
+       unsigned int lowest_bit;
+       unsigned int highest_bit;
+@@ -141,11 +155,15 @@
+ extern int total_swap_pages;
+ extern unsigned int nr_swapfiles;
+ extern struct swap_info_struct swap_info[];
+-extern int is_swap_partition(kdev_t);
++extern int register_swap_method(char *name, struct swap_ops *ops);
++extern int unregister_swap_method(char *name);
++extern int swap_run_test(int (*test_fct)(unsigned int flags,
++                                       struct file *swap_file,
++                                       void *testdata), void *testdata);
+ extern void si_swapinfo(struct sysinfo *);
+ extern swp_entry_t get_swap_page(void);
+-extern void get_swaphandle_info(swp_entry_t, unsigned long *, kdev_t *, 
+-                                      struct inode **);
++struct swap_method *get_swaphandle_info(swp_entry_t entry,
++                                      unsigned long *offset, void **data);
+ extern int swap_duplicate(swp_entry_t);
+ extern int swap_count(struct page *);
+ extern int valid_swaphandles(swp_entry_t, unsigned long *);
+diff -Nurb src/linux/linux.orig/include/net/netswapping.h src/linux/linux/include/net/netswapping.h
+--- src/linux/linux.orig/include/net/netswapping.h     1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/include/net/netswapping.h  2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,47 @@
++#ifndef _LINUX_NETSWAPPING_H
++#define _LINUX_NETSWAPPING_H
++
++#include <linux/swap.h>
++#include <linux/init.h>
++
++/* It is a mess. Socket options are defined in asm-ARCH/socket.h */
++
++#define SO_SWAPPING 0x00100000 /* hopefully not used by anybody else */
++
++#ifdef __KERNEL__
++
++#define CTL_NETSWAP 0x00100000
++
++enum {
++      NET_SWAP_DROPPED = 1,
++      NET_SWAP_DROP_THRESHOLD = 2,
++      NET_SWAP_SOCK_COUNT = 3
++};
++
++extern unsigned int netswap_free_pages_min;
++extern int netswap_sock_count;
++extern unsigned int netswap_dropped;
++
++/* this is "#defined" and not inline because sock.h includes us, but we need
++ * the "struct sock" definition.
++ */
++#define netswap_low_memory(sk, skb)                                      \
++({                                                                       \
++      int _ret = 0;                                                      \
++                                                                         \
++      if (netswap_sock_count > 0 && /* anybody swapping via network? */  \
++          !(sk)->swapping &&    /* but we are not needed for swapping */ \
++          nr_free_pages() < netswap_free_pages_min) { /* so drop us */   \
++              printk("netswap_low_memory: "                              \
++                     "dropping skb 0x%p@0x%p\n", skb, sk);               \
++              netswap_dropped ++;                                        \
++              _ret = 1;                                                  \
++      }                                                                  \
++      _ret;                                                              \
++})
++
++extern int __init netswap_init(void);
++
++#endif
++
++#endif
+diff -Nurb src/linux/linux.orig/include/net/sock.h src/linux/linux/include/net/sock.h
+--- src/linux/linux.orig/include/net/sock.h    2004-05-31 02:07:17.000000000 -0400
++++ src/linux/linux/include/net/sock.h 2004-05-31 02:18:03.000000000 -0400
+@@ -103,6 +103,10 @@
+ #include <linux/filter.h>
+ #endif
++#ifdef CONFIG_NETSWAP
++#include <net/netswapping.h>
++#endif
++
+ #include <asm/atomic.h>
+ #include <net/dst.h>
+@@ -536,6 +540,12 @@
+                               no_check,
+                               broadcast,
+                               bsdism;
++#ifdef CONFIG_NETSWAP
++      /* Increased by SO_SWAPPING with arg != 0, decreased by
++       * SO_SWAPPING with arg 0
++       */
++      int                     swapping;
++#endif
+       unsigned char           debug;
+       unsigned char           rcvtstamp;
+       unsigned char           use_write_queue;
+@@ -1165,6 +1175,11 @@
+                       return err;     /* Toss packet */
+       }
+ #endif /* CONFIG_FILTER */
++#ifdef CONFIG_NETSWAP
++      /* an inline function defined in net/netswapping.h */
++      if (netswap_low_memory(sk, skb))
++              return -ENOMEM;
++#endif /* CONFIG_NETSWAP */
+       skb->dev = NULL;
+       skb_set_owner_r(skb, sk);
+diff -Nurb src/linux/linux.orig/kernel/ksyms.c src/linux/linux/kernel/ksyms.c
+--- src/linux/linux.orig/kernel/ksyms.c        2004-05-31 02:02:43.000000000 -0400
++++ src/linux/linux/kernel/ksyms.c     2004-05-31 02:18:03.000000000 -0400
+@@ -41,6 +41,7 @@
+ #include <linux/mm.h>
+ #include <linux/capability.h>
+ #include <linux/highuid.h>
++#include <linux/swapctl.h>
+ #include <linux/brlock.h>
+ #include <linux/fs.h>
+ #include <linux/tty.h>
+@@ -127,6 +128,11 @@
+ EXPORT_SYMBOL(kmap_prot);
+ EXPORT_SYMBOL(kmap_pte);
+ #endif
++EXPORT_SYMBOL(nr_free_pages);
++/* EXPORT_SYMBOL(freepages); */
++EXPORT_SYMBOL(register_swap_method);
++EXPORT_SYMBOL(unregister_swap_method);
++EXPORT_SYMBOL(swap_run_test);
+ /* filesystem internal functions */
+ EXPORT_SYMBOL(def_blk_fops);
+@@ -531,7 +537,7 @@
+ EXPORT_SYMBOL(make_bad_inode);
+ EXPORT_SYMBOL(is_bad_inode);
+ EXPORT_SYMBOL(event);
+-EXPORT_SYMBOL(brw_page);
++EXPORT_SYMBOL(end_buffer_io_async);
+ EXPORT_SYMBOL(__inode_dir_notify);
+ #ifdef CONFIG_UID16
+diff -Nurb src/linux/linux.orig/mm/page_io.c src/linux/linux/mm/page_io.c
+--- src/linux/linux.orig/mm/page_io.c  2003-07-04 04:12:29.000000000 -0400
++++ src/linux/linux/mm/page_io.c       2004-05-31 02:18:03.000000000 -0400
+@@ -36,11 +36,8 @@
+ static int rw_swap_page_base(int rw, swp_entry_t entry, struct page *page)
+ {
+       unsigned long offset;
+-      int zones[PAGE_SIZE/512];
+-      int zones_used;
+-      kdev_t dev = 0;
+-      int block_size;
+-      struct inode *swapf = 0;
++      struct swap_method *method;
++      void *data;
+       if (rw == READ) {
+               ClearPageUptodate(page);
+@@ -48,30 +45,11 @@
+       } else
+               kstat.pswpout++;
+-      get_swaphandle_info(entry, &offset, &dev, &swapf);
+-      if (dev) {
+-              zones[0] = offset;
+-              zones_used = 1;
+-              block_size = PAGE_SIZE;
+-      } else if (swapf) {
+-              int i, j;
+-              unsigned int block = offset
+-                      << (PAGE_SHIFT - swapf->i_sb->s_blocksize_bits);
+-
+-              block_size = swapf->i_sb->s_blocksize;
+-              for (i=0, j=0; j< PAGE_SIZE ; i++, j += block_size)
+-                      if (!(zones[i] = bmap(swapf,block++))) {
+-                              printk("rw_swap_page: bad swap file\n");
+-                              return 0;
+-                      }
+-              zones_used = i;
+-              dev = swapf->i_dev;
+-      } else {
++      method = get_swaphandle_info(entry, &offset, &data);
++      if (!method || !method->ops->rw_page(rw, page, offset, data)) {
+               return 0;
+       }
+-      /* block_size == PAGE_SIZE/zones_used */
+-      brw_page(rw, page, dev, zones, block_size);
+       return 1;
+ }
+diff -Nurb src/linux/linux.orig/mm/slab.c src/linux/linux/mm/slab.c
+--- src/linux/linux.orig/mm/slab.c     2003-07-04 04:12:29.000000000 -0400
++++ src/linux/linux/mm/slab.c  2004-05-31 02:18:03.000000000 -0400
+@@ -111,10 +111,12 @@
+ # define CREATE_MASK  (SLAB_DEBUG_INITIAL | SLAB_RED_ZONE | \
+                        SLAB_POISON | SLAB_HWCACHE_ALIGN | \
+                        SLAB_NO_REAP | SLAB_CACHE_DMA | \
+-                       SLAB_MUST_HWCACHE_ALIGN)
++                       SLAB_MUST_HWCACHE_ALIGN | \
++                       SLAB_LOW_GFP_ORDER)
+ #else
+ # define CREATE_MASK  (SLAB_HWCACHE_ALIGN | SLAB_NO_REAP | \
+-                       SLAB_CACHE_DMA | SLAB_MUST_HWCACHE_ALIGN)
++                       SLAB_CACHE_DMA | SLAB_MUST_HWCACHE_ALIGN | \
++                       SLAB_LOW_GFP_ORDER)
+ #endif
+ /*
+@@ -247,8 +249,13 @@
+ };
+ /* internal c_flags */
+-#define       CFLGS_OFF_SLAB  0x010000UL      /* slab management in own cache */
+-#define       CFLGS_OPTIMIZE  0x020000UL      /* optimized slab lookup */
++#define       CFLGS_OFF_SLAB  0x020000UL      /* slab management in own cache */
++#define       CFLGS_OPTIMIZE  0x040000UL      /* optimized slab lookup */
++#define CFLGS_MASK (CFLGS_OFF_SLAB | CFLGS_OPTIMIZE)
++
++#if (CFLGS_MASK & CREATE_MASK)
++# error BUG: internal and external SLAB flags overlap
++#endif
+ /* c_dflags (dynamic flags). Need to hold the spinlock to access this member */
+ #define       DFLGS_GROWN     0x000001UL      /* don't reap a recently grown */
+@@ -452,7 +459,12 @@
+               snprintf(name, sizeof(name), "size-%Zd",sizes->cs_size);
+               if (!(sizes->cs_cachep =
+                       kmem_cache_create(name, sizes->cs_size,
+-                                      0, SLAB_HWCACHE_ALIGN, NULL, NULL))) {
++                                        0,
++#if CONFIG_NETSWAP
++                                        SLAB_LOW_GFP_ORDER|  /* sorry */
++#endif
++                                        SLAB_HWCACHE_ALIGN,
++                                        NULL, NULL))) {
+                       BUG();
+               }
+@@ -731,6 +743,8 @@
+                       break;
+               if (!cachep->num)
+                       goto next;
++              if (cachep->gfporder == 0 && (flags & SLAB_LOW_GFP_ORDER))
++                      break;
+               if (flags & CFLGS_OFF_SLAB && cachep->num > offslab_limit) {
+                       /* Oops, this num of objs will cause problems. */
+                       cachep->gfporder--;
+diff -Nurb src/linux/linux.orig/mm/swapfile.c src/linux/linux/mm/swapfile.c
+--- src/linux/linux.orig/mm/swapfile.c 2003-07-04 04:12:29.000000000 -0400
++++ src/linux/linux/mm/swapfile.c      2004-05-31 02:18:03.000000000 -0400
+@@ -11,12 +11,17 @@
+ #include <linux/swap.h>
+ #include <linux/swapctl.h>
+ #include <linux/blkdev.h> /* for blk_size */
++#include <linux/file.h>
+ #include <linux/vmalloc.h>
+ #include <linux/pagemap.h>
+ #include <linux/shm.h>
+ #include <asm/pgtable.h>
++#ifdef CONFIG_KMOD
++#include <linux/kmod.h>
++#endif
++
+ spinlock_t swaplock = SPIN_LOCK_UNLOCKED;
+ unsigned int nr_swapfiles;
+ int total_swap_pages;
+@@ -31,8 +36,78 @@
+ struct swap_info_struct swap_info[MAX_SWAPFILES];
++static struct swap_method *swap_methods = NULL;
++
+ #define SWAPFILE_CLUSTER 256
++int register_swap_method(char *name, struct swap_ops *ops)
++{
++      struct swap_method *pos;
++      struct swap_method *new;
++      int result = 0;
++
++      lock_kernel();
++
++      for (pos = swap_methods; pos; pos = pos->next) {
++              if (strcmp(pos->name, name) == 0) {
++                      printk(KERN_ERR "register_swap_method: "
++                             "method %s already registered\n", name);
++                      result = -EBUSY;
++                      goto out;
++              }
++      }
++
++      if (!(new = kmalloc(sizeof(*new), GFP_KERNEL))) {
++              printk(KERN_ERR "register_swap_method: "
++                     "no memory for new method \"%s\"\n", name);
++              result = -ENOMEM;
++              goto out;
++      }
++
++      new->name      = name;
++      new->ops       = ops;
++      new->use_count = 0;
++
++      /* ok, insert at top of list */
++      printk("register_swap_method: method %s\n", name);
++      new->next    = swap_methods;
++      swap_methods = new;
++ out:
++      unlock_kernel();
++      return result;
++}
++
++int unregister_swap_method(char *name)
++{
++      struct swap_method **method, *next;
++      int result = 0;
++
++      lock_kernel();
++
++      for (method = &swap_methods; *method; method = &(*method)->next) {
++              if (strcmp((*method)->name, name) == 0) {
++                      if ((*method)->use_count > 0) {
++                              printk(KERN_ERR "unregister_swap_method: "
++                                     "method \"%s\" is in use\n", name);
++                              result = -EBUSY;
++                              goto out;
++                      }
++
++                      next = (*method)->next;
++                      kfree(*method);
++                      *method = next;                 
++                      printk("unregister_swap_method: method %s\n", name);
++                      goto out;
++              }
++      }
++      /* not found */
++      printk("unregister_swap_method: no such method %s\n", name);
++      result = -ENOENT;
++ out:
++      unlock_kernel();
++      return result;
++}
++
+ static inline int scan_swap_map(struct swap_info_struct *si)
+ {
+       unsigned long offset;
+@@ -711,13 +786,14 @@
+       struct nameidata nd;
+       int i, type, prev;
+       int err;
++      struct file *swap_file;
+       
+       if (!capable(CAP_SYS_ADMIN))
+               return -EPERM;
+       err = user_path_walk(specialfile, &nd);
+       if (err)
+-              goto out;
++              return err;
+       lock_kernel();
+       prev = -1;
+@@ -725,15 +801,20 @@
+       for (type = swap_list.head; type >= 0; type = swap_info[type].next) {
+               p = swap_info + type;
+               if ((p->flags & SWP_WRITEOK) == SWP_WRITEOK) {
+-                      if (p->swap_file == nd.dentry)
++                      if (p->swap_file &&
++                          p->swap_file->f_dentry == nd.dentry)
+                         break;
+               }
+               prev = type;
+       }
+       err = -EINVAL;
++      /* p->swap_file contains all needed info, no need to keep nd, so
++       * release it now.
++       */
++      path_release(&nd);
+       if (type < 0) {
+               swap_list_unlock();
+-              goto out_dput;
++              goto out;
+       }
+       if (prev < 0) {
+@@ -767,32 +848,30 @@
+               total_swap_pages += p->pages;
+               p->flags = SWP_WRITEOK;
+               swap_list_unlock();
+-              goto out_dput;
++              goto out;
+       }
+-      if (p->swap_device)
+-              blkdev_put(p->swap_file->d_inode->i_bdev, BDEV_SWAP);
+-      path_release(&nd);
++      if (p->method->ops->release)
++              p->method->ops->release(p->swap_file, p->data);
+       swap_list_lock();
+       swap_device_lock(p);
+-      nd.mnt = p->swap_vfsmnt;
+-      nd.dentry = p->swap_file;
+-      p->swap_vfsmnt = NULL;
++      p->method->use_count --;
++      p->method = NULL;
++      p->data   = NULL;
++      swap_file = p->swap_file;
+       p->swap_file = NULL;
+-      p->swap_device = 0;
+       p->max = 0;
+       swap_map = p->swap_map;
+       p->swap_map = NULL;
+       p->flags = 0;
+       swap_device_unlock(p);
+       swap_list_unlock();
++      filp_close(swap_file, NULL);
+       vfree(swap_map);
+       err = 0;
+-out_dput:
+-      unlock_kernel();
+-      path_release(&nd);
+ out:
++      unlock_kernel();
+       return err;
+ }
+@@ -805,18 +884,17 @@
+       if (!page)
+               return -ENOMEM;
+-      len += sprintf(buf, "Filename\t\t\tType\t\tSize\tUsed\tPriority\n");
++      len += sprintf(buf, "%-32s%-16s%-8s%-8sPriority\n",
++                     "Filename", "Type", "Size", "Used");
+       for (i = 0 ; i < nr_swapfiles ; i++, ptr++) {
+               if ((ptr->flags & SWP_USED) && ptr->swap_map) {
+-                      char * path = d_path(ptr->swap_file, ptr->swap_vfsmnt,
++                      char * path = d_path(ptr->swap_file->f_dentry,
++                                           ptr->swap_file->f_vfsmnt,
+                                               page, PAGE_SIZE);
+                       len += sprintf(buf + len, "%-31s ", path);
+-                      if (!ptr->swap_device)
+-                              len += sprintf(buf + len, "file\t\t");
+-                      else
+-                              len += sprintf(buf + len, "partition\t");
++                      len += sprintf(buf + len, "%-15s ", ptr->method->name);
+                       usedswap = 0;
+                       for (j = 0; j < ptr->max; ++j)
+@@ -827,7 +905,7 @@
+                                       default:
+                                               usedswap++;
+                               }
+-                      len += sprintf(buf + len, "%d\t%d\t%d\n", ptr->pages << (PAGE_SHIFT - 10), 
++                      len += sprintf(buf + len, "%-8d%-8d%d\n", ptr->pages << (PAGE_SHIFT - 10), 
+                               usedswap << (PAGE_SHIFT - 10), ptr->prio);
+               }
+       }
+@@ -835,18 +913,55 @@
+       return len;
+ }
+-int is_swap_partition(kdev_t dev) {
++/* apply a test function to all active swap objects. E.g. for checking
++ * whether a partition is used for swapping
++ */
++int swap_run_test(int (*test_fct)(unsigned int flags,
++                                struct file * swap_file,
++                                void *testdata), void *testdata)
++{
+       struct swap_info_struct *ptr = swap_info;
+       int i;
+       for (i = 0 ; i < nr_swapfiles ; i++, ptr++) {
+-              if (ptr->flags & SWP_USED)
+-                      if (ptr->swap_device == dev)
++              if (ptr->swap_file && 
++                  test_fct(ptr->flags, ptr->swap_file, testdata))
+                               return 1;
+       }
+       return 0;
+ }
++/* Walk through the list of known swap method until somebody wants to
++ * handle this file. Pick the first one which claims to be able to
++ * swap to this kind of file.
++ *
++ * return value: < 0: error, 0: not found, > 0: swapfilesize
++ */
++int find_swap_method(struct file *swap_file,
++                   struct swap_info_struct *p)
++{
++      int swapfilesize = 0;
++      struct swap_method *method;
++
++      p->method = NULL;
++      for (method = swap_methods; method; method = method->next) {
++              swapfilesize = method->ops->open(swap_file, &p->data);
++              if (swapfilesize == 0) {
++                      continue;
++              }
++              if (swapfilesize > 0) {
++                      p->method = method;
++                      p->method->use_count ++;
++                      p->swap_file = swap_file;
++                      break;
++              }
++              if (swapfilesize < 0) {
++                      break;
++              }
++      }
++      return swapfilesize;
++}
++
+ /*
+  * Written 01/25/92 by Simmule Turner, heavily changed by Linus.
+  *
+@@ -855,8 +970,6 @@
+ asmlinkage long sys_swapon(const char * specialfile, int swap_flags)
+ {
+       struct swap_info_struct * p;
+-      struct nameidata nd;
+-      struct inode * swap_inode;
+       unsigned int type;
+       int i, j, prev;
+       int error;
+@@ -866,8 +979,9 @@
+       int nr_good_pages = 0;
+       unsigned long maxpages = 1;
+       int swapfilesize;
+-      struct block_device *bdev = NULL;
+       unsigned short *swap_map;
++      char * tmp_specialfile;
++      struct file *swap_file;
+       
+       if (!capable(CAP_SYS_ADMIN))
+               return -EPERM;
+@@ -886,8 +1000,7 @@
+               nr_swapfiles = type+1;
+       p->flags = SWP_USED;
+       p->swap_file = NULL;
+-      p->swap_vfsmnt = NULL;
+-      p->swap_device = 0;
++      p->method = NULL;
+       p->swap_map = NULL;
+       p->lowest_bit = 0;
+       p->highest_bit = 0;
+@@ -901,53 +1014,56 @@
+               p->prio = --least_priority;
+       }
+       swap_list_unlock();
+-      error = user_path_walk(specialfile, &nd);
+-      if (error)
++
++      /* Open the swap using filp_open. Bail out on any errors. */
++      tmp_specialfile = getname(specialfile);
++      if (IS_ERR(tmp_specialfile)) {
++              error = PTR_ERR(tmp_specialfile);
+               goto bad_swap_2;
++      }
++      p->swap_file = filp_open(tmp_specialfile, O_RDWR, 0600);
++      putname(tmp_specialfile);
++      if (IS_ERR(p->swap_file)) {
++              error = PTR_ERR(p->swap_file);
++              goto bad_swap_1;
++      }
+-      p->swap_file = nd.dentry;
+-      p->swap_vfsmnt = nd.mnt;
+-      swap_inode = nd.dentry->d_inode;
+       error = -EINVAL;
+-      if (S_ISBLK(swap_inode->i_mode)) {
+-              kdev_t dev = swap_inode->i_rdev;
+-              struct block_device_operations *bdops;
+-              devfs_handle_t de;
+-
+-              p->swap_device = dev;
+-              set_blocksize(dev, PAGE_SIZE);
+-              
+-              bd_acquire(swap_inode);
+-              bdev = swap_inode->i_bdev;
+-              de = devfs_get_handle_from_inode(swap_inode);
+-              bdops = devfs_get_ops(de);  /*  Increments module use count  */
+-              if (bdops) bdev->bd_op = bdops;
+-
+-              error = blkdev_get(bdev, FMODE_READ|FMODE_WRITE, 0, BDEV_SWAP);
+-              devfs_put_ops(de);/*Decrement module use count now we're safe*/
+-              if (error)
+-                      goto bad_swap_2;
+-              set_blocksize(dev, PAGE_SIZE);
+-              error = -ENODEV;
+-              if (!dev || (blk_size[MAJOR(dev)] &&
+-                   !blk_size[MAJOR(dev)][MINOR(dev)]))
+-                      goto bad_swap;
+-              swapfilesize = 0;
+-              if (blk_size[MAJOR(dev)])
+-                      swapfilesize = blk_size[MAJOR(dev)][MINOR(dev)]
+-                              >> (PAGE_SHIFT - 10);
+-      } else if (S_ISREG(swap_inode->i_mode))
+-              swapfilesize = swap_inode->i_size >> PAGE_SHIFT;
+-      else
+-              goto bad_swap;
++      swapfilesize = find_swap_method(p->swap_file, p);
++      if (swapfilesize < 0) {
++              error = swapfilesize;
++              goto bad_swap_1;
++      }
++#ifdef CONFIG_KMOD
++      if (swapfilesize == 0) {
++              (void)request_module("swapfile-mod");
++
++              swapfilesize = find_swap_method(p->swap_file, p);
++              if (swapfilesize < 0) {
++                      error = swapfilesize;
++                      goto bad_swap_1;
++              }
++      }
++#endif                
++      if (swapfilesize == 0) {
++              printk("Don't know how to swap to this kind of file\n");
++              goto bad_swap_1; /* free swap map */
++      }
++  
++      /* After this point, the swap-file has been opened by the swap
++       * method. We must make sure to use the bad_swap label for any
++       * errors.
++       */
+       error = -EBUSY;
+       for (i = 0 ; i < nr_swapfiles ; i++) {
+               struct swap_info_struct *q = &swap_info[i];
+               if (i == type || !q->swap_file)
+                       continue;
+-              if (swap_inode->i_mapping == q->swap_file->d_inode->i_mapping)
++              if (p->swap_file->f_dentry->d_inode->i_mapping
++                  ==
++                  q->swap_file->f_dentry->d_inode->i_mapping)
+                       goto bad_swap;
+       }
+@@ -1083,17 +1199,27 @@
+       swap_list_unlock();
+       error = 0;
+       goto out;
++
+ bad_swap:
+-      if (bdev)
+-              blkdev_put(bdev, BDEV_SWAP);
++      if (p->method->ops->release)
++              p->method->ops->release(p->swap_file, p->data);
++      swap_list_lock();
++      p->method->use_count --;
++      p->method = NULL;
++      p->data = NULL;
++      swap_list_unlock();
++
++bad_swap_1:
++      swap_list_lock();
++      swap_file = p->swap_file;
++      p->swap_file = NULL;
++      swap_list_unlock();
++      filp_close(swap_file, NULL);
++      
+ bad_swap_2:
++
+       swap_list_lock();
+       swap_map = p->swap_map;
+-      nd.mnt = p->swap_vfsmnt;
+-      nd.dentry = p->swap_file;
+-      p->swap_device = 0;
+-      p->swap_file = NULL;
+-      p->swap_vfsmnt = NULL;
+       p->swap_map = NULL;
+       p->flags = 0;
+       if (!(swap_flags & SWAP_FLAG_PREFER))
+@@ -1101,7 +1227,7 @@
+       swap_list_unlock();
+       if (swap_map)
+               vfree(swap_map);
+-      path_release(&nd);
++
+ out:
+       if (swap_header)
+               free_page((long) swap_header);
+@@ -1217,8 +1343,8 @@
+ /*
+  * Prior swap_duplicate protects against swap device deletion.
+  */
+-void get_swaphandle_info(swp_entry_t entry, unsigned long *offset, 
+-                      kdev_t *dev, struct inode **swapf)
++struct swap_method *get_swaphandle_info(swp_entry_t entry,
++                                      unsigned long *offset, void **data)
+ {
+       unsigned long type;
+       struct swap_info_struct *p;
+@@ -1226,32 +1352,26 @@
+       type = SWP_TYPE(entry);
+       if (type >= nr_swapfiles) {
+               printk(KERN_ERR "rw_swap_page: %s%08lx\n", Bad_file, entry.val);
+-              return;
++              return NULL;
+       }
+       p = &swap_info[type];
+       *offset = SWP_OFFSET(entry);
+       if (*offset >= p->max && *offset != 0) {
+               printk(KERN_ERR "rw_swap_page: %s%08lx\n", Bad_offset, entry.val);
+-              return;
++              return NULL;
+       }
+       if (p->swap_map && !p->swap_map[*offset]) {
+               printk(KERN_ERR "rw_swap_page: %s%08lx\n", Unused_offset, entry.val);
+-              return;
++              return NULL;
+       }
+       if (!(p->flags & SWP_USED)) {
+               printk(KERN_ERR "rw_swap_page: %s%08lx\n", Unused_file, entry.val);
+-              return;
++              return NULL;
+       }
+-      if (p->swap_device) {
+-              *dev = p->swap_device;
+-      } else if (p->swap_file) {
+-              *swapf = p->swap_file->d_inode;
+-      } else {
+-              printk(KERN_ERR "rw_swap_page: no swap file or device\n");
+-      }
+-      return;
++      *data = p->data;
++      return p->method;
+ }
+ /*
+diff -Nurb src/linux/linux.orig/net/Config.in src/linux/linux/net/Config.in
+--- src/linux/linux.orig/net/Config.in 2003-07-04 04:12:29.000000000 -0400
++++ src/linux/linux/net/Config.in      2004-05-31 02:18:03.000000000 -0400
+@@ -16,6 +16,9 @@
+ fi
+ bool 'Socket Filtering'  CONFIG_FILTER
+ tristate 'Unix domain sockets' CONFIG_UNIX
++if [ "$CONFIG_EXPERIMENTAL" = "y" ]; then
++    bool 'Swapping via network sockets (EXPERIMENTAL)' CONFIG_NETSWAP
++fi
+ bool 'TCP/IP networking' CONFIG_INET
+ if [ "$CONFIG_INET" = "y" ]; then
+    source net/ipv4/Config.in
+diff -Nurb src/linux/linux.orig/net/Makefile src/linux/linux/net/Makefile
+--- src/linux/linux.orig/net/Makefile  2003-07-04 04:12:29.000000000 -0400
++++ src/linux/linux/net/Makefile       2004-05-31 02:18:03.000000000 -0400
+@@ -51,6 +51,7 @@
+ ifeq ($(CONFIG_NET),y)
+ obj-$(CONFIG_MODULES)         += netsyms.o
+ obj-$(CONFIG_SYSCTL)          += sysctl_net.o
++obj-$(CONFIG_NETSWAP)           += netswapping.o
+ endif
+ include $(TOPDIR)/Rules.make
+diff -Nurb src/linux/linux.orig/net/core/sock.c src/linux/linux/net/core/sock.c
+--- src/linux/linux.orig/net/core/sock.c       2003-10-14 04:09:32.000000000 -0400
++++ src/linux/linux/net/core/sock.c    2004-05-31 02:18:03.000000000 -0400
+@@ -402,6 +402,21 @@
+                       ret = -ENONET;
+                       break;
+ #endif
++#ifdef CONFIG_NETSWAP
++              case SO_SWAPPING:
++                      if (valbool) {
++                              if (!sk->swapping) {
++                                      netswap_sock_count ++;
++                              }
++                              sk->swapping ++;
++                      } else if (sk->swapping > 0) {
++                              sk->swapping --;
++                              if (!sk->swapping) {
++                                      netswap_sock_count --;
++                              }
++                      }
++                      break;
++#endif
+               /* We implement the SO_SNDLOWAT etc to
+                  not be settable (1003.1g 5.3) */
+               default:
+@@ -552,6 +567,12 @@
+                       goto lenout;
+               }
++#ifdef CONFIG_NETSWAP
++              case SO_SWAPPING:
++                      v.val = sk->swapping;
++                      break;
++#endif
++
+               /* Dubious BSD thing... Probably nobody even uses it, but
+                * the UNIX standard wants it for whatever reason... -DaveM
+                */
+diff -Nurb src/linux/linux.orig/net/ipv4/tcp_ipv4.c src/linux/linux/net/ipv4/tcp_ipv4.c
+--- src/linux/linux.orig/net/ipv4/tcp_ipv4.c   2003-10-14 04:09:33.000000000 -0400
++++ src/linux/linux/net/ipv4/tcp_ipv4.c        2004-05-31 02:18:03.000000000 -0400
+@@ -1657,6 +1657,12 @@
+       if (filter && sk_filter(skb, filter))
+               goto discard;
+ #endif /* CONFIG_FILTER */
++#ifdef CONFIG_NETSWAP
++      /* tcp doesn't use sock_queue_rcv_skb() ... */
++      /* an inline function defined in net/netswapping.h */
++      if (netswap_low_memory(sk, skb))
++              goto discard;
++#endif /* CONFIG_NETSWAP */
+       IP_INC_STATS_BH(IpInDelivers);
+diff -Nurb src/linux/linux.orig/net/ipv6/tcp_ipv6.c src/linux/linux/net/ipv6/tcp_ipv6.c
+--- src/linux/linux.orig/net/ipv6/tcp_ipv6.c   2003-10-14 04:09:34.000000000 -0400
++++ src/linux/linux/net/ipv6/tcp_ipv6.c        2004-05-31 02:18:03.000000000 -0400
+@@ -1424,6 +1424,12 @@
+       if (filter && sk_filter(skb, filter))
+               goto discard;
+ #endif /* CONFIG_FILTER */
++#ifdef CONFIG_NETSWAP
++      /* tcp doesn't use sock_queue_rcv_skb() ... */
++      /* an inline function defined in net/netswapping.h */
++      if (netswap_low_memory(sk, skb))
++              goto discard;
++#endif /* CONFIG_NETSWAP */
+       /*
+        *      socket locking is here for SMP purposes as backlog rcv
+diff -Nurb src/linux/linux.orig/net/netswapping.c src/linux/linux/net/netswapping.c
+--- src/linux/linux.orig/net/netswapping.c     1969-12-31 19:00:00.000000000 -0500
++++ src/linux/linux/net/netswapping.c  2004-05-31 02:18:03.000000000 -0400
+@@ -0,0 +1,76 @@
++/*
++ * linux/net/swapping.c
++ *
++ * Support paging over network connections (inet only)
++ *
++ * (c) 2000 Claus-Justus Heine <heine@instmath.rwth-aachen.de>
++ */
++
++#include <linux/slab.h>
++#include <linux/swap.h>
++#include <linux/swapctl.h>
++#include <linux/skbuff.h>
++#include <linux/module.h>
++#include <linux/sysctl.h>
++#include <linux/init.h>
++#include <net/netswapping.h>
++#include <net/sock.h>
++#include <asm/uaccess.h>
++
++unsigned int netswap_dropped; /* statistics */
++unsigned int netswap_free_pages_min;
++int netswap_sock_count;   /* how many sockets have swapping option set */
++
++#ifdef CONFIG_SYSCTL
++
++static ctl_table netswap_table[] = {
++      {NET_SWAP_DROPPED, "dropped",
++       &netswap_dropped, sizeof(int), 0644, NULL, &proc_dointvec },
++      {NET_SWAP_DROP_THRESHOLD, "threshold",
++       &netswap_free_pages_min, sizeof(int), 0644, NULL, &proc_dointvec },
++      {NET_SWAP_SOCK_COUNT, "sock_count",
++       &netswap_sock_count, sizeof(int), 0444, NULL, &proc_dointvec },
++      {0},
++};
++
++static struct ctl_table_header *netswap_sysctl_header;
++
++static ctl_table netswap_net_table[] = {
++      {CTL_NETSWAP, "swapping", NULL, 0, 0555, netswap_table},
++      {0}
++};
++
++static ctl_table netswap_root_table[] = {
++      {CTL_NET, "net", NULL, 0, 0555, netswap_net_table},
++      {0}
++};
++
++#endif
++
++int __init netswap_init(void)
++{
++      /* drop packets when below this threshold */
++      netswap_free_pages_min = 32 /* freepages.min */;
++#ifdef CONFIG_SYSCTL
++      netswap_sysctl_header = register_sysctl_table(netswap_root_table, 0);
++#endif
++      return 0;
++}
++
++void __exit netswap_exit(void)
++{
++#ifdef CONFIG_SYSCTL
++      unregister_sysctl_table(netswap_sysctl_header);
++#endif
++}
++
++/* linux/init.h -- VERY nice :-)
++ *
++ * On the other hand, we have no control over the order the initcalls
++ * are performed ...
++ *
++ * Actually, we are not compiled as module ...
++ */
++
++module_init(netswap_init)
++module_exit(netswap_exit)
+diff -Nurb src/linux/linux.orig/net/netsyms.c src/linux/linux/net/netsyms.c
+--- src/linux/linux.orig/net/netsyms.c 2004-05-31 02:02:49.000000000 -0400
++++ src/linux/linux/net/netsyms.c      2004-05-31 02:18:03.000000000 -0400
+@@ -601,4 +601,10 @@
+ EXPORT_SYMBOL(wireless_send_event);
+ #endif /* CONFIG_NET_RADIO || CONFIG_NET_PCMCIA_RADIO */
++#ifdef CONFIG_NETSWAP
++EXPORT_SYMBOL(netswap_sock_count);
++EXPORT_SYMBOL(netswap_free_pages_min);
++EXPORT_SYMBOL(netswap_dropped);
++#endif
++
+ #endif  /* CONFIG_NET */
+diff -Nurb src/linux/linux.orig/net/packet/af_packet.c src/linux/linux/net/packet/af_packet.c
+--- src/linux/linux.orig/net/packet/af_packet.c        2003-10-14 04:09:35.000000000 -0400
++++ src/linux/linux/net/packet/af_packet.c     2004-05-31 02:18:03.000000000 -0400
+@@ -449,6 +449,12 @@
+                       snaplen = res;
+       }
+ #endif /* CONFIG_FILTER */
++#ifdef CONFIG_NETSWAP
++      /* packet doesn't use sock_queue_rcv_skb() ... */
++      /* an inline function defined in net/netswapping.h */
++      if (netswap_low_memory(sk, skb))
++              goto drop_n_restore;
++#endif /* CONFIG_NETSWAP */
+       if (atomic_read(&sk->rmem_alloc) + skb->truesize >= (unsigned)sk->rcvbuf)
+               goto drop_n_acct;
+@@ -496,7 +502,7 @@
+       po->stats.tp_drops++;
+       spin_unlock(&sk->receive_queue.lock);
+-#ifdef CONFIG_FILTER
++#if defined(CONFIG_FILTER) || defined(CONFIG_NETSWAP)
+ drop_n_restore:
+ #endif
+       if (skb_head != skb->data && skb_shared(skb)) {
+@@ -557,6 +563,12 @@
+                       snaplen = res;
+       }
+ #endif
++#ifdef CONFIG_NETSWAP
++      /* packet doesn't use sock_queue_rcv_skb() ... */
++      /* an inline function defined in net/netswapping.h */
++      if (netswap_low_memory(sk, skb))
++              goto drop_n_restore;
++#endif /* CONFIG_NETSWAP */
+       if (sk->type == SOCK_DGRAM) {
+               macoff = netoff = TPACKET_ALIGN(TPACKET_HDRLEN) + 16;
+diff -Nurb src/linux/linux.orig/net/sunrpc/sched.c src/linux/linux/net/sunrpc/sched.c
+--- src/linux/linux.orig/net/sunrpc/sched.c    2003-07-04 04:12:33.000000000 -0400
++++ src/linux/linux/net/sunrpc/sched.c 2004-05-31 02:18:03.000000000 -0400
+@@ -79,10 +79,11 @@
+  */
+ static spinlock_t rpc_sched_lock = SPIN_LOCK_UNLOCKED;
++#if CONFIG_SWAP_VIA_NFS || CONFIG_SWAP_VIA_NFS_MODULE
+ /*
+  * This is the last-ditch buffer for NFS swap requests
+  */
+-static u32                    swap_buffer[PAGE_SIZE >> 2];
++static u32                    swap_buffer[2*PAGE_SIZE >> 2];
+ static long                   swap_buffer_used;
+ /*
+@@ -96,6 +97,7 @@
+ {
+       clear_bit(1, &swap_buffer_used);
+ }
++#endif
+ /*
+  * Disable the timer for a given RPC task. Should be called with
+@@ -501,6 +503,7 @@
+ __rpc_execute(struct rpc_task *task)
+ {
+       int             status = 0;
++      unsigned long alloc_flag = current->flags & PF_MEMALLOC;
+       dprintk("RPC: %4d rpc_execute flgs %x\n",
+                               task->tk_pid, task->tk_flags);
+@@ -510,6 +513,13 @@
+               return 0;
+       }
++      if (task->tk_flags & RPC_TASK_SWAPPER) {
++              if (!current->flags & PF_MEMALLOC) {
++                      dprintk("__rpc_execute: Setting PF_MEMALLOC\n");
++              }
++              current->flags |= PF_MEMALLOC;
++      }
++
+  restarted:
+       while (1) {
+               /*
+@@ -554,7 +564,8 @@
+                       rpc_set_sleeping(task);
+                       if (RPC_IS_ASYNC(task)) {
+                               spin_unlock_bh(&rpc_queue_lock);
+-                              return 0;
++                              status = 0;
++                              goto out;
+                       }
+               }
+               spin_unlock_bh(&rpc_queue_lock);
+@@ -563,7 +574,12 @@
+                       /* sync task: sleep here */
+                       dprintk("RPC: %4d sync task going to sleep\n",
+                                                       task->tk_pid);
+-                      if (current->pid == rpciod_pid)
++                      /* it's ok to wait for rpciod when swapping,
++                       * because this means it needed memory and is
++                       * doing the swap-out itself.
++                       */
++                      if (current->pid == rpciod_pid &&
++                          !(task->tk_flags & RPC_TASK_SWAPPER))
+                               printk(KERN_ERR "RPC: rpciod waiting on sync task!\n");
+                       __wait_event(task->tk_wait, !RPC_IS_SLEEPING(task));
+@@ -608,6 +624,10 @@
+       /* Release all resources associated with the task */
+       rpc_release_task(task);
++ out:
++      if (!alloc_flag) {
++              current->flags &= ~PF_MEMALLOC;
++      }       
+       return status;
+ }
+@@ -699,10 +719,16 @@
+ {
+       u32     *buffer;
+       int     gfp;
++      unsigned long alloc_flag = current->flags & PF_MEMALLOC;
++      void    *ret = NULL;
+-      if (flags & RPC_TASK_SWAPPER)
++      if (flags & RPC_TASK_SWAPPER) {
+               gfp = GFP_ATOMIC;
+-      else if (flags & RPC_TASK_ASYNC)
++              if (!(current->flags & PF_MEMALLOC)) {
++                      dprintk("rpc_allocate: Setting PF_MEMALLOC\n");
++              }
++              current->flags |= PF_MEMALLOC;
++      } else if (flags & RPC_TASK_ASYNC)
+               gfp = GFP_RPC;
+       else
+               gfp = GFP_KERNEL;
+@@ -710,29 +736,44 @@
+       do {
+               if ((buffer = (u32 *) kmalloc(size, gfp)) != NULL) {
+                       dprintk("RPC:      allocated buffer %p\n", buffer);
+-                      return buffer;
++                      ret = buffer;
++                      goto out;
+               }
++#if CONFIG_SWAP_VIA_NFS || CONFIG_SWAP_VIA_NFS_MODULE
+               if ((flags & RPC_TASK_SWAPPER) && size <= sizeof(swap_buffer)
+                   && rpc_lock_swapbuf()) {
+                       dprintk("RPC:      used last-ditch swap buffer\n");
+-                      return swap_buffer;
++                      ret = swap_buffer;
++                      goto out;
++#endif
++              }
++              if (flags & RPC_TASK_ASYNC) {
++                      ret = NULL;
++                      goto out;
+               }
+-              if (flags & RPC_TASK_ASYNC)
+-                      return NULL;
+               yield();
+       } while (!signalled());
+-      return NULL;
++ out:
++      if (!alloc_flag) {
++              current->flags &= ~PF_MEMALLOC;
++      }
++      return ret;
+ }
+ void
+ rpc_free(void *buffer)
+ {
++#if CONFIG_SWAP_VIA_NFS || CONFIG_SWAP_VIA_NFS_MODULE
+       if (buffer != swap_buffer) {
++#endif
+               kfree(buffer);
+               return;
++#if CONFIG_SWAP_VIA_NFS || CONFIG_SWAP_VIA_NFS_MODULE
+       }
+       rpc_unlock_swapbuf();
++      printk("RPC:      Released swap buffer\n");
++#endif
+ }
+ /*
+diff -Nurb src/linux/linux.orig/net/sunrpc/xprt.c src/linux/linux/net/sunrpc/xprt.c
+--- src/linux/linux.orig/net/sunrpc/xprt.c     2003-07-04 04:12:33.000000000 -0400
++++ src/linux/linux/net/sunrpc/xprt.c  2004-05-31 02:18:03.000000000 -0400
+@@ -139,7 +139,7 @@
+ __xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
+ {
+       if (!xprt->snd_task) {
+-              if (xprt->nocong || __xprt_get_cong(xprt, task))
++              if (__xprt_get_cong(xprt, task))
+                       xprt->snd_task = task;
+       }
+       if (xprt->snd_task != task) {
+@@ -179,7 +179,7 @@
+               if (!task)
+                       return;
+       }
+-      if (xprt->nocong || __xprt_get_cong(xprt, task))
++      if (__xprt_get_cong(xprt, task))
+               xprt->snd_task = task;
+ }
+@@ -276,6 +276,9 @@
+ {
+       struct rpc_rqst *req = task->tk_rqstp;
++      if (xprt->nocong || RPC_IS_SWAPPER(task))
++              return 1;
++
+       if (req->rq_cong)
+               return 1;
+       dprintk("RPC: %4d xprt_cwnd_limited cong = %ld cwnd = %ld\n",